LCOV - code coverage report
Current view: top level - lib - idna.c (source / functions) Hit Total Coverage
Test: GNU Libidn Lines: 185 247 74.9 %
Date: 2016-07-20 19:34:35 Functions: 8 11 72.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11