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 <stdlib.h>
10 : : #include <string.h>
11 : :
12 : : #include "bpfilter/dump.h"
13 : : #include "bpfilter/helper.h"
14 : : #include "bpfilter/hook.h"
15 : : #include "bpfilter/list.h"
16 : : #include "bpfilter/logger.h"
17 : : #include "bpfilter/pack.h"
18 : : #include "bpfilter/rule.h"
19 : : #include "bpfilter/set.h"
20 : : #include "bpfilter/verdict.h"
21 : :
22 : 985 : int _bf_chain_check_rule(struct bf_chain *chain, const struct bf_rule *rule)
23 : : {
24 : : bf_assert(rule);
25 : :
26 [ + + ]: 985 : if (rule->log)
27 : 78 : chain->flags |= BF_FLAG(BF_CHAIN_LOG);
28 : :
29 [ + + ]: 985 : if (bf_rule_mark_is_set(rule) &&
30 [ + + ]: 22 : (chain->hook == BF_HOOK_XDP || chain->hook == BF_HOOK_NF_PRE_ROUTING ||
31 : : chain->hook == BF_HOOK_NF_POST_ROUTING ||
32 : : chain->hook == BF_HOOK_NF_FORWARD ||
33 : : chain->hook == BF_HOOK_NF_LOCAL_IN ||
34 : : chain->hook == BF_HOOK_NF_LOCAL_OUT)) {
35 [ + - ]: 2 : return bf_err_r(-EINVAL,
36 : : "XDP and Netfilter chains can't set packet mark");
37 : : }
38 : :
39 [ + + + + : 8598 : bf_list_foreach (&rule->matchers, matcher_node) {
+ + ]
40 : : struct bf_matcher *matcher = bf_list_node_get_data(matcher_node);
41 : : const struct bf_matcher_meta *meta;
42 : :
43 : : // Track if the chain uses IPv6 nexthdr matcher.
44 [ + + ]: 3325 : if (bf_matcher_get_type(matcher) == BF_MATCHER_IP6_NEXTHDR)
45 : 170 : chain->flags |= BF_FLAG(BF_CHAIN_STORE_NEXTHDR);
46 : :
47 : : // Set matchers are compatible with all hooks.
48 [ + + ]: 3325 : if (bf_matcher_get_type(matcher) == BF_MATCHER_SET)
49 : 184 : continue;
50 : :
51 : : // Ensure the matcher is compatible with the chain's hook.
52 : 3141 : meta = bf_matcher_get_meta(bf_matcher_get_type(matcher));
53 [ - + ]: 3141 : if (!meta) {
54 [ # # ]: 0 : return bf_err_r(-EINVAL, "unknown matcher type %d in rule",
55 : : bf_matcher_get_type(matcher));
56 : : }
57 : :
58 [ + + ]: 3141 : if (meta->unsupported_hooks & BF_FLAG(chain->hook)) {
59 [ + - ]: 9 : return bf_err_r(
60 : : -ENOTSUP, "matcher %s is not compatible with %s",
61 : : bf_matcher_type_to_str(bf_matcher_get_type(matcher)),
62 : : bf_hook_to_str(chain->hook));
63 : : }
64 : : }
65 : :
66 : : return 0;
67 : : }
68 : :
69 : 523 : int bf_chain_new(struct bf_chain **chain, const char *name, enum bf_hook hook,
70 : : enum bf_verdict policy, bf_list *sets, bf_list *rules)
71 : : {
72 : 523 : _free_bf_chain_ struct bf_chain *_chain = NULL;
73 : : size_t ridx = 0;
74 : : int r;
75 : :
76 : : bf_assert(chain && name);
77 : : bf_assert(policy < _BF_TERMINAL_VERDICT_MAX);
78 : :
79 : 523 : _chain = malloc(sizeof(*_chain));
80 [ - + ]: 523 : if (!_chain)
81 : : return -ENOMEM;
82 : :
83 : 523 : _chain->name = strdup(name);
84 [ - + ]: 523 : if (!_chain->name)
85 : : return -ENOMEM;
86 : :
87 : 523 : _chain->flags = 0;
88 : 523 : _chain->hook = hook;
89 : 523 : _chain->policy = policy;
90 : :
91 : 523 : _chain->sets = bf_list_default(bf_set_free, bf_set_pack);
92 [ + + ]: 523 : if (sets)
93 : 513 : _chain->sets = bf_list_move(*sets);
94 : :
95 : 523 : _chain->rules = bf_list_default(bf_rule_free, bf_rule_pack);
96 [ + + ]: 523 : if (rules)
97 : 472 : _chain->rules = bf_list_move(*rules);
98 [ + + + + : 2970 : bf_list_foreach (&_chain->rules, rule_node) {
+ + ]
99 : : struct bf_rule *rule = bf_list_node_get_data(rule_node);
100 : :
101 : 973 : rule->index = ridx++;
102 : 973 : r = _bf_chain_check_rule(_chain, rule);
103 [ + + ]: 973 : if (r)
104 : : return r;
105 : : }
106 : :
107 : 512 : *chain = TAKE_PTR(_chain);
108 : :
109 : 512 : return 0;
110 : : }
111 : :
112 : 78 : int bf_chain_new_from_pack(struct bf_chain **chain, bf_rpack_node_t node)
113 : : {
114 : 78 : _free_bf_chain_ struct bf_chain *_chain = NULL;
115 : 78 : _cleanup_free_ char *name = NULL;
116 : : enum bf_hook hook;
117 : : enum bf_verdict policy;
118 : : bf_rpack_node_t array, array_node;
119 : 78 : bf_list rules = bf_list_default(bf_rule_free, bf_rule_pack);
120 : 78 : bf_list sets = bf_list_default(bf_set_free, bf_set_pack);
121 : : int r;
122 : :
123 : 78 : r = bf_rpack_kv_str(node, "name", &name);
124 [ - + ]: 78 : if (r)
125 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.name");
126 : :
127 [ - + ]: 78 : r = bf_rpack_kv_enum(node, "hook", &hook);
128 : : if (r)
129 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.hook");
130 : :
131 [ - + ]: 78 : r = bf_rpack_kv_enum(node, "policy", &policy);
132 : : if (r)
133 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.policy");
134 : :
135 : 78 : r = bf_rpack_kv_array(node, "sets", &array);
136 [ - + ]: 78 : if (r)
137 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.sets");
138 [ + + + + : 316 : bf_rpack_array_foreach (array, array_node) {
+ + ]
139 : 160 : _free_bf_set_ struct bf_set *set = NULL;
140 : :
141 [ + - + - : 80 : r = bf_list_emplace(&sets, bf_set_new_from_pack, set, array_node);
- - - - ]
142 : : if (r) {
143 [ # # ]: 0 : return bf_err_r(r, "failed to unpack bf_set into bf_chain.sets");
144 : : }
145 : : }
146 : :
147 : 78 : r = bf_rpack_kv_array(node, "rules", &array);
148 [ - + ]: 78 : if (r)
149 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.rules");
150 [ + + + + : 774 : bf_rpack_array_foreach (array, array_node) {
+ + ]
151 : 618 : _free_bf_rule_ struct bf_rule *rule = NULL;
152 : :
153 [ + - + - : 309 : r = bf_list_emplace(&rules, bf_rule_new_from_pack, rule, array_node);
- - - - ]
154 : : if (r) {
155 [ # # ]: 0 : return bf_err_r(r, "failed to unpack bf_rule into bf_chain.rules");
156 : : }
157 : : }
158 : :
159 : 78 : r = bf_chain_new(&_chain, name, hook, policy, &sets, &rules);
160 [ - + ]: 78 : if (r)
161 [ # # ]: 0 : return bf_err_r(r, "failed to create bf_chain from pack");
162 : :
163 : 78 : *chain = TAKE_PTR(_chain);
164 : :
165 : 78 : return 0;
166 : : }
167 : :
168 : 1643 : void bf_chain_free(struct bf_chain **chain)
169 : : {
170 : : bf_assert(chain);
171 : :
172 [ + + ]: 1643 : if (!*chain)
173 : : return;
174 : :
175 : 523 : bf_list_clean(&(*chain)->sets);
176 : 523 : bf_list_clean(&(*chain)->rules);
177 : 523 : freep((void *)&(*chain)->name);
178 : : freep((void *)chain);
179 : : }
180 : :
181 : 244 : int bf_chain_pack(const struct bf_chain *chain, bf_wpack_t *pack)
182 : : {
183 : : bf_assert(chain);
184 : : bf_assert(pack);
185 : :
186 : 244 : bf_wpack_kv_str(pack, "name", chain->name);
187 : 244 : bf_wpack_kv_enum(pack, "hook", chain->hook);
188 : 244 : bf_wpack_kv_enum(pack, "policy", chain->policy);
189 : :
190 : 244 : bf_wpack_kv_list(pack, "sets", &chain->sets);
191 : 244 : bf_wpack_kv_list(pack, "rules", &chain->rules);
192 : :
193 [ - + ]: 244 : return bf_wpack_is_valid(pack) ? 0 : -EINVAL;
194 : : }
195 : :
196 : 16 : void bf_chain_dump(const struct bf_chain *chain, prefix_t *prefix)
197 : : {
198 : : bf_assert(chain && prefix);
199 : :
200 [ + + ]: 16 : DUMP(prefix, "struct bf_chain at %p", chain);
201 : 16 : bf_dump_prefix_push(prefix);
202 : :
203 [ + + ]: 16 : DUMP(prefix, "name: %s", chain->name);
204 [ + + ]: 16 : DUMP(prefix, "flags: %02x", chain->flags);
205 [ + + ]: 16 : DUMP(prefix, "hook: %s", bf_hook_to_str(chain->hook));
206 [ + + ]: 16 : DUMP(prefix, "policy: %s", bf_verdict_to_str(chain->policy));
207 : :
208 [ + + ]: 16 : DUMP(prefix, "sets: bf_list<bf_set>[%lu]", bf_list_size(&chain->sets));
209 : 16 : bf_dump_prefix_push(prefix);
210 [ + + + + : 38 : bf_list_foreach (&chain->sets, set_node) {
+ + ]
211 [ + + ]: 3 : if (bf_list_is_tail(&chain->sets, set_node))
212 : 1 : bf_dump_prefix_last(prefix);
213 : :
214 : 3 : bf_set_dump(bf_list_node_get_data(set_node), prefix);
215 : : }
216 : 16 : bf_dump_prefix_pop(prefix);
217 : :
218 [ + + ]: 16 : DUMP(bf_dump_prefix_last(prefix), "rules: bf_list<bf_rule>[%lu]",
219 : : bf_list_size(&chain->rules));
220 : 16 : bf_dump_prefix_push(prefix);
221 [ + + + + : 54 : bf_list_foreach (&chain->rules, rule_node) {
+ + ]
222 [ + + ]: 11 : if (bf_list_is_tail(&chain->rules, rule_node))
223 : 6 : bf_dump_prefix_last(prefix);
224 : :
225 : 11 : bf_rule_dump(bf_list_node_get_data(rule_node), prefix);
226 : : }
227 : 16 : bf_dump_prefix_pop(prefix);
228 : :
229 : 16 : bf_dump_prefix_pop(prefix);
230 : 16 : }
231 : :
232 : 12 : int bf_chain_add_rule(struct bf_chain *chain, struct bf_rule *rule)
233 : : {
234 : : int r;
235 : :
236 : : bf_assert(chain && rule);
237 : :
238 : 12 : rule->index = bf_list_size(&chain->rules);
239 : 12 : r = _bf_chain_check_rule(chain, rule);
240 [ + - ]: 12 : if (r)
241 : : return r;
242 : :
243 : 12 : return bf_list_add_tail(&chain->rules, rule);
244 : : }
245 : :
246 : 104 : struct bf_set *bf_chain_get_set_for_matcher(const struct bf_chain *chain,
247 : : const struct bf_matcher *matcher)
248 : : {
249 : : bf_assert(chain && matcher);
250 : :
251 : : uint32_t set_id;
252 : :
253 [ + + ]: 104 : if (bf_matcher_get_type(matcher) != BF_MATCHER_SET)
254 : : return NULL;
255 : :
256 : 103 : set_id = *(uint32_t *)bf_matcher_payload(matcher);
257 : :
258 : 103 : return bf_list_get_at(&chain->sets, set_id);
259 : : }
|
