libidn/idna.c

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