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 *
_nl_expand_alias(const char * name)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
read_alias_file(const char * fname,int fname_len)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
extend_alias_table()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
alias_compare(const struct alias_map * map1,const struct alias_map * map2)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 }
415