Debian Codegraph @

src/network/networkd-manager-varlink.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <unistd.h>
4
5 #include "sd-event.h"
6 #include "sd-varlink.h"
7
8 #include "bus-polkit.h"
9 #include "fd-util.h"
10 #include "hashmap.h"
11 #include "json-util.h"
12 #include "lldp-rx-internal.h"
13 #include "network-util.h"
14 #include "networkd-dhcp-server.h"
15 #include "networkd-json.h"
16 #include "networkd-link.h"
17 #include "networkd-link-varlink.h"
18 #include "networkd-manager.h"
19 #include "networkd-manager-varlink.h"
20 #include "stat-util.h"
21 #include "varlink-io.systemd.Network.h"
22 #include "varlink-io.systemd.Network.Link.h"
23 #include "varlink-io.systemd.service.h"
24 #include "varlink-util.h"
25
26 static int vl_method_describe(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
27 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
28 Manager *m = ASSERT_PTR(userdata);
29 int r;
30
31 assert(parameters);
32 assert(link);
33
34 r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
35 if (r != 0)
36 return r;
37
38 r = manager_build_json(m, &v);
39 if (r < 0)
40 return log_error_errno(r, "Failed to format JSON data: %m");
41
42 return sd_varlink_reply(link, v);
43 }
44
45 static int vl_method_get_states(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
46 Manager *m = ASSERT_PTR(userdata);
47 int r;
48
49 assert(link);
50
51 r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
52 if (r != 0)
53 return r;
54
55 return sd_varlink_replybo(
56 link,
57 JSON_BUILD_PAIR_ENUM("AddressState", link_address_state_to_string(m->address_state)),
58 JSON_BUILD_PAIR_ENUM("IPv4AddressState", link_address_state_to_string(m->ipv4_address_state)),
59 JSON_BUILD_PAIR_ENUM("IPv6AddressState", link_address_state_to_string(m->ipv6_address_state)),
60 SD_JSON_BUILD_PAIR_STRING("CarrierState", link_carrier_state_to_string(m->carrier_state)),
61 SD_JSON_BUILD_PAIR_CONDITION(m->online_state >= 0, "OnlineState", JSON_BUILD_STRING_UNDERSCORIFY(link_online_state_to_string(m->online_state))),
62 SD_JSON_BUILD_PAIR_STRING("OperationalState", link_operstate_to_string(m->operational_state)));
63 }
64
65 static int vl_method_get_namespace_id(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
66 uint64_t inode = 0;
67 uint32_t nsid = UINT32_MAX;
68 int r;
69
70 assert(link);
71
72 r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
73 if (r != 0)
74 return r;
75
76 /* Network namespaces have two identifiers: the inode number (which all namespace types have), and
77 * the "nsid" (aka the "cookie"), which only network namespaces know as a concept, and which is not
78 * assigned by default, but once it is, is fixed. Let's return both, to avoid any confusion which one
79 * this is. */
80
81 struct stat st;
82 if (stat("/proc/self/ns/net", &st) < 0)
83 log_warning_errno(errno, "Failed to stat network namespace, ignoring: %m");
84 else
85 inode = st.st_ino;
86
87 r = netns_get_nsid(/* netnsfd= */ -EBADF, &nsid);
88 if (r < 0)
89 log_full_errno(r == -ENODATA ? LOG_DEBUG : LOG_WARNING, r, "Failed to query network nsid, ignoring: %m");
90
91 return sd_varlink_replybo(link,
92 SD_JSON_BUILD_PAIR_UNSIGNED("NamespaceId", inode),
93 SD_JSON_BUILD_PAIR_CONDITION(nsid == UINT32_MAX, "NamespaceNSID", SD_JSON_BUILD_NULL),
94 SD_JSON_BUILD_PAIR_CONDITION(nsid != UINT32_MAX, "NamespaceNSID", SD_JSON_BUILD_UNSIGNED(nsid)));
95 }
96
97 static int link_append_lldp_neighbors(Link *link, sd_json_variant *v, sd_json_variant **array) {
98 assert(link);
99 assert(array);
100
101 return sd_json_variant_append_arraybo(
102 array,
103 SD_JSON_BUILD_PAIR_INTEGER("InterfaceIndex", link->ifindex),
104 SD_JSON_BUILD_PAIR_STRING("InterfaceName", link->ifname),
105 JSON_BUILD_PAIR_STRV_NON_EMPTY("InterfaceAlternativeNames", link->alternative_names),
106 SD_JSON_BUILD_PAIR_CONDITION(sd_json_variant_is_blank_array(v), "Neighbors", SD_JSON_BUILD_EMPTY_ARRAY),
107 SD_JSON_BUILD_PAIR_CONDITION(!sd_json_variant_is_blank_array(v), "Neighbors", SD_JSON_BUILD_VARIANT(v)));
108 }
109
110 static int vl_method_get_lldp_neighbors(sd_varlink *vlink, sd_json_variant *parameters, sd_varlink_method_flags_t flags, Manager *manager) {
111 _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
112 Link *link = NULL;
113 int r;
114
115 assert(vlink);
116 assert(manager);
117
118 r = dispatch_link(vlink, parameters, manager, /* flags= */ 0, &link);
119 if (r != 0)
120 return r;
121
122 if (link) {
123 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
124
125 if (link->lldp_rx) {
126 r = lldp_rx_build_neighbors_json(link->lldp_rx, &v);
127 if (r < 0)
128 return r;
129 }
130
131 r = link_append_lldp_neighbors(link, v, &array);
132 if (r < 0)
133 return r;
134 } else
135 HASHMAP_FOREACH(link, manager->links_by_index) {
136 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
137
138 if (!link->lldp_rx)
139 continue;
140
141 r = lldp_rx_build_neighbors_json(link->lldp_rx, &v);
142 if (r < 0)
143 return r;
144
145 if (sd_json_variant_is_blank_array(v))
146 continue;
147
148 r = link_append_lldp_neighbors(link, v, &array);
149 if (r < 0)
150 return r;
151 }
152
153 return sd_varlink_replybo(
154 vlink,
155 SD_JSON_BUILD_PAIR_CONDITION(sd_json_variant_is_blank_array(array), "Neighbors", SD_JSON_BUILD_EMPTY_ARRAY),
156 SD_JSON_BUILD_PAIR_CONDITION(!sd_json_variant_is_blank_array(array), "Neighbors", SD_JSON_BUILD_VARIANT(array)));
157 }
158
159 static int vl_method_set_persistent_storage(sd_varlink *vlink, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
160 static const sd_json_dispatch_field dispatch_table[] = {
161 { "Ready", SD_JSON_VARIANT_BOOLEAN, sd_json_dispatch_stdbool, 0, 0 },
162 {}
163 };
164
165 Manager *manager = ASSERT_PTR(userdata);
166 bool ready;
167 int r;
168
169 assert(vlink);
170
171 r = sd_varlink_dispatch(vlink, parameters, dispatch_table, &ready);
172 if (r != 0)
173 return r;
174
175 if (ready) {
176 struct stat st, st_prev;
177 int fd;
178
179 fd = sd_varlink_peek_fd(vlink, 0);
180 if (fd < 0)
181 return log_warning_errno(fd, "Failed to peek file descriptor of the persistent storage: %m");
182
183 r = fd_verify_safe_flags_full(fd, O_DIRECTORY);
184 if (r == -EREMOTEIO)
185 return log_warning_errno(r, "Passed persistent storage fd has unexpected flags, refusing.");
186 if (r < 0)
187 return log_warning_errno(r, "Failed to verify flags of passed persistent storage fd: %m");
188
189 r = fd_is_read_only_fs(fd);
190 if (r < 0)
191 return log_warning_errno(r, "Failed to check if the persistent storage is writable: %m");
192 if (r > 0) {
193 log_warning("The persistent storage is on read-only filesystem.");
194 return sd_varlink_error(vlink, "io.systemd.Network.StorageReadOnly", NULL);
195 }
196
197 if (fstat(fd, &st) < 0)
198 return log_warning_errno(errno, "Failed to stat the passed persistent storage fd: %m");
199
200 r = stat_verify_directory(&st);
201 if (r < 0)
202 return log_warning_errno(r, "The passed persistent storage fd is not a directory, refusing: %m");
203
204 if (manager->persistent_storage_fd >= 0 &&
205 fstat(manager->persistent_storage_fd, &st_prev) >= 0 &&
206 stat_inode_same(&st, &st_prev))
207 return sd_varlink_reply(vlink, NULL);
208
209 } else {
210 if (manager->persistent_storage_fd < 0)
211 return sd_varlink_reply(vlink, NULL);
212 }
213
214 r = varlink_verify_polkit_async(
215 vlink,
216 manager->bus,
217 "org.freedesktop.network1.set-persistent-storage",
218 /* details= */ NULL,
219 &manager->polkit_registry);
220 if (r <= 0)
221 return r;
222
223 if (ready) {
224 _cleanup_close_ int fd = -EBADF;
225
226 fd = sd_varlink_take_fd(vlink, 0);
227 if (fd < 0)
228 return log_warning_errno(fd, "Failed to take file descriptor of the persistent storage: %m");
229
230 close_and_replace(manager->persistent_storage_fd, fd);
231 } else
232 manager->persistent_storage_fd = safe_close(manager->persistent_storage_fd);
233
234 manager_toggle_dhcp4_server_state(manager, ready);
235
236 return sd_varlink_reply(vlink, NULL);
237 }
238
239 static int vl_method_reload(sd_varlink *vlink, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
240 Manager *m = ASSERT_PTR(userdata);
241 int r;
242
243 assert(vlink);
244
245 if (m->reloading > 0)
246 return sd_varlink_error(vlink, "io.systemd.Network.AlreadyReloading", NULL);
247
248 r = sd_varlink_dispatch(vlink, parameters, dispatch_table_polkit_only, /* userdata= */ NULL);
249 if (r != 0)
250 return r;
251
252 r = varlink_verify_polkit_async(
253 vlink,
254 m->bus,
255 "org.freedesktop.network1.reload",
256 /* details= */ NULL,
257 &m->polkit_registry);
258 if (r <= 0)
259 return r;
260
261 r = manager_reload(m, /* message= */ NULL, vlink);
262 if (r < 0)
263 return log_error_errno(r, "Failed to reload: %m");
264
265 if (m->reloading > 0)
266 return 0; /* Reply will be sent asynchronously. */
267
268 return sd_varlink_reply(vlink, NULL);
269 }
270
271 int manager_varlink_init(Manager *m, int fd) {
272 _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
273 _unused_ _cleanup_close_ int fd_close = fd; /* take possession */
274 int r;
275
276 assert(m);
277
278 if (m->varlink_server)
279 return 0;
280
281 r = varlink_server_new(
282 &s,
283 SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|
284 SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT,
285 m);
286 if (r < 0)
287 return log_error_errno(r, "Failed to allocate varlink server object: %m");
288
289 (void) sd_varlink_server_set_description(s, "varlink-api-network");
290
291 r = sd_varlink_server_add_interface_many(
292 s,
293 &vl_interface_io_systemd_Network,
294 &vl_interface_io_systemd_Network_Link,
295 &vl_interface_io_systemd_service);
296 if (r < 0)
297 return log_error_errno(r, "Failed to add Network interface to varlink server: %m");
298
299 r = sd_varlink_server_bind_method_many(
300 s,
301 "io.systemd.Network.Describe", vl_method_describe,
302 "io.systemd.Network.GetStates", vl_method_get_states,
303 "io.systemd.Network.GetNamespaceId", vl_method_get_namespace_id,
304 "io.systemd.Network.GetLLDPNeighbors", vl_method_get_lldp_neighbors,
305 "io.systemd.Network.SetPersistentStorage", vl_method_set_persistent_storage,
306 "io.systemd.Network.Link.Describe", vl_method_link_describe,
307 "io.systemd.Network.Link.Up", vl_method_link_up,
308 "io.systemd.Network.Link.Down", vl_method_link_down,
309 "io.systemd.Network.Link.Renew", vl_method_link_renew,
310 "io.systemd.Network.Link.ForceRenew", vl_method_link_force_renew,
311 "io.systemd.Network.Link.Reconfigure", vl_method_link_reconfigure,
312 "io.systemd.service.Ping", varlink_method_ping,
313 "io.systemd.service.Reload", vl_method_reload,
314 "io.systemd.service.SetLogLevel", varlink_method_set_log_level,
315 "io.systemd.service.GetEnvironment", varlink_method_get_environment);
316 if (r < 0)
317 return log_error_errno(r, "Failed to register varlink methods: %m");
318
319 if (fd < 0)
320 r = sd_varlink_server_listen_address(s, "/run/systemd/netif/io.systemd.Network", /* mode= */ 0666);
321 else
322 r = sd_varlink_server_listen_fd(s, fd);
323 if (r < 0)
324 return log_error_errno(r, "Failed to bind to varlink socket '/run/systemd/netif/io.systemd.Network': %m");
325
326 TAKE_FD(fd_close);
327
328 r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
329 if (r < 0)
330 return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
331
332 m->varlink_server = TAKE_PTR(s);
333 return 0;
334 }