(_dl_start_final): If not USE___THREAD, don't assert
[kopensolaris-gnu/glibc.git] / 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 }