[thirdparty/openssl.git] / test / packettest.c

/*
 * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include "internal/packet.h"
#include "testutil.h"

#define BUF_LEN 255

static unsigned char smbuf[BUF_LEN];

static int test_PACKET_remaining(void)
{
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf)))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
            || !TEST_true(PACKET_forward(&pkt, 1))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), 0))
        return 0;

    return 1;
}

static int test_PACKET_end(void)
{
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf)))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
            || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
            || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
            || !TEST_true(PACKET_forward(&pkt, 1))
            || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN))
        return 0;

    return 1;
}

static int test_PACKET_get_1(void)
{
    unsigned int i = 0;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_1(&pkt, &i))
            || !TEST_uint_eq(i, 0x02)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
            || !TEST_true(PACKET_get_1(&pkt, &i))
            || !TEST_uint_eq(i, 0xfe)
            || !TEST_false(PACKET_get_1(&pkt, &i)))
        return 0;

    return 1;
}

static int test_PACKET_get_4(void)
{
    unsigned long i = 0;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_4(&pkt, &i))
            || !TEST_ulong_eq(i, 0x08060402UL)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
            || !TEST_true(PACKET_get_4(&pkt, &i))
            || !TEST_ulong_eq(i, 0xfefcfaf8UL)
            || !TEST_false(PACKET_get_4(&pkt, &i)))
        return 0;

    return 1;
}

static int test_PACKET_get_net_2(void)
{
    unsigned int i = 0;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_net_2(&pkt, &i))
            || !TEST_uint_eq(i, 0x0204)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
            || !TEST_true(PACKET_get_net_2(&pkt, &i))
            || !TEST_uint_eq(i, 0xfcfe)
            || !TEST_false(PACKET_get_net_2(&pkt, &i)))
        return 0;

    return 1;
}

static int test_PACKET_get_net_3(void)
{
    unsigned long i = 0;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_net_3(&pkt, &i))
            || !TEST_ulong_eq(i, 0x020406UL)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
            || !TEST_true(PACKET_get_net_3(&pkt, &i))
            || !TEST_ulong_eq(i, 0xfafcfeUL)
            || !TEST_false(PACKET_get_net_3(&pkt, &i)))
        return 0;

    return 1;
}

static int test_PACKET_get_net_4(void)
{
    unsigned long i = 0;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_net_4(&pkt, &i))
            || !TEST_ulong_eq(i, 0x02040608UL)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
            || !TEST_true(PACKET_get_net_4(&pkt, &i))
            || !TEST_ulong_eq(i, 0xf8fafcfeUL)
            || !TEST_false(PACKET_get_net_4(&pkt, &i)))
        return 0;

    return 1;
}

static int test_PACKET_get_sub_packet(void)
{
    PACKET pkt, subpkt;
    unsigned long i = 0;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
            || !TEST_true(PACKET_get_net_4(&subpkt, &i))
            || !TEST_ulong_eq(i, 0x02040608UL)
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
            || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
            || !TEST_true(PACKET_get_net_4(&subpkt, &i))
            || !TEST_ulong_eq(i, 0xf8fafcfeUL)
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
            || !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
        return 0;

    return 1;
}

static int test_PACKET_get_bytes(void)
{
    const unsigned char *bytes = NULL;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
            || !TEST_uchar_eq(bytes[0], 2)
            || !TEST_uchar_eq(bytes[1], 4)
            || !TEST_uchar_eq(bytes[2], 6)
            || !TEST_uchar_eq(bytes[3], 8)
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
            || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
            || !TEST_uchar_eq(bytes[0], 0xf8)
            || !TEST_uchar_eq(bytes[1], 0xfa)
            || !TEST_uchar_eq(bytes[2], 0xfc)
            || !TEST_uchar_eq(bytes[3], 0xfe)
            || !TEST_false(PACKET_remaining(&pkt)))
        return 0;

    return 1;
}

static int test_PACKET_copy_bytes(void)
{
    unsigned char bytes[4];
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
            || !TEST_char_eq(bytes[0], 2)
            || !TEST_char_eq(bytes[1], 4)
            || !TEST_char_eq(bytes[2], 6)
            || !TEST_char_eq(bytes[3], 8)
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
            || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
            || !TEST_uchar_eq(bytes[0], 0xf8)
            || !TEST_uchar_eq(bytes[1], 0xfa)
            || !TEST_uchar_eq(bytes[2], 0xfc)
            || !TEST_uchar_eq(bytes[3], 0xfe)
            || !TEST_false(PACKET_remaining(&pkt)))
        return 0;

    return 1;
}

static int test_PACKET_copy_all(void)
{
    unsigned char tmp[BUF_LEN];
    PACKET pkt;
    size_t len;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
            || !TEST_size_t_eq(len, BUF_LEN)
            || !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
            || !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
        return 0;

    return 1;
}

static int test_PACKET_memdup(void)
{
    unsigned char *data = NULL;
    size_t len;
    PACKET pkt;
    int result = 0;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_memdup(&pkt, &data, &len))
            || !TEST_size_t_eq(len, BUF_LEN)
            || !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
            || !TEST_true(PACKET_forward(&pkt, 10))
            || !TEST_true(PACKET_memdup(&pkt, &data, &len))
            || !TEST_size_t_eq(len, BUF_LEN - 10)
            || !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
        goto end;
    result = 1;
end:
    OPENSSL_free(data);
    return result;
}

static int test_PACKET_strndup(void)
{
    char buf1[10], buf2[10];
    char *data = NULL;
    PACKET pkt;
    int result = 0;

    memset(buf1, 'x', 10);
    memset(buf2, 'y', 10);
    buf2[5] = '\0';

    if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
            || !TEST_true(PACKET_strndup(&pkt, &data))
            || !TEST_size_t_eq(strlen(data), 10)
            || !TEST_strn_eq(data, buf1, 10)
            || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
            || !TEST_true(PACKET_strndup(&pkt, &data))
            || !TEST_size_t_eq(strlen(data), 5)
            || !TEST_str_eq(data, buf2))
        goto end;

    result = 1;
end:
    OPENSSL_free(data);
    return result;
}

static int test_PACKET_contains_zero_byte(void)
{
    char buf1[10], buf2[10];
    PACKET pkt;

    memset(buf1, 'x', 10);
    memset(buf2, 'y', 10);
    buf2[5] = '\0';

    if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
            || !TEST_false(PACKET_contains_zero_byte(&pkt))
            || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
            || !TEST_true(PACKET_contains_zero_byte(&pkt)))
        return 0;

    return 1;
}

static int test_PACKET_forward(void)
{
    const unsigned char *byte = NULL;
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_forward(&pkt, 1))
            || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
            || !TEST_uchar_eq(byte[0], 4)
            || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
            || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
            || !TEST_uchar_eq(byte[0], 0xfe))
        return 0;

    return 1;
}

static int test_PACKET_buf_init(void)
{
    unsigned char buf1[BUF_LEN];
    PACKET pkt;

    /* Also tests PACKET_remaining() */
    if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
            || !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
            || !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
        return 0;

    return 1;
}

