config.Y 11.4 KB
Newer Older
1
2
3
/*
 *	BIRD - filters
 *
4
 *	Copyright 1998,1999 Pavel Machek
5
6
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
7
 *
8
	FIXME (nonurgent): define keyword
9
	FIXME (for BGP): whole system of paths, path ~ string, path.prepend(), path.originate
10
	FIXME: create community lists
Pavel Machek's avatar
Pavel Machek committed
11
	FIXME: IP addresses in ipv6
12
13
14
15
16
17
18
19
20
21
22
 */

CF_HDR

#include "nest/bird.h"
#include "lib/resource.h"
#include "lib/socket.h"
#include "lib/timer.h"
#include "nest/protocol.h"
#include "nest/iface.h"
#include "nest/route.h"
23
#include <string.h>
24

25
26
#define P(a,b) ((a<<8) | b)

27
28
CF_DECLS

29
CF_KEYWORDS(FUNCTION, PRINT, PRINTN, CONST, UNSET, RETURN,
30
31
	ACCEPT, REJECT, ERROR, QUITBIRD,
	INT, BOOL, IP, PREFIX, PAIR, SET, STRING,
32
	IF, THEN, ELSE, CASE,
33
	TRUE, FALSE,
34
	FROM, GW, NET, MASK, SOURCE,
35
	LEN,
36
	DEFINED,
37
	FILTER, WHERE)
38

39
%nonassoc THEN
40
%nonassoc ELSE
41

42
%type <x> term block cmds cmd function_body constant print_one print_list var_list var_listn dynamic_attr function_call
43
%type <f> filter filter_body where_filter
44
%type <i> type break_command pair
Pavel Machek's avatar
Pavel Machek committed
45
%type <e> set_item set_items switch_body
46
%type <v> set_atom prefix prefix_s ipa
47
%type <s> decls declsn one_decl function_params 
48
49
50

CF_GRAMMAR

Martin Mareš's avatar
Martin Mareš committed
51
52
CF_ADDTO(conf, filter_def)
filter_def:
53
   FILTER SYM { cf_push_scope( $2 ); } filter_body {
54
55
     cf_define_symbol($2, SYM_FILTER, $4);
     $4->name = $2->name;
56
     DBG( "We have new filter defined (%s)\n", $2->name );
57
     cf_pop_scope();
58
59
60
   }
 ;

61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
type:
   INT { $$ = T_INT; }
 | BOOL { $$ = T_BOOL; }
 | IP { $$ = T_IP; }
 | PREFIX { $$ = T_PREFIX; }
 | PAIR { $$ = T_PAIR; }
 | STRING { $$ = T_STRING; }
 | type SET { 
	switch ($1) {
	  default:
		cf_error( "You can not create sets of this type\n" );
	  case T_INT: case T_IP: case T_PREFIX: case T_PAIR:
	}
	$$ = $1 | T_SET;
	}
 ;

78
79
one_decl:
   type SYM {
80
     cf_define_symbol($2, SYM_VARIABLE | $1, NULL);
81
     DBG( "New variable %s type %x\n", $2->name, $1 );
82
     $2->aux = 0;
83
84
85
86
87
88
     {
       struct f_val * val; 
       val = cfg_alloc(sizeof(struct f_val)); 
       val->type = $1; 
       $2->aux2 = val;
     }
89
     $$=$2;
90
91
92
   }
 ;

93
94
95
96
/* Decls with ';' at the end */
decls: /* EMPTY */ { $$ = NULL; }
 | one_decl ';' decls {
     $$ = $1;
97
     $$->aux = (int) $3;
98
99
100
   }
 ;

101
/* Declarations that have no ';' at the end. */
102
103
declsn: one_decl { $$ = $1; }
 | declsn ';' one_decl {
104
105
     $$ = $1;
     $$->aux = (int) $3;
106
107
108
   }
 ;

Martin Mareš's avatar
Martin Mareš committed
109
filter_body:
110
   function_body {
Martin Mareš's avatar
Martin Mareš committed
111
112
     struct filter *f = cfg_alloc(sizeof(struct filter));
     f->name = NULL;
113
     f->root = $1;
Martin Mareš's avatar
Martin Mareš committed
114
115
116
117
118
119
120
121
122
123
124
125
     $$ = f;
   }
 ;

filter:
   SYM {
     if ($1->class != SYM_FILTER) cf_error("No such filter");
     $$ = $1->def;
   }
 | filter_body
 ;

