patch-2.2.16 linux/net/ipv4/ipconfig.c

Next file: linux/net/ipv4/proc.c
Previous file: linux/net/ipv4/ip_masq_mod.c
Back to the patch index
Back to the overall index

diff -urN v2.2.15/linux/net/ipv4/ipconfig.c linux/net/ipv4/ipconfig.c
@@ -1,10 +1,10 @@
 /*
  *  $Id: ipconfig.c,v 1.20.2.1 1999/06/28 11:33:27 davem Exp $
  *
- *  Automatic Configuration of IP -- use BOOTP or RARP or user-supplied
- *  information to configure own IP address and routes.
+ *  Automatic Configuration of IP -- use DHCP, BOOTP, RARP, or
+ *  user-supplied information to configure own IP address and routes.
  *
- *  Copyright (C) 1996--1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
+ *  Copyright (C) 1996-1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
  *
  *  Derived from network configuration code in fs/nfs/nfsroot.c,
  *  originally Copyright (C) 1995, 1996 Gero Kuhlmann and me.
@@ -12,6 +12,10 @@
  *  BOOTP rewritten to construct and analyse packets itself instead
  *  of misusing the IP layer. num_bugs_causing_wrong_arp_replies--;
  *					     -- MJ, December 1998
+ *
+ *  DHCP support added.  To users this looks like a whole separate
+ *  protocol, but we know it's just a bag on the side of BOOTP.
+ *		-- Chip Salzenberg <chip@valinux.com>, May 2000
  */
 
 #include <linux/config.h>
@@ -20,8 +24,9 @@
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/random.h>
-#include <linux/init.h>
 #include <linux/utsname.h>
+#include <linux/proc_fs.h>
+#include <linux/init.h>
 #include <linux/in.h>
 #include <linux/if.h>
 #include <linux/inet.h>
@@ -49,48 +54,88 @@
 #define DBG(x) do { } while(0)
 #endif
 
-/* Define the timeout for waiting for a RARP/BOOTP reply */
-#define CONF_BASE_TIMEOUT	(HZ*5)	/* Initial timeout: 5 seconds */
-#define CONF_RETRIES	 	10	/* 10 retries */
+#define SELF	"IP-Config: "
+
+#if defined(CONFIG_IP_PNP_DHCP)
+#define IPCONFIG_DHCP
+#endif
+#if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_DHCP)
+#define IPCONFIG_BOOTP
+#endif
+#if defined(CONFIG_IP_PNP_RARP)
+#define IPCONFIG_RARP
+#endif
+#if defined(IPCONFIG_BOOTP) || defined(IPCONFIG_RARP)
+#define IPCONFIG_DYNAMIC
+#endif
+
+/* Define the friendly delay before and after opening net devices */
+#define CONF_PRE_OPEN		(HZ/2)	/* Before opening: 1/2 second */
+#define CONF_POST_OPEN		(1*HZ)	/* After opening: 1 second */
+
+/* Define the timeout for waiting for a DHCP/BOOTP/RARP reply */
+#define CONF_OPEN_RETRIES 	3	/* (Re)open devices three times */
+#define CONF_SEND_RETRIES 	3	/* Send requests three times */
+#define CONF_BASE_TIMEOUT	(HZ*2)	/* Initial timeout: 2 seconds */
 #define CONF_TIMEOUT_RANDOM	(HZ)	/* Maximum amount of randomization */
-#define CONF_TIMEOUT_MULT	*5/4	/* Rate of timeout growth */
+#define CONF_TIMEOUT_MULT	*7/4	/* Rate of timeout growth */
 #define CONF_TIMEOUT_MAX	(HZ*30)	/* Maximum allowed timeout */
 
-/* IP configuration */
-static char user_dev_name[IFNAMSIZ] __initdata = { 0, };/* Name of user-selected boot device */
-u32 ic_myaddr __initdata = INADDR_NONE;		/* My IP address */
-u32 ic_servaddr __initdata = INADDR_NONE;	/* Server IP address */
-u32 ic_gateway __initdata = INADDR_NONE;	/* Gateway IP address */
-u32 ic_netmask __initdata = INADDR_NONE;	/* Netmask for local subnet */
-int ic_enable __initdata = 1;			/* Automatic IP configuration enabled */
-int ic_host_name_set __initdata = 0;		/* Host name configured manually */
-int ic_set_manually __initdata = 0;		/* IPconfig parameters set manually */
-
-u32 root_server_addr __initdata = INADDR_NONE;		/* Address of boot server */
-u8 root_server_path[256] __initdata = { 0, };		/* Path to mount as root */
 
-#if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_RARP)
+/*
+ * Public IP configuration
+ */
 
-#define CONFIG_IP_PNP_DYNAMIC
+int ic_enable __initdata = 1;			/* Automatic IP cfg enabled? */
 
-static int ic_proto_enabled __initdata = 0			/* Protocols enabled */
-#ifdef CONFIG_IP_PNP_BOOTP
+/* Protocol choice */
+static int ic_proto_enabled __initdata = 0
+#ifdef IPCONFIG_BOOTP
 			| IC_BOOTP
 #endif
-#ifdef CONFIG_IP_PNP_RARP
+#ifdef CONFIG_IP_PNP_DHCP
+			| IC_USE_DHCP
+#endif
+#ifdef IPCONFIG_RARP
 			| IC_RARP
 #endif
 			;
