/* GLIB - Library of useful routines for C programming

 *

 * gconvert.c: Convert between character sets using iconv

 * Copyright Red Hat Inc., 2000

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

 *

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

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

 * License as published by the Free Software Foundation; either

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

 *

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

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

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

 * Lesser General Public License for more details.

 *

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

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include "glibconfig.h"

#ifndef G_OS_WIN32

#include <iconv.h>

#endif

#include <errno.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#ifdef G_OS_WIN32

#include "win_iconv.c"

#endif

#ifdef G_PLATFORM_WIN32

#define STRICT

#include <windows.h>

#undef STRICT

#endif

#include "gconvert.h"

#include "gcharsetprivate.h"

#include "gslist.h"

#include "gstrfuncs.h"

#include "gtestutils.h"

#include "gthread.h"

#include "gunicode.h"

#include "gfileutils.h"

#include "glibintl.h"

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

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

#endif

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

     && !defined (__APPLE_CC__) && !defined (__LP_64__)

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

#endif

/**

 * SECTION:conversions

 * @title: Character Set Conversion

 * @short_description: convert strings between different character sets

 *

 * The g_convert() family of function wraps the functionality of iconv().

 * In addition to pure character set conversions, GLib has functions to

 * deal with the extra complications of encodings for file names.

 *

 * ## File Name Encodings

 *

 * Historically, UNIX has not had a defined encoding for file names:

 * a file name is valid as long as it does not have path separators

 * in it ("/"). However, displaying file names may require conversion:

 * from the character set in which they were created, to the character

 * set in which the application operates. Consider the Spanish file name

 * "Presentación.sxi". If the application which created it uses

 * ISO-8859-1 for its encoding,

 * |[

 * Character:  P  r  e  s  e  n  t  a  c  i  ó  n  .  s  x  i

 * Hex code:   50 72 65 73 65 6e 74 61 63 69 f3 6e 2e 73 78 69

 * ]|

 * However, if the application use UTF-8, the actual file name on

 * disk would look like this:

 * |[

 * Character:  P  r  e  s  e  n  t  a  c  i  ó     n  .  s  x  i

 * Hex code:   50 72 65 73 65 6e 74 61 63 69 c3 b3 6e 2e 73 78 69

 * ]|

 * Glib uses UTF-8 for its strings, and GUI toolkits like GTK+ that use

 * GLib do the same thing. If you get a file name from the file system,

 * for example, from readdir() or from g_dir_read_name(), and you wish

 * to display the file name to the user, you  will need to convert it

 * into UTF-8. The opposite case is when the user types the name of a

 * file they wish to save: the toolkit will give you that string in

 * UTF-8 encoding, and you will need to convert it to the character

 * set used for file names before you can create the file with open()

 * or fopen().

 *

 * By default, GLib assumes that file names on disk are in UTF-8

 * encoding. This is a valid assumption for file systems which

 * were created relatively recently: most applications use UTF-8

 * encoding for their strings, and that is also what they use for

 * the file names they create. However, older file systems may

 * still contain file names created in "older" encodings, such as

 * ISO-8859-1. In this case, for compatibility reasons, you may want

 * to instruct GLib to use that particular encoding for file names

 * rather than UTF-8. You can do this by specifying the encoding for

 * file names in the [`G_FILENAME_ENCODING`][G_FILENAME_ENCODING]

 * environment variable. For example, if your installation uses

 * ISO-8859-1 for file names, you can put this in your `~/.profile`:

 * |[

 * export G_FILENAME_ENCODING=ISO-8859-1

 * ]|

 * GLib provides the functions g_filename_to_utf8() and

 * g_filename_from_utf8() to perform the necessary conversions.

 * These functions convert file names from the encoding specified

 * in `G_FILENAME_ENCODING` to UTF-8 and vice-versa. This

 * [diagram][file-name-encodings-diagram] illustrates how

 * these functions are used to convert between UTF-8 and the

 * encoding for file names in the file system.

 *

 * ## Conversion between file name encodings # {#file-name-encodings-diagram)

 *

 * ![](file-name-encodings.png)

 *

 * ## Checklist for Application Writers

 *

 * This section is a practical summary of the detailed

 * things to do to make sure your applications process file

 * name encodings correctly.

 * 

 * 1. If you get a file name from the file system from a function

 *    such as readdir() or gtk_file_chooser_get_filename(), you do

 *    not need to do any conversion to pass that file name to

 *    functions like open(), rename(), or fopen() -- those are "raw"

 *    file names which the file system understands.

 *

 * 2. If you need to display a file name, convert it to UTF-8 first

 *    by using g_filename_to_utf8(). If conversion fails, display a

 *    string like "Unknown file name". Do not convert this string back

 *    into the encoding used for file names if you wish to pass it to

 *    the file system; use the original file name instead.

 *

 *    For example, the document window of a word processor could display

 *    "Unknown file name" in its title bar but still let the user save

 *    the file, as it would keep the raw file name internally. This

 *    can happen if the user has not set the `G_FILENAME_ENCODING`

 *    environment variable even though he has files whose names are

 *    not encoded in UTF-8.

 *

 * 3. If your user interface lets the user type a file name for saving

 *    or renaming, convert it to the encoding used for file names in

 *    the file system by using g_filename_from_utf8(). Pass the converted

 *    file name to functions like fopen(). If conversion fails, ask the

 *    user to enter a different file name. This can happen if the user

 *    types Japanese characters when `G_FILENAME_ENCODING` is set to

 *    `ISO-8859-1`, for example.

 */

