* the source from user into a tree of &f_inst structures. These trees are
* later interpreted using code in |filter/filter.c|.
*
- * A filter is represented by a tree of &f_inst structures, one structure per
- * "instruction". Each &f_inst contains @code, @aux value which is
- * usually the data type this instruction operates on and two generic
- * arguments (@a[0], @a[1]). Some instructions contain pointer(s) to other
- * instructions in their (@a[0], @a[1]) fields.
+ * A filter is represented by a tree of &f_inst structures, later translated
+ * into lists called &f_line. All the instructions are defined and documented
+ * in |filter/f-inst.c| definition file.
*
* Filters use a &f_val structure for their data. Each &f_val
- * contains type and value (types are constants prefixed with %T_). Few
- * of the types are special; %T_RETURN can be or-ed with a type to indicate
- * that return from a function or from the whole filter should be
- * forced. Important thing about &f_val's is that they may be copied
- * with a simple |=|. That's fine for all currently defined types: strings
- * are read-only (and therefore okay), paths are copied for each
- * operation (okay too).
+ * contains type and value (types are constants prefixed with %T_).
+ * Look into |filter/data.h| for more information and appropriate calls.
*/
#undef LOCAL_DEBUG
#include "lib/socket.h"
#include "lib/string.h"
#include "lib/unaligned.h"
-#include "lib/net.h"
#include "lib/ip.h"
+#include "lib/net.h"
+#include "lib/flowspec.h"
#include "nest/route.h"
#include "nest/protocol.h"
#include "nest/iface.h"
int flags;
};
-#if HAVE_THREAD_LOCAL
_Thread_local static struct filter_state filter_state;
_Thread_local static struct filter_stack filter_stack;
-#define FS_INIT(...) filter_state = (struct filter_state) { .stack = &filter_stack, __VA_ARGS__ }
-#else
-#define FS_INIT(...) struct filter_state filter_state = { .stack = alloca(sizeof(struct filter_stack)), __VA_ARGS__ };
-#endif
void (*bt_assert_hook)(int result, const struct f_line_item *assert);
/* The same as with the value stack. Not resetting the stack for performance reasons. */
fstk->ecnt = 1;
- fstk->estk[0].line = line;
+ fstk->estk[0].line = line;
fstk->estk[0].pos = 0;
#define curline fstk->estk[fstk->ecnt-1]
-#if DEBUGGING
+#ifdef LOCAL_DEBUG
debug("Interpreting line.");
f_dump_line(line, 1);
#endif
switch (what->fi_code) {
#define res fstk->vstk[fstk->vcnt]
-#define v1 fstk->vstk[fstk->vcnt]
-#define v2 fstk->vstk[fstk->vcnt + 1]
-#define v3 fstk->vstk[fstk->vcnt + 2]
+#define vv(i) fstk->vstk[fstk->vcnt + (i)]
+#define v1 vv(0)
+#define v2 vv(1)
+#define v3 vv(2)
#define runtime(fmt, ...) do { \
if (!(fs->flags & FF_SILENT)) \
#define falloc(size) lp_alloc(fs->pool, size)
#define fpool fs->pool
-#define ACCESS_RTE do { if (!fs->rte) runtime("No route to access"); } while (0)
#define ACCESS_EATTRS do { if (!fs->eattrs) f_cache_eattrs(fs); } while (0)
#include "filter/inst-interpret.c"
#undef runtime
#undef falloc
#undef fpool
-#undef ACCESS_RTE
#undef ACCESS_EATTRS
}
}
-
+
/* End of current line. Drop local variables before exiting. */
- fstk->vcnt -= curline.line->vars;
- fstk->vcnt -= curline.line->args;
+ fstk->vcnt = curline.ventry + curline.line->results;
fstk->ecnt--;
}
DBG( "Running filter `%s'...", filter->name );
/* Initialize the filter state */
- FS_INIT(
- .rte = rte,
- .pool = tmp_pool,
- .flags = flags,
- );
+ filter_state = (struct filter_state) {
+ .stack = &filter_stack,
+ .rte = rte,
+ .pool = tmp_pool,
+ .flags = flags,
+ };
LOG_BUFFER_INIT(filter_state.buf);
}
/**
- * f_eval_rte – run a filter line for an uncached route
+ * f_eval_rte - run a filter line for an uncached route
* @expr: filter line to run
* @rte: route being filtered, may be modified
* @tmp_pool: all filter allocations go from this pool
enum filter_return
f_eval_rte(const struct f_line *expr, struct rte **rte, struct linpool *tmp_pool)
{
- FS_INIT(
- .rte = rte,
- .pool = tmp_pool,
- );
+ filter_state = (struct filter_state) {
+ .stack = &filter_stack,
+ .rte = rte,
+ .pool = tmp_pool,
+ };
LOG_BUFFER_INIT(filter_state.buf);
}
/*
- * f_eval – get a value of a term
+ * f_eval - get a value of a term
* @expr: filter line containing the term
* @tmp_pool: long data may get allocated from this pool
* @pres: here the output will be stored
enum filter_return
f_eval(const struct f_line *expr, struct linpool *tmp_pool, struct f_val *pres)
{
- FS_INIT(
- .pool = tmp_pool,
- );
+ filter_state = (struct filter_state) {
+ .stack = &filter_stack,
+ .pool = tmp_pool,
+ };
LOG_BUFFER_INIT(filter_state.buf);
}
/*
- * f_eval_int – get an integer value of a term
+ * f_eval_int - get an integer value of a term
* Called internally from the config parser, uses its internal memory pool
* for allocations. Do not call in other cases.
*/
f_eval_int(const struct f_line *expr)
{
/* Called independently in parse-time to eval expressions */
- FS_INIT(
- .pool = cfg_mem,
- );
+ filter_state = (struct filter_state) {
+ .stack = &filter_stack,
+ .pool = cfg_mem,
+ };
struct f_val val;
LOG_BUFFER_INIT(filter_state.buf);
if (interpret(&filter_state, expr, &val) > F_RETURN)
- cf_error("Runtime error while evaluating expression");
+ cf_error("Runtime error while evaluating expression; see log for details");
if (val.type != T_INT)
cf_error("Integer expression expected");
}
/*
- * f_eval_buf – get a value of a term and print it to the supplied buffer
+ * f_eval_buf - get a value of a term and print it to the supplied buffer
*/
enum filter_return
f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf)
{
struct f_val val;
enum filter_return fret = f_eval(expr, tmp_pool, &val);
- if (fret > F_RETURN)
+ if (fret <= F_RETURN)
val_format(&val, buf);
return fret;
}
projects / thirdparty / bird.git / blobdiff