d0fa34d0d40bc9a3e747808d90542db9b8f899fa
[claws.git] / src / codeconv.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include <glib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <stdlib.h>
28
29 #if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
30 #  include <wchar.h>
31 #  include <wctype.h>
32 #endif
33
34 #if HAVE_LOCALE_H
35 #  include <locale.h>
36 #endif
37
38 #if HAVE_LIBJCONV
39 #  include <jconv.h>
40 #endif
41
42 #include <kcc.h>
43
44 #include "intl.h"
45 #include "codeconv.h"
46 #include "unmime.h"
47 #include "base64.h"
48 #include "utils.h"
49 #include "prefs_common.h"
50
51 #define iskanji(c) \
52         (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xfe)
53 #define iseucss(c) \
54         (((c) & 0xff) == 0x8e || ((c) & 0xff) == 0x8f)
55 #define isunprintablekanji(c) \
56         (((c) & 0xff) >= 0xa9 && ((c) & 0xff) <= 0xaf)
57
58 void conv_jistoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
59 {
60         KCC_filter(outbuf, "EUC", (gchar *)inbuf, "JISBB", 0, 0, 0);
61 }
62
63 void conv_euctojis(gchar *outbuf, gint outlen, const gchar *inbuf)
64 {
65         size_t inlen, len;
66
67         inlen = strlen(inbuf);
68         if (iskanji(inbuf[inlen - 1]) || iseucss(inbuf[inlen - 1])) {
69                 /* if tail end of the string is not ended with ascii,
70                    add dummy return code. */
71                 gchar *tmpin, *tmpout;
72
73                 /* length of original string + '\n' + '\0' */
74                 tmpin = alloca(inlen + 2);
75                 if (tmpin == NULL) {
76                         g_warning(_("can't allocate memory\n"));
77                         KCC_filter(outbuf, "JISBB", (gchar *)inbuf, "EUC",
78                                    0, 0, 0);
79                         return;
80                 }
81                 strcpy(tmpin, inbuf);
82                 tmpin[inlen] = '\n';
83                 tmpin[inlen + 1] = '\0';
84
85                 tmpout = alloca(outlen + 1);
86                 if (tmpout == NULL) {
87                         g_warning(_("can't allocate memory\n"));
88                         KCC_filter(outbuf, "JISBB", (gchar *)inbuf, "EUC",
89                                    0, 0, 0);
90                         return;
91                 }
92
93                 KCC_filter(tmpout, "JISBB", tmpin, "EUC", 0, 0, 0);
94                 len = strlen(tmpout);
95                 if (tmpout[len - 1] == '\n')
96                         tmpout[len - 1] = '\0';
97                 strncpy2(outbuf, tmpout, outlen);
98         } else
99                 KCC_filter(outbuf, "JISBB", (gchar *)inbuf, "EUC", 0, 0, 0);
100 }
101
102 void conv_sjistoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
103 {
104         KCC_filter(outbuf, "EUC", (gchar *)inbuf, "SJIS", 0, 0, 0);
105 }
106
107 void conv_anytoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
108 {
109         KCC_filter(outbuf, "EUC", (gchar *)inbuf, "AUTO", 0, 0, 0);
110 }
111
112 void conv_anytojis(gchar *outbuf, gint outlen, const gchar *inbuf)
113 {
114         KCC_filter(outbuf, "JISBB", (gchar *)inbuf, "AUTO", 0, 0, 0);
115 }
116
117 #define SUBST_CHAR      '_'
118
119 void conv_unreadable_eucjp(gchar *str)
120 {
121         register guchar *p = str;
122
123         while (*p != '\0') {
124                 if (isascii(*p)) {
125                         /* convert CR+LF -> LF */
126                         if (*p == '\r' && *(p + 1) == '\n')
127                                 memmove(p, p + 1, strlen(p));
128                         /* printable 7 bit code */
129                         p++;
130                 } else if (iskanji(*p)) {
131                         if (iskanji(*(p + 1)) && !isunprintablekanji(*p))
132                                 /* printable euc-jp code */
133                                 p += 2;
134                         else {
135                                 /* substitute unprintable code */
136                                 *p++ = SUBST_CHAR;
137                                 if (*p != '\0') {
138                                         if (isascii(*p))
139                                                 p++;
140                                         else
141                                                 *p++ = SUBST_CHAR;
142                                 }
143                         }
144                 } else if (iseucss(*p)) {
145                         if ((*(p + 1) & 0x80) != 0)
146                                 /* euc-jp hankaku kana */
147                                 p += 2;
148                         else
149                                 *p++ = SUBST_CHAR;
150                 } else
151                         /* substitute unprintable 1 byte code */
152                         *p++ = SUBST_CHAR;
153         }
154 }
155
156 void conv_unreadable_8bit(gchar *str)
157 {
158         register guchar *p = str;
159
160         while (*p != '\0') {
161                 /* convert CR+LF -> LF */
162                 if (*p == '\r' && *(p + 1) == '\n')
163                         memmove(p, p + 1, strlen(p));
164                 else if (!isascii(*p)) *p = SUBST_CHAR;
165                 p++;
166         }
167 }
168
169 void conv_unreadable_latin(gchar *str)
170 {
171         register guchar *p = str;
172
173         while (*p != '\0') {
174                 /* convert CR+LF -> LF */
175                 if (*p == '\r' && *(p + 1) == '\n')
176                         memmove(p, p + 1, strlen(p));
177                 else if ((*p & 0xff) >= 0x80 && (*p & 0xff) <= 0x9f)
178                         *p = SUBST_CHAR;
179                 p++;
180         }
181 }
182
183 #define NCV     '\0'
184
185 void conv_mb_alnum(gchar *str)
186 {
187         static guchar char_tbl[] = {
188                 /* 0xa0 - 0xaf */
189                 NCV, ' ', NCV, NCV, ',', '.', NCV, ':',
190                 ';', '?', '!', NCV, NCV, NCV, NCV, NCV,
191                 /* 0xb0 - 0xbf */
192                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
193                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
194                 /* 0xc0 - 0xcf */
195                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
196                 NCV, NCV, '(', ')', NCV, NCV, '[', ']',
197                 /* 0xd0 - 0xdf */
198                 '{', '}', NCV, NCV, NCV, NCV, NCV, NCV,
199                 NCV, NCV, NCV, NCV, '+', '-', NCV, NCV,
200                 /* 0xe0 - 0xef */
201                 NCV, '=', NCV, '<', '>', NCV, NCV, NCV,
202                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV
203         };
204
205         register guchar *p = str;
206         register gint len;
207
208         len = strlen(str);
209
210         while (len > 1) {
211                 if (*p == 0xa3) {
212                         register guchar ch = *(p + 1);
213
214                         if (ch >= 0xb0 && ch <= 0xfa) {
215                                 /* [a-zA-Z] */
216                                 *p = ch & 0x7f;
217                                 p++;
218                                 len--;
219                                 memmove(p, p + 1, len);
220                                 len--;
221                         } else  {
222                                 p += 2;
223                                 len -= 2;
224                         }
225                 } else if (*p == 0xa1) {
226                         register guchar ch = *(p + 1);
227
228                         if (ch >= 0xa0 && ch <= 0xef &&
229                             NCV != char_tbl[ch - 0xa0]) {
230                                 *p = char_tbl[ch - 0xa0];
231                                 p++;
232                                 len--;
233                                 memmove(p, p + 1, len);
234                                 len--;
235                         } else {
236                                 p += 2;
237                                 len -= 2;
238                         }
239                 } else if (iskanji(*p)) {
240                         p += 2;
241                         len -= 2;
242                 } else {
243                         p++;
244                         len--;
245                 }
246         }
247 }
248
249 void conv_jistodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
250 {
251         conv_jistoeuc(outbuf, outlen, inbuf);
252         conv_unreadable_eucjp(outbuf);
253 }
254
255 void conv_sjistodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
256 {
257         conv_sjistoeuc(outbuf, outlen, inbuf);
258         conv_unreadable_eucjp(outbuf);
259 }
260
261 void conv_euctodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
262 {
263         strncpy2(outbuf, inbuf, outlen);
264         conv_unreadable_eucjp(outbuf);
265 }
266
267 void conv_ustodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
268 {
269         strncpy2(outbuf, inbuf, outlen);
270         conv_unreadable_8bit(outbuf);
271 }
272
273 void conv_latintodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
274 {
275         strncpy2(outbuf, inbuf, outlen);
276         conv_unreadable_latin(outbuf);
277 }
278
279 void conv_noconv(gchar *outbuf, gint outlen, const gchar *inbuf)
280 {
281         strncpy2(outbuf, inbuf, outlen);
282 }
283
284 CodeConverter *conv_code_converter_new(const gchar *charset)
285 {
286         CodeConverter *conv;
287
288         conv = g_new0(CodeConverter, 1);
289 #if !HAVE_LIBJCONV
290         conv->code_conv_func = conv_get_code_conv_func(charset);
291 #endif
292         conv->charset_str = g_strdup(charset);
293         conv->charset = conv_get_charset_from_str(charset);
294
295         return conv;
296 }
297
298 void conv_code_converter_destroy(CodeConverter *conv)
299 {
300         g_free(conv->charset_str);
301         g_free(conv);
302 }
303
304 gint conv_convert(CodeConverter *conv, gchar *outbuf, gint outlen,
305                   const gchar *inbuf)
306 {
307 #if HAVE_LIBJCONV
308         gchar *str;
309
310         str = conv_codeset_strdup(inbuf, conv->charset_str, NULL);
311         if (!str)
312                 return -1;
313         else {
314                 strncpy2(outbuf, str, outlen);
315                 g_free(str);
316         }
317 #else /* !HAVE_LIBJCONV */
318         conv->code_conv_func(outbuf, outlen, inbuf);
319 #endif
320
321         return 0;
322 }
323
324 gchar *conv_codeset_strdup(const gchar *inbuf,
325                            const gchar *src_codeset, const gchar *dest_codeset)
326 {
327         gchar *buf;
328         size_t len;
329 #if HAVE_LIBJCONV
330         gint actual_codeset;
331         const gchar *const *codesets;
332         gint n_codesets;
333 #else /* !HAVE_LIBJCONV */
334         CharSet src_charset = C_AUTO, dest_charset = C_AUTO;
335 #endif
336
337         if (!dest_codeset) {
338                 CodeConvFunc func;
339
340                 func = conv_get_code_conv_func(src_codeset);
341                 if (func != conv_noconv) {
342                         if (func == conv_jistodisp || func == conv_sjistodisp)
343                                 len = strlen(inbuf) * 2 + 1;
344                         else
345                                 len = strlen(inbuf) + 1;
346                         buf = g_malloc(len);
347                         if (!buf) return NULL;
348                         func(buf, len, inbuf);
349                         buf = g_realloc(buf, strlen(buf) + 1);
350                         return buf;
351                 }
352         }
353
354         /* don't convert if src and dest codeset are identical */
355         if (src_codeset && dest_codeset &&
356             !strcasecmp(src_codeset, dest_codeset))
357                 return g_strdup(inbuf);
358
359 #if HAVE_LIBJCONV
360         if (src_codeset) {
361                 codesets = &src_codeset;
362                 n_codesets = 1;
363         } else
364                 codesets = jconv_info_get_pref_codesets(&n_codesets);
365         if (!dest_codeset) {
366                 dest_codeset = conv_get_current_charset_str();
367                 /* don't convert if current codeset is US-ASCII */
368                 if (!strcasecmp(dest_codeset, CS_US_ASCII))
369                         return g_strdup(inbuf);
370         }
371
372         if (jconv_alloc_conv(inbuf, strlen(inbuf), &buf, &len,
373                              codesets, n_codesets,
374                              &actual_codeset, dest_codeset)
375             == 0)
376                 return buf;
377         else
378                 return NULL;
379 #else /* !HAVE_LIBJCONV */
380         if (src_codeset) {
381                 if (!strcasecmp(src_codeset, CS_EUC_JP) ||
382                     !strcasecmp(src_codeset, CS_EUCJP))
383                         src_charset = C_EUC_JP;
384                 else if (!strcasecmp(src_codeset, CS_SHIFT_JIS) ||
385                          !strcasecmp(src_codeset, "SHIFT-JIS") ||
386                          !strcasecmp(src_codeset, "SJIS"))
387                         src_charset = C_SHIFT_JIS;
388                 if (dest_codeset && !strcasecmp(dest_codeset, CS_ISO_2022_JP))
389                         dest_charset = C_ISO_2022_JP;
390         }
391
392         if ((src_charset == C_EUC_JP || src_charset == C_SHIFT_JIS) &&
393             dest_charset == C_ISO_2022_JP) {
394                 len = (strlen(inbuf) + 1) * 3;
395                 buf = g_malloc(len);
396                 if (buf) {
397                         if (src_charset == C_EUC_JP)
398                                 conv_euctojis(buf, len, inbuf);
399                         else
400                                 conv_anytojis(buf, len, inbuf);
401                         buf = g_realloc(buf, strlen(buf) + 1);
402                 }
403         } else
404                 buf = g_strdup(inbuf);
405
406         return buf;
407 #endif /* !HAVE_LIBJCONV */
408 }
409
410 CodeConvFunc conv_get_code_conv_func(const gchar *charset)
411 {
412         CodeConvFunc code_conv;
413
414         if (!charset) {
415                 if (conv_get_outgoing_charset() == C_ISO_2022_JP)
416                         return conv_jistodisp;
417                 else
418                         return conv_noconv;
419         }
420
421         if (!strcasecmp(charset, CS_ISO_2022_JP) ||
422             !strcasecmp(charset, CS_ISO_2022_JP_2))
423                 code_conv = conv_jistodisp;
424         else if (!strcasecmp(charset, CS_US_ASCII))
425                 code_conv = conv_ustodisp;
426         else if (!strncasecmp(charset, CS_ISO_8859_1, 10))
427                 code_conv = conv_latintodisp;
428 #if !HAVE_LIBJCONV
429         else if (!strncasecmp(charset, "ISO-8859-", 9))
430                 code_conv = conv_latintodisp;
431 #endif
432         else if (!strcasecmp(charset, CS_SHIFT_JIS) ||
433                  !strcasecmp(charset, "SHIFT-JIS")  ||
434                  !strcasecmp(charset, "SJIS")       ||
435                  !strcasecmp(charset, "X-SJIS"))
436                 code_conv = conv_sjistodisp;
437         else if (!strcasecmp(charset, CS_EUC_JP) ||
438                  !strcasecmp(charset, CS_EUCJP))
439                 code_conv = conv_euctodisp;
440         else
441                 code_conv = conv_noconv;
442
443         return code_conv;
444 }
445
446 static const struct {
447         CharSet charset;
448         gchar *const name;
449 } charsets[] = {
450         {C_US_ASCII,            CS_US_ASCII},
451         {C_US_ASCII,            CS_ANSI_X3_4_1968},
452         {C_UTF_8,               CS_UTF_8},
453         {C_ISO_8859_1,          CS_ISO_8859_1},
454         {C_ISO_8859_2,          CS_ISO_8859_2},
455         {C_ISO_8859_4,          CS_ISO_8859_4},
456         {C_ISO_8859_5,          CS_ISO_8859_5},
457         {C_ISO_8859_7,          CS_ISO_8859_7},
458         {C_ISO_8859_8,          CS_ISO_8859_8},
459         {C_ISO_8859_9,          CS_ISO_8859_9},
460         {C_ISO_8859_11,         CS_ISO_8859_11},
461         {C_ISO_8859_13,         CS_ISO_8859_13},
462         {C_ISO_8859_15,         CS_ISO_8859_15},
463         {C_BALTIC,              CS_BALTIC},
464         {C_CP1251,              CS_CP1251},
465         {C_WINDOWS_1251,        CS_WINDOWS_1251},
466         {C_KOI8_R,              CS_KOI8_R},
467         {C_KOI8_U,              CS_KOI8_U},
468         {C_ISO_2022_JP,         CS_ISO_2022_JP},
469         {C_ISO_2022_JP_2,       CS_ISO_2022_JP_2},
470         {C_EUC_JP,              CS_EUC_JP},
471         {C_EUC_JP,              CS_EUCJP},
472         {C_SHIFT_JIS,           CS_SHIFT_JIS},
473         {C_ISO_2022_KR,         CS_ISO_2022_KR},
474         {C_EUC_KR,              CS_EUC_KR},
475         {C_ISO_2022_CN,         CS_ISO_2022_CN},
476         {C_EUC_CN,              CS_EUC_CN},
477         {C_GB2312,              CS_GB2312},
478         {C_EUC_TW,              CS_EUC_TW},
479         {C_BIG5,                CS_BIG5},
480         {C_TIS_620,             CS_TIS_620},
481         {C_WINDOWS_874,         CS_WINDOWS_874},
482 };
483
484 #if !HAVE_LIBJCONV
485 static const struct {
486         gchar *const locale;
487         CharSet charset;
488 } locale_table[] = {
489         {"ja_JP.eucJP"  , C_EUC_JP},
490         {"ja_JP.ujis"   , C_EUC_JP},
491         {"ja_JP.EUC"    , C_EUC_JP},
492         {"ja_JP.SJIS"   , C_SHIFT_JIS},
493         {"ja_JP.JIS"    , C_ISO_2022_JP},
494         {"ja_JP"        , C_EUC_JP},
495         {"ko_KR"        , C_EUC_KR},
496         {"zh_CN.GB2312" , C_GB2312},
497         {"zh_CN"        , C_GB2312},
498         {"zh_TW.eucTW"  , C_EUC_TW},
499         {"zh_TW.Big5"   , C_BIG5},
500         {"zh_TW"        , C_BIG5},
501
502         {"ru_RU.KOI8-R" , C_KOI8_R},
503         {"ru_RU.CP1251" , C_CP1251},
504
505         {"en_US"        , C_ISO_8859_1},
506         {"ca_ES"        , C_ISO_8859_1},
507         {"da_DK"        , C_ISO_8859_1},
508         {"de_DE"        , C_ISO_8859_1},
509         {"nl_NL"        , C_ISO_8859_1},
510         {"et_EE"        , C_ISO_8859_1},
511         {"fi_FI"        , C_ISO_8859_1},
512         {"fr_FR"        , C_ISO_8859_1},
513         {"is_IS"        , C_ISO_8859_1},
514         {"it_IT"        , C_ISO_8859_1},
515         {"no_NO"        , C_ISO_8859_1},
516         {"pt_PT"        , C_ISO_8859_1},
517         {"pt_BR"        , C_ISO_8859_1},
518         {"es_ES"        , C_ISO_8859_1},
519         {"sv_SE"        , C_ISO_8859_1},
520
521         {"hr_HR"        , C_ISO_8859_2},
522         {"hu_HU"        , C_ISO_8859_2},
523         {"pl_PL"        , C_ISO_8859_2},
524         {"ro_RO"        , C_ISO_8859_2},
525         {"sk_SK"        , C_ISO_8859_2},
526         {"sl_SI"        , C_ISO_8859_2},
527         {"ru_RU"        , C_ISO_8859_5},
528         {"el_GR"        , C_ISO_8859_7},
529         {"iw_IL"        , C_ISO_8859_8},
530         {"tr_TR"        , C_ISO_8859_9},
531
532         {"th_TH"        , C_TIS_620},
533         /* {"th_TH"     , C_WINDOWS_874}, */
534         /* {"th_TH"     , C_ISO_8859_11}, */
535
536         {"lt_LT.iso88594"       , C_ISO_8859_4},
537         {"lt_LT.ISO8859-4"      , C_ISO_8859_4},
538         {"lt_LT.ISO_8859-4"     , C_ISO_8859_4},
539         {"lt_LT"                , C_ISO_8859_13},
540         {"lv_LV"                , C_ISO_8859_13},
541
542         {"C"                    , C_US_ASCII},
543         {"POSIX"                , C_US_ASCII},
544         {"ANSI_X3.4-1968"       , C_US_ASCII},
545 };
546 #endif /* !HAVE_LIBJCONV */
547
548 const gchar *conv_get_charset_str(CharSet charset)
549 {
550         gint i;
551
552         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
553                 if (charsets[i].charset == charset)
554                         return charsets[i].name;
555         }
556
557         return NULL;
558 }
559
560 CharSet conv_get_charset_from_str(const gchar *charset)
561 {
562         gint i;
563
564         if (!charset) return C_AUTO;
565
566         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
567                 if (!strcasecmp(charsets[i].name, charset))
568                         return charsets[i].charset;
569         }
570
571         return C_AUTO;
572 }
573
574 CharSet conv_get_current_charset(void)
575 {
576         static CharSet cur_charset = -1;
577         gint i;
578
579 #if HAVE_LIBJCONV
580         const gchar *cur_codeset;
581 #else
582         const gchar *cur_locale;
583 #endif
584
585         if (cur_charset != -1)
586                 return cur_charset;
587
588 #if HAVE_LIBJCONV
589         cur_codeset = jconv_info_get_current_codeset();
590         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
591                 if (!strcasecmp(cur_codeset, charsets[i].name)) {
592                         cur_charset = charsets[i].charset;
593                         return cur_charset;
594                 }
595         }
596 #else
597         cur_locale = g_getenv("LC_ALL");
598         if (!cur_locale) cur_locale = g_getenv("LC_CTYPE");
599         if (!cur_locale) cur_locale = g_getenv("LANG");
600         if (!cur_locale) cur_locale = setlocale(LC_CTYPE, NULL);
601
602         debug_print("current locale: %s\n",
603                     cur_locale ? cur_locale : "(none)");
604
605         if (!cur_locale) {
606                 cur_charset = C_US_ASCII;
607                 return cur_charset;
608         }
609
610         if (strcasestr(cur_locale, "UTF-8")) {
611                 cur_charset = C_UTF_8;
612                 return cur_charset;
613         }
614
615         for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
616                 const gchar *p;
617
618                 /* "ja_JP.EUC" matches with "ja_JP.eucJP" and "ja_JP.EUC" */
619                 /* "ja_JP" matches with "ja_JP.xxxx" and "ja" */
620                 if (!strncasecmp(cur_locale, locale_table[i].locale,
621                                  strlen(locale_table[i].locale))) {
622                         cur_charset = locale_table[i].charset;
623                         return cur_charset;
624                 } else if ((p = strchr(locale_table[i].locale, '_')) &&
625                          !strchr(p + 1, '.')) {
626                         if (strlen(cur_locale) == 2 &&
627                             !strncasecmp(cur_locale, locale_table[i].locale, 2)) {
628                                 cur_charset = locale_table[i].charset;
629                                 return cur_charset;
630                         }
631                 }
632         }
633 #endif
634
635         cur_charset = C_AUTO;
636         return cur_charset;
637 }
638
639 const gchar *conv_get_current_charset_str(void)
640 {
641         static const gchar *codeset = NULL;
642
643         if (!codeset)
644                 codeset = conv_get_charset_str(conv_get_current_charset());
645
646         return codeset ? codeset : "US-ASCII";
647 }
648
649 CharSet conv_get_outgoing_charset(void)
650 {
651         static CharSet out_charset = -1;
652
653 #if HAVE_LIBJCONV
654         gint i, j, n_pref_codesets;
655         const gchar *const *pref_codesets;
656 #else
657         CharSet cur_charset;
658 #endif
659
660         if (out_charset != -1)
661                 return out_charset;
662
663 #if HAVE_LIBJCONV
664         /* skip US-ASCII and UTF-8 */
665         pref_codesets = jconv_info_get_pref_codesets(&n_pref_codesets);
666         for (i = 0; i < n_pref_codesets; i++) {
667                 for (j = 3; j < sizeof(charsets) / sizeof(charsets[0]); j++) {
668                         if (!strcasecmp(pref_codesets[i], charsets[j].name)) {
669                                 out_charset = charsets[j].charset;
670                                 return out_charset;
671                         }
672                 }
673         }
674
675         for (i = 0; i < n_pref_codesets; i++) {
676                 if (!strcasecmp(pref_codesets[i], "UTF-8")) {
677                         out_charset = C_UTF_8;
678                         return out_charset;
679                 }
680         }
681
682         out_charset = C_AUTO;
683 #else
684         cur_charset = conv_get_current_charset();
685         switch (cur_charset) {
686         case C_EUC_JP:
687         case C_SHIFT_JIS:
688                 out_charset = C_ISO_2022_JP;
689                 break;
690         default:
691                 out_charset = cur_charset;
692         }
693 #endif
694
695         return out_charset;
696 }
697
698 const gchar *conv_get_outgoing_charset_str(void)
699 {
700         CharSet out_charset;
701         const gchar *str;
702
703         if (prefs_common.outgoing_charset) {
704                 if (!isalpha(prefs_common.outgoing_charset[0])) {
705                         g_free(prefs_common.outgoing_charset);
706                         prefs_common.outgoing_charset = g_strdup(CS_AUTO);
707                 } else if (strcmp(prefs_common.outgoing_charset, CS_AUTO) != 0)
708                         return prefs_common.outgoing_charset;
709         }
710
711         out_charset = conv_get_outgoing_charset();
712         str = conv_get_charset_str(out_charset);
713
714         return str ? str : "US-ASCII";
715 }
716
717 const gchar *conv_get_current_locale(void)
718 {
719         gchar *cur_locale;
720
721         cur_locale = g_getenv("LC_ALL");
722         if (!cur_locale) cur_locale = g_getenv("LANG");
723         if (!cur_locale) cur_locale = setlocale(LC_CTYPE, NULL);
724
725         debug_print("current locale: %s\n",
726                     cur_locale ? cur_locale : "(none)");
727
728         return cur_locale;
729 }
730
731 void conv_unmime_header_overwrite(gchar *str)
732 {
733         gchar *buf;
734         gint outlen;
735         CharSet cur_charset;
736
737         cur_charset = conv_get_current_charset();
738
739 #if HAVE_LIBJCONV
740         Xstrdup_a(buf, str, return);
741         outlen = strlen(str) + 1;
742         UnMimeHeaderConv(buf, str, outlen);
743         if (cur_charset == C_EUC_JP) {
744                 gchar *tmp;
745                 gint len;
746
747                 len = strlen(str) * 2 + 1;
748                 Xalloca(tmp, len, return);
749                 conv_jistodisp(tmp, len, str);
750                 strncpy2(str, tmp, outlen);
751         }
752 #else
753         if (cur_charset == C_EUC_JP) {
754                 gchar *tmp;
755                 gint len;
756
757                 Xstrdup_a(buf, str, return);
758                 outlen = strlen(str) + 1;
759                 UnMimeHeader(buf);
760                 len = strlen(buf) * 2 + 1;
761                 Xalloca(tmp, len, {strncpy2(str, buf, outlen); return;});
762                 conv_jistodisp(tmp, len, buf);
763                 strncpy2(str, tmp, outlen);
764         } else
765                 UnMimeHeader(str);
766 #endif
767 }
768
769 void conv_unmime_header(gchar *outbuf, gint outlen, const gchar *str,
770                         const gchar *charset)
771 {
772         gchar *buf;
773         CharSet cur_charset;
774
775         cur_charset = conv_get_current_charset();
776         Xstrdup_a(buf, str, return);
777
778 #if HAVE_LIBJCONV
779         UnMimeHeaderConv(buf, outbuf, outlen);
780 #else
781         UnMimeHeader(buf);
782         strncpy2(outbuf, buf, outlen);
783 #endif
784         if (cur_charset == C_EUC_JP) {
785                 gint len;
786
787                 len = strlen(outbuf) * 2 + 1;
788                 Xalloca(buf, len, return);
789                 conv_jistodisp(buf, len, outbuf);
790                 strncpy2(outbuf, buf, outlen);
791         }
792 }
793
794 #define MAX_ENCLEN      75
795 #define MAX_LINELEN     76
796
797 #define B64LEN(len)     ((len) / 3 * 4 + ((len) % 3 ? 4 : 0))
798
799 #if HAVE_LIBJCONV
800 void conv_encode_header(gchar *dest, gint len, const gchar *src,
801                         gint header_len)
802 {
803         wchar_t *wsrc;
804         wchar_t *wsrcp;
805         gchar *destp;
806         size_t line_len, mimehdr_len, mimehdr_begin_len;
807         gchar *mimehdr_init = "=?";
808         gchar *mimehdr_end = "?=";
809         gchar *mimehdr_enctype = "?B?";
810         const gchar *mimehdr_charset;
811
812         /* g_print("src = %s\n", src); */
813         mimehdr_charset = conv_get_outgoing_charset_str();
814
815         /* convert to wide-character string */
816         wsrcp = wsrc = strdup_mbstowcs(src);
817
818         mimehdr_len = strlen(mimehdr_init) + strlen(mimehdr_end) +
819                 strlen(mimehdr_charset) + strlen(mimehdr_enctype);
820         mimehdr_begin_len = strlen(mimehdr_init) +
821                 strlen(mimehdr_charset) + strlen(mimehdr_enctype);
822         line_len = header_len;
823         destp = dest;
824         *dest = '\0';
825
826         g_return_if_fail(wsrc != NULL);
827
828         while (*wsrcp) {
829                 wchar_t *wp, *wtmp, *wtmpp;
830                 gint nspc = 0;
831
832                 /* irresponsible buffer overrun check */
833                 if ((len - (destp - dest)) < (MAX_LINELEN + 1) * 2) break;
834
835                 /* encode string including space
836                    if non-ASCII string follows */
837                 if (is_next_nonascii(wsrcp)) {
838                         wp = wsrcp;
839                         while ((wp = find_wspace(wp)) != NULL)
840                                 if (!is_next_nonascii(wp)) break;
841                 } else
842                         wp = find_wspace(wsrcp);
843
844                 if (wp != NULL) {
845                         wtmp = wcsndup(wsrcp, wp - wsrcp);
846                         wsrcp = wp + 1;
847                         while (iswspace(wsrcp[nspc])) nspc++;
848                 } else {
849                         wtmp = wcsdup(wsrcp);
850                         wsrcp += wcslen(wsrcp);
851                 }
852
853                 wtmpp = wtmp;
854
855                 do {
856                         gint tlen = 0, str_ascii = 1;
857                         gchar *tmp; /* internal codeset */
858                         gchar *raw; /* converted, but not base64 encoded */
859                         register gchar *tmpp;
860                         gint raw_len;
861
862                         tmpp = tmp = g_malloc(wcslen(wtmpp) * MB_CUR_MAX + 1);
863                         *tmp = '\0';
864                         raw = g_strdup("");
865                         raw_len = 0;
866
867                         while (*wtmpp != (wchar_t)0) {
868                                 gint mbl;
869                                 gint dummy;
870                                 gchar *raw_new = NULL;
871                                 int raw_new_len = 0;
872                                 const gchar *src_codeset;
873
874                                 if (*wtmpp < 32 || *wtmpp >= 127)
875                                         str_ascii = 0;
876                                 mbl = wctomb(tmpp, *wtmpp);
877                                 if (mbl == -1) {
878                                         g_warning("invalid wide character\n");
879                                         wtmpp++;
880                                         continue;
881                                 }
882                                 /* g_free(raw); */
883                                 src_codeset = conv_get_current_charset_str();
884                                 /* printf ("tmp = %s, tlen = %d, mbl\n",
885                                         tmp, tlen, mbl); */
886                                 if (jconv_alloc_conv(tmp, tlen + mbl,
887                                                      &raw_new, &raw_new_len,
888                                                      &src_codeset, 1,
889                                                      &dummy, mimehdr_charset)
890                                     != 0) {
891                                         g_warning("can't convert\n");
892                                         tmpp[0] = '\0';
893                                         wtmpp++;
894                                         continue;
895                                 }
896                                 if (!str_ascii) {
897                                         gint dlen = mimehdr_len +
898                                                 B64LEN(raw_len);
899                                         if ((line_len + dlen +
900                                              (*(wtmpp + 1) ? 0 : nspc) +
901                                              (line_len > 1 ? 1 : 0))
902                                             > MAX_LINELEN) {
903                                                 g_free(raw_new);
904                                                 if (tlen == 0) {
905                                                         *destp++ = '\n';
906                                                         *destp++ = ' ';
907                                                         line_len = 1;
908                                                         str_ascii = 1;
909                                                         continue;
910                                                 } else {
911                                                         *tmpp = '\0';
912                                                         break;
913                                                 }
914                                         }
915                                 } else if ((line_len + tlen + mbl +
916                                             (*(wtmpp + 1) ? 0 : nspc) +
917                                             (line_len > 1 ? 1 : 0))
918                                            > MAX_LINELEN) {
919                                         g_free(raw_new);
920                                         if (1 + tlen + mbl +
921                                             (*(wtmpp + 1) ? 0 : nspc)
922                                             >= MAX_LINELEN) {
923                                                 *tmpp = '\0';
924                                                 break;
925                                         }
926                                         *destp++ = '\n';
927                                         *destp++ = ' ';
928                                         line_len = 1;
929                                         continue;
930                                 }
931
932                                 tmpp += mbl;
933                                 *tmpp = '\0';
934
935                                 tlen += mbl;
936
937                                 g_free(raw);
938                                 raw = raw_new;
939                                 raw_len = raw_new_len;
940
941                                 wtmpp++;
942                         }
943                         /* g_print("tmp = %s, tlen = %d, mb_seqlen = %d\n",
944                                 tmp, tlen, mb_seqlen); */
945
946                         if (tlen == 0 || raw_len == 0) {
947                                 g_free(tmp);
948                                 g_free(raw);
949                                 continue;
950                         }
951
952                         if (line_len > 1 && destp > dest) {
953                                 *destp++ = ' ';
954                                 *destp = '\0';
955                                 line_len++;
956                         }
957
958                         if (!str_ascii) {
959                                 g_snprintf(destp, len - strlen(dest), "%s%s%s",
960                                            mimehdr_init, mimehdr_charset,
961                                            mimehdr_enctype);
962                                 destp += mimehdr_begin_len;
963                                 line_len += mimehdr_begin_len;
964
965                                 to64frombits(destp, raw, raw_len);
966                                 line_len += strlen(destp);
967                                 destp += strlen(destp);
968
969                                 strcpy(destp, mimehdr_end);
970                                 destp += strlen(mimehdr_end);
971                                 line_len += strlen(mimehdr_end);
972                         } else {
973                                 strcpy(destp, tmp);
974                                 line_len += strlen(destp);
975                                 destp += strlen(destp);
976                         }
977
978                         g_free(tmp);
979                         g_free(raw);
980                         /* g_print("line_len = %d\n\n", line_len); */
981                 } while (*wtmpp != (wchar_t)0);
982
983                 while (iswspace(*wsrcp)) {
984                         gint mbl;
985
986                         mbl = wctomb(destp, *wsrcp++);
987                         if (mbl != -1) {
988                                 destp += mbl;
989                                 line_len += mbl;
990                         }
991                 }
992                 *destp = '\0';
993
994                 g_free(wtmp);
995         }
996
997         g_free(wsrc);
998
999         /* g_print("dest = %s\n", dest); */
1000 }
1001 #else /* !HAVE_LIBJCONV */
1002
1003 #define JIS_SEQLEN      3
1004
1005 void conv_encode_header(gchar *dest, gint len, const gchar *src,
1006                         gint header_len)
1007 {
1008         wchar_t *wsrc;
1009         wchar_t *wsrcp;
1010         gchar *destp;
1011         size_t line_len, mimehdr_len, mimehdr_begin_len;
1012         gchar *mimehdr_init = "=?";
1013         gchar *mimehdr_end = "?=";
1014         gchar *mimehdr_enctype = "?B?";
1015         const gchar *mimehdr_charset;
1016
1017         /* g_print("src = %s\n", src); */
1018         mimehdr_charset = conv_get_outgoing_charset_str();
1019         if (strcmp(mimehdr_charset, "ISO-2022-JP") != 0) {
1020                 /* currently only supports Japanese */
1021                 strncpy2(dest, src, len);
1022                 return;
1023         }
1024
1025         /* convert to wide-character string */
1026         wsrcp = wsrc = strdup_mbstowcs(src);
1027
1028         mimehdr_len = strlen(mimehdr_init) + strlen(mimehdr_end) +
1029                       strlen(mimehdr_charset) + strlen(mimehdr_enctype);
1030         mimehdr_begin_len = strlen(mimehdr_init) +
1031                             strlen(mimehdr_charset) + strlen(mimehdr_enctype);
1032         line_len = header_len;
1033         destp = dest;
1034         *dest = '\0';
1035
1036         g_return_if_fail(wsrc != NULL);
1037
1038         while (*wsrcp) {
1039                 wchar_t *wp, *wtmp, *wtmpp;
1040                 gint nspc = 0;
1041
1042                 /* irresponsible buffer overrun check */
1043                 if ((len - (destp - dest)) < (MAX_LINELEN + 1) * 2) break;
1044
1045                 /* encode string including space
1046                    if non-ASCII string follows */
1047                 if (is_next_nonascii(wsrcp)) {
1048                         wp = wsrcp;
1049                         while ((wp = find_wspace(wp)) != NULL)
1050                                 if (!is_next_nonascii(wp)) break;
1051                 } else
1052                         wp = find_wspace(wsrcp);
1053
1054                 if (wp != NULL) {
1055                         wtmp = wcsndup(wsrcp, wp - wsrcp);
1056                         wsrcp = wp + 1;
1057                         while (iswspace(wsrcp[nspc])) nspc++;
1058                 } else {
1059                         wtmp = wcsdup(wsrcp);
1060                         wsrcp += wcslen(wsrcp);
1061                 }
1062
1063                 wtmpp = wtmp;
1064
1065                 do {
1066                         gint prev_mbl = 1, tlen = 0, mb_seqlen = 0;
1067                         gchar *tmp;
1068                         register gchar *tmpp;
1069
1070                         tmpp = tmp = g_malloc(wcslen(wtmpp) * MB_CUR_MAX + 1);
1071                         *tmp = '\0';
1072
1073                         while (*wtmpp != (wchar_t)0) {
1074                                 gint mbl;
1075
1076                                 mbl = wctomb(tmpp, *wtmpp);
1077                                 if (mbl == -1) {
1078                                         g_warning("invalid wide character\n");
1079                                         wtmpp++;
1080                                         continue;
1081                                 }
1082
1083                                 /* length of KI + KO */
1084                                 if (prev_mbl == 1 && mbl == 2)
1085                                         mb_seqlen += JIS_SEQLEN * 2;
1086
1087                                 if (mb_seqlen) {
1088                                         gint dlen = mimehdr_len +
1089                                                 B64LEN(tlen + mb_seqlen + mbl);
1090
1091                                         if ((line_len + dlen +
1092                                              (*(wtmpp + 1) ? 0 : nspc) +
1093                                              (line_len > 1 ? 1 : 0))
1094                                             > MAX_LINELEN) {
1095                                                 if (tlen == 0) {
1096                                                         *destp++ = '\n';
1097                                                         *destp++ = ' ';
1098                                                         line_len = 1;
1099                                                         mb_seqlen = 0;
1100                                                         continue;
1101                                                 } else {
1102                                                         *tmpp = '\0';
1103                                                         break;
1104                                                 }
1105                                         }
1106                                 } else if ((line_len + tlen + mbl +
1107                                             (*(wtmpp + 1) ? 0 : nspc) +
1108                                             (line_len > 1 ? 1 : 0))
1109                                            > MAX_LINELEN) {
1110                                         if (1 + tlen + mbl +
1111                                             (*(wtmpp + 1) ? 0 : nspc)
1112                                             >= MAX_LINELEN) {
1113                                                 *tmpp = '\0';
1114                                                 break;
1115                                         }
1116                                         *destp++ = '\n';
1117                                         *destp++ = ' ';
1118                                         line_len = 1;
1119                                         continue;
1120                                 }
1121
1122                                 tmpp += mbl;
1123                                 *tmpp = '\0';
1124
1125                                 tlen += mbl;
1126                                 prev_mbl = mbl;
1127
1128                                 wtmpp++;
1129                         }
1130                         /* g_print("tmp = %s, tlen = %d, mb_seqlen = %d\n",
1131                                 tmp, tlen, mb_seqlen); */
1132
1133                         if (tlen == 0) {
1134                                 g_free(tmp);
1135                                 continue;
1136                         }
1137
1138                         if (line_len > 1 && destp > dest) {
1139                                 *destp++ = ' ';
1140                                 *destp = '\0';
1141                                 line_len++;
1142                         }
1143
1144                         if (mb_seqlen) {
1145                                 gchar *tmp_jis;
1146
1147                                 tmp_jis = g_new(gchar, tlen + mb_seqlen + 1);
1148                                 conv_euctojis(tmp_jis,
1149                                               tlen + mb_seqlen + 1, tmp);
1150                                 g_snprintf(destp, len - strlen(dest), "%s%s%s",
1151                                            mimehdr_init, mimehdr_charset,
1152                                            mimehdr_enctype);
1153                                 destp += mimehdr_begin_len;
1154                                 line_len += mimehdr_begin_len;
1155
1156                                 to64frombits(destp, tmp_jis, strlen(tmp_jis));
1157                                 line_len += strlen(destp);
1158                                 destp += strlen(destp);
1159
1160                                 strcpy(destp, mimehdr_end);
1161                                 destp += strlen(mimehdr_end);
1162                                 line_len += strlen(mimehdr_end);
1163
1164                                 g_free(tmp_jis);
1165                         } else {
1166                                 strcpy(destp, tmp);
1167                                 line_len += strlen(destp);
1168                                 destp += strlen(destp);
1169                         }
1170
1171                         g_free(tmp);
1172                         /* g_print("line_len = %d\n\n", line_len); */
1173                 } while (*wtmpp != (wchar_t)0);
1174
1175                 while (iswspace(*wsrcp)) {
1176                         gint mbl;
1177
1178                         mbl = wctomb(destp, *wsrcp++);
1179                         if (mbl != -1) {
1180                                 destp += mbl;
1181                                 line_len += mbl;
1182                         }
1183                 }
1184                 *destp = '\0';
1185
1186                 g_free(wtmp);
1187         }
1188
1189         g_free(wsrc);
1190
1191         /* g_print("dest = %s\n", dest); */
1192 }
1193 #endif /* HAVE_LIBJCONV */