Back to index

glibc  2.9
Functions | Variables
locfile.c File Reference
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/stat.h>
#include "../../crypt/md5.h"
#include "localedef.h"
#include "locfile.h"
#include "simple-hash.h"
#include "locfile-kw.h"

Go to the source code of this file.

Functions

int locfile_read (struct localedef_t *result, const struct charmap_t *charmap)
void check_all_categories (struct localedef_t *definitions, const struct charmap_t *charmap)
void write_all_categories (struct localedef_t *definitions, const struct charmap_t *charmap, const char *locname, const char *output_path)
static const char ** siblings_uncached (const char *output_path)
static const char ** siblings (const char *output_path)
static ssize_t full_read (int fd, void *bufarea, size_t nbyte)
static int compare_files (const char *filename1, const char *filename2, size_t size, size_t blocksize)
void write_locale_data (const char *output_path, int catidx, const char *category, size_t n_elem, struct iovec *vec)
void handle_copy (struct linereader *ldfile, const struct charmap_t *charmap, const char *repertoire_name, struct localedef_t *result, enum token_t token, int locale, const char *locale_name, int ignore_content)

Variables

static locale_data_t to_archive
static void(*const check_funcs [])(struct localedef_t *, const struct charmap_t *)
static void(*const write_funcs [])(struct localedef_t *, const struct charmap_t *, const char *)

Function Documentation

void check_all_categories ( struct localedef_t definitions,
const struct charmap_t charmap 
)

Definition at line 292 of file locfile.c.

{
  int cnt;

  for (cnt = 0; cnt < sizeof (check_funcs) / sizeof (check_funcs[0]); ++cnt)
    if (check_funcs[cnt] != NULL)
      check_funcs[cnt] (definitions, charmap);
}

Here is the caller graph for this function:

static int compare_files ( const char *  filename1,
const char *  filename2,
size_t  size,
size_t  blocksize 
) [static]

Definition at line 491 of file locfile.c.

