1 /* Copyright (C) 1995-2023 Free Software Foundation, Inc.
2 Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published by
6 the Free Software Foundation; either version 2.1 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* Tell glibc's <string.h> to provide a prototype for stpcpy().
18 This must come before <config.h> because <config.h> may include
19 <features.h>, and once <features.h> has been included, it's too late. */
20 #ifndef _GNU_SOURCE
21 # define _GNU_SOURCE 1
22 #endif
23
24 #ifdef HAVE_CONFIG_H
25 # include <config.h>
26 #endif
27
28 #include <string.h>
29
30 #if defined _LIBC || defined HAVE_ARGZ_H
31 # include <argz.h>
32 #endif
33 #include <ctype.h>
34 #include <sys/types.h>
35 #include <stdlib.h>
36
37 #include "loadinfo.h"
38
39 /* On some strange systems still no definition of NULL is found. Sigh! */
40 #ifndef NULL
41 # if defined __STDC__ && __STDC__
42 # define NULL ((void *) 0)
43 # else
44 # define NULL 0
45 # endif
46 #endif
47
48 /* @@ end of prolog @@ */
49
50 #ifdef _LIBC
51 /* Rename the non ANSI C functions. This is required by the standard
52 because some ANSI C functions will require linking with this object
53 file and the name space must not be polluted. */
54 # ifndef stpcpy
55 # define stpcpy(dest, src) __stpcpy(dest, src)
56 # endif
57 #else
58 # ifndef HAVE_STPCPY
59 static char *stpcpy (char *dest, const char *src);
60 # endif
61 #endif
62
63 /* Define function which are usually not available. */
64
65 #if defined HAVE_ARGZ_COUNT
66 # undef __argz_count
67 # define __argz_count argz_count
68 #else
69 /* Returns the number of strings in ARGZ. */
70 static size_t
71 argz_count__ (const char *argz, size_t len)
72 {
73 size_t count = 0;
74 while (len > 0)
75 {
76 size_t part_len = strlen (argz);
77 argz += part_len + 1;
78 len -= part_len + 1;
79 count++;
80 }
81 return count;
82 }
83 # undef __argz_count
84 # define __argz_count(argz, len) argz_count__ (argz, len)
85 #endif /* !_LIBC && !HAVE_ARGZ_COUNT */
86
87 #if defined HAVE_ARGZ_STRINGIFY
88 # undef __argz_stringify
89 # define __argz_stringify argz_stringify
90 #else
91 /* Make '\0' separated arg vector ARGZ printable by converting all the '\0's
92 except the last into the character SEP. */
93 static void
94 argz_stringify__ (char *argz, size_t len, int sep)
95 {
96 while (len > 0)
97 {
98 size_t part_len = strlen (argz);
99 argz += part_len;
100 len -= part_len + 1;
101 if (len > 0)
102 *argz++ = sep;
103 }
104 }
105 # undef __argz_stringify
106 # define __argz_stringify(argz, len, sep) argz_stringify__ (argz, len, sep)
107 #endif /* !_LIBC && !HAVE_ARGZ_STRINGIFY */
108
109 #ifdef _LIBC
110 #elif defined HAVE_ARGZ_NEXT
111 # undef __argz_next
112 # define __argz_next argz_next
113 #else
114 static char *
115 argz_next__ (char *argz, size_t argz_len, const char *entry)
116 {
117 if (entry)
118 {
119 if (entry < argz + argz_len)
120 entry = strchr (entry, '\0') + 1;
121
122 return entry >= argz + argz_len ? NULL : (char *) entry;
123 }
124 else
125 if (argz_len > 0)
126 return argz;
127 else
128 return 0;
129 }
130 # undef __argz_next
131 # define __argz_next(argz, len, entry) argz_next__ (argz, len, entry)
132 #endif /* !_LIBC && !HAVE_ARGZ_NEXT */
133
134 /* Return number of bits set in X. */
135 #ifndef ARCH_POP
136 static inline int
137 pop (int x)
138 {
139 /* We assume that no more than 16 bits are used. */
140 x = ((x & ~0x5555) >> 1) + (x & 0x5555);
141 x = ((x & ~0x3333) >> 2) + (x & 0x3333);
142 x = ((x >> 4) + x) & 0x0f0f;
143 x = ((x >> 8) + x) & 0xff;
144
145 return x;
146 }
147 #endif
148
149
150 struct loaded_l10nfile *
151 _nl_make_l10nflist (struct loaded_l10nfile **l10nfile_list,
152 const char *dirlist, size_t dirlist_len,
153 int mask, const char *language, const char *territory,
154 const char *codeset, const char *normalized_codeset,
155 const char *modifier,
156 const char *filename, int do_allocate)
157 {
158 char *abs_filename;
159 struct loaded_l10nfile *last = NULL;
160 struct loaded_l10nfile *retval;
161 char *cp;
162 size_t entries;
163 int cnt;
164
165 /* Allocate room for the full file name. */
166 abs_filename = (char *) malloc (dirlist_len
167 + strlen (language)
168 + ((mask & XPG_TERRITORY) != 0
169 ? strlen (territory) + 1 : 0)
170 + ((mask & XPG_CODESET) != 0
171 ? strlen (codeset) + 1 : 0)
172 + ((mask & XPG_NORM_CODESET) != 0
173 ? strlen (normalized_codeset) + 1 : 0)
174 + ((mask & XPG_MODIFIER) != 0
175 ? strlen (modifier) + 1 : 0)
176 + 1 + strlen (filename) + 1);
177
178 if (abs_filename == NULL)
179 return NULL;
180
181 retval = NULL;
182 last = NULL;
183
184 /* Construct file name. */
185 memcpy (abs_filename, dirlist, dirlist_len);
186 __argz_stringify (abs_filename, dirlist_len, ':');
187 cp = abs_filename + (dirlist_len - 1);
188 *cp++ = '/';
189 cp = stpcpy (cp, language);
190
191 if ((mask & XPG_TERRITORY) != 0)
192 {
193 *cp++ = '_';
194 cp = stpcpy (cp, territory);
195 }
196 if ((mask & XPG_CODESET) != 0)
197 {
198 *cp++ = '.';
199 cp = stpcpy (cp, codeset);
200 }
201 if ((mask & XPG_NORM_CODESET) != 0)
202 {
203 *cp++ = '.';
204 cp = stpcpy (cp, normalized_codeset);
205 }
206 if ((mask & XPG_MODIFIER) != 0)
207 {
208 *cp++ = '@';
209 cp = stpcpy (cp, modifier);
210 }
211
212 *cp++ = '/';
213 stpcpy (cp, filename);
214
215 /* Look in list of already loaded domains whether it is already
216 available. */
217 last = NULL;
218 for (retval = *l10nfile_list; retval != NULL; retval = retval->next)
219 if (retval->filename != NULL)
220 {
221 int compare = strcmp (retval->filename, abs_filename);
222 if (compare == 0)
223 /* We found it! */
224 break;
225 if (compare < 0)
226 {
227 /* It's not in the list. */
228 retval = NULL;
229 break;
230 }
231
232 last = retval;
233 }
234
235 if (retval != NULL || do_allocate == 0)
236 {
237 free (abs_filename);
238 return retval;
239 }
240
241 retval = (struct loaded_l10nfile *)
242 malloc (sizeof (*retval) + (__argz_count (dirlist, dirlist_len)
243 * (1 << pop (mask))
244 * sizeof (struct loaded_l10nfile *)));
245 if (retval == NULL)
246 {
247 free (abs_filename);
248 return NULL;
249 }
250
251 retval->filename = abs_filename;
252 /* If more than one directory is in the list this is a pseudo-entry
253 which just references others. We do not try to load data for it,
254 ever. */
255 retval->decided = (__argz_count (dirlist, dirlist_len) != 1
256 || ((mask & XPG_CODESET) != 0
257 && (mask & XPG_NORM_CODESET) != 0));
258 retval->data = NULL;
259
260 if (last == NULL)
261 {
262 retval->next = *l10nfile_list;
263 *l10nfile_list = retval;
264 }
265 else
266 {
267 retval->next = last->next;
268 last->next = retval;
269 }
270
271 entries = 0;
272 /* If the DIRLIST is a real list the RETVAL entry corresponds not to
273 a real file. So we have to use the DIRLIST separation mechanism
274 of the inner loop. */
275 cnt = __argz_count (dirlist, dirlist_len) == 1 ? mask - 1 : mask;
276 for (; cnt >= 0; --cnt)
277 if ((cnt & ~mask) == 0)
278 {
279 /* Iterate over all elements of the DIRLIST. */
280 char *dir = NULL;
281
282 while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir))
283 != NULL)
284 retval->successor[entries++]
285 = _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, cnt,
286 language, territory, codeset,
287 normalized_codeset, modifier, filename, 1);
288 }
289 retval->successor[entries] = NULL;
290
291 return retval;
292 }
293
294 /* Normalize codeset name. There is no standard for the codeset
295 names. Normalization allows the user to use any of the common
296 names. The return value is dynamically allocated and has to be
297 freed by the caller. */
298 const char *
299 _nl_normalize_codeset (const char *codeset, size_t name_len)
300 {
301 size_t len = 0;
302 int only_digit = 1;
303 char *retval;
304 char *wp;
305 size_t cnt;
306 #if !IS_IN (libc)
307 locale_t locale = newlocale (0, "C", NULL);
308 #else
309 # define locale _nl_C_locobj_ptr
310 #endif
311
312 for (cnt = 0; cnt < name_len; ++cnt)
313 if (__isalnum_l ((unsigned char) codeset[cnt], locale))
314 {
315 ++len;
316
317 if (! __isdigit_l ((unsigned char) codeset[cnt], locale))
318 only_digit = 0;
319 }
320
321 retval = (char *) malloc ((only_digit ? 3 : 0) + len + 1);
322
323 if (retval != NULL)
324 {
325 if (only_digit)
326 wp = stpcpy (retval, "iso");
327 else
328 wp = retval;
329
330 for (cnt = 0; cnt < name_len; ++cnt)
331 if (__isalpha_l ((unsigned char) codeset[cnt], locale))
332 *wp++ = __tolower_l ((unsigned char) codeset[cnt], locale);
333 else if (__isdigit_l ((unsigned char) codeset[cnt], locale))
334 *wp++ = codeset[cnt];
335
336 *wp = '\0';
337 }
338
339 return (const char *) retval;
340 }
341
342
343 /* @@ begin of epilog @@ */
344
345 /* We don't want libintl.a to depend on any other library. So we
346 avoid the non-standard function stpcpy. In GNU C Library this
347 function is available, though. Also allow the symbol HAVE_STPCPY
348 to be defined. */
349 #if !_LIBC && !HAVE_STPCPY
350 static char *
351 stpcpy (char *dest, const char *src)
352 {
353 while ((*dest++ = *src++) != '\0')
354 /* Do nothing. */ ;
355 return dest - 1;
356 }
357 #endif