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