Copied gpg.texi over from 1.4.5 and started to restructure it into a proper
[gnupg.git] / intl / localealias.c
1 /* Handle aliases for locale names.
2    Copyright (C) 1995-1999, 2000-2001, 2003 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or modify it
5    under the terms of the GNU Library General Public License as published
6    by the Free Software Foundation; either version 2, or (at your option)
7    any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with this program; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17    USA.  */
18
19 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
20    This must come before <config.h> because <config.h> may include
21    <features.h>, and once <features.h> has been included, it's too late.  */
22 #ifndef _GNU_SOURCE
23 # define _GNU_SOURCE    1
24 #endif
25
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
29
30 #include <ctype.h>
31 #include <stdio.h>
32 #if defined _LIBC || defined HAVE___FSETLOCKING
33 # include <stdio_ext.h>
34 #endif
35 #include <sys/types.h>
36
37 #ifdef __GNUC__
38 # undef alloca
39 # define alloca __builtin_alloca
40 # define HAVE_ALLOCA 1
41 #else
42 # ifdef _MSC_VER
43 #  include <malloc.h>
44 #  define alloca _alloca
45 # else
46 #  if defined HAVE_ALLOCA_H || defined _LIBC
47 #   include <alloca.h>
48 #  else
49 #   ifdef _AIX
50  #pragma alloca
51 #   else
52 #    ifndef alloca
53 char *alloca ();
54 #    endif
55 #   endif
56 #  endif
57 # endif
58 #endif
59
60 #include <stdlib.h>
61 #include <string.h>
62
63 #include "gettextP.h"
64
65 #if ENABLE_RELOCATABLE
66 # include "relocatable.h"
67 #else
68 # define relocate(pathname) (pathname)
69 #endif
70
71 /* @@ end of prolog @@ */
72
73 #ifdef _LIBC
74 /* Rename the non ANSI C functions.  This is required by the standard
75    because some ANSI C functions will require linking with this object
76    file and the name space must not be polluted.  */
77 # define strcasecmp __strcasecmp
78
79 # ifndef mempcpy
80 #  define mempcpy __mempcpy
81 # endif
82 # define HAVE_MEMPCPY   1
83 # define HAVE___FSETLOCKING     1
84
85 /* We need locking here since we can be called from different places.  */
86 # include <bits/libc-lock.h>
87
88 __libc_lock_define_initialized (static, lock);
89 #endif
90
91 #ifndef internal_function
92 # define internal_function
93 #endif
94
95 /* Some optimizations for glibc.  */
96 #ifdef _LIBC
97 # define FEOF(fp)               feof_unlocked (fp)
98 # define FGETS(buf, n, fp)      fgets_unlocked (buf, n, fp)
99 #else
100 # define FEOF(fp)               feof (fp)
101 # define FGETS(buf, n, fp)      fgets (buf, n, fp)
102 #endif
103
104 /* For those losing systems which don't have `alloca' we have to add
105    some additional code emulating it.  */
106 #ifdef HAVE_ALLOCA
107 # define freea(p) /* nothing */
108 #else
109 # define alloca(n) malloc (n)
110 # define freea(p) free (p)
111 #endif
112
113 #if defined _LIBC_REENTRANT || HAVE_DECL_FGETS_UNLOCKED
114 # undef fgets
115 # define fgets(buf, len, s) fgets_unlocked (buf, len, s)
116 #endif
117 #if defined _LIBC_REENTRANT || HAVE_DECL_FEOF_UNLOCKED
118 # undef feof
119 # define feof(s) feof_unlocked (s)
120 #endif
121
122
123 struct alias_map
124 {
125   const char *alias;
126   const char *value;
127 };
128
129
130 #ifndef _LIBC
131 # define libc_freeres_ptr(decl) decl
132 #endif
133
134 libc_freeres_ptr (static char *string_space);
135 static size_t string_space_act;
136 static size_t string_space_max;
137 libc_freeres_ptr (static struct alias_map *map);
138 static size_t nmap;
139 static size_t maxmap;
140
141
142 /* Prototypes for local functions.  */
143 static size_t read_alias_file (const char *fname, int fname_len)
144      internal_function;
145 static int extend_alias_table (void);
146 static int alias_compare (const struct alias_map *map1,
147                           const struct alias_map *map2);
148
149
150 const char *
151 _nl_expand_alias (const char *name)
152 {
153   static const char *locale_alias_path;
154   struct alias_map *retval;
155   const char *result = NULL;
156   size_t added;
157
158 #ifdef _LIBC
159   __libc_lock_lock (lock);
160 #endif
161
162   if (locale_alias_path == NULL)
163     locale_alias_path = LOCALE_ALIAS_PATH;
164
165   do
166     {
167       struct alias_map item;
168
169       item.alias = name;
170
171       if (nmap > 0)
172         retval = (struct alias_map *) bsearch (&item, map, nmap,
173                                                sizeof (struct alias_map),
174                                                (int (*) (const void *,
175                                                          const void *)
176                                                 ) alias_compare);
177       else
178         retval = NULL;
179
180       /* We really found an alias.  Return the value.  */
181       if (retval != NULL)
182         {
183           result = retval->value;
184           break;
185         }
186
187       /* Perhaps we can find another alias file.  */
188       added = 0;
189       while (added == 0 && locale_alias_path[0] != '\0')
190         {
191           const char *start;
192
193           while (locale_alias_path[0] == PATH_SEPARATOR)
194             ++locale_alias_path;
195           start = locale_alias_path;
196
197           while (locale_alias_path[0] != '\0'
198                  && locale_alias_path[0] != PATH_SEPARATOR)
199             ++locale_alias_path;
200
201           if (start < locale_alias_path)
202             added = read_alias_file (start, locale_alias_path - start);
203         }
204     }
205   while (added != 0);
206
207 #ifdef _LIBC
208   __libc_lock_unlock (lock);
209 #endif
210
211   return result;
212 }
213
214
215 static size_t
216 internal_function
217 read_alias_file (const char *fname, int fname_len)
218 {
219   FILE *fp;
220   char *full_fname;
221   size_t added;
222   static const char aliasfile[] = "/locale.alias";
223
224   full_fname = (char *) alloca (fname_len + sizeof aliasfile);
225 #ifdef HAVE_MEMPCPY
226   mempcpy (mempcpy (full_fname, fname, fname_len),
227            aliasfile, sizeof aliasfile);
228 #else
229   memcpy (full_fname, fname, fname_len);
230   memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
231 #endif
232
233   fp = fopen (relocate (full_fname), "r");
234   freea (full_fname);
235   if (fp == NULL)
236     return 0;
237
238 #ifdef HAVE___FSETLOCKING
239   /* No threads present.  */
240   __fsetlocking (fp, FSETLOCKING_BYCALLER);
241 #endif
242
243   added = 0;
244   while (!FEOF (fp))
245     {
246       /* It is a reasonable approach to use a fix buffer here because
247          a) we are only interested in the first two fields
248          b) these fields must be usable as file names and so must not
249             be that long
250          We avoid a multi-kilobyte buffer here since this would use up
251          stack space which we might not have if the program ran out of
252          memory.  */
253       char buf[400];
254       char *alias;
255       char *value;
256       char *cp;
257
258       if (FGETS (buf, sizeof buf, fp) == NULL)
259         /* EOF reached.  */
260         break;
261
262       cp = buf;
263       /* Ignore leading white space.  */
264       while (isspace ((unsigned char) cp[0]))
265         ++cp;
266
267       /* A leading '#' signals a comment line.  */
268       if (cp[0] != '\0' && cp[0] != '#')
269         {
270           alias = cp++;
271           while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
272             ++cp;
273           /* Terminate alias name.  */
274           if (cp[0] != '\0')
275             *cp++ = '\0';
276
277           /* Now look for the beginning of the value.  */
278           while (isspace ((unsigned char) cp[0]))
279             ++cp;
280
281           if (cp[0] != '\0')
282             {
283               size_t alias_len;
284               size_t value_len;
285
286               value = cp++;
287               while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
288                 ++cp;
289               /* Terminate value.  */
290               if (cp[0] == '\n')
291                 {
292                   /* This has to be done to make the following test
293                      for the end of line possible.  We are looking for
294                      the terminating '\n' which do not overwrite here.  */
295                   *cp++ = '\0';
296                   *cp = '\n';
297                 }
298               else if (cp[0] != '\0')
299                 *cp++ = '\0';
300
301               if (nmap >= maxmap)
302                 if (__builtin_expect (extend_alias_table (), 0))
303                   return added;
304
305               alias_len = strlen (alias) + 1;
306               value_len = strlen (value) + 1;
307
308               if (string_space_act + alias_len + value_len > string_space_max)
309                 {
310                   /* Increase size of memory pool.  */
311                   size_t new_size = (string_space_max
312                                      + (alias_len + value_len > 1024
313                                         ? alias_len + value_len : 1024));
314                   char *new_pool = (char *) realloc (string_space, new_size);
315                   if (new_pool == NULL)
316                     return added;
317
318                   if (__builtin_expect (string_space != new_pool, 0))
319                     {
320                       size_t i;
321
322                       for (i = 0; i < nmap; i++)
323                         {
324                           map[i].alias += new_pool - string_space;
325                           map[i].value += new_pool - string_space;
326                         }
327                     }
328
329                   string_space = new_pool;
330                   string_space_max = new_size;
331                 }
332
333               map[nmap].alias = memcpy (&string_space[string_space_act],
334                                         alias, alias_len);
335               string_space_act += alias_len;
336
337               map[nmap].value = memcpy (&string_space[string_space_act],
338                                         value, value_len);
339               string_space_act += value_len;
340
341               ++nmap;
342               ++added;
343             }
344         }
345
346       /* Possibly not the whole line fits into the buffer.  Ignore
347          the rest of the line.  */
348       while (strchr (buf, '\n') == NULL)
349         if (FGETS (buf, sizeof buf, fp) == NULL)
350           /* Make sure the inner loop will be left.  The outer loop
351              will exit at the `feof' test.  */
352           break;
353     }
354
355   /* Should we test for ferror()?  I think we have to silently ignore
356      errors.  --drepper  */
357   fclose (fp);
358
359   if (added > 0)
360     qsort (map, nmap, sizeof (struct alias_map),
361            (int (*) (const void *, const void *)) alias_compare);
362
363   return added;
364 }
365
366
367 static int
368 extend_alias_table ()
369 {
370   size_t new_size;
371   struct alias_map *new_map;
372
373   new_size = maxmap == 0 ? 100 : 2 * maxmap;
374   new_map = (struct alias_map *) realloc (map, (new_size
375                                                 * sizeof (struct alias_map)));
376   if (new_map == NULL)
377     /* Simply don't extend: we don't have any more core.  */
378     return -1;
379
380   map = new_map;
381   maxmap = new_size;
382   return 0;
383 }
384
385
386 static int
387 alias_compare (const struct alias_map *map1, const struct alias_map *map2)
388 {
389 #if defined _LIBC || defined HAVE_STRCASECMP
390   return strcasecmp (map1->alias, map2->alias);
391 #else
392   const unsigned char *p1 = (const unsigned char *) map1->alias;
393   const unsigned char *p2 = (const unsigned char *) map2->alias;
394   unsigned char c1, c2;
395
396   if (p1 == p2)
397     return 0;
398
399   do
400     {
401       /* I know this seems to be odd but the tolower() function in
402          some systems libc cannot handle nonalpha characters.  */
403       c1 = isupper (*p1) ? tolower (*p1) : *p1;
404       c2 = isupper (*p2) ? tolower (*p2) : *p2;
405       if (c1 == '\0')
406         break;
407       ++p1;
408       ++p2;
409     }
410   while (c1 == c2);
411
412   return c1 - c2;
413 #endif
414 }