lib/idna.c

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