filter.c 7.7 KB
Newer Older
1
2
3
4
5
6
/*
 *	Filters: utility functions
 *
 *	Copyright 1998 Pavel Machek <pavel@ucw.cz>
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
7
8
 *
 *	FIXME: local namespace for functions
9
10
11
12
13
14
15
16
17
18
19
20
 */

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/signal.h>
#include <setjmp.h>

#include "nest/bird.h"
#include "lib/lists.h"
#include "lib/resource.h"
#include "lib/socket.h"
21
#include "lib/string.h"
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include "nest/route.h"
#include "nest/protocol.h"
#include "nest/iface.h"
#include "conf/conf.h"
#include "filter/filter.h"

struct f_inst *startup_func = NULL;

#define runtime(x) do { \
    log( L_ERR x ); \
    res.type = T_RETURN; \
    res.val.i = F_ERROR; \
    return res; \
  } while(0)

#define ARG(x,y) \
	x = interpret(what->y); \
	if (x.type == T_RETURN) \
		return x;

Pavel Machek's avatar
Pavel Machek committed
42
43
44
#define ONEARG ARG(v1, a1.p)
#define TWOARGS ARG(v1, a1.p) \
		ARG(v2, a2.p)
45
46
47
48
#define TWOARGS_C TWOARGS \
                  if (v1.type != v2.type) \
		    runtime( "Can not operate with values of incompatible types" );

49
50
51
52
53
54
#define CMP_ERROR 999

/* Compare two values, returns -1, 0, 1 compared, ERROR 999 */
int
val_compare(struct f_val v1, struct f_val v2)
{
55
56
  if (v1.type != v2.type)
    return CMP_ERROR;
57
58
59
60
61
  switch (v1.type) {
  case T_INT: 
    if (v1.val.i == v2.val.i) return 0;
    if (v1.val.i < v2.val.i) return -1;
    return 1;
62
63
  case T_IP:
    return ipa_compare(v1.val.ip, v2.val.ip);
64
65
66
67
  default: return CMP_ERROR;
  }
}

68
69
70
71
72
73
74
75
int
val_in_range(struct f_val v1, struct f_val v2)
{
  if (((v1.type == T_INT) || (v1.type == T_IP)) && (v2.type == T_SET))
    return !! find_tree(v2.val.t, v1);
  return CMP_ERROR;
}

76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
static void
tree_print(struct f_tree *t)
{
  if (!t) {
    printf( "() " );
    return;
  }
  printf( "[ " );
  tree_print( t->left );
  printf( ", " ); val_print( t->from ); printf( ".." ); val_print( t->to ); printf( ", " );
  tree_print( t->right );
  printf( "] " );
}

void
val_print(struct f_val v)
{
  char buf[2048];
#define PRINTF(a...) bsnprintf( buf, 2040, a )
  buf[0] = 0;
  switch (v.type) {
  case T_VOID: PRINTF( "(void)" ); break;
  case T_BOOL: PRINTF( v.val.i ? "TRUE" : "FALSE" ); break;
  case T_INT: PRINTF( "%d ", v.val.i ); break;
  case T_STRING: PRINTF( "%s", v.val.s ); break;
  case T_IP: PRINTF( "%I", v.val.ip ); break;
  case T_SET: tree_print( v.val.t ); PRINTF( "\n" ); break;
  default: PRINTF( "[unknown type %x]", v.type );
  }
  printf( buf );
}

108
109
static struct rte **f_rte;

110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
static struct f_val interpret(struct f_inst *what);

static struct f_val
interpret_switch(struct f_inst *what, struct f_val control)
{
  struct f_val this, res;
  int i;
  res.type = T_VOID;

  if (!what)
    return res;

  switch(what->code) {
  case 'el':
    return interpret(what->a2.p);

  case 'of':
    this = interpret(what->a1.p);
    i = val_compare(control, this);
    if (!i)
      return interpret(what->a2.p);
    if (i==CMP_ERROR) {
      i = val_in_range(control, this);
      if (i==1)
	return interpret(what->a2.p);
      if (i==CMP_ERROR)
	runtime( "incompatible types in case" );
    }
    break;
    
  default:
    bug( "This can not happen (%x)\n", what->code );
  }
  return interpret_switch(what->next, control);
}

