Coverage Report

Created: 2025-01-28 06:58

/src/libidn2/lib/lookup.c
Line
Count
Source (jump to first uncovered line)
1
/* lookup.c - implementation of IDNA2008 lookup functions
2
   Copyright (C) 2011-2024 Simon Josefsson
3
   Copyright (C) 2017-2024 Tim Ruehsen
4
5
   Libidn2 is free software: you can redistribute it and/or modify it
6
   under the terms of either:
7
8
     * the GNU Lesser General Public License as published by the Free
9
       Software Foundation; either version 3 of the License, or (at
10
       your option) any later version.
11
12
   or
13
14
     * the GNU General Public License as published by the Free
15
       Software Foundation; either version 2 of the License, or (at
16
       your option) any later version.
17
18
   or both in parallel, as here.
19
20
   This program is distributed in the hope that it will be useful,
21
   but WITHOUT ANY WARRANTY; without even the implied warranty of
22
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23
   GNU General Public License for more details.
24
25
   You should have received copies of the GNU General Public License and
26
   the GNU Lesser General Public License along with this program.  If
27
   not, see <http://www.gnu.org/licenses/>.
28
*/
29
30
#include <config.h>
31
32
#include "idn2.h"
33
34
#include <errno.h>    /* errno */
35
#include <stdlib.h>   /* malloc, free */
36
37
#include <unitypes.h>
38
#include <uniconv.h>    /* u8_strconv_from_locale */
39
#include <uninorm.h>    /* u32_normalize */
40
#include <unistr.h>   /* u8_to_u32 */
41
42
#include "idna.h"   /* _idn2_label_test */
43
#include "tr46map.h"    /* definition for tr46map.c */
44
45
#ifdef HAVE_LIBUNISTRING
46
/* copied from gnulib */
47
# include <limits.h>
48
# define _C_CTYPE_LOWER_N(N) \
49
0
   case 'a' + (N): case 'b' + (N): case 'c' + (N): case 'd' + (N): \
50
0
   case 'e' + (N): case 'f' + (N): \
51
0
   case 'g' + (N): case 'h' + (N): case 'i' + (N): case 'j' + (N): \
52
0
   case 'k' + (N): case 'l' + (N): case 'm' + (N): case 'n' + (N): \
53
0
   case 'o' + (N): case 'p' + (N): case 'q' + (N): case 'r' + (N): \
54
0
   case 's' + (N): case 't' + (N): case 'u' + (N): case 'v' + (N): \
55
0
   case 'w' + (N): case 'x' + (N): case 'y' + (N): case 'z' + (N)
56
0
# define _C_CTYPE_UPPER _C_CTYPE_LOWER_N ('A' - 'a')
57
static inline int
58
c_tolower (int c)
59
117k
{
60
117k
  switch (c)
61
117k
    {
62
0
    _C_CTYPE_UPPER:
63
0
      return c - 'A' + 'a';
64
117k
    default:
65
117k
      return c;
66
117k
    }
67
117k
}
68
69
static int
70
c_strncasecmp (const char *s1, const char *s2, size_t n)
71
4.65k
{
72
4.65k
  register const unsigned char *p1 = (const unsigned char *) s1;
73
4.65k
  register const unsigned char *p2 = (const unsigned char *) s2;
74
4.65k
  unsigned char c1, c2;
75
76
4.65k
  if (p1 == p2 || n == 0)
77
0
    return 0;
78
79
4.65k
  do
80
58.8k
    {
81
58.8k
      c1 = c_tolower (*p1);
82
58.8k
      c2 = c_tolower (*p2);
83
84
58.8k
      if (--n == 0 || c1 == '\0')
85
4.65k
  break;
86
87
54.1k
      ++p1;
88
54.1k
      ++p2;
89
54.1k
    }
90
54.1k
  while (c1 == c2);
91
92
4.65k
  if (UCHAR_MAX <= INT_MAX)
93
4.65k
    return c1 - c2;
94
0
  else
95
    /* On machines where 'char' and 'int' are types of the same size, the
96
       difference of two 'unsigned char' values - including the sign bit -
97
       doesn't fit in an 'int'.  */
98
0
    return (c1 > c2 ? 1 : c1 < c2 ? -1 : 0);
99
4.65k
}
100
#else
101
# include <c-strcase.h>
102
#endif
103
104
static int
105
set_default_flags (int *flags)
106
41.1k
{
107
41.1k
  if (((*flags) & IDN2_TRANSITIONAL) && ((*flags) & IDN2_NONTRANSITIONAL))
108
0
    return IDN2_INVALID_FLAGS;
109
110
41.1k
  if (((*flags) & (IDN2_TRANSITIONAL | IDN2_NONTRANSITIONAL))
111
41.1k
      && ((*flags) & IDN2_NO_TR46))
112
0
    return IDN2_INVALID_FLAGS;
113
114
41.1k
  if (((*flags) & IDN2_ALABEL_ROUNDTRIP)
115
41.1k
      && ((*flags) & IDN2_NO_ALABEL_ROUNDTRIP))
116
0
    return IDN2_INVALID_FLAGS;
117
118
41.1k
  if (!((*flags) & (IDN2_NO_TR46 | IDN2_TRANSITIONAL)))
119
21.3k
    *flags |= IDN2_NONTRANSITIONAL;
120
121
41.1k
  return IDN2_OK;
122
41.1k
}
123
124
static int
125
label (const uint8_t *src, size_t srclen, uint8_t *dst, size_t *dstlen,
126
       int flags)