126
127
128
129
130
131
where_filter:
   WHERE term {
     /* Construct 'IF term THEN ACCEPT; REJECT;' */
     struct filter *f = cfg_alloc(sizeof(struct filter));
     struct f_inst *i, *acc, *rej;
     acc = f_new_inst();		/* ACCEPT */
132
     acc->code = P('p',',');
133
134
135
     acc->a1.p = NULL;
     acc->a2.i = F_ACCEPT;
     rej = f_new_inst();		/* REJECT */
136
     rej->code = P('p',',');
137
138
139
140
141
142
143
144
145
146
147
148
149
     rej->a1.p = NULL;
     rej->a2.i = F_REJECT;
     i = f_new_inst();			/* IF */
     i->code = '?';
     i->a1.p = $2;
     i->a2.p = acc;
     i->next = rej;
     f->name = NULL;
     f->root = i;
     $$ = f;
  }
 ;

150
function_params:
151
   '(' declsn ')' { DBG( "Have function parameters\n" ); $$=$2; }
152
 | '(' ')' { $$=NULL; }
153
 ;
154

155
156
157
function_body:
   decls '{' cmds '}' {
     $$ = $3;
158
   }
159
160
161
162
 ;

CF_ADDTO(conf, function_def)
function_def:
163
   FUNCTION SYM { DBG( "Begining of function %s\n", $2->name ); cf_push_scope($2); } function_params function_body {
164
     extern struct f_inst *startup_func;
165
     cf_define_symbol($2, SYM_FUNCTION, $5);
166
     if (!strcasecmp($2->name, "startup"))
167
	startup_func = $5;
168
     $2->aux = (int) $4;
169
     $2->aux2 = $5;
170
     DBG("Hmm, we've got one function here - %s\n", $2->name); 
171
     cf_pop_scope();
172
173
174
175
176
177
178
   }
 ;

/* Programs */

cmds: /* EMPTY */ { $$ = NULL; }
 | cmd cmds {
179
     if ($1) {
180
181
       if ($1->next)
	 bug("Command has next already set\n");
182
       $1->next = $2;
183
       $$ = $1;
184
     } else $$ = $2;
185
186
187
   }
 ;

188
block:
189
   cmd {
190
191
192
193
194
195
196
     $$=$1;
   }
 | '{' cmds '}' {
     $$=$2;
   }
 ;

197
198
199
200
201
202
203
204
205
206
207
/*
 * Simple types, their bison value is int
 */
pair:
   '(' NUM ',' NUM ')' { $$ = $2 << 16 | $4; }
 ;

/*
 * Complex types, their bison value is struct f_val
 */
prefix_s:
208
   IPA '/' NUM { $$.type = T_PREFIX; $$.val.px.ip = $1; $$.val.px.len = $3; if (ipa_nonzero(ipa_and($$.val.px.ip, ipa_not(ipa_mkmask($$.val.px.len))))) cf_error( "%I/%d is not really prefix\n", $$.val.px.ip, $$.val.px.len ); }
209
210
211
212
213
214
 ;

prefix:
   prefix_s { $$ = $1; }
 | prefix_s '+' { $$ = $1; $$.val.px.len |= LEN_PLUS; }
 | prefix_s '-' { $$ = $1; $$.val.px.len |= LEN_MINUS; }
215
 | prefix_s '{' NUM ',' NUM '}' { $$ = $1; $$.val.px.len |= LEN_RANGE | ($3 << 16) | ($5 << 8); }
216
217
218
 ;

ipa:
219
   IPA  { $$.type = T_IP; $$.val.px.ip = $1; }
220
221
 ;

222
set_atom:
223
224
225
226
   NUM  { $$.type = T_INT; $$.val.i = $1; }
 | pair { $$.type = T_PAIR; $$.val.i = $1; }
 | ipa  { $$ = $1; }
 | prefix { $$ = $1; }
227
228
229
230
231
232
233
234
235
236
237
238
 ; 

set_item:
   set_atom { $$ = f_new_tree(); $$->from = $$->to = $1 }
 | set_atom '.' '.' set_atom { $$ = f_new_tree(); $$->from = $1; $$->to = $4; }
 ;

set_items:
   set_item { $$ = $1; }
 | set_items ',' set_item { $$ = $3; $$->left = $1; }
 ;

Pavel Machek's avatar
Pavel Machek committed
239
240
241
242
243
244
245
246
247
248
249
250
251
switch_body: /* EMPTY */ { $$ = NULL; }
 | set_item ':' cmds switch_body {
     $$ = $1;
     $$->data = $3;
     $$->left = $4;
   }
 | ELSE ':' cmds {
     $$ = f_new_tree(); 
     $$->from.type = T_VOID; 
     $$->to.type = T_VOID;
     $$->data = $3;
   }
 ;
252

