libuv-svace-build

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

25
#include <stdio.h>
26
#include <string.h>
27

28
static uv_pipe_t channel;
29
static uv_tcp_t tcp_server;
30
static uv_tcp_t tcp_server2;
31
static uv_tcp_t tcp_connection;
32

33
static int exit_cb_called;
34
static int read_cb_called;
35
static int tcp_write_cb_called;
36
static int tcp_read_cb_called;
37
static int on_pipe_read_called;
38
static int local_conn_accepted;
39
static int remote_conn_accepted;
40
static int tcp_server_listening;
41
static uv_write_t write_req;
42
static uv_write_t write_req2;
43
static uv_write_t conn_notify_req;
44
static int close_cb_called;
45
static int connection_accepted;
46
static int tcp_conn_read_cb_called;
47
static int tcp_conn_write_cb_called;
48
static int send_zero_write;
49

50
typedef struct {
51
  uv_connect_t conn_req;
52
  uv_write_t tcp_write_req;
53
  uv_tcp_t conn;
54
} tcp_conn;
55

56
#define CONN_COUNT 100
57
#define BACKLOG 128
58

59

60
static void close_server_conn_cb(uv_handle_t* handle) {
61
  free(handle);
62
}
63

64

65
static void on_connection(uv_stream_t* server, int status) {
66
  uv_tcp_t* conn;
67
  int r;
68

69
  if (!local_conn_accepted) {
70
    /* Accept the connection and close it.  Also and close the server. */
71
    ASSERT_OK(status);
72
    ASSERT_PTR_EQ(&tcp_server, server);
73

74
    conn = malloc(sizeof(*conn));
75
    ASSERT_NOT_NULL(conn);
76
    r = uv_tcp_init(server->loop, conn);
77
    ASSERT_OK(r);
78

79
    r = uv_accept(server, (uv_stream_t*)conn);
80
    ASSERT_OK(r);
81

82
    uv_close((uv_handle_t*)conn, close_server_conn_cb);
83
    uv_close((uv_handle_t*)server, NULL);
84
    local_conn_accepted = 1;
85
  }
86
}
87

88

89
static void exit_cb(uv_process_t* process,
90
                    int64_t exit_status,
91
                    int term_signal) {
92
  printf("exit_cb\n");
93
  exit_cb_called++;
94
  ASSERT_OK(exit_status);
95
  ASSERT_OK(term_signal);
96
  uv_close((uv_handle_t*)process, NULL);
97
}
98

99

100
static void on_alloc(uv_handle_t* handle,
101
                     size_t suggested_size,
102
                     uv_buf_t* buf) {
103
  buf->base = malloc(suggested_size);
104
  buf->len = suggested_size;
105
}
106

107

108
static void close_client_conn_cb(uv_handle_t* handle) {
109
  tcp_conn* p = (tcp_conn*)handle->data;
110
  free(p);
111
}
112

113

114
static void connect_cb(uv_connect_t* req, int status) {
115
  uv_close((uv_handle_t*)req->handle, close_client_conn_cb);
116
}
117

118

119
static void make_many_connections(void) {
120
  tcp_conn* conn;
121
  struct sockaddr_in addr;
122
  int r, i;
123

124
  for (i = 0; i < CONN_COUNT; i++) {
125
    conn = malloc(sizeof(*conn));
126
    ASSERT_NOT_NULL(conn);
127

128
    r = uv_tcp_init(uv_default_loop(), &conn->conn);
129
    ASSERT_OK(r);
130
    ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
131

132
    r = uv_tcp_connect(&conn->conn_req,
133
                       (uv_tcp_t*) &conn->conn,
134
                       (const struct sockaddr*) &addr,
135
                       connect_cb);
136
    ASSERT_OK(r);
137

138
    conn->conn.data = conn;
139
  }
140
}
141

142

