mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2024-09-07 22:15:19 +00:00
362 lines
9.0 KiB
C
362 lines
9.0 KiB
C
/*
|
|
* Filters: utility functions
|
|
*
|
|
* Copyright 1998 Pavel Machek <pavel@ucw.cz>
|
|
* 2017 Jan Maria Matejka <mq@ucw.cz>
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
#include "nest/bird.h"
|
|
#include "conf/conf.h"
|
|
#include "filter/filter.h"
|
|
#include "filter/f-inst.h"
|
|
#include "lib/idm.h"
|
|
#include "nest/protocol.h"
|
|
#include "nest/route.h"
|
|
|
|
#define P(a,b) ((a<<8) | b)
|
|
|
|
const char *
|
|
filter_name(const struct filter *filter)
|
|
{
|
|
if (!filter)
|
|
return "ACCEPT";
|
|
else if (filter == FILTER_REJECT)
|
|
return "REJECT";
|
|
else if (!filter->sym)
|
|
return "(unnamed)";
|
|
else
|
|
return filter->sym->name;
|
|
}
|
|
|
|
struct filter *
|
|
f_new_where(struct f_inst *where)
|
|
{
|
|
struct f_inst *cond = f_new_inst(FI_CONDITION, where,
|
|
f_new_inst(FI_DIE, F_ACCEPT),
|
|
f_new_inst(FI_DIE, F_REJECT));
|
|
|
|
struct filter *f = cfg_allocz(sizeof(struct filter));
|
|
f->root = f_linearize(cond, 0);
|
|
return f;
|
|
}
|
|
|
|
static inline int
|
|
f_match_signature(const struct f_method *dsc, struct f_inst *args)
|
|
{
|
|
int i, arg_num = (int) dsc->arg_num;
|
|
|
|
for (i = 1; args && (i < arg_num); args = args->next, i++)
|
|
if (dsc->args_type[i] && (args->type != dsc->args_type[i]) &&
|
|
!f_try_const_promotion(args, dsc->args_type[i]))
|
|
return 0;
|
|
|
|
return !args && !(i < arg_num);
|
|
}
|
|
|
|
/* Variant of f_match_signature(), optimized for error reporting */
|
|
static inline void
|
|
f_match_signature_err(const struct f_method *dsc, struct f_inst *args, int *pos, int *want, int *got)
|
|
{
|
|
int i, arg_num = (int) dsc->arg_num;
|
|
|
|
for (i = 1; args && (i < arg_num); args = args->next, i++)
|
|
if (dsc->args_type[i] && (args->type != dsc->args_type[i]) &&
|
|
!f_try_const_promotion(args, dsc->args_type[i]))
|
|
break;
|
|
|
|
*pos = i;
|
|
*want = (i < arg_num) ? dsc->args_type[i] : T_NONE;
|
|
*got = args ? args->type : T_NONE;
|
|
}
|
|
|
|
struct f_inst *
|
|
f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args, int skip)
|
|
{
|
|
/* Find match */
|
|
for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
|
|
if (f_match_signature(dsc, args))
|
|
return dsc->new_inst(obj, args);
|
|
|
|
|
|
/* No valid match - format error message */
|
|
|
|
int best_pos = -1; /* Longest argument position with partial match */
|
|
int best_got = 0; /* Received type at best partial match position */
|
|
int best_count = 0; /* Number of partial matches at best position */
|
|
const int best_max = 8; /* Max number of reported types */
|
|
int best_want[best_max]; /* Expected types at best position */
|
|
|
|
for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
|
|
{
|
|
int pos, want, got;
|
|
f_match_signature_err(dsc, args, &pos, &want, &got);
|
|
|
|
/* Ignore shorter match */
|
|
if (pos < best_pos)
|
|
continue;
|
|
|
|
/* Found longer match, reset existing results */
|
|
if (pos > best_pos)
|
|
{
|
|
best_pos = pos;
|
|
best_got = got;
|
|
best_count = 0;
|
|
}
|
|
|
|
/* Skip duplicates */
|
|
for (int i = 0; i < best_count; i++)
|
|
if (best_want[i] == want)
|
|
goto next;
|
|
|
|
/* Skip if we have enough types */
|
|
if (best_count >= best_max)
|
|
continue;
|
|
|
|
/* Add new expected type */
|
|
best_want[best_count] = want;
|
|
best_count++;
|
|
next:;
|
|
}
|
|
|
|
/* There is at least one method */
|
|
ASSERT(best_pos >= 0 && best_count > 0);
|
|
|
|
/* Update best_pos for printing */
|
|
best_pos = best_pos - skip + 1;
|
|
|
|
if (!best_got)
|
|
cf_error("Cannot infer type of argument %d of '%s', please assign it to a variable", best_pos, sym->name);
|
|
|
|
/* Format list of expected types */
|
|
buffer tbuf;
|
|
STACK_BUFFER_INIT(tbuf, 128);
|
|
for (int i = 0; i < best_count; i++)
|
|
buffer_print(&tbuf, " / %s", best_want[i] ? f_type_name(best_want[i]) : "any");
|
|
char *types = tbuf.start + 3;
|
|
char *dots = (best_count >= best_max) || (tbuf.pos == tbuf.end) ? " / ..." : "";
|
|
|
|
cf_error("Argument %d of '%s' expected %s%s, got %s",
|
|
best_pos, sym->name, types, dots, f_type_name(best_got));
|
|
}
|
|
|
|
struct f_inst *
|
|
f_dispatch_method_x(const char *name, enum f_type t, struct f_inst *obj, struct f_inst *args)
|
|
{
|
|
struct sym_scope *scope = f_type_method_scope(t);
|
|
struct symbol *sym = cf_find_symbol_scope(scope, name);
|
|
|
|
if (!sym)
|
|
cf_error("Cannot dispatch method '%s'", name);
|
|
|
|
return f_dispatch_method(sym, obj, args, 0);
|
|
}
|
|
|
|
|
|
struct f_inst *
|
|
f_for_cycle(struct symbol *var, struct f_inst *term, struct f_inst *block)
|
|
{
|
|
ASSERT((var->class & ~0xff) == SYM_VARIABLE);
|
|
ASSERT(term->next == NULL);
|
|
|
|
/* Static type check */
|
|
if (term->type == T_VOID)
|
|
cf_error("Cannot infer type of FOR expression, please assign it to a variable");
|
|
|
|
enum f_type el_type = f_type_element_type(term->type);
|
|
struct sym_scope *scope = el_type ? f_type_method_scope(term->type) : NULL;
|
|
struct symbol *ms = scope ? cf_find_symbol_scope(scope, "!for_next") : NULL;
|
|
|
|
if (!ms)
|
|
cf_error("Type %s is not iterable, can't be used in FOR", f_type_name(term->type));
|
|
|
|
if (var->class != (SYM_VARIABLE | el_type))
|
|
cf_error("Loop variable '%s' in FOR must be of type %s, got %s",
|
|
var->name, f_type_name(el_type), f_type_name(var->class & 0xff));
|
|
|
|
/* Push the iterator auxiliary value onto stack */
|
|
struct f_inst *iter = term->next = f_new_inst(FI_CONSTANT, (struct f_val) {});
|
|
|
|
/* Initialize the iterator variable */
|
|
iter->next = f_new_inst(FI_CONSTANT, (struct f_val) { .type = el_type });
|
|
|
|
/* Prepend the loop block with loop beginning instruction */
|
|
struct f_inst *loop_start = f_new_inst(FI_FOR_LOOP_START, var);
|
|
loop_start->next = block;
|
|
|
|
return ms->method->new_inst(term, loop_start);
|
|
}
|
|
|
|
struct f_inst *
|
|
f_print(struct f_inst *vars, int flush, enum filter_return fret)
|
|
{
|
|
#define AX(...) do { struct f_inst *_tmp = f_new_inst(__VA_ARGS__); _tmp->next = output; output = _tmp; } while (0)
|
|
struct f_inst *output = NULL;
|
|
if (fret != F_NOP)
|
|
AX(FI_DIE, fret);
|
|
|
|
if (flush)
|
|
AX(FI_FLUSH);
|
|
|
|
while (vars)
|
|
{
|
|
struct f_inst *tmp = vars;
|
|
vars = vars->next;
|
|
tmp->next = NULL;
|
|
|
|
AX(FI_PRINT, tmp);
|
|
}
|
|
|
|
return output;
|
|
#undef AX
|
|
}
|
|
|
|
|
|
#define CA_KEY(n) n->name, n->fda.type
|
|
#define CA_NEXT(n) n->next
|
|
#define CA_EQ(na,ta,nb,tb) (!strcmp(na,nb) && (ta == tb))
|
|
#define CA_FN(n,t) (mem_hash(n, strlen(n)) ^ (t*0xaae99453U))
|
|
#define CA_ORDER 8 /* Fixed */
|
|
|
|
struct ca_storage {
|
|
struct ca_storage *next;
|
|
struct f_dynamic_attr fda;
|
|
u32 uc;
|
|
char name[0];
|
|
};
|
|
|
|
HASH(struct ca_storage) ca_hash;
|
|
|
|
static struct idm ca_idm;
|
|
static struct ca_storage **ca_storage;
|
|
static uint ca_storage_max;
|
|
|
|
static void
|
|
ca_free(resource *r)
|
|
{
|
|
struct custom_attribute *ca = (void *) r;
|
|
struct ca_storage *cas = HASH_FIND(ca_hash, CA, ca->name, ca->fda->type);
|
|
ASSERT(cas);
|
|
|
|
ca->name = NULL;
|
|
ca->fda = NULL;
|
|
if (!--cas->uc) {
|
|
uint id = EA_CUSTOM_ID(cas->fda.ea_code);
|
|
idm_free(&ca_idm, id);
|
|
HASH_REMOVE(ca_hash, CA, cas);
|
|
ca_storage[id] = NULL;
|
|
mb_free(cas);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ca_dump(resource *r)
|
|
{
|
|
struct custom_attribute *ca = (void *) r;
|
|
debug("name \"%s\" id 0x%04x ea_type 0x%02x f_type 0x%02x\n",
|
|
ca->name, ca->fda->ea_code, ca->fda->type, ca->fda->f_type);
|
|
}
|
|
|
|
static struct resclass ca_class = {
|
|
.name = "Custom attribute",
|
|
.size = sizeof(struct custom_attribute),
|
|
.free = ca_free,
|
|
.dump = ca_dump,
|
|
.lookup = NULL,
|
|
.memsize = NULL,
|
|
};
|
|
|
|
struct custom_attribute *
|
|
ca_lookup(pool *p, const char *name, int f_type)
|
|
{
|
|
int ea_type;
|
|
|
|
switch (f_type) {
|
|
case T_INT:
|
|
ea_type = EAF_TYPE_INT;
|
|
break;
|
|
case T_IP:
|
|
ea_type = EAF_TYPE_IP_ADDRESS;
|
|
break;
|
|
case T_QUAD:
|
|
ea_type = EAF_TYPE_ROUTER_ID;
|
|
break;
|
|
case T_PATH:
|
|
ea_type = EAF_TYPE_AS_PATH;
|
|
break;
|
|
case T_CLIST:
|
|
ea_type = EAF_TYPE_INT_SET;
|
|
break;
|
|
case T_ECLIST:
|
|
ea_type = EAF_TYPE_EC_SET;
|
|
break;
|
|
case T_LCLIST:
|
|
ea_type = EAF_TYPE_LC_SET;
|
|
break;
|
|
case T_STRING:
|
|
ea_type = EAF_TYPE_STRING;
|
|
break;
|
|
case T_BYTESTRING:
|
|
ea_type = EAF_TYPE_OPAQUE;
|
|
break;
|
|
default:
|
|
cf_error("Custom route attribute of unsupported type");
|
|
}
|
|
|
|
static int inited = 0;
|
|
if (!inited) {
|
|
idm_init(&ca_idm, config_pool, 8);
|
|
HASH_INIT(ca_hash, config_pool, CA_ORDER);
|
|
|
|
ca_storage_max = 256;
|
|
ca_storage = mb_allocz(config_pool, sizeof(struct ca_storage *) * ca_storage_max);
|
|
|
|
inited++;
|
|
}
|
|
|
|
struct ca_storage *cas = HASH_FIND(ca_hash, CA, name, ea_type);
|
|
if (cas) {
|
|
cas->uc++;
|
|
} else {
|
|
|
|
uint id = idm_alloc(&ca_idm);
|
|
|
|
if (id >= EA_CUSTOM_BIT)
|
|
cf_error("Too many custom attributes.");
|
|
|
|
if (id >= ca_storage_max) {
|
|
ca_storage_max *= 2;
|
|
ca_storage = mb_realloc(ca_storage, sizeof(struct ca_storage *) * ca_storage_max * 2);
|
|
}
|
|
|
|
cas = mb_allocz(config_pool, sizeof(struct ca_storage) + strlen(name) + 1);
|
|
cas->fda = f_new_dynamic_attr(ea_type, f_type, EA_CUSTOM(id));
|
|
cas->uc = 1;
|
|
|
|
strcpy(cas->name, name);
|
|
ca_storage[id] = cas;
|
|
|
|
HASH_INSERT(ca_hash, CA, cas);
|
|
}
|
|
|
|
struct custom_attribute *ca = ralloc(p, &ca_class);
|
|
ca->fda = &(cas->fda);
|
|
ca->name = cas->name;
|
|
return ca;
|
|
}
|
|
|
|
const char *
|
|
ea_custom_name(uint ea)
|
|
{
|
|
uint id = EA_CUSTOM_ID(ea);
|
|
if (id >= ca_storage_max)
|
|
return NULL;
|
|
|
|
if (!ca_storage[id])
|
|
return NULL;
|
|
|
|
return ca_storage[id]->name;
|
|
}
|
|
|