146
147
148
149
150
static struct f_val
interpret(struct f_inst *what)
{
  struct symbol *sym;
  struct f_val v1, v2, res;
151
  int i,j,k;
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

  res.type = T_VOID;
  if (!what)
    return res;

  switch(what->code) {
  case ',':
    TWOARGS;
    break;

/* Binary operators */
  case '+':
    TWOARGS_C;
    switch (res.type = v1.type) {
    case T_VOID: runtime( "Can not operate with values of type void" );
    case T_INT: res.val.i = v1.val.i + v2.val.i; break;
    default: runtime( "Usage of unknown type" );
    }
    break;
  case '/':
    TWOARGS_C;
    switch (res.type = v1.type) {
    case T_VOID: runtime( "Can not operate with values of type void" );
    case T_INT: res.val.i = v1.val.i / v2.val.i; break;
    case T_IP: if (v2.type != T_INT)
                 runtime( "Operator / is <ip>/<int>" );
               break;
    default: runtime( "Usage of unknown type" );
    }
    break;

/* Relational operators */
184
185
186
187
188
189
190
191

#define COMPARE(x) \
    TWOARGS_C; \
    res.type = T_BOOL; \
    i = val_compare(v1, v2); \
    if (i==CMP_ERROR) \
      runtime( "Error in comparation" ); \
    res.val.i = (x); \
192
    break;
193
194
195
196
197
198

  case '!=': COMPARE(i!=0);
  case '==': COMPARE(i==0);
  case '<': COMPARE(i==-1);
  case '<=': COMPARE(i!=1);

199
    /* FIXME: Should be able to work with prefixes of limited sizes */
200
201
  case '~':
    TWOARGS;
202
    res.type = T_BOOL;
203
204
205
    res.val.i = val_in_range(v1, v2);
    if (res.val.i == CMP_ERROR)
      runtime( "~ applied on unknown type pair" );
206
207
    break;

208
  /* Set to consant, a1 = type, a2 = value */
209
  case 's':
Pavel Machek's avatar
Pavel Machek committed
210
211
    ARG(v2, a2.p);
    sym = what->a1.p;
212
213
214
215
216
217
218
219
220
221
222
    switch (res.type = v2.type) {
    case T_VOID: runtime( "Can not assign void values" );
    case T_INT: 
      if (sym->class != (SYM_VARIABLE | T_INT))
	runtime( "Variable of bad type" );
      sym->aux = v2.val.i; 
      break;
    }
    break;

  case 'c':
Pavel Machek's avatar
Pavel Machek committed
223
224
    res.type = what->a1.i;
    res.val.i = (int) what->a2.p;
225
    break;
226
227
228
  case 'C':
    res = * ((struct f_val *) what->a1.p);
    break;
229
  case 'i':
Pavel Machek's avatar
Pavel Machek committed
230
231
    res.type = what->a1.i;
    res.val.i = * ((int *) what->a2.p);
232
233
234
    break;
  case 'p':
    ONEARG;
235
    val_print(v1);
236
237
238
239
240
241
    break;
  case '?':	/* ? has really strange error value, so we can implement if ... else nicely :-) */
    ONEARG;
    if (v1.type != T_BOOL)
      runtime( "If requires bool expression" );
    if (v1.val.i) {
Pavel Machek's avatar
Pavel Machek committed
242
      ARG(res,a2.p);
243
244
245
246
247
248
249
250
251
252
253
      res.val.i = 0;
    } else res.val.i = 1;
    res.type = T_BOOL;
    break;
  case '0':
    printf( "No operation\n" );
    break;
  case 'p,':
    ONEARG;
    printf( "\n" );

Pavel Machek's avatar
Pavel Machek committed
254
    switch (what->a2.i) {
255
256
257
258
259
260
261
    case F_QUITBIRD:
      die( "Filter asked me to die" );
    case F_ACCEPT:
      /* Should take care about turning ACCEPT into MODIFY */
    case F_ERROR:
    case F_REJECT:
      res.type = T_RETURN;
Pavel Machek's avatar
Pavel Machek committed
262
      res.val.i = what->a1.i;
263
264
265
266
267
268
269
      break;
    case F_NOP:
      break;
    default:
      bug( "unknown return type: can not happen");
    }
    break;
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
  case 'a':	/* rta access */
    {
      struct rta *rta = (*f_rte)->attrs;
      res.type = what->a1.i;
      switch(res.type) {
      case T_IP:
	res.val.ip = * (ip_addr *) ((char *) rta + what->a2.i);
	break;
      case T_PREFIX:	/* Warning: this works only for prefix of network */
	{
	  res.val.px.ip = (*f_rte)->net->n.prefix;
	  res.val.px.len = (*f_rte)->net->n.pxlen;
	  break;
	}
      default:
	bug( "Invalid type for rta access" );
      }
    }
    break;
  case 'cp':	/* Convert prefix to ... */
    ONEARG;
    if (v1.type != T_PREFIX)
      runtime( "Can not convert non-prefix this way" );
    res.type = what->a2.i;
    switch(res.type) {
    case T_INT:	res.val.i = v1.val.px.len; break;
    case T_IP: res.val.ip = v1.val.px.ip; break;
    default: bug( "Unknown prefix to conversion\n" );
    }
    break;
300
301
302
303
  case 'ca': /* CALL */
    ONEARG;
    res = interpret(what->a2.p);
    break;
304
305
306
307
  case 'sw': /* SWITCH alias CASE */
    ONEARG;
    interpret_switch(what->a2.p, v1);
    break;
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
  default:
    bug( "Unknown instruction %d (%c)", what->code, what->code & 0xff);
  }
  if (what->next)
    return interpret(what->next);
  return res;
}

int
f_run(struct filter *filter, struct rte **rte, struct ea_list **tmp_attrs, struct linpool *tmp_pool)
{
  struct f_inst *inst;
  struct f_val res;
  debug( "Running filter `%s'...", filter->name );

323
  f_rte = rte;
324
325
326
327
328
329
330
331
332
333
334
335
336
  inst = filter->root;
  res = interpret(inst);
  if (res.type != T_RETURN)
    return F_ERROR;
  debug( "done (%d)\n", res.val.i );
  return res.val.i;
}


void
filters_postconfig(void)
{
  struct f_val res;
337
338
  if (startup_func) {
    printf( "Launching startup function...\n" );
339
    res = interpret(startup_func);
Pavel Machek's avatar
Pavel Machek committed
340
    if (res.type == F_ERROR)
341
342
343
      die( "Startup function resulted in error." );
    printf( "done\n" );
  }
344
}