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

#include <errno.h>
#include <stdbool.h>
#include <stdio.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,
                          SD_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, { SD_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, SD_DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_NAK }, 8,
          { SD_DHCP_OPTION_OVERLOAD, 1, DHCP_OVERLOAD_FILE }, 3, true, },

        { { 1, 4, 1, 2, 3, 4, SD_DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 9,
          { 222, 3, 1, 2, 3 }, 5,
          { SD_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, NULL) == -EINVAL);
        assert_se(dhcp_option_parse(&message, sizeof(DHCPMessage) - 1, NULL, 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, 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);

        memcpy_safe(&message->options, options, optlen);
        memcpy_safe(&message->file, file, filelen);
        memcpy_safe(&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 SD_DHCP_OPTION_PAD:
                        *descpos += 1;
                        break;

                case SD_DHCP_OPTION_MESSAGE_TYPE:
                case SD_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 != SD_DHCP_OPTION_PAD);
        assert_se(code != SD_DHCP_OPTION_END);
        assert_se(code != SD_DHCP_OPTION_MESSAGE_TYPE);
        assert_se(code != SD_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, NULL)) == -ENOMSG);
        } else if (desc->success) {
                assert_se((res = dhcp_option_parse(message, buflen, test_options_cb, desc, NULL)) >= 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, NULL)) < 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, SD_DHCP_OPTION_PAD,
                                     0, NULL) == -ENOBUFS);
        assert_se(offset == 0);

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

        offset = pos = 4;
        len = 11;
        while (pos < len && options[pos] != SD_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] == SD_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],
                       SD_DHCP_OPTION_END);

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

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

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