1 | /* Copyright (C) 1996-2019 Free Software Foundation, Inc. |
2 | This file is part of the GNU C Library. |
3 | Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ |
18 | |
19 | #include <assert.h> |
20 | #include <errno.h> |
21 | #include <locale.h> |
22 | #include <stdlib.h> |
23 | #include <string.h> |
24 | #include <unistd.h> |
25 | #ifdef _POSIX_MAPPED_FILES |
26 | # include <sys/mman.h> |
27 | #endif |
28 | |
29 | #include "localeinfo.h" |
30 | #include "../iconv/gconv_charset.h" |
31 | #include "../iconv/gconv_int.h" |
32 | |
33 | |
34 | #ifdef NL_CURRENT_INDIRECT |
35 | # define DEFINE_CATEGORY(category, category_name, items, a) \ |
36 | extern struct __locale_data _nl_C_##category; \ |
37 | weak_extern (_nl_C_##category) |
38 | # include "categories.def" |
39 | # undef DEFINE_CATEGORY |
40 | |
41 | /* Array indexed by category of pointers to _nl_C_CATEGORY slots. |
42 | Elements are zero for categories whose data is never used. */ |
43 | struct __locale_data *const _nl_C[] attribute_hidden = |
44 | { |
45 | # define DEFINE_CATEGORY(category, category_name, items, a) \ |
46 | [category] = &_nl_C_##category, |
47 | # include "categories.def" |
48 | # undef DEFINE_CATEGORY |
49 | }; |
50 | #else |
51 | # define _nl_C (_nl_C_locobj.__locales) |
52 | #endif |
53 | |
54 | |
55 | /* For each category we keep a list of records for the locale files |
56 | which are somehow addressed. */ |
57 | struct loaded_l10nfile *_nl_locale_file_list[__LC_LAST]; |
58 | |
59 | const char _nl_default_locale_path[] attribute_hidden = COMPLOCALEDIR; |
60 | |
61 | /* Checks if the name is actually present, that is, not NULL and not |
62 | empty. */ |
63 | static inline int |
64 | name_present (const char *name) |
65 | { |
66 | return name != NULL && name[0] != '\0'; |
67 | } |
68 | |
69 | /* Checks that the locale name neither extremely long, nor contains a |
70 | ".." path component (to prevent directory traversal). */ |
71 | static inline int |
72 | valid_locale_name (const char *name) |
73 | { |
74 | /* Not set. */ |
75 | size_t namelen = strlen (name); |
76 | /* Name too long. The limit is arbitrary and prevents stack overflow |
77 | issues later. */ |
78 | if (__glibc_unlikely (namelen > 255)) |
79 | return 0; |
80 | /* Directory traversal attempt. */ |
81 | static const char slashdot[4] = {'/', '.', '.', '/'}; |
82 | if (__glibc_unlikely (__memmem (name, namelen, |
83 | slashdot, sizeof (slashdot)) != NULL)) |
84 | return 0; |
85 | if (namelen == 2 && __glibc_unlikely (name[0] == '.' && name [1] == '.')) |
86 | return 0; |
87 | if (namelen >= 3 |
88 | && __glibc_unlikely (((name[0] == '.' |
89 | && name[1] == '.' |
90 | && name[2] == '/') |
91 | || (name[namelen - 3] == '/' |
92 | && name[namelen - 2] == '.' |
93 | && name[namelen - 1] == '.')))) |
94 | return 0; |
95 | /* If there is a slash in the name, it must start with one. */ |
96 | if (__glibc_unlikely (memchr (name, '/', namelen) != NULL) && name[0] != '/') |
97 | return 0; |
98 | return 1; |
99 | } |
100 | |
101 | struct __locale_data * |
102 | _nl_find_locale (const char *locale_path, size_t locale_path_len, |
103 | int category, const char **name) |
104 | { |
105 | int mask; |
106 | /* Name of the locale for this category. */ |
107 | const char *cloc_name = *name; |
108 | const char *language; |
109 | const char *modifier; |
110 | const char *territory; |
111 | const char *codeset; |
112 | const char *normalized_codeset; |
113 | struct loaded_l10nfile *locale_file; |
114 | |
115 | if (cloc_name[0] == '\0') |
116 | { |
117 | /* The user decides which locale to use by setting environment |
118 | variables. */ |
119 | cloc_name = getenv ("LC_ALL" ); |
120 | if (!name_present (cloc_name)) |
121 | cloc_name = getenv (_nl_category_names.str |
122 | + _nl_category_name_idxs[category]); |
123 | if (!name_present (cloc_name)) |
124 | cloc_name = getenv ("LANG" ); |
125 | if (!name_present (cloc_name)) |
126 | cloc_name = _nl_C_name; |
127 | } |
128 | |
129 | /* We used to fall back to the C locale if the name contains a slash |
130 | character '/', but we now check for directory traversal in |
131 | valid_locale_name, so this is no longer necessary. */ |
132 | |
133 | if (__builtin_expect (strcmp (cloc_name, _nl_C_name), 1) == 0 |
134 | || __builtin_expect (strcmp (cloc_name, _nl_POSIX_name), 1) == 0) |
135 | { |
136 | /* We need not load anything. The needed data is contained in |
137 | the library itself. */ |
138 | *name = _nl_C_name; |
139 | return _nl_C[category]; |
140 | } |
141 | else if (!valid_locale_name (cloc_name)) |
142 | { |
143 | __set_errno (EINVAL); |
144 | return NULL; |
145 | } |
146 | |
147 | *name = cloc_name; |
148 | |
149 | /* We really have to load some data. First we try the archive, |
150 | but only if there was no LOCPATH environment variable specified. */ |
151 | if (__glibc_likely (locale_path == NULL)) |
152 | { |
153 | struct __locale_data *data |
154 | = _nl_load_locale_from_archive (category, name); |
155 | if (__glibc_likely (data != NULL)) |
156 | return data; |
157 | |
158 | /* Nothing in the archive with the given name. Expanding it as |
159 | an alias and retry. */ |
160 | cloc_name = _nl_expand_alias (*name); |
161 | if (cloc_name != NULL) |
162 | { |
163 | data = _nl_load_locale_from_archive (category, &cloc_name); |
164 | if (__builtin_expect (data != NULL, 1)) |
165 | return data; |
166 | } |
167 | |
168 | /* Nothing in the archive. Set the default path to search below. */ |
169 | locale_path = _nl_default_locale_path; |
170 | locale_path_len = sizeof _nl_default_locale_path; |
171 | } |
172 | else |
173 | /* We really have to load some data. First see whether the name is |
174 | an alias. Please note that this makes it impossible to have "C" |
175 | or "POSIX" as aliases. */ |
176 | cloc_name = _nl_expand_alias (*name); |
177 | |
178 | if (cloc_name == NULL) |
179 | /* It is no alias. */ |
180 | cloc_name = *name; |
181 | |
182 | /* Make a writable copy of the locale name. */ |
183 | char *loc_name = strdupa (cloc_name); |
184 | |
185 | /* LOCALE can consist of up to four recognized parts for the XPG syntax: |
186 | |
187 | language[_territory[.codeset]][@modifier] |
188 | |
189 | Beside the first all of them are allowed to be missing. If the |
190 | full specified locale is not found, the less specific one are |
191 | looked for. The various part will be stripped off according to |
192 | the following order: |
193 | (1) codeset |
194 | (2) normalized codeset |
195 | (3) territory |
196 | (4) modifier |
197 | */ |
198 | mask = _nl_explode_name (loc_name, &language, &modifier, &territory, |
199 | &codeset, &normalized_codeset); |
200 | if (mask == -1) |
201 | /* Memory allocate problem. */ |
202 | return NULL; |
203 | |
204 | /* If exactly this locale was already asked for we have an entry with |
205 | the complete name. */ |
206 | locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category], |
207 | locale_path, locale_path_len, mask, |
208 | language, territory, codeset, |
209 | normalized_codeset, modifier, |
210 | _nl_category_names.str |
211 | + _nl_category_name_idxs[category], 0); |
212 | |
213 | if (locale_file == NULL) |
214 | { |
215 | /* Find status record for addressed locale file. We have to search |
216 | through all directories in the locale path. */ |
217 | locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category], |
218 | locale_path, locale_path_len, mask, |
219 | language, territory, codeset, |
220 | normalized_codeset, modifier, |
221 | _nl_category_names.str |
222 | + _nl_category_name_idxs[category], 1); |
223 | if (locale_file == NULL) |
224 | /* This means we are out of core. */ |
225 | return NULL; |
226 | } |
227 | |
228 | /* The space for normalized_codeset is dynamically allocated. Free it. */ |
229 | if (mask & XPG_NORM_CODESET) |
230 | free ((void *) normalized_codeset); |
231 | |
232 | if (locale_file->decided == 0) |
233 | _nl_load_locale (locale_file, category); |
234 | |
235 | if (locale_file->data == NULL) |
236 | { |
237 | int cnt; |
238 | for (cnt = 0; locale_file->successor[cnt] != NULL; ++cnt) |
239 | { |
240 | if (locale_file->successor[cnt]->decided == 0) |
241 | _nl_load_locale (locale_file->successor[cnt], category); |
242 | if (locale_file->successor[cnt]->data != NULL) |
243 | break; |
244 | } |
245 | /* Move the entry we found (or NULL) to the first place of |
246 | successors. */ |
247 | locale_file->successor[0] = locale_file->successor[cnt]; |
248 | locale_file = locale_file->successor[cnt]; |
249 | |
250 | if (locale_file == NULL) |
251 | return NULL; |
252 | } |
253 | |
254 | /* The LC_CTYPE category allows to check whether a locale is really |
255 | usable. If the locale name contains a charset name and the |
256 | charset name used in the locale (present in the LC_CTYPE data) is |
257 | not the same (after resolving aliases etc) we reject the locale |
258 | since using it would irritate users expecting the charset named |
259 | in the locale name. */ |
260 | if (codeset != NULL) |
261 | { |
262 | /* Get the codeset information from the locale file. */ |
263 | static const int codeset_idx[] = |
264 | { |
265 | [__LC_CTYPE] = _NL_ITEM_INDEX (CODESET), |
266 | [__LC_NUMERIC] = _NL_ITEM_INDEX (_NL_NUMERIC_CODESET), |
267 | [__LC_TIME] = _NL_ITEM_INDEX (_NL_TIME_CODESET), |
268 | [__LC_COLLATE] = _NL_ITEM_INDEX (_NL_COLLATE_CODESET), |
269 | [__LC_MONETARY] = _NL_ITEM_INDEX (_NL_MONETARY_CODESET), |
270 | [__LC_MESSAGES] = _NL_ITEM_INDEX (_NL_MESSAGES_CODESET), |
271 | [__LC_PAPER] = _NL_ITEM_INDEX (_NL_PAPER_CODESET), |
272 | [__LC_NAME] = _NL_ITEM_INDEX (_NL_NAME_CODESET), |
273 | [__LC_ADDRESS] = _NL_ITEM_INDEX (_NL_ADDRESS_CODESET), |
274 | [__LC_TELEPHONE] = _NL_ITEM_INDEX (_NL_TELEPHONE_CODESET), |
275 | [__LC_MEASUREMENT] = _NL_ITEM_INDEX (_NL_MEASUREMENT_CODESET), |
276 | [__LC_IDENTIFICATION] = _NL_ITEM_INDEX (_NL_IDENTIFICATION_CODESET) |
277 | }; |
278 | const struct __locale_data *data; |
279 | const char *locale_codeset; |
280 | char *clocale_codeset; |
281 | char *ccodeset; |
282 | |
283 | data = (const struct __locale_data *) locale_file->data; |
284 | locale_codeset = |
285 | (const char *) data->values[codeset_idx[category]].string; |
286 | assert (locale_codeset != NULL); |
287 | /* Note the length of the allocated memory: +3 for up to two slashes |
288 | and the NUL byte. */ |
289 | clocale_codeset = (char *) alloca (strlen (locale_codeset) + 3); |
290 | strip (clocale_codeset, locale_codeset); |
291 | |
292 | ccodeset = (char *) alloca (strlen (codeset) + 3); |
293 | strip (ccodeset, codeset); |
294 | |
295 | if (__gconv_compare_alias (upstr (ccodeset, ccodeset), |
296 | upstr (clocale_codeset, |
297 | clocale_codeset)) != 0) |
298 | /* The codesets are not identical, don't use the locale. */ |
299 | return NULL; |
300 | } |
301 | |
302 | /* Determine the locale name for which loading succeeded. This |
303 | information comes from the file name. The form is |
304 | <path>/<locale>/LC_foo. We must extract the <locale> part. */ |
305 | if (((const struct __locale_data *) locale_file->data)->name == NULL) |
306 | { |
307 | char *cp, *endp; |
308 | |
309 | endp = strrchr (locale_file->filename, '/'); |
310 | cp = endp - 1; |
311 | while (cp[-1] != '/') |
312 | --cp; |
313 | ((struct __locale_data *) locale_file->data)->name |
314 | = __strndup (cp, endp - cp); |
315 | } |
316 | |
317 | /* Determine whether the user wants transliteration or not. */ |
318 | if (modifier != NULL |
319 | && __strcasecmp_l (modifier, "TRANSLIT" , _nl_C_locobj_ptr) == 0) |
320 | ((struct __locale_data *) locale_file->data)->use_translit = 1; |
321 | |
322 | /* Increment the usage count. */ |
323 | if (((const struct __locale_data *) locale_file->data)->usage_count |
324 | < MAX_USAGE_COUNT) |
325 | ++((struct __locale_data *) locale_file->data)->usage_count; |
326 | |
327 | return (struct __locale_data *) locale_file->data; |
328 | } |
329 | |
330 | |
331 | /* Calling this function assumes the lock for handling global locale data |
332 | is acquired. */ |
333 | void |
334 | _nl_remove_locale (int locale, struct __locale_data *data) |
335 | { |
336 | if (--data->usage_count == 0) |
337 | { |
338 | if (data->alloc != ld_archive) |
339 | { |
340 | /* First search the entry in the list of loaded files. */ |
341 | struct loaded_l10nfile *ptr = _nl_locale_file_list[locale]; |
342 | |
343 | /* Search for the entry. It must be in the list. Otherwise it |
344 | is a bug and we crash badly. */ |
345 | while ((struct __locale_data *) ptr->data != data) |
346 | ptr = ptr->next; |
347 | |
348 | /* Mark the data as not available anymore. So when the data has |
349 | to be used again it is reloaded. */ |
350 | ptr->decided = 0; |
351 | ptr->data = NULL; |
352 | } |
353 | |
354 | /* This does the real work. */ |
355 | _nl_unload_locale (data); |
356 | } |
357 | } |
358 | |