src/option.c

/* dnsmasq is Copyright (c) 2000 - 2004 Simon Kelley

   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 dated June, 1991.

   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.
*/

/* Author's email: simon@thekelleys.org.uk */

#include "dnsmasq.h"

struct myoption {
  const char *name;
  int has_arg;
  int *flag;
  int val;
};

#define OPTSTRING "ZDNLERKzowefnbvhdkqr:m:p:c:l:s:i:t:u:g:a:x:S:C:A:T:H:Q:I:B:F:G:O:M:X:V:U:j:P:J:"

static struct myoption opts[] = { 
  {"version", 0, 0, 'v'},
  {"no-hosts", 0, 0, 'h'},
  {"no-poll", 0, 0, 'n'},
  {"help", 0, 0, 'w'},
  {"no-daemon", 0, 0, 'd'},
  {"log-queries", 0, 0, 'q'},
  {"user", 1, 0, 'u'},
  {"group", 1, 0, 'g'},
  {"resolv-file", 1, 0, 'r'},
  {"mx-host", 1, 0, 'm'},
  {"mx-target", 1, 0, 't'},
  {"cache-size", 1, 0, 'c'},
  {"port", 1, 0, 'p'},
  {"dhcp-leasefile", 1, 0, 'l'},
  {"dhcp-lease", 1, 0, 'l' },
  {"dhcp-host", 1, 0, 'G'},
  {"dhcp-range", 1, 0, 'F'},
  {"dhcp-option", 1, 0, 'O'},
  {"dhcp-boot", 1, 0, 'M'},
  {"domain", 1, 0, 's'},
  {"domain-suffix", 1, 0, 's'},
  {"interface", 1, 0, 'i'},
  {"listen-address", 1, 0, 'a'},
  {"bogus-priv", 0, 0, 'b'},
  {"bogus-nxdomain", 1, 0, 'B'},
  {"selfmx", 0, 0, 'e'},
  {"filterwin2k", 0, 0, 'f'},
  {"pid-file", 1, 0, 'x'},
  {"strict-order", 0, 0, 'o'},
  {"server", 1, 0, 'S'},
  {"local", 1, 0, 'S' },
  {"address", 1, 0, 'A' },
  {"conf-file", 1, 0, 'C'},
  {"no-resolv", 0, 0, 'R'},
  {"expand-hosts", 0, 0, 'E'},
  {"localmx", 0, 0, 'L'},
  {"local-ttl", 1, 0, 'T'},
  {"no-negcache", 0, 0, 'N'},
  {"addn-hosts", 1, 0, 'H'},
  {"query-port", 1, 0, 'Q'},
  {"except-interface", 1, 0, 'I'},
  {"domain-needed", 0, 0, 'D'},
  {"dhcp-lease-max", 1, 0, 'X' },
  {"bind-interfaces", 0, 0, 'z'},
  {"read-ethers", 0, 0, 'Z' },
  {"alias", 1, 0, 'V' },
  {"dhcp-vendorclass", 1, 0, 'U'},
  {"dhcp-userclass", 1, 0, 'j'},
  {"dhcp-ignore", 1, 0, 'J'},
  {"edns-packet-max", 1, 0, 'P'},
  {"keep-in-foreground", 0, 0, 'k'},
  {"dhcp-authoritative", 0, 0, 'K'},
  {0, 0, 0, 0}
};

struct optflags {
  char c;
  unsigned int flag; 
};

static struct optflags optmap[] = {
  { 'b', OPT_BOGUSPRIV },
  { 'f', OPT_FILTER },
  { 'q', OPT_LOG },
  { 'e', OPT_SELFMX },
  { 'h', OPT_NO_HOSTS },
  { 'n', OPT_NO_POLL },
  { 'd', OPT_DEBUG },
  { 'k', OPT_NO_FORK },
  { 'K', OPT_AUTHORITATIVE },
  { 'o', OPT_ORDER },
  { 'R', OPT_NO_RESOLV },
  { 'E', OPT_EXPAND },
  { 'L', OPT_LOCALMX },
  { 'N', OPT_NO_NEG },
  { 'D', OPT_NODOTS_LOCAL },
  { 'z', OPT_NOWILD },
  { 'Z', OPT_ETHERS },
  { 'v', 0},
  { 'w', 0},
  { 0, 0 }
};

