[Settings] Migrate DHCP and NVO code to the new settings API (untested)

3 files changed, 599 insertions, 685 deletions

diff --git a/src/net/dhcpopts.c b/src/net/dhcpopts.c
index 8788d13e..6d961f41 100644
--- a/src/net/dhcpopts.c
+++ b/src/net/dhcpopts.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -19,14 +19,10 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <byteswap.h>
 #include <errno.h>
 #include <string.h>
-#include <assert.h>
-#include <gpxe/list.h>
-#include <gpxe/in.h>
-#include <gpxe/uri.h>
 #include <gpxe/dhcp.h>
+#include <gpxe/dhcpopts.h>
 
 /** @file
  *
@@ -34,9 +30,6 @@
  *
  */
 
-/** List of registered DHCP option blocks */
-LIST_HEAD ( dhcp_option_blocks );
-
 /**
  * Obtain printable version of a DHCP option tag
  *
@@ -58,47 +51,28 @@ static inline char * dhcp_tag_name ( unsigned int tag ) {
 }
 
 /**
- * Obtain value of a numerical DHCP option
- *
- * @v option		DHCP option, or NULL
- * @ret value		Numerical value of the option, or 0
+ * Get pointer to DHCP option
  *
- * Parses the numerical value from a DHCP option, if present.  It is
- * permitted to call dhcp_num_option() with @c option set to NULL; in
- * this case 0 will be returned.
- *
- * The caller does not specify the size of the DHCP option data; this
- * is implied by the length field stored within the DHCP option
- * itself.
+ * @v options		DHCP options block
+ * @v offset		Offset within options block
+ * @ret option		DHCP option
  */
