[tftp] Strip the initial '/' to keep Windows TFTP servers happy.
[people/balajirrao/gpxe.git] / 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 };