static char *usage =
"Usage: dnsmasq [options]\n\n"
#ifndef HAVE_GETOPT_LONG
"Use short options only on the command line.\n"
#endif
"Valid options are :\n"
"-a, --listen-address=ipaddr         Specify local address(es) to listen on.\n"
"-A, --address=/domain/ipaddr        Return ipaddr for all hosts in specified domains.\n"
"-b, --bogus-priv                    Fake reverse lookups for RFC1918 private address ranges.\n"
"-B, --bogus-nxdomain=ipaddr         Treat ipaddr as NXDOMAIN (defeats Verisign wildcard).\n" 
"-c, --cache-size=cachesize          Specify the size of the cache in entries (defaults to %d).\n"
"-C, --conf-file=path                Specify configuration file (defaults to " CONFFILE ").\n"
"-d, --no-daemon                     Do NOT fork into the background: run in debug mode.\n"
"-D, --domain-needed                 Do NOT forward queries with no domain part.\n" 
"-e, --selfmx                        Return self-pointing MX records for local hosts.\n"
"-E, --expand-hosts                  Expand simple names in /etc/hosts with domain-suffix.\n"
"-f, --filterwin2k                   Don't forward spurious DNS requests from Windows hosts.\n"
"-F, --dhcp-range=ipaddr,ipaddr,time Enable DHCP in the range given with lease duration.\n"
"-g, --group=groupname               Change to this group after startup (defaults to " CHGRP ").\n"
"-G, --dhcp-host=<hostspec>          Set address or hostname for a specified machine.\n"
"-h, --no-hosts                      Do NOT load " HOSTSFILE " file.\n"
"-H, --addn-hosts=path               Specify a hosts file to be read in addition to " HOSTSFILE ".\n"
"-i, --interface=interface           Specify interface(s) to listen on.\n"
"-I, --except-interface=int          Specify interface(s) NOT to listen on.\n"
"-j, --dhcp-userclass=<id>,<class>   Map DHCP user class to option set.\n"
"-J, --dhcp-ignore=<id>              Don't do DHCP for hosts in option set.\n"
"-k, --keep-in-foreground            Do NOT fork into the background, do NOT run in debug mode.\n"
"-K, --dhcp-authoritative            Assume we are the only DHCP server on the local network.\n"
"-l, --dhcp-leasefile=path           Specify where to store DHCP leases (defaults to " LEASEFILE ").\n"
"-L, --localmx                       Return MX records for local hosts.\n"
"-m, --mx-host=host_name             Specify the MX name to reply to.\n"
"-M, --dhcp-boot=<bootp opts>        Specify BOOTP options to DHCP server.\n"
"-n, --no-poll                       Do NOT poll " RESOLVFILE " file, reload only on SIGHUP.\n"
"-N, --no-negcache                   Do NOT cache failed search results.\n"
"-o, --strict-order                  Use nameservers strictly in the order given in " RESOLVFILE ".\n"
"-O, --dhcp-option=<optspec>         Set extra options to be set to DHCP clients.\n"
"-p, --port=number                   Specify port to listen for DNS requests on (defaults to 53).\n"
"-P, --edns-packet-max=<size>        Maximum supported UDP packet size for EDNS.0 (defaults to %d).\n"
"-q, --log-queries                   Log queries.\n"
"-Q, --query-port=number             Force the originating port for upstream queries.\n"
"-R, --no-resolv                     Do NOT read resolv.conf.\n"
"-r, --resolv-file=path              Specify path to resolv.conf (defaults to " RESOLVFILE ").\n"
"-S, --server=/domain/ipaddr         Specify address(es) of upstream servers with optional domains.\n"
"    --local=/domain/                Never forward queries to specified domains.\n"
"-s, --domain=domain                 Specify the domain to be assigned in DHCP leases.\n"
"-t, --mx-target=host_name           Specify the host in an MX reply.\n"
"-T, --local-ttl=time                Specify time-to-live in seconds for replies from /etc/hosts.\n"
"-u, --user=username                 Change to this user after startup. (defaults to " CHUSER ").\n" 
"-U, --dhcp-vendorclass=<id>,<class> Map DHCP vendor class to option set.\n"
"-v, --version                       Display dnsmasq version and copyright information.\n"
"-V, --alias=addr,addr,mask          Translate IPv4 addresses from upstream servers.\n"
"-w, --help                          Display this message.\n"
"-x, --pid-file=path                 Specify path of PID file. (defaults to " RUNFILE ").\n"
"-X, --dhcp-lease-max=number         Specify maximum number of DHCP leases (defaults to %d).\n"
"-z, --bind-interfaces               Bind only to interfaces in use.\n"
"-Z, --read-ethers                   Read DHCP static host information from " ETHERSFILE ".\n"
"\n";


struct daemon *read_opts (int argc, char **argv)
{
  struct daemon *daemon = safe_malloc(sizeof(struct daemon));
  char *problem = NULL, *buff = safe_malloc(MAXDNAME);
  int option = 0, i;
  FILE *file_save = NULL, *f = NULL;
  char *comma, *file_name_save = NULL, *conffile = CONFFILE;
  int hosts_index = 1, conffile_set = 0;
  int line_save = 0, lineno = 0;
  opterr = 0;
  
  memset(daemon, 0, sizeof(struct daemon));
  daemon->namebuff = buff;

  /* Set defaults - everything else is zero or NULL */
  daemon->min_leasetime = UINT_MAX;
  daemon->cachesize = CACHESIZ;
  daemon->port = NAMESERVER_PORT;
  daemon->default_resolv.is_default = 1;
  daemon->default_resolv.name = RESOLVFILE;
  daemon->resolv_files = &daemon->default_resolv;
  daemon->username = CHUSER;
  daemon->groupname = CHGRP;
  daemon->runfile =  RUNFILE;
  daemon->dhcp_max = MAXLEASES;
  daemon->edns_pktsz = EDNS_PKTSZ;
  
