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