/* 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>

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

 * 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 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, write to the

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

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include "glib.h"

#ifndef G_OS_WIN32

#include <iconv.h>

#endif

#include <errno.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "gprintfint.h"

#include "gthreadprivate.h"

#include "gunicode.h"

#ifdef G_OS_WIN32

#include "win_iconv.c"

#endif

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif

#ifdef G_PLATFORM_WIN32

#define STRICT

#include <windows.h>

#undef STRICT

#endif

#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)

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

#endif

#include "galias.h"

EXPORT_C GQuark 

g_convert_error_quark (void)

{

  return g_quark_from_static_string ("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_GNUC_INTERNAL extern const char ** 

_g_charset_get_aliases (const char *canonical_name);

/**

 * g_iconv_open:

 * @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.

 * 

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

 *  opening the converter failed.

 **/

EXPORT_C 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:

 * @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.

 * 

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

 **/

EXPORT_C size_t 

g_iconv (GIConv   converter,

	 gchar  **inbuf,

	 gsize   *inbytes_left,

	 gchar  **outbuf,

	 gsize   *outbytes_left)

{

  iconv_t cd = (iconv_t)converter;

  return iconv (cd, (const gchar **)inbuf, inbytes_left, outbuf, outbytes_left);

}

/**

 * g_iconv_close:

 * @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.

 * 

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

 **/

EXPORT_C gint

g_iconv_close (GIConv converter)

{

  iconv_t cd = (iconv_t)converter;

  return iconv_close (cd);

}

#ifdef NEED_ICONV_CACHE

#define ICONV_CACHE_SIZE   (16)

struct _iconv_cache_bucket {

  gchar *key;

  guint32 refcount;

  gboolean used;

  GIConv cd;

};

static GList *iconv_cache_list;

static GHashTable *iconv_cache;

static GHashTable *iconv_open_hash;

static guint iconv_cache_size = 0;

G_LOCK_DEFINE_STATIC (iconv_cache_lock);

/* caller *must* hold the iconv_cache_lock */

static void

iconv_cache_init (void)

{

  static gboolean initialized = FALSE;

  if (initialized)

    return;

  iconv_cache_list = NULL;

  iconv_cache = g_hash_table_new (g_str_hash, g_str_equal);

  iconv_open_hash = g_hash_table_new (g_direct_hash, g_direct_equal);

  initialized = TRUE;

}

/*

 * iconv_cache_bucket_new:

 * @key: cache key

 * @cd: iconv descriptor

 *

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

 * increments the cache size.

 *

 * This assumes ownership of @key.

 *

 * Returns a pointer to the newly allocated cache bucket.

 **/

static struct _iconv_cache_bucket *

iconv_cache_bucket_new (gchar *key, GIConv cd)

{

  struct _iconv_cache_bucket *bucket;

  bucket = g_new (struct _iconv_cache_bucket, 1);

  bucket->key = key;

  bucket->refcount = 1;

  bucket->used = TRUE;

  bucket->cd = cd;

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

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

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

  iconv_cache_list = g_list_prepend (iconv_cache_list, bucket);

  iconv_cache_size++;

  return bucket;

}

/*

 * iconv_cache_bucket_expire:

 * @node: cache bucket's node

 * @bucket: cache bucket

 *

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

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

 * open.

 *

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

 * search for it ourselves.

 **/

static void

iconv_cache_bucket_expire (GList *node, struct _iconv_cache_bucket *bucket)

{

  g_hash_table_remove (iconv_cache, bucket->key);

  if (node == NULL)

    node = g_list_find (iconv_cache_list, bucket);

  g_assert (node != NULL);

  if (node->prev)

    {

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

      if (node->next)

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

    }

  else

    {

      iconv_cache_list = node->next;

      if (node->next)

        node->next->prev = NULL;

    }

  g_list_free_1 (node);

  g_free (bucket->key);

  g_iconv_close (bucket->cd);

  g_free (bucket);

  iconv_cache_size--;

}

/*

 * iconv_cache_expire_unused:

 *

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

 * the total number of buckets < ICONV_CACHE_SIZE.

 **/

static void

iconv_cache_expire_unused (void)

{

  struct _iconv_cache_bucket *bucket;

  GList *node, *next;

  node = iconv_cache_list;

  while (node && iconv_cache_size >= ICONV_CACHE_SIZE)

    {

      next = node->next;

      bucket = node->data;

      if (bucket->refcount == 0)

        iconv_cache_bucket_expire (node, bucket);

      node = next;

    }

}

static GIConv

open_converter (const gchar *to_codeset,

		const gchar *from_codeset,

		GError     **error)

{

  struct _iconv_cache_bucket *bucket;

  gchar *key, *dyn_key, auto_key[80];

  GIConv cd;

  gsize len_from_codeset, len_to_codeset;

  /* create our key */

  len_from_codeset = strlen (from_codeset);

  len_to_codeset = strlen (to_codeset);

  if (len_from_codeset + len_to_codeset + 2 < sizeof (auto_key))

    {

      key = auto_key;

      dyn_key = NULL;

    }

  else

    key = dyn_key = g_malloc (len_from_codeset + len_to_codeset + 2);

  memcpy (key, from_codeset, len_from_codeset);

  key[len_from_codeset] = ':';

  strcpy (key + len_from_codeset + 1, to_codeset);

  G_LOCK (iconv_cache_lock);

  /* make sure the cache has been initialized */

  iconv_cache_init ();

  bucket = g_hash_table_lookup (iconv_cache, key);

  if (bucket)

    {

      g_free (dyn_key);

      if (bucket->used)

        {

          cd = g_iconv_open (to_codeset, from_codeset);

          if (cd == (GIConv) -1)

            goto error;

        }

      else

        {

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

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

	   * or NULL *outbuf is allowed by Unix98.)

	   */

	  gsize inbytes_left = 0;

	  gchar *outbuf = NULL;

	  gsize outbytes_left = 0;

          cd = bucket->cd;

          bucket->used = TRUE;

          /* reset the descriptor */

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

        }

      bucket->refcount++;

    }

  else

    {

      cd = g_iconv_open (to_codeset, from_codeset);

      if (cd == (GIConv) -1) 

	{

	  g_free (dyn_key);

	  goto error;

	}

      iconv_cache_expire_unused ();

      bucket = iconv_cache_bucket_new (dyn_key ? dyn_key : g_strdup (key), cd);

    }

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

  G_UNLOCK (iconv_cache_lock);

  return cd;

 error:

  G_UNLOCK (iconv_cache_lock);

  /* 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 converter)

{

  struct _iconv_cache_bucket *bucket;

  const gchar *key;

  GIConv cd;

  cd = converter;

  if (cd == (GIConv) -1)

    return 0;

  G_LOCK (iconv_cache_lock);

  key = g_hash_table_lookup (iconv_open_hash, cd);

  if (key)

    {

      g_hash_table_remove (iconv_open_hash, cd);

      bucket = g_hash_table_lookup (iconv_cache, key);

      g_assert (bucket);

      bucket->refcount--;

      if (cd == bucket->cd)

        bucket->used = FALSE;

      else

        g_iconv_close (cd);

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

        {

          /* expire this cache bucket */

          iconv_cache_bucket_expire (NULL, bucket);

        }

    }

  else

    {

      G_UNLOCK (iconv_cache_lock);

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

      return g_iconv_close (converter);

    }

  G_UNLOCK (iconv_cache_lock);

  return 0;

}

#else  /* !NEED_ICONV_CACHE */

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)