Back to index

glibc  2.9
Classes | Defines | Enumerations | Functions | Variables
res_hconf.c File Reference
#include <assert.h>
#include <errno.h>
#include <ctype.h>
#include <libintl.h>
#include <memory.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netinet/in.h>
#include <bits/libc-lock.h>
#include "ifreq.h"
#include "res_hconf.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  cmd

Defines

#define _PATH_HOSTCONF   "/etc/host.conf"
#define ENV_HOSTCONF   "RESOLV_HOST_CONF"
#define ENV_SPOOF   "RESOLV_SPOOF_CHECK"
#define ENV_TRIM_OVERR   "RESOLV_OVERRIDE_TRIM_DOMAINS"
#define ENV_TRIM_ADD   "RESOLV_ADD_TRIM_DOMAINS"
#define ENV_MULTI   "RESOLV_MULTI"
#define ENV_REORDER   "RESOLV_REORDER"

Enumerations

enum  parse_cbs { CB_none, CB_arg_trimdomain_list, CB_arg_spoof, CB_arg_bool }

Functions

static const char * skip_ws (const char *str)
static const char * skip_string (const char *str)
static const char * arg_trimdomain_list (const char *fname, int line_num, const char *args)
static const char * arg_spoof (const char *fname, int line_num, const char *args)
static const char * arg_bool (const char *fname, int line_num, const char *args, unsigned flag)
static void parse_line (const char *fname, int line_num, const char *str)
static void do_init (void)
void _res_hconf_init (void)
 libc_freeres_ptr (static struct netaddr{int addrtype;union{struct{u_int32_t addr;u_int32_t mask;}ipv4;}u;}*ifaddrs)
void _res_hconf_reorder_addrs (struct hostent *hp)
void _res_hconf_trim_domain (char *hostname)
void _res_hconf_trim_domains (struct hostent *hp)

Variables

static struct cmd cmd []

Class Documentation

struct cmd

Definition at line 70 of file res_hconf.c.

Class Members
unsigned int arg
uint8_t cb
const char name

Define Documentation

#define _PATH_HOSTCONF   "/etc/host.conf"

Definition at line 52 of file res_hconf.c.

#define ENV_HOSTCONF   "RESOLV_HOST_CONF"

Definition at line 55 of file res_hconf.c.

#define ENV_MULTI   "RESOLV_MULTI"

Definition at line 59 of file res_hconf.c.

#define ENV_REORDER   "RESOLV_REORDER"

Definition at line 60 of file res_hconf.c.

#define ENV_SPOOF   "RESOLV_SPOOF_CHECK"

Definition at line 56 of file res_hconf.c.

#define ENV_TRIM_ADD   "RESOLV_ADD_TRIM_DOMAINS"

Definition at line 58 of file res_hconf.c.

#define ENV_TRIM_OVERR   "RESOLV_OVERRIDE_TRIM_DOMAINS"

Definition at line 57 of file res_hconf.c.


Enumeration Type Documentation

enum parse_cbs
Enumerator:
CB_none 
CB_arg_trimdomain_list 
CB_arg_spoof 
CB_arg_bool 

Definition at line 62 of file res_hconf.c.


Function Documentation

void _res_hconf_init ( void  )

Definition at line 356 of file res_hconf.c.

Here is the call graph for this function:

void _res_hconf_reorder_addrs ( struct hostent hp)

Definition at line 387 of file res_hconf.c.

