/* 
 * dhcpcd - DHCP client daemon
 * Copyright 2006-2008 Roy Marples <roy@marples.name>
 * All rights reserved

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/stat.h>

#include <arpa/inet.h>

#include <netinet/in.h>
#ifdef __linux__
# include <netinet/ether.h>
#endif
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <resolv.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>

#include "config.h"
#include "common.h"
#include "configure.h"
#include "dhcp.h"
#ifdef ENABLE_INFO
# include "info.h"
#endif
#include "interface.h"
#include "dhcpcd.h"
#include "logger.h"
#include "signal.h"
#include "socket.h"

#include "logwriter.h"

static int file_in_path (const char *file)
{
	char *p = getenv ("PATH");
	char *path;
	char *token;
	struct stat s;
	char mypath[PATH_MAX];
	int retval = -1;

	if (! p) {
		errno = ENOENT;
		return (-1);
	}

	path = strdup (p);
	p = path;
	while ((token = strsep (&p, ":"))) {
		snprintf (mypath, PATH_MAX, "%s/%s", token, file);
		if (stat (mypath, &s) == 0) {
			retval = 0;
			break;
		}
	}
	free (path);
	return (retval);
}

/* IMPORTANT: Ensure that the last parameter is NULL when calling */
static int exec_cmd (const char *cmd, const char *args, ...)
{
	va_list va;
	char **argv;
	int n = 1;
	int ret = 0;
	pid_t pid;
	sigset_t full;
	sigset_t old;

	va_start (va, args);
	while (va_arg (va, char *) != NULL)
		n++;
	va_end (va);
	argv = xmalloc (sizeof (char *) * (n + 2));

	va_start (va, args);
	n = 2;
	argv[0] = (char *) cmd;
	argv[1] = (char *) args;
	while ((argv[n] = va_arg (va, char *)) != NULL)
		n++;
	va_end (va);

	/* OK, we need to block signals */
	sigfillset (&full);
	sigprocmask (SIG_SETMASK, &full, &old);

#ifdef THERE_IS_NO_FORK
	signal_reset ();
	pid = vfork ();
#else
	pid = fork();
#endif

	switch (pid) {
		case -1:
			logger (LOG_ERR, "vfork: %s", strerror (errno));
			ret = -1;
			break;
		case 0:
#ifndef THERE_IS_NO_FORK
			signal_reset ();
#endif
			sigprocmask (SIG_SETMASK, &old, NULL);
			if (execvp (cmd, argv) && errno != ENOENT)
				logger (LOG_ERR, "error executing \"%s\": %s",
					cmd, strerror (errno));
			_exit (111);
			/* NOTREACHED */
	}

#ifdef THERE_IS_NO_FORK
	signal_setup ();
#endif

	/* Restore our signals */
	sigprocmask (SIG_SETMASK, &old, NULL);

	free (argv);
	return (ret);
}

static void exec_script (const char *script, const char *infofile,
			 const char *arg)
{
	struct stat buf;

	if (! script || ! infofile || ! arg)
		return;

	if (stat (script, &buf) == -1) {
		if (strcmp (script, DEFAULT_SCRIPT) != 0)
			logger (LOG_ERR, "`%s': %s", script, strerror (ENOENT));
		return;
	}

#ifdef ENABLE_INFO
	logger (LOG_DEBUG, "exec \"%s\" \"%s\" \"%s\"", script, infofile, arg);
	exec_cmd (script, infofile, arg, (char *) NULL);
#else
	logger (LOG_DEBUG, "exec \"%s\" \"\" \"%s\"", script, arg);
	exec_cmd (script, "", arg, (char *) NULL);
#endif
}

