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

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

#include <errno.h>
#include <poll.h>
#include <sys/inotify.h>

#include "sd-network.h"

#include "alloc-util.h"
#include "env-file.h"
#include "fd-util.h"
#include "fs-util.h"
#include "macro.h"
#include "parse-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
#include "util.h"

static int network_get_string(const char *field, char **ret) {
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(ret, -EINVAL);

        r = parse_env_file(NULL, "/run/systemd/netif/state", field, &s);
        if (r == -ENOENT)
                return -ENODATA;
        if (r < 0)
                return r;
        if (isempty(s))
                return -ENODATA;

        *ret = TAKE_PTR(s);

        return 0;
}

_public_ int sd_network_get_operational_state(char **state) {
        return network_get_string("OPER_STATE", state);
}

_public_ int sd_network_get_carrier_state(char **state) {
        return network_get_string("CARRIER_STATE", state);
}

_public_ int sd_network_get_address_state(char **state) {
        return network_get_string("ADDRESS_STATE", state);
}

_public_ int sd_network_get_ipv4_address_state(char **state) {
        return network_get_string("IPV4_ADDRESS_STATE", state);
}

_public_ int sd_network_get_ipv6_address_state(char **state) {
        return network_get_string("IPV6_ADDRESS_STATE", state);
}

_public_ int sd_network_get_online_state(char **state) {
        return network_get_string("ONLINE_STATE", state);
}

static int network_get_strv(const char *key, char ***ret) {
        _cleanup_strv_free_ char **a = NULL;
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(ret, -EINVAL);

        r = parse_env_file(NULL, "/run/systemd/netif/state", key, &s);
        if (r == -ENOENT)
                return -ENODATA;
        if (r < 0)
                return r;
        if (isempty(s)) {
                *ret = NULL;
                return 0;
        }

        a = strv_split(s, " ");
        if (!a)
                return -ENOMEM;

        strv_uniq(a);
        r = (int) strv_length(a);

        *ret = TAKE_PTR(a);

        return r;
}

_public_ int sd_network_get_dns(char ***ret) {
        return network_get_strv("DNS", ret);
}

_public_ int sd_network_get_ntp(char ***ret) {
        return network_get_strv("NTP", ret);
}

_public_ int sd_network_get_search_domains(char ***ret) {
        return network_get_strv("DOMAINS", ret);
}

_public_ int sd_network_get_route_domains(char ***ret) {
        return network_get_strv("ROUTE_DOMAINS", ret);
}

static int network_link_get_string(int ifindex, const char *field, char **ret) {
        char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(ifindex > 0, -EINVAL);
        assert_return(ret, -EINVAL);

        xsprintf(path, "/run/systemd/netif/links/%i", ifindex);

        r = parse_env_file(NULL, path, field, &s);
        if (r == -ENOENT)
                return -ENODATA;
        if (r < 0)
                return r;
        if (isempty(s))
                return -ENODATA;

        *ret = TAKE_PTR(s);

        return 0;
}

static int network_link_get_strv(int ifindex, const char *key, char ***ret) {
        char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
        _cleanup_strv_free_ char **a = NULL;
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(ifindex > 0, -EINVAL);
        assert_return(ret, -EINVAL);

        xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
        r = parse_env_file(NULL, path, key, &s);
        if (r == -ENOENT)
                return -ENODATA;
        if (r < 0)
                return r;
        if (isempty(s)) {
                *ret = NULL;
                return 0;
        }

        a = strv_split(s, " ");
        if (!a)
                return -ENOMEM;

        strv_uniq(a);
        r = (int) strv_length(a);

        *ret = TAKE_PTR(a);

        return r;
}

_public_ int sd_network_link_get_setup_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "ADMIN_STATE", state);
}

_public_ int sd_network_link_get_network_file(int ifindex, char **filename) {
        return network_link_get_string(ifindex, "NETWORK_FILE", filename);
}

_public_ int sd_network_link_get_operational_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "OPER_STATE", state);
}

_public_ int sd_network_link_get_required_family_for_online(int ifindex, char **state) {
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(state, -EINVAL);

        r = network_link_get_string(ifindex, "REQUIRED_FAMILY_FOR_ONLINE", &s);
        if (r < 0) {
                if (r != -ENODATA)
                        return r;

                s = strdup("any");
                if (!s)
                        return -ENOMEM;
        }

        *state = TAKE_PTR(s);
        return 0;
}

