iconv/gconv_cache.c

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