static int make_resolv (const char *ifname, const dhcp_t *dhcp)
{
	FILE *f = NULL;
	address_t *address;

#ifdef ENABLE_RESOLVCONF
	char *resolvconf = NULL;

	if (file_in_path ("resolvconf") == 0) {
		size_t len = strlen ("resolvconf -a ") + strlen (ifname) + 1;
		resolvconf = xmalloc (sizeof (char) * len);
		snprintf (resolvconf, len, "resolvconf -a %s", ifname);
		if ((f = popen (resolvconf , "w")))
			logger (LOG_DEBUG,
				"sending DNS information to resolvconf");
		else if (errno == EEXIST)
			logger (LOG_ERR, "popen: %s", strerror (errno));

		if (ferror (f))
			logger (LOG_ERR, "ferror");
		free (resolvconf);
	}
#endif
	if (! f) {
		logger (LOG_DEBUG, "writing "RESOLVFILE);
		if (! (f = fopen(RESOLVFILE, "w")))
			logger (LOG_ERR, "fopen `%s': %s", RESOLVFILE, strerror (errno));
	}

	if (! f)
		return (-1);

	fprintf (f, "# Generated by dhcpcd for interface %s\n", ifname);
	if (dhcp->dnssearch)
		fprintf (f, "search %s\n", dhcp->dnssearch);
	else if (dhcp->dnsdomain) {
		fprintf (f, "search %s\n", dhcp->dnsdomain);
	}

	STAILQ_FOREACH (address, dhcp->dnsservers, entries)
		fprintf (f, "nameserver %s\n", inet_ntoa (address->address));

#ifdef ENABLE_RESOLVCONF
	if (resolvconf)
		pclose (f);
	else
#endif
		fclose (f);

	/* Refresh the local resolver */
	res_init ();
	return (0);
}

static void restore_resolv (const char *ifname)
{
#ifdef ENABLE_RESOLVCONF
	if (file_in_path ("resolvconf") == 0) {
		logger (LOG_DEBUG, "removing information from resolvconf");
		exec_cmd("resolvconf", "-d", ifname, (char *) NULL);
	}
#endif
}

static bool in_addresses (const struct address_head *addresses,
			  struct in_addr address)
{
	const address_t *addr;

	STAILQ_FOREACH (addr, addresses, entries)
		if (addr->address.s_addr == address.s_addr)
			return (true);

	return (false);
}

static bool in_routes (const struct route_head *routes, route_t *route)
{
	const route_t *r;

	if (! routes)
		return (false);
	
	STAILQ_FOREACH (r, routes, entries)
		if (r->destination.s_addr == route->destination.s_addr &&
		    r->netmask.s_addr == route->netmask.s_addr &&
		    r->gateway.s_addr == route->gateway.s_addr)
			return (true);

	return (false);
}

#ifdef ENABLE_NTP
static int _make_ntp (const char *file, const char *ifname, const dhcp_t *dhcp)
{
	FILE *f;
	address_t *address;
	char *a;
	char *line;
	int tomatch = 0;
	char *token;
	bool ntp = false;

	STAILQ_FOREACH (address, dhcp->ntpservers, entries)
		tomatch++;

	/* Check that we really need to update the servers.
	 * We do this because ntp has to be restarted to
	 * work with a changed config. */
	if (! (f = fopen (file, "r"))) {
		if (errno != ENOENT) {
			logger (LOG_ERR, "fopen `%s': %s",
				file, strerror (errno));
			return (-1);
		}
	} else {
		while (tomatch != 0 && (line = get_line (f))) {
			struct in_addr addr;

			a = line;
			token = strsep (&a, " ");
			if (! token || strcmp (token, "server") != 0)
				goto next;

			if ((token = strsep (&a, " \n")) == NULL)
				goto next;

			if (inet_aton (token, &addr) == 1 &&
			    in_addresses (dhcp->ntpservers, addr))
				tomatch--;

next:
			free (line);
		}
		fclose (f);

		/* File has the same name servers that we do,
		 * so no need to restart ntp */
		if (tomatch == 0) {
			logger (LOG_DEBUG, "%s already configured, skipping",
				file);
			return (0);
		}
	}

	logger (LOG_DEBUG, "writing %s", file);
	if (! (f = fopen (file, "w"))) {
		logger (LOG_ERR, "fopen `%s': %s", file, strerror (errno));
		return (-1);
	}

	fprintf (f, "# Generated by dhcpcd for interface %s\n", ifname);
#ifdef NTPFILE
	if (strcmp (file, NTPFILE) == 0) {
		ntp = true;
		fprintf (f, "restrict default noquery notrust nomodify\n");
		fprintf (f, "restrict 127.0.0.1\n");
	}
#endif

	STAILQ_FOREACH (address, dhcp->ntpservers, entries) {
		a = inet_ntoa (address->address);
		if (ntp)
			fprintf (f, "restrict %s nomodify notrap noquery\n", a);
		fprintf (f, "server %s\n", a);
	}
	fclose (f);

	return (1);
}