127
25.3k
{
128
25.3k
  size_t plen;
129
25.3k
  uint32_t *p = NULL;
130
25.3k
  const uint8_t *src_org = NULL;
131
25.3k
  uint8_t *src_allocated = NULL;
132
25.3k
  int rc, check_roundtrip = 0;
133
25.3k
  size_t tmpl, srclen_org = 0;
134
25.3k
  uint32_t label_u32[IDN2_LABEL_MAX_LENGTH];
135
25.3k
  size_t label32_len = IDN2_LABEL_MAX_LENGTH;
136
137
25.3k
  if (_idn2_ascii_p (src, srclen))
138
9.41k
    {
139
9.41k
      if (!(flags & IDN2_NO_ALABEL_ROUNDTRIP) && srclen >= 4
140
9.41k
    && memcmp (src, "xn--", 4) == 0)
141
7.59k
  {
142
    /*
143
       If the input to this procedure appears to be an A-label
144
       (i.e., it starts in "xn--", interpreted
145
       case-insensitively), the lookup application MAY attempt to
146
       convert it to a U-label, first ensuring that the A-label is
147
       entirely in lowercase (converting it to lowercase if
148
       necessary), and apply the tests of Section 5.4 and the
149
       conversion of Section 5.5 to that form. */
150
7.59k
    rc = idn2_punycode_decode ((char *) src + 4, srclen - 4,
151
7.59k
             label_u32, &label32_len);
152
7.59k
    if (rc)
153
0
      return rc;
154
155
7.59k
    check_roundtrip = 1;
156
7.59k
    src_org = src;
157
7.59k
    srclen_org = srclen;
158
159
7.59k
    srclen = IDN2_LABEL_MAX_LENGTH;
160
7.59k
    src = src_allocated =
161
7.59k
      u32_to_u8 (label_u32, label32_len, NULL, &srclen);
162
7.59k
    if (!src)
163
0
      {
164
0
        if (errno == ENOMEM)
165
0
    return IDN2_MALLOC;
166
0
        return IDN2_ENCODING_ERROR;
167
0
      }
168
7.59k
  }
169
1.82k
      else
170
1.82k
  {
171
1.82k
    if (srclen > IDN2_LABEL_MAX_LENGTH)
172
410
      return IDN2_TOO_BIG_LABEL;
173
1.41k
    if (srclen > *dstlen)
174
0
      return IDN2_TOO_BIG_DOMAIN;
175
176
1.41k
    memcpy (dst, src, srclen);
177
1.41k
    *dstlen = srclen;
178
1.41k
    return IDN2_OK;
179
1.41k
  }
180
9.41k
    }
181
182
23.5k
  rc = _idn2_u8_to_u32_nfc (src, srclen, &p, &plen, flags & IDN2_NFC_INPUT);
183
23.5k
  if (rc != IDN2_OK)
184
0
    goto out;
185
186
23.5k
  if (!(flags & IDN2_TRANSITIONAL))
187
10.7k
    {
188
10.7k
      rc = _idn2_label_test (TEST_NFC |
189
10.7k
           TEST_2HYPHEN |
190
10.7k
           TEST_LEADING_COMBINING |
191
10.7k
           TEST_DISALLOWED |
192
10.7k
           TEST_CONTEXTJ_RULE |
193
10.7k
           TEST_CONTEXTO_WITH_RULE |
194
10.7k
           TEST_UNASSIGNED | TEST_BIDI |
195
10.7k
           ((flags & IDN2_NONTRANSITIONAL) ?
196
10.7k
            TEST_NONTRANSITIONAL : 0) | ((flags &
197
10.7k
                  IDN2_USE_STD3_ASCII_RULES)
198
10.7k
                 ? 0 :
199
10.7k
                 TEST_ALLOW_STD3_DISALLOWED),
200
10.7k
           p, plen);
201
202
10.7k
      if (rc != IDN2_OK)
203
4.70k
  goto out;
204
10.7k
    }
205
206
18.8k
  dst[0] = 'x';
207
18.8k
  dst[1] = 'n';
208
18.8k
  dst[2] = '-';
209
18.8k
  dst[3] = '-';
210
211
18.8k
  tmpl = *dstlen - 4;
212
18.8k
  rc = idn2_punycode_encode (p, plen, (char *) dst + 4, &tmpl);
213
18.8k
  if (rc != IDN2_OK)
214
836
    goto out;
215
216
217
17.9k
  *dstlen = 4 + tmpl;
218
219
17.9k
  if (check_roundtrip)
220
4.65k
    {
221
4.65k
      if (srclen_org != *dstlen
222
4.65k
    || c_strncasecmp ((char *) src_org, (char *) dst, srclen_org))
223
0
  {
224
0
    rc = IDN2_ALABEL_ROUNDTRIP_FAILED;
225
0
    goto out;
226
0
  }
227
4.65k
    }
228
13.3k
  else if (!(flags & IDN2_NO_ALABEL_ROUNDTRIP))
229
13.3k
    {
230
13.3k
      rc = idn2_punycode_decode ((char *) dst + 4, *dstlen - 4,
231
13.3k
         label_u32, &label32_len);
232
13.3k
      if (rc)
233
0
  {
234
0
    rc = IDN2_ALABEL_ROUNDTRIP_FAILED;
235
0
    goto out;
236
0
  }
237
238
13.3k
      if (plen != label32_len || u32_cmp (p, label_u32, label32_len))
239
0
  {
240
0
    rc = IDN2_ALABEL_ROUNDTRIP_FAILED;
241
0
    goto out;
242
0
  }
243
13.3k
    }
244
245
17.9k
  rc = IDN2_OK;
246
247
23.5k
out:
248
23.5k
  free (p);
249
23.5k
  free (src_allocated);
250
23.5k
  return rc;
251
17.9k
}
252
253
#define TR46_TRANSITIONAL_CHECK \
254
11.1k
  (TEST_NFC | TEST_2HYPHEN | TEST_HYPHEN_STARTEND | TEST_LEADING_COMBINING | TEST_TRANSITIONAL)
