kgess-mirror/freebsd-src
1
0
Fork 0
mirror of https://git.freebsd.org/src.git synced 2026-01-16 23:02:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2
freebsd-src/libexec/tftpd/tests/functional.c
Mark Johnston 79c342aaf8 tftpd: Address flaky tests 
The tftpd tests all follow the same pattern:
1. open a UDP socket,
2. fork a child to exec tftpd, which subsequently handles requests on
   the socket,
3. use a client socket to send some message to the tftpd daemon.

However, tftpd's first action is to mark its socket as non-blocking and
then read a request from it.  If no data is present in the socket, tftpd
exits immediately with an error.  So, there is a race; we often see
tftpd test timeouts when running tests in parallel.  These timeouts also
arise periodically in CI runs.

One solution is to restructure each test to create the server socket,
then write the request to the client socket, then fork tftpd.  This
closes the race.  However, this involves a lot of churn.

This patch fixes the problem a different way, by adding a new -b flag to
tftpd which makes it block to read the initial request.  Each test is
modified to use -b, closing the race.

Reviewed by:	imp, asomers
MFC after:	2 weeks
Differential Revision:	https://reviews.freebsd.org/D47404
2024-11-03 16:47:38 +00:00

1283 lines
31 KiB
C
Raw Permalink Blame History