static int make_ntp (const char *ifname, const dhcp_t *dhcp)
{
	/* On some systems we have only have one ntp service, but we don't
	 * know which configuration file we're using. So we need to write
	 * to both and restart accordingly. */

	bool restart_ntp = false;
	bool restart_openntp = false;
	int retval = 0;

#ifdef NTPFILE
	if (_make_ntp (NTPFILE, ifname, dhcp) > 0)
		restart_ntp = true;
#endif

#ifdef OPENNTPFILE
	if (_make_ntp (OPENNTPFILE, ifname, dhcp) > 0)
		restart_openntp = true;
#endif

#ifdef NTPSERVICE
	if (restart_ntp) {
#ifdef NTPCHECK
		if (system (NTPCHECK) == 0)
#endif
			retval += exec_cmd (NTPSERVICE, NTPRESTARTARGS,
					    (char *) NULL);
	}
#endif

#if defined (NTPSERVICE) && defined (OPENNTPSERVICE)
	if (restart_openntp &&
	    (strcmp (NTPSERVICE, OPENNTPSERVICE) != 0 || ! restart_ntp))
	{
#ifdef OPENNTPCHECK
		if (system (OPENNTPCHECK) == 0)
#endif
			retval += exec_cmd (OPENNTPSERVICE,
					    OPENNTPRESTARTARGS, (char *) NULL);
	}
#elif defined (OPENNTPSERVICE) && ! defined (NTPSERVICE)
	if (restart_openntp) {
#ifdef OPENNTPCHECK
		if (system (OPENNTPCHECK) == 0)
#endif
			retval += exec_cmd (OPENNTPSERVICE,
					    OPENNTPRESTARTARGS, (char *) NULL);
	}
#endif

	return (retval);
}
#endif

#ifdef ENABLE_NIS
#define PREFIXSIZE 256
static int make_nis (const char *ifname, const dhcp_t *dhcp)
{
	FILE *f;
	address_t *address;
	char *prefix;

	logger (LOG_DEBUG, "writing "NISFILE);
	if (! (f = fopen(NISFILE, "w"))) {
		logger (LOG_ERR, "fopen `%s': %s", NISFILE, strerror (errno));
		return (-1);
	}

	prefix = xmalloc (sizeof (char) * PREFIXSIZE);
	*prefix = '\0';
	fprintf (f, "# Generated by dhcpcd for interface %s\n", ifname);

	if (dhcp->nisdomain) {
		setdomainname (dhcp->nisdomain, (int) strlen (dhcp->nisdomain));

		if (dhcp->nisservers)
			snprintf (prefix, PREFIXSIZE, "domain %s server",
				  dhcp->nisdomain);
		else
			fprintf (f, "domain %s broadcast\n", dhcp->nisdomain);
	}
	else
		snprintf (prefix, PREFIXSIZE, "%s", "ypserver");

	NSTAILQ_FOREACH (address, dhcp->nisservers, entries)
		fprintf (f, "%s %s\n", prefix, inet_ntoa (address->address));

	free (prefix);
	fclose (f);

#ifdef NISCHECK
	if (system (NISCHECK) == 0)
#endif
		exec_cmd (NISSERVICE, NISRESTARTARGS, (char *) NULL);
	return (0);
}
#endif

