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