tests/test_tcp_listen.c

   1 #include <stdarg.h>
   2 #include <stddef.h>
   3 #include <setjmp.h>
   4 #include <cmocka.h>
   5
   6 #include "config.h"
   7 #include "torture.h"
   8
   9 #include <errno.h>
  10 #include <sys/types.h>
  11 #include <sys/socket.h>
  12 #include <sys/un.h>
  13 #include <netinet/in.h>
  14 #include <arpa/inet.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <unistd.h>
  18 #ifdef HAVE_RPC_RPC_H
  19 #include <rpc/rpc.h>
  20 #endif
  21
  22 static int setup(void **state)
  23 {
  24         torture_setup_socket_dir(state);
  25
  26         return 0;
  27 }
  28
  29 static int teardown(void **state)
  30 {
  31         torture_teardown_socket_dir(state);
  32
  33         return 0;
  34 }
  35
  36 static void test_listen_unbound_ipv4(void **state)
  37 {
  38         struct torture_address addr = {
  39                 .sa_socklen = sizeof(struct sockaddr_storage),
  40         };
  41         int rc;
  42         int s1;
  43         int s2;
  44
  45         (void) state; /* unused */
  46
  47         s1 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  48         assert_return_code(s1, errno);
  49
  50         rc = listen(s1, SOMAXCONN);
  51         assert_return_code(rc, errno);
  52
  53         rc = getsockname(s1, &addr.sa.s, &addr.sa_socklen);
  54         assert_return_code(rc, errno);
  55         assert_int_equal(addr.sa.in.sin_family, AF_INET);
  56         assert_int_equal(addr.sa_socklen, sizeof(struct sockaddr_in));
  57         assert_in_range(ntohs(addr.sa.in.sin_port), 1024, 65535);
  58
  59         s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  60         assert_return_code(s2, errno);
  61
  62         rc = connect(s2, &addr.sa.s, addr.sa_socklen);
  63         assert_return_code(rc, errno);
  64
  65         close(s1);
  66         close(s2);
  67 }
  68
  69 #ifdef HAVE_IPV6
  70 static void test_listen_unbound_ipv6(void **state)
  71 {
  72         struct torture_address addr = {
  73                 .sa_socklen = sizeof(struct sockaddr_storage),
  74         };
  75         int rc;
  76         int s1;
  77         int s2;
  78
  79         (void) state; /* unused */
  80
  81         s1 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
  82         assert_return_code(s1, errno);
  83
  84         rc = listen(s1, SOMAXCONN);
  85         assert_return_code(rc, errno);
  86
  87         rc = getsockname(s1, &addr.sa.s, &addr.sa_socklen);
  88         assert_return_code(rc, errno);
  89         assert_int_equal(addr.sa.in6.sin6_family, AF_INET6);
  90         assert_int_equal(addr.sa_socklen, sizeof(struct sockaddr_in6));
  91         assert_in_range(ntohs(addr.sa.in6.sin6_port), 1024, 65535);
  92
  93         s2 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
  94         assert_return_code(s2, errno);
  95
  96         rc = connect(s2, &addr.sa.s, addr.sa_socklen);
  97         assert_return_code(rc, errno);
  98
  99         close(s1);
 100         close(s2);
 101 }
 102 #endif /* HAVE_IPV6 */
 103
 104 int main(void) {
 105         int rc;
 106
 107         const struct CMUnitTest tcp_listen_tests[] = {
 108                 cmocka_unit_test(test_listen_unbound_ipv4),
 109 #ifdef HAVE_IPV6
 110                 cmocka_unit_test(test_listen_unbound_ipv6),
 111 #endif /* HAVE_IPV6 */
 112         };
 113
 114         rc = cmocka_run_group_tests(tcp_listen_tests, setup, teardown);
 115
 116         return rc;
 117 }