  while (1)
    {
      problem = NULL;

      if (!f)
#ifdef HAVE_GETOPT_LONG
	option = getopt_long(argc, argv, OPTSTRING, (struct option *)opts, NULL);
#else
        option = getopt(argc, argv, OPTSTRING);
#endif
      else
	{ /* f non-NULL, reading from conffile. */
	reread:
	  if (!fgets(buff, MAXDNAME, f))
	    {
	      /* At end of file, all done */
	      fclose(f);
	      if (file_save)
		{
		  /* may be nested */
		  conffile = file_name_save;
		  f = file_save;
		  file_save = NULL;
		  lineno = line_save;
		  goto reread;
		}
	      break;
	    }
	  else
	    {
	      char *p;
	      int white;
	      lineno++;
	      /* dump comments */
	      for (white = 1, p = buff; *p; p++)
		if (white && *p == '#')
		  { 
		    *p = 0;
		    break;
		  }
		else
		  white = isspace(*p);
	      /* fgets gets end of line char too. */
	      while (strlen(buff) > 0 && isspace(buff[strlen(buff)-1]))
		buff[strlen(buff)-1] = 0;
	      if (*buff == 0)
		continue; 
	      if ((p=strchr(buff, '=')))
		{
		  optarg = p+1;
		  *p = 0;
		}
	      else
		optarg = NULL;
	      
	      option = 0;
	      for (i=0; opts[i].name; i++) 
		if (strcmp(opts[i].name, buff) == 0)
		  option = opts[i].val;
	      if (!option)
		{
		  sprintf(buff, "bad option at line %d of %s ", lineno, conffile);
		  complain(buff, NULL);
		  continue;
		}
	    }
	}
      
      if (option == -1)
	{ /* end of command line args, start reading conffile. */
	  if (!conffile)
	    break; /* "confile=" option disables */
	fileopen:
	  option = 0;
	  if (!(f = fopen(conffile, "r")))
	    {   
	      if (errno == ENOENT && !conffile_set)
		break; /* No conffile, all done. */
	      else
		die("cannot read %s: %s", conffile);
	    }
	}
     
      if (!f && option == 'w')
	{
	  fprintf (stderr, usage,  CACHESIZ, EDNS_PKTSZ, MAXLEASES);
	  exit(0);
	}

      if (!f && option == 'v')
        {
          fprintf(stderr, "Dnsmasq version %s  %s\n\n", VERSION, COPYRIGHT);
	  fprintf(stderr, "This software comes with ABSOLUTELY NO WARRANTY.\n");
	  fprintf(stderr, "Dnsmasq is free software, and you are welcome to redistribute it\n");
	  fprintf(stderr, "under the terms of the GNU General Public License, version 2.\n");
          exit(0);
        }
      
      for (i=0; optmap[i].c; i++)
	if (option == optmap[i].c)
	  {
	    daemon->options |= optmap[i].flag;
	    option = 0;
	    if (f && optarg)
	      {
		sprintf(buff, "extraneous parameter at line %d of %s ", lineno, conffile);
		complain(buff, NULL);
	      }
	    break;
	  }
      
      if (option && option != '?')
	{
	  if (f && !optarg)
	    {
	      sprintf(buff, "missing parameter at line %d of %s ", lineno, conffile);
	      complain(buff, NULL);
	      continue;
	    }
	      	  
	  switch (option)
	    { 
	     case 'C': 
	       if (!f)
		 {
		   conffile = safe_string_alloc(optarg);
		   conffile_set = 1;
		   break;
		 }
	      
	       /* nest conffiles one deep */
	       if (file_save)
		 {
		   sprintf(buff, "nested includes not allowed at line %d of %s ", lineno, conffile);
		   complain(buff, NULL);
		   continue;
		 }
	       file_name_save = conffile;
	       file_save = f;
	       line_save = lineno;
	       conffile = safe_string_alloc(optarg);
	       conffile_set = 1;
	       lineno = 0;
	       goto fileopen;
	      
	    case 'x': 
	      daemon->runfile = safe_string_alloc(optarg);
	      break;
	      
	    case 'r':
	      {
		char *name = safe_string_alloc(optarg);
		struct resolvc *new, *list = daemon->resolv_files;
		if (list && list->is_default)
		  {
		    /* replace default resolv file - possibly with nothing */
		    if (name)
		      {
			list->is_default = 0;
			list->name = name;
		      }
		    else
		      list = NULL;
		  }
		else if (name)
		  {
		    new = safe_malloc(sizeof(struct resolvc));
		    new->next = list;
		    new->name = name;
		    new->is_default = 0;
		    new->logged = 0;
		    list = new;
		  }
		daemon->resolv_files = list;
		break;
	      }

	    case 'm':
	      {
		if ((comma = strchr(optarg, ',')))
		  *(comma++) = 0;
		if (!canonicalise(optarg) || (comma && !canonicalise(comma)))
		  {
		    option = '?';
		    problem = "bad MX name";
		  }
		else 
		  {
		    struct mx_record *new = safe_malloc(sizeof(struct mx_record));
		    new->next = daemon->mxnames;
		    daemon->mxnames = new;
		    new->mxname = safe_string_alloc(optarg);
		    new->mxtarget = safe_string_alloc(comma); /* may be NULL */
		  }
		break;
	      }
	      
	    case 't':
	      if (!canonicalise(optarg))
		{
		  option = '?';
		  problem = "bad MX target";
		}
	      else
		daemon->mxtarget = safe_string_alloc(optarg);
	      break;
	      
	    case 'l':
	      daemon->lease_file = safe_string_alloc(optarg);
	      break;
	      
	    case 'H':
	      {
		struct hostsfile *new = safe_malloc(sizeof(struct hostsfile));
		new->fname = safe_string_alloc(optarg);
		new->index = hosts_index++;
		new->next = daemon->addn_hosts;
		daemon->addn_hosts = new;
		break;
	      }

	    case 's':
	      if (strcmp (optarg, "#") == 0)
		daemon->options |= OPT_RESOLV_DOMAIN;
	      else if (!canonicalise(optarg))
		option = '?';
	      else
		daemon->domain_suffix = safe_string_alloc(optarg);
	      break;
	      
	    case 'u':
	      daemon->username = safe_string_alloc(optarg);
	      break;
	      
	    case 'g':
	      daemon->groupname = safe_string_alloc(optarg);
	      break;
	      
	    case 'i':
	      do {
		struct iname *new = safe_malloc(sizeof(struct iname));
		if ((comma = strchr(optarg, ',')))
		  *comma++ = 0;
		new->next = daemon->if_names;
		daemon->if_names = new;
		/* new->name may be NULL if someone does
		   "interface=" to disable all interfaces except loop. */
		new->name = safe_string_alloc(optarg);
		new->isloop = new->used = 0;
		if (strchr(optarg, ':'))
		  daemon->options |= OPT_NOWILD;
		optarg = comma;
	      } while (optarg);
	      break;
	    
	    case 'I':
	      do {
		struct iname *new = safe_malloc(sizeof(struct iname));
		if ((comma = strchr(optarg, ',')))
		  *comma++ = 0;
		new->next = daemon->if_except;
		daemon->if_except = new;
		new->name = safe_string_alloc(optarg);
		if (strchr(optarg, ':'))
		  daemon->options |= OPT_NOWILD;
		optarg = comma;
	      } while (optarg);
	      break;
	      	      
	    case 'B':
	      {
		struct in_addr addr;
		if ((addr.s_addr = inet_addr(optarg)) != (in_addr_t)-1)
		  {
		    struct bogus_addr *baddr = safe_malloc(sizeof(struct bogus_addr));
		    baddr->next = daemon->bogus_addr;
		    daemon->bogus_addr = baddr;
		    baddr->addr = addr;
		  }
		else
		  option = '?'; /* error */
		break;	
	      }

	    case 'a':
	      {
		struct iname *new = safe_malloc(sizeof(struct iname));
		new->next = daemon->if_addrs;
#ifdef HAVE_IPV6
		if (inet_pton(AF_INET, optarg, &new->addr.in.sin_addr))
		  {
		    new->addr.sa.sa_family = AF_INET;
#ifdef HAVE_SOCKADDR_SA_LEN
		    new->addr.in.sin_len = sizeof(struct sockaddr_in);
#endif
		  }
		else if (inet_pton(AF_INET6, optarg, &new->addr.in6.sin6_addr))
		  {
		    new->addr.sa.sa_family = AF_INET6;
		    new->addr.in6.sin6_flowinfo = htonl(0);
#ifdef HAVE_SOCKADDR_SA_LEN
		    new->addr.in6.sin6_len = sizeof(struct sockaddr_in6);
#endif
		  }
#else
		if ((new->addr.in.sin_addr.s_addr = inet_addr(optarg)) != (in_addr_t)-1)
		  {
		    new->addr.sa.sa_family = AF_INET;
#ifdef HAVE_SOCKADDR_SA_LEN
		    new->addr.in.sin_len = sizeof(struct sockaddr_in);
#endif
		  }
#endif
		else
		  {
		    option = '?'; /* error */
		    free(new);
		    new = NULL;
		  }
		
		if (new)
		  daemon->if_addrs = new;
		break;
	      }
	      
	    case 'S':
	    case 'A':
	      {
		struct server *serv, *newlist = NULL;
		
		if (*optarg == '/')
		  {
		    char *end;
		    optarg++;
		    while ((end = strchr(optarg, '/')))
		      {
			char *domain = NULL;
			*end = 0;
			/* # matches everything and becomes a zero length domain string */
			if (strcmp(optarg, "#") == 0)
			  domain = "";
			else if (!canonicalise(optarg) && strlen(optarg) != 0)
			  option = '?';
			else
			  domain = safe_string_alloc(optarg); /* NULL if strlen is zero */
			serv = safe_malloc(sizeof(struct server));
			serv->next = newlist;
			newlist = serv;
			serv->sfd = NULL;
			serv->domain = domain;
			serv->flags = domain ? SERV_HAS_DOMAIN : SERV_FOR_NODOTS;
			optarg = end+1;
		      }
		    if (!newlist)
		      {
			option = '?';
			break;
		      }
		
		  }
		else
		  {
		    newlist = safe_malloc(sizeof(struct server));
		    newlist->next = NULL;
		    newlist->flags = 0;
		    newlist->sfd = NULL;
		    newlist->domain = NULL;
		  }
		
		if (option == 'A')
		  {
		    newlist->flags |= SERV_LITERAL_ADDRESS;
		    if (!(newlist->flags & SERV_TYPE))
		      option = '?';
		  }
		
		if (!*optarg)
		  {
		    newlist->flags |= SERV_NO_ADDR; /* no server */
		    if (newlist->flags & SERV_LITERAL_ADDRESS)
		      option = '?';
		  }
		else
		  {
		    int source_port = 0, serv_port = NAMESERVER_PORT;
		    char *portno, *source;
		    
		    if ((source = strchr(optarg, '@'))) /* is there a source. */
		      {
			*source = 0; 
			if ((portno = strchr(source+1, '#')))
			  { 
			    *portno = 0;
			    if (!atoi_check(portno+1, &source_port))
			      {
				option = '?';
				problem = "bad port";
			      }
			  }
		      }
		    
		    if ((portno = strchr(optarg, '#'))) /* is there a port no. */
		      {
			*portno = 0;
			if (!atoi_check(portno+1, &serv_port))
			  {
			    option = '?';
			    problem = "bad port";
			  }
		      }

#ifdef HAVE_IPV6
		    if (inet_pton(AF_INET, optarg, &newlist->addr.in.sin_addr))
#else
		    if ((newlist->addr.in.sin_addr.s_addr = inet_addr(optarg)) != (in_addr_t) -1)
#endif
		      {
			newlist->addr.in.sin_port = htons(serv_port);	
			newlist->source_addr.in.sin_port = htons(source_port); 
			newlist->addr.sa.sa_family = newlist->source_addr.sa.sa_family = AF_INET;
#ifdef HAVE_SOCKADDR_SA_LEN
			newlist->source_addr.in.sin_len = newlist->addr.in.sin_len = sizeof(struct sockaddr_in);
#endif
			if (source)
			  {
#ifdef HAVE_IPV6
			    if (inet_pton(AF_INET, source+1, &newlist->source_addr.in.sin_addr))
#else
			    if ((newlist->source_addr.in.sin_addr.s_addr = inet_addr(source+1)) != (in_addr_t) -1)
#endif
				newlist->flags |= SERV_HAS_SOURCE;
			    else
			      option = '?'; /* error */
			  }
			else
			  newlist->source_addr.in.sin_addr.s_addr = INADDR_ANY;
		      }
#ifdef HAVE_IPV6
		    else if (inet_pton(AF_INET6, optarg, &newlist->addr.in6.sin6_addr))
		      {
			newlist->addr.in6.sin6_port = htons(serv_port);
			newlist->source_addr.in6.sin6_port = htons(source_port);
			newlist->addr.sa.sa_family = newlist->source_addr.sa.sa_family = AF_INET6;
			newlist->addr.in6.sin6_flowinfo = newlist->source_addr.in6.sin6_flowinfo = htonl(0);
#ifdef HAVE_SOCKADDR_SA_LEN
			newlist->addr.in6.sin6_len = newlist->source_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
#endif
			if (source)
			  {
			    if (inet_pton(AF_INET6, source+1, &newlist->source_addr.in6.sin6_addr))
			      newlist->flags |= SERV_HAS_SOURCE;
			    else
			      option = '?'; /* error */
			  }
			else
			  newlist->source_addr.in6.sin6_addr = in6addr_any; 
		      }
#endif
		    else
		      option = '?'; /* error */
		    
		  }
		
		if (option == '?')
		  while (newlist)
		    { 
		      serv = newlist;
		      newlist = newlist->next;
		      free(serv);
		    }
		else
		  {
		    serv = newlist;
		    while (serv->next)
		      {
			serv->next->flags = serv->flags;
			serv->next->addr = serv->addr;
			serv->next->source_addr = serv->source_addr;
			serv = serv->next;
		      }
		    serv->next = daemon->servers;
		    daemon->servers = newlist;
		  }
		break;
	      }
	      
	    case 'c':
	      {
		int size;
		if (!atoi_check(optarg, &size))
		  option = '?';
		else
		  {
		    /* zero is OK, and means no caching. */
		    
		    if (size < 0)
		      size = 0;
		    else if (size > 10000)
		      size = 10000;
		    
		    daemon->cachesize = size;
		  }
		break;
	      }
	      
	    case 'p':
	      if (!atoi_check(optarg, &daemon->port))
		option = '?';
	      break;
	      
	    case 'P':
	      {
		int i;
		if (!atoi_check(optarg, &i))
		  option = '?';
		daemon->edns_pktsz = (unsigned short)i;	
		break;
	      }

	    case 'Q':
	      if (!atoi_check(optarg, &daemon->query_port))
		option = '?';
	      break;

	    case 'T':
	      {
		int ttl;
		if (!atoi_check(optarg, &ttl))
		  option = '?';
		else
		  daemon->local_ttl = (unsigned long)ttl;
		break;
	      }

	    case 'X':
	      if (!atoi_check(optarg, &daemon->dhcp_max))
		option = '?';
	      break;

	    case 'F':
	      {
		int k, leasepos = 2;
		char *cp, *a[5] = { NULL, NULL, NULL, NULL, NULL };
		struct dhcp_context *new = safe_malloc(sizeof(struct dhcp_context));
		
		new->next = daemon->dhcp;
		new->lease_time = DEFLEASE;
		new->addr_epoch = 0;
		new->netmask.s_addr = 0;
		new->broadcast.s_addr = 0;
		new->router.s_addr = 0;
		new->netid.net = NULL;
		new->static_only = 0;
		
		problem = "bad dhcp-range";

		for (cp = optarg; *cp; cp++)
		  if (!(*cp == ' ' || *cp == '.' ||  (*cp >='0' && *cp <= '9')))
		    break;

		if (*cp != ',' && (comma = strchr(optarg, ',')))
		  {
		    *comma = 0;
		    new->netid.net = safe_string_alloc(optarg);
		    a[0] = comma + 1;
		  }
		else
		  a[0] = optarg;

		
		for (k = 1; k < 5; k++)
		  {
		    if (!(a[k] = strchr(a[k-1], ',')))
		      break;
		    *(a[k]++) = 0;
		  }
		  
		if ((k < 2) || ((new->start.s_addr = inet_addr(a[0])) == (in_addr_t)-1))
		  option = '?';
		else if (strcmp(a[1], "static") == 0)
		  {
		    new->end = new->start;
		    new->static_only = 1;
		  }
		else if ((new->end.s_addr = inet_addr(a[1])) == (in_addr_t)-1)
		  option = '?';
		  
		if (ntohl(new->start.s_addr) > ntohl(new->end.s_addr))
		  {
		    struct in_addr tmp = new->start;
		    new->start = new->end;
		    new->end = tmp;
		  }
		    
		if (option != '?' && k >= 3 && strchr(a[2], '.') &&  
		    ((new->netmask.s_addr = inet_addr(a[2])) != (in_addr_t)-1))
		  {
		    leasepos = 3;
		    if (!is_same_net(new->start, new->end, new->netmask))
		      {
			problem = "inconsistent DHCP range";
			option = '?';
		      }
		  }

		if (option == '?')
		  {
		    free(new);
		    break;
		  }
		else
		  daemon->dhcp = new;

		if (k >= 4 && strchr(a[3], '.') &&  
		    ((new->broadcast.s_addr = inet_addr(a[3])) != (in_addr_t)-1))
		  leasepos = 4;

		if (k >= leasepos+1)
		  {
		    if (strcmp(a[leasepos], "infinite") == 0)
		      new->lease_time = 0xffffffff;
		    else
		      {
			int fac = 1;
			if (strlen(a[leasepos]) > 0)
			  {
			    switch (a[leasepos][strlen(a[leasepos]) - 1])
			      {
			      case 'h':
			      case 'H':
				fac *= 60;
				/* fall through */
			      case 'm':
			      case 'M':
				fac *= 60;
				/* fall through */
			      case 's':
			      case 'S':
				a[leasepos][strlen(a[leasepos]) - 1] = 0;
			      }
			    
			    new->lease_time = atoi(a[leasepos]) * fac;
			  }
		      }
		  }
				
		if (new->lease_time < daemon->min_leasetime)
		  daemon->min_leasetime = new->lease_time;
		break;
	      }

	    case 'G':
	      {
		int j, k;
		char *a[6] = { NULL, NULL, NULL, NULL, NULL, NULL };
		unsigned int e0, e1, e2, e3, e4, e5;
		struct dhcp_config *new = safe_malloc(sizeof(struct dhcp_config));
		struct in_addr in;

		new->next = daemon->dhcp_conf;
		new->flags = 0;		  
		
		
		a[0] = optarg;
		for (k = 1; k < 6; k++)
		  {
		    if (!(a[k] = strchr(a[k-1], ',')))
		      break;
		    *(a[k]++) = 0;
		  }
		   
		for(j = 0; j < k; j++)
		  if (strchr(a[j], ':')) /* ethernet address, netid or binary CLID */
		    {
		      char *arg = a[j];
		      if ((arg[0] == 'i' || arg[0] == 'I') &&
			  (arg[1] == 'd' || arg[1] == 'D') &&
			  arg[2] == ':')
			{
			  if (arg[3] == '*')
			    new->flags |= CONFIG_NOCLID;
			  else
			    {
			      int len;
			      arg += 3; /* dump id: */
			      if (strchr(arg, ':'))
				{
				  /* decode hex in place */
				  char *p = arg, *q = arg, *r;
				  while (*p)
				    {
				      for (r = p; *r && *r != ':'; r++);
				      if (*r)
					{
					  if (r != p)
					    {
					      *r = 0;
					      *(q++) = strtol(p, NULL, 16);
					    }
					  p = r+1;
					}
				      else
					{
					  if (*p)
					    *(q++) = strtol(p, NULL, 16);
					  break;
					}
				    }
				  len = q - arg;
				}
			      else
				len = strlen(arg);
			      
			      new->flags |= CONFIG_CLID;
			      new->clid_len = len;
			      new->clid = safe_malloc(len);
			      memcpy(new->clid, arg, len);
			    }
			}
		      else if (strstr(arg, "net:") == arg)
			{
			  new->flags |= CONFIG_NETID;
			  new->netid.net = safe_string_alloc(arg+4);
			}
		      else if (sscanf(a[j], "%x:%x:%x:%x:%x:%x",
				      &e0, &e1, &e2, &e3, &e4, &e5) == 6)
			{
			  new->flags |= CONFIG_HWADDR;
			  new->hwaddr[0] = e0;
			  new->hwaddr[1] = e1;
			  new->hwaddr[2] = e2;
			  new->hwaddr[3] = e3;
			  new->hwaddr[4] = e4;
			  new->hwaddr[5] = e5;
			}
		      else
			option = '?';
		    }
		  else if (strchr(a[j], '.') && (in.s_addr = inet_addr(a[j])) != (in_addr_t)-1)
		    {
		      new->addr = in;
		      new->flags |= CONFIG_ADDR;
		    }
		  else
		    {
		      char *cp, *lastp = NULL, last = 0;
		      int fac = 1;
		      
		      if (strlen(a[j]) > 1)
			{
			  lastp = a[j] + strlen(a[j]) - 1;
			  last = *lastp;
			  switch (last)
			    {
			    case 'h':
			    case 'H':
			      fac *= 60;
			      /* fall through */
			    case 'm':
			    case 'M':
			      fac *= 60;
			      /* fall through */
			    case 's':
			    case 'S':
			      *lastp = 0;
			    }
			}
		      
		      for (cp = a[j]; *cp; cp++)
			if (!isdigit(*cp) && *cp != ' ')
			  break;
		      
		      if (*cp)
			{
			  if (lastp)
			    *lastp = last;
			  if (strcmp(a[j], "infinite") == 0)
			    {
			      new->lease_time = 0xffffffff;
			      new->flags |= CONFIG_TIME;
			    }
			  else if (strcmp(a[j], "ignore") == 0)
			    new->flags |= CONFIG_DISABLE;
			  else
			    {
			      new->hostname = safe_string_alloc(a[j]);
			      new->flags |= CONFIG_NAME;
			    }
			}
		      else
			{
			  new->lease_time = atoi(a[j]) * fac; 
			  new->flags |= CONFIG_TIME;
			}
		    }

		if (option == '?')
		  {
		    problem = "bad dhcp-host";
		    if (new->flags & CONFIG_NAME)
		      free(new->hostname);
		    if (new->flags & CONFIG_CLID)
		      free(new->clid);
		    if (new->flags & CONFIG_NETID)
		      free(new->netid.net);
		    free(new);
		  }
		else
		  {
		    if ((new->flags & CONFIG_TIME) && new->lease_time < daemon->min_leasetime)
		      daemon->min_leasetime = new->lease_time;
		    daemon->dhcp_conf = new;
		  }
		break;
	      }
	      
	    case 'O':
	      {
		struct dhcp_opt *new = safe_malloc(sizeof(struct dhcp_opt));
		char *cp;
		int addrs, digs, is_addr, is_hex, is_dec;
		
		new->next = daemon->dhcp_opts;
		new->len = 0;
		new->is_addr = 0;
		new->netid = NULL;
		new->val = NULL;
				
		if ((comma = strchr(optarg, ',')))
		  {
		    struct dhcp_netid *np = NULL;
		    *comma++ = 0;
		
		    do {
		      for (cp = optarg; *cp; cp++)
			if (!(*cp == ' ' || (*cp >='0' && *cp <= '9')))
			  break;
		      if (!*cp)
			break;
		      
		      new->netid = safe_malloc(sizeof (struct dhcp_netid));
		      new->netid->net = safe_string_alloc(optarg);
		      new->netid->next = np;
		      np = new->netid;
		      optarg = comma;
		      if ((comma = strchr(optarg, ',')))
			*comma++ = 0;
		    } while (optarg);
		  }
		
		if (!optarg || (new->opt = atoi(optarg)) == 0)
		  {
		    option = '?';
		    problem = "bad dhcp-option";
		  }
		else if (comma && new->opt == 119)
		  {
		    /* dns search, RFC 3397 */
		    unsigned char *q, *r, *tail;
		    unsigned char *p = NULL;
		    int newlen, len = 0;
		    
		    optarg = comma;
		    if ((comma = strchr(optarg, ',')))
		      *(comma++) = 0;

		    while (optarg && *optarg)
		      {
			if (!canonicalise(optarg))
			  {
			    option = '?';
			    problem = "bad domain in dhcp-option";
			    break;
			  }
			
			if (!(r = realloc(p, len + strlen(optarg) + 2)))
			  die("could not get memory", NULL);
			p = memmove(r, p, len);
			
			q = p + len;
			
			/* add string on the end in RFC1035 format */
			while (*optarg) 
			  {
			    char *cp = q++;
			    int j;
			    for (j = 0; *optarg && (*optarg != '.'); optarg++, j++)
			      *q++ = *optarg;
			    *cp = j;
			    if (*optarg)
			      optarg++;
			  }
			*q++ = 0;
			
			/* Now tail-compress using earlier names. */
			newlen = q - p;
			for (tail = p + len; *tail; tail += (*tail) + 1)
			  for (r = p; r - p < len; r += (*r) + 1)
			    if (strcmp(r, tail) == 0)
			      {
				PUTSHORT((r - p) | 0xc000, tail); 
				newlen = tail - p;
				goto end;
			      }
		      end:
			len = newlen;
		    
			optarg = comma;
			if (optarg && (comma = strchr(optarg, ',')))
			  *(comma++) = 0;
		      }

		    new->len = len;
		    new->val = p;
		  }
		else if (comma)
		  {
		    /* not option 119 */
		    /* characterise the value */
		    is_addr = is_hex = is_dec = 1;
		    addrs = digs = 1;
		    for (cp = comma; *cp; cp++)
		      if (*cp == ',')
			{
			  addrs++;
			  is_dec = is_hex = 0;
			}
		      else if (*cp == ':')
			{
			  digs++;
			  is_dec = is_addr = 0;
			}
		      else if (*cp == '.')
			is_dec = is_hex = 0;
		      else if (!((*cp >='0' && *cp <= '9') || *cp == '-'))
			{
			  is_dec = is_addr = 0;
			  if (!((*cp >='A' && *cp <= 'F') ||
				(*cp >='a' && *cp <= 'f')))
			    is_hex = 0;
			}
		
		    if (is_hex && digs > 1)
		      {
			char *p = comma, *q, *r;
			new->len = digs;
			q = new->val = safe_malloc(new->len);
			while (*p)
			  {
			    for (r = p; *r && *r != ':'; r++);
			    if (*r)
			      {
				if (r != p)
				  {
				    *r = 0;
				    *(q++) = strtol(p, NULL, 16);
				  }
				p = r+1;
			      }
			    else
			      {
				if (*p)
				  *(q++) = strtol(p, NULL, 16);
				break;
			      }
			  }
		      }
		    else if (is_dec)
		      {
			int i, val = atoi(comma);
			/* assume numeric arg is 1 byte except for
			   options where it is known otherwise. */
			switch (new->opt)
			  {
			  default:
			    new->len = 1;
			    break;
			  case 13: case 22: case 25: case 26: 
			    new->len = 2;
			    break;
			  case 2: case 24: case 35: case 38: 
			    new->len = 4;
			    break;
			  }
			new->val = safe_malloc(new->len);
			for (i=0; i<new->len; i++)
			  new->val[i] = val>>((new->len - i - 1)*8);
		      }
		    else if (is_addr)	
		      {
			struct in_addr in;
			unsigned char *op;
			new->len = INADDRSZ * addrs;
			new->val = op = safe_malloc(new->len);
			new->is_addr = 1;
			while (addrs--) 
			  {
			    cp = comma;
			    if ((comma = strchr(cp, ',')))
			      *comma++ = 0;
			    in.s_addr = inet_addr(cp);
			    memcpy(op, &in, INADDRSZ);
			    op += INADDRSZ;
			  }
		      }
		    else
		      {
			/* text arg */
			new->len = strlen(comma);
			new->val = safe_malloc(new->len);
			memcpy(new->val, comma, new->len);
		      }
		  }

		if (new->len > 256)
		  {
		    option = '?';
		    problem = "dhcp-option too long";
		  }

		if (option == '?')
		  {
		    if (new->netid)
		      free(new->netid);
		    if (new->val)
		      free(new->val);
		    free(new);
		  }
		else
		  daemon->dhcp_opts = new;

		break;
	      }

	    case 'M':
	      {
		struct dhcp_netid *id = NULL;
		while (optarg && strstr(optarg, "net:") == optarg)
		  {
		    struct dhcp_netid *newid = safe_malloc(sizeof(struct dhcp_netid));
		    newid->next = id;
		    id = newid;
		    if ((comma = strchr(optarg, ',')))
		      *comma++ = 0;
		    newid->net = safe_string_alloc(optarg+4);
		    optarg = comma;
		  };
		
		if (!optarg)
		  option = '?';
		else 
		  {
		    char *dhcp_file, *dhcp_sname = NULL;
		    struct in_addr dhcp_next_server;
		    if ((comma = strchr(optarg, ',')))
		      *comma++ = 0;
		    dhcp_file = safe_string_alloc(optarg);
		    dhcp_next_server.s_addr = 0;
		    if (comma)
		      {
			optarg = comma;
			if ((comma = strchr(optarg, ',')))
			  *comma++ = 0;
			dhcp_sname = safe_string_alloc(optarg);
			if (comma && (dhcp_next_server.s_addr = inet_addr(comma)) == (in_addr_t)-1)
			  option = '?';
		      }
		    if (option != '?')
		      {
			struct dhcp_boot *new = safe_malloc(sizeof(struct dhcp_boot));
			new->file = dhcp_file;
			new->sname = dhcp_sname;
			new->next_server = dhcp_next_server;
			new->netid = id;
			new->next = daemon->boot_config;
			daemon->boot_config = new;
		      }
		  }

		if (option == '?')
		  {
		    struct dhcp_netid *tmp;
		    for (; id; id = tmp)
		      {
			tmp = id->next;
			free(id);
		      }
		  }
		break;
	      }

	    case 'U':
	    case 'j':
	      {
		if (!(comma = strchr(optarg, ',')))
		  option = '?';
		else
		  {
		    struct dhcp_vendor *new = safe_malloc(sizeof(struct dhcp_vendor));
		    *comma = 0;
		    new->netid.net = safe_string_alloc(optarg);
		    new->len = strlen(comma+1);
		    new->data = safe_malloc(new->len);
		    memcpy(new->data, comma+1, new->len);
		    new->is_vendor = (option == 'U');
		    new->next = daemon->dhcp_vendors;
		    daemon->dhcp_vendors = new;
		  }
		break;
	      }
	      
	    case 'J':
	      {
		struct dhcp_netid_list *new = safe_malloc(sizeof(struct dhcp_netid_list));
		struct dhcp_netid *list = NULL;
		new->next = daemon->dhcp_ignore;
		daemon->dhcp_ignore = new;
		do {
		  struct dhcp_netid *member = safe_malloc(sizeof(struct dhcp_netid));
		  if ((comma = strchr(optarg, ',')))
		    *comma++ = 0;
		  member->next = list;
		  list = member;
		  member->net = safe_string_alloc(optarg);
		  optarg = comma;
		} while (optarg);
		
		new->list = list;
		break;
	      }

	    case 'V':
	      {
		char *a[3] = { NULL, NULL, NULL };
		int k;
		struct in_addr in, out, mask;
		struct doctor *new;

		mask.s_addr = 0xffffffff;
		
		a[0] = optarg;
		for (k = 1; k < 4; k++)
		  {
		    if (!(a[k] = strchr(a[k-1], ',')))
		      break;
		    *(a[k]++) = 0;
		  }

		if ((k < 2) ||
		    ((in.s_addr = inet_addr(a[0])) == (in_addr_t)-1) ||
		    ((out.s_addr = inet_addr(a[1])) == (in_addr_t)-1))
		  {
		    option = '?';
		    break;
		  }

		if (k == 3)
		  mask.s_addr = inet_addr(a[2]);

		new = safe_malloc(sizeof(struct doctor));
		new->in = in;
		new->out = out;
		new->mask = mask;
		new->next = daemon->doctors;
		daemon->doctors = new;
		
		break;
	      }
	    }
	}
      
      if (option == '?')
	{
	  if (f)
	    {
	      sprintf(buff, "%s at line %d of %s ", 
		      problem ? problem : "error", lineno, conffile);
	      complain(buff, NULL);
	    }
	  else
#ifdef HAVE_GETOPT_LONG
	    die("bad command line options: %s.", problem ? problem : "try --help");
#else
	    die("bad command line options: %s.", problem ? problem : "try -w");
#endif
	}
    }
      
