1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 5 * Copyright 2010 Nexenta Systems, Inc. All rights reserved. 6 * Copyright (c) 1995 Alex Tatmanjants <alex@elvisti.kiev.ua> 7 * at Electronni Visti IA, Kiev, Ukraine. 8 * All rights reserved. 9 * 10 * Copyright (c) 2011 The FreeBSD Foundation 11 * 12 * Portions of this software were developed by David Chisnall 13 * under sponsorship from the FreeBSD Foundation. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * Adapted to xlocale by John Marino <draco@marino.st> 37 */ 38 39 #include <sys/cdefs.h> 40 __FBSDID("$FreeBSD$"); 41 42 #include "namespace.h" 43 44 #include <sys/types.h> 45 #include <sys/stat.h> 46 #include <sys/mman.h> 47 48 #include <assert.h> 49 #include <stdio.h> 50 #include <stdlib.h> 51 #include <string.h> 52 #include <wchar.h> 53 #include <errno.h> 54 #include <unistd.h> 55 #include <fcntl.h> 56 #include "un-namespace.h" 57 58 #include "collate.h" 59 #include "setlocale.h" 60 #include "ldpart.h" 61 #include "libc_private.h" 62 63 struct xlocale_collate __xlocale_global_collate = { 64 {{0}, "C"}, 1, 0, 0, 0 65 }; 66 67 struct xlocale_collate __xlocale_C_collate = { 68 {{0}, "C"}, 1, 0, 0, 0 69 }; 70 71 struct xlocale_collate __xlocale_POSIX_collate = { 72 {{0}, "POSIX"}, 1, 0, 0, 0 73 }; 74 75 struct xlocale_collate __xlocale_CUTF8_collate = { 76 {{0}, "C.UTF-8"}, 1, 0, 0, 0 77 }; 78 79 static int 80 __collate_load_tables_l(const char *encoding, struct xlocale_collate *table); 81 82 static void 83 destruct_collate(void *t) 84 { 85 struct xlocale_collate *table = t; 86 if (table->map && (table->maplen > 0)) { 87 (void) munmap(table->map, table->maplen); 88 } 89 free(t); 90 } 91 92 void * 93 __collate_load(const char *encoding, __unused locale_t unused) 94 { 95 if (strcmp(encoding, "C") == 0) 96 return (&__xlocale_C_collate); 97 else if (strcmp(encoding, "POSIX") == 0) 98 return (&__xlocale_POSIX_collate); 99 else if (strcmp(encoding, "C.UTF-8") == 0) 100 return (&__xlocale_CUTF8_collate); 101 102 struct xlocale_collate *table = calloc(sizeof(struct xlocale_collate), 103 1); 104 if (table == NULL) 105 return (NULL); 106 table->header.header.destructor = destruct_collate; 107 108 /* 109 * FIXME: Make sure that _LDP_CACHE is never returned. We 110 * should be doing the caching outside of this section. 111 */ 112 if (__collate_load_tables_l(encoding, table) != _LDP_LOADED) { 113 xlocale_release(table); 114 return (NULL); 115 } 116 return (table); 117 } 118 119 /** 120 * Load the collation tables for the specified encoding into the global table. 121 */ 122 int 123 __collate_load_tables(const char *encoding) 124 { 125 126 return (__collate_load_tables_l(encoding, &__xlocale_global_collate)); 127 } 128 129 static int 130 __collate_load_tables_l(const char *encoding, struct xlocale_collate *table) 131 { 132 int i, chains, z; 133 char *buf; 134 char *TMP; 135 char *map; 136 collate_info_t *info; 137 struct stat sbuf; 138 int fd; 139 140 table->__collate_load_error = 1; 141 142 /* 'encoding' must be already checked. */ 143 if (strcmp(encoding, "C") == 0 || strcmp(encoding, "POSIX") == 0 || 144 strncmp(encoding, "C.", 2) == 0) { 145 return (_LDP_CACHE); 146 } 147 148 if (asprintf(&buf, "%s/%s/LC_COLLATE", _PathLocale, encoding) == -1) 149 return (_LDP_ERROR); 150 151 if ((fd = _open(buf, O_RDONLY | O_CLOEXEC)) < 0) { 152 free(buf); 153 return (_LDP_ERROR); 154 } 155 free(buf); 156 if (_fstat(fd, &sbuf) < 0) { 157 (void) _close(fd); 158 return (_LDP_ERROR); 159 } 160 if (sbuf.st_size < (COLLATE_FMT_VERSION_LEN + 161 XLOCALE_DEF_VERSION_LEN + 162 sizeof (info))) { 163 (void) _close(fd); 164 errno = EINVAL; 165 return (_LDP_ERROR); 166 } 167 map = mmap(NULL, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 168 (void) _close(fd); 169 if ((TMP = map) == MAP_FAILED) { 170 return (_LDP_ERROR); 171 } 172 173 if (strncmp(TMP, COLLATE_FMT_VERSION, COLLATE_FMT_VERSION_LEN) != 0) { 174 (void) munmap(map, sbuf.st_size); 175 errno = EINVAL; 176 return (_LDP_ERROR); 177 } 178 TMP += COLLATE_FMT_VERSION_LEN; 179 strlcat(table->header.version, TMP, sizeof (table->header.version)); 180 TMP += XLOCALE_DEF_VERSION_LEN; 181 182 info = (void *)TMP; 183 TMP += sizeof (*info); 184 185 if ((info->directive_count < 1) || 186 (info->directive_count >= COLL_WEIGHTS_MAX) || 187 ((chains = info->chain_count) < 0)) { 188 (void) munmap(map, sbuf.st_size); 189 errno = EINVAL; 190 return (_LDP_ERROR); 191 } 192 193 i = (sizeof (collate_char_t) * (UCHAR_MAX + 1)) + 194 (sizeof (collate_chain_t) * chains) + 195 (sizeof (collate_large_t) * info->large_count); 196 for (z = 0; z < info->directive_count; z++) { 197 i += sizeof (collate_subst_t) * info->subst_count[z]; 198 } 199 if (i != (sbuf.st_size - (TMP - map))) { 200 (void) munmap(map, sbuf.st_size); 201 errno = EINVAL; 202 return (_LDP_ERROR); 203 } 204 205 if (table->map && (table->maplen > 0)) { 206 (void) munmap(table->map, table->maplen); 207 } 208 table->map = map; 209 table->maplen = sbuf.st_size; 210 table->info = info; 211 table->char_pri_table = (void *)TMP; 212 TMP += sizeof (collate_char_t) * (UCHAR_MAX + 1); 213 214 for (z = 0; z < info->directive_count; z++) { 215 if (info->subst_count[z] > 0) { 216 table->subst_table[z] = (void *)TMP; 217 TMP += info->subst_count[z] * sizeof (collate_subst_t); 218 } else { 219 table->subst_table[z] = NULL; 220 } 221 } 222 223 if (chains > 0) { 224 table->chain_pri_table = (void *)TMP; 225 TMP += chains * sizeof (collate_chain_t); 226 } else 227 table->chain_pri_table = NULL; 228 if (info->large_count > 0) 229 table->large_pri_table = (void *)TMP; 230 else 231 table->large_pri_table = NULL; 232 233 table->__collate_load_error = 0; 234 return (_LDP_LOADED); 235 } 236 237 static const int32_t * 238 substsearch(struct xlocale_collate *table, const wchar_t key, int pass) 239 { 240 const collate_subst_t *p; 241 int n = table->info->subst_count[pass]; 242 243 if (n == 0) 244 return (NULL); 245 246 if (pass >= table->info->directive_count) 247 return (NULL); 248 249 if (!(key & COLLATE_SUBST_PRIORITY)) 250 return (NULL); 251 252 p = table->subst_table[pass] + (key & ~COLLATE_SUBST_PRIORITY); 253 assert(p->key == key); 254 255 return (p->pri); 256 } 257 258 static collate_chain_t * 259 chainsearch(struct xlocale_collate *table, const wchar_t *key, int *len) 260 { 261 int low = 0; 262 int high = table->info->chain_count - 1; 263 int next, compar, l; 264 collate_chain_t *p; 265 collate_chain_t *tab = table->chain_pri_table; 266 267 if (high < 0) 268 return (NULL); 269 270 while (low <= high) { 271 next = (low + high) / 2; 272 p = tab + next; 273 compar = *key - *p->str; 274 if (compar == 0) { 275 l = wcsnlen(p->str, COLLATE_STR_LEN); 276 compar = wcsncmp(key, p->str, l); 277 if (compar == 0) { 278 *len = l; 279 return (p); 280 } 281 } 282 if (compar > 0) 283 low = next + 1; 284 else 285 high = next - 1; 286 } 287 return (NULL); 288 } 289 290 static collate_large_t * 291 largesearch(struct xlocale_collate *table, const wchar_t key) 292 { 293 int low = 0; 294 int high = table->info->large_count - 1; 295 int next, compar; 296 collate_large_t *p; 297 collate_large_t *tab = table->large_pri_table; 298 299 if (high < 0) 300 return (NULL); 301 302 while (low <= high) { 303 next = (low + high) / 2; 304 p = tab + next; 305 compar = key - p->val; 306 if (compar == 0) 307 return (p); 308 if (compar > 0) 309 low = next + 1; 310 else 311 high = next - 1; 312 } 313 return (NULL); 314 } 315 316 void 317 _collate_lookup(struct xlocale_collate *table, const wchar_t *t, int *len, 318 int *pri, int which, const int **state) 319 { 320 collate_chain_t *p2; 321 collate_large_t *match; 322 int p, l; 323 const int *sptr; 324 325 /* 326 * If this is the "last" pass for the UNDEFINED, then 327 * we just return the priority itself. 328 */ 329 if (which >= table->info->directive_count) { 330 *pri = *t; 331 *len = 1; 332 *state = NULL; 333 return; 334 } 335 336 /* 337 * If we have remaining substitution data from a previous 338 * call, consume it first. 339 */ 340 if ((sptr = *state) != NULL) { 341 *pri = *sptr; 342 sptr++; 343 if ((sptr == *state) || (sptr == NULL)) 344 *state = NULL; 345 else 346 *state = sptr; 347 *len = 0; 348 return; 349 } 350 351 /* No active substitutions */ 352 *len = 1; 353 354 /* 355 * Check for composites such as diphthongs that collate as a 356 * single element (aka chains or collating-elements). 357 */ 358 if (((p2 = chainsearch(table, t, &l)) != NULL) && 359 ((p = p2->pri[which]) >= 0)) { 360 361 *len = l; 362 *pri = p; 363 364 } else if (*t <= UCHAR_MAX) { 365 366 /* 367 * Character is a small (8-bit) character. 368 * We just look these up directly for speed. 369 */ 370 *pri = table->char_pri_table[*t].pri[which]; 371 372 } else if ((table->info->large_count > 0) && 373 ((match = largesearch(table, *t)) != NULL)) { 374 375 /* 376 * Character was found in the extended table. 377 */ 378 *pri = match->pri.pri[which]; 379 380 } else { 381 /* 382 * Character lacks a specific definition. 383 */ 384 if (table->info->directive[which] & DIRECTIVE_UNDEFINED) { 385 /* Mask off sign bit to prevent ordering confusion. */ 386 *pri = (*t & COLLATE_MAX_PRIORITY); 387 } else { 388 *pri = table->info->undef_pri[which]; 389 } 390 /* No substitutions for undefined characters! */ 391 return; 392 } 393 394 /* 395 * Try substituting (expanding) the character. We are 396 * currently doing this *after* the chain compression. I 397 * think it should not matter, but this way might be slightly 398 * faster. 399 * 400 * We do this after the priority search, as this will help us 401 * to identify a single key value. In order for this to work, 402 * its important that the priority assigned to a given element 403 * to be substituted be unique for that level. The localedef 404 * code ensures this for us. 405 */ 406 if ((sptr = substsearch(table, *pri, which)) != NULL) { 407 if ((*pri = *sptr) > 0) { 408 sptr++; 409 *state = *sptr ? sptr : NULL; 410 } 411 } 412 413 } 414 415 /* 416 * This is the meaty part of wcsxfrm & strxfrm. Note that it does 417 * NOT NULL terminate. That is left to the caller. 418 */ 419 size_t 420 _collate_wxfrm(struct xlocale_collate *table, const wchar_t *src, wchar_t *xf, 421 size_t room) 422 { 423 int pri; 424 int len; 425 const wchar_t *t; 426 wchar_t *tr = NULL; 427 int direc; 428 int pass; 429 const int32_t *state; 430 size_t want = 0; 431 size_t need = 0; 432 int ndir = table->info->directive_count; 433 434 assert(src); 435 436 for (pass = 0; pass <= ndir; pass++) { 437 438 state = NULL; 439 440 if (pass != 0) { 441 /* insert level separator from the previous pass */ 442 if (room) { 443 *xf++ = 1; 444 room--; 445 } 446 want++; 447 } 448 449 /* special pass for undefined */ 450 if (pass == ndir) { 451 direc = DIRECTIVE_FORWARD | DIRECTIVE_UNDEFINED; 452 } else { 453 direc = table->info->directive[pass]; 454 } 455 456 t = src; 457 458 if (direc & DIRECTIVE_BACKWARD) { 459 wchar_t *bp, *fp, c; 460 free(tr); 461 if ((tr = wcsdup(t)) == NULL) { 462 errno = ENOMEM; 463 goto fail; 464 } 465 bp = tr; 466 fp = tr + wcslen(tr) - 1; 467 while (bp < fp) { 468 c = *bp; 469 *bp++ = *fp; 470 *fp-- = c; 471 } 472 t = (const wchar_t *)tr; 473 } 474 475 if (direc & DIRECTIVE_POSITION) { 476 while (*t || state) { 477 _collate_lookup(table, t, &len, &pri, pass, &state); 478 t += len; 479 if (pri <= 0) { 480 if (pri < 0) { 481 errno = EINVAL; 482 goto fail; 483 } 484 state = NULL; 485 pri = COLLATE_MAX_PRIORITY; 486 } 487 if (room) { 488 *xf++ = pri; 489 room--; 490 } 491 want++; 492 need = want; 493 } 494 } else { 495 while (*t || state) { 496 _collate_lookup(table, t, &len, &pri, pass, &state); 497 t += len; 498 if (pri <= 0) { 499 if (pri < 0) { 500 errno = EINVAL; 501 goto fail; 502 } 503 state = NULL; 504 continue; 505 } 506 if (room) { 507 *xf++ = pri; 508 room--; 509 } 510 want++; 511 need = want; 512 } 513 } 514 } 515 free(tr); 516 return (need); 517 518 fail: 519 free(tr); 520 return ((size_t)(-1)); 521 } 522 523 /* 524 * In the non-POSIX case, we transform each character into a string of 525 * characters representing the character's priority. Since char is usually 526 * signed, we are limited by 7 bits per byte. To avoid zero, we need to add 527 * XFRM_OFFSET, so we can't use a full 7 bits. For simplicity, we choose 6 528 * bits per byte. 529 * 530 * It turns out that we sometimes have real priorities that are 531 * 31-bits wide. (But: be careful using priorities where the high 532 * order bit is set -- i.e. the priority is negative. The sort order 533 * may be surprising!) 534 * 535 * TODO: This would be a good area to optimize somewhat. It turns out 536 * that real prioririties *except for the last UNDEFINED pass* are generally 537 * very small. We need the localedef code to precalculate the max 538 * priority for us, and ideally also give us a mask, and then we could 539 * severely limit what we expand to. 540 */ 541 #define XFRM_BYTES 6 542 #define XFRM_OFFSET ('0') /* make all printable characters */ 543 #define XFRM_SHIFT 6 544 #define XFRM_MASK ((1 << XFRM_SHIFT) - 1) 545 #define XFRM_SEP ('.') /* chosen to be less than XFRM_OFFSET */ 546 547 static int 548 xfrm(struct xlocale_collate *table, unsigned char *p, int pri, int pass) 549 { 550 /* we use unsigned to ensure zero fill on right shift */ 551 uint32_t val = (uint32_t)table->info->pri_count[pass]; 552 int nc = 0; 553 554 while (val) { 555 *p = (pri & XFRM_MASK) + XFRM_OFFSET; 556 pri >>= XFRM_SHIFT; 557 val >>= XFRM_SHIFT; 558 p++; 559 nc++; 560 } 561 return (nc); 562 } 563 564 size_t 565 _collate_sxfrm(struct xlocale_collate *table, const wchar_t *src, char *xf, 566 size_t room) 567 { 568 int pri; 569 int len; 570 const wchar_t *t; 571 wchar_t *tr = NULL; 572 int direc; 573 int pass; 574 const int32_t *state; 575 size_t want = 0; 576 size_t need = 0; 577 int b; 578 uint8_t buf[XFRM_BYTES]; 579 int ndir = table->info->directive_count; 580 581 assert(src); 582 583 for (pass = 0; pass <= ndir; pass++) { 584 585 state = NULL; 586 587 if (pass != 0) { 588 /* insert level separator from the previous pass */ 589 if (room) { 590 *xf++ = XFRM_SEP; 591 room--; 592 } 593 want++; 594 } 595 596 /* special pass for undefined */ 597 if (pass == ndir) { 598 direc = DIRECTIVE_FORWARD | DIRECTIVE_UNDEFINED; 599 } else { 600 direc = table->info->directive[pass]; 601 } 602 603 t = src; 604 605 if (direc & DIRECTIVE_BACKWARD) { 606 wchar_t *bp, *fp, c; 607 free(tr); 608 if ((tr = wcsdup(t)) == NULL) { 609 errno = ENOMEM; 610 goto fail; 611 } 612 bp = tr; 613 fp = tr + wcslen(tr) - 1; 614 while (bp < fp) { 615 c = *bp; 616 *bp++ = *fp; 617 *fp-- = c; 618 } 619 t = (const wchar_t *)tr; 620 } 621 622 if (direc & DIRECTIVE_POSITION) { 623 while (*t || state) { 624 625 _collate_lookup(table, t, &len, &pri, pass, &state); 626 t += len; 627 if (pri <= 0) { 628 if (pri < 0) { 629 errno = EINVAL; 630 goto fail; 631 } 632 state = NULL; 633 pri = COLLATE_MAX_PRIORITY; 634 } 635 636 b = xfrm(table, buf, pri, pass); 637 want += b; 638 if (room) { 639 while (b) { 640 b--; 641 if (room) { 642 *xf++ = buf[b]; 643 room--; 644 } 645 } 646 } 647 need = want; 648 } 649 } else { 650 while (*t || state) { 651 _collate_lookup(table, t, &len, &pri, pass, &state); 652 t += len; 653 if (pri <= 0) { 654 if (pri < 0) { 655 errno = EINVAL; 656 goto fail; 657 } 658 state = NULL; 659 continue; 660 } 661 662 b = xfrm(table, buf, pri, pass); 663 want += b; 664 if (room) { 665 666 while (b) { 667 b--; 668 if (room) { 669 *xf++ = buf[b]; 670 room--; 671 } 672 } 673 } 674 need = want; 675 } 676 } 677 } 678 free(tr); 679 return (need); 680 681 fail: 682 free(tr); 683 return ((size_t)(-1)); 684 } 685 686 /* 687 * __collate_equiv_value returns the primary collation value for the given 688 * collating symbol specified by str and len. Zero or negative is returned 689 * if the collating symbol was not found. This function is used by bracket 690 * code in the TRE regex library. 691 */ 692 int 693 __collate_equiv_value(locale_t locale, const wchar_t *str, size_t len) 694 { 695 int32_t e; 696 697 if (len < 1 || len >= COLLATE_STR_LEN) 698 return (-1); 699 700 FIX_LOCALE(locale); 701 struct xlocale_collate *table = 702 (struct xlocale_collate*)locale->components[XLC_COLLATE]; 703 704 if (table->__collate_load_error) 705 return ((len == 1 && *str <= UCHAR_MAX) ? *str : -1); 706 707 if (len == 1) { 708 e = -1; 709 if (*str <= UCHAR_MAX) 710 e = table->char_pri_table[*str].pri[0]; 711 else if (table->info->large_count > 0) { 712 collate_large_t *match_large; 713 match_large = largesearch(table, *str); 714 if (match_large) 715 e = match_large->pri.pri[0]; 716 } 717 if (e == 0) 718 return (1); 719 return (e > 0 ? e : 0); 720 } 721 if (table->info->chain_count > 0) { 722 wchar_t name[COLLATE_STR_LEN]; 723 collate_chain_t *match_chain; 724 int clen; 725 726 wcsncpy (name, str, len); 727 name[len] = 0; 728 match_chain = chainsearch(table, name, &clen); 729 if (match_chain) { 730 e = match_chain->pri[0]; 731 if (e == 0) 732 return (1); 733 return (e < 0 ? -e : e); 734 } 735 } 736 return (0); 737 } 738