255
#define TR46_NONTRANSITIONAL_CHECK \
256
45.8k
  (TEST_NFC | TEST_2HYPHEN | TEST_HYPHEN_STARTEND | TEST_LEADING_COMBINING | TEST_NONTRANSITIONAL)
257
258
static int
259
_tr46 (const uint8_t *domain_u8, uint8_t **out, int flags)
260
41.1k
{
261
41.1k
  size_t len, it;
262
41.1k
  uint32_t *domain_u32;
263
41.1k
  int err = IDN2_OK, rc;
264
41.1k
  int transitional = 0;
265
41.1k
  int test_flags;
266
267
41.1k
  if (flags & IDN2_TRANSITIONAL)
268
19.8k
    transitional = 1;
269
270
  /* convert UTF-8 to UTF-32 */
271
41.1k
  if (!(domain_u32 =
272
41.1k
  u8_to_u32 (domain_u8, u8_strlen (domain_u8) + 1, NULL, &len)))
273
0
    {
274
0
      if (errno == ENOMEM)
275
0
  return IDN2_MALLOC;
276
0
      return IDN2_ENCODING_ERROR;
277
0
    }
278
279
41.1k
  size_t len2 = 0;
280
506k
  for (it = 0; it < len - 1; it++)
281
486k
    {
282
486k
      IDNAMap map;
283
284
486k
      get_idna_map (domain_u32[it], &map);
285
286
486k
      if (map_is (&map, TR46_FLG_DISALLOWED))
287
21.1k
  {
288
21.1k
    if (domain_u32[it])
289
21.1k
      {
290
21.1k
        free (domain_u32);
291
21.1k
        return IDN2_DISALLOWED;
292
21.1k
      }
293
0
    len2++;
294
0
  }
295
465k
      else if (map_is (&map, TR46_FLG_MAPPED))
296
133k
  {
297
133k
    len2 += map.nmappings;
298
133k
  }
299
331k
      else if (map_is (&map, TR46_FLG_VALID))
300
285k
  {
301
285k
    len2++;
302
285k
  }
303
46.2k
      else if (map_is (&map, TR46_FLG_IGNORED))
304
2.03k
  {
305
2.03k
    continue;
306
2.03k
  }
307
44.2k
      else if (map_is (&map, TR46_FLG_DEVIATION))
308
21.4k
  {
309
21.4k
    if (transitional)
310
10.6k
      {
311
10.6k
        len2 += map.nmappings;
312
10.6k
      }
313
10.7k
    else
314
10.7k
      len2++;
315
21.4k
  }
316
22.7k
      else if (!(flags & IDN2_USE_STD3_ASCII_RULES))
317
0
  {
318
0
    if (map_is (&map, TR46_FLG_DISALLOWED_STD3_VALID))
319
0
      {
320
        /* valid because UseSTD3ASCIIRules=false, see #TR46 5 */
321
0
        len2++;
322
0
      }
323
0
    else if (map_is (&map, TR46_FLG_DISALLOWED_STD3_MAPPED))
324
0
      {
325
        /* mapped because UseSTD3ASCIIRules=false, see #TR46 5 */
326
0
        len2 += map.nmappings;
327
0
      }
328
0
  }
329
486k
    }
330
331
  /* Exit early if result is too long.
332
   * This avoids excessive CPU usage in punycode encoding, which is O(N^2). */
333
20.0k
  if (len2 >= IDN2_DOMAIN_MAX_LENGTH)
334
245
    {
335
245
      free (domain_u32);
336
245
      return IDN2_TOO_BIG_DOMAIN;
337
245
    }
338
339
19.8k
  uint32_t *tmp = (uint32_t *) malloc ((len2 + 1) * sizeof (uint32_t));
340
19.8k
  if (!tmp)
341
0
    {
342
0
      free (domain_u32);
343
0
      return IDN2_MALLOC;
344
0
    }
345
346
19.8k
  len2 = 0;
347
375k
  for (it = 0; it < len - 1; it++)
348
355k
    {
349
355k
      uint32_t c = domain_u32[it];
350
355k
      IDNAMap map;
351
352
355k
      get_idna_map (c, &map);
353
354
355k
      if (map_is (&map, TR46_FLG_DISALLOWED))
355
0
  {
356
0
    tmp[len2++] = c;
357
0
  }
358
355k
      else if (map_is (&map, TR46_FLG_MAPPED))
359
80.5k
  {
360
80.5k
    len2 += get_map_data (tmp + len2, &map);
361
80.5k
  }
362
274k
      else if (map_is (&map, TR46_FLG_VALID))
363
231k
  {
364
231k
    tmp[len2++] = c;
365
231k
  }
366
42.8k
      else if (map_is (&map, TR46_FLG_IGNORED))
367
1.66k
  {
368
1.66k
    continue;
369
1.66k
  }
370
41.1k
      else if (map_is (&map, TR46_FLG_DEVIATION))
371
19.6k
  {
372
19.6k
    if (transitional)
373
9.70k
      {
374
9.70k
        len2 += get_map_data (tmp + len2, &map);
375
9.70k
      }
376
9.93k
    else
377
9.93k
      tmp[len2++] = c;
378
19.6k
  }
379
21.5k
      else if (!(flags & IDN2_USE_STD3_ASCII_RULES))
380
0
  {
381
0
    if (map_is (&map, TR46_FLG_DISALLOWED_STD3_VALID))
382
0
      {
383
0
        tmp[len2++] = c;
384
0
      }
385
0
    else if (map_is (&map, TR46_FLG_DISALLOWED_STD3_MAPPED))
386
0
      {
387
0
        len2 += get_map_data (tmp + len2, &map);
388
0
      }
389
0
  }
390
355k
    }
391
19.8k
  free (domain_u32);
392
393
  /* Normalize to NFC */
394
19.8k
  tmp[len2] = 0;
395
19.8k
  domain_u32 = u32_normalize (UNINORM_NFC, tmp, len2 + 1, NULL, &len);
396
19.8k
  free (tmp);
397
19.8k
  tmp = NULL;
398
399
19.8k
  if (!domain_u32)
400
0
    {
401
0
      if (errno == ENOMEM)
402
0
  return IDN2_MALLOC;
403
0
      return IDN2_ENCODING_ERROR;
404
0
    }
405
406
  /* split into labels and check */
407
19.8k
  uint32_t *e, *s;
408
53.7k
  for (e = s = domain_u32; *e; s = e)
409
37.7k
    {
410
410k
      while (*e && *e != '.')
411
373k
  e++;
412
413
37.7k
      if (e - s >= 4 && s[0] == 'x' && s[1] == 'n' && s[2] == '-'
414
37.7k
    && s[3] == '-')
415
14.7k
  {
416
    /* decode punycode and check result non-transitional */
417
14.7k
    size_t ace_len;
418
14.7k
    uint32_t name_u32[IDN2_LABEL_MAX_LENGTH];
419
14.7k
    size_t name_len = IDN2_LABEL_MAX_LENGTH;
420
14.7k
    uint8_t *ace;
421
422
14.7k
    ace = u32_to_u8 (s + 4, e - s - 4, NULL, &ace_len);
423
14.7k
    if (!ace)
424
0
      {
425
0
        free (domain_u32);
426
0
        if (errno == ENOMEM)
427
0
    return IDN2_MALLOC;
428
0
        return IDN2_ENCODING_ERROR;
429
0
      }
430
431
14.7k
    rc = idn2_punycode_decode ((char *) ace, ace_len,
432
14.7k
             name_u32, &name_len);
433
434
14.7k
    free (ace);
435
436
14.7k
    if (rc)
437
3.84k
      {
438
3.84k
        free (domain_u32);
439
3.84k
        return rc;
440
3.84k
      }
441
442
10.8k
    test_flags = TR46_NONTRANSITIONAL_CHECK;
443
444
10.8k
    if (!(flags & IDN2_USE_STD3_ASCII_RULES))
445
0
      test_flags |= TEST_ALLOW_STD3_DISALLOWED;
446
447
10.8k
    if ((rc = _idn2_label_test (test_flags, name_u32, name_len)))
448
3.23k
      err = rc;
449
10.8k
  }
450
23.0k
      else
451
23.0k
  {
452
23.0k
    test_flags =
453
23.0k
      transitional ? TR46_TRANSITIONAL_CHECK :
454
23.0k
      TR46_NONTRANSITIONAL_CHECK;
455
456
23.0k
    if (!(flags & IDN2_USE_STD3_ASCII_RULES))
457
0
      test_flags |= TEST_ALLOW_STD3_DISALLOWED;
458
459
23.0k
    if ((rc = _idn2_label_test (test_flags, s, e - s)))
460
1.52k
      err = rc;
461
23.0k
  }
462
463
33.9k
      if (*e)
464
18.1k
  e++;
465
33.9k
    }
466
467
15.9k
  if (err == IDN2_OK && out)
468
12.0k
    {
469
12.0k
      uint8_t *_out = u32_to_u8 (domain_u32, len, NULL, &len);
470
12.0k
      free (domain_u32);
471
472
12.0k
      if (!_out)
473
0
  {
474
0
    if (errno == ENOMEM)
475
0
      return IDN2_MALLOC;
476
0
    return IDN2_ENCODING_ERROR;
477
0
  }
478
479
12.0k
      *out = _out;
480
12.0k
    }
481
3.98k
  else
482
3.98k
    free (domain_u32);
483
484
15.9k
  return err;
485
15.9k
}
486
487
/**
488
 * idn2_lookup_u8:
489
 * @src: input zero-terminated UTF-8 string in Unicode NFC normalized form.
490
 * @lookupname: newly allocated output variable with name to lookup in DNS.
491
 * @flags: optional #idn2_flags to modify behaviour.
492
 *
493
 * Perform IDNA2008 lookup string conversion on domain name @src, as
494
 * described in section 5 of RFC 5891.  Note that the input string
495
 * must be encoded in UTF-8 and be in Unicode NFC form.
496
 *
497
 * Pass %IDN2_NFC_INPUT in @flags to convert input to NFC form before
498
 * further processing.  %IDN2_TRANSITIONAL and %IDN2_NONTRANSITIONAL
499
 * do already imply %IDN2_NFC_INPUT.
500
 *
501
 * Pass %IDN2_ALABEL_ROUNDTRIP in @flags to
502
 * convert any input A-labels to U-labels and perform additional
503
 * testing. This is default since version 2.2.
504
 * To switch this behavior off, pass IDN2_NO_ALABEL_ROUNDTRIP
505
 *
506
 * Pass %IDN2_TRANSITIONAL to enable Unicode TR46
507
 * transitional processing, and %IDN2_NONTRANSITIONAL to enable
508
 * Unicode TR46 non-transitional processing.
509
 *
510
 * Multiple flags may be specified by binary or:ing them together.
511
 *
512
 * After version 2.0.3: %IDN2_USE_STD3_ASCII_RULES disabled by default.
513
 * Previously we were eliminating non-STD3 characters from domain strings
514
 * such as _443._tcp.example.com, or IPs 1.2.3.4/24 provided to libidn2
515
 * functions. That was an unexpected regression for applications switching
516
 * from libidn and thus it is no longer applied by default.
517
 * Use %IDN2_USE_STD3_ASCII_RULES to enable that behavior again.
518
 *
519
 * After version 0.11: @lookupname may be NULL to test lookup of @src
520
 * without allocating memory.
521
 *
522
 * Returns: On successful conversion %IDN2_OK is returned, if the
523
 *   output domain or any label would have been too long
524
 *   %IDN2_TOO_BIG_DOMAIN or %IDN2_TOO_BIG_LABEL is returned, or
525
 *   another error code is returned.
526
 *
527
 * Since: 0.1
528
 **/
