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

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

#include <errno.h>
#include <net/ethernet.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <linux/filter.h>
#include <linux/if_infiniband.h>
#include <linux/if_packet.h>

#include "dhcp-internal.h"
#include "fd-util.h"
#include "socket-util.h"
#include "unaligned.h"

static int _bind_raw_socket(int ifindex, union sockaddr_union *link,
                            uint32_t xid, const uint8_t *mac_addr,
                            size_t mac_addr_len,
                            const uint8_t *bcast_addr,
                            const struct ether_addr *eth_mac,
                            uint16_t arp_type, uint8_t dhcp_hlen,
                            uint16_t port) {
        struct sock_filter filter[] = {
                BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0),                                 /* A <- packet length */
                BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(DHCPPacket), 1, 0),         /* packet >= DHCPPacket ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, ip.protocol)), /* A <- IP protocol */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 1, 0),                /* IP protocol == UDP ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, ip.frag_off)), /* A <- Flags */
                BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0x20),                             /* A <- A & 0x20 (More Fragments bit) */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0),                          /* A == 0 ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(DHCPPacket, ip.frag_off)), /* A <- Flags + Fragment offset */
                BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0x1fff),                           /* A <- A & 0x1fff (Fragment offset) */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0),                          /* A == 0 ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(DHCPPacket, udp.dest)),    /* A <- UDP destination port */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, port, 1, 0),                       /* UDP destination port == DHCP client port ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, dhcp.op)),     /* A <- DHCP op */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, BOOTREPLY, 1, 0),                  /* op == BOOTREPLY ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, dhcp.htype)),  /* A <- DHCP header type */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arp_type, 1, 0),                   /* header type == arp_type ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(DHCPPacket, dhcp.xid)),    /* A <- client identifier */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, xid, 1, 0),                        /* client identifier == xid ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, dhcp.hlen)),   /* A <- MAC address length */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, dhcp_hlen, 1, 0),                  /* address length == dhcp_hlen ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */

                /* We only support MAC address length to be either 0 or 6 (ETH_ALEN). Optionally
                 * compare chaddr for ETH_ALEN bytes. */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETH_ALEN, 0, 12),                                  /* A (the MAC address length) == ETH_ALEN ? */
                BPF_STMT(BPF_LD + BPF_IMM, unaligned_read_be32(&eth_mac->ether_addr_octet[0])),        /* A <- 4 bytes of client's MAC */
                BPF_STMT(BPF_MISC + BPF_TAX, 0),                                                       /* X <- A */
                BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(DHCPPacket, dhcp.chaddr)),                 /* A <- 4 bytes of MAC from dhcp.chaddr */
                BPF_STMT(BPF_ALU + BPF_XOR + BPF_X, 0),                                                /* A xor X */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0),                                          /* A == 0 ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                                          /* ignore */
                BPF_STMT(BPF_LD + BPF_IMM, unaligned_read_be16(&eth_mac->ether_addr_octet[4])),        /* A <- remainder of client's MAC */
                BPF_STMT(BPF_MISC + BPF_TAX, 0),                                                       /* X <- A */
                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(DHCPPacket, dhcp.chaddr) + 4),             /* A <- remainder of MAC from dhcp.chaddr */
                BPF_STMT(BPF_ALU + BPF_XOR + BPF_X, 0),                                                /* A xor X */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0),                                          /* A == 0 ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                                          /* ignore */

                BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(DHCPPacket, dhcp.magic)),  /* A <- DHCP magic cookie */
                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, DHCP_MAGIC_COOKIE, 1, 0),          /* cookie == DHCP magic cookie ? */
                BPF_STMT(BPF_RET + BPF_K, 0),                                          /* ignore */
                BPF_STMT(BPF_RET + BPF_K, 65535),                                      /* return all */
        };
        struct sock_fprog fprog = {
                .len = ELEMENTSOF(filter),
                .filter = filter
        };
        _cleanup_close_ int s = -1;
        int r;

        assert(ifindex > 0);
        assert(link);

        s = socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
        if (s < 0)
                return -errno;

        r = setsockopt_int(s, SOL_PACKET, PACKET_AUXDATA, true);
        if (r < 0)
                return r;

        r = setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER, &fprog, sizeof(fprog));
        if (r < 0)
                return -errno;

        link->ll = (struct sockaddr_ll) {
                .sll_family = AF_PACKET,
                .sll_protocol = htobe16(ETH_P_IP),
                .sll_ifindex = ifindex,
                .sll_hatype = htobe16(arp_type),
                .sll_halen = mac_addr_len,
        };
        memcpy(link->ll.sll_addr, bcast_addr, mac_addr_len);

        r = bind(s, &link->sa, SOCKADDR_LL_LEN(link->ll));
        if (r < 0)
                return -errno;

        return TAKE_FD(s);
}

