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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <netinet/in.h>
#include <linux/if_arp.h>
#include <linux/if.h>

#include "sd-dhcp-server.h"

#include "fd-util.h"
#include "fileio.h"
#include "networkd-address.h"
#include "networkd-dhcp-server.h"
#include "networkd-dhcp-server-bus.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "parse-util.h"
#include "socket-netlink.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"

static bool link_dhcp4_server_enabled(Link *link) {
        assert(link);

        if (link->flags & IFF_LOOPBACK)
                return false;

        if (!link->network)
                return false;

        if (link->iftype == ARPHRD_CAN)
                return false;

        return link->network->dhcp_server;
}

void network_adjust_dhcp_server(Network *network) {
        assert(network);

        if (!network->dhcp_server)
                return;

        if (network->bond) {
                log_warning("%s: DHCPServer= is enabled for bond slave. Disabling DHCP server.",
                            network->filename);
                network->dhcp_server = false;
                return;
        }

        if (!in4_addr_is_set(&network->dhcp_server_address)) {
                Address *address;
                bool have = false;

                ORDERED_HASHMAP_FOREACH(address, network->addresses_by_section) {
                        if (section_is_invalid(address->section))
                                continue;
                        if (address->family == AF_INET &&
                            !in4_addr_is_localhost(&address->in_addr.in) &&
                            in4_addr_is_null(&address->in_addr_peer.in)) {
                                have = true;
                                break;
                        }
                }
                if (!have) {
                        log_warning("%s: DHCPServer= is enabled, but no static address configured. "
                                    "Disabling DHCP server.",
                                    network->filename);
                        network->dhcp_server = false;
                        return;
                }
        }
}

static int link_find_dhcp_server_address(Link *link, Address **ret) {
        Address *address;

        assert(link);
        assert(link->network);

        /* If ServerAddress= is specified, then use the address. */
        if (in4_addr_is_set(&link->network->dhcp_server_address))
                return link_get_ipv4_address(link, &link->network->dhcp_server_address,
                                             link->network->dhcp_server_address_prefixlen, ret);

        /* If not, then select one from static addresses. */
        SET_FOREACH(address, link->static_addresses)
                if (address->family == AF_INET &&
                    !in4_addr_is_localhost(&address->in_addr.in) &&
                    in4_addr_is_null(&address->in_addr_peer.in)) {
                        *ret = address;
                        return 0;
                }

        return -ENOENT;
}

static int link_push_uplink_to_dhcp_server(
                Link *link,
                sd_dhcp_lease_server_type_t what,
                sd_dhcp_server *s) {

        _cleanup_free_ struct in_addr *addresses = NULL;
        bool use_dhcp_lease_data = true;
        size_t n_addresses = 0;

        assert(link);

        if (!link->network)
                return 0;
        assert(link->network);

        log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what));

        switch (what) {

        case SD_DHCP_LEASE_DNS:
                /* For DNS we have a special case. We the data configured explicitly locally along with the
                 * data from the DHCP lease. */

                for (unsigned i = 0; i < link->network->n_dns; i++) {
                        struct in_addr ia;

                        /* Only look for IPv4 addresses */
                        if (link->network->dns[i]->family != AF_INET)
                                continue;

                        ia = link->network->dns[i]->address.in;

                        /* Never propagate obviously borked data */
                        if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia))
                                continue;

                        if (!GREEDY_REALLOC(addresses, n_addresses + 1))
                                return log_oom();

                        addresses[n_addresses++] = ia;
                }

                use_dhcp_lease_data = link->network->dhcp_use_dns;
                break;

        case SD_DHCP_LEASE_NTP: {
                char **i;

                /* For NTP things are similar, but for NTP hostnames can be configured too, which we cannot
                 * propagate via DHCP. Hence let's only propagate those which are IP addresses. */

                STRV_FOREACH(i, link->network->ntp) {
                        union in_addr_union ia;

                        if (in_addr_from_string(AF_INET, *i, &ia) < 0)
                                continue;

                        /* Never propagate obviously borked data */
                        if (in4_addr_is_null(&ia.in) || in4_addr_is_localhost(&ia.in))
                                continue;

                        if (!GREEDY_REALLOC(addresses, n_addresses + 1))
                                return log_oom();

                        addresses[n_addresses++] = ia.in;
                }

                use_dhcp_lease_data = link->network->dhcp_use_ntp;
                break;
        }

        case SD_DHCP_LEASE_SIP:

                /* For SIP we don't allow explicit, local configuration, but there's control whether to use the data */
                use_dhcp_lease_data = link->network->dhcp_use_sip;
                break;

        case SD_DHCP_LEASE_POP3:
        case SD_DHCP_LEASE_SMTP:
        case SD_DHCP_LEASE_LPR:
                /* For the other server types we currently do not allow local configuration of server data,
                 * since there are typically no local consumers of the data. */
                break;

        default:
                assert_not_reached("Unexpected server type");
        }

        if (use_dhcp_lease_data && link->dhcp_lease) {
                const struct in_addr *da;

                int n = sd_dhcp_lease_get_servers(link->dhcp_lease, what, &da);
                if (n > 0) {
                        if (!GREEDY_REALLOC(addresses, n_addresses + n))
                                return log_oom();

                        for (int j = 0; j < n; j++)
                                if (in4_addr_is_non_local(&da[j]))
                                        addresses[n_addresses++] = da[j];
                }
        }

        if (n_addresses <= 0)
                return 0;

        return sd_dhcp_server_set_servers(s, what, addresses, n_addresses);
}

