locale/loadlocale.c

   1 /* Functions to read locale data files.
   2    Copyright (C) 1996-2004, 2005, 2006, 2010, 2011 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <locale.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #ifdef _POSIX_MAPPED_FILES
  29 # include <sys/mman.h>
  30 #endif
  31 #include <sys/stat.h>
  32
  33 #include <not-cancel.h>
  34 #include "localeinfo.h"
  35
  36
  37 static const size_t _nl_category_num_items[] =
  38 {
  39 #define DEFINE_CATEGORY(category, category_name, items, a) \
  40   [category] = _NL_ITEM_INDEX (_NL_NUM_##category),
  41 #include "categories.def"
  42 #undef  DEFINE_CATEGORY
  43 };
  44
  45
  46 #define NO_PAREN(arg, rest...) arg, ##rest
  47
  48 #define DEFINE_CATEGORY(category, category_name, items, a) \
  49 static const enum value_type _nl_value_type_##category[] = { NO_PAREN items };
  50 #define DEFINE_ELEMENT(element, element_name, optstd, type, rest...) \
  51   [_NL_ITEM_INDEX (element)] = type,
  52 #include "categories.def"
  53 #undef DEFINE_CATEGORY
  54
  55 static const enum value_type *const _nl_value_types[] =
  56 {
  57 #define DEFINE_CATEGORY(category, category_name, items, a) \
  58   [category] = _nl_value_type_##category,
  59 #include "categories.def"
  60 #undef DEFINE_CATEGORY
  61 };
  62
  63
  64 struct __locale_data *
  65 internal_function
  66 _nl_intern_locale_data (int category, const void *data, size_t datasize)
  67 {
  68   const struct
  69     {
  70       unsigned int magic;
  71       unsigned int nstrings;
  72       unsigned int strindex[0];
  73     } *const filedata = data;
  74   struct __locale_data *newdata;
  75   size_t cnt;
  76
  77   if (__builtin_expect (datasize < sizeof *filedata, 0)
  78       || __builtin_expect (filedata->magic != LIMAGIC (category), 0))
  79     {
  80       /* Bad data file.  */
  81       __set_errno (EINVAL);
  82       return NULL;
  83     }
  84
  85   if (__builtin_expect (filedata->nstrings < _nl_category_num_items[category],
  86                         0)
  87       || (__builtin_expect (sizeof *filedata
  88                             + filedata->nstrings * sizeof (unsigned int)
  89                             >= datasize, 0)))
  90     {
  91       /* Insufficient data.  */
  92       __set_errno (EINVAL);
  93       return NULL;
  94     }
  95
  96   newdata = malloc (sizeof *newdata
  97                     + filedata->nstrings * sizeof (union locale_data_value));
  98   if (newdata == NULL)
  99     return NULL;
 100
 101   newdata->filedata = (void *) filedata;
 102   newdata->filesize = datasize;
 103   newdata->private.data = NULL;
 104   newdata->private.cleanup = NULL;
 105   newdata->usage_count = 0;
 106   newdata->use_translit = 0;
 107   newdata->nstrings = filedata->nstrings;
 108   for (cnt = 0; cnt < newdata->nstrings; ++cnt)
 109     {
 110       size_t idx = filedata->strindex[cnt];
 111       if (__builtin_expect (idx > (size_t) newdata->filesize, 0))
 112         {
 113         puntdata:
 114           free (newdata);
 115           __set_errno (EINVAL);
 116           return NULL;
 117         }
 118
 119       /* Determine the type.  There is one special case: the LC_CTYPE
 120          category can have more elements than there are in the
 121          _nl_value_type_LC_XYZ array.  There are all pointers.  */
 122       switch (category)
 123         {
 124 #define CATTEST(cat) \
 125         case LC_##cat:                                                        \
 126           assert (cnt < (sizeof (_nl_value_type_LC_##cat)                     \
 127                          / sizeof (_nl_value_type_LC_##cat[0])));             \
 128           break
 129           CATTEST (NUMERIC);
 130           CATTEST (TIME);
 131           CATTEST (COLLATE);
 132           CATTEST (MONETARY);
 133           CATTEST (MESSAGES);
 134           CATTEST (PAPER);
 135           CATTEST (NAME);
 136           CATTEST (ADDRESS);
 137           CATTEST (TELEPHONE);
 138           CATTEST (MEASUREMENT);
 139           CATTEST (IDENTIFICATION);
 140         default:
 141           assert (category == LC_CTYPE);
 142           break;
 143         }
 144
 145       if ((category == LC_CTYPE
 146            && cnt >= (sizeof (_nl_value_type_LC_CTYPE)
 147                       / sizeof (_nl_value_type_LC_CTYPE[0])))
 148           || __builtin_expect (_nl_value_types[category][cnt] != word, 1))
 149         newdata->values[cnt].string = newdata->filedata + idx;
 150       else
 151         {
 152           if (idx % __alignof__ (u_int32_t) != 0)
 153             goto puntdata;
 154           newdata->values[cnt].word =
 155             *((const u_int32_t *) (newdata->filedata + idx));
 156         }
 157     }
 158
 159   return newdata;
 160 }
 161
 162 void
 163 internal_function
 164 _nl_load_locale (struct loaded_l10nfile *file, int category)
 165 {
 166   int fd;
 167   void *filedata;
 168   struct stat64 st;
 169   struct __locale_data *newdata;
 170   int save_err;
 171   int alloc = ld_mapped;
 172
 173   file->decided = 1;
 174   file->data = NULL;
 175
 176   fd = open_not_cancel_2 (file->filename, O_RDONLY | O_CLOEXEC);
 177   if (__builtin_expect (fd, 0) < 0)
 178     /* Cannot open the file.  */
 179     return;
 180
 181   if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
 182     {
 183     puntfd:
 184       close_not_cancel_no_status (fd);
 185       return;
 186     }
 187   if (__builtin_expect (S_ISDIR (st.st_mode), 0))
 188     {
 189       /* LOCALE/LC_foo is a directory; open LOCALE/LC_foo/SYS_LC_foo
 190            instead.  */
 191       char *newp;
 192       size_t filenamelen;
 193
 194       close_not_cancel_no_status (fd);
 195
 196       filenamelen = strlen (file->filename);
 197       newp = (char *) alloca (filenamelen
 198                               + 5 + _nl_category_name_sizes[category] + 1);
 199       __mempcpy (__mempcpy (__mempcpy (newp, file->filename, filenamelen),
 200                             "/SYS_", 5),
 201                  _nl_category_names.str + _nl_category_name_idxs[category],
 202                  _nl_category_name_sizes[category] + 1);
 203
 204       fd = open_not_cancel_2 (newp, O_RDONLY | O_CLOEXEC);
 205       if (__builtin_expect (fd, 0) < 0)
 206         return;
 207
 208       if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
 209         goto puntfd;
 210     }
 211
 212   /* Map in the file's data.  */
 213   save_err = errno;
 214 #ifdef _POSIX_MAPPED_FILES
 215 # ifndef MAP_COPY
 216   /* Linux seems to lack read-only copy-on-write.  */
 217 #  define MAP_COPY MAP_PRIVATE
 218 # endif
 219 # ifndef MAP_FILE
 220   /* Some systems do not have this flag; it is superfluous.  */
 221 #  define MAP_FILE 0
 222 # endif
 223   filedata = __mmap ((caddr_t) 0, st.st_size,
 224                      PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
 225   if (__builtin_expect (filedata == MAP_FAILED, 0))
 226     {
 227       filedata = NULL;
 228       if (__builtin_expect (errno, ENOSYS) == ENOSYS)
 229         {
 230 #endif  /* _POSIX_MAPPED_FILES */
 231           /* No mmap; allocate a buffer and read from the file.  */
 232           alloc = ld_malloced;
 233           filedata = malloc (st.st_size);
 234           if (filedata != NULL)
 235             {
 236               off_t to_read = st.st_size;
 237               ssize_t nread;
 238               char *p = (char *) filedata;
 239               while (to_read > 0)
 240                 {
 241                   nread = read_not_cancel (fd, p, to_read);
 242                   if (__builtin_expect (nread, 1) <= 0)
 243                     {
 244                       free (filedata);
 245                       if (nread == 0)
 246                         __set_errno (EINVAL); /* Bizarreness going on.  */
 247                       goto puntfd;
 248                     }
 249                   p += nread;
 250                   to_read -= nread;
 251                 }
 252               __set_errno (save_err);
 253             }
 254 #ifdef _POSIX_MAPPED_FILES
 255         }
 256     }
 257 #endif  /* _POSIX_MAPPED_FILES */
 258
 259   /* We have mapped the data, so we no longer need the descriptor.  */
 260   close_not_cancel_no_status (fd);
 261
 262   if (__builtin_expect (filedata == NULL, 0))
 263     /* We failed to map or read the data.  */
 264     return;
 265
 266   newdata = _nl_intern_locale_data (category, filedata, st.st_size);
 267   if (__builtin_expect (newdata == NULL, 0))
 268     /* Bad data.  */
 269     {
 270 #ifdef _POSIX_MAPPED_FILES
 271       if (alloc == ld_mapped)
 272         __munmap ((caddr_t) filedata, st.st_size);
 273 #endif
 274       return;
 275     }
 276
 277   /* _nl_intern_locale_data leaves us these fields to initialize.  */
 278   newdata->name = NULL; /* This will be filled if necessary in findlocale.c. */
 279   newdata->alloc = alloc;
 280
 281   file->data = newdata;
 282 }
 283
 284 void
 285 internal_function
 286 _nl_unload_locale (struct __locale_data *locale)
 287 {
 288   if (locale->private.cleanup)
 289     (*locale->private.cleanup) (locale);
 290
 291   switch (__builtin_expect (locale->alloc, ld_mapped))
 292     {
 293     case ld_malloced:
 294       free ((void *) locale->filedata);
 295       break;
 296     case ld_mapped:
 297 #ifdef _POSIX_MAPPED_FILES
 298       __munmap ((caddr_t) locale->filedata, locale->filesize);
 299       break;
 300 #endif
 301     case ld_archive:            /* Nothing to do.  */
 302       break;
 303     }
 304
 305   if (__builtin_expect (locale->alloc, ld_mapped) != ld_archive)
 306     free ((char *) locale->name);
 307
 308   free (locale);
 309 }