[tcp] Ignore duplicate ACKs in TCP ESTABLISHED state
[people/oremanj/gpxe.git] / 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 };