[DHCP] FIXME: quick temporary settings fix, needs update for new API
[people/andreif/gpxe.git] / src / net / udp / dhcp.c
index 59dc807..2c1e76d 100644 (file)
  */
 
 #include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
 #include <errno.h>
 #include <assert.h>
 #include <byteswap.h>
 #include <gpxe/if_ether.h>
 #include <gpxe/netdevice.h>
-#include <gpxe/udp.h>
+#include <gpxe/device.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
+#include <gpxe/job.h>
+#include <gpxe/retry.h>
+#include <gpxe/tcpip.h>
+#include <gpxe/ip.h>
+#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
  *
@@ -31,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
@@ -52,16 +67,31 @@ static const uint8_t dhcp_op[] = {
 static uint8_t dhcp_request_options_data[] = {
        DHCP_MAX_MESSAGE_SIZE, DHCP_WORD ( ETH_MAX_MTU ),
        DHCP_VENDOR_CLASS_ID,
-       DHCP_STRING (  'E', 't', 'h', 'e', 'r', 'b', 'o', 'o', 't' ),
+       DHCP_STRING (  'P', 'X', 'E', 'C', 'l', 'i', 'e', 'n', 't', ':',
+                      'A', 'r', 'c', 'h', ':', '0', '0', '0', '0', '0', ':',
+                      'U', 'N', 'D', 'I', ':', '0', '0', '2', '0', '0', '1' ),
+       DHCP_CLIENT_ARCHITECTURE, DHCP_WORD ( 0 ),
+       DHCP_CLIENT_NDI, DHCP_OPTION ( 1 /* UNDI */ , 2, 1 /* v2.1 */ ),
        DHCP_PARAMETER_REQUEST_LIST,
        DHCP_OPTION ( DHCP_SUBNET_MASK, DHCP_ROUTERS, DHCP_DNS_SERVERS,
-                     DHCP_HOST_NAME, DHCP_DOMAIN_NAME, DHCP_ROOT_PATH,
-                     DHCP_VENDOR_ENCAP, DHCP_TFTP_SERVER_NAME,
-                     DHCP_BOOTFILE_NAME, DHCP_EB_ENCAP,
-                     DHCP_ISCSI_INITIATOR_IQN ),
+                     DHCP_LOG_SERVERS, DHCP_HOST_NAME, DHCP_DOMAIN_NAME,
+                     DHCP_ROOT_PATH, DHCP_VENDOR_ENCAP, DHCP_VENDOR_CLASS_ID,
+                     DHCP_TFTP_SERVER_NAME, DHCP_BOOTFILE_NAME,
+                     DHCP_EB_ENCAP, DHCP_ISCSI_INITIATOR_IQN ),
        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 );
+
 /**
  * Name a DHCP packet type
  *
@@ -100,395 +130,327 @@ static uint32_t dhcp_xid ( struct net_device *netdev ) {
        return xid;
 }
 
-/** Options common to all DHCP requests */
-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
+ * Create a 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
+ * @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
  * @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.