static int test_PACKET_null_init(void)
{
    PACKET pkt;

    PACKET_null_init(&pkt);
    if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
            || !TEST_false(PACKET_forward(&pkt, 1)))
        return 0;

    return 1;
}

static int test_PACKET_equal(void)
{
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
            || !TEST_true(PACKET_equal(&pkt, smbuf, 4))
            || !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
            || !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
            || !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
            || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
            || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
            || !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
        return 0;

    return 1;
}

static int test_PACKET_get_length_prefixed_1(void)
{
    unsigned char buf1[BUF_LEN];
    const size_t len = 16;
    unsigned int i;
    PACKET pkt, short_pkt, subpkt;

    memset(&subpkt, 0, sizeof(subpkt));
    buf1[0] = (unsigned char)len;
    for (i = 1; i < BUF_LEN; i++)
        buf1[i] = (i * 2) & 0xff;

    if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
            || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
            || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
            || !TEST_true(PACKET_get_net_2(&subpkt, &i))
            || !TEST_uint_eq(i, 0x0204)
            || !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
        return 0;

    return 1;
}

static int test_PACKET_get_length_prefixed_2(void)
{
    unsigned char buf1[1024];
    const size_t len = 516;  /* 0x0204 */
    unsigned int i;
    PACKET pkt, short_pkt, subpkt;

    memset(&subpkt, 0, sizeof(subpkt));
    for (i = 1; i <= 1024; i++)
        buf1[i - 1] = (i * 2) & 0xff;

    if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
            || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
            || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
            || !TEST_true(PACKET_get_net_2(&subpkt, &i))
            || !TEST_uint_eq(i, 0x0608)
            || !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
        return 0;

    return 1;
}