/* We try to terminate strings in unknown charsets with this many zero bytes

 * to ensure that multibyte strings really are nul-terminated when we return

 * them from g_convert() and friends.

 */

#define NUL_TERMINATOR_LENGTH 4

G_DEFINE_QUARK (g_convert_error, g_convert_error)

static gboolean

try_conversion (const char *to_codeset,

		const char *from_codeset,

		iconv_t    *cd)

{

  *cd = iconv_open (to_codeset, from_codeset);

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

    return FALSE;

  else

    return TRUE;

}

static gboolean

try_to_aliases (const char **to_aliases,

		const char  *from_codeset,

		iconv_t     *cd)

{

  if (to_aliases)

    {

      const char **p = to_aliases;

      while (*p)

	{

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

	    return TRUE;

	  p++;

	}

    }

  return FALSE;

}

/**

 * g_iconv_open: (skip)

 * @to_codeset: destination codeset

 * @from_codeset: source codeset

 * 

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

 * may be implemented via libiconv on UNIX flavors that lack

 * a native implementation.

 * 

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

 * more convenient than the raw iconv wrappers.

 * 

 * Returns: a "conversion descriptor", or (GIConv)-1 if

 *  opening the converter failed.

 **/

GIConv

g_iconv_open (const gchar  *to_codeset,

	      const gchar  *from_codeset)

{

  iconv_t cd;

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

    {

      const char **to_aliases = _g_charset_get_aliases (to_codeset);

      const char **from_aliases = _g_charset_get_aliases (from_codeset);

      if (from_aliases)

	{

	  const char **p = from_aliases;

	  while (*p)

	    {

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

		goto out;

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

		goto out;

	      p++;

	    }

	}

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

	goto out;

    }

 out:

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

}

/**

 * g_iconv: (skip)

 * @converter: conversion descriptor from g_iconv_open()

 * @inbuf: bytes to convert

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

 * @outbuf: converted output bytes

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

 * 

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

 * may be implemented via libiconv on UNIX flavors that lack

 * a native implementation.

 *

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

 * more convenient than the raw iconv wrappers.

 * 

 * Note that the behaviour of iconv() for characters which are valid in the

 * input character set, but which have no representation in the output character

 * set, is implementation defined. This function may return success (with a

 * positive number of non-reversible conversions as replacement characters were

 * used), or it may return -1 and set an error such as %EILSEQ, in such a

 * situation.

 *

 * Returns: count of non-reversible conversions, or -1 on error

 **/

