]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
13b498f9 | 2 | /*** |
810adae9 | 3 | Copyright © 2016 BISDN GmbH. All rights reserved. |
13b498f9 TJ |
4 | ***/ |
5 | ||
6 | #include <netinet/in.h> | |
7 | #include <linux/if_bridge.h> | |
8 | #include <stdbool.h> | |
9 | ||
10 | #include "alloc-util.h" | |
11 | #include "conf-parser.h" | |
12 | #include "netlink-util.h" | |
13 | #include "networkd-brvlan.h" | |
23f53b99 TG |
14 | #include "networkd-link.h" |
15 | #include "networkd-manager.h" | |
16 | #include "networkd-network.h" | |
13b498f9 TJ |
17 | #include "parse-util.h" |
18 | #include "vlan-util.h" | |
19 | ||
20 | static bool is_bit_set(unsigned bit, uint32_t scope) { | |
21 | assert(bit < sizeof(scope)*8); | |
22 | return scope & (1 << bit); | |
23 | } | |
24 | ||
25 | static inline void set_bit(unsigned nr, uint32_t *addr) { | |
26 | if (nr < BRIDGE_VLAN_BITMAP_MAX) | |
27 | addr[nr / 32] |= (((uint32_t) 1) << (nr % 32)); | |
28 | } | |
29 | ||
13b498f9 TJ |
30 | static int find_next_bit(int i, uint32_t x) { |
31 | int j; | |
32 | ||
33 | if (i >= 32) | |
34 | return -1; | |
35 | ||
36 | /* find first bit */ | |
37 | if (i < 0) | |
38 | return BUILTIN_FFS_U32(x); | |
39 | ||
40 | /* mask off prior finds to get next */ | |
41 | j = __builtin_ffs(x >> i); | |
42 | return j ? j + i : 0; | |
43 | } | |
44 | ||
45 | static int append_vlan_info_data(Link *const link, sd_netlink_message *req, uint16_t pvid, const uint32_t *br_vid_bitmap, const uint32_t *br_untagged_bitmap) { | |
46 | struct bridge_vlan_info br_vlan; | |
47 | int i, j, k, r, done, cnt; | |
48 | uint16_t begin, end; | |
3f0083a2 | 49 | bool untagged = false; |
13b498f9 TJ |
50 | |
51 | assert(link); | |
52 | assert(req); | |
53 | assert(br_vid_bitmap); | |
54 | assert(br_untagged_bitmap); | |
55 | ||
56 | i = cnt = -1; | |
57 | ||
58 | begin = end = UINT16_MAX; | |
59 | for (k = 0; k < BRIDGE_VLAN_BITMAP_LEN; k++) { | |
60 | unsigned base_bit; | |
61 | uint32_t vid_map = br_vid_bitmap[k]; | |
62 | uint32_t untagged_map = br_untagged_bitmap[k]; | |
63 | ||
64 | base_bit = k * 32; | |
65 | i = -1; | |
66 | done = 0; | |
67 | do { | |
68 | j = find_next_bit(i, vid_map); | |
69 | if (j > 0) { | |
70 | /* first hit of any bit */ | |
71 | if (begin == UINT16_MAX && end == UINT16_MAX) { | |
72 | begin = end = j - 1 + base_bit; | |
73 | untagged = is_bit_set(j - 1, untagged_map); | |
74 | goto next; | |
75 | } | |
76 | ||
77 | /* this bit is a continuation of prior bits */ | |
78 | if (j - 2 + base_bit == end && untagged == is_bit_set(j - 1, untagged_map) && (uint16_t)j - 1 + base_bit != pvid && (uint16_t)begin != pvid) { | |
79 | end++; | |
80 | goto next; | |
81 | } | |
82 | } else | |
83 | done = 1; | |
84 | ||
85 | if (begin != UINT16_MAX) { | |
86 | cnt++; | |
87 | if (done && k < BRIDGE_VLAN_BITMAP_LEN - 1) | |
88 | break; | |
89 | ||
90 | br_vlan.flags = 0; | |
91 | if (untagged) | |
92 | br_vlan.flags |= BRIDGE_VLAN_INFO_UNTAGGED; | |
93 | ||
94 | if (begin == end) { | |
95 | br_vlan.vid = begin; | |
96 | ||
97 | if (begin == pvid) | |
98 | br_vlan.flags |= BRIDGE_VLAN_INFO_PVID; | |
99 | ||
100 | r = sd_netlink_message_append_data(req, IFLA_BRIDGE_VLAN_INFO, &br_vlan, sizeof(br_vlan)); | |
101 | if (r < 0) | |
102 | return log_link_error_errno(link, r, "Could not append IFLA_BRIDGE_VLAN_INFO attribute: %m"); | |
103 | } else { | |
104 | br_vlan.vid = begin; | |
105 | br_vlan.flags |= BRIDGE_VLAN_INFO_RANGE_BEGIN; | |
106 | ||
107 | r = sd_netlink_message_append_data(req, IFLA_BRIDGE_VLAN_INFO, &br_vlan, sizeof(br_vlan)); | |
108 | if (r < 0) | |
109 | return log_link_error_errno(link, r, "Could not append IFLA_BRIDGE_VLAN_INFO attribute: %m"); | |
110 | ||
111 | br_vlan.vid = end; | |
112 | br_vlan.flags &= ~BRIDGE_VLAN_INFO_RANGE_BEGIN; | |
113 | br_vlan.flags |= BRIDGE_VLAN_INFO_RANGE_END; | |
114 | ||
115 | r = sd_netlink_message_append_data(req, IFLA_BRIDGE_VLAN_INFO, &br_vlan, sizeof(br_vlan)); | |
116 | if (r < 0) | |
117 | return log_link_error_errno(link, r, "Could not append IFLA_BRIDGE_VLAN_INFO attribute: %m"); | |
118 | } | |
119 | ||
120 | if (done) | |
121 | break; | |
122 | } | |
123 | if (j > 0) { | |
124 | begin = end = j - 1 + base_bit; | |
125 | untagged = is_bit_set(j - 1, untagged_map); | |
126 | } | |
127 | ||
128 | next: | |
129 | i = j; | |
508f63b4 | 130 | } while (!done); |
13b498f9 TJ |
131 | } |
132 | if (!cnt) | |
133 | return -EINVAL; | |
134 | ||
135 | return cnt; | |
136 | } | |
137 | ||
138 | static int set_brvlan_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) { | |
139 | Link *link = userdata; | |
140 | int r; | |
141 | ||
142 | assert(link); | |
143 | ||
144 | r = sd_netlink_message_get_errno(m); | |
145 | if (r < 0 && r != -EEXIST) | |
146 | log_link_error_errno(link, r, "Could not add VLAN to bridge port: %m"); | |
147 | ||
148 | return 1; | |
149 | } | |
150 | ||
151 | int br_vlan_configure(Link *link, uint16_t pvid, uint32_t *br_vid_bitmap, uint32_t *br_untagged_bitmap) { | |
152 | _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL; | |
153 | int r; | |
154 | uint16_t flags; | |
155 | sd_netlink *rtnl; | |
156 | ||
157 | assert(link); | |
158 | assert(link->manager); | |
159 | assert(br_vid_bitmap); | |
160 | assert(br_untagged_bitmap); | |
161 | assert(link->network); | |
162 | ||
163 | /* pvid might not be in br_vid_bitmap yet */ | |
164 | if (pvid) | |
165 | set_bit(pvid, br_vid_bitmap); | |
166 | ||
167 | rtnl = link->manager->rtnl; | |
168 | ||
169 | /* create new RTM message */ | |
170 | r = sd_rtnl_message_new_link(rtnl, &req, RTM_SETLINK, link->ifindex); | |
171 | if (r < 0) | |
172 | return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m"); | |
173 | ||
174 | r = sd_rtnl_message_link_set_family(req, PF_BRIDGE); | |
175 | if (r < 0) | |
176 | return log_link_error_errno(link, r, "Could not set message family: %m"); | |
177 | ||
178 | r = sd_netlink_message_open_container(req, IFLA_AF_SPEC); | |
179 | if (r < 0) | |
180 | return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m"); | |
181 | ||
182 | /* master needs flag self */ | |
183 | if (!link->network->bridge) { | |
184 | flags = BRIDGE_FLAGS_SELF; | |
185 | sd_netlink_message_append_data(req, IFLA_BRIDGE_FLAGS, &flags, sizeof(uint16_t)); | |
186 | } | |
187 | ||
188 | /* add vlan info */ | |
189 | r = append_vlan_info_data(link, req, pvid, br_vid_bitmap, br_untagged_bitmap); | |
190 | if (r < 0) | |
191 | return log_link_error_errno(link, r, "Could not append VLANs: %m"); | |
192 | ||
193 | r = sd_netlink_message_close_container(req); | |
194 | if (r < 0) | |
195 | return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m"); | |
196 | ||
197 | /* send message to the kernel */ | |
ee38400b | 198 | r = sd_netlink_call_async(rtnl, NULL, req, set_brvlan_handler, |
8190a388 | 199 | link_netlink_destroy_callback, link, 0, __func__); |
13b498f9 TJ |
200 | if (r < 0) |
201 | return log_link_error_errno(link, r, "Could not send rtnetlink message: %m"); | |
202 | ||
1046bf9b YW |
203 | link_ref(link); |
204 | ||
13b498f9 TJ |
205 | return 0; |
206 | } | |
207 | ||
208 | static int parse_vid_range(const char *rvalue, uint16_t *vid, uint16_t *vid_end) { | |
209 | int r; | |
210 | char *p; | |
211 | char *_rvalue = NULL; | |
212 | uint16_t _vid = UINT16_MAX; | |
213 | uint16_t _vid_end = UINT16_MAX; | |
214 | ||
215 | assert(rvalue); | |
216 | assert(vid); | |
217 | assert(vid_end); | |
218 | ||
219 | _rvalue = strdupa(rvalue); | |
220 | p = strchr(_rvalue, '-'); | |
221 | if (p) { | |
222 | *p = '\0'; | |
223 | p++; | |
224 | r = parse_vlanid(_rvalue, &_vid); | |
225 | if (r < 0) | |
226 | return r; | |
227 | ||
ceac4078 | 228 | if (_vid == 0) |
13b498f9 TJ |
229 | return -ERANGE; |
230 | ||
231 | r = parse_vlanid(p, &_vid_end); | |
232 | if (r < 0) | |
233 | return r; | |
234 | ||
ceac4078 | 235 | if (_vid_end == 0) |
13b498f9 TJ |
236 | return -ERANGE; |
237 | } else { | |
238 | r = parse_vlanid(_rvalue, &_vid); | |
239 | if (r < 0) | |
240 | return r; | |
241 | ||
ceac4078 | 242 | if (_vid == 0) |
13b498f9 TJ |
243 | return -ERANGE; |
244 | } | |
245 | ||
246 | *vid = _vid; | |
247 | *vid_end = _vid_end; | |
248 | return r; | |
249 | } | |
250 | ||
ffff9abe TJ |
251 | int config_parse_brvlan_pvid(const char *unit, const char *filename, |
252 | unsigned line, const char *section, | |
253 | unsigned section_line, const char *lvalue, | |
254 | int ltype, const char *rvalue, void *data, | |
255 | void *userdata) { | |
256 | Network *network = userdata; | |
257 | int r; | |
258 | uint16_t pvid; | |
259 | r = parse_vlanid(rvalue, &pvid); | |
260 | if (r < 0) | |
261 | return r; | |
262 | ||
263 | network->pvid = pvid; | |
264 | network->use_br_vlan = true; | |
265 | ||
266 | return 0; | |
267 | } | |
268 | ||
13b498f9 TJ |
269 | int config_parse_brvlan_vlan(const char *unit, const char *filename, |
270 | unsigned line, const char *section, | |
271 | unsigned section_line, const char *lvalue, | |
272 | int ltype, const char *rvalue, void *data, | |
273 | void *userdata) { | |
274 | Network *network = userdata; | |
275 | int r; | |
276 | uint16_t vid, vid_end; | |
277 | ||
278 | assert(filename); | |
279 | assert(section); | |
280 | assert(lvalue); | |
281 | assert(rvalue); | |
282 | assert(data); | |
283 | ||
284 | r = parse_vid_range(rvalue, &vid, &vid_end); | |
285 | if (r < 0) { | |
286 | log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse VLAN, ignoring: %s", rvalue); | |
287 | return 0; | |
288 | } | |
289 | ||
290 | if (UINT16_MAX == vid_end) | |
291 | set_bit(vid++, network->br_vid_bitmap); | |
292 | else { | |
293 | if (vid >= vid_end) { | |
294 | log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid VLAN range, ignoring %s", rvalue); | |
295 | return 0; | |
296 | } | |
297 | for (; vid <= vid_end; vid++) | |
298 | set_bit(vid, network->br_vid_bitmap); | |
299 | } | |
ffff9abe | 300 | network->use_br_vlan = true; |
13b498f9 TJ |
301 | return 0; |
302 | } | |
303 | ||
304 | int config_parse_brvlan_untagged(const char *unit, const char *filename, | |
305 | unsigned line, const char *section, | |
306 | unsigned section_line, const char *lvalue, | |
307 | int ltype, const char *rvalue, void *data, | |
308 | void *userdata) { | |
309 | Network *network = userdata; | |
310 | int r; | |
311 | uint16_t vid, vid_end; | |
312 | ||
313 | assert(filename); | |
314 | assert(section); | |
315 | assert(lvalue); | |
316 | assert(rvalue); | |
317 | assert(data); | |
318 | ||
319 | r = parse_vid_range(rvalue, &vid, &vid_end); | |
320 | if (r < 0) { | |
321 | log_syntax(unit, LOG_ERR, filename, line, r, "Could not parse VLAN: %s", rvalue); | |
322 | return 0; | |
323 | } | |
324 | ||
325 | if (UINT16_MAX == vid_end) { | |
326 | set_bit(vid, network->br_vid_bitmap); | |
327 | set_bit(vid, network->br_untagged_bitmap); | |
328 | } else { | |
329 | if (vid >= vid_end) { | |
330 | log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid VLAN range, ignoring %s", rvalue); | |
331 | return 0; | |
332 | } | |
333 | for (; vid <= vid_end; vid++) { | |
334 | set_bit(vid, network->br_vid_bitmap); | |
335 | set_bit(vid, network->br_untagged_bitmap); | |
336 | } | |
337 | } | |
ffff9abe | 338 | network->use_br_vlan = true; |
13b498f9 TJ |
339 | return 0; |
340 | } |