static int test_PACKET_get_length_prefixed_3(void)
{
    unsigned char buf1[1024];
    const size_t len = 516;  /* 0x000204 */
    unsigned int i;
    PACKET pkt, short_pkt, subpkt;

    memset(&subpkt, 0, sizeof(subpkt));
    for (i = 0; i < 1024; i++)
        buf1[i] = (i * 2) & 0xff;

    if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
            || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
            || !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
            || !TEST_true(PACKET_get_net_2(&subpkt, &i))
            || !TEST_uint_eq(i, 0x0608)
            || !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
        return 0;

    return 1;
}

static int test_PACKET_as_length_prefixed_1(void)
{
    unsigned char buf1[BUF_LEN];
    const size_t len = 16;
    unsigned int i;
    PACKET pkt, exact_pkt, subpkt;

    memset(&subpkt, 0, sizeof(subpkt));
    buf1[0] = (unsigned char)len;
    for (i = 1; i < BUF_LEN; i++)
        buf1[i] = (i * 2) & 0xff;

    if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
            || !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
            || !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
            || !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
        return 0;

    return 1;
}

static int test_PACKET_as_length_prefixed_2(void)
{
    unsigned char buf[1024];
    const size_t len = 516;  /* 0x0204 */
    unsigned int i;
    PACKET pkt, exact_pkt, subpkt;

    memset(&subpkt, 0, sizeof(subpkt));
    for (i = 1; i <= 1024; i++)
        buf[i-1] = (i * 2) & 0xff;

    if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
            || !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
            || !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
            || !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
            || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
            || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
        return 0;

    return 1;
}

int setup_tests(void)
{
    unsigned int i;

    for (i = 1; i <= BUF_LEN; i++)
        smbuf[i - 1] = (i * 2) & 0xff;

    ADD_TEST(test_PACKET_buf_init);
    ADD_TEST(test_PACKET_null_init);
    ADD_TEST(test_PACKET_remaining);
    ADD_TEST(test_PACKET_end);
    ADD_TEST(test_PACKET_equal);
    ADD_TEST(test_PACKET_get_1);
    ADD_TEST(test_PACKET_get_4);
    ADD_TEST(test_PACKET_get_net_2);
    ADD_TEST(test_PACKET_get_net_3);
    ADD_TEST(test_PACKET_get_net_4);
    ADD_TEST(test_PACKET_get_sub_packet);
    ADD_TEST(test_PACKET_get_bytes);
    ADD_TEST(test_PACKET_copy_bytes);
    ADD_TEST(test_PACKET_copy_all);
    ADD_TEST(test_PACKET_memdup);
    ADD_TEST(test_PACKET_strndup);
    ADD_TEST(test_PACKET_contains_zero_byte);
    ADD_TEST(test_PACKET_forward);
    ADD_TEST(test_PACKET_get_length_prefixed_1);
    ADD_TEST(test_PACKET_get_length_prefixed_2);
    ADD_TEST(test_PACKET_get_length_prefixed_3);
    ADD_TEST(test_PACKET_as_length_prefixed_1);
    ADD_TEST(test_PACKET_as_length_prefixed_2);
    return 1;
}
Commit	Line	Data
6fc2ef20	1	/*
b0edda11	2	* Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
6fc2ef20	3	*
909f1a2e	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
440e5d80 RS	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
6fc2ef20 MC	8	*/
6fc2ef20 MC	9
0d345f0e	10	#include "internal/packet.h"
adcd8e37	11	#include "testutil.h"
6fc2ef20 MC	12
	13	#define BUF_LEN 255
	14