143
static void on_read(uv_stream_t* handle,
144
                    ssize_t nread,
145
                    const uv_buf_t* buf) {
146
  int r;
147
  uv_pipe_t* pipe;
148
  uv_handle_type pending;
149
  uv_buf_t outbuf;
150

151
  pipe = (uv_pipe_t*) handle;
152

153
  if (nread == 0) {
154
    /* Everything OK, but nothing read. */
155
    free(buf->base);
156
    return;
157
  }
158

159
  if (nread < 0) {
160
    if (nread == UV_EOF) {
161
      free(buf->base);
162
      return;
163
    }
164

165
    printf("error recving on channel: %s\n", uv_strerror(nread));
166
    abort();
167
  }
168

169
  fprintf(stderr, "got %d bytes\n", (int)nread);
170

171
  pending = uv_pipe_pending_type(pipe);
172
  if (!tcp_server_listening) {
173
    ASSERT_EQ(1, uv_pipe_pending_count(pipe));
174
    ASSERT_GT(nread, 0);
175
    ASSERT_NOT_NULL(buf->base);
176
    ASSERT_NE(pending, UV_UNKNOWN_HANDLE);
177
    read_cb_called++;
178

179
    /* Accept the pending TCP server, and start listening on it. */
180
    ASSERT_EQ(pending, UV_TCP);
181
    r = uv_tcp_init(uv_default_loop(), &tcp_server);
182
    ASSERT_OK(r);
183

184
    r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
185
    ASSERT_OK(r);
186

187
    r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
188
    ASSERT_OK(r);
189

190
    tcp_server_listening = 1;
191

192
    /* Make sure that the expected data is correctly multiplexed. */
193
    ASSERT_MEM_EQ("hello\n", buf->base, nread);
194

195
    outbuf = uv_buf_init("foobar\n", 7);
196
    r = uv_write(&write_req, (uv_stream_t*)pipe, &outbuf, 1, NULL);
197
    ASSERT_OK(r);
198

199
    /* Create a bunch of connections to get both servers to accept. */
200
    make_many_connections();
201
  } else if (memcmp("accepted_connection\n", buf->base, nread) == 0) {
202
    /* Remote server has accepted a connection.  Close the channel. */
203
    ASSERT_OK(uv_pipe_pending_count(pipe));
204
    ASSERT_EQ(pending, UV_UNKNOWN_HANDLE);
205
    remote_conn_accepted = 1;
206
    uv_close((uv_handle_t*)&channel, NULL);
207
  }
208

209
  free(buf->base);
210
}
211

212
#ifdef _WIN32
213
static void on_read_listen_after_bound_twice(uv_stream_t* handle,
214
                                             ssize_t nread,
215
                                             const uv_buf_t* buf) {
216
  int r;
217
  uv_pipe_t* pipe;
218
  uv_handle_type pending;
219

220
  pipe = (uv_pipe_t*) handle;
221

222
  if (nread == 0) {
223
    /* Everything OK, but nothing read. */
224
    free(buf->base);
225
    return;
226
  }
227

228
  if (nread < 0) {
229
    if (nread == UV_EOF) {
230
      free(buf->base);
231
      return;
232
    }
233

234
    printf("error recving on channel: %s\n", uv_strerror(nread));
235
    abort();
236
  }
237

238
  fprintf(stderr, "got %d bytes\n", (int)nread);
239

240
  ASSERT_GT(uv_pipe_pending_count(pipe), 0);
241
  pending = uv_pipe_pending_type(pipe);
242
  ASSERT_GT(nread, 0);
243
  ASSERT_NOT_NULL(buf->base);
244
  ASSERT_NE(pending, UV_UNKNOWN_HANDLE);
245
  read_cb_called++;
246

247
  if (read_cb_called == 1) {
248
    /* Accept the first TCP server, and start listening on it. */
249
    ASSERT_EQ(pending, UV_TCP);
250
    r = uv_tcp_init(uv_default_loop(), &tcp_server);
251
    ASSERT_OK(r);
252

253
    r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
254
    ASSERT_OK(r);
255

256
    r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
257
    ASSERT_OK(r);
258
  } else if (read_cb_called == 2) {
259
    /* Accept the second TCP server, and start listening on it. */
260
    ASSERT_EQ(pending, UV_TCP);
261
    r = uv_tcp_init(uv_default_loop(), &tcp_server2);
262
    ASSERT_OK(r);
263

264
    r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server2);
265
    ASSERT_OK(r);
266

267
    r = uv_listen((uv_stream_t*)&tcp_server2, BACKLOG, on_connection);
268
    ASSERT_EQ(r, UV_EADDRINUSE);
269

270
    uv_close((uv_handle_t*)&tcp_server, NULL);
271
    uv_close((uv_handle_t*)&tcp_server2, NULL);
272
    ASSERT_OK(uv_pipe_pending_count(pipe));
273
    uv_close((uv_handle_t*)&channel, NULL);
274
  }
