Commit 5a14df39 authored by Maria Jan Matejka's avatar Maria Jan Matejka Committed by Jan Maria Matejka
Browse files

Filter: Instruction codes named as enum 

The two-letter instructions were quite messy but they could be easily
read from memory dumps. Now GDB (since 2012) supports pretty printing
enum values and GCC checks the switch construction for missing enum
values so we are converting the nice two-byte values to enums.

Anyway, the enum still keeps the old two-byte values to be able to read
the instruction codes even without GDB from plain memory dump.
parent 2d6d4b80

conf/confbase.Y

+2 −0
Original line number Diff line number Diff line
@@ -43,6 +43,8 @@ CF_DECLS 
  char *t;

  struct rtable_config *r;

  struct f_inst *x;

  struct f_dynamic_attr fda;

  struct f_static_attr fsa;

  struct filter *f;

  struct f_tree *e;

  struct f_trie *trie;

filter/config.Y

+103 −131

File changed.

Preview size limit exceeded, changes collapsed.

filter/f-util.c

+25 −19
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
 *	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.

 */
@@ -13,43 +14,48 @@ 
#define P(a,b) ((a<<8) | b)



struct f_inst *

f_new_inst(void)

f_new_inst(enum f_instruction_code fi_code)

{

  struct f_inst * ret;

  ret = cfg_alloc(sizeof(struct f_inst));

  ret->code = ret->aux = 0;

  ret->arg1 = ret->arg2 = ret->next = NULL;

  ret = cfg_allocz(sizeof(struct f_inst));

  ret->fi_code = fi_code;

  ret->lineno = ifs->lino;

  return ret;

}



struct f_inst *

f_new_dynamic_attr(int type, int f_type UNUSED, int code)

f_new_inst_da(enum f_instruction_code fi_code, struct f_dynamic_attr da)

{

  /* FIXME: Remove the f_type parameter? */

  struct f_inst *f = f_new_inst();

  f->aux = type;

  f->a2.i = code;

  return f;

  struct f_inst *ret = f_new_inst(fi_code);

  ret->aux = da.type;

  ret->a2.i = da.ea_code;

  return ret;

}



struct f_inst *

f_new_inst_sa(enum f_instruction_code fi_code, struct f_static_attr sa)

{

  struct f_inst *ret = f_new_inst(fi_code);

  ret->aux = sa.f_type;

  ret->a2.i = sa.sa_code;

  ret->a1.i = sa.readonly;

  return ret;

}



/*

 * Generate set_dynamic( operation( get_dynamic(), argument ) )

 */

struct f_inst *

f_generate_complex(int operation, int operation_aux, struct f_inst *dyn, struct f_inst *argument)

f_generate_complex(int operation, int operation_aux, struct f_dynamic_attr da, struct f_inst *argument)

{

  struct f_inst *set_dyn = f_new_inst(),

                *oper = f_new_inst(),

                *get_dyn = dyn;

  struct f_inst *set_dyn = f_new_inst_da(FI_EA_SET, da),

                *oper = f_new_inst(operation),

                *get_dyn = f_new_inst_da(FI_EA_GET, da);



  *set_dyn = *get_dyn;

  get_dyn->code = P('e','a');

  oper->code = operation;

  oper->aux = operation_aux;

  oper->a1.p = get_dyn;

  oper->a2.p = argument;

  set_dyn->code = P('e','S');



  set_dyn->a1.p = oper;

  return set_dyn;

}
@@ -59,7 +65,7 @@ struct f_inst * 
f_generate_roa_check(struct symbol *sym, struct f_inst *prefix, struct f_inst *asn)

