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

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  Copyright © 2014-2015 Intel Corporation. All rights reserved.
***/

#include <errno.h>
#include <netinet/in.h>
#include <string.h>

#include "sd-dhcp6-client.h"

#include "alloc-util.h"
#include "dhcp6-internal.h"
#include "dhcp6-lease-internal.h"
#include "dhcp6-protocol.h"
#include "dns-domain.h"
#include "memory-util.h"
#include "sparse-endian.h"
#include "strv.h"
#include "unaligned.h"

typedef struct DHCP6StatusOption {
        struct DHCP6Option option;
        be16_t status;
        char msg[];
} _packed_ DHCP6StatusOption;

typedef struct DHCP6AddressOption {
        struct DHCP6Option option;
        struct iaaddr iaaddr;
        uint8_t options[];
} _packed_ DHCP6AddressOption;

typedef struct DHCP6PDPrefixOption {
        struct DHCP6Option option;
        struct iapdprefix iapdprefix;
        uint8_t options[];
} _packed_ DHCP6PDPrefixOption;

#define DHCP6_OPTION_IA_NA_LEN (sizeof(struct ia_na))
#define DHCP6_OPTION_IA_PD_LEN (sizeof(struct ia_pd))
#define DHCP6_OPTION_IA_TA_LEN (sizeof(struct ia_ta))

static int option_append_hdr(uint8_t **buf, size_t *buflen, uint16_t optcode,
                             size_t optlen) {
        DHCP6Option *option = (DHCP6Option*) *buf;

        assert_return(buf, -EINVAL);
        assert_return(*buf, -EINVAL);
        assert_return(buflen, -EINVAL);

        if (optlen > 0xffff || *buflen < optlen + offsetof(DHCP6Option, data))
                return -ENOBUFS;

        option->code = htobe16(optcode);
        option->len = htobe16(optlen);

        *buf += offsetof(DHCP6Option, data);
        *buflen -= offsetof(DHCP6Option, data);

        return 0;
}

int dhcp6_option_append(uint8_t **buf, size_t *buflen, uint16_t code,
                        size_t optlen, const void *optval) {
        int r;

        assert_return(optval || optlen == 0, -EINVAL);

        r = option_append_hdr(buf, buflen, code, optlen);
        if (r < 0)
                return r;

        memcpy_safe(*buf, optval, optlen);

        *buf += optlen;
        *buflen -= optlen;

        return 0;
}

int dhcp6_option_append_ia(uint8_t **buf, size_t *buflen, const DHCP6IA *ia) {
        uint16_t len;
        uint8_t *ia_hdr;
        size_t iaid_offset, ia_buflen, ia_addrlen = 0;
        DHCP6Address *addr;
        int r;

        assert_return(buf, -EINVAL);
        assert_return(*buf, -EINVAL);
        assert_return(buflen, -EINVAL);
        assert_return(ia, -EINVAL);

        switch (ia->type) {
        case SD_DHCP6_OPTION_IA_NA:
                len = DHCP6_OPTION_IA_NA_LEN;
                iaid_offset = offsetof(DHCP6IA, ia_na);
                break;

        case SD_DHCP6_OPTION_IA_TA:
                len = DHCP6_OPTION_IA_TA_LEN;
                iaid_offset = offsetof(DHCP6IA, ia_ta);
                break;

        default:
                return -EINVAL;
        }

        if (*buflen < offsetof(DHCP6Option, data) + len)
                return -ENOBUFS;

        ia_hdr = *buf;
        ia_buflen = *buflen;

        *buf += offsetof(DHCP6Option, data);
        *buflen -= offsetof(DHCP6Option, data);

        memcpy(*buf, (char*) ia + iaid_offset, len);

        *buf += len;
        *buflen -= len;

        LIST_FOREACH(addresses, addr, ia->addresses) {
                r = option_append_hdr(buf, buflen, SD_DHCP6_OPTION_IAADDR,
                                      sizeof(addr->iaaddr));
                if (r < 0)
                        return r;

                memcpy(*buf, &addr->iaaddr, sizeof(addr->iaaddr));

                *buf += sizeof(addr->iaaddr);
                *buflen -= sizeof(addr->iaaddr);

                ia_addrlen += offsetof(DHCP6Option, data) + sizeof(addr->iaaddr);
        }

        r = option_append_hdr(&ia_hdr, &ia_buflen, ia->type, len + ia_addrlen);
        if (r < 0)
                return r;

        return 0;
}

int dhcp6_option_append_fqdn(uint8_t **buf, size_t *buflen, const char *fqdn) {
        uint8_t buffer[1 + DNS_WIRE_FORMAT_HOSTNAME_MAX];
        int r;

        assert_return(buf && *buf && buflen && fqdn, -EINVAL);

        buffer[0] = DHCP6_FQDN_FLAG_S; /* Request server to perform AAAA RR DNS updates */

        /* Store domain name after flags field */
        r = dns_name_to_wire_format(fqdn, buffer + 1, sizeof(buffer) - 1,  false);
        if (r <= 0)
                return r;

        /*
         * According to RFC 4704, chapter 4.2 only add terminating zero-length
         * label in case a FQDN is provided. Since dns_name_to_wire_format
         * always adds terminating zero-length label remove if only a hostname
         * is provided.
         */
        if (dns_name_is_single_label(fqdn))
                r--;

        r = dhcp6_option_append(buf, buflen, SD_DHCP6_OPTION_FQDN, 1 + r, buffer);

        return r;
}