+ * 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 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_MESSAGE_TYPE:
-       case DHCP_REQUESTED_ADDRESS:
-       case DHCP_PARAMETER_REQUEST_LIST:
-               /* These options have to be within the main options
-                * block.  This doesn't seem to be required by the
-                * RFCs, but at least ISC dhcpd refuses to recognise
-                * them otherwise.
-                */
-               options = &dhcppkt->options[OPTS_MAIN];
-               break;
-       default:
-               /* Continue processing as normal */
-               break;
-       }
-               
-       /* Set option in first available options block */
-       for ( ; options < &dhcppkt->options[NUM_OPT_BLOCKS] ; options++ ) {
-               option = set_dhcp_option ( options, tag, data, len );
-               if ( option )
-                       break;
+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 */
+       options_len = ( options ? options->len : 0 );
+       if ( max_len < ( sizeof ( *dhcphdr ) + options_len ) )
+               return -ENOSPC;
+
+       /* Initialise DHCP packet content */
+
+        /* FIXME: wrong place to fix this. */
+        memset ( dhcppkt, 0, sizeof ( *dhcppkt ) );
+
+       memset ( dhcphdr, 0, max_len );
+       dhcphdr->xid = dhcp_xid ( netdev );
+       dhcphdr->magic = htonl ( DHCP_MAGIC_COOKIE );
+       dhcphdr->htype = ntohs ( netdev->ll_protocol->ll_proto );
+       dhcphdr->op = dhcp_op[msgtype];
+       /* If hardware length exceeds the chaddr field length, don't
+        * use the chaddr field.  This is as per RFC4390.
+        */
+       hlen = netdev->ll_protocol->ll_addr_len;
+       if ( hlen > sizeof ( dhcphdr->chaddr ) ) {
+               hlen = 0;
+               dhcphdr->flags = htons ( BOOTP_FL_BROADCAST );
        }
+       dhcphdr->hlen = hlen;
+       memcpy ( dhcphdr->chaddr, netdev->ll_addr, hlen );
+       memcpy ( dhcphdr->options, options->data, options_len );
 
-       /* Update DHCP packet length */
-       dhcppkt->len = ( offsetof ( typeof ( *dhcppkt->dhcphdr ), options )
-                        + dhcppkt->options[OPTS_MAIN].len );
+       /* Initialise DHCP packet structure and settings interface */
+       dhcppkt_init ( dhcppkt, NULL, data, max_len );
+       
+       /* Set DHCP_MESSAGE_TYPE option */
+       if ( ( rc = store_setting ( &dhcppkt->settings, DHCP_MESSAGE_TYPE,
+                                   &msgtype, sizeof ( msgtype ) ) ) != 0 )
+               return rc;
 
-       return ( option ? 0 : -ENOSPC );
+       return 0;
 }
 
+/** DHCP network device descriptor */
+struct dhcp_netdev_desc {
+       /** Bus type ID */
+       uint8_t type;
+       /** Vendor ID */
+       uint16_t vendor;
+       /** Device ID */
+       uint16_t device;
+} __attribute__ (( packed ));
+
+/** DHCP client identifier */
+struct dhcp_client_id {
+       /** Link-layer protocol */
+       uint8_t ll_proto;
+       /** Link-layer address */
+       uint8_t ll_addr[MAX_LL_ADDR_LEN];
+} __attribute__ (( packed ));
+
+/** DHCP client UUID */
+struct dhcp_client_uuid {
+       /** Identifier type */
+       uint8_t type;
+       /** UUID */
+       union uuid uuid;
+} __attribute__ (( packed ));
+
+#define DHCP_CLIENT_UUID_TYPE 0
+
 /**
- * Copy option into DHCP packet
+ * Create DHCP request
  *
- * @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
+ * @v dhcppkt          DHCP packet structure to fill in
+ * @v netdev           Network device
+ * @v msgtype          DHCP message type
+ * @v offer_settings   Settings received in DHCPOFFER, or NULL
+ * @v data             Buffer for DHCP packet
+ * @v max_len          Size of DHCP packet buffer
  * @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 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;
+       struct dhcp_client_uuid client_uuid;
+       size_t dhcp_features_len;
+       size_t ll_addr_len;
        int rc;
 
-       option = find_dhcp_option ( options, tag );
-       if ( option ) {
-               if ( ( rc = set_dhcp_packet_option ( dhcppkt, new_tag,
-                                                    &option->data,
-                                                    option->len ) ) != 0 )
+       /* Create DHCP packet */
+       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 any required options from previous server repsonse */
+       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_setting ( &dhcppkt->settings,
+                                          DHCP_REQUESTED_ADDRESS,
+                                          offer_settings,
+                                          DHCP_EB_YIADDR ) ) != 0 ) {
+                       DBG ( "DHCP could not set requested address "
+                             "option: %s\n", strerror ( rc ) );
                        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;
+       /* Add options to identify the feature list */
+       dhcp_features_len = ( dhcp_features_end - dhcp_features );
+       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;
+       }
 
-       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;
-               };
+       /* Add options to identify the network device */
+       dhcp_desc.type = desc->bus_type;
+       dhcp_desc.vendor = htons ( desc->vendor );
+       dhcp_desc.device = htons ( desc->device );
+       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;
        }
 
-       return 0;
-}
+       /* Add DHCP client identifier.  Required for Infiniband, and
+        * doesn't hurt other link layers.
+        */
+       client_id.ll_proto = ntohs ( netdev->ll_protocol->ll_proto );
+       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 = 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;
+       }
 
