Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-only */
2 : : /*
3 : : * Copyright (c) 2022 Meta Platforms, Inc. and affiliates.
4 : : */
5 : :
6 : : #include "bpfilter/chain.h"
7 : :
8 : : #include <errno.h>
9 : : #include <limits.h>
10 : : #include <stdlib.h>
11 : : #include <string.h>
12 : :
13 : : #include "bpfilter/core/list.h"
14 : : #include "bpfilter/dump.h"
15 : : #include "bpfilter/helper.h"
16 : : #include "bpfilter/hook.h"
17 : : #include "bpfilter/logger.h"
18 : : #include "bpfilter/matcher.h"
19 : : #include "bpfilter/pack.h"
20 : : #include "bpfilter/rule.h"
21 : : #include "bpfilter/set.h"
22 : : #include "bpfilter/verdict.h"
23 : :
24 : : /**
25 : : * @brief Check if a rule references an empty set.
26 : : *
27 : : * @param chain Chain containing the sets list.
28 : : * @param rule Rule to check.
29 : : * @return 0 if no issues, 1 if rule references an empty set (should be
30 : : * disabled), or negative errno if rule references a non-existent set.
31 : : */
32 : 9059 : static int _bf_rule_references_empty_set(const struct bf_chain *chain,
33 : : const struct bf_rule *rule)
34 : : {
35 : : assert(chain);
36 : : assert(rule);
37 : :
38 [ + + + + : 41224 : bf_list_foreach (&rule->matchers, matcher_node) {
+ + ]
39 : : struct bf_matcher *matcher = bf_list_node_get_data(matcher_node);
40 : : uint32_t set_index;
41 : : struct bf_set *set;
42 : :
43 [ + + ]: 11565 : if (bf_matcher_get_type(matcher) != BF_MATCHER_SET)
44 : 9862 : continue;
45 : :
46 : 1703 : set_index = *(uint32_t *)bf_matcher_payload(matcher);
47 : 1703 : set = bf_list_get_at(&chain->sets, set_index);
48 : :
49 [ - + ]: 1703 : if (!set) {
50 [ # # ]: 0 : return bf_err_r(-EINVAL, "rule %u references non-existent set",
51 : : rule->index);
52 : : }
53 : :
54 [ + + ]: 1703 : if (bf_set_is_empty(set)) {
55 [ + - ]: 12 : bf_warn("rule %u references empty set, rule will be disabled",
56 : : rule->index);
57 : 12 : return 1;
58 : : }
59 : : }
60 : : return 0;
61 : : }
62 : :
63 : : /**
64 : : * @brief Check a single matcher type against per-layer header tracking.
65 : : *
66 : : * @param type Matcher type to check.
67 : : * @param layer_hdr_id Per-layer header ID tracking array.
68 : : * @return 0 if compatible, 1 if incompatible, negative errno on error.
69 : : */
70 : 11625 : static int _bf_rule_check_layer(enum bf_matcher_type type,
71 : : uint32_t layer_hdr_id[_BF_MATCHER_LAYER_MAX])
72 : : {
73 : : const struct bf_matcher_meta *meta;
74 : :
75 : : assert(layer_hdr_id);
76 : :
77 : 11625 : meta = bf_matcher_get_meta(type);
78 [ - + ]: 11625 : if (!meta) {
79 [ # # ]: 0 : return bf_err_r(-EINVAL, "missing meta for '%s'",
80 : : bf_matcher_type_to_str(type));
81 : : }
82 : :
83 [ + + ]: 11625 : if (meta->layer <= BF_MATCHER_NO_LAYER)
84 : : return 0;
85 : :
86 [ + + ]: 9245 : if (layer_hdr_id[meta->layer] == UINT32_MAX) {
87 : 7303 : layer_hdr_id[meta->layer] = meta->hdr_id;
88 : 7303 : return 0;
89 : : }
90 : :
91 [ + + ]: 1942 : if (layer_hdr_id[meta->layer] != meta->hdr_id)
92 : : return 1;
93 : :
94 : : return 0;
95 : : }
96 : :
97 : : /**
98 : : * @brief Check if a rule has matchers on the same layer but different
99 : : * protocols.
100 : : *
101 : : * A rule matching on e.g. both IPv4 source address and IPv6 destination
102 : : * address can never match a packet (a packet is either IPv4 or IPv6, not
103 : : * both). Same for layer 4 (e.g. TCP vs UDP). Such rules should be disabled.
104 : : *
105 : : * @param chain Chain containing the sets list.
106 : : * @param rule Rule to check.
107 : : * @return 0 if no conflict, 1 if the rule contains incompatible matchers, or
108 : : * a negative errno value on failure.
109 : : */
110 : 9047 : static int _bf_rule_has_incompatible_matchers(const struct bf_chain *chain,
111 : : const struct bf_rule *rule)
112 : : {
113 : : uint32_t layer_hdr_id[_BF_MATCHER_LAYER_MAX];
114 : :
115 : : assert(chain);
116 : : assert(rule);
117 : :
118 [ + + ]: 54282 : for (int i = 0; i < _BF_MATCHER_LAYER_MAX; ++i)
119 : 45235 : layer_hdr_id[i] = UINT32_MAX;
120 : :
121 [ + + + + : 41112 : bf_list_foreach (&rule->matchers, matcher_node) {
+ + ]
122 : : struct bf_matcher *matcher = bf_list_node_get_data(matcher_node);
123 : : int r = 0;
124 : :
125 [ + + ]: 11533 : if (bf_matcher_get_type(matcher) == BF_MATCHER_SET) {
126 : : const struct bf_set *set =
127 : 1671 : bf_chain_get_set_for_matcher(chain, matcher);
128 : :
129 [ - + ]: 1671 : if (!set) {
130 [ # # ]: 0 : return bf_err_r(-ENOENT, "rule %u references non-existent set",
131 : : rule->index);
132 : : }
133 : :
134 [ + + + - ]: 3434 : for (size_t i = 0; i < set->n_comps && !r; ++i)
135 : 1763 : r = _bf_rule_check_layer(set->key[i], layer_hdr_id);
136 : : } else {
137 : 9862 : r = _bf_rule_check_layer(bf_matcher_get_type(matcher),
138 : : layer_hdr_id);
139 : : }
140 : :
141 [ + - ]: 11533 : if (r < 0)
142 : : return r;
143 [ + + ]: 11533 : if (r) {
144 [ + - ]: 24 : bf_warn(
145 : : "rule %u has incompatible matchers on the same layer, rule will be disabled",
146 : : rule->index);
147 : 24 : return 1;
148 : : }
149 : : }
150 : :
151 : : return 0;
152 : : }
153 : :
154 : 9059 : int _bf_chain_check_rule(struct bf_chain *chain, struct bf_rule *rule)
155 : : {
156 : : int r;
157 : :
158 : : assert(rule);
159 : :
160 : 9059 : r = _bf_rule_references_empty_set(chain, rule);
161 [ - + ]: 9059 : if (r < 0)
162 : : return r;
163 : 9059 : rule->disabled = r;
164 : :
165 [ + + ]: 9059 : if (!rule->disabled) {
166 : 9047 : r = _bf_rule_has_incompatible_matchers(chain, rule);
167 [ + - ]: 9047 : if (r < 0)
168 : : return r;
169 : :
170 : 9047 : rule->disabled = r;
171 : : }
172 : :
173 [ + + + + ]: 9173 : if (rule->log && rule->log != BF_LOG_OPT_DEFAULT &&
174 : 114 : bf_hook_to_flavor(chain->hook) == BF_FLAVOR_CGROUP_SOCK_ADDR) {
175 [ + - ]: 4 : return bf_err_r(
176 : : -ENOTSUP,
177 : : "per-field log options are not supported by %s, use 'log'",
178 : : bf_hook_to_str(chain->hook));
179 : : }
180 : :
181 [ + + + + ]: 9055 : if (rule->log && !rule->disabled)
182 : 133 : chain->flags |= BF_FLAG(BF_CHAIN_LOG);
183 : :
184 [ + + + + ]: 9079 : if (bf_rule_mark_is_set(rule) &&
185 [ + + ]: 34 : bf_hook_to_flavor(chain->hook) != BF_FLAVOR_TC &&
186 : 10 : bf_hook_to_flavor(chain->hook) != BF_FLAVOR_CGROUP_SKB) {
187 [ + - ]: 2 : return bf_err_r(-EINVAL, "%s chains can't set packet mark",
188 : : bf_hook_to_str(chain->hook));
189 : : }
190 : :
191 [ + + + + : 41064 : bf_list_foreach (&rule->matchers, matcher_node) {
+ + ]
192 : : struct bf_matcher *matcher = bf_list_node_get_data(matcher_node);
193 : : const struct bf_matcher_meta *meta;
194 : :
195 : : // Track if the chain uses IPv6 nexthdr matcher.
196 [ + + ]: 11560 : if (bf_matcher_get_type(matcher) == BF_MATCHER_IP6_NEXTHDR &&
197 [ + - ]: 292 : !rule->disabled)
198 : 292 : chain->flags |= BF_FLAG(BF_CHAIN_STORE_NEXTHDR);
199 : :
200 : : // Ensure the matcher is compatible with the chain's hook.
201 : 11560 : meta = bf_matcher_get_meta(bf_matcher_get_type(matcher));
202 [ - + ]: 11560 : if (!meta) {
203 [ # # ]: 0 : return bf_err_r(-EINVAL, "unknown matcher type %d in rule",
204 : : bf_matcher_get_type(matcher));
205 : : }
206 : :
207 [ + + ]: 11560 : if (meta->unsupported_hooks & BF_FLAG(chain->hook)) {
208 [ + - ]: 72 : return bf_err_r(
209 : : -ENOTSUP, "matcher %s is not compatible with %s",
210 : : bf_matcher_type_to_str(bf_matcher_get_type(matcher)),
211 : : bf_hook_to_str(chain->hook));
212 : : }
213 : :
214 [ + + ]: 11488 : if (bf_matcher_get_type(matcher) == BF_MATCHER_SET) {
215 : : const struct bf_set *set =
216 : 1703 : bf_chain_get_set_for_matcher(chain, matcher);
217 : :
218 [ - + ]: 1703 : if (!set) {
219 [ # # ]: 0 : return bf_err_r(-ENOENT, "rule %u references non-existent set",
220 : : rule->index);
221 : : }
222 : :
223 [ + + ]: 3490 : for (size_t i = 0; i < set->n_comps; ++i) {
224 : : const struct bf_matcher_meta *comp_meta =
225 : 1796 : bf_matcher_get_meta(set->key[i]);
226 : :
227 [ - + ]: 1796 : if (!comp_meta) {
228 [ # # ]: 0 : return bf_err_r(-EINVAL,
229 : : "missing meta for set component '%s'",
230 : : bf_matcher_type_to_str(set->key[i]));
231 : : }
232 : :
233 [ + + ]: 1796 : if (comp_meta->unsupported_hooks & BF_FLAG(chain->hook)) {
234 [ + - ]: 9 : return bf_err_r(-ENOTSUP,
235 : : "set component '%s' not compatible with %s",
236 : : bf_matcher_type_to_str(set->key[i]),
237 : : bf_hook_to_str(chain->hook));
238 : : }
239 : : }
240 : : }
241 : : }
242 : :
243 : : return 0;
244 : : }
245 : :
246 : 8552 : int bf_chain_new(struct bf_chain **chain, const char *name, enum bf_hook hook,
247 : : enum bf_verdict policy, bf_list *sets, bf_list *rules)
248 : : {
249 : 8552 : _free_bf_chain_ struct bf_chain *_chain = NULL;
250 : : size_t ridx = 0;
251 : : int r;
252 : :
253 : : assert(chain && name);
254 [ - + ]: 8552 : if (hook >= _BF_HOOK_MAX)
255 [ # # ]: 0 : return bf_err_r(-EINVAL, "unknown hook type");
256 [ + + ]: 8552 : if (!bf_verdict_is_valid_policy(policy))
257 [ + - ]: 2 : return bf_err_r(-EINVAL, "invalid policy '%s'",
258 : : bf_verdict_to_str(policy));
259 : :
260 : 8550 : _chain = calloc(1, sizeof(*_chain));
261 [ - + ]: 8550 : if (!_chain)
262 : : return -ENOMEM;
263 : :
264 : 8550 : _chain->name = strdup(name);
265 [ - + ]: 8550 : if (!_chain->name)
266 : : return -ENOMEM;
267 : :
268 : 8550 : _chain->flags = 0;
269 : 8550 : _chain->hook = hook;
270 : 8550 : _chain->policy = policy;
271 : :
272 : 8550 : _chain->sets = bf_list_default(bf_set_free, bf_set_pack);
273 [ + + ]: 8550 : if (sets)
274 : 7402 : _chain->sets = bf_list_move(*sets);
275 : :
276 : 8550 : _chain->rules = bf_list_default(bf_rule_free, bf_rule_pack);
277 [ + + ]: 8550 : if (rules)
278 : 7361 : _chain->rules = bf_list_move(*rules);
279 [ + + + + : 32722 : bf_list_foreach (&_chain->rules, rule_node) {
+ + ]
280 : : struct bf_rule *rule = bf_list_node_get_data(rule_node);
281 : :
282 : 7898 : rule->index = ridx++;
283 : 7898 : r = _bf_chain_check_rule(_chain, rule);
284 [ + + ]: 7898 : if (r)
285 : : return r;
286 : : }
287 : :
288 : 8463 : *chain = TAKE_PTR(_chain);
289 : :
290 : 8463 : return 0;
291 : : }
292 : :
293 : 6638 : int bf_chain_new_from_pack(struct bf_chain **chain, bf_rpack_node_t node)
294 : : {
295 : 6638 : _free_bf_chain_ struct bf_chain *_chain = NULL;
296 : 6638 : _cleanup_free_ char *name = NULL;
297 : : enum bf_hook hook;
298 : : enum bf_verdict policy;
299 : : bf_rpack_node_t array, array_node;
300 : 6638 : _clean_bf_list_ bf_list rules = bf_list_default(bf_rule_free, bf_rule_pack);
301 : 6638 : _clean_bf_list_ bf_list sets = bf_list_default(bf_set_free, bf_set_pack);
302 : : int r;
303 : :
304 : 6638 : r = bf_rpack_kv_str(node, "name", &name);
305 [ - + ]: 6638 : if (r)
306 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.name");
307 : :
308 [ - + - + : 6638 : r = bf_rpack_kv_enum(node, "hook", &hook, 0, _BF_HOOK_MAX);
- - ]
309 : : if (r)
310 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.hook");
311 : :
312 [ - + - + : 6638 : r = bf_rpack_kv_enum(node, "policy", &policy, 0, _BF_VERDICT_MAX);
- - ]
313 : : if (r)
314 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.policy");
315 : :
316 : 6638 : r = bf_rpack_kv_array(node, "sets", &array);
317 [ - + ]: 6638 : if (r)
318 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.sets");
319 [ + + + + : 15950 : bf_rpack_array_foreach (array, array_node) {
+ + ]
320 : 2674 : _free_bf_set_ struct bf_set *set = NULL;
321 : :
322 [ + - + - : 1337 : r = bf_list_emplace(&sets, bf_set_new_from_pack, set, array_node);
- - - - ]
323 : : if (r) {
324 [ # # ]: 0 : return bf_err_r(r, "failed to unpack bf_set into bf_chain.sets");
325 : : }
326 : : }
327 : :
328 : 6638 : r = bf_rpack_kv_array(node, "rules", &array);
329 [ - + ]: 6638 : if (r)
330 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.rules");
331 [ + + + + : 27030 : bf_rpack_array_foreach (array, array_node) {
+ + ]
332 : 13754 : _free_bf_rule_ struct bf_rule *rule = NULL;
333 : :
334 [ + - + - : 6877 : r = bf_list_emplace(&rules, bf_rule_new_from_pack, rule, array_node);
- - - - ]
335 : : if (r) {
336 [ # # ]: 0 : return bf_err_r(r, "failed to unpack bf_rule into bf_chain.rules");
337 : : }
338 : : }
339 : :
340 : 6638 : r = bf_chain_new(&_chain, name, hook, policy, &sets, &rules);
341 [ - + ]: 6638 : if (r)
342 [ # # ]: 0 : return bf_err_r(r, "failed to create bf_chain from pack");
343 : :
344 : 6638 : *chain = TAKE_PTR(_chain);
345 : :
346 : 6638 : return 0;
347 : : }
348 : :
349 : 28044 : void bf_chain_free(struct bf_chain **chain)
350 : : {
351 : : assert(chain);
352 : :
353 [ + + ]: 28044 : if (!*chain)
354 : : return;
355 : :
356 : 8550 : bf_list_clean(&(*chain)->sets);
357 : 8550 : bf_list_clean(&(*chain)->rules);
358 : 8550 : freep((void *)&(*chain)->name);
359 : : freep((void *)chain);
360 : : }
361 : :
362 : 2640 : int bf_chain_pack(const struct bf_chain *chain, bf_wpack_t *pack)
363 : : {
364 : : assert(chain);
365 : : assert(pack);
366 : :
367 : 2640 : bf_wpack_kv_str(pack, "name", chain->name);
368 : 2640 : bf_wpack_kv_enum(pack, "hook", chain->hook);
369 : 2640 : bf_wpack_kv_enum(pack, "policy", chain->policy);
370 : :
371 : 2640 : bf_wpack_kv_list(pack, "sets", &chain->sets);
372 : 2640 : bf_wpack_kv_list(pack, "rules", &chain->rules);
373 : :
374 [ - + ]: 2640 : return bf_wpack_is_valid(pack) ? 0 : -EINVAL;
375 : : }
376 : :
377 : 18 : void bf_chain_dump(const struct bf_chain *chain, prefix_t *prefix)
378 : : {
379 : : assert(chain);
380 : : assert(prefix);
381 : :
382 [ - + ]: 18 : DUMP(prefix, "struct bf_chain at %p", chain);
383 : 18 : bf_dump_prefix_push(prefix);
384 : :
385 [ - + ]: 18 : DUMP(prefix, "name: %s", chain->name);
386 [ - + ]: 18 : DUMP(prefix, "flags: %02x", chain->flags);
387 [ - + ]: 18 : DUMP(prefix, "hook: %s", bf_hook_to_str(chain->hook));
388 [ - + ]: 18 : DUMP(prefix, "policy: %s", bf_verdict_to_str(chain->policy));
389 : :
390 [ - + ]: 18 : DUMP(prefix, "sets: bf_list<bf_set>[%lu]", bf_list_size(&chain->sets));
391 : 18 : bf_dump_prefix_push(prefix);
392 [ + + + + : 42 : bf_list_foreach (&chain->sets, set_node) {
+ + ]
393 [ + + ]: 3 : if (bf_list_is_tail(&chain->sets, set_node))
394 : 1 : bf_dump_prefix_last(prefix);
395 : :
396 : 3 : bf_set_dump(bf_list_node_get_data(set_node), prefix);
397 : : }
398 : 18 : bf_dump_prefix_pop(prefix);
399 : :
400 [ - + ]: 18 : DUMP(bf_dump_prefix_last(prefix), "rules: bf_list<bf_rule>[%lu]",
401 : : bf_list_size(&chain->rules));
402 : 18 : bf_dump_prefix_push(prefix);
403 [ + + + + : 60 : bf_list_foreach (&chain->rules, rule_node) {
+ + ]
404 [ + + ]: 12 : if (bf_list_is_tail(&chain->rules, rule_node))
405 : 7 : bf_dump_prefix_last(prefix);
406 : :
407 : : bf_rule_dump(bf_list_node_get_data(rule_node), prefix);
408 : : }
409 : 18 : bf_dump_prefix_pop(prefix);
410 : :
411 [ - + ]: 18 : DUMP(prefix, "policy_counters: struct bf_counter");
412 : 18 : bf_dump_prefix_push(prefix);
413 [ - + ]: 18 : DUMP(prefix, "count: %lu", chain->policy_counters.count);
414 [ - + ]: 18 : DUMP(prefix, "size: %lu", chain->policy_counters.size);
415 : 18 : bf_dump_prefix_pop(prefix);
416 : :
417 [ - + ]: 18 : DUMP(prefix, "error_counters: struct bf_counter");
418 : 18 : bf_dump_prefix_push(prefix);
419 [ - + ]: 18 : DUMP(prefix, "count: %lu", chain->error_counters.count);
420 [ - + ]: 18 : DUMP(prefix, "size: %lu", chain->error_counters.size);
421 : 18 : bf_dump_prefix_pop(prefix);
422 : :
423 : 18 : bf_dump_prefix_pop(prefix);
424 : 18 : }
425 : :
426 : 1161 : int bf_chain_add_rule(struct bf_chain *chain, struct bf_rule *rule)
427 : : {
428 : : int r;
429 : :
430 : : assert(chain);
431 : : assert(rule);
432 : :
433 : 1161 : rule->index = bf_list_size(&chain->rules);
434 : 1161 : r = _bf_chain_check_rule(chain, rule);
435 [ + - ]: 1161 : if (r)
436 : : return r;
437 : :
438 : 1161 : return bf_list_add_tail(&chain->rules, rule);
439 : : }
440 : :
441 : 190 : int bf_chain_add_set(struct bf_chain *chain, struct bf_set *set)
442 : : {
443 : : assert(chain && set);
444 : :
445 : 190 : return bf_list_add_tail(&chain->sets, set);
446 : : }
447 : :
448 : 4223 : struct bf_set *bf_chain_get_set_for_matcher(const struct bf_chain *chain,
449 : : const struct bf_matcher *matcher)
450 : : {
451 : : assert(chain);
452 : : assert(matcher);
453 : :
454 : : uint32_t set_id;
455 : :
456 [ + + ]: 4223 : if (bf_matcher_get_type(matcher) != BF_MATCHER_SET)
457 : : return NULL;
458 : :
459 : 4222 : set_id = *(uint32_t *)bf_matcher_payload(matcher);
460 : :
461 : 4222 : return bf_list_get_at(&chain->sets, set_id);
462 : : }
463 : :
464 : 20 : struct bf_set *bf_chain_get_set_by_name(struct bf_chain *chain,
465 : : const char *set_name)
466 : : {
467 : : assert(chain);
468 : : assert(set_name);
469 : :
470 [ + - + + : 46 : bf_list_foreach (&chain->sets, set_node) {
+ + ]
471 : : struct bf_set *set = bf_list_node_get_data(set_node);
472 [ + + ]: 22 : if (bf_streq(set->name, set_name))
473 : : return set;
474 : : }
475 : :
476 : : return NULL;
477 : : }
478 : :
479 : 1310 : int bf_chain_new_from_copy(struct bf_chain **dest, const struct bf_chain *src)
480 : : {
481 : 1310 : _free_bf_wpack_ bf_wpack_t *wpack = NULL;
482 : 1310 : _free_bf_rpack_ bf_rpack_t *rpack = NULL;
483 : : const void *data;
484 : : size_t data_len;
485 : : int r;
486 : :
487 : : assert(dest);
488 : : assert(src);
489 : :
490 : : // For now, we do a copy by serializing and deserializing the struct.
491 : : // @todo Implement deep copy to avoid serialization overhead.
492 : 1310 : r = bf_wpack_new(&wpack);
493 [ - + ]: 1310 : if (r)
494 [ # # ]: 0 : return bf_err_r(r, "failed to create wpack for chain serialization");
495 : :
496 : 1310 : r = bf_chain_pack(src, wpack);
497 [ - + ]: 1310 : if (r)
498 [ # # ]: 0 : return bf_err_r(r, "failed to serialize chain");
499 : :
500 : 1310 : r = bf_wpack_get_data(wpack, &data, &data_len);
501 [ - + ]: 1310 : if (r)
502 [ # # ]: 0 : return bf_err_r(r, "failed to get serialized chain data");
503 : :
504 : 1310 : r = bf_rpack_new(&rpack, data, data_len);
505 [ - + ]: 1310 : if (r)
506 [ # # ]: 0 : return bf_err_r(r, "failed to create rpack for chain deserialization");
507 : :
508 : 1310 : r = bf_chain_new_from_pack(dest, bf_rpack_root(rpack));
509 [ - + ]: 1310 : if (r)
510 [ # # ]: 0 : return bf_err_r(r, "failed to deserialize chain");
511 : :
512 : : return 0;
513 : : }
|
