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/epoll.h>
  19 #include <sys/types.h>
  20 #include <sys/sendfile.h>
  21 #include <sys/socket.h>
  22 #include <sys/stat.h>
  23
  24 #include "../kselftest_harness.h"
  25
  26 #define TLS_PAYLOAD_MAX_LEN 16384
  27 #define SOL_TLS 282
  28
  29 static int fips_enabled;
  30
  31 struct tls_crypto_info_keys {
  32         union {
  33                 struct tls_crypto_info crypto_info;
  34                 struct tls12_crypto_info_aes_gcm_128 aes128;
  35                 struct tls12_crypto_info_chacha20_poly1305 chacha20;
  36                 struct tls12_crypto_info_sm4_gcm sm4gcm;
  37                 struct tls12_crypto_info_sm4_ccm sm4ccm;
  38                 struct tls12_crypto_info_aes_ccm_128 aesccm128;
  39                 struct tls12_crypto_info_aes_gcm_256 aesgcm256;
  40                 struct tls12_crypto_info_aria_gcm_128 ariagcm128;
  41                 struct tls12_crypto_info_aria_gcm_256 ariagcm256;
  42         };
  43         size_t len;
  44 };
  45
  46 static void tls_crypto_info_init(uint16_t tls_version, uint16_t cipher_type,
  47                                  struct tls_crypto_info_keys *tls12)
  48 {
  49         memset(tls12, 0, sizeof(*tls12));
  50
  51         switch (cipher_type) {
  52         case TLS_CIPHER_CHACHA20_POLY1305:
  53                 tls12->len = sizeof(struct tls12_crypto_info_chacha20_poly1305);
  54                 tls12->chacha20.info.version = tls_version;
  55                 tls12->chacha20.info.cipher_type = cipher_type;
  56                 break;
  57         case TLS_CIPHER_AES_GCM_128:
  58                 tls12->len = sizeof(struct tls12_crypto_info_aes_gcm_128);
  59                 tls12->aes128.info.version = tls_version;
  60                 tls12->aes128.info.cipher_type = cipher_type;
  61                 break;
  62         case TLS_CIPHER_SM4_GCM:
  63                 tls12->len = sizeof(struct tls12_crypto_info_sm4_gcm);
  64                 tls12->sm4gcm.info.version = tls_version;
  65                 tls12->sm4gcm.info.cipher_type = cipher_type;
  66                 break;
  67         case TLS_CIPHER_SM4_CCM:
  68                 tls12->len = sizeof(struct tls12_crypto_info_sm4_ccm);
  69                 tls12->sm4ccm.info.version = tls_version;
  70                 tls12->sm4ccm.info.cipher_type = cipher_type;
  71                 break;
  72         case TLS_CIPHER_AES_CCM_128:
  73                 tls12->len = sizeof(struct tls12_crypto_info_aes_ccm_128);
  74                 tls12->aesccm128.info.version = tls_version;
  75                 tls12->aesccm128.info.cipher_type = cipher_type;
  76                 break;
  77         case TLS_CIPHER_AES_GCM_256:
  78                 tls12->len = sizeof(struct tls12_crypto_info_aes_gcm_256);
  79                 tls12->aesgcm256.info.version = tls_version;
  80                 tls12->aesgcm256.info.cipher_type = cipher_type;
  81                 break;
  82         case TLS_CIPHER_ARIA_GCM_128:
  83                 tls12->len = sizeof(struct tls12_crypto_info_aria_gcm_128);
  84                 tls12->ariagcm128.info.version = tls_version;
  85                 tls12->ariagcm128.info.cipher_type = cipher_type;
  86                 break;
  87         case TLS_CIPHER_ARIA_GCM_256:
  88                 tls12->len = sizeof(struct tls12_crypto_info_aria_gcm_256);
  89                 tls12->ariagcm256.info.version = tls_version;
  90                 tls12->ariagcm256.info.cipher_type = cipher_type;
  91                 break;
  92         default:
  93                 break;
  94         }
  95 }
  96
  97 static void memrnd(void *s, size_t n)
  98 {
  99         int *dword = s;
 100         char *byte;
 101
 102         for (; n >= 4; n -= 4)
 103                 *dword++ = rand();
 104         byte = (void *)dword;
 105         while (n--)
 106                 *byte++ = rand();
 107 }
 108
 109 static void ulp_sock_pair(struct __test_metadata *_metadata,
 110                           int *fd, int *cfd, bool *notls)
 111 {
 112         struct sockaddr_in addr;
 113         socklen_t len;
 114         int sfd, ret;
 115
 116         *notls = false;
 117         len = sizeof(addr);
 118
 119         addr.sin_family = AF_INET;
 120         addr.sin_addr.s_addr = htonl(INADDR_ANY);
 121         addr.sin_port = 0;
 122
 123         *fd = socket(AF_INET, SOCK_STREAM, 0);
 124         sfd = socket(AF_INET, SOCK_STREAM, 0);
 125
 126         ret = bind(sfd, &addr, sizeof(addr));
 127         ASSERT_EQ(ret, 0);
 128         ret = listen(sfd, 10);
 129         ASSERT_EQ(ret, 0);
 130
 131         ret = getsockname(sfd, &addr, &len);
 132         ASSERT_EQ(ret, 0);
 133
 134         ret = connect(*fd, &addr, sizeof(addr));
 135         ASSERT_EQ(ret, 0);
 136
 137         *cfd = accept(sfd, &addr, &len);
 138         ASSERT_GE(*cfd, 0);
 139
 140         close(sfd);
 141
 142         ret = setsockopt(*fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
 143         if (ret != 0) {
 144                 ASSERT_EQ(errno, ENOENT);
 145                 *notls = true;
 146                 printf("Failure setting TCP_ULP, testing without tls\n");
 147                 return;
 148         }
 149
 150         ret = setsockopt(*cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
 151         ASSERT_EQ(ret, 0);
 152 }
 153
 154 /* Produce a basic cmsg */
 155 static int tls_send_cmsg(int fd, unsigned char record_type,
 156                          void *data, size_t len, int flags)
 157 {
 158         char cbuf[CMSG_SPACE(sizeof(char))];
 159         int cmsg_len = sizeof(char);
 160         struct cmsghdr *cmsg;
 161         struct msghdr msg;
 162         struct iovec vec;
 163
 164         vec.iov_base = data;
 165         vec.iov_len = len;
 166         memset(&msg, 0, sizeof(struct msghdr));
 167         msg.msg_iov = &vec;
 168         msg.msg_iovlen = 1;
 169         msg.msg_control = cbuf;
 170         msg.msg_controllen = sizeof(cbuf);
 171         cmsg = CMSG_FIRSTHDR(&msg);
 172         cmsg->cmsg_level = SOL_TLS;
 173         /* test sending non-record types. */
 174         cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
 175         cmsg->cmsg_len = CMSG_LEN(cmsg_len);
 176         *CMSG_DATA(cmsg) = record_type;
 177         msg.msg_controllen = cmsg->cmsg_len;
 178
 179         return sendmsg(fd, &msg, flags);
 180 }
 181
 182 static int tls_recv_cmsg(struct __test_metadata *_metadata,
 183                          int fd, unsigned char record_type,
 184                          void *data, size_t len, int flags)
 185 {
 186         char cbuf[CMSG_SPACE(sizeof(char))];
 187         struct cmsghdr *cmsg;
 188         unsigned char ctype;
 189         struct msghdr msg;
 190         struct iovec vec;
 191         int n;
 192
 193         vec.iov_base = data;
 194         vec.iov_len = len;
 195         memset(&msg, 0, sizeof(struct msghdr));
 196         msg.msg_iov = &vec;
 197         msg.msg_iovlen = 1;
 198         msg.msg_control = cbuf;
 199         msg.msg_controllen = sizeof(cbuf);
 200
 201         n = recvmsg(fd, &msg, flags);
 202
 203         cmsg = CMSG_FIRSTHDR(&msg);
 204         EXPECT_NE(cmsg, NULL);
 205         EXPECT_EQ(cmsg->cmsg_level, SOL_TLS);
 206         EXPECT_EQ(cmsg->cmsg_type, TLS_GET_RECORD_TYPE);
 207         ctype = *((unsigned char *)CMSG_DATA(cmsg));
 208         EXPECT_EQ(ctype, record_type);
 209
 210         return n;
 211 }
 212
 213 FIXTURE(tls_basic)
 214 {
 215         int fd, cfd;
 216         bool notls;
 217 };
 218
 219 FIXTURE_SETUP(tls_basic)
 220 {
 221         ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls);
 222 }
 223
 224 FIXTURE_TEARDOWN(tls_basic)
 225 {
 226         close(self->fd);
 227         close(self->cfd);
 228 }
 229
 230 /* Send some data through with ULP but no keys */
 231 TEST_F(tls_basic, base_base)
 232 {
 233         char const *test_str = "test_read";
 234         int send_len = 10;
 235         char buf[10];
 236
 237         ASSERT_EQ(strlen(test_str) + 1, send_len);
 238
 239         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 240         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 241         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 242 };
 243
 244 TEST_F(tls_basic, bad_cipher)
 245 {
 246         struct tls_crypto_info_keys tls12;
 247
 248         tls12.crypto_info.version = 200;
 249         tls12.crypto_info.cipher_type = TLS_CIPHER_AES_GCM_128;
 250         EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1);
 251
 252         tls12.crypto_info.version = TLS_1_2_VERSION;
 253         tls12.crypto_info.cipher_type = 50;
 254         EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1);
 255
 256         tls12.crypto_info.version = TLS_1_2_VERSION;
 257         tls12.crypto_info.cipher_type = 59;
 258         EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1);
 259
 260         tls12.crypto_info.version = TLS_1_2_VERSION;
 261         tls12.crypto_info.cipher_type = 10;
 262         EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1);
 263
 264         tls12.crypto_info.version = TLS_1_2_VERSION;
 265         tls12.crypto_info.cipher_type = 70;
 266         EXPECT_EQ(setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, sizeof(struct tls12_crypto_info_aes_gcm_128)), -1);
 267 }
 268
 269 FIXTURE(tls)
 270 {
 271         int fd, cfd;
 272         bool notls;
 273 };
 274
 275 FIXTURE_VARIANT(tls)
 276 {
 277         uint16_t tls_version;
 278         uint16_t cipher_type;
 279         bool nopad, fips_non_compliant;
 280 };
 281
 282 FIXTURE_VARIANT_ADD(tls, 12_aes_gcm)
 283 {
 284         .tls_version = TLS_1_2_VERSION,
 285         .cipher_type = TLS_CIPHER_AES_GCM_128,
 286 };
 287
 288 FIXTURE_VARIANT_ADD(tls, 13_aes_gcm)
 289 {
 290         .tls_version = TLS_1_3_VERSION,
 291         .cipher_type = TLS_CIPHER_AES_GCM_128,
 292 };
 293
 294 FIXTURE_VARIANT_ADD(tls, 12_chacha)
 295 {
 296         .tls_version = TLS_1_2_VERSION,
 297         .cipher_type = TLS_CIPHER_CHACHA20_POLY1305,
 298         .fips_non_compliant = true,
 299 };
 300
 301 FIXTURE_VARIANT_ADD(tls, 13_chacha)
 302 {
 303         .tls_version = TLS_1_3_VERSION,
 304         .cipher_type = TLS_CIPHER_CHACHA20_POLY1305,
 305         .fips_non_compliant = true,
 306 };
 307
 308 FIXTURE_VARIANT_ADD(tls, 13_sm4_gcm)
 309 {
 310         .tls_version = TLS_1_3_VERSION,
 311         .cipher_type = TLS_CIPHER_SM4_GCM,
 312         .fips_non_compliant = true,
 313 };
 314
 315 FIXTURE_VARIANT_ADD(tls, 13_sm4_ccm)
 316 {
 317         .tls_version = TLS_1_3_VERSION,
 318         .cipher_type = TLS_CIPHER_SM4_CCM,
 319         .fips_non_compliant = true,
 320 };
 321
 322 FIXTURE_VARIANT_ADD(tls, 12_aes_ccm)
 323 {
 324         .tls_version = TLS_1_2_VERSION,
 325         .cipher_type = TLS_CIPHER_AES_CCM_128,
 326 };
 327
 328 FIXTURE_VARIANT_ADD(tls, 13_aes_ccm)
 329 {
 330         .tls_version = TLS_1_3_VERSION,
 331         .cipher_type = TLS_CIPHER_AES_CCM_128,
 332 };
 333
 334 FIXTURE_VARIANT_ADD(tls, 12_aes_gcm_256)
 335 {
 336         .tls_version = TLS_1_2_VERSION,
 337         .cipher_type = TLS_CIPHER_AES_GCM_256,
 338 };
 339
 340 FIXTURE_VARIANT_ADD(tls, 13_aes_gcm_256)
 341 {
 342         .tls_version = TLS_1_3_VERSION,
 343         .cipher_type = TLS_CIPHER_AES_GCM_256,
 344 };
 345
 346 FIXTURE_VARIANT_ADD(tls, 13_nopad)
 347 {
 348         .tls_version = TLS_1_3_VERSION,
 349         .cipher_type = TLS_CIPHER_AES_GCM_128,
 350         .nopad = true,
 351 };
 352
 353 FIXTURE_VARIANT_ADD(tls, 12_aria_gcm)
 354 {
 355         .tls_version = TLS_1_2_VERSION,
 356         .cipher_type = TLS_CIPHER_ARIA_GCM_128,
 357 };
 358
 359 FIXTURE_VARIANT_ADD(tls, 12_aria_gcm_256)
 360 {
 361         .tls_version = TLS_1_2_VERSION,
 362         .cipher_type = TLS_CIPHER_ARIA_GCM_256,
 363 };
 364
 365 FIXTURE_SETUP(tls)
 366 {
 367         struct tls_crypto_info_keys tls12;
 368         int one = 1;
 369         int ret;
 370
 371         if (fips_enabled && variant->fips_non_compliant)
 372                 SKIP(return, "Unsupported cipher in FIPS mode");
 373
 374         tls_crypto_info_init(variant->tls_version, variant->cipher_type,
 375                              &tls12);
 376
 377         ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls);
 378
 379         if (self->notls)
 380                 return;
 381
 382         ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len);
 383         ASSERT_EQ(ret, 0);
 384
 385         ret = setsockopt(self->cfd, SOL_TLS, TLS_RX, &tls12, tls12.len);
 386         ASSERT_EQ(ret, 0);
 387
 388         if (variant->nopad) {
 389                 ret = setsockopt(self->cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD,
 390                                  (void *)&one, sizeof(one));
 391                 ASSERT_EQ(ret, 0);
 392         }
 393 }
 394
 395 FIXTURE_TEARDOWN(tls)
 396 {
 397         close(self->fd);
 398         close(self->cfd);
 399 }
 400
 401 TEST_F(tls, sendfile)
 402 {
 403         int filefd = open("/proc/self/exe", O_RDONLY);
 404         struct stat st;
 405
 406         EXPECT_GE(filefd, 0);
 407         fstat(filefd, &st);
 408         EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
 409 }
 410
 411 TEST_F(tls, send_then_sendfile)
 412 {
 413         int filefd = open("/proc/self/exe", O_RDONLY);
 414         char const *test_str = "test_send";
 415         int to_send = strlen(test_str) + 1;
 416         char recv_buf[10];
 417         struct stat st;
 418         char *buf;
 419
 420         EXPECT_GE(filefd, 0);
 421         fstat(filefd, &st);
 422         buf = (char *)malloc(st.st_size);
 423
 424         EXPECT_EQ(send(self->fd, test_str, to_send, 0), to_send);
 425         EXPECT_EQ(recv(self->cfd, recv_buf, to_send, MSG_WAITALL), to_send);
 426         EXPECT_EQ(memcmp(test_str, recv_buf, to_send), 0);
 427
 428         EXPECT_GE(sendfile(self->fd, filefd, 0, st.st_size), 0);
 429         EXPECT_EQ(recv(self->cfd, buf, st.st_size, MSG_WAITALL), st.st_size);
 430 }
 431
 432 static void chunked_sendfile(struct __test_metadata *_metadata,
 433                              struct _test_data_tls *self,
 434                              uint16_t chunk_size,
 435                              uint16_t extra_payload_size)
 436 {
 437         char buf[TLS_PAYLOAD_MAX_LEN];
 438         uint16_t test_payload_size;
 439         int size = 0;
 440         int ret;
 441         char filename[] = "/tmp/mytemp.XXXXXX";
 442         int fd = mkstemp(filename);
 443         off_t offset = 0;
 444
 445         unlink(filename);
 446         ASSERT_GE(fd, 0);
 447         EXPECT_GE(chunk_size, 1);
 448         test_payload_size = chunk_size + extra_payload_size;
 449         ASSERT_GE(TLS_PAYLOAD_MAX_LEN, test_payload_size);
 450         memset(buf, 1, test_payload_size);
 451         size = write(fd, buf, test_payload_size);
 452         EXPECT_EQ(size, test_payload_size);
 453         fsync(fd);
 454
 455         while (size > 0) {
 456                 ret = sendfile(self->fd, fd, &offset, chunk_size);
 457                 EXPECT_GE(ret, 0);
 458                 size -= ret;
 459         }
 460
 461         EXPECT_EQ(recv(self->cfd, buf, test_payload_size, MSG_WAITALL),
 462                   test_payload_size);
 463
 464         close(fd);
 465 }
 466
 467 TEST_F(tls, multi_chunk_sendfile)
 468 {
 469         chunked_sendfile(_metadata, self, 4096, 4096);
 470         chunked_sendfile(_metadata, self, 4096, 0);
 471         chunked_sendfile(_metadata, self, 4096, 1);
 472         chunked_sendfile(_metadata, self, 4096, 2048);
 473         chunked_sendfile(_metadata, self, 8192, 2048);
 474         chunked_sendfile(_metadata, self, 4096, 8192);
 475         chunked_sendfile(_metadata, self, 8192, 4096);
 476         chunked_sendfile(_metadata, self, 12288, 1024);
 477         chunked_sendfile(_metadata, self, 12288, 2000);
 478         chunked_sendfile(_metadata, self, 15360, 100);
 479         chunked_sendfile(_metadata, self, 15360, 300);
 480         chunked_sendfile(_metadata, self, 1, 4096);
 481         chunked_sendfile(_metadata, self, 2048, 4096);
 482         chunked_sendfile(_metadata, self, 2048, 8192);
 483         chunked_sendfile(_metadata, self, 4096, 8192);
 484         chunked_sendfile(_metadata, self, 1024, 12288);
 485         chunked_sendfile(_metadata, self, 2000, 12288);
 486         chunked_sendfile(_metadata, self, 100, 15360);
 487         chunked_sendfile(_metadata, self, 300, 15360);
 488 }
 489
 490 TEST_F(tls, recv_max)
 491 {
 492         unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
 493         char recv_mem[TLS_PAYLOAD_MAX_LEN];
 494         char buf[TLS_PAYLOAD_MAX_LEN];
 495
 496         memrnd(buf, sizeof(buf));
 497
 498         EXPECT_GE(send(self->fd, buf, send_len, 0), 0);
 499         EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
 500         EXPECT_EQ(memcmp(buf, recv_mem, send_len), 0);
 501 }
 502
 503 TEST_F(tls, recv_small)
 504 {
 505         char const *test_str = "test_read";
 506         int send_len = 10;
 507         char buf[10];
 508
 509         send_len = strlen(test_str) + 1;
 510         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 511         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
 512         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 513 }
 514
 515 TEST_F(tls, msg_more)
 516 {
 517         char const *test_str = "test_read";
 518         int send_len = 10;
 519         char buf[10 * 2];
 520
 521         EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
 522         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
 523         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 524         EXPECT_EQ(recv(self->cfd, buf, send_len * 2, MSG_WAITALL),
 525                   send_len * 2);
 526         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 527 }
 528
 529 TEST_F(tls, msg_more_unsent)
 530 {
 531         char const *test_str = "test_read";
 532         int send_len = 10;
 533         char buf[10];
 534
 535         EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
 536         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_DONTWAIT), -1);
 537 }
 538
 539 TEST_F(tls, msg_eor)
 540 {
 541         char const *test_str = "test_read";
 542         int send_len = 10;
 543         char buf[10];
 544
 545         EXPECT_EQ(send(self->fd, test_str, send_len, MSG_EOR), send_len);
 546         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
 547         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 548 }
 549
 550 TEST_F(tls, sendmsg_single)
 551 {
 552         struct msghdr msg;
 553
 554         char const *test_str = "test_sendmsg";
 555         size_t send_len = 13;
 556         struct iovec vec;
 557         char buf[13];
 558
 559         vec.iov_base = (char *)test_str;
 560         vec.iov_len = send_len;
 561         memset(&msg, 0, sizeof(struct msghdr));
 562         msg.msg_iov = &vec;
 563         msg.msg_iovlen = 1;
 564         EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
 565         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
 566         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
 567 }
 568
 569 #define MAX_FRAGS       64
 570 #define SEND_LEN        13
 571 TEST_F(tls, sendmsg_fragmented)
 572 {
 573         char const *test_str = "test_sendmsg";
 574         char buf[SEND_LEN * MAX_FRAGS];
 575         struct iovec vec[MAX_FRAGS];
 576         struct msghdr msg;
 577         int i, frags;
 578
 579         for (frags = 1; frags <= MAX_FRAGS; frags++) {
 580                 for (i = 0; i < frags; i++) {
 581                         vec[i].iov_base = (char *)test_str;
 582                         vec[i].iov_len = SEND_LEN;
 583                 }
 584
 585                 memset(&msg, 0, sizeof(struct msghdr));
 586                 msg.msg_iov = vec;
 587                 msg.msg_iovlen = frags;
 588
 589                 EXPECT_EQ(sendmsg(self->fd, &msg, 0), SEND_LEN * frags);
 590                 EXPECT_EQ(recv(self->cfd, buf, SEND_LEN * frags, MSG_WAITALL),
 591                           SEND_LEN * frags);
 592
 593                 for (i = 0; i < frags; i++)
 594                         EXPECT_EQ(memcmp(buf + SEND_LEN * i,
 595                                          test_str, SEND_LEN), 0);
 596         }
 597 }
 598 #undef MAX_FRAGS
 599 #undef SEND_LEN
 600
 601 TEST_F(tls, sendmsg_large)
 602 {
 603         void *mem = malloc(16384);
 604         size_t send_len = 16384;
 605         size_t sends = 128;
 606         struct msghdr msg;
 607         size_t recvs = 0;
 608         size_t sent = 0;
 609
 610         memset(&msg, 0, sizeof(struct msghdr));
 611         while (sent++ < sends) {
 612                 struct iovec vec = { (void *)mem, send_len };
 613
 614                 msg.msg_iov = &vec;
 615                 msg.msg_iovlen = 1;
 616                 EXPECT_EQ(sendmsg(self->fd, &msg, 0), send_len);
 617         }
 618
 619         while (recvs++ < sends) {
 620                 EXPECT_NE(recv(self->cfd, mem, send_len, 0), -1);
 621         }
 622
 623         free(mem);
 624 }
 625
 626 TEST_F(tls, sendmsg_multiple)
 627 {
 628         char const *test_str = "test_sendmsg_multiple";
 629         struct iovec vec[5];
 630         char *test_strs[5];
 631         struct msghdr msg;
 632         int total_len = 0;
 633         int len_cmp = 0;
 634         int iov_len = 5;
 635         char *buf;
 636         int i;
 637
 638         memset(&msg, 0, sizeof(struct msghdr));
 639         for (i = 0; i < iov_len; i++) {
 640                 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
 641                 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
 642                 vec[i].iov_base = (void *)test_strs[i];
 643                 vec[i].iov_len = strlen(test_strs[i]) + 1;
 644                 total_len += vec[i].iov_len;
 645         }
 646         msg.msg_iov = vec;
 647         msg.msg_iovlen = iov_len;
 648
 649         EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
 650         buf = malloc(total_len);
 651         EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
 652         for (i = 0; i < iov_len; i++) {
 653                 EXPECT_EQ(memcmp(test_strs[i], buf + len_cmp,
 654                                  strlen(test_strs[i])),
 655                           0);
 656                 len_cmp += strlen(buf + len_cmp) + 1;
 657         }
 658         for (i = 0; i < iov_len; i++)
 659                 free(test_strs[i]);
 660         free(buf);
 661 }
 662
 663 TEST_F(tls, sendmsg_multiple_stress)
 664 {
 665         char const *test_str = "abcdefghijklmno";
 666         struct iovec vec[1024];
 667         char *test_strs[1024];
 668         int iov_len = 1024;
 669         int total_len = 0;
 670         char buf[1 << 14];
 671         struct msghdr msg;
 672         int len_cmp = 0;
 673         int i;
 674
 675         memset(&msg, 0, sizeof(struct msghdr));
 676         for (i = 0; i < iov_len; i++) {
 677                 test_strs[i] = (char *)malloc(strlen(test_str) + 1);
 678                 snprintf(test_strs[i], strlen(test_str) + 1, "%s", test_str);
 679                 vec[i].iov_base = (void *)test_strs[i];
 680                 vec[i].iov_len = strlen(test_strs[i]) + 1;
 681                 total_len += vec[i].iov_len;
 682         }
 683         msg.msg_iov = vec;
 684         msg.msg_iovlen = iov_len;
 685
 686         EXPECT_EQ(sendmsg(self->fd, &msg, 0), total_len);
 687         EXPECT_NE(recv(self->cfd, buf, total_len, 0), -1);
 688
 689         for (i = 0; i < iov_len; i++)
 690                 len_cmp += strlen(buf + len_cmp) + 1;
 691
 692         for (i = 0; i < iov_len; i++)
 693                 free(test_strs[i]);
 694 }
 695
 696 TEST_F(tls, splice_from_pipe)
 697 {
 698         int send_len = TLS_PAYLOAD_MAX_LEN;
 699         char mem_send[TLS_PAYLOAD_MAX_LEN];
 700         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 701         int p[2];
 702
 703         ASSERT_GE(pipe(p), 0);
 704         EXPECT_GE(write(p[1], mem_send, send_len), 0);
 705         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), 0);
 706         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 707         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 708 }
 709
 710 TEST_F(tls, splice_more)
 711 {
 712         unsigned int f = SPLICE_F_NONBLOCK | SPLICE_F_MORE | SPLICE_F_GIFT;
 713         int send_len = TLS_PAYLOAD_MAX_LEN;
 714         char mem_send[TLS_PAYLOAD_MAX_LEN];
 715         int i, send_pipe = 1;
 716         int p[2];
 717
 718         ASSERT_GE(pipe(p), 0);
 719         EXPECT_GE(write(p[1], mem_send, send_len), 0);
 720         for (i = 0; i < 32; i++)
 721                 EXPECT_EQ(splice(p[0], NULL, self->fd, NULL, send_pipe, f), 1);
 722 }
 723
 724 TEST_F(tls, splice_from_pipe2)
 725 {
 726         int send_len = 16000;
 727         char mem_send[16000];
 728         char mem_recv[16000];
 729         int p2[2];
 730         int p[2];
 731
 732         memrnd(mem_send, sizeof(mem_send));
 733
 734         ASSERT_GE(pipe(p), 0);
 735         ASSERT_GE(pipe(p2), 0);
 736         EXPECT_EQ(write(p[1], mem_send, 8000), 8000);
 737         EXPECT_EQ(splice(p[0], NULL, self->fd, NULL, 8000, 0), 8000);
 738         EXPECT_EQ(write(p2[1], mem_send + 8000, 8000), 8000);
 739         EXPECT_EQ(splice(p2[0], NULL, self->fd, NULL, 8000, 0), 8000);
 740         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 741         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 742 }
 743
 744 TEST_F(tls, send_and_splice)
 745 {
 746         int send_len = TLS_PAYLOAD_MAX_LEN;
 747         char mem_send[TLS_PAYLOAD_MAX_LEN];
 748         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 749         char const *test_str = "test_read";
 750         int send_len2 = 10;
 751         char buf[10];
 752         int p[2];
 753
 754         ASSERT_GE(pipe(p), 0);
 755         EXPECT_EQ(send(self->fd, test_str, send_len2, 0), send_len2);
 756         EXPECT_EQ(recv(self->cfd, buf, send_len2, MSG_WAITALL), send_len2);
 757         EXPECT_EQ(memcmp(test_str, buf, send_len2), 0);
 758
 759         EXPECT_GE(write(p[1], mem_send, send_len), send_len);
 760         EXPECT_GE(splice(p[0], NULL, self->fd, NULL, send_len, 0), send_len);
 761
 762         EXPECT_EQ(recv(self->cfd, mem_recv, send_len, MSG_WAITALL), send_len);
 763         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 764 }
 765
 766 TEST_F(tls, splice_to_pipe)
 767 {
 768         int send_len = TLS_PAYLOAD_MAX_LEN;
 769         char mem_send[TLS_PAYLOAD_MAX_LEN];
 770         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 771         int p[2];
 772
 773         memrnd(mem_send, sizeof(mem_send));
 774
 775         ASSERT_GE(pipe(p), 0);
 776         EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len);
 777         EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), send_len);
 778         EXPECT_EQ(read(p[0], mem_recv, send_len), send_len);
 779         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 780 }
 781
 782 TEST_F(tls, splice_cmsg_to_pipe)
 783 {
 784         char *test_str = "test_read";
 785         char record_type = 100;
 786         int send_len = 10;
 787         char buf[10];
 788         int p[2];
 789
 790         if (self->notls)
 791                 SKIP(return, "no TLS support");
 792
 793         ASSERT_GE(pipe(p), 0);
 794         EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10);
 795         EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1);
 796         EXPECT_EQ(errno, EINVAL);
 797         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
 798         EXPECT_EQ(errno, EIO);
 799         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
 800                                 buf, sizeof(buf), MSG_WAITALL),
 801                   send_len);
 802         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 803 }
 804
 805 TEST_F(tls, splice_dec_cmsg_to_pipe)
 806 {
 807         char *test_str = "test_read";
 808         char record_type = 100;
 809         int send_len = 10;
 810         char buf[10];
 811         int p[2];
 812
 813         if (self->notls)
 814                 SKIP(return, "no TLS support");
 815
 816         ASSERT_GE(pipe(p), 0);
 817         EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10);
 818         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
 819         EXPECT_EQ(errno, EIO);
 820         EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, send_len, 0), -1);
 821         EXPECT_EQ(errno, EINVAL);
 822         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
 823                                 buf, sizeof(buf), MSG_WAITALL),
 824                   send_len);
 825         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 826 }
 827
 828 TEST_F(tls, recv_and_splice)
 829 {
 830         int send_len = TLS_PAYLOAD_MAX_LEN;
 831         char mem_send[TLS_PAYLOAD_MAX_LEN];
 832         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 833         int half = send_len / 2;
 834         int p[2];
 835
 836         ASSERT_GE(pipe(p), 0);
 837         EXPECT_EQ(send(self->fd, mem_send, send_len, 0), send_len);
 838         /* Recv hald of the record, splice the other half */
 839         EXPECT_EQ(recv(self->cfd, mem_recv, half, MSG_WAITALL), half);
 840         EXPECT_EQ(splice(self->cfd, NULL, p[1], NULL, half, SPLICE_F_NONBLOCK),
 841                   half);
 842         EXPECT_EQ(read(p[0], &mem_recv[half], half), half);
 843         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 844 }
 845
 846 TEST_F(tls, peek_and_splice)
 847 {
 848         int send_len = TLS_PAYLOAD_MAX_LEN;
 849         char mem_send[TLS_PAYLOAD_MAX_LEN];
 850         char mem_recv[TLS_PAYLOAD_MAX_LEN];
 851         int chunk = TLS_PAYLOAD_MAX_LEN / 4;
 852         int n, i, p[2];
 853
 854         memrnd(mem_send, sizeof(mem_send));
 855
 856         ASSERT_GE(pipe(p), 0);
 857         for (i = 0; i < 4; i++)
 858                 EXPECT_EQ(send(self->fd, &mem_send[chunk * i], chunk, 0),
 859                           chunk);
 860
 861         EXPECT_EQ(recv(self->cfd, mem_recv, chunk * 5 / 2,
 862                        MSG_WAITALL | MSG_PEEK),
 863                   chunk * 5 / 2);
 864         EXPECT_EQ(memcmp(mem_send, mem_recv, chunk * 5 / 2), 0);
 865
 866         n = 0;
 867         while (n < send_len) {
 868                 i = splice(self->cfd, NULL, p[1], NULL, send_len - n, 0);
 869                 EXPECT_GT(i, 0);
 870                 n += i;
 871         }
 872         EXPECT_EQ(n, send_len);
 873         EXPECT_EQ(read(p[0], mem_recv, send_len), send_len);
 874         EXPECT_EQ(memcmp(mem_send, mem_recv, send_len), 0);
 875 }
 876
 877 TEST_F(tls, recvmsg_single)
 878 {
 879         char const *test_str = "test_recvmsg_single";
 880         int send_len = strlen(test_str) + 1;
 881         char buf[20];
 882         struct msghdr hdr;
 883         struct iovec vec;
 884
 885         memset(&hdr, 0, sizeof(hdr));
 886         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
 887         vec.iov_base = (char *)buf;
 888         vec.iov_len = send_len;
 889         hdr.msg_iovlen = 1;
 890         hdr.msg_iov = &vec;
 891         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 892         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
 893 }
 894
 895 TEST_F(tls, recvmsg_single_max)
 896 {
 897         int send_len = TLS_PAYLOAD_MAX_LEN;
 898         char send_mem[TLS_PAYLOAD_MAX_LEN];
 899         char recv_mem[TLS_PAYLOAD_MAX_LEN];
 900         struct iovec vec;
 901         struct msghdr hdr;
 902
 903         memrnd(send_mem, sizeof(send_mem));
 904
 905         EXPECT_EQ(send(self->fd, send_mem, send_len, 0), send_len);
 906         vec.iov_base = (char *)recv_mem;
 907         vec.iov_len = TLS_PAYLOAD_MAX_LEN;
 908
 909         hdr.msg_iovlen = 1;
 910         hdr.msg_iov = &vec;
 911         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 912         EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
 913 }
 914
 915 TEST_F(tls, recvmsg_multiple)
 916 {
 917         unsigned int msg_iovlen = 1024;
 918         struct iovec vec[1024];
 919         char *iov_base[1024];
 920         unsigned int iov_len = 16;
 921         int send_len = 1 << 14;
 922         char buf[1 << 14];
 923         struct msghdr hdr;
 924         int i;
 925
 926         memrnd(buf, sizeof(buf));
 927
 928         EXPECT_EQ(send(self->fd, buf, send_len, 0), send_len);
 929         for (i = 0; i < msg_iovlen; i++) {
 930                 iov_base[i] = (char *)malloc(iov_len);
 931                 vec[i].iov_base = iov_base[i];
 932                 vec[i].iov_len = iov_len;
 933         }
 934
 935         hdr.msg_iovlen = msg_iovlen;
 936         hdr.msg_iov = vec;
 937         EXPECT_NE(recvmsg(self->cfd, &hdr, 0), -1);
 938
 939         for (i = 0; i < msg_iovlen; i++)
 940                 free(iov_base[i]);
 941 }
 942
 943 TEST_F(tls, single_send_multiple_recv)
 944 {
 945         unsigned int total_len = TLS_PAYLOAD_MAX_LEN * 2;
 946         unsigned int send_len = TLS_PAYLOAD_MAX_LEN;
 947         char send_mem[TLS_PAYLOAD_MAX_LEN * 2];
 948         char recv_mem[TLS_PAYLOAD_MAX_LEN * 2];
 949
 950         memrnd(send_mem, sizeof(send_mem));
 951
 952         EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
 953         memset(recv_mem, 0, total_len);
 954
 955         EXPECT_NE(recv(self->cfd, recv_mem, send_len, 0), -1);
 956         EXPECT_NE(recv(self->cfd, recv_mem + send_len, send_len, 0), -1);
 957         EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
 958 }
 959
 960 TEST_F(tls, multiple_send_single_recv)
 961 {
 962         unsigned int total_len = 2 * 10;
 963         unsigned int send_len = 10;
 964         char recv_mem[2 * 10];
 965         char send_mem[10];
 966
 967         memrnd(send_mem, sizeof(send_mem));
 968
 969         EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
 970         EXPECT_GE(send(self->fd, send_mem, send_len, 0), 0);
 971         memset(recv_mem, 0, total_len);
 972         EXPECT_EQ(recv(self->cfd, recv_mem, total_len, MSG_WAITALL), total_len);
 973
 974         EXPECT_EQ(memcmp(send_mem, recv_mem, send_len), 0);
 975         EXPECT_EQ(memcmp(send_mem, recv_mem + send_len, send_len), 0);
 976 }
 977
 978 TEST_F(tls, single_send_multiple_recv_non_align)
 979 {
 980         const unsigned int total_len = 15;
 981         const unsigned int recv_len = 10;
 982         char recv_mem[recv_len * 2];
 983         char send_mem[total_len];
 984
 985         memrnd(send_mem, sizeof(send_mem));
 986
 987         EXPECT_GE(send(self->fd, send_mem, total_len, 0), 0);
 988         memset(recv_mem, 0, total_len);
 989
 990         EXPECT_EQ(recv(self->cfd, recv_mem, recv_len, 0), recv_len);
 991         EXPECT_EQ(recv(self->cfd, recv_mem + recv_len, recv_len, 0), 5);
 992         EXPECT_EQ(memcmp(send_mem, recv_mem, total_len), 0);
 993 }
 994
 995 TEST_F(tls, recv_partial)
 996 {
 997         char const *test_str = "test_read_partial";
 998         char const *test_str_first = "test_read";
 999         char const *test_str_second = "_partial";
1000         int send_len = strlen(test_str) + 1;
1001         char recv_mem[18];
1002
1003         memset(recv_mem, 0, sizeof(recv_mem));
1004         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1005         EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_first),
1006                        MSG_WAITALL), strlen(test_str_first));
1007         EXPECT_EQ(memcmp(test_str_first, recv_mem, strlen(test_str_first)), 0);
1008         memset(recv_mem, 0, sizeof(recv_mem));
1009         EXPECT_EQ(recv(self->cfd, recv_mem, strlen(test_str_second),
1010                        MSG_WAITALL), strlen(test_str_second));
1011         EXPECT_EQ(memcmp(test_str_second, recv_mem, strlen(test_str_second)),
1012                   0);
1013 }
1014
1015 TEST_F(tls, recv_nonblock)
1016 {
1017         char buf[4096];
1018         bool err;
1019
1020         EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_DONTWAIT), -1);
1021         err = (errno == EAGAIN || errno == EWOULDBLOCK);
1022         EXPECT_EQ(err, true);
1023 }
1024
1025 TEST_F(tls, recv_peek)
1026 {
1027         char const *test_str = "test_read_peek";
1028         int send_len = strlen(test_str) + 1;
1029         char buf[15];
1030
1031         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1032         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_PEEK), send_len);
1033         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
1034         memset(buf, 0, sizeof(buf));
1035         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), send_len);
1036         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
1037 }
1038
1039 TEST_F(tls, recv_peek_multiple)
1040 {
1041         char const *test_str = "test_read_peek";
1042         int send_len = strlen(test_str) + 1;
1043         unsigned int num_peeks = 100;
1044         char buf[15];
1045         int i;
1046
1047         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1048         for (i = 0; i < num_peeks; i++) {
1049                 EXPECT_NE(recv(self->cfd, buf, send_len, MSG_PEEK), -1);
1050                 EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
1051                 memset(buf, 0, sizeof(buf));
1052         }
1053         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1054         EXPECT_EQ(memcmp(test_str, buf, send_len), 0);
1055 }
1056
1057 TEST_F(tls, recv_peek_multiple_records)
1058 {
1059         char const *test_str = "test_read_peek_mult_recs";
1060         char const *test_str_first = "test_read_peek";
1061         char const *test_str_second = "_mult_recs";
1062         int len;
1063         char buf[64];
1064
1065         len = strlen(test_str_first);
1066         EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
1067
1068         len = strlen(test_str_second) + 1;
1069         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
1070
1071         len = strlen(test_str_first);
1072         memset(buf, 0, len);
1073         EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
1074
1075         /* MSG_PEEK can only peek into the current record. */
1076         len = strlen(test_str_first);
1077         EXPECT_EQ(memcmp(test_str_first, buf, len), 0);
1078
1079         len = strlen(test_str) + 1;
1080         memset(buf, 0, len);
1081         EXPECT_EQ(recv(self->cfd, buf, len, MSG_WAITALL), len);
1082
1083         /* Non-MSG_PEEK will advance strparser (and therefore record)
1084          * however.
1085          */
1086         len = strlen(test_str) + 1;
1087         EXPECT_EQ(memcmp(test_str, buf, len), 0);
1088
1089         /* MSG_MORE will hold current record open, so later MSG_PEEK
1090          * will see everything.
1091          */
1092         len = strlen(test_str_first);
1093         EXPECT_EQ(send(self->fd, test_str_first, len, MSG_MORE), len);
1094
1095         len = strlen(test_str_second) + 1;
1096         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
1097
1098         len = strlen(test_str) + 1;
1099         memset(buf, 0, len);
1100         EXPECT_EQ(recv(self->cfd, buf, len, MSG_PEEK | MSG_WAITALL), len);
1101
1102         len = strlen(test_str) + 1;
1103         EXPECT_EQ(memcmp(test_str, buf, len), 0);
1104 }
1105
1106 TEST_F(tls, recv_peek_large_buf_mult_recs)
1107 {
1108         char const *test_str = "test_read_peek_mult_recs";
1109         char const *test_str_first = "test_read_peek";
1110         char const *test_str_second = "_mult_recs";
1111         int len;
1112         char buf[64];
1113
1114         len = strlen(test_str_first);
1115         EXPECT_EQ(send(self->fd, test_str_first, len, 0), len);
1116
1117         len = strlen(test_str_second) + 1;
1118         EXPECT_EQ(send(self->fd, test_str_second, len, 0), len);
1119
1120         len = strlen(test_str) + 1;
1121         memset(buf, 0, len);
1122         EXPECT_NE((len = recv(self->cfd, buf, len,
1123                               MSG_PEEK | MSG_WAITALL)), -1);
1124         len = strlen(test_str) + 1;
1125         EXPECT_EQ(memcmp(test_str, buf, len), 0);
1126 }
1127
1128 TEST_F(tls, recv_lowat)
1129 {
1130         char send_mem[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
1131         char recv_mem[20];
1132         int lowat = 8;
1133
1134         EXPECT_EQ(send(self->fd, send_mem, 10, 0), 10);
1135         EXPECT_EQ(send(self->fd, send_mem, 5, 0), 5);
1136
1137         memset(recv_mem, 0, 20);
1138         EXPECT_EQ(setsockopt(self->cfd, SOL_SOCKET, SO_RCVLOWAT,
1139                              &lowat, sizeof(lowat)), 0);
1140         EXPECT_EQ(recv(self->cfd, recv_mem, 1, MSG_WAITALL), 1);
1141         EXPECT_EQ(recv(self->cfd, recv_mem + 1, 6, MSG_WAITALL), 6);
1142         EXPECT_EQ(recv(self->cfd, recv_mem + 7, 10, 0), 8);
1143
1144         EXPECT_EQ(memcmp(send_mem, recv_mem, 10), 0);
1145         EXPECT_EQ(memcmp(send_mem, recv_mem + 10, 5), 0);
1146 }
1147
1148 TEST_F(tls, bidir)
1149 {
1150         char const *test_str = "test_read";
1151         int send_len = 10;
1152         char buf[10];
1153         int ret;
1154
1155         if (!self->notls) {
1156                 struct tls_crypto_info_keys tls12;
1157
1158                 tls_crypto_info_init(variant->tls_version, variant->cipher_type,
1159                                      &tls12);
1160
1161                 ret = setsockopt(self->fd, SOL_TLS, TLS_RX, &tls12,
1162                                  tls12.len);
1163                 ASSERT_EQ(ret, 0);
1164
1165                 ret = setsockopt(self->cfd, SOL_TLS, TLS_TX, &tls12,
1166                                  tls12.len);
1167                 ASSERT_EQ(ret, 0);
1168         }
1169
1170         ASSERT_EQ(strlen(test_str) + 1, send_len);
1171
1172         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1173         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1174         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1175
1176         memset(buf, 0, sizeof(buf));
1177
1178         EXPECT_EQ(send(self->cfd, test_str, send_len, 0), send_len);
1179         EXPECT_NE(recv(self->fd, buf, send_len, 0), -1);
1180         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1181 };
1182
1183 TEST_F(tls, pollin)
1184 {
1185         char const *test_str = "test_poll";
1186         struct pollfd fd = { 0, 0, 0 };
1187         char buf[10];
1188         int send_len = 10;
1189
1190         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1191         fd.fd = self->cfd;
1192         fd.events = POLLIN;
1193
1194         EXPECT_EQ(poll(&fd, 1, 20), 1);
1195         EXPECT_EQ(fd.revents & POLLIN, 1);
1196         EXPECT_EQ(recv(self->cfd, buf, send_len, MSG_WAITALL), send_len);
1197         /* Test timing out */
1198         EXPECT_EQ(poll(&fd, 1, 20), 0);
1199 }
1200
1201 TEST_F(tls, poll_wait)
1202 {
1203         char const *test_str = "test_poll_wait";
1204         int send_len = strlen(test_str) + 1;
1205         struct pollfd fd = { 0, 0, 0 };
1206         char recv_mem[15];
1207
1208         fd.fd = self->cfd;
1209         fd.events = POLLIN;
1210         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1211         /* Set timeout to inf. secs */
1212         EXPECT_EQ(poll(&fd, 1, -1), 1);
1213         EXPECT_EQ(fd.revents & POLLIN, 1);
1214         EXPECT_EQ(recv(self->cfd, recv_mem, send_len, MSG_WAITALL), send_len);
1215 }
1216
1217 TEST_F(tls, poll_wait_split)
1218 {
1219         struct pollfd fd = { 0, 0, 0 };
1220         char send_mem[20] = {};
1221         char recv_mem[15];
1222
1223         fd.fd = self->cfd;
1224         fd.events = POLLIN;
1225         /* Send 20 bytes */
1226         EXPECT_EQ(send(self->fd, send_mem, sizeof(send_mem), 0),
1227                   sizeof(send_mem));
1228         /* Poll with inf. timeout */
1229         EXPECT_EQ(poll(&fd, 1, -1), 1);
1230         EXPECT_EQ(fd.revents & POLLIN, 1);
1231         EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), MSG_WAITALL),
1232                   sizeof(recv_mem));
1233
1234         /* Now the remaining 5 bytes of record data are in TLS ULP */
1235         fd.fd = self->cfd;
1236         fd.events = POLLIN;
1237         EXPECT_EQ(poll(&fd, 1, -1), 1);
1238         EXPECT_EQ(fd.revents & POLLIN, 1);
1239         EXPECT_EQ(recv(self->cfd, recv_mem, sizeof(recv_mem), 0),
1240                   sizeof(send_mem) - sizeof(recv_mem));
1241 }
1242
1243 TEST_F(tls, blocking)
1244 {
1245         size_t data = 100000;
1246         int res = fork();
1247
1248         EXPECT_NE(res, -1);
1249
1250         if (res) {
1251                 /* parent */
1252                 size_t left = data;
1253                 char buf[16384];
1254                 int status;
1255                 int pid2;
1256
1257                 while (left) {
1258                         int res = send(self->fd, buf,
1259                                        left > 16384 ? 16384 : left, 0);
1260
1261                         EXPECT_GE(res, 0);
1262                         left -= res;
1263                 }
1264
1265                 pid2 = wait(&status);
1266                 EXPECT_EQ(status, 0);
1267                 EXPECT_EQ(res, pid2);
1268         } else {
1269                 /* child */
1270                 size_t left = data;
1271                 char buf[16384];
1272
1273                 while (left) {
1274                         int res = recv(self->cfd, buf,
1275                                        left > 16384 ? 16384 : left, 0);
1276
1277                         EXPECT_GE(res, 0);
1278                         left -= res;
1279                 }
1280         }
1281 }
1282
1283 TEST_F(tls, nonblocking)
1284 {
1285         size_t data = 100000;
1286         int sendbuf = 100;
1287         int flags;
1288         int res;
1289
1290         flags = fcntl(self->fd, F_GETFL, 0);
1291         fcntl(self->fd, F_SETFL, flags | O_NONBLOCK);
1292         fcntl(self->cfd, F_SETFL, flags | O_NONBLOCK);
1293
1294         /* Ensure nonblocking behavior by imposing a small send
1295          * buffer.
1296          */
1297         EXPECT_EQ(setsockopt(self->fd, SOL_SOCKET, SO_SNDBUF,
1298                              &sendbuf, sizeof(sendbuf)), 0);
1299
1300         res = fork();
1301         EXPECT_NE(res, -1);
1302
1303         if (res) {
1304                 /* parent */
1305                 bool eagain = false;
1306                 size_t left = data;
1307                 char buf[16384];
1308                 int status;
1309                 int pid2;
1310
1311                 while (left) {
1312                         int res = send(self->fd, buf,
1313                                        left > 16384 ? 16384 : left, 0);
1314
1315                         if (res == -1 && errno == EAGAIN) {
1316                                 eagain = true;
1317                                 usleep(10000);
1318                                 continue;
1319                         }
1320                         EXPECT_GE(res, 0);
1321                         left -= res;
1322                 }
1323
1324                 EXPECT_TRUE(eagain);
1325                 pid2 = wait(&status);
1326
1327                 EXPECT_EQ(status, 0);
1328                 EXPECT_EQ(res, pid2);
1329         } else {
1330                 /* child */
1331                 bool eagain = false;
1332                 size_t left = data;
1333                 char buf[16384];
1334
1335                 while (left) {
1336                         int res = recv(self->cfd, buf,
1337                                        left > 16384 ? 16384 : left, 0);
1338
1339                         if (res == -1 && errno == EAGAIN) {
1340                                 eagain = true;
1341                                 usleep(10000);
1342                                 continue;
1343                         }
1344                         EXPECT_GE(res, 0);
1345                         left -= res;
1346                 }
1347                 EXPECT_TRUE(eagain);
1348         }
1349 }
1350
1351 static void
1352 test_mutliproc(struct __test_metadata *_metadata, struct _test_data_tls *self,
1353                bool sendpg, unsigned int n_readers, unsigned int n_writers)
1354 {
1355         const unsigned int n_children = n_readers + n_writers;
1356         const size_t data = 6 * 1000 * 1000;
1357         const size_t file_sz = data / 100;
1358         size_t read_bias, write_bias;
1359         int i, fd, child_id;
1360         char buf[file_sz];
1361         pid_t pid;
1362
1363         /* Only allow multiples for simplicity */
1364         ASSERT_EQ(!(n_readers % n_writers) || !(n_writers % n_readers), true);
1365         read_bias = n_writers / n_readers ?: 1;
1366         write_bias = n_readers / n_writers ?: 1;
1367
1368         /* prep a file to send */
1369         fd = open("/tmp/", O_TMPFILE | O_RDWR, 0600);
1370         ASSERT_GE(fd, 0);
1371
1372         memset(buf, 0xac, file_sz);
1373         ASSERT_EQ(write(fd, buf, file_sz), file_sz);
1374
1375         /* spawn children */
1376         for (child_id = 0; child_id < n_children; child_id++) {
1377                 pid = fork();
1378                 ASSERT_NE(pid, -1);
1379                 if (!pid)
1380                         break;
1381         }
1382
1383         /* parent waits for all children */
1384         if (pid) {
1385                 for (i = 0; i < n_children; i++) {
1386                         int status;
1387
1388                         wait(&status);
1389                         EXPECT_EQ(status, 0);
1390                 }
1391
1392                 return;
1393         }
1394
1395         /* Split threads for reading and writing */
1396         if (child_id < n_readers) {
1397                 size_t left = data * read_bias;
1398                 char rb[8001];
1399
1400                 while (left) {
1401                         int res;
1402
1403                         res = recv(self->cfd, rb,
1404                                    left > sizeof(rb) ? sizeof(rb) : left, 0);
1405
1406                         EXPECT_GE(res, 0);
1407                         left -= res;
1408                 }
1409         } else {
1410                 size_t left = data * write_bias;
1411
1412                 while (left) {
1413                         int res;
1414
1415                         ASSERT_EQ(lseek(fd, 0, SEEK_SET), 0);
1416                         if (sendpg)
1417                                 res = sendfile(self->fd, fd, NULL,
1418                                                left > file_sz ? file_sz : left);
1419                         else
1420                                 res = send(self->fd, buf,
1421                                            left > file_sz ? file_sz : left, 0);
1422
1423                         EXPECT_GE(res, 0);
1424                         left -= res;
1425                 }
1426         }
1427 }
1428
1429 TEST_F(tls, mutliproc_even)
1430 {
1431         test_mutliproc(_metadata, self, false, 6, 6);
1432 }
1433
1434 TEST_F(tls, mutliproc_readers)
1435 {
1436         test_mutliproc(_metadata, self, false, 4, 12);
1437 }
1438
1439 TEST_F(tls, mutliproc_writers)
1440 {
1441         test_mutliproc(_metadata, self, false, 10, 2);
1442 }
1443
1444 TEST_F(tls, mutliproc_sendpage_even)
1445 {
1446         test_mutliproc(_metadata, self, true, 6, 6);
1447 }
1448
1449 TEST_F(tls, mutliproc_sendpage_readers)
1450 {
1451         test_mutliproc(_metadata, self, true, 4, 12);
1452 }
1453
1454 TEST_F(tls, mutliproc_sendpage_writers)
1455 {
1456         test_mutliproc(_metadata, self, true, 10, 2);
1457 }
1458
1459 TEST_F(tls, control_msg)
1460 {
1461         char *test_str = "test_read";
1462         char record_type = 100;
1463         int send_len = 10;
1464         char buf[10];
1465
1466         if (self->notls)
1467                 SKIP(return, "no TLS support");
1468
1469         EXPECT_EQ(tls_send_cmsg(self->fd, record_type, test_str, send_len, 0),
1470                   send_len);
1471         /* Should fail because we didn't provide a control message */
1472         EXPECT_EQ(recv(self->cfd, buf, send_len, 0), -1);
1473
1474         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
1475                                 buf, sizeof(buf), MSG_WAITALL | MSG_PEEK),
1476                   send_len);
1477         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1478
1479         /* Recv the message again without MSG_PEEK */
1480         memset(buf, 0, sizeof(buf));
1481
1482         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, record_type,
1483                                 buf, sizeof(buf), MSG_WAITALL),
1484                   send_len);
1485         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1486 }
1487
1488 TEST_F(tls, control_msg_nomerge)
1489 {
1490         char *rec1 = "1111";
1491         char *rec2 = "2222";
1492         int send_len = 5;
1493         char buf[15];
1494
1495         if (self->notls)
1496                 SKIP(return, "no TLS support");
1497
1498         EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec1, send_len, 0), send_len);
1499         EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec2, send_len, 0), send_len);
1500
1501         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), MSG_PEEK), send_len);
1502         EXPECT_EQ(memcmp(buf, rec1, send_len), 0);
1503
1504         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), MSG_PEEK), send_len);
1505         EXPECT_EQ(memcmp(buf, rec1, send_len), 0);
1506
1507         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), 0), send_len);
1508         EXPECT_EQ(memcmp(buf, rec1, send_len), 0);
1509
1510         EXPECT_EQ(tls_recv_cmsg(_metadata, self->cfd, 100, buf, sizeof(buf), 0), send_len);
1511         EXPECT_EQ(memcmp(buf, rec2, send_len), 0);
1512 }
1513
1514 TEST_F(tls, data_control_data)
1515 {
1516         char *rec1 = "1111";
1517         char *rec2 = "2222";
1518         char *rec3 = "3333";
1519         int send_len = 5;
1520         char buf[15];
1521
1522         if (self->notls)
1523                 SKIP(return, "no TLS support");
1524
1525         EXPECT_EQ(send(self->fd, rec1, send_len, 0), send_len);
1526         EXPECT_EQ(tls_send_cmsg(self->fd, 100, rec2, send_len, 0), send_len);
1527         EXPECT_EQ(send(self->fd, rec3, send_len, 0), send_len);
1528
1529         EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len);
1530         EXPECT_EQ(recv(self->cfd, buf, sizeof(buf), MSG_PEEK), send_len);
1531 }
1532
1533 TEST_F(tls, shutdown)
1534 {
1535         char const *test_str = "test_read";
1536         int send_len = 10;
1537         char buf[10];
1538
1539         ASSERT_EQ(strlen(test_str) + 1, send_len);
1540
1541         EXPECT_EQ(send(self->fd, test_str, send_len, 0), send_len);
1542         EXPECT_NE(recv(self->cfd, buf, send_len, 0), -1);
1543         EXPECT_EQ(memcmp(buf, test_str, send_len), 0);
1544
1545         shutdown(self->fd, SHUT_RDWR);
1546         shutdown(self->cfd, SHUT_RDWR);
1547 }
1548
1549 TEST_F(tls, shutdown_unsent)
1550 {
1551         char const *test_str = "test_read";
1552         int send_len = 10;
1553
1554         EXPECT_EQ(send(self->fd, test_str, send_len, MSG_MORE), send_len);
1555
1556         shutdown(self->fd, SHUT_RDWR);
1557         shutdown(self->cfd, SHUT_RDWR);
1558 }
1559
1560 TEST_F(tls, shutdown_reuse)
1561 {
1562         struct sockaddr_in addr;
1563         int ret;
1564
1565         shutdown(self->fd, SHUT_RDWR);
1566         shutdown(self->cfd, SHUT_RDWR);
1567         close(self->cfd);
1568
1569         addr.sin_family = AF_INET;
1570         addr.sin_addr.s_addr = htonl(INADDR_ANY);
1571         addr.sin_port = 0;
1572
1573         ret = bind(self->fd, &addr, sizeof(addr));
1574         EXPECT_EQ(ret, 0);
1575         ret = listen(self->fd, 10);
1576         EXPECT_EQ(ret, -1);
1577         EXPECT_EQ(errno, EINVAL);
1578
1579         ret = connect(self->fd, &addr, sizeof(addr));
1580         EXPECT_EQ(ret, -1);
1581         EXPECT_EQ(errno, EISCONN);
1582 }
1583
1584 TEST_F(tls, getsockopt)
1585 {
1586         struct tls_crypto_info_keys expect, get;
1587         socklen_t len;
1588
1589         /* get only the version/cipher */
1590         len = sizeof(struct tls_crypto_info);
1591         memrnd(&get, sizeof(get));
1592         EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), 0);
1593         EXPECT_EQ(len, sizeof(struct tls_crypto_info));
1594         EXPECT_EQ(get.crypto_info.version, variant->tls_version);
1595         EXPECT_EQ(get.crypto_info.cipher_type, variant->cipher_type);
1596
1597         /* get the full crypto_info */
1598         tls_crypto_info_init(variant->tls_version, variant->cipher_type, &expect);
1599         len = expect.len;
1600         memrnd(&get, sizeof(get));
1601         EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), 0);
1602         EXPECT_EQ(len, expect.len);
1603         EXPECT_EQ(get.crypto_info.version, variant->tls_version);
1604         EXPECT_EQ(get.crypto_info.cipher_type, variant->cipher_type);
1605         EXPECT_EQ(memcmp(&get, &expect, expect.len), 0);
1606
1607         /* short get should fail */
1608         len = sizeof(struct tls_crypto_info) - 1;
1609         EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), -1);
1610         EXPECT_EQ(errno, EINVAL);
1611
1612         /* partial get of the cipher data should fail */
1613         len = expect.len - 1;
1614         EXPECT_EQ(getsockopt(self->fd, SOL_TLS, TLS_TX, &get, &len), -1);
1615         EXPECT_EQ(errno, EINVAL);
1616 }
1617
1618 TEST_F(tls, recv_efault)
1619 {
1620         char *rec1 = "1111111111";
1621         char *rec2 = "2222222222";
1622         struct msghdr hdr = {};
1623         struct iovec iov[2];
1624         char recv_mem[12];
1625         int ret;
1626
1627         if (self->notls)
1628                 SKIP(return, "no TLS support");
1629
1630         EXPECT_EQ(send(self->fd, rec1, 10, 0), 10);
1631         EXPECT_EQ(send(self->fd, rec2, 10, 0), 10);
1632
1633         iov[0].iov_base = recv_mem;
1634         iov[0].iov_len = sizeof(recv_mem);
1635         iov[1].iov_base = NULL; /* broken iov to make process_rx_list fail */
1636         iov[1].iov_len = 1;
1637
1638         hdr.msg_iovlen = 2;
1639         hdr.msg_iov = iov;
1640
1641         EXPECT_EQ(recv(self->cfd, recv_mem, 1, 0), 1);
1642         EXPECT_EQ(recv_mem[0], rec1[0]);
1643
1644         ret = recvmsg(self->cfd, &hdr, 0);
1645         EXPECT_LE(ret, sizeof(recv_mem));
1646         EXPECT_GE(ret, 9);
1647         EXPECT_EQ(memcmp(rec1, recv_mem, 9), 0);
1648         if (ret > 9)
1649                 EXPECT_EQ(memcmp(rec2, recv_mem + 9, ret - 9), 0);
1650 }
1651
1652 FIXTURE(tls_err)
1653 {
1654         int fd, cfd;
1655         int fd2, cfd2;
1656         bool notls;
1657 };
1658
1659 FIXTURE_VARIANT(tls_err)
1660 {
1661         uint16_t tls_version;
1662 };
1663
1664 FIXTURE_VARIANT_ADD(tls_err, 12_aes_gcm)
1665 {
1666         .tls_version = TLS_1_2_VERSION,
1667 };
1668
1669 FIXTURE_VARIANT_ADD(tls_err, 13_aes_gcm)
1670 {
1671         .tls_version = TLS_1_3_VERSION,
1672 };
1673
1674 FIXTURE_SETUP(tls_err)
1675 {
1676         struct tls_crypto_info_keys tls12;
1677         int ret;
1678
1679         tls_crypto_info_init(variant->tls_version, TLS_CIPHER_AES_GCM_128,
1680                              &tls12);
1681
1682         ulp_sock_pair(_metadata, &self->fd, &self->cfd, &self->notls);
1683         ulp_sock_pair(_metadata, &self->fd2, &self->cfd2, &self->notls);
1684         if (self->notls)
1685                 return;
1686
1687         ret = setsockopt(self->fd, SOL_TLS, TLS_TX, &tls12, tls12.len);
1688         ASSERT_EQ(ret, 0);
1689
1690         ret = setsockopt(self->cfd2, SOL_TLS, TLS_RX, &tls12, tls12.len);
1691         ASSERT_EQ(ret, 0);
1692 }
1693
1694 FIXTURE_TEARDOWN(tls_err)
1695 {
1696         close(self->fd);
1697         close(self->cfd);
1698         close(self->fd2);
1699         close(self->cfd2);
1700 }
1701
1702 TEST_F(tls_err, bad_rec)
1703 {
1704         char buf[64];
1705
1706         if (self->notls)
1707                 SKIP(return, "no TLS support");
1708
1709         memset(buf, 0x55, sizeof(buf));
1710         EXPECT_EQ(send(self->fd2, buf, sizeof(buf), 0), sizeof(buf));
1711         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1712         EXPECT_EQ(errno, EMSGSIZE);
1713         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), MSG_DONTWAIT), -1);
1714         EXPECT_EQ(errno, EAGAIN);
1715 }
1716
1717 TEST_F(tls_err, bad_auth)
1718 {
1719         char buf[128];
1720         int n;
1721
1722         if (self->notls)
1723                 SKIP(return, "no TLS support");
1724
1725         memrnd(buf, sizeof(buf) / 2);
1726         EXPECT_EQ(send(self->fd, buf, sizeof(buf) / 2, 0), sizeof(buf) / 2);
1727         n = recv(self->cfd, buf, sizeof(buf), 0);
1728         EXPECT_GT(n, sizeof(buf) / 2);
1729
1730         buf[n - 1]++;
1731
1732         EXPECT_EQ(send(self->fd2, buf, n, 0), n);
1733         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1734         EXPECT_EQ(errno, EBADMSG);
1735         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1736         EXPECT_EQ(errno, EBADMSG);
1737 }
1738
1739 TEST_F(tls_err, bad_in_large_read)
1740 {
1741         char txt[3][64];
1742         char cip[3][128];
1743         char buf[3 * 128];
1744         int i, n;
1745
1746         if (self->notls)
1747                 SKIP(return, "no TLS support");
1748
1749         /* Put 3 records in the sockets */
1750         for (i = 0; i < 3; i++) {
1751                 memrnd(txt[i], sizeof(txt[i]));
1752                 EXPECT_EQ(send(self->fd, txt[i], sizeof(txt[i]), 0),
1753                           sizeof(txt[i]));
1754                 n = recv(self->cfd, cip[i], sizeof(cip[i]), 0);
1755                 EXPECT_GT(n, sizeof(txt[i]));
1756                 /* Break the third message */
1757                 if (i == 2)
1758                         cip[2][n - 1]++;
1759                 EXPECT_EQ(send(self->fd2, cip[i], n, 0), n);
1760         }
1761
1762         /* We should be able to receive the first two messages */
1763         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt[0]) * 2);
1764         EXPECT_EQ(memcmp(buf, txt[0], sizeof(txt[0])), 0);
1765         EXPECT_EQ(memcmp(buf + sizeof(txt[0]), txt[1], sizeof(txt[1])), 0);
1766         /* Third mesasge is bad */
1767         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1768         EXPECT_EQ(errno, EBADMSG);
1769         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1770         EXPECT_EQ(errno, EBADMSG);
1771 }
1772
1773 TEST_F(tls_err, bad_cmsg)
1774 {
1775         char *test_str = "test_read";
1776         int send_len = 10;
1777         char cip[128];
1778         char buf[128];
1779         char txt[64];
1780         int n;
1781
1782         if (self->notls)
1783                 SKIP(return, "no TLS support");
1784
1785         /* Queue up one data record */
1786         memrnd(txt, sizeof(txt));
1787         EXPECT_EQ(send(self->fd, txt, sizeof(txt), 0), sizeof(txt));
1788         n = recv(self->cfd, cip, sizeof(cip), 0);
1789         EXPECT_GT(n, sizeof(txt));
1790         EXPECT_EQ(send(self->fd2, cip, n, 0), n);
1791
1792         EXPECT_EQ(tls_send_cmsg(self->fd, 100, test_str, send_len, 0), 10);
1793         n = recv(self->cfd, cip, sizeof(cip), 0);
1794         cip[n - 1]++; /* Break it */
1795         EXPECT_GT(n, send_len);
1796         EXPECT_EQ(send(self->fd2, cip, n, 0), n);
1797
1798         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), sizeof(txt));
1799         EXPECT_EQ(memcmp(buf, txt, sizeof(txt)), 0);
1800         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1801         EXPECT_EQ(errno, EBADMSG);
1802         EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1803         EXPECT_EQ(errno, EBADMSG);
1804 }
1805
1806 TEST_F(tls_err, timeo)
1807 {
1808         struct timeval tv = { .tv_usec = 10000, };
1809         char buf[128];
1810         int ret;
1811
1812         if (self->notls)
1813                 SKIP(return, "no TLS support");
1814
1815         ret = setsockopt(self->cfd2, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
1816         ASSERT_EQ(ret, 0);
1817
1818         ret = fork();
1819         ASSERT_GE(ret, 0);
1820
1821         if (ret) {
1822                 usleep(1000); /* Give child a head start */
1823
1824                 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1825                 EXPECT_EQ(errno, EAGAIN);
1826
1827                 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1828                 EXPECT_EQ(errno, EAGAIN);
1829
1830                 wait(&ret);
1831         } else {
1832                 EXPECT_EQ(recv(self->cfd2, buf, sizeof(buf), 0), -1);
1833                 EXPECT_EQ(errno, EAGAIN);
1834                 exit(0);
1835         }
1836 }
1837
1838 TEST_F(tls_err, poll_partial_rec)
1839 {
1840         struct pollfd pfd = { };
1841         ssize_t rec_len;
1842         char rec[256];
1843         char buf[128];
1844
1845         if (self->notls)
1846                 SKIP(return, "no TLS support");
1847
1848         pfd.fd = self->cfd2;
1849         pfd.events = POLLIN;
1850         EXPECT_EQ(poll(&pfd, 1, 1), 0);
1851
1852         memrnd(buf, sizeof(buf));
1853         EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf));
1854         rec_len = recv(self->cfd, rec, sizeof(rec), 0);
1855         EXPECT_GT(rec_len, sizeof(buf));
1856
1857         /* Write 100B, not the full record ... */
1858         EXPECT_EQ(send(self->fd2, rec, 100, 0), 100);
1859         /* ... no full record should mean no POLLIN */
1860         pfd.fd = self->cfd2;
1861         pfd.events = POLLIN;
1862         EXPECT_EQ(poll(&pfd, 1, 1), 0);
1863         /* Now write the rest, and it should all pop out of the other end. */
1864         EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), rec_len - 100);
1865         pfd.fd = self->cfd2;
1866         pfd.events = POLLIN;
1867         EXPECT_EQ(poll(&pfd, 1, 1), 1);
1868         EXPECT_EQ(recv(self->cfd2, rec, sizeof(rec), 0), sizeof(buf));
1869         EXPECT_EQ(memcmp(buf, rec, sizeof(buf)), 0);
1870 }
1871
1872 TEST_F(tls_err, epoll_partial_rec)
1873 {
1874         struct epoll_event ev, events[10];
1875         ssize_t rec_len;
1876         char rec[256];
1877         char buf[128];
1878         int epollfd;
1879
1880         if (self->notls)
1881                 SKIP(return, "no TLS support");
1882
1883         epollfd = epoll_create1(0);
1884         ASSERT_GE(epollfd, 0);
1885
1886         memset(&ev, 0, sizeof(ev));
1887         ev.events = EPOLLIN;
1888         ev.data.fd = self->cfd2;
1889         ASSERT_GE(epoll_ctl(epollfd, EPOLL_CTL_ADD, self->cfd2, &ev), 0);
1890
1891         EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 0);
1892
1893         memrnd(buf, sizeof(buf));
1894         EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf));
1895         rec_len = recv(self->cfd, rec, sizeof(rec), 0);
1896         EXPECT_GT(rec_len, sizeof(buf));
1897
1898         /* Write 100B, not the full record ... */
1899         EXPECT_EQ(send(self->fd2, rec, 100, 0), 100);
1900         /* ... no full record should mean no POLLIN */
1901         EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 0);
1902         /* Now write the rest, and it should all pop out of the other end. */
1903         EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0), rec_len - 100);
1904         EXPECT_EQ(epoll_wait(epollfd, events, 10, 0), 1);
1905         EXPECT_EQ(recv(self->cfd2, rec, sizeof(rec), 0), sizeof(buf));
1906         EXPECT_EQ(memcmp(buf, rec, sizeof(buf)), 0);
1907
1908         close(epollfd);
1909 }
1910
1911 TEST_F(tls_err, poll_partial_rec_async)
1912 {
1913         struct pollfd pfd = { };
1914         ssize_t rec_len;
1915         char rec[256];
1916         char buf[128];
1917         char token;
1918         int p[2];
1919         int ret;
1920
1921         if (self->notls)
1922                 SKIP(return, "no TLS support");
1923
1924         ASSERT_GE(pipe(p), 0);
1925
1926         memrnd(buf, sizeof(buf));
1927         EXPECT_EQ(send(self->fd, buf, sizeof(buf), 0), sizeof(buf));
1928         rec_len = recv(self->cfd, rec, sizeof(rec), 0);
1929         EXPECT_GT(rec_len, sizeof(buf));
1930
1931         ret = fork();
1932         ASSERT_GE(ret, 0);
1933
1934         if (ret) {
1935                 int status, pid2;
1936
1937                 close(p[1]);
1938                 usleep(1000); /* Give child a head start */
1939
1940                 EXPECT_EQ(send(self->fd2, rec, 100, 0), 100);
1941
1942                 EXPECT_EQ(read(p[0], &token, 1), 1); /* Barrier #1 */
1943
1944                 EXPECT_EQ(send(self->fd2, rec + 100, rec_len - 100, 0),
1945                           rec_len - 100);
1946
1947                 pid2 = wait(&status);
1948                 EXPECT_EQ(pid2, ret);
1949                 EXPECT_EQ(status, 0);
1950         } else {
1951                 close(p[0]);
1952
1953                 /* Child should sleep in poll(), never get a wake */
1954                 pfd.fd = self->cfd2;
1955                 pfd.events = POLLIN;
1956                 EXPECT_EQ(poll(&pfd, 1, 20), 0);
1957
1958                 EXPECT_EQ(write(p[1], &token, 1), 1); /* Barrier #1 */
1959
1960                 pfd.fd = self->cfd2;
1961                 pfd.events = POLLIN;
1962                 EXPECT_EQ(poll(&pfd, 1, 20), 1);
1963
1964                 exit(!__test_passed(_metadata));
1965         }
1966 }
1967
1968 TEST(non_established) {
1969         struct tls12_crypto_info_aes_gcm_256 tls12;
1970         struct sockaddr_in addr;
1971         int sfd, ret, fd;
1972         socklen_t len;
1973
1974         len = sizeof(addr);
1975
1976         memset(&tls12, 0, sizeof(tls12));
1977         tls12.info.version = TLS_1_2_VERSION;
1978         tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
1979
1980         addr.sin_family = AF_INET;
1981         addr.sin_addr.s_addr = htonl(INADDR_ANY);
1982         addr.sin_port = 0;
1983
1984         fd = socket(AF_INET, SOCK_STREAM, 0);
1985         sfd = socket(AF_INET, SOCK_STREAM, 0);
1986
1987         ret = bind(sfd, &addr, sizeof(addr));
1988         ASSERT_EQ(ret, 0);
1989         ret = listen(sfd, 10);
1990         ASSERT_EQ(ret, 0);
1991
1992         ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
1993         EXPECT_EQ(ret, -1);
1994         /* TLS ULP not supported */
1995         if (errno == ENOENT)
1996                 return;
1997         EXPECT_EQ(errno, ENOTCONN);
1998
1999         ret = setsockopt(sfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
2000         EXPECT_EQ(ret, -1);
2001         EXPECT_EQ(errno, ENOTCONN);
2002
2003         ret = getsockname(sfd, &addr, &len);
2004         ASSERT_EQ(ret, 0);
2005
2006         ret = connect(fd, &addr, sizeof(addr));
2007         ASSERT_EQ(ret, 0);
2008
2009         ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
2010         ASSERT_EQ(ret, 0);
2011
2012         ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
2013         EXPECT_EQ(ret, -1);
2014         EXPECT_EQ(errno, EEXIST);
2015
2016         close(fd);
2017         close(sfd);
2018 }
2019
2020 TEST(keysizes) {
2021         struct tls12_crypto_info_aes_gcm_256 tls12;
2022         int ret, fd, cfd;
2023         bool notls;
2024
2025         memset(&tls12, 0, sizeof(tls12));
2026         tls12.info.version = TLS_1_2_VERSION;
2027         tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
2028
2029         ulp_sock_pair(_metadata, &fd, &cfd, &notls);
2030
2031         if (!notls) {
2032                 ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12,
2033                                  sizeof(tls12));
2034                 EXPECT_EQ(ret, 0);
2035
2036                 ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12,
2037                                  sizeof(tls12));
2038                 EXPECT_EQ(ret, 0);
2039         }
2040
2041         close(fd);
2042         close(cfd);
2043 }
2044
2045 TEST(no_pad) {
2046         struct tls12_crypto_info_aes_gcm_256 tls12;
2047         int ret, fd, cfd, val;
2048         socklen_t len;
2049         bool notls;
2050
2051         memset(&tls12, 0, sizeof(tls12));
2052         tls12.info.version = TLS_1_3_VERSION;
2053         tls12.info.cipher_type = TLS_CIPHER_AES_GCM_256;
2054
2055         ulp_sock_pair(_metadata, &fd, &cfd, &notls);
2056
2057         if (notls)
2058                 exit(KSFT_SKIP);
2059
2060         ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, sizeof(tls12));
2061         EXPECT_EQ(ret, 0);
2062
2063         ret = setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, sizeof(tls12));
2064         EXPECT_EQ(ret, 0);
2065
2066         val = 1;
2067         ret = setsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD,
2068                          (void *)&val, sizeof(val));
2069         EXPECT_EQ(ret, 0);
2070
2071         len = sizeof(val);
2072         val = 2;
2073         ret = getsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD,
2074                          (void *)&val, &len);
2075         EXPECT_EQ(ret, 0);
2076         EXPECT_EQ(val, 1);
2077         EXPECT_EQ(len, 4);
2078
2079         val = 0;
2080         ret = setsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD,
2081                          (void *)&val, sizeof(val));
2082         EXPECT_EQ(ret, 0);
2083
2084         len = sizeof(val);
2085         val = 2;
2086         ret = getsockopt(cfd, SOL_TLS, TLS_RX_EXPECT_NO_PAD,
2087                          (void *)&val, &len);
2088         EXPECT_EQ(ret, 0);
2089         EXPECT_EQ(val, 0);
2090         EXPECT_EQ(len, 4);
2091
2092         close(fd);
2093         close(cfd);
2094 }
2095
2096 TEST(tls_v6ops) {
2097         struct tls_crypto_info_keys tls12;
2098         struct sockaddr_in6 addr, addr2;
2099         int sfd, ret, fd;
2100         socklen_t len, len2;
2101
2102         tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_128, &tls12);
2103
2104         addr.sin6_family = AF_INET6;
2105         addr.sin6_addr = in6addr_any;
2106         addr.sin6_port = 0;
2107
2108         fd = socket(AF_INET6, SOCK_STREAM, 0);
2109         sfd = socket(AF_INET6, SOCK_STREAM, 0);
2110
2111         ret = bind(sfd, &addr, sizeof(addr));
2112         ASSERT_EQ(ret, 0);
2113         ret = listen(sfd, 10);
2114         ASSERT_EQ(ret, 0);
2115
2116         len = sizeof(addr);
2117         ret = getsockname(sfd, &addr, &len);
2118         ASSERT_EQ(ret, 0);
2119
2120         ret = connect(fd, &addr, sizeof(addr));
2121         ASSERT_EQ(ret, 0);
2122
2123         len = sizeof(addr);
2124         ret = getsockname(fd, &addr, &len);
2125         ASSERT_EQ(ret, 0);
2126
2127         ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
2128         if (ret) {
2129                 ASSERT_EQ(errno, ENOENT);
2130                 SKIP(return, "no TLS support");
2131         }
2132         ASSERT_EQ(ret, 0);
2133
2134         ret = setsockopt(fd, SOL_TLS, TLS_TX, &tls12, tls12.len);
2135         ASSERT_EQ(ret, 0);
2136
2137         ret = setsockopt(fd, SOL_TLS, TLS_RX, &tls12, tls12.len);
2138         ASSERT_EQ(ret, 0);
2139
2140         len2 = sizeof(addr2);
2141         ret = getsockname(fd, &addr2, &len2);
2142         ASSERT_EQ(ret, 0);
2143
2144         EXPECT_EQ(len2, len);
2145         EXPECT_EQ(memcmp(&addr, &addr2, len), 0);
2146
2147         close(fd);
2148         close(sfd);
2149 }
2150
2151 TEST(prequeue) {
2152         struct tls_crypto_info_keys tls12;
2153         char buf[20000], buf2[20000];
2154         struct sockaddr_in addr;
2155         int sfd, cfd, ret, fd;
2156         socklen_t len;
2157
2158         len = sizeof(addr);
2159         memrnd(buf, sizeof(buf));
2160
2161         tls_crypto_info_init(TLS_1_2_VERSION, TLS_CIPHER_AES_GCM_256, &tls12);
2162
2163         addr.sin_family = AF_INET;
2164         addr.sin_addr.s_addr = htonl(INADDR_ANY);
2165         addr.sin_port = 0;
2166
2167         fd = socket(AF_INET, SOCK_STREAM, 0);
2168         sfd = socket(AF_INET, SOCK_STREAM, 0);
2169
2170         ASSERT_EQ(bind(sfd, &addr, sizeof(addr)), 0);
2171         ASSERT_EQ(listen(sfd, 10), 0);
2172         ASSERT_EQ(getsockname(sfd, &addr, &len), 0);
2173         ASSERT_EQ(connect(fd, &addr, sizeof(addr)), 0);
2174         ASSERT_GE(cfd = accept(sfd, &addr, &len), 0);
2175         close(sfd);
2176
2177         ret = setsockopt(fd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls"));
2178         if (ret) {
2179                 ASSERT_EQ(errno, ENOENT);
2180                 SKIP(return, "no TLS support");
2181         }
2182
2183         ASSERT_EQ(setsockopt(fd, SOL_TLS, TLS_TX, &tls12, tls12.len), 0);
2184         EXPECT_EQ(send(fd, buf, sizeof(buf), MSG_DONTWAIT), sizeof(buf));
2185
2186         ASSERT_EQ(setsockopt(cfd, IPPROTO_TCP, TCP_ULP, "tls", sizeof("tls")), 0);
2187         ASSERT_EQ(setsockopt(cfd, SOL_TLS, TLS_RX, &tls12, tls12.len), 0);
2188         EXPECT_EQ(recv(cfd, buf2, sizeof(buf2), MSG_WAITALL), sizeof(buf2));
2189
2190         EXPECT_EQ(memcmp(buf, buf2, sizeof(buf)), 0);
2191
2192         close(fd);
2193         close(cfd);
2194 }
2195
2196 static void __attribute__((constructor)) fips_check(void) {
2197         int res;
2198         FILE *f;
2199
2200         f = fopen("/proc/sys/crypto/fips_enabled", "r");
2201         if (f) {
2202                 res = fscanf(f, "%d", &fips_enabled);
2203                 if (res != 1)
2204                         ksft_print_msg("ERROR: Couldn't read /proc/sys/crypto/fips_enabled\n");
2205                 fclose(f);
2206         }
2207 }
2208
2209 TEST_HARNESS_MAIN