1// Copyright 2016 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <assert.h>
6#include <zircon/syscalls.h>
7#include <unittest/unittest.h>
8#include <stdbool.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <unistd.h>
12
13static zx_signals_t get_satisfied_signals(zx_handle_t handle) {
14    zx_signals_t pending = 0;
15    zx_object_wait_one(handle, 0u, 0u, &pending);
16    return pending;
17}
18
19static bool socket_basic(void) {
20    BEGIN_TEST;
21
22    zx_status_t status;
23    size_t count;
24
25    zx_handle_t h[2];
26    uint32_t read_data[] = { 0, 0 };
27
28    status = zx_socket_create(0, h, h + 1);
29    ASSERT_EQ(status, ZX_OK, "");
30
31    // Check that koids line up.
32    zx_info_handle_basic_t info[2] = {};
33    status = zx_object_get_info(h[0], ZX_INFO_HANDLE_BASIC, &info[0], sizeof(info[0]), NULL, NULL);
34    ASSERT_EQ(status, ZX_OK, "");
35    status = zx_object_get_info(h[1], ZX_INFO_HANDLE_BASIC, &info[1], sizeof(info[1]), NULL, NULL);
36    ASSERT_EQ(status, ZX_OK, "");
37    ASSERT_NE(info[0].koid, 0u, "zero koid!");
38    ASSERT_NE(info[0].related_koid, 0u, "zero peer koid!");
39    ASSERT_NE(info[1].koid, 0u, "zero koid!");
40    ASSERT_NE(info[1].related_koid, 0u, "zero peer koid!");
41    ASSERT_EQ(info[0].koid, info[1].related_koid, "mismatched koids!");
42    ASSERT_EQ(info[1].koid, info[0].related_koid, "mismatched koids!");
43
44    status = zx_socket_read(h[0], 0u, read_data, sizeof(read_data), &count);
45    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
46
47    static const uint32_t write_data[] = { 0xdeadbeef, 0xc0ffee };
48    status = zx_socket_write(h[0], 0u, &write_data[0], sizeof(write_data[0]), &count);
49    EXPECT_EQ(status, ZX_OK, "");
50    EXPECT_EQ(count, sizeof(write_data[0]), "");
51    status = zx_socket_write(h[0], 0u, &write_data[1], sizeof(write_data[1]), &count);
52    EXPECT_EQ(status, ZX_OK, "");
53    EXPECT_EQ(count, sizeof(write_data[1]), "");
54
55    status = zx_socket_read(h[1], 0u, read_data, sizeof(read_data), &count);
56    EXPECT_EQ(status, ZX_OK, "");
57    EXPECT_EQ(count, sizeof(read_data), "");
58    EXPECT_EQ(read_data[0], write_data[0], "");
59    EXPECT_EQ(read_data[1], write_data[1], "");
60
61    status = zx_socket_write(h[0], 0u, write_data, sizeof(write_data), NULL);
62    EXPECT_EQ(status, ZX_OK, "");
63    memset(read_data, 0, sizeof(read_data));
64    status = zx_socket_read(h[1], 0u, read_data, sizeof(read_data), NULL);
65    EXPECT_EQ(status, ZX_OK, "");
66    EXPECT_EQ(read_data[0], write_data[0], "");
67    EXPECT_EQ(read_data[1], write_data[1], "");
68
69    zx_handle_close(h[1]);
70
71    status = zx_socket_write(h[0], 0u, &write_data[1], sizeof(write_data[1]), &count);
72    EXPECT_EQ(status, ZX_ERR_PEER_CLOSED, "");
73
74    zx_handle_close(h[0]);
75    END_TEST;
76}
77
78static bool socket_signals(void) {
79    BEGIN_TEST;
80
81    zx_status_t status;
82    size_t count;
83
84    zx_handle_t h0, h1;
85    status = zx_socket_create(0, &h0, &h1);
86    ASSERT_EQ(status, ZX_OK, "");
87
88    zx_signals_t signals0 = get_satisfied_signals(h0);
89    zx_signals_t signals1 = get_satisfied_signals(h1);
90
91    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
92    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
93
94    const size_t kAllSize = 128 * 1024;
95    char* big_buf =  (char*) malloc(kAllSize);
96    ASSERT_NONNULL(big_buf, "");
97
98    memset(big_buf, 0x66, kAllSize);
99
100    status = zx_socket_write(h0, 0u, big_buf, kAllSize / 16, &count);
101    EXPECT_EQ(status, ZX_OK, "");
102    EXPECT_EQ(count, kAllSize / 16, "");
103
104    signals0 = get_satisfied_signals(h0);
105    signals1 = get_satisfied_signals(h1);
106
107    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
108    EXPECT_EQ(signals1, ZX_SOCKET_READABLE | ZX_SOCKET_WRITABLE, "");
109
110    status = zx_socket_read(h1, 0u, big_buf, kAllSize, &count);
111    EXPECT_EQ(status, ZX_OK, "");
112    EXPECT_EQ(count, kAllSize / 16, "");
113
114    signals0 = get_satisfied_signals(h0);
115    signals1 = get_satisfied_signals(h1);
116
117    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
118    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
119
120    status = zx_object_signal_peer(h0, ZX_SOCKET_WRITABLE, 0u);
121    EXPECT_EQ(status, ZX_ERR_INVALID_ARGS, "");
122
123    status = zx_object_signal_peer(h0, 0u, ZX_USER_SIGNAL_1);
124    EXPECT_EQ(status, ZX_OK, "");
125
126    signals0 = get_satisfied_signals(h0);
127    signals1 = get_satisfied_signals(h1);
128
129    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
130    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_USER_SIGNAL_1, "");
131
132    zx_handle_close(h1);
133
134    signals0 = get_satisfied_signals(h0);
135    EXPECT_EQ(signals0, ZX_SOCKET_PEER_CLOSED, "");
136
137    zx_handle_close(h0);
138
139    free(big_buf);
140    END_TEST;
141}
142
143static bool socket_signals2(void) {
144    BEGIN_TEST;
145
146    zx_status_t status;
147    size_t count;
148    zx_handle_t h0, h1;
149    status = zx_socket_create(0, &h0, &h1);
150    ASSERT_EQ(status, ZX_OK, "socket_create");
151
152    /* Set some invalid threshold values and verify */
153    count = 0;
154    status = zx_object_set_property(h0, ZX_PROP_SOCKET_RX_THRESHOLD,
155                                    &count, sizeof(size_t));
156    ASSERT_EQ(status, ZX_OK, "object_set_property");
157    count = 0xefffffff;
158    status = zx_object_set_property(h0, ZX_PROP_SOCKET_RX_THRESHOLD,
159                                    &count, sizeof(size_t));
160    ASSERT_EQ(status, ZX_ERR_INVALID_ARGS, "object_set_property");
161    count = 0;
162    status = zx_object_set_property(h1, ZX_PROP_SOCKET_TX_THRESHOLD,
163                                    &count, sizeof(size_t));
164    ASSERT_EQ(status, ZX_OK, "object_set_property");
165    count = 0xefffffff;
166    status = zx_object_set_property(h1, ZX_PROP_SOCKET_TX_THRESHOLD,
167                                    &count, sizeof(size_t));
168    ASSERT_EQ(status, ZX_ERR_INVALID_ARGS, "object_set_property");
169
170    /*
171     * In the code below, we are going to trigger the READ threshold
172     * signal as soon as 101 bytes are available to read, and triger
173     * the write threshold as long as we have 103 bytes we can write/
174     */
175
176    /* Set valid Read/Write thresholds and verify */
177#define SOCKET2_SIGNALTEST_RX_THRESHOLD     101
178    count = SOCKET2_SIGNALTEST_RX_THRESHOLD;
179    status = zx_object_set_property(h0, ZX_PROP_SOCKET_RX_THRESHOLD,
180                                    &count, sizeof(size_t));
181    ASSERT_EQ(status, ZX_OK, "object_set_property");
182    status = zx_object_get_property(h0, ZX_PROP_SOCKET_RX_THRESHOLD,
183                                    &count, sizeof(size_t));
184    ASSERT_EQ(status, ZX_OK, "object_get_property");
185    ASSERT_EQ(count, (size_t)SOCKET2_SIGNALTEST_RX_THRESHOLD, "");
186
187    size_t txbufmax;
188    status = zx_object_get_property(h1, ZX_PROP_SOCKET_TX_BUF_MAX,
189                                    &txbufmax, sizeof(size_t));
190    ASSERT_EQ(status, ZX_OK, "object_get_property");
191    size_t write_threshold = txbufmax - (SOCKET2_SIGNALTEST_RX_THRESHOLD + 2);
192    status = zx_object_set_property(h1, ZX_PROP_SOCKET_TX_THRESHOLD,
193                                    &write_threshold, sizeof(size_t));
194    ASSERT_EQ(status, ZX_OK, "object_set_property");
195    status = zx_object_get_property(h1, ZX_PROP_SOCKET_TX_THRESHOLD,
196                                    &count, sizeof(size_t));
197    ASSERT_EQ(status, ZX_OK, "object_get_property");
198    ASSERT_EQ(count, write_threshold, "");
199
200
201    /* Make sure duplicates get the same thresholds ! */
202    zx_handle_t h0_clone, h1_clone;
203    status = zx_handle_duplicate(h0, ZX_RIGHT_SAME_RIGHTS, &h0_clone);
204    ASSERT_EQ(status, ZX_OK, "handle_duplicate");
205    status = zx_handle_duplicate(h1, ZX_RIGHT_SAME_RIGHTS, &h1_clone);
206    ASSERT_EQ(status, ZX_OK, "handle_duplicate");
207
208    status = zx_object_get_property(h0_clone,
209                                    ZX_PROP_SOCKET_RX_THRESHOLD,
210                                    &count, sizeof(size_t));
211    ASSERT_EQ(status, ZX_OK, "object_get_property");
212    ASSERT_EQ(count, (size_t)SOCKET2_SIGNALTEST_RX_THRESHOLD, "");
213    status = zx_object_get_property(h1_clone,
214                                    ZX_PROP_SOCKET_TX_THRESHOLD,
215                                    &count, sizeof(size_t));
216    ASSERT_EQ(status, ZX_OK, "object_get_property");
217    ASSERT_EQ(count, write_threshold, "");
218
219    /* Test starting signal state after setting thresholds */
220    zx_signals_t signals0 = get_satisfied_signals(h0);
221    zx_signals_t signals1 = get_satisfied_signals(h1);
222    zx_signals_t signals0_clone = get_satisfied_signals(h0_clone);
223    zx_signals_t signals1_clone = get_satisfied_signals(h1_clone);
224
225    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
226    EXPECT_EQ(signals0_clone, ZX_SOCKET_WRITABLE, "");
227    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
228    EXPECT_EQ(signals1_clone,
229              ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
230
231    /* Write data and test signals */
232    size_t bufsize = SOCKET2_SIGNALTEST_RX_THRESHOLD - 1;
233    char buf[SOCKET2_SIGNALTEST_RX_THRESHOLD - 1];
234    status = zx_socket_write(h1, 0u, buf, bufsize, &count);
235    EXPECT_EQ(status, ZX_OK, "");
236    EXPECT_EQ(count, bufsize, "");
237
238    /*
239     * We wrote less than the read and write thresholds. So we expect
240     * the READ_THRESHOLD signal to be de-asserted and the WRITE_THRESHOLD
241     * signal to be asserted.
242     */
243    signals0 = get_satisfied_signals(h0);
244    signals1 = get_satisfied_signals(h1);
245    signals0_clone = get_satisfied_signals(h0_clone);
246    signals1_clone = get_satisfied_signals(h1_clone);
247
248    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE, "");
249    EXPECT_EQ(signals0_clone, ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE, "");
250    EXPECT_EQ(signals1_clone,
251              ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
252
253    /*
254     * Now write exactly enough data to hit the read threshold
255     */
256    bufsize = 1;
257    status = zx_socket_write(h1, 0u, buf, bufsize, &count);
258    EXPECT_EQ(status, ZX_OK, "");
259    EXPECT_EQ(count, bufsize, "");
260    signals0 = get_satisfied_signals(h0);
261    signals1 = get_satisfied_signals(h1);
262    signals0_clone = get_satisfied_signals(h0_clone);
263    signals1_clone = get_satisfied_signals(h1_clone);
264    EXPECT_EQ(signals0,
265              ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE | ZX_SOCKET_READ_THRESHOLD,
266              "");
267    EXPECT_EQ(signals0_clone,
268              ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE | ZX_SOCKET_READ_THRESHOLD,
269              "");
270    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
271    EXPECT_EQ(signals1_clone, ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
272
273    /*
274     * Next write enough data to de-assert WRITE Threshold
275     */
276    bufsize = write_threshold - (SOCKET2_SIGNALTEST_RX_THRESHOLD + 1);
277    char *buf2 =  (char *)malloc(bufsize);
278    status = zx_socket_write(h1, 0u, buf2, bufsize, &count);
279    EXPECT_EQ(status, ZX_OK, "");
280    EXPECT_EQ(count, bufsize, "");
281    free(buf2);
282    signals0 = get_satisfied_signals(h0);
283    signals1 = get_satisfied_signals(h1);
284    signals0_clone = get_satisfied_signals(h0_clone);
285    signals1_clone = get_satisfied_signals(h1_clone);
286    EXPECT_EQ(signals0,
287              ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE | ZX_SOCKET_READ_THRESHOLD,
288              "");
289    EXPECT_EQ(signals0_clone,
290              ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE | ZX_SOCKET_READ_THRESHOLD,
291              "");
292    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
293    EXPECT_EQ(signals1_clone, ZX_SOCKET_WRITABLE, "");
294
295    /*
296     * Finally read enough data to de-assert the read threshold and
297     * re-assert the write threshold signals.
298     */
299    bufsize += 10;
300    buf2 =  (char *)malloc(bufsize);
301    status = zx_socket_read(h0, 0u, buf2, bufsize, &count);
302    EXPECT_EQ(status, ZX_OK, "");
303    EXPECT_EQ(count, bufsize, "");
304    free(buf2);
305    signals0 = get_satisfied_signals(h0);
306    signals1 = get_satisfied_signals(h1);
307    signals0_clone = get_satisfied_signals(h0_clone);
308    signals1_clone = get_satisfied_signals(h1_clone);
309    EXPECT_EQ(signals0,
310              ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE,
311              "");
312    EXPECT_EQ(signals0_clone,
313              ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE,
314              "");
315    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
316    EXPECT_EQ(signals1_clone, ZX_SOCKET_WRITABLE | ZX_SOCKET_WRITE_THRESHOLD, "");
317
318    zx_handle_close(h0);
319    zx_handle_close(h1);
320    zx_handle_close(h0_clone);
321    zx_handle_close(h1_clone);
322    END_TEST;
323}
324
325static bool socket_peer_closed(void) {
326    BEGIN_TEST;
327
328    zx_handle_t socket[2];
329    ASSERT_EQ(zx_socket_create(0, &socket[0], &socket[1]), ZX_OK, "");
330    ASSERT_EQ(zx_handle_close(socket[1]), ZX_OK, "");
331    ASSERT_EQ(zx_object_signal_peer(socket[0], 0u, ZX_USER_SIGNAL_0), ZX_ERR_PEER_CLOSED, "");
332    ASSERT_EQ(zx_handle_close(socket[0]), ZX_OK, "");
333
334    END_TEST;
335}
336
337static bool socket_shutdown_write(void) {
338    BEGIN_TEST;
339
340    zx_status_t status;
341    size_t count;
342    zx_signals_t signals0, signals1;
343
344    zx_handle_t h0, h1;
345    status = zx_socket_create(0, &h0, &h1);
346    ASSERT_EQ(status, ZX_OK, "");
347
348    signals0 = get_satisfied_signals(h0);
349    signals1 = get_satisfied_signals(h1);
350
351    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
352    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
353
354    status = zx_socket_write(h1, 0u, "12345", 5u, &count);
355    EXPECT_EQ(status, ZX_OK, "");
356    EXPECT_EQ(count, 5u, "");
357
358    status = zx_socket_write(h1, ZX_SOCKET_SHUTDOWN_WRITE, NULL, 0u, NULL);
359    EXPECT_EQ(status, ZX_OK, "");
360
361    signals0 = get_satisfied_signals(h0);
362    signals1 = get_satisfied_signals(h1);
363
364    EXPECT_EQ(signals0,
365        ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE,
366        "");
367    EXPECT_EQ(signals1, ZX_SOCKET_WRITE_DISABLED, "");
368
369    status = zx_socket_write(h0, 0u, "abcde", 5u, &count);
370    EXPECT_EQ(status, ZX_OK, "");
371    EXPECT_EQ(count, 5u, "");
372
373    signals1 = get_satisfied_signals(h1);
374    EXPECT_EQ(signals1, ZX_SOCKET_READABLE | ZX_SOCKET_WRITE_DISABLED, "");
375
376    status = zx_socket_write(h1, 0u, "fghij", 5u, &count);
377    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
378
379    char rbuf[10] = {0};
380
381    status = zx_socket_read(h0, 0u, rbuf, sizeof(rbuf), &count);
382    EXPECT_EQ(status, ZX_OK, "");
383    EXPECT_EQ(count, 5u, "");
384    EXPECT_EQ(memcmp(rbuf, "12345", 5), 0, "");
385
386    status = zx_socket_read(h0, 0u, rbuf, 1u, &count);
387    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
388
389    signals0 = get_satisfied_signals(h0);
390    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READ_DISABLED, "");
391
392    status = zx_socket_read(h1, 0u, rbuf, sizeof(rbuf), &count);
393    EXPECT_EQ(status, ZX_OK, "");
394    EXPECT_EQ(count, 5u, "");
395    EXPECT_EQ(memcmp(rbuf, "abcde", 5), 0, "");
396
397    zx_handle_close(h0);
398
399    // Calling shutdown after the peer is closed is completely valid.
400    status = zx_socket_write(h1, ZX_SOCKET_SHUTDOWN_READ, NULL, 0u, NULL);
401    EXPECT_EQ(status, ZX_OK, "");
402
403    signals1 = get_satisfied_signals(h1);
404    EXPECT_EQ(signals1, ZX_SOCKET_READ_DISABLED | ZX_SOCKET_WRITE_DISABLED | ZX_SOCKET_PEER_CLOSED, "");
405
406    zx_handle_close(h1);
407
408    END_TEST;
409}
410
411static bool socket_shutdown_read(void) {
412    BEGIN_TEST;
413
414    zx_status_t status;
415    size_t count;
416    zx_signals_t signals0, signals1;
417
418    zx_handle_t h0, h1;
419    status = zx_socket_create(0, &h0, &h1);
420    ASSERT_EQ(status, ZX_OK, "");
421
422    signals0 = get_satisfied_signals(h0);
423    signals1 = get_satisfied_signals(h1);
424
425    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
426    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
427
428    status = zx_socket_write(h1, 0u, "12345", 5u, &count);
429    EXPECT_EQ(status, ZX_OK, "");
430    EXPECT_EQ(count, 5u, "");
431
432    status = zx_socket_write(h0, ZX_SOCKET_SHUTDOWN_READ, NULL, 0u, NULL);
433    EXPECT_EQ(status, ZX_OK, "");
434
435    signals0 = get_satisfied_signals(h0);
436    signals1 = get_satisfied_signals(h1);
437
438    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE, "");
439    EXPECT_EQ(signals1, ZX_SOCKET_WRITE_DISABLED, "");
440
441    status = zx_socket_write(h0, 0u, "abcde", 5u, &count);
442    EXPECT_EQ(status, ZX_OK, "");
443    EXPECT_EQ(count, 5u, "");
444
445    signals1 = get_satisfied_signals(h1);
446    EXPECT_EQ(signals1, ZX_SOCKET_READABLE | ZX_SOCKET_WRITE_DISABLED, "");
447
448    status = zx_socket_write(h1, 0u, "fghij", 5u, &count);
449    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
450
451    char rbuf[10] = {0};
452
453    status = zx_socket_read(h0, 0u, rbuf, sizeof(rbuf), &count);
454    EXPECT_EQ(status, ZX_OK, "");
455    EXPECT_EQ(count, 5u, "");
456    EXPECT_EQ(memcmp(rbuf, "12345", 5), 0, "");
457
458    status = zx_socket_read(h0, 0u, rbuf, 1u, &count);
459    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
460
461    signals0 = get_satisfied_signals(h0);
462    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READ_DISABLED, "");
463
464    status = zx_socket_read(h1, 0u, rbuf, sizeof(rbuf), &count);
465    EXPECT_EQ(status, ZX_OK, "");
466    EXPECT_EQ(count, 5u, "");
467    EXPECT_EQ(memcmp(rbuf, "abcde", 5), 0, "");
468
469    zx_handle_close(h0);
470    zx_handle_close(h1);
471
472    END_TEST;
473}
474
475static bool socket_bytes_outstanding(void) {
476    BEGIN_TEST;
477
478    zx_status_t status;
479    size_t count;
480
481    zx_handle_t h[2];
482    uint32_t read_data[] = { 0, 0 };
483
484    status = zx_socket_create(0, h, h + 1);
485    ASSERT_EQ(status, ZX_OK, "");
486
487    status = zx_socket_read(h[0], 0u, read_data, sizeof(read_data), &count);
488    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
489
490    static const uint32_t write_data[] = { 0xdeadbeef, 0xc0ffee };
491    status = zx_socket_write(h[0], 0u, &write_data[0], sizeof(write_data[0]), &count);
492    EXPECT_EQ(status, ZX_OK, "");
493    EXPECT_EQ(count, sizeof(write_data[0]), "");
494    status = zx_socket_write(h[0], 0u, &write_data[1], sizeof(write_data[1]), &count);
495    EXPECT_EQ(status, ZX_OK, "");
496    EXPECT_EQ(count, sizeof(write_data[1]), "");
497
498    // Check the number of bytes outstanding.
499    size_t outstanding = 0u;
500    status = zx_socket_read(h[1], 0u, NULL, 0, &outstanding);
501    EXPECT_EQ(outstanding, sizeof(write_data), "");
502
503    // Check that the prior zx_socket_read call didn't disturb the pending data.
504    status = zx_socket_read(h[1], 0u, read_data, sizeof(read_data), &count);
505    EXPECT_EQ(status, ZX_OK, "");
506    EXPECT_EQ(count, sizeof(read_data), "");
507    EXPECT_EQ(read_data[0], write_data[0], "");
508    EXPECT_EQ(read_data[1], write_data[1], "");
509
510    zx_handle_close(h[1]);
511
512    status = zx_socket_write(h[0], 0u, &write_data[1], sizeof(write_data[1]), &count);
513    EXPECT_EQ(status, ZX_ERR_PEER_CLOSED, "");
514
515    zx_handle_close(h[0]);
516
517    END_TEST;
518}
519
520static bool socket_bytes_outstanding_shutdown_write(void) {
521    BEGIN_TEST;
522
523    zx_status_t status;
524    size_t count;
525    zx_signals_t signals0, signals1;
526
527    zx_handle_t h0, h1;
528    status = zx_socket_create(0, &h0, &h1);
529    ASSERT_EQ(status, ZX_OK, "");
530
531    signals0 = get_satisfied_signals(h0);
532    signals1 = get_satisfied_signals(h1);
533
534    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
535    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
536
537    status = zx_socket_write(h1, 0u, "12345", 5u, &count);
538    EXPECT_EQ(status, ZX_OK, "");
539    EXPECT_EQ(count, 5u, "");
540
541    status = zx_socket_write(h1, ZX_SOCKET_SHUTDOWN_WRITE, NULL, 0u, NULL);
542    EXPECT_EQ(status, ZX_OK, "");
543
544    signals0 = get_satisfied_signals(h0);
545    signals1 = get_satisfied_signals(h1);
546
547    EXPECT_EQ(signals0,
548        ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE,
549        "");
550    EXPECT_EQ(signals1, ZX_SOCKET_WRITE_DISABLED, "");
551
552    status = zx_socket_write(h0, 0u, "abcde", 5u, &count);
553    EXPECT_EQ(status, ZX_OK, "");
554    EXPECT_EQ(count, 5u, "");
555
556    signals1 = get_satisfied_signals(h1);
557    EXPECT_EQ(signals1, ZX_SOCKET_READABLE | ZX_SOCKET_WRITE_DISABLED, "");
558
559    status = zx_socket_write(h1, 0u, "fghij", 5u, &count);
560    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
561
562    char rbuf[10] = {0};
563
564    status = zx_socket_read(h0, 0u, NULL, 0, &count);
565    EXPECT_EQ(status, ZX_OK, "");
566    EXPECT_EQ(count, 5u, "");
567    count = 0;
568
569    status = zx_socket_read(h0, 0u, rbuf, sizeof(rbuf), &count);
570    EXPECT_EQ(status, ZX_OK, "");
571    EXPECT_EQ(count, 5u, "");
572    EXPECT_EQ(memcmp(rbuf, "12345", 5), 0, "");
573
574    status = zx_socket_read(h0, 0u, rbuf, 1u, &count);
575    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
576
577    signals0 = get_satisfied_signals(h0);
578    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READ_DISABLED, "");
579
580    status = zx_socket_read(h1, 0u, rbuf, sizeof(rbuf), &count);
581    EXPECT_EQ(status, ZX_OK, "");
582    EXPECT_EQ(count, 5u, "");
583    EXPECT_EQ(memcmp(rbuf, "abcde", 5), 0, "");
584
585    zx_handle_close(h0);
586    zx_handle_close(h1);
587
588    END_TEST;
589}
590
591
592static bool socket_bytes_outstanding_shutdown_read(void) {
593    BEGIN_TEST;
594
595    zx_status_t status;
596    size_t count;
597    zx_signals_t signals0, signals1;
598
599    zx_handle_t h0, h1;
600    status = zx_socket_create(0, &h0, &h1);
601    ASSERT_EQ(status, ZX_OK, "");
602
603    signals0 = get_satisfied_signals(h0);
604    signals1 = get_satisfied_signals(h1);
605
606    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
607    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE, "");
608
609    status = zx_socket_write(h1, 0u, "12345", 5u, &count);
610    EXPECT_EQ(status, ZX_OK, "");
611    EXPECT_EQ(count, 5u, "");
612
613    status = zx_socket_write(h0, ZX_SOCKET_SHUTDOWN_READ, NULL, 0u, NULL);
614    EXPECT_EQ(status, ZX_OK, "");
615
616    signals0 = get_satisfied_signals(h0);
617    signals1 = get_satisfied_signals(h1);
618
619    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READABLE, "");
620    EXPECT_EQ(signals1, ZX_SOCKET_WRITE_DISABLED, "");
621
622    status = zx_socket_write(h0, 0u, "abcde", 5u, &count);
623    EXPECT_EQ(status, ZX_OK, "");
624    EXPECT_EQ(count, 5u, "");
625
626    signals1 = get_satisfied_signals(h1);
627    EXPECT_EQ(signals1, ZX_SOCKET_READABLE | ZX_SOCKET_WRITE_DISABLED, "");
628
629    status = zx_socket_write(h1, 0u, "fghij", 5u, &count);
630    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
631
632    char rbuf[10] = {0};
633
634    status = zx_socket_read(h0, 0u, NULL, 0, &count);
635    EXPECT_EQ(status, ZX_OK, "");
636    EXPECT_EQ(count, 5u, "");
637    count = 0;
638
639    status = zx_socket_read(h0, 0u, rbuf, sizeof(rbuf), &count);
640    EXPECT_EQ(status, ZX_OK, "");
641    EXPECT_EQ(count, 5u, "");
642    EXPECT_EQ(memcmp(rbuf, "12345", 5), 0, "");
643
644    status = zx_socket_read(h0, 0u, rbuf, 1u, &count);
645    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
646
647    signals0 = get_satisfied_signals(h0);
648    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_READ_DISABLED, "");
649
650    status = zx_socket_read(h1, 0u, rbuf, sizeof(rbuf), &count);
651    EXPECT_EQ(status, ZX_OK, "");
652    EXPECT_EQ(count, 5u, "");
653    EXPECT_EQ(memcmp(rbuf, "abcde", 5), 0, "");
654
655    zx_handle_close(h0);
656    zx_handle_close(h1);
657
658    END_TEST;
659}
660
661static bool socket_short_write(void) {
662    BEGIN_TEST;
663
664    zx_status_t status;
665
666    zx_handle_t h0, h1;
667    status = zx_socket_create(0, &h0, &h1);
668    ASSERT_EQ(status, ZX_OK, "");
669
670    // TODO(qsr): Request socket buffer and use (socket_buffer + 1).
671    const size_t buffer_size = 256 * 1024 + 1;
672    char* buffer = malloc(buffer_size);
673    size_t written = ~(size_t)0; // This should get overwritten by the syscall.
674    status = zx_socket_write(h0, 0u, buffer, buffer_size, &written);
675    EXPECT_EQ(status, ZX_OK, "");
676    EXPECT_LT(written, buffer_size, "");
677
678    free(buffer);
679    zx_handle_close(h0);
680    zx_handle_close(h1);
681
682    END_TEST;
683}
684
685static bool socket_datagram(void) {
686    BEGIN_TEST;
687
688    size_t count;
689    zx_status_t status;
690    zx_handle_t h0, h1;
691    unsigned char rbuf[4096] = {0}; // bigger than an mbuf
692
693    status = zx_socket_create(ZX_SOCKET_DATAGRAM, &h0, &h1);
694    ASSERT_EQ(status, ZX_OK, "");
695
696    status = zx_socket_write(h0, 0u, "packet1", 8u, &count);
697    EXPECT_EQ(status, ZX_OK, "");
698    EXPECT_EQ(count, 8u, "");
699
700    status = zx_socket_write(h0, 0u, "pkt2", 5u, &count);
701    EXPECT_EQ(status, ZX_OK, "");
702    EXPECT_EQ(count, 5u, "");
703
704    rbuf[0] = 'a';
705    rbuf[1000] = 'b';
706    rbuf[2000] = 'c';
707    rbuf[3000] = 'd';
708    rbuf[4000] = 'e';
709    rbuf[4095] = 'f';
710    status = zx_socket_write(h0, 0u, rbuf, sizeof(rbuf), &count);
711    EXPECT_EQ(status, ZX_OK, "");
712    EXPECT_EQ(count, sizeof(rbuf), "");
713
714    status = zx_socket_read(h1, 0u, NULL, 0, &count);
715    EXPECT_EQ(status, ZX_OK, "");
716    EXPECT_EQ(count, sizeof(rbuf) + 8u + 5u, "");
717    count = 0;
718
719    bzero(rbuf, sizeof(rbuf));
720    status = zx_socket_read(h1, 0u, rbuf, 3, &count);
721    EXPECT_EQ(status, ZX_OK, "");
722    EXPECT_EQ(count, 3u, "");
723    EXPECT_EQ(memcmp(rbuf, "pac", 4), 0, ""); // short read "packet1"
724    count = 0;
725
726    status = zx_socket_read(h1, 0u, NULL, 0, &count);
727    EXPECT_EQ(status, ZX_OK, "");
728    EXPECT_EQ(count, sizeof(rbuf) + 5u, "");
729    count = 0;
730
731    status = zx_socket_read(h1, 0u, rbuf, sizeof(rbuf), &count);
732    EXPECT_EQ(status, ZX_OK, "");
733    EXPECT_EQ(count, 5u, "");
734    EXPECT_EQ(memcmp(rbuf, "pkt2", 5), 0, "");
735
736    status = zx_socket_read(h1, 0u, rbuf, sizeof(rbuf), &count);
737    EXPECT_EQ(status, ZX_OK, "");
738    EXPECT_EQ(count, sizeof(rbuf), "");
739    EXPECT_EQ(rbuf[0], 'a', "");
740    EXPECT_EQ(rbuf[1000], 'b', "");
741    EXPECT_EQ(rbuf[2000], 'c', "");
742    EXPECT_EQ(rbuf[3000], 'd', "");
743    EXPECT_EQ(rbuf[4000], 'e', "");
744    EXPECT_EQ(rbuf[4095], 'f', "");
745
746    status = zx_socket_read(h1, 0u, NULL, 0, &count);
747    EXPECT_EQ(status, ZX_OK, "");
748    EXPECT_EQ(count, 0u, "");
749
750    END_TEST;
751}
752
753static bool socket_datagram_no_short_write(void) {
754    BEGIN_TEST;
755
756    zx_status_t status;
757
758    zx_handle_t h0, h1;
759    status = zx_socket_create(ZX_SOCKET_DATAGRAM, &h0, &h1);
760    ASSERT_EQ(status, ZX_OK, "");
761
762    size_t tx_buf_size = 0u;
763    status = zx_object_get_property(h0, ZX_PROP_SOCKET_TX_BUF_MAX, &tx_buf_size,
764                                    sizeof(tx_buf_size));
765    EXPECT_EQ(status, ZX_OK, "");
766    EXPECT_GT(tx_buf_size, 0u, "");
767
768    // Pick a size for a huge datagram, and make sure not to overflow.
769    size_t buffer_size = tx_buf_size * 2;
770    EXPECT_GT(buffer_size, 0u, "");
771
772    void* buffer = calloc(buffer_size, 1u);
773    EXPECT_NONNULL(buffer, "");
774
775    size_t written = ~0u;
776    status = zx_socket_write(h0, 0u, buffer, buffer_size, &written);
777    EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "");
778    // Since the syscall failed, it should not have overwritten this output
779    // parameter.
780    EXPECT_EQ(written, ~0u, "");
781
782    free(buffer);
783    zx_handle_close(h0);
784    zx_handle_close(h1);
785
786    END_TEST;
787}
788
789static bool socket_control_plane_absent(void) {
790    BEGIN_TEST;
791
792    zx_status_t status;
793
794    zx_handle_t h0, h1;
795    status = zx_socket_create(0, &h0, &h1);
796    ASSERT_EQ(status, ZX_OK, "");
797
798    status = zx_socket_write(h0, ZX_SOCKET_CONTROL, "hi", 2u, NULL);
799    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
800
801    status = zx_socket_write(h1, ZX_SOCKET_CONTROL, "hi", 2u, NULL);
802    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
803
804    size_t count;
805    char rbuf[10] = {0};
806
807    status = zx_socket_read(h0, ZX_SOCKET_CONTROL, rbuf, sizeof(rbuf), &count);
808    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
809
810    status = zx_socket_read(h1, ZX_SOCKET_CONTROL, rbuf, sizeof(rbuf), &count);
811    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
812
813    END_TEST;
814}
815
816static bool socket_control_plane(void) {
817    BEGIN_TEST;
818
819    zx_status_t status;
820
821    zx_handle_t h0, h1;
822    status = zx_socket_create(ZX_SOCKET_HAS_CONTROL, &h0, &h1);
823    ASSERT_EQ(status, ZX_OK, "");
824
825    zx_signals_t signals0 = get_satisfied_signals(h0);
826    zx_signals_t signals1 = get_satisfied_signals(h1);
827    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
828    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
829
830    // Write to the control plane.
831    size_t count;
832    status = zx_socket_write(h0, ZX_SOCKET_CONTROL, "hello1", 6u, &count);
833    EXPECT_EQ(status, ZX_OK, "");
834    EXPECT_EQ(count, 6u, "");
835
836    signals0 = get_satisfied_signals(h0);
837    signals1 = get_satisfied_signals(h1);
838    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
839    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_READABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
840
841    status = zx_socket_write(h0, ZX_SOCKET_CONTROL, "hi", 2u, NULL);
842    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
843
844    status = zx_socket_write(h1, ZX_SOCKET_CONTROL, "hello0", 6u, &count);
845    EXPECT_EQ(status, ZX_OK, "");
846    EXPECT_EQ(count, 6u, "");
847
848    signals0 = get_satisfied_signals(h0);
849    signals1 = get_satisfied_signals(h1);
850    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_READABLE, "");
851    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_READABLE, "");
852
853    status = zx_socket_write(h1, ZX_SOCKET_CONTROL, "hi", 2u, NULL);
854    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
855
856    char rbuf[10] = {0};
857
858    // The control plane is independent of normal reads and writes.
859    status = zx_socket_read(h0, 0, rbuf, sizeof(rbuf), &count);
860    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
861    status = zx_socket_read(h1, 0, rbuf, sizeof(rbuf), &count);
862    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
863    status = zx_socket_write(h0, 0, "normal", 7u, &count);
864    EXPECT_EQ(status, ZX_OK, "");
865    EXPECT_EQ(count, 7u, "");
866    status = zx_socket_read(h1, 0, rbuf, sizeof(rbuf), &count);
867    EXPECT_EQ(status, ZX_OK, "");
868    EXPECT_EQ(count, 7u, "");
869    EXPECT_EQ(memcmp(rbuf, "normal", 7), 0, "");
870
871    // Read from the control plane.
872    status = zx_socket_read(h0, ZX_SOCKET_CONTROL, rbuf, sizeof(rbuf), &count);
873    EXPECT_EQ(status, ZX_OK, "");
874    EXPECT_EQ(count, 6u, "");
875    EXPECT_EQ(memcmp(rbuf, "hello0", 6), 0, "");
876
877    status = zx_socket_read(h0, ZX_SOCKET_CONTROL, rbuf, sizeof(rbuf), &count);
878    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
879
880    status = zx_socket_read(h1, ZX_SOCKET_CONTROL, rbuf, sizeof(rbuf), &count);
881    EXPECT_EQ(status, ZX_OK, "");
882    EXPECT_EQ(count, 6u, "");
883    EXPECT_EQ(memcmp(rbuf, "hello1", 6), 0, "");
884
885    status = zx_socket_read(h1, ZX_SOCKET_CONTROL, rbuf, sizeof(rbuf), &count);
886    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
887
888    signals0 = get_satisfied_signals(h0);
889    signals1 = get_satisfied_signals(h1);
890    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
891    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
892
893    END_TEST;
894}
895
896static bool socket_control_plane_shutdown(void) {
897    BEGIN_TEST;
898
899    zx_status_t status;
900    size_t count;
901
902    zx_handle_t h0, h1;
903    status = zx_socket_create(ZX_SOCKET_HAS_CONTROL, &h0, &h1);
904    ASSERT_EQ(status, ZX_OK, "");
905
906    zx_signals_t signals0 = get_satisfied_signals(h0);
907    zx_signals_t signals1 = get_satisfied_signals(h1);
908    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
909    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE, "");
910
911    status = zx_socket_write(h1, 0u, "12345", 5u, &count);
912    EXPECT_EQ(status, ZX_OK, "");
913    EXPECT_EQ(count, 5u, "");
914
915    status = zx_socket_write(h1, ZX_SOCKET_SHUTDOWN_WRITE, NULL, 0u, NULL);
916    EXPECT_EQ(status, ZX_OK, "");
917
918    signals0 = get_satisfied_signals(h0);
919    signals1 = get_satisfied_signals(h1);
920    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_WRITABLE | ZX_SOCKET_READABLE, "");
921    EXPECT_EQ(signals1, ZX_SOCKET_WRITE_DISABLED | ZX_SOCKET_CONTROL_WRITABLE, "");
922
923    status = zx_socket_write(h0, ZX_SOCKET_CONTROL, "hello1", 6u, &count);
924    EXPECT_EQ(status, ZX_OK, "");
925    EXPECT_EQ(count, 6u, "");
926
927    status = zx_socket_write(h1, ZX_SOCKET_CONTROL, "hello0", 6u, &count);
928    EXPECT_EQ(status, ZX_OK, "");
929    EXPECT_EQ(count, 6u, "");
930
931    signals0 = get_satisfied_signals(h0);
932    signals1 = get_satisfied_signals(h1);
933    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_CONTROL_READABLE | ZX_SOCKET_READABLE, "");
934    EXPECT_EQ(signals1, ZX_SOCKET_WRITE_DISABLED | ZX_SOCKET_CONTROL_READABLE, "");
935
936    END_TEST;
937}
938
939static bool socket_accept(void) {
940    BEGIN_TEST;
941
942    zx_status_t status;
943
944    zx_handle_t a0, a1;
945    status = zx_socket_create(ZX_SOCKET_HAS_ACCEPT, &a0, &a1);
946    ASSERT_EQ(status, ZX_OK, "");
947
948    zx_handle_t b0, b1;
949    status = zx_socket_create(0, &b0, &b1);
950    ASSERT_EQ(status, ZX_OK, "");
951
952    zx_handle_t c0, c1;
953    status = zx_socket_create(0, &c0, &c1);
954    ASSERT_EQ(status, ZX_OK, "");
955
956    zx_signals_t signals0 = get_satisfied_signals(a0);
957    zx_signals_t signals1 = get_satisfied_signals(a1);
958    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_SHARE, "");
959    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_SHARE, "");
960
961    // cannot share a HAS_ACCEPT socket
962    status = zx_socket_share(b0, a0);
963    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
964    zx_handle_close(a1);
965    status = zx_socket_create(ZX_SOCKET_HAS_ACCEPT, &a0, &a1);
966    ASSERT_EQ(status, ZX_OK, "");
967
968    // cannot share via a non-HAS_ACCEPT socket
969    status = zx_socket_share(b0, c0);
970    EXPECT_EQ(status, ZX_ERR_NOT_SUPPORTED, "");
971
972    // cannot share a socket via itself (either direction)
973    status = zx_socket_share(a0, a0);
974    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
975    zx_handle_close(a1);
976    status = zx_socket_create(ZX_SOCKET_HAS_ACCEPT, &a0, &a1);
977    ASSERT_EQ(status, ZX_OK, "");
978
979    status = zx_socket_share(a0, a1);
980    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
981    zx_handle_close(a0);
982    status = zx_socket_create(ZX_SOCKET_HAS_ACCEPT, &a0, &a1);
983    ASSERT_EQ(status, ZX_OK, "");
984
985    status = zx_socket_share(a1, a0);
986    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
987    zx_handle_close(a1);
988    status = zx_socket_create(ZX_SOCKET_HAS_ACCEPT, &a0, &a1);
989    ASSERT_EQ(status, ZX_OK, "");
990
991    status = zx_socket_share(a1, a1);
992    EXPECT_EQ(status, ZX_ERR_BAD_STATE, "");
993    zx_handle_close(a0);
994    status = zx_socket_create(ZX_SOCKET_HAS_ACCEPT, &a0, &a1);
995    ASSERT_EQ(status, ZX_OK, "");
996
997    // cannot accept from a non-HAS_ACCEPT socket
998    zx_handle_t h;
999    status = zx_socket_accept(b0, &h);
1000    EXPECT_EQ(status, ZX_ERR_NOT_SUPPORTED, "");
1001
1002    status = zx_socket_share(a0, b0);
1003    EXPECT_EQ(status, ZX_OK, "");
1004
1005    signals0 = get_satisfied_signals(a0);
1006    signals1 = get_satisfied_signals(a1);
1007    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE, "");
1008    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_SHARE | ZX_SOCKET_ACCEPT, "");
1009
1010    // queue is only one deep
1011    status = zx_socket_share(a0, b1);
1012    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
1013
1014    status = zx_socket_accept(a1, &h);
1015    EXPECT_EQ(status, ZX_OK, "");
1016    b0 = h;
1017
1018    // queue is only one deep
1019    status = zx_socket_accept(a0, &h);
1020    EXPECT_EQ(status, ZX_ERR_SHOULD_WAIT, "");
1021
1022    signals0 = get_satisfied_signals(a0);
1023    signals1 = get_satisfied_signals(a1);
1024    EXPECT_EQ(signals0, ZX_SOCKET_WRITABLE | ZX_SOCKET_SHARE, "");
1025    EXPECT_EQ(signals1, ZX_SOCKET_WRITABLE | ZX_SOCKET_SHARE, "");
1026
1027    zx_handle_close(a0);
1028    zx_handle_close(a1);
1029    zx_handle_close(b0);
1030    zx_handle_close(b1);
1031    zx_handle_close(c0);
1032    zx_handle_close(c1);
1033
1034    END_TEST;
1035}
1036
1037bool socket_share_invalid_handle(void) {
1038    BEGIN_TEST;
1039
1040    zx_handle_t socket[2];
1041    zx_status_t status = zx_socket_create(0, &socket[0], &socket[1]);
1042    EXPECT_EQ(status, ZX_OK, "");
1043
1044    status = zx_socket_share(socket[0], ZX_HANDLE_INVALID);
1045    EXPECT_EQ(status, ZX_ERR_BAD_HANDLE, "");
1046
1047    zx_handle_close(socket[0]);
1048    zx_handle_close(socket[1]);
1049
1050    END_TEST;
1051}
1052
1053bool socket_share_consumes_on_failure(void) {
1054    BEGIN_TEST;
1055
1056    zx_handle_t socket[2];
1057    zx_status_t status = zx_socket_create(0, &socket[0], &socket[1]);
1058    EXPECT_EQ(status, ZX_OK, "");
1059
1060    zx_handle_t eventpair[2];
1061    status = zx_eventpair_create(0, &eventpair[0], &eventpair[1]);
1062    EXPECT_EQ(status, ZX_OK, "");
1063
1064    status = zx_socket_share(socket[0], eventpair[0]);
1065    EXPECT_EQ(status, ZX_ERR_WRONG_TYPE, "");
1066
1067    // eventpair[0] should have been closed, which we can detect by
1068    // waiting on its peer.
1069    zx_signals_t signals;
1070    status = zx_object_wait_one(eventpair[1], ZX_EVENTPAIR_PEER_CLOSED, 0u, &signals);
1071    EXPECT_EQ(status, ZX_OK, "");
1072    EXPECT_EQ(signals & ZX_EVENTPAIR_PEER_CLOSED, ZX_EVENTPAIR_PEER_CLOSED, "");
1073
1074    zx_handle_close(socket[0]);
1075    zx_handle_close(socket[1]);
1076    zx_handle_close(eventpair[1]);
1077
1078    END_TEST;
1079}
1080
1081BEGIN_TEST_CASE(socket_tests)
1082RUN_TEST(socket_basic)
1083RUN_TEST(socket_signals)
1084RUN_TEST(socket_peer_closed)
1085RUN_TEST(socket_shutdown_write)
1086RUN_TEST(socket_shutdown_read)
1087RUN_TEST(socket_bytes_outstanding)
1088RUN_TEST(socket_bytes_outstanding_shutdown_write)
1089RUN_TEST(socket_bytes_outstanding_shutdown_read)
1090RUN_TEST(socket_short_write)
1091RUN_TEST(socket_datagram)
1092RUN_TEST(socket_datagram_no_short_write)
1093RUN_TEST(socket_control_plane_absent)
1094RUN_TEST(socket_control_plane)
1095RUN_TEST(socket_control_plane_shutdown)
1096RUN_TEST(socket_accept)
1097RUN_TEST(socket_share_invalid_handle)
1098RUN_TEST(socket_share_consumes_on_failure)
1099RUN_TEST(socket_signals2)
1100END_TEST_CASE(socket_tests)
1101
1102#ifndef BUILD_COMBINED_TESTS
1103int main(int argc, char** argv) {
1104    return unittest_run_all_tests(argc, argv) ? 0 : -1;
1105}
1106#endif
1107