TestIo.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2021, Andrew Kaster <akaster@serenityos.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #include <AK/Assertions.h>
  8. #include <AK/Types.h>
  9. #include <LibCore/File.h>
  10. #include <LibTest/TestCase.h>
  11. #include <fcntl.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <sys/mman.h>
  15. #include <sys/stat.h>
  16. #include <sys/uio.h>
  17. #include <unistd.h>
  18. #define EXPECT_ERROR_2(err, syscall, arg1, arg2) \
  19. do { \
  20. rc = syscall(arg1, arg2); \
  21. EXPECT(rc < 0); \
  22. EXPECT_EQ(errno, err); \
  23. if (rc >= 0 || errno != err) { \
  24. warnln(__FILE__ ":{}: Expected " #err ": " #syscall "({}, {}), got rc={}, errno={}", __LINE__, arg1, arg2, rc, errno); \
  25. } \
  26. } while (0)
  27. #define EXPECT_ERROR_3(err, syscall, arg1, arg2, arg3) \
  28. do { \
  29. rc = syscall(arg1, arg2, arg3); \
  30. EXPECT(rc < 0); \
  31. EXPECT_EQ(errno, err); \
  32. if (rc >= 0 || errno != err) { \
  33. warnln(__FILE__ ":{}: Expected " #err ": " #syscall "({}, {}, {}), got rc={}, errno={}", __LINE__, arg1, arg2, arg3, rc, errno); \
  34. } \
  35. } while (0)
  36. TEST_CASE(read_from_directory)
  37. {
  38. char buffer[BUFSIZ];
  39. int fd = open("/", O_DIRECTORY | O_RDONLY);
  40. VERIFY(fd >= 0);
  41. int rc;
  42. EXPECT_ERROR_3(EISDIR, read, fd, buffer, sizeof(buffer));
  43. rc = close(fd);
  44. VERIFY(rc == 0);
  45. }
  46. TEST_CASE(write_to_directory)
  47. {
  48. char str[] = "oh frick";
  49. int fd = open("/", O_DIRECTORY | O_RDONLY);
  50. if (fd < 0)
  51. perror("open");
  52. VERIFY(fd >= 0);
  53. int rc;
  54. EXPECT_ERROR_3(EBADF, write, fd, str, sizeof(str));
  55. rc = close(fd);
  56. VERIFY(rc == 0);
  57. }
  58. TEST_CASE(read_from_writeonly)
  59. {
  60. char buffer[BUFSIZ];
  61. int fd = open("/tmp/xxxx123", O_CREAT | O_WRONLY);
  62. VERIFY(fd >= 0);
  63. int rc;
  64. EXPECT_ERROR_3(EBADF, read, fd, buffer, sizeof(buffer));
  65. rc = close(fd);
  66. VERIFY(rc == 0);
  67. rc = unlink("/tmp/xxxx123");
  68. VERIFY(rc == 0);
  69. }
  70. TEST_CASE(write_to_readonly)
  71. {
  72. char str[] = "hello";
  73. int fd = open("/tmp/abcd123", O_CREAT | O_RDONLY);
  74. VERIFY(fd >= 0);
  75. int rc;
  76. EXPECT_ERROR_3(EBADF, write, fd, str, sizeof(str));
  77. rc = close(fd);
  78. VERIFY(rc == 0);
  79. rc = unlink("/tmp/abcd123");
  80. VERIFY(rc == 0);
  81. }
  82. TEST_CASE(read_past_eof)
  83. {
  84. char buffer[BUFSIZ];
  85. int fd = open("/home/anon/README.md", O_RDONLY);
  86. if (fd < 0)
  87. perror("open");
  88. VERIFY(fd >= 0);
  89. int rc;
  90. rc = lseek(fd, 99999, SEEK_SET);
  91. if (rc < 0)
  92. perror("lseek");
  93. rc = read(fd, buffer, sizeof(buffer));
  94. if (rc < 0)
  95. perror("read");
  96. if (rc > 0)
  97. warnln("read {} bytes past EOF", rc);
  98. rc = close(fd);
  99. VERIFY(rc == 0);
  100. }
  101. TEST_CASE(ftruncate_readonly)
  102. {
  103. int fd = open("/tmp/trunctest", O_RDONLY | O_CREAT, 0666);
  104. VERIFY(fd >= 0);
  105. int rc;
  106. EXPECT_ERROR_2(EBADF, ftruncate, fd, 0);
  107. rc = close(fd);
  108. VERIFY(rc == 0);
  109. rc = unlink("/tmp/trunctest");
  110. VERIFY(rc == 0);
  111. }
  112. TEST_CASE(ftruncate_negative)
  113. {
  114. int fd = open("/tmp/trunctest", O_RDWR | O_CREAT, 0666);
  115. VERIFY(fd >= 0);
  116. int rc;
  117. EXPECT_ERROR_2(EINVAL, ftruncate, fd, -1);
  118. rc = close(fd);
  119. VERIFY(rc == 0);
  120. rc = unlink("/tmp/trunctest");
  121. VERIFY(rc == 0);
  122. }
  123. TEST_CASE(mmap_directory)
  124. {
  125. int fd = open("/tmp", O_RDONLY | O_DIRECTORY);
  126. VERIFY(fd >= 0);
  127. auto* ptr = mmap(nullptr, 4096, PROT_READ, MAP_FILE | MAP_SHARED, fd, 0);
  128. EXPECT_EQ(ptr, MAP_FAILED);
  129. if (ptr != MAP_FAILED) {
  130. warnln("Boo! mmap() of a directory succeeded!");
  131. }
  132. EXPECT_EQ(errno, ENODEV);
  133. if (errno != ENODEV) {
  134. warnln("Boo! mmap() of a directory gave errno={} instead of ENODEV!", errno);
  135. return;
  136. }
  137. close(fd);
  138. }
  139. TEST_CASE(tmpfs_read_past_end)
  140. {
  141. int fd = open("/tmp/x", O_RDWR | O_CREAT | O_TRUNC, 0600);
  142. VERIFY(fd >= 0);
  143. int rc = ftruncate(fd, 1);
  144. VERIFY(rc == 0);
  145. rc = lseek(fd, 4096, SEEK_SET);
  146. VERIFY(rc == 4096);
  147. char buffer[16];
  148. int nread = read(fd, buffer, sizeof(buffer));
  149. if (nread != 0) {
  150. warnln("Expected 0-length read past end of file in /tmp");
  151. }
  152. rc = close(fd);
  153. VERIFY(rc == 0);
  154. rc = unlink("/tmp/x");
  155. VERIFY(rc == 0);
  156. }
  157. TEST_CASE(procfs_read_past_end)
  158. {
  159. int fd = open("/proc/uptime", O_RDONLY);
  160. VERIFY(fd >= 0);
  161. int rc = lseek(fd, 4096, SEEK_SET);
  162. VERIFY(rc == 4096);
  163. char buffer[16];
  164. int nread = read(fd, buffer, sizeof(buffer));
  165. if (nread != 0) {
  166. warnln("Expected 0-length read past end of file in /proc");
  167. }
  168. close(fd);
  169. }
  170. TEST_CASE(open_create_device)
  171. {
  172. int fd = open("/tmp/fakedevice", (O_RDWR | O_CREAT), (S_IFCHR | 0600));
  173. VERIFY(fd >= 0);
  174. struct stat st;
  175. int rc = fstat(fd, &st);
  176. EXPECT(rc >= 0);
  177. if (rc < 0) {
  178. perror("stat");
  179. }
  180. EXPECT_EQ(st.st_mode, 0100600);
  181. if (st.st_mode != 0100600) {
  182. warnln("Expected mode 0100600 after attempt to create a device node with open(O_CREAT), mode={:o}", st.st_mode);
  183. }
  184. rc = unlink("/tmp/fakedevice");
  185. EXPECT_EQ(rc, 0);
  186. close(fd);
  187. EXPECT_EQ(rc, 0);
  188. }
  189. TEST_CASE(unlink_symlink)
  190. {
  191. int rc = symlink("/proc/2/foo", "/tmp/linky");
  192. EXPECT(rc >= 0);
  193. if (rc < 0) {
  194. perror("symlink");
  195. }
  196. auto target = Core::File::read_link("/tmp/linky");
  197. EXPECT_EQ(target, "/proc/2/foo");
  198. rc = unlink("/tmp/linky");
  199. EXPECT(rc >= 0);
  200. if (rc < 0) {
  201. perror("unlink");
  202. warnln("Expected unlink() of a symlink into an unreadable directory to succeed!");
  203. }
  204. }
  205. TEST_CASE(tmpfs_eoverflow)
  206. {
  207. int fd = open("/tmp/x", O_RDWR | O_CREAT);
  208. EXPECT(fd >= 0);
  209. off_t rc = lseek(fd, INT64_MAX, SEEK_SET);
  210. EXPECT_EQ(rc, INT64_MAX);
  211. char buffer[16] {};
  212. char empty_buffer[16] {};
  213. rc = read(fd, buffer, sizeof(buffer));
  214. EXPECT_EQ(rc, -1);
  215. EXPECT_EQ(errno, EOVERFLOW);
  216. [[maybe_unused]] auto ignored = strlcpy(buffer, "abcdefghijklmno", sizeof(buffer) - 1);
  217. rc = write(fd, buffer, sizeof(buffer));
  218. EXPECT_EQ(rc, -1);
  219. EXPECT_EQ(errno, EOVERFLOW);
  220. if (rc >= 0 || errno != EOVERFLOW) {
  221. warnln("Expected EOVERFLOW when trying to write past INT64_MAX");
  222. }
  223. // ok now, write something to it, and try again
  224. rc = lseek(fd, 0, SEEK_SET);
  225. EXPECT_EQ(rc, 0);
  226. rc = write(fd, buffer, sizeof(buffer));
  227. EXPECT_EQ(rc, 16);
  228. rc = lseek(fd, INT64_MAX, SEEK_SET);
  229. EXPECT_EQ(rc, INT64_MAX);
  230. memset(buffer, 0, sizeof(buffer));
  231. rc = read(fd, buffer, sizeof(buffer));
  232. EXPECT_EQ(rc, -1);
  233. EXPECT_EQ(errno, EOVERFLOW);
  234. if (rc >= 0 || errno != EOVERFLOW) {
  235. warnln("Expected EOVERFLOW when trying to read past INT64_MAX");
  236. }
  237. EXPECT_EQ(0, memcmp(buffer, empty_buffer, sizeof(buffer)));
  238. rc = close(fd);
  239. EXPECT_EQ(rc, 0);
  240. rc = unlink("/tmp/x");
  241. EXPECT_EQ(rc, 0);
  242. }
  243. TEST_CASE(tmpfs_massive_file)
  244. {
  245. int fd = open("/tmp/x", O_RDWR | O_CREAT);
  246. EXPECT(fd >= 0);
  247. off_t rc = lseek(fd, INT32_MAX, SEEK_SET);
  248. EXPECT_EQ(rc, INT32_MAX);
  249. char buffer[16] {};
  250. rc = read(fd, buffer, sizeof(buffer));
  251. EXPECT_EQ(rc, 0);
  252. [[maybe_unused]] auto ignored = strlcpy(buffer, "abcdefghijklmno", sizeof(buffer) - 1);
  253. rc = write(fd, buffer, sizeof(buffer));
  254. EXPECT_EQ(rc, -1);
  255. EXPECT_EQ(errno, ENOMEM);
  256. // ok now, write something to it, and try again
  257. rc = lseek(fd, 0, SEEK_SET);
  258. EXPECT_EQ(rc, 0);
  259. rc = write(fd, buffer, sizeof(buffer));
  260. EXPECT_EQ(rc, 16);
  261. rc = lseek(fd, INT32_MAX, SEEK_SET);
  262. EXPECT_EQ(rc, INT32_MAX);
  263. // FIXME: Should this return EOVERFLOW? Or is a 0 read fine?
  264. memset(buffer, 0, sizeof(buffer));
  265. rc = read(fd, buffer, sizeof(buffer));
  266. EXPECT_EQ(rc, 0);
  267. EXPECT(buffer != "abcdefghijklmno"sv);
  268. rc = close(fd);
  269. EXPECT_EQ(rc, 0);
  270. rc = unlink("/tmp/x");
  271. EXPECT_EQ(rc, 0);
  272. }
  273. TEST_CASE(rmdir_while_inside_dir)
  274. {
  275. int rc = mkdir("/home/anon/testdir", 0700);
  276. VERIFY(rc == 0);
  277. rc = chdir("/home/anon/testdir");
  278. VERIFY(rc == 0);
  279. rc = rmdir("/home/anon/testdir");
  280. VERIFY(rc == 0);
  281. int fd = open("x", O_CREAT | O_RDWR, 0600);
  282. EXPECT(fd < 0);
  283. EXPECT_EQ(errno, ENOENT);
  284. if (fd >= 0 || errno != ENOENT) {
  285. warnln("Expected ENOENT when trying to create a file inside a deleted directory. Got {} with errno={}", fd, errno);
  286. }
  287. rc = chdir("/home/anon");
  288. VERIFY(rc == 0);
  289. }
  290. TEST_CASE(writev)
  291. {
  292. int pipefds[2];
  293. int rc = pipe(pipefds);
  294. EXPECT(rc == 0);
  295. iovec iov[2];
  296. iov[0].iov_base = const_cast<void*>((const void*)"Hello");
  297. iov[0].iov_len = 5;
  298. iov[1].iov_base = const_cast<void*>((const void*)"Friends");
  299. iov[1].iov_len = 7;
  300. int nwritten = writev(pipefds[1], iov, 2);
  301. EXPECT_EQ(nwritten, 12);
  302. if (nwritten < 0) {
  303. perror("writev");
  304. }
  305. if (nwritten != 12) {
  306. warnln("Didn't write 12 bytes to pipe with writev");
  307. }
  308. char buffer[32] {};
  309. int nread = read(pipefds[0], buffer, sizeof(buffer));
  310. EXPECT_EQ(nread, 12);
  311. EXPECT_EQ(buffer, "HelloFriends"sv);
  312. if (nread != 12 || memcmp(buffer, "HelloFriends", 12)) {
  313. warnln("Didn't read the expected data from pipe after writev");
  314. VERIFY_NOT_REACHED();
  315. }
  316. close(pipefds[0]);
  317. close(pipefds[1]);
  318. }
  319. TEST_CASE(rmdir_root)
  320. {
  321. int rc = rmdir("/");
  322. EXPECT_EQ(rc, -1);
  323. EXPECT_EQ(errno, EBUSY);
  324. if (rc != -1 || errno != EBUSY) {
  325. warnln("rmdir(/) didn't fail with EBUSY");
  326. }
  327. }
  328. TEST_CASE(open_silly_things)
  329. {
  330. int rc = -1;
  331. EXPECT_ERROR_2(ENOTDIR, open, "/dev/zero", (O_DIRECTORY | O_RDONLY));
  332. EXPECT_ERROR_2(EINVAL, open, "/dev/zero", (O_DIRECTORY | O_CREAT | O_RDWR));
  333. EXPECT_ERROR_2(EEXIST, open, "/dev/zero", (O_CREAT | O_EXCL | O_RDWR));
  334. EXPECT_ERROR_2(EINVAL, open, "/tmp/abcdef", (O_DIRECTORY | O_CREAT | O_RDWR));
  335. EXPECT_ERROR_2(EACCES, open, "/proc/all", (O_RDWR));
  336. EXPECT_ERROR_2(ENOENT, open, "/boof/baaf/nonexistent", (O_CREAT | O_RDWR));
  337. EXPECT_ERROR_2(EISDIR, open, "/tmp", (O_DIRECTORY | O_RDWR));
  338. EXPECT_ERROR_2(EPERM, link, "/", "/home/anon/lolroot");
  339. }