  /* port might no be known when the address is parsed - fill in here */
  if (daemon->servers)
    {
      struct server *tmp;
      for (tmp = daemon->servers; tmp; tmp = tmp->next)
	if (!(tmp->flags & SERV_HAS_SOURCE))
	  {
	    if (tmp->source_addr.sa.sa_family == AF_INET)
	      tmp->source_addr.in.sin_port = htons(daemon->query_port);
#ifdef HAVE_IPV6
	    else if (tmp->source_addr.sa.sa_family == AF_INET6)
	      tmp->source_addr.in6.sin6_port = htons(daemon->query_port);
#endif  
	  }
    }
  
  if (daemon->if_addrs)
    {  
      struct iname *tmp;
      for(tmp = daemon->if_addrs; tmp; tmp = tmp->next)
	if (tmp->addr.sa.sa_family == AF_INET)
	  tmp->addr.in.sin_port = htons(daemon->port);
#ifdef HAVE_IPV6
	else if (tmp->addr.sa.sa_family == AF_INET6)
	  tmp->addr.in6.sin6_port = htons(daemon->port);
#endif /* IPv6 */
    }
		      
  /* only one of these need be specified: the other defaults to the
     host-name */
  if ((daemon->options & OPT_LOCALMX) || daemon->mxnames || daemon->mxtarget)
    {
      if (gethostname(buff, MAXDNAME) == -1)
	die("cannot get host-name: %s", NULL);
	      
      if (!daemon->mxnames)
	{
	  daemon->mxnames = safe_malloc(sizeof(struct mx_record));
	  daemon->mxnames->next = NULL;
	  daemon->mxnames->mxtarget = NULL;
	  daemon->mxnames->mxname = safe_string_alloc(buff);
}
      
      if (!daemon->mxtarget)
	daemon->mxtarget = safe_string_alloc(buff);
    }
  
  if (daemon->options & OPT_NO_RESOLV)
    daemon->resolv_files = 0;
  else if (daemon->resolv_files && (daemon->resolv_files)->next && (daemon->options & OPT_NO_POLL))
    die("only one resolv.conf file allowed in no-poll mode.", NULL);
  
  if (daemon->options & OPT_RESOLV_DOMAIN)
    {
      char *line;
      
      if (!daemon->resolv_files || (daemon->resolv_files)->next)
	die("must have exactly one resolv.conf to read domain from.", NULL);
      
      if (!(f = fopen((daemon->resolv_files)->name, "r")))
	die("failed to read %s: %m", (daemon->resolv_files)->name);
      
      while ((line = fgets(buff, MAXDNAME, f)))
	{
	  char *token = strtok(line, " \t\n\r");
	  
	  if (!token || strcmp(token, "search") != 0)
	    continue;
	  
	  if ((token = strtok(NULL, " \t\n\r")) &&  
	      canonicalise(token) &&
	      (daemon->domain_suffix = safe_string_alloc(token)))
	    break;
	}

      fclose(f);

      if (!daemon->domain_suffix)
	die("no search directive found in %s", (daemon->resolv_files)->name);
    }
      
  return daemon;
}