2006-08-08 23:45:52 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
|
|
* License, or any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdlib.h>
|
2007-01-19 01:13:12 +00:00
|
|
|
#include <stdio.h>
|
2006-08-08 23:45:52 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <strings.h>
|
|
|
|
#include <byteswap.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <assert.h>
|
2007-06-11 17:11:29 +00:00
|
|
|
#include <gpxe/refcnt.h>
|
|
|
|
#include <gpxe/xfer.h>
|
|
|
|
#include <gpxe/open.h>
|
2007-01-15 09:58:26 +00:00
|
|
|
#include <gpxe/uri.h>
|
2007-06-11 22:40:34 +00:00
|
|
|
#include <gpxe/tcpip.h>
|
|
|
|
#include <gpxe/retry.h>
|
2007-06-11 17:11:29 +00:00
|
|
|
#include <gpxe/tftp.h>
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/** @file
|
|
|
|
*
|
|
|
|
* TFTP protocol
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/**
|
|
|
|
* A TFTP request
|
|
|
|
*
|
|
|
|
* This data structure holds the state for an ongoing TFTP transfer.
|
|
|
|
*/
|
|
|
|
struct tftp_request {
|
|
|
|
/** Reference count */
|
|
|
|
struct refcnt refcnt;
|
|
|
|
/** Data transfer interface */
|
|
|
|
struct xfer_interface xfer;
|
|
|
|
|
|
|
|
/** URI being fetched */
|
|
|
|
struct uri *uri;
|
|
|
|
/** Transport layer interface */
|
|
|
|
struct xfer_interface socket;
|
|
|
|
|
|
|
|
/** Data block size
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
2007-06-11 17:11:29 +00:00
|
|
|
* This is the "blksize" option negotiated with the TFTP
|
|
|
|
* server. (If the TFTP server does not support TFTP options,
|
|
|
|
* this will default to 512).
|
|
|
|
*/
|
|
|
|
unsigned int blksize;
|
|
|
|
/** File size
|
|
|
|
*
|
|
|
|
* This is the value returned in the "tsize" option from the
|
|
|
|
* TFTP server. If the TFTP server does not support the
|
|
|
|
* "tsize" option, this value will be zero.
|
|
|
|
*/
|
|
|
|
unsigned long tsize;
|
|
|
|
|
|
|
|
/** Request state
|
|
|
|
*
|
|
|
|
* This is the block number to be used in the next ACK sent
|
|
|
|
* back to the server, i.e. the number of the last received
|
|
|
|
* data block. The value zero indicates that the last
|
|
|
|
* received block was an OACK (i.e. that the next ACK will
|
|
|
|
* contain a block number of zero), and any value less than
|
|
|
|
* zero indicates that the connection has not yet been opened
|
|
|
|
* (i.e. that no blocks have yet been received).
|
|
|
|
*/
|
|
|
|
int state;
|
|
|
|
/** Peer address
|
|
|
|
*
|
|
|
|
* The peer address is determined by the first response
|
|
|
|
* received to the TFTP RRQ.
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
struct sockaddr_tcpip peer;
|
|
|
|
/** Retransmission timer */
|
|
|
|
struct retry_timer timer;
|
2006-08-08 23:45:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Free TFTP request
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
2007-06-11 17:11:29 +00:00
|
|
|
* @v refcnt Reference counter
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static void tftp_free ( struct refcnt *refcnt ) {
|
|
|
|
struct tftp_request *tftp =
|
|
|
|
container_of ( refcnt, struct tftp_request, refcnt );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
uri_put ( tftp->uri );
|
|
|
|
free ( tftp );
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Mark TFTP request as complete
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
2007-06-11 17:11:29 +00:00
|
|
|
* @v rc Return status code
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static void tftp_done ( struct tftp_request *tftp, int rc ) {
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-07-01 21:04:19 +00:00
|
|
|
DBGC ( tftp, "TFTP %p finished with status %d (%s)\n",
|
|
|
|
tftp, rc, strerror ( rc ) );
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Stop the retry timer */
|
|
|
|
stop_timer ( &tftp->timer );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Close all data transfer interfaces */
|
|
|
|
xfer_nullify ( &tftp->socket );
|
|
|
|
xfer_close ( &tftp->socket, rc );
|
|
|
|
xfer_nullify ( &tftp->xfer );
|
|
|
|
xfer_close ( &tftp->xfer, rc );
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/**
|
|
|
|
* TFTP requested blocksize
|
|
|
|
*
|
|
|
|
* This is treated as a global configuration parameter.
|
|
|
|
*/
|
|
|
|
static unsigned int tftp_request_blksize = TFTP_MAX_BLKSIZE;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Set TFTP request blocksize
|
|
|
|
*
|
|
|
|
* @v blksize Requested block size
|
|
|
|
*/
|
|
|
|
void tftp_set_request_blksize ( unsigned int blksize ) {
|
|
|
|
if ( blksize < TFTP_DEFAULT_BLKSIZE )
|
|
|
|
blksize = TFTP_DEFAULT_BLKSIZE;
|
|
|
|
tftp_request_blksize = blksize;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Transmit RRQ
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_send_rrq ( struct tftp_request *tftp ) {
|
|
|
|
struct tftp_rrq *rrq;
|
|
|
|
const char *path = tftp->uri->path;
|
|
|
|
size_t len = ( sizeof ( *rrq ) + strlen ( path ) + 1 /* NUL */
|
|
|
|
+ 5 + 1 /* "octet" + NUL */
|
|
|
|
+ 7 + 1 + 5 + 1 /* "blksize" + NUL + ddddd + NUL */
|
|
|
|
+ 5 + 1 + 1 + 1 /* "tsize" + NUL + "0" + NUL */ );
|
|
|
|
struct io_buffer *iobuf;
|
|
|
|
|
|
|
|
DBGC ( tftp, "TFTP %p requesting \"%s\"\n", tftp, path );
|
|
|
|
|
|
|
|
/* Allocate buffer */
|
|
|
|
iobuf = xfer_alloc_iob ( &tftp->socket, len );
|
|
|
|
if ( ! iobuf )
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Build request */
|
|
|
|
rrq = iob_put ( iobuf, sizeof ( *rrq ) );
|
|
|
|
rrq->opcode = htons ( TFTP_RRQ );
|
|
|
|
iob_put ( iobuf,
|
2007-06-28 17:38:50 +00:00
|
|
|
snprintf ( rrq->data, iob_tailroom ( iobuf ),
|
2007-06-11 17:11:29 +00:00
|
|
|
"%s%coctet%cblksize%c%d%ctsize%c0", path, 0,
|
|
|
|
0, 0, tftp_request_blksize, 0, 0 ) + 1 );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* RRQ always goes to the address specified in the initial
|
|
|
|
* xfer_open() call
|
|
|
|
*/
|
|
|
|
return xfer_deliver_iob ( &tftp->socket, iobuf );
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Transmit ACK
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
2007-06-11 17:11:29 +00:00
|
|
|
* @ret rc Return status code
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_send_ack ( struct tftp_request *tftp ) {
|
|
|
|
struct tftp_ack *ack;
|
|
|
|
struct io_buffer *iobuf;
|
|
|
|
struct xfer_metadata meta = {
|
|
|
|
.dest = ( struct sockaddr * ) &tftp->peer,
|
|
|
|
};
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-07-01 21:04:19 +00:00
|
|
|
DBGC2 ( tftp, "TFTP %p sending ACK for block %d\n",
|
|
|
|
tftp, tftp->state );
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Allocate buffer */
|
|
|
|
iobuf = xfer_alloc_iob ( &tftp->socket, sizeof ( *ack ) );
|
|
|
|
if ( ! iobuf )
|
|
|
|
return -ENOMEM;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Build ACK */
|
|
|
|
ack = iob_put ( iobuf, sizeof ( *ack ) );
|
|
|
|
ack->opcode = htons ( TFTP_ACK );
|
|
|
|
ack->block = htons ( tftp->state );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* ACK always goes to the peer recorded from the RRQ response */
|
|
|
|
return xfer_deliver_iob_meta ( &tftp->socket, iobuf, &meta );
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Transmit data
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
2007-06-11 17:11:29 +00:00
|
|
|
* @ret rc Return status code
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_send_packet ( struct tftp_request *tftp ) {
|
|
|
|
|
|
|
|
/* Start retransmission timer */
|
2006-08-08 23:45:52 +00:00
|
|
|
start_timer ( &tftp->timer );
|
2007-06-11 17:11:29 +00:00
|
|
|
|
|
|
|
/* Send RRQ or ACK as appropriate */
|
|
|
|
if ( tftp->state < 0 ) {
|
|
|
|
return tftp_send_rrq ( tftp );
|
|
|
|
} else {
|
|
|
|
return tftp_send_ack ( tftp );
|
|
|
|
}
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle TFTP retransmission timer expiry
|
|
|
|
*
|
|
|
|
* @v timer Retry timer
|
|
|
|
* @v fail Failure indicator
|
|
|
|
*/
|
|
|
|
static void tftp_timer_expired ( struct retry_timer *timer, int fail ) {
|
2007-06-11 17:11:29 +00:00
|
|
|
struct tftp_request *tftp =
|
|
|
|
container_of ( timer, struct tftp_request, timer );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
if ( fail ) {
|
|
|
|
tftp_done ( tftp, -ETIMEDOUT );
|
|
|
|
} else {
|
|
|
|
tftp_send_packet ( tftp );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Mark TFTP block as received
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @v block Block number
|
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static void tftp_received ( struct tftp_request *tftp, unsigned int block ) {
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/* Stop the retry timer */
|
|
|
|
stop_timer ( &tftp->timer );
|
|
|
|
|
|
|
|
/* Update state to indicate which block we're now waiting for */
|
|
|
|
tftp->state = block;
|
|
|
|
|
|
|
|
/* Send next packet */
|
|
|
|
tftp_send_packet ( tftp );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Process TFTP "blksize" option
|
2006-08-08 23:45:52 +00:00
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
2007-06-11 17:11:29 +00:00
|
|
|
* @v value Option value
|
2006-08-08 23:45:52 +00:00
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_process_blksize ( struct tftp_request *tftp,
|
|
|
|
const char *value ) {
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
tftp->blksize = strtoul ( value, &end, 10 );
|
|
|
|
if ( *end ) {
|
|
|
|
DBGC ( tftp, "TFTP %p got invalid blksize \"%s\"\n",
|
|
|
|
tftp, value );
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
DBGC ( tftp, "TFTP %p blksize=%d\n", tftp, tftp->blksize );
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Process TFTP "tsize" option
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @v value Option value
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
|
|
|
static int tftp_process_tsize ( struct tftp_request *tftp,
|
|
|
|
const char *value ) {
|
|
|
|
char *end;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
tftp->tsize = strtoul ( value, &end, 10 );
|
|
|
|
if ( *end ) {
|
|
|
|
DBGC ( tftp, "TFTP %p got invalid tsize \"%s\"\n",
|
|
|
|
tftp, value );
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
DBGC ( tftp, "TFTP %p tsize=%ld\n", tftp, tftp->tsize );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Notify recipient of file size */
|
|
|
|
xfer_seek ( &tftp->xfer, tftp->tsize, SEEK_SET );
|
|
|
|
xfer_seek ( &tftp->xfer, 0, SEEK_SET );
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** A TFTP option */
|
|
|
|
struct tftp_option {
|
|
|
|
/** Option name */
|
|
|
|
const char *name;
|
|
|
|
/** Option processor
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @v value Option value
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
|
|
|
int ( * process ) ( struct tftp_request *tftp, const char *value );
|
|
|
|
};
|
|
|
|
|
|
|
|
/** Recognised TFTP options */
|
|
|
|
static struct tftp_option tftp_options[] = {
|
|
|
|
{ "blksize", tftp_process_blksize },
|
|
|
|
{ "tsize", tftp_process_tsize },
|
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Process TFTP option
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @v name Option name
|
|
|
|
* @v value Option value
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
|
|
|
static int tftp_process_option ( struct tftp_request *tftp,
|
|
|
|
const char *name, const char *value ) {
|
|
|
|
struct tftp_option *option;
|
|
|
|
|
|
|
|
for ( option = tftp_options ; option->name ; option++ ) {
|
|
|
|
if ( strcasecmp ( name, option->name ) == 0 )
|
|
|
|
return option->process ( tftp, value );
|
|
|
|
}
|
|
|
|
|
|
|
|
DBGC ( tftp, "TFTP %p received unknown option \"%s\" = \"%s\"\n",
|
|
|
|
tftp, name, value );
|
|
|
|
|
|
|
|
return -EINVAL;
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Receive OACK
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @v buf Temporary data buffer
|
|
|
|
* @v len Length of temporary data buffer
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_rx_oack ( struct tftp_request *tftp, void *buf, size_t len ) {
|
2006-08-08 23:45:52 +00:00
|
|
|
struct tftp_oack *oack = buf;
|
|
|
|
char *end = buf + len;
|
|
|
|
char *name;
|
|
|
|
char *value;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if ( len < sizeof ( *oack ) ) {
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received underlength OACK packet "
|
|
|
|
"length %d\n", tftp, len );
|
2006-08-08 23:45:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if ( end[-1] != '\0' ) {
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received OACK missing final NUL\n",
|
|
|
|
tftp );
|
2006-08-08 23:45:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Process each option in turn */
|
|
|
|
name = oack->data;
|
|
|
|
while ( name < end ) {
|
|
|
|
value = ( name + strlen ( name ) + 1 );
|
|
|
|
if ( value == end ) {
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received OACK missing value "
|
|
|
|
"for option \"%s\"\n", tftp, name );
|
2006-08-08 23:45:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if ( ( rc = tftp_process_option ( tftp, name, value ) ) != 0 )
|
|
|
|
return rc;
|
|
|
|
name = ( value + strlen ( value ) + 1 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark as received block 0 (the OACK) */
|
|
|
|
tftp_received ( tftp, 0 );
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Receive DATA
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
2007-06-11 17:11:29 +00:00
|
|
|
* @v iobuf I/O buffer
|
2006-08-08 23:45:52 +00:00
|
|
|
* @ret rc Return status code
|
2007-06-11 17:11:29 +00:00
|
|
|
*
|
|
|
|
* Takes ownership of I/O buffer.
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_rx_data ( struct tftp_request *tftp,
|
|
|
|
struct io_buffer *iobuf ) {
|
|
|
|
struct tftp_data *data = iobuf->data;
|
2006-08-08 23:45:52 +00:00
|
|
|
unsigned int block;
|
|
|
|
size_t data_len;
|
2007-01-11 15:14:54 +00:00
|
|
|
int rc;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/* Sanity check */
|
2007-06-11 17:11:29 +00:00
|
|
|
if ( iob_len ( iobuf ) < sizeof ( *data ) ) {
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received underlength DATA packet "
|
2007-06-11 17:11:29 +00:00
|
|
|
"length %d\n", tftp, iob_len ( iobuf ) );
|
|
|
|
free_iob ( iobuf );
|
2006-08-08 23:45:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Extract data */
|
2006-08-08 23:45:52 +00:00
|
|
|
block = ntohs ( data->block );
|
2007-06-11 17:11:29 +00:00
|
|
|
iob_pull ( iobuf, sizeof ( *data ) );
|
|
|
|
data_len = iob_len ( iobuf );
|
|
|
|
|
|
|
|
/* Deliver data */
|
|
|
|
if ( ( rc = xfer_deliver_iob ( &tftp->xfer, iobuf ) ) != 0 ) {
|
|
|
|
DBGC ( tftp, "TFTP %p could not deliver data: %s\n",
|
2007-01-11 15:14:54 +00:00
|
|
|
tftp, strerror ( rc ) );
|
|
|
|
tftp_done ( tftp, rc );
|
|
|
|
return rc;
|
|
|
|
}
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/* Mark block as received */
|
|
|
|
tftp_received ( tftp, block );
|
|
|
|
|
|
|
|
/* Finish when final block received */
|
|
|
|
if ( data_len < tftp->blksize )
|
|
|
|
tftp_done ( tftp, 0 );
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/** Translation between TFTP errors and internal error numbers */
|
|
|
|
static const uint8_t tftp_errors[] = {
|
|
|
|
[TFTP_ERR_FILE_NOT_FOUND] = PXENV_STATUS_TFTP_FILE_NOT_FOUND,
|
|
|
|
[TFTP_ERR_ACCESS_DENIED] = PXENV_STATUS_TFTP_ACCESS_VIOLATION,
|
|
|
|
[TFTP_ERR_ILLEGAL_OP] = PXENV_STATUS_TFTP_UNKNOWN_OPCODE,
|
|
|
|
};
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Receive ERROR
|
|
|
|
*
|
|
|
|
* @v tftp TFTP connection
|
|
|
|
* @v buf Temporary data buffer
|
|
|
|
* @v len Length of temporary data buffer
|
|
|
|
* @ret rc Return status code
|
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_rx_error ( struct tftp_request *tftp, void *buf, size_t len ) {
|
2006-08-08 23:45:52 +00:00
|
|
|
struct tftp_error *error = buf;
|
|
|
|
unsigned int err;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if ( len < sizeof ( *error ) ) {
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received underlength ERROR packet "
|
|
|
|
"length %d\n", tftp, len );
|
2006-08-08 23:45:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received ERROR packet with code %d, message "
|
|
|
|
"\"%s\"\n", tftp, ntohs ( error->errcode ), error->errmsg );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
|
|
|
/* Determine final operation result */
|
|
|
|
err = ntohs ( error->errcode );
|
|
|
|
if ( err < ( sizeof ( tftp_errors ) / sizeof ( tftp_errors[0] ) ) )
|
|
|
|
rc = -tftp_errors[err];
|
|
|
|
if ( ! rc )
|
|
|
|
rc = -PXENV_STATUS_TFTP_CANNOT_OPEN_CONNECTION;
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Close TFTP request */
|
2006-08-08 23:45:52 +00:00
|
|
|
tftp_done ( tftp, rc );
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Receive new data
|
|
|
|
*
|
|
|
|
* @v udp UDP connection
|
|
|
|
* @v data Received data
|
|
|
|
* @v len Length of received data
|
|
|
|
* @v st_src Partially-filled source address
|
|
|
|
* @v st_dest Partially-filled destination address
|
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static int tftp_socket_deliver_iob ( struct xfer_interface *socket,
|
|
|
|
struct io_buffer *iobuf,
|
|
|
|
struct xfer_metadata *meta ) {
|
|
|
|
struct tftp_request *tftp =
|
|
|
|
container_of ( socket, struct tftp_request, socket );
|
|
|
|
struct sockaddr_tcpip *st_src;
|
|
|
|
struct tftp_common *common = iobuf->data;
|
|
|
|
size_t len = iob_len ( iobuf );
|
|
|
|
int rc = -EINVAL;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Sanity checks */
|
2006-08-08 23:45:52 +00:00
|
|
|
if ( len < sizeof ( *common ) ) {
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received underlength packet length %d\n",
|
|
|
|
tftp, len );
|
2007-06-11 17:11:29 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if ( ! meta ) {
|
|
|
|
DBGC ( tftp, "TFTP %p received packet without metadata\n",
|
|
|
|
tftp );
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if ( ! meta->src ) {
|
|
|
|
DBGC ( tftp, "TFTP %p received packet without source port\n",
|
|
|
|
tftp );
|
|
|
|
goto done;
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Filter by TID. Set TID on first response received */
|
2007-06-11 17:11:29 +00:00
|
|
|
st_src = ( struct sockaddr_tcpip * ) meta->src;
|
|
|
|
if ( tftp->state < 0 ) {
|
|
|
|
memcpy ( &tftp->peer, st_src, sizeof ( tftp->peer ) );
|
2007-01-11 15:14:54 +00:00
|
|
|
DBGC ( tftp, "TFTP %p using remote port %d\n", tftp,
|
2007-06-11 17:11:29 +00:00
|
|
|
ntohs ( tftp->peer.st_port ) );
|
|
|
|
} else if ( memcmp ( &tftp->peer, st_src,
|
|
|
|
sizeof ( tftp->peer ) ) != 0 ) {
|
|
|
|
DBGC ( tftp, "TFTP %p received packet from wrong source (got "
|
|
|
|
"%d, wanted %d)\n", tftp, ntohs ( st_src->st_port ),
|
|
|
|
ntohs ( tftp->peer.st_port ) );
|
|
|
|
goto done;
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch ( common->opcode ) {
|
|
|
|
case htons ( TFTP_OACK ):
|
2007-06-11 17:11:29 +00:00
|
|
|
rc = tftp_rx_oack ( tftp, iobuf->data, len );
|
|
|
|
break;
|
2006-08-08 23:45:52 +00:00
|
|
|
case htons ( TFTP_DATA ):
|
2007-06-11 17:11:29 +00:00
|
|
|
rc = tftp_rx_data ( tftp, iobuf );
|
|
|
|
iobuf = NULL;
|
|
|
|
break;
|
2006-08-08 23:45:52 +00:00
|
|
|
case htons ( TFTP_ERROR ):
|
2007-06-11 17:11:29 +00:00
|
|
|
rc = tftp_rx_error ( tftp, iobuf->data, len );
|
|
|
|
break;
|
2006-08-08 23:45:52 +00:00
|
|
|
default:
|
2007-06-11 17:11:29 +00:00
|
|
|
DBGC ( tftp, "TFTP %p received strange packet type %d\n",
|
|
|
|
tftp, ntohs ( common->opcode ) );
|
|
|
|
break;
|
2006-08-08 23:45:52 +00:00
|
|
|
};
|
2007-06-11 17:11:29 +00:00
|
|
|
|
|
|
|
done:
|
|
|
|
free_iob ( iobuf );
|
|
|
|
return rc;
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/**
|
|
|
|
* TFTP connection closed by network stack
|
|
|
|
*
|
|
|
|
* @v socket Transport layer interface
|
|
|
|
* @v rc Reason for close
|
|
|
|
*/
|
|
|
|
static void tftp_socket_close ( struct xfer_interface *socket, int rc ) {
|
|
|
|
struct tftp_request *tftp =
|
|
|
|
container_of ( socket, struct tftp_request, socket );
|
|
|
|
|
|
|
|
DBGC ( tftp, "TFTP %p socket closed: %s\n",
|
|
|
|
tftp, strerror ( rc ) );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
tftp_done ( tftp, rc );
|
|
|
|
}
|
|
|
|
|
|
|
|
/** TFTP socket operations */
|
|
|
|
static struct xfer_interface_operations tftp_socket_operations = {
|
|
|
|
.close = tftp_socket_close,
|
|
|
|
.vredirect = xfer_vopen,
|
|
|
|
.request = ignore_xfer_request,
|
|
|
|
.seek = ignore_xfer_seek,
|
|
|
|
.alloc_iob = default_xfer_alloc_iob,
|
|
|
|
.deliver_iob = tftp_socket_deliver_iob,
|
|
|
|
.deliver_raw = xfer_deliver_as_iob,
|
|
|
|
};
|
|
|
|
|
2007-01-15 09:58:26 +00:00
|
|
|
/**
|
2007-06-11 17:11:29 +00:00
|
|
|
* Close TFTP data transfer interface
|
2007-01-15 09:58:26 +00:00
|
|
|
*
|
2007-06-11 17:11:29 +00:00
|
|
|
* @v xfer Data transfer interface
|
|
|
|
* @v rc Reason for close
|
2007-01-15 09:58:26 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
static void tftp_xfer_close ( struct xfer_interface *xfer, int rc ) {
|
|
|
|
struct tftp_request *tftp =
|
|
|
|
container_of ( xfer, struct tftp_request, xfer );
|
2007-01-15 09:58:26 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
DBGC ( tftp, "TFTP %p interface closed: %s\n",
|
|
|
|
tftp, strerror ( rc ) );
|
|
|
|
|
|
|
|
tftp_done ( tftp, rc );
|
2007-01-15 09:58:26 +00:00
|
|
|
}
|
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/** TFTP data transfer interface operations */
|
|
|
|
static struct xfer_interface_operations tftp_xfer_operations = {
|
|
|
|
.close = tftp_xfer_close,
|
|
|
|
.vredirect = ignore_xfer_vredirect,
|
|
|
|
.request = ignore_xfer_request,
|
|
|
|
.seek = ignore_xfer_seek,
|
|
|
|
.alloc_iob = default_xfer_alloc_iob,
|
|
|
|
.deliver_iob = xfer_deliver_as_raw,
|
|
|
|
.deliver_raw = ignore_xfer_deliver_raw,
|
2007-01-15 09:58:26 +00:00
|
|
|
};
|
|
|
|
|
2006-08-08 23:45:52 +00:00
|
|
|
/**
|
|
|
|
* Initiate TFTP download
|
|
|
|
*
|
2007-06-11 17:11:29 +00:00
|
|
|
* @v xfer Data transfer interface
|
2007-01-15 09:58:26 +00:00
|
|
|
* @v uri Uniform Resource Identifier
|
|
|
|
* @ret rc Return status code
|
2006-08-08 23:45:52 +00:00
|
|
|
*/
|
2007-06-11 17:11:29 +00:00
|
|
|
int tftp_open ( struct xfer_interface *xfer, struct uri *uri ) {
|
|
|
|
struct tftp_request *tftp;
|
|
|
|
struct sockaddr_tcpip server;
|
2006-08-08 23:45:52 +00:00
|
|
|
int rc;
|
|
|
|
|
2007-01-15 09:58:26 +00:00
|
|
|
/* Sanity checks */
|
2007-06-11 17:11:29 +00:00
|
|
|
if ( ! uri->host )
|
|
|
|
return -EINVAL;
|
|
|
|
if ( ! uri->path )
|
|
|
|
return -EINVAL;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-01-15 09:58:26 +00:00
|
|
|
/* Allocate and populate TFTP structure */
|
|
|
|
tftp = malloc ( sizeof ( *tftp ) );
|
2007-06-11 17:11:29 +00:00
|
|
|
if ( ! tftp )
|
|
|
|
return -ENOMEM;
|
2007-01-15 09:58:26 +00:00
|
|
|
memset ( tftp, 0, sizeof ( *tftp ) );
|
2007-06-11 17:11:29 +00:00
|
|
|
tftp->refcnt.free = tftp_free;
|
|
|
|
xfer_init ( &tftp->xfer, &tftp_xfer_operations, &tftp->refcnt );
|
|
|
|
tftp->uri = uri_get ( uri );
|
|
|
|
xfer_init ( &tftp->socket, &tftp_socket_operations, &tftp->refcnt );
|
2007-01-11 15:14:54 +00:00
|
|
|
tftp->state = -1;
|
|
|
|
tftp->timer.expired = tftp_timer_expired;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Open socket */
|
|
|
|
memset ( &server, 0, sizeof ( server ) );
|
|
|
|
server.st_port = htons ( uri_port ( tftp->uri, TFTP_PORT ) );
|
|
|
|
if ( ( rc = xfer_open_named_socket ( &tftp->socket, SOCK_DGRAM,
|
|
|
|
( struct sockaddr * ) &server,
|
|
|
|
uri->host, NULL ) ) != 0 )
|
2007-01-15 09:58:26 +00:00
|
|
|
goto err;
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Start timer to initiate RRQ */
|
|
|
|
start_timer ( &tftp->timer );
|
2006-08-08 23:45:52 +00:00
|
|
|
|
2007-06-11 17:11:29 +00:00
|
|
|
/* Attach to parent interface, mortalise self, and return */
|
|
|
|
xfer_plug_plug ( &tftp->xfer, xfer );
|
|
|
|
ref_put ( &tftp->refcnt );
|
2007-01-15 09:58:26 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2007-06-11 17:11:29 +00:00
|
|
|
DBGC ( tftp, "TFTP %p could not create request: %s\n",
|
2007-01-15 09:58:26 +00:00
|
|
|
tftp, strerror ( rc ) );
|
2007-06-11 17:11:29 +00:00
|
|
|
tftp_done ( tftp, rc );
|
|
|
|
ref_put ( &tftp->refcnt );
|
2007-01-15 09:58:26 +00:00
|
|
|
return rc;
|
2006-08-08 23:45:52 +00:00
|
|
|
}
|
2007-06-11 17:11:29 +00:00
|
|
|
|
|
|
|
/** TFTP URI opener */
|
|
|
|
struct uri_opener tftp_uri_opener __uri_opener = {
|
|
|
|
.scheme = "tftp",
|
|
|
|
.open = tftp_open,
|
|
|
|
};
|