275

276
  free(buf->base);
277
}
278
#endif
279

280
void spawn_helper(uv_pipe_t* channel,
281
                  uv_process_t* process,
282
                  const char* helper) {
283
  uv_process_options_t options;
284
  size_t exepath_size;
285
  char exepath[1024];
286
  char* args[3];
287
  int r;
288
  uv_stdio_container_t stdio[3];
289

290
  r = uv_pipe_init(uv_default_loop(), channel, 1);
291
  ASSERT_OK(r);
292
  ASSERT_NE(0, channel->ipc);
293

294
  exepath_size = sizeof(exepath);
295
  r = uv_exepath(exepath, &exepath_size);
296
  ASSERT_OK(r);
297

298
  exepath[exepath_size] = '\0';
299
  args[0] = exepath;
300
  args[1] = (char*)helper;
301
  args[2] = NULL;
302

303
  memset(&options, 0, sizeof(options));
304
  options.file = exepath;
305
  options.args = args;
306
  options.exit_cb = exit_cb;
307
  options.stdio = stdio;
308
  options.stdio_count = ARRAY_SIZE(stdio);
309

310
  stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE | UV_WRITABLE_PIPE;
311
  stdio[0].data.stream = (uv_stream_t*) channel;
312
  stdio[1].flags = UV_INHERIT_FD;
313
  stdio[1].data.fd = 1;
314
  stdio[2].flags = UV_INHERIT_FD;
315
  stdio[2].data.fd = 2;
316

317
  r = uv_spawn(uv_default_loop(), process, &options);
318
  ASSERT_OK(r);
319
}
320

321

322
static void on_tcp_write(uv_write_t* req, int status) {
323
  ASSERT_OK(status);
324
  ASSERT_PTR_EQ(req->handle, &tcp_connection);
325
  tcp_write_cb_called++;
326
}
327

328

329
static void on_read_alloc(uv_handle_t* handle,
330
                          size_t suggested_size,
331
                          uv_buf_t* buf) {
332
  buf->base = malloc(suggested_size);
333
  buf->len = suggested_size;
334
}
335

336

337
static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
338
  ASSERT_GT(nread, 0);
339
  ASSERT_MEM_EQ("hello again\n", buf->base, nread);
340
  ASSERT_PTR_EQ(tcp, &tcp_connection);
341
  free(buf->base);
342

343
  tcp_read_cb_called++;
344

345
  uv_close((uv_handle_t*)tcp, NULL);
346
  uv_close((uv_handle_t*)&channel, NULL);
347
}
348

349

