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

/* Functions to read locale data files.
   Copyright (C) 1996-2016 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 <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#ifdef _POSIX_MAPPED_FILES
# include <sys/mman.h>
#endif
#include <sys/stat.h>

#include <not-cancel.h>
#include "localeinfo.h"


static const size_t _nl_category_num_items[] =
{
#define DEFINE_CATEGORY(category, category_name, items, a) \
  [category] = _NL_ITEM_INDEX (_NL_NUM_##category),
#include "categories.def"
#undef	DEFINE_CATEGORY
};


#define NO_PAREN(arg, rest...) arg, ##rest

#define DEFINE_CATEGORY(category, category_name, items, a) \
static const enum value_type _nl_value_type_##category[] = { NO_PAREN items };
#define DEFINE_ELEMENT(element, element_name, optstd, type, rest...) \
  [_NL_ITEM_INDEX (element)] = type,
#include "categories.def"
#undef DEFINE_CATEGORY

static const enum value_type *const _nl_value_types[] =
{
#define DEFINE_CATEGORY(category, category_name, items, a) \
  [category] = _nl_value_type_##category,
#include "categories.def"
#undef DEFINE_CATEGORY
};


struct __locale_data *
internal_function
_nl_intern_locale_data (int category, const void *data, size_t datasize)
{
  const struct
    {
      unsigned int magic;
      unsigned int nstrings;
      unsigned int strindex[0];
    } *const filedata = data;
  struct __locale_data *newdata;
  size_t cnt;

  if (__builtin_expect (datasize < sizeof *filedata, 0)
      || __builtin_expect (filedata->magic != LIMAGIC (category), 0))
    {
      /* Bad data file.  */
      __set_errno (EINVAL);
      return NULL;
    }

  if (__builtin_expect (filedata->nstrings < _nl_category_num_items[category],
			0)
      || (__builtin_expect (sizeof *filedata
			    + filedata->nstrings * sizeof (unsigned int)
			    >= datasize, 0)))
    {
      /* Insufficient data.  */
      __set_errno (EINVAL);
      return NULL;
    }

  newdata = malloc (sizeof *newdata
		    + filedata->nstrings * sizeof (union locale_data_value));
  if (newdata == NULL)
    return NULL;

  newdata->filedata = (void *) filedata;
  newdata->filesize = datasize;
  newdata->private.data = NULL;
  newdata->private.cleanup = NULL;
  newdata->usage_count = 0;
  newdata->use_translit = 0;
  newdata->nstrings = filedata->nstrings;
  for (cnt = 0; cnt < newdata->nstrings; ++cnt)
    {
      size_t idx = filedata->strindex[cnt];
      if (__glibc_unlikely (idx > (size_t) newdata->filesize))
	{
	puntdata:
	  free (newdata);
	  __set_errno (EINVAL);
	  return NULL;
	}

      /* Determine the type.  There is one special case: the LC_CTYPE
	 category can have more elements than there are in the
	 _nl_value_type_LC_XYZ array.  There are all pointers.  */
      switch (category)
	{
#define CATTEST(cat) \
	case LC_##cat:						\
	  if (cnt >= (sizeof (_nl_value_type_LC_##cat)		\
		      / sizeof (_nl_value_type_LC_##cat[0])))	\
	    goto puntdata;					\
	  break
	  CATTEST (NUMERIC);
	  CATTEST (TIME);
	  CATTEST (COLLATE);
	  CATTEST (MONETARY);
	  CATTEST (MESSAGES);
	  CATTEST (PAPER);
	  CATTEST (NAME);
	  CATTEST (ADDRESS);
	  CATTEST (TELEPHONE);
	  CATTEST (MEASUREMENT);
	  CATTEST (IDENTIFICATION);
	default:
	  assert (category == LC_CTYPE);
	  break;
	}

      if ((category == LC_CTYPE
	   && cnt >= (sizeof (_nl_value_type_LC_CTYPE)
		      / sizeof (_nl_value_type_LC_CTYPE[0])))
	  || __builtin_expect (_nl_value_types[category][cnt] != word, 1))
	newdata->values[cnt].string = newdata->filedata + idx;
      else
	{
	  if (!LOCFILE_ALIGNED_P (idx))
	    goto puntdata;
	  newdata->values[cnt].word =
	    *((const u_int32_t *) (newdata->filedata + idx));
	}
    }

  return newdata;
}

void
internal_function
_nl_load_locale (struct loaded_l10nfile *file, int category)
{
  int fd;
  void *filedata;
  struct stat64 st;
  struct __locale_data *newdata;
  int save_err;
  int alloc = ld_mapped;

  file->decided = 1;
  file->data = NULL;

  fd = open_not_cancel_2 (file->filename, O_RDONLY | O_CLOEXEC);
  if (__builtin_expect (fd, 0) < 0)
    /* Cannot open the file.  */
    return;

  if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
    {
    puntfd:
      close_not_cancel_no_status (fd);
      return;
    }
  if (__glibc_unlikely (S_ISDIR (st.st_mode)))
    {
      /* LOCALE/LC_foo is a directory; open LOCALE/LC_foo/SYS_LC_foo
	   instead.  */
      char *newp;
      size_t filenamelen;

      close_not_cancel_no_status (fd);

      filenamelen = strlen (file->filename);
      newp = (char *) alloca (filenamelen
			      + 5 + _nl_category_name_sizes[category] + 1);
      __mempcpy (__mempcpy (__mempcpy (newp, file->filename, filenamelen),
			    "/SYS_", 5),
		 _nl_category_names.str + _nl_category_name_idxs[category],
		 _nl_category_name_sizes[category] + 1);

      fd = open_not_cancel_2 (newp, O_RDONLY | O_CLOEXEC);
      if (__builtin_expect (fd, 0) < 0)
	return;

      if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
	goto puntfd;
    }

  /* Map in the file's data.  */
  save_err = errno;
#ifdef _POSIX_MAPPED_FILES
# ifndef MAP_COPY
  /* Linux seems to lack read-only copy-on-write.  */
#  define MAP_COPY MAP_PRIVATE
# endif
# ifndef MAP_FILE
  /* Some systems do not have this flag; it is superfluous.  */
#  define MAP_FILE 0
# endif
  filedata = __mmap ((caddr_t) 0, st.st_size,
		     PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
  if (__glibc_unlikely (filedata == MAP_FAILED))
    {
      filedata = NULL;
      if (__builtin_expect (errno, ENOSYS) == ENOSYS)
	{
#endif	/* _POSIX_MAPPED_FILES */
	  /* No mmap; allocate a buffer and read from the file.  */
	  alloc = ld_malloced;
	  filedata = malloc (st.st_size);
	  if (filedata != NULL)
	    {
	      off_t to_read = st.st_size;
	      ssize_t nread;
	      char *p = (char *) filedata;
	      while (to_read > 0)
		{
		  nread = read_not_cancel (fd, p, to_read);
		  if (__builtin_expect (nread, 1) <= 0)
		    {
		      free (filedata);
		      if (nread == 0)
			__set_errno (EINVAL); /* Bizarreness going on.  */
		      goto puntfd;
		    }
		  p += nread;
		  to_read -= nread;
		}
	      __set_errno (save_err);
	    }
#ifdef _POSIX_MAPPED_FILES
	}
    }
#endif	/* _POSIX_MAPPED_FILES */

  /* We have mapped the data, so we no longer need the descriptor.  */
  close_not_cancel_no_status (fd);

  if (__glibc_unlikely (filedata == NULL))
    /* We failed to map or read the data.  */
    return;

  newdata = _nl_intern_locale_data (category, filedata, st.st_size);
  if (__glibc_unlikely (newdata == NULL))
    /* Bad data.  */
    {
#ifdef _POSIX_MAPPED_FILES
      if (alloc == ld_mapped)
	__munmap ((caddr_t) filedata, st.st_size);
#endif
      return;
    }

  /* _nl_intern_locale_data leaves us these fields to initialize.  */
  newdata->name = NULL;	/* This will be filled if necessary in findlocale.c. */
  newdata->alloc = alloc;

  file->data = newdata;
}

void
internal_function
_nl_unload_locale (struct __locale_data *locale)
{
  if (locale->private.cleanup)
    (*locale->private.cleanup) (locale);

  switch (__builtin_expect (locale->alloc, ld_mapped))
    {
    case ld_malloced:
      free ((void *) locale->filedata);
      break;
    case ld_mapped:
#ifdef _POSIX_MAPPED_FILES
      __munmap ((caddr_t) locale->filedata, locale->filesize);
      break;
#endif
    case ld_archive:		/* Nothing to do.  */
      break;
    }

  if (__builtin_expect (locale->alloc, ld_mapped) != ld_archive)
    free ((char *) locale->name);

  free (locale);
}
Commit	Line	Data
ce4d8b66	1	/* Functions to read locale data files.
f7a9f785	2	Copyright (C) 1996-2016 Free Software Foundation, Inc.
c84142e8	3	This file is part of the GNU C Library.
4b10dd6c	4	Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
933e73fa	5
c84142e8	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.
933e73fa	10
c84142e8 UD	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.
933e73fa	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/>. */
933e73fa	19
e43e0dd6	20	#include <assert.h>
933e73fa RM	21	#include <errno.h>
933e73fa RM	22	#include <fcntl.h>
3e154a6f	23	#include <locale.h>
933e73fa RM	24	#include <stdlib.h>
933e73fa RM	25	#include <string.h>
7a12c6bb	26	#include <unistd.h>
b6aa34eb UD	27	#ifdef _POSIX_MAPPED_FILES
	28	# include <sys/mman.h>
	29	#endif
7a12c6bb RM	30	#include <sys/stat.h>
7a12c6bb RM	31
72ef277e	32	#include <not-cancel.h>
933e73fa RM	33	#include "localeinfo.h"
933e73fa RM	34
7a12c6bb RM	35
7a12c6bb RM	36	static const size_t _nl_category_num_items[] =
19bc17a9	37	{
4b10dd6c	38	#define DEFINE_CATEGORY(category, category_name, items, a) \
19bc17a9	39	[category] = _NL_ITEM_INDEX (_NL_NUM_##category),
933e73fa RM	40	#include "categories.def"
933e73fa RM	41	#undef DEFINE_CATEGORY
19bc17a9 RM	42	};
	43
	44
	45	#define NO_PAREN(arg, rest...) arg, ##rest
	46
4b10dd6c	47	#define DEFINE_CATEGORY(category, category_name, items, a) \
19bc17a9 RM	48	static const enum value_type _nl_value_type_##category[] = { NO_PAREN items };
	49	#define DEFINE_ELEMENT(element, element_name, optstd, type, rest...) \
	50	[_NL_ITEM_INDEX (element)] = type,
	51	#include "categories.def"
	52	#undef DEFINE_CATEGORY
	53
aa87e915	54	static const enum value_type *const _nl_value_types[] =
19bc17a9	55	{
4b10dd6c	56	#define DEFINE_CATEGORY(category, category_name, items, a) \
19bc17a9 RM	57	[category] = _nl_value_type_##category,
	58	#include "categories.def"
	59	#undef DEFINE_CATEGORY
	60	};
	61
933e73fa	62
f095bb72	63	struct __locale_data *
cb09a2cd RM	64	internal_function
cb09a2cd RM	65	_nl_intern_locale_data (int category, const void *data, size_t datasize)
933e73fa	66	{
cb09a2cd	67	const struct
933e73fa RM	68	{
	69	unsigned int magic;
	70	unsigned int nstrings;
	71	unsigned int strindex[0];
cb09a2cd	72	} *const filedata = data;
f095bb72	73	struct __locale_data *newdata;
cb09a2cd RM	74	size_t cnt;
	75
	76	if (__builtin_expect (datasize < sizeof *filedata, 0)
	77	\|\| __builtin_expect (filedata->magic != LIMAGIC (category), 0))
	78	{
	79	/* Bad data file. */
	80	__set_errno (EINVAL);
	81	return NULL;
	82	}
	83
	84	if (__builtin_expect (filedata->nstrings < _nl_category_num_items[category],
	85	0)
	86	\|\| (__builtin_expect (sizeof *filedata
	87	+ filedata->nstrings * sizeof (unsigned int)
	88	>= datasize, 0)))
	89	{
	90	/* Insufficient data. */
	91	__set_errno (EINVAL);
	92	return NULL;
	93	}
	94
	95	newdata = malloc (sizeof *newdata
	96	+ filedata->nstrings * sizeof (union locale_data_value));
	97	if (newdata == NULL)
	98	return NULL;
	99
	100	newdata->filedata = (void *) filedata;
	101	newdata->filesize = datasize;
df9f41c9 RM	102	newdata->private.data = NULL;
df9f41c9 RM	103	newdata->private.cleanup = NULL;
cb09a2cd RM	104	newdata->usage_count = 0;
	105	newdata->use_translit = 0;
	106	newdata->nstrings = filedata->nstrings;
	107	for (cnt = 0; cnt < newdata->nstrings; ++cnt)
	108	{
	109	size_t idx = filedata->strindex[cnt];
a1ffb40e	110	if (__glibc_unlikely (idx > (size_t) newdata->filesize))
cb09a2cd RM	111	{
	112	puntdata:
	113	free (newdata);
	114	__set_errno (EINVAL);
	115	return NULL;
	116	}
fe6ce170 UD	117
	118	/* Determine the type. There is one special case: the LC_CTYPE
	119	category can have more elements than there are in the
	120	_nl_value_type_LC_XYZ array. There are all pointers. */
	121	switch (category)
	122	{
	123	#define CATTEST(cat) \
0062ace2 LC	124	case LC_##cat: \
	125	if (cnt >= (sizeof (_nl_value_type_LC_##cat) \
	126	/ sizeof (_nl_value_type_LC_##cat[0]))) \
	127	goto puntdata; \
fe6ce170 UD	128	break
	129	CATTEST (NUMERIC);
	130	CATTEST (TIME);
	131	CATTEST (COLLATE);
	132	CATTEST (MONETARY);
	133	CATTEST (MESSAGES);
	134	CATTEST (PAPER);
	135	CATTEST (NAME);
	136	CATTEST (ADDRESS);
	137	CATTEST (TELEPHONE);
	138	CATTEST (MEASUREMENT);
	139	CATTEST (IDENTIFICATION);
	140	default:
	141	assert (category == LC_CTYPE);
	142	break;
	143	}
	144
	145	if ((category == LC_CTYPE
	146	&& cnt >= (sizeof (_nl_value_type_LC_CTYPE)
	147	/ sizeof (_nl_value_type_LC_CTYPE[0])))
	148	\|\| __builtin_expect (_nl_value_types[category][cnt] != word, 1))
	149	newdata->values[cnt].string = newdata->filedata + idx;
	150	else
cb09a2cd	151	{
7602d070	152	if (!LOCFILE_ALIGNED_P (idx))
cb09a2cd RM	153	goto puntdata;
	154	newdata->values[cnt].word =
	155	((const u_int32_t ) (newdata->filedata + idx));
	156	}
cb09a2cd RM	157	}
	158
	159	return newdata;
	160	}
	161
	162	void
	163	internal_function
	164	_nl_load_locale (struct loaded_l10nfile *file, int category)
	165	{
	166	int fd;
	167	void *filedata;
8edf6e0d	168	struct stat64 st;
f095bb72	169	struct __locale_data *newdata;
7a12c6bb	170	int save_err;
cb09a2cd	171	int alloc = ld_mapped;
933e73fa	172
7a12c6bb RM	173	file->decided = 1;
	174	file->data = NULL;
	175
d62a8200	176	fd = open_not_cancel_2 (file->filename, O_RDONLY \| O_CLOEXEC);
3a31f6f4	177	if (__builtin_expect (fd, 0) < 0)
7a12c6bb RM	178	/* Cannot open the file. */
	179	return;
	180
8edf6e0d	181	if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
cb09a2cd RM	182	{
cb09a2cd RM	183	puntfd:
72ef277e	184	close_not_cancel_no_status (fd);
cb09a2cd RM	185	return;
cb09a2cd RM	186	}
a1ffb40e	187	if (__glibc_unlikely (S_ISDIR (st.st_mode)))
933e73fa	188	{
7a12c6bb	189	/* LOCALE/LC_foo is a directory; open LOCALE/LC_foo/SYS_LC_foo
f095bb72	190	instead. */
7a12c6bb	191	char *newp;
b6aa34eb	192	size_t filenamelen;
036cc82f	193
72ef277e	194	close_not_cancel_no_status (fd);
7a12c6bb	195
b6aa34eb UD	196	filenamelen = strlen (file->filename);
b6aa34eb UD	197	newp = (char *) alloca (filenamelen
7a12c6bb	198	+ 5 + _nl_category_name_sizes[category] + 1);
b6aa34eb UD	199	__mempcpy (__mempcpy (__mempcpy (newp, file->filename, filenamelen),
b6aa34eb UD	200	"/SYS_", 5),
9446614c	201	_nl_category_names.str + _nl_category_name_idxs[category],
b6aa34eb	202	_nl_category_name_sizes[category] + 1);
7a12c6bb	203
d62a8200	204	fd = open_not_cancel_2 (newp, O_RDONLY \| O_CLOEXEC);
3a31f6f4	205	if (__builtin_expect (fd, 0) < 0)
7a12c6bb RM	206	return;
7a12c6bb RM	207
8edf6e0d	208	if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
7a12c6bb	209	goto puntfd;
933e73fa RM	210	}
933e73fa RM	211
7a12c6bb RM	212	/* Map in the file's data. */
7a12c6bb RM	213	save_err = errno;
b6aa34eb UD	214	#ifdef _POSIX_MAPPED_FILES
b6aa34eb UD	215	# ifndef MAP_COPY
7a12c6bb	216	/* Linux seems to lack read-only copy-on-write. */
b6aa34eb UD	217	# define MAP_COPY MAP_PRIVATE
	218	# endif
	219	# ifndef MAP_FILE
7a12c6bb	220	/* Some systems do not have this flag; it is superfluous. */
b6aa34eb UD	221	# define MAP_FILE 0
b6aa34eb UD	222	# endif
cb09a2cd RM	223	filedata = __mmap ((caddr_t) 0, st.st_size,
cb09a2cd RM	224	PROT_READ, MAP_FILE\|MAP_COPY, fd, 0);
a1ffb40e	225	if (__glibc_unlikely (filedata == MAP_FAILED))
7a12c6bb	226	{
8b2f25c2	227	filedata = NULL;
3a31f6f4	228	if (__builtin_expect (errno, ENOSYS) == ENOSYS)
7a12c6bb	229	{
b6aa34eb	230	#endif /* _POSIX_MAPPED_FILES */
7a12c6bb	231	/* No mmap; allocate a buffer and read from the file. */
cb09a2cd	232	alloc = ld_malloced;
7a12c6bb RM	233	filedata = malloc (st.st_size);
	234	if (filedata != NULL)
	235	{
	236	off_t to_read = st.st_size;
	237	ssize_t nread;
	238	char p = (char ) filedata;
	239	while (to_read > 0)
	240	{
72ef277e	241	nread = read_not_cancel (fd, p, to_read);
3a31f6f4	242	if (__builtin_expect (nread, 1) <= 0)
7a12c6bb RM	243	{
	244	free (filedata);
	245	if (nread == 0)
c4029823	246	__set_errno (EINVAL); /* Bizarreness going on. */
7a12c6bb RM	247	goto puntfd;
	248	}
	249	p += nread;
	250	to_read -= nread;
	251	}
cb09a2cd	252	__set_errno (save_err);
7a12c6bb	253	}
b6aa34eb	254	#ifdef _POSIX_MAPPED_FILES
7a12c6bb	255	}
7a12c6bb	256	}
b6aa34eb	257	#endif /* _POSIX_MAPPED_FILES */
933e73fa	258
cb09a2cd	259	/* We have mapped the data, so we no longer need the descriptor. */
72ef277e	260	close_not_cancel_no_status (fd);
cb09a2cd	261
a1ffb40e	262	if (__glibc_unlikely (filedata == NULL))
cb09a2cd RM	263	/* We failed to map or read the data. */
	264	return;
	265
	266	newdata = _nl_intern_locale_data (category, filedata, st.st_size);
a1ffb40e	267	if (__glibc_unlikely (newdata == NULL))
cb09a2cd	268	/* Bad data. */
933e73fa	269	{
b6aa34eb	270	#ifdef _POSIX_MAPPED_FILES
cb09a2cd RM	271	if (alloc == ld_mapped)
cb09a2cd RM	272	__munmap ((caddr_t) filedata, st.st_size);
b6aa34eb	273	#endif
4a33c2f5	274	return;
933e73fa RM	275	}
933e73fa RM	276
cb09a2cd	277	/* _nl_intern_locale_data leaves us these fields to initialize. */
7a12c6bb	278	newdata->name = NULL; /* This will be filled if necessary in findlocale.c. */
cb09a2cd	279	newdata->alloc = alloc;
933e73fa	280
7a12c6bb	281	file->data = newdata;
933e73fa	282	}
a5a0310d UD	283
a5a0310d UD	284	void
cb09a2cd	285	internal_function
f095bb72	286	_nl_unload_locale (struct __locale_data *locale)
a5a0310d	287	{
df9f41c9 RM	288	if (locale->private.cleanup)
	289	(*locale->private.cleanup) (locale);
	290
cb09a2cd RM	291	switch (__builtin_expect (locale->alloc, ld_mapped))
	292	{
	293	case ld_malloced:
	294	free ((void *) locale->filedata);
	295	break;
	296	case ld_mapped:
b6aa34eb	297	#ifdef _POSIX_MAPPED_FILES
cb09a2cd RM	298	__munmap ((caddr_t) locale->filedata, locale->filesize);
cb09a2cd RM	299	break;
b6aa34eb	300	#endif
cb09a2cd RM	301	case ld_archive: /* Nothing to do. */
	302	break;
	303	}
	304
	305	if (__builtin_expect (locale->alloc, ld_mapped) != ld_archive)
	306	free ((char *) locale->name);
a5a0310d UD	307
	308	free (locale);
	309	}