/*
 * 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 <assert.h>
#include <str.h>
#include <errno.h>
#include <stdbool.h>
#include <stdlib.h>
#include <async.h>
#include <io/kio.h>
#include <vfs/vfs.h>
#include <vfs/vfs_sess.h>
#include <vfs/inbox.h>
#include <ipc/loc.h>
#include <adt/list.h>
#include <wchar.h>
#include "../private/io.h"
#include "../private/stdio.h"

static void _ffillbuf(FILE *stream);
static void _fflushbuf(FILE *stream);

static size_t stdio_kio_read(void *, size_t, size_t, FILE *);
static size_t stdio_kio_write(const void *, size_t, size_t, FILE *);
static int stdio_kio_flush(FILE *);

static size_t stdio_vfs_read(void *, size_t, size_t, FILE *);
static size_t stdio_vfs_write(const void *, size_t, size_t, FILE *);

static int stdio_vfs_flush(FILE *);

/** KIO stream ops */
static __stream_ops_t stdio_kio_ops = {
	.read = stdio_kio_read,
	.write = stdio_kio_write,
	.flush = stdio_kio_flush
};

/** VFS stream ops */
static __stream_ops_t stdio_vfs_ops = {
	.read = stdio_vfs_read,
	.write = stdio_vfs_write,
	.flush = stdio_vfs_flush
};

static FILE stdin_null = {
	.fd = -1,
	.pos = 0,
	.error = true,
	.eof = true,
	.ops = &stdio_vfs_ops,
	.arg = NULL,
	.sess = NULL,
	.btype = _IONBF,
	.buf = NULL,
	.buf_size = 0,
	.buf_head = NULL,
	.buf_tail = NULL,
	.buf_state = _bs_empty
};

static FILE stdout_kio = {
	.fd = -1,
	.pos = 0,
	.error = false,
	.eof = false,
	.ops = &stdio_kio_ops,
	.arg = NULL,
	.sess = NULL,
	.btype = _IOLBF,
	.buf = NULL,
	.buf_size = BUFSIZ,
	.buf_head = NULL,
	.buf_tail = NULL,
	.buf_state = _bs_empty
};

static FILE stderr_kio = {
	.fd = -1,
	.pos = 0,
	.error = false,
	.eof = false,
	.ops = &stdio_kio_ops,
	.arg = NULL,
	.sess = NULL,
	.btype = _IONBF,
	.buf = NULL,
	.buf_size = 0,
	.buf_head = NULL,
	.buf_tail = NULL,
	.buf_state = _bs_empty
};

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

static LIST_INITIALIZE(files);

void __stdio_init(void)
{
	/*
	 * The first three standard file descriptors are assigned for compatibility.
	 * This will probably be removed later.
	 */
	int infd = inbox_get("stdin");
	if (infd >= 0) {
		int stdinfd = -1;
		(void) vfs_clone(infd, -1, false, &stdinfd);
		assert(stdinfd == 0);
		vfs_open(stdinfd, MODE_READ);
		stdin = fdopen(stdinfd, "r");
	} else {
		stdin = &stdin_null;
		list_append(&stdin->link, &files);
	}

	int outfd = inbox_get("stdout");
	if (outfd >= 0) {
		int stdoutfd = -1;
		(void) vfs_clone(outfd, -1, false, &stdoutfd);
		assert(stdoutfd <= 1);
		while (stdoutfd < 1)
			(void) vfs_clone(outfd, -1, false, &stdoutfd);
		vfs_open(stdoutfd, MODE_APPEND);
		stdout = fdopen(stdoutfd, "a");
	} else {
		stdout = &stdout_kio;
		list_append(&stdout->link, &files);
	}

	int errfd = inbox_get("stderr");
	if (errfd >= 0) {
		int stderrfd = -1;
		(void) vfs_clone(errfd, -1, false, &stderrfd);
		assert(stderrfd <= 2);
		while (stderrfd < 2)
			(void) vfs_clone(errfd, -1, false, &stderrfd);
		vfs_open(stderrfd, MODE_APPEND);
		stderr = fdopen(stderrfd, "a");
	} else {
		stderr = &stderr_kio;
		list_append(&stderr->link, &files);
	}
}

