Add RFC2090 TFTP multicast support.

src/core/bitmap.c

+/*
+ * Copyright (C) 2007 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 <errno.h>
+#include <gpxe/bitmap.h>
+
+/** @file
+ *
+ * Bitmaps for multicast downloads
+ *
+ */
+
+/**
+ * Resize bitmap
+ *
+ * @v bitmap		Bitmap
+ * @v new_length	New length of bitmap, in bits
+ * @ret rc		Return status code
+ */
+int bitmap_resize ( struct bitmap *bitmap, unsigned int new_length ) {
+	unsigned int old_num_blocks;
+	unsigned int new_num_blocks;
+	size_t new_size;
+	bitmap_block_t *new_blocks;
+
+	old_num_blocks = BITMAP_INDEX ( bitmap->length + BITMAP_BLKSIZE - 1 );
+	new_num_blocks = BITMAP_INDEX ( new_length + BITMAP_BLKSIZE - 1 );
+
+	new_size = ( new_num_blocks * sizeof ( bitmap->blocks[0] ) );
+	new_blocks = realloc ( bitmap->blocks, new_size );
+	if ( ! new_blocks ) {
+		DBGC ( bitmap, "Bitmap %p could not resize to %d bits\n",
+		       bitmap, new_length );
+		return -ENOMEM;
+	}
+	bitmap->blocks = new_blocks;
+	bitmap->length = new_length;
+
+	while ( old_num_blocks < new_num_blocks ) {
+		bitmap->blocks[old_num_blocks++] = 0;
+	}
+
+	DBGC ( bitmap, "Bitmap %p resized to %d bits\n", bitmap, new_length );
+	return 0;
+}
+
+/**
+ * Test bit in bitmap
+ *
+ * @v bitmap		Bitmap
+ * @v bit		Bit index
+ * @ret is_set		Bit is set
+ */
+int bitmap_test ( struct bitmap *bitmap, unsigned int bit ) {
+	unsigned int index = BITMAP_INDEX ( bit );
+        bitmap_block_t mask = BITMAP_MASK ( bit );
+
+	if ( bit >= bitmap->length )
+		return 0;
+	return ( bitmap->blocks[index] & mask );
+}
+
+/**
+ * Set bit in bitmap
+ *
+ * @v bitmap		Bitmap
+ * @v bit		Bit index
+ */
+void bitmap_set ( struct bitmap *bitmap, unsigned int bit ) {
+	unsigned int index = BITMAP_INDEX ( bit );
+        bitmap_block_t mask = BITMAP_MASK ( bit );
+
+	DBGC ( bitmap, "Bitmap %p setting bit %d\n", bitmap, bit );
+
+	/* Update bitmap */
+	bitmap->blocks[index] |= mask;
+
+	/* Update first gap counter */
+	while ( bitmap_test ( bitmap, bitmap->first_gap ) ) {
+		bitmap->first_gap++;
+	}
+}

src/include/gpxe/bitmap.h

