HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd-network/dhcp-message.c
Git blob: c6ec2d7b4ce920b335efbd1c20cae01ca1224002
Lines 1001–1803 of 1,803
if (ERRNO_IS_NEG_RESOURCE(r))
return r;
if (r >= 0)
return 0;
/* Then, fall back to Host Name option. */
return dhcp_message_get_option_dns_name(message, SD_DHCP_OPTION_HOST_NAME, ret);
}
int dhcp_message_get_option_domains(sd_dhcp_message *message, uint8_t code, char ***ret) {
int r;
assert(message);
/* This is mostly for SD_DHCP_OPTION_DOMAIN_SEARCH and SD_DHCP_OPTION_SIP_SERVER. */
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, code, &iov);
if (r < 0)
return r;
const uint8_t *buf = iov.iov_base;
size_t len = iov.iov_len;
if (code == SD_DHCP_OPTION_SIP_SERVER) {
if (len == 0)
return -EBADMSG;
if (buf[0] != 0) /* 'enc' field, 0: domains, 1: addresses */
return -ENODATA;
len--;
buf++;
}
_cleanup_strv_free_ char **names = NULL;
size_t n_names = 0;
_cleanup_free_ char *name = NULL;
size_t n = 0;
for (size_t pos = 0, jump_barrier = 0, next_chunk = 0; pos < len;) {
uint8_t c = buf[pos++];
if (c == 0) {
/* End of name */
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;
r = strv_consume_with_size(&names, &n_names, TAKE_PTR(normalized));
if (r < 0)
return r;
if (next_chunk != 0)
pos = next_chunk;
next_chunk = 0;
jump_barrier = pos;
name = mfree(name);
n = 0;
} else if (c <= 63) {
/* Literal label */
const char *label = (const char*) (buf + pos);
pos += c;
if (pos >= len)
return -EBADMSG;
if (!GREEDY_REALLOC(name, n + 1 + DNS_LABEL_ESCAPED_MAX))
return -ENOMEM;
if (n != 0)
name[n++] = '.';
r = dns_label_escape(label, c, name + n, DNS_LABEL_ESCAPED_MAX);
if (r < 0)
return r;
n += r;
} else if (FLAGS_SET(c, 0xc0)) {
/* Pointer */
if (pos >= len) /* pointer is 2 bytes, hence we need to read at least one more byte. */
return -EBADMSG;
/* Save the current location so we don't end up re-parsing what's parsed so far. */
if (next_chunk == 0)
next_chunk = pos + 1;
pos = ((size_t) (c & ~0xc0) << 8) | ((size_t) buf[pos]);
/* Jumps are limited to a "prior occurrence" (RFC-1035 4.1.4) */
if (pos >= jump_barrier)
return -EBADMSG;
jump_barrier = pos;
} else
return -EBADMSG;
}
if (!isempty(name)) /* trailing garbage?? Should not happen, but for safety. */
return -EBADMSG;
if (strv_isempty(names))
return -EBADMSG;
if (ret)
*ret = TAKE_PTR(names);
return 0;
}
int dhcp_message_get_option_sub_tlv(sd_dhcp_message *message, uint8_t code, TLVFlag flags, TLV **ret) {
int r;
assert(message);
assert(!FLAGS_SET(flags, TLV_TEMPORARY));
_cleanup_(iovec_done) struct iovec iov = {};
r = dhcp_message_get_option_alloc(message, code, &iov);
if (r < 0)
return r;
_cleanup_(tlv_unrefp) TLV *tlv = tlv_new(flags);
if (!tlv)
return -ENOMEM;
r = tlv_parse(tlv, &iov);
if (r < 0)
return r;
if (tlv_isempty(tlv))
return -ENODATA;
if (ret)
*ret = TAKE_PTR(tlv);
return 0;
}
int dhcp_message_get_option_length_prefixed_data(
sd_dhcp_message *message,
uint8_t code,
size_t length_size,
struct iovec_wrapper *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;
_cleanup_(iovw_done_free) struct iovec_wrapper iovw = {};
r = iovec_split(&iov, length_size, &iovw);
if (r < 0)
return r;
if (iovw_isempty(&iovw))
return -ENODATA;
if (ret)
*ret = TAKE_STRUCT(iovw);
return 0;
}
static int parse_dnr_one(const struct iovec *iov, sd_dns_resolver *ret) {
int r;
assert(iovec_is_set(iov));
assert(ret);
_cleanup_(sd_dns_resolver_done) sd_dns_resolver resolver = {};
struct iovec i = *iov;
/* service priority */
if (i.iov_len < sizeof(be16_t))
return -EBADMSG;
resolver.priority = unaligned_read_be16(i.iov_base);
iovec_inc(&i, sizeof(be16_t));
/* RFC 9460 section 2.4.1:
* When SvcPriority is 0, the SVCB record is in AliasMode.
*
* We do not support the alias mode. But the entry itself is not invalid. */
if (resolver.priority == 0) {
*ret = (sd_dns_resolver) {};
return 0;
}
/* authentication domain name */
if (!iovec_is_set(&i))
return -EBADMSG;
size_t name_len = *(uint8_t*) i.iov_base;
iovec_inc(&i, 1);
if (i.iov_len < name_len)
return -EBADMSG;
const uint8_t *name_buf = i.iov_base;
iovec_inc(&i, name_len);
r = dns_name_from_wire_format(&name_buf, &name_len, &resolver.auth_name);
if (r < 0)
return r;
if (r == 0 || name_len != 0)
return -EBADMSG;
r = dns_name_is_valid_ldh(resolver.auth_name);
if (r < 0)
return r;
if (r == 0)
return -EBADMSG;
if (dns_name_is_root(resolver.auth_name))
return -EBADMSG;
/* RFC9463 section 3.1.6: In ADN-only mode, server omits everything after the ADN.
*
* We don't support these, but they are not invalid. */
if (!iovec_is_set(&i)) {
*ret = (sd_dns_resolver) {};
return 0;
}
/* IPv4 addresses */
size_t n = *(uint8_t*) i.iov_base;
iovec_inc(&i, 1);
if (n % sizeof(struct in_addr) != 0)
return -EBADMSG;
n /= sizeof(struct in_addr);
/* RFC9463 section 3.1.8: option MUST include at least one valid IP addr */
if (n == 0)
return -EBADMSG;
resolver.family = AF_INET;
resolver.n_addrs = n;
resolver.addrs = new(union in_addr_union, n);
if (!resolver.addrs)
return -ENOMEM;
for (size_t j = 0; j < n; j++) {
if (i.iov_len < sizeof(struct in_addr))
return -EBADMSG;
struct in_addr a;
memcpy(&a, i.iov_base, sizeof(struct in_addr));
iovec_inc(&i, sizeof(struct in_addr));
/* RFC9463 section 5.2: client MUST discard multicast and host loopback addresses */
if (in4_addr_is_multicast(&a) || in4_addr_is_localhost(&a))
return -EBADMSG;
resolver.addrs[j] = (union in_addr_union) { .in = a };
}
/* service params */
r = dnr_parse_svc_params(i.iov_base, i.iov_len, &resolver);
if (r < 0)
return r;
if (r == 0) {
/* We can't use this record, but it is not invalid. */
*ret = (sd_dns_resolver) {};
return 0;
}
*ret = TAKE_STRUCT(resolver);
return 1;
}
int dhcp_message_get_option_dnr(sd_dhcp_message *message, size_t *ret_n_resolvers, sd_dns_resolver **ret_resolvers) {
int r;
assert(message);
assert(ret_n_resolvers || !ret_resolvers);
/* See RFC 9463 section 5.1 */
_cleanup_(iovw_done_free) struct iovec_wrapper iovw = {};
r = dhcp_message_get_option_length_prefixed_data(message, SD_DHCP_OPTION_V4_DNR, /* length_size= */ 2, &iovw);
if (r < 0)
return r;
sd_dns_resolver *resolvers = NULL;
size_t n_resolvers = 0;
CLEANUP_ARRAY(resolvers, n_resolvers, dns_resolver_free_array);
FOREACH_ARRAY(i, iovw.iovec, iovw.count) {
_cleanup_(sd_dns_resolver_done) sd_dns_resolver dnr = {};
r = parse_dnr_one(i, &dnr);
if (r < 0)
return r;
if (r == 0)
continue;
if (!ret_resolvers) {
n_resolvers++;
continue;
}
if (!GREEDY_REALLOC(resolvers, n_resolvers + 1))
return -ENOMEM;
resolvers[n_resolvers++] = TAKE_STRUCT(dnr);
}
if (n_resolvers == 0) /* no supported resolver */
return -ENODATA;
if (ret_resolvers) {
/* Sort the resolvers with their priorities. */
typesafe_qsort(resolvers, n_resolvers, dns_resolver_prio_compare);
*ret_resolvers = TAKE_PTR(resolvers);
}
if (ret_n_resolvers)
*ret_n_resolvers = n_resolvers;
return 0;
}
static int dhcp_message_verify_header(
const struct iovec *iov,
uint8_t op,
const uint32_t *xid,
uint16_t arp_type,
const struct hw_addr_data *hw_addr) {
assert(iov);
assert(iovec_is_valid(iov));
assert(IN_SET(op, 0, BOOTREQUEST, BOOTREPLY)); /* when 0, both BOOTREQUEST and BOOTREPLY are accepted */
POINTER_MAY_BE_NULL(xid);
POINTER_MAY_BE_NULL(hw_addr);
if (iov->iov_len < sizeof(DHCPMessageHeader))
return -EBADMSG;
/* DHCP travels over UDP, so anything larger than the maximum UDP payload cannot be a valid
* message and would also be impossible to rebuild as a UDP packet. */
if (iov->iov_len > UDP_PAYLOAD_MAX_SIZE)
return -EBADMSG;
const DHCPMessageHeader *header = iov->iov_base;
if (!IN_SET(header->op, BOOTREQUEST, BOOTREPLY))
return -EBADMSG;
if (op != 0 && header->op != op)
return -EBADMSG;
if (xid && be32toh(header->xid) != *xid)
return -EBADMSG;
if (arp_type <= UINT8_MAX && header->htype != arp_type)
return -EBADMSG;
if (header->hlen > sizeof_field(DHCPMessageHeader, chaddr))
return -EBADMSG;
if (hw_addr && memcmp_nn(header->chaddr, header->hlen, hw_addr->bytes, hw_addr->length) != 0)
return -EBADMSG;
return 0;
}
int dhcp_message_parse(
const struct iovec *iov,
uint8_t op,
const uint32_t *xid,
uint16_t arp_type,
const struct hw_addr_data *hw_addr,
sd_dhcp_message **ret) {
int r;
assert(iov);
assert(ret);
r = dhcp_message_verify_header(iov, op, xid, arp_type, hw_addr);
if (r < 0)
return r;
_cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *message = NULL;
r = dhcp_message_new(&message);
if (r < 0)
return r;
memcpy(&message->header, iov->iov_base, sizeof(DHCPMessageHeader));
if (be32toh(message->header.magic) != DHCP_MAGIC_COOKIE) {
/* Should be BOOTP, and no options. */
*ret = TAKE_PTR(message);
return 0;
}
/* In the BOOTP protocol (RFC 951), the vendor field (magic + options) is 64 bytes, but here we do
* not check the length, and support all DHCP options even if we are running as BOOTP client. */
r = tlv_parse(&message->options, &IOVEC_SHIFT(iov, sizeof(DHCPMessageHeader)));
if (r < 0)
return r;
/* Parse SD_DHCP_OPTION_OVERLOAD (52) to determine if we should parse sname and/or file. */
uint8_t overload = DHCP_OVERLOAD_NONE;
(void) dhcp_message_get_option_u8(message, SD_DHCP_OPTION_OVERLOAD, &overload);
if (FLAGS_SET(overload, DHCP_OVERLOAD_FILE)) {
r = tlv_parse(&message->options, &IOVEC_MAKE(message->header.file, sizeof(message->header.file)));
if (r < 0)
return r;
/* The content of the overloaded field has been merged into options. Clear it so that the
* field is not re-parsed (which would duplicate the options) and not re-emitted verbatim
* by dhcp_message_build(), ensuring parse/build is idempotent. */
memzero(message->header.file, sizeof(message->header.file));
}
if (FLAGS_SET(overload, DHCP_OVERLOAD_SNAME)) {
r = tlv_parse(&message->options, &IOVEC_MAKE(message->header.sname, sizeof(message->header.sname)));
if (r < 0)
return r;
memzero(message->header.sname, sizeof(message->header.sname));
}
*ret = TAKE_PTR(message);
return 0;
}
size_t dhcp_message_payload_size(sd_dhcp_message *message) {
assert(message);
return MAX(size_add(sizeof(DHCPMessageHeader), tlv_size(&message->options)), BOOTP_MESSAGE_SIZE);
}
size_t dhcp_message_packet_size(sd_dhcp_message *message) {
assert(message);
return size_add(sizeof(struct iphdr) + sizeof(struct udphdr), dhcp_message_payload_size(message));
}
int dhcp_message_build(sd_dhcp_message *message, struct iovec_wrapper *ret) {
int r;
assert(message);
assert(ret);
size_t size = size_add(sizeof(DHCPMessageHeader), tlv_size(&message->options));
if (size > UDP_PAYLOAD_MAX_SIZE)
return -E2BIG;
_cleanup_(iovw_done_free) struct iovec_wrapper iovw = {};
r = iovw_extend(&iovw, &message->header, sizeof(DHCPMessageHeader));
if (r < 0)
return r;
struct iovec options;
r = tlv_build(&message->options, &options);
if (r < 0)
return r;
r = iovw_consume_iov(&iovw, &options);
if (r < 0)
return r;
/* For compatibility with other implementations and network appliances, the message size should be at
* least 300 bytes, which is the size of BOOTP message. */
size_t padding_size = LESS_BY(BOOTP_MESSAGE_SIZE, size);
if (padding_size > 0) {
uint8_t *padding = new0(uint8_t, padding_size);
if (!padding)
return -ENOMEM;
r = iovw_consume(&iovw, padding, padding_size);
if (r < 0)
return r;
}
*ret = TAKE_STRUCT(iovw);
return 0;
}
int dhcp_message_build_json(sd_dhcp_message *message, sd_json_variant **ret) {
int r;
assert(message);
assert(message->header.hlen <= sizeof(message->header.chaddr));
assert(ret);
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
r = sd_json_buildo(
&v,
SD_JSON_BUILD_PAIR_UNSIGNED("op", message->header.op),
SD_JSON_BUILD_PAIR_UNSIGNED("htype", message->header.htype),
SD_JSON_BUILD_PAIR_UNSIGNED("hops", message->header.hops),
SD_JSON_BUILD_PAIR_UNSIGNED("xid", be32toh(message->header.xid)),
SD_JSON_BUILD_PAIR_UNSIGNED("secs", be16toh(message->header.secs)),
SD_JSON_BUILD_PAIR_UNSIGNED("flags", be16toh(message->header.flags)),
JSON_BUILD_PAIR_HEX_NON_EMPTY("ciaddr", &message->header.ciaddr, sizeof(message->header.ciaddr)),
JSON_BUILD_PAIR_HEX_NON_EMPTY("yiaddr", &message->header.yiaddr, sizeof(message->header.yiaddr)),
JSON_BUILD_PAIR_HEX_NON_EMPTY("siaddr", &message->header.siaddr, sizeof(message->header.siaddr)),
JSON_BUILD_PAIR_HEX_NON_EMPTY("giaddr", &message->header.giaddr, sizeof(message->header.giaddr)),
JSON_BUILD_PAIR_HEX_NON_EMPTY("chaddr", message->header.chaddr, message->header.hlen));
if (r < 0)
return r;
uint8_t overload = DHCP_OVERLOAD_NONE;
(void) dhcp_message_get_option_u8(message, SD_DHCP_OPTION_OVERLOAD, &overload);
if (!FLAGS_SET(overload, DHCP_OVERLOAD_SNAME) && !eqzero(message->header.sname)) {
r = sd_json_variant_merge_objectbo(
&v,
JSON_BUILD_PAIR_HEX_NON_EMPTY("sname", message->header.sname, sizeof(message->header.sname)));
if (r < 0)
return r;
}
if (!FLAGS_SET(overload, DHCP_OVERLOAD_FILE) && !eqzero(message->header.file)) {
r = sd_json_variant_merge_objectbo(
&v,
JSON_BUILD_PAIR_HEX_NON_EMPTY("file", message->header.file, sizeof(message->header.file)));
if (r < 0)
return r;
}
_cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
r = tlv_build_json(&message->options, &w);
if (r < 0)
return r;
r = sd_json_variant_merge_objectbo(
&v,
JSON_BUILD_PAIR_VARIANT_NON_NULL("options", w));
if (r < 0)
return r;
*ret = TAKE_PTR(v);
return 0;
}
typedef struct MessageParam {
uint8_t op;
uint8_t htype;
uint8_t hops;
uint32_t xid;
uint16_t secs;
uint16_t flags;
struct iovec ciaddr;
struct iovec yiaddr;
struct iovec siaddr;
struct iovec giaddr;
struct iovec chaddr;
struct iovec sname;
struct iovec file;
TLV *options;
} MessageParam;
static void message_param_done(MessageParam *p) {
assert(p);
iovec_done(&p->ciaddr);
iovec_done(&p->yiaddr);
iovec_done(&p->siaddr);
iovec_done(&p->giaddr);
iovec_done(&p->chaddr);
iovec_done(&p->sname);
iovec_done(&p->file);
tlv_unref(p->options);
}
static int dispatch_options(const char *name, sd_json_variant *v, sd_json_dispatch_flags_t flags, void *userdata) {
TLV **options = ASSERT_PTR(userdata);
int r;
if (*options)
return -EINVAL; /* multiple options field? */
_cleanup_(tlv_unrefp) TLV *tlv = tlv_new(TLV_DHCP4);
if (!tlv)
return -ENOMEM;
r = tlv_parse_json(tlv, v);
if (r < 0)
return r;
*options = TAKE_PTR(tlv);
return 0;
}
int dhcp_message_parse_json(sd_json_variant *v, sd_dhcp_message **ret) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "op", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(MessageParam, op), SD_JSON_MANDATORY },
{ "htype", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(MessageParam, htype), 0 },
{ "hops", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint8, offsetof(MessageParam, hops), 0 },
{ "xid", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint32, offsetof(MessageParam, xid), 0 },
{ "secs", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(MessageParam, secs), 0 },
{ "flags", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(MessageParam, flags), 0 },
{ "ciaddr", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, ciaddr), 0 },
{ "yiaddr", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, yiaddr), 0 },
{ "siaddr", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, siaddr), 0 },
{ "giaddr", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, giaddr), 0 },
{ "chaddr", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, chaddr), 0 },
{ "sname", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, sname), 0 },
{ "file", SD_JSON_VARIANT_STRING, json_dispatch_unhex_iovec, offsetof(MessageParam, file), 0 },
{ "options", SD_JSON_VARIANT_ARRAY, dispatch_options, offsetof(MessageParam, options), 0 },
{},
};
int r;
assert(v);
assert(ret);
_cleanup_(message_param_done) MessageParam p = {};
r = sd_json_dispatch(v, dispatch_table, SD_JSON_ALLOW_EXTENSIONS, &p);
if (r < 0)
return r;
if (!IN_SET(p.op, BOOTREQUEST, BOOTREPLY))
return -EINVAL;
if (!iovec_is_valid(&p.ciaddr) || !IN_SET(p.ciaddr.iov_len, 0, sizeof_field(sd_dhcp_message, header.ciaddr)))
return -EINVAL;
if (!iovec_is_valid(&p.yiaddr) || !IN_SET(p.yiaddr.iov_len, 0, sizeof_field(sd_dhcp_message, header.yiaddr)))
return -EINVAL;
if (!iovec_is_valid(&p.siaddr) || !IN_SET(p.siaddr.iov_len, 0, sizeof_field(sd_dhcp_message, header.siaddr)))
return -EINVAL;
if (!iovec_is_valid(&p.giaddr) || !IN_SET(p.giaddr.iov_len, 0, sizeof_field(sd_dhcp_message, header.giaddr)))
return -EINVAL;
if (!iovec_is_valid(&p.chaddr) || p.chaddr.iov_len > sizeof_field(sd_dhcp_message, header.chaddr))
return -EINVAL;
if (!iovec_is_valid(&p.sname) || p.sname.iov_len > sizeof_field(sd_dhcp_message, header.sname))
return -EINVAL;
if (!iovec_is_valid(&p.file) || p.file.iov_len > sizeof_field(sd_dhcp_message, header.file))
return -EINVAL;
_cleanup_(sd_dhcp_message_unrefp) sd_dhcp_message *message = NULL;
r = dhcp_message_new(&message);
if (r < 0)
return r;
message->header = (DHCPMessageHeader) {
.op = p.op,
.htype = p.htype,
.hlen = p.chaddr.iov_len,
.hops = p.hops,
.xid = htobe32(p.xid),
.secs = htobe16(p.secs),
.flags = htobe16(p.flags),
.magic = htobe32(DHCP_MAGIC_COOKIE),
};
memcpy_safe(&message->header.ciaddr, p.ciaddr.iov_base, p.ciaddr.iov_len);
memcpy_safe(&message->header.yiaddr, p.yiaddr.iov_base, p.yiaddr.iov_len);
memcpy_safe(&message->header.siaddr, p.siaddr.iov_base, p.siaddr.iov_len);
memcpy_safe(&message->header.giaddr, p.giaddr.iov_base, p.giaddr.iov_len);
memcpy_safe(message->header.chaddr, p.chaddr.iov_base, p.chaddr.iov_len);
memcpy_safe(message->header.sname, p.sname.iov_base, p.sname.iov_len);
memcpy_safe(message->header.file, p.file.iov_base, p.file.iov_len);
if (p.options) {
message->options = TAKE_STRUCT(*p.options);
p.options = mfree(p.options);
}
*ret = TAKE_PTR(message);
return 0;
}
int dhcp_message_send_udp(
sd_dhcp_message *message,
int fd,
be32_t src_addr,
be32_t dst_addr,
uint16_t dst_port) {
int r;
assert(message);
assert(fd >= 0);
_cleanup_(iovw_done_free) struct iovec_wrapper payload = {};
r = dhcp_message_build(message, &payload);
if (r < 0)
return r;
union sockaddr_union sa = {
.in.sin_family = AF_INET,
.in.sin_port = htobe16(dst_port),
.in.sin_addr.s_addr = dst_addr,
};
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct in_pktinfo))) control = {};
struct msghdr msg = {
.msg_name = &sa,
.msg_namelen = sizeof(sa.in),
.msg_iov = payload.iovec,
.msg_iovlen = payload.count,
};
if (src_addr != INADDR_ANY) {
msg.msg_control = &control;
msg.msg_controllen = sizeof(control);
struct cmsghdr *cmsg = ASSERT_PTR(CMSG_FIRSTHDR(&msg));
cmsg->cmsg_level = IPPROTO_IP;
cmsg->cmsg_type = IP_PKTINFO;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
struct in_pktinfo *pktinfo = ASSERT_PTR(CMSG_TYPED_DATA(cmsg, struct in_pktinfo));
pktinfo->ipi_spec_dst.s_addr = src_addr;
}
if (sendmsg(fd, &msg, MSG_NOSIGNAL) < 0)
return -errno;
return 0;
}
int dhcp_message_send_raw(
sd_dhcp_message *message,
int fd,
int ifindex,
be32_t src_addr,
uint16_t src_port,
const struct hw_addr_data *dst_hw_addr,
be32_t dst_addr,
uint16_t dst_port,
int ip_service_type) {
int r;
assert(message);
assert(fd >= 0);
assert(ifindex > 0);
assert(dst_hw_addr);
_cleanup_(iovw_done_free) struct iovec_wrapper payload = {};
r = dhcp_message_build(message, &payload);
if (r < 0)
return r;
struct iphdr ip;
struct udphdr udp;
r = udp_packet_build(
src_addr,
src_port,
dst_addr,
dst_port,
ip_service_type,
&payload,
&ip,
&udp);
if (r < 0)
return r;
_cleanup_(iovw_done) struct iovec_wrapper iovw = {};
r = iovw_put(&iovw, &ip, sizeof(struct iphdr));
if (r < 0)
return r;
r = iovw_put(&iovw, &udp, sizeof(struct udphdr));
if (r < 0)
return r;
r = iovw_put_iovw(&iovw, &payload);
if (r < 0)
return r;
union sockaddr_union sa = {
.ll.sll_family = AF_PACKET,
.ll.sll_protocol = htobe16(ETH_P_IP),
.ll.sll_ifindex = ifindex,
.ll.sll_halen = dst_hw_addr->length,
};
memcpy_safe(sa.ll.sll_addr, dst_hw_addr->bytes, dst_hw_addr->length);
struct msghdr mh = {
.msg_name = &sa.sa,
.msg_namelen = sockaddr_ll_len(&sa.ll),
.msg_iov = iovw.iovec,
.msg_iovlen = iovw.count,
};
if (sendmsg(fd, &mh, MSG_NOSIGNAL) < 0)
return -errno;
return 0;
}