* locale/loadarchive.c (_nl_load_locale_from_archive): Parse locale

	name to find codeset name (if any) and normalize it.  If the
	normalized name differs, look up only that in the archive.
	* locale/programs/locarchive.c (add_locale_to_archive): If the name
	contains a codeset, normalize the codeset store only the normalized
	name in the archive.  If not, add an alias containing the locale's
	normalized codeset name.  Apply codeset name normalization when
	matching entries in the alias file.

	* locale/programs/locarchive.c (delete_locales_from_archive): Don't
	decrement HEAD->namehash_used here.
	(add_locale): Only need to insert name string when name_offset != 0.

	* locale/programs/localedef.c (options): Add -A/--alias-file.
	(alias_file): New variable.
	(parse_opt): Grok -A, set that.
	* locale/programs/localedef.h: Declare it.

	* locale/programs/locarchive.c (insert_name): New function, broken out
	of ...
	(add_locale_to_archive): ... here.  Call that.
	(add_alias): New function.
	(add_locale): New static function, add_locale_to_archive renamed.
	(add_locale_to_archive): Call that and use add_alias to add an alias
	for the name with codeset if the given name lacks it.
	(enlarge_archive): Call add_locale instead of add_locale_to_archive.

	* locale/Makefile (routines): Add loadarchive.
	* locale/loadarchive.c: New file, started from code by Ulrich Drepper.
	(_nl_load_locale_from_archive): New function.
	* locale/localeinfo.h: Declare it.
	* locale/findlocale.c (_nl_find_locale): If using default locale path,
	try _nl_load_locale_from_archive first.

	* locale/loadlocale.c (_nl_intern_locale_data): New function,
	broken out of _nl_load_locale.
	(_nl_load_locale): Call that.
	* locale/localeinfo.h: Declare it.
	(struct locale_data): Replace member `mmaped' with `alloc', an enum.
	(struct locale_data): Remove unused member `options'.
	* locale/findlocale.c (_nl_remove_locale): Update uses.
	* locale/loadlocale.c (_nl_load_locale, _nl_unload_locale): Likewise.
	* locale/C-collate.c: Update initializer.
	* locale/C-identification.c: Likewise.
	* locale/C-measurement.c: Likewise.
	* locale/C-telephone.c: Likewise.
	* locale/C-address.c: Likewise.
	* locale/C-name.c: Likewise.
	* locale/C-paper.c: Likewise.
	* locale/C-time.c: Likewise.
	* locale/C-numeric.c: Likewise.
	* locale/C-monetary.c: Likewise.
	* locale/C-messages.c : Likewise.
	* locale/C-ctype.c: Likewise.

	* locale/hashval.h [! LONGBITS]: Include <limits.h> here and
	use CHAR_BIT instead of BITSPERBYTE.

	* locale/localeinfo.h (_nl_find_locale, _nl_load_locale,
	_nl_unload_locale): Add `internal_function attribute_hidden' to decls.
	* locale/findlocale.c (_nl_find_locale): Add internal_function to defn.
	(_nl_remove_locale): Likewise.
	* locale/loadlocale.c (_nl_load_locale, _nl_unload_locale): Likewise.

	* locale/findlocale.c (_nl_default_locale_path): New variable.
	(_nl_find_locale): If LOCALE_PATH is null, default to that.
	* locale/localeinfo.h: Declare it.
	* locale/setlocale.c (setlocale): Use _nl_default_locale_path
	in place of LOCALEDIR.  If no LOCPATH, pass null to _nl_find_locale.
	* locale/newlocale.c (__newlocale): Likewise.

	* misc/err.c (vwarnx, vwarn): Fix typos in libc_hidden_def uses.
	* inet/rexec.c (rexec_af): Add libc_hidden_def.
	* sysdeps/generic/morecore.c: Likewise.
	* signal/allocrtsig.c (__libc_current_sigrtmin): Likewise.
	(__libc_current_sigrtmax): Likewise.

2002-08-08  Roland McGrath  <roland@redhat.com>

	* locale/loadlocale.c (_nl_load_locale): Don't use MAP_INHERIT.
	* catgets/open_catalog.c (__open_catalog): Likewise.

	* locale/programs/locarchive.c (INITIAL_NUM_NAMES): Renamed
	from typo INITIAL_NUM_NANES.
	(create_archive): Update use.

1 files changed, 107 insertions, 81 deletions

diff --git a/locale/loadlocale.c b/locale/loadlocale.c
index 53962babac..14f3773c47 100644
--- a/locale/loadlocale.c
+++ b/locale/loadlocale.c
@@ -60,21 +60,82 @@ static const enum value_type *_nl_value_types[] =
 };
 
 
-void
-_nl_load_locale (struct loaded_l10nfile *file, int category)
+struct locale_data *
+internal_function
+_nl_intern_locale_data (int category, const void *data, size_t datasize)
 {
-  int fd;
-  struct
+  const struct
     {
       unsigned int magic;
       unsigned int nstrings;
       unsigned int strindex[0];
-    } *filedata;
+    } *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->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 (__builtin_expect (idx > newdata->filesize, 0))
+	{
+	puntdata:
+	  free (newdata);
+	  __set_errno (EINVAL);
+	  return NULL;
+	}
+      if (__builtin_expect (_nl_value_types[category][cnt] == word, 0))
+	{
+	  if (idx % __alignof__ (u_int32_t) != 0)
+	    goto puntdata;
+	  newdata->values[cnt].word =
+	    *((const u_int32_t *) (newdata->filedata + idx));
+	}
+      else
+	newdata->values[cnt].string = 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 mmaped = 1;
-  size_t cnt;
+  int alloc = ld_mapped;
 
   file->decided = 1;
   file->data = NULL;