529
int
530
idn2_lookup_u8 (const uint8_t *src, uint8_t **lookupname, int flags)
531
41.1k
{
532
41.1k
  size_t lookupnamelen = 0;
533
41.1k
  uint8_t _lookupname[IDN2_DOMAIN_MAX_LENGTH + 1];
534
41.1k
  uint8_t *src_allocated = NULL;
535
41.1k
  int rc;
536
537
41.1k
  if (src == NULL)
538
0
    {
539
0
      if (lookupname)
540
0
  *lookupname = NULL;
541
0
      return IDN2_OK;
542
0
    }
543
544
41.1k
  rc = set_default_flags (&flags);
545
41.1k
  if (rc != IDN2_OK)
546
0
    return rc;
547
548
41.1k
  if (!(flags & IDN2_NO_TR46))
549
41.1k
    {
550
41.1k
      uint8_t *out = NULL;
551
552
41.1k
      rc = _tr46 (src, &out, flags);
553
41.1k
      if (rc != IDN2_OK)
554
29.1k
  return rc;
555
556
12.0k
      src = src_allocated = out;
557
12.0k
    }
558
559
12.0k
  do
560
25.3k
    {
561
25.3k
      const uint8_t *end = (uint8_t *) strchrnul ((const char *) src, '.');
562
      /* XXX Do we care about non-U+002E dots such as U+3002, U+FF0E
563
         and U+FF61 here?  Perhaps when IDN2_NFC_INPUT? */
564
25.3k
      size_t labellen = end - src;
565
25.3k
      uint8_t tmp[IDN2_LABEL_MAX_LENGTH];
566
25.3k
      size_t tmplen = IDN2_LABEL_MAX_LENGTH;
567
568
25.3k
      rc = label (src, labellen, tmp, &tmplen, flags);
569
25.3k
      if (rc != IDN2_OK)
570
5.95k
  {
571
5.95k
    free (src_allocated);
572
5.95k
    return rc;
573
5.95k
  }
574
575
19.4k
      if (lookupnamelen + tmplen
576
19.4k
    > IDN2_DOMAIN_MAX_LENGTH - (tmplen == 0 && *end == '\0' ? 1 : 2))
577
419
  {
578
419
    free (src_allocated);
579
419
    return IDN2_TOO_BIG_DOMAIN;
580
419
  }
581
582
18.9k
      memcpy (_lookupname + lookupnamelen, tmp, tmplen);
583
18.9k
      lookupnamelen += tmplen;
584
585
18.9k
      if (*end == '.')
586
13.3k
  {
587
13.3k
    if (lookupnamelen + 1 > IDN2_DOMAIN_MAX_LENGTH)
588
0
      {
589
0
        free (src_allocated);
590
0
        return IDN2_TOO_BIG_DOMAIN;
591
0
      }
592
593
13.3k
    _lookupname[lookupnamelen] = '.';
594
13.3k
    lookupnamelen++;
595
13.3k
  }
596
18.9k
      _lookupname[lookupnamelen] = '\0';
597
598
18.9k
      src = end;
599
18.9k
    }
600
18.9k
  while (*src++);
601
602
5.64k
  free (src_allocated);
603
604
5.64k
  if (lookupname)
605
5.64k
    {
606
5.64k
      uint8_t *tmp = (uint8_t *) malloc (lookupnamelen + 1);
607
608
5.64k
      if (tmp == NULL)
609
0
  return IDN2_MALLOC;
610
611
5.64k
      memcpy (tmp, _lookupname, lookupnamelen + 1);
612
5.64k
      *lookupname = tmp;
613
5.64k
    }
614
615
5.64k
  return IDN2_OK;
616
5.64k
}
617
618
/**
619
 * idn2_lookup_ul:
620
 * @src: input zero-terminated locale encoded string.
621
 * @lookupname: newly allocated output variable with name to lookup in DNS.
622
 * @flags: optional #idn2_flags to modify behaviour.
623
 *
624
 * Perform IDNA2008 lookup string conversion on domain name @src, as
625
 * described in section 5 of RFC 5891.  Note that the input is assumed
626
 * to be encoded in the locale's default coding system, and will be
627
 * transcoded to UTF-8 and NFC normalized by this function.
628
 *
629
 * Pass %IDN2_ALABEL_ROUNDTRIP in @flags to
630
 * convert any input A-labels to U-labels and perform additional
631
 * testing. This is default since version 2.2.
632
 * To switch this behavior off, pass IDN2_NO_ALABEL_ROUNDTRIP
633
 *
634
 * Pass %IDN2_TRANSITIONAL to enable Unicode TR46 transitional processing,
635
 * and %IDN2_NONTRANSITIONAL to enable Unicode TR46 non-transitional
636
 * processing.
637
 *
638
 * Multiple flags may be specified by binary or:ing them together, for
639
 * example %IDN2_ALABEL_ROUNDTRIP | %IDN2_NONTRANSITIONAL.
640
 *
641
 * The %IDN2_NFC_INPUT in @flags is always enabled in this function.
642
 *
643
 * After version 0.11: @lookupname may be NULL to test lookup of @src
644
 * without allocating memory.
645
 *
646
 * Returns: On successful conversion %IDN2_OK is returned, if
647
 *   conversion from locale to UTF-8 fails then %IDN2_ICONV_FAIL is
648
 *   returned, if the output domain or any label would have been too
649
 *   long %IDN2_TOO_BIG_DOMAIN or %IDN2_TOO_BIG_LABEL is returned, or
650
 *   another error code is returned.
651
 *
652
 * Since: 0.1
653
 **/
