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

/*
 * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (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 "../ssl/packet_locl.h"
#include "testutil.h"

#define BUF_LEN 255

static unsigned char smbuf[BUF_LEN];

static int test_PACKET_remaining()
{
    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()
{
    PACKET pkt;

    if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
            || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
            || !TEST_ptr_ne(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()
{
    unsigned int i;
    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()
{
    unsigned long i;
    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()
{
    unsigned int i;
    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()
{
    unsigned long i;
    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()
{
    unsigned long i;
    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()
{
    PACKET pkt, subpkt;
    unsigned long i;

    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()
{
    const unsigned char *bytes;
    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()
{
    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()
{
    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()
{
    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()
{
    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()
{
    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()
{
    const unsigned char *byte;
    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()
{
    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()
{
    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()
{
    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()
{
    unsigned char buf1[BUF_LEN];
    const size_t len = 16;
    unsigned int i;
    PACKET pkt, short_pkt, subpkt = {0};

    buf1[0] = 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()
{
    unsigned char buf1[1024];
    const size_t len = 516;  /* 0x0204 */
    unsigned int i;
    PACKET pkt, short_pkt, subpkt = {0};

    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()
{
    unsigned char buf1[1024];
    const size_t len = 516;  /* 0x000204 */
    unsigned int i;
    PACKET pkt, short_pkt, subpkt = {0};

    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()
{
    unsigned char buf1[BUF_LEN];
    const size_t len = 16;
    unsigned int i;
    PACKET pkt, exact_pkt, subpkt = {0};

    buf1[0] = 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()
{
    unsigned char buf[1024];
    const size_t len = 516;  /* 0x0204 */
    unsigned int i;
    PACKET pkt, exact_pkt, subpkt = {0};

    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;
}

void register_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);
}
Commit	Line	Data
6fc2ef20	1	/*
440e5d80	2	* Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
6fc2ef20	3	*
440e5d80 RS	4	* Licensed under the OpenSSL license (the "License"). You may not use
	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
6fc2ef20	10	#include "../ssl/packet_locl.h"
adcd8e37	11	#include "testutil.h"
6fc2ef20 MC	12
	13	#define BUF_LEN 255
	14
adcd8e37 RS	15	static unsigned char smbuf[BUF_LEN];
	16
	17	static int test_PACKET_remaining()
6fc2ef20	18	{
4bd16463 EK	19	PACKET pkt;
4bd16463 EK	20
adcd8e37 RS	21	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
	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))
	26	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), 0)))
6fc2ef20	27	return 0;
6fc2ef20 MC	28
	29	return 1;
	30	}
	31
adcd8e37	32	static int test_PACKET_end()
06217867 EK	33	{
	34	PACKET pkt;
	35
adcd8e37 RS	36	if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
	37	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
	38	\|\| !TEST_ptr_ne(PACKET_end(&pkt), smbuf + BUF_LEN)
	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))
	42	\|\| !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)))
06217867	43	return 0;
06217867 EK	44
	45	return 1;
	46	}
	47
adcd8e37	48	static int test_PACKET_get_1()
6fc2ef20 MC	49	{
6fc2ef20 MC	50	unsigned int i;
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
adcd8e37	65	static int test_PACKET_get_4()
6fc2ef20 MC	66	{
6fc2ef20 MC	67	unsigned long i;
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
adcd8e37	82	static int test_PACKET_get_net_2()
6fc2ef20 MC	83	{
6fc2ef20 MC	84	unsigned int i;
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
adcd8e37	99	static int test_PACKET_get_net_3()
6fc2ef20	100	{
04fe876b	101	unsigned long i;
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
adcd8e37	116	static int test_PACKET_get_net_4()
6fc2ef20 MC	117	{
6fc2ef20 MC	118	unsigned long i;
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
adcd8e37	133	static int test_PACKET_get_sub_packet()
6fc2ef20	134	{
4bd16463	135	PACKET pkt, subpkt;
6fc2ef20 MC	136	unsigned long i;
6fc2ef20 MC	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
adcd8e37	154	static int test_PACKET_get_bytes()
6fc2ef20	155	{
b6981744	156	const unsigned char *bytes;
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
adcd8e37	178	static int test_PACKET_copy_bytes()
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
adcd8e37	202	static int test_PACKET_copy_all()
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
adcd8e37	219	static int test_PACKET_memdup()
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	}
	240
	241	static int test_PACKET_strndup()
	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
06217867 EK	268	static int test_PACKET_contains_zero_byte()
06217867 EK	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
adcd8e37	286	static int test_PACKET_forward()
6fc2ef20	287	{
b6981744	288	const unsigned char *byte;
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
	303	static int test_PACKET_buf_init()
	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
b3e2272c EK	319	static int test_PACKET_null_init()
	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
adcd8e37	331	static int test_PACKET_equal()
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
ec30e856 EK	348	static int test_PACKET_get_length_prefixed_1()
ec30e856 EK	349	{
adcd8e37	350	unsigned char buf1[BUF_LEN];
ec30e856 EK	351	const size_t len = 16;
ec30e856 EK	352	unsigned int i;
adcd8e37 RS	353	PACKET pkt, short_pkt, subpkt = {0};
	354
	355	buf1[0] = len;
	356	for (i = 1; i < BUF_LEN; i++)
	357	buf1[i] = (i * 2) & 0xff;
	358
	359	if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
	360	\|\| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
	361	\|\| !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
	362	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
	363	\|\| !TEST_true(PACKET_get_net_2(&subpkt, &i))
	364	\|\| !TEST_uint_eq(i, 0x0204)
	365	\|\| !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
	366	\|\| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
ec30e856	367	return 0;
ec30e856 EK	368
	369	return 1;
	370	}
	371
	372	static int test_PACKET_get_length_prefixed_2()
	373	{
adcd8e37	374	unsigned char buf1[1024];
ec30e856 EK	375	const size_t len = 516; /* 0x0204 */
ec30e856 EK	376	unsigned int i;
adcd8e37 RS	377	PACKET pkt, short_pkt, subpkt = {0};
	378
	379	for (i = 1; i <= 1024; i++)
	380	buf1[i - 1] = (i * 2) & 0xff;
	381
	382	if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
	383	\|\| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
	384	\|\| !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
	385	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
	386	\|\| !TEST_true(PACKET_get_net_2(&subpkt, &i))
	387	\|\| !TEST_uint_eq(i, 0x0608)
	388	\|\| !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
	389	\|\| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
