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->fd, &msg, 0), send_len);
 203         }
 204
 205         while (recvs++ < sends) {
 206                 EXPECT_NE(recv(self->cfd, mem, send_len, 0), -1);
 207         }
 208
 209         free(mem);
 210 }
 211
 212 TEST_F(tls, sendmsg_multiple)
 213 {
 214         char const *test_str = "test_sendmsg_multiple";
 215         struct iovec vec[5];
 216         char *test_strs[5];
 217         struct msghdr msg;
 218         int total_len = 0;
 219         int len_cmp = 0;
 220         int iov_len = 5;
 221         char *buf;
 222         int i;
 223
 224         memset(&msg, 0, sizeof(struct msghdr));
 225         for (i = 0; i < iov_len; i++) {
 226                 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
 227                 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
 228                 vec[i].iov_base = (void *)test_strs[i];
 229                 vec[i].iov_len = strlen(test_strs[i]) + 1;
 230                 total_len += vec[i].iov_len;
 231         }
 232         msg.msg_iov = vec;
 233         msg.msg_iovlen = iov_len;
 234
 235         EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
 236         buf = malloc(total_len);
 237         EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
 238         for (i = 0; i < iov_len; i++) {
 239                 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
 240                                  strlen(test_strs[i])),
 241                           0);
 242                 len_cmp += strlen(buf + len_cmp) + 1;
 243         }
 244         for (i = 0; i < iov_len; i++)
 245                 free(test_strs[i]);
 246         free(buf);
 247 }
 248
 249 TEST_F(tls, sendmsg_multiple_stress)
 250 {
 251         char const *test_str = "abcdefghijklmno";
 252         struct iovec vec[1024];
 253         char *test_strs[1024];
 254         int iov_len = 1024;
 255         int total_len = 0;
 256         char buf[1 << 14];
 257         struct msghdr msg;
 258         int len_cmp = 0;
 259         int i;
 260
 261         memset(&msg, 0, sizeof(struct msghdr));
 262         for (i = 0; i < iov_len; i++) {
 263                 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
 264                 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
 265                 vec[i].iov_base = (void *)test_strs[i];
 266                 vec[i].iov_len = strlen(test_strs[i]) + 1;
 267                 total_len += vec[i].iov_len;
 268         }
 269         msg.msg_iov = vec;
 270         msg.msg_iovlen = iov_len;
 271
 272         EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
 273         EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
 274
 275         for (i = 0; i < iov_len; i++)
 276                 len_cmp += strlen(buf + len_cmp) + 1;
 277
 278         for (i = 0; i < iov_len; i++)
 279                 free(test_strs[i]);
 280 }
 281
 282 TEST_F(tls, splice_from_pipe)
 283 {
 284         int send_len = TLS_PAYLOAD_MAX_LEN;
 285         char mem_send[TLS_PAYLOAD_MAX_LEN];
 286         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 287         int p[2];
 288
 289         ASSERT_GE(pipe(p), 0);
 290         EXPECT_GE(write(p[1], mem_send, send_len), 0);
 291         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
 292         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 293         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 294 }
 295
 296 TEST_F(tls, splice_from_pipe2)
 297 {
 298         int send_len = 16000;
 299         char mem_send[16000];
 300         char mem_recv[16000];
 301         int p2[2];
 302         int p[2];
 303
 304         ASSERT_GE(pipe(p), 0);
 305         ASSERT_GE(pipe(p2), 0);
 306         EXPECT_GE(write(p[1], mem_send, 8000), 0);
 307         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, 8000, 0), 0);
 308         EXPECT_GE(write(p2[1], mem_send + 8000, 8000), 0);
 309         EXPECT_GE(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 0);
 310         EXPECT_GE(recv(self->cfd, mem_recv, send_len, 0), 0);
 311         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 312 }
 313
 314 TEST_F(tls, send_and_splice)
 315 {
 316         int send_len = TLS_PAYLOAD_MAX_LEN;
 317         char mem_send[TLS_PAYLOAD_MAX_LEN];
 318         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 319         char const *test_str = "test_read";
 320         int send_len2 = 10;
 321         char buf[10];
 322         int p[2];
 323
 324         ASSERT_GE(pipe(p), 0);
 325         EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
 326         EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
 327         EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
 328
 329         EXPECT_GE(write(p[1], mem_send, send_len), send_len);
 330         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
 331
 332         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 333         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 334 }
 335
 336 TEST_F(tls, splice_to_pipe)
 337 {
 338         int send_len = TLS_PAYLOAD_MAX_LEN;
 339         char mem_send[TLS_PAYLOAD_MAX_LEN];
 340         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 341         int p[2];
 342
 343         ASSERT_GE(pipe(p), 0);
 344         EXPECT_GE(send(self->fd, mem_send, send_len, 0), 0);
 345         EXPECT_GE(splice(self->cfd, NULL, p[1], NULL, send_len, 0), 0);
 346         EXPECT_GE(read(p[0], mem_recv, send_len), 0);
 347         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 348 }
 349
 350 TEST_F(tls, recvmsg_single)
 351 {
 352         char const *test_str = "test_recvmsg_single";
 353         int send_len = strlen(test_str) + 1;
 354         char buf[20];
 355         struct msghdr hdr;
 356         struct iovec vec;
 357
 358         memset(&hdr, 0, sizeof(hdr));
 359         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 360         vec.iov_base = (char *)buf;
 361         vec.iov_len = send_len;
 362         hdr.msg_iovlen = 1;
 363         hdr.msg_iov = &vec;
 364         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 365         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 366 }
 367
 368 TEST_F(tls, recvmsg_single_max)
 369 {
 370         int send_len = TLS_PAYLOAD_MAX_LEN;
 371         char send_mem[TLS_PAYLOAD_MAX_LEN];
 372         char recv_mem[TLS_PAYLOAD_MAX_LEN];
 373         struct iovec vec;
 374         struct msghdr hdr;
 375
 376         EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
 377         vec.iov_base = (char *)recv_mem;
 378         vec.iov_len = TLS_PAYLOAD_MAX_LEN;
 379
 380         hdr.msg_iovlen = 1;
 381         hdr.msg_iov = &vec;
 382         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 383         EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
 384 }
 385
 386 TEST_F(tls, recvmsg_multiple)
 387 {
 388         unsigned int msg_iovlen = 1024;
 389         unsigned int len_compared = 0;
 390         struct iovec vec[1024];
 391         char *iov_base[1024];
 392         unsigned int iov_len = 16;
 393         int send_len = 1 << 14;
 394         char buf[1 << 14];
 395         struct msghdr hdr;
 396         int i;
 397
 398         EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
 399         for (i = 0; i < msg_iovlen; i++) {
 400                 iov_base[i] = (char *)malloc(iov_len);
 401                 vec[i].iov_base = iov_base[i];
 402                 vec[i].iov_len = iov_len;
 403         }
 404
 405         hdr.msg_iovlen = msg_iovlen;
 406         hdr.msg_iov = vec;
 407         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 408         for (i = 0; i < msg_iovlen; i++)
 409                 len_compared += iov_len;
 410
 411         for (i = 0; i < msg_iovlen; i++)
 412                 free(iov_base[i]);
 413 }
 414
 415 TEST_F(tls, single_send_multiple_recv)
 416 {
 417         unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
 418         unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
 419         char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
 420         char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
 421
 422         EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
 423         memset(recv_mem, 0, total_len);
 424
 425         EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
 426         EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
 427         EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
 428 }
 429
 430 TEST_F(tls, multiple_send_single_recv)
 431 {
 432         unsigned int total_len = 2 * 10;
 433         unsigned int send_len = 10;
 434         char recv_mem[2 * 10];
 435         char send_mem[10];
 436
 437         EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
 438         EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
 439         memset(recv_mem, 0, total_len);
 440         EXPECT_EQ(recv(self->cfd, recv_mem, total_len, 0), total_len);
 441
 442         EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
 443         EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
 444 }
 445
 446 TEST_F(tls, recv_partial)
 447 {
 448         char const *test_str = "test_read_partial";
 449         char const *test_str_first = "test_read";
 450         char const *test_str_second = "_partial";
 451         int send_len = strlen(test_str) + 1;
 452         char recv_mem[18];
 453
 454         memset(recv_mem, 0, sizeof(recv_mem));
 455         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 456         EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_first), 0), -1);
 457         EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
 458         memset(recv_mem, 0, sizeof(recv_mem));
 459         EXPECT_NE(recv(self->cfd, recv_mem, strlen(test_str_second), 0), -1);
 460         EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
 461                   0);
 462 }
 463
 464 TEST_F(tls, recv_nonblock)
 465 {
 466         char buf[4096];
 467         bool err;
 468
 469         EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
 470         err = (errno == EAGAIN || errno == EWOULDBLOCK);
 471         EXPECT_EQ(err, true);
 472 }
 473
 474 TEST_F(tls, recv_peek)
 475 {
 476         char const *test_str = "test_read_peek";
 477         int send_len = strlen(test_str) + 1;
 478         char buf[15];
 479
 480         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 481         EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
 482         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 483         memset(buf, 0, sizeof(buf));
 484         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 485         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 486 }
 487
 488 TEST_F(tls, recv_peek_multiple)
 489 {
 490         char const *test_str = "test_read_peek";
 491         int send_len = strlen(test_str) + 1;
 492         unsigned int num_peeks = 100;
 493         char buf[15];
 494         int i;
 495
 496         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 497         for (i = 0; i < num_peeks; i++) {
 498                 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
 499                 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 500                 memset(buf, 0, sizeof(buf));
 501         }
 502         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 503         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 504 }
 505
 506 TEST_F(tls, recv_peek_multiple_records)
 507 {
 508         char const *test_str = "test_read_peek_mult_recs";
 509         char const *test_str_first = "test_read_peek";
 510         char const *test_str_second = "_mult_recs";
 511         int len;
 512         char buf[64];
 513
 514         len = strlen(test_str_first);
 515         EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
 516
 517         len = strlen(test_str_second) + 1;
 518         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
 519
 520         len = strlen(test_str_first);
 521         memset(buf, 0, len);
 522         EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
 523
 524         /* MSG_PEEK can only peek into the current record. */
 525         len = strlen(test_str_first);
 526         EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
 527
 528         len = strlen(test_str) + 1;
 529         memset(buf, 0, len);
 530         EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
 531
 532         /* Non-MSG_PEEK will advance strparser (and therefore record)
 533          * however.
 534          */
 535         len = strlen(test_str) + 1;
 536         EXPECT_EQ(memcmp(test_str, buf, len), 0);
 537
 538         /* MSG_MORE will hold current record open, so later MSG_PEEK
 539          * will see everything.
 540          */
 541         len = strlen(test_str_first);
 542         EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
 543
 544         len = strlen(test_str_second) + 1;
 545         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
 546
 547         len = strlen(test_str) + 1;
 548         memset(buf, 0, len);
 549         EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
 550
 551         len = strlen(test_str) + 1;
 552         EXPECT_EQ(memcmp(test_str, buf, len), 0);
 553 }
 554
 555 TEST_F(tls, pollin)
 556 {
 557         char const *test_str = "test_poll";
 558         struct pollfd fd = { 0, 0, 0 };
 559         char buf[10];
 560         int send_len = 10;
 561
 562         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 563         fd.fd = self->cfd;
 564         fd.events = POLLIN;
 565
 566         EXPECT_EQ(poll(&fd, 1, 20), 1);
 567         EXPECT_EQ(fd.revents & POLLIN, 1);
 568         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
 569         /* Test timing out */
 570         EXPECT_EQ(poll(&fd, 1, 20), 0);
 571 }
 572
 573 TEST_F(tls, poll_wait)
 574 {
 575         char const *test_str = "test_poll_wait";
 576         int send_len = strlen(test_str) + 1;
 577         struct pollfd fd = { 0, 0, 0 };
 578         char recv_mem[15];
 579
 580         fd.fd = self->cfd;
 581         fd.events = POLLIN;
 582         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 583         /* Set timeout to inf. secs */
 584         EXPECT_EQ(poll(&fd, 1, -1), 1);
 585         EXPECT_EQ(fd.revents & POLLIN, 1);
 586         EXPECT_EQ(recv(self->cfd, recv_mem, send_len, 0), send_len);
 587 }
 588
 589 TEST_F(tls, blocking)
 590 {
 591         size_t data = 100000;
 592         int res = fork();
 593
 594         EXPECT_NE(res, -1);
 595
 596         if (res) {
 597                 /* parent */
 598                 size_t left = data;
 599                 char buf[16384];
 600                 int status;
 601                 int pid2;
 602
 603                 while (left) {
 604                         int res = send(self->fd, buf,
 605                                        left > 16384 ? 16384 : left, 0);
 606
 607                         EXPECT_GE(res, 0);
 608                         left -= res;
 609                 }
 610
 611                 pid2 = wait(&status);
 612                 EXPECT_EQ(status, 0);
 613                 EXPECT_EQ(res, pid2);
 614         } else {
 615                 /* child */
 616                 size_t left = data;
 617                 char buf[16384];
 618
 619                 while (left) {
 620                         int res = recv(self->cfd, buf,
 621                                        left > 16384 ? 16384 : left, 0);
 622
 623                         EXPECT_GE(res, 0);
 624                         left -= res;
 625                 }
 626         }
 627 }
 628
 629 TEST_F(tls, nonblocking)
 630 {
 631         size_t data = 100000;
 632         int sendbuf = 100;
 633         int flags;
 634         int res;
 635
 636         flags = fcntl(self->fd, F_GETFL, 0);
 637         fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
 638         fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
 639
 640         /* Ensure nonblocking behavior by imposing a small send
 641          * buffer.
 642          */
 643         EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
 644                              &sendbuf, sizeof(sendbuf)), 0);
 645
 646         res = fork();
 647         EXPECT_NE(res, -1);
 648
 649         if (res) {
 650                 /* parent */
 651                 bool eagain = false;
 652                 size_t left = data;
 653                 char buf[16384];
 654                 int status;
 655                 int pid2;
 656
 657                 while (left) {
 658                         int res = send(self->fd, buf,
 659                                        left > 16384 ? 16384 : left, 0);
 660
 661                         if (res == -1 && errno == EAGAIN) {
 662                                 eagain = true;
 663                                 usleep(10000);
 664                                 continue;
 665                         }
 666                         EXPECT_GE(res, 0);
 667                         left -= res;
 668                 }
 669
 670                 EXPECT_TRUE(eagain);
 671                 pid2 = wait(&status);
 672
 673                 EXPECT_EQ(status, 0);
 674                 EXPECT_EQ(res, pid2);
 675         } else {
 676                 /* child */
 677                 bool eagain = false;
 678                 size_t left = data;
 679                 char buf[16384];
 680
 681                 while (left) {
 682                         int res = recv(self->cfd, buf,
 683                                        left > 16384 ? 16384 : left, 0);
 684
 685                         if (res == -1 && errno == EAGAIN) {
 686                                 eagain = true;
 687                                 usleep(10000);
 688                                 continue;
 689                         }
 690                         EXPECT_GE(res, 0);
 691                         left -= res;
 692                 }
 693                 EXPECT_TRUE(eagain);
 694         }
 695 }
 696
 697 TEST_F(tls, control_msg)
 698 {
 699         if (self->notls)
 700                 return;
 701
 702         char cbuf[CMSG_SPACE(sizeof(char))];
 703         char const *test_str = "test_read";
 704         int cmsg_len = sizeof(char);
 705         char record_type = 100;
 706         struct cmsghdr *cmsg;
 707         struct msghdr msg;
 708         int send_len = 10;
 709         struct iovec vec;
 710         char buf[10];
 711
 712         vec.iov_base = (char *)test_str;
 713         vec.iov_len = 10;
 714         memset(&msg, 0, sizeof(struct msghdr));
 715         msg.msg_iov = &vec;
 716         msg.msg_iovlen = 1;
 717         msg.msg_control = cbuf;
 718         msg.msg_controllen = sizeof(cbuf);
 719         cmsg = CMSG_FIRSTHDR(&msg);
 720         cmsg->cmsg_level = SOL_TLS;
 721         /* test sending non-record types. */
 722         cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
 723         cmsg->cmsg_len = CMSG_LEN(cmsg_len);
 724         *CMSG_DATA(cmsg) = record_type;
 725         msg.msg_controllen = cmsg->cmsg_len;
 726
 727         EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
 728         /* Should fail because we didn't provide a control message */
 729         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
 730
 731         vec.iov_base = buf;
 732         EXPECT_EQ(recvmsg(self->cfd, &msg, 0), send_len);
 733         cmsg = CMSG_FIRSTHDR(&msg);
 734         EXPECT_NE(cmsg, NULL);
 735         EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
 736         EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
 737         record_type = *((unsigned char *)CMSG_DATA(cmsg));
 738         EXPECT_EQ(record_type, 100);
 739         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 740 }
 741
 742 TEST_HARNESS_MAIN