kinit/ipconfig/main.c

#include <errno.h>
#include <poll.h>
#include <limits.h>
#include <setjmp.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/time.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>		/* for getopts */

#include <net/if_arp.h>

#include "ipconfig.h"
#include "netdev.h"
#include "bootp_packet.h"
#include "bootp_proto.h"
#include "dhcp_proto.h"
#include "packet.h"

static const char sysfs_class_net[] = "/sys/class/net";
static const char *progname;
static jmp_buf abort_buf;
static char do_not_config;
static unsigned int default_caps = CAP_DHCP | CAP_BOOTP | CAP_RARP;
static int loop_timeout = -1;
static int configured;
static int bringup_first = 0;

/* DHCP vendor class identifier */
char vendor_class_identifier[260];
int vendor_class_identifier_len;

struct state {
	int state;
	int restart_state;
	time_t expire;
	int retry_period;

	struct netdev *dev;
	struct state *next;
};

static inline const char *my_inet_ntoa(uint32_t addr)
{
	struct in_addr a;

	a.s_addr = addr;

	return inet_ntoa(a);
}

static void print_device_config(struct netdev *dev)
{
	printf("IP-Config: %s complete (from %s):\n", dev->name,
	       my_inet_ntoa(dev->serverid ? dev->serverid : dev->ip_server));
	printf(" address: %-16s ", my_inet_ntoa(dev->ip_addr));
	printf("broadcast: %-16s ", my_inet_ntoa(dev->ip_broadcast));
	printf("netmask: %-16s\n", my_inet_ntoa(dev->ip_netmask));
	printf(" gateway: %-16s ", my_inet_ntoa(dev->ip_gateway));
	printf("dns0     : %-16s ", my_inet_ntoa(dev->ip_nameserver[0]));
	printf("dns1   : %-16s\n", my_inet_ntoa(dev->ip_nameserver[1]));
	if (dev->hostname[0])
		printf(" host   : %-64s\n", dev->hostname);
	if (dev->dnsdomainname[0])
		printf(" domain : %-64s\n", dev->dnsdomainname);
	if (dev->nisdomainname[0])
		printf(" nisdomain: %-64s\n", dev->nisdomainname);
	printf(" rootserver: %s ", my_inet_ntoa(dev->ip_server));
	printf("rootpath: %s\n", dev->bootpath);
	printf(" filename  : %s\n", dev->filename);
}

static void configure_device(struct netdev *dev)
{
	if (do_not_config)
		return;

	if (netdev_setmtu(dev))
		printf("IP-Config: failed to set MTU on %s to %u\n",
		       dev->name, dev->mtu);

	if (netdev_setaddress(dev))
		printf("IP-Config: failed to set addresses on %s\n", dev->name);
	if (netdev_setdefaultroute(dev))
		printf("IP-Config: failed to set default route on %s\n",
		       dev->name);
	if (dev->hostname[0] &&
			sethostname(dev->hostname, strlen(dev->hostname)))
		printf("IP-Config: failed to set hostname '%s' from %s\n",
			dev->hostname, dev->name);
}

static void dump_device_config(struct netdev *dev)
{
	char fn[40];
	FILE *f;

	snprintf(fn, sizeof(fn), "/tmp/net-%s.conf", dev->name);
	f = fopen(fn, "w");
	if (f) {
		fprintf(f, "DEVICE=%s\n", dev->name);
		fprintf(f, "IPV4ADDR=%s\n", my_inet_ntoa(dev->ip_addr));
		fprintf(f, "IPV4BROADCAST=%s\n",
			my_inet_ntoa(dev->ip_broadcast));
		fprintf(f, "IPV4NETMASK=%s\n", my_inet_ntoa(dev->ip_netmask));
		fprintf(f, "IPV4GATEWAY=%s\n", my_inet_ntoa(dev->ip_gateway));
		fprintf(f, "IPV4DNS0=%s\n",
			my_inet_ntoa(dev->ip_nameserver[0]));
		fprintf(f, "IPV4DNS1=%s\n",
			my_inet_ntoa(dev->ip_nameserver[1]));
		fprintf(f, "HOSTNAME=%s\n", dev->hostname);
		fprintf(f, "DNSDOMAIN=%s\n", dev->dnsdomainname);
		fprintf(f, "NISDOMAIN=%s\n", dev->nisdomainname);
		fprintf(f, "ROOTSERVER=%s\n", my_inet_ntoa(dev->ip_server));
		fprintf(f, "ROOTPATH=%s\n", dev->bootpath);
		fprintf(f, "filename=\"%s\"\n", dev->filename);
		fclose(f);
	}
}

static uint32_t inet_class_netmask(uint32_t ip)
{
	ip = ntohl(ip);
	if (IN_CLASSA(ip))
		return htonl(IN_CLASSA_NET);
	if (IN_CLASSB(ip))
		return htonl(IN_CLASSB_NET);
	if (IN_CLASSC(ip))
		return htonl(IN_CLASSC_NET);
	return INADDR_ANY;
}

static void postprocess_device(struct netdev *dev)
{
	if (dev->ip_netmask == INADDR_ANY) {
		dev->ip_netmask = inet_class_netmask(dev->ip_addr);
		printf("IP-Config: %s guessed netmask %s\n",
		       dev->name, my_inet_ntoa(dev->ip_netmask));
	}
	if (dev->ip_broadcast == INADDR_ANY) {
		dev->ip_broadcast =
		    (dev->ip_addr & dev->ip_netmask) | ~dev->ip_netmask;
		printf("IP-Config: %s guessed broadcast address %s\n",
		       dev->name, my_inet_ntoa(dev->ip_broadcast));
	}
	if (dev->ip_nameserver[0] == INADDR_ANY) {
		dev->ip_nameserver[0] = dev->ip_server;
		printf("IP-Config: %s guessed nameserver address %s\n",
		       dev->name, my_inet_ntoa(dev->ip_nameserver[0]));
	}
}

