Debian Codegraph @

src/network/netdev/fou-tunnel.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/fou.h>
4
5 #include "sd-netlink.h"
6
7 #include "conf-parser.h"
8 #include "fou-tunnel.h"
9 #include "netlink-util.h"
10 #include "networkd-manager.h"
11 #include "string-table.h"
12 #include "string-util.h"
13
14 static const char* const fou_encap_type_table[_NETDEV_FOO_OVER_UDP_ENCAP_MAX] = {
15 [NETDEV_FOO_OVER_UDP_ENCAP_DIRECT] = "FooOverUDP",
16 [NETDEV_FOO_OVER_UDP_ENCAP_GUE] = "GenericUDPEncapsulation",
17 };
18
19 DEFINE_STRING_TABLE_LOOKUP(fou_encap_type, FooOverUDPEncapType);
20 DEFINE_CONFIG_PARSE_ENUM(config_parse_fou_encap_type, fou_encap_type, FooOverUDPEncapType);
21
22 static int netdev_fill_fou_tunnel_message(NetDev *netdev, sd_netlink_message *m) {
23 FouTunnel *t = FOU(netdev);
24 uint8_t encap_type;
25 int r;
26
27 r = sd_netlink_message_append_u16(m, FOU_ATTR_PORT, htobe16(t->port));
28 if (r < 0)
29 return r;
30
31 if (IN_SET(t->peer_family, AF_INET, AF_INET6)) {
32 r = sd_netlink_message_append_u16(m, FOU_ATTR_PEER_PORT, htobe16(t->peer_port));
33 if (r < 0)
34 return r;
35 }
36
37 switch (t->fou_encap_type) {
38 case NETDEV_FOO_OVER_UDP_ENCAP_DIRECT:
39 encap_type = FOU_ENCAP_DIRECT;
40 break;
41 case NETDEV_FOO_OVER_UDP_ENCAP_GUE:
42 encap_type = FOU_ENCAP_GUE;
43 break;
44 default:
45 assert_not_reached();
46 }
47
48 r = sd_netlink_message_append_u8(m, FOU_ATTR_TYPE, encap_type);
49 if (r < 0)
50 return r;
51
52 r = sd_netlink_message_append_u8(m, FOU_ATTR_AF, AF_INET);
53 if (r < 0)
54 return r;
55
56 r = sd_netlink_message_append_u8(m, FOU_ATTR_IPPROTO, t->fou_protocol);
57 if (r < 0)
58 return r;
59
60 if (t->local_family == AF_INET) {
61 r = sd_netlink_message_append_in_addr(m, FOU_ATTR_LOCAL_V4, &t->local.in);
62 if (r < 0)
63 return r;
64 } else if (t->local_family == AF_INET6) {
65 r = sd_netlink_message_append_in6_addr(m, FOU_ATTR_LOCAL_V6, &t->local.in6);
66 if (r < 0)
67 return r;
68 }
69
70 if (t->peer_family == AF_INET) {
71 r = sd_netlink_message_append_in_addr(m, FOU_ATTR_PEER_V4, &t->peer.in);
72 if (r < 0)
73 return r;
74 } else if (t->peer_family == AF_INET6){
75 r = sd_netlink_message_append_in6_addr(m, FOU_ATTR_PEER_V6, &t->peer.in6);
76 if (r < 0)
77 return r;
78 }
79
80 return 0;
81 }
82
83 static int netdev_create_fou_tunnel_message(NetDev *netdev, sd_netlink_message **ret) {
84 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
85 int r;
86
87 assert(netdev);
88 assert(netdev->manager);
89 assert(ret);
90
91 r = sd_genl_message_new(netdev->manager->genl, FOU_GENL_NAME, FOU_CMD_ADD, &m);
92 if (r < 0)
93 return log_netdev_error_errno(netdev, r, "Could not allocate netlink message: %m");
94
95 r = netdev_fill_fou_tunnel_message(netdev, m);
96 if (r < 0)
97 return log_netdev_error_errno(netdev, r, "Could not create netlink message: %m");
98
99 *ret = TAKE_PTR(m);
100 return 0;
101 }
102
103 static int fou_tunnel_create_handler(sd_netlink *rtnl, sd_netlink_message *m, NetDev *netdev) {
104 int r;
105
106 assert(netdev);
107 assert(netdev->state != _NETDEV_STATE_INVALID);
108
109 r = sd_netlink_message_get_errno(m);
110 if (r == -EEXIST)
111 log_netdev_info(netdev, "netdev exists, using existing without changing its parameters");
112 else if (r < 0) {
113 log_netdev_warning_errno(netdev, r, "netdev could not be created: %m");
114 netdev_enter_failed(netdev);
115
116 return 1;
117 }
118
119 log_netdev_debug(netdev, "FooOverUDP tunnel is created");
120 return 1;
121 }
122
123 static int netdev_fou_tunnel_create(NetDev *netdev) {
124 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
125 int r;
126
127 assert(FOU(netdev));
128
129 if (!netdev_is_managed(netdev))
130 return 0; /* Already detached, due to e.g. reloading .netdev files. */
131
132 r = netdev_create_fou_tunnel_message(netdev, &m);
133 if (r < 0)
134 return r;
135
136 r = netlink_call_async(netdev->manager->genl, NULL, m, fou_tunnel_create_handler,
137 netdev_destroy_callback, netdev);
138 if (r < 0)
139 return log_netdev_error_errno(netdev, r, "Failed to create FooOverUDP tunnel: %m");
140
141 netdev_ref(netdev);
142 return 0;
143 }
144
145 int config_parse_fou_tunnel_address(
146 const char *unit,
147 const char *filename,
148 unsigned line,
149 const char *section,
150 unsigned section_line,
151 const char *lvalue,
152 int ltype,
153 const char *rvalue,
154 void *data,
155 void *userdata) {
156
157 union in_addr_union *addr = ASSERT_PTR(data);
158 FouTunnel *t = userdata;
159 int r, *f;
160
161 assert(filename);
162 assert(lvalue);
163 assert(rvalue);
164
165 if (streq(lvalue, "Local"))
166 f = &t->local_family;
167 else
168 f = &t->peer_family;
169
170 r = in_addr_from_string_auto(rvalue, f, addr);
171 if (r < 0)
172 log_syntax(unit, LOG_WARNING, filename, line, r,
173 "FooOverUDP tunnel '%s' address is invalid, ignoring assignment: %s",
174 lvalue, rvalue);
175
176 return 0;
177 }
178
179 static int netdev_fou_tunnel_verify(NetDev *netdev, const char *filename) {
180 assert(filename);
181
182 FouTunnel *t = FOU(netdev);
183
184 switch (t->fou_encap_type) {
185 case NETDEV_FOO_OVER_UDP_ENCAP_DIRECT:
186 if (t->fou_protocol <= 0)
187 return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
188 "FooOverUDP protocol not configured in %s. Rejecting configuration.",
189 filename);
190 break;
191 case NETDEV_FOO_OVER_UDP_ENCAP_GUE:
192 if (t->fou_protocol > 0)
193 return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
194 "FooOverUDP GUE can't be set with protocol configured in %s. Rejecting configuration.",
195 filename);
196 break;
197 default:
198 assert_not_reached();
199 }
200
201 if (t->peer_family == AF_UNSPEC && t->peer_port > 0)
202 return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
203 "FooOverUDP peer port is set but peer address not configured in %s. Rejecting configuration.",
204 filename);
205 else if (t->peer_family != AF_UNSPEC && t->peer_port == 0)
206 return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
207 "FooOverUDP peer port not set but peer address is configured in %s. Rejecting configuration.",
208 filename);
209 return 0;
210 }
211
212 static void fou_tunnel_init(NetDev *netdev) {
213 FouTunnel *t = FOU(netdev);
214
215 t->fou_encap_type = NETDEV_FOO_OVER_UDP_ENCAP_DIRECT;
216 }
217
218 const NetDevVTable foutnl_vtable = {
219 .object_size = sizeof(FouTunnel),
220 .init = fou_tunnel_init,
221 .sections = NETDEV_COMMON_SECTIONS "FooOverUDP\0",
222 .create = netdev_fou_tunnel_create,
223 .create_type = NETDEV_CREATE_INDEPENDENT,
224 .config_verify = netdev_fou_tunnel_verify,
225 };