1 /* 2 ** Copyright 2009 The Android Open Source Project 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 /** socket testing */ 18 19 #include <stdlib.h> 20 #include <stdio.h> 21 #include <errno.h> 22 #include <sys/uio.h> 23 #include <unistd.h> 24 25 #include <pthread.h> 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <errno.h> 29 #include <unistd.h> 30 #include <sys/socket.h> 31 #include <sys/ioctl.h> 32 #include <sys/poll.h> 33 #include <sys/un.h> 34 #include <netinet/in.h> 35 36 #include <bluetooth/bluetooth.h> 37 #include <bluetooth/rfcomm.h> 38 #include <bluetooth/sco.h> 39 #include <bluetooth/l2cap.h> 40 41 #include "cutils/abort_socket.h" 42 43 enum sock_type { 44 UNIX = 0, 45 RFCOMM, 46 SCO, 47 L2CAP, 48 TCP, 49 }; 50 51 struct thread_args { 52 int fd; 53 int type; 54 int delay; 55 }; 56 57 struct sockaddr_un local_addr_un = {AF_UNIX, "/data/foo"}; 58 struct sockaddr_rc local_addr_rc = {AF_BLUETOOTH, *BDADDR_ANY, 4}; 59 struct sockaddr_sco local_addr_sco = {AF_BLUETOOTH, *BDADDR_LOCAL}; 60 struct sockaddr_l2 local_addr_l2 = {AF_BLUETOOTH, htobs(0x1001), *BDADDR_ANY, 0}; 61 struct sockaddr_in local_addr_in = {AF_INET, 9999, {0}, {0}}; 62 63 struct sockaddr_un remote_addr_un ; 64 struct sockaddr_rc remote_addr_rc ; 65 struct sockaddr_sco remote_addr_sco ; 66 struct sockaddr_l2 remote_addr_l2 ; 67 struct sockaddr_in remote_addr_in ; 68 69 static void print_events(int events) { 70 if (events & POLLIN) printf("POLLIN "); 71 if (events & POLLPRI) printf("POLLPRI "); 72 if (events & POLLOUT) printf("POLLOUT "); 73 if (events & POLLERR) printf("POLLERR "); 74 if (events & POLLHUP) printf("POLLHUP "); 75 if (events & POLLNVAL) printf("POLLNVAL "); 76 printf("\n"); 77 } 78 79 static void print_fds(struct pollfd *ufds, nfds_t nfds) { 80 unsigned int i; 81 for (i=0; i<nfds; i++) 82 printf("%d ", ufds[i].fd); 83 } 84 85 static int _socket(int type) { 86 int ret; 87 int family = -1; 88 int typ = -1; 89 int protocol = -1; 90 91 switch (type) { 92 case UNIX: 93 family = PF_UNIX; 94 typ = SOCK_STREAM; 95 protocol = 0; 96 break; 97 case RFCOMM: 98 family = PF_BLUETOOTH; 99 typ = SOCK_STREAM; 100 protocol = BTPROTO_RFCOMM; 101 break; 102 case SCO: 103 family = PF_BLUETOOTH; 104 typ = SOCK_SEQPACKET; 105 protocol = BTPROTO_SCO; 106 break; 107 case L2CAP: 108 family = PF_BLUETOOTH; 109 typ = SOCK_SEQPACKET; 110 protocol = BTPROTO_L2CAP; 111 break; 112 case TCP: 113 family = PF_INET; 114 typ = SOCK_STREAM; 115 protocol = 0; 116 break; 117 } 118 119 printf("%d: socket()\n", gettid()); 120 ret = socket(family, typ, protocol); 121 printf("%d: socket() = %d\n", gettid(), ret); 122 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 123 124 return ret; 125 } 126 127 static int _close(int fd, int type) { 128 int ret; 129 130 printf("%d: close(%d)\n", gettid(), fd); 131 ret = close(fd); 132 printf("%d: close(%d) = %d\n", gettid(), fd, ret); 133 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 134 135 return ret; 136 } 137 138 static int _bind(int fd, int type) { 139 int len = 0; 140 int ret; 141 struct sockaddr *addr = NULL; 142 143 switch (type) { 144 case UNIX: 145 unlink(local_addr_un.sun_path); 146 addr = (struct sockaddr *) &local_addr_un; 147 len = sizeof(local_addr_un); 148 break; 149 case RFCOMM: 150 addr = (struct sockaddr *) &local_addr_rc; 151 len = sizeof(local_addr_rc); 152 break; 153 case SCO: 154 addr = (struct sockaddr *) &local_addr_sco; 155 len = sizeof(local_addr_sco); 156 break; 157 case L2CAP: 158 addr = (struct sockaddr *) &local_addr_l2; 159 len = sizeof(local_addr_l2); 160 break; 161 case TCP: 162 addr = (struct sockaddr *) &local_addr_in; 163 len = sizeof(local_addr_in); 164 break; 165 } 166 167 printf("%d: bind(%d)\n", gettid(), fd); 168 ret = bind(fd, addr, len); 169 printf("%d: bind(%d) = %d\n", gettid(), fd, ret); 170 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 171 172 return ret; 173 } 174 175 static int _listen(int fd, int type) { 176 int ret; 177 178 printf("%d: listen(%d)\n", gettid(), fd); 179 ret = listen(fd, 1); 180 printf("%d: listen(%d) = %d\n", gettid(), fd, ret); 181 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 182 183 return ret; 184 } 185 186 static int _read(int fd) { 187 int ret; 188 char buf; 189 190 printf("%d: read(%d)\n", gettid(), fd); 191 ret = read(fd, &buf, 1); 192 printf("%d: read(%d) = %d [%d]\n", gettid(), fd, ret, (int)buf); 193 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 194 195 return ret; 196 } 197 198 199 static int _accept(int fd, int type) { 200 int ret; 201 int len; 202 struct sockaddr *addr = NULL; 203 204 switch (type) { 205 case UNIX: 206 addr = (struct sockaddr *) &remote_addr_un; 207 len = sizeof(remote_addr_un); 208 break; 209 case RFCOMM: 210 addr = (struct sockaddr *) &remote_addr_rc; 211 len = sizeof(remote_addr_rc); 212 break; 213 case SCO: 214 addr = (struct sockaddr *) &remote_addr_sco; 215 len = sizeof(remote_addr_sco); 216 break; 217 case L2CAP: 218 addr = (struct sockaddr *) &remote_addr_l2; 219 len = sizeof(remote_addr_l2); 220 break; 221 case TCP: 222 addr = (struct sockaddr *) &remote_addr_in; 223 len = sizeof(remote_addr_in); 224 break; 225 } 226 227 printf("%d: accept(%d)\n", gettid(), fd); 228 ret = accept(fd, addr, &len); 229 printf("%d: accept(%d) = %d\n", gettid(), fd, ret); 230 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 231 else { 232 printf("\tlen = %d\n", len); 233 } 234 235 return ret; 236 } 237 238 static int _connect(int fd, int type) { 239 int ret; 240 int len = 0; 241 struct sockaddr *addr = NULL; 242 243 switch (type) { 244 case UNIX: 245 addr = (struct sockaddr *) &local_addr_un; 246 len = sizeof(local_addr_un); 247 break; 248 case RFCOMM: 249 addr = (struct sockaddr *) &local_addr_rc; 250 len = sizeof(local_addr_rc); 251 break; 252 case SCO: 253 addr = (struct sockaddr *) &local_addr_sco; 254 len = sizeof(local_addr_sco); 255 break; 256 case L2CAP: 257 addr = (struct sockaddr *) &local_addr_l2; 258 len = sizeof(local_addr_l2); 259 break; 260 case TCP: 261 addr = (struct sockaddr *) &local_addr_in; 262 len = sizeof(local_addr_in); 263 break; 264 } 265 266 printf("%d: connect(%d)\n", gettid(), fd); 267 ret = connect(fd, addr, len); 268 printf("%d: connect(%d) = %d\n", gettid(), fd, ret); 269 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 270 271 return ret; 272 } 273 274 static int _write(int fd, int type) { 275 int ret; 276 char buf = 69; 277 278 printf("%d: write(%d)\n", gettid(), fd); 279 ret = write(fd, &buf, 1); 280 printf("%d: write(%d) = %d\n", gettid(), fd, ret); 281 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 282 283 return ret; 284 } 285 286 static int _shutdown(int fd, int how) { 287 int ret; 288 289 printf("%d: shutdown(%d)\n", gettid(), fd); 290 ret = shutdown(fd, how); 291 printf("%d: shutdown(%d) = %d\n", gettid(), fd, ret); 292 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 293 294 return ret; 295 } 296 297 static int _poll(struct pollfd *ufds, nfds_t nfds, int timeout) { 298 int ret; 299 unsigned int i; 300 301 printf("%d: poll(", gettid()); 302 print_fds(ufds, nfds); 303 printf(")\n"); 304 ret = poll(ufds, nfds, timeout); 305 printf("%d: poll() = %d\n", gettid(), ret); 306 if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno)); 307 if (ret > 0) { 308 for (i=0; i<nfds; i++) { 309 if (ufds[i].revents) { 310 printf("\tfd %d ", ufds[i].fd); print_events(ufds[i].revents); 311 } 312 } 313 } 314 return ret; 315 } 316 317 static void thread_delay_close(struct thread_args *args) { 318 printf("%d: START\n", gettid()); 319 sleep(args->delay); 320 _close(args->fd, args->type); 321 printf("%d: END\n", gettid()); 322 } 323 324 static void thread_poll(void *args) { 325 int fd = (int)args; 326 struct pollfd pfd; 327 printf("%d: START\n", gettid()); 328 pfd.fd = fd; 329 pfd.events = 0; 330 _poll(&pfd, 1, -1); 331 printf("%d: END\n", gettid()); 332 } 333 334 static void thread_read(void *args) { 335 int fd = (int)args; 336 printf("%d: START\n", gettid()); 337 _read(fd); 338 printf("%d: END\n", gettid()); 339 } 340 341 static void thread_pollin(void *args) { 342 int fd = (int)args; 343 struct pollfd pfd; 344 printf("%d: START\n", gettid()); 345 pfd.fd = fd; 346 pfd.events = POLLIN; 347 _poll(&pfd, 1, -1); 348 printf("%d: END\n", gettid()); 349 } 350 351 static void thread_shutdown(int fd) { 352 printf("%d: START\n", gettid()); 353 sleep(4); 354 _shutdown(fd, SHUT_RDWR); 355 printf("%d: END\n", gettid()); 356 } 357 358 static void thread_accept(struct thread_args *args) { 359 printf("%d: START\n", gettid()); 360 sleep(args->delay); 361 _accept(args->fd, args->type); 362 printf("%d: END\n", gettid()); 363 } 364 365 static void thread_connect(struct thread_args *args) { 366 printf("%d: START\n", gettid()); 367 sleep(args->delay); 368 _connect(args->fd, args->type); 369 printf("%d: END\n", gettid()); 370 } 371 372 static void thread_delay_close_write(struct thread_args *args) { 373 printf("%d: START\n", gettid()); 374 sleep(args->delay); 375 _close(args->fd, args->type); 376 sleep(args->delay); 377 _write(args->fd, args->type); 378 printf("%d: END\n", gettid()); 379 } 380 381 static void thread_accept_write(struct thread_args *args) { 382 printf("%d: START\n", gettid()); 383 sleep(args->delay); 384 _accept(args->fd, args->type); 385 sleep(args->delay); 386 _write(args->fd, args->type); 387 printf("%d: END\n", gettid()); 388 } 389 390 static void thread_delay_connect(struct thread_args *args) { 391 printf("%d: START\n", gettid()); 392 sleep(args->delay); 393 args->fd = _socket(args->type); 394 _connect(args->fd, args->type); 395 printf("%d: END\n", gettid()); 396 } 397 398 static int do_accept_accept_accept(int type) { 399 int fd; 400 401 fd = _socket(type); 402 if (fd < 0) goto error; 403 404 if (_bind(fd, type) < 0) goto error; 405 406 if (_listen(fd, type) < 0) goto error; 407 408 while (1) { 409 _accept(fd, type); 410 } 411 412 return 0; 413 414 error: 415 return -1; 416 } 417 418 static int do_accept_and_close(int type) { 419 int fd; 420 pthread_t thread; 421 struct thread_args args = {-1, type, 1}; 422 423 fd = _socket(type); 424 if (fd < 0) goto error; 425 426 if (_bind(fd, type) < 0) goto error; 427 428 if (_listen(fd, type) < 0) goto error; 429 430 args.fd = fd; 431 pthread_create(&thread, NULL, (void *)thread_delay_close, (void *)&args); 432 433 _accept(fd, type); 434 435 pthread_join(thread, NULL); 436 437 return 0; 438 439 error: 440 return -1; 441 } 442 443 static int do_accept_shutdown(int type) { 444 int fd; 445 pthread_t thread; 446 struct thread_args args = {-1, type, 0}; 447 448 fd = _socket(type); 449 if (fd < 0) goto error; 450 451 if (_bind(fd, type) < 0) goto error; 452 453 if (_listen(fd, type) < 0) goto error; 454 455 args.fd = fd; 456 pthread_create(&thread, NULL, (void *)thread_accept, (void *)&args); 457 458 sleep(4); 459 _shutdown(fd, SHUT_RDWR); 460 461 pthread_join(thread, NULL); 462 463 _close(fd, type); 464 465 return 0; 466 467 error: 468 return -1; 469 } 470 471 static int do_connect_shutdown(int type) { 472 int fd; 473 pthread_t thread; 474 struct thread_args args = {-1, type, 0}; 475 476 fd = _socket(type); 477 if (fd < 0) goto error; 478 479 args.fd = fd; 480 pthread_create(&thread, NULL, (void *)thread_connect, (void *)&args); 481 482 sleep(4); 483 _shutdown(fd, SHUT_RDWR); 484 485 pthread_join(thread, NULL); 486 487 _close(fd, type); 488 489 return 0; 490 491 error: 492 return -1; 493 } 494 495 // accept in one thread. close then write in another 496 static int do_accept_close_write(int type) { 497 int fd; 498 pthread_t thread; 499 struct thread_args args = {-1, type, 1}; 500 501 fd = _socket(type); 502 if (fd < 0) goto error; 503 504 if (_bind(fd, type) < 0) goto error; 505 506 if (_listen(fd, type) < 0) goto error; 507 508 args.fd = fd; 509 pthread_create(&thread, NULL, (void *)thread_delay_close_write, (void *)&args); 510 511 _accept(fd, type); 512 513 pthread_join(thread, NULL); 514 515 return 0; 516 517 error: 518 return -1; 519 } 520 521 static int do_poll_poll_poll_shutdown(int type) { 522 const int MAX_T = 32; 523 int fd; 524 pthread_t t[MAX_T]; 525 int i; 526 527 fd = _socket(type); 528 529 for (i=0; i<MAX_T; i++) 530 pthread_create(&t[i], NULL, (void *)thread_poll, (void *)fd); 531 532 sleep(1); 533 534 _shutdown(fd, SHUT_RDWR); 535 536 for (i=0; i<MAX_T; i++) 537 pthread_join(t[i], NULL); 538 539 _close(fd, type); 540 541 return 0; 542 } 543 544 static int do_poll_poll_poll_close(int type) { 545 const int MAX_T = 32; 546 int fd; 547 pthread_t t[MAX_T]; 548 int i; 549 550 fd = _socket(type); 551 552 for (i=0; i<MAX_T; i++) 553 pthread_create(&t[i], NULL, (void *)thread_poll, (void *)fd); 554 555 sleep(1); 556 557 _close(fd, type); 558 559 for (i=0; i<MAX_T; i++) 560 pthread_join(t[i], NULL); 561 562 return 0; 563 } 564 565 static int do_read_read_read_close(int type) { 566 const int MAX_T = 32; 567 int fd; 568 pthread_t t[MAX_T]; 569 int i; 570 571 fd = _socket(type); 572 573 for (i=0; i<MAX_T; i++) 574 pthread_create(&t[i], NULL, (void *)thread_read, (void *)fd); 575 576 sleep(1); 577 578 _close(fd, type); 579 580 for (i=0; i<MAX_T; i++) 581 pthread_join(t[i], NULL); 582 583 return 0; 584 } 585 586 static int do_read_read_read_shutdown(int type) { 587 const int MAX_T = 32; 588 int fd; 589 pthread_t t[MAX_T]; 590 int i; 591 592 fd = _socket(type); 593 594 for (i=0; i<MAX_T; i++) 595 pthread_create(&t[i], NULL, (void *)thread_read, (void *)fd); 596 597 sleep(1); 598 599 _shutdown(fd, SHUT_RDWR); 600 601 for (i=0; i<MAX_T; i++) 602 pthread_join(t[i], NULL); 603 604 _close(fd, type); 605 606 return 0; 607 } 608 609 static int do_connected_read1_shutdown1(int type) { 610 int fd1, fd2; 611 pthread_t t1; 612 pthread_t t2; 613 struct thread_args a1 = {-1, type, 0}; 614 struct thread_args a2 = {-1, type, 2}; 615 616 fd1 = _socket(type); 617 if (fd1 < 0) goto error; 618 619 if (_bind(fd1, type) < 0) goto error; 620 621 if (_listen(fd1, type) < 0) goto error; 622 623 a1.fd = fd1; 624 pthread_create(&t1, NULL, (void *)thread_accept_write, (void *)&a1); 625 626 fd2 = _socket(type); 627 if (_connect(fd2, type)) goto error; 628 629 pthread_create(&t2, NULL, (void *)thread_shutdown, (void *)&fd2); 630 631 while (1) if (_read(fd2)) break; 632 633 pthread_join(t1, NULL); 634 pthread_join(t2, NULL); 635 636 return 0; 637 638 error: 639 return -1; 640 } 641 642 // accept in one thread, connect from two different threads 643 static int do_accept_connect_connect(int type) { 644 int fd; 645 pthread_t t1; 646 pthread_t t2; 647 struct thread_args a1 = {-1, type, 1}; 648 struct thread_args a2 = {-1, type, 2}; 649 650 fd = _socket(type); 651 if (fd < 0) goto error; 652 653 if (_bind(fd, type) < 0) goto error; 654 655 if (_listen(fd, type) < 0) goto error; 656 657 pthread_create(&t1, NULL, (void *)thread_delay_connect, (void *)&a1); 658 pthread_create(&t2, NULL, (void *)thread_delay_connect, (void *)&a2); 659 660 _accept(fd, type); 661 662 pthread_join(t1, NULL); 663 pthread_join(t2, NULL); 664 665 return 0; 666 667 error: 668 return -1; 669 } 670 671 struct { 672 char *name; 673 int (*ptr)(int); 674 } action_table[] = { 675 {"accept_accept_accept", do_accept_accept_accept}, 676 {"accept_and_close", do_accept_and_close}, 677 {"accept_shutdown", do_accept_shutdown}, 678 {"connect_shutdown", do_connect_shutdown}, 679 {"accept_close_write", do_accept_close_write}, 680 {"accept_connect_connect", do_accept_connect_connect}, 681 {"poll_poll_poll_shutdown", do_poll_poll_poll_shutdown}, 682 {"poll_poll_poll_close", do_poll_poll_poll_close}, 683 {"read_read_read_shutdown", do_read_read_read_shutdown}, 684 {"read_read_read_close", do_read_read_read_close}, 685 {"connected_read1_shutdown1", do_connected_read1_shutdown1}, 686 {NULL, NULL}, 687 }; 688 689 struct { 690 char *name; 691 enum sock_type type; 692 } type_table[] = { 693 {"unix", UNIX}, 694 {"rfcomm", RFCOMM}, 695 {"sco", SCO}, 696 {"l2cap", L2CAP}, 697 {"tcp", TCP}, 698 {NULL, -1}, 699 }; 700 701 static void usage() { 702 int i; 703 704 printf("socktest TYPE ACTION\n"); 705 printf("\nTYPE:\n"); 706 for (i = 0; type_table[i].name; i++) { 707 printf("\t%s\n", type_table[i].name); 708 } 709 printf("\nACTION:\n"); 710 for (i = 0; action_table[i].name; i++) { 711 printf("\t%s\n", action_table[i].name); 712 } 713 } 714 715 int main(int argc, char **argv) { 716 int i; 717 int type = -1; 718 719 if (argc != 3) { 720 usage(); 721 return -1; 722 } 723 for (i = 0; type_table[i].name; i++) { 724 if (!strcmp(argv[1], type_table[i].name)) { 725 type = type_table[i].type; 726 break; 727 } 728 } 729 if (type == -1) { 730 usage(); 731 return -1; 732 } 733 for (i = 0; action_table[i].name; i++) { 734 if (!strcmp(argv[2], action_table[i].name)) { 735 printf("TYPE = %s ACTION = %s\n", type_table[type].name, 736 action_table[i].name); 737 return (*action_table[i].ptr)(type); 738 } 739 } 740 usage(); 741 return -1; 742 } 743