/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2018 Alan Somers.
*
* 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 AUTHOR 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 AUTHOR 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.
*/
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdalign.h>
#include <stdio.h>
#include <unistd.h>
#include <atf-c.h>
#include <libutil.h>
static const uint16_t BASEPORT = 6969;
static const char pidfile[] = "tftpd.pid";
static int protocol = PF_UNSPEC;
static int s = -1; /* tftp client socket */
static struct sockaddr_storage addr; /* Destination address for the client */
static bool s_flag = false; /* Pass -s to tftpd */
static bool w_flag = false; /* Pass -w to tftpd */
/* Helper functions*/
static void require_bufeq(const char *expected, size_t expected_len,
const char *actual, size_t len);
/*
* Receive a response from tftpd
* @param hdr The reply's expected header, as a char array
* @param contents The reply's expected contents, as a char array
* @param contents_len Length of contents
*/
#define RECV(hdr, contents, contents_len) do { \
char buffer[1024]; \
struct sockaddr_storage from; \
socklen_t fromlen = sizeof(from); \
ssize_t r = recvfrom(s, buffer, sizeof(buffer), 0, \
(struct sockaddr *)&from, &fromlen); \
ATF_REQUIRE(r > 0); \
require_bufeq((hdr), sizeof(hdr), buffer, \
MIN((size_t)r, sizeof(hdr))); \
require_bufeq((const char *) (contents), (contents_len), \
&buffer[sizeof(hdr)], r - sizeof(hdr)); \
if (protocol == PF_INET) { \
((struct sockaddr_in *)&addr)->sin_port = \
((struct sockaddr_in *)&from)->sin_port; \
} else { \
((struct sockaddr_in6 *)&addr)->sin6_port = \
((struct sockaddr_in6 *)&from)->sin6_port; \
} \
} while(0)
static void
recv_ack(uint16_t blocknum)
{
char hdr[] = {0, 4, blocknum >> 8, blocknum & 0xFF};
RECV(hdr, NULL, 0);
}
static void
recv_oack(const char *options, size_t options_len)
{
char hdr[] = {0, 6};
RECV(hdr, options, options_len);
}
/*
* Receive a data packet from tftpd
* @param blocknum Expected block number to be received
* @param contents Pointer to expected contents
* @param contents_len Length of contents expected to receive
*/
static void
recv_data(uint16_t blocknum, const char *contents, size_t contents_len)
{
char hdr[] = {0, 3, blocknum >> 8, blocknum & 0xFF};
RECV(hdr, contents, contents_len);
}
#define RECV_ERROR(code, msg) do { \
char hdr[] = {0, 5, code >> 8, code & 0xFF}; \
RECV(hdr, msg, sizeof(msg)); \
} while (0)
/*
* send a command to tftpd.
* @param cmd Command to send, as a char array
*/
static void
send_bytes(const void *cmd, size_t len)
{
ssize_t r;
r = sendto(s, cmd, len, 0, (struct sockaddr *)(&addr), addr.ss_len);
ATF_REQUIRE(r >= 0);
ATF_REQUIRE_EQ(len, (size_t)r);
}
static void
send_data(uint16_t blocknum, const char *contents, size_t contents_len)
{
char buffer[1024];
buffer[0] = 0; /* DATA opcode high byte */
buffer[1] = 3; /* DATA opcode low byte */
buffer[2] = blocknum >> 8;
buffer[3] = blocknum & 0xFF;
memmove(&buffer[4], contents, contents_len);
send_bytes(buffer, 4 + contents_len);
}
/*
* send a command to tftpd.
* @param cmd Command to send, as a const string
* (terminating NUL will be ignored)
*/
#define SEND_STR(cmd) \
ATF_REQUIRE_EQ(sizeof(cmd) - 1, \
sendto(s, (cmd), sizeof(cmd) - 1, 0, \
(struct sockaddr *)(&addr), addr.ss_len))
/*
* Acknowledge block blocknum
*/
static void
send_ack(uint16_t blocknum)
{
char packet[] = {
0, 4, /* ACK opcode in BE */
blocknum >> 8,
blocknum & 0xFF
};
send_bytes(packet, sizeof(packet));
}
/*
* build an option string
*/
#define OPTION_STR(name, value) name "\000" value "\000"
/*
* send a read request to tftpd.
* @param filename filename as a string, absolute or relative
* @param mode either "octet" or "netascii"
*/
#define SEND_RRQ(filename, mode) \
SEND_STR("\0\001" filename "\0" mode "\0")
/*
* send a read request with options
*/
#define SEND_RRQ_OPT(filename, mode, options) \
SEND_STR("\0\001" filename "\0" mode "\000" options)
/*
* send a write request to tftpd.
* @param filename filename as a string, absolute or relative
* @param mode either "octet" or "netascii"
*/
#define SEND_WRQ(filename, mode) \
SEND_STR("\0\002" filename "\0" mode "\0")
/*
* send a write request with options
*/
#define SEND_WRQ_OPT(filename, mode, options) \
SEND_STR("\0\002" filename "\0" mode "\000" options)
/* Define a test case, for both IPv4 and IPv6 */
#define TFTPD_TC_DEFINE(name, head, ...) \
static void \
name ## _body(void); \
ATF_TC_WITH_CLEANUP(name ## _v4); \
ATF_TC_HEAD(name ## _v4, tc) \
{ \
head \
} \
ATF_TC_BODY(name ## _v4, tc) \
{ \
int exitcode = 0; \
__VA_ARGS__; \
protocol = AF_INET; \
s = setup(&addr, __COUNTER__); \
name ## _body(); \
close(s); \
if (exitcode >= 0) \
check_server(exitcode); \
} \
ATF_TC_CLEANUP(name ## _v4, tc) \
{ \
cleanup(); \
} \
ATF_TC_WITH_CLEANUP(name ## _v6); \
ATF_TC_HEAD(name ## _v6, tc) \
{ \
head \
} \
ATF_TC_BODY(name ## _v6, tc) \
{ \
int exitcode = 0; \
__VA_ARGS__; \
protocol = AF_INET6; \
s = setup(&addr, __COUNTER__); \
name ## _body(); \
close(s); \
if (exitcode >= 0) \
check_server(exitcode); \
} \
ATF_TC_CLEANUP(name ## _v6, tc) \
{ \
cleanup(); \
} \
static void \
name ## _body(void)
/* Add the IPv4 and IPv6 versions of a test case */
#define TFTPD_TC_ADD(tp, name) do { \
ATF_TP_ADD_TC(tp, name ## _v4); \
ATF_TP_ADD_TC(tp, name ## _v6); \
} while (0)
static void
sigalrm(int signo __unused)
{
}
/* Check that server exits with specific exit code */
static void
check_server(int exitcode)
{
struct sigaction sa = { .sa_handler = sigalrm };
struct itimerval it = { .it_value = { .tv_sec = 30 } };
FILE *f;
pid_t pid;
int wstatus;
f = fopen(pidfile, "r");
ATF_REQUIRE(f != NULL);
ATF_REQUIRE_INTEQ(1, fscanf(f, "%d", &pid));
ATF_CHECK_INTEQ(0, fclose(f));
ATF_REQUIRE_INTEQ(0, sigaction(SIGALRM, &sa, NULL));
ATF_REQUIRE_EQ(0, setitimer(ITIMER_REAL, &it, NULL));
ATF_REQUIRE_EQ(pid, waitpid(pid, &wstatus, 0));
ATF_CHECK(WIFEXITED(wstatus));
ATF_CHECK_INTEQ(exitcode, WEXITSTATUS(wstatus));
unlink(pidfile);
}
/* Standard cleanup used by all testcases */
static void
cleanup(void)
{
FILE *f;
pid_t pid;
f = fopen(pidfile, "r");
if (f == NULL)
return;
unlink(pidfile);
if (fscanf(f, "%d", &pid) == 1) {
kill(pid, SIGTERM);
waitpid(pid, NULL, 0);
}
fclose(f);
}
/* Assert that two binary buffers are identical */
static void
require_bufeq(const char *expected, size_t expected_len,
const char *actual, size_t len)
{
size_t i;
ATF_REQUIRE_EQ_MSG(expected_len, len,
"Expected %zu bytes but got %zu", expected_len, len);
for (i = 0; i < len; i++) {
ATF_REQUIRE_EQ_MSG(expected[i], actual[i],
"Expected %#hhx at position %zu; got %hhx instead",
expected[i], i, actual[i]);
}
}
/*
* Start tftpd and return its communicating socket
* @param to Will be filled in for use with sendto
* @param idx Unique identifier of the test case
* @return Socket ready to use
*/
static int
setup(struct sockaddr_storage *to, uint16_t idx)
{
int client_s, server_s, pid, argv_idx;
char execname[] = "/usr/libexec/tftpd";
char b_flag_str[] = "-b";
char s_flag_str[] = "-s";
char w_flag_str[] = "-w";
char pwd[MAXPATHLEN];
char *argv[10];
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
struct sockaddr *server_addr;
struct pidfh *pfh;
uint16_t port = BASEPORT + idx;
socklen_t len;
int pd[2];
ATF_REQUIRE_EQ(0, pipe2(pd, O_CLOEXEC));
if (protocol == PF_INET) {
len = sizeof(addr4);
bzero(&addr4, len);
addr4.sin_len = len;
addr4.sin_family = PF_INET;
addr4.sin_port = htons(port);
server_addr = (struct sockaddr *)&addr4;
} else {
len = sizeof(addr6);
bzero(&addr6, len);
addr6.sin6_len = len;
addr6.sin6_family = PF_INET6;
addr6.sin6_port = htons(port);
server_addr = (struct sockaddr *)&addr6;
}
ATF_REQUIRE_EQ(pwd, getcwd(pwd, sizeof(pwd)));
/* Must bind(2) pre-fork so it happens before the client's send(2) */
server_s = socket(protocol, SOCK_DGRAM, 0);
if (server_s < 0 && errno == EAFNOSUPPORT) {
atf_tc_skip("This test requires IPv%d support",
protocol == PF_INET ? 4 : 6);
}
ATF_REQUIRE_MSG(server_s >= 0,
"socket failed with error %s", strerror(errno));
ATF_REQUIRE_EQ_MSG(0, bind(server_s, server_addr, len),
"bind failed with error %s", strerror(errno));
pid = fork();
switch (pid) {
case -1:
atf_tc_fail("fork failed");
break;
case 0:
/* In child */
pfh = pidfile_open(pidfile, 0644, NULL);
ATF_REQUIRE_MSG(pfh != NULL,
"pidfile_open: %s", strerror(errno));
ATF_REQUIRE_EQ(0, pidfile_write(pfh));
ATF_REQUIRE_EQ(0, pidfile_close(pfh));
bzero(argv, sizeof(argv));
argv[0] = execname;
argv_idx = 1;
argv[argv_idx++] = b_flag_str;
if (w_flag)
argv[argv_idx++] = w_flag_str;
if (s_flag)
argv[argv_idx++] = s_flag_str;
argv[argv_idx++] = pwd;
ATF_REQUIRE_EQ(STDOUT_FILENO, dup2(server_s, STDOUT_FILENO));
ATF_REQUIRE_EQ(STDIN_FILENO, dup2(server_s, STDIN_FILENO));
ATF_REQUIRE_EQ(STDERR_FILENO, dup2(server_s, STDERR_FILENO));
execv(execname, argv);
atf_tc_fail("exec failed");
break;
default:
/* In parent */
ATF_REQUIRE_INTEQ(0, close(pd[1]));
/* block until other end is closed on exec() or exit() */
ATF_REQUIRE_INTEQ(0, read(pd[0], &pd[1], sizeof(pd[1])));
ATF_REQUIRE_INTEQ(0, close(pd[0]));
bzero(to, sizeof(*to));
if (protocol == PF_INET) {
struct sockaddr_in *to4 = (struct sockaddr_in *)to;
to4->sin_len = sizeof(*to4);
to4->sin_family = PF_INET;
to4->sin_port = htons(port);
to4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
} else {
struct in6_addr loopback = IN6ADDR_LOOPBACK_INIT;
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)to;
to6->sin6_len = sizeof(*to6);
to6->sin6_family = PF_INET6;
to6->sin6_port = htons(port);
to6->sin6_addr = loopback;
}
ATF_REQUIRE_INTEQ(0, close(server_s));
ATF_REQUIRE((client_s = socket(protocol, SOCK_DGRAM, 0)) > 0);
break;
}
/* Clear the client's umask. Test cases will specify exact modes */
umask(0000);
return (client_s);
}
/* Like write(2), but never returns less than the requested length */
static void
write_all(int fd, const void *buf, size_t nbytes)
{
ssize_t r;
while (nbytes > 0) {
r = write(fd, buf, nbytes);
ATF_REQUIRE(r > 0);
nbytes -= (size_t)r;
buf = (const char *)buf + (size_t)r;
}
}
/*
* Test Cases
*/
/*
* Read a file, specified by absolute pathname.
*/
TFTPD_TC_DEFINE(abspath,)
{
int fd;
char command[1024];
size_t pathlen;
char suffix[] = {'\0', 'o', 'c', 't', 'e', 't', '\0'};
command[0] = 0; /* RRQ high byte */
command[1] = 1; /* RRQ low byte */
ATF_REQUIRE(getcwd(&command[2], sizeof(command) - 2) != NULL);
pathlen = strlcat(&command[2], "/abspath.txt", sizeof(command) - 2);
ATF_REQUIRE(pathlen + sizeof(suffix) < sizeof(command) - 2);
memmove(&command[2 + pathlen], suffix, sizeof(suffix));
fd = open("abspath.txt", O_CREAT | O_RDONLY, 0644);
ATF_REQUIRE(fd >= 0);
close(fd);
send_bytes(command, 2 + pathlen + sizeof(suffix));
recv_data(1, NULL, 0);
send_ack(1);
}
/*
* Attempt to read a file outside of the allowed directory(ies)
*/
TFTPD_TC_DEFINE(dotdot,)
{
ATF_REQUIRE_EQ(0, mkdir("subdir", 0777));
SEND_RRQ("../disallowed.txt", "octet");
RECV_ERROR(2, "Access violation");
s = setup(&addr, __COUNTER__);
SEND_RRQ("subdir/../../disallowed.txt", "octet");
RECV_ERROR(2, "Access violation");
s = setup(&addr, __COUNTER__);
SEND_RRQ("/etc/passwd", "octet");
RECV_ERROR(2, "Access violation");
}
/*
* With "-s", tftpd should chroot to the specified directory
*/
TFTPD_TC_DEFINE(s_flag,
atf_tc_set_md_var(tc, "require.user", "root");,
s_flag = true)
{
int fd;
char contents[] = "small";
fd = open("small.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, strlen(contents) + 1);
close(fd);
SEND_RRQ("/small.txt", "octet");
recv_data(1, contents, strlen(contents) + 1);
send_ack(1);
}
/*
* Read a file, and simulate a dropped ACK packet
*/
TFTPD_TC_DEFINE(rrq_dropped_ack,)
{
int fd;
char contents[] = "small";
fd = open("small.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, strlen(contents) + 1);
close(fd);
SEND_RRQ("small.txt", "octet");
recv_data(1, contents, strlen(contents) + 1);
/*
* client "sends" the ack, but network drops it
* Eventually, tftpd should resend the data packet
*/
recv_data(1, contents, strlen(contents) + 1);
send_ack(1);
}
/*
* Read a file, and simulate a dropped DATA packet
*/
TFTPD_TC_DEFINE(rrq_dropped_data,)
{
int fd;
size_t i;
uint32_t contents[192];
char buffer[1024];
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, sizeof(contents));
close(fd);
SEND_RRQ("medium.txt", "octet");
recv_data(1, (const char *)&contents[0], 512);
send_ack(1);
(void) recvfrom(s, buffer, sizeof(buffer), 0, NULL, NULL);
/*
* server "sends" the data, but network drops it
* Eventually, client should resend the last ACK
*/
send_ack(1);
recv_data(2, (const char *)&contents[128], 256);
send_ack(2);
}
/*
* Read a medium file, and simulate a duplicated ACK packet
*/
TFTPD_TC_DEFINE(rrq_duped_ack,)
{
int fd;
size_t i;
uint32_t contents[192];
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, sizeof(contents));
close(fd);
SEND_RRQ("medium.txt", "octet");
recv_data(1, (const char *)&contents[0], 512);
send_ack(1);
send_ack(1); /* Dupe an ACK packet */
recv_data(2, (const char *)&contents[128], 256);
recv_data(2, (const char *)&contents[128], 256);
send_ack(2);
}
/*
* Attempt to read a file without read permissions
*/
TFTPD_TC_DEFINE(rrq_eaccess,)
{
int fd;
fd = open("empty.txt", O_CREAT | O_RDONLY, 0000);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_RRQ("empty.txt", "octet");
RECV_ERROR(2, "Access violation");
}
/*
* Read an empty file
*/
TFTPD_TC_DEFINE(rrq_empty,)
{
int fd;
fd = open("empty.txt", O_CREAT | O_RDONLY, 0644);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_RRQ("empty.txt", "octet");
recv_data(1, NULL, 0);
send_ack(1);
}
/*
* Read a medium file of more than one block
*/
TFTPD_TC_DEFINE(rrq_medium,)
{
int fd;
size_t i;
uint32_t contents[192];
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, sizeof(contents));
close(fd);
SEND_RRQ("medium.txt", "octet");
recv_data(1, (const char *)&contents[0], 512);
send_ack(1);
recv_data(2, (const char *)&contents[128], 256);
send_ack(2);
}
/*
* Read a medium file with a window size of 2.
*/
TFTPD_TC_DEFINE(rrq_medium_window,)
{
int fd;
size_t i;
uint32_t contents[192];
char options[] = OPTION_STR("windowsize", "2");
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, sizeof(contents));
close(fd);
SEND_RRQ_OPT("medium.txt", "octet", OPTION_STR("windowsize", "2"));
recv_oack(options, sizeof(options) - 1);
send_ack(0);
recv_data(1, (const char *)&contents[0], 512);
recv_data(2, (const char *)&contents[128], 256);
send_ack(2);
}
/*
* Read a file in netascii format
*/
TFTPD_TC_DEFINE(rrq_netascii,)
{
int fd;
char contents[] = "foo\nbar\rbaz\n";
/*
* Weirdly, RFC-764 says that CR must be followed by NUL if a line feed
* is not intended
*/
char expected[] = "foo\r\nbar\r\0baz\r\n";
fd = open("unix.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, strlen(contents) + 1);
close(fd);
SEND_RRQ("unix.txt", "netascii");
recv_data(1, expected, sizeof(expected));
send_ack(1);
}
/*
* Read a file that doesn't exist
*/
TFTPD_TC_DEFINE(rrq_nonexistent,)
{
SEND_RRQ("nonexistent.txt", "octet");
RECV_ERROR(1, "File not found");
}
/*
* Attempt to read a file whose name exceeds PATH_MAX
*/
TFTPD_TC_DEFINE(rrq_path_max,)
{
#define AReallyBigFileName \
"AReallyBigFileNameXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
".txt"
ATF_REQUIRE_MSG(strlen(AReallyBigFileName) > PATH_MAX,
"Somebody increased PATH_MAX. Update the test");
SEND_RRQ(AReallyBigFileName, "octet");
RECV_ERROR(4, "Illegal TFTP operation");
}
/*
* Read a small file of less than one block
*/
TFTPD_TC_DEFINE(rrq_small,)
{
int fd;
char contents[] = "small";
fd = open("small.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, strlen(contents) + 1);
close(fd);
SEND_RRQ("small.txt", "octet");
recv_data(1, contents, strlen(contents) + 1);
send_ack(1);
}
/*
* Read a file following the example in RFC 7440.
*/
TFTPD_TC_DEFINE(rrq_window_rfc7440,)
{
int fd;
size_t i;
char options[] = OPTION_STR("windowsize", "4");
alignas(uint32_t) char contents[13 * 512 - 4];
uint32_t *u32p;
u32p = (uint32_t *)contents;
for (i = 0; i < sizeof(contents) / sizeof(uint32_t); i++)
u32p[i] = i;
fd = open("rfc7440.txt", O_RDWR | O_CREAT, 0644);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, sizeof(contents));
close(fd);
SEND_RRQ_OPT("rfc7440.txt", "octet", OPTION_STR("windowsize", "4"));
recv_oack(options, sizeof(options) - 1);
send_ack(0);
recv_data(1, &contents[0 * 512], 512);
recv_data(2, &contents[1 * 512], 512);
recv_data(3, &contents[2 * 512], 512);
recv_data(4, &contents[3 * 512], 512);
send_ack(4);
recv_data(5, &contents[4 * 512], 512);
recv_data(6, &contents[5 * 512], 512);
recv_data(7, &contents[6 * 512], 512);
recv_data(8, &contents[7 * 512], 512);
/* ACK 5 as if 6-8 were dropped. */
send_ack(5);
recv_data(6, &contents[5 * 512], 512);
recv_data(7, &contents[6 * 512], 512);
recv_data(8, &contents[7 * 512], 512);
recv_data(9, &contents[8 * 512], 512);
send_ack(9);
recv_data(10, &contents[9 * 512], 512);
recv_data(11, &contents[10 * 512], 512);
recv_data(12, &contents[11 * 512], 512);
recv_data(13, &contents[12 * 512], 508);
/* Drop ACK and after timeout receive 10-13. */
recv_data(10, &contents[9 * 512], 512);
recv_data(11, &contents[10 * 512], 512);
recv_data(12, &contents[11 * 512], 512);
recv_data(13, &contents[12 * 512], 508);
send_ack(13);
}
/*
* Try to transfer a file with an unknown mode.
*/
TFTPD_TC_DEFINE(unknown_modes,)
{
SEND_RRQ("foo.txt", "ascii"); /* Misspelling of "ascii" */
RECV_ERROR(4, "Illegal TFTP operation");
s = setup(&addr, __COUNTER__);
SEND_RRQ("foo.txt", "binary"); /* Obsolete. Use "octet" instead */
RECV_ERROR(4, "Illegal TFTP operation");
s = setup(&addr, __COUNTER__);
SEND_RRQ("foo.txt", "en_US.UTF-8");
RECV_ERROR(4, "Illegal TFTP operation");
s = setup(&addr, __COUNTER__);
SEND_RRQ("foo.txt", "mail"); /* Obsolete in RFC-1350 */
RECV_ERROR(4, "Illegal TFTP operation");
}
/*
* Send an unknown opcode. tftpd should respond with the appropriate error
*/
TFTPD_TC_DEFINE(unknown_opcode,)
{
/* Looks like an RRQ or WRQ request, but with a bad opcode */
SEND_STR("\0\007foo.txt\0octet\0");
RECV_ERROR(4, "Illegal TFTP operation");
}
/*
* Invoke tftpd with "-w" and write to a nonexistent file.
*/
TFTPD_TC_DEFINE(w_flag,, w_flag = 1;)
{
int fd;
ssize_t r;
char contents[] = "small";
char buffer[1024];
size_t contents_len;
contents_len = strlen(contents) + 1;
SEND_WRQ("small.txt", "octet");
recv_ack(0);
send_data(1, contents, contents_len);
recv_ack(1);
fd = open("small.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq(contents, contents_len, buffer, (size_t)r);
}
/*
* Write a medium file, and simulate a dropped ACK packet
*/
TFTPD_TC_DEFINE(wrq_dropped_ack,)
{
int fd;
size_t i;
ssize_t r;
uint32_t contents[192];
char buffer[1024];
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ("medium.txt", "octet");
recv_ack(0);
send_data(1, (const char *)&contents[0], 512);
/*
* Servers "sends" an ACK packet, but network drops it.
* Eventually, server should resend the last ACK
*/
(void) recvfrom(s, buffer, sizeof(buffer), 0, NULL, NULL);
recv_ack(1);
send_data(2, (const char *)&contents[128], 256);
recv_ack(2);
fd = open("medium.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq((const char *)contents, 768, buffer, (size_t)r);
}
/*
* Write a small file, and simulate a dropped DATA packet
*/
TFTPD_TC_DEFINE(wrq_dropped_data,)
{
int fd;
ssize_t r;
char contents[] = "small";
size_t contents_len;
char buffer[1024];
fd = open("small.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
contents_len = strlen(contents) + 1;
SEND_WRQ("small.txt", "octet");
recv_ack(0);
/*
* Client "sends" a DATA packet, but network drops it.
* Eventually, server should resend the last ACK
*/
recv_ack(0);
send_data(1, contents, contents_len);
recv_ack(1);
fd = open("small.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq(contents, contents_len, buffer, (size_t)r);
}
/*
* Write a medium file, and simulate a duplicated DATA packet
*/
TFTPD_TC_DEFINE(wrq_duped_data,)
{
int fd;
size_t i;
ssize_t r;
uint32_t contents[192];
char buffer[1024];
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ("medium.txt", "octet");
recv_ack(0);
send_data(1, (const char *)&contents[0], 512);
send_data(1, (const char *)&contents[0], 512);
recv_ack(1);
recv_ack(1);
send_data(2, (const char *)&contents[128], 256);
recv_ack(2);
fd = open("medium.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq((const char *)contents, 768, buffer, (size_t)r);
}
/*
* Attempt to write a file without write permissions
*/
TFTPD_TC_DEFINE(wrq_eaccess,)
{
int fd;
fd = open("empty.txt", O_CREAT | O_RDONLY, 0440);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ("empty.txt", "octet");
RECV_ERROR(2, "Access violation");
}
/*
* Attempt to write a file without world write permissions, but with world
* read permissions
*/
TFTPD_TC_DEFINE(wrq_eaccess_world_readable,)
{
int fd;
fd = open("empty.txt", O_CREAT | O_RDONLY, 0444);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ("empty.txt", "octet");
RECV_ERROR(2, "Access violation");
}
/*
* Write a medium file of more than one block
*/
TFTPD_TC_DEFINE(wrq_medium,)
{
int fd;
size_t i;
ssize_t r;
uint32_t contents[192];
char buffer[1024];
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ("medium.txt", "octet");
recv_ack(0);
send_data(1, (const char *)&contents[0], 512);
recv_ack(1);
send_data(2, (const char *)&contents[128], 256);
recv_ack(2);
fd = open("medium.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq((const char *)contents, 768, buffer, (size_t)r);
}
/*
* Write a medium file with a window size of 2.
*/
TFTPD_TC_DEFINE(wrq_medium_window,)
{
int fd;
size_t i;
ssize_t r;
uint32_t contents[192];
char buffer[1024];
char options[] = OPTION_STR("windowsize", "2");
for (i = 0; i < nitems(contents); i++)
contents[i] = i;
fd = open("medium.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ_OPT("medium.txt", "octet", OPTION_STR("windowsize", "2"));
recv_oack(options, sizeof(options) - 1);
send_data(1, (const char *)&contents[0], 512);
send_data(2, (const char *)&contents[128], 256);
recv_ack(2);
fd = open("medium.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq((const char *)contents, 768, buffer, (size_t)r);
}
/*
* Write a file in netascii format
*/
TFTPD_TC_DEFINE(wrq_netascii,)
{
int fd;
ssize_t r;
/*
* Weirdly, RFC-764 says that CR must be followed by NUL if a line feed
* is not intended
*/
char contents[] = "foo\r\nbar\r\0baz\r\n";
char expected[] = "foo\nbar\rbaz\n";
size_t contents_len;
char buffer[1024];
fd = open("unix.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
contents_len = sizeof(contents);
SEND_WRQ("unix.txt", "netascii");
recv_ack(0);
send_data(1, contents, contents_len);
recv_ack(1);
fd = open("unix.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq(expected, sizeof(expected), buffer, (size_t)r);
}
/*
* Attempt to write to a nonexistent file. With the default options, this
* isn't allowed.
*/
TFTPD_TC_DEFINE(wrq_nonexistent,)
{
SEND_WRQ("nonexistent.txt", "octet");
RECV_ERROR(1, "File not found");
}
/*
* Write a small file of less than one block
*/
TFTPD_TC_DEFINE(wrq_small,)
{
int fd;
ssize_t r;
char contents[] = "small";
size_t contents_len;
char buffer[1024];
fd = open("small.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
contents_len = strlen(contents) + 1;
SEND_WRQ("small.txt", "octet");
recv_ack(0);
send_data(1, contents, contents_len);
recv_ack(1);
fd = open("small.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq(contents, contents_len, buffer, (size_t)r);
}
/*
* Write an empty file over a non-empty one
*/
TFTPD_TC_DEFINE(wrq_truncate,)
{
int fd;
char contents[] = "small";
struct stat sb;
fd = open("small.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
write_all(fd, contents, strlen(contents) + 1);
close(fd);
SEND_WRQ("small.txt", "octet");
recv_ack(0);
send_data(1, NULL, 0);
recv_ack(1);
ATF_REQUIRE_EQ(0, stat("small.txt", &sb));
ATF_REQUIRE_EQ(0, sb.st_size);
}
/*
* Write a file following the example in RFC 7440.
*/
TFTPD_TC_DEFINE(wrq_window_rfc7440,)
{
int fd;
size_t i;
ssize_t r;
char options[] = OPTION_STR("windowsize", "4");
alignas(uint32_t) char contents[13 * 512 - 4];
char buffer[sizeof(contents)];
uint32_t *u32p;
u32p = (uint32_t *)contents;
for (i = 0; i < sizeof(contents) / sizeof(uint32_t); i++)
u32p[i] = i;
fd = open("rfc7440.txt", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(fd >= 0);
close(fd);
SEND_WRQ_OPT("rfc7440.txt", "octet", OPTION_STR("windowsize", "4"));
recv_oack(options, sizeof(options) - 1);
send_data(1, &contents[0 * 512], 512);
send_data(2, &contents[1 * 512], 512);
send_data(3, &contents[2 * 512], 512);
send_data(4, &contents[3 * 512], 512);
recv_ack(4);
send_data(5, &contents[4 * 512], 512);
/* Drop 6-8. */
recv_ack(5);
send_data(6, &contents[5 * 512], 512);
send_data(7, &contents[6 * 512], 512);
send_data(8, &contents[7 * 512], 512);
send_data(9, &contents[8 * 512], 512);
recv_ack(9);
/* Drop 11. */
send_data(10, &contents[9 * 512], 512);
send_data(12, &contents[11 * 512], 512);
/*
* We can't send 13 here as tftpd has probably already seen 12
* and sent the ACK of 10 if running locally. While it would
* recover by sending another ACK of 10, our state machine
* would be out of sync.
*/
/* Ignore ACK for 10 and resend 10-13. */
recv_ack(10);
send_data(10, &contents[9 * 512], 512);
send_data(11, &contents[10 * 512], 512);
send_data(12, &contents[11 * 512], 512);
send_data(13, &contents[12 * 512], 508);
recv_ack(13);
fd = open("rfc7440.txt", O_RDONLY);
ATF_REQUIRE(fd >= 0);
r = read(fd, buffer, sizeof(buffer));
ATF_REQUIRE(r > 0);
close(fd);
require_bufeq(contents, sizeof(contents), buffer, (size_t)r);
}
/*
* Send less than four bytes
*/
TFTPD_TC_DEFINE(short_packet1, /* no head */, exitcode = 1)
{
SEND_STR("\1");
}
TFTPD_TC_DEFINE(short_packet2, /* no head */, exitcode = 1)
{
SEND_STR("\1\2");
}
TFTPD_TC_DEFINE(short_packet3, /* no head */, exitcode = 1)
{
SEND_STR("\1\2\3");
}
/*
* Main
*/
ATF_TP_ADD_TCS(tp)
{
TFTPD_TC_ADD(tp, abspath);
TFTPD_TC_ADD(tp, dotdot);
TFTPD_TC_ADD(tp, s_flag);
TFTPD_TC_ADD(tp, rrq_dropped_ack);
TFTPD_TC_ADD(tp, rrq_dropped_data);
TFTPD_TC_ADD(tp, rrq_duped_ack);
TFTPD_TC_ADD(tp, rrq_eaccess);
TFTPD_TC_ADD(tp, rrq_empty);
TFTPD_TC_ADD(tp, rrq_medium);
TFTPD_TC_ADD(tp, rrq_medium_window);
TFTPD_TC_ADD(tp, rrq_netascii);
TFTPD_TC_ADD(tp, rrq_nonexistent);
TFTPD_TC_ADD(tp, rrq_path_max);
TFTPD_TC_ADD(tp, rrq_small);
TFTPD_TC_ADD(tp, rrq_window_rfc7440);
TFTPD_TC_ADD(tp, unknown_modes);
TFTPD_TC_ADD(tp, unknown_opcode);
TFTPD_TC_ADD(tp, w_flag);
TFTPD_TC_ADD(tp, wrq_dropped_ack);
TFTPD_TC_ADD(tp, wrq_dropped_data);
TFTPD_TC_ADD(tp, wrq_duped_data);
TFTPD_TC_ADD(tp, wrq_eaccess);
TFTPD_TC_ADD(tp, wrq_eaccess_world_readable);
TFTPD_TC_ADD(tp, wrq_medium);
TFTPD_TC_ADD(tp, wrq_medium_window);
TFTPD_TC_ADD(tp, wrq_netascii);
TFTPD_TC_ADD(tp, wrq_nonexistent);
TFTPD_TC_ADD(tp, wrq_small);
TFTPD_TC_ADD(tp, wrq_truncate);
TFTPD_TC_ADD(tp, wrq_window_rfc7440);
TFTPD_TC_ADD(tp, short_packet1);
TFTPD_TC_ADD(tp, short_packet2);
TFTPD_TC_ADD(tp, short_packet3);
return (atf_no_error());
}
Reference in a new issue View git blame Copy permalink