654
int
655
idn2_lookup_ul (const char *src, char **lookupname, int flags)
656
0
{
657
0
  uint8_t *utf8src = NULL;
658
0
  int rc;
659
660
0
  if (src)
661
0
    {
662
0
      const char *encoding = locale_charset ();
663
664
0
      utf8src = u8_strconv_from_encoding (src, encoding, iconveh_error);
665
666
0
      if (!utf8src)
667
0
  {
668
0
    if (errno == ENOMEM)
669
0
      return IDN2_MALLOC;
670
0
    return IDN2_ICONV_FAIL;
671
0
  }
672
0
    }
673
674
0
  rc = idn2_lookup_u8 (utf8src, (uint8_t **) lookupname,
675
0
           flags | IDN2_NFC_INPUT);
676
677
0
  free (utf8src);
678
679
0
  return rc;
680
0
}
681
682
/**
683
 * idn2_to_ascii_4i:
684
 * @input: zero terminated input Unicode (UCS-4) string.
685
 * @inlen: number of elements in @input.
686
 * @output: output zero terminated string that must have room for at
687
 *       least 63 characters plus the terminating zero.
688
 * @flags: optional #idn2_flags to modify behaviour.
689
 *
690
 * The ToASCII operation takes a sequence of Unicode code points that make
691
 * up one domain label and transforms it into a sequence of code points in
692
 * the ASCII range (0..7F). If ToASCII succeeds, the original sequence and
693
 * the resulting sequence are equivalent labels.
694
 *
695
 * It is important to note that the ToASCII operation can fail.
696
 * ToASCII fails if any step of it fails. If any step of the
697
 * ToASCII operation fails on any label in a domain name, that domain
698
 * name MUST NOT be used as an internationalized domain name.
699
 * The method for dealing with this failure is application-specific.
700
 *
701
 * The inputs to ToASCII are a sequence of code points.
702
 *
703
 * ToASCII never alters a sequence of code points that are all in the ASCII
704
 * range to begin with (although it could fail). Applying the ToASCII operation multiple
705
 * effect as applying it just once.
706
 *
707
 * The default behavior of this function (when flags are zero) is to apply
708
 * the IDNA2008 rules without the TR46 amendments. As the TR46
709
 * non-transitional processing is nowadays ubiquitous, when unsure, it is
710
 * recommended to call this function with the %IDN2_NONTRANSITIONAL
711
 * and the %IDN2_NFC_INPUT flags for compatibility with other software.
712
 *
713
 * Warning: With version 2.1.1 until before version 2.3.5 this
714
 * function was deprecated in favor idn2_to_ascii_4i2().  We still
715
 * encourage you to use idn2_to_ascii_4i2() when appropriate.
716
 *
717
 * Returns: On successful conversion %IDN2_OK is returned; if the
718
 *   output label would have been too long %IDN2_TOO_BIG_LABEL is
719
 *   returned, or another error code is returned.
720
 *
721
 * Since: 2.0.0
722
 **/
