gpxe/src/net/udp/slam.c

   1 /*
   2  * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <strings.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27 #include <byteswap.h>
  28 #include <gpxe/features.h>
  29 #include <gpxe/iobuf.h>
  30 #include <gpxe/bitmap.h>
  31 #include <gpxe/xfer.h>
  32 #include <gpxe/open.h>
  33 #include <gpxe/uri.h>
  34 #include <gpxe/tcpip.h>
  35 #include <gpxe/timer.h>
  36 #include <gpxe/retry.h>
  37
  38 /** @file
  39  *
  40  * Scalable Local Area Multicast protocol
  41  *
  42  * The SLAM protocol is supported only by Etherboot; it was designed
  43  * and implemented by Eric Biederman.  A server implementation is
  44  * available in contrib/mini-slamd.  There does not appear to be any
  45  * documentation beyond a few sparse comments in Etherboot's
  46  * proto_slam.c.
  47  *
  48  * SLAM packets use three types of data field:
  49  *
  50  *  Nul : A single NUL (0) byte, used as a list terminator
  51  *
  52  *  Raw : A block of raw data
  53  *
  54  *  Int : A variable-length integer, in big-endian order.  The length
  55  *        of the integer is encoded in the most significant three bits.
  56  *
  57  * Packets received by the client have the following layout:
  58  *
  59  *  Int : Transaction identifier.  This is an opaque value.
  60  *
  61  *  Int : Total number of bytes in the transfer.
  62  *
  63  *  Int : Block size, in bytes.
  64  *
  65  *  Int : Packet sequence number within the transfer (if this packet
  66  *        contains data).
  67  *
  68  *  Raw : Packet data (if this packet contains data).
  69  *
  70  * Packets transmitted by the client consist of a run-length-encoded
  71  * representation of the received-blocks bitmap, looking something
  72  * like:
  73  *
  74  *  Int : Number of consecutive successfully-received packets
  75  *  Int : Number of consecutive missing packets
  76  *  Int : Number of consecutive successfully-received packets
  77  *  Int : Number of consecutive missing packets
  78  *  ....
  79  *  Nul
  80  *
  81  */
  82
  83 FEATURE ( FEATURE_PROTOCOL, "SLAM", DHCP_EB_FEATURE_SLAM, 1 );
  84
  85 /** Default SLAM server port */
  86 #define SLAM_DEFAULT_PORT 10000
  87
  88 /** Default SLAM multicast IP address */
  89 #define SLAM_DEFAULT_MULTICAST_IP \
  90         ( ( 239 << 24 ) | ( 255 << 16 ) | ( 1 << 8 ) | ( 1 << 0 ) )
  91
  92 /** Default SLAM multicast port */
  93 #define SLAM_DEFAULT_MULTICAST_PORT 10000
  94
  95 /** Maximum SLAM header length */
  96 #define SLAM_MAX_HEADER_LEN ( 7 /* transaction id */ + 7 /* total_bytes */ + \
  97                               7 /* block_size */ )
  98
  99 /** Maximum number of blocks to request per NACK
 100  *
 101  * This is a policy decision equivalent to selecting a TCP window
 102  * size.
 103  */
 104 #define SLAM_MAX_BLOCKS_PER_NACK 4
 105
 106 /** Maximum SLAM NACK length
 107  *
 108  * We only ever send a NACK for a single range of up to @c
 109  * SLAM_MAX_BLOCKS_PER_NACK blocks.
 110  */
 111 #define SLAM_MAX_NACK_LEN ( 7 /* block */ + 7 /* #blocks */ + 1 /* NUL */ )
 112
 113 /** SLAM slave timeout */
 114 #define SLAM_SLAVE_TIMEOUT ( 1 * TICKS_PER_SEC )
 115
 116 /** A SLAM request */
 117 struct slam_request {
 118         /** Reference counter */
 119         struct refcnt refcnt;
 120
 121         /** Data transfer interface */
 122         struct xfer_interface xfer;
 123         /** Unicast socket */
 124         struct xfer_interface socket;
 125         /** Multicast socket */
 126         struct xfer_interface mc_socket;
 127
 128         /** Master client retry timer */
 129         struct retry_timer master_timer;
 130         /** Slave client retry timer */
 131         struct retry_timer slave_timer;
 132
 133         /** Cached header */
 134         uint8_t header[SLAM_MAX_HEADER_LEN];
 135         /** Size of cached header */
 136         size_t header_len;
 137         /** Total number of bytes in transfer */
 138         unsigned long total_bytes;
 139         /** Transfer block size */
 140         unsigned long block_size;
 141         /** Number of blocks in transfer */
 142         unsigned long num_blocks;
 143         /** Block bitmap */
 144         struct bitmap bitmap;
 145         /** NACK sent flag */
 146         int nack_sent;
 147 };
 148
 149 /**
 150  * Free a SLAM request
 151  *
 152  * @v refcnt            Reference counter
 153  */
 154 static void slam_free ( struct refcnt *refcnt ) {
 155         struct slam_request *slam =
 156                 container_of ( refcnt, struct slam_request, refcnt );
 157
 158         bitmap_free ( &slam->bitmap );
 159         free ( slam );
 160 }
 161
 162 /**
 163  * Mark SLAM request as complete
 164  *
 165  * @v slam              SLAM request
 166  * @v rc                Return status code
 167  */
 168 static void slam_finished ( struct slam_request *slam, int rc ) {
 169         static const uint8_t slam_disconnect[] = { 0 };
 170
 171         DBGC ( slam, "SLAM %p finished with status code %d (%s)\n",
 172                slam, rc, strerror ( rc ) );
 173
 174         /* Send a disconnect message if we ever sent anything to the
 175          * server.
 176          */
 177         if ( slam->nack_sent ) {
 178                 xfer_deliver_raw ( &slam->socket, slam_disconnect,
 179                                    sizeof ( slam_disconnect ) );
 180         }
 181
 182         /* Stop the retry timers */
 183         stop_timer ( &slam->master_timer );
 184         stop_timer ( &slam->slave_timer );
 185
 186         /* Close all data transfer interfaces */
 187         xfer_nullify ( &slam->socket );
 188         xfer_close ( &slam->socket, rc );
 189         xfer_nullify ( &slam->mc_socket );
 190         xfer_close ( &slam->mc_socket, rc );
 191         xfer_nullify ( &slam->xfer );
 192         xfer_close ( &slam->xfer, rc );
 193 }
 194
 195 /****************************************************************************
 196  *
 197  * TX datapath
 198  *
 199  */
 200
 201 /**
 202  * Add a variable-length value to a SLAM packet
 203  *
 204  * @v slam              SLAM request
 205  * @v iobuf             I/O buffer
 206  * @v value             Value to add
 207  * @ret rc              Return status code
 208  *
 209  * Adds a variable-length value to the end of an I/O buffer.  Will
 210  * always leave at least one byte of tailroom in the I/O buffer (to
 211  * allow space for the terminating NUL).
 212  */
 213 static int slam_put_value ( struct slam_request *slam,
 214                             struct io_buffer *iobuf, unsigned long value ) {
 215         uint8_t *data;
 216         size_t len;
 217         unsigned int i;
 218
 219         /* Calculate variable length required to store value.  Always
 220          * leave at least one byte in the I/O buffer.
 221          */
 222         len = ( ( flsl ( value ) + 10 ) / 8 );
 223         if ( len >= iob_tailroom ( iobuf ) ) {
 224                 DBGC2 ( slam, "SLAM %p cannot add %zd-byte value\n",
 225                         slam, len );
 226                 return -ENOBUFS;
 227         }
 228         /* There is no valid way within the protocol that we can end
 229          * up trying to push a full-sized long (i.e. without space for
 230          * the length encoding).
 231          */
 232         assert ( len <= sizeof ( value ) );
 233
 234         /* Add value */
 235         data = iob_put ( iobuf, len );
 236         for ( i = len ; i-- ; ) {
 237                 data[i] = value;
 238                 value >>= 8;
 239         }
 240         *data |= ( len << 5 );
 241         assert ( value == 0 );
 242
 243         return 0;
 244 }
 245
 246 /**
 247  * Send SLAM NACK packet
 248  *
 249  * @v slam              SLAM request
 250  * @ret rc              Return status code
 251  */
 252 static int slam_tx_nack ( struct slam_request *slam ) {
 253         struct io_buffer *iobuf;
 254         unsigned long first_block;
 255         unsigned long num_blocks;
 256         uint8_t *nul;
 257         int rc;
 258
 259         /* Mark NACK as sent, so that we know we have to disconnect later */
 260         slam->nack_sent = 1;
 261
 262         /* Allocate I/O buffer */
 263         iobuf = xfer_alloc_iob ( &slam->socket, SLAM_MAX_NACK_LEN );
 264         if ( ! iobuf ) {
 265                 DBGC ( slam, "SLAM %p could not allocate I/O buffer\n",
 266                        slam );
 267                 return -ENOMEM;
 268         }
 269
 270         /* Construct NACK.  We always request only a single packet;
 271          * this allows us to force multicast-TFTP-style flow control
 272          * on the SLAM server, which will otherwise just blast the
 273          * data out as fast as it can.  On a gigabit network, without
 274          * RX checksumming, this would inevitably cause packet drops.
 275          */
 276         first_block = bitmap_first_gap ( &slam->bitmap );
 277         for ( num_blocks = 1 ; ; num_blocks++ ) {
 278                 if ( num_blocks >= SLAM_MAX_BLOCKS_PER_NACK )
 279                         break;
 280                 if ( ( first_block + num_blocks ) >= slam->num_blocks )
 281                         break;
 282                 if ( bitmap_test ( &slam->bitmap,
 283                                    ( first_block + num_blocks ) ) )
 284                         break;
 285         }
 286         if ( first_block ) {
 287                 DBGCP ( slam, "SLAM %p transmitting NACK for blocks "
 288                         "%ld-%ld\n", slam, first_block,
 289                         ( first_block + num_blocks - 1 ) );
 290         } else {
 291                 DBGC ( slam, "SLAM %p transmitting initial NACK for blocks "
 292                        "0-%ld\n", slam, ( num_blocks - 1 ) );
 293         }
 294         if ( ( rc = slam_put_value ( slam, iobuf, first_block ) ) != 0 )
 295                 return rc;
 296         if ( ( rc = slam_put_value ( slam, iobuf, num_blocks ) ) != 0 )
 297                 return rc;
 298         nul = iob_put ( iobuf, 1 );
 299         *nul = 0;
 300
 301         /* Transmit packet */
 302         return xfer_deliver_iob ( &slam->socket, iobuf );
 303 }
 304
 305 /**
 306  * Handle SLAM master client retry timer expiry
 307  *
 308  * @v timer             Master retry timer
 309  * @v fail              Failure indicator
 310  */
 311 static void slam_master_timer_expired ( struct retry_timer *timer,
 312                                         int fail ) {
 313         struct slam_request *slam =
 314                 container_of ( timer, struct slam_request, master_timer );
 315
 316         if ( fail ) {
 317                 /* Allow timer to stop running.  We will terminate the
 318                  * connection only if the slave timer times out.
 319                  */
 320                 DBGC ( slam, "SLAM %p giving up acting as master client\n",
 321                        slam );
 322         } else {
 323                 /* Retransmit NACK */
 324                 start_timer ( timer );
 325                 slam_tx_nack ( slam );
 326         }
 327 }
 328
 329 /**
 330  * Handle SLAM slave client retry timer expiry
 331  *
 332  * @v timer             Master retry timer
 333  * @v fail              Failure indicator
 334  */
 335 static void slam_slave_timer_expired ( struct retry_timer *timer,
 336                                         int fail ) {
 337         struct slam_request *slam =
 338                 container_of ( timer, struct slam_request, slave_timer );
 339
 340         if ( fail ) {
 341                 /* Terminate connection */
 342                 slam_finished ( slam, -ETIMEDOUT );
 343         } else {
 344                 /* Try sending a NACK */
 345                 DBGC ( slam, "SLAM %p trying to become master client\n",
 346                        slam );
 347                 start_timer ( timer );
 348                 slam_tx_nack ( slam );
 349         }
 350 }
 351
 352 /****************************************************************************
 353  *
 354  * RX datapath
 355  *
 356  */
 357
 358 /**
 359  * Read and strip a variable-length value from a SLAM packet
 360  *
 361  * @v slam              SLAM request
 362  * @v iobuf             I/O buffer
 363  * @v value             Value to fill in, or NULL to ignore value
 364  * @ret rc              Return status code
 365  *
 366  * Reads a variable-length value from the start of the I/O buffer.
 367  */
 368 static int slam_pull_value ( struct slam_request *slam,
 369                              struct io_buffer *iobuf,
 370                              unsigned long *value ) {
 371         uint8_t *data;
 372         size_t len;
 373
 374         /* Sanity check */
 375         if ( iob_len ( iobuf ) == 0 ) {
 376                 DBGC ( slam, "SLAM %p empty value\n", slam );
 377                 return -EINVAL;
 378         }
 379
 380         /* Read and verify length of value */
 381         data = iobuf->data;
 382         len = ( *data >> 5 );
 383         if ( ( len == 0 ) ||
 384              ( value && ( len > sizeof ( *value ) ) ) ) {
 385                 DBGC ( slam, "SLAM %p invalid value length %zd bytes\n",
 386                        slam, len );
 387                 return -EINVAL;
 388         }
 389         if ( len > iob_len ( iobuf ) ) {
 390                 DBGC ( slam, "SLAM %p value extends beyond I/O buffer\n",
 391                        slam );
 392                 return -EINVAL;
 393         }
 394
 395         /* Read value */
 396         iob_pull ( iobuf, len );
 397         *value = ( *data & 0x1f );
 398         while ( --len ) {
 399                 *value <<= 8;
 400                 *value |= *(++data);
 401         }
 402
 403         return 0;
 404 }
 405
 406 /**
 407  * Read and strip SLAM header
 408  *
 409  * @v slam              SLAM request
 410  * @v iobuf             I/O buffer
 411  * @ret rc              Return status code
 412  */
 413 static int slam_pull_header ( struct slam_request *slam,
 414                               struct io_buffer *iobuf ) {
 415         void *header = iobuf->data;
 416         int rc;
 417
 418         /* If header matches cached header, just pull it and return */
 419         if ( ( slam->header_len <= iob_len ( iobuf ) ) &&
 420              ( memcmp ( slam->header, iobuf->data, slam->header_len ) == 0 )){
 421                 iob_pull ( iobuf, slam->header_len );
 422                 return 0;
 423         }
 424
 425         DBGC ( slam, "SLAM %p detected changed header; resetting\n", slam );
 426
 427         /* Read and strip transaction ID, total number of bytes, and
 428          * block size.
 429          */
 430         if ( ( rc = slam_pull_value ( slam, iobuf, NULL ) ) != 0 )
 431                 return rc;
 432         if ( ( rc = slam_pull_value ( slam, iobuf,
 433                                       &slam->total_bytes ) ) != 0 )
 434                 return rc;
 435         if ( ( rc = slam_pull_value ( slam, iobuf,
 436                                       &slam->block_size ) ) != 0 )
 437                 return rc;
 438
 439         /* Update the cached header */
 440         slam->header_len = ( iobuf->data - header );
 441         assert ( slam->header_len <= sizeof ( slam->header ) );
 442         memcpy ( slam->header, header, slam->header_len );
 443
 444         /* Calculate number of blocks */
 445         slam->num_blocks = ( ( slam->total_bytes + slam->block_size - 1 ) /
 446                              slam->block_size );
 447
 448         DBGC ( slam, "SLAM %p has total bytes %ld, block size %ld, num "
 449                "blocks %ld\n", slam, slam->total_bytes, slam->block_size,
 450                slam->num_blocks );
 451
 452         /* Discard and reset the bitmap */
 453         bitmap_free ( &slam->bitmap );
 454         memset ( &slam->bitmap, 0, sizeof ( slam->bitmap ) );
 455
 456         /* Allocate a new bitmap */
 457         if ( ( rc = bitmap_resize ( &slam->bitmap,
 458                                     slam->num_blocks ) ) != 0 ) {
 459                 /* Failure to allocate a bitmap is fatal */
 460                 DBGC ( slam, "SLAM %p could not allocate bitmap for %ld "
 461                        "blocks: %s\n", slam, slam->num_blocks,
 462                        strerror ( rc ) );
 463                 slam_finished ( slam, rc );
 464                 return rc;
 465         }
 466
 467         /* Notify recipient of file size */
 468         xfer_seek ( &slam->xfer, slam->total_bytes, SEEK_SET );
 469
 470         return 0;
 471 }
 472
 473 /**
 474  * Receive SLAM data packet
 475  *
 476  * @v mc_socket         SLAM multicast socket
 477  * @v iobuf             I/O buffer
 478  * @ret rc              Return status code
 479  */
 480 static int slam_mc_socket_deliver ( struct xfer_interface *mc_socket,
 481                                     struct io_buffer *iobuf,
 482                                     struct xfer_metadata *rx_meta __unused ) {
 483         struct slam_request *slam =
 484                 container_of ( mc_socket, struct slam_request, mc_socket );
 485         struct xfer_metadata meta;
 486         unsigned long packet;
 487         size_t len;
 488         int rc;
 489
 490         /* Stop the master client timer.  Restart the slave client timer. */
 491         stop_timer ( &slam->master_timer );
 492         stop_timer ( &slam->slave_timer );
 493         start_timer_fixed ( &slam->slave_timer, SLAM_SLAVE_TIMEOUT );
 494
 495         /* Read and strip packet header */
 496         if ( ( rc = slam_pull_header ( slam, iobuf ) ) != 0 )
 497                 goto err_discard;
 498
 499         /* Read and strip packet number */
 500         if ( ( rc = slam_pull_value ( slam, iobuf, &packet ) ) != 0 )
 501                 goto err_discard;
 502
 503         /* Sanity check packet number */
 504         if ( packet >= slam->num_blocks ) {
 505                 DBGC ( slam, "SLAM %p received out-of-range packet %ld "
 506                        "(num_blocks=%ld)\n", slam, packet, slam->num_blocks );
 507                 rc = -EINVAL;
 508                 goto err_discard;
 509         }
 510
 511         /* Sanity check length */
 512         len = iob_len ( iobuf );
 513         if ( len > slam->block_size ) {
 514                 DBGC ( slam, "SLAM %p received oversize packet of %zd bytes "
 515                        "(block_size=%ld)\n", slam, len, slam->block_size );
 516                 rc = -EINVAL;
 517                 goto err_discard;
 518         }
 519         if ( ( packet != ( slam->num_blocks - 1 ) ) &&
 520              ( len < slam->block_size ) ) {
 521                 DBGC ( slam, "SLAM %p received short packet of %zd bytes "
 522                        "(block_size=%ld)\n", slam, len, slam->block_size );
 523                 rc = -EINVAL;
 524                 goto err_discard;
 525         }
 526
 527         /* If we have already seen this packet, discard it */
 528         if ( bitmap_test ( &slam->bitmap, packet ) ) {
 529                 goto discard;
 530         }
 531
 532         /* Pass to recipient */
 533         memset ( &meta, 0, sizeof ( meta ) );
 534         meta.whence = SEEK_SET;
 535         meta.offset = ( packet * slam->block_size );
 536         if ( ( rc = xfer_deliver_iob_meta ( &slam->xfer, iobuf,
 537                                             &meta ) ) != 0 )
 538                 goto err;
 539
 540         /* Mark block as received */
 541         bitmap_set ( &slam->bitmap, packet );
 542
 543         /* If we have received all blocks, terminate */
 544         if ( bitmap_full ( &slam->bitmap ) )
 545                 slam_finished ( slam, 0 );
 546
 547         return 0;
 548
 549  err_discard:
 550  discard:
 551         free_iob ( iobuf );
 552  err:
 553         return rc;
 554 }
 555
 556 /**
 557  * Receive SLAM non-data packet
 558  *
 559  * @v socket            SLAM unicast socket
 560  * @v iobuf             I/O buffer
 561  * @ret rc              Return status code
 562  */
 563 static int slam_socket_deliver ( struct xfer_interface *socket,
 564                                  struct io_buffer *iobuf,
 565                                  struct xfer_metadata *rx_meta __unused ) {
 566         struct slam_request *slam =
 567                 container_of ( socket, struct slam_request, socket );
 568         int rc;
 569
 570         /* Restart the master client timer */
 571         stop_timer ( &slam->master_timer );
 572         start_timer ( &slam->master_timer );
 573
 574         /* Read and strip packet header */
 575         if ( ( rc = slam_pull_header ( slam, iobuf ) ) != 0 )
 576                 goto discard;
 577
 578         /* Sanity check */
 579         if ( iob_len ( iobuf ) != 0 ) {
 580                 DBGC ( slam, "SLAM %p received trailing garbage:\n", slam );
 581                 DBGC_HD ( slam, iobuf->data, iob_len ( iobuf ) );
 582                 rc = -EINVAL;
 583                 goto discard;
 584         }
 585
 586         /* Discard packet */
 587         free_iob ( iobuf );
 588
 589         /* Send NACK in reply */
 590         slam_tx_nack ( slam );
 591
 592         return 0;
 593
 594  discard:
 595         free_iob ( iobuf );
 596         return rc;
 597
 598 }
 599
 600 /**
 601  * Close SLAM unicast socket
 602  *
 603  * @v socket            SLAM unicast socket
 604  * @v rc                Reason for close
 605  */
 606 static void slam_socket_close ( struct xfer_interface *socket, int rc ) {
 607         struct slam_request *slam =
 608                 container_of ( socket, struct slam_request, socket );
 609
 610         DBGC ( slam, "SLAM %p unicast socket closed: %s\n",
 611                slam, strerror ( rc ) );
 612
 613         slam_finished ( slam, rc );
 614 }
 615
 616 /** SLAM unicast socket data transfer operations */
 617 static struct xfer_interface_operations slam_socket_operations = {
 618         .close          = slam_socket_close,
 619         .vredirect      = xfer_vreopen,
 620         .window         = unlimited_xfer_window,
 621         .alloc_iob      = default_xfer_alloc_iob,
 622         .deliver_iob    = slam_socket_deliver,
 623         .deliver_raw    = xfer_deliver_as_iob,
 624 };
 625
 626 /**
 627  * Close SLAM multicast socket
 628  *
 629  * @v mc_socket         SLAM multicast socket
 630  * @v rc                Reason for close
 631  */
 632 static void slam_mc_socket_close ( struct xfer_interface *mc_socket, int rc ){
 633         struct slam_request *slam =
 634                 container_of ( mc_socket, struct slam_request, mc_socket );
 635
 636         DBGC ( slam, "SLAM %p multicast socket closed: %s\n",
 637                slam, strerror ( rc ) );
 638
 639         slam_finished ( slam, rc );
 640 }
 641
 642 /** SLAM multicast socket data transfer operations */
 643 static struct xfer_interface_operations slam_mc_socket_operations = {
 644         .close          = slam_mc_socket_close,
 645         .vredirect      = xfer_vreopen,
 646         .window         = unlimited_xfer_window,
 647         .alloc_iob      = default_xfer_alloc_iob,
 648         .deliver_iob    = slam_mc_socket_deliver,
 649         .deliver_raw    = xfer_deliver_as_iob,
 650 };
 651
 652 /****************************************************************************
 653  *
 654  * Data transfer interface
 655  *
 656  */
 657
 658 /**
 659  * Close SLAM data transfer interface
 660  *
 661  * @v xfer              SLAM data transfer interface
 662  * @v rc                Reason for close
 663  */
 664 static void slam_xfer_close ( struct xfer_interface *xfer, int rc ) {
 665         struct slam_request *slam =
 666                 container_of ( xfer, struct slam_request, xfer );
 667
 668         DBGC ( slam, "SLAM %p data transfer interface closed: %s\n",
 669                slam, strerror ( rc ) );
 670
 671         slam_finished ( slam, rc );
 672 }
 673
 674 /** SLAM data transfer operations */
 675 static struct xfer_interface_operations slam_xfer_operations = {
 676         .close          = slam_xfer_close,
 677         .vredirect      = ignore_xfer_vredirect,
 678         .window         = unlimited_xfer_window,
 679         .alloc_iob      = default_xfer_alloc_iob,
 680         .deliver_iob    = xfer_deliver_as_raw,
 681         .deliver_raw    = ignore_xfer_deliver_raw,
 682 };
 683
 684 /**
 685  * Parse SLAM URI multicast address
 686  *
 687  * @v slam              SLAM request
 688  * @v path              Path portion of x-slam:// URI
 689  * @v address           Socket address to fill in
 690  * @ret rc              Return status code
 691  */
 692 static int slam_parse_multicast_address ( struct slam_request *slam,
 693                                           const char *path,
 694                                           struct sockaddr_in *address ) {
 695         char path_dup[ strlen ( path ) /* no +1 */ ];
 696         char *sep;
 697         char *end;
 698
 699         /* Create temporary copy of path, minus the leading '/' */
 700         assert ( *path == '/' );
 701         memcpy ( path_dup, ( path + 1 ) , sizeof ( path_dup ) );
 702
 703         /* Parse port, if present */
 704         sep = strchr ( path_dup, ':' );
 705         if ( sep ) {
 706                 *(sep++) = '\0';
 707                 address->sin_port = htons ( strtoul ( sep, &end, 0 ) );
 708                 if ( *end != '\0' ) {
 709                         DBGC ( slam, "SLAM %p invalid multicast port "
 710                                "\"%s\"\n", slam, sep );
 711                         return -EINVAL;
 712                 }
 713         }
 714
 715         /* Parse address */
 716         if ( inet_aton ( path_dup, &address->sin_addr ) == 0 ) {
 717                 DBGC ( slam, "SLAM %p invalid multicast address \"%s\"\n",
 718                        slam, path_dup );
 719                 return -EINVAL;
 720         }
 721
 722         return 0;
 723 }
 724
 725 /**
 726  * Initiate a SLAM request
 727  *
 728  * @v xfer              Data transfer interface
 729  * @v uri               Uniform Resource Identifier
 730  * @ret rc              Return status code
 731  */
 732 static int slam_open ( struct xfer_interface *xfer, struct uri *uri ) {
 733         static const struct sockaddr_in default_multicast = {
 734                 .sin_family = AF_INET,
 735                 .sin_port = htons ( SLAM_DEFAULT_MULTICAST_PORT ),
 736                 .sin_addr = { htonl ( SLAM_DEFAULT_MULTICAST_IP ) },
 737         };
 738         struct slam_request *slam;
 739         struct sockaddr_tcpip server;
 740         struct sockaddr_in multicast;
 741         int rc;
 742
 743         /* Sanity checks */
 744         if ( ! uri->host )
 745                 return -EINVAL;
 746
 747         /* Allocate and populate structure */
 748         slam = zalloc ( sizeof ( *slam ) );
 749         if ( ! slam )
 750                 return -ENOMEM;
 751         slam->refcnt.free = slam_free;
 752         xfer_init ( &slam->xfer, &slam_xfer_operations, &slam->refcnt );
 753         xfer_init ( &slam->socket, &slam_socket_operations, &slam->refcnt );
 754         xfer_init ( &slam->mc_socket, &slam_mc_socket_operations,
 755                     &slam->refcnt );
 756         slam->master_timer.expired = slam_master_timer_expired;
 757         slam->slave_timer.expired = slam_slave_timer_expired;
 758         /* Fake an invalid cached header of { 0x00, ... } */
 759         slam->header_len = 1;
 760         /* Fake parameters for initial NACK */
 761         slam->num_blocks = 1;
 762         if ( ( rc = bitmap_resize ( &slam->bitmap, 1 ) ) != 0 ) {
 763                 DBGC ( slam, "SLAM %p could not allocate initial bitmap: "
 764                        "%s\n", slam, strerror ( rc ) );
 765                 goto err;
 766         }
 767
 768         /* Open unicast socket */
 769         memset ( &server, 0, sizeof ( server ) );
 770         server.st_port = htons ( uri_port ( uri, SLAM_DEFAULT_PORT ) );
 771         if ( ( rc = xfer_open_named_socket ( &slam->socket, SOCK_DGRAM,
 772                                              ( struct sockaddr * ) &server,
 773                                              uri->host, NULL ) ) != 0 ) {
 774                 DBGC ( slam, "SLAM %p could not open unicast socket: %s\n",
 775                        slam, strerror ( rc ) );
 776                 goto err;
 777         }
 778
 779         /* Open multicast socket */
 780         memcpy ( &multicast, &default_multicast, sizeof ( multicast ) );
 781         if ( uri->path &&
 782              ( ( rc = slam_parse_multicast_address ( slam, uri->path,
 783                                                      &multicast ) ) != 0 ) ) {
 784                 goto err;
 785         }
 786         if ( ( rc = xfer_open_socket ( &slam->mc_socket, SOCK_DGRAM,
 787                                  ( struct sockaddr * ) &multicast,
 788                                  ( struct sockaddr * ) &multicast ) ) != 0 ) {
 789                 DBGC ( slam, "SLAM %p could not open multicast socket: %s\n",
 790                        slam, strerror ( rc ) );
 791                 goto err;
 792         }
 793
 794         /* Start slave retry timer */
 795         start_timer_fixed ( &slam->slave_timer, SLAM_SLAVE_TIMEOUT );
 796
 797         /* Attach to parent interface, mortalise self, and return */
 798         xfer_plug_plug ( &slam->xfer, xfer );
 799         ref_put ( &slam->refcnt );
 800         return 0;
 801
 802  err:
 803         slam_finished ( slam, rc );
 804         ref_put ( &slam->refcnt );
 805         return rc;
 806 }
 807
 808 /** SLAM URI opener */
 809 struct uri_opener slam_uri_opener __uri_opener = {
 810         .scheme = "x-slam",
 811         .open   = slam_open,
 812 };