Mercurial

comparison third_party/libuv/test/echo-server.c @ 160:948de3f54cea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added libuv
author June Park <parkjune1995@gmail.com>
date Wed, 14 Jan 2026 19:39:52 -0800
parents
children
comparison
equal deleted inserted replaced
159:05cf9467a1c3 160:948de3f54cea
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 "uv.h"
23 #include "task.h"
24 #include <stdio.h>
25 #include <stdlib.h>
26
27 typedef struct {
28 uv_write_t req;
29 uv_buf_t buf;
30 } write_req_t;
31
32 static uv_loop_t* loop;
33
34 static int server_closed;
35 static stream_type serverType;
36 static uv_tcp_t tcpServer;
37 static uv_udp_t udpServer;
38 static uv_pipe_t pipeServer;
39 static uv_handle_t* server;
40 static uv_udp_send_t* send_freelist;
41
42 static void after_write(uv_write_t* req, int status);
43 static void after_read(uv_stream_t*, ssize_t nread, const uv_buf_t* buf);
44 static void on_close(uv_handle_t* peer);
45 static void on_server_close(uv_handle_t* handle);
46 static void on_connection(uv_stream_t*, int status);
47
48
49 static void after_write(uv_write_t* req, int status) {
50 write_req_t* wr;
51
52 /* Free the read/write buffer and the request */
53 wr = (write_req_t*) req;
54 free(wr->buf.base);
55 free(wr);
56
57 if (status == 0)
58 return;
59
60 fprintf(stderr,
61 "uv_write error: %s - %s\n",
62 uv_err_name(status),
63 uv_strerror(status));
64 }
65
66
67 static void after_shutdown(uv_shutdown_t* req, int status) {
68 ASSERT_OK(status);
69 uv_close((uv_handle_t*) req->handle, on_close);
70 free(req);
71 }
72
73
74 static void on_shutdown(uv_shutdown_t* req, int status) {
75 ASSERT_OK(status);
76 free(req);
77 }
78
79
80 static void after_read(uv_stream_t* handle,
81 ssize_t nread,
82 const uv_buf_t* buf) {
83 int i;
84 write_req_t *wr;
85 uv_shutdown_t* sreq;
86 int shutdown = 0;
87
88 if (nread < 0) {
89 /* Error or EOF */
90 ASSERT_EQ(nread, UV_EOF);
91
92 free(buf->base);
93 sreq = malloc(sizeof* sreq);
94 if (uv_is_writable(handle)) {
95 ASSERT_OK(uv_shutdown(sreq, handle, after_shutdown));
96 }
97 return;
98 }
99
100 if (nread == 0) {
101 /* Everything OK, but nothing read. */
102 free(buf->base);
103 return;
104 }
105
106 /*
107 * Scan for the letter Q which signals that we should quit the server.
108 * If we get QS it means close the stream.
109 * If we get QSS it means shutdown the stream.
110 * If we get QSH it means disable linger before close the socket.
111 */
112 for (i = 0; i < nread; i++) {
113 if (buf->base[i] == 'Q') {
114 if (i + 1 < nread && buf->base[i + 1] == 'S') {
115 int reset = 0;
116 if (i + 2 < nread && buf->base[i + 2] == 'S')
117 shutdown = 1;
118 if (i + 2 < nread && buf->base[i + 2] == 'H')
119 reset = 1;
120 if (reset && handle->type == UV_TCP)
121 ASSERT_OK(uv_tcp_close_reset((uv_tcp_t*) handle, on_close));
122 else if (shutdown)
123 break;
124 else
125 uv_close((uv_handle_t*) handle, on_close);
126 free(buf->base);
127 return;
128 } else if (!server_closed) {
129 uv_close(server, on_server_close);
130 server_closed = 1;
131 }
132 }
133 }
134
135 wr = (write_req_t*) malloc(sizeof *wr);
136 ASSERT_NOT_NULL(wr);
137 wr->buf = uv_buf_init(buf->base, nread);
138
139 if (uv_write(&wr->req, handle, &wr->buf, 1, after_write)) {
140 FATAL("uv_write failed");
141 }
142
143 if (shutdown)
144 ASSERT_OK(uv_shutdown(malloc(sizeof* sreq), handle, on_shutdown));
145 }
146
147
148 static void on_close(uv_handle_t* peer) {
149 free(peer);
150 }
151
152
153 static void echo_alloc(uv_handle_t* handle,
154 size_t suggested_size,
155 uv_buf_t* buf) {
156 buf->base = malloc(suggested_size);
157 buf->len = suggested_size;
158 }
159
160 static void slab_alloc(uv_handle_t* handle,
161 size_t suggested_size,
162 uv_buf_t* buf) {
163 /* up to 16 datagrams at once */
164 static char slab[16 * 64 * 1024];
165 buf->base = slab;
166 buf->len = sizeof(slab);
167 }
168
169 static void on_connection(uv_stream_t* server, int status) {
170 uv_stream_t* stream;
171 int r;
172
173 if (status != 0) {
174 fprintf(stderr, "Connect error %s\n", uv_err_name(status));
175 }
176 ASSERT_OK(status);
177
178 switch (serverType) {
179 case TCP:
180 stream = malloc(sizeof(uv_tcp_t));
181 ASSERT_NOT_NULL(stream);
182 r = uv_tcp_init(loop, (uv_tcp_t*)stream);
183 ASSERT_OK(r);
184 break;
185
186 case PIPE:
187 stream = malloc(sizeof(uv_pipe_t));
188 ASSERT_NOT_NULL(stream);
189 r = uv_pipe_init(loop, (uv_pipe_t*)stream, 0);
190 ASSERT_OK(r);
191 break;
192
193 default:
194 ASSERT(0 && "Bad serverType");
195 abort();
196 }
197
198 /* associate server with stream */
199 stream->data = server;
200
201 r = uv_accept(server, stream);
202 ASSERT_OK(r);
203
204 r = uv_read_start(stream, echo_alloc, after_read);
205 ASSERT_OK(r);
206 }
207
208
209 static void on_server_close(uv_handle_t* handle) {
210 ASSERT_PTR_EQ(handle, server);
211 }
212
213 static uv_udp_send_t* send_alloc(void) {
214 uv_udp_send_t* req = send_freelist;
215 if (req != NULL)
216 send_freelist = req->data;
217 else
218 req = malloc(sizeof(*req));
219 return req;
220 }
221
222 static void on_send(uv_udp_send_t* req, int status) {
223 ASSERT_NOT_NULL(req);
224 ASSERT_OK(status);
225 req->data = send_freelist;
226 send_freelist = req;
227 }
228
229 static void on_recv(uv_udp_t* handle,
230 ssize_t nread,
231 const uv_buf_t* rcvbuf,
232 const struct sockaddr* addr,
233 unsigned flags) {
234 uv_buf_t sndbuf;
235 uv_udp_send_t* req;
236
237 if (nread == 0) {
238 /* Everything OK, but nothing read. */
239 return;
240 }
241
242 ASSERT_GT(nread, 0);
243 ASSERT_EQ(addr->sa_family, AF_INET);
244
245 req = send_alloc();
246 ASSERT_NOT_NULL(req);
247 sndbuf = uv_buf_init(rcvbuf->base, nread);
248 ASSERT_LE(0, uv_udp_send(req, handle, &sndbuf, 1, addr, on_send));
249 }
250
251 static int tcp4_echo_start(int port) {
252 struct sockaddr_in addr;
253 int r;
254
255 ASSERT_OK(uv_ip4_addr("127.0.0.1", port, &addr));
256
257 server = (uv_handle_t*)&tcpServer;
258 serverType = TCP;
259
260 r = uv_tcp_init(loop, &tcpServer);
261 if (r) {
262 /* TODO: Error codes */
263 fprintf(stderr, "Socket creation error\n");
264 return 1;
265 }
266
267 r = uv_tcp_bind(&tcpServer, (const struct sockaddr*) &addr, 0);
268 if (r) {
269 /* TODO: Error codes */
270 fprintf(stderr, "Bind error\n");
271 return 1;
272 }
273
274 r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);
275 if (r) {
276 /* TODO: Error codes */
277 fprintf(stderr, "Listen error %s\n", uv_err_name(r));
278 return 1;
279 }
280
281 return 0;
282 }
283
284
285 static int tcp6_echo_start(int port) {
286 struct sockaddr_in6 addr6;
287 int r;
288
289 ASSERT_OK(uv_ip6_addr("::1", port, &addr6));
290
291 server = (uv_handle_t*)&tcpServer;
292 serverType = TCP;
293
294 r = uv_tcp_init(loop, &tcpServer);
295 if (r) {
296 /* TODO: Error codes */
297 fprintf(stderr, "Socket creation error\n");
298 return 1;
299 }
300
301 /* IPv6 is optional as not all platforms support it */
302 r = uv_tcp_bind(&tcpServer, (const struct sockaddr*) &addr6, 0);
303 if (r) {
304 /* show message but return OK */
305 fprintf(stderr, "IPv6 not supported\n");
306 return 0;
307 }
308
309 r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);
310 if (r) {
311 /* TODO: Error codes */
312 fprintf(stderr, "Listen error\n");
313 return 1;
314 }
315
316 return 0;
317 }
318
319
320 static int udp4_echo_start(int port) {
321 struct sockaddr_in addr;
322 int r;
323
324 ASSERT_OK(uv_ip4_addr("127.0.0.1", port, &addr));
325 server = (uv_handle_t*)&udpServer;
326 serverType = UDP;
327
328 r = uv_udp_init(loop, &udpServer);
329 if (r) {
330 fprintf(stderr, "uv_udp_init: %s\n", uv_strerror(r));
331 return 1;
332 }
333
334 r = uv_udp_bind(&udpServer, (const struct sockaddr*) &addr, 0);
335 if (r) {
336 fprintf(stderr, "uv_udp_bind: %s\n", uv_strerror(r));
337 return 1;
338 }
339
340 r = uv_udp_recv_start(&udpServer, slab_alloc, on_recv);
341 if (r) {
342 fprintf(stderr, "uv_udp_recv_start: %s\n", uv_strerror(r));
343 return 1;
344 }
345
346 return 0;
347 }
348
349
350 static int pipe_echo_start(char* pipeName) {
351 int r;
352
353 #ifndef _WIN32
354 {
355 uv_fs_t req;
356 uv_fs_unlink(NULL, &req, pipeName, NULL);
357 uv_fs_req_cleanup(&req);
358 }
359 #endif
360
361 server = (uv_handle_t*)&pipeServer;
362 serverType = PIPE;
363
364 r = uv_pipe_init(loop, &pipeServer, 0);
365 if (r) {
366 fprintf(stderr, "uv_pipe_init: %s\n", uv_strerror(r));
367 return 1;
368 }
369
370 r = uv_pipe_bind(&pipeServer, pipeName);
371 if (r) {
372 fprintf(stderr, "uv_pipe_bind: %s\n", uv_strerror(r));
373 return 1;
374 }
375
376 r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
377 if (r) {
378 fprintf(stderr, "uv_pipe_listen: %s\n", uv_strerror(r));
379 return 1;
380 }
381
382 return 0;
383 }
384
385
386 HELPER_IMPL(tcp4_echo_server) {
387 loop = uv_default_loop();
388
389 if (tcp4_echo_start(TEST_PORT))
390 return 1;
391
392 notify_parent_process();
393 uv_run(loop, UV_RUN_DEFAULT);
394 return 0;
395 }
396
397
398 HELPER_IMPL(tcp6_echo_server) {
399 loop = uv_default_loop();
400
401 if (tcp6_echo_start(TEST_PORT))
402 return 1;
403
404 notify_parent_process();
405 uv_run(loop, UV_RUN_DEFAULT);
406 return 0;
407 }
408
409
410 HELPER_IMPL(pipe_echo_server) {
411 loop = uv_default_loop();
412
413 if (pipe_echo_start(TEST_PIPENAME))
414 return 1;
415
416 notify_parent_process();
417 uv_run(loop, UV_RUN_DEFAULT);
418 return 0;
419 }
420
421
422 HELPER_IMPL(udp4_echo_server) {
423 loop = uv_default_loop();
424
425 if (udp4_echo_start(TEST_PORT))
426 return 1;
427
428 notify_parent_process();
429 uv_run(loop, UV_RUN_DEFAULT);
430 return 0;
431 }