WebSVN – HelenOS-historic – Diff – /uspace/trunk/libc/generic/io/stream.c


/*
 * Copyright (C) 2006 Josef Cejka
 * Copyright (C) 2006 Jakub Vana
 * 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.
 */
 
 
#include <io/io.h>
#include <io/stream.h>
#include <string.h>
#include <malloc.h>
#include <libc.h>
#include <ipc/ipc.h>
#include <ipc/ns.h>
#include <ipc/fb.h>
#include <ipc/services.h>
#include <console.h>
#include <unistd.h>
 
#define FDS 32
 
typedef struct stream_t {
    pwritefn_t w;
    preadfn_t r;
    void * param;
} stream_t;
 
int console_phone = -1;
 
stream_t streams[FDS] = {{0, 0, 0}};
 
/*
ssize_t write_stdout(void *param, const void * buf, size_t count);
ssize_t write_stdout(void *param, const void * buf, size_t count)
{
    return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
}*/
 
static ssize_t write_stderr(void *param, const void *buf, size_t count)
{
    return count;
    //return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
}
 
static ssize_t read_stdin(void *param, void *buf, size_t count)
{
    ipcarg_t r0,r1;
    size_t i = 0;
 
    while (i < count) {
        if (ipc_call_sync_2(console_phone, CONSOLE_GETCHAR, 0, 0, &r0, &r1) < 0) {
            return -1;
        }
        ((char *)buf)[i++] = r0;
    }
    return i;
    //return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
}
 
static ssize_t write_stdout(void *param, const void *buf, size_t count)
{
    int i;
    ipcarg_t r0,r1;
 
    for (i = 0; i < count; i++)
        ipc_call_sync_2(console_phone, CONSOLE_PUTCHAR, 0, ((const char *)buf)[i], &r0, &r1);
   
    return count;
    //return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
}
 
 
 
static stream_t open_stdin(void)
{
    stream_t stream;
    int phoneid;
    int res;
   
    if (console_phone < 0) {
        while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
            usleep(10000);
        }
    }
   
    stream.r = read_stdin;
    stream.param = 0;
    return stream;
}
 
static stream_t open_stdout(void)
{
    stream_t stream;
    int res;
   
    if (console_phone < 0) {
        while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
            usleep(10000);
 
        }
    }
   
    stream.w = write_stdout;
    stream.param = 0;
    return stream;
}
 
fd_t open(const char *fname, int flags)
{
    int c = 0;
   
    while (((streams[c].w) || (streams[c].r)) && (c < FDS))
        c++;
    if (c == FDS)
        return EMFILE;
   
    if (!strcmp(fname, "stdin")) {
        streams[c] = open_stdin();
        return c;
    }
   
    if (!strcmp(fname, "stdout")) {
        //streams[c].w = write_stdout;
        //return c;
        streams[c] = open_stdout();
        return c;
    }
   
    if (!strcmp(fname, "stderr")) {
        streams[c].w = write_stderr;
        return c;
    }
}
 
 
ssize_t write(int fd, const void *buf, size_t count)
{
    if (fd < FDS)
        return streams[fd].w(streams[fd].param, buf, count);
   
    return 0;
}
 
ssize_t read(int fd, void *buf, size_t count)
{
    if (fd < FDS)
        return streams[fd].r(streams[fd].param, buf, count);
   
    return 0;
}
 
 

