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 : 9071 : 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 [ + + + + : 41272 : 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 [ + + ]: 11577 : if (bf_matcher_get_type(matcher) != BF_MATCHER_SET)
44 : 9868 : continue;
45 : :
46 : 1709 : set_index = *(uint32_t *)bf_matcher_payload(matcher);
47 : 1709 : set = bf_list_get_at(&chain->sets, set_index);
48 : :
49 [ - + ]: 1709 : if (!set) {
50 [ # # ]: 0 : return bf_err_r(-EINVAL, "rule %u references non-existent set",
51 : : rule->index);
52 : : }
53 : :
54 [ + + ]: 1709 : if (bf_set_is_empty(set)) {
55 [ + - ]: 12 : bf_warn("rule %u references empty set, rule will be disabled",
56 : : rule->index);
57 : : 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 : 11637 : 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 : 11637 : meta = bf_matcher_get_meta(type);
78 [ - + ]: 11637 : if (!meta) {
79 [ # # ]: 0 : return bf_err_r(-EINVAL, "missing meta for '%s'",
80 : : bf_matcher_type_to_str(type));
81 : : }
82 : :
83 [ + + ]: 11637 : if (meta->layer <= BF_MATCHER_NO_LAYER)
84 : : return 0;
85 : :
86 [ + + ]: 9257 : if (layer_hdr_id[meta->layer] == UINT32_MAX) {
87 : 7315 : layer_hdr_id[meta->layer] = meta->hdr_id;
88 : 7315 : return 0;
89 : : }
90 : :
91 [ + + ]: 1942 : if (layer_hdr_id[meta->layer] != meta->hdr_id)
92 : 24 : 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 : 9059 : 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 [ + + ]: 54354 : for (int i = 0; i < _BF_MATCHER_LAYER_MAX; ++i)
119 : 45295 : layer_hdr_id[i] = UINT32_MAX;
120 : :
121 [ + + + + : 41160 : 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 [ + + ]: 11545 : if (bf_matcher_get_type(matcher) == BF_MATCHER_SET) {
126 : : const struct bf_set *set =
127 : 1677 : bf_chain_get_set_for_matcher(chain, matcher);
128 : :
129 [ - + ]: 1677 : if (!set) {
130 [ # # ]: 0 : return bf_err_r(-ENOENT, "rule %u references non-existent set",
131 : : rule->index);
132 : : }
133 : :
134 [ + + + - ]: 3446 : for (size_t i = 0; i < set->n_comps && !r; ++i)
135 : 1769 : r = _bf_rule_check_layer(set->key[i], layer_hdr_id);
136 : : } else {
137 : 9868 : r = _bf_rule_check_layer(bf_matcher_get_type(matcher),
138 : : layer_hdr_id);
139 : : }
140 : :
141 [ + - ]: 11545 : if (r < 0)
142 : : return r;
143 [ + + ]: 11545 : if (r) {
144 [ + - ]: 24 : bf_warn(
145 : : "rule %u has incompatible matchers on the same layer, rule will be disabled",
146 : : rule->index);
147 : : return 1;
148 : : }
149 : : }
150 : :
151 : : return 0;
152 : : }
153 : :
154 : 9071 : static int _bf_chain_check_rule(struct bf_chain *chain, struct bf_rule *rule)
155 : : {
156 : : int r;
157 : :
158 : : assert(rule);
159 : :
160 : 9071 : r = _bf_rule_references_empty_set(chain, rule);
161 [ + - ]: 9071 : if (r < 0)
162 : : return r;
163 : 9071 : rule->disabled = r;
164 : :
165 [ + + ]: 9071 : if (!rule->disabled) {
166 : 9059 : r = _bf_rule_has_incompatible_matchers(chain, rule);
167 [ + - ]: 9059 : if (r < 0)
168 : : return r;
169 : :
170 : 9059 : rule->disabled = r;
171 : : }
172 : :
173 [ + + + + ]: 9187 : if (rule->log && rule->log != BF_LOG_OPT_DEFAULT &&
174 : 116 : 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 [ + + + + ]: 9067 : if (rule->log && !rule->disabled)
182 : 139 : chain->flags |= BF_FLAG(BF_CHAIN_LOG);
183 : :
184 [ + + + + : 9067 : if (rule->log && rule->log_rate_ns && !rule->disabled)
+ - ]
185 : 32 : chain->flags |= BF_FLAG(BF_CHAIN_LOG_RATELIMIT);
186 : :
187 [ + + + + ]: 9091 : if (bf_rule_mark_is_set(rule) &&
188 [ + + ]: 34 : bf_hook_to_flavor(chain->hook) != BF_FLAVOR_TC &&
189 : 10 : bf_hook_to_flavor(chain->hook) != BF_FLAVOR_CGROUP_SKB) {
190 [ + - ]: 2 : return bf_err_r(-EINVAL, "%s chains can't set packet mark",
191 : : bf_hook_to_str(chain->hook));
192 : : }
193 : :
194 [ + + + + : 41112 : bf_list_foreach (&rule->matchers, matcher_node) {
+ + ]
195 : : struct bf_matcher *matcher = bf_list_node_get_data(matcher_node);
196 : : const struct bf_matcher_meta *meta;
197 : :
198 : : // Track if the chain uses IPv6 nexthdr matcher.
199 [ + + ]: 11572 : if (bf_matcher_get_type(matcher) == BF_MATCHER_IP6_NEXTHDR &&
200 [ + - ]: 292 : !rule->disabled)
201 : 292 : chain->flags |= BF_FLAG(BF_CHAIN_STORE_NEXTHDR);
202 : :
203 : : // Ensure the matcher is compatible with the chain's hook.
204 : 11572 : meta = bf_matcher_get_meta(bf_matcher_get_type(matcher));
205 [ - + ]: 11572 : if (!meta) {
206 [ # # ]: 0 : return bf_err_r(-EINVAL, "unknown matcher type %d in rule",
207 : : bf_matcher_get_type(matcher));
208 : : }
209 : :
210 [ + + ]: 11572 : if (meta->unsupported_hooks & BF_FLAG(chain->hook)) {
211 [ + - ]: 72 : return bf_err_r(
212 : : -ENOTSUP, "matcher %s is not compatible with %s",
213 : : bf_matcher_type_to_str(bf_matcher_get_type(matcher)),
214 : : bf_hook_to_str(chain->hook));
215 : : }
216 : :
217 [ + + ]: 11500 : if (bf_matcher_get_type(matcher) == BF_MATCHER_SET) {
218 : : const struct bf_set *set =
219 : 1709 : bf_chain_get_set_for_matcher(chain, matcher);
220 : :
221 [ - + ]: 1709 : if (!set) {
222 [ # # ]: 0 : return bf_err_r(-ENOENT, "rule %u references non-existent set",
223 : : rule->index);
224 : : }
225 : :
226 [ + + ]: 3502 : for (size_t i = 0; i < set->n_comps; ++i) {
227 : : const struct bf_matcher_meta *comp_meta =
228 : 1802 : bf_matcher_get_meta(set->key[i]);
229 : :
230 [ - + ]: 1802 : if (!comp_meta) {
231 [ # # ]: 0 : return bf_err_r(-EINVAL,
232 : : "missing meta for set component '%s'",
233 : : bf_matcher_type_to_str(set->key[i]));
234 : : }
235 : :
236 [ + + ]: 1802 : if (comp_meta->unsupported_hooks & BF_FLAG(chain->hook)) {
237 [ + - ]: 9 : return bf_err_r(-ENOTSUP,
238 : : "set component '%s' not compatible with %s",
239 : : bf_matcher_type_to_str(set->key[i]),
240 : : bf_hook_to_str(chain->hook));
241 : : }
242 : : }
243 : : }
244 : : }
245 : :
246 : : return 0;
247 : : }
248 : :
249 : 8561 : int bf_chain_new(struct bf_chain **chain, const char *name, enum bf_hook hook,
250 : : enum bf_verdict policy, bf_list *sets, bf_list *rules)
251 : : {
252 : 8561 : _free_bf_chain_ struct bf_chain *_chain = NULL;
253 : : size_t ridx = 0;
254 : : int r;
255 : :
256 : : assert(chain && name);
257 [ - + ]: 8561 : if (hook >= _BF_HOOK_MAX)
258 [ # # ]: 0 : return bf_err_r(-EINVAL, "unknown hook type");
259 [ + + ]: 8561 : if (!bf_verdict_is_valid_policy(policy))
260 [ + - ]: 2 : return bf_err_r(-EINVAL, "invalid policy '%s'",
261 : : bf_verdict_to_str(policy));
262 : :
263 : 8559 : _chain = calloc(1, sizeof(*_chain));
264 [ + - ]: 8559 : if (!_chain)
265 : : return -ENOMEM;
266 : :
267 : 8559 : _chain->name = strdup(name);
268 [ + - ]: 8559 : if (!_chain->name)
269 : : return -ENOMEM;
270 : :
271 : 8559 : _chain->flags = 0;
272 : 8559 : _chain->hook = hook;
273 : 8559 : _chain->policy = policy;
274 : :
275 : 8559 : _chain->sets = bf_list_default(bf_set_free, bf_set_pack);
276 [ + + ]: 8559 : if (sets)
277 : 7411 : _chain->sets = bf_list_move(*sets);
278 : :
279 : 8559 : _chain->rules = bf_list_default(bf_rule_free, bf_rule_pack);
280 [ + + ]: 8559 : if (rules)
281 : 7370 : _chain->rules = bf_list_move(*rules);
282 [ + + + + : 32764 : bf_list_foreach (&_chain->rules, rule_node) {
+ + ]
283 : : struct bf_rule *rule = bf_list_node_get_data(rule_node);
284 : :
285 : 7910 : rule->index = ridx++;
286 : 7910 : r = _bf_chain_check_rule(_chain, rule);
287 [ + + ]: 7910 : if (r)
288 : : return r;
289 : : }
290 : :
291 : 8472 : *chain = TAKE_PTR(_chain);
292 : :
293 : 8472 : return 0;
294 : : }
295 : :
296 : 6640 : int bf_chain_new_from_pack(struct bf_chain **chain, bf_rpack_node_t node)
297 : : {
298 : 6640 : _free_bf_chain_ struct bf_chain *_chain = NULL;
299 : 6640 : _cleanup_free_ char *name = NULL;
300 : : enum bf_hook hook;
301 : : enum bf_verdict policy;
302 : : bf_rpack_node_t array, array_node;
303 : 6640 : _clean_bf_list_ bf_list rules = bf_list_default(bf_rule_free, bf_rule_pack);
304 : 6640 : _clean_bf_list_ bf_list sets = bf_list_default(bf_set_free, bf_set_pack);
305 : : int r;
306 : :
307 : 6640 : r = bf_rpack_kv_str(node, "name", &name);
308 [ - + ]: 6640 : if (r)
309 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.name");
310 : :
311 [ - + - + : 6640 : r = bf_rpack_kv_enum(node, "hook", &hook, 0, _BF_HOOK_MAX);
- - ]
312 : : if (r)
313 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.hook");
314 : :
315 [ - + - + : 6640 : r = bf_rpack_kv_enum(node, "policy", &policy, 0, _BF_VERDICT_MAX);
- - ]
316 : : if (r)
317 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.policy");
318 : :
319 : 6640 : r = bf_rpack_kv_array(node, "sets", &array);
320 [ - + ]: 6640 : if (r)
321 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.sets");
322 [ + + + + : 9350 : bf_rpack_array_foreach (array, array_node) {
+ + ]
323 : 2710 : _free_bf_set_ struct bf_set *set = NULL;
324 : :
325 [ + - + - : 1355 : r = bf_list_emplace(&sets, bf_set_new_from_pack, set, array_node);
- - - - ]
326 : : if (r) {
327 [ # # ]: 0 : return bf_err_r(r, "failed to unpack bf_set into bf_chain.sets");
328 : : }
329 : : }
330 : :
331 : 6640 : r = bf_rpack_kv_array(node, "rules", &array);
332 [ - + ]: 6640 : if (r)
333 [ # # ]: 0 : return bf_rpack_key_err(r, "bf_chain.rules");
334 [ + + + + : 20402 : bf_rpack_array_foreach (array, array_node) {
+ + ]
335 : 13762 : _free_bf_rule_ struct bf_rule *rule = NULL;
336 : :
337 [ + - + - : 6881 : r = bf_list_emplace(&rules, bf_rule_new_from_pack, rule, array_node);
- - - - ]
338 : : if (r) {
339 [ # # ]: 0 : return bf_err_r(r, "failed to unpack bf_rule into bf_chain.rules");
340 : : }
341 : : }
342 : :
343 : 6640 : r = bf_chain_new(&_chain, name, hook, policy, &sets, &rules);
344 [ - + ]: 6640 : if (r)
345 [ # # ]: 0 : return bf_err_r(r, "failed to create bf_chain from pack");
346 : :
347 : 6640 : *chain = TAKE_PTR(_chain);
348 : :
349 : 6640 : return 0;
350 : : }
351 : :
352 : 28072 : void bf_chain_free(struct bf_chain **chain)
353 : : {
354 : : assert(chain);
355 : :
356 [ + + ]: 28072 : if (!*chain)
357 : : return;
358 : :
359 : 8559 : bf_list_clean(&(*chain)->sets);
360 : 8559 : bf_list_clean(&(*chain)->rules);
361 : 8559 : BF_FREEP(&(*chain)->name);
362 : 8559 : BF_FREEP(chain);
363 : : }
364 : :
365 : 2642 : int bf_chain_pack(const struct bf_chain *chain, bf_wpack_t *pack)
366 : : {
367 : : assert(chain);
368 : : assert(pack);
369 : :
370 : 2642 : bf_wpack_kv_str(pack, "name", chain->name);
371 : 2642 : bf_wpack_kv_enum(pack, "hook", chain->hook);
372 : 2642 : bf_wpack_kv_enum(pack, "policy", chain->policy);
373 : :
374 : 2642 : bf_wpack_kv_list(pack, "sets", &chain->sets);
375 : 2642 : bf_wpack_kv_list(pack, "rules", &chain->rules);
376 : :
377 [ - + ]: 2642 : return bf_wpack_is_valid(pack) ? 0 : -EINVAL;
378 : : }
379 : :
380 : 18 : void bf_chain_dump(const struct bf_chain *chain, prefix_t *prefix)
381 : : {
382 : : assert(chain);
383 : : assert(prefix);
384 : :
385 [ - + ]: 18 : DUMP(prefix, "struct bf_chain at %p", chain);
386 : 18 : bf_dump_prefix_push(prefix);
387 : :
388 [ - + ]: 18 : DUMP(prefix, "name: %s", chain->name);
389 [ - + ]: 18 : DUMP(prefix, "flags: %02x", chain->flags);
390 [ - + ]: 18 : DUMP(prefix, "hook: %s", bf_hook_to_str(chain->hook));
391 [ - + ]: 18 : DUMP(prefix, "policy: %s", bf_verdict_to_str(chain->policy));
392 : :
393 [ - + ]: 18 : DUMP(prefix, "sets: bf_list<bf_set>[%lu]", bf_list_size(&chain->sets));
394 : 18 : bf_dump_prefix_push(prefix);
395 [ + + + + : 42 : bf_list_foreach (&chain->sets, set_node) {
+ + ]
396 [ + + ]: 3 : if (bf_list_is_tail(&chain->sets, set_node))
397 : 1 : bf_dump_prefix_last(prefix);
398 : :
399 : 3 : bf_set_dump(bf_list_node_get_data(set_node), prefix);
400 : : }
401 : 18 : bf_dump_prefix_pop(prefix);
402 : :
403 [ - + ]: 18 : DUMP(bf_dump_prefix_last(prefix), "rules: bf_list<bf_rule>[%lu]",
404 : : bf_list_size(&chain->rules));
405 : 18 : bf_dump_prefix_push(prefix);
406 [ + + + + : 60 : bf_list_foreach (&chain->rules, rule_node) {
+ + ]
407 [ + + ]: 12 : if (bf_list_is_tail(&chain->rules, rule_node))
408 : 7 : bf_dump_prefix_last(prefix);
409 : :
410 : 12 : bf_rule_dump(bf_list_node_get_data(rule_node), prefix);
411 : : }
412 : 18 : bf_dump_prefix_pop(prefix);
413 : :
414 [ - + ]: 18 : DUMP(prefix, "policy_counters: struct bf_counter");
415 : 18 : bf_dump_prefix_push(prefix);
416 [ - + ]: 18 : DUMP(prefix, "count: %lu", chain->policy_counters.count);
417 [ - + ]: 18 : DUMP(prefix, "size: %lu", chain->policy_counters.size);
418 : 18 : bf_dump_prefix_pop(prefix);
419 : :
420 [ - + ]: 18 : DUMP(prefix, "error_counters: struct bf_counter");
421 : 18 : bf_dump_prefix_push(prefix);
422 [ - + ]: 18 : DUMP(prefix, "count: %lu", chain->error_counters.count);
423 [ - + ]: 18 : DUMP(prefix, "size: %lu", chain->error_counters.size);
424 : 18 : bf_dump_prefix_pop(prefix);
425 : :
426 : 18 : bf_dump_prefix_pop(prefix);
427 : 18 : }
428 : :
429 : 1161 : int bf_chain_add_rule(struct bf_chain *chain, struct bf_rule *rule)
430 : : {
431 : : int r;
432 : :
433 : : assert(chain);
434 : : assert(rule);
435 : :
436 : 1161 : rule->index = bf_list_size(&chain->rules);
437 : 1161 : r = _bf_chain_check_rule(chain, rule);
438 [ + - ]: 1161 : if (r)
439 : : return r;
440 : :
441 : 1161 : return bf_list_add_tail(&chain->rules, rule);
442 : : }
443 : :
444 : 190 : int bf_chain_add_set(struct bf_chain *chain, struct bf_set *set)
445 : : {
446 : : assert(chain && set);
447 : :
448 : 190 : return bf_list_add_tail(&chain->sets, set);
449 : : }
450 : :
451 : 4241 : struct bf_set *bf_chain_get_set_for_matcher(const struct bf_chain *chain,
452 : : const struct bf_matcher *matcher)
453 : : {
454 : : assert(chain);
455 : : assert(matcher);
456 : :
457 : : uint32_t set_id;
458 : :
459 [ + + ]: 4241 : if (bf_matcher_get_type(matcher) != BF_MATCHER_SET)
460 : : return NULL;
461 : :
462 : 4240 : set_id = *(uint32_t *)bf_matcher_payload(matcher);
463 : :
464 : 4240 : return bf_list_get_at(&chain->sets, set_id);
465 : : }
466 : :
467 : 20 : struct bf_set *bf_chain_get_set_by_name(struct bf_chain *chain,
468 : : const char *set_name)
469 : : {
470 : : assert(chain);
471 : : assert(set_name);
472 : :
473 [ + - + + : 48 : bf_list_foreach (&chain->sets, set_node) {
+ + ]
474 : : struct bf_set *set = bf_list_node_get_data(set_node);
475 [ + + ]: 22 : if (bf_streq(set->name, set_name))
476 : : return set;
477 : : }
478 : :
479 : : return NULL;
480 : : }
481 : :
482 : 1311 : int bf_chain_new_from_copy(struct bf_chain **dest, const struct bf_chain *src)
483 : : {
484 : 1311 : _free_bf_wpack_ bf_wpack_t *wpack = NULL;
485 : 1311 : _free_bf_rpack_ bf_rpack_t *rpack = NULL;
486 : : const void *data;
487 : : size_t data_len;
488 : : int r;
489 : :
490 : : assert(dest);
491 : : assert(src);
492 : :
493 : : // For now, we do a copy by serializing and deserializing the struct.
494 : : // @todo Implement deep copy to avoid serialization overhead.
495 : 1311 : r = bf_wpack_new(&wpack);
496 [ - + ]: 1311 : if (r)
497 [ # # ]: 0 : return bf_err_r(r, "failed to create wpack for chain serialization");
498 : :
499 : 1311 : r = bf_chain_pack(src, wpack);
500 [ - + ]: 1311 : if (r)
501 [ # # ]: 0 : return bf_err_r(r, "failed to serialize chain");
502 : :
503 : 1311 : r = bf_wpack_get_data(wpack, &data, &data_len);
504 [ - + ]: 1311 : if (r)
505 [ # # ]: 0 : return bf_err_r(r, "failed to get serialized chain data");
506 : :
507 : 1311 : r = bf_rpack_new(&rpack, data, data_len);
508 [ - + ]: 1311 : if (r)
509 [ # # ]: 0 : return bf_err_r(r, "failed to create rpack for chain deserialization");
510 : :
511 : 1311 : r = bf_chain_new_from_pack(dest, bf_rpack_root(rpack));
512 [ - + ]: 1311 : if (r)
513 [ # # ]: 0 : return bf_err_r(r, "failed to deserialize chain");
514 : :
515 : : return 0;
516 : : }
|
