lib/libintl/gettext.c

   1 /*      $NetBSD: gettext.c,v 1.24 2005/06/01 11:08:57 lukem Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2000, 2001 Citrus Project,
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $Citrus: xpg4dl/FreeBSD/lib/libintl/gettext.c,v 1.31 2001/09/27 15:18:45 yamt Exp $
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __RCSID("$NetBSD: gettext.c,v 1.24 2005/06/01 11:08:57 lukem Exp $");
  33
  34 #include <sys/param.h>
  35 #include <sys/stat.h>
  36 #include <sys/mman.h>
  37 #include <sys/uio.h>
  38
  39 #include <assert.h>
  40 #include <fcntl.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44 #include <string.h>
  45 #if 0
  46 #include <util.h>
  47 #endif
  48 #include <libintl.h>
  49 #include <locale.h>
  50 #include "libintl_local.h"
  51 #include "plural_parser.h"
  52 #include "pathnames.h"
  53
  54 static const char *lookup_category(int);
  55 static const char *split_locale(const char *);
  56 static const char *lookup_mofile(char *, size_t, const char *, const char *,
  57                                  const char *, const char *,
  58                                  struct domainbinding *);
  59 static uint32_t flip(uint32_t, uint32_t);
  60 static int validate(void *, struct mohandle *);
  61 static int mapit(const char *, struct domainbinding *);
  62 static int unmapit(struct domainbinding *);
  63 static const char *lookup_hash(const char *, struct domainbinding *, size_t *);
  64 static const char *lookup_bsearch(const char *, struct domainbinding *,
  65                                   size_t *);
  66 static const char *lookup(const char *, struct domainbinding *, size_t *);
  67 static const char *get_lang_env(const char *);
  68
  69 /*
  70  * shortcut functions.  the main implementation resides in dcngettext().
  71  */
  72 char *
  73 gettext(const char *msgid)
  74 {
  75
  76         return dcngettext(NULL, msgid, NULL, 1UL, LC_MESSAGES);
  77 }
  78
  79 char *
  80 dgettext(const char *domainname, const char *msgid)
  81 {
  82
  83         return dcngettext(domainname, msgid, NULL, 1UL, LC_MESSAGES);
  84 }
  85
  86 char *
  87 dcgettext(const char *domainname, const char *msgid, int category)
  88 {
  89
  90         return dcngettext(domainname, msgid, NULL, 1UL, category);
  91 }
  92
  93 char *
  94 ngettext(const char *msgid1, const char *msgid2, unsigned long int n)
  95 {
  96
  97         return dcngettext(NULL, msgid1, msgid2, n, LC_MESSAGES);
  98 }
  99
 100 char *
 101 dngettext(const char *domainname, const char *msgid1, const char *msgid2,
 102           unsigned long int n)
 103 {
 104
 105         return dcngettext(domainname, msgid1, msgid2, n, LC_MESSAGES);
 106 }
 107
 108 /*
 109  * dcngettext() -
 110  * lookup internationalized message on database locale/category/domainname
 111  * (like ja_JP.eucJP/LC_MESSAGES/domainname).
 112  * if n equals to 1, internationalized message will be looked up for msgid1.
 113  * otherwise, message will be looked up for msgid2.
 114  * if the lookup fails, the function will return msgid1 or msgid2 as is.
 115  *
 116  * Even though the return type is "char *", caller should not rewrite the
 117  * region pointed to by the return value (should be "const char *", but can't
 118  * change it for compatibility with other implementations).
 119  *
 120  * by default (if domainname == NULL), domainname is taken from the value set
 121  * by textdomain().  usually name of the application (like "ls") is used as
 122  * domainname.  category is usually LC_MESSAGES.
 123  *
 124  * the code reads in *.mo files generated by GNU gettext.  *.mo is a host-
 125  * endian encoded file.  both endians are supported here, as the files are in
 126  * /usr/share/locale! (or we should move those files into /usr/libdata)
 127  */
 128
 129 static const char *
 130 lookup_category(int category)
 131 {
 132
 133         switch (category) {
 134         case LC_COLLATE:        return "LC_COLLATE";
 135         case LC_CTYPE:          return "LC_CTYPE";
 136         case LC_MONETARY:       return "LC_MONETARY";
 137         case LC_NUMERIC:        return "LC_NUMERIC";
 138         case LC_TIME:           return "LC_TIME";
 139         case LC_MESSAGES:       return "LC_MESSAGES";
 140         }
 141         return NULL;
 142 }
 143
 144 /*
 145  * XPG syntax: language[_territory[.codeset]][@modifier]
 146  * XXX boundary check on "result" is lacking
 147  */
 148 static const char *
 149 split_locale(const char *lname)
 150 {
 151         char buf[BUFSIZ], tmp[BUFSIZ];
 152         char *l, *t, *c, *m;
 153         static char result[BUFSIZ];
 154
 155         memset(result, 0, sizeof(result));
 156
 157         if (strlen(lname) + 1 > sizeof(buf)) {
 158 fail:
 159                 return lname;
 160         }
 161
 162         strlcpy(buf, lname, sizeof(buf));
 163         m = strrchr(buf, '@');
 164         if (m)
 165                 *m++ = '\0';
 166         c = strrchr(buf, '.');
 167         if (c)
 168                 *c++ = '\0';
 169         t = strrchr(buf, '_');
 170         if (t)
 171                 *t++ = '\0';
 172         l = buf;
 173         if (strlen(l) == 0)
 174                 goto fail;
 175         if (c && !t)
 176                 goto fail;
 177
 178         if (m) {
 179                 if (t) {
 180                         if (c) {
 181                                 snprintf(tmp, sizeof(tmp), "%s_%s.%s@%s",
 182                                     l, t, c, m);
 183                                 strlcat(result, tmp, sizeof(result));
 184                                 strlcat(result, ":", sizeof(result));
 185                         }
 186                         snprintf(tmp, sizeof(tmp), "%s_%s@%s", l, t, m);
 187                         strlcat(result, tmp, sizeof(result));
 188                         strlcat(result, ":", sizeof(result));
 189                 }
 190                 snprintf(tmp, sizeof(tmp), "%s@%s", l, m);
 191                 strlcat(result, tmp, sizeof(result));
 192                 strlcat(result, ":", sizeof(result));
 193         }
 194         if (t) {
 195                 if (c) {
 196                         snprintf(tmp, sizeof(tmp), "%s_%s.%s", l, t, c);
 197                         strlcat(result, tmp, sizeof(result));
 198                         strlcat(result, ":", sizeof(result));
 199                 }
 200                 snprintf(tmp, sizeof(tmp), "%s_%s", l, t);
 201                 strlcat(result, tmp, sizeof(result));
 202                 strlcat(result, ":", sizeof(result));
 203         }
 204         strlcat(result, l, sizeof(result));
 205
 206         return result;
 207 }
 208
 209 static const char *
 210 lookup_mofile(char *buf, size_t len, const char *dir, const char *lpath,
 211               const char *category, const char *domainname,
 212               struct domainbinding *db)
 213 {
 214         struct stat st;
 215         char *p, *q;
 216         char lpath_tmp[BUFSIZ];
 217
 218         strlcpy(lpath_tmp, lpath, sizeof(lpath_tmp));
 219         q = lpath_tmp;
 220         /* CONSTCOND */
 221         while (1) {
 222                 p = strsep(&q, ":");
 223                 if (!p)
 224                         break;
 225                 if (!*p)
 226                         continue;
 227
 228                 /* don't mess with default locales */
 229                 if (strcmp(p, "C") == 0 || strcmp(p, "POSIX") == 0)
 230                         return NULL;
 231
 232                 /* validate pathname */
 233                 if (strchr(p, '/') || strchr(category, '/'))
 234                         continue;
 235 #if 1   /*?*/
 236                 if (strchr(domainname, '/'))
 237                         continue;
 238 #endif
 239
 240                 snprintf(buf, len, "%s/%s/%s/%s.mo", dir, p,
 241                     category, domainname);
 242                 if (stat(buf, &st) < 0)
 243                         continue;
 244                 if ((st.st_mode & S_IFMT) != S_IFREG)
 245                         continue;
 246
 247                 if (mapit(buf, db) == 0)
 248                         return buf;
 249         }
 250
 251         return NULL;
 252 }
 253
 254 static uint32_t
 255 flip(uint32_t v, uint32_t magic)
 256 {
 257
 258         if (magic == MO_MAGIC)
 259                 return v;
 260         else if (magic == MO_MAGIC_SWAPPED) {
 261                 v = ((v >> 24) & 0xff) | ((v >> 8) & 0xff00) |
 262                     ((v << 8) & 0xff0000) | ((v << 24) & 0xff000000);
 263                 return v;
 264         } else {
 265                 abort();
 266                 /*NOTREACHED*/
 267         }
 268 }
 269
 270 static int
 271 validate(void *arg, struct mohandle *mohandle)
 272 {
 273         char *p;
 274
 275         p = (char *)arg;
 276         if (p < (char *)mohandle->addr ||
 277             p > (char *)mohandle->addr + mohandle->len)
 278                 return 0;
 279         else
 280                 return 1;
 281 }
 282
 283 /*
 284  * calculate the step value if the hash value is conflicted.
 285  */
 286 static __inline uint32_t
 287 calc_collision_step(uint32_t hashval, uint32_t hashsize)
 288 {
 289         _DIAGASSERT(hashsize>2);
 290         return (hashval % (hashsize - 2)) + 1;
 291 }
 292
 293 /*
 294  * calculate the next index while conflicting.
 295  */
 296 static __inline uint32_t
 297 calc_next_index(uint32_t curidx, uint32_t hashsize, uint32_t step)
 298 {
 299         return curidx+step - (curidx >= hashsize-step ? hashsize : 0);
 300 }
 301
 302 static int
 303 get_sysdep_string_table(struct mosysdepstr_h **table_h, uint32_t *ofstable,
 304                         uint32_t nstrings, uint32_t magic, char *base)
 305 {
 306         int i, j;
 307         int count;
 308         size_t l;
 309         struct mosysdepstr *table;
 310
 311         for (i=0; i<nstrings; i++) {
 312                 /* get mosysdepstr record */
 313                 /* LINTED: ignore the alignment problem. */
 314                 table = (struct mosysdepstr *)(base + flip(ofstable[i], magic));
 315                 /* count number of segments */
 316                 count = 0;
 317                 while (flip(table->segs[count++].ref, magic) != MO_LASTSEG)
 318                         ;
 319                 /* get table */
 320                 l = sizeof(struct mosysdepstr_h) +
 321                     sizeof(struct mosysdepsegentry_h) * (count-1);
 322                 table_h[i] = (struct mosysdepstr_h *)malloc(l);
 323                 if (!table_h[i])
 324                         return -1;
 325                 memset(table_h[i], 0, l);
 326                 table_h[i]->off = (const char *)(base + flip(table->off, magic));
 327                 for (j=0; j<count; j++) {
 328                         table_h[i]->segs[j].len =
 329                             flip(table->segs[j].len, magic);
 330                         table_h[i]->segs[j].ref =
 331                             flip(table->segs[j].ref, magic);
 332                 }
 333                 /* LINTED: ignore the alignment problem. */
 334                 table = (struct mosysdepstr *)&table->segs[count];
 335         }
 336         return 0;
 337 }
 338
 339 static int
 340 expand_sysdep(struct mohandle *mohandle, struct mosysdepstr_h *str)
 341 {
 342         int i;
 343         const char *src;
 344         char *dst;
 345
 346         /* check whether already expanded */
 347         if (str->expanded)
 348                 return 0;
 349
 350         /* calc total length */
 351         str->expanded_len = 1;
 352         for (i=0; /*CONSTCOND*/1; i++) {
 353                 str->expanded_len += str->segs[i].len;
 354                 if (str->segs[i].ref == MO_LASTSEG)
 355                         break;
 356                 str->expanded_len +=
 357                     mohandle->mo.mo_sysdep_segs[str->segs[i].ref].len;
 358         }
 359         /* expand */
 360         str->expanded = malloc(str->expanded_len);
 361         if (!str->expanded)
 362                 return -1;
 363         src = str->off;
 364         dst = str->expanded;
 365         for (i=0; /*CONSTCOND*/1; i++) {
 366                 memcpy(dst, src, str->segs[i].len);
 367                 src += str->segs[i].len;
 368                 dst += str->segs[i].len;
 369                 if (str->segs[i].ref == MO_LASTSEG)
 370                         break;
 371                 memcpy(dst, mohandle->mo.mo_sysdep_segs[str->segs[i].ref].str,
 372                        mohandle->mo.mo_sysdep_segs[str->segs[i].ref].len);
 373                 dst += mohandle->mo.mo_sysdep_segs[str->segs[i].ref].len;
 374         }
 375         *dst = '\0';
 376
 377         return 0;
 378 }
 379
 380 static void
 381 insert_to_hash(uint32_t *htable, uint32_t hsize, const char *str, uint32_t ref)
 382 {
 383         uint32_t hashval, idx, step;
 384
 385         hashval = __intl_string_hash(str);
 386         step = calc_collision_step(hashval, hsize);
 387         idx = hashval % hsize;
 388
 389         while (htable[idx])
 390                 idx = calc_next_index(idx, hsize, step);
 391
 392         htable[idx] = ref;
 393 }
 394
 395 static int
 396 setup_sysdep_stuffs(struct mo *mo, struct mohandle *mohandle, char *base)
 397 {
 398         uint32_t magic;
 399         struct moentry *stable;
 400         size_t l;
 401         int i;
 402         char *v;
 403         uint32_t *ofstable;
 404
 405         magic = mo->mo_magic;
 406
 407         mohandle->mo.mo_sysdep_nsegs = flip(mo->mo_sysdep_nsegs, magic);
 408         mohandle->mo.mo_sysdep_nstring = flip(mo->mo_sysdep_nstring, magic);
 409
 410         if (mohandle->mo.mo_sysdep_nstring == 0)
 411                 return 0;
 412
 413         /* check hash size */
 414         if (mohandle->mo.mo_hsize <= 2 ||
 415             mohandle->mo.mo_hsize <
 416             (mohandle->mo.mo_nstring + mohandle->mo.mo_sysdep_nstring))
 417                 return -1;
 418
 419         /* get sysdep segments */
 420         l = sizeof(struct mosysdepsegs_h) * mohandle->mo.mo_sysdep_nsegs;
 421         mohandle->mo.mo_sysdep_segs = (struct mosysdepsegs_h *)malloc(l);
 422         if (!mohandle->mo.mo_sysdep_segs)
 423                 return -1;
 424         /* LINTED: ignore the alignment problem. */
 425         stable = (struct moentry *)(base + flip(mo->mo_sysdep_segoff, magic));
 426         for (i=0; i<mohandle->mo.mo_sysdep_nsegs; i++) {
 427                 v = base + flip(stable[i].off, magic);
 428                 mohandle->mo.mo_sysdep_segs[i].str =
 429                     __intl_sysdep_get_string_by_tag(
 430                             v,
 431                             &mohandle->mo.mo_sysdep_segs[i].len);
 432         }
 433
 434         /* get sysdep string table */
 435         mohandle->mo.mo_sysdep_otable =
 436             (struct mosysdepstr_h **)calloc(mohandle->mo.mo_sysdep_nstring,
 437                                             sizeof(struct mosysdepstr_h *));
 438         if (!mohandle->mo.mo_sysdep_otable)
 439                 return -1;
 440         /* LINTED: ignore the alignment problem. */
 441         ofstable = (uint32_t *)(base + flip(mo->mo_sysdep_otable, magic));
 442         if (get_sysdep_string_table(mohandle->mo.mo_sysdep_otable, ofstable,
 443                                     mohandle->mo.mo_sysdep_nstring, magic,
 444                                     base))
 445                 return -1;
 446         mohandle->mo.mo_sysdep_ttable =
 447             (struct mosysdepstr_h **)calloc(mohandle->mo.mo_sysdep_nstring,
 448                                             sizeof(struct mosysdepstr_h *));
 449         if (!mohandle->mo.mo_sysdep_ttable)
 450                 return -1;
 451         /* LINTED: ignore the alignment problem. */
 452         ofstable = (uint32_t *)(base + flip(mo->mo_sysdep_ttable, magic));
 453         if (get_sysdep_string_table(mohandle->mo.mo_sysdep_ttable, ofstable,
 454                                     mohandle->mo.mo_sysdep_nstring, magic,
 455                                     base))
 456                 return -1;
 457
 458         /* update hash */
 459         for (i=0; i<mohandle->mo.mo_sysdep_nstring; i++) {
 460                 if (expand_sysdep(mohandle, mohandle->mo.mo_sysdep_otable[i]))
 461                         return -1;
 462                 insert_to_hash(mohandle->mo.mo_htable,
 463                                mohandle->mo.mo_hsize,
 464                                mohandle->mo.mo_sysdep_otable[i]->expanded,
 465                                (i+1) | MO_HASH_SYSDEP_MASK);
 466         }
 467
 468         return 0;
 469 }
 470
 471 int
 472 mapit(const char *path, struct domainbinding *db)
 473 {
 474         int fd;
 475         struct stat st;
 476         char *base;
 477         uint32_t magic, revision, flags = 0;
 478         struct moentry *otable, *ttable;
 479         const uint32_t *htable;
 480         struct moentry_h *p;
 481         struct mo *mo;
 482         size_t l, headerlen;
 483         int i;
 484         char *v;
 485         struct mohandle *mohandle = &db->mohandle;
 486
 487         if (mohandle->addr && mohandle->addr != MAP_FAILED &&
 488             mohandle->mo.mo_magic)
 489                 return 0;       /*already opened*/
 490
 491         unmapit(db);
 492
 493 #if 0
 494         if (secure_path(path) != 0)
 495                 goto fail;
 496 #endif
 497         if (stat(path, &st) < 0)
 498                 goto fail;
 499         if ((st.st_mode & S_IFMT) != S_IFREG || st.st_size > GETTEXT_MMAP_MAX)
 500                 goto fail;
 501         fd = open(path, O_RDONLY);
 502         if (fd < 0)
 503                 goto fail;
 504         if (read(fd, &magic, sizeof(magic)) != sizeof(magic) ||
 505             (magic != MO_MAGIC && magic != MO_MAGIC_SWAPPED)) {
 506                 close(fd);
 507                 goto fail;
 508         }
 509         if (read(fd, &revision, sizeof(revision)) != sizeof(revision)) {
 510                 close(fd);
 511                 goto fail;
 512         }
 513         switch (flip(revision, magic)) {
 514         case MO_MAKE_REV(0, 0):
 515                 break;
 516         case MO_MAKE_REV(0, 1):
 517         case MO_MAKE_REV(1, 1):
 518                 flags |= MO_F_SYSDEP;
 519                 break;
 520         default:
 521                 close(fd);
 522                 goto fail;
 523         }
 524         mohandle->addr = mmap(NULL, (size_t)st.st_size, PROT_READ,
 525             MAP_FILE | MAP_SHARED, fd, (off_t)0);
 526         if (!mohandle->addr || mohandle->addr == MAP_FAILED) {
 527                 close(fd);
 528                 goto fail;
 529         }
 530         close(fd);
 531         mohandle->len = (size_t)st.st_size;
 532
 533         base = mohandle->addr;
 534         mo = (struct mo *)mohandle->addr;
 535
 536         /* flip endian.  do not flip magic number! */
 537         mohandle->mo.mo_magic = mo->mo_magic;
 538         mohandle->mo.mo_revision = flip(mo->mo_revision, magic);
 539         mohandle->mo.mo_nstring = flip(mo->mo_nstring, magic);
 540         mohandle->mo.mo_hsize = flip(mo->mo_hsize, magic);
 541         mohandle->mo.mo_flags = flags;
 542
 543         /* validate otable/ttable */
 544         /* LINTED: ignore the alignment problem. */
 545         otable = (struct moentry *)(base + flip(mo->mo_otable, magic));
 546         /* LINTED: ignore the alignment problem. */
 547         ttable = (struct moentry *)(base + flip(mo->mo_ttable, magic));
 548         if (!validate(otable, mohandle) ||
 549             !validate(&otable[mohandle->mo.mo_nstring], mohandle)) {
 550                 unmapit(db);
 551                 goto fail;
 552         }
 553         if (!validate(ttable, mohandle) ||
 554             !validate(&ttable[mohandle->mo.mo_nstring], mohandle)) {
 555                 unmapit(db);
 556                 goto fail;
 557         }
 558
 559         /* allocate [ot]table, and convert to normal pointer representation. */
 560         l = sizeof(struct moentry_h) * mohandle->mo.mo_nstring;
 561         mohandle->mo.mo_otable = (struct moentry_h *)malloc(l);
 562         if (!mohandle->mo.mo_otable) {
 563                 unmapit(db);
 564                 goto fail;
 565         }
 566         mohandle->mo.mo_ttable = (struct moentry_h *)malloc(l);
 567         if (!mohandle->mo.mo_ttable) {
 568                 unmapit(db);
 569                 goto fail;
 570         }
 571         p = mohandle->mo.mo_otable;
 572         for (i = 0; i < mohandle->mo.mo_nstring; i++) {
 573                 p[i].len = flip(otable[i].len, magic);
 574                 p[i].off = base + flip(otable[i].off, magic);
 575
 576                 if (!validate(p[i].off, mohandle) ||
 577                     !validate(p[i].off + p[i].len + 1, mohandle)) {
 578                         unmapit(db);
 579                         goto fail;
 580                 }
 581         }
 582         p = mohandle->mo.mo_ttable;
 583         for (i = 0; i < mohandle->mo.mo_nstring; i++) {
 584                 p[i].len = flip(ttable[i].len, magic);
 585                 p[i].off = base + flip(ttable[i].off, magic);
 586
 587                 if (!validate(p[i].off, mohandle) ||
 588                     !validate(p[i].off + p[i].len + 1, mohandle)) {
 589                         unmapit(db);
 590                         goto fail;
 591                 }
 592         }
 593         /* allocate htable, and convert it to the host order. */
 594         if (mohandle->mo.mo_hsize > 2) {
 595                 l = sizeof(uint32_t) * mohandle->mo.mo_hsize;
 596                 mohandle->mo.mo_htable = (uint32_t *)malloc(l);
 597                 if (!mohandle->mo.mo_htable) {
 598                         unmapit(db);
 599                         goto fail;
 600                 }
 601                 /* LINTED: ignore the alignment problem. */
 602                 htable = (const uint32_t *)(base+flip(mo->mo_hoffset, magic));
 603                 for (i=0; i < mohandle->mo.mo_hsize; i++) {
 604                         mohandle->mo.mo_htable[i] = flip(htable[i], magic);
 605                         if (mohandle->mo.mo_htable[i] >=
 606                             mohandle->mo.mo_nstring+1) {
 607                                 /* illegal string number. */
 608                                 unmapit(db);
 609                                 goto fail;
 610                         }
 611                 }
 612         }
 613         /* grab MIME-header and charset field */
 614         mohandle->mo.mo_header = lookup("", db, &headerlen);
 615         if (mohandle->mo.mo_header)
 616                 v = strstr(mohandle->mo.mo_header, "charset=");
 617         else
 618                 v = NULL;
 619         if (v) {
 620                 mohandle->mo.mo_charset = strdup(v + 8);
 621                 if (!mohandle->mo.mo_charset)
 622                         goto fail;
 623                 v = strchr(mohandle->mo.mo_charset, '\n');
 624                 if (v)
 625                         *v = '\0';
 626         }
 627         if (_gettext_parse_plural(&mohandle->mo.mo_plural,
 628                                   &mohandle->mo.mo_nplurals,
 629                                   mohandle->mo.mo_header, headerlen))
 630                 mohandle->mo.mo_plural = NULL;
 631
 632         /*
 633          * XXX check charset, reject it if we are unable to support the charset
 634          * with the current locale.
 635          * for example, if we are using euc-jp locale and we are looking at
 636          * *.mo file encoded by euc-kr (charset=euc-kr), we should reject
 637          * the *.mo file as we cannot support it.
 638          */
 639
 640         /* system dependent string support */
 641         if ((mohandle->mo.mo_flags & MO_F_SYSDEP) != 0) {
 642                 if (setup_sysdep_stuffs(mo, mohandle, base)) {
 643                         unmapit(db);
 644                         goto fail;
 645                 }
 646         }
 647
 648         return 0;
 649
 650 fail:
 651         return -1;
 652 }
 653
 654 static void
 655 free_sysdep_table(struct mosysdepstr_h **table, uint32_t nstring)
 656 {
 657         uint32_t i;
 658
 659         for (i=0; i<nstring; i++) {
 660                 if (table[i]) {
 661                         if (table[i]->expanded)
 662                                 free(table[i]->expanded);
 663                         free(table[i]);
 664                 }
 665         }
 666         free(table);
 667 }
 668
 669 static int
 670 unmapit(struct domainbinding *db)
 671 {
 672         struct mohandle *mohandle = &db->mohandle;
 673
 674         /* unmap if there's already mapped region */
 675         if (mohandle->addr && mohandle->addr != MAP_FAILED)
 676                 munmap(mohandle->addr, mohandle->len);
 677         mohandle->addr = NULL;
 678         if (mohandle->mo.mo_otable)
 679                 free(mohandle->mo.mo_otable);
 680         if (mohandle->mo.mo_ttable)
 681                 free(mohandle->mo.mo_ttable);
 682         if (mohandle->mo.mo_charset)
 683                 free(mohandle->mo.mo_charset);
 684         if (mohandle->mo.mo_htable)
 685                 free(mohandle->mo.mo_htable);
 686         if (mohandle->mo.mo_sysdep_segs)
 687                 free(mohandle->mo.mo_sysdep_segs);
 688         if (mohandle->mo.mo_sysdep_otable) {
 689                 free_sysdep_table(mohandle->mo.mo_sysdep_otable,
 690                                   mohandle->mo.mo_sysdep_nstring);
 691         }
 692         if (mohandle->mo.mo_sysdep_ttable) {
 693                 free_sysdep_table(mohandle->mo.mo_sysdep_ttable,
 694                                   mohandle->mo.mo_sysdep_nstring);
 695         }
 696         if (mohandle->mo.mo_plural)
 697                 _gettext_free_plural(mohandle->mo.mo_plural);
 698         memset(&mohandle->mo, 0, sizeof(mohandle->mo));
 699         return 0;
 700 }
 701
 702 /* ARGSUSED */
 703 static const char *
 704 lookup_hash(const char *msgid, struct domainbinding *db, size_t *rlen)
 705 {
 706         struct mohandle *mohandle = &db->mohandle;
 707         uint32_t idx, hashval, step, strno;
 708         size_t len;
 709         struct mosysdepstr_h *sysdep_otable, *sysdep_ttable;
 710
 711         if (mohandle->mo.mo_hsize <= 2 || mohandle->mo.mo_htable == NULL)
 712                 return NULL;
 713
 714         hashval = __intl_string_hash(msgid);
 715         step = calc_collision_step(hashval, mohandle->mo.mo_hsize);
 716         idx = hashval % mohandle->mo.mo_hsize;
 717         len = strlen(msgid);
 718         while (/*CONSTCOND*/1) {
 719                 strno = mohandle->mo.mo_htable[idx];
 720                 if (strno == 0) {
 721                         /* unexpected miss */
 722                         return NULL;
 723                 }
 724                 strno--;
 725                 if ((strno & MO_HASH_SYSDEP_MASK) == 0) {
 726                         /* system independent strings */
 727                         if (len <= mohandle->mo.mo_otable[strno].len &&
 728                             !strcmp(msgid, mohandle->mo.mo_otable[strno].off)) {
 729                                 /* hit */
 730                                 if (rlen)
 731                                         *rlen =
 732                                             mohandle->mo.mo_ttable[strno].len;
 733                                 return mohandle->mo.mo_ttable[strno].off;
 734                         }
 735                 } else {
 736                         /* system dependent strings */
 737                         strno &= ~MO_HASH_SYSDEP_MASK;
 738                         sysdep_otable = mohandle->mo.mo_sysdep_otable[strno];
 739                         sysdep_ttable = mohandle->mo.mo_sysdep_ttable[strno];
 740                         if (len <= sysdep_otable->expanded_len &&
 741                             !strcmp(msgid, sysdep_otable->expanded)) {
 742                                 /* hit */
 743                                 if (expand_sysdep(mohandle, sysdep_ttable))
 744                                         /* memory exhausted */
 745                                         return NULL;
 746                                 if (rlen)
 747                                         *rlen = sysdep_ttable->expanded_len;
 748                                 return sysdep_ttable->expanded;
 749                         }
 750                 }
 751                 idx = calc_next_index(idx, mohandle->mo.mo_hsize, step);
 752         }
 753         /*NOTREACHED*/
 754 }
 755
 756 static const char *
 757 lookup_bsearch(const char *msgid, struct domainbinding *db, size_t *rlen)
 758 {
 759         int top, bottom, middle, omiddle;
 760         int n;
 761         struct mohandle *mohandle = &db->mohandle;
 762
 763         top = 0;
 764         bottom = mohandle->mo.mo_nstring;
 765         omiddle = -1;
 766         /* CONSTCOND */
 767         while (1) {
 768                 if (top > bottom)
 769                         break;
 770                 middle = (top + bottom) / 2;
 771                 /* avoid possible infinite loop, when the data is not sorted */
 772                 if (omiddle == middle)
 773                         break;
 774                 if (middle < 0 || middle >= mohandle->mo.mo_nstring)
 775                         break;
 776
 777                 n = strcmp(msgid, mohandle->mo.mo_otable[middle].off);
 778                 if (n == 0) {
 779                         if (rlen)
 780                                 *rlen = mohandle->mo.mo_ttable[middle].len;
 781                         return (const char *)mohandle->mo.mo_ttable[middle].off;
 782                 }
 783                 else if (n < 0)
 784                         bottom = middle;
 785                 else
 786                         top = middle;
 787                 omiddle = middle;
 788         }
 789
 790         return NULL;
 791 }
 792
 793 static const char *
 794 lookup(const char *msgid, struct domainbinding *db, size_t *rlen)
 795 {
 796         const char *v;
 797
 798         v = lookup_hash(msgid, db, rlen);
 799         if (v)
 800                 return v;
 801
 802         return lookup_bsearch(msgid, db, rlen);
 803 }
 804
 805 static const char *
 806 get_lang_env(const char *category_name)
 807 {
 808         const char *lang;
 809
 810         /* 1. see LANGUAGE variable first. */
 811         lang = getenv("LANGUAGE");
 812         if (lang)
 813                 return lang;
 814
 815         /* 2. if LANGUAGE isn't set, see LC_ALL, LC_xxx, LANG. */
 816         lang = getenv("LC_ALL");
 817         if (!lang)
 818                 lang = getenv(category_name);
 819         if (!lang)
 820                 lang = getenv("LANG");
 821
 822         if (!lang)
 823                 return 0; /* error */
 824
 825         return split_locale(lang);
 826 }
 827
 828 static const char *
 829 get_indexed_string(const char *str, size_t len, unsigned long idx)
 830 {
 831         while (idx > 0) {
 832                 if (len <= 1)
 833                         return str;
 834                 if (*str == '\0')
 835                         idx--;
 836                 if (len > 0) {
 837                         str++;
 838                         len--;
 839                 }
 840         }
 841         return str;
 842 }
 843
 844 #define _NGETTEXT_DEFAULT(msgid1, msgid2, n)    \
 845         ((char *)__UNCONST((n) == 1 ? (msgid1) : (msgid2)))
 846
 847 char *
 848 dcngettext(const char *domainname, const char *msgid1, const char *msgid2,
 849            unsigned long int n, int category)
 850 {
 851         const char *msgid;
 852         char path[PATH_MAX];
 853         const char *lpath;
 854         static char olpath[PATH_MAX];
 855         const char *cname = NULL;
 856         const char *v;
 857         static char *ocname = NULL;
 858         static char *odomainname = NULL;
 859         struct domainbinding *db;
 860         unsigned long plural_index = 0;
 861         size_t len;
 862
 863         if (!domainname)
 864                 domainname = __current_domainname;
 865         cname = lookup_category(category);
 866         if (!domainname || !cname)
 867                 goto fail;
 868
 869         lpath = get_lang_env(cname);
 870         if (!lpath)
 871                 goto fail;
 872
 873         for (db = __bindings; db; db = db->next)
 874                 if (strcmp(db->domainname, domainname) == 0)
 875                         break;
 876         if (!db) {
 877                 if (!bindtextdomain(domainname, _PATH_TEXTDOMAIN))
 878                         goto fail;
 879                 db = __bindings;
 880         }
 881
 882         /* resolve relative path */
 883         /* XXX not necessary? */
 884         if (db->path[0] != '/') {
 885                 char buf[PATH_MAX];
 886
 887                 if (getcwd(buf, sizeof(buf)) == 0)
 888                         goto fail;
 889                 if (strlcat(buf, "/", sizeof(buf)) >= sizeof(buf))
 890                         goto fail;
 891                 if (strlcat(buf, db->path, sizeof(buf)) >= sizeof(buf))
 892                         goto fail;
 893                 strlcpy(db->path, buf, sizeof(db->path));
 894         }
 895
 896         /* don't bother looking it up if the values are the same */
 897         if (odomainname && strcmp(domainname, odomainname) == 0 &&
 898             ocname && strcmp(cname, ocname) == 0 && strcmp(lpath, olpath) == 0 &&
 899             db->mohandle.mo.mo_magic)
 900                 goto found;
 901
 902         /* try to find appropriate file, from $LANGUAGE */
 903         if (lookup_mofile(path, sizeof(path), db->path, lpath, cname,
 904             domainname, db) == NULL)
 905                 goto fail;
 906
 907         if (odomainname)
 908                 free(odomainname);
 909         if (ocname)
 910                 free(ocname);
 911         odomainname = strdup(domainname);
 912         ocname = strdup(cname);
 913         if (!odomainname || !ocname) {
 914                 if (odomainname)
 915                         free(odomainname);
 916                 if (ocname)
 917                         free(ocname);
 918                 odomainname = ocname = NULL;
 919         }
 920         else
 921                 strlcpy(olpath, lpath, sizeof(olpath));
 922
 923 found:
 924         if (db->mohandle.mo.mo_plural) {
 925                 plural_index =
 926                     _gettext_calculate_plural(db->mohandle.mo.mo_plural, n);
 927                 if (plural_index >= db->mohandle.mo.mo_nplurals)
 928                         plural_index = 0;
 929                 msgid = msgid1;
 930         } else
 931                 msgid = _NGETTEXT_DEFAULT(msgid1, msgid2, n);
 932
 933         if (msgid == NULL)
 934                 return NULL;
 935
 936         v = lookup(msgid, db, &len);
 937         if (v) {
 938                 if (db->mohandle.mo.mo_plural)
 939                         v = get_indexed_string(v, len, plural_index);
 940                 /*
 941                  * convert the translated message's encoding.
 942                  *
 943                  * special case:
 944                  *      a result of gettext("") shouldn't need any conversion.
 945                  */
 946                 if (msgid[0])
 947                         v = __gettext_iconv(v, db);
 948
 949                 /*
 950                  * Given the amount of printf-format security issues, it may
 951                  * be a good idea to validate if the original msgid and the
 952                  * translated message format string carry the same printf-like
 953                  * format identifiers.
 954                  */
 955
 956                 msgid = v;
 957         }
 958
 959         return (char *)__UNCONST(msgid);
 960
 961 fail:
 962         return _NGETTEXT_DEFAULT(msgid1, msgid2, n);
 963 }