snap_interp.c

一个学习SNMP项目：tmoerlan.

    /* integer arithmetic operators */
    case MOD: INTOP(int,%,"MOD");
    case MODI: INTIMMOP(int,%,"MODI");
    case XOR: INTOP(int,^,"XOR");
    case XORI: INTIMMOP(int,^,"XORI");

    case NOT: {
      value_t *top = p->sp - 1;
      int result;

      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,INTV);
      result = !(GET_INT(*top));
      d_printf(10,"%s:%d: pc=%d: NOT: %d -> %d\n",__FILE__,__LINE__,
	       (p->pc - p->code_min),GET_INT(*top),result);
      SET_TAG(*top,INTV);
      SET_INT(*top,result);
      p->pc++;
      break;
    }

    case LNOT: {
      value_t *top = p->sp - 1;
      int result;

      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,INTV);
      result = ~(GET_INT(*top));
      d_printf(10,"%s:%d: pc=%d: LNOT: 0x%x -> 0x%x\n",__FILE__,__LINE__,
	       (p->pc - p->code_min),GET_INT(*top),result);
      SET_TAG(*top,INTV);
      SET_INT(*top,result);
      p->pc++;
      break;
    }

    case AND: INTOP(int,&,"AND");
    case ANDI: INTIMMOP(int,&,"ANDI");
    case OR: INTOP(int,|,"OR");
    case ORI: INTIMMOP(int,|,"ORI");
    case LSHL: INTOP(int,<<,"LSHL");
    case LSHLI: INTIMMOP(int,<<,"LSHLI");
    case RSHL: INTOP(uint32,>>,"RSHL");
    case RSHLI: INTIMMOP(uint32,>>,"RSHLI");
    case RSHA: INTOP(int,>>,"RSHA");
    case RSHAI: INTIMMOP(int,>>,"RSHAI");

    case SNET: {
      value_t *top1 = p->sp - 1;
      value_t *top2 = p->sp - 2;
      uint32 result, a1, a2;

      d_printf(100,"%s:%d: interp: SNET\n",__FILE__,__LINE__);
      ENSURE_HEAP_ROOM(p,iph);
      top1 = p->sp - 1;
      top2 = p->sp - 2;
      DYNCHECK(top2 >= p->stack_min);
      DYNCHECK_TAG(*top1,ADDRV);
      DYNCHECK_TAG(*top2,ADDRV);
      GET_ADDR(a1,p->heap_min,*top1);
      GET_ADDR(a2,p->heap_min,*top2);
      result = a1 & a2;
      d_printf(10,"%s:%d: pc=%d: SNET %d.%d.%d.%d %d.%d.%d.%d = %d.%d.%d.%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(GET_ADDR_VAL(p->heap_min,*top1)),
	       NIPQUAD(GET_ADDR_VAL(p->heap_min,*top2)),
	       NIPQUAD(result));
      SET_TAG(*top2,ADDRV);
      SET_ADDR(*top2,result,p);
      p->sp--;
      p->pc++;
      break;
    }

    case SNETI: {
      value_t *top = p->sp - 1;
      uint32 a1, a2, result;

      ENSURE_HEAP_ROOM(p,iph);
      top = p->sp - 1;
      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,ADDRV);
