nsz Git - musl/blob - src/locale/__setlocalecat.c

   1 #include <locale.h>
   2 #include <string.h>
   3 #include "locale_impl.h"
   4 #include "libc.h"
   5 #include "atomic.h"
   6
   7 const unsigned char *__map_file(const char *, size_t *);
   8 int __munmap(void *, size_t);
   9 char *__strchrnul(const char *, int);
  10
  11 static struct __locale_map *findlocale(const char *name, size_t n)
  12 {
  13         static void *loc_head;
  14         struct __locale_map *p, *new, *old_head;
  15         const char *path = 0, *z;
  16         char buf[256];
  17         size_t l;
  18         const void *map;
  19         size_t map_size;
  20
  21         for (p=loc_head; p; p=p->next)
  22                 if (!strcmp(name, p->name)) return p;
  23
  24         if (strchr(name, '/')) return 0;
  25
  26         if (!libc.secure) path = getenv("MUSL_LOCPATH");
  27         /* FIXME: add a default path? */
  28         if (!path) return 0;
  29
  30         for (; *path; path=z+!!*z) {
  31                 z = __strchrnul(path, ':');
  32                 l = z - path - !!*z;
  33                 if (l >= sizeof buf - n - 2) continue;
  34                 memcpy(buf, path, l);
  35                 buf[l] = '/';
  36                 memcpy(buf+l+1, name, n);
  37                 buf[l+1+n] = 0;
  38                 map = __map_file(buf, &map_size);
  39                 if (map) {
  40                         new = malloc(sizeof *new);
  41                         if (!new) {
  42                                 __munmap((void *)map, map_size);
  43                                 return 0;
  44                         }
  45                         new->map = map;
  46                         new->map_size = map_size;
  47                         memcpy(new->name, name, n);
  48                         new->name[n] = 0;
  49                         do {
  50                                 old_head = loc_head;
  51                                 new->next = old_head;
  52                         } while (a_cas_p(&loc_head, old_head, new) != old_head);
  53                         return new;
  54                 }
  55         }
  56         return 0;
  57 }
  58
  59 static const char envvars[][12] = {
  60         "LC_CTYPE",
  61         "LC_NUMERIC",
  62         "LC_TIME",
  63         "LC_COLLATE",
  64         "LC_MONETARY",
  65         "LC_MESSAGES",
  66 };
  67
  68 int __setlocalecat(locale_t loc, int cat, const char *val)
  69 {
  70         if (!*val) {
  71                 (val = getenv("LC_ALL")) && *val ||
  72                 (val = getenv(envvars[cat])) && *val ||
  73                 (val = getenv("LANG")) && *val ||
  74                 (val = "C.UTF-8");
  75         }
  76
  77         size_t n = strnlen(val, LOCALE_NAME_MAX);
  78         int builtin = (val[0]=='C' && !val[1])
  79                 || !strcmp(val, "C.UTF-8")
  80                 || !strcmp(val, "POSIX");
  81         struct __locale_map *data, *old;
  82
  83         switch (cat) {
  84         case LC_CTYPE:
  85                 a_store(&loc->ctype_utf8, !builtin || val[1]=='.');
  86                 break;
  87         case LC_MESSAGES:
  88                 if (builtin) {
  89                         loc->messages_name[0] = 0;
  90                 } else {
  91                         memcpy(loc->messages_name, val, n);
  92                         loc->messages_name[n] = 0;
  93                 }
  94                 /* fall through */
  95         default:
  96                 data = builtin ? 0 : findlocale(val, n);
  97                 if (data == loc->cat[cat-2]) break;
  98                 do old = loc->cat[cat-2];
  99                 while (a_cas_p(&loc->cat[cat-2], old, data) != old);
 100         case LC_NUMERIC:
 101                 break;
 102         }
 103         return 0;
 104 }