libakstdlib/tests/test_stat.c

/* File metadata wrapper tests. */
#include "aksl_capture.h"
#include <errno.h>
#include <fcntl.h>
#include <string.h>

/*
 * A bit libc has never assigned in the AT_ space. fstatat(2) must reject it
 * with EINVAL rather than ignoring it, which is what proves flags reach libc
 * unmasked. Re-check this constant if AT_ ever grows into 0x40000000.
 */
#define AKSL_TEST_AT_INVALID 0x40000000

static int test_stat_success_and_fstat(void)
{
    char path[AKSL_TMP_MAX];
    int fd = -1;
    struct stat path_dest;
    struct stat fd_dest;
    struct statvfs vfs_dest;
    /* A real file makes the mode and four-byte size observable to stat(2). */
    AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
    fd = open(path, O_RDWR);
    AKSL_CHECK(fd >= 0);
    AKSL_CHECK(write(fd, "stat", 4) == 4);
    AKSL_CHECK_OK(aksl_stat(path, &path_dest));
    AKSL_CHECK(S_ISREG(path_dest.st_mode));
    AKSL_CHECK(path_dest.st_size == 4);

    /* fstat(2) addresses the same opened inode, not a second pathname lookup. */
    AKSL_CHECK_OK(aksl_fstat(fd, &fd_dest));
    AKSL_CHECK(fd_dest.st_ino == path_dest.st_ino);

    /* fstatvfs(3) describes the backing filesystem and has a usable block size. */
    AKSL_CHECK_OK(aksl_fstatvfs(fd, &vfs_dest));
    AKSL_CHECK(vfs_dest.f_frsize != 0);
    AKSL_CHECK(close(fd) == 0);

    /* A descriptor that was just closed must surface libc's EBADF. */
    AKSL_CHECK_STATUS(aksl_fstat(fd, &fd_dest), EBADF);
    AKSL_CHECK_STATUS(aksl_fstatvfs(fd, &vfs_dest), EBADF);
    AKSL_CHECK(unlink(path) == 0);
    return 0;
}

static int test_stat_paths_and_fstatat(void)
{
    char path[AKSL_TMP_MAX];
    char child[AKSL_TMP_MAX * 2];
    char directory[AKSL_TMP_MAX];
    char linkpath[AKSL_TMP_MAX * 2];
    char *basename = NULL;
    int dirfd = -1;
    struct stat dest;
    struct stat ldest;
    struct stat path_dest;
    struct statvfs vdest;
    /* Missing paths and a regular file used as a directory preserve errno. */
    AKSL_CHECK_STATUS(aksl_stat("/nonexistent/aksl/stat", &dest), ENOENT);
    AKSL_CHECK_STATUS(aksl_lstat("/nonexistent/aksl/stat", &ldest), ENOENT);
    /* The temporary path is a regular file, so adding a child tests ENOTDIR. */
    AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
    AKSL_CHECK(snprintf(child, sizeof(child), "%s/child", path) < (int)sizeof(child));
    AKSL_CHECK_OK(aksl_stat(path, &path_dest));
    AKSL_CHECK_STATUS(aksl_stat(child, &dest), ENOTDIR);
    AKSL_CHECK(snprintf(linkpath, sizeof(linkpath), "%s.link", path) < (int)sizeof(linkpath));
    AKSL_CHECK(symlink(path, linkpath) == 0);

    /* stat follows the link while lstat reports the link object itself. */
    AKSL_CHECK_OK(aksl_stat(linkpath, &dest));
    AKSL_CHECK_OK(aksl_lstat(linkpath, &ldest));
    AKSL_CHECK(S_ISREG(dest.st_mode));
    AKSL_CHECK(S_ISLNK(ldest.st_mode));

    /* A real dirfd must resolve a relative name against that directory. */
    AKSL_CHECK(snprintf(directory, sizeof(directory), "%s", path) < (int)sizeof(directory));
    basename = strrchr(directory, '/');
    AKSL_CHECK(basename != NULL);
    *basename = '\0';
    dirfd = open(directory, O_RDONLY | O_DIRECTORY);
    AKSL_CHECK(dirfd >= 0);
    AKSL_CHECK_OK(aksl_fstatat(dirfd, strrchr(path, '/') + 1, &dest, 0));
    AKSL_CHECK(dest.st_ino == path_dest.st_ino);
    AKSL_CHECK(close(dirfd) == 0);

    /* A valid non-zero flag must reach libc, making this call an lstat. */
    AKSL_CHECK_OK(aksl_fstatat(AT_FDCWD, linkpath, &dest, AT_SYMLINK_NOFOLLOW));
    AKSL_CHECK(S_ISLNK(dest.st_mode));

    /* Invalid flags must replace stale errno with the EINVAL libc reports. */
    errno = E2BIG;
    AKSL_CHECK_STATUS(aksl_fstatat(AT_FDCWD, path, &dest, AKSL_TEST_AT_INVALID), EINVAL);

    /* statvfs reports ENOENT before it can describe a missing filesystem path. */
    AKSL_CHECK_STATUS(aksl_statvfs("/nonexistent/aksl/stat", &vdest), ENOENT);

    /* statvfs reports the filesystem containing the current directory. */
    AKSL_CHECK_OK(aksl_statvfs(".", &vdest));
    AKSL_CHECK(vdest.f_frsize != 0);
    AKSL_CHECK(unlink(linkpath) == 0);
    AKSL_CHECK(unlink(path) == 0);
    return 0;
}

static int test_stat_null_arguments(void)
{
    char path[AKSL_TMP_MAX];
    struct stat dest;
    struct statvfs vdest;
    /* Create a valid path so each failure below isolates a NULL argument. */
    AKSL_CHECK(aksl_temp_file(path, sizeof(path)) == 0);
    /* Every wrapper refuses either missing caller-owned input or output storage. */
    AKSL_CHECK_STATUS(aksl_stat(NULL, &dest), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_stat(path, NULL), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_lstat(NULL, &dest), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_lstat(path, NULL), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_fstat(0, NULL), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_fstatat(AT_FDCWD, NULL, &dest, 0), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_fstatat(AT_FDCWD, path, NULL, 0), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_statvfs(NULL, &vdest), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_statvfs(path, NULL), AKERR_NULLPOINTER);
    AKSL_CHECK_STATUS(aksl_fstatvfs(0, NULL), AKERR_NULLPOINTER);
    AKSL_CHECK(unlink(path) == 0);
    return 0;
}

int main(void)
{
    int failures = 0;
    AKSL_RUN(failures, test_stat_success_and_fstat);
    AKSL_RUN(failures, test_stat_paths_and_fstatat);
    AKSL_RUN(failures, test_stat_null_arguments);
    AKSL_REPORT(failures);
}