adcd8e37 RS	15	static unsigned char smbuf[BUF_LEN];
adcd8e37 RS	16
31a80694	17	static int test_PACKET_remaining(void)
6fc2ef20	18	{
4bd16463 EK	19	PACKET pkt;
4bd16463 EK	20
23fa9789	21	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf)))
adcd8e37 RS	22	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
	23	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
	24	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
	25	\|\| !TEST_true(PACKET_forward(&pkt, 1))
23fa9789	26	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), 0))
6fc2ef20	27	return 0;
6fc2ef20 MC	28
	29	return 1;
	30	}
	31
31a80694	32	static int test_PACKET_end(void)
06217867 EK	33	{
	34	PACKET pkt;
	35
23fa9789	36	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf)))
adcd8e37	37	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
23fa9789	38	\|\| !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
adcd8e37 RS	39	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
	40	\|\| !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
	41	\|\| !TEST_true(PACKET_forward(&pkt, 1))
23fa9789	42	\|\| !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN))
06217867	43	return 0;
06217867 EK	44
	45	return 1;
	46	}
	47
31a80694	48	static int test_PACKET_get_1(void)
6fc2ef20	49	{
fce1b86f	50	unsigned int i = 0;
4bd16463	51	PACKET pkt;
6fc2ef20	52
adcd8e37 RS	53	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	54	\|\| !TEST_true(PACKET_get_1(&pkt, &i))
	55	\|\| !TEST_uint_eq(i, 0x02)
	56	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
	57	\|\| !TEST_true(PACKET_get_1(&pkt, &i))
	58	\|\| !TEST_uint_eq(i, 0xfe)
	59	\|\| !TEST_false(PACKET_get_1(&pkt, &i)))
6fc2ef20	60	return 0;
6fc2ef20 MC	61
	62	return 1;
	63	}
	64
31a80694	65	static int test_PACKET_get_4(void)
6fc2ef20	66	{
fce1b86f	67	unsigned long i = 0;
4bd16463	68	PACKET pkt;
6fc2ef20	69
adcd8e37 RS	70	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	71	\|\| !TEST_true(PACKET_get_4(&pkt, &i))
	72	\|\| !TEST_ulong_eq(i, 0x08060402UL)
	73	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
	74	\|\| !TEST_true(PACKET_get_4(&pkt, &i))
	75	\|\| !TEST_ulong_eq(i, 0xfefcfaf8UL)
	76	\|\| !TEST_false(PACKET_get_4(&pkt, &i)))
6fc2ef20	77	return 0;
6fc2ef20 MC	78
	79	return 1;
	80	}
	81
31a80694	82	static int test_PACKET_get_net_2(void)
6fc2ef20	83	{
fce1b86f	84	unsigned int i = 0;
4bd16463	85	PACKET pkt;
6fc2ef20	86
adcd8e37 RS	87	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	88	\|\| !TEST_true(PACKET_get_net_2(&pkt, &i))
	89	\|\| !TEST_uint_eq(i, 0x0204)
	90	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
	91	\|\| !TEST_true(PACKET_get_net_2(&pkt, &i))
	92	\|\| !TEST_uint_eq(i, 0xfcfe)
	93	\|\| !TEST_false(PACKET_get_net_2(&pkt, &i)))
6fc2ef20	94	return 0;
6fc2ef20 MC	95
	96	return 1;
	97	}
	98
31a80694	99	static int test_PACKET_get_net_3(void)
6fc2ef20	100	{
fce1b86f	101	unsigned long i = 0;
4bd16463	102	PACKET pkt;
6fc2ef20	103
adcd8e37 RS	104	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	105	\|\| !TEST_true(PACKET_get_net_3(&pkt, &i))
	106	\|\| !TEST_ulong_eq(i, 0x020406UL)
	107	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
	108	\|\| !TEST_true(PACKET_get_net_3(&pkt, &i))
	109	\|\| !TEST_ulong_eq(i, 0xfafcfeUL)
	110	\|\| !TEST_false(PACKET_get_net_3(&pkt, &i)))
