intl/localealias.c

   1 /* Handle aliases for locale names.
   2    Copyright (C) 1995-2022 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 <https://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 #pragma GCC diagnostic push
 322
 323 #if defined __GNUC__ && __GNUC__ >= 12
 324   /* Suppress the valid GCC 12 warning until the code below is changed
 325      to avoid using pointers to the reallocated block.  */
 326 #  pragma GCC diagnostic ignored "-Wuse-after-free"
 327 #endif
 328
 329                     /* Increase size of memory pool.  */
 330                       size_t new_size = (string_space_max
 331                                          + (alias_len + value_len > 1024
 332                                             ? alias_len + value_len : 1024));
 333                       char *new_pool = (char *) realloc (string_space, new_size);
 334                       if (new_pool == NULL)
 335                         goto out;
 336
 337                       if (__builtin_expect (string_space != new_pool, 0))
 338                         {
 339                           size_t i;
 340
 341                           for (i = 0; i < nmap; i++)
 342                             {
 343                               map[i].alias += new_pool - string_space;
 344                               map[i].value += new_pool - string_space;
 345                             }
 346                         }
 347
 348                       string_space = new_pool;
 349                       string_space_max = new_size;
 350                     }
 351
 352                   map[nmap].alias =
 353                     (const char *) memcpy (&string_space[string_space_act],
 354                                            alias, alias_len);
 355                   string_space_act += alias_len;
 356
 357                   map[nmap].value =
 358                     (const char *) memcpy (&string_space[string_space_act],
 359                                            value, value_len);
 360                   string_space_act += value_len;
 361
 362 #pragma GCC diagnostic pop
 363
 364                   ++nmap;
 365                   ++added;
 366                 }
 367             }
 368         }
 369
 370       /* Possibly not the whole line fits into the buffer.  Ignore
 371          the rest of the line.  */
 372       if (! complete_line)
 373         do
 374           if (FGETS (buf, sizeof buf, fp) == NULL)
 375             /* Make sure the inner loop will be left.  The outer loop
 376                will exit at the `feof' test.  */
 377             break;
 378         while (strchr (buf, '\n') == NULL);
 379     }
 380
 381  out:
 382   /* Should we test for ferror()?  I think we have to silently ignore
 383      errors.  --drepper  */
 384   fclose (fp);
 385
 386   if (added > 0)
 387     qsort (map, nmap, sizeof (struct alias_map),
 388            (int (*) (const void *, const void *)) alias_compare);
 389
 390   return added;
 391 }
 392
 393
 394 static int
 395 extend_alias_table (void)
 396 {
 397   size_t new_size;
 398   struct alias_map *new_map;
 399
 400   new_size = maxmap == 0 ? 100 : 2 * maxmap;
 401   new_map = (struct alias_map *) realloc (map, (new_size
 402                                                 * sizeof (struct alias_map)));
 403   if (new_map == NULL)
 404     /* Simply don't extend: we don't have any more core.  */
 405     return -1;
 406
 407   map = new_map;
 408   maxmap = new_size;
 409   return 0;
 410 }
 411
 412
 413 static int
 414 alias_compare (const struct alias_map *map1, const struct alias_map *map2)
 415 {
 416 #if defined _LIBC || defined HAVE_STRCASECMP
 417   return strcasecmp (map1->alias, map2->alias);
 418 #else
 419   const unsigned char *p1 = (const unsigned char *) map1->alias;
 420   const unsigned char *p2 = (const unsigned char *) map2->alias;
 421   unsigned char c1, c2;
 422
 423   if (p1 == p2)
 424     return 0;
 425
 426   do
 427     {
 428       /* I know this seems to be odd but the tolower() function in
 429          some systems libc cannot handle nonalpha characters.  */
 430       c1 = isupper (*p1) ? tolower (*p1) : *p1;
 431       c2 = isupper (*p2) ? tolower (*p2) : *p2;
 432       if (c1 == '\0')
 433         break;
 434       ++p1;
 435       ++p2;
 436     }
 437   while (c1 == c2);
 438
 439   return c1 - c2;
 440 #endif
 441 }