BIRD has variety of types, used to represent most common attributes in protocols. But sometimes wery complex attributes might be found. An good example of such attribute is BGP_AGGREGATOR which consists from an INT, and QUAD types (ASN,ROUTER_ID). Rather than making *special* type for aggregator, introduce general infrastructure for structured types and implement aggregator as STRUCT ASID with its literal format written as { ASN, ROUTER_ID }. Variables of STRUCT ASID also supported. Introduce additional operator for dereference structure members: ->, So for example bgp_aggregator->'ai.as' gies an ASN number from structure. Assignment to structure members also supported on both extended attributes and variables. --- conf/cf-lex.l | 30 +++++++++++ conf/conf.h | 2 + conf/confbase.Y | 4 +- doc/bird.sgml | 61 ++++++++++++++++++++-- filter/config.Y | 96 ++++++++++++++++++++++++++++++++++ filter/f-util.c | 91 ++++++++++++++++++++++++++++++-- filter/filter.c | 146 ++++++++++++++++++++++++++++++++++++++++++++++++++++ filter/filter.h | 31 +++++++++-- nest/route.h | 1 + proto/bgp/attrs.c | 14 +++-- proto/bgp/config.Y | 2 +- 11 files changed, 457 insertions(+), 21 deletions(-) diff --git a/conf/cf-lex.l b/conf/cf-lex.l index b1bbeae..5996f30 100644 --- a/conf/cf-lex.l +++ b/conf/cf-lex.l @@ -252,6 +252,7 @@ else: { \[\= return PO; \=\] return PC; +\-\> return REF; %% static int @@ -512,6 +513,33 @@ cf_define_symbol(struct symbol *sym, int type, void *def) return sym; } +/** + * cf_define_symbol_if_undef - redefine symbol with new meaning + * @sym: symbol to be defined + * @type: symbol class to assign + * @def: class dependent data + * + * Takes symbol and re-defines it to the new type if it's type was + * undefined previously (%SYM_VOID) or returns symbol unmodified + * if it's type same as specified with @type parameter, overwise + * an error is reported via cf_error(). + */ +struct symbol * +cf_define_symbol_if_undef(struct symbol *sym, int type, void *def) +{ + if (sym->class) + { + if (sym->class != type) + cf_error("Symbol already defined"); + } + else + { + sym->class = type; + sym->def = def; + } + return sym; +} + static void cf_lex_init_kh(void) { @@ -642,6 +670,8 @@ cf_symbol_class_name(struct symbol *sym) return "routing table"; case SYM_ROA: return "ROA table"; + case SYM_REF: + return "reference to struct member"; default: return "unknown type"; } diff --git a/conf/conf.h b/conf/conf.h index 2862429..5aaa1f3 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -115,6 +115,7 @@ struct symbol { #define SYM_FILTER 4 #define SYM_TABLE 5 #define SYM_ROA 6 +#define SYM_REF 255 #define SYM_VARIABLE 0x100 /* 0x100-0x1ff are variable types */ #define SYM_CONSTANT 0x200 /* 0x200-0x2ff are variable types */ @@ -141,6 +142,7 @@ void cf_lex_init(int is_cli, struct config *c); struct symbol *cf_find_symbol(byte *c); struct symbol *cf_default_name(char *template, int *counter); struct symbol *cf_define_symbol(struct symbol *symbol, int type, void *def); +struct symbol *cf_define_symbol_if_undef(struct symbol *sym, int type, void *def); void cf_push_scope(struct symbol *); void cf_pop_scope(void); struct symbol *cf_walk_symbols(struct config *cf, struct symbol *sym, int *pos); diff --git a/conf/confbase.Y b/conf/confbase.Y index c6678e7..f5f701f 100644 --- a/conf/confbase.Y +++ b/conf/confbase.Y @@ -62,7 +62,7 @@ CF_DECLS struct timeformat *tf; } -%token END CLI_MARKER INVALID_TOKEN ELSECOL DDOT +%token END CLI_MARKER INVALID_TOKEN ELSECOL DDOT REF %token GEQ LEQ NEQ AND OR %token PO PC %token <i> NUM ENUM @@ -84,7 +84,7 @@ CF_DECLS %left '+' '-' %left '*' '/' '%' %left '!' -%nonassoc '.' +%nonassoc '.' REF CF_KEYWORDS(DEFINE, ON, OFF, YES, NO) diff --git a/doc/bird.sgml b/doc/bird.sgml index e4839a6..5791c0b 100644 --- a/doc/bird.sgml +++ b/doc/bird.sgml @@ -1049,6 +1049,60 @@ function is_bird_ipv6() variables of such type, but some route attributes are of enumeration type. Enumeration types are incompatible with each other. + <tag/asid struct/ + Structured types are supported in filters. Structure aggregates fixed set of + objects with possibly different types in given order. Each object within structure + has it's own label by which object can be referenced. Literals of structured type look + like <cf/{ 1, 192.168.1.1, ... }/ and order of objects in literals is important. + You can not define your own structures, but any literal of predefined structure + could be used in configuration. Standard operations like assignment to variable + of structured type, printing, comparison also supported. + + There is special operator on structured type <cf/->/ which could be used for + referencing labeled object in structured type. This allows retrieving/assignment + of particular object in structured type. + + BIRD defines following structured types: + + <cf/asid/ represents AS number of integer type, followed by a router ID of quad + type. There are two corresponding labels to reference each object within structure: + <cf/ai.as/ refering to AS number object and <cf/ai.as/ refering to router ID object. + This type is used to represent <cf/bgp_aggregator/ attribute. + + There examples on how to work with structured types in filters: +<code> +define C_IP = 10.20.20.20; +define C_BGP_AGGREGATOR = { 10, C_IP }; + +function make_aggregator(int asn; quad router_id) +asid struct ai; +{ + ai = { asn, router_id }; + return ai; +} + +function print_aggregator(asid struct ai) +{ + print "aggregator: ", ai; + print "ai.as: ", ai->'ai.as', ", ai.id: ", ai->'ai.id'; + print "--"; +} + +function test_aggregator() +{ + print { 10, 10.10.10.10 }->'ai.as', ", ", { 10, 10.10.10.10 }->'ai.id'; + print_aggregator({ 10, 10.10.10.10 }); + print_aggregator(C_BGP_AGGREGATOR); + + bgp_aggregator = { 10, 10.30.30.30 }; + print_aggregator(bgp_aggregator); + + bgp_aggregator->'ai.as' = 1; + bgp_aggregator->'ai.id' = 1.1.1.1; + print_aggregator(bgp_aggregator); +} +</code> + <tag/bgppath/ BGP path is a list of autonomous system numbers. You can't write literals of this type. There are several special operators on bgppaths: @@ -1705,9 +1759,10 @@ with `<tt/O/') are optional. has been aggregated from multiple routes by some router on the path from the originator. -<!-- we don't handle aggregators right since they are of a very obscure type - <tag>bgp_aggregator</tag> ---> + <tag>asid struct bgp_aggregator</tag> This is an optional attribute which carries + ASN and router ID that formed aggregated route. See <cf/asid struct/ type + description for more information on type of this attribute. + <tag>clist <cf/bgp_community/ [O]</tag> List of community values associated with the route. Each such value is a pair (represented as a <cf/pair/ data type inside the filters) of 16-bit integers, the first of them containing the number of the AS which defines diff --git a/filter/config.Y b/filter/config.Y index a7a69a4..77b2446 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -250,6 +250,48 @@ f_generate_ec(u16 kind, struct f_inst *tk, struct f_inst *tv) return rv; } +static inline struct f_inst * +f_generate_ref(struct f_inst *t, struct symbol *s) +{ + struct f_inst *rv; + + s = cf_define_symbol_if_undef(s, SYM_REF, NULL); + + if (t->code == 'C') { + struct f_val res, *v = t->a1.p; + + res.type = T_VOID; + switch (v->type) { + case T_STRUCT_ASID: + if (!strcmp(s->name, "ai.as")) { + res.type = T_INT; + res.val.i = v->val.ai.as; + } else if (!strcmp(s->name, "ai.id")) { + res.type = T_QUAD; + res.val.i = v->val.ai.id; + } + break; + default: + cf_error("Expected structured type: %x", v->type); + } + + if (res.type == T_VOID) + cf_error("Unknown member in structure: %s", s->name); + + NEW_F_VAL; + rv = f_new_inst(); + rv->code = 'C'; + rv->a1.p = val; + memcpy(val, &res, sizeof(*val)); + } else { + rv = f_new_inst(); + rv->code = P('s','s'); + rv->a1.p = s; + rv->a2.p = t; + } + + return rv; +} CF_DECLS @@ -259,6 +301,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN, INT, BOOL, IP, PREFIX, PAIR, QUAD, EC, SET, STRING, BGPMASK, BGPPATH, CLIST, ECLIST, IF, THEN, ELSE, CASE, TRY, CATCH, + STRUCT, ASID, TRUE, FALSE, RT, RO, UNKNOWN, GENERIC, FROM, GW, NET, MASK, PROTO, SOURCE, SCOPE, CAST, DEST, IFNAME, IFINDEX, PREFERENCE, @@ -313,6 +356,7 @@ type: | BGPPATH { $$ = T_PATH; } | CLIST { $$ = T_CLIST; } | ECLIST { $$ = T_ECLIST; } + | ASID STRUCT { $$ = T_STRUCT_ASID; } | type SET { switch ($1) { case T_INT: @@ -628,6 +672,7 @@ constant: constructor: '(' term ',' term ')' { $$ = f_generate_dpair($2, $4); } | '(' ec_kind ',' term ',' term ')' { $$ = f_generate_ec($2, $4, $6); } + | '{' term ',' term '}' { $$ = f_generate_struct(T_STRUCT_ASID, $2, $4); } ; @@ -719,6 +764,8 @@ term: | rtadot dynamic_attr { $$ = $2; $$->code = P('e','a'); } + | term REF SYM { $$ = f_generate_ref($1, $3); } + | term '.' IP { $$ = f_new_inst(); $$->code = P('c','p'); $$->a1.p = $1; $$->aux = T_IP; } | term '.' LEN { $$ = f_new_inst(); $$->code = 'L'; $$->a1.p = $1; } | term '.' MASK '(' term ')' { $$ = f_new_inst(); $$->code = P('i','M'); $$->a1.p = $1; $$->a2.p = $5; } @@ -877,6 +924,55 @@ cmd: $$->a1.p = $2; $$->a2.p = build_tree( $4 ); } + | rtadot dynamic_attr REF SYM '=' term ';' { + struct f_inst_data *get_dyn; + struct f_inst *set_ref; + char **c; + + $4 = cf_define_symbol_if_undef($4, SYM_REF, NULL); + + get_dyn = f_new_inst2(sizeof(char *)); + get_dyn->i = *($2); + get_dyn->i.code = P('e','a'); + c = (char **) get_dyn->data; + *c = $4->name; + + set_ref = f_new_inst(); + set_ref->code = P('s','S'); + set_ref->a1.p = get_dyn; + set_ref->a2.p = $6; + + $$ = $2; + $$->code = P('e','S'); + $$->a1.p = set_ref; + } + | SYM REF SYM '=' term ';' { + struct f_inst_data *get_sym; + struct f_inst *set_ref; + char **c; + + if (($1->class & ~T_MASK) != SYM_VARIABLE) + cf_error( "You may set only variables." ); + + $3 = cf_define_symbol_if_undef($3, SYM_REF, NULL); + + get_sym = f_new_inst2(sizeof(char *)); + get_sym->i.code = 'V'; + get_sym->i.a1.p = $1->def; + get_sym->i.a2.p = $1->name; + c = (char **) get_sym->data; + *c = $3->name; + + set_ref = f_new_inst(); + set_ref->code = P('s','S'); + set_ref->a1.p = get_sym; + set_ref->a2.p = $5; + + $$ = f_new_inst(); + $$->code = 's'; + $$->a1.p = $1; + $$->a2.p = set_ref; + } | rtadot dynamic_attr '.' EMPTY ';' { $$ = f_generate_empty($2); } diff --git a/filter/f-util.c b/filter/f-util.c index ad91002..a02d058 100644 --- a/filter/f-util.c +++ b/filter/f-util.c @@ -15,14 +15,21 @@ struct f_inst * f_new_inst(void) { - struct f_inst * ret; - ret = cfg_alloc(sizeof(struct f_inst)); - ret->code = ret->aux = 0; - ret->arg1 = ret->arg2 = ret->next = NULL; + struct f_inst *ret; + ret = cfg_allocz(sizeof(struct f_inst)); ret->lineno = ifs->lino; return ret; } +struct f_inst_data * +f_new_inst2(unsigned int size) +{ + struct f_inst_data *ret; + ret = cfg_allocz(sizeof(struct f_inst_data) + size); + ret->i.lineno = ifs->lino; + return ret; +} + struct f_inst * f_new_dynamic_attr(int type, int f_type, int code) { @@ -71,6 +78,82 @@ f_generate_roa_check(struct symbol *sym, struct f_inst *prefix, struct f_inst *a return &ret->i; } +struct f_inst * +f_generate_struct(int type, ...) +{ + struct f_inst *rv; + va_list args; + + va_start(args, type); + + switch (type) { + case T_STRUCT_ASID: + { + struct f_inst *t1 = va_arg(args, struct f_inst *); + struct f_inst *t2 = va_arg(args, struct f_inst *); + int c1 = 0, c2 = 0; + struct f_asid ai = { 0, 0 }; + + if (t1->code == 'c') { + if (t1->aux != T_INT) + cf_error("Can't operate with non-integer value of AS part in AS,ID constructor"); + + ai.as = t1->a2.i; + c1 = 1; + } + + if (t2->code == 'c') { + if (t2->aux != T_QUAD) + cf_error("Can't operate with non-quad value of ID part in AS,ID constructor"); + + ai.id = t2->a2.i; + c2 = 1; + } + +#ifndef IPV6 + /* IP->Quad implicit conversion */ + else if (t2->code == 'C') { + struct f_val *val = t2->a1.p; + + if (val->type == T_QUAD) + ai.id = val->val.i; + else if (val->type == T_IP) + ai.id = ipa_to_u32(val->val.px.ip); + else + cf_error("Can't operate with non-quad value of ID part in AS,ID constructor"); + + c2 = 1; + } +#endif + + if (c1 && c2) { + NEW_F_VAL; + rv = f_new_inst(); + rv->code = 'C'; + rv->a1.p = val; + val->type = T_STRUCT_ASID; + val->val.ai = ai; + } else { + rv = f_new_inst(); + rv->code = P('m','a'); + rv->a1.p = t1; + rv->a2.p = t2; + } + } + break; + + default: + rv = NULL; + } + + va_end(args); + + if (!rv) + cf_error("Unknown structure type: %x", type); + + return rv; +} + char * filter_name(struct filter *filter) { diff --git a/filter/filter.c b/filter/filter.c index 9b99f28..4b41d4f 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -50,6 +50,19 @@ #define CMP_ERROR 999 +/* [S]tructured types [E]rror codes and their text representation */ +#define SE_OK 0 +#define SE_NOT_STRUCT 1 +#define SE_IN_TYPE 2 +#define SE_NO_MEMBER 3 + +static char *se_desc[] = { + [SE_OK] = "", + [SE_NOT_STRUCT] = "Requested type is not structure", + [SE_IN_TYPE] = "Attempt to set member to incompatible type", + [SE_NO_MEMBER] = "Unknown member in structure", +}; + static struct adata * adata_empty(struct linpool *pool, int l) { @@ -188,6 +201,9 @@ val_compare(struct f_val v1, struct f_val v2) return uint_cmp(v1.val.i, v2.val.i); case T_EC: return u64_cmp(v1.val.ec, v2.val.ec); + case T_STRUCT_ASID: + return u64_cmp((((u64) v1.val.ai.as) << 32) | v1.val.ai.id, + (((u64) v2.val.ai.as) << 32) | v2.val.ai.id); case T_IP: return ipa_compare(v1.val.px.ip, v2.val.px.ip); case T_PREFIX: @@ -490,6 +506,7 @@ val_print(struct f_val v) case T_PAIR: logn("(%d,%d)", v.val.i >> 16, v.val.i & 0xffff); return; case T_QUAD: logn("%R", v.val.i); return; case T_EC: ec_format(buf2, v.val.ec); logn("%s", buf2); return; + case T_STRUCT_ASID: logn("{ %u, %R }", v.val.ai.as, v.val.ai.id); return; case T_PREFIX_SET: trie_print(v.val.ti); return; case T_SET: tree_print(v.val.t); return; case T_ENUM: logn("(enum %x)%d", v.type, v.val.i); return; @@ -710,6 +727,102 @@ interpret(struct f_inst *what) break; } + case P('m','a'): + { + TWOARGS; + + struct f_asid ai; + + if (v1.type != T_INT) + runtime("Can't operate with non-integer value of AS part in AS,ID constructor"); + ai.as = v1.val.i; + + if (v2.type == T_QUAD) + ai.id = v2.val.i; +#ifndef IPV6 + /* IP->Quad implicit conversion */ + else if (v2.type == T_IP) + ai.id = ipa_to_u32(v2.val.px.ip); +#endif + else + runtime("Can't operate with non-quad value of ID part in AS,ID constructor"); + + res.val.ai = ai; + res.type = T_STRUCT_ASID; + break; + } + + case P('s','s'): + { + char *name; + + ARG(v2, a2.p); + + sym = what->a1.p; + name = sym->name; + + i = SE_OK; + switch (v2.type) { + case T_STRUCT_ASID: + if (!strcmp(name, "ai.as")) { + res.type = T_INT; + res.val.i = v2.val.ai.as; + } else if (!strcmp(name, "ai.id")) { + res.type = T_QUAD; + res.val.i = v2.val.ai.id; + } else + i = SE_NO_MEMBER; + break; + default: + i = SE_NOT_STRUCT; + } + + if (i != SE_OK) + runtime(se_desc[i]); + } + break; + + case P('s','S'): + { + char **pname; + char *name; + + TWOARGS; + + pname = (char **) ((struct f_inst_data *) what->a1.p)->data; + name = *pname; + + res = v1; + i = SE_OK; + switch (res.type) { + case T_STRUCT_ASID: + if (!strcmp(name, "ai.as")) { + if (v2.type == T_INT) + res.val.ai.as = v2.val.i; + else + i = SE_IN_TYPE; + } else if (!strcmp(name, "ai.id")) { + if (v2.type == T_QUAD) + res.val.ai.id = v2.val.i; +#ifndef IPV6 + /* IP->Quad implicit conversion */ + else if (v2.type == T_IP) + res.val.ai.id = ipa_to_u32(v2.val.px.ip); +#endif + else + i = SE_IN_TYPE; + } else + i = SE_NO_MEMBER; + break; + default: + i = SE_NOT_STRUCT; + } + + if (i != SE_OK) + runtime(se_desc[i]); + } + break; + /* Relational operators */ #define COMPARE(f,x) \ @@ -937,6 +1050,12 @@ interpret(struct f_inst *what) res.val.px.ip = * (ip_addr *) ad->data; } break; + case T_STRUCT_ASID: + { + struct adata * ad = e->u.ptr; + res.val.ai = * (struct f_asid *) ad->data; + } + break; case T_PATH: case T_CLIST: case T_ECLIST: @@ -998,6 +1117,14 @@ interpret(struct f_inst *what) l->attrs[0].u.ptr = ad; } break; + case T_STRUCT_ASID: + { + struct adata *ad = lp_alloc(f_pool, sizeof(struct adata) + sizeof(struct f_asid)); + ad->length = sizeof(struct f_asid); + (* (struct f_asid *) ad->data) = v1.val.ai; + l->attrs[0].u.ptr = ad; + } + break; case T_PATH: case T_CLIST: case T_ECLIST: @@ -1352,6 +1479,7 @@ i_same(struct f_inst *f1, struct f_inst *f2) case '&': case P('m','p'): case P('m','c'): + case P('m','a'): case P('!','='): case P('=','='): case '<': @@ -1361,6 +1489,7 @@ i_same(struct f_inst *f1, struct f_inst *f2) case '~': TWOARGS; break; case P('d','e'): ONEARG; break; + case P('s','s'): case 's': ARG(v2, a2.p); { @@ -1374,6 +1503,23 @@ i_same(struct f_inst *f1, struct f_inst *f2) } break; + case P('s','S'): + TWOARGS; + { + char **pname1, **pname2; + char *name1, *name2; + + pname1 = (char **) ((struct f_inst_data *) f1->a1.p)->data; + name1 = *pname1; + + pname2 = (char **) ((struct f_inst_data *) f2->a1.p)->data; + name2 = *pname2; + + if (strcmp(name1, name2)) + return 0; + } + break; + case 'c': switch (f1->aux) { diff --git a/filter/filter.h b/filter/filter.h index aed4418..970d093 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -29,6 +29,11 @@ struct f_inst { /* Instruction */ int lineno; }; +struct f_inst_data { + struct f_inst i; + byte data[0]; +}; + #define arg1 a1.p #define arg2 a2.p @@ -48,11 +53,17 @@ struct f_prefix { /* If range then prefix must be in range (len >> 16 & 0xff, len >> 8 & 0xff) */ }; +struct f_asid { + u32 as; + u32 id; +}; + struct f_val { int type; union { int i; u64 ec; + struct f_asid ai; /* ip_addr ip; Folded into prefix */ struct f_prefix px; char *s; @@ -69,10 +80,12 @@ struct filter { }; struct f_inst *f_new_inst(void); +struct f_inst_data *f_new_inst2(unsigned int size); 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_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_roa_check(struct symbol *sym, struct f_inst *prefix, struct f_inst *asn); +struct f_inst *f_generate_struct(int type, ...); struct f_tree *build_tree(struct f_tree *); @@ -177,9 +190,21 @@ void val_print(struct f_val v); #define T_ECLIST 0x26 /* Extended community list */ #define T_EC 0x27 /* Extended community value, u64 */ -#define T_RETURN 0x40 -#define T_SET 0x80 -#define T_PREFIX_SET 0x81 +/* Put set types in 0x40..0x4f range */ +#define T_SET 0x40 /* General set type */ +#define T_PREFIX_SET 0x41 /* Special set for prefixes */ +/* new sets go here */ + +/* Put structured types in 0x50..0x5f range */ +#define T_STRUCT_LO 0x50 +#define T_STRUCT_HI 0x5f + +#define T_STRUCT_ASID 0x50 /* AS,ID structure (BGP_AGGREGATOR) */ +/* new structs go here */ + +#define T_STRUCT T_STRUCT_LO ... T_STRUCT_HI + +#define T_RETURN 0x80 #define SA_FROM 1 diff --git a/nest/route.h b/nest/route.h index 35b5fa1..7aadfc9 100644 --- a/nest/route.h +++ b/nest/route.h @@ -392,6 +392,7 @@ typedef struct eattr { #define EAF_TYPE_IP_ADDRESS 0x04 /* IP address */ #define EAF_TYPE_ROUTER_ID 0x05 /* Router ID (IPv4 address) */ #define EAF_TYPE_AS_PATH 0x06 /* BGP AS path (encoding per RFC 1771:4.3) */ +#define EAF_TYPE_BGP_AGGREGATOR 0x08 /* BGP AGGREGATOR attribute */ #define EAF_TYPE_INT_SET 0x0a /* Set of u32's (e.g., a community list) */ #define EAF_TYPE_EC_SET 0x0e /* Set of pairs of u32's - ext. community list */ #define EAF_TYPE_UNDEF 0x0f /* `force undefined' entry */ diff --git a/proto/bgp/attrs.c b/proto/bgp/attrs.c index c27a498..706ed7d 100644 --- a/proto/bgp/attrs.c +++ b/proto/bgp/attrs.c @@ -231,14 +231,10 @@ bgp_check_aggregator(struct bgp_proto *p, byte *a UNUSED, int len) static void bgp_format_aggregator(eattr *a, byte *buf, int buflen UNUSED) { - struct adata *ad = a->u.ptr; - byte *data = ad->data; - u32 as; - - as = get_u32(data); - data += 4; + struct adata *ad = a->u.ptr; + struct f_asid *ai = (struct f_asid *) ad->data; - bsprintf(buf, "%d.%d.%d.%d AS%u", data[0], data[1], data[2], data[3], as); + bsprintf(buf, "%R AS%u", ai->id, ai->as); } static int @@ -302,7 +298,7 @@ static struct attr_desc bgp_attr_table[] = { NULL, NULL }, { "atomic_aggr", 0, BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1, /* BA_ATOMIC_AGGR */ NULL, NULL }, - { "aggregator", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1, /* BA_AGGREGATOR */ + { "aggregator", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_BGP_AGGREGATOR, 1,/* BA_AGGREGATOR */ bgp_check_aggregator, bgp_format_aggregator }, { "community", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_INT_SET, 1, /* BA_COMMUNITY */ bgp_check_community, NULL }, @@ -597,6 +593,7 @@ bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains) memcpy(w, &ip, len); break; } + case EAF_TYPE_BGP_AGGREGATOR: case EAF_TYPE_INT_SET: case EAF_TYPE_EC_SET: { @@ -1660,6 +1657,7 @@ bgp_decode_attrs(struct bgp_conn *conn, byte *attr, unsigned int len, struct lin case EAF_TYPE_IP_ADDRESS: ipa_ntoh(*(ip_addr *)ad->data); break; + case EAF_TYPE_BGP_AGGREGATOR: case EAF_TYPE_INT_SET: case EAF_TYPE_EC_SET: { diff --git a/proto/bgp/config.Y b/proto/bgp/config.Y index 19f7a21..0c949ff 100644 --- a/proto/bgp/config.Y +++ b/proto/bgp/config.Y @@ -125,7 +125,7 @@ CF_ADDTO(dynamic_attr, BGP_LOCAL_PREF CF_ADDTO(dynamic_attr, BGP_ATOMIC_AGGR { $$ = f_new_dynamic_attr(EAF_TYPE_OPAQUE, T_EMPTY, EA_CODE(EAP_BGP, BA_ATOMIC_AGGR)); }) CF_ADDTO(dynamic_attr, BGP_AGGREGATOR - { $$ = f_new_dynamic_attr(EAF_TYPE_OPAQUE, T_EMPTY, EA_CODE(EAP_BGP, BA_AGGREGATOR)); }) + { $$ = f_new_dynamic_attr(EAF_TYPE_BGP_AGGREGATOR, T_STRUCT_ASID, EA_CODE(EAP_BGP, BA_AGGREGATOR)); }) CF_ADDTO(dynamic_attr, BGP_COMMUNITY { $$ = f_new_dynamic_attr(EAF_TYPE_INT_SET, T_CLIST, EA_CODE(EAP_BGP, BA_COMMUNITY)); }) CF_ADDTO(dynamic_attr, BGP_ORIGINATOR_ID -- 1.7.10.4