New upstream version 1.4.1upstream/1.4.1upstream

1 files changed, 695 insertions, 0 deletions

diff --git a/lib/getlocalename_l-unsafe.c b/lib/getlocalename_l-unsafe.c
new file mode 100644
index 00000000..e2738829
--- /dev/null
+++ b/lib/getlocalename_l-unsafe.c
@@ -0,0 +1,695 @@
+/* Return name of a single locale category.
+   Copyright (C) 1995-2025 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Don't use __attribute__ __nonnull__ in this compilation unit.  Otherwise gcc
+   optimizes away the locale == NULL tests below.  */
+#define _GL_ARG_NONNULL(params)
+
+#include <config.h>
+
+/* Specification.  */
+#include "getlocalename_l-unsafe.h"
+
+#include <locale.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if LC_MESSAGES == 1729 || defined __ANDROID__
+# include "setlocale-fixes.h"
+#endif
+#include "setlocale_null.h"
+
+#if (__GLIBC__ >= 2 && !defined __UCLIBC__) || (defined __linux__ && HAVE_LANGINFO_H) || defined __CYGWIN__
+# include <langinfo.h>
+#endif
+#if defined __sun
+# if HAVE_SOLARIS114_LOCALES
+#  include <sys/localedef.h>
+# endif
+#endif
+#if HAVE_NAMELESS_LOCALES
+# include "localename-table.h"
+#endif
+#if defined __HAIKU__
+# include <dlfcn.h>
+#endif
+
+
+#if LOCALENAME_ENHANCE_LOCALE_FUNCS
+
+# include "flexmember.h"
+# include "glthread/lock.h"
+# include "thread-optim.h"
+
+/* Define a local struniq() function.  */
+# include "struniq.h"
+
+/* The 'locale_t' object does not contain the names of the locale categories.
+   We have to associate them with the object through a hash table.
+   The hash table is defined in localename-table.[hc].  */
+
+/* Returns the name of a given locale category in a given locale_t object.  */
+static struct string_with_storage
+get_locale_t_name_unsafe (int category, locale_t locale)
+{
+  if (category == LC_ALL)
+    /* Invalid argument.  */
+    abort ();
+  if (locale == LC_GLOBAL_LOCALE)
+    {
+      /* Query the global locale.  */
+      const char *name = setlocale_null (category);
+      if (name != NULL)
+        return (struct string_with_storage) { name, STORAGE_GLOBAL };
+      else
+        /* Should normally not happen.  */
+        return (struct string_with_storage) { "", STORAGE_INDEFINITE };
+    }
+  else
+    {
+# if HAVE_AIX72_LOCALES
+      if (category == LC_MESSAGES)
+        {
+          const char *name = ((__locale_t) locale)->locale_name;
+          if (name != NULL)
+            return (struct string_with_storage) { name, STORAGE_OBJECT };
+        }
+# endif
+      /* Look up the names in the hash table.  */
+      size_t hashcode = locale_hash_function (locale);
+      size_t slot = hashcode % LOCALE_HASH_TABLE_SIZE;
+      /* If the locale was not found in the table, return "".  This can
+         happen if the application uses the original newlocale()/duplocale()
+         functions instead of the overridden ones.  */
+      const char *name = "";
+      struct locale_hash_node *p;
+      /* Lock while looking up the hash node.  */
+      gl_rwlock_rdlock (locale_lock);
+      for (p = locale_hash_table[slot]; p != NULL; p = p->next)
+        if (p->locale == locale)
+          {
+            name = p->names.category_name[category - LCMIN];
+            break;
+          }
+      gl_rwlock_unlock (locale_lock);
+      return (struct string_with_storage) { name, STORAGE_INDEFINITE };
+    }
+}
+
+/* Returns the name of a given locale category in a given locale_t object,
+   allocated as a string with indefinite extent.  */
+static const char *
+get_locale_t_name (int category, locale_t locale)
+{
+  struct string_with_storage ret = get_locale_t_name_unsafe (category, locale);
+  return (ret.storage != STORAGE_INDEFINITE
+          ? struniq (ret.value)
+          : ret.value);
+}
+
+# if !(defined newlocale && defined duplocale && defined freelocale)
+#  error "newlocale, duplocale, freelocale not being replaced as expected!"
+# endif
+
+/* newlocale() override.  */
+locale_t
+newlocale (int category_mask, const char *name, locale_t base)
+#undef newlocale
+{
+  struct locale_categories_names names;
+  struct locale_hash_node *node;
+  locale_t result;
+
+  /* Make sure name has indefinite extent.  */
+  if (((LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK
+        | LC_MONETARY_MASK | LC_MESSAGES_MASK)
+       & category_mask) != 0)
+    name = struniq (name);
+
+  /* Determine the category names of the result.  */
+  if (((LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK
+        | LC_MONETARY_MASK | LC_MESSAGES_MASK)
+       & ~category_mask) == 0)
+    {
+      /* Use name, ignore base.  */
+      int i;
+
+      name = struniq (name);
+      for (i = 0; i < 6; i++)
+        names.category_name[i] = name;
+    }
+  else
+    {
+      /* Use base, possibly also name.  */
+      if (base == NULL)
+        {
+          int i;
+
+          for (i = 0; i < 6; i++)
+            {
+              int category = i + LCMIN;
+              int mask;
+
+              switch (category)
+                {
+                case LC_CTYPE:
+                  mask = LC_CTYPE_MASK;
+                  break;
+                case LC_NUMERIC:
+                  mask = LC_NUMERIC_MASK;
+                  break;
+                case LC_TIME:
+                  mask = LC_TIME_MASK;
+                  break;
+                case LC_COLLATE:
+                  mask = LC_COLLATE_MASK;
+                  break;
+                case LC_MONETARY:
+                  mask = LC_MONETARY_MASK;
+                  break;
+                case LC_MESSAGES:
+                  mask = LC_MESSAGES_MASK;
+                  break;
+                default:
+                  abort ();
+                }
+              names.category_name[i] =
+                ((mask & category_mask) != 0 ? name : "C");
+            }
+        }
+      else if (base == LC_GLOBAL_LOCALE)
+        {
+          int i;
+
+          for (i = 0; i < 6; i++)
+            {
+              int category = i + LCMIN;
+              int mask;
+
+              switch (category)
+                {
+                case LC_CTYPE:
+                  mask = LC_CTYPE_MASK;
+                  break;
+                case LC_NUMERIC:
+                  mask = LC_NUMERIC_MASK;
+                  break;
+                case LC_TIME:
+                  mask = LC_TIME_MASK;
+                  break;
+                case LC_COLLATE:
+                  mask = LC_COLLATE_MASK;
+                  break;
+                case LC_MONETARY:
+                  mask = LC_MONETARY_MASK;
+                  break;
+                case LC_MESSAGES:
+                  mask = LC_MESSAGES_MASK;
+                  break;
+                default:
+                  abort ();
+                }
+              names.category_name[i] =
+                ((mask & category_mask) != 0
+                 ? name
+                 : get_locale_t_name (category, LC_GLOBAL_LOCALE));
+            }
+        }
+      else
+        {
+          /* Look up the names of base in the hash table.  Like multiple calls
+             of get_locale_t_name, but locking only once.  */
+          struct locale_hash_node *p;
+
+          /* Lock while looking up the hash node.  */
+          gl_rwlock_rdlock (locale_lock);
+          for (p = locale_hash_table[locale_hash_function (base) % LOCALE_HASH_TABLE_SIZE];
+               p != NULL;
+               p = p->next)
+            if (p->locale == base)
+              break;
+
+          int i;
+          for (i = 0; i < 6; i++)
+            {
+              int category = i + LCMIN;
+              int mask;
+
+              switch (category)
+                {
+                case LC_CTYPE:
+                  mask = LC_CTYPE_MASK;
+                  break;
+                case LC_NUMERIC:
+                  mask = LC_NUMERIC_MASK;
+                  break;
+                case LC_TIME:
+                  mask = LC_TIME_MASK;
+                  break;
+                case LC_COLLATE:
+                  mask = LC_COLLATE_MASK;
+                  break;
+                case LC_MONETARY:
+                  mask = LC_MONETARY_MASK;
+                  break;
+                case LC_MESSAGES:
+                  mask = LC_MESSAGES_MASK;
+                  break;
+                default:
+                  abort ();
+                }
+              names.category_name[i] =
+                ((mask & category_mask) != 0
+                 ? name
+                 : (p != NULL ? p->names.category_name[i] : ""));
+            }
+
+          gl_rwlock_unlock (locale_lock);
+        }
+    }
+
+  node = (struct locale_hash_node *) malloc (sizeof (struct locale_hash_node));
+  if (node == NULL)
+    /* errno is set to ENOMEM.  */
+    return NULL;
+
+  result = newlocale (category_mask, name, base);
+  if (result == NULL)
+    {
+      free (node);
+      return NULL;
+    }
+
+  /* Fill the hash node.  */
+  node->locale = result;
+  node->names = names;
+
+  /* Insert it in the hash table.  */
+  {
+    size_t hashcode = locale_hash_function (result);
+    size_t slot = hashcode % LOCALE_HASH_TABLE_SIZE;
+    struct locale_hash_node *p;
+
+    /* Lock while inserting the new node.  */
+    gl_rwlock_wrlock (locale_lock);
+    for (p = locale_hash_table[slot]; p != NULL; p = p->next)
+      if (p->locale == result)
+        {
+          /* This can happen if the application uses the original freelocale()
+             function instead of the overridden one.  */
+          p->names = node->names;
+          break;
+        }
+    if (p == NULL)
+      {
+        node->next = locale_hash_table[slot];
+        locale_hash_table[slot] = node;
+      }
+
+    gl_rwlock_unlock (locale_lock);
+
+    if (p != NULL)
+      free (node);
+  }
+
+  return result;
+}
+
+/* duplocale() override.  */
+locale_t
+duplocale (locale_t locale)
+#undef duplocale
+{
+  struct locale_hash_node *node;
+  locale_t result;
+
+  if (locale == NULL)
+    /* Invalid argument.  */
+    abort ();
+
+  node = (struct locale_hash_node *) malloc (sizeof (struct locale_hash_node));
+  if (node == NULL)
+    /* errno is set to ENOMEM.  */
+    return NULL;
+
+  result = duplocale (locale);
+  if (result == NULL)
+    {
+      free (node);
+      return NULL;
+    }
+
+  /* Fill the hash node.  */
+  node->locale = result;
+  if (locale == LC_GLOBAL_LOCALE)
+    {
+      int i;
+
+      for (i = 0; i < 6; i++)
+        {
+          int category = i + LCMIN;
+          node->names.category_name[i] =
+            get_locale_t_name (category, LC_GLOBAL_LOCALE);
+        }
+
+      /* Lock before inserting the new node.  */
+      gl_rwlock_wrlock (locale_lock);
+    }
+  else
+    {
+      struct locale_hash_node *p;
+
+      /* Lock once, for the lookup and the insertion.  */
+      gl_rwlock_wrlock (locale_lock);
+
+      for (p = locale_hash_table[locale_hash_function (locale) % LOCALE_HASH_TABLE_SIZE];
+           p != NULL;
+           p = p->next)
+        if (p->locale == locale)
+          break;
+      if (p != NULL)
+        node->names = p->names;
+      else
+        {
+          /* This can happen if the application uses the original
+             newlocale()/duplocale() functions instead of the overridden
+             ones.  */
+          int i;
+
+          for (i = 0; i < 6; i++)
+            node->names.category_name[i] = "";
+        }
+    }
+
+  /* Insert it in the hash table.  */
+  {
+    size_t hashcode = locale_hash_function (result);
+    size_t slot = hashcode % LOCALE_HASH_TABLE_SIZE;
+    struct locale_hash_node *p;
+
+    for (p = locale_hash_table[slot]; p != NULL; p = p->next)
+      if (p->locale == result)
+        {
+          /* This can happen if the application uses the original freelocale()
+             function instead of the overridden one.  */
+          p->names = node->names;
+          break;
+        }
+    if (p == NULL)
+      {
+        node->next = locale_hash_table[slot];
+        locale_hash_table[slot] = node;
+      }
+
+    gl_rwlock_unlock (locale_lock);
+
+    if (p != NULL)
+      free (node);
+  }
+
+  return result;
+}
+
+/* freelocale() override.  */
+void
+freelocale (locale_t locale)
+#undef freelocale
+{
+  if (locale == NULL || locale == LC_GLOBAL_LOCALE)
+    /* Invalid argument.  */
+    abort ();
+
+  {
+    size_t hashcode = locale_hash_function (locale);
+    size_t slot = hashcode % LOCALE_HASH_TABLE_SIZE;
+    struct locale_hash_node *found;
+    struct locale_hash_node **p;
+
+    found = NULL;
+    /* Lock while removing the hash node.  */
+    gl_rwlock_wrlock (locale_lock);
+    for (p = &locale_hash_table[slot]; *p != NULL; p = &(*p)->next)
+      if ((*p)->locale == locale)
+        {
+          found = *p;
+          *p = (*p)->next;
+          break;
+        }
+    gl_rwlock_unlock (locale_lock);
+    free (found);
+  }
+
+  freelocale (locale);
+}
+
+#endif
+
+
+struct string_with_storage
+getlocalename_l_unsafe (int category, locale_t locale)
+{
+  if (category == LC_ALL)
+    /* Unsupported in this simple implementation.  */
+    abort ();
+
+  if (locale != LC_GLOBAL_LOCALE)
+    {
+#if GNULIB_defined_locale_t
+      struct gl_locale_category_t *plc =
+        &locale->category[gl_log2_lcmask_to_index (gl_log2_lc_mask (category))];
+      return (struct string_with_storage) { plc->name, STORAGE_OBJECT };
+#elif __GLIBC__ >= 2 && !defined __UCLIBC__
+      /* Work around an incorrect definition of the _NL_LOCALE_NAME macro in
+         glibc < 2.12.
+         See <https://sourceware.org/PR10968>.  */
+      const char *name =
+        nl_langinfo_l (_NL_ITEM ((category), _NL_ITEM_INDEX (-1)), locale);
+      if (name[0] == '\0')
+        /* Fallback code for glibc < 2.4, which did not implement
+           nl_langinfo_l (_NL_LOCALE_NAME (category), locale).  */
+        name = locale->__names[category];
+      return (struct string_with_storage) { name, STORAGE_OBJECT };
+#elif defined __linux__ && HAVE_LANGINFO_H && defined NL_LOCALE_NAME
+      /* musl libc */
+      const char *name = nl_langinfo_l (NL_LOCALE_NAME (category), locale);
+      return (struct string_with_storage) { name, STORAGE_OBJECT };
+#elif (defined __FreeBSD__ || defined __DragonFly__) || (defined __APPLE__ && defined __MACH__)
+      /* FreeBSD >= 9.1, Mac OS X */
+      int mask;
+
+      switch (category)
+        {
+        case LC_CTYPE:
+          mask = LC_CTYPE_MASK;
+          break;
+        case LC_NUMERIC:
+          mask = LC_NUMERIC_MASK;
+          break;
+        case LC_TIME:
+          mask = LC_TIME_MASK;
+          break;
+        case LC_COLLATE:
+          mask = LC_COLLATE_MASK;
+          break;
+        case LC_MONETARY:
+          mask = LC_MONETARY_MASK;
+          break;
+        case LC_MESSAGES:
+          mask = LC_MESSAGES_MASK;
+          break;
+        default: /* We shouldn't get here.  */
+          return (struct string_with_storage) { "", STORAGE_INDEFINITE };
+        }
+      const char *name = querylocale (mask, locale);
+      return (struct string_with_storage) { name, STORAGE_OBJECT };
+#elif defined __NetBSD__
+      /* NetBSD >= 7.0 */
+      #define _LOCALENAME_LEN_MAX 33
+      struct _locale {
+        void *cache;
+        char query[_LOCALENAME_LEN_MAX * 6];
+        const char *part_name[7];
+      };
+      const char *name = ((struct _locale *) locale)->part_name[category];
+      return (struct string_with_storage) { name, STORAGE_OBJECT };
+#elif defined __sun
+# if HAVE_SOLARIS114_LOCALES
+      /* Solaris >= 11.4.  */
+      void *lcp = (*locale)->core.data->lcp;
+      if (lcp != NULL)
+        switch (category)
+          {
+          case LC_CTYPE:
+          case LC_NUMERIC:
+          case LC_TIME:
+          case LC_COLLATE:
+          case LC_MONETARY:
+          case LC_MESSAGES:
+            {
+              const char *name = ((const char * const *) lcp)[category];
+              return (struct string_with_storage) { name, STORAGE_OBJECT };
+            }
+          default: /* We shouldn't get here.  */
+            return (struct string_with_storage) { "", STORAGE_INDEFINITE };
+          }
+      /* We shouldn't get here.  */
+      return (struct string_with_storage) { "", STORAGE_INDEFINITE };
+# else
+      /* Solaris 11 OpenIndiana or Solaris 11 OmniOS.  */
+#  if HAVE_GETLOCALENAME_L
+      /* illumos after April 2025.  */
+#   undef getlocalename_l
+      const char *name = getlocalename_l (category, locale);
+      return (struct string_with_storage) { name, STORAGE_OBJECT };
+#  else
+      /* For the internal structure of locale objects, see
+         https://github.com/OpenIndiana/illumos-gate/blob/master/usr/src/lib/libc/port/locale/localeimpl.h  */
+      switch (category)
+        {
+        case LC_CTYPE:
+        case LC_NUMERIC:
+        case LC_TIME:
+        case LC_COLLATE:
+        case LC_MONETARY:
+        case LC_MESSAGES:
+          {
+            const char *name = ((const char * const *) locale)[category];
+            return (struct string_with_storage) { name, STORAGE_OBJECT };
+          }
+        default: /* We shouldn't get here.  */
+          return (struct string_with_storage) { "", STORAGE_INDEFINITE };
+        }
+#  endif
+# endif
+#elif HAVE_NAMELESS_LOCALES
+      /* OpenBSD >= 6.2, AIX >= 7.1 */
+      return get_locale_t_name_unsafe (category, locale);
+#elif defined __OpenBSD__ && HAVE_FAKE_LOCALES
+      /* OpenBSD >= 6.2 has only fake locales.  */
+      if (locale == (locale_t) 2)
+        return (struct string_with_storage) { "C.UTF-8", STORAGE_INDEFINITE };
+      return (struct string_with_storage) { "C", STORAGE_INDEFINITE };
+#elif defined __CYGWIN__
+      /* Cygwin >= 2.6.
+         Cygwin <= 2.6.1 lacks NL_LOCALE_NAME, requiring peeking inside
+         an opaque struct.  */
+# ifdef NL_LOCALE_NAME
+      const char *name = nl_langinfo_l (NL_LOCALE_NAME (category), locale);
+# else
+      /* FIXME: Remove when we can assume new-enough Cygwin.  */
+      struct __locale_t {
+        char categories[7][32];
+      };
+      const char *name = ((struct __locale_t *) locale)->categories[category];
+# endif
+      return (struct string_with_storage) { name, STORAGE_OBJECT };
+#elif defined __HAIKU__
+      /* Since 2022, Haiku has per-thread locales.  locale_t is 'void *',
+         but in fact a 'LocaleBackendData *'.  */
+      struct LocaleBackendData {
+        int magic;
+        void /*BPrivate::Libroot::LocaleBackend*/ *backend;
+        void /*BPrivate::Libroot::LocaleDataBridge*/ *databridge;
+      };
+      void *locale_backend =
+        ((struct LocaleBackendData *) locale)->backend;
+      if (locale_backend != NULL)
+        {
+          /* The only existing concrete subclass of
+             BPrivate::Libroot::LocaleBackend is
+             BPrivate::Libroot::ICULocaleBackend.
+             Invoke the (non-virtual) method
+             BPrivate::Libroot::ICULocaleBackend::_QueryLocale on it.
+             This method is located in a separate shared library,
+             libroot-addon-icu.so.  */
+          static void * volatile querylocale_method /* = NULL */;
+          static int volatile querylocale_found /* = 0 */;
+          /* Attempt to open this shared library, the first time we get
+             here.  */
+          if (querylocale_found == 0)
+            {
+              void *handle =
+                dlopen ("/boot/system/lib/libroot-addon-icu.so", 0);
+              if (handle != NULL)
+                {
+                  void *sym =
+                    dlsym (handle, "_ZN8BPrivate7Libroot16ICULocaleBackend12_QueryLocaleEi");
+                  if (sym != NULL)
+                    {
+                      querylocale_method = sym;
+                      querylocale_found = 1;
+                    }
+                  else
+                    /* Could not find the symbol.  */
+                    querylocale_found = -1;
+                }
+              else
+                /* Could not open the separate shared library.  */
+                querylocale_found = -1;
+            }
+          if (querylocale_found > 0)
+            {
+              /* The _QueryLocale method is a non-static C++ method with
+                 parameters (int category) and return type 'const char *'.
+                 See
+                   haiku/headers/private/libroot/locale/ICULocaleBackend.h
+                   haiku/src/system/libroot/add-ons/icu/ICULocaleBackend.cpp
+                 This is the same as a C function with parameters
+                   (BPrivate::Libroot::LocaleBackend* this, int category)
+                 and return type 'const char *'.  Invoke it.  */
+              const char * (*querylocale_func) (void *, int) =
+                (const char * (*) (void *, int)) querylocale_method;
+              const char *name = querylocale_func (locale_backend, category);
+              return (struct string_with_storage) { name, STORAGE_OBJECT };
+            }
+        }
+      else
+        /* It's the "C" or "POSIX" locale.  */
+        return (struct string_with_storage) { "C", STORAGE_INDEFINITE };
+#elif defined __ANDROID__
+      /* Android API level >= 21 */
+      struct __locale_t {
+        size_t mb_cur_max;
+      };
+      const char *name = ((struct __locale_t *) locale)->mb_cur_max == 4 ? "C.UTF-8" : "C";
+      return (struct string_with_storage) { name, STORAGE_INDEFINITE };
+#else
+ #error "Please port gnulib getlocalename_l-unsafe.c to your platform! Report this to bug-gnulib."
+#endif
+    }
+  else
+    {
+      /* Query the global locale.  */
+      const char *name;
+#if LC_MESSAGES == 1729
+      if (category == LC_MESSAGES)
+        name = setlocale_messages_null ();
+      else
+#endif
+#if defined __ANDROID__
+        name = setlocale_fixed_null (category);
+#else
+        name = setlocale_null (category);
+#endif
+      if (name != NULL)
+        return (struct string_with_storage) { name, STORAGE_GLOBAL };
+      else
+        /* Should normally not happen.  */
+        return (struct string_with_storage) { "", STORAGE_INDEFINITE };
+    }
+}