auto import from //depot/cupcake/@135843

1 files changed, 1038 insertions, 0 deletions

diff --git a/dhcpcd.c b/dhcpcd.c
new file mode 100644
index 0000000..e674bd2
--- /dev/null
+++ b/dhcpcd.c
@@ -0,0 +1,1038 @@
+/* 
+ * 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.
+ */
+
+const char copyright[] = "Copyright (c) 2006-2008 Roy Marples";
+
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <arpa/inet.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <getopt.h>
+#include <paths.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+
+#include "config.h"
+#include "client.h"
+#include "dhcpcd.h"
+#include "dhcp.h"
+#include "net.h"
+#include "logger.h"
+
+#ifdef ANDROID
+#include <linux/capability.h>
+#include <linux/prctl.h>
+#include <cutils/properties.h>
+#include <private/android_filesystem_config.h>
+#endif
+
+/* Don't set any optional arguments here so we retain POSIX
+ * compatibility with getopt */
+#define OPTS "bc:df:h:i:kl:m:no:pqr:s:t:u:v:xABC:DEF:GI:KLO:Q:TVX:"
+
+static int doversion = 0;
+static int dohelp = 0;
+static const struct option longopts[] = {
+	{"background",    no_argument,        NULL, 'b'},
+	{"script",        required_argument,  NULL, 'c'},
+	{"debug",         no_argument,        NULL, 'd'},
+	{"config",        required_argument,  NULL, 'f'},
+	{"hostname",      optional_argument,  NULL, 'h'},
+	{"vendorclassid", optional_argument,  NULL, 'i'},
+	{"release",       no_argument,        NULL, 'k'},
+	{"leasetime",     required_argument,  NULL, 'l'},
+	{"metric",        required_argument,  NULL, 'm'},
+	{"rebind",        no_argument,        NULL, 'n'},
+	{"option",        required_argument,  NULL, 'o'},
+	{"persistent",    no_argument,        NULL, 'p'},
+	{"quiet",         no_argument,        NULL, 'q'},
+	{"request",       optional_argument,  NULL, 'r'},
+	{"inform",        optional_argument,  NULL, 's'},
+	{"timeout",       required_argument,  NULL, 't'},
+	{"userclass",     required_argument,  NULL, 'u'},
+	{"vendor",        required_argument,  NULL, 'v'},
+	{"exit",          no_argument,        NULL, 'x'},
+	{"noarp",         no_argument,        NULL, 'A'},
+	{"nobackground",  no_argument,        NULL, 'B'},
+	{"nohook",	  required_argument,  NULL, 'C'},
+	{"duid",          no_argument,        NULL, 'D'},
+	{"lastlease",     no_argument,        NULL, 'E'},
+	{"fqdn",          optional_argument,  NULL, 'F'},
+	{"nogateway",     no_argument,        NULL, 'G'},
+	{"clientid",      optional_argument,  NULL, 'I'},
+	{"nolink",        no_argument,        NULL, 'K'},
+	{"noipv4ll",      no_argument,        NULL, 'L'},
+	{"nooption",      optional_argument,  NULL, 'O'},
+	{"require",       required_argument,  NULL, 'Q'},
+	{"test",          no_argument,        NULL, 'T'},
+	{"variables",     no_argument,        NULL, 'V'},
+	{"blacklist",     required_argument,  NULL, 'X'},
+	{"help",          no_argument,        &dohelp, 1},
+	{"version",       no_argument,        &doversion, 1},
+#ifdef CMDLINE_COMPAT
+	{"classid",       optional_argument,  NULL, 'i'},
+	{"renew",         no_argument,        NULL, 'n'},
+	{"nohostname",    no_argument,        NULL, 'H'},
+	{"nomtu",         no_argument,        NULL, 'M'},
+	{"nontp",         no_argument,        NULL, 'N'},
+	{"nodns",         no_argument,        NULL, 'R'},
+	{"msscr",         no_argument,        NULL, 'S'},
+	{"nonis",         no_argument,        NULL, 'Y'},
+#endif
+	{NULL,          0,                  NULL, '\0'}
+};
+
+#ifdef CMDLINE_COMPAT
+# define EXTRA_OPTS "HMNRSY"
+#endif
+
+#ifndef EXTRA_OPTS
+# define EXTRA_OPTS
+#endif
+
+static int
+atoint(const char *s)
+{
+	char *t;
+	long n;
+
+	errno = 0;
+	n = strtol(s, &t, 0);
+	if ((errno != 0 && n == 0) || s == t ||
+	    (errno == ERANGE && (n == LONG_MAX || n == LONG_MIN)))
+	{
+		logger(LOG_ERR, "`%s' out of range", s);
+		return -1;
+	}
+
+	return (int)n;
+}
+
+static pid_t
+read_pid(const char *pidfile)
+{
+	FILE *fp;
+	pid_t pid = 0;
+
+	if ((fp = fopen(pidfile, "r")) == NULL) {
+		errno = ENOENT;
+		return 0;
+	}
+
+	fscanf(fp, "%d", &pid);
+	fclose(fp);
+
+	return pid;
+}
+
+static void
+usage(void)
+{
+	printf("usage: "PACKAGE" [-dknpqxADEGHKLOTV] [-c script] [-f file ] [-h hostname]\n"
+	       "              [-i classID ] [-l leasetime] [-m metric] [-o option] [-r ipaddr]\n"
+	       "              [-s ipaddr] [-t timeout] [-u userclass] [-F none|ptr|both]\n"
+	       "              [-I clientID] [-C hookscript] [-Q option] [-X ipaddr] <interface>\n");
+}
+
+static char * 
+add_environ(struct options *options, const char *value, int uniq)
+{
+	char **newlist;
+	char **lst = options->environ;
+	size_t i = 0, l, lv;
+	char *match = NULL, *p;
+
+	match = xstrdup(value);
+	p = strchr(match, '=');
+	if (p)
+		*p++ = '\0';
+	l = strlen(match);
+
+	while (lst && lst[i]) {
+		if (match && strncmp(lst[i], match, l) == 0) {
+			if (uniq) {
+				free(lst[i]);
+				lst[i] = xstrdup(value);
+			} else {
+				/* Append a space and the value to it */
+				l = strlen(lst[i]);
+				lv = strlen(p);
+				lst[i] = xrealloc(lst[i], l + lv + 2);
+				lst[i][l] = ' ';
+				memcpy(lst[i] + l + 1, p, lv);
+				lst[i][l + lv + 1] = '\0';
+			}
+			free(match);
+			return lst[i];
+		}
+		i++;
+	}
+
+	newlist = xrealloc(lst, sizeof(char *) * (i + 2));
+	newlist[i] = xstrdup(value);
+	newlist[i + 1] = NULL;
+	options->environ = newlist;
+	free(match);
+	return newlist[i];
+}
+
+#define parse_string(buf, len, arg) parse_string_hwaddr(buf, len, arg, 0)
+static ssize_t
+parse_string_hwaddr(char *sbuf, ssize_t slen, char *str, int clid)
+{
+	ssize_t l;
+	char *p;
+	int i;
+	char c[4];
+
+	/* If surrounded by quotes then it's a string */
+	if (*str == '"') {
+		str++;
+		l = strlen(str);
+		p = str + l - 1;
+		if (*p == '"')
+			*p = '\0';
+	} else {
+		l = hwaddr_aton(NULL, str);
+		if (l > 1) {
+			if (l > slen) {
+				errno = ENOBUFS;
+				return -1;
+			}
+			hwaddr_aton((uint8_t *)sbuf, str);
+			return l;
+		}
+	}
+
+	/* Process escapes */
+	l = 0;
+	/* If processing a string on the clientid, first byte should be
+	 * 0 to indicate a non hardware type */
+	if (clid) {
+		*sbuf++ = 0;
+		l++;
+	}
+	c[3] = '\0';
+	while (*str) {
+		if (++l > slen) {
+			errno = ENOBUFS;
+			return -1;
+		}
+		if (*str == '\\') {
+			str++;
+			switch(*str++) {
+			case '\0':
+				break;
+			case 'b':
+				*sbuf++ = '\b';
+				break;
+			case 'n':
+				*sbuf++ = '\n';
+				break;
+			case 'r':
+				*sbuf++ = '\r';
+				break;
+			case 't':
+				*sbuf++ = '\t';
+				break;
+			case 'x':
+				/* Grab a hex code */
+				c[1] = '\0';
+				for (i = 0; i < 2; i++) {
+					if (isxdigit((unsigned char)*str) == 0)
+						break;
+					c[i] = *str++;
+				}
+				if (c[1] != '\0') {
+					c[2] = '\0';
+					*sbuf++ = strtol(c, NULL, 16);
+				} else
+					l--;
+				break;
+			case '0':
+				/* Grab an octal code */
+				c[2] = '\0';
+				for (i = 0; i < 3; i++) {
+					if (*str < '0' || *str > '7')
+						break;
+					c[i] = *str++;
+				}
+				if (c[2] != '\0') {
+					i = strtol(c, NULL, 8);
+					if (i > 255)
+						i = 255;
+					*sbuf ++= i;
+				} else
+					l--;
+				break;
+			default:
+				*sbuf++ = *str++;
+			}
+		} else
+			*sbuf++ = *str++;
+	}
+	return l;
+}
+
+static int
+parse_option(int opt, char *oarg, struct options *options)
+{
+	int i;
+	char *p;
+	ssize_t s;
+	struct in_addr addr;
+
+	switch(opt) {
+	case 'b':
+		options->options |= DHCPCD_BACKGROUND;
+		break;
+	case 'c':
+		strlcpy(options->script, oarg, sizeof(options->script));
+		break;
+	case 'h':
+		if (oarg)
+			s = parse_string(options->hostname + 1,
+					 HOSTNAME_MAX_LEN, oarg);
+		else
+			s = 0;
+		if (s == -1) {
+			logger(LOG_ERR, "hostname: %s", strerror(errno));
+			return -1;
+		}
+		if (s != 0 && options->hostname[1] == '.') {
+			logger(LOG_ERR, "hostname cannot begin with a .");
+			return -1;
+		}
+		options->hostname[0] = (uint8_t)s;
+		break;
+	case 'i':
+		if (oarg)
+			s = parse_string((char *)options->vendorclassid + 1,
+					 VENDORCLASSID_MAX_LEN, oarg);
+		else
+			s = 0;
+		if (s == -1) {
+			logger(LOG_ERR, "vendorclassid: %s", strerror(errno));
+			return -1;
+		}
+		*options->vendorclassid = (uint8_t)s;
+		break;
+	case 'l':
+		if (*oarg == '-') {
+			logger(LOG_ERR,
+			       "leasetime must be a positive value");
+			return -1;
+		}
+		errno = 0;
+		options->leasetime = (uint32_t)strtol(oarg, NULL, 0);
+		if (errno == EINVAL || errno == ERANGE) {
+			logger(LOG_ERR, "`%s' out of range", oarg);
+			return -1;
+		}
+		break;
+	case 'm':
+		options->metric = atoint(oarg);
+		if (options->metric < 0) {
+			logger(LOG_ERR, "metric must be a positive value");
+			return -1;
+		}
+		break;
+	case 'o':
+		if (make_option_mask(options->requestmask, &oarg, 1) != 0) {
+			logger(LOG_ERR, "unknown option `%s'", oarg);
+			return -1;
+		}
+		break;
+	case 'p':
+		options->options |= DHCPCD_PERSISTENT;
+		break;
+	case 'q':
+		setloglevel(LOG_WARNING);
+		break;
+	case 's':
+		options->options |= DHCPCD_INFORM;
+		options->options |= DHCPCD_PERSISTENT;
+		options->options &= ~DHCPCD_ARP;
+		if (!oarg || *oarg == '\0') {
+			options->request_address.s_addr = 0;
+			break;
+		} else {
+			if ((p = strchr(oarg, '/'))) {
+				/* nullify the slash, so the -r option
+				 * can read the address */
+				*p++ = '\0';
+				if (sscanf(p, "%d", &i) != 1 ||
+				    inet_cidrtoaddr(i, &options->request_netmask) != 0)
+				{
+					logger(LOG_ERR,
+					       "`%s' is not a valid CIDR",
+					       p);
+					return -1;
+				}
+			}
+		}
+		/* FALLTHROUGH */
+	case 'r':
+		if (!(options->options & DHCPCD_INFORM))
+			options->options |= DHCPCD_REQUEST;
+		if (oarg && !inet_aton(oarg, &options->request_address)) {
+			logger(LOG_ERR, "`%s' is not a valid IP address",
+			       oarg);
+			return -1;
+		}
+		break;
+	case 't':
+		options->timeout = atoint(oarg);
+		if (options->timeout < 0) {
+			logger (LOG_ERR, "timeout must be a positive value");
+			return -1;
+		}
+		break;
+	case 'u':
+		s = USERCLASS_MAX_LEN - options->userclass[0] - 1;
+		s = parse_string((char *)options->userclass + options->userclass[0] + 2,
+				 s, oarg);
+		if (s == -1) {
+			logger(LOG_ERR, "userclass: %s", strerror(errno));
+			return -1;
+		}
+		if (s != 0) {
+			options->userclass[options->userclass[0] + 1] = s;
+			options->userclass[0] += s + 1;
+		}
+		break;
+	case 'v':
+		p = strchr(oarg, ',');
+		if (!p || !p[1]) {
+			logger(LOG_ERR, "invalid vendor format");
+			return -1;
+		}
+		*p = '\0';
+		i = atoint(oarg);
+		oarg = p + 1;
+		if (i < 1 || i > 254) {
+			logger(LOG_ERR, "vendor option should be between"
+					" 1 and 254 inclusive");
+			return -1;
+		}
+		s = VENDOR_MAX_LEN - options->vendor[0] - 2;
+		if (inet_aton(oarg, &addr) == 1) {
+			if (s < 6) {
+				s = -1;
+				errno = ENOBUFS;
+			} else
+				memcpy(options->vendor + options->vendor[0] + 3,
+				       &addr.s_addr, sizeof(addr.s_addr));
+		} else {
+			s = parse_string((char *)options->vendor + options->vendor[0] + 3,
+					 s, oarg);
+		}
+		if (s == -1) {
+			logger(LOG_ERR, "vendor: %s", strerror(errno));
+			return -1;
+		}
+		if (s != 0) {
+			options->vendor[options->vendor[0] + 1] = i;
+			options->vendor[options->vendor[0] + 2] = s;
+			options->vendor[0] += s + 2;
+		}
+		break;
+	case 'A':
+		options->options &= ~DHCPCD_ARP;
+		/* IPv4LL requires ARP */
+		options->options &= ~DHCPCD_IPV4LL;
+		break;
+	case 'B':
+		options->options &= ~DHCPCD_DAEMONISE;
+		break;
+	case 'C':
+		/* Commas to spaces for shell */
+		while ((p = strchr(oarg, ',')))
+			*p = ' ';
+		s = strlen("skip_hooks=") + strlen(oarg) + 1;
+		p = xmalloc(sizeof(char) * s);
+		snprintf(p, s, "skip_hooks=%s", oarg);
+		add_environ(options, p, 0);
+		free(p);
+		break;
+	case 'D':
+		options->options |= DHCPCD_DUID;
+		break;
+	case 'E':
+		options->options |= DHCPCD_LASTLEASE;
+		break;
+	case 'F':
+		if (!oarg) {
+			options->fqdn = FQDN_BOTH;
+			break;
+		}
+		if (strcmp(oarg, "none") == 0)
+			options->fqdn = FQDN_NONE;
+		else if (strcmp(oarg, "ptr") == 0)
+			options->fqdn = FQDN_PTR;
+		else if (strcmp(oarg, "both") == 0)
+			options->fqdn = FQDN_BOTH;
+		else if (strcmp(oarg, "disable") == 0)
+			options->fqdn = FQDN_DISABLE;
+		else {
+			logger(LOG_ERR, "invalid value `%s' for FQDN",
+			       oarg);
+			return -1;
+		}
+		break;
+	case 'G':
+		options->options &= ~DHCPCD_GATEWAY;
+		break;
+	case 'I':
+		/* Strings have a type of 0 */;
+		options->clientid[1] = 0;
+		if (oarg)
+			s = parse_string_hwaddr((char *)options->clientid + 1,
+						CLIENTID_MAX_LEN, oarg, 1);
+		else
+			s = 0;
+		if (s == -1) {
+			logger(LOG_ERR, "clientid: %s", strerror(errno));
+			return -1;
+		}
+		options->clientid[0] = (uint8_t)s;
+		if (s == 0) {
+			options->options &= ~DHCPCD_DUID;
+			options->options &= ~DHCPCD_CLIENTID;
+		}
+		break;
+	case 'K':
+		options->options &= ~DHCPCD_LINK;
+		break;
+	case 'L':
+		options->options &= ~DHCPCD_IPV4LL;
+		break;
+	case 'O':
+		if (make_option_mask(options->requestmask, &oarg, -1) != 0 ||
+		    make_option_mask(options->requiremask, &oarg, -1) != 0 ||
+		    make_option_mask(options->nomask, &oarg, 1) != 0)
+		{
+			logger(LOG_ERR, "unknown option `%s'", oarg);
+			return -1;
+		}
+		break;
+	case 'Q':
+		if (make_option_mask(options->requiremask, &oarg, 1) != 0 ||
+		    make_option_mask(options->requestmask, &oarg, 1) != 0)
+		{
+			logger(LOG_ERR, "unknown option `%s'", oarg);
+			return -1;
+		}
+		break;
+	case 'X':
+		if (!inet_aton(oarg, &addr)) {
+			logger(LOG_ERR, "`%s' is not a valid IP address",
+			       oarg);
+			return -1;
+		}
+		options->blacklist = xrealloc(options->blacklist,
+		    sizeof(in_addr_t) * (options->blacklist_len + 1));
+		options->blacklist[options->blacklist_len] = addr.s_addr;
+		options->blacklist_len++;
+		break;
+	default:
+		return 0;
+	}
+
+	return 1;
+}
+
+static int
+parse_config_line(const char *opt, char *line, struct options *options)
+{
+	unsigned int i;
+
+	for (i = 0; i < sizeof(longopts) / sizeof(longopts[0]); i++) {
+		if (!longopts[i].name ||
+		    strcmp(longopts[i].name, opt) != 0)
+			continue;
+
+		if (longopts[i].has_arg == required_argument && !line) {
+			fprintf(stderr,
+				PACKAGE ": option requires an argument -- %s\n",
+				opt);
+			return -1;
+		}
+
+		return parse_option(longopts[i].val, line, options);
+	}
+
+	fprintf(stderr, PACKAGE ": unknown option -- %s\n", opt);
+	return -1;
+}
+
+#ifdef ANDROID
+void switchUser() {
+	gid_t groups[] = { AID_INET, AID_SHELL };
+	setgroups(sizeof(groups)/sizeof(groups[0]), groups);
+
+	prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
+
+	setgid(AID_DHCP);
+	setuid(AID_DHCP);
+
+	struct __user_cap_header_struct header;
+	struct __user_cap_data_struct cap;
+	header.version = _LINUX_CAPABILITY_VERSION;
+	header.pid = 0;
+	cap.effective = cap.permitted =
+		(1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) |
+                (1 << CAP_NET_BROADCAST) | (1 << CAP_NET_BIND_SERVICE);
+	cap.inheritable = 0;
+	capset(&header, &cap);
+}
+#endif /* ANDROID */
+
+int
+main(int argc, char **argv)
+{
+	struct options *options;
+	int opt;
+	int option_index = 0;
+	char *prefix;
+	pid_t pid;
+	int debug = 0;
+	int i, r;
+	int pid_fd = -1;
+	int sig = 0;
+	int retval = EXIT_FAILURE;
+	char *line, *option, *p, *buffer = NULL;
+	size_t len = 0;
+	FILE *f;
+	char *cf = NULL;
+	char *intf = NULL;
+	struct timespec ts;
+
+#ifdef ANDROID
+	switchUser();
+#endif
+	closefrom(3);
+	/* Saves calling fflush(stream) in the logger */
+	setlinebuf(stdout);
+	openlog(PACKAGE, LOG_PID, LOG_LOCAL0);
+	setlogprefix(PACKAGE ": ");
+
+	options = xzalloc(sizeof(*options));
+	options->options |= DHCPCD_CLIENTID | DHCPCD_GATEWAY | DHCPCD_DAEMONISE;
+	options->options |= DHCPCD_ARP | DHCPCD_IPV4LL | DHCPCD_LINK;
+	options->timeout = DEFAULT_TIMEOUT;
+	strlcpy(options->script, SCRIPT, sizeof(options->script));
+
+	options->vendorclassid[0] = snprintf((char *)options->vendorclassid + 1,
+					     VENDORCLASSID_MAX_LEN,
+					     "%s %s", PACKAGE, VERSION);
+
+#ifdef CMDLINE_COMPAT
+	add_option_mask(options->requestmask, DHO_DNSSERVER);
+	add_option_mask(options->requestmask, DHO_DNSDOMAIN);
+	add_option_mask(options->requestmask, DHO_DNSSEARCH);
+	add_option_mask(options->requestmask, DHO_NISSERVER);
+	add_option_mask(options->requestmask, DHO_NISDOMAIN);
+	add_option_mask(options->requestmask, DHO_NTPSERVER);
+
+	/* If the duid file exists, then enable duid by default
+	 * This means we don't break existing clients that easily :) */
+	if ((f = fopen(DUID, "r"))) {
+		options->options |= DHCPCD_DUID;
+		fclose(f);
+	}
+#endif
+
+	gethostname(options->hostname + 1, sizeof(options->hostname));
+	if (strcmp(options->hostname + 1, "(none)") == 0 ||
+	    strcmp(options->hostname + 1, "localhost") == 0)
+		options->hostname[1] = '\0';
+	*options->hostname = strlen(options->hostname + 1);
+
+	while ((opt = getopt_long(argc, argv, OPTS EXTRA_OPTS,
+				  longopts, &option_index)) != -1)
+	{
+		switch (opt) {
+		case 0:
+			if (longopts[option_index].flag)
+				break;
+			logger(LOG_ERR,	"option `%s' should set a flag",
+			       longopts[option_index].name);
+			goto abort;
+		case 'f':
+			cf = optarg;
+			break;
+		case 'V':
+			print_options();
+			goto abort;
+		case '?':
+			usage();
+			goto abort;
+		}
+	}
+
+	if (doversion)
+		printf(""PACKAGE" "VERSION"\n%s\n", copyright);
+
+	if (dohelp)
+		usage();
+
+	if (optind < argc) {
+		if (strlen(argv[optind]) >= IF_NAMESIZE) {
+			logger(LOG_ERR,
+			       "`%s' too long for an interface name (max=%d)",
+			       argv[optind], IF_NAMESIZE);
+			goto abort;
+		}
+		strlcpy(options->interface, argv[optind],
+			sizeof(options->interface));
+	} else {
+		/* If only version was requested then exit now */
+		if (doversion || dohelp) {
+			retval = 0;
+			goto abort;
+		}
+
+		logger(LOG_ERR, "no interface specified");
+		goto abort;
+	}
+
+	/* Parse our options file */
+	f = fopen(cf ? cf : CONFIG, "r");
+	if (f) {
+		r = 1;
+		while ((get_line(&buffer, &len, f))) {
+			line = buffer;
+			while ((option = strsep(&line, " \t")))
+				if (*option != '\0')
+					break;
+			if (!option || *option == '\0' || *option == '#')
+				continue;
+			/* Trim leading whitespace */
+			if (line) {
+				while (*line != '\0' && (*line == ' ' || *line == '\t'))
+					line++;
+			}
+			/* Trim trailing whitespace */
+			if (line && *line) {
+				p = line + strlen(line) - 1;
+				while (p != line &&
+				       (*p == ' ' || *p == '\t') &&
+				       *(p - 1) != '\\')
+					*p-- = '\0';
+			}
+			if (strcmp(option, "interface") == 0) {
+				free(intf);
+				intf = xstrdup(line);
+				continue;
+			}
+			/* If we're in an interface block don't use these
+			 * options unless it's for us */
+			if (intf && strcmp(intf, options->interface) != 0)
+				continue;
+			r = parse_config_line(option, line, options);
+			if (r != 1)
+				break;
+		}
+		free(buffer);
+		free(intf);
+		fclose(f);
+		if (r == 0)
+			usage();
+		if (r != 1)
+			goto abort;
+	} else {
+		if (errno != ENOENT || cf) {
+			logger(LOG_ERR, "fopen `%s': %s", cf ? cf : CONFIG,
+			       strerror(errno));
+			goto abort;
+		}
+	}
+
+	optind = 0;
+	while ((opt = getopt_long(argc, argv, OPTS EXTRA_OPTS,
+				  longopts, &option_index)) != -1)
+	{
+		switch (opt) {
+		case 'd':
+			debug++;
+			switch (debug) {
+			case 1:
+				setloglevel(LOG_DEBUG);
+				break;
+			case 2:
+				options->options &= ~DHCPCD_DAEMONISE;
+				break;
+			}
+			break;
+		case 'f':
+			break;
+		case 'k':
+			sig = SIGHUP;
+			break;
+		case 'n':
+			sig = SIGALRM;
+			break;
+		case 'x':
+			sig = SIGTERM;
+			break;
+		case 'T':
+			options->options |= DHCPCD_TEST | DHCPCD_PERSISTENT;
+			break;
+#ifdef CMDLINE_COMPAT
+		case 'H': /* FALLTHROUGH */
+		case 'M':
+			del_option_mask(options->requestmask, DHO_MTU);
+			break;
+		case 'N':
+			del_option_mask(options->requestmask, DHO_NTPSERVER);
+			break;
+		case 'R':
+			del_option_mask(options->requestmask, DHO_DNSSERVER);
+			del_option_mask(options->requestmask, DHO_DNSDOMAIN);
+			del_option_mask(options->requestmask, DHO_DNSSEARCH);
+			break;
+		case 'S':
+			add_option_mask(options->requestmask, DHO_MSCSR);
+			break;
+		case 'Y':
+			del_option_mask(options->requestmask, DHO_NISSERVER);
+			del_option_mask(options->requestmask, DHO_NISDOMAIN);
+			break;
+#endif
+		default:
+			i = parse_option(opt, optarg, options);
+			if (i == 1)
+				break;
+			if (i == 0)
+				usage();
+			goto abort;
+		}
+	}
+
+#ifdef THERE_IS_NO_FORK
+	options->options &= ~DHCPCD_DAEMONISE;
+#endif
+
+#ifndef ANDROID
+        /* android runs us as user "dhcp" */
+	if (geteuid())
+		logger(LOG_WARNING, PACKAGE " will not work correctly unless"
+		       " run as root");
+#endif
+
+	if (options->options & DHCPCD_TEST) {
+		if (options->options & DHCPCD_REQUEST ||
+		    options->options & DHCPCD_INFORM) {
+			logger(LOG_ERR,
+			       "cannot test with --inform or --request");
+			goto abort;
+		}
+
+		if (options->options & DHCPCD_LASTLEASE) {
+			logger(LOG_ERR, "cannot test with --lastlease");
+			goto abort;
+		}
+
+		if (sig != 0) {
+			logger(LOG_ERR,
+			       "cannot test with --release or --renew");
+			goto abort;
+		}
+	}
+
+	prefix = xmalloc(sizeof(char) * (IF_NAMESIZE + 3));
+	snprintf(prefix, IF_NAMESIZE, "%s: ", options->interface);
+	setlogprefix(prefix);
+	snprintf(options->pidfile, sizeof(options->pidfile), PIDFILE,
+		 options->interface);
+	free(prefix);
+
+	if (options->request_address.s_addr == 0 &&
+	    (options->options & DHCPCD_INFORM ||
+	     options->options & DHCPCD_REQUEST))
+	{
+		errno = 0;
+		if (get_address(options->interface,
+				&options->request_address,
+				&options->request_netmask) != 1)
+		{
+			if (errno)
+				logger(LOG_ERR, "get_address: %s",
+				       strerror(errno));
+			else
+				logger(LOG_ERR, "no existing address");
+			goto abort;
+		}
+	}
+	if (IN_LINKLOCAL(ntohl(options->request_address.s_addr))) {
+		logger(LOG_ERR,
+		       "you are not allowed to request a link local address");
+		goto abort;
+	}
+
+	chdir("/");
+	umask(022);
+
+	if (sig != 0 && !(options->options & DHCPCD_DAEMONISED)) {
+#ifdef ANDROID
+                char pidpropname[PROPERTY_KEY_MAX];
+                char pidpropval[PROPERTY_VALUE_MAX];
+
+		i = -1;
+                if (snprintf(pidpropname,
+                             sizeof(pidpropname),
+                             "dhcp.%s.pid", options->interface) >= PROPERTY_KEY_MAX) {
+                    goto abort;
+                }
+                property_get(pidpropname, pidpropval, NULL);
+                if (strlen(pidpropval) == 0) {
+                    goto abort;
+                }
+                pid = atoi(pidpropval);
+#else
+		i = -1;
+		pid = read_pid(options->pidfile);
+#endif
+		if (pid != 0)
+			logger(LOG_INFO, "sending signal %d to pid %d",
+			       sig, pid);
+
+		if (!pid || (i = kill(pid, sig))) {
+			if (sig != SIGALRM)
+				logger(LOG_ERR, ""PACKAGE" not running");
+			unlink(options->pidfile);
+		}
+		if (i == 0) {
+			if (sig == SIGALRM) {
+				retval = EXIT_SUCCESS;
+				goto abort;
+			}
+			/* Spin until it exits */
+			logger(LOG_INFO, "waiting for pid %d to exit", pid);
+			ts.tv_sec = 0;
+			ts.tv_nsec = 100000000; /* 10th of a second */
+			for(i = 0; i < 100; i++) {
+				nanosleep(&ts, NULL);
+				if (read_pid(options->pidfile) == 0) {
+					retval = EXIT_SUCCESS;
+					break;
+				}
+			}
+			if (retval != EXIT_SUCCESS)
+				logger(LOG_ERR, "pid %d failed to exit", pid);
+			goto abort;
+		}
+		if (sig != SIGALRM)
+			goto abort;	
+	}
+
+	if (!(options->options & DHCPCD_TEST) &&
+	    !(options->options & DHCPCD_DAEMONISED))
+	{
+#ifdef ANDROID
+                char pidpropname[PROPERTY_KEY_MAX];
+                char pidpropval[PROPERTY_VALUE_MAX];
+#endif
+#ifndef ANDROID
+		if ((pid = read_pid(options->pidfile)) > 0 &&
+		    kill(pid, 0) == 0)
+		{
+			logger(LOG_ERR, ""PACKAGE
+			       " already running on pid %d (%s)",
+			       pid, options->pidfile);
+			goto abort;
+		}
+#endif
+		pid_fd = open(options->pidfile,
+			     O_WRONLY | O_CREAT | O_NONBLOCK, 0664);
+		if (pid_fd == -1) {
+			logger(LOG_ERR, "open `%s': %s",
+			       options->pidfile, strerror(errno));
+			goto abort;
+		}
+
+		/* Lock the file so that only one instance of dhcpcd runs
+		 * on an interface */
+		if (flock(pid_fd, LOCK_EX | LOCK_NB) == -1) {
+			logger(LOG_ERR, "flock `%s': %s",
+			       options->pidfile, strerror(errno));
+			goto abort;
+		}
+
+		if (set_cloexec(pid_fd) == -1)
+			goto abort;
+#ifdef ANDROID
+                if (snprintf(pidpropname,
+                             sizeof(pidpropname),
+                             "dhcp.%s.pid", options->interface) >= PROPERTY_KEY_MAX) {
+                    goto abort;
+                }
+                if (snprintf(pidpropval, sizeof(pidpropval), "%d", getpid()) >= PROPERTY_VALUE_MAX) {
+                    goto abort;
+                }
+		property_set(pidpropname, pidpropval);
+#else
+		writepid(pid_fd, getpid());
+#endif
+		logger(LOG_INFO, PACKAGE " " VERSION " starting");
+	}
+
+	/* Terminate the encapsulated options */
+	if (options->vendor[0]) {
+		options->vendor[0]++;
+		options->vendor[options->vendor[0]] = DHO_END;
+	}
+
+	if (dhcp_run(options, &pid_fd) == 0)
+		retval = EXIT_SUCCESS;
+
+abort:
+	/* If we didn't daemonise then we need to punt the pidfile now */
+	if (pid_fd > -1) {
+		close(pid_fd);
+		unlink(options->pidfile);
+	}
+	if (options->environ) {
+		len = 0;
+		while (options->environ[len])
+			free(options->environ[len++]);
+		free(options->environ);
+	}
+	free(options->blacklist);
+	free(options);
+	exit(retval);
+	/* NOTREACHED */
+}