Subversion Repositories HelenOS

/*
 * Copyright (c) 2005 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libc
 * @{
 */
/** @file
 */

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <string.h>
#include <errno.h>
#include <bool.h>
#include <malloc.h>
#include <io/klog.h>
#include <vfs/vfs.h>
#include <ipc/devmap.h>
#include <adt/list.h>

static void _fflushbuf(FILE *stream);

static FILE stdin_null = {
    .fd = -1,
    .error = true,
    .eof = true,
    .klog = false,
    .phone = -1,
    .btype = _IONBF,
    .buf = NULL,
    .buf_size = 0,
    .buf_head = NULL
};

static FILE stdout_klog = {
    .fd = -1,
    .error = false,
    .eof = false,
    .klog = true,
    .phone = -1,
    .btype = _IOLBF,
    .buf = NULL,
    .buf_size = BUFSIZ,
    .buf_head = NULL
};

static FILE stderr_klog = {
    .fd = -1,
    .error = false,
    .eof = false,
    .klog = true,
    .phone = -1,
    .btype = _IONBF,
    .buf = NULL,
    .buf_size = 0,
    .buf_head = NULL
};

FILE *stdin = NULL;
FILE *stdout = NULL;
FILE *stderr = NULL;

static LIST_INITIALIZE(files);

void __stdio_init(int filc, fdi_node_t *filv[])
{
    if (filc > 0) {
        stdin = fopen_node(filv[0], "r");
    } else {
        stdin = &stdin_null;
        list_append(&stdin->link, &files);
    }
    
    if (filc > 1) {
        stdout = fopen_node(filv[1], "w");
    } else {
        stdout = &stdout_klog;
        list_append(&stdout->link, &files);
    }
    
    if (filc > 2) {
        stderr = fopen_node(filv[2], "w");
    } else {
        stderr = &stderr_klog;
        list_append(&stderr->link, &files);
    }
}

void __stdio_done(void)
{
    link_t *link = files.next;
    
    while (link != &files) {
        FILE *file = list_get_instance(link, FILE, link);
        fclose(file);
        link = files.next;
    }
}

static bool parse_mode(const char *mode, int *flags)
{
    /* Parse mode except first character. */
    const char *mp = mode;
    if (*mp++ == 0) {
        errno = EINVAL;
        return false;
    }
    
    if ((*mp == 'b') || (*mp == 't'))
        mp++;
    
    bool plus;
    if (*mp == '+') {
        mp++;
        plus = true;
    } else
        plus = false;
    
    if (*mp != 0) {
        errno = EINVAL;
        return false;
    }
    
    /* Parse first character of mode and determine flags for open(). */
    switch (mode[0]) {
    case 'r':
        *flags = plus ? O_RDWR : O_RDONLY;
        break;
    case 'w':
        *flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
        break;
    case 'a':
        /* TODO: a+ must read from beginning, append to the end. */
        if (plus) {
            errno = ENOTSUP;
            return false;
        }
        *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
    default:
        errno = EINVAL;
        return false;
    }
    
    return true;
}

/** Set stream buffer. */
void setvbuf(FILE *stream, void *buf, int mode, size_t size)
{
    stream->btype = mode;
    stream->buf = buf;
    stream->buf_size = size;
    stream->buf_head = stream->buf;
}

static void _setvbuf(FILE *stream)
{
    /* FIXME: Use more complex rules for setting buffering options. */
    
    switch (stream->fd) {
    case 1:
        setvbuf(stream, NULL, _IOLBF, BUFSIZ);
        break;
    case 0:
    case 2:
        setvbuf(stream, NULL, _IONBF, 0);
        break;
    default:
        setvbuf(stream, NULL, _IOFBF, BUFSIZ);
    }
}

/** Allocate stream buffer. */
static int _fallocbuf(FILE *stream)
{
    assert(stream->buf == NULL);
    
    stream->buf = malloc(stream->buf_size);
    if (stream->buf == NULL) {
        errno = ENOMEM;
        return -1;
    }
    
    stream->buf_head = stream->buf;
    return 0;
}