static int dhcp4_server_parse_dns_server_string_and_warn(
                const char *string,
                struct in_addr **addresses,
                size_t *n_addresses) {

        for (;;) {
                _cleanup_free_ char *word = NULL, *server_name = NULL;
                union in_addr_union address;
                int family, r, ifindex = 0;

                r = extract_first_word(&string, &word, NULL, 0);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;

                r = in_addr_ifindex_name_from_string_auto(word, &family, &address, &ifindex, &server_name);
                if (r < 0) {
                        log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring: %m", word);
                        continue;
                }

                /* Only look for IPv4 addresses */
                if (family != AF_INET)
                        continue;

                /* Never propagate obviously borked data */
                if (in4_addr_is_null(&address.in) || in4_addr_is_localhost(&address.in))
                        continue;

                if (!GREEDY_REALLOC(*addresses, *n_addresses + 1))
                        return log_oom();

                (*addresses)[(*n_addresses)++] = address.in;
        }

        return 0;
}

static int dhcp4_server_set_dns_from_resolve_conf(Link *link) {
        _cleanup_free_ struct in_addr *addresses = NULL;
        _cleanup_fclose_ FILE *f = NULL;
        size_t n_addresses = 0;
        int n = 0, r;

        f = fopen(PRIVATE_UPLINK_RESOLV_CONF, "re");
        if (!f) {
                if (errno == ENOENT)
                        return 0;

                return log_warning_errno(errno, "Failed to open " PRIVATE_UPLINK_RESOLV_CONF ": %m");
        }

        for (;;) {
                _cleanup_free_ char *line = NULL;
                const char *a;
                char *l;

                r = read_line(f, LONG_LINE_MAX, &line);
                if (r < 0)
                        return log_error_errno(r, "Failed to read " PRIVATE_UPLINK_RESOLV_CONF ": %m");
                if (r == 0)
                        break;

                n++;

                l = strstrip(line);
                if (IN_SET(*l, '#', ';', 0))
                        continue;

                a = first_word(l, "nameserver");
                if (!a)
                        continue;

                r = dhcp4_server_parse_dns_server_string_and_warn(a, &addresses, &n_addresses);
                if (r < 0)
                        log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring.", a);
        }

        if (n_addresses <= 0)
                return 0;

        return sd_dhcp_server_set_dns(link->dhcp_server, addresses, n_addresses);
}

