tools/testing/selftests/net/tls.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #define _GNU_SOURCE
   4
   5 #include <arpa/inet.h>
   6 #include <errno.h>
   7 #include <error.h>
   8 #include <fcntl.h>
   9 #include <poll.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <unistd.h>
  13
  14 #include <linux/tls.h>
  15 #include <linux/tcp.h>
  16 #include <linux/socket.h>
  17
  18 #include <sys/types.h>
  19 #include <sys/sendfile.h>
  20 #include <sys/socket.h>
  21 #include <sys/stat.h>
  22
  23 #include "../kselftest_harness.h"
  24
  25 #define TLS_PAYLOAD_MAX_LEN 16384
  26 #define SOL_TLS 282
  27
  28 FIXTURE(tls)
  29 {
  30         int fd, cfd;
  31         bool notls;
  32 };
  33
  34 FIXTURE_SETUP(tls)
  35 {
  36         struct tls12_crypto_info_aes_gcm_128 tls12;
  37         struct sockaddr_in addr;
  38         socklen_t len;
  39         int sfd, ret;
  40
  41         self->notls = false;
  42         len = sizeof(addr);
  43
  44         memset(&tls12, 0, sizeof(tls12));
  45         tls12.info.version = TLS_1_2_VERSION;
  46         tls12.info.cipher_type = TLS_CIPHER_AES_GCM_128;
  47
  48         addr.sin_family = AF_INET;
  49         addr.sin_addr.s_addr = htonl(INADDR_ANY);
  50         addr.sin_port = 0;
  51
  52         self->fd = socket(AF_INET, SOCK_STREAM, 0);
  53         sfd = socket(AF_INET, SOCK_STREAM, 0);
  54
  55         ret = bind(sfd, &addr, sizeof(addr));
  56         ASSERT_EQ(ret, 0);
  57         ret = listen(sfd, 10);
  58         ASSERT_EQ(ret, 0);
  59
  60         ret = getsockname(sfd, &addr, &len);
  61         ASSERT_EQ(ret, 0);
  62
  63         ret = connect(self->fd, &addr, sizeof(addr));
  64         ASSERT_EQ(ret, 0);
  65
  66         ret = setsockopt(self->fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
  67         if (ret != 0) {
  68                 self->notls = true;
  69                 printf("Failure setting TCP_ULP, testing without tls\n");
  70         }
  71
  72         if (!self->notls) {
  73                 ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12,
  74                                  sizeof(tls12));
  75                 ASSERT_EQ(ret, 0);
  76         }
  77
  78         self->cfd = accept(sfd, &addr, &len);
  79         ASSERT_GE(self->cfd, 0);
  80
  81         if (!self->notls) {
  82                 ret = setsockopt(self->cfd, IPPROTO_TCP, TCP_ULP, "tls",
  83                                  sizeof("tls"));
  84                 ASSERT_EQ(ret, 0);
  85
  86                 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12,
  87                                  sizeof(tls12));
  88                 ASSERT_EQ(ret, 0);
  89         }
  90
  91         close(sfd);
  92 }
  93
  94 FIXTURE_TEARDOWN(tls)
  95 {
  96         close(self->fd);
  97         close(self->cfd);
  98 }
  99
 100 TEST_F(tls, sendfile)
 101 {
 102         int filefd = open("/proc/self/exe", O_RDONLY);
 103         struct stat st;
 104
 105         EXPECT_GE(filefd, 0);
 106         fstat(filefd, &st);
 107         EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
 108 }
 109
 110 TEST_F(tls, send_then_sendfile)
 111 {
 112         int filefd = open("/proc/self/exe", O_RDONLY);
 113         char const *test_str = "test_send";
 114         int to_send = strlen(test_str) + 1;
 115         char recv_buf[10];
 116         struct stat st;
 117         char *buf;
 118
 119         EXPECT_GE(filefd, 0);
 120         fstat(filefd, &st);
 121         buf = (char *)malloc(st.st_size);
 122
 123         EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
 124         EXPECT_EQ(recv(self->cfd, recv_buf, to_send, 0), to_send);
 125         EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
 126
 127         EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
 128         EXPECT_EQ(recv(self->cfd, buf, st.st_size, 0), st.st_size);
 129 }
 130
 131 TEST_F(tls, recv_max)
 132 {
 133         unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
 134         char recv_mem[TLS_PAYLOAD_MAX_LEN];
 135         char buf[TLS_PAYLOAD_MAX_LEN];
 136
 137         EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
 138         EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
 139         EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
 140 }
 141
 142 TEST_F(tls, recv_small)
 143 {
 144         char const *test_str = "test_read";
 145         int send_len = 10;
 146         char buf[10];
 147
 148         send_len = strlen(test_str) + 1;
 149         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 150         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 151         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 152 }
 153
 154 TEST_F(tls, msg_more)
 155 {
 156         char const *test_str = "test_read";
 157         int send_len = 10;
 158         char buf[10 * 2];
 159
 160         EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
 161         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
 162         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 163         EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_DONTWAIT),
 164                   send_len * 2);
 165         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 166 }
 167
 168 TEST_F(tls, sendmsg_single)
 169 {
 170         struct msghdr msg;
 171
 172         char const *test_str = "test_sendmsg";
 173         size_t send_len = 13;
 174         struct iovec vec;
 175         char buf[13];
 176
 177         vec.iov_base = (char *)test_str;
 178         vec.iov_len = send_len;
 179         memset(&msg, 0, sizeof(struct msghdr));
 180         msg.msg_iov = &vec;
 181         msg.msg_iovlen = 1;
 182         EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
 183         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
 184         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 185 }
 186
 187 TEST_F(tls, sendmsg_large)
 188 {
 189         void *mem = malloc(16384);
 190         size_t send_len = 16384;
 191         size_t sends = 128;
 192         struct msghdr msg;
 193         size_t recvs = 0;
 194         size_t sent = 0;
 195
 196         memset(&msg, 0, sizeof(struct msghdr));
 197         while (sent++ < sends) {
 198                 struct iovec vec = { (void *)mem, send_len };
 199
 200                 msg.msg_iov = &vec;
 201                 msg.msg_iovlen = 1;
 202                 EXPECT_EQ(sendmsg(self->cfd, &msg, 0), send_len);
 203         }
 204
 205         while (recvs++ < sends)
 206                 EXPECT_NE(recv(self->fd, mem, send_len, 0), -1);
 207
 208         free(mem);
 209 }
 210
 211 TEST_F(tls, sendmsg_multiple)
 212 {
 213         char const *test_str = "test_sendmsg_multiple";
 214         struct iovec vec[5];
 215         char *test_strs[5];
 216         struct msghdr msg;
 217         int total_len = 0;
 218         int len_cmp = 0;
 219         int iov_len = 5;
 220         char *buf;
 221         int i;
 222
 223         memset(&msg, 0, sizeof(struct msghdr));
 224         for (i = 0; i < iov_len; i++) {
 225                 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
 226                 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
 227                 vec[i].iov_base = (void *)test_strs[i];
 228                 vec[i].iov_len = strlen(test_strs[i]) + 1;
 229                 total_len += vec[i].iov_len;
 230         }
 231         msg.msg_iov = vec;
 232         msg.msg_iovlen = iov_len;
 233
 234         EXPECT_EQ(sendmsg(self->cfd, &msg, 0), total_len);
 235         buf = malloc(total_len);
 236         EXPECT_NE(recv(self->fd, buf, total_len, 0), -1);
 237         for (i = 0; i < iov_len; i++) {
 238                 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
 239                                  strlen(test_strs[i])),
 240                           0);
 241                 len_cmp += strlen(buf + len_cmp) + 1;
 242         }
 243         for (i = 0; i < iov_len; i++)
 244                 free(test_strs[i]);
 245         free(buf);
 246 }
 247
 248 TEST_F(tls, sendmsg_multiple_stress)
 249 {
 250         char const *test_str = "abcdefghijklmno";
 251         struct iovec vec[1024];
 252         char *test_strs[1024];
 253         int iov_len = 1024;
 254         int total_len = 0;
 255         char buf[1 << 14];
 256         struct msghdr msg;
 257         int len_cmp = 0;
 258         int i;
 259
 260         memset(&msg, 0, sizeof(struct msghdr));
 261         for (i = 0; i < iov_len; i++) {
 262                 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
 263                 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
 264                 vec[i].iov_base = (void *)test_strs[i];
 265                 vec[i].iov_len = strlen(test_strs[i]) + 1;
 266                 total_len += vec[i].iov_len;
 267         }
 268         msg.msg_iov = vec;
 269         msg.msg_iovlen = iov_len;
 270
 271         EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
 272         EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
 273
 274         for (i = 0; i < iov_len; i++)
 275                 len_cmp += strlen(buf + len_cmp) + 1;
 276
 277         for (i = 0; i < iov_len; i++)
 278                 free(test_strs[i]);
 279 }
 280
 281 TEST_F(tls, splice_from_pipe)
 282 {
 283         int send_len = TLS_PAYLOAD_MAX_LEN;
 284         char mem_send[TLS_PAYLOAD_MAX_LEN];
 285         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 286         int p[2];
 287
 288         ASSERT_GE(pipe(p), 0);
 289         EXPECT_GE(write(p[1], mem_send, send_len), 0);
 290         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
 291         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 292         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 293 }
 294
 295 TEST_F(tls, splice_from_pipe2)
 296 {
 297         int send_len = 16000;
 298         char mem_send[16000];
 299         char mem_recv[16000];
 300         int p2[2];
 301         int p[2];
 302
 303         ASSERT_GE(pipe(p), 0);
 304         ASSERT_GE(pipe(p2), 0);
 305         EXPECT_GE(write(p[1], mem_send, 8000), 0);
 306         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
 307         EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
 308         EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
 309         EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
 310         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 311 }
 312
 313 TEST_F(tls, send_and_splice)
 314 {
 315         int send_len = TLS_PAYLOAD_MAX_LEN;
 316         char mem_send[TLS_PAYLOAD_MAX_LEN];
 317         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 318         char const *test_str = "test_read";
 319         int send_len2 = 10;
 320         char buf[10];
 321         int p[2];
 322
 323         ASSERT_GE(pipe(p), 0);
 324         EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
 325         EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
 326         EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
 327
 328         EXPECT_GE(write(p[1], mem_send, send_len), send_len);
 329         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
 330
 331         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 332         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 333 }
 334
 335 TEST_F(tls, splice_to_pipe)
 336 {
 337         int send_len = TLS_PAYLOAD_MAX_LEN;
 338         char mem_send[TLS_PAYLOAD_MAX_LEN];
 339         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 340         int p[2];
 341
 342         ASSERT_GE(pipe(p), 0);
 343         EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
 344         EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
 345         EXPECT_GE(read(p[0], mem_recv, send_len), 0);
 346         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 347 }
 348
 349 TEST_F(tls, recvmsg_single)
 350 {
 351         char const *test_str = "test_recvmsg_single";
 352         int send_len = strlen(test_str) + 1;
 353         char buf[20];
 354         struct msghdr hdr;
 355         struct iovec vec;
 356
 357         memset(&hdr, 0, sizeof(hdr));
 358         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 359         vec.iov_base = (char *)buf;
 360         vec.iov_len = send_len;
 361         hdr.msg_iovlen = 1;
 362         hdr.msg_iov = &vec;
 363         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 364         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 365 }
 366
 367 TEST_F(tls, recvmsg_single_max)
 368 {
 369         int send_len = TLS_PAYLOAD_MAX_LEN;
 370         char send_mem[TLS_PAYLOAD_MAX_LEN];
 371         char recv_mem[TLS_PAYLOAD_MAX_LEN];
 372         struct iovec vec;
 373         struct msghdr hdr;
 374
 375         EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
 376         vec.iov_base = (char *)recv_mem;
 377         vec.iov_len = TLS_PAYLOAD_MAX_LEN;
 378
 379         hdr.msg_iovlen = 1;
 380         hdr.msg_iov = &vec;
 381         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 382         EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
 383 }
 384
 385 TEST_F(tls, recvmsg_multiple)
 386 {
 387         unsigned int msg_iovlen = 1024;
 388         unsigned int len_compared = 0;
 389         struct iovec vec[1024];
 390         char *iov_base[1024];
 391         unsigned int iov_len = 16;
 392         int send_len = 1 << 14;
 393         char buf[1 << 14];
 394         struct msghdr hdr;
 395         int i;
 396
 397         EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
 398         for (i = 0; i < msg_iovlen; i++) {
 399                 iov_base[i] = (char *)malloc(iov_len);
 400                 vec[i].iov_base = iov_base[i];
 401                 vec[i].iov_len = iov_len;
 402         }
 403
 404         hdr.msg_iovlen = msg_iovlen;
 405         hdr.msg_iov = vec;
 406         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 407         for (i = 0; i < msg_iovlen; i++)
 408                 len_compared += iov_len;
 409
 410         for (i = 0; i < msg_iovlen; i++)
 411                 free(iov_base[i]);
 412 }
 413
 414 TEST_F(tls, single_send_multiple_recv)
 415 {
 416         unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
 417         unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
 418         char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
 419         char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
 420
 421         EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
 422         memset(recv_mem, 0, total_len);
 423
 424         EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
 425         EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
 426         EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
 427 }
 428
 429 TEST_F(tls, multiple_send_single_recv)
 430 {
 431         unsigned int total_len = 2 * 10;
 432         unsigned int send_len = 10;
 433         char recv_mem[2 * 10];
 434         char send_mem[10];
 435
 436         EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
 437         EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
 438         memset(recv_mem, 0, total_len);
 439         EXPECT_EQ(recv(self->cfd, recv_mem, total_len, 0), total_len);
 440
 441         EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
 442         EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
 443 }
 444
 445 TEST_F(tls, recv_partial)
 446 {
 447         char const *test_str = "test_read_partial";
 448         char const *test_str_first = "test_read";
 449         char const *test_str_second = "_partial";
 450         int send_len = strlen(test_str) + 1;
 451         char recv_mem[18];
 452
 453         memset(recv_mem, 0, sizeof(recv_mem));
 454         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 455         EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first), 0), -1);
 456         EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
 457         memset(recv_mem, 0, sizeof(recv_mem));
 458         EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
 459         EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
 460                   0);
 461 }
 462
 463 TEST_F(tls, recv_nonblock)
 464 {
 465         char buf[4096];
 466         bool err;
 467
 468         EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
 469         err = (errno == EAGAIN || errno == EWOULDBLOCK);
 470         EXPECT_EQ(err, true);
 471 }
 472
 473 TEST_F(tls, recv_peek)
 474 {
 475         char const *test_str = "test_read_peek";
 476         int send_len = strlen(test_str) + 1;
 477         char buf[15];
 478
 479         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 480         EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
 481         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 482         memset(buf, 0, sizeof(buf));
 483         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 484         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 485 }
 486
 487 TEST_F(tls, recv_peek_multiple)
 488 {
 489         char const *test_str = "test_read_peek";
 490         int send_len = strlen(test_str) + 1;
 491         unsigned int num_peeks = 100;
 492         char buf[15];
 493         int i;
 494
 495         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 496         for (i = 0; i < num_peeks; i++) {
 497                 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
 498                 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 499                 memset(buf, 0, sizeof(buf));
 500         }
 501         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 502         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 503 }
 504
 505 TEST_F(tls, recv_peek_multiple_records)
 506 {
 507         char const *test_str = "test_read_peek_mult_recs";
 508         char const *test_str_first = "test_read_peek";
 509         char const *test_str_second = "_mult_recs";
 510         int len;
 511         char buf[64];
 512
 513         len = strlen(test_str_first);
 514         EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
 515
 516         len = strlen(test_str_second) + 1;
 517         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
 518
 519         len = strlen(test_str_first);
 520         memset(buf, 0, len);
 521         EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
 522
 523         /* MSG_PEEK can only peek into the current record. */
 524         len = strlen(test_str_first);
 525         EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
 526
 527         len = strlen(test_str) + 1;
 528         memset(buf, 0, len);
 529         EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
 530
 531         /* Non-MSG_PEEK will advance strparser (and therefore record)
 532          * however.
 533          */
 534         len = strlen(test_str) + 1;
 535         EXPECT_EQ(memcmp(test_str, buf, len), 0);
 536
 537         /* MSG_MORE will hold current record open, so later MSG_PEEK
 538          * will see everything.
 539          */
 540         len = strlen(test_str_first);
 541         EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
 542
 543         len = strlen(test_str_second) + 1;
 544         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
 545
 546         len = strlen(test_str) + 1;
 547         memset(buf, 0, len);
 548         EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
 549
 550         len = strlen(test_str) + 1;
 551         EXPECT_EQ(memcmp(test_str, buf, len), 0);
 552 }
 553
 554 TEST_F(tls, pollin)
 555 {
 556         char const *test_str = "test_poll";
 557         struct pollfd fd = { 0, 0, 0 };
 558         char buf[10];
 559         int send_len = 10;
 560
 561         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 562         fd.fd = self->cfd;
 563         fd.events = POLLIN;
 564
 565         EXPECT_EQ(poll(&fd, 1, 20), 1);
 566         EXPECT_EQ(fd.revents & POLLIN, 1);
 567         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
 568         /* Test timing out */
 569         EXPECT_EQ(poll(&fd, 1, 20), 0);
 570 }
 571
 572 TEST_F(tls, poll_wait)
 573 {
 574         char const *test_str = "test_poll_wait";
 575         int send_len = strlen(test_str) + 1;
 576         struct pollfd fd = { 0, 0, 0 };
 577         char recv_mem[15];
 578
 579         fd.fd = self->cfd;
 580         fd.events = POLLIN;
 581         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 582         /* Set timeout to inf. secs */
 583         EXPECT_EQ(poll(&fd, 1, -1), 1);
 584         EXPECT_EQ(fd.revents & POLLIN, 1);
 585         EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len);
 586 }
 587
 588 TEST_F(tls, blocking)
 589 {
 590         size_t data = 100000;
 591         int res = fork();
 592
 593         EXPECT_NE(res, -1);
 594
 595         if (res) {
 596                 /* parent */
 597                 size_t left = data;
 598                 char buf[16384];
 599                 int status;
 600                 int pid2;
 601
 602                 while (left) {
 603                         int res = send(self->fd, buf,
 604                                        left > 16384 ? 16384 : left, 0);
 605
 606                         EXPECT_GE(res, 0);
 607                         left -= res;
 608                 }
 609
 610                 pid2 = wait(&status);
 611                 EXPECT_EQ(status, 0);
 612                 EXPECT_EQ(res, pid2);
 613         } else {
 614                 /* child */
 615                 size_t left = data;
 616                 char buf[16384];
 617
 618                 while (left) {
 619                         int res = recv(self->cfd, buf,
 620                                        left > 16384 ? 16384 : left, 0);
 621
 622                         EXPECT_GE(res, 0);
 623                         left -= res;
 624                 }
 625         }
 626 }
 627
 628 TEST_F(tls, nonblocking)
 629 {
 630         size_t data = 100000;
 631         int sendbuf = 100;
 632         int flags;
 633         int res;
 634
 635         flags = fcntl(self->fd, F_GETFL, 0);
 636         fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
 637         fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
 638
 639         /* Ensure nonblocking behavior by imposing a small send
 640          * buffer.
 641          */
 642         EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
 643                              &sendbuf, sizeof(sendbuf)), 0);
 644
 645         res = fork();
 646         EXPECT_NE(res, -1);
 647
 648         if (res) {
 649                 /* parent */
 650                 bool eagain = false;
 651                 size_t left = data;
 652                 char buf[16384];
 653                 int status;
 654                 int pid2;
 655
 656                 while (left) {
 657                         int res = send(self->fd, buf,
 658                                        left > 16384 ? 16384 : left, 0);
 659
 660                         if (res == -1 && errno == EAGAIN) {
 661                                 eagain = true;
 662                                 usleep(10000);
 663                                 continue;
 664                         }
 665                         EXPECT_GE(res, 0);
 666                         left -= res;
 667                 }
 668
 669                 EXPECT_TRUE(eagain);
 670                 pid2 = wait(&status);
 671
 672                 EXPECT_EQ(status, 0);
 673                 EXPECT_EQ(res, pid2);
 674         } else {
 675                 /* child */
 676                 bool eagain = false;
 677                 size_t left = data;
 678                 char buf[16384];
 679
 680                 while (left) {
 681                         int res = recv(self->cfd, buf,
 682                                        left > 16384 ? 16384 : left, 0);
 683
 684                         if (res == -1 && errno == EAGAIN) {
 685                                 eagain = true;
 686                                 usleep(10000);
 687                                 continue;
 688                         }
 689                         EXPECT_GE(res, 0);
 690                         left -= res;
 691                 }
 692                 EXPECT_TRUE(eagain);
 693         }
 694 }
 695
 696 TEST_F(tls, control_msg)
 697 {
 698         if (self->notls)
 699                 return;
 700
 701         char cbuf[CMSG_SPACE(sizeof(char))];
 702         char const *test_str = "test_read";
 703         int cmsg_len = sizeof(char);
 704         char record_type = 100;
 705         struct cmsghdr *cmsg;
 706         struct msghdr msg;
 707         int send_len = 10;
 708         struct iovec vec;
 709         char buf[10];
 710
 711         vec.iov_base = (char *)test_str;
 712         vec.iov_len = 10;
 713         memset(&msg, 0, sizeof(struct msghdr));
 714         msg.msg_iov = &vec;
 715         msg.msg_iovlen = 1;
 716         msg.msg_control = cbuf;
 717         msg.msg_controllen = sizeof(cbuf);
 718         cmsg = CMSG_FIRSTHDR(&msg);
 719         cmsg->cmsg_level = SOL_TLS;
 720         /* test sending non-record types. */
 721         cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
 722         cmsg->cmsg_len = CMSG_LEN(cmsg_len);
 723         *CMSG_DATA(cmsg) = record_type;
 724         msg.msg_controllen = cmsg->cmsg_len;
 725
 726         EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
 727         /* Should fail because we didn't provide a control message */
 728         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
 729
 730         vec.iov_base = buf;
 731         EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len);
 732         cmsg = CMSG_FIRSTHDR(&msg);
 733         EXPECT_NE(cmsg, NULL);
 734         EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
 735         EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
 736         record_type = *((unsigned char *)CMSG_DATA(cmsg));
 737         EXPECT_EQ(record_type, 100);
 738         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 739 }
 740
 741 TEST_HARNESS_MAIN