Debian Codegraph @

src/network/netdev/vxlan.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/if_arp.h>
4
5 #include "sd-netlink.h"
6
7 #include "conf-parser.h"
8 #include "in-addr-util.h"
9 #include "networkd-link.h"
10 #include "parse-util.h"
11 #include "string-table.h"
12 #include "string-util.h"
13 #include "time-util.h"
14 #include "vxlan.h"
15
16 static const char* const df_table[_NETDEV_VXLAN_DF_MAX] = {
17 [NETDEV_VXLAN_DF_NO] = "no",
18 [NETDEV_VXLAN_DF_YES] = "yes",
19 [NETDEV_VXLAN_DF_INHERIT] = "inherit",
20 };
21
22 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(df, VxLanDF, NETDEV_VXLAN_DF_YES);
23 DEFINE_CONFIG_PARSE_ENUM(config_parse_df, df, VxLanDF);
24
25 static int vxlan_get_local_address(VxLan *v, Link *link, int *ret_family, union in_addr_union *ret_address) {
26 assert(v);
27
28 if (v->local_type < 0) {
29 if (ret_family)
30 *ret_family = v->local_family;
31 if (ret_address)
32 *ret_address = v->local;
33 return 0;
34 }
35
36 return link_get_local_address(link, v->local_type, v->local_family, ret_family, ret_address);
37 }
38
39 static int netdev_vxlan_fill_message_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
40 assert(m);
41
42 union in_addr_union local;
43 int local_family, r;
44 VxLan *v = VXLAN(netdev);
45
46 if (in_addr_is_set(v->group_family, &v->group)) {
47 if (v->group_family == AF_INET)
48 r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_GROUP, &v->group.in);
49 else
50 r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_GROUP6, &v->group.in6);
51 if (r < 0)
52 return r;
53 } else if (in_addr_is_set(v->remote_family, &v->remote)) {
54 if (v->remote_family == AF_INET)
55 r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_GROUP, &v->remote.in);
56 else
57 r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_GROUP6, &v->remote.in6);
58 if (r < 0)
59 return r;
60 }
61
62 r = vxlan_get_local_address(v, link, &local_family, &local);
63 if (r < 0)
64 return r;
65
66 if (in_addr_is_set(local_family, &local)) {
67 if (local_family == AF_INET)
68 r = sd_netlink_message_append_in_addr(m, IFLA_VXLAN_LOCAL, &local.in);
69 else
70 r = sd_netlink_message_append_in6_addr(m, IFLA_VXLAN_LOCAL6, &local.in6);
71 if (r < 0)
72 return r;
73 }
74
75 r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LINK, link ? link->ifindex : 0);
76 if (r < 0)
77 return r;
78
79 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TTL, v->ttl);
80 if (r < 0)
81 return r;
82
83 if (v->fdb_ageing != 0) {
84 r = sd_netlink_message_append_u32(m, IFLA_VXLAN_AGEING, v->fdb_ageing / USEC_PER_SEC);
85 if (r < 0)
86 return r;
87 }
88
89 if (v->tos != 0) {
90 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_TOS, v->tos);
91 if (r < 0)
92 return r;
93 }
94
95 r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LABEL, htobe32(v->flow_label));
96 if (r < 0)
97 return r;
98
99 if (v->df != _NETDEV_VXLAN_DF_INVALID) {
100 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_DF, v->df);
101 if (r < 0)
102 return r;
103 }
104
105 if (netdev->ifindex > 0)
106 return 0;
107
108 /* The properties below cannot be updated, and the kernel refuses the whole request if one of the
109 * following attributes is set for an existing interface. */
110
111 if (!v->external && v->vni <= VXLAN_VID_MAX) {
112 r = sd_netlink_message_append_u32(m, IFLA_VXLAN_ID, v->vni);
113 if (r < 0)
114 return r;
115 }
116
117 if (v->inherit) {
118 r = sd_netlink_message_append_flag(m, IFLA_VXLAN_TTL_INHERIT);
119 if (r < 0)
120 return r;
121 }
122
123 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_LEARNING, v->learning);
124 if (r < 0)
125 return r;
126
127 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_RSC, v->route_short_circuit);
128 if (r < 0)
129 return r;
130
131 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_PROXY, v->arp_proxy);
132 if (r < 0)
133 return r;
134
135 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L2MISS, v->l2miss);
136 if (r < 0)
137 return r;
138
139 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_L3MISS, v->l3miss);
140 if (r < 0)
141 return r;
142
143 if (v->max_fdb != 0) {
144 r = sd_netlink_message_append_u32(m, IFLA_VXLAN_LIMIT, v->max_fdb);
145 if (r < 0)
146 return r;
147 }
148
149 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_CSUM, v->udpcsum);
150 if (r < 0)
151 return r;
152
153 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_TX, v->udp6zerocsumtx);
154 if (r < 0)
155 return r;
156
157 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_UDP_ZERO_CSUM6_RX, v->udp6zerocsumrx);
158 if (r < 0)
159 return r;
160
161 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_REMCSUM_TX, v->remote_csum_tx);
162 if (r < 0)
163 return r;
164
165 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_REMCSUM_RX, v->remote_csum_rx);
166 if (r < 0)
167 return r;
168
169 r = sd_netlink_message_append_u16(m, IFLA_VXLAN_PORT, htobe16(v->dest_port));
170 if (r < 0)
171 return r;
172
173 if (v->port_range.low != 0 || v->port_range.high != 0) {
174 struct ifla_vxlan_port_range port_range;
175
176 port_range.low = htobe16(v->port_range.low);
177 port_range.high = htobe16(v->port_range.high);
178
179 r = sd_netlink_message_append_data(m, IFLA_VXLAN_PORT_RANGE, &port_range, sizeof(port_range));
180 if (r < 0)
181 return r;
182 }
183
184 if (v->group_policy) {
185 r = sd_netlink_message_append_flag(m, IFLA_VXLAN_GBP);
186 if (r < 0)
187 return r;
188 }
189
190 if (v->generic_protocol_extension) {
191 r = sd_netlink_message_append_flag(m, IFLA_VXLAN_GPE);
192 if (r < 0)
193 return r;
194 }
195
196 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_COLLECT_METADATA, v->external);
197 if (r < 0)
198 return r;
199
200 if (v->external) {
201 r = sd_netlink_message_append_u8(m, IFLA_VXLAN_VNIFILTER, v->vnifilter);
202 if (r < 0)
203 return r;
204 }
205
206 return 0;
207 }
208
209 static bool vxlan_can_set_mac(NetDev *netdev, const struct hw_addr_data *hw_addr) {
210 return true;
211 }
212
213 static bool vxlan_can_set_mtu(NetDev *netdev, uint32_t mtu) {
214 assert(netdev);
215
216 /* MTU cannot be updated. Even unchanged, IFLA_MTU attribute cannot be set in the message. */
217 return netdev->ifindex <= 0;
218 }
219
220 int config_parse_vxlan_address(
221 const char *unit,
222 const char *filename,
223 unsigned line,
224 const char *section,
225 unsigned section_line,
226 const char *lvalue,
227 int ltype,
228 const char *rvalue,
229 void *data,
230 void *userdata) {
231
232 VxLan *v = ASSERT_PTR(userdata);
233 union in_addr_union *addr = data, buffer;
234 int *family, f, r;
235
236 assert(filename);
237 assert(lvalue);
238 assert(rvalue);
239 assert(data);
240
241 if (streq(lvalue, "Local"))
242 family = &v->local_family;
243 else if (streq(lvalue, "Remote"))
244 family = &v->remote_family;
245 else if (streq(lvalue, "Group"))
246 family = &v->group_family;
247 else
248 assert_not_reached();
249
250 if (isempty(rvalue)) {
251 *addr = IN_ADDR_NULL;
252 *family = AF_UNSPEC;
253 return 0;
254 }
255
256 if (streq(lvalue, "Local")) {
257 NetDevLocalAddressType t;
258
259 t = netdev_local_address_type_from_string(rvalue);
260 if (t >= 0) {
261 v->local = IN_ADDR_NULL;
262 v->local_family = AF_UNSPEC;
263 v->local_type = t;
264 return 0;
265 }
266 }
267
268 r = in_addr_from_string_auto(rvalue, &f, &buffer);
269 if (r < 0) {
270 log_syntax(unit, LOG_WARNING, filename, line, r,
271 "Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
272 return 0;
273 }
274
275 r = in_addr_is_multicast(f, &buffer);
276
277 if (streq(lvalue, "Group")) {
278 if (r <= 0) {
279 log_syntax(unit, LOG_WARNING, filename, line, 0,
280 "%s= must be a multicast address, ignoring assignment: %s", lvalue, rvalue);
281 return 0;
282 }
283 } else {
284 if (r > 0) {
285 log_syntax(unit, LOG_WARNING, filename, line, 0,
286 "%s= cannot be a multicast address, ignoring assignment: %s", lvalue, rvalue);
287 return 0;
288 }
289 }
290
291 if (streq(lvalue, "Local"))
292 v->local_type = _NETDEV_LOCAL_ADDRESS_TYPE_INVALID;
293 *addr = buffer;
294 *family = f;
295
296 return 0;
297 }
298
299 int config_parse_port_range(
300 const char *unit,
301 const char *filename,
302 unsigned line,
303 const char *section,
304 unsigned section_line,
305 const char *lvalue,
306 int ltype,
307 const char *rvalue,
308 void *data,
309 void *userdata) {
310
311 assert(filename);
312 assert(lvalue);
313 assert(rvalue);
314 assert(data);
315
316 VxLan *v = ASSERT_PTR(userdata);
317 int r;
318
319 r = parse_ip_port_range(rvalue, &v->port_range.low, &v->port_range.high, /* allow_zero= */ false);
320 if (r < 0)
321 log_syntax(unit, LOG_WARNING, filename, line, r,
322 "Failed to parse VXLAN port range '%s'. Port should be greater than 0 and less than 65535.", rvalue);
323 return 0;
324 }
325
326 int config_parse_flow_label(
327 const char *unit,
328 const char *filename,
329 unsigned line,
330 const char *section,
331 unsigned section_line,
332 const char *lvalue,
333 int ltype,
334 const char *rvalue,
335 void *data,
336 void *userdata) {
337
338 VxLan *v = userdata;
339 unsigned f;
340 int r;
341
342 assert(filename);
343 assert(lvalue);
344 assert(rvalue);
345 assert(data);
346
347 r = safe_atou(rvalue, &f);
348 if (r < 0) {
349 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse VXLAN flow label '%s'.", rvalue);
350 return 0;
351 }
352
353 if (f & ~VXLAN_FLOW_LABEL_MAX_MASK) {
354 log_syntax(unit, LOG_WARNING, filename, line, r,
355 "VXLAN flow label '%s' not valid. Flow label range should be [0-1048575].", rvalue);
356 return 0;
357 }
358
359 v->flow_label = f;
360
361 return 0;
362 }
363
364 int config_parse_vxlan_ttl(
365 const char *unit,
366 const char *filename,
367 unsigned line,
368 const char *section,
369 unsigned section_line,
370 const char *lvalue,
371 int ltype,
372 const char *rvalue,
373 void *data,
374 void *userdata) {
375
376 assert(filename);
377 assert(lvalue);
378 assert(rvalue);
379 assert(data);
380
381 VxLan *v = ASSERT_PTR(userdata);
382 int r;
383
384 if (streq(rvalue, "inherit")) {
385 v->inherit = true;
386 v->ttl = 0; /* unset the unused ttl field for clarity */
387 return 0;
388 }
389
390 r = config_parse_unsigned_bounded(
391 unit, filename, line, section, section_line, lvalue, rvalue,
392 0, UINT8_MAX, true,
393 &v->ttl);
394 if (r <= 0)
395 return r;
396 v->inherit = false;
397 return 0;
398 }
399
400 static int netdev_vxlan_verify(NetDev *netdev, const char *filename) {
401 assert(filename);
402
403 VxLan *v = VXLAN(netdev);
404
405 if (v->ttl > 255)
406 return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
407 "%s: VXLAN TTL must be <= 255. Ignoring.",
408 filename);
409
410 if (!v->dest_port && v->generic_protocol_extension)
411 v->dest_port = 4790;
412
413 if (in_addr_is_set(v->group_family, &v->group) && in_addr_is_set(v->remote_family, &v->remote))
414 return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
415 "%s: VXLAN both 'Group=' and 'Remote=' cannot be specified. Ignoring.",
416 filename);
417
418 if (v->independent && v->local_type >= 0)
419 return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
420 "The local address cannot be '%s' when Independent= is enabled, ignoring.",
421 strna(netdev_local_address_type_to_string(v->local_type)));
422
423 if (v->external) {
424 if (v->vni <= VXLAN_VID_MAX)
425 log_netdev_warning(netdev, "VNI= is set while External= is enabled. VNI= setting will be ignored.");
426 } else {
427 if (v->vnifilter)
428 log_netdev_warning(netdev, "VNIFilter= is enabled while External= is disabled. VNIFilter= setting will be ignored.");
429 if (v->vni > VXLAN_VID_MAX)
430 return log_netdev_warning_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
431 "%s: VXLAN without valid VNI (or VXLAN Segment ID) configured. Ignoring.",
432 filename);
433 }
434
435 return 0;
436 }
437
438 static bool vxlan_needs_reconfigure(NetDev *netdev, NetDevLocalAddressType type) {
439 assert(type >= 0 && type < _NETDEV_LOCAL_ADDRESS_TYPE_MAX);
440
441 VxLan *v = VXLAN(netdev);
442
443 return v->local_type == type;
444 }
445
446 static int netdev_vxlan_is_ready_to_create(NetDev *netdev, Link *link) {
447 VxLan *v = VXLAN(netdev);
448
449 if (v->independent)
450 return true;
451
452 return vxlan_get_local_address(v, link, NULL, NULL) >= 0;
453 }
454
455 static void vxlan_init(NetDev *netdev) {
456 VxLan *v = VXLAN(netdev);
457
458 v->local_type = _NETDEV_LOCAL_ADDRESS_TYPE_INVALID;
459 v->vni = VXLAN_VID_MAX + 1;
460 v->df = _NETDEV_VXLAN_DF_INVALID;
461 v->learning = true;
462 v->udpcsum = false;
463 v->udp6zerocsumtx = false;
464 v->udp6zerocsumrx = false;
465 v->external = false;
466 v->vnifilter = false;
467 }
468
469 const NetDevVTable vxlan_vtable = {
470 .object_size = sizeof(VxLan),
471 .init = vxlan_init,
472 .sections = NETDEV_COMMON_SECTIONS "VXLAN\0",
473 .fill_message_create = netdev_vxlan_fill_message_create,
474 .create_type = NETDEV_CREATE_STACKED,
475 .is_ready_to_create = netdev_vxlan_is_ready_to_create,
476 .config_verify = netdev_vxlan_verify,
477 .can_set_mac = vxlan_can_set_mac,
478 .can_set_mtu = vxlan_can_set_mtu,
479 .needs_reconfigure = vxlan_needs_reconfigure,
480 .iftype = ARPHRD_ETHER,
481 .generate_mac = true,
482 };