[thirdparty/glibc.git] / locale / newlocale.c

/* Return a reference to locale information record.
   Copyright (C) 1996-2015 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.

   The GNU C Library 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.

   The GNU C Library 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 the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <argz.h>
#include <bits/libc-lock.h>
#include <errno.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>

#include "localeinfo.h"


/* Lock for protecting global data.  */
__libc_rwlock_define (extern , __libc_setlocale_lock attribute_hidden)


/* Use this when we come along an error.  */
#define ERROR_RETURN							      \
  do {									      \
    __set_errno (EINVAL);						      \
    return NULL;							      \
  } while (0)


__locale_t
__newlocale (int category_mask, const char *locale, __locale_t base)
{
  /* Intermediate memory for result.  */
  const char *newnames[__LC_LAST];
  struct __locale_struct result;
  __locale_t result_ptr;
  char *locale_path;
  size_t locale_path_len;
  const char *locpath_var;
  int cnt;
  size_t names_len;

  /* We treat LC_ALL in the same way as if all bits were set.  */
  if (category_mask == 1 << LC_ALL)
    category_mask = (1 << __LC_LAST) - 1 - (1 << LC_ALL);

  /* Sanity check for CATEGORY argument.  */
  if ((category_mask & ~((1 << __LC_LAST) - 1 - (1 << LC_ALL))) != 0)
    ERROR_RETURN;

  /* `newlocale' does not support asking for the locale name. */
  if (locale == NULL)
    ERROR_RETURN;

  if (base == _nl_C_locobj_ptr)
    /* We're to modify BASE, returned for a previous call with "C".
       We can't really modify the read-only structure, so instead
       start over by copying it.  */
    base = NULL;

  if ((base == NULL || category_mask == (1 << __LC_LAST) - 1 - (1 << LC_ALL))
      && (category_mask == 0 || !strcmp (locale, "C")))
    /* Asking for the "C" locale needn't allocate a new object.  */
    return _nl_C_locobj_ptr;

  /* Allocate memory for the result.  */
  if (base != NULL)
    result = *base;
  else
    /* Fill with pointers to C locale data.  */
    result = _nl_C_locobj;

  /* If no category is to be set we return BASE if available or a
     dataset using the C locale data.  */
  if (category_mask == 0)
    {
      result_ptr = (__locale_t) malloc (sizeof (struct __locale_struct));
      if (result_ptr == NULL)
	return NULL;
      *result_ptr = result;

      goto update;
    }

  /* We perhaps really have to load some data.  So we determine the
     path in which to look for the data now.  The environment variable
     `LOCPATH' must only be used when the binary has no SUID or SGID
     bit set.  If using the default path, we tell _nl_find_locale
     by passing null and it can check the canonical locale archive.  */
  locale_path = NULL;
  locale_path_len = 0;

  locpath_var = getenv ("LOCPATH");
  if (locpath_var != NULL && locpath_var[0] != '\0')
    {
      if (__argz_create_sep (locpath_var, ':',
			     &locale_path, &locale_path_len) != 0)
	return NULL;

      if (__argz_add_sep (&locale_path, &locale_path_len,
			  _nl_default_locale_path, ':') != 0)
	return NULL;
    }

  /* Get the names for the locales we are interested in.  We either
     allow a composite name or a single name.  */
  for (cnt = 0; cnt < __LC_LAST; ++cnt)
    if (cnt != LC_ALL)
      newnames[cnt] = locale;
  if (strchr (locale, ';') != NULL)
    {
      /* This is a composite name.  Make a copy and split it up.  */
      char *np = strdupa (locale);
      char *cp;
      int specified_mask = 0;

      while ((cp = strchr (np, '=')) != NULL)
	{
	  for (cnt = 0; cnt < __LC_LAST; ++cnt)
	    if (cnt != LC_ALL
		&& (size_t) (cp - np) == _nl_category_name_sizes[cnt]
		&& memcmp (np, (_nl_category_names.str
				+ _nl_category_name_idxs[cnt]), cp - np) == 0)
	      break;

	  if (cnt == __LC_LAST)
	    /* Bogus category name.  */
	    ERROR_RETURN;

	  /* Found the category this clause sets.  */
	  specified_mask |= 1 << cnt;
	  newnames[cnt] = ++cp;
	  cp = strchr (cp, ';');
	  if (cp != NULL)
	    {
	      /* Examine the next clause.  */
	      *cp = '\0';
	      np = cp + 1;
	    }
	  else
	    /* This was the last clause.  We are done.  */
	    break;
	}

      if (category_mask &~ specified_mask)
	/* The composite name did not specify all categories we need.  */
	ERROR_RETURN;
    }

  /* Protect global data.  */
  __libc_rwlock_wrlock (__libc_setlocale_lock);

  /* Now process all categories we are interested in.  */
  names_len = 0;
  for (cnt = 0; cnt < __LC_LAST; ++cnt)
    {
      if ((category_mask & 1 << cnt) != 0)
	{
	  result.__locales[cnt] = _nl_find_locale (locale_path,
						   locale_path_len,
						   cnt, &newnames[cnt]);
	  if (result.__locales[cnt] == NULL)
	    {
	    free_cnt_data_and_exit:
	      while (cnt-- > 0)
		if (((category_mask & 1 << cnt) != 0)
		    && result.__locales[cnt]->usage_count != UNDELETABLE)
		  /* We can remove the data.  */
		  _nl_remove_locale (cnt, result.__locales[cnt]);

              /* Critical section left.  */
              __libc_rwlock_unlock (__libc_setlocale_lock);
	      return NULL;
	    }

	  if (newnames[cnt] != _nl_C_name)
	    names_len += strlen (newnames[cnt]) + 1;
	}
      else if (cnt != LC_ALL && result.__names[cnt] != _nl_C_name)
	/* Tally up the unchanged names from BASE as well.  */
	names_len += strlen (result.__names[cnt]) + 1;
    }

  /* We successfully loaded all required data.  Allocate a new structure.
     We can't just reuse the BASE pointer, because the name strings are
     changing and we need the old name string area intact so we can copy
     out of it into the new one without overlap problems should some
     category's name be getting longer.  */
  result_ptr = malloc (sizeof (struct __locale_struct) + names_len);
  if (result_ptr == NULL)
    {
      cnt = __LC_LAST;
      goto free_cnt_data_and_exit;
    }

  if (base == NULL)
    {
      /* Fill in this new structure from scratch.  */

      char *namep = (char *) (result_ptr + 1);

      /* Install copied new names in the new structure's __names array.
	 If resolved to "C", that is already in RESULT.__names to start.  */
      for (cnt = 0; cnt < __LC_LAST; ++cnt)
	if ((category_mask & 1 << cnt) != 0 && newnames[cnt] != _nl_C_name)
	  {
	    result.__names[cnt] = namep;
	    namep = __stpcpy (namep, newnames[cnt]) + 1;
	  }

      *result_ptr = result;
    }
  else
    {
      /* We modify the base structure.  */

      char *namep = (char *) (result_ptr + 1);

      for (cnt = 0; cnt < __LC_LAST; ++cnt)
	if ((category_mask & 1 << cnt) != 0)
	  {
	    if (base->__locales[cnt]->usage_count != UNDELETABLE)
	      /* We can remove the old data.  */
	      _nl_remove_locale (cnt, base->__locales[cnt]);
	    result_ptr->__locales[cnt] = result.__locales[cnt];

	    if (newnames[cnt] == _nl_C_name)
	      result_ptr->__names[cnt] = _nl_C_name;
	    else
	      {
		result_ptr->__names[cnt] = namep;
		namep = __stpcpy (namep, newnames[cnt]) + 1;
	      }
	  }
	else if (cnt != LC_ALL)
	  {
	    /* The RESULT members point into the old BASE structure.  */
	    result_ptr->__locales[cnt] = result.__locales[cnt];
	    if (result.__names[cnt] == _nl_C_name)
	      result_ptr->__names[cnt] = _nl_C_name;
	    else
	      {
		result_ptr->__names[cnt] = namep;
		namep = __stpcpy (namep, result.__names[cnt]) + 1;
	      }
	  }

      free (base);
    }

  /* Critical section left.  */
  __libc_rwlock_unlock (__libc_setlocale_lock);

  /* Update the special members.  */
 update:
  {
    union locale_data_value *ctypes = result_ptr->__locales[LC_CTYPE]->values;
    result_ptr->__ctype_b = (const unsigned short int *)
      ctypes[_NL_ITEM_INDEX (_NL_CTYPE_CLASS)].string + 128;
    result_ptr->__ctype_tolower = (const int *)
      ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOLOWER)].string + 128;
    result_ptr->__ctype_toupper = (const int *)
      ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOUPPER)].string + 128;
  }

  return result_ptr;
}
weak_alias (__newlocale, newlocale)
Commit	Line	Data
c84142e8	1	/* Return a reference to locale information record.
b168057a	2	Copyright (C) 1996-2015 Free Software Foundation, Inc.
c84142e8 UD	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
41bdb6e2 AJ	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.
c84142e8 UD	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
41bdb6e2	14	Lesser General Public License for more details.
c84142e8	15
41bdb6e2	16	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	17	License along with the GNU C Library; if not, see
59ba27a6 PE	18	<http://www.gnu.org/licenses/>. */
c84142e8 UD	19
c84142e8 UD	20	#include <argz.h>
531b71dd	21	#include <bits/libc-lock.h>
c84142e8 UD	22	#include <errno.h>
	23	#include <locale.h>
	24	#include <stdlib.h>
