glib/gconvert.c

   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  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <iconv.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27
  28 #include "glib.h"
  29 #include "config.h"
  30
  31 #ifdef G_PLATFORM_WIN32
  32 #define STRICT
  33 #include <windows.h>
  34 #undef STRICT
  35 #endif
  36
  37 #include "glibintl.h"
  38
  39 GQuark
  40 g_convert_error_quark()
  41 {
  42   static GQuark quark;
  43   if (!quark)
  44     quark = g_quark_from_static_string ("g_convert_error");
  45
  46   return quark;
  47 }
  48
  49 #if defined(USE_LIBICONV) && !defined (_LIBICONV_H)
  50 #error libiconv in use but included iconv.h not from libiconv
  51 #endif
  52 #if !defined(USE_LIBICONV) && defined (_LIBICONV_H)
  53 #error libiconv not in use but included iconv.h is from libiconv
  54 #endif
  55
  56 static gboolean
  57 try_conversion (const char *to_codeset,
  58                 const char *from_codeset,
  59                 iconv_t    *cd)
  60 {
  61   *cd = iconv_open (to_codeset, from_codeset);
  62
  63   if (*cd == (iconv_t)-1 && errno == EINVAL)
  64     return FALSE;
  65   else
  66     return TRUE;
  67 }
  68
  69 static gboolean
  70 try_to_aliases (const char **to_aliases,
  71                 const char  *from_codeset,
  72                 iconv_t     *cd)
  73 {
  74   if (to_aliases)
  75     {
  76       const char **p = to_aliases;
  77       while (*p)
  78         {
  79           if (try_conversion (*p, from_codeset, cd))
  80             return TRUE;
  81
  82           p++;
  83         }
  84     }
  85
  86   return FALSE;
  87 }
  88
  89 extern const char **_g_charset_get_aliases (const char *canonical_name);
  90
  91 /**
  92  * g_iconv_open:
  93  * @to_codeset: destination codeset
  94  * @from_codeset: source codeset
  95  *
  96  * Same as the standard UNIX routine <function>iconv_open()</function>, but
  97  * may be implemented via libiconv on UNIX flavors that lack
  98  * a native implementation.
  99  *
 100  * GLib provides g_convert() and g_locale_to_utf8() which are likely
 101  * more convenient than the raw iconv wrappers.
 102  *
 103  * Return value: a "conversion descriptor"
 104  **/
 105 GIConv
 106 g_iconv_open (const gchar  *to_codeset,
 107               const gchar  *from_codeset)
 108 {
 109   iconv_t cd;
 110
 111   if (!try_conversion (to_codeset, from_codeset, &cd))
 112     {
 113       const char **to_aliases = _g_charset_get_aliases (to_codeset);
 114       const char **from_aliases = _g_charset_get_aliases (from_codeset);
 115
 116       if (from_aliases)
 117         {
 118           const char **p = from_aliases;
 119           while (*p)
 120             {
 121               if (try_conversion (to_codeset, *p, &cd))
 122                 return (GIConv)cd;
 123
 124               if (try_to_aliases (to_aliases, *p, &cd))
 125                 return (GIConv)cd;
 126
 127               p++;
 128             }
 129         }
 130
 131       if (try_to_aliases (to_aliases, from_codeset, &cd))
 132         return (GIConv)cd;
 133     }
 134
 135   return (GIConv)cd;
 136 }
 137
 138 /**
 139  * g_iconv:
 140  * @converter: conversion descriptor from g_iconv_open()
 141  * @inbuf: bytes to convert
 142  * @inbytes_left: inout parameter, bytes remaining to convert in @inbuf
 143  * @outbuf: converted output bytes
 144  * @outbytes_left: inout parameter, bytes available to fill in @outbuf
 145  *
 146  * Same as the standard UNIX routine <function>iconv()</function>, but
 147  * may be implemented via libiconv on UNIX flavors that lack
 148  * a native implementation.
 149  *
 150  * GLib provides g_convert() and g_locale_to_utf8() which are likely
 151  * more convenient than the raw iconv wrappers.
 152  *
 153  * Return value: count of non-reversible conversions, or -1 on error
 154  **/
 155 size_t
 156 g_iconv (GIConv   converter,
 157          gchar  **inbuf,
 158          gsize   *inbytes_left,
 159          gchar  **outbuf,
 160          gsize   *outbytes_left)
 161 {
 162   iconv_t cd = (iconv_t)converter;
 163
 164   return iconv (cd, inbuf, inbytes_left, outbuf, outbytes_left);
 165 }
 166
 167 /**
 168  * g_iconv_close:
 169  * @converter: a conversion descriptor from g_iconv_open()
 170  *
 171  * Same as the standard UNIX routine <function>iconv_close()</function>, but
 172  * may be implemented via libiconv on UNIX flavors that lack
 173  * a native implementation. Should be called to clean up
 174  * the conversion descriptor from g_iconv_open() when
 175  * you are done converting things.
 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: -1 on error, 0 on success
 181  **/
 182 gint
 183 g_iconv_close (GIConv converter)
 184 {
 185   iconv_t cd = (iconv_t)converter;
 186
 187   return iconv_close (cd);
 188 }
 189
 190 static GIConv
 191 open_converter (const gchar *to_codeset,
 192                 const gchar *from_codeset,
 193                 GError     **error)
 194 {
 195   GIConv cd = g_iconv_open (to_codeset, from_codeset);
 196
 197   if (cd == (iconv_t) -1)
 198     {
 199       /* Something went wrong.  */
 200       if (errno == EINVAL)
 201         g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,
 202                      _("Conversion from character set '%s' to '%s' is not supported"),
 203                      from_codeset, to_codeset);
 204       else
 205         g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
 206                      _("Could not open converter from '%s' to '%s': %s"),
 207                      from_codeset, to_codeset, strerror (errno));
 208     }
 209
 210   return cd;
 211
 212 }
 213
 214 /**
 215  * g_convert:
 216  * @str:           the string to convert
 217  * @len:           the length of the string
 218  * @to_codeset:    name of character set into which to convert @str
 219  * @from_codeset:  character set of @str.
 220  * @bytes_read:    location to store the number of bytes in the
 221  *                 input string that were successfully converted, or %NULL.
 222  *                 Even if the conversion was successful, this may be
 223  *                 less than @len if there were partial characters
 224  *                 at the end of the input. If the error
 225  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
 226  *                 stored will the byte offset after the last valid
 227  *                 input sequence.
 228  * @bytes_written: the number of bytes stored in the output buffer (not
 229  *                 including the terminating nul).
 230  * @error:         location to store the error occuring, or %NULL to ignore
 231  *                 errors. Any of the errors in #GConvertError may occur.
 232  *
 233  * Converts a string from one character set to another.
 234  *
 235  * Return value: If the conversion was successful, a newly allocated
 236  *               nul-terminated string, which must be freed with
 237  *               g_free(). Otherwise %NULL and @error will be set.
 238  **/
 239 gchar*
 240 g_convert (const gchar *str,
 241            gssize       len,
 242            const gchar *to_codeset,
 243            const gchar *from_codeset,
 244            gsize       *bytes_read,
 245            gsize       *bytes_written,
 246            GError     **error)
 247 {
 248   gchar *res;
 249   GIConv cd;
 250
 251   g_return_val_if_fail (str != NULL, NULL);
 252   g_return_val_if_fail (to_codeset != NULL, NULL);
 253   g_return_val_if_fail (from_codeset != NULL, NULL);
 254
 255   cd = open_converter (to_codeset, from_codeset, error);
 256
 257   if (cd == (GIConv) -1)
 258     {
 259       if (bytes_read)
 260         *bytes_read = 0;
 261
 262       if (bytes_written)
 263         *bytes_written = 0;
 264
 265       return NULL;
 266     }
 267
 268   res = g_convert_with_iconv (str, len, cd,
 269                               bytes_read, bytes_written,
 270                               error);
 271
 272   g_iconv_close (cd);
 273
 274   return res;
 275 }
 276
 277 /**
 278  * g_convert_with_iconv:
 279  * @str:           the string to convert
 280  * @len:           the length of the string
 281  * @converter:     conversion descriptor from g_iconv_open()
 282  * @bytes_read:    location to store the number of bytes in the
 283  *                 input string that were successfully converted, or %NULL.
 284  *                 Even if the conversion was successful, this may be
 285  *                 less than @len if there were partial characters
 286  *                 at the end of the input. If the error
 287  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
 288  *                 stored will the byte offset after the last valid
 289  *                 input sequence.
 290  * @bytes_written: the number of bytes stored in the output buffer (not
 291  *                 including the terminating nul).
 292  * @error:         location to store the error occuring, or %NULL to ignore
 293  *                 errors. Any of the errors in #GConvertError may occur.
 294  *
 295  * Converts a string from one character set to another.
 296  *
 297  * Return value: If the conversion was successful, a newly allocated
 298  *               nul-terminated string, which must be freed with
 299  *               g_free(). Otherwise %NULL and @error will be set.
 300  **/
 301 gchar*
 302 g_convert_with_iconv (const gchar *str,
 303                       gssize       len,
 304                       GIConv       converter,
 305                       gsize       *bytes_read,
 306                       gsize       *bytes_written,
 307                       GError     **error)
 308 {
 309   gchar *dest;
 310   gchar *outp;
 311   const gchar *p;
 312   gsize inbytes_remaining;
 313   gsize outbytes_remaining;
 314   gsize err;
 315   gsize outbuf_size;
 316   gboolean have_error = FALSE;
 317
 318   g_return_val_if_fail (str != NULL, NULL);
 319   g_return_val_if_fail (converter != (GIConv) -1, NULL);
 320
 321   if (len < 0)
 322     len = strlen (str);
 323
 324   p = str;
 325   inbytes_remaining = len;
 326   outbuf_size = len + 1; /* + 1 for nul in case len == 1 */
 327
 328   outbytes_remaining = outbuf_size - 1; /* -1 for nul */
 329   outp = dest = g_malloc (outbuf_size);
 330
 331  again:
 332
 333   err = g_iconv (converter, (char **)&p, &inbytes_remaining, &outp, &outbytes_remaining);
 334
 335   if (err == (size_t) -1)
 336     {
 337       switch (errno)
 338         {
 339         case EINVAL:
 340           /* Incomplete text, do not report an error */
 341           break;
 342         case E2BIG:
 343           {
 344             size_t used = outp - dest;
 345
 346             outbuf_size *= 2;
 347             dest = g_realloc (dest, outbuf_size);
 348
 349             outp = dest + used;
 350             outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */
 351
 352             goto again;
 353           }
 354         case EILSEQ:
 355           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
 356                        _("Invalid byte sequence in conversion input"));
 357           have_error = TRUE;
 358           break;
 359         default:
 360           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
 361                        _("Error during conversion: %s"),
 362                        strerror (errno));
 363           have_error = TRUE;
 364           break;
 365         }
 366     }
 367
 368   *outp = '\0';
 369
 370   if (bytes_read)
 371     *bytes_read = p - str;
 372   else
 373     {
 374       if ((p - str) != len)
 375         {
 376           if (!have_error)
 377             {
 378               g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_PARTIAL_INPUT,
 379                            _("Partial character sequence at end of input"));
 380               have_error = TRUE;
 381             }
 382         }
 383     }
 384
 385   if (bytes_written)
 386     *bytes_written = outp - dest;       /* Doesn't include '\0' */
 387
 388   if (have_error)
 389     {
 390       g_free (dest);
 391       return NULL;
 392     }
 393   else
 394     return dest;
 395 }
 396
 397 /**
 398  * g_convert_with_fallback:
 399  * @str:          the string to convert
 400  * @len:          the length of the string
 401  * @to_codeset:   name of character set into which to convert @str
 402  * @from_codeset: character set of @str.
 403  * @fallback:     UTF-8 string to use in place of character not
 404  *                present in the target encoding. (This must be
 405  *                in the target encoding), if %NULL, characters
 406  *                not in the target encoding will be represented
 407  *                as Unicode escapes \x{XXXX} or \x{XXXXXX}.
 408  * @bytes_read:   location to store the number of bytes in the
 409  *                input string that were successfully converted, or %NULL.
 410  *                Even if the conversion was successful, this may be
 411  *                less than @len if there were partial characters
 412  *                at the end of the input.
 413  * @bytes_written: the number of bytes stored in the output buffer (not
 414  *                including the terminating nul).
 415  * @error:        location to store the error occuring, or %NULL to ignore
 416  *                errors. Any of the errors in #GConvertError may occur.
 417  *
 418  * Converts a string from one character set to another, possibly
 419  * including fallback sequences for characters not representable
 420  * in the output. Note that it is not guaranteed that the specification
 421  * for the fallback sequences in @fallback will be honored. Some
 422  * systems may do a approximate conversion from @from_codeset
 423  * to @to_codeset in their <function>iconv()</function> functions,
 424  * in which case GLib will simply return that approximate conversion.
 425  *
 426  * Return value: If the conversion was successful, a newly allocated
 427  *               nul-terminated string, which must be freed with
 428  *               g_free(). Otherwise %NULL and @error will be set.
 429  **/
 430 gchar*
 431 g_convert_with_fallback (const gchar *str,
 432                          gssize       len,
 433                          const gchar *to_codeset,
 434                          const gchar *from_codeset,
 435                          gchar       *fallback,
 436                          gsize       *bytes_read,
 437                          gsize       *bytes_written,
 438                          GError     **error)
 439 {
 440   gchar *utf8;
 441   gchar *dest;
 442   gchar *outp;
 443   const gchar *insert_str = NULL;
 444   const gchar *p;
 445   gsize inbytes_remaining;
 446   const gchar *save_p = NULL;
 447   gsize save_inbytes = 0;
 448   gsize outbytes_remaining;
 449   gsize err;
 450   GIConv cd;
 451   gsize outbuf_size;
 452   gboolean have_error = FALSE;
 453   gboolean done = FALSE;
 454
 455   GError *local_error = NULL;
 456
 457   g_return_val_if_fail (str != NULL, NULL);
 458   g_return_val_if_fail (to_codeset != NULL, NULL);
 459   g_return_val_if_fail (from_codeset != NULL, NULL);
 460
 461   if (len < 0)
 462     len = strlen (str);
 463
 464   /* Try an exact conversion; we only proceed if this fails
 465    * due to an illegal sequence in the input string.
 466    */
 467   dest = g_convert (str, len, to_codeset, from_codeset,
 468                     bytes_read, bytes_written, &local_error);
 469   if (!local_error)
 470     return dest;
 471
 472   if (!g_error_matches (local_error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
 473     {
 474       g_propagate_error (error, local_error);
 475       return NULL;
 476     }
 477   else
 478     g_error_free (local_error);
 479
 480   local_error = NULL;
 481
 482   /* No go; to proceed, we need a converter from "UTF-8" to
 483    * to_codeset, and the string as UTF-8.
 484    */
 485   cd = open_converter (to_codeset, "UTF-8", error);
 486   if (cd == (GIConv) -1)
 487     {
 488       if (bytes_read)
 489         *bytes_read = 0;
 490
 491       if (bytes_written)
 492         *bytes_written = 0;
 493
 494       return NULL;
 495     }
 496
 497   utf8 = g_convert (str, len, "UTF-8", from_codeset,
 498                     bytes_read, &inbytes_remaining, error);
 499   if (!utf8)
 500     {
 501       g_iconv_close (cd);
 502       if (bytes_written)
 503         *bytes_written = 0;
 504       return NULL;
 505     }
 506
 507   /* Now the heart of the code. We loop through the UTF-8 string, and
 508    * whenever we hit an offending character, we form fallback, convert
 509    * the fallback to the target codeset, and then go back to
 510    * converting the original string after finishing with the fallback.
 511    *
 512    * The variables save_p and save_inbytes store the input state
 513    * for the original string while we are converting the fallback
 514    */
 515   p = utf8;
 516
 517   outbuf_size = len + 1; /* + 1 for nul in case len == 1 */
 518   outbytes_remaining = outbuf_size - 1; /* -1 for nul */
 519   outp = dest = g_malloc (outbuf_size);
 520
 521   while (!done && !have_error)
 522     {
 523       size_t inbytes_tmp = inbytes_remaining;
 524       err = g_iconv (cd, (char **)&p, &inbytes_tmp, &outp, &outbytes_remaining);
 525       inbytes_remaining = inbytes_tmp;
 526
 527       if (err == (size_t) -1)
 528         {
 529           switch (errno)
 530             {
 531             case EINVAL:
 532               g_assert_not_reached();
 533               break;
 534             case E2BIG:
 535               {
 536                 size_t used = outp - dest;
 537
 538                 outbuf_size *= 2;
 539                 dest = g_realloc (dest, outbuf_size);
 540
 541                 outp = dest + used;
 542                 outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */
 543
 544                 break;
 545               }
 546             case EILSEQ:
 547               if (save_p)
 548                 {
 549                   /* Error converting fallback string - fatal
 550                    */
 551                   g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
 552                                _("Cannot convert fallback '%s' to codeset '%s'"),
 553                                insert_str, to_codeset);
 554                   have_error = TRUE;
 555                   break;
 556                 }
 557               else
 558                 {
 559                   if (!fallback)
 560                     {
 561                       gunichar ch = g_utf8_get_char (p);
 562                       insert_str = g_strdup_printf ("\\x{%0*X}",
 563                                                     (ch < 0x10000) ? 4 : 6,
 564                                                     ch);
 565                     }
 566                   else
 567                     insert_str = fallback;
 568
 569                   save_p = g_utf8_next_char (p);
 570                   save_inbytes = inbytes_remaining - (save_p - p);
 571                   p = insert_str;
 572                   inbytes_remaining = strlen (p);
 573                 }
 574               break;
 575             default:
 576               g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
 577                            _("Error during conversion: %s"),
 578                            strerror (errno));
 579               have_error = TRUE;
 580               break;
 581             }
 582         }
 583       else
 584         {
 585           if (save_p)
 586             {
 587               if (!fallback)
 588                 g_free ((gchar *)insert_str);
 589               p = save_p;
 590               inbytes_remaining = save_inbytes;
 591               save_p = NULL;
 592             }
 593           else
 594             done = TRUE;
 595         }
 596     }
 597
 598   /* Cleanup
 599    */
 600   *outp = '\0';
 601
 602   g_iconv_close (cd);
 603
 604   if (bytes_written)
 605     *bytes_written = outp - dest;       /* Doesn't include '\0' */
 606
 607   g_free (utf8);
 608
 609   if (have_error)
 610     {
 611       if (save_p && !fallback)
 612         g_free ((gchar *)insert_str);
 613       g_free (dest);
 614       return NULL;
 615     }
 616   else
 617     return dest;
 618 }
 619
 620 /*
 621  * g_locale_to_utf8
 622  *
 623  *
 624  */
 625
 626 static gchar *
 627 strdup_len (const gchar *string,
 628             gssize       len,
 629             gsize       *bytes_written,
 630             gsize       *bytes_read,
 631             GError      **error)
 632
 633 {
 634   gsize real_len;
 635
 636   if (!g_utf8_validate (string, -1, NULL))
 637     {
 638       if (bytes_read)
 639         *bytes_read = 0;
 640       if (bytes_written)
 641         *bytes_written = 0;
 642
 643       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
 644                    _("Invalid byte sequence in conversion input"));
 645       return NULL;
 646     }
 647
 648   if (len < 0)
 649     real_len = strlen (string);
 650   else
 651     {
 652       real_len = 0;
 653
 654       while (real_len < len && string[real_len])
 655         real_len++;
 656     }
 657
 658   if (bytes_read)
 659     *bytes_read = real_len;
 660   if (bytes_written)
 661     *bytes_written = real_len;
 662
 663   return g_strndup (string, real_len);
 664 }
 665
 666 /**
 667  * g_locale_to_utf8:
 668  * @opsysstring:   a string in the encoding of the current locale
 669  * @len:           the length of the string, or -1 if the string is
 670  *                 nul-terminated.
 671  * @bytes_read:    location to store the number of bytes in the
 672  *                 input string that were successfully converted, or %NULL.
 673  *                 Even if the conversion was successful, this may be
 674  *                 less than @len if there were partial characters
 675  *                 at the end of the input. If the error
 676  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
 677  *                 stored will the byte offset after the last valid
 678  *                 input sequence.
 679  * @bytes_written: the number of bytes stored in the output buffer (not
 680  *                 including the terminating nul).
 681  * @error:         location to store the error occuring, or %NULL to ignore
 682  *                 errors. Any of the errors in #GConvertError may occur.
 683  *
 684  * Converts a string which is in the encoding used for strings by
 685  * the C runtime (usually the same as that used by the operating
 686  * system) in the current locale into a UTF-8 string.
 687  *
 688  * Return value: The converted string, or %NULL on an error.
 689  **/
 690 gchar *
 691 g_locale_to_utf8 (const gchar  *opsysstring,
 692                   gssize        len,
 693                   gsize        *bytes_read,
 694                   gsize        *bytes_written,
 695                   GError      **error)
 696 {
 697 #ifdef G_PLATFORM_WIN32
 698
 699   gint i, clen, total_len, wclen, first;
 700   wchar_t *wcs, wc;
 701   gchar *result, *bp;
 702   const wchar_t *wcp;
 703
 704   if (len == -1)
 705     len = strlen (opsysstring);
 706
 707   wcs = g_new (wchar_t, len);
 708   wclen = MultiByteToWideChar (CP_ACP, 0, opsysstring, len, wcs, len);
 709
 710   wcp = wcs;
 711   total_len = 0;
 712   for (i = 0; i < wclen; i++)
 713     {
 714       wc = *wcp++;
 715
 716       if (wc < 0x80)
 717         total_len += 1;
 718       else if (wc < 0x800)
 719         total_len += 2;
 720       else if (wc < 0x10000)
 721         total_len += 3;
 722       else if (wc < 0x200000)
 723         total_len += 4;
 724       else if (wc < 0x4000000)
 725         total_len += 5;
 726       else
 727         total_len += 6;
 728     }
 729
 730   result = g_malloc (total_len + 1);
 731
 732   wcp = wcs;
 733   bp = result;
 734   for (i = 0; i < wclen; i++)
 735     {
 736       wc = *wcp++;
 737
 738       if (wc < 0x80)
 739         {
 740           first = 0;
 741           clen = 1;
 742         }
 743       else if (wc < 0x800)
 744         {
 745           first = 0xc0;
 746           clen = 2;
 747         }
 748       else if (wc < 0x10000)
 749         {
 750           first = 0xe0;
 751           clen = 3;
 752         }
 753       else if (wc < 0x200000)
 754         {
 755           first = 0xf0;
 756           clen = 4;
 757         }
 758       else if (wc < 0x4000000)
 759         {
 760           first = 0xf8;
 761           clen = 5;
 762         }
 763       else
 764         {
 765           first = 0xfc;
 766           clen = 6;
 767         }
 768
 769       /* Woo-hoo! */
 770       switch (clen)
 771         {
 772         case 6: bp[5] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
 773         case 5: bp[4] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
 774         case 4: bp[3] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
 775         case 3: bp[2] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
 776         case 2: bp[1] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
 777         case 1: bp[0] = wc | first;
 778         }
 779
 780       bp += clen;
 781     }
 782   *bp = 0;
 783
 784   g_free (wcs);
 785
 786   if (bytes_read)
 787     *bytes_read = len;
 788   if (bytes_written)
 789     *bytes_written = total_len;
 790
 791   return result;
 792
 793 #else  /* !G_PLATFORM_WIN32 */
 794
 795   const char *charset;
 796
 797   if (g_get_charset (&charset))
 798     return strdup_len (opsysstring, len, bytes_read, bytes_written, error);
 799   else
 800     return g_convert (opsysstring, len,
 801                       "UTF-8", charset, bytes_read, bytes_written, error);
 802
 803 #endif /* !G_PLATFORM_WIN32 */
 804 }
 805
 806 /**
 807  * g_locale_from_utf8:
 808  * @utf8string:    a UTF-8 encoded string
 809  * @len:           the length of the string, or -1 if the string is
 810  *                 nul-terminated.
 811  * @bytes_read:    location to store the number of bytes in the
 812  *                 input string that were successfully converted, or %NULL.
 813  *                 Even if the conversion was successful, this may be
 814  *                 less than @len if there were partial characters
 815  *                 at the end of the input. If the error
 816  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
 817  *                 stored will the byte offset after the last valid
 818  *                 input sequence.
 819  * @bytes_written: the number of bytes stored in the output buffer (not
 820  *                 including the terminating nul).
 821  * @error:         location to store the error occuring, or %NULL to ignore
 822  *                 errors. Any of the errors in #GConvertError may occur.
 823  *
 824  * Converts a string from UTF-8 to the encoding used for strings by
 825  * the C runtime (usually the same as that used by the operating
 826  * system) in the current locale.
 827  *
 828  * Return value: The converted string, or %NULL on an error.
 829  **/
 830 gchar *
 831 g_locale_from_utf8 (const gchar *utf8string,
 832                     gssize       len,
 833                     gsize       *bytes_read,
 834                     gsize       *bytes_written,
 835                     GError     **error)
 836 {
 837 #ifdef G_PLATFORM_WIN32
 838
 839   gint i, mask, clen, mblen;
 840   wchar_t *wcs, *wcp;
 841   gchar *result;
 842   guchar *cp, *end, c;
 843   gint n;
 844
 845   if (len == -1)
 846     len = strlen (utf8string);
 847
 848   /* First convert to wide chars */
 849   cp = (guchar *) utf8string;
 850   end = cp + len;
 851   n = 0;
 852   wcs = g_new (wchar_t, len + 1);
 853   wcp = wcs;
 854   while (cp != end)
 855     {
 856       mask = 0;
 857       c = *cp;
 858
 859       if (c < 0x80)
 860         {
 861           clen = 1;
 862           mask = 0x7f;
 863         }
 864       else if ((c & 0xe0) == 0xc0)
 865         {
 866           clen = 2;
 867           mask = 0x1f;
 868         }
 869       else if ((c & 0xf0) == 0xe0)
 870         {
 871           clen = 3;
 872           mask = 0x0f;
 873         }
 874       else if ((c & 0xf8) == 0xf0)
 875         {
 876           clen = 4;
 877           mask = 0x07;
 878         }
 879       else if ((c & 0xfc) == 0xf8)
 880         {
 881           clen = 5;
 882           mask = 0x03;
 883         }
 884       else if ((c & 0xfc) == 0xfc)
 885         {
 886           clen = 6;
 887           mask = 0x01;
 888         }
 889       else
 890         {
 891           g_free (wcs);
 892           return NULL;
 893         }
 894
 895       if (cp + clen > end)
 896         {
 897           g_free (wcs);
 898           return NULL;
 899         }
 900
 901       *wcp = (cp[0] & mask);
 902       for (i = 1; i < clen; i++)
 903         {
 904           if ((cp[i] & 0xc0) != 0x80)
 905             {
 906               g_free (wcs);
 907               return NULL;
 908             }
 909           *wcp <<= 6;
 910           *wcp |= (cp[i] & 0x3f);
 911         }
 912
 913       cp += clen;
 914       wcp++;
 915       n++;
 916     }
 917   if (cp != end)
 918     {
 919       g_free (wcs);
 920       return NULL;
 921     }
 922
 923   /* n is the number of wide chars constructed */
 924
 925   /* Convert to a string in the current ANSI codepage */
 926
 927   result = g_new (gchar, 3 * n + 1);
 928   mblen = WideCharToMultiByte (CP_ACP, 0, wcs, n, result, 3*n, NULL, NULL);
 929   result[mblen] = 0;
 930   g_free (wcs);
 931
 932   if (bytes_read)
 933     *bytes_read = len;
 934   if (bytes_written)
 935     *bytes_written = mblen;
 936
 937   return result;
 938
 939 #else  /* !G_PLATFORM_WIN32 */
 940
 941   const gchar *charset;
 942
 943   if (g_get_charset (&charset))
 944     return strdup_len (utf8string, len, bytes_read, bytes_written, error);
 945   else
 946     return g_convert (utf8string, len,
 947                       charset, "UTF-8", bytes_read, bytes_written, error);
 948
 949 #endif /* !G_PLATFORM_WIN32 */
 950 }
 951
 952 /**
 953  * g_filename_to_utf8:
 954  * @opsysstring:   a string in the encoding for filenames
 955  * @len:           the length of the string, or -1 if the string is
 956  *                 nul-terminated.
 957  * @bytes_read:    location to store the number of bytes in the
 958  *                 input string that were successfully converted, or %NULL.
 959  *                 Even if the conversion was successful, this may be
 960  *                 less than @len if there were partial characters
 961  *                 at the end of the input. If the error
 962  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
 963  *                 stored will the byte offset after the last valid
 964  *                 input sequence.
 965  * @bytes_written: the number of bytes stored in the output buffer (not
 966  *                 including the terminating nul).
 967  * @error:         location to store the error occuring, or %NULL to ignore
 968  *                 errors. Any of the errors in #GConvertError may occur.
 969  *
 970  * Converts a string which is in the encoding used for filenames
 971  * into a UTF-8 string.
 972  *
 973  * Return value: The converted string, or %NULL on an error.
 974  **/
 975 gchar*
 976 g_filename_to_utf8 (const gchar *opsysstring,
 977                     gssize       len,
 978                     gsize       *bytes_read,
 979                     gsize       *bytes_written,
 980                     GError     **error)
 981 {
 982 #ifdef G_PLATFORM_WIN32
 983   return g_locale_to_utf8 (opsysstring, len,
 984                            bytes_read, bytes_written,
 985                            error);
 986 #else  /* !G_PLATFORM_WIN32 */
 987
 988   if (getenv ("G_BROKEN_FILENAMES"))
 989     return g_locale_to_utf8 (opsysstring, len,
 990                              bytes_read, bytes_written,
 991                              error);
 992   else
 993     return strdup_len (opsysstring, len, bytes_read, bytes_written, error);
 994 #endif /* !G_PLATFORM_WIN32 */
 995 }
 996
 997 /**
 998  * g_filename_from_utf8:
 999  * @utf8string:    a UTF-8 encoded string.
1000  * @len:           the length of the string, or -1 if the string is
1001  *                 nul-terminated.
1002  * @bytes_read:    location to store the number of bytes in the
1003  *                 input string that were successfully converted, or %NULL.
1004  *                 Even if the conversion was successful, this may be
1005  *                 less than @len if there were partial characters
1006  *                 at the end of the input. If the error
1007  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
1008  *                 stored will the byte offset after the last valid
1009  *                 input sequence.
1010  * @bytes_written: the number of bytes stored in the output buffer (not
1011  *                 including the terminating nul).
1012  * @error:         location to store the error occuring, or %NULL to ignore
1013  *                 errors. Any of the errors in #GConvertError may occur.
1014  *
1015  * Converts a string from UTF-8 to the encoding used for filenames.
1016  *
1017  * Return value: The converted string, or %NULL on an error.
1018  **/
1019 gchar*
1020 g_filename_from_utf8 (const gchar *utf8string,
1021                       gssize       len,
1022                       gsize       *bytes_read,
1023                       gsize       *bytes_written,
1024                       GError     **error)
1025 {
1026 #ifdef G_PLATFORM_WIN32
1027   return g_locale_from_utf8 (utf8string, len,
1028                              bytes_read, bytes_written,
1029                              error);
1030 #else  /* !G_PLATFORM_WIN32 */
1031   if (getenv ("G_BROKEN_FILENAMES"))
1032     return g_locale_from_utf8 (utf8string, len,
1033                                bytes_read, bytes_written,
1034                                error);
1035   else
1036     return strdup_len (utf8string, len, bytes_read, bytes_written, error);
1037 #endif /* !G_PLATFORM_WIN32 */
1038 }
1039
1040 /* Test of haystack has the needle prefix, comparing case
1041  * insensitive. haystack may be UTF-8, but needle must
1042  * contain only ascii. */
1043 static gboolean
1044 has_case_prefix (const gchar *haystack, const gchar *needle)
1045 {
1046   const gchar *h, *n;
1047
1048   /* Eat one character at a time. */
1049   h = haystack;
1050   n = needle;
1051
1052   while (*n && *h &&
1053          g_ascii_tolower (*n) == g_ascii_tolower (*h))
1054     {
1055       n++;
1056       h++;
1057     }
1058
1059   return *n == '\0';
1060 }
1061
1062 typedef enum {
1063   UNSAFE_ALL        = 0x1,  /* Escape all unsafe characters   */
1064   UNSAFE_ALLOW_PLUS = 0x2,  /* Allows '+'  */
1065   UNSAFE_PATH       = 0x4,  /* Allows '/' and '?' and '&' and '='  */
1066   UNSAFE_DOS_PATH   = 0x8,  /* Allows '/' and '?' and '&' and '=' and ':' */
1067   UNSAFE_HOST       = 0x10, /* Allows '/' and ':' and '@' */
1068   UNSAFE_SLASHES    = 0x20  /* Allows all characters except for '/' and '%' */
1069 } UnsafeCharacterSet;
1070
1071 static const guchar acceptable[96] = {
1072  /* X0   X1   X2   X3   X4   X5   X6   X7   X8   X9   XA   XB   XC   XD   XE   XF */
1073   0x00,0x3F,0x20,0x20,0x20,0x00,0x2C,0x3F,0x3F,0x3F,0x3F,0x22,0x20,0x3F,0x3F,0x1C, /* 2X  !"#$%&'()*+,-./   */
1074   0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x38,0x20,0x20,0x2C,0x20,0x2C, /* 3X 0123456789:;<=>?   */
1075   0x30,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F, /* 4X @ABCDEFGHIJKLMNO   */
1076   0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x20,0x3F, /* 5X PQRSTUVWXYZ[\]^_   */
1077   0x20,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F, /* 6X `abcdefghijklmno   */
1078   0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x3F,0x20  /* 7X pqrstuvwxyz{|}~DEL */
1079 };
1080
1081 static const gchar hex[16] = "0123456789ABCDEF";
1082
1083 /* Note: This escape function works on file: URIs, but if you want to
1084  * escape something else, please read RFC-2396 */
1085 static gchar *
1086 g_escape_uri_string (const gchar *string,
1087                      UnsafeCharacterSet mask)
1088 {
1089 #define ACCEPTABLE(a) ((a)>=32 && (a)<128 && (acceptable[(a)-32] & use_mask))
1090
1091   const gchar *p;
1092   gchar *q;
1093   gchar *result;
1094   int c;
1095   gint unacceptable;
1096   UnsafeCharacterSet use_mask;
1097
1098   g_return_val_if_fail (mask == UNSAFE_ALL
1099                         || mask == UNSAFE_ALLOW_PLUS
1100                         || mask == UNSAFE_PATH
1101                         || mask == UNSAFE_DOS_PATH
1102                         || mask == UNSAFE_HOST
1103                         || mask == UNSAFE_SLASHES, NULL);
1104
1105   unacceptable = 0;
1106   use_mask = mask;
1107   for (p = string; *p != '\0'; p++)
1108     {
1109       c = *p;
1110       if (!ACCEPTABLE (c))
1111         unacceptable++;
1112     }
1113
1114   result = g_malloc (p - string + unacceptable * 2 + 1);
1115
1116   use_mask = mask;
1117   for (q = result, p = string; *p != '\0'; p++)
1118     {
1119       c = (unsigned char)*p;
1120
1121       if (!ACCEPTABLE (c))
1122         {
1123           *q++ = '%'; /* means hex coming */
1124           *q++ = hex[c >> 4];
1125           *q++ = hex[c & 15];
1126         }
1127       else
1128         *q++ = *p;
1129     }
1130
1131   *q = '\0';
1132
1133   return result;
1134 }
1135
1136
1137 static gchar *
1138 g_escape_file_uri (const gchar *hostname,
1139                    const gchar *pathname)
1140 {
1141   char *escaped_hostname = NULL;
1142   char *escaped_path;
1143   char *res;
1144
1145   if (hostname && *hostname != '\0')
1146     {
1147       escaped_hostname = g_escape_uri_string (hostname, UNSAFE_HOST);
1148     }
1149
1150   escaped_path = g_escape_uri_string (pathname, UNSAFE_DOS_PATH);
1151
1152   res = g_strconcat ("file://",
1153                      (escaped_hostname) ? escaped_hostname : "",
1154                      (*escaped_path != '/') ? "/" : "",
1155                      escaped_path,
1156                      NULL);
1157
1158   g_free (escaped_hostname);
1159   g_free (escaped_path);
1160
1161   return res;
1162 }
1163
1164 static int
1165 unescape_character (const char *scanner)
1166 {
1167   int first_digit;
1168   int second_digit;
1169
1170   first_digit = g_ascii_xdigit_value (*scanner++);
1171
1172   if (first_digit < 0)
1173     return -1;
1174
1175   second_digit = g_ascii_xdigit_value (*scanner++);
1176   if (second_digit < 0)
1177     return -1;
1178
1179   return (first_digit << 4) | second_digit;
1180 }
1181
1182 static gchar *
1183 g_unescape_uri_string (const gchar *escaped,
1184                        const gchar *illegal_characters,
1185                        int          len)
1186 {
1187   const gchar *in, *in_end;
1188   gchar *out, *result;
1189   int character;
1190
1191   if (escaped == NULL)
1192     return NULL;
1193
1194   if (len < 0)
1195     len = strlen (escaped);
1196
1197     result = g_malloc (len + 1);
1198
1199   out = result;
1200   for (in = escaped, in_end = escaped + len; in < in_end && *in != '\0'; in++)
1201     {
1202       character = *in;
1203       if (character == '%')
1204         {
1205           character = unescape_character (in + 1);
1206
1207           /* Check for an illegal character. We consider '\0' illegal here. */
1208           if (character == 0
1209               || (illegal_characters != NULL
1210                   && strchr (illegal_characters, (char)character) != NULL))
1211             {
1212               g_free (result);
1213               return NULL;
1214             }
1215           in += 2;
1216         }
1217       *out++ = character;
1218     }
1219
1220   *out = '\0';
1221
1222   g_assert (out - result <= strlen (escaped));
1223
1224   if (!g_utf8_validate (result, -1, NULL))
1225     {
1226       g_free (result);
1227       return NULL;
1228     }
1229
1230   return result;
1231 }
1232
1233 /**
1234  * g_filename_from_uri:
1235  * @uri: a uri describing a filename (escaped, encoded in UTF-8).
1236  * @hostname: Location to store hostname for the URI, or %NULL.
1237  *            If there is no hostname in the URI, %NULL will be
1238  *            stored in this location.
1239  * @error: location to store the error occuring, or %NULL to ignore
1240  *         errors. Any of the errors in #GConvertError may occur.
1241  *
1242  * Converts an escaped UTF-8 encoded URI to a local filename in the
1243  * encoding used for filenames.
1244  *
1245  * Return value: a newly-allocated string holding the resulting
1246  *               filename, or %NULL on an error.
1247  **/
1248 gchar *
1249 g_filename_from_uri (const char *uri,
1250                      char      **hostname,
1251                      GError    **error)
1252 {
1253   const char *path_part;
1254   const char *host_part;
1255   char *unescaped_hostname;
1256   char *result;
1257   char *filename;
1258   int offs;
1259
1260   if (hostname)
1261     *hostname = NULL;
1262
1263   if (!has_case_prefix (uri, "file:/"))
1264     {
1265       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1266                    _("The URI '%s' is not an absolute URI using the file scheme"),
1267                    uri);
1268       return NULL;
1269     }
1270
1271   path_part = uri + strlen ("file:");
1272
1273   if (strchr (path_part, '#') != NULL)
1274     {
1275       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1276                    _("The local file URI '%s' may not include a '#'"),
1277                    uri);
1278       return NULL;
1279     }
1280
1281   if (has_case_prefix (path_part, "///"))
1282     path_part += 2;
1283   else if (has_case_prefix (path_part, "//"))
1284     {
1285       path_part += 2;
1286       host_part = path_part;
1287
1288       path_part = strchr (path_part, '/');
1289
1290       if (path_part == NULL)
1291         {
1292           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1293                        _("The URI '%s' is invalid"),
1294                        uri);
1295           return NULL;
1296         }
1297
1298       unescaped_hostname = g_unescape_uri_string (host_part, "", path_part - host_part);
1299       if (unescaped_hostname == NULL)
1300         {
1301           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1302                        _("The hostname of the URI '%s' contains invalidly escaped characters"),
1303                        uri);
1304           return NULL;
1305         }
1306
1307       if (hostname)
1308         *hostname = unescaped_hostname;
1309       else
1310         g_free (unescaped_hostname);
1311     }
1312
1313   filename = g_unescape_uri_string (path_part, "/", -1);
1314
1315   if (filename == NULL)
1316     {
1317       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1318                    _("The URI '%s' contains invalidly escaped characters"),
1319                    uri);
1320       return NULL;
1321     }
1322
1323   /* DOS uri's are like "file://host/c:\foo", so we need to check if we need to
1324    * drop the initial slash */
1325   offs = 0;
1326   if (g_path_is_absolute (filename+1))
1327     offs = 1;
1328
1329   result = g_filename_from_utf8 (filename + offs, -1, NULL, NULL, error);
1330   g_free (filename);
1331
1332   return result;
1333 }
1334
1335 /**
1336  * g_filename_to_uri:
1337  * @filename: an absolute filename specified in the encoding
1338  *            used for filenames by the operating system.
1339  * @hostname: A UTF-8 encoded hostname, or %NULL for none.
1340  * @error: location to store the error occuring, or %NULL to ignore
1341  *         errors. Any of the errors in #GConvertError may occur.
1342  *
1343  * Converts an absolute filename to an escaped UTF-8 encoded URI.
1344  *
1345  * Return value: a newly-allocated string holding the resulting
1346  *               URI, or %NULL on an error.
1347  **/
1348 gchar *
1349 g_filename_to_uri   (const char *filename,
1350                      char       *hostname,
1351                      GError    **error)
1352 {
1353   char *escaped_uri;
1354   char *utf8_filename;
1355
1356   g_return_val_if_fail (filename != NULL, NULL);
1357
1358   if (!g_path_is_absolute (filename))
1359     {
1360       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH,
1361                    _("The pathname '%s' is not an absolute path"),
1362                    filename);
1363       return NULL;
1364     }
1365
1366   utf8_filename = g_filename_to_utf8 (filename, -1, NULL, NULL, error);
1367   if (utf8_filename == NULL)
1368     return NULL;
1369
1370   if (hostname &&
1371       !g_utf8_validate (hostname, -1, NULL))
1372     {
1373       g_free (utf8_filename);
1374       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1375                    _("Invalid byte sequence in hostname"));
1376       return NULL;
1377     }
1378
1379   escaped_uri = g_escape_file_uri (hostname,
1380                                    utf8_filename);
1381   g_free (utf8_filename);
1382
1383   return escaped_uri;
1384 }
1385