/** Open a stream.
 *
 * @param path Path of the file to open.
 * @param mode Mode string, (r|w|a)[b|t][+].
 *
 */
FILE *fopen(const char *path, const char *mode)
{
    int flags;
    if (!parse_mode(mode, &flags))
        return NULL;
    
    /* Open file. */
    FILE *stream = malloc(sizeof(FILE));
    if (stream == NULL) {
        errno = ENOMEM;
        return NULL;
    }
    
    stream->fd = open(path, flags, 0666);
    if (stream->fd < 0) {
        /* errno was set by open() */
        free(stream);
        return NULL;
    }
    
    stream->error = false;
    stream->eof = false;
    stream->klog = false;
    stream->phone = -1;
    _setvbuf(stream);
    
    list_append(&stream->link, &files);
    
    return stream;
}

FILE *fdopen(int fd, const char *mode)
{
    /* Open file. */
    FILE *stream = malloc(sizeof(FILE));
    if (stream == NULL) {
        errno = ENOMEM;
        return NULL;
    }
    
    stream->fd = fd;
    stream->error = false;
    stream->eof = false;
    stream->klog = false;
    stream->phone = -1;
    _setvbuf(stream);
    
    list_append(&stream->link, &files);
    
    return stream;
}

FILE *fopen_node(fdi_node_t *node, const char *mode)
{
    int flags;
    if (!parse_mode(mode, &flags))
        return NULL;
    
    /* Open file. */
    FILE *stream = malloc(sizeof(FILE));
    if (stream == NULL) {
        errno = ENOMEM;
        return NULL;
    }
    
    stream->fd = open_node(node, flags);
    if (stream->fd < 0) {
        /* errno was set by open_node() */
        free(stream);
        return NULL;
    }
    
    stream->error = false;
    stream->eof = false;
    stream->klog = false;
    stream->phone = -1;
    _setvbuf(stream);
    
    list_append(&stream->link, &files);
    
    return stream;
}

int fclose(FILE *stream)
{
    int rc = 0;
    
    fflush(stream);
    
    if (stream->phone >= 0)
        ipc_hangup(stream->phone);
    
    if (stream->fd >= 0)
        rc = close(stream->fd);
    
    list_remove(&stream->link);
    
    if ((stream != &stdin_null)
        && (stream != &stdout_klog)
        && (stream != &stderr_klog))
        free(stream);
    
    stream = NULL;
    
    if (rc != 0) {
        /* errno was set by close() */
        return EOF;
    }
    
    return 0;
}

/** Read from a stream.
 *
 * @param buf    Destination buffer.
 * @param size   Size of each record.
 * @param nmemb  Number of records to read.
 * @param stream Pointer to the stream.
 *
 */
size_t fread(void *buf, size_t size, size_t nmemb, FILE *stream)
{
    size_t left = size * nmemb;
    size_t done = 0;
    
    /* Make sure no data is pending write. */
    _fflushbuf(stream);
    
    while ((left > 0) && (!stream->error) && (!stream->eof)) {
        ssize_t rd = read(stream->fd, buf + done, left);
        
        if (rd < 0)
            stream->error = true;
        else if (rd == 0)
            stream->eof = true;
        else {
            left -= rd;
            done += rd;
        }
    }
    
    return (done / size);
}

static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
{
    size_t left = size * nmemb;
    size_t done = 0;
    
    while ((left > 0) && (!stream->error)) {
        ssize_t wr;
        
        if (stream->klog)
            wr = klog_write(buf + done, left);
        else
            wr = write(stream->fd, buf + done, left);
        
        if (wr <= 0)
            stream->error = true;
        else {
            left -= wr;
            done += wr;
        }
    }
    
    return (done / size);
}

/** Drain stream buffer, do not sync stream. */
static void _fflushbuf(FILE *stream)
{
    size_t bytes_used;
    
    if ((!stream->buf) || (stream->btype == _IONBF) || (stream->error))
        return;
    
    bytes_used = stream->buf_head - stream->buf;
    if (bytes_used == 0)
        return;
    
    (void) _fwrite(stream->buf, 1, bytes_used, stream);
    stream->buf_head = stream->buf;
}

