/* dnsmasq is Copyright (c) 2000-2026 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, or

   (at your option) version 3 dated 29 June, 2007.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/* Declare static char *compiler_opts  in config.h */

#define DNSMASQ_COMPILE_OPTS

/* dnsmasq.h has to be included first as it sources config.h */

#include "dnsmasq.h"

#if defined(HAVE_IDN) || defined(HAVE_LIBIDN2) || defined(LOCALEDIR)

#include <locale.h>

#endif

struct daemon *daemon;

static volatile pid_t pid = 0;

static volatile int pipewrite;

static void set_dns_listeners(void);

#ifdef HAVE_TFTP

static void set_tftp_listeners(void);

#endif

static void check_dns_listeners(time_t now);

static void do_tcp_connection(struct listener *listener, time_t now, int slot);

static void sig_handler(int sig);

static void async_event(int pipe, time_t now);

static void fatal_event(struct event_desc *ev, char *msg);

static int read_event(int fd, struct event_desc *evp, char **msg);

static void poll_resolv(int force, int do_reload, time_t now);

int main2 (int argc, char **argv)

{

  time_t now;

  struct sigaction sigact;

  struct iname *if_tmp;

  int piperead, pipefd[2], err_pipe[2];

  struct passwd *ent_pw = NULL;

#if defined(HAVE_SCRIPT)

  uid_t script_uid = 0;

  gid_t script_gid = 0;

#endif

  struct group *gp = NULL;

  long i, max_fd = sysconf(_SC_OPEN_MAX);

  char *baduser = NULL;

  int log_err;

  int chown_warn = 0;

#if defined(HAVE_LINUX_NETWORK)

  cap_user_header_t hdr = NULL;

  cap_user_data_t data = NULL;

  int need_cap_net_admin = 0;

  int need_cap_net_raw = 0;

  int need_cap_net_bind_service = 0;

  int have_cap_chown = 0;

#  ifdef HAVE_DHCP

  char *bound_device = NULL;

  int did_bind = 0;

#  endif

  struct server *serv;

  char *netlink_warn;

#else

  int bind_fallback = 0;

#endif 

#if defined(HAVE_DHCP)

  struct dhcp_context *context;

  struct dhcp_relay *relay;

#endif

#ifdef HAVE_TFTP

  int tftp_prefix_missing = 0;

#endif

#ifdef HAVE_LINUX_NETWORK

  (void)netlink_warn;

#endif

#if defined(HAVE_IDN) || defined(HAVE_LIBIDN2) || defined(LOCALEDIR)

  setlocale(LC_ALL, "");

#endif

#ifdef LOCALEDIR

  bindtextdomain("dnsmasq", LOCALEDIR); 

  textdomain("dnsmasq");

#endif

  sigact.sa_handler = sig_handler;

  sigact.sa_flags = 0;

  sigemptyset(&sigact.sa_mask);

  sigaction(SIGUSR1, &sigact, NULL);

  sigaction(SIGUSR2, &sigact, NULL);

  sigaction(SIGHUP, &sigact, NULL);

  sigaction(SIGTERM, &sigact, NULL);

  sigaction(SIGALRM, &sigact, NULL);

  sigaction(SIGCHLD, &sigact, NULL);

  sigaction(SIGINT, &sigact, NULL);

  /* ignore SIGPIPE */

  sigact.sa_handler = SIG_IGN;

  sigaction(SIGPIPE, &sigact, NULL);

  umask(022); /* known umask, create leases and pid files as 0644 */

  rand_init(); /* Must precede read_opts() */

  read_opts(argc, argv, compile_opts);

#ifdef HAVE_LINUX_NETWORK

  daemon->kernel_version = kernel_version();

#endif

  if (daemon->edns_pktsz < PACKETSZ)

    daemon->edns_pktsz = PACKETSZ;

  /* Min buffer size: we check after adding each record, so there must be 

     memory for the largest packet, and the largest record so the

     min for DNS is PACKETSZ+MAXDNAME+RRFIXEDSZ which is < 1000.

     This might be increased is EDNS packet size if greater than the minimum. */ 

  daemon->packet_buff_sz = daemon->edns_pktsz + MAXDNAME + RRFIXEDSZ;

  daemon->packet = safe_malloc(daemon->packet_buff_sz);

  daemon->pipe_to_parent = -1;

  if (option_bool(OPT_EXTRALOG))

    daemon->addrbuff2 = safe_malloc(ADDRSTRLEN);

#ifdef HAVE_DNSSEC

  if (option_bool(OPT_DNSSEC_VALID))

    {

      daemon->keyname = safe_malloc(MAXDNAMESTR + 1);

      daemon->cname = safe_malloc(MAXDNAMESTR + 1);

      /* one char flag per possible RR in answer section (may get extended). */

      daemon->rr_status_sz = 64;

      daemon->rr_status = safe_malloc(sizeof(*daemon->rr_status) * daemon->rr_status_sz);

    }

#endif

#ifdef HAVE_DHCP

  if (!daemon->lease_file)

    {

      if (daemon->dhcp || daemon->dhcp6)

  daemon->lease_file = LEASEFILE;

    }

#endif

  /* Ensure that at least stdin, stdout and stderr (fd 0, 1, 2) exist,

     otherwise file descriptors we create can end up being 0, 1, or 2 

     and then get accidentally closed later when we make 0, 1, and 2 

     open to /dev/null. Normally we'll be started with 0, 1 and 2 open, 

     but it's not guaranteed. By opening /dev/null three times, we 

     ensure that we're not using those fds for real stuff. */

  for (i = 0; i < 3; i++)

    open("/dev/null", O_RDWR); 

  /* Close any file descriptors we inherited apart from std{in|out|err} */

  close_fds(max_fd, -1, -1, -1);

#ifndef HAVE_LINUX_NETWORK

#  if !(defined(IP_RECVDSTADDR) && defined(IP_RECVIF) && defined(IP_SENDSRCADDR))

  if (!option_bool(OPT_NOWILD))

    {

      bind_fallback = 1;

      set_option_bool(OPT_NOWILD);

    }

#  endif

  /* -- bind-dynamic not supported on !Linux, fall back to --bind-interfaces */

  if (option_bool(OPT_CLEVERBIND))

    {

      bind_fallback = 1;

      set_option_bool(OPT_NOWILD);

      reset_option_bool(OPT_CLEVERBIND);

    }

#endif

#ifndef HAVE_INOTIFY

  if (daemon->dynamic_dirs)

    die(_("dhcp-hostsdir, dhcp-optsdir and hostsdir are not supported on this platform"), NULL, EC_BADCONF);

#endif

  if (option_bool(OPT_DNSSEC_VALID))

    {

#ifdef HAVE_DNSSEC

      struct ds_config *ds;

      /* Must have at least a root trust anchor, or the DNSSEC code

   can loop forever. */

      for (ds = daemon->ds; ds; ds = ds->next)

  if (ds->name && ds->name[0] == 0)

    break;

      if (!ds)

  die(_("no root trust anchor provided for DNSSEC"), NULL, EC_BADCONF);

      if (daemon->cachesize < CACHESIZ)

  die(_("cannot reduce cache size from default when DNSSEC enabled"), NULL, EC_BADCONF);

#else 

      die(_("DNSSEC not available: set HAVE_DNSSEC in src/config.h"), NULL, EC_BADCONF);

#endif

    }

#ifndef HAVE_TFTP

  if (option_bool(OPT_TFTP))

    die(_("TFTP server not available: set HAVE_TFTP in src/config.h"), NULL, EC_BADCONF);

#endif

#ifdef HAVE_CONNTRACK

  if (option_bool(OPT_CONNTRACK))

    {

      if (daemon->query_port != 0 || daemon->osport)

  die (_("cannot use --conntrack AND --query-port"), NULL, EC_BADCONF);

      need_cap_net_admin = 1;

    }

#else

  if (option_bool(OPT_CONNTRACK))

    die(_("conntrack support not available: set HAVE_CONNTRACK in src/config.h"), NULL, EC_BADCONF);

#endif

#ifdef HAVE_SOLARIS_NETWORK

  if (daemon->max_logs != 0)

    die(_("asynchronous logging is not available under Solaris"), NULL, EC_BADCONF);

#endif

#ifdef __ANDROID__

  if (daemon->max_logs != 0)

    die(_("asynchronous logging is not available under Android"), NULL, EC_BADCONF);

#endif

#ifndef HAVE_AUTH

  if (daemon->auth_zones)

    die(_("authoritative DNS not available: set HAVE_AUTH in src/config.h"), NULL, EC_BADCONF);

#endif

#ifndef HAVE_LOOP

  if (option_bool(OPT_LOOP_DETECT))

    die(_("loop detection not available: set HAVE_LOOP in src/config.h"), NULL, EC_BADCONF);

#endif

#ifndef HAVE_UBUS

  if (option_bool(OPT_UBUS))

    die(_("Ubus not available: set HAVE_UBUS in src/config.h"), NULL, EC_BADCONF);

#endif

  /* Handle only one of min_port/max_port being set. */

  if (daemon->min_port != 0 && daemon->max_port == 0)

    daemon->max_port = MAX_PORT;

  if (daemon->max_port != 0 && daemon->min_port == 0)

    daemon->min_port = MIN_PORT;

  if (daemon->max_port < daemon->min_port)

    die(_("max_port cannot be smaller than min_port"), NULL, EC_BADCONF);

  if (daemon->max_port != 0 &&

      daemon->max_port - daemon->min_port + 1 < daemon->randport_limit)

    die(_("port_limit must not be larger than available port range"), NULL, EC_BADCONF);

  now = dnsmasq_time();

  if (daemon->auth_zones)

    {

      if (!daemon->authserver)

  die(_("--auth-server required when an auth zone is defined."), NULL, EC_BADCONF);

      /* Create a serial at startup if not configured. */

#ifdef HAVE_BROKEN_RTC

      if (daemon->soa_sn == 0)

  die(_("zone serial must be configured in --auth-soa"), NULL, EC_BADCONF);

#else

      if (daemon->soa_sn == 0)

  daemon->soa_sn = now;

#endif

    }

#ifdef HAVE_DHCP6

  if (daemon->dhcp6)

    {

      daemon->doing_ra = option_bool(OPT_RA);

      for (context = daemon->dhcp6; context; context = context->next)

  {

    if (context->flags & CONTEXT_DHCP)

      daemon->doing_dhcp6 = 1;

    if (context->flags & CONTEXT_RA)

      daemon->doing_ra = 1;

#if !defined(HAVE_LINUX_NETWORK) && !defined(HAVE_BSD_NETWORK)

    if (context->flags & CONTEXT_TEMPLATE)

      die (_("dhcp-range constructor not available on this platform"), NULL, EC_BADCONF);

#endif 

  }

    }

#endif

#ifdef HAVE_DHCP

  /* Note that order matters here, we must call lease_init before

     creating any file descriptors which shouldn't be leaked

     to the lease-script init process. We need to call common_init

     before lease_init to allocate buffers it uses.

     The script subsystem relies on DHCP buffers, hence the last two

     conditions below. */  

  if (daemon->dhcp || daemon->doing_dhcp6 || daemon->relay4 || 

      daemon->relay6 || option_bool(OPT_TFTP) || option_bool(OPT_SCRIPT_ARP))

    {

      dhcp_common_init();

      if (daemon->dhcp || daemon->doing_dhcp6)

  lease_init(now);

    }

  if (daemon->dhcp || daemon->relay4)

    {

      dhcp_init();

#   ifdef HAVE_LINUX_NETWORK

      /* Need NET_RAW to send ping. */

      if (!option_bool(OPT_NO_PING))

  need_cap_net_raw = 1;

      /* Need NET_ADMIN to change ARP cache if not always broadcasting. */

      if (daemon->force_broadcast == NULL || daemon->force_broadcast->list != NULL)

        need_cap_net_admin = 1;

#   endif

    }

#  ifdef HAVE_DHCP6

  if (daemon->doing_ra || daemon->doing_dhcp6 || daemon->relay6)

    {

      ra_init(now);

#   ifdef HAVE_LINUX_NETWORK

      need_cap_net_raw = 1;

      need_cap_net_admin = 1;

#   endif

    }

  if (daemon->doing_dhcp6 || daemon->relay6)

    dhcp6_init();

#  endif

#endif

#ifdef HAVE_IPSET

  if (daemon->ipsets)

    {

      ipset_init();

#  ifdef HAVE_LINUX_NETWORK

      need_cap_net_admin = 1;

#  endif

    }

#endif

#ifdef HAVE_NFTSET

  if (daemon->nftsets)

    {

      nftset_init();

#  ifdef HAVE_LINUX_NETWORK

      need_cap_net_admin = 1;

#  endif

    }

#endif

#if  defined(HAVE_LINUX_NETWORK)

  netlink_warn = netlink_init();

#elif defined(HAVE_BSD_NETWORK)

  route_init();

#endif

  if (option_bool(OPT_NOWILD) && option_bool(OPT_CLEVERBIND))

    die(_("cannot set --bind-interfaces and --bind-dynamic"), NULL, EC_BADCONF);

  if (!enumerate_interfaces(1) || !enumerate_interfaces(0))

    die(_("failed to find list of interfaces: %s"), NULL, EC_MISC);

#ifdef HAVE_DHCP

  /* Determine lease FQDNs after enumerate_interfaces() call, since it needs

     to call get_domain and that's only valid for some domain configs once we

     have interface addresses. */

  lease_calc_fqdns();

#endif

  if (option_bool(OPT_NOWILD) || option_bool(OPT_CLEVERBIND)) 

    {

      create_bound_listeners(1);

      if (!option_bool(OPT_CLEVERBIND))

  for (if_tmp = daemon->if_names; if_tmp; if_tmp = if_tmp->next)

    if (if_tmp->name && !(if_tmp->flags & INAME_USED))

      die(_("unknown interface %s"), if_tmp->name, EC_BADNET);

#if defined(HAVE_LINUX_NETWORK) && defined(HAVE_DHCP)

      /* after enumerate_interfaces()  */

      bound_device = whichdevice();

      if ((did_bind = bind_dhcp_devices(bound_device)) & 2)

  die(_("failed to set SO_BINDTODEVICE on DHCP socket: %s"), NULL, EC_BADNET);  

#endif

    }

  else 

    create_wildcard_listeners();

#ifdef HAVE_DHCP6

  /* after enumerate_interfaces() */

  if (daemon->doing_dhcp6 || daemon->relay6 || daemon->doing_ra)

    join_multicast(1);

  /* After netlink_init() and before create_helper() */

  lease_make_duid(now);

#endif

  if (daemon->port != 0)

    {

      cache_init();

      blockdata_init();

      /* Scale random socket pool by ftabsize, but

   limit it based on available fds. */

      daemon->numrrand = daemon->ftabsize/2;

      if (daemon->numrrand > max_fd/3)

  daemon->numrrand = max_fd/3;

      /* safe_malloc returns zero'd memory */

      daemon->randomsocks = safe_malloc(daemon->numrrand * sizeof(struct randfd));

      daemon->tcp_pids = safe_malloc(daemon->max_procs*sizeof(pid_t));

      daemon->tcp_pipes = safe_malloc(daemon->max_procs*sizeof(int));

      for (i = 0; i < daemon->max_procs; i++)

  daemon->tcp_pipes[i] = -1;

    }

  if (daemon->dump_file)

#ifdef HAVE_DUMPFILE

    dump_init();

  else 

    daemon->dumpfd = -1;

#else

  die(_("Packet dumps not available: set HAVE_DUMP in src/config.h"), NULL, EC_BADCONF);

#endif

  if (option_bool(OPT_DBUS))

#ifdef HAVE_DBUS

    {

      char *err;

      if ((err = dbus_init()))

  die(_("DBus error: %s"), err, EC_MISC);

    }

#else

  die(_("DBus not available: set HAVE_DBUS in src/config.h"), NULL, EC_BADCONF);

#endif

  if (option_bool(OPT_UBUS))

#ifdef HAVE_UBUS

    {

      char *err;

      if ((err = ubus_init()))

  die(_("UBus error: %s"), err, EC_MISC);

    }

#else

  die(_("UBus not available: set HAVE_UBUS in src/config.h"), NULL, EC_BADCONF);

#endif

  if (daemon->port != 0)

    pre_allocate_sfds();

#if defined(HAVE_SCRIPT)

  /* Note getpwnam returns static storage */

  if ((daemon->dhcp || daemon->dhcp6) && 

      daemon->scriptuser && 

      (daemon->lease_change_command || daemon->luascript))

    {

      struct passwd *scr_pw;

      if ((scr_pw = getpwnam(daemon->scriptuser)))

  {

    script_uid = scr_pw->pw_uid;

    script_gid = scr_pw->pw_gid;

   }

      else

  baduser = daemon->scriptuser;

    }

#endif

  if (daemon->username && !(ent_pw = getpwnam(daemon->username)))

    baduser = daemon->username;

  else if (daemon->groupname && !(gp = getgrnam(daemon->groupname)))

    baduser = daemon->groupname;

  if (baduser)

    die(_("unknown user or group: %s"), baduser, EC_BADCONF);

  /* implement group defaults, "dip" if available, or group associated with uid */

  if (!daemon->group_set && !gp)

    {

      if (!(gp = getgrnam(CHGRP)) && ent_pw)

  gp = getgrgid(ent_pw->pw_gid);

      /* for error message */

      if (gp)

  daemon->groupname = gp->gr_name; 

    }

#if defined(HAVE_LINUX_NETWORK)

  /* We keep CAP_NETADMIN (for ARP-injection) and

     CAP_NET_RAW (for icmp) if we're doing dhcp,

     if we have yet to bind ports because of DAD, 

     or we're doing it dynamically, we need CAP_NET_BIND_SERVICE. */

  if ((is_dad_listeners() || option_bool(OPT_CLEVERBIND)) &&

      (option_bool(OPT_TFTP) || (daemon->port != 0 && daemon->port <= 1024)))

    need_cap_net_bind_service = 1;

  /* usptream servers which bind to an interface call SO_BINDTODEVICE

     for each TCP connection, so need CAP_NET_RAW */

  for (serv = daemon->servers; serv; serv = serv->next)

    if (serv->interface[0] != 0)

      need_cap_net_raw = 1;

  /* If we're doing Dbus or UBus, the above can be set dynamically,

     (as can ports) so always (potentially) needed. */

#ifdef HAVE_DBUS

  if (option_bool(OPT_DBUS))

    {

      need_cap_net_bind_service = 1;

      need_cap_net_raw = 1;

    }

#endif

#ifdef HAVE_UBUS

  if (option_bool(OPT_UBUS))

    {

      need_cap_net_bind_service = 1;

      need_cap_net_raw = 1;

    }

#endif

  /* determine capability API version here, while we can still

     call safe_malloc */

  int capsize = 1; /* for header version 1 */

  char *fail = NULL;

  hdr = safe_malloc(sizeof(*hdr));

  /* find version supported by kernel */

  memset(hdr, 0, sizeof(*hdr));

  capget(hdr, NULL);

  if (hdr->version != LINUX_CAPABILITY_VERSION_1)

    {

      /* if unknown version, use largest supported version (3) */

      if (hdr->version != LINUX_CAPABILITY_VERSION_2)

  hdr->version = LINUX_CAPABILITY_VERSION_3;

      capsize = 2;

    }

  data = safe_malloc(sizeof(*data) * capsize);

  capget(hdr, data); /* Get current values, for verification */

  have_cap_chown = data->permitted & (1 << CAP_CHOWN);

  if (need_cap_net_admin && !(data->permitted & (1 << CAP_NET_ADMIN)))

    fail = "NET_ADMIN";

  else if (need_cap_net_raw && !(data->permitted & (1 << CAP_NET_RAW)))

    fail = "NET_RAW";

  else if (need_cap_net_bind_service && !(data->permitted & (1 << CAP_NET_BIND_SERVICE)))

    fail = "NET_BIND_SERVICE";

  if (fail)

    die(_("process is missing required capability %s"), fail, EC_MISC);

  /* Now set bitmaps to set caps after daemonising */

  memset(data, 0, sizeof(*data) * capsize);

  if (need_cap_net_admin)

    data->effective |= (1 << CAP_NET_ADMIN);

  if (need_cap_net_raw)

    data->effective |= (1 << CAP_NET_RAW);

  if (need_cap_net_bind_service)

    data->effective |= (1 << CAP_NET_BIND_SERVICE);

  data->permitted = data->effective;  

#endif

  /* Use a pipe to carry signals and other events back to the event loop 

     in a race-free manner and another to carry errors to daemon-invoking process */

  safe_pipe(pipefd, 1);

  piperead = pipefd[0];

  pipewrite = pipefd[1];

  /* prime the pipe to load stuff first time. */

  send_event(pipewrite, EVENT_INIT, 0, NULL); 

  err_pipe[1] = -1;

  if (!option_bool(OPT_DEBUG))   

    {

      /* The following code "daemonizes" the process. 

   See Stevens section 12.4 */

      if (chdir("/") != 0)

  die(_("cannot chdir to filesystem root: %s"), NULL, EC_MISC); 

      if (!option_bool(OPT_NO_FORK))

  {

    pid_t pid;

    /* pipe to carry errors back to original process.

       When startup is complete we close this and the process terminates. */

    safe_pipe(err_pipe, 0);

    if ((pid = fork()) == -1)

      /* fd == -1 since we've not forked, never returns. */

      send_event(-1, EVENT_FORK_ERR, errno, NULL);

    if (pid != 0)

      {

        struct event_desc ev;

        char *msg;

        /* close our copy of write-end */

        close(err_pipe[1]);

        /* check for errors after the fork */

        if (read_event(err_pipe[0], &ev, &msg))

    fatal_event(&ev, msg);

        _exit(EC_GOOD);

      } 

    close(err_pipe[0]);

    /* NO calls to die() from here on. */

    setsid();

    if ((pid = fork()) == -1)

      send_event(err_pipe[1], EVENT_FORK_ERR, errno, NULL);

    if (pid != 0)

      _exit(0);

  }

      /* write pidfile _after_ forking ! */

      if (daemon->runfile)

  {

    int fd, err = 0;

    sprintf(daemon->namebuff, "%d\n", (int) getpid());

    /* Explanation: Some installations of dnsmasq (eg Debian/Ubuntu) locate the pid-file

       in a directory which is writable by the non-privileged user that dnsmasq runs as. This

       allows the daemon to delete the file as part of its shutdown. This is a security hole to the 

       extent that an attacker running as the unprivileged  user could replace the pidfile with a 

       symlink, and have the target of that symlink overwritten as root next time dnsmasq starts. 

       The following code first deletes any existing file, and then opens it with the O_EXCL flag,

       ensuring that the open() fails should there be any existing file (because the unlink() failed, 

       or an attacker exploited the race between unlink() and open()). This ensures that no symlink

       attack can succeed. 

       Any compromise of the non-privileged user still theoretically allows the pid-file to be

       replaced whilst dnsmasq is running. The worst that could allow is that the usual 

       "shutdown dnsmasq" shell command could be tricked into stopping any other process.

       Note that if dnsmasq is started as non-root (eg for testing) it silently ignores 

       failure to write the pid-file.

    */

    unlink(daemon->runfile); 

    if ((fd = open(daemon->runfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)) == -1)

      {

        /* only complain if started as root */

        if (getuid() == 0)

    err = 1;

      }

    else

      {

        /* We're still running as root here. Change the ownership of the PID file

     to the user we will be running as. Note that this is not to allow

     us to delete the file, since that depends on the permissions 

     of the directory containing the file. That directory will

     need to by owned by the dnsmasq user, and the ownership of the

     file has to match, to keep systemd >273 happy. */

        if (getuid() == 0 && ent_pw && ent_pw->pw_uid != 0 && fchown(fd, ent_pw->pw_uid, ent_pw->pw_gid) == -1)

    chown_warn = errno;

        if (!read_write(fd, (unsigned char *)daemon->namebuff, strlen(daemon->namebuff), RW_WRITE))

    err = 1;

        else

    {

      if (close(fd) == -1)

        err = 1;

    }

      }

    if (err)

      {

        send_event(err_pipe[1], EVENT_PIDFILE, errno, daemon->runfile);

        _exit(0);

      }

  }

    }

   log_err = log_start(ent_pw, err_pipe[1]);

   if (!option_bool(OPT_DEBUG)) 

     {       

       /* open  stdout etc to /dev/null */

       int nullfd = open("/dev/null", O_RDWR);

       if (nullfd != -1)

   {

     dup2(nullfd, STDOUT_FILENO);

     dup2(nullfd, STDERR_FILENO);

     dup2(nullfd, STDIN_FILENO);

     close(nullfd);

   }

     }

   /* if we are to run scripts, we need to fork a helper before dropping root. */

  daemon->helperfd = -1;

#ifdef HAVE_SCRIPT 

  if ((daemon->dhcp ||

       daemon->dhcp6 ||

       daemon->relay6 ||

       option_bool(OPT_TFTP) ||

       option_bool(OPT_SCRIPT_ARP)) && 

      (daemon->lease_change_command || daemon->luascript))

      daemon->helperfd = create_helper(pipewrite, err_pipe[1], script_uid, script_gid, max_fd);

#endif

  if (!option_bool(OPT_DEBUG) && getuid() == 0)   

    {

      int bad_capabilities = 0;

      gid_t dummy;

      /* remove all supplementary groups */

      if (gp && 

    (setgroups(0, &dummy) == -1 ||

     setgid(gp->gr_gid) == -1))

  {

    send_event(err_pipe[1], EVENT_GROUP_ERR, errno, daemon->groupname);

    _exit(0);

  }

      if (ent_pw && ent_pw->pw_uid != 0)

  {     

#if defined(HAVE_LINUX_NETWORK)   

    /* Need to be able to drop root. */

    data->effective |= (1 << CAP_SETUID);

    data->permitted |= (1 << CAP_SETUID);

    /* Tell kernel to not clear capabilities when dropping root */

    if (capset(hdr, data) == -1 || prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1)

      bad_capabilities = errno;

#elif defined(HAVE_SOLARIS_NETWORK)

    /* http://developers.sun.com/solaris/articles/program_privileges.html */

    priv_set_t *priv_set;

    if (!(priv_set = priv_str_to_set("basic", ",", NULL)) ||

        priv_addset(priv_set, PRIV_NET_ICMPACCESS) == -1 ||

        priv_addset(priv_set, PRIV_SYS_NET_CONFIG) == -1)

      bad_capabilities = errno;

    if (priv_set && bad_capabilities == 0)

      {

        priv_inverse(priv_set);

        if (setppriv(PRIV_OFF, PRIV_LIMIT, priv_set) == -1)

    bad_capabilities = errno;

      }

    if (priv_set)

      priv_freeset(priv_set);

#endif    

    if (bad_capabilities != 0)

      {

        send_event(err_pipe[1], EVENT_CAP_ERR, bad_capabilities, NULL);

        _exit(0);

      }

    /* finally drop root */

    if (setuid(ent_pw->pw_uid) == -1)

      {

        send_event(err_pipe[1], EVENT_USER_ERR, errno, daemon->username);

        _exit(0);

      }     

#ifdef HAVE_LINUX_NETWORK

    data->effective &= ~(1 << CAP_SETUID);

    data->permitted &= ~(1 << CAP_SETUID);

    /* lose the setuid capability */

    if (capset(hdr, data) == -1)

      {

        send_event(err_pipe[1], EVENT_CAP_ERR, errno, NULL);

        _exit(0);

      }

#endif

  }

    }

#ifdef HAVE_LINUX_NETWORK

  free(hdr);

  free(data);

  if (option_bool(OPT_DEBUG)) 

    prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);

