gio/gcharsetconverter.c - third_party/glib - Git at Google

 /* GIO - GLib Input, Output and Streaming Library
  *
  * Copyright (C) 2009 Red Hat, Inc.
  *
  * 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/>.
  *
  * Author: Alexander Larsson <alexl@redhat.com>
  */

 #include "config.h"

 #include "gcharsetconverter.h"

 #include <errno.h>

 #include "ginitable.h"
 #include "gioerror.h"
 #include "glibintl.h"


 enum {
   PROP_0,
   PROP_FROM_CHARSET,
   PROP_TO_CHARSET,
   PROP_USE_FALLBACK
 };

 /**
  * SECTION:gcharsetconverter
  * @short_description: Convert between charsets
  * @include: gio/gio.h
  *
  * #GCharsetConverter is an implementation of #GConverter based on
  * GIConv.
  */

 static void g_charset_converter_iface_init          (GConverterIface *iface);
 static void g_charset_converter_initable_iface_init (GInitableIface  *iface);

 /**
  * GCharsetConverter:
  *
  * Conversions between character sets.
  */
 struct _GCharsetConverter
 {
   GObject parent_instance;

   char *from;
   char *to;
   GIConv iconv;
   gboolean use_fallback;
   guint n_fallback_errors;
 };

 G_DEFINE_TYPE_WITH_CODE (GCharsetConverter, g_charset_converter, G_TYPE_OBJECT,
 			 G_IMPLEMENT_INTERFACE (G_TYPE_CONVERTER,
 						g_charset_converter_iface_init);
 			 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
 						g_charset_converter_initable_iface_init))

 static void
 g_charset_converter_finalize (GObject *object)
 {
   GCharsetConverter *conv;

   conv = G_CHARSET_CONVERTER (object);

   g_free (conv->from);
   g_free (conv->to);
   if (conv->iconv)
     g_iconv_close (conv->iconv);

   G_OBJECT_CLASS (g_charset_converter_parent_class)->finalize (object);
 }

 static void
 g_charset_converter_set_property (GObject      *object,
 				  guint         prop_id,
 				  const GValue *value,
 				  GParamSpec   *pspec)
 {
   GCharsetConverter *conv;

   conv = G_CHARSET_CONVERTER (object);

   switch (prop_id)
     {
     case PROP_TO_CHARSET:
       g_free (conv->to);
       conv->to = g_value_dup_string (value);
       break;

     case PROP_FROM_CHARSET:
       g_free (conv->from);
       conv->from = g_value_dup_string (value);
       break;

     case PROP_USE_FALLBACK:
       conv->use_fallback = g_value_get_boolean (value);
       break;

     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }

 }

 static void
 g_charset_converter_get_property (GObject    *object,
 				  guint       prop_id,
 				  GValue     *value,
 				  GParamSpec *pspec)
 {
   GCharsetConverter *conv;

   conv = G_CHARSET_CONVERTER (object);

   switch (prop_id)
     {
     case PROP_TO_CHARSET:
       g_value_set_string (value, conv->to);
       break;

     case PROP_FROM_CHARSET:
       g_value_set_string (value, conv->from);
       break;

     case PROP_USE_FALLBACK:
       g_value_set_boolean (value, conv->use_fallback);
       break;

     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }

 static void
 g_charset_converter_class_init (GCharsetConverterClass *klass)
 {
   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

   gobject_class->finalize = g_charset_converter_finalize;
   gobject_class->get_property = g_charset_converter_get_property;
   gobject_class->set_property = g_charset_converter_set_property;

   g_object_class_install_property (gobject_class,
 				   PROP_TO_CHARSET,
 				   g_param_spec_string ("to-charset",
 							P_("To Charset"),
 							P_("The character encoding to convert to"),
 							NULL,
 							G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 							G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (gobject_class,
 				   PROP_FROM_CHARSET,
 				   g_param_spec_string ("from-charset",
 							P_("From Charset"),
 							P_("The character encoding to convert from"),
 							NULL,
 							G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 							G_PARAM_STATIC_STRINGS));
   g_object_class_install_property (gobject_class,
 				   PROP_USE_FALLBACK,
 				   g_param_spec_boolean ("use-fallback",
 							 P_("Fallback enabled"),
 							 P_("Use fallback (of form \\<hexval>) for invalid bytes"),
 							 FALSE,
 							 G_PARAM_READWRITE |
 							 G_PARAM_CONSTRUCT |
 							 G_PARAM_STATIC_STRINGS));
 }

 static void
 g_charset_converter_init (GCharsetConverter *local)
 {
 }


 /**
  * g_charset_converter_new:
  * @to_charset: destination charset
  * @from_charset: source charset
  * @error: #GError for error reporting, or %NULL to ignore.
  *
  * Creates a new #GCharsetConverter.
  *
  * Returns: a new #GCharsetConverter or %NULL on error.
  *
  * Since: 2.24
  **/
 GCharsetConverter *
 g_charset_converter_new (const gchar *to_charset,
 			 const gchar *from_charset,
 			 GError      **error)
 {
   GCharsetConverter *conv;

   conv = g_initable_new (G_TYPE_CHARSET_CONVERTER,
 			 NULL, error,
 			 "to-charset", to_charset,
 			 "from-charset", from_charset,
 			 NULL);

   return conv;
 }

 static void
 g_charset_converter_reset (GConverter *converter)
 {
   GCharsetConverter *conv = G_CHARSET_CONVERTER (converter);

   if (conv->iconv == NULL)
     {
       g_warning ("Invalid object, not initialized");
       return;
     }

   g_iconv (conv->iconv, NULL, NULL, NULL, NULL);
   conv->n_fallback_errors = 0;
 }

 static GConverterResult
 g_charset_converter_convert (GConverter       *converter,
 			     const void       *inbuf,
 			     gsize             inbuf_size,
 			     void             *outbuf,
 			     gsize             outbuf_size,
 			     GConverterFlags   flags,
 			     gsize            *bytes_read,
 			     gsize            *bytes_written,
 			     GError          **error)
 {
   GCharsetConverter  *conv;
   gsize res;
   GConverterResult ret;
   gchar *inbufp, *outbufp;
   gsize in_left, out_left;
   int errsv;
   gboolean reset;

   conv = G_CHARSET_CONVERTER (converter);

   if (conv->iconv == NULL)
     {
       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED,
 			   _("Invalid object, not initialized"));
       return G_CONVERTER_ERROR;
     }

   inbufp = (char *)inbuf;
   outbufp = (char *)outbuf;
   in_left = inbuf_size;
   out_left = outbuf_size;
   reset = FALSE;

   /* if there is not input try to flush the data */
   if (inbuf_size == 0)
     {
       if (flags & G_CONVERTER_INPUT_AT_END ||
           flags & G_CONVERTER_FLUSH)
         {
           reset = TRUE;
         }
       else
         {
           g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT,
                                _("Incomplete multibyte sequence in input"));
           return G_CONVERTER_ERROR;
         }
     }

   if (reset)
     /* call g_iconv with NULL inbuf to cleanup shift state */
     res = g_iconv (conv->iconv,
                    NULL, &in_left,
                    &outbufp, &out_left);
   else
     res = g_iconv (conv->iconv,
                    &inbufp, &in_left,
                    &outbufp, &out_left);

   *bytes_read = inbufp - (char *)inbuf;
   *bytes_written = outbufp - (char *)outbuf;

   /* Don't report error if we converted anything */
   if (res == (gsize) -1 && *bytes_read == 0)
     {
       errsv = errno;

       switch (errsv)
 	{
 	case EINVAL:
 	  /* Incomplete input text */
 	  g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT,
 			       _("Incomplete multibyte sequence in input"));
 	  break;

 	case E2BIG:
 	  /* Not enough destination space */
 	  g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE,
 			       _("Not enough space in destination"));
 	  break;

 	case EILSEQ:
 	  /* Invalid code sequence */
 	  if (conv->use_fallback)
 	    {
 	      if (outbuf_size < 3)
 		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE,
 				     _("Not enough space in destination"));
 	      else
 		{
 		  const char hex[] = "0123456789ABCDEF";
 		  guint8 v = *(guint8 *)inbuf;
 		  guint8 *out = (guint8 *)outbuf;
 		  out[0] = '\\';
 		  out[1] = hex[(v & 0xf0) >> 4];
 		  out[2] = hex[(v & 0x0f) >> 0];
 		  *bytes_read = 1;
 		  *bytes_written = 3;
 		  in_left--;
 		  conv->n_fallback_errors++;
 		  goto ok;
 		}
 	    }
 	  else
 	    g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
 				 _("Invalid byte sequence in conversion input"));
 	  break;

 	default:
 	  g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 		       _("Error during conversion: %s"),
 		       g_strerror (errsv));
 	  break;
 	}
       ret = G_CONVERTER_ERROR;
     }
   else
     {
     ok:
       ret = G_CONVERTER_CONVERTED;

       if (reset &&
 	  (flags & G_CONVERTER_INPUT_AT_END))
         ret = G_CONVERTER_FINISHED;
       else if (reset &&
 	       (flags & G_CONVERTER_FLUSH))
         ret = G_CONVERTER_FLUSHED;
     }

   return ret;
 }

 /**
  * g_charset_converter_set_use_fallback:
  * @converter: a #GCharsetConverter
  * @use_fallback: %TRUE to use fallbacks
  *
  * Sets the #GCharsetConverter:use-fallback property.
  *
  * Since: 2.24
  */
 void
 g_charset_converter_set_use_fallback (GCharsetConverter *converter,
 				      gboolean           use_fallback)
 {
   use_fallback = !!use_fallback;

   if (converter->use_fallback != use_fallback)
     {
       converter->use_fallback = use_fallback;
       g_object_notify (G_OBJECT (converter), "use-fallback");
     }
 }

 /**
  * g_charset_converter_get_use_fallback:
  * @converter: a #GCharsetConverter
  *
  * Gets the #GCharsetConverter:use-fallback property.
  *
  * Returns: %TRUE if fallbacks are used by @converter
  *
  * Since: 2.24
  */
 gboolean
 g_charset_converter_get_use_fallback (GCharsetConverter *converter)
 {
   return converter->use_fallback;
 }

 /**
  * g_charset_converter_get_num_fallbacks:
  * @converter: a #GCharsetConverter
  *
  * Gets the number of fallbacks that @converter has applied so far.
  *
  * Returns: the number of fallbacks that @converter has applied
  *
  * Since: 2.24
  */
 guint
 g_charset_converter_get_num_fallbacks (GCharsetConverter *converter)
 {
   return converter->n_fallback_errors;
 }

 static void
 g_charset_converter_iface_init (GConverterIface *iface)
 {
   iface->convert = g_charset_converter_convert;
   iface->reset = g_charset_converter_reset;
 }

 static gboolean
 g_charset_converter_initable_init (GInitable     *initable,
 				   GCancellable  *cancellable,
 				   GError       **error)
 {
   GCharsetConverter  *conv;
   int errsv;

   g_return_val_if_fail (G_IS_CHARSET_CONVERTER (initable), FALSE);

   conv = G_CHARSET_CONVERTER (initable);

   if (cancellable != NULL)
     {
       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 			   _("Cancellable initialization not supported"));
       return FALSE;
     }

   conv->iconv = g_iconv_open (conv->to, conv->from);
   errsv = errno;

   if (conv->iconv == (GIConv)-1)
     {
       if (errsv == EINVAL)
 	g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 		     _("Conversion from character set “%s” to “%s” is not supported"),
 		     conv->from, conv->to);
       else
 	g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
 		     _("Could not open converter from “%s” to “%s”"),
 		     conv->from, conv->to);
       return FALSE;
     }

   return TRUE;
 }

 static void
 g_charset_converter_initable_iface_init (GInitableIface *iface)
 {
   iface->init = g_charset_converter_initable_init;
 }
	/* GIO - GLib Input, Output and Streaming Library
	*
	* Copyright (C) 2009 Red Hat, Inc.
	*
	* 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/>.
	*
	* Author: Alexander Larsson <alexl@redhat.com>
	*/

	#include "config.h"

	#include "gcharsetconverter.h"

	#include <errno.h>

	#include "ginitable.h"
	#include "gioerror.h"
	#include "glibintl.h"


	enum {
	PROP_0,
	PROP_FROM_CHARSET,
	PROP_TO_CHARSET,
	PROP_USE_FALLBACK
	};

	/**
	* SECTION:gcharsetconverter
	* @short_description: Convert between charsets
	* @include: gio/gio.h
	*
	* #GCharsetConverter is an implementation of #GConverter based on
	* GIConv.
	*/

	static void g_charset_converter_iface_init (GConverterIface *iface);
	static void g_charset_converter_initable_iface_init (GInitableIface *iface);

	/**
	* GCharsetConverter:
	*
	* Conversions between character sets.
	*/
	struct _GCharsetConverter
	{
	GObject parent_instance;

	char *from;
	char *to;
	GIConv iconv;
	gboolean use_fallback;
	guint n_fallback_errors;
	};

	G_DEFINE_TYPE_WITH_CODE (GCharsetConverter, g_charset_converter, G_TYPE_OBJECT,
	G_IMPLEMENT_INTERFACE (G_TYPE_CONVERTER,
	g_charset_converter_iface_init);
	G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
	g_charset_converter_initable_iface_init))

	static void
	g_charset_converter_finalize (GObject *object)
	{
	GCharsetConverter *conv;

	conv = G_CHARSET_CONVERTER (object);

	g_free (conv->from);
	g_free (conv->to);
	if (conv->iconv)
	g_iconv_close (conv->iconv);

	G_OBJECT_CLASS (g_charset_converter_parent_class)->finalize (object);
	}

	static void
	g_charset_converter_set_property (GObject *object,
	guint prop_id,
	const GValue *value,
	GParamSpec *pspec)
	{
	GCharsetConverter *conv;

	conv = G_CHARSET_CONVERTER (object);

	switch (prop_id)
	{
	case PROP_TO_CHARSET:
	g_free (conv->to);
	conv->to = g_value_dup_string (value);
	break;

	case PROP_FROM_CHARSET:
	g_free (conv->from);
	conv->from = g_value_dup_string (value);
	break;

	case PROP_USE_FALLBACK:
	conv->use_fallback = g_value_get_boolean (value);
	break;

	default:
	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
	break;
	}

	}

	static void
	g_charset_converter_get_property (GObject *object,
	guint prop_id,
	GValue *value,
	GParamSpec *pspec)
	{
	GCharsetConverter *conv;

	conv = G_CHARSET_CONVERTER (object);

	switch (prop_id)
	{
	case PROP_TO_CHARSET:
	g_value_set_string (value, conv->to);
	break;

	case PROP_FROM_CHARSET:
	g_value_set_string (value, conv->from);
	break;

	case PROP_USE_FALLBACK:
	g_value_set_boolean (value, conv->use_fallback);
	break;

	default:
	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
	break;
	}
	}

	static void
	g_charset_converter_class_init (GCharsetConverterClass *klass)
	{
	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

	gobject_class->finalize = g_charset_converter_finalize;
	gobject_class->get_property = g_charset_converter_get_property;
	gobject_class->set_property = g_charset_converter_set_property;

	g_object_class_install_property (gobject_class,
	PROP_TO_CHARSET,
	g_param_spec_string ("to-charset",
	P_("To Charset"),
	P_("The character encoding to convert to"),
	NULL,
	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \|
	G_PARAM_STATIC_STRINGS));
	g_object_class_install_property (gobject_class,
	PROP_FROM_CHARSET,
	g_param_spec_string ("from-charset",
	P_("From Charset"),
	P_("The character encoding to convert from"),
	NULL,
	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \|
	G_PARAM_STATIC_STRINGS));
	g_object_class_install_property (gobject_class,
	PROP_USE_FALLBACK,
	g_param_spec_boolean ("use-fallback",
	P_("Fallback enabled"),
	P_("Use fallback (of form \\<hexval>) for invalid bytes"),
	FALSE,
	G_PARAM_READWRITE \|
	G_PARAM_CONSTRUCT \|
	G_PARAM_STATIC_STRINGS));
	}

	static void
	g_charset_converter_init (GCharsetConverter *local)
	{
	}


	/**
	* g_charset_converter_new:
	* @to_charset: destination charset
	* @from_charset: source charset
	* @error: #GError for error reporting, or %NULL to ignore.
	*
	* Creates a new #GCharsetConverter.
	*
	* Returns: a new #GCharsetConverter or %NULL on error.
	*
	* Since: 2.24
	**/
	GCharsetConverter *
	g_charset_converter_new (const gchar *to_charset,
	const gchar *from_charset,
	GError **error)
	{
	GCharsetConverter *conv;

	conv = g_initable_new (G_TYPE_CHARSET_CONVERTER,
	NULL, error,
	"to-charset", to_charset,
	"from-charset", from_charset,
	NULL);

	return conv;
	}

	static void
	g_charset_converter_reset (GConverter *converter)
	{
	GCharsetConverter *conv = G_CHARSET_CONVERTER (converter);

	if (conv->iconv == NULL)
	{
	g_warning ("Invalid object, not initialized");
	return;
	}

	g_iconv (conv->iconv, NULL, NULL, NULL, NULL);
	conv->n_fallback_errors = 0;
	}

	static GConverterResult
	g_charset_converter_convert (GConverter *converter,
	const void *inbuf,
	gsize inbuf_size,
	void *outbuf,
	gsize outbuf_size,
	GConverterFlags flags,
	gsize *bytes_read,
	gsize *bytes_written,
	GError **error)
	{
	GCharsetConverter *conv;
	gsize res;
	GConverterResult ret;
	gchar inbufp, outbufp;
	gsize in_left, out_left;
	int errsv;
	gboolean reset;

	conv = G_CHARSET_CONVERTER (converter);

	if (conv->iconv == NULL)
	{
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED,
	_("Invalid object, not initialized"));
	return G_CONVERTER_ERROR;
	}

	inbufp = (char *)inbuf;
	outbufp = (char *)outbuf;
	in_left = inbuf_size;
	out_left = outbuf_size;
	reset = FALSE;

	/* if there is not input try to flush the data */
	if (inbuf_size == 0)
	{
	if (flags & G_CONVERTER_INPUT_AT_END \|\|
	flags & G_CONVERTER_FLUSH)
	{
	reset = TRUE;
	}
	else
	{
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT,
	_("Incomplete multibyte sequence in input"));
	return G_CONVERTER_ERROR;
	}
	}

	if (reset)
	/* call g_iconv with NULL inbuf to cleanup shift state */
	res = g_iconv (conv->iconv,
	NULL, &in_left,
	&outbufp, &out_left);
	else
	res = g_iconv (conv->iconv,
	&inbufp, &in_left,
	&outbufp, &out_left);

	bytes_read = inbufp - (char )inbuf;
	bytes_written = outbufp - (char )outbuf;

	/* Don't report error if we converted anything */
	if (res == (gsize) -1 && *bytes_read == 0)
	{
	errsv = errno;

	switch (errsv)
	{
	case EINVAL:
	/* Incomplete input text */
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT,
	_("Incomplete multibyte sequence in input"));
	break;

	case E2BIG:
	/* Not enough destination space */
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE,
	_("Not enough space in destination"));
	break;

	case EILSEQ:
	/* Invalid code sequence */
	if (conv->use_fallback)
	{
	if (outbuf_size < 3)
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE,
	_("Not enough space in destination"));
	else
	{
	const char hex[] = "0123456789ABCDEF";
	guint8 v = (guint8 )inbuf;
	guint8 out = (guint8 )outbuf;
	out[0] = '\\';
	out[1] = hex[(v & 0xf0) >> 4];
	out[2] = hex[(v & 0x0f) >> 0];
	*bytes_read = 1;
	*bytes_written = 3;
	in_left--;
	conv->n_fallback_errors++;
	goto ok;
	}
	}
	else
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
	_("Invalid byte sequence in conversion input"));
	break;

	default:
	g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
	_("Error during conversion: %s"),
	g_strerror (errsv));
	break;
	}
	ret = G_CONVERTER_ERROR;
	}
	else
	{
	ok:
	ret = G_CONVERTER_CONVERTED;

	if (reset &&
	(flags & G_CONVERTER_INPUT_AT_END))
	ret = G_CONVERTER_FINISHED;
	else if (reset &&
	(flags & G_CONVERTER_FLUSH))
	ret = G_CONVERTER_FLUSHED;
	}

	return ret;
	}

	/**
	* g_charset_converter_set_use_fallback:
	* @converter: a #GCharsetConverter
	* @use_fallback: %TRUE to use fallbacks
	*
	* Sets the #GCharsetConverter:use-fallback property.
	*
	* Since: 2.24
	*/
	void
	g_charset_converter_set_use_fallback (GCharsetConverter *converter,
	gboolean use_fallback)
	{
	use_fallback = !!use_fallback;

	if (converter->use_fallback != use_fallback)
	{
	converter->use_fallback = use_fallback;
	g_object_notify (G_OBJECT (converter), "use-fallback");
	}
	}

	/**
	* g_charset_converter_get_use_fallback:
	* @converter: a #GCharsetConverter
	*
	* Gets the #GCharsetConverter:use-fallback property.
	*
	* Returns: %TRUE if fallbacks are used by @converter
	*
	* Since: 2.24
	*/
	gboolean
	g_charset_converter_get_use_fallback (GCharsetConverter *converter)
	{
	return converter->use_fallback;
	}

	/**
	* g_charset_converter_get_num_fallbacks:
	* @converter: a #GCharsetConverter
	*
	* Gets the number of fallbacks that @converter has applied so far.
	*
	* Returns: the number of fallbacks that @converter has applied
	*
	* Since: 2.24
	*/
	guint
	g_charset_converter_get_num_fallbacks (GCharsetConverter *converter)
	{
	return converter->n_fallback_errors;
	}

	static void
	g_charset_converter_iface_init (GConverterIface *iface)
	{
	iface->convert = g_charset_converter_convert;
	iface->reset = g_charset_converter_reset;
	}

	static gboolean
	g_charset_converter_initable_init (GInitable *initable,
	GCancellable *cancellable,
	GError **error)
	{
	GCharsetConverter *conv;
	int errsv;

	g_return_val_if_fail (G_IS_CHARSET_CONVERTER (initable), FALSE);

	conv = G_CHARSET_CONVERTER (initable);

	if (cancellable != NULL)
	{
	g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
	_("Cancellable initialization not supported"));
	return FALSE;
	}

	conv->iconv = g_iconv_open (conv->to, conv->from);
	errsv = errno;

	if (conv->iconv == (GIConv)-1)
	{
	if (errsv == EINVAL)
	g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
	_("Conversion from character set “%s” to “%s” is not supported"),
	conv->from, conv->to);
	else
	g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
	_("Could not open converter from “%s” to “%s”"),
	conv->from, conv->to);
	return FALSE;
	}

	return TRUE;
	}

	static void
	g_charset_converter_initable_iface_init (GInitableIface *iface)
	{
	iface->init = g_charset_converter_initable_init;
	}