int dhcp4_server_configure(Link *link) {
        bool acquired_uplink = false;
        sd_dhcp_option *p;
        Link *uplink = NULL;
        Address *address;
        bool bind_to_interface;
        int r;

        assert(link);

        if (!link_dhcp4_server_enabled(link))
                return 0;

        if (!(link->flags & IFF_UP))
                return 0;

        if (!link->dhcp_server) {
                r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
                if (r < 0)
                        return r;

                r = sd_dhcp_server_attach_event(link->dhcp_server, link->manager->event, 0);
                if (r < 0)
                        return r;
        }

        r = sd_dhcp_server_set_callback(link->dhcp_server, dhcp_server_callback, link);
        if (r < 0)
                return log_link_warning_errno(link, r, "Failed to set callback for DHCPv4 server instance: %m");

        r = link_find_dhcp_server_address(link, &address);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to find suitable address for DHCPv4 server instance: %m");

        /* use the server address' subnet as the pool */
        r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen,
                                          link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to configure address pool for DHCPv4 server instance: %m");

        /* TODO:
        r = sd_dhcp_server_set_router(link->dhcp_server, &main_address->in_addr.in);
        if (r < 0)
                return r;
        */

        if (link->network->dhcp_server_max_lease_time_usec > 0) {
                r = sd_dhcp_server_set_max_lease_time(link->dhcp_server,
                                                      DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
                if (r < 0)
                        return log_link_error_errno(link, r, "Failed to set maximum lease time for DHCPv4 server instance: %m");
        }

        if (link->network->dhcp_server_default_lease_time_usec > 0) {
                r = sd_dhcp_server_set_default_lease_time(link->dhcp_server,
                                                          DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
                if (r < 0)
                        return log_link_error_errno(link, r, "Failed to set default lease time for DHCPv4 server instance: %m");
        }

        for (sd_dhcp_lease_server_type_t type = 0; type < _SD_DHCP_LEASE_SERVER_TYPE_MAX; type ++) {

                if (!link->network->dhcp_server_emit[type].emit)
                        continue;

                if (link->network->dhcp_server_emit[type].n_addresses > 0)
                        /* Explicitly specified servers to emit */
                        r = sd_dhcp_server_set_servers(
                                        link->dhcp_server,
                                        type,
                                        link->network->dhcp_server_emit[type].addresses,
                                        link->network->dhcp_server_emit[type].n_addresses);
                else {
                        /* Emission is requested, but nothing explicitly configured. Let's find a suitable upling */
                        if (!acquired_uplink) {
                                uplink = manager_find_uplink(link->manager, link);
                                acquired_uplink = true;
                        }

                        if (uplink && uplink->network)
                                r = link_push_uplink_to_dhcp_server(uplink, type, link->dhcp_server);
                        else if (type == SD_DHCP_LEASE_DNS)
                                r = dhcp4_server_set_dns_from_resolve_conf(link);
                        else {
                                log_link_debug(link,
                                               "Not emitting %s on link, couldn't find suitable uplink.",
                                               dhcp_lease_server_type_to_string(type));
                                continue;
                        }
                }

                if (r < 0)
                        log_link_warning_errno(link, r,
                                               "Failed to set %s for DHCP server, ignoring: %m",
                                               dhcp_lease_server_type_to_string(type));
        }

        r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to set router emission for DHCP server: %m");

        r = sd_dhcp_server_set_relay_target(link->dhcp_server, &link->network->dhcp_server_relay_target);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to set relay target for DHCP server: %m");

        bind_to_interface = sd_dhcp_server_is_in_relay_mode(link->dhcp_server) ? false : link->network->dhcp_server_bind_to_interface;
        r = sd_dhcp_server_set_bind_to_interface(link->dhcp_server, bind_to_interface);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to set interface binding for DHCP server: %m");

        r = sd_dhcp_server_set_relay_agent_information(link->dhcp_server, link->network->dhcp_server_relay_agent_circuit_id, link->network->dhcp_server_relay_agent_remote_id);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to set agent circuit/remote id for DHCP server: %m");

        if (link->network->dhcp_server_emit_timezone) {
                _cleanup_free_ char *buffer = NULL;
                const char *tz = NULL;

                if (link->network->dhcp_server_timezone)
                        tz = link->network->dhcp_server_timezone;
                else {
                        r = get_timezone(&buffer);
                        if (r < 0)
                                log_link_warning_errno(link, r, "Failed to determine timezone, not sending timezone: %m");
                        else
                                tz = buffer;
                }

                if (tz) {
                        r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
                        if (r < 0)
                                return log_link_error_errno(link, r, "Failed to set timezone for DHCP server: %m");
                }
        }

        ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options) {
                r = sd_dhcp_server_add_option(link->dhcp_server, p);
                if (r == -EEXIST)
                        continue;
                if (r < 0)
                        return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
        }

        ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options) {
                r = sd_dhcp_server_add_vendor_option(link->dhcp_server, p);
                if (r == -EEXIST)
                        continue;
                if (r < 0)
                        return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
        }

        if (!sd_dhcp_server_is_running(link->dhcp_server)) {
                r = sd_dhcp_server_start(link->dhcp_server);
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not start DHCPv4 server instance: %m");

                log_link_debug(link, "Offering DHCPv4 leases");
        }

        return 0;
}

int config_parse_dhcp_server_relay_agent_suboption(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        char **suboption_value = data;
        char* p;

        assert(filename);
        assert(lvalue);
        assert(rvalue);

        if (isempty(rvalue)) {
                *suboption_value = mfree(*suboption_value);
                return 0;
        }

        p = startswith(rvalue, "string:");
        if (!p) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "Failed to parse %s=%s'. Invalid format, ignoring.", lvalue, rvalue);
                return 0;
        }
        return free_and_strdup(suboption_value, empty_to_null(p));
}

int config_parse_dhcp_server_emit(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        NetworkDHCPServerEmitAddress *emit = data;

        assert(emit);
        assert(rvalue);

        for (const char *p = rvalue;;) {
                _cleanup_free_ char *w = NULL;
                union in_addr_union a;
                int r;

                r = extract_first_word(&p, &w, NULL, 0);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r,
                                   "Failed to extract word, ignoring: %s", rvalue);
                        return 0;
                }
                if (r == 0)
                        return 0;

                r = in_addr_from_string(AF_INET, w, &a);
                if (r < 0) {
                        log_syntax(unit, LOG_WARNING, filename, line, r,
                                   "Failed to parse %s= address '%s', ignoring: %m", lvalue, w);
                        continue;
                }

                struct in_addr *m = reallocarray(emit->addresses, emit->n_addresses + 1, sizeof(struct in_addr));
                if (!m)
                        return log_oom();

                emit->addresses = m;
                emit->addresses[emit->n_addresses++] = a.in;
        }
}