#ifndef ADDR_IN_HEAP
      DYNCHECK_TAG(p->pc->arg,ADDRV);
	  GET_ADDR(a1
      GET_ADDR(a2,p->heap_min,p->pc->arg);
#else
      { 
	value_t v = ZERO_VALUE_T;
	COPY_LIT(v,ADDRV,*p->pc);
	GET_ADDR(a2,p->heap_min,v);
      }
#endif
      GET_ADDR(a1,p->heap_min,*top);
      result = a1 & a2;
      d_printf(10,"%s:%d: pc=%d: SNETI [%d.%d.%d.%d] %d.%d.%d.%d = %d.%d.%d.%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(a1),
	       NIPQUAD(a2),
	       NIPQUAD(result));
      SET_TAG(*top,ADDRV);
      SET_ADDR(*top,result,p);
      p->pc++;
      break;
    }

    case BCAST: {
      value_t *top1 = p->sp - 1;
      value_t *top2 = p->sp - 2;
      uint32 a1, a2, result;

      d_printf(100,"%s:%d: interp: BCAST\n",__FILE__,__LINE__);
      ENSURE_HEAP_ROOM(p,iph);
      top1 = p->sp - 1;
      top2 = p->sp - 2;
      DYNCHECK(top2 >= p->stack_min);
      DYNCHECK_TAG(*top1,ADDRV);
      DYNCHECK_TAG(*top2,ADDRV);
      GET_ADDR(a1,p->heap_min,*top1);
      GET_ADDR(a2,p->heap_min,*top2);
      result = a1 | ~a2;
      d_printf(10,"%s:%d: pc=%d: BCAST %d.%d.%d.%d %d.%d.%d.%d = %d.%d.%d.%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(a1),
	       NIPQUAD(a2),
	       NIPQUAD(result));
      SET_TAG(*top2,ADDRV);
      SET_ADDR(*top2,result,p);
      p->sp--;
      p->pc++;
      break;
    }

    case BCASTI: {
      value_t *top = p->sp - 1;
      uint32 a1, a2, result;

      ENSURE_HEAP_ROOM(p,iph);
      top = p->sp - 1;
      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,ADDRV);
#ifndef ADDR_IN_HEAP
      DYNCHECK_TAG(p->pc->arg,ADDRV);
      GET_ADDR(a2,p->heap_min,p->pc->arg);
#else
      { 
	value_t v = ZERO_VALUE_T;
	COPY_LIT(v,ADDRV,*p->pc);
	GET_ADDR(a2,p->heap_min,v);
      }
