1 /*-
2 * Copyright (c) 2011 The FreeBSD Foundation
3 * All rights reserved.
4 *
5 * This software was developed by David Chisnall under sponsorship from
6 * the FreeBSD Foundation.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $FreeBSD: head/lib/libc/locale/xlocale.c 303495 2016-07-29 17:18:47Z ed $
30 */
31
32 #include "namespace.h"
33 #include <errno.h>
34 #include <pthread.h>
35 #include <stdio.h>
36 #include <string.h>
37 #include <runetype.h>
38 #include "libc_private.h"
39 #include "xlocale_private.h"
40 #include "un-namespace.h"
41
42 /**
43 * Each locale loader declares a global component. This is used by setlocale()
44 * and also by xlocale with LC_GLOBAL_LOCALE..
45 */
46 extern struct xlocale_component __xlocale_global_collate;
47 extern struct xlocale_component __xlocale_global_ctype;
48 extern struct xlocale_component __xlocale_global_monetary;
49 extern struct xlocale_component __xlocale_global_numeric;
50 extern struct xlocale_component __xlocale_global_time;
51 extern struct xlocale_component __xlocale_global_messages;
52 /*
53 * And another version for the statically-allocated C locale. We only have
54 * components for the parts that are expected to be sensible.
55 */
56 extern struct xlocale_component __xlocale_C_collate;
57 extern struct xlocale_component __xlocale_C_ctype;
58
59 /*
60 * The locale for this thread.
61 */
62 __thread locale_t __thread_locale;
63 /*
64 * Flag indicating that one or more per-thread locales exist.
65 */
66 int __has_thread_locale;
67 /*
68 * Private functions in setlocale.c.
69 */
70 const char * __get_locale_env(int category);
71 int __get_locale_str(int category, const char *str, char * const res);
72 int __detect_path_locale(void);
73
74 struct _xlocale __xlocale_global_locale = {
75 .header = {0},
76 .components = {
77 &__xlocale_global_collate,
78 &__xlocale_global_ctype,
79 &__xlocale_global_monetary,
80 &__xlocale_global_numeric,
81 &__xlocale_global_time,
82 &__xlocale_global_messages
83 },
84 .monetary_locale_changed = 1,
85 .using_monetary_locale = 0,
86 .numeric_locale_changed = 1,
87 .using_numeric_locale = 0
88 };
89
90 struct _xlocale __xlocale_C_locale = {
91 .header = {0},
92 .components = {
93 &__xlocale_C_collate,
94 &__xlocale_C_ctype,
95 0, 0, 0, 0
96 },
97 .monetary_locale_changed = 1,
98 .using_monetary_locale = 0,
99 .numeric_locale_changed = 1,
100 .using_numeric_locale = 0
101 };
102
103 static void*(*constructors[])(const char*, locale_t) =
104 {
105 __collate_load,
106 __ctype_load,
107 __monetary_load,
108 __numeric_load,
109 __time_load,
110 __messages_load
111 };
112
113 static pthread_key_t locale_info_key;
114 static int fake_tls;
115 static locale_t thread_local_locale;
116
init_key(void)117 static void init_key(void)
118 {
119
120 _pthread_key_create(&locale_info_key, xlocale_release);
121 _pthread_setspecific(locale_info_key, (void*)42);
122 if (_pthread_getspecific(locale_info_key) == (void*)42) {
123 _pthread_setspecific(locale_info_key, 0);
124 } else {
125 fake_tls = 1;
126 }
127 /* At least one per-thread locale has now been set. */
128 __has_thread_locale = 1;
129 __detect_path_locale();
130 }
131
132 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
133
134 static locale_t
get_thread_locale(void)135 get_thread_locale(void)
136 {
137
138 _once(&once_control, init_key);
139
140 return (fake_tls ? thread_local_locale :
141 _pthread_getspecific(locale_info_key));
142 }
143
144 static void
set_thread_locale(locale_t loc)145 set_thread_locale(locale_t loc)
146 {
147 locale_t l = (loc == LC_GLOBAL_LOCALE) ? 0 : loc;
148
149 _once(&once_control, init_key);
150
151 if (NULL != l) {
152 xlocale_retain((struct xlocale_refcounted*)l);
153 }
154 locale_t old = _pthread_getspecific(locale_info_key);
155 if ((NULL != old) && (l != old)) {
156 xlocale_release((struct xlocale_refcounted*)old);
157 }
158 if (fake_tls) {
159 thread_local_locale = l;
160 } else {
161 _pthread_setspecific(locale_info_key, l);
162 }
163 __thread_locale = l;
164 __set_thread_rune_locale(loc);
165 }
166
167 /**
168 * Clean up a locale, once its reference count reaches zero. This function is
169 * called by xlocale_release(), it should not be called directly.
170 */
171 static void
destruct_locale(void * l)172 destruct_locale(void *l)
173 {
174 locale_t loc = l;
175
176 for (int type=0 ; type<XLC_LAST ; type++) {
177 if (loc->components[type]) {
178 xlocale_release(loc->components[type]);
179 }
180 }
181 if (loc->csym) {
182 free(loc->csym);
183 }
184 free(l);
185 }
186
187 /**
188 * Allocates a new, uninitialised, locale.
189 */
190 static locale_t
alloc_locale(void)191 alloc_locale(void)
192 {
193 locale_t new = calloc(sizeof(struct _xlocale), 1);
194
195 new->header.destructor = destruct_locale;
196 new->monetary_locale_changed = 1;
197 new->numeric_locale_changed = 1;
198 return (new);
199 }
200 static void
copyflags(locale_t new,locale_t old)201 copyflags(locale_t new, locale_t old)
202 {
203 new->using_monetary_locale = old->using_monetary_locale;
204 new->using_numeric_locale = old->using_numeric_locale;
205 new->using_time_locale = old->using_time_locale;
206 new->using_messages_locale = old->using_messages_locale;
207 }
208
dupcomponent(int type,locale_t base,locale_t new)209 static int dupcomponent(int type, locale_t base, locale_t new)
210 {
211 /* Always copy from the global locale, since it has mutable components.
212 */
213 struct xlocale_component *src = base->components[type];
214
215 if (&__xlocale_global_locale == base) {
216 new->components[type] = constructors[type](src->locale, new);
217 if (new->components[type]) {
218 strncpy(new->components[type]->locale, src->locale,
219 ENCODING_LEN);
220 }
221 } else if (base->components[type]) {
222 new->components[type] = xlocale_retain(base->components[type]);
223 } else {
224 /* If the component was NULL, return success - if base is a
225 * valid locale then the flag indicating that this isn't
226 * present should be set. If it isn't a valid locale, then
227 * we're stuck anyway. */
228 return 1;
229 }
230 return (0 != new->components[type]);
231 }
232
233 /*
234 * Public interfaces. These are the five public functions described by the
235 * xlocale interface.
236 */
237
newlocale(int mask,const char * locale,locale_t base)238 locale_t newlocale(int mask, const char *locale, locale_t base)
239 {
240 int type;
241 const char *realLocale = locale;
242 const char *np, *cp;
243 char lres[ENCODING_LEN + 1] = "";
244 int len;
245 int useenv = 0;
246 int useslh = 0;
247 int usestr = 0;
248 int success = 1;
249
250 _once(&once_control, init_key);
251
252 locale_t new = alloc_locale();
253 if (NULL == new) {
254 return (NULL);
255 }
256
257 FIX_LOCALE(base);
258 copyflags(new, base);
259
260 if (NULL == locale) {
261 realLocale = "C";
262 } else if ('\0' == locale[0]) {
263 useenv = 1;
264 } else if (strchr(locale, '/') != NULL) {
265 /*
266 * Handle system native locale string
267 * e.g. "C/en_US.UTF-8/C/C/lt_LT/C"
268 */
269 useslh = 1;
270 np = locale;
271 } else if ('L' == locale[0] && strchr(locale, ';') != NULL) {
272 /*
273 * We are called from c++ runtime lib with LC_*; string??
274 */
275 usestr = 1;
276 }
277
278 for (type=0 ; type<XLC_LAST ; type++) {
279 if (useslh) {
280 cp = strchr(np, '/');
281 if (cp == NULL && type == XLC_LAST - 1) {
282 cp = locale + strlen(locale);
283 } else if (cp == NULL || type == XLC_LAST - 1) {
284 errno = EINVAL;
285 success = 0;
286 break;
287 }
288 len = cp - np;
289 if (len > ENCODING_LEN || len <= 0) {
290 errno = EINVAL;
291 success = 0;
292 break;
293 }
294 strncpy(lres, np, len);
295 lres[len] = '\0';
296 np = cp + 1;
297 }
298
299 if (mask & 1) {
300 if (useenv) {
301 realLocale = __get_locale_env(type + 1);
302 } else if (useslh) {
303 realLocale = lres;
304 } else if (usestr) {
305 __get_locale_str(type + 1, locale, lres);
306 realLocale = lres;
307 }
308 new->components[type] =
309 constructors[type](realLocale, new);
310 if (new->components[type]) {
311 strncpy(new->components[type]->locale,
312 realLocale, ENCODING_LEN);
313 } else {
314 success = 0;
315 break;
316 }
317 } else {
318 if (!dupcomponent(type, base, new)) {
319 success = 0;
320 break;
321 }
322 }
323 mask >>= 1;
324 }
325 if (0 == success) {
326 xlocale_release(new);
327 new = NULL;
328 }
329
330 return (new);
331 }
332
duplocale(locale_t base)333 locale_t duplocale(locale_t base)
334 {
335 locale_t new = alloc_locale();
336 int type;
337
338 _once(&once_control, init_key);
339
340 if (NULL == new) {
341 return (NULL);
342 }
343
344 FIX_LOCALE(base);
345 copyflags(new, base);
346
347 for (type=0 ; type<XLC_LAST ; type++) {
348 dupcomponent(type, base, new);
349 }
350
351 return (new);
352 }
353
354 /*
355 * Free a locale_t. This is quite a poorly named function. It actually
356 * disclaims a reference to a locale_t, rather than freeing it.
357 */
358 void
freelocale(locale_t loc)359 freelocale(locale_t loc)
360 {
361
362 /*
363 * Fail if we're passed something that isn't a locale. If we're
364 * passed the global locale, pretend that we freed it but don't
365 * actually do anything.
366 */
367 if (loc != NULL && loc != LC_GLOBAL_LOCALE &&
368 loc != &__xlocale_global_locale)
369 xlocale_release(loc);
370 }
371
372 /*
373 * Returns the name of the locale for a particular component of a locale_t.
374 */
querylocale(int mask,locale_t loc)375 const char *querylocale(int mask, locale_t loc)
376 {
377 int type = ffs(mask) - 1;
378 FIX_LOCALE(loc);
379 if (type >= XLC_LAST)
380 return (NULL);
381 if (loc->components[type])
382 return (loc->components[type]->locale);
383 return ("C");
384 }
385
386 /*
387 * Installs the specified locale_t as this thread's locale.
388 */
uselocale(locale_t loc)389 locale_t uselocale(locale_t loc)
390 {
391 locale_t old = get_thread_locale();
392 if (NULL != loc) {
393 set_thread_locale(loc);
394 }
395 return (old ? old : LC_GLOBAL_LOCALE);
396 }
397
398