WebSVN – HelenOS – Diff – /trunk/uspace/lib/libc/generic/io/io.c


/*
 * 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 <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 FILE stdin_null = {
    .fd = -1,
    .error = true,
    .eof = true,
    .klog = false,
    .phone = -1
};
 
static FILE stdout_klog = {
    .fd = -1,
    .error = false,
    .eof = false,
    .klog = true,
    .phone = -1
};
 
static FILE stderr_klog = {
    .fd = -1,
    .error = false,
    .eof = false,
    .klog = true,
    .phone = -1
};
 
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;
}
 
/** 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;
   
    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;
   
    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;
   
    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);
}
 
/** 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)
{
    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);
}
 
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;
}
 
int fflush(FILE *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;
}
 
/** @}
 */
 

Rev 4511	Rev 4512
1	/*	1	/*
2	* Copyright (c) 2005 Martin Decky	2	* Copyright (c) 2005 Martin Decky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup libc	29	/** @addtogroup libc
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <stdio.h>	35	#include <stdio.h>
36	#include <unistd.h>	36	#include <unistd.h>
37	#include <fcntl.h>	37	#include <fcntl.h>
38	#include <string.h>	38	#include <string.h>
39	#include <errno.h>	39	#include <errno.h>
40	#include <bool.h>	40	#include <bool.h>
41	#include <malloc.h>	41	#include <malloc.h>
42	#include <io/klog.h>	42	#include <io/klog.h>
43	#include <vfs/vfs.h>	43	#include <vfs/vfs.h>
44	#include <ipc/devmap.h>	44	#include <ipc/devmap.h>
45	#include <adt/list.h>	45	#include <adt/list.h>
46		46
47	static FILE stdin_null = {	47	static FILE stdin_null = {
48	.fd = -1,	48	.fd = -1,
49	.error = true,	49	.error = true,
50	.eof = true,	50	.eof = true,
51	.klog = false,	51	.klog = false,
52	.phone = -1	52	.phone = -1
53	};	53	};
54		54
55	static FILE stdout_klog = {	55	static FILE stdout_klog = {
56	.fd = -1,	56	.fd = -1,
57	.error = false,	57	.error = false,
58	.eof = false,	58	.eof = false,
59	.klog = true,	59	.klog = true,
60	.phone = -1	60	.phone = -1
61	};	61	};
62		62
63	static FILE stderr_klog = {	63	static FILE stderr_klog = {
64	.fd = -1,	64	.fd = -1,
65	.error = false,	65	.error = false,
66	.eof = false,	66	.eof = false,
67	.klog = true,	67	.klog = true,
68	.phone = -1	68	.phone = -1
69	};	69	};
70		70
71	FILE *stdin = NULL;	71	FILE *stdin = NULL;
72	FILE *stdout = NULL;	72	FILE *stdout = NULL;
73	FILE *stderr = NULL;	73	FILE *stderr = NULL;
74		74
75	static LIST_INITIALIZE(files);	75	static LIST_INITIALIZE(files);
76		76
77	void stdio_init(int filc, fdi_node_t *filv[])	77	void stdio_init(int filc, fdi_node_t *filv[])
78	{	78	{
79	if (filc > 0) {	79	if (filc > 0) {
80	stdin = fopen_node(filv[0], "r");	80	stdin = fopen_node(filv[0], "r");
81	} else {	81	} else {
82	stdin = &stdin_null;	82	stdin = &stdin_null;
83	list_append(&stdin->link, &files);	83	list_append(&stdin->link, &files);
84	}	84	}
85		85
86	if (filc > 1) {	86	if (filc > 1) {
87	stdout = fopen_node(filv[1], "w");	87	stdout = fopen_node(filv[1], "w");
88	} else {	88	} else {
89	stdout = &stdout_klog;	89	stdout = &stdout_klog;
90	list_append(&stdout->link, &files);	90	list_append(&stdout->link, &files);
91	}	91	}
92		92
93	if (filc > 2) {	93	if (filc > 2) {
94	stderr = fopen_node(filv[2], "w");	94	stderr = fopen_node(filv[2], "w");
95	} else {	95	} else {
96	stderr = &stderr_klog;	96	stderr = &stderr_klog;
97	list_append(&stderr->link, &files);	97	list_append(&stderr->link, &files);
98	}	98	}
99	}	99	}
100		100
101	void stdio_done(void)	101	void stdio_done(void)
102	{	102	{
103	link_t *link = files.next;	103	link_t *link = files.next;
104		104
105	while (link != &files) {	105	while (link != &files) {
106	FILE *file = list_get_instance(link, FILE, link);	106	FILE *file = list_get_instance(link, FILE, link);
107	fclose(file);	107	fclose(file);
108	link = files.next;	108	link = files.next;
109	}	109	}
110	}	110	}
111		111
112	static bool parse_mode(const char mode, int flags)	112	static bool parse_mode(const char mode, int flags)
113	{	113	{
114	/* Parse mode except first character. */	114	/* Parse mode except first character. */
115	const char *mp = mode;	115	const char *mp = mode;
116	if (*mp++ == 0) {	116	if (*mp++ == 0) {
117	errno = EINVAL;	117	errno = EINVAL;
118	return false;	118	return false;
119	}	119	}
120		120
121	if ((mp == 'b') \|\| (mp == 't'))	121	if ((mp == 'b') \|\| (mp == 't'))
122	mp++;	122	mp++;
123		123
124	bool plus;	124	bool plus;
125	if (*mp == '+') {	125	if (*mp == '+') {
126	mp++;	126	mp++;
127	plus = true;	127	plus = true;
128	} else	128	} else
129	plus = false;	129	plus = false;
130		130
131	if (*mp != 0) {	131	if (*mp != 0) {
132	errno = EINVAL;	132	errno = EINVAL;
133	return false;	133	return false;
134	}	134	}
135		135
136	/* Parse first character of mode and determine flags for open(). */	136	/* Parse first character of mode and determine flags for open(). */
137	switch (mode[0]) {	137	switch (mode[0]) {
138	case 'r':	138	case 'r':
139	*flags = plus ? O_RDWR : O_RDONLY;	139	*flags = plus ? O_RDWR : O_RDONLY;
140	break;	140	break;
141	case 'w':	141	case 'w':
142	*flags = (O_TRUNC \| O_CREAT) \| (plus ? O_RDWR : O_WRONLY);	142	*flags = (O_TRUNC \| O_CREAT) \| (plus ? O_RDWR : O_WRONLY);
143	break;	143	break;
144	case 'a':	144	case 'a':
145	/* TODO: a+ must read from beginning, append to the end. */	145	/* TODO: a+ must read from beginning, append to the end. */
146	if (plus) {	146	if (plus) {
147	errno = ENOTSUP;	147	errno = ENOTSUP;
148	return false;	148	return false;
149	}	149	}
150	*flags = (O_APPEND \| O_CREAT) \| (plus ? O_RDWR : O_WRONLY);	150	*flags = (O_APPEND \| O_CREAT) \| (plus ? O_RDWR : O_WRONLY);
151	default:	151	default:
152	errno = EINVAL;	152	errno = EINVAL;
153	return false;	153	return false;
154	}	154	}
155		155
156	return true;	156	return true;
157	}	157	}
158		158
159	/** Open a stream.	159	/** Open a stream.
160	*	160	*
161	* @param path Path of the file to open.	161	* @param path Path of the file to open.
162	* @param mode Mode string, (r\|w\|a)[b\|t][+].	162	* @param mode Mode string, (r\|w\|a)[b\|t][+].
163	*	163	*
164	*/	164	*/
165	FILE fopen(const char path, const char *mode)	165	FILE fopen(const char path, const char *mode)
166	{	166	{
167	int flags;	167	int flags;
168	if (!parse_mode(mode, &flags))	168	if (!parse_mode(mode, &flags))
169	return NULL;	169	return NULL;
170		170
171	/* Open file. */	171	/* Open file. */
172	FILE *stream = malloc(sizeof(FILE));	172	FILE *stream = malloc(sizeof(FILE));
173	if (stream == NULL) {	173	if (stream == NULL) {
174	errno = ENOMEM;	174	errno = ENOMEM;
175	return NULL;	175	return NULL;
176	}	176	}
177		177
178	stream->fd = open(path, flags, 0666);	178	stream->fd = open(path, flags, 0666);
179	if (stream->fd < 0) {	179	if (stream->fd < 0) {
180	/* errno was set by open() */	180	/* errno was set by open() */
181	free(stream);	181	free(stream);
182	return NULL;	182	return NULL;
183	}	183	}
184		184
185	stream->error = false;	185	stream->error = false;
186	stream->eof = false;	186	stream->eof = false;
187	stream->klog = false;	187	stream->klog = false;
188	stream->phone = -1;	188	stream->phone = -1;
189		189
190	list_append(&stream->link, &files);	190	list_append(&stream->link, &files);
191		191
192	return stream;	192	return stream;
193	}	193	}
194		194
195	FILE fopen_node(fdi_node_t node, const char *mode)	195	FILE fopen_node(fdi_node_t node, const char *mode)
196	{	196	{
197	int flags;	197	int flags;
198	if (!parse_mode(mode, &flags))	198	if (!parse_mode(mode, &flags))
199	return NULL;	199	return NULL;
200		200
201	/* Open file. */	201	/* Open file. */
202	FILE *stream = malloc(sizeof(FILE));	202	FILE *stream = malloc(sizeof(FILE));
203	if (stream == NULL) {	203	if (stream == NULL) {
204	errno = ENOMEM;	204	errno = ENOMEM;
205	return NULL;	205	return NULL;
206	}	206	}
207		207
208	stream->fd = open_node(node, flags);	208	stream->fd = open_node(node, flags);
209	if (stream->fd < 0) {	209	if (stream->fd < 0) {
210	/* errno was set by open_node() */	210	/* errno was set by open_node() */
211	free(stream);	211	free(stream);
212	return NULL;	212	return NULL;
213	}	213	}
214		214
215	stream->error = false;	215	stream->error = false;
216	stream->eof = false;	216	stream->eof = false;
217	stream->klog = false;	217	stream->klog = false;
218	stream->phone = -1;	218	stream->phone = -1;
219		219
220	list_append(&stream->link, &files);	220	list_append(&stream->link, &files);
221		221
222	return stream;	222	return stream;
223	}	223	}
224		224
225	int fclose(FILE *stream)	225	int fclose(FILE *stream)
226	{	226	{
227	int rc = 0;	227	int rc = 0;
228		228
229	fflush(stream);	229	fflush(stream);
230		230
231	if (stream->phone >= 0)	231	if (stream->phone >= 0)
232	ipc_hangup(stream->phone);	232	ipc_hangup(stream->phone);
233		233
234	if (stream->fd >= 0)	234	if (stream->fd >= 0)
235	rc = close(stream->fd);	235	rc = close(stream->fd);
236		236
237	list_remove(&stream->link);	237	list_remove(&stream->link);
238		238
239	if ((stream != &stdin_null)	239	if ((stream != &stdin_null)
240	&& (stream != &stdout_klog)	240	&& (stream != &stdout_klog)
241	&& (stream != &stderr_klog))	241	&& (stream != &stderr_klog))
242	free(stream);	242	free(stream);
243		243
244	stream = NULL;	244	stream = NULL;
245		245
246	if (rc != 0) {	246	if (rc != 0) {
247	/* errno was set by close() */	247	/* errno was set by close() */
248	return EOF;	248	return EOF;
249	}	249	}
250		250
251	return 0;	251	return 0;
252	}	252	}
253		253
254	/** Read from a stream.	254	/** Read from a stream.
255	*	255	*
256	* @param buf Destination buffer.	256	* @param buf Destination buffer.
257	* @param size Size of each record.	257	* @param size Size of each record.
258	* @param nmemb Number of records to read.	258	* @param nmemb Number of records to read.
259	* @param stream Pointer to the stream.	259	* @param stream Pointer to the stream.
260	*	260	*
261	*/	261	*/
262	size_t fread(void buf, size_t size, size_t nmemb, FILE stream)	262	size_t fread(void buf, size_t size, size_t nmemb, FILE stream)
263	{	263	{
264	size_t left = size * nmemb;	264	size_t left = size * nmemb;
265	size_t done = 0;	265	size_t done = 0;
266		266
267	while ((left > 0) && (!stream->error) && (!stream->eof)) {	267	while ((left > 0) && (!stream->error) && (!stream->eof)) {
268	ssize_t rd = read(stream->fd, buf + done, left);	268	ssize_t rd = read(stream->fd, buf + done, left);
269		269
270	if (rd < 0)	270	if (rd < 0)
271	stream->error = true;	271	stream->error = true;
272	else if (rd == 0)	272	else if (rd == 0)
273	stream->eof = true;	273	stream->eof = true;
274	else {	274	else {
275	left -= rd;	275	left -= rd;
276	done += rd;	276	done += rd;
277	}	277	}
278	}	278	}
279		279
280	return (done / size);	280	return (done / size);
281	}	281	}
282		282
283	/** Write to a stream.	283	/** Write to a stream.
284	*	284	*
285	* @param buf Source buffer.	285	* @param buf Source buffer.
286	* @param size Size of each record.	286	* @param size Size of each record.
287	* @param nmemb Number of records to write.	287	* @param nmemb Number of records to write.
288	* @param stream Pointer to the stream.	288	* @param stream Pointer to the stream.
289	*	289	*
290	*/	290	*/
291	size_t fwrite(const void buf, size_t size, size_t nmemb, FILE stream)	291	size_t fwrite(const void buf, size_t size, size_t nmemb, FILE stream)
292	{	292	{
293	size_t left = size * nmemb;	293	size_t left = size * nmemb;
294	size_t done = 0;	294	size_t done = 0;
295		295
296	while ((left > 0) && (!stream->error)) {	296	while ((left > 0) && (!stream->error)) {
297	ssize_t wr;	297	ssize_t wr;
298		298
299	if (stream->klog)	299	if (stream->klog)
300	wr = klog_write(buf + done, left);	300	wr = klog_write(buf + done, left);
301	else	301	else
302	wr = write(stream->fd, buf + done, left);	302	wr = write(stream->fd, buf + done, left);
303		303
304	if (wr <= 0)	304	if (wr <= 0)
305	stream->error = true;	305	stream->error = true;
306	else {	306	else {
307	left -= wr;	307	left -= wr;
308	done += wr;	308	done += wr;
309	}	309	}
310	}	310	}
311		311
312	return (done / size);	312	return (done / size);
313	}	313	}
314		314
315	int fputc(wchar_t c, FILE *stream)	315	int fputc(wchar_t c, FILE *stream)
316	{	316	{
317	char buf[STR_BOUNDS(1)];	317	char buf[STR_BOUNDS(1)];
318	size_t sz = 0;	318	size_t sz = 0;
319		319
320	if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {	320	if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) {
321	size_t wr = fwrite(buf, sz, 1, stream);	321	size_t wr = fwrite(buf, sz, 1, stream);
322		322
323	if (wr < sz)	323	if (wr < sz)
324	return EOF;	324	return EOF;
325		325
326	return (int) c;	326	return (int) c;
327	}	327	}
328		328
329	return EOF;	329	return EOF;
330	}	330	}
331		331
332	int putchar(wchar_t c)	332	int putchar(wchar_t c)
333	{	333	{
334	return fputc(c, stdout);	334	return fputc(c, stdout);
335	}	335	}
336		336
337	int fputs(const char str, FILE stream)	337	int fputs(const char str, FILE stream)
338	{	338	{
339	return fwrite(str, str_size(str), 1, stream);	339	return fwrite(str, str_size(str), 1, stream);
340	}	340	}
341		341
342	int puts(const char *str)	342	int puts(const char *str)
343	{	343	{
344	return fputs(str, stdout);	344	return fputs(str, stdout);
345	}	345	}
346		346
347	int fgetc(FILE *stream)	347	int fgetc(FILE *stream)
348	{	348	{
349	char c;	349	char c;
350		350
351	/* This could be made faster by only flushing when needed. */	351	/* This could be made faster by only flushing when needed. */
-		352	if (stdout)
352	if (stdout) fflush(stdout);	353	fflush(stdout);
-		354	if (stderr)
353	if (stderr) fflush(stderr);	355	fflush(stderr);
354		356
355	if (fread(&c, sizeof(char), 1, stream) < sizeof(char))	357	if (fread(&c, sizeof(char), 1, stream) < sizeof(char))
356	return EOF;	358	return EOF;
357		359
358	return (int) c;	360	return (int) c;
359	}	361	}
360		362
361	int getchar(void)	363	int getchar(void)
362	{	364	{
363	return fgetc(stdin);	365	return fgetc(stdin);
364	}	366	}
365		367
366	int fseek(FILE *stream, long offset, int origin)	368	int fseek(FILE *stream, long offset, int origin)
367	{	369	{
368	off_t rc = lseek(stream->fd, offset, origin);	370	off_t rc = lseek(stream->fd, offset, origin);
369	if (rc == (off_t) (-1)) {	371	if (rc == (off_t) (-1)) {
370	/* errno has been set by lseek. */	372	/* errno has been set by lseek. */
371	return -1;	373	return -1;
372	}	374	}
373		375
374	stream->eof = false;	376	stream->eof = false;
375		377
376	return 0;	378	return 0;
377	}	379	}
378		380
379	int fflush(FILE *stream)	381	int fflush(FILE *stream)
380	{	382	{
381	if (stream->klog) {	383	if (stream->klog) {
382	klog_update();	384	klog_update();
383	return EOK;	385	return EOK;
384	}	386	}
385		387
386	if (stream->fd >= 0)	388	if (stream->fd >= 0)
387	return fsync(stream->fd);	389	return fsync(stream->fd);
388		390
389	return ENOENT;	391	return ENOENT;
390	}	392	}
391		393
392	int feof(FILE *stream)	394	int feof(FILE *stream)
393	{	395	{
394	return stream->eof;	396	return stream->eof;
395	}	397	}
396		398
397	int ferror(FILE *stream)	399	int ferror(FILE *stream)
398	{	400	{
399	return stream->error;	401	return stream->error;
400	}	402	}
401		403
402	int fphone(FILE *stream)	404	int fphone(FILE *stream)
403	{	405	{
404	if (stream->fd >= 0) {	406	if (stream->fd >= 0) {
405	if (stream->phone < 0)	407	if (stream->phone < 0)
406	stream->phone = fd_phone(stream->fd);	408	stream->phone = fd_phone(stream->fd);
407		409
408	return stream->phone;	410	return stream->phone;
409	}	411	}
410		412
411	return -1;	413	return -1;
412	}	414	}
413		415
414	int fnode(FILE stream, fdi_node_t node)	416	int fnode(FILE stream, fdi_node_t node)
415	{	417	{
416	if (stream->fd >= 0)	418	if (stream->fd >= 0)
417	return fd_node(stream->fd, node);	419	return fd_node(stream->fd, node);
418		420
419	return ENOENT;	421	return ENOENT;
420	}	422	}
421		423
422	/** @}	424	/** @}
423	*/	425	*/
424		426

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libc/generic/io/io.c @ 4590 – Rev 4511 → 4512