void __stdio_done(void)
{
	while (!list_empty(&files)) {
		FILE *file = list_get_instance(list_first(&files), FILE, link);
		fclose(file);
	}
}

static bool parse_mode(const char *fmode, int *mode, bool *create, bool *excl,
    bool *truncate)
{
	/* Parse mode except first character. */
	const char *mp = fmode;

	if (*mp++ == '\0') {
		errno = EINVAL;
		return false;
	}

	if ((*mp == 'b') || (*mp == 't'))
		mp++;

	bool plus;
	if (*mp == '+') {
		mp++;
		plus = true;
	} else {
		plus = false;
	}

	bool ex;
	if (*mp == 'x') {
		mp++;
		ex = true;
	} else {
		ex = false;
	}

	if (*mp != '\0') {
		errno = EINVAL;
		return false;
	}

	*create = false;
	*truncate = false;
	*excl = false;

	/* Parse first character of fmode and determine mode for vfs_open(). */
	switch (fmode[0]) {
	case 'r':
		*mode = plus ? MODE_READ | MODE_WRITE : MODE_READ;
		if (ex) {
			errno = EINVAL;
			return false;
		}
		break;
	case 'w':
		*mode = plus ? MODE_READ | MODE_WRITE : MODE_WRITE;
		*create = true;
		*excl = ex;
		if (!plus)
			*truncate = true;
		break;
	case 'a':
		/* TODO: a+ must read from beginning, append to the end. */
		if (plus) {
			errno = ENOTSUP;
			return false;
		}

		if (ex) {
			errno = EINVAL;
			return false;
		}

		*mode = MODE_APPEND | (plus ? MODE_READ | MODE_WRITE : MODE_WRITE);
		*create = true;
		break;
	default:
		errno = EINVAL;
		return false;
	}

	return true;
}

/** Set stream buffer. */
int setvbuf(FILE *stream, void *buf, int mode, size_t size)
{
	if (mode != _IONBF && mode != _IOLBF && mode != _IOFBF)
		return -1;

	stream->btype = mode;
	stream->buf = buf;
	stream->buf_size = size;
	stream->buf_head = stream->buf;
	stream->buf_tail = stream->buf;
	stream->buf_state = _bs_empty;

	return 0;
}

/** Set stream buffer.
 *
 * When @p buf is NULL, the stream is set as unbuffered, otherwise
 * full buffering is enabled.
 */
void setbuf(FILE *stream, void *buf)
{
	if (buf == NULL) {
		setvbuf(stream, NULL, _IONBF, BUFSIZ);
	} else {
		setvbuf(stream, buf, _IOFBF, BUFSIZ);
	}
}

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 EOF;
	}

	stream->buf_head = stream->buf;
	stream->buf_tail = stream->buf;
	return 0;
}

/** Open a stream.
 *
 * @param path Path of the file to open.
 * @param mode Mode string, (r|w|a)[b|t][+][x].
 *
 */
FILE *fopen(const char *path, const char *fmode)
{
	int mode;
	bool create;
	bool excl;
	bool truncate;

	if (!parse_mode(fmode, &mode, &create, &excl, &truncate))
		return NULL;

	/* Open file. */
	FILE *stream = malloc(sizeof(FILE));
	if (stream == NULL) {
		errno = ENOMEM;
		return NULL;
	}

	int flags = WALK_REGULAR;
	if (create && excl)
		flags |= WALK_MUST_CREATE;
	else if (create)
		flags |= WALK_MAY_CREATE;
	int file;
	errno_t rc = vfs_lookup(path, flags, &file);
	if (rc != EOK) {
		errno = rc;
		free(stream);
		return NULL;
	}

	rc = vfs_open(file, mode);
	if (rc != EOK) {
		errno = rc;
		vfs_put(file);
		free(stream);
		return NULL;
	}

	if (truncate) {
		rc = vfs_resize(file, 0);
		if (rc != EOK) {
			errno = rc;
			vfs_put(file);
			free(stream);
			return NULL;
		}
	}

	stream->fd = file;
	stream->pos = 0;
	stream->error = false;
	stream->eof = false;
	stream->ops = &stdio_vfs_ops;
	stream->arg = NULL;
	stream->sess = NULL;
	stream->need_sync = false;
	_setvbuf(stream);
	stream->ungetc_chars = 0;

	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->pos = 0;
	stream->error = false;
	stream->eof = false;
	stream->ops = &stdio_vfs_ops;
	stream->arg = NULL;
	stream->sess = NULL;
	stream->need_sync = false;
	_setvbuf(stream);
	stream->ungetc_chars = 0;

	list_append(&stream->link, &files);

	return stream;
}