-/**
- * 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.
- */
-int copy_dhcp_packet_options ( struct dhcp_packet *dhcppkt,
-                              struct dhcp_option_block *options ) {
-       return copy_dhcp_packet_encap_options ( dhcppkt, options, 0 );
+       /* 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 = 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;
+               }
+       }
+
+       return 0;
 }
 
 /**
- * Create a DHCP packet
+ * Create DHCP response
  *
+ * @v dhcppkt          DHCP packet structure to fill in
  * @v netdev           Network device
  * @v msgtype          DHCP message type
+ * @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
- *
- * 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().
  */
-int create_dhcp_packet ( struct net_device *netdev, uint8_t msgtype,
-                        void *data, size_t max_len,
-                        struct dhcp_packet *dhcppkt ) {
-       struct dhcphdr *dhcphdr = data;
-       static const uint8_t overloading = ( DHCP_OPTION_OVERLOAD_FILE |
-                                            DHCP_OPTION_OVERLOAD_SNAME );
+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;
 
-       /* Sanity check */
-       if ( max_len < sizeof ( *dhcphdr ) )
-               return -ENOSPC;
-
-       /* Initialise DHCP packet content */
-       memset ( dhcphdr, 0, max_len );
-       dhcphdr->xid = dhcp_xid ( netdev );
-       dhcphdr->magic = htonl ( DHCP_MAGIC_COOKIE );
-       dhcphdr->htype = ntohs ( netdev->ll_protocol->ll_proto );
-       dhcphdr->hlen = netdev->ll_protocol->ll_addr_len;
-       memcpy ( dhcphdr->chaddr, netdev->ll_addr, dhcphdr->hlen );
-       dhcphdr->op = dhcp_op[msgtype];
-
-       /* Initialise DHCP packet structure */
-       dhcppkt->dhcphdr = dhcphdr;
-       dhcppkt->max_len = max_len;
-       init_dhcp_options ( &dhcppkt->options[OPTS_MAIN], dhcphdr->options,
-                           ( max_len -
-                             offsetof ( typeof ( *dhcphdr ), options ) ) );
-       init_dhcp_options ( &dhcppkt->options[OPTS_FILE], dhcphdr->file,
-                           sizeof ( dhcphdr->file ) );
-       init_dhcp_options ( &dhcppkt->options[OPTS_SNAME], dhcphdr->sname,
-                           sizeof ( dhcphdr->sname ) );
-       
-       /* Set DHCP_OPTION_OVERLOAD option within the main options block */
-       if ( set_dhcp_option ( &dhcppkt->options[OPTS_MAIN],
-                              DHCP_OPTION_OVERLOAD, &overloading,
-                              sizeof ( overloading ) ) == NULL )
-               return -ENOSPC;
-
-       /* Set DHCP_MESSAGE_TYPE option */
-       if ( ( rc = set_dhcp_packet_option ( dhcppkt, DHCP_MESSAGE_TYPE,
-                                            &msgtype,
-                                            sizeof ( msgtype ) ) ) != 0 )
+       /* Create packet and copy in options */
+       if ( ( rc = create_dhcp_packet ( dhcppkt, netdev, msgtype, NULL,
+                                        data, max_len ) ) != 0 )
+               return rc;
+       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;
+};
+
 /**
- * Calculate used length of a field containing DHCP options
+ * Free DHCP packet contained in an I/O buffer
  *
- * @v data             Field containing DHCP options
- * @v max_len          Field length
- * @ret len            Used length (excluding the @c DHCP_END tag)
+ * @v refcnt           Reference counter
  */
-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 );
+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 );
 }
 
 /**
- * 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
+ * Create DHCP packet from I/O buffer
  *
- * If @c tag is non-zero, 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.
+ * @v iobuf            I/O buffer
+ * @ret dhcpiob                DHCP packet contained in I/O buffer
  *
- * The caller must ensure that there is enough space in the options
- * block to perform the merge.
+ * This function takes ownership of the I/O buffer.  Future accesses
+ * must be via the @c dhcpiob data structure.
  */
-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 ) {
-               set_dhcp_option ( options, tag, data, strlen ( data ) );
-       } 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;
+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;
 }
 
