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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <net/if_arp.h>
#include <stdio.h>
#include <string.h>

#include "alloc-util.h"
#include "dhcp-option.h"
#include "dhcp-packet.h"
#include "memory-util.h"
#include "tests.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,
                                    ARPHRD_ETHER, ETH_ALEN, (uint8_t[16]){}, DHCP_DISCOVER,
                                    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_se(*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;

        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 (unsigned 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 void test_option_removal(struct option_desc *desc) {
        _cleanup_free_ DHCPMessage *message = create_message(&desc->options[0], desc->len, NULL, 0, NULL, 0);

        assert_se(dhcp_option_parse(message, sizeof(DHCPMessage) + desc->len, NULL, NULL, NULL) >= 0);
        assert_se((desc->len = dhcp_option_remove_option(message->options, desc->len, SD_DHCP_OPTION_MESSAGE_TYPE)) >= 0);
        assert_se(dhcp_option_parse(message, sizeof(DHCPMessage) + desc->len, NULL, NULL, NULL) < 0);
}

static uint8_t the_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;

        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 && the_options[pos] != SD_DHCP_OPTION_END) {
                assert_se(dhcp_option_append(result, len, &offset, DHCP_OVERLOAD_SNAME,
                                             the_options[pos],
                                             the_options[pos + 1],
                                             &the_options[pos + 2]) >= 0);

                if (the_options[pos] == SD_DHCP_OPTION_PAD)
                        pos++;
                else
                        pos += 2 + the_options[pos + 1];

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

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

        if (verbose)
                printf("%2d: 0x%02x(0x%02x) (options)\n", 9, result->options[9],
                       (unsigned) 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],
                       (unsigned) SD_DHCP_OPTION_PAD);

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

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

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

int main(int argc, char *argv[]) {
        test_setup_logging(LOG_DEBUG);

        test_invalid_buffer_length();
        test_message_init();

        test_options(NULL);

        FOREACH_ELEMENT(desc, option_tests)
                test_options(desc);

        test_option_set();

        FOREACH_ELEMENT(desc, option_tests) {
                if (!desc->success || desc->snamelen > 0 || desc->filelen > 0)
                        continue;
                test_option_removal(desc);
        }

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