ec30e856	390	return 0;
ec30e856 EK	391
	392	return 1;
	393	}
	394
	395	static int test_PACKET_get_length_prefixed_3()
	396	{
adcd8e37	397	unsigned char buf1[1024];
ec30e856 EK	398	const size_t len = 516; /* 0x000204 */
ec30e856 EK	399	unsigned int i;
adcd8e37 RS	400	PACKET pkt, short_pkt, subpkt = {0};
	401
	402	for (i = 0; i < 1024; i++)
	403	buf1[i] = (i * 2) & 0xff;
	404
	405	if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
	406	\|\| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
	407	\|\| !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
	408	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
	409	\|\| !TEST_true(PACKET_get_net_2(&subpkt, &i))
	410	\|\| !TEST_uint_eq(i, 0x0608)
	411	\|\| !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
	412	\|\| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
ec30e856	413	return 0;
ec30e856 EK	414
	415	return 1;
	416	}
	417
06217867 EK	418	static int test_PACKET_as_length_prefixed_1()
06217867 EK	419	{
adcd8e37	420	unsigned char buf1[BUF_LEN];
06217867 EK	421	const size_t len = 16;
06217867 EK	422	unsigned int i;
de34966b	423	PACKET pkt, exact_pkt, subpkt = {0};
06217867	424
adcd8e37 RS	425	buf1[0] = len;
	426	for (i = 1; i < BUF_LEN; i++)
	427	buf1[i] = (i * 2) & 0xff;
	428
	429	if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
	430	\|\| !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
	431	\|\| !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
	432	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
	433	\|\| !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
	434	\|\| !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
	435	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)))
06217867	436	return 0;
06217867 EK	437
	438	return 1;
	439	}
	440
	441	static int test_PACKET_as_length_prefixed_2()
	442	{
	443	unsigned char buf[1024];
	444	const size_t len = 516; /* 0x0204 */
	445	unsigned int i;
de34966b	446	PACKET pkt, exact_pkt, subpkt = {0};
06217867	447
adcd8e37	448	for (i = 1; i <= 1024; i++)
06217867	449	buf[i-1] = (i * 2) & 0xff;
adcd8e37 RS	450
	451	if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
	452	\|\| !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
	453	\|\| !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
	454	\|\| !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
	455	\|\| !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
	456	\|\| !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
	457	\|\| !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
06217867	458	return 0;
06217867 EK	459
	460	return 1;
	461	}
	462
adcd8e37	463	void register_tests(void)
6fc2ef20	464	{
6fc2ef20	465	unsigned int i;
6fc2ef20	466
adcd8e37 RS	467	for (i = 1; i <= BUF_LEN; i++)
	468	smbuf[i - 1] = (i * 2) & 0xff;
	469
	470	ADD_TEST(test_PACKET_buf_init);
	471	ADD_TEST(test_PACKET_null_init);
	472	ADD_TEST(test_PACKET_remaining);
	473	ADD_TEST(test_PACKET_end);
	474	ADD_TEST(test_PACKET_equal);
	475	ADD_TEST(test_PACKET_get_1);
	476	ADD_TEST(test_PACKET_get_4);
	477	ADD_TEST(test_PACKET_get_net_2);
	478	ADD_TEST(test_PACKET_get_net_3);
	479	ADD_TEST(test_PACKET_get_net_4);
	480	ADD_TEST(test_PACKET_get_sub_packet);
	481	ADD_TEST(test_PACKET_get_bytes);
	482	ADD_TEST(test_PACKET_copy_bytes);
	483	ADD_TEST(test_PACKET_copy_all);
	484	ADD_TEST(test_PACKET_memdup);
	485	ADD_TEST(test_PACKET_strndup);
	486	ADD_TEST(test_PACKET_contains_zero_byte);
	487	ADD_TEST(test_PACKET_forward);
	488	ADD_TEST(test_PACKET_get_length_prefixed_1);
	489	ADD_TEST(test_PACKET_get_length_prefixed_2);
	490	ADD_TEST(test_PACKET_get_length_prefixed_3);
	491	ADD_TEST(test_PACKET_as_length_prefixed_1);
	492	ADD_TEST(test_PACKET_as_length_prefixed_2);
6fc2ef20	493	}