lib/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     {
 442       /* Handle implicit zero-length root label. */
 443       *output = malloc (1);
 444       if (!*output)
 445         return IDNA_MALLOC_ERROR;
 446       strcpy (*output, "");
 447       return IDNA_SUCCESS;
 448     }
 449
 450   if (DOTP (input[0]) && input[1] == 0)
 451     {
 452       /* Handle explicit zero-length root label. */
 453       *output = malloc (2);
 454       if (!*output)
 455         return IDNA_MALLOC_ERROR;
 456       strcpy (*output, ".");
 457       return IDNA_SUCCESS;
 458     }
 459
 460   *output = NULL;
 461   do
 462     {
 463       end = start;
 464
 465       for (; *end && !DOTP (*end); end++)
 466         ;
 467
 468       if (*end == '\0' && start == end)
 469         {
 470           /* Handle explicit zero-length root label. */
 471           buf[0] = '\0';
 472         }
 473       else
 474         {
 475           rc = idna_to_ascii_4i (start, end - start, buf, flags);
 476           if (rc != IDNA_SUCCESS)
 477             return rc;
 478         }
 479
 480       if (out)
 481         {
 482           out = realloc (out, strlen (out) + 1 + strlen (buf) + 1);
 483           if (!out)
 484             return IDNA_MALLOC_ERROR;
 485           strcat (out, ".");
 486           strcat (out, buf);
 487         }
 488       else
 489         {
 490           out = (char *) malloc (strlen (buf) + 1);
 491           if (!out)
 492             return IDNA_MALLOC_ERROR;
 493           strcpy (out, buf);
 494         }
 495
 496       start = end + 1;
 497     }
 498   while (*end);
 499
 500   *output = out;
 501
 502   return IDNA_SUCCESS;
 503 }
 504
 505 /**
 506  * idna_to_ascii_8z:
 507  * @input: zero terminated input UTF-8 string.
 508  * @output: pointer to newly allocated output string.
 509  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 510  *
 511  * Convert UTF-8 domain name to ASCII string.  The domain name may
 512  * contain several labels, separated by dots.  The output buffer must
 513  * be deallocated by the caller.
 514  *
 515  * Return value: Returns IDNA_SUCCESS on success, or error code.
 516  **/
 517 int
 518 idna_to_ascii_8z (const char *input, char **output, int flags)
 519 {
 520   uint32_t *ucs4;
 521   size_t ucs4len;
 522   int rc;
 523
 524   ucs4 = stringprep_utf8_to_ucs4 (input, -1, &ucs4len);
 525   if (!ucs4)
 526     return IDNA_ICONV_ERROR;
 527
 528   rc = idna_to_ascii_4z (ucs4, output, flags);
 529
 530   free (ucs4);
 531
 532   return rc;
 533
 534 }
 535
 536 /**
 537  * idna_to_ascii_lz:
 538  * @input: zero terminated input UTF-8 string.
 539  * @output: pointer to newly allocated output string.
 540  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 541  *
 542  * Convert domain name in the locale's encoding to ASCII string.  The
 543  * domain name may contain several labels, separated by dots.  The
 544  * output buffer must be deallocated by the caller.
 545  *
 546  * Return value: Returns IDNA_SUCCESS on success, or error code.
 547  **/
 548 int
 549 idna_to_ascii_lz (const char *input, char **output, int flags)
 550 {
 551   char *utf8;
 552   int rc;
 553
 554   utf8 = stringprep_locale_to_utf8 (input);
 555   if (!utf8)
 556     return IDNA_ICONV_ERROR;
 557
 558   rc = idna_to_ascii_8z (utf8, output, flags);
 559
 560   free (utf8);
 561
 562   return rc;
 563 }
 564
 565 /**
 566  * idna_to_unicode_4z4z:
 567  * @input: zero-terminated Unicode string.
 568  * @output: pointer to newly allocated output Unicode string.
 569  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 570  *
 571  * Convert possibly ACE encoded domain name in UCS-4 format into a
 572  * UCS-4 string.  The domain name may contain several labels,
 573  * separated by dots.  The output buffer must be deallocated by the
 574  * caller.
 575  *
 576  * Return value: Returns IDNA_SUCCESS on success, or error code.
 577  **/
 578 int
 579 idna_to_unicode_4z4z (const uint32_t * input, uint32_t ** output, int flags)
 580 {
 581   const uint32_t *start = input;
 582   const uint32_t *end = input;
 583   uint32_t *buf;
 584   size_t buflen;
 585   uint32_t *out = NULL;
 586   size_t outlen = 0;
 587   int rc;
 588
 589   *output = NULL;
 590
 591   do
 592     {
 593       end = start;
 594
 595       for (; *end && !DOTP (*end); end++)
 596         ;
 597
 598       buflen = end - start;
 599       buf = malloc (sizeof (buf[0]) * (buflen + 1));
 600       if (!buf)
 601         return IDNA_MALLOC_ERROR;
 602
 603       rc = idna_to_unicode_44i (start, end - start, buf, &buflen, flags);
 604       /* don't check rc as per specification! */
 605
 606       if (out)
 607         {
 608           out = realloc (out, sizeof (out[0]) * (outlen + 1 + buflen + 1));
 609           if (!out)
 610             return IDNA_MALLOC_ERROR;
 611           out[outlen++] = 0x002E;       /* '.' (full stop) */
 612           memcpy (out + outlen, buf, sizeof (buf[0]) * buflen);
 613           outlen += buflen;
 614           out[outlen] = 0x0;
 615           free (buf);
 616         }
 617       else
 618         {
 619           out = buf;
 620           outlen = buflen;
 621           out[outlen] = 0x0;
 622         }
 623
 624       start = end + 1;
 625     }
 626   while (*end);
 627
 628   *output = out;
 629
 630   return IDNA_SUCCESS;
 631 }
 632
 633 /**
 634  * idna_to_unicode_8z4z:
 635  * @input: zero-terminated UTF-8 string.
 636  * @output: pointer to newly allocated output Unicode string.
 637  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 638  *
 639  * Convert possibly ACE encoded domain name in UTF-8 format into a
 640  * UCS-4 string.  The domain name may contain several labels,
 641  * separated by dots.  The output buffer must be deallocated by the
 642  * caller.
 643  *
 644  * Return value: Returns IDNA_SUCCESS on success, or error code.
 645  **/
 646 int
 647 idna_to_unicode_8z4z (const char *input, uint32_t ** output, int flags)
 648 {
 649   uint32_t *ucs4;
 650   size_t ucs4len;
 651   int rc;
 652
 653   ucs4 = stringprep_utf8_to_ucs4 (input, -1, &ucs4len);
 654   if (!ucs4)
 655     return IDNA_ICONV_ERROR;
 656
 657   rc = idna_to_unicode_4z4z (ucs4, output, flags);
 658   free (ucs4);
 659
 660   return rc;
 661 }
 662
 663 /**
 664  * idna_to_unicode_8z8z:
 665  * @input: zero-terminated UTF-8 string.
 666  * @output: pointer to newly allocated output UTF-8 string.
 667  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 668  *
 669  * Convert possibly ACE encoded domain name in UTF-8 format into a
 670  * UTF-8 string.  The domain name may contain several labels,
 671  * separated by dots.  The output buffer must be deallocated by the
 672  * caller.
 673  *
 674  * Return value: Returns IDNA_SUCCESS on success, or error code.
 675  **/
 676 int
 677 idna_to_unicode_8z8z (const char *input, char **output, int flags)
 678 {
 679   uint32_t *ucs4;
 680   int rc;
 681
 682   rc = idna_to_unicode_8z4z (input, &ucs4, flags);
 683   *output = stringprep_ucs4_to_utf8 (ucs4, -1, NULL, NULL);
 684   free (ucs4);
 685
 686   if (!*output)
 687     return IDNA_ICONV_ERROR;
 688
 689   return rc;
 690 }
 691
 692 /**
 693  * idna_to_unicode_8zlz:
 694  * @input: zero-terminated UTF-8 string.
 695  * @output: pointer to newly allocated output string encoded in the
 696  *   current locale's character set.
 697  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 698  *
 699  * Convert possibly ACE encoded domain name in UTF-8 format into a
 700  * string encoded in the current locale's character set.  The domain
 701  * name may contain several labels, separated by dots.  The output
 702  * buffer must be deallocated by the caller.
 703  *
 704  * Return value: Returns IDNA_SUCCESS on success, or error code.
 705  **/
 706 int
 707 idna_to_unicode_8zlz (const char *input, char **output, int flags)
 708 {
 709   char *utf8;
 710   int rc;
 711
 712   rc = idna_to_unicode_8z8z (input, &utf8, flags);
 713   *output = stringprep_utf8_to_locale (utf8);
 714   free (utf8);
 715
 716   if (!*output)
 717     return IDNA_ICONV_ERROR;
 718
 719   return rc;
 720 }
 721
 722 /**
 723  * idna_to_unicode_lzlz:
 724  * @input: zero-terminated string encoded in the current locale's
 725  *   character set.
 726  * @output: pointer to newly allocated output string encoded in the
 727  *   current locale's character set.
 728  * @flags: IDNA flags, e.g. IDNA_ALLOW_UNASSIGNED or IDNA_USE_STD3_ASCII_RULES.
 729  *
 730  * Convert possibly ACE encoded domain name in the locale's character
 731  * set into a string encoded in the current locale's character set.
 732  * The domain name may contain several labels, separated by dots.  The
 733  * output buffer must be deallocated by the caller.
 734  *
 735  * Return value: Returns IDNA_SUCCESS on success, or error code.
 736  **/
 737 int
 738 idna_to_unicode_lzlz (const char *input, char **output, int flags)
 739 {
 740   char *utf8;
 741   int rc;
 742
 743   utf8 = stringprep_locale_to_utf8 (input);
 744   if (!utf8)
 745     return IDNA_ICONV_ERROR;
 746
 747   rc = idna_to_unicode_8zlz (utf8, output, flags);
 748   free (utf8);
 749
 750   return rc;
 751 }
 752
 753 /**
 754  * IDNA_ACE_PREFIX
 755  *
 756  * The IANA allocated prefix to use for IDNA. "xn--"
 757  */
 758
 759 /**
 760  * Idna_rc:
 761  * @IDNA_SUCCESS: Successful operation.  This value is guaranteed to
 762  *   always be zero, the remaining ones are only guaranteed to hold
 763  *   non-zero values, for logical comparison purposes.
 764  * @IDNA_STRINGPREP_ERROR:  Error during string preparation.
 765  * @IDNA_PUNYCODE_ERROR: Error during punycode operation.
 766  * @IDNA_CONTAINS_NON_LDH: For IDNA_USE_STD3_ASCII_RULES, indicate that
 767  *   the string contains non-LDH ASCII characters.
 768  * @IDNA_CONTAINS_MINUS: For IDNA_USE_STD3_ASCII_RULES, indicate that
 769  *   the string contains a leading or trailing hyphen-minus (U+002D).
 770  * @IDNA_INVALID_LENGTH: The final output string is not within the
 771  *   (inclusive) range 1 to 63 characters.
 772  * @IDNA_NO_ACE_PREFIX: The string does not contain the ACE prefix
 773  *   (for ToUnicode).
 774  * @IDNA_ROUNDTRIP_VERIFY_ERROR: The ToASCII operation on output
 775  *   string does not equal the input.
 776  * @IDNA_CONTAINS_ACE_PREFIX: The input contains the ACE prefix (for
 777  *   ToASCII).
 778  * @IDNA_ICONV_ERROR: Could not convert string in locale encoding.
 779  * @IDNA_MALLOC_ERROR: Could not allocate buffer (this is typically a
 780  *   fatal error).
 781  *
 782  * Enumerated return codes of idna_to_ascii_4i(),
 783  * idna_to_unicode_44i() functions (and functions derived from those
 784  * functions).  The value 0 is guaranteed to always correspond to
 785  * success.
 786  */
 787
 788
 789 /**
 790  * Idna_flags:
 791  * @IDNA_ALLOW_UNASSIGNED: Don't reject strings containing unassigned
 792  *   Unicode code points.
 793  * @IDNA_USE_STD3_ASCII_RULES: Validate strings according to STD3
 794  *   rules (i.e., normal host name rules).
 795  *
 796  * Flags to pass to idna_to_ascii_4i(), idna_to_unicode_44i() etc.
 797  */