HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd-network/dhcp-message.c

61,353 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
}