snap_bytecode.c

一个学习SNMP项目：tmoerlan.

/* $Id: snap_bytecode.c,v 1.2 2003/09/17 11:26:10 tmoerlan Exp $ */

#ifdef __KERNEL__
#include <linux/kernel.h>
#include <linux/ctype.h>
#include <snap/bytecode.h>
#include <snap/dyncheck.h>
#include <snap/wassert.h>
#include <snap/packet.h>
#else
#include <stdlib.h>
#include <ctype.h>
#include <netinet/in.h>
#include <stdio.h>
#include "bytecode.h"
#include "dyncheck.h"
#include "wassert.h"
#include "packet.h"
#endif /* __KERNEL__ */

#ifndef __KERNEL__
int fprintf_addr(FILE *f, uint32_t addr) {
  /* in network byte order */
  return fprintf(f,"%u:%u:%u:%u",addr << 24 >> 24, addr << 16 >> 24, addr << 8 >> 24, addr >> 24);
}

int sprintf_addr(char *buf, uint32_t addr) {
  /* in network byte order */
  return sprintf(buf,"%u:%u:%u:%u",addr << 24 >> 24, addr << 16 >> 24, addr << 8 >> 24, addr >> 24);
}

int fprintf_value_tag(FILE *f,TAG_T tag) {
  switch(tag) {
  case INTV: return fprintf(f,"INTV"); break;
  case ADDRV: return fprintf(f,"ADDRV"); break;
  case STRV: return fprintf(f,"STRV"); break;
  case EXCV: return fprintf(f,"EXCV"); break;
  case TUPLEV: return fprintf(f,"TUPLEV"); break;
  case FLOATV: return fprintf(f,"FLOATV"); break;
  default: return fprintf(f,"BOGUSV"); break;
  }
}

/* 
	these DEFINEs are necessary for fprintf_value_heap to work
	
	we need this if we want to print without access to the packet
	for instace after a DEMUX

	I've copied this from bytecode.h in snaputils-0.1 and added the _HEAP
	for compatibility
*/
#define GET_TAG_HEAP(v) ((v) >> (sizeof(unsigned int)*8-TAGSZ))
#define SET_TAG_HEAP(v,t) ((v) = (((v) << TAGSZ) >> TAGSZ) | ((t) << (sizeof(unsigned int)*8-TAGSZ)))

#define GET_INT_HEAP(v) (((int)((v) << TAGSZ)) >> TAGSZ)
#define SET_INT_HEAP(v,i) ((v) = (((v) >> (sizeof(unsigned int)*8-TAGSZ)) << (sizeof(unsigned int)*8-TAGSZ)) | ((((unsigned int)(i)) << TAGSZ) >> TAGSZ))

#define GET_OFFS_HEAP GET_INT_HEAP
#define SET_OFFS_HEAP SET_INT_HEAP

#ifndef ADDR_IN_HEAP
#define GET_ADDR_HEAP(res,unused,val) ((res) = (val).v.addrval)
#define SET_ADDR_HEAP(val,a,unused) ((val).v.addrval = (a))

#define GET_FLOAT_HEAP(res,unused,val) ((res) = (val).v.floatval)
#define SET_FLOAT_HEAP(val,a,unused) ((val).v.floatval = (a))

#endif

int fprintf_value_heap(void *heap,FILE *f,value_t *val) {
  switch(GET_TAG(*val)) {
    case INTV: fprintf(f,"%d",GET_INT_HEAP(*val)); break;
#ifndef ADDR_IN_HEAP
    case ADDRV: {
      uint32_t addr;
      GET_ADDR_HEAP(addr,heap,*val);
      fprintf_addr(f,addr);
      break;
    }
    case FLOATV: {
      float32 fv;
      GET_FLOAT_HEAP(fv,heap,*val);
      fprintf(f,"%12.6f",fv);
      break;
    }
#else
    case ADDRV: {
      uint32_t dest;
      dest = GET_ADDR_VAL(heap,*val);
	  fprintf(f,"in heap: %u:%u:%u:%u",dest <<24 >> 24, dest << 16 >> 24, dest << 8 >> 24, dest >> 24); 
	break;
	}
#endif
    case STRV: {
      heap_obj *_ho = (heap_obj *)((void *)heap + GET_OFFS_HEAP(*val));
      char *cp = (char *)&(_ho->s);
      int i;
      if (cp[_ho->len - 1] == (char)0xff) {
	/* blob */
	fprintf(f,"|%d|",_ho->len);
	break;
      }
      fprintf(f,"\"");
      for(i=0; i<_ho->len; i++) {
	if (*cp == '\0') {
	  break;
	}
	switch(*cp) {
	case '"': fprintf(f,"\\\""); break;
	case '\\': fprintf(f,"\\"); break;
	case '\n': fprintf(f,"\\n"); break;
	case '\b': fprintf(f,"\\b"); break;
	case '\r': fprintf(f,"\\r"); break;
	case '\t': fprintf(f,"\\t"); break;
	default:
	  if (isprint(*cp)) {
	    fprintf(f,"%c",*cp);
	  } else {
	    fprintf(f,"\\%03o",(int)*cp);
	  }
	  break;
	}
	cp++;
      }
      fprintf(f,"\"");
      break;
    }
    case EXCV:
      fprintf(f,"E_%d",GET_INT_HEAP(*val)); break;
    case TUPLEV: {
      heap_obj *_ho = (heap_obj *)((void *)heap + GET_OFFS_HEAP(*val));
      int i;
      fprintf(f,"(");
      for (i=0; i< _ho->len; i+= sizeof(value_t)) {
	fprintf_value_heap(heap,f,(value_t *)&(_ho->s[i]));
	if (i+sizeof(value_t) < _ho->len) fprintf(f,", ");
      }
      fprintf(f,")");
      break;
    }
    default:
      fprintf(f,"<bogusv>");
      break;
  }
  return 0;
}

