![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to slam.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / udp|
Return to slam.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / udp |
1.1 ! root 1: /* ! 2: * Copyright (C) 2008 Michael Brown <[email protected]>. ! 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 <ipxe/features.h> ! 29: #include <ipxe/iobuf.h> ! 30: #include <ipxe/bitmap.h> ! 31: #include <ipxe/xfer.h> ! 32: #include <ipxe/open.h> ! 33: #include <ipxe/uri.h> ! 34: #include <ipxe/tcpip.h> ! 35: #include <ipxe/timer.h> ! 36: #include <ipxe/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 interface xfer; ! 123: /** Unicast socket */ ! 124: struct interface socket; ! 125: /** Multicast socket */ ! 126: struct 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: intf_shutdown ( &slam->socket, rc ); ! 188: intf_shutdown ( &slam->mc_socket, rc ); ! 189: intf_shutdown ( &slam->xfer, rc ); ! 190: } ! 191: ! 192: /**************************************************************************** ! 193: * ! 194: * TX datapath ! 195: * ! 196: */ ! 197: ! 198: /** ! 199: * Add a variable-length value to a SLAM packet ! 200: * ! 201: * @v slam SLAM request ! 202: * @v iobuf I/O buffer ! 203: * @v value Value to add ! 204: * @ret rc Return status code ! 205: * ! 206: * Adds a variable-length value to the end of an I/O buffer. Will ! 207: * always leave at least one byte of tailroom in the I/O buffer (to ! 208: * allow space for the terminating NUL). ! 209: */ ! 210: static int slam_put_value ( struct slam_request *slam, ! 211: struct io_buffer *iobuf, unsigned long value ) { ! 212: uint8_t *data; ! 213: size_t len; ! 214: unsigned int i; ! 215: ! 216: /* Calculate variable length required to store value. Always ! 217: * leave at least one byte in the I/O buffer. ! 218: */ ! 219: len = ( ( flsl ( value ) + 10 ) / 8 ); ! 220: if ( len >= iob_tailroom ( iobuf ) ) { ! 221: DBGC2 ( slam, "SLAM %p cannot add %zd-byte value\n", ! 222: slam, len ); ! 223: return -ENOBUFS; ! 224: } ! 225: /* There is no valid way within the protocol that we can end ! 226: * up trying to push a full-sized long (i.e. without space for ! 227: * the length encoding). ! 228: */ ! 229: assert ( len <= sizeof ( value ) ); ! 230: ! 231: /* Add value */ ! 232: data = iob_put ( iobuf, len ); ! 233: for ( i = len ; i-- ; ) { ! 234: data[i] = value; ! 235: value >>= 8; ! 236: } ! 237: *data |= ( len << 5 ); ! 238: assert ( value == 0 ); ! 239: ! 240: return 0; ! 241: } ! 242: ! 243: /** ! 244: * Send SLAM NACK packet ! 245: * ! 246: * @v slam SLAM request ! 247: * @ret rc Return status code ! 248: */ ! 249: static int slam_tx_nack ( struct slam_request *slam ) { ! 250: struct io_buffer *iobuf; ! 251: unsigned long first_block; ! 252: unsigned long num_blocks; ! 253: uint8_t *nul; ! 254: int rc; ! 255: ! 256: /* Mark NACK as sent, so that we know we have to disconnect later */ ! 257: slam->nack_sent = 1; ! 258: ! 259: /* Allocate I/O buffer */ ! 260: iobuf = xfer_alloc_iob ( &slam->socket, SLAM_MAX_NACK_LEN ); ! 261: if ( ! iobuf ) { ! 262: DBGC ( slam, "SLAM %p could not allocate I/O buffer\n", ! 263: slam ); ! 264: return -ENOMEM; ! 265: } ! 266: ! 267: /* Construct NACK. We always request only a single packet; ! 268: * this allows us to force multicast-TFTP-style flow control ! 269: * on the SLAM server, which will otherwise just blast the ! 270: * data out as fast as it can. On a gigabit network, without ! 271: * RX checksumming, this would inevitably cause packet drops. ! 272: */ ! 273: first_block = bitmap_first_gap ( &slam->bitmap ); ! 274: for ( num_blocks = 1 ; ; num_blocks++ ) { ! 275: if ( num_blocks >= SLAM_MAX_BLOCKS_PER_NACK ) ! 276: break; ! 277: if ( ( first_block + num_blocks ) >= slam->num_blocks ) ! 278: break; ! 279: if ( bitmap_test ( &slam->bitmap, ! 280: ( first_block + num_blocks ) ) ) ! 281: break; ! 282: } ! 283: if ( first_block ) { ! 284: DBGCP ( slam, "SLAM %p transmitting NACK for blocks " ! 285: "%ld-%ld\n", slam, first_block, ! 286: ( first_block + num_blocks - 1 ) ); ! 287: } else { ! 288: DBGC ( slam, "SLAM %p transmitting initial NACK for blocks " ! 289: "0-%ld\n", slam, ( num_blocks - 1 ) ); ! 290: } ! 291: if ( ( rc = slam_put_value ( slam, iobuf, first_block ) ) != 0 ) ! 292: return rc; ! 293: if ( ( rc = slam_put_value ( slam, iobuf, num_blocks ) ) != 0 ) ! 294: return rc; ! 295: nul = iob_put ( iobuf, 1 ); ! 296: *nul = 0; ! 297: ! 298: /* Transmit packet */ ! 299: return xfer_deliver_iob ( &slam->socket, iobuf ); ! 300: } ! 301: ! 302: /** ! 303: * Handle SLAM master client retry timer expiry ! 304: * ! 305: * @v timer Master retry timer ! 306: * @v fail Failure indicator ! 307: */ ! 308: static void slam_master_timer_expired ( struct retry_timer *timer, ! 309: int fail ) { ! 310: struct slam_request *slam = ! 311: container_of ( timer, struct slam_request, master_timer ); ! 312: ! 313: if ( fail ) { ! 314: /* Allow timer to stop running. We will terminate the ! 315: * connection only if the slave timer times out. ! 316: */ ! 317: DBGC ( slam, "SLAM %p giving up acting as master client\n", ! 318: slam ); ! 319: } else { ! 320: /* Retransmit NACK */ ! 321: start_timer ( timer ); ! 322: slam_tx_nack ( slam ); ! 323: } ! 324: } ! 325: ! 326: /** ! 327: * Handle SLAM slave client retry timer expiry ! 328: * ! 329: * @v timer Master retry timer ! 330: * @v fail Failure indicator ! 331: */ ! 332: static void slam_slave_timer_expired ( struct retry_timer *timer, ! 333: int fail ) { ! 334: struct slam_request *slam = ! 335: container_of ( timer, struct slam_request, slave_timer ); ! 336: ! 337: if ( fail ) { ! 338: /* Terminate connection */ ! 339: slam_finished ( slam, -ETIMEDOUT ); ! 340: } else { ! 341: /* Try sending a NACK */ ! 342: DBGC ( slam, "SLAM %p trying to become master client\n", ! 343: slam ); ! 344: start_timer ( timer ); ! 345: slam_tx_nack ( slam ); ! 346: } ! 347: } ! 348: ! 349: /**************************************************************************** ! 350: * ! 351: * RX datapath ! 352: * ! 353: */ ! 354: ! 355: /** ! 356: * Read and strip a variable-length value from a SLAM packet ! 357: * ! 358: * @v slam SLAM request ! 359: * @v iobuf I/O buffer ! 360: * @v value Value to fill in, or NULL to ignore value ! 361: * @ret rc Return status code ! 362: * ! 363: * Reads a variable-length value from the start of the I/O buffer. ! 364: */ ! 365: static int slam_pull_value ( struct slam_request *slam, ! 366: struct io_buffer *iobuf, ! 367: unsigned long *value ) { ! 368: uint8_t *data; ! 369: size_t len; ! 370: ! 371: /* Sanity check */ ! 372: if ( iob_len ( iobuf ) == 0 ) { ! 373: DBGC ( slam, "SLAM %p empty value\n", slam ); ! 374: return -EINVAL; ! 375: } ! 376: ! 377: /* Read and verify length of value */ ! 378: data = iobuf->data; ! 379: len = ( *data >> 5 ); ! 380: if ( ( len == 0 ) || ! 381: ( value && ( len > sizeof ( *value ) ) ) ) { ! 382: DBGC ( slam, "SLAM %p invalid value length %zd bytes\n", ! 383: slam, len ); ! 384: return -EINVAL; ! 385: } ! 386: if ( len > iob_len ( iobuf ) ) { ! 387: DBGC ( slam, "SLAM %p value extends beyond I/O buffer\n", ! 388: slam ); ! 389: return -EINVAL; ! 390: } ! 391: ! 392: /* Read value */ ! 393: iob_pull ( iobuf, len ); ! 394: *value = ( *data & 0x1f ); ! 395: while ( --len ) { ! 396: *value <<= 8; ! 397: *value |= *(++data); ! 398: } ! 399: ! 400: return 0; ! 401: } ! 402: ! 403: /** ! 404: * Read and strip SLAM header ! 405: * ! 406: * @v slam SLAM request ! 407: * @v iobuf I/O buffer ! 408: * @ret rc Return status code ! 409: */ ! 410: static int slam_pull_header ( struct slam_request *slam, ! 411: struct io_buffer *iobuf ) { ! 412: void *header = iobuf->data; ! 413: int rc; ! 414: ! 415: /* If header matches cached header, just pull it and return */ ! 416: if ( ( slam->header_len <= iob_len ( iobuf ) ) && ! 417: ( memcmp ( slam->header, iobuf->data, slam->header_len ) == 0 )){ ! 418: iob_pull ( iobuf, slam->header_len ); ! 419: return 0; ! 420: } ! 421: ! 422: DBGC ( slam, "SLAM %p detected changed header; resetting\n", slam ); ! 423: ! 424: /* Read and strip transaction ID, total number of bytes, and ! 425: * block size. ! 426: */ ! 427: if ( ( rc = slam_pull_value ( slam, iobuf, NULL ) ) != 0 ) ! 428: return rc; ! 429: if ( ( rc = slam_pull_value ( slam, iobuf, ! 430: &slam->total_bytes ) ) != 0 ) ! 431: return rc; ! 432: if ( ( rc = slam_pull_value ( slam, iobuf, ! 433: &slam->block_size ) ) != 0 ) ! 434: return rc; ! 435: ! 436: /* Update the cached header */ ! 437: slam->header_len = ( iobuf->data - header ); ! 438: assert ( slam->header_len <= sizeof ( slam->header ) ); ! 439: memcpy ( slam->header, header, slam->header_len ); ! 440: ! 441: /* Calculate number of blocks */ ! 442: slam->num_blocks = ( ( slam->total_bytes + slam->block_size - 1 ) / ! 443: slam->block_size ); ! 444: ! 445: DBGC ( slam, "SLAM %p has total bytes %ld, block size %ld, num " ! 446: "blocks %ld\n", slam, slam->total_bytes, slam->block_size, ! 447: slam->num_blocks ); ! 448: ! 449: /* Discard and reset the bitmap */ ! 450: bitmap_free ( &slam->bitmap ); ! 451: memset ( &slam->bitmap, 0, sizeof ( slam->bitmap ) ); ! 452: ! 453: /* Allocate a new bitmap */ ! 454: if ( ( rc = bitmap_resize ( &slam->bitmap, ! 455: slam->num_blocks ) ) != 0 ) { ! 456: /* Failure to allocate a bitmap is fatal */ ! 457: DBGC ( slam, "SLAM %p could not allocate bitmap for %ld " ! 458: "blocks: %s\n", slam, slam->num_blocks, ! 459: strerror ( rc ) ); ! 460: slam_finished ( slam, rc ); ! 461: return rc; ! 462: } ! 463: ! 464: /* Notify recipient of file size */ ! 465: xfer_seek ( &slam->xfer, slam->total_bytes ); ! 466: ! 467: return 0; ! 468: } ! 469: ! 470: /** ! 471: * Receive SLAM data packet ! 472: * ! 473: * @v slam SLAM request ! 474: * @v iobuf I/O buffer ! 475: * @ret rc Return status code ! 476: */ ! 477: static int slam_mc_socket_deliver ( struct slam_request *slam, ! 478: struct io_buffer *iobuf, ! 479: struct xfer_metadata *rx_meta __unused ) { ! 480: struct xfer_metadata meta; ! 481: unsigned long packet; ! 482: size_t len; ! 483: int rc; ! 484: ! 485: /* Stop the master client timer. Restart the slave client timer. */ ! 486: stop_timer ( &slam->master_timer ); ! 487: stop_timer ( &slam->slave_timer ); ! 488: start_timer_fixed ( &slam->slave_timer, SLAM_SLAVE_TIMEOUT ); ! 489: ! 490: /* Read and strip packet header */ ! 491: if ( ( rc = slam_pull_header ( slam, iobuf ) ) != 0 ) ! 492: goto err_discard; ! 493: ! 494: /* Read and strip packet number */ ! 495: if ( ( rc = slam_pull_value ( slam, iobuf, &packet ) ) != 0 ) ! 496: goto err_discard; ! 497: ! 498: /* Sanity check packet number */ ! 499: if ( packet >= slam->num_blocks ) { ! 500: DBGC ( slam, "SLAM %p received out-of-range packet %ld " ! 501: "(num_blocks=%ld)\n", slam, packet, slam->num_blocks ); ! 502: rc = -EINVAL; ! 503: goto err_discard; ! 504: } ! 505: ! 506: /* Sanity check length */ ! 507: len = iob_len ( iobuf ); ! 508: if ( len > slam->block_size ) { ! 509: DBGC ( slam, "SLAM %p received oversize packet of %zd bytes " ! 510: "(block_size=%ld)\n", slam, len, slam->block_size ); ! 511: rc = -EINVAL; ! 512: goto err_discard; ! 513: } ! 514: if ( ( packet != ( slam->num_blocks - 1 ) ) && ! 515: ( len < slam->block_size ) ) { ! 516: DBGC ( slam, "SLAM %p received short packet of %zd bytes " ! 517: "(block_size=%ld)\n", slam, len, slam->block_size ); ! 518: rc = -EINVAL; ! 519: goto err_discard; ! 520: } ! 521: ! 522: /* If we have already seen this packet, discard it */ ! 523: if ( bitmap_test ( &slam->bitmap, packet ) ) { ! 524: goto discard; ! 525: } ! 526: ! 527: /* Pass to recipient */ ! 528: memset ( &meta, 0, sizeof ( meta ) ); ! 529: meta.flags = XFER_FL_ABS_OFFSET; ! 530: meta.offset = ( packet * slam->block_size ); ! 531: if ( ( rc = xfer_deliver ( &slam->xfer, iobuf, &meta ) ) != 0 ) ! 532: goto err; ! 533: ! 534: /* Mark block as received */ ! 535: bitmap_set ( &slam->bitmap, packet ); ! 536: ! 537: /* If we have received all blocks, terminate */ ! 538: if ( bitmap_full ( &slam->bitmap ) ) ! 539: slam_finished ( slam, 0 ); ! 540: ! 541: return 0; ! 542: ! 543: err_discard: ! 544: discard: ! 545: free_iob ( iobuf ); ! 546: err: ! 547: return rc; ! 548: } ! 549: ! 550: /** ! 551: * Receive SLAM non-data packet ! 552: * ! 553: * @v slam SLAM request ! 554: * @v iobuf I/O buffer ! 555: * @ret rc Return status code ! 556: */ ! 557: static int slam_socket_deliver ( struct slam_request *slam, ! 558: struct io_buffer *iobuf, ! 559: struct xfer_metadata *rx_meta __unused ) { ! 560: int rc; ! 561: ! 562: /* Restart the master client timer */ ! 563: stop_timer ( &slam->master_timer ); ! 564: start_timer ( &slam->master_timer ); ! 565: ! 566: /* Read and strip packet header */ ! 567: if ( ( rc = slam_pull_header ( slam, iobuf ) ) != 0 ) ! 568: goto discard; ! 569: ! 570: /* Sanity check */ ! 571: if ( iob_len ( iobuf ) != 0 ) { ! 572: DBGC ( slam, "SLAM %p received trailing garbage:\n", slam ); ! 573: DBGC_HD ( slam, iobuf->data, iob_len ( iobuf ) ); ! 574: rc = -EINVAL; ! 575: goto discard; ! 576: } ! 577: ! 578: /* Discard packet */ ! 579: free_iob ( iobuf ); ! 580: ! 581: /* Send NACK in reply */ ! 582: slam_tx_nack ( slam ); ! 583: ! 584: return 0; ! 585: ! 586: discard: ! 587: free_iob ( iobuf ); ! 588: return rc; ! 589: ! 590: } ! 591: ! 592: /** SLAM unicast socket interface operations */ ! 593: static struct interface_operation slam_socket_operations[] = { ! 594: INTF_OP ( xfer_deliver, struct slam_request *, slam_socket_deliver ), ! 595: INTF_OP ( intf_close, struct slam_request *, slam_finished ), ! 596: }; ! 597: ! 598: /** SLAM unicast socket interface descriptor */ ! 599: static struct interface_descriptor slam_socket_desc = ! 600: INTF_DESC ( struct slam_request, socket, slam_socket_operations ); ! 601: ! 602: /** SLAM multicast socket interface operations */ ! 603: static struct interface_operation slam_mc_socket_operations[] = { ! 604: INTF_OP ( xfer_deliver, struct slam_request *, slam_mc_socket_deliver ), ! 605: INTF_OP ( intf_close, struct slam_request *, slam_finished ), ! 606: }; ! 607: ! 608: /** SLAM multicast socket interface descriptor */ ! 609: static struct interface_descriptor slam_mc_socket_desc = ! 610: INTF_DESC ( struct slam_request, mc_socket, slam_mc_socket_operations ); ! 611: ! 612: /**************************************************************************** ! 613: * ! 614: * Data transfer interface ! 615: * ! 616: */ ! 617: ! 618: /** SLAM data transfer interface operations */ ! 619: static struct interface_operation slam_xfer_operations[] = { ! 620: INTF_OP ( intf_close, struct slam_request *, slam_finished ), ! 621: }; ! 622: ! 623: /** SLAM data transfer interface descriptor */ ! 624: static struct interface_descriptor slam_xfer_desc = ! 625: INTF_DESC ( struct slam_request, xfer, slam_xfer_operations ); ! 626: ! 627: /** ! 628: * Parse SLAM URI multicast address ! 629: * ! 630: * @v slam SLAM request ! 631: * @v path Path portion of x-slam:// URI ! 632: * @v address Socket address to fill in ! 633: * @ret rc Return status code ! 634: */ ! 635: static int slam_parse_multicast_address ( struct slam_request *slam, ! 636: const char *path, ! 637: struct sockaddr_in *address ) { ! 638: char path_dup[ strlen ( path ) /* no +1 */ ]; ! 639: char *sep; ! 640: char *end; ! 641: ! 642: /* Create temporary copy of path, minus the leading '/' */ ! 643: assert ( *path == '/' ); ! 644: memcpy ( path_dup, ( path + 1 ) , sizeof ( path_dup ) ); ! 645: ! 646: /* Parse port, if present */ ! 647: sep = strchr ( path_dup, ':' ); ! 648: if ( sep ) { ! 649: *(sep++) = '\0'; ! 650: address->sin_port = htons ( strtoul ( sep, &end, 0 ) ); ! 651: if ( *end != '\0' ) { ! 652: DBGC ( slam, "SLAM %p invalid multicast port " ! 653: "\"%s\"\n", slam, sep ); ! 654: return -EINVAL; ! 655: } ! 656: } ! 657: ! 658: /* Parse address */ ! 659: if ( inet_aton ( path_dup, &address->sin_addr ) == 0 ) { ! 660: DBGC ( slam, "SLAM %p invalid multicast address \"%s\"\n", ! 661: slam, path_dup ); ! 662: return -EINVAL; ! 663: } ! 664: ! 665: return 0; ! 666: } ! 667: ! 668: /** ! 669: * Initiate a SLAM request ! 670: * ! 671: * @v xfer Data transfer interface ! 672: * @v uri Uniform Resource Identifier ! 673: * @ret rc Return status code ! 674: */ ! 675: static int slam_open ( struct interface *xfer, struct uri *uri ) { ! 676: static const struct sockaddr_in default_multicast = { ! 677: .sin_family = AF_INET, ! 678: .sin_port = htons ( SLAM_DEFAULT_MULTICAST_PORT ), ! 679: .sin_addr = { htonl ( SLAM_DEFAULT_MULTICAST_IP ) }, ! 680: }; ! 681: struct slam_request *slam; ! 682: struct sockaddr_tcpip server; ! 683: struct sockaddr_in multicast; ! 684: int rc; ! 685: ! 686: /* Sanity checks */ ! 687: if ( ! uri->host ) ! 688: return -EINVAL; ! 689: ! 690: /* Allocate and populate structure */ ! 691: slam = zalloc ( sizeof ( *slam ) ); ! 692: if ( ! slam ) ! 693: return -ENOMEM; ! 694: ref_init ( &slam->refcnt, slam_free ); ! 695: intf_init ( &slam->xfer, &slam_xfer_desc, &slam->refcnt ); ! 696: intf_init ( &slam->socket, &slam_socket_desc, &slam->refcnt ); ! 697: intf_init ( &slam->mc_socket, &slam_mc_socket_desc, &slam->refcnt ); ! 698: timer_init ( &slam->master_timer, slam_master_timer_expired, ! 699: &slam->refcnt ); ! 700: timer_init ( &slam->slave_timer, slam_slave_timer_expired, ! 701: &slam->refcnt ); ! 702: /* Fake an invalid cached header of { 0x00, ... } */ ! 703: slam->header_len = 1; ! 704: /* Fake parameters for initial NACK */ ! 705: slam->num_blocks = 1; ! 706: if ( ( rc = bitmap_resize ( &slam->bitmap, 1 ) ) != 0 ) { ! 707: DBGC ( slam, "SLAM %p could not allocate initial bitmap: " ! 708: "%s\n", slam, strerror ( rc ) ); ! 709: goto err; ! 710: } ! 711: ! 712: /* Open unicast socket */ ! 713: memset ( &server, 0, sizeof ( server ) ); ! 714: server.st_port = htons ( uri_port ( uri, SLAM_DEFAULT_PORT ) ); ! 715: if ( ( rc = xfer_open_named_socket ( &slam->socket, SOCK_DGRAM, ! 716: ( struct sockaddr * ) &server, ! 717: uri->host, NULL ) ) != 0 ) { ! 718: DBGC ( slam, "SLAM %p could not open unicast socket: %s\n", ! 719: slam, strerror ( rc ) ); ! 720: goto err; ! 721: } ! 722: ! 723: /* Open multicast socket */ ! 724: memcpy ( &multicast, &default_multicast, sizeof ( multicast ) ); ! 725: if ( uri->path && ! 726: ( ( rc = slam_parse_multicast_address ( slam, uri->path, ! 727: &multicast ) ) != 0 ) ) { ! 728: goto err; ! 729: } ! 730: if ( ( rc = xfer_open_socket ( &slam->mc_socket, SOCK_DGRAM, ! 731: ( struct sockaddr * ) &multicast, ! 732: ( struct sockaddr * ) &multicast ) ) != 0 ) { ! 733: DBGC ( slam, "SLAM %p could not open multicast socket: %s\n", ! 734: slam, strerror ( rc ) ); ! 735: goto err; ! 736: } ! 737: ! 738: /* Start slave retry timer */ ! 739: start_timer_fixed ( &slam->slave_timer, SLAM_SLAVE_TIMEOUT ); ! 740: ! 741: /* Attach to parent interface, mortalise self, and return */ ! 742: intf_plug_plug ( &slam->xfer, xfer ); ! 743: ref_put ( &slam->refcnt ); ! 744: return 0; ! 745: ! 746: err: ! 747: slam_finished ( slam, rc ); ! 748: ref_put ( &slam->refcnt ); ! 749: return rc; ! 750: } ! 751: ! 752: /** SLAM URI opener */ ! 753: struct uri_opener slam_uri_opener __uri_opener = { ! 754: .scheme = "x-slam", ! 755: .open = slam_open, ! 756: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.