gsize 

g_iconv (GIConv   converter,

	 gchar  **inbuf,

	 gsize   *inbytes_left,

	 gchar  **outbuf,

	 gsize   *outbytes_left)

{

  iconv_t cd = (iconv_t)converter;

  return iconv (cd, inbuf, inbytes_left, outbuf, outbytes_left);

}

/**

 * g_iconv_close: (skip)

 * @converter: a conversion descriptor from g_iconv_open()

 *

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

 * may be implemented via libiconv on UNIX flavors that lack

 * a native implementation. Should be called to clean up

 * the conversion descriptor from g_iconv_open() when

 * you are done converting things.

 *

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

 * more convenient than the raw iconv wrappers.

 * 

 * Returns: -1 on error, 0 on success

 **/

gint

g_iconv_close (GIConv converter)

{

  iconv_t cd = (iconv_t)converter;

  return iconv_close (cd);

}

static GIConv

open_converter (const gchar *to_codeset,

		const gchar *from_codeset,

		GError     **error)

{

  GIConv cd;

  cd = g_iconv_open (to_codeset, from_codeset);

  if (cd == (GIConv) -1)

    {

      /* Something went wrong.  */

      if (error)

	{

	  if (errno == EINVAL)

	    g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,

			 _("Conversion from character set “%s” to “%s” is not supported"),

			 from_codeset, to_codeset);

	  else

	    g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

			 _("Could not open converter from “%s” to “%s”"),

			 from_codeset, to_codeset);

	}

    }

  return cd;

}

static int

close_converter (GIConv cd)

{

  if (cd == (GIConv) -1)

    return 0;

  return g_iconv_close (cd);  

}

/**

 * g_convert_with_iconv: (skip)

 * @str:           (array length=len) (element-type guint8):

 *                 the string to convert.

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

 *                 nul-terminated (Note that some encodings may allow nul

 *                 bytes to occur inside strings. In that case, using -1

 *                 for the @len parameter is unsafe)

 * @converter:     conversion descriptor from g_iconv_open()

 * @bytes_read:    (out) (optional): location to store the number of bytes in

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

 *                 Even if the conversion was successful, this may be 

 *                 less than @len if there were partial characters

 *                 at the end of the input. If the error

 *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value

 *                 stored will be the byte offset after the last valid

 *                 input sequence.

 * @bytes_written: (out) (optional): the number of bytes stored in

 *                 the output buffer (not including the terminating nul).

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

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

 *

 * Converts a string from one character set to another. 

 * 

 * Note that you should use g_iconv() for streaming conversions. 

 * Despite the fact that @bytes_read can return information about partial

 * characters, the g_convert_... functions are not generally suitable

 * for streaming. If the underlying converter maintains internal state,

 * then this won't be preserved across successive calls to g_convert(),

 * g_convert_with_iconv() or g_convert_with_fallback(). (An example of

 * this is the GNU C converter for CP1255 which does not emit a base

 * character until it knows that the next character is not a mark that

 * could combine with the base character.)

 *

 * Characters which are valid in the input character set, but which have no

 * representation in the output character set will result in a

 * %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error. This is in contrast to the iconv()

 * specification, which leaves this behaviour implementation defined. Note that

 * this is the same error code as is returned for an invalid byte sequence in

 * the input character set. To get defined behaviour for conversion of

 * unrepresentable characters, use g_convert_with_fallback().

 *

 * Returns: (array length=bytes_written) (element-type guint8) (transfer full):

 *               If the conversion was successful, a newly allocated buffer

 *               containing the converted string, which must be freed with

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

 **/

gchar*

g_convert_with_iconv (const gchar *str,

		      gssize       len,

		      GIConv       converter,

		      gsize       *bytes_read, 

		      gsize       *bytes_written, 

		      GError     **error)

