[slam] Add Scalable Local Area Multicast (SLAM) protocol support
authorMichael Brown <mcb30@etherboot.org>
Mon, 9 Jun 2008 23:04:19 +0000 (00:04 +0100)
committerMichael Brown <mcb30@etherboot.org>
Mon, 9 Jun 2008 23:04:19 +0000 (00:04 +0100)
Tested against the mini-slamd server located in contrib/mini-slamd
with a single client, on a lossy network.

src/include/gpxe/errfile.h
src/include/gpxe/features.h
src/net/udp/slam.c [new file with mode: 0644]
src/proto/slam.c [deleted file]

index 42952d7..a059195 100644 (file)
 #define ERRFILE_infiniband             ( ERRFILE_NET | 0x00130000 )
 #define ERRFILE_netdev_settings                ( ERRFILE_NET | 0x00140000 )
 #define ERRFILE_dhcppkt                        ( ERRFILE_NET | 0x00150000 )
+#define ERRFILE_slam                   ( ERRFILE_NET | 0x00160000 )
 
 #define ERRFILE_image                ( ERRFILE_IMAGE | 0x00000000 )
 #define ERRFILE_elf                  ( ERRFILE_IMAGE | 0x00010000 )
index 54498b5..70daac3 100644 (file)
@@ -41,6 +41,7 @@
 #define DHCP_EB_FEATURE_DNS            0x17 /**< DNS protocol */
 #define DHCP_EB_FEATURE_BZIMAGE                0x18 /**< bzImage format */
 #define DHCP_EB_FEATURE_MULTIBOOT      0x19 /**< Multiboot format */
+#define DHCP_EB_FEATURE_SLAM           0x1a /**< SLAM protocol */
 #define DHCP_EB_FEATURE_NBI            0x20 /**< NBI format */
 #define DHCP_EB_FEATURE_PXE            0x21 /**< PXE format */
 #define DHCP_EB_FEATURE_ELF            0x22 /**< ELF format */