+#ifndef _GPXE_BITMAP_H
+#define _GPXE_BITMAP_H
+
+/** @file
+ *
+ * Bitmaps for multicast downloads
+ *
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+/** A single block of bits within a bitmap */
+typedef unsigned long bitmap_block_t;
+
+/** Size of a block of bits (in bits) */
+#define BITMAP_BLKSIZE ( sizeof ( bitmap_block_t ) * 8 )
+
+/**
+ * Block index within bitmap
+ *
+ * @v bit		Bit index
+ * @ret index		Block index
+ */
+#define BITMAP_INDEX( bit ) ( (bit) / BITMAP_BLKSIZE )
+
+/**
+ * Block mask within bitmap
+ *
+ * @v bit		Bit index
+ * @ret mask		Block mask
+ */
+#define BITMAP_MASK( bit ) ( 1 << ( (bit) % BITMAP_BLKSIZE ) )
+
+/** A bitmap */
+struct bitmap {
+	/** Bitmap data */
+	bitmap_block_t *blocks;
+	/** Length of the bitmap, in bits */
+	unsigned int length;
+	/** Index of first gap in the bitmap */
+	unsigned int first_gap;
+};
+
+extern int bitmap_resize ( struct bitmap *bitmap, unsigned int new_length );
+extern int bitmap_test ( struct bitmap *bitmap, unsigned int bit );
+extern void bitmap_set ( struct bitmap *bitmap, unsigned int bit );
+
+/**
+ * Free bitmap resources
+ *
+ * @v bitmap		Bitmap
+ */
+static inline void bitmap_free ( struct bitmap *bitmap ) {
+	free ( bitmap->blocks );
+}
+
+/**
+ * Get first gap within bitmap
+ *
+ * @v bitmap		Bitmap
+ * @ret first_gap	First gap
+ *
+ * The first gap is the first unset bit within the bitmap.
+ */
+static inline unsigned int bitmap_first_gap ( struct bitmap *bitmap ) {
+	return bitmap->first_gap;
+}
+
+/**
+ * Check to see if bitmap is full
+ *
+ * @v bitmap		Bitmap
+ * @ret is_full		Bitmap is full
+ *
+ * The bitmap is full if it has no gaps (i.e. no unset bits).
+ */
+static inline int bitmap_full ( struct bitmap *bitmap ) {
+	return ( bitmap->first_gap == bitmap->length );
+}
+
+#endif /* _GPXE_BITMAP_H */

src/include/gpxe/errfile.h

 #define ERRFILE_settings	       ( ERRFILE_CORE | 0x000c0000 )
 #define ERRFILE_vsprintf	       ( ERRFILE_CORE | 0x000d0000 )
 #define ERRFILE_xfer		       ( ERRFILE_CORE | 0x000e0000 )
+#define ERRFILE_bitmap		       ( ERRFILE_CORE | 0x000f0000 )
 
 #define ERRFILE_eisa		     ( ERRFILE_DRIVER | 0x00000000 )
 #define ERRFILE_isa		     ( ERRFILE_DRIVER | 0x00010000 )

src/net/udp/tftp.c

 #include <gpxe/tcpip.h>
 #include <gpxe/retry.h>
 #include <gpxe/features.h>
+#include <gpxe/bitmap.h>
 #include <gpxe/tftp.h>
 
 /** @file
 	struct uri *uri;
 	/** Transport layer interface */
 	struct xfer_interface socket;
+	/** Multicast transport layer interface */
+	struct xfer_interface mc_socket;
 
 	/** Data block size
 	 *
 	 * "tsize" option, this value will be zero.
 	 */
 	unsigned long tsize;
-
-	/** Request state
+	/** Multicast address
+	 *
+	 * This is the destination address for multicast data
+	 * transmissions.
+	 */
+	struct sockaddr_tcpip multicast;
+	/** Master client
 	 *
-	 * This is the block number to be used in the next ACK sent
-	 * back to the server, i.e. the number of the last received
-	 * data block.  The value zero indicates that the last
-	 * received block was an OACK (i.e. that the next ACK will
-	 * contain a block number of zero), and any value less than
-	 * zero indicates that the connection has not yet been opened
-	 * (i.e. that no blocks have yet been received).
+	 * True if this is the client responsible for sending ACKs.
 	 */
-	int state;
+	int master;
+	
 	/** Peer address
 	 *
 	 * The peer address is determined by the first response
 	 * received to the TFTP RRQ.
 	 */
 	struct sockaddr_tcpip peer;
+	/** Block bitmap */
+	struct bitmap bitmap;
+	/** Maximum known length
+	 *
+	 * We don't always know the file length in advance.  In
+	 * particular, if the TFTP server doesn't support the tsize
+	 * option, or we are using MTFTP, then we don't know the file
+	 * length until we see the end-of-file block (which, in the
+	 * case of MTFTP, may not be the last block we see).
+	 *
+	 * This value is updated whenever we obtain information about
+	 * the file length.
+	 */
+	size_t filesize;
 	/** Retransmission timer */
 	struct retry_timer timer;
 };
 		container_of ( refcnt, struct tftp_request, refcnt );
 
 	uri_put ( tftp->uri );
