[DHCP] FIXME: quick temporary settings fix, needs update for new API
[people/andreif/gpxe.git] / src / net / udp / dhcp.c
index 7e9af09..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/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
  *
@@ -29,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
@@ -46,318 +63,730 @@ static const uint8_t dhcp_op[] = {
        [DHCPINFORM]    = BOOTP_REQUEST,
 };
 
-/** DHCP packet option block fill order
- *
- * This is the order in which option blocks are filled when
- * reassembling a DHCP packet.  We fill the smallest field ("sname")
- * first, to maximise the chances of being able to fit large options
- * within fields which are large enough to contain them.
- */
-enum dhcp_packet_option_block_fill_order {
-       OPTS_SNAME = 0,
-       OPTS_FILE,
-       OPTS_MAIN,
-       NUM_OPT_BLOCKS
+/** Raw option data for options common to all DHCP requests */
+static uint8_t dhcp_request_options_data[] = {
+       DHCP_MAX_MESSAGE_SIZE, DHCP_WORD ( ETH_MAX_MTU ),
+       DHCP_VENDOR_CLASS_ID,
+       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_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 option blocks within a DHCP packet
+/** 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
  *
- * A DHCP packet contains three fields which can be used to contain
- * options: the actual "options" field plus the "file" and "sname"
- * fields (which can be overloaded to contain options).
+ * @v msgtype          DHCP message type
+ * @ret string         DHCP mesasge type name
  */
-struct dhcp_packet_option_blocks {
-       struct dhcp_option_block options[NUM_OPT_BLOCKS];
-};
+static inline const char * dhcp_msgtype_name ( unsigned int msgtype ) {
+       switch ( msgtype ) {
+       case 0:                 return "BOOTP"; /* Non-DHCP packet */
+       case DHCPDISCOVER:      return "DHCPDISCOVER";
+       case DHCPOFFER:         return "DHCPOFFER";
+       case DHCPREQUEST:       return "DHCPREQUEST";
+       case DHCPDECLINE:       return "DHCPDECLINE";
+       case DHCPACK:           return "DHCPACK";
+       case DHCPNAK:           return "DHCPNAK";
+       case DHCPRELEASE:       return "DHCPRELEASE";
+       case DHCPINFORM:        return "DHCPINFORM";
+       default:                return "DHCP<invalid>";
+       }
+}
 
 /**
- * Set option within DHCP packet
+ * Calculate DHCP transaction ID for a network device
  *
- * @v optblocks                DHCP packet option blocks
- * @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 netdev           Network device
+ * @ret xid            DHCP XID
  *
- * 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.
+ * Extract the least significant bits of the hardware address for use
+ * as the transaction ID.
  */
-static struct dhcp_option *
-set_dhcp_packet_option ( struct dhcp_packet_option_blocks *optblocks,
-                        unsigned int tag, const void *data, size_t len ) {
-       struct dhcp_option_block *options;
-       struct dhcp_option *option;
-
-       for ( options = optblocks->options ;
-             options < &optblocks->options[NUM_OPT_BLOCKS] ; options++ ) {
-               option = set_dhcp_option ( options, tag, data, len );
-               if ( option )
-                       return option;
-       }
-       return NULL;
+static uint32_t dhcp_xid ( struct net_device *netdev ) {
+       uint32_t xid;
+
+       memcpy ( &xid, ( netdev->ll_addr + netdev->ll_protocol->ll_addr_len
+                        - sizeof ( xid ) ), sizeof ( xid ) );
+       return xid;
 }
 
 /**
- * Copy options to DHCP packet
+ * Create a DHCP packet
  *
- * @v optblocks                DHCP packet option blocks
- * @v encapsulator     Encapsulating option, or zero
+ * @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
- * 
- * Copies options from DHCP options blocks into a DHCP packet.  Most
- * options are copied verbatim.  Recognised encapsulated options
- * fields are handled as such.  Selected options (e.g. @c
- * DHCP_OPTION_OVERLOAD) are always ignored, since these special cases
- * are handled by other 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
-copy_dhcp_options_to_packet ( struct dhcp_packet_option_blocks *optblocks,
-                             unsigned int encapsulator ) {
-       unsigned int subtag;
-       unsigned int tag;
-       struct dhcp_option *option;
-       struct dhcp_option *copied;
+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;
 
-       for ( subtag = DHCP_MIN_OPTION; subtag <= DHCP_MAX_OPTION; subtag++ ) {
-               tag = DHCP_ENCAP_OPT ( encapsulator, subtag );
-               switch ( tag ) {
-               case DHCP_OPTION_OVERLOAD:
-                       /* Hard-coded in packets we reassemble; skip
-                        * this option
-                        */
-                       break;
-               case DHCP_EB_ENCAP:
-               case DHCP_VENDOR_ENCAP:
-                       /* Process encapsulated options field */
-                       if ( ( rc = copy_dhcp_options_to_packet ( optblocks,
-                                                                 tag ) ) != 0)
-                               return rc;
-                       break;
-               default:
-                       /* Copy option to reassembled packet */
-                       option = find_global_dhcp_option ( tag );
-                       if ( ! option )
-                               break;
-                       copied = set_dhcp_packet_option ( optblocks, tag,
-                                                         &option->data,
-                                                         option->len );
-                       if ( ! copied )
-                               return -ENOSPC;
-                       break;
-               };
+       /* 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 );
+
+       /* 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 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
+
 /**
- * Assemble a DHCP packet
- *
- * @v dhcp             DHCP session
- * @v data             Packet to be filled in
- * @v max_len          Length of packet buffer
- * @ret len            Length of assembled packet
+ * Create DHCP request
  *
- * Reconstruct a DHCP packet from a DHCP options list.
+ * @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
  */
-size_t dhcp_assemble ( struct dhcp_session *dhcp, void *data,
-                      size_t max_len ) {
-       struct dhcp_packet *dhcppkt = data;
-       struct dhcp_option *option;
-       struct dhcp_packet_option_blocks optblocks;
-       unsigned int dhcp_message_type;
-       static const uint8_t overloading = ( DHCP_OPTION_OVERLOAD_FILE |
-                                            DHCP_OPTION_OVERLOAD_SNAME );
-
-       /* Fill in constant fields */
-       memset ( dhcppkt, 0, max_len );
-       dhcppkt->xid = dhcp->xid;
-       dhcppkt->magic = htonl ( DHCP_MAGIC_COOKIE );
-
-       /* Derive "op" field from DHCP_MESSAGE_TYPE option value */
-       dhcp_message_type = find_global_dhcp_num_option ( DHCP_MESSAGE_TYPE );
-       dhcppkt->op = dhcp_op[dhcp_message_type];
-
-       /* Fill in NIC details */
-       dhcppkt->htype = ntohs ( dhcp->netdev->ll_protocol->ll_proto );
-       dhcppkt->hlen = dhcp->netdev->ll_protocol->ll_addr_len;
-       memcpy ( dhcppkt->chaddr, dhcp->netdev->ll_addr, dhcppkt->hlen );
-
-       /* Fill in IP addresses if present */
-       option = find_global_dhcp_option ( DHCP_EB_YIADDR );
-       if ( option ) {
-               memcpy ( &dhcppkt->yiaddr, &option->data,
-                        sizeof ( dhcppkt->yiaddr ) );
+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;
+
+       /* 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;
        }
-       option = find_global_dhcp_option ( DHCP_EB_SIADDR );
-       if ( option ) {
-               memcpy ( &dhcppkt->siaddr, &option->data,
-                        sizeof ( dhcppkt->siaddr ) );
+
+       /* 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;
+               }
        }
 
-       /* Initialise option blocks */
-       init_dhcp_options ( &optblocks.options[OPTS_MAIN], dhcppkt->options,
-                           ( max_len -
-                             offsetof ( typeof ( *dhcppkt ), options ) ) );
-       init_dhcp_options ( &optblocks.options[OPTS_FILE], dhcppkt->file,
-                           sizeof ( dhcppkt->file ) );
-       init_dhcp_options ( &optblocks.options[OPTS_SNAME], dhcppkt->sname,
-                           sizeof ( dhcppkt->sname ) );
-       set_dhcp_option ( &optblocks.options[OPTS_MAIN], DHCP_OPTION_OVERLOAD,
-                         &overloading, sizeof ( overloading ) );
-
-       /* Populate option blocks */
-       copy_dhcp_options_to_packet ( &optblocks, 0 );
-
-       return ( offsetof ( typeof ( *dhcppkt ), options )
-                + optblocks.options[OPTS_MAIN].len );
+       /* 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;
+       }
+
+       /* 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;
+       }
+
+       /* 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;
+       }
+
+       /* 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;
 }
 
 /**
- * Calculate used length of a field containing DHCP options
+ * Create DHCP response
  *
- * @v data             Field containing DHCP options
- * @v max_len          Field length
- * @ret len            Used length (excluding the @c DHCP_END tag)
+ * @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
+ * @ret rc             Return status code
  */
-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 );
+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 ( 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;
+};
+
 /**
- * Merge field containing DHCP options or string into DHCP options block
+ * Free DHCP packet contained in an I/O buffer
  *
- * @v options          DHCP option block
- * @v data             Field containing DHCP options
- * @v max_len          Field length
- * @v tag              DHCP option tag, or 0
+ * @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
  *
- * 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 data             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
- * 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
+ *
  */
-struct dhcp_option_block * dhcp_parse ( const void *data, size_t len ) {
-       const struct dhcp_packet *dhcppkt = data;
-       struct dhcp_option_block *options;
-       size_t options_len;
-       unsigned int overloading;
 
-       /* Sanity check */
-       if ( len < sizeof ( *dhcppkt ) )
-               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 ( *dhcppkt ), options ) ) - 1
-                       + ( sizeof ( dhcppkt->file ) + 1 )
-                       + ( sizeof ( dhcppkt->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;
+       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;
+};
+
+/**
+ * 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 );
+
+       netdev_put ( dhcp->netdev );
+       dhcpiob_put ( dhcp->response );
+       dhcpiob_put ( dhcp->proxy_response );
+       free ( dhcp );
+}
+
+/**
+ * Mark DHCP session as complete
+ *
+ * @v dhcp             DHCP session
+ * @v rc               Return status code
+ */
+static void dhcp_finished ( struct dhcp_session *dhcp, int rc ) {
+
+       /* Block futher incoming messages */
+       job_nullify ( &dhcp->job );
+       xfer_nullify ( &dhcp->xfer );
+
+       /* Stop retry timer */
+       stop_timer ( &dhcp->timer );
+
+       /* Free resources and close interfaces */
+       xfer_close ( &dhcp->xfer, 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
+ *
+ */
+
+/**
+ * Transmit DHCP request
+ *
+ * @v dhcp             DHCP session
+ * @ret rc             Return status code
+ */
+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;
        
-       /* Merge in "options" field, if this is a DHCP packet */
-       if ( dhcppkt->magic == htonl ( DHCP_MAGIC_COOKIE ) ) {
-               merge_dhcp_field ( options, dhcppkt->options,
-                                  ( len -
-                                    offsetof ( typeof (*dhcppkt), options ) ),
-                                  0 /* Always contains options */ );
+       DBGC ( dhcp, "DHCP %p transmitting %s\n",
+              dhcp, dhcp_msgtype_name ( dhcp->state ) );
+
+       assert ( ( dhcp->state == DHCPDISCOVER ) ||
+                ( dhcp->state == DHCPREQUEST ) );
+
+       /* Start retry timer.  Do this first so that failures to
+        * transmit will be retried.
+        */
+       start_timer ( &dhcp->timer );
+
+       /* Allocate buffer for packet */
+       iobuf = xfer_alloc_iob ( &dhcp->xfer, DHCP_MIN_LEN );
+       if ( ! iobuf )
+               return -ENOMEM;
+
+       /* 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;
        }
 
-       /* Identify overloaded fields */
-       overloading = find_dhcp_num_option ( options, DHCP_OPTION_OVERLOAD );
-       
-       /* Merge in "file" and "sname" fields */
-       merge_dhcp_field ( options, dhcppkt->file, sizeof ( dhcppkt->file ),
-                          ( ( overloading & DHCP_OPTION_OVERLOAD_FILE ) ?
-                            DHCP_BOOTFILE_NAME : 0 ) );
-       merge_dhcp_field ( options, dhcppkt->sname, sizeof ( dhcppkt->sname ),
-                          ( ( overloading & DHCP_OPTION_OVERLOAD_SNAME ) ?
-                            DHCP_TFTP_SERVER_NAME : 0 ) );
-
-       /* Set options for "yiaddr" and "siaddr", if present */
-       if ( dhcppkt->yiaddr.s_addr ) {
-               set_dhcp_option ( options, DHCP_EB_YIADDR,
-                                 &dhcppkt->yiaddr, sizeof (dhcppkt->yiaddr) );
+       /* Transmit the packet */
+       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;
        }
-       if ( dhcppkt->siaddr.s_addr ) {
-               set_dhcp_option ( options, DHCP_EB_SIADDR,
-                                 &dhcppkt->siaddr, sizeof (dhcppkt->siaddr) );
+
+ done:
+       free_iob ( iobuf );
+       return rc;
+}
+
+/**
+ * Handle DHCP retry timer expiry
+ *
+ * @v timer            DHCP retry timer
+ * @v fail             Failure indicator
+ */
+static void dhcp_timer_expired ( struct retry_timer *timer, int fail ) {
+       struct dhcp_session *dhcp =
+               container_of ( timer, struct dhcp_session, timer );
+
+       if ( fail ) {
+               dhcp_finished ( dhcp, -ETIMEDOUT );
+       } else {
+               dhcp_send_request ( dhcp );
        }
-       
-       assert ( options->len <= options->max_len );
+}
+
+/**
+ * Receive new data
+ *
+ * @v xfer             Data transfer interface
+ * @v iobuf            I/O buffer
+ * @v data             Received data
+ * @v len              Length of received data
+ * @ret rc             Return status code
+ */
+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 ) ) {
+               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;
+       }
+
+       /* 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 );
+       }
+
+       /* 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 response */
+       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
+                * 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:
+               /* 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 );
+       }
+
+ out:
+       return 0;
+
+ out_discard:
+       dhcpiob_put ( response );
+       return 0;
+}
+
+/** 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
+ *
+ */
+
+/**
+ * Handle kill() event received via job control interface
+ *
+ * @v job              DHCP job control interface
+ */
+static void dhcp_job_kill ( struct job_interface *job ) {
+       struct dhcp_session *dhcp =
+               container_of ( job, struct dhcp_session, job );
+
+       /* 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
+ *
+ */
+
+/**
+ * Start DHCP on a network device
+ *
+ * @v job              Job control interface
+ * @v netdev           Network device
+ * @v register_options DHCP option block registration routine
+ * @ret rc             Return status code
+ *
+ * Starts DHCP on the specified network device.  If successful, the @c
+ * register_options() routine will be called with the acquired
+ * options.
+ */
+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;
+
+       /* 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();
+
+       /* 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;
+
+       /* Start timer to initiate initial DHCPREQUEST */
+       start_timer_nodelay ( &dhcp->timer );
+
+       /* Attach parent interface, mortalise self, and return */
+       job_plug_plug ( &dhcp->job, job );
+       ref_put ( &dhcp->refcnt );
+       return 0;
 
-       return options;
+ err:
+       dhcp_finished ( dhcp, rc );
+       ref_put ( &dhcp->refcnt );
+       return rc;
 }