{
#if defined SIOCGIFCONF && defined SIOCGIFNETMASK
  int i, j;
  /* Number of interfaces.  */
  static int num_ifs = -1;
  /* We need to protect the dynamic buffer handling.  */
  __libc_lock_define_initialized (static, lock);

  /* Only reorder if we're supposed to.  */
  if ((_res_hconf.flags & HCONF_FLAG_REORDER) == 0)
    return;

  /* Can't deal with anything but IPv4 for now...  */
  if (hp->h_addrtype != AF_INET)
    return;

  if (num_ifs <= 0)
    {
      struct ifreq *ifr, *cur_ifr;
      int sd, num, i;
      /* Save errno.  */
      int save = errno;

      /* Initialize interface table.  */

      /* The SIOCGIFNETMASK ioctl will only work on an AF_INET socket.  */
      sd = __socket (AF_INET, SOCK_DGRAM, 0);
      if (sd < 0)
       return;

      /* Get lock.  */
      __libc_lock_lock (lock);

      /* Recheck, somebody else might have done the work by done.  */
      if (num_ifs <= 0)
       {
         int new_num_ifs = 0;

         /* Get a list of interfaces.  */
         __ifreq (&ifr, &num, sd);
         if (!ifr)
           goto cleanup;

         ifaddrs = malloc (num * sizeof (ifaddrs[0]));
         if (!ifaddrs)
           goto cleanup1;

         /* Copy usable interfaces in ifaddrs structure.  */
         for (cur_ifr = ifr, i = 0; i < num;
              cur_ifr = __if_nextreq (cur_ifr), ++i)
           {
             if (cur_ifr->ifr_addr.sa_family != AF_INET)
              continue;

             ifaddrs[new_num_ifs].addrtype = AF_INET;
             ifaddrs[new_num_ifs].u.ipv4.addr =
              ((struct sockaddr_in *) &cur_ifr->ifr_addr)->sin_addr.s_addr;

             if (__ioctl (sd, SIOCGIFNETMASK, cur_ifr) < 0)
              continue;

             ifaddrs[new_num_ifs].u.ipv4.mask =
              ((struct sockaddr_in *) &cur_ifr->ifr_netmask)->sin_addr.s_addr;

             /* Now we're committed to this entry.  */
             ++new_num_ifs;
           }
         /* Just keep enough memory to hold all the interfaces we want.  */
         ifaddrs = realloc (ifaddrs, new_num_ifs * sizeof (ifaddrs[0]));
         assert (ifaddrs != NULL);

       cleanup1:
         __if_freereq (ifr, num);

       cleanup:
         /* Release lock, preserve error value, and close socket.  */
         save = errno;

         num_ifs = new_num_ifs;

         __libc_lock_unlock (lock);
       }

      __close (sd);
    }

  if (num_ifs == 0)
    return;

  /* Find an address for which we have a direct connection.  */
  for (i = 0; hp->h_addr_list[i]; ++i)
    {
      struct in_addr *haddr = (struct in_addr *) hp->h_addr_list[i];

      for (j = 0; j < num_ifs; ++j)
       {
         u_int32_t if_addr    = ifaddrs[j].u.ipv4.addr;
         u_int32_t if_netmask = ifaddrs[j].u.ipv4.mask;

         if (((haddr->s_addr ^ if_addr) & if_netmask) == 0)
           {
             void *tmp;

             tmp = hp->h_addr_list[i];
             hp->h_addr_list[i] = hp->h_addr_list[0];
             hp->h_addr_list[0] = tmp;
             return;
           }
       }
    }
#endif /* defined(SIOCGIFCONF) && ... */
}

Here is the call graph for this function:

void _res_hconf_trim_domain ( char *  hostname)

Definition at line 508 of file res_hconf.c.

