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