350
static void on_read_connection(uv_stream_t* handle,
351
                               ssize_t nread,
352
                               const uv_buf_t* buf) {
353
  int r;
354
  uv_buf_t outbuf;
355
  uv_pipe_t* pipe;
356
  uv_handle_type pending;
357

358
  pipe = (uv_pipe_t*) handle;
359
  if (nread == 0) {
360
    /* Everything OK, but nothing read. */
361
    free(buf->base);
362
    return;
363
  }
364

365
  if (nread < 0) {
366
    if (nread == UV_EOF) {
367
      free(buf->base);
368
      return;
369
    }
370

371
    printf("error recving on channel: %s\n", uv_strerror(nread));
372
    abort();
373
  }
374

375
  fprintf(stderr, "got %d bytes\n", (int)nread);
376

377
  ASSERT_EQ(1, uv_pipe_pending_count(pipe));
378
  pending = uv_pipe_pending_type(pipe);
379

380
  ASSERT_GT(nread, 0);
381
  ASSERT_NOT_NULL(buf->base);
382
  ASSERT_NE(pending, UV_UNKNOWN_HANDLE);
383
  read_cb_called++;
384

385
  /* Accept the pending TCP connection */
386
  ASSERT_EQ(pending, UV_TCP);
387
  r = uv_tcp_init(uv_default_loop(), &tcp_connection);
388
  ASSERT_OK(r);
389

390
  r = uv_accept(handle, (uv_stream_t*)&tcp_connection);
391
  ASSERT_OK(r);
392

393
  /* Make sure that the expected data is correctly multiplexed. */
394
  ASSERT_MEM_EQ("hello\n", buf->base, nread);
395

396
  /* Write/read to/from the connection */
397
  outbuf = uv_buf_init("world\n", 6);
398
  r = uv_write(&write_req, (uv_stream_t*)&tcp_connection, &outbuf, 1,
399
    on_tcp_write);
400
  ASSERT_OK(r);
401

402
  r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read);
403
  ASSERT_OK(r);
404

405
  free(buf->base);
406
}
407

408

409
static void on_read_send_zero(uv_stream_t* handle,
410
                              ssize_t nread,
411
                              const uv_buf_t* buf) {
412
  ASSERT(nread == 0 || nread == UV_EOF);
413
  free(buf->base);
414
}
415

416

417
static int run_ipc_test(const char* helper, uv_read_cb read_cb) {
418
  uv_process_t process;
419
  int r;
420

421
  spawn_helper(&channel, &process, helper);
422
  uv_read_start((uv_stream_t*)&channel, on_alloc, read_cb);
423

424
  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
425
  ASSERT_OK(r);
426

427
  MAKE_VALGRIND_HAPPY(uv_default_loop());
428
  return 0;
429
}
430

431

432
TEST_IMPL(ipc_listen_before_write) {
433
#if defined(NO_SEND_HANDLE_ON_PIPE)
434
  RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
435
#endif
436
  int r = run_ipc_test("ipc_helper_listen_before_write", on_read);
437
  ASSERT_EQ(1, local_conn_accepted);
438
  ASSERT_EQ(1, remote_conn_accepted);
439
  ASSERT_EQ(1, read_cb_called);
440
  ASSERT_EQ(1, exit_cb_called);
441
  return r;
442
}
443

444

445
TEST_IMPL(ipc_listen_after_write) {
446
#if defined(NO_SEND_HANDLE_ON_PIPE)
447
  RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
448
#endif
449
  int r = run_ipc_test("ipc_helper_listen_after_write", on_read);
450
  ASSERT_EQ(1, local_conn_accepted);
451
  ASSERT_EQ(1, remote_conn_accepted);
452
  ASSERT_EQ(1, read_cb_called);
453
  ASSERT_EQ(1, exit_cb_called);
454
  return r;
455
}
456

457

458
TEST_IMPL(ipc_tcp_connection) {
459
#if defined(NO_SEND_HANDLE_ON_PIPE)
460
  RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
461
#endif
462
  int r = run_ipc_test("ipc_helper_tcp_connection", on_read_connection);
463
  ASSERT_EQ(1, read_cb_called);
464
  ASSERT_EQ(1, tcp_write_cb_called);
465
  ASSERT_EQ(1, tcp_read_cb_called);
466
  ASSERT_EQ(1, exit_cb_called);
467
  return r;
468
}
469

470