-/**
- * 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 void dhcpiob_put ( struct dhcp_iobuf_packet *dhcpiob ) {
+       if ( dhcpiob )
+               ref_put ( &dhcpiob->refcnt );
+}
+
+/****************************************************************************
+ *
+ * DHCP to UDP interface
+ *
  */
-static struct dhcp_option_block * dhcp_parse ( 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;
+/** A DHCP session */
+struct dhcp_session {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Job control interface */
+       struct job_interface job;
+       /** Data transfer interface */
+       struct xfer_interface xfer;
 
-       /* 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
+       /** Network device being configured */
+       struct net_device *netdev;
+
+       /** State of the session
         *
-        *   1 byte for a final terminating DHCP_END tag.
+        * This is a value for the @c DHCP_MESSAGE_TYPE option
+        * (e.g. @c DHCPDISCOVER).
         */
-       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 %d-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;
-}
+       int state;
+       /** 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) */
+       unsigned long start;
+};
 
-/****************************************************************************
- *
- * DHCP to UDP interface
+/**
+ * Free DHCP session
  *
+ * @v refcnt           Reference counter
  */
+static void dhcp_free ( struct refcnt *refcnt ) {
+       struct dhcp_session *dhcp =
+               container_of ( refcnt, struct dhcp_session, refcnt );
 
-static inline struct dhcp_session *
-udp_to_dhcp ( struct udp_connection *conn ) {
-       return container_of ( conn, struct dhcp_session, udp );
+       netdev_put ( dhcp->netdev );
+       dhcpiob_put ( dhcp->response );
+       dhcpiob_put ( dhcp->proxy_response );
+       free ( dhcp );
 }
 
 /**
@@ -497,108 +459,106 @@ udp_to_dhcp ( struct udp_connection *conn ) {
  * @v dhcp             DHCP session
  * @v rc               Return status code
  */
-static void dhcp_done ( struct dhcp_session *dhcp, int rc ) {
+static void dhcp_finished ( struct dhcp_session *dhcp, int rc ) {
 
-       /* Free up options if we failed */
-       if ( rc != 0 ) {
-               if ( dhcp->options ) {
-                       free_dhcp_options ( dhcp->options );
-                       dhcp->options = NULL;
-               }
-       }
+       /* Block futher incoming messages */
+       job_nullify ( &dhcp->job );
+       xfer_nullify ( &dhcp->xfer );
 
        /* Stop retry timer */
        stop_timer ( &dhcp->timer );
 
-       /* Close UDP connection */
-       udp_close ( &dhcp->udp );
+       /* Free resources and close interfaces */
+       xfer_close ( &dhcp->xfer, rc );
+       job_done ( &dhcp->job, rc );
+}
 
-       /* Release reference on net device */
-       ref_del ( &dhcp->netdev_ref );
+/**
+ * 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;
+       }
 
-       /* Mark async operation as complete */
-       async_done ( &dhcp->aop, rc );
+       settings = &dhcp->response->dhcppkt.settings;
+       parent = netdev_settings ( dhcp->netdev );
+       if ( ( rc = register_settings ( settings, parent ) ) != 0 )
+               return rc;
+
+       return 0;
 }
 
-/** Address for transmitting DHCP requests */
-static union {
-       struct sockaddr_tcpip st;
-       struct sockaddr_in sin;
-} sa_dhcp_server = {
-       .sin = {
-               .sin_family = AF_INET,
-               .sin_addr.s_addr = INADDR_BROADCAST,
-               .sin_port = htons ( BOOTPS_PORT ),
-       },
-};
+/****************************************************************************
+ *
+ * Data transfer interface
+ *
+ */
 
 /**
  * Transmit DHCP request
  *
- * @v conn             UDP connection
- * @v buf              Temporary data buffer
- * @v len              Length of temporary data buffer
+ * @v dhcp             DHCP session
  * @ret rc             Return status code
  */
-static int dhcp_senddata ( struct udp_connection *conn,
-                          void *buf, size_t len ) {
-       struct dhcp_session *dhcp = udp_to_dhcp ( conn );
+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;
        
-       DBG ( "Transmitting %s\n", dhcp_msgtype_name ( dhcp->state ) );
+       DBGC ( dhcp, "DHCP %p transmitting %s\n",
+              dhcp, dhcp_msgtype_name ( dhcp->state ) );
 
        assert ( ( dhcp->state == DHCPDISCOVER ) ||
                 ( dhcp->state == DHCPREQUEST ) );
 
-       /* Create DHCP packet in temporary buffer */
-       if ( ( rc = create_dhcp_packet ( dhcp->netdev, dhcp->state, buf, len,
-                                        &dhcppkt ) ) != 0 ) {
-               DBG ( "Could not create DHCP packet\n" );
-               return rc;
-       }
+       /* Start retry timer.  Do this first so that failures to
+        * transmit will be retried.
+        */
+       start_timer ( &dhcp->timer );
 
-       /* Copy in options common to all requests */
-       if ( ( rc = copy_dhcp_packet_options ( &dhcppkt,
-                                              &dhcp_request_options ) ) != 0){
-               DBG ( "Could not set common DHCP options\n" );
-               return rc;
-       }
+       /* Allocate buffer for packet */
+       iobuf = xfer_alloc_iob ( &dhcp->xfer, DHCP_MIN_LEN );
+       if ( ! iobuf )
+               return -ENOMEM;
 
-       /* Copy any required options from previous server repsonse */
-       if ( dhcp->options ) {
-               if ( ( rc = copy_dhcp_packet_option ( &dhcppkt, dhcp->options,
-                                           DHCP_SERVER_IDENTIFIER,
-                                           DHCP_SERVER_IDENTIFIER ) ) != 0 ) {
-                       DBG ( "Could not set server identifier option\n" );
-                       return rc;
-               }
-               if ( ( rc = copy_dhcp_packet_option ( &dhcppkt, dhcp->options,
-                                           DHCP_EB_YIADDR,
-                                           DHCP_REQUESTED_ADDRESS ) ) != 0 ) {
-                       DBG ( "Could not set requested address option\n" );
-                       return rc;
-               }
+       /* Create DHCP packet in temporary buffer */
+       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;
        }
 
        /* Transmit the packet */
-       if ( ( rc = udp_sendto ( conn, &sa_dhcp_server.st,
-                                dhcppkt.dhcphdr, dhcppkt.len ) ) != 0 ) {
-               DBG ( "Could not transmit UDP packet\n" );
-               return rc;
+       iob_put ( iobuf, dhcppkt.len );
+       rc = xfer_deliver_iob_meta ( &dhcp->xfer, iobuf, &meta );
+       iobuf = NULL;
+       if ( rc != 0 ) {
+               DBGC ( dhcp, "DHCP %p could not transmit UDP packet: %s\n",
+                      dhcp, strerror ( rc ) );
+               goto done;
        }
 
-       return 0;
-}
-
-/**
- * Transmit DHCP request
- *
- * @v dhcp             DHCP session
- */
-static void dhcp_send_request ( struct dhcp_session *dhcp ) {
-       start_timer ( &dhcp->timer );
-       udp_senddata ( &dhcp->udp );
+ done:
+       free_iob ( iobuf );
+       return rc;
 }
 
 /**
@@ -612,7 +572,7 @@ static void dhcp_timer_expired ( struct retry_timer *timer, int fail ) {
                container_of ( timer, struct dhcp_session, timer );
 
        if ( fail ) {
-               dhcp_done ( dhcp, -ETIMEDOUT );
+               dhcp_finished ( dhcp, -ETIMEDOUT );
        } else {
                dhcp_send_request ( dhcp );
        }
@@ -621,126 +581,212 @@ static void dhcp_timer_expired ( struct retry_timer *timer, int fail ) {
 /**
  * Receive new data
  *
- * @v udp              UDP connection
+ * @v xfer             Data transfer interface
+ * @v iobuf            I/O buffer
  * @v data             Received data
  * @v len              Length of received data
- * @v st_src           Partially-filled source address
- * @v st_dest          Partially-filled destination address
+ * @ret rc             Return status code
  */
-static int dhcp_newdata ( struct udp_connection *conn, void *data, size_t len,
-                         struct sockaddr_tcpip *st_src __unused,
-                         struct sockaddr_tcpip *st_dest __unused ) {
-       struct dhcp_session *dhcp = udp_to_dhcp ( conn );
-       struct dhcphdr *dhcphdr = data;
-       struct dhcp_option_block *options;
+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 );
+       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 ) ) {
-               DBG ( "DHCP wrong transaction ID (wanted %08lx, got %08lx)\n",
-                     ntohl ( dhcphdr->xid ),
-                     ntohl ( dhcp_xid ( dhcp->netdev ) ) );
-               return 0;
-       };
+               DBGC ( dhcp, "DHCP %p wrong transaction ID (wanted %08lx, "
+                       "got %08lx)\n", dhcp, ntohl ( dhcphdr->xid ),
+                       ntohl ( dhcp_xid ( dhcp->netdev ) ) );
+               goto out_discard;
+       };      
+
+       /* Determine and verify message type */
+       is_proxy = ( dhcphdr->yiaddr.s_addr == 0 );
+       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 ) ) &&
+            ( ( dhcp->state != DHCPREQUEST ) || ( msgtype != DHCPACK ) ) ) {
+               DBGC ( dhcp, "DHCP %p discarding %s while in %s state\n",
+                      dhcp, dhcp_msgtype_name ( msgtype ),
+                      dhcp_msgtype_name ( dhcp->state ) );
+               goto out_discard;
+       }
 
