1/* Handle aliases for locale names.
2 Copyright (C) 1995-2022 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 <https://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#pragma GCC diagnostic push
322
323#if defined __GNUC__ && __GNUC__ >= 12
324 /* Suppress the valid GCC 12 warning until the code below is changed
325 to avoid using pointers to the reallocated block. */
326# pragma GCC diagnostic ignored "-Wuse-after-free"
327#endif
328
329 /* Increase size of memory pool. */
330 size_t new_size = (string_space_max
331 + (alias_len + value_len > 1024
332 ? alias_len + value_len : 1024));
333 char *new_pool = (char *) realloc (string_space, new_size);
334 if (new_pool == NULL)
335 goto out;
336
337 if (__builtin_expect (string_space != new_pool, 0))
338 {
339 size_t i;
340
341 for (i = 0; i < nmap; i++)
342 {
343 map[i].alias += new_pool - string_space;
344 map[i].value += new_pool - string_space;
345 }
346 }
347
348 string_space = new_pool;
349 string_space_max = new_size;
350 }
351
352 map[nmap].alias =
353 (const char *) memcpy (&string_space[string_space_act],
354 alias, alias_len);
355 string_space_act += alias_len;
356
357 map[nmap].value =
358 (const char *) memcpy (&string_space[string_space_act],
359 value, value_len);
360 string_space_act += value_len;
361
362#pragma GCC diagnostic pop
363
364 ++nmap;
365 ++added;
366 }
367 }
368 }
369
370 /* Possibly not the whole line fits into the buffer. Ignore
371 the rest of the line. */
372 if (! complete_line)
373 do
374 if (FGETS (buf, sizeof buf, fp) == NULL)
375 /* Make sure the inner loop will be left. The outer loop
376 will exit at the `feof' test. */
377 break;
378 while (strchr (buf, '\n') == NULL);
379 }
380
381 out:
382 /* Should we test for ferror()? I think we have to silently ignore
383 errors. --drepper */
384 fclose (fp);
385
386 if (added > 0)
387 qsort (map, nmap, sizeof (struct alias_map),
388 (int (*) (const void *, const void *)) alias_compare);
389
390 return added;
391}
392
393
394static int
395extend_alias_table (void)
396{
397 size_t new_size;
398 struct alias_map *new_map;
399
400 new_size = maxmap == 0 ? 100 : 2 * maxmap;
401 new_map = (struct alias_map *) realloc (map, (new_size
402 * sizeof (struct alias_map)));
403 if (new_map == NULL)
404 /* Simply don't extend: we don't have any more core. */
405 return -1;
406
407 map = new_map;
408 maxmap = new_size;
409 return 0;
410}
411
412
413static int
414alias_compare (const struct alias_map *map1, const struct alias_map *map2)
415{
416#if defined _LIBC || defined HAVE_STRCASECMP
417 return strcasecmp (map1->alias, map2->alias);
418#else
419 const unsigned char *p1 = (const unsigned char *) map1->alias;
420 const unsigned char *p2 = (const unsigned char *) map2->alias;
421 unsigned char c1, c2;
422
423 if (p1 == p2)
424 return 0;
425
426 do
427 {
428 /* I know this seems to be odd but the tolower() function in
429 some systems libc cannot handle nonalpha characters. */
430 c1 = isupper (*p1) ? tolower (*p1) : *p1;
431 c2 = isupper (*p2) ? tolower (*p2) : *p2;
432 if (c1 == '\0')
433 break;
434 ++p1;
435 ++p2;
436 }
437 while (c1 == c2);
438
439 return c1 - c2;
440#endif
441}
442