1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 /*
27  * Copyright 2015 Joyent, Inc.
28  */
29 
30 #include "lint.h"
31 #include "mtlib.h"
32 #include <ctype.h>
33 #include <locale.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/types.h>
38 #include <sys/mman.h>
39 #include <sys/param.h>
40 #include <sys/stat.h>
41 #include <libintl.h>
42 #include <thread.h>
43 #include <synch.h>
44 #include <limits.h>
45 #include <unistd.h>
46 #include "libc.h"
47 #include "_loc_path.h"
48 #include "msgfmt.h"
49 #include "gettext.h"
50 #include "nlspath_checks.h"
51 
52 static int	process_nlspath(const char *, const char *,
53     const char *, char **);
54 static char	*replace_nls_option(char *, const char *, char *,
55     char *, char *, char *, char *);
56 
57 char *
_real_gettext_u(const char * domain,const char * msgid1,const char * msgid2,unsigned long int ln,int category,int plural,locale_t loc)58 _real_gettext_u(const char *domain, const char *msgid1, const char *msgid2,
59     unsigned long int ln, int category, int plural, locale_t loc)
60 {
61 	char	msgfile[MAXPATHLEN]; /* 1024 */
62 	char	mydomain[TEXTDOMAINMAX + 1]; /* 256 + 1 */
63 	char	*cur_binding;	/* points to current binding in list */
64 	const char *cur_locale;
65 	char	*cur_domain, *result, *nlspath;
66 	char	*msgloc, *cb, *cur_domain_binding;
67 	char	*language;
68 	unsigned int	n = (unsigned int)ln;	/* we don't need long for n */
69 	uint32_t	cur_domain_len, cblen;
70 	uint32_t	hash_domain;
71 	struct msg_pack	*mp, omp;
72 
73 #ifdef GETTEXT_DEBUG
74 	gprintf(0, "*************** _real_gettext_u(\"%s\", \"%s\", "
75 	    "\"%s\", %d, %d, %d)\n",
76 	    domain ? domain : "NULL", msgid1 ? msgid1 : "NULL",
77 	    msgid2 ? msgid2 : "NULL", n, category, plural);
78 	gprintf(0, "***************** global_gt: 0x%p\n", global_gt);
79 	printgt(global_gt, 1);
80 #endif
81 
82 	if (msgid1 == NULL)
83 		return (NULL);
84 
85 	mp = memset(&omp, 0, sizeof (omp));	/* msg pack */
86 
87 	/*
88 	 * category may be LC_MESSAGES or LC_TIME
89 	 * locale contains the value of 'category'
90 	 */
91 	if (loc == NULL)
92 		loc = uselocale(NULL);
93 	cur_locale = current_locale(loc, category);
94 
95 	language = getenv("LANGUAGE"); /* for GNU */
96 	if (language) {
97 		if (!*language || strchr(language, '/') != NULL) {
98 			/*
99 			 * LANGUAGE is an empty string or
100 			 * LANGUAGE contains '/'.
101 			 * Ignore it.
102 			 */
103 			language = NULL;
104 		}
105 	}
106 
107 	/*
108 	 * Query the current domain if domain argument is NULL pointer
109 	 */
110 	mydomain[0] = '\0';
111 	if (domain == NULL) {
112 		/*
113 		 * if NULL is specified for domainname,
114 		 * use the currently bound domain.
115 		 */
116 		cur_domain = _textdomain_u(NULL, mydomain);
117 	} else if (!*domain) {
118 		/*
119 		 * if an empty string is specified
120 		 */
121 		cur_domain = DEFAULT_DOMAIN;
122 	} else {
123 		cur_domain = (char *)domain;
124 	}
125 
126 	hash_domain = get_hashid(cur_domain, &cur_domain_len);
127 	if (cur_domain_len > TEXTDOMAINMAX) {
128 		/* domain is invalid, return msg_id */
129 		DFLTMSG(result, msgid1, msgid2, n, plural);
130 		return (result);
131 	}
132 
133 	nlspath = getenv("NLSPATH"); /* get the content of NLSPATH */
134 	if (nlspath == NULL || !*nlspath) {
135 		/* no NLSPATH is defined in the environ */
136 		if ((*cur_locale == 'C') && (*(cur_locale + 1) == '\0')) {
137 			/*
138 			 * If C locale,
139 			 * return the original msgid immediately.
140 			 */
141 			DFLTMSG(result, msgid1, msgid2, n, plural);
142 			return (result);
143 		}
144 		nlspath = NULL;
145 	} else {
146 		/* NLSPATH is set */
147 		int	ret;
148 
149 		msgloc = current_locale(loc, LC_MESSAGES);
150 
151 		ret = process_nlspath(cur_domain, msgloc,
152 		    (const char *)nlspath, &cur_binding);
153 		if (ret == -1) {
154 			/* error occurred */
155 			DFLTMSG(result, msgid1, msgid2, n, plural);
156 			return (result);
157 		} else if (ret == 0) {
158 			nlspath = NULL;
159 		}
160 	}
161 
162 	cur_domain_binding = _real_bindtextdomain_u(cur_domain,
163 	    NULL, TP_BINDING);
164 	if (cur_domain_binding == NULL) {
165 		DFLTMSG(result, msgid1, msgid2, n, plural);
166 		return (result);
167 	}
168 
169 	mp->msgid1 = msgid1;
170 	mp->msgid2 = msgid2;
171 	mp->msgfile = msgfile;
172 	mp->domain = cur_domain;
173 	mp->binding = cur_domain_binding;
174 	mp->locale = cur_locale;
175 	mp->language = language;
176 	mp->domain_len = cur_domain_len;
177 	mp->n = n;
178 	mp->category = category;
179 	mp->plural = plural;
180 	mp->hash_domain = hash_domain;
181 
182 	/*
183 	 * Spec1170 requires that we use NLSPATH if it's defined, to
184 	 * override any system default variables.  If NLSPATH is not
185 	 * defined or if a message catalog is not found in any of the
186 	 * components (bindings) specified by NLSPATH, dcgettext_u() will
187 	 * search for the message catalog in either a) the binding path set
188 	 * by any previous application calls to bindtextdomain() or
189 	 * b) the default binding path (/usr/lib/locale).  Save the original
190 	 * binding path so that we can search it if the message catalog
191 	 * is not found via NLSPATH.  The original binding is restored before
192 	 * returning from this routine because the gettext routines should
193 	 * not change the binding set by the application.  This allows
194 	 * bindtextdomain() to be called once for all gettext() calls in the
195 	 * application.
196 	 */
197 
198 	/*
199 	 * First, examine NLSPATH
200 	 */
201 	if (nlspath) {
202 		/*
203 		 * NLSPATH binding has been successfully built
204 		 */
205 #ifdef GETTEXT_DEBUG
206 		gprintf(0, "************************** examining NLSPATH\n");
207 		gprintf(0, "       cur_binding: \"%s\"\n",
208 		    cur_binding ? cur_binding : "(null)");
209 #endif
210 
211 		mp->nlsp = 1;
212 		/*
213 		 * cur_binding always ends with ':' before a null
214 		 * termination.
215 		 */
216 		while (*cur_binding) {
217 			cb = cur_binding;
218 			while (*cur_binding != ':')
219 				cur_binding++;
220 			cblen = cur_binding - cb;
221 			cur_binding++;
222 			if (cblen >= MAXPATHLEN) {
223 				/* cur_binding too long */
224 				DFLTMSG(result, msgid1, msgid2, n, plural);
225 				return (result);
226 			}
227 
228 			(void) memcpy(mp->msgfile, cb, cblen);
229 			*(mp->msgfile + cblen) = '\0';
230 
231 #ifdef GETTEXT_DEBUG
232 			gprintf(0, "*******************"
233 			    "********************* \n");
234 			gprintf(0, "       msgfile: \"%s\"\n",
235 			    msgfile ? msgfile : "(null)");
236 			gprintf(0, "*******************"
237 			    "********************* \n");
238 #endif
239 			result = handle_mo(mp);
240 			if (result) {
241 				return (result);
242 			}
243 		}
244 	}
245 
246 	mp->nlsp = 0;
247 	mp->binding = cur_domain_binding;
248 	/*
249 	 * Next, examine LANGUAGE
250 	 */
251 	if (language) {
252 		char	*ret_msg;
253 		ret_msg = handle_lang(mp);
254 		if (ret_msg != NULL) {
255 			/* valid msg found in GNU MO */
256 			return (ret_msg);
257 		}
258 		/*
259 		 * handle_lang() may have overridden locale
260 		 */
261 		mp->locale = cur_locale;
262 		mp->status = 0;
263 	}
264 
265 	/*
266 	 * Finally, handle a single binding
267 	 */
268 #ifdef GETTEXT_DEBUG
269 	*mp->msgfile = '\0';
270 #endif
271 	if (mk_msgfile(mp) == NULL) {
272 		DFLTMSG(result, msgid1, msgid2, n, plural);
273 		return (result);
274 	}
275 
276 	result = handle_mo(mp);
277 	if (result) {
278 		return (result);
279 	}
280 	DFLTMSG(result, msgid1, msgid2, n, plural);
281 	return (result);
282 } /* _real_gettext_u */
283 
284 #define	ALLFREE	\
285 	free_all(nlstmp, nnp, pathname, ppaths, lang)
286 
287 static void
free_all(Nlstmp * nlstmp,Nls_node * nnp,char * pathname,char * ppaths,char * lang)288 free_all(Nlstmp *nlstmp, Nls_node *nnp, char *pathname,
289     char *ppaths, char *lang)
290 {
291 	Nlstmp	*tp, *tq;
292 
293 	tp = nlstmp;
294 	while (tp) {
295 		tq = tp->next;
296 		free(tp);
297 		tp = tq;
298 	}
299 	if (nnp->locale)
300 		free(nnp->locale);
301 	if (nnp->domain)
302 		free(nnp->domain);
303 	if (pathname)
304 		free(pathname);
305 	if (ppaths)
306 		free(ppaths);
307 	if (lang)
308 		free(lang);
309 	free(nnp);
310 }
311 
312 /*
313  * process_nlspath(): process the NLSPATH environment variable.
314  *
315  *		this routine looks at NLSPATH in the environment,
316  *		and will try to build up the binding list based
317  *		on the settings of NLSPATH.
318  *
319  * RETURN:
320  * -1:  Error occurred
321  *  0:  No error, but no binding list has been built
322  *  1:  No error, and a binding list has been built
323  *
324  */
325 static int
process_nlspath(const char * cur_domain,const char * cur_msgloc,const char * nlspath,char ** binding)326 process_nlspath(const char *cur_domain, const char *cur_msgloc,
327     const char *nlspath, char **binding)
328 {
329 	char	*s;			/* generic string ptr */
330 	char	*territory;		/* our current territory element */
331 	char	*codeset;		/* our current codeset element */
332 	char	*s1;			/* for handling territory */
333 	char	*s2;			/* for handling codeset */
334 	char	*lang = NULL;	/* our current language element */
335 	char	*ppaths = NULL;	/* ptr to all of the templates */
336 	char	*pathname = NULL;	/* the full pathname to the file */
337 	size_t	nlspath_len, domain_len, locale_len, path_len;
338 	size_t	ppaths_len = 0;
339 	Nlstmp	*nlstmp = NULL;
340 	Nlstmp	*pnlstmp, *qnlstmp;
341 	Nls_node	*cur_nls, *nnp;
342 	Gettext_t	*gt = global_gt;
343 
344 #ifdef GETTEXT_DEBUG
345 	gprintf(0, "*************** process_nlspath(%s, %s, "
346 	    "%s, 0x%p)\n", cur_domain,
347 	    cur_msgloc, nlspath, (void *)binding);
348 #endif
349 
350 	cur_nls = gt->c_n_node;
351 	if (cur_nls &&
352 	    (strcmp(cur_nls->domain, cur_domain) == 0 &&
353 	    strcmp(cur_nls->locale, cur_msgloc) == 0 &&
354 	    strcmp(cur_nls->nlspath, nlspath) == 0)) {
355 		*binding = cur_nls->ppaths;
356 		return (1);
357 	}
358 
359 	nnp = gt->n_node;
360 	while (nnp) {
361 		if (strcmp(nnp->domain, cur_domain) == 0 &&
362 		    strcmp(nnp->locale, cur_msgloc) == 0 &&
363 		    strcmp(nnp->nlspath, nlspath) == 0) {
364 			/* found */
365 			gt->c_n_node = nnp;
366 			*binding = nnp->ppaths;
367 			return (1);
368 		}
369 		nnp = nnp->next;
370 	}
371 	/* not found */
372 
373 	nnp = calloc(1, sizeof (Nls_node));
374 	if (nnp == NULL) {
375 		ALLFREE;
376 		return (-1);
377 	}
378 
379 	nlspath_len = strlen(nlspath);
380 	locale_len = strlen(cur_msgloc);
381 	domain_len = strlen(cur_domain);
382 
383 	lang = s = strdup(cur_msgloc);
384 	if (lang == NULL) {
385 		ALLFREE;
386 		return (-1);
387 	}
388 	s1 = s2 = NULL;
389 	while (*s) {
390 		if (*s == '_') {
391 			s1 = s;
392 			*s1++ = '\0';
393 		} else if (*s == '.') {
394 			s2 = s;
395 			*s2++ = '\0';
396 		}
397 		s++;
398 	}
399 	territory = s1;
400 	codeset = s2;
401 
402 	/*
403 	 * now that we have the name (domain), we first look through NLSPATH,
404 	 * in an attempt to get the locale. A locale may be completely
405 	 * specified as "language_territory.codeset". NLSPATH consists
406 	 * of templates separated by ":" characters. The following are
407 	 * the substitution values within NLSPATH:
408 	 *	%N = DEFAULT_DOMAIN
409 	 *	%L = The value of the LC_MESSAGES category.
410 	 *	%I = The language element from the LC_MESSAGES category.
411 	 *	%t = The territory element from the LC_MESSAGES category.
412 	 *	%c = The codeset element from the LC_MESSAGES category.
413 	 *	%% = A single character.
414 	 * if we find one of these characters, we will carry out the
415 	 * appropriate substitution.
416 	 */
417 	pathname = malloc(MAXPATHLEN);
418 	if (pathname == NULL) {
419 		ALLFREE;
420 		return (-1);
421 	}
422 	s = (char *)nlspath;		/* s has a content of NLSPATH */
423 	while (*s) {				/* march through NLSPATH */
424 		(void) memset(pathname, 0, MAXPATHLEN);
425 		if (*s == ':') {
426 			/*
427 			 * this loop only occurs if we have to replace
428 			 * ":" by "name". replace_nls_option() below
429 			 * will handle the subsequent ":"'s.
430 			 */
431 			pnlstmp = malloc(sizeof (Nlstmp));
432 			if (pnlstmp == NULL) {
433 				ALLFREE;
434 				return (-1);
435 			}
436 
437 			(void) memcpy(pnlstmp->pathname, cur_domain,
438 			    domain_len + 1);
439 			pnlstmp->len = domain_len;
440 			ppaths_len += domain_len + 1; /* 1 for ':' */
441 
442 
443 			pnlstmp->next = NULL;
444 
445 			if (nlstmp == NULL) {
446 				nlstmp = pnlstmp;
447 				qnlstmp = pnlstmp;
448 			} else {
449 				qnlstmp->next = pnlstmp;
450 				qnlstmp = pnlstmp;
451 			}
452 
453 			++s;
454 			continue;
455 		}
456 		/* replace Substitution field */
457 		s = replace_nls_option(s, cur_domain, pathname,
458 		    (char *)cur_msgloc, lang, territory, codeset);
459 
460 		if (s == NULL) {
461 			ALLFREE;
462 			return (-1);
463 		}
464 
465 		/* if we've found a valid file: */
466 		if (*pathname) {
467 			/* add template to end of chain of pathnames: */
468 			pnlstmp = malloc(sizeof (Nlstmp));
469 			if (pnlstmp == NULL) {
470 				ALLFREE;
471 				return (-1);
472 			}
473 
474 			path_len = strlen(pathname);
475 			(void) memcpy(pnlstmp->pathname, pathname,
476 			    path_len + 1);
477 			pnlstmp->len = path_len;
478 			ppaths_len += path_len + 1; /* 1 for ':' */
479 
480 			pnlstmp->next = NULL;
481 
482 			if (nlstmp == NULL) {
483 				nlstmp = pnlstmp;
484 				qnlstmp = pnlstmp;
485 			} else {
486 				qnlstmp->next = pnlstmp;
487 				qnlstmp = pnlstmp;
488 			}
489 		}
490 		if (*s) {
491 			++s;
492 		}
493 	}
494 	/*
495 	 * now that we've handled the pathname templates, concatenate them
496 	 * all into the form "template1:template2:..." for _bindtextdomain_u()
497 	 */
498 
499 	if (ppaths_len != 0) {
500 		ppaths = malloc(ppaths_len + 1);
501 		if (ppaths == NULL) {
502 			ALLFREE;
503 			return (-1);
504 		}
505 		*ppaths = '\0';
506 	} else {
507 		ALLFREE;
508 		return (0);
509 	}
510 
511 	/*
512 	 * extract the path templates (fifo), and concatenate them
513 	 * all into a ":" separated string for _bindtextdomain_u()
514 	 */
515 	pnlstmp = nlstmp;
516 	s = ppaths;
517 	while (pnlstmp) {
518 		(void) memcpy(s, pnlstmp->pathname, pnlstmp->len);
519 		s += pnlstmp->len;
520 		*s++ = ':';
521 		qnlstmp = pnlstmp->next;
522 		free(pnlstmp);
523 		pnlstmp = qnlstmp;
524 	}
525 	*s = '\0';
526 	nlstmp = NULL;
527 
528 	nnp->domain = malloc(domain_len + 1);
529 	if (nnp->domain == NULL) {
530 		ALLFREE;
531 		return (-1);
532 	} else {
533 		(void) memcpy(nnp->domain, cur_domain, domain_len + 1);
534 	}
535 	nnp->locale = malloc(locale_len + 1);
536 	if (nnp->locale == NULL) {
537 		ALLFREE;
538 		return (-1);
539 	} else {
540 		(void) memcpy(nnp->locale, cur_msgloc, locale_len + 1);
541 	}
542 	nnp->nlspath = malloc(nlspath_len + 1);
543 	if (nnp->nlspath == NULL) {
544 		ALLFREE;
545 		return (-1);
546 	} else {
547 		(void) memcpy(nnp->nlspath, nlspath, nlspath_len + 1);
548 	}
549 	nnp->ppaths = ppaths;
550 
551 	nnp->next = gt->n_node;
552 	gt->n_node = nnp;
553 	gt->c_n_node = nnp;
554 
555 	free(pathname);
556 	free(lang);
557 #ifdef GETTEXT_DEBUG
558 	gprintf(0, "*************** existing process_nlspath with success\n");
559 	gprintf(0, "       binding: \"%s\"\n", ppaths);
560 #endif
561 	*binding = ppaths;
562 	return (1);
563 }
564 
565 
566 /*
567  * This routine will replace substitution parameters in NLSPATH
568  * with appropiate values.
569  */
570 static char *
replace_nls_option(char * s,const char * name,char * pathname,char * locale,char * lang,char * territory,char * codeset)571 replace_nls_option(char *s, const char *name, char *pathname,
572     char *locale, char *lang, char *territory, char *codeset)
573 {
574 	char	*t, *u;
575 	char	*limit;
576 
577 	t = pathname;
578 	limit = pathname + MAXPATHLEN - 1;
579 
580 	while (*s && *s != ':') {
581 		if (t < limit) {
582 			/*
583 			 * %% is considered a single % character (XPG).
584 			 * %L : LC_MESSAGES (XPG4) LANG(XPG3)
585 			 * %l : The language element from the current locale.
586 			 *	(XPG3, XPG4)
587 			 */
588 			if (*s != '%')
589 				*t++ = *s;
590 			else if (*++s == 'N') {
591 				if (name) {
592 					u = (char *)name;
593 					while (*u && (t < limit))
594 						*t++ = *u++;
595 				}
596 			} else if (*s == 'L') {
597 				if (locale) {
598 					u = locale;
599 					while (*u && (t < limit))
600 						*t++ = *u++;
601 				}
602 			} else if (*s == 'l') {
603 				if (lang) {
604 					u = lang;
605 					while (*u && (*u != '_') &&
606 					    (t < limit))
607 						*t++ = *u++;
608 				}
609 			} else if (*s == 't') {
610 				if (territory) {
611 					u = territory;
612 					while (*u && (*u != '.') &&
613 					    (t < limit))
614 						*t++ = *u++;
615 				}
616 			} else if (*s == 'c') {
617 				if (codeset) {
618 					u = codeset;
619 					while (*u && (t < limit))
620 						*t++ = *u++;
621 				}
622 			} else {
623 				if (t < limit)
624 					*t++ = *s;
625 			}
626 		} else {
627 			/* too long pathname */
628 			return (NULL);
629 		}
630 		++s;
631 	}
632 	*t = '\0';
633 	return (s);
634 }
635 
636 
637 char *
_real_bindtextdomain_u(const char * domain,const char * binding,int type)638 _real_bindtextdomain_u(const char *domain, const char *binding,
639     int type)
640 {
641 	struct domain_binding	*bind, *prev;
642 	Gettext_t	*gt = global_gt;
643 	char	**binding_addr;
644 
645 #ifdef GETTEXT_DEBUG
646 	gprintf(0, "*************** _real_bindtextdomain_u(\"%s\", "
647 	    "\"%s\", \"%s\")\n",
648 	    (domain ? domain : ""),
649 	    (binding ? binding : ""),
650 	    (type == TP_BINDING) ? "TP_BINDING" : "TP_CODESET");
651 #endif
652 
653 	/*
654 	 * If domain is a NULL pointer, no change will occur regardless
655 	 * of binding value. Just return NULL.
656 	 */
657 	if (domain == NULL) {
658 		return (NULL);
659 	}
660 
661 	/*
662 	 * Global Binding is not supported any more.
663 	 * Just return NULL if domain is NULL string.
664 	 */
665 	if (*domain == '\0') {
666 		return (NULL);
667 	}
668 
669 	/* linear search for binding, rebind if found, add if not */
670 	bind = FIRSTBIND(gt);
671 	prev = NULL;	/* Two pointers needed for pointer operations */
672 
673 	while (bind) {
674 		if (strcmp(domain, bind->domain) == 0) {
675 			/*
676 			 * Domain found.
677 			 */
678 			binding_addr = (type == TP_BINDING) ? &(bind->binding) :
679 			    &(bind->codeset);
680 			if (binding == NULL) {
681 				/*
682 				 * if binding is null, then query
683 				 */
684 				return (*binding_addr);
685 			}
686 			/* replace existing binding with new binding */
687 			char *new_binding = strdup(binding);
688 			if (new_binding == NULL) {
689 				return (NULL);
690 			}
691 			free(*binding_addr);
692 			*binding_addr = new_binding;
693 #ifdef GETTEXT_DEBUG
694 			printlist();
695 #endif
696 			return (*binding_addr);
697 		}
698 		prev = bind;
699 		bind = bind->next;
700 	} /* while (bind) */
701 
702 	/* domain has not been found in the list at this point */
703 	if (binding) {
704 		/*
705 		 * domain is not found, but binding is not NULL.
706 		 * Then add a new node to the end of linked list.
707 		 */
708 
709 		if ((bind = malloc(sizeof (Dbinding))) == NULL) {
710 			return (NULL);
711 		}
712 		if ((bind->domain = strdup(domain)) == NULL) {
713 			free(bind);
714 			return (NULL);
715 		}
716 		bind->binding = NULL;
717 		bind->codeset = NULL;
718 		binding_addr = (type == TP_BINDING) ? &(bind->binding) :
719 		    &(bind->codeset);
720 		if ((*binding_addr = strdup(binding)) == NULL) {
721 			free(bind->domain);
722 			free(bind);
723 			return (NULL);
724 		}
725 		bind->next = NULL;
726 
727 		if (prev) {
728 			/* reached the end of list */
729 			prev->next = bind;
730 		} else {
731 			/* list was empty */
732 			FIRSTBIND(gt) = bind;
733 		}
734 
735 #ifdef GETTEXT_DEBUG
736 		printlist();
737 #endif
738 		return (*binding_addr);
739 	} else {
740 		/*
741 		 * Query of domain which is not found in the list
742 		 * for bindtextdomain, returns defaultbind
743 		 * for bind_textdomain_codeset, returns NULL
744 		 */
745 		if (type == TP_BINDING) {
746 			return ((char *)defaultbind);
747 		} else {
748 			return (NULL);
749 		}
750 	} /* if (binding) */
751 
752 	/* Must not reach here */
753 
754 } /* _real_bindtextdomain_u */
755 
756 
757 char *
_textdomain_u(const char * domain,char * result)758 _textdomain_u(const char *domain, char *result)
759 {
760 	char	*p;
761 	size_t	domain_len;
762 	Gettext_t	*gt = global_gt;
763 
764 #ifdef GETTEXT_DEBUG
765 	gprintf(0, "*************** _textdomain_u(\"%s\", 0x%p)\n",
766 	    (domain ? domain : ""), (void *)result);
767 #endif
768 
769 	/* Query is performed for NULL domain pointer */
770 	if (domain == NULL) {
771 		(void) strcpy(result, CURRENT_DOMAIN(gt));
772 		return (result);
773 	}
774 
775 	/* check for error. */
776 	/*
777 	 * domain is limited to TEXTDOMAINMAX bytes
778 	 * excluding a null termination.
779 	 */
780 	domain_len = strlen(domain);
781 	if (domain_len > TEXTDOMAINMAX) {
782 		/* too long */
783 		return (NULL);
784 	}
785 
786 	/*
787 	 * Calling textdomain() with a null domain string sets
788 	 * the domain to the default domain.
789 	 * If non-null string is passwd, current domain is changed
790 	 * to the new domain.
791 	 */
792 
793 	/* actually this if clause should be protected from signals */
794 	if (*domain == '\0') {
795 		if (CURRENT_DOMAIN(gt) != default_domain) {
796 			free(CURRENT_DOMAIN(gt));
797 			CURRENT_DOMAIN(gt) = (char *)default_domain;
798 		}
799 	} else {
800 		p = malloc(domain_len + 1);
801 		if (p == NULL)
802 			return (NULL);
803 		(void) strcpy(p, domain);
804 		if (CURRENT_DOMAIN(gt) != default_domain)
805 			free(CURRENT_DOMAIN(gt));
806 		CURRENT_DOMAIN(gt) = p;
807 	}
808 
809 	(void) strcpy(result, CURRENT_DOMAIN(gt));
810 	return (result);
811 } /* _textdomain_u */
812 
813 /*
814  * key_2_text() translates msd_id into target string.
815  */
816 static char *
key_2_text(Msg_s_node * messages,const char * key_string)817 key_2_text(Msg_s_node *messages, const char *key_string)
818 {
819 	int	val;
820 	char	*msg_id_str;
821 	unsigned char	kc = *(unsigned char *)key_string;
822 	struct msg_struct	*check_msg_list;
823 
824 #ifdef GETTEXT_DEBUG
825 	gprintf(0, "*************** key_2_text(0x%p, \"%s\")\n",
826 	    (void *)messages, key_string ? key_string : "(null)");
827 	printsunmsg(messages, 1);
828 #endif
829 
830 	check_msg_list = messages->msg_list +
831 	    messages->msg_file_info->msg_mid;
832 	for (;;) {
833 		msg_id_str = messages->msg_ids +
834 		    check_msg_list->msgid_offset;
835 		/*
836 		 * To maintain the compatibility with Zeus mo file,
837 		 * msg_id's are stored in descending order.
838 		 * If the ascending order is desired, change "msgfmt.c"
839 		 * and switch msg_id_str and key_string in the following
840 		 * strcmp() statement.
841 		 */
842 		val = *(unsigned char *)msg_id_str - kc;
843 		if ((val == 0) &&
844 		    (val = strcmp(msg_id_str, key_string)) == 0) {
845 			return (messages->msg_strs
846 			    + check_msg_list->msgstr_offset);
847 		} else if (val < 0) {
848 			if (check_msg_list->less != LEAFINDICATOR) {
849 				check_msg_list = messages->msg_list +
850 				    check_msg_list->less;
851 				continue;
852 			}
853 			return ((char *)key_string);
854 		} else {
855 			/* val > 0 */
856 			if (check_msg_list->more != LEAFINDICATOR) {
857 				check_msg_list = messages->msg_list +
858 				    check_msg_list->more;
859 				continue;
860 			}
861 			return ((char *)key_string);
862 		}
863 	}
864 }
865 
866 /*
867  * sun_setmsg
868  *
869  * INPUT
870  *   mnp  - message node
871  *   addr - address to the mmapped file
872  *   size - size of the file
873  *
874  * RETURN
875  *   0   - either T_SUN_MO or T_ILL_MO has been set
876  *   1   - not a valid sun mo file
877  *  -1   - failed
878  */
879 static int
sun_setmsg(Msg_node * mnp,char * addr,size_t size)880 sun_setmsg(Msg_node *mnp, char *addr, size_t size)
881 {
882 	struct msg_info	*sun_header;
883 	Msg_s_node	*p;
884 	uint32_t	first_4bytes;
885 	int	mid, count;
886 	int	struct_size, struct_size_old;
887 	int	msg_struct_size;
888 
889 	if (size < sizeof (struct msg_info)) {
890 		/* invalid mo file */
891 		mnp->type = T_ILL_MO;
892 #ifdef GETTEXT_DEBUG
893 		gprintf(0, "********* exiting sun_setmsg\n");
894 		printmnp(mnp, 1);
895 #endif
896 		return (0);
897 	}
898 
899 	first_4bytes = *((uint32_t *)(uintptr_t)addr);
900 	if (first_4bytes > INT_MAX) {
901 		/*
902 		 * Not a valid sun mo file
903 		 */
904 		return (1);
905 	}
906 
907 	/* candidate for sun mo */
908 
909 	sun_header = (struct msg_info *)(uintptr_t)addr;
910 	mid = sun_header->msg_mid;
911 	count = sun_header->msg_count;
912 	msg_struct_size = sun_header->msg_struct_size;
913 	struct_size_old = (int)(OLD_MSG_STRUCT_SIZE * count);
914 	struct_size = (int)(MSG_STRUCT_SIZE * count);
915 
916 	if ((((count - 1) / 2) != mid) ||
917 	    ((msg_struct_size != struct_size_old) &&
918 	    (msg_struct_size != struct_size))) {
919 		/* invalid mo file */
920 		mnp->type = T_ILL_MO;
921 #ifdef GETTEXT_DEBUG
922 		gprintf(0, "********* exiting sun_setmsg\n");
923 		printmnp(mnp, 1);
924 #endif
925 		return (0);
926 	}
927 	/* valid sun mo file */
928 
929 	p = malloc(sizeof (Msg_s_node));
930 	if (p == NULL) {
931 		return (-1);
932 	}
933 
934 	p->msg_file_info = sun_header;
935 	p->msg_list = (struct msg_struct *)(uintptr_t)
936 	    (addr + sizeof (struct msg_info));
937 	p->msg_ids = (char *)(addr + sizeof (struct msg_info) +
938 	    struct_size);
939 	p->msg_strs = (char *)(addr + sizeof (struct msg_info) +
940 	    struct_size + sun_header->str_count_msgid);
941 
942 	mnp->msg.sunmsg = p;
943 	mnp->type = T_SUN_MO;
944 #ifdef GETTEXT_DEBUG
945 	gprintf(0, "******** exiting sun_setmsg\n");
946 	printmnp(mnp, 1);
947 #endif
948 	return (0);
949 }
950 
951 /*
952  * setmsg
953  *
954  * INPUT
955  *   mnp  - message node
956  *   addr - address to the mmapped file
957  *   size - size of the file
958  *
959  * RETURN
960  *   0   - succeeded
961  *  -1   - failed
962  */
963 static int
setmsg(Msg_node * mnp,char * addr,size_t size)964 setmsg(Msg_node *mnp, char *addr, size_t size)
965 {
966 	int	ret;
967 	if ((ret = sun_setmsg(mnp, addr, size)) <= 0)
968 		return (ret);
969 
970 	return (gnu_setmsg(mnp, addr, size));
971 }
972 
973 static char *
handle_type_mo(Msg_node * mnp,struct msg_pack * mp)974 handle_type_mo(Msg_node *mnp, struct msg_pack *mp)
975 {
976 	char	*result;
977 
978 	switch (mnp->type) {
979 	case T_ILL_MO:
980 		/* invalid MO */
981 		return (NULL);
982 	case T_SUN_MO:
983 		/* Sun MO found */
984 		mp->status |= ST_SUN_MO_FOUND;
985 
986 		if (mp->plural) {
987 			/*
988 			 * *ngettext is called against
989 			 * Sun MO file
990 			 */
991 			int	exp = (mp->n == 1);
992 			result = (char *)mp->msgid1;
993 			if (!exp)
994 				result = (char *)mp->msgid2;
995 			return (result);
996 		}
997 		result = key_2_text(mnp->msg.sunmsg, mp->msgid1);
998 		if (!mnp->trusted) {
999 			result = check_format(mp->msgid1, result, 0);
1000 		}
1001 		return (result);
1002 	case T_GNU_MO:
1003 		/* GNU MO found */
1004 		mp->status |= ST_GNU_MO_FOUND;
1005 
1006 		result = gnu_key_2_text(mnp->msg.gnumsg,
1007 		    get_codeset(mp->domain), mp);
1008 
1009 		if (result == mp->msgid1 || result == mp->msgid2) {
1010 			/* no valid msg found */
1011 			return (result);
1012 		}
1013 
1014 		/* valid msg found */
1015 		mp->status |= ST_GNU_MSG_FOUND;
1016 
1017 		if (!mnp->trusted) {
1018 			result = check_format(mp->msgid1, result, 0);
1019 			if (result == mp->msgid1) {
1020 				DFLTMSG(result, mp->msgid1, mp->msgid2,
1021 				    mp->n, mp->plural);
1022 			}
1023 		}
1024 		return (result);
1025 	default:
1026 		/* this should never happen */
1027 		DFLTMSG(result, mp->msgid1, mp->msgid2, mp->n, mp->plural);
1028 		return (result);
1029 	}
1030 	/* NOTREACHED */
1031 }
1032 
1033 /*
1034  * handle_mo() returns NULL if invalid MO found.
1035  */
1036 char *
handle_mo(struct msg_pack * mp)1037 handle_mo(struct msg_pack *mp)
1038 {
1039 	int	fd;
1040 	char	*result;
1041 	struct stat64	statbuf;
1042 	Msg_node	*mnp;
1043 	Gettext_t	*gt = global_gt;
1044 
1045 #define	CONNECT_ENTRY	\
1046 	mnp->next = gt->m_node; \
1047 	gt->m_node = mnp; \
1048 	gt->c_m_node = mnp
1049 
1050 #ifdef GETTEXT_DEBUG
1051 	gprintf(0, "*************** handle_mo(0x%p)\n", (void *)mp);
1052 	printmp(mp, 1);
1053 #endif
1054 
1055 	mnp = check_cache(mp);
1056 
1057 	if (mnp != NULL) {
1058 		/* cache found */
1059 		return (handle_type_mo(mnp, mp));
1060 	}
1061 
1062 	/*
1063 	 * Valid entry not found in the cache
1064 	 */
1065 	mnp = calloc(1, sizeof (Msg_node));
1066 	if (mnp == NULL) {
1067 		DFLTMSG(result, mp->msgid1, mp->msgid2, mp->n, mp->plural);
1068 		return (result);
1069 	}
1070 	mnp->hashid = mp->hash_domain;
1071 	mnp->path = strdup(mp->msgfile);
1072 	if (mnp->path == NULL) {
1073 		free(mnp);
1074 		DFLTMSG(result, mp->msgid1, mp->msgid2, mp->n, mp->plural);
1075 		return (result);
1076 	}
1077 
1078 	fd = nls_safe_open(mp->msgfile, &statbuf, &mp->trusted, !mp->nlsp);
1079 	if ((fd == -1) || (statbuf.st_size > LONG_MAX)) {
1080 		if (fd != -1)
1081 			(void) close(fd);
1082 		mnp->type = T_ILL_MO;
1083 		CONNECT_ENTRY;
1084 		return (NULL);
1085 	}
1086 	mp->fsz = (size_t)statbuf.st_size;
1087 	mp->addr = mmap(NULL, mp->fsz, PROT_READ, MAP_SHARED, fd, 0);
1088 	(void) close(fd);
1089 
1090 	if (mp->addr == MAP_FAILED) {
1091 		free(mnp->path);
1092 		free(mnp);
1093 		DFLTMSG(result, mp->msgid1, mp->msgid2, mp->n, mp->plural);
1094 		return (result);
1095 	}
1096 
1097 	if (setmsg(mnp, (char *)mp->addr, mp->fsz) == -1) {
1098 		free(mnp->path);
1099 		free(mnp);
1100 		(void) munmap(mp->addr, mp->fsz);
1101 		DFLTMSG(result, mp->msgid1, mp->msgid2, mp->n, mp->plural);
1102 		return (result);
1103 	}
1104 	mnp->trusted = mp->trusted;
1105 	CONNECT_ENTRY;
1106 
1107 	return (handle_type_mo(mnp, mp));
1108 }
1109