filter.c 6.78 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 9
 *
 *	FIXME: local namespace for functions
 *	FIXME: switch (or how did we call it in final release?)
10 11 12 13 14 15 16 17 18 19 20 21
 */

#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"
22
#include "lib/string.h"
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
#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
43 44 45
#define ONEARG ARG(v1, a1.p)
#define TWOARGS ARG(v1, a1.p) \
		ARG(v2, a2.p)
46 47 48 49
#define TWOARGS_C TWOARGS \
                  if (v1.type != v2.type) \
		    runtime( "Can not operate with values of incompatible types" );

50 51 52 53 54 55 56 57 58 59 60
#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)
{
  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;
61 62
  case T_IP:
    return ipa_compare(v1.val.ip, v2.val.ip);
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
  default: return CMP_ERROR;
  }
}

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 );
}

99 100
static struct rte **f_rte;

101 102 103 104 105
static struct f_val
interpret(struct f_inst *what)
{
  struct symbol *sym;
  struct f_val v1, v2, res;
106
  int i,j,k;
107 108 109 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

  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 */
139 140 141 142 143 144 145 146

#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); \
147
    break;
148 149 150 151 152 153

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

154
    /* FIXME: Should be able to work with prefixes of limited sizes */
155 156
  case '~':
    TWOARGS;
157
    res.type = T_BOOL;
158 159 160
    if (((v1.type == T_INT) || (v1.type == T_IP)) && (v2.type == T_SET)) {
      res.val.i = !! find_tree(v2.val.t, v1);
      break;
161
    }
162
    runtime( "~ applied on unknown type pair" );
163 164
    break;

165
  /* Set to consant, a1 = type, a2 = value */
166
  case 's':
Pavel Machek's avatar
Pavel Machek committed
167 168
    ARG(v2, a2.p);
    sym = what->a1.p;
169 170 171 172 173 174 175 176 177 178 179
    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
180 181
    res.type = what->a1.i;
    res.val.i = (int) what->a2.p;
182
    break;
183 184 185
  case 'C':
    res = * ((struct f_val *) what->a1.p);
    break;
186
  case 'i':
Pavel Machek's avatar
Pavel Machek committed
187 188
    res.type = what->a1.i;
    res.val.i = * ((int *) what->a2.p);
189 190 191
    break;
  case 'p':
    ONEARG;
192
    val_print(v1);
193 194 195 196 197 198
    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
199
      ARG(res,a2.p);
200 201 202 203 204 205 206 207 208 209 210
      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
211
    switch (what->a2.i) {
212 213 214 215 216 217 218
    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
219
      res.val.i = what->a1.i;
220 221 222 223 224 225 226
      break;
    case F_NOP:
      break;
    default:
      bug( "unknown return type: can not happen");
    }
    break;
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
  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;
257 258 259 260
  case 'ca': /* CALL */
    ONEARG;
    res = interpret(what->a2.p);
    break;
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
  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 );

276
  f_rte = rte;
277 278 279 280 281 282 283 284 285 286 287 288 289
  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;
290 291
  if (startup_func) {
    printf( "Launching startup function...\n" );
292
    res = interpret(startup_func);
Pavel Machek's avatar
Pavel Machek committed
293
    if (res.type == F_ERROR)
294 295 296
      die( "Startup function resulted in error." );
    printf( "done\n" );
  }
297
}