-       /* Parse packet and create options structure */
-       options = dhcp_parse ( dhcphdr, len );
-       if ( ! options ) {
-               DBG ( "Could not parse DHCP packet\n" );
-               return -EINVAL;
+       /* Update stored standard/ProxyDHCP options, if the new
+        * options have equal or higher priority than the
+        * currently-stored 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 {
+               dhcpiob_put ( response );
        }
 
-       /* Determine message type */
-       msgtype = find_dhcp_num_option ( options, DHCP_MESSAGE_TYPE );
-       DBG ( "Received %s\n", dhcp_msgtype_name ( msgtype ) );
+       /* 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->response )
+               goto out;
 
-       /* Handle DHCP reply */
+       /* Handle DHCP response */
+       ignore_proxy = fetch_uintz_setting ( &dhcp->response->dhcppkt.settings,
+                                            DHCP_EB_NO_PROXYDHCP );
        switch ( dhcp->state ) {
        case DHCPDISCOVER:
-               if ( msgtype != DHCPOFFER )
-                       goto out_discard;
-               dhcp->state = DHCPREQUEST;
+               /* If we have allowed sufficient time for ProxyDHCP
+                * reponses, then transition to making the DHCPREQUEST.
+                */
+               elapsed = ( currticks() - dhcp->start );
+               if ( ignore_proxy || ( elapsed > PROXYDHCP_WAIT_TIME ) ) {
+                       stop_timer ( &dhcp->timer );
+                       dhcp->state = DHCPREQUEST;
+                       dhcp_send_request ( dhcp );
+               }
                break;
        case DHCPREQUEST:
-               if ( msgtype != DHCPACK )
-                       goto out_discard;
-               dhcp->state = DHCPACK;
+               /* DHCP finished; register options and exit */
+               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_finished ( dhcp, 0 );
                break;
        default:
                assert ( 0 );
-               goto out_discard;
        }
 
-       /* Stop timer and update stored options */
-       stop_timer ( &dhcp->timer );
-       if ( dhcp->options )
-               free_dhcp_options ( dhcp->options );
-       dhcp->options = options;
-
-       /* Transmit next packet, or terminate session */
-       if ( dhcp->state < DHCPACK ) {
-               dhcp_send_request ( dhcp );
-       } else {
-               dhcp_done ( dhcp, 0 );
-       }
+ out:
        return 0;
 
  out_discard:
-       free_dhcp_options ( options );
+       dhcpiob_put ( response );
        return 0;
 }
 