int config_parse_dhcp_server_address(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        Network *network = userdata;
        union in_addr_union a;
        unsigned char prefixlen;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);

        if (isempty(rvalue)) {
                network->dhcp_server_address = (struct in_addr) {};
                network->dhcp_server_address_prefixlen = 0;
                return 0;
        }

        r = in_addr_prefix_from_string(rvalue, AF_INET, &a, &prefixlen);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
                return 0;
        }
        if (in4_addr_is_null(&a.in) || in4_addr_is_localhost(&a.in)) {
                log_syntax(unit, LOG_WARNING, filename, line, 0,
                           "DHCP server address cannot be the ANY address or a localhost address, "
                           "ignoring assignment: %s", rvalue);
                return 0;
        }

        network->dhcp_server_address = a.in;
        network->dhcp_server_address_prefixlen = prefixlen;
        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
8fcf1d61	2
5ae0fb7f YW	3	#include <netinet/in.h>
	4	#include <linux/if_arp.h>
	5	#include <linux/if.h>
	6
8fcf1d61 YW	7	#include "sd-dhcp-server.h"
8fcf1d61 YW	8
dd1d3060 MAL	9	#include "fd-util.h"
dd1d3060 MAL	10	#include "fileio.h"
093e3533	11	#include "networkd-address.h"
8fcf1d61	12	#include "networkd-dhcp-server.h"
a95e9306	13	#include "networkd-dhcp-server-bus.h"
8fcf1d61 YW	14	#include "networkd-link.h"
	15	#include "networkd-manager.h"
	16	#include "networkd-network.h"
564ca984	17	#include "parse-util.h"
dd1d3060	18	#include "socket-netlink.h"
564ca984 SS	19	#include "string-table.h"
564ca984 SS	20	#include "string-util.h"
dd1d3060	21	#include "strv.h"
8fcf1d61	22
5ae0fb7f YW	23	static bool link_dhcp4_server_enabled(Link *link) {
	24	assert(link);
	25
	26	if (link->flags & IFF_LOOPBACK)
	27	return false;
	28
	29	if (!link->network)
	30	return false;
	31
5ae0fb7f YW	32	if (link->iftype == ARPHRD_CAN)
	33	return false;
	34
	35	return link->network->dhcp_server;
	36	}
	37