static int _fclose_nofree(FILE *stream)
{
	errno_t rc = 0;

	fflush(stream);

	if (stream->sess != NULL)
		async_hangup(stream->sess);

	if (stream->fd >= 0)
		rc = vfs_put(stream->fd);

	list_remove(&stream->link);

	if (rc != EOK) {
		errno = rc;
		return EOF;
	}

	return 0;
}

int fclose(FILE *stream)
{
	int rc = _fclose_nofree(stream);

	if ((stream != &stdin_null) &&
	    (stream != &stdout_kio) &&
	    (stream != &stderr_kio))
		free(stream);

	return rc;
}

FILE *freopen(const char *path, const char *mode, FILE *stream)
{
	FILE *nstr;

	if (path == NULL) {
		/* Changing mode is not supported */
		return NULL;
	}

	(void) _fclose_nofree(stream);
	nstr = fopen(path, mode);
	if (nstr == NULL) {
		free(stream);
		return NULL;
	}

	list_remove(&nstr->link);
	*stream = *nstr;
	list_append(&stream->link, &files);

	free(nstr);

	return stream;
}

/** Read from a stream (unbuffered).
 *
 * @param buf    Destination buffer.
 * @param size   Size of each record.
 * @param nmemb  Number of records to read.
 * @param stream Pointer to the stream.
 *
 * @return Number of elements successfully read. On error this is less than
 *         nmemb, stream error indicator is set and errno is set.
 */
static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
{
	return stream->ops->read(buf, size, nmemb, stream);
}

/** Write to a stream (unbuffered).
 *
 * @param buf    Source buffer.
 * @param size   Size of each record.
 * @param nmemb  Number of records to write.
 * @param stream Pointer to the stream.
 *
 * @return Number of elements successfully written. On error this is less than
 *         nmemb, stream error indicator is set and errno is set.
 */
static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
{
	size_t nwritten;

	if (size == 0 || nmemb == 0)
		return 0;

	nwritten = stream->ops->write(buf, size, nmemb, stream);

	if (nwritten > 0)
		stream->need_sync = true;

	return (nwritten / size);
}

/** Read some data in stream buffer.
 *
 * On error, stream error indicator is set and errno is set.
 */
static void _ffillbuf(FILE *stream)
{
	errno_t rc;
	size_t nread;

	stream->buf_head = stream->buf_tail = stream->buf;

	rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size,
	    &nread);
	if (rc != EOK) {
		errno = rc;
		stream->error = true;
		return;
	}

	if (nread == 0) {
		stream->eof = true;
		return;
	}

	stream->buf_head += nread;
	stream->buf_state = _bs_read;
}

/** Write out 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_tail;

	/* If buffer has prefetched read data, we need to seek back. */
	if (bytes_used > 0 && stream->buf_state == _bs_read)
		stream->pos -= bytes_used;

	/* If buffer has unwritten data, we need to write them out. */
	if (bytes_used > 0 && stream->buf_state == _bs_write) {
		(void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
		/* On error stream error indicator and errno are set by _fwrite */
		if (stream->error)
			return;
	}

	stream->buf_head = stream->buf;
	stream->buf_tail = stream->buf;
	stream->buf_state = _bs_empty;
}