26e40124	25	#include <string.h>
c84142e8 UD	26
	27	#include "localeinfo.h"
	28
	29
531b71dd	30	/* Lock for protecting global data. */
9a69db29	31	__libc_rwlock_define (extern , __libc_setlocale_lock attribute_hidden)
531b71dd UD	32
531b71dd UD	33
c84142e8 UD	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
	42	__locale_t
	43	__newlocale (int category_mask, const char *locale, __locale_t base)
	44	{
	45	/* Intermediate memory for result. */
4b10dd6c	46	const char *newnames[__LC_LAST];
4cca6b86	47	struct __locale_struct result;
c84142e8 UD	48	__locale_t result_ptr;
	49	char *locale_path;
	50	size_t locale_path_len;
	51	const char *locpath_var;
	52	int cnt;
a0fc81e1	53	size_t names_len;
c84142e8 UD	54
c84142e8 UD	55	/* We treat LC_ALL in the same way as if all bits were set. */
f7719a9a	56	if (category_mask == 1 << LC_ALL)
4b10dd6c	57	category_mask = (1 << __LC_LAST) - 1 - (1 << LC_ALL);
c84142e8 UD	58
c84142e8 UD	59	/* Sanity check for CATEGORY argument. */
5bef2820	60	if ((category_mask & ~((1 << __LC_LAST) - 1 - (1 << LC_ALL))) != 0)
c84142e8 UD	61	ERROR_RETURN;
	62
	63	/* `newlocale' does not support asking for the locale name. */
	64	if (locale == NULL)
	65	ERROR_RETURN;
	66
4b5b009c	67	if (base == _nl_C_locobj_ptr)
679e4c43 RM	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. */
4b5b009c	76	return _nl_C_locobj_ptr;
679e4c43	77
c84142e8 UD	78	/* Allocate memory for the result. */
c84142e8 UD	79	if (base != NULL)
5bef2820	80	result = *base;
c84142e8	81	else
30c14c31 RM	82	/* Fill with pointers to C locale data. */
30c14c31 RM	83	result = _nl_C_locobj;
c84142e8	84
5bef2820 UD	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;
c84142e8	93
5bef2820	94	goto update;
c84142e8 UD	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
cb09a2cd RM	100	bit set. If using the default path, we tell _nl_find_locale
cb09a2cd RM	101	by passing null and it can check the canonical locale archive. */
c84142e8 UD	102	locale_path = NULL;
	103	locale_path_len = 0;
	104
74955460	105	locpath_var = getenv ("LOCPATH");
c84142e8	106	if (locpath_var != NULL && locpath_var[0] != '\0')
cb09a2cd RM	107	{
	108	if (__argz_create_sep (locpath_var, ':',
	109	&locale_path, &locale_path_len) != 0)
	110	return NULL;
c84142e8	111
cb09a2cd RM	112	if (__argz_add_sep (&locale_path, &locale_path_len,
	113	_nl_default_locale_path, ':') != 0)
	114	return NULL;
	115	}
c84142e8 UD	116
	117	/* Get the names for the locales we are interested in. We either
	118	allow a composite name or a single name. */
4b10dd6c UD	119	for (cnt = 0; cnt < __LC_LAST; ++cnt)
	120	if (cnt != LC_ALL)
	121	newnames[cnt] = locale;
c84142e8 UD	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;
78323b5b	127	int specified_mask = 0;
c84142e8 UD	128
	129	while ((cp = strchr (np, '=')) != NULL)
	130	{
4b10dd6c UD	131	for (cnt = 0; cnt < __LC_LAST; ++cnt)
	132	if (cnt != LC_ALL
	133	&& (size_t) (cp - np) == _nl_category_name_sizes[cnt]
9446614c UD	134	&& memcmp (np, (_nl_category_names.str
9446614c UD	135	+ _nl_category_name_idxs[cnt]), cp - np) == 0)
c84142e8 UD	136	break;
c84142e8 UD	137
4b10dd6c	138	if (cnt == __LC_LAST)
c84142e8 UD	139	/* Bogus category name. */
	140	ERROR_RETURN;
	141
	142	/* Found the category this clause sets. */
78323b5b	143	specified_mask \|= 1 << cnt;
c84142e8 UD	144	newnames[cnt] = ++cp;
	145	cp = strchr (cp, ';');
	146	if (cp != NULL)
	147	{
	148	/* Examine the next clause. */
	149	*cp = '\0';
	150	np = cp + 1;
	151	}
	152	else
	153	/* This was the last clause. We are done. */
	154	break;
	155	}
	156
78323b5b RM	157	if (category_mask &~ specified_mask)
	158	/* The composite name did not specify all categories we need. */
	159	ERROR_RETURN;
c84142e8 UD	160	}
c84142e8 UD	161
531b71dd	162	/* Protect global data. */
9a69db29	163	__libc_rwlock_wrlock (__libc_setlocale_lock);
531b71dd	164
c84142e8	165	/* Now process all categories we are interested in. */
a0fc81e1	166	names_len = 0;
4b10dd6c	167	for (cnt = 0; cnt < __LC_LAST; ++cnt)
a0fc81e1 RM	168	{
	169	if ((category_mask & 1 << cnt) != 0)
	170	{
	171	result.__locales[cnt] = _nl_find_locale (locale_path,
	172	locale_path_len,
	173	cnt, &newnames[cnt]);
	174	if (result.__locales[cnt] == NULL)
	175	{
	176	free_cnt_data_and_exit:
	177	while (cnt-- > 0)
	178	if (((category_mask & 1 << cnt) != 0)
	179	&& result.__locales[cnt]->usage_count != UNDELETABLE)
	180	/* We can remove the data. */
	181	_nl_remove_locale (cnt, result.__locales[cnt]);
531b71dd UD	182
531b71dd UD	183	/* Critical section left. */
9a69db29	184	__libc_rwlock_unlock (__libc_setlocale_lock);
a0fc81e1 RM	185	return NULL;
	186	}
	187
	188	if (newnames[cnt] != _nl_C_name)
	189	names_len += strlen (newnames[cnt]) + 1;
	190	}
	191	else if (cnt != LC_ALL && result.__names[cnt] != _nl_C_name)
	192	/* Tally up the unchanged names from BASE as well. */
	193	names_len += strlen (result.__names[cnt]) + 1;
	194	}
	195
	196	/* We successfully loaded all required data. Allocate a new structure.
	197	We can't just reuse the BASE pointer, because the name strings are
	198	changing and we need the old name string area intact so we can copy
	199	out of it into the new one without overlap problems should some
	200	category's name be getting longer. */
	201	result_ptr = malloc (sizeof (struct __locale_struct) + names_len);
	202	if (result_ptr == NULL)
	203	{
	204	cnt = __LC_LAST;
	205	goto free_cnt_data_and_exit;
	206	}
