intl/localealias.c

   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 *
 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
 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
 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
 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 }