]>
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 | ||
a1e92eee | 25 | static void set_bit(unsigned nr, uint32_t *addr) { |
13b498f9 TJ |
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 | ||
302a796f | 138 | static int set_brvlan_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) { |
13b498f9 TJ |
139 | int r; |
140 | ||
141 | assert(link); | |
142 | ||
143 | r = sd_netlink_message_get_errno(m); | |
144 | if (r < 0 && r != -EEXIST) | |
145 | log_link_error_errno(link, r, "Could not add VLAN to bridge port: %m"); | |
146 | ||
147 | return 1; | |
148 | } | |
149 | ||
150 | int br_vlan_configure(Link *link, uint16_t pvid, uint32_t *br_vid_bitmap, uint32_t *br_untagged_bitmap) { | |
151 | _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL; | |
152 | int r; | |
153 | uint16_t flags; | |
154 | sd_netlink *rtnl; | |
155 | ||
156 | assert(link); | |
157 | assert(link->manager); | |
158 | assert(br_vid_bitmap); | |
159 | assert(br_untagged_bitmap); | |
160 | assert(link->network); | |
161 | ||
162 | /* pvid might not be in br_vid_bitmap yet */ | |
163 | if (pvid) | |
164 | set_bit(pvid, br_vid_bitmap); | |
165 | ||
166 | rtnl = link->manager->rtnl; | |
167 | ||
168 | /* create new RTM message */ | |
169 | r = sd_rtnl_message_new_link(rtnl, &req, RTM_SETLINK, link->ifindex); | |
170 | if (r < 0) | |
171 | return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m"); | |
172 | ||
173 | r = sd_rtnl_message_link_set_family(req, PF_BRIDGE); | |
174 | if (r < 0) | |
175 | return log_link_error_errno(link, r, "Could not set message family: %m"); | |
176 | ||
177 | r = sd_netlink_message_open_container(req, IFLA_AF_SPEC); | |
178 | if (r < 0) | |
179 | return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m"); | |
180 | ||
181 | /* master needs flag self */ | |
182 | if (!link->network->bridge) { | |
183 | flags = BRIDGE_FLAGS_SELF; | |
184 | sd_netlink_message_append_data(req, IFLA_BRIDGE_FLAGS, &flags, sizeof(uint16_t)); | |
185 | } | |
186 | ||
187 | /* add vlan info */ | |
188 | r = append_vlan_info_data(link, req, pvid, br_vid_bitmap, br_untagged_bitmap); | |
189 | if (r < 0) | |
190 | return log_link_error_errno(link, r, "Could not append VLANs: %m"); | |
191 | ||
192 | r = sd_netlink_message_close_container(req); | |
193 | if (r < 0) | |
194 | return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m"); | |
195 | ||
196 | /* send message to the kernel */ | |
302a796f YW |
197 | r = netlink_call_async(rtnl, NULL, req, set_brvlan_handler, |
198 | link_netlink_destroy_callback, link); | |
13b498f9 TJ |
199 | if (r < 0) |
200 | return log_link_error_errno(link, r, "Could not send rtnetlink message: %m"); | |
201 | ||
1046bf9b YW |
202 | link_ref(link); |
203 | ||
13b498f9 TJ |
204 | return 0; |
205 | } | |
206 | ||
207 | static int parse_vid_range(const char *rvalue, uint16_t *vid, uint16_t *vid_end) { | |
208 | int r; | |
209 | char *p; | |
210 | char *_rvalue = NULL; | |
211 | uint16_t _vid = UINT16_MAX; | |
212 | uint16_t _vid_end = UINT16_MAX; | |
213 | ||
214 | assert(rvalue); | |
215 | assert(vid); | |
216 | assert(vid_end); | |
217 | ||
218 | _rvalue = strdupa(rvalue); | |
219 | p = strchr(_rvalue, '-'); | |
220 | if (p) { | |
221 | *p = '\0'; | |
222 | p++; | |
223 | r = parse_vlanid(_rvalue, &_vid); | |
224 | if (r < 0) | |
225 | return r; | |
226 | ||
ceac4078 | 227 | if (_vid == 0) |
13b498f9 TJ |
228 | return -ERANGE; |
229 | ||
230 | r = parse_vlanid(p, &_vid_end); | |
231 | if (r < 0) | |
232 | return r; | |
233 | ||
ceac4078 | 234 | if (_vid_end == 0) |
13b498f9 TJ |
235 | return -ERANGE; |
236 | } else { | |
237 | r = parse_vlanid(_rvalue, &_vid); | |
238 | if (r < 0) | |
239 | return r; | |
240 | ||
ceac4078 | 241 | if (_vid == 0) |
13b498f9 TJ |
242 | return -ERANGE; |
243 | } | |
244 | ||
245 | *vid = _vid; | |
246 | *vid_end = _vid_end; | |
247 | return r; | |
248 | } | |
249 | ||
ffff9abe TJ |
250 | int config_parse_brvlan_pvid(const char *unit, const char *filename, |
251 | unsigned line, const char *section, | |
252 | unsigned section_line, const char *lvalue, | |
253 | int ltype, const char *rvalue, void *data, | |
254 | void *userdata) { | |
255 | Network *network = userdata; | |
256 | int r; | |
257 | uint16_t pvid; | |
258 | r = parse_vlanid(rvalue, &pvid); | |
259 | if (r < 0) | |
260 | return r; | |
261 | ||
262 | network->pvid = pvid; | |
263 | network->use_br_vlan = true; | |
264 | ||
265 | return 0; | |
266 | } | |
267 | ||
13b498f9 TJ |
268 | int config_parse_brvlan_vlan(const char *unit, const char *filename, |
269 | unsigned line, const char *section, | |
270 | unsigned section_line, const char *lvalue, | |
271 | int ltype, const char *rvalue, void *data, | |
272 | void *userdata) { | |
273 | Network *network = userdata; | |
274 | int r; | |
275 | uint16_t vid, vid_end; | |
276 | ||
277 | assert(filename); | |
278 | assert(section); | |
279 | assert(lvalue); | |
280 | assert(rvalue); | |
281 | assert(data); | |
282 | ||
283 | r = parse_vid_range(rvalue, &vid, &vid_end); | |
284 | if (r < 0) { | |
285 | log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse VLAN, ignoring: %s", rvalue); | |
286 | return 0; | |
287 | } | |
288 | ||
289 | if (UINT16_MAX == vid_end) | |
290 | set_bit(vid++, network->br_vid_bitmap); | |
291 | else { | |
292 | if (vid >= vid_end) { | |
293 | log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid VLAN range, ignoring %s", rvalue); | |
294 | return 0; | |
295 | } | |
296 | for (; vid <= vid_end; vid++) | |
297 | set_bit(vid, network->br_vid_bitmap); | |
298 | } | |
ffff9abe | 299 | network->use_br_vlan = true; |
13b498f9 TJ |
300 | return 0; |
301 | } | |
302 | ||
303 | int config_parse_brvlan_untagged(const char *unit, const char *filename, | |
304 | unsigned line, const char *section, | |
305 | unsigned section_line, const char *lvalue, | |
306 | int ltype, const char *rvalue, void *data, | |
307 | void *userdata) { | |
308 | Network *network = userdata; | |
309 | int r; | |
310 | uint16_t vid, vid_end; | |
311 | ||
312 | assert(filename); | |
313 | assert(section); | |
314 | assert(lvalue); | |
315 | assert(rvalue); | |
316 | assert(data); | |
317 | ||
318 | r = parse_vid_range(rvalue, &vid, &vid_end); | |
319 | if (r < 0) { | |
320 | log_syntax(unit, LOG_ERR, filename, line, r, "Could not parse VLAN: %s", rvalue); | |
321 | return 0; | |
322 | } | |
323 | ||
324 | if (UINT16_MAX == vid_end) { | |
325 | set_bit(vid, network->br_vid_bitmap); | |
326 | set_bit(vid, network->br_untagged_bitmap); | |
327 | } else { | |
328 | if (vid >= vid_end) { | |
329 | log_syntax(unit, LOG_ERR, filename, line, 0, "Invalid VLAN range, ignoring %s", rvalue); | |
330 | return 0; | |
331 | } | |
332 | for (; vid <= vid_end; vid++) { | |
333 | set_bit(vid, network->br_vid_bitmap); | |
334 | set_bit(vid, network->br_untagged_bitmap); | |
335 | } | |
336 | } | |
ffff9abe | 337 | network->use_br_vlan = true; |
13b498f9 TJ |
338 | return 0; |
339 | } |