6fc2ef20	111	return 0;
6fc2ef20 MC	112
	113	return 1;
	114	}
	115
31a80694	116	static int test_PACKET_get_net_4(void)
6fc2ef20	117	{
fce1b86f	118	unsigned long i = 0;
4bd16463	119	PACKET pkt;
6fc2ef20	120
adcd8e37 RS	121	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	122	\|\| !TEST_true(PACKET_get_net_4(&pkt, &i))
	123	\|\| !TEST_ulong_eq(i, 0x02040608UL)
	124	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
	125	\|\| !TEST_true(PACKET_get_net_4(&pkt, &i))
	126	\|\| !TEST_ulong_eq(i, 0xf8fafcfeUL)
	127	\|\| !TEST_false(PACKET_get_net_4(&pkt, &i)))
6fc2ef20	128	return 0;
6fc2ef20 MC	129
	130	return 1;
	131	}
	132
31a80694	133	static int test_PACKET_get_sub_packet(void)
6fc2ef20	134	{
4bd16463	135	PACKET pkt, subpkt;
fce1b86f	136	unsigned long i = 0;
6fc2ef20	137
adcd8e37 RS	138	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	139	\|\| !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
	140	\|\| !TEST_true(PACKET_get_net_4(&subpkt, &i))
	141	\|\| !TEST_ulong_eq(i, 0x02040608UL)
	142	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
	143	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
	144	\|\| !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
	145	\|\| !TEST_true(PACKET_get_net_4(&subpkt, &i))
	146	\|\| !TEST_ulong_eq(i, 0xf8fafcfeUL)
	147	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
	148	\|\| !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
6fc2ef20	149	return 0;
6fc2ef20 MC	150
	151	return 1;
	152	}
	153
31a80694	154	static int test_PACKET_get_bytes(void)
6fc2ef20	155	{
fce1b86f	156	const unsigned char *bytes = NULL;
4bd16463	157	PACKET pkt;
6fc2ef20	158
adcd8e37 RS	159	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	160	\|\| !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
	161	\|\| !TEST_uchar_eq(bytes[0], 2)
	162	\|\| !TEST_uchar_eq(bytes[1], 4)
	163	\|\| !TEST_uchar_eq(bytes[2], 6)
	164	\|\| !TEST_uchar_eq(bytes[3], 8)
	165	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
	166	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
	167	\|\| !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
	168	\|\| !TEST_uchar_eq(bytes[0], 0xf8)
	169	\|\| !TEST_uchar_eq(bytes[1], 0xfa)
	170	\|\| !TEST_uchar_eq(bytes[2], 0xfc)
	171	\|\| !TEST_uchar_eq(bytes[3], 0xfe)
	172	\|\| !TEST_false(PACKET_remaining(&pkt)))
6fc2ef20	173	return 0;
6fc2ef20 MC	174
	175	return 1;
	176	}
	177
31a80694	178	static int test_PACKET_copy_bytes(void)
6fc2ef20 MC	179	{
6fc2ef20 MC	180	unsigned char bytes[4];
4bd16463	181	PACKET pkt;
6fc2ef20	182
adcd8e37 RS	183	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	184	\|\| !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
	185	\|\| !TEST_char_eq(bytes[0], 2)
	186	\|\| !TEST_char_eq(bytes[1], 4)
	187	\|\| !TEST_char_eq(bytes[2], 6)
	188	\|\| !TEST_char_eq(bytes[3], 8)
	189	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
	190	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
	191	\|\| !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
	192	\|\| !TEST_uchar_eq(bytes[0], 0xf8)
	193	\|\| !TEST_uchar_eq(bytes[1], 0xfa)
	194	\|\| !TEST_uchar_eq(bytes[2], 0xfc)
	195	\|\| !TEST_uchar_eq(bytes[3], 0xfe)
	196	\|\| !TEST_false(PACKET_remaining(&pkt)))