static void complete_device(struct netdev *dev)
{
	postprocess_device(dev);
	configure_device(dev);
	dump_device_config(dev);
	print_device_config(dev);

	++configured;

	dev->next = ifaces;
	ifaces = dev;
}

static int process_receive_event(struct state *s, time_t now)
{
	int handled = 1;

	switch (s->state) {
	case DEVST_BOOTP:
		s->restart_state = DEVST_BOOTP;
		switch (bootp_recv_reply(s->dev)) {
		case -1:
			s->state = DEVST_ERROR;
			break;
		case 1:
			s->state = DEVST_COMPLETE;
			DEBUG(("\n   bootp reply\n"));
			break;
		}
		break;

	case DEVST_DHCPDISC:
		s->restart_state = DEVST_DHCPDISC;
		switch (dhcp_recv_offer(s->dev)) {
		case -1:
			s->state = DEVST_ERROR;
			break;
		case 1:	/* Offer received */
			s->state = DEVST_DHCPREQ;
			dhcp_send_request(s->dev);
			break;
		}
		break;

	case DEVST_DHCPREQ:
		s->restart_state = DEVST_DHCPDISC;
		switch (dhcp_recv_ack(s->dev)) {
		case -1:	/* error */
			s->state = DEVST_ERROR;
			break;
		case 1:	/* ACK received */
			s->state = DEVST_COMPLETE;
			break;
		case 2:	/* NAK received */
			s->state = DEVST_DHCPDISC;
			break;
		}
		break;
	}

	switch (s->state) {
	case DEVST_COMPLETE:
		complete_device(s->dev);
		break;

	case DEVST_ERROR:
		/* error occurred, try again in 10 seconds */
		s->expire = now + 10;
	default:
		DEBUG(("\n"));
		handled = 0;
		break;
	}

	return handled;
}

static void process_timeout_event(struct state *s, time_t now)
{
	int ret = 0;

	/*
	 * Is the link up?  If not, try again in 1 second.
	 */
	if (!netdev_running(s->dev)) {
		s->expire = now + 1;
		s->state = s->restart_state;
		return;
	}

	/*
	 * If we had an error, restore a sane state to
	 * restart from.
	 */
	if (s->state == DEVST_ERROR)
		s->state = s->restart_state;

	/*
	 * Now send a packet depending on our state.
	 */
	switch (s->state) {
	case DEVST_BOOTP:
		ret = bootp_send_request(s->dev);
		s->restart_state = DEVST_BOOTP;
		break;

	case DEVST_DHCPDISC:
		ret = dhcp_send_discover(s->dev);
		s->restart_state = DEVST_DHCPDISC;
		break;

	case DEVST_DHCPREQ:
		ret = dhcp_send_request(s->dev);
		s->restart_state = DEVST_DHCPDISC;
		break;
	}

	if (ret == -1) {
		s->state = DEVST_ERROR;
		s->expire = now + 10;
	} else {
		s->expire = now + s->retry_period;

		s->retry_period *= 2;
		if (s->retry_period > 60)
			s->retry_period = 60;
	}
}

static struct state *slist;
struct netdev *ifaces;

static int do_pkt_recv(int pkt_fd, time_t now)
{
	int ifindex, ret;
	struct state *s;

	ret = packet_peek(&ifindex);
	if (ret < 0)
		goto bail;

	for (s = slist; s; s = s->next) {
		if (s->dev->ifindex == ifindex) {
			ret |= process_receive_event(s, now);
			break;
		}
	}

      bail:
	return ret;
}

static int loop(void)
{
#define NR_FDS	1
	struct pollfd fds[NR_FDS];
	struct state *s;
	int pkt_fd;
	int nr = 0;
	struct timeval now, prev;
	time_t start;

	pkt_fd = packet_open();
	if (pkt_fd == -1) {
		perror("packet_open");
		return -1;
	}

	fds[0].fd = pkt_fd;
	fds[0].events = POLLRDNORM;

	gettimeofday(&now, NULL);
	start = now.tv_sec;
	while (1) {
		int timeout = 60;
		int pending = 0;
		int done = 0;
		int timeout_ms;
		int x;

		for (s = slist; s; s = s->next) {
			DEBUG(("%s: state = %d\n", s->dev->name, s->state));

			if (s->state == DEVST_COMPLETE) {
				done++;
				continue;
			}

			pending++;

			if (s->expire - now.tv_sec <= 0) {
				DEBUG(("timeout\n"));
				process_timeout_event(s, now.tv_sec);
			}

			if (timeout > s->expire - now.tv_sec)
				timeout = s->expire - now.tv_sec;
		}

		if (pending == 0 || (bringup_first && done))
			break;

		timeout_ms = timeout * 1000;

		for (x = 0; x < 2; x++) {
			int delta_ms;

			if (timeout_ms <= 0)
				timeout_ms = 100;

			nr = poll(fds, NR_FDS, timeout_ms);
			prev = now;
			gettimeofday(&now, NULL);

			if ((fds[0].revents & POLLRDNORM)) {
				nr = do_pkt_recv(pkt_fd, now.tv_sec);
				if (nr == 1)
					break;
				else if (nr == 0)
					packet_discard();
			}

			if (loop_timeout >= 0 &&
			    now.tv_sec - start >= loop_timeout) {
				printf("IP-Config: no response after %d "
				       "secs - giving up\n", loop_timeout);
				goto bail;
			}

			delta_ms = (now.tv_sec - prev.tv_sec) * 1000;
			delta_ms += (now.tv_usec - prev.tv_usec) / 1000;

			DEBUG(("Delta: %d ms\n", delta_ms));

			timeout_ms -= delta_ms;
		}
	}
      bail:
	packet_close();

	return 0;
}

static int add_one_dev(struct netdev *dev)
{
	struct state *state;

	state = malloc(sizeof(struct state));
	if (!state)
		return -1;

	state->dev = dev;
	state->expire = time(NULL);
	state->retry_period = 1;

	/*
	 * Select the state that we start from.
	 */
	if (dev->caps & CAP_DHCP && dev->ip_addr == INADDR_ANY) {
		state->restart_state = state->state = DEVST_DHCPDISC;
	} else if (dev->caps & CAP_DHCP) {
		state->restart_state = state->state = DEVST_DHCPREQ;
	} else if (dev->caps & CAP_BOOTP) {
		state->restart_state = state->state = DEVST_BOOTP;
	}

	state->next = slist;
	slist = state;

	return 0;
}