/** Write to a stream.
 *
 * @param buf    Source buffer.
 * @param size   Size of each record.
 * @param nmemb  Number of records to write.
 * @param stream Pointer to the stream.
 *
 */
size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
{
    uint8_t *data;
    size_t bytes_left;
    size_t now;
    size_t buf_free;
    size_t total_written;
    size_t i;
    uint8_t b;
    bool need_flush;
    
    /* If not buffered stream, write out directly. */
    if (stream->btype == _IONBF) {
        now = _fwrite(buf, size, nmemb, stream);
        fflush(stream);
        return now;
    }
    
    /* Perform lazy allocation of stream buffer. */
    if (stream->buf == NULL) {
        if (_fallocbuf(stream) != 0)
            return 0; /* Errno set by _fallocbuf(). */
    }
    
    data = (uint8_t *) buf;
    bytes_left = size * nmemb;
    total_written = 0;
    need_flush = false;
    
    while ((!stream->error) && (bytes_left > 0)) {
        buf_free = stream->buf_size - (stream->buf_head - stream->buf);
        if (bytes_left > buf_free)
            now = buf_free;
        else
            now = bytes_left;
        
        for (i = 0; i < now; i++) {
            b = data[i];
            stream->buf_head[i] = b;
            
            if ((b == '\n') && (stream->btype == _IOLBF))
                need_flush = true;
        }
        
        buf += now;
        stream->buf_head += now;
        buf_free -= now;
        bytes_left -= now;
        total_written += now;
        
        if (buf_free == 0) {
            /* Only need to drain buffer. */
            _fflushbuf(stream);
            need_flush = false;
        }
    }
    
    if (need_flush)
        fflush(stream);
    
    return (total_written / size);
}

int fputc(wchar_t c, FILE *stream)
{
    char buf[STR_BOUNDS(1)];
    size_t sz = 0;
    
    if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {
        size_t wr = fwrite(buf, sz, 1, stream);
        
        if (wr < sz)
            return EOF;
        
        return (int) c;
    }
    
    return EOF;
}

int putchar(wchar_t c)
{
    return fputc(c, stdout);
}

int fputs(const char *str, FILE *stream)
{
    return fwrite(str, str_size(str), 1, stream);
}

int puts(const char *str)
{
    return fputs(str, stdout);
}

int fgetc(FILE *stream)
{
    char c;
    
    /* This could be made faster by only flushing when needed. */
    if (stdout)
        fflush(stdout);
    if (stderr)
        fflush(stderr);
    
    if (fread(&c, sizeof(char), 1, stream) < sizeof(char))
        return EOF;
    
    return (int) c;
}

int getchar(void)
{
    return fgetc(stdin);
}

int fseek(FILE *stream, long offset, int origin)
{
    off_t rc = lseek(stream->fd, offset, origin);
    if (rc == (off_t) (-1)) {
        /* errno has been set by lseek. */
        return -1;
    }
    
    stream->eof = false;
    
    return 0;
}

void rewind(FILE *stream)
{
    (void) fseek(stream, 0, SEEK_SET);
}

int fflush(FILE *stream)
{
    _fflushbuf(stream);
    
    if (stream->klog) {
        klog_update();
        return EOK;
    }
    
    if (stream->fd >= 0)
        return fsync(stream->fd);
    
    return ENOENT;
}

int feof(FILE *stream)
{
    return stream->eof;
}

int ferror(FILE *stream)
{
    return stream->error;
}

int fphone(FILE *stream)
{
    if (stream->fd >= 0) {
        if (stream->phone < 0)
            stream->phone = fd_phone(stream->fd);
        
        return stream->phone;
    }
    
    return -1;
}

int fnode(FILE *stream, fdi_node_t *node)
{
    if (stream->fd >= 0)
        return fd_node(stream->fd, node);
    
    return ENOENT;
}

/** @}
 */