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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
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
53char *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
123struct 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
134libc_freeres_ptr (static char *string_space);
135static size_t string_space_act;
136static size_t string_space_max;
137libc_freeres_ptr (static struct alias_map *map);
138static size_t nmap;
139static size_t maxmap;
140
141
142/* Prototypes for local functions.  */
143static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
144     internal_function;
145static int extend_alias_table PARAMS ((void));
146static int alias_compare PARAMS ((const struct alias_map *map1,
147				  const struct alias_map *map2));
148
149
150const char *
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
216static size_t
217internal_function
218read_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
370static int
371extend_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
389static int
390alias_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