{
  int fd1, fd2;
  int ret = -1;

  fd1 = open (filename1, O_RDONLY);
  if (fd1 >= 0)
    {
      fd2 = open (filename2, O_RDONLY);
      if (fd2 >= 0)
       {
         char *buf1 = (char *) xmalloc (2 * blocksize);
         char *buf2 = buf1 + blocksize;

         ret = 0;
         while (size > 0)
           {
             size_t bytes = (size < blocksize ? size : blocksize);

             if (full_read (fd1, buf1, bytes) < (ssize_t) bytes)
              {
                ret = -1;
                break;
              }
             if (full_read (fd2, buf2, bytes) < (ssize_t) bytes)
              {
                ret = -1;
                break;
              }
             if (memcmp (buf1, buf2, bytes) != 0)
              {
                ret = 1;
                break;
              }
             size -= bytes;
           }

         free (buf1);
         close (fd2);
       }
      close (fd1);
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ssize_t full_read ( int  fd,
void *  bufarea,
size_t  nbyte 
) [static]

Definition at line 466 of file locfile.c.

{
  char *buf = (char *) bufarea;

  while (nbyte > 0)
    {
      ssize_t retval = read (fd, buf, nbyte);

      if (retval == 0)
       break;
      else if (retval > 0)
       {
         buf += retval;
         nbyte -= retval;
       }
      else if (errno != EINTR)
       return retval;
    }
  return buf - (char *) bufarea;
}

Here is the caller graph for this function:

void handle_copy ( struct linereader ldfile,
const struct charmap_t charmap,
const char *  repertoire_name,
struct localedef_t result,
enum token_t  token,
int  locale,
const char *  locale_name,
int  ignore_content 
)

Definition at line 772 of file locfile.c.

{
  struct token *now;
  int warned = 0;

  now = lr_token (ldfile, charmap, result, NULL, verbose);
  if (now->tok != tok_string)
    lr_error (ldfile, _("expecting string argument for `copy'"));
  else if (!ignore_content)
    {
      if (now->val.str.startmb == NULL)
       lr_error (ldfile, _("\
locale name should consist only of portable characters"));
      else
       {
         (void) add_to_readlist (locale, now->val.str.startmb,
                              repertoire_name, 1, NULL);
         result->copy_name[locale] = now->val.str.startmb;
       }
    }

  lr_ignore_rest (ldfile, now->tok == tok_string);

  /* The rest of the line must be empty and the next keyword must be
     `END xxx'.  */
  while ((now = lr_token (ldfile, charmap, result, NULL, verbose))->tok
        != tok_end && now->tok != tok_eof)
    {
      if (warned == 0)
       {
         lr_error (ldfile, _("\
no other keyword shall be specified when `copy' is used"));
         warned = 1;
       }

      lr_ignore_rest (ldfile, 0);
    }

  if (now->tok != tok_eof)
    {
      /* Handle `END xxx'.  */
      now = lr_token (ldfile, charmap, result, NULL, verbose);

      if (now->tok != token)
       lr_error (ldfile, _("\
`%1$s' definition does not end with `END %1$s'"), locale_name);

      lr_ignore_rest (ldfile, now->tok == token);
    }
  else
    /* When we come here we reached the end of the file.  */
    lr_error (ldfile, _("%s: premature end of file"), locale_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int locfile_read ( struct localedef_t result,
const struct charmap_t charmap 
)

Definition at line 45 of file locfile.c.

{
  const char *filename = result->name;
  const char *repertoire_name = result->repertoire_name;
  int locale_mask = result->needed & ~result->avail;
  struct linereader *ldfile;
  int not_here = ALL_LOCALES;

  /* If no repertoire name was specified use the global one.  */
  if (repertoire_name == NULL)
    repertoire_name = repertoire_global;

  /* Open the locale definition file.  */
  ldfile = lr_open (filename, locfile_hash);
  if (ldfile == NULL)
    {
      if (filename != NULL && filename[0] != '/')
       {
         char *i18npath = getenv ("I18NPATH");
         if (i18npath != NULL && *i18npath != '\0')
           {
             const size_t pathlen = strlen (i18npath);
             char i18npathbuf[pathlen + 1];
             char path[strlen (filename) + 1 + pathlen
                     + sizeof ("/locales/") - 1];
             char *next;
             i18npath = memcpy (i18npathbuf, i18npath, pathlen + 1);

             while (ldfile == NULL
                   && (next = strsep (&i18npath, ":")) != NULL)
              {
                stpcpy (stpcpy (stpcpy (path, next), "/locales/"), filename);

                ldfile = lr_open (path, locfile_hash);

                if (ldfile == NULL)
                  {
                    stpcpy (stpcpy (path, next), filename);

                    ldfile = lr_open (path, locfile_hash);
                  }
              }
           }

         /* Test in the default directory.  */
         if (ldfile == NULL)
           {
             char path[strlen (filename) + 1 + sizeof (LOCSRCDIR)];

             stpcpy (stpcpy (stpcpy (path, LOCSRCDIR), "/"), filename);
             ldfile = lr_open (path, locfile_hash);
           }
       }

      if (ldfile == NULL)
       return 1;
    }

    /* Parse locale definition file and store result in RESULT.  */
  while (1)
    {
      struct token *now = lr_token (ldfile, charmap, NULL, NULL, verbose);
      enum token_t nowtok = now->tok;
      struct token *arg;

      if (nowtok == tok_eof)
       break;

      if (nowtok == tok_eol)
       /* Ignore empty lines.  */
       continue;

      switch (nowtok)
       {
       case tok_escape_char:
       case tok_comment_char:
         /* We need an argument.  */
         arg = lr_token (ldfile, charmap, NULL, NULL, verbose);

         if (arg->tok != tok_ident)
           {
             SYNTAX_ERROR (_("bad argument"));
             continue;
           }

         if (arg->val.str.lenmb != 1)
           {
             lr_error (ldfile, _("\
argument to `%s' must be a single character"),
                     nowtok == tok_escape_char
                     ? "escape_char" : "comment_char");

             lr_ignore_rest (ldfile, 0);
             continue;
           }

         if (nowtok == tok_escape_char)
           ldfile->escape_char = *arg->val.str.startmb;
         else
           ldfile->comment_char = *arg->val.str.startmb;
         break;

       case tok_repertoiremap:
         /* We need an argument.  */
         arg = lr_token (ldfile, charmap, NULL, NULL, verbose);

         if (arg->tok != tok_ident)
           {
             SYNTAX_ERROR (_("bad argument"));
             continue;
           }

         if (repertoire_name == NULL)
           {
             char *newp = alloca (arg->val.str.lenmb + 1);

             *((char *) mempcpy (newp, arg->val.str.startmb,
                              arg->val.str.lenmb)) = '\0';
             repertoire_name = newp;
           }
         break;

       case tok_lc_ctype:
         ctype_read (ldfile, result, charmap, repertoire_name,
                    (locale_mask & CTYPE_LOCALE) == 0);
         result->avail |= locale_mask & CTYPE_LOCALE;
         not_here ^= CTYPE_LOCALE;
         continue;

       case tok_lc_collate:
         collate_read (ldfile, result, charmap, repertoire_name,
                     (locale_mask & COLLATE_LOCALE) == 0);
         result->avail |= locale_mask & COLLATE_LOCALE;
         not_here ^= COLLATE_LOCALE;
         continue;

       case tok_lc_monetary:
         monetary_read (ldfile, result, charmap, repertoire_name,
                      (locale_mask & MONETARY_LOCALE) == 0);
         result->avail |= locale_mask & MONETARY_LOCALE;
         not_here ^= MONETARY_LOCALE;
         continue;

       case tok_lc_numeric:
         numeric_read (ldfile, result, charmap, repertoire_name,
                     (locale_mask & NUMERIC_LOCALE) == 0);
         result->avail |= locale_mask & NUMERIC_LOCALE;
         not_here ^= NUMERIC_LOCALE;
         continue;

       case tok_lc_time:
         time_read (ldfile, result, charmap, repertoire_name,
                   (locale_mask & TIME_LOCALE) == 0);
         result->avail |= locale_mask & TIME_LOCALE;
         not_here ^= TIME_LOCALE;
         continue;

       case tok_lc_messages:
         messages_read (ldfile, result, charmap, repertoire_name,
                      (locale_mask & MESSAGES_LOCALE) == 0);
         result->avail |= locale_mask & MESSAGES_LOCALE;
         not_here ^= MESSAGES_LOCALE;
         continue;

       case tok_lc_paper:
         paper_read (ldfile, result, charmap, repertoire_name,
                    (locale_mask & PAPER_LOCALE) == 0);
         result->avail |= locale_mask & PAPER_LOCALE;
         not_here ^= PAPER_LOCALE;
         continue;

       case tok_lc_name:
         name_read (ldfile, result, charmap, repertoire_name,
                   (locale_mask & NAME_LOCALE) == 0);
         result->avail |= locale_mask & NAME_LOCALE;
         not_here ^= NAME_LOCALE;
         continue;

       case tok_lc_address:
         address_read (ldfile, result, charmap, repertoire_name,
                     (locale_mask & ADDRESS_LOCALE) == 0);
         result->avail |= locale_mask & ADDRESS_LOCALE;
         not_here ^= ADDRESS_LOCALE;
         continue;

       case tok_lc_telephone:
         telephone_read (ldfile, result, charmap, repertoire_name,
                       (locale_mask & TELEPHONE_LOCALE) == 0);
         result->avail |= locale_mask & TELEPHONE_LOCALE;
         not_here ^= TELEPHONE_LOCALE;
         continue;

       case tok_lc_measurement:
         measurement_read (ldfile, result, charmap, repertoire_name,
                         (locale_mask & MEASUREMENT_LOCALE) == 0);
         result->avail |= locale_mask & MEASUREMENT_LOCALE;
         not_here ^= MEASUREMENT_LOCALE;
         continue;

       case tok_lc_identification:
         identification_read (ldfile, result, charmap, repertoire_name,
                            (locale_mask & IDENTIFICATION_LOCALE) == 0);
         result->avail |= locale_mask & IDENTIFICATION_LOCALE;
         not_here ^= IDENTIFICATION_LOCALE;
         continue;

       default:
         SYNTAX_ERROR (_("\
syntax error: not inside a locale definition section"));
         continue;
       }

      /* The rest of the line must be empty.  */
      lr_ignore_rest (ldfile, 1);
    }

  /* We read all of the file.  */
  lr_close (ldfile);

  /* Mark the categories which are not contained in the file.  We assume
     them to be available and the default data will be used.  */
  result->avail |= not_here;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char** siblings ( const char *  output_path) [static]

Definition at line 441 of file locfile.c.

{
  static const char *last_output_path;
  static const char **last_result;

  if (output_path != last_output_path)
    {
      if (last_result != NULL)
       {
         const char **p;

         for (p = last_result; *p != NULL; p++)
           free ((char *) *p);
         free (last_result);
       }

      last_output_path = output_path;
      last_result = siblings_uncached (output_path);
    }
  return last_result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char** siblings_uncached ( const char *  output_path) [static]

Definition at line 355 of file locfile.c.

{
  size_t len;
  char *base, *p;
  struct stat output_stat;
  DIR *dirp;
  int nelems;
  const char **elems;

  /* Remove trailing slashes and trailing pathname component.  */
  len = strlen (output_path);
  base = (char *) alloca (len);
  memcpy (base, output_path, len);
  p = base + len;
  while (p > base && p[-1] == '/')
    p--;
  if (p == base)
    return NULL;
  do
    p--;
  while (p > base && p[-1] != '/');
  if (p == base)
    return NULL;
  *--p = '\0';
  len = p - base;

  /* Get the properties of output_path.  */
  if (lstat (output_path, &output_stat) < 0 || !S_ISDIR (output_stat.st_mode))
    return NULL;

  /* Iterate through the directories in base directory.  */
  dirp = opendir (base);
  if (dirp == NULL)
    return NULL;
  nelems = 0;
  elems = NULL;
  for (;;)
    {
      struct dirent64 *other_dentry;
      const char *other_name;
      char *other_path;
      struct stat other_stat;

      other_dentry = readdir64 (dirp);
      if (other_dentry == NULL)
       break;

      other_name = other_dentry->d_name;
      if (strcmp (other_name, ".") == 0 || strcmp (other_name, "..") == 0)
       continue;

      other_path = (char *) xmalloc (len + 1 + strlen (other_name) + 2);
      memcpy (other_path, base, len);
      other_path[len] = '/';
      strcpy (other_path + len + 1, other_name);

      if (lstat (other_path, &other_stat) >= 0
         && S_ISDIR (other_stat.st_mode)
         && other_stat.st_uid == output_stat.st_uid
         && other_stat.st_gid == output_stat.st_gid
         && other_stat.st_mode == output_stat.st_mode
         && other_stat.st_dev == output_stat.st_dev)
       {
         /* Found a subdirectory.  Add a trailing slash and store it.  */
         p = other_path + len + 1 + strlen (other_name);
         *p++ = '/';
         *p = '\0';
         elems = (const char **) xrealloc ((char *) elems,
                                       (nelems + 2) * sizeof (char **));
         elems[nelems++] = other_path;
       }
      else
       free (other_path);
    }
  closedir (dirp);

  if (elems != NULL)
    elems[nelems] = NULL;
  return elems;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_all_categories ( struct localedef_t definitions,
const struct charmap_t charmap,
const char *  locname,
const char *  output_path 
)

Definition at line 324 of file locfile.c.

{
  int cnt;

  for (cnt = 0; cnt < sizeof (write_funcs) / sizeof (write_funcs[0]); ++cnt)
    if (write_funcs[cnt] != NULL)
      write_funcs[cnt] (definitions, charmap, output_path);

  if (! no_archive)
    {
      /* The data has to be added to the archive.  Do this now.  */
      struct locarhandle ah;

      /* Open the archive.  This call never returns if we cannot
        successfully open the archive.  */
      open_archive (&ah, false);

      if (add_locale_to_archive (&ah, locname, to_archive, true) != 0)
       error (EXIT_FAILURE, errno, _("cannot add to locale archive"));

      /* We are done.  */
      close_archive (&ah);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_locale_data ( const char *  output_path,
int  catidx,
const char *  category,
size_t  n_elem,
struct iovec vec 
)

Definition at line 540 of file locfile.c.

{
  size_t cnt, step, maxiov;
  int fd;
  char *fname;
  const char **other_paths;

  if (! no_archive)
    {
      /* The data will be added to the archive.  For now we simply
        generate the image which will be written.  First determine
        the size.  */
      int cnt;
      void *endp;

      to_archive[catidx].size = 0;
      for (cnt = 0; cnt < n_elem; ++cnt)
       to_archive[catidx].size += vec[cnt].iov_len;

      /* Allocate the memory for it.  */
      to_archive[catidx].addr = xmalloc (to_archive[catidx].size);

      /* Fill it in.  */
      for (cnt = 0, endp = to_archive[catidx].addr; cnt < n_elem; ++cnt)
       endp = mempcpy (endp, vec[cnt].iov_base, vec[cnt].iov_len);

      /* Compute the MD5 sum for the data.  */
      __md5_buffer (to_archive[catidx].addr, to_archive[catidx].size,
                  to_archive[catidx].sum);

      return;
    }

  fname = xmalloc (strlen (output_path) + 2 * strlen (category) + 7);

  /* Normally we write to the directory pointed to by the OUTPUT_PATH.
     But for LC_MESSAGES we have to take care for the translation
     data.  This means we need to have a directory LC_MESSAGES in
     which we place the file under the name SYS_LC_MESSAGES.  */
  sprintf (fname, "%s%s", output_path, category);
  fd = -2;
  if (strcmp (category, "LC_MESSAGES") == 0)
    {
      struct stat st;

      if (stat (fname, &st) < 0)
       {
         if (mkdir (fname, 0777) >= 0)
           {
             fd = -1;
             errno = EISDIR;
           }
       }
      else if (!S_ISREG (st.st_mode))
       {
         fd = -1;
         errno = EISDIR;
       }
    }

  /* Create the locale file with nlinks == 1; this avoids crashing processes
     which currently use the locale and damaging files belonging to other
     locales as well.  */
  if (fd == -2)
    {
      unlink (fname);
      fd = creat (fname, 0666);
    }

  if (fd == -1)
    {
      int save_err = errno;

      if (errno == EISDIR)
       {
         sprintf (fname, "%1$s%2$s/SYS_%2$s", output_path, category);
         unlink (fname);
         fd = creat (fname, 0666);
         if (fd == -1)
           save_err = errno;
       }

      if (fd == -1)
       {
         if (!be_quiet)
           WITH_CUR_LOCALE (error (0, save_err, _("\
cannot open output file `%s' for category `%s'"), fname, category));
         free (fname);
         return;
       }
    }

#ifdef UIO_MAXIOV
  maxiov = UIO_MAXIOV;
#else
  maxiov = sysconf (_SC_UIO_MAXIOV);
#endif

  /* Write the data using writev.  But we must take care for the
     limitation of the implementation.  */
  for (cnt = 0; cnt < n_elem; cnt += step)
    {
      step = n_elem - cnt;
      if (maxiov > 0)
       step = MIN (maxiov, step);

      if (writev (fd, &vec[cnt], step) < 0)
       {
         if (!be_quiet)
           WITH_CUR_LOCALE (error (0, errno, _("\
failure while writing data for category `%s'"), category));
         break;
       }
    }

  close (fd);

  /* Compare the file with the locale data files for the same category in
     other locales, and see if we can reuse it, to save disk space.  */
  other_paths = siblings (output_path);
  if (other_paths != NULL)
    {
      struct stat fname_stat;

      if (lstat (fname, &fname_stat) >= 0
         && S_ISREG (fname_stat.st_mode))
       {
         const char *fname_tail = fname + strlen (output_path);
         const char **other_p;
         int seen_count;
         ino_t *seen_inodes;

         seen_count = 0;
         for (other_p = other_paths; *other_p; other_p++)
           seen_count++;
         seen_inodes = (ino_t *) xmalloc (seen_count * sizeof (ino_t));
         seen_count = 0;

         for (other_p = other_paths; *other_p; other_p++)
           {
             const char *other_path = *other_p;
             size_t other_path_len = strlen (other_path);
             char *other_fname;
             struct stat other_fname_stat;

             other_fname =
              (char *) xmalloc (other_path_len + strlen (fname_tail) + 1);
             memcpy (other_fname, other_path, other_path_len);
             strcpy (other_fname + other_path_len, fname_tail);

             if (lstat (other_fname, &other_fname_stat) >= 0
                && S_ISREG (other_fname_stat.st_mode)
                /* Consider only files on the same device.
                   Otherwise hard linking won't work anyway.  */
                && other_fname_stat.st_dev == fname_stat.st_dev
                /* Consider only files with the same permissions.
                   Otherwise there are security risks.  */
                && other_fname_stat.st_uid == fname_stat.st_uid
                && other_fname_stat.st_gid == fname_stat.st_gid
                && other_fname_stat.st_mode == fname_stat.st_mode
                /* Don't compare fname with itself.  */
                && other_fname_stat.st_ino != fname_stat.st_ino
                /* Files must have the same size, otherwise they
                   cannot be the same.  */
                && other_fname_stat.st_size == fname_stat.st_size)
              {
                /* Skip this file if we have already read it (under a
                   different name).  */
                int i;

                for (i = seen_count - 1; i >= 0; i--)
                  if (seen_inodes[i] == other_fname_stat.st_ino)
                    break;
                if (i < 0)
                  {
                    /* Now compare fname and other_fname for real.  */
                    blksize_t blocksize;

#ifdef _STATBUF_ST_BLKSIZE
                    blocksize = MAX (fname_stat.st_blksize,
                                   other_fname_stat.st_blksize);
                    if (blocksize > 8 * 1024)
                     blocksize = 8 * 1024;
#else
                    blocksize = 8 * 1024;
#endif

                    if (compare_files (fname, other_fname,
                                    fname_stat.st_size, blocksize) == 0)
                     {
                       /* Found! other_fname is identical to fname.  */
                       /* Link other_fname to fname.  But use a temporary
                          file, in case hard links don't work on the
                          particular filesystem.  */
                       char * tmp_fname =
                         (char *) xmalloc (strlen (fname) + 4 + 1);

                       strcpy (stpcpy (tmp_fname, fname), ".tmp");

                       if (link (other_fname, tmp_fname) >= 0)
                         {
                           unlink (fname);
                           if (rename (tmp_fname, fname) < 0)
                            {
                              if (!be_quiet)
                                WITH_CUR_LOCALE (error (0, errno, _("\
cannot create output file `%s' for category `%s'"), fname, category));
                            }
                           free (tmp_fname);
                           free (other_fname);
                           break;
                         }
                       free (tmp_fname);
                     }

                    /* Don't compare with this file a second time.  */
                    seen_inodes[seen_count++] = other_fname_stat.st_ino;
                  }
              }
             free (other_fname);
           }
         free (seen_inodes);
       }
    }

  free (fname);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

void(*const check_funcs[])(struct localedef_t *, const struct charmap_t *) [static]

Definition at line 41 of file locfile.c.

void(*const write_funcs[])(struct localedef_t *, const struct charmap_t *, const char *) [static]