Subversion Repositories HelenOS-historic

Rev

Rev 1519 | Rev 1610 | 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;
1536 palkovsky 54 
static stream_t streams[FDS];
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;
1536 palkovsky 119 
    stream.phone = console_phone;
1451 cejka 120 
    stream.param = 0;
1363 vana 121 
    return stream;
122 
}
123 
 
1508 vana 124 
static ssize_t write_null(void *param, const void *buf, size_t count)
125 
{
126 
    return count;
127 
}
128 
 
129 
 
1366 decky 130 
fd_t open(const char *fname, int flags)
1363 vana 131 
{
1366 decky 132 
    int c = 0;
133 
 
134 
    while (((streams[c].w) || (streams[c].r)) && (c < FDS))
135 
        c++;
136 
    if (c == FDS)
137 
        return EMFILE;
138 
 
139 
    if (!strcmp(fname, "stdin")) {
1451 cejka 140 
        streams[c] = open_stdin();
1363 vana 141 
        return c;
142 
    }
143 
 
1366 decky 144 
    if (!strcmp(fname, "stdout")) {
1451 cejka 145 
        streams[c] = open_stdout();
1363 vana 146 
        return c;
147 
    }
148 
 
1366 decky 149 
    if (!strcmp(fname, "stderr")) {
150 
        streams[c].w = write_stderr;
1363 vana 151 
        return c;
152 
    }
1508 vana 153 
    if (!strcmp(fname, "null")) {
154 
        streams[c].w = write_null;
155 
        return c;
156 
    }
1363 vana 157 
}
158 
 
159 
 
1366 decky 160 
ssize_t write(int fd, const void *buf, size_t count)
1363 vana 161 
{
1366 decky 162 
    if (fd < FDS)
163 
        return streams[fd].w(streams[fd].param, buf, count);
164 
 
1363 vana 165 
    return 0;
166 
}
1465 cejka 167 
 
168 
ssize_t read(int fd, void *buf, size_t count)
169 
{
170 
    if (fd < FDS)
171 
        return streams[fd].r(streams[fd].param, buf, count);
172 
 
173 
    return 0;
174 
}
175 
 
1519 palkovsky 176 
int get_fd_phone(int fd)
177 
{
178 
    if (fd >= FDS || fd < 0)
179 
        return -1;
180 
    return streams[fd].phone;
181 
}