Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include "sd-netlink.h"
4 : :
5 : : #include "alloc-util.h"
6 : : #include "conf-parser.h"
7 : : #include "ether-addr-util.h"
8 : : #include "hashmap.h"
9 : : #include "in-addr-util.h"
10 : : #include "netlink-util.h"
11 : : #include "networkd-link.h"
12 : : #include "networkd-manager.h"
13 : : #include "networkd-neighbor.h"
14 : : #include "set.h"
15 : :
16 : 0 : void neighbor_free(Neighbor *neighbor) {
17 [ # # ]: 0 : if (!neighbor)
18 : 0 : return;
19 : :
20 [ # # ]: 0 : if (neighbor->network) {
21 [ # # # # : 0 : LIST_REMOVE(neighbors, neighbor->network->neighbors, neighbor);
# # # # ]
22 [ # # ]: 0 : assert(neighbor->network->n_neighbors > 0);
23 : 0 : neighbor->network->n_neighbors--;
24 : :
25 [ # # ]: 0 : if (neighbor->section)
26 : 0 : hashmap_remove(neighbor->network->neighbors_by_section, neighbor->section);
27 : : }
28 : :
29 : 0 : network_config_section_free(neighbor->section);
30 : :
31 [ # # ]: 0 : if (neighbor->link) {
32 : 0 : set_remove(neighbor->link->neighbors, neighbor);
33 : 0 : set_remove(neighbor->link->neighbors_foreign, neighbor);
34 : : }
35 : :
36 : 0 : free(neighbor);
37 : : }
38 : :
39 : 0 : static int neighbor_new_static(Network *network, const char *filename, unsigned section_line, Neighbor **ret) {
40 : 0 : _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
41 : 0 : _cleanup_(neighbor_freep) Neighbor *neighbor = NULL;
42 : : int r;
43 : :
44 [ # # ]: 0 : assert(network);
45 [ # # ]: 0 : assert(ret);
46 [ # # ]: 0 : assert(!!filename == (section_line > 0));
47 : :
48 [ # # ]: 0 : if (filename) {
49 : 0 : r = network_config_section_new(filename, section_line, &n);
50 [ # # ]: 0 : if (r < 0)
51 : 0 : return r;
52 : :
53 : 0 : neighbor = hashmap_get(network->neighbors_by_section, n);
54 [ # # ]: 0 : if (neighbor) {
55 : 0 : *ret = TAKE_PTR(neighbor);
56 : :
57 : 0 : return 0;
58 : : }
59 : : }
60 : :
61 : 0 : neighbor = new(Neighbor, 1);
62 [ # # ]: 0 : if (!neighbor)
63 : 0 : return -ENOMEM;
64 : :
65 : 0 : *neighbor = (Neighbor) {
66 : : .network = network,
67 : : .family = AF_UNSPEC,
68 : : };
69 : :
70 [ # # # # : 0 : LIST_APPEND(neighbors, network->neighbors, neighbor);
# # # # #
# # # ]
71 : 0 : network->n_neighbors++;
72 : :
73 [ # # ]: 0 : if (filename) {
74 : 0 : neighbor->section = TAKE_PTR(n);
75 : :
76 : 0 : r = hashmap_ensure_allocated(&network->neighbors_by_section, &network_config_hash_ops);
77 [ # # ]: 0 : if (r < 0)
78 : 0 : return r;
79 : :
80 : 0 : r = hashmap_put(network->neighbors_by_section, neighbor->section, neighbor);
81 [ # # ]: 0 : if (r < 0)
82 : 0 : return r;
83 : : }
84 : :
85 : 0 : *ret = TAKE_PTR(neighbor);
86 : :
87 : 0 : return 0;
88 : : }
89 : :
90 : 0 : static int neighbor_configure_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
91 : : int r;
92 : :
93 [ # # ]: 0 : assert(m);
94 [ # # ]: 0 : assert(link);
95 [ # # ]: 0 : assert(link->neighbor_messages > 0);
96 : :
97 : 0 : link->neighbor_messages--;
98 : :
99 [ # # # # ]: 0 : if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
100 : 0 : return 1;
101 : :
102 : 0 : r = sd_netlink_message_get_errno(m);
103 [ # # # # ]: 0 : if (r < 0 && r != -EEXIST)
104 : : /* Neighbor may not exist yet. So, do not enter failed state here. */
105 [ # # # # ]: 0 : log_link_warning_errno(link, r, "Could not set neighbor, ignoring: %m");
106 : :
107 [ # # ]: 0 : if (link->neighbor_messages == 0) {
108 [ # # # # ]: 0 : log_link_debug(link, "Neighbors set");
109 : 0 : link->neighbors_configured = true;
110 : 0 : link_check_ready(link);
111 : : }
112 : :
113 : 0 : return 1;
114 : : }
115 : :
116 : 0 : int neighbor_configure(Neighbor *neighbor, Link *link, link_netlink_message_handler_t callback) {
117 : 0 : _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
118 : : int r;
119 : :
120 [ # # ]: 0 : assert(neighbor);
121 [ # # ]: 0 : assert(link);
122 [ # # ]: 0 : assert(link->ifindex > 0);
123 [ # # ]: 0 : assert(link->manager);
124 [ # # ]: 0 : assert(link->manager->rtnl);
125 : :
126 : 0 : r = sd_rtnl_message_new_neigh(link->manager->rtnl, &req, RTM_NEWNEIGH,
127 : : link->ifindex, neighbor->family);
128 [ # # ]: 0 : if (r < 0)
129 [ # # ]: 0 : return log_error_errno(r, "Could not allocate RTM_NEWNEIGH message: %m");
130 : :
131 : 0 : r = sd_rtnl_message_neigh_set_state(req, NUD_PERMANENT);
132 [ # # ]: 0 : if (r < 0)
133 [ # # ]: 0 : return log_error_errno(r, "Could not set state: %m");
134 : :
135 : 0 : r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE);
136 [ # # ]: 0 : if (r < 0)
137 [ # # ]: 0 : return log_error_errno(r, "Could not set flags: %m");
138 : :
139 : 0 : r = sd_netlink_message_append_data(req, NDA_LLADDR, &neighbor->lladdr, neighbor->lladdr_size);
140 [ # # ]: 0 : if (r < 0)
141 [ # # ]: 0 : return log_error_errno(r, "Could not append NDA_LLADDR attribute: %m");
142 : :
143 : 0 : r = netlink_message_append_in_addr_union(req, NDA_DST, neighbor->family, &neighbor->in_addr);
144 [ # # ]: 0 : if (r < 0)
145 [ # # ]: 0 : return log_error_errno(r, "Could not append NDA_DST attribute: %m");
146 : :
147 [ # # ]: 0 : r = netlink_call_async(link->manager->rtnl, NULL, req, callback ?: neighbor_configure_handler,
148 : : link_netlink_destroy_callback, link);
149 [ # # ]: 0 : if (r < 0)
150 [ # # ]: 0 : return log_error_errno(r, "Could not send rtnetlink message: %m");
151 : :
152 : 0 : link->neighbor_messages++;
153 : 0 : link_ref(link);
154 : :
155 : 0 : r = neighbor_add(link, neighbor->family, &neighbor->in_addr, &neighbor->lladdr, neighbor->lladdr_size, NULL);
156 [ # # ]: 0 : if (r < 0)
157 [ # # # # ]: 0 : return log_link_error_errno(link, r, "Could not add neighbor: %m");
158 : :
159 : 0 : return 0;
160 : : }
161 : :
162 : 0 : static int neighbor_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
163 : : int r;
164 : :
165 [ # # ]: 0 : assert(m);
166 [ # # ]: 0 : assert(link);
167 : :
168 [ # # # # ]: 0 : if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
169 : 0 : return 1;
170 : :
171 : 0 : r = sd_netlink_message_get_errno(m);
172 [ # # # # ]: 0 : if (r < 0 && r != -ESRCH)
173 : : /* Neighbor may not exist because it already got deleted, ignore that. */
174 [ # # # # ]: 0 : log_link_warning_errno(link, r, "Could not remove neighbor: %m");
175 : :
176 : 0 : return 1;
177 : : }
178 : :
179 : 0 : int neighbor_remove(Neighbor *neighbor, Link *link, link_netlink_message_handler_t callback) {
180 : 0 : _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
181 : : int r;
182 : :
183 [ # # ]: 0 : assert(neighbor);
184 [ # # ]: 0 : assert(link);
185 [ # # ]: 0 : assert(link->ifindex > 0);
186 [ # # ]: 0 : assert(link->manager);
187 [ # # ]: 0 : assert(link->manager->rtnl);
188 : :
189 : 0 : r = sd_rtnl_message_new_neigh(link->manager->rtnl, &req, RTM_DELNEIGH,
190 : : link->ifindex, neighbor->family);
191 [ # # ]: 0 : if (r < 0)
192 [ # # ]: 0 : return log_error_errno(r, "Could not allocate RTM_DELNEIGH message: %m");
193 : :
194 : 0 : r = netlink_message_append_in_addr_union(req, NDA_DST, neighbor->family, &neighbor->in_addr);
195 [ # # ]: 0 : if (r < 0)
196 [ # # ]: 0 : return log_error_errno(r, "Could not append NDA_DST attribute: %m");
197 : :
198 [ # # ]: 0 : r = netlink_call_async(link->manager->rtnl, NULL, req, callback ?: neighbor_remove_handler,
199 : : link_netlink_destroy_callback, link);
200 [ # # ]: 0 : if (r < 0)
201 [ # # ]: 0 : return log_error_errno(r, "Could not send rtnetlink message: %m");
202 : :
203 : 0 : link_ref(link);
204 : :
205 : 0 : return 0;
206 : : }
207 : :
208 : 0 : static void neighbor_hash_func(const Neighbor *neighbor, struct siphash *state) {
209 [ # # ]: 0 : assert(neighbor);
210 : :
211 : 0 : siphash24_compress(&neighbor->family, sizeof(neighbor->family), state);
212 : :
213 [ # # ]: 0 : switch (neighbor->family) {
214 : 0 : case AF_INET:
215 : : case AF_INET6:
216 : : /* Equality of neighbors are given by the pair (addr,lladdr) */
217 : 0 : siphash24_compress(&neighbor->in_addr, FAMILY_ADDRESS_SIZE(neighbor->family), state);
218 : 0 : siphash24_compress(&neighbor->lladdr, neighbor->lladdr_size, state);
219 : 0 : break;
220 : 0 : default:
221 : : /* treat any other address family as AF_UNSPEC */
222 : 0 : break;
223 : : }
224 : 0 : }
225 : :
226 : 0 : static int neighbor_compare_func(const Neighbor *a, const Neighbor *b) {
227 : : int r;
228 : :
229 [ # # ]: 0 : r = CMP(a->family, b->family);
230 [ # # ]: 0 : if (r != 0)
231 : 0 : return r;
232 : :
233 [ # # ]: 0 : r = CMP(a->lladdr_size, b->lladdr_size);
234 [ # # ]: 0 : if (r != 0)
235 : 0 : return r;
236 : :
237 [ # # ]: 0 : switch (a->family) {
238 : 0 : case AF_INET:
239 : : case AF_INET6:
240 : 0 : r = memcmp(&a->in_addr, &b->in_addr, FAMILY_ADDRESS_SIZE(a->family));
241 [ # # ]: 0 : if (r != 0)
242 : 0 : return r;
243 : : }
244 : :
245 : 0 : return memcmp(&a->lladdr, &b->lladdr, a->lladdr_size);
246 : : }
247 : :
248 : : DEFINE_PRIVATE_HASH_OPS(neighbor_hash_ops, Neighbor, neighbor_hash_func, neighbor_compare_func);
249 : :
250 : 0 : int neighbor_get(Link *link, int family, const union in_addr_union *addr, const union lladdr_union *lladdr, size_t lladdr_size, Neighbor **ret) {
251 : : Neighbor neighbor, *existing;
252 : :
253 [ # # ]: 0 : assert(link);
254 [ # # ]: 0 : assert(addr);
255 [ # # ]: 0 : assert(lladdr);
256 : :
257 : 0 : neighbor = (Neighbor) {
258 : : .family = family,
259 : 0 : .in_addr = *addr,
260 : 0 : .lladdr = *lladdr,
261 : : .lladdr_size = lladdr_size,
262 : : };
263 : :
264 : 0 : existing = set_get(link->neighbors, &neighbor);
265 [ # # ]: 0 : if (existing) {
266 [ # # ]: 0 : if (ret)
267 : 0 : *ret = existing;
268 : 0 : return 1;
269 : : }
270 : :
271 : 0 : existing = set_get(link->neighbors_foreign, &neighbor);
272 [ # # ]: 0 : if (existing) {
273 [ # # ]: 0 : if (ret)
274 : 0 : *ret = existing;
275 : 0 : return 0;
276 : : }
277 : :
278 : 0 : return -ENOENT;
279 : : }
280 : :
281 : 0 : static int neighbor_add_internal(Link *link, Set **neighbors, int family, const union in_addr_union *addr, const union lladdr_union *lladdr, size_t lladdr_size, Neighbor **ret) {
282 : 0 : _cleanup_(neighbor_freep) Neighbor *neighbor = NULL;
283 : : int r;
284 : :
285 [ # # ]: 0 : assert(link);
286 [ # # ]: 0 : assert(neighbors);
287 [ # # ]: 0 : assert(addr);
288 [ # # ]: 0 : assert(lladdr);
289 : :
290 : 0 : neighbor = new(Neighbor, 1);
291 [ # # ]: 0 : if (!neighbor)
292 : 0 : return -ENOMEM;
293 : :
294 : 0 : *neighbor = (Neighbor) {
295 : : .family = family,
296 : 0 : .in_addr = *addr,
297 : 0 : .lladdr = *lladdr,
298 : : .lladdr_size = lladdr_size,
299 : : };
300 : :
301 : 0 : r = set_ensure_allocated(neighbors, &neighbor_hash_ops);
302 [ # # ]: 0 : if (r < 0)
303 : 0 : return r;
304 : :
305 : 0 : r = set_put(*neighbors, neighbor);
306 [ # # ]: 0 : if (r < 0)
307 : 0 : return r;
308 [ # # ]: 0 : if (r == 0)
309 : 0 : return -EEXIST;
310 : :
311 : 0 : neighbor->link = link;
312 : :
313 [ # # ]: 0 : if (ret)
314 : 0 : *ret = neighbor;
315 : :
316 : 0 : neighbor = NULL;
317 : :
318 : 0 : return 0;
319 : : }
320 : :
321 : 0 : int neighbor_add(Link *link, int family, const union in_addr_union *addr, const union lladdr_union *lladdr, size_t lladdr_size, Neighbor **ret) {
322 : : Neighbor *neighbor;
323 : : int r;
324 : :
325 : 0 : r = neighbor_get(link, family, addr, lladdr, lladdr_size, &neighbor);
326 [ # # ]: 0 : if (r == -ENOENT) {
327 : : /* Neighbor doesn't exist, make a new one */
328 : 0 : r = neighbor_add_internal(link, &link->neighbors, family, addr, lladdr, lladdr_size, &neighbor);
329 [ # # ]: 0 : if (r < 0)
330 : 0 : return r;
331 [ # # ]: 0 : } else if (r == 0) {
332 : : /* Neighbor is foreign, claim it as recognized */
333 : 0 : r = set_ensure_allocated(&link->neighbors, &neighbor_hash_ops);
334 [ # # ]: 0 : if (r < 0)
335 : 0 : return r;
336 : :
337 : 0 : r = set_put(link->neighbors, neighbor);
338 [ # # ]: 0 : if (r < 0)
339 : 0 : return r;
340 : :
341 : 0 : set_remove(link->neighbors_foreign, neighbor);
342 [ # # ]: 0 : } else if (r == 1) {
343 : : /* Neighbor already exists */
344 : : } else
345 : 0 : return r;
346 : :
347 [ # # ]: 0 : if (ret)
348 : 0 : *ret = neighbor;
349 : 0 : return 0;
350 : : }
351 : :
352 : 0 : int neighbor_add_foreign(Link *link, int family, const union in_addr_union *addr, const union lladdr_union *lladdr, size_t lladdr_size, Neighbor **ret) {
353 : 0 : return neighbor_add_internal(link, &link->neighbors_foreign, family, addr, lladdr, lladdr_size, ret);
354 : : }
355 : :
356 : 0 : bool neighbor_equal(const Neighbor *n1, const Neighbor *n2) {
357 [ # # ]: 0 : if (n1 == n2)
358 : 0 : return true;
359 : :
360 [ # # # # ]: 0 : if (!n1 || !n2)
361 : 0 : return false;
362 : :
363 : 0 : return neighbor_compare_func(n1, n2) == 0;
364 : : }
365 : :
366 : 0 : int neighbor_section_verify(Neighbor *neighbor) {
367 [ # # ]: 0 : if (section_is_invalid(neighbor->section))
368 : 0 : return -EINVAL;
369 : :
370 [ # # ]: 0 : if (neighbor->family == AF_UNSPEC)
371 [ # # ]: 0 : return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
372 : : "%s: Neighbor section without Address= configured. "
373 : : "Ignoring [Neighbor] section from line %u.",
374 : : neighbor->section->filename, neighbor->section->line);
375 : :
376 [ # # ]: 0 : if (neighbor->lladdr_size == 0)
377 [ # # ]: 0 : return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
378 : : "%s: Neighbor section without LinkLayerAddress= configured. "
379 : : "Ignoring [Neighbor] section from line %u.",
380 : : neighbor->section->filename, neighbor->section->line);
381 : :
382 : 0 : return 0;
383 : : }
384 : :
385 : 0 : int config_parse_neighbor_address(
386 : : const char *unit,
387 : : const char *filename,
388 : : unsigned line,
389 : : const char *section,
390 : : unsigned section_line,
391 : : const char *lvalue,
392 : : int ltype,
393 : : const char *rvalue,
394 : : void *data,
395 : : void *userdata) {
396 : :
397 : 0 : Network *network = userdata;
398 : 0 : _cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
399 : : int r;
400 : :
401 [ # # ]: 0 : assert(filename);
402 [ # # ]: 0 : assert(section);
403 [ # # ]: 0 : assert(lvalue);
404 [ # # ]: 0 : assert(rvalue);
405 [ # # ]: 0 : assert(data);
406 : :
407 : 0 : r = neighbor_new_static(network, filename, section_line, &n);
408 [ # # ]: 0 : if (r < 0)
409 : 0 : return r;
410 : :
411 : 0 : r = in_addr_from_string_auto(rvalue, &n->family, &n->in_addr);
412 [ # # ]: 0 : if (r < 0) {
413 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, r, "Neighbor Address is invalid, ignoring assignment: %s", rvalue);
414 : 0 : return 0;
415 : : }
416 : :
417 : 0 : TAKE_PTR(n);
418 : :
419 : 0 : return 0;
420 : : }
421 : :
422 : 0 : int config_parse_neighbor_lladdr(
423 : : const char *unit,
424 : : const char *filename,
425 : : unsigned line,
426 : : const char *section,
427 : : unsigned section_line,
428 : : const char *lvalue,
429 : : int ltype,
430 : : const char *rvalue,
431 : : void *data,
432 : : void *userdata) {
433 : :
434 : 0 : Network *network = userdata;
435 : 0 : _cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
436 : : int family, r;
437 : :
438 [ # # ]: 0 : assert(filename);
439 [ # # ]: 0 : assert(section);
440 [ # # ]: 0 : assert(lvalue);
441 [ # # ]: 0 : assert(rvalue);
442 [ # # ]: 0 : assert(data);
443 : :
444 : 0 : r = neighbor_new_static(network, filename, section_line, &n);
445 [ # # ]: 0 : if (r < 0)
446 : 0 : return r;
447 : :
448 : 0 : r = ether_addr_from_string(rvalue, &n->lladdr.mac);
449 [ # # ]: 0 : if (r >= 0)
450 : 0 : n->lladdr_size = sizeof(n->lladdr.mac);
451 : : else {
452 : 0 : r = in_addr_from_string_auto(rvalue, &family, &n->lladdr.ip);
453 [ # # ]: 0 : if (r < 0) {
454 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, r,
455 : : "Neighbor LinkLayerAddress= is invalid, ignoring assignment: %s",
456 : : rvalue);
457 : 0 : return 0;
458 : : }
459 [ # # ]: 0 : n->lladdr_size = family == AF_INET ? sizeof(n->lladdr.ip.in) : sizeof(n->lladdr.ip.in6);
460 : : }
461 : :
462 : 0 : TAKE_PTR(n);
463 : :
464 : 0 : return 0;
465 : : }
466 : :
467 : 0 : int config_parse_neighbor_hwaddr(
468 : : const char *unit,
469 : : const char *filename,
470 : : unsigned line,
471 : : const char *section,
472 : : unsigned section_line,
473 : : const char *lvalue,
474 : : int ltype,
475 : : const char *rvalue,
476 : : void *data,
477 : : void *userdata) {
478 : :
479 : 0 : Network *network = userdata;
480 : 0 : _cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
481 : : int r;
482 : :
483 [ # # ]: 0 : assert(filename);
484 [ # # ]: 0 : assert(section);
485 [ # # ]: 0 : assert(lvalue);
486 [ # # ]: 0 : assert(rvalue);
487 [ # # ]: 0 : assert(data);
488 : :
489 : 0 : r = neighbor_new_static(network, filename, section_line, &n);
490 [ # # ]: 0 : if (r < 0)
491 : 0 : return r;
492 : :
493 : 0 : r = ether_addr_from_string(rvalue, &n->lladdr.mac);
494 [ # # ]: 0 : if (r < 0) {
495 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, r,
496 : : "Neighbor MACAddress= is invalid, ignoring assignment: %s", rvalue);
497 : 0 : return 0;
498 : : }
499 : :
500 : 0 : n->lladdr_size = sizeof(n->lladdr.mac);
501 : 0 : TAKE_PTR(n);
502 : :
503 : 0 : return 0;
504 : : }
|
