Make hostname parameter const char *. Added a new "ASCII must not be
[platform/upstream/glib.git] / 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 <stdio.h>
26 #include <string.h>
27 #include <stdlib.h>
28
29 #include "glib.h"
30 #include "config.h"
31
32 #ifdef G_PLATFORM_WIN32
33 #define STRICT
34 #include <windows.h>
35 #undef STRICT
36 #endif
37
38 #include "glibintl.h"
39
40 #if defined(USE_LIBICONV) && !defined (_LIBICONV_H)
41 #error libiconv in use but included iconv.h not from libiconv
42 #endif
43 #if !defined(USE_LIBICONV) && defined (_LIBICONV_H)
44 #error libiconv not in use but included iconv.h is from libiconv
45 #endif
46
47 GQuark 
48 g_convert_error_quark (void)
49 {
50   static GQuark quark;
51   if (!quark)
52     quark = g_quark_from_static_string ("g_convert_error");
53
54   return quark;
55 }
56
57 static gboolean
58 try_conversion (const char *to_codeset,
59                 const char *from_codeset,
60                 iconv_t    *cd)
61 {
62   *cd = iconv_open (to_codeset, from_codeset);
63
64   if (*cd == (iconv_t)-1 && errno == EINVAL)
65     return FALSE;
66   else
67     return TRUE;
68 }
69
70 static gboolean
71 try_to_aliases (const char **to_aliases,
72                 const char  *from_codeset,
73                 iconv_t     *cd)
74 {
75   if (to_aliases)
76     {
77       const char **p = to_aliases;
78       while (*p)
79         {
80           if (try_conversion (*p, from_codeset, cd))
81             return TRUE;
82
83           p++;
84         }
85     }
86
87   return FALSE;
88 }
89
90 extern const char **_g_charset_get_aliases (const char *canonical_name);
91
92 /**
93  * g_iconv_open:
94  * @to_codeset: destination codeset
95  * @from_codeset: source codeset
96  * 
97  * Same as the standard UNIX routine <function>iconv_open()</function>, but
98  * may be implemented via libiconv on UNIX flavors that lack
99  * a native implementation.
100  * 
101  * GLib provides g_convert() and g_locale_to_utf8() which are likely
102  * more convenient than the raw iconv wrappers.
103  * 
104  * Return value: a "conversion descriptor"
105  **/
106 GIConv
107 g_iconv_open (const gchar  *to_codeset,
108               const gchar  *from_codeset)
109 {
110   iconv_t cd;
111   
112   if (!try_conversion (to_codeset, from_codeset, &cd))
113     {
114       const char **to_aliases = _g_charset_get_aliases (to_codeset);
115       const char **from_aliases = _g_charset_get_aliases (from_codeset);
116
117       if (from_aliases)
118         {
119           const char **p = from_aliases;
120           while (*p)
121             {
122               if (try_conversion (to_codeset, *p, &cd))
123                 return (GIConv)cd;
124
125               if (try_to_aliases (to_aliases, *p, &cd))
126                 return (GIConv)cd;
127
128               p++;
129             }
130         }
131
132       if (try_to_aliases (to_aliases, from_codeset, &cd))
133         return (GIConv)cd;
134     }
135
136   return (GIConv)cd;
137 }
138
139 /**
140  * g_iconv:
141  * @converter: conversion descriptor from g_iconv_open()
142  * @inbuf: bytes to convert
143  * @inbytes_left: inout parameter, bytes remaining to convert in @inbuf
144  * @outbuf: converted output bytes
145  * @outbytes_left: inout parameter, bytes available to fill in @outbuf
146  * 
147  * Same as the standard UNIX routine <function>iconv()</function>, but
148  * may be implemented via libiconv on UNIX flavors that lack
149  * a native implementation.
150  *
151  * GLib provides g_convert() and g_locale_to_utf8() which are likely
152  * more convenient than the raw iconv wrappers.
153  * 
154  * Return value: count of non-reversible conversions, or -1 on error
155  **/
156 size_t 
157 g_iconv (GIConv   converter,
158          gchar  **inbuf,
159          gsize   *inbytes_left,
160          gchar  **outbuf,
161          gsize   *outbytes_left)
162 {
163   iconv_t cd = (iconv_t)converter;
164
165   return iconv (cd, inbuf, inbytes_left, outbuf, outbytes_left);
166 }
167
168 /**
169  * g_iconv_close:
170  * @converter: a conversion descriptor from g_iconv_open()
171  *
172  * Same as the standard UNIX routine <function>iconv_close()</function>, but
173  * may be implemented via libiconv on UNIX flavors that lack
174  * a native implementation. Should be called to clean up
175  * the conversion descriptor from g_iconv_open() when
176  * you are done converting things.
177  *
178  * GLib provides g_convert() and g_locale_to_utf8() which are likely
179  * more convenient than the raw iconv wrappers.
180  * 
181  * Return value: -1 on error, 0 on success
182  **/
183 gint
184 g_iconv_close (GIConv converter)
185 {
186   iconv_t cd = (iconv_t)converter;
187
188   return iconv_close (cd);
189 }
190
191
192 #define ICONV_CACHE_SIZE   (16)
193
194 struct _iconv_cache_bucket {
195   gchar *key;
196   guint32 refcount;
197   gboolean used;
198   iconv_t cd;
199 };
200
201 static GList *iconv_cache_list;
202 static GHashTable *iconv_cache;
203 static GHashTable *iconv_open_hash;
204 static guint iconv_cache_size = 0;
205 G_LOCK_DEFINE_STATIC (iconv_cache_lock);
206
207 /* caller *must* hold the iconv_cache_lock */
208 static void
209 iconv_cache_init (void)
210 {
211   static gboolean initialized = FALSE;
212   
213   if (initialized)
214     return;
215   
216   iconv_cache_list = NULL;
217   iconv_cache = g_hash_table_new (g_str_hash, g_str_equal);
218   iconv_open_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
219   
220   initialized = TRUE;
221 }
222
223
224 /**
225  * iconv_cache_bucket_new:
226  * @key: cache key
227  * @cd: iconv descriptor
228  *
229  * Creates a new cache bucket, inserts it into the cache and
230  * increments the cache size.
231  *
232  * Returns a pointer to the newly allocated cache bucket.
233  **/
234 struct _iconv_cache_bucket *
235 iconv_cache_bucket_new (const gchar *key, iconv_t cd)
236 {
237   struct _iconv_cache_bucket *bucket;
238   
239   bucket = g_new (struct _iconv_cache_bucket, 1);
240   bucket->key = g_strdup (key);
241   bucket->refcount = 1;
242   bucket->used = TRUE;
243   bucket->cd = cd;
244   
245   g_hash_table_insert (iconv_cache, bucket->key, bucket);
246   
247   /* FIXME: if we sorted the list so items with few refcounts were
248      first, then we could expire them faster in iconv_cache_expire_unused () */
249   iconv_cache_list = g_list_prepend (iconv_cache_list, bucket);
250   
251   iconv_cache_size++;
252   
253   return bucket;
254 }
255
256
257 /**
258  * iconv_cache_bucket_expire:
259  * @node: cache bucket's node
260  * @bucket: cache bucket
261  *
262  * Expires a single cache bucket @bucket. This should only ever be
263  * called on a bucket that currently has no used iconv descriptors
264  * open.
265  *
266  * @node is not a required argument. If @node is not supplied, we
267  * search for it ourselves.
268  **/
269 static void
270 iconv_cache_bucket_expire (GList *node, struct _iconv_cache_bucket *bucket)
271 {
272   g_hash_table_remove (iconv_cache, bucket->key);
273   
274   if (node == NULL)
275     node = g_list_find (iconv_cache_list, bucket);
276   
277   g_assert (node != NULL);
278   
279   if (node->prev)
280     {
281       node->prev->next = node->next;
282       if (node->next)
283         node->next->prev = node->prev;
284     }
285   else
286     {
287       iconv_cache_list = node->next;
288       if (node->next)
289         node->next->prev = NULL;
290     }
291   
292   g_list_free_1 (node);
293   
294   g_free (bucket->key);
295   g_iconv_close (bucket->cd);
296   g_free (bucket);
297   
298   iconv_cache_size--;
299 }
300
301
302 /**
303  * iconv_cache_expire_unused:
304  *
305  * Expires as many unused cache buckets as it needs to in order to get
306  * the total number of buckets < ICONV_CACHE_SIZE.
307  **/
308 static void
309 iconv_cache_expire_unused (void)
310 {
311   struct _iconv_cache_bucket *bucket;
312   GList *node, *next;
313   
314   node = iconv_cache_list;
315   while (node && iconv_cache_size >= ICONV_CACHE_SIZE)
316     {
317       next = node->next;
318       
319       bucket = node->data;
320       if (bucket->refcount == 0)
321         iconv_cache_bucket_expire (node, bucket);
322       
323       node = next;
324     }
325 }
326
327 static GIConv
328 open_converter (const gchar *to_codeset,
329                 const gchar *from_codeset,
330                 GError     **error)
331 {
332   struct _iconv_cache_bucket *bucket;
333   gchar *key;
334   GIConv cd;
335   
336   /* create our key */
337   key = g_alloca (strlen (from_codeset) + strlen (to_codeset) + 2);
338   sprintf (key, "%s:%s", from_codeset, to_codeset);
339   
340   G_LOCK (iconv_cache_lock);
341   
342   /* make sure the cache has been initialized */
343   iconv_cache_init ();
344   
345   bucket = g_hash_table_lookup (iconv_cache, key);
346   if (bucket)
347     {
348       if (bucket->used)
349         {
350           cd = g_iconv_open (to_codeset, from_codeset);
351           if (cd == (iconv_t) -1)
352             goto error;
353         }
354       else
355         {
356           cd = bucket->cd;
357           bucket->used = TRUE;
358           
359           /* reset the descriptor */
360           g_iconv (cd, NULL, NULL, NULL, NULL);
361         }
362       
363       bucket->refcount++;
364     }
365   else
366     {
367       cd = g_iconv_open (to_codeset, from_codeset);
368       if (cd == (iconv_t) -1)
369         goto error;
370       
371       iconv_cache_expire_unused ();
372       
373       bucket = iconv_cache_bucket_new (key, cd);
374     }
375   
376   g_hash_table_insert (iconv_open_hash, cd, bucket->key);
377   
378   G_UNLOCK (iconv_cache_lock);
379   
380   return cd;
381   
382  error:
383   
384   G_UNLOCK (iconv_cache_lock);
385   
386   /* Something went wrong.  */
387   if (errno == EINVAL)
388     g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,
389                  _("Conversion from character set '%s' to '%s' is not supported"),
390                  from_codeset, to_codeset);
391   else
392     g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
393                  _("Could not open converter from '%s' to '%s': %s"),
394                  from_codeset, to_codeset, strerror (errno));
395   
396   return cd;
397 }
398
399 static int
400 close_converter (GIConv converter)
401 {
402   struct _iconv_cache_bucket *bucket;
403   const gchar *key;
404   iconv_t cd;
405   
406   cd = (iconv_t) converter;
407   
408   if (cd == (iconv_t) -1)
409     return 0;
410   
411   G_LOCK (iconv_cache_lock);
412   
413   key = g_hash_table_lookup (iconv_open_hash, cd);
414   if (key)
415     {
416       g_hash_table_remove (iconv_open_hash, cd);
417       
418       bucket = g_hash_table_lookup (iconv_cache, key);
419       g_assert (bucket);
420       
421       bucket->refcount--;
422       
423       if (cd == bucket->cd)
424         bucket->used = FALSE;
425       else
426         g_iconv_close (cd);
427       
428       if (!bucket->refcount && iconv_cache_size > ICONV_CACHE_SIZE)
429         {
430           /* expire this cache bucket */
431           iconv_cache_bucket_expire (NULL, bucket);
432         }
433     }
434   else
435     {
436       G_UNLOCK (iconv_cache_lock);
437       
438       g_warning ("This iconv context wasn't opened using open_converter");
439       
440       return g_iconv_close (converter);
441     }
442   
443   G_UNLOCK (iconv_cache_lock);
444   
445   return 0;
446 }
447
448
449 /**
450  * g_convert:
451  * @str:           the string to convert
452  * @len:           the length of the string
453  * @to_codeset:    name of character set into which to convert @str
454  * @from_codeset:  character set of @str.
455  * @bytes_read:    location to store the number of bytes in the
456  *                 input string that were successfully converted, or %NULL.
457  *                 Even if the conversion was successful, this may be 
458  *                 less than @len if there were partial characters
459  *                 at the end of the input. If the error
460  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
461  *                 stored will the byte offset after the last valid
462  *                 input sequence.
463  * @bytes_written: the number of bytes stored in the output buffer (not 
464  *                 including the terminating nul).
465  * @error:         location to store the error occuring, or %NULL to ignore
466  *                 errors. Any of the errors in #GConvertError may occur.
467  *
468  * Converts a string from one character set to another.
469  *
470  * Return value: If the conversion was successful, a newly allocated
471  *               nul-terminated string, which must be freed with
472  *               g_free(). Otherwise %NULL and @error will be set.
473  **/
474 gchar*
475 g_convert (const gchar *str,
476            gssize       len,  
477            const gchar *to_codeset,
478            const gchar *from_codeset,
479            gsize       *bytes_read, 
480            gsize       *bytes_written, 
481            GError     **error)
482 {
483   gchar *res;
484   GIConv cd;
485   
486   g_return_val_if_fail (str != NULL, NULL);
487   g_return_val_if_fail (to_codeset != NULL, NULL);
488   g_return_val_if_fail (from_codeset != NULL, NULL);
489   
490   cd = open_converter (to_codeset, from_codeset, error);
491
492   if (cd == (GIConv) -1)
493     {
494       if (bytes_read)
495         *bytes_read = 0;
496       
497       if (bytes_written)
498         *bytes_written = 0;
499       
500       return NULL;
501     }
502
503   res = g_convert_with_iconv (str, len, cd,
504                               bytes_read, bytes_written,
505                               error);
506   
507   close_converter (cd);
508
509   return res;
510 }
511
512 /**
513  * g_convert_with_iconv:
514  * @str:           the string to convert
515  * @len:           the length of the string
516  * @converter:     conversion descriptor from g_iconv_open()
517  * @bytes_read:    location to store the number of bytes in the
518  *                 input string that were successfully converted, or %NULL.
519  *                 Even if the conversion was successful, this may be 
520  *                 less than @len if there were partial characters
521  *                 at the end of the input. If the error
522  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
523  *                 stored will the byte offset after the last valid
524  *                 input sequence.
525  * @bytes_written: the number of bytes stored in the output buffer (not 
526  *                 including the terminating nul).
527  * @error:         location to store the error occuring, or %NULL to ignore
528  *                 errors. Any of the errors in #GConvertError may occur.
529  *
530  * Converts a string from one character set to another.
531  *
532  * Return value: If the conversion was successful, a newly allocated
533  *               nul-terminated string, which must be freed with
534  *               g_free(). Otherwise %NULL and @error will be set.
535  **/
536 gchar*
537 g_convert_with_iconv (const gchar *str,
538                       gssize       len,
539                       GIConv       converter,
540                       gsize       *bytes_read, 
541                       gsize       *bytes_written, 
542                       GError     **error)
543 {
544   gchar *dest;
545   gchar *outp;
546   const gchar *p;
547   gsize inbytes_remaining;
548   gsize outbytes_remaining;
549   gsize err;
550   gsize outbuf_size;
551   gboolean have_error = FALSE;
552   
553   g_return_val_if_fail (str != NULL, NULL);
554   g_return_val_if_fail (converter != (GIConv) -1, NULL);
555      
556   if (len < 0)
557     len = strlen (str);
558
559   p = str;
560   inbytes_remaining = len;
561   outbuf_size = len + 1; /* + 1 for nul in case len == 1 */
562   
563   outbytes_remaining = outbuf_size - 1; /* -1 for nul */
564   outp = dest = g_malloc (outbuf_size);
565
566  again:
567   
568   err = g_iconv (converter, (char **)&p, &inbytes_remaining, &outp, &outbytes_remaining);
569
570   if (err == (size_t) -1)
571     {
572       switch (errno)
573         {
574         case EINVAL:
575           /* Incomplete text, do not report an error */
576           break;
577         case E2BIG:
578           {
579             size_t used = outp - dest;
580
581             outbuf_size *= 2;
582             dest = g_realloc (dest, outbuf_size);
583                 
584             outp = dest + used;
585             outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */
586
587             goto again;
588           }
589         case EILSEQ:
590           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
591                        _("Invalid byte sequence in conversion input"));
592           have_error = TRUE;
593           break;
594         default:
595           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
596                        _("Error during conversion: %s"),
597                        strerror (errno));
598           have_error = TRUE;
599           break;
600         }
601     }
602
603   *outp = '\0';
604   
605   if (bytes_read)
606     *bytes_read = p - str;
607   else
608     {
609       if ((p - str) != len) 
610         {
611           if (!have_error)
612             {
613               g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_PARTIAL_INPUT,
614                            _("Partial character sequence at end of input"));
615               have_error = TRUE;
616             }
617         }
618     }
619
620   if (bytes_written)
621     *bytes_written = outp - dest;       /* Doesn't include '\0' */
622
623   if (have_error)
624     {
625       g_free (dest);
626       return NULL;
627     }
628   else
629     return dest;
630 }
631
632 /**
633  * g_convert_with_fallback:
634  * @str:          the string to convert
635  * @len:          the length of the string
636  * @to_codeset:   name of character set into which to convert @str
637  * @from_codeset: character set of @str.
638  * @fallback:     UTF-8 string to use in place of character not
639  *                present in the target encoding. (This must be
640  *                in the target encoding), if %NULL, characters
641  *                not in the target encoding will be represented
642  *                as Unicode escapes \x{XXXX} or \x{XXXXXX}.
643  * @bytes_read:   location to store the number of bytes in the
644  *                input string that were successfully converted, or %NULL.
645  *                Even if the conversion was successful, this may be 
646  *                less than @len if there were partial characters
647  *                at the end of the input.
648  * @bytes_written: the number of bytes stored in the output buffer (not 
649  *                including the terminating nul).
650  * @error:        location to store the error occuring, or %NULL to ignore
651  *                errors. Any of the errors in #GConvertError may occur.
652  *
653  * Converts a string from one character set to another, possibly
654  * including fallback sequences for characters not representable
655  * in the output. Note that it is not guaranteed that the specification
656  * for the fallback sequences in @fallback will be honored. Some
657  * systems may do a approximate conversion from @from_codeset
658  * to @to_codeset in their <function>iconv()</function> functions, 
659  * in which case GLib will simply return that approximate conversion.
660  *
661  * Return value: If the conversion was successful, a newly allocated
662  *               nul-terminated string, which must be freed with
663  *               g_free(). Otherwise %NULL and @error will be set.
664  **/
665 gchar*
666 g_convert_with_fallback (const gchar *str,
667                          gssize       len,    
668                          const gchar *to_codeset,
669                          const gchar *from_codeset,
670                          gchar       *fallback,
671                          gsize       *bytes_read,
672                          gsize       *bytes_written,
673                          GError     **error)
674 {
675   gchar *utf8;
676   gchar *dest;
677   gchar *outp;
678   const gchar *insert_str = NULL;
679   const gchar *p;
680   gsize inbytes_remaining;   
681   const gchar *save_p = NULL;
682   gsize save_inbytes = 0;
683   gsize outbytes_remaining; 
684   gsize err;
685   GIConv cd;
686   gsize outbuf_size;
687   gboolean have_error = FALSE;
688   gboolean done = FALSE;
689
690   GError *local_error = NULL;
691   
692   g_return_val_if_fail (str != NULL, NULL);
693   g_return_val_if_fail (to_codeset != NULL, NULL);
694   g_return_val_if_fail (from_codeset != NULL, NULL);
695      
696   if (len < 0)
697     len = strlen (str);
698   
699   /* Try an exact conversion; we only proceed if this fails
700    * due to an illegal sequence in the input string.
701    */
702   dest = g_convert (str, len, to_codeset, from_codeset, 
703                     bytes_read, bytes_written, &local_error);
704   if (!local_error)
705     return dest;
706
707   if (!g_error_matches (local_error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE))
708     {
709       g_propagate_error (error, local_error);
710       return NULL;
711     }
712   else
713     g_error_free (local_error);
714
715   local_error = NULL;
716   
717   /* No go; to proceed, we need a converter from "UTF-8" to
718    * to_codeset, and the string as UTF-8.
719    */
720   cd = open_converter (to_codeset, "UTF-8", error);
721   if (cd == (GIConv) -1)
722     {
723       if (bytes_read)
724         *bytes_read = 0;
725       
726       if (bytes_written)
727         *bytes_written = 0;
728       
729       return NULL;
730     }
731
732   utf8 = g_convert (str, len, "UTF-8", from_codeset, 
733                     bytes_read, &inbytes_remaining, error);
734   if (!utf8)
735     {
736       close_converter (cd);
737       if (bytes_written)
738         *bytes_written = 0;
739       return NULL;
740     }
741
742   /* Now the heart of the code. We loop through the UTF-8 string, and
743    * whenever we hit an offending character, we form fallback, convert
744    * the fallback to the target codeset, and then go back to
745    * converting the original string after finishing with the fallback.
746    *
747    * The variables save_p and save_inbytes store the input state
748    * for the original string while we are converting the fallback
749    */
750   p = utf8;
751
752   outbuf_size = len + 1; /* + 1 for nul in case len == 1 */
753   outbytes_remaining = outbuf_size - 1; /* -1 for nul */
754   outp = dest = g_malloc (outbuf_size);
755
756   while (!done && !have_error)
757     {
758       size_t inbytes_tmp = inbytes_remaining;
759       err = g_iconv (cd, (char **)&p, &inbytes_tmp, &outp, &outbytes_remaining);
760       inbytes_remaining = inbytes_tmp;
761
762       if (err == (size_t) -1)
763         {
764           switch (errno)
765             {
766             case EINVAL:
767               g_assert_not_reached();
768               break;
769             case E2BIG:
770               {
771                 size_t used = outp - dest;
772
773                 outbuf_size *= 2;
774                 dest = g_realloc (dest, outbuf_size);
775                 
776                 outp = dest + used;
777                 outbytes_remaining = outbuf_size - used - 1; /* -1 for nul */
778                 
779                 break;
780               }
781             case EILSEQ:
782               if (save_p)
783                 {
784                   /* Error converting fallback string - fatal
785                    */
786                   g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
787                                _("Cannot convert fallback '%s' to codeset '%s'"),
788                                insert_str, to_codeset);
789                   have_error = TRUE;
790                   break;
791                 }
792               else
793                 {
794                   if (!fallback)
795                     { 
796                       gunichar ch = g_utf8_get_char (p);
797                       insert_str = g_strdup_printf ("\\x{%0*X}",
798                                                     (ch < 0x10000) ? 4 : 6,
799                                                     ch);
800                     }
801                   else
802                     insert_str = fallback;
803                   
804                   save_p = g_utf8_next_char (p);
805                   save_inbytes = inbytes_remaining - (save_p - p);
806                   p = insert_str;
807                   inbytes_remaining = strlen (p);
808                 }
809               break;
810             default:
811               g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
812                            _("Error during conversion: %s"),
813                            strerror (errno));
814               have_error = TRUE;
815               break;
816             }
817         }
818       else
819         {
820           if (save_p)
821             {
822               if (!fallback)
823                 g_free ((gchar *)insert_str);
824               p = save_p;
825               inbytes_remaining = save_inbytes;
826               save_p = NULL;
827             }
828           else
829             done = TRUE;
830         }
831     }
832
833   /* Cleanup
834    */
835   *outp = '\0';
836   
837   close_converter (cd);
838
839   if (bytes_written)
840     *bytes_written = outp - dest;       /* Doesn't include '\0' */
841
842   g_free (utf8);
843
844   if (have_error)
845     {
846       if (save_p && !fallback)
847         g_free ((gchar *)insert_str);
848       g_free (dest);
849       return NULL;
850     }
851   else
852     return dest;
853 }
854
855 /*
856  * g_locale_to_utf8
857  *
858  * 
859  */
860
861 #ifndef G_PLATFORM_WIN32
862
863 static gchar *
864 strdup_len (const gchar *string,
865             gssize       len,
866             gsize       *bytes_written,
867             gsize       *bytes_read,
868             GError      **error)
869          
870 {
871   gsize real_len;
872
873   if (!g_utf8_validate (string, -1, NULL))
874     {
875       if (bytes_read)
876         *bytes_read = 0;
877       if (bytes_written)
878         *bytes_written = 0;
879
880       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
881                    _("Invalid byte sequence in conversion input"));
882       return NULL;
883     }
884   
885   if (len < 0)
886     real_len = strlen (string);
887   else
888     {
889       real_len = 0;
890       
891       while (real_len < len && string[real_len])
892         real_len++;
893     }
894   
895   if (bytes_read)
896     *bytes_read = real_len;
897   if (bytes_written)
898     *bytes_written = real_len;
899
900   return g_strndup (string, real_len);
901 }
902
903 #endif
904
905 /**
906  * g_locale_to_utf8:
907  * @opsysstring:   a string in the encoding of the current locale
908  * @len:           the length of the string, or -1 if the string is
909  *                 nul-terminated.
910  * @bytes_read:    location to store the number of bytes in the
911  *                 input string that were successfully converted, or %NULL.
912  *                 Even if the conversion was successful, this may be 
913  *                 less than @len if there were partial characters
914  *                 at the end of the input. If the error
915  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
916  *                 stored will the byte offset after the last valid
917  *                 input sequence.
918  * @bytes_written: the number of bytes stored in the output buffer (not 
919  *                 including the terminating nul).
920  * @error:         location to store the error occuring, or %NULL to ignore
921  *                 errors. Any of the errors in #GConvertError may occur.
922  * 
923  * Converts a string which is in the encoding used for strings by
924  * the C runtime (usually the same as that used by the operating
925  * system) in the current locale into a UTF-8 string.
926  * 
927  * Return value: The converted string, or %NULL on an error.
928  **/
929 gchar *
930 g_locale_to_utf8 (const gchar  *opsysstring,
931                   gssize        len,            
932                   gsize        *bytes_read,    
933                   gsize        *bytes_written,
934                   GError      **error)
935 {
936 #ifdef G_PLATFORM_WIN32
937
938   gint i, clen, total_len, wclen, first;
939   wchar_t *wcs, wc;
940   gchar *result, *bp;
941   const wchar_t *wcp;
942
943   if (len == -1)
944     len = strlen (opsysstring);
945   
946   wcs = g_new (wchar_t, len);
947   wclen = MultiByteToWideChar (CP_ACP, 0, opsysstring, len, wcs, len);
948
949   wcp = wcs;
950   total_len = 0;
951   for (i = 0; i < wclen; i++)
952     {
953       wc = *wcp++;
954
955       if (wc < 0x80)
956         total_len += 1;
957       else if (wc < 0x800)
958         total_len += 2;
959       else if (wc < 0x10000)
960         total_len += 3;
961       else if (wc < 0x200000)
962         total_len += 4;
963       else if (wc < 0x4000000)
964         total_len += 5;
965       else
966         total_len += 6;
967     }
968
969   result = g_malloc (total_len + 1);
970   
971   wcp = wcs;
972   bp = result;
973   for (i = 0; i < wclen; i++)
974     {
975       wc = *wcp++;
976
977       if (wc < 0x80)
978         {
979           first = 0;
980           clen = 1;
981         }
982       else if (wc < 0x800)
983         {
984           first = 0xc0;
985           clen = 2;
986         }
987       else if (wc < 0x10000)
988         {
989           first = 0xe0;
990           clen = 3;
991         }
992       else if (wc < 0x200000)
993         {
994           first = 0xf0;
995           clen = 4;
996         }
997       else if (wc < 0x4000000)
998         {
999           first = 0xf8;
1000           clen = 5;
1001         }
1002       else
1003         {
1004           first = 0xfc;
1005           clen = 6;
1006         }
1007       
1008       /* Woo-hoo! */
1009       switch (clen)
1010         {
1011         case 6: bp[5] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
1012         case 5: bp[4] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
1013         case 4: bp[3] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
1014         case 3: bp[2] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
1015         case 2: bp[1] = (wc & 0x3f) | 0x80; wc >>= 6; /* Fall through */
1016         case 1: bp[0] = wc | first;
1017         }
1018
1019       bp += clen;
1020     }
1021   *bp = 0;
1022
1023   g_free (wcs);
1024
1025   if (bytes_read)
1026     *bytes_read = len;
1027   if (bytes_written)
1028     *bytes_written = total_len;
1029   
1030   return result;
1031
1032 #else  /* !G_PLATFORM_WIN32 */
1033
1034   const char *charset;
1035
1036   if (g_get_charset (&charset))
1037     return strdup_len (opsysstring, len, bytes_read, bytes_written, error);
1038   else
1039     return g_convert (opsysstring, len, 
1040                       "UTF-8", charset, bytes_read, bytes_written, error);
1041
1042 #endif /* !G_PLATFORM_WIN32 */
1043 }
1044
1045 /**
1046  * g_locale_from_utf8:
1047  * @utf8string:    a UTF-8 encoded string 
1048  * @len:           the length of the string, or -1 if the string is
1049  *                 nul-terminated.
1050  * @bytes_read:    location to store the number of bytes in the
1051  *                 input string that were successfully converted, or %NULL.
1052  *                 Even if the conversion was successful, this may be 
1053  *                 less than @len if there were partial characters
1054  *                 at the end of the input. If the error
1055  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
1056  *                 stored will the byte offset after the last valid
1057  *                 input sequence.
1058  * @bytes_written: the number of bytes stored in the output buffer (not 
1059  *                 including the terminating nul).
1060  * @error:         location to store the error occuring, or %NULL to ignore
1061  *                 errors. Any of the errors in #GConvertError may occur.
1062  * 
1063  * Converts a string from UTF-8 to the encoding used for strings by
1064  * the C runtime (usually the same as that used by the operating
1065  * system) in the current locale.
1066  * 
1067  * Return value: The converted string, or %NULL on an error.
1068  **/
1069 gchar *
1070 g_locale_from_utf8 (const gchar *utf8string,
1071                     gssize       len,            
1072                     gsize       *bytes_read,    
1073                     gsize       *bytes_written,
1074                     GError     **error)
1075 {
1076 #ifdef G_PLATFORM_WIN32
1077
1078   gint i, mask, clen, mblen;
1079   wchar_t *wcs, *wcp;
1080   gchar *result;
1081   guchar *cp, *end, c;
1082   gint n;
1083   
1084   if (len == -1)
1085     len = strlen (utf8string);
1086   
1087   /* First convert to wide chars */
1088   cp = (guchar *) utf8string;
1089   end = cp + len;
1090   n = 0;
1091   wcs = g_new (wchar_t, len + 1);
1092   wcp = wcs;
1093   while (cp != end)
1094     {
1095       mask = 0;
1096       c = *cp;
1097
1098       if (c < 0x80)
1099         {
1100           clen = 1;
1101           mask = 0x7f;
1102         }
1103       else if ((c & 0xe0) == 0xc0)
1104         {
1105           clen = 2;
1106           mask = 0x1f;
1107         }
1108       else if ((c & 0xf0) == 0xe0)
1109         {
1110           clen = 3;
1111           mask = 0x0f;
1112         }
1113       else if ((c & 0xf8) == 0xf0)
1114         {
1115           clen = 4;
1116           mask = 0x07;
1117         }
1118       else if ((c & 0xfc) == 0xf8)
1119         {
1120           clen = 5;
1121           mask = 0x03;
1122         }
1123       else if ((c & 0xfc) == 0xfc)
1124         {
1125           clen = 6;
1126           mask = 0x01;
1127         }
1128       else
1129         {
1130           g_free (wcs);
1131           return NULL;
1132         }
1133
1134       if (cp + clen > end)
1135         {
1136           g_free (wcs);
1137           return NULL;
1138         }
1139
1140       *wcp = (cp[0] & mask);
1141       for (i = 1; i < clen; i++)
1142         {
1143           if ((cp[i] & 0xc0) != 0x80)
1144             {
1145               g_free (wcs);
1146               return NULL;
1147             }
1148           *wcp <<= 6;
1149           *wcp |= (cp[i] & 0x3f);
1150         }
1151
1152       cp += clen;
1153       wcp++;
1154       n++;
1155     }
1156   if (cp != end)
1157     {
1158       g_free (wcs);
1159       return NULL;
1160     }
1161
1162   /* n is the number of wide chars constructed */
1163
1164   /* Convert to a string in the current ANSI codepage */
1165
1166   result = g_new (gchar, 3 * n + 1);
1167   mblen = WideCharToMultiByte (CP_ACP, 0, wcs, n, result, 3*n, NULL, NULL);
1168   result[mblen] = 0;
1169   g_free (wcs);
1170
1171   if (bytes_read)
1172     *bytes_read = len;
1173   if (bytes_written)
1174     *bytes_written = mblen;
1175   
1176   return result;
1177
1178 #else  /* !G_PLATFORM_WIN32 */
1179   
1180   const gchar *charset;
1181
1182   if (g_get_charset (&charset))
1183     return strdup_len (utf8string, len, bytes_read, bytes_written, error);
1184   else
1185     return g_convert (utf8string, len,
1186                       charset, "UTF-8", bytes_read, bytes_written, error);
1187
1188 #endif /* !G_PLATFORM_WIN32 */
1189 }
1190
1191 /**
1192  * g_filename_to_utf8:
1193  * @opsysstring:   a string in the encoding for filenames
1194  * @len:           the length of the string, or -1 if the string is
1195  *                 nul-terminated.
1196  * @bytes_read:    location to store the number of bytes in the
1197  *                 input string that were successfully converted, or %NULL.
1198  *                 Even if the conversion was successful, this may be 
1199  *                 less than @len if there were partial characters
1200  *                 at the end of the input. If the error
1201  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
1202  *                 stored will the byte offset after the last valid
1203  *                 input sequence.
1204  * @bytes_written: the number of bytes stored in the output buffer (not 
1205  *                 including the terminating nul).
1206  * @error:         location to store the error occuring, or %NULL to ignore
1207  *                 errors. Any of the errors in #GConvertError may occur.
1208  * 
1209  * Converts a string which is in the encoding used for filenames
1210  * into a UTF-8 string.
1211  * 
1212  * Return value: The converted string, or %NULL on an error.
1213  **/
1214 gchar*
1215 g_filename_to_utf8 (const gchar *opsysstring, 
1216                     gssize       len,           
1217                     gsize       *bytes_read,   
1218                     gsize       *bytes_written,
1219                     GError     **error)
1220 {
1221 #ifdef G_PLATFORM_WIN32
1222   return g_locale_to_utf8 (opsysstring, len,
1223                            bytes_read, bytes_written,
1224                            error);
1225 #else  /* !G_PLATFORM_WIN32 */
1226       
1227   if (getenv ("G_BROKEN_FILENAMES"))
1228     return g_locale_to_utf8 (opsysstring, len,
1229                              bytes_read, bytes_written,
1230                              error);
1231   else
1232     return strdup_len (opsysstring, len, bytes_read, bytes_written, error);
1233 #endif /* !G_PLATFORM_WIN32 */
1234 }
1235
1236 /**
1237  * g_filename_from_utf8:
1238  * @utf8string:    a UTF-8 encoded string.
1239  * @len:           the length of the string, or -1 if the string is
1240  *                 nul-terminated.
1241  * @bytes_read:    location to store the number of bytes in the
1242  *                 input string that were successfully converted, or %NULL.
1243  *                 Even if the conversion was successful, this may be 
1244  *                 less than @len if there were partial characters
1245  *                 at the end of the input. If the error
1246  *                 #G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
1247  *                 stored will the byte offset after the last valid
1248  *                 input sequence.
1249  * @bytes_written: the number of bytes stored in the output buffer (not 
1250  *                 including the terminating nul).
1251  * @error:         location to store the error occuring, or %NULL to ignore
1252  *                 errors. Any of the errors in #GConvertError may occur.
1253  * 
1254  * Converts a string from UTF-8 to the encoding used for filenames.
1255  * 
1256  * Return value: The converted string, or %NULL on an error.
1257  **/
1258 gchar*
1259 g_filename_from_utf8 (const gchar *utf8string,
1260                       gssize       len,            
1261                       gsize       *bytes_read,    
1262                       gsize       *bytes_written,
1263                       GError     **error)
1264 {
1265 #ifdef G_PLATFORM_WIN32
1266   return g_locale_from_utf8 (utf8string, len,
1267                              bytes_read, bytes_written,
1268                              error);
1269 #else  /* !G_PLATFORM_WIN32 */
1270   if (getenv ("G_BROKEN_FILENAMES"))
1271     return g_locale_from_utf8 (utf8string, len,
1272                                bytes_read, bytes_written,
1273                                error);
1274   else
1275     return strdup_len (utf8string, len, bytes_read, bytes_written, error);
1276 #endif /* !G_PLATFORM_WIN32 */
1277 }
1278
1279 /* Test of haystack has the needle prefix, comparing case
1280  * insensitive. haystack may be UTF-8, but needle must
1281  * contain only ascii. */
1282 static gboolean
1283 has_case_prefix (const gchar *haystack, const gchar *needle)
1284 {
1285   const gchar *h, *n;
1286   
1287   /* Eat one character at a time. */
1288   h = haystack;
1289   n = needle;
1290
1291   while (*n && *h &&
1292          g_ascii_tolower (*n) == g_ascii_tolower (*h))
1293     {
1294       n++;
1295       h++;
1296     }
1297   
1298   return *n == '\0';
1299 }
1300
1301 typedef enum {
1302   UNSAFE_ALL        = 0x1,  /* Escape all unsafe characters   */
1303   UNSAFE_ALLOW_PLUS = 0x2,  /* Allows '+'  */
1304   UNSAFE_PATH       = 0x4,  /* Allows '/' and '?' and '&' and '='  */
1305   UNSAFE_DOS_PATH   = 0x8,  /* Allows '/' and '?' and '&' and '=' and ':' */
1306   UNSAFE_HOST       = 0x10, /* Allows '/' and ':' and '@' */
1307   UNSAFE_SLASHES    = 0x20  /* Allows all characters except for '/' and '%' */
1308 } UnsafeCharacterSet;
1309
1310 static const guchar acceptable[96] = {
1311   /* A table of the ASCII chars from space (32) to DEL (127) */
1312   /*      !    "    #    $    %    &    '    (    )    *    +    ,    -    .    / */ 
1313   0x00,0x3F,0x20,0x20,0x20,0x00,0x2C,0x3F,0x3F,0x3F,0x3F,0x22,0x20,0x3F,0x3F,0x1C,
1314   /* 0    1    2    3    4    5    6    7    8    9    :    ;    <    =    >    ? */
1315   0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x38,0x20,0x20,0x2C,0x20,0x2C,
1316   /* @    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O */
1317   0x30,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
1318   /* P    Q    R    S    T    U    V    W    X    Y    Z    [    \    ]    ^    _ */
1319   0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x20,0x3F,
1320   /* `    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o */
1321   0x20,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
1322   /* p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~  DEL */
1323   0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x20,0x20,0x20,0x3F,0x20
1324 };
1325
1326 static const gchar hex[16] = "0123456789ABCDEF";
1327
1328 /* Note: This escape function works on file: URIs, but if you want to
1329  * escape something else, please read RFC-2396 */
1330 static gchar *
1331 g_escape_uri_string (const gchar *string, 
1332                      UnsafeCharacterSet mask)
1333 {
1334 #define ACCEPTABLE(a) ((a)>=32 && (a)<128 && (acceptable[(a)-32] & use_mask))
1335
1336   const gchar *p;
1337   gchar *q;
1338   gchar *result;
1339   int c;
1340   gint unacceptable;
1341   UnsafeCharacterSet use_mask;
1342   
1343   g_return_val_if_fail (mask == UNSAFE_ALL
1344                         || mask == UNSAFE_ALLOW_PLUS
1345                         || mask == UNSAFE_PATH
1346                         || mask == UNSAFE_DOS_PATH
1347                         || mask == UNSAFE_HOST
1348                         || mask == UNSAFE_SLASHES, NULL);
1349   
1350   unacceptable = 0;
1351   use_mask = mask;
1352   for (p = string; *p != '\0'; p++)
1353     {
1354       c = (guchar) *p;
1355       if (!ACCEPTABLE (c)) 
1356         unacceptable++;
1357     }
1358   
1359   result = g_malloc (p - string + unacceptable * 2 + 1);
1360   
1361   use_mask = mask;
1362   for (q = result, p = string; *p != '\0'; p++)
1363     {
1364       c = (guchar) *p;
1365       
1366       if (!ACCEPTABLE (c))
1367         {
1368           *q++ = '%'; /* means hex coming */
1369           *q++ = hex[c >> 4];
1370           *q++ = hex[c & 15];
1371         }
1372       else
1373         *q++ = *p;
1374     }
1375   
1376   *q = '\0';
1377   
1378   return result;
1379 }
1380
1381
1382 static gchar *
1383 g_escape_file_uri (const gchar *hostname,
1384                    const gchar *pathname)
1385 {
1386   char *escaped_hostname = NULL;
1387   char *escaped_path;
1388   char *res;
1389
1390 #ifdef G_OS_WIN32
1391   char *p, *backslash;
1392
1393   /* Turn backslashes into forward slashes. That's what Netscape
1394    * does, and they are actually more or less equivalent in Windows.
1395    */
1396   
1397   pathname = g_strdup (pathname);
1398   p = (char *) pathname;
1399   
1400   while ((backslash = strchr (p, '\\')) != NULL)
1401     {
1402       *backslash = '/';
1403       p = backslash + 1;
1404     }
1405 #endif
1406
1407   if (hostname && *hostname != '\0')
1408     {
1409       escaped_hostname = g_escape_uri_string (hostname, UNSAFE_HOST);
1410     }
1411
1412   escaped_path = g_escape_uri_string (pathname, UNSAFE_DOS_PATH);
1413
1414   res = g_strconcat ("file://",
1415                      (escaped_hostname) ? escaped_hostname : "",
1416                      (*escaped_path != '/') ? "/" : "",
1417                      escaped_path,
1418                      NULL);
1419
1420 #ifdef G_OS_WIN32
1421   g_free ((char *) pathname);
1422 #endif
1423
1424   g_free (escaped_hostname);
1425   g_free (escaped_path);
1426   
1427   return res;
1428 }
1429
1430 static int
1431 unescape_character (const char *scanner)
1432 {
1433   int first_digit;
1434   int second_digit;
1435
1436   first_digit = g_ascii_xdigit_value (scanner[0]);
1437   if (first_digit < 0) 
1438     return -1;
1439   
1440   second_digit = g_ascii_xdigit_value (scanner[1]);
1441   if (second_digit < 0) 
1442     return -1;
1443   
1444   return (first_digit << 4) | second_digit;
1445 }
1446
1447 static gchar *
1448 g_unescape_uri_string (const char *escaped,
1449                        int         len,
1450                        const char *illegal_escaped_characters,
1451                        gboolean    ascii_must_not_be_escaped)
1452 {
1453   const gchar *in, *in_end;
1454   gchar *out, *result;
1455   int c;
1456   
1457   if (escaped == NULL)
1458     return NULL;
1459
1460   if (len < 0)
1461     len = strlen (escaped);
1462
1463   result = g_malloc (len + 1);
1464   
1465   out = result;
1466   for (in = escaped, in_end = escaped + len; in < in_end; in++)
1467     {
1468       c = *in;
1469
1470       if (c == '%')
1471         {
1472           /* catch partial escape sequences past the end of the substring */
1473           if (in + 3 > in_end)
1474             break;
1475
1476           c = unescape_character (in + 1);
1477
1478           /* catch bad escape sequences and NUL characters */
1479           if (c <= 0)
1480             break;
1481
1482           /* catch escaped ASCII */
1483           if (ascii_must_not_be_escaped && c <= 0x7F)
1484             break;
1485
1486           /* catch other illegal escaped characters */
1487           if (strchr (illegal_escaped_characters, c) != NULL)
1488             break;
1489
1490           in += 2;
1491         }
1492
1493       *out++ = c;
1494     }
1495   
1496   g_assert (out - result <= len);
1497   *out = '\0';
1498
1499   if (in != in_end || !g_utf8_validate (result, -1, NULL))
1500     {
1501       g_free (result);
1502       return NULL;
1503     }
1504
1505   return result;
1506 }
1507
1508 static gboolean
1509 is_escalphanum (gunichar c)
1510 {
1511   return c > 0x7F || g_ascii_isalnum (c);
1512 }
1513
1514 static gboolean
1515 is_escalpha (gunichar c)
1516 {
1517   return c > 0x7F || g_ascii_isalpha (c);
1518 }
1519
1520 /* allows an empty string */
1521 static gboolean
1522 hostname_validate (const char *hostname)
1523 {
1524   const char *p;
1525   gunichar c, first_char, last_char;
1526
1527   p = hostname;
1528   if (*p == '\0')
1529     return TRUE;
1530   do
1531     {
1532       /* read in a label */
1533       c = g_utf8_get_char (p);
1534       p = g_utf8_next_char (p);
1535       if (!is_escalphanum (c))
1536         return FALSE;
1537       first_char = c;
1538       do
1539         {
1540           last_char = c;
1541           c = g_utf8_get_char (p);
1542           p = g_utf8_next_char (p);
1543         }
1544       while (is_escalphanum (c) || c == '-');
1545       if (last_char == '-')
1546         return FALSE;
1547       
1548       /* if that was the last label, check that it was a toplabel */
1549       if (c == '\0' || (c == '.' && *p == '\0'))
1550         return is_escalpha (first_char);
1551     }
1552   while (c == '.');
1553   return FALSE;
1554 }
1555
1556 /**
1557  * g_filename_from_uri:
1558  * @uri: a uri describing a filename (escaped, encoded in UTF-8).
1559  * @hostname: Location to store hostname for the URI, or %NULL.
1560  *            If there is no hostname in the URI, %NULL will be
1561  *            stored in this location.
1562  * @error: location to store the error occuring, or %NULL to ignore
1563  *         errors. Any of the errors in #GConvertError may occur.
1564  * 
1565  * Converts an escaped UTF-8 encoded URI to a local filename in the
1566  * encoding used for filenames. 
1567  * 
1568  * Return value: a newly-allocated string holding the resulting
1569  *               filename, or %NULL on an error.
1570  **/
1571 gchar *
1572 g_filename_from_uri (const char *uri,
1573                      char      **hostname,
1574                      GError    **error)
1575 {
1576   const char *path_part;
1577   const char *host_part;
1578   char *unescaped_hostname;
1579   char *result;
1580   char *filename;
1581   int offs;
1582 #ifdef G_OS_WIN32
1583   char *p, *slash;
1584 #endif
1585
1586   if (hostname)
1587     *hostname = NULL;
1588
1589   if (!has_case_prefix (uri, "file:/"))
1590     {
1591       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1592                    _("The URI '%s' is not an absolute URI using the file scheme"),
1593                    uri);
1594       return NULL;
1595     }
1596   
1597   path_part = uri + strlen ("file:");
1598   
1599   if (strchr (path_part, '#') != NULL)
1600     {
1601       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1602                    _("The local file URI '%s' may not include a '#'"),
1603                    uri);
1604       return NULL;
1605     }
1606         
1607   if (has_case_prefix (path_part, "///")) 
1608     path_part += 2;
1609   else if (has_case_prefix (path_part, "//"))
1610     {
1611       path_part += 2;
1612       host_part = path_part;
1613
1614       path_part = strchr (path_part, '/');
1615
1616       if (path_part == NULL)
1617         {
1618           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1619                        _("The URI '%s' is invalid"),
1620                        uri);
1621           return NULL;
1622         }
1623
1624       unescaped_hostname = g_unescape_uri_string (host_part, path_part - host_part, "", TRUE);
1625
1626       if (unescaped_hostname == NULL ||
1627           !hostname_validate (unescaped_hostname))
1628         {
1629           g_free (unescaped_hostname);
1630           g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1631                        _("The hostname of the URI '%s' is invalid"),
1632                        uri);
1633           return NULL;
1634         }
1635       
1636       if (hostname)
1637         *hostname = unescaped_hostname;
1638       else
1639         g_free (unescaped_hostname);
1640     }
1641
1642   filename = g_unescape_uri_string (path_part, -1, "/", FALSE);
1643
1644   if (filename == NULL)
1645     {
1646       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_BAD_URI,
1647                    _("The URI '%s' contains invalidly escaped characters"),
1648                    uri);
1649       return NULL;
1650     }
1651
1652   offs = 0;
1653 #ifdef G_OS_WIN32
1654   /* Drop localhost */
1655   if (hostname && *hostname != NULL &&
1656       g_ascii_strcasecmp (*hostname, "localhost") == 0)
1657     {
1658       g_free (*hostname);
1659       *hostname = NULL;
1660     }
1661
1662   /* Turn slashes into backslashes, because that's the canonical spelling */
1663   p = filename;
1664   while ((slash = strchr (p, '/')) != NULL)
1665     {
1666       *slash = '\\';
1667       p = slash + 1;
1668     }
1669
1670   /* Windows URIs with a drive letter can be like "file://host/c:/foo"
1671    * or "file://host/c|/foo" (some Netscape versions). In those cases, start
1672    * the filename from the drive letter.
1673    */
1674   if (g_ascii_isalpha (filename[1]))
1675     {
1676       if (filename[2] == ':')
1677         offs = 1;
1678       else if (filename[2] == '|')
1679         {
1680           filename[2] = ':';
1681           offs = 1;
1682         }
1683     }
1684 #endif
1685   
1686   result = g_filename_from_utf8 (filename + offs, -1, NULL, NULL, error);
1687   g_free (filename);
1688   
1689   return result;
1690 }
1691
1692 /**
1693  * g_filename_to_uri:
1694  * @filename: an absolute filename specified in the encoding
1695  *            used for filenames by the operating system.
1696  * @hostname: A UTF-8 encoded hostname, or %NULL for none.
1697  * @error: location to store the error occuring, or %NULL to ignore
1698  *         errors. Any of the errors in #GConvertError may occur.
1699  * 
1700  * Converts an absolute filename to an escaped UTF-8 encoded URI.
1701  * 
1702  * Return value: a newly-allocated string holding the resulting
1703  *               URI, or %NULL on an error.
1704  **/
1705 gchar *
1706 g_filename_to_uri   (const char *filename,
1707                      const char *hostname,
1708                      GError    **error)
1709 {
1710   char *escaped_uri;
1711   char *utf8_filename;
1712
1713   g_return_val_if_fail (filename != NULL, NULL);
1714
1715   if (!g_path_is_absolute (filename))
1716     {
1717       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH,
1718                    _("The pathname '%s' is not an absolute path"),
1719                    filename);
1720       return NULL;
1721     }
1722
1723   if (hostname &&
1724       !(g_utf8_validate (hostname, -1, NULL)
1725         && hostname_validate (hostname)))
1726     {
1727       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1728                    _("Invalid hostname"));
1729       return NULL;
1730     }
1731   
1732   utf8_filename = g_filename_to_utf8 (filename, -1, NULL, NULL, error);
1733   if (utf8_filename == NULL)
1734     return NULL;
1735   
1736 #ifdef G_OS_WIN32
1737   /* Don't use localhost unnecessarily */
1738   if (hostname && g_ascii_strcasecmp (hostname, "localhost") == 0)
1739     hostname = NULL;
1740 #endif
1741
1742   escaped_uri = g_escape_file_uri (hostname,
1743                                    utf8_filename);
1744   g_free (utf8_filename);
1745   
1746   return escaped_uri;
1747 }
1748