da62883d239e457b3572ddb778891824c29030e8
[platform/upstream/nodejs.git] / deps / uv / src / win / stream.c
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2  *
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to
5  * deal in the Software without restriction, including without limitation the
6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7  * sell copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  *
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19  * IN THE SOFTWARE.
20  */
21
22 #include <assert.h>
23
24 #include "uv.h"
25 #include "internal.h"
26 #include "handle-inl.h"
27 #include "req-inl.h"
28
29
30 int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
31   int err;
32
33   err = ERROR_INVALID_PARAMETER;
34   switch (stream->type) {
35     case UV_TCP:
36       err = uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
37       break;
38     case UV_NAMED_PIPE:
39       err = uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
40       break;
41     default:
42       assert(0);
43   }
44
45   return uv_translate_sys_error(err);
46 }
47
48
49 int uv_accept(uv_stream_t* server, uv_stream_t* client) {
50   int err;
51
52   err = ERROR_INVALID_PARAMETER;
53   switch (server->type) {
54     case UV_TCP:
55       err = uv_tcp_accept((uv_tcp_t*)server, (uv_tcp_t*)client);
56       break;
57     case UV_NAMED_PIPE:
58       err = uv_pipe_accept((uv_pipe_t*)server, client);
59       break;
60     default:
61       assert(0);
62   }
63
64   return uv_translate_sys_error(err);
65 }
66
67
68 int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
69     uv_read_cb read_cb) {
70   int err;
71
72   if (handle->flags & UV_HANDLE_READING) {
73     return UV_EALREADY;
74   }
75
76   if (!(handle->flags & UV_HANDLE_READABLE)) {
77     return UV_ENOTCONN;
78   }
79
80   err = ERROR_INVALID_PARAMETER;
81   switch (handle->type) {
82     case UV_TCP:
83       err = uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
84       break;
85     case UV_NAMED_PIPE:
86       err = uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
87       break;
88     case UV_TTY:
89       err = uv_tty_read_start((uv_tty_t*) handle, alloc_cb, read_cb);
90       break;
91     default:
92       assert(0);
93   }
94
95   return uv_translate_sys_error(err);
96 }
97
98
99 int uv_read2_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
100     uv_read2_cb read_cb) {
101   int err;
102
103   if (handle->flags & UV_HANDLE_READING) {
104     return UV_EALREADY;
105   }
106
107   if (!(handle->flags & UV_HANDLE_READABLE)) {
108     return UV_ENOTCONN;
109   }
110
111   err = ERROR_INVALID_PARAMETER;
112   switch (handle->type) {
113     case UV_NAMED_PIPE:
114       err = uv_pipe_read2_start((uv_pipe_t*)handle, alloc_cb, read_cb);
115       break;
116     default:
117       assert(0);
118   }
119
120   return uv_translate_sys_error(err);
121 }
122
123
124 int uv_read_stop(uv_stream_t* handle) {
125   int err;
126
127   if (!(handle->flags & UV_HANDLE_READING))
128     return 0;
129
130   err = 0;
131   if (handle->type == UV_TTY) {
132     err = uv_tty_read_stop((uv_tty_t*) handle);
133   } else {
134     handle->flags &= ~UV_HANDLE_READING;
135     DECREASE_ACTIVE_COUNT(handle->loop, handle);
136   }
137
138   return uv_translate_sys_error(err);
139 }
140
141
142 int uv_write(uv_write_t* req,
143              uv_stream_t* handle,
144              const uv_buf_t bufs[],
145              unsigned int nbufs,
146              uv_write_cb cb) {
147   uv_loop_t* loop = handle->loop;
148   int err;
149
150   if (!(handle->flags & UV_HANDLE_WRITABLE)) {
151     return UV_EPIPE;
152   }
153
154   err = ERROR_INVALID_PARAMETER;
155   switch (handle->type) {
156     case UV_TCP:
157       err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, nbufs, cb);
158       break;
159     case UV_NAMED_PIPE:
160       err = uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, nbufs, cb);
161       break;
162     case UV_TTY:
163       err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, nbufs, cb);
164       break;
165     default:
166       assert(0);
167   }
168
169   return uv_translate_sys_error(err);
170 }
171
172
173 int uv_write2(uv_write_t* req,
174               uv_stream_t* handle,
175               const uv_buf_t bufs[],
176               unsigned int nbufs,
177               uv_stream_t* send_handle,
178               uv_write_cb cb) {
179   uv_loop_t* loop = handle->loop;
180   int err;
181
182   if (!(handle->flags & UV_HANDLE_WRITABLE)) {
183     return UV_EPIPE;
184   }
185
186   err = ERROR_INVALID_PARAMETER;
187   switch (handle->type) {
188     case UV_NAMED_PIPE:
189       err = uv_pipe_write2(loop,
190                            req,
191                            (uv_pipe_t*) handle,
192                            bufs,
193                            nbufs,
194                            send_handle,
195                            cb);
196       break;
197     default:
198       assert(0);
199   }
200
201   return uv_translate_sys_error(err);
202 }
203
204
205 int uv_try_write(uv_stream_t* handle, const char* buf, size_t length) {
206   /* NOTE: Won't work with overlapped writes */
207   return UV_ENOSYS;
208 }
209
210
211 int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) {
212   uv_loop_t* loop = handle->loop;
213
214   if (!(handle->flags & UV_HANDLE_WRITABLE)) {
215     return UV_EPIPE;
216   }
217
218   uv_req_init(loop, (uv_req_t*) req);
219   req->type = UV_SHUTDOWN;
220   req->handle = handle;
221   req->cb = cb;
222
223   handle->flags &= ~UV_HANDLE_WRITABLE;
224   handle->shutdown_req = req;
225   handle->reqs_pending++;
226   REGISTER_HANDLE_REQ(loop, handle, req);
227
228   uv_want_endgame(loop, (uv_handle_t*)handle);
229
230   return 0;
231 }
232
233
234 int uv_is_readable(const uv_stream_t* handle) {
235   return !!(handle->flags & UV_HANDLE_READABLE);
236 }
237
238
239 int uv_is_writable(const uv_stream_t* handle) {
240   return !!(handle->flags & UV_HANDLE_WRITABLE);
241 }
242
243
244 int uv_stream_set_blocking(uv_stream_t* handle, int blocking) {
245   if (blocking != 0)
246     handle->flags |= UV_HANDLE_BLOCKING_WRITES;
247   else
248     handle->flags &= ~UV_HANDLE_BLOCKING_WRITES;
249
250   return 0;
251 }