_public_ int sd_network_link_get_carrier_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "CARRIER_STATE", state);
}

_public_ int sd_network_link_get_address_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "ADDRESS_STATE", state);
}

_public_ int sd_network_link_get_ipv4_address_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "IPV4_ADDRESS_STATE", state);
}

_public_ int sd_network_link_get_ipv6_address_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "IPV6_ADDRESS_STATE", state);
}

_public_ int sd_network_link_get_online_state(int ifindex, char **state) {
        return network_link_get_string(ifindex, "ONLINE_STATE", state);
}

_public_ int sd_network_link_get_dhcp6_client_iaid_string(int ifindex, char **iaid) {
        return network_link_get_string(ifindex, "DHCP6_CLIENT_IAID", iaid);
}

_public_ int sd_network_link_get_dhcp6_client_duid_string(int ifindex, char **duid) {
        return network_link_get_string(ifindex, "DHCP6_CLIENT_DUID", duid);
}

_public_ int sd_network_link_get_required_for_online(int ifindex) {
        _cleanup_free_ char *s = NULL;
        int r;

        r = network_link_get_string(ifindex, "REQUIRED_FOR_ONLINE", &s);
        if (r < 0) {
                /* Handle -ENODATA as RequiredForOnline=yes, for compatibility */
                if (r == -ENODATA)
                        return true;
                return r;
        }

        return parse_boolean(s);
}

_public_ int sd_network_link_get_required_operstate_for_online(int ifindex, char **state) {
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(state, -EINVAL);

        r = network_link_get_string(ifindex, "REQUIRED_OPER_STATE_FOR_ONLINE", &s);
        if (r < 0) {
                if (r != -ENODATA)
                        return r;

                /* For compatibility, assuming degraded. */
                s = strdup("degraded");
                if (!s)
                        return -ENOMEM;
        }

        *state = TAKE_PTR(s);
        return 0;
}

_public_ int sd_network_link_get_activation_policy(int ifindex, char **policy) {
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(policy, -EINVAL);

        r = network_link_get_string(ifindex, "ACTIVATION_POLICY", &s);
        if (r < 0) {
                if (r != -ENODATA)
                        return r;

                /* For compatibility, assuming up. */
                s = strdup("up");
                if (!s)
                        return -ENOMEM;
        }

        *policy = TAKE_PTR(s);
        return 0;
}

_public_ int sd_network_link_get_llmnr(int ifindex, char **llmnr) {
        return network_link_get_string(ifindex, "LLMNR", llmnr);
}

_public_ int sd_network_link_get_mdns(int ifindex, char **mdns) {
        return network_link_get_string(ifindex, "MDNS", mdns);
}

_public_ int sd_network_link_get_dns_over_tls(int ifindex, char **dns_over_tls) {
        return network_link_get_string(ifindex, "DNS_OVER_TLS", dns_over_tls);
}

_public_ int sd_network_link_get_dnssec(int ifindex, char **dnssec) {
        return network_link_get_string(ifindex, "DNSSEC", dnssec);
}

_public_ int sd_network_link_get_dnssec_negative_trust_anchors(int ifindex, char ***nta) {
        return network_link_get_strv(ifindex, "DNSSEC_NTA", nta);
}

_public_ int sd_network_link_get_dns(int ifindex, char ***ret) {
        return network_link_get_strv(ifindex, "DNS", ret);
}

_public_ int sd_network_link_get_ntp(int ifindex, char ***ret) {
        return network_link_get_strv(ifindex, "NTP", ret);
}

_public_ int sd_network_link_get_sip(int ifindex, char ***ret) {
        return network_link_get_strv(ifindex, "SIP", ret);
}

_public_ int sd_network_link_get_search_domains(int ifindex, char ***ret) {
        return network_link_get_strv(ifindex, "DOMAINS", ret);
}

_public_ int sd_network_link_get_route_domains(int ifindex, char ***ret) {
        return network_link_get_strv(ifindex, "ROUTE_DOMAINS", ret);
}

