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