{

  struct f_inst_roa_check *ret = cfg_allocz(sizeof(struct f_inst_roa_check));

  ret->i.code = P('R','C');

  ret->i.fi_code = FI_ROA_CHECK;

  ret->i.lineno = ifs->lino;

  ret->i.arg1 = prefix;

  ret->i.arg2 = asn;

filter/filter.c

+99 −101

File changed.

Preview size limit exceeded, changes collapsed.

filter/filter.h

+79 −4
Original line number Diff line number Diff line
@@ -14,9 +14,67 @@ 
#include "nest/route.h"

#include "nest/attrs.h"



/* Filter instruction types */



#define FI__TWOCHAR(a,b)	((a<<8) | b)

#define FI__LIST \

  F(FI_COMMA,			  0, ',') \

  F(FI_ADD,			  0, '+') \

  F(FI_SUBTRACT,		  0, '-') \

  F(FI_MULTIPLY,		  0, '*') \

  F(FI_DIVIDE,			  0, '/') \

  F(FI_AND,			  0, '&') \

  F(FI_OR,			  0, '|') \

  F(FI_PAIR_CONSTRUCT,		'm', 'p') \

  F(FI_EC_CONSTRUCT,		'm', 'c') \

  F(FI_LC_CONSTRUCT,		'm', 'l') \

  F(FI_NEQ,			'!', '=') \

  F(FI_EQ,			'=', '=') \

  F(FI_LT,			  0, '<') \

  F(FI_LTE,			'<', '=') \

  F(FI_NOT,			  0, '!') \

  F(FI_MATCH,			  0, '~') \

  F(FI_NOT_MATCH,		'!', '~') \

  F(FI_DEFINED,			'd', 'e') \

  F(FI_SET,			  0, 's') \

  F(FI_CONSTANT,		  0, 'c') \

  F(FI_VARIABLE,		  0, 'V') \

  F(FI_CONSTANT_INDIRECT,	  0, 'C') \

  F(FI_PRINT,			  0, 'p') \

  F(FI_CONDITION,		  0, '?') \

  F(FI_NOP,			  0, '0') \

  F(FI_PRINT_AND_DIE,		'p', ',') \

  F(FI_RTA_GET,			  0, 'a') \

  F(FI_RTA_SET,			'a', 'S') \

  F(FI_EA_GET,			'e', 'a') \

  F(FI_EA_SET,			'e', 'S') \

  F(FI_PREF_GET,		  0, 'P') \

  F(FI_PREF_SET,		'P', 'S') \

  F(FI_LENGTH,			  0, 'L') \

  F(FI_IP,			'c', 'p') \

  F(FI_AS_PATH_FIRST,		'a', 'f') \

  F(FI_AS_PATH_LAST,		'a', 'l') \

  F(FI_AS_PATH_LAST_NAG,	'a', 'L') \

  F(FI_RETURN,			  0, 'r') \

  F(FI_CALL,			'c', 'a') \

  F(FI_CLEAR_LOCAL_VARS,	'c', 'V') \

  F(FI_SWITCH,			'S', 'W') \

  F(FI_IP_MASK,			'i', 'M') \

  F(FI_EMPTY,			  0, 'E') \

  F(FI_PATH_PREPEND,		'A', 'p') \

  F(FI_CLIST_ADD_DEL,		'C', 'a') \

  F(FI_ROA_CHECK,		'R', 'C')



enum f_instruction_code {

#define F(c,a,b) \

  c = FI__TWOCHAR(a,b),

FI__LIST

#undef F

} PACKED;



struct f_inst {		/* Instruction */

  struct f_inst *next;	/* Structure is 16 bytes, anyway */

  u16 code;

  enum f_instruction_code fi_code;

  u16 aux;

  union {

    int i;
@@ -75,15 +133,32 @@ struct f_val { 
  } val;

};



struct f_dynamic_attr {

  int type;

  int f_type;

  int ea_code;

};



struct f_static_attr {

  int f_type;

  int sa_code;

  int readonly;

};



struct filter {

  char *name;

  struct f_inst *root;

};



struct f_inst *f_new_inst(void);

struct f_inst *f_new_dynamic_attr(int type, int f_type, int code);	/* Type as core knows it, type as filters know it, and code of dynamic attribute */

struct f_inst *f_new_inst(enum f_instruction_code fi_code);

struct f_inst *f_new_inst_da(enum f_instruction_code fi_code, struct f_dynamic_attr da);

struct f_inst *f_new_inst_sa(enum f_instruction_code fi_code, struct f_static_attr sa);

static inline struct f_dynamic_attr f_new_dynamic_attr(int type, int f_type, int code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */

{ return (struct f_dynamic_attr) { .type = type, .f_type = f_type, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */

static inline struct f_static_attr f_new_static_attr(int f_type, int code, int readonly)

{ return (struct f_static_attr) { .f_type = f_type, .sa_code = code, .readonly = readonly }; }

struct f_tree *f_new_tree(void);

struct f_inst *f_generate_complex(int operation, int operation_aux, struct f_inst *dyn, struct f_inst *argument);

struct f_inst *f_generate_complex(int operation, int operation_aux, struct f_dynamic_attr da, struct f_inst *argument);

struct f_inst *f_generate_roa_check(struct symbol *sym, struct f_inst *prefix, struct f_inst *asn);

CRA Git | Maintained and supported by SUSTech CRA and CCSE