Splash: SNMP Plus a Lightweight API for SNAP Handling

00001 /* $Id: snap_bytecode.c,v 1.5 2003/03/27 18:55:07 wdebruij Exp $ */
00002 
00003 #ifdef __KERNEL__
00004 #include <linux/kernel.h>
00005 #include <linux/ctype.h>
00006 #include <snap/bytecode.h>
00007 #include <snap/dyncheck.h>
00008 #include <snap/wassert.h>
00009 #include <snap/packet.h>
00010 #else
00011 #include <stdlib.h>
00012 #include <ctype.h>
00013 #include <netinet/in.h>
00014 #include <stdio.h>
00015 #include "bytecode.h"
00016 #include "dyncheck.h"
00017 #include "wassert.h"
00018 #include "packet.h"
00019 #endif /* __KERNEL__ */
00020 
00021 #ifndef __KERNEL__
00022 int fprintf_addr(FILE *f, uint32_t addr) {
00023   /* in network byte order */
00024   return fprintf(f,"%u:%u:%u:%u",addr << 24 >> 24, addr << 16 >> 24, addr << 8 >> 24, addr >> 24);
00025 }
00026 
00027 int sprintf_addr(char *buf, uint32_t addr) {
00028   /* in network byte order */
00029   return sprintf(buf,"%u:%u:%u:%u",addr << 24 >> 24, addr << 16 >> 24, addr << 8 >> 24, addr >> 24);
00030 }
00031 
00032 int fprintf_value_tag(FILE *f,TAG_T tag) {
00033   switch(tag) {
00034   case INTV: return fprintf(f,"INTV"); break;
00035   case ADDRV: return fprintf(f,"ADDRV"); break;
00036   case STRV: return fprintf(f,"STRV"); break;
00037   case EXCV: return fprintf(f,"EXCV"); break;
00038   case TUPLEV: return fprintf(f,"TUPLEV"); break;
00039   case FLOATV: return fprintf(f,"FLOATV"); break;
00040   default: return fprintf(f,"BOGUSV"); break;
00041   }
00042 }
00043 
00044 /* 
00045     these DEFINEs are necessary for fprintf_value_heap to work
00046     
00047     we need this if we want to print without access to the packet
00048     for instace after a DEMUX
00049 
00050     I've copied this from bytecode.h in snaputils-0.1 and added the _HEAP
00051     for compatibility
00052 */
00053 #define GET_TAG_HEAP(v) ((v) >> (sizeof(unsigned int)*8-TAGSZ))
00054 #define SET_TAG_HEAP(v,t) ((v) = (((v) << TAGSZ) >> TAGSZ) | ((t) << (sizeof(unsigned int)*8-TAGSZ)))
00055 
00056 #define GET_INT_HEAP(v) (((int)((v) << TAGSZ)) >> TAGSZ)
00057 #define SET_INT_HEAP(v,i) ((v) = (((v) >> (sizeof(unsigned int)*8-TAGSZ)) << (sizeof(unsigned int)*8-TAGSZ)) | ((((unsigned int)(i)) << TAGSZ) >> TAGSZ))
00058 
00059 #define GET_OFFS_HEAP GET_INT_HEAP
00060 #define SET_OFFS_HEAP SET_INT_HEAP
00061 
00062 #ifndef ADDR_IN_HEAP
00063 #define GET_ADDR_HEAP(res,unused,val) ((res) = (val).v.addrval)
00064 #define SET_ADDR_HEAP(val,a,unused) ((val).v.addrval = (a))
00065 
00066 #define GET_FLOAT_HEAP(res,unused,val) ((res) = (val).v.floatval)
00067 #define SET_FLOAT_HEAP(val,a,unused) ((val).v.floatval = (a))
00068 
00069 #endif
00070 
00071 int fprintf_value_heap(void *heap,FILE *f,value_t *val) {
00072   switch(GET_TAG(*val)) {
00073     case INTV: fprintf(f,"%d",GET_INT_HEAP(*val)); break;
00074 #ifndef ADDR_IN_HEAP
00075     case ADDRV: {
00076       uint32_t addr;
00077       GET_ADDR_HEAP(addr,heap,*val);
00078       fprintf_addr(f,addr);
00079       break;
00080     }
00081     case FLOATV: {
00082       float32 fv;
00083       GET_FLOAT_HEAP(fv,heap,*val);
00084       fprintf(f,"%12.6f",fv);
00085       break;
00086     }
00087 #else
00088     case ADDRV: {
00089       uint32_t dest;
00090       dest = GET_ADDR_VAL(heap,*val);
00091       fprintf(f,"in heap: %u:%u:%u:%u",dest <<24 >> 24, dest << 16 >> 24, dest << 8 >> 24, dest >> 24); 
00092     break;
00093     }
00094 #endif
00095     case STRV: {
00096       heap_obj *_ho = (heap_obj *)((void *)heap + GET_OFFS_HEAP(*val));
00097       char *cp = (char *)&(_ho->s);
00098       int i;
00099       if (cp[_ho->len - 1] == (char)0xff) {
00100     /* blob */
00101     fprintf(f,"|%d|",_ho->len);
00102     break;
00103       }
00104       fprintf(f,"\"");
00105       for(i=0; i<_ho->len; i++) {
00106     if (*cp == '\0') {
00107       break;
00108     }
00109     switch(*cp) {
00110     case '"': fprintf(f,"\\\""); break;
00111     case '\\': fprintf(f,"\\"); break;
00112     case '\n': fprintf(f,"\\n"); break;
00113     case '\b': fprintf(f,"\\b"); break;
00114     case '\r': fprintf(f,"\\r"); break;
00115     case '\t': fprintf(f,"\\t"); break;
00116     default:
00117       if (isprint(*cp)) {
00118         fprintf(f,"%c",*cp);
00119       } else {
00120         fprintf(f,"\\%03o",(int)*cp);
00121       }
00122       break;
00123     }
00124     cp++;
00125       }
00126       fprintf(f,"\"");
00127       break;
00128     }
00129     case EXCV:
00130       fprintf(f,"E_%d",GET_INT_HEAP(*val)); break;
00131     case TUPLEV: {
00132       heap_obj *_ho = (heap_obj *)((void *)heap + GET_OFFS_HEAP(*val));
00133       int i;
00134       fprintf(f,"(");
00135       for (i=0; i< _ho->len; i+= sizeof(value_t)) {
00136     fprintf_value_heap(heap,f,(value_t *)&(_ho->s[i]));
00137     if (i+sizeof(value_t) < _ho->len) fprintf(f,", ");
00138       }
00139       fprintf(f,")");
00140       break;
00141     }
00142     default:
00143       fprintf(f,"<bogusv>");
00144       break;
00145   }
00146   return 0;
00147 }
00148 
00149 int fprintf_value(packet_t *p,FILE *f,value_t *val) {
00150   void *heap = p->heap_min;
00151   return fprintf_value_heap(heap,f,val);
00152 }
00153 
00154 int fprintf_opcode(FILE *f, OPCODE_T op) {
00155   switch(op) {
00156   case EXIT: fprintf(f,"exit"); break;
00157   case POP: fprintf(f,"pop"); break;
00158   case POPI: fprintf(f,"popi"); break;
00159   case PULL: fprintf(f,"pull"); break;
00160   case STORE: fprintf(f,"store"); break;
00161   case JI: fprintf(f,"ji"); break;
00162   case PAJ: fprintf(f,"paj"); break;
00163   case TPAJ: fprintf(f,"tpaj"); break;
00164   case BEZ: fprintf(f,"bez"); break;
00165   case BNE: fprintf(f,"bne"); break;
00166   case MKTUP: fprintf(f,"mktup"); break;
00167   case NTH: fprintf(f,"nth"); break;
00168   case LEN: fprintf(f,"len"); break;
00169   case ISTUP: fprintf(f,"istup"); break;
00170   case EQ: fprintf(f,"eq"); break;
00171   case NEQ: fprintf(f,"neq"); break;
00172   case GT: fprintf(f,"gt"); break;
00173   case GTI: fprintf(f,"gti"); break;
00174   case GEQ: fprintf(f,"geq"); break;
00175   case GEQI: fprintf(f,"geqi"); break;
00176   case LEQ: fprintf(f,"leq"); break;
00177   case LEQI: fprintf(f,"leqi"); break;
00178   case LT: fprintf(f,"lt"); break;
00179   case LTI: fprintf(f,"lti"); break;
00180   case ADD: fprintf(f,"add"); break;
00181   case ADDI: fprintf(f,"addi"); break;
00182   case SUB: fprintf(f,"sub"); break;
00183   case SUBI: fprintf(f,"subi"); break;
00184   case MULT: fprintf(f,"mult"); break;
00185   case MULTI: fprintf(f,"multi"); break;
00186   case DIV: fprintf(f,"div"); break;
00187   case DIVI: fprintf(f,"divi"); break;
00188   case MOD: fprintf(f,"mod"); break;
00189   case MODI: fprintf(f,"modi"); break;
00190   case NEG: fprintf(f,"neg"); break;
00191   case NOT: fprintf(f,"not"); break;
00192   case LNOT: fprintf(f,"lnot"); break;
00193   case AND: fprintf(f,"and"); break;
00194   case ANDI: fprintf(f,"andi"); break;
00195   case OR: fprintf(f,"or"); break;
00196   case ORI: fprintf(f,"ori"); break;
00197   case LSHL: fprintf(f,"lshl"); break;
00198   case LSHLI: fprintf(f,"lshli"); break;
00199   case RSHL: fprintf(f,"rshl"); break;
00200   case RSHLI: fprintf(f,"rshli"); break;
00201   case RSHA: fprintf(f,"rsha"); break;
00202   case RSHAI: fprintf(f,"rshai"); break;
00203   case XOR: fprintf(f,"xor"); break;    
00204   case XORI: fprintf(f,"xori"); break;    
00205   case SNET: fprintf(f,"snet"); break;
00206   case SNETI: fprintf(f,"sneti"); break;
00207   case BCAST: fprintf(f,"bcast"); break;
00208   case BCASTI: fprintf(f,"bcasti"); break;
00209   case ISX: fprintf(f,"isx"); break;
00210   case GETRB: fprintf(f,"getrb"); break;
00211   case GETSRC: fprintf(f,"getsrc"); break;
00212   case GETDST: fprintf(f,"getdst"); break;
00213   case GETSPT: fprintf(f,"getspt"); break;
00214   case HERE: fprintf(f,"here"); break;
00215   case ISHERE: fprintf(f,"ishere"); break;
00216   case ROUTE: fprintf(f,"route"); break;
00217   case RTDEV: fprintf(f,"rtdev"); break;
00218   case SEND: fprintf(f,"send"); break;
00219   case HOP: fprintf(f,"hop"); break;
00220 /*    case SENDCK: fprintf(f,"sendck"); break; */
00221 /*    case HOPCK: fprintf(f,"hopck"); break; */
00222   case FORW: fprintf(f,"forw"); break;
00223   case FORWTO: fprintf(f,"forwto"); break;
00224   case DEMUX: fprintf(f,"demux"); break;
00225   case DEMUXI: fprintf(f,"demuxi"); break;
00226   case PRINT: fprintf(f,"print"); break;
00227 #ifndef SMALL_INSTRS
00228   case PUSH: fprintf(f,"push"); break;
00229   case EQI: fprintf(f,"eqi"); break;
00230   case NEQI: fprintf(f,"neqi"); break;
00231 #else
00232   case PINT: fprintf(f,"push"); break;
00233   case EQINT: fprintf(f,"eqi"); break;
00234   case NQINT: fprintf(f,"neqi"); break;
00235   case PADDR: fprintf(f,"push"); break;
00236   case EQADR: fprintf(f,"eqi"); break;
00237   case NQADR: fprintf(f,"neqi"); break;
00238   case PTUP: fprintf(f,"push"); break;
00239   case EQTUP: fprintf(f,"eqi"); break;
00240   case NQTUP: fprintf(f,"neqi"); break;
00241   case PEXC: fprintf(f,"push"); break;
00242   case EQEXC: fprintf(f,"eqi"); break;
00243   case NQEXC: fprintf(f,"neqi"); break;
00244   case PSTR: fprintf(f,"push"); break;
00245   case EQSTR: fprintf(f,"eqi"); break;
00246   case NQSTR: fprintf(f,"neqi"); break;
00247   case PFLT: fprintf(f,"push"); break;
00248   case EQFLT: fprintf(f,"eqi"); break;
00249   case NQFLT: fprintf(f,"neqi"); break;    
00250   case FGTI: fprintf(f,"gti"); break;
00251   case FGEQI: fprintf(f,"geqi"); break;
00252   case FLEQI: fprintf(f,"leqi"); break;
00253   case FLTI: fprintf(f,"lti"); break;
00254   case FADDI: fprintf(f,"addi"); break;
00255   case FSUBI: fprintf(f,"subi"); break;
00256   case FMULI: fprintf(f,"multi"); break;
00257   case FDIVI: fprintf(f,"divi"); break;
00258   case GETLD: fprintf(f,"getld"); break;
00259 #endif
00260   case SVCV: fprintf(f,"svcv"); break;
00261   case CALLS: fprintf(f,"calls"); break;
00262   default: 
00263     fprintf(stderr,"invalid opcode %d\n",op); 
00264     exit(1);
00265   }
00266   return 0;
00267 }
00268 
00269 int fprintf_instr(packet_t *p, FILE *f, instr_t *i) {
00270 /*    void *heap = p->heap_min; */
00271   fprintf_opcode(f,GET_OP(*i));
00272   switch(GET_OP(*i)) {
00273     /* int literals */
00274 #ifdef SMALL_INSTRS
00275   case PINT:
00276   case EQINT:
00277   case NQINT:
00278   case GTI:
00279   case GEQI:
00280   case LTI:
00281   case LEQI:
00282   case ADDI:
00283   case SUBI:
00284   case MULTI:
00285   case DIVI:
00286 #endif
00287   case POPI:
00288   case PULL:
00289   case STORE:
00290   case PAJ:
00291   case TPAJ:
00292   case JI:
00293   case BEZ:
00294   case BNE:
00295   case MKTUP:
00296   case NTH:
00297   case MODI:
00298   case ANDI:
00299   case ORI:
00300   case LSHLI:
00301   case RSHLI:
00302   case RSHAI:
00303   case XORI: {
00304     value_t lit;
00305     COPY_LIT(lit,INTV,*i);
00306     fprintf(f,"\t");
00307     fprintf_value(p,f,&lit);
00308     break;
00309   }
00310     /* addr literals */
00311 #ifdef SMALL_INSTRS
00312   case PADDR:
00313   case EQADR:
00314   case NQADR:
00315 #endif
00316   case SNETI:
00317   case BCASTI: {
00318     value_t lit;
00319     COPY_LIT(lit,ADDRV,*i);
00320     fprintf(f,"\t");
00321     fprintf_value(p,f,&lit);
00322     break;
00323   }
00324 
00325     /* string literals */
00326 #ifdef SMALL_INSTRS
00327   case PSTR:
00328   case EQSTR:
00329   case NQSTR:
00330 #endif
00331   case CALLS:
00332   case SVCV: {
00333     value_t lit;
00334     COPY_LIT(lit,STRV,*i);
00335     fprintf(f,"\t");
00336     fprintf_value(p,f,&lit);
00337     break;
00338   }
00339 
00340 #ifdef SMALL_INSTRS
00341     /* tuple literals */
00342   case PTUP:
00343   case EQTUP:
00344   case NQTUP: {
00345     value_t lit;
00346     COPY_LIT(lit,TUPLEV,*i);
00347     fprintf(f,"\t");
00348     fprintf_value(p,f,&lit);
00349     break;
00350   }
00351 
00352     /* exception literals */
00353   case PEXC:
00354   case EQEXC:
00355   case NQEXC: {
00356     value_t lit;
00357     COPY_LIT(lit,EXCV,*i);
00358     fprintf(f,"\t");
00359     fprintf_value(p,f,&lit);
00360     break;
00361   }
00362 
00363     /* float literals */
00364   case PFLT:
00365   case EQFLT:
00366   case NQFLT:
00367   case FGEQI:
00368   case FLEQI:
00369   case FLTI:
00370   case FGTI:
00371   case FADDI:
00372   case FSUBI:
00373   case FMULI:
00374   case FDIVI: {
00375     value_t lit;
00376     COPY_LIT(lit,FLOATV,*i);
00377     fprintf(f,"\t");
00378     fprintf_value(p,f,&lit);
00379     break;
00380   }
00381 
00382 #else
00383     /* polymorphic literals */
00384   case PUSH:
00385   case EQI:
00386   case NEQI:
00387   case GTI:
00388   case GEQI:
00389   case LTI:
00390   case LEQI:
00391   case ADDI:
00392   case SUBI:
00393   case MULTI:
00394   case DIVI:
00395     fprintf(f,"\t");
00396     fprintf_value(p,f,&(i->arg));
00397     break;
00398 #endif
00399   default:
00400     /* nothing */;
00401   }
00402   return 0;
00403 }
00404 
00405 #else
00406 
00407 /* kernel versions */
00408 int printk_addr(unsigned int addr) {
00409   printk("%d.%d.%d.%d",NIPQUAD(addr));
00410   return 0;
00411 }
00412 
00413 int printk_value_tag(TAG_T tag) {
00414   switch(tag) {
00415   case INTV: printk("INTV"); break;
00416   case ADDRV: printk("ADDRV"); break;
00417   case STRV: printk("STRV"); break;
00418   case EXCV: printk("EXCV"); break;
00419   case TUPLEV: printk("TUPLEV"); break;
00420   case FLOATV: printk("FLOATV"); break;
00421   default: printk("BOGUSV"); break;
00422   }
00423   return 0;
00424 }
00425 
00426 int printk_value(packet_t *p,value_t *val) {
00427   void *heap = p->heap_min;
00428   switch(GET_TAG(*val)) {
00429     case INTV: printk("%d",GET_INT(*val)); break;
00430     case ADDRV: {
00431       uint32 addr;
00432       GET_ADDR(addr,heap,*val);
00433       printk_addr(addr);
00434       break;
00435     }
00436     case FLOATV: {
00437       float32 fv;
00438       GET_FLOAT(fv,heap,*val);
00439       printk("%d.%02d",(int)fv,(int)((fv - (int)fv) * 100)); 
00440       break;
00441     }
00442     case STRV: {
00443       heap_obj *_ho = (heap_obj *)((void *)heap + GET_OFFS(*val));
00444       char *cp = (char *)&(_ho->s);
00445       int i;
00446       if (cp[_ho->len - 1] == (char)0xff) {
00447     /* blob */
00448     printk("|%d|",_ho->len);
00449     break;
00450       }
00451       printk("\"");
00452       for(i=0; i<_ho->len; i++) {
00453     if (*cp == '\0') {
00454       break;
00455     }
00456     switch(*cp) {
00457     case '"': printk("\\\""); break;
00458     case '\\': printk("\\"); break;
00459     case '\n': printk("\\n"); break;
00460     case '\b': printk("\\b"); break;
00461     case '\r': printk("\\r"); break;
00462     case '\t': printk("\\t"); break;
00463     default: 
00464       if (isprint(*cp)) {
00465         printk("%c",*cp);
00466       } else {
00467         printk("\\%03o",(int)*cp);
00468       }
00469       break;
00470     }
00471     cp++;
00472       }
00473       printk("\"");
00474       break;
00475     }
00476     case EXCV:
00477       printk("E_%d",GET_INT(*val)); break;
00478     case TUPLEV: {
00479       heap_obj *_ho = (heap_obj *)((void *)heap + GET_OFFS(*val));
00480       int i;
00481       printk("(");
00482       for (i=0; i< _ho->len; i+= sizeof(value_t)) {
00483     printk_value(p,(value_t *)&(_ho->s[i]));
00484     if (i+sizeof(value_t) < _ho->len) printk(", ");
00485       }
00486       printk(")");
00487       break;
00488     }
00489     default:
00490       printk("<bogusv>");
00491       break;
00492   }
00493   return 0;
00494 }
00495 
00496 int printk_opcode(OPCODE_T op) {
00497   switch(op) {
00498   case EXIT: printk("exit"); break;
00499   case POP: printk("pop"); break;
00500   case POPI: printk("popi"); break;
00501   case PULL: printk("pull"); break;
00502   case STORE: printk("store"); break;
00503   case JI: printk("ji"); break;
00504   case PAJ: printk("paj"); break;
00505   case TPAJ: printk("tpaj"); break;
00506   case BEZ: printk("bez"); break;
00507   case BNE: printk("bne"); break;
00508   case MKTUP: printk("mktup"); break;
00509   case NTH: printk("nth"); break;
00510   case LEN: printk("len"); break;
00511   case ISTUP: printk("istup"); break;
00512   case EQ: printk("eq"); break;
00513   case NEQ: printk("neq"); break;
00514   case GT: printk("gt"); break;
00515   case GTI: printk("gti"); break;
00516   case GEQ: printk("geq"); break;
00517   case GEQI: printk("geqi"); break;
00518   case LEQ: printk("leq"); break;
00519   case LEQI: printk("leqi"); break;
00520   case LT: printk("lt"); break;
00521   case LTI: printk("lti"); break;
00522   case ADD: printk("add"); break;
00523   case ADDI: printk("addi"); break;
00524   case SUB: printk("sub"); break;
00525   case SUBI: printk("subi"); break;
00526   case MULT: printk("mult"); break;
00527   case MULTI: printk("multi"); break;
00528   case DIV: printk("div"); break;
00529   case DIVI: printk("divi"); break;
00530   case MOD: printk("mod"); break;
00531   case MODI: printk("modi"); break;
00532   case NEG: printk("neg"); break;
00533   case NOT: printk("not"); break;
00534   case LNOT: printk("lnot"); break;
00535   case AND: printk("and"); break;
00536   case ANDI: printk("andi"); break;
00537   case OR: printk("or"); break;
00538   case ORI: printk("ori"); break;
00539   case LSHL: printk("lshl"); break;
00540   case LSHLI: printk("lshli"); break;
00541   case RSHL: printk("rshl"); break;
00542   case RSHLI: printk("rshli"); break;
00543   case RSHA: printk("rsha"); break;
00544   case RSHAI: printk("rshai"); break;
00545   case XOR: printk("xor"); break;    
00546   case XORI: printk("xori"); break;    
00547   case SNET: printk("snet"); break;
00548   case SNETI: printk("sneti"); break;
00549   case BCAST: printk("bcast"); break;
00550   case BCASTI: printk("bcasti"); break;
00551   case ISX: printk("isx"); break;
00552   case GETRB: printk("getrb"); break;
00553   case GETSRC: printk("getsrc"); break;
00554   case GETDST: printk("getdst"); break;
00555   case GETSPT: printk("getspt"); break;
00556   case HERE: printk("here"); break;
00557   case ISHERE: printk("ishere"); break;
00558   case ROUTE: printk("route"); break;
00559   case RTDEV: printk("rtdev"); break;
00560   case SEND: printk("send"); break;
00561   case HOP: printk("hop"); break;
00562 /*    case SENDCK: printk("sendck"); break; */
00563 /*    case HOPCK: printk("hopck"); break; */
00564   case FORW: printk("forw"); break;
00565   case FORWTO: printk("forwto"); break;
00566   case DEMUX: printk("demux"); break;
00567   case DEMUXI: printk("demuxi"); break;
00568   case PRINT: printk("print"); break;
00569 #ifndef SMALL_INSTRS
00570   case PUSH: printk("push"); break;
00571   case EQI: printk("eqi"); break;
00572   case NEQI: printk("neqi"); break;
00573 #else
00574   case PINT: printk("pint"); break;
00575   case EQINT: printk("eqint"); break;
00576   case NQINT: printk("nqint"); break;
00577   case PADDR: printk("paddr"); break;
00578   case EQADR: printk("eqadr"); break;
00579   case NQADR: printk("nqadr"); break;
00580   case PTUP: printk("ptup"); break;
00581   case EQTUP: printk("eqtup"); break;
00582   case NQTUP: printk("nqtup"); break;
00583   case PEXC: printk("pexc"); break;
00584   case EQEXC: printk("eqexc"); break;
00585   case NQEXC: printk("nqexc"); break;
00586   case PSTR: printk("pstr"); break;
00587   case EQSTR: printk("eqstr"); break;
00588   case NQSTR: printk("nqstr"); break;
00589   case PFLT: printk("pflt"); break;
00590   case EQFLT: printk("eqflt"); break;
00591   case NQFLT: printk("nqflt"); break;    
00592   case FGTI: printk("fgti"); break;
00593   case FGEQI: printk("fgeqi"); break;
00594   case FLEQI: printk("fleqi"); break;
00595   case FLTI: printk("flti"); break;
00596   case FADDI: printk("faddi"); break;
00597   case FSUBI: printk("fsubi"); break;
00598   case FMULI: printk("fmulti"); break;
00599   case FDIVI: printk("fdivi"); break;
00600   case GETLD: printk("getld"); break;
00601 #endif
00602   case SVCV: printk("svcv"); break;
00603   case CALLS: printk("calls"); break;
00604   default: printk("invalid opcode %d\n",op);
00605   }
00606   return 0;
00607 }
00608 
00609 int printk_instr(packet_t *p, instr_t *i) {
00610   printk_opcode(GET_OP(*i));
00611   switch(GET_OP(*i)) {
00612     /* int literals */
00613 #ifdef SMALL_INSTRS
00614   case PINT:
00615   case EQINT:
00616   case NQINT:
00617   case GTI:
00618   case GEQI:
00619   case LTI:
00620   case LEQI:
00621   case ADDI:
00622   case SUBI:
00623   case MULTI:
00624   case DIVI:
00625 #endif
00626   case POPI:
00627   case PULL:
00628   case STORE:
00629   case PAJ:
00630   case TPAJ:
00631   case JI:
00632   case BEZ:
00633   case BNE:
00634   case MKTUP:
00635   case NTH:
00636   case MODI:
00637   case ANDI:
00638   case ORI:
00639   case LSHLI:
00640   case RSHLI:
00641   case RSHAI:
00642   case XORI: {
00643     value_t lit;
00644     COPY_LIT(lit,INTV,*i);
00645     printk("\t");
00646     printk_value(p,&lit);
00647     break;
00648   }
00649     /* addr literals */
00650 #ifdef SMALL_INSTRS
00651   case PADDR:
00652   case EQADR:
00653   case NQADR:
00654 #endif
00655   case SNETI:
00656   case BCASTI: {
00657     value_t lit;
00658     COPY_LIT(lit,ADDRV,*i);
00659     printk("\t");
00660     printk_value(p,&lit);
00661     break;
00662   }
00663 
00664     /* string literals */
00665 #ifdef SMALL_INSTRS
00666   case PSTR:
00667   case EQSTR:
00668   case NQSTR:
00669 #endif
00670   case CALLS:
00671   case SVCV: {
00672     value_t lit;
00673     COPY_LIT(lit,STRV,*i);
00674     printk("\t");
00675     printk_value(p,&lit);
00676     break;
00677   }
00678 
00679 #ifdef SMALL_INSTRS
00680     /* tuple literals */
00681   case PTUP:
00682   case EQTUP:
00683   case NQTUP: {
00684     value_t lit;
00685     COPY_LIT(lit,TUPLEV,*i);
00686     printk("\t");
00687     printk_value(p,&lit);
00688     break;
00689   }
00690 
00691     /* exception literals */
00692   case PEXC:
00693   case EQEXC:
00694   case NQEXC: {
00695     value_t lit;
00696     COPY_LIT(lit,EXCV,*i);
00697     printk("\t");
00698     printk_value(p,&lit);
00699     break;
00700   }
00701 
00702     /* float literals */
00703   case PFLT:
00704   case EQFLT:
00705   case NQFLT:
00706   case FGEQI:
00707   case FLEQI:
00708   case FLTI:
00709   case FGTI:
00710   case FADDI:
00711   case FSUBI:
00712   case FMULI:
00713   case FDIVI: {
00714     value_t lit;
00715     COPY_LIT(lit,FLOATV,*i);
00716     printk("\t");
00717     printk_value(p,&lit);
00718     break;
00719   }
00720 
00721 #else
00722     /* polymorphic literals */
00723   case PUSH:
00724   case EQI:
00725   case NEQI:
00726   case GTI:
00727   case GEQI:
00728   case LTI:
00729   case LEQI:
00730   case ADDI:
00731   case SUBI:
00732   case MULTI:
00733   case DIVI:
00734     printk("\t");
00735     printk_value(p,&(i->arg));
00736     break;
00737 #endif
00738   default:
00739     /* nothing */;
00740   }
00741   return 0;
00742 }
00743 #endif /* !__KERNEL__ */
Splash - Documentation

SNMP Plus a Lightweight API for SNAP Handling

snap-1.1-wjdb/lib/snap_bytecode.c