@@ -85,7 +146,11 @@ _nl_load_locale (struct loaded_l10nfile *file, int category)
     return;
 
   if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
-    goto puntfd;
+    {
+    puntfd:
+      __close (fd);
+      return;
+    }
   if (__builtin_expect (S_ISDIR (st.st_mode), 0))
     {
       /* LOCALE/LC_foo is a directory; open LOCALE/LC_foo/SYS_LC_foo
@@ -122,25 +187,15 @@ _nl_load_locale (struct loaded_l10nfile *file, int category)
   /* Some systems do not have this flag; it is superfluous.  */
 #  define MAP_FILE 0
 # endif
-# ifndef MAP_INHERIT
-  /* Some systems might lack this; they lose.  */
-#  define MAP_INHERIT 0
-# endif
-  filedata = (void *) __mmap ((caddr_t) 0, st.st_size, PROT_READ,
-			      MAP_FILE|MAP_COPY|MAP_INHERIT, fd, 0);
-  if (__builtin_expect ((void *) filedata != MAP_FAILED, 1))
-    {
-      if (__builtin_expect (st.st_size < sizeof (*filedata), 0))
-	/* This cannot be a locale data file since it's too small.  */
-	goto puntfd;
-    }
-  else
+  filedata = __mmap ((caddr_t) 0, st.st_size,
+		     PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
+  if (__builtin_expect (filedata == MAP_FAILED, 0))
     {
       if (__builtin_expect (errno, ENOSYS) == ENOSYS)
 	{
 #endif	/* _POSIX_MAPPED_FILES */
 	  /* No mmap; allocate a buffer and read from the file.  */
-	  mmaped = 0;
+	  alloc = ld_malloced;
 	  filedata = malloc (st.st_size);
 	  if (filedata != NULL)
 	    {
@@ -160,87 +215,58 @@ _nl_load_locale (struct loaded_l10nfile *file, int category)
 		  p += nread;
 		  to_read -= nread;
 		}
+	      __set_errno (save_err);
 	    }
-	  else
-	    goto puntfd;
-	  __set_errno (save_err);
 #ifdef _POSIX_MAPPED_FILES
 	}
-      else
-	goto puntfd;
     }
 #endif	/* _POSIX_MAPPED_FILES */
 
-  if (__builtin_expect (filedata->magic != LIMAGIC (category), 0))
-    /* Bad data file in either byte order.  */
+  /* We have mapped the data, so we no longer need the descriptor.  */
+  __close (fd);
+
+  if (__builtin_expect (filedata == NULL, 0))
+    /* We failed to map or read the data.  */
+    return;
+
+  newdata = _nl_intern_locale_data (category, filedata, st.st_size);
+  if (__builtin_expect (newdata == NULL, 0))
+    /* Bad data.  */
     {
-    puntmap:
 #ifdef _POSIX_MAPPED_FILES
-      __munmap ((caddr_t) filedata, st.st_size);
+      if (alloc == ld_mapped)
+	__munmap ((caddr_t) filedata, st.st_size);
 #endif
-    puntfd:
-      __close (fd);
       return;
     }
 
-  if (__builtin_expect (filedata->nstrings < _nl_category_num_items[category],
-			0)
-      || (__builtin_expect (sizeof *filedata
-			    + filedata->nstrings * sizeof (unsigned int)
-			    >= (size_t) st.st_size, 0)))
-    {
-      /* Insufficient data.  */
-      __set_errno (EINVAL);
-      goto puntmap;
-    }
-
-  newdata = malloc (sizeof *newdata
-		    + filedata->nstrings * sizeof (union locale_data_value));
-  if (newdata == NULL)
-    goto puntmap;
-
+  /* _nl_intern_locale_data leaves us these fields to initialize.  */
   newdata->name = NULL;	/* This will be filled if necessary in findlocale.c. */
-  newdata->filedata = (void *) filedata;
-  newdata->filesize = st.st_size;
-  newdata->mmaped = mmaped;
-  newdata->usage_count = 0;
-  newdata->use_translit = 0;
-  newdata->options = NULL;
-  newdata->nstrings = filedata->nstrings;
-  for (cnt = 0; cnt < newdata->nstrings; ++cnt)
-    {
-      off_t idx = filedata->strindex[cnt];
-      if (__builtin_expect (idx > newdata->filesize, 0))
-	{
-	  free (newdata);
-	  __set_errno (EINVAL);
-	  goto puntmap;
-	}
-      if (__builtin_expect (_nl_value_types[category][cnt] == word, 0))
-	{
-	  assert (idx % __alignof__ (u_int32_t) == 0);
-	  newdata->values[cnt].word =
-	    *((u_int32_t *) (newdata->filedata + idx));
-	}
-      else
-	newdata->values[cnt].string = newdata->filedata + idx;
-    }
+  newdata->alloc = alloc;
 
-  __close (fd);
   file->data = newdata;
 }
 
 void
+internal_function
 _nl_unload_locale (struct locale_data *locale)
 {
+  switch (__builtin_expect (locale->alloc, ld_mapped))
+    {
+    case ld_malloced:
+      free ((void *) locale->filedata);
+      break;
+    case ld_mapped:
 #ifdef _POSIX_MAPPED_FILES
-  if (__builtin_expect (locale->mmaped, 1))
-    __munmap ((caddr_t) locale->filedata, locale->filesize);
-  else
+      __munmap ((caddr_t) locale->filedata, locale->filesize);
+      break;
 #endif
-    free ((void *) locale->filedata);
+    case ld_archive:		/* Nothing to do.  */
+      break;
+    }
+
+  if (__builtin_expect (locale->alloc, ld_mapped) != ld_archive)
+    free ((char *) locale->name);
 
-  free ((char *) locale->options);
-  free ((char *) locale->name);
   free (locale);
 }