iconv/gconv_cache.c

   1 /* Cache handling for iconv modules.
   2    Copyright (C) 2001-2018 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 2001.
   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, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <dlfcn.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/mman.h>
  27 #include <sys/stat.h>
  28
  29 #include <gconv_int.h>
  30 #include <iconvconfig.h>
  31 #include <not-cancel.h>
  32
  33 #include "../intl/hash-string.h"
  34
  35 static void *gconv_cache;
  36 static size_t cache_size;
  37 static int cache_malloced;
  38
  39
  40 void *
  41 __gconv_get_cache (void)
  42 {
  43   return gconv_cache;
  44 }
  45
  46
  47 int
  48 __gconv_load_cache (void)
  49 {
  50   int fd;
  51   struct stat64 st;
  52   struct gconvcache_header *header;
  53
  54   /* We cannot use the cache if the GCONV_PATH environment variable is
  55      set.  */
  56   __gconv_path_envvar = getenv ("GCONV_PATH");
  57   if (__gconv_path_envvar != NULL)
  58     return -1;
  59
  60   /* See whether the cache file exists.  */
  61   fd = __open_nocancel (GCONV_MODULES_CACHE, O_RDONLY, 0);
  62   if (__builtin_expect (fd, 0) == -1)
  63     /* Not available.  */
  64     return -1;
  65
  66   /* Get information about the file.  */
  67   if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0
  68       /* We do not have to start looking at the file if it cannot contain
  69          at least the cache header.  */
  70       || (size_t) st.st_size < sizeof (struct gconvcache_header))
  71     {
  72     close_and_exit:
  73       __close_nocancel_nostatus (fd);
  74       return -1;
  75     }
  76
  77   /* Make the file content available.  */
  78   cache_size = st.st_size;
  79 #ifdef _POSIX_MAPPED_FILES
  80   gconv_cache = __mmap (NULL, cache_size, PROT_READ, MAP_SHARED, fd, 0);
  81   if (__glibc_unlikely (gconv_cache == MAP_FAILED))
  82 #endif
  83     {
  84       size_t already_read;
  85
  86       gconv_cache = malloc (cache_size);
  87       if (gconv_cache == NULL)
  88         goto close_and_exit;
  89
  90       already_read = 0;
  91       do
  92         {
  93           ssize_t n = __read (fd, (char *) gconv_cache + already_read,
  94                               cache_size - already_read);
  95           if (__builtin_expect (n, 0) == -1)
  96             {
  97               free (gconv_cache);
  98               gconv_cache = NULL;
  99               goto close_and_exit;
 100             }
 101
 102           already_read += n;
 103         }
 104       while (already_read < cache_size);
 105
 106       cache_malloced = 1;
 107     }
 108
 109   /* We don't need the file descriptor anymore.  */
 110   __close_nocancel_nostatus (fd);
 111
 112   /* Check the consistency.  */
 113   header = (struct gconvcache_header *) gconv_cache;
 114   if (__builtin_expect (header->magic, GCONVCACHE_MAGIC) != GCONVCACHE_MAGIC
 115       || __builtin_expect (header->string_offset >= cache_size, 0)
 116       || __builtin_expect (header->hash_offset >= cache_size, 0)
 117       || __builtin_expect (header->hash_size == 0, 0)
 118       || __builtin_expect ((header->hash_offset
 119                             + header->hash_size * sizeof (struct hash_entry))
 120                            > cache_size, 0)
 121       || __builtin_expect (header->module_offset >= cache_size, 0)
 122       || __builtin_expect (header->otherconv_offset > cache_size, 0))
 123     {
 124       if (cache_malloced)
 125         {
 126           free (gconv_cache);
 127           cache_malloced = 0;
 128         }
 129 #ifdef _POSIX_MAPPED_FILES
 130       else
 131         __munmap (gconv_cache, cache_size);
 132 #endif
 133       gconv_cache = NULL;
 134
 135       return -1;
 136     }
 137
 138   /* That worked.  */
 139   return 0;
 140 }
 141
 142
 143 static int
 144 find_module_idx (const char *str, size_t *idxp)
 145 {
 146   unsigned int idx;
 147   unsigned int hval;
 148   unsigned int hval2;
 149   const struct gconvcache_header *header;
 150   const char *strtab;
 151   const struct hash_entry *hashtab;
 152   unsigned int limit;
 153
 154   header = (const struct gconvcache_header *) gconv_cache;
 155   strtab = (char *) gconv_cache + header->string_offset;
 156   hashtab = (struct hash_entry *) ((char *) gconv_cache
 157                                    + header->hash_offset);
 158
 159   hval = __hash_string (str);
 160   idx = hval % header->hash_size;
 161   hval2 = 1 + hval % (header->hash_size - 2);
 162
 163   limit = cache_size - header->string_offset;
 164   while (hashtab[idx].string_offset != 0)
 165     if (hashtab[idx].string_offset < limit
 166         && strcmp (str, strtab + hashtab[idx].string_offset) == 0)
 167       {
 168         *idxp = hashtab[idx].module_idx;
 169         return 0;
 170       }
 171     else
 172       if ((idx += hval2) >= header->hash_size)
 173         idx -= header->hash_size;
 174
 175   /* Nothing found.  */
 176   return -1;
 177 }
 178
 179
 180 #ifndef STATIC_GCONV
 181 static int
 182 find_module (const char *directory, const char *filename,
 183              struct __gconv_step *result)
 184 {
 185   size_t dirlen = strlen (directory);
 186   size_t fnamelen = strlen (filename) + 1;
 187   char fullname[dirlen + fnamelen];
 188   int status = __GCONV_NOCONV;
 189
 190   memcpy (__mempcpy (fullname, directory, dirlen), filename, fnamelen);
 191
 192   result->__shlib_handle = __gconv_find_shlib (fullname);
 193   if (result->__shlib_handle != NULL)
 194     {
 195       status = __GCONV_OK;
 196
 197       result->__modname = NULL;
 198       result->__fct = result->__shlib_handle->fct;
 199       result->__init_fct = result->__shlib_handle->init_fct;
 200       result->__end_fct = result->__shlib_handle->end_fct;
 201
 202       /* These settings can be overridden by the init function.  */
 203       result->__btowc_fct = NULL;
 204       result->__data = NULL;
 205
 206       /* Call the init function.  */
 207       __gconv_init_fct init_fct = result->__init_fct;
 208 #ifdef PTR_DEMANGLE
 209       PTR_DEMANGLE (init_fct);
 210 #endif
 211       if (init_fct != NULL)
 212         {
 213           status = DL_CALL_FCT (init_fct, (result));
 214
 215 #ifdef PTR_MANGLE
 216           PTR_MANGLE (result->__btowc_fct);
 217 #endif
 218         }
 219     }
 220
 221   return status;
 222 }
 223 #endif
 224
 225
 226 int
 227 __gconv_compare_alias_cache (const char *name1, const char *name2, int *result)
 228 {
 229   size_t name1_idx;
 230   size_t name2_idx;
 231
 232   if (gconv_cache == NULL)
 233     return -1;
 234
 235   if (find_module_idx (name1, &name1_idx) != 0
 236       || find_module_idx (name2, &name2_idx) != 0)
 237     *result = strcmp (name1, name2);
 238   else
 239     *result = (int) (name1_idx - name2_idx);
 240
 241   return 0;
 242 }
 243
 244
 245 int
 246 __gconv_lookup_cache (const char *toset, const char *fromset,
 247                       struct __gconv_step **handle, size_t *nsteps, int flags)
 248 {
 249   const struct gconvcache_header *header;
 250   const char *strtab;
 251   size_t fromidx;
 252   size_t toidx;
 253   const struct module_entry *modtab;
 254   const struct module_entry *from_module;
 255   const struct module_entry *to_module;
 256   struct __gconv_step *result;
 257
 258   if (gconv_cache == NULL)
 259     /* We have no cache available.  */
 260     return __GCONV_NODB;
 261
 262   header = (const struct gconvcache_header *) gconv_cache;
 263   strtab = (char *) gconv_cache + header->string_offset;
 264   modtab = (const struct module_entry *) ((char *) gconv_cache
 265                                           + header->module_offset);
 266
 267   if (find_module_idx (fromset, &fromidx) != 0
 268       || (header->module_offset + (fromidx + 1) * sizeof (struct module_entry)
 269           > cache_size))
 270     return __GCONV_NOCONV;
 271   from_module = &modtab[fromidx];
 272
 273   if (find_module_idx (toset, &toidx) != 0
 274       || (header->module_offset + (toidx + 1) * sizeof (struct module_entry)
 275           > cache_size))
 276     return __GCONV_NOCONV;
 277   to_module = &modtab[toidx];
 278
 279   /* Avoid copy-only transformations if the user requests.   */
 280   if (__builtin_expect (flags & GCONV_AVOID_NOCONV, 0) && fromidx == toidx)
 281     return __GCONV_NULCONV;
 282
 283   /* If there are special conversions available examine them first.  */
 284   if (fromidx != 0 && toidx != 0
 285       && __builtin_expect (from_module->extra_offset, 0) != 0)
 286     {
 287       /* Search through the list to see whether there is a module
 288          matching the destination character set.  */
 289       const struct extra_entry *extra;
 290
 291       /* Note the -1.  This is due to the offset added in iconvconfig.
 292          See there for more explanations.  */
 293       extra = (const struct extra_entry *) ((char *) gconv_cache
 294                                             + header->otherconv_offset
 295                                             + from_module->extra_offset - 1);
 296       while (extra->module_cnt != 0
 297              && extra->module[extra->module_cnt - 1].outname_offset != toidx)
 298         extra = (const struct extra_entry *) ((char *) extra
 299                                               + sizeof (struct extra_entry)
 300                                               + (extra->module_cnt
 301                                                  * sizeof (struct extra_entry_module)));
 302
 303       if (extra->module_cnt != 0)
 304         {
 305           /* Use the extra module.  First determine how many steps.  */
 306           char *fromname;
 307           int idx;
 308
 309           *nsteps = extra->module_cnt;
 310           *handle = result =
 311             (struct __gconv_step *) malloc (extra->module_cnt
 312                                             * sizeof (struct __gconv_step));
 313           if (result == NULL)
 314             return __GCONV_NOMEM;
 315
 316           fromname = (char *) strtab + from_module->canonname_offset;
 317           idx = 0;
 318           do
 319             {
 320               result[idx].__from_name = fromname;
 321               fromname = result[idx].__to_name =
 322                 (char *) strtab + modtab[extra->module[idx].outname_offset].canonname_offset;
 323
 324               result[idx].__counter = 1;
 325               result[idx].__data = NULL;
 326
 327 #ifndef STATIC_GCONV
 328               if (strtab[extra->module[idx].dir_offset] != '\0')
 329                 {
 330                   /* Load the module, return handle for it.  */
 331                   int res;
 332
 333                   res = find_module (strtab + extra->module[idx].dir_offset,
 334                                      strtab + extra->module[idx].name_offset,
 335                                      &result[idx]);
 336                   if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)
 337                     {
 338                       /* Something went wrong.  */
 339                       free (result);
 340                       goto try_internal;
 341                     }
 342                 }
 343               else
 344 #endif
 345                 /* It's a builtin transformation.  */
 346                 __gconv_get_builtin_trans (strtab
 347                                            + extra->module[idx].name_offset,
 348                                            &result[idx]);
 349
 350             }
 351           while (++idx < extra->module_cnt);
 352
 353           return __GCONV_OK;
 354         }
 355     }
 356
 357  try_internal:
 358   /* See whether we can convert via the INTERNAL charset.  */
 359   if ((fromidx != 0 && __builtin_expect (from_module->fromname_offset, 1) == 0)
 360       || (toidx != 0 && __builtin_expect (to_module->toname_offset, 1) == 0)
 361       || (fromidx == 0 && toidx == 0))
 362     /* Not possible.  Nothing we can do.  */
 363     return __GCONV_NOCONV;
 364
 365   /* We will use up to two modules.  Always allocate room for two.  */
 366   result = (struct __gconv_step *) malloc (2 * sizeof (struct __gconv_step));
 367   if (result == NULL)
 368     return __GCONV_NOMEM;
 369
 370   *handle = result;
 371   *nsteps = 0;
 372
 373   /* Generate data structure for conversion to INTERNAL.  */
 374   if (fromidx != 0)
 375     {
 376       result[0].__from_name = (char *) strtab + from_module->canonname_offset;
 377       result[0].__to_name = (char *) "INTERNAL";
 378
 379       result[0].__counter = 1;
 380       result[0].__data = NULL;
 381
 382 #ifndef STATIC_GCONV
 383       if (strtab[from_module->todir_offset] != '\0')
 384         {
 385           /* Load the module, return handle for it.  */
 386           int res = find_module (strtab + from_module->todir_offset,
 387                                  strtab + from_module->toname_offset,
 388                                  &result[0]);
 389           if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)
 390             {
 391               /* Something went wrong.  */
 392               free (result);
 393               return res;
 394             }
 395         }
 396       else
 397 #endif
 398         /* It's a builtin transformation.  */
 399         __gconv_get_builtin_trans (strtab + from_module->toname_offset,
 400                                    &result[0]);
 401
 402       ++*nsteps;
 403     }
 404
 405   /* Generate data structure for conversion from INTERNAL.  */
 406   if (toidx != 0)
 407     {
 408       int idx = *nsteps;
 409
 410       result[idx].__from_name = (char *) "INTERNAL";
 411       result[idx].__to_name = (char *) strtab + to_module->canonname_offset;
 412
 413       result[idx].__counter = 1;
 414       result[idx].__data = NULL;
 415
 416 #ifndef STATIC_GCONV
 417       if (strtab[to_module->fromdir_offset] != '\0')
 418         {
 419           /* Load the module, return handle for it.  */
 420           int res = find_module (strtab + to_module->fromdir_offset,
 421                                  strtab + to_module->fromname_offset,
 422                                  &result[idx]);
 423           if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)
 424             {
 425               /* Something went wrong.  */
 426               if (idx != 0)
 427                 __gconv_release_step (&result[0]);
 428               free (result);
 429               return res;
 430             }
 431         }
 432       else
 433 #endif
 434         /* It's a builtin transformation.  */
 435         __gconv_get_builtin_trans (strtab + to_module->fromname_offset,
 436                                    &result[idx]);
 437
 438       ++*nsteps;
 439     }
 440
 441   return __GCONV_OK;
 442 }
 443
 444
 445 /* Free memory allocated for the transformation record.  */
 446 void
 447 __gconv_release_cache (struct __gconv_step *steps, size_t nsteps)
 448 {
 449   if (gconv_cache != NULL)
 450     /* The only thing we have to deallocate is the record with the
 451        steps.  */
 452     free (steps);
 453 }
 454
 455
 456 /* Free all resources if necessary.  */
 457 libc_freeres_fn (free_mem)
 458 {
 459   if (cache_malloced)
 460     free (gconv_cache);
 461 #ifdef _POSIX_MAPPED_FILES
 462   else if (gconv_cache != NULL)
 463     __munmap (gconv_cache, cache_size);
 464 #endif
 465 }