0017ba31 YW	38	void network_adjust_dhcp_server(Network *network) {
	39	assert(network);
	40
	41	if (!network->dhcp_server)
	42	return;
	43
	44	if (network->bond) {
	45	log_warning("%s: DHCPServer= is enabled for bond slave. Disabling DHCP server.",
	46	network->filename);
	47	network->dhcp_server = false;
	48	return;
	49	}
	50
	51	if (!in4_addr_is_set(&network->dhcp_server_address)) {
	52	Address *address;
	53	bool have = false;
	54
	55	ORDERED_HASHMAP_FOREACH(address, network->addresses_by_section) {
	56	if (section_is_invalid(address->section))
	57	continue;
	58	if (address->family == AF_INET &&
	59	!in4_addr_is_localhost(&address->in_addr.in) &&
	60	in4_addr_is_null(&address->in_addr_peer.in)) {
	61	have = true;
	62	break;
	63	}
	64	}
	65	if (!have) {
	66	log_warning("%s: DHCPServer= is enabled, but no static address configured. "
	67	"Disabling DHCP server.",
	68	network->filename);
	69	network->dhcp_server = false;
	70	return;
	71	}
	72	}
	73	}
	74
	75	static int link_find_dhcp_server_address(Link link, Address *ret) {
8fcf1d61 YW	76	Address *address;
	77
	78	assert(link);
	79	assert(link->network);
	80
0017ba31 YW	81	/* If ServerAddress= is specified, then use the address. */
	82	if (in4_addr_is_set(&link->network->dhcp_server_address))
	83	return link_get_ipv4_address(link, &link->network->dhcp_server_address,
	84	link->network->dhcp_server_address_prefixlen, ret);
8fcf1d61	85
0017ba31 YW	86	/* If not, then select one from static addresses. */
	87	SET_FOREACH(address, link->static_addresses)
	88	if (address->family == AF_INET &&
	89	!in4_addr_is_localhost(&address->in_addr.in) &&
	90	in4_addr_is_null(&address->in_addr_peer.in)) {
	91	*ret = address;
	92	return 0;
	93	}
8fcf1d61	94
0017ba31	95	return -ENOENT;
8fcf1d61 YW	96	}
8fcf1d61 YW	97
2a71d57f LP	98	static int link_push_uplink_to_dhcp_server(
2a71d57f LP	99	Link *link,
2324fd3a	100	sd_dhcp_lease_server_type_t what,
2a71d57f LP	101	sd_dhcp_server *s) {
2a71d57f LP	102
8fcf1d61	103	_cleanup_free_ struct in_addr *addresses = NULL;
2a71d57f	104	bool use_dhcp_lease_data = true;
319a4f4b	105	size_t n_addresses = 0;
8fcf1d61	106
2a71d57f	107	assert(link);
8fcf1d61	108
2a71d57f LP	109	if (!link->network)
	110	return 0;
	111	assert(link->network);
8fcf1d61	112
2a71d57f	113	log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what));
8fcf1d61	114
2a71d57f	115	switch (what) {
8fcf1d61	116
2a71d57f LP	117	case SD_DHCP_LEASE_DNS:
	118	/* For DNS we have a special case. We the data configured explicitly locally along with the
	119	* data from the DHCP lease. */
8fcf1d61	120
2a71d57f LP	121	for (unsigned i = 0; i < link->network->n_dns; i++) {
2a71d57f LP	122	struct in_addr ia;
8fcf1d61	123
2a71d57f	124	/* Only look for IPv4 addresses */
e77bd3fd	125	if (link->network->dns[i]->family != AF_INET)
2a71d57f	126	continue;
8fcf1d61	127
e77bd3fd	128	ia = link->network->dns[i]->address.in;
2a71d57f LP	129
	130	/* Never propagate obviously borked data */
	131	if (in4_addr_is_null(&ia) \|\| in4_addr_is_localhost(&ia))
	132	continue;
	133
319a4f4b	134	if (!GREEDY_REALLOC(addresses, n_addresses + 1))
8fcf1d61 YW	135	return log_oom();
8fcf1d61 YW	136
2a71d57f	137	addresses[n_addresses++] = ia;
8fcf1d61	138	}
8fcf1d61	139
2a71d57f LP	140	use_dhcp_lease_data = link->network->dhcp_use_dns;
2a71d57f LP	141	break;
8fcf1d61	142
2a71d57f LP	143	case SD_DHCP_LEASE_NTP: {
2a71d57f LP	144	char **i;
8fcf1d61	145
2a71d57f LP	146	/* For NTP things are similar, but for NTP hostnames can be configured too, which we cannot
2a71d57f LP	147	* propagate via DHCP. Hence let's only propagate those which are IP addresses. */
284e8fd0	148
2a71d57f LP	149	STRV_FOREACH(i, link->network->ntp) {
2a71d57f LP	150	union in_addr_union ia;
284e8fd0	151
2a71d57f LP	152	if (in_addr_from_string(AF_INET, *i, &ia) < 0)
2a71d57f LP	153	continue;
284e8fd0	154
2a71d57f LP	155	/* Never propagate obviously borked data */
	156	if (in4_addr_is_null(&ia.in) \|\| in4_addr_is_localhost(&ia.in))
	157	continue;
284e8fd0	158
319a4f4b	159	if (!GREEDY_REALLOC(addresses, n_addresses + 1))
2a71d57f	160	return log_oom();
284e8fd0	161
2a71d57f LP	162	addresses[n_addresses++] = ia.in;
2a71d57f LP	163	}
284e8fd0	164
2a71d57f	165	use_dhcp_lease_data = link->network->dhcp_use_ntp;
24e6f458	166	break;
2a71d57f	167	}
284e8fd0	168
ddb82ec2	169	case SD_DHCP_LEASE_SIP:
2a71d57f LP	170
	171	/* For SIP we don't allow explicit, local configuration, but there's control whether to use the data */
	172	use_dhcp_lease_data = link->network->dhcp_use_sip;
24e6f458	173	break;
284e8fd0	174
2a71d57f LP	175	case SD_DHCP_LEASE_POP3:
2a71d57f LP	176	case SD_DHCP_LEASE_SMTP:
ddb82ec2	177	case SD_DHCP_LEASE_LPR:
2a71d57f LP	178	/* For the other server types we currently do not allow local configuration of server data,
2a71d57f LP	179	* since there are typically no local consumers of the data. */
c4e585a3	180	break;
d361b373	181
24e6f458	182	default:
2a71d57f	183	assert_not_reached("Unexpected server type");
f6269fe7 SS	184	}
f6269fe7 SS	185
2a71d57f	186	if (use_dhcp_lease_data && link->dhcp_lease) {
24e6f458	187	const struct in_addr *da;
f6269fe7	188
a2706075	189	int n = sd_dhcp_lease_get_servers(link->dhcp_lease, what, &da);
f6269fe7	190	if (n > 0) {
319a4f4b	191	if (!GREEDY_REALLOC(addresses, n_addresses + n))
f6269fe7 SS	192	return log_oom();
f6269fe7 SS	193
2a71d57f LP	194	for (int j = 0; j < n; j++)
	195	if (in4_addr_is_non_local(&da[j]))
	196	addresses[n_addresses++] = da[j];
f6269fe7 SS	197	}
	198	}
	199
	200	if (n_addresses <= 0)
	201	return 0;
	202
