Back to index

glibc  2.9
Defines | Functions | Variables
gconv_conf.c File Reference
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <locale.h>
#include <search.h>
#include <stddef.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include <bits/libc-lock.h>
#include <gconv_int.h>
#include "gconv_builtin.h"

Go to the source code of this file.

Defines

#define MODULE_EXT   ".so"
#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, BtowcFct, MinF, MaxF, MinT, MaxT)
#define BUILTIN_ALIAS(From, To)
#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, BtowcFct, MinF, MaxF, MinT, MaxT)
#define BUILTIN_ALIAS(From, To)   From "\0" To "\0"

Functions

static int internal_function detect_conflict (const char *alias)
static void add_alias2 (const char *from, const char *to, const char *wp, void *modules)
static void add_alias (char *rp, void *modules)
static void internal_function insert_module (struct gconv_module *newp, int tobefreed)
static void internal_function add_module (char *rp, const char *directory, size_t dir_len, void **modules, size_t *nmodules, int modcounter)
static void internal_function read_conf_file (const char *filename, const char *directory, size_t dir_len, void **modules, size_t *nmodules)
void internal_function __gconv_get_path (void)
void attribute_hidden __gconv_read_conf (void)
 libc_freeres_fn (free_mem)

Variables

static const char default_gconv_path [] = GCONV_PATH
struct path_elem__gconv_path_elem
size_t __gconv_max_path_elem_len
static struct path_elem = { NULL, 0 }
static const char gconv_conf_filename [] = "gconv-modules"
static const char gconv_module_ext [] = MODULE_EXT
static struct gconv_module []
static const char builtin_aliases []
const char * __gconv_path_envvar

Define Documentation

#define BUILTIN_ALIAS (   From,
  To 
)
#define BUILTIN_ALIAS (   From,
  To 
)    From "\0" To "\0"
#define BUILTIN_TRANSFORMATION (   From,
  To,
  Cost,
  Name,
  Fct,
  BtowcFct,
  MinF,
  MaxF,
  MinT,
  MaxT 
)
Value:
{                                                                    \
    .from_string = From,                                             \
    .to_string = To,                                                 \
    .cost_hi = Cost,                                                 \
    .cost_lo = INT_MAX,                                                     \
    .module_name = Name                                                     \
  },
#define BUILTIN_TRANSFORMATION (   From,
  To,
  Cost,
  Name,
  Fct,
  BtowcFct,
  MinF,
  MaxF,
  MinT,
  MaxT 
)
#define MODULE_EXT   ".so"

Definition at line 57 of file gconv_conf.c.


Function Documentation

Definition at line 432 of file gconv_conf.c.

