fb0baab9f9e8ad10e692da997a44a88ebef4d38a
[claws.git] / src / codeconv.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2003 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 #include <errno.h>
29
30 #if HAVE_LOCALE_H
31 #  include <locale.h>
32 #endif
33
34 #if HAVE_ICONV
35 #  include <iconv.h>
36 #endif
37
38 #include "intl.h"
39 #include "codeconv.h"
40 #include "unmime.h"
41 #include "base64.h"
42 #include "quoted-printable.h"
43 #include "utils.h"
44 #include "prefs_common.h"
45
46 typedef enum
47 {
48         JIS_ASCII,
49         JIS_KANJI,
50         JIS_HWKANA,
51         JIS_AUXKANJI
52 } JISState;
53
54 #define SUBST_CHAR      '_'
55 #define ESC             '\033'
56
57 #define iseuckanji(c) \
58         (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xfe)
59 #define iseuchwkana1(c) \
60         (((c) & 0xff) == 0x8e)
61 #define iseuchwkana2(c) \
62         (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xdf)
63 #define iseucaux(c) \
64         (((c) & 0xff) == 0x8f)
65 #define issjiskanji1(c) \
66         ((((c) & 0xff) >= 0x81 && ((c) & 0xff) <= 0x9f) || \
67          (((c) & 0xff) >= 0xe0 && ((c) & 0xff) <= 0xfc))
68 #define issjiskanji2(c) \
69         ((((c) & 0xff) >= 0x40 && ((c) & 0xff) <= 0x7e) || \
70          (((c) & 0xff) >= 0x80 && ((c) & 0xff) <= 0xfc))
71 #define issjishwkana(c) \
72         (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xdf)
73
74 #define K_IN()                          \
75         if (state != JIS_KANJI) {       \
76                 *out++ = ESC;           \
77                 *out++ = '$';           \
78                 *out++ = 'B';           \
79                 state = JIS_KANJI;      \
80         }
81
82 #define K_OUT()                         \
83         if (state != JIS_ASCII) {       \
84                 *out++ = ESC;           \
85                 *out++ = '(';           \
86                 *out++ = 'B';           \
87                 state = JIS_ASCII;      \
88         }
89
90 #define HW_IN()                         \
91         if (state != JIS_HWKANA) {      \
92                 *out++ = ESC;           \
93                 *out++ = '(';           \
94                 *out++ = 'I';           \
95                 state = JIS_HWKANA;     \
96         }
97
98 #define AUX_IN()                        \
99         if (state != JIS_AUXKANJI) {    \
100                 *out++ = ESC;           \
101                 *out++ = '$';           \
102                 *out++ = '(';           \
103                 *out++ = 'D';           \
104                 state = JIS_AUXKANJI;   \
105         }
106
107 void conv_jistoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
108 {
109         const guchar *in = inbuf;
110         guchar *out = outbuf;
111         JISState state = JIS_ASCII;
112
113         while (*in != '\0') {
114                 if (*in == ESC) {
115                         in++;
116                         if (*in == '$') {
117                                 if (*(in + 1) == '@' || *(in + 1) == 'B') {
118                                         state = JIS_KANJI;
119                                         in += 2;
120                                 } else if (*(in + 1) == '(' &&
121                                            *(in + 2) == 'D') {
122                                         state = JIS_AUXKANJI;
123                                         in += 3;
124                                 } else {
125                                         /* unknown escape sequence */
126                                         state = JIS_ASCII;
127                                 }
128                         } else if (*in == '(') {
129                                 if (*(in + 1) == 'B' || *(in + 1) == 'J') {
130                                         state = JIS_ASCII;
131                                         in += 2;
132                                 } else if (*(in + 1) == 'I') {
133                                         state = JIS_HWKANA;
134                                         in += 2;
135                                 } else {
136                                         /* unknown escape sequence */
137                                         state = JIS_ASCII;
138                                 }
139                         } else {
140                                 /* unknown escape sequence */
141                                 state = JIS_ASCII;
142                         }
143                 } else if (*in == 0x0e) {
144                         state = JIS_HWKANA;
145                         in++;
146                 } else if (*in == 0x0f) {
147                         state = JIS_ASCII;
148                         in++;
149                 } else {
150                         switch (state) {
151                         case JIS_ASCII:
152                                 *out++ = *in++;
153                                 break;
154                         case JIS_KANJI:
155                                 *out++ = *in++ | 0x80;
156                                 if (*in == '\0') break;
157                                 *out++ = *in++ | 0x80;
158                                 break;
159                         case JIS_HWKANA:
160                                 *out++ = 0x8e;
161                                 *out++ = *in++ | 0x80;
162                                 break;
163                         case JIS_AUXKANJI:
164                                 *out++ = 0x8f;
165                                 *out++ = *in++ | 0x80;
166                                 if (*in == '\0') break;
167                                 *out++ = *in++ | 0x80;
168                                 break;
169                         }
170                 }
171         }
172
173         *out = '\0';
174 }
175
176 void conv_euctojis(gchar *outbuf, gint outlen, const gchar *inbuf)
177 {
178         const guchar *in = inbuf;
179         guchar *out = outbuf;
180         JISState state = JIS_ASCII;
181
182         while (*in != '\0') {
183                 if (isascii(*in)) {
184                         K_OUT();
185                         *out++ = *in++;
186                 } else if (iseuckanji(*in)) {
187                         if (iseuckanji(*(in + 1))) {
188                                 K_IN();
189                                 *out++ = *in++ & 0x7f;
190                                 *out++ = *in++ & 0x7f;
191                         } else {
192                                 K_OUT();
193                                 *out++ = SUBST_CHAR;
194                                 in++;
195                                 if (*in != '\0' && !isascii(*in)) {
196                                         *out++ = SUBST_CHAR;
197                                         in++;
198                                 }
199                         }
200                 } else if (iseuchwkana1(*in)) {
201                         in++;
202                         if (iseuchwkana2(*in)) {
203                                 HW_IN();
204                                 *out++ = *in++ & 0x7f;
205                         } else {
206                                 K_OUT();
207                                 if (*in != '\0' && !isascii(*in)) {
208                                         *out++ = SUBST_CHAR;
209                                         in++;
210                                 }
211                         }
212                 } else if (iseucaux(*in)) {
213                         in++;
214                         if (iseuckanji(*in) && iseuckanji(*(in + 1))) {
215                                 AUX_IN();
216                                 *out++ = *in++ & 0x7f;
217                                 *out++ = *in++ & 0x7f;
218                         } else {
219                                 K_OUT();
220                                 if (*in != '\0' && !isascii(*in)) {
221                                         *out++ = SUBST_CHAR;
222                                         in++;
223                                         if (*in != '\0' && !isascii(*in)) {
224                                                 *out++ = SUBST_CHAR;
225                                                 in++;
226                                         }
227                                 }
228                         }
229                 } else {
230                         K_OUT();
231                         *out++ = SUBST_CHAR;
232                         in++;
233                 }
234         }
235
236         K_OUT();
237         *out = '\0';
238 }
239
240 void conv_sjistoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
241 {
242         const guchar *in = inbuf;
243         guchar *out = outbuf;
244
245         while (*in != '\0') {
246                 if (isascii(*in)) {
247                         *out++ = *in++;
248                 } else if (issjiskanji1(*in)) {
249                         if (issjiskanji2(*(in + 1))) {
250                                 guchar out1 = *in;
251                                 guchar out2 = *(in + 1);
252                                 guchar row;
253
254                                 row = out1 < 0xa0 ? 0x70 : 0xb0;
255                                 if (out2 < 0x9f) {
256                                         out1 = (out1 - row) * 2 - 1;
257                                         out2 -= out2 > 0x7f ? 0x20 : 0x1f;
258                                 } else {
259                                         out1 = (out1 - row) * 2;
260                                         out2 -= 0x7e;
261                                 }
262
263                                 *out++ = out1 | 0x80;
264                                 *out++ = out2 | 0x80;
265                                 in += 2;
266                         } else {
267                                 *out++ = SUBST_CHAR;
268                                 in++;
269                                 if (*in != '\0' && !isascii(*in)) {
270                                         *out++ = SUBST_CHAR;
271                                         in++;
272                                 }
273                         }
274                 } else if (issjishwkana(*in)) {
275                         *out++ = 0x8e;
276                         *out++ = *in++;
277                 } else {
278                         *out++ = SUBST_CHAR;
279                         in++;
280                 }
281         }
282
283         *out = '\0';
284 }
285
286 void conv_anytoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
287 {
288         switch (conv_guess_ja_encoding(inbuf)) {
289         case C_ISO_2022_JP:
290                 conv_jistoeuc(outbuf, outlen, inbuf);
291                 break;
292         case C_SHIFT_JIS:
293                 conv_sjistoeuc(outbuf, outlen, inbuf);
294                 break;
295         default:
296                 strncpy2(outbuf, inbuf, outlen);
297                 break;
298         }
299 }
300
301 void conv_anytojis(gchar *outbuf, gint outlen, const gchar *inbuf)
302 {
303         switch (conv_guess_ja_encoding(inbuf)) {
304         case C_EUC_JP:
305                 conv_euctojis(outbuf, outlen, inbuf);
306                 break;
307         default:
308                 strncpy2(outbuf, inbuf, outlen);
309                 break;
310         }
311 }
312
313 static gchar valid_eucjp_tbl[][96] = {
314         /* 0xa2a0 - 0xa2ff */
315         { 0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 0,
316           0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 1, 1, 1, 1, 1, 1,
317           1, 1, 0, 0, 0, 0, 0, 0,  0, 0, 1, 1, 1, 1, 1, 1,
318           1, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 1, 1, 1, 1,
319           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 0, 0, 0, 0, 0,
320           0, 0, 1, 1, 1, 1, 1, 1,  1, 1, 0, 0, 0, 0, 1, 0 },
321
322         /* 0xa3a0 - 0xa3ff */
323         { 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
324           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 0, 0, 0, 0, 0, 0,
325           0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
326           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 0, 0, 0, 0, 0,
327           0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
328           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 0, 0, 0, 0, 0 },
329
330         /* 0xa4a0 - 0xa4ff */
331         { 0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
332           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
333           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
334           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
335           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
336           1, 1, 1, 1, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0 },
337
338         /* 0xa5a0 - 0xa5ff */
339         { 0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
340           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
341           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
342           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
343           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
344           1, 1, 1, 1, 1, 1, 1, 0,  0, 0, 0, 0, 0, 0, 0, 0 },
345
346         /* 0xa6a0 - 0xa6ff */
347         { 0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
348           1, 1, 1, 1, 1, 1, 1, 1,  1, 0, 0, 0, 0, 0, 0, 0,
349           0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
350           1, 1, 1, 1, 1, 1, 1, 1,  1, 0, 0, 0, 0, 0, 0, 0,
351           0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
352           0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0 },
353
354         /* 0xa7a0 - 0xa7ff */
355         { 0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
356           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
357           1, 1, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
358           0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
359           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
360           1, 1, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0 },
361
362         /* 0xa8a0 - 0xa8ff */
363         { 0, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
364           1, 1, 1, 1, 1, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1,
365           1, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
366           0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
367           0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
368           0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0 }
369 };
370
371 static gboolean isprintableeuckanji(guchar c1, guchar c2)
372 {
373         if (c1 <= 0xa0 || c1 >= 0xf5)
374                 return FALSE;
375         if (c2 <= 0xa0 || c2 == 0xff)
376                 return FALSE;
377
378         if (c1 >= 0xa9 && c1 <= 0xaf)
379                 return FALSE;
380
381         if (c1 >= 0xa2 && c1 <= 0xa8)
382                 return (gboolean)valid_eucjp_tbl[c1 - 0xa2][c2 - 0xa0];
383
384         if (c1 == 0xcf) {
385                 if (c2 >= 0xd4 && c2 <= 0xff)
386                         return FALSE;
387         } else if (c1 == 0xf4) {
388                 if (c2 >= 0xa7 && c2 <= 0xff)
389                         return FALSE;
390         }
391
392         return TRUE;
393 }
394
395 void conv_unreadable_eucjp(gchar *str)
396 {
397         register guchar *p = str;
398
399         while (*p != '\0') {
400                 if (isascii(*p)) {
401                         /* convert CR+LF -> LF */
402                         if (*p == '\r' && *(p + 1) == '\n')
403                                 memmove(p, p + 1, strlen(p));
404                         /* printable 7 bit code */
405                         p++;
406                 } else if (iseuckanji(*p)) {
407                         if (isprintableeuckanji(*p, *(p + 1))) {
408                                 /* printable euc-jp code */
409                                 p += 2;
410                         } else {
411                                 /* substitute unprintable code */
412                                 *p++ = SUBST_CHAR;
413                                 if (*p != '\0') {
414                                         if (isascii(*p))
415                                                 p++;
416                                         else
417                                                 *p++ = SUBST_CHAR;
418                                 }
419                         }
420                 } else if (iseuchwkana1(*p)) {
421                         if (iseuchwkana2(*(p + 1)))
422                                 /* euc-jp hankaku kana */
423                                 p += 2;
424                         else
425                                 *p++ = SUBST_CHAR;
426                 } else if (iseucaux(*p)) {
427                         if (iseuckanji(*(p + 1)) && iseuckanji(*(p + 2))) {
428                                 /* auxiliary kanji */
429                                 p += 3;
430                         } else
431                                 *p++ = SUBST_CHAR;
432                 } else
433                         /* substitute unprintable 1 byte code */
434                         *p++ = SUBST_CHAR;
435         }
436 }
437
438 void conv_unreadable_8bit(gchar *str)
439 {
440         register guchar *p = str;
441
442         while (*p != '\0') {
443                 /* convert CR+LF -> LF */
444                 if (*p == '\r' && *(p + 1) == '\n')
445                         memmove(p, p + 1, strlen(p));
446                 else if (!isascii(*p)) *p = SUBST_CHAR;
447                 p++;
448         }
449 }
450
451 void conv_unreadable_latin(gchar *str)
452 {
453         register guchar *p = str;
454
455         while (*p != '\0') {
456                 /* convert CR+LF -> LF */
457                 if (*p == '\r' && *(p + 1) == '\n')
458                         memmove(p, p + 1, strlen(p));
459                 else if ((*p & 0xff) >= 0x7f && (*p & 0xff) <= 0x9f)
460                         *p = SUBST_CHAR;
461                 p++;
462         }
463 }
464
465 void conv_unreadable_locale(gchar *str)
466 {
467         switch (conv_get_current_charset()) {
468         case C_US_ASCII:
469         case C_ISO_8859_1:
470         case C_ISO_8859_2:
471         case C_ISO_8859_3:
472         case C_ISO_8859_4:
473         case C_ISO_8859_5:
474         case C_ISO_8859_6:
475         case C_ISO_8859_7:
476         case C_ISO_8859_8:
477         case C_ISO_8859_9:
478         case C_ISO_8859_10:
479         case C_ISO_8859_11:
480         case C_ISO_8859_13:
481         case C_ISO_8859_14:
482         case C_ISO_8859_15:
483                 conv_unreadable_latin(str);
484                 break;
485         case C_EUC_JP:
486                 conv_unreadable_eucjp(str);
487                 break;
488         default:
489                 break;
490         }
491 }
492
493 #define NCV     '\0'
494
495 void conv_mb_alnum(gchar *str)
496 {
497         static guchar char_tbl[] = {
498                 /* 0xa0 - 0xaf */
499                 NCV, ' ', NCV, NCV, ',', '.', NCV, ':',
500                 ';', '?', '!', NCV, NCV, NCV, NCV, NCV,
501                 /* 0xb0 - 0xbf */
502                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
503                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
504                 /* 0xc0 - 0xcf */
505                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
506                 NCV, NCV, '(', ')', NCV, NCV, '[', ']',
507                 /* 0xd0 - 0xdf */
508                 '{', '}', NCV, NCV, NCV, NCV, NCV, NCV,
509                 NCV, NCV, NCV, NCV, '+', '-', NCV, NCV,
510                 /* 0xe0 - 0xef */
511                 NCV, '=', NCV, '<', '>', NCV, NCV, NCV,
512                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV
513         };
514
515         register guchar *p = str;
516         register gint len;
517
518         len = strlen(str);
519
520         while (len > 1) {
521                 if (*p == 0xa3) {
522                         register guchar ch = *(p + 1);
523
524                         if (ch >= 0xb0 && ch <= 0xfa) {
525                                 /* [a-zA-Z] */
526                                 *p = ch & 0x7f;
527                                 p++;
528                                 len--;
529                                 memmove(p, p + 1, len);
530                                 len--;
531                         } else  {
532                                 p += 2;
533                                 len -= 2;
534                         }
535                 } else if (*p == 0xa1) {
536                         register guchar ch = *(p + 1);
537
538                         if (ch >= 0xa0 && ch <= 0xef &&
539                             NCV != char_tbl[ch - 0xa0]) {
540                                 *p = char_tbl[ch - 0xa0];
541                                 p++;
542                                 len--;
543                                 memmove(p, p + 1, len);
544                                 len--;
545                         } else {
546                                 p += 2;
547                                 len -= 2;
548                         }
549                 } else if (iseuckanji(*p)) {
550                         p += 2;
551                         len -= 2;
552                 } else {
553                         p++;
554                         len--;
555                 }
556         }
557 }
558
559 CharSet conv_guess_ja_encoding(const gchar *str)
560 {
561         const guchar *p = str;
562         CharSet guessed = C_US_ASCII;
563
564         while (*p != '\0') {
565                 if (*p == ESC && (*(p + 1) == '$' || *(p + 1) == '(')) {
566                         if (guessed == C_US_ASCII)
567                                 return C_ISO_2022_JP;
568                         p += 2;
569                 } else if (isascii(*p)) {
570                         p++;
571                 } else if (iseuckanji(*p) && iseuckanji(*(p + 1))) {
572                         if (*p >= 0xfd && *p <= 0xfe)
573                                 return C_EUC_JP;
574                         else if (guessed == C_SHIFT_JIS) {
575                                 if ((issjiskanji1(*p) &&
576                                      issjiskanji2(*(p + 1))) ||
577                                     issjishwkana(*p))
578                                         guessed = C_SHIFT_JIS;
579                                 else
580                                         guessed = C_EUC_JP;
581                         } else
582                                 guessed = C_EUC_JP;
583                         p += 2;
584                 } else if (issjiskanji1(*p) && issjiskanji2(*(p + 1))) {
585                         if (iseuchwkana1(*p) && iseuchwkana2(*(p + 1)))
586                                 guessed = C_SHIFT_JIS;
587                         else
588                                 return C_SHIFT_JIS;
589                         p += 2;
590                 } else if (issjishwkana(*p)) {
591                         guessed = C_SHIFT_JIS;
592                         p++;
593                 } else {
594                         p++;
595                 }
596         }
597
598         return guessed;
599 }
600
601 void conv_jistodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
602 {
603         conv_jistoeuc(outbuf, outlen, inbuf);
604         conv_unreadable_eucjp(outbuf);
605 }
606
607 void conv_sjistodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
608 {
609         conv_sjistoeuc(outbuf, outlen, inbuf);
610         conv_unreadable_eucjp(outbuf);
611 }
612
613 void conv_euctodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
614 {
615         strncpy2(outbuf, inbuf, outlen);
616         conv_unreadable_eucjp(outbuf);
617 }
618
619 void conv_anytodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
620 {
621         conv_anytoeuc(outbuf, outlen, inbuf);
622         conv_unreadable_eucjp(outbuf);
623 }
624
625 void conv_ustodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
626 {
627         strncpy2(outbuf, inbuf, outlen);
628         conv_unreadable_8bit(outbuf);
629 }
630
631 void conv_latintodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
632 {
633         strncpy2(outbuf, inbuf, outlen);
634         conv_unreadable_latin(outbuf);
635 }
636
637 void conv_localetodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
638 {
639         strncpy2(outbuf, inbuf, outlen);
640         conv_unreadable_locale(outbuf);
641 }
642
643 void conv_noconv(gchar *outbuf, gint outlen, const gchar *inbuf)
644 {
645         strncpy2(outbuf, inbuf, outlen);
646 }
647
648 CodeConverter *conv_code_converter_new(const gchar *charset)
649 {
650         CodeConverter *conv;
651
652         conv = g_new0(CodeConverter, 1);
653         conv->code_conv_func = conv_get_code_conv_func(charset, NULL);
654         conv->charset_str = g_strdup(charset);
655         conv->charset = conv_get_charset_from_str(charset);
656
657         return conv;
658 }
659
660 void conv_code_converter_destroy(CodeConverter *conv)
661 {
662         g_free(conv->charset_str);
663         g_free(conv);
664 }
665
666 gint conv_convert(CodeConverter *conv, gchar *outbuf, gint outlen,
667                   const gchar *inbuf)
668 {
669 #if HAVE_ICONV
670         if (conv->code_conv_func != conv_noconv)
671                 conv->code_conv_func(outbuf, outlen, inbuf);
672         else {
673                 gchar *str;
674
675                 str = conv_iconv_strdup(inbuf, conv->charset_str, NULL);
676                 if (!str)
677                         return -1;
678                 else {
679                         strncpy2(outbuf, str, outlen);
680                         g_free(str);
681                 }
682         }
683 #else /* !HAVE_ICONV */
684         conv->code_conv_func(outbuf, outlen, inbuf);
685 #endif
686
687         return 0;
688 }
689
690 gchar *conv_codeset_strdup(const gchar *inbuf,
691                            const gchar *src_code, const gchar *dest_code)
692 {
693         gchar *buf;
694         size_t len;
695         CodeConvFunc conv_func;
696
697         conv_func = conv_get_code_conv_func(src_code, dest_code);
698         if (conv_func != conv_noconv) {
699                 len = (strlen(inbuf) + 1) * 3;
700                 buf = g_malloc(len);
701                 if (!buf) return NULL;
702
703                 conv_func(buf, len, inbuf);
704                 return g_realloc(buf, strlen(buf) + 1);
705         }
706
707 #if HAVE_ICONV
708         return conv_iconv_strdup(inbuf, src_code, dest_code);
709 #else
710         return g_strdup(inbuf);
711 #endif /* HAVE_ICONV */
712 }
713
714 CodeConvFunc conv_get_code_conv_func(const gchar *src_charset_str,
715                                      const gchar *dest_charset_str)
716 {
717         CodeConvFunc code_conv = conv_noconv;
718         CharSet src_charset;
719         CharSet dest_charset;
720
721         if (!src_charset_str)
722                 src_charset = conv_get_current_charset();
723         else
724                 src_charset = conv_get_charset_from_str(src_charset_str);
725
726         /* auto detection mode */
727         if (!src_charset_str && !dest_charset_str) {
728                 if (src_charset == C_EUC_JP || src_charset == C_SHIFT_JIS)
729                         return conv_anytodisp;
730                 else
731                         return conv_noconv;
732         }
733
734         dest_charset = conv_get_charset_from_str(dest_charset_str);
735
736         if (dest_charset == C_US_ASCII)
737                 return conv_ustodisp;
738         else if (dest_charset == C_UTF_8 ||
739                  (dest_charset == C_AUTO &&
740                   conv_get_current_charset() == C_UTF_8))
741                 return conv_noconv;
742
743         switch (src_charset) {
744         case C_ISO_2022_JP:
745         case C_ISO_2022_JP_2:
746                 if (dest_charset == C_AUTO)
747                         code_conv = conv_jistodisp;
748                 else if (dest_charset == C_EUC_JP)
749                         code_conv = conv_jistoeuc;
750                 break;
751         case C_US_ASCII:
752                 if (dest_charset == C_AUTO)
753                         code_conv = conv_ustodisp;
754                 break;
755         case C_ISO_8859_1:
756         case C_ISO_8859_2:
757         case C_ISO_8859_3:
758         case C_ISO_8859_4:
759         case C_ISO_8859_5:
760         case C_ISO_8859_6:
761         case C_ISO_8859_7:
762         case C_ISO_8859_8:
763         case C_ISO_8859_9:
764         case C_ISO_8859_10:
765         case C_ISO_8859_11:
766         case C_ISO_8859_13:
767         case C_ISO_8859_14:
768         case C_ISO_8859_15:
769                 if (dest_charset == C_AUTO)
770                         code_conv = conv_latintodisp;
771                 break;
772         case C_SHIFT_JIS:
773                 if (dest_charset == C_AUTO)
774                         code_conv = conv_sjistodisp;
775                 else if (dest_charset == C_EUC_JP)
776                         code_conv = conv_sjistoeuc;
777                 break;
778         case C_EUC_JP:
779                 if (dest_charset == C_AUTO)
780                         code_conv = conv_euctodisp;
781                 else if (dest_charset == C_ISO_2022_JP ||
782                          dest_charset == C_ISO_2022_JP_2)
783                         code_conv = conv_euctojis;
784                 break;
785         default:
786                 break;
787         }
788
789         return code_conv;
790 }
791
792 #if HAVE_ICONV
793 gchar *conv_iconv_strdup(const gchar *inbuf,
794                          const gchar *src_code, const gchar *dest_code)
795 {
796         iconv_t cd;
797         const gchar *inbuf_p;
798         gchar *outbuf;
799         gchar *outbuf_p;
800         gint in_size;
801         gint in_left;
802         gint out_size;
803         gint out_left;
804         gint n_conv;
805
806         if (!src_code)
807                 src_code = conv_get_outgoing_charset_str();
808         if (!dest_code)
809                 dest_code = conv_get_current_charset_str();
810
811         /* don't convert if current codeset is US-ASCII */
812         if (!strcasecmp(dest_code, CS_US_ASCII))
813                 return g_strdup(inbuf);
814
815         /* don't convert if src and dest codeset are identical */
816         if (!strcasecmp(src_code, dest_code))
817                 return g_strdup(inbuf);
818
819         cd = iconv_open(dest_code, src_code);
820         if (cd == (iconv_t)-1)
821                 return NULL;
822
823         inbuf_p = inbuf;
824         in_size = strlen(inbuf) + 1;
825         in_left = in_size;
826         out_size = in_size * 2;
827         outbuf = g_malloc(out_size);
828         outbuf_p = outbuf;
829         out_left = out_size;
830
831         while ((n_conv = iconv(cd, (ICONV_CONST gchar **)&inbuf_p, &in_left,
832                                &outbuf_p, &out_left)) < 0) {
833                 if (EILSEQ == errno) {
834                         inbuf_p++;
835                         in_left--;
836                         *outbuf_p++ = SUBST_CHAR;
837                         out_left--;
838                 } else if (EINVAL == errno) {
839                         *outbuf_p = '\0';
840                         break;
841                 } else if (E2BIG == errno) {
842                         out_size *= 2;
843                         outbuf = g_realloc(outbuf, out_size);
844                         inbuf_p = inbuf;
845                         in_left = in_size;
846                         outbuf_p = outbuf;
847                         out_left = out_size;
848                 } else {
849                         g_warning("conv_iconv_strdup(): %s\n",
850                                   g_strerror(errno));
851                         *outbuf_p = '\0';
852                         break;
853                 }
854         }
855
856         iconv(cd, NULL, NULL, &outbuf_p, &out_left);
857         outbuf = g_realloc(outbuf, strlen(outbuf) + 1);
858
859         iconv_close(cd);
860
861         return outbuf;
862 }
863 #endif /* HAVE_ICONV */
864
865 static const struct {
866         CharSet charset;
867         gchar *const name;
868 } charsets[] = {
869         {C_US_ASCII,            CS_US_ASCII},
870         {C_US_ASCII,            CS_ANSI_X3_4_1968},
871         {C_UTF_8,               CS_UTF_8},
872         {C_ISO_8859_1,          CS_ISO_8859_1},
873         {C_ISO_8859_2,          CS_ISO_8859_2},
874         {C_ISO_8859_3,          CS_ISO_8859_3},
875         {C_ISO_8859_4,          CS_ISO_8859_4},
876         {C_ISO_8859_5,          CS_ISO_8859_5},
877         {C_ISO_8859_6,          CS_ISO_8859_6},
878         {C_ISO_8859_7,          CS_ISO_8859_7},
879         {C_ISO_8859_8,          CS_ISO_8859_8},
880         {C_ISO_8859_9,          CS_ISO_8859_9},
881         {C_ISO_8859_10,         CS_ISO_8859_10},
882         {C_ISO_8859_11,         CS_ISO_8859_11},
883         {C_ISO_8859_13,         CS_ISO_8859_13},
884         {C_ISO_8859_14,         CS_ISO_8859_14},
885         {C_ISO_8859_15,         CS_ISO_8859_15},
886         {C_BALTIC,              CS_BALTIC},
887         {C_CP1250,              CS_CP1250},
888         {C_CP1251,              CS_CP1251},
889         {C_CP1252,              CS_CP1252},
890         {C_CP1253,              CS_CP1253},
891         {C_CP1254,              CS_CP1254},
892         {C_CP1255,              CS_CP1255},
893         {C_CP1256,              CS_CP1256},
894         {C_CP1257,              CS_CP1257},
895         {C_CP1258,              CS_CP1258},
896         {C_WINDOWS_1250,        CS_WINDOWS_1250},
897         {C_WINDOWS_1251,        CS_WINDOWS_1251},
898         {C_WINDOWS_1252,        CS_WINDOWS_1252},
899         {C_WINDOWS_1253,        CS_WINDOWS_1253},
900         {C_WINDOWS_1254,        CS_WINDOWS_1254},
901         {C_WINDOWS_1255,        CS_WINDOWS_1255},
902         {C_WINDOWS_1256,        CS_WINDOWS_1256},
903         {C_WINDOWS_1257,        CS_WINDOWS_1257},
904         {C_WINDOWS_1258,        CS_WINDOWS_1258},
905         {C_KOI8_R,              CS_KOI8_R},
906         {C_KOI8_T,              CS_KOI8_T},
907         {C_KOI8_U,              CS_KOI8_U},
908         {C_ISO_2022_JP,         CS_ISO_2022_JP},
909         {C_ISO_2022_JP_2,       CS_ISO_2022_JP_2},
910         {C_EUC_JP,              CS_EUC_JP},
911         {C_EUC_JP,              CS_EUCJP},
912         {C_SHIFT_JIS,           CS_SHIFT_JIS},
913         {C_SHIFT_JIS,           CS_SHIFT__JIS},
914         {C_SHIFT_JIS,           CS_SJIS},
915         {C_ISO_2022_KR,         CS_ISO_2022_KR},
916         {C_EUC_KR,              CS_EUC_KR},
917         {C_ISO_2022_CN,         CS_ISO_2022_CN},
918         {C_EUC_CN,              CS_EUC_CN},
919         {C_GB2312,              CS_GB2312},
920         {C_GBK,                 CS_GBK},
921         {C_EUC_TW,              CS_EUC_TW},
922         {C_BIG5,                CS_BIG5},
923         {C_BIG5_HKSCS,          CS_BIG5_HKSCS},
924         {C_TIS_620,             CS_TIS_620},
925         {C_WINDOWS_874,         CS_WINDOWS_874},
926         {C_GEORGIAN_PS,         CS_GEORGIAN_PS},
927         {C_TCVN5712_1,          CS_TCVN5712_1},
928 };
929
930 static const struct {
931         gchar *const locale;
932         CharSet charset;
933         CharSet out_charset;
934 } locale_table[] = {
935         {"ja_JP.eucJP"  , C_EUC_JP      , C_ISO_2022_JP},
936         {"ja_JP.EUC-JP" , C_EUC_JP      , C_ISO_2022_JP},
937         {"ja_JP.EUC"    , C_EUC_JP      , C_ISO_2022_JP},
938         {"ja_JP.ujis"   , C_EUC_JP      , C_ISO_2022_JP},
939         {"ja_JP.SJIS"   , C_SHIFT_JIS   , C_ISO_2022_JP},
940         {"ja_JP.JIS"    , C_ISO_2022_JP , C_ISO_2022_JP},
941         {"ja_JP"        , C_EUC_JP      , C_ISO_2022_JP},
942         {"ko_KR.EUC-KR" , C_EUC_KR      , C_EUC_KR},
943         {"ko_KR"        , C_EUC_KR      , C_EUC_KR},
944         {"zh_CN.GB2312" , C_GB2312      , C_GB2312},
945         {"zh_CN.GBK"    , C_GBK         , C_GB2312},
946         {"zh_CN"        , C_GB2312      , C_GB2312},
947         {"zh_HK"        , C_BIG5_HKSCS  , C_BIG5_HKSCS},
948         {"zh_TW.eucTW"  , C_EUC_TW      , C_BIG5},
949         {"zh_TW.EUC-TW" , C_EUC_TW      , C_BIG5},
950         {"zh_TW.Big5"   , C_BIG5        , C_BIG5},
951         {"zh_TW"        , C_BIG5        , C_BIG5},
952
953         {"ru_RU.KOI8-R" , C_KOI8_R      , C_KOI8_R},
954         {"ru_RU.KOI8R"  , C_KOI8_R      , C_KOI8_R},
955         {"ru_RU.CP1251" , C_WINDOWS_1251, C_KOI8_R},
956         {"ru_RU"        , C_ISO_8859_5  , C_KOI8_R},
957         {"tg_TJ"        , C_KOI8_T      , C_KOI8_T},
958         {"ru_UA"        , C_KOI8_U      , C_KOI8_U},
959         {"uk_UA"        , C_KOI8_U      , C_KOI8_U},
960
961         {"be_BY"        , C_WINDOWS_1251, C_WINDOWS_1251},
962         {"bg_BG"        , C_WINDOWS_1251, C_WINDOWS_1251},
963
964         {"yi_US"        , C_WINDOWS_1255, C_WINDOWS_1255},
965
966         {"af_ZA"        , C_ISO_8859_1  , C_ISO_8859_1},
967         {"br_FR"        , C_ISO_8859_1  , C_ISO_8859_1},
968         {"ca_ES"        , C_ISO_8859_1  , C_ISO_8859_1},
969         {"da_DK"        , C_ISO_8859_1  , C_ISO_8859_1},
970         {"de_AT"        , C_ISO_8859_1  , C_ISO_8859_1},
971         {"de_BE"        , C_ISO_8859_1  , C_ISO_8859_1},
972         {"de_CH"        , C_ISO_8859_1  , C_ISO_8859_1},
973         {"de_DE"        , C_ISO_8859_1  , C_ISO_8859_1},
974         {"de_LU"        , C_ISO_8859_1  , C_ISO_8859_1},
975         {"en_AU"        , C_ISO_8859_1  , C_ISO_8859_1},
976         {"en_BW"        , C_ISO_8859_1  , C_ISO_8859_1},
977         {"en_CA"        , C_ISO_8859_1  , C_ISO_8859_1},
978         {"en_DK"        , C_ISO_8859_1  , C_ISO_8859_1},
979         {"en_GB"        , C_ISO_8859_1  , C_ISO_8859_1},
980         {"en_HK"        , C_ISO_8859_1  , C_ISO_8859_1},
981         {"en_IE"        , C_ISO_8859_1  , C_ISO_8859_1},
982         {"en_NZ"        , C_ISO_8859_1  , C_ISO_8859_1},
983         {"en_PH"        , C_ISO_8859_1  , C_ISO_8859_1},
984         {"en_SG"        , C_ISO_8859_1  , C_ISO_8859_1},
985         {"en_US"        , C_ISO_8859_1  , C_ISO_8859_1},
986         {"en_ZA"        , C_ISO_8859_1  , C_ISO_8859_1},
987         {"en_ZW"        , C_ISO_8859_1  , C_ISO_8859_1},
988         {"es_AR"        , C_ISO_8859_1  , C_ISO_8859_1},
989         {"es_BO"        , C_ISO_8859_1  , C_ISO_8859_1},
990         {"es_CL"        , C_ISO_8859_1  , C_ISO_8859_1},
991         {"es_CO"        , C_ISO_8859_1  , C_ISO_8859_1},
992         {"es_CR"        , C_ISO_8859_1  , C_ISO_8859_1},
993         {"es_DO"        , C_ISO_8859_1  , C_ISO_8859_1},
994         {"es_EC"        , C_ISO_8859_1  , C_ISO_8859_1},
995         {"es_ES"        , C_ISO_8859_1  , C_ISO_8859_1},
996         {"es_GT"        , C_ISO_8859_1  , C_ISO_8859_1},
997         {"es_HN"        , C_ISO_8859_1  , C_ISO_8859_1},
998         {"es_MX"        , C_ISO_8859_1  , C_ISO_8859_1},
999         {"es_NI"        , C_ISO_8859_1  , C_ISO_8859_1},
1000         {"es_PA"        , C_ISO_8859_1  , C_ISO_8859_1},
1001         {"es_PE"        , C_ISO_8859_1  , C_ISO_8859_1},
1002         {"es_PR"        , C_ISO_8859_1  , C_ISO_8859_1},
1003         {"es_PY"        , C_ISO_8859_1  , C_ISO_8859_1},
1004         {"es_SV"        , C_ISO_8859_1  , C_ISO_8859_1},
1005         {"es_US"        , C_ISO_8859_1  , C_ISO_8859_1},
1006         {"es_UY"        , C_ISO_8859_1  , C_ISO_8859_1},
1007         {"es_VE"        , C_ISO_8859_1  , C_ISO_8859_1},
1008         {"et_EE"        , C_ISO_8859_1  , C_ISO_8859_1},
1009         {"eu_ES"        , C_ISO_8859_1  , C_ISO_8859_1},
1010         {"fi_FI"        , C_ISO_8859_1  , C_ISO_8859_1},
1011         {"fo_FO"        , C_ISO_8859_1  , C_ISO_8859_1},
1012         {"fr_BE"        , C_ISO_8859_1  , C_ISO_8859_1},
1013         {"fr_CA"        , C_ISO_8859_1  , C_ISO_8859_1},
1014         {"fr_CH"        , C_ISO_8859_1  , C_ISO_8859_1},
1015         {"fr_FR"        , C_ISO_8859_1  , C_ISO_8859_1},
1016         {"fr_LU"        , C_ISO_8859_1  , C_ISO_8859_1},
1017         {"ga_IE"        , C_ISO_8859_1  , C_ISO_8859_1},
1018         {"gl_ES"        , C_ISO_8859_1  , C_ISO_8859_1},
1019         {"gv_GB"        , C_ISO_8859_1  , C_ISO_8859_1},
1020         {"id_ID"        , C_ISO_8859_1  , C_ISO_8859_1},
1021         {"is_IS"        , C_ISO_8859_1  , C_ISO_8859_1},
1022         {"it_CH"        , C_ISO_8859_1  , C_ISO_8859_1},
1023         {"it_IT"        , C_ISO_8859_1  , C_ISO_8859_1},
1024         {"kl_GL"        , C_ISO_8859_1  , C_ISO_8859_1},
1025         {"kw_GB"        , C_ISO_8859_1  , C_ISO_8859_1},
1026         {"ms_MY"        , C_ISO_8859_1  , C_ISO_8859_1},
1027         {"nl_BE"        , C_ISO_8859_1  , C_ISO_8859_1},
1028         {"nl_NL"        , C_ISO_8859_1  , C_ISO_8859_1},
1029         {"nn_NO"        , C_ISO_8859_1  , C_ISO_8859_1},
1030         {"no_NO"        , C_ISO_8859_1  , C_ISO_8859_1},
1031         {"oc_FR"        , C_ISO_8859_1  , C_ISO_8859_1},
1032         {"pt_BR"        , C_ISO_8859_1  , C_ISO_8859_1},
1033         {"pt_PT"        , C_ISO_8859_1  , C_ISO_8859_1},
1034         {"sq_AL"        , C_ISO_8859_1  , C_ISO_8859_1},
1035         {"sv_FI"        , C_ISO_8859_1  , C_ISO_8859_1},
1036         {"sv_SE"        , C_ISO_8859_1  , C_ISO_8859_1},
1037         {"tl_PH"        , C_ISO_8859_1  , C_ISO_8859_1},
1038         {"uz_UZ"        , C_ISO_8859_1  , C_ISO_8859_1},
1039         {"wa_BE"        , C_ISO_8859_1  , C_ISO_8859_1},
1040
1041         {"bs_BA"        , C_ISO_8859_2  , C_ISO_8859_2},
1042         {"cs_CZ"        , C_ISO_8859_2  , C_ISO_8859_2},
1043         {"hr_HR"        , C_ISO_8859_2  , C_ISO_8859_2},
1044         {"hu_HU"        , C_ISO_8859_2  , C_ISO_8859_2},
1045         {"pl_PL"        , C_ISO_8859_2  , C_ISO_8859_2},
1046         {"ro_RO"        , C_ISO_8859_2  , C_ISO_8859_2},
1047         {"sk_SK"        , C_ISO_8859_2  , C_ISO_8859_2},
1048         {"sl_SI"        , C_ISO_8859_2  , C_ISO_8859_2},
1049
1050         {"sr_YU@cyrillic"       , C_ISO_8859_5  , C_ISO_8859_5},
1051         {"sr_YU"                , C_ISO_8859_2  , C_ISO_8859_2},
1052
1053         {"mt_MT"                , C_ISO_8859_3  , C_ISO_8859_3},
1054
1055         {"lt_LT.iso88594"       , C_ISO_8859_4  , C_ISO_8859_4},
1056         {"lt_LT.ISO8859-4"      , C_ISO_8859_4  , C_ISO_8859_4},
1057         {"lt_LT.ISO_8859-4"     , C_ISO_8859_4  , C_ISO_8859_4},
1058         {"lt_LT"                , C_ISO_8859_13 , C_ISO_8859_13},
1059
1060         {"mk_MK"        , C_ISO_8859_5  , C_ISO_8859_5},
1061
1062         {"ar_AE"        , C_ISO_8859_6  , C_ISO_8859_6},
1063         {"ar_BH"        , C_ISO_8859_6  , C_ISO_8859_6},
1064         {"ar_DZ"        , C_ISO_8859_6  , C_ISO_8859_6},
1065         {"ar_EG"        , C_ISO_8859_6  , C_ISO_8859_6},
1066         {"ar_IQ"        , C_ISO_8859_6  , C_ISO_8859_6},
1067         {"ar_JO"        , C_ISO_8859_6  , C_ISO_8859_6},
1068         {"ar_KW"        , C_ISO_8859_6  , C_ISO_8859_6},
1069         {"ar_LB"        , C_ISO_8859_6  , C_ISO_8859_6},
1070         {"ar_LY"        , C_ISO_8859_6  , C_ISO_8859_6},
1071         {"ar_MA"        , C_ISO_8859_6  , C_ISO_8859_6},
1072         {"ar_OM"        , C_ISO_8859_6  , C_ISO_8859_6},
1073         {"ar_QA"        , C_ISO_8859_6  , C_ISO_8859_6},
1074         {"ar_SA"        , C_ISO_8859_6  , C_ISO_8859_6},
1075         {"ar_SD"        , C_ISO_8859_6  , C_ISO_8859_6},
1076         {"ar_SY"        , C_ISO_8859_6  , C_ISO_8859_6},
1077         {"ar_TN"        , C_ISO_8859_6  , C_ISO_8859_6},
1078         {"ar_YE"        , C_ISO_8859_6  , C_ISO_8859_6},
1079
1080         {"el_GR"        , C_ISO_8859_7  , C_ISO_8859_7},
1081         {"he_IL"        , C_ISO_8859_8  , C_ISO_8859_8},
1082         {"iw_IL"        , C_ISO_8859_8  , C_ISO_8859_8},
1083         {"tr_TR"        , C_ISO_8859_9  , C_ISO_8859_9},
1084
1085         {"lv_LV"        , C_ISO_8859_13 , C_ISO_8859_13},
1086         {"mi_NZ"        , C_ISO_8859_13 , C_ISO_8859_13},
1087
1088         {"cy_GB"        , C_ISO_8859_14 , C_ISO_8859_14},
1089
1090         {"ar_IN"        , C_UTF_8       , C_UTF_8},
1091         {"en_IN"        , C_UTF_8       , C_UTF_8},
1092         {"se_NO"        , C_UTF_8       , C_UTF_8},
1093         {"ta_IN"        , C_UTF_8       , C_UTF_8},
1094         {"te_IN"        , C_UTF_8       , C_UTF_8},
1095         {"ur_PK"        , C_UTF_8       , C_UTF_8},
1096
1097         {"th_TH"        , C_TIS_620     , C_TIS_620},
1098         /* {"th_TH"     , C_WINDOWS_874}, */
1099         /* {"th_TH"     , C_ISO_8859_11}, */
1100
1101         {"ka_GE"        , C_GEORGIAN_PS , C_GEORGIAN_PS},
1102         {"vi_VN.TCVN"   , C_TCVN5712_1  , C_TCVN5712_1},
1103
1104         {"C"                    , C_US_ASCII    , C_US_ASCII},
1105         {"POSIX"                , C_US_ASCII    , C_US_ASCII},
1106         {"ANSI_X3.4-1968"       , C_US_ASCII    , C_US_ASCII},
1107 };
1108
1109 static GHashTable *conv_get_charset_to_str_table(void)
1110 {
1111         static GHashTable *table;
1112         gint i;
1113
1114         if (table)
1115                 return table;
1116
1117         table = g_hash_table_new(NULL, g_direct_equal);
1118
1119         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
1120                 if (g_hash_table_lookup(table, GUINT_TO_POINTER(charsets[i].charset))
1121                     == NULL) {
1122                         g_hash_table_insert
1123                                 (table, GUINT_TO_POINTER(charsets[i].charset),
1124                                  charsets[i].name);
1125                 }
1126         }
1127
1128         return table;
1129 }
1130
1131 static gint str_case_equal(gconstpointer v, gconstpointer v2)
1132 {
1133         return strcasecmp((const gchar *)v, (const gchar *)v2) == 0;
1134 }
1135
1136 static guint str_case_hash(gconstpointer key)
1137 {
1138         const gchar *p = key;
1139         guint h = *p;
1140
1141         if (h) {
1142                 h = tolower(h);
1143                 for (p += 1; *p != '\0'; p++)
1144                         h = (h << 5) - h + tolower(*p);
1145         }
1146
1147         return h;
1148 }
1149
1150 static GHashTable *conv_get_charset_from_str_table(void)
1151 {
1152         static GHashTable *table;
1153         gint i;
1154
1155         if (table)
1156                 return table;
1157
1158         table = g_hash_table_new(str_case_hash, str_case_equal);
1159
1160         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
1161                 g_hash_table_insert(table, charsets[i].name,
1162                                     GUINT_TO_POINTER(charsets[i].charset));
1163         }
1164
1165         return table;
1166 }
1167
1168 const gchar *conv_get_charset_str(CharSet charset)
1169 {
1170         GHashTable *table;
1171
1172         table = conv_get_charset_to_str_table();
1173         return g_hash_table_lookup(table, GUINT_TO_POINTER(charset));
1174 }
1175
1176 CharSet conv_get_charset_from_str(const gchar *charset)
1177 {
1178         GHashTable *table;
1179
1180         if (!charset) return C_AUTO;
1181
1182         table = conv_get_charset_from_str_table();
1183         return GPOINTER_TO_UINT(g_hash_table_lookup(table, charset));
1184 }
1185
1186 CharSet conv_get_current_charset(void)
1187 {
1188         static CharSet cur_charset = -1;
1189         const gchar *cur_locale;
1190         const gchar *p;
1191         gint i;
1192
1193         if (cur_charset != -1)
1194                 return cur_charset;
1195
1196         cur_locale = conv_get_current_locale();
1197         if (!cur_locale) {
1198                 cur_charset = C_US_ASCII;
1199                 return cur_charset;
1200         }
1201
1202         if (strcasestr(cur_locale, "UTF-8")) {
1203                 cur_charset = C_UTF_8;
1204                 return cur_charset;
1205         }
1206
1207         if ((p = strcasestr(cur_locale, "@euro")) && p[5] == '\0') {
1208                 cur_charset = C_ISO_8859_15;
1209                 return cur_charset;
1210         }
1211
1212         for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
1213                 const gchar *p;
1214
1215                 /* "ja_JP.EUC" matches with "ja_JP.eucJP", "ja_JP.EUC" and
1216                    "ja_JP". "ja_JP" matches with "ja_JP.xxxx" and "ja" */
1217                 if (!strncasecmp(cur_locale, locale_table[i].locale,
1218                                  strlen(locale_table[i].locale))) {
1219                         cur_charset = locale_table[i].charset;
1220                         return cur_charset;
1221                 } else if ((p = strchr(locale_table[i].locale, '_')) &&
1222                          !strchr(p + 1, '.')) {
1223                         if (strlen(cur_locale) == 2 &&
1224                             !strncasecmp(cur_locale, locale_table[i].locale, 2)) {
1225                                 cur_charset = locale_table[i].charset;
1226                                 return cur_charset;
1227                         }
1228                 }
1229         }
1230
1231         cur_charset = C_AUTO;
1232         return cur_charset;
1233 }
1234
1235 const gchar *conv_get_current_charset_str(void)
1236 {
1237         static const gchar *codeset = NULL;
1238
1239         if (!codeset)
1240                 codeset = conv_get_charset_str(conv_get_current_charset());
1241
1242         return codeset ? codeset : CS_US_ASCII;
1243 }
1244
1245 CharSet conv_get_outgoing_charset(void)
1246 {
1247         static CharSet out_charset = -1;
1248         const gchar *cur_locale;
1249         const gchar *p;
1250         gint i;
1251
1252         if (out_charset != -1)
1253                 return out_charset;
1254
1255         cur_locale = conv_get_current_locale();
1256         if (!cur_locale) {
1257                 out_charset = C_AUTO;
1258                 return out_charset;
1259         }
1260
1261         if ((p = strcasestr(cur_locale, "@euro")) && p[5] == '\0') {
1262                 out_charset = C_ISO_8859_15;
1263                 return out_charset;
1264         }
1265
1266         for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
1267                 const gchar *p;
1268
1269                 if (!strncasecmp(cur_locale, locale_table[i].locale,
1270                                  strlen(locale_table[i].locale))) {
1271                         out_charset = locale_table[i].out_charset;
1272                         break;
1273                 } else if ((p = strchr(locale_table[i].locale, '_')) &&
1274                          !strchr(p + 1, '.')) {
1275                         if (strlen(cur_locale) == 2 &&
1276                             !strncasecmp(cur_locale, locale_table[i].locale, 2)) {
1277                                 out_charset = locale_table[i].out_charset;
1278                                 break;
1279                         }
1280                 }
1281         }
1282
1283 #if !HAVE_ICONV
1284         /* encoding conversion without iconv() is only supported
1285            on Japanese locale for now */
1286         if (out_charset == C_ISO_2022_JP)
1287                 return out_charset;
1288         else
1289                 return conv_get_current_charset();
1290 #endif
1291
1292         return out_charset;
1293 }
1294
1295 const gchar *conv_get_outgoing_charset_str(void)
1296 {
1297         CharSet out_charset;
1298         const gchar *str;
1299
1300         if (prefs_common.outgoing_charset) {
1301                 if (!isalpha(prefs_common.outgoing_charset[0])) {
1302                         g_free(prefs_common.outgoing_charset);
1303                         prefs_common.outgoing_charset = g_strdup(CS_AUTO);
1304                 } else if (strcmp(prefs_common.outgoing_charset, CS_AUTO) != 0)
1305                         return prefs_common.outgoing_charset;
1306         }
1307
1308         out_charset = conv_get_outgoing_charset();
1309         str = conv_get_charset_str(out_charset);
1310
1311         return str ? str : CS_US_ASCII;
1312 }
1313
1314 gboolean conv_is_multibyte_encoding(CharSet encoding)
1315 {
1316         switch (encoding) {
1317         case C_EUC_JP:
1318         case C_EUC_KR:
1319         case C_EUC_TW:
1320         case C_EUC_CN:
1321         case C_ISO_2022_JP:
1322         case C_ISO_2022_JP_2:
1323         case C_ISO_2022_KR:
1324         case C_ISO_2022_CN:
1325         case C_SHIFT_JIS:
1326         case C_GB2312:
1327         case C_BIG5:
1328         case C_UTF_8:
1329                 return TRUE;
1330         default:
1331                 return FALSE;
1332         }
1333 }
1334
1335 const gchar *conv_get_current_locale(void)
1336 {
1337         gchar *cur_locale;
1338
1339         cur_locale = g_getenv("LC_ALL");
1340         if (!cur_locale) cur_locale = g_getenv("LC_CTYPE");
1341         if (!cur_locale) cur_locale = g_getenv("LANG");
1342         if (!cur_locale) cur_locale = setlocale(LC_CTYPE, NULL);
1343
1344         debug_print("current locale: %s\n",
1345                     cur_locale ? cur_locale : "(none)");
1346
1347         return cur_locale;
1348 }
1349
1350 void conv_unmime_header_overwrite(gchar *str)
1351 {
1352         gchar *buf;
1353         gint buflen;
1354         CharSet cur_charset;
1355
1356         cur_charset = conv_get_current_charset();
1357
1358         if (cur_charset == C_EUC_JP) {
1359                 buflen = strlen(str) * 2 + 1;
1360                 Xalloca(buf, buflen, return);
1361                 conv_anytodisp(buf, buflen, str);
1362                 unmime_header(str, buf);
1363         } else {
1364                 buflen = strlen(str) + 1;
1365                 Xalloca(buf, buflen, return);
1366                 unmime_header(buf, str);
1367                 strncpy2(str, buf, buflen);
1368         }
1369 }
1370
1371 void conv_unmime_header(gchar *outbuf, gint outlen, const gchar *str,
1372                         const gchar *charset)
1373 {
1374         CharSet cur_charset;
1375
1376         cur_charset = conv_get_current_charset();
1377
1378         if (cur_charset == C_EUC_JP) {
1379                 gchar *buf;
1380                 gint buflen;
1381
1382                 buflen = strlen(str) * 2 + 1;
1383                 Xalloca(buf, buflen, return);
1384                 conv_anytodisp(buf, buflen, str);
1385                 unmime_header(outbuf, buf);
1386         } else
1387                 unmime_header(outbuf, str);
1388 }
1389
1390 #define MAX_LINELEN             76
1391 #define MAX_HARD_LINELEN        996
1392 #define MIMESEP_BEGIN           "=?"
1393 #define MIMESEP_END             "?="
1394
1395 #define B64LEN(len)     ((len) / 3 * 4 + ((len) % 3 ? 4 : 0))
1396
1397 #define LBREAK_IF_REQUIRED(cond, is_plain_text)                         \
1398 {                                                                       \
1399         if (len - (destp - dest) < MAX_LINELEN + 2) {                   \
1400                 *destp = '\0';                                          \
1401                 return;                                                 \
1402         }                                                               \
1403                                                                         \
1404         if ((cond) && *srcp) {                                          \
1405                 if (destp > dest && left < MAX_LINELEN - 1) {           \
1406                         if (isspace(*(destp - 1)))                      \
1407                                 destp--;                                \
1408                         else if (is_plain_text && isspace(*srcp))       \
1409                                 srcp++;                                 \
1410                         if (*srcp) {                                    \
1411                                 *destp++ = '\n';                        \
1412                                 *destp++ = ' ';                         \
1413                                 left = MAX_LINELEN - 1;                 \
1414                         }                                               \
1415                 }                                                       \
1416         }                                                               \
1417 }
1418
1419 void conv_encode_header(gchar *dest, gint len, const gchar *src,
1420                         gint header_len)
1421 {
1422         const gchar *cur_encoding;
1423         const gchar *out_encoding;
1424         gint mimestr_len;
1425         gchar *mimesep_enc;
1426         gint left;
1427         const gchar *srcp = src;
1428         gchar *destp = dest;
1429         gboolean use_base64;
1430
1431         if (MB_CUR_MAX > 1) {
1432                 use_base64 = TRUE;
1433                 mimesep_enc = "?B?";
1434         } else {
1435                 use_base64 = FALSE;
1436                 mimesep_enc = "?Q?";
1437         }
1438
1439         cur_encoding = conv_get_current_charset_str();
1440         if (!strcmp(cur_encoding, CS_US_ASCII))
1441                 cur_encoding = CS_ISO_8859_1;
1442         out_encoding = conv_get_outgoing_charset_str();
1443         if (!strcmp(out_encoding, CS_US_ASCII))
1444                 out_encoding = CS_ISO_8859_1;
1445
1446         mimestr_len = strlen(MIMESEP_BEGIN) + strlen(out_encoding) +
1447                 strlen(mimesep_enc) + strlen(MIMESEP_END);
1448
1449         left = MAX_LINELEN - header_len;
1450
1451         while (*srcp) {
1452                 LBREAK_IF_REQUIRED(left <= 0, TRUE);
1453
1454                 while (isspace(*srcp)) {
1455                         *destp++ = *srcp++;
1456                         left--;
1457                         LBREAK_IF_REQUIRED(left <= 0, TRUE);
1458                 }
1459
1460                 /* output as it is if the next word is ASCII string */
1461                 if (!is_next_nonascii(srcp)) {
1462                         gint word_len;
1463
1464                         word_len = get_next_word_len(srcp);
1465                         LBREAK_IF_REQUIRED(left < word_len, TRUE);
1466                         while (word_len > 0) {
1467                                 LBREAK_IF_REQUIRED(left + (MAX_HARD_LINELEN - MAX_LINELEN) <= 0, TRUE)
1468                                 *destp++ = *srcp++;
1469                                 left--;
1470                                 word_len--;
1471                         }
1472
1473                         continue;
1474                 }
1475
1476                 while (1) {
1477                         gint mb_len = 0;
1478                         gint cur_len = 0;
1479                         gchar *part_str;
1480                         gchar *out_str;
1481                         gchar *enc_str;
1482                         const gchar *p = srcp;
1483                         gint out_str_len;
1484                         gint out_enc_str_len;
1485                         gint mime_block_len;
1486                         gboolean cont = FALSE;
1487
1488                         while (*p != '\0') {
1489                                 if (isspace(*p) && !is_next_nonascii(p + 1))
1490                                         break;
1491
1492                                 if (MB_CUR_MAX > 1) {
1493                                         mb_len = mblen(p, MB_CUR_MAX);
1494                                         if (mb_len < 0) {
1495                                                 g_warning("conv_encode_header(): invalid multibyte character encountered\n");
1496                                                 mb_len = 1;
1497                                         }
1498                                 } else
1499                                         mb_len = 1;
1500
1501                                 Xstrndup_a(part_str, srcp, cur_len + mb_len, );
1502                                 out_str = conv_codeset_strdup
1503                                         (part_str, cur_encoding, out_encoding);
1504                                 if (!out_str) {
1505                                         g_warning("conv_encode_header(): code conversion failed\n");
1506                                         conv_unreadable_8bit(part_str);
1507                                         out_str = g_strdup(part_str);
1508                                 }
1509                                 out_str_len = strlen(out_str);
1510
1511                                 if (use_base64)
1512                                         out_enc_str_len = B64LEN(out_str_len);
1513                                 else
1514                                         out_enc_str_len =
1515                                                 qp_get_q_encoding_len(out_str);
1516
1517                                 g_free(out_str);
1518
1519                                 if (mimestr_len + out_enc_str_len <= left) {
1520                                         cur_len += mb_len;
1521                                         p += mb_len;
1522                                 } else if (cur_len == 0) {
1523                                         LBREAK_IF_REQUIRED(1, FALSE);
1524                                         continue;
1525                                 } else {
1526                                         cont = TRUE;
1527                                         break;
1528                                 }
1529                         }
1530
1531                         if (cur_len > 0) {
1532                                 Xstrndup_a(part_str, srcp, cur_len, );
1533                                 out_str = conv_codeset_strdup
1534                                         (part_str, cur_encoding, out_encoding);
1535                                 if (!out_str) {
1536                                         g_warning("conv_encode_header(): code conversion failed\n");
1537                                         conv_unreadable_8bit(part_str);
1538                                         out_str = g_strdup(part_str);
1539                                 }
1540                                 out_str_len = strlen(out_str);
1541
1542                                 if (use_base64)
1543                                         out_enc_str_len = B64LEN(out_str_len);
1544                                 else
1545                                         out_enc_str_len =
1546                                                 qp_get_q_encoding_len(out_str);
1547
1548                                 Xalloca(enc_str, out_enc_str_len + 1, );
1549                                 if (use_base64)
1550                                         base64_encode(enc_str, out_str, out_str_len);
1551                                 else
1552                                         qp_q_encode(enc_str, out_str);
1553
1554                                 g_free(out_str);
1555
1556                                 /* output MIME-encoded string block */
1557                                 mime_block_len = mimestr_len + strlen(enc_str);
1558                                 g_snprintf(destp, mime_block_len + 1,
1559                                            MIMESEP_BEGIN "%s%s%s" MIMESEP_END,
1560                                            out_encoding, mimesep_enc, enc_str);
1561                                 destp += mime_block_len;
1562                                 srcp += cur_len;
1563
1564                                 left -= mime_block_len;
1565                         }
1566
1567                         LBREAK_IF_REQUIRED(cont, FALSE);
1568
1569                         if (cur_len == 0)
1570                                 break;
1571                 }
1572         }
1573
1574         *destp = '\0';
1575 }
1576
1577 #undef LBREAK_IF_REQUIRED