static void parse_addr(uint32_t * addr, const char *ip)
{
	struct in_addr in;
	if (inet_aton(ip, &in) == 0) {
		fprintf(stderr, "%s: can't parse IP address '%s'\n",
			progname, ip);
		longjmp(abort_buf, 1);
	}
	*addr = in.s_addr;
}

static unsigned int parse_proto(const char *ip)
{
	unsigned int caps = 0;

	if (*ip == '\0' || strcmp(ip, "on") == 0 || strcmp(ip, "any") == 0)
		caps = CAP_BOOTP | CAP_DHCP | CAP_RARP;
	else if (strcmp(ip, "both") == 0)
		caps = CAP_BOOTP | CAP_RARP;
	else if (strcmp(ip, "dhcp") == 0)
		caps = CAP_BOOTP | CAP_DHCP;
	else if (strcmp(ip, "bootp") == 0)
		caps = CAP_BOOTP;
	else if (strcmp(ip, "rarp") == 0)
		caps = CAP_RARP;
	else if (strcmp(ip, "none") == 0 || strcmp(ip, "static") == 0
		 || strcmp(ip, "off") == 0)
		goto bail;
	else {
		fprintf(stderr, "%s: invalid protocol '%s'\n", progname, ip);
		longjmp(abort_buf, 1);
	}
      bail:
	return caps;
}

static int add_all_devices(struct netdev *template);

static int parse_device(struct netdev *dev, const char *ip)
{
	char *cp;
	int i, opt;
	int is_ip = 0;

	DEBUG(("IP-Config: parse_device: \"%s\"\n", ip));

	if (strncmp(ip, "ip=", 3) == 0) {
		ip += 3;
		is_ip = 1;
	} else if (strncmp(ip, "nfsaddrs=", 9) == 0) {
		ip += 9;
		is_ip = 1;	/* Not sure about this...? */
	}

	if (!strchr(ip, ':')) {
		/* Only one option, e.g. "ip=dhcp", or it's an interface name */
		if (is_ip) {
			dev->caps = parse_proto(ip);
			bringup_first = 1;
		} else {
			dev->name = ip;
		}
	} else {
		for (i = opt = 0; ip && *ip; ip = cp, opt++) {
			if ((cp = strchr(ip, ':'))) {
				*cp++ = '\0';
			}
			if (opt > 6) {
				fprintf(stderr, "%s: too many options for %s\n",
					progname, dev->name);
				longjmp(abort_buf, 1);
			}

			if (*ip == '\0')
				continue;
			DEBUG(("IP-Config: opt #%d: '%s'\n", opt, ip));
			switch (opt) {
			case 0:
				parse_addr(&dev->ip_addr, ip);
				dev->caps = 0;
				break;
			case 1:
				parse_addr(&dev->ip_server, ip);
				break;
			case 2:
				parse_addr(&dev->ip_gateway, ip);
				break;
			case 3:
				parse_addr(&dev->ip_netmask, ip);
				break;
			case 4:
				strncpy(dev->hostname, ip, SYS_NMLN - 1);
				dev->hostname[SYS_NMLN - 1] = '\0';
				break;
			case 5:
				dev->name = ip;
				break;
			case 6:
				dev->caps = parse_proto(ip);
				break;
			}
		}
	}

	if (dev->name == NULL ||
	    dev->name[0] == '\0' || strcmp(dev->name, "all") == 0) {
		add_all_devices(dev);
		return 0;
	}
	return 1;
}

static void bringup_device(struct netdev *dev)
{
	if (netdev_up(dev) == 0) {
		if (dev->caps) {
			add_one_dev(dev);
		} else {
			complete_device(dev);
		}
	}
}

static void bringup_one_dev(struct netdev *template, struct netdev *dev)
{
	if (template->ip_addr != INADDR_NONE)
		dev->ip_addr = template->ip_addr;
	if (template->ip_server != INADDR_NONE)
		dev->ip_server = template->ip_server;
	if (template->ip_gateway != INADDR_NONE)
		dev->ip_gateway = template->ip_gateway;
	if (template->ip_netmask != INADDR_NONE)
		dev->ip_netmask = template->ip_netmask;
	if (template->ip_nameserver[0] != INADDR_NONE)
		dev->ip_nameserver[0] = template->ip_nameserver[0];
	if (template->ip_nameserver[1] != INADDR_NONE)
		dev->ip_nameserver[1] = template->ip_nameserver[1];
	if (template->hostname[0] != '\0')
		strcpy(dev->hostname, template->hostname);
	dev->caps &= template->caps;

	bringup_device(dev);
}

static struct netdev *add_device(const char *info)
{
	struct netdev *dev;
	int i;

	dev = malloc(sizeof(struct netdev));
	if (dev == NULL) {
		fprintf(stderr, "%s: out of memory\n", progname);
		longjmp(abort_buf, 1);
	}

	memset(dev, 0, sizeof(struct netdev));
	dev->caps = default_caps;

	if (parse_device(dev, info) == 0)
		goto bail;

	if (netdev_init_if(dev) == -1)
		goto bail;

	if (bootp_init_if(dev) == -1)
		goto bail;

	printf("IP-Config: %s hardware address", dev->name);
	for (i = 0; i < dev->hwlen; i++)
		printf("%c%02x", i == 0 ? ' ' : ':', dev->hwaddr[i]);
	printf(" mtu %d%s%s\n", dev->mtu,
	       dev->caps & CAP_DHCP ? " DHCP" :
	       dev->caps & CAP_BOOTP ? " BOOTP" : "",
	       dev->caps & CAP_RARP ? " RARP" : "");
	return dev;
      bail:
	free(dev);
	return NULL;
}

