Skip to content

Commit

Permalink
rename and cleanup
Browse files Browse the repository at this point in the history
  • Loading branch information
@toidiu
toidiu committed Aug 8, 2023
1 parent b211bfe commit e76e610
Show file tree
Hide file tree
Showing 4 changed files with 182 additions and 155 deletions.
86 changes: 40 additions & 46 deletions tests/testlib/s2n_ktls_test_utils.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,20 +36,20 @@ static S2N_RESULT s2n_test_ktls_update_prev_header_len(struct s2n_test_ktls_io_s
return S2N_RESULT_OK;
}

ssize_t s2n_test_ktls_sendmsg_stuffer_io(void *io_context, const struct msghdr *msg)
ssize_t s2n_test_ktls_sendmsg_io_stuffer(void *io_context, const struct msghdr *msg)
{
POSIX_ENSURE_REF(io_context);
POSIX_ENSURE_REF(msg);
POSIX_ENSURE_REF(msg->msg_iov);

/* Assuming msg_control is uint8_t is a simplification and will not work when we
* attempt to test the production 2n_ktls_send implementation. However, setting/parsing
* attempt to test the production s2n_ktls_send implementation. However, setting/parsing
* cmsg is critical code and will be added in a separate PR. */
uint8_t *record_type = (uint8_t *) msg->msg_control;
POSIX_ENSURE_REF(record_type);
struct s2n_test_ktls_io_stuffer *io_ctx = (struct s2n_test_ktls_io_stuffer *) io_context;
POSIX_ENSURE_REF(io_ctx);
io_ctx->send_recv_msg_invoked_count++;
io_ctx->sendmsg_invoked_count++;

size_t total_len = 0;
for (size_t count = 0; count < msg->msg_iovlen; count++) {
Expand All @@ -58,12 +58,12 @@ ssize_t s2n_test_ktls_sendmsg_stuffer_io(void *io_context, const struct msghdr *
size_t len = msg->msg_iov[count].iov_len;

if (s2n_stuffer_write_bytes(&io_ctx->data_buffer, buf, len) < 0) {
/* This mock implementation doesn't handle partial writes for msg_iovlen > 1.
/* This mock implementation only handles partial writes for msg_iovlen == 1.
*
* This simplifies the implementation and importantly doesn't limit our test
* coverage because partial write are handled the same regardless of
* coverage because partial writes are handled the same regardless of
* msg_iovlen. */
POSIX_ENSURE(count == 0, S2N_ERR_SAFETY);
POSIX_ENSURE(msg->msg_iovlen == 1, S2N_ERR_SAFETY);

errno = EAGAIN;
return -1;
Expand All @@ -83,24 +83,22 @@ ssize_t s2n_test_ktls_sendmsg_stuffer_io(void *io_context, const struct msghdr *
/* In userspace TLS, s2n first reads the header to determine the length of next record
* and then reads the entire record into conn->in. In kTLS it is not possible to know
* the length of the next record. Instead the socket returns the minimum of
* bytes-requested and data-available; reading multiple consecutive records if they
* bytes-requested and data-available, reading multiple consecutive records if they
* are of the same type. */
ssize_t s2n_test_ktls_recvmsg_stuffer_io(void *io_context, struct msghdr *msg)
ssize_t s2n_test_ktls_recvmsg_io_stuffer(void *io_context, struct msghdr *msg)
{
POSIX_ENSURE_REF(io_context);
POSIX_ENSURE_REF(msg);
POSIX_ENSURE_REF(msg->msg_iov);

/* Assuming msg_control is uint8_t is a simplification and will not work when we
* attempt to test the production 2n_ktls_send implementation. However, setting/parsing
* attempt to test the production s2n_ktls_recv implementation. However, setting/parsing
* cmsg is critical code and will be added in a separate PR. */
uint8_t *record_type = (uint8_t *) msg->msg_control;
POSIX_ENSURE_REF(record_type);
struct s2n_test_ktls_io_stuffer *io_ctx = (struct s2n_test_ktls_io_stuffer *) io_context;
POSIX_ENSURE_REF(io_ctx);
io_ctx->send_recv_msg_invoked_count++;
/* s2n only receives using msg_iovlen of 1 */
POSIX_ENSURE_EQ(msg->msg_iovlen, 1);
io_ctx->recvmsg_invoked_count++;
uint8_t *buf = msg->msg_iov->iov_base;
POSIX_ENSURE_REF(buf);

Expand All @@ -110,51 +108,47 @@ ssize_t s2n_test_ktls_recvmsg_stuffer_io(void *io_context, struct msghdr *msg)
return -1;
}

ssize_t total_read = 0;
size_t amount_requested = msg->msg_iov->iov_len;
while (true) {
/* s2n only receives using msg_iovlen of 1 */
POSIX_ENSURE_EQ(msg->msg_iovlen, 1);
size_t size = msg->msg_iov->iov_len;

ssize_t bytes_read = 0;
while (bytes_read < size) {
/* read record_type and number of bytes available in the next record */
POSIX_GUARD(s2n_stuffer_read_uint8(&io_ctx->ancillary_buffer, record_type));
uint16_t n_avail = 0;
POSIX_GUARD(s2n_stuffer_read_uint16(&io_ctx->ancillary_buffer, &n_avail));
POSIX_ENSURE_LTE(n_avail, s2n_stuffer_data_available(&io_ctx->data_buffer));

/* read minimum of requested_len and bytes_available */
size_t n_read = MIN(amount_requested, n_avail);
size_t n_read = MIN(size - bytes_read, n_avail);
POSIX_ENSURE_GT(n_read, 0);
POSIX_GUARD(s2n_stuffer_read_bytes(&io_ctx->data_buffer, buf + total_read, n_read));
POSIX_GUARD(s2n_stuffer_read_bytes(&io_ctx->data_buffer, buf + bytes_read, n_read));

amount_requested -= n_read;
POSIX_ENSURE_GTE(amount_requested, 0);
total_read += n_read;
bytes_read += n_read;

/* handle partially read records */
ssize_t remaining_len = n_avail - n_read;
if (remaining_len) {
POSIX_GUARD_RESULT(s2n_test_ktls_update_prev_header_len(io_ctx, remaining_len));
}

/* if we have read the amount_requested then we are done */
if (amount_requested == 0) {
/* attempt to read multiple records (must be of the same type) */
uint8_t next_record_type = 0;
int ret = s2n_stuffer_peek_char(&io_ctx->ancillary_buffer, (char *) &next_record_type);
bool no_more_records = ret != S2N_SUCCESS;
if (no_more_records) {
break;
}
/* attempt to read multiple records (must be of the same type) */
if (amount_requested) {
uint8_t next_record_type = 0;
int ret = s2n_stuffer_peek_char(&io_ctx->ancillary_buffer, (char *) &next_record_type);
bool no_more_records = ret < 0;
bool next_record_different_type = next_record_type != *record_type;
if (no_more_records || next_record_different_type) {
break;
}
bool next_record_different_type = next_record_type != *record_type;
if (next_record_different_type) {
break;
}
}

return total_read;
return bytes_read;
}

S2N_RESULT s2n_test_init_ktls_stuffer_io(struct s2n_connection *server, struct s2n_connection *client,
struct s2n_test_ktls_io_pair *io_pair)
S2N_RESULT s2n_test_init_ktls_io_stuffer(struct s2n_connection *server, struct s2n_connection *client,
struct s2n_test_ktls_io_stuffer_pair *io_pair)
{
RESULT_ENSURE_REF(server);
RESULT_ENSURE_REF(client);
Expand All @@ -165,21 +159,21 @@ S2N_RESULT s2n_test_init_ktls_stuffer_io(struct s2n_connection *server, struct s
RESULT_GUARD_POSIX(s2n_stuffer_growable_alloc(&io_pair->client_in.data_buffer, 0));
RESULT_GUARD_POSIX(s2n_stuffer_growable_alloc(&io_pair->client_in.ancillary_buffer, 0));

RESULT_GUARD(s2n_ktls_set_sendmsg_cb(server, s2n_test_ktls_sendmsg_stuffer_io, &io_pair->client_in));
RESULT_GUARD(s2n_ktls_set_recvmsg_cb(server, s2n_test_ktls_recvmsg_stuffer_io, &io_pair->server_in));
RESULT_GUARD(s2n_ktls_set_sendmsg_cb(client, s2n_test_ktls_sendmsg_stuffer_io, &io_pair->server_in));
RESULT_GUARD(s2n_ktls_set_recvmsg_cb(client, s2n_test_ktls_recvmsg_stuffer_io, &io_pair->client_in));
RESULT_GUARD(s2n_ktls_set_sendmsg_cb(server, s2n_test_ktls_sendmsg_io_stuffer, &io_pair->client_in));
RESULT_GUARD(s2n_ktls_set_recvmsg_cb(server, s2n_test_ktls_recvmsg_io_stuffer, &io_pair->server_in));
RESULT_GUARD(s2n_ktls_set_sendmsg_cb(client, s2n_test_ktls_sendmsg_io_stuffer, &io_pair->server_in));
RESULT_GUARD(s2n_ktls_set_recvmsg_cb(client, s2n_test_ktls_recvmsg_io_stuffer, &io_pair->client_in));

return S2N_RESULT_OK;
}

S2N_CLEANUP_RESULT s2n_ktls_io_pair_free(struct s2n_test_ktls_io_pair *ctx)
S2N_CLEANUP_RESULT s2n_ktls_io_stuffer_pair_free(struct s2n_test_ktls_io_stuffer_pair *pair)
{
RESULT_ENSURE_REF(ctx);
RESULT_GUARD_POSIX(s2n_stuffer_free(&ctx->client_in.data_buffer));
RESULT_GUARD_POSIX(s2n_stuffer_free(&ctx->client_in.ancillary_buffer));
RESULT_GUARD_POSIX(s2n_stuffer_free(&ctx->server_in.data_buffer));
RESULT_GUARD_POSIX(s2n_stuffer_free(&ctx->server_in.ancillary_buffer));
RESULT_ENSURE_REF(pair);
RESULT_GUARD_POSIX(s2n_stuffer_free(&pair->client_in.data_buffer));
RESULT_GUARD_POSIX(s2n_stuffer_free(&pair->client_in.ancillary_buffer));
RESULT_GUARD_POSIX(s2n_stuffer_free(&pair->server_in.data_buffer));
RESULT_GUARD_POSIX(s2n_stuffer_free(&pair->server_in.ancillary_buffer));

return S2N_RESULT_OK;
}
15 changes: 8 additions & 7 deletions tests/testlib/s2n_ktls_test_utils.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,15 +52,16 @@
struct s2n_test_ktls_io_stuffer {
struct s2n_stuffer ancillary_buffer;
struct s2n_stuffer data_buffer;
size_t send_recv_msg_invoked_count;
size_t sendmsg_invoked_count;
size_t recvmsg_invoked_count;
};
struct s2n_test_ktls_io_pair {
struct s2n_test_ktls_io_stuffer_pair {
struct s2n_test_ktls_io_stuffer client_in;
struct s2n_test_ktls_io_stuffer server_in;
};
ssize_t s2n_test_ktls_sendmsg_stuffer_io(void *io_context, const struct msghdr *msg);
ssize_t s2n_test_ktls_recvmsg_stuffer_io(void *io_context, struct msghdr *msg);
ssize_t s2n_test_ktls_sendmsg_io_stuffer(void *io_context, const struct msghdr *msg);
ssize_t s2n_test_ktls_recvmsg_io_stuffer(void *io_context, struct msghdr *msg);

S2N_RESULT s2n_test_init_ktls_stuffer_io(struct s2n_connection *server, struct s2n_connection *client,
struct s2n_test_ktls_io_pair *io_pair);
S2N_CLEANUP_RESULT s2n_ktls_io_pair_free(struct s2n_test_ktls_io_pair *ctx);
S2N_RESULT s2n_test_init_ktls_io_stuffer(struct s2n_connection *server, struct s2n_connection *client,
struct s2n_test_ktls_io_stuffer_pair *io_pair);
S2N_CLEANUP_RESULT s2n_ktls_io_stuffer_pair_free(struct s2n_test_ktls_io_stuffer_pair *pair);
Loading

0 comments on commit e76e610

Please sign in to comment.