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

/* SPDX-License-Identifier: LGPL-2.1+ */

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

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_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_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_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 allocated = 0, 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, allocated, 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(fd);
        fd = -1;

        return 0;
}

_public_ sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
        int fd;

        if (m) {
                fd = MONITOR_TO_FD(m);
                close_nointr(fd);
        }

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