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 isunprintableeuckanji(c) \
  66         (((c) & 0xff) >= 0xa9 && ((c) & 0xff) <= 0xaf)
  67 #define issjiskanji1(c) \
  68         ((((c) & 0xff) >= 0x81 && ((c) & 0xff) <= 0x9f) || \
  69          (((c) & 0xff) >= 0xe0 && ((c) & 0xff) <= 0xfc))
  70 #define issjiskanji2(c) \
  71         ((((c) & 0xff) >= 0x40 && ((c) & 0xff) <= 0x7e) || \
  72          (((c) & 0xff) >= 0x80 && ((c) & 0xff) <= 0xfc))
  73 #define issjishwkana(c) \
  74         (((c) & 0xff) >= 0xa1 && ((c) & 0xff) <= 0xdf)
  75
  76 #define K_IN()                          \
  77         if (state != JIS_KANJI) {       \
  78                 *out++ = ESC;           \
  79                 *out++ = '$';           \
  80                 *out++ = 'B';           \
  81                 state = JIS_KANJI;      \
  82         }
  83
  84 #define K_OUT()                         \
  85         if (state != JIS_ASCII) {       \
  86                 *out++ = ESC;           \
  87                 *out++ = '(';           \
  88                 *out++ = 'B';           \
  89                 state = JIS_ASCII;      \
  90         }
  91
  92 #define HW_IN()                         \
  93         if (state != JIS_HWKANA) {      \
  94                 *out++ = ESC;           \
  95                 *out++ = '(';           \
  96                 *out++ = 'I';           \
  97                 state = JIS_HWKANA;     \
  98         }
  99
 100 #define AUX_IN()                        \
 101         if (state != JIS_AUXKANJI) {    \
 102                 *out++ = ESC;           \
 103                 *out++ = '$';           \
 104                 *out++ = '(';           \
 105                 *out++ = 'D';           \
 106                 state = JIS_AUXKANJI;   \
 107         }
 108
 109 void conv_jistoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
 110 {
 111         const guchar *in = inbuf;
 112         guchar *out = outbuf;
 113         JISState state = JIS_ASCII;
 114
 115         while (*in != '\0') {
 116                 if (*in == ESC) {
 117                         in++;
 118                         if (*in == '$') {
 119                                 if (*(in + 1) == '@' || *(in + 1) == 'B') {
 120                                         state = JIS_KANJI;
 121                                         in += 2;
 122                                 } else if (*(in + 1) == '(' &&
 123                                            *(in + 2) == 'D') {
 124                                         state = JIS_AUXKANJI;
 125                                         in += 3;
 126                                 } else {
 127                                         /* unknown escape sequence */
 128                                         state = JIS_ASCII;
 129                                 }
 130                         } else if (*in == '(') {
 131                                 if (*(in + 1) == 'B' || *(in + 1) == 'J') {
 132                                         state = JIS_ASCII;
 133                                         in += 2;
 134                                 } else if (*(in + 1) == 'I') {
 135                                         state = JIS_HWKANA;
 136                                         in += 2;
 137                                 } else {
 138                                         /* unknown escape sequence */
 139                                         state = JIS_ASCII;
 140                                 }
 141                         } else {
 142                                 /* unknown escape sequence */
 143                                 state = JIS_ASCII;
 144                         }
 145                 } else if (*in == 0x0e) {
 146                         state = JIS_HWKANA;
 147                         in++;
 148                 } else if (*in == 0x0f) {
 149                         state = JIS_ASCII;
 150                         in++;
 151                 } else {
 152                         switch (state) {
 153                         case JIS_ASCII:
 154                                 *out++ = *in++;
 155                                 break;
 156                         case JIS_KANJI:
 157                                 *out++ = *in++ | 0x80;
 158                                 if (*in == '\0') break;
 159                                 *out++ = *in++ | 0x80;
 160                                 break;
 161                         case JIS_HWKANA:
 162                                 *out++ = 0x8e;
 163                                 *out++ = *in++ | 0x80;
 164                                 break;
 165                         case JIS_AUXKANJI:
 166                                 *out++ = 0x8f;
 167                                 *out++ = *in++ | 0x80;
 168                                 if (*in == '\0') break;
 169                                 *out++ = *in++ | 0x80;
 170                                 break;
 171                         }
 172                 }
 173         }
 174
 175         *out = '\0';
 176 }
 177
 178 void conv_euctojis(gchar *outbuf, gint outlen, const gchar *inbuf)
 179 {
 180         const guchar *in = inbuf;
 181         guchar *out = outbuf;
 182         JISState state = JIS_ASCII;
 183
 184         while (*in != '\0') {
 185                 if (isascii(*in)) {
 186                         K_OUT();
 187                         *out++ = *in++;
 188                 } else if (iseuckanji(*in)) {
 189                         if (iseuckanji(*(in + 1))) {
 190                                 K_IN();
 191                                 *out++ = *in++ & 0x7f;
 192                                 *out++ = *in++ & 0x7f;
 193                         } else {
 194                                 K_OUT();
 195                                 *out++ = SUBST_CHAR;
 196                                 in++;
 197                                 if (*in != '\0' && !isascii(*in)) {
 198                                         *out++ = SUBST_CHAR;
 199                                         in++;
 200                                 }
 201                         }
 202                 } else if (iseuchwkana1(*in)) {
 203                         in++;
 204                         if (iseuchwkana2(*in)) {
 205                                 HW_IN();
 206                                 *out++ = *in++ & 0x7f;
 207                         } else {
 208                                 K_OUT();
 209                                 if (*in != '\0' && !isascii(*in)) {
 210                                         *out++ = SUBST_CHAR;
 211                                         in++;
 212                                 }
 213                         }
 214                 } else if (iseucaux(*in)) {
 215                         in++;
 216                         if (iseuckanji(*in) && iseuckanji(*(in + 1))) {
 217                                 AUX_IN();
 218                                 *out++ = *in++ & 0x7f;
 219                                 *out++ = *in++ & 0x7f;
 220                         } else {
 221                                 K_OUT();
 222                                 if (*in != '\0' && !isascii(*in)) {
 223                                         *out++ = SUBST_CHAR;
 224                                         in++;
 225                                         if (*in != '\0' && !isascii(*in)) {
 226                                                 *out++ = SUBST_CHAR;
 227                                                 in++;
 228                                         }
 229                                 }
 230                         }
 231                 } else {
 232                         K_OUT();
 233                         *out++ = SUBST_CHAR;
 234                         in++;
 235                 }
 236         }
 237
 238         K_OUT();
 239         *out = '\0';
 240 }
 241
 242 void conv_sjistoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
 243 {
 244         const guchar *in = inbuf;
 245         guchar *out = outbuf;
 246
 247         while (*in != '\0') {
 248                 if (isascii(*in)) {
 249                         *out++ = *in++;
 250                 } else if (issjiskanji1(*in)) {
 251                         if (issjiskanji2(*(in + 1))) {
 252                                 guchar out1 = *in;
 253                                 guchar out2 = *(in + 1);
 254                                 guchar row;
 255
 256                                 row = out1 < 0xa0 ? 0x70 : 0xb0;
 257                                 if (out2 < 0x9f) {
 258                                         out1 = (out1 - row) * 2 - 1;
 259                                         out2 -= out2 > 0x7f ? 0x20 : 0x1f;
 260                                 } else {
 261                                         out1 = (out1 - row) * 2;
 262                                         out2 -= 0x7e;
 263                                 }
 264
 265                                 *out++ = out1 | 0x80;
 266                                 *out++ = out2 | 0x80;
 267                                 in += 2;
 268                         } else {
 269                                 *out++ = SUBST_CHAR;
 270                                 in++;
 271                                 if (*in != '\0' && !isascii(*in)) {
 272                                         *out++ = SUBST_CHAR;
 273                                         in++;
 274                                 }
 275                         }
 276                 } else if (issjishwkana(*in)) {
 277                         *out++ = 0x8e;
 278                         *out++ = *in++;
 279                 } else {
 280                         *out++ = SUBST_CHAR;
 281                         in++;
 282                 }
 283         }
 284
 285         *out = '\0';
 286 }
 287
 288 void conv_anytoeuc(gchar *outbuf, gint outlen, const gchar *inbuf)
 289 {
 290         switch (conv_guess_encoding(inbuf)) {
 291         case C_ISO_2022_JP:
 292                 conv_jistoeuc(outbuf, outlen, inbuf);
 293                 break;
 294         case C_SHIFT_JIS:
 295                 conv_sjistoeuc(outbuf, outlen, inbuf);
 296                 break;
 297         default:
 298                 strncpy2(outbuf, inbuf, outlen);
 299                 break;
 300         }
 301 }
 302
 303 void conv_anytojis(gchar *outbuf, gint outlen, const gchar *inbuf)
 304 {
 305         switch (conv_guess_encoding(inbuf)) {
 306         case C_EUC_JP:
 307                 conv_euctojis(outbuf, outlen, inbuf);
 308                 break;
 309         default:
 310                 strncpy2(outbuf, inbuf, outlen);
 311                 break;
 312         }
 313 }
 314
 315 void conv_unreadable_eucjp(gchar *str)
 316 {
 317         register guchar *p = str;
 318
 319         while (*p != '\0') {
 320                 if (isascii(*p)) {
 321                         /* convert CR+LF -> LF */
 322                         if (*p == '\r' && *(p + 1) == '\n')
 323                                 memmove(p, p + 1, strlen(p));
 324                         /* printable 7 bit code */
 325                         p++;
 326                 } else if (iseuckanji(*p)) {
 327                         if (iseuckanji(*(p + 1)) && !isunprintableeuckanji(*p))
 328                                 /* printable euc-jp code */
 329                                 p += 2;
 330                         else {
 331                                 /* substitute unprintable code */
 332                                 *p++ = SUBST_CHAR;
 333                                 if (*p != '\0') {
 334                                         if (isascii(*p))
 335                                                 p++;
 336                                         else
 337                                                 *p++ = SUBST_CHAR;
 338                                 }
 339                         }
 340                 } else if (iseuchwkana1(*p)) {
 341                         if (iseuchwkana2(*(p + 1)))
 342                                 /* euc-jp hankaku kana */
 343                                 p += 2;
 344                         else
 345                                 *p++ = SUBST_CHAR;
 346                 } else if (iseucaux(*p)) {
 347                         if (iseuckanji(*(p + 1)) && iseuckanji(*(p + 2))) {
 348                                 /* auxiliary kanji */
 349                                 p += 3;
 350                         } else
 351                                 *p++ = SUBST_CHAR;
 352                 } else
 353                         /* substitute unprintable 1 byte code */
 354                         *p++ = SUBST_CHAR;
 355         }
 356 }
 357
 358 void conv_unreadable_8bit(gchar *str)
 359 {
 360         register guchar *p = str;
 361
 362         while (*p != '\0') {
 363                 /* convert CR+LF -> LF */
 364                 if (*p == '\r' && *(p + 1) == '\n')
 365                         memmove(p, p + 1, strlen(p));
 366                 else if (!isascii(*p)) *p = SUBST_CHAR;
 367                 p++;
 368         }
 369 }
 370
 371 void conv_unreadable_latin(gchar *str)
 372 {
 373         register guchar *p = str;
 374
 375         while (*p != '\0') {
 376                 /* convert CR+LF -> LF */
 377                 if (*p == '\r' && *(p + 1) == '\n')
 378                         memmove(p, p + 1, strlen(p));
 379                 else if ((*p & 0xff) >= 0x80 && (*p & 0xff) <= 0x9f)
 380                         *p = SUBST_CHAR;
 381                 p++;
 382         }
 383 }
 384
 385 #define NCV     '\0'
 386
 387 void conv_mb_alnum(gchar *str)
 388 {
 389         static guchar char_tbl[] = {
 390                 /* 0xa0 - 0xaf */
 391                 NCV, ' ', NCV, NCV, ',', '.', NCV, ':',
 392                 ';', '?', '!', NCV, NCV, NCV, NCV, NCV,
 393                 /* 0xb0 - 0xbf */
 394                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
 395                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
 396                 /* 0xc0 - 0xcf */
 397                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV,
 398                 NCV, NCV, '(', ')', NCV, NCV, '[', ']',
 399                 /* 0xd0 - 0xdf */
 400                 '{', '}', NCV, NCV, NCV, NCV, NCV, NCV,
 401                 NCV, NCV, NCV, NCV, '+', '-', NCV, NCV,
 402                 /* 0xe0 - 0xef */
 403                 NCV, '=', NCV, '<', '>', NCV, NCV, NCV,
 404                 NCV, NCV, NCV, NCV, NCV, NCV, NCV, NCV
 405         };
 406
 407         register guchar *p = str;
 408         register gint len;
 409
 410         len = strlen(str);
 411
 412         while (len > 1) {
 413                 if (*p == 0xa3) {
 414                         register guchar ch = *(p + 1);
 415
 416                         if (ch >= 0xb0 && ch <= 0xfa) {
 417                                 /* [a-zA-Z] */
 418                                 *p = ch & 0x7f;
 419                                 p++;
 420                                 len--;
 421                                 memmove(p, p + 1, len);
 422                                 len--;
 423                         } else  {
 424                                 p += 2;
 425                                 len -= 2;
 426                         }
 427                 } else if (*p == 0xa1) {
 428                         register guchar ch = *(p + 1);
 429
 430                         if (ch >= 0xa0 && ch <= 0xef &&
 431                             NCV != char_tbl[ch - 0xa0]) {
 432                                 *p = char_tbl[ch - 0xa0];
 433                                 p++;
 434                                 len--;
 435                                 memmove(p, p + 1, len);
 436                                 len--;
 437                         } else {
 438                                 p += 2;
 439                                 len -= 2;
 440                         }
 441                 } else if (iseuckanji(*p)) {
 442                         p += 2;
 443                         len -= 2;
 444                 } else {
 445                         p++;
 446                         len--;
 447                 }
 448         }
 449 }
 450
 451 CharSet conv_guess_encoding(const gchar *str)
 452 {
 453         const guchar *p = str;
 454         CharSet guessed = C_US_ASCII;
 455
 456         while (*p != '\0') {
 457                 if (*p == ESC && (*(p + 1) == '$' || *(p + 1) == '(')) {
 458                         if (guessed == C_US_ASCII)
 459                                 return C_ISO_2022_JP;
 460                         p += 2;
 461                 } else if (isascii(*p)) {
 462                         p++;
 463                 } else if (iseuckanji(*p) && iseuckanji(*(p + 1))) {
 464                         if (*p >= 0xfd && *p <= 0xfe)
 465                                 return C_EUC_JP;
 466                         else if (guessed == C_SHIFT_JIS) {
 467                                 if ((issjiskanji1(*p) &&
 468                                      issjiskanji2(*(p + 1))) ||
 469                                     issjishwkana(*p))
 470                                         guessed = C_SHIFT_JIS;
 471                                 else
 472                                         guessed = C_EUC_JP;
 473                         } else
 474                                 guessed = C_EUC_JP;
 475                         p += 2;
 476                 } else if (issjiskanji1(*p) && issjiskanji2(*(p + 1))) {
 477                         if (iseuchwkana1(*p) && iseuchwkana2(*(p + 1)))
 478                                 guessed = C_SHIFT_JIS;
 479                         else
 480                                 return C_SHIFT_JIS;
 481                         p += 2;
 482                 } else if (issjishwkana(*p)) {
 483                         guessed = C_SHIFT_JIS;
 484                         p++;
 485                 } else {
 486                         p++;
 487                 }
 488         }
 489
 490         return guessed;
 491 }
 492
 493 void conv_jistodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
 494 {
 495         conv_jistoeuc(outbuf, outlen, inbuf);
 496         conv_unreadable_eucjp(outbuf);
 497 }
 498
 499 void conv_sjistodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
 500 {
 501         conv_sjistoeuc(outbuf, outlen, inbuf);
 502         conv_unreadable_eucjp(outbuf);
 503 }
 504
 505 void conv_euctodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
 506 {
 507         strncpy2(outbuf, inbuf, outlen);
 508         conv_unreadable_eucjp(outbuf);
 509 }
 510
 511 void conv_anytodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
 512 {
 513         conv_anytoeuc(outbuf, outlen, inbuf);
 514         conv_unreadable_eucjp(outbuf);
 515 }
 516
 517 void conv_ustodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
 518 {
 519         strncpy2(outbuf, inbuf, outlen);
 520         conv_unreadable_8bit(outbuf);
 521 }
 522
 523 void conv_latintodisp(gchar *outbuf, gint outlen, const gchar *inbuf)
 524 {
 525         strncpy2(outbuf, inbuf, outlen);
 526         conv_unreadable_latin(outbuf);
 527 }
 528
 529 void conv_noconv(gchar *outbuf, gint outlen, const gchar *inbuf)
 530 {
 531         strncpy2(outbuf, inbuf, outlen);
 532 }
 533
 534 CodeConverter *conv_code_converter_new(const gchar *charset)
 535 {
 536         CodeConverter *conv;
 537
 538         conv = g_new0(CodeConverter, 1);
 539         conv->code_conv_func = conv_get_code_conv_func(charset, NULL);
 540         conv->charset_str = g_strdup(charset);
 541         conv->charset = conv_get_charset_from_str(charset);
 542
 543         return conv;
 544 }
 545
 546 void conv_code_converter_destroy(CodeConverter *conv)
 547 {
 548         g_free(conv->charset_str);
 549         g_free(conv);
 550 }
 551
 552 gint conv_convert(CodeConverter *conv, gchar *outbuf, gint outlen,
 553                   const gchar *inbuf)
 554 {
 555 #if HAVE_ICONV
 556         if (conv->code_conv_func != conv_noconv)
 557                 conv->code_conv_func(outbuf, outlen, inbuf);
 558         else {
 559                 gchar *str;
 560
 561                 str = conv_codeset_strdup(inbuf, conv->charset_str, NULL);
 562                 if (!str)
 563                         return -1;
 564                 else {
 565                         strncpy2(outbuf, str, outlen);
 566                         g_free(str);
 567                 }
 568         }
 569 #else /* !HAVE_ICONV */
 570         conv->code_conv_func(outbuf, outlen, inbuf);
 571 #endif
 572
 573         return 0;
 574 }
 575
 576 gchar *conv_codeset_strdup(const gchar *inbuf,
 577                            const gchar *src_code, const gchar *dest_code)
 578 {
 579         gchar *buf;
 580         size_t len;
 581         CodeConvFunc conv_func;
 582
 583         conv_func = conv_get_code_conv_func(src_code, dest_code);
 584         if (conv_func != conv_noconv) {
 585                 len = (strlen(inbuf) + 1) * 3;
 586                 buf = g_malloc(len);
 587                 if (!buf) return NULL;
 588
 589                 conv_func(buf, len, inbuf);
 590                 return g_realloc(buf, strlen(buf) + 1);
 591         }
 592
 593 #if HAVE_ICONV
 594         if (!src_code)
 595                 src_code = conv_get_outgoing_charset_str();
 596         if (!dest_code)
 597                 dest_code = conv_get_current_charset_str();
 598
 599         /* don't convert if current codeset is US-ASCII */
 600         if (!strcasecmp(dest_code, CS_US_ASCII))
 601                 return g_strdup(inbuf);
 602
 603         /* don't convert if src and dest codeset are identical */
 604         if (!strcasecmp(src_code, dest_code))
 605                 return g_strdup(inbuf);
 606
 607         return conv_iconv_strdup(inbuf, src_code, dest_code);
 608 #else
 609         return g_strdup(inbuf);
 610 #endif /* HAVE_ICONV */
 611 }
 612
 613 CodeConvFunc conv_get_code_conv_func(const gchar *src_charset_str,
 614                                      const gchar *dest_charset_str)
 615 {
 616         CodeConvFunc code_conv = conv_noconv;
 617         CharSet src_charset;
 618         CharSet dest_charset;
 619
 620         if (!src_charset_str)
 621                 src_charset = conv_get_current_charset();
 622         else
 623                 src_charset = conv_get_charset_from_str(src_charset_str);
 624
 625         /* auto detection mode */
 626         if (!src_charset_str && !dest_charset_str) {
 627                 if (src_charset == C_EUC_JP || src_charset == C_SHIFT_JIS)
 628                         return conv_anytodisp;
 629                 else
 630                         return conv_noconv;
 631         }
 632
 633         dest_charset = conv_get_charset_from_str(dest_charset_str);
 634
 635         switch (src_charset) {
 636         case C_ISO_2022_JP:
 637         case C_ISO_2022_JP_2:
 638                 if (dest_charset == C_AUTO)
 639                         code_conv = conv_jistodisp;
 640                 else if (dest_charset == C_EUC_JP)
 641                         code_conv = conv_jistoeuc;
 642                 break;
 643         case C_US_ASCII:
 644                 if (dest_charset == C_AUTO)
 645                         code_conv = conv_ustodisp;
 646                 break;
 647         case C_ISO_8859_1:
 648 #if !HAVE_ICONV
 649         case C_ISO_8859_2:
 650         case C_ISO_8859_4:
 651         case C_ISO_8859_5:
 652         case C_ISO_8859_7:
 653         case C_ISO_8859_8:
 654         case C_ISO_8859_9:
 655         case C_ISO_8859_11:
 656         case C_ISO_8859_13:
 657         case C_ISO_8859_15:
 658 #endif
 659                 if (dest_charset == C_AUTO)
 660                         code_conv = conv_latintodisp;
 661                 break;
 662         case C_SHIFT_JIS:
 663                 if (dest_charset == C_AUTO)
 664                         code_conv = conv_sjistodisp;
 665                 else if (dest_charset == C_EUC_JP)
 666                         code_conv = conv_sjistoeuc;
 667                 break;
 668         case C_EUC_JP:
 669                 if (dest_charset == C_AUTO)
 670                         code_conv = conv_euctodisp;
 671                 else if (dest_charset == C_ISO_2022_JP ||
 672                          dest_charset == C_ISO_2022_JP_2)
 673                         code_conv = conv_euctojis;
 674                 break;
 675         default:
 676                 break;
 677         }
 678
 679         return code_conv;
 680 }
 681
 682 #if HAVE_ICONV
 683 gchar *conv_iconv_strdup(const gchar *inbuf,
 684                          const gchar *src_code, const gchar *dest_code)
 685 {
 686         iconv_t cd;
 687         const gchar *inbuf_p;
 688         gchar *outbuf;
 689         gchar *outbuf_p;
 690         gint in_size;
 691         gint in_left;
 692         gint out_size;
 693         gint out_left;
 694         gint n_conv;
 695
 696         cd = iconv_open(dest_code, src_code);
 697         if (cd == (iconv_t)-1)
 698                 return NULL;
 699
 700         inbuf_p = inbuf;
 701         in_size = strlen(inbuf) + 1;
 702         in_left = in_size;
 703         out_size = in_size * 2;
 704         outbuf = g_malloc(out_size);
 705         outbuf_p = outbuf;
 706         out_left = out_size;
 707
 708         while ((n_conv = iconv(cd, (gchar **)&inbuf_p, &in_left,
 709                                &outbuf_p, &out_left)) < 0) {
 710                 if (EILSEQ == errno) {
 711                         *outbuf_p = '\0';
 712                         break;
 713                 } else if (EINVAL == errno) {
 714                         *outbuf_p = '\0';
 715                         break;
 716                 } else if (E2BIG == errno) {
 717                         out_size *= 2;
 718                         outbuf = g_realloc(outbuf, out_size);
 719                         inbuf_p = inbuf;
 720                         in_left = in_size;
 721                         outbuf_p = outbuf;
 722                         out_left = out_size;
 723                 } else {
 724                         g_warning("conv_iconv_strdup(): %s\n",
 725                                   g_strerror(errno));
 726                         *outbuf_p = '\0';
 727                         break;
 728                 }
 729         }
 730
 731         iconv_close(cd);
 732
 733         return outbuf;
 734 }
 735 #endif /* HAVE_ICONV */
 736
 737 static const struct {
 738         CharSet charset;
 739         gchar *const name;
 740 } charsets[] = {
 741         {C_US_ASCII,            CS_US_ASCII},
 742         {C_US_ASCII,            CS_ANSI_X3_4_1968},
 743         {C_UTF_8,               CS_UTF_8},
 744         {C_ISO_8859_1,          CS_ISO_8859_1},
 745         {C_ISO_8859_2,          CS_ISO_8859_2},
 746         {C_ISO_8859_4,          CS_ISO_8859_4},
 747         {C_ISO_8859_5,          CS_ISO_8859_5},
 748         {C_ISO_8859_7,          CS_ISO_8859_7},
 749         {C_ISO_8859_8,          CS_ISO_8859_8},
 750         {C_ISO_8859_9,          CS_ISO_8859_9},
 751         {C_ISO_8859_11,         CS_ISO_8859_11},
 752         {C_ISO_8859_13,         CS_ISO_8859_13},
 753         {C_ISO_8859_15,         CS_ISO_8859_15},
 754         {C_BALTIC,              CS_BALTIC},
 755         {C_CP1251,              CS_CP1251},
 756         {C_WINDOWS_1251,        CS_WINDOWS_1251},
 757         {C_KOI8_R,              CS_KOI8_R},
 758         {C_KOI8_U,              CS_KOI8_U},
 759         {C_ISO_2022_JP,         CS_ISO_2022_JP},
 760         {C_ISO_2022_JP_2,       CS_ISO_2022_JP_2},
 761         {C_EUC_JP,              CS_EUC_JP},
 762         {C_EUC_JP,              CS_EUCJP},
 763         {C_SHIFT_JIS,           CS_SHIFT_JIS},
 764         {C_SHIFT_JIS,           CS_SHIFT__JIS},
 765         {C_SHIFT_JIS,           CS_SJIS},
 766         {C_ISO_2022_KR,         CS_ISO_2022_KR},
 767         {C_EUC_KR,              CS_EUC_KR},
 768         {C_ISO_2022_CN,         CS_ISO_2022_CN},
 769         {C_EUC_CN,              CS_EUC_CN},
 770         {C_GB2312,              CS_GB2312},
 771         {C_EUC_TW,              CS_EUC_TW},
 772         {C_BIG5,                CS_BIG5},
 773         {C_TIS_620,             CS_TIS_620},
 774         {C_WINDOWS_874,         CS_WINDOWS_874},
 775 };
 776
 777 static const struct {
 778         gchar *const locale;
 779         CharSet charset;
 780         CharSet out_charset;
 781 } locale_table[] = {
 782         {"ja_JP.eucJP"  , C_EUC_JP      , C_ISO_2022_JP},
 783         {"ja_JP.ujis"   , C_EUC_JP      , C_ISO_2022_JP},
 784         {"ja_JP.EUC"    , C_EUC_JP      , C_ISO_2022_JP},
 785         {"ja_JP.SJIS"   , C_SHIFT_JIS   , C_ISO_2022_JP},
 786         {"ja_JP.JIS"    , C_ISO_2022_JP , C_ISO_2022_JP},
 787         {"ja_JP"        , C_EUC_JP      , C_ISO_2022_JP},
 788         {"ko_KR"        , C_EUC_KR      , C_EUC_KR},
 789         {"zh_CN.GB2312" , C_GB2312      , C_GB2312},
 790         {"zh_CN"        , C_GB2312      , C_GB2312},
 791         {"zh_TW.eucTW"  , C_EUC_TW      , C_BIG5},
 792         {"zh_TW.Big5"   , C_BIG5        , C_BIG5},
 793         {"zh_TW"        , C_BIG5        , C_BIG5},
 794
 795         {"ru_RU.KOI8-R" , C_KOI8_R      , C_KOI8_R},
 796         {"ru_RU.CP1251" , C_WINDOWS_1251, C_KOI8_R},
 797         {"ru_RU"        , C_ISO_8859_5  , C_KOI8_R},
 798         {"ru_UA"        , C_KOI8_U      , C_KOI8_U},
 799         {"uk_UA"        , C_KOI8_U      , C_KOI8_U},
 800         {"be_BY"        , C_WINDOWS_1251, C_WINDOWS_1251},
 801         {"bg_BG"        , C_WINDOWS_1251, C_WINDOWS_1251},
 802
 803         {"en_US"        , C_ISO_8859_1  , C_ISO_8859_1},
 804         {"ca_ES"        , C_ISO_8859_1  , C_ISO_8859_1},
 805         {"da_DK"        , C_ISO_8859_1  , C_ISO_8859_1},
 806         {"de_DE"        , C_ISO_8859_1  , C_ISO_8859_1},
 807         {"nl_NL"        , C_ISO_8859_1  , C_ISO_8859_1},
 808         {"et_EE"        , C_ISO_8859_1  , C_ISO_8859_1},
 809         {"fi_FI"        , C_ISO_8859_1  , C_ISO_8859_1},
 810         {"fr_FR"        , C_ISO_8859_1  , C_ISO_8859_1},
 811         {"is_IS"        , C_ISO_8859_1  , C_ISO_8859_1},
 812         {"it_IT"        , C_ISO_8859_1  , C_ISO_8859_1},
 813         {"no_NO"        , C_ISO_8859_1  , C_ISO_8859_1},
 814         {"pt_PT"        , C_ISO_8859_1  , C_ISO_8859_1},
 815         {"pt_BR"        , C_ISO_8859_1  , C_ISO_8859_1},
 816         {"es_ES"        , C_ISO_8859_1  , C_ISO_8859_1},
 817         {"sv_SE"        , C_ISO_8859_1  , C_ISO_8859_1},
 818
 819         {"hr_HR"        , C_ISO_8859_2  , C_ISO_8859_2},
 820         {"hu_HU"        , C_ISO_8859_2  , C_ISO_8859_2},
 821         {"pl_PL"        , C_ISO_8859_2  , C_ISO_8859_2},
 822         {"ro_RO"        , C_ISO_8859_2  , C_ISO_8859_2},
 823         {"sk_SK"        , C_ISO_8859_2  , C_ISO_8859_2},
 824         {"sl_SI"        , C_ISO_8859_2  , C_ISO_8859_2},
 825         {"el_GR"        , C_ISO_8859_7  , C_ISO_8859_7},
 826         {"iw_IL"        , C_ISO_8859_8  , C_ISO_8859_8},
 827         {"tr_TR"        , C_ISO_8859_9  , C_ISO_8859_9},
 828
 829         {"th_TH"        , C_TIS_620     , C_TIS_620},
 830         /* {"th_TH"     , C_WINDOWS_874}, */
 831         /* {"th_TH"     , C_ISO_8859_11}, */
 832
 833         {"lt_LT.iso88594"       , C_ISO_8859_4  , C_ISO_8859_4},
 834         {"lt_LT.ISO8859-4"      , C_ISO_8859_4  , C_ISO_8859_4},
 835         {"lt_LT.ISO_8859-4"     , C_ISO_8859_4  , C_ISO_8859_4},
 836         {"lt_LT"                , C_ISO_8859_13 , C_ISO_8859_13},
 837         {"lv_LV"                , C_ISO_8859_13 , C_ISO_8859_13},
 838
 839         {"C"                    , C_US_ASCII    , C_US_ASCII},
 840         {"POSIX"                , C_US_ASCII    , C_US_ASCII},
 841         {"ANSI_X3.4-1968"       , C_US_ASCII    , C_US_ASCII},
 842 };
 843
 844 const gchar *conv_get_charset_str(CharSet charset)
 845 {
 846         gint i;
 847
 848         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
 849                 if (charsets[i].charset == charset)
 850                         return charsets[i].name;
 851         }
 852
 853         return NULL;
 854 }
 855
 856 CharSet conv_get_charset_from_str(const gchar *charset)
 857 {
 858         gint i;
 859
 860         if (!charset) return C_AUTO;
 861
 862         for (i = 0; i < sizeof(charsets) / sizeof(charsets[0]); i++) {
 863                 if (!strcasecmp(charsets[i].name, charset))
 864                         return charsets[i].charset;
 865         }
 866
 867         return C_AUTO;
 868 }
 869
 870 CharSet conv_get_current_charset(void)
 871 {
 872         static CharSet cur_charset = -1;
 873         const gchar *cur_locale;
 874         gint i;
 875
 876         if (cur_charset != -1)
 877                 return cur_charset;
 878
 879         cur_locale = conv_get_current_locale();
 880         if (!cur_locale) {
 881                 cur_charset = C_US_ASCII;
 882                 return cur_charset;
 883         }
 884
 885         if (strcasestr(cur_locale, "UTF-8")) {
 886                 cur_charset = C_UTF_8;
 887                 return cur_charset;
 888         }
 889
 890         for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
 891                 const gchar *p;
 892
 893                 /* "ja_JP.EUC" matches with "ja_JP.eucJP", "ja_JP.EUC" and
 894                    "ja_JP". "ja_JP" matches with "ja_JP.xxxx" and "ja" */
 895                 if (!strncasecmp(cur_locale, locale_table[i].locale,
 896                                  strlen(locale_table[i].locale))) {
 897                         cur_charset = locale_table[i].charset;
 898                         return cur_charset;
 899                 } else if ((p = strchr(locale_table[i].locale, '_')) &&
 900                          !strchr(p + 1, '.')) {
 901                         if (strlen(cur_locale) == 2 &&
 902                             !strncasecmp(cur_locale, locale_table[i].locale, 2)) {
 903                                 cur_charset = locale_table[i].charset;
 904                                 return cur_charset;
 905                         }
 906                 }
 907         }
 908
 909         cur_charset = C_AUTO;
 910         return cur_charset;
 911 }
 912
 913 const gchar *conv_get_current_charset_str(void)
 914 {
 915         static const gchar *codeset = NULL;
 916
 917         if (!codeset)
 918                 codeset = conv_get_charset_str(conv_get_current_charset());
 919
 920         return codeset ? codeset : "US-ASCII";
 921 }
 922
 923 CharSet conv_get_outgoing_charset(void)
 924 {
 925         static CharSet out_charset = -1;
 926         const gchar *cur_locale;
 927         gint i;
 928
 929         if (out_charset != -1)
 930                 return out_charset;
 931
 932         cur_locale = conv_get_current_locale();
 933         if (!cur_locale) {
 934                 out_charset = C_AUTO;
 935                 return out_charset;
 936         }
 937
 938         for (i = 0; i < sizeof(locale_table) / sizeof(locale_table[0]); i++) {
 939                 const gchar *p;
 940
 941                 if (!strncasecmp(cur_locale, locale_table[i].locale,
 942                                  strlen(locale_table[i].locale))) {
 943                         out_charset = locale_table[i].out_charset;
 944                         break;
 945                 } else if ((p = strchr(locale_table[i].locale, '_')) &&
 946                          !strchr(p + 1, '.')) {
 947                         if (strlen(cur_locale) == 2 &&
 948                             !strncasecmp(cur_locale, locale_table[i].locale, 2)) {
 949                                 out_charset = locale_table[i].out_charset;
 950                                 break;
 951                         }
 952                 }
 953         }
 954
 955 #if !HAVE_ICONV
 956         /* encoding conversion without iconv() is only supported
 957            on Japanese locale for now */
 958         if (out_charset == C_ISO_2022_JP)
 959                 return out_charset;
 960         else
 961                 return conv_get_current_charset();
 962 #endif
 963
 964         return out_charset;
 965 }
 966
 967 const gchar *conv_get_outgoing_charset_str(void)
 968 {
 969         CharSet out_charset;
 970         const gchar *str;
 971
 972         if (prefs_common.outgoing_charset) {
 973                 if (!isalpha(prefs_common.outgoing_charset[0])) {
 974                         g_free(prefs_common.outgoing_charset);
 975                         prefs_common.outgoing_charset = g_strdup(CS_AUTO);
 976                 } else if (strcmp(prefs_common.outgoing_charset, CS_AUTO) != 0)
 977                         return prefs_common.outgoing_charset;
 978         }
 979
 980         out_charset = conv_get_outgoing_charset();
 981         str = conv_get_charset_str(out_charset);
 982
 983         return str ? str : "US-ASCII";
 984 }
 985
 986 const gchar *conv_get_current_locale(void)
 987 {
 988         gchar *cur_locale;
 989
 990         cur_locale = g_getenv("LC_ALL");
 991         if (!cur_locale) cur_locale = g_getenv("LC_CTYPE");
 992         if (!cur_locale) cur_locale = g_getenv("LANG");
 993         if (!cur_locale) cur_locale = setlocale(LC_CTYPE, NULL);
 994
 995         debug_print("current locale: %s\n",
 996                     cur_locale ? cur_locale : "(none)");
 997
 998         return cur_locale;
 999 }