-/** DHCP UDP operations */
-static struct udp_operations dhcp_udp_operations = {
-       .senddata       = dhcp_senddata,
-       .newdata        = dhcp_newdata,
+/** DHCP data transfer interface operations */
+static struct xfer_interface_operations dhcp_xfer_operations = {
+       .close          = ignore_xfer_close,
+       .vredirect      = xfer_vopen,
+       .window         = unlimited_xfer_window,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = dhcp_deliver_iob,
+       .deliver_raw    = xfer_deliver_as_iob,
 };
 
+/****************************************************************************
+ *
+ * Job control interface
+ *
+ */
+
 /**
- * Forget reference to net_device
+ * Handle kill() event received via job control interface
  *
- * @v ref              Persistent reference
+ * @v job              DHCP job control interface
  */
-static void dhcp_forget_netdev ( struct reference *ref ) {
-       struct dhcp_session *dhcp
-               = container_of ( ref, struct dhcp_session, netdev_ref );
+static void dhcp_job_kill ( struct job_interface *job ) {
+       struct dhcp_session *dhcp =
+               container_of ( job, struct dhcp_session, job );
 
-       /* Kill DHCP session immediately */
-       dhcp_done ( dhcp, -ENETUNREACH );
+       /* Terminate DHCP session */
+       dhcp_finished ( dhcp, -ECANCELED );
 }
 
+/** DHCP job control interface operations */
+static struct job_interface_operations dhcp_job_operations = {
+       .done           = ignore_job_done,
+       .kill           = dhcp_job_kill,
+       .progress       = ignore_job_progress,
+};
+
+/****************************************************************************
+ *
+ * Instantiator
+ *
+ */
+
 /**
- * Initiate DHCP on a network interface
+ * Start DHCP on a network device
  *
- * @v dhcp             DHCP session
- * @ret aop            Asynchronous operation
+ * @v job              Job control interface
+ * @v netdev           Network device
+ * @v register_options DHCP option block registration routine
+ * @ret rc             Return status code
  *
- * If the DHCP operation completes successfully, the
- * dhcp_session::options field will be filled in with the resulting
- * options block.  The caller takes responsibility for eventually
- * calling free_dhcp_options().
+ * Starts DHCP on the specified network device.  If successful, the @c
+ * register_options() routine will be called with the acquired
+ * options.
  */
-struct async_operation * start_dhcp ( struct dhcp_session *dhcp ) {
+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,
+               .sin_port = htons ( BOOTPS_PORT ),
+       };
+       static struct sockaddr_in client = {
+               .sin_family = AF_INET,
+               .sin_port = htons ( BOOTPC_PORT ),
+       };
+       struct dhcp_session *dhcp;
        int rc;
 
-       /* Initialise DHCP session */
-       dhcp->udp.udp_op = &dhcp_udp_operations;
+       /* Allocate and initialise structure */
+       dhcp = zalloc ( sizeof ( *dhcp ) );
+       if ( ! dhcp )
+               return -ENOMEM;
+       dhcp->refcnt.free = dhcp_free;
+       job_init ( &dhcp->job, &dhcp_job_operations, &dhcp->refcnt );
+       xfer_init ( &dhcp->xfer, &dhcp_xfer_operations, &dhcp->refcnt );
+       dhcp->netdev = netdev_get ( netdev );
        dhcp->timer.expired = dhcp_timer_expired;
        dhcp->state = DHCPDISCOVER;
+       dhcp->start = currticks();
 
-       /* Bind to local port */
-       if ( ( rc = udp_open ( &dhcp->udp, htons ( BOOTPC_PORT ) ) ) != 0 ) {
-               async_done ( &dhcp->aop, rc );
-               goto out;
-       }
+       /* Instantiate child objects and attach to our interfaces */
+       if ( ( rc = xfer_open_socket ( &dhcp->xfer, SOCK_DGRAM,
+                                      ( struct sockaddr * ) &server,
+                                      ( struct sockaddr * ) &client ) ) != 0 )
+               goto err;
 
-       /* Add persistent reference to net device */
-       dhcp->netdev_ref.forget = dhcp_forget_netdev;
-       ref_add ( &dhcp->netdev_ref, &dhcp->netdev->references );
+       /* Start timer to initiate initial DHCPREQUEST */
+       start_timer_nodelay ( &dhcp->timer );
 
-       /* Proof of concept: just send a single DHCPDISCOVER */
-       dhcp_send_request ( dhcp );
+       /* Attach parent interface, mortalise self, and return */
+       job_plug_plug ( &dhcp->job, job );
+       ref_put ( &dhcp->refcnt );
+       return 0;
 
- out:
-       return &dhcp->aop;
+ err:
+       dhcp_finished ( dhcp, rc );
+       ref_put ( &dhcp->refcnt );
+       return rc;
 }