kinit/ipconfig/dhcp_proto.c

/*
 * DHCP RFC 2131 and 2132
 */
#include <sys/types.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <time.h>

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

static uint8_t dhcp_params[] = {
	1,			/* subnet mask */
	3,			/* default gateway */
	6,			/* DNS server */
	12,			/* host name */
	15,			/* domain name */
	17,			/* root path */
	26,			/* interface mtu */
	28,			/* broadcast addr */
	40,			/* NIS domain name (why?) */
};

static uint8_t dhcp_discover_hdr[] = {
	99, 130, 83, 99,		/* bootp cookie */
	53, 1, DHCPDISCOVER,		/* dhcp message type */
	55, sizeof(dhcp_params),	/* parameter list */
};

static uint8_t dhcp_request_hdr[] = {
	99, 130, 83, 99,		/* boot cookie */
	53, 1, DHCPREQUEST,		/* dhcp message type */
#define SERVER_IP_OFF 9
	54, 4, 0, 0, 0, 0,		/* server IP */
#define REQ_IP_OFF 15
	50, 4, 0, 0, 0, 0,		/* requested IP address */
	55, sizeof(dhcp_params),	/* parameter list */
};

static uint8_t dhcp_end[] = {
	255,
};

/* Both iovecs below have to have the same structure, since dhcp_send()
   pokes at the internals */
#define DHCP_IOV_LEN 6

static struct iovec dhcp_discover_iov[] = {
	/* [0] = ip + udp header */
	/* [1] = bootp header */
	[2] = {dhcp_discover_hdr, sizeof(dhcp_discover_hdr)},
	[3] = {dhcp_params, sizeof(dhcp_params)},
	/* [4] = DHCP vendor class */
	[5] = {dhcp_end, sizeof(dhcp_end)}
};

static struct iovec dhcp_request_iov[] = {
	/* [0] = ip + udp header */
	/* [1] = bootp header */
	[2] = {dhcp_request_hdr, sizeof(dhcp_request_hdr)},
	[3] = {dhcp_params, sizeof(dhcp_params)},
	/* [4] = DHCP vendor class */
	[5] = {dhcp_end, sizeof(dhcp_end)}
};

/*
 * Parse a DHCP response packet
 */
static int
dhcp_parse(struct netdev *dev, struct bootp_hdr *hdr, uint8_t * exts, int extlen)
{
	uint8_t type = 0;
	uint32_t serverid = INADDR_NONE;
	int ret = 0;

	if (extlen >= 4 && exts[0] == 99 && exts[1] == 130 &&
	    exts[2] == 83 && exts[3] == 99) {
		uint8_t *ext;

		for (ext = exts + 4; ext - exts < extlen;) {
			uint8_t len, *opt = ext++;
			if (*opt == 0)
				continue;

			len = *ext++;

			ext += len;

			if (*opt == 53)
				type = opt[2];
			if (*opt == 54)
				memcpy(&serverid, opt + 2, 4);
		}
	}

	switch (type) {
	case DHCPOFFER:
		ret = bootp_parse(dev, hdr, exts, extlen);
		if (ret == 1 && serverid != INADDR_NONE)
			dev->serverid = serverid;
		DEBUG(("\n   dhcp offer\n"));
		break;

	case DHCPACK:
		ret = bootp_parse(dev, hdr, exts, extlen);
		DEBUG(("\n   dhcp ack\n"));
		break;

	case DHCPNAK:
		ret = 2;
		DEBUG(("\n   dhcp nak\n"));
		break;
	}
	return ret;
}

/*
 * Receive and parse a DHCP packet
 */
static int dhcp_recv(struct netdev *dev)
{
	struct bootp_hdr bootp;
	uint8_t dhcp_options[1500];
	struct iovec iov[] = {
		/* [0] = ip + udp header */
		[1] = {&bootp, sizeof(struct bootp_hdr)},
		[2] = {dhcp_options, sizeof(dhcp_options)}
	};
	int ret;

	ret = packet_recv(iov, 3);
	if (ret <= 0)
		return ret;

	DEBUG(("\n   dhcp xid %08x ", dev->bootp.xid));

	if (ret < sizeof(struct bootp_hdr) || bootp.op != BOOTP_REPLY ||	/* RFC951 7.5 */
	    bootp.xid != dev->bootp.xid ||
	    memcmp(bootp.chaddr, dev->hwaddr, 16))
		return 0;

	ret -= sizeof(struct bootp_hdr);

	return dhcp_parse(dev, &bootp, dhcp_options, ret);
}