int dhcp_network_bind_raw_socket(int ifindex, union sockaddr_union *link,
                                 uint32_t xid, const uint8_t *mac_addr,
                                 size_t mac_addr_len, uint16_t arp_type,
                                 uint16_t port) {
        static const uint8_t eth_bcast[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
        /* Default broadcast address for IPoIB */
        static const uint8_t ib_bcast[] = {
                0x00, 0xff, 0xff, 0xff, 0xff, 0x12, 0x40, 0x1b,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0xff, 0xff, 0xff, 0xff
          };
        struct ether_addr eth_mac = { { 0, 0, 0, 0, 0, 0 } };
        const uint8_t *bcast_addr = NULL;
        uint8_t dhcp_hlen = 0;

        if (arp_type == ARPHRD_ETHER) {
                assert_return(mac_addr_len == ETH_ALEN, -EINVAL);
                memcpy(&eth_mac, mac_addr, ETH_ALEN);
                bcast_addr = eth_bcast;
                dhcp_hlen = ETH_ALEN;
        } else if (arp_type == ARPHRD_INFINIBAND) {
                assert_return(mac_addr_len == INFINIBAND_ALEN, -EINVAL);
                bcast_addr = ib_bcast;
        } else
                return -EINVAL;

        return _bind_raw_socket(ifindex, link, xid, mac_addr, mac_addr_len,
                                bcast_addr, &eth_mac, arp_type, dhcp_hlen, port);
}

int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port) {
        union sockaddr_union src = {
                .in.sin_family = AF_INET,
                .in.sin_port = htobe16(port),
                .in.sin_addr.s_addr = address,
        };
        _cleanup_close_ int s = -1;
        int r;

        s = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
        if (s < 0)
                return -errno;

        r = setsockopt_int(s, IPPROTO_IP, IP_TOS, IPTOS_CLASS_CS6);
        if (r < 0)
                return r;

        r = setsockopt_int(s, SOL_SOCKET, SO_REUSEADDR, true);
        if (r < 0)
                return r;

        if (ifindex > 0) {
                r = socket_bind_to_ifindex(s, ifindex);
                if (r < 0)
                        return r;
        }

        if (address == INADDR_ANY) {
                r = setsockopt_int(s, IPPROTO_IP, IP_PKTINFO, true);
                if (r < 0)
                        return r;

                r = setsockopt_int(s, SOL_SOCKET, SO_BROADCAST, true);
                if (r < 0)
                        return r;

        } else {
                r = setsockopt_int(s, IPPROTO_IP, IP_FREEBIND, true);
                if (r < 0)
                        return r;
        }

        r = bind(s, &src.sa, sizeof(src.in));
        if (r < 0)
                return -errno;

        return TAKE_FD(s);
}

int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link,
                                 const void *packet, size_t len) {
        int r;

        assert(link);
        assert(packet);
        assert(len);

        r = sendto(s, packet, len, 0, &link->sa, SOCKADDR_LL_LEN(link->ll));
        if (r < 0)
                return -errno;

        return 0;
}