int dhcp6_option_append_pd(uint8_t *buf, size_t len, const DHCP6IA *pd) {
        DHCP6Option *option = (DHCP6Option *)buf;
        size_t i = sizeof(*option) + sizeof(pd->ia_pd);
        DHCP6Address *prefix;

        assert_return(buf, -EINVAL);
        assert_return(pd, -EINVAL);
        assert_return(pd->type == SD_DHCP6_OPTION_IA_PD, -EINVAL);

        if (len < i)
                return -ENOBUFS;

        option->code = htobe16(SD_DHCP6_OPTION_IA_PD);

        memcpy(&option->data, &pd->ia_pd, sizeof(pd->ia_pd));

        LIST_FOREACH(addresses, prefix, pd->addresses) {
                DHCP6PDPrefixOption *prefix_opt;

                if (len < i + sizeof(*prefix_opt))
                        return -ENOBUFS;

                prefix_opt = (DHCP6PDPrefixOption *)&buf[i];
                prefix_opt->option.code = htobe16(SD_DHCP6_OPTION_IA_PD_PREFIX);
                prefix_opt->option.len = htobe16(sizeof(prefix_opt->iapdprefix));

                memcpy(&prefix_opt->iapdprefix, &prefix->iapdprefix,
                       sizeof(struct iapdprefix));

                i += sizeof(*prefix_opt);
        }

        option->len = htobe16(i - sizeof(*option));

        return i;
}

static int option_parse_hdr(uint8_t **buf, size_t *buflen, uint16_t *optcode, size_t *optlen) {
        DHCP6Option *option = (DHCP6Option*) *buf;
        uint16_t len;

        assert_return(buf, -EINVAL);
        assert_return(optcode, -EINVAL);
        assert_return(optlen, -EINVAL);

        if (*buflen < offsetof(DHCP6Option, data))
                return -ENOMSG;

        len = be16toh(option->len);

        if (len > *buflen)
                return -ENOMSG;

        *optcode = be16toh(option->code);
        *optlen = len;

        *buf += 4;
        *buflen -= 4;

        return 0;
}

int dhcp6_option_parse(uint8_t **buf, size_t *buflen, uint16_t *optcode,
                       size_t *optlen, uint8_t **optvalue) {
        int r;

        assert_return(buf && buflen && optcode && optlen && optvalue, -EINVAL);

        r = option_parse_hdr(buf, buflen, optcode, optlen);
        if (r < 0)
                return r;

        if (*optlen > *buflen)
                return -ENOBUFS;

        *optvalue = *buf;
        *buflen -= *optlen;
        *buf += *optlen;

        return 0;
}

int dhcp6_option_parse_status(DHCP6Option *option, size_t len) {
        DHCP6StatusOption *statusopt = (DHCP6StatusOption *)option;

        if (len < sizeof(DHCP6StatusOption) ||
            be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(DHCP6StatusOption))
                return -ENOBUFS;

        return be16toh(statusopt->status);
}

static int dhcp6_option_parse_address(DHCP6Option *option, DHCP6IA *ia,
                                      uint32_t *lifetime_valid) {
        DHCP6AddressOption *addr_option = (DHCP6AddressOption *)option;
        DHCP6Address *addr;
        uint32_t lt_valid, lt_pref;
        int r;

        if (be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(*addr_option))
                return -ENOBUFS;

        lt_valid = be32toh(addr_option->iaaddr.lifetime_valid);
        lt_pref = be32toh(addr_option->iaaddr.lifetime_preferred);

        if (lt_valid == 0 || lt_pref > lt_valid) {
                log_dhcp6_client(client, "Valid lifetime of an IA address is zero or preferred lifetime %d > valid lifetime %d",
                                 lt_pref, lt_valid);

                return 0;
        }

        if (be16toh(option->len) + offsetof(DHCP6Option, data) > sizeof(*addr_option)) {
                r = dhcp6_option_parse_status((DHCP6Option *)addr_option->options, be16toh(option->len) + offsetof(DHCP6Option, data) - sizeof(*addr_option));
                if (r != 0)
                        return r < 0 ? r: 0;
        }

        addr = new0(DHCP6Address, 1);
        if (!addr)
                return -ENOMEM;

        LIST_INIT(addresses, addr);
        memcpy(&addr->iaaddr, option->data, sizeof(addr->iaaddr));

        LIST_PREPEND(addresses, ia->addresses, addr);

        *lifetime_valid = be32toh(addr->iaaddr.lifetime_valid);

        return 0;
}

static int dhcp6_option_parse_pdprefix(DHCP6Option *option, DHCP6IA *ia,
                                       uint32_t *lifetime_valid) {
        DHCP6PDPrefixOption *pdprefix_option = (DHCP6PDPrefixOption *)option;
        DHCP6Address *prefix;
        uint32_t lt_valid, lt_pref;
        int r;

        if (be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(*pdprefix_option))
                return -ENOBUFS;

        lt_valid = be32toh(pdprefix_option->iapdprefix.lifetime_valid);
        lt_pref = be32toh(pdprefix_option->iapdprefix.lifetime_preferred);

        if (lt_valid == 0 || lt_pref > lt_valid) {
                log_dhcp6_client(client, "Valid lifetieme of a PD prefix is zero or preferred lifetime %d > valid lifetime %d",
                                 lt_pref, lt_valid);

                return 0;
        }

        if (be16toh(option->len) + offsetof(DHCP6Option, data) > sizeof(*pdprefix_option)) {
                r = dhcp6_option_parse_status((DHCP6Option *)pdprefix_option->options, be16toh(option->len) + offsetof(DHCP6Option, data) - sizeof(*pdprefix_option));
                if (r != 0)
                        return r < 0 ? r: 0;
        }

        prefix = new0(DHCP6Address, 1);
        if (!prefix)
                return -ENOMEM;

        LIST_INIT(addresses, prefix);
        memcpy(&prefix->iapdprefix, option->data, sizeof(prefix->iapdprefix));

        LIST_PREPEND(addresses, ia->addresses, prefix);

        *lifetime_valid = be32toh(prefix->iapdprefix.lifetime_valid);

        return 0;
}

