lib/toutf8.c

   1 /* toutf8.c     Convert strings from system locale into UTF-8.
   2  * Copyright (C) 2002, 2003  Simon Josefsson
   3  *
   4  * This file is part of GNU Libidn.
   5  *
   6  * GNU Libidn is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * GNU Libidn is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with GNU Libidn; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23
  24 #ifdef HAVE_ICONV
  25
  26 #include <iconv.h>
  27
  28 #if LOCALE_WORKS
  29 #include <langinfo.h>
  30 #include <locale.h>
  31 #endif
  32
  33 static const char *
  34 stringprep_locale_charset_slow (void)
  35 {
  36   const char *charset = getenv ("CHARSET");     /* flawfinder: ignore */
  37
  38   if (charset && *charset)
  39     return charset;
  40
  41 #if LOCALE_WORKS
  42   {
  43     char *p;
  44
  45     p = setlocale (LC_CTYPE, NULL);
  46     setlocale (LC_CTYPE, "");
  47
  48     charset = nl_langinfo (CODESET);
  49
  50     setlocale (LC_CTYPE, p);
  51
  52     if (charset && *charset)
  53       return charset;
  54   }
  55 #endif
  56
  57   return "ASCII";
  58 }
  59
  60 static const char *stringprep_locale_charset_cache = NULL;
  61
  62 /**
  63  * stringprep_locale_charset:
  64  *
  65  * Find out system locale charset.
  66  *
  67  * Note that this function return what it believe the SYSTEM is using
  68  * as a locale, not what locale the program is currently in (modified,
  69  * e.g., by a setlocale(LC_CTYPE, "ISO-8859-1")).  The reason is that
  70  * data read from argv[], stdin etc comes from the system, and is more
  71  * likely to be encoded using the system locale than the program
  72  * locale.
  73  *
  74  * You can set the environment variable CHARSET to override the value
  75  * returned.  Note that this function caches the result, so you will
  76  * have to modify CHARSET before calling (even indirectly) any
  77  * stringprep functions, e.g., by setting it when invoking the
  78  * application.
  79  *
  80  * Return value: Return the character set used by the system locale.
  81  *   It will never return NULL, but use "ASCII" as a fallback.
  82  **/
  83 const char *
  84 stringprep_locale_charset (void)
  85 {
  86   if (!stringprep_locale_charset_cache)
  87     stringprep_locale_charset_cache = stringprep_locale_charset_slow ();
  88
  89   return stringprep_locale_charset_cache;
  90 }
  91
  92 /**
  93  * stringprep_convert:
  94  * @str: input zero-terminated string.
  95  * @to_codeset: name of destination character set.
  96  * @from_codeset: name of origin character set, as used by @str.
  97  *
  98  * Convert the string from one character set to another using the
  99  * system's iconv() function.
 100  *
 101  * Return value: Returns newly allocated zero-terminated string which
 102  *   is @str transcoded into to_codeset.
 103  **/
 104 char *
 105 stringprep_convert (const char *str,
 106                     const char *to_codeset, const char *from_codeset)
 107 {
 108   iconv_t cd;
 109   char *dest;
 110   char *outp;
 111   char *p, *startp;
 112   size_t inbytes_remaining;
 113   size_t outbytes_remaining;
 114   size_t err;
 115   size_t outbuf_size;
 116   int have_error = 0;
 117   int len;
 118
 119   if (strcmp (to_codeset, from_codeset) == 0)
 120     {
 121       char *p;
 122       p = malloc (strlen (str) + 1);
 123       if (!p)
 124         return NULL;
 125       strcpy (p, str);
 126       return p;
 127     }
 128
 129   cd = iconv_open (to_codeset, from_codeset);
 130
 131   if (cd == (iconv_t) - 1)
 132     return NULL;
 133
 134   p = (char *) malloc (strlen (str) + 1);
 135   strcpy (p, str);
 136   if (p == NULL)
 137     return NULL;
 138   len = strlen (p);
 139   startp = p;
 140   inbytes_remaining = len;
 141   outbuf_size = len + 1;        /* + 1 for nul in case len == 1 */
 142
 143   outbytes_remaining = outbuf_size - 1; /* -1 for nul */
 144   outp = dest = malloc (outbuf_size);
 145
 146 again:
 147
 148   err = iconv (cd, (ICONV_CONST char **) &p, &inbytes_remaining,
 149                &outp, &outbytes_remaining);
 150
 151   if (err == (size_t) - 1)
 152     {
 153       switch (errno)
 154         {
 155         case EINVAL:
 156           /* Incomplete text, do not report an error */
 157           break;
 158
 159         case E2BIG:
 160           {
 161             size_t used = outp - dest;
 162
 163             outbuf_size *= 2;
 164             dest = realloc (dest, outbuf_size);
 165
 166             outp = dest + used;
 167             outbytes_remaining = outbuf_size - used - 1;        /* -1 for nul */
 168
 169             goto again;
 170           }
 171           break;
 172
 173         case EILSEQ:
 174           have_error = 1;
 175           break;
 176
 177         default:
 178           have_error = 1;
 179           break;
 180         }
 181     }
 182
 183   *outp = '\0';
 184
 185   if ((p - startp) != len)
 186     have_error = 1;
 187
 188
 189   free (startp);
 190
 191   iconv_close (cd);
 192
 193   if (have_error)
 194     {
 195       free (dest);
 196       dest = NULL;
 197     }
 198
 199   return dest;
 200 }
 201
 202 #else
 203
 204 const char *
 205 stringprep_locale_charset ()
 206 {
 207   return "ASCII";
 208 }
 209
 210 char *
 211 stringprep_convert (const char *str,
 212                     const char *to_codeset, const char *from_codeset)
 213 {
 214   char *p;
 215   fprintf (stderr, "libidn: warning: libiconv not installed, cannot "
 216            "convert data to UTF-8\n");
 217   p = malloc (strlen (str) + 1);
 218   if (!p)
 219     return NULL;
 220   strcpy (p, str);
 221   return p;
 222 }
 223
 224 #endif
 225
 226 /**
 227  * stringprep_locale_to_utf8:
 228  * @str: input zero terminated string.
 229  *
 230  * Convert string encoded in the locale's character set into UTF-8 by
 231  * using stringprep_convert().
 232  *
 233  * Return value: Returns newly allocated zero-terminated string which
 234  *   is @str transcoded into UTF-8.
 235  **/
 236 char *
 237 stringprep_locale_to_utf8 (const char *str)
 238 {
 239   return stringprep_convert (str, "UTF-8", stringprep_locale_charset ());
 240 }
 241
 242 /**
 243  * stringprep_utf8_to_locale:
 244  * @str: input zero terminated string.
 245  *
 246  * Convert string encoded in UTF-8 into the locale's character set by
 247  * using stringprep_convert().
 248  *
 249  * Return value: Returns newly allocated zero-terminated string which
 250  *   is @str transcoded into the locale's character set.
 251  **/
 252 char *
 253 stringprep_utf8_to_locale (const char *str)
 254 {
 255   return stringprep_convert (str, stringprep_locale_charset (), "UTF-8");
 256 }