static int add_all_devices(struct netdev *template)
{
	DIR *d;
	struct dirent *de;
	struct netdev *dev;
	char t[PATH_MAX], p[255];
	int i, fd;
	unsigned long flags;

	d = opendir(sysfs_class_net);
	if (!d)
		return 0;

	while ((de = readdir(d)) != NULL) {
		/* This excludes devices beginning with dots or "dummy", as well as . or .. */
		if (de->d_name[0] == '.' || !strcmp(de->d_name, ".."))
			continue;
		i = snprintf(t, PATH_MAX - 1, "%s/%s/flags", sysfs_class_net,
			     de->d_name);
		if (i < 0 || i >= PATH_MAX - 1)
			continue;
		t[i] = '\0';
		fd = open(t, O_RDONLY);
		if (fd < 0) {
			perror(t);
			continue;
		}
		i = read(fd, &p, sizeof(p) - 1);
		close(fd);
		if (i < 0) {
			perror(t);
			continue;
		}
		p[i] = '\0';
		flags = strtoul(p, NULL, 0);
		/* Heuristic for if this is a reasonable boot interface.
		   This is the same
		   logic the in-kernel ipconfig uses... */
		if (!(flags & IFF_LOOPBACK) &&
		    (flags & (IFF_BROADCAST | IFF_POINTOPOINT))) {
			DEBUG(("Trying to bring up %s\n", de->d_name));

			if (!(dev = add_device(de->d_name)))
				continue;
			bringup_one_dev(template, dev);
		}
	}
	closedir(d);
	return 1;
}

static int check_autoconfig(void)
{
	int ndev = 0, nauto = 0;
	struct state *s;

	for (s = slist; s; s = s->next) {
		ndev++;
		if (s->dev->caps)
			nauto++;
	}

	if (ndev == 0) {
		if (configured == 0) {
			fprintf(stderr, "%s: no devices to configure\n",
				progname);
			longjmp(abort_buf, 1);
		}
	}

	return nauto;
}

static void set_vendor_identifier(const char *id)
{
	int len = strlen(id);
	if (len >= 255) {
		fprintf(stderr,
			"%s: invalid vendor class identifier: "
			"%s\n", progname, id);
		longjmp(abort_buf, 1);
	}
	memcpy(vendor_class_identifier+2, id, len);
	vendor_class_identifier[0] = 60;
	vendor_class_identifier[1] = len;
	vendor_class_identifier_len = len+2;
}

int main(int argc, char *argv[])
    __attribute__ ((weak, alias("ipconfig_main")));

