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 = tftp->uri->path;
 320         size_t len = ( sizeof ( *rrq ) + strlen ( path ) + 1 /* NUL */
 321                        + 5 + 1 /* "octet" + NUL */
 322                        + 7 + 1 + 5 + 1 /* "blksize" + NUL + ddddd + NUL */
 323                        + 5 + 1 + 1 + 1 /* "tsize" + NUL + "0" + NUL */
 324                        + 9 + 1 + 1 /* "multicast" + NUL + NUL */ );
 325         struct io_buffer *iobuf;
 326
 327         DBGC ( tftp, "TFTP %p requesting \"%s\"\n", tftp, path );
 328
 329         /* Allocate buffer */
 330         iobuf = xfer_alloc_iob ( &tftp->socket, len );
 331         if ( ! iobuf )
 332                 return -ENOMEM;
 333
 334         /* Build request */
 335         rrq = iob_put ( iobuf, sizeof ( *rrq ) );
 336         rrq->opcode = htons ( TFTP_RRQ );
 337         iob_put ( iobuf, snprintf ( iobuf->tail, iob_tailroom ( iobuf ),
 338                                     "%s%coctet", path, 0 ) + 1 );
 339         if ( tftp->flags & TFTP_FL_RRQ_SIZES ) {
 340                 iob_put ( iobuf, snprintf ( iobuf->tail,
 341                                             iob_tailroom ( iobuf ),
 342                                             "blksize%c%d%ctsize%c0", 0,
 343                                             tftp_request_blksize, 0, 0 ) + 1 );
 344         }
 345         if ( tftp->flags & TFTP_FL_RRQ_MULTICAST ) {
 346                 iob_put ( iobuf, snprintf ( iobuf->tail,
 347                                             iob_tailroom ( iobuf ),
 348                                             "multicast%c", 0 ) + 1 );
 349         }
 350
 351         /* RRQ always goes to the address specified in the initial
 352          * xfer_open() call
 353          */
 354         return xfer_deliver_iob ( &tftp->socket, iobuf );
 355 }
 356
 357 /**
 358  * Transmit ACK
 359  *
 360  * @v tftp              TFTP connection
 361  * @ret rc              Return status code
 362  */
 363 static int tftp_send_ack ( struct tftp_request *tftp ) {
 364         struct tftp_ack *ack;
 365         struct io_buffer *iobuf;
 366         struct xfer_metadata meta = {
 367                 .dest = ( struct sockaddr * ) &tftp->peer,
 368         };
 369         unsigned int block;
 370
 371         /* Determine next required block number */
 372         block = bitmap_first_gap ( &tftp->bitmap );
 373         DBGC2 ( tftp, "TFTP %p sending ACK for block %d\n", tftp, block );
 374
 375         /* Allocate buffer */
 376         iobuf = xfer_alloc_iob ( &tftp->socket, sizeof ( *ack ) );
 377         if ( ! iobuf )
 378                 return -ENOMEM;
 379
 380         /* Build ACK */
 381         ack = iob_put ( iobuf, sizeof ( *ack ) );
 382         ack->opcode = htons ( TFTP_ACK );
 383         ack->block = htons ( block );
 384
 385         /* ACK always goes to the peer recorded from the RRQ response */
 386         return xfer_deliver_iob_meta ( &tftp->socket, iobuf, &meta );
 387 }
 388
 389 /**
 390  * Transmit next relevant packet
 391  *
 392  * @v tftp              TFTP connection
 393  * @ret rc              Return status code
 394  */
 395 static int tftp_send_packet ( struct tftp_request *tftp ) {
 396
 397         /* Update retransmission timer */
 398         stop_timer ( &tftp->timer );
 399         start_timer ( &tftp->timer );
 400
 401         /* Send RRQ or ACK as appropriate */
 402         if ( ! tftp->peer.st_family ) {
 403                 return tftp_send_rrq ( tftp );
 404         } else {
 405                 if ( tftp->flags & TFTP_FL_SEND_ACK ) {
 406                         return tftp_send_ack ( tftp );
 407                 } else {
 408                         return 0;
 409                 }
 410         }
 411 }
 412
 413 /**
 414  * Handle TFTP retransmission timer expiry
 415  *
 416  * @v timer             Retry timer
 417  * @v fail              Failure indicator
 418  */
 419 static void tftp_timer_expired ( struct retry_timer *timer, int fail ) {
 420         struct tftp_request *tftp =
 421                 container_of ( timer, struct tftp_request, timer );
 422         int rc;
 423
 424         /* If we are doing MTFTP, attempt the various recovery strategies */
 425         if ( tftp->flags & TFTP_FL_MTFTP_RECOVERY ) {
 426                 if ( tftp->peer.st_family ) {
 427                         /* If we have received any response from the server,
 428                          * try resending the RRQ to restart the download.
 429                          */
 430                         DBGC ( tftp, "TFTP %p attempting reopen\n", tftp );
 431                         if ( ( rc = tftp_reopen ( tftp ) ) != 0 )
 432                                 goto err;
 433                 } else {
 434                         /* Fall back to plain TFTP after several attempts */
 435                         tftp->mtftp_timeouts++;
 436                         DBGC ( tftp, "TFTP %p timeout %d waiting for MTFTP "
 437                                "open\n", tftp, tftp->mtftp_timeouts );
 438
 439                         if ( tftp->mtftp_timeouts > MTFTP_MAX_TIMEOUTS ) {
 440                                 DBGC ( tftp, "TFTP %p falling back to plain "
 441                                        "TFTP\n", tftp );
 442                                 tftp->flags = TFTP_FL_RRQ_SIZES;
 443
 444                                 /* Close multicast socket */
 445                                 xfer_close ( &tftp->mc_socket, 0 );
 446
 447                                 /* Reset retry timer */
 448                                 start_timer_nodelay ( &tftp->timer );
 449
 450                                 /* The blocksize may change: discard
 451                                  * the block bitmap
 452                                  */
 453                                 bitmap_free ( &tftp->bitmap );
 454                                 memset ( &tftp->bitmap, 0,
 455                                          sizeof ( tftp->bitmap ) );
 456
 457                                 /* Reopen on standard TFTP port */
 458                                 tftp->port = TFTP_PORT;
 459                                 if ( ( rc = tftp_reopen ( tftp ) ) != 0 )
 460                                         goto err;
 461                         }
 462                 }
 463         } else {
 464                 /* Not doing MTFTP (or have fallen back to plain
 465                  * TFTP); fail as per normal.
 466                  */
 467                 if ( fail ) {
 468                         rc = -ETIMEDOUT;
 469                         goto err;
 470                 }
 471         }
 472         tftp_send_packet ( tftp );
 473         return;
 474
 475  err:
 476         tftp_done ( tftp, rc );
 477 }
 478
 479 /**
 480  * Process TFTP "blksize" option
 481  *
 482  * @v tftp              TFTP connection
 483  * @v value             Option value
 484  * @ret rc              Return status code
 485  */
 486 static int tftp_process_blksize ( struct tftp_request *tftp,
 487                                   const char *value ) {
 488         char *end;
 489
 490         tftp->blksize = strtoul ( value, &end, 10 );
 491         if ( *end ) {
 492                 DBGC ( tftp, "TFTP %p got invalid blksize \"%s\"\n",
 493                        tftp, value );
 494                 return -EINVAL;
 495         }
 496         DBGC ( tftp, "TFTP %p blksize=%d\n", tftp, tftp->blksize );
 497
 498         return 0;
 499 }
 500
 501 /**
 502  * Process TFTP "tsize" option
 503  *
 504  * @v tftp              TFTP connection
 505  * @v value             Option value
 506  * @ret rc              Return status code
 507  */
 508 static int tftp_process_tsize ( struct tftp_request *tftp,
 509                                 const char *value ) {
 510         char *end;
 511
 512         tftp->tsize = strtoul ( value, &end, 10 );
 513         if ( *end ) {
 514                 DBGC ( tftp, "TFTP %p got invalid tsize \"%s\"\n",
 515                        tftp, value );
 516                 return -EINVAL;
 517         }
 518         DBGC ( tftp, "TFTP %p tsize=%ld\n", tftp, tftp->tsize );
 519
 520         return 0;
 521 }
 522
 523 /**
 524  * Process TFTP "multicast" option
 525  *
 526  * @v tftp              TFTP connection
 527  * @v value             Option value
 528  * @ret rc              Return status code
 529  */
 530 static int tftp_process_multicast ( struct tftp_request *tftp,
 531                                     const char *value ) {
 532         union {
 533                 struct sockaddr sa;
 534                 struct sockaddr_in sin;
 535         } socket;
 536         char buf[ strlen ( value ) + 1 ];
 537         char *addr;
 538         char *port;
 539         char *port_end;
 540         char *mc;
 541         char *mc_end;
 542         int rc;
 543
 544         /* Split value into "addr,port,mc" fields */
 545         memcpy ( buf, value, sizeof ( buf ) );
 546         addr = buf;
 547         port = strchr ( addr, ',' );
 548         if ( ! port ) {
 549                 DBGC ( tftp, "TFTP %p multicast missing port,mc\n", tftp );
 550                 return -EINVAL;
 551         }
 552         *(port++) = '\0';
 553         mc = strchr ( port, ',' );
 554         if ( ! mc ) {
 555                 DBGC ( tftp, "TFTP %p multicast missing mc\n", tftp );
 556                 return -EINVAL;
 557         }
 558         *(mc++) = '\0';
 559
 560         /* Parse parameters */
 561         if ( strtoul ( mc, &mc_end, 0 ) == 0 )
 562                 tftp->flags &= ~TFTP_FL_SEND_ACK;
 563         if ( *mc_end ) {
 564                 DBGC ( tftp, "TFTP %p multicast invalid mc %s\n", tftp, mc );
 565                 return -EINVAL;
 566         }
 567         DBGC ( tftp, "TFTP %p is%s the master client\n",
 568                tftp, ( ( tftp->flags & TFTP_FL_SEND_ACK ) ? "" : " not" ) );
 569         if ( *addr && *port ) {
 570                 socket.sin.sin_family = AF_INET;
 571                 if ( inet_aton ( addr, &socket.sin.sin_addr ) == 0 ) {
 572                         DBGC ( tftp, "TFTP %p multicast invalid IP address "
 573                                "%s\n", tftp, addr );
 574                         return -EINVAL;
 575                 }
 576                 DBGC ( tftp, "TFTP %p multicast IP address %s\n",
 577                        tftp, inet_ntoa ( socket.sin.sin_addr ) );
 578                 socket.sin.sin_port = htons ( strtoul ( port, &port_end, 0 ) );
 579                 if ( *port_end ) {
 580                         DBGC ( tftp, "TFTP %p multicast invalid port %s\n",
 581                                tftp, port );
 582                         return -EINVAL;
 583                 }
 584                 DBGC ( tftp, "TFTP %p multicast port %d\n",
 585                        tftp, ntohs ( socket.sin.sin_port ) );
 586                 if ( ( rc = tftp_reopen_mc ( tftp, &socket.sa ) ) != 0 )
 587                         return rc;
 588         }
 589
 590         return 0;
 591 }
 592
 593 /** A TFTP option */
 594 struct tftp_option {
 595         /** Option name */
 596         const char *name;
 597         /** Option processor
 598          *
 599          * @v tftp      TFTP connection
 600          * @v value     Option value
 601          * @ret rc      Return status code
 602          */
 603         int ( * process ) ( struct tftp_request *tftp, const char *value );
 604 };
 605
 606 /** Recognised TFTP options */
 607 static struct tftp_option tftp_options[] = {
 608         { "blksize", tftp_process_blksize },
 609         { "tsize", tftp_process_tsize },
 610         { "multicast", tftp_process_multicast },
 611         { NULL, NULL }
 612 };
 613
 614 /**
 615  * Process TFTP option
 616  *
 617  * @v tftp              TFTP connection
 618  * @v name              Option name
 619  * @v value             Option value
 620  * @ret rc              Return status code
 621  */
 622 static int tftp_process_option ( struct tftp_request *tftp,
 623                                  const char *name, const char *value ) {
 624         struct tftp_option *option;
 625
 626         for ( option = tftp_options ; option->name ; option++ ) {
 627                 if ( strcasecmp ( name, option->name ) == 0 )
 628                         return option->process ( tftp, value );
 629         }
 630
 631         DBGC ( tftp, "TFTP %p received unknown option \"%s\" = \"%s\"\n",
 632                tftp, name, value );
 633
 634         /* Unknown options should be silently ignored */
 635         return 0;
 636 }
 637
 638 /**
 639  * Receive OACK
 640  *
 641  * @v tftp              TFTP connection
 642  * @v buf               Temporary data buffer
 643  * @v len               Length of temporary data buffer
 644  * @ret rc              Return status code
 645  */
 646 static int tftp_rx_oack ( struct tftp_request *tftp, void *buf, size_t len ) {
 647         struct tftp_oack *oack = buf;
 648         char *end = buf + len;
 649         char *name;
 650         char *value;
 651         int rc = 0;
 652
 653         /* Sanity check */
 654         if ( len < sizeof ( *oack ) ) {
 655                 DBGC ( tftp, "TFTP %p received underlength OACK packet "
 656                        "length %zd\n", tftp, len );
 657                 rc = -EINVAL;
 658                 goto done;
 659         }
 660         if ( end[-1] != '\0' ) {
 661                 DBGC ( tftp, "TFTP %p received OACK missing final NUL\n",
 662                        tftp );
 663                 rc = -EINVAL;
 664                 goto done;
 665         }
 666
 667         /* Process each option in turn */
 668         name = oack->data;
 669         while ( name < end ) {
 670                 value = ( name + strlen ( name ) + 1 );
 671                 if ( value == end ) {
 672                         DBGC ( tftp, "TFTP %p received OACK missing value "
 673                                "for option \"%s\"\n", tftp, name );
 674                         rc = -EINVAL;
 675                         goto done;
 676                 }
 677                 if ( ( rc = tftp_process_option ( tftp, name, value ) ) != 0 )
 678                         goto done;
 679                 name = ( value + strlen ( value ) + 1 );
 680         }
 681
 682         /* Process tsize information, if available */
 683         if ( tftp->tsize ) {
 684                 if ( ( rc = tftp_presize ( tftp, tftp->tsize ) ) != 0 )
 685                         goto done;
 686         }
 687
 688         /* Request next data block */
 689         tftp_send_packet ( tftp );
 690
 691  done:
 692         if ( rc )
 693                 tftp_done ( tftp, rc );
 694         return rc;
 695 }
 696
 697 /**
 698  * Receive DATA
 699  *
 700  * @v tftp              TFTP connection
 701  * @v iobuf             I/O buffer
 702  * @ret rc              Return status code
 703  *
 704  * Takes ownership of I/O buffer.
 705  */
 706 static int tftp_rx_data ( struct tftp_request *tftp,
 707                           struct io_buffer *iobuf ) {
 708         struct tftp_data *data = iobuf->data;
 709         struct xfer_metadata meta;
 710         int block;
 711         off_t offset;
 712         size_t data_len;
 713         int rc;
 714
 715         /* Sanity check */
 716         if ( iob_len ( iobuf ) < sizeof ( *data ) ) {
 717                 DBGC ( tftp, "TFTP %p received underlength DATA packet "
 718                        "length %zd\n", tftp, iob_len ( iobuf ) );
 719                 rc = -EINVAL;
 720                 goto done;
 721         }
 722
 723         /* Extract data */
 724         block = ( ntohs ( data->block ) - 1 );
 725         offset = ( block * tftp->blksize );
 726         iob_pull ( iobuf, sizeof ( *data ) );
 727         data_len = iob_len ( iobuf );
 728         if ( data_len > tftp->blksize ) {
 729                 DBGC ( tftp, "TFTP %p received overlength DATA packet "
 730                        "length %zd\n", tftp, data_len );
 731                 rc = -EINVAL;
 732                 goto done;
 733         }
 734
 735         /* Deliver data */
 736         memset ( &meta, 0, sizeof ( meta ) );
 737         meta.whence = SEEK_SET;
 738         meta.offset = offset;
 739         rc = xfer_deliver_iob_meta ( &tftp->xfer, iobuf, &meta );
 740         iobuf = NULL;
 741         if ( rc != 0 ) {
 742                 DBGC ( tftp, "TFTP %p could not deliver data: %s\n",
 743                        tftp, strerror ( rc ) );
 744                 goto done;
 745         }
 746
 747         /* Ensure block bitmap is ready */
 748         if ( ( rc = tftp_presize ( tftp, ( offset + data_len ) ) ) != 0 )
 749                 goto done;
 750
 751         /* Mark block as received */
 752         bitmap_set ( &tftp->bitmap, block );
 753
 754         /* Acknowledge block */
 755         tftp_send_packet ( tftp );
 756
 757         /* If all blocks have been received, finish. */
 758         if ( bitmap_full ( &tftp->bitmap ) )
 759                 tftp_done ( tftp, 0 );
 760
 761  done:
 762         free_iob ( iobuf );
 763         if ( rc )
 764                 tftp_done ( tftp, rc );
 765         return rc;
 766 }
 767
 768 /** Translation between TFTP errors and internal error numbers */
 769 static const int tftp_errors[] = {
 770         [TFTP_ERR_FILE_NOT_FOUND]       = ENOENT,
 771         [TFTP_ERR_ACCESS_DENIED]        = EACCES,
 772         [TFTP_ERR_ILLEGAL_OP]           = ENOTSUP,
 773 };
 774
 775 /**
 776  * Receive ERROR
 777  *
 778  * @v tftp              TFTP connection
 779  * @v buf               Temporary data buffer
 780  * @v len               Length of temporary data buffer
 781  * @ret rc              Return status code
 782  */
 783 static int tftp_rx_error ( struct tftp_request *tftp, void *buf, size_t len ) {
 784         struct tftp_error *error = buf;
 785         unsigned int err;
 786         int rc = 0;
 787
 788         /* Sanity check */
 789         if ( len < sizeof ( *error ) ) {
 790                 DBGC ( tftp, "TFTP %p received underlength ERROR packet "
 791                        "length %zd\n", tftp, len );
 792                 return -EINVAL;
 793         }
 794
 795         DBGC ( tftp, "TFTP %p received ERROR packet with code %d, message "
 796                "\"%s\"\n", tftp, ntohs ( error->errcode ), error->errmsg );
 797
 798         /* Determine final operation result */
 799         err = ntohs ( error->errcode );
 800         if ( err < ( sizeof ( tftp_errors ) / sizeof ( tftp_errors[0] ) ) )
 801                 rc = -tftp_errors[err];
 802         if ( ! rc )
 803                 rc = -ENOTSUP;
 804
 805         /* Close TFTP request */
 806         tftp_done ( tftp, rc );
 807
 808         return 0;
 809 }
 810
 811 /**
 812  * Receive new data
 813  *
 814  * @v tftp              TFTP connection
 815  * @v iobuf             I/O buffer
 816  * @v meta              Transfer metadata, or NULL
 817  * @ret rc              Return status code
 818  */
 819 static int tftp_rx ( struct tftp_request *tftp,
 820                      struct io_buffer *iobuf,
 821                      struct xfer_metadata *meta ) {
 822         struct sockaddr_tcpip *st_src;
 823         struct tftp_common *common = iobuf->data;
 824         size_t len = iob_len ( iobuf );
 825         int rc = -EINVAL;
 826
 827         /* Sanity checks */
 828         if ( len < sizeof ( *common ) ) {
 829                 DBGC ( tftp, "TFTP %p received underlength packet length "
 830                        "%zd\n", tftp, len );
 831                 goto done;
 832         }
 833         if ( ! meta ) {
 834                 DBGC ( tftp, "TFTP %p received packet without metadata\n",
 835                        tftp );
 836                 goto done;
 837         }
 838         if ( ! meta->src ) {
 839                 DBGC ( tftp, "TFTP %p received packet without source port\n",
 840                        tftp );
 841                 goto done;
 842         }
 843
 844         /* Filter by TID.  Set TID on first response received */
 845         st_src = ( struct sockaddr_tcpip * ) meta->src;
 846         if ( ! tftp->peer.st_family ) {
 847                 memcpy ( &tftp->peer, st_src, sizeof ( tftp->peer ) );
 848                 DBGC ( tftp, "TFTP %p using remote port %d\n", tftp,
 849                        ntohs ( tftp->peer.st_port ) );
 850         } else if ( memcmp ( &tftp->peer, st_src,
 851                              sizeof ( tftp->peer ) ) != 0 ) {
 852                 DBGC ( tftp, "TFTP %p received packet from wrong source (got "
 853                        "%d, wanted %d)\n", tftp, ntohs ( st_src->st_port ),
 854                        ntohs ( tftp->peer.st_port ) );
 855                 goto done;
 856         }
 857
 858         switch ( common->opcode ) {
 859         case htons ( TFTP_OACK ):
 860                 rc = tftp_rx_oack ( tftp, iobuf->data, len );
 861                 break;
 862         case htons ( TFTP_DATA ):
 863                 rc = tftp_rx_data ( tftp, iobuf );
 864                 iobuf = NULL;
 865                 break;
 866         case htons ( TFTP_ERROR ):
 867                 rc = tftp_rx_error ( tftp, iobuf->data, len );
 868                 break;
 869         default:
 870                 DBGC ( tftp, "TFTP %p received strange packet type %d\n",
 871                        tftp, ntohs ( common->opcode ) );
 872                 break;
 873         };
 874
 875  done:
 876         free_iob ( iobuf );
 877         return rc;
 878 }
 879
 880 /**
 881  * Receive new data via socket
 882  *
 883  * @v socket            Transport layer interface
 884  * @v iobuf             I/O buffer
 885  * @v meta              Transfer metadata, or NULL
 886  * @ret rc              Return status code
 887  */
 888 static int tftp_socket_deliver_iob ( struct xfer_interface *socket,
 889                                      struct io_buffer *iobuf,
 890                                      struct xfer_metadata *meta ) {
 891         struct tftp_request *tftp =
 892                 container_of ( socket, struct tftp_request, socket );
 893
 894         /* Enable sending ACKs when we receive a unicast packet.  This
 895          * covers three cases:
 896          *
 897          * 1. Standard TFTP; we should always send ACKs, and will
 898          *    always receive a unicast packet before we need to send the
 899          *    first ACK.
 900          *
 901          * 2. RFC2090 multicast TFTP; the only unicast packets we will
 902          *    receive are the OACKs; enable sending ACKs here (before
 903          *    processing the OACK) and disable it when processing the
 904          *    multicast option if we are not the master client.
 905          *
 906          * 3. MTFTP; receiving a unicast datagram indicates that we
 907          *    are the "master client" and should send ACKs.
 908          */
 909         tftp->flags |= TFTP_FL_SEND_ACK;
 910
 911         return tftp_rx ( tftp, iobuf, meta );
 912 }
 913
 914 /** TFTP socket operations */
 915 static struct xfer_interface_operations tftp_socket_operations = {
 916         .close          = ignore_xfer_close,
 917         .vredirect      = xfer_vopen,
 918         .window         = unlimited_xfer_window,
 919         .alloc_iob      = default_xfer_alloc_iob,
 920         .deliver_iob    = tftp_socket_deliver_iob,
 921         .deliver_raw    = xfer_deliver_as_iob,
 922 };
 923
 924 /**
 925  * Receive new data via multicast socket
 926  *
 927  * @v mc_socket         Multicast transport layer interface
 928  * @v iobuf             I/O buffer
 929  * @v meta              Transfer metadata, or NULL
 930  * @ret rc              Return status code
 931  */
 932 static int tftp_mc_socket_deliver_iob ( struct xfer_interface *mc_socket,
 933                                         struct io_buffer *iobuf,
 934                                         struct xfer_metadata *meta ) {
 935         struct tftp_request *tftp =
 936                 container_of ( mc_socket, struct tftp_request, mc_socket );
 937
 938         return tftp_rx ( tftp, iobuf, meta );
 939 }
 940
 941 /** TFTP multicast socket operations */
 942 static struct xfer_interface_operations tftp_mc_socket_operations = {
 943         .close          = ignore_xfer_close,
 944         .vredirect      = xfer_vopen,
 945         .window         = unlimited_xfer_window,
 946         .alloc_iob      = default_xfer_alloc_iob,
 947         .deliver_iob    = tftp_mc_socket_deliver_iob,
 948         .deliver_raw    = xfer_deliver_as_iob,
 949 };
 950
 951 /**
 952  * Close TFTP data transfer interface
 953  *
 954  * @v xfer              Data transfer interface
 955  * @v rc                Reason for close
 956  */
 957 static void tftp_xfer_close ( struct xfer_interface *xfer, int rc ) {
 958         struct tftp_request *tftp =
 959                 container_of ( xfer, struct tftp_request, xfer );
 960
 961         DBGC ( tftp, "TFTP %p interface closed: %s\n",
 962                tftp, strerror ( rc ) );
 963
 964         tftp_done ( tftp, rc );
 965 }
 966
 967 /** TFTP data transfer interface operations */
 968 static struct xfer_interface_operations tftp_xfer_operations = {
 969         .close          = tftp_xfer_close,
 970         .vredirect      = ignore_xfer_vredirect,
 971         .window         = unlimited_xfer_window,
 972         .alloc_iob      = default_xfer_alloc_iob,
 973         .deliver_iob    = xfer_deliver_as_raw,
 974         .deliver_raw    = ignore_xfer_deliver_raw,
 975 };
 976
 977 /**
 978  * Initiate TFTP/TFTM/MTFTP download
 979  *
 980  * @v xfer              Data transfer interface
 981  * @v uri               Uniform Resource Identifier
 982  * @ret rc              Return status code
 983  */
 984 static int tftp_core_open ( struct xfer_interface *xfer, struct uri *uri,
 985                             unsigned int default_port,
 986                             struct sockaddr *multicast,
 987                             unsigned int flags ) {
 988         struct tftp_request *tftp;
 989         int rc;
 990
 991         /* Sanity checks */
 992         if ( ! uri->host )
 993                 return -EINVAL;
 994         if ( ! uri->path )
 995                 return -EINVAL;
 996
 997         /* Allocate and populate TFTP structure */
 998         tftp = zalloc ( sizeof ( *tftp ) );
 999         if ( ! tftp )
1000                 return -ENOMEM;
1001         tftp->refcnt.free = tftp_free;
1002         xfer_init ( &tftp->xfer, &tftp_xfer_operations, &tftp->refcnt );
1003         tftp->uri = uri_get ( uri );
1004         xfer_init ( &tftp->socket, &tftp_socket_operations, &tftp->refcnt );
1005         xfer_init ( &tftp->mc_socket, &tftp_mc_socket_operations,
1006                     &tftp->refcnt );
1007         tftp->blksize = TFTP_DEFAULT_BLKSIZE;
1008         tftp->flags = flags;
1009         tftp->timer.expired = tftp_timer_expired;
1010
1011         /* Open socket */
1012         tftp->port = uri_port ( tftp->uri, default_port );
1013         if ( ( rc = tftp_reopen ( tftp ) ) != 0 )
1014                 goto err;
1015
1016         /* Open multicast socket */
1017         if ( multicast ) {
1018                 if ( ( rc = tftp_reopen_mc ( tftp, multicast ) ) != 0 )
1019                         goto err;
1020         }
1021
1022         /* Start timer to initiate RRQ */
1023         start_timer_nodelay ( &tftp->timer );
1024
1025         /* Attach to parent interface, mortalise self, and return */
1026         xfer_plug_plug ( &tftp->xfer, xfer );
1027         ref_put ( &tftp->refcnt );
1028         return 0;
1029
1030  err:
1031         DBGC ( tftp, "TFTP %p could not create request: %s\n",
1032                tftp, strerror ( rc ) );
1033         tftp_done ( tftp, rc );
1034         ref_put ( &tftp->refcnt );
1035         return rc;
1036 }
1037
1038 /**
1039  * Initiate TFTP download
1040  *
1041  * @v xfer              Data transfer interface
1042  * @v uri               Uniform Resource Identifier
1043  * @ret rc              Return status code
1044  */
1045 static int tftp_open ( struct xfer_interface *xfer, struct uri *uri ) {
1046         return tftp_core_open ( xfer, uri, TFTP_PORT, NULL,
1047                                 TFTP_FL_RRQ_SIZES );
1048
1049 }
1050
1051 /** TFTP URI opener */
1052 struct uri_opener tftp_uri_opener __uri_opener = {
1053         .scheme = "tftp",
1054         .open   = tftp_open,
1055 };
1056
1057 /**
1058  * Initiate TFTM download
1059  *
1060  * @v xfer              Data transfer interface
1061  * @v uri               Uniform Resource Identifier
1062  * @ret rc              Return status code
1063  */
1064 static int tftm_open ( struct xfer_interface *xfer, struct uri *uri ) {
1065         return tftp_core_open ( xfer, uri, TFTP_PORT, NULL,
1066                                 ( TFTP_FL_RRQ_SIZES |
1067                                   TFTP_FL_RRQ_MULTICAST ) );
1068
1069 }
1070
1071 /** TFTM URI opener */
1072 struct uri_opener tftm_uri_opener __uri_opener = {
1073         .scheme = "tftm",
1074         .open   = tftm_open,
1075 };
1076
1077 /**
1078  * Initiate MTFTP download
1079  *
1080  * @v xfer              Data transfer interface
1081  * @v uri               Uniform Resource Identifier
1082  * @ret rc              Return status code
1083  */
1084 static int mtftp_open ( struct xfer_interface *xfer, struct uri *uri ) {
1085         return tftp_core_open ( xfer, uri, MTFTP_PORT,
1086                                 ( struct sockaddr * ) &tftp_mtftp_socket,
1087                                 TFTP_FL_MTFTP_RECOVERY );
1088 }
1089
1090 /** MTFTP URI opener */
1091 struct uri_opener mtftp_uri_opener __uri_opener = {
1092         .scheme = "mtftp",
1093         .open   = mtftp_open,
1094 };
1095
1096 /******************************************************************************
1097  *
1098  * Settings
1099  *
1100  ******************************************************************************
1101  */
1102
1103 /** TFTP server setting */
1104 struct setting next_server_setting __setting = {
1105         .name = "next-server",
1106         .description = "TFTP server",
1107         .tag = DHCP_EB_SIADDR,
1108         .type = &setting_type_ipv4,
1109 };
1110
1111 /**
1112  * Apply TFTP configuration settings
1113  *
1114  * @ret rc              Return status code
1115  */
1116 static int tftp_apply_settings ( void ) {
1117         static struct in_addr tftp_server = { 0 };
1118         struct in_addr last_tftp_server;
1119         char uri_string[32];
1120         struct uri *uri;
1121
1122         /* Retrieve TFTP server setting */
1123         last_tftp_server = tftp_server;
1124         fetch_ipv4_setting ( NULL, &next_server_setting, &tftp_server );
1125
1126         /* If TFTP server setting has changed, set the current working
1127          * URI to match.  Do it only when the TFTP server has changed
1128          * to try to minimise surprises to the user, who probably
1129          * won't expect the CWURI to change just because they updated
1130          * an unrelated setting and triggered all the settings
1131          * applicators.
1132          */
1133         if ( tftp_server.s_addr != last_tftp_server.s_addr ) {
1134                 snprintf ( uri_string, sizeof ( uri_string ),
1135                            "tftp://%s/", inet_ntoa ( tftp_server ) );
1136                 uri = parse_uri ( uri_string );
1137                 if ( ! uri )
1138                         return -ENOMEM;
1139                 churi ( uri );
1140                 uri_put ( uri );
1141         }
1142
1143         return 0;
1144 }
1145
1146 /** TFTP settings applicator */
1147 struct settings_applicator tftp_settings_applicator __settings_applicator = {
1148         .apply = tftp_apply_settings,
1149 };