6fc2ef20	197	return 0;
6fc2ef20 MC	198
	199	return 1;
	200	}
	201
31a80694	202	static int test_PACKET_copy_all(void)
67202973	203	{
2d284623	204	unsigned char tmp[BUF_LEN];
67202973 EK	205	PACKET pkt;
	206	size_t len;
	207
adcd8e37 RS	208	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	209	\|\| !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
	210	\|\| !TEST_size_t_eq(len, BUF_LEN)
	211	\|\| !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
	212	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
	213	\|\| !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
67202973	214	return 0;
67202973 EK	215
	216	return 1;
	217	}
	218
31a80694	219	static int test_PACKET_memdup(void)
6d41fc80 EK	220	{
	221	unsigned char *data = NULL;
	222	size_t len;
4bd16463	223	PACKET pkt;
adcd8e37 RS	224	int result = 0;
	225
	226	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	227	\|\| !TEST_true(PACKET_memdup(&pkt, &data, &len))
	228	\|\| !TEST_size_t_eq(len, BUF_LEN)
	229	\|\| !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
	230	\|\| !TEST_true(PACKET_forward(&pkt, 10))
	231	\|\| !TEST_true(PACKET_memdup(&pkt, &data, &len))
	232	\|\| !TEST_size_t_eq(len, BUF_LEN - 10)
	233	\|\| !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
	234	goto end;
	235	result = 1;
	236	end:
6d41fc80	237	OPENSSL_free(data);
adcd8e37	238	return result;
6d41fc80 EK	239	}
6d41fc80 EK	240
31a80694	241	static int test_PACKET_strndup(void)
6d41fc80	242	{
adcd8e37	243	char buf1[10], buf2[10];
2dcac136 DSH	244	char *data = NULL;
2dcac136 DSH	245	PACKET pkt;
adcd8e37	246	int result = 0;
2dcac136	247
adcd8e37	248	memset(buf1, 'x', 10);
6d41fc80 EK	249	memset(buf2, 'y', 10);
6d41fc80 EK	250	buf2[5] = '\0';
6d41fc80	251
adcd8e37 RS	252	if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
	253	\|\| !TEST_true(PACKET_strndup(&pkt, &data))
	254	\|\| !TEST_size_t_eq(strlen(data), 10)
	255	\|\| !TEST_strn_eq(data, buf1, 10)
	256	\|\| !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
	257	\|\| !TEST_true(PACKET_strndup(&pkt, &data))
	258	\|\| !TEST_size_t_eq(strlen(data), 5)
	259	\|\| !TEST_str_eq(data, buf2))
	260	goto end;
	261
	262	result = 1;
	263	end:
6d41fc80	264	OPENSSL_free(data);
adcd8e37	265	return result;
6d41fc80 EK	266	}
6d41fc80 EK	267
31a80694	268	static int test_PACKET_contains_zero_byte(void)
06217867	269	{
adcd8e37	270	char buf1[10], buf2[10];
06217867 EK	271	PACKET pkt;
06217867 EK	272
adcd8e37	273	memset(buf1, 'x', 10);
06217867 EK	274	memset(buf2, 'y', 10);
	275	buf2[5] = '\0';
	276
adcd8e37 RS	277	if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
	278	\|\| !TEST_false(PACKET_contains_zero_byte(&pkt))
	279	\|\| !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
	280	\|\| !TEST_true(PACKET_contains_zero_byte(&pkt)))
06217867	281	return 0;
06217867 EK	282
	283	return 1;
	284	}
	285
31a80694	286	static int test_PACKET_forward(void)
6fc2ef20	287	{
fce1b86f	288	const unsigned char *byte = NULL;
4bd16463	289	PACKET pkt;
6fc2ef20	290
adcd8e37 RS	291	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	292	\|\| !TEST_true(PACKET_forward(&pkt, 1))
	293	\|\| !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
	294	\|\| !TEST_uchar_eq(byte[0], 4)
	295	\|\| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
	296	\|\| !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
	297	\|\| !TEST_uchar_eq(byte[0], 0xfe))
