[Settings] Migrate DHCP and NVO code to the new settings API (untested)
authorMichael Brown <mcb30@etherboot.org>
Fri, 21 Mar 2008 22:15:31 +0000 (22:15 +0000)
committerMichael Brown <mcb30@etherboot.org>
Fri, 21 Mar 2008 22:15:31 +0000 (22:15 +0000)
16 files changed:
src/arch/i386/image/nbi.c
src/core/nvo.c
src/core/settings.c
src/drivers/net/etherfabric.c
src/drivers/net/rtl8139.c
src/include/gpxe/dhcp.h
src/include/gpxe/dhcpopts.h [new file with mode: 0644]
src/include/gpxe/dhcppkt.h [new file with mode: 0644]
src/include/gpxe/errfile.h
src/include/gpxe/nvo.h
src/include/gpxe/settings.h
src/interface/pxe/pxe_preboot.c
src/net/dhcpopts.c
src/net/dhcppkt.c [new file with mode: 0644]
src/net/udp/dhcp.c
src/usr/dhcpmgmt.c

index 195cfbf..d167755 100644 (file)
@@ -9,6 +9,7 @@
 #include <gpxe/init.h>
 #include <gpxe/netdevice.h>
 #include <gpxe/dhcp.h>
+#include <gpxe/dhcppkt.h>
 #include <gpxe/image.h>
 #include <gpxe/features.h>
 
@@ -400,10 +401,9 @@ static int nbi_prepare_dhcp ( struct image *image ) {
                return -ENODEV;
        }
 
