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