471
#ifdef _WIN32
472
TEST_IMPL(listen_with_simultaneous_accepts) {
473
  uv_tcp_t server;
474
  int r;
475
  struct sockaddr_in addr;
476

477
  ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
478

479
  r = uv_tcp_init(uv_default_loop(), &server);
480
  ASSERT_OK(r);
481

482
  r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
483
  ASSERT_OK(r);
484

485
  r = uv_tcp_simultaneous_accepts(&server, 1);
486
  ASSERT_OK(r);
487

488
  r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
489
  ASSERT_OK(r);
490
  ASSERT_EQ(32, server.reqs_pending);
491

492
  MAKE_VALGRIND_HAPPY(uv_default_loop());
493
  return 0;
494
}
495

496

497
TEST_IMPL(listen_no_simultaneous_accepts) {
498
  uv_tcp_t server;
499
  int r;
500
  struct sockaddr_in addr;
501

502
  ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
503

504
  r = uv_tcp_init(uv_default_loop(), &server);
505
  ASSERT_OK(r);
506

507
  r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
508
  ASSERT_OK(r);
509

510
  r = uv_tcp_simultaneous_accepts(&server, 0);
511
  ASSERT_OK(r);
512

513
  r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
514
  ASSERT_OK(r);
515
  ASSERT_EQ(1, server.reqs_pending);
516

517
  MAKE_VALGRIND_HAPPY(uv_default_loop());
518
  return 0;
519
}
520

521
TEST_IMPL(ipc_listen_after_bind_twice) {
522
#if defined(NO_SEND_HANDLE_ON_PIPE)
523
  RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE);
524
#endif
525
  int r = run_ipc_test("ipc_helper_bind_twice", on_read_listen_after_bound_twice);
526
  ASSERT_EQ(2, read_cb_called);
527
  ASSERT_EQ(1, exit_cb_called);
528
  return r;
529
}
530
#endif
531

532
TEST_IMPL(ipc_send_zero) {
533
  int r;
534
  r = run_ipc_test("ipc_helper_send_zero", on_read_send_zero);
535
  ASSERT_OK(r);
536
  return 0;
537
}
538

539

540
/* Everything here runs in a child process. */
541

542
static tcp_conn conn;
543

544

545
static void close_cb(uv_handle_t* handle) {
546
  close_cb_called++;
547
}
548

549

550
static void conn_notify_write_cb(uv_write_t* req, int status) {
551
  uv_close((uv_handle_t*)&tcp_server, close_cb);
552
  uv_close((uv_handle_t*)&channel, close_cb);
553
}
554

555

556
static void tcp_connection_write_cb(uv_write_t* req, int status) {
557
  ASSERT_PTR_EQ(&conn.conn, req->handle);
558
  uv_close((uv_handle_t*)req->handle, close_cb);
559
  uv_close((uv_handle_t*)&channel, close_cb);
560
  uv_close((uv_handle_t*)&tcp_server, close_cb);
561
  tcp_conn_write_cb_called++;
562
}
563

564

565
static void send_zero_write_cb(uv_write_t* req, int status) {
566
  ASSERT_OK(status);
567
  send_zero_write++;
568
}
569

570
static void on_tcp_child_process_read(uv_stream_t* tcp,
571
                                      ssize_t nread,
572
                                      const uv_buf_t* buf) {
573
  uv_buf_t outbuf;
574
  int r;
575

576
  if (nread < 0) {
577
    if (nread == UV_EOF) {
578
      free(buf->base);
579
      return;
580
    }
581

582
    printf("error recving on tcp connection: %s\n", uv_strerror(nread));
583
    abort();
584
  }
585

586
  ASSERT_GT(nread, 0);
587
  ASSERT_MEM_EQ("world\n", buf->base, nread);
588
  on_pipe_read_called++;
589
  free(buf->base);
590

591
  /* Write to the socket */
592
  outbuf = uv_buf_init("hello again\n", 12);
593
  r = uv_write(&conn.tcp_write_req, tcp, &outbuf, 1, tcp_connection_write_cb);
594
  ASSERT_OK(r);
595

596
  tcp_conn_read_cb_called++;
597
}
598

599

