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

_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 (ERRNO_IS_TRANSIENT(errno))
                        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"
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
ac999bf0 YW	40	_public_ int sd_network_get_operational_state(char **state) {
	41	return network_get_string("OPER_STATE", state);
	42	}
	43
	44	_public_ int sd_network_get_carrier_state(char **state) {
	45	return network_get_string("CARRIER_STATE", state);
	46	}
	47
	48	_public_ int sd_network_get_address_state(char **state) {
	49	return network_get_string("ADDRESS_STATE", state);
	50	}
	51
bbea8813 L	52	_public_ int sd_network_get_ipv4_address_state(char **state) {
	53	return network_get_string("IPV4_ADDRESS_STATE", state);
	54	}
	55
	56	_public_ int sd_network_get_ipv6_address_state(char **state) {
	57	return network_get_string("IPV6_ADDRESS_STATE", state);
	58	}
	59
bcdcc596 AŠ	60	_public_ int sd_network_get_online_state(char **state) {
	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
	93	_public_ int sd_network_get_dns(char ***ret) {
	94	return network_get_strv("DNS", ret);
	95	}
	96
	97	_public_ int sd_network_get_ntp(char ***ret) {
	98	return network_get_strv("NTP", ret);
	99	}
	100
3df9bec5	101	_public_ int sd_network_get_search_domains(char ***ret) {
8612e936 LP	102	return network_get_strv("DOMAINS", ret);
	103	}
	104
3df9bec5 LP	105	_public_ int sd_network_get_route_domains(char ***ret) {
	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) {
fbd0b64f	110	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
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) {
fbd0b64f	133	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
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
38e5900f LP	164	_public_ int sd_network_link_get_setup_state(int ifindex, char **state) {
	165	return network_link_get_string(ifindex, "ADMIN_STATE", state);
	166	}
adc5b2e2	167
38e5900f LP	168	_public_ int sd_network_link_get_network_file(int ifindex, char **filename) {
38e5900f LP	169	return network_link_get_string(ifindex, "NETWORK_FILE", filename);
adc5b2e2 TG	170	}
adc5b2e2 TG	171
d6731e4c	172	_public_ 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
bbea8813 L	176	_public_ int sd_network_link_get_required_family_for_online(int ifindex, char **state) {
	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
ac999bf0 YW	196	_public_ int sd_network_link_get_carrier_state(int ifindex, char **state) {
	197	return network_link_get_string(ifindex, "CARRIER_STATE", state);
	198	}
	199
	200	_public_ int sd_network_link_get_address_state(int ifindex, char **state) {
	201	return network_link_get_string(ifindex, "ADDRESS_STATE", state);
	202	}
	203
bbea8813 L	204	_public_ int sd_network_link_get_ipv4_address_state(int ifindex, char **state) {
	205	return network_link_get_string(ifindex, "IPV4_ADDRESS_STATE", state);
	206	}
	207
	208	_public_ int sd_network_link_get_ipv6_address_state(int ifindex, char **state) {
	209	return network_link_get_string(ifindex, "IPV6_ADDRESS_STATE", state);
	210	}
	211
bcdcc596 AŠ	212	_public_ int sd_network_link_get_online_state(int ifindex, char **state) {
	213	return network_link_get_string(ifindex, "ONLINE_STATE", state);
	214	}
	215
01dd1380 SS	216	_public_ int sd_network_link_get_dhcp6_client_iaid_string(int ifindex, char **iaid) {
	217	return network_link_get_string(ifindex, "DHCP6_CLIENT_IAID", iaid);
	218	}
	219
a9deab2e SS	220	_public_ int sd_network_link_get_dhcp6_client_duid_string(int ifindex, char **duid) {
	221	return network_link_get_string(ifindex, "DHCP6_CLIENT_DUID", duid);
	222	}
	223
c1a38904 MTL	224	_public_ int sd_network_link_get_required_for_online(int ifindex) {
	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
22eab27c YW	239	_public_ int sd_network_link_get_required_operstate_for_online(int ifindex, char **state) {
	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
a853652a DS	260	_public_ int sd_network_link_get_activation_policy(int ifindex, char **policy) {
	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
d6731e4c	281	_public_ 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
aaa297d4 LP	285	_public_ int sd_network_link_get_mdns(int ifindex, char **mdns) {
	286	return network_link_get_string(ifindex, "MDNS", mdns);
	287	}
	288
c9299be2 IT	289	_public_ int sd_network_link_get_dns_over_tls(int ifindex, char **dns_over_tls) {
c9299be2 IT	290	return network_link_get_string(ifindex, "DNS_OVER_TLS", dns_over_tls);
d050561a IT	291	}
d050561a IT	292
ad6c0475 LP	293	_public_ int sd_network_link_get_dnssec(int ifindex, char **dnssec) {
	294	return network_link_get_string(ifindex, "DNSSEC", dnssec);
	295	}
	296
8a516214 LP	297	_public_ int sd_network_link_get_dnssec_negative_trust_anchors(int ifindex, char ***nta) {
	298	return network_link_get_strv(ifindex, "DNSSEC_NTA", nta);
	299	}
	300
d6731e4c	301	_public_ 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
d6731e4c	305	_public_ 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
eb46288c SS	309	_public_ int sd_network_link_get_sip(int ifindex, char ***ret) {
	310	return network_link_get_strv(ifindex, "SIP", ret);
	311	}
	312
3df9bec5	313	_public_ 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
3df9bec5 LP	317	_public_ int sd_network_link_get_route_domains(int ifindex, char ***ret) {
	318	return network_link_get_strv(ifindex, "ROUTE_DOMAINS", ret);
	319	}
	320
c629354e LP	321	_public_ int sd_network_link_get_dns_default_route(int ifindex) {
	322	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
	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) {
fbd0b64f	341	char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex) + 1];
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
	382	_public_ int sd_network_link_get_carrier_bound_to(int ifindex, int **ret) {
	383	return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_TO", ret);
0d4ad91d AR	384	}
0d4ad91d AR	385
b295beea LP	386	_public_ int sd_network_link_get_carrier_bound_by(int ifindex, int **ret) {
b295beea LP	387	return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_BY", ret);
0d4ad91d AR	388	}
0d4ad91d AR	389
a1e92eee	390	static int MONITOR_TO_FD(sd_network_monitor *m) {
fe8db0c5 TG	391	return (int) (unsigned long) m - 1;
	392	}
	393
a1e92eee	394	static sd_network_monitor* FD_TO_MONITOR(int fd) {
fe8db0c5 TG	395	return (sd_network_monitor*) (unsigned long) (fd + 1);
	396	}
	397
870395a4 TG	398	static int monitor_add_inotify_watch(int fd) {
	399	int k;
	400
	401	k = inotify_add_watch(fd, "/run/systemd/netif/links/", IN_MOVED_TO\|IN_DELETE);
	402	if (k >= 0)
	403	return 0;
	404	else if (errno != ENOENT)
	405	return -errno;
	406
	407	k = inotify_add_watch(fd, "/run/systemd/netif/", IN_CREATE\|IN_ISDIR);
	408	if (k >= 0)
	409	return 0;
	410	else if (errno != ENOENT)
	411	return -errno;
	412
	413	k = inotify_add_watch(fd, "/run/systemd/", IN_CREATE\|IN_ISDIR);
	414	if (k < 0)
	415	return -errno;
	416
	417	return 0;
	418	}
	419
0014a4ad	420	_public_ int sd_network_monitor_new(sd_network_monitor *m, const char category) {
870395a4 TG	421	_cleanup_close_ int fd = -1;
870395a4 TG	422	int k;
fe8db0c5 TG	423	bool good = false;
	424
	425	assert_return(m, -EINVAL);
	426
	427	fd = inotify_init1(IN_NONBLOCK\|IN_CLOEXEC);
	428	if (fd < 0)
	429	return -errno;
	430
7e141e49	431	if (!category \|\| streq(category, "links")) {
870395a4 TG	432	k = monitor_add_inotify_watch(fd);
	433	if (k < 0)
	434	return k;
fe8db0c5 TG	435
	436	good = true;
	437	}
	438
3de1c8ce	439	if (!good)
fe8db0c5	440	return -EINVAL;
fe8db0c5	441
d52e1c42	442	*m = FD_TO_MONITOR(TAKE_FD(fd));
fe8db0c5 TG	443	return 0;
	444	}
	445
	446	_public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
d52e1c42	447	if (m)
b87dfaa2	448	(void) close_nointr(MONITOR_TO_FD(m));
fe8db0c5 TG	449
	450	return NULL;
	451	}
	452
	453	_public_ int sd_network_monitor_flush(sd_network_monitor *m) {
870395a4 TG	454	union inotify_event_buffer buffer;
	455	struct inotify_event *e;
	456	ssize_t l;
	457	int fd, k;
fe8db0c5 TG	458
	459	assert_return(m, -EINVAL);
	460
870395a4 TG	461	fd = MONITOR_TO_FD(m);
	462
	463	l = read(fd, &buffer, sizeof(buffer));
	464	if (l < 0) {
8add30a0	465	if (ERRNO_IS_TRANSIENT(errno))
870395a4 TG	466	return 0;
	467
	468	return -errno;
	469	}
	470
	471	FOREACH_INOTIFY_EVENT(e, buffer, l) {
	472	if (e->mask & IN_ISDIR) {
	473	k = monitor_add_inotify_watch(fd);
	474	if (k < 0)
	475	return k;
	476
	477	k = inotify_rm_watch(fd, e->wd);
	478	if (k < 0)
	479	return -errno;
	480	}
	481	}
	482
	483	return 0;
fe8db0c5 TG	484	}
	485
	486	_public_ int sd_network_monitor_get_fd(sd_network_monitor *m) {
	487
	488	assert_return(m, -EINVAL);
	489
	490	return MONITOR_TO_FD(m);
	491	}
	492
	493	_public_ int sd_network_monitor_get_events(sd_network_monitor *m) {
	494
	495	assert_return(m, -EINVAL);
	496
	497	/* For now we will only return POLLIN here, since we don't
	498	* need anything else ever for inotify. However, let's have
	499	* this API to keep our options open should we later on need
	500	* it. */
	501	return POLLIN;
	502	}
	503
	504	_public_ int sd_network_monitor_get_timeout(sd_network_monitor m, uint64_t timeout_usec) {
	505
	506	assert_return(m, -EINVAL);
	507	assert_return(timeout_usec, -EINVAL);
	508
f5fbe71d	509	/* For now we will only return UINT64_MAX, since we don't
fe8db0c5 TG	510	* need any timeout. However, let's have this API to keep our
fe8db0c5 TG	511	* options open should we later on need it. */
f5fbe71d	512	*timeout_usec = UINT64_MAX;
fe8db0c5 TG	513	return 0;
fe8db0c5 TG	514	}