locale/loadlocale.c

   1 /* Functions to read locale data files.
   2    Copyright (C) 1996-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   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    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <locale.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #ifdef _POSIX_MAPPED_FILES
  27 # include <sys/mman.h>
  28 #endif
  29 #include <sys/stat.h>
  30
  31 #include <not-cancel.h>
  32 #include "localeinfo.h"
  33
  34
  35 static const size_t _nl_category_num_items[] =
  36 {
  37 #define DEFINE_CATEGORY(category, category_name, items, a) \
  38   [category] = _NL_ITEM_INDEX (_NL_NUM_##category),
  39 #include "categories.def"
  40 #undef  DEFINE_CATEGORY
  41 };
  42
  43
  44 #define NO_PAREN(arg, rest...) arg, ##rest
  45
  46 /* The size of the array must be specified explicitly because some of
  47    the 'items' may be subarrays, which will cause the compiler to deduce
  48    an incorrect size from the initializer.  */
  49 #define DEFINE_CATEGORY(category, category_name, items, a) \
  50 static const enum value_type _nl_value_type_##category     \
  51   [_NL_ITEM_INDEX (_NL_NUM_##category)] = { NO_PAREN items };
  52 #define DEFINE_ELEMENT(element, element_name, optstd, type, rest...) \
  53   [_NL_ITEM_INDEX (element)] = type,
  54 #include "categories.def"
  55 #undef DEFINE_CATEGORY
  56
  57 static const enum value_type *const _nl_value_types[] =
  58 {
  59 #define DEFINE_CATEGORY(category, category_name, items, a) \
  60   [category] = _nl_value_type_##category,
  61 #include "categories.def"
  62 #undef DEFINE_CATEGORY
  63 };
  64
  65 /* Fill in LOCDATA->private for the LC_CTYPE category.  */
  66 static void
  67 _nl_intern_locale_data_fill_cache_ctype (struct __locale_data *locdata)
  68 {
  69   struct lc_ctype_data *data = locdata->private;
  70
  71   /* Default to no translation.  Assumes zero initialization of *data.  */
  72   memset (data->outdigit_bytes, 1, sizeof (data->outdigit_bytes));
  73
  74   for (int i = 0; i <= 9; ++i)
  75     {
  76       const char *digit
  77         = locdata->values[_NL_ITEM_INDEX (_NL_CTYPE_OUTDIGIT0_MB + i)].string;
  78       unsigned char len;
  79       if (digit[0] != '0' + i || digit[1] != '\0')
  80          {
  81            data->outdigit_translation_needed = true;
  82            len = strlen (locdata->values[_NL_ITEM_INDEX
  83                                          (_NL_CTYPE_OUTDIGIT0_MB + i)].string);
  84          }
  85       else
  86         len = 1;
  87       data->outdigit_bytes[i] = len;
  88       if (i == 0)
  89         data->outdigit_bytes_all_equal = len;
  90       else if (data->outdigit_bytes_all_equal != len)
  91         data->outdigit_bytes_all_equal = 0;
  92     }
  93 }
  94
  95 /* Updates data in LOCDATA->private for CATEGORY.  */
  96 static void
  97 _nl_intern_locale_data_fill_cache (int category, struct __locale_data *locdata)
  98 {
  99   switch (category)
 100     {
 101     case LC_CTYPE:
 102       _nl_intern_locale_data_fill_cache_ctype (locdata);
 103       break;
 104     }
 105 }
 106
 107 /* Returns the number of bytes allocated of struct __locale_data for
 108    CATEGORY.  */
 109 static size_t
 110 _nl_intern_locale_data_extra_size (int category)
 111 {
 112   switch (category)
 113     {
 114     case LC_CTYPE:
 115       return sizeof (struct lc_ctype_data);
 116     default:
 117       return 0;
 118     }
 119 }
 120
 121 struct __locale_data *
 122 _nl_intern_locale_data (int category, const void *data, size_t datasize)
 123 {
 124   const struct
 125     {
 126       unsigned int magic;
 127       unsigned int nstrings;
 128       unsigned int strindex[0];
 129     } *const filedata = data;
 130   struct __locale_data *newdata;
 131   size_t cnt;
 132
 133   if (__builtin_expect (datasize < sizeof *filedata, 0)
 134       || __builtin_expect (filedata->magic != LIMAGIC (category), 0))
 135     {
 136       /* Bad data file.  */
 137       __set_errno (EINVAL);
 138       return NULL;
 139     }
 140
 141   if (__builtin_expect (filedata->nstrings < _nl_category_num_items[category],
 142                         0)
 143       || (__builtin_expect (sizeof *filedata
 144                             + filedata->nstrings * sizeof (unsigned int)
 145                             >= datasize, 0)))
 146     {
 147       /* Insufficient data.  */
 148       __set_errno (EINVAL);
 149       return NULL;
 150     }
 151
 152   size_t base_size = (sizeof *newdata
 153                       + filedata->nstrings * sizeof (union locale_data_value));
 154   size_t extra_size = _nl_intern_locale_data_extra_size (category);
 155
 156   newdata = malloc (base_size + extra_size);
 157   if (newdata == NULL)
 158     return NULL;
 159
 160   newdata->filedata = (void *) filedata;
 161   newdata->filesize = datasize;
 162   if (extra_size == 0)
 163     newdata->private = NULL;
 164   else
 165     {
 166       newdata->private = (char *) newdata + base_size;
 167       memset (newdata->private, 0, extra_size);
 168     }
 169   newdata->usage_count = 0;
 170   newdata->use_translit = 0;
 171   newdata->nstrings = filedata->nstrings;
 172   for (cnt = 0; cnt < newdata->nstrings; ++cnt)
 173     {
 174       size_t idx = filedata->strindex[cnt];
 175       if (__glibc_unlikely (idx > (size_t) newdata->filesize))
 176         {
 177         puntdata:
 178           free (newdata);
 179           __set_errno (EINVAL);
 180           return NULL;
 181         }
 182
 183       /* Determine the type.  There is one special case: the LC_CTYPE
 184          category can have more elements than there are in the
 185          _nl_value_type_LC_XYZ array.  There are all pointers.  */
 186       switch (category)
 187         {
 188 #define CATTEST(cat) \
 189         case LC_##cat:                                          \
 190           if (cnt >= (sizeof (_nl_value_type_LC_##cat)          \
 191                       / sizeof (_nl_value_type_LC_##cat[0])))   \
 192             goto puntdata;                                      \
 193           break
 194           CATTEST (NUMERIC);
 195           CATTEST (TIME);
 196           CATTEST (COLLATE);
 197           CATTEST (MONETARY);
 198           CATTEST (MESSAGES);
 199           CATTEST (PAPER);
 200           CATTEST (NAME);
 201           CATTEST (ADDRESS);
 202           CATTEST (TELEPHONE);
 203           CATTEST (MEASUREMENT);
 204           CATTEST (IDENTIFICATION);
 205         default:
 206           assert (category == LC_CTYPE);
 207           break;
 208         }
 209
 210       if ((category == LC_CTYPE
 211            && cnt >= (sizeof (_nl_value_type_LC_CTYPE)
 212                       / sizeof (_nl_value_type_LC_CTYPE[0])))
 213           || __builtin_expect (_nl_value_types[category][cnt] != word, 1))
 214         newdata->values[cnt].string = newdata->filedata + idx;
 215       else
 216         {
 217           if (!LOCFILE_ALIGNED_P (idx))
 218             goto puntdata;
 219           newdata->values[cnt].word =
 220             *((const uint32_t *) (newdata->filedata + idx));
 221         }
 222     }
 223
 224   if (extra_size > 0)
 225     _nl_intern_locale_data_fill_cache (category, newdata);
 226
 227   return newdata;
 228 }
 229
 230 void
 231 _nl_load_locale (struct loaded_l10nfile *file, int category)
 232 {
 233   int fd;
 234   void *filedata;
 235   struct __stat64_t64 st;
 236   struct __locale_data *newdata;
 237   int save_err;
 238   int alloc = ld_mapped;
 239
 240   file->decided = 1;
 241   file->data = NULL;
 242
 243   fd = __open_nocancel (file->filename, O_RDONLY | O_CLOEXEC);
 244   if (__builtin_expect (fd, 0) < 0)
 245     /* Cannot open the file.  */
 246     return;
 247
 248   if (__glibc_unlikely (__fstat64_time64 (fd, &st) < 0))
 249     {
 250     puntfd:
 251       __close_nocancel_nostatus (fd);
 252       return;
 253     }
 254   if (__glibc_unlikely (S_ISDIR (st.st_mode)))
 255     {
 256       /* LOCALE/LC_foo is a directory; open LOCALE/LC_foo/SYS_LC_foo
 257            instead.  */
 258       char *newp;
 259       size_t filenamelen;
 260
 261       __close_nocancel_nostatus (fd);
 262
 263       filenamelen = strlen (file->filename);
 264       newp = (char *) alloca (filenamelen
 265                               + 5 + _nl_category_name_sizes[category] + 1);
 266       __mempcpy (__mempcpy (__mempcpy (newp, file->filename, filenamelen),
 267                             "/SYS_", 5), _nl_category_names_get (category),
 268                  _nl_category_name_sizes[category] + 1);
 269
 270       fd = __open_nocancel (newp, O_RDONLY | O_CLOEXEC);
 271       if (__builtin_expect (fd, 0) < 0)
 272         return;
 273
 274       if (__glibc_unlikely (__fstat64_time64 (fd, &st) < 0))
 275         goto puntfd;
 276     }
 277
 278   /* Map in the file's data.  */
 279   save_err = errno;
 280 #ifdef _POSIX_MAPPED_FILES
 281 # ifndef MAP_COPY
 282   /* Linux seems to lack read-only copy-on-write.  */
 283 #  define MAP_COPY MAP_PRIVATE
 284 # endif
 285 # ifndef MAP_FILE
 286   /* Some systems do not have this flag; it is superfluous.  */
 287 #  define MAP_FILE 0
 288 # endif
 289   filedata = __mmap ((caddr_t) 0, st.st_size,
 290                      PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
 291   if (__glibc_unlikely (filedata == MAP_FAILED))
 292     {
 293       filedata = NULL;
 294       if (__builtin_expect (errno, ENOSYS) == ENOSYS)
 295         {
 296 #endif  /* _POSIX_MAPPED_FILES */
 297           /* No mmap; allocate a buffer and read from the file.  */
 298           alloc = ld_malloced;
 299           filedata = malloc (st.st_size);
 300           if (filedata != NULL)
 301             {
 302               off_t to_read = st.st_size;
 303               ssize_t nread;
 304               char *p = (char *) filedata;
 305               while (to_read > 0)
 306                 {
 307                   nread = __read_nocancel (fd, p, to_read);
 308                   if (__builtin_expect (nread, 1) <= 0)
 309                     {
 310                       free (filedata);
 311                       if (nread == 0)
 312                         __set_errno (EINVAL); /* Bizarreness going on.  */
 313                       goto puntfd;
 314                     }
 315                   p += nread;
 316                   to_read -= nread;
 317                 }
 318               __set_errno (save_err);
 319             }
 320 #ifdef _POSIX_MAPPED_FILES
 321         }
 322     }
 323 #endif  /* _POSIX_MAPPED_FILES */
 324
 325   /* We have mapped the data, so we no longer need the descriptor.  */
 326   __close_nocancel_nostatus (fd);
 327
 328   if (__glibc_unlikely (filedata == NULL))
 329     /* We failed to map or read the data.  */
 330     return;
 331
 332   newdata = _nl_intern_locale_data (category, filedata, st.st_size);
 333   if (__glibc_unlikely (newdata == NULL))
 334     /* Bad data.  */
 335     {
 336 #ifdef _POSIX_MAPPED_FILES
 337       if (alloc == ld_mapped)
 338         __munmap ((caddr_t) filedata, st.st_size);
 339 #endif
 340       return;
 341     }
 342
 343   /* _nl_intern_locale_data leaves us these fields to initialize.  */
 344   newdata->name = NULL; /* This will be filled if necessary in findlocale.c. */
 345   newdata->alloc = alloc;
 346
 347   file->data = newdata;
 348 }
 349
 350 void
 351 _nl_unload_locale (int category, struct __locale_data *locale)
 352 {
 353   /* Deallocate locale->private.  */
 354   switch (category)
 355     {
 356     case LC_CTYPE:
 357       _nl_cleanup_ctype (locale);
 358       break;
 359     case LC_TIME:
 360       _nl_cleanup_time (locale);
 361       break;
 362     }
 363
 364   switch (__builtin_expect (locale->alloc, ld_mapped))
 365     {
 366     case ld_malloced:
 367       free ((void *) locale->filedata);
 368       break;
 369     case ld_mapped:
 370 #ifdef _POSIX_MAPPED_FILES
 371       __munmap ((caddr_t) locale->filedata, locale->filesize);
 372       break;
 373 #endif
 374     case ld_archive:            /* Nothing to do.  */
 375       break;
 376     }
 377
 378   if (__builtin_expect (locale->alloc, ld_mapped) != ld_archive)
 379     free ((char *) locale->name);
 380
 381   free (locale);
 382 }