723
int
724
idn2_to_ascii_4i (const uint32_t *input, size_t inlen, char *output,
725
      int flags)
726
0
{
727
0
  char *out;
728
0
  int rc;
729
730
0
  if (!input)
731
0
    {
732
0
      if (output)
733
0
  *output = 0;
734
0
      return IDN2_OK;
735
0
    }
736
737
0
  rc = idn2_to_ascii_4i2 (input, inlen, &out, flags);
738
0
  if (rc == IDN2_OK)
739
0
    {
740
0
      size_t len = strlen (out);
741
742
0
      if (len > IDN2_LABEL_MAX_LENGTH)
743
0
  rc = IDN2_TOO_BIG_LABEL;
744
0
      else if (output)
745
0
  strcpy (output, out);
746
747
0
      free (out);
748
0
    }
749
750
0
  return rc;
751
0
}
752
753
/**
754
 * idn2_to_ascii_4i2:
755
 * @input: zero terminated input Unicode (UCS-4) string.
756
 * @inlen: number of elements in @input.
757
 * @output: pointer to newly allocated zero-terminated output string.
758
 * @flags: optional #idn2_flags to modify behaviour.
759
 *
760
 * The ToASCII operation takes a sequence of Unicode code points that make
761
 * up one domain label and transforms it into a sequence of code points in
762
 * the ASCII range (0..7F). If ToASCII succeeds, the original sequence and
763
 * the resulting sequence are equivalent labels.
764
 *
765
 * It is important to note that the ToASCII operation can fail.
766
 * ToASCII fails if any step of it fails. If any step of the
767
 * ToASCII operation fails on any label in a domain name, that domain
768
 * name MUST NOT be used as an internationalized domain name.
769
 * The method for dealing with this failure is application-specific.
770
 *
771
 * The inputs to ToASCII are a sequence of code points.
772
 *
773
 * ToASCII never alters a sequence of code points that are all in the ASCII
774
 * range to begin with (although it could fail). Applying the ToASCII operation multiple
775
 * effect as applying it just once.
776
 *
777
 * The default behavior of this function (when flags are zero) is to apply
778
 * the IDNA2008 rules without the TR46 amendments. As the TR46
779
 * non-transitional processing is nowadays ubiquitous, when unsure, it is
780
 * recommended to call this function with the %IDN2_NONTRANSITIONAL
781
 * and the %IDN2_NFC_INPUT flags for compatibility with other software.
782
 *
783
 * Returns: On successful conversion %IDN2_OK is returned; if the
784
 *   output label would have been too long %IDN2_TOO_BIG_LABEL is
785
 *   returned, or another error code is returned.
786
 *
787
 * Since: 2.1.1
788
 **/
