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     return (char *) strdup (str);
 121
 122   cd = iconv_open (to_codeset, from_codeset);
 123
 124   if (cd == (iconv_t) - 1)
 125     return NULL;
 126
 127   p = (char *) strdup (str);
 128   if (p == NULL)
 129     return NULL;
 130   len = strlen (p);
 131   startp = p;
 132   inbytes_remaining = len;
 133   outbuf_size = len + 1;        /* + 1 for nul in case len == 1 */
 134
 135   outbytes_remaining = outbuf_size - 1; /* -1 for nul */
 136   outp = dest = malloc (outbuf_size);
 137
 138 again:
 139
 140   err = iconv (cd, (ICONV_CONST char **) &p, &inbytes_remaining,
 141                &outp, &outbytes_remaining);
 142
 143   if (err == (size_t) - 1)
 144     {
 145       switch (errno)
 146         {
 147         case EINVAL:
 148           /* Incomplete text, do not report an error */
 149           break;
 150
 151         case E2BIG:
 152           {
 153             size_t used = outp - dest;
 154
 155             outbuf_size *= 2;
 156             dest = realloc (dest, outbuf_size);
 157
 158             outp = dest + used;
 159             outbytes_remaining = outbuf_size - used - 1;        /* -1 for nul */
 160
 161             goto again;
 162           }
 163           break;
 164
 165         case EILSEQ:
 166           have_error = 1;
 167           break;
 168
 169         default:
 170           have_error = 1;
 171           break;
 172         }
 173     }
 174
 175   *outp = '\0';
 176
 177   if ((p - startp) != len)
 178     have_error = 1;
 179
 180
 181   free (startp);
 182
 183   iconv_close (cd);
 184
 185   if (have_error)
 186     {
 187       free (dest);
 188       dest = NULL;
 189     }
 190
 191   return dest;
 192 }
 193
 194 #else
 195
 196 const char *
 197 stringprep_locale_charset ()
 198 {
 199   return "ASCII";
 200 }
 201
 202 char *
 203 stringprep_convert (const char *str,
 204                     const char *to_codeset, const char *from_codeset)
 205 {
 206   fprintf (stderr, "libidn: warning: libiconv not installed, cannot "
 207            "convert data to UTF-8\n");
 208   return strdup (str);
 209 }
 210
 211 #endif
 212
 213 /**
 214  * stringprep_locale_to_utf8:
 215  * @str: input zero terminated string.
 216  *
 217  * Convert string encoded in the locale's character set into UTF-8 by
 218  * using stringprep_convert().
 219  *
 220  * Return value: Returns newly allocated zero-terminated string which
 221  *   is @str transcoded into UTF-8.
 222  **/
 223 char *
 224 stringprep_locale_to_utf8 (const char *str)
 225 {
 226   return stringprep_convert (str, "UTF-8", stringprep_locale_charset ());
 227 }
 228
 229 /**
 230  * stringprep_utf8_to_locale:
 231  * @str: input zero terminated string.
 232  *
 233  * Convert string encoded in UTF-8 into the locale's character set by
 234  * using stringprep_convert().
 235  *
 236  * Return value: Returns newly allocated zero-terminated string which
 237  *   is @str transcoded into the locale's character set.
 238  **/
 239 char *
 240 stringprep_utf8_to_locale (const char *str)
 241 {
 242   return stringprep_convert (str, stringprep_locale_charset (), "UTF-8");
 243 }