/** Read from a stream.
 *
 * @param dest   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 *dest, size_t size, size_t nmemb, FILE *stream)
{
	uint8_t *dp;
	size_t bytes_left;
	size_t now;
	size_t data_avail;
	size_t total_read;
	size_t i;

	if (size == 0 || nmemb == 0)
		return 0;

	bytes_left = size * nmemb;
	total_read = 0;
	dp = (uint8_t *) dest;

	/* Bytes from ungetc() buffer */
	while (stream->ungetc_chars > 0 && bytes_left > 0) {
		*dp++ = stream->ungetc_buf[--stream->ungetc_chars];
		++total_read;
		--bytes_left;
	}

	/* If not buffered stream, read in directly. */
	if (stream->btype == _IONBF) {
		total_read += _fread(dest, 1, bytes_left, stream);
		return total_read / size;
	}

	/* Make sure no data is pending write. */
	if (stream->buf_state == _bs_write)
		_fflushbuf(stream);

	/* Perform lazy allocation of stream buffer. */
	if (stream->buf == NULL) {
		if (_fallocbuf(stream) != 0)
			return 0; /* Errno set by _fallocbuf(). */
	}

	while ((!stream->error) && (!stream->eof) && (bytes_left > 0)) {
		if (stream->buf_head == stream->buf_tail)
			_ffillbuf(stream);

		if (stream->error || stream->eof) {
			/* On error errno was set by _ffillbuf() */
			break;
		}

		data_avail = stream->buf_head - stream->buf_tail;

		if (bytes_left > data_avail)
			now = data_avail;
		else
			now = bytes_left;

		for (i = 0; i < now; i++) {
			dp[i] = stream->buf_tail[i];
		}

		dp += now;
		stream->buf_tail += now;
		bytes_left -= now;
		total_read += now;
	}

	return (total_read / size);
}

/** 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 (size == 0 || nmemb == 0)
		return 0;

	/* If not buffered stream, write out directly. */
	if (stream->btype == _IONBF) {
		now = _fwrite(buf, size, nmemb, stream);
		fflush(stream);
		return now;
	}

	/* Make sure buffer contains no prefetched data. */
	if (stream->buf_state == _bs_read)
		_fflushbuf(stream);

	/* 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;
		}

		data += now;
		stream->buf_head += now;
		buf_free -= now;
		bytes_left -= now;
		total_written += now;
		stream->buf_state = _bs_write;

		if (buf_free == 0) {
			/* Only need to drain buffer. */
			_fflushbuf(stream);
			if (!stream->error)
				need_flush = false;
		}
	}

	if (need_flush)
		fflush(stream);

	return (total_written / size);
}

wint_t fputwc(wchar_t wc, FILE *stream)
{
	char buf[STR_BOUNDS(1)];
	size_t sz = 0;

	if (chr_encode(wc, buf, &sz, STR_BOUNDS(1)) != EOK) {
		errno = EILSEQ;
		return WEOF;
	}

	size_t wr = fwrite(buf, 1, sz, stream);
	if (wr < sz)
		return WEOF;

	return wc;
}

wint_t putwchar(wchar_t wc)
{
	return fputwc(wc, stdout);
}

int fputc(int c, FILE *stream)
{
	unsigned char b;
	size_t wr;

	b = (unsigned char) c;
	wr = fwrite(&b, sizeof(b), 1, stream);
	if (wr < 1)
		return EOF;

	return b;
}

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

int fputs(const char *str, FILE *stream)
{
	(void) fwrite(str, str_size(str), 1, stream);
	if (ferror(stream))
		return EOF;
	return 0;
}

int puts(const char *str)
{
	if (fputs(str, stdout) < 0)
		return EOF;
	return putchar('\n');
}

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;
}

char *fgets(char *str, int size, FILE *stream)
{
	int c;
	int idx;

	idx = 0;
	while (idx < size - 1) {
		c = fgetc(stream);
		if (c == EOF)
			break;

		str[idx++] = c;

		if (c == '\n')
			break;
	}

	if (ferror(stream))
		return NULL;

	if (idx == 0)
		return NULL;

	str[idx] = '\0';
	return str;
}

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

int ungetc(int c, FILE *stream)
{
	if (c == EOF)
		return EOF;

	if (stream->ungetc_chars >= UNGETC_MAX)
		return EOF;

	stream->ungetc_buf[stream->ungetc_chars++] =
	    (uint8_t)c;

	stream->eof = false;
	return (uint8_t)c;
}