-static int ic_got_reply __initdata = 0;				/* Protocol(s) we got reply from */
 
-#else
+int ic_host_name_set __initdata = 0;		/* Host name set by us? */
+
+u32 ic_myaddr __initdata = INADDR_NONE;		/* My IP address */
+u32 ic_netmask __initdata = INADDR_NONE;	/* Netmask for local subnet */
+u32 ic_gateway __initdata = INADDR_NONE;	/* Gateway IP address */
 
-static int ic_proto_enabled __initdata = 0;
+u32 ic_servaddr __initdata = INADDR_NONE;	/* Boot server IP address */
 
-#endif
+u32 root_server_addr __initdata = INADDR_NONE;	/* Address of NFS server */
+u8 root_server_path[256] __initdata = { 0, };	/* Path to mount as root */
+
+/* Persistent data: */
+
+int ic_proto_used = 0;			/* Protocol used, if any */
+u32 ic_nameserver = INADDR_NONE;	/* DNS Server IP address */
+u8 ic_domain[64] = { 0, };		/* DNS (not NIS) domain name */
 
+/*
+ * Private state.
+ */
+
+/* Name of user-selected boot device */
+static char user_dev_name[IFNAMSIZ] __initdata = { 0, };
+
+/* Protocols supported by available interfaces */
 static int ic_proto_have_if __initdata = 0;
 
+#ifdef IPCONFIG_DYNAMIC
+static volatile int ic_got_reply = 0;	    /* Protocol(s) we got reply from */
+#endif
+#ifdef IPCONFIG_DHCP
+static int ic_dhcp_msgtype __initdata = 0;	/* Last incoming msg type */
+#endif
+
+
 /*
  *	Network devices
  */
@@ -121,7 +166,7 @@
 			if (dev->mtu >= 364)
 				able |= IC_BOOTP;
 			else
-				printk(KERN_WARNING "BOOTP: Ignoring device %s, MTU %d too small", dev->name, dev->mtu);
+				printk(KERN_WARNING "DHCP/BOOTP: Ignoring device %s, MTU %d too small", dev->name, dev->mtu);
 			if (!(dev->flags & IFF_NOARP))
 				able |= IC_RARP;
 			able &= ic_proto_enabled;
@@ -129,7 +174,8 @@
 				continue;
 			oflags = dev->flags;
 			if (dev_change_flags(dev, oflags | IFF_UP) < 0) {
-				printk(KERN_ERR "IP-Config: Failed to open %s\n", dev->name);
+				printk(KERN_ERR SELF
+				       "Can't open %s\n", dev->name);
 				continue;
 			}
 			if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL)))
@@ -140,15 +186,17 @@
 			d->flags = oflags;
 			d->able = able;
 			ic_proto_have_if |= able;
-			DBG(("IP-Config: Opened %s (able=%d)\n", dev->name, able));
+			DBG((SELF "%s UP (able=%d)\n", dev->name, able));
 		}
 	*last = NULL;
 
 	if (!ic_first_dev) {
 		if (user_dev_name[0])
-			printk(KERN_ERR "IP-Config: Device `%s' not found.\n", user_dev_name);
+			printk(KERN_ERR SELF
+			       "No such device: %s\n", user_dev_name);
 		else
-			printk(KERN_ERR "IP-Config: No network devices available.\n");
+			printk(KERN_ERR SELF
+			       "No network devices available\n");
 		return -1;
 	}
 	return 0;
@@ -164,8 +212,8 @@
 		next = d->next;
 		dev = d->dev;
 		if (dev != ic_dev) {
-			DBG(("IP-Config: Downing %s\n", dev->name));
 			dev_change_flags(dev, d->flags);
+			DBG((SELF "%s DOWN\n", dev->name));
 		}
 		kfree_s(d, sizeof(struct ic_device));
 	}
@@ -219,17 +267,20 @@
 	strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->name);
 	set_sockaddr(sin, ic_myaddr, 0);
 	if ((err = ic_dev_ioctl(SIOCSIFADDR, &ir)) < 0) {
-		printk(KERN_ERR "IP-Config: Unable to set interface address (%d).\n", err);
+		printk(KERN_ERR SELF
+		       "Can't set interface address: Error %d\n", err);
 		return -1;
 	}
 	set_sockaddr(sin, ic_netmask, 0);
 	if ((err = ic_dev_ioctl(SIOCSIFNETMASK, &ir)) < 0) {
-		printk(KERN_ERR "IP-Config: Unable to set interface netmask (%d).\n", err);
+		printk(KERN_ERR SELF
+		       "Can't set netmask: Error %d\n", err);
 		return -1;
 	}
 	set_sockaddr(sin, ic_myaddr | ~ic_netmask, 0);
 	if ((err = ic_dev_ioctl(SIOCSIFBRDADDR, &ir)) < 0) {
-		printk(KERN_ERR "IP-Config: Unable to set interface broadcast address (%d).\n", err);
+		printk(KERN_ERR SELF
+		       "Can't set broadcast address: Error %d\n", err);
 		return -1;
 	}
 	return 0;