24e6f458	203	return sd_dhcp_server_set_servers(s, what, addresses, n_addresses);
299d578f SS	204	}
299d578f SS	205
319a4f4b LP	206	static int dhcp4_server_parse_dns_server_string_and_warn(
	207	const char *string,
	208	struct in_addr **addresses,
	209	size_t *n_addresses) {
	210
dd1d3060 MAL	211	for (;;) {
	212	_cleanup_free_ char word = NULL, server_name = NULL;
	213	union in_addr_union address;
	214	int family, r, ifindex = 0;
	215
	216	r = extract_first_word(&string, &word, NULL, 0);
	217	if (r < 0)
	218	return r;
	219	if (r == 0)
	220	break;
	221
	222	r = in_addr_ifindex_name_from_string_auto(word, &family, &address, &ifindex, &server_name);
	223	if (r < 0) {
	224	log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring: %m", word);
	225	continue;
	226	}
	227
	228	/* Only look for IPv4 addresses */
	229	if (family != AF_INET)
	230	continue;
	231
	232	/* Never propagate obviously borked data */
	233	if (in4_addr_is_null(&address.in) \|\| in4_addr_is_localhost(&address.in))
	234	continue;
	235
319a4f4b	236	if (!GREEDY_REALLOC(addresses, n_addresses + 1))
dd1d3060 MAL	237	return log_oom();
	238
	239	(addresses)[(n_addresses)++] = address.in;
	240	}
	241
	242	return 0;
	243	}
	244
	245	static int dhcp4_server_set_dns_from_resolve_conf(Link *link) {
	246	_cleanup_free_ struct in_addr *addresses = NULL;
dd1d3060	247	_cleanup_fclose_ FILE *f = NULL;
319a4f4b	248	size_t n_addresses = 0;
dd1d3060 MAL	249	int n = 0, r;
	250
	251	f = fopen(PRIVATE_UPLINK_RESOLV_CONF, "re");
	252	if (!f) {
	253	if (errno == ENOENT)
	254	return 0;
	255
	256	return log_warning_errno(errno, "Failed to open " PRIVATE_UPLINK_RESOLV_CONF ": %m");
	257	}
	258
	259	for (;;) {
	260	_cleanup_free_ char *line = NULL;
	261	const char *a;
	262	char *l;
	263
	264	r = read_line(f, LONG_LINE_MAX, &line);
	265	if (r < 0)
	266	return log_error_errno(r, "Failed to read " PRIVATE_UPLINK_RESOLV_CONF ": %m");
	267	if (r == 0)
	268	break;
	269
	270	n++;
	271
	272	l = strstrip(line);
	273	if (IN_SET(*l, '#', ';', 0))
	274	continue;
	275
	276	a = first_word(l, "nameserver");
	277	if (!a)
	278	continue;
	279
319a4f4b	280	r = dhcp4_server_parse_dns_server_string_and_warn(a, &addresses, &n_addresses);
dd1d3060 MAL	281	if (r < 0)
	282	log_warning_errno(r, "Failed to parse DNS server address '%s', ignoring.", a);
	283	}
	284
	285	if (n_addresses <= 0)
	286	return 0;
	287
	288	return sd_dhcp_server_set_dns(link->dhcp_server, addresses, n_addresses);
	289	}
	290
8fcf1d61	291	int dhcp4_server_configure(Link *link) {
8fcf1d61	292	bool acquired_uplink = false;
461dbb2f	293	sd_dhcp_option *p;
564ca984 SS	294	Link *uplink = NULL;
564ca984 SS	295	Address *address;
11c38d3e	296	bool bind_to_interface;
8fcf1d61 YW	297	int r;
8fcf1d61 YW	298
5ae0fb7f YW	299	assert(link);
	300
	301	if (!link_dhcp4_server_enabled(link))
	302	return 0;
	303
	304	if (!(link->flags & IFF_UP))
	305	return 0;
	306
	307	if (!link->dhcp_server) {
	308	r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
	309	if (r < 0)
	310	return r;
	311
	312	r = sd_dhcp_server_attach_event(link->dhcp_server, link->manager->event, 0);
	313	if (r < 0)
	314	return r;
	315	}
	316
a95e9306 LK	317	r = sd_dhcp_server_set_callback(link->dhcp_server, dhcp_server_callback, link);
	318	if (r < 0)
	319	return log_link_warning_errno(link, r, "Failed to set callback for DHCPv4 server instance: %m");
	320
0017ba31 YW	321	r = link_find_dhcp_server_address(link, &address);
	322	if (r < 0)
	323	return log_link_error_errno(link, r, "Failed to find suitable address for DHCPv4 server instance: %m");
8fcf1d61 YW	324
	325	/* use the server address' subnet as the pool */
	326	r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen,
	327	link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size);
	328	if (r < 0)
