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