1/* Return a reference to locale information record.
2 Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#include <argz.h>
21#include <libc-lock.h>
22#include <errno.h>
23#include <locale.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include "localeinfo.h"
28
29
30/* Lock for protecting global data. */
31__libc_rwlock_define (extern , __libc_setlocale_lock attribute_hidden)
32
33
34/* Use this when we come along an error. */
35#define ERROR_RETURN \
36 do { \
37 __set_errno (EINVAL); \
38 return NULL; \
39 } while (0)
40
41
42locale_t
43__newlocale (int category_mask, const char *locale, locale_t base)
44{
45 /* Intermediate memory for result. */
46 const char *newnames[__LC_LAST];
47 struct __locale_struct result;
48 locale_t result_ptr;
49 char *locale_path;
50 size_t locale_path_len;
51 const char *locpath_var;
52 int cnt;
53 size_t names_len;
54
55 /* We treat LC_ALL in the same way as if all bits were set. */
56 if (category_mask == 1 << LC_ALL)
57 category_mask = (1 << __LC_LAST) - 1 - (1 << LC_ALL);
58
59 /* Sanity check for CATEGORY argument. */
60 if ((category_mask & ~((1 << __LC_LAST) - 1 - (1 << LC_ALL))) != 0)
61 ERROR_RETURN;
62
63 /* `newlocale' does not support asking for the locale name. */
64 if (locale == NULL)
65 ERROR_RETURN;
66
67 if (base == _nl_C_locobj_ptr)
68 /* We're to modify BASE, returned for a previous call with "C".
69 We can't really modify the read-only structure, so instead
70 start over by copying it. */
71 base = NULL;
72
73 if ((base == NULL || category_mask == (1 << __LC_LAST) - 1 - (1 << LC_ALL))
74 && (category_mask == 0 || !strcmp (locale, "C")))
75 /* Asking for the "C" locale needn't allocate a new object. */
76 return _nl_C_locobj_ptr;
77
78 /* Allocate memory for the result. */
79 if (base != NULL)
80 result = *base;
81 else
82 /* Fill with pointers to C locale data. */
83 result = _nl_C_locobj;
84
85 /* If no category is to be set we return BASE if available or a
86 dataset using the C locale data. */
87 if (category_mask == 0)
88 {
89 result_ptr = (locale_t) malloc (sizeof (struct __locale_struct));
90 if (result_ptr == NULL)
91 return NULL;
92 *result_ptr = result;
93
94 goto update;
95 }
96
97 /* We perhaps really have to load some data. So we determine the
98 path in which to look for the data now. The environment variable
99 `LOCPATH' must only be used when the binary has no SUID or SGID
100 bit set. If using the default path, we tell _nl_find_locale
101 by passing null and it can check the canonical locale archive. */
102 locale_path = NULL;
103 locale_path_len = 0;
104
105 locpath_var = getenv ("LOCPATH");
106 if (locpath_var != NULL && locpath_var[0] != '\0')
107 {
108 if (__argz_create_sep (locpath_var, ':',
109 &locale_path, &locale_path_len) != 0)
110 return NULL;
111
112 if (__argz_add_sep (&locale_path, &locale_path_len,
113 _nl_default_locale_path, ':') != 0)
114 return NULL;
115 }
116
117 /* Get the names for the locales we are interested in. We either
118 allow a composite name or a single name. */
119 for (cnt = 0; cnt < __LC_LAST; ++cnt)
120 if (cnt != LC_ALL)
121 newnames[cnt] = locale;
122 if (strchr (locale, ';') != NULL)
123 {
124 /* This is a composite name. Make a copy and split it up. */
125 char *np = strdupa (locale);
126 char *cp;
127 int specified_mask = 0;
128
129 while ((cp = strchr (np, '=')) != NULL)
130 {
131 for (cnt = 0; cnt < __LC_LAST; ++cnt)
132 if (cnt != LC_ALL
133 && (size_t) (cp - np) == _nl_category_name_sizes[cnt]
134 && memcmp (np, (_nl_category_names_get (cnt)), cp - np) == 0)
135 break;
136
137 if (cnt == __LC_LAST)
138 /* Bogus category name. */
139 ERROR_RETURN;
140
141 /* Found the category this clause sets. */
142 specified_mask |= 1 << cnt;
143 newnames[cnt] = ++cp;
144 cp = strchr (cp, ';');
145 if (cp != NULL)
146 {
147 /* Examine the next clause. */
148 *cp = '\0';
149 np = cp + 1;
150 }
151 else
152 /* This was the last clause. We are done. */
153 break;
154 }
155
156 if (category_mask &~ specified_mask)
157 /* The composite name did not specify all categories we need. */
158 ERROR_RETURN;
159 }
160
161 /* Protect global data. */
162 __libc_rwlock_wrlock (__libc_setlocale_lock);
163
164 /* Now process all categories we are interested in. */
165 names_len = 0;
166 for (cnt = 0; cnt < __LC_LAST; ++cnt)
167 {
168 if ((category_mask & 1 << cnt) != 0)
169 {
170 result.__locales[cnt] = _nl_find_locale (locale_path,
171 locale_path_len,
172 cnt, &newnames[cnt]);
173 if (result.__locales[cnt] == NULL)
174 {
175 free_cnt_data_and_exit:
176 while (cnt-- > 0)
177 if (((category_mask & 1 << cnt) != 0)
178 && result.__locales[cnt]->usage_count != UNDELETABLE)
179 /* We can remove the data. */
180 _nl_remove_locale (cnt, result.__locales[cnt]);
181
182 /* Critical section left. */
183 __libc_rwlock_unlock (__libc_setlocale_lock);
184 return NULL;
185 }
186
187 if (newnames[cnt] != _nl_C_name)
188 names_len += strlen (newnames[cnt]) + 1;
189 }
190 else if (cnt != LC_ALL && result.__names[cnt] != _nl_C_name)
191 /* Tally up the unchanged names from BASE as well. */
192 names_len += strlen (result.__names[cnt]) + 1;
193 }
194
195 /* We successfully loaded all required data. Allocate a new structure.
196 We can't just reuse the BASE pointer, because the name strings are
197 changing and we need the old name string area intact so we can copy
198 out of it into the new one without overlap problems should some
199 category's name be getting longer. */
200 result_ptr = malloc (sizeof (struct __locale_struct) + names_len);
201 if (result_ptr == NULL)
202 {
203 cnt = __LC_LAST;
204 goto free_cnt_data_and_exit;
205 }
206
207 if (base == NULL)
208 {
209 /* Fill in this new structure from scratch. */
210
211 char *namep = (char *) (result_ptr + 1);
212
213 /* Install copied new names in the new structure's __names array.
214 If resolved to "C", that is already in RESULT.__names to start. */
215 for (cnt = 0; cnt < __LC_LAST; ++cnt)
216 if ((category_mask & 1 << cnt) != 0 && newnames[cnt] != _nl_C_name)
217 {
218 result.__names[cnt] = namep;
219 namep = __stpcpy (namep, newnames[cnt]) + 1;
220 }
221
222 *result_ptr = result;
223 }
224 else
225 {
226 /* We modify the base structure. */
227
228 char *namep = (char *) (result_ptr + 1);
229
230 for (cnt = 0; cnt < __LC_LAST; ++cnt)
231 if ((category_mask & 1 << cnt) != 0)
232 {
233 if (base->__locales[cnt]->usage_count != UNDELETABLE)
234 /* We can remove the old data. */
235 _nl_remove_locale (cnt, base->__locales[cnt]);
236 result_ptr->__locales[cnt] = result.__locales[cnt];
237
238 if (newnames[cnt] == _nl_C_name)
239 result_ptr->__names[cnt] = _nl_C_name;
240 else
241 {
242 result_ptr->__names[cnt] = namep;
243 namep = __stpcpy (namep, newnames[cnt]) + 1;
244 }
245 }
246 else if (cnt != LC_ALL)
247 {
248 /* The RESULT members point into the old BASE structure. */
249 result_ptr->__locales[cnt] = result.__locales[cnt];
250 if (result.__names[cnt] == _nl_C_name)
251 result_ptr->__names[cnt] = _nl_C_name;
252 else
253 {
254 result_ptr->__names[cnt] = namep;
255 namep = __stpcpy (namep, result.__names[cnt]) + 1;
256 }
257 }
258
259 free (base);
260 }
261
262 /* Critical section left. */
263 __libc_rwlock_unlock (__libc_setlocale_lock);
264
265 /* Update the special members. */
266 update:
267 {
268 union locale_data_value *ctypes = result_ptr->__locales[LC_CTYPE]->values;
269 result_ptr->__ctype_b = (const unsigned short int *)
270 ctypes[_NL_ITEM_INDEX (_NL_CTYPE_CLASS)].string + 128;
271 result_ptr->__ctype_tolower = (const int *)
272 ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOLOWER)].string + 128;
273 result_ptr->__ctype_toupper = (const int *)
274 ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOUPPER)].string + 128;
275 }
276
277 return result_ptr;
278}
279weak_alias (__newlocale, newlocale)
280