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
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 #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 
394 static int
extend_alias_table(void)395 extend_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 
413 static int
alias_compare(const struct alias_map * map1,const struct alias_map * map2)414 alias_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