static int dhcp_send(struct netdev *dev, struct iovec *vec)
{
	struct bootp_hdr bootp;

	memset(&bootp, 0, sizeof(struct bootp_hdr));

	bootp.op	= BOOTP_REQUEST;
	bootp.htype	= dev->hwtype;
	bootp.hlen	= dev->hwlen;
	bootp.xid	= dev->bootp.xid;
	bootp.ciaddr	= dev->ip_addr;
	bootp.giaddr	= dev->bootp.gateway;
	bootp.secs	= htons(time(NULL) - dev->open_time);
	memcpy(bootp.chaddr, dev->hwaddr, 16);

	vec[1].iov_base	= &bootp;
	vec[1].iov_len	= sizeof(struct bootp_hdr);

	vec[4].iov_base = vendor_class_identifier;
	vec[4].iov_len  = vendor_class_identifier_len;

	DEBUG(("xid %08x secs %d ", bootp.xid, ntohs(bootp.secs)));

	return packet_send(dev, vec, DHCP_IOV_LEN);
}

/*
 * Send a DHCP discover packet
 */
int dhcp_send_discover(struct netdev *dev)
{
	dev->ip_addr = INADDR_ANY;
	dev->ip_gateway = INADDR_ANY;

	DEBUG(("-> dhcp discover "));

	return dhcp_send(dev, dhcp_discover_iov);
}

/*
 * Receive a DHCP offer packet
 */
int dhcp_recv_offer(struct netdev *dev)
{
	return dhcp_recv(dev);
}

/*
 * Send a DHCP request packet
 */
int dhcp_send_request(struct netdev *dev)
{
	memcpy(&dhcp_request_hdr[SERVER_IP_OFF], &dev->serverid, 4);
	memcpy(&dhcp_request_hdr[REQ_IP_OFF], &dev->ip_addr, 4);

	DEBUG(("-> dhcp request "));

	return dhcp_send(dev, dhcp_request_iov);
}

/*
 * Receive a DHCP ack packet
 */
