![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tftp.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 tftp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net / udp |
1.1 ! root 1: /* ! 2: * Copyright (C) 2006 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 <stdio.h> ! 24: #include <string.h> ! 25: #include <strings.h> ! 26: #include <byteswap.h> ! 27: #include <errno.h> ! 28: #include <assert.h> ! 29: #include <ipxe/refcnt.h> ! 30: #include <ipxe/iobuf.h> ! 31: #include <ipxe/xfer.h> ! 32: #include <ipxe/open.h> ! 33: #include <ipxe/uri.h> ! 34: #include <ipxe/tcpip.h> ! 35: #include <ipxe/retry.h> ! 36: #include <ipxe/features.h> ! 37: #include <ipxe/bitmap.h> ! 38: #include <ipxe/settings.h> ! 39: #include <ipxe/dhcp.h> ! 40: #include <ipxe/uri.h> ! 41: #include <ipxe/tftp.h> ! 42: ! 43: /** @file ! 44: * ! 45: * TFTP protocol ! 46: * ! 47: */ ! 48: ! 49: FEATURE ( FEATURE_PROTOCOL, "TFTP", DHCP_EB_FEATURE_TFTP, 1 ); ! 50: ! 51: /* TFTP-specific error codes */ ! 52: #define EINVAL_BLKSIZE __einfo_error ( EINFO_EINVAL_BLKSIZE ) ! 53: #define EINFO_EINVAL_BLKSIZE __einfo_uniqify \ ! 54: ( EINFO_EINVAL, 0x01, "Invalid blksize" ) ! 55: #define EINVAL_TSIZE __einfo_error ( EINFO_EINVAL_TSIZE ) ! 56: #define EINFO_EINVAL_TSIZE __einfo_uniqify \ ! 57: ( EINFO_EINVAL, 0x02, "Invalid tsize" ) ! 58: #define EINVAL_MC_NO_PORT __einfo_error ( EINFO_EINVAL_MC_NO_PORT ) ! 59: #define EINFO_EINVAL_MC_NO_PORT __einfo_uniqify \ ! 60: ( EINFO_EINVAL, 0x03, "Missing multicast port" ) ! 61: #define EINVAL_MC_NO_MC __einfo_error ( EINFO_EINVAL_MC_NO_MC ) ! 62: #define EINFO_EINVAL_MC_NO_MC __einfo_uniqify \ ! 63: ( EINFO_EINVAL, 0x04, "Missing multicast mc" ) ! 64: #define EINVAL_MC_INVALID_MC __einfo_error ( EINFO_EINVAL_MC_INVALID_MC ) ! 65: #define EINFO_EINVAL_MC_INVALID_MC __einfo_uniqify \ ! 66: ( EINFO_EINVAL, 0x05, "Missing multicast IP" ) ! 67: #define EINVAL_MC_INVALID_IP __einfo_error ( EINFO_EINVAL_MC_INVALID_IP ) ! 68: #define EINFO_EINVAL_MC_INVALID_IP __einfo_uniqify \ ! 69: ( EINFO_EINVAL, 0x06, "Invalid multicast IP" ) ! 70: #define EINVAL_MC_INVALID_PORT __einfo_error ( EINFO_EINVAL_MC_INVALID_PORT ) ! 71: #define EINFO_EINVAL_MC_INVALID_PORT __einfo_uniqify \ ! 72: ( EINFO_EINVAL, 0x07, "Invalid multicast port" ) ! 73: ! 74: /** ! 75: * A TFTP request ! 76: * ! 77: * This data structure holds the state for an ongoing TFTP transfer. ! 78: */ ! 79: struct tftp_request { ! 80: /** Reference count */ ! 81: struct refcnt refcnt; ! 82: /** Data transfer interface */ ! 83: struct interface xfer; ! 84: ! 85: /** URI being fetched */ ! 86: struct uri *uri; ! 87: /** Transport layer interface */ ! 88: struct interface socket; ! 89: /** Multicast transport layer interface */ ! 90: struct interface mc_socket; ! 91: ! 92: /** Data block size ! 93: * ! 94: * This is the "blksize" option negotiated with the TFTP ! 95: * server. (If the TFTP server does not support TFTP options, ! 96: * this will default to 512). ! 97: */ ! 98: unsigned int blksize; ! 99: /** File size ! 100: * ! 101: * This is the value returned in the "tsize" option from the ! 102: * TFTP server. If the TFTP server does not support the ! 103: * "tsize" option, this value will be zero. ! 104: */ ! 105: unsigned long tsize; ! 106: ! 107: /** Server port ! 108: * ! 109: * This is the port to which RRQ packets are sent. ! 110: */ ! 111: unsigned int port; ! 112: /** Peer address ! 113: * ! 114: * The peer address is determined by the first response ! 115: * received to the TFTP RRQ. ! 116: */ ! 117: struct sockaddr_tcpip peer; ! 118: /** Request flags */ ! 119: unsigned int flags; ! 120: /** MTFTP timeout count */ ! 121: unsigned int mtftp_timeouts; ! 122: ! 123: /** Block bitmap */ ! 124: struct bitmap bitmap; ! 125: /** Maximum known length ! 126: * ! 127: * We don't always know the file length in advance. In ! 128: * particular, if the TFTP server doesn't support the tsize ! 129: * option, or we are using MTFTP, then we don't know the file ! 130: * length until we see the end-of-file block (which, in the ! 131: * case of MTFTP, may not be the last block we see). ! 132: * ! 133: * This value is updated whenever we obtain information about ! 134: * the file length. ! 135: */ ! 136: size_t filesize; ! 137: /** Retransmission timer */ ! 138: struct retry_timer timer; ! 139: }; ! 140: ! 141: /** TFTP request flags */ ! 142: enum { ! 143: /** Send ACK packets */ ! 144: TFTP_FL_SEND_ACK = 0x0001, ! 145: /** Request blksize and tsize options */ ! 146: TFTP_FL_RRQ_SIZES = 0x0002, ! 147: /** Request multicast option */ ! 148: TFTP_FL_RRQ_MULTICAST = 0x0004, ! 149: /** Perform MTFTP recovery on timeout */ ! 150: TFTP_FL_MTFTP_RECOVERY = 0x0008, ! 151: /** Only get filesize and then abort the transfer */ ! 152: TFTP_FL_SIZEONLY = 0x0010, ! 153: }; ! 154: ! 155: /** Maximum number of MTFTP open requests before falling back to TFTP */ ! 156: #define MTFTP_MAX_TIMEOUTS 3 ! 157: ! 158: /** ! 159: * Free TFTP request ! 160: * ! 161: * @v refcnt Reference counter ! 162: */ ! 163: static void tftp_free ( struct refcnt *refcnt ) { ! 164: struct tftp_request *tftp = ! 165: container_of ( refcnt, struct tftp_request, refcnt ); ! 166: ! 167: uri_put ( tftp->uri ); ! 168: bitmap_free ( &tftp->bitmap ); ! 169: free ( tftp ); ! 170: } ! 171: ! 172: /** ! 173: * Mark TFTP request as complete ! 174: * ! 175: * @v tftp TFTP connection ! 176: * @v rc Return status code ! 177: */ ! 178: static void tftp_done ( struct tftp_request *tftp, int rc ) { ! 179: ! 180: DBGC ( tftp, "TFTP %p finished with status %d (%s)\n", ! 181: tftp, rc, strerror ( rc ) ); ! 182: ! 183: /* Stop the retry timer */ ! 184: stop_timer ( &tftp->timer ); ! 185: ! 186: /* Close all data transfer interfaces */ ! 187: intf_shutdown ( &tftp->socket, rc ); ! 188: intf_shutdown ( &tftp->mc_socket, rc ); ! 189: intf_shutdown ( &tftp->xfer, rc ); ! 190: } ! 191: ! 192: /** ! 193: * Reopen TFTP socket ! 194: * ! 195: * @v tftp TFTP connection ! 196: * @ret rc Return status code ! 197: */ ! 198: static int tftp_reopen ( struct tftp_request *tftp ) { ! 199: struct sockaddr_tcpip server; ! 200: int rc; ! 201: ! 202: /* Close socket */ ! 203: intf_restart ( &tftp->socket, 0 ); ! 204: ! 205: /* Disable ACK sending. */ ! 206: tftp->flags &= ~TFTP_FL_SEND_ACK; ! 207: ! 208: /* Reset peer address */ ! 209: memset ( &tftp->peer, 0, sizeof ( tftp->peer ) ); ! 210: ! 211: /* Open socket */ ! 212: memset ( &server, 0, sizeof ( server ) ); ! 213: server.st_port = htons ( tftp->port ); ! 214: if ( ( rc = xfer_open_named_socket ( &tftp->socket, SOCK_DGRAM, ! 215: ( struct sockaddr * ) &server, ! 216: tftp->uri->host, NULL ) ) != 0 ) { ! 217: DBGC ( tftp, "TFTP %p could not open socket: %s\n", ! 218: tftp, strerror ( rc ) ); ! 219: return rc; ! 220: } ! 221: ! 222: return 0; ! 223: } ! 224: ! 225: /** ! 226: * Reopen TFTP multicast socket ! 227: * ! 228: * @v tftp TFTP connection ! 229: * @v local Local socket address ! 230: * @ret rc Return status code ! 231: */ ! 232: static int tftp_reopen_mc ( struct tftp_request *tftp, ! 233: struct sockaddr *local ) { ! 234: int rc; ! 235: ! 236: /* Close multicast socket */ ! 237: intf_restart ( &tftp->mc_socket, 0 ); ! 238: ! 239: /* Open multicast socket. We never send via this socket, so ! 240: * use the local address as the peer address (since the peer ! 241: * address cannot be NULL). ! 242: */ ! 243: if ( ( rc = xfer_open_socket ( &tftp->mc_socket, SOCK_DGRAM, ! 244: local, local ) ) != 0 ) { ! 245: DBGC ( tftp, "TFTP %p could not open multicast " ! 246: "socket: %s\n", tftp, strerror ( rc ) ); ! 247: return rc; ! 248: } ! 249: ! 250: return 0; ! 251: } ! 252: ! 253: /** ! 254: * Presize TFTP receive buffers and block bitmap ! 255: * ! 256: * @v tftp TFTP connection ! 257: * @v filesize Known minimum file size ! 258: * @ret rc Return status code ! 259: */ ! 260: static int tftp_presize ( struct tftp_request *tftp, size_t filesize ) { ! 261: unsigned int num_blocks; ! 262: int rc; ! 263: ! 264: /* Do nothing if we are already large enough */ ! 265: if ( filesize <= tftp->filesize ) ! 266: return 0; ! 267: ! 268: /* Record filesize */ ! 269: tftp->filesize = filesize; ! 270: ! 271: /* Notify recipient of file size */ ! 272: xfer_seek ( &tftp->xfer, filesize ); ! 273: xfer_seek ( &tftp->xfer, 0 ); ! 274: ! 275: /* Calculate expected number of blocks. Note that files whose ! 276: * length is an exact multiple of the blocksize will have a ! 277: * trailing zero-length block, which must be included. ! 278: */ ! 279: num_blocks = ( ( filesize / tftp->blksize ) + 1 ); ! 280: if ( ( rc = bitmap_resize ( &tftp->bitmap, num_blocks ) ) != 0 ) { ! 281: DBGC ( tftp, "TFTP %p could not resize bitmap to %d blocks: " ! 282: "%s\n", tftp, num_blocks, strerror ( rc ) ); ! 283: return rc; ! 284: } ! 285: ! 286: return 0; ! 287: } ! 288: ! 289: /** ! 290: * TFTP requested blocksize ! 291: * ! 292: * This is treated as a global configuration parameter. ! 293: */ ! 294: static unsigned int tftp_request_blksize = TFTP_MAX_BLKSIZE; ! 295: ! 296: /** ! 297: * Set TFTP request blocksize ! 298: * ! 299: * @v blksize Requested block size ! 300: */ ! 301: void tftp_set_request_blksize ( unsigned int blksize ) { ! 302: if ( blksize < TFTP_DEFAULT_BLKSIZE ) ! 303: blksize = TFTP_DEFAULT_BLKSIZE; ! 304: tftp_request_blksize = blksize; ! 305: } ! 306: ! 307: /** ! 308: * MTFTP multicast receive address ! 309: * ! 310: * This is treated as a global configuration parameter. ! 311: */ ! 312: static struct sockaddr_in tftp_mtftp_socket = { ! 313: .sin_family = AF_INET, ! 314: .sin_addr.s_addr = htonl ( 0xefff0101 ), ! 315: .sin_port = htons ( 3001 ), ! 316: }; ! 317: ! 318: /** ! 319: * Set MTFTP multicast address ! 320: * ! 321: * @v address Multicast IPv4 address ! 322: */ ! 323: void tftp_set_mtftp_address ( struct in_addr address ) { ! 324: tftp_mtftp_socket.sin_addr = address; ! 325: } ! 326: ! 327: /** ! 328: * Set MTFTP multicast port ! 329: * ! 330: * @v port Multicast port ! 331: */ ! 332: void tftp_set_mtftp_port ( unsigned int port ) { ! 333: tftp_mtftp_socket.sin_port = htons ( port ); ! 334: } ! 335: ! 336: /** ! 337: * Transmit RRQ ! 338: * ! 339: * @v tftp TFTP connection ! 340: * @ret rc Return status code ! 341: */ ! 342: static int tftp_send_rrq ( struct tftp_request *tftp ) { ! 343: struct tftp_rrq *rrq; ! 344: const char *path; ! 345: size_t len; ! 346: struct io_buffer *iobuf; ! 347: ! 348: /* Strip initial '/' if present. If we were opened via the ! 349: * URI interface, then there will be an initial '/', since a ! 350: * full tftp:// URI provides no way to specify a non-absolute ! 351: * path. However, many TFTP servers (particularly Windows ! 352: * TFTP servers) complain about having an initial '/', and it ! 353: * violates user expectations to have a '/' silently added to ! 354: * the DHCP-specified filename. ! 355: */ ! 356: path = tftp->uri->path; ! 357: if ( *path == '/' ) ! 358: path++; ! 359: ! 360: DBGC ( tftp, "TFTP %p requesting \"%s\"\n", tftp, path ); ! 361: ! 362: /* Allocate buffer */ ! 363: len = ( sizeof ( *rrq ) + strlen ( path ) + 1 /* NUL */ ! 364: + 5 + 1 /* "octet" + NUL */ ! 365: + 7 + 1 + 5 + 1 /* "blksize" + NUL + ddddd + NUL */ ! 366: + 5 + 1 + 1 + 1 /* "tsize" + NUL + "0" + NUL */ ! 367: + 9 + 1 + 1 /* "multicast" + NUL + NUL */ ); ! 368: iobuf = xfer_alloc_iob ( &tftp->socket, len ); ! 369: if ( ! iobuf ) ! 370: return -ENOMEM; ! 371: ! 372: /* Build request */ ! 373: rrq = iob_put ( iobuf, sizeof ( *rrq ) ); ! 374: rrq->opcode = htons ( TFTP_RRQ ); ! 375: iob_put ( iobuf, snprintf ( iobuf->tail, iob_tailroom ( iobuf ), ! 376: "%s%coctet", path, 0 ) + 1 ); ! 377: if ( tftp->flags & TFTP_FL_RRQ_SIZES ) { ! 378: iob_put ( iobuf, snprintf ( iobuf->tail, ! 379: iob_tailroom ( iobuf ), ! 380: "blksize%c%d%ctsize%c0", 0, ! 381: tftp_request_blksize, 0, 0 ) + 1 ); ! 382: } ! 383: if ( tftp->flags & TFTP_FL_RRQ_MULTICAST ) { ! 384: iob_put ( iobuf, snprintf ( iobuf->tail, ! 385: iob_tailroom ( iobuf ), ! 386: "multicast%c", 0 ) + 1 ); ! 387: } ! 388: ! 389: /* RRQ always goes to the address specified in the initial ! 390: * xfer_open() call ! 391: */ ! 392: return xfer_deliver_iob ( &tftp->socket, iobuf ); ! 393: } ! 394: ! 395: /** ! 396: * Transmit ACK ! 397: * ! 398: * @v tftp TFTP connection ! 399: * @ret rc Return status code ! 400: */ ! 401: static int tftp_send_ack ( struct tftp_request *tftp ) { ! 402: struct tftp_ack *ack; ! 403: struct io_buffer *iobuf; ! 404: struct xfer_metadata meta = { ! 405: .dest = ( struct sockaddr * ) &tftp->peer, ! 406: }; ! 407: unsigned int block; ! 408: ! 409: /* Determine next required block number */ ! 410: block = bitmap_first_gap ( &tftp->bitmap ); ! 411: DBGC2 ( tftp, "TFTP %p sending ACK for block %d\n", tftp, block ); ! 412: ! 413: /* Allocate buffer */ ! 414: iobuf = xfer_alloc_iob ( &tftp->socket, sizeof ( *ack ) ); ! 415: if ( ! iobuf ) ! 416: return -ENOMEM; ! 417: ! 418: /* Build ACK */ ! 419: ack = iob_put ( iobuf, sizeof ( *ack ) ); ! 420: ack->opcode = htons ( TFTP_ACK ); ! 421: ack->block = htons ( block ); ! 422: ! 423: /* ACK always goes to the peer recorded from the RRQ response */ ! 424: return xfer_deliver ( &tftp->socket, iobuf, &meta ); ! 425: } ! 426: ! 427: /** ! 428: * Transmit ERROR (Abort) ! 429: * ! 430: * @v tftp TFTP connection ! 431: * @v errcode TFTP error code ! 432: * @v errmsg Error message string ! 433: * @ret rc Return status code ! 434: */ ! 435: static int tftp_send_error ( struct tftp_request *tftp, int errcode, ! 436: const char *errmsg ) { ! 437: struct tftp_error *err; ! 438: struct io_buffer *iobuf; ! 439: struct xfer_metadata meta = { ! 440: .dest = ( struct sockaddr * ) &tftp->peer, ! 441: }; ! 442: size_t msglen; ! 443: ! 444: DBGC2 ( tftp, "TFTP %p sending ERROR %d: %s\n", tftp, errcode, ! 445: errmsg ); ! 446: ! 447: /* Allocate buffer */ ! 448: msglen = sizeof ( *err ) + strlen ( errmsg ) + 1 /* NUL */; ! 449: iobuf = xfer_alloc_iob ( &tftp->socket, msglen ); ! 450: if ( ! iobuf ) ! 451: return -ENOMEM; ! 452: ! 453: /* Build ERROR */ ! 454: err = iob_put ( iobuf, msglen ); ! 455: err->opcode = htons ( TFTP_ERROR ); ! 456: err->errcode = htons ( errcode ); ! 457: strcpy ( err->errmsg, errmsg ); ! 458: ! 459: /* ERR always goes to the peer recorded from the RRQ response */ ! 460: return xfer_deliver ( &tftp->socket, iobuf, &meta ); ! 461: } ! 462: ! 463: /** ! 464: * Transmit next relevant packet ! 465: * ! 466: * @v tftp TFTP connection ! 467: * @ret rc Return status code ! 468: */ ! 469: static int tftp_send_packet ( struct tftp_request *tftp ) { ! 470: ! 471: /* Update retransmission timer. While name resolution takes place the ! 472: * window is zero. Avoid unnecessary delay after name resolution ! 473: * completes by retrying immediately. ! 474: */ ! 475: stop_timer ( &tftp->timer ); ! 476: if ( xfer_window ( &tftp->socket ) ) { ! 477: start_timer ( &tftp->timer ); ! 478: } else { ! 479: start_timer_nodelay ( &tftp->timer ); ! 480: } ! 481: ! 482: /* Send RRQ or ACK as appropriate */ ! 483: if ( ! tftp->peer.st_family ) { ! 484: return tftp_send_rrq ( tftp ); ! 485: } else { ! 486: if ( tftp->flags & TFTP_FL_SEND_ACK ) { ! 487: return tftp_send_ack ( tftp ); ! 488: } else { ! 489: return 0; ! 490: } ! 491: } ! 492: } ! 493: ! 494: /** ! 495: * Handle TFTP retransmission timer expiry ! 496: * ! 497: * @v timer Retry timer ! 498: * @v fail Failure indicator ! 499: */ ! 500: static void tftp_timer_expired ( struct retry_timer *timer, int fail ) { ! 501: struct tftp_request *tftp = ! 502: container_of ( timer, struct tftp_request, timer ); ! 503: int rc; ! 504: ! 505: /* If we are doing MTFTP, attempt the various recovery strategies */ ! 506: if ( tftp->flags & TFTP_FL_MTFTP_RECOVERY ) { ! 507: if ( tftp->peer.st_family ) { ! 508: /* If we have received any response from the server, ! 509: * try resending the RRQ to restart the download. ! 510: */ ! 511: DBGC ( tftp, "TFTP %p attempting reopen\n", tftp ); ! 512: if ( ( rc = tftp_reopen ( tftp ) ) != 0 ) ! 513: goto err; ! 514: } else { ! 515: /* Fall back to plain TFTP after several attempts */ ! 516: tftp->mtftp_timeouts++; ! 517: DBGC ( tftp, "TFTP %p timeout %d waiting for MTFTP " ! 518: "open\n", tftp, tftp->mtftp_timeouts ); ! 519: ! 520: if ( tftp->mtftp_timeouts > MTFTP_MAX_TIMEOUTS ) { ! 521: DBGC ( tftp, "TFTP %p falling back to plain " ! 522: "TFTP\n", tftp ); ! 523: tftp->flags = TFTP_FL_RRQ_SIZES; ! 524: ! 525: /* Close multicast socket */ ! 526: intf_restart ( &tftp->mc_socket, 0 ); ! 527: ! 528: /* Reset retry timer */ ! 529: start_timer_nodelay ( &tftp->timer ); ! 530: ! 531: /* The blocksize may change: discard ! 532: * the block bitmap ! 533: */ ! 534: bitmap_free ( &tftp->bitmap ); ! 535: memset ( &tftp->bitmap, 0, ! 536: sizeof ( tftp->bitmap ) ); ! 537: ! 538: /* Reopen on standard TFTP port */ ! 539: tftp->port = TFTP_PORT; ! 540: if ( ( rc = tftp_reopen ( tftp ) ) != 0 ) ! 541: goto err; ! 542: } ! 543: } ! 544: } else { ! 545: /* Not doing MTFTP (or have fallen back to plain ! 546: * TFTP); fail as per normal. ! 547: */ ! 548: if ( fail ) { ! 549: rc = -ETIMEDOUT; ! 550: goto err; ! 551: } ! 552: } ! 553: tftp_send_packet ( tftp ); ! 554: return; ! 555: ! 556: err: ! 557: tftp_done ( tftp, rc ); ! 558: } ! 559: ! 560: /** ! 561: * Process TFTP "blksize" option ! 562: * ! 563: * @v tftp TFTP connection ! 564: * @v value Option value ! 565: * @ret rc Return status code ! 566: */ ! 567: static int tftp_process_blksize ( struct tftp_request *tftp, ! 568: const char *value ) { ! 569: char *end; ! 570: ! 571: tftp->blksize = strtoul ( value, &end, 10 ); ! 572: if ( *end ) { ! 573: DBGC ( tftp, "TFTP %p got invalid blksize \"%s\"\n", ! 574: tftp, value ); ! 575: return -EINVAL_BLKSIZE; ! 576: } ! 577: DBGC ( tftp, "TFTP %p blksize=%d\n", tftp, tftp->blksize ); ! 578: ! 579: return 0; ! 580: } ! 581: ! 582: /** ! 583: * Process TFTP "tsize" option ! 584: * ! 585: * @v tftp TFTP connection ! 586: * @v value Option value ! 587: * @ret rc Return status code ! 588: */ ! 589: static int tftp_process_tsize ( struct tftp_request *tftp, ! 590: const char *value ) { ! 591: char *end; ! 592: ! 593: tftp->tsize = strtoul ( value, &end, 10 ); ! 594: if ( *end ) { ! 595: DBGC ( tftp, "TFTP %p got invalid tsize \"%s\"\n", ! 596: tftp, value ); ! 597: return -EINVAL_TSIZE; ! 598: } ! 599: DBGC ( tftp, "TFTP %p tsize=%ld\n", tftp, tftp->tsize ); ! 600: ! 601: return 0; ! 602: } ! 603: ! 604: /** ! 605: * Process TFTP "multicast" option ! 606: * ! 607: * @v tftp TFTP connection ! 608: * @v value Option value ! 609: * @ret rc Return status code ! 610: */ ! 611: static int tftp_process_multicast ( struct tftp_request *tftp, ! 612: const char *value ) { ! 613: union { ! 614: struct sockaddr sa; ! 615: struct sockaddr_in sin; ! 616: } socket; ! 617: char buf[ strlen ( value ) + 1 ]; ! 618: char *addr; ! 619: char *port; ! 620: char *port_end; ! 621: char *mc; ! 622: char *mc_end; ! 623: int rc; ! 624: ! 625: /* Split value into "addr,port,mc" fields */ ! 626: memcpy ( buf, value, sizeof ( buf ) ); ! 627: addr = buf; ! 628: port = strchr ( addr, ',' ); ! 629: if ( ! port ) { ! 630: DBGC ( tftp, "TFTP %p multicast missing port,mc\n", tftp ); ! 631: return -EINVAL_MC_NO_PORT; ! 632: } ! 633: *(port++) = '\0'; ! 634: mc = strchr ( port, ',' ); ! 635: if ( ! mc ) { ! 636: DBGC ( tftp, "TFTP %p multicast missing mc\n", tftp ); ! 637: return -EINVAL_MC_NO_MC; ! 638: } ! 639: *(mc++) = '\0'; ! 640: ! 641: /* Parse parameters */ ! 642: if ( strtoul ( mc, &mc_end, 0 ) == 0 ) ! 643: tftp->flags &= ~TFTP_FL_SEND_ACK; ! 644: if ( *mc_end ) { ! 645: DBGC ( tftp, "TFTP %p multicast invalid mc %s\n", tftp, mc ); ! 646: return -EINVAL_MC_INVALID_MC; ! 647: } ! 648: DBGC ( tftp, "TFTP %p is%s the master client\n", ! 649: tftp, ( ( tftp->flags & TFTP_FL_SEND_ACK ) ? "" : " not" ) ); ! 650: if ( *addr && *port ) { ! 651: socket.sin.sin_family = AF_INET; ! 652: if ( inet_aton ( addr, &socket.sin.sin_addr ) == 0 ) { ! 653: DBGC ( tftp, "TFTP %p multicast invalid IP address " ! 654: "%s\n", tftp, addr ); ! 655: return -EINVAL_MC_INVALID_IP; ! 656: } ! 657: DBGC ( tftp, "TFTP %p multicast IP address %s\n", ! 658: tftp, inet_ntoa ( socket.sin.sin_addr ) ); ! 659: socket.sin.sin_port = htons ( strtoul ( port, &port_end, 0 ) ); ! 660: if ( *port_end ) { ! 661: DBGC ( tftp, "TFTP %p multicast invalid port %s\n", ! 662: tftp, port ); ! 663: return -EINVAL_MC_INVALID_PORT; ! 664: } ! 665: DBGC ( tftp, "TFTP %p multicast port %d\n", ! 666: tftp, ntohs ( socket.sin.sin_port ) ); ! 667: if ( ( rc = tftp_reopen_mc ( tftp, &socket.sa ) ) != 0 ) ! 668: return rc; ! 669: } ! 670: ! 671: return 0; ! 672: } ! 673: ! 674: /** A TFTP option */ ! 675: struct tftp_option { ! 676: /** Option name */ ! 677: const char *name; ! 678: /** Option processor ! 679: * ! 680: * @v tftp TFTP connection ! 681: * @v value Option value ! 682: * @ret rc Return status code ! 683: */ ! 684: int ( * process ) ( struct tftp_request *tftp, const char *value ); ! 685: }; ! 686: ! 687: /** Recognised TFTP options */ ! 688: static struct tftp_option tftp_options[] = { ! 689: { "blksize", tftp_process_blksize }, ! 690: { "tsize", tftp_process_tsize }, ! 691: { "multicast", tftp_process_multicast }, ! 692: { NULL, NULL } ! 693: }; ! 694: ! 695: /** ! 696: * Process TFTP option ! 697: * ! 698: * @v tftp TFTP connection ! 699: * @v name Option name ! 700: * @v value Option value ! 701: * @ret rc Return status code ! 702: */ ! 703: static int tftp_process_option ( struct tftp_request *tftp, ! 704: const char *name, const char *value ) { ! 705: struct tftp_option *option; ! 706: ! 707: for ( option = tftp_options ; option->name ; option++ ) { ! 708: if ( strcasecmp ( name, option->name ) == 0 ) ! 709: return option->process ( tftp, value ); ! 710: } ! 711: ! 712: DBGC ( tftp, "TFTP %p received unknown option \"%s\" = \"%s\"\n", ! 713: tftp, name, value ); ! 714: ! 715: /* Unknown options should be silently ignored */ ! 716: return 0; ! 717: } ! 718: ! 719: /** ! 720: * Receive OACK ! 721: * ! 722: * @v tftp TFTP connection ! 723: * @v buf Temporary data buffer ! 724: * @v len Length of temporary data buffer ! 725: * @ret rc Return status code ! 726: */ ! 727: static int tftp_rx_oack ( struct tftp_request *tftp, void *buf, size_t len ) { ! 728: struct tftp_oack *oack = buf; ! 729: char *end = buf + len; ! 730: char *name; ! 731: char *value; ! 732: char *next; ! 733: int rc = 0; ! 734: ! 735: /* Sanity check */ ! 736: if ( len < sizeof ( *oack ) ) { ! 737: DBGC ( tftp, "TFTP %p received underlength OACK packet " ! 738: "length %zd\n", tftp, len ); ! 739: rc = -EINVAL; ! 740: goto done; ! 741: } ! 742: ! 743: /* Process each option in turn */ ! 744: for ( name = oack->data ; name < end ; name = next ) { ! 745: ! 746: /* Parse option name and value ! 747: * ! 748: * We treat parsing errors as non-fatal, because there ! 749: * exists at least one TFTP server (IBM Tivoli PXE ! 750: * Server 5.1.0.3) that has been observed to send ! 751: * malformed OACKs containing trailing garbage bytes. ! 752: */ ! 753: value = ( name + strnlen ( name, ( end - name ) ) + 1 ); ! 754: if ( value > end ) { ! 755: DBGC ( tftp, "TFTP %p received OACK with malformed " ! 756: "option name:\n", tftp ); ! 757: DBGC_HD ( tftp, oack, len ); ! 758: break; ! 759: } ! 760: if ( value == end ) { ! 761: DBGC ( tftp, "TFTP %p received OACK missing value " ! 762: "for option \"%s\"\n", tftp, name ); ! 763: DBGC_HD ( tftp, oack, len ); ! 764: break; ! 765: } ! 766: next = ( value + strnlen ( value, ( end - value ) ) + 1 ); ! 767: if ( next > end ) { ! 768: DBGC ( tftp, "TFTP %p received OACK with malformed " ! 769: "value for option \"%s\":\n", tftp, name ); ! 770: DBGC_HD ( tftp, oack, len ); ! 771: break; ! 772: } ! 773: ! 774: /* Process option */ ! 775: if ( ( rc = tftp_process_option ( tftp, name, value ) ) != 0 ) ! 776: goto done; ! 777: } ! 778: ! 779: /* Process tsize information, if available */ ! 780: if ( tftp->tsize ) { ! 781: if ( ( rc = tftp_presize ( tftp, tftp->tsize ) ) != 0 ) ! 782: goto done; ! 783: } ! 784: ! 785: /* Abort request if only trying to determine file size */ ! 786: if ( tftp->flags & TFTP_FL_SIZEONLY ) { ! 787: rc = 0; ! 788: tftp_send_error ( tftp, 0, "TFTP Aborted" ); ! 789: tftp_done ( tftp, rc ); ! 790: return rc; ! 791: } ! 792: ! 793: /* Request next data block */ ! 794: tftp_send_packet ( tftp ); ! 795: ! 796: done: ! 797: if ( rc ) ! 798: tftp_done ( tftp, rc ); ! 799: return rc; ! 800: } ! 801: ! 802: /** ! 803: * Receive DATA ! 804: * ! 805: * @v tftp TFTP connection ! 806: * @v iobuf I/O buffer ! 807: * @ret rc Return status code ! 808: * ! 809: * Takes ownership of I/O buffer. ! 810: */ ! 811: static int tftp_rx_data ( struct tftp_request *tftp, ! 812: struct io_buffer *iobuf ) { ! 813: struct tftp_data *data = iobuf->data; ! 814: struct xfer_metadata meta; ! 815: unsigned int block; ! 816: off_t offset; ! 817: size_t data_len; ! 818: int rc; ! 819: ! 820: if ( tftp->flags & TFTP_FL_SIZEONLY ) { ! 821: /* If we get here then server doesn't support SIZE option */ ! 822: rc = -ENOTSUP; ! 823: tftp_send_error ( tftp, 0, "TFTP Aborted" ); ! 824: goto done; ! 825: } ! 826: ! 827: /* Sanity check */ ! 828: if ( iob_len ( iobuf ) < sizeof ( *data ) ) { ! 829: DBGC ( tftp, "TFTP %p received underlength DATA packet " ! 830: "length %zd\n", tftp, iob_len ( iobuf ) ); ! 831: rc = -EINVAL; ! 832: goto done; ! 833: } ! 834: ! 835: /* Calculate block number */ ! 836: block = ( ( bitmap_first_gap ( &tftp->bitmap ) + 1 ) & ~0xffff ); ! 837: if ( data->block == 0 && block == 0 ) { ! 838: DBGC ( tftp, "TFTP %p received data block 0\n", tftp ); ! 839: rc = -EINVAL; ! 840: goto done; ! 841: } ! 842: block += ( ntohs ( data->block ) - 1 ); ! 843: ! 844: /* Extract data */ ! 845: offset = ( block * tftp->blksize ); ! 846: iob_pull ( iobuf, sizeof ( *data ) ); ! 847: data_len = iob_len ( iobuf ); ! 848: if ( data_len > tftp->blksize ) { ! 849: DBGC ( tftp, "TFTP %p received overlength DATA packet " ! 850: "length %zd\n", tftp, data_len ); ! 851: rc = -EINVAL; ! 852: goto done; ! 853: } ! 854: ! 855: /* Deliver data */ ! 856: memset ( &meta, 0, sizeof ( meta ) ); ! 857: meta.flags = XFER_FL_ABS_OFFSET; ! 858: meta.offset = offset; ! 859: if ( ( rc = xfer_deliver ( &tftp->xfer, iob_disown ( iobuf ), ! 860: &meta ) ) != 0 ) { ! 861: DBGC ( tftp, "TFTP %p could not deliver data: %s\n", ! 862: tftp, strerror ( rc ) ); ! 863: goto done; ! 864: } ! 865: ! 866: /* Ensure block bitmap is ready */ ! 867: if ( ( rc = tftp_presize ( tftp, ( offset + data_len ) ) ) != 0 ) ! 868: goto done; ! 869: ! 870: /* Mark block as received */ ! 871: bitmap_set ( &tftp->bitmap, block ); ! 872: ! 873: /* Acknowledge block */ ! 874: tftp_send_packet ( tftp ); ! 875: ! 876: /* If all blocks have been received, finish. */ ! 877: if ( bitmap_full ( &tftp->bitmap ) ) ! 878: tftp_done ( tftp, 0 ); ! 879: ! 880: done: ! 881: free_iob ( iobuf ); ! 882: if ( rc ) ! 883: tftp_done ( tftp, rc ); ! 884: return rc; ! 885: } ! 886: ! 887: /** ! 888: * Convert TFTP error code to return status code ! 889: * ! 890: * @v errcode TFTP error code ! 891: * @ret rc Return status code ! 892: */ ! 893: static int tftp_errcode_to_rc ( unsigned int errcode ) { ! 894: switch ( errcode ) { ! 895: case TFTP_ERR_FILE_NOT_FOUND: return -ENOENT; ! 896: case TFTP_ERR_ACCESS_DENIED: return -EACCES; ! 897: case TFTP_ERR_ILLEGAL_OP: return -ENOTTY; ! 898: default: return -ENOTSUP; ! 899: } ! 900: } ! 901: ! 902: /** ! 903: * Receive ERROR ! 904: * ! 905: * @v tftp TFTP connection ! 906: * @v buf Temporary data buffer ! 907: * @v len Length of temporary data buffer ! 908: * @ret rc Return status code ! 909: */ ! 910: static int tftp_rx_error ( struct tftp_request *tftp, void *buf, size_t len ) { ! 911: struct tftp_error *error = buf; ! 912: int rc; ! 913: ! 914: /* Sanity check */ ! 915: if ( len < sizeof ( *error ) ) { ! 916: DBGC ( tftp, "TFTP %p received underlength ERROR packet " ! 917: "length %zd\n", tftp, len ); ! 918: return -EINVAL; ! 919: } ! 920: ! 921: DBGC ( tftp, "TFTP %p received ERROR packet with code %d, message " ! 922: "\"%s\"\n", tftp, ntohs ( error->errcode ), error->errmsg ); ! 923: ! 924: /* Determine final operation result */ ! 925: rc = tftp_errcode_to_rc ( ntohs ( error->errcode ) ); ! 926: ! 927: /* Close TFTP request */ ! 928: tftp_done ( tftp, rc ); ! 929: ! 930: return 0; ! 931: } ! 932: ! 933: /** ! 934: * Receive new data ! 935: * ! 936: * @v tftp TFTP connection ! 937: * @v iobuf I/O buffer ! 938: * @v meta Transfer metadata ! 939: * @ret rc Return status code ! 940: */ ! 941: static int tftp_rx ( struct tftp_request *tftp, ! 942: struct io_buffer *iobuf, ! 943: struct xfer_metadata *meta ) { ! 944: struct sockaddr_tcpip *st_src; ! 945: struct tftp_common *common = iobuf->data; ! 946: size_t len = iob_len ( iobuf ); ! 947: int rc = -EINVAL; ! 948: ! 949: /* Sanity checks */ ! 950: if ( len < sizeof ( *common ) ) { ! 951: DBGC ( tftp, "TFTP %p received underlength packet length " ! 952: "%zd\n", tftp, len ); ! 953: goto done; ! 954: } ! 955: if ( ! meta->src ) { ! 956: DBGC ( tftp, "TFTP %p received packet without source port\n", ! 957: tftp ); ! 958: goto done; ! 959: } ! 960: ! 961: /* Filter by TID. Set TID on first response received */ ! 962: st_src = ( struct sockaddr_tcpip * ) meta->src; ! 963: if ( ! tftp->peer.st_family ) { ! 964: memcpy ( &tftp->peer, st_src, sizeof ( tftp->peer ) ); ! 965: DBGC ( tftp, "TFTP %p using remote port %d\n", tftp, ! 966: ntohs ( tftp->peer.st_port ) ); ! 967: } else if ( memcmp ( &tftp->peer, st_src, ! 968: sizeof ( tftp->peer ) ) != 0 ) { ! 969: DBGC ( tftp, "TFTP %p received packet from wrong source (got " ! 970: "%d, wanted %d)\n", tftp, ntohs ( st_src->st_port ), ! 971: ntohs ( tftp->peer.st_port ) ); ! 972: goto done; ! 973: } ! 974: ! 975: switch ( common->opcode ) { ! 976: case htons ( TFTP_OACK ): ! 977: rc = tftp_rx_oack ( tftp, iobuf->data, len ); ! 978: break; ! 979: case htons ( TFTP_DATA ): ! 980: rc = tftp_rx_data ( tftp, iob_disown ( iobuf ) ); ! 981: break; ! 982: case htons ( TFTP_ERROR ): ! 983: rc = tftp_rx_error ( tftp, iobuf->data, len ); ! 984: break; ! 985: default: ! 986: DBGC ( tftp, "TFTP %p received strange packet type %d\n", ! 987: tftp, ntohs ( common->opcode ) ); ! 988: break; ! 989: }; ! 990: ! 991: done: ! 992: free_iob ( iobuf ); ! 993: return rc; ! 994: } ! 995: ! 996: /** ! 997: * Receive new data via socket ! 998: * ! 999: * @v tftp TFTP connection ! 1000: * @v iobuf I/O buffer ! 1001: * @v meta Transfer metadata ! 1002: * @ret rc Return status code ! 1003: */ ! 1004: static int tftp_socket_deliver ( struct tftp_request *tftp, ! 1005: struct io_buffer *iobuf, ! 1006: struct xfer_metadata *meta ) { ! 1007: ! 1008: /* Enable sending ACKs when we receive a unicast packet. This ! 1009: * covers three cases: ! 1010: * ! 1011: * 1. Standard TFTP; we should always send ACKs, and will ! 1012: * always receive a unicast packet before we need to send the ! 1013: * first ACK. ! 1014: * ! 1015: * 2. RFC2090 multicast TFTP; the only unicast packets we will ! 1016: * receive are the OACKs; enable sending ACKs here (before ! 1017: * processing the OACK) and disable it when processing the ! 1018: * multicast option if we are not the master client. ! 1019: * ! 1020: * 3. MTFTP; receiving a unicast datagram indicates that we ! 1021: * are the "master client" and should send ACKs. ! 1022: */ ! 1023: tftp->flags |= TFTP_FL_SEND_ACK; ! 1024: ! 1025: return tftp_rx ( tftp, iobuf, meta ); ! 1026: } ! 1027: ! 1028: /** TFTP socket operations */ ! 1029: static struct interface_operation tftp_socket_operations[] = { ! 1030: INTF_OP ( xfer_deliver, struct tftp_request *, tftp_socket_deliver ), ! 1031: }; ! 1032: ! 1033: /** TFTP socket interface descriptor */ ! 1034: static struct interface_descriptor tftp_socket_desc = ! 1035: INTF_DESC ( struct tftp_request, socket, tftp_socket_operations ); ! 1036: ! 1037: /** TFTP multicast socket operations */ ! 1038: static struct interface_operation tftp_mc_socket_operations[] = { ! 1039: INTF_OP ( xfer_deliver, struct tftp_request *, tftp_rx ), ! 1040: }; ! 1041: ! 1042: /** TFTP multicast socket interface descriptor */ ! 1043: static struct interface_descriptor tftp_mc_socket_desc = ! 1044: INTF_DESC ( struct tftp_request, mc_socket, tftp_mc_socket_operations ); ! 1045: ! 1046: /** ! 1047: * Check flow control window ! 1048: * ! 1049: * @v tftp TFTP connection ! 1050: * @ret len Length of window ! 1051: */ ! 1052: static size_t tftp_xfer_window ( struct tftp_request *tftp ) { ! 1053: ! 1054: /* We abuse this data-xfer method to convey the blocksize to ! 1055: * the caller. This really should be done using some kind of ! 1056: * stat() method, but we don't yet have the facility to do ! 1057: * that. ! 1058: */ ! 1059: return tftp->blksize; ! 1060: } ! 1061: ! 1062: /** TFTP data transfer interface operations */ ! 1063: static struct interface_operation tftp_xfer_operations[] = { ! 1064: INTF_OP ( xfer_window, struct tftp_request *, tftp_xfer_window ), ! 1065: INTF_OP ( intf_close, struct tftp_request *, tftp_done ), ! 1066: }; ! 1067: ! 1068: /** TFTP data transfer interface descriptor */ ! 1069: static struct interface_descriptor tftp_xfer_desc = ! 1070: INTF_DESC ( struct tftp_request, xfer, tftp_xfer_operations ); ! 1071: ! 1072: /** ! 1073: * Initiate TFTP/TFTM/MTFTP download ! 1074: * ! 1075: * @v xfer Data transfer interface ! 1076: * @v uri Uniform Resource Identifier ! 1077: * @ret rc Return status code ! 1078: */ ! 1079: static int tftp_core_open ( struct interface *xfer, struct uri *uri, ! 1080: unsigned int default_port, ! 1081: struct sockaddr *multicast, ! 1082: unsigned int flags ) { ! 1083: struct tftp_request *tftp; ! 1084: int rc; ! 1085: ! 1086: /* Sanity checks */ ! 1087: if ( ! uri->host ) ! 1088: return -EINVAL; ! 1089: if ( ! uri->path ) ! 1090: return -EINVAL; ! 1091: ! 1092: /* Allocate and populate TFTP structure */ ! 1093: tftp = zalloc ( sizeof ( *tftp ) ); ! 1094: if ( ! tftp ) ! 1095: return -ENOMEM; ! 1096: ref_init ( &tftp->refcnt, tftp_free ); ! 1097: intf_init ( &tftp->xfer, &tftp_xfer_desc, &tftp->refcnt ); ! 1098: intf_init ( &tftp->socket, &tftp_socket_desc, &tftp->refcnt ); ! 1099: intf_init ( &tftp->mc_socket, &tftp_mc_socket_desc, &tftp->refcnt ); ! 1100: timer_init ( &tftp->timer, tftp_timer_expired, &tftp->refcnt ); ! 1101: tftp->uri = uri_get ( uri ); ! 1102: tftp->blksize = TFTP_DEFAULT_BLKSIZE; ! 1103: tftp->flags = flags; ! 1104: ! 1105: /* Open socket */ ! 1106: tftp->port = uri_port ( tftp->uri, default_port ); ! 1107: if ( ( rc = tftp_reopen ( tftp ) ) != 0 ) ! 1108: goto err; ! 1109: ! 1110: /* Open multicast socket */ ! 1111: if ( multicast ) { ! 1112: if ( ( rc = tftp_reopen_mc ( tftp, multicast ) ) != 0 ) ! 1113: goto err; ! 1114: } ! 1115: ! 1116: /* Start timer to initiate RRQ */ ! 1117: start_timer_nodelay ( &tftp->timer ); ! 1118: ! 1119: /* Attach to parent interface, mortalise self, and return */ ! 1120: intf_plug_plug ( &tftp->xfer, xfer ); ! 1121: ref_put ( &tftp->refcnt ); ! 1122: return 0; ! 1123: ! 1124: err: ! 1125: DBGC ( tftp, "TFTP %p could not create request: %s\n", ! 1126: tftp, strerror ( rc ) ); ! 1127: tftp_done ( tftp, rc ); ! 1128: ref_put ( &tftp->refcnt ); ! 1129: return rc; ! 1130: } ! 1131: ! 1132: /** ! 1133: * Initiate TFTP download ! 1134: * ! 1135: * @v xfer Data transfer interface ! 1136: * @v uri Uniform Resource Identifier ! 1137: * @ret rc Return status code ! 1138: */ ! 1139: static int tftp_open ( struct interface *xfer, struct uri *uri ) { ! 1140: return tftp_core_open ( xfer, uri, TFTP_PORT, NULL, ! 1141: TFTP_FL_RRQ_SIZES ); ! 1142: ! 1143: } ! 1144: ! 1145: /** TFTP URI opener */ ! 1146: struct uri_opener tftp_uri_opener __uri_opener = { ! 1147: .scheme = "tftp", ! 1148: .open = tftp_open, ! 1149: }; ! 1150: ! 1151: /** ! 1152: * Initiate TFTP-size request ! 1153: * ! 1154: * @v xfer Data transfer interface ! 1155: * @v uri Uniform Resource Identifier ! 1156: * @ret rc Return status code ! 1157: */ ! 1158: static int tftpsize_open ( struct interface *xfer, struct uri *uri ) { ! 1159: return tftp_core_open ( xfer, uri, TFTP_PORT, NULL, ! 1160: ( TFTP_FL_RRQ_SIZES | ! 1161: TFTP_FL_SIZEONLY ) ); ! 1162: ! 1163: } ! 1164: ! 1165: /** TFTP URI opener */ ! 1166: struct uri_opener tftpsize_uri_opener __uri_opener = { ! 1167: .scheme = "tftpsize", ! 1168: .open = tftpsize_open, ! 1169: }; ! 1170: ! 1171: /** ! 1172: * Initiate TFTM download ! 1173: * ! 1174: * @v xfer Data transfer interface ! 1175: * @v uri Uniform Resource Identifier ! 1176: * @ret rc Return status code ! 1177: */ ! 1178: static int tftm_open ( struct interface *xfer, struct uri *uri ) { ! 1179: return tftp_core_open ( xfer, uri, TFTP_PORT, NULL, ! 1180: ( TFTP_FL_RRQ_SIZES | ! 1181: TFTP_FL_RRQ_MULTICAST ) ); ! 1182: ! 1183: } ! 1184: ! 1185: /** TFTM URI opener */ ! 1186: struct uri_opener tftm_uri_opener __uri_opener = { ! 1187: .scheme = "tftm", ! 1188: .open = tftm_open, ! 1189: }; ! 1190: ! 1191: /** ! 1192: * Initiate MTFTP download ! 1193: * ! 1194: * @v xfer Data transfer interface ! 1195: * @v uri Uniform Resource Identifier ! 1196: * @ret rc Return status code ! 1197: */ ! 1198: static int mtftp_open ( struct interface *xfer, struct uri *uri ) { ! 1199: return tftp_core_open ( xfer, uri, MTFTP_PORT, ! 1200: ( struct sockaddr * ) &tftp_mtftp_socket, ! 1201: TFTP_FL_MTFTP_RECOVERY ); ! 1202: } ! 1203: ! 1204: /** MTFTP URI opener */ ! 1205: struct uri_opener mtftp_uri_opener __uri_opener = { ! 1206: .scheme = "mtftp", ! 1207: .open = mtftp_open, ! 1208: }; ! 1209: ! 1210: /****************************************************************************** ! 1211: * ! 1212: * Settings ! 1213: * ! 1214: ****************************************************************************** ! 1215: */ ! 1216: ! 1217: /** TFTP server setting */ ! 1218: struct setting next_server_setting __setting ( SETTING_BOOT ) = { ! 1219: .name = "next-server", ! 1220: .description = "TFTP server", ! 1221: .tag = DHCP_EB_SIADDR, ! 1222: .type = &setting_type_ipv4, ! 1223: }; ! 1224: ! 1225: /** ! 1226: * Apply TFTP configuration settings ! 1227: * ! 1228: * @ret rc Return status code ! 1229: */ ! 1230: static int tftp_apply_settings ( void ) { ! 1231: static struct in_addr tftp_server = { 0 }; ! 1232: struct in_addr last_tftp_server; ! 1233: char uri_string[32]; ! 1234: struct uri *uri; ! 1235: ! 1236: /* Retrieve TFTP server setting */ ! 1237: last_tftp_server = tftp_server; ! 1238: fetch_ipv4_setting ( NULL, &next_server_setting, &tftp_server ); ! 1239: ! 1240: /* If TFTP server setting has changed, set the current working ! 1241: * URI to match. Do it only when the TFTP server has changed ! 1242: * to try to minimise surprises to the user, who probably ! 1243: * won't expect the CWURI to change just because they updated ! 1244: * an unrelated setting and triggered all the settings ! 1245: * applicators. ! 1246: */ ! 1247: if ( tftp_server.s_addr != last_tftp_server.s_addr ) { ! 1248: if ( tftp_server.s_addr ) { ! 1249: snprintf ( uri_string, sizeof ( uri_string ), ! 1250: "tftp://%s/", inet_ntoa ( tftp_server ) ); ! 1251: uri = parse_uri ( uri_string ); ! 1252: if ( ! uri ) ! 1253: return -ENOMEM; ! 1254: } else { ! 1255: uri = NULL; ! 1256: } ! 1257: churi ( uri ); ! 1258: uri_put ( uri ); ! 1259: } ! 1260: ! 1261: return 0; ! 1262: } ! 1263: ! 1264: /** TFTP settings applicator */ ! 1265: struct settings_applicator tftp_settings_applicator __settings_applicator = { ! 1266: .apply = tftp_apply_settings, ! 1267: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.