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