{
  size_t hostname_len, trim_len;
  int i;

  hostname_len = strlen (hostname);

  for (i = 0; i < _res_hconf.num_trimdomains; ++i)
    {
      const char *trim = _res_hconf.trimdomain[i];

      trim_len = strlen (trim);
      if (hostname_len > trim_len
         && __strcasecmp (&hostname[hostname_len - trim_len], trim) == 0)
       {
         hostname[hostname_len - trim_len] = '\0';
         break;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _res_hconf_trim_domains ( struct hostent hp)

Definition at line 533 of file res_hconf.c.

{
  int i;

  if (_res_hconf.num_trimdomains == 0)
    return;

  _res_hconf_trim_domain (hp->h_name);
  for (i = 0; hp->h_aliases[i]; ++i)
    _res_hconf_trim_domain (hp->h_aliases[i]);
}

Here is the call graph for this function:

static const char* arg_bool ( const char *  fname,
int  line_num,
const char *  args,
unsigned  flag 
) [static]

Definition at line 187 of file res_hconf.c.

{
  if (__strncasecmp (args, "on", 2) == 0)
    {
      args += 2;
      _res_hconf.flags |= flag;
    }
  else if (__strncasecmp (args, "off", 3) == 0)
    {
      args += 3;
      _res_hconf.flags &= ~flag;
    }
  else
    {
      char *buf;

      if (__asprintf (&buf,
                    _("%s: line %d: expected `on' or `off', found `%s'\n"),
                    fname, line_num, args) < 0)
       return 0;

      __fxprintf (NULL, "%s", buf);

      free (buf);
      return 0;
    }
  return args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* arg_spoof ( const char *  fname,
int  line_num,
const char *  args 
) [static]

Definition at line 165 of file res_hconf.c.

{
  const char *start = args;
  size_t len;

  args = skip_string (args);
  len = args - start;

  if (len == 3 && __strncasecmp (start, "off", len) == 0)
    _res_hconf.flags &= ~(HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
  else
    {
      _res_hconf.flags |= (HCONF_FLAG_SPOOF | HCONF_FLAG_SPOOFALERT);
      if ((len == 6 && __strncasecmp (start, "nowarn", len) == 0)
         || !(len == 4 && __strncasecmp (start, "warn", len) == 0))
       _res_hconf.flags &= ~HCONF_FLAG_SPOOFALERT;
    }
  return args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* arg_trimdomain_list ( const char *  fname,
int  line_num,
const char *  args 
) [static]

Definition at line 109 of file res_hconf.c.

{
  const char * start;
  size_t len;

  do
    {
      start = args;
      args = skip_string (args);
      len = args - start;

      if (_res_hconf.num_trimdomains >= TRIMDOMAINS_MAX)
       {
         char *buf;

         if (__asprintf (&buf, _("\
%s: line %d: cannot specify more than %d trim domains"),
                       fname, line_num, TRIMDOMAINS_MAX) < 0)
           return 0;

         __fxprintf (NULL, "%s", buf);

         free (buf);
         return 0;
       }
      _res_hconf.trimdomain[_res_hconf.num_trimdomains++] =
       __strndup (start, len);
      args = skip_ws (args);
      switch (*args)
       {
       case ',': case ';': case ':':
         args = skip_ws (++args);
         if (!*args || *args == '#')
           {
             char *buf;

             if (__asprintf (&buf, _("\
%s: line %d: list delimiter not followed by domain"),
                           fname, line_num) < 0)
              return 0;

             __fxprintf (NULL, "%s", buf);

             free (buf);
             return 0;
           }
       default:
         break;
       }
    }
  while (*args && *args != '#');
  return args;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void do_init ( void  ) [static]

Definition at line 298 of file res_hconf.c.

{
  const char *hconf_name;
  int line_num = 0;
  char buf[256], *envval;
  FILE *fp;

  memset (&_res_hconf, '\0', sizeof (_res_hconf));

  hconf_name = getenv (ENV_HOSTCONF);
  if (hconf_name == NULL)
    hconf_name = _PATH_HOSTCONF;

  fp = fopen (hconf_name, "rc");
  if (fp)
    {
      /* No threads using this stream.  */
      __fsetlocking (fp, FSETLOCKING_BYCALLER);

      while (fgets_unlocked (buf, sizeof (buf), fp))
       {
         ++line_num;
         *__strchrnul (buf, '\n') = '\0';
         parse_line (hconf_name, line_num, buf);
       }
      fclose (fp);
    }

  envval = getenv (ENV_SPOOF);
  if (envval)
    arg_spoof (ENV_SPOOF, 1, envval);

  envval = getenv (ENV_MULTI);
  if (envval)
    arg_bool (ENV_MULTI, 1, envval, HCONF_FLAG_MULTI);

  envval = getenv (ENV_REORDER);
  if (envval)
    arg_bool (ENV_REORDER, 1, envval, HCONF_FLAG_REORDER);

  envval = getenv (ENV_TRIM_ADD);
  if (envval)
    arg_trimdomain_list (ENV_TRIM_ADD, 1, envval);

  envval = getenv (ENV_TRIM_OVERR);
  if (envval)
    {
      _res_hconf.num_trimdomains = 0;
      arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval);
    }

  _res_hconf.initialized = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void parse_line ( const char *  fname,
int  line_num,
const char *  str 
) [static]

Definition at line 218 of file res_hconf.c.

{
  const char *start;
  const struct cmd *c = 0;
  size_t len;
  size_t i;

  str = skip_ws (str);

  /* skip line comment and empty lines: */
  if (*str == '\0' || *str == '#') return;

  start = str;
  str = skip_string (str);
  len = str - start;

  for (i = 0; i < sizeof (cmd) / sizeof (cmd[0]); ++i)
    {
      if (__strncasecmp (start, cmd[i].name, len) == 0
         && strlen (cmd[i].name) == len)
       {
         c = &cmd[i];
         break;
       }
    }
  if (c == NULL)
    {
      char *buf;

      if (__asprintf (&buf, _("%s: line %d: bad command `%s'\n"),
                    fname, line_num, start) < 0)
       return;

      __fxprintf (NULL, "%s", buf);

      free (buf);
      return;
    }

  /* process args: */
  str = skip_ws (str);

  if (c->cb == CB_arg_trimdomain_list)
    str = arg_trimdomain_list (fname, line_num, str);
  else if (c->cb == CB_arg_spoof)
    str = arg_spoof (fname, line_num, str);
  else if (c->cb == CB_arg_bool)
    str = arg_bool (fname, line_num, str, c->arg);
  else
    /* Ignore the line.  */
    return;

  if (!str)
    return;

  /* rest of line must contain white space or comment only: */
  while (*str)
    {
      if (!isspace (*str)) {
       if (*str != '#')
         {
           char *buf;

           if (__asprintf (&buf,
                         _("%s: line %d: ignoring trailing garbage `%s'\n"),
                         fname, line_num, str) < 0)
             break;

           __fxprintf (NULL, "%s", buf);

           free (buf);
         }
       break;
      }
      ++str;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* skip_string ( const char *  str) [static]

Definition at line 100 of file res_hconf.c.

{
  while (*str && !isspace (*str) && *str != '#' && *str != ',')
    ++str;
  return str;
}

Here is the caller graph for this function:

static const char* skip_ws ( const char *  str) [static]

Definition at line 91 of file res_hconf.c.

{
  while (isspace (*str)) ++str;
  return str;
}

Here is the caller graph for this function:


Variable Documentation

struct cmd cmd[] [static]