b89350f1f346c776bf645f26814ba70ca6c13698
[kopensolaris-gnu/glibc.git] / libidn / idna.c
1 /* idna.c       Convert to or from IDN strings.
2  * Copyright (C) 2002, 2003, 2004  Simon Josefsson
3  *
4  * This file is part of GNU Libidn.
5  *
6  * GNU Libidn is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * GNU Libidn is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with GNU Libidn; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #if HAVE_CONFIG_H
23 # include "config.h"
24 #endif
25
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stringprep.h>
29 #include <punycode.h>
30
31 #include "idna.h"
32
33 #define DOTP(c) ((c) == 0x002E || (c) == 0x3002 ||      \
34                  (c) == 0xFF0E || (c) == 0xFF61)
35
36 /* Core functions */
37
38 /**
39  * idna_to_ascii_4i
40  * @in: input array with unicode code points.
41  * @inlen: length of input array with unicode code points.
42  * @out: output zero terminated string that must have room for at
43  *       least 63 characters plus the terminating zero.
44  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
45  *
46  * The ToASCII operation takes a sequence of Unicode code points that make
47  * up one label and transforms it into a sequence of code points in the
48  * ASCII range (0..7F). If ToASCII succeeds, the original sequence and the
49  * resulting sequence are equivalent labels.
50  *
51  * It is important to note that the ToASCII operation can fail. ToASCII
52  * fails if any step of it fails. If any step of the ToASCII operation
53  * fails on any label in a domain name, that domain name MUST NOT be used
54  * as an internationalized domain name. The method for deadling with this
55  * failure is application-specific.
56  *
57  * The inputs to ToASCII are a sequence of code points, the AllowUnassigned
58  * flag, and the UseSTD3ASCIIRules flag. The output of ToASCII is either a
59  * sequence of ASCII code points or a failure condition.
60  *
61  * ToASCII never alters a sequence of code points that are all in the ASCII
62  * range to begin with (although it could fail). Applying the ToASCII
63  * operation multiple times has exactly the same effect as applying it just
64  * once.
65  *
66  * Return value: Returns 0 on success, or an error code.
67  */
68 int
69 idna_to_ascii_4i (const uint32_t * in, size_t inlen, char *out, int flags)
70 {
71   size_t len, outlen;
72   uint32_t *src;                /* XXX don't need to copy data? */
73   int rc;
74
75   /*
76    * ToASCII consists of the following steps:
77    *
78    * 1. If all code points in the sequence are in the ASCII range (0..7F)
79    * then skip to step 3.
80    */
81
82   {
83     size_t i;
84     int inasciirange;
85
86     inasciirange = 1;
87     for (i = 0; i < inlen; i++)
88       if (in[i] > 0x7F)
89         inasciirange = 0;
90     if (inasciirange)
91       {
92         src = malloc (sizeof (in[0]) * (inlen + 1));
93         if (src == NULL)
94           return IDNA_MALLOC_ERROR;
95
96         memcpy (src, in, sizeof (in[0]) * inlen);
97         src[inlen] = 0;
98
99         goto step3;
100       }
101   }
102
103   /*
104    * 2. Perform the steps specified in [NAMEPREP] and fail if there is
105    * an error. The AllowUnassigned flag is used in [NAMEPREP].
106    */
107
108   {
109     char *p;
110
111     p = stringprep_ucs4_to_utf8 (in, inlen, NULL, NULL);
112     if (p == NULL)
113       return IDNA_MALLOC_ERROR;
114
115     len = strlen (p);
116     do
117       {
118         len = 2 * len + 10;     /* XXX better guess? */
119         p = realloc (p, len);
120         if (p == NULL)
121           return IDNA_MALLOC_ERROR;
122
123         if (flags & IDNA_ALLOW_UNASSIGNED)
124           rc = stringprep_nameprep (p, len);
125         else
126           rc = stringprep_nameprep_no_unassigned (p, len);
127       }
128     while (rc == STRINGPREP_TOO_SMALL_BUFFER);
129
130     if (rc != STRINGPREP_OK)
131       {
132         free (p);
133         return IDNA_STRINGPREP_ERROR;
134       }
135
136     src = stringprep_utf8_to_ucs4 (p, -1, NULL);
137
138     free (p);
139   }
140
141 step3:
142   /*
143    * 3. If the UseSTD3ASCIIRules flag is set, then perform these checks:
144    *
145    * (a) Verify the absence of non-LDH ASCII code points; that is,
146    * the absence of 0..2C, 2E..2F, 3A..40, 5B..60, and 7B..7F.
147    *
148    * (b) Verify the absence of leading and trailing hyphen-minus;
149    * that is, the absence of U+002D at the beginning and end of
150    * the sequence.
151    */
152
153   if (flags & IDNA_USE_STD3_ASCII_RULES)
154     {
155       size_t i;
156
157       for (i = 0; src[i]; i++)
158         if (src[i] <= 0x2C || src[i] == 0x2E || src[i] == 0x2F ||
159             (src[i] >= 0x3A && src[i] <= 0x40) ||
160             (src[i] >= 0x5B && src[i] <= 0x60) ||
161             (src[i] >= 0x7B && src[i] <= 0x7F))
162           {
163             free (src);
164             return IDNA_CONTAINS_NON_LDH;
165           }
166
167       if (src[0] == 0x002D || (i > 0 && src[i - 1] == 0x002D))
168         {
169           free (src);
170           return IDNA_CONTAINS_MINUS;
171         }
172     }
173
174   /*
175    * 4. If all code points in the sequence are in the ASCII range
176    * (0..7F), then skip to step 8.
177    */
178
179   {
180     size_t i;
181     int inasciirange;
182
183     inasciirange = 1;
184     for (i = 0; src[i]; i++)
185       {
186         if (src[i] > 0x7F)
187           inasciirange = 0;
188         /* copy string to output buffer if we are about to skip to step8 */
189         if (i < 64)
190           out[i] = src[i];
191       }
192     if (i < 64)
193       out[i] = '\0';
194     if (inasciirange)
195       goto step8;
196   }
197
198   /*
199    * 5. Verify that the sequence does NOT begin with the ACE prefix.
200    *
201    */
202
203   {
204     size_t i;
205     int match;
206
207     match = 1;
208     for (i = 0; match && i < strlen (IDNA_ACE_PREFIX); i++)
209       if (((uint32_t) IDNA_ACE_PREFIX[i] & 0xFF) != src[i])
210         match = 0;
211     if (match)
212       {
213         free (src);
214         return IDNA_CONTAINS_ACE_PREFIX;
215       }
216   }
217
218   /*
219    * 6. Encode the sequence using the encoding algorithm in [PUNYCODE]
220    * and fail if there is an error.
221    */
222   for (len = 0; src[len]; len++)
223     ;
224   src[len] = '\0';
225   outlen = 63 - strlen (IDNA_ACE_PREFIX);
226   rc = punycode_encode (len, src, NULL,
227                         &outlen, &out[strlen (IDNA_ACE_PREFIX)]);
228   if (rc != PUNYCODE_SUCCESS)
229     {
230       free (src);
231       return IDNA_PUNYCODE_ERROR;
232     }
233   out[strlen (IDNA_ACE_PREFIX) + outlen] = '\0';
234
235   /*
236    * 7. Prepend the ACE prefix.
237    */
238
239   memcpy (out, IDNA_ACE_PREFIX, strlen (IDNA_ACE_PREFIX));
240
241   /*
242    * 8. Verify that the number of code points is in the range 1 to 63
243    * inclusive (0 is excluded).
244    */
245
246 step8:
247   free (src);
248   if (strlen (out) < 1 || strlen (out) > 63)
249     return IDNA_INVALID_LENGTH;
250
251   return IDNA_SUCCESS;
252 }
253
254 /* ToUnicode().  May realloc() utf8in. */
255 static int
256 idna_to_unicode_internal (char *utf8in,
257                           uint32_t * out, size_t * outlen, int flags)
258 {
259   int rc;
260   char tmpout[64];
261   size_t utf8len = strlen (utf8in) + 1;
262   size_t addlen = 0;
263
264   /*
265    * ToUnicode consists of the following steps:
266    *
267    * 1. If the sequence contains any code points outside the ASCII range
268    * (0..7F) then proceed to step 2, otherwise skip to step 3.
269    */
270
271   {
272     size_t i;
273     int inasciirange;
274
275     inasciirange = 1;
276     for (i = 0; utf8in[i]; i++)
277       if (utf8in[i] & ~0x7F)
278         inasciirange = 0;
279     if (inasciirange)
280       goto step3;
281   }
282
283   /*
284    * 2. Perform the steps specified in [NAMEPREP] and fail if there is an
285    * error. (If step 3 of ToASCII is also performed here, it will not
286    * affect the overall behavior of ToUnicode, but it is not
287    * necessary.) The AllowUnassigned flag is used in [NAMEPREP].
288    */
289   do
290     {
291       utf8in = realloc (utf8in, utf8len + addlen);
292       if (!utf8in)
293         return IDNA_MALLOC_ERROR;
294       if (flags & IDNA_ALLOW_UNASSIGNED)
295         rc = stringprep_nameprep (utf8in, utf8len + addlen);
296       else
297         rc = stringprep_nameprep_no_unassigned (utf8in, utf8len + addlen);
298       addlen += 1;
299     }
300   while (rc == STRINGPREP_TOO_SMALL_BUFFER);
301
302   if (rc != STRINGPREP_OK)
303     return IDNA_STRINGPREP_ERROR;
304
305   /* 3. Verify that the sequence begins with the ACE prefix, and save a
306    * copy of the sequence.
307    */
308
309 step3:
310   if (memcmp (IDNA_ACE_PREFIX, utf8in, strlen (IDNA_ACE_PREFIX)) != 0)
311     return IDNA_NO_ACE_PREFIX;
312
313   /* 4. Remove the ACE prefix.
314    */
315
316   memmove (utf8in, &utf8in[strlen (IDNA_ACE_PREFIX)],
317            strlen (utf8in) - strlen (IDNA_ACE_PREFIX) + 1);
318
319   /* 5. Decode the sequence using the decoding algorithm in [PUNYCODE]
320    * and fail if there is an error. Save a copy of the result of
321    * this step.
322    */
323
324   (*outlen)--;                  /* reserve one for the zero */
325
326   rc = punycode_decode (strlen (utf8in), utf8in, outlen, out, NULL);
327   if (rc != PUNYCODE_SUCCESS)
328     return IDNA_PUNYCODE_ERROR;
329
330   out[*outlen] = 0;             /* add zero */
331
332   /* 6. Apply ToASCII.
333    */
334
335   rc = idna_to_ascii_4i (out, *outlen, tmpout, flags);
336   if (rc != IDNA_SUCCESS)
337     return rc;
338
339   /* 7. Verify that the result of step 6 matches the saved copy from
340    * step 3, using a case-insensitive ASCII comparison.
341    */
342
343   if (strcasecmp (utf8in, tmpout + strlen (IDNA_ACE_PREFIX)) != 0)
344     return IDNA_ROUNDTRIP_VERIFY_ERROR;
345
346   /* 8. Return the saved copy from step 5.
347    */
348
349   return IDNA_SUCCESS;
350 }
351
352 /**
353  * idna_to_unicode_44i
354  * @in: input array with unicode code points.
355  * @inlen: length of input array with unicode code points.
356  * @out: output array with unicode code points.
357  * @outlen: on input, maximum size of output array with unicode code points,
358  *          on exit, actual size of output array with unicode code points.
359  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
360  *
361  * The ToUnicode operation takes a sequence of Unicode code points
362  * that make up one label and returns a sequence of Unicode code
363  * points. If the input sequence is a label in ACE form, then the
364  * result is an equivalent internationalized label that is not in ACE
365  * form, otherwise the original sequence is returned unaltered.
366  *
367  * ToUnicode never fails. If any step fails, then the original input
368  * sequence is returned immediately in that step.
369  *
370  * The Punycode decoder can never output more code points than it
371  * inputs, but Nameprep can, and therefore ToUnicode can.  Note that
372  * the number of octets needed to represent a sequence of code points
373  * depends on the particular character encoding used.
374  *
375  * The inputs to ToUnicode are a sequence of code points, the
376  * AllowUnassigned flag, and the UseSTD3ASCIIRules flag. The output of
377  * ToUnicode is always a sequence of Unicode code points.
378  *
379  * Return value: Returns error condition, but it must only be used for
380  *               debugging purposes.  The output buffer is always
381  *               guaranteed to contain the correct data according to
382  *               the specification (sans malloc induced errors).  NB!
383  *               This means that you normally ignore the return code
384  *               from this function, as checking it means breaking the
385  *               standard.
386  */
387 int
388 idna_to_unicode_44i (const uint32_t * in, size_t inlen,
389                      uint32_t * out, size_t * outlen, int flags)
390 {
391   int rc;
392   size_t outlensave = *outlen;
393   char *p;
394
395   p = stringprep_ucs4_to_utf8 (in, inlen, NULL, NULL);
396   if (p == NULL)
397     return IDNA_MALLOC_ERROR;
398
399   rc = idna_to_unicode_internal (p, out, outlen, flags);
400   if (rc != IDNA_SUCCESS)
401     {
402       memcpy (out, in, sizeof (in[0]) * (inlen < outlensave ?
403                                          inlen : outlensave));
404       *outlen = inlen;
405     }
406
407   free (p);
408
409   return rc;
410 }
411
412 /* Wrappers that handle several labels */
413
414 /**
415  * idna_to_ascii_4z:
416  * @input: zero terminated input Unicode string.
417  * @output: pointer to newly allocated output string.
418  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
419  *
420  * Convert UCS-4 domain name to ASCII string.  The domain name may
421  * contain several labels, separated by dots.  The output buffer must
422  * be deallocated by the caller.
423  *
424  * Return value: Returns IDNA_SUCCESS on success, or error code.
425  **/
426 int
427 idna_to_ascii_4z (const uint32_t * input, char **output, int flags)
428 {
429   const uint32_t *start = input;
430   const uint32_t *end = input;
431   char buf[64];
432   char *out = NULL;
433   int rc;
434
435   /* 1) Whenever dots are used as label separators, the following
436      characters MUST be recognized as dots: U+002E (full stop),
437      U+3002 (ideographic full stop), U+FF0E (fullwidth full stop),
438      U+FF61 (halfwidth ideographic full stop). */
439
440   if (input[0] == 0
441       /* Handle explicit zero-length root label. */
442       || (DOTP (input[0]) && input[1] == 0))
443     {
444 #if defined HAVE_STRDUP || defined _LIBC
445       *output = strdup (input);
446       return *output == NULL ? IDNA_MALLOC_ERROR : IDNA_SUCCESS;
447 #else
448       /* Handle implicit zero-length root label. */
449       *output = malloc (1);
450       if (!*output)
451         return IDNA_MALLOC_ERROR;
452       strcpy (*output, input);
453       return IDNA_SUCCESS;
454 #endif
455     }
456
457   *output = NULL;
458   do
459     {
460       end = start;
461
462       for (; *end && !DOTP (*end); end++)
463         ;
464
465       if (*end == '\0' && start == end)
466         {
467           /* Handle explicit zero-length root label. */
468           buf[0] = '\0';
469         }
470       else
471         {
472           rc = idna_to_ascii_4i (start, end - start, buf, flags);
473           if (rc != IDNA_SUCCESS)
474             return rc;
475         }
476
477       if (out)
478         {
479           out = realloc (out, strlen (out) + 1 + strlen (buf) + 1);
480           if (!out)
481             return IDNA_MALLOC_ERROR;
482           strcat (out, ".");
483           strcat (out, buf);
484         }
485       else
486         {
487           out = (char *) malloc (strlen (buf) + 1);
488           if (!out)
489             return IDNA_MALLOC_ERROR;
490           strcpy (out, buf);
491         }
492
493       start = end + 1;
494     }
495   while (*end);
496
497   *output = out;
498
499   return IDNA_SUCCESS;
500 }
501
502 /**
503  * idna_to_ascii_8z:
504  * @input: zero terminated input UTF-8 string.
505  * @output: pointer to newly allocated output string.
506  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
507  *
508  * Convert UTF-8 domain name to ASCII string.  The domain name may
509  * contain several labels, separated by dots.  The output buffer must
510  * be deallocated by the caller.
511  *
512  * Return value: Returns IDNA_SUCCESS on success, or error code.
513  **/
514 int
515 idna_to_ascii_8z (const char *input, char **output, int flags)
516 {
517   uint32_t *ucs4;
518   size_t ucs4len;
519   int rc;
520
521   ucs4 = stringprep_utf8_to_ucs4 (input, -1, &ucs4len);
522   if (!ucs4)
523     return IDNA_ICONV_ERROR;
524
525   rc = idna_to_ascii_4z (ucs4, output, flags);
526
527   free (ucs4);
528
529   return rc;
530
531 }
532
533 /**
534  * idna_to_ascii_lz:
535  * @input: zero terminated input UTF-8 string.
536  * @output: pointer to newly allocated output string.
537  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
538  *
539  * Convert domain name in the locale's encoding to ASCII string.  The
540  * domain name may contain several labels, separated by dots.  The
541  * output buffer must be deallocated by the caller.
542  *
543  * Return value: Returns IDNA_SUCCESS on success, or error code.
544  **/
545 int
546 idna_to_ascii_lz (const char *input, char **output, int flags)
547 {
548   char *utf8;
549   int rc;
550
551   utf8 = stringprep_locale_to_utf8 (input);
552   if (!utf8)
553     return IDNA_ICONV_ERROR;
554
555   rc = idna_to_ascii_8z (utf8, output, flags);
556
557   free (utf8);
558
559   return rc;
560 }
561
562 /**
563  * idna_to_unicode_4z4z:
564  * @input: zero-terminated Unicode string.
565  * @output: pointer to newly allocated output Unicode string.
566  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
567  *
568  * Convert possibly ACE encoded domain name in UCS-4 format into a
569  * UCS-4 string.  The domain name may contain several labels,
570  * separated by dots.  The output buffer must be deallocated by the
571  * caller.
572  *
573  * Return value: Returns IDNA_SUCCESS on success, or error code.
574  **/
575 int
576 idna_to_unicode_4z4z (const uint32_t * input, uint32_t ** output, int flags)
577 {
578   const uint32_t *start = input;
579   const uint32_t *end = input;
580   uint32_t *buf;
581   size_t buflen;
582   uint32_t *out = NULL;
583   size_t outlen = 0;
584   int rc;
585
586   *output = NULL;
587
588   do
589     {
590       end = start;
591
592       for (; *end && !DOTP (*end); end++)
593         ;
594
595       buflen = end - start;
596       buf = malloc (sizeof (buf[0]) * (buflen + 1));
597       if (!buf)
598         return IDNA_MALLOC_ERROR;
599
600       rc = idna_to_unicode_44i (start, end - start, buf, &buflen, flags);
601       /* don't check rc as per specification! */
602
603       if (out)
604         {
605           out = realloc (out, sizeof (out[0]) * (outlen + 1 + buflen + 1));
606           if (!out)
607             return IDNA_MALLOC_ERROR;
608           out[outlen++] = 0x002E;       /* '.' (full stop) */
609           memcpy (out + outlen, buf, sizeof (buf[0]) * buflen);
610           outlen += buflen;
611           out[outlen] = 0x0;
612           free (buf);
613         }
614       else
615         {
616           out = buf;
617           outlen = buflen;
618           out[outlen] = 0x0;
619         }
620
621       start = end + 1;
622     }
623   while (*end);
624
625   *output = out;
626
627   return IDNA_SUCCESS;
628 }
629
630 /**
631  * idna_to_unicode_8z4z:
632  * @input: zero-terminated UTF-8 string.
633  * @output: pointer to newly allocated output Unicode string.
634  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
635  *
636  * Convert possibly ACE encoded domain name in UTF-8 format into a
637  * UCS-4 string.  The domain name may contain several labels,
638  * separated by dots.  The output buffer must be deallocated by the
639  * caller.
640  *
641  * Return value: Returns IDNA_SUCCESS on success, or error code.
642  **/
643 int
644 idna_to_unicode_8z4z (const char *input, uint32_t ** output, int flags)
645 {
646   uint32_t *ucs4;
647   size_t ucs4len;
648   int rc;
649
650   ucs4 = stringprep_utf8_to_ucs4 (input, -1, &ucs4len);
651   if (!ucs4)
652     return IDNA_ICONV_ERROR;
653
654   rc = idna_to_unicode_4z4z (ucs4, output, flags);
655   free (ucs4);
656
657   return rc;
658 }
659
660 /**
661  * idna_to_unicode_8z8z:
662  * @input: zero-terminated UTF-8 string.
663  * @output: pointer to newly allocated output UTF-8 string.
664  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
665  *
666  * Convert possibly ACE encoded domain name in UTF-8 format into a
667  * UTF-8 string.  The domain name may contain several labels,
668  * separated by dots.  The output buffer must be deallocated by the
669  * caller.
670  *
671  * Return value: Returns IDNA_SUCCESS on success, or error code.
672  **/
673 int
674 idna_to_unicode_8z8z (const char *input, char **output, int flags)
675 {
676   uint32_t *ucs4;
677   int rc;
678
679   rc = idna_to_unicode_8z4z (input, &ucs4, flags);
680   *output = stringprep_ucs4_to_utf8 (ucs4, -1, NULL, NULL);
681   free (ucs4);
682
683   if (!*output)
684     return IDNA_ICONV_ERROR;
685
686   return rc;
687 }
688
689 /**
690  * idna_to_unicode_8zlz:
691  * @input: zero-terminated UTF-8 string.
692  * @output: pointer to newly allocated output string encoded in the
693  *   current locale's character set.
694  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
695  *
696  * Convert possibly ACE encoded domain name in UTF-8 format into a
697  * string encoded in the current locale's character set.  The domain
698  * name may contain several labels, separated by dots.  The output
699  * buffer must be deallocated by the caller.
700  *
701  * Return value: Returns IDNA_SUCCESS on success, or error code.
702  **/
703 int
704 idna_to_unicode_8zlz (const char *input, char **output, int flags)
705 {
706   char *utf8;
707   int rc;
708
709   rc = idna_to_unicode_8z8z (input, &utf8, flags);
710   *output = stringprep_utf8_to_locale (utf8);
711   free (utf8);
712
713   if (!*output)
714     return IDNA_ICONV_ERROR;
715
716   return rc;
717 }
718
719 /**
720  * idna_to_unicode_lzlz:
721  * @input: zero-terminated string encoded in the current locale's
722  *   character set.
723  * @output: pointer to newly allocated output string encoded in the
724  *   current locale's character set.
725  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
726  *
727  * Convert possibly ACE encoded domain name in the locale's character
728  * set into a string encoded in the current locale's character set.
729  * The domain name may contain several labels, separated by dots.  The
730  * output buffer must be deallocated by the caller.
731  *
732  * Return value: Returns IDNA_SUCCESS on success, or error code.
733  **/
734 int
735 idna_to_unicode_lzlz (const char *input, char **output, int flags)
736 {
737   char *utf8;
738   int rc;
739
740   utf8 = stringprep_locale_to_utf8 (input);
741   if (!utf8)
742     return IDNA_ICONV_ERROR;
743
744   rc = idna_to_unicode_8zlz (utf8, output, flags);
745   free (utf8);
746
747   return rc;
748 }
749
750 /**
751  * IDNA_ACE_PREFIX
752  *
753  * The IANA allocated prefix to use for IDNA. "xn--"
754  */
755
756 /**
757  * Idna_rc:
758  * @IDNA_SUCCESS: Successful operation.  This value is guaranteed to
759  *   always be zero, the remaining ones are only guaranteed to hold
760  *   non-zero values, for logical comparison purposes.
761  * @IDNA_STRINGPREP_ERROR:  Error during string preparation.
762  * @IDNA_PUNYCODE_ERROR: Error during punycode operation.
763  * @IDNA_CONTAINS_NON_LDH: For IDNA_USE_STD3_ASCII_RULES, indicate that
764  *   the string contains non-LDH ASCII characters.
765  * @IDNA_CONTAINS_MINUS: For IDNA_USE_STD3_ASCII_RULES, indicate that
766  *   the string contains a leading or trailing hyphen-minus (U+002D).
767  * @IDNA_INVALID_LENGTH: The final output string is not within the
768  *   (inclusive) range 1 to 63 characters.
769  * @IDNA_NO_ACE_PREFIX: The string does not contain the ACE prefix
770  *   (for ToUnicode).
771  * @IDNA_ROUNDTRIP_VERIFY_ERROR: The ToASCII operation on output
772  *   string does not equal the input.
773  * @IDNA_CONTAINS_ACE_PREFIX: The input contains the ACE prefix (for
774  *   ToASCII).
775  * @IDNA_ICONV_ERROR: Could not convert string in locale encoding.
776  * @IDNA_MALLOC_ERROR: Could not allocate buffer (this is typically a
777  *   fatal error).
778  *
779  * Enumerated return codes of idna_to_ascii_4i(),
780  * idna_to_unicode_44i() functions (and functions derived from those
781  * functions).  The value 0 is guaranteed to always correspond to
782  * success.
783  */
784
785
786 /**
787  * Idna_flags:
788  * @IDNA_ALLOW_UNASSIGNED: Don't reject strings containing unassigned
789  *   Unicode code points.
790  * @IDNA_USE_STD3_ASCII_RULES: Validate strings according to STD3
791  *   rules (i.e., normal host name rules).
792  *
793  * Flags to pass to idna_to_ascii_4i(), idna_to_unicode_44i() etc.
794  */