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