intl/localealias.c

   1 /* Handle aliases for locale names.
   2    Copyright (C) 1995-1999, 2000, 2001 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 #include <sys/types.h>
  33
  34 #ifdef __GNUC__
  35 # define alloca __builtin_alloca
  36 # define HAVE_ALLOCA 1
  37 #else
  38 # if defined HAVE_ALLOCA_H || defined _LIBC
  39 #  include <alloca.h>
  40 # else
  41 #  ifdef _AIX
  42  #pragma alloca
  43 #  else
  44 #   ifndef alloca
  45 char *alloca ();
  46 #   endif
  47 #  endif
  48 # endif
  49 #endif
  50
  51 #include <stdlib.h>
  52
  53 #include <string.h>
  54 #if !HAVE_STRCHR && !defined _LIBC
  55 # ifndef strchr
  56 #  define strchr index
  57 # endif
  58 #endif
  59
  60 #include "gettextP.h"
  61
  62 /* @@ end of prolog @@ */
  63
  64 #ifdef _LIBC
  65 /* Rename the non ANSI C functions.  This is required by the standard
  66    because some ANSI C functions will require linking with this object
  67    file and the name space must not be polluted.  */
  68 # define strcasecmp __strcasecmp
  69
  70 # ifndef mempcpy
  71 #  define mempcpy __mempcpy
  72 # endif
  73 # define HAVE_MEMPCPY   1
  74
  75 /* We need locking here since we can be called from different places.  */
  76 # include <bits/libc-lock.h>
  77
  78 __libc_lock_define_initialized (static, lock);
  79 #endif
  80
  81 #ifndef internal_function
  82 # define internal_function
  83 #endif
  84
  85 /* For those losing systems which don't have `alloca' we have to add
  86    some additional code emulating it.  */
  87 #ifdef HAVE_ALLOCA
  88 # define freea(p) /* nothing */
  89 #else
  90 # define alloca(n) malloc (n)
  91 # define freea(p) free (p)
  92 #endif
  93
  94 #if defined _LIBC_REENTRANT || defined HAVE_FGETS_UNLOCKED
  95 # undef fgets
  96 # define fgets(buf, len, s) fgets_unlocked (buf, len, s)
  97 #endif
  98 #if defined _LIBC_REENTRANT || defined HAVE_FEOF_UNLOCKED
  99 # undef feof
 100 # define feof(s) feof_unlocked (s)
 101 #endif
 102
 103
 104 struct alias_map
 105 {
 106   const char *alias;
 107   const char *value;
 108 };
 109
 110
 111 static char *string_space;
 112 static size_t string_space_act;
 113 static size_t string_space_max;
 114 static struct alias_map *map;
 115 static size_t nmap;
 116 static size_t maxmap;
 117
 118
 119 /* Prototypes for local functions.  */
 120 static size_t read_alias_file PARAMS ((const char *fname, int fname_len))
 121      internal_function;
 122 static int extend_alias_table PARAMS ((void));
 123 static int alias_compare PARAMS ((const struct alias_map *map1,
 124                                   const struct alias_map *map2));
 125
 126
 127 const char *
 128 _nl_expand_alias (name)
 129     const char *name;
 130 {
 131   static const char *locale_alias_path = LOCALE_ALIAS_PATH;
 132   struct alias_map *retval;
 133   const char *result = NULL;
 134   size_t added;
 135
 136 #ifdef _LIBC
 137   __libc_lock_lock (lock);
 138 #endif
 139
 140   do
 141     {
 142       struct alias_map item;
 143
 144       item.alias = name;
 145
 146       if (nmap > 0)
 147         retval = (struct alias_map *) bsearch (&item, map, nmap,
 148                                                sizeof (struct alias_map),
 149                                                (int (*) PARAMS ((const void *,
 150                                                                  const void *))
 151                                                 ) alias_compare);
 152       else
 153         retval = NULL;
 154
 155       /* We really found an alias.  Return the value.  */
 156       if (retval != NULL)
 157         {
 158           result = retval->value;
 159           break;
 160         }
 161
 162       /* Perhaps we can find another alias file.  */
 163       added = 0;
 164       while (added == 0 && locale_alias_path[0] != '\0')
 165         {
 166           const char *start;
 167
 168           while (locale_alias_path[0] == PATH_SEPARATOR)
 169             ++locale_alias_path;
 170           start = locale_alias_path;
 171
 172           while (locale_alias_path[0] != '\0'
 173                  && locale_alias_path[0] != PATH_SEPARATOR)
 174             ++locale_alias_path;
 175
 176           if (start < locale_alias_path)
 177             added = read_alias_file (start, locale_alias_path - start);
 178         }
 179     }
 180   while (added != 0);
 181
 182 #ifdef _LIBC
 183   __libc_lock_unlock (lock);
 184 #endif
 185
 186   return result;
 187 }
 188
 189
 190 static size_t
 191 internal_function
 192 read_alias_file (fname, fname_len)
 193      const char *fname;
 194      int fname_len;
 195 {
 196   FILE *fp;
 197   char *full_fname;
 198   size_t added;
 199   static const char aliasfile[] = "/locale.alias";
 200
 201   full_fname = (char *) alloca (fname_len + sizeof aliasfile);
 202 #ifdef HAVE_MEMPCPY
 203   mempcpy (mempcpy (full_fname, fname, fname_len),
 204            aliasfile, sizeof aliasfile);
 205 #else
 206   memcpy (full_fname, fname, fname_len);
 207   memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
 208 #endif
 209
 210   fp = fopen (full_fname, "r");
 211   freea (full_fname);
 212   if (fp == NULL)
 213     return 0;
 214
 215   added = 0;
 216   while (!feof (fp))
 217     {
 218       /* It is a reasonable approach to use a fix buffer here because
 219          a) we are only interested in the first two fields
 220          b) these fields must be usable as file names and so must not
 221             be that long
 222        */
 223       char buf[BUFSIZ];
 224       char *alias;
 225       char *value;
 226       char *cp;
 227
 228       if (fgets (buf, sizeof buf, fp) == NULL)
 229         /* EOF reached.  */
 230         break;
 231
 232       /* Possibly not the whole line fits into the buffer.  Ignore
 233          the rest of the line.  */
 234       if (strchr (buf, '\n') == NULL)
 235         {
 236           char altbuf[BUFSIZ];
 237           do
 238             if (fgets (altbuf, sizeof altbuf, fp) == NULL)
 239               /* Make sure the inner loop will be left.  The outer loop
 240                  will exit at the `feof' test.  */
 241               break;
 242           while (strchr (altbuf, '\n') == NULL);
 243         }
 244
 245       cp = buf;
 246       /* Ignore leading white space.  */
 247       while (isspace (cp[0]))
 248         ++cp;
 249
 250       /* A leading '#' signals a comment line.  */
 251       if (cp[0] != '\0' && cp[0] != '#')
 252         {
 253           alias = cp++;
 254           while (cp[0] != '\0' && !isspace (cp[0]))
 255             ++cp;
 256           /* Terminate alias name.  */
 257           if (cp[0] != '\0')
 258             *cp++ = '\0';
 259
 260           /* Now look for the beginning of the value.  */
 261           while (isspace (cp[0]))
 262             ++cp;
 263
 264           if (cp[0] != '\0')
 265             {
 266               size_t alias_len;
 267               size_t value_len;
 268
 269               value = cp++;
 270               while (cp[0] != '\0' && !isspace (cp[0]))
 271                 ++cp;
 272               /* Terminate value.  */
 273               if (cp[0] == '\n')
 274                 {
 275                   /* This has to be done to make the following test
 276                      for the end of line possible.  We are looking for
 277                      the terminating '\n' which do not overwrite here.  */
 278                   *cp++ = '\0';
 279                   *cp = '\n';
 280                 }
 281               else if (cp[0] != '\0')
 282                 *cp++ = '\0';
 283
 284               if (nmap >= maxmap)
 285                 if (__builtin_expect (extend_alias_table (), 0))
 286                   return added;
 287
 288               alias_len = strlen (alias) + 1;
 289               value_len = strlen (value) + 1;
 290
 291               if (string_space_act + alias_len + value_len > string_space_max)
 292                 {
 293                   /* Increase size of memory pool.  */
 294                   size_t new_size = (string_space_max
 295                                      + (alias_len + value_len > 1024
 296                                         ? alias_len + value_len : 1024));
 297                   char *new_pool = (char *) realloc (string_space, new_size);
 298                   if (new_pool == NULL)
 299                     return added;
 300
 301                   if (__builtin_expect (string_space != new_pool, 0))
 302                     {
 303                       size_t i;
 304
 305                       for (i = 0; i < nmap; i++)
 306                         {
 307                           map[i].alias += new_pool - string_space;
 308                           map[i].value += new_pool - string_space;
 309                         }
 310                     }
 311
 312                   string_space = new_pool;
 313                   string_space_max = new_size;
 314                 }
 315
 316               map[nmap].alias = memcpy (&string_space[string_space_act],
 317                                         alias, alias_len);
 318               string_space_act += alias_len;
 319
 320               map[nmap].value = memcpy (&string_space[string_space_act],
 321                                         value, value_len);
 322               string_space_act += value_len;
 323
 324               ++nmap;
 325               ++added;
 326             }
 327         }
 328     }
 329
 330   /* Should we test for ferror()?  I think we have to silently ignore
 331      errors.  --drepper  */
 332   fclose (fp);
 333
 334   if (added > 0)
 335     qsort (map, nmap, sizeof (struct alias_map),
 336            (int (*) PARAMS ((const void *, const void *))) alias_compare);
 337
 338   return added;
 339 }
 340
 341
 342 static int
 343 extend_alias_table ()
 344 {
 345   size_t new_size;
 346   struct alias_map *new_map;
 347
 348   new_size = maxmap == 0 ? 100 : 2 * maxmap;
 349   new_map = (struct alias_map *) realloc (map, (new_size
 350                                                 * sizeof (struct alias_map)));
 351   if (new_map == NULL)
 352     /* Simply don't extend: we don't have any more core.  */
 353     return -1;
 354
 355   map = new_map;
 356   maxmap = new_size;
 357   return 0;
 358 }
 359
 360
 361 #ifdef _LIBC
 362 static void __attribute__ ((unused))
 363 free_mem (void)
 364 {
 365   if (string_space != NULL)
 366     free (string_space);
 367   if (map != NULL)
 368     free (map);
 369 }
 370 text_set_element (__libc_subfreeres, free_mem);
 371 #endif
 372
 373
 374 static int
 375 alias_compare (map1, map2)
 376      const struct alias_map *map1;
 377      const struct alias_map *map2;
 378 {
 379 #if defined _LIBC || defined HAVE_STRCASECMP
 380   return strcasecmp (map1->alias, map2->alias);
 381 #else
 382   const unsigned char *p1 = (const unsigned char *) map1->alias;
 383   const unsigned char *p2 = (const unsigned char *) map2->alias;
 384   unsigned char c1, c2;
 385
 386   if (p1 == p2)
 387     return 0;
 388
 389   do
 390     {
 391       /* I know this seems to be odd but the tolower() function in
 392          some systems libc cannot handle nonalpha characters.  */
 393       c1 = isupper (*p1) ? tolower (*p1) : *p1;
 394       c2 = isupper (*p2) ? tolower (*p2) : *p2;
 395       if (c1 == '\0')
 396         break;
 397       ++p1;
 398       ++p2;
 399     }
 400   while (c1 == c2);
 401
 402   return c1 - c2;
 403 #endif
 404 }