[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 "inotify-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;
}

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

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

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

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

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

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

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

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

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

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)];
        _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)];
        _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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int sd_network_link_get_dns_default_route(int ifindex) {
        char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex)];
        _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)];
        _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;
}

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

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

int sd_network_link_get_stat(int ifindex, struct stat *ret) {
        char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex)];
        struct stat st;

        assert_return(ifindex > 0, -EINVAL);

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

        if (stat(path, &st) < 0)
                return -errno;

        if (ret)
                *ret = st;

        return 0;
}

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

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

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

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

        return wd;
}

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

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

        return NULL;
}

int sd_network_monitor_flush(sd_network_monitor *m) {
        union inotify_event_buffer buffer;
        ssize_t l;
        int fd;

        assert_return(m, -EINVAL);

        fd = MONITOR_TO_FD(m);

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

                return -errno;
        }

        FOREACH_INOTIFY_EVENT(e, buffer, l) {
                if (e->mask & IN_ISDIR) {
                        int wd;

                        wd = monitor_add_inotify_watch(fd);
                        if (wd < 0)
                                return wd;

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

        return 0;
}

int sd_network_monitor_get_fd(sd_network_monitor *m) {

        assert_return(m, -EINVAL);

        return MONITOR_TO_FD(m);
}

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

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