1 /* GLIB - Library of useful routines for C programming

     2  * 

     3  * gconvert.c: Convert between character sets using iconv

     4  * Copyright Red Hat Inc., 2000

     5  * Authors: Havoc Pennington <hp@redhat.com>, Owen Taylor <otaylor@redhat.com

     6  * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

     7  *

     8  * This library is free software; you can redistribute it and/or

     9  * modify it under the terms of the GNU Lesser General Public

    10  * License as published by the Free Software Foundation; either

    11  * version 2 of the License, or (at your option) any later version.

    12  *

    13  * This library is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    16  * Lesser General Public License for more details.

    17  *

    18  * You should have received a copy of the GNU Lesser General Public

    19  * License along with this library; if not, write to the

    20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    21  * Boston, MA 02111-1307, USA.

    22  */

    23 

    24 #include "config.h"

    25 

    26 #include <iconv.h>

    27 #include <errno.h>

    28 #include <stdio.h>

    29 #include <string.h>

    30 #include <stdlib.h>

    31 

    32 #include "glib.h"

    33 #include "gprintfint.h"

    34 #include "gthreadinit.h"

    35 #ifdef __SYMBIAN32__

    36 #include <glib_wsd.h>

    37 #endif

    38 

    39 #ifdef G_PLATFORM_WIN32

    40 #define STRICT

    41 #include <windows.h>

    42 #undef STRICT

    43 #endif

    44 

    45 #include "glibintl.h"

    46 

    47 #if defined(USE_LIBICONV_GNU) && !defined (_LIBICONV_H)

    48 #error GNU libiconv in use but included iconv.h not from libiconv

    49 #endif

    50 #if !defined(USE_LIBICONV_GNU) && defined (_LIBICONV_H)

    51 #error GNU libiconv not in use but included iconv.h is from libiconv

    52 #endif

    53 

    54 #include "galias.h"

    55 

    56 #if EMULATOR

    57 

    58 PLS(quark,g_convert_error_quark,GQuark)

    59 #define quark (*FUNCTION_NAME(quark,g_convert_error_quark)())

    60 

    61 #endif /* EMULATOR */

    62 

    63 EXPORT_C GQuark 

    64 g_convert_error_quark (void)

    65 {

    66   #if!EMULATOR

    67   

    68   static GQuark quark;

    69   

    70   #endif /* EMULATOR */

    71   

    72   if (!quark)

    73     quark = g_quark_from_static_string ("g_convert_error");

    74 

    75   return quark;

    76 }

    77 #if EMULATOR

    78 #undef quark

    79 #endif /* EMULATOR */

    80 

    81 static gboolean

    82 try_conversion (const char *to_codeset,

    83 		const char *from_codeset,

    84 		iconv_t    *cd)

    85 {

    86   *cd = iconv_open (to_codeset, from_codeset);

    87 

    88   if (*cd == (iconv_t)-1 && errno == EINVAL)

    89     return FALSE;

    90   else

    91     return TRUE;

    92 }

    93 

    94 static gboolean

    95 try_to_aliases (const char **to_aliases,

    96 		const char  *from_codeset,

    97 		iconv_t     *cd)

    98 {

    99   if (to_aliases)

   100     {

   101       const char **p = to_aliases;

   102       while (*p)

   103 	{

   104 	  if (try_conversion (*p, from_codeset, cd))

   105 	    return TRUE;

   106 

   107 	  p++;

   108 	}

   109     }

   110 

   111   return FALSE;

   112 }

   113 

   114 extern const char **_g_charset_get_aliases (const char *canonical_name) G_GNUC_INTERNAL;

   115 

   116 /**

   117  * g_iconv_open:

   118  * @to_codeset: destination codeset

   119  * @from_codeset: source codeset

   120  * 

   121  * Same as the standard UNIX routine iconv_open(), but

   122  * may be implemented via libiconv on UNIX flavors that lack

   123  * a native implementation.

   124  * 

   125  * GLib provides g_convert() and g_locale_to_utf8() which are likely

   126  * more convenient than the raw iconv wrappers.

   127  * 

   128  * Return value: a "conversion descriptor", or (GIConv)-1 if

   129  *  opening the converter failed.

   130  **/

   131 EXPORT_C GIConv

   132 g_iconv_open (const gchar  *to_codeset,

   133 	      const gchar  *from_codeset)

   134 {

   135   iconv_t cd;

   136   

   137   if (!try_conversion (to_codeset, from_codeset, &cd))

   138     {

   139       const char **to_aliases = _g_charset_get_aliases (to_codeset);

   140       const char **from_aliases = _g_charset_get_aliases (from_codeset);

   141 

   142       if (from_aliases)

   143 	{

   144 	  const char **p = from_aliases;

   145 	  while (*p)

   146 	    {

   147 	      if (try_conversion (to_codeset, *p, &cd))

   148 		goto out;

   149 

   150 	      if (try_to_aliases (to_aliases, *p, &cd))

   151 		goto out;

   152 

   153 	      p++;

   154 	    }

   155 	}

   156 

   157       if (try_to_aliases (to_aliases, from_codeset, &cd))

   158 	goto out;

   159     }

   160 

   161  out:

   162   return (cd == (iconv_t)-1) ? (GIConv)-1 : (GIConv)cd;

   163 }

   164 

   165 /**

   166  * g_iconv:

   167  * @converter: conversion descriptor from g_iconv_open()

   168  * @inbuf: bytes to convert

   169  * @inbytes_left: inout parameter, bytes remaining to convert in @inbuf

   170  * @outbuf: converted output bytes

   171  * @outbytes_left: inout parameter, bytes available to fill in @outbuf

   172  * 

   173  * Same as the standard UNIX routine iconv(), but

   174  * may be implemented via libiconv on UNIX flavors that lack

   175  * a native implementation.

   176  *

   177  * GLib provides g_convert() and g_locale_to_utf8() which are likely

   178  * more convenient than the raw iconv wrappers.

   179  * 

   180  * Return value: count of non-reversible conversions, or -1 on error

   181  **/

   182 EXPORT_C size_t 

   183 g_iconv (GIConv   converter,

   184 	 gchar  **inbuf,

   185 	 gsize   *inbytes_left,

   186 	 gchar  **outbuf,

   187 	 gsize   *outbytes_left)

   188 {

   189   iconv_t cd = (iconv_t)converter;

   190 

   191   return iconv (cd, FIX_CASTING(const char **)inbuf, inbytes_left, outbuf, outbytes_left);

   192 }

   193 

   194 /**

   195  * g_iconv_close:

   196  * @converter: a conversion descriptor from g_iconv_open()

   197  *

   198  * Same as the standard UNIX routine iconv_close(), but

   199  * may be implemented via libiconv on UNIX flavors that lack

   200  * a native implementation. Should be called to clean up

   201  * the conversion descriptor from g_iconv_open() when

   202  * you are done converting things.

   203  *

   204  * GLib provides g_convert() and g_locale_to_utf8() which are likely

   205  * more convenient than the raw iconv wrappers.

   206  * 

   207  * Return value: -1 on error, 0 on success

   208  **/

   209 EXPORT_C gint

   210 g_iconv_close (GIConv converter)

   211 {

   212   iconv_t cd = (iconv_t)converter;

   213 

   214   return iconv_close (cd);

   215 }

   216 

   217 

   218 #ifdef NEED_ICONV_CACHE

   219 

   220 #define ICONV_CACHE_SIZE   (16)

   221 

   222 struct _iconv_cache_bucket {

   223   gchar *key;

   224   guint32 refcount;

   225   gboolean used;

   226   GIConv cd;

   227 };

   228 

   229 static GList *iconv_cache_list;

   230 static GHashTable *iconv_cache;

   231 static GHashTable *iconv_open_hash;

   232 static guint iconv_cache_size = 0;

   233 G_LOCK_DEFINE_STATIC (iconv_cache_lock);

   234 

   235 /* caller *must* hold the iconv_cache_lock */

   236 static void

   237 iconv_cache_init (void)

   238 {

   239   static gboolean initialized = FALSE;

   240   

   241   if (initialized)

   242     return;

   243   

   244   iconv_cache_list = NULL;

   245   iconv_cache = g_hash_table_new (g_str_hash, g_str_equal);

   246   iconv_open_hash = g_hash_table_new (g_direct_hash, g_direct_equal);

   247   

   248   initialized = TRUE;

   249 }

   250 

   251 

   252 /**

   253  * iconv_cache_bucket_new:

   254  * @key: cache key

   255  * @cd: iconv descriptor

   256  *

   257  * Creates a new cache bucket, inserts it into the cache and

   258  * increments the cache size.

   259  *

   260  * Returns a pointer to the newly allocated cache bucket.

   261  **/

   262 static struct _iconv_cache_bucket *

   263 iconv_cache_bucket_new (const gchar *key, GIConv cd)

   264 {

   265   struct _iconv_cache_bucket *bucket;

   266   bucket = g_new (struct _iconv_cache_bucket, 1);

   267   bucket->key = g_strdup (key);

   268   bucket->refcount = 1;

   269   bucket->used = TRUE;

   270   bucket->cd = cd;

   271   

   272   g_hash_table_insert (iconv_cache, bucket->key, bucket);

   273   

   274   /* FIXME: if we sorted the list so items with few refcounts were

   275      first, then we could expire them faster in iconv_cache_expire_unused () */

   276   iconv_cache_list = g_list_prepend (iconv_cache_list, bucket);

   277   

   278   iconv_cache_size++;

   279   

   280   return bucket;

   281 }

   282 

   283 

   284 /**

   285  * iconv_cache_bucket_expire:

   286  * @node: cache bucket's node

   287  * @bucket: cache bucket

   288  *

   289  * Expires a single cache bucket @bucket. This should only ever be

   290  * called on a bucket that currently has no used iconv descriptors

   291  * open.

   292  *

   293  * @node is not a required argument. If @node is not supplied, we

   294  * search for it ourselves.

   295  **/

   296 static void

   297 iconv_cache_bucket_expire (GList *node, struct _iconv_cache_bucket *bucket)

   298 {

   299   g_hash_table_remove (iconv_cache, bucket->key);

   300   

   301   if (node == NULL)

   302     node = g_list_find (iconv_cache_list, bucket);

   303   

   304   g_assert (node != NULL);

   305   

   306   if (node->prev)

   307     {

   308       node->prev->next = node->next;

   309       if (node->next)

   310         node->next->prev = node->prev;

   311     }

   312   else

   313     {

   314       iconv_cache_list = node->next;

   315       if (node->next)

   316         node->next->prev = NULL;

   317     }

   318   

   319   g_list_free_1 (node);

   320   

   321   g_free (bucket->key);

   322   g_iconv_close (bucket->cd);

   323   g_free (bucket);

   324   

   325   iconv_cache_size--;

   326 }

   327 

   328 

   329 /**

   330  * iconv_cache_expire_unused:

   331  *

   332  * Expires as many unused cache buckets as it needs to in order to get

   333  * the total number of buckets < ICONV_CACHE_SIZE.

   334  **/

   335 static void

   336 iconv_cache_expire_unused (void)

   337 {

   338   struct _iconv_cache_bucket *bucket;

   339   GList *node, *next;

   340   

   341   node = iconv_cache_list;

   342   while (node && iconv_cache_size >= ICONV_CACHE_SIZE)

   343     {

   344       next = node->next;

   345       

   346       bucket = node->data;

   347       if (bucket->refcount == 0)

   348         iconv_cache_bucket_expire (node, bucket);

   349       

   350       node = next;

   351     }

   352 }

   353 

   354 static GIConv

   355 open_converter (const gchar *to_codeset,

   356 		const gchar *from_codeset,

   357 		GError     **error)

   358 {

   359   struct _iconv_cache_bucket *bucket;

   360   gchar *key;

   361   GIConv cd;

   362   

   363   /* create our key */

   364   key = g_alloca (strlen (from_codeset) + strlen (to_codeset) + 2);

   365   _g_sprintf (key, "%s:%s", from_codeset, to_codeset);

   366   

   367   G_LOCK (iconv_cache_lock);

   368   

   369   /* make sure the cache has been initialized */

   370   iconv_cache_init ();

   371   

   372   bucket = g_hash_table_lookup (iconv_cache, key);

   373   if (bucket)

   374     {

   375       if (bucket->used)

   376         {

   377           cd = g_iconv_open (to_codeset, from_codeset);

   378           if (cd == (GIConv) -1)

   379             goto error;

   380         }

   381       else

   382         {

   383 	  /* Apparently iconv on Solaris <= 7 segfaults if you pass in

   384 	   * NULL for anything but inbuf; work around that. (NULL outbuf

   385 	   * or NULL *outbuf is allowed by Unix98.)

   386 	   */

   387 	  gsize inbytes_left = 0;

   388 	  gchar *outbuf = NULL;

   389 	  gsize outbytes_left = 0;

   390 		

   391           cd = bucket->cd;

   392           bucket->used = TRUE;

   393           

   394           /* reset the descriptor */

   395           g_iconv (cd, NULL, &inbytes_left, &outbuf, &outbytes_left);

   396         }

   397       

   398       bucket->refcount++;

   399     }

   400   else

   401     {

   402       cd = g_iconv_open (to_codeset, from_codeset);

   403       if (cd == (GIConv) -1)

   404         goto error;

   405       

   406       iconv_cache_expire_unused ();

   407       

   408       bucket = iconv_cache_bucket_new (key, cd);

   409     }

   410   

   411   g_hash_table_insert (iconv_open_hash, cd, bucket->key);

   412   

   413   G_UNLOCK (iconv_cache_lock);

   414   

   415   return cd;

   416   

   417  error:

   418   

   419   G_UNLOCK (iconv_cache_lock);

   420   

   421   /* Something went wrong.  */

   422   if (error)

   423     {

   424       if (errno == EINVAL)

   425 	g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,

   426 		     _("Conversion from character set '%s' to '%s' is not supported"),

   427 		     from_codeset, to_codeset);

   428       else

   429 	g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

   430 		     _("Could not open converter from '%s' to '%s'"),

   431 		     from_codeset, to_codeset);

   432     }

   433   

   434   return cd;

   435 }

   436 

   437 static int

   438 close_converter (GIConv converter)

   439 {

   440   struct _iconv_cache_bucket *bucket;

   441   const gchar *key;

   442   GIConv cd;

   443   

   444   cd = converter;

   445   

   446   if (cd == (GIConv) -1)

   447     return 0;

   448   

   449   G_LOCK (iconv_cache_lock);

   450   

   451   key = g_hash_table_lookup (iconv_open_hash, cd);

   452   if (key)

   453     {

   454       g_hash_table_remove (iconv_open_hash, cd);

   455       

   456       bucket = g_hash_table_lookup (iconv_cache, key);

   457       g_assert (bucket);

   458       

   459       bucket->refcount--;

   460       

   461       if (cd == bucket->cd)

   462         bucket->used = FALSE;

   463       else

   464         g_iconv_close (cd);

   465       

   466       if (!bucket->refcount && iconv_cache_size > ICONV_CACHE_SIZE)

   467         {

   468           /* expire this cache bucket */

   469           iconv_cache_bucket_expire (NULL, bucket);

   470         }

   471     }

   472   else

   473     {

   474       G_UNLOCK (iconv_cache_lock);

   475       

   476       g_warning ("This iconv context wasn't opened using open_converter");

   477       

   478       return g_iconv_close (converter);

   479     }

   480   

   481   G_UNLOCK (iconv_cache_lock);

   482   

   483   return 0;

   484 }

   485 

   486 #else  /* !NEED_ICONV_CACHE */

   487 

   488 static GIConv

   489 open_converter (const gchar *to_codeset,

   490 		const gchar *from_codeset,

   491 		GError     **error)

   492 {

   493   GIConv cd;

   494 

   495   cd = g_iconv_open (to_codeset, from_codeset);

   496 

   497   if (cd == (GIConv) -1)

   498     {

   499       /* Something went wrong.  */

   500       if (error)

   501 	{

   502 	  if (errno == EINVAL)

   503 	    g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,

   504 			 _("Conversion from character set '%s' to '%s' is not supported"),

   505 			 from_codeset, to_codeset);

   506 	  else

   507 	    g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

   508 			 _("Could not open converter from '%s' to '%s'"),

   509 			 from_codeset, to_codeset);

   510 	}

   511     }

   512   

   513   return cd;

   514 }

   515 

   516 static int

   517 close_converter (GIConv cd)

   518 {

   519   if (cd == (GIConv) -1)

   520     return 0;

   521   

   522   return g_iconv_close (cd);  

   523 }

   524 

   525 #endif /* NEED_ICONV_CACHE */

   526 

   527 /**

   528  * g_convert_with_iconv:

   529  * @str:           the string to convert

   530  * @len:           the length of the string, or -1 if the string is 

   531  *                 nul-terminated<footnoteref linkend="nul-unsafe"/>. 

   532  * @converter:     conversion descriptor from g_iconv_open()

   533  * @bytes_read:    location to store the number of bytes in the

   534  *                 input string that were successfully converted, or %NULL.

   535  *                 Even if the conversion was successful, this may be 

   536  *                 less than @len if there were partial characters

   537  *                 at the end of the input. If the error

   538  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value

   539  *                 stored will the byte offset after the last valid

   540  *                 input sequence.

   541  * @bytes_written: the number of bytes stored in the output buffer (not 

   542  *                 including the terminating nul).

   543  * @error:         location to store the error occuring, or %NULL to ignore

   544  *                 errors. Any of the errors in #GConvertError may occur.

   545  *

   546  * Converts a string from one character set to another. 

   547  * 

   548  * Note that you should use g_iconv() for streaming 

   549  * conversions<footnote id="streaming-state">

   550  *  <para>

   551  * Despite the fact that @byes_read can return information about partial 

   552  * characters, the <literal>g_convert_...</literal> functions

   553  * are not generally suitable for streaming. If the underlying converter 

   554  * being used maintains internal state, then this won't be preserved 

   555  * across successive calls to g_convert(), g_convert_with_iconv() or 

   556  * g_convert_with_fallback(). (An example of this is the GNU C converter 

   557  * for CP1255 which does not emit a base character until it knows that 

   558  * the next character is not a mark that could combine with the base 

   559  * character.)

   560  *  </para>

   561  * </footnote>. 

   562  *

   563  * Return value: If the conversion was successful, a newly allocated

   564  *               nul-terminated string, which must be freed with

   565  *               g_free(). Otherwise %NULL and @error will be set.

   566  **/

   567 EXPORT_C gchar*

   568 g_convert_with_iconv (const gchar *str,

   569 		      gssize       len,

   570 		      GIConv       converter,

   571 		      gsize       *bytes_read, 

   572 		      gsize       *bytes_written, 

   573 		      GError     **error)

   574 {

   575   gchar *dest;

   576   gchar *outp;

   577   const gchar *p;

   578   const gchar *shift_p = NULL;

   579   gsize inbytes_remaining;

   580   gsize outbytes_remaining;

   581   gsize err;

   582   gsize outbuf_size;

   583   gboolean have_error = FALSE;

   584   gboolean done = FALSE;

   585   

   586   g_return_val_if_fail (converter != (GIConv) -1, NULL);

   587      

   588   if (len < 0)

   589     len = strlen (str);

   590 

   591   p = str;

   592   inbytes_remaining = len;

   593   outbuf_size = len + 1; /* + 1 for nul in case len == 1 */

   594   

   595   outbytes_remaining = outbuf_size - 1; /* -1 for nul */

   596 

   597   outp = dest = g_malloc (outbuf_size);

   598 

   599   while (!done && !have_error)

   600     {

   601       err = g_iconv (converter, (char **)&p, &inbytes_remaining, &outp, &outbytes_remaining);

   602 

   603       if (err == (size_t) -1)

   604 	{

   605 	  switch (errno)

   606 	    {

   607 	    case EINVAL:

   608 	      /* Incomplete text, do not report an error */

   609 	      done = TRUE;

   610 	      break;

   611 	    case E2BIG:

   612 	      {

   613 		size_t used = outp - dest;

   614 		

   615 		outbuf_size *= 2;

   616 		dest = g_realloc (dest, outbuf_size);

   617 		

   618 		outp = dest + used;

   619 		outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */

   620 	      }

   621 	      break;

   622 	    case EILSEQ:

   623 	      if (error)

   624 		g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,

   625 			     _("Invalid byte sequence in conversion input"));

   626 	      have_error = TRUE;

   627 	      break;

   628 	    default:

   629 	      if (error)

   630 		g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

   631 			     _("Error during conversion: %s"),

   632 			     g_strerror (errno));

   633 	      have_error = TRUE;

   634 	      break;

   635 	    }

   636 	}

   637       else 

   638 	{

   639 	  if (!shift_p)

   640 	    {

   641 	      /* call g_iconv with NULL inbuf to cleanup shift state */

   642 	      shift_p = p;

   643 	      p = NULL;

   644 	      inbytes_remaining = 0;

   645 	    }

   646 	  else

   647 	    done = TRUE;

   648 	}

   649     }

   650 

   651   if (shift_p)

   652     p = shift_p;

   653 

   654   *outp = '\0';

   655   

   656   if (bytes_read)

   657     *bytes_read = p - str;

   658   else

   659     {

   660       if ((p - str) != len) 

   661 	{

   662           if (!have_error)

   663             {

   664 	      if (error)

   665 		g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_PARTIAL_INPUT,

   666 			     _("Partial character sequence at end of input"));

   667               have_error = TRUE;

   668             }

   669 	}

   670     }

   671 

   672   if (bytes_written)

   673     *bytes_written = outp - dest;	/* Doesn't include '\0' */

   674 

   675   if (have_error)

   676     {

   677       g_free (dest);

   678       return NULL;

   679     }

   680   else

   681     return dest;

   682 }

   683 

   684 /**

   685  * g_convert:

   686  * @str:           the string to convert

   687  * @len:           the length of the string, or -1 if the string is 

   688  *                 nul-terminated<footnote id="nul-unsafe">

   689                      <para>

   690                        Note that some encodings may allow nul bytes to 

   691                        occur inside strings. In that case, using -1 for 

   692                        the @len parameter is unsafe.

   693                      </para>

   694                    </footnote>. 

   695  * @to_codeset:    name of character set into which to convert @str

   696  * @from_codeset:  character set of @str.

   697  * @bytes_read:    location to store the number of bytes in the

   698  *                 input string that were successfully converted, or %NULL.

   699  *                 Even if the conversion was successful, this may be 

   700  *                 less than @len if there were partial characters

   701  *                 at the end of the input. If the error

   702  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value

   703  *                 stored will the byte offset after the last valid

   704  *                 input sequence.

   705  * @bytes_written: the number of bytes stored in the output buffer (not 

   706  *                 including the terminating nul).

   707  * @error:         location to store the error occuring, or %NULL to ignore

   708  *                 errors. Any of the errors in #GConvertError may occur.

   709  *

   710  * Converts a string from one character set to another.

   711  *

   712  * Note that you should use g_iconv() for streaming 

   713  * conversions<footnoteref linkend="streaming-state"/>.

   714  *

   715  * Return value: If the conversion was successful, a newly allocated

   716  *               nul-terminated string, which must be freed with

   717  *               g_free(). Otherwise %NULL and @error will be set.

   718  **/

   719 EXPORT_C gchar*

   720 g_convert (const gchar *str,

   721            gssize       len,  

   722            const gchar *to_codeset,

   723            const gchar *from_codeset,

   724            gsize       *bytes_read, 

   725 	   gsize       *bytes_written, 

   726 	   GError     **error)

   727 {

   728   gchar *res;

   729   GIConv cd;

   730 

   731   g_return_val_if_fail (str != NULL, NULL);

   732   g_return_val_if_fail (to_codeset != NULL, NULL);

   733   g_return_val_if_fail (from_codeset != NULL, NULL);

   734   

   735   cd = open_converter (to_codeset, from_codeset, error);

   736 

   737   if (cd == (GIConv) -1)

   738     {

   739       if (bytes_read)

   740         *bytes_read = 0;

   741       

   742       if (bytes_written)

   743         *bytes_written = 0;

   744       

   745       return NULL;

   746     }

   747 

   748   res = g_convert_with_iconv (str, len, cd,

   749 			      bytes_read, bytes_written,

   750 			      error);

   751 

   752   close_converter (cd);

   753 

   754   return res;

   755 }

   756 

   757 /**

   758  * g_convert_with_fallback:

   759  * @str:          the string to convert

   760  * @len:          the length of the string, or -1 if the string is 

   761  *                nul-terminated<footnoteref linkend="nul-unsafe"/>. 

   762  * @to_codeset:   name of character set into which to convert @str

   763  * @from_codeset: character set of @str.

   764  * @fallback:     UTF-8 string to use in place of character not

   765  *                present in the target encoding. (The string must be

   766  *                representable in the target encoding). 

   767                   If %NULL, characters not in the target encoding will 

   768                   be represented as Unicode escapes \uxxxx or \Uxxxxyyyy.

   769  * @bytes_read:   location to store the number of bytes in the

   770  *                input string that were successfully converted, or %NULL.

   771  *                Even if the conversion was successful, this may be 

   772  *                less than @len if there were partial characters

   773  *                at the end of the input.

   774  * @bytes_written: the number of bytes stored in the output buffer (not 

   775  *                including the terminating nul).

   776  * @error:        location to store the error occuring, or %NULL to ignore

   777  *                errors. Any of the errors in #GConvertError may occur.

   778  *

   779  * Converts a string from one character set to another, possibly

   780  * including fallback sequences for characters not representable

   781  * in the output. Note that it is not guaranteed that the specification

   782  * for the fallback sequences in @fallback will be honored. Some

   783  * systems may do a approximate conversion from @from_codeset

   784  * to @to_codeset in their iconv() functions, 

   785  * in which case GLib will simply return that approximate conversion.

   786  *

   787  * Note that you should use g_iconv() for streaming 

   788  * conversions<footnoteref linkend="streaming-state"/>.

   789  *

   790  * Return value: If the conversion was successful, a newly allocated

   791  *               nul-terminated string, which must be freed with

   792  *               g_free(). Otherwise %NULL and @error will be set.

   793  **/

   794 EXPORT_C gchar*

   795 g_convert_with_fallback (const gchar *str,

   796 			 gssize       len,    

   797 			 const gchar *to_codeset,

   798 			 const gchar *from_codeset,

   799 			 gchar       *fallback,

   800 			 gsize       *bytes_read,

   801 			 gsize       *bytes_written,

   802 			 GError     **error)

   803 {

   804   gchar *utf8;

   805   gchar *dest;

   806   gchar *outp;

   807   const gchar *insert_str = NULL;

   808   const gchar *p;

   809   gsize inbytes_remaining;   

   810   const gchar *save_p = NULL;

   811   gsize save_inbytes = 0;

   812   gsize outbytes_remaining; 

   813   gsize err;

   814   GIConv cd;

   815   gsize outbuf_size;

   816   gboolean have_error = FALSE;

   817   gboolean done = FALSE;

   818 

   819   GError *local_error = NULL;

   820   

   821   g_return_val_if_fail (str != NULL, NULL);

   822   g_return_val_if_fail (to_codeset != NULL, NULL);

   823   g_return_val_if_fail (from_codeset != NULL, NULL);

   824      

   825   if (len < 0)

   826     len = strlen (str);

   827   

   828   /* Try an exact conversion; we only proceed if this fails

   829    * due to an illegal sequence in the input string.

   830    */

   831   dest = g_convert (str, len, to_codeset, from_codeset, 

   832 		    bytes_read, bytes_written, &local_error);

   833   if (!local_error)

   834     return dest;

   835 

   836   if (!g_error_matches (local_error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))

   837     {

   838       g_propagate_error (error, local_error);

   839       return NULL;

   840     }

   841   else

   842     g_error_free (local_error);

   843 

   844   local_error = NULL;

   845   

   846   /* No go; to proceed, we need a converter from "UTF-8" to

   847    * to_codeset, and the string as UTF-8.

   848    */

   849   cd = open_converter (to_codeset, "UTF-8", error);

   850   if (cd == (GIConv) -1)

   851     {

   852       if (bytes_read)

   853         *bytes_read = 0;

   854       

   855       if (bytes_written)

   856         *bytes_written = 0;

   857       

   858       return NULL;

   859     }

   860 

   861   utf8 = g_convert (str, len, "UTF-8", from_codeset, 

   862 		    bytes_read, &inbytes_remaining, error);

   863   if (!utf8)

   864     {

   865       close_converter (cd);

   866       if (bytes_written)

   867         *bytes_written = 0;

   868       return NULL;

   869     }

   870 

   871   /* Now the heart of the code. We loop through the UTF-8 string, and

   872    * whenever we hit an offending character, we form fallback, convert

   873    * the fallback to the target codeset, and then go back to

   874    * converting the original string after finishing with the fallback.

   875    *

   876    * The variables save_p and save_inbytes store the input state

   877    * for the original string while we are converting the fallback

   878    */

   879   p = utf8;

   880 

   881   outbuf_size = len + 1; /* + 1 for nul in case len == 1 */

   882   outbytes_remaining = outbuf_size - 1; /* -1 for nul */

   883   outp = dest = g_malloc (outbuf_size);

   884 

   885   while (!done && !have_error)

   886     {

   887       size_t inbytes_tmp = inbytes_remaining;

   888       err = g_iconv (cd, (char **)&p, &inbytes_tmp, &outp, &outbytes_remaining);

   889       inbytes_remaining = inbytes_tmp;

   890 

   891       if (err == (size_t) -1)

   892 	{

   893 	  switch (errno)

   894 	    {

   895 	    case EINVAL:

   896 	      g_assert_not_reached();

   897 	      break;

   898 	    case E2BIG:

   899 	      {

   900 		size_t used = outp - dest;

   901 

   902 		outbuf_size *= 2;

   903 		dest = g_realloc (dest, outbuf_size);

   904 		

   905 		outp = dest + used;

   906 		outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */

   907 		

   908 		break;

   909 	      }

   910 	    case EILSEQ:

   911 	      if (save_p)

   912 		{

   913 		  /* Error converting fallback string - fatal

   914 		   */

   915 		  g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,

   916 			       _("Cannot convert fallback '%s' to codeset '%s'"),

   917 			       insert_str, to_codeset);

   918 		  have_error = TRUE;

   919 		  break;

   920 		}

   921 	      else if (p)

   922 		{

   923 		  if (!fallback)

   924 		    { 

   925 		      gunichar ch = g_utf8_get_char (p);

   926 		      insert_str = g_strdup_printf (ch < 0x10000 ? "\\u%04x" : "\\U%08x",

   927 						    ch);

   928 		    }

   929 		  else

   930 		    insert_str = fallback;

   931 		  

   932 		  save_p = g_utf8_next_char (p);

   933 		  save_inbytes = inbytes_remaining - (save_p - p);

   934 		  p = insert_str;

   935 		  inbytes_remaining = strlen (p);

   936 		  break;

   937 		}

   938 	      /* fall thru if p is NULL */

   939 	    default:

   940 	      g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

   941 			   _("Error during conversion: %s"),

   942 			   g_strerror (errno));

   943 	      have_error = TRUE;

   944 	      break;

   945 	    }

   946 	}

   947       else

   948 	{

   949 	  if (save_p)

   950 	    {

   951 	      if (!fallback)

   952 		g_free ((gchar *)insert_str);

   953 	      p = save_p;

   954 	      inbytes_remaining = save_inbytes;

   955 	      save_p = NULL;

   956 	    }

   957 	  else if (p)

   958 	    {

   959 	      /* call g_iconv with NULL inbuf to cleanup shift state */

   960 	      p = NULL;

   961 	      inbytes_remaining = 0;

   962 	    }

   963 	  else

   964 	    done = TRUE;

   965 	}

   966     }

   967 

   968   /* Cleanup

   969    */

   970   *outp = '\0';

   971   

   972   close_converter (cd);

   973 

   974   if (bytes_written)

   975     *bytes_written = outp - dest;	/* Doesn't include '\0' */

   976 

   977   g_free (utf8);

   978 

   979   if (have_error)

   980     {

   981       if (save_p && !fallback)

   982 	g_free ((gchar *)insert_str);

   983       g_free (dest);

   984       return NULL;

   985     }

   986   else

   987     return dest;

   988 }

   989 

   990 /*

   991  * g_locale_to_utf8

   992  *

   993  * 

   994  */

   995 

   996 static gchar *

   997 strdup_len (const gchar *string,

   998 	    gssize       len,

   999 	    gsize       *bytes_written,

  1000 	    gsize       *bytes_read,

  1001 	    GError      **error)

  1002 	 

  1003 {

  1004   gsize real_len;

  1005 

  1006   if (!g_utf8_validate (string, len, NULL))

  1007     {

  1008       if (bytes_read)

  1009 	*bytes_read = 0;

  1010       if (bytes_written)

  1011 	*bytes_written = 0;

  1012 

  1013       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,

  1014 		   _("Invalid byte sequence in conversion input"));

  1015       return NULL;

  1016     }

  1017   

  1018   if (len < 0)

  1019     real_len = strlen (string);

  1020   else

  1021     {

  1022       real_len = 0;

  1023       

  1024       while (real_len < len && string[real_len])

  1025 	real_len++;

  1026     }

  1027   

  1028   if (bytes_read)

  1029     *bytes_read = real_len;

  1030   if (bytes_written)

  1031     *bytes_written = real_len;

  1032 

  1033   return g_strndup (string, real_len);

  1034 }

  1035 

  1036 /**

  1037  * g_locale_to_utf8:

  1038  * @opsysstring:   a string in the encoding of the current locale. On Windows

  1039  *                 this means the system codepage.

  1040  * @len:           the length of the string, or -1 if the string is

  1041  *                 nul-terminated<footnoteref linkend="nul-unsafe"/>. 

  1042  * @bytes_read:    location to store the number of bytes in the

  1043  *                 input string that were successfully converted, or %NULL.

  1044  *                 Even if the conversion was successful, this may be 

  1045  *                 less than @len if there were partial characters

  1046  *                 at the end of the input. If the error

  1047  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value

  1048  *                 stored will the byte offset after the last valid

  1049  *                 input sequence.

  1050  * @bytes_written: the number of bytes stored in the output buffer (not 

  1051  *                 including the terminating nul).

  1052  * @error:         location to store the error occuring, or %NULL to ignore

  1053  *                 errors. Any of the errors in #GConvertError may occur.

  1054  * 

  1055  * Converts a string which is in the encoding used for strings by

  1056  * the C runtime (usually the same as that used by the operating

  1057  * system) in the current locale into a UTF-8 string.

  1058  * 

  1059  * Return value: The converted string, or %NULL on an error.

  1060  **/

  1061 EXPORT_C gchar *

  1062 g_locale_to_utf8 (const gchar  *opsysstring,

  1063 		  gssize        len,            

  1064 		  gsize        *bytes_read,    

  1065 		  gsize        *bytes_written,

  1066 		  GError      **error)

  1067 {

  1068   const char *charset;

  1069 

  1070   if (g_get_charset (&charset))

  1071     return strdup_len (opsysstring, len, bytes_read, bytes_written, error);

  1072   else

  1073     return g_convert (opsysstring, len, 

  1074 		      "UTF-8", charset, bytes_read, bytes_written, error);

  1075 }

  1076 

  1077 /**

  1078  * g_locale_from_utf8:

  1079  * @utf8string:    a UTF-8 encoded string 

  1080  * @len:           the length of the string, or -1 if the string is

  1081  *                 nul-terminated<footnoteref linkend="nul-unsafe"/>. 

  1082  * @bytes_read:    location to store the number of bytes in the

  1083  *                 input string that were successfully converted, or %NULL.

  1084  *                 Even if the conversion was successful, this may be 

  1085  *                 less than @len if there were partial characters

  1086  *                 at the end of the input. If the error

  1087  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value

  1088  *                 stored will the byte offset after the last valid

  1089  *                 input sequence.

  1090  * @bytes_written: the number of bytes stored in the output buffer (not 

  1091  *                 including the terminating nul).

  1092  * @error:         location to store the error occuring, or %NULL to ignore

  1093  *                 errors. Any of the errors in #GConvertError may occur.

  1094  * 

  1095  * Converts a string from UTF-8 to the encoding used for strings by

  1096  * the C runtime (usually the same as that used by the operating

  1097  * system) in the current locale.

  1098  * 

  1099  * Return value: The converted string, or %NULL on an error.

  1100  **/

  1101 EXPORT_C gchar *

  1102 g_locale_from_utf8 (const gchar *utf8string,

  1103 		    gssize       len,            

  1104 		    gsize       *bytes_read,    

  1105 		    gsize       *bytes_written,

  1106 		    GError     **error)

  1107 {

  1108   const gchar *charset;

  1109 

  1110   if (g_get_charset (&charset))

  1111     return strdup_len (utf8string, len, bytes_read, bytes_written, error);

  1112   else

  1113     return g_convert (utf8string, len,

  1114 		      charset, "UTF-8", bytes_read, bytes_written, error);

  1115 }

  1116 

  1117 #ifndef G_PLATFORM_WIN32

  1118 

  1119 typedef struct _GFilenameCharsetCache GFilenameCharsetCache;

  1120 

  1121 struct _GFilenameCharsetCache {

  1122   gboolean is_utf8;

  1123   gchar *charset;

  1124   gchar **filename_charsets;

  1125 };

  1126 

  1127 static void

  1128 filename_charset_cache_free (gpointer data)

  1129 {

  1130   GFilenameCharsetCache *cache = data;

  1131   g_free (cache->charset);

  1132   g_strfreev (cache->filename_charsets);

  1133   g_free (cache);

  1134 }

  1135