c84142e8	207
c84142e8 UD	208	if (base == NULL)
c84142e8 UD	209	{
a0fc81e1 RM	210	/* Fill in this new structure from scratch. */
	211
	212	char namep = (char ) (result_ptr + 1);
c84142e8	213
a0fc81e1	214	/* Install copied new names in the new structure's __names array.
252e7983	215	If resolved to "C", that is already in RESULT.__names to start. */
26e40124	216	for (cnt = 0; cnt < __LC_LAST; ++cnt)
252e7983	217	if ((category_mask & 1 << cnt) != 0 && newnames[cnt] != _nl_C_name)
26e40124	218	{
a0fc81e1 RM	219	result.__names[cnt] = namep;
a0fc81e1 RM	220	namep = __stpcpy (namep, newnames[cnt]) + 1;
26e40124	221	}
252e7983 RM	222
252e7983 RM	223	*result_ptr = result;
c84142e8 UD	224	}
c84142e8 UD	225	else
26e40124	226	{
a0fc81e1	227	/* We modify the base structure. */
26e40124	228
a0fc81e1	229	char namep = (char ) (result_ptr + 1);
26e40124	230
26e40124	231	for (cnt = 0; cnt < __LC_LAST; ++cnt)
252e7983	232	if ((category_mask & 1 << cnt) != 0)
26e40124	233	{
252e7983 RM	234	if (base->__locales[cnt]->usage_count != UNDELETABLE)
	235	/* We can remove the old data. */
	236	_nl_remove_locale (cnt, base->__locales[cnt]);
a0fc81e1	237	result_ptr->__locales[cnt] = result.__locales[cnt];
252e7983	238
a0fc81e1 RM	239	if (newnames[cnt] == _nl_C_name)
	240	result_ptr->__names[cnt] = _nl_C_name;
	241	else
	242	{
	243	result_ptr->__names[cnt] = namep;
	244	namep = __stpcpy (namep, newnames[cnt]) + 1;
	245	}
	246	}
	247	else if (cnt != LC_ALL)
	248	{
	249	/* The RESULT members point into the old BASE structure. */
	250	result_ptr->__locales[cnt] = result.__locales[cnt];
	251	if (result.__names[cnt] == _nl_C_name)
	252	result_ptr->__names[cnt] = _nl_C_name;
	253	else
	254	{
	255	result_ptr->__names[cnt] = namep;
	256	namep = __stpcpy (namep, result.__names[cnt]) + 1;
	257	}
26e40124 RM	258	}
26e40124 RM	259
a0fc81e1	260	free (base);
26e40124	261	}
5db91571	262
531b71dd	263	/* Critical section left. */
9a69db29	264	__libc_rwlock_unlock (__libc_setlocale_lock);
531b71dd	265
c84142e8 UD	266	/* Update the special members. */
	267	update:
	268	{
	269	union locale_data_value *ctypes = result_ptr->__locales[LC_CTYPE]->values;
5bef2820	270	result_ptr->__ctype_b = (const unsigned short int *)
671ab00d	271	ctypes[_NL_ITEM_INDEX (_NL_CTYPE_CLASS)].string + 128;
5bef2820	272	result_ptr->__ctype_tolower = (const int *)
671ab00d	273	ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOLOWER)].string + 128;
5bef2820	274	result_ptr->__ctype_toupper = (const int *)
671ab00d	275	ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOUPPER)].string + 128;
c84142e8 UD	276	}
	277
	278	return result_ptr;
	279	}
30c14c31	280	weak_alias (__newlocale, newlocale)