static char *lookuphostname (char *hostname, const dhcp_t *dhcp,
			     const options_t *options)
{
	union {
		struct sockaddr sa;
		struct sockaddr_in sin;
	} su;
	socklen_t salen;
	char *addr;
	struct addrinfo hints;
	struct addrinfo *res = NULL;
	int result;
	char *p;

	logger (LOG_DEBUG, "Looking up hostname via DNS");
	addr = xmalloc (sizeof (char) * NI_MAXHOST);
	salen = sizeof (su.sa);
	memset (&su.sa, 0, salen);
	su.sin.sin_family = AF_INET;
	memcpy (&su.sin.sin_addr, &dhcp->address, sizeof (su.sin.sin_addr));

	if ((result = getnameinfo (&su.sa, salen, addr, NI_MAXHOST,
				   NULL, 0, NI_NAMEREQD)) != 0) {
		logger (LOG_ERR,
			"Failed to lookup hostname via DNS: %s",
			gai_strerror (result));
		free (addr);
		return (NULL);
	}
	
	/* Check for a malicious PTR record */
	memset (&hints, 0, sizeof (hints));
	hints.ai_socktype = SOCK_DGRAM;
	hints.ai_flags = AI_NUMERICHOST;
	result = getaddrinfo (addr, "0", &hints, &res);
	if (res)
		freeaddrinfo (res);
	if (result == 0)
		logger (LOG_ERR, "malicious PTR record detected");
	if (result == 0 || ! *addr) {
		free (addr);
		return (NULL);
	}

	p = strchr (addr, '.');
	if (p) {
		switch (options->dohostname) {
			case 1: /* -H */
			case 4: /* -HHHH */
				break;
			case 2: /* -HH */
			case 5: /* -HHHHH */
				/* Strip out the domain if it matches */
				p++;
				if (*p && dhcp->dnssearch) {
					char *s = xstrdup (dhcp->dnssearch);
					char *sp = s;
					char *t;

					while ((t = strsep (&sp, " ")))
						if (strcmp (t, p) == 0) {
							*--p = '\0';
							break;
						}
					free (s);
				} else if (dhcp->dnsdomain) {
					if (strcmp (dhcp->dnsdomain, p) == 0)
						*--p = '\0';
				}
				break;
			case 3: /* -HHH */
			case 6: /* -HHHHHH */
				/* Just strip the domain */
				*p = '\0';
				break;
			default: /* Too many H! */
				break;
		}
	}

	strlcpy (hostname, addr, MAXHOSTNAMELEN);
	free (addr);
	return (hostname);
}

