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