-       if ( ( rc = create_dhcp_response ( boot_netdev, DHCPACK, NULL,
-                                          basemem_packet,
-                                          sizeof ( basemem_packet ),
-                                          &dhcppkt ) ) != 0 ) {
+       if ( ( rc = create_dhcp_response ( &dhcppkt, boot_netdev, DHCPACK,
+                                          NULL, basemem_packet,
+                                          sizeof ( basemem_packet ) ) ) != 0){
                DBGC ( image, "NBI %p failed to build DHCP packet\n", image );
                return rc;
        }
index d3cb77e..951539f 100644 (file)
@@ -17,6 +17,7 @@
  */
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <gpxe/dhcp.h>
@@ -29,9 +30,6 @@
  *
  */
 
-/* FIXME: "Temporary hack" */
-struct nvo_block *ugly_nvo_hack = NULL;
-
 /**
  * Calculate checksum over non-volatile stored options
  *
@@ -39,7 +37,7 @@ struct nvo_block *ugly_nvo_hack = NULL;
  * @ret sum            Checksum
  */
 static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
-       uint8_t *data = nvo->options->data;
+       uint8_t *data = nvo->data;
        uint8_t sum = 0;
        unsigned int i;
 
@@ -56,22 +54,22 @@ static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
  * @ret rc             Return status code
  */
 static int nvo_load ( struct nvo_block *nvo ) {
-       void *data = nvo->options->data;
-       struct nvo_fragment *fragment;
+       void *data = nvo->data;
+       struct nvo_fragment *frag;
        int rc;
 
        /* Read data a fragment at a time */
-       for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
-               if ( ( rc = nvs_read ( nvo->nvs, fragment->address,
-                                      data, fragment->len ) ) != 0 ) {
-                       DBG ( "NVO %p could not read %zd bytes at %#04x\n",
-                             nvo, fragment->len, fragment->address );
+       for ( frag = nvo->fragments ; frag->len ; frag++ ) {
+               if ( ( rc = nvs_read ( nvo->nvs, frag->address, data,
+                                      frag->len ) ) != 0 ) {
+                       DBGC ( nvo, "NVO %p could not read %zd bytes at "
+                              "%#04x\n", nvo, frag->len, frag->address );
                        return rc;
                }
-               data += fragment->len;
+               data += frag->len;
        }
 
-       DBG ( "NVO %p loaded from non-volatile storage\n", nvo );
+       DBGC ( nvo, "NVO %p loaded from non-volatile storage\n", nvo );
        return 0;
 }
 
@@ -81,27 +79,27 @@ static int nvo_load ( struct nvo_block *nvo ) {
  * @v nvo              Non-volatile options block
  * @ret rc             Return status code
  */
-int nvo_save ( struct nvo_block *nvo ) {
-       void *data = nvo->options->data;
-       uint8_t *checksum = ( data + nvo->total_len - 1 );
-       struct nvo_fragment *fragment;
+static int nvo_save ( struct nvo_block *nvo ) {
+       void *data = nvo->data;
+       uint8_t *checksum = data;
+       struct nvo_fragment *frag;
        int rc;
 
        /* Recalculate checksum */
        *checksum -= nvo_checksum ( nvo );
 
        /* Write data a fragment at a time */
-       for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
-               if ( ( rc = nvs_write ( nvo->nvs, fragment->address,
-                                       data, fragment->len ) ) != 0 ) {
-                       DBG ( "NVO %p could not write %zd bytes at %#04x\n",
-                             nvo, fragment->len, fragment->address );
+       for ( frag = nvo->fragments ; frag->len ; frag++ ) {
+               if ( ( rc = nvs_write ( nvo->nvs, frag->address, data,
+                                       frag->len ) ) != 0 ) {
+                       DBGC ( nvo, "NVO %p could not write %zd bytes at "
+                              "%#04x\n", nvo, frag->len, frag->address );
                        return rc;
                }
-               data += fragment->len;
+               data += frag->len;
        }
 
-       DBG ( "NVO %p saved to non-volatile storage\n", nvo );
+       DBGC ( nvo, "NVO %p saved to non-volatile storage\n", nvo );
        return 0;
 }
 
@@ -114,88 +112,138 @@ int nvo_save ( struct nvo_block *nvo ) {
  * options block.  If the data is not valid, it is replaced with an
  * empty options block.
  */
-static void nvo_init_dhcp ( struct nvo_block *nvo ) {
-       struct dhcp_option_block *options = nvo->options;
-       struct dhcp_option *option;
+static void nvo_init_dhcpopts ( struct nvo_block *nvo ) {
+       uint8_t *options_data;
+       size_t options_len;
 
        /* Steal one byte for the checksum */
-       options->max_len = ( nvo->total_len - 1 );
+       options_data = ( nvo->data + 1 );
+       options_len = ( nvo->total_len - 1 );
 
-       /* Verify checksum over whole block */
-       if ( nvo_checksum ( nvo ) != 0 ) {
-               DBG ( "NVO %p has bad checksum %02x; assuming empty\n",
-                     nvo, nvo_checksum ( nvo ) );
-               goto empty;
+       /* If checksum fails, or options data starts with a zero,
+        * assume the whole block is invalid.  This should capture the
+        * case of random initial contents.
+        */
+       if ( ( nvo_checksum ( nvo ) != 0 ) || ( options_data[0] == 0 ) ) {
+               DBGC ( nvo, "NVO %p has checksum %02x and initial byte %02x; "
+                      "assuming empty\n", nvo, nvo_checksum ( nvo ),
+                      options_data[0] );
+               memset ( nvo->data, 0, nvo->total_len );
        }
 
-       /* Check that we don't just have a block full of zeroes */
-       option = options->data;
-       if ( option->tag == DHCP_PAD ) {
-               DBG ( "NVO %p has bad start; assuming empty\n", nvo );
-               goto empty;
-       }
-       
-       /* Search for the DHCP_END tag */
-       options->len = options->max_len;
-       option = find_dhcp_option ( options, DHCP_END );
-       if ( ! option ) {
-               DBG ( "NVO %p has no end tag; assuming empty\n", nvo );
-               goto empty;
+       dhcpopt_init ( &nvo->dhcpopts, options_data, options_len );
+}
+
+/**
+ * Store value of NVO 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 nvo_store ( struct settings *settings, unsigned int tag,
+                      const void *data, size_t len ) {
+       struct nvo_block *nvo =
+               container_of ( settings, struct nvo_block, settings );
+       int rc;
+
+       /* Update stored options */
+       if ( ( rc = dhcpopt_store ( &nvo->dhcpopts, tag, data, len ) ) != 0 ) {
+               DBGC ( nvo, "NVO %p could not store %zd bytes: %s\n",
+                      nvo, len, strerror ( rc ) );
+               return rc;
        }
 
-       /* Set correct length of DHCP options */
-       options->len = ( ( void * ) option - options->data + 1 );
-       DBG ( "NVO %p contains %zd bytes of options (maximum %zd)\n",
-             nvo, options->len, options->max_len );
-       return;
-
- empty:
-       /* No options found; initialise an empty options block */
-       option = options->data;
-       option->tag = DHCP_END;
-       options->len = 1;
-       return;
+       /* Save updated options to NVS */
+       if ( ( rc = nvo_save ( nvo ) ) != 0 )
+               return rc;
+
+       return 0;
+}
+
+/**
+ * Fetch value of NVO 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
+ *
+ * The actual length of the setting will be returned even if
+ * the buffer was too small.
+ */
+static int nvo_fetch ( struct settings *settings, unsigned int tag,
+                      void *data, size_t len ) {
+       struct nvo_block *nvo =
+               container_of ( settings, struct nvo_block, settings );
+
+       return dhcpopt_fetch ( &nvo->dhcpopts, tag, data, len );
+}
+
+/** NVO settings operations */
+static struct settings_operations nvo_settings_operations = {
+       .store = nvo_store,
+       .fetch = nvo_fetch,
+};
+
+/**
+ * Initialise non-volatile stored options
+ *
+ * @v nvo              Non-volatile options block
+ * @v nvs              Underlying non-volatile storage device
+ * @v fragments                List of option-containing fragments
+ * @v refcnt           Containing object reference counter, or NULL
+ */
+void nvo_init ( struct nvo_block *nvo, struct nvs_device *nvs,
+               struct nvo_fragment *fragments, struct refcnt *refcnt ) {
+       nvo->nvs = nvs;
+       nvo->fragments = fragments;
+       settings_init ( &nvo->settings, &nvo_settings_operations, refcnt,
+                       "nvo" );
 }
 
 /**
  * Register non-volatile stored options
  *
  * @v nvo              Non-volatile options block
+ * @v parent           Parent settings block, or NULL
  * @ret rc             Return status code
  */
-int nvo_register ( struct nvo_block *nvo ) {
+int register_nvo ( struct nvo_block *nvo, struct settings *parent ) {
        struct nvo_fragment *fragment = nvo->fragments;
        int rc;
 
        /* Calculate total length of all fragments */
-       nvo->total_len = 0;
-       for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
+       for ( fragment = nvo->fragments ; fragment->len ; fragment++ )
                nvo->total_len += fragment->len;
-       }
 
        /* Allocate memory for options and read in from NVS */
-       nvo->options = alloc_dhcp_options ( nvo->total_len );
-       if ( ! nvo->options ) {
-               DBG ( "NVO %p could not allocate %zd bytes\n",
-                     nvo, nvo->total_len );
+       nvo->data = malloc ( nvo->total_len );
+       if ( ! nvo->data ) {
+               DBGC ( nvo, "NVO %p could not allocate %zd bytes\n",
+                      nvo, nvo->total_len );
                rc = -ENOMEM;
-               goto err;
+               goto err_malloc;
        }
        if ( ( rc = nvo_load ( nvo ) ) != 0 )
-               goto err;
+               goto err_load;
 
        /* Verify and register options */
-       nvo_init_dhcp ( nvo );
-       register_dhcp_options ( nvo->options );
-
-       ugly_nvo_hack = nvo;
+       nvo_init_dhcpopts ( nvo );
+       if ( ( rc = register_settings ( &nvo->settings, parent ) ) != 0 )
+               goto err_register;
 
-       DBG ( "NVO %p registered\n", nvo );
+       DBGC ( nvo, "NVO %p registered\n", nvo );
        return 0;
        
- err:
-       dhcpopt_put ( nvo->options );
-       nvo->options = NULL;
+ err_register:
+ err_load:
+       free ( nvo->data );
+       nvo->data = NULL;
+ err_malloc:
        return rc;
 }
 
@@ -204,15 +252,9 @@ int nvo_register ( struct nvo_block *nvo ) {
  *
  * @v nvo              Non-volatile options block
  */
-void nvo_unregister ( struct nvo_block *nvo ) {
-
-       if ( nvo->options ) {
-               unregister_dhcp_options ( nvo->options );
-               dhcpopt_put ( nvo->options );
-               nvo->options = NULL;
-       }
-
-       DBG ( "NVO %p unregistered\n", nvo );
-
-       ugly_nvo_hack = NULL;
+void unregister_nvo ( struct nvo_block *nvo ) {
+       unregister_settings ( &nvo->settings );
+       free ( nvo->data );
+       nvo->data = NULL;
+       DBGC ( nvo, "NVO %p unregistered\n", nvo );
 }
index 3f961bc..cf0b898 100644 (file)
@@ -213,6 +213,7 @@ void unregister_settings ( struct settings *settings ) {
        /* Remove from list of settings */
        ref_put ( settings->refcnt );
        ref_put ( settings->parent->refcnt );
+       settings->parent = NULL;
        list_del ( &settings->siblings );
        DBGC ( settings, "Settings %p unregistered\n", settings );
 
@@ -280,8 +281,13 @@ struct settings * find_settings ( const char *name ) {
  */
 int store_setting ( struct settings *settings, unsigned int tag,
                    const void *data, size_t len ) {
+       struct settings *parent;
        int rc;
 
+       /* Sanity check */
+       if ( ! settings )
+               return -ENODEV;
+
        /* Store setting */
        if ( ( rc = settings->op->store ( settings, tag, data, len ) ) != 0 )
                return rc;
@@ -290,9 +296,16 @@ int store_setting ( struct settings *settings, unsigned int tag,
        if ( tag == DHCP_EB_PRIORITY )
                reprioritise_settings ( settings );
 
-       /* Apply potentially-updated setting */
-       if ( ( rc = apply_settings() ) != 0 )
-               return rc;
+       /* If these settings are registered, apply potentially-updated
+        * settings
+        */
+       for ( parent = settings->parent ; parent ; parent = parent->parent ) {
+               if ( parent == &settings_root ) {
+                       if ( ( rc = apply_settings() ) != 0 )
+                               return rc;
+                       break;
+               }
+       }
 
        return 0;
 }
@@ -468,6 +481,88 @@ unsigned long fetch_uintz_setting ( struct settings *settings,
        return value;
 }
 
+/**
+ * Copy setting
+ *
+ * @v dest             Destination settings block
+ * @v dest_tag         Destination setting tag number
+ * @v source           Source settings block
+ * @v source_tag       Source setting tag number
+ * @ret rc             Return status code
+ */
+int copy_setting ( struct settings *dest, unsigned int dest_tag,
+                  struct settings *source, unsigned int source_tag ) {
+       int len;
+       int check_len;
+       int rc;
+
+       len = fetch_setting_len ( source, source_tag );
+       if ( len < 0 )
+               return len;
+
+       {
+               char buf[len];
+
+               check_len = fetch_setting ( source, source_tag, buf,
+                                           sizeof ( buf ) );
+               assert ( check_len == len );
+
+               if ( ( rc = store_setting ( dest, dest_tag, buf,
+                                           sizeof ( buf ) ) ) != 0 )
+                       return rc;
+       }
+
+       return 0;
+}
+
+/**
+ * Copy settings
+ *
+ * @v dest             Destination settings block
+ * @v source           Source settings block
+ * @v encapsulator     Encapsulating setting tag number, or zero
+ * @ret rc             Return status code
+ */
+static int copy_encap_settings ( struct settings *dest,
+                                struct settings *source,
+                                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_encap_settings ( dest, source,
+                                                         tag ) ) != 0 )
+                               return rc;
+                       break;
+               default:
+                       /* Copy option to reassembled packet */
+                       if ( ( rc = copy_setting ( dest, tag, source,
+                                                  tag ) ) != 0 )
+                               return rc;
+                       break;
+               }
+       }
+
+       return 0;
+}
+
+/**
+ * Copy settings
+ *
+ * @v dest             Destination settings block
+ * @v source           Source settings block
+ * @ret rc             Return status code
+ */
+int copy_settings ( struct settings *dest, struct settings *source ) {
+       return copy_encap_settings ( dest, source, 0 );
+}
+
 /******************************************************************************
  *
  * Named and typed setting routines
index 90cc73f..8a6b1a1 100644 (file)
@@ -3008,9 +3008,9 @@ static int falcon_init_nic ( struct efab_nic *efab ) {
 
        /* Register non-volatile storage */
        if ( efab->has_eeprom ) {
-               efab->nvo.nvs = &efab->falcon_eeprom.nvs;
-               efab->nvo.fragments = falcon_eeprom_fragments;
-               if ( nvo_register ( &efab->nvo ) != 0 )
+               nvo_init ( &efab->nvo, &efab->falcon_eeprom.nvs,
+                          falcon_eeprom_fragments, NULL /* hack */ );
+               if ( register_nvo ( &efab->nvo, NULL /* hack */ ) != 0 )
                        return 0;
        }
 
index 83fac55..c432884 100644 (file)
@@ -261,9 +261,10 @@ static struct nvo_fragment rtl_nvo_fragments[] = {
 /**
  * Set up for EEPROM access
  *
- * @v rtl              RTL8139 NIC
+ * @v netdev           Net device
  */
-static void rtl_init_eeprom ( struct rtl8139_nic *rtl ) {
+static void rtl_init_eeprom ( struct net_device *netdev ) {
+       struct rtl8139_nic *rtl = netdev->priv;
        int ee9356;
        int vpd;
 
@@ -288,19 +289,20 @@ static void rtl_init_eeprom ( struct rtl8139_nic *rtl ) {
        if ( vpd ) {
                DBG ( "EEPROM in use for VPD; cannot use for options\n" );
        } else {
-               rtl->nvo.nvs = &rtl->eeprom.nvs;
-               rtl->nvo.fragments = rtl_nvo_fragments;
+               nvo_init ( &rtl->nvo, &rtl->eeprom.nvs, rtl_nvo_fragments,
+                          &netdev->refcnt );
        }
 }
 
 /**
  * Reset NIC
  *
- * @v rtl              RTL8139 NIC
+ * @v netdev           Net device
  *
  * Issues a hardware reset and waits for the reset to complete.
  */
-static void rtl_reset ( struct rtl8139_nic *rtl ) {
+static void rtl_reset ( struct net_device *netdev ) {
+       struct rtl8139_nic *rtl = netdev->priv;
 
        /* Reset chip */
        outb ( CmdReset, rtl->ioaddr + ChipCmd );
@@ -352,7 +354,7 @@ static void rtl_close ( struct net_device *netdev ) {
        struct rtl8139_nic *rtl = netdev->priv;
 
        /* Reset the hardware to disable everything in one go */
-       rtl_reset ( rtl );
+       rtl_reset ( netdev );
 
        /* Free RX ring */
        free ( rtl->rx.ring );
@@ -366,7 +368,8 @@ static void rtl_close ( struct net_device *netdev ) {
  * @v iobuf    I/O buffer
  * @ret rc     Return status code
  */
-static int rtl_transmit ( struct net_device *netdev, struct io_buffer *iobuf ) {
+static int rtl_transmit ( struct net_device *netdev,
+                         struct io_buffer *iobuf ) {
        struct rtl8139_nic *rtl = netdev->priv;
 
        /* Check for space in TX ring */
@@ -512,8 +515,8 @@ static int rtl_probe ( struct pci_device *pci,
        adjust_pci_device ( pci );
 
        /* Reset the NIC, set up EEPROM access and read MAC address */
-       rtl_reset ( rtl );
-       rtl_init_eeprom ( rtl );
+       rtl_reset ( netdev );
+       rtl_init_eeprom ( netdev );
        nvs_read ( &rtl->eeprom.nvs, EE_MAC, netdev->ll_addr, ETH_ALEN );
        
        /* Register network device */
@@ -522,7 +525,8 @@ static int rtl_probe ( struct pci_device *pci,
 
        /* Register non-volatile storage */
        if ( rtl->nvo.nvs ) {
-               if ( ( rc = nvo_register ( &rtl->nvo ) ) != 0 )
+               if ( ( rc = register_nvo ( &rtl->nvo,
+                                          netdev_settings ( netdev ) ) ) != 0)
                        goto err_register_nvo;
        }
 
@@ -531,7 +535,7 @@ static int rtl_probe ( struct pci_device *pci,
  err_register_nvo:
        unregister_netdev ( netdev );
  err_register_netdev:
-       rtl_reset ( rtl );
+       rtl_reset ( netdev );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
        return rc;
@@ -547,9 +551,9 @@ static void rtl_remove ( struct pci_device *pci ) {
        struct rtl8139_nic *rtl = netdev->priv;
 
        if ( rtl->nvo.nvs )
-               nvo_unregister ( &rtl->nvo );
+               unregister_nvo ( &rtl->nvo );
        unregister_netdev ( netdev );
-       rtl_reset ( rtl );
+       rtl_reset ( netdev );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 }
index fe9c3e3..c00f9f0 100644 (file)
@@ -8,13 +8,15 @@
  */
 
 #include <stdint.h>
-#include <gpxe/list.h>
 #include <gpxe/in.h>
+#include <gpxe/list.h>
 #include <gpxe/refcnt.h>
 #include <gpxe/tables.h>
 
 struct net_device;
 struct job_interface;
+struct dhcp_packet;
+struct settings;
 
 /** BOOTP/DHCP server port */
 #define BOOTPS_PORT 67
@@ -294,7 +296,7 @@ struct job_interface;
 
 /** Construct a word-valued DHCP option */
 #define DHCP_WORD( value ) DHCP_OPTION ( ( ( (value) >> 8 ) & 0xff ),   \
-                                        ( ( (value) >> 0  ) & 0xff ) )
+                                        ( ( (value) >> 0 ) & 0xff ) )
 
 /** Construct a dword-valued DHCP option */
 #define DHCP_DWORD( value ) DHCP_OPTION ( ( ( (value) >> 24 ) & 0xff ), \
@@ -327,21 +329,8 @@ struct dhcp_option {
         * byte in length.
         */
        uint8_t len;
-       /** Option data
-        *
-        * Interpretation of the content is entirely dependent upon
-        * the tag.  For fields containing a multi-byte integer, the
-        * field is defined to be in network-endian order (unless you
-        * are Intel and feel like violating the spec for fun).
-        */
-       union {
-               uint8_t byte;
-               uint16_t word;
-               uint32_t dword;
-               struct in_addr in;
-               uint8_t bytes[0];
-               char string[0];
-       } data;
+       /** Option data */
+       uint8_t data[0];
 } __attribute__ (( packed ));
 
 /**
@@ -355,27 +344,6 @@ struct dhcp_option {
 /** Maximum length for a single DHCP option */
 #define DHCP_MAX_LEN 0xff
 
-/** A DHCP options block */
-struct dhcp_option_block {
-       /** Reference counter */
-       struct refcnt refcnt;
-       /** List of option blocks */
-       struct list_head list;
-       /** Option block raw data */
-       void *data;
-       /** Option block length */
-       size_t len;
-       /** Option block maximum length */
-       size_t max_len;
-       /** Block priority
-        *
-        * This is determined at the time of the call to
-        * register_options() by searching for the @c DHCP_EB_PRIORITY
-        * option.
-        */
-       signed int priority;
-};
-
 /**
  * A DHCP header
  *
@@ -448,7 +416,7 @@ struct dhcphdr {
         * length (for the sake of sanity) is 1, to allow for a single
         * @c DHCP_END tag.
         */
-       uint8_t options[1];
+       uint8_t options[0];
 };
 
 /** Opcode for a request from client to server */
@@ -474,74 +442,17 @@ struct dhcphdr {
  */
 #define DHCP_MIN_LEN 552
 
-/**
- * A DHCP packet
- *
- */
-struct dhcp_packet {
-       /** The DHCP packet contents */
-       struct dhcphdr *dhcphdr;
-       /** Maximum length of the DHCP packet buffer */
-       size_t max_len;
-       /** Used length of the DHCP packet buffer */
-       size_t len;
-       /** DHCP options */
-       struct dhcp_option_block options;
-};
-
-/**
- * Get reference to DHCP options block
- *
- * @v options          DHCP options block
- * @ret options                DHCP options block
- */
-static inline __attribute__ (( always_inline )) struct dhcp_option_block *
-dhcpopt_get ( struct dhcp_option_block *options ) {
-       ref_get ( &options->refcnt );
-       return options;
-}
-
-/**
- * Drop reference to DHCP options block
- *
- * @v options          DHCP options block, or NULL
- */
-static inline __attribute__ (( always_inline )) void
-dhcpopt_put ( struct dhcp_option_block *options ) {
-       ref_put ( &options->refcnt );
-}
-
 /** Maximum time that we will wait for ProxyDHCP offers */
 #define PROXYDHCP_WAIT_TIME ( TICKS_PER_SEC * 1 )
 
-extern struct list_head dhcp_option_blocks;
-
-extern unsigned long dhcp_num_option ( struct dhcp_option *option );
-extern struct dhcp_option *
-find_dhcp_option ( struct dhcp_option_block *options, unsigned int tag );
-extern void register_dhcp_options ( struct dhcp_option_block *options );
-extern void unregister_dhcp_options ( struct dhcp_option_block *options );
-extern void init_dhcp_options ( struct dhcp_option_block *options,
-                               void *data, size_t max_len );
-extern struct dhcp_option_block * __malloc alloc_dhcp_options ( size_t max_len );
-extern struct dhcp_option *
-set_dhcp_option ( struct dhcp_option_block *options, unsigned int tag,
-                 const void *data, size_t len );
-extern unsigned long find_dhcp_num_option ( struct dhcp_option_block *options,
-                                           unsigned int tag );
-extern void delete_dhcp_option ( struct dhcp_option_block *options,
-                                unsigned int tag );
-
-extern 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 );
-extern 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 );
-
-extern int start_dhcp ( struct job_interface *job, struct net_device *netdev,
-                       int (*register_options) ( struct net_device *,
-                                                 struct dhcp_option_block * ));
+extern int create_dhcp_request ( struct dhcp_packet *dhcppkt,
+                                struct net_device *netdev, int msgtype,
+                                struct settings *offer_settings,
+                                void *data, size_t max_len );
+extern int create_dhcp_response ( struct dhcp_packet *dhcppkt,
+                                 struct net_device *netdev, int msgtype,
+                                 struct settings *settings,
+                                 void *data, size_t max_len );
+extern int start_dhcp ( struct job_interface *job, struct net_device *netdev );
+
 #endif /* _GPXE_DHCP_H */
diff --git a/src/include/gpxe/dhcpopts.h b/src/include/gpxe/dhcpopts.h
new file mode 100644 (file)
index 0000000..b16c5f2
--- /dev/null
@@ -0,0 +1,32 @@
+#ifndef _GPXE_DHCPOPTS_H
+#define _GPXE_DHCPOPTS_H
+
+/** @file
+ *
+ * DHCP options
+ *
+ */
+
+#include <gpxe/dhcp.h>
+
+/** A DHCP options block */
+struct dhcp_options {
+       /** Option block raw data */
+       void *data;
+       /** Option block length */
+       size_t len;
+       /** Option block maximum length */
+       size_t max_len;
+};
+
+extern int dhcpopt_store ( struct dhcp_options *options, unsigned int tag,
+                          const void *data, size_t len );
+extern int dhcpopt_extensible_store ( struct dhcp_options *options,
+                                     unsigned int tag,
+                                     const void *data, size_t len );
+extern int dhcpopt_fetch ( struct dhcp_options *options, unsigned int tag,
+                          void *data, size_t len );
+extern void dhcpopt_init ( struct dhcp_options *options,
+                          void *data, size_t max_len );
+
+#endif /* _GPXE_DHCPOPTS_H */
diff --git a/src/include/gpxe/dhcppkt.h b/src/include/gpxe/dhcppkt.h
new file mode 100644 (file)
index 0000000..98b8dad
--- /dev/null
@@ -0,0 +1,34 @@
+#ifndef _GPXE_DHCPPKT_H
+#define _GPXE_DHCPPKT_H
+
+/** @file
+ *
+ * DHCP packets
+ *
+ */
+
+#include <gpxe/dhcp.h>
+#include <gpxe/dhcpopts.h>
+#include <gpxe/settings.h>
+
+/**
+ * A DHCP packet
+ *
+ */
+struct dhcp_packet {
+       /** Settings block */
+       struct settings settings;
+       /** The DHCP packet contents */
+       struct dhcphdr *dhcphdr;
+       /** Maximum length of the DHCP packet buffer */
+       size_t max_len;
+       /** Used length of the DHCP packet buffer */
+       size_t len;
+       /** DHCP option blocks */
+       struct dhcp_options options;
+};
+
+extern void dhcppkt_init ( struct dhcp_packet *dhcppkt, struct refcnt *refcnt,
+                          void *data, size_t len );
+
+#endif /* _GPXE_DHCPPKT_H */
index 0b3b6c4..ae8b148 100644 (file)
 #define ERRFILE_tftp                   ( ERRFILE_NET | 0x00120000 )
 #define ERRFILE_infiniband             ( ERRFILE_NET | 0x00130000 )
 #define ERRFILE_netdev_settings                ( ERRFILE_NET | 0x00140000 )
+#define ERRFILE_dhcppkt                        ( ERRFILE_NET | 0x00150000 )
 
 #define ERRFILE_image                ( ERRFILE_IMAGE | 0x00000000 )
 #define ERRFILE_elf                  ( ERRFILE_IMAGE | 0x00010000 )
index 90d4ff9..28068f4 100644 (file)
@@ -8,9 +8,11 @@
  */
 
 #include <stdint.h>
+#include <gpxe/dhcpopts.h>
+#include <gpxe/settings.h>
 
 struct nvs_device;
-struct dhcp_option_block;
+struct refcnt;
 
 /**
  * A fragment of a non-volatile storage device used for stored options
@@ -26,6 +28,8 @@ struct nvo_fragment {
  * A block of non-volatile stored options
  */
 struct nvo_block {
+       /** Settings block */
+       struct settings settings;
        /** Underlying non-volatile storage device */
        struct nvs_device *nvs;
        /** List of option-containing fragments
@@ -33,17 +37,17 @@ struct nvo_block {
         * The list is terminated by a fragment with a length of zero.
         */
        struct nvo_fragment *fragments;
-       /** Total length of all fragments
-        *
-        * This field is filled in by nvo_register().
-        */
+       /** Total length of option-containing fragments */
        size_t total_len;
+       /** Option-containing data */
+       void *data;
        /** DHCP options block */
-       struct dhcp_option_block *options;
+       struct dhcp_options dhcpopts;
 };
 
-extern int nvo_register ( struct nvo_block *nvo );
-extern int nvo_save ( struct nvo_block *nvo );
-extern void nvo_unregister ( struct nvo_block *nvo );
+extern void nvo_init ( struct nvo_block *nvo, struct nvs_device *nvs,
+                      struct nvo_fragment *fragments, struct refcnt *refcnt );
+extern int register_nvo ( struct nvo_block *nvo, struct settings *parent );
+extern void unregister_nvo ( struct nvo_block *nvo );
 
 #endif /* _GPXE_NVO_H */
index b79ce50..f20c412 100644 (file)
@@ -151,6 +151,9 @@ extern int store_setting ( struct settings *settings, unsigned int tag,
                           const void *data, size_t len );
 extern int fetch_setting ( struct settings *settings, unsigned int tag,
                           void *data, size_t len );
+extern int copy_setting ( struct settings *dest, unsigned int dest_tag,
+                         struct settings *source, unsigned int source_tag );
+extern int copy_settings ( struct settings *dest, struct settings *source );
 extern int fetch_setting_len ( struct settings *settings, unsigned int tag );
 extern int fetch_string_setting ( struct settings *settings, unsigned int tag,
                                  char *data, size_t len );
@@ -163,6 +166,8 @@ extern int fetch_uint_setting ( struct settings *settings, unsigned int tag,
 extern long fetch_intz_setting ( struct settings *settings, unsigned int tag );
 extern unsigned long fetch_uintz_setting ( struct settings *settings,
                                           unsigned int tag );
+extern struct settings * find_child_settings ( struct settings *parent,
+                                              const char *name );
 extern struct settings * find_settings ( const char *name );
 extern int store_typed_setting ( struct settings *settings,
                                 unsigned int tag, struct setting_type *type,
index 2d6f135..ae59722 100644 (file)
@@ -28,6 +28,7 @@
 #include <stdlib.h>
 #include <gpxe/uaccess.h>
 #include <gpxe/dhcp.h>
+#include <gpxe/dhcppkt.h>
 #include <gpxe/device.h>
 #include <gpxe/netdevice.h>
 #include <gpxe/isapnp.h>
@@ -117,9 +118,10 @@ PXENV_EXIT_t pxenv_unload_stack ( struct s_PXENV_UNLOAD_STACK *unload_stack ) {
 PXENV_EXIT_t pxenv_get_cached_info ( struct s_PXENV_GET_CACHED_INFO
                                     *get_cached_info ) {
        struct dhcp_packet dhcppkt;
-       int ( * dhcp_packet_creator ) ( struct net_device *, int,
-                                       struct dhcp_option_block *, void *,
-                                       size_t, struct dhcp_packet * );
+       int ( * dhcp_packet_creator ) ( struct dhcp_packet *dhcppkt,
+                                       struct net_device *netdev, int msgtype,
+                                       struct settings *settings,
+                                       void *data, size_t max_len );
        unsigned int idx;
        unsigned int msgtype;
        size_t len;
@@ -149,10 +151,9 @@ PXENV_EXIT_t pxenv_get_cached_info ( struct s_PXENV_GET_CACHED_INFO
                        dhcp_packet_creator = create_dhcp_response;
                        msgtype = DHCPACK;
                }
-               if ( ( rc = dhcp_packet_creator ( pxe_netdev, msgtype,
-                                                 NULL, &cached_info[idx],
-                                                 sizeof ( cached_info[idx] ),
-                                                 &dhcppkt ) ) != 0 ) {
+               if ( ( rc = dhcp_packet_creator ( &dhcppkt, pxe_netdev,
+                                      msgtype, NULL, &cached_info[idx],
+                                      sizeof ( cached_info[idx] ) ) ) != 0 ) {
                        DBG ( " failed to build packet" );
                        goto err;
                }
index 8788d13..6d961f4 100644 (file)
@@ -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
 #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 (file)
index 0000000..0a11520
--- /dev/null
@@ -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" );
+}
index 1beabb9..624532d 100644 (file)
 #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,34 +319,86 @@ 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();
index 39fe920..d638bd4 100644 (file)
  *
  */
 
-static int dhcp_success ( struct net_device *netdev __unused,
-                         struct dhcp_option_block *options ) {
-       DBGC ( options, "DHCP client registering options %p\n", options );
-       register_dhcp_options ( options );
-       return 0;
-}
-
 int dhcp ( struct net_device *netdev ) {
-       struct dhcp_option_block *options;
-       struct dhcp_option_block *tmp;
+       struct settings *settings;
        int rc;
 
        /* Check we can open the interface first */
@@ -49,18 +41,13 @@ int dhcp ( struct net_device *netdev ) {
                return rc;
 
        /* Unregister any option blocks acquired via DHCP */
-       list_for_each_entry_safe ( options, tmp, &dhcp_option_blocks, list ) {
-               /* Skip static option blocks (e.g. from NVS) */
-               if ( find_dhcp_option ( options, DHCP_MESSAGE_TYPE ) ) {
-                       DBGC ( options, "DHCP client unregistering options "
-                              "%p\n", options );
-                       unregister_dhcp_options ( options );
-               }
-       }
+       settings = find_child_settings ( netdev_settings ( netdev ), "dhcp" );
+       if ( settings )
+               unregister_settings ( settings );
 
        /* Perform DHCP */
        printf ( "DHCP (%s %s)", netdev->name, netdev_hwaddr ( netdev ) );
-       if ( ( rc = start_dhcp ( &monojob, netdev, dhcp_success ) ) == 0 )
+       if ( ( rc = start_dhcp ( &monojob, netdev ) ) == 0 )
                rc = monojob_wait ( "" );
 
        return rc;