_public_ int sd_network_link_get_dns_default_route(int ifindex) {
        char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
        _cleanup_free_ char *s = NULL;
        int r;

        assert_return(ifindex > 0, -EINVAL);

        xsprintf(path, "/run/systemd/netif/links/%i", ifindex);

        r = parse_env_file(NULL, path, "DNS_DEFAULT_ROUTE", &s);
        if (r == -ENOENT)
                return -ENODATA;
        if (r < 0)
                return r;
        if (isempty(s))
                return -ENODATA;
        return parse_boolean(s);
}

static int network_link_get_ifindexes(int ifindex, const char *key, int **ret) {
        char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
        _cleanup_free_ int *ifis = NULL;
        _cleanup_free_ char *s = NULL;
        size_t c = 0;
        int r;

        assert_return(ifindex > 0, -EINVAL);
        assert_return(ret, -EINVAL);

        xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
        r = parse_env_file(NULL, path, key, &s);
        if (r == -ENOENT)
                return -ENODATA;
        if (r < 0)
                return r;

        for (const char *x = s;;) {
                _cleanup_free_ char *word = NULL;

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

                if (!GREEDY_REALLOC(ifis, c + 2))
                        return -ENOMEM;

                r = ifis[c++] = parse_ifindex(word);
                if (r < 0)
                        return r;
        }

        if (ifis)
                ifis[c] = 0; /* Let's add a 0 ifindex to the end, to be nice */

        *ret = TAKE_PTR(ifis);

        return c;
}

_public_ int sd_network_link_get_carrier_bound_to(int ifindex, int **ret) {
        return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_TO", ret);
}

_public_ int sd_network_link_get_carrier_bound_by(int ifindex, int **ret) {
        return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_BY", ret);
}

static int MONITOR_TO_FD(sd_network_monitor *m) {
        return (int) (unsigned long) m - 1;
}

static sd_network_monitor* FD_TO_MONITOR(int fd) {
        return (sd_network_monitor*) (unsigned long) (fd + 1);
}

static int monitor_add_inotify_watch(int fd) {
        int k;

        k = inotify_add_watch(fd, "/run/systemd/netif/links/", IN_MOVED_TO|IN_DELETE);
        if (k >= 0)
                return 0;
        else if (errno != ENOENT)
                return -errno;

        k = inotify_add_watch(fd, "/run/systemd/netif/", IN_CREATE|IN_ISDIR);
        if (k >= 0)
                return 0;
        else if (errno != ENOENT)
                return -errno;

        k = inotify_add_watch(fd, "/run/systemd/", IN_CREATE|IN_ISDIR);
        if (k < 0)
                return -errno;

        return 0;
}

_public_ int sd_network_monitor_new(sd_network_monitor **m, const char *category) {
        _cleanup_close_ int fd = -1;
        int k;
        bool good = false;

        assert_return(m, -EINVAL);

        fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
        if (fd < 0)
                return -errno;

        if (!category || streq(category, "links")) {
                k = monitor_add_inotify_watch(fd);
                if (k < 0)
                        return k;

                good = true;
        }

        if (!good)
                return -EINVAL;

        *m = FD_TO_MONITOR(TAKE_FD(fd));
        return 0;
}

_public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
        if (m)
                (void) close_nointr(MONITOR_TO_FD(m));

        return NULL;
}

_public_ int sd_network_monitor_flush(sd_network_monitor *m) {
        union inotify_event_buffer buffer;
        struct inotify_event *e;
        ssize_t l;
        int fd, k;

        assert_return(m, -EINVAL);

        fd = MONITOR_TO_FD(m);

        l = read(fd, &buffer, sizeof(buffer));
        if (l < 0) {
                if (IN_SET(errno, EAGAIN, EINTR))
                        return 0;

                return -errno;
        }

        FOREACH_INOTIFY_EVENT(e, buffer, l) {
                if (e->mask & IN_ISDIR) {
                        k = monitor_add_inotify_watch(fd);
                        if (k < 0)
                                return k;

                        k = inotify_rm_watch(fd, e->wd);
                        if (k < 0)
                                return -errno;
                }
        }

        return 0;
}

_public_ int sd_network_monitor_get_fd(sd_network_monitor *m) {

        assert_return(m, -EINVAL);

        return MONITOR_TO_FD(m);
}

_public_ int sd_network_monitor_get_events(sd_network_monitor *m) {

        assert_return(m, -EINVAL);

        /* For now we will only return POLLIN here, since we don't
         * need anything else ever for inotify.  However, let's have
         * this API to keep our options open should we later on need
         * it. */
        return POLLIN;
}

