aboutsummaryrefslogtreecommitdiff
path: root/libexec/tftpd/tests
diff options
context:
space:
mode:
Diffstat (limited to 'libexec/tftpd/tests')
-rw-r--r--libexec/tftpd/tests/Makefile8
-rw-r--r--libexec/tftpd/tests/functional.c1283
2 files changed, 1291 insertions, 0 deletions
diff --git a/libexec/tftpd/tests/Makefile b/libexec/tftpd/tests/Makefile
new file mode 100644
index 000000000000..d1faca03331e
--- /dev/null
+++ b/libexec/tftpd/tests/Makefile
@@ -0,0 +1,8 @@
+.include <bsd.own.mk>
+
+ATF_TESTS_C= functional
+TEST_METADATA.functional+= timeout=15
+
+LIBADD= util
+
+.include <bsd.test.mk>
diff --git a/libexec/tftpd/tests/functional.c b/libexec/tftpd/tests/functional.c
new file mode 100644
index 000000000000..791aa9190a2f
--- /dev/null
+++ b/libexec/tftpd/tests/functional.c
@@ -0,0 +1,1283 @@
+/*-
+ * 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());
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-08 22:53:19 +0000