789
int
790
idn2_to_ascii_4i2 (const uint32_t *input, size_t inlen, char **output,
791
       int flags)
792
0
{
793
0
  uint32_t *input_u32;
794
0
  uint8_t *input_u8, *output_u8;
795
0
  size_t length;
796
0
  int rc;
797
798
0
  if (!input)
799
0
    {
800
0
      if (output)
801
0
  *output = NULL;
802
0
      return IDN2_OK;
803
0
    }
804
805
0
  input_u32 = (uint32_t *) malloc ((inlen + 1) * sizeof (uint32_t));
806
0
  if (!input_u32)
807
0
    return IDN2_MALLOC;
808
809
0
  u32_cpy (input_u32, input, inlen);
810
0
  input_u32[inlen] = 0;
811
812
0
  input_u8 = u32_to_u8 (input_u32, inlen + 1, NULL, &length);
813
0
  free (input_u32);
814
0
  if (!input_u8)
815
0
    {
816
0
      if (errno == ENOMEM)
817
0
  return IDN2_MALLOC;
818
0
      return IDN2_ENCODING_ERROR;
819
0
    }
820
821
0
  rc = idn2_lookup_u8 (input_u8, &output_u8, flags);
822
0
  free (input_u8);
823
824
0
  if (rc == IDN2_OK)
825
0
    {
826
0
      if (output)
827
0
  *output = (char *) output_u8;
828
0
      else
829
0
  free (output_u8);
830
0
    }
831
832
0
  return rc;
833
0
}
834
835
/**
836
 * idn2_to_ascii_4z:
837
 * @input: zero terminated input Unicode (UCS-4) string.
838
 * @output: pointer to newly allocated zero-terminated output string.
839
 * @flags: optional #idn2_flags to modify behaviour.
840
 *
841
 * Convert UCS-4 domain name to ASCII string using the IDNA2008
842
 * rules.  The domain name may contain several labels, separated by dots.
843
 * The output buffer must be deallocated by the caller.
844
 *
845
 * The default behavior of this function (when flags are zero) is to apply
846
 * the IDNA2008 rules without the TR46 amendments. As the TR46
847
 * non-transitional processing is nowadays ubiquitous, when unsure, it is
848
 * recommended to call this function with the %IDN2_NONTRANSITIONAL
849
 * and the %IDN2_NFC_INPUT flags for compatibility with other software.
850
 *
851
 * Return value: Returns %IDN2_OK on success, or error code.
852
 *
853
 * Since: 2.0.0
854
 **/