#endif
      GET_ADDR(a1,p->heap_min,*top);
      result = a1 | ~a2;
      d_printf(10,"%s:%d: pc=%d: BCASTI [%d.%d.%d.%d] %d.%d.%d.%d = %d.%d.%d.%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(a1),
	       NIPQUAD(a2),
	       NIPQUAD(result));
      SET_TAG(*top,ADDRV);
      SET_ADDR(*top,result,p);
      p->pc++;
      break;
    }

    case ISX: { /* unlike other ops, does not blow away top stack
		   value */
      value_t *top = p->sp - 1;
      int result;

      ENSURE_STACK_ROOM(p,iph);
      top = p->sp - 1;
      DYNCHECK(top >= p->stack_min);
      result = (GET_TAG(*top) == EXCV);
      DYNCHECK(p->sp < p->stack_max);
      d_printf(10,"%s:%d: pc=%d: ISX: (%s)\n",__FILE__,__LINE__,
	       (p->pc - p->code_min),(result?"yes":"no"));
      SET_TAG(*p->sp,INTV);
      SET_INT(*p->sp,result);
      p->sp++;
      p->pc++;
      break;
    }

    case GETRB: {
      ENSURE_STACK_ROOM(p,iph);
      DYNCHECK(p->sp < p->stack_max);
      SET_TAG(*p->sp,INTV);
      SET_INT(*p->sp, p->rb);
      d_printf(10,"%s:%d: pc=%d: GETRB = %d\n",__FILE__,__LINE__,
	       (p->pc - p->code_min),p->rb);
      p->sp++;
      p->pc++;
      break;
    }

    case GETSRC: {
      ENSURE_HEAP_ROOM(p,iph);
      DYNCHECK(p->sp < p->stack_max);
      SET_TAG(*p->sp,ADDRV);
      SET_ADDR(*p->sp,p->hdr->saddr,p);
      d_printf(10,"%s:%d: pc=%d: GETSRC = %d.%d.%d.%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(p->iph->saddr));
      p->sp++;
      p->pc++;
      break;
    }

    case GETDST: {
      ENSURE_HEAP_ROOM(p,iph);
      DYNCHECK(p->sp < p->stack_max);
      SET_TAG(*p->sp,ADDRV);
      SET_ADDR(*p->sp,p->hdr->daddr,p);
      d_printf(10,"%s:%d: pc=%d: GETDST = %d.%d.%d.%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(p->hdr->daddr));
      p->sp++;
      p->pc++;
      break;
    }

    case GETSPT: {
      ENSURE_STACK_ROOM(p,iph);
      DYNCHECK(p->sp < p->stack_max);
      SET_TAG(*p->sp,INTV);
      SET_INT(*p->sp,ntohs(p->hdr->sport));
      d_printf(10,"%s:%d: pc=%d: GETSPT = %d\n",__FILE__,__LINE__,
	       (p->pc - p->code_min),GET_INT(*p->sp));
      p->sp++;
      p->pc++;
      break;
    }

#if 0
    case GETLD: {

#define LOAD_INT(x) ((x) >> FSHIFT)
#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)

      int loadint = avenrun[0] + (FIXED_1/200);
      float loadavg = LOAD_INT(loadint) + (LOAD_FRAC(loadint) / 100.0);

      ENSURE_HEAP_ROOM(p,iph);
      DYNCHECK(p->sp < p->stack_max);
      d_printf(10,"%s:%d: pc=%d: GETLD = loadavg is %d.%0d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       LOAD_INT(loadint),LOAD_FRAC(loadint));
      SET_TAG(*p->sp,FLOATV);
      SET_FLOAT(*p->sp,loadavg,p);
      p->sp++;
      p->pc++;
      break;
#undef LOAD_INT
#undef LOAD_FRAC
    }
#endif

    case SETXH: {
      value_t *top = p->sp - 1;
      int newhandler_offs = -1;
      instr_t *newhandler;
      
      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,INTV);
      newhandler_offs = GET_INT(*top);
      newhandler = p->code_min + newhandler_offs;

      /* now check that handler falls within bounds */
      DYNCHECK(newhandler > p->pc);
      DYNCHECK(newhandler <= p->code_max);
      p->handler = newhandler;
      d_printf(10,"%s:%d: pc=%d: SETXH = new handler at pc=%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       newhandler_offs);
      p->sp--;			/* pop */
      p->pc++;
      break;
    }

    case RAISEX: {
      /* all control transfers must go forward */
      DYNCHECK(p->handler > p->pc);
      p->pc = p->handler;
      d_printf(10,"%s:%d: pc=%d: RAISEX = throwing to pc=%d\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       (p->handler - p->code_min));
      break;
    }

    case HERE: {
      __u32 myaddr;

      ENSURE_HEAP_ROOM(p,iph);
      DYNCHECK(p->sp < p->stack_max);
      SET_TAG(*p->sp,ADDRV);
      if (snap_here(&myaddr, p)) {
	warn("%s:%d: HERE failed!\n",__FILE__,__LINE__);
	return -1;
      }
      SET_ADDR(*p->sp,myaddr,p);
      d_printf(10,"%s:%d: pc=%d: HERE = %d.%d.%d.%d\n",__FILE__,__LINE__,
	       (p->pc - p->code_min),NIPQUAD(GET_ADDR_VAL(p->heap_min,
							  *p->sp)));
      p->sp++;
      p->pc++;
      break;
    }

    case ISHERE: {
      value_t *top = p->sp - 1;
      uint32 addr;
      int result;

      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,ADDRV);
      GET_ADDR(addr,p->heap_min,*top);
      print_timer(1,"interp_packet");
#ifdef __KERNEL__
      result = ishere(addr,p->skb);
#else
      result = ishere(addr,p);
#endif /* __KERNEL__ */
      print_anti_timer(1,"interp_packet");
      d_printf(10,"%s:%d: pc=%d: ISHERE [%d.%d.%d.%d]: (%s)\n",
	       __FILE__,__LINE__,(p->pc - p->code_min),
	       NIPQUAD(GET_ADDR_VAL(p->heap_min,*top)),
	       (result?"yes":"no"));
      SET_TAG(*top,INTV);
      SET_INT(*top,result);
      p->pc++;
      break;
    }

    case ROUTE: {
      value_t *top = p->sp - 1;
      uint32 *ret,addr;
#ifdef __KERNEL__
      struct rtable *rt;
#endif
      __u32 hop = 0;

      ENSURE_HEAP_ROOM(p,iph);
      top = p->sp - 1;
      DYNCHECK(top >= p->stack_min);
      DYNCHECK_TAG(*top,ADDRV);
      GET_ADDR(addr,p->heap_min,*top);
      print_timer(1,"interp_packet");

#ifdef __KERNEL__
      if (next_hop(&rt,addr,p->skb->nh.iph->tos)) {
#else
      if (next_hop(&hop,addr,p->iph->tos)) {
#endif
	/* no route found */
	hop = 0;
	ret = &hop;
      } else {
	ret = &hop;
      }

      print_anti_timer(1,"interp_packet");
      DYNCHECK(ret != NULL);
      if (*ret != 0) {
	d_printf(10,"%s:%d: pc=%d: ROUTE [%d.%d.%d.%d] = %d.%d.%d.%d\n",
		 __FILE__,__LINE__,(p->pc - p->code_min),
		 NIPQUAD(GET_ADDR_VAL(p->heap_min,*top)),
		 NIPQUAD(*ret));
	SET_TAG(*top,ADDRV);
	SET_ADDR(*top,*ret,p);
      }
      else {
	d_printf(10,"%s:%d: pc=%d: ROUTE [%d.%d.%d.%d] -> E_NO_ROUTE!!!\n",
		 __FILE__,__LINE__,(p->pc - p->code_min),
		 NIPQUAD(GET_ADDR_VAL(p->heap_min,*top)));
	SET_TAG(*top,EXCV);
	SET_INT(*top,E_NO_ROUTE);
      }
      p->pc++;
      break;
    }

    case RTDEV: {
      value_t *top = p->sp - 1;
      int err;
      uint32 addr;
      __u32 hop;
      int hop_out_if;

      ENSURE_HEAP_ROOM(p,iph);
      top = p->sp - 1;
      DYNCHECK(top >= p->stack_min);
      DYNCHECK(p->sp < p->stack_max);
      DYNCHECK_TAG(*top,ADDRV);
      GET_ADDR(addr,p->heap_min,*top);

      err = next_hop_and_dev(&hop,&hop_out_if,addr);

      if (err == 0) {
	d_printf(10,"%s:%d: pc=%d: RTDEV [%d.%d.%d.%d] = (%d.%d.%d.%d,%d)\n",
		 __FILE__,__LINE__,(p->pc - p->code_min),
		 NIPQUAD(GET_ADDR_VAL(p->heap_min,*top)),
		 NIPQUAD(hop), hop_out_if);
	SET_TAG(*top,ADDRV);
	SET_ADDR(*top,hop,p);
	SET_TAG(*p->sp,INTV);
	SET_INT(*p->sp,hop_out_if);
	p->sp++;
      } else {
	d_printf(10,"%s:%d: pc=%d: RTDEV [%d.%d.%d.%d] -> E_NO_ROUTE!!!\n",
		 __FILE__,__LINE__,(p->pc - p->code_min),
		 NIPQUAD(GET_ADDR_VAL(p->heap_min,*top)));
	SET_TAG(*top,EXCV);
	SET_INT(*top,E_NO_ROUTE);
      }
      p->pc++;
      break;
    }

    case SEND:
	case DSEND: {
      value_t *top1 = p->sp - 1; /* dest addr */
      value_t *top2 = p->sp - 2; /* RB to use */