@@ -245,7 +296,8 @@
 
 		memset(&rm, 0, sizeof(rm));
 		if ((ic_gateway ^ ic_myaddr) & ic_netmask) {
-			printk(KERN_ERR "IP-Config: Gateway not on directly connected network.\n");
+			printk(KERN_ERR SELF
+			       "Gateway not on directly connected network\n");
 			return -1;
 		}
 		set_sockaddr((struct sockaddr_in *) &rm.rt_dst, 0, 0);
@@ -253,7 +305,8 @@
 		set_sockaddr((struct sockaddr_in *) &rm.rt_gateway, ic_gateway, 0);
 		rm.rt_flags = RTF_UP | RTF_GATEWAY;
 		if ((err = ic_route_ioctl(SIOCADDRT, &rm)) < 0) {
-			printk(KERN_ERR "IP-Config: Cannot add default route (%d).\n", err);
+			printk(KERN_ERR SELF
+			       "Can't add default route: Error %d\n", err);
 			return -1;
 		}
 	}
@@ -286,10 +339,12 @@
 		else if (IN_CLASSC(ntohl(ic_myaddr)))
 			ic_netmask = htonl(IN_CLASSC_NET);
 		else {
-			printk(KERN_ERR "IP-Config: Unable to guess netmask for address %08x\n", ic_myaddr);
+			printk(KERN_ERR SELF
+			       "Can't guess netmask for %s\n",
+			       in_ntoa(ic_myaddr));
 			return -1;
 		}
-		printk("IP-Config: Guessing netmask %s\n", in_ntoa(ic_netmask));
+		printk(SELF "Guessing netmask: %s\n", in_ntoa(ic_netmask));
 	}
 
 	return 0;
@@ -299,7 +354,7 @@
  *	RARP support.
  */
 
-#ifdef CONFIG_IP_PNP_RARP
+#ifdef IPCONFIG_RARP
 
 static int ic_rarp_recv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
 
@@ -366,16 +421,14 @@
 		goto drop;
 
 	/* Victory! The packet is what we were looking for! */
-	if (!ic_got_reply) {
-		ic_got_reply = IC_RARP;
-		ic_dev = dev;
-		if (ic_myaddr == INADDR_NONE)
-			ic_myaddr = tip;
-		ic_servaddr = sip;
-	}
+	ic_dev = dev;
+	if (ic_myaddr == INADDR_NONE)
+		ic_myaddr = tip;
+	ic_servaddr = sip;
+	ic_got_reply = IC_RARP;
 
-	/* And throw the packet out... */
 drop:
+	/* and throw the packet out */
 	kfree_skb(skb);
 	return 0;
 }
@@ -399,10 +452,10 @@
 #endif
 
 /*
- *	BOOTP support.
+ *	DHCP/BOOTP support.
  */
 
-#ifdef CONFIG_IP_PNP_BOOTP
+#ifdef IPCONFIG_BOOTP
 
 struct bootp_pkt {		/* BOOTP packet format */
 	struct iphdr iph;	/* IP header */
@@ -416,20 +469,32 @@
 	u16 flags;		/* Just what it says */
 	u32 client_ip;		/* Client's IP address if known */
 	u32 your_ip;		/* Assigned IP address */
-	u32 server_ip;		/* Server's IP address */
+	u32 server_ip;		/* (Next, e.g. NFS) Server's IP address */
 	u32 relay_ip;		/* IP address of BOOTP relay */
 	u8 hw_addr[16];		/* Client's HW address */
-	u8 serv_name[64];	/* Server host name */
-	u8 boot_file[128];	/* Name of boot file */
-	u8 vendor_area[128];	/* Area for extensions */
+	char server_name[64];	/* Server host name */
+	char boot_file[128];	/* Name of boot file */
+	u8 exten[312];		/* DHCP options / BOOTP vendor extensions */
 };
 
-#define BOOTP_REQUEST 1
-#define BOOTP_REPLY 2
+/* packet ops */
+#define BOOTP_REQUEST	1
+#define BOOTP_REPLY	2
+
+/* DHCP message types */
+#define DHCPDISCOVER	1
+#define DHCPOFFER	2
+#define DHCPREQUEST	3
+#define DHCPDECLINE	4
+#define DHCPACK		5
+#define DHCPNAK		6
+#define DHCPRELEASE	7
+#define DHCPINFORM	8
 
 static u32 ic_bootp_xid;
 
