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