int configure (const options_t *options, interface_t *iface,
	       const dhcp_t *dhcp, bool up)
{
	route_t *route = NULL;
	struct route_head *new_routes = NULL;
	route_t *new_route = NULL;
	char *newhostname = NULL;
	char *curhostname = NULL;
	int remember;
#ifdef ENABLE_IPV4LL
	bool haslinklocal = false;
#endif
#ifdef THERE_IS_NO_FORK
	int skip = 0;
	size_t skiplen;
	char *skipp;
#endif

	if (! options || ! iface || ! dhcp)
		return (-1);

	if (dhcp->address.s_addr == 0)
		up = 0;

	logGatewayToFile(iface, dhcp);

	/* Remove old routes.
	 * Always do this as the interface may have >1 address not added by us
	 * so the routes we added may still exist. */
	NSTAILQ_FOREACH (route, iface->previous_routes, entries)
		if ((route->destination.s_addr || options->dogateway) &&
		    (! up || ! in_routes (dhcp->routes, route)))
			del_route (iface->name, route->destination,
				   route->netmask, route->gateway,
				   options->metric);
	/* If we aren't up, then reset the interface as much as we can */
	if (! up) {
		if (iface->previous_routes) {
			free_route (iface->previous_routes);
			iface->previous_routes = NULL;
		}

		/* Restore the original MTU value */
		if (iface->mtu && iface->previous_mtu != iface->mtu) {
			set_mtu (iface->name, iface->mtu);
			iface->previous_mtu = iface->mtu;
		}

#ifdef ENABLE_INFO
		/* If we haven't created an info file, do so now */
		if (! dhcp->frominfo)
			write_info (iface, dhcp, options, false);
#endif

		/* Only reset things if we had set them before */
		if (iface->previous_address.s_addr != 0) {
			if (! options->keep_address) {
				del_address (iface->name,
					     iface->previous_address,
					     iface->previous_netmask);
				memset (&iface->previous_address,
					0, sizeof (iface->previous_address));
				memset (&iface->previous_netmask,
					0, sizeof (iface->previous_netmask));
			}
		}

		restore_resolv (iface->name);
		exec_script (options->script, iface->infofile, "down");

		return (0);
	}

	/* Set the MTU requested.
	 * If the DHCP server no longer sends one OR it's invalid then
	 * we restore the original MTU */
	if (options->domtu) {
		unsigned short mtu = iface->mtu;
		if (dhcp->mtu)
			mtu = dhcp->mtu;

		if (mtu != iface->previous_mtu) {
			if (set_mtu (iface->name, mtu) == 0)
				iface->previous_mtu = mtu;
		}
	}

	/* This also changes netmask */
	if (! options->doinform || ! has_address (iface->name, dhcp->address))
		if (add_address (iface->name, dhcp->address, dhcp->netmask,
				 dhcp->broadcast) == -1 && errno != EEXIST)
			return (false);

	/* Now delete the old address if different */
	if (iface->previous_address.s_addr != dhcp->address.s_addr &&
	    iface->previous_address.s_addr != 0 &&
	    ! options->keep_address)
		del_address (iface->name,
			     iface->previous_address, iface->previous_netmask);

#ifdef __linux__
	/* On linux, we need to change the subnet route to have our metric. */
	if (iface->previous_address.s_addr != dhcp->address.s_addr &&
	    options->metric > 0 &&
	    dhcp->netmask.s_addr != INADDR_BROADCAST)
	{
		struct in_addr td;
		struct in_addr tg;
		memset (&td, 0, sizeof (td));
		memset (&tg, 0, sizeof (tg));
		td.s_addr = dhcp->address.s_addr & dhcp->netmask.s_addr;
		add_route (iface->name, td, dhcp->netmask, tg, options->metric);
		del_route (iface->name, td, dhcp->netmask, tg, 0);
	}
#endif

#ifdef THERE_IS_NO_FORK
	free (dhcpcd_skiproutes);
	/* We can never have more than 255 routes. So we need space
	 * for 255 3 digit numbers and commas */
	skiplen = 255 * 4 + 1;
	skipp = dhcpcd_skiproutes = xmalloc (sizeof (char) * skiplen);
	*skipp = '\0';
#endif

	/* Remember added routes */
	NSTAILQ_FOREACH (route, dhcp->routes, entries) {
#ifdef ENABLE_IPV4LL
		/* Check if we have already got a link locale route dished
		 * out by the DHCP server */
		if (route->destination.s_addr == htonl (LINKLOCAL_ADDR) &&
		    route->netmask.s_addr == htonl (LINKLOCAL_MASK))
			haslinklocal = true;
#endif
		/* Don't set default routes if not asked to */
		if (route->destination.s_addr == 0 &&
		    route->netmask.s_addr == 0 &&
		    ! options->dogateway)
			continue;

		remember = add_route (iface->name, route->destination,
				      route->netmask,  route->gateway,
				      options->metric);
		/* If we failed to add the route, we may have already added it
		   ourselves. If so, remember it again. */
		if (remember < 0 && in_routes (iface->previous_routes, route))
			remember = 1;

		if (remember >= 0) {
			if (! new_routes) {
				new_routes = xmalloc (sizeof (*new_routes));
				STAILQ_INIT (new_routes);
			}
			new_route = xmalloc (sizeof (route_t));
			memcpy (new_route, route, sizeof (*new_route));
			STAILQ_INSERT_TAIL (new_routes, new_route, entries);
		}
#ifdef THERE_IS_NO_FORK
		/* If we have daemonised yet we need to record which routes
		 * we failed to add so we can skip them */
		else if (! options->daemonised) {
			/* We can never have more than 255 / 4 routes,
			 * so 3 chars is plently */
			if (*skipp)
				*skipp++ = ',';
			skipp += snprintf (skipp,
					   dhcpcd_skiproutes + skiplen - skipp,
					   "%d", skip);
		}
		skip++;
#endif
	}

#ifdef THERE_IS_NO_FORK
	if (*dhcpcd_skiproutes)
		*skipp = '\0';
	else {
		free (dhcpcd_skiproutes);
		dhcpcd_skiproutes = NULL;
	}
#endif

#ifdef ENABLE_IPV4LL
	/* Ensure we always add the link local route if we got a private
	 * address and isn't link local itself */
	if (options->doipv4ll &&
	    ! haslinklocal &&
	    IN_PRIVATE (ntohl (dhcp->address.s_addr)))
	{
		struct in_addr dest;
		struct in_addr mask;
		struct in_addr gate;

		dest.s_addr = htonl (LINKLOCAL_ADDR);
		mask.s_addr = htonl (LINKLOCAL_MASK);
		gate.s_addr = 0;
		remember = add_route (iface->name, dest, mask, gate,
				      options->metric);

		if (remember >= 0) {
			if (! new_routes) {
				new_routes = xmalloc (sizeof (*new_routes));
				STAILQ_INIT (new_routes);
			}
			new_route = xmalloc (sizeof (*new_route));
			new_route->destination.s_addr = dest.s_addr;
			new_route->netmask.s_addr = mask.s_addr;
			new_route->gateway.s_addr = gate.s_addr;
			STAILQ_INSERT_TAIL (new_routes, new_route, entries);
		}
	}
#endif

	if (iface->previous_routes)
		free_route (iface->previous_routes);
	iface->previous_routes = new_routes;

	logToQt(LOG_INFO, DHCPCD_WRITE, "");
	if (options->dodns && dhcp->dnsservers)
		make_resolv(iface->name, dhcp);
	else
		logger (LOG_DEBUG, "no dns information to write");

#ifdef ENABLE_NTP
	if (options->dontp && dhcp->ntpservers)
		make_ntp(iface->name, dhcp);
#endif

#ifdef ENABLE_NIS
	if (options->donis && (dhcp->nisservers || dhcp->nisdomain))
		make_nis(iface->name, dhcp);
#endif

	curhostname = xmalloc (sizeof (char) * MAXHOSTNAMELEN);
	*curhostname = '\0';

	gethostname (curhostname, MAXHOSTNAMELEN);
	if (options->dohostname ||
	    strlen (curhostname) == 0 ||
	    strcmp (curhostname, "(none)") == 0 ||
	    strcmp (curhostname, "localhost") == 0)
	{
		newhostname = xmalloc (sizeof (char) * MAXHOSTNAMELEN);

		if (dhcp->hostname)
			strlcpy (newhostname, dhcp->hostname, MAXHOSTNAMELEN);
		else
			*newhostname = '\0';

		/* Now we have made a resolv.conf we can obtain a hostname
		 * if we need it */
		if (! *newhostname || options->dohostname > 3)
			lookuphostname (newhostname, dhcp, options);

		if (*newhostname) {
			logger (LOG_INFO, "setting hostname to `%s'",
				newhostname);
			sethostname (newhostname, (int) strlen (newhostname));
		}

		free (newhostname);
	}

	free (curhostname);

#ifdef ENABLE_INFO
	if (! dhcp->frominfo)
		write_info (iface, dhcp, options, true);
#endif

	if (iface->previous_address.s_addr != dhcp->address.s_addr ||
	    iface->previous_netmask.s_addr != dhcp->netmask.s_addr)
	{
		memcpy (&iface->previous_address,
			&dhcp->address, sizeof (iface->previous_address));
		memcpy (&iface->previous_netmask,
			&dhcp->netmask, sizeof (iface->previous_netmask));
		exec_script (options->script, iface->infofile, "new");
	} else
		exec_script (options->script, iface->infofile, "up");

	return (0);
}