-static int ic_bootp_recv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
+static int ic_bootp_recv(struct sk_buff *skb, struct device *dev,
+			 struct packet_type *pt);
 
 static struct packet_type bootp_packet_type __initdata = {
 	__constant_htons(ETH_P_IP),
@@ -441,20 +506,76 @@
 
 
 /*
- *  Initialize BOOTP extension fields in the request.
+ *  Initialize DHCP/BOOTP extension fields in the request.
  */
-static void __init ic_bootp_init_ext(u8 *e)
+
+static const u8 ic_bootp_cookie[4] = { 99, 130, 83, 99 };
+
+#ifdef IPCONFIG_DHCP
+
+static void __init
+ic_dhcp_init_options(u8 *options)
 {
-	*e++ = 99;		/* RFC1048 Magic Cookie */
-	*e++ = 130;
-	*e++ = 83;
-	*e++ = 99;
+	u8 msgtype = ((ic_dhcp_msgtype == DHCPOFFER)
+		      ? DHCPREQUEST : DHCPDISCOVER);
+	u8 *e = options;
+
+#ifdef IPCONFIG_DEBUG
+	printk("DHCP: Sending message type %d\n", msgtype);
+#endif
+
+	memcpy(e, ic_bootp_cookie, 4);	/* RFC1048 Magic Cookie */
+	e += 4;
+
+	*e++ = 53;		/* DHCP message type */
+	*e++ = 1;
+	*e++ = msgtype;
+
+	if (msgtype == DHCPREQUEST) {
+		*e++ = 50;	/* Requested IP address */
+		*e++ = 4;
+		memcpy(e, &ic_myaddr, 4);
+		e += 4;
+	}
+
+	/* always? */
+	{
+		static const u8 ic_req_params[] = {
+			1,	/* Subnet mask */
+			3,	/* Default gateway */
+			6,	/* DNS server */
+			12,	/* Host name */
+			15,	/* Domain name */
+			17,	/* Boot path */
+			40,	/* NIS domain name */
+		};
+
+		*e++ = 55;	/* Parameter request list */
+		*e++ = sizeof(ic_req_params);
+		memcpy(e, ic_req_params, sizeof(ic_req_params));
+		e += sizeof(ic_req_params);
+	}
+
+	*e++ = 255;	/* End of the list */
+}
+
+#endif /* IPCONFIG_DHCP */
+
+static void __init
+ic_bootp_init_ext(u8 *ext)
+{
+	u8 *e = ext;
+	memcpy(e, ic_bootp_cookie, 4);	/* RFC1048 Magic Cookie */
+	e += 4;
 	*e++ = 1;		/* Subnet mask request */
 	*e++ = 4;
 	e += 4;
 	*e++ = 3;		/* Default gateway request */
 	*e++ = 4;
 	e += 4;
+	*e++ = 5;		/* Name server reqeust */
+	*e++ = 8;
+	e += 8;
 	*e++ = 12;		/* Host name request */
 	*e++ = 32;
 	e += 32;
@@ -462,36 +583,39 @@
 	*e++ = 32;
 	e += 32;
 	*e++ = 17;		/* Boot path */
-	*e++ = 32;
-	e += 32;
-	*e = 255;		/* End of the list */
+	*e++ = 40;
+	e += 40;
+	*e++ = 255;		/* End of the list */
 }
 
 
 /*
- *  Initialize the BOOTP mechanism.
+ *  Initialize the DHCP/BOOTP mechanism.
  */
-static inline void ic_bootp_init(void)
+static inline void
+ic_bootp_init(void)
 {
 	get_random_bytes(&ic_bootp_xid, sizeof(u32));
-	DBG(("BOOTP: XID=%08x\n", ic_bootp_xid));
+	DBG(("DHCP/BOOTP: XID=%08x\n", ic_bootp_xid));
 	dev_add_pack(&bootp_packet_type);
 }
 
 
 /*
- *  BOOTP cleanup.
+ *  DHCP/BOOTP cleanup.
  */
-static inline void ic_bootp_cleanup(void)
+static inline void
+ic_bootp_cleanup(void)
 {
 	dev_remove_pack(&bootp_packet_type);
 }
 
 
 /*
- *  Send BOOTP request to single interface.
+ *  Send DHCP/BOOTP request to single interface.
  */
-static void __init ic_bootp_send_if(struct ic_device *d, u32 jiffies)
+static void __init
+ic_bootp_send_if(struct ic_device *d, u32 jiffies)
 {
 	struct device *dev = d->dev;
 	struct sk_buff *skb;
@@ -524,14 +648,23 @@
 	b->udph.len = htons(sizeof(struct bootp_pkt) - sizeof(struct iphdr));
 	/* UDP checksum not calculated -- explicitly allowed in BOOTP RFC */
 
-	/* Construct BOOTP header */
+	/* Construct DHCP/BOOTP header */
 	b->op = BOOTP_REQUEST;
 	b->htype = dev->type;
 	b->hlen = dev->addr_len;
+	b->your_ip = INADDR_NONE;
+	b->server_ip = INADDR_NONE;
 	memcpy(b->hw_addr, dev->dev_addr, dev->addr_len);
 	b->secs = htons(jiffies / HZ);
 	b->xid = ic_bootp_xid;
-	ic_bootp_init_ext(b->vendor_area);
+
+	/* add DHCP options or BOOTP extensions */
+#ifdef IPCONFIG_DHCP
+	if (ic_proto_enabled & IC_USE_DHCP)
+		ic_dhcp_init_options(b->exten);
+	else
+#endif
+		ic_bootp_init_ext(b->exten);
 
 	/* Chain packet down the line... */
 	skb->dev = dev;
@@ -544,15 +677,16 @@
 
 
 /*
- *  Send BOOTP requests to all interfaces.
+ *  Send DHCP/BOOTP requests to all interfaces.
  */
 static void __init ic_bootp_send(u32 jiffies)
 {
 	struct ic_device *d;
 
-	for(d=ic_first_dev; d; d=d->next)
+	for(d = ic_first_dev; d; d=d->next) {
 		if (d->able & IC_BOOTP)
 			ic_bootp_send_if(d, jiffies);
+	}
 }
 
 
@@ -565,21 +699,20 @@
 		return 0;
 	if (len > max-1)
 		len = max-1;
-	strncpy(dest, src, len);
+	memcpy(dest, src, len);
 	dest[len] = '\0';
 	return 1;
 }
 
-
 /*
- *  Process BOOTP extension.
+ *  Process BOOTP extensions.
  */
 static void __init ic_do_bootp_ext(u8 *ext)
 {
 #ifdef IPCONFIG_DEBUG
 	u8 *c;
 
-	printk("BOOTP: Got extension %02x",*ext);
+	printk("DHCP/BOOTP: Got extension %d:",*ext);
 	for(c=ext+2; c<ext+2+ext[1]; c++)
 		printk(" %02x", *c);
 	printk("\n");
@@ -594,17 +727,24 @@
 			if (ic_gateway == INADDR_NONE)
 				memcpy(&ic_gateway, ext+1, 4);
 			break;
+		case 6:		/* DNS server */
+			if (ic_nameserver == INADDR_NONE)
+				memcpy(&ic_nameserver, ext+1, 4);
+			break;
 		case 12:	/* Host name */
 			ic_bootp_string(system_utsname.nodename, ext+1, *ext, __NEW_UTS_LEN);
 			ic_host_name_set = 1;
 			break;
-		case 40:	/* NIS Domain name */
-			ic_bootp_string(system_utsname.domainname, ext+1, *ext, __NEW_UTS_LEN);
+		case 15:	/* Domain name (DNS) */
+			ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
 			break;
 		case 17:	/* Root path */
 			if (!root_server_path[0])
 				ic_bootp_string(root_server_path, ext+1, *ext, sizeof(root_server_path));
 			break;
+		case 40:	/* NIS domain name (_not_ DNS) */
+			ic_bootp_string(system_utsname.domainname, ext+1, *ext, __NEW_UTS_LEN);
+			break;
 	}
 }
 
