1 /* Handle aliases for locale names.
2    Copyright (C) 1995-2021 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
51 char *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 
122 struct 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 
133 libc_freeres_ptr (static char *string_space);
134 static size_t string_space_act;
135 static size_t string_space_max;
136 libc_freeres_ptr (static struct alias_map *map);
137 static size_t nmap;
138 static size_t maxmap;
139 
140 
141 /* Prototypes for local functions.  */
142 static size_t read_alias_file (const char *fname, int fname_len);
143 static int extend_alias_table (void);
144 static int alias_compare (const struct alias_map *map1,
145 			  const struct alias_map *map2);
146 
147 
148 const char *
_nl_expand_alias(const char * name)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 
209 static size_t
read_alias_file(const char * fname,int fname_len)210 read_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 
384 static int
extend_alias_table(void)385 extend_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 
403 static int
alias_compare(const struct alias_map * map1,const struct alias_map * map2)404 alias_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