+	bitmap_free ( &tftp->bitmap );
 	free ( tftp );
 }
 
 	/* Close all data transfer interfaces */
 	xfer_nullify ( &tftp->socket );
 	xfer_close ( &tftp->socket, rc );
+	xfer_nullify ( &tftp->mc_socket );
+	xfer_close ( &tftp->mc_socket, rc );
 	xfer_nullify ( &tftp->xfer );
 	xfer_close ( &tftp->xfer, rc );
 }
 
+/**
+ * Presize TFTP receive buffers and block bitmap
+ *
+ * @v tftp		TFTP connection
+ * @v filesize		Known minimum file size
+ * @ret rc		Return status code
+ */
+static int tftp_presize ( struct tftp_request *tftp, size_t filesize ) {
+	unsigned int num_blocks;
+	int rc;
+
+	/* Do nothing if we are already large enough */
+	if ( filesize <= tftp->filesize )
+		return 0;
+
+	/* Record filesize */
+	tftp->filesize = filesize;
+
+	/* Notify recipient of file size */
+	xfer_seek ( &tftp->xfer, filesize, SEEK_SET );
+	xfer_seek ( &tftp->xfer, 0, SEEK_SET );
+
+	/* Calculate expected number of blocks.  Note that files whose
+	 * length is an exact multiple of the blocksize will have a
+	 * trailing zero-length block, which must be included.
+	 */
+	num_blocks = ( ( filesize / tftp->blksize ) + 1 );
+	if ( ( rc = bitmap_resize ( &tftp->bitmap, num_blocks ) ) != 0 ) {
+		DBGC ( tftp, "TFTP %p could not resize bitmap to %d blocks: "
+		       "%s\n", tftp, num_blocks, strerror ( rc ) );
+		return rc;
+	}
+
+	return 0;
+}
+
 /**
  * TFTP requested blocksize
  *
 	size_t len = ( sizeof ( *rrq ) + strlen ( path ) + 1 /* NUL */
 		       + 5 + 1 /* "octet" + NUL */
 		       + 7 + 1 + 5 + 1 /* "blksize" + NUL + ddddd + NUL */
-		       + 5 + 1 + 1 + 1 /* "tsize" + NUL + "0" + NUL */ );
+		       + 5 + 1 + 1 + 1 /* "tsize" + NUL + "0" + NUL */ 
+		       + 9 + 1 + 1 /* "multicast" + NUL + NUL */ );
 	struct io_buffer *iobuf;
 
 	DBGC ( tftp, "TFTP %p requesting \"%s\"\n", tftp, path );
 	rrq->opcode = htons ( TFTP_RRQ );
 	iob_put ( iobuf,
 		  snprintf ( rrq->data, iob_tailroom ( iobuf ),
-			     "%s%coctet%cblksize%c%d%ctsize%c0", path, 0,
-			     0, 0, tftp_request_blksize, 0, 0 ) + 1 );
+			     "%s%coctet%cblksize%c%d%ctsize%c0%cmulticast%c",
+			     path, 0, 0, 0, tftp_request_blksize, 0,
+			     0, 0, 0 ) + 1 );
 
 	/* RRQ always goes to the address specified in the initial
 	 * xfer_open() call
 	struct xfer_metadata meta = {
 		.dest = ( struct sockaddr * ) &tftp->peer,
 	};
+	unsigned int block;
 
-	DBGC2 ( tftp, "TFTP %p sending ACK for block %d\n",
-		tftp, tftp->state );
+	/* Determine next required block number */
+	block = bitmap_first_gap ( &tftp->bitmap );
+	DBGC2 ( tftp, "TFTP %p sending ACK for block %d\n", tftp, block );
 
 	/* Allocate buffer */
 	iobuf = xfer_alloc_iob ( &tftp->socket, sizeof ( *ack ) );
 	/* Build ACK */
 	ack = iob_put ( iobuf, sizeof ( *ack ) );
 	ack->opcode = htons ( TFTP_ACK );