600
static void connect_child_process_cb(uv_connect_t* req, int status) {
601
  int r;
602

603
  ASSERT_OK(status);
604
  r = uv_read_start(req->handle, on_read_alloc, on_tcp_child_process_read);
605
  ASSERT_OK(r);
606
}
607

608

609
static void ipc_on_connection(uv_stream_t* server, int status) {
610
  int r;
611
  uv_buf_t buf;
612

613
  if (!connection_accepted) {
614
    /*
615
     * Accept the connection and close it.  Also let the other
616
     * side know.
617
     */
618
    ASSERT_OK(status);
619
    ASSERT_PTR_EQ(&tcp_server, server);
620

621
    r = uv_tcp_init(server->loop, &conn.conn);
622
    ASSERT_OK(r);
623

624
    r = uv_accept(server, (uv_stream_t*)&conn.conn);
625
    ASSERT_OK(r);
626

627
    uv_close((uv_handle_t*)&conn.conn, close_cb);
628

629
    buf = uv_buf_init("accepted_connection\n", 20);
630
    r = uv_write2(&conn_notify_req, (uv_stream_t*)&channel, &buf, 1,
631
      NULL, conn_notify_write_cb);
632
    ASSERT_OK(r);
633

634
    connection_accepted = 1;
635
  }
636
}
637

638

639
static void close_and_free_cb(uv_handle_t* handle) {
640
  close_cb_called++;
641
  free(handle);
642
}
643

644
static void ipc_on_connection_tcp_conn(uv_stream_t* server, int status) {
645
  int r;
646
  uv_buf_t buf;
647
  uv_tcp_t* conn;
648

649
  ASSERT_OK(status);
650
  ASSERT_PTR_EQ(&tcp_server, server);
651

652
  conn = malloc(sizeof(*conn));
653
  ASSERT_NOT_NULL(conn);
654

655
  r = uv_tcp_init(server->loop, conn);
656
  ASSERT_OK(r);
657

658
  r = uv_accept(server, (uv_stream_t*)conn);
659
  ASSERT_OK(r);
660

661
  /* Send the accepted connection to the other process */
662
  buf = uv_buf_init("hello\n", 6);
663
  r = uv_write2(&conn_notify_req, (uv_stream_t*)&channel, &buf, 1,
664
    (uv_stream_t*)conn, NULL);
665
  ASSERT_OK(r);
666

667
  r = uv_read_start((uv_stream_t*) conn,
668
                    on_read_alloc,
669
                    on_tcp_child_process_read);
670
  ASSERT_OK(r);
671

672
  uv_close((uv_handle_t*)conn, close_and_free_cb);
673
}
674

675

676
int ipc_helper(int listen_after_write) {
677
  /*
678
   * This is launched from test-ipc.c. stdin is a duplex channel that we
679
   * over which a handle will be transmitted.
680
   */
681
  struct sockaddr_in addr;
682
  int r;
683
  uv_buf_t buf;
684

685
  ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
686

687
  r = uv_pipe_init(uv_default_loop(), &channel, 1);
688
  ASSERT_OK(r);
689

690
  uv_pipe_open(&channel, 0);
691

692
  ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
693
  ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
694
  ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
695

696
  r = uv_tcp_init(uv_default_loop(), &tcp_server);
697
  ASSERT_OK(r);
698

699
  r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
700
  ASSERT_OK(r);
701

702
  if (!listen_after_write) {
703
    r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection);
704
    ASSERT_OK(r);
705
  }
706

707
  buf = uv_buf_init("hello\n", 6);
708
  r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1,
709
      (uv_stream_t*)&tcp_server, NULL);
710
  ASSERT_OK(r);
711

712
  if (listen_after_write) {
713
    r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection);
714
    ASSERT_OK(r);
715
  }
716

717
  notify_parent_process();
718
  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
719
  ASSERT_OK(r);
720

721
  ASSERT_EQ(1, connection_accepted);
722
  ASSERT_EQ(3, close_cb_called);
723

724
  MAKE_VALGRIND_HAPPY(uv_default_loop());
725
  return 0;
726
}
727

728