@@ -637,7 +777,7 @@
 
 	/* Fragments are not supported */
 	if (h->frag_off & htons(IP_OFFSET|IP_MF)) {
-		printk(KERN_ERR "BOOTP: Ignoring fragmented reply.\n");
+		printk(KERN_ERR "DHCP/BOOTP: Ignoring fragmented reply.\n");
 		goto drop;
 	}
 
@@ -650,35 +790,86 @@
 		goto drop;
 	}
 
-	/* Extract basic fields */
-	ic_myaddr = b->your_ip;
-	ic_servaddr = b->server_ip;
-	ic_got_reply = IC_BOOTP;
-	ic_dev = dev;
-
 	/* Parse extensions */
-	if (b->vendor_area[0] == 99 &&	/* Check magic cookie */
-	    b->vendor_area[1] == 130 &&
-	    b->vendor_area[2] == 83 &&
-	    b->vendor_area[3] == 99) {
-		u8 *ext = &b->vendor_area[4];
+	if (!memcmp(b->exten, ic_bootp_cookie, 4)) {
                 u8 *end = (u8 *) b + ntohs(b->iph.tot_len);
+		u8 *ext;
+
+#ifdef IPCONFIG_DHCP
+
+		u32 server_id = INADDR_NONE;
+		ic_dhcp_msgtype = 0;
+
+		ext = &b->exten[4];
 		while (ext < end && *ext != 0xff) {
-			if (*ext == 0)		/* Padding */
-				ext++;
-			else {
-				u8 *opt = ext;
-				ext += ext[1] + 2;
-				if (ext <= end)
-					ic_do_bootp_ext(opt);
+			u8 *opt = ext++;
+			if (*opt == 0)	/* Padding */
+				continue;
+			ext += *ext + 1;
+			if (ext >= end)
+				break;
+			switch (*opt) {
+			    case 53:	/* Message type */
+				if (opt[1])
+					ic_dhcp_msgtype = opt[2];
+				break;
+			    case 54:	/* Server ID (IP address) */
+				if (opt[1] >= 4)
+					memcpy(&server_id, opt + 2, 4);
+				break;
 			}
 		}
+
+#ifdef IPCONFIG_DEBUG
+		printk("DHCP: Got message type %d\n", ic_dhcp_msgtype);
+#endif
+
+		switch (ic_dhcp_msgtype) {
+		    case DHCPOFFER:
+			/* Let's accept that offer. */
+			ic_myaddr = b->your_ip;
+			ic_servaddr = server_id;
+#ifdef IPCONFIG_DEBUG
+			printk("DHCP: Offered address %s", in_ntoa(ic_myaddr));
+			printk(" by server %s\n", in_ntoa(ic_servaddr));
+#endif
+			goto drop;
+
+		    case DHCPACK:
+			/* Yeah! */
+			break;
+
+		    default:
+			/* Urque.  Forget it*/
+			ic_myaddr = INADDR_NONE;
+			ic_servaddr = INADDR_NONE;
+			goto drop;
+		}
+
+#endif /* IPCONFIG_DHCP */
+
+		ext = &b->exten[4];
+		while (ext < end && *ext != 0xff) {
+			u8 *opt = ext++;
+			if (*opt == 0)	/* Padding */
+				continue;
+			ext += *ext + 1;
+			if (ext < end)
+				ic_do_bootp_ext(opt);
+		}
 	}
 
+	ic_dev = dev;
+	ic_myaddr = b->your_ip;
+	ic_servaddr = b->server_ip;
 	if (ic_gateway == INADDR_NONE && b->relay_ip)
 		ic_gateway = b->relay_ip;
+	if (ic_nameserver == INADDR_NONE)
+		ic_nameserver = ic_servaddr;
+	ic_got_reply = IC_BOOTP;
 
 drop:
+	/* and throw the packet out */
 	kfree_skb(skb);
 	return 0;
 }	
@@ -688,36 +879,35 @@
 
 
 /*
- *	Dynamic IP configuration -- BOOTP and RARP.
+ *	Dynamic IP configuration -- DHCP, BOOTP, RARP.
  */
 
-#ifdef CONFIG_IP_PNP_DYNAMIC
+#ifdef IPCONFIG_DYNAMIC
 
 static int __init ic_dynamic(void)
 {
 	int retries;
 	unsigned long timeout, jiff;
 	unsigned long start_jiffies;
-	int do_rarp = ic_proto_have_if & IC_RARP;
 	int do_bootp = ic_proto_have_if & IC_BOOTP;
+	int do_rarp = ic_proto_have_if & IC_RARP;
 
 	/*
-	 * If neither BOOTP nor RARP was selected, return with an error. This
-	 * routine gets only called when some pieces of information are mis-
-	 * sing, and without BOOTP and RARP we are not able to get that in-
-	 * formation.
+	 * If none of DHCP/BOOTP/RARP was selected, return with an error.
+	 * This routine gets only called when some pieces of information
+	 * are missing, and without BOOTP and RARP we are unable to get it.
 	 */
 	if (!ic_proto_enabled) {
-		printk(KERN_ERR "IP-Config: Incomplete network configuration information.\n");
+		printk(KERN_ERR SELF
+		       "Incomplete network configuration information\n");
 		return -1;
 	}
 
-#ifdef CONFIG_IP_PNP_BOOTP
+#ifdef IPCONFIG_BOOTP
 	if ((ic_proto_enabled ^ ic_proto_have_if) & IC_BOOTP)
-		printk(KERN_ERR "BOOTP: No suitable device found.\n");
+		printk(KERN_ERR "DHCP/BOOTP: No suitable device found.\n");
 #endif
-
-#ifdef CONFIG_IP_PNP_RARP
+#ifdef IPCONFIG_RARP
 	if ((ic_proto_enabled ^ ic_proto_have_if) & IC_RARP)
 		printk(KERN_ERR "RARP: No suitable device found.\n");
 #endif
@@ -727,16 +917,16 @@
 		return -1;
 
 	/*
-	 * Setup RARP and BOOTP protocols
+	 * Setup protocols
 	 */
-#ifdef CONFIG_IP_PNP_RARP
-	if (do_rarp)
-		ic_rarp_init();
-#endif
-#ifdef CONFIG_IP_PNP_BOOTP
+#ifdef IPCONFIG_BOOTP
 	if (do_bootp)
 		ic_bootp_init();
 #endif
+#ifdef IPCONFIG_RARP
+	if (do_rarp)
+		ic_rarp_init();
+#endif
 
 	/*
 	 * Send requests and wait, until we get an answer. This loop
@@ -746,61 +936,109 @@
 	 * [Actually we could now, but the nothing else running note still 
 	 *  applies.. - AC]
 	 */
-	printk(KERN_NOTICE "Sending %s%s%s requests...",
-	        do_bootp ? "BOOTP" : "",
-		do_bootp && do_rarp ? " and " : "",
-		do_rarp ? "RARP" : "");
+	printk(KERN_NOTICE "Sending %s%s%s requests ",
+	       do_bootp
+		? ((ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP") : "",
+	       (do_bootp && do_rarp) ? " and " : "",
+	       do_rarp ? "RARP" : "");
 	start_jiffies = jiffies;
-	retries = CONF_RETRIES;
+	retries = CONF_SEND_RETRIES;
 	get_random_bytes(&timeout, sizeof(timeout));
 	timeout = CONF_BASE_TIMEOUT + (timeout % (unsigned) CONF_TIMEOUT_RANDOM);
 	for(;;) {
-#ifdef CONFIG_IP_PNP_BOOTP
+#ifdef IPCONFIG_BOOTP
 		if (do_bootp)
 			ic_bootp_send(jiffies - start_jiffies);
 #endif
-#ifdef CONFIG_IP_PNP_RARP
+#ifdef IPCONFIG_RARP
 		if (do_rarp)
 			ic_rarp_send();
 #endif
 		printk(".");
+
 		jiff = jiffies + timeout;
 		while (jiffies < jiff && !ic_got_reply)
 			;
+#ifdef IPCONFIG_DHCP
+		if ((ic_got_reply & IC_BOOTP)
+		    && (ic_proto_enabled & IC_USE_DHCP)
+		    && ic_dhcp_msgtype != DHCPACK)
+		{
+			printk(",");
+			ic_got_reply = 0;
+			continue;
+		}
+#endif /* IPCONFIG_DHCP */
+
 		if (ic_got_reply) {
 			printk(" OK\n");
 			break;
 		}
+
 		if (! --retries) {
 			printk(" timed out!\n");
 			break;
 		}
+
 		timeout = timeout CONF_TIMEOUT_MULT;
 		if (timeout > CONF_TIMEOUT_MAX)
 			timeout = CONF_TIMEOUT_MAX;
 	}
 
-#ifdef CONFIG_IP_PNP_RARP
-	if (do_rarp)
-		ic_rarp_cleanup();
-#endif
-#ifdef CONFIG_IP_PNP_BOOTP
+#ifdef IPCONFIG_BOOTP
 	if (do_bootp)
 		ic_bootp_cleanup();
 #endif
+#ifdef IPCONFIG_RARP
+	if (do_rarp)
+		ic_rarp_cleanup();
+#endif
 
 	if (!ic_got_reply)
 		return -1;
 
-	printk("IP-Config: Got %s answer from %s, ",
-		(ic_got_reply & IC_BOOTP) ? "BOOTP" : "RARP",
-		in_ntoa(ic_servaddr));
-	printk("my address is %s\n", in_ntoa(ic_myaddr));
+	printk(SELF "Got %s answer from %s\n",
+	       ((ic_got_reply & IC_RARP) ? "RARP"
+		: (ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP"),
+	       in_ntoa(ic_servaddr));
 
 	return 0;
 }
 
-#endif
+#endif /* IPCONFIG_DYNAMIC */
+
+#ifdef CONFIG_PROC_FS
+
+static int pnp_get_info(char *buffer, char **start,
+			off_t offset, int length, int dummy)
+{
+	int len;
+
+	if (ic_proto_used & IC_PROTO)
+	    sprintf(buffer, "#PROTO: %s\n",
+		    (ic_proto_used & IC_RARP) ? "RARP"
+		    : (ic_proto_used & IC_USE_DHCP) ? "DHCP" : "BOOTP");
+	else
+	    strcpy(buffer, "#MANUAL\n");
+	len = strlen(buffer);
+
+	if (ic_domain[0])
+		len += sprintf(buffer + len,
+			       "domain %s\n", ic_domain);
+	if (ic_nameserver != INADDR_NONE)
+		len += sprintf(buffer + len,
+			       "nameserver %s\n", in_ntoa(ic_nameserver));
+
+	if (offset > len)
+		offset = len;
+	*start = buffer + offset;
+
+	if (offset + length > len)
+		length = len - offset;
+	return length;
+}
+
+#endif /* CONFIG_PROC_FS */
 
 /*
  *	IP Autoconfig dispatcher.
@@ -808,15 +1046,38 @@
 
 int __init ip_auto_config(void)
 {
+	int retries = CONF_OPEN_RETRIES;
+	unsigned long jiff;
+
+#ifdef CONFIG_PROC_FS
+	proc_net_register(&(struct proc_dir_entry) {
+		PROC_NET_PNP, 3, "pnp",
+		S_IFREG | S_IRUGO, 1, 0, 0,
+		0, &proc_net_inode_operations,
+		pnp_get_info
+	});
+#endif /* CONFIG_PROC_FS */
+
 	if (!ic_enable)
 		return 0;
 
-	DBG(("IP-Config: Entered.\n"));
+	DBG((SELF "BEGIN\n"));
+
+ try_try_again:
+	/* Give hardware a chance to settle */
+	jiff = jiffies + CONF_PRE_OPEN;
+	while (jiffies < jiff)
+			;
 
 	/* Setup all network devices */
 	if (ic_open_devs() < 0)
 		return -1;
 
+	/* Give drivers a chance to settle */
+	jiff = jiffies + CONF_POST_OPEN;
+	while (jiffies < jiff)
+			;
+
 	/*
 	 * If the config information is insufficient (e.g., our IP address or
 	 * IP address of the boot server is missing or we have multiple network
@@ -827,20 +1088,57 @@
 #ifdef CONFIG_ROOT_NFS
 	    (root_server_addr == INADDR_NONE && ic_servaddr == INADDR_NONE) ||
 #endif
-	    ic_first_dev->next) {
-#ifdef CONFIG_IP_PNP_DYNAMIC
+	    ic_first_dev->next)
+	{
+
+#ifdef IPCONFIG_DYNAMIC
+
 		if (ic_dynamic() < 0) {
-			printk(KERN_ERR "IP-Config: Auto-configuration of network failed.\n");
 			ic_close_devs();
+
+			/*
+			 * I don't know why, but sometimes the
+			 * eepro100 driver (at least) gets upset and
+			 * doesn't work the first time it's opened.
+			 * But then if you close it and reopen it, it
+			 * works just fine.  So we need to try that at
+			 * least once before giving up.
+			 *
+			 * Also, if the root will be NFS-mounted, we
+			 * have nowhere to go if DHCP fails.  So we
+			 * just have to keep trying forever.
+			 *
+			 * 				-- Chip
+			 */
+#ifdef CONFIG_ROOT_NFS
+			if (ROOT_DEV == MKDEV(UNNAMED_MAJOR, 255)) {
+				printk(KERN_ERR SELF
+				       "Retrying forever (NFS root)...\n");
+				goto try_try_again;
+			}
+#endif
+
+			if (--retries) {
+				printk(KERN_ERR SELF
+				       "Reopening network devices...\n");
+				goto try_try_again;
+			}
+
+			/* Oh, well.  At least we tried.  */
 			return -1;
 		}
-#else
-		printk(KERN_ERR "IP-Config: Incomplete network configuration information.\n");
+
+#else /* !DYNAMIC */
+
+		printk(KERN_ERR SELF "Not enough information\n");
 		ic_close_devs();
 		return -1;
-#endif
+
+#endif /* IPCONFIG_DYNAMIC */
+
 	} else {
-		ic_dev = ic_first_dev->dev;	/* Device selected manually or only one device -> use it */
+		/* Device selected manually or only one device -> use it */
+		ic_dev = ic_first_dev->dev;
 	}
 
 	/*
@@ -857,10 +1155,30 @@
 	if (ic_setup_if() < 0 || ic_setup_routes() < 0)
 		return -1;
 
-	DBG(("IP-Config: device=%s, local=%08x, server=%08x, boot=%08x, gw=%08x, mask=%08x\n",
-	    ic_dev->name, ic_myaddr, ic_servaddr, root_server_addr, ic_gateway, ic_netmask));
-	DBG(("IP-Config: host=%s, domain=%s, path=`%s'\n", system_utsname.nodename,
-	    system_utsname.domainname, root_server_path));
+	/*
+	 * Record which protocol was actually used.
+	 */
+#ifdef IPCONFIG_DYNAMIC
+	ic_proto_used = ic_got_reply | (ic_proto_enabled & IC_USE_DHCP);
+#endif
+
+#ifndef IPCONFIG_SILENT
+	/*
+	 * Clue in the operator.
+	 */
+	printk(SELF "Complete:");
+	printk("\n      device=%s", ic_dev->name);
+	printk(", addr=%s", in_ntoa(ic_myaddr));
+	printk(", mask=%s", in_ntoa(ic_netmask));
+	printk(", gw=%s", in_ntoa(ic_gateway));
+	printk(",\n     host=%s, domain=%s, nis-domain=%s",
+	       system_utsname.nodename, ic_domain, system_utsname.domainname);
+	printk(",\n     bootserver=%s", in_ntoa(ic_servaddr));
+	printk(", rootserver=%s", in_ntoa(root_server_addr));
+	printk(", rootpath=%s", root_server_path);
+	printk("\n");
+#endif /* !SILENT */
+
 	return 0;
 }
 
@@ -869,7 +1187,7 @@
  *  command line parameter. It consists of option fields separated by colons in
  *  the following order:
  *
- *  <client-ip>:<server-ip>:<gw-ip>:<netmask>:<host name>:<device>:<bootp|rarp>
+ *  <client-ip>:<server-ip>:<gw-ip>:<netmask>:<host name>:<device>:<PROTO>
  *
  *  Any of the fields can be empty which means to use a default value:
  *	<client-ip>	- address given by BOOTP or RARP
@@ -880,28 +1198,38 @@
  *	<host name>	- <client-ip> in ASCII notation, or the name returned
  *			  by BOOTP
  *	<device>	- use all available devices
- *	<bootp|rarp|both|off> - use both protocols to determine my own address
+ *	<PROTO>:
+ *	   dhcp|bootp|rarp  - use given protocol
+ *	   both or empty    - use both BOOTP and RARP (not DHCP)
+ *	   off or none	    - don't do autoconfig at all
  */
 static int __init ic_proto_name(char *name)
 {
-	if (!strcmp(name, "off")) {
+	if (!strcmp(name, "off") || !strcmp(name, "none")) {
 		ic_proto_enabled = 0;
 		return 1;
 	}
+#ifdef CONFIG_IP_PNP_DHCP
+	else if (!strcmp(name, "dhcp")) {
+		ic_proto_enabled &= ~IC_RARP;
+		return 1;
+	}
+#endif
 #ifdef CONFIG_IP_PNP_BOOTP
 	else if (!strcmp(name, "bootp")) {
-		ic_proto_enabled &= ~IC_RARP;
+		ic_proto_enabled &= ~(IC_RARP | IC_USE_DHCP);
 		return 1;
 	}
 #endif
 #ifdef CONFIG_IP_PNP_RARP
 	else if (!strcmp(name, "rarp")) {
-		ic_proto_enabled &= ~IC_BOOTP;
+		ic_proto_enabled &= ~(IC_BOOTP | IC_USE_DHCP);
 		return 1;
 	}
 #endif
-#ifdef CONFIG_IP_PNP_DYNAMIC
+#ifdef IPCONFIG_DYNAMIC
 	else if (!strcmp(name, "both")) {
+		ic_proto_enabled &= ~IC_USE_DHCP; /* backward compat :-( */
 		return 1;
 	}
 #endif
@@ -913,8 +1241,7 @@
 	char *cp, *ip, *dp;
 	int num = 0;
 
-	ic_set_manually = 1;
-	if (!strcmp(addrs, "off")) {
+	if (!strcmp(addrs, "off") || !strcmp(addrs, "none")) {
 		ic_enable = 0;
 		return;
 	}
@@ -927,7 +1254,7 @@
 		if ((cp = strchr(ip, ':')))
 			*cp++ = '\0';
 		if (strlen(ip) > 0) {
-			DBG(("IP-Config: Parameter #%d: `%s'\n", num, ip));
+			DBG((SELF "Param #%d: `%s'\n", num, ip));
 			switch (num) {
 			case 0:
 				if ((ic_myaddr = in_aton(ip)) == INADDR_ANY)
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)