int dhcp6_option_parse_ia(DHCP6Option *iaoption, DHCP6IA *ia) {
        uint16_t iatype, optlen;
        size_t i, len;
        int r = 0, status;
        uint16_t opt;
        size_t iaaddr_offset;
        uint32_t lt_t1, lt_t2, lt_valid = 0, lt_min = UINT32_MAX;

        assert_return(ia, -EINVAL);
        assert_return(!ia->addresses, -EINVAL);

        iatype = be16toh(iaoption->code);
        len = be16toh(iaoption->len);

        switch (iatype) {
        case SD_DHCP6_OPTION_IA_NA:

                if (len < DHCP6_OPTION_IA_NA_LEN)
                        return -ENOBUFS;

                iaaddr_offset = DHCP6_OPTION_IA_NA_LEN;
                memcpy(&ia->ia_na, iaoption->data, sizeof(ia->ia_na));

                lt_t1 = be32toh(ia->ia_na.lifetime_t1);
                lt_t2 = be32toh(ia->ia_na.lifetime_t2);

                if (lt_t1 && lt_t2 && lt_t1 > lt_t2) {
                        log_dhcp6_client(client, "IA NA T1 %ds > T2 %ds",
                                         lt_t1, lt_t2);
                        return -EINVAL;
                }

                break;

        case SD_DHCP6_OPTION_IA_PD:

                if (len < sizeof(ia->ia_pd))
                        return -ENOBUFS;

                iaaddr_offset = sizeof(ia->ia_pd);
                memcpy(&ia->ia_pd, iaoption->data, sizeof(ia->ia_pd));

                lt_t1 = be32toh(ia->ia_pd.lifetime_t1);
                lt_t2 = be32toh(ia->ia_pd.lifetime_t2);

                if (lt_t1 && lt_t2 && lt_t1 > lt_t2) {
                        log_dhcp6_client(client, "IA PD T1 %ds > T2 %ds",
                                         lt_t1, lt_t2);
                        return -EINVAL;
                }

                break;

        case SD_DHCP6_OPTION_IA_TA:
                if (len < DHCP6_OPTION_IA_TA_LEN)
                        return -ENOBUFS;

                iaaddr_offset = DHCP6_OPTION_IA_TA_LEN;
                memcpy(&ia->ia_ta.id, iaoption->data, sizeof(ia->ia_ta));

                break;

        default:
                return -ENOMSG;
        }

        ia->type = iatype;
        i = iaaddr_offset;

        while (i < len) {
                DHCP6Option *option = (DHCP6Option *)&iaoption->data[i];

                if (len < i + sizeof(*option) || len < i + sizeof(*option) + be16toh(option->len))
                        return -ENOBUFS;

                opt = be16toh(option->code);
                optlen = be16toh(option->len);

                switch (opt) {
                case SD_DHCP6_OPTION_IAADDR:

                        if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_NA, SD_DHCP6_OPTION_IA_TA)) {
                                log_dhcp6_client(client, "IA Address option not in IA NA or TA option");
                                return -EINVAL;
                        }

                        r = dhcp6_option_parse_address(option, ia, &lt_valid);
                        if (r < 0)
                                return r;

                        if (lt_valid < lt_min)
                                lt_min = lt_valid;

                        break;

                case SD_DHCP6_OPTION_IA_PD_PREFIX:

                        if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_PD)) {
                                log_dhcp6_client(client, "IA PD Prefix option not in IA PD option");
                                return -EINVAL;
                        }

                        r = dhcp6_option_parse_pdprefix(option, ia, &lt_valid);
                        if (r < 0)
                                return r;

                        if (lt_valid < lt_min)
                                lt_min = lt_valid;

                        break;

                case SD_DHCP6_OPTION_STATUS_CODE:

                        status = dhcp6_option_parse_status(option, optlen + offsetof(DHCP6Option, data));
                        if (status < 0)
                                return status;
                        if (status > 0) {
                                log_dhcp6_client(client, "IA status %d",
                                                 status);

                                return -EINVAL;
                        }

                        break;

                default:
                        log_dhcp6_client(client, "Unknown IA option %d", opt);
                        break;
                }

                i += sizeof(*option) + optlen;
        }

        switch(iatype) {
        case SD_DHCP6_OPTION_IA_NA:
                if (!ia->ia_na.lifetime_t1 && !ia->ia_na.lifetime_t2) {
                        lt_t1 = lt_min / 2;
                        lt_t2 = lt_min / 10 * 8;
                        ia->ia_na.lifetime_t1 = htobe32(lt_t1);
                        ia->ia_na.lifetime_t2 = htobe32(lt_t2);

                        log_dhcp6_client(client, "Computed IA NA T1 %ds and T2 %ds as both were zero",
                                         lt_t1, lt_t2);
                }

                break;

        case SD_DHCP6_OPTION_IA_PD:
                if (!ia->ia_pd.lifetime_t1 && !ia->ia_pd.lifetime_t2) {
                        lt_t1 = lt_min / 2;
                        lt_t2 = lt_min / 10 * 8;
                        ia->ia_pd.lifetime_t1 = htobe32(lt_t1);
                        ia->ia_pd.lifetime_t2 = htobe32(lt_t2);

                        log_dhcp6_client(client, "Computed IA PD T1 %ds and T2 %ds as both were zero",
                                         lt_t1, lt_t2);
                }

                break;

        default:
                break;
        }

        return 0;
}