729
int ipc_helper_tcp_connection(void) {
730
  /*
731
   * This is launched from test-ipc.c. stdin is a duplex channel
732
   * over which a handle will be transmitted.
733
   */
734

735
  int r;
736
  struct sockaddr_in addr;
737

738
  r = uv_pipe_init(uv_default_loop(), &channel, 1);
739
  ASSERT_OK(r);
740

741
  uv_pipe_open(&channel, 0);
742

743
  ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
744
  ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
745
  ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
746

747
  r = uv_tcp_init(uv_default_loop(), &tcp_server);
748
  ASSERT_OK(r);
749

750
  ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
751

752
  r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
753
  ASSERT_OK(r);
754

755
  r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection_tcp_conn);
756
  ASSERT_OK(r);
757

758
  /* Make a connection to the server */
759
  r = uv_tcp_init(uv_default_loop(), &conn.conn);
760
  ASSERT_OK(r);
761

762
  ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
763

764
  r = uv_tcp_connect(&conn.conn_req,
765
                     (uv_tcp_t*) &conn.conn,
766
                     (const struct sockaddr*) &addr,
767
                     connect_child_process_cb);
768
  ASSERT_OK(r);
769

770
  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
771
  ASSERT_OK(r);
772

773
  ASSERT_EQ(1, tcp_conn_read_cb_called);
774
  ASSERT_EQ(1, tcp_conn_write_cb_called);
775
  ASSERT_EQ(4, close_cb_called);
776

777
  MAKE_VALGRIND_HAPPY(uv_default_loop());
778
  return 0;
779
}
780

781
int ipc_helper_bind_twice(void) {
782
  /*
783
   * This is launched from test-ipc.c. stdin is a duplex channel
784
   * over which two handles will be transmitted.
785
   */
786
  struct sockaddr_in addr;
787
  int r;
788
  uv_buf_t buf;
789

790
  ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
791

792
  r = uv_pipe_init(uv_default_loop(), &channel, 1);
793
  ASSERT_OK(r);
794

795
  uv_pipe_open(&channel, 0);
796

797
  ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
798
  ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
799
  ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
800

801
  buf = uv_buf_init("hello\n", 6);
802

803
  r = uv_tcp_init(uv_default_loop(), &tcp_server);
804
  ASSERT_OK(r);
805
  r = uv_tcp_init(uv_default_loop(), &tcp_server2);
806
  ASSERT_OK(r);
807

808
  r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);
809
  ASSERT_OK(r);
810
  r = uv_tcp_bind(&tcp_server2, (const struct sockaddr*) &addr, 0);
811
  ASSERT_OK(r);
812

813
  r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1,
814
                (uv_stream_t*)&tcp_server, NULL);
815
  ASSERT_OK(r);
816
  r = uv_write2(&write_req2, (uv_stream_t*)&channel, &buf, 1,
817
                (uv_stream_t*)&tcp_server2, NULL);
818
  ASSERT_OK(r);
819

820
  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
821
  ASSERT_OK(r);
822

823
  MAKE_VALGRIND_HAPPY(uv_default_loop());
824
  return 0;
825
}
826

827
int ipc_helper_send_zero(void) {
828
  int r;
829
  uv_buf_t zero_buf;
830

831
  zero_buf = uv_buf_init(0, 0);
832

833
  r = uv_pipe_init(uv_default_loop(), &channel, 0);
834
  ASSERT_OK(r);
835

836
  uv_pipe_open(&channel, 0);
837

838
  ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel));
839
  ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel));
840
  ASSERT_OK(uv_is_closing((uv_handle_t*) &channel));
841

842
  r = uv_write(&write_req,
843
               (uv_stream_t*)&channel,
844
               &zero_buf,
845
               1,
846
               send_zero_write_cb);
847

848
  ASSERT_OK(r);
849

850
  r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
851
  ASSERT_OK(r);
852

853
  ASSERT_EQ(1, send_zero_write);
854

855
  MAKE_VALGRIND_HAPPY(uv_default_loop());
856
  return 0;
857
}
858