new resolve fd logic: openat

int hook_openat(int dirfd, const char *cpath, int flags, mode_t mode) {

    if(cpath == nullptr || cpath[0] == '\0') {

        CTX->log()->error("{}() path is invalid", __func__);

        return -EINVAL;

    }

    CTX->log()->trace("{}() called with fd: {}, path: {}, flags: {}, mode: {}", __func__, dirfd, cpath, flags, mode);

    CTX->log()->trace("{}() called with fd: {}, path: {}, flags: {}, mode: {}",

                       __func__, dirfd, cpath, flags, mode);

    std::string resolved;

    if((cpath[0] == PSP) || (dirfd == AT_FDCWD)) {

        // cpath is absolute or relative to CWD

        if (CTX->relativize_path(cpath, resolved)) {

            int ret = adafs_open(resolved, mode, flags);

            if(ret < 0) {

                return -errno;

            }

            return ret;

        }

    } else {

        // cpath is relative

        if(!(CTX->file_map()->exist(dirfd))) {

            //TODO relative cpath could still lead to our FS

    auto rstatus = CTX->relativize_fd_path(dirfd, cpath, resolved);

    switch(rstatus) {

        case RelativizeStatus::fd_unknown:

            return syscall_no_intercept(SYS_openat, dirfd, cpath, flags, mode);

        }

        auto dir = CTX->file_map()->get_dir(dirfd);

        if(dir == nullptr) {

            CTX->log()->error("{}() dirfd is not a directory ", __func__);

        case RelativizeStatus::external:

            return syscall_no_intercept(SYS_openat, dirfd, resolved.c_str(), flags, mode);

        case RelativizeStatus::fd_not_a_dir:

            return -ENOTDIR;

        }

        std::string path = CTX->mountdir();

        path.append(dir->path());

        path.push_back(PSP);

        path.append(cpath);

        if(resolve_path(path, resolved)) {

            int ret = adafs_open(resolved, mode, flags);

            if(ret < 0) {

                return -errno;

            }

            return ret;

        }

        case RelativizeStatus::internal:

            return with_errno(adafs_open(resolved, mode, flags));

        default:

            CTX->log()->error("{}() relativize status unknown: {}", __func__);

            return -EINVAL;

    }

    return syscall_no_intercept(SYS_openat, dirfd, resolved.c_str(), flags, mode);

}

int hook_close(int fd) {