2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2018 Alan Somers. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/socket.h>
35 #include <netinet/in.h>
46 static const uint16_t BASEPORT = 6969;
47 static const char pidfile[] = "tftpd.pid";
48 static int protocol = PF_UNSPEC;
49 static int s = -1; /* tftp client socket */
50 static struct sockaddr_storage addr; /* Destination address for the client */
51 static bool s_flag = false; /* Pass -s to tftpd */
52 static bool w_flag = false; /* Pass -w to tftpd */
55 static void require_bufeq(const char *expected, ssize_t expected_len,
56 const char *actual, ssize_t len);
59 * Receive a response from tftpd
60 * @param hdr The reply's expected header, as a char array
61 * @param contents The reply's expected contents, as a char array
62 * @param contents_len Length of contents
64 #define RECV(hdr, contents, contents_len) do { \
66 struct sockaddr_storage from; \
67 socklen_t fromlen = sizeof(from); \
68 ssize_t r = recvfrom(s, buffer, sizeof(buffer), 0, \
69 (struct sockaddr*)&from, &fromlen); \
71 require_bufeq((hdr), sizeof(hdr), buffer, \
72 MIN(r, (ssize_t)sizeof(hdr))); \
73 require_bufeq((const char*) (contents), (contents_len), \
74 &buffer[sizeof(hdr)], r - sizeof(hdr)); \
75 if (protocol == PF_INET) { \
76 ((struct sockaddr_in*)&addr)->sin_port = \
77 ((struct sockaddr_in*)&from)->sin_port; \
79 ((struct sockaddr_in6*)&addr)->sin6_port = \
80 ((struct sockaddr_in6*)&from)->sin6_port; \
85 recv_ack(uint16_t blocknum)
87 char hdr[] = {0, 4, blocknum >> 8, blocknum & 0xFF};
92 * Receive a data packet from tftpd
93 * @param blocknum Expected block number to be received
94 * @param contents Pointer to expected contents
95 * @param contents_len Length of contents expected to receive
98 recv_data(uint16_t blocknum, const char* contents, size_t contents_len)
100 char hdr[] = {0, 3, blocknum >> 8, blocknum & 0xFF};
101 RECV(hdr, contents, contents_len);
104 #define RECV_ERROR(code, msg) do { \
105 char hdr[] = {0, 5, code >> 8, code & 0xFF}; \
106 RECV(hdr, msg, sizeof(msg)); \
110 * send a command to tftpd.
111 * @param cmd Command to send, as a char array
114 send_bytes(const void* cmd, ssize_t len)
118 r = sendto(s, cmd, len, 0, (struct sockaddr*)(&addr), addr.ss_len);
119 ATF_REQUIRE_EQ(r, len);
123 send_data(uint16_t blocknum, const char* contents, size_t contents_len)
127 buffer[0] = 0; /* DATA opcode high byte */
128 buffer[1] = 3; /* DATA opcode low byte */
129 buffer[2] = blocknum >> 8;
130 buffer[3] = blocknum & 0xFF;
131 memmove(&buffer[4], contents, contents_len);
132 send_bytes(buffer, 4 + contents_len);
136 * send a command to tftpd.
137 * @param cmd Command to send, as a const string
138 * (terminating NUL will be ignored)
140 #define SEND_STR(cmd) ATF_REQUIRE_EQ( \
141 sendto(s, (cmd), sizeof(cmd) - 1, 0, (struct sockaddr*)(&addr), \
146 * Acknowledge block blocknum
149 send_ack(uint16_t blocknum)
152 0, 4, /* ACK opcode in BE */
157 send_bytes(packet, sizeof(packet));
162 * send a read request to tftpd.
163 * @param filename filename as a string, absolute or relative
164 * @param mode either "octet" or "netascii"
166 #define SEND_RRQ(filename, mode) SEND_STR("\0\001" filename "\0" mode "\0")
169 * send a write request to tftpd.
170 * @param filename filename as a string, absolute or relative
171 * @param mode either "octet" or "netascii"
173 #define SEND_WRQ(filename, mode) SEND_STR("\0\002" filename "\0" mode "\0")
175 /* Define a test case, for both IPv4 and IPv6 */
176 #define TFTPD_TC_DEFINE(name, head, ...) \
178 name ## _body(void); \
179 ATF_TC_WITH_CLEANUP(name ## _v4); \
180 ATF_TC_HEAD(name ## _v4, tc) \
184 ATF_TC_BODY(name ## _v4, tc) \
187 protocol = AF_INET; \
188 s = setup(&addr, __COUNTER__); \
192 ATF_TC_CLEANUP(name ## _v4, tc) \
196 ATF_TC_WITH_CLEANUP(name ## _v6); \
197 ATF_TC_HEAD(name ## _v6, tc) \
201 ATF_TC_BODY(name ## _v6, tc) \
204 protocol = AF_INET6; \
205 s = setup(&addr, __COUNTER__); \
209 ATF_TC_CLEANUP(name ## _v6, tc) \
216 /* Add the IPv4 and IPv6 versions of a test case */
217 #define TFTPD_TC_ADD(tp, name ) \
219 ATF_TP_ADD_TC(tp, name ## _v4); \
220 ATF_TP_ADD_TC(tp, name ## _v6); \
223 /* Standard cleanup used by all testcases */
230 f = fopen(pidfile, "r");
233 if (fscanf(f, "%d", &pid) == 1) {
235 waitpid(pid, NULL, 0);
241 /* Assert that two binary buffers are identical */
243 require_bufeq(const char *expected, ssize_t expected_len, const char *actual,
248 ATF_REQUIRE_EQ_MSG(expected_len, len,
249 "Expected %zd bytes but got %zd", expected_len, len);
250 for (i = 0; i < len; i++) {
251 ATF_REQUIRE_EQ_MSG(actual[i], expected[i],
252 "Expected %#hhx at position %zd; got %hhx instead",
253 expected[i], i, actual[i]);
258 * Start tftpd and return its communicating socket
259 * @param to Will be filled in for use with sendto
260 * @param idx Unique identifier of the test case
261 * @return Socket ready to use
264 setup(struct sockaddr_storage *to, uint16_t idx)
266 int client_s, server_s, pid, argv_idx;
267 char execname[] = "/usr/libexec/tftpd";
268 char s_flag_str[] = "-s";
269 char w_flag_str[] = "-w";
270 char pwd[MAXPATHLEN];
272 struct sockaddr_in addr4;
273 struct sockaddr_in6 addr6;
274 struct sockaddr *server_addr;
276 uint16_t port = BASEPORT + idx;
279 if (protocol == PF_INET) {
283 addr4.sin_family = PF_INET;
284 addr4.sin_port = htons(port);
285 server_addr = (struct sockaddr*)&addr4;
289 addr6.sin6_len = len;
290 addr6.sin6_family = PF_INET6;
291 addr6.sin6_port = htons(port);
292 server_addr = (struct sockaddr*)&addr6;
295 ATF_REQUIRE_EQ(getcwd(pwd, sizeof(pwd)), pwd);
297 /* Must bind(2) pre-fork so it happens before the client's send(2) */
298 ATF_REQUIRE((server_s = socket(protocol, SOCK_DGRAM, 0)) > 0);
299 ATF_REQUIRE_EQ_MSG(bind(server_s, server_addr, len), 0,
300 "bind failed with error %s", strerror(errno));
305 atf_tc_fail("fork failed");
309 pfh = pidfile_open(pidfile, 0644, NULL);
310 ATF_REQUIRE_MSG(pfh != NULL,
311 "pidfile_open: %s", strerror(errno));
312 ATF_REQUIRE_EQ(pidfile_write(pfh), 0);
313 ATF_REQUIRE_EQ(pidfile_close(pfh), 0);
315 bzero(argv, sizeof(argv));
319 argv[argv_idx++] = w_flag_str;
321 argv[argv_idx++] = s_flag_str;
322 argv[argv_idx++] = pwd;
323 ATF_REQUIRE_EQ(dup2(server_s, STDOUT_FILENO), STDOUT_FILENO);
324 ATF_REQUIRE_EQ(dup2(server_s, STDIN_FILENO), STDIN_FILENO);
325 ATF_REQUIRE_EQ(dup2(server_s, STDERR_FILENO), STDERR_FILENO);
326 execv(execname, argv);
327 atf_tc_fail("exec failed");
331 bzero(to, sizeof(*to));
332 if (protocol == PF_INET) {
333 struct sockaddr_in *to4 = (struct sockaddr_in*)to;
334 to4->sin_len = sizeof(*to4);
335 to4->sin_family = PF_INET;
336 to4->sin_port = htons(port);
337 to4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
339 struct in6_addr loopback = IN6ADDR_LOOPBACK_INIT;
340 struct sockaddr_in6 *to6 = (struct sockaddr_in6*)to;
341 to6->sin6_len = sizeof(*to6);
342 to6->sin6_family = PF_INET6;
343 to6->sin6_port = htons(port);
344 to6->sin6_addr = loopback;
348 ATF_REQUIRE((client_s = socket(protocol, SOCK_DGRAM, 0)) > 0);
354 /* Like write(2), but never returns less than the requested length */
356 write_all(int fd, const void *buf, size_t nbytes)
361 r = write(fd, buf, nbytes);
364 buf = (const char*)buf + r;
374 * Read a file, specified by absolute pathname.
376 TFTPD_TC_DEFINE(abspath,)
381 char suffix[] = {'\0', 'o', 'c', 't', 'e', 't', '\0'};
383 command[0] = 0; /* RRQ high byte */
384 command[1] = 1; /* RRQ low byte */
385 ATF_REQUIRE(getcwd(&command[2], sizeof(command) - 2) != NULL);
386 pathlen = strlcat(&command[2], "/abspath.txt", sizeof(command) - 2);
387 ATF_REQUIRE(pathlen + sizeof(suffix) < sizeof(command) - 2);
388 memmove(&command[2 + pathlen], suffix, sizeof(suffix));
390 fd = open("abspath.txt", O_CREAT | O_RDONLY, 0644);
391 ATF_REQUIRE(fd >= 0);
394 send_bytes(command, 2 + pathlen + sizeof(suffix));
395 recv_data(1, NULL, 0);
400 * Attempt to read a file outside of the allowed directory(ies)
402 TFTPD_TC_DEFINE(dotdot,)
404 ATF_REQUIRE_EQ(mkdir("subdir", 0777), 0);
405 SEND_RRQ("../disallowed.txt", "octet");
406 RECV_ERROR(2, "Access violation");
407 s = setup(&addr, __COUNTER__); \
408 SEND_RRQ("subdir/../../disallowed.txt", "octet");
409 RECV_ERROR(2, "Access violation");
410 s = setup(&addr, __COUNTER__); \
411 SEND_RRQ("/etc/passwd", "octet");
412 RECV_ERROR(2, "Access violation");
416 * With "-s", tftpd should chroot to the specified directory
418 TFTPD_TC_DEFINE(s_flag, atf_tc_set_md_var(tc, "require.user", "root");,
422 char contents[] = "small";
424 fd = open("small.txt", O_RDWR | O_CREAT, 0644);
425 ATF_REQUIRE(fd >= 0);
426 write_all(fd, contents, strlen(contents) + 1);
429 SEND_RRQ("/small.txt", "octet");
430 recv_data(1, contents, strlen(contents) + 1);
435 * Read a file, and simulate a dropped ACK packet
437 TFTPD_TC_DEFINE(rrq_dropped_ack,)
440 char contents[] = "small";
442 fd = open("small.txt", O_RDWR | O_CREAT, 0644);
443 ATF_REQUIRE(fd >= 0);
444 write_all(fd, contents, strlen(contents) + 1);
447 SEND_RRQ("small.txt", "octet");
448 recv_data(1, contents, strlen(contents) + 1);
450 * client "sends" the ack, but network drops it
451 * Eventually, tftpd should resend the data packet
453 recv_data(1, contents, strlen(contents) + 1);
458 * Read a file, and simulate a dropped DATA packet
460 TFTPD_TC_DEFINE(rrq_dropped_data,)
464 uint32_t contents[192];
467 for (i = 0; i < nitems(contents); i++)
470 fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
471 ATF_REQUIRE(fd >= 0);
472 write_all(fd, contents, sizeof(contents));
475 SEND_RRQ("medium.txt", "octet");
476 recv_data(1, (const char*)&contents[0], 512);
478 (void) recvfrom(s, buffer, sizeof(buffer), 0, NULL, NULL);
480 * server "sends" the data, but network drops it
481 * Eventually, client should resend the last ACK
484 recv_data(2, (const char*)&contents[128], 256);
489 * Read a medium file, and simulate a duplicated ACK packet
491 TFTPD_TC_DEFINE(rrq_duped_ack,)
495 uint32_t contents[192];
497 for (i = 0; i < nitems(contents); i++)
500 fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
501 ATF_REQUIRE(fd >= 0);
502 write_all(fd, contents, sizeof(contents));
505 SEND_RRQ("medium.txt", "octet");
506 recv_data(1, (const char*)&contents[0], 512);
508 send_ack(1); /* Dupe an ACK packet */
509 recv_data(2, (const char*)&contents[128], 256);
510 recv_data(2, (const char*)&contents[128], 256);
516 * Attempt to read a file without read permissions
518 TFTPD_TC_DEFINE(rrq_eaccess,)
522 fd = open("empty.txt", O_CREAT | O_RDONLY, 0000);
523 ATF_REQUIRE(fd >= 0);
526 SEND_RRQ("empty.txt", "octet");
527 RECV_ERROR(2, "Access violation");
533 TFTPD_TC_DEFINE(rrq_empty,)
537 fd = open("empty.txt", O_CREAT | O_RDONLY, 0644);
538 ATF_REQUIRE(fd >= 0);
541 SEND_RRQ("empty.txt", "octet");
542 recv_data(1, NULL, 0);
547 * Read a medium file of more than one block
549 TFTPD_TC_DEFINE(rrq_medium,)
553 uint32_t contents[192];
555 for (i = 0; i < nitems(contents); i++)
558 fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
559 ATF_REQUIRE(fd >= 0);
560 write_all(fd, contents, sizeof(contents));
563 SEND_RRQ("medium.txt", "octet");
564 recv_data(1, (const char*)&contents[0], 512);
566 recv_data(2, (const char*)&contents[128], 256);
571 * Read a file in netascii format
573 TFTPD_TC_DEFINE(rrq_netascii,)
576 char contents[] = "foo\nbar\rbaz\n";
578 * Weirdly, RFC-764 says that CR must be followed by NUL if a line feed
581 char expected[] = "foo\r\nbar\r\0baz\r\n";
583 fd = open("unix.txt", O_RDWR | O_CREAT, 0644);
584 ATF_REQUIRE(fd >= 0);
585 write_all(fd, contents, strlen(contents) + 1);
588 SEND_RRQ("unix.txt", "netascii");
589 recv_data(1, expected, sizeof(expected));
594 * Read a file that doesn't exist
596 TFTPD_TC_DEFINE(rrq_nonexistent,)
598 SEND_RRQ("nonexistent.txt", "octet");
599 RECV_ERROR(1, "File not found");
603 * Attempt to read a file whose name exceeds PATH_MAX
605 TFTPD_TC_DEFINE(rrq_path_max,)
607 #define AReallyBigFileName \
608 "AReallyBigFileNameXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
609 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
610 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
611 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
612 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
613 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
614 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
615 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
616 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
617 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
618 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
619 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
620 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
621 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
622 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
623 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\
625 ATF_REQUIRE_MSG(strlen(AReallyBigFileName) > PATH_MAX,
626 "Somebody increased PATH_MAX. Update the test");
627 SEND_RRQ(AReallyBigFileName, "octet");
628 RECV_ERROR(4, "Illegal TFTP operation");
632 * Read a small file of less than one block
634 TFTPD_TC_DEFINE(rrq_small,)
637 char contents[] = "small";
639 fd = open("small.txt", O_RDWR | O_CREAT, 0644);
640 ATF_REQUIRE(fd >= 0);
641 write_all(fd, contents, strlen(contents) + 1);
644 SEND_RRQ("small.txt", "octet");
645 recv_data(1, contents, strlen(contents) + 1);
650 * Try to transfer a file with an unknown mode.
652 TFTPD_TC_DEFINE(unknown_modes,)
654 SEND_RRQ("foo.txt", "ascii"); /* Misspelling of "ascii" */
655 RECV_ERROR(4, "Illegal TFTP operation");
656 s = setup(&addr, __COUNTER__); \
657 SEND_RRQ("foo.txt", "binary"); /* Obsolete. Use "octet" instead */
658 RECV_ERROR(4, "Illegal TFTP operation");
659 s = setup(&addr, __COUNTER__); \
660 SEND_RRQ("foo.txt", "en_US.UTF-8");
661 RECV_ERROR(4, "Illegal TFTP operation");
662 s = setup(&addr, __COUNTER__); \
663 SEND_RRQ("foo.txt", "mail"); /* Obsolete in RFC-1350 */
664 RECV_ERROR(4, "Illegal TFTP operation");
668 * Send an unknown opcode. tftpd should respond with the appropriate error
670 TFTPD_TC_DEFINE(unknown_opcode,)
672 /* Looks like an RRQ or WRQ request, but with a bad opcode */
673 SEND_STR("\0\007foo.txt\0octet\0");
674 atf_tc_expect_timeout("PR 226005 tftpd ignores bad opcodes but doesn't reject them");
675 RECV_ERROR(4, "Illegal TFTP operation");
679 * Invoke tftpd with "-w" and write to a nonexistent file.
681 TFTPD_TC_DEFINE(w_flag,, w_flag = 1;)
685 char contents[] = "small";
689 contents_len = strlen(contents) + 1;
690 SEND_WRQ("small.txt", "octet");
692 send_data(1, contents, contents_len);
695 fd = open("small.txt", O_RDONLY);
696 ATF_REQUIRE(fd >= 0);
697 r = read(fd, buffer, sizeof(buffer));
699 require_bufeq(contents, contents_len, buffer, r);
703 * Write a medium file, and simulate a dropped ACK packet
705 TFTPD_TC_DEFINE(wrq_dropped_ack,)
710 uint32_t contents[192];
713 for (i = 0; i < nitems(contents); i++)
716 fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
717 ATF_REQUIRE(fd >= 0);
720 SEND_WRQ("medium.txt", "octet");
722 send_data(1, (const char*)&contents[0], 512);
724 * Servers "sends" an ACK packet, but network drops it.
725 * Eventually, server should resend the last ACK
727 (void) recvfrom(s, buffer, sizeof(buffer), 0, NULL, NULL);
729 send_data(2, (const char*)&contents[128], 256);
732 fd = open("medium.txt", O_RDONLY);
733 ATF_REQUIRE(fd >= 0);
734 r = read(fd, buffer, sizeof(buffer));
736 require_bufeq((const char*)contents, 768, buffer, r);
740 * Write a small file, and simulate a dropped DATA packet
742 TFTPD_TC_DEFINE(wrq_dropped_data,)
746 char contents[] = "small";
750 fd = open("small.txt", O_RDWR | O_CREAT, 0644);
751 ATF_REQUIRE(fd >= 0);
753 contents_len = strlen(contents) + 1;
755 SEND_WRQ("small.txt", "octet");
758 * Client "sends" a DATA packet, but network drops it.
759 * Eventually, server should resend the last ACK
762 send_data(1, contents, contents_len);
765 fd = open("small.txt", O_RDONLY);
766 ATF_REQUIRE(fd >= 0);
767 r = read(fd, buffer, sizeof(buffer));
769 require_bufeq(contents, contents_len, buffer, r);
773 * Write a medium file, and simulate a duplicated DATA packet
775 TFTPD_TC_DEFINE(wrq_duped_data,)
780 uint32_t contents[192];
783 for (i = 0; i < nitems(contents); i++)
786 fd = open("medium.txt", O_RDWR | O_CREAT, 0644);
787 ATF_REQUIRE(fd >= 0);
790 SEND_WRQ("medium.txt", "octet");
792 send_data(1, (const char*)&contents[0], 512);
793 send_data(1, (const char*)&contents[0], 512);
796 send_data(2, (const char*)&contents[128], 256);
799 fd = open("medium.txt", O_RDONLY);
800 ATF_REQUIRE(fd >= 0);
801 r = read(fd, buffer, sizeof(buffer));
803 require_bufeq((const char*)contents, 768, buffer, r);
807 * Attempt to write a file without write permissions
809 TFTPD_TC_DEFINE(wrq_eaccess,)
813 fd = open("empty.txt", O_CREAT | O_RDONLY, 0440);
814 ATF_REQUIRE(fd >= 0);
817 SEND_WRQ("empty.txt", "octet");
818 atf_tc_expect_fail("PR 225996 tftpd doesn't abort on a WRQ access "
820 RECV_ERROR(2, "Access violation");
824 * Attempt to write a file without world write permissions, but with world
827 TFTPD_TC_DEFINE(wrq_eaccess_world_readable,)
831 fd = open("empty.txt", O_CREAT | O_RDONLY, 0444);
832 ATF_REQUIRE(fd >= 0);
835 SEND_WRQ("empty.txt", "octet");
836 atf_tc_expect_fail("PR 226004 with relative pathnames, tftpd doesn't validate world writability");
837 RECV_ERROR(2, "Access violation");
842 * Write a medium file of more than one block
844 TFTPD_TC_DEFINE(wrq_medium,)
849 uint32_t contents[192];
852 for (i = 0; i < nitems(contents); i++)
855 fd = open("medium.txt", O_RDWR | O_CREAT, 0666);
856 ATF_REQUIRE(fd >= 0);
859 SEND_WRQ("medium.txt", "octet");
861 send_data(1, (const char*)&contents[0], 512);
863 send_data(2, (const char*)&contents[128], 256);
866 fd = open("medium.txt", O_RDONLY);
867 ATF_REQUIRE(fd >= 0);
868 r = read(fd, buffer, sizeof(buffer));
870 require_bufeq((const char*)contents, 768, buffer, r);
874 * Write a file in netascii format
876 TFTPD_TC_DEFINE(wrq_netascii,)
881 * Weirdly, RFC-764 says that CR must be followed by NUL if a line feed
884 char contents[] = "foo\r\nbar\r\0baz\r\n";
885 char expected[] = "foo\nbar\rbaz\n";
889 fd = open("unix.txt", O_RDWR | O_CREAT, 0666);
890 ATF_REQUIRE(fd >= 0);
892 contents_len = sizeof(contents);
894 SEND_WRQ("unix.txt", "netascii");
896 send_data(1, contents, contents_len);
899 fd = open("unix.txt", O_RDONLY);
900 ATF_REQUIRE(fd >= 0);
901 r = read(fd, buffer, sizeof(buffer));
903 require_bufeq(expected, sizeof(expected), buffer, r);
907 * Attempt to write to a nonexistent file. With the default options, this
910 TFTPD_TC_DEFINE(wrq_nonexistent,)
912 SEND_WRQ("nonexistent.txt", "octet");
913 atf_tc_expect_fail("PR 225996 tftpd doesn't abort on a WRQ access "
915 RECV_ERROR(1, "File not found");
919 * Write a small file of less than one block
921 TFTPD_TC_DEFINE(wrq_small,)
925 char contents[] = "small";
929 fd = open("small.txt", O_RDWR | O_CREAT, 0666);
930 ATF_REQUIRE(fd >= 0);
932 contents_len = strlen(contents) + 1;
934 SEND_WRQ("small.txt", "octet");
936 send_data(1, contents, contents_len);
939 fd = open("small.txt", O_RDONLY);
940 ATF_REQUIRE(fd >= 0);
941 r = read(fd, buffer, sizeof(buffer));
943 require_bufeq(contents, contents_len, buffer, r);
947 * Write an empty file over a non-empty one
949 TFTPD_TC_DEFINE(wrq_truncate,)
952 char contents[] = "small";
955 fd = open("small.txt", O_RDWR | O_CREAT, 0666);
956 ATF_REQUIRE(fd >= 0);
957 write_all(fd, contents, strlen(contents) + 1);
960 SEND_WRQ("small.txt", "octet");
962 send_data(1, NULL, 0);
965 ATF_REQUIRE_EQ(stat("small.txt", &sb), 0);
966 ATF_REQUIRE_EQ(sb.st_size, 0);
976 TFTPD_TC_ADD(tp, abspath);
977 TFTPD_TC_ADD(tp, dotdot);
978 TFTPD_TC_ADD(tp, s_flag);
979 TFTPD_TC_ADD(tp, rrq_dropped_ack);
980 TFTPD_TC_ADD(tp, rrq_dropped_data);
981 TFTPD_TC_ADD(tp, rrq_duped_ack);
982 TFTPD_TC_ADD(tp, rrq_eaccess);
983 TFTPD_TC_ADD(tp, rrq_empty);
984 TFTPD_TC_ADD(tp, rrq_medium);
985 TFTPD_TC_ADD(tp, rrq_netascii);
986 TFTPD_TC_ADD(tp, rrq_nonexistent);
987 TFTPD_TC_ADD(tp, rrq_path_max);
988 TFTPD_TC_ADD(tp, rrq_small);
989 TFTPD_TC_ADD(tp, unknown_modes);
990 TFTPD_TC_ADD(tp, unknown_opcode);
991 TFTPD_TC_ADD(tp, w_flag);
992 TFTPD_TC_ADD(tp, wrq_dropped_ack);
993 TFTPD_TC_ADD(tp, wrq_dropped_data);
994 TFTPD_TC_ADD(tp, wrq_duped_data);
995 TFTPD_TC_ADD(tp, wrq_eaccess);
996 TFTPD_TC_ADD(tp, wrq_eaccess_world_readable);
997 TFTPD_TC_ADD(tp, wrq_medium);
998 TFTPD_TC_ADD(tp, wrq_netascii);
999 TFTPD_TC_ADD(tp, wrq_nonexistent);
1000 TFTPD_TC_ADD(tp, wrq_small);
1001 TFTPD_TC_ADD(tp, wrq_truncate);
1003 return (atf_no_error());