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