c00c3b64	329	return log_link_error_errno(link, r, "Failed to configure address pool for DHCPv4 server instance: %m");
8fcf1d61 YW	330
	331	/* TODO:
	332	r = sd_dhcp_server_set_router(link->dhcp_server, &main_address->in_addr.in);
	333	if (r < 0)
	334	return r;
	335	*/
	336
	337	if (link->network->dhcp_server_max_lease_time_usec > 0) {
	338	r = sd_dhcp_server_set_max_lease_time(link->dhcp_server,
	339	DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
	340	if (r < 0)
c00c3b64	341	return log_link_error_errno(link, r, "Failed to set maximum lease time for DHCPv4 server instance: %m");
8fcf1d61 YW	342	}
	343
	344	if (link->network->dhcp_server_default_lease_time_usec > 0) {
	345	r = sd_dhcp_server_set_default_lease_time(link->dhcp_server,
	346	DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
	347	if (r < 0)
c00c3b64	348	return log_link_error_errno(link, r, "Failed to set default lease time for DHCPv4 server instance: %m");
8fcf1d61 YW	349	}
8fcf1d61 YW	350
2324fd3a	351	for (sd_dhcp_lease_server_type_t type = 0; type < _SD_DHCP_LEASE_SERVER_TYPE_MAX; type ++) {
2a71d57f LP	352
	353	if (!link->network->dhcp_server_emit[type].emit)
	354	continue;
	355
	356	if (link->network->dhcp_server_emit[type].n_addresses > 0)
	357	/* Explicitly specified servers to emit */
	358	r = sd_dhcp_server_set_servers(
	359	link->dhcp_server,
	360	type,
	361	link->network->dhcp_server_emit[type].addresses,
	362	link->network->dhcp_server_emit[type].n_addresses);
	363	else {
	364	/* Emission is requested, but nothing explicitly configured. Let's find a suitable upling */
	365	if (!acquired_uplink) {
	366	uplink = manager_find_uplink(link->manager, link);
	367	acquired_uplink = true;
	368	}
	369
	370	if (uplink && uplink->network)
	371	r = link_push_uplink_to_dhcp_server(uplink, type, link->dhcp_server);
	372	else if (type == SD_DHCP_LEASE_DNS)
	373	r = dhcp4_server_set_dns_from_resolve_conf(link);
24e6f458	374	else {
2a71d57f LP	375	log_link_debug(link,
	376	"Not emitting %s on link, couldn't find suitable uplink.",
	377	dhcp_lease_server_type_to_string(type));
	378	continue;
24e6f458	379	}
299d578f	380	}
284e8fd0	381
2a71d57f LP	382	if (r < 0)
	383	log_link_warning_errno(link, r,
	384	"Failed to set %s for DHCP server, ignoring: %m",
	385	dhcp_lease_server_type_to_string(type));
	386	}
	387
8fcf1d61 YW	388	r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);
8fcf1d61 YW	389	if (r < 0)
a0fa3ef7	390	return log_link_error_errno(link, r, "Failed to set router emission for DHCP server: %m");
8fcf1d61	391
c95df587 YA	392	r = sd_dhcp_server_set_relay_target(link->dhcp_server, &link->network->dhcp_server_relay_target);
	393	if (r < 0)
	394	return log_link_error_errno(link, r, "Failed to set relay target for DHCP server: %m");
	395
11c38d3e YA	396	bind_to_interface = sd_dhcp_server_is_in_relay_mode(link->dhcp_server) ? false : link->network->dhcp_server_bind_to_interface;
	397	r = sd_dhcp_server_set_bind_to_interface(link->dhcp_server, bind_to_interface);
	398	if (r < 0)
	399	return log_link_error_errno(link, r, "Failed to set interface binding for DHCP server: %m");
	400
	401	r = sd_dhcp_server_set_relay_agent_information(link->dhcp_server, link->network->dhcp_server_relay_agent_circuit_id, link->network->dhcp_server_relay_agent_remote_id);
	402	if (r < 0)
	403	return log_link_error_errno(link, r, "Failed to set agent circuit/remote id for DHCP server: %m");
	404
8fcf1d61 YW	405	if (link->network->dhcp_server_emit_timezone) {
8fcf1d61 YW	406	_cleanup_free_ char *buffer = NULL;
7b5018ca	407	const char *tz = NULL;
8fcf1d61 YW	408
	409	if (link->network->dhcp_server_timezone)
	410	tz = link->network->dhcp_server_timezone;
	411	else {
	412	r = get_timezone(&buffer);
	413	if (r < 0)
7b5018ca	414	log_link_warning_errno(link, r, "Failed to determine timezone, not sending timezone: %m");
	415	else
	416	tz = buffer;
8fcf1d61 YW	417	}
8fcf1d61 YW	418
7b5018ca	419	if (tz) {
	420	r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
	421	if (r < 0)
	422	return log_link_error_errno(link, r, "Failed to set timezone for DHCP server: %m");
	423	}
8fcf1d61	424	}
564ca984	425
90e74a66	426	ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_options) {
461dbb2f	427	r = sd_dhcp_server_add_option(link->dhcp_server, p);
564ca984 SS	428	if (r == -EEXIST)
	429	continue;
	430	if (r < 0)
c00c3b64	431	return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
564ca984 SS	432	}
564ca984 SS	433
90e74a66	434	ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_send_vendor_options) {
7354900d DW	435	r = sd_dhcp_server_add_vendor_option(link->dhcp_server, p);
	436	if (r == -EEXIST)
	437	continue;
	438	if (r < 0)
	439	return log_link_error_errno(link, r, "Failed to set DHCPv4 option: %m");
	440	}
	441
