Page MenuHomeFreeBSD
Files F163947523

D14310.id39458.diff
No OneTemporary
Actions

D14310.id39458.diff
View Options

Index: etc/mtree/BSD.tests.dist
===================================================================
--- etc/mtree/BSD.tests.dist
+++ etc/mtree/BSD.tests.dist
@@ -382,6 +382,8 @@
..
rtld-elf
..
+ tftpd
+ ..
..
sbin
dhclient
Index: libexec/tftpd/Makefile
===================================================================
--- libexec/tftpd/Makefile
+++ libexec/tftpd/Makefile
@@ -14,4 +14,7 @@
LIBADD= wrap
.endif
+HAS_TESTS=
+SUBDIR.${MK_TESTS}+= tests
+
.include <bsd.prog.mk>
Index: libexec/tftpd/tests/Makefile
===================================================================
--- /dev/null
+++ libexec/tftpd/tests/Makefile
@@ -0,0 +1,14 @@
+# $FreeBSD$
+
+.include <bsd.own.mk>
+
+# Skip on GCC 4.2, because it lacks __COUNTER__
+.if ${COMPILER_TYPE} != "gcc" || ${COMPILER_VERSION} >= 40300
+ATF_TESTS_C= functional
+TEST_METADATA.functional+= timeout=15
+.endif
+
+LIBADD= util
+WARNS?= 6
+
+.include <bsd.test.mk>
Index: libexec/tftpd/tests/functional.c
===================================================================
--- /dev/null
+++ libexec/tftpd/tests/functional.c
@@ -0,0 +1,534 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2018 Alan Somers. All rights reserved.
+ * 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/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <netinet/in.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.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 const int protocols[] = {PF_INET, PF_INET6};
+static int protocol = PF_UNSPEC;
+static int s = -1; /* tftp client socket */
+static struct sockaddr_storage addr; /* Destination address for the client */
+
+/* Helper functions*/
+static void require_bufeq(const char *expected, ssize_t expected_len,
+ const char *actual, ssize_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(r, (ssize_t)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);
+}
+
+/*
+ * 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, ssize_t len)
+{
+ ssize_t r;
+
+ r = sendto(s, cmd, len, 0, (struct sockaddr*)(&addr), addr.ss_len);
+ ATF_REQUIRE_EQ(r, len);
+}
+
+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( \
+ sendto(s, (cmd), sizeof(cmd) - 1, 0, (struct sockaddr*)(&addr), \
+ addr.ss_len), \
+ sizeof(cmd) - 1)
+
+/*
+ * 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));
+
+}
+
+/*
+ * 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 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")
+
+/* Define a test case, for both IPv4 and IPv6 */
+#define TFTPD_TC_DEFINE(name) \
+static void \
+name ## _body(void); \
+ATF_TC_WITH_CLEANUP(name ## _v4); \
+ATF_TC_HEAD(name ## _v4, tc) \
+{ \
+} \
+ATF_TC_BODY(name ## _v4, tc) \
+{ \
+ protocol = AF_INET; \
+ s = setup(&addr, __COUNTER__); \
+ name ## _body(); \
+ close(s); \
+} \
+ATF_TC_CLEANUP(name ## _v4, tc) \
+{ \
+ cleanup(); \
+} \
+ATF_TC_WITH_CLEANUP(name ## _v6); \
+ATF_TC_HEAD(name ## _v6, tc) \
+{ \
+} \
+ATF_TC_BODY(name ## _v6, tc) \
+{ \
+ protocol = AF_INET6; \
+ s = setup(&addr, __COUNTER__); \
+ name ## _body(); \
+ close(s); \
+} \
+ATF_TC_CLEANUP(name ## _v6, tc) \
+{ \
+ cleanup(); \
+} \
+static void \
+name ## _body()
+
+/* 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)
+
+/* Standard cleanup used by all testcases */
+static void
+cleanup(void)
+{
+ int fd = -1;
+ char buffer[80] = {0};
+ pid_t pid;
+
+ fd = open(pidfile, O_RDONLY);
+ if (fd < 0)
+ return;
+ if (read(fd, buffer, sizeof(buffer)) > 0) {
+ sscanf(buffer, "%d", &pid);
+ kill(pid, SIGTERM);
+ waitpid(pid, NULL, 0);
+ }
+ close(fd);
+}
+
+/* Assert that two binary buffers are identical */
+static void
+require_bufeq(const char *expected, ssize_t expected_len, const char *actual,
+ ssize_t len)
+{
+ ssize_t i;
+
+ ATF_REQUIRE_EQ_MSG(expected_len, len,
+ "Expected %lu bytes but got %lu", expected_len, len);
+ for (i = 0; i < len; i++) {
+ ATF_REQUIRE_EQ_MSG(actual[i], expected[i],
+ "Expected %#hhx at position %lu; 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;
+ char execname[] = "/usr/libexec/tftpd";
+ char logging[] = "-l";
+ char pwd[MAXPATHLEN];
+ char *argv[4];
+ struct sockaddr_in addr4;
+ struct sockaddr_in6 addr6;
+ struct sockaddr *server_addr;
+ struct pidfh *pfh;
+ uint16_t port = BASEPORT + idx;
+ socklen_t len;
+
+ 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(getcwd(pwd, sizeof(pwd)), pwd);
+
+ /* Must bind(2) pre-fork so it happens before the client's send(2) */
+ ATF_REQUIRE((server_s = socket(protocol, SOCK_DGRAM, 0)) > 0);
+ ATF_REQUIRE_EQ_MSG(bind(server_s, server_addr, len), 0,
+ "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(pfh != NULL);
+ ATF_REQUIRE_EQ(pidfile_write(pfh), 0);
+ ATF_REQUIRE_EQ(pidfile_close(pfh), 0);
+
+ argv[0] = execname;
+ argv[1] = logging;
+ argv[2] = pwd;
+ argv[3] = NULL;
+ ATF_REQUIRE_EQ(dup2(server_s, STDOUT_FILENO), STDOUT_FILENO);
+ ATF_REQUIRE_EQ(dup2(server_s, STDIN_FILENO), STDIN_FILENO);
+ ATF_REQUIRE_EQ(dup2(server_s, STDERR_FILENO), STDERR_FILENO);
+ execv(execname, argv);
+ atf_tc_fail("exec failed");
+ break;
+ default:
+ /* In parent */
+ 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;
+ }
+
+ close(server_s);
+ ATF_REQUIRE((client_s = socket(protocol, SOCK_DGRAM, 0)) > 0);
+ break;
+ }
+ 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 -= r;
+ buf = (const char*)buf + r;
+ }
+}
+
+
+/*
+ * Test Cases
+ */
+
+/*
+ * 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 file that doesn't exist
+ */
+TFTPD_TC_DEFINE(rrq_nonexistent)
+{
+ SEND_RRQ("nonexistent.txt", "octet");
+ RECV_ERROR(1, "File not found");
+}
+
+/*
+ * 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);
+}
+
+/*
+ * Write a medium file of more than one block
+ */
+TFTPD_TC_DEFINE(wrq_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);
+ 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);
+}
+
+/*
+ * 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");
+ atf_tc_expect_fail("PR 225996 tftpd doesn't abort on a WRQ access "
+ "violation");
+ 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, 0644);
+ 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);
+
+ atf_tc_expect_fail("PR 157700 tftpd expects more data after EOF");
+ fd = open("small.txt", O_RDONLY);
+ r = read(fd, buffer, sizeof(buffer));
+ close(fd);
+ require_bufeq(contents, contents_len, buffer, 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, 0644);
+ 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(stat("small.txt", &sb), 0);
+ ATF_REQUIRE_EQ(sb.st_size, 0);
+}
+
+
+/*
+ * Main
+ */
+
+ATF_TP_ADD_TCS(tp)
+{
+ TFTPD_TC_ADD(tp, rrq_empty);
+ TFTPD_TC_ADD(tp, rrq_small);
+ TFTPD_TC_ADD(tp, rrq_medium);
+ TFTPD_TC_ADD(tp, rrq_nonexistent);
+ TFTPD_TC_ADD(tp, wrq_medium);
+ TFTPD_TC_ADD(tp, wrq_nonexistent);
+ TFTPD_TC_ADD(tp, wrq_small);
+ TFTPD_TC_ADD(tp, wrq_truncate);
+
+ return (atf_no_error());
+}

File Metadata

Mime Type
text/plain
Expires
Tue, Jul 28, 9:41 AM (15 h, 49 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
35645375
Default Alt Text
D14310.id39458.diff (14 KB)

Event Timeline