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 */
slam_free(struct refcnt * refcnt)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 */
slam_finished(struct slam_request * slam,int rc)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 */
slam_put_value(struct slam_request * slam,struct io_buffer * iobuf,unsigned long value)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 */
slam_tx_nack(struct slam_request * slam)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 */
slam_master_timer_expired(struct retry_timer * timer,int fail)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 */
slam_slave_timer_expired(struct retry_timer * timer,int fail)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 */
slam_pull_value(struct slam_request * slam,struct io_buffer * iobuf,unsigned long * value)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 */
slam_pull_header(struct slam_request * slam,struct io_buffer * iobuf)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 */
slam_mc_socket_deliver(struct xfer_interface * mc_socket,struct io_buffer * iobuf,struct xfer_metadata * rx_meta __unused)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 */
slam_socket_deliver(struct xfer_interface * socket,struct io_buffer * iobuf,struct xfer_metadata * rx_meta __unused)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 */
slam_socket_close(struct xfer_interface * socket,int rc)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 */
slam_mc_socket_close(struct xfer_interface * mc_socket,int rc)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 */
slam_xfer_close(struct xfer_interface * xfer,int rc)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 */
slam_parse_multicast_address(struct slam_request * slam,const char * path,struct sockaddr_in * address)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 */
slam_open(struct xfer_interface * xfer,struct uri * uri)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 };
813