int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port,
                                 const void *packet, size_t len) {
        union sockaddr_union dest = {
                .in.sin_family = AF_INET,
                .in.sin_port = htobe16(port),
                .in.sin_addr.s_addr = address,
        };
        int r;

        assert(s >= 0);
        assert(packet);
        assert(len);

        r = sendto(s, packet, len, 0, &dest.sa, sizeof(dest.in));
        if (r < 0)
                return -errno;

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
8b4a9693	2	/***
810adae9	3	Copyright © 2013 Intel Corporation. All rights reserved.
8b4a9693 PF	4	***/
	5
	6	#include <errno.h>
8b4a9693	7	#include <net/ethernet.h>
3e7b9f76	8	#include <net/if.h>
7429b07f	9	#include <net/if_arp.h>
8b4a9693	10	#include <stdio.h>
3ffd4af2 LP	11	#include <string.h>
3ffd4af2 LP	12	#include <sys/socket.h>
bc29e507	13	#include <linux/filter.h>
3ffd4af2 LP	14	#include <linux/if_infiniband.h>
3ffd4af2 LP	15	#include <linux/if_packet.h>
8b4a9693 PF	16
8b4a9693 PF	17	#include "dhcp-internal.h"
3ffd4af2 LP	18	#include "fd-util.h"
3ffd4af2 LP	19	#include "socket-util.h"
f11cba74	20	#include "unaligned.h"
8b4a9693	21
76253e73 DW	22	static int _bind_raw_socket(int ifindex, union sockaddr_union *link,
	23	uint32_t xid, const uint8_t *mac_addr,
	24	size_t mac_addr_len,
	25	const uint8_t *bcast_addr,
	26	const struct ether_addr *eth_mac,
9faed222 SS	27	uint16_t arp_type, uint8_t dhcp_hlen,
9faed222 SS	28	uint16_t port) {
bc29e507	29	struct sock_filter filter[] = {
088b6ba2 LP	30	BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0), /* A <- packet length */
	31	BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(DHCPPacket), 1, 0), /* packet >= DHCPPacket ? */
	32	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	33	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, ip.protocol)), /* A <- IP protocol */
	34	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 1, 0), /* IP protocol == UDP ? */
	35	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	36	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, ip.frag_off)), /* A <- Flags */
	37	BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0x20), /* A <- A & 0x20 (More Fragments bit) */
	38	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0), /* A == 0 ? */
	39	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	40	BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(DHCPPacket, ip.frag_off)), /* A <- Flags + Fragment offset */
	41	BPF_STMT(BPF_ALU + BPF_AND + BPF_K, 0x1fff), /* A <- A & 0x1fff (Fragment offset) */
	42	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0), /* A == 0 ? */
	43	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	44	BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(DHCPPacket, udp.dest)), /* A <- UDP destination port */
9faed222	45	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, port, 1, 0), /* UDP destination port == DHCP client port ? */
088b6ba2 LP	46	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	47	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, dhcp.op)), /* A <- DHCP op */
	48	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, BOOTREPLY, 1, 0), /* op == BOOTREPLY ? */
	49	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	50	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, dhcp.htype)), /* A <- DHCP header type */
76253e73	51	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, arp_type, 1, 0), /* header type == arp_type ? */
088b6ba2	52	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
088b6ba2 LP	53	BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(DHCPPacket, dhcp.xid)), /* A <- client identifier */
	54	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, xid, 1, 0), /* client identifier == xid ? */
	55	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
13f1fd03 TH	56	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(DHCPPacket, dhcp.hlen)), /* A <- MAC address length */
	57	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, dhcp_hlen, 1, 0), /* address length == dhcp_hlen ? */
	58	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	59
	60	/* We only support MAC address length to be either 0 or 6 (ETH_ALEN). Optionally
	61	* compare chaddr for ETH_ALEN bytes. */
	62	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETH_ALEN, 0, 12), /* A (the MAC address length) == ETH_ALEN ? */
f11cba74	63	BPF_STMT(BPF_LD + BPF_IMM, unaligned_read_be32(&eth_mac->ether_addr_octet[0])), /* A <- 4 bytes of client's MAC */
088b6ba2 LP	64	BPF_STMT(BPF_MISC + BPF_TAX, 0), /* X <- A */
	65	BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(DHCPPacket, dhcp.chaddr)), /* A <- 4 bytes of MAC from dhcp.chaddr */
	66	BPF_STMT(BPF_ALU + BPF_XOR + BPF_X, 0), /* A xor X */
	67	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0), /* A == 0 ? */
	68	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