253
constant:
254
255
256
257
258
259
   CONST '(' expr ')' { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT; $$->a2.i = $3; }
 | NUM    { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_INT;  $$->a2.i = $1; }
 | TRUE   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_BOOL; $$->a2.i = 1;  }
 | FALSE  { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_BOOL; $$->a2.i = 0;  }
 | TEXT   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_STRING; $$->a2.p = $1; }
 | pair   { $$ = f_new_inst(); $$->code = 'c'; $$->aux = T_PAIR;  $$->a2.i = $1; }
260
 | ipa	   { NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; *val = $1; }
Pavel Machek's avatar
Pavel Machek committed
261
 | prefix_s {NEW_F_VAL; $$ = f_new_inst(); $$->code = 'C'; $$->a1.p = val; *val = $1; }
262
 | '[' 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" ); }
263
 | ENUM	  { $$ = f_new_inst(); $$->code = 'c'; $$->aux = $1 >> 16; $$->a2.i = $1 & 0xffff; }
264
265
 ;

266
267
268
269
270
271
/*
 *  Maybe there are no dynamic attributes defined by protocols.
 *  For such cases, we force the dynamic_attr list to contain
 *  at least an invalid token, so it's syntantically correct.
 */
CF_ADDTO(dynamic_attr, INVALID_TOKEN { $$ = NULL; })
272

Pavel Machek's avatar
Pavel Machek committed
273
rtadot: /* EMPTY, we are not permitted RTA. prefix */
Pavel Machek's avatar
Pavel Machek committed
274
 ;
275

276
277
278
279
280
281
function_call:
   SYM '(' var_list ')' {
     struct symbol *sym;
     struct f_inst *inst = $3;
     if ($1->class != SYM_FUNCTION)
       cf_error("You can not call something which is not function. Really.");
282
     DBG("You are calling function %s\n", $1->name);
283
284
285
286
287
288
289
290
     $$ = f_new_inst();
     $$->code = P('c','a');
     $$->a1.p = inst;
     $$->a2.p = $1->aux2;
     sym = (void *) $1->aux;
     while (sym || inst) {
       if (!sym || !inst)
	 cf_error("wrong number of arguments for function %s.", $1->name);
291
       DBG( "You should pass parameter called %s\n", sym->name);
292
293
294
295
296
297
298
       inst->a1.p = sym;
       sym = (void *) sym->aux;
       inst = inst->next;
     }
   }
 ;

299
term:
300
   '(' term ')'      { $$ = $2; }
301
 | term '+' term     { $$ = f_new_inst(); $$->code = '+';        $$->a1.p = $1; $$->a2.p = $3; }
302
 | term '=' term     { $$ = f_new_inst(); $$->code = P('=','='); $$->a1.p = $1; $$->a2.p = $3; }
303
304
305
306
307
308
 | term NEQ term { $$ = f_new_inst(); $$->code = P('!','=');     $$->a1.p = $1; $$->a2.p = $3; }
 | term '<' term     { $$ = f_new_inst(); $$->code = '<';        $$->a1.p = $1; $$->a2.p = $3; }
 | term LEQ term { $$ = f_new_inst(); $$->code = P('<','=');     $$->a1.p = $1; $$->a2.p = $3; }
 | term '>' term     { $$ = f_new_inst(); $$->code = '<';        $$->a1.p = $3; $$->a2.p = $1; }
 | term GEQ term { $$ = f_new_inst(); $$->code = P('<','=');     $$->a1.p = $3; $$->a2.p = $1; }
 | term '~' term     { $$ = f_new_inst(); $$->code = '~';        $$->a1.p = $1; $$->a2.p = $3; }
309
 | DEFINED '(' term ')' { $$ = f_new_inst(); $$->code = P('d','e');  $$->a1.p = $3; }
310

311
 | constant { $$ = $1; }
312
313
314
 | SYM {
     $$ = f_new_inst();
     switch ($1->class) {
315
       case SYM_VARIABLE | T_INT:
316
317
318
319
320
       case SYM_VARIABLE | T_PAIR:
       case SYM_VARIABLE | T_PREFIX:
       case SYM_VARIABLE | T_IP:
	 $$->code = 'C';
	 $$->a1.p = $1->aux2;
321
322
	 break;
       default:
323
	 cf_error("Can not use this class of symbol (%s,%x) as variable.", $1->name, $1->class );
324
325
     }
   }
326

Pavel Machek's avatar
Pavel Machek committed
327
 | rtadot FROM    { $$ = f_new_inst(); $$->code = 'a'; $$->aux = T_IP; $$->a2.i = OFFSETOF(struct rta, from); }
328

Pavel Machek's avatar
Pavel Machek committed
329
330
331
 | rtadot GW      { $$ = f_new_inst(); $$->code = 'a'; $$->aux = T_IP; $$->a2.i = OFFSETOF(struct rta, gw); }
 | rtadot NET     { $$ = f_new_inst(); $$->code = 'a'; $$->aux = T_PREFIX; $$->a2.i = 0x12345678; }
 | rtadot SOURCE  { $$ = f_new_inst(); $$->code = 'a'; $$->aux = T_ENUM_RTS; $$->a2.i = OFFSETOF(struct rta, gw); }
