1 /* Copyright libuv contributors. All rights reserved. 2 * 3 * Permission to use, copy, modify, and/or distribute this software for any 4 * purpose with or without fee is hereby granted, provided that the above 5 * copyright notice and this permission notice appear in all copies. 6 * 7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 10 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 12 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 13 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 14 */ 15 16 /* Derived from https://github.com/bnoordhuis/punycode 17 * but updated to support IDNA 2008. 18 */ 19 20 #include "uv.h" 21 #include "uv-common.h" 22 #include "idna.h" 23 #include <assert.h> 24 #include <string.h> 25 #include <limits.h> /* UINT_MAX */ 26 27 28 static int32_t uv__wtf8_decode1(const char** input) { 29 uint32_t code_point; 30 uint8_t b1; 31 uint8_t b2; 32 uint8_t b3; 33 uint8_t b4; 34 35 b1 = **input; 36 if (b1 <= 0x7F) 37 return b1; /* ASCII code point */ 38 if (b1 < 0xC2) 39 return -1; /* invalid: continuation byte */ 40 code_point = b1; 41 42 b2 = *++*input; 43 if ((b2 & 0xC0) != 0x80) 44 return -1; /* invalid: not a continuation byte */ 45 code_point = (code_point << 6) | (b2 & 0x3F); 46 if (b1 <= 0xDF) 47 return 0x7FF & code_point; /* two-byte character */ 48 49 b3 = *++*input; 50 if ((b3 & 0xC0) != 0x80) 51 return -1; /* invalid: not a continuation byte */ 52 code_point = (code_point << 6) | (b3 & 0x3F); 53 if (b1 <= 0xEF) 54 return 0xFFFF & code_point; /* three-byte character */ 55 56 b4 = *++*input; 57 if ((b4 & 0xC0) != 0x80) 58 return -1; /* invalid: not a continuation byte */ 59 code_point = (code_point << 6) | (b4 & 0x3F); 60 if (b1 <= 0xF4) { 61 code_point &= 0x1FFFFF; 62 if (code_point <= 0x10FFFF) 63 return code_point; /* four-byte character */ 64 } 65 66 /* code point too large */ 67 return -1; 68 } 69 70 71 static unsigned uv__utf8_decode1_slow(const char** p, 72 const char* pe, 73 unsigned a) { 74 unsigned b; 75 unsigned c; 76 unsigned d; 77 unsigned min; 78 79 if (a > 0xF7) 80 return -1; 81 82 switch (pe - *p) { 83 default: 84 if (a > 0xEF) { 85 min = 0x10000; 86 a = a & 7; 87 b = (unsigned char) *(*p)++; 88 c = (unsigned char) *(*p)++; 89 d = (unsigned char) *(*p)++; 90 break; 91 } 92 /* Fall through. */ 93 case 2: 94 if (a > 0xDF) { 95 min = 0x800; 96 b = 0x80 | (a & 15); 97 c = (unsigned char) *(*p)++; 98 d = (unsigned char) *(*p)++; 99 a = 0; 100 break; 101 } 102 /* Fall through. */ 103 case 1: 104 if (a > 0xBF) { 105 min = 0x80; 106 b = 0x80; 107 c = 0x80 | (a & 31); 108 d = (unsigned char) *(*p)++; 109 a = 0; 110 break; 111 } 112 /* Fall through. */ 113 case 0: 114 return -1; /* Invalid continuation byte. */ 115 } 116 117 if (0x80 != (0xC0 & (b ^ c ^ d))) 118 return -1; /* Invalid sequence. */ 119 120 b &= 63; 121 c &= 63; 122 d &= 63; 123 a = (a << 18) | (b << 12) | (c << 6) | d; 124 125 if (a < min) 126 return -1; /* Overlong sequence. */ 127 128 if (a > 0x10FFFF) 129 return -1; /* Four-byte sequence > U+10FFFF. */ 130 131 if (a >= 0xD800 && a <= 0xDFFF) 132 return -1; /* Surrogate pair. */ 133 134 return a; 135 } 136 137 138 unsigned uv__utf8_decode1(const char** p, const char* pe) { 139 unsigned a; 140 141 assert(*p < pe); 142 143 a = (unsigned char) *(*p)++; 144 145 if (a < 128) 146 return a; /* ASCII, common case. */ 147 148 return uv__utf8_decode1_slow(p, pe, a); 149 } 150 151 152 static int uv__idna_toascii_label(const char* s, const char* se, 153 char** d, char* de) { 154 static const char alphabet[] = "abcdefghijklmnopqrstuvwxyz0123456789"; 155 const char* ss; 156 unsigned c; 157 unsigned h; 158 unsigned k; 159 unsigned n; 160 unsigned m; 161 unsigned q; 162 unsigned t; 163 unsigned x; 164 unsigned y; 165 unsigned bias; 166 unsigned delta; 167 unsigned todo; 168 int first; 169 170 h = 0; 171 ss = s; 172 todo = 0; 173 174 /* Note: after this loop we've visited all UTF-8 characters and know 175 * they're legal so we no longer need to check for decode errors. 176 */ 177 while (s < se) { 178 c = uv__utf8_decode1(&s, se); 179 180 if (c == UINT_MAX) 181 return UV_EINVAL; 182 183 if (c < 128) 184 h++; 185 else 186 todo++; 187 } 188 189 /* Only write "xn--" when there are non-ASCII characters. */ 190 if (todo > 0) { 191 if (*d < de) *(*d)++ = 'x'; 192 if (*d < de) *(*d)++ = 'n'; 193 if (*d < de) *(*d)++ = '-'; 194 if (*d < de) *(*d)++ = '-'; 195 } 196 197 /* Write ASCII characters. */ 198 x = 0; 199 s = ss; 200 while (s < se) { 201 c = uv__utf8_decode1(&s, se); 202 assert(c != UINT_MAX); 203 204 if (c > 127) 205 continue; 206 207 if (*d < de) 208 *(*d)++ = c; 209 210 if (++x == h) 211 break; /* Visited all ASCII characters. */ 212 } 213 214 if (todo == 0) 215 return h; 216 217 /* Only write separator when we've written ASCII characters first. */ 218 if (h > 0) 219 if (*d < de) 220 *(*d)++ = '-'; 221 222 n = 128; 223 bias = 72; 224 delta = 0; 225 first = 1; 226 227 while (todo > 0) { 228 m = -1; 229 s = ss; 230 231 while (s < se) { 232 c = uv__utf8_decode1(&s, se); 233 assert(c != UINT_MAX); 234 235 if (c >= n) 236 if (c < m) 237 m = c; 238 } 239 240 x = m - n; 241 y = h + 1; 242 243 if (x > ~delta / y) 244 return UV_E2BIG; /* Overflow. */ 245 246 delta += x * y; 247 n = m; 248 249 s = ss; 250 while (s < se) { 251 c = uv__utf8_decode1(&s, se); 252 assert(c != UINT_MAX); 253 254 if (c < n) 255 if (++delta == 0) 256 return UV_E2BIG; /* Overflow. */ 257 258 if (c != n) 259 continue; 260 261 for (k = 36, q = delta; /* empty */; k += 36) { 262 t = 1; 263 264 if (k > bias) 265 t = k - bias; 266 267 if (t > 26) 268 t = 26; 269 270 if (q < t) 271 break; 272 273 /* TODO(bnoordhuis) Since 1 <= t <= 26 and therefore 274 * 10 <= y <= 35, we can optimize the long division 275 * into a table-based reciprocal multiplication. 276 */ 277 x = q - t; 278 y = 36 - t; /* 10 <= y <= 35 since 1 <= t <= 26. */ 279 q = x / y; 280 t = t + x % y; /* 1 <= t <= 35 because of y. */ 281 282 if (*d < de) 283 *(*d)++ = alphabet[t]; 284 } 285 286 if (*d < de) 287 *(*d)++ = alphabet[q]; 288 289 delta /= 2; 290 291 if (first) { 292 delta /= 350; 293 first = 0; 294 } 295 296 /* No overflow check is needed because |delta| was just 297 * divided by 2 and |delta+delta >= delta + delta/h|. 298 */ 299 h++; 300 delta += delta / h; 301 302 for (bias = 0; delta > 35 * 26 / 2; bias += 36) 303 delta /= 35; 304 305 bias += 36 * delta / (delta + 38); 306 delta = 0; 307 todo--; 308 } 309 310 delta++; 311 n++; 312 } 313 314 return 0; 315 } 316 317 318 ssize_t uv__idna_toascii(const char* s, const char* se, char* d, char* de) { 319 const char* si; 320 const char* st; 321 unsigned c; 322 char* ds; 323 int rc; 324 325 if (s == se) 326 return UV_EINVAL; 327 328 ds = d; 329 330 si = s; 331 while (si < se) { 332 st = si; 333 c = uv__utf8_decode1(&si, se); 334 335 if (c == UINT_MAX) 336 return UV_EINVAL; 337 338 if (c != '.') 339 if (c != 0x3002) /* */ 340 if (c != 0xFF0E) /* */ 341 if (c != 0xFF61) /* */ 342 continue; 343 344 rc = uv__idna_toascii_label(s, st, &d, de); 345 346 if (rc < 0) 347 return rc; 348 349 if (d < de) 350 *d++ = '.'; 351 352 s = si; 353 } 354 355 if (s < se) { 356 rc = uv__idna_toascii_label(s, se, &d, de); 357 358 if (rc < 0) 359 return rc; 360 } 361 362 if (d >= de) 363 return UV_EINVAL; 364 365 *d++ = '\0'; 366 return d - ds; /* Number of bytes written. */ 367 } 368 369 370 ssize_t uv_wtf8_length_as_utf16(const char* source_ptr) { 371 size_t w_target_len = 0; 372 int32_t code_point; 373 374 do { 375 code_point = uv__wtf8_decode1(&source_ptr); 376 if (code_point < 0) 377 return -1; 378 if (code_point > 0xFFFF) 379 w_target_len++; 380 w_target_len++; 381 } while (*source_ptr++); 382 383 return w_target_len; 384 } 385 386 387 void uv_wtf8_to_utf16(const char* source_ptr, 388 uint16_t* w_target, 389 size_t w_target_len) { 390 int32_t code_point; 391 392 do { 393 code_point = uv__wtf8_decode1(&source_ptr); 394 /* uv_wtf8_length_as_utf16 should have been called and checked first. */ 395 assert(code_point >= 0); 396 if (code_point > 0xFFFF) { 397 assert(code_point < 0x10FFFF); 398 *w_target++ = (((code_point - 0x10000) >> 10) + 0xD800); 399 *w_target++ = ((code_point - 0x10000) & 0x3FF) + 0xDC00; 400 w_target_len -= 2; 401 } else { 402 *w_target++ = code_point; 403 w_target_len -= 1; 404 } 405 } while (*source_ptr++); 406 407 (void)w_target_len; 408 assert(w_target_len == 0); 409 } 410 411 412 static int32_t uv__get_surrogate_value(const uint16_t* w_source_ptr, 413 ssize_t w_source_len) { 414 uint16_t u; 415 uint16_t next; 416 417 u = w_source_ptr[0]; 418 if (u >= 0xD800 && u <= 0xDBFF && w_source_len != 1) { 419 next = w_source_ptr[1]; 420 if (next >= 0xDC00 && next <= 0xDFFF) 421 return 0x10000 + ((u - 0xD800) << 10) + (next - 0xDC00); 422 } 423 return u; 424 } 425 426 427 size_t uv_utf16_length_as_wtf8(const uint16_t* w_source_ptr, 428 ssize_t w_source_len) { 429 size_t target_len; 430 int32_t code_point; 431 432 target_len = 0; 433 while (w_source_len) { 434 code_point = uv__get_surrogate_value(w_source_ptr, w_source_len); 435 /* Can be invalid UTF-8 but must be valid WTF-8. */ 436 assert(code_point >= 0); 437 if (w_source_len < 0 && code_point == 0) 438 break; 439 if (code_point < 0x80) 440 target_len += 1; 441 else if (code_point < 0x800) 442 target_len += 2; 443 else if (code_point < 0x10000) 444 target_len += 3; 445 else { 446 target_len += 4; 447 w_source_ptr++; 448 if (w_source_len > 0) 449 w_source_len--; 450 } 451 w_source_ptr++; 452 if (w_source_len > 0) 453 w_source_len--; 454 } 455 456 return target_len; 457 } 458 459 460 int uv_utf16_to_wtf8(const uint16_t* w_source_ptr, 461 ssize_t w_source_len, 462 char** target_ptr, 463 size_t* target_len_ptr) { 464 size_t target_len; 465 char* target; 466 char* target_end; 467 int32_t code_point; 468 469 /* If *target_ptr is provided, then *target_len_ptr must be its length 470 * (excluding space for NUL), otherwise we will compute the target_len_ptr 471 * length and may return a new allocation in *target_ptr if target_ptr is 472 * provided. */ 473 if (target_ptr == NULL || *target_ptr == NULL) { 474 target_len = uv_utf16_length_as_wtf8(w_source_ptr, w_source_len); 475 if (target_len_ptr != NULL) 476 *target_len_ptr = target_len; 477 } else { 478 target_len = *target_len_ptr; 479 } 480 481 if (target_ptr == NULL) 482 return 0; 483 484 if (*target_ptr == NULL) { 485 target = uv__malloc(target_len + 1); 486 if (target == NULL) { 487 return UV_ENOMEM; 488 } 489 *target_ptr = target; 490 } else { 491 target = *target_ptr; 492 } 493 494 target_end = target + target_len; 495 496 while (target != target_end && w_source_len) { 497 code_point = uv__get_surrogate_value(w_source_ptr, w_source_len); 498 /* Can be invalid UTF-8 but must be valid WTF-8. */ 499 assert(code_point >= 0); 500 if (w_source_len < 0 && code_point == 0) { 501 w_source_len = 0; 502 break; 503 } 504 if (code_point < 0x80) { 505 *target++ = code_point; 506 } else if (code_point < 0x800) { 507 *target++ = 0xC0 | (code_point >> 6); 508 if (target == target_end) 509 break; 510 *target++ = 0x80 | (code_point & 0x3F); 511 } else if (code_point < 0x10000) { 512 *target++ = 0xE0 | (code_point >> 12); 513 if (target == target_end) 514 break; 515 *target++ = 0x80 | ((code_point >> 6) & 0x3F); 516 if (target == target_end) 517 break; 518 *target++ = 0x80 | (code_point & 0x3F); 519 } else { 520 *target++ = 0xF0 | (code_point >> 18); 521 if (target == target_end) 522 break; 523 *target++ = 0x80 | ((code_point >> 12) & 0x3F); 524 if (target == target_end) 525 break; 526 *target++ = 0x80 | ((code_point >> 6) & 0x3F); 527 if (target == target_end) 528 break; 529 *target++ = 0x80 | (code_point & 0x3F); 530 /* uv__get_surrogate_value consumed 2 input characters */ 531 w_source_ptr++; 532 if (w_source_len > 0) 533 w_source_len--; 534 } 535 target_len = target - *target_ptr; 536 w_source_ptr++; 537 if (w_source_len > 0) 538 w_source_len--; 539 } 540 541 if (target != target_end && target_len_ptr != NULL) 542 /* Did not fill all of the provided buffer, so update the target_len_ptr 543 * output with the space used. */ 544 *target_len_ptr = target - *target_ptr; 545 546 /* Check if input fit into target exactly. */ 547 if (w_source_len < 0 && target == target_end && w_source_ptr[0] == 0) 548 w_source_len = 0; 549 550 *target++ = '\0'; 551 552 /* Characters remained after filling the buffer, compute the remaining length now. */ 553 if (w_source_len) { 554 if (target_len_ptr != NULL) 555 *target_len_ptr = target_len + uv_utf16_length_as_wtf8(w_source_ptr, w_source_len); 556 return UV_ENOBUFS; 557 } 558 559 return 0; 560 } 561
Indexes created Tue Feb 24 08:35:24 UTC 2026