mirror of
git://sourceware.org/git/glibc.git
synced 2024-12-03 04:01:43 +08:00
1758 lines
49 KiB
C
1758 lines
49 KiB
C
/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published
|
|
by the Free Software Foundation; version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <error.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <libintl.h>
|
|
#include <locale.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdio_ext.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <stdint.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/param.h>
|
|
#include <sys/shm.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <libc-internal.h>
|
|
#include <libc-mmap.h>
|
|
#include "../../crypt/md5.h"
|
|
#include "../localeinfo.h"
|
|
#include "../locarchive.h"
|
|
#include "localedef.h"
|
|
#include "locfile.h"
|
|
|
|
/* Define the hash function. We define the function as static inline.
|
|
We must change the name so as not to conflict with simple-hash.h. */
|
|
#define compute_hashval static archive_hashval
|
|
#define hashval_t uint32_t
|
|
#include "hashval.h"
|
|
#undef compute_hashval
|
|
|
|
extern const char *output_prefix;
|
|
|
|
#define ARCHIVE_NAME COMPLOCALEDIR "/locale-archive"
|
|
|
|
static const char *locnames[] =
|
|
{
|
|
#define DEFINE_CATEGORY(category, category_name, items, a) \
|
|
[category] = category_name,
|
|
#include "categories.def"
|
|
#undef DEFINE_CATEGORY
|
|
};
|
|
|
|
|
|
/* Size of the initial archive header. */
|
|
#define INITIAL_NUM_NAMES 900
|
|
#define INITIAL_SIZE_STRINGS 7500
|
|
#define INITIAL_NUM_LOCREC 420
|
|
#define INITIAL_NUM_SUMS 2000
|
|
|
|
|
|
/* Get and set values (possibly endian-swapped) in structures mapped
|
|
from or written directly to locale archives. */
|
|
#define GET(FIELD) maybe_swap_uint32 (FIELD)
|
|
#define SET(FIELD, VALUE) ((FIELD) = maybe_swap_uint32 (VALUE))
|
|
#define INC(FIELD, INCREMENT) SET (FIELD, GET (FIELD) + (INCREMENT))
|
|
|
|
|
|
/* Size of the reserved address space area. */
|
|
#define RESERVE_MMAP_SIZE 512 * 1024 * 1024
|
|
|
|
/* To prepare for enlargements of the mmaped area reserve some address
|
|
space. On some machines, being a file mapping rather than an anonymous
|
|
mapping affects the address selection. So do this mapping from the
|
|
actual file, even though it's only a dummy to reserve address space. */
|
|
static void *
|
|
prepare_address_space (int fd, size_t total, size_t *reserved, int *xflags,
|
|
void **mmap_base, size_t *mmap_len)
|
|
{
|
|
if (total < RESERVE_MMAP_SIZE)
|
|
{
|
|
void *p = mmap64 (NULL, RESERVE_MMAP_SIZE, PROT_NONE, MAP_SHARED, fd, 0);
|
|
if (p != MAP_FAILED)
|
|
{
|
|
void *aligned_p = PTR_ALIGN_UP (p, MAP_FIXED_ALIGNMENT);
|
|
size_t align_adjust = aligned_p - p;
|
|
*mmap_base = p;
|
|
*mmap_len = RESERVE_MMAP_SIZE;
|
|
assert (align_adjust < RESERVE_MMAP_SIZE);
|
|
*reserved = RESERVE_MMAP_SIZE - align_adjust;
|
|
*xflags = MAP_FIXED;
|
|
return aligned_p;
|
|
}
|
|
}
|
|
|
|
*reserved = total;
|
|
*xflags = 0;
|
|
*mmap_base = NULL;
|
|
*mmap_len = 0;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
create_archive (const char *archivefname, struct locarhandle *ah)
|
|
{
|
|
int fd;
|
|
char fname[strlen (archivefname) + sizeof (".XXXXXX")];
|
|
struct locarhead head;
|
|
size_t total;
|
|
|
|
strcpy (stpcpy (fname, archivefname), ".XXXXXX");
|
|
|
|
/* Create a temporary file in the correct directory. */
|
|
fd = mkstemp (fname);
|
|
if (fd == -1)
|
|
error (EXIT_FAILURE, errno, _("cannot create temporary file: %s"), fname);
|
|
|
|
/* Create the initial content of the archive. */
|
|
SET (head.magic, AR_MAGIC);
|
|
SET (head.serial, 0);
|
|
SET (head.namehash_offset, sizeof (struct locarhead));
|
|
SET (head.namehash_used, 0);
|
|
SET (head.namehash_size, next_prime (INITIAL_NUM_NAMES));
|
|
|
|
SET (head.string_offset,
|
|
(GET (head.namehash_offset)
|
|
+ GET (head.namehash_size) * sizeof (struct namehashent)));
|
|
SET (head.string_used, 0);
|
|
SET (head.string_size, INITIAL_SIZE_STRINGS);
|
|
|
|
SET (head.locrectab_offset,
|
|
GET (head.string_offset) + GET (head.string_size));
|
|
SET (head.locrectab_used, 0);
|
|
SET (head.locrectab_size, INITIAL_NUM_LOCREC);
|
|
|
|
SET (head.sumhash_offset,
|
|
(GET (head.locrectab_offset)
|
|
+ GET (head.locrectab_size) * sizeof (struct locrecent)));
|
|
SET (head.sumhash_used, 0);
|
|
SET (head.sumhash_size, next_prime (INITIAL_NUM_SUMS));
|
|
|
|
total = (GET (head.sumhash_offset)
|
|
+ GET (head.sumhash_size) * sizeof (struct sumhashent));
|
|
|
|
/* Write out the header and create room for the other data structures. */
|
|
if (TEMP_FAILURE_RETRY (write (fd, &head, sizeof (head))) != sizeof (head))
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot initialize archive file"));
|
|
}
|
|
|
|
if (ftruncate64 (fd, total) != 0)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot resize archive file"));
|
|
}
|
|
|
|
size_t reserved, mmap_len;
|
|
int xflags;
|
|
void *mmap_base;
|
|
void *p = prepare_address_space (fd, total, &reserved, &xflags, &mmap_base,
|
|
&mmap_len);
|
|
|
|
/* Map the header and all the administration data structures. */
|
|
p = mmap64 (p, total, PROT_READ | PROT_WRITE, MAP_SHARED | xflags, fd, 0);
|
|
if (p == MAP_FAILED)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot map archive header"));
|
|
}
|
|
|
|
/* Now try to rename it. We don't use the rename function since
|
|
this would overwrite a file which has been created in
|
|
parallel. */
|
|
if (link (fname, archivefname) == -1)
|
|
{
|
|
int errval = errno;
|
|
|
|
/* We cannot use the just created file. */
|
|
close (fd);
|
|
unlink (fname);
|
|
|
|
if (errval == EEXIST)
|
|
{
|
|
/* There is already an archive. Must have been a localedef run
|
|
which happened in parallel. Simply open this file then. */
|
|
open_archive (ah, false);
|
|
return;
|
|
}
|
|
|
|
error (EXIT_FAILURE, errval, _("failed to create new locale archive"));
|
|
}
|
|
|
|
/* Remove the temporary name. */
|
|
unlink (fname);
|
|
|
|
/* Make the file globally readable. */
|
|
if (fchmod (fd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) == -1)
|
|
{
|
|
int errval = errno;
|
|
unlink (archivefname);
|
|
error (EXIT_FAILURE, errval,
|
|
_("cannot change mode of new locale archive"));
|
|
}
|
|
|
|
ah->fname = NULL;
|
|
ah->fd = fd;
|
|
ah->mmap_base = mmap_base;
|
|
ah->mmap_len = mmap_len;
|
|
ah->addr = p;
|
|
ah->mmaped = total;
|
|
ah->reserved = reserved;
|
|
}
|
|
|
|
|
|
/* This structure and qsort comparator function are used below to sort an
|
|
old archive's locrec table in order of data position in the file. */
|
|
struct oldlocrecent
|
|
{
|
|
unsigned int cnt;
|
|
struct locrecent *locrec;
|
|
};
|
|
|
|
static int
|
|
oldlocrecentcmp (const void *a, const void *b)
|
|
{
|
|
struct locrecent *la = ((const struct oldlocrecent *) a)->locrec;
|
|
struct locrecent *lb = ((const struct oldlocrecent *) b)->locrec;
|
|
uint32_t start_a = -1, end_a = 0;
|
|
uint32_t start_b = -1, end_b = 0;
|
|
int cnt;
|
|
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (cnt != LC_ALL)
|
|
{
|
|
if (GET (la->record[cnt].offset) < start_a)
|
|
start_a = GET (la->record[cnt].offset);
|
|
if (GET (la->record[cnt].offset) + GET (la->record[cnt].len) > end_a)
|
|
end_a = GET (la->record[cnt].offset) + GET (la->record[cnt].len);
|
|
}
|
|
assert (start_a != (uint32_t)-1);
|
|
assert (end_a != 0);
|
|
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (cnt != LC_ALL)
|
|
{
|
|
if (GET (lb->record[cnt].offset) < start_b)
|
|
start_b = GET (lb->record[cnt].offset);
|
|
if (GET (lb->record[cnt].offset) + GET (lb->record[cnt].len) > end_b)
|
|
end_b = GET (lb->record[cnt].offset) + GET (lb->record[cnt].len);
|
|
}
|
|
assert (start_b != (uint32_t)-1);
|
|
assert (end_b != 0);
|
|
|
|
if (start_a != start_b)
|
|
return (int)start_a - (int)start_b;
|
|
return (int)end_a - (int)end_b;
|
|
}
|
|
|
|
|
|
/* forward decls for below */
|
|
static uint32_t add_locale (struct locarhandle *ah, const char *name,
|
|
locale_data_t data, bool replace);
|
|
static void add_alias (struct locarhandle *ah, const char *alias,
|
|
bool replace, const char *oldname,
|
|
uint32_t *locrec_offset_p);
|
|
|
|
|
|
static bool
|
|
file_data_available_p (struct locarhandle *ah, uint32_t offset, uint32_t size)
|
|
{
|
|
if (offset < ah->mmaped && offset + size <= ah->mmaped)
|
|
return true;
|
|
|
|
struct stat64 st;
|
|
if (fstat64 (ah->fd, &st) != 0)
|
|
return false;
|
|
|
|
if (st.st_size > ah->reserved)
|
|
return false;
|
|
|
|
size_t start = ALIGN_DOWN (ah->mmaped, MAP_FIXED_ALIGNMENT);
|
|
void *p = mmap64 (ah->addr + start, st.st_size - start,
|
|
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED,
|
|
ah->fd, start);
|
|
if (p == MAP_FAILED)
|
|
{
|
|
ah->mmaped = start;
|
|
return false;
|
|
}
|
|
|
|
ah->mmaped = st.st_size;
|
|
return true;
|
|
}
|
|
|
|
|
|
static int
|
|
compare_from_file (struct locarhandle *ah, void *p1, uint32_t offset2,
|
|
uint32_t size)
|
|
{
|
|
void *p2 = xmalloc (size);
|
|
if (pread (ah->fd, p2, size, offset2) != size)
|
|
WITH_CUR_LOCALE (error (4, errno,
|
|
_("cannot read data from locale archive")));
|
|
|
|
int res = memcmp (p1, p2, size);
|
|
free (p2);
|
|
return res;
|
|
}
|
|
|
|
|
|
static void
|
|
enlarge_archive (struct locarhandle *ah, const struct locarhead *head)
|
|
{
|
|
struct stat64 st;
|
|
int fd;
|
|
struct locarhead newhead;
|
|
size_t total;
|
|
unsigned int cnt, loccnt;
|
|
struct namehashent *oldnamehashtab;
|
|
struct locarhandle new_ah;
|
|
size_t prefix_len = output_prefix ? strlen (output_prefix) : 0;
|
|
char archivefname[prefix_len + sizeof (ARCHIVE_NAME)];
|
|
char fname[prefix_len + sizeof (ARCHIVE_NAME) + sizeof (".XXXXXX") - 1];
|
|
|
|
if (output_prefix)
|
|
memcpy (archivefname, output_prefix, prefix_len);
|
|
strcpy (archivefname + prefix_len, ARCHIVE_NAME);
|
|
strcpy (stpcpy (fname, archivefname), ".XXXXXX");
|
|
|
|
/* Not all of the old file has to be mapped. Change this now this
|
|
we will have to access the whole content. */
|
|
if (fstat64 (ah->fd, &st) != 0)
|
|
enomap:
|
|
error (EXIT_FAILURE, errno, _("cannot map locale archive file"));
|
|
|
|
if (st.st_size < ah->reserved)
|
|
ah->addr = mmap64 (ah->addr, st.st_size, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED | MAP_FIXED, ah->fd, 0);
|
|
else
|
|
{
|
|
if (ah->mmap_base)
|
|
munmap (ah->mmap_base, ah->mmap_len);
|
|
else
|
|
munmap (ah->addr, ah->reserved);
|
|
ah->addr = mmap64 (NULL, st.st_size, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED, ah->fd, 0);
|
|
ah->reserved = st.st_size;
|
|
ah->mmap_base = NULL;
|
|
ah->mmap_len = 0;
|
|
head = ah->addr;
|
|
}
|
|
if (ah->addr == MAP_FAILED)
|
|
goto enomap;
|
|
ah->mmaped = st.st_size;
|
|
|
|
/* Create a temporary file in the correct directory. */
|
|
fd = mkstemp (fname);
|
|
if (fd == -1)
|
|
error (EXIT_FAILURE, errno, _("cannot create temporary file: %s"), fname);
|
|
|
|
/* Copy the existing head information. */
|
|
newhead = *head;
|
|
|
|
/* Create the new archive header. The sizes of the various tables
|
|
should be double from what is currently used. */
|
|
SET (newhead.namehash_size,
|
|
MAX (next_prime (2 * GET (newhead.namehash_used)),
|
|
GET (newhead.namehash_size)));
|
|
if (verbose)
|
|
printf ("name: size: %u, used: %d, new: size: %u\n",
|
|
GET (head->namehash_size),
|
|
GET (head->namehash_used), GET (newhead.namehash_size));
|
|
|
|
SET (newhead.string_offset, (GET (newhead.namehash_offset)
|
|
+ (GET (newhead.namehash_size)
|
|
* sizeof (struct namehashent))));
|
|
/* Keep the string table size aligned to 4 bytes, so that
|
|
all the struct { uint32_t } types following are happy. */
|
|
SET (newhead.string_size, MAX ((2 * GET (newhead.string_used) + 3) & -4,
|
|
GET (newhead.string_size)));
|
|
|
|
SET (newhead.locrectab_offset,
|
|
GET (newhead.string_offset) + GET (newhead.string_size));
|
|
SET (newhead.locrectab_size, MAX (2 * GET (newhead.locrectab_used),
|
|
GET (newhead.locrectab_size)));
|
|
|
|
SET (newhead.sumhash_offset, (GET (newhead.locrectab_offset)
|
|
+ (GET (newhead.locrectab_size)
|
|
* sizeof (struct locrecent))));
|
|
SET (newhead.sumhash_size,
|
|
MAX (next_prime (2 * GET (newhead.sumhash_used)),
|
|
GET (newhead.sumhash_size)));
|
|
|
|
total = (GET (newhead.sumhash_offset)
|
|
+ GET (newhead.sumhash_size) * sizeof (struct sumhashent));
|
|
|
|
/* The new file is empty now. */
|
|
SET (newhead.namehash_used, 0);
|
|
SET (newhead.string_used, 0);
|
|
SET (newhead.locrectab_used, 0);
|
|
SET (newhead.sumhash_used, 0);
|
|
|
|
/* Write out the header and create room for the other data structures. */
|
|
if (TEMP_FAILURE_RETRY (write (fd, &newhead, sizeof (newhead)))
|
|
!= sizeof (newhead))
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot initialize archive file"));
|
|
}
|
|
|
|
if (ftruncate64 (fd, total) != 0)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot resize archive file"));
|
|
}
|
|
|
|
size_t reserved, mmap_len;
|
|
int xflags;
|
|
void *mmap_base;
|
|
void *p = prepare_address_space (fd, total, &reserved, &xflags, &mmap_base,
|
|
&mmap_len);
|
|
|
|
/* Map the header and all the administration data structures. */
|
|
p = mmap64 (p, total, PROT_READ | PROT_WRITE, MAP_SHARED | xflags, fd, 0);
|
|
if (p == MAP_FAILED)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot map archive header"));
|
|
}
|
|
|
|
/* Lock the new file. */
|
|
if (lockf64 (fd, F_LOCK, total) != 0)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot lock new archive"));
|
|
}
|
|
|
|
new_ah.mmaped = total;
|
|
new_ah.mmap_base = mmap_base;
|
|
new_ah.mmap_len = mmap_len;
|
|
new_ah.addr = p;
|
|
new_ah.fd = fd;
|
|
new_ah.reserved = reserved;
|
|
|
|
/* Walk through the hash name hash table to find out what data is
|
|
still referenced and transfer it into the new file. */
|
|
oldnamehashtab = (struct namehashent *) ((char *) ah->addr
|
|
+ GET (head->namehash_offset));
|
|
|
|
/* Sort the old locrec table in order of data position. */
|
|
struct oldlocrecent oldlocrecarray[GET (head->namehash_size)];
|
|
for (cnt = 0, loccnt = 0; cnt < GET (head->namehash_size); ++cnt)
|
|
if (GET (oldnamehashtab[cnt].locrec_offset) != 0)
|
|
{
|
|
oldlocrecarray[loccnt].cnt = cnt;
|
|
oldlocrecarray[loccnt++].locrec
|
|
= (struct locrecent *) ((char *) ah->addr
|
|
+ GET (oldnamehashtab[cnt].locrec_offset));
|
|
}
|
|
qsort (oldlocrecarray, loccnt, sizeof (struct oldlocrecent),
|
|
oldlocrecentcmp);
|
|
|
|
uint32_t last_locrec_offset = 0;
|
|
for (cnt = 0; cnt < loccnt; ++cnt)
|
|
{
|
|
/* Insert this entry in the new hash table. */
|
|
locale_data_t old_data;
|
|
unsigned int idx;
|
|
struct locrecent *oldlocrec = oldlocrecarray[cnt].locrec;
|
|
|
|
for (idx = 0; idx < __LC_LAST; ++idx)
|
|
if (idx != LC_ALL)
|
|
{
|
|
old_data[idx].size = GET (oldlocrec->record[idx].len);
|
|
old_data[idx].addr
|
|
= ((char *) ah->addr + GET (oldlocrec->record[idx].offset));
|
|
|
|
__md5_buffer (old_data[idx].addr, old_data[idx].size,
|
|
old_data[idx].sum);
|
|
}
|
|
|
|
if (cnt > 0 && oldlocrecarray[cnt - 1].locrec == oldlocrec)
|
|
{
|
|
const char *oldname
|
|
= ((char *) ah->addr
|
|
+ GET (oldnamehashtab[oldlocrecarray[cnt
|
|
- 1].cnt].name_offset));
|
|
|
|
add_alias
|
|
(&new_ah,
|
|
((char *) ah->addr
|
|
+ GET (oldnamehashtab[oldlocrecarray[cnt].cnt].name_offset)),
|
|
0, oldname, &last_locrec_offset);
|
|
continue;
|
|
}
|
|
|
|
last_locrec_offset =
|
|
add_locale
|
|
(&new_ah,
|
|
((char *) ah->addr
|
|
+ GET (oldnamehashtab[oldlocrecarray[cnt].cnt].name_offset)),
|
|
old_data, 0);
|
|
if (last_locrec_offset == 0)
|
|
error (EXIT_FAILURE, 0, _("cannot extend locale archive file"));
|
|
}
|
|
|
|
/* Make the file globally readable. */
|
|
if (fchmod (fd, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) == -1)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval,
|
|
_("cannot change mode of resized locale archive"));
|
|
}
|
|
|
|
/* Rename the new file. */
|
|
if (rename (fname, archivefname) != 0)
|
|
{
|
|
int errval = errno;
|
|
unlink (fname);
|
|
error (EXIT_FAILURE, errval, _("cannot rename new archive"));
|
|
}
|
|
|
|
/* Close the old file. */
|
|
close_archive (ah);
|
|
|
|
/* Add the information for the new one. */
|
|
*ah = new_ah;
|
|
}
|
|
|
|
|
|
void
|
|
open_archive (struct locarhandle *ah, bool readonly)
|
|
{
|
|
struct stat64 st;
|
|
struct stat64 st2;
|
|
int fd;
|
|
struct locarhead head;
|
|
int retry = 0;
|
|
size_t prefix_len = output_prefix ? strlen (output_prefix) : 0;
|
|
char default_fname[prefix_len + sizeof (ARCHIVE_NAME)];
|
|
const char *archivefname = ah->fname;
|
|
|
|
/* If ah has a non-NULL fname open that otherwise open the default. */
|
|
if (archivefname == NULL)
|
|
{
|
|
archivefname = default_fname;
|
|
if (output_prefix)
|
|
memcpy (default_fname, output_prefix, prefix_len);
|
|
strcpy (default_fname + prefix_len, ARCHIVE_NAME);
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
/* Open the archive. We must have exclusive write access. */
|
|
fd = open64 (archivefname, readonly ? O_RDONLY : O_RDWR);
|
|
if (fd == -1)
|
|
{
|
|
/* Maybe the file does not yet exist? If we are opening
|
|
the default locale archive we ignore the failure and
|
|
list an empty archive, otherwise we print an error
|
|
and exit. */
|
|
if (errno == ENOENT && archivefname == default_fname)
|
|
{
|
|
if (readonly)
|
|
{
|
|
static const struct locarhead nullhead =
|
|
{
|
|
.namehash_used = 0,
|
|
.namehash_offset = 0,
|
|
.namehash_size = 0
|
|
};
|
|
|
|
ah->addr = (void *) &nullhead;
|
|
ah->fd = -1;
|
|
}
|
|
else
|
|
create_archive (archivefname, ah);
|
|
|
|
return;
|
|
}
|
|
else
|
|
error (EXIT_FAILURE, errno, _("cannot open locale archive \"%s\""),
|
|
archivefname);
|
|
}
|
|
|
|
if (fstat64 (fd, &st) < 0)
|
|
error (EXIT_FAILURE, errno, _("cannot stat locale archive \"%s\""),
|
|
archivefname);
|
|
|
|
if (!readonly && lockf64 (fd, F_LOCK, sizeof (struct locarhead)) == -1)
|
|
{
|
|
close (fd);
|
|
|
|
if (retry++ < max_locarchive_open_retry)
|
|
{
|
|
struct timespec req;
|
|
|
|
/* Wait for a bit. */
|
|
req.tv_sec = 0;
|
|
req.tv_nsec = 1000000 * (random () % 500 + 1);
|
|
(void) nanosleep (&req, NULL);
|
|
|
|
continue;
|
|
}
|
|
|
|
error (EXIT_FAILURE, errno, _("cannot lock locale archive \"%s\""),
|
|
archivefname);
|
|
}
|
|
|
|
/* One more check. Maybe another process replaced the archive file
|
|
with a new, larger one since we opened the file. */
|
|
if (stat64 (archivefname, &st2) == -1
|
|
|| st.st_dev != st2.st_dev
|
|
|| st.st_ino != st2.st_ino)
|
|
{
|
|
(void) lockf64 (fd, F_ULOCK, sizeof (struct locarhead));
|
|
close (fd);
|
|
continue;
|
|
}
|
|
|
|
/* Leave the loop. */
|
|
break;
|
|
}
|
|
|
|
/* Read the header. */
|
|
if (TEMP_FAILURE_RETRY (read (fd, &head, sizeof (head))) != sizeof (head))
|
|
{
|
|
(void) lockf64 (fd, F_ULOCK, sizeof (struct locarhead));
|
|
error (EXIT_FAILURE, errno, _("cannot read archive header"));
|
|
}
|
|
|
|
ah->fd = fd;
|
|
ah->mmaped = st.st_size;
|
|
|
|
size_t reserved, mmap_len;
|
|
int xflags;
|
|
void *mmap_base;
|
|
void *p = prepare_address_space (fd, st.st_size, &reserved, &xflags,
|
|
&mmap_base, &mmap_len);
|
|
|
|
/* Map the entire file. We might need to compare the category data
|
|
in the file with the newly added data. */
|
|
ah->addr = mmap64 (p, st.st_size, PROT_READ | (readonly ? 0 : PROT_WRITE),
|
|
MAP_SHARED | xflags, fd, 0);
|
|
if (ah->addr == MAP_FAILED)
|
|
{
|
|
(void) lockf64 (fd, F_ULOCK, sizeof (struct locarhead));
|
|
error (EXIT_FAILURE, errno, _("cannot map archive header"));
|
|
}
|
|
ah->reserved = reserved;
|
|
ah->mmap_base = mmap_base;
|
|
ah->mmap_len = mmap_len;
|
|
}
|
|
|
|
|
|
void
|
|
close_archive (struct locarhandle *ah)
|
|
{
|
|
if (ah->fd != -1)
|
|
{
|
|
if (ah->mmap_base)
|
|
munmap (ah->mmap_base, ah->mmap_len);
|
|
else
|
|
munmap (ah->addr, ah->reserved);
|
|
close (ah->fd);
|
|
}
|
|
}
|
|
|
|
#include "../../intl/explodename.c"
|
|
#include "../../intl/l10nflist.c"
|
|
|
|
static struct namehashent *
|
|
insert_name (struct locarhandle *ah,
|
|
const char *name, size_t name_len, bool replace)
|
|
{
|
|
const struct locarhead *const head = ah->addr;
|
|
struct namehashent *namehashtab
|
|
= (struct namehashent *) ((char *) ah->addr
|
|
+ GET (head->namehash_offset));
|
|
unsigned int insert_idx, idx, incr;
|
|
|
|
/* Hash value of the locale name. */
|
|
uint32_t hval = archive_hashval (name, name_len);
|
|
|
|
insert_idx = -1;
|
|
idx = hval % GET (head->namehash_size);
|
|
incr = 1 + hval % (GET (head->namehash_size) - 2);
|
|
|
|
/* If the name_offset field is zero this means this is a
|
|
deleted entry and therefore no entry can be found. */
|
|
while (GET (namehashtab[idx].name_offset) != 0)
|
|
{
|
|
if (GET (namehashtab[idx].hashval) == hval
|
|
&& (strcmp (name,
|
|
(char *) ah->addr + GET (namehashtab[idx].name_offset))
|
|
== 0))
|
|
{
|
|
/* Found the entry. */
|
|
if (GET (namehashtab[idx].locrec_offset) != 0 && ! replace)
|
|
{
|
|
if (! be_quiet)
|
|
error (0, 0, _("locale '%s' already exists"), name);
|
|
return NULL;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (GET (namehashtab[idx].hashval) == hval && ! be_quiet)
|
|
{
|
|
error (0, 0, "hash collision (%u) %s, %s",
|
|
hval, name,
|
|
(char *) ah->addr + GET (namehashtab[idx].name_offset));
|
|
}
|
|
|
|
/* Remember the first place we can insert the new entry. */
|
|
if (GET (namehashtab[idx].locrec_offset) == 0 && insert_idx == -1)
|
|
insert_idx = idx;
|
|
|
|
idx += incr;
|
|
if (idx >= GET (head->namehash_size))
|
|
idx -= GET (head->namehash_size);
|
|
}
|
|
|
|
/* Add as early as possible. */
|
|
if (insert_idx != -1)
|
|
idx = insert_idx;
|
|
|
|
SET (namehashtab[idx].hashval, hval); /* no-op if replacing an old entry. */
|
|
return &namehashtab[idx];
|
|
}
|
|
|
|
static void
|
|
add_alias (struct locarhandle *ah, const char *alias, bool replace,
|
|
const char *oldname, uint32_t *locrec_offset_p)
|
|
{
|
|
uint32_t locrec_offset = *locrec_offset_p;
|
|
struct locarhead *head = ah->addr;
|
|
const size_t name_len = strlen (alias);
|
|
struct namehashent *namehashent = insert_name (ah, alias, strlen (alias),
|
|
replace);
|
|
if (namehashent == NULL && ! replace)
|
|
return;
|
|
|
|
if (GET (namehashent->name_offset) == 0)
|
|
{
|
|
/* We are adding a new hash entry for this alias.
|
|
Determine whether we have to resize the file. */
|
|
if (GET (head->string_used) + name_len + 1 > GET (head->string_size)
|
|
|| (100 * GET (head->namehash_used)
|
|
> 75 * GET (head->namehash_size)))
|
|
{
|
|
/* The current archive is not large enough. */
|
|
enlarge_archive (ah, head);
|
|
|
|
/* The locrecent might have moved, so we have to look up
|
|
the old name afresh. */
|
|
namehashent = insert_name (ah, oldname, strlen (oldname), true);
|
|
assert (GET (namehashent->name_offset) != 0);
|
|
assert (GET (namehashent->locrec_offset) != 0);
|
|
*locrec_offset_p = GET (namehashent->locrec_offset);
|
|
|
|
/* Tail call to try the whole thing again. */
|
|
add_alias (ah, alias, replace, oldname, locrec_offset_p);
|
|
return;
|
|
}
|
|
|
|
/* Add the name string. */
|
|
memcpy (ah->addr + GET (head->string_offset) + GET (head->string_used),
|
|
alias, name_len + 1);
|
|
SET (namehashent->name_offset,
|
|
GET (head->string_offset) + GET (head->string_used));
|
|
INC (head->string_used, name_len + 1);
|
|
|
|
INC (head->namehash_used, 1);
|
|
}
|
|
|
|
if (GET (namehashent->locrec_offset) != 0)
|
|
{
|
|
/* Replacing an existing entry.
|
|
Mark that we are no longer using the old locrecent. */
|
|
struct locrecent *locrecent
|
|
= (struct locrecent *) ((char *) ah->addr
|
|
+ GET (namehashent->locrec_offset));
|
|
INC (locrecent->refs, -1);
|
|
}
|
|
|
|
/* Point this entry at the locrecent installed for the main name. */
|
|
SET (namehashent->locrec_offset, locrec_offset);
|
|
}
|
|
|
|
static int /* qsort comparator used below */
|
|
cmpcategorysize (const void *a, const void *b)
|
|
{
|
|
if (*(const void **) a == NULL)
|
|
return 1;
|
|
if (*(const void **) b == NULL)
|
|
return -1;
|
|
return ((*(const struct locale_category_data **) a)->size
|
|
- (*(const struct locale_category_data **) b)->size);
|
|
}
|
|
|
|
/* Check the content of the archive for duplicates. Add the content
|
|
of the files if necessary. Returns the locrec_offset. */
|
|
static uint32_t
|
|
add_locale (struct locarhandle *ah,
|
|
const char *name, locale_data_t data, bool replace)
|
|
{
|
|
/* First look for the name. If it already exists and we are not
|
|
supposed to replace it don't do anything. If it does not exist
|
|
we have to allocate a new locale record. */
|
|
size_t name_len = strlen (name);
|
|
uint32_t file_offsets[__LC_LAST];
|
|
unsigned int num_new_offsets = 0;
|
|
struct sumhashent *sumhashtab;
|
|
uint32_t hval;
|
|
unsigned int cnt, idx;
|
|
struct locarhead *head;
|
|
struct namehashent *namehashent;
|
|
unsigned int incr;
|
|
struct locrecent *locrecent;
|
|
off64_t lastoffset;
|
|
char *ptr;
|
|
struct locale_category_data *size_order[__LC_LAST];
|
|
/* Page size alignment is a minor optimization for locality; use a
|
|
common value here rather than making the localedef output depend
|
|
on the page size of the system on which localedef is run. See
|
|
<https://sourceware.org/glibc/wiki/Development_Todo/Master#Locale_archive_alignment>
|
|
for more discussion. */
|
|
const size_t pagesz = 4096;
|
|
int small_mask;
|
|
|
|
head = ah->addr;
|
|
sumhashtab = (struct sumhashent *) ((char *) ah->addr
|
|
+ GET (head->sumhash_offset));
|
|
|
|
memset (file_offsets, 0, sizeof (file_offsets));
|
|
|
|
size_order[LC_ALL] = NULL;
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (cnt != LC_ALL)
|
|
size_order[cnt] = &data[cnt];
|
|
|
|
/* Sort the array in ascending order of data size. */
|
|
qsort (size_order, __LC_LAST, sizeof size_order[0], cmpcategorysize);
|
|
|
|
small_mask = 0;
|
|
data[LC_ALL].size = 0;
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (size_order[cnt] != NULL)
|
|
{
|
|
const size_t rounded_size = (size_order[cnt]->size + 15) & -16;
|
|
if (data[LC_ALL].size + rounded_size > 2 * pagesz)
|
|
{
|
|
/* This category makes the small-categories block
|
|
stop being small, so this is the end of the road. */
|
|
do
|
|
size_order[cnt++] = NULL;
|
|
while (cnt < __LC_LAST);
|
|
break;
|
|
}
|
|
data[LC_ALL].size += rounded_size;
|
|
small_mask |= 1 << (size_order[cnt] - data);
|
|
}
|
|
|
|
/* Copy the data for all the small categories into the LC_ALL
|
|
pseudo-category. */
|
|
|
|
data[LC_ALL].addr = alloca (data[LC_ALL].size);
|
|
memset (data[LC_ALL].addr, 0, data[LC_ALL].size);
|
|
|
|
ptr = data[LC_ALL].addr;
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (small_mask & (1 << cnt))
|
|
{
|
|
memcpy (ptr, data[cnt].addr, data[cnt].size);
|
|
ptr += (data[cnt].size + 15) & -16;
|
|
}
|
|
__md5_buffer (data[LC_ALL].addr, data[LC_ALL].size, data[LC_ALL].sum);
|
|
|
|
/* For each locale category data set determine whether the same data
|
|
is already somewhere in the archive. */
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (small_mask == 0 ? cnt != LC_ALL : !(small_mask & (1 << cnt)))
|
|
{
|
|
++num_new_offsets;
|
|
|
|
/* Compute the hash value of the checksum to determine a
|
|
starting point for the search in the MD5 hash value
|
|
table. */
|
|
hval = archive_hashval (data[cnt].sum, 16);
|
|
|
|
idx = hval % GET (head->sumhash_size);
|
|
incr = 1 + hval % (GET (head->sumhash_size) - 2);
|
|
|
|
while (GET (sumhashtab[idx].file_offset) != 0)
|
|
{
|
|
if (memcmp (data[cnt].sum, sumhashtab[idx].sum, 16) == 0)
|
|
{
|
|
/* Check the content, there could be a collision of
|
|
the hash sum.
|
|
|
|
Unfortunately the sumhashent record does not include
|
|
the size of the stored data. So we have to search for
|
|
it. */
|
|
locrecent
|
|
= (struct locrecent *) ((char *) ah->addr
|
|
+ GET (head->locrectab_offset));
|
|
size_t iloc;
|
|
for (iloc = 0; iloc < GET (head->locrectab_used); ++iloc)
|
|
if (GET (locrecent[iloc].refs) != 0
|
|
&& (GET (locrecent[iloc].record[cnt].offset)
|
|
== GET (sumhashtab[idx].file_offset)))
|
|
break;
|
|
|
|
if (iloc != GET (head->locrectab_used)
|
|
&& data[cnt].size == GET (locrecent[iloc].record[cnt].len)
|
|
/* We have to compare the content. Either we can
|
|
have the data mmaped or we have to read from
|
|
the file. */
|
|
&& (file_data_available_p
|
|
(ah, GET (sumhashtab[idx].file_offset),
|
|
data[cnt].size)
|
|
? memcmp (data[cnt].addr,
|
|
(char *) ah->addr
|
|
+ GET (sumhashtab[idx].file_offset),
|
|
data[cnt].size) == 0
|
|
: compare_from_file (ah, data[cnt].addr,
|
|
GET (sumhashtab[idx].file_offset),
|
|
data[cnt].size) == 0))
|
|
{
|
|
/* Found it. */
|
|
file_offsets[cnt] = GET (sumhashtab[idx].file_offset);
|
|
--num_new_offsets;
|
|
break;
|
|
}
|
|
}
|
|
|
|
idx += incr;
|
|
if (idx >= GET (head->sumhash_size))
|
|
idx -= GET (head->sumhash_size);
|
|
}
|
|
}
|
|
|
|
/* Find a slot for the locale name in the hash table. */
|
|
namehashent = insert_name (ah, name, name_len, replace);
|
|
if (namehashent == NULL) /* Already exists and !REPLACE. */
|
|
return 0;
|
|
|
|
/* Determine whether we have to resize the file. */
|
|
if ((100 * (GET (head->sumhash_used) + num_new_offsets)
|
|
> 75 * GET (head->sumhash_size))
|
|
|| (GET (namehashent->locrec_offset) == 0
|
|
&& (GET (head->locrectab_used) == GET (head->locrectab_size)
|
|
|| (GET (head->string_used) + name_len + 1
|
|
> GET (head->string_size))
|
|
|| (100 * GET (head->namehash_used)
|
|
> 75 * GET (head->namehash_size)))))
|
|
{
|
|
/* The current archive is not large enough. */
|
|
enlarge_archive (ah, head);
|
|
return add_locale (ah, name, data, replace);
|
|
}
|
|
|
|
/* Add the locale data which is not yet in the archive. */
|
|
for (cnt = 0, lastoffset = 0; cnt < __LC_LAST; ++cnt)
|
|
if ((small_mask == 0 ? cnt != LC_ALL : !(small_mask & (1 << cnt)))
|
|
&& file_offsets[cnt] == 0)
|
|
{
|
|
/* The data for this section is not yet available in the
|
|
archive. Append it. */
|
|
off64_t lastpos;
|
|
uint32_t md5hval;
|
|
|
|
lastpos = lseek64 (ah->fd, 0, SEEK_END);
|
|
if (lastpos == (off64_t) -1)
|
|
error (EXIT_FAILURE, errno, _("cannot add to locale archive"));
|
|
|
|
/* If block of small categories would cross page boundary,
|
|
align it unless it immediately follows a large category. */
|
|
if (cnt == LC_ALL && lastoffset != lastpos
|
|
&& ((((lastpos & (pagesz - 1)) + data[cnt].size + pagesz - 1)
|
|
& -pagesz)
|
|
> ((data[cnt].size + pagesz - 1) & -pagesz)))
|
|
{
|
|
size_t sz = pagesz - (lastpos & (pagesz - 1));
|
|
char *zeros = alloca (sz);
|
|
|
|
memset (zeros, 0, sz);
|
|
if (TEMP_FAILURE_RETRY (write (ah->fd, zeros, sz) != sz))
|
|
error (EXIT_FAILURE, errno,
|
|
_("cannot add to locale archive"));
|
|
|
|
lastpos += sz;
|
|
}
|
|
|
|
/* Align all data to a 16 byte boundary. */
|
|
if ((lastpos & 15) != 0)
|
|
{
|
|
static const char zeros[15] = { 0, };
|
|
|
|
if (TEMP_FAILURE_RETRY (write (ah->fd, zeros, 16 - (lastpos & 15)))
|
|
!= 16 - (lastpos & 15))
|
|
error (EXIT_FAILURE, errno, _("cannot add to locale archive"));
|
|
|
|
lastpos += 16 - (lastpos & 15);
|
|
}
|
|
|
|
/* Remember the position. */
|
|
file_offsets[cnt] = lastpos;
|
|
lastoffset = lastpos + data[cnt].size;
|
|
|
|
/* Write the data. */
|
|
if (TEMP_FAILURE_RETRY (write (ah->fd, data[cnt].addr, data[cnt].size))
|
|
!= data[cnt].size)
|
|
error (EXIT_FAILURE, errno, _("cannot add to locale archive"));
|
|
|
|
/* Add the hash value to the hash table. */
|
|
md5hval = archive_hashval (data[cnt].sum, 16);
|
|
|
|
idx = md5hval % GET (head->sumhash_size);
|
|
incr = 1 + md5hval % (GET (head->sumhash_size) - 2);
|
|
|
|
while (GET (sumhashtab[idx].file_offset) != 0)
|
|
{
|
|
idx += incr;
|
|
if (idx >= GET (head->sumhash_size))
|
|
idx -= GET (head->sumhash_size);
|
|
}
|
|
|
|
memcpy (sumhashtab[idx].sum, data[cnt].sum, 16);
|
|
SET (sumhashtab[idx].file_offset, file_offsets[cnt]);
|
|
|
|
INC (head->sumhash_used, 1);
|
|
}
|
|
|
|
lastoffset = file_offsets[LC_ALL];
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (small_mask & (1 << cnt))
|
|
{
|
|
file_offsets[cnt] = lastoffset;
|
|
lastoffset += (data[cnt].size + 15) & -16;
|
|
}
|
|
|
|
if (GET (namehashent->name_offset) == 0)
|
|
{
|
|
/* Add the name string. */
|
|
memcpy ((char *) ah->addr + GET (head->string_offset)
|
|
+ GET (head->string_used),
|
|
name, name_len + 1);
|
|
SET (namehashent->name_offset,
|
|
GET (head->string_offset) + GET (head->string_used));
|
|
INC (head->string_used, name_len + 1);
|
|
INC (head->namehash_used, 1);
|
|
}
|
|
|
|
if (GET (namehashent->locrec_offset == 0))
|
|
{
|
|
/* Allocate a name location record. */
|
|
SET (namehashent->locrec_offset, (GET (head->locrectab_offset)
|
|
+ (GET (head->locrectab_used)
|
|
* sizeof (struct locrecent))));
|
|
INC (head->locrectab_used, 1);
|
|
locrecent = (struct locrecent *) ((char *) ah->addr
|
|
+ GET (namehashent->locrec_offset));
|
|
SET (locrecent->refs, 1);
|
|
}
|
|
else
|
|
{
|
|
/* If there are other aliases pointing to this locrecent,
|
|
we still need a new one. If not, reuse the old one. */
|
|
|
|
locrecent = (struct locrecent *) ((char *) ah->addr
|
|
+ GET (namehashent->locrec_offset));
|
|
if (GET (locrecent->refs) > 1)
|
|
{
|
|
INC (locrecent->refs, -1);
|
|
SET (namehashent->locrec_offset, (GET (head->locrectab_offset)
|
|
+ (GET (head->locrectab_used)
|
|
* sizeof (struct locrecent))));
|
|
INC (head->locrectab_used, 1);
|
|
locrecent
|
|
= (struct locrecent *) ((char *) ah->addr
|
|
+ GET (namehashent->locrec_offset));
|
|
SET (locrecent->refs, 1);
|
|
}
|
|
}
|
|
|
|
/* Fill in the table with the locations of the locale data. */
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
{
|
|
SET (locrecent->record[cnt].offset, file_offsets[cnt]);
|
|
SET (locrecent->record[cnt].len, data[cnt].size);
|
|
}
|
|
|
|
return GET (namehashent->locrec_offset);
|
|
}
|
|
|
|
|
|
/* Check the content of the archive for duplicates. Add the content
|
|
of the files if necessary. Add all the names, possibly overwriting
|
|
old files. */
|
|
int
|
|
add_locale_to_archive (struct locarhandle *ah, const char *name,
|
|
locale_data_t data, bool replace)
|
|
{
|
|
char *normalized_name = NULL;
|
|
uint32_t locrec_offset;
|
|
|
|
/* First analyze the name to decide how to archive it. */
|
|
const char *language;
|
|
const char *modifier;
|
|
const char *territory;
|
|
const char *codeset;
|
|
const char *normalized_codeset;
|
|
int mask = _nl_explode_name (strdupa (name),
|
|
&language, &modifier, &territory,
|
|
&codeset, &normalized_codeset);
|
|
if (mask == -1)
|
|
return -1;
|
|
|
|
if (mask & XPG_NORM_CODESET)
|
|
/* This name contains a codeset in unnormalized form.
|
|
We will store it in the archive with a normalized name. */
|
|
asprintf (&normalized_name, "%s%s%s.%s%s%s",
|
|
language, territory == NULL ? "" : "_", territory ?: "",
|
|
(mask & XPG_NORM_CODESET) ? normalized_codeset : codeset,
|
|
modifier == NULL ? "" : "@", modifier ?: "");
|
|
|
|
/* This call does the main work. */
|
|
locrec_offset = add_locale (ah, normalized_name ?: name, data, replace);
|
|
if (locrec_offset == 0)
|
|
{
|
|
free (normalized_name);
|
|
if (mask & XPG_NORM_CODESET)
|
|
free ((char *) normalized_codeset);
|
|
return -1;
|
|
}
|
|
|
|
if ((mask & XPG_CODESET) == 0)
|
|
{
|
|
/* This name lacks a codeset, so determine the locale's codeset and
|
|
add an alias for its name with normalized codeset appended. */
|
|
|
|
const struct
|
|
{
|
|
unsigned int magic;
|
|
unsigned int nstrings;
|
|
unsigned int strindex[0];
|
|
} *filedata = data[LC_CTYPE].addr;
|
|
codeset = (char *) filedata
|
|
+ maybe_swap_uint32 (filedata->strindex[_NL_ITEM_INDEX
|
|
(_NL_CTYPE_CODESET_NAME)]);
|
|
char *normalized_codeset_name = NULL;
|
|
|
|
normalized_codeset = _nl_normalize_codeset (codeset, strlen (codeset));
|
|
mask |= XPG_NORM_CODESET;
|
|
|
|
asprintf (&normalized_codeset_name, "%s%s%s.%s%s%s",
|
|
language, territory == NULL ? "" : "_", territory ?: "",
|
|
normalized_codeset,
|
|
modifier == NULL ? "" : "@", modifier ?: "");
|
|
|
|
add_alias (ah, normalized_codeset_name, replace,
|
|
normalized_name ?: name, &locrec_offset);
|
|
free (normalized_codeset_name);
|
|
}
|
|
|
|
/* Now read the locale.alias files looking for lines whose
|
|
right hand side matches our name after normalization. */
|
|
int result = 0;
|
|
if (alias_file != NULL)
|
|
{
|
|
FILE *fp;
|
|
fp = fopen (alias_file, "rm");
|
|
if (fp == NULL)
|
|
error (1, errno, _("locale alias file `%s' not found"),
|
|
alias_file);
|
|
|
|
/* No threads present. */
|
|
__fsetlocking (fp, FSETLOCKING_BYCALLER);
|
|
|
|
while (! feof_unlocked (fp))
|
|
{
|
|
/* It is a reasonable approach to use a fix buffer here
|
|
because
|
|
a) we are only interested in the first two fields
|
|
b) these fields must be usable as file names and so must
|
|
not be that long */
|
|
char buf[BUFSIZ];
|
|
char *alias;
|
|
char *value;
|
|
char *cp;
|
|
|
|
if (fgets_unlocked (buf, BUFSIZ, fp) == NULL)
|
|
/* EOF reached. */
|
|
break;
|
|
|
|
cp = buf;
|
|
/* Ignore leading white space. */
|
|
while (isspace (cp[0]) && cp[0] != '\n')
|
|
++cp;
|
|
|
|
/* A leading '#' signals a comment line. */
|
|
if (cp[0] != '\0' && cp[0] != '#' && cp[0] != '\n')
|
|
{
|
|
alias = cp++;
|
|
while (cp[0] != '\0' && !isspace (cp[0]))
|
|
++cp;
|
|
/* Terminate alias name. */
|
|
if (cp[0] != '\0')
|
|
*cp++ = '\0';
|
|
|
|
/* Now look for the beginning of the value. */
|
|
while (isspace (cp[0]))
|
|
++cp;
|
|
|
|
if (cp[0] != '\0')
|
|
{
|
|
value = cp++;
|
|
while (cp[0] != '\0' && !isspace (cp[0]))
|
|
++cp;
|
|
/* Terminate value. */
|
|
if (cp[0] == '\n')
|
|
{
|
|
/* This has to be done to make the following
|
|
test for the end of line possible. We are
|
|
looking for the terminating '\n' which do not
|
|
overwrite here. */
|
|
*cp++ = '\0';
|
|
*cp = '\n';
|
|
}
|
|
else if (cp[0] != '\0')
|
|
*cp++ = '\0';
|
|
|
|
/* Does this alias refer to our locale? We will
|
|
normalize the right hand side and compare the
|
|
elements of the normalized form. */
|
|
{
|
|
const char *rhs_language;
|
|
const char *rhs_modifier;
|
|
const char *rhs_territory;
|
|
const char *rhs_codeset;
|
|
const char *rhs_normalized_codeset;
|
|
int rhs_mask = _nl_explode_name (value,
|
|
&rhs_language,
|
|
&rhs_modifier,
|
|
&rhs_territory,
|
|
&rhs_codeset,
|
|
&rhs_normalized_codeset);
|
|
if (rhs_mask == -1)
|
|
{
|
|
result = -1;
|
|
goto out;
|
|
}
|
|
if (!strcmp (language, rhs_language)
|
|
&& ((rhs_mask & XPG_CODESET)
|
|
/* He has a codeset, it must match normalized. */
|
|
? !strcmp ((mask & XPG_NORM_CODESET)
|
|
? normalized_codeset : codeset,
|
|
(rhs_mask & XPG_NORM_CODESET)
|
|
? rhs_normalized_codeset : rhs_codeset)
|
|
/* He has no codeset, we must also have none. */
|
|
: (mask & XPG_CODESET) == 0)
|
|
/* Codeset (or lack thereof) matches. */
|
|
&& !strcmp (territory ?: "", rhs_territory ?: "")
|
|
&& !strcmp (modifier ?: "", rhs_modifier ?: ""))
|
|
/* We have a winner. */
|
|
add_alias (ah, alias, replace,
|
|
normalized_name ?: name, &locrec_offset);
|
|
if (rhs_mask & XPG_NORM_CODESET)
|
|
free ((char *) rhs_normalized_codeset);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Possibly not the whole line fits into the buffer.
|
|
Ignore the rest of the line. */
|
|
while (strchr (cp, '\n') == NULL)
|
|
{
|
|
cp = buf;
|
|
if (fgets_unlocked (buf, BUFSIZ, fp) == NULL)
|
|
/* Make sure the inner loop will be left. The outer
|
|
loop will exit at the `feof' test. */
|
|
*cp = '\n';
|
|
}
|
|
}
|
|
|
|
out:
|
|
fclose (fp);
|
|
}
|
|
|
|
free (normalized_name);
|
|
|
|
if (mask & XPG_NORM_CODESET)
|
|
free ((char *) normalized_codeset);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
int
|
|
add_locales_to_archive (size_t nlist, char *list[], bool replace)
|
|
{
|
|
struct locarhandle ah;
|
|
int result = 0;
|
|
|
|
/* Open the archive. This call never returns if we cannot
|
|
successfully open the archive. */
|
|
ah.fname = NULL;
|
|
open_archive (&ah, false);
|
|
|
|
while (nlist-- > 0)
|
|
{
|
|
const char *fname = *list++;
|
|
size_t fnamelen = strlen (fname);
|
|
struct stat64 st;
|
|
DIR *dirp;
|
|
struct dirent64 *d;
|
|
int seen;
|
|
locale_data_t data;
|
|
int cnt;
|
|
|
|
if (! be_quiet)
|
|
printf (_("Adding %s\n"), fname);
|
|
|
|
/* First see whether this really is a directory and whether it
|
|
contains all the require locale category files. */
|
|
if (stat64 (fname, &st) < 0)
|
|
{
|
|
error (0, 0, _("stat of \"%s\" failed: %s: ignored"), fname,
|
|
strerror (errno));
|
|
continue;
|
|
}
|
|
if (!S_ISDIR (st.st_mode))
|
|
{
|
|
error (0, 0, _("\"%s\" is no directory; ignored"), fname);
|
|
continue;
|
|
}
|
|
|
|
dirp = opendir (fname);
|
|
if (dirp == NULL)
|
|
{
|
|
error (0, 0, _("cannot open directory \"%s\": %s: ignored"),
|
|
fname, strerror (errno));
|
|
continue;
|
|
}
|
|
|
|
seen = 0;
|
|
while ((d = readdir64 (dirp)) != NULL)
|
|
{
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (cnt != LC_ALL)
|
|
if (strcmp (d->d_name, locnames[cnt]) == 0)
|
|
{
|
|
unsigned char d_type;
|
|
|
|
/* We have an object of the required name. If it's
|
|
a directory we have to look at a file with the
|
|
prefix "SYS_". Otherwise we have found what we
|
|
are looking for. */
|
|
#ifdef _DIRENT_HAVE_D_TYPE
|
|
d_type = d->d_type;
|
|
|
|
if (d_type != DT_REG)
|
|
#endif
|
|
{
|
|
char fullname[fnamelen + 2 * strlen (d->d_name) + 7];
|
|
|
|
#ifdef _DIRENT_HAVE_D_TYPE
|
|
if (d_type == DT_UNKNOWN)
|
|
#endif
|
|
{
|
|
strcpy (stpcpy (stpcpy (fullname, fname), "/"),
|
|
d->d_name);
|
|
|
|
if (stat64 (fullname, &st) == -1)
|
|
/* We cannot stat the file, ignore it. */
|
|
break;
|
|
|
|
d_type = IFTODT (st.st_mode);
|
|
}
|
|
|
|
if (d_type == DT_DIR)
|
|
{
|
|
/* We have to do more tests. The file is a
|
|
directory and it therefore must contain a
|
|
regular file with the same name except a
|
|
"SYS_" prefix. */
|
|
char *t = stpcpy (stpcpy (fullname, fname), "/");
|
|
strcpy (stpcpy (stpcpy (t, d->d_name), "/SYS_"),
|
|
d->d_name);
|
|
|
|
if (stat64 (fullname, &st) == -1)
|
|
/* There is no SYS_* file or we cannot
|
|
access it. */
|
|
break;
|
|
|
|
d_type = IFTODT (st.st_mode);
|
|
}
|
|
}
|
|
|
|
/* If we found a regular file (eventually after
|
|
following a symlink) we are successful. */
|
|
if (d_type == DT_REG)
|
|
++seen;
|
|
break;
|
|
}
|
|
}
|
|
|
|
closedir (dirp);
|
|
|
|
if (seen != __LC_LAST - 1)
|
|
{
|
|
/* We don't have all locale category files. Ignore the name. */
|
|
error (0, 0, _("incomplete set of locale files in \"%s\""),
|
|
fname);
|
|
continue;
|
|
}
|
|
|
|
/* Add the files to the archive. To do this we first compute
|
|
sizes and the MD5 sums of all the files. */
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (cnt != LC_ALL)
|
|
{
|
|
char fullname[fnamelen + 2 * strlen (locnames[cnt]) + 7];
|
|
int fd;
|
|
|
|
strcpy (stpcpy (stpcpy (fullname, fname), "/"), locnames[cnt]);
|
|
fd = open64 (fullname, O_RDONLY);
|
|
if (fd == -1 || fstat64 (fd, &st) == -1)
|
|
{
|
|
/* Cannot read the file. */
|
|
if (fd != -1)
|
|
close (fd);
|
|
break;
|
|
}
|
|
|
|
if (S_ISDIR (st.st_mode))
|
|
{
|
|
char *t;
|
|
close (fd);
|
|
t = stpcpy (stpcpy (fullname, fname), "/");
|
|
strcpy (stpcpy (stpcpy (t, locnames[cnt]), "/SYS_"),
|
|
locnames[cnt]);
|
|
|
|
fd = open64 (fullname, O_RDONLY);
|
|
if (fd == -1 || fstat64 (fd, &st) == -1
|
|
|| !S_ISREG (st.st_mode))
|
|
{
|
|
if (fd != -1)
|
|
close (fd);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Map the file. */
|
|
data[cnt].addr = mmap64 (NULL, st.st_size, PROT_READ, MAP_SHARED,
|
|
fd, 0);
|
|
if (data[cnt].addr == MAP_FAILED)
|
|
{
|
|
/* Cannot map it. */
|
|
close (fd);
|
|
break;
|
|
}
|
|
|
|
data[cnt].size = st.st_size;
|
|
__md5_buffer (data[cnt].addr, st.st_size, data[cnt].sum);
|
|
|
|
/* We don't need the file descriptor anymore. */
|
|
close (fd);
|
|
}
|
|
|
|
if (cnt != __LC_LAST)
|
|
{
|
|
while (cnt-- > 0)
|
|
if (cnt != LC_ALL)
|
|
munmap (data[cnt].addr, data[cnt].size);
|
|
|
|
error (0, 0, _("cannot read all files in \"%s\": ignored"), fname);
|
|
|
|
continue;
|
|
}
|
|
|
|
result |= add_locale_to_archive (&ah, basename (fname), data, replace);
|
|
|
|
for (cnt = 0; cnt < __LC_LAST; ++cnt)
|
|
if (cnt != LC_ALL)
|
|
munmap (data[cnt].addr, data[cnt].size);
|
|
}
|
|
|
|
/* We are done. */
|
|
close_archive (&ah);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
int
|
|
delete_locales_from_archive (size_t nlist, char *list[])
|
|
{
|
|
struct locarhandle ah;
|
|
struct locarhead *head;
|
|
struct namehashent *namehashtab;
|
|
|
|
/* Open the archive. This call never returns if we cannot
|
|
successfully open the archive. */
|
|
ah.fname = NULL;
|
|
open_archive (&ah, false);
|
|
|
|
head = ah.addr;
|
|
namehashtab = (struct namehashent *) ((char *) ah.addr
|
|
+ GET (head->namehash_offset));
|
|
|
|
while (nlist-- > 0)
|
|
{
|
|
const char *locname = *list++;
|
|
uint32_t hval;
|
|
unsigned int idx;
|
|
unsigned int incr;
|
|
|
|
/* Search for this locale in the archive. */
|
|
hval = archive_hashval (locname, strlen (locname));
|
|
|
|
idx = hval % GET (head->namehash_size);
|
|
incr = 1 + hval % (GET (head->namehash_size) - 2);
|
|
|
|
/* If the name_offset field is zero this means this is no
|
|
deleted entry and therefore no entry can be found. */
|
|
while (GET (namehashtab[idx].name_offset) != 0)
|
|
{
|
|
if (GET (namehashtab[idx].hashval) == hval
|
|
&& (strcmp (locname,
|
|
((char *) ah.addr
|
|
+ GET (namehashtab[idx].name_offset)))
|
|
== 0))
|
|
{
|
|
/* Found the entry. Now mark it as removed by zero-ing
|
|
the reference to the locale record. */
|
|
SET (namehashtab[idx].locrec_offset, 0);
|
|
break;
|
|
}
|
|
|
|
idx += incr;
|
|
if (idx >= GET (head->namehash_size))
|
|
idx -= GET (head->namehash_size);
|
|
}
|
|
|
|
if (GET (namehashtab[idx].name_offset) == 0 && ! be_quiet)
|
|
error (0, 0, _("locale \"%s\" not in archive"), locname);
|
|
}
|
|
|
|
close_archive (&ah);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct nameent
|
|
{
|
|
char *name;
|
|
uint32_t locrec_offset;
|
|
};
|
|
|
|
|
|
struct dataent
|
|
{
|
|
const unsigned char *sum;
|
|
uint32_t file_offset;
|
|
uint32_t nlink;
|
|
};
|
|
|
|
|
|
static int
|
|
nameentcmp (const void *a, const void *b)
|
|
{
|
|
return strcmp (((const struct nameent *) a)->name,
|
|
((const struct nameent *) b)->name);
|
|
}
|
|
|
|
|
|
static int
|
|
dataentcmp (const void *a, const void *b)
|
|
{
|
|
if (((const struct dataent *) a)->file_offset
|
|
< ((const struct dataent *) b)->file_offset)
|
|
return -1;
|
|
|
|
if (((const struct dataent *) a)->file_offset
|
|
> ((const struct dataent *) b)->file_offset)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void
|
|
show_archive_content (const char *fname, int verbose)
|
|
{
|
|
struct locarhandle ah;
|
|
struct locarhead *head;
|
|
struct namehashent *namehashtab;
|
|
struct nameent *names;
|
|
size_t cnt, used;
|
|
|
|
/* Open the archive. This call never returns if we cannot
|
|
successfully open the archive. */
|
|
ah.fname = fname;
|
|
open_archive (&ah, true);
|
|
|
|
head = ah.addr;
|
|
|
|
names = (struct nameent *) xmalloc (GET (head->namehash_used)
|
|
* sizeof (struct nameent));
|
|
|
|
namehashtab = (struct namehashent *) ((char *) ah.addr
|
|
+ GET (head->namehash_offset));
|
|
for (cnt = used = 0; cnt < GET (head->namehash_size); ++cnt)
|
|
if (GET (namehashtab[cnt].locrec_offset) != 0)
|
|
{
|
|
assert (used < GET (head->namehash_used));
|
|
names[used].name = ah.addr + GET (namehashtab[cnt].name_offset);
|
|
names[used++].locrec_offset = GET (namehashtab[cnt].locrec_offset);
|
|
}
|
|
|
|
/* Sort the names. */
|
|
qsort (names, used, sizeof (struct nameent), nameentcmp);
|
|
|
|
if (verbose)
|
|
{
|
|
struct dataent *files;
|
|
struct sumhashent *sumhashtab;
|
|
int sumused;
|
|
|
|
files = (struct dataent *) xmalloc (GET (head->sumhash_used)
|
|
* sizeof (struct dataent));
|
|
|
|
sumhashtab = (struct sumhashent *) ((char *) ah.addr
|
|
+ GET (head->sumhash_offset));
|
|
for (cnt = sumused = 0; cnt < GET (head->sumhash_size); ++cnt)
|
|
if (GET (sumhashtab[cnt].file_offset) != 0)
|
|
{
|
|
assert (sumused < GET (head->sumhash_used));
|
|
files[sumused].sum = (const unsigned char *) sumhashtab[cnt].sum;
|
|
files[sumused].file_offset = GET (sumhashtab[cnt].file_offset);
|
|
files[sumused++].nlink = 0;
|
|
}
|
|
|
|
/* Sort by file locations. */
|
|
qsort (files, sumused, sizeof (struct dataent), dataentcmp);
|
|
|
|
/* Compute nlink fields. */
|
|
for (cnt = 0; cnt < used; ++cnt)
|
|
{
|
|
struct locrecent *locrec;
|
|
int idx;
|
|
|
|
locrec = (struct locrecent *) ((char *) ah.addr
|
|
+ names[cnt].locrec_offset);
|
|
for (idx = 0; idx < __LC_LAST; ++idx)
|
|
if (GET (locrec->record[LC_ALL].offset) != 0
|
|
? (idx == LC_ALL
|
|
|| (GET (locrec->record[idx].offset)
|
|
< GET (locrec->record[LC_ALL].offset))
|
|
|| ((GET (locrec->record[idx].offset)
|
|
+ GET (locrec->record[idx].len))
|
|
> (GET (locrec->record[LC_ALL].offset)
|
|
+ GET (locrec->record[LC_ALL].len))))
|
|
: idx != LC_ALL)
|
|
{
|
|
struct dataent *data, dataent;
|
|
|
|
dataent.file_offset = GET (locrec->record[idx].offset);
|
|
data = (struct dataent *) bsearch (&dataent, files, sumused,
|
|
sizeof (struct dataent),
|
|
dataentcmp);
|
|
assert (data != NULL);
|
|
++data->nlink;
|
|
}
|
|
}
|
|
|
|
/* Print it. */
|
|
for (cnt = 0; cnt < used; ++cnt)
|
|
{
|
|
struct locrecent *locrec;
|
|
int idx, i;
|
|
|
|
locrec = (struct locrecent *) ((char *) ah.addr
|
|
+ names[cnt].locrec_offset);
|
|
for (idx = 0; idx < __LC_LAST; ++idx)
|
|
if (idx != LC_ALL)
|
|
{
|
|
struct dataent *data, dataent;
|
|
|
|
dataent.file_offset = GET (locrec->record[idx].offset);
|
|
if (GET (locrec->record[LC_ALL].offset) != 0
|
|
&& (dataent.file_offset
|
|
>= GET (locrec->record[LC_ALL].offset))
|
|
&& (dataent.file_offset + GET (locrec->record[idx].len)
|
|
<= (GET (locrec->record[LC_ALL].offset)
|
|
+ GET (locrec->record[LC_ALL].len))))
|
|
dataent.file_offset = GET (locrec->record[LC_ALL].offset);
|
|
|
|
data = (struct dataent *) bsearch (&dataent, files, sumused,
|
|
sizeof (struct dataent),
|
|
dataentcmp);
|
|
printf ("%6d %7x %3d%c ",
|
|
GET (locrec->record[idx].len),
|
|
GET (locrec->record[idx].offset),
|
|
data->nlink,
|
|
(dataent.file_offset
|
|
== GET (locrec->record[LC_ALL].offset))
|
|
? '+' : ' ');
|
|
for (i = 0; i < 16; i += 4)
|
|
printf ("%02x%02x%02x%02x",
|
|
data->sum[i], data->sum[i + 1],
|
|
data->sum[i + 2], data->sum[i + 3]);
|
|
printf (" %s/%s\n", names[cnt].name,
|
|
idx == LC_MESSAGES ? "LC_MESSAGES/SYS_LC_MESSAGES"
|
|
: locnames[idx]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
for (cnt = 0; cnt < used; ++cnt)
|
|
puts (names[cnt].name);
|
|
|
|
close_archive (&ah);
|
|
|
|
exit (EXIT_SUCCESS);
|
|
}
|