855
int
856
idn2_to_ascii_4z (const uint32_t *input, char **output, int flags)
857
0
{
858
0
  uint8_t *input_u8;
859
0
  size_t length;
860
0
  int rc;
861
862
0
  if (!input)
863
0
    {
864
0
      if (output)
865
0
  *output = NULL;
866
0
      return IDN2_OK;
867
0
    }
868
869
0
  input_u8 = u32_to_u8 (input, u32_strlen (input) + 1, NULL, &length);
870
0
  if (!input_u8)
871
0
    {
872
0
      if (errno == ENOMEM)
873
0
  return IDN2_MALLOC;
874
0
      return IDN2_ENCODING_ERROR;
875
0
    }
876
877
0
  rc = idn2_lookup_u8 (input_u8, (uint8_t **) output, flags);
878
0
  free (input_u8);
879
880
0
  return rc;
881
0
}
882
883
/**
884
 * idn2_to_ascii_8z:
885
 * @input: zero terminated input UTF-8 string.
886
 * @output: pointer to newly allocated output string.
887
 * @flags: optional #idn2_flags to modify behaviour.
888
 *
889
 * Convert UTF-8 domain name to ASCII string using the IDNA2008
890
 * rules.  The domain name may contain several labels, separated by dots.
891
 * The output buffer must be deallocated by the caller.
892
 *
893
 * The default behavior of this function (when flags are zero) is to apply
894
 * the IDNA2008 rules without the TR46 amendments. As the TR46
895
 * non-transitional processing is nowadays ubiquitous, when unsure, it is
896
 * recommended to call this function with the %IDN2_NONTRANSITIONAL
897
 * and the %IDN2_NFC_INPUT flags for compatibility with other software.
898
 *
899
 * Return value: Returns %IDN2_OK on success, or error code.
900
 *
901
 * Since: 2.0.0
902
 **/
903
int
904
idn2_to_ascii_8z (const char *input, char **output, int flags)
905
0
{
906
0
  return idn2_lookup_u8 ((const uint8_t *) input, (uint8_t **) output, flags);
907
0
}
908
909
/**
910
 * idn2_to_ascii_lz:
911
 * @input: zero terminated input UTF-8 string.
912
 * @output: pointer to newly allocated output string.
913
 * @flags: optional #idn2_flags to modify behaviour.
914
 *
915
 * Convert a domain name in locale's encoding to ASCII string using the IDNA2008
916
 * rules.  The domain name may contain several labels, separated by dots.
917
 * The output buffer must be deallocated by the caller.
918
 *
919
 * The default behavior of this function (when flags are zero) is to apply
920
 * the IDNA2008 rules without the TR46 amendments. As the TR46
921
 * non-transitional processing is nowadays ubiquitous, when unsure, it is
922
 * recommended to call this function with the %IDN2_NONTRANSITIONAL
923
 * and the %IDN2_NFC_INPUT flags for compatibility with other software.
924
 *
925
 * Returns: %IDN2_OK on success, or error code.
926
 * Same as described in idn2_lookup_ul() documentation.
927
 *
928
 * Since: 2.0.0
929
 **/
930
int
931
idn2_to_ascii_lz (const char *input, char **output, int flags)
932
0
{
933
0
  return idn2_lookup_ul (input, output, flags);
934
0
}