-	ack->block = htons ( tftp->state );
+	ack->block = htons ( block );
 
 	/* ACK always goes to the peer recorded from the RRQ response */
 	return xfer_deliver_iob_meta ( &tftp->socket, iobuf, &meta );
 }
 
 /**
- * Transmit data
+ * Transmit next relevant packet
  *
  * @v tftp		TFTP connection
  * @ret rc		Return status code
  */
 static int tftp_send_packet ( struct tftp_request *tftp ) {
 
-	/* Start retransmission timer */
+	/* Update retransmission timer */
+	stop_timer ( &tftp->timer );
 	start_timer ( &tftp->timer );
 
-	/* Send RRQ or ACK as appropriate */
-	if ( tftp->state < 0 ) {
-		return tftp_send_rrq ( tftp );
+	/* If we are the master client, send RRQ or ACK as appropriate */
+	if ( tftp->master ) {
+		if ( ! tftp->peer.st_family ) {
+			return tftp_send_rrq ( tftp );
+		} else {
+			return tftp_send_ack ( tftp );
+		}
 	} else {
-		return tftp_send_ack ( tftp );
+		/* Do nothing when not the master client */
+		return 0;
 	}
 }
 
 	}
 }
 
-/**
- * Mark TFTP block as received
- *
- * @v tftp		TFTP connection
- * @v block		Block number
- */
-static void tftp_received ( struct tftp_request *tftp, unsigned int block ) {
-
-	/* Stop the retry timer */
-	stop_timer ( &tftp->timer );
-
-	/* Update state to indicate which block we're now waiting for */
-	tftp->state = block;
-
-	/* Send next packet */
-	tftp_send_packet ( tftp );
-}
-
 /**
  * Process TFTP "blksize" option
  *
 	}
 	DBGC ( tftp, "TFTP %p tsize=%ld\n", tftp, tftp->tsize );
 
-	/* Notify recipient of file size */
-	xfer_seek ( &tftp->xfer, tftp->tsize, SEEK_SET );
-	xfer_seek ( &tftp->xfer, 0, SEEK_SET );
+	return 0;
+}
+
+/**
+ * Process TFTP "multicast" option
+ *
+ * @v tftp		TFTP connection
+ * @v value		Option value
+ * @ret rc		Return status code
+ */
+static int tftp_process_multicast ( struct tftp_request *tftp,
+				    const char *value ) {
+	struct sockaddr_in *sin = ( struct sockaddr_in * ) &tftp->multicast;
+	char buf[ strlen ( value ) + 1 ];
+	char *addr;
+	char *port;
+	char *port_end;
+	char *mc;
+	char *mc_end;
+	struct sockaddr *mc_peer;
+	struct sockaddr *mc_local;
+	int rc;
+
+	/* Split value into "addr,port,mc" fields */
+	memcpy ( buf, value, sizeof ( buf ) );
+	addr = buf;
+	port = strchr ( addr, ',' );
+	if ( ! port ) {
+		DBGC ( tftp, "TFTP %p multicast missing port,mc\n", tftp );
+		return -EINVAL;
+	}
+	*(port++) = '\0';
+	mc = strchr ( port, ',' );
+	if ( ! mc ) {
+		DBGC ( tftp, "TFTP %p multicast missing mc\n", tftp );
+		return -EINVAL;
+	}
+	*(mc++) = '\0';
+
+	/* Parse parameters */
+	if ( *addr ) {
+		if ( inet_aton ( addr, &sin->sin_addr ) == 0 ) {
+			DBGC ( tftp, "TFTP %p multicast invalid IP address "
+			       "%s\n", tftp, addr );
+			return -EINVAL;
+		}
+		DBGC ( tftp, "TFTP %p multicast IP address %s\n",
+		       tftp, inet_ntoa ( sin->sin_addr ) );
+	}
+	if ( *port ) {
+		sin->sin_port = htons ( strtoul ( port, &port_end, 0 ) );
+		if ( *port_end ) {
+			DBGC ( tftp, "TFTP %p multicast invalid port %s\n",
+			       tftp, port );
+			return -EINVAL;
+		}
+		DBGC ( tftp, "TFTP %p multicast port %d\n",
+		       tftp, ntohs ( sin->sin_port ) );
+	}
+	tftp->master = strtoul ( mc, &mc_end, 0 );
+	if ( *mc_end ) {
+		DBGC ( tftp, "TFTP %p multicast invalid mc %s\n", tftp, mc );
+		return -EINVAL;
+	}
+	DBGC ( tftp, "TFTP %p is%s the master client\n",
+	       tftp, ( tftp->master ? "" : " not" ) );
+
+	/* Open multicast socket, if new address specified */
+	if ( *addr || *port ) {
+		xfer_close ( &tftp->mc_socket, 0 );
+		mc_peer = ( ( struct sockaddr * ) &tftp->peer );
+		mc_local = ( ( struct sockaddr * ) &tftp->multicast );
+		mc_local->sa_family = mc_peer->sa_family;
+		if ( ( rc = xfer_open_socket ( &tftp->mc_socket, SOCK_DGRAM,
+					       mc_peer, mc_local ) ) != 0 ) {
+			DBGC ( tftp, "TFTP %p could not open multicast "
+			       "socket: %s\n", tftp, strerror ( rc ) );
+			return rc;
+		}
+	}
 
 	return 0;
 }
 static struct tftp_option tftp_options[] = {
 	{ "blksize", tftp_process_blksize },
 	{ "tsize", tftp_process_tsize },
+	{ "multicast", tftp_process_multicast },
 	{ NULL, NULL }
 };
 
 	DBGC ( tftp, "TFTP %p received unknown option \"%s\" = \"%s\"\n",
 	       tftp, name, value );
 