{
  struct path_elem *result;
  __libc_lock_define_initialized (static, lock);

  __libc_lock_lock (lock);

  /* Make sure there wasn't a second thread doing it already.  */
  result = (struct path_elem *) __gconv_path_elem;
  if (result == NULL)
    {
      /* Determine the complete path first.  */
      char *gconv_path;
      size_t gconv_path_len;
      char *elem;
      char *oldp;
      char *cp;
      int nelems;
      char *cwd;
      size_t cwdlen;

      if (__gconv_path_envvar == NULL)
       {
         /* No user-defined path.  Make a modifiable copy of the
            default path.  */
         gconv_path = strdupa (default_gconv_path);
         gconv_path_len = sizeof (default_gconv_path);
         cwd = NULL;
         cwdlen = 0;
       }
      else
       {
         /* Append the default path to the user-defined path.  */
         size_t user_len = strlen (__gconv_path_envvar);

         gconv_path_len = user_len + 1 + sizeof (default_gconv_path);
         gconv_path = alloca (gconv_path_len);
         __mempcpy (__mempcpy (__mempcpy (gconv_path, __gconv_path_envvar,
                                      user_len),
                            ":", 1),
                   default_gconv_path, sizeof (default_gconv_path));
         cwd = __getcwd (NULL, 0);
         cwdlen = strlen (cwd);
       }
      assert (default_gconv_path[0] == '/');

      /* In a first pass we calculate the number of elements.  */
      oldp = NULL;
      cp = strchr (gconv_path, ':');
      nelems = 1;
      while (cp != NULL)
       {
         if (cp != oldp + 1)
           ++nelems;
         oldp = cp;
         cp =  strchr (cp + 1, ':');
       }

      /* Allocate the memory for the result.  */
      result = (struct path_elem *) malloc ((nelems + 1)
                                       * sizeof (struct path_elem)
                                       + gconv_path_len + nelems
                                       + (nelems - 1) * (cwdlen + 1));
      if (result != NULL)
       {
         char *strspace = (char *) &result[nelems + 1];
         int n = 0;

         /* Separate the individual parts.  */
         __gconv_max_path_elem_len = 0;
         elem = __strtok_r (gconv_path, ":", &gconv_path);
         assert (elem != NULL);
         do
           {
             result[n].name = strspace;
             if (elem[0] != '/')
              {
                assert (cwd != NULL);
                strspace = __mempcpy (strspace, cwd, cwdlen);
                *strspace++ = '/';
              }
             strspace = __stpcpy (strspace, elem);
             if (strspace[-1] != '/')
              *strspace++ = '/';

             result[n].len = strspace - result[n].name;
             if (result[n].len > __gconv_max_path_elem_len)
              __gconv_max_path_elem_len = result[n].len;

             *strspace++ = '\0';
             ++n;
           }
         while ((elem = __strtok_r (NULL, ":", &gconv_path)) != NULL);

         result[n].name = NULL;
         result[n].len = 0;
       }

      __gconv_path_elem = result ?: (struct path_elem *) &empty_path_elem;

      free (cwd);
    }

  __libc_lock_unlock (lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 543 of file gconv_conf.c.

{
  void *modules = NULL;
  size_t nmodules = 0;
  int save_errno = errno;
  size_t cnt;

  /* First see whether we should use the cache.  */
  if (__gconv_load_cache () == 0)
    {
      /* Yes, we are done.  */
      __set_errno (save_errno);
      return;
    }

#ifndef STATIC_GCONV
  /* Find out where we have to look.  */
  if (__gconv_path_elem == NULL)
    __gconv_get_path ();

  for (cnt = 0; __gconv_path_elem[cnt].name != NULL; ++cnt)
    {
      const char *elem = __gconv_path_elem[cnt].name;
      size_t elem_len = __gconv_path_elem[cnt].len;
      char *filename;

      /* No slash needs to be inserted between elem and gconv_conf_filename;
        elem already ends in a slash.  */
      filename = alloca (elem_len + sizeof (gconv_conf_filename));
      __mempcpy (__mempcpy (filename, elem, elem_len),
               gconv_conf_filename, sizeof (gconv_conf_filename));

      /* Read the next configuration file.  */
      read_conf_file (filename, elem, elem_len, &modules, &nmodules);
    }
#endif

  /* Add the internal modules.  */
  for (cnt = 0; cnt < sizeof (builtin_modules) / sizeof (builtin_modules[0]);
       ++cnt)
    {
      struct gconv_alias fake_alias;

      fake_alias.fromname = (char *) builtin_modules[cnt].from_string;

      if (__tfind (&fake_alias, &__gconv_alias_db, __gconv_alias_compare)
         != NULL)
       /* It'll conflict so don't add it.  */
       continue;

      insert_module (&builtin_modules[cnt], 0);
    }

  /* Add aliases for builtin conversions.  */
  const char *cp = builtin_aliases;
  do
    {
      const char *from = cp;
      const char *to = __rawmemchr (from, '\0') + 1;
      cp = __rawmemchr (to, '\0') + 1;

      add_alias2 (from, to, cp, modules);
    }
  while (*cp != '\0');

  /* Restore the error number.  */
  __set_errno (save_errno);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_alias ( char *  rp,
void *  modules 
) [static]

Definition at line 158 of file gconv_conf.c.

{
  /* We now expect two more string.  The strings are normalized
     (converted to UPPER case) and strored in the alias database.  */
  char *from, *to, *wp;

  while (__isspace_l (*rp, _nl_C_locobj_ptr))
    ++rp;
  from = wp = rp;
  while (*rp != '\0' && !__isspace_l (*rp, _nl_C_locobj_ptr))
    *wp++ = __toupper_l (*rp++, _nl_C_locobj_ptr);
  if (*rp == '\0')
    /* There is no `to' string on the line.  Ignore it.  */
    return;
  *wp++ = '\0';
  to = ++rp;
  while (__isspace_l (*rp, _nl_C_locobj_ptr))
    ++rp;
  while (*rp != '\0' && !__isspace_l (*rp, _nl_C_locobj_ptr))
    *wp++ = __toupper_l (*rp++, _nl_C_locobj_ptr);
  if (to == wp)
    /* No `to' string, ignore the line.  */
    return;
  *wp++ = '\0';

  add_alias2 (from, to, wp, modules);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_alias2 ( const char *  from,
const char *  to,
const char *  wp,
void *  modules 
) [static]

Definition at line 129 of file gconv_conf.c.

{
  /* Test whether this alias conflicts with any available module.  */
  if (detect_conflict (from))
    /* It does conflict, don't add the alias.  */
    return;

  struct gconv_alias *new_alias = (struct gconv_alias *)
    malloc (sizeof (struct gconv_alias) + (wp - from));
  if (new_alias != NULL)
    {
      void **inserted;

      new_alias->fromname = memcpy ((char *) new_alias
                                + sizeof (struct gconv_alias),
                                from, wp - from);
      new_alias->toname = new_alias->fromname + (to - from);

      inserted = (void **) __tsearch (new_alias, &__gconv_alias_db,
                                  __gconv_alias_compare);
      if (inserted == NULL || *inserted != new_alias)
       /* Something went wrong, free this entry.  */
       free (new_alias);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void internal_function add_module ( char *  rp,
const char *  directory,
size_t  dir_len,
void **  modules,
size_t nmodules,
int  modcounter 
) [static]

Definition at line 249 of file gconv_conf.c.

{
  /* We expect now
     1. `from' name
     2. `to' name
     3. filename of the module
     4. an optional cost value
  */
  struct gconv_alias fake_alias;
  struct gconv_module *new_module;
  char *from, *to, *module, *wp;
  int need_ext;
  int cost_hi;

  while (__isspace_l (*rp, _nl_C_locobj_ptr))
    ++rp;
  from = rp;
  while (*rp != '\0' && !__isspace_l (*rp, _nl_C_locobj_ptr))
    {
      *rp = __toupper_l (*rp, _nl_C_locobj_ptr);
      ++rp;
    }
  if (*rp == '\0')
    return;
  *rp++ = '\0';
  to = wp = rp;
  while (__isspace_l (*rp, _nl_C_locobj_ptr))
    ++rp;
  while (*rp != '\0' && !__isspace_l (*rp, _nl_C_locobj_ptr))
    *wp++ = __toupper_l (*rp++, _nl_C_locobj_ptr);
  if (*rp == '\0')
    return;
  *wp++ = '\0';
  do
    ++rp;
  while (__isspace_l (*rp, _nl_C_locobj_ptr));
  module = wp;
  while (*rp != '\0' && !__isspace_l (*rp, _nl_C_locobj_ptr))
    *wp++ = *rp++;
  if (*rp == '\0')
    {
      /* There is no cost, use one by default.  */
      *wp++ = '\0';
      cost_hi = 1;
    }
  else
    {
      /* There might be a cost value.  */
      char *endp;

      *wp++ = '\0';
      cost_hi = strtol (rp, &endp, 10);
      if (rp == endp || cost_hi < 1)
       /* No useful information.  */
       cost_hi = 1;
    }

  if (module[0] == '\0')
    /* No module name given.  */
    return;
  if (module[0] == '/')
    dir_len = 0;

  /* See whether we must add the ending.  */
  need_ext = 0;
  if (wp - module < (ptrdiff_t) sizeof (gconv_module_ext)
      || memcmp (wp - sizeof (gconv_module_ext), gconv_module_ext,
               sizeof (gconv_module_ext)) != 0)
    /* We must add the module extension.  */
    need_ext = sizeof (gconv_module_ext) - 1;

  /* See whether we have already an alias with this name defined.  */
  fake_alias.fromname = strndupa (from, to - from);

  if (__tfind (&fake_alias, &__gconv_alias_db, __gconv_alias_compare) != NULL)
    /* This module duplicates an alias.  */
    return;

  new_module = (struct gconv_module *) calloc (1,
                                          sizeof (struct gconv_module)
                                          + (wp - from)
                                          + dir_len + need_ext);
  if (new_module != NULL)
    {
      char *tmp;

      new_module->from_string = tmp = (char *) (new_module + 1);
      tmp = __mempcpy (tmp, from, to - from);

      new_module->to_string = tmp;
      tmp = __mempcpy (tmp, to, module - to);

      new_module->cost_hi = cost_hi;
      new_module->cost_lo = modcounter;

      new_module->module_name = tmp;

      if (dir_len != 0)
       tmp = __mempcpy (tmp, directory, dir_len);

      tmp = __mempcpy (tmp, module, wp - module);

      if (need_ext)
       memcpy (tmp - 1, gconv_module_ext, sizeof (gconv_module_ext));

      /* Now insert the new module data structure in our search tree.  */
      insert_module (new_module, 1);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int internal_function detect_conflict ( const char *  alias) [static]

Definition at line 106 of file gconv_conf.c.

{
  struct gconv_module *node = __gconv_modules_db;

  while (node != NULL)
    {
      int cmpres = strcmp (alias, node->from_string);

      if (cmpres == 0)
       /* We have a conflict.  */
       return 1;
      else if (cmpres < 0)
       node = node->left;
      else
       node = node->right;
    }

  return node != NULL;
}

Here is the caller graph for this function:

static void internal_function insert_module ( struct gconv_module newp,
int  tobefreed 
) [static]

Definition at line 190 of file gconv_conf.c.

{
  struct gconv_module **rootp = &__gconv_modules_db;

  while (*rootp != NULL)
    {
      struct gconv_module *root = *rootp;
      int cmpres;

      cmpres = strcmp (newp->from_string, root->from_string);
      if (cmpres == 0)
       {
         /* Both strings are identical.  Insert the string at the
            end of the `same' list if it is not already there.  */
         while (strcmp (newp->from_string, root->from_string) != 0
               || strcmp (newp->to_string, root->to_string) != 0)
           {
             rootp = &root->same;
             root = *rootp;
             if (root == NULL)
              break;
           }

         if (root != NULL)
           {
             /* This is a no new conversion.  But maybe the cost is
               better.  */
             if (newp->cost_hi < root->cost_hi
                || (newp->cost_hi == root->cost_hi
                    && newp->cost_lo < root->cost_lo))
              {
                newp->left = root->left;
                newp->right = root->right;
                newp->same = root->same;
                *rootp = newp;

                free (root);
              }
             else if (tobefreed)
              free (newp);
             return;
           }

         break;
       }
      else if (cmpres < 0)
       rootp = &root->left;
      else
       rootp = &root->right;
    }

  /* Plug in the new node here.  */
  *rootp = newp;
}

Here is the caller graph for this function:

libc_freeres_fn ( free_mem  )

Definition at line 615 of file gconv_conf.c.

{
  if (__gconv_path_elem != NULL && __gconv_path_elem != &empty_path_elem)
    free ((void *) __gconv_path_elem);
}
static void internal_function read_conf_file ( const char *  filename,
const char *  directory,
size_t  dir_len,
void **  modules,
size_t nmodules 
) [static]

Definition at line 364 of file gconv_conf.c.

{
  /* Note the file is opened with cancellation in the I/O functions
     disabled.  */
  FILE *fp = fopen (filename, "rc");
  char *line = NULL;
  size_t line_len = 0;
  static int modcounter;

  /* Don't complain if a file is not present or readable, simply silently
     ignore it.  */
  if (fp == NULL)
    return;

  /* No threads reading from this stream.  */
  __fsetlocking (fp, FSETLOCKING_BYCALLER);

  /* Process the known entries of the file.  Comments start with `#' and
     end with the end of the line.  Empty lines are ignored.  */
  while (!feof_unlocked (fp))
    {
      char *rp, *endp, *word;
      ssize_t n = __getdelim (&line, &line_len, '\n', fp);
      if (n < 0)
       /* An error occurred.  */
       break;

      rp = line;
      /* Terminate the line (excluding comments or newline) by an NUL byte
        to simplify the following code.  */
      endp = strchr (rp, '#');
      if (endp != NULL)
       *endp = '\0';
      else
       if (rp[n - 1] == '\n')
         rp[n - 1] = '\0';

      while (__isspace_l (*rp, _nl_C_locobj_ptr))
       ++rp;

      /* If this is an empty line go on with the next one.  */
      if (rp == endp)
       continue;

      word = rp;
      while (*rp != '\0' && !__isspace_l (*rp, _nl_C_locobj_ptr))
       ++rp;

      if (rp - word == sizeof ("alias") - 1
         && memcmp (word, "alias", sizeof ("alias") - 1) == 0)
       add_alias (rp, *modules);
      else if (rp - word == sizeof ("module") - 1
              && memcmp (word, "module", sizeof ("module") - 1) == 0)
       add_module (rp, directory, dir_len, modules, nmodules, modcounter++);
      /* else */
       /* Otherwise ignore the line.  */
    }

  free (line);

  fclose (fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 46 of file gconv_conf.c.

Definition at line 44 of file gconv_conf.c.

Definition at line 100 of file gconv_conf.c.

const char builtin_aliases[] [static]

Definition at line 81 of file gconv_conf.c.

const char default_gconv_path[] = GCONV_PATH [static]

Definition at line 40 of file gconv_conf.c.

const char gconv_conf_filename[] = "gconv-modules" [static]

Definition at line 53 of file gconv_conf.c.

struct gconv_module[] [static]

Definition at line 62 of file gconv_conf.c.

const char gconv_module_ext[] = MODULE_EXT [static]

Definition at line 59 of file gconv_conf.c.

struct path_elem = { NULL, 0 } [static]

Definition at line 49 of file gconv_conf.c.