diff options
| -rw-r--r-- | filter/filter.c | 189 |
1 files changed, 96 insertions, 93 deletions
diff --git a/filter/filter.c b/filter/filter.c index 37cf16a3..1e608138 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -50,6 +50,16 @@ #define CMP_ERROR 999 +/* Internal filter state, to be allocated on stack when executing filters */ +struct filter_state { + struct rte **rte; + struct rta *old_rta; + struct ea_list **eattrs; + struct linpool *pool; + struct buffer buf; + int flags; +}; + void (*bt_assert_hook)(int result, struct f_inst *assert); static struct adata undef_adata; /* adata of length 0 used for undefined */ @@ -536,65 +546,59 @@ val_format(struct f_val v, buffer *buf) } } -static struct rte **f_rte; -static struct rta *f_old_rta; -static struct ea_list **f_eattrs; -static struct linpool *f_pool; -static struct buffer f_buf; -static int f_flags; -static inline void f_cache_eattrs(void) +static inline void f_cache_eattrs(struct filter_state *fs) { - f_eattrs = &((*f_rte)->attrs->eattrs); + fs->eattrs = &((*fs->rte)->attrs->eattrs); } -static inline void f_rte_cow(void) +static inline void f_rte_cow(struct filter_state *fs) { - if (!((*f_rte)->flags & REF_COW)) + if (!((*fs->rte)->flags & REF_COW)) return; - *f_rte = rte_do_cow(*f_rte); + *fs->rte = rte_cow(*fs->rte); } /* * rta_cow - prepare rta for modification by filter */ static void -f_rta_cow(void) +f_rta_cow(struct filter_state *fs) { - if (!rta_is_cached((*f_rte)->attrs)) + if (!rta_is_cached((*fs->rte)->attrs)) return; /* Prepare to modify rte */ - f_rte_cow(); + f_rte_cow(fs); /* Store old rta to free it later, it stores reference from rte_cow() */ - f_old_rta = (*f_rte)->attrs; + fs->old_rta = (*fs->rte)->attrs; /* * Get shallow copy of rta. Fields eattrs and nexthops of rta are shared - * with f_old_rta (they will be copied when the cached rta will be obtained + * with fs->old_rta (they will be copied when the cached rta will be obtained * at the end of f_run()), also the lock of hostentry is inherited (we * suppose hostentry is not changed by filters). */ - (*f_rte)->attrs = rta_do_cow((*f_rte)->attrs, f_pool); + (*fs->rte)->attrs = rta_do_cow((*fs->rte)->attrs, fs->pool); /* Re-cache the ea_list */ - f_cache_eattrs(); + f_cache_eattrs(fs); } static char * -val_format_str(struct f_val v) { +val_format_str(struct filter_state *fs, struct f_val v) { buffer b; LOG_BUFFER_INIT(b); val_format(v, &b); - return lp_strdup(f_pool, b.start); + return lp_strdup(fs->pool, b.start); } static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS; #define runtime(fmt, ...) do { \ - if (!(f_flags & FF_SILENT)) \ + if (!(fs->flags & FF_SILENT)) \ log_rl(&rl_runtime_err, L_ERR "filters, line %d: " fmt, what->lineno, ##__VA_ARGS__); \ res.type = T_RETURN; \ res.val.i = F_ERROR; \ @@ -609,21 +613,22 @@ static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS; n, f_instruction_name(what->fi_code), t, v##n.type); #define INTERPRET(val, what_) \ - val = interpret(what_); \ + val = interpret(fs, what_); \ if (val.type & T_RETURN) \ return val; #define ACCESS_RTE \ - do { if (!f_rte) runtime("No route to access"); } while (0) + do { if (!fs->rte) runtime("No route to access"); } while (0) #define ACCESS_EATTRS \ - do { if (!f_eattrs) f_cache_eattrs(); } while (0) + do { if (!fs->eattrs) f_cache_eattrs(fs); } while (0) #define BITFIELD_MASK(what) \ (1u << (what->a2.i >> 24)) /** * interpret + * @fs: filter state * @what: filter to interpret * * Interpret given tree of filter instructions. This is core function @@ -640,7 +645,7 @@ static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS; * memory managment. */ static struct f_val -interpret(struct f_inst *what) +interpret(struct filter_state *fs, struct f_inst *what) { struct symbol *sym; struct f_val v1, v2, v3, res = { .type = T_VOID }, *vp; @@ -761,7 +766,7 @@ interpret(struct f_inst *what) struct f_path_mask *tt = what->a1.p, *vbegin, **vv = &vbegin; while (tt) { - *vv = lp_alloc(f_pool, sizeof(struct f_path_mask)); + *vv = lp_alloc(fs->pool, sizeof(struct f_path_mask)); if (tt->kind == PM_ASN_EXPR) { struct f_val res; INTERPRET(res, (struct f_inst *) tt->val); @@ -895,7 +900,7 @@ interpret(struct f_inst *what) break; case FI_PRINT: ARG_ANY(1); - val_format(v1, &f_buf); + val_format(v1, &fs->buf); break; case FI_CONDITION: /* ? has really strange error value, so we can implement if ... else nicely :-) */ ARG(1, T_BOOL); @@ -912,8 +917,8 @@ interpret(struct f_inst *what) case FI_PRINT_AND_DIE: ARG_ANY(1); if ((what->a2.i == F_NOP || (what->a2.i != F_NONL && what->a1.p)) && - !(f_flags & FF_SILENT)) - log_commit(*L_INFO, &f_buf); + !(fs->flags & FF_SILENT)) + log_commit(*L_INFO, &fs->buf); switch (what->a2.i) { case F_QUITBIRD: @@ -935,14 +940,14 @@ interpret(struct f_inst *what) case FI_RTA_GET: /* rta access */ { ACCESS_RTE; - struct rta *rta = (*f_rte)->attrs; + struct rta *rta = (*fs->rte)->attrs; res.type = what->aux; switch (what->a2.i) { case SA_FROM: res.val.ip = rta->from; break; case SA_GW: res.val.ip = rta->nh.gw; break; - case SA_NET: res.val.net = (*f_rte)->net->n.addr; break; + case SA_NET: res.val.net = (*fs->rte)->net->n.addr; break; case SA_PROTO: res.val.s = rta->src->proto->name; break; case SA_SOURCE: res.val.i = rta->source; break; case SA_SCOPE: res.val.i = rta->scope; break; @@ -961,9 +966,9 @@ interpret(struct f_inst *what) if (what->aux != v1.type) runtime( "Attempt to set static attribute to incompatible type" ); - f_rta_cow(); + f_rta_cow(fs); { - struct rta *rta = (*f_rte)->attrs; + struct rta *rta = (*fs->rte)->attrs; switch (what->a2.i) { @@ -1027,7 +1032,7 @@ interpret(struct f_inst *what) { u16 code = what->a2.i; int f_type = what->aux >> 8; - eattr *e = ea_find(*f_eattrs, code); + eattr *e = ea_find(*fs->eattrs, code); if (!e) { /* A special case: undefined as_path looks like empty as_path */ @@ -1114,7 +1119,7 @@ interpret(struct f_inst *what) ACCESS_EATTRS; ARG_ANY(1); { - struct ea_list *l = lp_alloc(f_pool, sizeof(struct ea_list) + sizeof(eattr)); + struct ea_list *l = lp_alloc(fs->pool, sizeof(struct ea_list) + sizeof(eattr)); u16 code = what->a2.i; int f_type = what->aux >> 8; @@ -1151,7 +1156,7 @@ interpret(struct f_inst *what) if (v1.type != T_IP) runtime( "Setting ip attribute to non-ip value" ); int len = sizeof(ip_addr); - struct adata *ad = lp_alloc(f_pool, sizeof(struct adata) + len); + struct adata *ad = lp_alloc(fs->pool, sizeof(struct adata) + len); ad->length = len; (* (ip_addr *) ad->data) = v1.val.ip; l->attrs[0].u.ptr = ad; @@ -1166,7 +1171,7 @@ interpret(struct f_inst *what) runtime( "Setting bit in bitfield attribute to non-bool value" ); { /* First, we have to find the old value */ - eattr *e = ea_find(*f_eattrs, code); + eattr *e = ea_find(*fs->eattrs, code); u32 data = e ? e->u.data : 0; if (v1.val.i) @@ -1198,23 +1203,23 @@ interpret(struct f_inst *what) default: bug("Unknown type in e,S"); } - f_rta_cow(); - l->next = *f_eattrs; - *f_eattrs = l; + f_rta_cow(fs); + l->next = *fs->eattrs; + *fs->eattrs = l; } break; case FI_PREF_GET: ACCESS_RTE; res.type = T_INT; - res.val.i = (*f_rte)->pref; + res.val.i = (*fs->rte)->pref; break; case FI_PREF_SET: ACCESS_RTE; ARG(1,T_INT); if (v1.val.i > 0xFFFF) runtime( "Setting preference value out of bounds" ); - f_rte_cow(); - (*f_rte)->pref = v1.val.i; + f_rte_cow(fs); + (*fs->rte)->pref = v1.val.i; break; case FI_LENGTH: /* Get length of */ ARG_ANY(1); @@ -1235,7 +1240,7 @@ interpret(struct f_inst *what) { net_addr_ip6_sadr *net = (void *) v1.val.net; - net_addr *src = lp_alloc(f_pool, sizeof(net_addr_ip6)); + net_addr *src = lp_alloc(fs->pool, sizeof(net_addr_ip6)); net_fill_ip6(src, net->src_prefix, net->src_pxlen); res.type = T_NET; @@ -1304,7 +1309,7 @@ interpret(struct f_inst *what) return res; case FI_CALL: /* CALL: this is special: if T_RETURN and returning some value, mask it out */ ARG_ANY(1); - res = interpret(what->a2.p); + res = interpret(fs, what->a2.p); if (res.type == T_RETURN) return res; res.type &= ~T_RETURN; @@ -1342,14 +1347,14 @@ interpret(struct f_inst *what) case FI_EMPTY: /* Create empty attribute */ res.type = what->aux; - res.val.ad = adata_empty(f_pool, 0); + res.val.ad = adata_empty(fs->pool, 0); break; case FI_PATH_PREPEND: /* Path prepend */ ARG(1, T_PATH); ARG(2, T_INT); res.type = T_PATH; - res.val.ad = as_path_prepend(f_pool, v1.val.ad, v2.val.i); + res.val.ad = as_path_prepend(fs->pool, v1.val.ad, v2.val.i); break; case FI_CLIST_ADD_DEL: /* (Extended) Community list add or delete */ @@ -1380,7 +1385,7 @@ interpret(struct f_inst *what) runtime("Can't filter integer"); res.type = T_PATH; - res.val.ad = as_path_filter(f_pool, v1.val.ad, set, key, pos); + res.val.ad = as_path_filter(fs->pool, v1.val.ad, set, key, pos); } else if (v1.type == T_CLIST) { @@ -1408,22 +1413,22 @@ interpret(struct f_inst *what) if (arg_set == 1) runtime("Can't add set"); else if (!arg_set) - res.val.ad = int_set_add(f_pool, v1.val.ad, n); + res.val.ad = int_set_add(fs->pool, v1.val.ad, n); else - res.val.ad = int_set_union(f_pool, v1.val.ad, v2.val.ad); + res.val.ad = int_set_union(fs->pool, v1.val.ad, v2.val.ad); break; case 'd': if (!arg_set) - res.val.ad = int_set_del(f_pool, v1.val.ad, n); + res.val.ad = int_set_del(fs->pool, v1.val.ad, n); else - res.val.ad = clist_filter(f_pool, v1.val.ad, v2, 0); + res.val.ad = clist_filter(fs->pool, v1.val.ad, v2, 0); break; case 'f': if (!arg_set) runtime("Can't filter pair"); - res.val.ad = clist_filter(f_pool, v1.val.ad, v2, 1); + res.val.ad = clist_filter(fs->pool, v1.val.ad, v2, 1); break; default: @@ -1450,22 +1455,22 @@ interpret(struct f_inst *what) if (arg_set == 1) runtime("Can't add set"); else if (!arg_set) - res.val.ad = ec_set_add(f_pool, v1.val.ad, v2.val.ec); + res.val.ad = ec_set_add(fs->pool, v1.val.ad, v2.val.ec); else - res.val.ad = ec_set_union(f_pool, v1.val.ad, v2.val.ad); + res.val.ad = ec_set_union(fs->pool, v1.val.ad, v2.val.ad); break; case 'd': if (!arg_set) - res.val.ad = ec_set_del(f_pool, v1.val.ad, v2.val.ec); + res.val.ad = ec_set_del(fs->pool, v1.val.ad, v2.val.ec); else - res.val.ad = eclist_filter(f_pool, v1.val.ad, v2, 0); + res.val.ad = eclist_filter(fs->pool, v1.val.ad, v2, 0); break; case 'f': if (!arg_set) runtime("Can't filter ec"); - res.val.ad = eclist_filter(f_pool, v1.val.ad, v2, 1); + res.val.ad = eclist_filter(fs->pool, v1.val.ad, v2, 1); break; default: @@ -1492,22 +1497,22 @@ interpret(struct f_inst *what) if (arg_set == 1) runtime("Can't add set"); else if (!arg_set) - res.val.ad = lc_set_add(f_pool, v1.val.ad, v2.val.lc); + res.val.ad = lc_set_add(fs->pool, v1.val.ad, v2.val.lc); else - res.val.ad = lc_set_union(f_pool, v1.val.ad, v2.val.ad); + res.val.ad = lc_set_union(fs->pool, v1.val.ad, v2.val.ad); break; case 'd': if (!arg_set) - res.val.ad = lc_set_del(f_pool, v1.val.ad, v2.val.lc); + res.val.ad = lc_set_del(fs->pool, v1.val.ad, v2.val.lc); else - res.val.ad = lclist_filter(f_pool, v1.val.ad, v2, 0); + res.val.ad = lclist_filter(fs->pool, v1.val.ad, v2, 0); break; case 'f': if (!arg_set) runtime("Can't filter lc"); - res.val.ad = lclist_filter(f_pool, v1.val.ad, v2, 1); + res.val.ad = lclist_filter(fs->pool, v1.val.ad, v2, 1); break; default: @@ -1531,11 +1536,11 @@ interpret(struct f_inst *what) { ACCESS_RTE; ACCESS_EATTRS; - v1.val.net = (*f_rte)->net->n.addr; + v1.val.net = (*fs->rte)->net->n.addr; /* We ignore temporary attributes, probably not a problem here */ /* 0x02 is a value of BA_AS_PATH, we don't want to include BGP headers */ - eattr *e = ea_find(*f_eattrs, EA_CODE(PROTOCOL_BGP, 0x02)); + eattr *e = ea_find(*fs->eattrs, EA_CODE(PROTOCOL_BGP, 0x02)); if (!e || ((e->type & EAF_TYPE_MASK) != EAF_TYPE_AS_PATH)) runtime("Missing AS_PATH attribute"); @@ -1563,7 +1568,7 @@ interpret(struct f_inst *what) ARG_ANY(1); res.type = T_STRING; - res.val.s = val_format_str(v1); + res.val.s = val_format_str(fs, v1); break; case FI_ASSERT: /* Birdtest Assert */ @@ -1765,38 +1770,38 @@ f_run(struct filter *filter, struct rte **rte, struct linpool *tmp_pool, int fla int rte_cow = ((*rte)->flags & REF_COW); DBG( "Running filter `%s'...", filter->name ); - f_rte = rte; - f_eattrs = NULL; - f_old_rta = NULL; - f_pool = tmp_pool; - f_flags = flags; + struct filter_state fs = { + .rte = rte, + .pool = tmp_pool, + .flags = flags, + }; - LOG_BUFFER_INIT(f_buf); + LOG_BUFFER_INIT(fs.buf); - struct f_val res = interpret(filter->root); + struct f_val res = interpret(&fs, filter->root); - if (f_old_rta) { + if (fs.old_rta) { /* - * Cached rta was modified and f_rte contains now an uncached one, + * Cached rta was modified and fs->rte contains now an uncached one, * sharing some part with the cached one. The cached rta should - * be freed (if rte was originally COW, f_old_rta is a clone + * be freed (if rte was originally COW, fs->old_rta is a clone * obtained during rte_cow()). * * This also implements the exception mentioned in f_run() * description. The reason for this is that rta reuses parts of - * f_old_rta, and these may be freed during rta_free(f_old_rta). + * fs->old_rta, and these may be freed during rta_free(fs->old_rta). * This is not the problem if rte was COW, because original rte * also holds the same rta. */ if (!rte_cow) - (*f_rte)->attrs = rta_lookup((*f_rte)->attrs); + (*fs.rte)->attrs = rta_lookup((*fs.rte)->attrs); - rta_free(f_old_rta); + rta_free(fs.old_rta); } if (res.type != T_RETURN) { - if (!(f_flags & FF_SILENT)) + if (!(fs.flags & FF_SILENT)) log_rl(&rl_runtime_err, L_ERR "Filter %s did not return accept nor reject. Make up your mind", filter->name); return F_ERROR; } @@ -1810,16 +1815,15 @@ struct f_val f_eval_rte(struct f_inst *expr, struct rte **rte, struct linpool *tmp_pool) { - f_rte = rte; - f_eattrs = NULL; - f_old_rta = NULL; - f_pool = tmp_pool; - f_flags = 0; + struct filter_state fs = { + .rte = rte, + .pool = tmp_pool, + }; - LOG_BUFFER_INIT(f_buf); + LOG_BUFFER_INIT(fs.buf); /* Note that in this function we assume that rte->attrs is private / uncached */ - struct f_val res = interpret(expr); + struct f_val res = interpret(&fs, expr); return res; } @@ -1827,14 +1831,13 @@ f_eval_rte(struct f_inst *expr, struct rte **rte, struct linpool *tmp_pool) struct f_val f_eval(struct f_inst *expr, struct linpool *tmp_pool) { - f_flags = 0; - f_eattrs = NULL; - f_rte = NULL; - f_pool = tmp_pool; + struct filter_state fs = { + .pool = tmp_pool, + }; - LOG_BUFFER_INIT(f_buf); + LOG_BUFFER_INIT(fs.buf); - return interpret(expr); + return interpret(&fs, expr); } uint |