8fcf1d61 YW	442	if (!sd_dhcp_server_is_running(link->dhcp_server)) {
	443	r = sd_dhcp_server_start(link->dhcp_server);
	444	if (r < 0)
a0fa3ef7	445	return log_link_error_errno(link, r, "Could not start DHCPv4 server instance: %m");
5ae0fb7f YW	446
5ae0fb7f YW	447	log_link_debug(link, "Offering DHCPv4 leases");
8fcf1d61 YW	448	}
	449
	450	return 0;
	451	}
	452
11c38d3e YA	453	int config_parse_dhcp_server_relay_agent_suboption(
	454	const char *unit,
	455	const char *filename,
	456	unsigned line,
	457	const char *section,
	458	unsigned section_line,
	459	const char *lvalue,
	460	int ltype,
	461	const char *rvalue,
	462	void *data,
	463	void *userdata) {
	464
	465	char **suboption_value = data;
	466	char* p;
	467
	468	assert(filename);
	469	assert(lvalue);
	470	assert(rvalue);
	471
11c38d3e YA	472	if (isempty(rvalue)) {
	473	suboption_value = mfree(suboption_value);
	474	return 0;
	475	}
	476
	477	p = startswith(rvalue, "string:");
	478	if (!p) {
	479	log_syntax(unit, LOG_WARNING, filename, line, 0,
	480	"Failed to parse %s=%s'. Invalid format, ignoring.", lvalue, rvalue);
	481	return 0;
	482	}
	483	return free_and_strdup(suboption_value, empty_to_null(p));
	484	}
	485
2a71d57f	486	int config_parse_dhcp_server_emit(
8fcf1d61 YW	487	const char *unit,
	488	const char *filename,
	489	unsigned line,
2a71d57f LP	490	const char *section,
2a71d57f LP	491	unsigned section_line,
8fcf1d61	492	const char *lvalue,
2a71d57f	493	int ltype,
8fcf1d61	494	const char *rvalue,
2a71d57f LP	495	void *data,
2a71d57f LP	496	void *userdata) {
8fcf1d61	497
2a71d57f LP	498	NetworkDHCPServerEmitAddress *emit = data;
	499
	500	assert(emit);
8fcf1d61 YW	501	assert(rvalue);
8fcf1d61 YW	502
c1997a5b	503	for (const char *p = rvalue;;) {
8fcf1d61 YW	504	_cleanup_free_ char *w = NULL;
8fcf1d61 YW	505	union in_addr_union a;
c1997a5b	506	int r;
8fcf1d61 YW	507
	508	r = extract_first_word(&p, &w, NULL, 0);
	509	if (r == -ENOMEM)
	510	return log_oom();
	511	if (r < 0) {
d96edb2c	512	log_syntax(unit, LOG_WARNING, filename, line, r,
8fcf1d61 YW	513	"Failed to extract word, ignoring: %s", rvalue);
	514	return 0;
	515	}
	516	if (r == 0)
c1997a5b	517	return 0;
8fcf1d61 YW	518
	519	r = in_addr_from_string(AF_INET, w, &a);
	520	if (r < 0) {
d96edb2c	521	log_syntax(unit, LOG_WARNING, filename, line, r,
c1997a5b	522	"Failed to parse %s= address '%s', ignoring: %m", lvalue, w);
8fcf1d61 YW	523	continue;
	524	}
	525
2a71d57f	526	struct in_addr *m = reallocarray(emit->addresses, emit->n_addresses + 1, sizeof(struct in_addr));
8fcf1d61 YW	527	if (!m)
	528	return log_oom();
	529
2a71d57f LP	530	emit->addresses = m;
2a71d57f LP	531	emit->addresses[emit->n_addresses++] = a.in;
8fcf1d61	532	}
8fcf1d61	533	}
0017ba31 YW	534
	535	int config_parse_dhcp_server_address(
	536	const char *unit,
	537	const char *filename,
	538	unsigned line,
	539	const char *section,
	540	unsigned section_line,
	541	const char *lvalue,
	542	int ltype,
	543	const char *rvalue,
	544	void *data,
	545	void *userdata) {
	546
	547	Network *network = userdata;
	548	union in_addr_union a;
	549	unsigned char prefixlen;
	550	int r;
	551
	552	assert(filename);
	553	assert(lvalue);
	554	assert(rvalue);
	555
	556	if (isempty(rvalue)) {
	557	network->dhcp_server_address = (struct in_addr) {};
	558	network->dhcp_server_address_prefixlen = 0;
	559	return 0;
	560	}
	561
	562	r = in_addr_prefix_from_string(rvalue, AF_INET, &a, &prefixlen);
	563	if (r < 0) {
	564	log_syntax(unit, LOG_WARNING, filename, line, r,
	565	"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
	566	return 0;
	567	}
	568	if (in4_addr_is_null(&a.in) \|\| in4_addr_is_localhost(&a.in)) {
	569	log_syntax(unit, LOG_WARNING, filename, line, 0,
	570	"DHCP server address cannot be the ANY address or a localhost address, "
	571	"ignoring assignment: %s", rvalue);
	572	return 0;
	573	}
	574
	575	network->dhcp_server_address = a.in;
	576	network->dhcp_server_address_prefixlen = prefixlen;
	577	return 0;
	578	}