int ipconfig_main(int argc, char *argv[])
{
	struct netdev *dev;
	int c, port;
	int err;

	/* If progname is set we're invoked from another program */
	if (!progname) {
		struct timeval now;
		progname = argv[0];
		gettimeofday(&now, NULL);
		srand48(now.tv_usec ^ (now.tv_sec << 24));
	}

	if ((err = setjmp(abort_buf)))
		return err;

	/* Default vendor identifier */
	set_vendor_identifier("Linux ipconfig");

	do {
		c = getopt(argc, argv, "c:d:i:onp:t:");
		if (c == EOF)
			break;

		switch (c) {
		case 'c':
			default_caps = parse_proto(optarg);
			break;
		case 'p':
			port = atoi(optarg);
			if (port <= 0 || port > USHRT_MAX) {
				fprintf(stderr,
					"%s: invalid port number %d\n",
					progname, port);
				longjmp(abort_buf, 1);
			}
			cfg_local_port = port;
			cfg_remote_port = cfg_local_port - 1;
			break;
		case 't':
			loop_timeout = atoi(optarg);
			if (loop_timeout < 0) {
				fprintf(stderr,
					"%s: invalid timeout %d\n",
					progname, loop_timeout);
				longjmp(abort_buf, 1);
			}
			break;
		case 'i':
			set_vendor_identifier(optarg);
			break;
		case 'o':
			bringup_first = 1;
			break;
		case 'n':
			do_not_config = 1;
			break;
		case 'd':
			dev = add_device(optarg);
			if (dev)
				bringup_device(dev);
			break;
		case '?':
			fprintf(stderr, "%s: invalid option -%c\n",
				progname, optopt);
			longjmp(abort_buf, 1);
		}
	} while (1);

	for (c = optind; c < argc; c++) {
		dev = add_device(argv[c]);
		if (dev)
			bringup_device(dev);
	}

	if (check_autoconfig()) {
		if (cfg_local_port != LOCAL_PORT) {
			printf("IP-Config: binding source port to %d, "
			       "dest to %d\n", cfg_local_port, cfg_remote_port);
		}
		loop();
	}

	return 0;
}
1	niro	532	#include <errno.h>
2			#include <poll.h>
3			#include <limits.h>
4			#include <setjmp.h>
5			#include <stdio.h>
6			#include <string.h>
7			#include <stdlib.h>
8			#include <time.h>
9			#include <arpa/inet.h>
10			#include <sys/types.h>
11			#include <sys/time.h>
12			#include <dirent.h>
13			#include <fcntl.h>
14			#include <unistd.h> /* for getopts */
15
16			#include <net/if_arp.h>
17
18			#include "ipconfig.h"
19			#include "netdev.h"
20			#include "bootp_packet.h"
21			#include "bootp_proto.h"
22			#include "dhcp_proto.h"
23			#include "packet.h"
24
25			static const char sysfs_class_net[] = "/sys/class/net";
26			static const char *progname;
27			static jmp_buf abort_buf;
28			static char do_not_config;
29			static unsigned int default_caps = CAP_DHCP \| CAP_BOOTP \| CAP_RARP;
30			static int loop_timeout = -1;
31			static int configured;
32			static int bringup_first = 0;
33
34			/* DHCP vendor class identifier */
35			char vendor_class_identifier[260];
36			int vendor_class_identifier_len;
37
38			struct state {
39			int state;
40			int restart_state;
41			time_t expire;
42			int retry_period;
43
44			struct netdev *dev;
45			struct state *next;
46			};
47
48			static inline const char *my_inet_ntoa(uint32_t addr)
49			{
50			struct in_addr a;
51
52			a.s_addr = addr;
53
54			return inet_ntoa(a);
55			}
56
57			static void print_device_config(struct netdev *dev)
58			{
59			printf("IP-Config: %s complete (from %s):\n", dev->name,
60			my_inet_ntoa(dev->serverid ? dev->serverid : dev->ip_server));
61			printf(" address: %-16s ", my_inet_ntoa(dev->ip_addr));
62			printf("broadcast: %-16s ", my_inet_ntoa(dev->ip_broadcast));
63			printf("netmask: %-16s\n", my_inet_ntoa(dev->ip_netmask));
64			printf(" gateway: %-16s ", my_inet_ntoa(dev->ip_gateway));
65			printf("dns0 : %-16s ", my_inet_ntoa(dev->ip_nameserver[0]));
66			printf("dns1 : %-16s\n", my_inet_ntoa(dev->ip_nameserver[1]));
67			if (dev->hostname[0])
68			printf(" host : %-64s\n", dev->hostname);
69			if (dev->dnsdomainname[0])
70			printf(" domain : %-64s\n", dev->dnsdomainname);
71			if (dev->nisdomainname[0])
72			printf(" nisdomain: %-64s\n", dev->nisdomainname);
73			printf(" rootserver: %s ", my_inet_ntoa(dev->ip_server));
74			printf("rootpath: %s\n", dev->bootpath);
75			printf(" filename : %s\n", dev->filename);
76			}
77
78			static void configure_device(struct netdev *dev)
79			{
80			if (do_not_config)
81			return;
82
83			if (netdev_setmtu(dev))
84			printf("IP-Config: failed to set MTU on %s to %u\n",
85			dev->name, dev->mtu);
86
87			if (netdev_setaddress(dev))
88			printf("IP-Config: failed to set addresses on %s\n", dev->name);
89			if (netdev_setdefaultroute(dev))
90			printf("IP-Config: failed to set default route on %s\n",
91			dev->name);
92			if (dev->hostname[0] &&
93			sethostname(dev->hostname, strlen(dev->hostname)))
94			printf("IP-Config: failed to set hostname '%s' from %s\n",
95			dev->hostname, dev->name);
96			}
97
98			static void dump_device_config(struct netdev *dev)
99			{
100			char fn[40];
101			FILE *f;
102
103			snprintf(fn, sizeof(fn), "/tmp/net-%s.conf", dev->name);
104			f = fopen(fn, "w");
105			if (f) {
106			fprintf(f, "DEVICE=%s\n", dev->name);
107			fprintf(f, "IPV4ADDR=%s\n", my_inet_ntoa(dev->ip_addr));
108			fprintf(f, "IPV4BROADCAST=%s\n",
109			my_inet_ntoa(dev->ip_broadcast));
110			fprintf(f, "IPV4NETMASK=%s\n", my_inet_ntoa(dev->ip_netmask));
111			fprintf(f, "IPV4GATEWAY=%s\n", my_inet_ntoa(dev->ip_gateway));
112			fprintf(f, "IPV4DNS0=%s\n",
113			my_inet_ntoa(dev->ip_nameserver[0]));
114			fprintf(f, "IPV4DNS1=%s\n",
115			my_inet_ntoa(dev->ip_nameserver[1]));
116			fprintf(f, "HOSTNAME=%s\n", dev->hostname);
117			fprintf(f, "DNSDOMAIN=%s\n", dev->dnsdomainname);
118			fprintf(f, "NISDOMAIN=%s\n", dev->nisdomainname);
119			fprintf(f, "ROOTSERVER=%s\n", my_inet_ntoa(dev->ip_server));
120			fprintf(f, "ROOTPATH=%s\n", dev->bootpath);
121			fprintf(f, "filename=\"%s\"\n", dev->filename);
122			fclose(f);
123			}
124			}
125
126			static uint32_t inet_class_netmask(uint32_t ip)
127			{
128			ip = ntohl(ip);
129			if (IN_CLASSA(ip))
130			return htonl(IN_CLASSA_NET);
131			if (IN_CLASSB(ip))
132			return htonl(IN_CLASSB_NET);
133			if (IN_CLASSC(ip))
134			return htonl(IN_CLASSC_NET);
135			return INADDR_ANY;
136			}
137
138			static void postprocess_device(struct netdev *dev)
139			{
140			if (dev->ip_netmask == INADDR_ANY) {
141			dev->ip_netmask = inet_class_netmask(dev->ip_addr);
142			printf("IP-Config: %s guessed netmask %s\n",
143			dev->name, my_inet_ntoa(dev->ip_netmask));
144			}
145			if (dev->ip_broadcast == INADDR_ANY) {
146			dev->ip_broadcast =
147			(dev->ip_addr & dev->ip_netmask) \| ~dev->ip_netmask;
148			printf("IP-Config: %s guessed broadcast address %s\n",
149			dev->name, my_inet_ntoa(dev->ip_broadcast));
150			}
151			if (dev->ip_nameserver[0] == INADDR_ANY) {
152			dev->ip_nameserver[0] = dev->ip_server;
153			printf("IP-Config: %s guessed nameserver address %s\n",
154			dev->name, my_inet_ntoa(dev->ip_nameserver[0]));
155			}
156			}
157
158			static void complete_device(struct netdev *dev)
159			{
160			postprocess_device(dev);
161			configure_device(dev);
162			dump_device_config(dev);
163			print_device_config(dev);
164
165			++configured;
166
167			dev->next = ifaces;
168			ifaces = dev;
169			}
170
171			static int process_receive_event(struct state *s, time_t now)
172			{
173			int handled = 1;
174
175			switch (s->state) {
176			case DEVST_BOOTP:
177			s->restart_state = DEVST_BOOTP;
178			switch (bootp_recv_reply(s->dev)) {
179			case -1:
180			s->state = DEVST_ERROR;
181			break;
182			case 1:
183			s->state = DEVST_COMPLETE;
184			DEBUG(("\n bootp reply\n"));
185			break;
186			}
187			break;
188
189			case DEVST_DHCPDISC:
190			s->restart_state = DEVST_DHCPDISC;
191			switch (dhcp_recv_offer(s->dev)) {
192			case -1:
193			s->state = DEVST_ERROR;
194			break;
195			case 1: /* Offer received */
196			s->state = DEVST_DHCPREQ;
197			dhcp_send_request(s->dev);
198			break;
199			}
200			break;
201
202			case DEVST_DHCPREQ:
203			s->restart_state = DEVST_DHCPDISC;
204			switch (dhcp_recv_ack(s->dev)) {
205			case -1: /* error */
206			s->state = DEVST_ERROR;
207			break;
208			case 1: /* ACK received */
209			s->state = DEVST_COMPLETE;
210			break;
211			case 2: /* NAK received */
212			s->state = DEVST_DHCPDISC;
213			break;
214			}
215			break;
216			}
217
218			switch (s->state) {
219			case DEVST_COMPLETE:
220			complete_device(s->dev);
221			break;
222
223			case DEVST_ERROR:
224			/* error occurred, try again in 10 seconds */
225			s->expire = now + 10;
226			default:
227			DEBUG(("\n"));
228			handled = 0;
229			break;
230			}
231
232			return handled;
233			}
234
235			static void process_timeout_event(struct state *s, time_t now)
236			{
237			int ret = 0;
238
239			/*
240			* Is the link up? If not, try again in 1 second.
241			*/
242			if (!netdev_running(s->dev)) {
243			s->expire = now + 1;
244			s->state = s->restart_state;
245			return;
246			}
247
248			/*
249			* If we had an error, restore a sane state to
250			* restart from.
251			*/
252			if (s->state == DEVST_ERROR)
253			s->state = s->restart_state;
254
255			/*
256			* Now send a packet depending on our state.
257			*/
258			switch (s->state) {
259			case DEVST_BOOTP:
260			ret = bootp_send_request(s->dev);
261			s->restart_state = DEVST_BOOTP;
262			break;
263
264			case DEVST_DHCPDISC:
265			ret = dhcp_send_discover(s->dev);
266			s->restart_state = DEVST_DHCPDISC;
267			break;
268
269			case DEVST_DHCPREQ:
270			ret = dhcp_send_request(s->dev);
271			s->restart_state = DEVST_DHCPDISC;
272			break;
273			}
274
275			if (ret == -1) {
276			s->state = DEVST_ERROR;
277			s->expire = now + 10;
278			} else {
279			s->expire = now + s->retry_period;
280
281			s->retry_period *= 2;
282			if (s->retry_period > 60)
283			s->retry_period = 60;
284			}
285			}
286
287			static struct state *slist;
288			struct netdev *ifaces;
289
290			static int do_pkt_recv(int pkt_fd, time_t now)
291			{
292			int ifindex, ret;
293			struct state *s;
294
295			ret = packet_peek(&ifindex);
296			if (ret < 0)
297			goto bail;
298
299			for (s = slist; s; s = s->next) {
300			if (s->dev->ifindex == ifindex) {
301			ret \|= process_receive_event(s, now);
302			break;
303			}
304			}
305
306			bail:
307			return ret;
308			}
309
310			static int loop(void)
311			{
312			#define NR_FDS 1
313			struct pollfd fds[NR_FDS];
314			struct state *s;
315			int pkt_fd;
316			int nr = 0;
317			struct timeval now, prev;
318			time_t start;
319
320			pkt_fd = packet_open();
321			if (pkt_fd == -1) {
322			perror("packet_open");
323			return -1;
324			}
325
326			fds[0].fd = pkt_fd;
327			fds[0].events = POLLRDNORM;
328
329			gettimeofday(&now, NULL);
330			start = now.tv_sec;
331			while (1) {
332			int timeout = 60;
333			int pending = 0;
334			int done = 0;
335			int timeout_ms;
336			int x;
337
338			for (s = slist; s; s = s->next) {
339			DEBUG(("%s: state = %d\n", s->dev->name, s->state));
340
341			if (s->state == DEVST_COMPLETE) {
342			done++;
343			continue;
344			}
345
346			pending++;
347
348			if (s->expire - now.tv_sec <= 0) {
349			DEBUG(("timeout\n"));
350			process_timeout_event(s, now.tv_sec);
351			}
352
353			if (timeout > s->expire - now.tv_sec)
354			timeout = s->expire - now.tv_sec;
355			}
356
357			if (pending == 0 \|\| (bringup_first && done))
358			break;
359
360			timeout_ms = timeout * 1000;
361
362			for (x = 0; x < 2; x++) {
363			int delta_ms;
364
365			if (timeout_ms <= 0)
366			timeout_ms = 100;
367
368			nr = poll(fds, NR_FDS, timeout_ms);
369			prev = now;
370			gettimeofday(&now, NULL);
371
372			if ((fds[0].revents & POLLRDNORM)) {
373			nr = do_pkt_recv(pkt_fd, now.tv_sec);
374			if (nr == 1)
375			break;
376			else if (nr == 0)
377			packet_discard();
378			}
379
380			if (loop_timeout >= 0 &&
381			now.tv_sec - start >= loop_timeout) {
382			printf("IP-Config: no response after %d "
383			"secs - giving up\n", loop_timeout);
384			goto bail;
385			}
386
387			delta_ms = (now.tv_sec - prev.tv_sec) * 1000;
388			delta_ms += (now.tv_usec - prev.tv_usec) / 1000;
389
390			DEBUG(("Delta: %d ms\n", delta_ms));
391
392			timeout_ms -= delta_ms;
393			}
394			}
395			bail:
396			packet_close();
397
398			return 0;
399			}
400
401			static int add_one_dev(struct netdev *dev)
402			{
403			struct state *state;
404
405			state = malloc(sizeof(struct state));
406			if (!state)
407			return -1;
408
409			state->dev = dev;
410			state->expire = time(NULL);
411			state->retry_period = 1;
412
413			/*
414			* Select the state that we start from.
415			*/
416			if (dev->caps & CAP_DHCP && dev->ip_addr == INADDR_ANY) {
417			state->restart_state = state->state = DEVST_DHCPDISC;
418			} else if (dev->caps & CAP_DHCP) {
419			state->restart_state = state->state = DEVST_DHCPREQ;
420			} else if (dev->caps & CAP_BOOTP) {
421			state->restart_state = state->state = DEVST_BOOTP;
422			}
423
424			state->next = slist;
425			slist = state;
426
427			return 0;
428			}
429
430			static void parse_addr(uint32_t * addr, const char *ip)
431			{
432			struct in_addr in;
433			if (inet_aton(ip, &in) == 0) {
434			fprintf(stderr, "%s: can't parse IP address '%s'\n",
435			progname, ip);
436			longjmp(abort_buf, 1);
437			}
438			*addr = in.s_addr;
439			}
440
441			static unsigned int parse_proto(const char *ip)
442			{
443			unsigned int caps = 0;
444
445			if (*ip == '\0' \|\| strcmp(ip, "on") == 0 \|\| strcmp(ip, "any") == 0)
446			caps = CAP_BOOTP \| CAP_DHCP \| CAP_RARP;
447			else if (strcmp(ip, "both") == 0)
448			caps = CAP_BOOTP \| CAP_RARP;
449			else if (strcmp(ip, "dhcp") == 0)
450			caps = CAP_BOOTP \| CAP_DHCP;
451			else if (strcmp(ip, "bootp") == 0)
452			caps = CAP_BOOTP;
453			else if (strcmp(ip, "rarp") == 0)
454			caps = CAP_RARP;
455			else if (strcmp(ip, "none") == 0 \|\| strcmp(ip, "static") == 0
456			\|\| strcmp(ip, "off") == 0)
457			goto bail;
458			else {
459			fprintf(stderr, "%s: invalid protocol '%s'\n", progname, ip);
460			longjmp(abort_buf, 1);
461			}
462			bail:
463			return caps;
464			}
465
466			static int add_all_devices(struct netdev *template);
467
468			static int parse_device(struct netdev dev, const char ip)
469			{
470			char *cp;
471			int i, opt;
472			int is_ip = 0;
473
474			DEBUG(("IP-Config: parse_device: \"%s\"\n", ip));
475
476			if (strncmp(ip, "ip=", 3) == 0) {
477			ip += 3;
478			is_ip = 1;
479			} else if (strncmp(ip, "nfsaddrs=", 9) == 0) {
480			ip += 9;
481			is_ip = 1; /* Not sure about this...? */
482			}
483
484			if (!strchr(ip, ':')) {
485			/* Only one option, e.g. "ip=dhcp", or it's an interface name */
486			if (is_ip) {
487			dev->caps = parse_proto(ip);
488			bringup_first = 1;
489			} else {
490			dev->name = ip;
491			}
492			} else {
493			for (i = opt = 0; ip && *ip; ip = cp, opt++) {
494			if ((cp = strchr(ip, ':'))) {
495			*cp++ = '\0';
496			}
497			if (opt > 6) {
498			fprintf(stderr, "%s: too many options for %s\n",
499			progname, dev->name);
500			longjmp(abort_buf, 1);
501			}
502
503			if (*ip == '\0')
504			continue;
505			DEBUG(("IP-Config: opt #%d: '%s'\n", opt, ip));
506			switch (opt) {
507			case 0:
508			parse_addr(&dev->ip_addr, ip);
509			dev->caps = 0;
510			break;
511			case 1:
512			parse_addr(&dev->ip_server, ip);
513			break;
514			case 2:
515			parse_addr(&dev->ip_gateway, ip);
516			break;
517			case 3:
518			parse_addr(&dev->ip_netmask, ip);
519			break;
520			case 4:
521			strncpy(dev->hostname, ip, SYS_NMLN - 1);
522			dev->hostname[SYS_NMLN - 1] = '\0';
523			break;
524			case 5:
525			dev->name = ip;
526			break;
527			case 6:
528			dev->caps = parse_proto(ip);
529			break;
530			}
531			}
532			}
533
534			if (dev->name == NULL \|\|
535			dev->name[0] == '\0' \|\| strcmp(dev->name, "all") == 0) {
536			add_all_devices(dev);
537			return 0;
538			}
539			return 1;
540			}
541
542			static void bringup_device(struct netdev *dev)
543			{
544			if (netdev_up(dev) == 0) {
545			if (dev->caps) {
546			add_one_dev(dev);
547			} else {
548			complete_device(dev);
549			}
550			}
551			}
552
553			static void bringup_one_dev(struct netdev template, struct netdev dev)
554			{
555			if (template->ip_addr != INADDR_NONE)
556			dev->ip_addr = template->ip_addr;
557			if (template->ip_server != INADDR_NONE)
558			dev->ip_server = template->ip_server;
559			if (template->ip_gateway != INADDR_NONE)
560			dev->ip_gateway = template->ip_gateway;
561			if (template->ip_netmask != INADDR_NONE)
562			dev->ip_netmask = template->ip_netmask;
563			if (template->ip_nameserver[0] != INADDR_NONE)
564			dev->ip_nameserver[0] = template->ip_nameserver[0];
565			if (template->ip_nameserver[1] != INADDR_NONE)
566			dev->ip_nameserver[1] = template->ip_nameserver[1];
567			if (template->hostname[0] != '\0')
568			strcpy(dev->hostname, template->hostname);
569			dev->caps &= template->caps;
570
571			bringup_device(dev);
572			}
573
574			static struct netdev add_device(const char info)
575			{
576			struct netdev *dev;
577			int i;
578
579			dev = malloc(sizeof(struct netdev));
580			if (dev == NULL) {
581			fprintf(stderr, "%s: out of memory\n", progname);
582			longjmp(abort_buf, 1);
583			}
584
585			memset(dev, 0, sizeof(struct netdev));
586			dev->caps = default_caps;
587
588			if (parse_device(dev, info) == 0)
589			goto bail;
590
591			if (netdev_init_if(dev) == -1)
592			goto bail;
593
594			if (bootp_init_if(dev) == -1)
595			goto bail;
596
597			printf("IP-Config: %s hardware address", dev->name);
598			for (i = 0; i < dev->hwlen; i++)
599			printf("%c%02x", i == 0 ? ' ' : ':', dev->hwaddr[i]);
600			printf(" mtu %d%s%s\n", dev->mtu,
601			dev->caps & CAP_DHCP ? " DHCP" :
602			dev->caps & CAP_BOOTP ? " BOOTP" : "",
603			dev->caps & CAP_RARP ? " RARP" : "");
604			return dev;
605			bail:
606			free(dev);
607			return NULL;
608			}
609
610			static int add_all_devices(struct netdev *template)
611			{
612			DIR *d;
613			struct dirent *de;
614			struct netdev *dev;
615			char t[PATH_MAX], p[255];
616			int i, fd;
617			unsigned long flags;
618
619			d = opendir(sysfs_class_net);
620			if (!d)
621			return 0;
622
623			while ((de = readdir(d)) != NULL) {
624			/* This excludes devices beginning with dots or "dummy", as well as . or .. */
625			if (de->d_name[0] == '.' \|\| !strcmp(de->d_name, ".."))
626			continue;
627			i = snprintf(t, PATH_MAX - 1, "%s/%s/flags", sysfs_class_net,
628			de->d_name);
629			if (i < 0 \|\| i >= PATH_MAX - 1)
630			continue;
631			t[i] = '\0';
632			fd = open(t, O_RDONLY);
633			if (fd < 0) {
634			perror(t);
635			continue;
636			}
637			i = read(fd, &p, sizeof(p) - 1);
638			close(fd);
639			if (i < 0) {
640			perror(t);
641			continue;
642			}
643			p[i] = '\0';
644			flags = strtoul(p, NULL, 0);
645			/* Heuristic for if this is a reasonable boot interface.
646			This is the same
647			logic the in-kernel ipconfig uses... */
648			if (!(flags & IFF_LOOPBACK) &&
649			(flags & (IFF_BROADCAST \| IFF_POINTOPOINT))) {
650			DEBUG(("Trying to bring up %s\n", de->d_name));
651
652			if (!(dev = add_device(de->d_name)))
653			continue;
654			bringup_one_dev(template, dev);
655			}
656			}
657			closedir(d);
658			return 1;
659			}
660
661			static int check_autoconfig(void)
662			{
663			int ndev = 0, nauto = 0;
664			struct state *s;
665
666			for (s = slist; s; s = s->next) {
667			ndev++;
668			if (s->dev->caps)
669			nauto++;
670			}
671
672			if (ndev == 0) {
673			if (configured == 0) {
674			fprintf(stderr, "%s: no devices to configure\n",
675			progname);
676			longjmp(abort_buf, 1);
677			}
678			}
679
680			return nauto;
681			}
682
683			static void set_vendor_identifier(const char *id)
684			{
685			int len = strlen(id);
686			if (len >= 255) {
687			fprintf(stderr,
688			"%s: invalid vendor class identifier: "
689			"%s\n", progname, id);
690			longjmp(abort_buf, 1);
691			}
692			memcpy(vendor_class_identifier+2, id, len);
693			vendor_class_identifier[0] = 60;
694			vendor_class_identifier[1] = len;
695			vendor_class_identifier_len = len+2;
696			}
697
698			int main(int argc, char *argv[])
699			__attribute__ ((weak, alias("ipconfig_main")));
700
701			int ipconfig_main(int argc, char *argv[])
702			{
703			struct netdev *dev;
704			int c, port;
705			int err;
706
707			/* If progname is set we're invoked from another program */
708			if (!progname) {
709			struct timeval now;
710			progname = argv[0];
711			gettimeofday(&now, NULL);
712			srand48(now.tv_usec ^ (now.tv_sec << 24));
713			}
714
715			if ((err = setjmp(abort_buf)))
716			return err;
717
718			/* Default vendor identifier */
719			set_vendor_identifier("Linux ipconfig");
720
721			do {
722			c = getopt(argc, argv, "c:d:i:onp:t:");
723			if (c == EOF)
724			break;
725
726			switch (c) {
727			case 'c':
728			default_caps = parse_proto(optarg);
729			break;
730			case 'p':
731			port = atoi(optarg);
732			if (port <= 0 \|\| port > USHRT_MAX) {
733			fprintf(stderr,
734			"%s: invalid port number %d\n",
735			progname, port);
736			longjmp(abort_buf, 1);
737			}
738			cfg_local_port = port;
739			cfg_remote_port = cfg_local_port - 1;
740			break;
741			case 't':
742			loop_timeout = atoi(optarg);
743			if (loop_timeout < 0) {
744			fprintf(stderr,
745			"%s: invalid timeout %d\n",
746			progname, loop_timeout);
747			longjmp(abort_buf, 1);
748			}
749			break;
750			case 'i':
751			set_vendor_identifier(optarg);
752			break;
753			case 'o':
754			bringup_first = 1;
755			break;
756			case 'n':
757			do_not_config = 1;
758			break;
759			case 'd':
760			dev = add_device(optarg);
761			if (dev)
762			bringup_device(dev);
763			break;
764			case '?':
765			fprintf(stderr, "%s: invalid option -%c\n",
766			progname, optopt);
767			longjmp(abort_buf, 1);
768			}
769			} while (1);
770
771			for (c = optind; c < argc; c++) {
772			dev = add_device(argv[c]);
773			if (dev)
774			bringup_device(dev);
775			}
776
777			if (check_autoconfig()) {
778			if (cfg_local_port != LOCAL_PORT) {
779			printf("IP-Config: binding source port to %d, "
780			"dest to %d\n", cfg_local_port, cfg_remote_port);
781			}
782			loop();
783			}
784
785			return 0;
786			}