1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 * 21 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 22 * Use is subject to license terms. 23 */ 24 25 #include <errno.h> 26 #include <locale.h> 27 #include <langinfo.h> 28 #include <iconv.h> 29 #include <ctype.h> 30 #include <wctype.h> 31 #include <strings.h> 32 #include <string.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include "includes.h" 36 #include "xmalloc.h" 37 #include "xlist.h" 38 #include "compat.h" 39 #include "log.h" 40 41 #ifdef MIN 42 #undef MIN 43 #endif /* MIN */ 44 45 #define MIN(x, y) ((x) < (y) ? (x) : (y)) 46 47 #define LOCALE_PATH "/usr/bin/locale" 48 49 /* two-char country code, '-' and two-char region code */ 50 #define LANGTAG_MAX 5 51 52 static int locale_cmp(const void *d1, const void *d2); 53 static char *g11n_locale2langtag(char *locale); 54 55 static char *do_iconv(iconv_t cd, const char *s, uint_t *lenp, char **err_str); 56 57 /* 58 * native_codeset records the codeset of the default system locale. 59 * It is used to convert the contents of file (eg /etc/issue) which is 60 * supposed to be in the codeset of default system locale. 61 */ 62 static char *native_codeset; 63 64 /* 65 * Convert locale string name into a language tag. The caller is responsible for 66 * freeing the memory allocated for the result. 67 */ 68 static char * 69 g11n_locale2langtag(char *locale) 70 { 71 char *langtag; 72 73 /* base cases */ 74 if (!locale || !*locale) 75 return (NULL); 76 77 if (strcmp(locale, "POSIX") == 0 || strcmp(locale, "C") == 0) 78 return (xstrdup("i-default")); 79 80 /* punt for language codes which are not exactly 2 letters */ 81 if (strlen(locale) < 2 || 82 !isalpha(locale[0]) || 83 !isalpha(locale[1]) || 84 (locale[2] != '\0' && 85 locale[2] != '_' && 86 locale[2] != '.' && 87 locale[2] != '@')) 88 return (NULL); 89 90 91 /* we have a primary language sub-tag */ 92 langtag = (char *)xmalloc(LANGTAG_MAX + 1); 93 94 strncpy(langtag, locale, 2); 95 langtag[2] = '\0'; 96 97 /* do we have country sub-tag? For example: cs_CZ */ 98 if (locale[2] == '_') { 99 if (strlen(locale) < 5 || 100 !isalpha(locale[3]) || 101 !isalpha(locale[4]) || 102 (locale[5] != '\0' && (locale[5] != '.' && 103 locale[5] != '@'))) { 104 return (langtag); 105 } 106 107 /* example: create cs-CZ from cs_CZ */ 108 if (snprintf(langtag, 6, "%.*s-%.*s", 2, locale, 2, 109 locale + 3) == 5) 110 return (langtag); 111 } 112 113 /* in all other cases we just use the primary language sub-tag */ 114 return (langtag); 115 } 116 117 uint_t 118 g11n_langtag_is_default(char *langtag) 119 { 120 return (strcmp(langtag, "i-default") == 0); 121 } 122 123 /* 124 * This lang tag / locale matching function works only for two-character 125 * language primary sub-tags and two-character country sub-tags. 126 */ 127 uint_t 128 g11n_langtag_matches_locale(char *langtag, char *locale) 129 { 130 /* match "i-default" to the process' current locale if possible */ 131 if (g11n_langtag_is_default(langtag)) { 132 if (strcasecmp(locale, "POSIX") == 0 || 133 strcasecmp(locale, "C") == 0) 134 return (1); 135 else 136 return (0); 137 } 138 139 /* 140 * locale must be at least 2 chars long and the lang part must be 141 * exactly two characters 142 */ 143 if (strlen(locale) < 2 || 144 (!isalpha(locale[0]) || !isalpha(locale[1]) || 145 (locale[2] != '\0' && locale[2] != '_' && 146 locale[2] != '.' && locale[2] != '@'))) 147 return (0); 148 149 /* same thing with the langtag */ 150 if (strlen(langtag) < 2 || 151 (!isalpha(langtag[0]) || !isalpha(langtag[1]) || 152 (langtag[2] != '\0' && langtag[2] != '-'))) 153 return (0); 154 155 /* primary language sub-tag and the locale's language part must match */ 156 if (strncasecmp(langtag, locale, 2) != 0) 157 return (0); 158 159 /* 160 * primary language sub-tag and the locale's language match, now 161 * fuzzy check country part 162 */ 163 164 /* neither langtag nor locale have more than one component */ 165 if (langtag[2] == '\0' && 166 (locale[2] == '\0' || locale[2] == '.' || locale[2] == '@')) 167 return (2); 168 169 /* langtag has only one sub-tag... */ 170 if (langtag[2] == '\0') 171 return (1); 172 173 /* locale has no country code... */ 174 if (locale[2] == '\0' || locale[2] == '.' || locale[2] == '@') 175 return (1); 176 177 /* langtag has more than one subtag and the locale has a country code */ 178 179 /* ignore second subtag if not two chars */ 180 if (strlen(langtag) < 5) 181 return (1); 182 183 if (!isalpha(langtag[3]) || !isalpha(langtag[4]) || 184 (langtag[5] != '\0' && langtag[5] != '-')) 185 return (1); 186 187 /* ignore rest of locale if there is no two-character country part */ 188 if (strlen(locale) < 5) 189 return (1); 190 191 if (locale[2] != '_' || !isalpha(locale[3]) || !isalpha(locale[4]) || 192 (locale[5] != '\0' && locale[5] != '.' && locale[5] != '@')) 193 return (1); 194 195 /* if the country part matches, return 2 */ 196 if (strncasecmp(&langtag[3], &locale[3], 2) == 0) 197 return (2); 198 199 return (1); 200 } 201 202 char * 203 g11n_getlocale() 204 { 205 /* we have one text domain - always set it */ 206 (void) textdomain(TEXT_DOMAIN); 207 208 /* if the locale is not set, set it from the env vars */ 209 if (!setlocale(LC_MESSAGES, NULL)) 210 (void) setlocale(LC_MESSAGES, ""); 211 212 return (setlocale(LC_MESSAGES, NULL)); 213 } 214 215 void 216 g11n_setlocale(int category, const char *locale) 217 { 218 char *curr; 219 220 if (native_codeset == NULL) { 221 /* set default locale, and record current codeset */ 222 (void) setlocale(LC_ALL, ""); 223 curr = nl_langinfo(CODESET); 224 native_codeset = xstrdup(curr); 225 } 226 227 /* we have one text domain - always set it */ 228 (void) textdomain(TEXT_DOMAIN); 229 230 if (!locale) 231 return; 232 233 if (*locale && ((curr = setlocale(category, NULL))) && 234 strcmp(curr, locale) == 0) 235 return; 236 237 /* if <category> is bogus, setlocale() will do nothing */ 238 (void) setlocale(category, locale); 239 } 240 241 char ** 242 g11n_getlocales() 243 { 244 FILE *locale_out; 245 uint_t n_elems, list_size, long_line = 0; 246 char **list; 247 char locale[64]; /* 64 bytes is plenty for locale names */ 248 249 if ((locale_out = popen(LOCALE_PATH " -a", "r")) == NULL) 250 return (NULL); 251 252 /* 253 * start with enough room for 65 locales - that's a lot fewer than 254 * all the locales available for installation, but a lot more than 255 * what most users will need and install 256 */ 257 n_elems = 0; 258 list_size = 192; 259 list = (char **) xmalloc(sizeof (char *) * (list_size + 1)); 260 memset(list, 0, sizeof (char *) * (list_size + 1)); 261 262 while (fgets(locale, sizeof (locale), locale_out)) { 263 /* skip long locale names (if any) */ 264 if (!strchr(locale, '\n')) { 265 long_line = 1; 266 continue; 267 } else if (long_line) { 268 long_line = 0; 269 continue; 270 } 271 272 if (strncmp(locale, "iso_8859", 8) == 0) 273 /* ignore locale names like "iso_8859-1" */ 274 continue; 275 276 if (n_elems == list_size) { 277 list_size *= 2; 278 list = (char **)xrealloc((void *) list, 279 (list_size + 1) * sizeof (char *)); 280 memset(&list[n_elems + 1], 0, 281 sizeof (char *) * (list_size - n_elems + 1)); 282 } 283 284 *(strchr(locale, '\n')) = '\0'; /* remove the trailing \n */ 285 list[n_elems++] = xstrdup(locale); 286 } 287 288 (void) pclose(locale_out); 289 290 if (n_elems == 0) { 291 xfree(list); 292 return (NULL); 293 } 294 295 list[n_elems] = NULL; 296 297 qsort(list, n_elems - 1, sizeof (char *), locale_cmp); 298 return (list); 299 } 300 301 char * 302 g11n_getlangs() 303 { 304 char *locale; 305 306 if (getenv("SSH_LANGS")) 307 return (xstrdup(getenv("SSH_LANGS"))); 308 309 locale = g11n_getlocale(); 310 311 if (!locale || !*locale) 312 return (xstrdup("i-default")); 313 314 return (g11n_locale2langtag(locale)); 315 } 316 317 char * 318 g11n_locales2langs(char **locale_set) 319 { 320 char **p, **r, **q; 321 char *langtag, *langs; 322 int locales, skip; 323 324 for (locales = 0, p = locale_set; p && *p; p++) 325 locales++; 326 327 r = (char **)xmalloc((locales + 1) * sizeof (char *)); 328 memset(r, 0, (locales + 1) * sizeof (char *)); 329 330 for (p = locale_set; p && *p && ((p - locale_set) <= locales); p++) { 331 skip = 0; 332 if ((langtag = g11n_locale2langtag(*p)) == NULL) 333 continue; 334 for (q = r; (q - r) < locales; q++) { 335 if (!*q) 336 break; 337 if (*q && strcmp(*q, langtag) == 0) 338 skip = 1; 339 } 340 if (!skip) 341 *(q++) = langtag; 342 else 343 xfree(langtag); 344 *q = NULL; 345 } 346 347 langs = xjoin(r, ','); 348 g11n_freelist(r); 349 350 return (langs); 351 } 352 353 static int 354 sortcmp(const void *d1, const void *d2) 355 { 356 char *s1 = *(char **)d1; 357 char *s2 = *(char **)d2; 358 359 return (strcmp(s1, s2)); 360 } 361 362 int 363 g11n_langtag_match(char *langtag1, char *langtag2) 364 { 365 int len1, len2; 366 char c1, c2; 367 368 len1 = (strchr(langtag1, '-')) ? 369 (strchr(langtag1, '-') - langtag1) 370 : strlen(langtag1); 371 372 len2 = (strchr(langtag2, '-')) ? 373 (strchr(langtag2, '-') - langtag2) 374 : strlen(langtag2); 375 376 /* no match */ 377 if (len1 != len2 || strncmp(langtag1, langtag2, len1) != 0) 378 return (0); 379 380 c1 = *(langtag1 + len1); 381 c2 = *(langtag2 + len2); 382 383 /* no country sub-tags - exact match */ 384 if (c1 == '\0' && c2 == '\0') 385 return (2); 386 387 /* one langtag has a country sub-tag, the other doesn't */ 388 if (c1 == '\0' || c2 == '\0') 389 return (1); 390 391 /* can't happen - both langtags have a country sub-tag */ 392 if (c1 != '-' || c2 != '-') 393 return (1); 394 395 /* compare country subtags */ 396 langtag1 = langtag1 + len1 + 1; 397 langtag2 = langtag2 + len2 + 1; 398 399 len1 = (strchr(langtag1, '-')) ? 400 (strchr(langtag1, '-') - langtag1) : strlen(langtag1); 401 402 len2 = (strchr(langtag2, '-')) ? 403 (strchr(langtag2, '-') - langtag2) : strlen(langtag2); 404 405 if (len1 != len2 || strncmp(langtag1, langtag2, len1) != 0) 406 return (1); 407 408 /* country tags matched - exact match */ 409 return (2); 410 } 411 412 char * 413 g11n_langtag_set_intersect(char *set1, char *set2) 414 { 415 char **list1, **list2, **list3, **p, **q, **r; 416 char *set3, *lang_subtag; 417 uint_t n1, n2, n3; 418 uint_t do_append; 419 420 list1 = xsplit(set1, ','); 421 list2 = xsplit(set2, ','); 422 423 for (n1 = 0, p = list1; p && *p; p++, n1++) 424 ; 425 for (n2 = 0, p = list2; p && *p; p++, n2++) 426 ; 427 428 list3 = (char **) xmalloc(sizeof (char *) * (n1 + n2 + 1)); 429 *list3 = NULL; 430 431 /* 432 * we must not sort the user langtags - sorting or not the server's 433 * should not affect the outcome 434 */ 435 qsort(list2, n2, sizeof (char *), sortcmp); 436 437 for (n3 = 0, p = list1; p && *p; p++) { 438 do_append = 0; 439 for (q = list2; q && *q; q++) { 440 if (g11n_langtag_match(*p, *q) != 2) continue; 441 /* append element */ 442 for (r = list3; (r - list3) <= (n1 + n2); r++) { 443 do_append = 1; 444 if (!*r) 445 break; 446 if (strcmp(*p, *r) == 0) { 447 do_append = 0; 448 break; 449 } 450 } 451 if (do_append && n3 <= (n1 + n2)) { 452 list3[n3++] = xstrdup(*p); 453 list3[n3] = NULL; 454 } 455 } 456 } 457 458 for (p = list1; p && *p; p++) { 459 do_append = 0; 460 for (q = list2; q && *q; q++) { 461 if (g11n_langtag_match(*p, *q) != 1) 462 continue; 463 464 /* append element */ 465 lang_subtag = xstrdup(*p); 466 if (strchr(lang_subtag, '-')) 467 *(strchr(lang_subtag, '-')) = '\0'; 468 for (r = list3; (r - list3) <= (n1 + n2); r++) { 469 do_append = 1; 470 if (!*r) 471 break; 472 if (strcmp(lang_subtag, *r) == 0) { 473 do_append = 0; 474 break; 475 } 476 } 477 if (do_append && n3 <= (n1 + n2)) { 478 list3[n3++] = lang_subtag; 479 list3[n3] = NULL; 480 } else 481 xfree(lang_subtag); 482 } 483 } 484 485 set3 = xjoin(list3, ','); 486 xfree_split_list(list1); 487 xfree_split_list(list2); 488 xfree_split_list(list3); 489 490 return (set3); 491 } 492 493 char * 494 g11n_clnt_langtag_negotiate(char *clnt_langtags, char *srvr_langtags) 495 { 496 char *list, *result; 497 char **xlist; 498 499 /* g11n_langtag_set_intersect uses xmalloc - should not return NULL */ 500 list = g11n_langtag_set_intersect(clnt_langtags, srvr_langtags); 501 502 if (!list) 503 return (NULL); 504 505 xlist = xsplit(list, ','); 506 507 xfree(list); 508 509 if (!xlist || !*xlist) 510 return (NULL); 511 512 result = xstrdup(*xlist); 513 xfree_split_list(xlist); 514 515 return (result); 516 } 517 518 /* 519 * Compare locales, preferring UTF-8 codesets to others, otherwise doing 520 * a stright strcmp() 521 */ 522 static int 523 locale_cmp(const void *d1, const void *d2) 524 { 525 char *dot_ptr; 526 char *s1 = *(char **)d1; 527 char *s2 = *(char **)d2; 528 int s1_is_utf8 = 0; 529 int s2_is_utf8 = 0; 530 531 /* check if s1 is a UTF-8 locale */ 532 if (((dot_ptr = strchr((char *)s1, '.')) != NULL) && 533 (*dot_ptr != '\0') && (strncmp(dot_ptr + 1, "UTF-8", 5) == 0) && 534 (*(dot_ptr + 6) == '\0' || *(dot_ptr + 6) == '@')) { 535 s1_is_utf8++; 536 } 537 538 /* check if s2 is a UTF-8 locale */ 539 if (((dot_ptr = strchr((char *)s2, '.')) != NULL) && 540 (*dot_ptr != '\0') && (strncmp(dot_ptr + 1, "UTF-8", 5) == 0) && 541 (*(dot_ptr + 6) == '\0' || *(dot_ptr + 6) == '@')) { 542 s2_is_utf8++; 543 } 544 545 /* prefer UTF-8 locales */ 546 if (s1_is_utf8 && !s2_is_utf8) 547 return (-1); 548 549 if (s2_is_utf8 && !s1_is_utf8) 550 return (1); 551 552 /* prefer any locale over the default locales */ 553 if (strcmp(s1, "C") == 0 || strcmp(s1, "POSIX") == 0 || 554 strcmp(s1, "common") == 0) { 555 if (strcmp(s2, "C") != 0 && strcmp(s2, "POSIX") != 0 && 556 strcmp(s2, "common") != 0) 557 return (1); 558 } 559 560 if (strcmp(s2, "C") == 0 || strcmp(s2, "POSIX") == 0 || 561 strcmp(s2, "common") == 0) { 562 if (strcmp(s1, "C") != 0 && 563 strcmp(s1, "POSIX") != 0 && 564 strcmp(s1, "common") != 0) 565 return (-1); 566 } 567 568 return (strcmp(s1, s2)); 569 } 570 571 572 char ** 573 g11n_langtag_set_locale_set_intersect(char *langtag_set, char **locale_set) 574 { 575 char **langtag_list, **result, **p, **q, **r; 576 char *s; 577 uint_t do_append, n_langtags, n_locales, n_results, max_results; 578 579 if (locale_set == NULL) 580 return (NULL); 581 582 /* count lang tags and locales */ 583 for (n_locales = 0, p = locale_set; p && *p; p++) 584 n_locales++; 585 586 n_langtags = ((s = langtag_set) != NULL && *s && *s != ',') ? 1 : 0; 587 /* count the number of langtags */ 588 for (; s = strchr(s, ','); s++, n_langtags++) 589 ; 590 591 qsort(locale_set, n_locales, sizeof (char *), locale_cmp); 592 593 langtag_list = xsplit(langtag_set, ','); 594 for (n_langtags = 0, p = langtag_list; p && *p; p++, n_langtags++) 595 ; 596 597 max_results = MIN(n_locales, n_langtags) * 2; 598 result = (char **) xmalloc(sizeof (char *) * (max_results + 1)); 599 *result = NULL; 600 n_results = 0; 601 602 /* more specific matches first */ 603 for (p = langtag_list; p && *p; p++) { 604 do_append = 0; 605 for (q = locale_set; q && *q; q++) { 606 if (g11n_langtag_matches_locale(*p, *q) == 2) { 607 do_append = 1; 608 for (r = result; (r - result) <= 609 MIN(n_locales, n_langtags); r++) { 610 if (!*r) 611 break; 612 if (strcmp(*q, *r) == 0) { 613 do_append = 0; 614 break; 615 } 616 } 617 if (do_append && n_results < max_results) { 618 result[n_results++] = xstrdup(*q); 619 result[n_results] = NULL; 620 } 621 break; 622 } 623 } 624 } 625 626 for (p = langtag_list; p && *p; p++) { 627 do_append = 0; 628 for (q = locale_set; q && *q; q++) { 629 if (g11n_langtag_matches_locale(*p, *q) == 1) { 630 do_append = 1; 631 for (r = result; (r - result) <= 632 MIN(n_locales, n_langtags); r++) { 633 if (!*r) 634 break; 635 if (strcmp(*q, *r) == 0) { 636 do_append = 0; 637 break; 638 } 639 } 640 if (do_append && n_results < max_results) { 641 result[n_results++] = xstrdup(*q); 642 result[n_results] = NULL; 643 } 644 break; 645 } 646 } 647 } 648 649 xfree_split_list(langtag_list); 650 651 return (result); 652 } 653 654 char * 655 g11n_srvr_locale_negotiate(char *clnt_langtags, char **srvr_locales) 656 { 657 char **results, **locales, *result = NULL; 658 659 if (srvr_locales == NULL) 660 locales = g11n_getlocales(); 661 else 662 locales = srvr_locales; 663 664 if ((results = g11n_langtag_set_locale_set_intersect(clnt_langtags, 665 locales)) == NULL) 666 goto err; 667 668 if (*results != NULL) 669 result = xstrdup(*results); 670 671 xfree_split_list(results); 672 673 err: 674 if (locales != NULL && locales != srvr_locales) 675 g11n_freelist(locales); 676 return (result); 677 } 678 679 /* 680 * Functions for converting to UTF-8 from the local codeset and 681 * converting from UTF-8 to the local codeset. 682 * 683 * The error_str parameter is an pointer to a char variable where to 684 * store a string suitable for use with error() or fatal() or friends. 685 * It is also used for an error indicator when NULL is returned. 686 * 687 * If conversion isn't necessary, *error_str is set to NULL, and 688 * NULL is returned. 689 * If conversion error occured, *error_str points to an error message, 690 * and NULL is returned. 691 */ 692 char * 693 g11n_convert_from_utf8(const char *str, uint_t *lenp, char **error_str) 694 { 695 static char *last_codeset; 696 static iconv_t cd = (iconv_t)-1; 697 char *codeset; 698 699 *error_str = NULL; 700 701 codeset = nl_langinfo(CODESET); 702 703 if (strcmp(codeset, "UTF-8") == 0) 704 return (NULL); 705 706 if (last_codeset == NULL || strcmp(codeset, last_codeset) != 0) { 707 if (last_codeset != NULL) { 708 xfree(last_codeset); 709 last_codeset = NULL; 710 } 711 if (cd != (iconv_t)-1) 712 (void) iconv_close(cd); 713 714 if ((cd = iconv_open(codeset, "UTF-8")) == (iconv_t)-1) { 715 *error_str = gettext("Cannot convert UTF-8 " 716 "strings to the local codeset"); 717 return (NULL); 718 } 719 last_codeset = xstrdup(codeset); 720 } 721 return (do_iconv(cd, str, lenp, error_str)); 722 } 723 724 char * 725 g11n_convert_to_utf8(const char *str, uint_t *lenp, 726 int native, char **error_str) 727 { 728 static char *last_codeset; 729 static iconv_t cd = (iconv_t)-1; 730 char *codeset; 731 732 *error_str = NULL; 733 734 if (native) 735 codeset = native_codeset; 736 else 737 codeset = nl_langinfo(CODESET); 738 739 if (strcmp(codeset, "UTF-8") == 0) 740 return (NULL); 741 742 if (last_codeset == NULL || strcmp(codeset, last_codeset) != 0) { 743 if (last_codeset != NULL) { 744 xfree(last_codeset); 745 last_codeset = NULL; 746 } 747 if (cd != (iconv_t)-1) 748 (void) iconv_close(cd); 749 750 if ((cd = iconv_open("UTF-8", codeset)) == (iconv_t)-1) { 751 *error_str = gettext("Cannot convert the " 752 "local codeset strings to UTF-8"); 753 return (NULL); 754 } 755 last_codeset = xstrdup(codeset); 756 } 757 return (do_iconv(cd, str, lenp, error_str)); 758 } 759 760 /* 761 * Wrapper around iconv() 762 * 763 * The caller is responsible for freeing the result. NULL is returned when 764 * (errno && errno != E2BIG) (i.e., EILSEQ, EINVAL, EBADF). 765 * The caller must ensure that the input string isn't NULL pointer. 766 */ 767 static char * 768 do_iconv(iconv_t cd, const char *str, uint_t *lenp, char **err_str) 769 { 770 int ilen, olen; 771 size_t ileft, oleft; 772 char *ostr, *optr; 773 const char *istr; 774 775 ilen = *lenp; 776 olen = ilen + 1; 777 778 ostr = NULL; 779 for (;;) { 780 olen *= 2; 781 oleft = olen; 782 ostr = optr = xrealloc(ostr, olen); 783 istr = (const char *)str; 784 if ((ileft = ilen) == 0) 785 break; 786 787 if (iconv(cd, &istr, &ileft, &optr, &oleft) != (size_t)-1) { 788 /* success: generate reset sequence */ 789 if (iconv(cd, NULL, NULL, 790 &optr, &oleft) == (size_t)-1 && errno == E2BIG) { 791 continue; 792 } 793 break; 794 } 795 /* failed */ 796 if (errno != E2BIG) { 797 oleft = olen; 798 (void) iconv(cd, NULL, NULL, &ostr, &oleft); 799 xfree(ostr); 800 *err_str = gettext("Codeset conversion failed"); 801 return (NULL); 802 } 803 } 804 olen = optr - ostr; 805 optr = xmalloc(olen + 1); 806 (void) memcpy(optr, ostr, olen); 807 xfree(ostr); 808 809 optr[olen] = '\0'; 810 *lenp = olen; 811 812 return (optr); 813 } 814 815 /* 816 * A filter for output string. Control and unprintable characters 817 * are converted into visible form (eg "\ooo"). 818 */ 819 char * 820 g11n_filter_string(char *s) 821 { 822 int mb_cur_max = MB_CUR_MAX; 823 int mblen, len; 824 char *os = s; 825 wchar_t wc; 826 char *obuf, *op; 827 828 /* all character may be converted into the form of \ooo */ 829 obuf = op = xmalloc(strlen(s) * 4 + 1); 830 831 while (*s != '\0') { 832 mblen = mbtowc(&wc, s, mb_cur_max); 833 if (mblen <= 0) { 834 mblen = 1; 835 wc = (unsigned char)*s; 836 } 837 if (!iswprint(wc) && 838 wc != L'\n' && wc != L'\r' && wc != L'\t') { 839 /* 840 * control chars which need to be replaced 841 * with safe character sequence. 842 */ 843 while (mblen != 0) { 844 op += sprintf(op, "\\%03o", 845 (unsigned char)*s++); 846 mblen--; 847 } 848 } else { 849 while (mblen != 0) { 850 *op++ = *s++; 851 mblen--; 852 } 853 } 854 } 855 *op = '\0'; 856 len = op - obuf + 1; 857 op = xrealloc(os, len); 858 (void) memcpy(op, obuf, len); 859 xfree(obuf); 860 return (op); 861 } 862 863 /* 864 * Once we negotiated with a langtag, server need to map it to a system 865 * locale. That is done based on the locale supported on the server side. 866 * We know (with the locale supported on Solaris) how the langtag is 867 * mapped to. However, from the client point of view, there is no way to 868 * know exactly what locale(encoding) will be used. 869 * 870 * With the bug fix of SSH_BUG_STRING_ENCODING, it is guaranteed that the 871 * UTF-8 characters always come over the wire, so it is no longer the problem 872 * as long as both side has the bug fix. However if the server side doesn't 873 * have the fix, client can't safely perform the code conversion since the 874 * incoming character encoding is unknown. 875 * 876 * To alleviate this situation, we take an empirical approach to find 877 * encoding from langtag. 878 * 879 * If langtag has a subtag, we can directly map the langtag to UTF-8 locale 880 * (eg en-US can be mapped to en_US.UTF-8) with a few exceptions. 881 * Certain xx_YY locales don't support UTF-8 encoding (probably due to lack 882 * of L10N support ..). Those are: 883 * 884 * no_NO, no_NY, sr_SP, sr_YU 885 * 886 * They all use ISO8859-X encoding. 887 * 888 * For those "xx" langtags, some of them can be mapped to "xx.UTF-8", 889 * but others cannot. So we need to use the "xx" as the locale name. 890 * Those locales are: 891 * 892 * ar, ca, cs, da, et, fi, he, hu, ja, lt, lv, nl, no, pt, sh, th, tr 893 * 894 * Their encoding vary. They could be ISO8859-X or EUC or something else. 895 * So we don't perform code conversion for these langtags. 896 */ 897 static const char *non_utf8_langtag[] = { 898 "no-NO", "no-NY", "sr-SP", "sr-YU", 899 "ar", "ca", "cs", "da", "et", "fi", "he", "hu", "ja", 900 "lt", "lv", "nl", "no", "pt", "sh", "th", "tr", NULL}; 901 902 void 903 g11n_test_langtag(const char *lang, int server) 904 { 905 const char **lp; 906 907 if (datafellows & SSH_BUG_LOCALES_NOT_LANGTAGS) { 908 /* 909 * We negotiated with real locale name (not lang tag). 910 * We shouldn't expect UTF-8, thus shouldn't do code 911 * conversion. 912 */ 913 datafellows |= SSH_BUG_STRING_ENCODING; 914 return; 915 } 916 917 if (datafellows & SSH_BUG_STRING_ENCODING) { 918 if (server) { 919 /* 920 * Whatever bug exists in the client side, server 921 * side has nothing to do, since server has no way 922 * to know what actual encoding is used on the client 923 * side. For example, even if we negotiated with 924 * en_US, client locale could be en_US.ISO8859-X or 925 * en_US.UTF-8. 926 */ 927 return; 928 } 929 /* 930 * We are on the client side. We'll check with known 931 * locales to see if non-UTF8 characters could come in. 932 */ 933 for (lp = non_utf8_langtag; *lp != NULL; lp++) { 934 if (strcmp(lang, *lp) == 0) 935 break; 936 } 937 if (*lp == NULL) { 938 debug2("Server is expected to use UTF-8 locale"); 939 datafellows &= ~SSH_BUG_STRING_ENCODING; 940 } else { 941 /* 942 * Server is expected to use non-UTF8 encoding. 943 */ 944 debug2("Enforcing no code conversion: %s", lang); 945 } 946 } 947 } 948 949 /* 950 * Free all strings in the list and then free the list itself. We know that the 951 * list ends with a NULL pointer. 952 */ 953 void 954 g11n_freelist(char **list) 955 { 956 int i = 0; 957 958 while (list[i] != NULL) { 959 xfree(list[i]); 960 i++; 961 } 962 963 xfree(list); 964 }