int dhcp_recv_ack(struct netdev *dev)
{
	return dhcp_recv(dev);
}
1	/*
2	* DHCP RFC 2131 and 2132
3	*/
4	#include <sys/types.h>
5	#include <sys/uio.h>
6	#include <netinet/in.h>
7	#include <stdio.h>
8	#include <string.h>
9	#include <time.h>
10
11	#include "ipconfig.h"
12	#include "netdev.h"
13	#include "bootp_packet.h"
14	#include "bootp_proto.h"
15	#include "dhcp_proto.h"
16	#include "packet.h"
17
18	static uint8_t dhcp_params[] = {
19	1, /* subnet mask */
20	3, /* default gateway */
21	6, /* DNS server */
22	12, /* host name */
23	15, /* domain name */
24	17, /* root path */
25	26, /* interface mtu */
26	28, /* broadcast addr */
27	40, /* NIS domain name (why?) */
28	};
29
30	static uint8_t dhcp_discover_hdr[] = {
31	99, 130, 83, 99, /* bootp cookie */
32	53, 1, DHCPDISCOVER, /* dhcp message type */
33	55, sizeof(dhcp_params), /* parameter list */
34	};
35
36	static uint8_t dhcp_request_hdr[] = {
37	99, 130, 83, 99, /* boot cookie */
38	53, 1, DHCPREQUEST, /* dhcp message type */
39	#define SERVER_IP_OFF 9
40	54, 4, 0, 0, 0, 0, /* server IP */
41	#define REQ_IP_OFF 15
42	50, 4, 0, 0, 0, 0, /* requested IP address */
43	55, sizeof(dhcp_params), /* parameter list */
44	};
45
46	static uint8_t dhcp_end[] = {
47	255,
48	};
49
50	/* Both iovecs below have to have the same structure, since dhcp_send()
51	pokes at the internals */
52	#define DHCP_IOV_LEN 6
53
54	static struct iovec dhcp_discover_iov[] = {
55	/* [0] = ip + udp header */
56	/* [1] = bootp header */
57	[2] = {dhcp_discover_hdr, sizeof(dhcp_discover_hdr)},
58	[3] = {dhcp_params, sizeof(dhcp_params)},
59	/* [4] = DHCP vendor class */
60	[5] = {dhcp_end, sizeof(dhcp_end)}
61	};
62
63	static struct iovec dhcp_request_iov[] = {
64	/* [0] = ip + udp header */
65	/* [1] = bootp header */
66	[2] = {dhcp_request_hdr, sizeof(dhcp_request_hdr)},
67	[3] = {dhcp_params, sizeof(dhcp_params)},
68	/* [4] = DHCP vendor class */
69	[5] = {dhcp_end, sizeof(dhcp_end)}
70	};
71
72	/*
73	* Parse a DHCP response packet
74	*/
75	static int
76	dhcp_parse(struct netdev dev, struct bootp_hdr hdr, uint8_t * exts, int extlen)
77	{
78	uint8_t type = 0;
79	uint32_t serverid = INADDR_NONE;
80	int ret = 0;
81
82	if (extlen >= 4 && exts[0] == 99 && exts[1] == 130 &&
83	exts[2] == 83 && exts[3] == 99) {
84	uint8_t *ext;
85
86	for (ext = exts + 4; ext - exts < extlen;) {
87	uint8_t len, *opt = ext++;
88	if (*opt == 0)
89	continue;
90
91	len = *ext++;
92
93	ext += len;
94
95	if (*opt == 53)
96	type = opt[2];
97	if (*opt == 54)
98	memcpy(&serverid, opt + 2, 4);
99	}
100	}
101
102	switch (type) {
103	case DHCPOFFER:
104	ret = bootp_parse(dev, hdr, exts, extlen);
105	if (ret == 1 && serverid != INADDR_NONE)
106	dev->serverid = serverid;
107	DEBUG(("\n dhcp offer\n"));
108	break;
109
110	case DHCPACK:
111	ret = bootp_parse(dev, hdr, exts, extlen);
112	DEBUG(("\n dhcp ack\n"));
113	break;
114
115	case DHCPNAK:
116	ret = 2;
117	DEBUG(("\n dhcp nak\n"));
118	break;
119	}
120	return ret;
121	}
122
123	/*
124	* Receive and parse a DHCP packet
125	*/
126	static int dhcp_recv(struct netdev *dev)
127	{
128	struct bootp_hdr bootp;
129	uint8_t dhcp_options[1500];
130	struct iovec iov[] = {
131	/* [0] = ip + udp header */
132	[1] = {&bootp, sizeof(struct bootp_hdr)},
133	[2] = {dhcp_options, sizeof(dhcp_options)}
134	};
135	int ret;
136
137	ret = packet_recv(iov, 3);
138	if (ret <= 0)
139	return ret;
140
141	DEBUG(("\n dhcp xid %08x ", dev->bootp.xid));
142
143	if (ret < sizeof(struct bootp_hdr) \|\| bootp.op != BOOTP_REPLY \|\| /* RFC951 7.5 */
144	bootp.xid != dev->bootp.xid \|\|
145	memcmp(bootp.chaddr, dev->hwaddr, 16))
146	return 0;
147
148	ret -= sizeof(struct bootp_hdr);
149
150	return dhcp_parse(dev, &bootp, dhcp_options, ret);
151	}
152
153	static int dhcp_send(struct netdev dev, struct iovec vec)
154	{
155	struct bootp_hdr bootp;
156
157	memset(&bootp, 0, sizeof(struct bootp_hdr));
158
159	bootp.op = BOOTP_REQUEST;
160	bootp.htype = dev->hwtype;
161	bootp.hlen = dev->hwlen;
162	bootp.xid = dev->bootp.xid;
163	bootp.ciaddr = dev->ip_addr;
164	bootp.giaddr = dev->bootp.gateway;
165	bootp.secs = htons(time(NULL) - dev->open_time);
166	memcpy(bootp.chaddr, dev->hwaddr, 16);
167
168	vec[1].iov_base = &bootp;
169	vec[1].iov_len = sizeof(struct bootp_hdr);
170
171	vec[4].iov_base = vendor_class_identifier;
172	vec[4].iov_len = vendor_class_identifier_len;
173
174	DEBUG(("xid %08x secs %d ", bootp.xid, ntohs(bootp.secs)));
175
176	return packet_send(dev, vec, DHCP_IOV_LEN);
177	}
178
179	/*
180	* Send a DHCP discover packet
181	*/
182	int dhcp_send_discover(struct netdev *dev)
183	{
184	dev->ip_addr = INADDR_ANY;
185	dev->ip_gateway = INADDR_ANY;
186
187	DEBUG(("-> dhcp discover "));
188
189	return dhcp_send(dev, dhcp_discover_iov);
190	}
191
192	/*
193	* Receive a DHCP offer packet
194	*/
195	int dhcp_recv_offer(struct netdev *dev)
196	{
197	return dhcp_recv(dev);
198	}
199
200	/*
201	* Send a DHCP request packet
202	*/
203	int dhcp_send_request(struct netdev *dev)
204	{
205	memcpy(&dhcp_request_hdr[SERVER_IP_OFF], &dev->serverid, 4);
206	memcpy(&dhcp_request_hdr[REQ_IP_OFF], &dev->ip_addr, 4);
207
208	DEBUG(("-> dhcp request "));
209
210	return dhcp_send(dev, dhcp_request_iov);
211	}
212
213	/*
214	* Receive a DHCP ack packet
215	*/
216	int dhcp_recv_ack(struct netdev *dev)
217	{
218	return dhcp_recv(dev);
219	}