intl/dcigettext.c

   1 /* Implementation of the internal dcigettext function.
   2    Copyright (C) 1995-2005, 2006 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  21    This must come before <config.h> because <config.h> may include
  22    <features.h>, and once <features.h> has been included, it's too late.  */
  23 #ifndef _GNU_SOURCE
  24 # define _GNU_SOURCE    1
  25 #endif
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include <config.h>
  29 #endif
  30
  31 #include <sys/types.h>
  32
  33 #ifdef __GNUC__
  34 # define alloca __builtin_alloca
  35 # define HAVE_ALLOCA 1
  36 #else
  37 # if defined HAVE_ALLOCA_H || defined _LIBC
  38 #  include <alloca.h>
  39 # else
  40 #  ifdef _AIX
  41  #pragma alloca
  42 #  else
  43 #   ifndef alloca
  44 char *alloca ();
  45 #   endif
  46 #  endif
  47 # endif
  48 #endif
  49
  50 #include <errno.h>
  51 #ifndef errno
  52 extern int errno;
  53 #endif
  54 #ifndef __set_errno
  55 # define __set_errno(val) errno = (val)
  56 #endif
  57
  58 #include <stddef.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61
  62 #if defined HAVE_UNISTD_H || defined _LIBC
  63 # include <unistd.h>
  64 #endif
  65
  66 #include <locale.h>
  67
  68 #if defined HAVE_SYS_PARAM_H || defined _LIBC
  69 # include <sys/param.h>
  70 #endif
  71
  72 #include "gettextP.h"
  73 #include "plural-exp.h"
  74 #ifdef _LIBC
  75 # include <libintl.h>
  76 #else
  77 # include "libgnuintl.h"
  78 #endif
  79 #include "hash-string.h"
  80
  81 /* Thread safetyness.  */
  82 #ifdef _LIBC
  83 # include <bits/libc-lock.h>
  84 #else
  85 /* Provide dummy implementation if this is outside glibc.  */
  86 # define __libc_lock_define_initialized(CLASS, NAME)
  87 # define __libc_lock_lock(NAME)
  88 # define __libc_lock_unlock(NAME)
  89 # define __libc_rwlock_define_initialized(CLASS, NAME)
  90 # define __libc_rwlock_rdlock(NAME)
  91 # define __libc_rwlock_unlock(NAME)
  92 #endif
  93
  94 /* Alignment of types.  */
  95 #if defined __GNUC__ && __GNUC__ >= 2
  96 # define alignof(TYPE) __alignof__ (TYPE)
  97 #else
  98 # define alignof(TYPE) \
  99     ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
 100 #endif
 101
 102 /* The internal variables in the standalone libintl.a must have different
 103    names than the internal variables in GNU libc, otherwise programs
 104    using libintl.a cannot be linked statically.  */
 105 #if !defined _LIBC
 106 # define _nl_default_default_domain libintl_nl_default_default_domain
 107 # define _nl_current_default_domain libintl_nl_current_default_domain
 108 # define _nl_default_dirname libintl_nl_default_dirname
 109 # define _nl_domain_bindings libintl_nl_domain_bindings
 110 #endif
 111
 112 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
 113 #ifndef offsetof
 114 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
 115 #endif
 116
 117 /* @@ end of prolog @@ */
 118
 119 #ifdef _LIBC
 120 /* Rename the non ANSI C functions.  This is required by the standard
 121    because some ANSI C functions will require linking with this object
 122    file and the name space must not be polluted.  */
 123 # define getcwd __getcwd
 124 # ifndef stpcpy
 125 #  define stpcpy __stpcpy
 126 # endif
 127 # define tfind __tfind
 128 #else
 129 # if !defined HAVE_GETCWD
 130 char *getwd ();
 131 #  define getcwd(buf, max) getwd (buf)
 132 # else
 133 char *getcwd ();
 134 # endif
 135 # ifndef HAVE_STPCPY
 136 static char *stpcpy PARAMS ((char *dest, const char *src));
 137 # endif
 138 # ifndef HAVE_MEMPCPY
 139 static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
 140 # endif
 141 #endif
 142
 143 /* Amount to increase buffer size by in each try.  */
 144 #define PATH_INCR 32
 145
 146 /* The following is from pathmax.h.  */
 147 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
 148    PATH_MAX but might cause redefinition warnings when sys/param.h is
 149    later included (as on MORE/BSD 4.3).  */
 150 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
 151 # include <limits.h>
 152 #endif
 153
 154 #ifndef _POSIX_PATH_MAX
 155 # define _POSIX_PATH_MAX 255
 156 #endif
 157
 158 #if !defined PATH_MAX && defined _PC_PATH_MAX
 159 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
 160 #endif
 161
 162 /* Don't include sys/param.h if it already has been.  */
 163 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
 164 # include <sys/param.h>
 165 #endif
 166
 167 #if !defined PATH_MAX && defined MAXPATHLEN
 168 # define PATH_MAX MAXPATHLEN
 169 #endif
 170
 171 #ifndef PATH_MAX
 172 # define PATH_MAX _POSIX_PATH_MAX
 173 #endif
 174
 175 /* Whether to support different locales in different threads.  */
 176 #if defined _LIBC || HAVE_NL_LOCALE_NAME
 177 # define HAVE_PER_THREAD_LOCALE
 178 #endif
 179
 180 /* This is the type used for the search tree where known translations
 181    are stored.  */
 182 struct known_translation_t
 183 {
 184   /* Domain in which to search.  */
 185   const char *domainname;
 186
 187   /* The category.  */
 188   int category;
 189
 190 #ifdef HAVE_PER_THREAD_LOCALE
 191   /* Name of the relevant locale category, or "" for the global locale.  */
 192   const char *localename;
 193 #endif
 194
 195   /* State of the catalog counter at the point the string was found.  */
 196   int counter;
 197
 198   /* Catalog where the string was found.  */
 199   struct loaded_l10nfile *domain;
 200
 201   /* And finally the translation.  */
 202   const char *translation;
 203   size_t translation_length;
 204
 205   /* Pointer to the string in question.  */
 206   char msgid[ZERO];
 207 };
 208
 209 /* Root of the search tree with known translations.  We can use this
 210    only if the system provides the `tsearch' function family.  */
 211 #if defined HAVE_TSEARCH || defined _LIBC
 212 # include <search.h>
 213
 214 static void *root;
 215
 216 # ifdef _LIBC
 217 #  define tsearch __tsearch
 218 # endif
 219
 220 /* Function to compare two entries in the table of known translations.  */
 221 static int transcmp PARAMS ((const void *p1, const void *p2));
 222 static int
 223 transcmp (p1, p2)
 224      const void *p1;
 225      const void *p2;
 226 {
 227   const struct known_translation_t *s1;
 228   const struct known_translation_t *s2;
 229   int result;
 230
 231   s1 = (const struct known_translation_t *) p1;
 232   s2 = (const struct known_translation_t *) p2;
 233
 234   result = strcmp (s1->msgid, s2->msgid);
 235   if (result == 0)
 236     {
 237       result = strcmp (s1->domainname, s2->domainname);
 238       if (result == 0)
 239         {
 240 #ifdef HAVE_PER_THREAD_LOCALE
 241           result = strcmp (s1->localename, s2->localename);
 242           if (result == 0)
 243 #endif
 244             /* We compare the category last (though this is the cheapest
 245                operation) since it is hopefully always the same (namely
 246                LC_MESSAGES).  */
 247             result = s1->category - s2->category;
 248         }
 249     }
 250
 251   return result;
 252 }
 253 #endif
 254
 255 /* Name of the default domain used for gettext(3) prior any call to
 256    textdomain(3).  The default value for this is "messages".  */
 257 const char _nl_default_default_domain[] attribute_hidden = "messages";
 258
 259 /* Value used as the default domain for gettext(3).  */
 260 const char *_nl_current_default_domain attribute_hidden
 261      = _nl_default_default_domain;
 262
 263 /* Contains the default location of the message catalogs.  */
 264
 265 #ifdef _LIBC
 266 extern const char _nl_default_dirname[];
 267 libc_hidden_proto (_nl_default_dirname)
 268 #endif
 269 const char _nl_default_dirname[] = LOCALEDIR;
 270 #ifdef _LIBC
 271 libc_hidden_data_def (_nl_default_dirname)
 272 #endif
 273
 274 /* List with bindings of specific domains created by bindtextdomain()
 275    calls.  */
 276 struct binding *_nl_domain_bindings;
 277
 278 /* Prototypes for local functions.  */
 279 static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
 280                                     unsigned long int n,
 281                                     const char *translation,
 282                                     size_t translation_len))
 283      internal_function;
 284 static const char *guess_category_value PARAMS ((int category,
 285                                                  const char *categoryname))
 286      internal_function;
 287 #ifdef _LIBC
 288 # include "../locale/localeinfo.h"
 289 # define category_to_name(category) \
 290   _nl_category_names.str + _nl_category_name_idxs[category]
 291 #else
 292 static const char *category_to_name PARAMS ((int category)) internal_function;
 293 #endif
 294
 295
 296 /* For those loosing systems which don't have `alloca' we have to add
 297    some additional code emulating it.  */
 298 #ifdef HAVE_ALLOCA
 299 /* Nothing has to be done.  */
 300 # define freea(p) /* nothing */
 301 # define ADD_BLOCK(list, address) /* nothing */
 302 # define FREE_BLOCKS(list) /* nothing */
 303 #else
 304 struct block_list
 305 {
 306   void *address;
 307   struct block_list *next;
 308 };
 309 # define ADD_BLOCK(list, addr)                                                \
 310   do {                                                                        \
 311     struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
 312     /* If we cannot get a free block we cannot add the new element to         \
 313        the list.  */                                                          \
 314     if (newp != NULL) {                                                       \
 315       newp->address = (addr);                                                 \
 316       newp->next = (list);                                                    \
 317       (list) = newp;                                                          \
 318     }                                                                         \
 319   } while (0)
 320 # define FREE_BLOCKS(list)                                                    \
 321   do {                                                                        \
 322     while (list != NULL) {                                                    \
 323       struct block_list *old = list;                                          \
 324       list = list->next;                                                      \
 325       free (old->address);                                                    \
 326       free (old);                                                             \
 327     }                                                                         \
 328   } while (0)
 329 # undef alloca
 330 # define alloca(size) (malloc (size))
 331 # define freea(p) free (p)
 332 #endif  /* have alloca */
 333
 334
 335 #ifdef _LIBC
 336 /* List of blocks allocated for translations.  */
 337 typedef struct transmem_list
 338 {
 339   struct transmem_list *next;
 340   char data[ZERO];
 341 } transmem_block_t;
 342 static struct transmem_list *transmem_list;
 343 #else
 344 typedef unsigned char transmem_block_t;
 345 #endif
 346 #if defined _LIBC || HAVE_ICONV
 347 static const char *get_output_charset PARAMS ((struct binding *domainbinding))
 348      internal_function;
 349 #endif
 350
 351
 352 /* Names for the libintl functions are a problem.  They must not clash
 353    with existing names and they should follow ANSI C.  But this source
 354    code is also used in GNU C Library where the names have a __
 355    prefix.  So we have to make a difference here.  */
 356 #ifdef _LIBC
 357 # define DCIGETTEXT __dcigettext
 358 #else
 359 # define DCIGETTEXT libintl_dcigettext
 360 #endif
 361
 362 /* Lock variable to protect the global data in the gettext implementation.  */
 363 #ifdef _LIBC
 364 __libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
 365 #endif
 366
 367 /* Checking whether the binaries runs SUID must be done and glibc provides
 368    easier methods therefore we make a difference here.  */
 369 #ifdef _LIBC
 370 # define ENABLE_SECURE __libc_enable_secure
 371 # define DETERMINE_SECURE
 372 #else
 373 # ifndef HAVE_GETUID
 374 #  define getuid() 0
 375 # endif
 376 # ifndef HAVE_GETGID
 377 #  define getgid() 0
 378 # endif
 379 # ifndef HAVE_GETEUID
 380 #  define geteuid() getuid()
 381 # endif
 382 # ifndef HAVE_GETEGID
 383 #  define getegid() getgid()
 384 # endif
 385 static int enable_secure;
 386 # define ENABLE_SECURE (enable_secure == 1)
 387 # define DETERMINE_SECURE \
 388   if (enable_secure == 0)                                                     \
 389     {                                                                         \
 390       if (getuid () != geteuid () || getgid () != getegid ())                 \
 391         enable_secure = 1;                                                    \
 392       else                                                                    \
 393         enable_secure = -1;                                                   \
 394     }
 395 #endif
 396
 397 /* Get the function to evaluate the plural expression.  */
 398 #include "plural-eval.c"
 399
 400 /* Look up MSGID in the DOMAINNAME message catalog for the current
 401    CATEGORY locale and, if PLURAL is nonzero, search over string
 402    depending on the plural form determined by N.  */
 403 char *
 404 DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
 405      const char *domainname;
 406      const char *msgid1;
 407      const char *msgid2;
 408      int plural;
 409      unsigned long int n;
 410      int category;
 411 {
 412 #ifndef HAVE_ALLOCA
 413   struct block_list *block_list = NULL;
 414 #endif
 415   struct loaded_l10nfile *domain;
 416   struct binding *binding;
 417   const char *categoryname;
 418   const char *categoryvalue;
 419   char *dirname, *xdomainname;
 420   char *single_locale;
 421   char *retval;
 422   size_t retlen;
 423   int saved_errno;
 424 #if defined HAVE_TSEARCH || defined _LIBC
 425   struct known_translation_t *search;
 426   struct known_translation_t **foundp = NULL;
 427   size_t msgid_len;
 428 # ifdef HAVE_PER_THREAD_LOCALE
 429   const char *localename;
 430 # endif
 431 #endif
 432   size_t domainname_len;
 433
 434   /* If no real MSGID is given return NULL.  */
 435   if (msgid1 == NULL)
 436     return NULL;
 437
 438 #ifdef _LIBC
 439   if (category < 0 || category >= __LC_LAST || category == LC_ALL)
 440     /* Bogus.  */
 441     return (plural == 0
 442             ? (char *) msgid1
 443             /* Use the Germanic plural rule.  */
 444             : n == 1 ? (char *) msgid1 : (char *) msgid2);
 445 #endif
 446
 447   __libc_rwlock_rdlock (_nl_state_lock);
 448
 449   /* If DOMAINNAME is NULL, we are interested in the default domain.  If
 450      CATEGORY is not LC_MESSAGES this might not make much sense but the
 451      definition left this undefined.  */
 452   if (domainname == NULL)
 453     domainname = _nl_current_default_domain;
 454
 455 #if defined HAVE_TSEARCH || defined _LIBC
 456   msgid_len = strlen (msgid1) + 1;
 457
 458   /* Try to find the translation among those which we found at
 459      some time.  */
 460   search = (struct known_translation_t *)
 461            alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
 462   memcpy (search->msgid, msgid1, msgid_len);
 463   search->domainname = domainname;
 464   search->category = category;
 465 # ifdef HAVE_PER_THREAD_LOCALE
 466 #  ifdef _LIBC
 467   localename = __current_locale_name (category);
 468 #  endif
 469   search->localename = localename;
 470 # endif
 471
 472   /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
 473      tsearch calls can be fatal.  */
 474   __libc_rwlock_define_initialized (static, tree_lock);
 475   __libc_rwlock_rdlock (tree_lock);
 476
 477   foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
 478
 479   __libc_rwlock_unlock (tree_lock);
 480
 481   freea (search);
 482   if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
 483     {
 484       /* Now deal with plural.  */
 485       if (plural)
 486         retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
 487                                 (*foundp)->translation_length);
 488       else
 489         retval = (char *) (*foundp)->translation;
 490
 491       __libc_rwlock_unlock (_nl_state_lock);
 492       return retval;
 493     }
 494 #endif
 495
 496   /* Preserve the `errno' value.  */
 497   saved_errno = errno;
 498
 499   /* See whether this is a SUID binary or not.  */
 500   DETERMINE_SECURE;
 501
 502   /* First find matching binding.  */
 503   for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
 504     {
 505       int compare = strcmp (domainname, binding->domainname);
 506       if (compare == 0)
 507         /* We found it!  */
 508         break;
 509       if (compare < 0)
 510         {
 511           /* It is not in the list.  */
 512           binding = NULL;
 513           break;
 514         }
 515     }
 516
 517   if (binding == NULL)
 518     dirname = (char *) _nl_default_dirname;
 519   else if (binding->dirname[0] == '/')
 520     dirname = binding->dirname;
 521   else
 522     {
 523       /* We have a relative path.  Make it absolute now.  */
 524       size_t dirname_len = strlen (binding->dirname) + 1;
 525       size_t path_max;
 526       char *ret;
 527
 528       path_max = (unsigned int) PATH_MAX;
 529       path_max += 2;            /* The getcwd docs say to do this.  */
 530
 531       for (;;)
 532         {
 533           dirname = (char *) alloca (path_max + dirname_len);
 534           ADD_BLOCK (block_list, dirname);
 535
 536           __set_errno (0);
 537           ret = getcwd (dirname, path_max);
 538           if (ret != NULL || errno != ERANGE)
 539             break;
 540
 541           path_max += path_max / 2;
 542           path_max += PATH_INCR;
 543         }
 544
 545       if (ret == NULL)
 546         {
 547           /* We cannot get the current working directory.  Don't signal an
 548              error but simply return the default string.  */
 549           FREE_BLOCKS (block_list);
 550           __libc_rwlock_unlock (_nl_state_lock);
 551           __set_errno (saved_errno);
 552           return (plural == 0
 553                   ? (char *) msgid1
 554                   /* Use the Germanic plural rule.  */
 555                   : n == 1 ? (char *) msgid1 : (char *) msgid2);
 556         }
 557
 558       stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
 559     }
 560
 561   /* Now determine the symbolic name of CATEGORY and its value.  */
 562   categoryname = category_to_name (category);
 563   categoryvalue = guess_category_value (category, categoryname);
 564
 565   domainname_len = strlen (domainname);
 566   xdomainname = (char *) alloca (strlen (categoryname)
 567                                  + domainname_len + 5);
 568   ADD_BLOCK (block_list, xdomainname);
 569
 570   stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
 571                   domainname, domainname_len),
 572           ".mo");
 573
 574   /* Creating working area.  */
 575   single_locale = (char *) alloca (strlen (categoryvalue) + 1);
 576   ADD_BLOCK (block_list, single_locale);
 577
 578
 579   /* Search for the given string.  This is a loop because we perhaps
 580      got an ordered list of languages to consider for the translation.  */
 581   while (1)
 582     {
 583       /* Make CATEGORYVALUE point to the next element of the list.  */
 584       while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
 585         ++categoryvalue;
 586       if (categoryvalue[0] == '\0')
 587         {
 588           /* The whole contents of CATEGORYVALUE has been searched but
 589              no valid entry has been found.  We solve this situation
 590              by implicitly appending a "C" entry, i.e. no translation
 591              will take place.  */
 592           single_locale[0] = 'C';
 593           single_locale[1] = '\0';
 594         }
 595       else
 596         {
 597           char *cp = single_locale;
 598           while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
 599             *cp++ = *categoryvalue++;
 600           *cp = '\0';
 601
 602           /* When this is a SUID binary we must not allow accessing files
 603              outside the dedicated directories.  */
 604           if (ENABLE_SECURE && strchr (single_locale, '/') != NULL)
 605             /* Ingore this entry.  */
 606             continue;
 607         }
 608
 609       /* If the current locale value is C (or POSIX) we don't load a
 610          domain.  Return the MSGID.  */
 611       if (strcmp (single_locale, "C") == 0
 612           || strcmp (single_locale, "POSIX") == 0)
 613         {
 614           FREE_BLOCKS (block_list);
 615           __libc_rwlock_unlock (_nl_state_lock);
 616           __set_errno (saved_errno);
 617           return (plural == 0
 618                   ? (char *) msgid1
 619                   /* Use the Germanic plural rule.  */
 620                   : n == 1 ? (char *) msgid1 : (char *) msgid2);
 621         }
 622
 623
 624       /* Find structure describing the message catalog matching the
 625          DOMAINNAME and CATEGORY.  */
 626       domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
 627
 628       if (domain != NULL)
 629         {
 630           retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
 631
 632           if (retval == NULL)
 633             {
 634               int cnt;
 635
 636               for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
 637                 {
 638                   retval = _nl_find_msg (domain->successor[cnt], binding,
 639                                          msgid1, 1, &retlen);
 640
 641                   if (retval != NULL)
 642                     {
 643                       domain = domain->successor[cnt];
 644                       break;
 645                     }
 646                 }
 647             }
 648
 649           if (retval != NULL)
 650             {
 651               /* Found the translation of MSGID1 in domain DOMAIN:
 652                  starting at RETVAL, RETLEN bytes.  */
 653               FREE_BLOCKS (block_list);
 654 #if defined HAVE_TSEARCH || defined _LIBC
 655               if (foundp == NULL)
 656                 {
 657                   /* Create a new entry and add it to the search tree.  */
 658                   size_t size;
 659                   struct known_translation_t *newp;
 660
 661                   size = offsetof (struct known_translation_t, msgid)
 662                          + msgid_len + domainname_len + 1;
 663 # ifdef HAVE_PER_THREAD_LOCALE
 664                   size += strlen (localename) + 1;
 665 # endif
 666                   newp = (struct known_translation_t *) malloc (size);
 667                   if (newp != NULL)
 668                     {
 669                       char *new_domainname;
 670 # ifdef HAVE_PER_THREAD_LOCALE
 671                       char *new_localename;
 672 # endif
 673
 674                       new_domainname = mempcpy (newp->msgid, msgid1, msgid_len);
 675                       memcpy (new_domainname, domainname, domainname_len + 1);
 676 # ifdef HAVE_PER_THREAD_LOCALE
 677                       new_localename = new_domainname + domainname_len + 1;
 678                       strcpy (new_localename, localename);
 679 # endif
 680                       newp->domainname = new_domainname;
 681                       newp->category = category;
 682 # ifdef HAVE_PER_THREAD_LOCALE
 683                       newp->localename = new_localename;
 684 # endif
 685                       newp->counter = _nl_msg_cat_cntr;
 686                       newp->domain = domain;
 687                       newp->translation = retval;
 688                       newp->translation_length = retlen;
 689
 690                       __libc_rwlock_wrlock (tree_lock);
 691
 692                       /* Insert the entry in the search tree.  */
 693                       foundp = (struct known_translation_t **)
 694                         tsearch (newp, &root, transcmp);
 695
 696                       __libc_rwlock_unlock (tree_lock);
 697
 698                       if (foundp == NULL
 699                           || __builtin_expect (*foundp != newp, 0))
 700                         /* The insert failed.  */
 701                         free (newp);
 702                     }
 703                 }
 704               else
 705                 {
 706                   /* We can update the existing entry.  */
 707                   (*foundp)->counter = _nl_msg_cat_cntr;
 708                   (*foundp)->domain = domain;
 709                   (*foundp)->translation = retval;
 710                   (*foundp)->translation_length = retlen;
 711                 }
 712 #endif
 713               __set_errno (saved_errno);
 714
 715               /* Now deal with plural.  */
 716               if (plural)
 717                 retval = plural_lookup (domain, n, retval, retlen);
 718
 719               __libc_rwlock_unlock (_nl_state_lock);
 720               return retval;
 721             }
 722         }
 723     }
 724   /* NOTREACHED */
 725 }
 726
 727
 728 char *
 729 internal_function
 730 _nl_find_msg (domain_file, domainbinding, msgid, convert, lengthp)
 731      struct loaded_l10nfile *domain_file;
 732      struct binding *domainbinding;
 733      const char *msgid;
 734      int convert;
 735      size_t *lengthp;
 736 {
 737   struct loaded_domain *domain;
 738   nls_uint32 nstrings;
 739   size_t act;
 740   char *result;
 741   size_t resultlen;
 742
 743   if (domain_file->decided <= 0)
 744     _nl_load_domain (domain_file, domainbinding);
 745
 746   if (domain_file->data == NULL)
 747     return NULL;
 748
 749   domain = (struct loaded_domain *) domain_file->data;
 750
 751   nstrings = domain->nstrings;
 752
 753   /* Locate the MSGID and its translation.  */
 754   if (domain->hash_tab != NULL)
 755     {
 756       /* Use the hashing table.  */
 757       nls_uint32 len = strlen (msgid);
 758       nls_uint32 hash_val = __hash_string (msgid);
 759       nls_uint32 idx = hash_val % domain->hash_size;
 760       nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
 761
 762       while (1)
 763         {
 764           nls_uint32 nstr =
 765             W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
 766
 767           if (nstr == 0)
 768             /* Hash table entry is empty.  */
 769             return NULL;
 770
 771           nstr--;
 772
 773           /* Compare msgid with the original string at index nstr.
 774              We compare the lengths with >=, not ==, because plural entries
 775              are represented by strings with an embedded NUL.  */
 776           if (nstr < nstrings
 777               ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
 778                 && (strcmp (msgid,
 779                             domain->data + W (domain->must_swap,
 780                                               domain->orig_tab[nstr].offset))
 781                     == 0)
 782               : domain->orig_sysdep_tab[nstr - nstrings].length > len
 783                 && (strcmp (msgid,
 784                             domain->orig_sysdep_tab[nstr - nstrings].pointer)
 785                     == 0))
 786             {
 787               act = nstr;
 788               goto found;
 789             }
 790
 791           if (idx >= domain->hash_size - incr)
 792             idx -= domain->hash_size - incr;
 793           else
 794             idx += incr;
 795         }
 796       /* NOTREACHED */
 797     }
 798   else
 799     {
 800       /* Try the default method:  binary search in the sorted array of
 801          messages.  */
 802       size_t top, bottom;
 803
 804       bottom = 0;
 805       top = nstrings;
 806       while (bottom < top)
 807         {
 808           int cmp_val;
 809
 810           act = (bottom + top) / 2;
 811           cmp_val = strcmp (msgid, (domain->data
 812                                     + W (domain->must_swap,
 813                                          domain->orig_tab[act].offset)));
 814           if (cmp_val < 0)
 815             top = act;
 816           else if (cmp_val > 0)
 817             bottom = act + 1;
 818           else
 819             goto found;
 820         }
 821       /* No translation was found.  */
 822       return NULL;
 823     }
 824
 825  found:
 826   /* The translation was found at index ACT.  If we have to convert the
 827      string to use a different character set, this is the time.  */
 828   if (act < nstrings)
 829     {
 830       result = (char *)
 831         (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
 832       resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
 833     }
 834   else
 835     {
 836       result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
 837       resultlen = domain->trans_sysdep_tab[act - nstrings].length;
 838     }
 839
 840 #if defined _LIBC || HAVE_ICONV
 841   if (convert)
 842     {
 843       /* We are supposed to do a conversion.  */
 844       const char *encoding = get_output_charset (domainbinding);
 845
 846       /* Search whether a table with converted translations for this
 847          encoding has already been allocated.  */
 848       size_t nconversions = domain->nconversions;
 849       struct converted_domain *convd = NULL;
 850       size_t i;
 851
 852       for (i = nconversions; i > 0; )
 853         {
 854           i--;
 855           if (strcmp (domain->conversions[i].encoding, encoding) == 0)
 856             {
 857               convd = &domain->conversions[i];
 858               break;
 859             }
 860         }
 861
 862       if (convd == NULL)
 863         {
 864           /* Allocate a table for the converted translations for this
 865              encoding.  */
 866           struct converted_domain *new_conversions =
 867             (struct converted_domain *)
 868             (domain->conversions != NULL
 869              ? realloc (domain->conversions,
 870                         (nconversions + 1) * sizeof (struct converted_domain))
 871              : malloc ((nconversions + 1) * sizeof (struct converted_domain)));
 872
 873           if (__builtin_expect (new_conversions == NULL, 0))
 874             /* Nothing we can do, no more memory.  */
 875             goto converted;
 876           domain->conversions = new_conversions;
 877
 878           /* Copy the 'encoding' string to permanent storage.  */
 879           encoding = strdup (encoding);
 880           if (__builtin_expect (encoding == NULL, 0))
 881             /* Nothing we can do, no more memory.  */
 882             goto converted;
 883
 884           convd = &new_conversions[nconversions];
 885           convd->encoding = encoding;
 886
 887           /* Find out about the character set the file is encoded with.
 888              This can be found (in textual form) in the entry "".  If this
 889              entry does not exist or if this does not contain the 'charset='
 890              information, we will assume the charset matches the one the
 891              current locale and we don't have to perform any conversion.  */
 892 # ifdef _LIBC
 893           convd->conv = (__gconv_t) -1;
 894 # else
 895 #  if HAVE_ICONV
 896           convd->conv = (iconv_t) -1;
 897 #  endif
 898 # endif
 899           {
 900             char *nullentry;
 901             size_t nullentrylen;
 902
 903             /* Get the header entry.  This is a recursion, but it doesn't
 904                reallocate domain->conversions because we pass convert = 0.  */
 905             nullentry =
 906               _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
 907
 908             if (nullentry != NULL)
 909               {
 910                 const char *charsetstr;
 911
 912                 charsetstr = strstr (nullentry, "charset=");
 913                 if (charsetstr != NULL)
 914                   {
 915                     size_t len;
 916                     char *charset;
 917                     const char *outcharset;
 918
 919                     charsetstr += strlen ("charset=");
 920                     len = strcspn (charsetstr, " \t\n");
 921
 922                     charset = (char *) alloca (len + 1);
 923 # if defined _LIBC || HAVE_MEMPCPY
 924                     *((char *) mempcpy (charset, charsetstr, len)) = '\0';
 925 # else
 926                     memcpy (charset, charsetstr, len);
 927                     charset[len] = '\0';
 928 # endif
 929
 930                     outcharset = encoding;
 931
 932 # ifdef _LIBC
 933                     /* We always want to use transliteration.  */
 934                     outcharset = norm_add_slashes (outcharset, "TRANSLIT");
 935                     charset = norm_add_slashes (charset, "");
 936                     if (__gconv_open (outcharset, charset, &convd->conv,
 937                                       GCONV_AVOID_NOCONV)
 938                         != __GCONV_OK)
 939                       convd->conv = (__gconv_t) -1;
 940 # else
 941 #  if HAVE_ICONV
 942                     /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
 943                        we want to use transliteration.  */
 944 #   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
 945        || _LIBICONV_VERSION >= 0x0105
 946                     if (strchr (outcharset, '/') == NULL)
 947                       {
 948                         char *tmp;
 949
 950                         len = strlen (outcharset);
 951                         tmp = (char *) alloca (len + 10 + 1);
 952                         memcpy (tmp, outcharset, len);
 953                         memcpy (tmp + len, "//TRANSLIT", 10 + 1);
 954                         outcharset = tmp;
 955
 956                         convd->conv = iconv_open (outcharset, charset);
 957
 958                         freea (outcharset);
 959                       }
 960                     else
 961 #   endif
 962                       convd->conv = iconv_open (outcharset, charset);
 963 #  endif
 964 # endif
 965
 966                     freea (charset);
 967                   }
 968               }
 969           }
 970           convd->conv_tab = NULL;
 971           /* Here domain->conversions is still == new_conversions.  */
 972           domain->nconversions++;
 973         }
 974
 975       if (
 976 # ifdef _LIBC
 977           convd->conv != (__gconv_t) -1
 978 # else
 979 #  if HAVE_ICONV
 980           convd->conv != (iconv_t) -1
 981 #  endif
 982 # endif
 983           )
 984         {
 985           /* We are supposed to do a conversion.  First allocate an
 986              appropriate table with the same structure as the table
 987              of translations in the file, where we can put the pointers
 988              to the converted strings in.
 989              There is a slight complication with plural entries.  They
 990              are represented by consecutive NUL terminated strings.  We
 991              handle this case by converting RESULTLEN bytes, including
 992              NULs.  */
 993
 994           if (convd->conv_tab == NULL
 995               && ((convd->conv_tab =
 996                     (char **) calloc (nstrings + domain->n_sysdep_strings,
 997                                       sizeof (char *)))
 998                   == NULL))
 999             /* Mark that we didn't succeed allocating a table.  */
1000             convd->conv_tab = (char **) -1;
1001
1002           if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
1003             /* Nothing we can do, no more memory.  */
1004             goto converted;
1005
1006           if (convd->conv_tab[act] == NULL)
1007             {
1008               /* We haven't used this string so far, so it is not
1009                  translated yet.  Do this now.  */
1010               /* We use a bit more efficient memory handling.
1011                  We allocate always larger blocks which get used over
1012                  time.  This is faster than many small allocations.   */
1013               __libc_lock_define_initialized (static, lock)
1014 # define INITIAL_BLOCK_SIZE     4080
1015               static unsigned char *freemem;
1016               static size_t freemem_size;
1017
1018               const unsigned char *inbuf;
1019               unsigned char *outbuf;
1020               int malloc_count;
1021 # ifndef _LIBC
1022               transmem_block_t *transmem_list = NULL;
1023 # endif
1024
1025               __libc_lock_lock (lock);
1026
1027               inbuf = (const unsigned char *) result;
1028               outbuf = freemem + sizeof (size_t);
1029
1030               malloc_count = 0;
1031               while (1)
1032                 {
1033                   transmem_block_t *newmem;
1034 # ifdef _LIBC
1035                   size_t non_reversible;
1036                   int res;
1037
1038                   if (freemem_size < sizeof (size_t))
1039                     goto resize_freemem;
1040
1041                   res = __gconv (convd->conv,
1042                                  &inbuf, inbuf + resultlen,
1043                                  &outbuf,
1044                                  outbuf + freemem_size - sizeof (size_t),
1045                                  &non_reversible);
1046
1047                   if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
1048                     break;
1049
1050                   if (res != __GCONV_FULL_OUTPUT)
1051                     {
1052                       __libc_lock_unlock (lock);
1053                       goto converted;
1054                     }
1055
1056                   inbuf = (const unsigned char *) result;
1057 # else
1058 #  if HAVE_ICONV
1059                   const char *inptr = (const char *) inbuf;
1060                   size_t inleft = resultlen;
1061                   char *outptr = (char *) outbuf;
1062                   size_t outleft;
1063
1064                   if (freemem_size < sizeof (size_t))
1065                     goto resize_freemem;
1066
1067                   outleft = freemem_size - sizeof (size_t);
1068                   if (iconv (convd->conv,
1069                              (ICONV_CONST char **) &inptr, &inleft,
1070                              &outptr, &outleft)
1071                       != (size_t) (-1))
1072                     {
1073                       outbuf = (unsigned char *) outptr;
1074                       break;
1075                     }
1076                   if (errno != E2BIG)
1077                     {
1078                       __libc_lock_unlock (lock);
1079                       goto converted;
1080                     }
1081 #  endif
1082 # endif
1083
1084                 resize_freemem:
1085                   /* We must allocate a new buffer or resize the old one.  */
1086                   if (malloc_count > 0)
1087                     {
1088                       ++malloc_count;
1089                       freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
1090                       newmem = (transmem_block_t *) realloc (transmem_list,
1091                                                              freemem_size);
1092 # ifdef _LIBC
1093                       if (newmem != NULL)
1094                         transmem_list = transmem_list->next;
1095                       else
1096                         {
1097                           struct transmem_list *old = transmem_list;
1098
1099                           transmem_list = transmem_list->next;
1100                           free (old);
1101                         }
1102 # endif
1103                     }
1104                   else
1105                     {
1106                       malloc_count = 1;
1107                       freemem_size = INITIAL_BLOCK_SIZE;
1108                       newmem = (transmem_block_t *) malloc (freemem_size);
1109                     }
1110                   if (__builtin_expect (newmem == NULL, 0))
1111                     {
1112                       freemem = NULL;
1113                       freemem_size = 0;
1114                       __libc_lock_unlock (lock);
1115                       goto converted;
1116                     }
1117
1118 # ifdef _LIBC
1119                   /* Add the block to the list of blocks we have to free
1120                      at some point.  */
1121                   newmem->next = transmem_list;
1122                   transmem_list = newmem;
1123
1124                   freemem = (unsigned char *) newmem->data;
1125                   freemem_size -= offsetof (struct transmem_list, data);
1126 # else
1127                   transmem_list = newmem;
1128                   freemem = newmem;
1129 # endif
1130
1131                   outbuf = freemem + sizeof (size_t);
1132                 }
1133
1134               /* We have now in our buffer a converted string.  Put this
1135                  into the table of conversions.  */
1136               *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
1137               convd->conv_tab[act] = (char *) freemem;
1138               /* Shrink freemem, but keep it aligned.  */
1139               freemem_size -= outbuf - freemem;
1140               freemem = outbuf;
1141               freemem += freemem_size & (alignof (size_t) - 1);
1142               freemem_size = freemem_size & ~ (alignof (size_t) - 1);
1143
1144               __libc_lock_unlock (lock);
1145             }
1146
1147           /* Now convd->conv_tab[act] contains the translation of all
1148              the plural variants.  */
1149           result = convd->conv_tab[act] + sizeof (size_t);
1150           resultlen = *(size_t *) convd->conv_tab[act];
1151         }
1152     }
1153
1154  converted:
1155   /* The result string is converted.  */
1156
1157 #endif /* _LIBC || HAVE_ICONV */
1158
1159   *lengthp = resultlen;
1160   return result;
1161 }
1162
1163
1164 /* Look up a plural variant.  */
1165 static char *
1166 internal_function
1167 plural_lookup (domain, n, translation, translation_len)
1168      struct loaded_l10nfile *domain;
1169      unsigned long int n;
1170      const char *translation;
1171      size_t translation_len;
1172 {
1173   struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
1174   unsigned long int index;
1175   const char *p;
1176
1177   index = plural_eval (domaindata->plural, n);
1178   if (index >= domaindata->nplurals)
1179     /* This should never happen.  It means the plural expression and the
1180        given maximum value do not match.  */
1181     index = 0;
1182
1183   /* Skip INDEX strings at TRANSLATION.  */
1184   p = translation;
1185   while (index-- > 0)
1186     {
1187 #ifdef _LIBC
1188       p = __rawmemchr (p, '\0');
1189 #else
1190       p = strchr (p, '\0');
1191 #endif
1192       /* And skip over the NUL byte.  */
1193       p++;
1194
1195       if (p >= translation + translation_len)
1196         /* This should never happen.  It means the plural expression
1197            evaluated to a value larger than the number of variants
1198            available for MSGID1.  */
1199         return (char *) translation;
1200     }
1201   return (char *) p;
1202 }
1203
1204 #ifndef _LIBC
1205 /* Return string representation of locale CATEGORY.  */
1206 static const char *
1207 internal_function
1208 category_to_name (category)
1209      int category;
1210 {
1211   const char *retval;
1212
1213   switch (category)
1214   {
1215 #ifdef LC_COLLATE
1216   case LC_COLLATE:
1217     retval = "LC_COLLATE";
1218     break;
1219 #endif
1220 #ifdef LC_CTYPE
1221   case LC_CTYPE:
1222     retval = "LC_CTYPE";
1223     break;
1224 #endif
1225 #ifdef LC_MONETARY
1226   case LC_MONETARY:
1227     retval = "LC_MONETARY";
1228     break;
1229 #endif
1230 #ifdef LC_NUMERIC
1231   case LC_NUMERIC:
1232     retval = "LC_NUMERIC";
1233     break;
1234 #endif
1235 #ifdef LC_TIME
1236   case LC_TIME:
1237     retval = "LC_TIME";
1238     break;
1239 #endif
1240 #ifdef LC_MESSAGES
1241   case LC_MESSAGES:
1242     retval = "LC_MESSAGES";
1243     break;
1244 #endif
1245 #ifdef LC_RESPONSE
1246   case LC_RESPONSE:
1247     retval = "LC_RESPONSE";
1248     break;
1249 #endif
1250 #ifdef LC_ALL
1251   case LC_ALL:
1252     /* This might not make sense but is perhaps better than any other
1253        value.  */
1254     retval = "LC_ALL";
1255     break;
1256 #endif
1257   default:
1258     /* If you have a better idea for a default value let me know.  */
1259     retval = "LC_XXX";
1260   }
1261
1262   return retval;
1263 }
1264 #endif
1265
1266 /* Guess value of current locale from value of the environment variables.  */
1267 static const char *
1268 internal_function
1269 guess_category_value (category, categoryname)
1270      int category;
1271      const char *categoryname;
1272 {
1273   const char *language;
1274   const char *retval;
1275
1276   /* The highest priority value is the `LANGUAGE' environment
1277      variable.  But we don't use the value if the currently selected
1278      locale is the C locale.  This is a GNU extension.  */
1279   language = getenv ("LANGUAGE");
1280   if (language != NULL && language[0] == '\0')
1281     language = NULL;
1282
1283   /* We have to proceed with the POSIX methods of looking to `LC_ALL',
1284      `LC_xxx', and `LANG'.  On some systems this can be done by the
1285      `setlocale' function itself.  */
1286 #ifdef _LIBC
1287   retval = __current_locale_name (category);
1288 #else
1289   retval = _nl_locale_name (category, categoryname);
1290 #endif
1291
1292   return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
1293 }
1294
1295 #if defined _LIBC || HAVE_ICONV
1296 /* Returns the output charset.  */
1297 static const char *
1298 internal_function
1299 get_output_charset (domainbinding)
1300      struct binding *domainbinding;
1301 {
1302   /* The output charset should normally be determined by the locale.  But
1303      sometimes the locale is not used or not correctly set up, so we provide
1304      a possibility for the user to override this: the OUTPUT_CHARSET
1305      environment variable.  Moreover, the value specified through
1306      bind_textdomain_codeset overrides both.  */
1307   if (domainbinding != NULL && domainbinding->codeset != NULL)
1308     return domainbinding->codeset;
1309   else
1310     {
1311       /* For speed reasons, we look at the value of OUTPUT_CHARSET only
1312          once.  This is a user variable that is not supposed to change
1313          during a program run.  */
1314       static char *output_charset_cache;
1315       static int output_charset_cached;
1316
1317       if (!output_charset_cached)
1318         {
1319           const char *value = getenv ("OUTPUT_CHARSET");
1320
1321           if (value != NULL && value[0] != '\0')
1322             {
1323               size_t len = strlen (value) + 1;
1324               char *value_copy = (char *) malloc (len);
1325
1326               if (value_copy != NULL)
1327                 memcpy (value_copy, value, len);
1328               output_charset_cache = value_copy;
1329             }
1330           output_charset_cached = 1;
1331         }
1332
1333       if (output_charset_cache != NULL)
1334         return output_charset_cache;
1335       else
1336         {
1337 # ifdef _LIBC
1338           return _NL_CURRENT (LC_CTYPE, CODESET);
1339 # else
1340 #  if HAVE_ICONV
1341           extern const char *locale_charset PARAMS ((void);
1342           return locale_charset ();
1343 #  endif
1344 # endif
1345         }
1346     }
1347 }
1348 #endif
1349
1350 /* @@ begin of epilog @@ */
1351
1352 /* We don't want libintl.a to depend on any other library.  So we
1353    avoid the non-standard function stpcpy.  In GNU C Library this
1354    function is available, though.  Also allow the symbol HAVE_STPCPY
1355    to be defined.  */
1356 #if !_LIBC && !HAVE_STPCPY
1357 static char *
1358 stpcpy (dest, src)
1359      char *dest;
1360      const char *src;
1361 {
1362   while ((*dest++ = *src++) != '\0')
1363     /* Do nothing. */ ;
1364   return dest - 1;
1365 }
1366 #endif
1367
1368 #if !_LIBC && !HAVE_MEMPCPY
1369 static void *
1370 mempcpy (dest, src, n)
1371      void *dest;
1372      const void *src;
1373      size_t n;
1374 {
1375   return (void *) ((char *) memcpy (dest, src, n) + n);
1376 }
1377 #endif
1378
1379
1380 #ifdef _LIBC
1381 /* If we want to free all resources we have to do some work at
1382    program's end.  */
1383 libc_freeres_fn (free_mem)
1384 {
1385   void *old;
1386
1387   while (_nl_domain_bindings != NULL)
1388     {
1389       struct binding *oldp = _nl_domain_bindings;
1390       _nl_domain_bindings = _nl_domain_bindings->next;
1391       if (oldp->dirname != _nl_default_dirname)
1392         /* Yes, this is a pointer comparison.  */
1393         free (oldp->dirname);
1394       free (oldp->codeset);
1395       free (oldp);
1396     }
1397
1398   if (_nl_current_default_domain != _nl_default_default_domain)
1399     /* Yes, again a pointer comparison.  */
1400     free ((char *) _nl_current_default_domain);
1401
1402   /* Remove the search tree with the known translations.  */
1403   __tdestroy (root, free);
1404   root = NULL;
1405
1406   while (transmem_list != NULL)
1407     {
1408       old = transmem_list;
1409       transmem_list = transmem_list->next;
1410       free (old);
1411     }
1412 }
1413 #endif