(__gconv_read_conf): Don't define as internal_function since it is
[kopensolaris-gnu/glibc.git] / iconv / gconv_conf.c
1 /* Handle configuration data.
2    Copyright (C) 1997, 1998 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    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    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include <ctype.h>
22 #include <errno.h>
23 #include <limits.h>
24 #include <search.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/param.h>
30
31 #include <gconv_int.h>
32
33
34 /* This is the default path where we look for module lists.  */
35 static const char default_gconv_path[] = GCONV_PATH;
36
37 /* Name of the file containing the module information in the directories
38    along the path.  */
39 static const char gconv_conf_filename[] = "gconv-modules";
40
41 /* Filename extension for the modules.  */
42 #ifndef MODULE_EXT
43 # define MODULE_EXT ".so"
44 #endif
45 static const char gconv_module_ext[] = MODULE_EXT;
46
47 /* We have a few builtin transformations.  */
48 static struct gconv_module builtin_modules[] =
49 {
50 #define BUILTIN_TRANSFORMATION(From, ConstPfx, ConstLen, To, Cost, Name, \
51                                Fct, Init, End, MinF, MaxF, MinT, MaxT) \
52   {                                                                           \
53     from_pattern: From,                                                       \
54     from_constpfx: ConstPfx,                                                  \
55     from_constpfx_len: ConstLen,                                              \
56     from_regex: NULL,                                                         \
57     to_string: To,                                                            \
58     cost_hi: Cost,                                                            \
59     cost_lo: INT_MAX,                                                         \
60     module_name: Name                                                         \
61   },
62 #define BUILTIN_ALIAS(From, To)
63
64 #include "gconv_builtin.h"
65 };
66
67 #undef BUILTIN_TRANSFORMATION
68 #undef BUILTIN_ALIAS
69
70 static const char *
71 builtin_aliases[] =
72 {
73 #define BUILTIN_TRANSFORMATION(From, ConstPfx, ConstLen, To, Cost, Name, \
74                                Fct, Init, End, MinF, MaxF, MinT, MaxT)
75 #define BUILTIN_ALIAS(From, To) From " " To,
76
77 #include "gconv_builtin.h"
78 };
79
80 #ifdef USE_IN_LIBIO
81 # include <libio/libioP.h>
82 # define __getdelim(line, len, c, fp) _IO_getdelim (line, len, c, fp)
83 #endif
84
85
86 /* Function for searching module.  */
87 static int
88 module_compare (const void *p1, const void *p2)
89 {
90   struct gconv_module *s1 = (struct gconv_module *) p1;
91   struct gconv_module *s2 = (struct gconv_module *) p2;
92   int result;
93
94   if (s1->from_pattern == NULL)
95     {
96       if (s2->from_pattern == NULL)
97         result = strcmp (s1->from_constpfx, s2->from_constpfx);
98       else
99         result = -1;
100     }
101   else if (s2->from_pattern == NULL)
102     result = 1;
103   else
104     result = strcmp (s1->from_pattern, s2->from_pattern);
105
106   if (result == 0)
107     result = strcmp (s1->to_string, s2->to_string);
108
109   return result;
110 }
111
112
113 /* Add new alias.  */
114 static inline void
115 add_alias (char *rp)
116 {
117   /* We now expect two more string.  The strings are normalized
118      (converted to UPPER case) and strored in the alias database.  */
119   struct gconv_alias *new_alias;
120   char *from, *to, *wp;
121
122   while (isspace (*rp))
123     ++rp;
124   from = wp = rp;
125   while (*rp != '\0' && !isspace (*rp))
126     ++rp;
127   if (*rp == '\0')
128     /* There is no `to' string on the line.  Ignore it.  */
129     return;
130   *rp++ = '\0';
131   to = wp = rp;
132   while (isspace (*rp))
133     ++rp;
134   while (*rp != '\0' && !isspace (*rp))
135     *wp++ = *rp++;
136   if (to == wp)
137     /* No `to' string, ignore the line.  */
138     return;
139   *wp++ = '\0';
140
141   new_alias = (struct gconv_alias *)
142     malloc (sizeof (struct gconv_alias) + (wp - from));
143   if (new_alias != NULL)
144     {
145       new_alias->fromname = memcpy ((char *) new_alias
146                                     + sizeof (struct gconv_alias),
147                                     from, wp - from);
148       new_alias->toname = new_alias->fromname + (to - from);
149
150       if (__tsearch (new_alias, &__gconv_alias_db, __gconv_alias_compare)
151           == NULL)
152         /* Something went wrong, free this entry.  */
153         free (new_alias);
154     }
155 }
156
157
158 /* Add new module.  */
159 static inline void
160 add_module (char *rp, const char *directory, size_t dir_len, void **modules,
161             size_t *nmodules, int modcounter)
162 {
163   /* We expect now
164      1. `from' name
165      2. `to' name
166      3. filename of the module
167      4. an optional cost value
168   */
169   struct gconv_module *new_module;
170   char *from, *to, *module, *wp;
171   size_t const_len;
172   int from_is_regex;
173   int need_ext;
174   int cost_hi;
175
176   while (isspace (*rp))
177     ++rp;
178   from = rp;
179   from_is_regex = 0;
180   while (*rp != '\0' && !isspace (*rp))
181     {
182       if (!isalnum (*rp) && *rp != '-' && *rp != '/' && *rp != '.'
183           && *rp != '_')
184         from_is_regex = 1;
185       ++rp;
186     }
187   if (*rp == '\0')
188     return;
189   *rp++ = '\0';
190   to = wp = rp;
191   while (isspace (*rp))
192     ++rp;
193   while (*rp != '\0' && !isspace (*rp))
194     *wp++ = *rp++;
195   if (*rp == '\0')
196     return;
197   *wp++ = '\0';
198   do
199     ++rp;
200   while (isspace (*rp));
201   module = wp;
202   while (*rp != '\0' && !isspace (*rp))
203     *wp++ = *rp++;
204   if (*rp == '\0')
205     {
206       /* There is no cost, use one by default.  */
207       *wp++ = '\0';
208       cost_hi = 1;
209     }
210   else
211     {
212       /* There might be a cost value.  */
213       char *endp;
214
215       *wp++ = '\0';
216       cost_hi = strtol (rp, &endp, 10);
217       if (rp == endp)
218         /* No useful information.  */
219         cost_hi = 1;
220     }
221
222   if (module[0] == '\0')
223     /* No module name given.  */
224     return;
225   if (module[0] == '/')
226     dir_len = 0;
227   else
228     /* Increment by one for the slash.  */
229     ++dir_len;
230
231   /* See whether we must add the ending.  */
232   need_ext = 0;
233   if (wp - module < sizeof (gconv_module_ext)
234       || memcmp (wp - sizeof (gconv_module_ext), gconv_module_ext,
235                  sizeof (gconv_module_ext)) != 0)
236     /* We must add the module extension.  */
237     need_ext = sizeof (gconv_module_ext) - 1;
238
239   /* We've collected all the information, now create an entry.  */
240
241   if (from_is_regex)
242     {
243       const_len = 0;
244       while (isalnum (from[const_len]) || from[const_len] == '-'
245              || from[const_len] == '/' || from[const_len] == '.'
246              || from[const_len] == '_')
247         ++const_len;
248     }
249   else
250     const_len = to - from - 1;
251
252   new_module = (struct gconv_module *) malloc (sizeof (struct gconv_module)
253                                                + (wp - from)
254                                                + dir_len + need_ext);
255   if (new_module != NULL)
256     {
257       char *tmp;
258
259       new_module->from_constpfx = memcpy ((char *) new_module
260                                           + sizeof (struct gconv_module),
261                                           from, to - from);
262       if (from_is_regex)
263         new_module->from_pattern = new_module->from_constpfx;
264       else
265         new_module->from_pattern = NULL;
266
267       new_module->from_constpfx_len = const_len;
268
269       new_module->from_regex = NULL;
270
271       new_module->to_string = memcpy ((char *) new_module->from_constpfx
272                                       + (to - from), to, module - to);
273
274       new_module->cost_hi = cost_hi;
275       new_module->cost_lo = modcounter;
276
277       new_module->module_name = (char *) new_module->to_string + (module - to);
278
279       if (dir_len == 0)
280         tmp = (char *) new_module->module_name;
281       else
282         {
283           tmp = __mempcpy ((char *) new_module->module_name,
284                            directory, dir_len - 1);
285           *tmp++ = '/';
286         }
287
288       tmp = __mempcpy (tmp, module, wp - module);
289
290       if (need_ext)
291         memcpy (tmp - 1, gconv_module_ext, sizeof (gconv_module_ext));
292
293       if (__tfind (new_module, modules, module_compare) == NULL)
294         {
295           if (__tsearch (new_module, modules, module_compare) == NULL)
296             /* Something went wrong while inserting the new module.  */
297             free (new_module);
298           else
299             ++*nmodules;
300         }
301     }
302 }
303
304
305 static void
306 insert_module (const void *nodep, VISIT value, int level)
307 {
308   if (value == preorder || value == leaf)
309     __gconv_modules_db[__gconv_nmodules++] = *(struct gconv_module **) nodep;
310 }
311
312 static void
313 nothing (void *unused __attribute__ ((unused)))
314 {
315 }
316
317
318 /* Read the next configuration file.  */
319 static void
320 internal_function
321 read_conf_file (const char *filename, const char *directory, size_t dir_len,
322                 void **modules, size_t *nmodules)
323 {
324   FILE *fp = fopen (filename, "r");
325   char *line = NULL;
326   size_t line_len = 0;
327   int modcounter = 0;
328
329   /* Don't complain if a file is not present or readable, simply silently
330      ignore it.  */
331   if (fp == NULL)
332     return;
333
334   /* Process the known entries of the file.  Comments start with `#' and
335      end with the end of the line.  Empty lines are ignored.  */
336   while (!feof_unlocked (fp))
337     {
338       char *rp, *endp, *word;
339       ssize_t n = __getdelim (&line, &line_len, '\n', fp);
340       if (n < 0)
341         /* An error occurred.  */
342         break;
343
344       rp = line;
345       /* Terminate the line (excluding comments or newline) by an NUL byte
346          to simplify the following code.  */
347       endp = strchr (rp, '#');
348       if (endp != NULL)
349         *endp = '\0';
350       else
351         if (rp[n - 1] == '\n')
352           rp[n - 1] = '\0';
353
354       while (isspace (*rp))
355         ++rp;
356
357       /* If this is an empty line go on with the next one.  */
358       if (rp == endp)
359         continue;
360
361       word = rp;
362       while (*rp != '\0' && !isspace (*rp))
363         ++rp;
364
365       if (rp - word == sizeof ("alias") - 1
366           && memcmp (word, "alias", sizeof ("alias") - 1) == 0)
367         add_alias (rp);
368       else if (rp - word == sizeof ("module") - 1
369                && memcmp (word, "module", sizeof ("module") - 1) == 0)
370         add_module (rp, directory, dir_len, modules, nmodules, modcounter++);
371       /* else */
372         /* Otherwise ignore the line.  */
373     }
374
375   if (line != NULL)
376     free (line);
377   fclose (fp);
378 }
379
380
381 /* Read all configuration files found in the user-specified and the default
382    path.  */
383 void
384 __gconv_read_conf (void)
385 {
386   const char *user_path = __secure_getenv ("GCONV_PATH");
387   char *gconv_path, *elem;
388   void *modules = NULL;
389   size_t nmodules = 0;
390   int save_errno = errno;
391   size_t cnt;
392
393   if (user_path == NULL)
394     /* No user-defined path.  Make a modifiable copy of the default path.  */
395     gconv_path = strdupa (default_gconv_path);
396   else
397     {
398       /* Append the default path to the user-defined path.  */
399       size_t user_len = strlen (user_path);
400       char *tmp;
401
402       gconv_path = alloca (user_len + 1 + sizeof (default_gconv_path));
403       tmp = __mempcpy (gconv_path, user_path, user_len);
404       *tmp++ = ':';
405       __mempcpy (tmp, default_gconv_path, sizeof (default_gconv_path));
406     }
407
408   elem = strtok_r (gconv_path, ":", &gconv_path);
409   while (elem != NULL)
410     {
411 #ifndef MAXPATHLEN
412       /* We define a reasonable limit.  */
413 # define MAXPATHLEN 4096
414 #endif
415       char real_elem[MAXPATHLEN];
416
417       if (__realpath (elem, real_elem) != NULL)
418         {
419           size_t elem_len = strlen (real_elem);
420           char *filename, *tmp;
421
422           filename = alloca (elem_len + 1 + sizeof (gconv_conf_filename));
423           tmp = __mempcpy (filename, real_elem, elem_len);
424           *tmp++ = '/';
425           __mempcpy (tmp, gconv_conf_filename, sizeof (gconv_conf_filename));
426
427           /* Read the next configuration file.  */
428           read_conf_file (filename, real_elem, elem_len, &modules, &nmodules);
429         }
430
431       /* Get next element in the path.  */
432       elem = strtok_r (NULL, ":", &gconv_path);
433     }
434
435   /* If the configuration files do not contain any valid module specification
436      remember this by setting the pointer to the module array to NULL.  */
437   nmodules += sizeof (builtin_modules) / sizeof (builtin_modules[0]);
438   if (nmodules == 0)
439     __gconv_modules_db = NULL;
440   else
441     {
442       __gconv_modules_db =
443         (struct gconv_module **) malloc (nmodules
444                                          * sizeof (struct gconv_module));
445       if (__gconv_modules_db != NULL)
446         {
447           size_t cnt;
448
449           /* Insert all module entries into the array.  */
450           __twalk (modules, insert_module);
451
452           /* No remove the tree data structure.  */
453           __tdestroy (modules, nothing);
454
455           /* Finally insert the builtin transformations.  */
456           for (cnt = 0; cnt < (sizeof (builtin_modules)
457                                / sizeof (struct gconv_module)); ++cnt)
458             __gconv_modules_db[__gconv_nmodules++] = &builtin_modules[cnt];
459         }
460     }
461
462   /* Add aliases for builtin conversions.  */
463   cnt = sizeof (builtin_aliases) / sizeof (builtin_aliases[0]);
464   while (cnt > 0)
465     {
466       char *copy = strdupa (builtin_aliases[--cnt]);
467       add_alias (copy);
468     }
469
470   /* Restore the error number.  */
471   __set_errno (save_errno);
472 }