6fc2ef20	298	return 0;
6fc2ef20 MC	299
	300	return 1;
	301	}
	302
31a80694	303	static int test_PACKET_buf_init(void)
6fc2ef20	304	{
adcd8e37	305	unsigned char buf1[BUF_LEN];
6fc2ef20 MC	306	PACKET pkt;
6fc2ef20 MC	307
67202973	308	/* Also tests PACKET_remaining() */
adcd8e37 RS	309	if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
	310	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
	311	\|\| !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
	312	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
	313	\|\| !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
6fc2ef20	314	return 0;
6fc2ef20 MC	315
	316	return 1;
	317	}
	318
31a80694	319	static int test_PACKET_null_init(void)
b3e2272c EK	320	{
	321	PACKET pkt;
	322
	323	PACKET_null_init(&pkt);
adcd8e37 RS	324	if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
adcd8e37 RS	325	\|\| !TEST_false(PACKET_forward(&pkt, 1)))
b3e2272c	326	return 0;
b3e2272c EK	327
	328	return 1;
	329	}
	330
31a80694	331	static int test_PACKET_equal(void)
31011544 EK	332	{
	333	PACKET pkt;
	334
adcd8e37 RS	335	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
	336	\|\| !TEST_true(PACKET_equal(&pkt, smbuf, 4))
	337	\|\| !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
	338	\|\| !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
	339	\|\| !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
	340	\|\| !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
	341	\|\| !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
	342	\|\| !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
31011544	343	return 0;
31011544 EK	344
	345	return 1;
	346	}
	347
31a80694	348	static int test_PACKET_get_length_prefixed_1(void)
ec30e856	349	{
adcd8e37	350	unsigned char buf1[BUF_LEN];
ec30e856 EK	351	const size_t len = 16;
ec30e856 EK	352	unsigned int i;
72962d02	353	PACKET pkt, short_pkt, subpkt;
adcd8e37	354
72962d02	355	memset(&subpkt, 0, sizeof(subpkt));
3a63c0ed	356	buf1[0] = (unsigned char)len;
adcd8e37 RS	357	for (i = 1; i < BUF_LEN; i++)
	358	buf1[i] = (i * 2) & 0xff;
	359
	360	if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
	361	\|\| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
	362	\|\| !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
	363	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
	364	\|\| !TEST_true(PACKET_get_net_2(&subpkt, &i))
	365	\|\| !TEST_uint_eq(i, 0x0204)
	366	\|\| !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
	367	\|\| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
ec30e856	368	return 0;
ec30e856 EK	369
	370	return 1;
	371	}
	372
31a80694	373	static int test_PACKET_get_length_prefixed_2(void)
ec30e856	374	{
adcd8e37	375	unsigned char buf1[1024];
ec30e856 EK	376	const size_t len = 516; /* 0x0204 */
ec30e856 EK	377	unsigned int i;
72962d02	378	PACKET pkt, short_pkt, subpkt;
adcd8e37	379
72962d02	380	memset(&subpkt, 0, sizeof(subpkt));
adcd8e37 RS	381	for (i = 1; i <= 1024; i++)
	382	buf1[i - 1] = (i * 2) & 0xff;
	383
	384	if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
	385	\|\| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
	386	\|\| !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
	387	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
	388	\|\| !TEST_true(PACKET_get_net_2(&subpkt, &i))
	389	\|\| !TEST_uint_eq(i, 0x0608)
	390	\|\| !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
	391	\|\| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
ec30e856	392	return 0;
ec30e856 EK	393
	394	return 1;
	395	}
	396