_public_ int sd_network_monitor_get_timeout(sd_network_monitor *m, uint64_t *timeout_usec) {

        assert_return(m, -EINVAL);
        assert_return(timeout_usec, -EINVAL);

        /* For now we will only return UINT64_MAX, since we don't
         * need any timeout. However, let's have this API to keep our
         * options open should we later on need it. */
        *timeout_usec = UINT64_MAX;
        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
fe8db0c5	2
fe8db0c5	3	#include <errno.h>
0a6f50c0	4	#include <poll.h>
07630cea	5	#include <sys/inotify.h>
fe8db0c5	6
07630cea LP	7	#include "sd-network.h"
07630cea LP	8
b5efdb8a	9	#include "alloc-util.h"
686d13b9	10	#include "env-file.h"
77601719	11	#include "fd-util.h"
77601719	12	#include "fs-util.h"
fe8db0c5	13	#include "macro.h"
77601719	14	#include "parse-util.h"
5f02f341	15	#include "stdio-util.h"
07630cea	16	#include "string-util.h"
fe8db0c5	17	#include "strv.h"
07630cea	18	#include "util.h"
fe8db0c5	19
ac999bf0	20	static int network_get_string(const char field, char *ret) {
03cc0fd1	21	_cleanup_free_ char *s = NULL;
deb2e523 TG	22	int r;
deb2e523 TG	23
ac999bf0	24	assert_return(ret, -EINVAL);
fe8db0c5	25
ac999bf0	26	r = parse_env_file(NULL, "/run/systemd/netif/state", field, &s);
cb6fa44c TG	27	if (r == -ENOENT)
cb6fa44c TG	28	return -ENODATA;
03cc0fd1	29	if (r < 0)
fe8db0c5	30	return r;
03cc0fd1 LP	31	if (isempty(s))
03cc0fd1 LP	32	return -ENODATA;
deb2e523	33
ac999bf0	34	*ret = TAKE_PTR(s);
deb2e523 TG	35
	36	return 0;
	37	}
	38
ac999bf0 YW	39	_public_ int sd_network_get_operational_state(char **state) {
	40	return network_get_string("OPER_STATE", state);
	41	}
	42
	43	_public_ int sd_network_get_carrier_state(char **state) {
	44	return network_get_string("CARRIER_STATE", state);
	45	}
	46
	47	_public_ int sd_network_get_address_state(char **state) {
	48	return network_get_string("ADDRESS_STATE", state);
	49	}
	50
bbea8813 L	51	_public_ int sd_network_get_ipv4_address_state(char **state) {
	52	return network_get_string("IPV4_ADDRESS_STATE", state);
	53	}
	54
	55	_public_ int sd_network_get_ipv6_address_state(char **state) {
	56	return network_get_string("IPV6_ADDRESS_STATE", state);
	57	}
	58
bcdcc596 AŠ	59	_public_ int sd_network_get_online_state(char **state) {
	60	return network_get_string("ONLINE_STATE", state);
	61	}
	62
03cc0fd1 LP	63	static int network_get_strv(const char key, char **ret) {
03cc0fd1 LP	64	_cleanup_strv_free_ char **a = NULL;
bbf7c048 TG	65	_cleanup_free_ char *s = NULL;
	66	int r;
	67
03cc0fd1 LP	68	assert_return(ret, -EINVAL);
03cc0fd1 LP	69
13df9c39	70	r = parse_env_file(NULL, "/run/systemd/netif/state", key, &s);
03cc0fd1 LP	71	if (r == -ENOENT)
	72	return -ENODATA;
	73	if (r < 0)
	74	return r;
	75	if (isempty(s)) {
	76	*ret = NULL;
	77	return 0;
	78	}
	79
	80	a = strv_split(s, " ");
	81	if (!a)
	82	return -ENOMEM;
	83
	84	strv_uniq(a);
da6053d0	85	r = (int) strv_length(a);
03cc0fd1	86
ae2a15bc	87	*ret = TAKE_PTR(a);
03cc0fd1 LP	88
	89	return r;
	90	}
	91
	92	_public_ int sd_network_get_dns(char ***ret) {
	93	return network_get_strv("DNS", ret);
	94	}
	95
	96	_public_ int sd_network_get_ntp(char ***ret) {
	97	return network_get_strv("NTP", ret);
	98	}
	99
3df9bec5	100	_public_ int sd_network_get_search_domains(char ***ret) {
8612e936 LP	101	return network_get_strv("DOMAINS", ret);
	102	}
	103
3df9bec5 LP	104	_public_ int sd_network_get_route_domains(char ***ret) {
	105	return network_get_strv("ROUTE_DOMAINS", ret);
	106	}
	107
38e5900f	108	static int network_link_get_string(int ifindex, const char field, char *ret) {
fbd0b64f	109	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
5f02f341	110	_cleanup_free_ char *s = NULL;
03cc0fd1 LP	111	int r;
	112
	113	assert_return(ifindex > 0, -EINVAL);
38e5900f	114	assert_return(ret, -EINVAL);
bbf7c048	115
5f02f341	116	xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
03cc0fd1	117
13df9c39	118	r = parse_env_file(NULL, path, field, &s);
bbf7c048 TG	119	if (r == -ENOENT)
bbf7c048 TG	120	return -ENODATA;
03cc0fd1	121	if (r < 0)
bbf7c048	122	return r;
03cc0fd1 LP	123	if (isempty(s))
03cc0fd1 LP	124	return -ENODATA;
bbf7c048	125
ae2a15bc	126	*ret = TAKE_PTR(s);
bbf7c048 TG	127
	128	return 0;
	129	}
	130
8a516214	131	static int network_link_get_strv(int ifindex, const char key, char **ret) {
fbd0b64f	132	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
8a516214	133	_cleanup_strv_free_ char **a = NULL;
5f02f341	134	_cleanup_free_ char *s = NULL;
8a516214 LP	135	int r;
	136
	137	assert_return(ifindex > 0, -EINVAL);
	138	assert_return(ret, -EINVAL);
	139
5f02f341	140	xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
13df9c39	141	r = parse_env_file(NULL, path, key, &s);
8a516214 LP	142	if (r == -ENOENT)
	143	return -ENODATA;
	144	if (r < 0)
	145	return r;
	146	if (isempty(s)) {
	147	*ret = NULL;
	148	return 0;
	149	}
	150
	151	a = strv_split(s, " ");
	152	if (!a)
	153	return -ENOMEM;
	154
	155	strv_uniq(a);
da6053d0	156	r = (int) strv_length(a);
8a516214	157
ae2a15bc	158	*ret = TAKE_PTR(a);
8a516214 LP	159
	160	return r;
	161	}
	162
38e5900f LP	163	_public_ int sd_network_link_get_setup_state(int ifindex, char **state) {
	164	return network_link_get_string(ifindex, "ADMIN_STATE", state);
	165	}
adc5b2e2	166
38e5900f LP	167	_public_ int sd_network_link_get_network_file(int ifindex, char **filename) {
38e5900f LP	168	return network_link_get_string(ifindex, "NETWORK_FILE", filename);
adc5b2e2 TG	169	}
adc5b2e2 TG	170
d6731e4c	171	_public_ int sd_network_link_get_operational_state(int ifindex, char **state) {
38e5900f	172	return network_link_get_string(ifindex, "OPER_STATE", state);
fe8db0c5 TG	173	}
fe8db0c5 TG	174
bbea8813 L	175	_public_ int sd_network_link_get_required_family_for_online(int ifindex, char **state) {
	176	_cleanup_free_ char *s = NULL;
	177	int r;
	178
	179	assert_return(state, -EINVAL);
	180
	181	r = network_link_get_string(ifindex, "REQUIRED_FAMILY_FOR_ONLINE", &s);
	182	if (r < 0) {
	183	if (r != -ENODATA)
	184	return r;
	185
	186	s = strdup("any");
	187	if (!s)
	188	return -ENOMEM;
	189	}
	190
	191	*state = TAKE_PTR(s);
	192	return 0;
	193	}
	194
ac999bf0 YW	195	_public_ int sd_network_link_get_carrier_state(int ifindex, char **state) {
	196	return network_link_get_string(ifindex, "CARRIER_STATE", state);
	197	}
	198
	199	_public_ int sd_network_link_get_address_state(int ifindex, char **state) {
	200	return network_link_get_string(ifindex, "ADDRESS_STATE", state);
	201	}
	202
bbea8813 L	203	_public_ int sd_network_link_get_ipv4_address_state(int ifindex, char **state) {
	204	return network_link_get_string(ifindex, "IPV4_ADDRESS_STATE", state);
	205	}
	206
	207	_public_ int sd_network_link_get_ipv6_address_state(int ifindex, char **state) {
	208	return network_link_get_string(ifindex, "IPV6_ADDRESS_STATE", state);
	209	}
	210
bcdcc596 AŠ	211	_public_ int sd_network_link_get_online_state(int ifindex, char **state) {
	212	return network_link_get_string(ifindex, "ONLINE_STATE", state);
	213	}
	214
01dd1380 SS	215	_public_ int sd_network_link_get_dhcp6_client_iaid_string(int ifindex, char **iaid) {
	216	return network_link_get_string(ifindex, "DHCP6_CLIENT_IAID", iaid);
	217	}
	218
a9deab2e SS	219	_public_ int sd_network_link_get_dhcp6_client_duid_string(int ifindex, char **duid) {
	220	return network_link_get_string(ifindex, "DHCP6_CLIENT_DUID", duid);
	221	}
	222
c1a38904 MTL	223	_public_ int sd_network_link_get_required_for_online(int ifindex) {
	224	_cleanup_free_ char *s = NULL;
	225	int r;
	226
	227	r = network_link_get_string(ifindex, "REQUIRED_FOR_ONLINE", &s);
	228	if (r < 0) {
	229	/* Handle -ENODATA as RequiredForOnline=yes, for compatibility */
	230	if (r == -ENODATA)
	231	return true;
	232	return r;
	233	}
	234
	235	return parse_boolean(s);
	236	}
	237
22eab27c YW	238	_public_ int sd_network_link_get_required_operstate_for_online(int ifindex, char **state) {
	239	_cleanup_free_ char *s = NULL;
	240	int r;
	241
	242	assert_return(state, -EINVAL);
	243
	244	r = network_link_get_string(ifindex, "REQUIRED_OPER_STATE_FOR_ONLINE", &s);
	245	if (r < 0) {
	246	if (r != -ENODATA)
	247	return r;
	248
	249	/* For compatibility, assuming degraded. */
	250	s = strdup("degraded");
	251	if (!s)
	252	return -ENOMEM;
	253	}
	254
	255	*state = TAKE_PTR(s);
	256	return 0;
	257	}
	258
a853652a DS	259	_public_ int sd_network_link_get_activation_policy(int ifindex, char **policy) {
	260	_cleanup_free_ char *s = NULL;
	261	int r;
	262
	263	assert_return(policy, -EINVAL);
	264
	265	r = network_link_get_string(ifindex, "ACTIVATION_POLICY", &s);
	266	if (r < 0) {
	267	if (r != -ENODATA)
	268	return r;
	269
	270	/* For compatibility, assuming up. */
	271	s = strdup("up");
	272	if (!s)
	273	return -ENOMEM;
	274	}
	275
	276	*policy = TAKE_PTR(s);
	277	return 0;
	278	}
	279
d6731e4c	280	_public_ int sd_network_link_get_llmnr(int ifindex, char **llmnr) {
38e5900f	281	return network_link_get_string(ifindex, "LLMNR", llmnr);
bd8f6538 TG	282	}
bd8f6538 TG	283
aaa297d4 LP	284	_public_ int sd_network_link_get_mdns(int ifindex, char **mdns) {
	285	return network_link_get_string(ifindex, "MDNS", mdns);
	286	}
	287
c9299be2 IT	288	_public_ int sd_network_link_get_dns_over_tls(int ifindex, char **dns_over_tls) {
c9299be2 IT	289	return network_link_get_string(ifindex, "DNS_OVER_TLS", dns_over_tls);
d050561a IT	290	}
d050561a IT	291
ad6c0475 LP	292	_public_ int sd_network_link_get_dnssec(int ifindex, char **dnssec) {
	293	return network_link_get_string(ifindex, "DNSSEC", dnssec);
	294	}
	295
8a516214 LP	296	_public_ int sd_network_link_get_dnssec_negative_trust_anchors(int ifindex, char ***nta) {
	297	return network_link_get_strv(ifindex, "DNSSEC_NTA", nta);
	298	}
	299
d6731e4c	300	_public_ int sd_network_link_get_dns(int ifindex, char ***ret) {
8a516214	301	return network_link_get_strv(ifindex, "DNS", ret);
bcb7a07e TG	302	}
bcb7a07e TG	303
d6731e4c	304	_public_ int sd_network_link_get_ntp(int ifindex, char ***ret) {
8a516214	305	return network_link_get_strv(ifindex, "NTP", ret);
bcb7a07e TG	306	}
bcb7a07e TG	307
eb46288c SS	308	_public_ int sd_network_link_get_sip(int ifindex, char ***ret) {
	309	return network_link_get_strv(ifindex, "SIP", ret);
	310	}
	311
3df9bec5	312	_public_ int sd_network_link_get_search_domains(int ifindex, char ***ret) {
8a516214	313	return network_link_get_strv(ifindex, "DOMAINS", ret);
9b4d1882 TG	314	}
9b4d1882 TG	315
3df9bec5 LP	316	_public_ int sd_network_link_get_route_domains(int ifindex, char ***ret) {
	317	return network_link_get_strv(ifindex, "ROUTE_DOMAINS", ret);
	318	}
	319
c629354e LP	320	_public_ int sd_network_link_get_dns_default_route(int ifindex) {
	321	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
	322	_cleanup_free_ char *s = NULL;
	323	int r;
	324
	325	assert_return(ifindex > 0, -EINVAL);
	326
	327	xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
	328
	329	r = parse_env_file(NULL, path, "DNS_DEFAULT_ROUTE", &s);
	330	if (r == -ENOENT)
	331	return -ENODATA;
	332	if (r < 0)
	333	return r;
	334	if (isempty(s))
	335	return -ENODATA;
	336	return parse_boolean(s);
	337	}
	338
b295beea	339	static int network_link_get_ifindexes(int ifindex, const char key, int *ret) {
fbd0b64f	340	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
b295beea	341	_cleanup_free_ int *ifis = NULL;
5f02f341	342	_cleanup_free_ char *s = NULL;
319a4f4b	343	size_t c = 0;
b295beea LP	344	int r;
	345
	346	assert_return(ifindex > 0, -EINVAL);
	347	assert_return(ret, -EINVAL);
	348
5f02f341	349	xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
13df9c39	350	r = parse_env_file(NULL, path, key, &s);
b295beea LP	351	if (r == -ENOENT)
	352	return -ENODATA;
	353	if (r < 0)
	354	return r;
b295beea	355
597da51b	356	for (const char *x = s;;) {
b295beea LP	357	_cleanup_free_ char *word = NULL;
	358
	359	r = extract_first_word(&x, &word, NULL, 0);
	360	if (r < 0)
	361	return r;
	362	if (r == 0)
	363	break;
	364
319a4f4b	365	if (!GREEDY_REALLOC(ifis, c + 2))
b295beea LP	366	return -ENOMEM;
b295beea LP	367
597da51b ZJS	368	r = ifis[c++] = parse_ifindex(word);
	369	if (r < 0)
	370	return r;
b295beea LP	371	}
b295beea LP	372
c58bd76a	373	if (ifis)
13e785f7	374	ifis[c] = 0; /* Let's add a 0 ifindex to the end, to be nice */
b295beea	375
ae2a15bc	376	*ret = TAKE_PTR(ifis);
b295beea LP	377
	378	return c;
	379	}
	380
	381	_public_ int sd_network_link_get_carrier_bound_to(int ifindex, int **ret) {
	382	return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_TO", ret);
0d4ad91d AR	383	}
0d4ad91d AR	384
b295beea LP	385	_public_ int sd_network_link_get_carrier_bound_by(int ifindex, int **ret) {
b295beea LP	386	return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_BY", ret);
0d4ad91d AR	387	}
0d4ad91d AR	388
a1e92eee	389	static int MONITOR_TO_FD(sd_network_monitor *m) {
fe8db0c5 TG	390	return (int) (unsigned long) m - 1;
	391	}
	392
a1e92eee	393	static sd_network_monitor* FD_TO_MONITOR(int fd) {
fe8db0c5 TG	394	return (sd_network_monitor*) (unsigned long) (fd + 1);
	395	}
	396
870395a4 TG	397	static int monitor_add_inotify_watch(int fd) {
	398	int k;
	399
	400	k = inotify_add_watch(fd, "/run/systemd/netif/links/", IN_MOVED_TO\|IN_DELETE);
	401	if (k >= 0)
	402	return 0;
	403	else if (errno != ENOENT)
	404	return -errno;
	405
	406	k = inotify_add_watch(fd, "/run/systemd/netif/", IN_CREATE\|IN_ISDIR);
	407	if (k >= 0)
	408	return 0;
	409	else if (errno != ENOENT)
	410	return -errno;
	411
	412	k = inotify_add_watch(fd, "/run/systemd/", IN_CREATE\|IN_ISDIR);
	413	if (k < 0)
	414	return -errno;
	415
	416	return 0;
	417	}
	418
0014a4ad	419	_public_ int sd_network_monitor_new(sd_network_monitor *m, const char category) {
870395a4 TG	420	_cleanup_close_ int fd = -1;
870395a4 TG	421	int k;
fe8db0c5 TG	422	bool good = false;
	423
	424	assert_return(m, -EINVAL);
	425
	426	fd = inotify_init1(IN_NONBLOCK\|IN_CLOEXEC);
	427	if (fd < 0)
	428	return -errno;
	429
7e141e49	430	if (!category \|\| streq(category, "links")) {
870395a4 TG	431	k = monitor_add_inotify_watch(fd);
	432	if (k < 0)
	433	return k;
fe8db0c5 TG	434
	435	good = true;
	436	}
	437
3de1c8ce	438	if (!good)
fe8db0c5	439	return -EINVAL;
fe8db0c5	440
d52e1c42	441	*m = FD_TO_MONITOR(TAKE_FD(fd));
fe8db0c5 TG	442	return 0;
	443	}
	444
	445	_public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
d52e1c42	446	if (m)
b87dfaa2	447	(void) close_nointr(MONITOR_TO_FD(m));
fe8db0c5 TG	448
	449	return NULL;
	450	}
	451
	452	_public_ int sd_network_monitor_flush(sd_network_monitor *m) {
870395a4 TG	453	union inotify_event_buffer buffer;
	454	struct inotify_event *e;
	455	ssize_t l;
	456	int fd, k;
fe8db0c5 TG	457
	458	assert_return(m, -EINVAL);
	459
870395a4 TG	460	fd = MONITOR_TO_FD(m);
	461
	462	l = read(fd, &buffer, sizeof(buffer));
	463	if (l < 0) {
945c2931	464	if (IN_SET(errno, EAGAIN, EINTR))
870395a4 TG	465	return 0;
	466
	467	return -errno;
	468	}
	469
	470	FOREACH_INOTIFY_EVENT(e, buffer, l) {
	471	if (e->mask & IN_ISDIR) {
	472	k = monitor_add_inotify_watch(fd);
	473	if (k < 0)
	474	return k;
	475
	476	k = inotify_rm_watch(fd, e->wd);
	477	if (k < 0)
	478	return -errno;
	479	}
	480	}
	481
	482	return 0;
fe8db0c5 TG	483	}
	484
	485	_public_ int sd_network_monitor_get_fd(sd_network_monitor *m) {
	486
	487	assert_return(m, -EINVAL);
	488
	489	return MONITOR_TO_FD(m);
	490	}
	491
	492	_public_ int sd_network_monitor_get_events(sd_network_monitor *m) {
	493
	494	assert_return(m, -EINVAL);
	495
	496	/* For now we will only return POLLIN here, since we don't
	497	* need anything else ever for inotify. However, let's have
	498	* this API to keep our options open should we later on need
	499	* it. */
	500	return POLLIN;
	501	}
	502
	503	_public_ int sd_network_monitor_get_timeout(sd_network_monitor m, uint64_t timeout_usec) {
	504
	505	assert_return(m, -EINVAL);
	506	assert_return(timeout_usec, -EINVAL);
	507
f5fbe71d	508	/* For now we will only return UINT64_MAX, since we don't
fe8db0c5 TG	509	* need any timeout. However, let's have this API to keep our
fe8db0c5 TG	510	* options open should we later on need it. */
f5fbe71d	511	*timeout_usec = UINT64_MAX;
fe8db0c5 TG	512	return 0;
fe8db0c5 TG	513	}