lib/libc/locale/xlocale.c

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