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