Rev 1465	Rev 1476
1	/*	1	/*
2	* Copyright (C) 2006 Josef Cejka	2	* Copyright (C) 2006 Josef Cejka
3	* Copyright (C) 2006 Jakub Vana	3	* Copyright (C) 2006 Jakub Vana
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30		30
31	#include <io/io.h>	31	#include <io/io.h>
32	#include <io/stream.h>	32	#include <io/stream.h>
33	#include <string.h>	33	#include <string.h>
34	#include <malloc.h>	34	#include <malloc.h>
35	#include <libc.h>	35	#include <libc.h>
36	#include <ipc/ipc.h>	36	#include <ipc/ipc.h>
37	#include <ipc/ns.h>	37	#include <ipc/ns.h>
38	#include <ipc/fb.h>	38	#include <ipc/fb.h>
39	#include <ipc/services.h>	39	#include <ipc/services.h>
40	#include <console.h>	40	#include <console.h>
41	#include <unistd.h>	41	#include <unistd.h>
42		42
43	#define FDS 32	43	#define FDS 32
44		44
45	typedef struct stream_t {	45	typedef struct stream_t {
46	pwritefn_t w;	46	pwritefn_t w;
47	preadfn_t r;	47	preadfn_t r;
48	void * param;	48	void * param;
49	} stream_t;	49	} stream_t;
50		50
51	int console_phone = -1;	51	int console_phone = -1;
52		52
53	stream_t streams[FDS] = {{0, 0, 0}};	53	stream_t streams[FDS] = {{0, 0, 0}};
54		54
55	/*	55	/*
56	ssize_t write_stdout(void param, const void buf, size_t count);	56	ssize_t write_stdout(void param, const void buf, size_t count);
57	ssize_t write_stdout(void param, const void buf, size_t count)	57	ssize_t write_stdout(void param, const void buf, size_t count)
58	{	58	{
59	return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);	59	return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
60	}*/	60	}*/
61		61
62	static ssize_t write_stderr(void param, const void buf, size_t count)	62	static ssize_t write_stderr(void param, const void buf, size_t count)
63	{	63	{
64	return count;	64	return count;
65	//return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);	65	//return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
66	}	66	}
67		67
68	static ssize_t read_stdin(void param, void buf, size_t count)	68	static ssize_t read_stdin(void param, void buf, size_t count)
69	{	69	{
70	ipcarg_t r0,r1;	70	ipcarg_t r0,r1;
71	size_t i = 0;	71	size_t i = 0;
72		72
73	while (i < count) {	73	while (i < count) {
74	if (ipc_call_sync_2(console_phone, CONSOLE_GETCHAR, 0, 0, &r0, &r1) < 0) {	74	if (ipc_call_sync_2(console_phone, CONSOLE_GETCHAR, 0, 0, &r0, &r1) < 0) {
75	return -1;	75	return -1;
76	}	76	}
77	((char *)buf)[i++] = r0;	77	((char *)buf)[i++] = r0;
78	}	78	}
79	return i;	79	return i;
80	//return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);	80	//return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
81	}	81	}
82		82
83	static ssize_t write_stdout(void param, const void buf, size_t count)	83	static ssize_t write_stdout(void param, const void buf, size_t count)
84	{	84	{
85	int i;	85	int i;
86	ipcarg_t r0,r1;	86	ipcarg_t r0,r1;
87		87
88	for (i = 0; i < count; i++)	88	for (i = 0; i < count; i++)
89	ipc_call_sync_2(console_phone, CONSOLE_PUTCHAR, 0, ((const char *)buf)[i], &r0, &r1);	89	ipc_call_sync_2(console_phone, CONSOLE_PUTCHAR, 0, ((const char *)buf)[i], &r0, &r1);
90		90
91	return count;	91	return count;
92	//return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);	92	//return (ssize_t) __SYSCALL3(SYS_IO, 1, (sysarg_t) buf, (sysarg_t) count);
93	}	93	}
94		94
95		95
96		96
97	static stream_t open_stdin(void)	97	static stream_t open_stdin(void)
98	{	98	{
99	stream_t stream;	99	stream_t stream;
100	int phoneid;	100	int phoneid;
101	int res;	101	int res;
102		102
103	if (console_phone < 0) {	103	if (console_phone < 0) {
104	while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {	104	while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
105	usleep(10000);	105	usleep(10000);
106	}	106	}
107	}	107	}
108		108
109	stream.r = read_stdin;	109	stream.r = read_stdin;
110	stream.param = 0;	110	stream.param = 0;
111	return stream;	111	return stream;
112	}	112	}
113		113
114	static stream_t open_stdout(void)	114	static stream_t open_stdout(void)
115	{	115	{
116	stream_t stream;	116	stream_t stream;
117	int res;	117	int res;
118		118
119	if (console_phone < 0) {	119	if (console_phone < 0) {
120	while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {	120	while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
121	volatile int a;	121	usleep(10000);
122	for (a = 0; a < 1048576; a++);	-
123	}	122	}
124	}	123	}
125		124
126	stream.w = write_stdout;	125	stream.w = write_stdout;
127	stream.param = 0;	126	stream.param = 0;
128	return stream;	127	return stream;
129	}	128	}
130		129
131	fd_t open(const char *fname, int flags)	130	fd_t open(const char *fname, int flags)
132	{	131	{
133	int c = 0;	132	int c = 0;
134		133
135	while (((streams[c].w) \|\| (streams[c].r)) && (c < FDS))	134	while (((streams[c].w) \|\| (streams[c].r)) && (c < FDS))
136	c++;	135	c++;
137	if (c == FDS)	136	if (c == FDS)
138	return EMFILE;	137	return EMFILE;
139		138
140	if (!strcmp(fname, "stdin")) {	139	if (!strcmp(fname, "stdin")) {
141	streams[c] = open_stdin();	140	streams[c] = open_stdin();
142	return c;	141	return c;
143	}	142	}
144		143
145	if (!strcmp(fname, "stdout")) {	144	if (!strcmp(fname, "stdout")) {
146	//streams[c].w = write_stdout;	145	//streams[c].w = write_stdout;
147	//return c;	146	//return c;
148	streams[c] = open_stdout();	147	streams[c] = open_stdout();
149	return c;	148	return c;
150	}	149	}
151		150
152	if (!strcmp(fname, "stderr")) {	151	if (!strcmp(fname, "stderr")) {
153	streams[c].w = write_stderr;	152	streams[c].w = write_stderr;
154	return c;	153	return c;
155	}	154	}
156	}	155	}
157		156
158		157
159	ssize_t write(int fd, const void *buf, size_t count)	158	ssize_t write(int fd, const void *buf, size_t count)
160	{	159	{
161	if (fd < FDS)	160	if (fd < FDS)
162	return streams[fd].w(streams[fd].param, buf, count);	161	return streams[fd].w(streams[fd].param, buf, count);
163		162
164	return 0;	163	return 0;
165	}	164	}
166		165
167	ssize_t read(int fd, void *buf, size_t count)	166	ssize_t read(int fd, void *buf, size_t count)
168	{	167	{
169	if (fd < FDS)	168	if (fd < FDS)
170	return streams[fd].r(streams[fd].param, buf, count);	169	return streams[fd].r(streams[fd].param, buf, count);
171		170
172	return 0;	171	return 0;
173	}	172	}
174		173
175		174

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/libc/generic/io/stream.c – Rev 1465 → 1476