libs/Ficonv.c

   1 /* -*-c-*- */
   2 /* Copyright (C) 2002  Olivier Chapuis */
   3 /* This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 /* Some code (convert_charsets) inspired by the glib-2 (gutf8.c) copyrighted
  19  * by Tom Tromey & Red Hat, Inc. */
  20
  21 /* ---------------------------- included header files ---------------------- */
  22
  23 #include "config.h"
  24 #include <stdio.h>
  25 #include <errno.h>
  26
  27 #include <X11/Xlib.h>
  28
  29 #include "FlocaleCharset.h"
  30 #include "Ficonv.h"
  31
  32 #if FiconvSupport
  33 #include <iconv.h>
  34
  35 #if defined(USE_LIBICONV) && !defined (_LIBICONV_H)
  36 #error libiconv in use but included iconv.h not from libiconv
  37 #endif
  38 #if !defined(USE_LIBICONV) && defined (_LIBICONV_H)
  39 #error libiconv not in use but included iconv.h is from libiconv
  40 #endif
  41 #endif /* FiconvSupport */
  42
  43 /* ---------------------------- local definitions -------------------------- */
  44
  45 /* ---------------------------- local macros ------------------------------- */
  46
  47 /* ---------------------------- imports ------------------------------------ */
  48
  49 /* ---------------------------- included code files ------------------------ */
  50
  51 /* ---------------------------- local types -------------------------------- */
  52
  53 /* ---------------------------- forward declarations ----------------------- */
  54
  55 /* ---------------------------- local variables ---------------------------- */
  56
  57 static Bool FiconvInitialized = False;
  58 static FlocaleCharset *FLCIconvUtf8Charset = NULL;       /* UTF-8 charset */
  59 static FlocaleCharset *FLCIconvDefaultCharset = NULL;
  60
  61 /* ---------------------------- exported variables (globals) --------------- */
  62
  63 /* ---------------------------- local functions ---------------------------- */
  64
  65 static
  66 Bool is_iconv_supported(char *c1, char *c2)
  67 {
  68         Ficonv_t cd1,cd2;
  69         Bool r = False;
  70         int dummy;
  71
  72         if (!FiconvSupport || !c1 || !c2)
  73                 return False;
  74
  75         cd1 = Ficonv_open(c1, c2);
  76         cd2 = Ficonv_open(c2, c1);
  77         if (cd1 != (Ficonv_t) -1 && cd2 != (Ficonv_t) -1)
  78                 r = True;
  79         if (cd1 != (Ficonv_t) -1)
  80                 dummy = Ficonv_close(cd1);
  81         if (cd2 != (Ficonv_t) -1)
  82                 dummy = Ficonv_close(cd2);
  83         return r;
  84 }
  85
  86 static
  87 int set_default_iconv_charsets(FlocaleCharset *fc)
  88 {
  89         int i=0,j=0;
  90
  91         if (!FiconvSupport || FLCIconvUtf8Charset == NULL || fc == NULL)
  92                 return False;
  93
  94         while(FLC_GET_LOCALE_CHARSET(FLCIconvUtf8Charset,i) != NULL)
  95         {
  96                 j = 0;
  97                 while(FLC_GET_LOCALE_CHARSET(fc,j) != NULL)
  98                 {
  99                         if (is_iconv_supported(
 100                                   FLC_GET_LOCALE_CHARSET(
 101                                           FLCIconvUtf8Charset,i),
 102                                   FLC_GET_LOCALE_CHARSET(fc,j)))
 103                         {
 104                                 FLC_SET_ICONV_INDEX(FLCIconvUtf8Charset,i);
 105                                 FLC_SET_ICONV_INDEX(fc,j);
 106                                 return 1;
 107                         }
 108                         j++;
 109                 }
 110                 i++;
 111         }
 112         FLC_SET_ICONV_INDEX(FLCIconvUtf8Charset,
 113                             FLC_INDEX_ICONV_CHARSET_NOT_FOUND);
 114         FLC_SET_ICONV_INDEX(fc, FLC_INDEX_ICONV_CHARSET_NOT_FOUND);
 115         return 0;
 116 }
 117
 118 static
 119 void set_iconv_charset_index(FlocaleCharset *fc)
 120 {
 121         int i = 0;
 122
 123         if (!FiconvSupport || fc == NULL)
 124                 return;
 125
 126         if (FLC_DO_ICONV_CHARSET_INITIALIZED(fc))
 127                 return; /* already set */
 128         if (FLCIconvUtf8Charset == NULL ||
 129             !FLC_DO_ICONV_CHARSET_INITIALIZED(FLCIconvUtf8Charset))
 130         {
 131                 FLC_SET_ICONV_INDEX(fc, FLC_INDEX_ICONV_CHARSET_NOT_FOUND);
 132                 return;
 133         }
 134         while(FLC_GET_LOCALE_CHARSET(fc,i) != NULL)
 135         {
 136                 if (is_iconv_supported(
 137                         FLC_GET_ICONV_CHARSET(FLCIconvUtf8Charset),
 138                         FLC_GET_LOCALE_CHARSET(fc,i)))
 139                 {
 140                         FLC_SET_ICONV_INDEX(fc,i);
 141                         return;
 142                 }
 143                 i++;
 144         }
 145         FLC_SET_ICONV_INDEX(fc, FLC_INDEX_ICONV_CHARSET_NOT_FOUND);
 146 }
 147
 148 static
 149 char *convert_charsets(const char *in_charset, const char *out_charset,
 150                        const char *in, unsigned int in_size)
 151 {
 152         static int error_count = 0;
 153         Ficonv_t cd;
 154         int have_error = 0;
 155         int is_finished = 0;
 156         size_t nconv;
 157         size_t insize,outbuf_size,outbytes_remaining,len;
 158         const char *inptr;
 159         char *dest;
 160         char *outp;
 161
 162         if (in == NULL || !FiconvSupport)
 163                 return NULL;
 164
 165         cd = Ficonv_open(out_charset, in_charset);
 166         if (cd == (Ficonv_t) -1)
 167         {
 168                 /* Something went wrong.  */
 169                 if (error_count > FICONV_CONVERSION_MAX_NUMBER_OF_WARNING)
 170                         return NULL;
 171                 error_count++;
 172                 if (errno == EINVAL)
 173                 {
 174                         fprintf(
 175                                 stderr,
 176                                 "[fvwm][convert_charsets]: WARNING -\n\t");
 177                         fprintf(
 178                                 stderr,
 179                                 "conversion from `%s' to `%s' not available\n",
 180                                 in_charset,out_charset);
 181                 }
 182                 else
 183                 {
 184                         fprintf(
 185                                 stderr,
 186                                 "[fvwm][convert_charsets]: WARNING -\n\t");
 187                         fprintf(
 188                                 stderr,
 189                                 "conversion from `%s' to `%s' fail (init)\n",
 190                                 in_charset,out_charset);
 191                 }
 192                 /* Terminate the output string.  */
 193                 return NULL;
 194         }
 195
 196         /* in maybe a none terminate string */
 197         len = in_size;
 198
 199         outbuf_size = len + 1;
 200         outbytes_remaining = outbuf_size - 1;
 201         insize = len;
 202         outp = dest = safemalloc(outbuf_size);
 203
 204         inptr = in;
 205
 206         for (is_finished = 0; is_finished == 0; )
 207         {
 208                 nconv = Ficonv(
 209                         cd, (ICONV_ARG_CONST char **)&inptr, &insize, &outp,
 210                         &outbytes_remaining);
 211                 is_finished = 1;
 212                 if (nconv == (size_t) - 1)
 213                 {
 214                         switch (errno)
 215                         {
 216                         case EINVAL:
 217                                 /* Incomplete text, do not report an error */
 218                                 break;
 219                         case E2BIG:
 220                         {
 221                                 size_t used = outp - dest;
 222
 223                                 outbuf_size *= 2;
 224                                 dest = realloc (dest, outbuf_size);
 225
 226                                 outp = dest + used;
 227                                 /* -1 for nul */
 228                                 outbytes_remaining = outbuf_size - used - 1;
 229                                 is_finished = 0;
 230                                 break;
 231                         }
 232 #ifdef EILSEQ
 233                         case EILSEQ:
 234                                 /* Something went wrong.  */
 235                                 if (error_count <=
 236                                     FICONV_CONVERSION_MAX_NUMBER_OF_WARNING)
 237                                 {
 238                                         fprintf(
 239                                                 stderr,
 240                                                 "[fvwm][convert_charsets]:"
 241                                                 " WARNING -\n\t");
 242                                         fprintf(
 243                                                 stderr,
 244                                                 "Invalid byte sequence during"
 245                                                 " conversion from %s to %s\n",
 246                                                 in_charset,out_charset);
 247                                 }
 248                                 have_error = 1;
 249                                 break;
 250 #endif
 251                         default:
 252                                 if (error_count <=
 253                                     FICONV_CONVERSION_MAX_NUMBER_OF_WARNING)
 254                                 {
 255                                         fprintf(
 256                                                 stderr,
 257                                                 "[fvwm][convert_charsets]:"
 258                                                 " WARNING -\n\t");
 259                                         fprintf(
 260                                                 stderr,
 261                                                 "Error during conversion from"
 262                                                 " %s to %s\n", in_charset,
 263                                                 out_charset);
 264                                 }
 265                                 have_error = 1;
 266                                 break;
 267                         }
 268                 }
 269         }
 270
 271         /* Terminate the output string  */
 272         *outp = '\0';
 273
 274         if (Ficonv_close (cd) != 0)
 275         {
 276                 fprintf(
 277                         stderr,
 278                         "[fvwm][convert_charsets]: WARNING - iconv_close"
 279                         " fail\n");
 280         }
 281
 282         if (have_error)
 283         {
 284                 error_count++;
 285                 free (dest);
 286                 return NULL;
 287         }
 288         else
 289         {
 290                 return dest;
 291         }
 292 }
 293
 294 static
 295 void FiconvInit(Display *dpy, const char *module)
 296 {
 297         int suc = False;
 298
 299         if (!FiconvSupport || FiconvInitialized)
 300                 return;
 301
 302         FiconvInitialized = True;
 303         FlocaleCharsetInit(dpy, module);
 304         FLCIconvUtf8Charset = FlocaleCharsetGetUtf8Charset();
 305         FLCIconvDefaultCharset = FlocaleCharsetGetFLCXOMCharset();
 306
 307         suc = set_default_iconv_charsets(FLCIconvDefaultCharset);
 308         if (!suc)
 309         {
 310                 FLCIconvDefaultCharset = FlocaleCharsetGetLocaleCharset();
 311                 suc = set_default_iconv_charsets(FLCIconvDefaultCharset);
 312         }
 313         if (!suc)
 314         {
 315                 fprintf(stderr,
 316                        "[%s][FiconvInit]: WARN -- Cannot get default "
 317                        "iconv charset for default charsets '%s' and '%s'\n",
 318                        module,
 319                        FLC_DEBUG_GET_X_CHARSET(
 320                                FlocaleCharsetGetFLCXOMCharset()),
 321                        FLC_DEBUG_GET_X_CHARSET(FLCIconvDefaultCharset));
 322                 FLCIconvUtf8Charset = NULL;
 323                 FLCIconvDefaultCharset = NULL;
 324         }
 325
 326 #if FLOCALE_DEBUG_CHARSET
 327         fprintf(stderr,"[FiconvInit] iconv charset: x:%s, iconv:%s\n",
 328                 FLC_DEBUG_GET_X_CHARSET(FLCIconvDefaultCharset),
 329                 FLC_DEBUG_GET_ICONV_CHARSET(FLCIconvDefaultCharset));
 330         fprintf(stderr,"[FiconvInit] UTF-8 charset: x:%s, iconv:%s\n",
 331                 FLC_DEBUG_GET_X_CHARSET(FLCIconvUtf8Charset),
 332                 FLC_DEBUG_GET_ICONV_CHARSET(FLCIconvUtf8Charset));
 333 #endif
 334
 335 }
 336
 337 static
 338 FlocaleCharset *FiconvSetupConversion(Display *dpy, FlocaleCharset *fc)
 339 {
 340         FlocaleCharset *my_fc = NULL;
 341
 342         if (!FiconvSupport)
 343         {
 344                 return NULL;
 345         }
 346
 347         if (!FiconvInitialized)
 348         {
 349                 FiconvInit(dpy, "fvwm");
 350         }
 351
 352         if (FLCIconvUtf8Charset == NULL)
 353         {
 354                 return NULL;
 355         }
 356
 357         if (fc == NULL)
 358         {
 359                 my_fc = FLCIconvDefaultCharset;
 360                 if (my_fc == NULL)
 361                 {
 362                         return NULL;
 363                 }
 364         }
 365         else
 366         {
 367                 my_fc = fc;
 368         }
 369
 370         if (!FLC_DO_ICONV_CHARSET_INITIALIZED(my_fc))
 371         {
 372                 set_iconv_charset_index(my_fc);
 373 #if FLOCALE_DEBUG_CHARSET
 374                 fprintf(stderr, "[Flocale] set up iconv charset: "
 375                         "x: %s, iconv: %s\n",
 376                         FLC_DEBUG_GET_X_CHARSET(my_fc),
 377                         FLC_DEBUG_GET_ICONV_CHARSET(my_fc));
 378 #endif
 379                 if (!FLC_HAVE_ICONV_CHARSET(my_fc))
 380                 {
 381                         fprintf(
 382                                 stderr,
 383                                 "[fvwmlibs] cannot get iconv converter "
 384                                 "for charset %s\n",
 385                                 FLC_DEBUG_GET_X_CHARSET(my_fc));
 386                         return NULL;
 387                 }
 388         }
 389         if (!FLC_HAVE_ICONV_CHARSET(my_fc))
 390         {
 391                 return NULL;
 392         }
 393
 394         return my_fc;
 395 }
 396
 397 /* ---------------------------- interface functions ------------------------ */
 398
 399 /* conversion from UTF8 to the "current" charset */
 400 char *FiconvUtf8ToCharset(Display *dpy, FlocaleCharset *fc,
 401                           const char *in, unsigned int in_size)
 402 {
 403         char *out = NULL;
 404         FlocaleCharset *my_fc = NULL;
 405
 406         if (!FiconvSupport)
 407         {
 408                 return NULL;
 409         }
 410
 411         my_fc = FiconvSetupConversion(dpy, fc);
 412         if (my_fc == NULL)
 413         {
 414                 return NULL;
 415         }
 416
 417 #if FLOCALE_DEBUG_ICONV
 418         fprintf(stderr, "[FiconvUtf8ToCharset] conversion from %s to %s\n",
 419                 FLC_DEBUG_GET_ICONV_CHARSET(FLCIconvUtf8Charset),
 420                 FLC_DEBUG_GET_ICONV_CHARSET(my_fc));
 421 #endif
 422
 423         if (FLC_ENCODING_TYPE_IS_UTF_8(my_fc))
 424         {
 425                 /* in can be a none terminate string so do not use CopyString
 426                  */
 427                 out = safemalloc(in_size+1);
 428                 strncpy(out, in, in_size);
 429                 out[in_size]=0;
 430         }
 431         else
 432         {
 433                 out = convert_charsets(
 434                                 FLC_GET_ICONV_CHARSET(FLCIconvUtf8Charset),
 435                                 FLC_GET_ICONV_CHARSET(my_fc),
 436                                 in, in_size);
 437         }
 438
 439         return out;
 440 }
 441
 442 /* conversion from the current charset to UTF8 */
 443 char *FiconvCharsetToUtf8(Display *dpy, FlocaleCharset *fc,
 444                           const char *in, unsigned int in_size)
 445 {
 446         char *out = NULL;
 447         FlocaleCharset *my_fc = NULL;
 448
 449         if (!FiconvSupport)
 450         {
 451                 return NULL;
 452         }
 453
 454         my_fc = FiconvSetupConversion(dpy, fc);
 455         if (my_fc == NULL)
 456         {
 457                 return NULL;
 458         }
 459
 460 #if FLOCALE_DEBUG_ICONV
 461         fprintf(stderr, "[FiconvCharsetToUtf8] conversion from %s to %s\n",
 462                 FLC_DEBUG_GET_ICONV_CHARSET(my_fc),
 463                 FLC_DEBUG_GET_ICONV_CHARSET(FLCIconvUtf8Charset));
 464 #endif
 465
 466         if (FLC_ENCODING_TYPE_IS_UTF_8(my_fc))
 467         {
 468                 /* in can be a non terminate string so do not use CopyString */
 469                 out = safemalloc(in_size+1);
 470                 strncpy(out, in, in_size);
 471                 out[in_size]=0;
 472         }
 473         else
 474         {
 475                 out = convert_charsets(
 476                                 FLC_GET_ICONV_CHARSET(my_fc),
 477                                 FLC_GET_ICONV_CHARSET(FLCIconvUtf8Charset),
 478                                 in, in_size);
 479         }
 480         return out;
 481 }
 482
 483 /* conversion from charset to charset */
 484 char *FiconvCharsetToCharset(
 485         Display *dpy, FlocaleCharset *in_fc, FlocaleCharset *out_fc,
 486         const char *in, unsigned int in_size)
 487 {
 488         char *out = NULL;
 489         char *tmp = NULL;
 490         int tmp_len;
 491         Bool free_tmp = False;
 492         FlocaleCharset *my_in_fc;
 493         FlocaleCharset *my_out_fc;
 494
 495         if (!FiconvSupport ||
 496             (my_in_fc = FiconvSetupConversion(dpy, in_fc)) == NULL)
 497         {
 498                 return NULL;
 499         }
 500         if (!FiconvSupport ||
 501             (my_out_fc = FiconvSetupConversion(dpy, out_fc)) == NULL)
 502         {
 503                 return NULL;
 504         }
 505
 506         tmp = (char *)in;
 507         tmp_len = in_size;
 508         if (!FLC_ENCODING_TYPE_IS_UTF_8(my_in_fc))
 509         {
 510                 tmp = FiconvCharsetToUtf8(
 511                         dpy, my_in_fc, (const char *)in, in_size);
 512                 if (tmp != NULL)
 513                 {
 514                         free_tmp = True;
 515                         tmp_len = strlen(tmp);
 516                 }
 517                 else
 518                 {
 519                         /* fail to convert */
 520                         return NULL;
 521                 }
 522         }
 523
 524         out = tmp;
 525         if (!FLC_ENCODING_TYPE_IS_UTF_8(my_out_fc))
 526         {
 527                 out = FiconvUtf8ToCharset(
 528                         dpy, my_out_fc, (const char *)tmp, tmp_len);
 529                 if (free_tmp)
 530                 {
 531                         free(tmp);
 532                 }
 533         }
 534
 535         return out;
 536 }