332

333
 | rtadot dynamic_attr { $$ = $2; $$->code = P('e','a'); }
334

335
336
337
338
 | term '.' IP { $$ = f_new_inst(); $$->code = P('c','p'); $$->a1.p = $1; $$->aux = T_IP; }
 | term '.' LEN { $$ = f_new_inst(); $$->code = P('c','p'); $$->a1.p = $1; $$->aux = T_INT; }
 | term '.' MASK '(' term ')' { $$ = f_new_inst(); $$->code = P('i','M'); $$->a1.p = $1; $$->a2.p = $5; }
 | function_call { $$ = $1; /* 1 shift/reduce conflict */ }
339
340
341
342
343
344
345
 ;

break_command:
   QUITBIRD { $$ = F_QUITBIRD }
 | ACCEPT { $$ = F_ACCEPT }
 | REJECT { $$ = F_REJECT }
 | ERROR { $$ = F_ERROR }
346
 | PRINT { $$ = F_NOP }
347
 | PRINTN { $$ = F_NONL }
348
349
 ;

350
print_one:
Pavel Machek's avatar
Pavel Machek committed
351
   term { $$ = f_new_inst(); $$->code = 'p'; $$->a1.p = $1; $$->a2.p = NULL; }
352
353
354
355
356
357
358
359
360
361
362
 ;

print_list: /* EMPTY */ { $$ = NULL; }
 | print_one print_list {
     if ($1) {
       $1->next = $2;
       $$ = $1;
     } else $$ = $2;
   }
 ;

363
var_listn: term { 
364
365
366
367
368
369
     $$ = f_new_inst();
     $$->code = 's';
     $$->a1.p = NULL;
     $$->a2.p = $1;
     $$->next = NULL;
   }
370
 | term ',' var_listn {
371
372
373
374
375
376
377
378
     $$ = f_new_inst();
     $$->code = 's';
     $$->a1.p = NULL;
     $$->a2.p = $1;
     $$->next = $3;
   }
 ;

379
380
381
382
var_list: /* EMPTY */ { $$ = NULL; }
 | var_listn { $$ = $1; }
 ;

383
cmd:
384
385
386
387
388
   IF term THEN block {
     $$ = f_new_inst();
     $$->code = '?';
     $$->a1.p = $2;
     $$->a2.p = $4;
389
   }
390
391
392
393
394
 | IF term THEN block ELSE block {
     struct f_inst *i = f_new_inst();
     i->code = '?';
     i->a1.p = $2;
     i->a2.p = $4;
395
396
     $$ = f_new_inst();
     $$->code = '?';
397
398
     $$->a1.p = i;
     $$->a2.p = $6;
399
   }
400
 | SYM '=' term ';' {
401
     $$ = f_new_inst();
402
     DBG( "Ook, we'll set value\n" );
403
404
     if (($1->class & ~T_MASK) != SYM_VARIABLE)
       cf_error( "You may only set variables, and this is %x.\n", $1->class );
405
     $$->code = 's';
Pavel Machek's avatar
Pavel Machek committed
406
407
     $$->a1.p = $1;
     $$->a2.p = $3;
408
   }
409
410
 | RETURN term ';' {
     $$ = f_new_inst();
411
     DBG( "Ook, we'll return the value\n" );
412
413
414
     $$->code = 'r';
     $$->a1.p = $2;
   }
415
 | rtadot dynamic_attr '=' term ';' {
Pavel Machek's avatar
Pavel Machek committed
416
     $$ = $2;
417
     $$->code  = P('e','S');
Pavel Machek's avatar
Pavel Machek committed
418
     $$->a1.p = $4;
419
   }
420
 | UNSET '(' rtadot dynamic_attr ')' ';' {
Pavel Machek's avatar
Pavel Machek committed
421
     $$ = $4;
422
     $$->aux = EAF_TYPE_UNDEF | EAF_TEMP;
423
     $$->code = P('e','S');
424
     $$->a1.p = NULL;
425
   }
426
427
 | break_command print_list ';' { $$ = f_new_inst(); $$->code = P('p',','); $$->a1.p = $2; $$->a2.i = $1; }
 | function_call ';' { $$ = $1; }
428
429
 | CASE term '{' switch_body '}' {
      $$ = f_new_inst();
430
      $$->code = P('S','W');
431
      $$->a1.p = $2;
Pavel Machek's avatar
Pavel Machek committed
432
      $$->a2.p = build_tree( $4 );
433
   }
434
435
436
 ;

CF_END