| 0,0 → 1,593 |
|---|
| /* |
| * 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; |
| } |
| |
| /** @} |
| */ |