mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-02-01 03:53:33 +00:00
322 lines
12 KiB
C
322 lines
12 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
|
│ │
|
|
│ Permission to use, copy, modify, and/or distribute this software for │
|
|
│ any purpose with or without fee is hereby granted, provided that the │
|
|
│ above copyright notice and this permission notice appear in all copies. │
|
|
│ │
|
|
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
|
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
|
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
|
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
|
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
|
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
|
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
|
│ PERFORMANCE OF THIS SOFTWARE. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "libc/calls/calls.h"
|
|
#include "libc/calls/internal.h"
|
|
#include "libc/calls/struct/stat.h"
|
|
#include "libc/dce.h"
|
|
#include "libc/errno.h"
|
|
#include "libc/macros.internal.h"
|
|
#include "libc/mem/gc.internal.h"
|
|
#include "libc/runtime/runtime.h"
|
|
#include "libc/stdio/stdio.h"
|
|
#include "libc/str/str.h"
|
|
#include "libc/sysv/consts/o.h"
|
|
#include "libc/testlib/testlib.h"
|
|
#include "libc/x/x.h"
|
|
#include "libc/x/xasprintf.h"
|
|
|
|
#define abs(rel) gc(xasprintf("%s/%s", gc(getcwd(0, 0)), rel))
|
|
|
|
char testlib_enable_tmp_setup_teardown;
|
|
|
|
void SetUpOnce(void) {
|
|
ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath fattr", 0));
|
|
}
|
|
|
|
TEST(open, efault) {
|
|
ASSERT_SYS(EFAULT, -1, open(0, O_RDONLY));
|
|
if (IsWindows() || !IsAsan()) return; // not possible
|
|
ASSERT_SYS(EFAULT, -1, open((void *)77, O_RDONLY));
|
|
}
|
|
|
|
TEST(open, enoent) {
|
|
ASSERT_SYS(ENOENT, -1, open("", O_RDONLY));
|
|
ASSERT_SYS(ENOENT, -1, open("doesnotexist", O_RDONLY));
|
|
ASSERT_SYS(ENOENT, -1, open("o/doesnotexist", O_RDONLY));
|
|
}
|
|
|
|
TEST(open, enotdir) {
|
|
ASSERT_SYS(0, 0, touch("o", 0644));
|
|
ASSERT_SYS(ENOTDIR, -1, open("o/", O_RDONLY));
|
|
ASSERT_SYS(ENOTDIR, -1, open("o/.", O_RDONLY));
|
|
ASSERT_SYS(ENOTDIR, -1, open("o/./", O_RDONLY));
|
|
ASSERT_SYS(ENOTDIR, -1, open("o/doesnotexist", O_RDONLY));
|
|
}
|
|
|
|
TEST(open, eexist) {
|
|
ASSERT_SYS(0, 0, touch("exists", 0644));
|
|
ASSERT_SYS(EEXIST, -1, open("exists", O_WRONLY | O_CREAT | O_EXCL, 0644));
|
|
}
|
|
|
|
TEST(open, doubleSlash_worksAndGetsNormalizedOnWindows) {
|
|
ASSERT_SYS(0, 0, mkdir("o", 0755));
|
|
ASSERT_SYS(0, 3,
|
|
open(gc(xjoinpaths(gc(getcwd(0, 0)), "o//deleteme")),
|
|
O_WRONLY | O_CREAT | O_TRUNC, 0644));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, enametoolong) {
|
|
size_t n = 260;
|
|
char *s = gc(xcalloc(1, n + 1));
|
|
memset(s, 'J', n);
|
|
ASSERT_SYS(ENAMETOOLONG, -1, creat(s, 0644));
|
|
}
|
|
|
|
TEST(open, testSpaceInFilename) {
|
|
char buf[8] = {0};
|
|
ASSERT_SYS(0, 0, xbarf("hello txt", "hello", -1));
|
|
ASSERT_SYS(0, 3, open("hello txt", O_WRONLY));
|
|
EXPECT_SYS(0, 1, write(3, "H", 1));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open("hello txt", O_RDONLY));
|
|
EXPECT_SYS(0, 5, read(3, buf, 7));
|
|
EXPECT_STREQ("Hello", buf);
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, testOpenExistingForWriteOnly_seeksToStart) {
|
|
char buf[8] = {0};
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hello", -1));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_WRONLY));
|
|
EXPECT_SYS(0, 1, write(3, "H", 1));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDONLY));
|
|
EXPECT_SYS(0, 5, read(3, buf, 7));
|
|
EXPECT_STREQ("Hello", buf);
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, testOpenExistingForReadWrite_seeksToStart) {
|
|
char buf[8] = {0};
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hello", -1));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDWR));
|
|
EXPECT_SYS(0, 1, write(3, "H", 1));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDONLY));
|
|
EXPECT_SYS(0, 5, read(3, buf, 7));
|
|
EXPECT_STREQ("Hello", buf);
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, testOpenExistingForAppendWriteOnly_seeksToEnd) {
|
|
char buf[16] = {0};
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hell", -1));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_WRONLY | O_APPEND));
|
|
EXPECT_SYS(EBADF, -1, pread(3, buf, 4, 0)); // in O_WRONLY mode
|
|
EXPECT_SYS(0, 1, write(3, "o", 1));
|
|
EXPECT_SYS(0, 0, lseek(3, 0, SEEK_SET));
|
|
EXPECT_SYS(0, 1, write(3, "!", 1));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDONLY));
|
|
EXPECT_SYS(0, 6, read(3, buf, 8));
|
|
EXPECT_STREQ("hello!", buf);
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, appendRwMode_readsStartZero_writesAlwaysEof) {
|
|
char buf[8] = {0};
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hell", -1));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDWR | O_APPEND));
|
|
ASSERT_SYS(0, 2, read(3, buf, 2));
|
|
ASSERT_SYS(0, 2, read(3, buf + 2, 2));
|
|
EXPECT_STREQ("hell", buf);
|
|
EXPECT_SYS(0, 2, write(3, "o!", 2));
|
|
ASSERT_SYS(0, 6, pread(3, buf, 8, 0));
|
|
EXPECT_STREQ("hello!", buf);
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, appendReadOnlyMode_appendIsIgnored) {
|
|
char buf[8] = {0};
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hell", -1));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDONLY | O_APPEND));
|
|
EXPECT_SYS(EBADF, -1, write(3, "o!", 2)); // due to O_RDONLY
|
|
ASSERT_EQ(0, errno);
|
|
ASSERT_SYS(0, 2, read(3, buf, 2));
|
|
ASSERT_SYS(0, 2, read(3, buf + 2, 2));
|
|
EXPECT_STREQ("hell", buf);
|
|
ASSERT_SYS(0, 4, pread(3, buf, 4, 0));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, truncReadWriteMode_getsTruncated) {
|
|
char buf[8] = {0};
|
|
ASSERT_FALSE(fileexists("hello.txt"));
|
|
ASSERT_SYS(ENOENT, -1, open("hello.txt", O_RDWR | O_TRUNC));
|
|
ASSERT_SYS(ENOENT, -1, open("hello.txt/there", O_RDWR | O_TRUNC));
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hell", -1));
|
|
ASSERT_SYS(ENOTDIR, -1, open("hello.txt/there", O_RDWR | O_TRUNC));
|
|
ASSERT_SYS(0, 3, open("hello.txt", O_RDWR | O_TRUNC));
|
|
ASSERT_SYS(0, 0, read(3, buf, 8));
|
|
EXPECT_STREQ("", buf);
|
|
ASSERT_SYS(0, 8, write(3, buf, 8));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, truncReadOnlyMode_wontTruncate) {
|
|
ASSERT_SYS(EINVAL, -1, open("hello.txt", O_RDONLY | O_TRUNC));
|
|
}
|
|
|
|
TEST(open, testRelativePath_opensRelativeToDirFd) {
|
|
ASSERT_SYS(0, 0, mkdir("foo", 0755));
|
|
ASSERT_SYS(0, 3, open("foo", O_RDONLY | O_DIRECTORY));
|
|
EXPECT_SYS(0, 4, openat(3, "bar", O_WRONLY | O_TRUNC | O_CREAT, 0755));
|
|
EXPECT_TRUE(fileexists("foo/bar"));
|
|
EXPECT_SYS(0, 0, close(4));
|
|
EXPECT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, eloop) {
|
|
ASSERT_SYS(0, 0, symlink("froot", "link"));
|
|
ASSERT_TRUE(issymlink("link"));
|
|
ASSERT_SYS(ELOOP, -1, open("link", O_RDONLY | O_NOFOLLOW));
|
|
}
|
|
|
|
TEST(open, norm) {
|
|
ASSERT_SYS(0, 0, mkdir("fun", 0755));
|
|
ASSERT_SYS(0, 0, mkdir("fun/house", 0755));
|
|
ASSERT_SYS(0, 0, touch("fun/house/norm", 0644));
|
|
ASSERT_SYS(0, 3, open("fun//house//norm", O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open(abs("fun//house//norm"), O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open("fun//house/./norm", O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open(abs("fun//house/./norm"), O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open("fun//house/../house/norm", O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(0, 3, open(abs("fun//house/../house/norm"), O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
ASSERT_SYS(ENOTDIR, -1, open("fun//house//norm/", O_RDONLY));
|
|
ASSERT_SYS(ENOTDIR, -1, open("fun//house//norm/.", O_RDONLY));
|
|
ASSERT_SYS(ENOTDIR, -1, open("fun//house//norm/./", O_RDONLY));
|
|
ASSERT_SYS(0, 3, open("fun//house//", O_RDONLY | O_DIRECTORY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, longNormDot) {
|
|
if (IsWindows()) return; // todo: why won't long paths work on windows
|
|
#define NAME \
|
|
"funfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfu" \
|
|
"nfunfunfunfunfunfunnfunfunfunfunfunfunnfunfunfunfunfunfununfunfunfunfunfun"
|
|
ASSERT_SYS(0, 0, mkdir(NAME, 0755));
|
|
ASSERT_SYS(0, 0, mkdir(abs(NAME "/" NAME), 0755));
|
|
ASSERT_SYS(0, 3, creat(abs(NAME "//" NAME "/./norm"), 0644));
|
|
ASSERT_TRUE(fileexists(abs(NAME "//" NAME "/norm")));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, longNormDotDot) {
|
|
if (IsWindows()) return; // todo: why won't long paths work on windows
|
|
#define NAME \
|
|
"funfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfunfu" \
|
|
"nfunfunfunfunfunfunnfunfunfunfunfunfunnfunfunfunfunfunfununfunfunfunfunfun"
|
|
ASSERT_SYS(0, 0, mkdir(NAME, 0755));
|
|
ASSERT_SYS(0, 0, mkdir(abs(NAME "/" NAME), 0755));
|
|
ASSERT_SYS(0, 0, mkdir(abs(NAME "/" NAME "/" NAME), 0755));
|
|
ASSERT_SYS(0, 3, creat(abs(NAME "//" NAME "//" NAME "/../norm"), 0644));
|
|
ASSERT_TRUE(fileexists(abs(NAME "//" NAME "/norm")));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, creat_directory) {
|
|
ASSERT_SYS(ENOENT, -1, open("fun", O_WRONLY | O_DIRECTORY));
|
|
ASSERT_FALSE(fileexists("fun"));
|
|
if (1) return; // linux 5.15.122-0-lts creates file and returns error D:
|
|
ASSERT_SYS(ENOTDIR, -1, open("fun", O_CREAT | O_WRONLY | O_DIRECTORY, 0644));
|
|
ASSERT_TRUE(fileexists("fun"));
|
|
}
|
|
|
|
TEST(open, O_DIRECTORY_preventsOpeningRegularFiles) {
|
|
ASSERT_SYS(0, 0, touch("file", 0644));
|
|
ASSERT_SYS(ENOTDIR, -1, open("file", O_WRONLY | O_DIRECTORY));
|
|
}
|
|
|
|
TEST(open, O_DIRECTORY_isNotARequirementToOpenDirectory) {
|
|
ASSERT_SYS(0, 0, mkdir("dir", 0755));
|
|
ASSERT_SYS(0, 3, open("dir", O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
}
|
|
|
|
TEST(open, openExistingDirectoryForWriting_raisesError) {
|
|
ASSERT_SYS(0, 0, mkdir("dir", 0755));
|
|
ASSERT_SYS(EISDIR, -1, open("dir", O_WRONLY));
|
|
}
|
|
|
|
TEST(open, nameWithControlCode) {
|
|
if (IsWindows()) {
|
|
ASSERT_SYS(EINVAL, -1, touch("hi\1there", 0755));
|
|
} else {
|
|
ASSERT_SYS(0, 0, touch("hi\1there", 0755));
|
|
}
|
|
}
|
|
|
|
TEST(open, nameWithOverlongNul_doesntCreateTruncatedName) {
|
|
if (IsXnu() || IsWindows()) {
|
|
// XNU is the only one that thought to restrict this. XNU chose
|
|
// EILSEQ which makes the most sense. Linux says it'll raise EINVAL
|
|
// if invalid characters are detected. Not sure yet which characters
|
|
// those are. POSIX says nothing about invalid charaters in open.
|
|
ASSERT_SYS(EILSEQ, -1, touch("hi\300\200there", 0755));
|
|
} else {
|
|
ASSERT_SYS(0, 0, touch("hi\300\200there", 0755));
|
|
ASSERT_TRUE(fileexists("hi\300\200there"));
|
|
ASSERT_FALSE(fileexists("hi"));
|
|
}
|
|
}
|
|
|
|
int CountFds(void) {
|
|
int i, count;
|
|
for (count = i = 0; i < g_fds.n; ++i) {
|
|
if (g_fds.p[i].kind) {
|
|
++count;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
TEST(open, lotsOfFds) {
|
|
if (!IsWindows()) return;
|
|
int i, n = 200;
|
|
ASSERT_SYS(0, 0, xbarf("hello.txt", "hello", -1));
|
|
for (i = 3; i < n; ++i) {
|
|
EXPECT_EQ(i, CountFds());
|
|
EXPECT_SYS(0, i, open("hello.txt", O_RDONLY));
|
|
}
|
|
for (i = 3; i < n; ++i) {
|
|
EXPECT_SYS(0, 0, close(i));
|
|
}
|
|
}
|
|
|
|
static int64_t GetInode(const char *path) {
|
|
struct stat st;
|
|
ASSERT_SYS(0, 0, stat(path, &st));
|
|
return st.st_ino;
|
|
}
|
|
|
|
TEST(open, drive) {
|
|
if (!IsWindows()) return;
|
|
ASSERT_NE(GetInode("/"), GetInode("."));
|
|
ASSERT_EQ(GetInode("/"), GetInode("/c")); // sorry you have to run on c:/
|
|
ASSERT_EQ(GetInode("/"), GetInode("/c/"));
|
|
ASSERT_SYS(0, 3, open("/", O_RDONLY));
|
|
ASSERT_SYS(0, 0, close(3));
|
|
}
|