/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSImplTFTPFS
*
* @brief This source file contains the implementation of
* a Trivial File Transfer Protocol (TFTP) client library.
*
* The code in this file provides the ability to read files from and
* to write files to remote servers using the Trivial File Transfer
* Protocol (TFTP). It is used by the @ref tftpfs.c "TFTP file system" and
* tested through its test suite. The
* following RFCs are implemented:
*
* + RFC 1350 "The TFTP Protocol (Revision 2)"
* + RFC 2347 "TFTP Option Extension"
* + RFC 2348 "TFTP Blocksize Option"
* + RFC 7440 "TFTP Windowsize Option"
*/
/*
* Copyright (C) 1998 W. Eric Norum <eric@norum.ca>
* Copyright (C) 2012, 2022 embedded brains GmbH (http://www.embedded-brains.de)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <errno.h>
#include <malloc.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <rtems.h>
#include <rtems/tftp.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include "tftp_driver.h"
/*
* Range of UDP ports to try
*/
#define UDP_PORT_BASE 3180
/*
* Default limits
*/
#define PACKET_FIRST_TIMEOUT_MILLISECONDS 400L
#define TFTP_WINDOW_SIZE_MIN 1
#define TFTP_BLOCK_SIZE_MIN 8
#define TFTP_BLOCK_SIZE_MAX 65464
#define TFTP_BLOCK_SIZE_OPTION "blksize"
#define TFTP_WINDOW_SIZE_OPTION "windowsize"
#define TFTP_DECIMAL_BASE 10
#define TFTP_DEFAULT_SERVER_PORT 69
/*
* These values are suggested by RFC 7440.
*/
#define TFTP_RFC7440_DATA_RETRANSMISSIONS 6
#define TFTP_RFC7440_TIMEOUT_MILLISECONDS 1000
/*
* TFTP opcodes
*/
#define TFTP_OPCODE_RRQ 1
#define TFTP_OPCODE_WRQ 2
#define TFTP_OPCODE_DATA 3
#define TFTP_OPCODE_ACK 4
#define TFTP_OPCODE_ERROR 5
#define TFTP_OPCODE_OACK 6
/*
* TFTP error codes
*/
#define TFTP_ERROR_CODE_NOT_DEFINED 0
#define TFTP_ERROR_CODE_NOT_FOUND 1
#define TFTP_ERROR_CODE_NO_ACCESS 2
#define TFTP_ERROR_CODE_DISK_FULL 3
#define TFTP_ERROR_CODE_ILLEGAL 4
#define TFTP_ERROR_CODE_UNKNOWN_ID 5
#define TFTP_ERROR_CODE_FILE_EXISTS 6
#define TFTP_ERROR_CODE_NO_USER 7
#define TFTP_ERROR_CODE_OPTION_NEGO 8
/*
* Special return values for process_*_packet() functions
* (other return values are POSIX errors)
*/
#define GOT_EXPECTED_PACKET 0
#define GOT_DUPLICATE_OF_CURRENT_PACKET -1
#define GOT_OLD_PACKET -2
#define GOT_FIRST_OUT_OF_ORDER_PACKET -3
/*
* Special argument value for getPacket()
*/
#define GET_PACKET_DONT_WAIT -1
/*
* Special return value for prepare_*_packet_for_sending() functions
* (other return values are the length of the packet to be send)
*/
#define DO_NOT_SEND_PACKET 0
#define PKT_SIZE_FROM_BLK_SIZE(_blksize) ((_blksize) + 2 * sizeof (uint16_t))
#define BLK_SIZE_FROM_PKT_SIZE(_pktsize) ((_pktsize) - 2 * sizeof (uint16_t))
#define MUST_SEND_OPTIONS(_options) (\
(_options).block_size != TFTP_RFC1350_BLOCK_SIZE || \
(_options).window_size != TFTP_RFC1350_WINDOW_SIZE )
/*
* Packets transferred between machines
*/
union tftpPacket {
/*
* RRQ/WRQ packet
*/
struct tftpRWRQ {
uint16_t opcode;
char filename_mode[];
} tftpRWRQ;
/*
* DATA packet
*/
struct tftpDATA {
uint16_t opcode;
uint16_t blocknum;
uint8_t data[];
} tftpDATA;
/*
* ACK packet
*/
struct tftpACK {
uint16_t opcode;
uint16_t blocknum;
} tftpACK;
/*
* OACK packet
*/
struct tftpOACK {
uint16_t opcode;
char options[];
} tftpOACK;
/*
* ERROR packet
*/
struct tftpERROR {
uint16_t opcode;
uint16_t errorCode;
char errorMessage[];
} tftpERROR;
};
/*
* State of each TFTP stream
*/
struct tftpStream {
/*
* Buffer for storing packets for sending and receiving. Can point
* to the same address when only one buffer is needed for reading.
*/
union tftpPacket *receive_buf;
union tftpPacket *send_buf;
/*
* Current block number - i.e. the block currently send or received
*/
uint16_t blocknum;
/*
* Size of the data area in a DATA single packet.
*/
size_t block_size;
/*
* The maximum size of a packet. It depends linearly on the block_size.
* The receive_buf and (the packets in) the send_buf are of this size.
*/
size_t packet_size;
/*
* The number of packets which can be stored in the send buffer.
* During option negotiation and for reading a file from the server
* only a buffer for a single packet is needed. In those cases, this
* value is always one. When a file is written to the server,
* the value equals the window size:
* send_buf_size_in_pkts == server_options.window_size
*
* Packet N is stored in
* send_buf + packet_size * (N % send_buf_size_in_pkts)
*/
uint16_t send_buf_size_in_pkts;
/*
* When writing files with windowsize > 1, the number of the completely
* filled packet with the highest block number in the send buffer.
* When the user calls write(), the data will be written into
* the block after this one.
*/
uint16_t blocknum_last_filled;
/*
* When writing files with windowsize > 1, the number of the packet
* which is the last one in the whole file (i.e. the user
* called close()). This block is never full (but maybe empty).
*/
uint16_t blocknum_eof_block;
/*
* Data transfer socket
*/
int socket;
struct sockaddr_in myAddress;
struct sockaddr_in farAddress;
/*
* Indices into buffer
* In case of sending a file with windowsize > 1, these values apply
* only to the packet with the highest number in the send buffer
* (blocknum_last_filled + 1).
*/
int nleft;
int nused;
/*
* Flags
*/
int firstReply;
bool at_eof;
bool is_for_reading;
/*
* Function pointers and members for use by communicate_with_server().
*/
ssize_t (*prepare_packet_for_sending) (
struct tftpStream *tp,
bool force_retransmission,
union tftpPacket **send_buf,
bool *wait_for_packet_reception,
const void *create_packet_data
);
int (*process_data_packet) (struct tftpStream *tp, ssize_t len);
int (*process_ack_packet) (struct tftpStream *tp, ssize_t len);
int (*process_oack_packet) (struct tftpStream *tp, ssize_t len);
int (*process_error_packet) (struct tftpStream *tp, ssize_t len);
int retransmission_error_code;
bool ignore_out_of_order_packets;
int32_t blocknum_of_first_packet_of_window;
int error;
/*
* Configuration and TFTP options
*
* * config.options are options desired by the user (i.e. the values
* send to the server).
* * server_options are the options agreed by the server
* (the option values actually used for the transfer of data).
*/
tftp_net_config config;
tftp_options server_options;
};
/*
* Forward declaration cannot be avoided.
*/
static ssize_t prepare_data_packet_for_sending (
struct tftpStream *tp,
bool force_retransmission,
union tftpPacket **send_buf,
bool *wait_for_packet_reception,
const void *path_name
);
static ssize_t prepare_ack_packet_for_sending (
struct tftpStream *tp,
bool force_retransmission,
union tftpPacket **send_buf,
bool *wait_for_packet_reception,
const void *path_name
);
/*
* Calculate the address of packet N in the send buffer
*/
static union tftpPacket *get_send_buffer_packet (
struct tftpStream *tp,
uint16_t packet_num
)
{
return (union tftpPacket *) ( ( (char *) tp->send_buf) + tp->packet_size *
(packet_num % tp->send_buf_size_in_pkts) );
}
/*
* Create read or write request
*/
static size_t create_request (
union tftpPacket *send_buf,
size_t data_size,
bool is_for_reading,
const char *path,
const tftp_options *options
)
{
size_t res_size;
char *cur = send_buf->tftpRWRQ.filename_mode;
send_buf->tftpRWRQ.opcode = htons (
is_for_reading ? TFTP_OPCODE_RRQ : TFTP_OPCODE_WRQ
);
res_size = snprintf (cur, data_size, "%s%c%s", path, 0, "octet");
if (res_size >= data_size) {
return -1;
}
res_size++;
data_size -= res_size;
cur += res_size;
if (options->block_size != TFTP_RFC1350_BLOCK_SIZE) {
res_size = snprintf (
cur,
data_size,
"%s%c%"PRIu16,
TFTP_BLOCK_SIZE_OPTION,
0,
options->block_size
);
if (res_size >= data_size) {
return -1;
}
res_size++;
data_size -= res_size;
cur += res_size;
}
if (options->window_size != TFTP_RFC1350_WINDOW_SIZE) {
res_size = snprintf (
cur,
data_size,
"%s%c%"PRIu16,
TFTP_WINDOW_SIZE_OPTION,
0,
options->window_size
);
if (res_size >= data_size) {
return -1;
}
res_size++;
data_size -= res_size;
cur += res_size;
}
return cur - (char *)send_buf;
}
static bool parse_decimal_number (
char **pos,
size_t *remain,
long min,
long max,
uint16_t *variable
)
{
long value;
const char *start = *pos;
if (*remain < 2) {
return false;
}
value = strtoul(start, pos, TFTP_DECIMAL_BASE);
if (value < min || value > max || **pos != 0) {
return false;
}
*variable = (uint16_t) value;
(*pos)++;
*remain -= *pos - start;
return true;
}
/*
* Map error message
*/
static int tftpErrno (uint16_t error_code)
{
unsigned int tftpError;
static const int errorMap[] = {
EINVAL,
ENOENT,
EPERM,
ENOSPC,
EINVAL,
ENXIO,
EEXIST,
ESRCH,
ENOTSUP, /* Error: Option negotiation failed (RFC 2347) */
};
tftpError = ntohs (error_code);
if (tftpError < (sizeof errorMap / sizeof errorMap[0]))
return errorMap[tftpError];
else
return 1000 + tftpError;
}
/*
* Parse options from an OACK packet
*/
static bool parse_options (
union tftpPacket *receive_buf,
size_t packet_size,
tftp_options *options_in,
tftp_options *options_out
)
{
char *pos = receive_buf->tftpOACK.options;
size_t remain = packet_size - sizeof (receive_buf->tftpOACK.opcode);
/*
* Make sure there is a 0 byte in the end before comparing strings
*/
if (remain > 0 && pos[remain - 1] != 0) {
return false;
}
while (remain > 0) {
if (strcasecmp(pos, TFTP_BLOCK_SIZE_OPTION) == 0 &&
options_in->block_size != TFTP_RFC1350_BLOCK_SIZE) {
remain -= sizeof (TFTP_BLOCK_SIZE_OPTION);
pos += sizeof (TFTP_BLOCK_SIZE_OPTION);
if (!parse_decimal_number (
&pos,
&remain,
TFTP_BLOCK_SIZE_MIN,
options_in->block_size,
&options_out->block_size)) {
return false;
};
} else if (strcasecmp(pos, TFTP_WINDOW_SIZE_OPTION) == 0 &&
options_in->window_size != TFTP_RFC1350_WINDOW_SIZE) {
remain -= sizeof (TFTP_WINDOW_SIZE_OPTION);
pos += sizeof (TFTP_WINDOW_SIZE_OPTION);
if (!parse_decimal_number (
&pos,
&remain,
TFTP_WINDOW_SIZE_MIN,
options_in->window_size,
&options_out->window_size)) {
return false;
};
} else {
return false; /* Unknown option */
}
}
return true;
}
/*
* Send an error message
*/
static void send_error (
struct tftpStream *tp,
struct sockaddr_in *to,
uint8_t error_code,
const char *error_message
)
{
int len;
struct {
uint16_t opcode;
uint16_t errorCode;
char errorMessage[80];
} msg;
/*
* Create the error packet (Unknown transfer ID).
*/
msg.opcode = htons (TFTP_OPCODE_ERROR);
msg.errorCode = htons (error_code);
len = snprintf (msg.errorMessage, sizeof (msg.errorMessage), error_message);
if (len >= sizeof (msg.errorMessage)) {
len = sizeof (msg.errorMessage) - 1;
}
len += sizeof (msg.opcode) + sizeof (msg.errorCode) + 1;
/*
* Send it
*/
sendto (tp->socket, (char *)&msg, len, 0, (struct sockaddr *)to, sizeof *to);
}
/*
* Send a message to make the other end shut up
*/
static void sendStifle (struct tftpStream *tp, struct sockaddr_in *to)
{
send_error (tp, to, TFTP_ERROR_CODE_UNKNOWN_ID, "GO AWAY");
}
/*
* Wait for a packet
*/
static ssize_t
getPacket (struct tftpStream *tp, int retryCount)
{
ssize_t len;
struct timeval tv;
int flags = 0;
if (retryCount == GET_PACKET_DONT_WAIT) {
flags = MSG_DONTWAIT;
} else if (retryCount == 0) {
tv.tv_sec = tp->config.first_timeout / 1000L;
tv.tv_usec = (tp->config.first_timeout % 1000L) * 1000L;
setsockopt (tp->socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
} else {
tv.tv_sec = tp->config.timeout / 1000L;
tv.tv_usec = (tp->config.timeout % 1000L) * 1000L;
setsockopt (tp->socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
}
for (;;) {
union {
struct sockaddr s;
struct sockaddr_in i;
} from;
socklen_t fromlen = sizeof from;
len = recvfrom (tp->socket,
tp->receive_buf,
tp->packet_size,
flags,
&from.s,
&fromlen
);
if (len < 0)
break;
if (from.i.sin_addr.s_addr == tp->farAddress.sin_addr.s_addr) {
if (tp->firstReply) {
tp->firstReply = 0;
tp->farAddress.sin_port = from.i.sin_port;
}
if (tp->farAddress.sin_port == from.i.sin_port)
break;
}
/*
* Packet is from someone with whom we are
* not interested. Tell them to go away.
*/
sendStifle (tp, &from.i);
}
if (retryCount != GET_PACKET_DONT_WAIT) {
tv.tv_sec = 0;
tv.tv_usec = 0;
setsockopt (tp->socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof tv);
}
return len;
}
static int process_unexpected_packet (struct tftpStream *tp, ssize_t len)
{
(void) len;
send_error (
tp,
&tp->farAddress,
TFTP_ERROR_CODE_ILLEGAL,
"Got packet with unexpected opcode from server"
);
return EPROTO;
}
static int process_malformed_packet (struct tftpStream *tp, ssize_t len)
{
(void) len;
send_error (
tp,
&tp->farAddress,
TFTP_ERROR_CODE_ILLEGAL,
"Got malformed packet from server"
);
return EPROTO;
}
static int process_error_packet (struct tftpStream *tp, ssize_t len)
{
(void) len;
return tftpErrno (tp->receive_buf->tftpERROR.errorCode);
}
/*
* When an RRQ or a WRQ with options is sent and the server responds with
* an error, this function will trigger a re-sent of an RRQ or WRQ
* without options (falling back to old RFC1350).
*
* If someone wants to change the implementation to force using options
* (i.e. prevent fallback to RFC1350), at least these points must be
* considered:
*
* * Use `process_error_packet()` instead of
* `process_error_packet_option_negotiation()`
* * React to DATA and ACK packets, which are an immediate response to
* an RRQ or a WRQ with options, with an error packet.
* * Check the option values in the OACK whether they are in the
* desired range.
*/
static int process_error_packet_option_negotiation (
struct tftpStream *tp, ssize_t len
)
{
(void) len;
/*
* Setting tp->config.options causes an RRQ or a WRQ to be created without
* options.
* Setting tp->server_option is defensive programming as these fields
* should already have these values.
*/
tp->config.options.block_size = TFTP_RFC1350_BLOCK_SIZE;
tp->config.options.window_size = TFTP_RFC1350_WINDOW_SIZE;
tp->server_options.block_size = TFTP_RFC1350_BLOCK_SIZE;
tp->server_options.window_size = TFTP_RFC1350_WINDOW_SIZE;
tp->process_error_packet = process_error_packet;
/*
* GOT_FIRST_OUT_OF_ORDER_PACKET will trigger a re-send of the RRQ or WRQ.
*/
return GOT_FIRST_OUT_OF_ORDER_PACKET;
}
static int process_data_packet (struct tftpStream *tp, ssize_t len)
{
ssize_t plen;
int32_t pkt_blocknum;
union tftpPacket *send_buf;
if (len < sizeof (tp->receive_buf->tftpACK)) {
return process_malformed_packet (tp, len);
}
pkt_blocknum = (int32_t) ntohs (tp->receive_buf->tftpACK.blocknum);
if (pkt_blocknum == 0) {
return process_malformed_packet (tp, len);
}
/*
* In case of reading a file from the server:
* If the latest ACK packet(s) did not reach the server, the server
* starts the window from the last ACK it received. This if-clause
* ensures, the client sends an ACK after having seen `windowsize`
* packets.
*/
if (pkt_blocknum < tp->blocknum_of_first_packet_of_window &&
pkt_blocknum >= (int32_t) tp->blocknum + 1 -
(int32_t) tp->server_options.window_size) {
tp->blocknum_of_first_packet_of_window = pkt_blocknum;
}
if (!tp->ignore_out_of_order_packets &&
pkt_blocknum > (int32_t) tp->blocknum + 1) {
tp->ignore_out_of_order_packets = true;
return GOT_FIRST_OUT_OF_ORDER_PACKET;
} else if (pkt_blocknum == (int32_t) tp->blocknum) {
/*
* In case of reading a file from the server:
* If the last ACK packet send by the client did not reach the
* server, the server re-sends all packets of the window. In this
* case, the client must re-send the ACK packet after having
* received the last packet of the window (even through it has
* already received that packet before).
* GOT_OLD_PACKET would wrongly suppress this.
*/
return GOT_DUPLICATE_OF_CURRENT_PACKET;
} else if (pkt_blocknum != (int32_t) tp->blocknum + 1) {
return GOT_OLD_PACKET;
}
tp->ignore_out_of_order_packets = false;
tp->blocknum++;
tp->nused = 0; /* Only for 2nd, 3rd, 4th DATA packet received */
tp->nleft = BLK_SIZE_FROM_PKT_SIZE (len);
tp->at_eof = (tp->nleft < tp->server_options.block_size);
/*
* After the last DATA packet, the client must send a final ACK
*/
if (tp->at_eof) {
plen = prepare_ack_packet_for_sending (tp, true, &send_buf, NULL, NULL);
/*
* Send it. Errors during send will not matter for this last ACK.
*/
sendto (
tp->socket,
send_buf,
plen,
0,
(struct sockaddr *) &tp->farAddress,
sizeof (tp->farAddress)
);
}
tp->prepare_packet_for_sending = prepare_ack_packet_for_sending;
return GOT_EXPECTED_PACKET;
}
static int process_ack_packet (struct tftpStream *tp, ssize_t len)
{
uint16_t blocknum_ack;
if (len < sizeof (tp->receive_buf->tftpACK)) {
return process_malformed_packet (tp, len);
}
blocknum_ack = ntohs (tp->receive_buf->tftpACK.blocknum);
if ((int32_t) blocknum_ack == tp->blocknum_of_first_packet_of_window - 1 &&
blocknum_ack != 0
) {
tp->blocknum = tp->blocknum_of_first_packet_of_window;
return GOT_DUPLICATE_OF_CURRENT_PACKET;
}
if ((int32_t) blocknum_ack < tp->blocknum_of_first_packet_of_window ||
blocknum_ack > tp->blocknum_last_filled) {
return GOT_OLD_PACKET;
}
tp->blocknum = blocknum_ack + 1;
tp->blocknum_of_first_packet_of_window = (int32_t) tp->blocknum;
tp->prepare_packet_for_sending = prepare_data_packet_for_sending;
return GOT_EXPECTED_PACKET;
}
static ssize_t prepare_data_packet_for_sending (
struct tftpStream *tp,
bool force_retransmission,
union tftpPacket **send_buf,
bool *wait_for_packet_reception,
const void *not_used
)
{
(void) not_used;
ssize_t len;
*send_buf = get_send_buffer_packet (tp, tp->blocknum);
len = PKT_SIZE_FROM_BLK_SIZE (
(tp->blocknum == tp->blocknum_eof_block) ? tp->nused : tp->block_size
);
(*send_buf)->tftpDATA.opcode = htons (TFTP_OPCODE_DATA);
(*send_buf)->tftpDATA.blocknum = htons (tp->blocknum);
/*
* If the client sends the last packet of a window,
* it must wait for an ACK and - in case no ACK is received - begin
* a retransmission with the first packet of the window.
* Note that the last DATA block for the whole transfer is also
* a "last packet of a window".
*/
if ((int32_t) tp->blocknum + 1 >=
tp->blocknum_of_first_packet_of_window + tp->send_buf_size_in_pkts ||
tp->blocknum == tp->blocknum_eof_block) {
tp->blocknum = (uint16_t) tp->blocknum_of_first_packet_of_window;
} else {
tp->blocknum++;
*wait_for_packet_reception = false;
}
tp->process_data_packet = process_unexpected_packet;
tp->process_ack_packet = process_ack_packet;
tp->process_oack_packet = process_unexpected_packet;
tp->process_error_packet = process_error_packet;
/*
* Our last packet won't necessarily be acknowledged!
*/
if (tp->blocknum == tp->blocknum_eof_block) {
tp->retransmission_error_code = 0;
}
return len;
}
static ssize_t prepare_ack_packet_for_sending (
struct tftpStream *tp,
bool force_retransmission,
union tftpPacket **send_buf,
bool *wait_for_packet_reception,
const void *path_name
)
{
(void) wait_for_packet_reception;
if (!force_retransmission &&
tp->blocknum_of_first_packet_of_window - 1 +
(int32_t) tp->server_options.window_size > (int32_t) tp->blocknum) {
return DO_NOT_SEND_PACKET;
}
tp->blocknum_of_first_packet_of_window = (int32_t) tp->blocknum + 1;
/*
* Create the acknowledgement
*/
*send_buf = tp->send_buf;
(*send_buf)->tftpACK.opcode = htons (TFTP_OPCODE_ACK);
(*send_buf)->tftpACK.blocknum = htons (tp->blocknum);
tp->process_data_packet = process_data_packet;
tp->process_ack_packet = process_unexpected_packet;
tp->process_oack_packet = process_unexpected_packet;
tp->process_error_packet = process_error_packet;
return sizeof (tp->send_buf->tftpACK);
}
static int process_oack_packet (struct tftpStream *tp, ssize_t len)
{
if (!parse_options(tp->receive_buf,
len,
&tp->config.options,
&tp->server_options)) {
send_error (
tp,
&tp->farAddress,
TFTP_ERROR_CODE_OPTION_NEGO,
"Bad options, option values or malformed OACK packet"
);
return EPROTO;
}
if (tp->is_for_reading) {
/*
* Since no DATA packet has been received yet, tell
* tftp_read() there is no data left.
*/
tp->nleft = 0;
tp->prepare_packet_for_sending = prepare_ack_packet_for_sending;
} else {
tp->blocknum_of_first_packet_of_window = 1;
tp->blocknum = (uint16_t) tp->blocknum_of_first_packet_of_window;
tp->prepare_packet_for_sending = prepare_data_packet_for_sending;
}
return GOT_EXPECTED_PACKET;
}
static ssize_t prepare_request_packet_for_sending (
struct tftpStream *tp,
bool force_retransmission,
union tftpPacket **send_buf,
bool *wait_for_packet_reception,
const void *path_name
)
{
(void) wait_for_packet_reception;
ssize_t len;
*send_buf = tp->send_buf;
len = create_request (
*send_buf,
tp->block_size,
tp->is_for_reading,
path_name,
&tp->config.options
);
if (len < 0) {
tp->error = ENAMETOOLONG;
} else {
tp->process_data_packet = tp->is_for_reading ?
process_data_packet : process_unexpected_packet;
tp->process_ack_packet = tp->is_for_reading ?
process_unexpected_packet : process_ack_packet;
tp->process_oack_packet = MUST_SEND_OPTIONS(tp->config.options) ?
process_oack_packet : process_unexpected_packet;
tp->process_error_packet = MUST_SEND_OPTIONS(tp->config.options) ?
process_error_packet_option_negotiation : process_error_packet;
}
/*
* getPacket() will change these values when the first packet is
* received. Yet, this first packet may be an unexpected one
* (e.g. an ERROR or having a wrong block number).
* If a second, third, forth, ... RRQ/WRQ is to be sent, it should
* be directed to the server port again and not to the port the
* first unexpected packet came from.
*/
tp->farAddress.sin_port = htons (tp->config.server_port);
tp->firstReply = 1;
return len;
}
/*
* Conduct one communication step with the server. For windowsize == 1,
* one step is:
* a) Send a packet to the server
* b) Receive a reply packet from the server
* c) Handle errors (if any)
* d) If no packet has been received from the server and the maximum
* retransmission count has not yet been reached, start over with a)
* The flow of packets (i.e. which packet to send and which packet(s) to
* expect from the server) is controlled by function pointers found in
* struct tftpStream.
*
* Besides of handling errors and retransmissions, the essential data exchange
* follows these patterns:
*
* Connection establishment and option negotiation:
* * Send RRQ/WRQ (read or write request packet)
* * Receive OACK (read and write) or ACK (write only) or DATA (read only)
*
* Read step with windowsize == 1:
* * Send ACK packet
* * Receive DATA packet
* Sending the very last ACK packet for a "read" session is treated as a
* special case.
*
* Write step with windowsize == 1:
* * Send DATA packet
* * Receive ACK packet
*
* A windowsize lager than one makes thinks more complicated.
* In this case, a step normally only receives (read) or only sends (write)
* a packet. The sending or receiving of the ACK packets is skipped normally
* and happens only at the last step of the window (in which case this last
* step is similar to the windowsize == 1 case):
*
* Normal read step with windowsize > 1:
* * Receive DATA packet
* Last read step of a window with windowsize > 1:
* * Send ACK packet
* * Receive DATA packet
*
* Normal write step with windowsize > 1:
* * Send DATA packet
* * Check for an ACK packet but do not wait for it
* Last write step of a window with windowsize > 1:
* * Send DATA packet
* * Receive ACK packet
*
* The "normal write step for windowsize > 1" checks whether an ACK packet
* has been received after each sending of a DATA packet. Package lost and
* exchanges in the network can give rise to situations in which the server
* sends more than a single ACK packet during a window. If these packets
* are not reacted on immediately, the network would be flooded with
* surplus packets. (An example where two ACK packets appear in a window
* appears in test case "read_file_windowsize_trouble" where the client/server
* roles are exchanged.)
*/
static int communicate_with_server (
struct tftpStream *tp,
const void *create_packet_data
)
{
ssize_t len;
uint16_t opcode;
union tftpPacket *send_buf;
bool received_duplicated_or_old_package = false;
bool force_retransmission = false;
bool wait_for_packet_reception;
int retryCount = 0;
while (tp->error == 0) {
if (!received_duplicated_or_old_package) {
wait_for_packet_reception = true;
len = tp->prepare_packet_for_sending (
tp,
force_retransmission,
&send_buf,
&wait_for_packet_reception,
create_packet_data
);
if (len < 0) {
if (tp->error == 0) {
tp->error = EIO;
}
break;
}
if (len != DO_NOT_SEND_PACKET) {
/*
* Send the packet
*/
if (sendto (tp->socket, send_buf, len, 0,
(struct sockaddr *)&tp->farAddress,
sizeof tp->farAddress) < 0) {
tp->error = EIO;
break;
}
}
}
received_duplicated_or_old_package = false;
force_retransmission = false;
/*
* Get reply
*/
len = getPacket (
tp,
wait_for_packet_reception ? retryCount : GET_PACKET_DONT_WAIT
);
if (len >= (int) sizeof (tp->receive_buf->tftpDATA.opcode)) {
opcode = ntohs (tp->receive_buf->tftpDATA.opcode);
switch (opcode) {
case TFTP_OPCODE_DATA:
tp->error = tp->process_data_packet (tp, len);
break;
case TFTP_OPCODE_ACK:
tp->error = tp->process_ack_packet (tp, len);
break;
case TFTP_OPCODE_OACK:
tp->error = tp->process_oack_packet (tp, len);
break;
case TFTP_OPCODE_ERROR:
tp->error = tp->process_error_packet (tp, len);
break;
default:
tp->error = process_unexpected_packet (tp, len);
break;
}
if (tp->error == GOT_EXPECTED_PACKET) {
break;
} else if (tp->error == GOT_DUPLICATE_OF_CURRENT_PACKET) {
tp->error = 0;
} else if (tp->error == GOT_OLD_PACKET) {
received_duplicated_or_old_package = true;
tp->error = 0;
} else if (tp->error <= GOT_FIRST_OUT_OF_ORDER_PACKET) {
force_retransmission = true;
tp->error = 0;
} /* else ... tp->error > 0 means "exit this function with error" */
} else if (len >= 0) {
tp->error = process_malformed_packet (tp, len);
} else if (len < 0 && !wait_for_packet_reception) {
tp->error = 0;
break;
} else {
/*
* Timeout or other problems to receive packets
* Attempt a retransmission
*/
if (++retryCount >= (int) tp->config.retransmissions) {
tp->error = tp->retransmission_error_code;
break;
}
force_retransmission = true;
}
}
return tp->error;
}
/*
* Allocate and initialize an struct tftpStream object.
*
* This function does not check whether the config values are in valid ranges.
*/
static struct tftpStream *create_stream(
const tftp_net_config *config,
const struct in_addr *farAddress,
bool is_for_reading
)
{
struct tftpStream *tp = NULL;
tp = malloc (sizeof (struct tftpStream));
if (tp == NULL) {
return NULL;
}
/*
* Initialize fields accessed by _Tftp_Destroy().
*/
tp->receive_buf = NULL;
tp->send_buf = NULL;
tp->socket = 0;
/*
* Allocate send and receive buffer for exchange of RRQ/WRQ and ACK/OACK.
*/
tp->block_size = TFTP_RFC1350_BLOCK_SIZE;
tp->packet_size = PKT_SIZE_FROM_BLK_SIZE (tp->block_size);
tp->receive_buf = malloc (tp->packet_size);
if (tp->receive_buf == NULL) {
_Tftp_Destroy (tp);
return NULL;
}
tp->send_buf = tp->receive_buf;
tp->send_buf_size_in_pkts = 1;
/*
* Create the socket
*/
if ((tp->socket = socket (AF_INET, SOCK_DGRAM, 0)) < 0) {
_Tftp_Destroy (tp);
return NULL;
}
/*
* Setup configuration and options
*/
if ( config == NULL ) {
tftp_initialize_net_config (&tp->config);
} else {
tp->config = *config;
}
/*
* If the server does not confirm our option values later on,
* use numbers from the original RFC 1350 for the actual transfer.
*/
tp->server_options.block_size = TFTP_RFC1350_BLOCK_SIZE;
tp->server_options.window_size = TFTP_RFC1350_WINDOW_SIZE;
/*
* Set the UDP destination to the TFTP server
* port on the remote machine.
*/
tp->farAddress.sin_family = AF_INET;
tp->farAddress.sin_addr = *farAddress;
tp->farAddress.sin_port = htons (tp->config.server_port);
tp->nleft = 0;
tp->nused = 0;
tp->blocknum = 0;
tp->blocknum_last_filled = 0;
tp->blocknum_eof_block = UINT16_MAX;
tp->firstReply = 1;
tp->at_eof = false;
tp->is_for_reading = is_for_reading;
tp->prepare_packet_for_sending = prepare_request_packet_for_sending;
tp->process_data_packet = process_unexpected_packet;
tp->process_ack_packet = process_unexpected_packet;
tp->process_oack_packet = process_unexpected_packet;
tp->process_error_packet = process_error_packet;
tp->retransmission_error_code = EIO;
tp->ignore_out_of_order_packets = false;
tp->blocknum_of_first_packet_of_window = INT32_MIN;
tp->error = 0;
return tp;
}
/*
* Change the size of the receive and send buffer to match the options
* values acknowledged by the server.
*/
static struct tftpStream *reallocate_stream_buffer(struct tftpStream *tp)
{
tp->block_size = tp->server_options.block_size;
tp->packet_size = PKT_SIZE_FROM_BLK_SIZE (tp->block_size);
/*
* Defensive programming
*/
if (tp->receive_buf == tp->send_buf) {
tp->send_buf = NULL;
} else {
free (tp->send_buf);
}
tp->receive_buf = realloc (tp->receive_buf, tp->packet_size);
if (tp->is_for_reading) {
tp->send_buf = tp->receive_buf;
} else {
tp->send_buf_size_in_pkts = tp->server_options.window_size;
tp->send_buf = malloc (
tp->send_buf_size_in_pkts * tp->packet_size
);
}
if (tp->receive_buf == NULL || tp->send_buf == NULL) {
sendStifle (tp, &tp->farAddress);
_Tftp_Destroy (tp);
return NULL;
}
return tp;
}
/*
* Convert hostname to an Internet address
*/
static struct in_addr *get_ip_address(
const char *hostname,
struct in_addr *farAddress
)
{
struct hostent *he = gethostbyname(hostname);
if (he == NULL) {
return NULL;
}
memcpy (farAddress, he->h_addr, sizeof (*farAddress));
return farAddress;
}
void tftp_initialize_net_config (tftp_net_config *config)
{
static const tftp_net_config default_config = {
.retransmissions = TFTP_RFC7440_DATA_RETRANSMISSIONS,
.server_port = TFTP_DEFAULT_SERVER_PORT,
.timeout = TFTP_RFC7440_TIMEOUT_MILLISECONDS,
.first_timeout = PACKET_FIRST_TIMEOUT_MILLISECONDS,
.options = {
.block_size = TFTP_DEFAULT_BLOCK_SIZE,
.window_size = TFTP_DEFAULT_WINDOW_SIZE
}
};
if (config != NULL) {
memcpy (config, &default_config, sizeof (default_config));
}
}
int tftp_open(
const char *hostname,
const char *path,
bool is_for_reading,
const tftp_net_config *config,
void **tftp_handle
)
{
struct tftpStream *tp;
struct in_addr farAddress;
int err;
/*
* Check parameters
*/
if (tftp_handle == NULL) {
return EINVAL;
}
*tftp_handle = NULL;
if (hostname == NULL || path == NULL) {
return EINVAL;
}
if (config != NULL && (
config->options.window_size < TFTP_WINDOW_SIZE_MIN ||
config->options.block_size < TFTP_BLOCK_SIZE_MIN ||
config->options.block_size > TFTP_BLOCK_SIZE_MAX ) ) {
return EINVAL;
}
/*
* Create tftpStream structure
*/
if (get_ip_address( hostname, &farAddress ) == NULL) {
return ENOENT;
}
tp = create_stream( config, &farAddress, is_for_reading );
if (tp == NULL) {
return ENOMEM;
}
/*
* Send RRQ or WRQ and wait for reply
*/
tp->prepare_packet_for_sending = prepare_request_packet_for_sending;
err = communicate_with_server (tp, path);
if ( err != 0 ) {
_Tftp_Destroy (tp);
return err;
}
*tftp_handle = reallocate_stream_buffer ( tp );
if( *tftp_handle == NULL ) {
return ENOMEM;
}
return 0;
}
/*
* Read from a TFTP stream
*/
ssize_t tftp_read(
void *tftp_handle,
void *buffer,
size_t count
)
{
char *bp;
struct tftpStream *tp = tftp_handle;
int nwant;
int err;
if (tp == NULL || !tp->is_for_reading || buffer == NULL)
return -EIO;
/*
* Read till user request is satisfied or EOF is reached
*/
bp = buffer;
nwant = count;
while (nwant) {
if (tp->nleft) {
int ncopy;
if (nwant < tp->nleft)
ncopy = nwant;
else
ncopy = tp->nleft;
memcpy (bp, &tp->receive_buf->tftpDATA.data[tp->nused], ncopy);
tp->nused += ncopy;
tp->nleft -= ncopy;
bp += ncopy;
nwant -= ncopy;
if (nwant == 0)
break;
}
if (tp->at_eof) {
break;
}
/*
* Wait for the next packet
*/
tp->retransmission_error_code = -EIO;
err = communicate_with_server(tp, NULL);
if (err == tp->retransmission_error_code) {
return -EIO;
}
/*
* If communicate_with_server() returns an error, either
* * an error message from the server was received or
* * an error message was already sent to the server
* Setting tp->at_eof true, prevents all further calls to
* communicate_with_server() and suppresses the sending of
* an error message to the server by tftp_close().
*/
if (err != 0) {
tp->at_eof = true;
return -err;
}
}
return count - nwant;
}
/*
* Flush a write buffer and wait for acknowledgement
*
* This function returns only if there is at least one packet buffer free
* in the tp->send_buf. This ensures that tftp_write() can store
* further data for sending in this free packet buffer.
*
* When the end of file has been reached (i.e. tftp_close() called this
* function), this function returns only after all packets
* in the write buffer have been send and acknowledged (or if an error
* occurred).
*/
static int rtems_tftp_flush (struct tftpStream *tp)
{
int err;
if (tp->at_eof) {
return 0;
}
do {
err = communicate_with_server(tp, NULL);
/*
* If communicate_with_server() returns an error, either
* * an error message from the server was received or
* * an error message was already sent to the server
* Setting tp->at_eof true, prevents all further calls to
* communicate_with_server() and suppresses the sending of
* an error message to the server by tftp_close().
*/
if (err != 0) {
tp->at_eof = true;
return err;
}
} while(
(int32_t) tp->blocknum_last_filled + 1 >=
tp->blocknum_of_first_packet_of_window + tp->send_buf_size_in_pkts ||
/*
* tp->blocknum_eof_block == tp->blocknum_last_filled
* holds only true when the user invoked tftp_close().
*/
(tp->blocknum_eof_block == tp->blocknum_last_filled &&
tp->blocknum_of_first_packet_of_window <=
(int32_t) tp->blocknum_eof_block)
);
return 0;
}
/*
* Close a TFTP stream
*/
int tftp_close(
void *tftp_handle
)
{
struct tftpStream *tp = tftp_handle;
int e = 0;
if (tp == NULL) {
return 0;
}
if (!tp->is_for_reading) {
tp->blocknum_last_filled++;
tp->blocknum_eof_block = tp->blocknum_last_filled;
e = rtems_tftp_flush (tp);
tp->at_eof = true;
}
if (!tp->at_eof && !tp->firstReply) {
/*
* Tell the other end to stop
*/
rtems_interval ticksPerSecond;
send_error (
tp,
&tp->farAddress,
TFTP_ERROR_CODE_NO_USER,
"User (client) stopped reading or "
"server stopped sending packets (timeout)"
);
ticksPerSecond = rtems_clock_get_ticks_per_second();
rtems_task_wake_after (1 + ticksPerSecond / 10);
}
_Tftp_Destroy (tp);
return e;
}
ssize_t tftp_write(
void *tftp_handle,
const void *buffer,
size_t count
)
{
const char *bp;
struct tftpStream *tp = tftp_handle;
int nleft, nfree, ncopy;
int err;
union tftpPacket *send_buf;
/*
* Bail out if an error has occurred
*/
if (tp == NULL || tp->is_for_reading || tp->at_eof || buffer == NULL) {
return -EIO;
}
/*
* Write till user request is satisfied
* Notice that the buffer is flushed as soon as it is filled rather
* than waiting for the next write or a close. This ensures that
* the flush in close writes a less than full buffer so the far
* end can detect the end-of-file condition.
*/
bp = buffer;
nleft = count;
while (nleft) {
nfree = tp->block_size - tp->nused;
if (nleft < nfree)
ncopy = nleft;
else
ncopy = nfree;
send_buf = get_send_buffer_packet (tp, tp->blocknum_last_filled + 1);
memcpy (&send_buf->tftpDATA.data[tp->nused], bp, ncopy);
tp->nused += ncopy;
nleft -= ncopy;
bp += ncopy;
if (tp->nused == tp->block_size) {
tp->blocknum_last_filled++;
err = rtems_tftp_flush (tp);
if (err) {
return -err;
}
tp->nused = 0;
}
}
return count;
}
void _Tftp_Destroy(
void *tftp_handle
)
{
struct tftpStream *tp = tftp_handle;
if (tp == NULL) {
return;
}
if (tp->socket >= 0) {
close (tp->socket);
}
if (tp->receive_buf == tp->send_buf) {
tp->send_buf = NULL;
}
free (tp->receive_buf);
free (tp->send_buf);
free (tp);
}