-	return -EINVAL;
+	/* Unknown options should be silently ignored */
+	return 0;
 }
 
 /**
 	if ( len < sizeof ( *oack ) ) {
 		DBGC ( tftp, "TFTP %p received underlength OACK packet "
 		       "length %d\n", tftp, len );
-		return -EINVAL;
+		rc = -EINVAL;
+		goto done;
 	}
 	if ( end[-1] != '\0' ) {
 		DBGC ( tftp, "TFTP %p received OACK missing final NUL\n",
 		       tftp );
-		return -EINVAL;
+		rc = -EINVAL;
+		goto done;
 	}
 
 	/* Process each option in turn */
 		if ( value == end ) {
 			DBGC ( tftp, "TFTP %p received OACK missing value "
 			       "for option \"%s\"\n", tftp, name );
-			return -EINVAL;
+			rc = -EINVAL;
+			goto done;
 		}
 		if ( ( rc = tftp_process_option ( tftp, name, value ) ) != 0 )
-			return rc;
+			goto done;
 		name = ( value + strlen ( value ) + 1 );
 	}
 
-	/* Mark as received block 0 (the OACK) */
-	tftp_received ( tftp, 0 );
+	/* Process tsize information, if available */
+	if ( tftp->tsize ) {
+		if ( ( rc = tftp_presize ( tftp, tftp->tsize ) ) != 0 )
+			goto done;
+	}
 
