1 /** @file 2 Worker functions for the setlocale function. 3 4 Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials are licensed and made available under 6 the terms and conditions of the BSD License that accompanies this distribution. 7 The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license. 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 * Copyright (c) 1991, 1993 14 * The Regents of the University of California. All rights reserved. 15 * 16 * This code is derived from software contributed to Berkeley by 17 * Paul Borman at Krystal Technologies. 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions and the following disclaimer. 24 * 2. Redistributions in binary form must reproduce the above copyright 25 * notice, this list of conditions and the following disclaimer in the 26 * documentation and/or other materials provided with the distribution. 27 * 3. Neither the name of the University nor the names of its contributors 28 * may be used to endorse or promote products derived from this software 29 * without specific prior written permission. 30 * 31 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 32 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 33 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 34 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 35 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 39 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 40 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 41 * SUCH DAMAGE. 42 43 setlocale.c 8.1 (Berkeley) 7/4/93 44 * NetBSD: setlocale.c,v 1.50 2006/02/16 19:19:49 tnozaki Exp 45 **/ 46 #include <LibConfig.h> 47 #include <sys/EfiCdefs.h> 48 49 #if defined(_MSC_VER) 50 // Disable warnings about assignment within conditional expressions. 51 #pragma warning ( disable : 4706 ) 52 #endif 53 54 #define _CTYPE_PRIVATE 55 56 #include "namespace.h" 57 #include <sys/localedef.h> 58 #include <sys/types.h> 59 #include <sys/stat.h> 60 #include <assert.h> 61 #include <limits.h> 62 #include <ctype.h> 63 #define __SETLOCALE_SOURCE__ 64 #include <locale.h> 65 #include <paths.h> 66 #include <stdio.h> 67 #include <stdlib.h> 68 #include <string.h> 69 #include <unistd.h> 70 #include "rune.h" 71 #ifdef WITH_RUNE 72 #include "rune_local.h" 73 #else 74 #include "ctypeio.h" 75 #endif 76 77 #ifdef CITRUS 78 #include <citrus/citrus_namespace.h> 79 #include <citrus/citrus_region.h> 80 #include <citrus/citrus_lookup.h> 81 #include <citrus/citrus_bcs.h> 82 #else 83 #include "aliasname_local.h" 84 #define _lookup_alias(p, a, b, s, c) __unaliasname((p), (a), (b), (s)) 85 #define _bcs_strcasecmp(a, b) strcasecmp((a), (b)) 86 #endif 87 88 #define _LOCALE_SYM_FORCE "/force" 89 90 #ifndef WITH_RUNE 91 const char *_PathLocale = NULL; 92 #endif 93 94 /** Category names for getenv(). **/ 95 static const char *const categories[_LC_LAST] = { 96 "LC_ALL", 97 "LC_COLLATE", 98 "LC_CTYPE", 99 "LC_MONETARY", 100 "LC_NUMERIC", 101 "LC_TIME", 102 "LC_MESSAGES" 103 }; 104 105 /** Current locales for each category. **/ 106 static char current_categories[_LC_LAST][32] = { 107 "C", 108 "C", 109 "C", 110 "C", 111 "C", 112 "C", 113 "C" 114 }; 115 116 /* 117 * The locales we are going to try and load 118 */ 119 static char new_categories[_LC_LAST][32]; 120 121 static char current_locale_string[_LC_LAST * 33]; 122 123 static char *currentlocale(void); 124 static void revert_to_default(int); 125 static int force_locale_enable(int); 126 static int load_locale_sub(int, const char *, int); 127 static char *loadlocale(int); 128 static const char *__get_locale_env(int); 129 130 char * 131 __setlocale(int category, const char *locale) 132 { 133 int i, loadlocale_success; 134 size_t len; 135 const char *env, *r; 136 137 //if (issetugid() || 138 // (!_PathLocale && !(_PathLocale = getenv("PATH_LOCALE")))) 139 // _PathLocale = _PATH_LOCALE; 140 141 if (category < 0 || category >= _LC_LAST) 142 return (NULL); 143 144 if (!locale) 145 return (category ? 146 current_categories[category] : currentlocale()); 147 148 /* 149 * Default to the current locale for everything. 150 */ 151 for (i = 1; i < _LC_LAST; ++i) 152 (void)strncpyX(new_categories[i], current_categories[i], 153 sizeof(new_categories[i])); 154 155 /* 156 * Now go fill up new_categories from the locale argument 157 */ 158 if (!*locale) { 159 if (category == LC_ALL) { 160 for (i = 1; i < _LC_LAST; ++i) { 161 env = __get_locale_env(i); 162 (void)strncpyX(new_categories[i], env, 163 sizeof(new_categories[i])); 164 } 165 } 166 else { 167 env = __get_locale_env(category); 168 (void)strncpyX(new_categories[category], env, 169 sizeof(new_categories[category])); 170 } 171 } else if (category) { 172 (void)strncpyX(new_categories[category], locale, 173 sizeof(new_categories[category])); 174 } else { 175 if ((r = strchr(locale, '/')) == 0) { 176 for (i = 1; i < _LC_LAST; ++i) { 177 (void)strncpyX(new_categories[i], locale, 178 sizeof(new_categories[i])); 179 } 180 } else { 181 for (i = 1;;) { 182 _DIAGASSERT(*r == '/' || *r == 0); 183 _DIAGASSERT(*locale != 0); 184 if (*locale == '/') 185 return (NULL); /* invalid format. */ 186 len = r - locale; 187 if (len + 1 > sizeof(new_categories[i])) 188 return (NULL); /* too long */ 189 (void)memcpy(new_categories[i], locale, len); 190 new_categories[i][len] = '\0'; 191 if (*r == 0) 192 break; 193 _DIAGASSERT(*r == '/'); 194 if (*(locale = ++r) == 0) 195 /* slash followed by NUL */ 196 return (NULL); 197 /* skip until NUL or '/' */ 198 while (*r && *r != '/') 199 r++; 200 if (++i == _LC_LAST) 201 return (NULL); /* too many slashes. */ 202 } 203 if (i + 1 != _LC_LAST) 204 return (NULL); /* too few slashes. */ 205 } 206 } 207 208 if (category) 209 return (loadlocale(category)); 210 211 loadlocale_success = 0; 212 for (i = 1; i < _LC_LAST; ++i) { 213 if (loadlocale(i) != NULL) 214 loadlocale_success = 1; 215 } 216 217 /* 218 * If all categories failed, return NULL; we don't need to back 219 * changes off, since none happened. 220 */ 221 if (!loadlocale_success) 222 return NULL; 223 224 return (currentlocale()); 225 } 226 227 static char * 228 currentlocale() 229 { 230 int i; 231 232 (void)strncpyX(current_locale_string, current_categories[1], 233 sizeof(current_locale_string)); 234 235 for (i = 2; i < _LC_LAST; ++i) 236 if (strcmp(current_categories[1], current_categories[i])) { 237 (void)snprintf(current_locale_string, 238 sizeof(current_locale_string), "%s/%s/%s/%s/%s/%s", 239 current_categories[1], current_categories[2], 240 current_categories[3], current_categories[4], 241 current_categories[5], current_categories[6]); 242 break; 243 } 244 return (current_locale_string); 245 } 246 247 static void 248 revert_to_default(int category) 249 { 250 switch (category) { 251 case LC_CTYPE: 252 #ifdef WITH_RUNE 253 (void)_xpg4_setrunelocale("C"); 254 (void)__runetable_to_netbsd_ctype("C"); 255 #else 256 if (_cClass != _C_CharClassTable) { 257 /* LINTED const castaway */ 258 free((void *)_cClass); 259 _cClass = _C_CharClassTable; 260 } 261 if (_uConvT != _C_ToUpperTable) { 262 /* LINTED const castaway */ 263 free((void *)_uConvT); 264 _uConvT = _C_ToUpperTable; 265 } 266 if (_lConvT != _C_ToLowerTable) { 267 /* LINTED const castaway */ 268 free((void *)_lConvT); 269 _lConvT = _C_ToLowerTable; 270 } 271 #endif 272 break; 273 case LC_MESSAGES: 274 case LC_COLLATE: 275 case LC_MONETARY: 276 case LC_NUMERIC: 277 case LC_TIME: 278 break; 279 } 280 } 281 282 static int 283 force_locale_enable(int category) 284 { 285 revert_to_default(category); 286 287 return 0; 288 } 289 290 static int 291 load_locale_sub( 292 int category, 293 const char *locname, 294 int isspecial 295 ) 296 { 297 char name[PATH_MAX]; 298 299 /* check for the default locales */ 300 if (!strcmp(new_categories[category], "C") || 301 !strcmp(new_categories[category], "POSIX")) { 302 revert_to_default(category); 303 return 0; 304 } 305 306 /* check whether special symbol */ 307 if (isspecial && _bcs_strcasecmp(locname, _LOCALE_SYM_FORCE) == 0) 308 return force_locale_enable(category); 309 310 /* sanity check */ 311 if (strchr(locname, '/') != NULL) 312 return -1; 313 314 (void)snprintf(name, sizeof(name), "%s/%s/%s", 315 _PathLocale, locname, categories[category]); 316 317 switch (category) { 318 case LC_CTYPE: 319 #ifdef WITH_RUNE 320 if (_xpg4_setrunelocale(__UNCONST(locname))) 321 return -1; 322 if (__runetable_to_netbsd_ctype(locname)) { 323 /* very unfortunate, but need to go to "C" locale */ 324 revert_to_default(category); 325 return -1; 326 } 327 #else 328 if (!__loadctype(name)) 329 return -1; 330 #endif 331 break; 332 333 case LC_MESSAGES: 334 /* 335 * XXX we don't have LC_MESSAGES support yet, 336 * but catopen may use the value of LC_MESSAGES category. 337 * so return successfully if locale directory is present. 338 */ 339 (void)snprintf(name, sizeof(name), "%s/%s", 340 _PathLocale, locname); 341 /* local */ 342 { 343 struct stat st; 344 if (stat(name, &st) < 0) 345 return -1; 346 if (!S_ISDIR(st.st_mode)) 347 return -1; 348 } 349 break; 350 351 case LC_COLLATE: 352 case LC_MONETARY: 353 case LC_NUMERIC: 354 case LC_TIME: 355 return -1; 356 } 357 358 return 0; 359 } 360 361 static char * 362 loadlocale(int category) 363 { 364 //char aliaspath[PATH_MAX], loccat[PATH_MAX], buf[PATH_MAX]; 365 //const char *alias; 366 367 _DIAGASSERT(0 < category && category < _LC_LAST); 368 369 if (strcmp(new_categories[category], current_categories[category]) == 0) 370 return (current_categories[category]); 371 372 /* (1) non-aliased file */ 373 if (!load_locale_sub(category, new_categories[category], 0)) 374 goto success; 375 376 ///* (2) lookup locname/catname type alias */ 377 //(void)snprintf(aliaspath, sizeof(aliaspath), 378 // "%s/" _LOCALE_ALIAS_NAME, _PathLocale); 379 //(void)snprintf(loccat, sizeof(loccat), "%s/%s", 380 // new_categories[category], categories[category]); 381 //alias = _lookup_alias(aliaspath, loccat, buf, sizeof(buf), 382 // _LOOKUP_CASE_SENSITIVE); 383 //if (!load_locale_sub(category, alias, 1)) 384 // goto success; 385 386 ///* (3) lookup locname type alias */ 387 //alias = _lookup_alias(aliaspath, new_categories[category], 388 // buf, sizeof(buf), _LOOKUP_CASE_SENSITIVE); 389 //if (!load_locale_sub(category, alias, 1)) 390 // goto success; 391 392 return NULL; 393 394 success: 395 (void)strncpyX(current_categories[category], 396 new_categories[category], 397 sizeof(current_categories[category])); 398 return current_categories[category]; 399 } 400 401 static const char * 402 __get_locale_env(int category) 403 { 404 const char *env; 405 406 //_DIAGASSERT(category != LC_ALL); 407 408 ///* 1. check LC_ALL. */ 409 //env = getenv(categories[0]); 410 411 ///* 2. check LC_* */ 412 //if (!env || !*env) 413 // env = getenv(categories[category]); 414 415 ///* 3. check LANG */ 416 //if (!env || !*env) 417 // env = getenv("LANG"); 418 419 ///* 4. if none is set, fall to "C" */ 420 //if (!env || !*env || strchr(env, '/')) 421 env = "C"; 422 423 return env; 424 } 425
