[insert project logo here (125x200px max)] Navigator Home Downloads Documentation Research News Forums Project Summary CVS repository Mailinglists Help Announcement Developer Please report any errors or ommissions you find to our `Help' mailinglist, or post a message in the Forums. Copyright and Licensing Information Snap is (c) Jonathan T. Moore, 1999-2002 and licensed under the GNU General Public License (GPL). All other parts of Splash are (c) Willem de Bruijn, 2002-2003 and licensed under the BSD Open Source License. All sourcecode is made publicly available. Acknowledgement Splash and the Splash website are hosted by SourceForge.net

Splash - Documentation SNMP Plus a Lightweight API for SNAP Handling             snap-1.1-wjdb/lib/snap_interp.c Go to the documentation of this file. /* $Id: snap_interp.c,v 1.14 2003/04/02 17:01:14 wdebruij Exp $ */ #include <asm/types.h> #include <netinet/ip.h> #include <sys/types.h> #include "bytecode.h" #include "config.h" #include "d_printf.h" #include "dyncheck.h" #include "io.h" #include "myassert.h" #include "packet.h" #include "timers.h" #include "exception.h" #include "wassert.h" #include "snap_kern_iface.h" #include "snap_svc_handler.h" #include "printval.h" #include "warn.h" #define NIPQUAD(addr) addr << 24 >> 24, addr << 16 >> 24, addr << 8 >> 24, addr >> 24 #ifdef CONFIG_IP_SNAP #ifndef __KERNEL__ extern int fprintf_value(packet_t *p, FILE *f, value_t *v); #endif /************************************************************************/ /* macros for use in interp_packet */ /* Dynamic type checks */ int heap_alloc(packet_t *p, int lenb, int flag, heap_obj **ho, int *hoffset) { int sizeb = lenb + sizeof(heap_obj); DYNCHECK(((void *)p->stack_max - sizeb) > (void *)p->sp); DYNCHECK(lenb <= MAX_HEAPOBJ_SZ); p->stack_max = (value_t *)((void *)p->stack_max - sizeb); *ho = (heap_obj *)((p)->stack_max); *hoffset = (void *)(p)->stack_max - (p)->heap_min; (*ho)->len = lenb; (*ho)->flag = flag; d_printf(100,"%s:%d: allocated %d-buf (f=%d) at %#x\n", __FILE__,__LINE__,lenb,flag,(unsigned int)ho); return 0; } #ifdef __KERNEL__ static void resize_to_max_buffer(packet_t *p, struct iphdr **interpiph) { struct sk_buff *tmp; struct iphdr *oldiph; struct iphdr *newiph; if (p->resized) { /* already resized it */ printk(KERN_WARNING "%s:%d: resizing already resized buffer\n", __FILE__,__LINE__); return; } if (!p->is_contiguous) { /* uh-oh */ printk(KERN_WARNING "%s:%d: resizing non-contiguous buffer\n", __FILE__,__LINE__); return; } d_printf(50,"%s:%d: growing buffer...\n",__FILE__,__LINE__); tmp = skb_grow(p->skb,3000); /* get the new buffer, copy data over */ /* see if there was any additional stack */ if ((void *)(p->sp) > (void *)(p->skb->tail)) { memcpy(tmp->tail, p->skb->tail, (char *)(p->sp) - (char *)(p->skb->tail)); } /* reset packet pointers */ oldiph = p->skb->nh.iph; newiph = tmp->nh.iph; *interpiph = newiph; p->hdr = (header_t *)((void *)newiph + (newiph->ihl << 2)); p->code_min = (instr_t *)((void *)p->hdr + sizeof(header_t)); p->pc = (instr_t *)((void *)newiph + ((void *)p->pc - (void *)oldiph)); p->code_max = (instr_t *)((void *)p->code_min + ntohs(p->hdr->code_sizeb)); p->handler = (instr_t *)((void *)newiph + ((void *)p->handler - (void *)oldiph)); p->heap_min = (void *)p->code_max; if (p->h_alloc_ptr != NULL) { printk(KERN_WARNING "%s:%d: p->h_alloc_ptr should be NULL\n", __FILE__,__LINE__); } p->heap_max = p->heap_min + ntohs(p->hdr->heap_sizeb); p->stack_min = (value_t *)p->heap_max; p->sp = (value_t *)((void *)newiph + ((void *)p->sp - (void *)oldiph)); p->stack_max = (value_t *)tmp->end; p->h_alloc_heap_max = tmp->end; p->resized = 1; p->is_contiguous = 1; d_printf(50,"%s:%d: resized packet: %d instrs, %d stack vals\n", __FILE__,__LINE__,p->code_max - p->code_min, p->sp - p->stack_min); d_printf(50,"%s:%d: hdr=0x%08x cmin=0x%08x pc=0x%08x cmax=0x%08x\n", __FILE__,__LINE__, (__u32)p->hdr, (__u32)p->code_min, (__u32)p->pc, (__u32)p->code_max); d_printf(50,"%s:%d: hmin=0x%08x hmax=0x%08x\n",__FILE__,__LINE__, (__u32)p->heap_min, (__u32)p->heap_max); d_printf(50,"%s:%d: smin=0x%08x sp=0x%08x smax=0x%08x\n", __FILE__,__LINE__, (__u32)p->stack_min, (__u32)p->sp, (__u32)p->stack_max); /* make the new buffer live, chuck old buffer */ kfree_skb(p->skb); p->skb = tmp; return; } #define ENSURE_STACK_ROOM(p,iph) \ { if (p->sp >= p->stack_max && !p->resized) \ resize_to_max_buffer(p,&(iph)); \ } #define ENSURE_HEAP_ROOM(p,iph) \ { if (!p->resized) \ resize_to_max_buffer(p,&(iph)); \ } #else #define ENSURE_STACK_ROOM(p,iph) #define ENSURE_HEAP_ROOM(p,iph) #endif /* __KERNEL__ */ #ifdef CONFIG_IP_SNAP #define DEBUGFMTCONCAT(fmt1,t,fmt2) \ (((t) == INTV) ? fmt1 "%d" fmt2 : \ (((t) == ADDRV) ? fmt1 "%d.%d.%d.%d" fmt2 : \ (((t) == TUPLEV) ? fmt1 "offs[%d]" fmt2 : \ (((t) == EXCV) ? fmt1 "exc(%d)" fmt2 : \ (((t) == STRV) ? fmt1 "\"%s\"" fmt2 : \ /* FLOATV */ fmt1 "%d.%06d" fmt2))))) #endif #ifdef ADDR_IN_HEAP #endif /* Instruction cases */ #define INTOP(t,op,opname) { \ value_t *top1 = p->sp - 1; \ value_t *top2 = p->sp - 2; \ int result; \ \ DYNCHECK(top2 >= p->stack_min); \ DYNCHECK_TAG(*top1,INTV); \ DYNCHECK_TAG(*top2,INTV); \ result = (t)GET_INT(*top2) op (t)GET_INT(*top1); \ wassert((result <= MAX_VINT) && (result >= MIN_VINT)); \ d_printf(10,"%s:%d: pc=%d: %s %d %d = %d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ GET_INT(*top2),GET_INT(*top1),result); \ SET_TAG(*top2,INTV); \ SET_INT(*top2,result); \ p->sp--; \ p->pc++; \ break; \ } #define INTFLOATOP(op,opname) { \ value_t *top1 = p->sp - 1; \ value_t *top2 = p->sp - 2; \ \ DYNCHECK(top2 >= p->stack_min); \ if (GET_TAG(*top1) == INTV) { \ int result; \ DYNCHECK_TAG(*top2,INTV); \ result = (int)GET_INT(*top2) op (int)GET_INT(*top1); \ wassert((result <= MAX_VINT) && (result >= MIN_VINT)); \ d_printf(10,"%s:%d: pc=%d: %s %d %d = %d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ GET_INT(*top2),GET_INT(*top1),result); \ SET_TAG(*top2,INTV); \ SET_INT(*top2,result); \ } else { \ float32 v1, v2, result; \ ENSURE_HEAP_ROOM(p,iph); \ top1 = p->sp - 1; \ top2 = p->sp - 2; \ DYNCHECK_TAG(*top1,FLOATV); \ DYNCHECK_TAG(*top2,FLOATV); \ GET_FLOAT(v1,p->heap_min,*top1); \ GET_FLOAT(v2,p->heap_min,*top2); \ result = v2 op v1; \ d_printf(10,"%s:%d: pc=%d: %s %d.%06d %d.%06d = %d.%06d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (int)v2,(int)((v2 - (int)v2) * 1000000), \ (int)v1,(int)((v1 - (int)v1) * 1000000), \ (int)result,(int)((result - (int)result) * 1000000)); \ SET_TAG(*top2,FLOATV); \ SET_FLOAT(*top2,result,p); \ } \ p->sp--; \ p->pc++; \ break; \ } #define INTFLOATOPI(op,opname) { \ value_t *top1 = p->sp - 1; \ value_t *top2 = p->sp - 2; \ \ DYNCHECK(top2 >= p->stack_min); \ if (GET_TAG(*top1) == INTV) { \ int result; \ DYNCHECK_TAG(*top2,INTV); \ result = (int)GET_INT(*top2) op (int)GET_INT(*top1); \ wassert((result <= MAX_VINT) && (result >= MIN_VINT)); \ d_printf(10,"%s:%d: pc=%d: %s %d %d = %d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ GET_INT(*top2),GET_INT(*top1),result); \ SET_TAG(*top2,INTV); \ SET_INT(*top2,result); \ } else { \ float32 v1, v2; \ int result; \ ENSURE_HEAP_ROOM(p,iph); \ top1 = p->sp - 1; \ top2 = p->sp - 2; \ DYNCHECK_TAG(*top1,FLOATV); \ DYNCHECK_TAG(*top2,FLOATV); \ GET_FLOAT(v1,p->heap_min,*top1); \ GET_FLOAT(v2,p->heap_min,*top2); \ result = v2 op v1; \ d_printf(10,"%s:%d: pc=%d: %s %d.%06d %d.%06d = %d.%06d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (int)v2,(int)((v2 - (int)v2) * 1000000), \ (int)v1,(int)((v1 - (int)v1) * 1000000), \ (int)result,(int)((result - (int)result) * 1000000)); \ SET_TAG(*top2,INTV); \ SET_INT(*top2,result); \ } \ p->sp--; \ p->pc++; \ break; \ } #define INTIMMOP(t,op,opname) { \ value_t *top = p->sp - 1; \ int lit; \ int result; \ \ DYNCHECK(top >= p->stack_min); \ DYNCHECK_TAG(*top,INTV); \ GET_LIT(lit,INTV,*p->pc); \ result = (t)GET_INT(*top) op (t)lit; \ wassert((result <= MAX_VINT) && (result >= MIN_VINT)); \ d_printf(10,"%s:%d: pc=%d: %s %d %d = %d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ GET_INT(*top),lit,result); \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ p->pc++; \ break; \ } #define INTFLOATIMMOP(op,opname) { \ value_t *top = p->sp - 1; \ \ DYNCHECK(top >= p->stack_min); \ if (GET_TAG(*top) == INTV) { \ int lit; \ int result; \ GET_LIT(lit,INTV,*p->pc); \ result = GET_INT(*top) op lit; \ wassert((result <= MAX_VINT) && (result >= MIN_VINT)); \ d_printf(10,"%s:%d: pc=%d: %s %d %d = %d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ GET_INT(*top),lit,result); \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ } else { \ float32 f1, lit, result; \ value_t v = ZERO_VALUE_T; \ ENSURE_HEAP_ROOM(p,iph); \ top = p->sp - 1; \ DYNCHECK_TAG(*top,FLOATV); \ COPY_LIT(v,FLOATV,*p->pc); \ GET_FLOAT(lit,p->heap_min,v); \ GET_FLOAT(f1,p->heap_min,*top); \ result = f1 op lit; \ d_printf(10,"%s:%d: pc=%d: %s %d.%06d %d.%06d = %d.%06d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (int)f1,(int)((f1 - (int)f1) * 1000000), \ (int)lit,(int)((lit - (int)lit) * 1000000), \ (int)result,(int)((result - (int)result) * 1000000)); \ SET_TAG(*top,FLOATV); \ SET_FLOAT(*top,result,p); \ } \ p->pc++; \ break; \ } #define INTFLOATIMMOPI(op,opname) { \ value_t *top = p->sp - 1; \ \ DYNCHECK(top >= p->stack_min); \ if (GET_TAG(*top) == INTV) { \ int lit; \ int result; \ GET_LIT(lit,INTV,*p->pc); \ result = GET_INT(*top) op lit; \ wassert((result <= MAX_VINT) && (result >= MIN_VINT)); \ d_printf(10,"%s:%d: pc=%d: %s %d %d = %d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ GET_INT(*top),lit,result); \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ } else { \ float32 f1, lit; \ int result; \ value_t v = ZERO_VALUE_T; \ ENSURE_HEAP_ROOM(p,iph); \ top = p->sp - 1; \ DYNCHECK_TAG(*top,FLOATV); \ COPY_LIT(v,FLOATV,*p->pc); \ GET_FLOAT(lit,p->heap_min,v); \ GET_FLOAT(f1,p->heap_min,*top); \ result = f1 op lit; \ d_printf(10,"%s:%d: pc=%d: %s %d.%06d %d.%06d = %d.%06d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (int)f1,(int)((f1 - (int)f1) * 1000000), \ (int)lit,(int)((lit - (int)lit) * 1000000), \ (int)result,(int)((result - (int)result) * 1000000)); \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ } \ p->pc++; \ break; \ } #define FLOATIMMOP(op,opname) { \ value_t *top = p->sp - 1; \ value_t v = ZERO_VALUE_T; \ float32 result, f1, lit; \ \ ENSURE_HEAP_ROOM(p,iph); \ top = p->sp - 1; \ DYNCHECK(top >= p->stack_min); \ DYNCHECK_TAG(*top,FLOATV); \ COPY_LIT(v,FLOATV,*p->pc); \ GET_FLOAT(lit,p->heap_min,v); \ GET_FLOAT(f1,p->heap_min,*top); \ result = f1 op lit; \ d_printf(10,"%s:%d: pc=%d: %s %d.%06d %d.%06d = %d.%06d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (int)f1,(int)((f1 - (int)f1) * 1000000), \ (int)lit,(int)((lit - (int)lit) * 1000000), \ (int)result,(int)((result - (int)result) * 1000000)); \ SET_TAG(*top,FLOATV); \ SET_FLOAT(*top,result,p); \ p->pc++; \ break; \ } #define FLOATIMMOPI(op,opname) { \ value_t *top = p->sp - 1; \ value_t v = ZERO_VALUE_T; \ float32 f1, lit; \ int result; \ \ ENSURE_HEAP_ROOM(p,iph); \ top = p->sp - 1; \ DYNCHECK(top >= p->stack_min); \ DYNCHECK_TAG(*top,FLOATV); \ COPY_LIT(v,FLOATV,*p->pc); \ GET_FLOAT(lit,p->heap_min,v); \ GET_FLOAT(f1,p->heap_min,*top); \ result = f1 op lit; \ d_printf(10,"%s:%d: pc=%d: %s %d.%06d %d.%06d = %d.%06d\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (int)f1,(int)((f1 - (int)f1) * 1000000), \ (int)lit,(int)((lit - (int)lit) * 1000000), \ (int)result,(int)((result - (int)result) * 1000000)); \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ p->pc++; \ break; \ } #define EQOP(res,opname) { \ value_t *top1 = p->sp - 1; \ value_t *top2 = p->sp - 2; \ int result; \ \ DYNCHECK(top2 >= p->stack_min); \ result = (res == eq_value(top1,top2,p)); \ if (result == -1) \ return -1; \ d_printf(10,"%s:%d: pc=%d: %s: (%s)\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (result ? "equal" : "not equal")); \ SET_TAG(*top2,INTV); \ SET_INT(*top2,result); \ p->sp--; \ p->pc++; \ break; \ } #ifndef SMALL_INSTRS #define EQOPI(res,opname) { \ value_t *top = p->sp - 1; \ int result; \ \ DYNCHECK(top >= p->stack_min); \ result = (res == eq_value(top,&p->pc->arg,p)); \ d_printf(125,"%s:%d: pc=%d: %s: (%s)\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ (result ? "equal" : "not equal")); \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ p->pc++; \ break; \ } #endif /************************************************************************/ static int eq_value(value_t *v1, value_t *v2, packet_t *p) { int result; TAG_T tag1 = GET_TAG(*v1); switch(tag1) { #ifdef SMALL_VALUES case INTV: case TUPLEV: case EXCV: case STRV: default: result = (*v1 == *v2); break; #else case EXCV: case INTV: default: result = (GET_INT(*v1) == GET_INT(*v2)) && (tag1 == GET_TAG(*v2)); break; case TUPLEV: case STRV: result = (GET_OFFS(*v1) == GET_OFFS(*v2)) && (tag1 == GET_TAG(*v2)); break; #endif case ADDRV: { uint32 addr1, addr2; if (tag1 == GET_TAG(*v2)) { GET_ADDR(addr1,p->heap_min,*v1); GET_ADDR(addr2,p->heap_min,*v2); result = (addr1 == addr2); } else result = 0; break; } case FLOATV: { float32 f1, f2; if (tag1 == GET_TAG(*v2)) { GET_FLOAT(f1,p->heap_min,*v1); GET_FLOAT(f2,p->heap_min,*v2); result = (f1 == f2); } else result = 0; break; } } return result; } /* assumes packet is well-formed on entry; returns -1 on failure */ #ifdef __KERNEL__ int snap_interp_packet(struct sk_buff *skb) { #else int snap_interp_packet(packet_t *p) { #endif #ifdef __KERNEL__ struct iphdr *iph = skb->nh.iph; packet_t pack; packet_t *p = &pack; #endif int done; #ifdef __KERNEL__ /* set up packet struct */ p->hdr = (header_t *)((void *)iph + (iph->ihl << 2)); p->rb = iph->ttl; p->code_min = (instr_t *)((void *)p->hdr + sizeof(header_t)); p->pc = p->code_min + ntohs(p->hdr->entry_point); p->code_max = (instr_t *)((void *)p->code_min + ntohs(p->hdr->code_sizeb)); p->handler = p->code_max; /* default handler */ p->heap_min = (void *)p->code_max; p->h_alloc_ptr = NULL; p->heap_max = p->heap_min + ntohs(p->hdr->heap_sizeb); p->stack_min = (value_t *)p->heap_max; p->sp = (value_t *)((void *)p->stack_min + ntohs(p->hdr->stack_sizeb)); p->stack_max = (value_t *)skb->end; p->h_alloc_heap_max = skb->end; p->resized = 0; /* haven't grown it yet */ p->is_contiguous = 1; p->skb = skb; #else p->rb = p->iph->ttl; #endif print_anti_timer(1,"interp_packet"); done = 0; assert(p->pc >= p->code_min); d_printf(40,"%s:%d: packet src: %d.%d.%d.%d, dst: %d.%d.%d.%d\n", __FILE__,__LINE__,NIPQUAD(p->hdr->saddr),NIPQUAD(p->hdr->daddr)); d_printf(40,"%s:%d: interp_packet: %d instrs, %d stack vals, ep=%d, rb=%d\n", __FILE__,__LINE__,p->code_max - p->code_min, p->sp - p->stack_min, ntohs(p->hdr->entry_point), p->iph->ttl); d_printf(50,"%s:%d: hdr=0x%08x cmin=0x%08x pc=0x%08x cmax=0x%08x\n", __FILE__,__LINE__, (__u32)p->hdr, (__u32)p->code_min, (__u32)p->pc, (__u32)p->code_max); d_printf(50,"%s:%d: hmin=0x%08x hmax=0x%08x\n",__FILE__,__LINE__, (__u32)p->heap_min, (__u32)p->heap_max); d_printf(50,"%s:%d: smin=0x%08x sp=0x%08x smax=0x%08x\n", __FILE__,__LINE__, (__u32)p->stack_min, (__u32)p->sp, (__u32)p->stack_max); #ifdef __KERNEL__ d_printf(100,"%s:%d: skb->head=0x%08x skb->data=0x%08x skb->tail=0x%08x skb->end=0x%08x\n", __FILE__,__LINE__, (__u32)skb->head, (__u32)skb->data, (__u32)skb->tail, (__u32)skb->end); #endif /* decrement resource bound on arrival */ { if (p->rb <= 1) { /* out of resource bound after decrement */ d_printf(1,"%s:%d: out of RB, dropping packet\n",__FILE__,__LINE__); #ifdef __KERNEL__ return -ICMP_TIME_EXCEEDED; #else return -1; #endif } p->rb--; } while(!done) { /* if we exactly fall off the end of the code, we can assume an implicit EXIT instruction */ if (p->pc == p->code_max) { done = 1; break; } DYNCHECK(p->pc < p->code_max); switch(GET_OP(*p->pc)) { case EXIT: d_printf(10,"%s:%d: pc=%d: EXIT\n",__FILE__,__LINE__, (p->pc - p->code_min)); done = 1; break; #ifndef SMALL_INSTRS case PUSH: d_printf(100,"%s:%d: interp: PUSH\n",__FILE__,__LINE__); ENSURE_STACK_ROOM(p,iph); DYNCHECK(p->sp < p->stack_max); COPY_VAL(*p->sp,p->pc->arg); p->sp++; p->pc++; break; #else #ifndef NDEBUG #define PUSHOP(t,opname,fmt,arg...) { \ ENSURE_STACK_ROOM(p,iph); \ DYNCHECK(p->sp < p->stack_max); \ COPY_LIT(*p->sp,t,*p->pc); \ d_printf(10,"%s:%d: pc=%d: %s " fmt "\n", \ __FILE__,__LINE__,(p->pc - p->code_min), \ opname,##arg); \ p->sp++; \ p->pc++; \ break; \ } #define PUSHWJDB(t,opname,val,fmt,arg...) { \ ENSURE_STACK_ROOM(p,iph); \ DYNCHECK(p->sp < p->stack_max); \ COPY_LIT(*p->sp,t,val); \ d_printf(10,"%s:%d: pc=%d: %s " fmt "\n", \ __FILE__,__LINE__,(p->pc - p->code_min), \ opname,##arg); \ p->sp++; \ p->pc++; \ break; \ } #else /* NDEBUG */ #define PUSHOP(t,opname,fmt,arg...) { \ ENSURE_STACK_ROOM(p,iph); \ DYNCHECK(p->sp < p->stack_max); \ COPY_LIT(*p->sp,t,*p->pc); \ p->sp++; \ p->pc++; \ break; \ } #endif /* NDEBUG */ case PINT: PUSHOP(INTV,"PINT","%d",GET_LIT_VAL(*p->pc)); case PADDR: PUSHOP(ADDRV,"PADDR","%u.%u.%u.%u", NIPQUAD(GET_ADDR_VAL(p->heap_min,*p->pc))); case PTUP: PUSHOP(TUPLEV,"PTUP","offs[%d]",GET_OFFS(*p->pc)); case PEXC: PUSHOP(EXCV,"PEXC","exc(%d)",GET_LIT_VAL(*p->pc)); case PSTR: PUSHOP(STRV,"PSTR","\"%s\"", GET_STR_VAL(p->heap_min,*p->pc)); case PFLT: PUSHOP(FLOATV,"PFLT","%d.%06d", (int)GET_FLT_VAL(p->heap_min,*p->pc), (int)((GET_FLT_VAL(p->heap_min,*p->pc) - (int)GET_FLT_VAL(p->heap_min,*p->pc)) * 1000000)); #endif case POP: d_printf(10,"%s:%d: pc=%d: POP\n",__FILE__,__LINE__, (p->pc - p->code_min)); DYNCHECK(p->sp > p->stack_min); p->sp--; p->pc++; break; case POPI: { int n; value_t *newsp; GET_LIT(n,INTV,*p->pc); DYNCHECK(n >= 0); d_printf(10,"%s:%d: pc=%d: POPI %d\n", __FILE__,__LINE__,(p->pc - p->code_min),n); newsp = p->sp - n; DYNCHECK(newsp >= p->stack_min); p->sp = newsp; p->pc++; break; } case PULL: { int n; value_t *src; d_printf(100,"%s:%d: interp: PULL\n",__FILE__,__LINE__); ENSURE_STACK_ROOM(p,iph); GET_LIT(n,INTV,*p->pc); DYNCHECK(n >= 0); src = p->sp - (n + 1); DYNCHECK(src >= p->stack_min); DYNCHECK(p->sp < p->stack_max); COPY_VAL(*p->sp,*src); #ifdef CONFIG_IP_SNAP_DEBUG d_printf(10,"%s:%d: pc=%d: PULL %d = ", __FILE__,__LINE__,(p->pc - p->code_min),n); if (sysctl_snap_debug_level == -1 || 10 <= sysctl_snap_debug_level) { printk_value(p,p->sp); printk("\n"); } #if 0 #define PULL_D_PRINTF(fmt,arg...) \ { d_printf(10,"%s:%d: pc=%d: PULL %d = " fmt "\n", \ __FILE__,__LINE__,(p->pc - p->code_min),n, \ ##arg); \ break; \ } switch(GET_TAG(*p->sp)) { case INTV: PULL_D_PRINTF("%d",GET_INT(*p->sp)); case ADDRV: PULL_D_PRINTF("%d.%d.%d.%d", NIPQUAD(GET_ADDR_VAL(p->heap_min,*p->sp))); case STRV: PULL_D_PRINTF("\"%s\"",GET_STR_VAL(p->heap_min,*p->sp)); case EXCV: PULL_D_PRINTF("exc(%d)",GET_LIT_VAL(*p->sp)); case TUPLEV: PULL_D_PRINTF("offs[%d]",GET_OFFS(*p->sp)); case FLOATV: PULL_D_PRINTF("%d.%06d", (int)GET_FLT_VAL(p->heap_min,*p->sp), (int)((GET_FLT_VAL(p->heap_min,*p->sp) - (int)GET_FLT_VAL(p->heap_min,*p->sp)) * 1000000)); } #undef PULL_D_PRINTF #endif /* if 0 */ #endif /* CONFIG_IP_SNAP_DEBUG */ p->sp++; p->pc++; break; } case PULLSTACK:{ int n; value_t *src; ENSURE_STACK_ROOM(p,iph); GET_LIT(n,INTV,*(p->sp -1)); DYNCHECK(n >= 0); src = p->sp - (n + 1); DYNCHECK(src >= p->stack_min); DYNCHECK(p->sp < p->stack_max); COPY_VAL(*(p->sp-1),*src); d_printf(100,"%s:%d: interp: PULLSTACK (from element %d)\n",__FILE__,__LINE__, n); p->pc++; break; } case STORE: { int n; value_t *src; value_t *dst; d_printf(100,"%s:%d: interp: STORE\n",__FILE__,__LINE__); GET_LIT(n,INTV,*p->pc); DYNCHECK(n >= 0); src = p->sp - 1; dst = p->sp - (n + 1); DYNCHECK(src >= p->stack_min); /* also effectively checks that the stack is non-empty */ COPY_VAL(*dst,*src); #ifdef CONFIG_IP_SNAP_DEBUG #define STORE_D_PRINTF(fmt,arg...) \ { d_printf(10,"%s:%d: pc=%d: STORE s[%d] := " fmt "\n", \ __FILE__,__LINE__,(p->pc - p->code_min),n, \ ##arg); \ break; \ } switch(GET_TAG(*src)) { case INTV: STORE_D_PRINTF("%d",GET_INT(*src)); case ADDRV: STORE_D_PRINTF("%d.%d.%d.%d", NIPQUAD(GET_ADDR_VAL(p->heap_min,*src))); case STRV: STORE_D_PRINTF("\"%s\"",GET_STR_VAL(p->heap_min,*src)); case EXCV: STORE_D_PRINTF("exc(%d)",GET_LIT_VAL(*src)); case TUPLEV: STORE_D_PRINTF("offs[%d]",GET_OFFS(*src)); case FLOATV: STORE_D_PRINTF("%d.%06d", (int)GET_FLT_VAL(p->heap_min,*src), (int)((GET_FLT_VAL(p->heap_min,*src) - (int)GET_FLT_VAL(p->heap_min,*src)) * 1000000)); } #undef STORE_D_PRINTF #endif /* CONFIG_IP_SNAP_DEBUG */ p->sp--; p->pc++; break; } case JI: { int jump; GET_LIT(jump,INTV,*p->pc); DYNCHECK(jump > 0); d_printf(10,"%s:%d: pc=%d: JI %d\n",__FILE__,__LINE__, (p->pc - p->code_min), jump); p->pc = p->pc + jump; break; } case PAJ: { value_t *top = p->sp - 1; int jump; int lit; DYNCHECK(top >= p->stack_min); GET_LIT(lit,INTV,*p->pc); DYNCHECK_TAG(*top,INTV); jump = GET_INT(*top); DYNCHECK(jump + lit > 0); d_printf(10,"%s:%d: pc=%d: PAJ %d + [%d] = %d\n",__FILE__,__LINE__, (p->pc - p->code_min),lit,jump,lit+jump); p->sp--; /* pop */ p->pc = p->pc + jump + lit; break; } case TPAJ: { value_t *top1 = p->sp - 1; value_t *top2 = p->sp - 2; int jump = 1; int lit; DYNCHECK(top2 >= p->stack_min); DYNCHECK_TAG(*top1,INTV); if (GET_INT(*top1) == 0) { GET_LIT(lit,INTV,*p->pc); DYNCHECK_TAG(*top2,INTV); jump = GET_INT(*top2); DYNCHECK(jump + lit > 0); d_printf(10,"%s:%d: pc=%d: TPAJ %d: top=0, branch %d+[%d]=%d\n", __FILE__,__LINE__,(p->pc - p->code_min), lit,lit,jump,jump + lit); jump += lit; } else { d_printf(10,"%s:%d: pc=%d: TPAJ %d: top=%d, falling thru\n", __FILE__,__LINE__,(p->pc - p->code_min), GET_LIT_VAL(*p->pc), GET_INT(*top1)); } p->sp = p->sp - 2; /* pop */ p->pc = p->pc + jump; break; } case BEZ: { value_t *top = p->sp - 1; int jump = 1; DYNCHECK(top >= p->stack_min); DYNCHECK_TAG(*top,INTV); if (GET_INT(*top) == 0) { GET_LIT(jump,INTV,*p->pc); DYNCHECK(jump > 0); d_printf(10,"%s:%d: pc=%d: BEZ %d: branching ahead\n", __FILE__,__LINE__,(p->pc - p->code_min),jump); } else { d_printf(100,"%s:%d: pc=%d: BEZ %d: falling thru\n", __FILE__,__LINE__,(p->pc - p->code_min),jump); } p->sp--; /* pop */ p->pc = p->pc + jump; break; } case BNE: { value_t *top = p->sp - 1; int jump = 1; DYNCHECK(top >= p->stack_min); DYNCHECK_TAG(*top,INTV); if (GET_INT(*top) != 0) { GET_LIT(jump,INTV,*p->pc); DYNCHECK(jump > 0); d_printf(10,"%s:%d: pc=%d: BNE %d: branching ahead\n", __FILE__,__LINE__,(p->pc - p->code_min),jump); } else { d_printf(10,"%s:%d: pc=%d: BNE %d: falling thru\n", __FILE__,__LINE__,(p->pc - p->code_min),jump); } p->sp--; /* pop */ p->pc = p->pc + jump; break; } case MKTUP: { int n, i, hoffset; value_t *newtop, *heapv, *cp; heap_obj *ho; ENSURE_HEAP_ROOM(p,iph); GET_LIT(n,INTV,*p->pc); DYNCHECK(n > 0); /* check for (n-2) trailing non-mktups */ DYNCHECK((p->pc + ((n-2) > 0 ? (n-2) : 0) < p->code_max)); #ifndef NDYNCHECK for(i=1; i<n-1; i++) { /* check for non-mktup */ DYNCHECK(GET_OP(p->pc[i]) != MKTUP); } #endif /* check that the initial arguments are on the stack */ newtop = (p->sp - n); /* where to store the tuple result */ DYNCHECK(newtop >= p->stack_min); /* perform the allocation */ if (!heap_alloc(p,n*sizeof(value_t),1,&ho,&hoffset)) { /* initialize the tuple entries */ for (heapv = (value_t *)(&ho->s[0]), cp = p->sp - n, i=0; i<n; i++, heapv++, cp++) { #ifdef CONFIG_IP_SNAP_DEBUG d_printf(50,"%s:%d: MKTUP copying ",__FILE__,__LINE__); if (sysctl_snap_debug_level == -1 || 50 <= sysctl_snap_debug_level) { printk_value(p,cp); printk(" ( *0x%08x = 0x%08x)\n",(__u32)cp,(unsigned int)(*cp)); } #endif *heapv = *cp; } /* store pointer on the stack */ SET_TAG(*newtop,TUPLEV); SET_OFFS(*newtop,hoffset); d_printf(10,"%s:%d: pc=%d: MKTUP %d: new offs[%d] = \n", __FILE__,__LINE__,(p->pc - p->code_min),n, GET_OFFS(*newtop)); p->sp = newtop + 1; #ifdef CONFIG_IP_SNAP_DEBUG if (sysctl_snap_debug_level == -1 || 10 <= sysctl_snap_debug_level) { printk_value(p,p->sp - 1); printk("\n"); } #endif } else /* allocation failed, quit */ return -1; p->pc++; break; } case NTH: { value_t *top1 = p->sp - 1; int n,offs; heap_obj *ho; DYNCHECK(top1 >= p->stack_min); DYNCHECK_TAG(*top1,TUPLEV); GET_LIT(n,INTV,*p->pc); DYNCHECK(n > 0); offs = GET_OFFS(*top1); ho = (heap_obj *)(p->heap_min + offs); DYNCHECK_IN_HEAP(ho); DYNCHECK((ho->len / 4) >= n); wassert((ho->len / 4) * 4 == ho->len); *top1 = ((value_t *)&(ho->s[0]))[n-1]; #ifdef CONFIG_IP_SNAP_DEBUG d_printf(10,"%s:%d: pc=%d: NTH %d: offs[%d].%d = ", __FILE__,__LINE__,(p->pc - p->code_min),n,offs,n); if (sysctl_snap_debug_level == -1 || 10 <= sysctl_snap_debug_level) { printk_value(p,top1); printk("\n"); } #endif /* CONFIG_IP_SNAP_DEBUG */ p->pc++; break; } case ISTUP: { /* unlike other ops, does not blow away top stack value */ value_t *top = p->sp - 1; int result; DYNCHECK(top >= p->stack_min); result = (GET_TAG(*top) == TUPLEV); DYNCHECK(p->sp < p->stack_max); SET_TAG(*p->sp,INTV); SET_INT(*p->sp,result); d_printf(10,"%s:%d: pc=%d: ISTUP: %s\n",__FILE__,__LINE__, (p->pc - p->code_min),(GET_INT(*p->sp)?"yes":"no")); p->sp++; p->pc++; break; } case LEN: { value_t *top = p->sp - 1; heap_obj *tup; int offs; DYNCHECK(top >= p->stack_min); DYNCHECK_TAG(*top,TUPLEV); offs = GET_OFFS(*top); tup = (heap_obj *)(p->heap_min + offs); DYNCHECK_IN_HEAP(tup); SET_TAG(*top,INTV); SET_INT(*top,tup->len / sizeof(value_t)); d_printf(10,"%s:%d: pc=%d: LEN: |offs[%d]|=%d\n",__FILE__,__LINE__, (p->pc - p->code_min),offs,GET_INT(*top)); p->pc++; break; } /* equality/inequality are polymorphic */ case EQ: EQOP(1,"EQ"); case NEQ: EQOP(0,"NEQ"); #ifndef SMALL_INSTRS case EQI: EQOPI(1,"EQI"); case NEQI: EQOPI(0,"NEQI"); /* these could be on floats or on ints */ case GTI: INTFLOATIMMOPI(>,"GTI"); case GEQI: INTFLOATIMMOPI(>=,"GEQI"); case LEQI: INTFLOATIMMOPI(<=,"LEQI"); case LTI: INTFLOATIMMOPI(<,"LTI"); case ADDI: INTFLOATIMMOP(+,"ADDI"); case SUBI: INTFLOATIMMOP(-,"SUBI"); case MULTI: INTFLOATIMMOP(*,"MULTI"); case DIVI: INTFLOATIMMOP(/,"DIVI"); #else #ifdef CONFIG_IP_SNAP_DEBUG #define EQOPI_D_PRINTF(opname,fmt1,fmt2,arg...) \ { d_printf(10,"%s:%d: pc=%d: %s " fmt1 ": eq? " fmt2 " (%s)\n", \ __FILE__,__LINE__,(p->pc - p->code_min),opname, \ ##arg,(result?"yes":"no")); \ break; \ } #define EQOPI(res,t,opname) \ { \ value_t v = ZERO_VALUE_T; \ int result; \ value_t *top = p->sp - 1; \ \ ENSURE_STACK_ROOM(p,iph); \ top = p->sp - 1; \ DYNCHECK(p->sp < p->stack_max); \ COPY_LIT(v,t,*p->pc); \ result = (res == eq_value(top,&v,p)); \ if (result == -1) \ return -1; \ switch(t) { \ case INTV: \ switch(GET_TAG(*top)) { \ case INTV: EQOPI_D_PRINTF(opname,"%d","%d",GET_INT(v),GET_INT(*top)); \ case ADDRV: EQOPI_D_PRINTF(opname,"%d","%d.%d.%d.%d",GET_INT(v), \ NIPQUAD(GET_ADDR_VAL(p->heap_min,*top))); \ case STRV: EQOPI_D_PRINTF(opname,"%d","\"%s\"",GET_INT(v), \ GET_STR_VAL(p->heap_min,*top)); \ case EXCV: EQOPI_D_PRINTF(opname,"%d","exc(%d)", \ GET_INT(v),GET_LIT_VAL(*top)); \ case TUPLEV: EQOPI_D_PRINTF(opname,"%d","offs[%d]", \ GET_INT(v),GET_OFFS(*top)); \ case FLOATV: EQOPI_D_PRINTF(opname,"%d","%d.%06d",GET_INT(v), \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top))); \ } \ break; \ case ADDRV: \ switch(GET_TAG(*top)) { \ case INTV: EQOPI_D_PRINTF(opname,"%d.%d.%d.%d","%d",\ NIPQUAD(GET_ADDR_VAL(p->heap_min,v)),GET_INT(*top)); \ case ADDRV: EQOPI_D_PRINTF(opname,"%d.%d.%d.%d","%d.%d.%d.%d", \ NIPQUAD(GET_ADDR_VAL(p->heap_min,v)), \ NIPQUAD(GET_ADDR_VAL(p->heap_min,*top))); \ case STRV: EQOPI_D_PRINTF(opname,"%d.%d.%d.%d","\"%s\"", \ NIPQUAD(GET_ADDR_VAL(p->heap_min,v)), \ GET_STR_VAL(p->heap_min,*top)); \ case EXCV: EQOPI_D_PRINTF(opname,"%d.%d.%d.%d","exc(%d)", \ NIPQUAD(GET_ADDR_VAL(p->heap_min,v)), \ GET_LIT_VAL(*top)); \ case TUPLEV: EQOPI_D_PRINTF(opname,"%d.%d.%d.%d","offs[%d]", \ NIPQUAD(GET_ADDR_VAL(p->heap_min,v)), \ GET_OFFS(*top)); \ case FLOATV: EQOPI_D_PRINTF(opname,"%d.%d.%d.%d","%d.%06d", \ NIPQUAD(GET_ADDR_VAL(p->heap_min,v)), \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top))); \ } \ break; \ case STRV: \ switch(GET_TAG(*top)) { \ case INTV: EQOPI_D_PRINTF(opname,"\"%s\"","%d", \ GET_STR_VAL(p->heap_min,v),GET_INT(*top)); \ case ADDRV: EQOPI_D_PRINTF(opname,"\"%s\"","%d.%d.%d.%d", \ GET_STR_VAL(p->heap_min,v), \ NIPQUAD(GET_ADDR_VAL(p->heap_min,*top))); \ case STRV: EQOPI_D_PRINTF(opname,"\"%s\"","\"%s\"", \ GET_STR_VAL(p->heap_min,v), \ GET_STR_VAL(p->heap_min,*top)); \ case EXCV: EQOPI_D_PRINTF(opname,"\"%s\"","exc(%d)", \ GET_STR_VAL(p->heap_min,v), \ GET_LIT_VAL(*top)); \ case TUPLEV: EQOPI_D_PRINTF(opname,"\"%s\"","offs[%d]", \ GET_STR_VAL(p->heap_min,v), \ GET_OFFS(*top)); \ case FLOATV: EQOPI_D_PRINTF(opname,"\"%s\"","%d.%06d", \ GET_STR_VAL(p->heap_min,v), \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top))); \ } \ break; \ case EXCV: \ switch(GET_TAG(*top)) { \ case INTV: EQOPI_D_PRINTF(opname,"exc(%d)","%d", \ GET_INT(v),GET_INT(*top)); \ case ADDRV: EQOPI_D_PRINTF(opname,"exc(%d)","%d.%d.%d.%d",GET_INT(v), \ NIPQUAD(GET_ADDR_VAL(p->heap_min,*top))); \ case STRV: EQOPI_D_PRINTF(opname,"exc(%d)","\"%s\"",GET_INT(v), \ GET_STR_VAL(p->heap_min,*top)); \ case EXCV: EQOPI_D_PRINTF(opname,"exc(%d)","exc(%d)", \ GET_INT(v),GET_LIT_VAL(*top)); \ case TUPLEV: EQOPI_D_PRINTF(opname,"exc(%d)","offs[%d]", \ GET_INT(v),GET_OFFS(*top)); \ case FLOATV: EQOPI_D_PRINTF(opname,"exc(%d)","%d.%06d",GET_INT(v), \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top))); \ } \ break; \ case TUPLEV: \ switch(GET_TAG(*top)) { \ case INTV: EQOPI_D_PRINTF(opname,"offs[%d])","%d", \ GET_OFFS(v),GET_INT(*top)); \ case ADDRV: EQOPI_D_PRINTF(opname,"offs[%d]","%d.%d.%d.%d",GET_OFFS(v), \ NIPQUAD(GET_ADDR_VAL(p->heap_min,*top))); \ case STRV: EQOPI_D_PRINTF(opname,"offs[%d]","\"%s\"",GET_OFFS(v), \ GET_STR_VAL(p->heap_min,*top)); \ case EXCV: EQOPI_D_PRINTF(opname,"offs[%d]","exc(%d)", \ GET_OFFS(v),GET_LIT_VAL(*top)); \ case TUPLEV: EQOPI_D_PRINTF(opname,"offs[%d]","offs[%d]", \ GET_OFFS(v),GET_OFFS(*top)); \ case FLOATV: EQOPI_D_PRINTF(opname,"offs[%d]","%d.%06d",GET_OFFS(v), \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top))); \ } \ break; \ case FLOATV: \ switch(GET_TAG(*top)) { \ case INTV: EQOPI_D_PRINTF(opname,"%d.%06d","%d", \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,v)), \ GET_INT(*top)); \ case ADDRV: EQOPI_D_PRINTF(opname,"%d.%06d","%d.%d.%d.%d", \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,v)), \ NIPQUAD(GET_ADDR_VAL(p->heap_min,*top))); \ case STRV: EQOPI_D_PRINTF(opname,"%d.%06d","\"%s\"", \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,v)), \ GET_STR_VAL(p->heap_min,*top)); \ case EXCV: EQOPI_D_PRINTF(opname,"%d.%06d","exc(%d)", \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,v)), \ GET_LIT_VAL(*top)); \ case TUPLEV: EQOPI_D_PRINTF(opname,"%d.%06d","offs[%d]", \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,v)), \ GET_OFFS(*top)); \ case FLOATV: EQOPI_D_PRINTF(opname,"%d.%06d","%d.%06d", \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,v)), \ FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top))); \ } \ break; \ } \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ p->pc++; \ break; \ } #else #define EQOPI(res,t,opname) \ { \ value_t v = ZERO_VALUE_T; \ int result; \ value_t *top = p->sp - 1; \ \ d_printf(100,"%s:%d: interp: %s\n",__FILE__,__LINE__, \ opname); \ ENSURE_STACK_ROOM(p,iph); \ top = p->sp - 1; \ DYNCHECK(p->sp < p->stack_max); \ COPY_LIT(v,t,*p->pc); \ result = (res == eq_value(top,&v,p)); \ if (result == -1) \ return -1; \ SET_TAG(*top,INTV); \ SET_INT(*top,result); \ p->pc++; \ break; \ } #define EQOPI_D_PRINTF(fmt,arg...) /**/ #endif case EQINT: EQOPI(1,INTV,"EQINT"); case EQADR: EQOPI(1,ADDRV,"EQADR"); case EQTUP: EQOPI(1,TUPLEV,"EQTUP"); case EQEXC: EQOPI(1,EXCV,"EQEXC"); case EQSTR: EQOPI(1,STRV,"EQSTR"); case EQFLT: EQOPI(1,FLOATV,"EQFLT"); case NQINT: EQOPI(0,INTV,"NQINT"); case NQADR: EQOPI(0,ADDRV,"NQADR"); case NQTUP: EQOPI(0,TUPLEV,"NQTUP"); case NQEXC: EQOPI(0,EXCV,"NQEXC"); case NQSTR: EQOPI(0,STRV,"NQSTR"); case NQFLT: EQOPI(0,FLOATV,"EQFLT"); /* floating point ops */ case FGTI: FLOATIMMOPI(>,"GTI"); case FGEQI: FLOATIMMOPI(>=,"GEQI"); case FLEQI: FLOATIMMOPI(<=,"LEQI"); case FLTI: FLOATIMMOPI(<,"LTI"); case FADDI: FLOATIMMOP(+,"ADDI"); case FSUBI: FLOATIMMOP(-,"SUBI"); case FMULI: FLOATIMMOP(*,"MULTI"); case FDIVI: FLOATIMMOP(/,"DIVI"); /* integer ops */ case GTI: INTIMMOP(int,>,"GTI"); case GEQI: INTIMMOP(int,>=,"GEQI"); case LEQI: INTIMMOP(int,<=,"LEQI"); case LTI: INTIMMOP(int,<,"LTI"); case ADDI: INTIMMOP(int,+,"ADDI"); case SUBI: INTIMMOP(int,-,"SUBI"); case MULTI: INTIMMOP(int,*,"MULTI"); case DIVI: INTIMMOP(int,/,"DIVI"); #undef EQOPI_D_PRINTF #endif /* integer and/or floating point relational and arithmetic operators */ case GT: INTFLOATOPI(>,"GT"); case GEQ: INTFLOATOPI(>=,"GEQ"); case LEQ: INTFLOATOPI(<=,"LEQ"); case LT: INTFLOATOPI(<,"LT"); case ADD: INTFLOATOP(+,"ADD"); case SUB: INTFLOATOP(-,"SUB"); case MULT: INTFLOATOP(*,"MULT"); case DIV: INTFLOATOP(/,"DIV"); case NEG: { value_t *top = p->sp - 1; DYNCHECK(top >= p->stack_min); if (GET_TAG(*top) == INTV) { int result; result = -(GET_INT(*top)); d_printf(10,"%s:%d: pc=%d: NEG: %d -> %d\n",__FILE__,__LINE__, (p->pc - p->code_min),GET_INT(*top),result); SET_TAG(*top,INTV); SET_INT(*top,result); } else { float32 v, result; ENSURE_HEAP_ROOM(p,iph); top = p->sp - 1; DYNCHECK_TAG(*top,FLOATV); GET_FLOAT(v,p->heap_min,*top); result = -v; d_printf(10,"%s:%d: pc=%d: NEG: %d.%06d -> %d.%06d\n", __FILE__,__LINE__,(p->pc - p->code_min), FLTINTPAIR(GET_FLT_VAL(p->heap_min,*top)), FLTINTPAIR(result)); SET_TAG(*top,FLOATV); SET_FLOAT(*top,result,p); } p->pc++; break; } /* 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 */ value_t *top3 = p->sp - 3; /* stack amount */ value_t *top4 = p->sp - 4; /* entry point */ int child_rb_arg; int st_amt; int ep; unsigned char child_ttl; __u32 dest; packet_t *pdup; DYNCHECK(top4 >= p->stack_min); DYNCHECK_TAG(*top1,ADDRV); GET_ADDR(dest,p->heap_min,*top1); DYNCHECK_TAG(*top2,INTV); child_rb_arg = GET_INT(*top2); DYNCHECK(child_rb_arg > 0); DYNCHECK(child_rb_arg <= p->rb); child_ttl = (unsigned char)child_rb_arg; DYNCHECK_TAG(*top3,INTV); st_amt = GET_INT(*top3); DYNCHECK_TAG(*top4,INTV); ep = GET_INT(*top4); DYNCHECK(ep >= 0); p->sp -= 4; pdup = pkt_dup(p); /* if (pdup == NULL) { */ /* warn("%s:%d: failed on pdup\n",__FILE__,__LINE__); */ /* return -1; */ /* } */ /* pdup->skb->nh.iph->daddr = dest; */ /* pdup->skb->nh.iph->ttl = child_ttl; */ /* pdup->hdr->entry_point = htons(ep); */ d_printf(10,"%s:%d: pc=%d: SEND [%d.%d.%d.%d] rb=%d ep=%d sa=%d\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest),child_ttl,ep,st_amt); DYNCHECK(child_ttl > 0); /* ok to do dyncheck here because packet will just get dropped anyway */ /* send the request. the last parameter distinguishes between SEND and DSEND */ if (snap_send_packet(p, (st_amt == -1) ? (p->sp - p->stack_min) : st_amt, dest, child_ttl, ep, GET_OP(*p->pc) == SEND ? 0 : 1)) { warn("%s:%d: SEND or DSEND snap_send_packet failed\n", __FILE__,__LINE__); return -1; } p->rb -= child_ttl; p->pc++; break; } #undef OLDSEND #ifdef OLDSEND case SEND: { value_t *top1 = p->sp - 1; /* dest addr */ value_t *top2 = p->sp - 2; /* RB to use */ value_t *top3 = p->sp - 3; /* stack amount */ value_t *top4 = p->sp - 4; /* entry point */ uint32 dest; int intrb; DYNCHECK(top4 >= p->stack_min); DYNCHECK_TAG(*top1,ADDRV); GET_ADDR(dest,p->heap_min,*top1); DYNCHECK_TAG(*top2,INTV); intrb = GET_INT(*top2); p->sp -= 3; /* pop; leave room for return value */ if (intrb > 0) { if (intrb <= p->rb) { uint32 dstcache; unsigned char rb = (unsigned char)intrb; unsigned char rb_cache; int ep,st_amt; DYNCHECK_TAG(*top3,INTV); st_amt = GET_INT(*top3); DYNCHECK_TAG(*top4,INTV); ep = GET_INT(*top4); dstcache = p->hdr->daddr; rb_cache = p->rb; iph->daddr = dest; /* iph->ttl = rb; */ /* p->hdr->entry_point = htons(ep); */ p->sp--; d_printf(50,"%s:%d: SEND about to call snap_send_packet()\n", __FILE__,__LINE__); snap_send_packet(p, (st_amt == -1) ? (p->sp - p->stack_min) : st_amt, dest); d_printf(150,"%s:%d: back from snap_send_packet\n", __FILE__,__LINE__); print_anti_timer(1,"interp_packet"); p->sp++; /* iph->daddr = dstcache; */ /* iph->ttl = (rb_cache - rb); */ d_printf(10,"%s:%d: pc=%d: SEND %u.%u.%u.%u rb=%d st=%d ep=%d\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest),rb,st_amt,ep); SET_TAG(*top4,INTV); SET_INT(*top4,0); done = 1; } /* not enough resource bound */ else { d_printf(10,"%s:%d: pc=%d: SEND %d.%d.%d.%d rb=%d st=%d ep=%d (NOT ENOUGH RB!!!)\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest),intrb,GET_INT(*top3),GET_INT(*top4)); SET_TAG(*top4,EXCV); SET_INT(*top4,E_NOT_ENOUGH_RB); } } /* non-positive resource bound */ else { d_printf(10,"%s:%d: pc=%d: SEND %d.%d.%d.%d rb=%d st=%d ep=%d (NON-POSITIVE RB!!!)\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest),intrb,GET_INT(*top3),GET_INT(*top4)); SET_TAG(*top4,EXCV); SET_INT(*top4,E_NON_POSITIVE_RB); } p->pc++; break; } #endif /* OLDSEND */ case HOP: { value_t *top1 = p->sp - 1; /* dest addr */ value_t *top2 = p->sp - 2; /* RB to use */ value_t *top3 = p->sp - 3; /* stack amount (-1 = whole stack) */ value_t *top4 = p->sp - 4; /* entry point */ uint32 dest; int rb; DYNCHECK(top4 >= p->stack_min); DYNCHECK_TAG(*top1,ADDRV); GET_ADDR(dest,p->heap_min,*top1); DYNCHECK_TAG(*top2,INTV); rb = GET_INT(*top2); p->sp -= 3; /* pop; leave room for return value */ if (rb > 0) { if (rb <= p->rb) { short rb_cache; int ep,st_amt; DYNCHECK_TAG(*top3,INTV); st_amt = GET_INT(*top3); DYNCHECK_TAG(*top4,INTV); ep = GET_INT(*top4); rb_cache = p->rb; p->hdr->entry_point = htons(ep); p->rb = rb; p->sp--; print_timer(1,"interp_packet"); snap_send_packet(p,st_amt,dest,rb,ep, 0); print_anti_timer(1,"interp_packet"); p->sp++; p->rb = rb_cache - rb; d_printf(10,"%s:%d: pc=%d: HOP %d.%d.%d.%d rb=%d st=%d ep=%d\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest), rb, st_amt, ep); SET_TAG(*top4,INTV); SET_INT(*top4,0); } /* not enough resource bound */ else { d_printf(10,"%s:%d: pc=%d: HOP %d.%d.%d.%d rb=%d st=%d ep=%d (NOT ENOUGH RB!!!)\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest), rb, GET_INT(*top3), GET_INT(*top4)); SET_TAG(*top4,EXCV); SET_INT(*top4,E_NOT_ENOUGH_RB); } } /* non-positive resource bound */ else { d_printf(10,"%s:%d: pc=%d: HOP %d.%d.%d.%d rb=%d st=%d ep=%d (NON-POSITIVE RB!!!)\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest), rb, GET_INT(*top3),GET_INT(*top4)); SET_TAG(*top4,EXCV); SET_INT(*top4,E_NON_POSITIVE_RB); } p->pc++; break; } case FORW: case DFORW: { int herep; print_timer(1,"interp_packet"); herep = ishere(p->hdr->daddr, p); print_anti_timer(1,"interp_packet"); if (herep) { d_printf(10,"%s:%d: pc=%d: FORW: at dest, falling thru\n", __FILE__,__LINE__,(p->pc - p->code_min)); } else { d_printf(10,"%s:%d: pc=%d: FORW: moving on\n", __FILE__,__LINE__,(p->pc - p->code_min)); DYNCHECK(p->rb > 0); /* OK to do dyncheck here because packet will just get dropped anyway */ print_timer(1,"interp_packet"); /* send the request. the last parameter distinguishes between FORW and DFORW */ if (snap_send_packet(p, p->sp - p->stack_min, p->hdr->daddr, p->rb, ntohs(p->hdr->entry_point), GET_OP(*p->pc) == FORW ? 0 : 1)) { warn("%s:%d: snap_send_packet failed\n", __FILE__,__LINE__); return -1; } print_anti_timer(1,"interp_packet"); p->rb = 0; done = 1; } p->pc++; break; } case FORWTO: case DFORWTO: { value_t *top = p->sp - 1; uint32_t dest; int herep; DYNCHECK(top >= p->stack_min); DYNCHECK_TAG(*top,ADDRV); GET_ADDR(dest,p->heap_min,*top); p->sp--; print_timer(1,"interp_packet"); herep = ishere(dest,p); print_anti_timer(1,"interp_packet"); if (!herep) { d_printf(10,"%s:%d: pc=%d: FORWTO [%u.%u.%u.%u]: moving on\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest)); print_timer(1,"interp_packet"); DYNCHECK(p->rb > 0); /* OK to do dyncheck here because packet will just get dropped anyway */ print_timer(1,"interp_packet"); /* send the request. the last parameter distinguishes between FORWTO and DFORWTO */ if (snap_send_packet(p, p->sp - p->stack_min, dest, p->rb, htons(p->hdr->entry_point), GET_OP(*p->pc) == FORWTO ? 0 : 1)) { warn("%s:%d: FORWTO snap_send_packet failed\n", __FILE__,__LINE__); return -1; } print_anti_timer(1,"interp_packet"); p->rb = 0; done = 1; } else { d_printf(10,"%s:%d: pc=%d: FORWTO [%u.%u.%u.%u]: at dest, falling thru\n", __FILE__,__LINE__,(p->pc - p->code_min), NIPQUAD(dest)); } p->pc++; break; } case STACKEMPTY : PUSHWJDB(INTV,"STACKEMPTY",(p->sp == p->stack_min ? 1 : 0),"%d",(p->sp == p->stack_min ? 1 : 0)); break; case STACKCOUNT : PUSHWJDB(INTV,"STACKCOUNT",(p->sp - p->stack_min),"%d",(p->sp - p->stack_min)); break; case DEMUX:{ value_t *top1 = p->sp - 1; value_t *top2 = p->sp - 2; int pnum = 0; char *s; int slen = 0; heap_obj *ho; DYNCHECK(top2 >= p->stack_min); DYNCHECK_TAG(*top1,INTV); pnum = GET_INT(*top1); DYNCHECK(pnum > 0); DYNCHECK_TAG(*top2,STRV); ho = (heap_obj *)(p->heap_min + GET_OFFS(*top2)); DYNCHECK_IN_HEAP(ho); s = (char *)&(ho->s); slen = ho->len; print_timer(1,"interp_packet"); d_printf(10,"%s:%d: pc=%d: DEMUX or DEMUXUDP [%d] bytes to port [%d]\n", __FILE__,__LINE__,(p->pc - p->code_min),slen, pnum); if (snap_demux_send(pnum,p,s,slen)) { warn("%s:%d: snap_demux_send failed\n", __FILE__,__LINE__); return -1; } print_anti_timer(1,"interp_packet"); p->sp -= 2; /* pop */ p->pc++; done = 1; /* exit after one demux */ return 0; /* return, avoid skb_free */ break; } case DEMUXI:{ value_t *top = p->sp - 1; int pnum = 0; char *s; int slen = 0; heap_obj *ho; DYNCHECK(top >= p->stack_min); GET_LIT(pnum,INTV,*p->pc); DYNCHECK(pnum > 0); DYNCHECK_TAG(*top,STRV); ho = (heap_obj *)(p->heap_min + GET_OFFS(*top)); DYNCHECK_IN_HEAP(ho); s = (char *)&(ho->s); slen = ho->len; print_timer(1,"interp_packet"); d_printf(10,"%s:%d: pc=%d: DEMUXI or DEMUXIUDP port %d : [%d] bytes\n", __FILE__,__LINE__,(p->pc - p->code_min),pnum,slen); if (snap_demux_send(pnum,p,s,slen)) { warn("%s:%d: snap_demux_send failed\n",__FILE__,__LINE__); return -1; } print_anti_timer(1,"interp_packet"); p->sp--; /* pop */ p->pc++; done = 1; /* exit after one demux */ return 0; /* return, avoid skb_free */ break; } case PRINT: { value_t *top = p->sp - 1; DYNCHECK(top >= p->stack_min); d_printf(10,"%s:%d: pc=%d: PRINT\n",__FILE__,__LINE__, (p->pc - p->code_min)); #ifdef __KERNEL__ printk(KERN_WARNING "print: "); printk_value(p,top); printk("\n"); #else fprintf(stderr,"snap_interp : print: "); fprintf_value(p,stderr,top); fprintf(stderr,"\n"); fflush(stderr); #endif p->pc++; break; } #ifdef CONFIG_IP_SNAP_SVCS #if 0 case SVCV: { int offs, retc; heap_obj *ho; char *s; ENSURE_HEAP_ROOM(p,iph); DYNCHECK(p->sp < p->stack_max); GET_LIT(offs,STRV,*p->pc); ho = (heap_obj *)(p->heap_min + offs); DYNCHECK_IN_HEAP(ho); s = (char *)&(ho->s); retc = lookup_value(p,s,p->sp); if (retc != 0) { /* not found */ d_printf(10,"%s:%d: pc=%d: SVCV \"%s\": (SERVICE NOT PRESENT!!!)\n", __FILE__,__LINE__, (p->pc - p->code_min),s); SET_TAG(*p->sp,EXCV); SET_INT(*p->sp,E_SERVICE_NOT_PRESENT); } else { d_printf(10,"%s:%d: pc=%d: SVCV \"%s\"\n",__FILE__,__LINE__, (p->pc - p->code_min),s); } p->sp++; p->pc++; break; } #endif case CALLS: { int offs; heap_obj *ho; char *s; ENSURE_HEAP_ROOM(p,iph); DYNCHECK(p->sp < p->stack_max); GET_LIT(offs,STRV,*p->pc); ho = (heap_obj *)(p->heap_min + offs); DYNCHECK_IN_HEAP(ho); s = (char *)&(ho->s); if (snap_svc_call_service(p,s)) { /* not found */ d_printf(10,"%s:%d: pc=%d: CALLS \"%s\": (SERVICE NOT PRESENT!!!)\n", __FILE__,__LINE__, (p->pc - p->code_min),s); SET_TAG(*p->sp,EXCV); SET_INT(*p->sp,E_SERVICE_NOT_PRESENT); p->sp++; } else { d_printf(10,"%s:%d: pc=%d: CALLS \"%s\"\n",__FILE__,__LINE__, (p->pc - p->code_min),s); } p->pc++; break; } #endif /* CONFIG_IP_SNAP_SVCS */ default: warn("%s: unknown opcode: 0x%x\n",__FILE__,GET_OP(*p->pc)); return -1; } } print_timer(1,"interp_packet"); d_printf(40,"%s:%d: packet exits normally\n",__FILE__,__LINE__); return 0; } #endif /* CONFIG_IP_SNAP */