-	return 0;
+	/* Request next data block */
+	tftp_send_packet ( tftp );
+
+ done:
+	if ( rc )
+		tftp_done ( tftp, rc );
+	return rc;
 }
 
 /**
 			  struct io_buffer *iobuf ) {
 	struct tftp_data *data = iobuf->data;
 	int block;
+	off_t offset;
 	size_t data_len;
 	int rc;
 
 	if ( iob_len ( iobuf ) < sizeof ( *data ) ) {
 		DBGC ( tftp, "TFTP %p received underlength DATA packet "
 		       "length %d\n", tftp, iob_len ( iobuf ) );
-		free_iob ( iobuf );
-		return -EINVAL;
+		rc = -EINVAL;
+		goto done;
 	}
 
 	/* Extract data */
-	block = ntohs ( data->block );
+	block = ( ntohs ( data->block ) - 1 );
+	offset = ( block * tftp->blksize );
 	iob_pull ( iobuf, sizeof ( *data ) );
 	data_len = iob_len ( iobuf );
-
-	/* Check for correct block */
-	if ( ( tftp->state == -1 ) && ( block == 1 ) )
-		tftp->state = 0;
-	if ( block != ( tftp->state + 1 ) ) {
-		DBGC ( tftp, "TFTP %p received out-of-order block %d "
-		       "(expecting %d)\n", tftp, block, ( tftp->state + 1 ) );
-		free_iob ( iobuf );
-		return 0;
+	if ( data_len > tftp->blksize ) {
+		DBGC ( tftp, "TFTP %p received overlength DATA packet "
+		       "length %d\n", tftp, data_len );
+		rc = -EINVAL;
+		goto done;
 	}
 
 	/* Deliver data */
-	if ( ( rc = xfer_deliver_iob ( &tftp->xfer, iobuf ) ) != 0 ) {
+	xfer_seek ( &tftp->xfer, offset, SEEK_SET );
+	rc = xfer_deliver_iob ( &tftp->xfer, iobuf );
+	iobuf = NULL;
+	if ( rc != 0 ) {
 		DBGC ( tftp, "TFTP %p could not deliver data: %s\n",
 		       tftp, strerror ( rc ) );
-		tftp_done ( tftp, rc );
-		return rc;
+		goto done;
 	}
 
+	/* Ensure block bitmap is ready */
+	if ( ( rc = tftp_presize ( tftp, ( offset + data_len ) ) ) != 0 )
+		goto done;
+
 	/* Mark block as received */
-	tftp_received ( tftp, block );
+	bitmap_set ( &tftp->bitmap, block );
+
+	/* Acknowledge block */
+	tftp_send_packet ( tftp );
 
-	/* Finish when final block received */
-	if ( data_len < tftp->blksize )
+	/* If all blocks have been received, finish. */
+	if ( bitmap_full ( &tftp->bitmap ) )
 		tftp_done ( tftp, 0 );
 
-	return 0;
+ done:
+	free_iob ( iobuf );
+	if ( rc )
+		tftp_done ( tftp, rc );
+	return rc;
 }
 
 /** Translation between TFTP errors and internal error numbers */
 /**
  * Receive new data
  *
- * @v udp		UDP connection
- * @v data		Received data
- * @v len		Length of received data
- * @v st_src		Partially-filled source address
- * @v st_dest		Partially-filled destination address
+ * @v tftp		TFTP connection
+ * @v iobuf		I/O buffer
+ * @v meta		Transfer metadata, or NULL
+ * @ret rc		Return status code
  */
-static int tftp_socket_deliver_iob ( struct xfer_interface *socket,
-				     struct io_buffer *iobuf,
-				     struct xfer_metadata *meta ) {
-	struct tftp_request *tftp =
-		container_of ( socket, struct tftp_request, socket );
+static int tftp_rx ( struct tftp_request *tftp,
+		     struct io_buffer *iobuf,
+		     struct xfer_metadata *meta ) {
 	struct sockaddr_tcpip *st_src;
 	struct tftp_common *common = iobuf->data;
 	size_t len = iob_len ( iobuf );
 
 	/* Filter by TID.  Set TID on first response received */
 	st_src = ( struct sockaddr_tcpip * ) meta->src;
-	if ( tftp->state < 0 ) {
+	if ( ! tftp->peer.st_family ) {
 		memcpy ( &tftp->peer, st_src, sizeof ( tftp->peer ) );
 		DBGC ( tftp, "TFTP %p using remote port %d\n", tftp,
 		       ntohs ( tftp->peer.st_port ) );
 	return rc;
 }
 
+/**
+ * Receive new data via socket
+ *
+ * @v socket		Transport layer interface
+ * @v iobuf		I/O buffer
+ * @v meta		Transfer metadata, or NULL
+ * @ret rc		Return status code
+ */
+static int tftp_socket_deliver_iob ( struct xfer_interface *socket,
+				     struct io_buffer *iobuf,
+				     struct xfer_metadata *meta ) {
+	struct tftp_request *tftp =
+		container_of ( socket, struct tftp_request, socket );
+
+	return tftp_rx ( tftp, iobuf, meta );
+}
+
 /**
  * TFTP connection closed by network stack
  *
 	DBGC ( tftp, "TFTP %p socket closed: %s\n",
 	       tftp, strerror ( rc ) );
 
+	/* Any close counts as an error */
+	if ( ! rc )
+		rc = -ECONNRESET;
+
 	tftp_done ( tftp, rc );
 }
 
 	.deliver_iob	= tftp_socket_deliver_iob,
 	.deliver_raw	= xfer_deliver_as_iob,
 };
+
+/**
+ * Receive new data via multicast socket
+ *
+ * @v mc_socket		Multicast transport layer interface
+ * @v iobuf		I/O buffer
+ * @v meta		Transfer metadata, or NULL
+ * @ret rc		Return status code
+ */
+static int tftp_mc_socket_deliver_iob ( struct xfer_interface *mc_socket,
+					struct io_buffer *iobuf,
+					struct xfer_metadata *meta ) {
+	struct tftp_request *tftp =
+		container_of ( mc_socket, struct tftp_request, mc_socket );
+
+	return tftp_rx ( tftp, iobuf, meta );
+}
+
+/**
+ * TFTP multicast connection closed by network stack
+ *
+ * @v socket		Multicast transport layer interface
+ * @v rc		Reason for close
+ */
+static void tftp_mc_socket_close ( struct xfer_interface *mc_socket,
+				   int rc ) {
+	struct tftp_request *tftp =
+		container_of ( mc_socket, struct tftp_request, mc_socket );
+
+	DBGC ( tftp, "TFTP %p multicast socket closed: %s\n",
+	       tftp, strerror ( rc ) );
+
+	/* The multicast socket may be closed when we receive a new
+	 * OACK and open/reopen the socket; we should not call
+	 * tftp_done() at this point.
+	 */
+}
  
+/** TFTP multicast socket operations */
+static struct xfer_interface_operations tftp_mc_socket_operations = {
+	.close		= tftp_mc_socket_close,
+	.vredirect	= xfer_vopen,
+	.seek		= ignore_xfer_seek,
+	.window		= unlimited_xfer_window,
+	.alloc_iob	= default_xfer_alloc_iob,
+	.deliver_iob	= tftp_mc_socket_deliver_iob,
+	.deliver_raw	= xfer_deliver_as_iob,
+};
+
 /**
  * Close TFTP data transfer interface
  *
 	xfer_init ( &tftp->xfer, &tftp_xfer_operations, &tftp->refcnt );
 	tftp->uri = uri_get ( uri );
 	xfer_init ( &tftp->socket, &tftp_socket_operations, &tftp->refcnt );
+	xfer_init ( &tftp->mc_socket, &tftp_mc_socket_operations,
+		    &tftp->refcnt );
 	tftp->blksize = TFTP_DEFAULT_BLKSIZE;
-	tftp->state = -1;
+	tftp->master = 1;
 	tftp->timer.expired = tftp_timer_expired;
 
 	/* Open socket */