diff --git a/src/netboot/Makefile.inc b/src/netboot/Makefile.inc
index b584d2f..5ff6533 100644
--- a/src/netboot/Makefile.inc
+++ b/src/netboot/Makefile.inc
@@ -17,7 +17,7 @@
 ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 ##
 
-netboot-y += bootp.c
+netboot-y += dhcp.c
 netboot-y += main.c
 netboot-y += tftp.c
 
diff --git a/src/netboot/bootp.c b/src/netboot/bootp.c
deleted file mode 100644
index 137e7c7..0000000
--- a/src/netboot/bootp.c
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but without any warranty; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
- * MA 02111-1307 USA
- */
-
-#include <assert.h>
-#include <endian.h>
-#include <libpayload.h>
-
-#include "drivers/net/net.h"
-#include "net/net.h"
-#include "net/uip.h"
-#include "net/uip_arp.h"
-#include "net/uip-udp-packet.h"
-#include "netboot/bootp.h"
-
-static BootpPacket *bootp_reply;
-static int bootp_reply_ready;
-static BootpPacket *bootp_request;
-
-static void bootp_options(uint8_t *options, int bytes);
-
-static void bootp_callback(void)
-{
-	// Check that it's the right port. If it isn't, some other connection
-	// is open and we got their packet, and that's a bug on our end.
-	assert(ntohw(uip_udp_conn->lport) == BootpClientPort);
-
-	// If there isn't any or enough data, ignore the packet.
-	if (!uip_newdata())
-		return;
-	if (uip_datalen() < sizeof(BootpPacket))
-		return;
-
-	// Copy the packet out to ensure alignment, etc.
-	memcpy(bootp_reply, uip_appdata, sizeof(BootpPacket));
-
-	// Check for problems in the reply.
-	if (bootp_reply->opcode != BootpReply ||
-		bootp_reply->hw_length != bootp_request->hw_length ||
-		memcmp(bootp_reply->client_hw_addr,
-		       bootp_request->client_hw_addr,
-		       bootp_request->hw_length) ||
-		(bootp_reply->transaction_id !=
-		 bootp_request->transaction_id))
-		return;
-
-	// Everything checks out. We have a valid reply.
-	bootp_reply_ready = 1;
-}
-
-int bootp(uip_ipaddr_t *server_ip, const char **bootfile)
-{
-	BootpPacket request, reply;
-
-	// Prepare the bootp request packet.
-	memset(&request, 0, sizeof(request));
-	request.opcode = BootpRequest;
-	request.hw_type = BootpEthernet;
-	request.hw_length = sizeof(uip_ethaddr);
-	request.hops = 0;
-	request.transaction_id = rand();
-	request.seconds = htonw(100);
-	assert(sizeof(uip_ethaddr) < sizeof(request.client_hw_addr));
-	memcpy(request.client_hw_addr, &uip_ethaddr, sizeof(uip_ethaddr));
-	memcpy(request.options, BootpCookie, sizeof(BootpCookie));
-	// Truncate the option list.
-	request.options[sizeof(BootpCookie)] = BootpTagEndOfList;
-
-	// Set up the UDP connection.
-	uip_ipaddr_t addr;
-	uip_ipaddr(&addr, 255,255,255,255);
-	struct uip_udp_conn *conn = uip_udp_new(&addr, htonw(BootpServerPort));
-	if (!conn) {
-		printf("Failed to set up UDP connection.\n");
-		return -1;
-	}
-	uip_udp_bind(conn, htonw(BootpClientPort));
-
-	// Send the request.
-	printf("Sending bootp request... ");
-	uip_udp_packet_send(conn, &request, sizeof(request));
-	printf("done.\n");
-
-	// Prepare for the reply.
-	printf("Waiting for reply... ");
-	bootp_reply = &reply;
-	bootp_request = &request;
-	bootp_reply_ready = 0;
-
-	// Poll network driver until we get a reply. Resend periodically.
-	net_set_callback(&bootp_callback);
-	for (;;) {
-		net_poll();
-		if (bootp_reply_ready)
-			break;
-		// No response, try again.
-		uip_udp_packet_send(conn, &request, sizeof(request));
-	}
-	uip_udp_remove(conn);
-	net_set_callback(NULL);
-	printf("done.\n");
-
-	// Get the stuff we wanted out of the reply.
-	int bootfile_size = sizeof(reply.bootfile_name) + 1;
-	char *file = malloc(bootfile_size);
-	if (!file) {
-		printf("Failed to allocate %d bytes for bootfile name.\n",
-			bootfile_size);
-		return -1;
-	}
-	file[bootfile_size - 1] = 0;
-	memcpy(file, reply.bootfile_name, sizeof(reply.bootfile_name));
-	*bootfile = file;
-	uip_ipaddr(server_ip, reply.server_ip >> 0, reply.server_ip >> 8,
-			      reply.server_ip >> 16, reply.server_ip >> 24);
-
-	// Apply the new network info.
-	uip_ipaddr_t my_ip;
-	uip_ipaddr(&my_ip, reply.your_ip >> 0, reply.your_ip >> 8,
-			   reply.your_ip >> 16, reply.your_ip >> 24);
-	uip_sethostaddr(&my_ip);
-
-	bootp_options(reply.options, sizeof(reply.options));
-
-	return 0;
-}
-
-static void bootp_options(uint8_t *options, int bytes)
-{
-	if (bytes < sizeof(BootpCookie) ||
-		memcmp(options, BootpCookie, sizeof(BootpCookie)))
-		return;
-
-	int pos = sizeof(BootpCookie);
-
-	while (pos < bytes) {
-		uint8_t tag = options[pos++];
-		if (pos >= bytes)
-			return;
-		uint8_t length = options[pos++];
-		if (pos >= bytes)
-			return;
-		uint8_t *value = &options[pos];
-		pos += length;
-		if (pos >= bytes)
-			return;
-
-		switch (tag) {
-		case BootpTagPadding:
-		case BootpTagTimeOffset:
-		case BootpTagTimeServers:
-		case BootpTagDnsServers:
-		case BootpTagPrintServers:
-		case BootpTagHostName:
-		case BootpTagFileSize:
-			break;
-		case BootpTagSubnetMask:
-			if (length < 4) {
-				printf("Truncated subnet mask.\n");
-			} else {
-				uip_ipaddr_t netmask;
-				uip_ipaddr(&netmask, value[0], value[1],
-						     value[2], value[3]);
-				uip_setnetmask(&netmask);
-			}
-			break;
-		case BootpTagDefaultRouters:
-			if (length < 4) {
-				printf("Truncated routers.\n");
-			} else {
-				uip_ipaddr_t router;
-				uip_ipaddr(&router, value[0], value[1],
-						    value[2], value[3]);
-				uip_setdraddr(&router);
-			}
-			break;
-		case BootpTagEndOfList:
-			return;
-		}
-	}
-}
diff --git a/src/netboot/bootp.h b/src/netboot/bootp.h
deleted file mode 100644
index fcc2722..0000000
--- a/src/netboot/bootp.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2013 Google Inc.
- *
- * See file CREDITS for list of people who contributed to this
- * project.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but without any warranty; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
- * MA 02111-1307 USA
- */
-
-#ifndef __NETBOOT_BOOTP_H__
-#define __NETBOOT_BOOTP_H__
-
-#include <stdint.h>
-
-#include "net/uip.h"
-
-typedef enum BootpOpcode
-{
-	BootpRequest = 1,
-	BootpReply = 2
-} BootpOpcode;
-
-typedef enum BootpHardwareType
-{
-	BootpEthernet = 1
-} BootpHardwareType;
-
-static const uint16_t BootpClientPort = 68;
-static const uint16_t BootpServerPort = 67;
-
-typedef struct __attribute__((packed)) BootpPacket
-{
-	uint8_t opcode;
-	uint8_t hw_type;
-	uint8_t hw_length;
-	uint8_t hops;
-	uint32_t transaction_id;
-	uint16_t seconds;
-	uint16_t unused;
-	uint32_t client_ip;
-	uint32_t your_ip;
-	uint32_t server_ip;
-	uint32_t gateway_ip;
-	uint8_t client_hw_addr[16];
-	uint8_t server_name[64];
-	uint8_t bootfile_name[128];
-	uint8_t options[64];
-} BootpPacket;
-
-static const uint8_t BootpCookie[] = { 99, 130, 83, 99 };
-
-typedef enum BootpTags {
-	BootpTagPadding = 0,
-	BootpTagSubnetMask = 1,
-	BootpTagTimeOffset = 2,
-	BootpTagDefaultRouters = 3,
-	BootpTagTimeServers = 4,
-	BootpTagDnsServers = 6,
-	BootpTagPrintServers = 9,
-	BootpTagHostName = 12,
-	BootpTagFileSize = 13,
-	BootpTagEndOfList = 255
-} BootpTags;
-
-int bootp(uip_ipaddr_t *server_ip, const char **bootfile);
-
-#endif /* __NETBOOT_BOOTP_H__ */
diff --git a/src/netboot/dhcp.c b/src/netboot/dhcp.c
new file mode 100644
index 0000000..0954e4a
--- /dev/null
+++ b/src/netboot/dhcp.c
@@ -0,0 +1,559 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <assert.h>
+#include <endian.h>
+#include <libpayload.h>
+
+#include "drivers/net/net.h"
+#include "net/net.h"
+#include "net/uip.h"
+#include "net/uip_arp.h"
+#include "net/uip-udp-packet.h"
+#include "netboot/dhcp.h"
+
+typedef enum DhcpOpcode
+{
+	DhcpRequestOp = 1,
+	DhcpReplyOp = 2
+} DhcpOpcode;
+
+typedef enum DhcpHardwareType
+{
+	DhcpEthernet = 1
+} DhcpHardwareType;
+
+static const uint16_t DhcpServerPort = 67;
+static const uint16_t DhcpClientPort = 68;
+
+typedef struct __attribute__((packed)) DhcpPacket
+{
+	uint8_t opcode;
+	uint8_t hw_type;
+	uint8_t hw_length;
+	uint8_t hops;
+	uint32_t transaction_id;
+	uint16_t seconds;
+	uint16_t flags;
+	uint32_t client_ip;
+	uint32_t your_ip;
+	uint32_t server_ip;
+	uint32_t gateway_ip;
+	uint8_t client_hw_addr[16];
+	uint8_t server_name[64];
+	uint8_t bootfile_name[128];
+	uint32_t cookie;
+	uint8_t options[308];
+} DhcpPacket;
+
+static const unsigned int DhcpMinPacketSize = 576;
+static const unsigned int DhcpMaxPacketSize =
+	sizeof(DhcpPacket) + UIP_IPH_LEN + UIP_UDPH_LEN;
+
+static const uint8_t DhcpCookie[] = { 99, 130, 83, 99 };
+
+typedef enum DhcpTags {
+	// "Vendor extensions".
+	DhcpTagPadding = 0,
+	DhcpTagSubnetMask = 1,
+	DhcpTagTimeOffset = 2,
+	DhcpTagDefaultRouter = 3,
+	DhcpTagTimeServer = 4,
+	DhcpTagDnsServer = 6,
+	DhcpTagLogServer = 7,
+	DhcpTagCookieServer = 8,
+	DhcpTagPrintServer = 9,
+	DhcpTagImpressServer = 10,
+	DhcpTagResourceLocationServer = 11,
+	DhcpTagHostName = 12,
+	DhcpTagBootFileSize = 13,
+	DhcpTagMeritDumpFile = 14,
+	DhcpTagDomainName = 15,
+	DhcpTagSwapServer = 16,
+	DhcpTagRootPath = 17,
+	DhcpTagExtensionsPath = 18,
+
+	// IP layer paramters per host.
+	DhcpTagIpForwarding = 19,
+	DhcpTagNonLocalSourceRouting = 20,
+	DhcpTagPolicyFilter = 21,
+	DhcpTagMaximumDatagramSize = 22,
+	DhcpTagDefaultTimeToLive = 23,
+	DhcpTagPathMtuAgingTimeout = 24,
+	DhcpTagPathMtuPlateauTable = 25,
+
+	// IP later parameters per interface.
+	DhcpTagInterfaceMtu = 26,
+	DhcpTagAllSubnetsAreLocal = 27,
+	DhcpTagBroadcastAddress = 28,
+	DhcpTagPerformMaskDiscovery = 29,
+	DhcpTagMaskSupplier = 30,
+	DhcpTagPerformRouterDiscovery = 31,
+	DhcpTagRouterSolicitationAddress = 32,
+	DhcpTagStaticRouteOption = 33,
+
+	// Link layer paramters per interface.
+	DhcpTagTrailerEncapsulation = 34,
+	DhcpTagArpCacheTimeout = 35,
+	DhcpTagEthernetEncapsulation = 36,
+
+	// Tcp parameters.
+	DhcpTagTcpDefaultTtl = 37,
+	DhcpTagTcpKeepaliveInterval = 38,
+	DhcpTagTcpKeepaliveGarbage = 39,
+
+	// Application and service parameters.
+	DhcpTagNetworkInformationServiceDomain = 40,
+	DhcpTagNetworkInformationServers = 41,
+	DhcpTagNetworkTimeProtocolServers = 42,
+	DhcpTagVendorSpecificInformation = 43,
+	DhcpTagNetbiosOverTcpIpNameServer = 44,
+	DhcpTagNetbiosOverTcpIpDatagramDistributionServer = 45,
+	DhcpTagNetbiosOverTcpIpNodeType = 46,
+	DhcpTagNetbiosOverTcpIpScope = 47,
+	DhcpTagXWindowSystemFontServer = 48,
+	DhcpTagXWindowSystemDisplayManager = 49,
+
+	// Dhcp extensions.
+	DhcpTagRequestedIpAddress = 50,
+	DhcpTagIpAddressLeaseTime = 51,
+	DhcpTagOptionOverload = 52,
+	DhcpTagMessageType = 53,
+	DhcpTagServerIdentifier = 54,
+	DhcpTagParameterRequestList = 55,
+	DhcpTagMessage = 56,
+	DhcpTagMaximumDhcpMessageSize = 57,
+	DhcpTagRenewalTimeValue = 58,
+	DhcpTagRebindTimeValue = 59,
+	DhcpTagClassIdentifier = 60,
+	DhcpTagClientIdentifier = 61,
+
+	DhcpTagEndOfList = 255
+} DhcpTags;
+
+typedef enum DhcpState
+{
+	DhcpInit,
+	DhcpRequesting,
+	DhcpBound
+} DhcpState;
+
+typedef enum DhcpMessageType
+{
+	DhcpNoMessageType = 0,
+	DhcpDiscover = 1,
+	DhcpOffer = 2,
+	DhcpRequest = 3,
+	DhcpDecline = 4,
+	DhcpAck = 5,
+	DhcpNak = 6,
+	DhcpRelease = 7
+} DhcpMessageType;
+
+enum {
+	OptionOverloadNone = 0,
+	OptionOverloadFile = 1,
+	OptionOverloadSname = 2,
+	OptionOverloadBoth = 3
+};
+
+// Used in dhcp_callback().
+static DhcpState dhcp_state = DhcpInit;
+static DhcpPacket *dhcp_in;
+static int dhcp_in_ready;
+static DhcpPacket *dhcp_out;
+
+typedef int (*DhcpOptionFunc)(uint8_t tag, uint8_t length, uint8_t *value,
+			      void *data);
+
+static int dhcp_process_options(DhcpPacket *packet, int overload,
+				DhcpOptionFunc func, void *data)
+{
+	uint8_t *options;
+	int size;
+	switch (overload) {
+	case OptionOverloadNone:
+		options = packet->options;
+		size = sizeof(packet->options);
+		break;
+	case OptionOverloadFile:
+		options = packet->bootfile_name;
+		size = sizeof(packet->bootfile_name);
+		break;
+	case OptionOverloadSname:
+		options = packet->server_name;
+		size = sizeof(packet->server_name);
+		break;
+	case OptionOverloadBoth:
+		options = packet->server_name;
+		size = sizeof(packet->server_name) +
+			sizeof(packet->bootfile_name);
+		break;
+	default:
+		return 1;
+	}
+
+	int pos = 0;
+
+	int new_overload = 0;
+
+	while (pos < size) {
+		uint8_t tag = options[pos++];
+		if (pos >= size)
+			return 1;
+		uint8_t length = options[pos++];
+		if (pos >= size)
+			return 1;
+		uint8_t *value = &options[pos];
+		pos += length;
+		if (pos >= size)
+			return 1;
+
+		// Handle "end of list" and "option overload" options.
+		if (tag == DhcpTagEndOfList)
+			break;
+		if (tag == DhcpTagOptionOverload) {
+			if (length < 1)
+				return 1;
+			new_overload = *value;
+			continue;
+		}
+
+		// Otherwise, use the provided callback.
+		assert(func);
+		if (func(tag, length, value, data))
+			return 1;
+	}
+
+	if (!overload && new_overload)
+		return dhcp_process_options(packet, new_overload, func, data);
+
+	return 0;
+}
+
+static int dhcp_get_type(uint8_t tag, uint8_t length, uint8_t *value,
+			 void *data)
+{
+	if (tag != DhcpTagMessageType)
+		return 0;
+	if (length < 1)
+		return 1;
+
+	DhcpMessageType *type = (DhcpMessageType *)data;
+	*type = (DhcpMessageType)*value;
+
+	return 0;
+}
+
+static int dhcp_get_server(uint8_t tag, uint8_t length, uint8_t *value,
+			   void *data)
+{
+	if (tag != DhcpTagServerIdentifier)
+		return 0;
+	if (length < sizeof(uint32_t))
+		return 1;
+
+	memcpy(data, value, sizeof(uint32_t));
+
+	return 0;
+}
+
+static int dhcp_apply_options(uint8_t tag, uint8_t length, uint8_t *value,
+			      void *data)
+{
+	switch (tag) {
+	case DhcpTagSubnetMask:
+		if (length < 4) {
+			printf("Truncated subnet mask.\n");
+			return 1;
+		} else {
+			uip_ipaddr_t netmask;
+			uip_ipaddr(&netmask, value[0], value[1],
+					     value[2], value[3]);
+			uip_setnetmask(&netmask);
+			return 0;
+		}
+	case DhcpTagDefaultRouter:
+		if (length < 4) {
+			printf("Truncated routers.\n");
+			return 1;
+		} else {
+			uip_ipaddr_t router;
+			uip_ipaddr(&router, value[0], value[1],
+					    value[2], value[3]);
+			uip_setdraddr(&router);
+			return 0;
+		}
+	}
+	return 0;
+}
+
+static void dhcp_callback(void)
+{
+	// Check that it's the right port. If it isn't, some other connection
+	// is open and we got their packet, and that's a bug on our end.
+	assert(ntohw(uip_udp_conn->lport) == DhcpClientPort);
+
+	// If there isn't any data, ignore the packet.
+	if (!uip_newdata())
+		return;
+
+	// Copy the packet out to ensure alignment, etc.
+	memset(dhcp_in, 0, sizeof(DhcpPacket));
+	memcpy(dhcp_in, uip_appdata, uip_datalen());
+
+	// Check for problems in the reply.
+	if (dhcp_in->opcode != DhcpReplyOp ||
+		dhcp_in->hw_length != dhcp_out->hw_length ||
+		memcmp(dhcp_in->client_hw_addr,
+		       dhcp_out->client_hw_addr,
+		       dhcp_out->hw_length) ||
+		(dhcp_in->transaction_id != dhcp_out->transaction_id))
+		return;
+
+	if (memcmp(&dhcp_in->cookie, DhcpCookie, sizeof(DhcpCookie)))
+		return;
+
+	DhcpMessageType type = DhcpNoMessageType;
+	if (dhcp_process_options(dhcp_in, OptionOverloadNone, &dhcp_get_type,
+				 &type))
+		return;
+
+	switch (dhcp_state) {
+	case DhcpInit:
+		if (type != DhcpOffer)
+			return;
+		break;
+	case DhcpRequesting:
+		if (type != DhcpAck && type != DhcpNak)
+			return;
+		break;
+	case DhcpBound:
+		// We shouldn't get any more packets once we're bound.
+		break;
+	}
+
+	// Everything checks out. We have a valid reply.
+	dhcp_in_ready = 1;
+}
+
+static void dhcp_send_packet(struct uip_udp_conn *conn, const char *name,
+			     DhcpPacket *out, DhcpPacket *in)
+{
+	// Send the outbound packet.
+	printf("Sending %s... ", name);
+	uip_udp_packet_send(conn, out, sizeof(*out));
+	printf("done.\n");
+
+	// Prepare for the reply.
+	printf("Waiting for reply... ");
+	dhcp_in = in;
+	dhcp_out = out;
+	dhcp_in_ready = 0;
+
+	// Poll network driver until we get a reply. Resend periodically.
+	net_set_callback(&dhcp_callback);
+	for (;;) {
+		net_poll();
+		if (dhcp_in_ready)
+			break;
+		// No response, try again.
+		uip_udp_packet_send(conn, out, sizeof(*out));
+	}
+	net_set_callback(NULL);
+	printf("done.\n");
+}
+
+static void dhcp_prep_packet(DhcpPacket *packet, uint32_t transaction_id)
+{
+	memset(packet, 0, sizeof(*packet));
+	packet->opcode = DhcpRequestOp;
+	packet->hw_type = DhcpEthernet;
+	packet->hw_length = sizeof(uip_ethaddr);
+	packet->hops = 0;
+	packet->transaction_id = transaction_id;
+	packet->seconds = htonw(100);
+	assert(sizeof(uip_ethaddr) < sizeof(packet->client_hw_addr));
+	memcpy(packet->client_hw_addr, &uip_ethaddr, sizeof(uip_ethaddr));
+	memcpy(&packet->cookie, DhcpCookie, sizeof(DhcpCookie));
+}
+
+static void dhcp_add_option(uint8_t **options, uint8_t tag, uint8_t *value,
+			    uint8_t length, int *remaining)
+{
+	assert(*remaining >= length + 2);
+	(*options)[0] = tag;
+	(*options)[1] = length;
+	if (length) {
+		assert(value);
+		memcpy(*options + 2, value, length);
+	}
+	*remaining -= length + 2;
+	*options += length + 2;
+}
+
+int dhcp_request(uip_ipaddr_t *next_ip, uip_ipaddr_t *server_ip,
+		 const char **bootfile)
+{
+	DhcpPacket out, in;
+	uint8_t byte;
+	uint8_t *options;
+	int remaining;
+	uint8_t requested[] = { DhcpTagSubnetMask, DhcpTagDefaultRouter };
+	assert(DhcpMaxPacketSize >= DhcpMinPacketSize);
+	uint16_t max_size = htonw(DhcpMaxPacketSize);
+
+	// Set up the UDP connection.
+	uip_ipaddr_t addr;
+	uip_ipaddr(&addr, 255,255,255,255);
+	struct uip_udp_conn *conn = uip_udp_new(&addr, htonw(DhcpServerPort));
+	if (!conn) {
+		printf("Failed to set up UDP connection.\n");
+		return 1;
+	}
+	uip_udp_bind(conn, htonw(DhcpClientPort));
+
+	// Send a DHCP discover packet.
+	dhcp_prep_packet(&out, rand());
+	options = out.options;
+	remaining = sizeof(out.options);
+	byte = DhcpDiscover;
+	dhcp_add_option(&options, DhcpTagMessageType, &byte, sizeof(byte),
+			&remaining);
+	dhcp_add_option(&options, DhcpTagParameterRequestList, requested,
+			sizeof(requested), &remaining);
+	dhcp_add_option(&options, DhcpTagMaximumDhcpMessageSize,
+			(uint8_t *)&max_size, sizeof(max_size), &remaining);
+	dhcp_add_option(&options, DhcpTagEndOfList, NULL, 0, &remaining);
+	dhcp_send_packet(conn, "DHCP discover", &out, &in);
+
+	// Extract the DHCP server id.
+	uint32_t server_id;
+	if (dhcp_process_options(&in, OptionOverloadNone, &dhcp_get_server,
+				 &server_id)) {
+		printf("Failed to extract server id.\n");
+		return 1;
+	}
+
+	// We got an offer. Request it.
+	dhcp_state = DhcpRequesting;
+	dhcp_prep_packet(&out, rand());
+	out.client_ip = in.your_ip;
+	options = out.options;
+	remaining = sizeof(out.options);
+	byte = DhcpRequest;
+	dhcp_add_option(&options, DhcpTagMessageType, &byte, sizeof(byte),
+			&remaining);
+	dhcp_add_option(&options, DhcpTagParameterRequestList, requested,
+			sizeof(requested), &remaining);
+	dhcp_add_option(&options, DhcpTagMaximumDhcpMessageSize,
+			(uint8_t *)&max_size, sizeof(max_size), &remaining);
+	dhcp_add_option(&options, DhcpTagServerIdentifier,
+			(uint8_t *)&server_id, sizeof(server_id), &remaining);
+	dhcp_add_option(&options, DhcpTagEndOfList, NULL, 0, &remaining);
+	dhcp_send_packet(conn, "DHCP request", &out, &in);
+
+	DhcpMessageType type;
+	if (dhcp_process_options(&in, OptionOverloadNone, &dhcp_get_type,
+				 &type)) {
+		printf("Failed to extract message type.\n");
+		dhcp_state = DhcpInit;
+		return 1;
+	}
+	if (type == DhcpNak) {
+		printf("DHCP request nak-ed by the server.\n");
+		dhcp_state = DhcpInit;
+		return 1;
+	}
+
+	// The server acked, completing the transaction.
+	dhcp_state = DhcpBound;
+	uip_udp_remove(conn);
+
+	// Apply the settings.
+	if (dhcp_process_options(&in, OptionOverloadNone,
+				 &dhcp_apply_options, NULL)) {
+		dhcp_state = DhcpInit;
+		return 1;
+	}
+
+	int bootfile_size = sizeof(in.bootfile_name) + 1;
+	char *file = malloc(bootfile_size);
+	if (!file) {
+		printf("Failed to allocate %d bytes for bootfile name.\n",
+			bootfile_size);
+		dhcp_state = DhcpInit;
+		return 1;
+	}
+	file[bootfile_size - 1] = 0;
+	memcpy(file, in.bootfile_name, sizeof(in.bootfile_name));
+	*bootfile = file;
+	uip_ipaddr(next_ip, in.server_ip >> 0, in.server_ip >> 8,
+			    in.server_ip >> 16, in.server_ip >> 24);
+
+	uip_ipaddr(server_ip, server_id >> 0, server_id >> 8,
+			      server_id >> 16, server_id >> 24);
+
+	uip_ipaddr_t my_ip;
+	uip_ipaddr(&my_ip, in.your_ip >> 0, in.your_ip >> 8,
+			   in.your_ip >> 16, in.your_ip >> 24);
+	uip_sethostaddr(&my_ip);
+
+	return 0;
+}
+
+int dhcp_release(uip_ipaddr_t server_ip)
+{
+	DhcpPacket release;
+
+	// Set up the UDP connection.
+	struct uip_udp_conn *conn =
+		uip_udp_new(&server_ip, htonw(DhcpServerPort));
+	if (!conn) {
+		printf("Failed to set up UDP connection.\n");
+		return 1;
+	}
+	uip_udp_bind(conn, htonw(DhcpClientPort));
+
+	// Prepare the DHCP release packet.
+	dhcp_prep_packet(&release, rand());
+	uip_ipaddr_t my_ip;
+	uip_gethostaddr(&my_ip);
+	release.client_ip = (uip_ipaddr1(&my_ip) << 0) |
+			    (uip_ipaddr2(&my_ip) << 8) |
+			    (uip_ipaddr3(&my_ip) << 16) |
+			    (uip_ipaddr4(&my_ip) << 24);
+	uint8_t *options = release.options;
+	int remaining = sizeof(release.options);
+	uint8_t byte = DhcpRelease;
+	dhcp_add_option(&options, DhcpTagMessageType, &byte, sizeof(byte),
+			&remaining);
+	dhcp_add_option(&options, DhcpTagEndOfList, NULL, 0, &remaining);
+
+	// Call uip_udp_packet_send directly since we won't get a reply.
+	uip_udp_packet_send(conn, &release, sizeof(release));
+
+	dhcp_state = DhcpInit;
+	uip_udp_remove(conn);
+
+	return 0;
+}
diff --git a/src/netboot/dhcp.h b/src/netboot/dhcp.h
new file mode 100644
index 0000000..dde59cd
--- /dev/null
+++ b/src/netboot/dhcp.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __NETBOOT_DHCP_H__
+#define __NETBOOT_DHCP_H__
+
+#include <stdint.h>
+
+#include "net/uip.h"
+
+int dhcp_request(uip_ipaddr_t *next_ip, uip_ipaddr_t *server_ip,
+		 const char **bootfile);
+int dhcp_release(uip_ipaddr_t server_ip);
+
+#endif /* __NETBOOT_DHCP_H__ */
diff --git a/src/netboot/main.c b/src/netboot/main.c
index 4880b50..7ebc615 100644
--- a/src/netboot/main.c
+++ b/src/netboot/main.c
@@ -35,7 +35,7 @@
 #include "drivers/power/power.h"
 #include "net/uip.h"
 #include "net/uip_arp.h"