1000
1001 void conv_unmime_header_overwrite(gchar *str)
1002 {
1003         gchar *buf;
1004         gint buflen;
1005         CharSet cur_charset;
1006
1007         cur_charset = conv_get_current_charset();
1008
1009         if (cur_charset == C_EUC_JP) {
1010                 buflen = strlen(str) * 2 + 1;
1011                 Xalloca(buf, buflen, return);
1012                 conv_anytodisp(buf, buflen, str);
1013                 unmime_header(str, buf);
1014         } else {
1015                 buflen = strlen(str) + 1;
1016                 Xalloca(buf, buflen, return);
1017                 unmime_header(buf, str);
1018                 strncpy2(str, buf, buflen);
1019         }
1020 }
1021
1022 void conv_unmime_header(gchar *outbuf, gint outlen, const gchar *str,
1023                         const gchar *charset)
1024 {
1025         CharSet cur_charset;
1026
1027         cur_charset = conv_get_current_charset();
1028
1029         if (cur_charset == C_EUC_JP) {
1030                 gchar *buf;
1031                 gint buflen;
1032
1033                 buflen = strlen(str) * 2 + 1;
1034                 Xalloca(buf, buflen, return);
1035                 conv_anytodisp(buf, buflen, str);
1036                 unmime_header(outbuf, buf);
1037         } else
1038                 unmime_header(outbuf, str);
1039 }
1040
1041 #define MAX_LINELEN     76
1042 #define MIMESEP_BEGIN   "=?"
1043 #define MIMESEP_END     "?="
1044
1045 #define B64LEN(len)     ((len) / 3 * 4 + ((len) % 3 ? 4 : 0))
1046
1047 #define LBREAK_IF_REQUIRED(cond, plaintext)                     \
1048 {                                                               \
1049         if (len - (destp - dest) < MAX_LINELEN + 2) {           \
1050                 *destp = '\0';                                  \
1051                 return;                                         \
1052         }                                                       \
1053                                                                 \
1054         if ((cond) && *srcp) {                                  \
1055                 if (destp > dest && isspace(*(destp - 1)))      \
1056                         destp--;                                \
1057                 else if (plaintext && isspace(*srcp))           \
1058                         srcp++;                                 \
1059                 if (*srcp) {                                    \
1060                         *destp++ = '\n';                        \
1061                         *destp++ = ' ';                         \
1062                         left = MAX_LINELEN - 1;                 \
1063                 }                                               \
1064         }                                                       \
1065 }
1066
1067 void conv_encode_header(gchar *dest, gint len, const gchar *src,
1068                         gint header_len)
1069 {
1070         const gchar *cur_encoding;
1071         const gchar *out_encoding;
1072         gint mimestr_len;
1073         gchar *mimesep_enc;
1074         gint left;
1075         const gchar *srcp = src;
1076         gchar *destp = dest;
1077         gboolean use_base64;
1078
1079         if (MB_CUR_MAX > 1) {
1080                 use_base64 = TRUE;
1081                 mimesep_enc = "?B?";
1082         } else {
1083                 use_base64 = FALSE;
1084                 mimesep_enc = "?Q?";
1085         }
1086
1087         cur_encoding = conv_get_current_charset_str();
1088         if (!strcmp(cur_encoding, "US-ASCII"))
1089                 cur_encoding = "ISO-8859-1";
1090         out_encoding = conv_get_outgoing_charset_str();
1091         if (!strcmp(out_encoding, "US-ASCII"))
1092                 out_encoding = "ISO-8859-1";
1093
1094         mimestr_len = strlen(MIMESEP_BEGIN) + strlen(out_encoding) +
1095                 strlen(mimesep_enc) + strlen(MIMESEP_END);
1096
1097         left = MAX_LINELEN - header_len;
1098
1099         while (*srcp) {
1100                 LBREAK_IF_REQUIRED(left <= 0, TRUE);
1101
1102                 while (isspace(*srcp)) {
1103                         *destp++ = *srcp++;
1104                         left--;
1105                         LBREAK_IF_REQUIRED(left <= 0, TRUE);
1106                 }
1107
1108                 /* output as it is if the next word is ASCII string */
1109                 if (!is_next_nonascii(srcp)) {
1110                         gint word_len;
1111
1112                         word_len = get_next_word_len(srcp);
1113                         LBREAK_IF_REQUIRED(left < word_len, TRUE);
1114                         while (word_len > 0) {
1115                                 LBREAK_IF_REQUIRED(left <= 0, TRUE);
1116                                 *destp++ = *srcp++;
1117                                 left--;
1118                                 word_len--;
1119                         }
1120
1121                         continue;
1122                 }
1123
1124                 while (1) {
1125                         gint mb_len = 0;
1126                         gint cur_len = 0;
1127                         gchar *part_str;
1128                         gchar *out_str;
1129                         gchar *enc_str;
1130                         const gchar *p = srcp;
1131                         gint out_str_len;
1132                         gint out_enc_str_len;
1133                         gint mime_block_len;
1134                         gboolean cont = FALSE;
1135
1136                         while (*p != '\0') {
1137                                 if (isspace(*p) && !is_next_nonascii(p + 1))
1138                                         break;
1139
1140                                 if (MB_CUR_MAX > 1) {
1141                                         mb_len = mblen(p, MB_CUR_MAX);
1142                                         if (mb_len < 0) {
1143                                                 g_warning("conv_encode_header(): invalid multibyte character encountered\n");
1144                                                 mb_len = 1;
1145                                         }
1146                                 } else
1147                                         mb_len = 1;
1148
1149                                 Xstrndup_a(part_str, srcp, cur_len + mb_len, );
1150                                 out_str = conv_codeset_strdup
1151                                         (part_str, cur_encoding, out_encoding);
1152                                 if (!out_str) {
1153                                         g_warning("conv_encode_header(): code conversion failed\n");
1154                                         out_str = g_strdup(out_str);
1155                                 }
1156                                 out_str_len = strlen(out_str);
1157
1158                                 if (use_base64)
1159                                         out_enc_str_len = B64LEN(out_str_len);
1160                                 else
1161                                         out_enc_str_len =
1162                                                 qp_get_q_encoding_len(out_str);
1163
1164                                 g_free(out_str);
1165
1166                                 if (mimestr_len + out_enc_str_len <= left) {
1167                                         cur_len += mb_len;
1168                                         p += mb_len;
1169                                 } else if (cur_len == 0) {
1170                                         LBREAK_IF_REQUIRED(1, FALSE);
1171                                         continue;
1172                                 } else {
1173                                         cont = TRUE;
1174                                         break;
1175                                 }
1176                         }
1177
1178                         if (cur_len > 0) {
1179                                 Xstrndup_a(part_str, srcp, cur_len, );
1180                                 out_str = conv_codeset_strdup
1181                                         (part_str, cur_encoding, out_encoding);
1182                                 if (!out_str) {
1183                                         g_warning("conv_encode_header(): code conversion failed\n");
1184                                         out_str = g_strdup(out_str);
1185                                 }
1186                                 out_str_len = strlen(out_str);
1187
1188                                 if (use_base64)
1189                                         out_enc_str_len = B64LEN(out_str_len);
1190                                 else
1191                                         out_enc_str_len =
1192                                                 qp_get_q_encoding_len(out_str);
1193
1194                                 Xalloca(enc_str, out_enc_str_len + 1, );
1195                                 if (use_base64)
1196                                         base64_encode(enc_str, out_str, out_str_len);
1197                                 else
1198                                         qp_q_encode(enc_str, out_str);
1199
1200                                 g_free(out_str);
1201
1202                                 /* output MIME-encoded string block */
1203                                 mime_block_len = mimestr_len + strlen(enc_str);
1204                                 g_snprintf(destp, mime_block_len + 1,
1205                                            MIMESEP_BEGIN "%s%s%s" MIMESEP_END,
1206                                            out_encoding, mimesep_enc, enc_str);
1207                                 destp += mime_block_len;
1208                                 srcp += cur_len;
1209
1210                                 left -= mime_block_len;
1211                         }
1212
1213                         LBREAK_IF_REQUIRED(cont, FALSE);
1214
1215                         if (cur_len == 0)
1216                                 break;
1217                 }
1218         }
1219
1220         *destp = '\0';
1221 }
1222
1223 #undef LBREAK_IF_REQUIRED