open.c

Go to the documentation of this file.

#include <slibc.h>
#include <stdint.h>
#include <sys/types.h>
#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stropts.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

#include <object.h>
#include <list.h>
#include <vfs.h>
#include <thread.h>

#include <debug.h>

int open(const char *path, int mode, ...)
{
        struct file_object_info info;
        struct thread *tcb;
        register int fd;
        int ret;

        tcb = pthread_self();
        if (!tcb || !tcb->file_ctx) {
                printf("Invalid TCB\n");
                return -EFAULT;
        }

        fd = 0;
        while (fd < MAX_ENTRY && tcb->file_ctx->table[fd].ctx) {
                fd++;
        }

        if (fd == MAX_ENTRY) {
                printf("No more slot\n");
                return -ENOSPC;
        }

        info.size = BUFSIZ;
        info.path = path;
        info.mode = mode;

        ret = object_create(&tcb->file_ctx->table[fd].object, &info);
        if (ret < 0) {
                return ret;
        }

        return fd;
}

off_t lseek(int fd, off_t offset, int whence)
{
        struct entry *ctx;
        struct ninfo *ninfo;
        struct thread *tcb;

        tcb = pthread_self();
        if (!tcb || !tcb->file_ctx) {
                return -EFAULT;
        }

        ctx = tcb->file_ctx->table[fd].ctx;
        if (!ctx) {
                return -EINVAL;
        }

        ninfo = ctx->ninfo;
        if (!ninfo) {
                return -EINVAL;
        }

        if (!ninfo->nops.lseek) {
                return -EPERM;
        }

        return ninfo->nops.lseek(ninfo, &ctx->nctx, offset, whence);
}

ssize_t read(int fd, void *buf, size_t size)
{
        struct entry *ctx;
        struct ninfo *ninfo;
        struct thread *tcb;

        tcb = pthread_self();
        if (!tcb || !tcb->file_ctx) {
                return -EFAULT;
        }

        ctx = tcb->file_ctx->table[fd].ctx;
        if (!ctx) {
                return -EINVAL;
        }

        ninfo = ctx->ninfo;
        if (!ninfo) {
                return -EINVAL;
        }

        if (!ninfo->nops.read) {
                return -EPERM;
        }

        return ninfo->nops.read(ninfo, &ctx->nctx, buf, size);
}

ssize_t write(int fd, const void *buf, size_t size)
{
        struct entry *ctx;
        struct ninfo *ninfo;
        struct thread *tcb;

        tcb = pthread_self();
        if (!tcb || !tcb->file_ctx) {
                return -EFAULT;
        }

        ctx = tcb->file_ctx->table[fd].ctx;
        if (!ctx) {
                return -EINVAL;
        }

        ninfo = ctx->ninfo;
        if (!ninfo) {
                return -EINVAL;
        }

        if (!ninfo->nops.write) {
                return -EPERM;
        }

        return ninfo->nops.write(ninfo, &ctx->nctx, buf, size);
}

int close(int fd)
{
        struct thread *tcb;
        int ret = 0;

        tcb = pthread_self();
        if (!tcb || !tcb->file_ctx) {
                return -EFAULT;
        }

        object_destroy(&tcb->file_ctx->table[fd].object);
        return ret;
}

int ioctl(int fd, int request, ...)
{
        struct entry *ctx;
        struct ninfo *ninfo;
        struct thread *tcb;
        va_list ap;
        int ret = -EPERM;

        tcb = pthread_self();
        if (!tcb || !tcb->file_ctx) {
                return -EFAULT;
        }

        ctx = tcb->file_ctx->table[fd].ctx;
        if (!ctx) {
                return -EINVAL;
        }

        ninfo = ctx->ninfo;
        if (!ninfo) {
                return -EINVAL;
        }

        if (ninfo->nops.ioctl) {
                va_start(ap, request);
                ret = ninfo->nops.ioctl(ninfo, &ctx->nctx, request, ap);
                va_end(ap);
        }

        return ret;
}

/* End of a file */