-unsigned long dhcp_num_option ( struct dhcp_option *option ) {
-	unsigned long value = 0;
-	uint8_t *data;
-
-	if ( option ) {
-		/* This is actually smaller code than using htons()
-		 * etc., and will also cope well with malformed
-		 * options (such as zero-length options).
-		 */
-		for ( data = option->data.bytes ;
-		      data < ( option->data.bytes + option->len ) ; data++ )
-			value = ( ( value << 8 ) | *data );
-	}
-	return value;
+static inline __attribute__ (( always_inline )) struct dhcp_option *
+dhcp_option ( struct dhcp_options *options, unsigned int offset ) {
+	return ( ( struct dhcp_option * ) ( options->data + offset ) );
 }
 
 /**
- * Calculate length of a normal DHCP option
+ * Get offset of a DHCP option
  *
+ * @v options		DHCP options block
  * @v option		DHCP option
- * @ret len		Length (including tag and length field)
- *
- * @c option may not be a @c DHCP_PAD or @c DHCP_END option.
+ * @ret offset		Offset within options block
  */
-static inline unsigned int dhcp_option_len ( struct dhcp_option *option ) {
-	assert ( option->tag != DHCP_PAD );
-	assert ( option->tag != DHCP_END );
-	return ( option->len + DHCP_OPTION_HEADER_LEN );
+static inline __attribute__ (( always_inline )) int
+dhcp_option_offset ( struct dhcp_options *options,
+		     struct dhcp_option *option ) {
+	return ( ( ( void * ) option ) - options->data );
 }
 
 /**
@@ -107,11 +81,11 @@ static inline unsigned int dhcp_option_len ( struct dhcp_option *option ) {
  * @v option		DHCP option
  * @ret len		Length (including tag and length field)
  */
-static inline unsigned int dhcp_any_option_len ( struct dhcp_option *option ) {
+static unsigned int dhcp_option_len ( struct dhcp_option *option ) {
 	if ( ( option->tag == DHCP_END ) || ( option->tag == DHCP_PAD ) ) {
 		return 1;
 	} else {
-		return dhcp_option_len ( option );
+		return ( option->len + DHCP_OPTION_HEADER_LEN );
 	}
 }
 
@@ -120,27 +94,27 @@ static inline unsigned int dhcp_any_option_len ( struct dhcp_option *option ) {
  *
  * @v options		DHCP options block
  * @v tag		DHCP option tag to search for
- * @ret encapsulator	Encapsulating DHCP option
- * @ret option		DHCP option, or NULL if not found
+ * @ret encap_offset	Offset of encapsulating DHCP option
+ * @ret offset		Offset of DHCP option, or negative error
  *
  * Searches for the DHCP option matching the specified tag within the
  * DHCP option block.  Encapsulated options may be searched for by
  * using DHCP_ENCAP_OPT() to construct the tag value.
  *
  * If the option is encapsulated, and @c encapsulator is non-NULL, it
- * will be filled in with a pointer to the encapsulating option.
+ * will be filled in with the offset of the encapsulating option.
  *
  * This routine is designed to be paranoid.  It does not assume that
  * the option data is well-formatted, and so must guard against flaws
  * such as options missing a @c DHCP_END terminator, or options whose
  * length would take them beyond the end of the data block.
  */
-static struct dhcp_option *
-find_dhcp_option_with_encap ( struct dhcp_option_block *options,
-			      unsigned int tag,
-			      struct dhcp_option **encapsulator ) {
+static int find_dhcp_option_with_encap ( struct dhcp_options *options,
+					 unsigned int tag,
+					 int *encap_offset ) {
 	unsigned int original_tag __attribute__ (( unused )) = tag;
-	struct dhcp_option *option = options->data;
+	struct dhcp_option *option;
+	int offset = 0;
 	ssize_t remaining = options->len;
 	unsigned int option_len;
 
@@ -149,16 +123,17 @@ find_dhcp_option_with_encap ( struct dhcp_option_block *options,
 		 * if the length is malformed (i.e. takes us beyond
 		 * the end of the data block).
 		 */
-		option_len = dhcp_any_option_len ( option );
+		option = dhcp_option ( options, offset );
+		option_len = dhcp_option_len ( option );
 		remaining -= option_len;
 		if ( remaining < 0 )
 			break;
 		/* Check for matching tag */
 		if ( option->tag == tag ) {
-			DBG ( "Found DHCP option %s (length %d) in block %p\n",
-			      dhcp_tag_name ( original_tag ), option->len,
-			      options );
-			return option;
+			DBGC ( options, "DHCPOPT %p found %s (length %d)\n",
+			       options, dhcp_tag_name ( original_tag ),
+			       option_len );
+			return offset;
 		}
 		/* Check for explicit end marker */
 		if ( option->tag == DHCP_END )
@@ -166,168 +141,74 @@ find_dhcp_option_with_encap ( struct dhcp_option_block *options,
 		/* Check for start of matching encapsulation block */
 		if ( DHCP_IS_ENCAP_OPT ( tag ) &&
 		     ( option->tag == DHCP_ENCAPSULATOR ( tag ) ) ) {
-			if ( encapsulator )
-				*encapsulator = option;
+			if ( encap_offset )
+				*encap_offset = offset;
 			/* Continue search within encapsulated option block */
 			tag = DHCP_ENCAPSULATED ( tag );
-			remaining = option->len;
-			option = ( void * ) &option->data;
+			remaining = option_len;
+			offset += DHCP_OPTION_HEADER_LEN;
 			continue;
 		}
-		option = ( ( ( void * ) option ) + option_len );
-	}
-	return NULL;
-}
-
-/**
- * Find DHCP option within DHCP options block
- *
- * @v options		DHCP options block, or NULL
- * @v tag		DHCP option tag to search for
- * @ret option		DHCP option, or NULL if not found
- *
- * Searches for the DHCP option matching the specified tag within the
- * DHCP option block.  Encapsulated options may be searched for by
- * using DHCP_ENCAP_OPT() to construct the tag value.
- *
- * If @c options is NULL, all registered option blocks will be
- * searched.  Where multiple option blocks contain the same DHCP
- * option, the option from the highest-priority block will be
- * returned.  (Priority of an options block is determined by the value
- * of the @c DHCP_EB_PRIORITY option within the block, if present; the
- * default priority is zero).
- */
-struct dhcp_option * find_dhcp_option ( struct dhcp_option_block *options,
-					unsigned int tag ) {
-	struct dhcp_option *option;
-
-	if ( options ) {
-		return find_dhcp_option_with_encap ( options, tag, NULL );
-	} else {
-		list_for_each_entry ( options, &dhcp_option_blocks, list ) {
-			if ( ( option = find_dhcp_option ( options, tag ) ) )
-				return option;
-		}
-		return NULL;
-	}
-}
-
-/**
- * Register DHCP option block
- *
- * @v options		DHCP option block
- *
- * Register a block of DHCP options.
- */
-void register_dhcp_options ( struct dhcp_option_block *options ) {
-	struct dhcp_option_block *existing;
-
-	/* Determine priority of new block */
-	options->priority = find_dhcp_num_option ( options, DHCP_EB_PRIORITY );
-	DBG ( "Registering DHCP options block %p with priority %d\n",
-	      options, options->priority );
-
-	/* Insert after any existing blocks which have a higher priority */
-	list_for_each_entry ( existing, &dhcp_option_blocks, list ) {
-		if ( options->priority > existing->priority )
-			break;
-	}
-	dhcpopt_get ( options );
-	list_add_tail ( &options->list, &existing->list );
-
-}
-
-/**
- * Unregister DHCP option block
- *
- * @v options		DHCP option block
- */
-void unregister_dhcp_options ( struct dhcp_option_block *options ) {
-	list_del ( &options->list );
-	dhcpopt_put ( options );
-}
-
-/**
- * Initialise empty block of DHCP options
- *
- * @v options		Uninitialised DHCP option block
- * @v data		Memory for DHCP option data
- * @v max_len		Length of memory for DHCP option data
- *
- * Populates the DHCP option data with a single @c DHCP_END option and
- * fills in the fields of the @c dhcp_option_block structure.
- */
-void init_dhcp_options ( struct dhcp_option_block *options,
-			 void *data, size_t max_len ) {
-	struct dhcp_option *option;
-
-	options->data = data;
-	options->max_len = max_len;
-	option = options->data;
-	option->tag = DHCP_END;
-	options->len = 1;
-
-	DBG ( "DHCP options block %p initialised (data %p max_len %#zx)\n",
-	      options, options->data, options->max_len );
-}
-
-/**
- * Allocate space for a block of DHCP options
- *
- * @v max_len		Maximum length of option block
- * @ret options		DHCP option block, or NULL
- *
- * Creates a new DHCP option block and populates it with an empty
- * options list.  This call does not register the options block.
- */
-struct dhcp_option_block * alloc_dhcp_options ( size_t max_len ) {
-	struct dhcp_option_block *options;
-
-	options = malloc ( sizeof ( *options ) + max_len );
-	if ( options ) {
-		init_dhcp_options ( options, 
-				    ( (void *) options + sizeof ( *options ) ),
-				    max_len );
+		offset += option_len;
 	}
-	return options;
+	return -ENOENT;
 }
 
 /**
  * Resize a DHCP option
  *
  * @v options		DHCP option block
- * @v option		DHCP option to resize
- * @v encapsulator	Encapsulating option (or NULL)
+ * @v offset		Offset of option to resize
+ * @v encap_offset	Offset of encapsulating offset (or -ve for none)
  * @v old_len		Old length (including header)
  * @v new_len		New length (including header)
+ * @v can_realloc	Can reallocate options data if necessary
  * @ret rc		Return status code
  */
-static int resize_dhcp_option ( struct dhcp_option_block *options,
-				struct dhcp_option *option,
-				struct dhcp_option *encapsulator,
-				size_t old_len, size_t new_len ) {
-	void *source = ( ( ( void * ) option ) + old_len );
-	void *dest = ( ( ( void * ) option ) + new_len );
-	void *end = ( options->data + options->max_len );
+static int resize_dhcp_option ( struct dhcp_options *options,
+				int offset, int encap_offset,
+				size_t old_len, size_t new_len,
+				int can_realloc ) {
+	struct dhcp_option *encapsulator;
+	struct dhcp_option *option;
 	ssize_t delta = ( new_len - old_len );
 	size_t new_options_len;
 	size_t new_encapsulator_len;
+	void *new_data;
+	void *source;
+	void *dest;
+	void *end;
 
 	/* Check for sufficient space, and update length fields */
 	if ( new_len > DHCP_MAX_LEN )
-		return -ENOMEM;
+		return -ENOSPC;
 	new_options_len = ( options->len + delta );
-	if ( new_options_len > options->max_len )
-		return -ENOMEM;
-	if ( encapsulator ) {
+	if ( new_options_len > options->max_len ) {
+		/* Reallocate options block if allowed to do so. */
+		if ( can_realloc ) {
+			new_data = realloc ( options->data, new_options_len );
+			if ( ! new_data )
+				return -ENOMEM;
+			options->data = new_data;
+			options->max_len = new_options_len;
+		} else {
+			return -ENOMEM;
+		}
+	}
+	if ( encap_offset >= 0 ) {
+		encapsulator = dhcp_option ( options, encap_offset );
 		new_encapsulator_len = ( encapsulator->len + delta );
 		if ( new_encapsulator_len > DHCP_MAX_LEN )
-			return -ENOMEM;
+			return -ENOSPC;
 		encapsulator->len = new_encapsulator_len;
 	}
 	options->len = new_options_len;
 
 	/* Move remainder of option data */
+	option = dhcp_option ( options, offset );
+	source = ( ( ( void * ) option ) + old_len );
+	dest = ( ( ( void * ) option ) + new_len );
+	end = ( options->data + options->max_len );
 	memmove ( dest, source, ( end - dest ) );
 
 	return 0;
@@ -340,7 +221,8 @@ static int resize_dhcp_option ( struct dhcp_option_block *options,
  * @v tag		DHCP option tag
  * @v data		New value for DHCP option
  * @v len		Length of value, in bytes
- * @ret option		DHCP option, or NULL
+ * @v can_realloc	Can reallocate options data if necessary
+ * @ret offset		Offset of DHCP option, or negative error
  *
  * Sets the value of a DHCP option within the options block.  The
  * option may or may not already exist.  Encapsulators will be created
@@ -350,97 +232,183 @@ static int resize_dhcp_option ( struct dhcp_option_block *options,
  * If it does fail, and the option existed previously, the option will
  * be left with its original value.
  */
-struct dhcp_option * set_dhcp_option ( struct dhcp_option_block *options,
-				       unsigned int tag,
-				       const void *data, size_t len ) {
+static int set_dhcp_option ( struct dhcp_options *options, unsigned int tag,
+			     const void *data, size_t len,
+			     int can_realloc ) {
 	static const uint8_t empty_encapsulator[] = { DHCP_END };
+	int offset;
+	int encap_offset = -1;
+	int creation_offset = 0;
 	struct dhcp_option *option;
-	void *insertion_point;
-	struct dhcp_option *encapsulator = NULL;
 	unsigned int encap_tag = DHCP_ENCAPSULATOR ( tag );
 	size_t old_len = 0;
 	size_t new_len = ( len ? ( len + DHCP_OPTION_HEADER_LEN ) : 0 );
-
-	/* Return NULL if no options block specified */
-	if ( ! options )
-		return NULL;
+	int rc;
 
 	/* Find old instance of this option, if any */
-	option = find_dhcp_option_with_encap ( options, tag, &encapsulator );
-	if ( option ) {
-		old_len = dhcp_option_len ( option );
-		DBG ( "Resizing DHCP option %s from length %d to %zd in block "
-		      "%p\n", dhcp_tag_name (tag), option->len, len, options );
+	offset = find_dhcp_option_with_encap ( options, tag, &encap_offset );
+	if ( offset >= 0 ) {
+		old_len = dhcp_option_len ( dhcp_option ( options, offset ) );
+		DBGC ( options, "DHCPOPT %p resizing %s from %zd to %zd\n",
+		       options, dhcp_tag_name ( tag ), old_len, new_len );
 	} else {
-		old_len = 0;
-		DBG ( "Creating DHCP option %s (length %zd) in block %p\n",
-		      dhcp_tag_name ( tag ), len, options );
+		DBGC ( options, "DHCPOPT %p creating %s (length %zd)\n",
+		       options, dhcp_tag_name ( tag ), len );
 	}
-	
+
 	/* Ensure that encapsulator exists, if required */
-	insertion_point = options->data;
-	if ( DHCP_IS_ENCAP_OPT ( tag ) ) {
-		if ( ! encapsulator )
-			encapsulator = set_dhcp_option ( options, encap_tag,
-							 empty_encapsulator,
-						sizeof ( empty_encapsulator) );
-		if ( ! encapsulator )
-			return NULL;
-		insertion_point = &encapsulator->data;
+	if ( encap_tag ) {
+		if ( encap_offset < 0 )
+			encap_offset = set_dhcp_option ( options, encap_tag,
+							 empty_encapsulator, 1,
+							 can_realloc );
+		if ( encap_offset < 0 )
+			return encap_offset;
+		creation_offset = ( encap_offset + DHCP_OPTION_HEADER_LEN );
 	}
 
 	/* Create new option if necessary */
-	if ( ! option )
-		option = insertion_point;
-	
+	if ( offset < 0 )
+		offset = creation_offset;
+
 	/* Resize option to fit new data */
-	if ( resize_dhcp_option ( options, option, encapsulator,
-				  old_len, new_len ) != 0 )
-		return NULL;
+	if ( ( rc = resize_dhcp_option ( options, offset, encap_offset,
+					 old_len, new_len,
+					 can_realloc ) ) != 0 )
+		return rc;
 
 	/* Copy new data into option, if applicable */
 	if ( len ) {
+		option = dhcp_option ( options, offset );
 		option->tag = tag;
 		option->len = len;
 		memcpy ( &option->data, data, len );
 	}
 
 	/* Delete encapsulator if there's nothing else left in it */
-	if ( encapsulator && ( encapsulator->len <= 1 ) )
-		set_dhcp_option ( options, encap_tag, NULL, 0 );
+	if ( encap_offset >= 0 ) {
+		option = dhcp_option ( options, encap_offset );
+		if ( option->len <= 1 )
+			set_dhcp_option ( options, encap_tag, NULL, 0, 0 );
+	}
 
-	return option;
+	return offset;
 }
 
 /**
- * Find DHCP numerical option, and return its value
+ * Store value of DHCP option setting
  *
- * @v options		DHCP options block
- * @v tag		DHCP option tag to search for
- * @ret value		Numerical value of the option, or 0 if not found
+ * @v options		DHCP option block
+ * @v tag		Setting tag number
+ * @v data		Setting data, or NULL to clear setting
+ * @v len		Length of setting data
+ * @ret rc		Return status code
+ */
+int dhcpopt_store ( struct dhcp_options *options, unsigned int tag,
+		    const void *data, size_t len ) {
+	int offset;
+
+	offset = set_dhcp_option ( options, tag, data, len, 0 );
+	if ( offset < 0 )
+		return offset;
+	return 0;
+}
+
+/**
+ * Store value of DHCP option setting, extending options block if necessary
  *
- * This function exists merely as a notational shorthand for a call to
- * find_dhcp_option() followed by a call to dhcp_num_option().  It is
- * not possible to distinguish between the cases "option not found"
- * and "option has a value of zero" using this function; if this
- * matters to you then issue the two constituent calls directly and
- * check that find_dhcp_option() returns a non-NULL value.
+ * @v options		DHCP option block
+ * @v tag		Setting tag number
+ * @v data		Setting data, or NULL to clear setting
+ * @v len		Length of setting data
+ * @ret rc		Return status code
  */
-unsigned long find_dhcp_num_option ( struct dhcp_option_block *options,
-				     unsigned int tag ) {
-	return dhcp_num_option ( find_dhcp_option ( options, tag ) );
+int dhcpopt_extensible_store ( struct dhcp_options *options, unsigned int tag,
+			       const void *data, size_t len ) {
+	int offset;
+
+	offset = set_dhcp_option ( options, tag, data, len, 1 );
+	if ( offset < 0 )
+		return offset;
+	return 0;
 }
 
 /**
- * Delete DHCP option
+ * Fetch value of DHCP option setting
  *
- * @v options		DHCP options block
- * @v tag		DHCP option tag
+ * @v options		DHCP option block
+ * @v tag		Setting tag number
+ * @v data		Buffer to fill with setting data
+ * @v len		Length of buffer
+ * @ret len		Length of setting data, or negative error
+ */
+int dhcpopt_fetch ( struct dhcp_options *options, unsigned int tag,
+		    void *data, size_t len ) {
+	int offset;
+	struct dhcp_option *option;
+	size_t option_len;
+
+	offset = find_dhcp_option_with_encap ( options, tag, NULL );
+	if ( offset < 0 )
+		return offset;
+
+	option = dhcp_option ( options, offset );
+	option_len = dhcp_option_len ( option );
+	if ( len > option_len )
+		len = option_len;
+	memcpy ( data, option->data, len );
+
+	return option_len;
+}
+
+/**
+ * Recalculate length of DHCP options block
+ *
+ * @v options		Uninitialised DHCP option block
  *
- * This function exists merely as a notational shorthand for a call to
- * set_dhcp_option() with @c len set to zero.
+ * The "used length" field will be updated based on scanning through
+ * the block to find the end of the options.
  */
-void delete_dhcp_option ( struct dhcp_option_block *options,
-			  unsigned int tag ) {
-	set_dhcp_option ( options, tag, NULL, 0 );
+static void dhcpopt_update_len ( struct dhcp_options *options ) {
+	struct dhcp_option *option;
+	int offset = 0;
+	ssize_t remaining = options->max_len;
+	unsigned int option_len;
+
+	/* Find last non-pad option */
+	options->len = 0;
+	while ( remaining ) {
+		option = dhcp_option ( options, offset );
+		option_len = dhcp_option_len ( option );
+		remaining -= option_len;
+		if ( remaining < 0 )
+			break;
+		offset += option_len;
+		if ( option->tag != DHCP_PAD )
+			options->len = offset;
+	}
+}
+
+/**
+ * Initialise prepopulated block of DHCP options
+ *
+ * @v options		Uninitialised DHCP option block
+ * @v data		Memory for DHCP option data
+ * @v max_len		Length of memory for DHCP option data
+ *
+ * The memory content must already be filled with valid DHCP options.
+ * A zeroed block counts as a block of valid DHCP options.
+ */
+void dhcpopt_init ( struct dhcp_options *options, void *data,
+		    size_t max_len ) {
+
+	/* Fill in fields */
+	options->data = data;
+	options->max_len = max_len;
+
+	/* Update length */
+	dhcpopt_update_len ( options );
+
+	DBGC ( options, "DHCPOPT %p created (data %p len %#zx max_len %#zx)\n",
+	       options, options->data, options->len, options->max_len );
 }
diff --git a/src/net/dhcppkt.c b/src/net/dhcppkt.c
new file mode 100644
index 00000000..0a11520f
--- /dev/null
+++ b/src/net/dhcppkt.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <gpxe/netdevice.h>
+#include <gpxe/dhcp.h>
+#include <gpxe/dhcpopts.h>
+#include <gpxe/dhcppkt.h>
+
+/** @file
+ *
+ * DHCP packets
+ *
+ */
+
+/** A dedicated field within a DHCP packet */
+struct dhcp_packet_field {
+	/** Settings tag number */
+	unsigned int tag;
+	/** Offset within DHCP packet */
+	uint16_t offset;
+	/** Length of field */
+	uint16_t len;
+};
+
+/** Declare a dedicated field within a DHCP packet
+ *
+ * @v _tag		Settings tag number
+ * @v _field		Field name
+ */
+#define DHCP_PACKET_FIELD( _tag, _field ) {				\
+		.tag = (_tag),						\
+		.offset = offsetof ( struct dhcphdr, _field ),		\
+		.len = sizeof ( ( ( struct dhcphdr * ) 0 )->_field ),	\
+	}
+
+/** Dedicated fields within a DHCP packet */
+static struct dhcp_packet_field dhcp_packet_fields[] = {
+	DHCP_PACKET_FIELD ( DHCP_EB_YIADDR, yiaddr ),
+	DHCP_PACKET_FIELD ( DHCP_EB_SIADDR, siaddr ),
+	DHCP_PACKET_FIELD ( DHCP_TFTP_SERVER_NAME, sname ),
+	DHCP_PACKET_FIELD ( DHCP_BOOTFILE_NAME, file ),
+};
+
+/**
+ * Get address of a DHCP packet field
+ *
+ * @v dhcphdr		DHCP packet header
+ * @v field		DHCP packet field
+ * @ret data		Packet field data
+ */
+static inline void * dhcp_packet_field ( struct dhcphdr *dhcphdr,
+					 struct dhcp_packet_field *field ) {
+	return ( ( ( void * ) dhcphdr ) + field->offset );
+}
+
+/**
+ * Find DHCP packet field corresponding to settings tag number
+ *
+ * @v tag		Settings tag number
+ * @ret field		DHCP packet field, or NULL
+ */
+static struct dhcp_packet_field *
+find_dhcp_packet_field ( unsigned int tag ) {
+	struct dhcp_packet_field *field;
+	unsigned int i;
+
+	for ( i = 0 ; i < ( sizeof ( dhcp_packet_fields ) /
+			    sizeof ( dhcp_packet_fields[0] ) ) ; i++ ) {
+		field = &dhcp_packet_fields[i];
+		if ( field->tag == tag )
+			return field;
+	}
+	return NULL;
+}
+				    
+/**
+ * Store value of DHCP packet setting
+ *
+ * @v settings		Settings block
+ * @v tag		Setting tag number
+ * @v data		Setting data, or NULL to clear setting
+ * @v len		Length of setting data
+ * @ret rc		Return status code
+ */
+static int dhcppkt_store ( struct settings *settings, unsigned int tag,
+			   const void *data, size_t len ) {
+	struct dhcp_packet *dhcppkt =
+		container_of ( settings, struct dhcp_packet, settings );
+	struct dhcp_packet_field *field;
+	int rc;
+
+	/* If this is a special field, fill it in */
+	if ( ( field = find_dhcp_packet_field ( tag ) ) != NULL ) {
+		if ( len > field->len )
+			return -ENOSPC;
+		memcpy ( dhcp_packet_field ( dhcppkt->dhcphdr, field ),
+			 data, len );
+		return 0;
+	}
+
+	/* Otherwise, use the generic options block */
+	rc = dhcpopt_store ( &dhcppkt->options, tag, data, len );
+
+	/* Update our used-length field */
+	dhcppkt->len = ( offsetof ( struct dhcphdr, options ) +
+			 dhcppkt->options.len );
+
+	return rc;
+}
+
+/**
+ * Fetch value of DHCP packet setting
+ *
+ * @v settings		Settings block
+ * @v tag		Setting tag number
+ * @v data		Buffer to fill with setting data
+ * @v len		Length of buffer
+ * @ret len		Length of setting data, or negative error
+ */
+static int dhcppkt_fetch ( struct settings *settings, unsigned int tag,
+			   void *data, size_t len ) {
+	struct dhcp_packet *dhcppkt =
+		container_of ( settings, struct dhcp_packet, settings );
+	struct dhcp_packet_field *field;
+	
+	/* If this is a special field, return it */
+	if ( ( field = find_dhcp_packet_field ( tag ) ) != NULL ) {
+		if ( len > field->len )
+			len = field->len;
+		memcpy ( data,
+			 dhcp_packet_field ( dhcppkt->dhcphdr, field ), len );
+		return field->len;
+	}
+
+	/* Otherwise, use the generic options block */
+	return dhcpopt_fetch ( &dhcppkt->options, tag, data, len );
+}
+
+/** DHCP settings operations */
+static struct settings_operations dhcppkt_settings_operations = {
+	.store = dhcppkt_store,
+	.fetch = dhcppkt_fetch,
+};
+
+/**
+ * Initialise prepopulated DHCP packet
+ *
+ * @v dhcppkt		Uninitialised DHCP packet
+ * @v refcnt		Reference counter of containing object, or NULL
+ * @v data		Memory for DHCP packet data
+ * @v max_len		Length of memory for DHCP packet data
+ *
+ * The memory content must already be filled with valid DHCP options.
+ * A zeroed block counts as a block of valid DHCP options.
+ */
+void dhcppkt_init ( struct dhcp_packet *dhcppkt, struct refcnt *refcnt,
+		    void *data, size_t len ) {
+	dhcppkt->dhcphdr = data;
+	dhcppkt->max_len = len;
+	dhcpopt_init ( &dhcppkt->options, &dhcppkt->dhcphdr->options,
+		       ( len - offsetof ( struct dhcphdr, options ) ) );
+	dhcppkt->len = ( offsetof ( struct dhcphdr, options ) +
+			 dhcppkt->options.len );
+	settings_init ( &dhcppkt->settings, &dhcppkt_settings_operations,
+			refcnt, "dhcp" );
+}
diff --git a/src/net/udp/dhcp.c b/src/net/udp/dhcp.c
index 1beabb98..624532d2 100644
--- a/src/net/udp/dhcp.c
+++ b/src/net/udp/dhcp.c
@@ -34,6 +34,10 @@
 #include <gpxe/uuid.h>
 #include <gpxe/dhcp.h>
 #include <gpxe/timer.h>
+#include <gpxe/settings.h>
+#include <gpxe/dhcp.h>
+#include <gpxe/dhcpopts.h>
+#include <gpxe/dhcppkt.h>
 
 /** @file
  *
@@ -41,7 +45,8 @@
  *
  */
 
-/** DHCP operation types
+/**
+ * DHCP operation types
  *
  * This table maps from DHCP message types (i.e. values of the @c
  * DHCP_MESSAGE_TYPE option) to values of the "op" field within a DHCP
@@ -76,6 +81,13 @@ static uint8_t dhcp_request_options_data[] = {
 	DHCP_END
 };
 
+/** Options common to all DHCP requests */
+static struct dhcp_options dhcp_request_options = {
+	.data = dhcp_request_options_data,
+	.max_len = sizeof ( dhcp_request_options_data ),
+	.len = sizeof ( dhcp_request_options_data ),
+};
+
 /** DHCP feature codes */
 static uint8_t dhcp_features[0] __table_start ( uint8_t, dhcp_features );
 static uint8_t dhcp_features_end[0] __table_end ( uint8_t, dhcp_features );
@@ -118,197 +130,33 @@ static uint32_t dhcp_xid ( struct net_device *netdev ) {
 	return xid;
 }
 
-/** Options common to all DHCP requests */
-static struct dhcp_option_block dhcp_request_options = {
-	.data = dhcp_request_options_data,
-	.max_len = sizeof ( dhcp_request_options_data ),
-	.len = sizeof ( dhcp_request_options_data ),
-};
-
-/**
- * Set option within DHCP packet
- *
- * @v dhcppkt		DHCP packet
- * @v tag		DHCP option tag
- * @v data		New value for DHCP option
- * @v len		Length of value, in bytes
- * @ret rc		Return status code
- *
- * Sets the option within the first available options block within the
- * DHCP packet.  Option blocks are tried in the order specified by @c
- * dhcp_option_block_fill_order.
- *
- * The magic options @c DHCP_EB_YIADDR and @c DHCP_EB_SIADDR are
- * intercepted and inserted into the appropriate fixed fields within
- * the DHCP packet.  The option @c DHCP_OPTION_OVERLOAD is silently
- * ignored, since our DHCP packet assembly method relies on always
- * having option overloading in use.
- */
-static int set_dhcp_packet_option ( struct dhcp_packet *dhcppkt,
-				    unsigned int tag, const void *data,
-				    size_t len ) {
-	struct dhcphdr *dhcphdr = dhcppkt->dhcphdr;
-	struct dhcp_option_block *options = &dhcppkt->options;
-	struct dhcp_option *option = NULL;
-
-	/* Special-case the magic options */
-	switch ( tag ) {
-	case DHCP_OPTION_OVERLOAD:
-		/* Hard-coded in packets we create; always ignore */
-		return 0;
-	case DHCP_EB_YIADDR:
-		memcpy ( &dhcphdr->yiaddr, data, sizeof ( dhcphdr->yiaddr ) );
-		return 0;
-	case DHCP_EB_SIADDR:
-		memcpy ( &dhcphdr->siaddr, data, sizeof ( dhcphdr->siaddr ) );
-		return 0;
-	case DHCP_TFTP_SERVER_NAME:
-		memset ( dhcphdr->sname, 0, sizeof ( dhcphdr->sname ) );
-		if ( len > sizeof ( dhcphdr->sname ) )
-			len = sizeof ( dhcphdr->sname );
-		memcpy ( dhcphdr->sname, data, len );
-		return 0;
-	case DHCP_BOOTFILE_NAME:
-		memset ( dhcphdr->file, 0, sizeof ( dhcphdr->file ) );
-		if ( len > sizeof ( dhcphdr->file ) )
-			len = sizeof ( dhcphdr->file );
-		memcpy ( dhcphdr->file, data, len );
-		return 0;
-	default:
-		/* Continue processing as normal */
-		break;
-	}
-		
-	/* Set option */
-	option = set_dhcp_option ( options, tag, data, len );
-
-	/* Update DHCP packet length */
-	dhcppkt->len = ( offsetof ( typeof ( *dhcppkt->dhcphdr ), options )
-			 + dhcppkt->options.len );
-
-	return ( option ? 0 : -ENOSPC );
-}
-
-/**
- * Copy option into DHCP packet
- *
- * @v dhcppkt		DHCP packet
- * @v options		DHCP option block, or NULL
- * @v tag		DHCP option tag to search for
- * @v new_tag		DHCP option tag to use for copied option
- * @ret rc		Return status code
- *
- * Copies a single option, if present, from the DHCP options block
- * into a DHCP packet.  The tag for the option may be changed if
- * desired; this is required by other parts of the DHCP code.
- *
- * @c options may specify a single options block, or be left as NULL
- * in order to search for the option within all registered options
- * blocks.
- */
-static int copy_dhcp_packet_option ( struct dhcp_packet *dhcppkt,
-				     struct dhcp_option_block *options,
-				     unsigned int tag, unsigned int new_tag ) {
-	struct dhcp_option *option;
-	int rc;
-
-	option = find_dhcp_option ( options, tag );
-	if ( option ) {
-		if ( ( rc = set_dhcp_packet_option ( dhcppkt, new_tag,
-						     &option->data,
-						     option->len ) ) != 0 )
-			return rc;
-	}
-	return 0;
-}
-
-/**
- * Copy options into DHCP packet
- *
- * @v dhcppkt		DHCP packet
- * @v options		DHCP option block, or NULL
- * @v encapsulator	Encapsulating option, or zero
- * @ret rc		Return status code
- * 
- * Copies options with the specified encapsulator from DHCP options
- * blocks into a DHCP packet.  Most options are copied verbatim.
- * Recognised encapsulated options fields are handled as such.
- *
- * @c options may specify a single options block, or be left as NULL
- * in order to copy options from all registered options blocks.
- */
-static int copy_dhcp_packet_encap_options ( struct dhcp_packet *dhcppkt,
-					    struct dhcp_option_block *options,
-					    unsigned int encapsulator ) {
-	unsigned int subtag;
-	unsigned int tag;
-	int rc;
-
-	for ( subtag = DHCP_MIN_OPTION; subtag <= DHCP_MAX_OPTION; subtag++ ) {
-		tag = DHCP_ENCAP_OPT ( encapsulator, subtag );
-		switch ( tag ) {
-		case DHCP_EB_ENCAP:
-		case DHCP_VENDOR_ENCAP:
-			/* Process encapsulated options field */
-			if ( ( rc = copy_dhcp_packet_encap_options ( dhcppkt,
-								     options,
-								     tag)) !=0)
-				return rc;
-			break;
-		default:
-			/* Copy option to reassembled packet */
-			if ( ( rc = copy_dhcp_packet_option ( dhcppkt, options,
-							      tag, tag ) ) !=0)
-				return rc;
-			break;
-		};
-	}
-
-	return 0;
-}
-
-/**
- * Copy options into DHCP packet
- *
- * @v dhcppkt		DHCP packet
- * @v options		DHCP option block, or NULL
- * @ret rc		Return status code
- * 
- * Copies options from DHCP options blocks into a DHCP packet.  Most
- * options are copied verbatim.  Recognised encapsulated options
- * fields are handled as such.
- *
- * @c options may specify a single options block, or be left as NULL
- * in order to copy options from all registered options blocks.
- */
-static int copy_dhcp_packet_options ( struct dhcp_packet *dhcppkt,
-				      struct dhcp_option_block *options ) {
-	return copy_dhcp_packet_encap_options ( dhcppkt, options, 0 );
-}
-
 /**
  * Create a DHCP packet
  *
+ * @v dhcppkt		DHCP packet structure to fill in
  * @v netdev		Network device
  * @v msgtype		DHCP message type
+ * @v options		Initial options to include (or NULL)
  * @v data		Buffer for DHCP packet
  * @v max_len		Size of DHCP packet buffer
- * @v dhcppkt		DHCP packet structure to fill in
  * @ret rc		Return status code
  *
  * Creates a DHCP packet in the specified buffer, and fills out a @c
  * dhcp_packet structure that can be passed to
  * set_dhcp_packet_option() or copy_dhcp_packet_options().
  */
-static int create_dhcp_packet ( struct net_device *netdev, uint8_t msgtype,
-				void *data, size_t max_len,
-				struct dhcp_packet *dhcppkt ) {
+static int create_dhcp_packet ( struct dhcp_packet *dhcppkt,
+				struct net_device *netdev, uint8_t msgtype,
+				struct dhcp_options *options, 
+				void *data, size_t max_len ) {
 	struct dhcphdr *dhcphdr = data;
+	size_t options_len;
 	unsigned int hlen;
 	int rc;
 
 	/* Sanity check */
-	if ( max_len < sizeof ( *dhcphdr ) )
+	options_len = ( options ? options->len : 0 );
+	if ( max_len < ( sizeof ( *dhcphdr ) + options_len ) )
 		return -ENOSPC;
 
 	/* Initialise DHCP packet content */
@@ -327,180 +175,19 @@ static int create_dhcp_packet ( struct net_device *netdev, uint8_t msgtype,
 	}
 	dhcphdr->hlen = hlen;
 	memcpy ( dhcphdr->chaddr, netdev->ll_addr, hlen );
+	memcpy ( dhcphdr->options, options, options_len );
 
-	/* Initialise DHCP packet structure */
-	dhcppkt->dhcphdr = dhcphdr;
-	dhcppkt->max_len = max_len;
-	init_dhcp_options ( &dhcppkt->options, dhcphdr->options,
-			    ( max_len -
-			      offsetof ( typeof ( *dhcphdr ), options ) ) );
+	/* Initialise DHCP packet structure and settings interface */
+	dhcppkt_init ( dhcppkt, NULL, data, max_len );
 	
 	/* Set DHCP_MESSAGE_TYPE option */
-	if ( ( rc = set_dhcp_packet_option ( dhcppkt, DHCP_MESSAGE_TYPE,
-					     &msgtype,
-					     sizeof ( msgtype ) ) ) != 0 )
+	if ( ( rc = store_setting ( &dhcppkt->settings, DHCP_MESSAGE_TYPE,
+				    &msgtype, sizeof ( msgtype ) ) ) != 0 )
 		return rc;
 
 	return 0;
 }
 
-/**
- * Calculate used length of a field containing DHCP options
- *
- * @v data		Field containing DHCP options
- * @v max_len		Field length
- * @ret len		Used length (excluding the @c DHCP_END tag)
- */
-static size_t dhcp_field_len ( const void *data, size_t max_len ) {
-	struct dhcp_option_block options;
-	struct dhcp_option *end;
-
-	options.data = ( ( void * ) data );
-	options.len = max_len;
-	end = find_dhcp_option ( &options, DHCP_END );
-	return ( end ? ( ( ( void * ) end ) - data ) : 0 );
-}
-
-/**
- * Merge field containing DHCP options or string into DHCP options block
- *
- * @v options		DHCP option block
- * @v data		Field containing DHCP options
- * @v max_len		Field length
- * @v tag		DHCP option tag, or 0
- *
- * If @c tag is non-zero (and the field is not empty), the field will
- * be treated as a NUL-terminated string representing the value of the
- * specified DHCP option.  If @c tag is zero, the field will be
- * treated as a block of DHCP options, and simply appended to the
- * existing options in the option block.
- *
- * The caller must ensure that there is enough space in the options
- * block to perform the merge.
- */
-static void merge_dhcp_field ( struct dhcp_option_block *options,
-			       const void *data, size_t max_len,
-			       unsigned int tag ) {
-	size_t len;
-	void *dest;
-	struct dhcp_option *end;
-
-	if ( tag ) {
-		len = strlen ( data );
-		if ( len )
-			set_dhcp_option ( options, tag, data, len );
-	} else {
-		len = dhcp_field_len ( data, max_len );
-		dest = ( options->data + options->len - 1 );
-		memcpy ( dest, data, len );
-		options->len += len;
-		end = ( dest + len );
-		end->tag = DHCP_END;
-	}
-}
-
-/**
- * Parse DHCP packet and construct DHCP options block
- *
- * @v dhcphdr		DHCP packet
- * @v len		Length of DHCP packet
- * @ret options		DHCP options block, or NULL
- *
- * Parses a received DHCP packet and canonicalises its contents into a
- * single DHCP options block.  The "file" and "sname" fields are
- * converted into the corresponding DHCP options (@c
- * DHCP_BOOTFILE_NAME and @c DHCP_TFTP_SERVER_NAME respectively).  If
- * these fields are used for option overloading, their options are
- * merged in to the options block.
- *
- * The values of the "yiaddr" and "siaddr" fields will be stored
- * within the options block as the magic options @c DHCP_EB_YIADDR and
- * @c DHCP_EB_SIADDR.
- * 
- * Note that this call allocates new memory for the constructed DHCP
- * options block; it is the responsibility of the caller to eventually
- * free this memory.
- */
-static struct dhcp_option_block * dhcp_parse ( const struct dhcphdr *dhcphdr,
-					       size_t len ) {
-	struct dhcp_option_block *options;
-	size_t options_len;
-	unsigned int overloading;
-
-	/* Sanity check */
-	if ( len < sizeof ( *dhcphdr ) )
-		return NULL;
-
-	/* Calculate size of resulting concatenated option block:
-	 *
-	 *   The "options" field : length of the field minus the DHCP_END tag.
-	 *
-	 *   The "file" field : maximum length of the field minus the
-	 *   NUL terminator, plus a 2-byte DHCP header or, if used for
-	 *   option overloading, the length of the field minus the
-	 *   DHCP_END tag.
-	 *
-	 *   The "sname" field : as for the "file" field.
-	 *
-	 *   15 bytes for an encapsulated options field to contain the
-	 *   value of the "yiaddr" and "siaddr" fields
-	 *
-	 *   1 byte for a final terminating DHCP_END tag.
-	 */
-	options_len = ( ( len - offsetof ( typeof ( *dhcphdr ), options ) ) - 1
-			+ ( sizeof ( dhcphdr->file ) + 1 )
-			+ ( sizeof ( dhcphdr->sname ) + 1 )
-			+ 15 /* yiaddr and siaddr */
-			+ 1 /* DHCP_END tag */ );
-	
-	/* Allocate empty options block of required size */
-	options = alloc_dhcp_options ( options_len );
-	if ( ! options ) {
-		DBG ( "DHCP could not allocate %zd-byte option block\n",
-		      options_len );
-		return NULL;
-	}
-	
-	/* Merge in "options" field, if this is a DHCP packet */
-	if ( dhcphdr->magic == htonl ( DHCP_MAGIC_COOKIE ) ) {
-		merge_dhcp_field ( options, dhcphdr->options,
-				   ( len -
-				     offsetof ( typeof (*dhcphdr), options ) ),
-				   0 /* Always contains options */ );
-	}
-
-	/* Identify overloaded fields */
-	overloading = find_dhcp_num_option ( options, DHCP_OPTION_OVERLOAD );
-	
-	/* Merge in "file" and "sname" fields */
-	merge_dhcp_field ( options, dhcphdr->file, sizeof ( dhcphdr->file ),
-			   ( ( overloading & DHCP_OPTION_OVERLOAD_FILE ) ?
-			     0 : DHCP_BOOTFILE_NAME ) );
-	merge_dhcp_field ( options, dhcphdr->sname, sizeof ( dhcphdr->sname ),
-			   ( ( overloading & DHCP_OPTION_OVERLOAD_SNAME ) ?
-			     0 : DHCP_TFTP_SERVER_NAME ) );
-
-	/* Set magic options for "yiaddr" and "siaddr", if present */
-	if ( dhcphdr->yiaddr.s_addr ) {
-		set_dhcp_option ( options, DHCP_EB_YIADDR,
-				  &dhcphdr->yiaddr, sizeof (dhcphdr->yiaddr) );
-	}
-	if ( dhcphdr->siaddr.s_addr ) {
-		set_dhcp_option ( options, DHCP_EB_SIADDR,
-				  &dhcphdr->siaddr, sizeof (dhcphdr->siaddr) );
-	}
-	
-	assert ( options->len <= options->max_len );
-
-	return options;
-}
-
-/****************************************************************************
- *
- * Whole-packet construction
- *
- */
-
 /** DHCP network device descriptor */
 struct dhcp_netdev_desc {
 	/** Bus type ID */
@@ -532,18 +219,18 @@ struct dhcp_client_uuid {
 /**
  * Create DHCP request
  *
+ * @v dhcppkt		DHCP packet structure to fill in
  * @v netdev		Network device
  * @v msgtype		DHCP message type
- * @v options		DHCP server response options, or NULL
+ * @v offer_settings	Settings received in DHCPOFFER, or NULL
  * @v data		Buffer for DHCP packet
  * @v max_len		Size of DHCP packet buffer
- * @v dhcppkt		DHCP packet structure to fill in
  * @ret rc		Return status code
  */
-int create_dhcp_request ( struct net_device *netdev, int msgtype,
-			  struct dhcp_option_block *options,
-			  void *data, size_t max_len,
-			  struct dhcp_packet *dhcppkt ) {
+int create_dhcp_request ( struct dhcp_packet *dhcppkt,
+			  struct net_device *netdev, int msgtype,
+			  struct settings *offer_settings,
+			  void *data, size_t max_len ) {
 	struct device_description *desc = &netdev->dev->desc;
 	struct dhcp_netdev_desc dhcp_desc;
 	struct dhcp_client_id client_id;
@@ -553,33 +240,27 @@ int create_dhcp_request ( struct net_device *netdev, int msgtype,
 	int rc;
 
 	/* Create DHCP packet */
-	if ( ( rc = create_dhcp_packet ( netdev, msgtype, data, max_len,
-					 dhcppkt ) ) != 0 ) {
+	if ( ( rc = create_dhcp_packet ( dhcppkt, netdev, msgtype,
+					 &dhcp_request_options, data,
+					 max_len ) ) != 0 ) {
 		DBG ( "DHCP could not create DHCP packet: %s\n",
 		      strerror ( rc ) );
 		return rc;
 	}
 
-	/* Copy in options common to all requests */
-	if ( ( rc = copy_dhcp_packet_options ( dhcppkt,
-					       &dhcp_request_options )) !=0 ){
-		DBG ( "DHCP could not set common DHCP options: %s\n",
-		      strerror ( rc ) );
-		return rc;
-	}
-
 	/* Copy any required options from previous server repsonse */
-	if ( options ) {
-		if ( ( rc = copy_dhcp_packet_option ( dhcppkt, options,
-					  DHCP_SERVER_IDENTIFIER,
-					  DHCP_SERVER_IDENTIFIER ) ) != 0 ) {
+	if ( offer_settings ) {
+		if ( ( rc = copy_setting ( &dhcppkt->settings,
+					   DHCP_SERVER_IDENTIFIER,
+					   offer_settings,
+					   DHCP_SERVER_IDENTIFIER ) ) != 0 ) {
 			DBG ( "DHCP could not set server identifier "
 			      "option: %s\n", strerror ( rc ) );
 			return rc;
 		}
-		if ( ( rc = copy_dhcp_packet_option ( dhcppkt, options,
-					  DHCP_EB_YIADDR,
-					  DHCP_REQUESTED_ADDRESS ) ) != 0 ) {
+		if ( ( rc = copy_setting ( &dhcppkt->settings, DHCP_EB_YIADDR,
+					   offer_settings,
+					   DHCP_REQUESTED_ADDRESS ) ) != 0 ) {
 			DBG ( "DHCP could not set requested address "
 			      "option: %s\n", strerror ( rc ) );
 			return rc;
@@ -588,9 +269,8 @@ int create_dhcp_request ( struct net_device *netdev, int msgtype,
 
 	/* Add options to identify the feature list */
 	dhcp_features_len = ( dhcp_features_end - dhcp_features );
-	if ( ( rc = set_dhcp_packet_option ( dhcppkt, DHCP_EB_ENCAP,
-					     dhcp_features,
-					     dhcp_features_len ) ) != 0 ) {
+	if ( ( rc = store_setting ( &dhcppkt->settings, DHCP_EB_ENCAP,
+				    dhcp_features, dhcp_features_len ) ) !=0 ){
 		DBG ( "DHCP could not set features list option: %s\n",
 		      strerror ( rc ) );
 		return rc;
@@ -600,9 +280,8 @@ int create_dhcp_request ( struct net_device *netdev, int msgtype,
 	dhcp_desc.type = desc->bus_type;
 	dhcp_desc.vendor = htons ( desc->vendor );
 	dhcp_desc.device = htons ( desc->device );
-	if ( ( rc = set_dhcp_packet_option ( dhcppkt, DHCP_EB_BUS_ID,
-					     &dhcp_desc,
-					     sizeof ( dhcp_desc ) ) ) != 0 ) {
+	if ( ( rc = store_setting ( &dhcppkt->settings, DHCP_EB_BUS_ID,
+				    &dhcp_desc, sizeof ( dhcp_desc ) ) ) !=0 ){
 		DBG ( "DHCP could not set bus ID option: %s\n",
 		      strerror ( rc ) );
 		return rc;
@@ -615,9 +294,8 @@ int create_dhcp_request ( struct net_device *netdev, int msgtype,
 	ll_addr_len = netdev->ll_protocol->ll_addr_len;
 	assert ( ll_addr_len <= sizeof ( client_id.ll_addr ) );
 	memcpy ( client_id.ll_addr, netdev->ll_addr, ll_addr_len );
-	if ( ( rc = set_dhcp_packet_option ( dhcppkt, DHCP_CLIENT_ID,
-					     &client_id,
-					     ( ll_addr_len + 1 ) ) ) != 0 ) {
+	if ( ( rc = store_setting ( &dhcppkt->settings, DHCP_CLIENT_ID,
+				    &client_id, ( ll_addr_len + 1 ) ) ) != 0 ){
 		DBG ( "DHCP could not set client ID: %s\n",
 		      strerror ( rc ) );
 		return rc;
@@ -626,9 +304,9 @@ int create_dhcp_request ( struct net_device *netdev, int msgtype,
 	/* Add client UUID, if we have one.  Required for PXE. */
 	client_uuid.type = DHCP_CLIENT_UUID_TYPE;
 	if ( ( rc = get_uuid ( &client_uuid.uuid ) ) == 0 ) {
-		if ( ( rc = set_dhcp_packet_option ( dhcppkt,
-					   DHCP_CLIENT_UUID, &client_uuid,
-					   sizeof ( client_uuid ) ) ) != 0 ) {
+		if ( ( rc = store_setting ( &dhcppkt->settings,
+					    DHCP_CLIENT_UUID, &client_uuid,
+					    sizeof ( client_uuid ) ) ) != 0 ) {
 			DBG ( "DHCP could not set client UUID: %s\n",
 			      strerror ( rc ) );
 			return rc;
@@ -641,36 +319,88 @@ int create_dhcp_request ( struct net_device *netdev, int msgtype,
 /**
  * Create DHCP response
  *
+ * @v dhcppkt		DHCP packet structure to fill in
  * @v netdev		Network device
  * @v msgtype		DHCP message type
- * @v options		DHCP options, or NULL
+ * @v settings		Settings to include, or NULL
  * @v data		Buffer for DHCP packet
  * @v max_len		Size of DHCP packet buffer
- * @v dhcppkt		DHCP packet structure to fill in
  * @ret rc		Return status code
  */
-int create_dhcp_response ( struct net_device *netdev, int msgtype,
-			   struct dhcp_option_block *options,
-			   void *data, size_t max_len,
-			   struct dhcp_packet *dhcppkt ) {
+int create_dhcp_response ( struct dhcp_packet *dhcppkt,
+			   struct net_device *netdev, int msgtype,
+			   struct settings *settings,
+			   void *data, size_t max_len ) {
 	int rc;
 
 	/* Create packet and copy in options */
-	if ( ( rc = create_dhcp_packet ( netdev, msgtype, data, max_len,
-					 dhcppkt ) ) != 0 ) {
-		DBG ( " failed to build packet" );
+	if ( ( rc = create_dhcp_packet ( dhcppkt, netdev, msgtype, NULL,
+					 data, max_len ) ) != 0 )
 		return rc;
-	}
-	if ( ( rc = copy_dhcp_packet_options ( dhcppkt, options ) ) != 0 ) {
-		DBG ( " failed to copy options" );
+	if ( ( rc = copy_settings ( &dhcppkt->settings, settings ) ) != 0 )
 		return rc;
-	}
 
 	return 0;
 }
 
 /****************************************************************************
  *
+ * DHCP packets contained in I/O buffers
+ *
+ */
+
+/** A DHCP packet contained in an I/O buffer */
+struct dhcp_iobuf_packet {
+	/** Reference counter */
+	struct refcnt refcnt;
+	/** DHCP packet */
+	struct dhcp_packet dhcppkt;
+	/** Containing I/O buffer */
+	struct io_buffer *iobuf;
+};
+
+/**
+ * Free DHCP packet contained in an I/O buffer
+ *
+ * @v refcnt		Reference counter
+ */
+static void dhcpiob_free ( struct refcnt *refcnt ) {
+	struct dhcp_iobuf_packet *dhcpiob =
+		container_of ( refcnt, struct dhcp_iobuf_packet, refcnt );
+
+	free_iob ( dhcpiob->iobuf );
+	free ( dhcpiob );
+}
+
+/**
+ * Create DHCP packet from I/O buffer
+ *
+ * @v iobuf		I/O buffer
+ * @ret dhcpiob		DHCP packet contained in I/O buffer
+ *
+ * This function takes ownership of the I/O buffer.  Future accesses
+ * must be via the @c dhcpiob data structure.
+ */
+static struct dhcp_iobuf_packet * dhcpiob_create ( struct io_buffer *iobuf ) {
+	struct dhcp_iobuf_packet *dhcpiob;
+
+	dhcpiob = zalloc ( sizeof ( *dhcpiob ) );
+	if ( dhcpiob ) {
+		dhcpiob->refcnt.free = dhcpiob_free;
+		dhcpiob->iobuf = iobuf;
+		dhcppkt_init ( &dhcpiob->dhcppkt, &dhcpiob->refcnt,
+			       iobuf->data, iob_len ( iobuf ) );
+	}
+	return dhcpiob;
+}
+
+static void dhcpiob_put ( struct dhcp_iobuf_packet *dhcpiob ) {
+	if ( dhcpiob )
+		ref_put ( &dhcpiob->refcnt );
+}
+
+/****************************************************************************
+ *
  * DHCP to UDP interface
  *
  */
@@ -686,9 +416,6 @@ struct dhcp_session {
 
 	/** Network device being configured */
 	struct net_device *netdev;
-	/** Option block registration routine */
-	int ( * register_options ) ( struct net_device *netdev,
-				     struct dhcp_option_block *options );
 
 	/** State of the session
 	 *
@@ -696,10 +423,10 @@ struct dhcp_session {
 	 * (e.g. @c DHCPDISCOVER).
 	 */
 	int state;
-	/** Options obtained from DHCP server */
-	struct dhcp_option_block *options;
-	/** Options obtained from ProxyDHCP server */
-	struct dhcp_option_block *proxy_options;
+	/** Response obtained from DHCP server */
+	struct dhcp_iobuf_packet *response;
+	/** Response obtained from ProxyDHCP server */
+	struct dhcp_iobuf_packet *proxy_response;
 	/** Retransmission timer */
 	struct retry_timer timer;
 	/** Session start time (in ticks) */
@@ -716,8 +443,8 @@ static void dhcp_free ( struct refcnt *refcnt ) {
 		container_of ( refcnt, struct dhcp_session, refcnt );
 
 	netdev_put ( dhcp->netdev );
-	dhcpopt_put ( dhcp->options );
-	dhcpopt_put ( dhcp->proxy_options );
+	dhcpiob_put ( dhcp->response );
+	dhcpiob_put ( dhcp->proxy_response );
 	free ( dhcp );
 }
 
@@ -741,6 +468,31 @@ static void dhcp_finished ( struct dhcp_session *dhcp, int rc ) {
 	job_done ( &dhcp->job, rc );
 }
 
+/**
+ * Register options received via DHCP
+ *
+ * @v dhcp		DHCP session
+ * @ret rc		Return status code
+ */
+static int dhcp_register_settings ( struct dhcp_session *dhcp ) {
+	struct settings *settings;
+	struct settings *parent;
+	int rc;
+
+	if ( dhcp->proxy_response ) {
+		settings = &dhcp->proxy_response->dhcppkt.settings;
+		if ( ( rc = register_settings ( settings, NULL ) ) != 0 )
+			return rc;
+	}
+
+	settings = &dhcp->response->dhcppkt.settings;
+	parent = netdev_settings ( dhcp->netdev );
+	if ( ( rc = register_settings ( settings, parent ) ) != 0 )
+		return rc;
+
+	return 0;
+}
+
 /****************************************************************************
  *
  * Data transfer interface
@@ -757,6 +509,7 @@ static int dhcp_send_request ( struct dhcp_session *dhcp ) {
 	struct xfer_metadata meta = {
 		.netdev = dhcp->netdev,
 	};
+	struct settings *offer_settings = NULL;
 	struct io_buffer *iobuf;
 	struct dhcp_packet dhcppkt;
 	int rc;
@@ -778,10 +531,11 @@ static int dhcp_send_request ( struct dhcp_session *dhcp ) {
 		return -ENOMEM;
 
 	/* Create DHCP packet in temporary buffer */
-	if ( ( rc = create_dhcp_request ( dhcp->netdev, dhcp->state,
-					  dhcp->options, iobuf->data,
-					  iob_tailroom ( iobuf ),
-					  &dhcppkt ) ) != 0 ) {
+	if ( dhcp->response )
+		offer_settings = &dhcp->response->dhcppkt.settings;
+	if ( ( rc = create_dhcp_request ( &dhcppkt, dhcp->netdev, dhcp->state,
+					  offer_settings, iobuf->data,
+					  iob_tailroom ( iobuf ) ) ) != 0 ) {
 		DBGC ( dhcp, "DHCP %p could not construct DHCP request: %s\n",
 		       dhcp, strerror ( rc ) );
 		goto done;
@@ -828,36 +582,41 @@ static void dhcp_timer_expired ( struct retry_timer *timer, int fail ) {
  * @v len		Length of received data
  * @ret rc		Return status code
  */
-static int dhcp_deliver_raw ( struct xfer_interface *xfer,
-			      const void *data, size_t len ) {
+static int dhcp_deliver_iob ( struct xfer_interface *xfer,
+			      struct io_buffer *iobuf,
+			      struct xfer_metadata *meta __unused ) {
 	struct dhcp_session *dhcp =
 		container_of ( xfer, struct dhcp_session, xfer );
-	const struct dhcphdr *dhcphdr = data;
-	struct dhcp_option_block *options;
-	struct dhcp_option_block **store_options;
+	struct dhcp_iobuf_packet *response;
+	struct dhcp_iobuf_packet **store_response;
+	struct dhcphdr *dhcphdr;
+	struct settings *settings;
 	unsigned int msgtype;
 	unsigned long elapsed;
 	int is_proxy;
 	int ignore_proxy;
+	int rc;
+
+	/* Convert packet into a DHCP-packet-in-iobuf */
+	response = dhcpiob_create ( iobuf );
+	if ( ! response ) {
+		DBGC ( dhcp, "DHCP %p could not store DHCP packet\n", dhcp );
+		return -ENOMEM;
+	}
+	dhcphdr = response->dhcppkt.dhcphdr;
+	settings = &response->dhcppkt.settings;
 
 	/* Check for matching transaction ID */
 	if ( dhcphdr->xid != dhcp_xid ( dhcp->netdev ) ) {
 		DBGC ( dhcp, "DHCP %p wrong transaction ID (wanted %08lx, "
 			"got %08lx)\n", dhcp, ntohl ( dhcphdr->xid ),
 			ntohl ( dhcp_xid ( dhcp->netdev ) ) );
-		return 0;
-	};
-
-	/* Parse packet and create options structure */
-	options = dhcp_parse ( dhcphdr, len );
-	if ( ! options ) {
-		DBGC ( dhcp, "DHCP %p could not parse DHCP packet\n", dhcp );
-		return -EINVAL;
-	}
+		goto out_discard;
+	};	
 
 	/* Determine and verify message type */
 	is_proxy = ( dhcphdr->yiaddr.s_addr == 0 );
-	msgtype = find_dhcp_num_option ( options, DHCP_MESSAGE_TYPE );
+	msgtype = fetch_uintz_setting ( settings, DHCP_MESSAGE_TYPE );
 	DBGC ( dhcp, "DHCP %p received %s%s\n", dhcp,
 	       ( is_proxy ? "Proxy" : "" ), dhcp_msgtype_name ( msgtype ) );
 	if ( ( ( dhcp->state != DHCPDISCOVER ) || ( msgtype != DHCPOFFER ) ) &&
@@ -872,25 +631,26 @@ static int dhcp_deliver_raw ( struct xfer_interface *xfer,
 	 * options have equal or higher priority than the
 	 * currently-stored options.
 	 */
-	store_options = ( is_proxy ? &dhcp->proxy_options : &dhcp->options );
-	if ( ( ! *store_options ) || 
-	     ( find_dhcp_num_option ( options, DHCP_EB_PRIORITY ) >=
-	       find_dhcp_num_option ( *store_options, DHCP_EB_PRIORITY ) ) ) {
-		dhcpopt_put ( *store_options );
-		*store_options = options;
+	store_response = ( is_proxy ? &dhcp->proxy_response : &dhcp->response);
+	if ( ( ! *store_response ) || 
+	     ( fetch_uintz_setting ( settings, DHCP_EB_PRIORITY ) >=
+	       fetch_uintz_setting ( &(*store_response)->dhcppkt.settings,
+				     DHCP_EB_PRIORITY ) ) ) {
+		dhcpiob_put ( *store_response );
+		*store_response = response;
 	} else {
-		dhcpopt_put ( options );
+		dhcpiob_put ( response );
 	}
 
 	/* If we don't yet have a standard DHCP response (i.e. one
 	 * with an IP address), then just leave the timer running.
 	 */
-	if ( ! dhcp->options )
+	if ( ! dhcp->response )
 		goto out;
 
 	/* Handle DHCP response */
-	ignore_proxy = find_dhcp_num_option ( dhcp->options,
-					      DHCP_EB_NO_PROXYDHCP );
+	ignore_proxy = fetch_uintz_setting ( &dhcp->response->dhcppkt.settings,
+					     DHCP_EB_NO_PROXYDHCP );
 	switch ( dhcp->state ) {
 	case DHCPDISCOVER:
 		/* If we have allowed sufficient time for ProxyDHCP
@@ -905,11 +665,14 @@ static int dhcp_deliver_raw ( struct xfer_interface *xfer,
 		break;
 	case DHCPREQUEST:
 		/* DHCP finished; register options and exit */
-		if ( dhcp->proxy_options && ( ! ignore_proxy ) ) {
-			dhcp->register_options ( dhcp->netdev,
-						 dhcp->proxy_options );
+		if ( ignore_proxy && dhcp->proxy_response ) {
+			dhcpiob_put ( dhcp->proxy_response );
+			dhcp->proxy_response = NULL;
+		}
+		if ( ( rc = dhcp_register_settings ( dhcp ) ) != 0 ) {
+			dhcp_finished ( dhcp, rc );
+			break;
 		}
-		dhcp->register_options ( dhcp->netdev, dhcp->options );
 		dhcp_finished ( dhcp, 0 );
 		break;
 	default:
@@ -920,7 +683,7 @@ static int dhcp_deliver_raw ( struct xfer_interface *xfer,
 	return 0;
 
  out_discard:
-	dhcpopt_put ( options );
+	dhcpiob_put ( response );
 	return 0;
 }
 
@@ -930,8 +693,8 @@ static struct xfer_interface_operations dhcp_xfer_operations = {
 	.vredirect	= xfer_vopen,
 	.window		= unlimited_xfer_window,
 	.alloc_iob	= default_xfer_alloc_iob,
-	.deliver_iob	= xfer_deliver_as_raw,
-	.deliver_raw	= dhcp_deliver_raw,
+	.deliver_iob	= dhcp_deliver_iob,
+	.deliver_raw	= xfer_deliver_as_iob,
 };
 
 /****************************************************************************
@@ -978,9 +741,7 @@ static struct job_interface_operations dhcp_job_operations = {
  * register_options() routine will be called with the acquired
  * options.
  */
-int start_dhcp ( struct job_interface *job, struct net_device *netdev,
-		 int ( * register_options ) ( struct net_device *netdev,
-					      struct dhcp_option_block * ) ) {
+int start_dhcp ( struct job_interface *job, struct net_device *netdev ) {
 	static struct sockaddr_in server = {
 		.sin_family = AF_INET,
 		.sin_addr.s_addr = INADDR_BROADCAST,
@@ -1001,7 +762,6 @@ int start_dhcp ( struct job_interface *job, struct net_device *netdev,
 	job_init ( &dhcp->job, &dhcp_job_operations, &dhcp->refcnt );
 	xfer_init ( &dhcp->xfer, &dhcp_xfer_operations, &dhcp->refcnt );
 	dhcp->netdev = netdev_get ( netdev );
-	dhcp->register_options = register_options;
 	dhcp->timer.expired = dhcp_timer_expired;
 	dhcp->state = DHCPDISCOVER;
 	dhcp->start = currticks();