intl/localealias.c

   1 /* Handle aliases for locale names.
   2    Copyright (C) 1995-2017 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as published by
   6    the Free Software Foundation; either version 2.1 of the License, or
   7    (at your option) 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
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  18    This must come before <config.h> because <config.h> may include
  19    <features.h>, and once <features.h> has been included, it's too late.  */
  20 #ifndef _GNU_SOURCE
  21 # define _GNU_SOURCE    1
  22 #endif
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #include <ctype.h>
  29 #include <stdio.h>
  30 #if defined _LIBC || defined HAVE___FSETLOCKING
  31 # include <stdio_ext.h>
  32 #endif
  33 #include <sys/types.h>
  34
  35 #ifdef __GNUC__
  36 # undef alloca
  37 # define alloca __builtin_alloca
  38 # define HAVE_ALLOCA 1
  39 #else
  40 # ifdef _MSC_VER
  41 #  include <malloc.h>
  42 #  define alloca _alloca
  43 # else
  44 #  if defined HAVE_ALLOCA_H || defined _LIBC
  45 #   include <alloca.h>
  46 #  else
  47 #   ifdef _AIX
  48  #pragma alloca
  49 #   else
  50 #    ifndef alloca
  51 char *alloca ();
  52 #    endif
  53 #   endif
  54 #  endif
  55 # endif
  56 #endif
  57
  58 #include <stdlib.h>
  59 #include <string.h>
  60
  61 #include "gettextP.h"
  62
  63 #ifdef ENABLE_RELOCATABLE
  64 # include "relocatable.h"
  65 #else
  66 # define relocate(pathname) (pathname)
  67 #endif
  68
  69 /* @@ end of prolog @@ */
  70
  71 #ifdef _LIBC
  72 /* Rename the non ANSI C functions.  This is required by the standard
  73    because some ANSI C functions will require linking with this object
  74    file and the name space must not be polluted.  */
  75 # define strcasecmp(s1, s2) __strcasecmp_l (s1, s2, _nl_C_locobj_ptr)
  76
  77 # ifndef mempcpy
  78 #  define mempcpy __mempcpy
  79 # endif
  80 # define HAVE_MEMPCPY   1
  81 # define HAVE___FSETLOCKING     1
  82 #endif
  83
  84 /* Handle multi-threaded applications.  */
  85 #ifdef _LIBC
  86 # include <libc-lock.h>
  87 #else
  88 # include "lock.h"
  89 #endif
  90
  91 /* Some optimizations for glibc.  */
  92 #ifdef _LIBC
  93 # define FEOF(fp)               feof_unlocked (fp)
  94 # define FGETS(buf, n, fp)      __fgets_unlocked (buf, n, fp)
  95 #else
  96 # define FEOF(fp)               feof (fp)
  97 # define FGETS(buf, n, fp)      fgets (buf, n, fp)
  98 #endif
  99
 100 /* For those losing systems which don't have `alloca' we have to add
 101    some additional code emulating it.  */
 102 #ifdef HAVE_ALLOCA
 103 # define freea(p) /* nothing */
 104 #else
 105 # define alloca(n) malloc (n)
 106 # define freea(p) free (p)
 107 #endif
 108
 109 #if defined _LIBC_REENTRANT || defined HAVE_DECL_FGETS_UNLOCKED
 110 # undef fgets
 111 # define fgets(buf, len, s) fgets_unlocked (buf, len, s)
 112 #endif
 113 #if defined _LIBC_REENTRANT || defined HAVE_DECL_FEOF_UNLOCKED
 114 # undef feof
 115 # define feof(s) feof_unlocked (s)
 116 #endif
 117
 118
 119 __libc_lock_define_initialized (static, lock)
 120
 121
 122 struct alias_map
 123 {
 124   const char *alias;
 125   const char *value;
 126 };
 127
 128
 129 #ifndef _LIBC
 130 # define libc_freeres_ptr(decl) decl
 131 #endif
 132
 133 libc_freeres_ptr (static char *string_space);
 134 static size_t string_space_act;
 135 static size_t string_space_max;
 136 libc_freeres_ptr (static struct alias_map *map);
 137 static size_t nmap;
 138 static size_t maxmap;
 139
 140
 141 /* Prototypes for local functions.  */
 142 static size_t read_alias_file (const char *fname, int fname_len);
 143 static int extend_alias_table (void);
 144 static int alias_compare (const struct alias_map *map1,
 145                           const struct alias_map *map2);
 146
 147
 148 const char *
 149 _nl_expand_alias (const char *name)
 150 {
 151   static const char *locale_alias_path;
 152   struct alias_map *retval;
 153   const char *result = NULL;
 154   size_t added;
 155
 156   __libc_lock_lock (lock);
 157
 158   if (locale_alias_path == NULL)
 159     locale_alias_path = LOCALE_ALIAS_PATH;
 160
 161   do
 162     {
 163       struct alias_map item;
 164
 165       item.alias = name;
 166
 167       if (nmap > 0)
 168         retval = (struct alias_map *) bsearch (&item, map, nmap,
 169                                                sizeof (struct alias_map),
 170                                                (int (*) (const void *,
 171                                                          const void *)
 172                                                 ) alias_compare);
 173       else
 174         retval = NULL;
 175
 176       /* We really found an alias.  Return the value.  */
 177       if (retval != NULL)
 178         {
 179           result = retval->value;
 180           break;
 181         }
 182
 183       /* Perhaps we can find another alias file.  */
 184       added = 0;
 185       while (added == 0 && locale_alias_path[0] != '\0')
 186         {
 187           const char *start;
 188
 189           while (locale_alias_path[0] == PATH_SEPARATOR)
 190             ++locale_alias_path;
 191           start = locale_alias_path;
 192
 193           while (locale_alias_path[0] != '\0'
 194                  && locale_alias_path[0] != PATH_SEPARATOR)
 195             ++locale_alias_path;
 196
 197           if (start < locale_alias_path)
 198             added = read_alias_file (start, locale_alias_path - start);
 199         }
 200     }
 201   while (added != 0);
 202
 203   __libc_lock_unlock (lock);
 204
 205   return result;
 206 }
 207
 208
 209 static size_t
 210 read_alias_file (const char *fname, int fname_len)
 211 {
 212   FILE *fp;
 213   char *full_fname;
 214   size_t added;
 215   static const char aliasfile[] = "/locale.alias";
 216
 217   full_fname = (char *) alloca (fname_len + sizeof aliasfile);
 218 #ifdef HAVE_MEMPCPY
 219   mempcpy (mempcpy (full_fname, fname, fname_len),
 220            aliasfile, sizeof aliasfile);
 221 #else
 222   memcpy (full_fname, fname, fname_len);
 223   memcpy (&full_fname[fname_len], aliasfile, sizeof aliasfile);
 224 #endif
 225
 226 #ifdef _LIBC
 227   /* Note the file is opened with cancellation in the I/O functions
 228      disabled.  */
 229   fp = fopen (relocate (full_fname), "rce");
 230 #else
 231   fp = fopen (relocate (full_fname), "r");
 232 #endif
 233   freea (full_fname);
 234   if (fp == NULL)
 235     return 0;
 236
 237 #ifdef HAVE___FSETLOCKING
 238   /* No threads present.  */
 239   __fsetlocking (fp, FSETLOCKING_BYCALLER);
 240 #endif
 241
 242   added = 0;
 243   while (!FEOF (fp))
 244     {
 245       /* It is a reasonable approach to use a fix buffer here because
 246          a) we are only interested in the first two fields
 247          b) these fields must be usable as file names and so must not
 248             be that long
 249          We avoid a multi-kilobyte buffer here since this would use up
 250          stack space which we might not have if the program ran out of
 251          memory.  */
 252       char buf[400];
 253       char *alias;
 254       char *value;
 255       char *cp;
 256       int complete_line;
 257
 258       if (FGETS (buf, sizeof buf, fp) == NULL)
 259         /* EOF reached.  */
 260         break;
 261
 262       /* Determine whether the line is complete.  */
 263       complete_line = strchr (buf, '\n') != NULL;
 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               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 #ifdef IN_LIBGLOCALE
 302               /* glibc's locale.alias contains entries for ja_JP and ko_KR
 303                  that make it impossible to use a Japanese or Korean UTF-8
 304                  locale under the name "ja_JP" or "ko_KR".  Ignore these
 305                  entries.  */
 306               if (strchr (alias, '_') == NULL)
 307 #endif
 308                 {
 309                   size_t alias_len;
 310                   size_t value_len;
 311
 312                   if (nmap >= maxmap)
 313                     if (__builtin_expect (extend_alias_table (), 0))
 314                       goto out;
 315
 316                   alias_len = strlen (alias) + 1;
 317                   value_len = strlen (value) + 1;
 318
 319                   if (string_space_act + alias_len + value_len > string_space_max)
 320                     {
 321                       /* Increase size of memory pool.  */
 322                       size_t new_size = (string_space_max
 323                                          + (alias_len + value_len > 1024
 324                                             ? alias_len + value_len : 1024));
 325                       char *new_pool = (char *) realloc (string_space, new_size);
 326                       if (new_pool == NULL)
 327                         goto out;
 328
 329                       if (__builtin_expect (string_space != new_pool, 0))
 330                         {
 331                           size_t i;
 332
 333                           for (i = 0; i < nmap; i++)
 334                             {
 335                               map[i].alias += new_pool - string_space;
 336                               map[i].value += new_pool - string_space;
 337                             }
 338                         }
 339
 340                       string_space = new_pool;
 341                       string_space_max = new_size;
 342                     }
 343
 344                   map[nmap].alias =
 345                     (const char *) memcpy (&string_space[string_space_act],
 346                                            alias, alias_len);
 347                   string_space_act += alias_len;
 348
 349                   map[nmap].value =
 350                     (const char *) memcpy (&string_space[string_space_act],
 351                                            value, value_len);
 352                   string_space_act += value_len;
 353
 354                   ++nmap;
 355                   ++added;
 356                 }
 357             }
 358         }
 359
 360       /* Possibly not the whole line fits into the buffer.  Ignore
 361          the rest of the line.  */
 362       if (! complete_line)
 363         do
 364           if (FGETS (buf, sizeof buf, fp) == NULL)
 365             /* Make sure the inner loop will be left.  The outer loop
 366                will exit at the `feof' test.  */
 367             break;
 368         while (strchr (buf, '\n') == NULL);
 369     }
 370
 371  out:
 372   /* Should we test for ferror()?  I think we have to silently ignore
 373      errors.  --drepper  */
 374   fclose (fp);
 375
 376   if (added > 0)
 377     qsort (map, nmap, sizeof (struct alias_map),
 378            (int (*) (const void *, const void *)) alias_compare);
 379
 380   return added;
 381 }
 382
 383
 384 static int
 385 extend_alias_table (void)
 386 {
 387   size_t new_size;
 388   struct alias_map *new_map;
 389
 390   new_size = maxmap == 0 ? 100 : 2 * maxmap;
 391   new_map = (struct alias_map *) realloc (map, (new_size
 392                                                 * sizeof (struct alias_map)));
 393   if (new_map == NULL)
 394     /* Simply don't extend: we don't have any more core.  */
 395     return -1;
 396
 397   map = new_map;
 398   maxmap = new_size;
 399   return 0;
 400 }
 401
 402
 403 static int
 404 alias_compare (const struct alias_map *map1, const struct alias_map *map2)
 405 {
 406 #if defined _LIBC || defined HAVE_STRCASECMP
 407   return strcasecmp (map1->alias, map2->alias);
 408 #else
 409   const unsigned char *p1 = (const unsigned char *) map1->alias;
 410   const unsigned char *p2 = (const unsigned char *) map2->alias;
 411   unsigned char c1, c2;
 412
 413   if (p1 == p2)
 414     return 0;
 415
 416   do
 417     {
 418       /* I know this seems to be odd but the tolower() function in
 419          some systems libc cannot handle nonalpha characters.  */
 420       c1 = isupper (*p1) ? tolower (*p1) : *p1;
 421       c2 = isupper (*p2) ? tolower (*p2) : *p2;
 422       if (c1 == '\0')
 423         break;
 424       ++p1;
 425       ++p2;
 426     }
 427   while (c1 == c2);
 428
 429   return c1 - c2;
 430 #endif
 431 }