int dhcp6_option_parse_ip6addrs(uint8_t *optval, uint16_t optlen,
                                struct in6_addr **addrs, size_t count,
                                size_t *allocated) {

        if (optlen == 0 || optlen % sizeof(struct in6_addr) != 0)
                return -EINVAL;

        if (!GREEDY_REALLOC(*addrs, *allocated,
                            count * sizeof(struct in6_addr) + optlen))
                return -ENOMEM;

        memcpy(*addrs + count, optval, optlen);

        count += optlen / sizeof(struct in6_addr);

        return count;
}

int dhcp6_option_parse_domainname(const uint8_t *optval, uint16_t optlen, char ***str_arr) {
        size_t pos = 0, idx = 0;
        _cleanup_strv_free_ char **names = NULL;
        int r;

        assert_return(optlen > 1, -ENODATA);
        assert_return(optval[optlen - 1] == '\0', -EINVAL);

        while (pos < optlen) {
                _cleanup_free_ char *ret = NULL;
                size_t n = 0, allocated = 0;
                bool first = true;

                for (;;) {
                        const char *label;
                        uint8_t c;

                        c = optval[pos++];

                        if (c == 0)
                                /* End of name */
                                break;
                        if (c > 63)
                                return -EBADMSG;

                        /* Literal label */
                        label = (const char *)&optval[pos];
                        pos += c;
                        if (pos >= optlen)
                                return -EMSGSIZE;

                        if (!GREEDY_REALLOC(ret, allocated, n + !first + DNS_LABEL_ESCAPED_MAX))
                                return -ENOMEM;

                        if (first)
                                first = false;
                        else
                                ret[n++] = '.';

                        r = dns_label_escape(label, c, ret + n, DNS_LABEL_ESCAPED_MAX);
                        if (r < 0)
                                return r;

                        n += r;
                }

                if (n == 0)
                        continue;

                if (!GREEDY_REALLOC(ret, allocated, n + 1))
                        return -ENOMEM;

                ret[n] = 0;

                r = strv_extend(&names, ret);
                if (r < 0)
                        return r;

                idx++;
        }

        *str_arr = TAKE_PTR(names);

        return idx;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
f12ed3bf	2	/***
810adae9	3	Copyright © 2014-2015 Intel Corporation. All rights reserved.
f12ed3bf PF	4	***/
f12ed3bf PF	5
f12ed3bf	6	#include <errno.h>
cf0fbc49	7	#include <netinet/in.h>
f12ed3bf PF	8	#include <string.h>
f12ed3bf PF	9
2c1ab8ca BG	10	#include "sd-dhcp6-client.h"
2c1ab8ca BG	11
b5efdb8a	12	#include "alloc-util.h"
f12ed3bf	13	#include "dhcp6-internal.h"
c6b4f32a	14	#include "dhcp6-lease-internal.h"
f12ed3bf	15	#include "dhcp6-protocol.h"
f96ccab7	16	#include "dns-domain.h"
0a970718	17	#include "memory-util.h"
b5efdb8a LP	18	#include "sparse-endian.h"
	19	#include "strv.h"
	20	#include "unaligned.h"
f12ed3bf	21
c6b4f32a PF	22	typedef struct DHCP6StatusOption {
	23	struct DHCP6Option option;
	24	be16_t status;
	25	char msg[];
	26	} _packed_ DHCP6StatusOption;
	27
0dfe2a4b PF	28	typedef struct DHCP6AddressOption {
	29	struct DHCP6Option option;
	30	struct iaaddr iaaddr;
	31	uint8_t options[];
	32	} _packed_ DHCP6AddressOption;
	33
f8ad4dd4 PF	34	typedef struct DHCP6PDPrefixOption {
	35	struct DHCP6Option option;
	36	struct iapdprefix iapdprefix;
	37	uint8_t options[];
	38	} _packed_ DHCP6PDPrefixOption;
	39
990668aa LP	40	#define DHCP6_OPTION_IA_NA_LEN (sizeof(struct ia_na))
	41	#define DHCP6_OPTION_IA_PD_LEN (sizeof(struct ia_pd))
	42	#define DHCP6_OPTION_IA_TA_LEN (sizeof(struct ia_ta))
f12ed3bf PF	43
	44	static int option_append_hdr(uint8_t *buf, size_t buflen, uint16_t optcode,
	45	size_t optlen) {
c962cb68	46	DHCP6Option option = (DHCP6Option) *buf;
4903a73c	47
f12ed3bf PF	48	assert_return(buf, -EINVAL);
	49	assert_return(*buf, -EINVAL);
	50	assert_return(buflen, -EINVAL);
	51
20b55f85	52	if (optlen > 0xffff \|\| *buflen < optlen + offsetof(DHCP6Option, data))
f12ed3bf PF	53	return -ENOBUFS;
f12ed3bf PF	54
c962cb68 TG	55	option->code = htobe16(optcode);
c962cb68 TG	56	option->len = htobe16(optlen);
f12ed3bf	57
20b55f85 LP	58	*buf += offsetof(DHCP6Option, data);
20b55f85 LP	59	*buflen -= offsetof(DHCP6Option, data);
f12ed3bf PF	60
	61	return 0;
	62	}
	63
	64	int dhcp6_option_append(uint8_t *buf, size_t buflen, uint16_t code,
	65	size_t optlen, const void *optval) {
	66	int r;
	67
ed6ee219	68	assert_return(optval \|\| optlen == 0, -EINVAL);
f12ed3bf PF	69
	70	r = option_append_hdr(buf, buflen, code, optlen);
	71	if (r < 0)
	72	return r;
	73
75f32f04	74	memcpy_safe(*buf, optval, optlen);
f12ed3bf PF	75
	76	*buf += optlen;
	77	*buflen -= optlen;
	78
	79	return 0;
	80	}
	81
e0a18b74	82	int dhcp6_option_append_ia(uint8_t *buf, size_t buflen, const DHCP6IA *ia) {
f12ed3bf PF	83	uint16_t len;
f12ed3bf PF	84	uint8_t *ia_hdr;
976fade6	85	size_t iaid_offset, ia_buflen, ia_addrlen = 0;
f12ed3bf PF	86	DHCP6Address *addr;
	87	int r;
	88
3c290c03 LP	89	assert_return(buf, -EINVAL);
	90	assert_return(*buf, -EINVAL);
	91	assert_return(buflen, -EINVAL);
	92	assert_return(ia, -EINVAL);
f12ed3bf PF	93
f12ed3bf PF	94	switch (ia->type) {
2c1ab8ca	95	case SD_DHCP6_OPTION_IA_NA:
f12ed3bf	96	len = DHCP6_OPTION_IA_NA_LEN;
976fade6	97	iaid_offset = offsetof(DHCP6IA, ia_na);
f12ed3bf PF	98	break;
f12ed3bf PF	99
2c1ab8ca	100	case SD_DHCP6_OPTION_IA_TA:
f12ed3bf	101	len = DHCP6_OPTION_IA_TA_LEN;
976fade6	102	iaid_offset = offsetof(DHCP6IA, ia_ta);
f12ed3bf PF	103	break;
	104
	105	default:
	106	return -EINVAL;
	107	}
	108
4dac5eab	109	if (*buflen < offsetof(DHCP6Option, data) + len)
f12ed3bf PF	110	return -ENOBUFS;
	111
	112	ia_hdr = *buf;
	113	ia_buflen = *buflen;
	114
20b55f85 LP	115	*buf += offsetof(DHCP6Option, data);
20b55f85 LP	116	*buflen -= offsetof(DHCP6Option, data);
f12ed3bf	117
976fade6	118	memcpy(buf, (char) ia + iaid_offset, len);
f12ed3bf PF	119
	120	*buf += len;
	121	*buflen -= len;
	122
	123	LIST_FOREACH(addresses, addr, ia->addresses) {
2c1ab8ca	124	r = option_append_hdr(buf, buflen, SD_DHCP6_OPTION_IAADDR,
ee3a5027	125	sizeof(addr->iaaddr));
f12ed3bf PF	126	if (r < 0)
	127	return r;
	128
ee3a5027	129	memcpy(*buf, &addr->iaaddr, sizeof(addr->iaaddr));
f12ed3bf	130
ee3a5027 PF	131	*buf += sizeof(addr->iaaddr);
ee3a5027 PF	132	*buflen -= sizeof(addr->iaaddr);
f12ed3bf	133
20b55f85	134	ia_addrlen += offsetof(DHCP6Option, data) + sizeof(addr->iaaddr);
f12ed3bf PF	135	}
	136
	137	r = option_append_hdr(&ia_hdr, &ia_buflen, ia->type, len + ia_addrlen);
	138	if (r < 0)
	139	return r;
	140
	141	return 0;
	142	}
	143
8006aa32	144	int dhcp6_option_append_fqdn(uint8_t *buf, size_t buflen, const char *fqdn) {
5e55cde9	145	uint8_t buffer[1 + DNS_WIRE_FORMAT_HOSTNAME_MAX];
8006aa32 SA	146	int r;
	147
	148	assert_return(buf && *buf && buflen && fqdn, -EINVAL);
	149
	150	buffer[0] = DHCP6_FQDN_FLAG_S; /* Request server to perform AAAA RR DNS updates */
	151
	152	/* Store domain name after flags field */
	153	r = dns_name_to_wire_format(fqdn, buffer + 1, sizeof(buffer) - 1, false);
	154	if (r <= 0)
	155	return r;
	156
	157	/*
	158	* According to RFC 4704, chapter 4.2 only add terminating zero-length
	159	* label in case a FQDN is provided. Since dns_name_to_wire_format
	160	* always adds terminating zero-length label remove if only a hostname
	161	* is provided.
	162	*/
	163	if (dns_name_is_single_label(fqdn))
	164	r--;
	165
	166	r = dhcp6_option_append(buf, buflen, SD_DHCP6_OPTION_FQDN, 1 + r, buffer);
	167
	168	return r;
	169	}
	170
e0a18b74	171	int dhcp6_option_append_pd(uint8_t buf, size_t len, const DHCP6IA pd) {
c77e3db1 PF	172	DHCP6Option option = (DHCP6Option )buf;
	173	size_t i = sizeof(*option) + sizeof(pd->ia_pd);
	174	DHCP6Address *prefix;
	175
	176	assert_return(buf, -EINVAL);
	177	assert_return(pd, -EINVAL);
	178	assert_return(pd->type == SD_DHCP6_OPTION_IA_PD, -EINVAL);
	179
	180	if (len < i)
	181	return -ENOBUFS;
	182
	183	option->code = htobe16(SD_DHCP6_OPTION_IA_PD);
	184
	185	memcpy(&option->data, &pd->ia_pd, sizeof(pd->ia_pd));
	186
	187	LIST_FOREACH(addresses, prefix, pd->addresses) {
	188	DHCP6PDPrefixOption *prefix_opt;
	189
	190	if (len < i + sizeof(*prefix_opt))
	191	return -ENOBUFS;
	192
	193	prefix_opt = (DHCP6PDPrefixOption *)&buf[i];
	194	prefix_opt->option.code = htobe16(SD_DHCP6_OPTION_IA_PD_PREFIX);
	195	prefix_opt->option.len = htobe16(sizeof(prefix_opt->iapdprefix));
	196
	197	memcpy(&prefix_opt->iapdprefix, &prefix->iapdprefix,
	198	sizeof(struct iapdprefix));
	199
	200	i += sizeof(*prefix_opt);
	201	}
	202
	203	option->len = htobe16(i - sizeof(*option));
	204
	205	return i;
	206	}
c6affce8	207
c962cb68 TG	208	static int option_parse_hdr(uint8_t *buf, size_t buflen, uint16_t optcode, size_t optlen) {
c962cb68 TG	209	DHCP6Option option = (DHCP6Option) *buf;
c6affce8 PF	210	uint16_t len;
	211
	212	assert_return(buf, -EINVAL);
4903a73c	213	assert_return(optcode, -EINVAL);
c6affce8 PF	214	assert_return(optlen, -EINVAL);
c6affce8 PF	215
20b55f85	216	if (*buflen < offsetof(DHCP6Option, data))
c6affce8 PF	217	return -ENOMSG;
c6affce8 PF	218
c962cb68	219	len = be16toh(option->len);
c6affce8 PF	220
	221	if (len > *buflen)
	222	return -ENOMSG;
	223
c962cb68	224	*optcode = be16toh(option->code);
c6affce8 PF	225	*optlen = len;
	226
	227	*buf += 4;
	228	*buflen -= 4;
	229
	230	return 0;
	231	}
	232
f12ed3bf PF	233	int dhcp6_option_parse(uint8_t *buf, size_t buflen, uint16_t *optcode,
f12ed3bf PF	234	size_t optlen, uint8_t *optvalue) {
c6affce8	235	int r;
f12ed3bf	236
c6affce8	237	assert_return(buf && buflen && optcode && optlen && optvalue, -EINVAL);
f12ed3bf	238
c6affce8 PF	239	r = option_parse_hdr(buf, buflen, optcode, optlen);
	240	if (r < 0)
	241	return r;
f12ed3bf	242
c6affce8	243	if (optlen > buflen)
f12ed3bf PF	244	return -ENOBUFS;
f12ed3bf PF	245
c6affce8 PF	246	optvalue = buf;
	247	buflen -= optlen;
	248	buf += optlen;
f12ed3bf PF	249
	250	return 0;
	251	}
c6affce8	252
84452783	253	int dhcp6_option_parse_status(DHCP6Option *option, size_t len) {
c6b4f32a PF	254	DHCP6StatusOption statusopt = (DHCP6StatusOption )option;
c6b4f32a PF	255
84452783	256	if (len < sizeof(DHCP6StatusOption) \|\|
20b55f85	257	be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(DHCP6StatusOption))
c6b4f32a PF	258	return -ENOBUFS;
	259
	260	return be16toh(statusopt->status);
	261	}
	262
0dfe2a4b PF	263	static int dhcp6_option_parse_address(DHCP6Option option, DHCP6IA ia,
	264	uint32_t *lifetime_valid) {
	265	DHCP6AddressOption addr_option = (DHCP6AddressOption )option;
	266	DHCP6Address *addr;
	267	uint32_t lt_valid, lt_pref;
	268	int r;
	269
20b55f85	270	if (be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(*addr_option))
0dfe2a4b PF	271	return -ENOBUFS;
	272
	273	lt_valid = be32toh(addr_option->iaaddr.lifetime_valid);
	274	lt_pref = be32toh(addr_option->iaaddr.lifetime_preferred);
	275
	276	if (lt_valid == 0 \|\| lt_pref > lt_valid) {
	277	log_dhcp6_client(client, "Valid lifetime of an IA address is zero or preferred lifetime %d > valid lifetime %d",
	278	lt_pref, lt_valid);
	279
	280	return 0;
	281	}
	282
20b55f85 LP	283	if (be16toh(option->len) + offsetof(DHCP6Option, data) > sizeof(*addr_option)) {
20b55f85 LP	284	r = dhcp6_option_parse_status((DHCP6Option )addr_option->options, be16toh(option->len) + offsetof(DHCP6Option, data) - sizeof(addr_option));
0dfe2a4b PF	285	if (r != 0)
	286	return r < 0 ? r: 0;
	287	}
	288
	289	addr = new0(DHCP6Address, 1);
	290	if (!addr)
	291	return -ENOMEM;
	292
	293	LIST_INIT(addresses, addr);
	294	memcpy(&addr->iaaddr, option->data, sizeof(addr->iaaddr));
	295
	296	LIST_PREPEND(addresses, ia->addresses, addr);
	297
	298	*lifetime_valid = be32toh(addr->iaaddr.lifetime_valid);
	299
	300	return 0;
	301	}
	302
f8ad4dd4 PF	303	static int dhcp6_option_parse_pdprefix(DHCP6Option option, DHCP6IA ia,
	304	uint32_t *lifetime_valid) {
	305	DHCP6PDPrefixOption pdprefix_option = (DHCP6PDPrefixOption )option;
	306	DHCP6Address *prefix;
	307	uint32_t lt_valid, lt_pref;
	308	int r;
	309
20b55f85	310	if (be16toh(option->len) + offsetof(DHCP6Option, data) < sizeof(*pdprefix_option))
f8ad4dd4 PF	311	return -ENOBUFS;
	312
	313	lt_valid = be32toh(pdprefix_option->iapdprefix.lifetime_valid);
	314	lt_pref = be32toh(pdprefix_option->iapdprefix.lifetime_preferred);
	315
	316	if (lt_valid == 0 \|\| lt_pref > lt_valid) {
	317	log_dhcp6_client(client, "Valid lifetieme of a PD prefix is zero or preferred lifetime %d > valid lifetime %d",
	318	lt_pref, lt_valid);
	319
	320	return 0;
	321	}
	322
20b55f85 LP	323	if (be16toh(option->len) + offsetof(DHCP6Option, data) > sizeof(*pdprefix_option)) {
20b55f85 LP	324	r = dhcp6_option_parse_status((DHCP6Option )pdprefix_option->options, be16toh(option->len) + offsetof(DHCP6Option, data) - sizeof(pdprefix_option));
f8ad4dd4 PF	325	if (r != 0)
	326	return r < 0 ? r: 0;
	327	}
	328
	329	prefix = new0(DHCP6Address, 1);
	330	if (!prefix)
	331	return -ENOMEM;
	332
	333	LIST_INIT(addresses, prefix);
	334	memcpy(&prefix->iapdprefix, option->data, sizeof(prefix->iapdprefix));
	335
	336	LIST_PREPEND(addresses, ia->addresses, prefix);
	337
	338	*lifetime_valid = be32toh(prefix->iapdprefix.lifetime_valid);
	339
	340	return 0;
	341	}
	342
3bc424a3 PF	343	int dhcp6_option_parse_ia(DHCP6Option iaoption, DHCP6IA ia) {
	344	uint16_t iatype, optlen;
	345	size_t i, len;
	346	int r = 0, status;
	347	uint16_t opt;
c6affce8	348	size_t iaaddr_offset;
3c035649	349	uint32_t lt_t1, lt_t2, lt_valid = 0, lt_min = UINT32_MAX;
c6affce8 PF	350
	351	assert_return(ia, -EINVAL);
	352	assert_return(!ia->addresses, -EINVAL);
	353
3bc424a3 PF	354	iatype = be16toh(iaoption->code);
	355	len = be16toh(iaoption->len);
	356
c6affce8	357	switch (iatype) {
2c1ab8ca	358	case SD_DHCP6_OPTION_IA_NA:
c6affce8	359
aae1fa5c YW	360	if (len < DHCP6_OPTION_IA_NA_LEN)
aae1fa5c YW	361	return -ENOBUFS;
c6affce8 PF	362
c6affce8 PF	363	iaaddr_offset = DHCP6_OPTION_IA_NA_LEN;
3bc424a3	364	memcpy(&ia->ia_na, iaoption->data, sizeof(ia->ia_na));
c6affce8	365
e0026dcb PF	366	lt_t1 = be32toh(ia->ia_na.lifetime_t1);
e0026dcb PF	367	lt_t2 = be32toh(ia->ia_na.lifetime_t2);
c6affce8 PF	368
c6affce8 PF	369	if (lt_t1 && lt_t2 && lt_t1 > lt_t2) {
f8ad4dd4 PF	370	log_dhcp6_client(client, "IA NA T1 %ds > T2 %ds",
f8ad4dd4 PF	371	lt_t1, lt_t2);
aae1fa5c	372	return -EINVAL;
f8ad4dd4 PF	373	}
	374
	375	break;
	376
	377	case SD_DHCP6_OPTION_IA_PD:
	378
aae1fa5c YW	379	if (len < sizeof(ia->ia_pd))
aae1fa5c YW	380	return -ENOBUFS;
f8ad4dd4 PF	381
	382	iaaddr_offset = sizeof(ia->ia_pd);
	383	memcpy(&ia->ia_pd, iaoption->data, sizeof(ia->ia_pd));
	384
	385	lt_t1 = be32toh(ia->ia_pd.lifetime_t1);
	386	lt_t2 = be32toh(ia->ia_pd.lifetime_t2);
	387
	388	if (lt_t1 && lt_t2 && lt_t1 > lt_t2) {
	389	log_dhcp6_client(client, "IA PD T1 %ds > T2 %ds",
c6affce8	390	lt_t1, lt_t2);
aae1fa5c	391	return -EINVAL;
c6affce8 PF	392	}
	393
	394	break;
	395
2c1ab8ca	396	case SD_DHCP6_OPTION_IA_TA:
aae1fa5c YW	397	if (len < DHCP6_OPTION_IA_TA_LEN)
aae1fa5c YW	398	return -ENOBUFS;
c6affce8 PF	399
c6affce8 PF	400	iaaddr_offset = DHCP6_OPTION_IA_TA_LEN;
3bc424a3	401	memcpy(&ia->ia_ta.id, iaoption->data, sizeof(ia->ia_ta));
c6affce8 PF	402
	403	break;
	404
	405	default:
aae1fa5c	406	return -ENOMSG;
c6affce8 PF	407	}
	408
	409	ia->type = iatype;
3bc424a3 PF	410	i = iaaddr_offset;
	411
	412	while (i < len) {
	413	DHCP6Option option = (DHCP6Option )&iaoption->data[i];
c6affce8	414
aae1fa5c YW	415	if (len < i + sizeof(option) \|\| len < i + sizeof(option) + be16toh(option->len))
aae1fa5c YW	416	return -ENOBUFS;
c6affce8	417
3bc424a3 PF	418	opt = be16toh(option->code);
3bc424a3 PF	419	optlen = be16toh(option->len);
c6affce8 PF	420
c6affce8 PF	421	switch (opt) {
2c1ab8ca	422	case SD_DHCP6_OPTION_IAADDR:
0dfe2a4b	423
f8ad4dd4 PF	424	if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_NA, SD_DHCP6_OPTION_IA_TA)) {
f8ad4dd4 PF	425	log_dhcp6_client(client, "IA Address option not in IA NA or TA option");
aae1fa5c	426	return -EINVAL;
f8ad4dd4 PF	427	}
f8ad4dd4 PF	428
0dfe2a4b PF	429	r = dhcp6_option_parse_address(option, ia, &lt_valid);
0dfe2a4b PF	430	if (r < 0)
aae1fa5c	431	return r;
0dfe2a4b PF	432
	433	if (lt_valid < lt_min)
	434	lt_min = lt_valid;
c6affce8 PF	435
	436	break;
	437
f8ad4dd4 PF	438	case SD_DHCP6_OPTION_IA_PD_PREFIX:
	439
	440	if (!IN_SET(ia->type, SD_DHCP6_OPTION_IA_PD)) {
	441	log_dhcp6_client(client, "IA PD Prefix option not in IA PD option");
aae1fa5c	442	return -EINVAL;
f8ad4dd4 PF	443	}
	444
	445	r = dhcp6_option_parse_pdprefix(option, ia, &lt_valid);
	446	if (r < 0)
aae1fa5c	447	return r;
f8ad4dd4 PF	448
	449	if (lt_valid < lt_min)
	450	lt_min = lt_valid;
	451
	452	break;
	453
2c1ab8ca	454	case SD_DHCP6_OPTION_STATUS_CODE:
c6affce8	455
20b55f85	456	status = dhcp6_option_parse_status(option, optlen + offsetof(DHCP6Option, data));
aae1fa5c YW	457	if (status < 0)
aae1fa5c YW	458	return status;
91c43f39	459	if (status > 0) {
c6affce8 PF	460	log_dhcp6_client(client, "IA status %d",
c6affce8 PF	461	status);
c6b4f32a	462
aae1fa5c	463	return -EINVAL;
c6affce8 PF	464	}
	465
	466	break;
	467
	468	default:
	469	log_dhcp6_client(client, "Unknown IA option %d", opt);
	470	break;
	471	}
	472
3bc424a3	473	i += sizeof(*option) + optlen;
c6affce8 PF	474	}
c6affce8 PF	475
f8ad4dd4 PF	476	switch(iatype) {
	477	case SD_DHCP6_OPTION_IA_NA:
	478	if (!ia->ia_na.lifetime_t1 && !ia->ia_na.lifetime_t2) {
	479	lt_t1 = lt_min / 2;
	480	lt_t2 = lt_min / 10 * 8;
	481	ia->ia_na.lifetime_t1 = htobe32(lt_t1);
	482	ia->ia_na.lifetime_t2 = htobe32(lt_t2);
	483
	484	log_dhcp6_client(client, "Computed IA NA T1 %ds and T2 %ds as both were zero",
	485	lt_t1, lt_t2);
	486	}
	487
	488	break;
	489
	490	case SD_DHCP6_OPTION_IA_PD:
	491	if (!ia->ia_pd.lifetime_t1 && !ia->ia_pd.lifetime_t2) {
	492	lt_t1 = lt_min / 2;
	493	lt_t2 = lt_min / 10 * 8;
	494	ia->ia_pd.lifetime_t1 = htobe32(lt_t1);
	495	ia->ia_pd.lifetime_t2 = htobe32(lt_t2);
	496
	497	log_dhcp6_client(client, "Computed IA PD T1 %ds and T2 %ds as both were zero",
	498	lt_t1, lt_t2);
	499	}
c6affce8	500
f8ad4dd4 PF	501	break;
	502
	503	default:
	504	break;
c6affce8 PF	505	}
c6affce8 PF	506
aae1fa5c	507	return 0;
c6affce8	508	}
b553817c PF	509
	510	int dhcp6_option_parse_ip6addrs(uint8_t *optval, uint16_t optlen,
	511	struct in6_addr **addrs, size_t count,
	512	size_t *allocated) {
	513
	514	if (optlen == 0 \|\| optlen % sizeof(struct in6_addr) != 0)
	515	return -EINVAL;
	516
	517	if (!GREEDY_REALLOC(addrs, allocated,
	518	count * sizeof(struct in6_addr) + optlen))
	519	return -ENOMEM;
	520
	521	memcpy(*addrs + count, optval, optlen);
	522
	523	count += optlen / sizeof(struct in6_addr);
	524
	525	return count;
	526	}
