src/codeconv.c

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