locale/FreeBSD/setlocale.c

   1 /*
   2  * Copyright (c) 1996 - 2002 FreeBSD Project
   3  * Copyright (c) 1991, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Paul Borman at Krystal Technologies.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #if defined(LIBC_SCCS) && !defined(lint)
  35 static char sccsid[] = "@(#)setlocale.c 8.1 (Berkeley) 7/4/93";
  36 #endif /* LIBC_SCCS and not lint */
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD: src/lib/libc/locale/setlocale.c,v 1.51 2007/01/09 00:28:00 imp Exp $");
  39
  40 #include "xlocale_private.h"
  41
  42 #include <sys/types.h>
  43 #include <sys/stat.h>
  44 #include <errno.h>
  45 #include <limits.h>
  46 #include <locale.h>
  47 #include <paths.h>      /* for _PATH_LOCALE */
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <unistd.h>
  51 #include <fcntl.h>
  52 #include "collate.h"
  53 #include "lmonetary.h"  /* for __monetary_load_locale() */
  54 #include "lnumeric.h"   /* for __numeric_load_locale() */
  55 #include "lmessages.h"  /* for __messages_load_locale() */
  56 #include "setlocale.h"
  57 #include "ldpart.h"
  58 #include "timelocal.h" /* for __time_load_locale() */
  59
  60 /*
  61  * Category names for getenv()
  62  */
  63 static const char * const categories[_LC_LAST] = {
  64     "LC_ALL",
  65     "LC_COLLATE",
  66     "LC_CTYPE",
  67     "LC_MONETARY",
  68     "LC_NUMERIC",
  69     "LC_TIME",
  70     "LC_MESSAGES",
  71 };
  72
  73 /*
  74  * Current locales for each category
  75  */
  76 static char current_categories[_LC_LAST][ENCODING_LEN + 1] = {
  77     "C",
  78     "C",
  79     "C",
  80     "C",
  81     "C",
  82     "C",
  83     "C",
  84 };
  85
  86 /*
  87  * Path to locale storage directory
  88  */
  89 char    *_PathLocale;
  90
  91 /*
  92  * The locales we are going to try and load
  93  */
  94 static char new_categories[_LC_LAST][ENCODING_LEN + 1];
  95 static char saved_categories[_LC_LAST][ENCODING_LEN + 1];
  96
  97 static char     *currentlocale(void);
  98 static char     *loadlocale(int);
  99 __private_extern__ const char *__get_locale_env(int);
 100
 101 #define UNLOCK_AND_RETURN(x)    {XL_UNLOCK(&__global_locale); return (x);}
 102
 103 char *
 104 setlocale(category, locale)
 105         int category;
 106         const char *locale;
 107 {
 108         int i, j, len, saverr, save__numeric_fp_cvt;
 109         const char *env, *r;
 110         locale_t save__lc_numeric_loc;
 111
 112         if (category < LC_ALL || category >= _LC_LAST) {
 113                 errno = EINVAL;
 114                 return (NULL);
 115         }
 116
 117         if (locale == NULL)
 118                 return (category != LC_ALL ?
 119                     current_categories[category] : currentlocale());
 120
 121         XL_LOCK(&__global_locale);
 122         /*
 123          * Default to the current locale for everything.
 124          */
 125         for (i = 1; i < _LC_LAST; ++i)
 126                 (void)strcpy(new_categories[i], current_categories[i]);
 127
 128         /*
 129          * Now go fill up new_categories from the locale argument
 130          */
 131         if (!*locale) {
 132                 if (category == LC_ALL) {
 133                         for (i = 1; i < _LC_LAST; ++i) {
 134                                 env = __get_locale_env(i);
 135                                 if (strlen(env) > ENCODING_LEN) {
 136                                         errno = EINVAL;
 137                                         UNLOCK_AND_RETURN (NULL);
 138                                 }
 139                                 (void)strcpy(new_categories[i], env);
 140                         }
 141                 } else {
 142                         env = __get_locale_env(category);
 143                         if (strlen(env) > ENCODING_LEN) {
 144                                 errno = EINVAL;
 145                                 UNLOCK_AND_RETURN (NULL);
 146                         }
 147                         (void)strcpy(new_categories[category], env);
 148                 }
 149         } else if (category != LC_ALL) {
 150                 if (strlen(locale) > ENCODING_LEN) {
 151                         errno = EINVAL;
 152                         UNLOCK_AND_RETURN (NULL);
 153                 }
 154                 (void)strcpy(new_categories[category], locale);
 155         } else {
 156                 if ((r = strchr(locale, '/')) == NULL) {
 157                         if (strlen(locale) > ENCODING_LEN) {
 158                                 errno = EINVAL;
 159                                 UNLOCK_AND_RETURN (NULL);
 160                         }
 161                         for (i = 1; i < _LC_LAST; ++i)
 162                                 (void)strcpy(new_categories[i], locale);
 163                 } else {
 164                         for (i = 1; r[1] == '/'; ++r)
 165                                 ;
 166                         if (!r[1]) {
 167                                 errno = EINVAL;
 168                                 UNLOCK_AND_RETURN (NULL);       /* Hmm, just slashes... */
 169                         }
 170                         do {
 171                                 if (i == _LC_LAST)
 172                                         break;  /* Too many slashes... */
 173                                 if ((len = r - locale) > ENCODING_LEN) {
 174                                         errno = EINVAL;
 175                                         UNLOCK_AND_RETURN (NULL);
 176                                 }
 177                                 (void)strlcpy(new_categories[i], locale,
 178                                               len + 1);
 179                                 i++;
 180                                 while (*r == '/')
 181                                         r++;
 182                                 locale = r;
 183                                 while (*r && *r != '/')
 184                                         r++;
 185                         } while (*locale);
 186                         while (i < _LC_LAST) {
 187                                 (void)strcpy(new_categories[i],
 188                                              new_categories[i-1]);
 189                                 i++;
 190                         }
 191                 }
 192         }
 193
 194         if (category != LC_ALL)
 195                 UNLOCK_AND_RETURN (loadlocale(category));
 196
 197         save__numeric_fp_cvt = __global_locale.__numeric_fp_cvt;
 198         save__lc_numeric_loc = __global_locale.__lc_numeric_loc;
 199         XL_RETAIN(save__lc_numeric_loc);
 200         for (i = 1; i < _LC_LAST; ++i) {
 201                 (void)strcpy(saved_categories[i], current_categories[i]);
 202                 if (loadlocale(i) == NULL) {
 203                         saverr = errno;
 204                         for (j = 1; j < i; j++) {
 205                                 (void)strcpy(new_categories[j],
 206                                              saved_categories[j]);
 207                                 if (loadlocale(j) == NULL) {
 208                                         (void)strcpy(new_categories[j], "C");
 209                                         (void)loadlocale(j);
 210                                 }
 211                         }
 212                         __global_locale.__numeric_fp_cvt = save__numeric_fp_cvt;
 213                         __global_locale.__lc_numeric_loc = save__lc_numeric_loc;
 214                         XL_RELEASE(save__lc_numeric_loc);
 215                         errno = saverr;
 216                         UNLOCK_AND_RETURN (NULL);
 217                 }
 218         }
 219         XL_RELEASE(save__lc_numeric_loc);
 220         UNLOCK_AND_RETURN (currentlocale());
 221 }
 222
 223 static char *
 224 currentlocale()
 225 {
 226         int i;
 227
 228         size_t bufsiz = _LC_LAST * (ENCODING_LEN + 1/*"/"*/ + 1);
 229         static char *current_locale_string = NULL;
 230
 231         if (current_locale_string == NULL) {
 232                 current_locale_string = malloc(bufsiz);
 233                 if (current_locale_string == NULL) {
 234                         return NULL;
 235                 }
 236         }
 237
 238         (void)strlcpy(current_locale_string, current_categories[1], bufsiz);
 239
 240         for (i = 2; i < _LC_LAST; ++i)
 241                 if (strcmp(current_categories[1], current_categories[i])) {
 242                         for (i = 2; i < _LC_LAST; ++i) {
 243                                 (void)strcat(current_locale_string, "/");
 244                                 (void)strcat(current_locale_string,
 245                                              current_categories[i]);
 246                         }
 247                         break;
 248                 }
 249         return (current_locale_string);
 250 }
 251
 252 static char *
 253 loadlocale(category)
 254         int category;
 255 {
 256         char *new = new_categories[category];
 257         char *old = current_categories[category];
 258         int (*func)(const char *, locale_t);
 259         int saved_errno;
 260
 261         if ((new[0] == '.' &&
 262              (new[1] == '\0' || (new[1] == '.' && new[2] == '\0'))) ||
 263             strchr(new, '/') != NULL) {
 264                 errno = EINVAL;
 265                 return (NULL);
 266         }
 267
 268         saved_errno = errno;
 269         errno = __detect_path_locale();
 270         if (errno != 0)
 271                 return (NULL);
 272         errno = saved_errno;
 273
 274         switch (category) {
 275         case LC_CTYPE:
 276                 func = __wrap_setrunelocale;
 277                 break;
 278         case LC_COLLATE:
 279                 func = __collate_load_tables;
 280                 break;
 281         case LC_TIME:
 282                 func = __time_load_locale;
 283                 break;
 284         case LC_NUMERIC:
 285                 func = __numeric_load_locale;
 286                 break;
 287         case LC_MONETARY:
 288                 func = __monetary_load_locale;
 289                 break;
 290         case LC_MESSAGES:
 291                 func = __messages_load_locale;
 292                 break;
 293         default:
 294                 errno = EINVAL;
 295                 return (NULL);
 296         }
 297
 298         if (strcmp(new, old) == 0)
 299                 return (old);
 300
 301         if (func(new, &__global_locale) != _LDP_ERROR) {
 302                 (void)strcpy(old, new);
 303                 switch (category) {
 304                 case LC_CTYPE:
 305                         if (__global_locale.__numeric_fp_cvt == LC_NUMERIC_FP_SAME_LOCALE)
 306                                 __global_locale.__numeric_fp_cvt = LC_NUMERIC_FP_UNINITIALIZED;
 307                         break;
 308                 case LC_NUMERIC:
 309                         __global_locale.__numeric_fp_cvt = LC_NUMERIC_FP_UNINITIALIZED;
 310                         XL_RELEASE(__global_locale.__lc_numeric_loc);
 311                         __global_locale.__lc_numeric_loc = NULL;
 312                         break;
 313                 }
 314                 return (old);
 315         }
 316
 317         return (NULL);
 318 }
 319
 320 __private_extern__ const char *
 321 __get_locale_env(category)
 322         int category;
 323 {
 324         const char *env;
 325
 326         /* 1. check LC_ALL. */
 327         env = getenv(categories[0]);
 328
 329         /* 2. check LC_* */
 330         if (env == NULL || !*env)
 331                 env = getenv(categories[category]);
 332
 333         /* 3. check LANG */
 334         if (env == NULL || !*env)
 335                 env = getenv("LANG");
 336
 337         /* 4. if none is set, fall to "C" */
 338         if (env == NULL || !*env)
 339                 env = "C";
 340
 341         return (env);
 342 }
 343
 344 /*
 345  * Detect locale storage location and store its value to _PathLocale variable
 346  */
 347 __private_extern__ int
 348 __detect_path_locale(void)
 349 {
 350         if (_PathLocale == NULL) {
 351                 char *p = getenv("PATH_LOCALE");
 352
 353                 if (p != NULL && !issetugid()) {
 354                         if (strlen(p) + 1/*"/"*/ + ENCODING_LEN +
 355                             1/*"/"*/ + CATEGORY_LEN >= PATH_MAX)
 356                                 return (ENAMETOOLONG);
 357                         _PathLocale = strdup(p);
 358                         if (_PathLocale == NULL)
 359                                 return (errno == 0 ? ENOMEM : errno);
 360                 } else
 361                         _PathLocale = _PATH_LOCALE;
 362         }
 363         return (0);
 364 }
 365
 366 __private_extern__ int
 367 __open_path_locale(const char *subpath)
 368 {
 369         char filename[PATH_MAX];
 370         int fd;
 371
 372         strcpy(filename, _PathLocale);
 373         strcat(filename, "/");
 374         strcat(filename, subpath);
 375         fd = _open(filename, O_RDONLY);
 376         if (fd >= 0) {
 377                 return fd;
 378         }
 379
 380         strcpy(filename, _PATH_LOCALE);
 381         strcat(filename, "/");
 382         strcat(filename, subpath);
 383         fd = _open(filename, O_RDONLY);
 384         if (fd >= 0) {
 385                 return fd;
 386         }
 387
 388         strcpy(filename, "/usr/local/share/locale");
 389         strcat(filename, "/");
 390         strcat(filename, subpath);
 391         return _open(filename, O_RDONLY);
 392 }
 393