int fprintf_value(packet_t *p,FILE *f,value_t *val) {
  void *heap = p->heap_min;
  return fprintf_value_heap(heap,f,val);
}

int fprintf_opcode(FILE *f, OPCODE_T op) {
  switch(op) {
  case EXIT: fprintf(f,"exit"); break;
  case POP: fprintf(f,"pop"); break;
  case POPI: fprintf(f,"popi"); break;
  case PULL: fprintf(f,"pull"); break;
  case STORE: fprintf(f,"store"); break;
  case JI: fprintf(f,"ji"); break;
  case PAJ: fprintf(f,"paj"); break;
  case TPAJ: fprintf(f,"tpaj"); break;
  case BEZ: fprintf(f,"bez"); break;
  case BNE: fprintf(f,"bne"); break;
  case MKTUP: fprintf(f,"mktup"); break;
  case NTH: fprintf(f,"nth"); break;
  case LEN: fprintf(f,"len"); break;
  case ISTUP: fprintf(f,"istup"); break;
  case EQ: fprintf(f,"eq"); break;
  case NEQ: fprintf(f,"neq"); break;
  case GT: fprintf(f,"gt"); break;
  case GTI: fprintf(f,"gti"); break;
  case GEQ: fprintf(f,"geq"); break;
  case GEQI: fprintf(f,"geqi"); break;
  case LEQ: fprintf(f,"leq"); break;
  case LEQI: fprintf(f,"leqi"); break;
  case LT: fprintf(f,"lt"); break;
  case LTI: fprintf(f,"lti"); break;
  case ADD: fprintf(f,"add"); break;
  case ADDI: fprintf(f,"addi"); break;
  case SUB: fprintf(f,"sub"); break;
  case SUBI: fprintf(f,"subi"); break;
  case MULT: fprintf(f,"mult"); break;
  case MULTI: fprintf(f,"multi"); break;
  case DIV: fprintf(f,"div"); break;
  case DIVI: fprintf(f,"divi"); break;
  case MOD: fprintf(f,"mod"); break;
  case MODI: fprintf(f,"modi"); break;
  case NEG: fprintf(f,"neg"); break;
  case NOT: fprintf(f,"not"); break;
  case LNOT: fprintf(f,"lnot"); break;
  case AND: fprintf(f,"and"); break;
  case ANDI: fprintf(f,"andi"); break;
  case OR: fprintf(f,"or"); break;
  case ORI: fprintf(f,"ori"); break;
  case LSHL: fprintf(f,"lshl"); break;
  case LSHLI: fprintf(f,"lshli"); break;
  case RSHL: fprintf(f,"rshl"); break;
  case RSHLI: fprintf(f,"rshli"); break;
  case RSHA: fprintf(f,"rsha"); break;
  case RSHAI: fprintf(f,"rshai"); break;
  case XOR: fprintf(f,"xor"); break;    
  case XORI: fprintf(f,"xori"); break;    
  case SNET: fprintf(f,"snet"); break;
  case SNETI: fprintf(f,"sneti"); break;
  case BCAST: fprintf(f,"bcast"); break;
  case BCASTI: fprintf(f,"bcasti"); break;
  case ISX: fprintf(f,"isx"); break;
  case GETRB: fprintf(f,"getrb"); break;
  case GETSRC: fprintf(f,"getsrc"); break;
  case GETDST: fprintf(f,"getdst"); break;
  case GETSPT: fprintf(f,"getspt"); break;
  case HERE: fprintf(f,"here"); break;
  case ISHERE: fprintf(f,"ishere"); break;
  case ROUTE: fprintf(f,"route"); break;
  case RTDEV: fprintf(f,"rtdev"); break;
  case SEND: fprintf(f,"send"); break;
  case HOP: fprintf(f,"hop"); break;
/*    case SENDCK: fprintf(f,"sendck"); break; */
/*    case HOPCK: fprintf(f,"hopck"); break; */
  case FORW: fprintf(f,"forw"); break;
  case FORWTO: fprintf(f,"forwto"); break;
  case DEMUX: fprintf(f,"demux"); break;
  case DEMUXI: fprintf(f,"demuxi"); break;
  case PRINT: fprintf(f,"print"); break;
#ifndef SMALL_INSTRS
  case PUSH: fprintf(f,"push"); break;
  case EQI: fprintf(f,"eqi"); break;
  case NEQI: fprintf(f,"neqi"); break;
#else
  case PINT: fprintf(f,"push"); break;
  case EQINT: fprintf(f,"eqi"); break;
  case NQINT: fprintf(f,"neqi"); break;
  case PADDR: fprintf(f,"push"); break;
  case EQADR: fprintf(f,"eqi"); break;
  case NQADR: fprintf(f,"neqi"); break;
  case PTUP: fprintf(f,"push"); break;
  case EQTUP: fprintf(f,"eqi"); break;
  case NQTUP: fprintf(f,"neqi"); break;
  case PEXC: fprintf(f,"push"); break;
  case EQEXC: fprintf(f,"eqi"); break;
  case NQEXC: fprintf(f,"neqi"); break;
  case PSTR: fprintf(f,"push"); break;
  case EQSTR: fprintf(f,"eqi"); break;
  case NQSTR: fprintf(f,"neqi"); break;
  case PFLT: fprintf(f,"push"); break;
  case EQFLT: fprintf(f,"eqi"); break;
  case NQFLT: fprintf(f,"neqi"); break;    
  case FGTI: fprintf(f,"gti"); break;
  case FGEQI: fprintf(f,"geqi"); break;
  case FLEQI: fprintf(f,"leqi"); break;
  case FLTI: fprintf(f,"lti"); break;
  case FADDI: fprintf(f,"addi"); break;
  case FSUBI: fprintf(f,"subi"); break;
  case FMULI: fprintf(f,"multi"); break;
  case FDIVI: fprintf(f,"divi"); break;
  case GETLD: fprintf(f,"getld"); break;
#endif
  case SVCV: fprintf(f,"svcv"); break;
  case CALLS: fprintf(f,"calls"); break;
  default: 
  	fprintf(stderr,"invalid opcode %d\n",op); 
  	exit(1);
  }
  return 0;
}