f11cba74	69	BPF_STMT(BPF_LD + BPF_IMM, unaligned_read_be16(&eth_mac->ether_addr_octet[4])), /* A <- remainder of client's MAC */
088b6ba2 LP	70	BPF_STMT(BPF_MISC + BPF_TAX, 0), /* X <- A */
	71	BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(DHCPPacket, dhcp.chaddr) + 4), /* A <- remainder of MAC from dhcp.chaddr */
	72	BPF_STMT(BPF_ALU + BPF_XOR + BPF_X, 0), /* A xor X */
	73	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 1, 0), /* A == 0 ? */
	74	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
13f1fd03	75
088b6ba2 LP	76	BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(DHCPPacket, dhcp.magic)), /* A <- DHCP magic cookie */
	77	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, DHCP_MAGIC_COOKIE, 1, 0), /* cookie == DHCP magic cookie ? */
	78	BPF_STMT(BPF_RET + BPF_K, 0), /* ignore */
	79	BPF_STMT(BPF_RET + BPF_K, 65535), /* return all */
bc29e507 TG	80	};
bc29e507 TG	81	struct sock_fprog fprog = {
088b6ba2 LP	82	.len = ELEMENTSOF(filter),
088b6ba2 LP	83	.filter = filter
bc29e507	84	};
c3d2994b	85	_cleanup_close_ int s = -1;
6d5e65f6	86	int r;
8b4a9693	87
088b6ba2	88	assert(ifindex > 0);
23f30ed3 TG	89	assert(link);
23f30ed3 TG	90
66a67eff	91	s = socket(AF_PACKET, SOCK_DGRAM \| SOCK_CLOEXEC \| SOCK_NONBLOCK, 0);
8b4a9693 PF	92	if (s < 0)
	93	return -errno;
	94
2ff48e98	95	r = setsockopt_int(s, SOL_PACKET, PACKET_AUXDATA, true);
c3d2994b	96	if (r < 0)
2ff48e98	97	return r;
c3d2994b TG	98
	99	r = setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER, &fprog, sizeof(fprog));
	100	if (r < 0)
	101	return -errno;
	102
b1f24b75 BG	103	link->ll = (struct sockaddr_ll) {
	104	.sll_family = AF_PACKET,
	105	.sll_protocol = htobe16(ETH_P_IP),
	106	.sll_ifindex = ifindex,
	107	.sll_hatype = htobe16(arp_type),
	108	.sll_halen = mac_addr_len,
	109	};
76253e73	110	memcpy(link->ll.sll_addr, bcast_addr, mac_addr_len);
8b4a9693	111
b1f24b75	112	r = bind(s, &link->sa, SOCKADDR_LL_LEN(link->ll));
c3d2994b	113	if (r < 0)
bc29e507	114	return -errno;
bc29e507	115
c10d6bdb	116	return TAKE_FD(s);
8c00042c PF	117	}
8c00042c PF	118
76253e73 DW	119	int dhcp_network_bind_raw_socket(int ifindex, union sockaddr_union *link,
76253e73 DW	120	uint32_t xid, const uint8_t *mac_addr,
9faed222 SS	121	size_t mac_addr_len, uint16_t arp_type,
9faed222 SS	122	uint16_t port) {
76253e73 DW	123	static const uint8_t eth_bcast[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
	124	/* Default broadcast address for IPoIB */
	125	static const uint8_t ib_bcast[] = {
	126	0x00, 0xff, 0xff, 0xff, 0xff, 0x12, 0x40, 0x1b,
	127	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	128	0xff, 0xff, 0xff, 0xff
	129	};
	130	struct ether_addr eth_mac = { { 0, 0, 0, 0, 0, 0 } };
	131	const uint8_t *bcast_addr = NULL;
	132	uint8_t dhcp_hlen = 0;
	133
76253e73 DW	134	if (arp_type == ARPHRD_ETHER) {
	135	assert_return(mac_addr_len == ETH_ALEN, -EINVAL);
	136	memcpy(&eth_mac, mac_addr, ETH_ALEN);
	137	bcast_addr = eth_bcast;
	138	dhcp_hlen = ETH_ALEN;
	139	} else if (arp_type == ARPHRD_INFINIBAND) {
	140	assert_return(mac_addr_len == INFINIBAND_ALEN, -EINVAL);
	141	bcast_addr = ib_bcast;
	142	} else
	143	return -EINVAL;
	144
	145	return _bind_raw_socket(ifindex, link, xid, mac_addr, mac_addr_len,
9faed222	146	bcast_addr, &eth_mac, arp_type, dhcp_hlen, port);
76253e73 DW	147	}
76253e73 DW	148
3e7b9f76	149	int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port) {
234fc2df PF	150	union sockaddr_union src = {
234fc2df PF	151	.in.sin_family = AF_INET,
080ab276 TG	152	.in.sin_port = htobe16(port),
080ab276 TG	153	.in.sin_addr.s_addr = address,
234fc2df	154	};
c3d2994b	155	_cleanup_close_ int s = -1;
9e5b6496	156	int r;
234fc2df PF	157
	158	s = socket(AF_INET, SOCK_DGRAM \| SOCK_CLOEXEC \| SOCK_NONBLOCK, 0);
	159	if (s < 0)
	160	return -errno;
	161
9e5b6496	162	r = setsockopt_int(s, IPPROTO_IP, IP_TOS, IPTOS_CLASS_CS6);
c3d2994b	163	if (r < 0)
9e5b6496	164	return r;
b44cd882	165
2ff48e98	166	r = setsockopt_int(s, SOL_SOCKET, SO_REUSEADDR, true);
076adf01	167	if (r < 0)
2ff48e98	168	return r;
fef0e0f3	169
3e7b9f76	170	if (ifindex > 0) {
953a02d1	171	r = socket_bind_to_ifindex(s, ifindex);
3e7b9f76	172	if (r < 0)
953a02d1	173	return r;
3e7b9f76 MK	174	}
3e7b9f76 MK	175
076adf01	176	if (address == INADDR_ANY) {
2ff48e98	177	r = setsockopt_int(s, IPPROTO_IP, IP_PKTINFO, true);
fef0e0f3	178	if (r < 0)
2ff48e98	179	return r;
d6bd972d	180
2ff48e98	181	r = setsockopt_int(s, SOL_SOCKET, SO_BROADCAST, true);
d6bd972d	182	if (r < 0)
2ff48e98	183	return r;
3e7b9f76	184
076adf01	185	} else {
2ff48e98	186	r = setsockopt_int(s, IPPROTO_IP, IP_FREEBIND, true);
076adf01	187	if (r < 0)
2ff48e98	188	return r;
fef0e0f3	189	}
85923f79	190
c3d2994b TG	191	r = bind(s, &src.sa, sizeof(src.in));
c3d2994b TG	192	if (r < 0)
234fc2df	193	return -errno;
234fc2df	194
c10d6bdb	195	return TAKE_FD(s);
234fc2df PF	196	}
234fc2df PF	197
8c00042c	198	int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link,
c3d2994b TG	199	const void *packet, size_t len) {
	200	int r;
	201
23f30ed3 TG	202	assert(link);
	203	assert(packet);
	204	assert(len);
	205
b1f24b75	206	r = sendto(s, packet, len, 0, &link->sa, SOCKADDR_LL_LEN(link->ll));
c3d2994b	207	if (r < 0)
1c8035a8	208	return -errno;
8b4a9693	209
1c8035a8	210	return 0;
8b4a9693	211	}
234fc2df	212
080ab276	213	int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port,
c3d2994b	214	const void *packet, size_t len) {
234fc2df PF	215	union sockaddr_union dest = {
234fc2df PF	216	.in.sin_family = AF_INET,
080ab276 TG	217	.in.sin_port = htobe16(port),
080ab276 TG	218	.in.sin_addr.s_addr = address,
234fc2df	219	};
c3d2994b TG	220	int r;
	221
	222	assert(s >= 0);
	223	assert(packet);
	224	assert(len);
234fc2df	225
c3d2994b TG	226	r = sendto(s, packet, len, 0, &dest.sa, sizeof(dest.in));
c3d2994b TG	227	if (r < 0)
234fc2df PF	228	return -errno;
	229
	230	return 0;
	231	}