tests/test_echo_tcp_writev_readv.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/uio.h>
  13 #include <netinet/in.h>
  14 #include <arpa/inet.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <unistd.h>
  18
  19 static int setup_echo_srv_tcp_ipv4(void **state)
  20 {
  21         torture_setup_echo_srv_tcp_ipv4(state);
  22
  23         return 0;
  24 }
  25
  26 #ifdef HAVE_IPV6
  27 static int setup_echo_srv_tcp_ipv6(void **state)
  28 {
  29         torture_setup_echo_srv_tcp_ipv6(state);
  30
  31         return 0;
  32 }
  33 #endif
  34
  35 static int teardown(void **state)
  36 {
  37         torture_teardown_echo_srv(state);
  38
  39         return 0;
  40 }
  41
  42 static void test_writev_readv_ipv4(void **state)
  43 {
  44         struct torture_address addr = {
  45                 .sa_socklen = sizeof(struct sockaddr_in),
  46         };
  47         ssize_t ret;
  48         int rc;
  49         int i;
  50         int s;
  51
  52         (void) state; /* unused */
  53
  54         s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  55         assert_int_not_equal(s, -1);
  56
  57         addr.sa.in.sin_family = AF_INET;
  58         addr.sa.in.sin_port = htons(torture_server_port());
  59
  60         rc = inet_pton(addr.sa.in.sin_family,
  61                         torture_server_address(AF_INET),
  62                         &addr.sa.in.sin_addr);
  63         assert_int_equal(rc, 1);
  64
  65         rc = connect(s, &addr.sa.s, addr.sa_socklen);
  66         assert_int_equal(rc, 0);
  67
  68         for (i = 1; i < 10; i++) {
  69                 char send_buf[10][64];
  70                 char recv_buf[10][64];
  71                 struct iovec iov_send[10];
  72                 struct iovec iov_recv[10];
  73                 int j;
  74
  75                 for (j = 0; j < i; j++) {
  76                         memset(send_buf[j], 0, 64);
  77                         snprintf(send_buf[j], sizeof(send_buf[j]),
  78                                  "packet.%d", j);
  79
  80                         iov_send[j].iov_base = send_buf[j];
  81                         iov_send[j].iov_len = strlen(send_buf[j]);
  82
  83                         iov_recv[j].iov_base = recv_buf[j];
  84                         iov_recv[j].iov_len = strlen(send_buf[j]);
  85                 }
  86
  87                 ret = writev(s, iov_send, j);
  88                 assert_int_not_equal(ret, -1);
  89
  90                 ret = readv(s, iov_recv, j);
  91                 assert_int_not_equal(ret, -1);
  92
  93                 for (j = 0; j < i; j++) {
  94                         assert_int_equal(iov_send[j].iov_len,
  95                                          iov_recv[j].iov_len);
  96
  97                         assert_memory_equal(iov_send[j].iov_base,
  98                                             iov_recv[j].iov_base,
  99                                             iov_send[j].iov_len);
 100                 }
 101         }
 102
 103         close(s);
 104 }
 105
 106 #ifdef HAVE_IPV6
 107 static void test_writev_readv_ipv6(void **state)
 108 {
 109         struct torture_address addr = {
 110                 .sa_socklen = sizeof(struct sockaddr_in6),
 111         };
 112         ssize_t ret;
 113         int rc;
 114         int i;
 115         int s;
 116
 117         (void) state; /* unused */
 118
 119         s = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
 120         assert_int_not_equal(s, -1);
 121
 122         addr.sa.in6.sin6_family = AF_INET6;
 123         addr.sa.in6.sin6_port = htons(torture_server_port());
 124
 125         rc = inet_pton(AF_INET6,
 126                        torture_server_address(AF_INET6),
 127                        &addr.sa.in6.sin6_addr);
 128         assert_int_equal(rc, 1);
 129
 130         rc = connect(s, &addr.sa.s, addr.sa_socklen);
 131         assert_int_equal(rc, 0);
 132
 133         for (i = 1; i < 10; i++) {
 134                 char send_buf[10][64];
 135                 char recv_buf[10][64];
 136                 struct iovec iov_send[10];
 137                 struct iovec iov_recv[10];
 138                 int j;
 139
 140                 for (j = 0; j < i; j++) {
 141                         memset(send_buf[j], 0, 64);
 142                         snprintf(send_buf[j], sizeof(send_buf[j]),
 143                                  "packet.%d", j);
 144
 145                         iov_send[j].iov_base = send_buf[j];
 146                         iov_send[j].iov_len = strlen(send_buf[j]);
 147
 148                         iov_recv[j].iov_base = recv_buf[j];
 149                         iov_recv[j].iov_len = strlen(send_buf[j]);
 150                 }
 151
 152                 ret = writev(s, iov_send, j);
 153                 assert_int_not_equal(ret, -1);
 154
 155                 ret = readv(s, iov_recv, j);
 156                 assert_int_not_equal(ret, -1);
 157
 158                 for (j = 0; j < i; j++) {
 159                         assert_int_equal(iov_send[j].iov_len,
 160                                          iov_recv[j].iov_len);
 161
 162                         assert_memory_equal(iov_send[j].iov_base,
 163                                             iov_recv[j].iov_base,
 164                                             iov_send[j].iov_len);
 165                 }
 166         }
 167
 168         close(s);
 169 }
 170 #endif
 171
 172 int main(void) {
 173         int rc;
 174
 175         const struct CMUnitTest tcp_writev_tests[] = {
 176                 cmocka_unit_test_setup_teardown(test_writev_readv_ipv4,
 177                                                 setup_echo_srv_tcp_ipv4,
 178                                                 teardown),
 179 #ifdef HAVE_IPV6
 180                 cmocka_unit_test_setup_teardown(test_writev_readv_ipv6,
 181                                                 setup_echo_srv_tcp_ipv6,
 182                                                 teardown),
 183 #endif
 184         };
 185
 186         rc = cmocka_run_group_tests(tcp_writev_tests, NULL, NULL);
 187
 188         return rc;
 189 }