locale/findlocale.c

   1 /* Copyright (C) 1996-2015 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <locale.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #ifdef _POSIX_MAPPED_FILES
  26 # include <sys/mman.h>
  27 #endif
  28
  29 #include "localeinfo.h"
  30 #include "../iconv/gconv_charset.h"
  31 #include "../iconv/gconv_int.h"
  32
  33
  34 #ifdef NL_CURRENT_INDIRECT
  35 # define DEFINE_CATEGORY(category, category_name, items, a) \
  36 extern struct __locale_data _nl_C_##category; \
  37 weak_extern (_nl_C_##category)
  38 # include "categories.def"
  39 # undef DEFINE_CATEGORY
  40
  41 /* Array indexed by category of pointers to _nl_C_CATEGORY slots.
  42    Elements are zero for categories whose data is never used.  */
  43 struct __locale_data *const _nl_C[] attribute_hidden =
  44   {
  45 # define DEFINE_CATEGORY(category, category_name, items, a) \
  46     [category] = &_nl_C_##category,
  47 # include "categories.def"
  48 # undef DEFINE_CATEGORY
  49   };
  50 #else
  51 # define _nl_C          (_nl_C_locobj.__locales)
  52 #endif
  53
  54
  55 /* For each category we keep a list of records for the locale files
  56    which are somehow addressed.  */
  57 struct loaded_l10nfile *_nl_locale_file_list[__LC_LAST];
  58
  59 const char _nl_default_locale_path[] attribute_hidden = LOCALEDIR;
  60
  61 /* Checks if the name is actually present, that is, not NULL and not
  62    empty.  */
  63 static inline int
  64 name_present (const char *name)
  65 {
  66   return name != NULL && name[0] != '\0';
  67 }
  68
  69 /* Checks that the locale name neither extremely long, nor contains a
  70    ".." path component (to prevent directory traversal).  */
  71 static inline int
  72 valid_locale_name (const char *name)
  73 {
  74   /* Not set.  */
  75   size_t namelen = strlen (name);
  76   /* Name too long.  The limit is arbitrary and prevents stack overflow
  77      issues later.  */
  78   if (__glibc_unlikely (namelen > 255))
  79     return 0;
  80   /* Directory traversal attempt.  */
  81   static const char slashdot[4] = {'/', '.', '.', '/'};
  82   if (__glibc_unlikely (__memmem (name, namelen,
  83                                   slashdot, sizeof (slashdot)) != NULL))
  84     return 0;
  85   if (namelen == 2 && __glibc_unlikely (name[0] == '.' && name [1] == '.'))
  86     return 0;
  87   if (namelen >= 3
  88       && __glibc_unlikely (((name[0] == '.'
  89                              && name[1] == '.'
  90                              && name[2] == '/')
  91                             || (name[namelen - 3] == '/'
  92                                 && name[namelen - 2] == '.'
  93                                 && name[namelen - 1] == '.'))))
  94     return 0;
  95   /* If there is a slash in the name, it must start with one.  */
  96   if (__glibc_unlikely (memchr (name, '/', namelen) != NULL) && name[0] != '/')
  97     return 0;
  98   return 1;
  99 }
 100
 101 struct __locale_data *
 102 internal_function
 103 _nl_find_locale (const char *locale_path, size_t locale_path_len,
 104                  int category, const char **name)
 105 {
 106   int mask;
 107   /* Name of the locale for this category.  */
 108   char *loc_name = (char *) *name;
 109   const char *language;
 110   const char *modifier;
 111   const char *territory;
 112   const char *codeset;
 113   const char *normalized_codeset;
 114   struct loaded_l10nfile *locale_file;
 115
 116   if (loc_name[0] == '\0')
 117     {
 118       /* The user decides which locale to use by setting environment
 119          variables.  */
 120       loc_name = getenv ("LC_ALL");
 121       if (!name_present (loc_name))
 122         loc_name = getenv (_nl_category_names.str
 123                         + _nl_category_name_idxs[category]);
 124       if (!name_present (loc_name))
 125         loc_name = getenv ("LANG");
 126       if (!name_present (loc_name))
 127         loc_name = (char *) _nl_C_name;
 128     }
 129
 130   /* We used to fall back to the C locale if the name contains a slash
 131      character '/', but we now check for directory traversal in
 132      valid_locale_name, so this is no longer necessary.  */
 133
 134   if (__builtin_expect (strcmp (loc_name, _nl_C_name), 1) == 0
 135       || __builtin_expect (strcmp (loc_name, _nl_POSIX_name), 1) == 0)
 136     {
 137       /* We need not load anything.  The needed data is contained in
 138          the library itself.  */
 139       *name = (char *) _nl_C_name;
 140       return _nl_C[category];
 141     }
 142   else if (!valid_locale_name (loc_name))
 143     {
 144       __set_errno (EINVAL);
 145       return NULL;
 146     }
 147
 148   *name = loc_name;
 149
 150   /* We really have to load some data.  First we try the archive,
 151      but only if there was no LOCPATH environment variable specified.  */
 152   if (__glibc_likely (locale_path == NULL))
 153     {
 154       struct __locale_data *data
 155         = _nl_load_locale_from_archive (category, name);
 156       if (__glibc_likely (data != NULL))
 157         return data;
 158
 159       /* Nothing in the archive with the given name.  Expanding it as
 160          an alias and retry.  */
 161       loc_name = (char *) _nl_expand_alias (*name);
 162       if (loc_name != NULL)
 163         {
 164           data = _nl_load_locale_from_archive (category,
 165                                                (const char **) &loc_name);
 166           if (__builtin_expect (data != NULL, 1))
 167             return data;
 168         }
 169
 170       /* Nothing in the archive.  Set the default path to search below.  */
 171       locale_path = _nl_default_locale_path;
 172       locale_path_len = sizeof _nl_default_locale_path;
 173     }
 174   else
 175     /* We really have to load some data.  First see whether the name is
 176        an alias.  Please note that this makes it impossible to have "C"
 177        or "POSIX" as aliases.  */
 178     loc_name = (char *) _nl_expand_alias (*name);
 179
 180   if (loc_name == NULL)
 181     /* It is no alias.  */
 182     loc_name = (char *) *name;
 183
 184   /* Make a writable copy of the locale name.  */
 185   loc_name = strdupa (loc_name);
 186
 187   /* LOCALE can consist of up to four recognized parts for the XPG syntax:
 188
 189                 language[_territory[.codeset]][@modifier]
 190
 191      Beside the first all of them are allowed to be missing.  If the
 192      full specified locale is not found, the less specific one are
 193      looked for.  The various part will be stripped off according to
 194      the following order:
 195                 (1) codeset
 196                 (2) normalized codeset
 197                 (3) territory
 198                 (4) modifier
 199    */
 200   mask = _nl_explode_name (loc_name, &language, &modifier, &territory,
 201                            &codeset, &normalized_codeset);
 202   if (mask == -1)
 203     /* Memory allocate problem.  */
 204     return NULL;
 205
 206   /* If exactly this locale was already asked for we have an entry with
 207      the complete name.  */
 208   locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category],
 209                                     locale_path, locale_path_len, mask,
 210                                     language, territory, codeset,
 211                                     normalized_codeset, modifier,
 212                                     _nl_category_names.str
 213                                     + _nl_category_name_idxs[category], 0);
 214
 215   if (locale_file == NULL)
 216     {
 217       /* Find status record for addressed locale file.  We have to search
 218          through all directories in the locale path.  */
 219       locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category],
 220                                         locale_path, locale_path_len, mask,
 221                                         language, territory, codeset,
 222                                         normalized_codeset, modifier,
 223                                         _nl_category_names.str
 224                                         + _nl_category_name_idxs[category], 1);
 225       if (locale_file == NULL)
 226         /* This means we are out of core.  */
 227         return NULL;
 228     }
 229
 230   /* The space for normalized_codeset is dynamically allocated.  Free it.  */
 231   if (mask & XPG_NORM_CODESET)
 232     free ((void *) normalized_codeset);
 233
 234   if (locale_file->decided == 0)
 235     _nl_load_locale (locale_file, category);
 236
 237   if (locale_file->data == NULL)
 238     {
 239       int cnt;
 240       for (cnt = 0; locale_file->successor[cnt] != NULL; ++cnt)
 241         {
 242           if (locale_file->successor[cnt]->decided == 0)
 243             _nl_load_locale (locale_file->successor[cnt], category);
 244           if (locale_file->successor[cnt]->data != NULL)
 245             break;
 246         }
 247       /* Move the entry we found (or NULL) to the first place of
 248          successors.  */
 249       locale_file->successor[0] = locale_file->successor[cnt];
 250       locale_file = locale_file->successor[cnt];
 251
 252       if (locale_file == NULL)
 253         return NULL;
 254     }
 255
 256   /* The LC_CTYPE category allows to check whether a locale is really
 257      usable.  If the locale name contains a charset name and the
 258      charset name used in the locale (present in the LC_CTYPE data) is
 259      not the same (after resolving aliases etc) we reject the locale
 260      since using it would irritate users expecting the charset named
 261      in the locale name.  */
 262   if (codeset != NULL)
 263     {
 264       /* Get the codeset information from the locale file.  */
 265       static const int codeset_idx[] =
 266         {
 267           [__LC_CTYPE] = _NL_ITEM_INDEX (CODESET),
 268           [__LC_NUMERIC] = _NL_ITEM_INDEX (_NL_NUMERIC_CODESET),
 269           [__LC_TIME] = _NL_ITEM_INDEX (_NL_TIME_CODESET),
 270           [__LC_COLLATE] = _NL_ITEM_INDEX (_NL_COLLATE_CODESET),
 271           [__LC_MONETARY] = _NL_ITEM_INDEX (_NL_MONETARY_CODESET),
 272           [__LC_MESSAGES] = _NL_ITEM_INDEX (_NL_MESSAGES_CODESET),
 273           [__LC_PAPER] = _NL_ITEM_INDEX (_NL_PAPER_CODESET),
 274           [__LC_NAME] = _NL_ITEM_INDEX (_NL_NAME_CODESET),
 275           [__LC_ADDRESS] = _NL_ITEM_INDEX (_NL_ADDRESS_CODESET),
 276           [__LC_TELEPHONE] = _NL_ITEM_INDEX (_NL_TELEPHONE_CODESET),
 277           [__LC_MEASUREMENT] = _NL_ITEM_INDEX (_NL_MEASUREMENT_CODESET),
 278           [__LC_IDENTIFICATION] = _NL_ITEM_INDEX (_NL_IDENTIFICATION_CODESET)
 279         };
 280       const struct __locale_data *data;
 281       const char *locale_codeset;
 282       char *clocale_codeset;
 283       char *ccodeset;
 284
 285       data = (const struct __locale_data *) locale_file->data;
 286       locale_codeset =
 287         (const char *) data->values[codeset_idx[category]].string;
 288       assert (locale_codeset != NULL);
 289       /* Note the length of the allocated memory: +3 for up to two slashes
 290          and the NUL byte.  */
 291       clocale_codeset = (char *) alloca (strlen (locale_codeset) + 3);
 292       strip (clocale_codeset, locale_codeset);
 293
 294       ccodeset = (char *) alloca (strlen (codeset) + 3);
 295       strip (ccodeset, codeset);
 296
 297       if (__gconv_compare_alias (upstr (ccodeset, ccodeset),
 298                                  upstr (clocale_codeset,
 299                                         clocale_codeset)) != 0)
 300         /* The codesets are not identical, don't use the locale.  */
 301         return NULL;
 302     }
 303
 304   /* Determine the locale name for which loading succeeded.  This
 305      information comes from the file name.  The form is
 306      <path>/<locale>/LC_foo.  We must extract the <locale> part.  */
 307   if (((const struct __locale_data *) locale_file->data)->name == NULL)
 308     {
 309       char *cp, *endp;
 310
 311       endp = strrchr (locale_file->filename, '/');
 312       cp = endp - 1;
 313       while (cp[-1] != '/')
 314         --cp;
 315       ((struct __locale_data *) locale_file->data)->name
 316         = __strndup (cp, endp - cp);
 317     }
 318
 319   /* Determine whether the user wants transliteration or not.  */
 320   if (modifier != NULL
 321       && __strcasecmp_l (modifier, "TRANSLIT", _nl_C_locobj_ptr) == 0)
 322     ((struct __locale_data *) locale_file->data)->use_translit = 1;
 323
 324   /* Increment the usage count.  */
 325   if (((const struct __locale_data *) locale_file->data)->usage_count
 326       < MAX_USAGE_COUNT)
 327     ++((struct __locale_data *) locale_file->data)->usage_count;
 328
 329   return (struct __locale_data *) locale_file->data;
 330 }
 331
 332
 333 /* Calling this function assumes the lock for handling global locale data
 334    is acquired.  */
 335 void
 336 internal_function
 337 _nl_remove_locale (int locale, struct __locale_data *data)
 338 {
 339   if (--data->usage_count == 0)
 340     {
 341       if (data->alloc != ld_archive)
 342         {
 343           /* First search the entry in the list of loaded files.  */
 344           struct loaded_l10nfile *ptr = _nl_locale_file_list[locale];
 345
 346           /* Search for the entry.  It must be in the list.  Otherwise it
 347              is a bug and we crash badly.  */
 348           while ((struct __locale_data *) ptr->data != data)
 349             ptr = ptr->next;
 350
 351           /* Mark the data as not available anymore.  So when the data has
 352              to be used again it is reloaded.  */
 353           ptr->decided = 0;
 354           ptr->data = NULL;
 355         }
 356
 357       /* This does the real work.  */
 358       _nl_unload_locale (data);
 359     }
 360 }