#endif

#ifdef HAVE_TFTP

  if (option_bool(OPT_TFTP))

    {

      DIR *dir;

      struct tftp_prefix *p;

      if (daemon->tftp_prefix)

  {

    if (!((dir = opendir(daemon->tftp_prefix))))

      {

        tftp_prefix_missing = 1;

        if (!option_bool(OPT_TFTP_NO_FAIL))

          {

            send_event(err_pipe[1], EVENT_TFTP_ERR, errno, daemon->tftp_prefix);

            _exit(0);

          }

      }

    else

      closedir(dir);

  }

      for (p = daemon->if_prefix; p; p = p->next)

  {

    p->missing = 0;

    if (!((dir = opendir(p->prefix))))

      {

        p->missing = 1;

        if (!option_bool(OPT_TFTP_NO_FAIL))

    {

      send_event(err_pipe[1], EVENT_TFTP_ERR, errno, p->prefix);

      _exit(0);

    }

      }

    else

      closedir(dir);

  }

    }

#endif

#ifdef HAVE_INOTIFY

  if ((daemon->port != 0 && !option_bool(OPT_NO_RESOLV)) ||

      daemon->dynamic_dirs)

    inotify_dnsmasq_init(err_pipe[1]);

  else

    daemon->inotifyfd = -1;

#endif

   /* Don't start logging malloc before logging is set up. */

  daemon->log_malloc = option_bool(OPT_LOG_MALLOC);

  if (daemon->port == 0)

    my_syslog(LOG_INFO, _("started, version %s DNS disabled"), VERSION);

  else 

    {

      if (daemon->cachesize != 0)

  {

    my_syslog(LOG_INFO, _("started, version %s cachesize %d"), VERSION, daemon->cachesize);

    if (daemon->cachesize > 10000)

      my_syslog(LOG_WARNING, _("cache size greater than 10000 may cause performance issues, and is unlikely to be useful."));

  }

      else