Pass DBUS_SESSION_BUS_ADDRESS for gnome3
[gnupg.git] / common / utf8conv.c
1 /* utf8conf.c -  UTF8 character set conversion
2  * Copyright (C) 1994, 1998, 1999, 2000, 2001, 2003, 2006,
3  *               2008, 2010  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify it
8  * under the terms of either
9  *
10  *   - the GNU Lesser General Public License as published by the Free
11  *     Software Foundation; either version 3 of the License, or (at
12  *     your option) any later version.
13  *
14  * or
15  *
16  *   - the GNU General Public License as published by the Free
17  *     Software Foundation; either version 2 of the License, or (at
18  *     your option) any later version.
19  *
20  * or both in parallel, as here.
21  *
22  * GnuPG is distributed in the hope that it will be useful, but
23  * WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * General Public License for more details.
26  *
27  * You should have received a copies of the GNU General Public License
28  * and the GNU Lesser General Public License along with this program;
29  * if not, see <http://www.gnu.org/licenses/>.
30  */
31
32 #include <config.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdarg.h>
36 #include <ctype.h>
37 #ifdef HAVE_LANGINFO_CODESET
38 #include <langinfo.h>
39 #endif
40 #include <errno.h>
41 #ifndef HAVE_ANDROID_SYSTEM
42 # include <iconv.h>
43 #endif
44
45 #include "util.h"
46 #include "common-defs.h"
47 #include "i18n.h"
48 #include "stringhelp.h"
49 #include "utf8conv.h"
50
51 #ifndef MB_LEN_MAX
52 #define MB_LEN_MAX 16
53 #endif
54
55 static const char *active_charset_name = "iso-8859-1";
56 static int no_translation;     /* Set to true if we let simply pass through. */
57 static int use_iconv;          /* iconv conversion functions required. */
58
59
60 #ifdef HAVE_ANDROID_SYSTEM
61 /* Fake stuff to get things building.  */
62 typedef void *iconv_t;
63 #define ICONV_CONST
64
65 static iconv_t
66 iconv_open (const char *tocode, const char *fromcode)
67 {
68   (void)tocode;
69   (void)fromcode;
70   return (iconv_t)(-1);
71 }
72
73 static size_t
74 iconv (iconv_t cd, char **inbuf, size_t *inbytesleft,
75        char **outbuf, size_t *outbytesleft)
76 {
77   (void)cd;
78   (void)inbuf;
79   (void)inbytesleft;
80   (void)outbuf;
81   (void)outbytesleft;
82   return (size_t)(0);
83 }
84
85 static int
86 iconv_close (iconv_t cd)
87 {
88   (void)cd;
89   return 0;
90 }
91 #endif /*HAVE_ANDROID_SYSTEM*/
92
93
94 /* Error handler for iconv failures. This is needed to not clutter the
95    output with repeated diagnostics about a missing conversion. */
96 static void
97 handle_iconv_error (const char *to, const char *from, int use_fallback)
98 {
99   if (errno == EINVAL)
100     {
101       static int shown1, shown2;
102       int x;
103
104       if (to && !strcmp (to, "utf-8"))
105         {
106           x = shown1;
107           shown1 = 1;
108         }
109       else
110         {
111           x = shown2;
112           shown2 = 1;
113         }
114
115       if (!x)
116         log_info (_("conversion from '%s' to '%s' not available\n"),
117                   from, to);
118     }
119   else
120     {
121       static int shown;
122
123       if (!shown)
124         log_info (_("iconv_open failed: %s\n"), strerror (errno));
125       shown = 1;
126     }
127
128   if (use_fallback)
129     {
130       /* To avoid further error messages we fallback to Latin-1 for the
131          native encoding.  This is justified as one can expect that on a
132          utf-8 enabled system nl_langinfo() will work and thus we won't
133          never get to here.  Thus Latin-1 seems to be a reasonable
134          default.  */
135       active_charset_name = "iso-8859-1";
136       no_translation = 0;
137       use_iconv = 0;
138     }
139 }
140
141
142
143 int
144 set_native_charset (const char *newset)
145 {
146   const char *full_newset;
147
148   if (!newset)
149     {
150 #ifdef HAVE_ANDROID_SYSTEM
151       newset = "utf-8";
152 #elif defined HAVE_W32_SYSTEM
153       static char codepage[30];
154       unsigned int cpno;
155       const char *aliases;
156
157       /* We are a console program thus we need to use the
158          GetConsoleOutputCP function and not the the GetACP which
159          would give the codepage for a GUI program.  Note this is not
160          a bulletproof detection because GetConsoleCP might return a
161          different one for console input.  Not sure how to cope with
162          that.  If the console Code page is not known we fall back to
163          the system code page.  */
164 #ifndef HAVE_W32CE_SYSTEM
165       cpno = GetConsoleOutputCP ();
166       if (!cpno)
167 #endif
168         cpno = GetACP ();
169       sprintf (codepage, "CP%u", cpno );
170       /* Resolve alias.  We use a long string string and not the usual
171          array to optimize if the code is taken to a DSO.  Taken from
172          libiconv 1.9.2. */
173       newset = codepage;
174       for (aliases = ("CP936"   "\0" "GBK" "\0"
175                       "CP1361"  "\0" "JOHAB" "\0"
176                       "CP20127" "\0" "ASCII" "\0"
177                       "CP20866" "\0" "KOI8-R" "\0"
178                       "CP21866" "\0" "KOI8-RU" "\0"
179                       "CP28591" "\0" "ISO-8859-1" "\0"
180                       "CP28592" "\0" "ISO-8859-2" "\0"
181                       "CP28593" "\0" "ISO-8859-3" "\0"
182                       "CP28594" "\0" "ISO-8859-4" "\0"
183                       "CP28595" "\0" "ISO-8859-5" "\0"
184                       "CP28596" "\0" "ISO-8859-6" "\0"
185                       "CP28597" "\0" "ISO-8859-7" "\0"
186                       "CP28598" "\0" "ISO-8859-8" "\0"
187                       "CP28599" "\0" "ISO-8859-9" "\0"
188                       "CP28605" "\0" "ISO-8859-15" "\0"
189                       "CP65001" "\0" "UTF-8" "\0");
190            *aliases;
191            aliases += strlen (aliases) + 1, aliases += strlen (aliases) + 1)
192         {
193           if (!strcmp (codepage, aliases) ||(*aliases == '*' && !aliases[1]))
194             {
195               newset = aliases + strlen (aliases) + 1;
196               break;
197             }
198         }
199
200 #else /*!HAVE_W32_SYSTEM && !HAVE_ANDROID_SYSTEM*/
201
202 #ifdef HAVE_LANGINFO_CODESET
203       newset = nl_langinfo (CODESET);
204 #else /*!HAVE_LANGINFO_CODESET*/
205       /* Try to get the used charset from environment variables.  */
206       static char codepage[30];
207       const char *lc, *dot, *mod;
208
209       strcpy (codepage, "iso-8859-1");
210       lc = getenv ("LC_ALL");
211       if (!lc || !*lc)
212         {
213           lc = getenv ("LC_CTYPE");
214           if (!lc || !*lc)
215             lc = getenv ("LANG");
216         }
217       if (lc && *lc)
218         {
219           dot = strchr (lc, '.');
220           if (dot)
221             {
222               mod = strchr (++dot, '@');
223               if (!mod)
224                 mod = dot + strlen (dot);
225               if (mod - dot < sizeof codepage && dot != mod)
226                 {
227                   memcpy (codepage, dot, mod - dot);
228                   codepage [mod - dot] = 0;
229                 }
230             }
231         }
232       newset = codepage;
233 #endif /*!HAVE_LANGINFO_CODESET*/
234 #endif /*!HAVE_W32_SYSTEM && !HAVE_ANDROID_SYSTEM*/
235     }
236
237   full_newset = newset;
238   if (strlen (newset) > 3 && !ascii_memcasecmp (newset, "iso", 3))
239     {
240       newset += 3;
241       if (*newset == '-' || *newset == '_')
242         newset++;
243     }
244
245   /* Note that we silently assume that plain ASCII is actually meant
246      as Latin-1.  This makes sense because many Unix system don't have
247      their locale set up properly and thus would get annoying error
248      messages and we have to handle all the "bug" reports. Latin-1 has
249      always been the character set used for 8 bit characters on Unix
250      systems. */
251   if ( !*newset
252        || !ascii_strcasecmp (newset, "8859-1" )
253        || !ascii_strcasecmp (newset, "646" )
254        || !ascii_strcasecmp (newset, "ASCII" )
255        || !ascii_strcasecmp (newset, "ANSI_X3.4-1968" )
256        )
257     {
258       active_charset_name = "iso-8859-1";
259       no_translation = 0;
260       use_iconv = 0;
261     }
262   else if ( !ascii_strcasecmp (newset, "utf8" )
263             || !ascii_strcasecmp(newset, "utf-8") )
264     {
265       active_charset_name = "utf-8";
266       no_translation = 1;
267       use_iconv = 0;
268     }
269   else
270     {
271       iconv_t cd;
272
273       cd = iconv_open (full_newset, "utf-8");
274       if (cd == (iconv_t)-1)
275         {
276           handle_iconv_error (full_newset, "utf-8", 0);
277           return -1;
278         }
279       iconv_close (cd);
280       cd = iconv_open ("utf-8", full_newset);
281       if (cd == (iconv_t)-1)
282         {
283           handle_iconv_error ("utf-8", full_newset, 0);
284           return -1;
285         }
286       iconv_close (cd);
287       active_charset_name = full_newset;
288       no_translation = 0;
289       use_iconv = 1;
290     }
291   return 0;
292 }
293
294 const char *
295 get_native_charset ()
296 {
297   return active_charset_name;
298 }
299
300 /* Return true if the native charset is utf-8.  */
301 int
302 is_native_utf8 (void)
303 {
304   return no_translation;
305 }
306
307
308 /* Convert string, which is in native encoding to UTF8 and return a
309    new allocated UTF-8 string.  This function terminates the process
310    on memory shortage.  */
311 char *
312 native_to_utf8 (const char *orig_string)
313 {
314   const unsigned char *string = (const unsigned char *)orig_string;
315   const unsigned char *s;
316   char *buffer;
317   unsigned char *p;
318   size_t length = 0;
319
320   if (no_translation)
321     {
322       /* Already utf-8 encoded. */
323       buffer = xstrdup (orig_string);
324     }
325   else if (!use_iconv)
326     {
327       /* For Latin-1 we can avoid the iconv overhead. */
328       for (s = string; *s; s++)
329         {
330           length++;
331           if (*s & 0x80)
332             length++;
333         }
334       buffer = xmalloc (length + 1);
335       for (p = (unsigned char *)buffer, s = string; *s; s++)
336         {
337           if ( (*s & 0x80 ))
338             {
339               *p++ = 0xc0 | ((*s >> 6) & 3);
340               *p++ = 0x80 | (*s & 0x3f);
341             }
342           else
343             *p++ = *s;
344         }
345       *p = 0;
346     }
347   else
348     {
349       /* Need to use iconv.  */
350       iconv_t cd;
351       const char *inptr;
352       char *outptr;
353       size_t inbytes, outbytes;
354
355       cd = iconv_open ("utf-8", active_charset_name);
356       if (cd == (iconv_t)-1)
357         {
358           handle_iconv_error ("utf-8", active_charset_name, 1);
359           return native_to_utf8 (string);
360         }
361
362       for (s=string; *s; s++ )
363         {
364           length++;
365           if ((*s & 0x80))
366             length += 5; /* We may need up to 6 bytes for the utf8 output. */
367         }
368       buffer = xmalloc (length + 1);
369
370       inptr = string;
371       inbytes = strlen (string);
372       outptr = buffer;
373       outbytes = length;
374       if ( iconv (cd, (ICONV_CONST char **)&inptr, &inbytes,
375                   &outptr, &outbytes) == (size_t)-1)
376         {
377           static int shown;
378
379           if (!shown)
380             log_info (_("conversion from '%s' to '%s' failed: %s\n"),
381                       active_charset_name, "utf-8", strerror (errno));
382           shown = 1;
383           /* We don't do any conversion at all but use the strings as is. */
384           strcpy (buffer, string);
385         }
386       else /* Success.  */
387         {
388           *outptr = 0;
389           /* We could realloc the buffer now but I doubt that it makes
390              much sense given that it will get freed anyway soon
391              after.  */
392         }
393       iconv_close (cd);
394     }
395   return buffer;
396 }
397
398
399
400 static char *
401 do_utf8_to_native (const char *string, size_t length, int delim,
402                    int with_iconv)
403 {
404   int nleft;
405   int i;
406   unsigned char encbuf[8];
407   int encidx;
408   const unsigned char *s;
409   size_t n;
410   char *buffer = NULL;
411   char *p = NULL;
412   unsigned long val = 0;
413   size_t slen;
414   int resync = 0;
415
416   /* First pass (p==NULL): count the extended utf-8 characters.  */
417   /* Second pass (p!=NULL): create string.  */
418   for (;;)
419     {
420       for (slen = length, nleft = encidx = 0, n = 0,
421              s = (const unsigned char *)string;
422            slen;
423            s++, slen--)
424         {
425           if (resync)
426             {
427               if (!(*s < 128 || (*s >= 0xc0 && *s <= 0xfd)))
428                 {
429                   /* Still invalid. */
430                   if (p)
431                     {
432                       sprintf (p, "\\x%02x", *s);
433                       p += 4;
434                     }
435                   n += 4;
436                   continue;
437                 }
438               resync = 0;
439             }
440           if (!nleft)
441             {
442               if (!(*s & 0x80))
443                 {
444                   /* Plain ascii. */
445                   if ( delim != -1
446                        && (*s < 0x20 || *s == 0x7f || *s == delim
447                            || (delim && *s == '\\')))
448                     {
449                       n++;
450                       if (p)
451                         *p++ = '\\';
452                       switch (*s)
453                         {
454                         case '\n': n++; if ( p ) *p++ = 'n'; break;
455                         case '\r': n++; if ( p ) *p++ = 'r'; break;
456                         case '\f': n++; if ( p ) *p++ = 'f'; break;
457                         case '\v': n++; if ( p ) *p++ = 'v'; break;
458                         case '\b': n++; if ( p ) *p++ = 'b'; break;
459                         case    0: n++; if ( p ) *p++ = '0'; break;
460                         default:
461                           n += 3;
462                           if (p)
463                             {
464                               sprintf (p, "x%02x", *s);
465                               p += 3;
466                             }
467                           break;
468                         }
469                     }
470                   else
471                     {
472                       if (p)
473                         *p++ = *s;
474                       n++;
475                     }
476                 }
477               else if ((*s & 0xe0) == 0xc0) /* 110x xxxx */
478                 {
479                   val = *s & 0x1f;
480                   nleft = 1;
481                   encidx = 0;
482                   encbuf[encidx++] = *s;
483                 }
484               else if ((*s & 0xf0) == 0xe0) /* 1110 xxxx */
485                 {
486                   val = *s & 0x0f;
487                   nleft = 2;
488                   encidx = 0;
489                   encbuf[encidx++] = *s;
490                 }
491               else if ((*s & 0xf8) == 0xf0) /* 1111 0xxx */
492                 {
493                   val = *s & 0x07;
494                   nleft = 3;
495                   encidx = 0;
496                   encbuf[encidx++] = *s;
497                 }
498               else if ((*s & 0xfc) == 0xf8) /* 1111 10xx */
499                 {
500                   val = *s & 0x03;
501                   nleft = 4;
502                   encidx = 0;
503                   encbuf[encidx++] = *s;
504                 }
505               else if ((*s & 0xfe) == 0xfc) /* 1111 110x */
506                 {
507                   val = *s & 0x01;
508                   nleft = 5;
509                   encidx = 0;
510                   encbuf[encidx++] = *s;
511                 }
512               else /* Invalid encoding: print as \xNN. */
513                 {
514                   if (p)
515                     {
516                       sprintf (p, "\\x%02x", *s);
517                       p += 4;
518                     }
519                   n += 4;
520                   resync = 1;
521                 }
522             }
523           else if (*s < 0x80 || *s >= 0xc0) /* Invalid utf-8 */
524             {
525               if (p)
526                 {
527                   for (i = 0; i < encidx; i++)
528                     {
529                       sprintf (p, "\\x%02x", encbuf[i]);
530                       p += 4;
531                     }
532                   sprintf (p, "\\x%02x", *s);
533                   p += 4;
534                 }
535               n += 4 + 4 * encidx;
536               nleft = 0;
537               encidx = 0;
538               resync = 1;
539             }
540           else
541             {
542               encbuf[encidx++] = *s;
543               val <<= 6;
544               val |= *s & 0x3f;
545               if (!--nleft)  /* Ready. */
546                 {
547                   if (no_translation)
548                     {
549                       if (p)
550                         {
551                           for (i = 0; i < encidx; i++)
552                             *p++ = encbuf[i];
553                         }
554                       n += encidx;
555                       encidx = 0;
556                     }
557                   else if (with_iconv)
558                     {
559                       /* Our strategy for using iconv is a bit strange
560                          but it better keeps compatibility with
561                          previous versions in regard to how invalid
562                          encodings are displayed.  What we do is to
563                          keep the utf-8 as is and have the real
564                          translation step then at the end.  Yes, I
565                          know that this is ugly.  However we are short
566                          of the 1.4 release and for this branch we
567                          should not mess too much around with iconv
568                          things.  One reason for this is that we don't
569                          know enough about non-GNU iconv
570                          implementation and want to minimize the risk
571                          of breaking the code on too many platforms.  */
572                         if ( p )
573                           {
574                             for (i=0; i < encidx; i++ )
575                               *p++ = encbuf[i];
576                           }
577                         n += encidx;
578                         encidx = 0;
579                     }
580                   else  /* Latin-1 case. */
581                     {
582                       if (val >= 0x80 && val < 256)
583                         {
584                           /* We can simply print this character */
585                           n++;
586                           if (p)
587                             *p++ = val;
588                         }
589                       else
590                         {
591                           /* We do not have a translation: print utf8. */
592                           if (p)
593                             {
594                               for (i = 0; i < encidx; i++)
595                                 {
596                                   sprintf (p, "\\x%02x", encbuf[i]);
597                                   p += 4;
598                                 }
599                             }
600                           n += encidx * 4;
601                           encidx = 0;
602                         }
603                     }
604                 }
605
606             }
607         }
608       if (!buffer)
609         {
610           /* Allocate the buffer after the first pass. */
611           buffer = p = xmalloc (n + 1);
612         }
613       else if (with_iconv)
614         {
615           /* Note: See above for comments.  */
616           iconv_t cd;
617           const char *inptr;
618           char *outbuf, *outptr;
619           size_t inbytes, outbytes;
620
621           *p = 0;  /* Terminate the buffer. */
622
623           cd = iconv_open (active_charset_name, "utf-8");
624           if (cd == (iconv_t)-1)
625             {
626               handle_iconv_error (active_charset_name, "utf-8", 1);
627               xfree (buffer);
628               return utf8_to_native (string, length, delim);
629             }
630
631           /* Allocate a new buffer large enough to hold all possible
632              encodings. */
633           n = p - buffer + 1;
634           inbytes = n - 1;;
635           inptr = buffer;
636           outbytes = n * MB_LEN_MAX;
637           if (outbytes / MB_LEN_MAX != n)
638             BUG (); /* Actually an overflow. */
639           outbuf = outptr = xmalloc (outbytes);
640           if ( iconv (cd, (ICONV_CONST char **)&inptr, &inbytes,
641                       &outptr, &outbytes) == (size_t)-1)
642             {
643               static int shown;
644
645               if (!shown)
646                 log_info (_("conversion from '%s' to '%s' failed: %s\n"),
647                           "utf-8", active_charset_name, strerror (errno));
648               shown = 1;
649               /* Didn't worked out.  Try again but without iconv.  */
650               xfree (buffer);
651               buffer = NULL;
652               xfree (outbuf);
653               outbuf = do_utf8_to_native (string, length, delim, 0);
654             }
655             else /* Success.  */
656               {
657                 *outptr = 0; /* Make sure it is a string. */
658                 /* We could realloc the buffer now but I doubt that it
659                    makes much sense given that it will get freed
660                    anyway soon after.  */
661                 xfree (buffer);
662               }
663           iconv_close (cd);
664           return outbuf;
665         }
666       else /* Not using iconv. */
667         {
668           *p = 0; /* Make sure it is a string. */
669           return buffer;
670         }
671     }
672 }
673
674 /* Convert string, which is in UTF-8 to native encoding.  Replace
675    illegal encodings by some "\xnn" and quote all control
676    characters. A character with value DELIM will always be quoted, it
677    must be a vanilla ASCII character.  A DELIM value of -1 is special:
678    it disables all quoting of control characters.  This function
679    terminates the process on memory shortage.  */
680 char *
681 utf8_to_native (const char *string, size_t length, int delim)
682 {
683   return do_utf8_to_native (string, length, delim, use_iconv);
684 }
685
686
687
688
689 /* Wrapper function for iconv_open, required for W32 as we dlopen that
690    library on that system.  */
691 jnlib_iconv_t
692 jnlib_iconv_open (const char *tocode, const char *fromcode)
693 {
694   return (jnlib_iconv_t)iconv_open (tocode, fromcode);
695 }
696
697
698 /* Wrapper function for iconv, required for W32 as we dlopen that
699    library on that system.  */
700 size_t
701 jnlib_iconv (jnlib_iconv_t cd,
702              const char **inbuf, size_t *inbytesleft,
703              char **outbuf, size_t *outbytesleft)
704 {
705   return iconv ((iconv_t)cd, (char**)inbuf, inbytesleft, outbuf, outbytesleft);
706 }
707
708 /* Wrapper function for iconv_close, required for W32 as we dlopen that
709    library on that system.  */
710 int
711 jnlib_iconv_close (jnlib_iconv_t cd)
712 {
713   return iconv_close ((iconv_t)cd);
714 }
715
716
717 #ifdef HAVE_W32_SYSTEM
718 /* Return a malloced string encoded in UTF-8 from the wide char input
719    string STRING.  Caller must free this value.  Returns NULL and sets
720    ERRNO on failure.  Calling this function with STRING set to NULL is
721    not defined.  */
722 char *
723 wchar_to_utf8 (const wchar_t *string)
724 {
725   int n;
726   char *result;
727
728   n = WideCharToMultiByte (CP_UTF8, 0, string, -1, NULL, 0, NULL, NULL);
729   if (n < 0)
730     {
731       gpg_err_set_errno (EINVAL);
732       return NULL;
733     }
734
735   result = xtrymalloc (n+1);
736   if (!result)
737     return NULL;
738
739   n = WideCharToMultiByte (CP_UTF8, 0, string, -1, result, n, NULL, NULL);
740   if (n < 0)
741     {
742       xfree (result);
743       gpg_err_set_errno (EINVAL);
744       result = NULL;
745     }
746   return result;
747 }
748
749
750 /* Return a malloced wide char string from an UTF-8 encoded input
751    string STRING.  Caller must free this value.  Returns NULL and sets
752    ERRNO on failure.  Calling this function with STRING set to NULL is
753    not defined.  */
754 wchar_t *
755 utf8_to_wchar (const char *string)
756 {
757   int n;
758   size_t nbytes;
759   wchar_t *result;
760
761   n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
762   if (n < 0)
763     {
764       gpg_err_set_errno (EINVAL);
765       return NULL;
766     }
767
768   nbytes = (size_t)(n+1) * sizeof(*result);
769   if (nbytes / sizeof(*result) != (n+1))
770     {
771       gpg_err_set_errno (ENOMEM);
772       return NULL;
773     }
774   result = xtrymalloc (nbytes);
775   if (!result)
776     return NULL;
777
778   n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
779   if (n < 0)
780     {
781       xfree (result);
782       gpg_err_set_errno (EINVAL);
783       result = NULL;
784     }
785   return result;
786 }
787 #endif /*HAVE_W32_SYSTEM*/