f96ccab7	527
52efd56a	528	int dhcp6_option_parse_domainname(const uint8_t optval, uint16_t optlen, char **str_arr) {
f96ccab7	529	size_t pos = 0, idx = 0;
419eaa8f	530	_cleanup_strv_free_ char **names = NULL;
f96ccab7 PF	531	int r;
	532
	533	assert_return(optlen > 1, -ENODATA);
93f660da	534	assert_return(optval[optlen - 1] == '\0', -EINVAL);
f96ccab7 PF	535
	536	while (pos < optlen) {
	537	_cleanup_free_ char *ret = NULL;
	538	size_t n = 0, allocated = 0;
	539	bool first = true;
	540
	541	for (;;) {
3c72b6ed	542	const char *label;
f96ccab7 PF	543	uint8_t c;
	544
	545	c = optval[pos++];
	546
	547	if (c == 0)
	548	/* End of name */
	549	break;
3c72b6ed YW	550	if (c > 63)
	551	return -EBADMSG;
	552
	553	/* Literal label */
	554	label = (const char *)&optval[pos];
	555	pos += c;
	556	if (pos >= optlen)
	557	return -EMSGSIZE;
	558
	559	if (!GREEDY_REALLOC(ret, allocated, n + !first + DNS_LABEL_ESCAPED_MAX))
	560	return -ENOMEM;
	561
	562	if (first)
	563	first = false;
	564	else
	565	ret[n++] = '.';
	566
	567	r = dns_label_escape(label, c, ret + n, DNS_LABEL_ESCAPED_MAX);
	568	if (r < 0)
	569	return r;
f96ccab7	570
3c72b6ed	571	n += r;
f96ccab7 PF	572	}
f96ccab7 PF	573
3c72b6ed YW	574	if (n == 0)
	575	continue;
	576
	577	if (!GREEDY_REALLOC(ret, allocated, n + 1))
	578	return -ENOMEM;
	579
f96ccab7 PF	580	ret[n] = 0;
	581
	582	r = strv_extend(&names, ret);
	583	if (r < 0)
3c72b6ed	584	return r;
f96ccab7	585
f96ccab7 PF	586	idx++;
	587	}
	588
ae2a15bc	589	*str_arr = TAKE_PTR(names);
f96ccab7 PF	590
f96ccab7 PF	591	return idx;
f96ccab7	592	}