-#include "netboot/bootp.h"
+#include "netboot/dhcp.h"
 #include "netboot/tftp.h"
 #include "vboot/boot.h"
 #include "vboot/util/flag.h"
@@ -128,24 +128,33 @@
 	uip_setethaddr(*mac_addr);
 
 	// Find out who we are and what we should boot.
-	uip_ipaddr_t my_ip, server_ip;
+	uip_ipaddr_t my_ip, next_ip, server_ip;
 	const char *bootfile;
-	if (bootp(&server_ip, &bootfile)) {
-		printf("Bootp failed.\n");
-		halt();
-	}
+	while (dhcp_request(&next_ip, &server_ip, &bootfile))
+		printf("Dhcp failed, retrying.\n");
+
 	printf("My ip is ");
 	uip_gethostaddr(&my_ip);
 	print_ip_addr(&my_ip);
-	printf("\nThe server ip is ");
+	printf("\nThe DHCP server ip is ");
 	print_ip_addr(&server_ip);
+	printf("\nThe TFTP server ip is ");
+	print_ip_addr(&next_ip);
 	printf("\nThe boot file is %s\n", bootfile);
 
 	uint32_t size;
-	if (tftp_read(payload, &server_ip, bootfile, &size)) {
+	if (tftp_read(payload, &next_ip, bootfile, &size)) {
 		printf("Tftp failed.\n");
+		if (dhcp_release(server_ip))
+			printf("Dhcp release failed.\n");
 		halt();
 	}
+
+	if (dhcp_release(server_ip)) {
+		printf("Dhcp release failed.\n");
+		halt();
+	}
+
 	printf("The bootfile was %d bytes long.\n", size);
 
 	char *cmd_line = CONFIG_NETBOOT_DEFAULT_COMMAND_LINE;