31a80694	397	static int test_PACKET_get_length_prefixed_3(void)
ec30e856	398	{
adcd8e37	399	unsigned char buf1[1024];
ec30e856 EK	400	const size_t len = 516; /* 0x000204 */
ec30e856 EK	401	unsigned int i;
72962d02	402	PACKET pkt, short_pkt, subpkt;
adcd8e37	403
72962d02	404	memset(&subpkt, 0, sizeof(subpkt));
adcd8e37 RS	405	for (i = 0; i < 1024; i++)
	406	buf1[i] = (i * 2) & 0xff;
	407
	408	if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
	409	\|\| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
	410	\|\| !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
	411	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
	412	\|\| !TEST_true(PACKET_get_net_2(&subpkt, &i))
	413	\|\| !TEST_uint_eq(i, 0x0608)
	414	\|\| !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
	415	\|\| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
ec30e856	416	return 0;
ec30e856 EK	417
	418	return 1;
	419	}
	420
31a80694	421	static int test_PACKET_as_length_prefixed_1(void)
06217867	422	{
adcd8e37	423	unsigned char buf1[BUF_LEN];
06217867 EK	424	const size_t len = 16;
06217867 EK	425	unsigned int i;
72962d02	426	PACKET pkt, exact_pkt, subpkt;
06217867	427
72962d02	428	memset(&subpkt, 0, sizeof(subpkt));
3a63c0ed	429	buf1[0] = (unsigned char)len;
adcd8e37 RS	430	for (i = 1; i < BUF_LEN; i++)
	431	buf1[i] = (i * 2) & 0xff;
	432
	433	if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
	434	\|\| !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
	435	\|\| !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
	436	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
23fa9789	437	\|\| !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt))
adcd8e37	438	\|\| !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
23fa9789	439	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
06217867	440	return 0;
06217867 EK	441
	442	return 1;
	443	}
	444
31a80694	445	static int test_PACKET_as_length_prefixed_2(void)
06217867 EK	446	{
	447	unsigned char buf[1024];
	448	const size_t len = 516; /* 0x0204 */
	449	unsigned int i;
72962d02	450	PACKET pkt, exact_pkt, subpkt;
06217867	451
72962d02	452	memset(&subpkt, 0, sizeof(subpkt));
adcd8e37	453	for (i = 1; i <= 1024; i++)
06217867	454	buf[i-1] = (i * 2) & 0xff;
adcd8e37 RS	455
	456	if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
	457	\|\| !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
	458	\|\| !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
	459	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
	460	\|\| !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
	461	\|\| !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
	462	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
06217867	463	return 0;
06217867 EK	464
	465	return 1;
	466	}
	467
ad887416	468	int setup_tests(void)
6fc2ef20	469	{
6fc2ef20	470	unsigned int i;
6fc2ef20	471
adcd8e37 RS	472	for (i = 1; i <= BUF_LEN; i++)
	473	smbuf[i - 1] = (i * 2) & 0xff;
	474
	475	ADD_TEST(test_PACKET_buf_init);
	476	ADD_TEST(test_PACKET_null_init);
	477	ADD_TEST(test_PACKET_remaining);
	478	ADD_TEST(test_PACKET_end);
	479	ADD_TEST(test_PACKET_equal);
	480	ADD_TEST(test_PACKET_get_1);
	481	ADD_TEST(test_PACKET_get_4);
	482	ADD_TEST(test_PACKET_get_net_2);
	483	ADD_TEST(test_PACKET_get_net_3);
	484	ADD_TEST(test_PACKET_get_net_4);
	485	ADD_TEST(test_PACKET_get_sub_packet);
	486	ADD_TEST(test_PACKET_get_bytes);
	487	ADD_TEST(test_PACKET_copy_bytes);
	488	ADD_TEST(test_PACKET_copy_all);
	489	ADD_TEST(test_PACKET_memdup);
	490	ADD_TEST(test_PACKET_strndup);
	491	ADD_TEST(test_PACKET_contains_zero_byte);
	492	ADD_TEST(test_PACKET_forward);
	493	ADD_TEST(test_PACKET_get_length_prefixed_1);
	494	ADD_TEST(test_PACKET_get_length_prefixed_2);
	495	ADD_TEST(test_PACKET_get_length_prefixed_3);
	496	ADD_TEST(test_PACKET_as_length_prefixed_1);
	497	ADD_TEST(test_PACKET_as_length_prefixed_2);
ad887416	498	return 1;
6fc2ef20	499	}