Subversion Repositories HelenOS-historic

Rev

Rev 1518 | Rev 1536 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1465 cejka 1 
/*
2 
 * Copyright (C) 2006 Josef Cejka
3 
 * Copyright (C) 2006 Jakub Vana
4 
 * All rights reserved.
5 
 *
6 
 * Redistribution and use in source and binary forms, with or without
7 
 * modification, are permitted provided that the following conditions
8 
 * are met:
9 
 *
10 
 * - Redistributions of source code must retain the above copyright
11 
 *   notice, this list of conditions and the following disclaimer.
12 
 * - Redistributions in binary form must reproduce the above copyright
13 
 *   notice, this list of conditions and the following disclaimer in the
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
16 
 *   derived from this software without specific prior written permission.
17 
 *
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
20 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
27 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 
 */
29 
 
30 
 
1363 vana 31 
#include <io/io.h>
32 
#include <io/stream.h>
33 
#include <string.h>
34 
#include <malloc.h>
35 
#include <libc.h>
36 
#include <ipc/ipc.h>
37 
#include <ipc/ns.h>
38 
#include <ipc/fb.h>
39 
#include <ipc/services.h>
1451 cejka 40 
#include <console.h>
1465 cejka 41 
#include <unistd.h>
1519 palkovsky 42 
#include <async.h>
1363 vana 43 
 
44 
#define FDS 32
45 
 
1366 decky 46 
typedef struct stream_t {
1363 vana 47 
    pwritefn_t w;
48 
    preadfn_t r;
49 
    void * param;
1519 palkovsky 50 
    int phone;
1366 decky 51 
} stream_t;
1363 vana 52 
 
1519 palkovsky 53 
static int console_phone = -1;
54 
static stream_t streams[FDS] = {{0, 0, 0, -1}};
1363 vana 55 
 
1451 cejka 56 
static ssize_t write_stderr(void *param, const void *buf, size_t count)
1363 vana 57 
{
1451 cejka 58 
    return count;
59 
}
60 
 
1465 cejka 61 
static ssize_t read_stdin(void *param, void *buf, size_t count)
1451 cejka 62 
{
1363 vana 63 
    ipcarg_t r0,r1;
1465 cejka 64 
    size_t i = 0;
65 
 
66 
    while (i < count) {
1519 palkovsky 67 
        if (sync_send_2(streams[0].phone, CONSOLE_GETCHAR, 0, 0, &r0, &r1) < 0) {
1465 cejka 68 
            return -1;
69 
        }
70 
        ((char *)buf)[i++] = r0;
71 
    }
72 
    return i;
1363 vana 73 
}
1465 cejka 74 
 
1451 cejka 75 
static ssize_t write_stdout(void *param, const void *buf, size_t count)
1363 vana 76 
{
77 
    int i;
1451 cejka 78 
    ipcarg_t r0,r1;
79 
 
1366 decky 80 
    for (i = 0; i < count; i++)
1519 palkovsky 81 
        send_call(streams[1].phone, CONSOLE_PUTCHAR, ((const char *)buf)[i]);
1363 vana 82 
 
83 
    return count;
84 
}
85 
 
86 
 
87 
 
1451 cejka 88 
static stream_t open_stdin(void)
1363 vana 89 
{
90 
    stream_t stream;
91 
    int phoneid;
92 
    int res;
93 
 
1451 cejka 94 
    if (console_phone < 0) {
95 
        while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
1452 palkovsky 96 
            usleep(10000);
1451 cejka 97 
        }
1363 vana 98 
    }
99 
 
1451 cejka 100 
    stream.r = read_stdin;
101 
    stream.param = 0;
1519 palkovsky 102 
    stream.phone = console_phone;
103 
 
1451 cejka 104 
    return stream;
105 
}
106 
 
107 
static stream_t open_stdout(void)
108 
{
109 
    stream_t stream;
110 
    int res;
1519 palkovsky 111 
 
1451 cejka 112 
    if (console_phone < 0) {
113 
        while ((console_phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0)) < 0) {
1476 cejka 114 
            usleep(10000);
1451 cejka 115 
        }
116 
    }
1363 vana 117 
 
1451 cejka 118 
    stream.w = write_stdout;
119 
    stream.param = 0;
1363 vana 120 
    return stream;
121 
}
122 
 
1508 vana 123 
static ssize_t write_null(void *param, const void *buf, size_t count)
124 
{
125 
    return count;
126 
}
127 
 
128 
 
1366 decky 129 
fd_t open(const char *fname, int flags)
1363 vana 130 
{
1366 decky 131 
    int c = 0;
132 
 
133 
    while (((streams[c].w) || (streams[c].r)) && (c < FDS))
134 
        c++;
135 
    if (c == FDS)
136 
        return EMFILE;
137 
 
138 
    if (!strcmp(fname, "stdin")) {
1451 cejka 139 
        streams[c] = open_stdin();
1363 vana 140 
        return c;
141 
    }
142 
 
1366 decky 143 
    if (!strcmp(fname, "stdout")) {
1451 cejka 144 
        streams[c] = open_stdout();
1363 vana 145 
        return c;
146 
    }
147 
 
1366 decky 148 
    if (!strcmp(fname, "stderr")) {
149 
        streams[c].w = write_stderr;
1363 vana 150 
        return c;
151 
    }
1508 vana 152 
    if (!strcmp(fname, "null")) {
153 
        streams[c].w = write_null;
154 
        return c;
155 
    }
1363 vana 156 
}
157 
 
158 
 
1366 decky 159 
ssize_t write(int fd, const void *buf, size_t count)
1363 vana 160 
{
1366 decky 161 
    if (fd < FDS)
162 
        return streams[fd].w(streams[fd].param, buf, count);
163 
 
1363 vana 164 
    return 0;
165 
}
1465 cejka 166 
 
167 
ssize_t read(int fd, void *buf, size_t count)
168 
{
169 
    if (fd < FDS)
170 
        return streams[fd].r(streams[fd].param, buf, count);
171 
 
172 
    return 0;
173 
}
174 
 
1519 palkovsky 175 
int get_fd_phone(int fd)
176 
{
177 
    if (fd >= FDS || fd < 0)
178 
        return -1;
179 
    return streams[fd].phone;
180 
}