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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
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 || defined HAVE_FGETS_UNLOCKED
114 # undef fgets
115 # define fgets(buf, len, s) fgets_unlocked (buf, len, s)
116 #endif
117 #if defined _LIBC_REENTRANT || defined HAVE_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 PARAMS ((const char *fname, int fname_len))
144      internal_function;
145 static int extend_alias_table PARAMS ((void));
146 static int alias_compare PARAMS ((const struct alias_map *map1,
147 				  const struct alias_map *map2));
148 
149 
150 const char *
_nl_expand_alias(name)151 _nl_expand_alias (name)
152     const char *name;
153 {
154   static const char *locale_alias_path;
155   struct alias_map *retval;
156   const char *result = NULL;
157   size_t added;
158 
159 #ifdef _LIBC
160   __libc_lock_lock (lock);
161 #endif
162 
163   if (locale_alias_path == NULL)
164     locale_alias_path = LOCALE_ALIAS_PATH;
165 
166   do
167     {
168       struct alias_map item;
169 
170       item.alias = name;
171 
172       if (nmap > 0)
173 	retval = (struct alias_map *) bsearch (&item, map, nmap,
174 					       sizeof (struct alias_map),
175 					       (int (*) PARAMS ((const void *,
176 								 const void *))
177 						) alias_compare);
178       else
179 	retval = NULL;
180 
181       /* We really found an alias.  Return the value.  */
182       if (retval != NULL)
183 	{
184 	  result = retval->value;
185 	  break;
186 	}
187 
188       /* Perhaps we can find another alias file.  */
189       added = 0;
190       while (added == 0 && locale_alias_path[0] != '\0')
191 	{
192 	  const char *start;
193 
194 	  while (locale_alias_path[0] == PATH_SEPARATOR)
195 	    ++locale_alias_path;
196 	  start = locale_alias_path;
197 
198 	  while (locale_alias_path[0] != '\0'
199 		 && locale_alias_path[0] != PATH_SEPARATOR)
200 	    ++locale_alias_path;
201 
202 	  if (start < locale_alias_path)
203 	    added = read_alias_file (start, locale_alias_path - start);
204 	}
205     }
206   while (added != 0);
207 
208 #ifdef _LIBC
209   __libc_lock_unlock (lock);
210 #endif
211 
212   return result;
213 }
214 
215 
216 static size_t
217 internal_function
read_alias_file(fname,fname_len)218 read_alias_file (fname, fname_len)
219      const char *fname;
220      int fname_len;
221 {
222   FILE *fp;
223   char *full_fname;
224   size_t added;
225   static const char aliasfile[] = "/locale.alias";
226 
227   full_fname = (char *) alloca (fname_len + sizeof aliasfile);
228 #ifdef HAVE_MEMPCPY
229   mempcpy (mempcpy (full_fname, fname, fname_len),
230 	   aliasfile, sizeof aliasfile);
231 #else
232   memcpy (full_fname, fname, fname_len);
233   memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
234 #endif
235 
236   fp = fopen (relocate (full_fname), "r");
237   freea (full_fname);
238   if (fp == NULL)
239     return 0;
240 
241 #ifdef HAVE___FSETLOCKING
242   /* No threads present.  */
243   __fsetlocking (fp, FSETLOCKING_BYCALLER);
244 #endif
245 
246   added = 0;
247   while (!FEOF (fp))
248     {
249       /* It is a reasonable approach to use a fix buffer here because
250 	 a) we are only interested in the first two fields
251 	 b) these fields must be usable as file names and so must not
252 	    be that long
253 	 We avoid a multi-kilobyte buffer here since this would use up
254 	 stack space which we might not have if the program ran out of
255 	 memory.  */
256       char buf[400];
257       char *alias;
258       char *value;
259       char *cp;
260 
261       if (FGETS (buf, sizeof buf, fp) == NULL)
262 	/* EOF reached.  */
263 	break;
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 	      size_t alias_len;
287 	      size_t value_len;
288 
289 	      value = cp++;
290 	      while (cp[0] != '\0' && !isspace ((unsigned char) cp[0]))
291 		++cp;
292 	      /* Terminate value.  */
293 	      if (cp[0] == '\n')
294 		{
295 		  /* This has to be done to make the following test
296 		     for the end of line possible.  We are looking for
297 		     the terminating '\n' which do not overwrite here.  */
298 		  *cp++ = '\0';
299 		  *cp = '\n';
300 		}
301 	      else if (cp[0] != '\0')
302 		*cp++ = '\0';
303 
304 	      if (nmap >= maxmap)
305 		if (__builtin_expect (extend_alias_table (), 0))
306 		  return added;
307 
308 	      alias_len = strlen (alias) + 1;
309 	      value_len = strlen (value) + 1;
310 
311 	      if (string_space_act + alias_len + value_len > string_space_max)
312 		{
313 		  /* Increase size of memory pool.  */
314 		  size_t new_size = (string_space_max
315 				     + (alias_len + value_len > 1024
316 					? alias_len + value_len : 1024));
317 		  char *new_pool = (char *) realloc (string_space, new_size);
318 		  if (new_pool == NULL)
319 		    return added;
320 
321 		  if (__builtin_expect (string_space != new_pool, 0))
322 		    {
323 		      size_t i;
324 
325 		      for (i = 0; i < nmap; i++)
326 			{
327 			  map[i].alias += new_pool - string_space;
328 			  map[i].value += new_pool - string_space;
329 			}
330 		    }
331 
332 		  string_space = new_pool;
333 		  string_space_max = new_size;
334 		}
335 
336 	      map[nmap].alias = memcpy (&string_space[string_space_act],
337 					alias, alias_len);
338 	      string_space_act += alias_len;
339 
340 	      map[nmap].value = memcpy (&string_space[string_space_act],
341 					value, value_len);
342 	      string_space_act += value_len;
343 
344 	      ++nmap;
345 	      ++added;
346 	    }
347 	}
348 
349       /* Possibly not the whole line fits into the buffer.  Ignore
350 	 the rest of the line.  */
351       while (strchr (buf, '\n') == NULL)
352 	if (FGETS (buf, sizeof buf, fp) == NULL)
353 	  /* Make sure the inner loop will be left.  The outer loop
354 	     will exit at the `feof' test.  */
355 	  break;
356     }
357 
358   /* Should we test for ferror()?  I think we have to silently ignore
359      errors.  --drepper  */
360   fclose (fp);
361 
362   if (added > 0)
363     qsort (map, nmap, sizeof (struct alias_map),
364 	   (int (*) PARAMS ((const void *, const void *))) alias_compare);
365 
366   return added;
367 }
368 
369 
370 static int
extend_alias_table()371 extend_alias_table ()
372 {
373   size_t new_size;
374   struct alias_map *new_map;
375 
376   new_size = maxmap == 0 ? 100 : 2 * maxmap;
377   new_map = (struct alias_map *) realloc (map, (new_size
378 						* sizeof (struct alias_map)));
379   if (new_map == NULL)
380     /* Simply don't extend: we don't have any more core.  */
381     return -1;
382 
383   map = new_map;
384   maxmap = new_size;
385   return 0;
386 }
387 
388 
389 static int
alias_compare(map1,map2)390 alias_compare (map1, map2)
391      const struct alias_map *map1;
392      const struct alias_map *map2;
393 {
394 #if defined _LIBC || defined HAVE_STRCASECMP
395   return strcasecmp (map1->alias, map2->alias);
396 #else
397   const unsigned char *p1 = (const unsigned char *) map1->alias;
398   const unsigned char *p2 = (const unsigned char *) map2->alias;
399   unsigned char c1, c2;
400 
401   if (p1 == p2)
402     return 0;
403 
404   do
405     {
406       /* I know this seems to be odd but the tolower() function in
407 	 some systems libc cannot handle nonalpha characters.  */
408       c1 = isupper (*p1) ? tolower (*p1) : *p1;
409       c2 = isupper (*p2) ? tolower (*p2) : *p2;
410       if (c1 == '\0')
411 	break;
412       ++p1;
413       ++p2;
414     }
415   while (c1 == c2);
416 
417   return c1 - c2;
418 #endif
419 }
420