src/net/udp/tftp.c

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