1: /*
2: * BIRD - filters
3: *
4: * Copyright 1998--2000 Pavel Machek
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: *
8: FIXME: priority of ! should be lower
9: */
10:
11: CF_HDR
12:
13: CF_DEFINES
14:
15: #define P(a,b) ((a << 8) | b)
16:
17: static inline u32 pair(u32 a, u32 b) { return (a << 16) | b; }
18: static inline u32 pair_a(u32 p) { return p >> 16; }
19: static inline u32 pair_b(u32 p) { return p & 0xFFFF; }
20:
21:
22: /*
23: * Sets and their items are during parsing handled as lists, linked
24: * through left ptr. The first item in a list also contains a pointer
25: * to the last item in a list (right ptr). For convenience, even items
26: * are handled as one-item lists. Lists are merged by f_merge_items().
27: */
28: static int
29: f_valid_set_type(int type)
30: {
31: switch (type)
32: {
33: case T_INT:
34: case T_PAIR:
35: case T_QUAD:
36: case T_ENUM:
37: case T_IP:
38: case T_EC:
39: case T_LC:
40: return 1;
41:
42: default:
43: return 0;
44: }
45: }
46:
47: static inline struct f_tree *
48: f_new_item(struct f_val from, struct f_val to)
49: {
50: struct f_tree *t = f_new_tree();
51: t->right = t;
52: t->from = from;
53: t->to = to;
54: return t;
55: }
56:
57: static inline struct f_tree *
58: f_merge_items(struct f_tree *a, struct f_tree *b)
59: {
60: if (!a) return b;
61: a->right->left = b;
62: a->right = b->right;
63: b->right = NULL;
64: return a;
65: }
66:
67: static inline struct f_tree *
68: f_new_pair_item(int fa, int ta, int fb, int tb)
69: {
70: check_u16(fa);
71: check_u16(ta);
72: check_u16(fb);
73: check_u16(tb);
74:
75: if ((ta < fa) || (tb < fb))
76: cf_error( "From value cannot be higher that To value in pair sets");
77:
78: struct f_tree *t = f_new_tree();
79: t->right = t;
80: t->from.type = t->to.type = T_PAIR;
81: t->from.val.i = pair(fa, fb);
82: t->to.val.i = pair(ta, tb);
83: return t;
84: }
85:
86: static inline struct f_tree *
87: f_new_pair_set(int fa, int ta, int fb, int tb)
88: {
89: check_u16(fa);
90: check_u16(ta);
91: check_u16(fb);
92: check_u16(tb);
93:
94: if ((ta < fa) || (tb < fb))
95: cf_error( "From value cannot be higher that To value in pair sets");
96:
97: struct f_tree *lst = NULL;
98: int i;
99:
100: for (i = fa; i <= ta; i++)
101: lst = f_merge_items(lst, f_new_pair_item(i, i, fb, tb));
102:
103: return lst;
104: }
105:
106: #define CC_ALL 0xFFFF
107: #define EC_ALL 0xFFFFFFFF
108: #define LC_ALL 0xFFFFFFFF
109:
110: static struct f_tree *
111: f_new_ec_item(u32 kind, u32 ipv4_used, u32 key, u32 vf, u32 vt)
112: {
113: u64 fm, to;
114:
115: if (ipv4_used || (key >= 0x10000)) {
116: check_u16(vf);
117: if (vt == EC_ALL)
118: vt = 0xFFFF;
119: else
120: check_u16(vt);
121: }
122:
123: if (kind == EC_GENERIC) {
124: fm = ec_generic(key, vf);
125: to = ec_generic(key, vt);
126: }
127: else if (ipv4_used) {
128: fm = ec_ip4(kind, key, vf);
129: to = ec_ip4(kind, key, vt);
130: }
131: else if (key < 0x10000) {
132: fm = ec_as2(kind, key, vf);
133: to = ec_as2(kind, key, vt);
134: }
135: else {
136: fm = ec_as4(kind, key, vf);
137: to = ec_as4(kind, key, vt);
138: }
139:
140: struct f_tree *t = f_new_tree();
141: t->right = t;
142: t->from.type = t->to.type = T_EC;
143: t->from.val.ec = fm;
144: t->to.val.ec = to;
145: return t;
146: }
147:
148: static struct f_tree *
149: f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
150: {
151: struct f_tree *t = f_new_tree();
152: t->right = t;
153: t->from.type = t->to.type = T_LC;
154: t->from.val.lc = (lcomm) {f1, f2, f3};
155: t->to.val.lc = (lcomm) {t1, t2, t3};
156: return t;
157: }
158:
159: static inline struct f_inst *
160: f_generate_empty(struct f_inst *dyn)
161: {
162: struct f_inst *e = f_new_inst();
163: e->code = 'E';
164:
165: switch (dyn->aux & EAF_TYPE_MASK) {
166: case EAF_TYPE_AS_PATH:
167: e->aux = T_PATH;
168: break;
169: case EAF_TYPE_INT_SET:
170: e->aux = T_CLIST;
171: break;
172: case EAF_TYPE_EC_SET:
173: e->aux = T_ECLIST;
174: break;
175: case EAF_TYPE_LC_SET:
176: e->aux = T_LCLIST;
177: break;
178: default:
179: cf_error("Can't empty that attribute");
180: }
181:
182: dyn->code = P('e','S');
183: dyn->a1.p = e;
184: return dyn;
185: }
186:
187:
188: static inline struct f_inst *
189: f_generate_dpair(struct f_inst *t1, struct f_inst *t2)
190: {
191: struct f_inst *rv;
192:
193: if ((t1->code == 'c') && (t2->code == 'c')) {
194: if ((t1->aux != T_INT) || (t2->aux != T_INT))
195: cf_error( "Can't operate with value of non-integer type in pair constructor");
196:
197: check_u16(t1->a2.i);
198: check_u16(t2->a2.i);
199:
200: rv = f_new_inst();
201: rv->code = 'c';
202: rv->aux = T_PAIR;
203: rv->a2.i = pair(t1->a2.i, t2->a2.i);
204: }
205: else {
206: rv = f_new_inst();
207: rv->code = P('m', 'p');
208: rv->a1.p = t1;
209: rv->a2.p = t2;
210: }
211:
212: return rv;
213: }
214:
215: static inline struct f_inst *
216: f_generate_ec(u16 kind, struct f_inst *tk, struct f_inst *tv)
217: {
218: struct f_inst *rv;
219: int c1 = 0, c2 = 0, ipv4_used = 0;
220: u32 key = 0, val2 = 0;
221:
222: if (tk->code == 'c') {
223: c1 = 1;
224:
225: if (tk->aux == T_INT) {
226: ipv4_used = 0; key = tk->a2.i;
227: }
228: else if (tk->aux == T_QUAD) {
229: ipv4_used = 1; key = tk->a2.i;
230: }
231: else
232: cf_error("Can't operate with key of non-integer/IPv4 type in EC constructor");
233: }
234:
235: #ifndef IPV6
236: /* IP->Quad implicit conversion */
237: else if (tk->code == 'C') {
238: c1 = 1;
239: struct f_val *val = tk->a1.p;
240:
241: if (val->type == T_INT) {
242: ipv4_used = 0; key = val->val.i;
243: }
244: else if (val->type == T_QUAD) {
245: ipv4_used = 1; key = val->val.i;
246: }
247: else if (val->type == T_IP) {
248: ipv4_used = 1; key = ipa_to_u32(val->val.px.ip);
249: }
250: else
251: cf_error("Can't operate with key of non-integer/IPv4 type in EC constructor");
252: }
253: #endif
254:
255: if (tv->code == 'c') {
256: if (tv->aux != T_INT)
257: cf_error("Can't operate with value of non-integer type in EC constructor");
258: c2 = 1;
259: val2 = tv->a2.i;
260: }
261:
262: if (c1 && c2) {
263: u64 ec;
264:
265: if (kind == EC_GENERIC) {
266: ec = ec_generic(key, val2);
267: }
268: else if (ipv4_used) {
269: check_u16(val2);
270: ec = ec_ip4(kind, key, val2);
271: }
272: else if (key < 0x10000) {
273: ec = ec_as2(kind, key, val2);
274: }
275: else {
276: check_u16(val2);
277: ec = ec_as4(kind, key, val2);
278: }
279:
280: NEW_F_VAL;
281: rv = f_new_inst();
282: rv->code = 'C';
283: rv->a1.p = val;
284: val->type = T_EC;
285: val->val.ec = ec;
286: }
287: else {
288: rv = f_new_inst();
289: rv->code = P('m','c');
290: rv->aux = kind;
291: rv->a1.p = tk;
292: rv->a2.p = tv;
293: }
294:
295: return rv;
296: }
297:
298: static inline struct f_inst *
299: f_generate_lc(struct f_inst *t1, struct f_inst *t2, struct f_inst *t3)
300: {
301: struct f_inst *rv;
302:
303: if ((t1->code == 'c') && (t2->code == 'c') && (t3->code == 'c')) {
304: if ((t1->aux != T_INT) || (t2->aux != T_INT) || (t3->aux != T_INT))
305: cf_error( "LC - Can't operate with value of non-integer type in tuple constructor");
306:
307: rv = f_new_inst();
308: rv->code = 'C';
309:
310: NEW_F_VAL;
311: rv->a1.p = val;
312: val->type = T_LC;
313: val->val.lc = (lcomm) { t1->a2.i, t2->a2.i, t3->a2.i };
314: }
315: else
316: {
317: rv = cfg_allocz(sizeof(struct f_inst3));
318: rv->lineno = ifs->lino;
319: rv->code = P('m','l');
320: rv->a1.p = t1;
321: rv->a2.p = t2;
322: INST3(rv).p = t3;
323: }
324:
325: return rv;
326: }
327:
328:
329:
330: CF_DECLS
331:
332: CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
333: ACCEPT, REJECT, ERROR, QUITBIRD,
334: INT, BOOL, IP, PREFIX, PAIR, QUAD, EC, LC,
335: SET, STRING, BGPMASK, BGPPATH, CLIST, ECLIST, LCLIST,
336: IF, THEN, ELSE, CASE,
337: TRUE, FALSE, RT, RO, UNKNOWN, GENERIC,
338: FROM, GW, NET, MASK, PROTO, SOURCE, SCOPE, CAST, DEST, IFNAME, IFINDEX,
339: PREFERENCE,
340: LEN,
341: DEFINED,
342: ADD, DELETE, CONTAINS, RESET,
343: PREPEND, FIRST, LAST, LAST_NONAGGREGATED, MATCH,
344: ROA_CHECK,
345: EMPTY,
346: FILTER, WHERE, EVAL)
347:
348: %nonassoc THEN
349: %nonassoc ELSE
350:
351: %type <x> term block cmds cmds_int cmd function_body constant constructor print_one print_list var_list var_listn dynamic_attr static_attr function_call symbol bgp_path_expr
352: %type <f> filter filter_body where_filter
353: %type <i> type break_command ec_kind
354: %type <i32> cnum
355: %type <e> pair_item ec_item lc_item set_item switch_item set_items switch_items switch_body
356: %type <trie> fprefix_set
357: %type <v> set_atom switch_atom fprefix fprefix_s fipa
358: %type <s> decls declsn one_decl function_params
359: %type <h> bgp_path bgp_path_tail1 bgp_path_tail2
360:
361: CF_GRAMMAR
362:
363: CF_ADDTO(conf, filter_def)
364: filter_def:
365: FILTER SYM { $2 = cf_define_symbol($2, SYM_FILTER, NULL); cf_push_scope( $2 ); }
366: filter_body {
367: $2->def = $4;
368: $4->name = $2->name;
369: DBG( "We have new filter defined (%s)\n", $2->name );
370: cf_pop_scope();
371: }
372: ;
373:
374: CF_ADDTO(conf, filter_eval)
375: filter_eval:
376: EVAL term { f_eval_int($2); }
377: ;
378:
379: type:
380: INT { $$ = T_INT; }
381: | BOOL { $$ = T_BOOL; }
382: | IP { $$ = T_IP; }
383: | PREFIX { $$ = T_PREFIX; }
384: | PAIR { $$ = T_PAIR; }
385: | QUAD { $$ = T_QUAD; }
386: | EC { $$ = T_EC; }
387: | LC { $$ = T_LC; }
388: | STRING { $$ = T_STRING; }
389: | BGPMASK { $$ = T_PATH_MASK; }
390: | BGPPATH { $$ = T_PATH; }
391: | CLIST { $$ = T_CLIST; }
392: | ECLIST { $$ = T_ECLIST; }
393: | LCLIST { $$ = T_LCLIST; }
394: | type SET {
395: switch ($1) {
396: case T_INT:
397: case T_PAIR:
398: case T_QUAD:
399: case T_EC:
400: case T_LC:
401: case T_IP:
402: $$ = T_SET;
403: break;
404:
405: case T_PREFIX:
406: $$ = T_PREFIX_SET;
407: break;
408:
409: default:
410: cf_error( "You can't create sets of this type." );
411: }
412: }
413: ;
414:
415: one_decl:
416: type SYM {
417: struct f_val * val = cfg_alloc(sizeof(struct f_val));
418: val->type = T_VOID;
419: $2 = cf_define_symbol($2, SYM_VARIABLE | $1, val);
420: DBG( "New variable %s type %x\n", $2->name, $1 );
421: $2->aux2 = NULL;
422: $$=$2;
423: }
424: ;
425:
426: /* Decls with ';' at the end */
427: decls: /* EMPTY */ { $$ = NULL; }
428: | one_decl ';' decls {
429: $$ = $1;
430: $$->aux2 = $3;
431: }
432: ;
433:
434: /* Declarations that have no ';' at the end. */
435: declsn: one_decl { $$ = $1; }
436: | one_decl ';' declsn {
437: $$ = $1;
438: $$->aux2 = $3;
439: }
440: ;
441:
442: filter_body:
443: function_body {
444: struct filter *f = cfg_alloc(sizeof(struct filter));
445: f->name = NULL;
446: f->root = $1;
447: $$ = f;
448: }
449: ;
450:
451: filter:
452: SYM {
453: if ($1->class != SYM_FILTER) cf_error("No such filter.");
454: $$ = $1->def;
455: }
456: | filter_body
457: ;
458:
459: where_filter:
460: WHERE term {
461: /* Construct 'IF term THEN ACCEPT; REJECT;' */
462: struct filter *f = cfg_alloc(sizeof(struct filter));
463: struct f_inst *i, *acc, *rej;
464: acc = f_new_inst(); /* ACCEPT */
465: acc->code = P('p',',');
466: acc->a1.p = NULL;
467: acc->a2.i = F_ACCEPT;
468: rej = f_new_inst(); /* REJECT */
469: rej->code = P('p',',');
470: rej->a1.p = NULL;
471: rej->a2.i = F_REJECT;
472: i = f_new_inst(); /* IF */
473: i->code = '?';
474: i->a1.p = $2;
475: i->a2.p = acc;
476: i->next = rej;
477: f->name = NULL;
478: f->root = i;
479: $$ = f;
480: }
481: ;
482:
483: function_params:
484: '(' declsn ')' { DBG( "Have function parameters\n" ); $$=$2; }
485: | '(' ')' { $$=NULL; }
486: ;
487:
488: function_body:
489: decls '{' cmds '}' {
490: if ($1) {
491: /* Prepend instruction to clear local variables */
492: $$ = f_new_inst();
493: $$->code = P('c','v');
494: $$->a1.p = $1;
495: $$->next = $3;
496: } else
497: $$ = $3;
498: }
499: ;
500:
501: CF_ADDTO(conf, function_def)
502: function_def:
503: FUNCTION SYM { DBG( "Beginning of function %s\n", $2->name );
504: $2 = cf_define_symbol($2, SYM_FUNCTION, NULL);
505: cf_push_scope($2);
506: } function_params function_body {
507: $2->def = $5;
508: $2->aux2 = $4;
509: DBG("Hmm, we've got one function here - %s\n", $2->name);
510: cf_pop_scope();
511: }
512: ;
513:
514: /* Programs */
515:
516: /* Hack: $$ of cmds_int is the last node.
517: $$->next of cmds_int is temporary used for the first node */
518:
519: cmds: /* EMPTY */ { $$ = NULL; }
520: | cmds_int { $$ = $1->next; $1->next = NULL; }
521: ;
522:
523: cmds_int: cmd { $$ = $1; $1->next = $1; }
524: | cmds_int cmd { $$ = $2; $2->next = $1->next ; $1->next = $2; }
525: ;
526:
527: block:
528: cmd {
529: $$=$1;
530: }
531: | '{' cmds '}' {
532: $$=$2;
533: }
534: ;
535:
536: /*
537: * Complex types, their bison value is struct f_val
538: */
539: fipa:
540: IPA %prec PREFIX_DUMMY { $$.type = T_IP; $$.val.px.ip = $1; }
541: ;
542:
543:
544:
545: /*
546: * Set constants. They are also used in switch cases. We use separate
547: * nonterminals for switch (set_atom/switch_atom, set_item/switch_item ...)
548: * to elude a collision between symbol (in expr) in set_atom and symbol
549: * as a function call in switch case cmds.
550: */
551:
552: set_atom:
553: NUM { $$.type = T_INT; $$.val.i = $1; }
554: | RTRID { $$.type = T_QUAD; $$.val.i = $1; }
555: | fipa { $$ = $1; }
556: | ENUM { $$.type = pair_a($1); $$.val.i = pair_b($1); }
557: | '(' term ')' {
558: $$ = f_eval($2, cfg_mem);
559: if (!f_valid_set_type($$.type)) cf_error("Set-incompatible type");
560: }
561: | SYM {
562: if (!cf_symbol_is_constant($1)) cf_error("%s: constant expected", $1->name);
563: if (!f_valid_set_type(SYM_TYPE($1))) cf_error("%s: set-incompatible type", $1->name);
564: $$ = *(struct f_val *)($1->def);
565: }
566: ;
567:
568: switch_atom:
569: NUM { $$.type = T_INT; $$.val.i = $1; }
570: | '(' term ')' { $$.type = T_INT; $$.val.i = f_eval_int($2); }
571: | RTRID { $$.type = T_QUAD; $$.val.i = $1; }
572: | fipa { $$ = $1; }
573: | ENUM { $$.type = pair_a($1); $$.val.i = pair_b($1); }
574: ;
575:
576: cnum:
577: term { $$ = f_eval_int($1); }
578:
579: pair_item:
580: '(' cnum ',' cnum ')' { $$ = f_new_pair_item($2, $2, $4, $4); }
581: | '(' cnum ',' cnum DDOT cnum ')' { $$ = f_new_pair_item($2, $2, $4, $6); }
582: | '(' cnum ',' '*' ')' { $$ = f_new_pair_item($2, $2, 0, CC_ALL); }
583: | '(' cnum DDOT cnum ',' cnum ')' { $$ = f_new_pair_set($2, $4, $6, $6); }
584: | '(' cnum DDOT cnum ',' cnum DDOT cnum ')' { $$ = f_new_pair_set($2, $4, $6, $8); }
585: | '(' cnum DDOT cnum ',' '*' ')' { $$ = f_new_pair_item($2, $4, 0, CC_ALL); }
586: | '(' '*' ',' cnum ')' { $$ = f_new_pair_set(0, CC_ALL, $4, $4); }
587: | '(' '*' ',' cnum DDOT cnum ')' { $$ = f_new_pair_set(0, CC_ALL, $4, $6); }
588: | '(' '*' ',' '*' ')' { $$ = f_new_pair_item(0, CC_ALL, 0, CC_ALL); }
589: | '(' cnum ',' cnum ')' DDOT '(' cnum ',' cnum ')'
590: { $$ = f_new_pair_item($2, $8, $4, $10); }
591: ;
592:
593: ec_kind:
594: RT { $$ = EC_RT; }
595: | RO { $$ = EC_RO; }
596: | UNKNOWN NUM { $$ = $2; }
597: | GENERIC { $$ = EC_GENERIC; }
598: ;
599:
600: ec_item:
601: '(' ec_kind ',' cnum ',' cnum ')' { $$ = f_new_ec_item($2, 0, $4, $6, $6); }
602: | '(' ec_kind ',' cnum ',' cnum DDOT cnum ')' { $$ = f_new_ec_item($2, 0, $4, $6, $8); }
603: | '(' ec_kind ',' cnum ',' '*' ')' { $$ = f_new_ec_item($2, 0, $4, 0, EC_ALL); }
604: ;
605:
606: lc_item:
607: '(' cnum ',' cnum ',' cnum ')' { $$ = f_new_lc_item($2, $2, $4, $4, $6, $6); }
608: | '(' cnum ',' cnum ',' cnum DDOT cnum ')' { $$ = f_new_lc_item($2, $2, $4, $4, $6, $8); }
609: | '(' cnum ',' cnum ',' '*' ')' { $$ = f_new_lc_item($2, $2, $4, $4, 0, LC_ALL); }
610: | '(' cnum ',' cnum DDOT cnum ',' '*' ')' { $$ = f_new_lc_item($2, $2, $4, $6, 0, LC_ALL); }
611: | '(' cnum ',' '*' ',' '*' ')' { $$ = f_new_lc_item($2, $2, 0, LC_ALL, 0, LC_ALL); }
612: | '(' cnum DDOT cnum ',' '*' ',' '*' ')' { $$ = f_new_lc_item($2, $4, 0, LC_ALL, 0, LC_ALL); }
613: | '(' '*' ',' '*' ',' '*' ')' { $$ = f_new_lc_item(0, LC_ALL, 0, LC_ALL, 0, LC_ALL); }
614: | '(' cnum ',' cnum ',' cnum ')' DDOT '(' cnum ',' cnum ',' cnum ')'
615: { $$ = f_new_lc_item($2, $10, $4, $12, $6, $14); }
616: ;
617:
618: set_item:
619: pair_item
620: | ec_item
621: | lc_item
622: | set_atom { $$ = f_new_item($1, $1); }
623: | set_atom DDOT set_atom { $$ = f_new_item($1, $3); }
624: ;
625:
626: switch_item:
627: pair_item
628: | ec_item
629: | lc_item
630: | switch_atom { $$ = f_new_item($1, $1); }
631: | switch_atom DDOT switch_atom { $$ = f_new_item($1, $3); }
632: ;
633:
634: set_items:
635: set_item
636: | set_items ',' set_item { $$ = f_merge_items($1, $3); }
637: ;
638:
639: switch_items:
640: switch_item
641: | switch_items ',' switch_item { $$ = f_merge_items($1, $3); }
642: ;
643:
644: fprefix_s:
645: IPA '/' NUM %prec '/' {
646: if (($3 < 0) || ($3 > MAX_PREFIX_LENGTH) || !ip_is_prefix($1, $3)) cf_error("Invalid network prefix: %I/%d.", $1, $3);
647: $$.type = T_PREFIX; $$.val.px.ip = $1; $$.val.px.len = $3;
648: }
649: ;
650:
651: fprefix:
652: fprefix_s { $$ = $1; }
653: | fprefix_s '+' { $$ = $1; $$.val.px.len |= LEN_PLUS; }
654: | fprefix_s '-' { $$ = $1; $$.val.px.len |= LEN_MINUS; }
655: | fprefix_s '{' NUM ',' NUM '}' {
656: if (! ((0 <= $3) && ($3 <= $5) && ($5 <= MAX_PREFIX_LENGTH))) cf_error("Invalid prefix pattern range: {%d, %d}.", $3, $5);
657: $$ = $1; $$.val.px.len |= LEN_RANGE | ($3 << 16) | ($5 << 8);
658: }
659: ;
660:
661: fprefix_set:
662: fprefix { $$ = f_new_trie(cfg_mem, sizeof(struct f_trie_node)); trie_add_fprefix($$, &($1.val.px)); }
663: | fprefix_set ',' fprefix { $$ = $1; trie_add_fprefix($$, &($3.val.px)); }
664: ;
665:
666: switch_body: /* EMPTY */ { $$ = NULL; }
667: | switch_body switch_items ':' cmds {
668: /* Fill data fields */
669: struct f_tree *t;
670: for (t = $2; t; t = t->left)
671: t->data = $4;
672: $$ = f_merge_items($1, $2);
673: }
674: | switch_body ELSECOL cmds {
675: struct f_tree *t = f_new_tree();
676: t->from.type = t->to.type = T_VOID;
677: t->right = t;
678: t->data = $3;
679: $$ = f_merge_items($1, t);
680: }
681: ;
682:
683: /* CONST '(' expr ')' { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT; $$->a2.i = $3; } */
684:
685: bgp_path_expr:
686: symbol { $$ = $1; }
687: | '(' term ')' { $$ = $2; }
688: ;
689:
690: bgp_path:
691: PO bgp_path_tail1 PC { $$ = $2; }
692: | '/' bgp_path_tail2 '/' { $$ = $2; }
693: ;
694:
695: bgp_path_tail1:
696: NUM bgp_path_tail1 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN; $$->val = $1; }
697: | NUM DDOT NUM bgp_path_tail1 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $4; $$->kind = PM_ASN_RANGE; $$->val = $1; $$->val2 = $3; }
698: | '*' bgp_path_tail1 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; }
699: | '?' bgp_path_tail1 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_QUESTION; }
700: | bgp_path_expr bgp_path_tail1 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN_EXPR; $$->val = (uintptr_t) $1; }
701: | { $$ = NULL; }
702: ;
703:
704: bgp_path_tail2:
705: NUM bgp_path_tail2 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASN; $$->val = $1; }
706: | '?' bgp_path_tail2 { $$ = cfg_allocz(sizeof(struct f_path_mask)); $$->next = $2; $$->kind = PM_ASTERISK; }
707: | { $$ = NULL; }
708: ;
709:
710: constant:
711: NUM { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT; $$->a2.i = $1; }
712: | TRUE { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_BOOL; $$->a2.i = 1; }
713: | FALSE { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_BOOL; $$->a2.i = 0; }
714: | TEXT { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_STRING; $$->a2.p = $1; }
715: | fipa { NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; *val = $1; }
716: | fprefix_s {NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; *val = $1; }
717: | RTRID { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_QUAD; $$->a2.i = $1; }
718: | '[' set_items ']' { DBG( "We've got a set here..." ); $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_SET; $$->a2.p = build_tree($2); DBG( "ook\n" ); }
719: | '[' fprefix_set ']' { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_PREFIX_SET; $$->a2.p = $2; }
720: | ENUM { $$ = f_new_inst(); $$->code = 'c'; $$->aux = $1 >> 16; $$->a2.i = $1 & 0xffff; }
721: | bgp_path { NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; val->type = T_PATH_MASK; val->val.path_mask = $1; $$->a1.p = val; }
722: ;
723:
724: constructor:
725: '(' term ',' term ')' { $$ = f_generate_dpair($2, $4); }
726: | '(' ec_kind ',' term ',' term ')' { $$ = f_generate_ec($2, $4, $6); }
727: | '(' term ',' term ',' term ')' { $$ = f_generate_lc($2, $4, $6); }
728: ;
729:
730:
731: /*
732: * Maybe there are no dynamic attributes defined by protocols.
733: * For such cases, we force the dynamic_attr list to contain
734: * at least an invalid token, so it is syntantically correct.
735: */
736: CF_ADDTO(dynamic_attr, INVALID_TOKEN { $$ = NULL; })
737:
738: rtadot: /* EMPTY, we are not permitted RTA. prefix */
739: ;
740:
741: function_call:
742: SYM '(' var_list ')' {
743: struct symbol *sym;
744: struct f_inst *inst = $3;
745: if ($1->class != SYM_FUNCTION)
746: cf_error("You can't call something which is not a function. Really.");
747: DBG("You are calling function %s\n", $1->name);
748: $$ = f_new_inst();
749: $$->code = P('c','a');
750: $$->a1.p = inst;
751: $$->a2.p = $1->def;
752: sym = $1->aux2;
753: while (sym || inst) {
754: if (!sym || !inst)
755: cf_error("Wrong number of arguments for function %s.", $1->name);
756: DBG( "You should pass parameter called %s\n", sym->name);
757: inst->a1.p = sym;
758: sym = sym->aux2;
759: inst = inst->next;
760: }
761: }
762: ;
763:
764: symbol:
765: SYM {
766: $$ = f_new_inst();
767:
768: switch ($1->class & 0xff00) {
769: case SYM_CONSTANT: $$->code = 'C'; break;
770: case SYM_VARIABLE: $$->code = 'V'; break;
771: default: cf_error("%s: variable expected.", $1->name);
772: }
773:
774: $$->a1.p = $1->def;
775: $$->a2.p = $1->name;
776: }
777:
778: static_attr:
779: FROM { $$ = f_new_inst(); $$->aux = T_IP; $$->a2.i = SA_FROM; $$->a1.i = 1; }
780: | GW { $$ = f_new_inst(); $$->aux = T_IP; $$->a2.i = SA_GW; $$->a1.i = 1; }
781: | NET { $$ = f_new_inst(); $$->aux = T_PREFIX; $$->a2.i = SA_NET; }
782: | PROTO { $$ = f_new_inst(); $$->aux = T_STRING; $$->a2.i = SA_PROTO; }
783: | SOURCE { $$ = f_new_inst(); $$->aux = T_ENUM_RTS; $$->a2.i = SA_SOURCE; }
784: | SCOPE { $$ = f_new_inst(); $$->aux = T_ENUM_SCOPE; $$->a2.i = SA_SCOPE; $$->a1.i = 1; }
785: | CAST { $$ = f_new_inst(); $$->aux = T_ENUM_RTC; $$->a2.i = SA_CAST; }
786: | DEST { $$ = f_new_inst(); $$->aux = T_ENUM_RTD; $$->a2.i = SA_DEST; $$->a1.i = 1; }
787: | IFNAME { $$ = f_new_inst(); $$->aux = T_STRING; $$->a2.i = SA_IFNAME; }
788: | IFINDEX { $$ = f_new_inst(); $$->aux = T_INT; $$->a2.i = SA_IFINDEX; }
789: ;
790:
791: term:
792: '(' term ')' { $$ = $2; }
793: | term '+' term { $$ = f_new_inst(); $$->code = '+'; $$->a1.p = $1; $$->a2.p = $3; }
794: | term '-' term { $$ = f_new_inst(); $$->code = '-'; $$->a1.p = $1; $$->a2.p = $3; }
795: | term '*' term { $$ = f_new_inst(); $$->code = '*'; $$->a1.p = $1; $$->a2.p = $3; }
796: | term '/' term { $$ = f_new_inst(); $$->code = '/'; $$->a1.p = $1; $$->a2.p = $3; }
797: | term AND term { $$ = f_new_inst(); $$->code = '&'; $$->a1.p = $1; $$->a2.p = $3; }
798: | term OR term { $$ = f_new_inst(); $$->code = '|'; $$->a1.p = $1; $$->a2.p = $3; }
799: | term '=' term { $$ = f_new_inst(); $$->code = P('=','='); $$->a1.p = $1; $$->a2.p = $3; }
800: | term NEQ term { $$ = f_new_inst(); $$->code = P('!','='); $$->a1.p = $1; $$->a2.p = $3; }
801: | term '<' term { $$ = f_new_inst(); $$->code = '<'; $$->a1.p = $1; $$->a2.p = $3; }
802: | term LEQ term { $$ = f_new_inst(); $$->code = P('<','='); $$->a1.p = $1; $$->a2.p = $3; }
803: | term '>' term { $$ = f_new_inst(); $$->code = '<'; $$->a1.p = $3; $$->a2.p = $1; }
804: | term GEQ term { $$ = f_new_inst(); $$->code = P('<','='); $$->a1.p = $3; $$->a2.p = $1; }
805: | term '~' term { $$ = f_new_inst(); $$->code = '~'; $$->a1.p = $1; $$->a2.p = $3; }
806: | term NMA term { $$ = f_new_inst(); $$->code = P('!','~'); $$->a1.p = $1; $$->a2.p = $3; }
807: | '!' term { $$ = f_new_inst(); $$->code = '!'; $$->a1.p = $2; }
808: | DEFINED '(' term ')' { $$ = f_new_inst(); $$->code = P('d','e'); $$->a1.p = $3; }
809:
810: | symbol { $$ = $1; }
811: | constant { $$ = $1; }
812: | constructor { $$ = $1; }
813:
814: | PREFERENCE { $$ = f_new_inst(); $$->code = 'P'; }
815:
816: | rtadot static_attr { $$ = $2; $$->code = 'a'; }
817:
818: | rtadot dynamic_attr { $$ = $2; $$->code = P('e','a'); }
819:
820: | term '.' IP { $$ = f_new_inst(); $$->code = P('c','p'); $$->a1.p = $1; $$->aux = T_IP; }
821: | term '.' LEN { $$ = f_new_inst(); $$->code = 'L'; $$->a1.p = $1; }
822: | term '.' MASK '(' term ')' { $$ = f_new_inst(); $$->code = P('i','M'); $$->a1.p = $1; $$->a2.p = $5; }
823: | term '.' FIRST { $$ = f_new_inst(); $$->code = P('a','f'); $$->a1.p = $1; }
824: | term '.' LAST { $$ = f_new_inst(); $$->code = P('a','l'); $$->a1.p = $1; }
825: | term '.' LAST_NONAGGREGATED { $$ = f_new_inst(); $$->code = P('a','L'); $$->a1.p = $1; }
826:
827: /* Communities */
828: /* This causes one shift/reduce conflict
829: | rtadot dynamic_attr '.' ADD '(' term ')' { }
830: | rtadot dynamic_attr '.' DELETE '(' term ')' { }
831: | rtadot dynamic_attr '.' CONTAINS '(' term ')' { }
832: | rtadot dynamic_attr '.' RESET{ }
833: */
834:
835: | '+' EMPTY '+' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_PATH; }
836: | '-' EMPTY '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_CLIST; }
837: | '-' '-' EMPTY '-' '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_ECLIST; }
838: | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_new_inst(); $$->code = 'E'; $$->aux = T_LCLIST; }
839: | PREPEND '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('A','p'); $$->a1.p = $3; $$->a2.p = $5; }
840: | ADD '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'a'; }
841: | DELETE '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'd'; }
842: | FILTER '(' term ',' term ')' { $$ = f_new_inst(); $$->code = P('C','a'); $$->a1.p = $3; $$->a2.p = $5; $$->aux = 'f'; }
843:
844: | ROA_CHECK '(' SYM ')' { $$ = f_generate_roa_check($3, NULL, NULL); }
845: | ROA_CHECK '(' SYM ',' term ',' term ')' { $$ = f_generate_roa_check($3, $5, $7); }
846:
847: /* | term '.' LEN { $$->code = P('P','l'); } */
848:
849: /* function_call is inlined here */
850: | SYM '(' var_list ')' {
851: struct symbol *sym;
852: struct f_inst *inst = $3;
853: if ($1->class != SYM_FUNCTION)
854: cf_error("You can't call something which is not a function. Really.");
855: DBG("You are calling function %s\n", $1->name);
856: $$ = f_new_inst();
857: $$->code = P('c','a');
858: $$->a1.p = inst;
859: $$->a2.p = $1->def;
860: sym = $1->aux2;
861: while (sym || inst) {
862: if (!sym || !inst)
863: cf_error("Wrong number of arguments for function %s.", $1->name);
864: DBG( "You should pass parameter called %s\n", sym->name);
865: inst->a1.p = sym;
866: sym = sym->aux2;
867: inst = inst->next;
868: }
869: }
870: ;
871:
872: break_command:
873: QUITBIRD { $$ = F_QUITBIRD; }
874: | ACCEPT { $$ = F_ACCEPT; }
875: | REJECT { $$ = F_REJECT; }
876: | ERROR { $$ = F_ERROR; }
877: | PRINT { $$ = F_NOP; }
878: | PRINTN { $$ = F_NONL; }
879: ;
880:
881: print_one:
882: term { $$ = f_new_inst(); $$->code = 'p'; $$->a1.p = $1; $$->a2.p = NULL; }
883: ;
884:
885: print_list: /* EMPTY */ { $$ = NULL; }
886: | print_one { $$ = $1; }
887: | print_one ',' print_list {
888: if ($1) {
889: $1->next = $3;
890: $$ = $1;
891: } else $$ = $3;
892: }
893: ;
894:
895: var_listn: term {
896: $$ = f_new_inst();
897: $$->code = 's';
898: $$->a1.p = NULL;
899: $$->a2.p = $1;
900: $$->next = NULL;
901: }
902: | term ',' var_listn {
903: $$ = f_new_inst();
904: $$->code = 's';
905: $$->a1.p = NULL;
906: $$->a2.p = $1;
907: $$->next = $3;
908: }
909: ;
910:
911: var_list: /* EMPTY */ { $$ = NULL; }
912: | var_listn { $$ = $1; }
913: ;
914:
915: cmd:
916: IF term THEN block {
917: $$ = f_new_inst();
918: $$->code = '?';
919: $$->a1.p = $2;
920: $$->a2.p = $4;
921: }
922: | IF term THEN block ELSE block {
923: struct f_inst *i = f_new_inst();
924: i->code = '?';
925: i->a1.p = $2;
926: i->a2.p = $4;
927: $$ = f_new_inst();
928: $$->code = '?';
929: $$->a1.p = i;
930: $$->a2.p = $6;
931: }
932: | SYM '=' term ';' {
933: $$ = f_new_inst();
934: DBG( "Ook, we'll set value\n" );
935: if (($1->class & ~T_MASK) != SYM_VARIABLE)
936: cf_error( "You may set only variables." );
937: $$->code = 's';
938: $$->a1.p = $1;
939: $$->a2.p = $3;
940: }
941: | RETURN term ';' {
942: $$ = f_new_inst();
943: DBG( "Ook, we'll return the value\n" );
944: $$->code = 'r';
945: $$->a1.p = $2;
946: }
947: | rtadot dynamic_attr '=' term ';' {
948: $$ = $2;
949: $$->code = P('e','S');
950: $$->a1.p = $4;
951: }
952: | rtadot static_attr '=' term ';' {
953: $$ = $2;
954: if (!$$->a1.i)
955: cf_error( "This static attribute is read-only.");
956: $$->code = P('a','S');
957: $$->a1.p = $4;
958: }
959: | PREFERENCE '=' term ';' {
960: $$ = f_new_inst();
961: $$->code = P('P','S');
962: $$->a1.p = $3;
963: }
964: | UNSET '(' rtadot dynamic_attr ')' ';' {
965: $$ = $4;
966: $$->aux = EAF_TYPE_UNDEF | EAF_TEMP;
967: $$->code = P('e','S');
968: $$->a1.p = NULL;
969: }
970: | break_command print_list ';' { $$ = f_new_inst(); $$->code = P('p',','); $$->a1.p = $2; $$->a2.i = $1; }
971: | function_call ';' { $$ = $1; }
972: | CASE term '{' switch_body '}' {
973: $$ = f_new_inst();
974: $$->code = P('S','W');
975: $$->a1.p = $2;
976: $$->a2.p = build_tree( $4 );
977: }
978:
979:
980: | rtadot dynamic_attr '.' EMPTY ';' { $$ = f_generate_empty($2); }
981: | rtadot dynamic_attr '.' PREPEND '(' term ')' ';' { $$ = f_generate_complex( P('A','p'), 'x', $2, $6 ); }
982: | rtadot dynamic_attr '.' ADD '(' term ')' ';' { $$ = f_generate_complex( P('C','a'), 'a', $2, $6 ); }
983: | rtadot dynamic_attr '.' DELETE '(' term ')' ';' { $$ = f_generate_complex( P('C','a'), 'd', $2, $6 ); }
984: | rtadot dynamic_attr '.' FILTER '(' term ')' ';' { $$ = f_generate_complex( P('C','a'), 'f', $2, $6 ); }
985: ;
986:
987: CF_END
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to config.Y CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / filter