Convert asynciotest for the new test framework (c7910796) · Commits · CYBER - Cyber Security / TS 103 523 MSP / ETS / ETS OpenSSL

test/asynciotest.c

+102 −115

Original line number	Diff line number	Diff line
		@@ -16,10 +16,15 @@
		#include "../ssl/packet_locl.h"

		#include "ssltestlib.h"
		#include "testutil.h"
		#include "test_main_custom.h"

		/* Should we fragment records or not? 0 = no, !0 = yes*/
		static int fragment = 0;

		static char *cert = NULL;
		static char *privkey = NULL;

		static int async_new(BIO *bi);
		static int async_free(BIO *a);
		static int async_read(BIO b, char out, int outl);
		@@ -139,7 +144,7 @@ static int async_write(BIO bio, const char in, int inl)
		PACKET pkt;

		if (!PACKET_buf_init(&pkt, (const unsigned char *)in, inl))
		abort();
		return -1;

		while (PACKET_remaining(&pkt) > 0) {
		PACKET payload, wholebody;
		@@ -150,7 +155,7 @@ static int async_write(BIO bio, const char in, int inl)
		\|\| !PACKET_get_1(&pkt, &versionhi)
		\|\| !PACKET_get_1(&pkt, &versionlo)
		\|\| !PACKET_get_length_prefixed_2(&pkt, &payload))
		abort();
		return -1;

		/* Pretend we wrote out the record header */
		written += SSL3_RT_HEADER_LENGTH;
		@@ -158,13 +163,13 @@ static int async_write(BIO bio, const char in, int inl)
		wholebody = payload;
		if (contenttype == SSL3_RT_HANDSHAKE
		&& !PACKET_get_1(&wholebody, &msgtype))
		abort();
		return -1;

		if (msgtype == SSL3_MT_SERVER_HELLO
		&& (!PACKET_forward(&wholebody,
		SSL3_HM_HEADER_LENGTH - 1)
		\|\| !PACKET_get_net_2(&wholebody, &negversion)))
		abort();
		return -1;

		while (PACKET_get_1(&payload, &data)) {
		/* Create a new one byte long record for each byte in the
		@@ -185,7 +190,7 @@ static int async_write(BIO bio, const char in, int inl)
		smallrec[DATAPOS] = data;
		ret = BIO_write(next, smallrec, MIN_RECORD_LEN);
		if (ret <= 0)
		abort();
		return -1;
		written++;
		}
		/*
		@@ -252,29 +257,19 @@ static int async_puts(BIO bio, const char str)

		#define MAX_ATTEMPTS 100

		int main(int argc, char *argv[])
		static int test_asyncio(int test)
		{
		SSL_CTX serverctx = NULL, clientctx = NULL;
		SSL serverssl = NULL, clientssl = NULL;
		BIO s_to_c_fbio = NULL, c_to_s_fbio = NULL;
		int test, err = 1, ret;
		int testresult = 0, ret;
		size_t i, j;
		const char testdata[] = "Test data";
		char buf[sizeof(testdata)];

		CRYPTO_set_mem_debug(1);
		CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);

		if (argc != 3) {
		printf("Invalid argument count\n");
		if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
		&serverctx, &clientctx, cert, privkey)))
		goto end;
		}

		if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
		&serverctx, &clientctx, argv[1], argv[2])) {
		printf("Failed to create SSL_CTX pair\n");
		goto end;
		}

		/*
		* We do 2 test runs. The first time around we just do a normal handshake
		@@ -282,31 +277,25 @@ int main(int argc, char *argv[])
		* all records so that the content is only one byte length (up until the
		* CCS)
		*/
		for (test = 1; test < 3; test++) {
		if (test == 2)
		if (test == 1)
		fragment = 1;


		s_to_c_fbio = BIO_new(bio_f_async_filter());
		c_to_s_fbio = BIO_new(bio_f_async_filter());
		if (s_to_c_fbio == NULL \|\| c_to_s_fbio == NULL) {
		printf("Failed to create filter BIOs\n");
		if (!TEST_ptr(s_to_c_fbio)
		\|\| !TEST_ptr(c_to_s_fbio)) {
		BIO_free(s_to_c_fbio);
		BIO_free(c_to_s_fbio);
		goto end;
		}

		/* BIOs get freed on error */
		if (!create_ssl_objects(serverctx, clientctx, &serverssl, &clientssl,
		s_to_c_fbio, c_to_s_fbio)) {
		printf("Test %d failed: Create SSL objects failed\n", test);
		goto end;
		}

		if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
		printf("Test %d failed: Create SSL connection failed\n", test);
		if (!TEST_true(create_ssl_objects(serverctx, clientctx, &serverssl,
		&clientssl, s_to_c_fbio, c_to_s_fbio))
		\|\| !TEST_true(create_ssl_connection(serverssl, clientssl,
		SSL_ERROR_NONE)))
		goto end;
		}

		/*
		* Send and receive some test data. Do the whole thing twice to ensure
		@@ -328,70 +317,68 @@ int main(int argc, char *argv[])
		} else {
		int ssl_error = SSL_get_error(clientssl, ret);

		if (ssl_error == SSL_ERROR_SYSCALL \|\|
		ssl_error == SSL_ERROR_SSL) {
		printf("Test %d failed: Failed to write app data\n", test);
		err = -1;
		if (!TEST_false(ssl_error == SSL_ERROR_SYSCALL \|\|
		ssl_error == SSL_ERROR_SSL))
		goto end;
		}
		}
		}
		if (len != sizeof(testdata)) {
		err = -1;
		printf("Test %d failed: Failed to write all app data\n", test);
		if (!TEST_size_t_eq(len, sizeof(testdata)))
		goto end;
		}

		/*
		* Now read the test data. It may take more attemps here because
		* it could fail once for each byte read, including all overhead
		* bytes from the record header/padding etc.
		*/
		for (ret = -1, i = 0, len = 0; len != sizeof(testdata) &&
		i < MAX_ATTEMPTS; i++)
		{
		i < MAX_ATTEMPTS; i++) {
		ret = SSL_read(serverssl, buf + len, sizeof(buf) - len);
		if (ret > 0) {
		len += ret;
		} else {
		int ssl_error = SSL_get_error(serverssl, ret);

		if (ssl_error == SSL_ERROR_SYSCALL \|\|
		ssl_error == SSL_ERROR_SSL) {
		printf("Test %d failed: Failed to read app data\n", test);
		err = -1;
		if (!TEST_false(ssl_error == SSL_ERROR_SYSCALL \|\|
		ssl_error == SSL_ERROR_SSL))
		goto end;
		}
		}
		}
		if (len != sizeof(testdata)
		\|\| memcmp(buf, testdata, sizeof(testdata)) != 0) {
		err = -1;
		printf("Test %d failed: Unexpected app data received\n", test);
		if (!TEST_mem_eq(testdata, sizeof(testdata), buf, len))
		goto end;
		}
		}

		/* Also frees the BIOs */
		SSL_free(clientssl);
		SSL_free(serverssl);
		clientssl = serverssl = NULL;
		}

		printf("Test success\n");
		testresult = 1;

		err = 0;
		end:
		if (err)
		ERR_print_errors_fp(stderr);

		SSL_free(clientssl);
		SSL_free(serverssl);
		SSL_CTX_free(clientctx);
		SSL_CTX_free(serverctx);

		# ifndef OPENSSL_NO_CRYPTO_MDEBUG
		CRYPTO_mem_leaks_fp(stderr);
		# endif
		return testresult;
		}

		int test_main(int argc, char *argv[])
		{
		int testresult = 0;

		if (!TEST_int_eq(argc, 3))
		goto end;

		cert = argv[1];
		privkey = argv[2];

		ADD_ALL_TESTS(test_asyncio, 2);

		testresult = run_tests(argv[0]);

		end:
		BIO_meth_free(methods_async);

		return err;
		return testresult;
		}

test/build.info

+1 −1

Original line number	Diff line number	Diff line
		@@ -264,7 +264,7 @@ IF[{- !$disabled{tests} -}]
		INCLUDE[x509aux]=../include
		DEPEND[x509aux]=../libcrypto

		SOURCE[asynciotest]=asynciotest.c ssltestlib.c
		SOURCE[asynciotest]=asynciotest.c ssltestlib.c testutil.c test_main_custom.c
		INCLUDE[asynciotest]=../include
		DEPEND[asynciotest]=../libcrypto ../libssl