/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2002-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * "buffered" i/o functions for the standalone environment. (ugh).
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include <sys/promif.h>
#include <sys/varargs.h>
#include <sys/bootvfs.h>
#include <sys/salib.h>

enum {
	F_OPEN		= 0x01,
	F_ERROR		= 0x02,
	F_SEEKABLE	= 0x04
};

FILE	__iob[_NFILE] = {
	{ F_OPEN, 0, 0, 0, "stdin"	},
	{ F_OPEN, 1, 0, 0, "stdout"	},
	{ F_OPEN, 2, 0, 0, "stderr"	}
};

static boolean_t
fcheck(FILE *stream, int flags)
{
	errno = 0;
	if ((stream->_flag & flags) != flags) {
		errno = EBADF;
		return (B_FALSE);
	}
	return (B_TRUE);
}

int
fclose(FILE *stream)
{
	if (!fcheck(stream, F_OPEN))
		return (EOF);

	(void) close(stream->_file);
	stream->_flag = 0;
	stream->_file = -1;
	stream->_name[0] = '\0';
	return (0);
}

int
feof(FILE *stream)
{
	if (!fcheck(stream, F_OPEN))
		return (0);

	return (stream->_len == stream->_offset);
}

int
ferror(FILE *stream)
{
	if (!fcheck(stream, F_OPEN))
		return (0);

	return ((stream->_flag & F_ERROR) != 0);
}

void
clearerr(FILE *stream)
{
	stream->_flag &= ~F_ERROR;
}

int
fflush(FILE *stream)
{
	if (!fcheck(stream, F_OPEN))
		return (EOF);

	/* Currently, a nop */
	return (0);
}

char *
fgets(char *s, int n, FILE *stream)
{
	int	bytes;
	ssize_t	cnt;

	if (!fcheck(stream, F_OPEN))
		return (NULL);

	for (bytes = 0; bytes < (n - 1); ++bytes) {
		cnt = read(stream->_file, &s[bytes], 1);
		if (cnt < 0) {
			if (bytes != 0) {
				s[bytes] = '\0';
				return (s);
			} else {
				stream->_flag |= F_ERROR;
				return (NULL);
			}
		} else if (cnt == 0) {
			/* EOF */
			if (bytes != 0) {
				s[bytes] = '\0';
				return (s);
			} else
				return (NULL);
		} else {
			stream->_offset++;
			if (s[bytes] == '\n') {
				s[bytes + 1] = '\0';
				return (s);
			}
		}
	}
	s[bytes] = '\0';
	return (s);
}

/*
 * We currently only support read-only ("r" mode) opens and unbuffered I/O.
 */
FILE *
fopen(const char *filename, const char *mode)
{
	FILE		*stream;
	const char	*t;
	int		fd, i;

	errno = 0;

	/*
	 * Make sure we have a filesystem underneath us before even trying.
	 */
	if (get_default_fs() == NULL)
		return (NULL);

	for (t = mode; t != NULL && *t != '\0'; t++) {
		switch (*t) {
		case 'b':
			/* We ignore this a'la ISO C standard conformance */
			break;
		case 'r':
			/* We ignore this because we always open for reading */
			break;

		case 'a':
		case 'w':
		case '+':
			errno = EROFS;
			return (NULL);

		default:
			errno = EINVAL;
			return (NULL);
		}
	}

	for (i = 0; i < _NFILE; i++) {
		stream = &__iob[i];
		if ((stream->_flag & F_OPEN) == 0) {
			fd = open(filename, O_RDONLY);
			if (fd < 0)
				return (NULL);

			stream->_file = fd;
			stream->_flag |= F_OPEN;
			(void) strlcpy(stream->_name, filename,
			    sizeof (stream->_name));
			return (stream);
		}
	}

	errno = EMFILE;
	return (NULL);
}

/* PRINTFLIKE1 */
void
printf(const char *fmt, ...)
{
	va_list adx;

	va_start(adx, fmt);
	prom_vprintf(fmt, adx);
	va_end(adx);
}

/*
 * Only writing to stderr or stdout is permitted.
 */
/* PRINTFLIKE2 */
int
fprintf(FILE *stream, const char *format, ...)
{
	int	nwritten;
	va_list	va;

	if (!fcheck(stream, F_OPEN))
		return (-1);

	/*
	 * Since fopen() doesn't return writable streams, the only valid
	 * writable streams are stdout and stderr.
	 */
	if (stream != stdout && stream != stderr) {
		errno = EBADF;
		return (-1);
	}

	va_start(va, format);
	printf(format, va);
	va_end(va);

	va_start(va, format);
	nwritten = vsnprintf(NULL, 0, format, va);
	va_end(va);

	return (nwritten);
}

size_t
fread(void *ptr, size_t size, size_t nitems, FILE *stream)
{
	size_t	items;
	ssize_t	bytes, totbytes = 0;
	char	*strp = ptr;

	if (!fcheck(stream, F_OPEN))
		return (0);

	for (items = 0, bytes = 0; items < nitems; items++) {
		bytes = read(stream->_file, &strp[totbytes], size);
		if (bytes < 0) {
			stream->_flag |= F_ERROR;
			return (0);
		} else if (bytes == 0) {
			/* EOF */
			return ((totbytes == 0) ? 0 : totbytes / size);
		} else if (bytes == size) {
			stream->_offset += bytes;
			totbytes += bytes;
		} else {
			(void) lseek(stream->_file, stream->_offset, SEEK_SET);
			return (totbytes / size);
		}
	}

	return (totbytes / size);
}

/*
 * We don't grow files.
 */
int
fseek(FILE *stream, long offset, int whence)
{
	off_t	new_offset, result;

	if (!fcheck(stream, F_OPEN | F_SEEKABLE))
		return (-1);

	switch (whence) {
	case SEEK_SET:
		new_offset = (off_t)offset;
		break;
	case SEEK_CUR:
		new_offset = stream->_offset + (off_t)offset;
		break;
	case SEEK_END:
		new_offset = (off_t)stream->_len + (off_t)offset;
		break;
	default:
		errno = EINVAL;
		return (-1);
	}

	if (new_offset > (off_t)stream->_len) {
		errno = EFBIG;
	} else if (new_offset < 0L) {
		errno = EOVERFLOW;
	} else {
		errno = 0;
	}

	result = lseek(stream->_file, new_offset, SEEK_SET);
	if (result >= 0)
		stream->_offset = result;
	else
		stream->_flag |= F_ERROR;

	return (result);
}

long
ftell(FILE *stream)
{
	if (!fcheck(stream, F_OPEN | F_SEEKABLE))
		return (0);

	return ((long)stream->_offset);
}

size_t
fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream)
{
	if (!fcheck(stream, F_OPEN))
		return (0);

	/*
	 * Since fopen() doesn't return writable streams, the only valid
	 * writable streams are stdout and stderr.
	 */
	if (stream != stdout && stream != stderr) {
		errno = EBADF;
		return (0);
	}

	prom_writestr(ptr, size * nitems);
	return (nitems);
}

/*ARGSUSED*/
int
setvbuf(FILE *stream, char *buf, int type, size_t size)
{
	if (!fcheck(stream, F_OPEN))
		return (-1);

	/* Currently a nop, probably always will be. */
	return (0);
}