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