diff --git a/src/net/udp/slam.c b/src/net/udp/slam.c
new file mode 100644 (file)
index 0000000..67af8cb
--- /dev/null
@@ -0,0 +1,749 @@
+/*
+ * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <errno.h>
+#include <assert.h>
+#include <byteswap.h>
+#include <gpxe/features.h>
+#include <gpxe/iobuf.h>
+#include <gpxe/bitmap.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
+#include <gpxe/uri.h>
+#include <gpxe/tcpip.h>
+#include <gpxe/retry.h>
+
+/** @file
+ *
+ * Scalable Local Area Multicast protocol
+ *
+ * The SLAM protocol is supported only by Etherboot; it was designed
+ * and implemented by Eric Biederman.  A server implementation is
+ * available in contrib/mini-slamd.  There does not appear to be any
+ * documentation beyond a few sparse comments in Etherboot's
+ * proto_slam.c.
+ *
+ * SLAM packets use three types of data field:
+ *
+ *  Nul : A single NUL (0) byte, used as a list terminator
+ *
+ *  Raw : A block of raw data
+ *
+ *  Int : A variable-length integer, in big-endian order.  The length
+ *        of the integer is encoded in the most significant three bits.
+ *
+ * Packets received by the client have the following layout:
+ *
+ *  Int : Transaction identifier.  This is an opaque value.
+ *
+ *  Int : Total number of bytes in the transfer.
+ *
+ *  Int : Block size, in bytes.
+ *
+ *  Int : Packet sequence number within the transfer (if this packet
+ *        contains data).
+ *
+ *  Raw : Packet data (if this packet contains data).
+ *
+ * Packets transmitted by the client consist of a run-length-encoded
+ * representation of the received-blocks bitmap, looking something
+ * like:
+ *
+ *  Int : Number of consecutive successfully-received packets
+ *  Int : Number of consecutive missing packets
+ *  Int : Number of consecutive successfully-received packets
+ *  Int : Number of consecutive missing packets
+ *  ....
+ *  Nul
+ *
+ */
+
+FEATURE ( FEATURE_PROTOCOL, "SLAM", DHCP_EB_FEATURE_SLAM, 1 );
+
+/** Default SLAM server port */
+#define SLAM_DEFAULT_PORT 10000
+
+/** Default SLAM multicast IP address */
+#define SLAM_DEFAULT_MULTICAST_IP \
+       ( ( 239 << 24 ) | ( 255 << 16 ) | ( 1 << 8 ) | ( 1 << 0 ) )
+
+/** Default SLAM multicast port */
+#define SLAM_DEFAULT_MULTICAST_PORT 10000
+
+/** Maximum SLAM header length */
+#define SLAM_MAX_HEADER_LEN ( 8 /* transaction id */ + 8 /* total_bytes */ + \
+                             8 /* block_size */ )
+
+/** A SLAM request */
+struct slam_request {
+       /** Reference counter */
+       struct refcnt refcnt;
+
+       /** Data transfer interface */
+       struct xfer_interface xfer;
+       /** Unicast socket */
+       struct xfer_interface socket;
+       /** Multicast socket */
+       struct xfer_interface mc_socket;
+
+       /** NACK timer */
+       struct retry_timer timer;
+
+       /** Cached header */
+       uint8_t header[SLAM_MAX_HEADER_LEN];
+       /** Size of cached header */
+       size_t header_len;
+       /** Total number of bytes in transfer */
+       unsigned long total_bytes;
+       /** Transfer block size */
+       unsigned long block_size;
+       /** Number of blocks in transfer */
+       unsigned long num_blocks;
+       /** Block bitmap */
+       struct bitmap bitmap;
+       /** NACK sent flag */
+       int nack_sent;
+};
+
+/**
+ * Free a SLAM request
+ *
+ * @v refcnt           Reference counter
+ */
+static void slam_free ( struct refcnt *refcnt ) {
+       struct slam_request *slam =
+               container_of ( refcnt, struct slam_request, refcnt );
+
+       bitmap_free ( &slam->bitmap );
+       free ( slam );
+}
+
+/**
+ * Mark SLAM request as complete
+ *
+ * @v slam             SLAM request
+ * @v rc               Return status code
+ */
+static void slam_finished ( struct slam_request *slam, int rc ) {
+       static const uint8_t slam_disconnect[] = { 0 };
+
+       DBGC ( slam, "SLAM %p finished with status code %d (%s)\n",
+              slam, rc, strerror ( rc ) );
+
+       /* Send a disconnect message if we ever sent anything to the
+        * server.
+        */
+       if ( slam->nack_sent ) {
+               xfer_deliver_raw ( &slam->socket, slam_disconnect,
+                                  sizeof ( slam_disconnect ) );
+       }
+
+       /* Stop the retry timer */
+       stop_timer ( &slam->timer );
+
+       /* Close all data transfer interfaces */
+       xfer_nullify ( &slam->socket );
+       xfer_close ( &slam->socket, rc );
+       xfer_nullify ( &slam->mc_socket );
+       xfer_close ( &slam->mc_socket, rc );
+       xfer_nullify ( &slam->xfer );
+       xfer_close ( &slam->xfer, rc );
+}
+
+/****************************************************************************
+ *
+ * TX datapath
+ *
+ */
+
+/**
+ * Add a variable-length value to a SLAM packet
+ *
+ * @v slam             SLAM request
+ * @v iobuf            I/O buffer
+ * @v value            Value to add
+ * @ret rc             Return status code
+ *
+ * Adds a variable-length value to the end of an I/O buffer.  Will
+ * refuse to use the last byte of the I/O buffer; this is to allow
+ * space for the terminating NUL.
+ */
+static int slam_put_value ( struct slam_request *slam,
+                           struct io_buffer *iobuf, unsigned long value ) {
+       uint8_t *data;
+       size_t len;
+       unsigned int i;
+
+       /* Calculate variable length required to store value.  Always
+        * leave at least one byte in the I/O buffer.
+        */
+       len = ( ( flsl ( value ) + 10 ) / 8 );
+       if ( len >= iob_tailroom ( iobuf ) ) {
+               DBGC ( slam, "SLAM %p cannot add %d-byte value\n",
+                      slam, len );
+               return -ENOBUFS;
+       }
+       /* There is no valid way within the protocol that we can end
+        * up trying to push a full-sized long (i.e. without space for
+        * the length encoding).
+        */
+       assert ( len <= sizeof ( value ) );
+
+       /* Add value */
+       data = iob_put ( iobuf, len );
+       for ( i = len ; i-- ; ) {
+               data[i] = value;
+               value >>= 8;
+       }
+       *data |= ( len << 5 );
+       assert ( value == 0 );
+
+       return 0;
+}
+
+/**
+ * Send SLAM NACK packet
+ *
+ * @v slam             SLAM request
+ * @ret rc             Return status code
+ */
+static int slam_tx_nack ( struct slam_request *slam ) {
+       struct io_buffer *iobuf;
+       unsigned int block;
+       unsigned int block_count;
+       int block_present;
+       int last_block_present;
+       uint8_t *nul;
+
+       DBGC ( slam, "SLAM %p transmitting NACK\n", slam );
+
+       /* Mark NACK as sent, so that we know we have to disconnect later */
+       slam->nack_sent = 1;
+
+       /* Use the current block size as a good estimate of how much
+        * data we can fit in a packet.  If we overrun, it seems to be
+        * acceptable to drop information anyway.
+        */
+       iobuf = xfer_alloc_iob ( &slam->socket, slam->block_size );
+       if ( ! iobuf ) {
+               DBGC ( slam, "SLAM %p could not allocate I/O buffer\n",
+                      slam );
+               return -ENOMEM;
+       }
+
+       /* Walk bitmap to construct list */
+       block_count = 0;
+       last_block_present = ( ! 0 );
+       for ( block = 0 ; block < slam->num_blocks ; block++ ) {
+               block_present = ( !! bitmap_test ( &slam->bitmap, block ) );
+               if ( block_present != last_block_present ) {
+                       slam_put_value ( slam, iobuf, block_count );
+                       block_count = 0;
+                       last_block_present = block_present;
+               }
+               block_count++;
+       }
+       slam_put_value ( slam, iobuf, block_count );
+
+       /* Add NUL terminator */
+       nul = iob_put ( iobuf, 1 );
+       *nul = 0;
+
+       /* Transmit packet */
+       return xfer_deliver_iob ( &slam->socket, iobuf );
+}
+
+/**
+ * Handle SLAM retransmission timer expiry
+ *
+ * @v timer            Retry timer
+ * @v fail             Failure indicator
+ */
+static void slam_timer_expired ( struct retry_timer *timer, int fail ) {
+       struct slam_request *slam =
+               container_of ( timer, struct slam_request, timer );
+
+       if ( fail ) {
+               slam_finished ( slam, -ETIMEDOUT );
+       } else {
+               start_timer ( timer );
+               slam_tx_nack ( slam );
+       }
+}
+
+/****************************************************************************
+ *
+ * RX datapath
+ *
+ */
+
+/**
+ * Read and strip a variable-length value from a SLAM packet
+ *
+ * @v slam             SLAM request
+ * @v iobuf            I/O buffer
+ * @v value            Value to fill in, or NULL to ignore value
+ * @ret rc             Return status code
+ *
+ * Reads a variable-length value from the start of the I/O buffer.  
+ */
+static int slam_pull_value ( struct slam_request *slam,
+                            struct io_buffer *iobuf,
+                            unsigned long *value ) {
+       uint8_t *data;
+       size_t len;
+
+       /* Sanity check */
+       if ( iob_len ( iobuf ) == 0 ) {
+               DBGC ( slam, "SLAM %p empty value\n", slam );
+               return -EINVAL;
+       }
+
+       /* Read and verify length of value */
+       data = iobuf->data;
+       len = ( *data >> 5 );
+       if ( ( len == 0 ) ||
+            ( value && ( len > sizeof ( *value ) ) ) ) {
+               DBGC ( slam, "SLAM %p invalid value length %d bytes\n",
+                      slam, len );
+               return -EINVAL;
+       }
+       if ( len > iob_len ( iobuf ) ) {
+               DBGC ( slam, "SLAM %p value extends beyond I/O buffer\n",
+                      slam );
+               return -EINVAL;
+       }
+
+       /* Read value */
+       iob_pull ( iobuf, len );
+       *value = ( *data & 0x1f );
+       while ( --len ) {
+               *value <<= 8;
+               *value |= *(++data);
+       }
+
+       return 0;
+}
+
+/**
+ * Read and strip SLAM header
+ *
+ * @v slam             SLAM request
+ * @v iobuf            I/O buffer
+ * @ret rc             Return status code
+ */
+static int slam_pull_header ( struct slam_request *slam,
+                             struct io_buffer *iobuf ) {
+       void *header = iobuf->data;
+       int rc;
+
+       /* If header matches cached header, just pull it and return */
+       if ( ( slam->header_len <= iob_len ( iobuf ) ) &&
+            ( memcmp ( slam->header, iobuf->data, slam->header_len ) == 0 )){
+               iob_pull ( iobuf, slam->header_len );
+               return 0;
+       }
+
+       DBGC ( slam, "SLAM %p detected changed header; resetting\n", slam );
+
+       /* Read and strip transaction ID, total number of bytes, and
+        * block size.
+        */
+       if ( ( rc = slam_pull_value ( slam, iobuf, NULL ) ) != 0 )
+               return rc;
+       if ( ( rc = slam_pull_value ( slam, iobuf,
+                                     &slam->total_bytes ) ) != 0 )
+               return rc;
+       if ( ( rc = slam_pull_value ( slam, iobuf,
+                                     &slam->block_size ) ) != 0 )
+               return rc;
+
+       /* Update the cached header */
+       slam->header_len = ( iobuf->data - header );
+       assert ( slam->header_len <= sizeof ( slam->header ) );
+       memcpy ( slam->header, header, slam->header_len );
+
+       /* Calculate number of blocks */
+       slam->num_blocks = ( ( slam->total_bytes + slam->block_size - 1 ) /
+                            slam->block_size );
+
+       DBGC ( slam, "SLAM %p has total bytes %ld, block size %ld, num "
+              "blocks %ld\n", slam, slam->total_bytes, slam->block_size,
+              slam->num_blocks );
+
+       /* Discard and reset the bitmap */
+       bitmap_free ( &slam->bitmap );
+       memset ( &slam->bitmap, 0, sizeof ( slam->bitmap ) );
+
+       /* Allocate a new bitmap */
+       if ( ( rc = bitmap_resize ( &slam->bitmap,
+                                   slam->num_blocks ) ) != 0 ) {
+               /* Failure to allocate a bitmap is fatal */
+               DBGC ( slam, "SLAM %p could not allocate bitmap for %ld "
+                      "blocks: %s\n", slam, slam->num_blocks,
+                      strerror ( rc ) );
+               slam_finished ( slam, rc );
+               return rc;
+       }
+
+       /* Notify recipient of file size */
+       xfer_seek ( &slam->xfer, slam->total_bytes, SEEK_SET );
+
+       return 0;
+}
+
+/**
+ * Receive SLAM data packet
+ *
+ * @v mc_socket                SLAM multicast socket
+ * @v iobuf            I/O buffer
+ * @ret rc             Return status code
+ */
+static int slam_mc_socket_deliver ( struct xfer_interface *mc_socket,
+                                   struct io_buffer *iobuf,
+                                   struct xfer_metadata *rx_meta __unused ) {
+       struct slam_request *slam =
+               container_of ( mc_socket, struct slam_request, mc_socket );
+       struct xfer_metadata meta;
+       unsigned long packet;
+       size_t len;
+       int rc;
+
+       /* Hit the timer */
+       stop_timer ( &slam->timer );
+       start_timer ( &slam->timer );
+
+       /* Read and strip packet header */
+       if ( ( rc = slam_pull_header ( slam, iobuf ) ) != 0 )
+               goto err_discard;
+
+       /* Read and strip packet number */
+       if ( ( rc = slam_pull_value ( slam, iobuf, &packet ) ) != 0 )
+               goto err_discard;
+
+       /* Sanity check packet number */
+       if ( packet >= slam->num_blocks ) {
+               DBGC ( slam, "SLAM %p received out-of-range packet %ld "
+                      "(num_blocks=%ld)\n", slam, packet, slam->num_blocks );
+               rc = -EINVAL;
+               goto err_discard;
+       }
+
+       /* Sanity check length */
+       len = iob_len ( iobuf );
+       if ( len > slam->block_size ) {
+               DBGC ( slam, "SLAM %p received oversize packet of %zd bytes "
+                      "(block_size=%ld)\n", slam, len, slam->block_size );
+               rc = -EINVAL;
+               goto err_discard;
+       }
+       if ( ( packet != ( slam->num_blocks - 1 ) ) &&
+            ( len < slam->block_size ) ) {
+               DBGC ( slam, "SLAM %p received short packet of %zd bytes "
+                      "(block_size=%ld)\n", slam, len, slam->block_size );
+               rc = -EINVAL;
+               goto err_discard;
+       }
+
+       /* If we have already seen this packet, discard it */
+       if ( bitmap_test ( &slam->bitmap, packet ) ) {
+               goto discard;
+       }
+
+       /* Pass to recipient */
+       memset ( &meta, 0, sizeof ( meta ) );
+       meta.whence = SEEK_SET;
+       meta.offset = ( packet * slam->block_size );
+       if ( ( rc = xfer_deliver_iob_meta ( &slam->xfer, iobuf,
+                                           &meta ) ) != 0 )
+               goto err;
+
+       /* Mark block as received */
+       bitmap_set ( &slam->bitmap, packet );
+
+       /* If we have received all blocks, terminate */
+       if ( bitmap_full ( &slam->bitmap ) )
+               slam_finished ( slam, 0 );
+
+       return 0;
+
+ err_discard:
+ discard:
+       free_iob ( iobuf );
+ err:
+       return rc;
+}
+
+/**
+ * Receive SLAM non-data packet
+ *
+ * @v socket           SLAM unicast socket
+ * @v iobuf            I/O buffer
+ * @ret rc             Return status code
+ */
+static int slam_socket_deliver ( struct xfer_interface *socket,
+                                struct io_buffer *iobuf,
+                                struct xfer_metadata *rx_meta __unused ) {
+       struct slam_request *slam =
+               container_of ( socket, struct slam_request, socket );
+       int rc;
+
+       /* Hit the timer */
+       stop_timer ( &slam->timer );
+       start_timer ( &slam->timer );
+
+       /* Read and strip packet header */
+       if ( ( rc = slam_pull_header ( slam, iobuf ) ) != 0 )
+               goto discard;
+
+       /* Sanity check */
+       if ( iob_len ( iobuf ) != 0 ) {
+               DBGC ( slam, "SLAM %p received trailing garbage:\n", slam );
+               DBGC_HD ( slam, iobuf->data, iob_len ( iobuf ) );
+               rc = -EINVAL;
+               goto discard;
+       }
+
+       /* Discard packet */
+       free_iob ( iobuf );
+
+       /* Send NACK in reply */
+       slam_tx_nack ( slam );
+
+       return 0;
+
+ discard:
+       free_iob ( iobuf );
+       return rc;
+
+}
+
+/**
+ * Close SLAM unicast socket
+ *
+ * @v socket           SLAM unicast socket
+ * @v rc               Reason for close
+ */
+static void slam_socket_close ( struct xfer_interface *socket, int rc ) {
+       struct slam_request *slam =
+               container_of ( socket, struct slam_request, socket );
+
+       DBGC ( slam, "SLAM %p unicast socket closed: %s\n",
+              slam, strerror ( rc ) );
+
+       slam_finished ( slam, rc );
+}
+
+/** SLAM unicast socket data transfer operations */
+static struct xfer_interface_operations slam_socket_operations = {
+       .close          = slam_socket_close,
+       .vredirect      = xfer_vopen,
+       .window         = unlimited_xfer_window,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = slam_socket_deliver,
+       .deliver_raw    = xfer_deliver_as_iob,
+};
+
+/**
+ * Close SLAM multicast socket
+ *
+ * @v mc_socket                SLAM multicast socket
+ * @v rc               Reason for close
+ */
+static void slam_mc_socket_close ( struct xfer_interface *mc_socket, int rc ){
+       struct slam_request *slam =
+               container_of ( mc_socket, struct slam_request, mc_socket );
+
+       DBGC ( slam, "SLAM %p multicast socket closed: %s\n",
+              slam, strerror ( rc ) );
+
+       slam_finished ( slam, rc );
+}
+
+/** SLAM multicast socket data transfer operations */
+static struct xfer_interface_operations slam_mc_socket_operations = {
+       .close          = slam_mc_socket_close,
+       .vredirect      = xfer_vopen,
+       .window         = unlimited_xfer_window,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = slam_mc_socket_deliver,
+       .deliver_raw    = xfer_deliver_as_iob,
+};
+
+/****************************************************************************
+ *
+ * Data transfer interface
+ *
+ */
+
+/**
+ * Close SLAM data transfer interface
+ *
+ * @v xfer             SLAM data transfer interface
+ * @v rc               Reason for close
+ */
+static void slam_xfer_close ( struct xfer_interface *xfer, int rc ) {
+       struct slam_request *slam =
+               container_of ( xfer, struct slam_request, xfer );
+
+       DBGC ( slam, "SLAM %p data transfer interface closed: %s\n",
+              slam, strerror ( rc ) );
+
+       slam_finished ( slam, rc );
+}
+
+/** SLAM data transfer operations */
+static struct xfer_interface_operations slam_xfer_operations = {
+       .close          = slam_xfer_close,
+       .vredirect      = ignore_xfer_vredirect,
+       .window         = unlimited_xfer_window,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = xfer_deliver_as_raw,
+       .deliver_raw    = ignore_xfer_deliver_raw,
+};
+
+/**
+ * Parse SLAM URI multicast address
+ *
+ * @v slam             SLAM request
+ * @v path             Path portion of x-slam:// URI
+ * @v address          Socket address to fill in
+ * @ret rc             Return status code
+ */
+static int slam_parse_multicast_address ( struct slam_request *slam,
+                                         const char *path,
+                                         struct sockaddr_in *address ) {
+       char path_dup[ strlen ( path ) + 1 ];
+       char *sep;
+
+       /* Create temporary copy of path */
+       memcpy ( path_dup, path, sizeof ( path_dup ) );
+
+       /* Parse port, if present */
+       sep = strchr ( path_dup, ':' );
+       if ( sep ) {
+               *(sep++) = '\0';
+               address->sin_port = htons ( strtoul ( sep, &sep, 0 ) );
+               if ( *sep != '\0' ) {
+                       DBGC ( slam, "SLAM %p invalid multicast port\n",
+                              slam );
+                       return -EINVAL;
+               }
+       }
+
+       /* Parse address */
+       if ( inet_aton ( path_dup, &address->sin_addr ) == 0 ) {
+               DBGC ( slam, "SLAM %p invalid multicast address\n", slam );
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+/**
+ * Initiate a SLAM request
+ *
+ * @v xfer             Data transfer interface
+ * @v uri              Uniform Resource Identifier
+ * @ret rc             Return status code
+ */
+static int slam_open ( struct xfer_interface *xfer, struct uri *uri ) {
+       static const struct sockaddr_in default_multicast = {
+               .sin_family = AF_INET,
+               .sin_port = htons ( SLAM_DEFAULT_MULTICAST_PORT ),
+               .sin_addr = { htonl ( SLAM_DEFAULT_MULTICAST_IP ) },
+       };
+       struct slam_request *slam;
+       struct sockaddr_tcpip server;
+       struct sockaddr_in multicast;
+       int rc;
+
+       /* Sanity checks */
+       if ( ! uri->host )
+               return -EINVAL;
+
+       /* Allocate and populate structure */
+       slam = zalloc ( sizeof ( *slam ) );
+       if ( ! slam )
+               return -ENOMEM;
+       slam->refcnt.free = slam_free;
+       xfer_init ( &slam->xfer, &slam_xfer_operations, &slam->refcnt );
+       xfer_init ( &slam->socket, &slam_socket_operations, &slam->refcnt );
+       xfer_init ( &slam->mc_socket, &slam_mc_socket_operations,
+                   &slam->refcnt );
+       slam->timer.expired = slam_timer_expired;
+       /* Fake an invalid cached header of { 0x00, ... } */
+       slam->header_len = 1;
+       /* Fake parameters for initial NACK */
+       slam->block_size = 512;
+       slam->num_blocks = 1;
+       if ( ( rc = bitmap_resize ( &slam->bitmap, 1 ) ) != 0 ) {
+               DBGC ( slam, "SLAM %p could not allocate initial bitmap: "
+                      "%s\n", slam, strerror ( rc ) );
+               goto err;
+       }
+
+       /* Open unicast socket */
+       memset ( &server, 0, sizeof ( server ) );
+       server.st_port = htons ( uri_port ( uri, SLAM_DEFAULT_PORT ) );
+       if ( ( rc = xfer_open_named_socket ( &slam->socket, SOCK_DGRAM,
+                                            ( struct sockaddr * ) &server,
+                                            uri->host, NULL ) ) != 0 ) {
+               DBGC ( slam, "SLAM %p could not open unicast socket: %s\n",
+                      slam, strerror ( rc ) );
+               goto err;
+       }
+
+       /* Open multicast socket */
+       memcpy ( &multicast, &default_multicast, sizeof ( multicast ) );
+       if ( uri->path && 
+            ( ( rc = slam_parse_multicast_address ( slam, uri->path,
+                                                    &multicast ) ) != 0 ) ) {
+               goto err;
+       }
+       if ( ( rc = xfer_open_socket ( &slam->mc_socket, SOCK_DGRAM,
+                                ( struct sockaddr * ) &multicast,
+                                ( struct sockaddr * ) &multicast ) ) != 0 ) {
+               DBGC ( slam, "SLAM %p could not open multicast socket: %s\n",
+                      slam, strerror ( rc ) );
+               goto err;
+       }
+
+       /* Start retry timer */
+       start_timer ( &slam->timer );
+
+       /* Attach to parent interface, mortalise self, and return */
+       xfer_plug_plug ( &slam->xfer, xfer );
+       ref_put ( &slam->refcnt );
+       return 0;
+
+ err:
+       slam_finished ( slam, rc );
+       ref_put ( &slam->refcnt );
+       return rc;
+}
+
+/** SLAM URI opener */
+struct uri_opener slam_uri_opener __uri_opener = {
+       .scheme = "x-slam",
+       .open   = slam_open,
+};
diff --git a/src/proto/slam.c b/src/proto/slam.c
deleted file mode 100644 (file)
index a25c30d..0000000
+++ /dev/null
@@ -1,541 +0,0 @@
-#if 0
-
-/*
- * IMPORTANT
- *
- * This file should be rewritten to avoid the use of a bitmap.  Our
- * buffer routines can cope with being handed blocks in an arbitrary
- * order, duplicate blocks, etc.  This code could be substantially
- * simplified by taking advantage of these features.
- *
- */
-
-#define SLAM_PORT 10000
-#define SLAM_MULTICAST_IP ((239<<24)|(255<<16)|(1<<8)|(1<<0))
-#define SLAM_MULTICAST_PORT 10000
-#define SLAM_LOCAL_PORT 10000
-
-/* Set the timeout intervals to at least 1 second so
- * on a 100Mbit ethernet can receive 10000 packets
- * in one second.  
- *
- * The only case that is likely to trigger all of the nodes
- * firing a nack packet is a slow server.  The odds of this
- * happening could be reduced being slightly smarter and utilizing 
- * the multicast channels for nacks.   But that only improves the odds
- * it doesn't improve the worst case.  So unless this proves to be
- * a common case having the control data going unicast should increase
- * the odds of the data not being dropped.  
- *
- * When doing exponential backoff we increase just the timeout
- * interval and not the base to optimize for throughput.  This is only
- * expected to happen when the server is down.  So having some nodes
- * pinging immediately should get the transmission restarted quickly after a
- * server restart.  The host nic won't be to baddly swamped because of
- * the random distribution of the nodes.
- *
- */
-#define SLAM_INITIAL_MIN_TIMEOUT      (TICKS_PER_SEC/3)
-#define SLAM_INITIAL_TIMEOUT_INTERVAL (TICKS_PER_SEC)
-#define SLAM_BASE_MIN_TIMEOUT         (2*TICKS_PER_SEC)
-#define SLAM_BASE_TIMEOUT_INTERVAL    (4*TICKS_PER_SEC)
-#define SLAM_BACKOFF_LIMIT 5
-#define SLAM_MAX_RETRIES 20
-
-/*** Packets Formats ***
- * Data Packet:
- *   transaction
- *   total bytes
- *   block size
- *   packet #
- *   data
- *
- * Status Request Packet
- *   transaction
- *   total bytes
- *   block size
- *
- * Status Packet
- *   received packets
- *   requested packets
- *   received packets
- *   requested packets
- *   ...
- *   received packets
- *   requested packtes
- *   0
- */
-
-#define MAX_HDR (7 + 7 + 7) /* transaction, total size, block size */
-#define MIN_HDR (1 + 1 + 1) /* transactino, total size, block size */
-
-#define MAX_SLAM_REQUEST MAX_HDR
-#define MIN_SLAM_REQUEST MIN_HDR
-
-#define MIN_SLAM_DATA (MIN_HDR + 1)
-
-static struct slam_nack {
-       struct iphdr ip;
-       struct udphdr udp;
-       unsigned char data[ETH_MAX_MTU - 
-               (sizeof(struct iphdr) + sizeof(struct udphdr))];
-} nack;
-
-struct slam_state {
-       unsigned char hdr[MAX_HDR];
-       unsigned long hdr_len;
-       unsigned long block_size;
-       unsigned long total_bytes;
-       unsigned long total_packets;
-
-       unsigned long received_packets;
-
-       struct buffer *buffer;
-       unsigned char *image;
-       unsigned char *bitmap;
-} state;
-
-
-static void init_slam_state(void)
-{
-       state.hdr_len = sizeof(state.hdr);
-       memset(state.hdr, 0, state.hdr_len);
-       state.block_size = 0;
-       state.total_packets = 0;
-
-       state.received_packets = 0;
-
-       state.image = 0;
-       state.bitmap = 0;
-}
-
-struct slam_info {
-       struct sockaddr_in server;
-       struct sockaddr_in local;
-       struct sockaddr_in multicast;
-       int sent_nack;
-       struct buffer *buffer;
-};
-
-#define SLAM_TIMEOUT 0
-#define SLAM_REQUEST 1
-#define SLAM_DATA    2
-static int await_slam(int ival __unused, void *ptr,
-                     unsigned short ptype __unused, struct iphdr *ip,
-                     struct udphdr *udp, struct tcphdr *tcp __unused)
-{
-       struct slam_info *info = ptr;
-       if (!udp) {
-               return 0;
-       }
-       /* I can receive two kinds of packets here, a multicast data packet,
-        * or a unicast request for information 
-        */
-       /* Check for a data request packet */
-       if ((ip->dest.s_addr == arptable[ARP_CLIENT].ipaddr.s_addr) &&
-               (ntohs(udp->dest) == info->local.sin_port) && 
-               (nic.packetlen >= 
-                       ETH_HLEN + 
-                       sizeof(struct iphdr) + 
-                       sizeof(struct udphdr) +
-                       MIN_SLAM_REQUEST)) {
-               return SLAM_REQUEST;
-       }
-       /* Check for a multicast data packet */
-       if ((ip->dest.s_addr == info->multicast.sin_addr.s_addr) &&
-               (ntohs(udp->dest) == info->multicast.sin_port) &&
-               (nic.packetlen >= 
-                       ETH_HLEN + 
-                       sizeof(struct iphdr) + 
-                       sizeof(struct udphdr) +
-                       MIN_SLAM_DATA)) {
-               return SLAM_DATA;
-       }
-#if 0
-       printf("#");
-       printf("dest: %@ port: %d len: %d\n", 
-               ip->dest.s_addr, ntohs(udp->dest), nic.packetlen);
-#endif
-       return 0;
-               
-}
-
-static int slam_encode(
-       unsigned char **ptr, unsigned char *end, unsigned long value)
-{
-       unsigned char *data = *ptr;
-       int bytes;
-       bytes = sizeof(value);
-       while ((bytes > 0) && ((0xff & (value >> ((bytes -1)<<3))) == 0)) {
-               bytes--;
-       }
-       if (bytes <= 0) {
-               bytes = 1;
-       }
-       if (data + bytes >= end) {
-               return -1;
-       }
-       if ((0xe0 & (value >> ((bytes -1)<<3))) == 0) {
-               /* packed together */
-               *data = (bytes << 5) | (value >> ((bytes -1)<<3));
-       } else {
-               bytes++;
-               *data = (bytes << 5);
-       }
-       bytes--;
-       data++;
-       while(bytes) {
-               *(data++) = 0xff & (value >> ((bytes -1)<<3));
-               bytes--;
-       }
-       *ptr = data;
-       return 0;
-}
-
-static int slam_skip(unsigned char **ptr, unsigned char *end) 
-{
-       int bytes;
-       if (*ptr >= end) {
-               return -1;
-       }
-       bytes = ((**ptr) >> 5) & 7;
-       if (bytes == 0) {
-               return -1;
-       }
-       if (*ptr + bytes >= end) {
-               return -1;
-       }
-       (*ptr) += bytes;
-       return 0;
-       
-}
-
-static unsigned long slam_decode(unsigned char **ptr, unsigned char *end,
-                                int *err)
-{
-       unsigned long value;
-       unsigned bytes;
-       if (*ptr >= end) {
-               *err = -1;
-       }
-       bytes = ((**ptr) >> 5) & 7;
-       if ((bytes == 0) || (bytes > sizeof(unsigned long))) {
-               *err = -1;
-               return 0;
-       }
-       if ((*ptr) + bytes >= end) {
-               *err =  -1;
-       }
-       value = (**ptr) & 0x1f;
-       bytes--;
-       (*ptr)++;
-       while(bytes) {
-               value <<= 8;
-               value |= **ptr;
-               (*ptr)++;
-               bytes--;
-       }
-       return value;
-}
-
-
-static long slam_sleep_interval(int exp)
-{
-       long range;
-       long divisor;
-       long interval;
-       range = SLAM_BASE_TIMEOUT_INTERVAL;
-       if (exp < 0) { 
-               divisor = RAND_MAX/SLAM_INITIAL_TIMEOUT_INTERVAL;
-       } else {
-               if (exp > SLAM_BACKOFF_LIMIT) 
-                       exp = SLAM_BACKOFF_LIMIT;
-               divisor = RAND_MAX/(range << exp);
-       }
-       interval = random()/divisor;
-       if (exp < 0) {
-               interval += SLAM_INITIAL_MIN_TIMEOUT;
-       } else {
-               interval += SLAM_BASE_MIN_TIMEOUT;
-       }
-       return interval;
-}
-
-
-static unsigned char *reinit_slam_state(
-       unsigned char *header, unsigned char *end)
-{
-       unsigned long total_bytes;
-       unsigned long block_size;
-
-       unsigned long bitmap_len;
-       unsigned long max_packet_len;
-       unsigned char *data;
-       int err;
-
-#if 0
-       printf("reinit\n");
-#endif
-       data = header;
-
-       state.hdr_len = 0;
-       err = slam_skip(&data, end); /* transaction id */
-       total_bytes = slam_decode(&data, end, &err);
-       block_size  = slam_decode(&data, end, &err);
-       if (err) {
-               printf("ALERT: slam size out of range\n");
-               return 0;
-       }
-       state.block_size = block_size;
-       state.total_bytes = total_bytes;
-       state.total_packets = (total_bytes + block_size - 1)/block_size;
-       state.hdr_len = data - header;
-       state.received_packets = 0;
-
-       data = state.hdr;
-       slam_encode(&data, &state.hdr[sizeof(state.hdr)], state.total_packets);
-       max_packet_len = data - state.hdr;
-       memcpy(state.hdr, header, state.hdr_len);
-       
-#if 0
-       printf("block_size:     %ld\n", block_size);
-       printf("total_bytes:    %ld\n", total_bytes);
-       printf("total_packets:  %ld\n", state.total_packets);
-       printf("hdr_len:        %ld\n", state.hdr_len);
-       printf("max_packet_len: %ld\n", max_packet_len);
-#endif
-
-       if (state.block_size > ETH_MAX_MTU - (
-               sizeof(struct iphdr) + sizeof(struct udphdr) +
-               state.hdr_len + max_packet_len)) {
-               printf("ALERT: slam blocksize to large\n");
-               return 0;
-       }
-       bitmap_len   = (state.total_packets + 1 + 7)/8;
-       state.image  = phys_to_virt ( state.buffer->addr );
-       /* We don't use the buffer routines properly yet; fake it */
-       state.buffer->fill = total_bytes;
-       state.bitmap = state.image + total_bytes;
-       if ((unsigned long)state.image < 1024*1024) {
-               printf("ALERT: slam filesize to large for available memory\n");
-               return 0;
-       }
-       memset(state.bitmap, 0, bitmap_len);
-
-       return header + state.hdr_len;
-}
-
-static int slam_recv_data(unsigned char *data)
-{
-       unsigned long packet;
-       unsigned long data_len;
-       int err;
-       struct udphdr *udp;
-       udp = (struct udphdr *)&nic.packet[ETH_HLEN + sizeof(struct iphdr)];
-       err = 0;
-       packet = slam_decode(&data, &nic.packet[nic.packetlen], &err);
-       if (err || (packet > state.total_packets)) {
-               printf("ALERT: Invalid packet number\n");
-               return 0;
-       }
-       /* Compute the expected data length */
-       if (packet != state.total_packets -1) {
-               data_len = state.block_size;
-       } else {
-               data_len = state.total_bytes % state.block_size;
-       }
-       /* If the packet size is wrong drop the packet and then continue */
-       if (ntohs(udp->len) != (data_len + (data - (unsigned char*)udp))) {
-               printf("ALERT: udp packet is not the correct size\n");
-               return 1;
-       }
-       if (nic.packetlen < data_len + (data - nic.packet)) {
-               printf("ALERT: Ethernet packet shorter than data_len\n");
-               return 1;
-       }
-       if (data_len > state.block_size) {
-               data_len = state.block_size;
-       }
-       if (((state.bitmap[packet >> 3] >> (packet & 7)) & 1) == 0) {
-               /* Non duplicate packet */
-               state.bitmap[packet >> 3] |= (1 << (packet & 7));
-               memcpy(state.image + (packet*state.block_size), data, data_len);
-               state.received_packets++;
-       } else {
-#ifdef MDEBUG
-               printf("<DUP>\n");
-#endif
-       }
-       return 1;
-}
-
-static void transmit_nack(unsigned char *ptr, struct slam_info *info)
-{
-       int nack_len;
-       /* Ensure the packet is null terminated */
-       *ptr++ = 0;
-       nack_len = ptr - (unsigned char *)&nack;
-       build_udp_hdr(info->server.sin_addr.s_addr, info->local.sin_port,
-                     info->server.sin_port, 1, nack_len, &nack);
-       ip_transmit(nack_len, &nack);
-#if defined(MDEBUG) && 0
-       printf("Sent NACK to %@ bytes: %d have:%ld/%ld\n", 
-               info->server_ip, nack_len,
-               state.received_packets, state.total_packets);
-#endif
-}
-
-static void slam_send_nack(struct slam_info *info)
-{
-       unsigned char *ptr, *end;
-       /* Either I timed out or I was explicitly 
-        * asked for a request packet 
-        */
-       ptr = &nack.data[0];
-       /* Reserve space for the trailling null */
-       end = &nack.data[sizeof(nack.data) -1]; 
-       if (!state.bitmap) {
-               slam_encode(&ptr, end, 0);
-               slam_encode(&ptr, end, 1);
-       }
-       else {
-               /* Walk the bitmap */
-               unsigned long i;
-               unsigned long len;
-               unsigned long max;
-               int value;
-               int last;
-               /* Compute the last bit and store an inverted trailer */
-               max = state.total_packets;
-               value = ((state.bitmap[(max -1) >> 3] >> ((max -1) & 7) ) & 1);
-               value = !value;
-               state.bitmap[max >> 3] &= ~(1 << (max & 7));
-               state.bitmap[max >> 3] |= value << (max & 7);
-
-               len = 0;
-               last = 1; /* Start with the received packets */
-               for(i = 0; i <= max; i++) {
-                       value = (state.bitmap[i>>3] >> (i & 7)) & 1;
-                       if (value == last) {
-                               len++;
-                       } else {
-                               if (slam_encode(&ptr, end, len))
-                                       break;
-                               last = value;
-                               len = 1;
-                       }
-               }
-       }
-       info->sent_nack = 1;
-       transmit_nack(ptr, info);
-}
-
-static void slam_send_disconnect(struct slam_info *info)
-{
-       if (info->sent_nack) {
-               /* A disconnect is a packet with just the null terminator */
-               transmit_nack(&nack.data[0], info);
-       }
-       info->sent_nack = 0;
-}
-
-
-static int proto_slam(struct slam_info *info)
-{
-       int retry;
-       long timeout;
-
-       init_slam_state();
-       state.buffer = info->buffer;
-
-       retry = -1;
-       rx_qdrain();
-       /* Arp for my server */
-       if (arptable[ARP_SERVER].ipaddr.s_addr != info->server.sin_addr.s_addr) {
-               arptable[ARP_SERVER].ipaddr.s_addr = info->server.sin_addr.s_addr;
-               memset(arptable[ARP_SERVER].node, 0, ETH_ALEN);
-       }
-       /* If I'm running over multicast join the multicast group */
-       join_group(IGMP_SERVER, info->multicast.sin_addr.s_addr);
-       for(;;) {
-               unsigned char *header;
-               unsigned char *data;
-               int type;
-               header = data = 0;
-
-               timeout = slam_sleep_interval(retry);
-               type = await_reply(await_slam, 0, info, timeout);
-               /* Compute the timeout for next time */
-               if (type == SLAM_TIMEOUT) {
-                       /* If I timeouted recompute the next timeout */
-                       if (retry++ > SLAM_MAX_RETRIES) {
-                               return 0;
-                       }
-               } else {
-                       retry = 0;
-               }
-               if ((type == SLAM_DATA) || (type == SLAM_REQUEST)) {
-                       /* Check the incomming packet and reinit the data 
-                        * structures if necessary.
-                        */
-                       header = &nic.packet[ETH_HLEN + 
-                               sizeof(struct iphdr) + sizeof(struct udphdr)];
-                       data = header + state.hdr_len;
-                       if (memcmp(state.hdr, header, state.hdr_len) != 0) {
-                               /* Something is fishy reset the transaction */
-                               data = reinit_slam_state(header, &nic.packet[nic.packetlen]);
-                               if (!data) {
-                                       return 0;
-                               }
-                       }
-               }
-               if (type == SLAM_DATA) {
-                       if (!slam_recv_data(data)) {
-                               return 0;
-                       }
-                       if (state.received_packets == state.total_packets) {
-                               /* We are done get out */
-                               break;
-                       }
-               }
-               if ((type == SLAM_TIMEOUT) || (type == SLAM_REQUEST)) {
-                       /* Either I timed out or I was explicitly 
-                        * asked by a request packet 
-                        */
-                       slam_send_nack(info);
-               }
-       }
-       slam_send_disconnect(info);
-
-       /* Leave the multicast group */
-       leave_group(IGMP_SERVER);
-       /* FIXME don't overwrite myself */
-       /* load file to correct location */
-       return 1;
-}
-
-static int url_slam ( char *url __unused, struct sockaddr_in *server,
-                     char *file, struct buffer *buffer ) {
-       struct slam_info info;
-       /* Set the defaults */
-       info.server = *server;
-       info.multicast.sin_addr.s_addr = htonl(SLAM_MULTICAST_IP);
-       info.multicast.sin_port      = SLAM_MULTICAST_PORT;
-       info.local.sin_addr.s_addr   = arptable[ARP_CLIENT].ipaddr.s_addr;
-       info.local.sin_port          = SLAM_LOCAL_PORT;
-       info.buffer                  = buffer;
-       info.sent_nack = 0;
-       if (file[0]) {
-               printf("\nBad url\n");
-               return 0;
-       }
-       return proto_slam(&info);
-}
-
-struct protocol slam_protocol __protocol = {
-       .name = "x-slam",
-       .default_port = SLAM_PORT,
-       .load = url_slam,
-};
-
-#endif