{

  gchar *dest;

  gchar *outp;

  const gchar *p;

  gsize inbytes_remaining;

  gsize outbytes_remaining;

  gsize err;

  gsize outbuf_size;

  gboolean have_error = FALSE;

  gboolean done = FALSE;

  gboolean reset = FALSE;

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

  if (len < 0)

    len = strlen (str);

  p = str;

  inbytes_remaining = len;

  outbuf_size = len + NUL_TERMINATOR_LENGTH;

  outbytes_remaining = outbuf_size - NUL_TERMINATOR_LENGTH;

  outp = dest = g_malloc (outbuf_size);

  while (!done && !have_error)

    {

      if (reset)

        err = g_iconv (converter, NULL, &inbytes_remaining, &outp, &outbytes_remaining);

      else

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

      if (err == (gsize) -1)

	{

	  switch (errno)

	    {

	    case EINVAL:

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

	      done = TRUE;

	      break;

	    case E2BIG:

	      {

		gsize used = outp - dest;

		outbuf_size *= 2;

		dest = g_realloc (dest, outbuf_size);

		outp = dest + used;

		outbytes_remaining = outbuf_size - used - NUL_TERMINATOR_LENGTH;

	      }

	      break;

	    case EILSEQ:

              g_set_error_literal (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,

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

	      have_error = TRUE;

	      break;

	    default:

              {

                int errsv = errno;

                g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

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

                             g_strerror (errsv));

              }

	      have_error = TRUE;

	      break;

	    }

	}

      else if (err > 0)

        {

          /* @err gives the number of replacement characters used. */

          g_set_error_literal (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,

                               _("Unrepresentable character in conversion input"));

          have_error = TRUE;

        }

      else 

	{

	  if (!reset)

	    {

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

	      reset = TRUE;

	      inbytes_remaining = 0;

	    }

	  else

	    done = TRUE;

	}

    }

  memset (outp, 0, NUL_TERMINATOR_LENGTH);

  if (bytes_read)

    *bytes_read = p - str;

  else

    {

      if ((p - str) != len) 

	{

          if (!have_error)

            {

              g_set_error_literal (error, G_CONVERT_ERROR, G_CONVERT_ERROR_PARTIAL_INPUT,

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

              have_error = TRUE;

            }

	}

    }

  if (bytes_written)

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

  if (have_error)

    {

      g_free (dest);

      return NULL;

    }

  else

    return dest;

}

/**

 * g_convert:

 * @str:           (array length=len) (element-type guint8):

 *                 the string to convert.

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

 *                 nul-terminated (Note that some encodings may allow nul

 *                 bytes to occur inside strings. In that case, using -1

 *                 for the @len parameter is unsafe)

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

 * @from_codeset:  character set of @str.

 * @bytes_read:    (out) (optional): location to store the number of bytes in

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

 *                 Even if the conversion was successful, this may be 

 *                 less than @len if there were partial characters

 *                 at the end of the input. If the error

 *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value

 *                 stored will be the byte offset after the last valid

 *                 input sequence.

 * @bytes_written: (out) (optional): the number of bytes stored in

 *                 the output buffer (not including the terminating nul).

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

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

 *

 * Converts a string from one character set to another.

 *

 * Note that you should use g_iconv() for streaming conversions. 

 * Despite the fact that @bytes_read can return information about partial

 * characters, the g_convert_... functions are not generally suitable

 * for streaming. If the underlying converter maintains internal state,

 * then this won't be preserved across successive calls to g_convert(),

 * g_convert_with_iconv() or g_convert_with_fallback(). (An example of

 * this is the GNU C converter for CP1255 which does not emit a base

 * character until it knows that the next character is not a mark that

 * could combine with the base character.)

 *

 * Using extensions such as "//TRANSLIT" may not work (or may not work

 * well) on many platforms.  Consider using g_str_to_ascii() instead.

 *

 * Returns: (array length=bytes_written) (element-type guint8) (transfer full):

 *          If the conversion was successful, a newly allocated buffer

 *          containing the converted string, which must be freed with g_free().

 *          Otherwise %NULL and @error will be set.

 **/

gchar*

g_convert (const gchar *str,

           gssize       len,  

           const gchar *to_codeset,

           const gchar *from_codeset,

           gsize       *bytes_read, 

	   gsize       *bytes_written, 

	   GError     **error)

{

  gchar *res;

  GIConv cd;

  g_return_val_if_fail (str != NULL, NULL);

  g_return_val_if_fail (to_codeset != NULL, NULL);

  g_return_val_if_fail (from_codeset != NULL, NULL);

  cd = open_converter (to_codeset, from_codeset, error);

  if (cd == (GIConv) -1)

    {

      if (bytes_read)

        *bytes_read = 0;

      if (bytes_written)

        *bytes_written = 0;

      return NULL;

    }

  res = g_convert_with_iconv (str, len, cd,

			      bytes_read, bytes_written,

			      error);

  close_converter (cd);

  return res;

}

/**

 * g_convert_with_fallback:

 * @str:          (array length=len) (element-type guint8):

 *                the string to convert.

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

 *                 nul-terminated (Note that some encodings may allow nul

 *                 bytes to occur inside strings. In that case, using -1

 *                 for the @len parameter is unsafe)

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

 * @from_codeset: character set of @str.

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

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

 *                representable in the target encoding). 

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

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

 * @bytes_read:   (out) (optional): location to store the number of bytes in

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

 *                Even if the conversion was successful, this may be 

 *                less than @len if there were partial characters

 *                at the end of the input.

 * @bytes_written: (out) (optional): the number of bytes stored in

 *                 the output buffer (not including the terminating nul).

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

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

 *

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

 * including fallback sequences for characters not representable

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

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

 * systems may do an approximate conversion from @from_codeset

 * to @to_codeset in their iconv() functions, 

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

 *

 * Note that you should use g_iconv() for streaming conversions. 

 * Despite the fact that @bytes_read can return information about partial

 * characters, the g_convert_... functions are not generally suitable

 * for streaming. If the underlying converter maintains internal state,

 * then this won't be preserved across successive calls to g_convert(),

 * g_convert_with_iconv() or g_convert_with_fallback(). (An example of

 * this is the GNU C converter for CP1255 which does not emit a base

 * character until it knows that the next character is not a mark that

 * could combine with the base character.)

 *

 * Returns: (array length=bytes_written) (element-type guint8) (transfer full):

 *          If the conversion was successful, a newly allocated buffer

 *          containing the converted string, which must be freed with g_free().

 *          Otherwise %NULL and @error will be set.

 **/

gchar*

g_convert_with_fallback (const gchar *str,

			 gssize       len,    

			 const gchar *to_codeset,

			 const gchar *from_codeset,

			 const gchar *fallback,

			 gsize       *bytes_read,

			 gsize       *bytes_written,

			 GError     **error)

{

  gchar *utf8;

  gchar *dest;

  gchar *outp;

  const gchar *insert_str = NULL;

  const gchar *p;

  gsize inbytes_remaining;   

  const gchar *save_p = NULL;

  gsize save_inbytes = 0;

  gsize outbytes_remaining; 

  gsize err;

  GIConv cd;

  gsize outbuf_size;

  gboolean have_error = FALSE;

  gboolean done = FALSE;

  GError *local_error = NULL;

  g_return_val_if_fail (str != NULL, NULL);

  g_return_val_if_fail (to_codeset != NULL, NULL);

  g_return_val_if_fail (from_codeset != NULL, NULL);

  if (len < 0)

    len = strlen (str);

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

   * due to an illegal sequence in the input string.

   */

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

		    bytes_read, bytes_written, &local_error);

  if (!local_error)

    return dest;

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

    {

      g_propagate_error (error, local_error);

      return NULL;

    }

  else

    g_error_free (local_error);

  local_error = NULL;

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

   * to_codeset, and the string as UTF-8.

   */

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

  if (cd == (GIConv) -1)

    {

      if (bytes_read)

        *bytes_read = 0;

      if (bytes_written)

        *bytes_written = 0;

      return NULL;

    }

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

		    bytes_read, &inbytes_remaining, error);

  if (!utf8)

    {

      close_converter (cd);

      if (bytes_written)

        *bytes_written = 0;

      return NULL;

    }

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

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

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

   * converting the original string after finishing with the fallback.

   *

   * The variables save_p and save_inbytes store the input state

   * for the original string while we are converting the fallback

   */

  p = utf8;

  outbuf_size = len + NUL_TERMINATOR_LENGTH;

  outbytes_remaining = outbuf_size - NUL_TERMINATOR_LENGTH;

  outp = dest = g_malloc (outbuf_size);

  while (!done && !have_error)

    {

      gsize inbytes_tmp = inbytes_remaining;

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

      inbytes_remaining = inbytes_tmp;

      if (err == (gsize) -1)

	{

	  switch (errno)

	    {

	    case EINVAL:

	      g_assert_not_reached();

	      break;

	    case E2BIG:

	      {

		gsize used = outp - dest;

		outbuf_size *= 2;

		dest = g_realloc (dest, outbuf_size);

		outp = dest + used;

		outbytes_remaining = outbuf_size - used - NUL_TERMINATOR_LENGTH;

		break;

	      }

	    case EILSEQ:

	      if (save_p)

		{

		  /* Error converting fallback string - fatal

		   */

		  g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,

			       _("Cannot convert fallback “%s” to codeset “%s”"),

			       insert_str, to_codeset);

		  have_error = TRUE;

		  break;

		}

	      else if (p)

		{

		  if (!fallback)

		    { 

		      gunichar ch = g_utf8_get_char (p);

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

						    ch);

		    }

		  else

		    insert_str = fallback;

		  save_p = g_utf8_next_char (p);

		  save_inbytes = inbytes_remaining - (save_p - p);

		  p = insert_str;

		  inbytes_remaining = strlen (p);

		  break;

		}

	      /* fall thru if p is NULL */

	    default:

              {

                int errsv = errno;

                g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,

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

                             g_strerror (errsv));

              }

	      have_error = TRUE;

	      break;

	    }

	}

      else

	{

	  if (save_p)

	    {

	      if (!fallback)

		g_free ((gchar *)insert_str);

	      p = save_p;

	      inbytes_remaining = save_inbytes;

	      save_p = NULL;

	    }

	  else if (p)

	    {

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

	      p = NULL;

	      inbytes_remaining = 0;

	    }

	  else

	    done = TRUE;

	}

    }

  /* Cleanup

   */

  memset (outp, 0, NUL_TERMINATOR_LENGTH);

  close_converter (cd);

  if (bytes_written)

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

  g_free (utf8);

  if (have_error)

    {

      if (save_p && !fallback)

	g_free ((gchar *)insert_str);

      g_free (dest);

      return NULL;

    }

  else

    return dest;

}

/*

 * g_locale_to_utf8

 *

 * 

 */

/*

 * Validate @string as UTF-8. @len can be negative if @string is

 * nul-terminated, or a non-negative value in bytes. If @string ends in an

 * incomplete sequence, or contains any illegal sequences or nul codepoints,

 * %NULL will be returned and the error set to

 * %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.

 * On success, @bytes_read and @bytes_written, if provided, will be set to

 * the number of bytes in @string up to @len or the terminating nul byte.

 * On error, @bytes_read will be set to the byte offset after the last valid

 * and non-nul UTF-8 sequence in @string, and @bytes_written will be set to 0.

 */

static gchar *

strdup_len (const gchar *string,

	    gssize       len,

	    gsize       *bytes_read,

	    gsize       *bytes_written,

	    GError     **error)

{

  gsize real_len;

  const gchar *end_valid;

  if (!g_utf8_validate (string, len, &end_valid))

    {

      if (bytes_read)

	*bytes_read = end_valid - string;

      if (bytes_written)

	*bytes_written = 0;