[thirdparty/systemd.git] / src / libsystemd-network / test-dhcp-option.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

#include <stdio.h>
#include <stdbool.h>
#include <errno.h>
#include <string.h>

#include "alloc-util.h"
#include "dhcp-internal.h"
#include "dhcp-protocol.h"
#include "macro.h"
#include "util.h"

struct option_desc {
        uint8_t sname[64];
        int snamelen;
        uint8_t file[128];
        int filelen;
        uint8_t options[128];
        int len;
        bool success;
        int filepos;
        int snamepos;
        int pos;
};

static bool verbose = false;

static struct option_desc option_tests[] = {
        { {}, 0, {}, 0, { 42, 5, 65, 66, 67, 68, 69 }, 7, false, },
        { {}, 0, {}, 0, { 42, 5, 65, 66, 67, 68, 69, 0, 0,
                          DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 12, true, },
        { {}, 0, {}, 0, { 8, 255, 70, 71, 72 }, 5, false, },
        { {}, 0, {}, 0, { 0x35, 0x01, 0x05, 0x36, 0x04, 0x01, 0x00, 0xa8,
                          0xc0, 0x33, 0x04, 0x00, 0x01, 0x51, 0x80, 0x01,
                          0x04, 0xff, 0xff, 0xff, 0x00, 0x03, 0x04, 0xc0,
                          0xa8, 0x00, 0x01, 0x06, 0x04, 0xc0, 0xa8, 0x00,
                          0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
          40, true, },
        { {}, 0, {}, 0, { DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_OFFER,
                          42, 3, 0, 0, 0 }, 8, true, },
        { {}, 0, {}, 0, { 42, 2, 1, 2, 44 }, 5, false, },

        { {}, 0,
          { 222, 3, 1, 2, 3, DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_NAK }, 8,
          { DHCP_OPTION_OVERLOAD, 1, DHCP_OVERLOAD_FILE }, 3, true, },

        { { 1, 4, 1, 2, 3, 4, DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 9,
          { 222, 3, 1, 2, 3 }, 5,
          { DHCP_OPTION_OVERLOAD, 1,
            DHCP_OVERLOAD_FILE|DHCP_OVERLOAD_SNAME }, 3, true, },
};

static const char *dhcp_type(int type) {
        switch(type) {
        case DHCP_DISCOVER:
                return "DHCPDISCOVER";
        case DHCP_OFFER:
                return "DHCPOFFER";
        case DHCP_REQUEST:
                return "DHCPREQUEST";
        case DHCP_DECLINE:
                return "DHCPDECLINE";
        case DHCP_ACK:
                return "DHCPACK";
        case DHCP_NAK:
                return "DHCPNAK";
        case DHCP_RELEASE:
                return "DHCPRELEASE";
        default:
                return "unknown";
        }
}

static void test_invalid_buffer_length(void) {
        DHCPMessage message;

        assert_se(dhcp_option_parse(&message, 0, NULL, NULL) == -EINVAL);
        assert_se(dhcp_option_parse(&message, sizeof(DHCPMessage) - 1, NULL, NULL)
               == -EINVAL);
}

static void test_message_init(void) {
        _cleanup_free_ DHCPMessage *message = NULL;
        size_t optlen = 4, optoffset;
        size_t len = sizeof(DHCPMessage) + optlen;
        uint8_t *magic;

        message = malloc0(len);

        assert_se(dhcp_message_init(message, BOOTREQUEST, 0x12345678,
                  DHCP_DISCOVER, ARPHRD_ETHER, optlen, &optoffset) >= 0);

        assert_se(message->xid == htobe32(0x12345678));
        assert_se(message->op == BOOTREQUEST);

        magic = (uint8_t*)&message->magic;

        assert_se(magic[0] == 99);
        assert_se(magic[1] == 130);
        assert_se(magic[2] == 83);
        assert_se(magic[3] == 99);

        assert_se(dhcp_option_parse(message, len, NULL, NULL) >= 0);
}

static DHCPMessage *create_message(uint8_t *options, uint16_t optlen,
                uint8_t *file, uint8_t filelen,
                uint8_t *sname, uint8_t snamelen) {
        DHCPMessage *message;
        size_t len = sizeof(DHCPMessage) + optlen;

        message = malloc0(len);
        assert_se(message);

        if (options && optlen)
                memcpy(&message->options, options, optlen);

        if (file && filelen <= 128)
                memcpy(&message->file, file, filelen);

        if (sname && snamelen <= 64)
                memcpy(&message->sname, sname, snamelen);

        return message;
}

static void test_ignore_opts(uint8_t *descoption, int *descpos, int *desclen) {
        assert(*descpos >= 0);

        while (*descpos < *desclen) {
                switch(descoption[*descpos]) {
                case DHCP_OPTION_PAD:
                        *descpos += 1;
                        break;

                case DHCP_OPTION_MESSAGE_TYPE:
                case DHCP_OPTION_OVERLOAD:
                        *descpos += 3;
                        break;

                default:
                        return;
                }
        }
}

static int test_options_cb(uint8_t code, uint8_t len, const void *option, void *userdata) {
        struct option_desc *desc = userdata;
        uint8_t *descoption = NULL;
        int *desclen = NULL, *descpos = NULL;
        uint8_t optcode = 0;
        uint8_t optlen = 0;
        uint8_t i;

        assert_se((!desc && !code && !len) || desc);

        if (!desc)
                return -EINVAL;

        assert_se(code != DHCP_OPTION_PAD);
        assert_se(code != DHCP_OPTION_END);
        assert_se(code != DHCP_OPTION_MESSAGE_TYPE);
        assert_se(code != DHCP_OPTION_OVERLOAD);

        while (desc->pos >= 0 || desc->filepos >= 0 || desc->snamepos >= 0) {

                if (desc->pos >= 0) {
                        descoption = &desc->options[0];
                        desclen = &desc->len;
                        descpos = &desc->pos;
                } else if (desc->filepos >= 0) {
                        descoption = &desc->file[0];
                        desclen = &desc->filelen;
                        descpos = &desc->filepos;
                } else if (desc->snamepos >= 0) {
                        descoption = &desc->sname[0];
                        desclen = &desc->snamelen;
                        descpos = &desc->snamepos;
                }

                assert_se(descoption && desclen && descpos);

                if (*desclen)
                        test_ignore_opts(descoption, descpos, desclen);

                if (*descpos < *desclen)
                        break;

                if (*descpos == *desclen)
                        *descpos = -1;
        }

        assert_se(descpos);
        assert_se(*descpos != -1);

        optcode = descoption[*descpos];
        optlen = descoption[*descpos + 1];

        if (verbose)
                printf("DHCP code %2d(%2d) len %2d(%2d) ", code, optcode,
                                len, optlen);

        assert_se(code == optcode);
        assert_se(len == optlen);

        for (i = 0; i < len; i++) {

                if (verbose)
                        printf("0x%02x(0x%02x) ", ((uint8_t*) option)[i],
                                        descoption[*descpos + 2 + i]);

                assert_se(((uint8_t*) option)[i] == descoption[*descpos + 2 + i]);
        }

        if (verbose)
                printf("\n");

        *descpos += optlen + 2;

        test_ignore_opts(descoption, descpos, desclen);

        if (desc->pos != -1 && desc->pos == desc->len)
                desc->pos = -1;

        if (desc->filepos != -1 && desc->filepos == desc->filelen)
                desc->filepos = -1;

        if (desc->snamepos != -1 && desc->snamepos == desc->snamelen)
                desc->snamepos = -1;

        return 0;
}

static void test_options(struct option_desc *desc) {
        uint8_t *options = NULL;
        uint8_t *file = NULL;
        uint8_t *sname = NULL;
        int optlen = 0;
        int filelen = 0;
        int snamelen = 0;
        int buflen = 0;
        _cleanup_free_ DHCPMessage *message = NULL;
        int res;

        if (desc) {
                file = &desc->file[0];
                filelen = desc->filelen;
                if (!filelen)
                        desc->filepos = -1;

                sname = &desc->sname[0];
                snamelen = desc->snamelen;
                if (!snamelen)
                        desc->snamepos = -1;

                options = &desc->options[0];
                optlen = desc->len;
                desc->pos = 0;
        }
        message = create_message(options, optlen, file, filelen,
                                 sname, snamelen);

        buflen = sizeof(DHCPMessage) + optlen;

        if (!desc) {
                assert_se((res = dhcp_option_parse(message, buflen,
                                                test_options_cb,
                                                NULL)) == -ENOMSG);
        } else if (desc->success) {
                assert_se((res = dhcp_option_parse(message, buflen,
                                                test_options_cb,
                                                desc)) >= 0);
                assert_se(desc->pos == -1 && desc->filepos == -1 &&
                                desc->snamepos == -1);
        } else
                assert_se((res = dhcp_option_parse(message, buflen,
                                                test_options_cb,
                                                desc)) < 0);

        if (verbose)
                printf("DHCP type %s\n", dhcp_type(res));
}

static uint8_t options[64] = {
        'A', 'B', 'C', 'D',
        160, 2, 0x11, 0x12,
        0,
        31, 8, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
        0,
        55, 3, 0x51, 0x52, 0x53,
        17, 7, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
        255
};

static void test_option_set(void) {
        _cleanup_free_ DHCPMessage *result = NULL;
        size_t offset = 0, len, pos;
        unsigned i;

        result = malloc0(sizeof(DHCPMessage) + 11);
        assert_se(result);

        result->options[0] = 'A';
        result->options[1] = 'B';
        result->options[2] = 'C';
        result->options[3] = 'D';

        assert_se(dhcp_option_append(result, 0, &offset, 0, DHCP_OPTION_PAD,
                                     0, NULL) == -ENOBUFS);
        assert_se(offset == 0);

        offset = 4;
        assert_se(dhcp_option_append(result, 5, &offset, 0, DHCP_OPTION_PAD,
                                     0, NULL) == -ENOBUFS);
        assert_se(offset == 4);
        assert_se(dhcp_option_append(result, 6, &offset, 0, DHCP_OPTION_PAD,
                                     0, NULL) >= 0);
        assert_se(offset == 5);

        offset = pos = 4;
        len = 11;
        while (pos < len && options[pos] != DHCP_OPTION_END) {
                assert_se(dhcp_option_append(result, len, &offset, DHCP_OVERLOAD_SNAME,
                                             options[pos],
                                             options[pos + 1],
                                             &options[pos + 2]) >= 0);

                if (options[pos] == DHCP_OPTION_PAD)
                        pos++;
                else
                        pos += 2 + options[pos + 1];

                if (pos < len)
                        assert_se(offset == pos);
        }

        for (i = 0; i < 9; i++) {
                if (verbose)
                        printf("%2u: 0x%02x(0x%02x) (options)\n", i, result->options[i],
                               options[i]);
                assert_se(result->options[i] == options[i]);
        }

        if (verbose)
                printf("%2d: 0x%02x(0x%02x) (options)\n", 9, result->options[9],
                       DHCP_OPTION_END);

        assert_se(result->options[9] == DHCP_OPTION_END);

        if (verbose)
                printf("%2d: 0x%02x(0x%02x) (options)\n", 10, result->options[10],
                       DHCP_OPTION_PAD);

        assert_se(result->options[10] == DHCP_OPTION_PAD);

        for (i = 0; i < pos - 8; i++) {
                if (verbose)
                        printf("%2u: 0x%02x(0x%02x) (sname)\n", i, result->sname[i],
                               options[i + 9]);
                assert_se(result->sname[i] == options[i + 9]);
        }

        if (verbose)
                printf ("\n");
}

int main(int argc, char *argv[]) {
        unsigned i;

        test_invalid_buffer_length();
        test_message_init();

        test_options(NULL);

        for (i = 0; i < ELEMENTSOF(option_tests); i++)
                test_options(&option_tests[i]);

        test_option_set();

        return 0;
}
Commit	Line	Data
9116b406	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
a0ae95c9 PF	2
	3	#include <stdio.h>
	4	#include <stdbool.h>
	5	#include <errno.h>
	6	#include <string.h>
a0ae95c9	7
b5efdb8a	8	#include "alloc-util.h"
a0ae95c9	9	#include "dhcp-internal.h"
b5efdb8a LP	10	#include "dhcp-protocol.h"
	11	#include "macro.h"
	12	#include "util.h"
a0ae95c9	13
a10c375e PF	14	struct option_desc {
	15	uint8_t sname[64];
	16	int snamelen;
	17	uint8_t file[128];
	18	int filelen;
	19	uint8_t options[128];
	20	int len;
	21	bool success;
	22	int filepos;
	23	int snamepos;
	24	int pos;
	25	};
	26
	27	static bool verbose = false;
	28
	29	static struct option_desc option_tests[] = {
	30	{ {}, 0, {}, 0, { 42, 5, 65, 66, 67, 68, 69 }, 7, false, },
	31	{ {}, 0, {}, 0, { 42, 5, 65, 66, 67, 68, 69, 0, 0,
	32	DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 12, true, },
	33	{ {}, 0, {}, 0, { 8, 255, 70, 71, 72 }, 5, false, },
	34	{ {}, 0, {}, 0, { 0x35, 0x01, 0x05, 0x36, 0x04, 0x01, 0x00, 0xa8,
	35	0xc0, 0x33, 0x04, 0x00, 0x01, 0x51, 0x80, 0x01,
	36	0x04, 0xff, 0xff, 0xff, 0x00, 0x03, 0x04, 0xc0,
	37	0xa8, 0x00, 0x01, 0x06, 0x04, 0xc0, 0xa8, 0x00,
	38	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
	39	40, true, },
	40	{ {}, 0, {}, 0, { DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_OFFER,
	41	42, 3, 0, 0, 0 }, 8, true, },
	42	{ {}, 0, {}, 0, { 42, 2, 1, 2, 44 }, 5, false, },
	43
	44	{ {}, 0,
	45	{ 222, 3, 1, 2, 3, DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_NAK }, 8,
	46	{ DHCP_OPTION_OVERLOAD, 1, DHCP_OVERLOAD_FILE }, 3, true, },
	47
	48	{ { 1, 4, 1, 2, 3, 4, DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 9,
	49	{ 222, 3, 1, 2, 3 }, 5,
	50	{ DHCP_OPTION_OVERLOAD, 1,
	51	DHCP_OVERLOAD_FILE\|DHCP_OVERLOAD_SNAME }, 3, true, },
	52	};
	53
9116b406	54	static const char *dhcp_type(int type) {
a10c375e PF	55	switch(type) {
	56	case DHCP_DISCOVER:
	57	return "DHCPDISCOVER";
	58	case DHCP_OFFER:
	59	return "DHCPOFFER";
	60	case DHCP_REQUEST:
	61	return "DHCPREQUEST";
	62	case DHCP_DECLINE:
	63	return "DHCPDECLINE";
	64	case DHCP_ACK:
	65	return "DHCPACK";
	66	case DHCP_NAK:
	67	return "DHCPNAK";
	68	case DHCP_RELEASE:
	69	return "DHCPRELEASE";
	70	default:
	71	return "unknown";
	72	}
	73	}
	74
9116b406	75	static void test_invalid_buffer_length(void) {
a0ae95c9 PF	76	DHCPMessage message;
a0ae95c9 PF	77
12e0f830	78	assert_se(dhcp_option_parse(&message, 0, NULL, NULL) == -EINVAL);
d47e1de4	79	assert_se(dhcp_option_parse(&message, sizeof(DHCPMessage) - 1, NULL, NULL)
a0ae95c9 PF	80	== -EINVAL);
	81	}
	82
9116b406	83	static void test_message_init(void) {
d47e1de4	84	_cleanup_free_ DHCPMessage *message = NULL;
2688ef60	85	size_t optlen = 4, optoffset;
d47e1de4	86	size_t len = sizeof(DHCPMessage) + optlen;
20b958bf	87	uint8_t *magic;
a0ae95c9 PF	88
	89	message = malloc0(len);
	90
d47e1de4	91	assert_se(dhcp_message_init(message, BOOTREQUEST, 0x12345678,
76253e73	92	DHCP_DISCOVER, ARPHRD_ETHER, optlen, &optoffset) >= 0);
d47e1de4 TG	93
	94	assert_se(message->xid == htobe32(0x12345678));
	95	assert_se(message->op == BOOTREQUEST);
a0ae95c9	96
d47e1de4	97	magic = (uint8_t*)&message->magic;
a0ae95c9	98
d47e1de4	99	assert_se(magic[0] == 99);
86be3e1e TA	100	assert_se(magic[1] == 130);
	101	assert_se(magic[2] == 83);
	102	assert_se(magic[3] == 99);
d47e1de4 TG	103
d47e1de4 TG	104	assert_se(dhcp_option_parse(message, len, NULL, NULL) >= 0);
a10c375e PF	105	}
	106
	107	static DHCPMessage create_message(uint8_t options, uint16_t optlen,
	108	uint8_t *file, uint8_t filelen,
9116b406	109	uint8_t *sname, uint8_t snamelen) {
a10c375e	110	DHCPMessage *message;
d47e1de4	111	size_t len = sizeof(DHCPMessage) + optlen;
a0ae95c9	112
a10c375e	113	message = malloc0(len);
6f428772	114	assert_se(message);
a10c375e	115
a10c375e	116	if (options && optlen)
20b958bf	117	memcpy(&message->options, options, optlen);
a10c375e PF	118
	119	if (file && filelen <= 128)
	120	memcpy(&message->file, file, filelen);
	121
	122	if (sname && snamelen <= 64)
	123	memcpy(&message->sname, sname, snamelen);
	124
	125	return message;
	126	}
	127
9116b406	128	static void test_ignore_opts(uint8_t descoption, int descpos, int *desclen) {
0915fda6 ZJS	129	assert(*descpos >= 0);
0915fda6 ZJS	130
a10c375e PF	131	while (descpos < desclen) {
	132	switch(descoption[*descpos]) {
	133	case DHCP_OPTION_PAD:
	134	*descpos += 1;
	135	break;
	136
	137	case DHCP_OPTION_MESSAGE_TYPE:
	138	case DHCP_OPTION_OVERLOAD:
	139	*descpos += 3;
	140	break;
	141
	142	default:
	143	return;
	144	}
	145	}
	146	}
	147
e4735228	148	static int test_options_cb(uint8_t code, uint8_t len, const void option, void userdata) {
89ca10c6	149	struct option_desc *desc = userdata;
a10c375e PF	150	uint8_t *descoption = NULL;
	151	int desclen = NULL, descpos = NULL;
	152	uint8_t optcode = 0;
	153	uint8_t optlen = 0;
	154	uint8_t i;
	155
12e0f830	156	assert_se((!desc && !code && !len) \|\| desc);
a10c375e PF	157
	158	if (!desc)
	159	return -EINVAL;
	160
12e0f830 TG	161	assert_se(code != DHCP_OPTION_PAD);
	162	assert_se(code != DHCP_OPTION_END);
	163	assert_se(code != DHCP_OPTION_MESSAGE_TYPE);
	164	assert_se(code != DHCP_OPTION_OVERLOAD);
a10c375e PF	165
	166	while (desc->pos >= 0 \|\| desc->filepos >= 0 \|\| desc->snamepos >= 0) {
	167
	168	if (desc->pos >= 0) {
	169	descoption = &desc->options[0];
	170	desclen = &desc->len;
	171	descpos = &desc->pos;
	172	} else if (desc->filepos >= 0) {
	173	descoption = &desc->file[0];
	174	desclen = &desc->filelen;
	175	descpos = &desc->filepos;
	176	} else if (desc->snamepos >= 0) {
	177	descoption = &desc->sname[0];
	178	desclen = &desc->snamelen;
	179	descpos = &desc->snamepos;
	180	}
	181
12e0f830	182	assert_se(descoption && desclen && descpos);
a10c375e PF	183
	184	if (*desclen)
	185	test_ignore_opts(descoption, descpos, desclen);
	186
	187	if (descpos < desclen)
	188	break;
	189
	190	if (descpos == desclen)
	191	*descpos = -1;
	192	}
	193
12e0f830 TG	194	assert_se(descpos);
12e0f830 TG	195	assert_se(*descpos != -1);
a10c375e PF	196
	197	optcode = descoption[*descpos];
	198	optlen = descoption[*descpos + 1];
	199
	200	if (verbose)
	201	printf("DHCP code %2d(%2d) len %2d(%2d) ", code, optcode,
	202	len, optlen);
	203
12e0f830 TG	204	assert_se(code == optcode);
12e0f830 TG	205	assert_se(len == optlen);
a10c375e PF	206
	207	for (i = 0; i < len; i++) {
	208
	209	if (verbose)
e4735228	210	printf("0x%02x(0x%02x) ", ((uint8_t*) option)[i],
a10c375e PF	211	descoption[*descpos + 2 + i]);
a10c375e PF	212
e4735228	213	assert_se(((uint8_t) option)[i] == descoption[descpos + 2 + i]);
a10c375e PF	214	}
	215
	216	if (verbose)
	217	printf("\n");
	218
	219	*descpos += optlen + 2;
	220
	221	test_ignore_opts(descoption, descpos, desclen);
	222
	223	if (desc->pos != -1 && desc->pos == desc->len)
	224	desc->pos = -1;
	225
	226	if (desc->filepos != -1 && desc->filepos == desc->filelen)
	227	desc->filepos = -1;
	228
	229	if (desc->snamepos != -1 && desc->snamepos == desc->snamelen)
	230	desc->snamepos = -1;
	231
	232	return 0;
	233	}
	234
9116b406	235	static void test_options(struct option_desc *desc) {
a10c375e PF	236	uint8_t *options = NULL;
	237	uint8_t *file = NULL;
	238	uint8_t *sname = NULL;
	239	int optlen = 0;
	240	int filelen = 0;
	241	int snamelen = 0;
	242	int buflen = 0;
d47e1de4	243	_cleanup_free_ DHCPMessage *message = NULL;
a10c375e PF	244	int res;
	245
	246	if (desc) {
	247	file = &desc->file[0];
	248	filelen = desc->filelen;
	249	if (!filelen)
	250	desc->filepos = -1;
	251
	252	sname = &desc->sname[0];
	253	snamelen = desc->snamelen;
	254	if (!snamelen)
	255	desc->snamepos = -1;
	256
	257	options = &desc->options[0];
	258	optlen = desc->len;
	259	desc->pos = 0;
	260	}
	261	message = create_message(options, optlen, file, filelen,
d47e1de4	262	sname, snamelen);
a10c375e	263
d47e1de4	264	buflen = sizeof(DHCPMessage) + optlen;
a10c375e PF	265
a10c375e PF	266	if (!desc) {
12e0f830	267	assert_se((res = dhcp_option_parse(message, buflen,
a10c375e PF	268	test_options_cb,
	269	NULL)) == -ENOMSG);
	270	} else if (desc->success) {
12e0f830	271	assert_se((res = dhcp_option_parse(message, buflen,
a10c375e PF	272	test_options_cb,
a10c375e PF	273	desc)) >= 0);
12e0f830	274	assert_se(desc->pos == -1 && desc->filepos == -1 &&
a10c375e PF	275	desc->snamepos == -1);
a10c375e PF	276	} else
12e0f830	277	assert_se((res = dhcp_option_parse(message, buflen,
a10c375e PF	278	test_options_cb,
	279	desc)) < 0);
	280
	281	if (verbose)
	282	printf("DHCP type %s\n", dhcp_type(res));
a0ae95c9 PF	283	}
a0ae95c9 PF	284
d8b61a1d PF	285	static uint8_t options[64] = {
	286	'A', 'B', 'C', 'D',
	287	160, 2, 0x11, 0x12,
	288	0,
	289	31, 8, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
	290	0,
	291	55, 3, 0x51, 0x52, 0x53,
	292	17, 7, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
	293	255
	294	};
	295
9116b406	296	static void test_option_set(void) {
4eb20caa	297	_cleanup_free_ DHCPMessage *result = NULL;
20b958bf TG	298	size_t offset = 0, len, pos;
20b958bf TG	299	unsigned i;
d8b61a1d	300
04b28be1 TG	301	result = malloc0(sizeof(DHCPMessage) + 11);
	302	assert_se(result);
	303
	304	result->options[0] = 'A';
	305	result->options[1] = 'B';
	306	result->options[2] = 'C';
	307	result->options[3] = 'D';
	308
	309	assert_se(dhcp_option_append(result, 0, &offset, 0, DHCP_OPTION_PAD,
	310	0, NULL) == -ENOBUFS);
20b958bf	311	assert_se(offset == 0);
d8b61a1d	312
20b958bf	313	offset = 4;
04b28be1 TG	314	assert_se(dhcp_option_append(result, 5, &offset, 0, DHCP_OPTION_PAD,
	315	0, NULL) == -ENOBUFS);
	316	assert_se(offset == 4);
	317	assert_se(dhcp_option_append(result, 6, &offset, 0, DHCP_OPTION_PAD,
	318	0, NULL) >= 0);
20b958bf	319	assert_se(offset == 5);
d8b61a1d	320
20b958bf	321	offset = pos = 4;
04b28be1 TG	322	len = 11;
	323	while (pos < len && options[pos] != DHCP_OPTION_END) {
	324	assert_se(dhcp_option_append(result, len, &offset, DHCP_OVERLOAD_SNAME,
20b958bf TG	325	options[pos],
	326	options[pos + 1],
	327	&options[pos + 2]) >= 0);
d8b61a1d	328
20b958bf	329	if (options[pos] == DHCP_OPTION_PAD)
d8b61a1d	330	pos++;
20b958bf	331	else
d8b61a1d	332	pos += 2 + options[pos + 1];
20b958bf	333
04b28be1 TG	334	if (pos < len)
04b28be1 TG	335	assert_se(offset == pos);
d8b61a1d PF	336	}
d8b61a1d PF	337
04b28be1	338	for (i = 0; i < 9; i++) {
d8b61a1d	339	if (verbose)
c4ef0548	340	printf("%2u: 0x%02x(0x%02x) (options)\n", i, result->options[i],
d8b61a1d	341	options[i]);
04b28be1 TG	342	assert_se(result->options[i] == options[i]);
	343	}
	344
	345	if (verbose)
	346	printf("%2d: 0x%02x(0x%02x) (options)\n", 9, result->options[9],
	347	DHCP_OPTION_END);
	348
	349	assert_se(result->options[9] == DHCP_OPTION_END);
	350
	351	if (verbose)
	352	printf("%2d: 0x%02x(0x%02x) (options)\n", 10, result->options[10],
	353	DHCP_OPTION_PAD);
	354
	355	assert_se(result->options[10] == DHCP_OPTION_PAD);
	356
	357	for (i = 0; i < pos - 8; i++) {
	358	if (verbose)
c4ef0548	359	printf("%2u: 0x%02x(0x%02x) (sname)\n", i, result->sname[i],
04b28be1 TG	360	options[i + 9]);
04b28be1 TG	361	assert_se(result->sname[i] == options[i + 9]);
d8b61a1d PF	362	}
	363
	364	if (verbose)
	365	printf ("\n");
	366	}
	367
9116b406 ZJS	368	int main(int argc, char *argv[]) {
9116b406 ZJS	369	unsigned i;
a10c375e	370
a0ae95c9	371	test_invalid_buffer_length();
d47e1de4	372	test_message_init();
a0ae95c9	373
a10c375e PF	374	test_options(NULL);
	375
	376	for (i = 0; i < ELEMENTSOF(option_tests); i++)
	377	test_options(&option_tests[i]);
	378
d8b61a1d PF	379	test_option_set();
d8b61a1d PF	380
a0ae95c9 PF	381	return 0;
a0ae95c9 PF	382	}