HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd-network/dhcp-message.c
Git blob: c6ec2d7b4ce920b335efbd1c20cae01ca1224002
Lines 1–1000 of 1,803
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if_arp.h>
#include "alloc-util.h"
#include "dhcp-client-id-internal.h"
#include "dhcp-message.h"
#include "dhcp-route.h"
#include "dns-def.h"
#include "dns-domain.h"
#include "dns-resolver-internal.h"
#include "errno-util.h"
#include "ether-addr-util.h"
#include "hostname-util.h"
#include "in-addr-util.h"
#include "iovec-util.h"
#include "iovec-wrapper.h"
#include "ip-util.h"
#include "json-util.h"
#include "network-common.h"
#include "set.h"
#include "socket-util.h"
#include "sort-util.h"
#include "string-util.h"
#include "unaligned.h"
static sd_dhcp_message* dhcp_message_free(sd_dhcp_message *message) {
if (!message)
return NULL;
tlv_done(&message->options);
return mfree(message);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_message, sd_dhcp_message, dhcp_message_free);
int dhcp_message_new(sd_dhcp_message **ret) {
assert(ret);
sd_dhcp_message *message = new(sd_dhcp_message, 1);
if (!message)
return -ENOMEM;
*message = (sd_dhcp_message) {
.n_ref = 1,
.options = TLV_INIT(TLV_DHCP4),
};
*ret = TAKE_PTR(message);
return 0;
}
int dhcp_message_init_header(
sd_dhcp_message *message,
uint8_t op,
uint32_t xid,
uint16_t arp_type,
const struct hw_addr_data *hw_addr) {
assert(message);
assert(IN_SET(op, BOOTREQUEST, BOOTREPLY));
/* RFC 2131 section 4.1.1:
* The client MUST include its hardware address in the ’chaddr’ field, if necessary for delivery of
* DHCP reply messages.
*
* RFC 4390 section 2.1:
* A DHCP client, when working over an IPoIB interface, MUST follow the following rules:
* "htype" (hardware address type) MUST be 32 [ARPPARAM].
* "hlen" (hardware address length) MUST be 0.
* "chaddr" (client hardware address) field MUST be zeroed.
*
* Note, the maximum hardware address length (HW_ADDR_MAX_SIZE) is 32, but the size of the chaddr
* field is 16.
*
* Also, ARP type is 2 bytes, but the htype field is 1 byte. */
if (arp_type == ARPHRD_INFINIBAND)
hw_addr = NULL;
if (hw_addr && hw_addr->length > sizeof_field(DHCPMessageHeader, chaddr))
return -EINVAL;
message->header = (DHCPMessageHeader) {
.op = op,
.htype = arp_type <= UINT8_MAX ? arp_type : 0,
.hlen = hw_addr ? hw_addr->length : 0,
.xid = htobe32(xid),
.magic = htobe32(DHCP_MAGIC_COOKIE),
};
if (hw_addr)
memcpy_safe(message->header.chaddr, hw_addr->bytes, hw_addr->length);
return 0;
}
void dhcp_message_set_broadcast_flag(sd_dhcp_message *message, bool b) {
assert(message);
SET_FLAG(message->header.flags, htobe16(0x8000), b);
}
bool dhcp_message_has_broadcast_flag(sd_dhcp_message *message) {
assert(message);
return FLAGS_SET(message->header.flags, htobe16(0x8000));
}
int dhcp_message_get_hw_addr(sd_dhcp_message *message, struct hw_addr_data *ret) {
assert(message);
assert(ret);
if (message->header.hlen > sizeof_field(DHCPMessageHeader, chaddr))
return -EBADMSG;
ret->length = message->header.hlen;
memcpy_safe(ret->bytes, message->header.chaddr, message->header.hlen);
return 0;
}
bool dhcp_message_has_option(sd_dhcp_message *message, uint8_t code) {
assert(message);
return tlv_contains(&message->options, code);
}
void dhcp_message_remove_option(sd_dhcp_message *message, uint8_t code) {
assert(message);
tlv_remove(&message->options, code);
}
int dhcp_message_append_option(sd_dhcp_message *message, uint8_t code, size_t length, const void *data) {
assert(message);
return tlv_append(&message->options, code, length, data);
}
int dhcp_message_append_option_tlv(sd_dhcp_message *message, const TLV *tlv) {
assert(message);
return tlv_append_tlv(&message->options, tlv);
}
int dhcp_message_append_option_flag(sd_dhcp_message *message, uint8_t code) {
assert(message);
if (dhcp_message_has_option(message, code))
return -EEXIST;
return dhcp_message_append_option(message, code, /* length= */ 0, /* data= */ NULL);
}
int dhcp_message_append_option_u8(sd_dhcp_message *message, uint8_t code, uint8_t data) {
assert(message);
if (dhcp_message_has_option(message, code))
return -EEXIST;
return dhcp_message_append_option(message, code, sizeof(uint8_t), &data);
}
int dhcp_message_append_option_u16(sd_dhcp_message *message, uint8_t code, uint16_t data) {
assert(message);
if (dhcp_message_has_option(message, code))
return -EEXIST;
be16_t b = htobe16(data);
return dhcp_message_append_option(message, code, sizeof(be16_t), &b);
}
int dhcp_message_append_option_be32(sd_dhcp_message *message, uint8_t code, be32_t data) {
assert(message);
if (dhcp_message_has_option(message, code))
return -EEXIST;
return dhcp_message_append_option(message, code, sizeof(be32_t), &data);
}
int dhcp_message_append_option_sec(sd_dhcp_message *message, uint8_t code, usec_t usec) {
assert(message);
return dhcp_message_append_option_be32(message, code, usec_to_be32_sec(usec));
}
int dhcp_message_append_option_address(sd_dhcp_message *message, uint8_t code, const struct in_addr *addr) {
assert(message);
assert(addr);
return dhcp_message_append_option_be32(message, code, addr->s_addr);
}
int dhcp_message_append_option_addresses(sd_dhcp_message *message, uint8_t code, size_t n_addr, const struct in_addr *addr) {
assert(message);
assert(n_addr == 0 || addr);
if (n_addr == 0)
return 0;
if (size_multiply_overflow(sizeof(struct in_addr), n_addr))
return -ENOBUFS;
if (code == SD_DHCP_OPTION_SIP_SERVER) {
if (dhcp_message_has_option(message, SD_DHCP_OPTION_SIP_SERVER))
return -EEXIST;
size_t len = size_add(1, sizeof(struct in_addr) * n_addr);
if (len == SIZE_MAX)
return -ENOBUFS;
_cleanup_free_ uint8_t *buf = new(uint8_t, len);
if (!buf)
return -ENOMEM;
buf[0] = 1; /* 'enc' field, 0: domains, 1: addresses */
memcpy(buf + 1, addr, sizeof(struct in_addr) * n_addr);
return dhcp_message_append_option(message, code, len, buf);
}
return dhcp_message_append_option(message, code, sizeof(struct in_addr) * n_addr, addr);
}
int dhcp_message_append_option_string(sd_dhcp_message *message, uint8_t code, const char *data) {
assert(message);
if (isempty(data))
return 0;
if (!string_is_safe(data, STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS))
return -EINVAL;
if (dhcp_message_has_option(message, code))
return -EEXIST;
return dhcp_message_append_option(message, code, strlen(data), data);
}
static int dhcp_message_append_option_static_routes(sd_dhcp_message *message, size_t n_routes, const sd_dhcp_route *routes) {
int r;
assert(message);
assert(routes || n_routes == 0);
if (n_routes == 0)
return 0;
if (size_multiply_overflow(2 * sizeof(struct in_addr), n_routes))
return -ENOBUFS;
_cleanup_free_ struct in_addr *buf = new(struct in_addr, 2 * n_routes);
if (!buf)
return -ENOMEM;
size_t count = 0;
FOREACH_ARRAY(route, routes, n_routes) {
uint8_t prefixlen;
r = in4_addr_default_prefixlen(&route->dst_addr, &prefixlen);
if (r < 0)
return r;
if (prefixlen != route->dst_prefixlen)
return -EINVAL;
struct in_addr dst = route->dst_addr;
(void) in4_addr_mask(&dst, prefixlen);
buf[count++] = dst;
buf[count++] = route->gw_addr;
}
assert(count == 2 * n_routes);
return dhcp_message_append_option_addresses(message, SD_DHCP_OPTION_STATIC_ROUTE, 2 * n_routes, buf);
}
static int dhcp_message_append_option_classless_static_routes(sd_dhcp_message *message, uint8_t code, size_t n_routes, const sd_dhcp_route *routes) {
assert(message);
assert(routes || n_routes == 0);
assert(IN_SET(code,
SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE,
SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE));
if (n_routes == 0)
return 0;
if (size_multiply_overflow(1 + 2 * sizeof(struct in_addr), n_routes))
return -ENOBUFS;
_cleanup_free_ uint8_t *buf = new(uint8_t, (1 + 2 * sizeof(struct in_addr)) * n_routes);
if (!buf)
return -ENOMEM;
uint8_t *p = buf;
FOREACH_ARRAY(route, routes, n_routes) {
if (route->dst_prefixlen > sizeof(struct in_addr) * 8)
return -EINVAL;
*p++ = route->dst_prefixlen;
struct in_addr dst = route->dst_addr;
(void) in4_addr_mask(&dst, route->dst_prefixlen);
p = mempcpy(p, &dst, DIV_ROUND_UP(route->dst_prefixlen, 8));
p = mempcpy(p, &route->gw_addr, sizeof(struct in_addr));
}
return dhcp_message_append_option(message, code, p - buf, buf);
}
int dhcp_message_append_option_routes(sd_dhcp_message *message, uint8_t code, size_t n_routes, const sd_dhcp_route *routes) {
switch (code) {
case SD_DHCP_OPTION_STATIC_ROUTE:
return dhcp_message_append_option_static_routes(message, n_routes, routes);
case SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
case SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE:
return dhcp_message_append_option_classless_static_routes(message, code, n_routes, routes);
default:
return -EINVAL;
}
}
int dhcp_message_append_option_6rd(
sd_dhcp_message *message,
uint8_t ipv4masklen,
uint8_t prefixlen,
const struct in6_addr *prefix,
size_t n_br_addresses,
const struct in_addr *br_addresses) {
assert(message);
assert(prefix);
assert(n_br_addresses == 0 || br_addresses);
/* See RFC 5969 Section 7.1.1 and dhcp_message_get_option_6rd() below. */
if (dhcp_message_has_option(message, SD_DHCP_OPTION_6RD))
return -EEXIST;
if (ipv4masklen > 32)
return -EINVAL;
if (32 - ipv4masklen + prefixlen > 128)
return -EINVAL;
if (32 - ipv4masklen + prefixlen == 0)
return -EINVAL;
if (n_br_addresses == 0)
return -EINVAL;
if (size_multiply_overflow(sizeof(struct in_addr), n_br_addresses))
return -ENOBUFS;
size_t buflen = size_add(2 + sizeof(struct in6_addr), sizeof(struct in_addr) * n_br_addresses);
if (buflen == SIZE_MAX)
return -ENOBUFS;
_cleanup_free_ uint8_t *buf = new(uint8_t, buflen);
if (!buf)
return -ENOMEM;
uint8_t *p = buf;
*p++ = ipv4masklen;
*p++ = prefixlen;
struct in6_addr masked = *prefix;
(void) in6_addr_mask(&masked, prefixlen);
p = mempcpy(p, &masked, sizeof(struct in6_addr));
memcpy(p, br_addresses, n_br_addresses * sizeof(struct in_addr));
return dhcp_message_append_option(message, SD_DHCP_OPTION_6RD, buflen, buf);
}
int dhcp_message_append_option_client_id(sd_dhcp_message *message, const sd_dhcp_client_id *id) {
assert(message);
assert(id);
if (!sd_dhcp_client_id_is_set(id))
return -EINVAL;
if (dhcp_message_has_option(message, SD_DHCP_OPTION_CLIENT_IDENTIFIER))
return -EEXIST;
return dhcp_message_append_option(message, SD_DHCP_OPTION_CLIENT_IDENTIFIER, id->size, id->raw);
}
static int cmp_uint8(const uint8_t *a, const uint8_t *b) {
assert(a);
assert(b);
return CMP(*a, *b);
}
int dhcp_message_append_option_parameter_request_list(sd_dhcp_message *message, Set *prl) {
assert(message);
size_t len = set_size(prl);
if (len == 0)
return 0;
_cleanup_free_ uint8_t *buf = new(uint8_t, len);
if (!buf)
return -ENOMEM;
uint8_t *p = buf;
void *q;
SET_FOREACH(q, prl)
*p++ = PTR_TO_UINT8(q);
/* Sort the options to make the message reproducible. */
typesafe_qsort(buf, len, cmp_uint8);
return dhcp_message_append_option(message, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST, len, buf);
}
static int dhcp_message_append_option_fqdn(sd_dhcp_message *message, uint8_t flags, bool is_client, const char *fqdn) {
int r;
assert(message);
assert(fqdn);
/* FIXME: Allow long fqdn, as now we support long option. */
uint8_t buf[3 + DHCP_MAX_FQDN_LENGTH];
/* RFC 4702 section 2.1
* The "E" bit indicates the encoding of the Domain Name field. 1 indicates canonical wire format,
* without compression. This encoding SHOULD be used by clients and MUST be supported by servers.
* A server MUST use the same encoding as that used by the client. A server that does not support
* the deprecated ASCII encoding MUST ignore Client FQDN options that use that encoding.
*
* Here, we unconditionally set the 'E' flag. Hence, sd_dhcp_server must ignore the option if a
* client does not set the 'E' flag in the request. */
buf[0] = flags | DHCP_FQDN_FLAG_E;
/* RFC 4702 section 2.2
* The two 1-octet RCODE1 and RCODE2 fields are deprecated. A client SHOULD set these to 0 when
* sending the option and SHOULD ignore them on receipt. A server SHOULD set these to 255 when
* sending the option and MUST ignore them on receipt. */
buf[1] = is_client ? 0 : 255;
buf[2] = is_client ? 0 : 255;
r = dns_name_to_wire_format(fqdn, buf + 3, sizeof(buf) - 3, false);
if (r <= 0)
return r;
return dhcp_message_append_option(message, SD_DHCP_OPTION_FQDN, 3 + r, buf);
}
int dhcp_message_append_option_hostname(sd_dhcp_message *message, uint8_t flags, bool is_client, const char *hostname) {
assert(message);
/* Hostname (12) or FQDN (81)
*
* RFC 4702 section 3.1
* clients that send the Client FQDN option in their messages MUST NOT also send the Host Name option. */
if (isempty(hostname))
return 0;
if (dhcp_message_has_option(message, SD_DHCP_OPTION_HOST_NAME))
return -EEXIST;
if (dhcp_message_has_option(message, SD_DHCP_OPTION_FQDN))
return -EEXIST;
if (dns_name_is_single_label(hostname))
return dhcp_message_append_option_string(message, SD_DHCP_OPTION_HOST_NAME, hostname);
return dhcp_message_append_option_fqdn(message, flags, is_client, hostname);
}
int dhcp_message_append_option_sub_tlv(sd_dhcp_message *message, uint8_t code, const TLV *tlv) {
int r;
assert(message);
if (tlv_isempty(tlv))
return 0;
if (dhcp_message_has_option(message, code))
return -EEXIST;
_cleanup_(iovec_done) struct iovec iov = {};
r = tlv_build(tlv, &iov);
if (r < 0)
return r;
return dhcp_message_append_option(message, code, iov.iov_len, iov.iov_base);
}
int dhcp_message_append_option_length_prefixed_data(
sd_dhcp_message *message,
uint8_t code,
size_t length_size,
const struct iovec_wrapper *iovw) {
int r;
assert(message);
_cleanup_(iovec_done) struct iovec iov = {};
r = iovw_merge(iovw, length_size, &iov);
if (r < 0)
return r;
if (!iovec_is_set(&iov))
return 0;
return dhcp_message_append_option(message, code, iov.iov_len, iov.iov_base);
}
int dhcp_message_get_option(sd_dhcp_message *message, uint8_t code, size_t length, void *ret) {
int r;
assert(message);
struct iovec iov;
r = tlv_get_full(&message->options, code, length, ret ? &iov : NULL);
if (r < 0)
return r;
if (ret)
memcpy_safe(ret, iov.iov_base, iov.iov_len);
return 0;
}
int dhcp_message_get_option_alloc(sd_dhcp_message *message, uint8_t code, struct iovec *ret) {
assert(message);
return tlv_get_alloc(&message->options, code, ret);
}
int dhcp_message_get_option_flag(sd_dhcp_message *message, uint8_t code) {
assert(message);
return dhcp_message_get_option(message, code, /* length= */ 0, /* ret= */ NULL);
}
int dhcp_message_get_option_u8(sd_dhcp_message *message, uint8_t code, uint8_t *ret) {
assert(message);
return dhcp_message_get_option(message, code, sizeof(uint8_t), ret);
}
int dhcp_message_get_option_u16(sd_dhcp_message *message, uint8_t code, uint16_t *ret) {
be16_t b;
int r;
assert(message);
r = dhcp_message_get_option(message, code, sizeof(be16_t), ret ? &b : NULL);
if (r < 0)
return r;
if (ret)
*ret = be16toh(b);
return 0;
}
int dhcp_message_get_option_be32(sd_dhcp_message *message, uint8_t code, be32_t *ret) {
assert(message);
return dhcp_message_get_option(message, code, sizeof(be32_t), ret);
}
int dhcp_message_get_option_sec(sd_dhcp_message *message, uint8_t code, bool max_as_infinity, usec_t *ret) {
int r;
assert(message);
be32_t t;
r = dhcp_message_get_option_be32(message, code, &t);
if (r < 0)
return r;
if (ret)
*ret = be32_sec_to_usec(t, max_as_infinity);
return 0;
}
int dhcp_message_get_option_address(sd_dhcp_message *message, uint8_t code, struct in_addr *ret) {
assert(message);
return dhcp_message_get_option_be32(message, code, ret ? &ret->s_addr : NULL);
}
int dhcp_message_get_option_addresses(sd_dhcp_message *message, uint8_t code, size_t *ret_n_addr, struct in_addr **ret_addr) {
int r;
assert(message);
assert(ret_n_addr || !ret_addr);
_cleanup_(iovec_done) struct iovec iov_free = {};
r = dhcp_message_get_option_alloc(message, code, &iov_free);
if (r < 0)
return r;
struct iovec iov = iov_free;
if (code == SD_DHCP_OPTION_SIP_SERVER) {
if (!iovec_is_set(&iov))
return -EBADMSG;
if (*(uint8_t*) iov.iov_base != 1) /* 'enc' field, 0: domains, 1: addresses */
return -ENODATA;
iovec_inc(&iov, 1);
}
if (iov.iov_len % sizeof(struct in_addr) != 0)
return -EBADMSG;
size_t n = iov.iov_len / sizeof(struct in_addr);
if (n == 0)
return -ENODATA;
if (ret_addr) {
if (code == SD_DHCP_OPTION_SIP_SERVER) {
struct in_addr *addr = newdup(struct in_addr, iov.iov_base, n);
if (!addr)
return -ENOMEM;
*ret_addr = addr;
} else {
*ret_addr = iov.iov_base;
TAKE_STRUCT(iov_free);
}
}
if (ret_n_addr)
*ret_n_addr = n;
return 0;
}
int dhcp_message_get_option_string(sd_dhcp_message *message, uint8_t code, char **ret) {
int r;
assert(message);
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, code, &iov);
if (r < 0)
return r;
if (!iovec_is_set(&iov))
return -ENODATA;
/* Allow NUL at the end for buggy DHCP servers, but refuse intermediate NUL. */
if (memchr(iov.iov_base, 0, iov.iov_len - 1))
return -EBADMSG;
/* Note, dhcp_message_get_option_alloc() -> tlv_get_alloc() allocates an extra byte to make
* iov.iov_base can be handled as a NUL-terminated string. Hence, we can directly pass it to
* isempty() and string_is_safe(). */
if (isempty(iov.iov_base))
return -ENODATA;
if (!string_is_safe(iov.iov_base, STRING_ALLOW_BACKSLASHES | STRING_ALLOW_QUOTES | STRING_ALLOW_GLOBS))
return -EBADMSG;
if (ret)
*ret = TAKE_PTR(iov.iov_base);
return 0;
}
static int dhcp_message_get_option_static_routes(sd_dhcp_message *message, size_t *ret_n_routes, sd_dhcp_route **ret_routes) {
int r;
assert(message);
size_t n;
_cleanup_free_ struct in_addr *addrs = NULL;
r = dhcp_message_get_option_addresses(message, SD_DHCP_OPTION_STATIC_ROUTE, &n, &addrs);
if (r < 0)
return r;
if (n % 2 != 0)
return -EBADMSG;
_cleanup_free_ sd_dhcp_route *routes = NULL;
size_t n_routes = 0;
for (size_t i = 0; i < n; i += 2) {
struct in_addr dst = addrs[i];
uint8_t prefixlen;
if (in4_addr_default_prefixlen(&dst, &prefixlen) < 0)
continue;
(void) in4_addr_mask(&dst, prefixlen);
/* RFC 2132 section 5.8:
* The default route (0.0.0.0) is an illegal destination for a static route.*/
if (in4_addr_is_null(&dst))
continue;
if (!ret_routes) {
n_routes++;
continue;
}
if (!GREEDY_REALLOC(routes, n_routes + 1))
return -ENOMEM;
routes[n_routes++] = (struct sd_dhcp_route) {
.dst_addr = dst,
.gw_addr = addrs[i + 1],
.dst_prefixlen = prefixlen,
};
}
if (n_routes == 0)
return -ENODATA;
if (ret_routes)
*ret_routes = TAKE_PTR(routes);
if (ret_n_routes)
*ret_n_routes = n_routes;
return 0;
}
static int dhcp_message_get_option_classless_static_routes(sd_dhcp_message *message, uint8_t code, size_t *ret_n_routes, sd_dhcp_route **ret_routes) {
int r;
assert(message);
assert(IN_SET(code,
SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE,
SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE));
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, code, &iov);
if (r < 0)
return r;
_cleanup_free_ sd_dhcp_route *routes = NULL;
size_t n_routes = 0;
for (struct iovec i = iov; iovec_is_set(&i);) {
uint8_t prefixlen = *(uint8_t*) i.iov_base;
iovec_inc(&i, 1);
if (prefixlen > 32)
return -EBADMSG;
size_t n = DIV_ROUND_UP(prefixlen, 8);
if (n > i.iov_len)
return -EBADMSG;
struct in_addr dst = {};
memcpy_safe(&dst, i.iov_base, n);
(void) in4_addr_mask(&dst, prefixlen);
iovec_inc(&i, n);
if (i.iov_len < sizeof(struct in_addr))
return -EBADMSG;
struct in_addr gw;
memcpy(&gw, i.iov_base, sizeof(struct in_addr));
iovec_inc(&i, sizeof(struct in_addr));
if (!ret_routes) {
n_routes++;
continue;
}
if (!GREEDY_REALLOC(routes, n_routes + 1))
return -ENOMEM;
routes[n_routes++] = (struct sd_dhcp_route) {
.dst_addr = dst,
.gw_addr = gw,
.dst_prefixlen = prefixlen,
};
}
if (n_routes == 0)
return -ENODATA;
if (ret_routes)
*ret_routes = TAKE_PTR(routes);
if (ret_n_routes)
*ret_n_routes = n_routes;
return 0;
}
int dhcp_message_get_option_routes(sd_dhcp_message *message, uint8_t code, size_t *ret_n_routes, sd_dhcp_route **ret_routes) {
switch (code) {
case SD_DHCP_OPTION_STATIC_ROUTE:
return dhcp_message_get_option_static_routes(message, ret_n_routes, ret_routes);
case SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE:
case SD_DHCP_OPTION_PRIVATE_CLASSLESS_STATIC_ROUTE:
return dhcp_message_get_option_classless_static_routes(message, code, ret_n_routes, ret_routes);
default:
return -EINVAL;
}
}
int dhcp_message_get_option_6rd(
sd_dhcp_message *message,
uint8_t *ret_ipv4masklen,
uint8_t *ret_prefixlen,
struct in6_addr *ret_prefix,
size_t *ret_n_br_addresses,
struct in_addr **ret_br_addresses) {
int r;
assert(message);
assert(ret_n_br_addresses || !ret_br_addresses);
/* See RFC 5969 Section 7.1.1 */
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, SD_DHCP_OPTION_6RD, &iov);
if (r < 0)
return r;
/* option-length: The length of the DHCP option in octets (22 octets with one BR IPv4 address). */
if (iov.iov_len < 2 + sizeof(struct in6_addr) + sizeof(struct in_addr) ||
(iov.iov_len - 2 - sizeof(struct in6_addr)) % sizeof(struct in_addr) != 0)
return -EBADMSG;
size_t n_br_addresses = (iov.iov_len - 2 - sizeof(struct in6_addr)) / sizeof(struct in_addr);
assert(n_br_addresses > 0); /* We have already checked that in the above. */
const uint8_t *p = iov.iov_base;
/* IPv4MaskLen: The number of high-order bits that are identical across all CE IPv4 addresses
* within a given 6rd domain. This may be any value between 0 and 32. Any value
* greater than 32 is invalid. */
uint8_t ipv4masklen = *p++;
if (ipv4masklen > 32)
return -EBADMSG;
/* 6rdPrefixLen: The IPv6 prefix length of the SP's 6rd IPv6 prefix in number of bits. For the
* purpose of bounds checking by DHCP option processing, the sum of
* (32 - IPv4MaskLen) + 6rdPrefixLen MUST be less than or equal to 128. */
uint8_t prefixlen = *p++;
if (32 - ipv4masklen + prefixlen > 128)
return -EBADMSG;
/* The delegated prefix length is (32 - IPv4MaskLen) + 6rdPrefixLen. A zero-length delegated
* prefix would cover the whole IPv6 address space, refuse it. */
if (32 - ipv4masklen + prefixlen == 0)
return -EBADMSG;
/* 6rdPrefix: The service provider's 6rd IPv6 prefix represented as a 16-octet IPv6 address.
* The bits in the prefix after the 6rdPrefixlen number of bits are reserved and
* MUST be initialized to zero by the sender and ignored by the receiver. */
struct in6_addr prefix;
memcpy(&prefix, p, sizeof(struct in6_addr));
(void) in6_addr_mask(&prefix, prefixlen);
p += sizeof(struct in6_addr);
/* 6rdBRIPv4Address: One or more IPv4 addresses of the 6rd Border Relays for a given 6rd domain. */
if (ret_br_addresses) {
struct in_addr *br_addresses = newdup(struct in_addr, p, n_br_addresses);
if (!br_addresses)
return -ENOMEM;
*ret_br_addresses = br_addresses;
}
if (ret_ipv4masklen)
*ret_ipv4masklen = ipv4masklen;
if (ret_prefixlen)
*ret_prefixlen = prefixlen;
if (ret_prefix)
*ret_prefix = prefix;
if (ret_n_br_addresses)
*ret_n_br_addresses = n_br_addresses;
return 0;
}
int dhcp_message_get_option_client_id(sd_dhcp_message *message, sd_dhcp_client_id *ret) {
int r;
assert(message);
assert(ret);
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, SD_DHCP_OPTION_CLIENT_IDENTIFIER, &iov);
if (r < 0)
return r;
return sd_dhcp_client_id_set_raw(ret, iov.iov_base, iov.iov_len);
}
int dhcp_message_get_option_parameter_request_list(sd_dhcp_message *message, Set **ret) {
int r;
assert(message);
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST, &iov);
if (r < 0)
return r;
if (!iovec_is_set(&iov))
return -ENODATA;
if (!ret)
return 0;
_cleanup_set_free_ Set *prl = NULL;
for (struct iovec i = iov; iovec_is_set(&i); iovec_inc(&i, 1)) {
r = set_ensure_put(&prl, /* hash_ops= */ NULL, UINT8_TO_PTR(*(uint8_t*) i.iov_base));
if (r < 0)
return r;
}
*ret = TAKE_PTR(prl);
return 0;
}
static int normalize_dns_name(const char *name, char **ret) {
int r;
assert(name);
_cleanup_free_ char *normalized = NULL;
r = dns_name_normalize(name, /* flags= */ 0, &normalized);
if (r < 0)
return r;
if (is_localhost(normalized))
return -EINVAL;
if (dns_name_is_root(normalized))
return -EINVAL;
if (ret)
*ret = TAKE_PTR(normalized);
return 0;
}
int dhcp_message_get_option_fqdn(sd_dhcp_message *message, uint8_t *ret_flags, char **ret_fqdn) {
int r;
assert(message);
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, SD_DHCP_OPTION_FQDN, &iov);
if (r < 0)
return r;
if (iov.iov_len <= 3)
return -EBADMSG;
uint8_t flags = *(uint8_t*) iov.iov_base;
if (!FLAGS_SET(flags, DHCP_FQDN_FLAG_E))
return -EOPNOTSUPP;
struct iovec i;
iovec_shift(&iov, 3, &i);
_cleanup_free_ char *name = NULL;
const uint8_t *p = i.iov_base;
r = dns_name_from_wire_format(&p, &i.iov_len, &name);
if (r < 0)
return r;
if (i.iov_len > 0) /* trailing garbage? */
return -EBADMSG;
if (isempty(name))
return -ENODATA;
if (!string_is_safe(name, /* flags= */ 0))
return -EBADMSG;
_cleanup_free_ char *normalized = NULL;
r = normalize_dns_name(name, &normalized);
if (r < 0)
return r;
if (ret_flags)
*ret_flags = flags;
if (ret_fqdn)
*ret_fqdn = TAKE_PTR(normalized);
return 0;
}
int dhcp_message_get_option_dns_name(sd_dhcp_message *message, uint8_t code, char **ret) {
int r;
assert(message);
/* Mainly for Host Name or Domain Name options. */
_cleanup_free_ char *name = NULL;
r = dhcp_message_get_option_string(message, code, &name);
if (r < 0)
return r;
_cleanup_free_ char *normalized = NULL;
r = normalize_dns_name(name, &normalized);
if (r < 0)
return r;
if (ret)
*ret = TAKE_PTR(normalized);
return 0;
}
int dhcp_message_get_option_hostname(sd_dhcp_message *message, char **ret) {
int r;
assert(message);
/* FQDN option always takes precedence. */
r = dhcp_message_get_option_fqdn(message, /* ret_flags= */ NULL, ret);