int fseek64(FILE *stream, off64_t offset, int whence)
{
	errno_t rc;

	if (stream->error)
		return -1;

	_fflushbuf(stream);
	if (stream->error) {
		/* errno was set by _fflushbuf() */
		return -1;
	}

	stream->ungetc_chars = 0;

	vfs_stat_t st;
	switch (whence) {
	case SEEK_SET:
		stream->pos = offset;
		break;
	case SEEK_CUR:
		stream->pos += offset;
		break;
	case SEEK_END:
		rc = vfs_stat(stream->fd, &st);
		if (rc != EOK) {
			errno = rc;
			stream->error = true;
			return -1;
		}
		stream->pos = st.size + offset;
		break;
	}

	stream->eof = false;
	return 0;
}

off64_t ftell64(FILE *stream)
{
	if (stream->error)
		return EOF;

	_fflushbuf(stream);
	if (stream->error) {
		/* errno was set by _fflushbuf() */
		return EOF;
	}

	return stream->pos - stream->ungetc_chars;
}

int fseek(FILE *stream, long offset, int whence)
{
	return fseek64(stream, offset, whence);
}

long ftell(FILE *stream)
{
	off64_t off = ftell64(stream);

	/* The native position is too large for the C99-ish interface. */
	if (off > LONG_MAX)
		return EOF;

	return off;
}

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

int fflush(FILE *stream)
{
	if (stream->error)
		return EOF;

	_fflushbuf(stream);
	if (stream->error) {
		/* errno was set by _fflushbuf() */
		return EOF;
	}

	if (stream->need_sync) {
		/**
		 * Better than syncing always, but probably still not the
		 * right thing to do.
		 */
		if (stream->ops->flush(stream) == EOF)
			return EOF;

		stream->need_sync = false;
	}

	return 0;
}

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

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

void clearerr(FILE *stream)
{
	stream->eof = false;
	stream->error = false;
}

int fileno(FILE *stream)
{
	if (stream->ops != &stdio_vfs_ops) {
		errno = EBADF;
		return EOF;
	}

	return stream->fd;
}

async_sess_t *vfs_fsession(FILE *stream, iface_t iface)
{
	if (stream->fd >= 0) {
		if (stream->sess == NULL)
			stream->sess = vfs_fd_session(stream->fd, iface);

		return stream->sess;
	}

	return NULL;
}

errno_t vfs_fhandle(FILE *stream, int *handle)
{
	if (stream->fd >= 0) {
		*handle = stream->fd;
		return EOK;
	}

	return ENOENT;
}

/** Read from KIO stream. */
static size_t stdio_kio_read(void *buf, size_t size, size_t nmemb, FILE *stream)
{
	stream->eof = true;
	return 0;
}

/** Write to KIO stream. */
static size_t stdio_kio_write(const void *buf, size_t size, size_t nmemb,
    FILE *stream)
{
	errno_t rc;
	size_t nwritten;

	rc = kio_write(buf, size * nmemb, &nwritten);
	if (rc != EOK) {
		stream->error = true;
		nwritten = 0;
	}

	return nwritten / size;
}

/** Flush KIO stream. */
static int stdio_kio_flush(FILE *stream)
{
	kio_update();
	return 0;
}

/** Read from VFS stream. */
static size_t stdio_vfs_read(void *buf, size_t size, size_t nmemb, FILE *stream)
{
	errno_t rc;
	size_t nread;

	if (size == 0 || nmemb == 0)
		return 0;

	rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
	if (rc != EOK) {
		errno = rc;
		stream->error = true;
	} else if (nread == 0) {
		stream->eof = true;
	}

	return (nread / size);
}

/** Write to VFS stream. */
static size_t stdio_vfs_write(const void *buf, size_t size, size_t nmemb,
    FILE *stream)
{
	errno_t rc;
	size_t nwritten;

	rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb, &nwritten);
	if (rc != EOK) {
		errno = rc;
		stream->error = true;
	}

	return nwritten / size;
}

/** Flush VFS stream. */
static int stdio_vfs_flush(FILE *stream)
{
	errno_t rc;

	rc = vfs_sync(stream->fd);
	if (rc != EOK) {
		errno = rc;
		return EOF;
	}

	return 0;
}

/** @}
 */