int fprintf_instr(packet_t *p, FILE *f, instr_t *i) {
/*    void *heap = p->heap_min; */
  fprintf_opcode(f,GET_OP(*i));
  switch(GET_OP(*i)) {
    /* int literals */
#ifdef SMALL_INSTRS
  case PINT:
  case EQINT:
  case NQINT:
  case GTI:
  case GEQI:
  case LTI:
  case LEQI:
  case ADDI:
  case SUBI:
  case MULTI:
  case DIVI:
#endif
  case POPI:
  case PULL:
  case STORE:
  case PAJ:
  case TPAJ:
  case JI:
  case BEZ:
  case BNE:
  case MKTUP:
  case NTH:
  case MODI:
  case ANDI:
  case ORI:
  case LSHLI:
  case RSHLI:
  case RSHAI:
  case XORI: {
    value_t lit;
    COPY_LIT(lit,INTV,*i);
    fprintf(f,"\t");
    fprintf_value(p,f,&lit);
    break;
  }
    /* addr literals */
#ifdef SMALL_INSTRS
  case PADDR:
  case EQADR:
  case NQADR:
#endif
  case SNETI:
  case BCASTI: {
    value_t lit;
    COPY_LIT(lit,ADDRV,*i);
    fprintf(f,"\t");
    fprintf_value(p,f,&lit);
    break;
  }

    /* string literals */
#ifdef SMALL_INSTRS
  case PSTR:
  case EQSTR:
  case NQSTR:
#endif
  case CALLS:
  case SVCV: {
    value_t lit;
    COPY_LIT(lit,STRV,*i);
    fprintf(f,"\t");
    fprintf_value(p,f,&lit);
    break;
  }

#ifdef SMALL_INSTRS
    /* tuple literals */
  case PTUP:
  case EQTUP:
  case NQTUP: {
    value_t lit;
    COPY_LIT(lit,TUPLEV,*i);
    fprintf(f,"\t");
    fprintf_value(p,f,&lit);
    break;
  }

    /* exception literals */
  case PEXC:
  case EQEXC:
  case NQEXC: {
    value_t lit;
    COPY_LIT(lit,EXCV,*i);
    fprintf(f,"\t");
    fprintf_value(p,f,&lit);
    break;
  }

    /* float literals */
  case PFLT:
  case EQFLT:
  case NQFLT:
  case FGEQI:
  case FLEQI:
  case FLTI:
  case FGTI:
  case FADDI:
  case FSUBI: