home *** CD-ROM | disk | FTP | other *** search
/ Steganos Hacker Tools / SHT151.iso / programme / scanner / nmapNTsp1 / Win_2000.exe / nmapNT-src / libpcap-possiblymodified / gencode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-14  |  38.6 KB  |  1,945 lines
  1. /*
  2.  * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that: (1) source code distributions
  7.  * retain the above copyright notice and this paragraph in its entirety, (2)
  8.  * distributions including binary code include the above copyright notice and
  9.  * this paragraph in its entirety in the documentation or other materials
  10.  * provided with the distribution, and (3) all advertising materials mentioning
  11.  * features or use of this software display the following acknowledgement:
  12.  * ``This product includes software developed by the University of California,
  13.  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14.  * the University nor the names of its contributors may be used to endorse
  15.  * or promote products derived from this software without specific prior
  16.  * written permission.
  17.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20.  */
  21. #ifndef lint
  22. static const char rcsid[] =
  23.     "@(#) $Header: /archive/CVS/nmap/libpcap-possiblymodified/gencode.c,v 1.1 1998/10/15 04:39:58 fyodor Exp $ (LBL)";
  24. #endif
  25.  
  26. #include <sys/types.h>
  27. #include <sys/socket.h>
  28. #include <sys/time.h>
  29.  
  30. #if __STDC__
  31. struct mbuf;
  32. struct rtentry;
  33. #endif
  34.  
  35. #include <net/if.h>
  36.  
  37. #include <netinet/in.h>
  38. #include <netinet/if_ether.h>
  39.  
  40. #include <stdlib.h>
  41. #include <memory.h>
  42. #include <setjmp.h>
  43. #if __STDC__
  44. #include <stdarg.h>
  45. #else
  46. #include <varargs.h>
  47. #endif
  48.  
  49. #include "pcap-int.h"
  50.  
  51. #include "ethertype.h"
  52. #include "gencode.h"
  53. #include "ppp.h"
  54. #include <pcap-namedb.h>
  55.  
  56. #include "gnuc.h"
  57. #ifdef HAVE_OS_PROTO_H
  58. #include "os-proto.h"
  59. #endif
  60.  
  61. #define JMP(c) ((c)|BPF_JMP|BPF_K)
  62.  
  63. /* Locals */
  64. static jmp_buf top_ctx;
  65. static pcap_t *bpf_pcap;
  66.  
  67. /* XXX */
  68. #ifdef PCAP_FDDIPAD
  69. int    pcap_fddipad = PCAP_FDDIPAD;
  70. #else
  71. int    pcap_fddipad;
  72. #endif
  73.  
  74. /* VARARGS */
  75. __dead void
  76. #if __STDC__
  77. bpf_error(const char *fmt, ...)
  78. #else
  79. bpf_error(fmt, va_alist)
  80.     const char *fmt;
  81.     va_dcl
  82. #endif
  83. {
  84.     va_list ap;
  85.  
  86. #if __STDC__
  87.     va_start(ap, fmt);
  88. #else
  89.     va_start(ap);
  90. #endif
  91.     if (bpf_pcap != NULL)
  92.         (void)vsprintf(pcap_geterr(bpf_pcap), fmt, ap);
  93.     va_end(ap);
  94.     longjmp(top_ctx, 1);
  95.     /* NOTREACHED */
  96. }
  97.  
  98. static void init_linktype(int);
  99.  
  100. static int alloc_reg(void);
  101. static void free_reg(int);
  102.  
  103. static struct block *root;
  104.  
  105. /*
  106.  * We divy out chunks of memory rather than call malloc each time so
  107.  * we don't have to worry about leaking memory.  It's probably
  108.  * not a big deal if all this memory was wasted but it this ever
  109.  * goes into a library that would probably not be a good idea.
  110.  */
  111. #define NCHUNKS 16
  112. #define CHUNK0SIZE 1024
  113. struct chunk {
  114.     u_int n_left;
  115.     void *m;
  116. };
  117.  
  118. static struct chunk chunks[NCHUNKS];
  119. static int cur_chunk;
  120.  
  121. static void *newchunk(u_int);
  122. static void freechunks(void);
  123. static inline struct block *new_block(int);
  124. static inline struct slist *new_stmt(int);
  125. static struct block *gen_retblk(int);
  126. static inline void syntax(void);
  127.  
  128. static void backpatch(struct block *, struct block *);
  129. static void merge(struct block *, struct block *);
  130. static struct block *gen_cmp(u_int, u_int, bpf_int32);
  131. static struct block *gen_mcmp(u_int, u_int, bpf_int32, bpf_u_int32);
  132. static struct block *gen_bcmp(u_int, u_int, const u_char *);
  133. static struct block *gen_uncond(int);
  134. static inline struct block *gen_true(void);
  135. static inline struct block *gen_false(void);
  136. static struct block *gen_linktype(int);
  137. static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
  138. static struct block *gen_ehostop(const u_char *, int);
  139. static struct block *gen_fhostop(const u_char *, int);
  140. static struct block *gen_dnhostop(bpf_u_int32, int, u_int);
  141. static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int);
  142. static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
  143. static struct block *gen_ipfrag(void);
  144. static struct block *gen_portatom(int, bpf_int32);
  145. struct block *gen_portop(int, int, int);
  146. static struct block *gen_port(int, int, int);
  147. static int lookup_proto(const char *, int);
  148. static struct block *gen_proto(int, int, int);
  149. static struct slist *xfer_to_x(struct arth *);
  150. static struct slist *xfer_to_a(struct arth *);
  151. static struct block *gen_len(int, int);
  152.  
  153. static void *
  154. newchunk(n)
  155.     u_int n;
  156. {
  157.     struct chunk *cp;
  158.     int k, size;
  159.  
  160.     /* XXX Round up to nearest long. */
  161.     n = (n + sizeof(long) - 1) & ~(sizeof(long) - 1);
  162.  
  163.     cp = &chunks[cur_chunk];
  164.     if (n > cp->n_left) {
  165.         ++cp, k = ++cur_chunk;
  166.         if (k >= NCHUNKS)
  167.             bpf_error("out of memory");
  168.         size = CHUNK0SIZE << k;
  169.         cp->m = (void *)malloc(size);
  170.         memset((char *)cp->m, 0, size);
  171.         cp->n_left = size;
  172.         if (n > size)
  173.             bpf_error("out of memory");
  174.     }
  175.     cp->n_left -= n;
  176.     return (void *)((char *)cp->m + cp->n_left);
  177. }
  178.  
  179. static void
  180. freechunks()
  181. {
  182.     int i;
  183.  
  184.     cur_chunk = 0;
  185.     for (i = 0; i < NCHUNKS; ++i)
  186.         if (chunks[i].m != NULL) {
  187.             free(chunks[i].m);
  188.             chunks[i].m = NULL;
  189.         }
  190. }
  191.  
  192. /*
  193.  * A strdup whose allocations are freed after code generation is over.
  194.  */
  195. char *
  196. sdup(s)
  197.     register const char *s;
  198. {
  199.     int n = strlen(s) + 1;
  200.     char *cp = newchunk(n);
  201.  
  202.     strcpy(cp, s);
  203.     return (cp);
  204. }
  205.  
  206. static inline struct block *
  207. new_block(code)
  208.     int code;
  209. {
  210.     struct block *p;
  211.  
  212.     p = (struct block *)newchunk(sizeof(*p));
  213.     p->s.code = code;
  214.     p->head = p;
  215.  
  216.     return p;
  217. }
  218.  
  219. static inline struct slist *
  220. new_stmt(code)
  221.     int code;
  222. {
  223.     struct slist *p;
  224.  
  225.     p = (struct slist *)newchunk(sizeof(*p));
  226.     p->s.code = code;
  227.  
  228.     return p;
  229. }
  230.  
  231. static struct block *
  232. gen_retblk(v)
  233.     int v;
  234. {
  235.     struct block *b = new_block(BPF_RET|BPF_K);
  236.  
  237.     b->s.k = v;
  238.     return b;
  239. }
  240.  
  241. static inline void
  242. syntax()
  243. {
  244.     bpf_error("syntax error in filter expression");
  245. }
  246.  
  247. static bpf_u_int32 netmask;
  248. static int snaplen;
  249.  
  250. int
  251. pcap_compile(pcap_t *p, struct bpf_program *program,
  252.          char *buf, int optimize, bpf_u_int32 mask)
  253. {
  254.     extern int n_errors;
  255.     int len;
  256.  
  257.     n_errors = 0;
  258.     root = NULL;
  259.     bpf_pcap = p;
  260.     if (setjmp(top_ctx)) {
  261.         freechunks();
  262.         return (-1);
  263.     }
  264.  
  265.     netmask = mask;
  266.     snaplen = pcap_snapshot(p);
  267.  
  268.     lex_init(buf ? buf : "");
  269.     init_linktype(pcap_datalink(p));
  270.     (void)pcap_parse();
  271.  
  272.     if (n_errors)
  273.         syntax();
  274.  
  275.     if (root == NULL)
  276.         root = gen_retblk(snaplen);
  277.  
  278.     if (optimize) {
  279.         bpf_optimize(&root);
  280.         if (root == NULL ||
  281.             (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
  282.             bpf_error("expression rejects all packets");
  283.     }
  284.     program->bf_insns = icode_to_fcode(root, &len);
  285.     program->bf_len = len;
  286.  
  287.     freechunks();
  288.     return (0);
  289. }
  290.  
  291. /*
  292.  * Backpatch the blocks in 'list' to 'target'.  The 'sense' field indicates
  293.  * which of the jt and jf fields has been resolved and which is a pointer
  294.  * back to another unresolved block (or nil).  At least one of the fields
  295.  * in each block is already resolved.
  296.  */
  297. static void
  298. backpatch(list, target)
  299.     struct block *list, *target;
  300. {
  301.     struct block *next;
  302.  
  303.     while (list) {
  304.         if (!list->sense) {
  305.             next = JT(list);
  306.             JT(list) = target;
  307.         } else {
  308.             next = JF(list);
  309.             JF(list) = target;
  310.         }
  311.         list = next;
  312.     }
  313. }
  314.  
  315. /*
  316.  * Merge the lists in b0 and b1, using the 'sense' field to indicate
  317.  * which of jt and jf is the link.
  318.  */
  319. static void
  320. merge(b0, b1)
  321.     struct block *b0, *b1;
  322. {
  323.     register struct block **p = &b0;
  324.  
  325.     /* Find end of list. */
  326.     while (*p)
  327.         p = !((*p)->sense) ? &JT(*p) : &JF(*p);
  328.  
  329.     /* Concatenate the lists. */
  330.     *p = b1;
  331. }
  332.  
  333. void
  334. finish_parse(p)
  335.     struct block *p;
  336. {
  337.     backpatch(p, gen_retblk(snaplen));
  338.     p->sense = !p->sense;
  339.     backpatch(p, gen_retblk(0));
  340.     root = p->head;
  341. }
  342.  
  343. void
  344. gen_and(b0, b1)
  345.     struct block *b0, *b1;
  346. {
  347.     backpatch(b0, b1->head);
  348.     b0->sense = !b0->sense;
  349.     b1->sense = !b1->sense;
  350.     merge(b1, b0);
  351.     b1->sense = !b1->sense;
  352.     b1->head = b0->head;
  353. }
  354.  
  355. void
  356. gen_or(b0, b1)
  357.     struct block *b0, *b1;
  358. {
  359.     b0->sense = !b0->sense;
  360.     backpatch(b0, b1->head);
  361.     b0->sense = !b0->sense;
  362.     merge(b1, b0);
  363.     b1->head = b0->head;
  364. }
  365.  
  366. void
  367. gen_not(b)
  368.     struct block *b;
  369. {
  370.     b->sense = !b->sense;
  371. }
  372.  
  373. static struct block *
  374. gen_cmp(offset, size, v)
  375.     u_int offset, size;
  376.     bpf_int32 v;
  377. {
  378.     struct slist *s;
  379.     struct block *b;
  380.  
  381.     s = new_stmt(BPF_LD|BPF_ABS|size);
  382.     s->s.k = offset;
  383.  
  384.     b = new_block(JMP(BPF_JEQ));
  385.     b->stmts = s;
  386.     b->s.k = v;
  387.  
  388.     return b;
  389. }
  390.  
  391. static struct block *
  392. gen_mcmp(offset, size, v, mask)
  393.     u_int offset, size;
  394.     bpf_int32 v;
  395.     bpf_u_int32 mask;
  396. {
  397.     struct block *b = gen_cmp(offset, size, v);
  398.     struct slist *s;
  399.  
  400.     if (mask != 0xffffffff) {
  401.         s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
  402.         s->s.k = mask;
  403.         b->stmts->next = s;
  404.     }
  405.     return b;
  406. }
  407.  
  408. static struct block *
  409. gen_bcmp(offset, size, v)
  410.     register u_int offset, size;
  411.     register const u_char *v;
  412. {
  413.     register struct block *b, *tmp;
  414.  
  415.     b = NULL;
  416.     while (size >= 4) {
  417.         register const u_char *p = &v[size - 4];
  418.         bpf_int32 w = ((bpf_int32)p[0] << 24) |
  419.             ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
  420.  
  421.         tmp = gen_cmp(offset + size - 4, BPF_W, w);
  422.         if (b != NULL)
  423.             gen_and(b, tmp);
  424.         b = tmp;
  425.         size -= 4;
  426.     }
  427.     while (size >= 2) {
  428.         register const u_char *p = &v[size - 2];
  429.         bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
  430.  
  431.         tmp = gen_cmp(offset + size - 2, BPF_H, w);
  432.         if (b != NULL)
  433.             gen_and(b, tmp);
  434.         b = tmp;
  435.         size -= 2;
  436.     }
  437.     if (size > 0) {
  438.         tmp = gen_cmp(offset, BPF_B, (bpf_int32)v[0]);
  439.         if (b != NULL)
  440.             gen_and(b, tmp);
  441.         b = tmp;
  442.     }
  443.     return b;
  444. }
  445.  
  446. /*
  447.  * Various code constructs need to know the layout of the data link
  448.  * layer.  These variables give the necessary offsets.  off_linktype
  449.  * is set to -1 for no encapsulation, in which case, IP is assumed.
  450.  */
  451. static u_int off_linktype;
  452. static u_int off_nl;
  453. static int linktype;
  454.  
  455. static void
  456. init_linktype(type)
  457.     int type;
  458. {
  459.     linktype = type;
  460.  
  461.     switch (type) {
  462.  
  463.     case DLT_EN10MB:
  464.         off_linktype = 12;
  465.         off_nl = 14;
  466.         return;
  467.  
  468.     case DLT_SLIP:
  469.         /*
  470.          * SLIP doesn't have a link level type.  The 16 byte
  471.          * header is hacked into our SLIP driver.
  472.          */
  473.         off_linktype = -1;
  474.         off_nl = 16;
  475.         return;
  476.  
  477.     case DLT_SLIP_BSDOS:
  478.         /* XXX this may be the same as the DLT_PPP_BSDOS case */
  479.         off_linktype = -1;
  480.         /* XXX end */
  481.         off_nl = 24;
  482.         return;
  483.  
  484.     case DLT_NULL:
  485.         off_linktype = 0;
  486.         off_nl = 4;
  487.         return;
  488.  
  489.     case DLT_PPP:
  490.         off_linktype = 2;
  491.         off_nl = 4;
  492.         return;
  493.  
  494.     case DLT_PPP_BSDOS:
  495.         off_linktype = 5;
  496.         off_nl = 24;
  497.         return;
  498.  
  499.     case DLT_FDDI:
  500.         /*
  501.          * FDDI doesn't really have a link-level type field.
  502.          * We assume that SSAP = SNAP is being used and pick
  503.          * out the encapsulated Ethernet type.
  504.          */
  505.         off_linktype = 19;
  506. #ifdef PCAP_FDDIPAD
  507.         off_linktype += pcap_fddipad;
  508. #endif
  509.         off_nl = 21;
  510. #ifdef PCAP_FDDIPAD
  511.         off_nl += pcap_fddipad;
  512. #endif
  513.         return;
  514.  
  515.     case DLT_IEEE802:
  516.         off_linktype = 20;
  517.         off_nl = 22;
  518.         return;
  519.  
  520.     case DLT_ATM_RFC1483:
  521.         /*
  522.          * assume routed, non-ISO PDUs
  523.          * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)
  524.          */
  525.         off_linktype = 6;
  526.         off_nl = 8;
  527.         return;
  528.  
  529.     case DLT_RAW:
  530.         off_linktype = -1;
  531.         off_nl = 0;
  532.         return;
  533.     }
  534.     bpf_error("unknown data link type 0x%x", linktype);
  535.     /* NOTREACHED */
  536. }
  537.  
  538. static struct block *
  539. gen_uncond(rsense)
  540.     int rsense;
  541. {
  542.     struct block *b;
  543.     struct slist *s;
  544.  
  545.     s = new_stmt(BPF_LD|BPF_IMM);
  546.     s->s.k = !rsense;
  547.     b = new_block(JMP(BPF_JEQ));
  548.     b->stmts = s;
  549.  
  550.     return b;
  551. }
  552.  
  553. static inline struct block *
  554. gen_true()
  555. {
  556.     return gen_uncond(1);
  557. }
  558.  
  559. static inline struct block *
  560. gen_false()
  561. {
  562.     return gen_uncond(0);
  563. }
  564.  
  565. static struct block *
  566. gen_linktype(proto)
  567.     register int proto;
  568. {
  569.     struct block *b0, *b1;
  570.  
  571.     /* If we're not using encapsulation and checking for IP, we're done */
  572.     if (off_linktype == -1 && proto == ETHERTYPE_IP)
  573.         return gen_true();
  574.  
  575.     switch (linktype) {
  576.  
  577.     case DLT_SLIP:
  578.         return gen_false();
  579.  
  580.     case DLT_PPP:
  581.         if (proto == ETHERTYPE_IP)
  582.             proto = PPP_IP;            /* XXX was 0x21 */
  583.         break;
  584.  
  585.     case DLT_PPP_BSDOS:
  586.         switch (proto) {
  587.  
  588.         case ETHERTYPE_IP:
  589.             b0 = gen_cmp(off_linktype, BPF_H, PPP_IP);
  590.             b1 = gen_cmp(off_linktype, BPF_H, PPP_VJC);
  591.             gen_or(b0, b1);
  592.             b0 = gen_cmp(off_linktype, BPF_H, PPP_VJNC);
  593.             gen_or(b1, b0);
  594.             return b0;
  595.  
  596.         case ETHERTYPE_DN:
  597.             proto = PPP_DECNET;
  598.             break;
  599.  
  600.         case ETHERTYPE_ATALK:
  601.             proto = PPP_APPLE;
  602.             break;
  603.  
  604.         case ETHERTYPE_NS:
  605.             proto = PPP_NS;
  606.             break;
  607.         }
  608.         break;
  609.  
  610.     case DLT_NULL:
  611.         /* XXX */
  612.         if (proto == ETHERTYPE_IP)
  613.             return (gen_cmp(0, BPF_W, (bpf_int32)htonl(AF_INET)));
  614.         else
  615.             return gen_false();
  616.     }
  617.     return gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
  618. }
  619.  
  620. static struct block *
  621. gen_hostop(addr, mask, dir, proto, src_off, dst_off)
  622.     bpf_u_int32 addr;
  623.     bpf_u_int32 mask;
  624.     int dir, proto;
  625.     u_int src_off, dst_off;
  626. {
  627.     struct block *b0, *b1;
  628.     u_int offset;
  629.  
  630.     switch (dir) {
  631.  
  632.     case Q_SRC:
  633.         offset = src_off;
  634.         break;
  635.  
  636.     case Q_DST:
  637.         offset = dst_off;
  638.         break;
  639.  
  640.     case Q_AND:
  641.         b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
  642.         b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
  643.         gen_and(b0, b1);
  644.         return b1;
  645.  
  646.     case Q_OR:
  647.     case Q_DEFAULT:
  648.         b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
  649.         b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
  650.         gen_or(b0, b1);
  651.         return b1;
  652.  
  653.     default:
  654.         abort();
  655.     }
  656.     b0 = gen_linktype(proto);
  657.     b1 = gen_mcmp(offset, BPF_W, (bpf_int32)addr, mask);
  658.     gen_and(b0, b1);
  659.     return b1;
  660. }
  661.  
  662. static struct block *
  663. gen_ehostop(eaddr, dir)
  664.     register const u_char *eaddr;
  665.     register int dir;
  666. {
  667.     register struct block *b0, *b1;
  668.  
  669.     switch (dir) {
  670.     case Q_SRC:
  671.         return gen_bcmp(6, 6, eaddr);
  672.  
  673.     case Q_DST:
  674.         return gen_bcmp(0, 6, eaddr);
  675.  
  676.     case Q_AND:
  677.         b0 = gen_ehostop(eaddr, Q_SRC);
  678.         b1 = gen_ehostop(eaddr, Q_DST);
  679.         gen_and(b0, b1);
  680.         return b1;
  681.  
  682.     case Q_DEFAULT:
  683.     case Q_OR:
  684.         b0 = gen_ehostop(eaddr, Q_SRC);
  685.         b1 = gen_ehostop(eaddr, Q_DST);
  686.         gen_or(b0, b1);
  687.         return b1;
  688.     }
  689.     abort();
  690.     /* NOTREACHED */
  691. }
  692.  
  693. /*
  694.  * Like gen_ehostop, but for DLT_FDDI
  695.  */
  696. static struct block *
  697. gen_fhostop(eaddr, dir)
  698.     register const u_char *eaddr;
  699.     register int dir;
  700. {
  701.     struct block *b0, *b1;
  702.  
  703.     switch (dir) {
  704.     case Q_SRC:
  705. #ifdef PCAP_FDDIPAD
  706.         return gen_bcmp(6 + 1 + pcap_fddipad, 6, eaddr);
  707. #else
  708.         return gen_bcmp(6 + 1, 6, eaddr);
  709. #endif
  710.  
  711.     case Q_DST:
  712. #ifdef PCAP_FDDIPAD
  713.         return gen_bcmp(0 + 1 + pcap_fddipad, 6, eaddr);
  714. #else
  715.         return gen_bcmp(0 + 1, 6, eaddr);
  716. #endif
  717.  
  718.     case Q_AND:
  719.         b0 = gen_fhostop(eaddr, Q_SRC);
  720.         b1 = gen_fhostop(eaddr, Q_DST);
  721.         gen_and(b0, b1);
  722.         return b1;
  723.  
  724.     case Q_DEFAULT:
  725.     case Q_OR:
  726.         b0 = gen_fhostop(eaddr, Q_SRC);
  727.         b1 = gen_fhostop(eaddr, Q_DST);
  728.         gen_or(b0, b1);
  729.         return b1;
  730.     }
  731.     abort();
  732.     /* NOTREACHED */
  733. }
  734.  
  735. /*
  736.  * This is quite tricky because there may be pad bytes in front of the
  737.  * DECNET header, and then there are two possible data packet formats that
  738.  * carry both src and dst addresses, plus 5 packet types in a format that
  739.  * carries only the src node, plus 2 types that use a different format and
  740.  * also carry just the src node.
  741.  *
  742.  * Yuck.
  743.  *
  744.  * Instead of doing those all right, we just look for data packets with
  745.  * 0 or 1 bytes of padding.  If you want to look at other packets, that
  746.  * will require a lot more hacking.
  747.  *
  748.  * To add support for filtering on DECNET "areas" (network numbers)
  749.  * one would want to add a "mask" argument to this routine.  That would
  750.  * make the filter even more inefficient, although one could be clever
  751.  * and not generate masking instructions if the mask is 0xFFFF.
  752.  */
  753. static struct block *
  754. gen_dnhostop(addr, dir, base_off)
  755.     bpf_u_int32 addr;
  756.     int dir;
  757.     u_int base_off;
  758. {
  759.     struct block *b0, *b1, *b2, *tmp;
  760.     u_int offset_lh;    /* offset if long header is received */
  761.     u_int offset_sh;    /* offset if short header is received */
  762.  
  763.     switch (dir) {
  764.  
  765.     case Q_DST:
  766.         offset_sh = 1;    /* follows flags */
  767.         offset_lh = 7;    /* flgs,darea,dsubarea,HIORD */
  768.         break;
  769.  
  770.     case Q_SRC:
  771.         offset_sh = 3;    /* follows flags, dstnode */
  772.         offset_lh = 15;    /* flgs,darea,dsubarea,did,sarea,ssub,HIORD */
  773.         break;
  774.  
  775.     case Q_AND:
  776.         /* Inefficient because we do our Calvinball dance twice */
  777.         b0 = gen_dnhostop(addr, Q_SRC, base_off);
  778.         b1 = gen_dnhostop(addr, Q_DST, base_off);
  779.         gen_and(b0, b1);
  780.         return b1;
  781.  
  782.     case Q_OR:
  783.     case Q_DEFAULT:
  784.         /* Inefficient because we do our Calvinball dance twice */
  785.         b0 = gen_dnhostop(addr, Q_SRC, base_off);
  786.         b1 = gen_dnhostop(addr, Q_DST, base_off);
  787.         gen_or(b0, b1);
  788.         return b1;
  789.  
  790.     default:
  791.         abort();
  792.     }
  793.     b0 = gen_linktype(ETHERTYPE_DN);
  794.     /* Check for pad = 1, long header case */
  795.     tmp = gen_mcmp(base_off + 2, BPF_H,
  796.         (bpf_int32)ntohs(0x0681), (bpf_int32)ntohs(0x07FF));
  797.     b1 = gen_cmp(base_off + 2 + 1 + offset_lh,
  798.         BPF_H, (bpf_int32)ntohs(addr));
  799.     gen_and(tmp, b1);
  800.     /* Check for pad = 0, long header case */
  801.     tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x06, (bpf_int32)0x7);
  802.     b2 = gen_cmp(base_off + 2 + offset_lh, BPF_H, (bpf_int32)ntohs(addr));
  803.     gen_and(tmp, b2);
  804.     gen_or(b2, b1);
  805.     /* Check for pad = 1, short header case */
  806.     tmp = gen_mcmp(base_off + 2, BPF_H,
  807.         (bpf_int32)ntohs(0x0281), (bpf_int32)ntohs(0x07FF));
  808.     b2 = gen_cmp(base_off + 2 + 1 + offset_sh,
  809.         BPF_H, (bpf_int32)ntohs(addr));
  810.     gen_and(tmp, b2);
  811.     gen_or(b2, b1);
  812.     /* Check for pad = 0, short header case */
  813.     tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x02, (bpf_int32)0x7);
  814.     b2 = gen_cmp(base_off + 2 + offset_sh, BPF_H, (bpf_int32)ntohs(addr));
  815.     gen_and(tmp, b2);
  816.     gen_or(b2, b1);
  817.  
  818.     /* Combine with test for linktype */
  819.     gen_and(b0, b1);
  820.     return b1;
  821. }
  822.  
  823. static struct block *
  824. gen_host(addr, mask, proto, dir)
  825.     bpf_u_int32 addr;
  826.     bpf_u_int32 mask;
  827.     int proto;
  828.     int dir;
  829. {
  830.     struct block *b0, *b1;
  831.  
  832.     switch (proto) {
  833.  
  834.     case Q_DEFAULT:
  835.         b0 = gen_host(addr, mask, Q_IP, dir);
  836.         b1 = gen_host(addr, mask, Q_ARP, dir);
  837.         gen_or(b0, b1);
  838.         b0 = gen_host(addr, mask, Q_RARP, dir);
  839.         gen_or(b1, b0);
  840.         return b0;
  841.  
  842.     case Q_IP:
  843.         return gen_hostop(addr, mask, dir, ETHERTYPE_IP,
  844.                   off_nl + 12, off_nl + 16);
  845.  
  846.     case Q_RARP:
  847.         return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP,
  848.                   off_nl + 14, off_nl + 24);
  849.  
  850.     case Q_ARP:
  851.         return gen_hostop(addr, mask, dir, ETHERTYPE_ARP,
  852.                   off_nl + 14, off_nl + 24);
  853.  
  854.     case Q_TCP:
  855.         bpf_error("'tcp' modifier applied to host");
  856.  
  857.     case Q_UDP:
  858.         bpf_error("'udp' modifier applied to host");
  859.  
  860.     case Q_ICMP:
  861.         bpf_error("'icmp' modifier applied to host");
  862.  
  863.     case Q_IGMP:
  864.         bpf_error("'igmp' modifier applied to host");
  865.  
  866.     case Q_IGRP:
  867.         bpf_error("'igrp' modifier applied to host");
  868.  
  869.     case Q_ATALK:
  870.         bpf_error("ATALK host filtering not implemented");
  871.  
  872.     case Q_DECNET:
  873.         return gen_dnhostop(addr, dir, off_nl);
  874.  
  875.     case Q_SCA:
  876.         bpf_error("SCA host filtering not implemented");
  877.  
  878.     case Q_LAT:
  879.         bpf_error("LAT host filtering not implemented");
  880.  
  881.     case Q_MOPDL:
  882.         bpf_error("MOPDL host filtering not implemented");
  883.  
  884.     case Q_MOPRC:
  885.         bpf_error("MOPRC host filtering not implemented");
  886.  
  887.     default:
  888.         abort();
  889.     }
  890.     /* NOTREACHED */
  891. }
  892.  
  893. static struct block *
  894. gen_gateway(eaddr, alist, proto, dir)
  895.     const u_char *eaddr;
  896.     bpf_u_int32 **alist;
  897.     int proto;
  898.     int dir;
  899. {
  900.     struct block *b0, *b1, *tmp;
  901.  
  902.     if (dir != 0)
  903.         bpf_error("direction applied to 'gateway'");
  904.  
  905.     switch (proto) {
  906.     case Q_DEFAULT:
  907.     case Q_IP:
  908.     case Q_ARP:
  909.     case Q_RARP:
  910.         if (linktype == DLT_EN10MB)
  911.             b0 = gen_ehostop(eaddr, Q_OR);
  912.         else if (linktype == DLT_FDDI)
  913.             b0 = gen_fhostop(eaddr, Q_OR);
  914.         else
  915.             bpf_error(
  916.                 "'gateway' supported only on ethernet or FDDI");
  917.  
  918.         b1 = gen_host(**alist++, 0xffffffff, proto, Q_OR);
  919.         while (*alist) {
  920.             tmp = gen_host(**alist++, 0xffffffff, proto, Q_OR);
  921.             gen_or(b1, tmp);
  922.             b1 = tmp;
  923.         }
  924.         gen_not(b1);
  925.         gen_and(b0, b1);
  926.         return b1;
  927.     }
  928.     bpf_error("illegal modifier of 'gateway'");
  929.     /* NOTREACHED */
  930. }
  931.  
  932. struct block *
  933. gen_proto_abbrev(proto)
  934.     int proto;
  935. {
  936.     struct block *b0, *b1;
  937.  
  938.     switch (proto) {
  939.  
  940.     case Q_TCP:
  941.         b0 = gen_linktype(ETHERTYPE_IP);
  942.         b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_TCP);
  943.         gen_and(b0, b1);
  944.         break;
  945.  
  946.     case Q_UDP:
  947.         b0 =  gen_linktype(ETHERTYPE_IP);
  948.         b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_UDP);
  949.         gen_and(b0, b1);
  950.         break;
  951.  
  952.     case Q_ICMP:
  953.         b0 =  gen_linktype(ETHERTYPE_IP);
  954.         b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_ICMP);
  955.         gen_and(b0, b1);
  956.         break;
  957.  
  958.     case Q_IGMP:
  959.         b0 =  gen_linktype(ETHERTYPE_IP);
  960.         b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)2);
  961.         gen_and(b0, b1);
  962.         break;
  963.  
  964. #ifndef    IPPROTO_IGRP
  965. #define    IPPROTO_IGRP    9
  966. #endif
  967.     case Q_IGRP:
  968.         b0 =  gen_linktype(ETHERTYPE_IP);
  969.         b1 = gen_cmp(off_nl + 9, BPF_B, (long)IPPROTO_IGRP);
  970.         gen_and(b0, b1);
  971.         break;
  972.  
  973.     case Q_IP:
  974.         b1 =  gen_linktype(ETHERTYPE_IP);
  975.         break;
  976.  
  977.     case Q_ARP:
  978.         b1 =  gen_linktype(ETHERTYPE_ARP);
  979.         break;
  980.  
  981.     case Q_RARP:
  982.         b1 =  gen_linktype(ETHERTYPE_REVARP);
  983.         break;
  984.  
  985.     case Q_LINK:
  986.         bpf_error("link layer applied in wrong context");
  987.  
  988.     case Q_ATALK:
  989.         b1 =  gen_linktype(ETHERTYPE_ATALK);
  990.         break;
  991.  
  992.     case Q_DECNET:
  993.         b1 =  gen_linktype(ETHERTYPE_DN);
  994.         break;
  995.  
  996.     case Q_SCA:
  997.         b1 =  gen_linktype(ETHERTYPE_SCA);
  998.         break;
  999.  
  1000.     case Q_LAT:
  1001.         b1 =  gen_linktype(ETHERTYPE_LAT);
  1002.         break;
  1003.  
  1004.     case Q_MOPDL:
  1005.         b1 =  gen_linktype(ETHERTYPE_MOPDL);
  1006.         break;
  1007.  
  1008.     case Q_MOPRC:
  1009.         b1 =  gen_linktype(ETHERTYPE_MOPRC);
  1010.         break;
  1011.  
  1012.     default:
  1013.         abort();
  1014.     }
  1015.     return b1;
  1016. }
  1017.  
  1018. static struct block *
  1019. gen_ipfrag()
  1020. {
  1021.     struct slist *s;
  1022.     struct block *b;
  1023.  
  1024.     /* not ip frag */
  1025.     s = new_stmt(BPF_LD|BPF_H|BPF_ABS);
  1026.     s->s.k = off_nl + 6;
  1027.     b = new_block(JMP(BPF_JSET));
  1028.     b->s.k = 0x1fff;
  1029.     b->stmts = s;
  1030.     gen_not(b);
  1031.  
  1032.     return b;
  1033. }
  1034.  
  1035. static struct block *
  1036. gen_portatom(off, v)
  1037.     int off;
  1038.     bpf_int32 v;
  1039. {
  1040.     struct slist *s;
  1041.     struct block *b;
  1042.  
  1043.     s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
  1044.     s->s.k = off_nl;
  1045.  
  1046.     s->next = new_stmt(BPF_LD|BPF_IND|BPF_H);
  1047.     s->next->s.k = off_nl + off;
  1048.  
  1049.     b = new_block(JMP(BPF_JEQ));
  1050.     b->stmts = s;
  1051.     b->s.k = v;
  1052.  
  1053.     return b;
  1054. }
  1055.  
  1056. struct block *
  1057. gen_portop(port, proto, dir)
  1058.     int port, proto, dir;
  1059. {
  1060.     struct block *b0, *b1, *tmp;
  1061.  
  1062.     /* ip proto 'proto' */
  1063.     tmp = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)proto);
  1064.     b0 = gen_ipfrag();
  1065.     gen_and(tmp, b0);
  1066.  
  1067.     switch (dir) {
  1068.     case Q_SRC:
  1069.         b1 = gen_portatom(0, (bpf_int32)port);
  1070.         break;
  1071.  
  1072.     case Q_DST:
  1073.         b1 = gen_portatom(2, (bpf_int32)port);
  1074.         break;
  1075.  
  1076.     case Q_OR:
  1077.     case Q_DEFAULT:
  1078.         tmp = gen_portatom(0, (bpf_int32)port);
  1079.         b1 = gen_portatom(2, (bpf_int32)port);
  1080.         gen_or(tmp, b1);
  1081.         break;
  1082.  
  1083.     case Q_AND:
  1084.         tmp = gen_portatom(0, (bpf_int32)port);
  1085.         b1 = gen_portatom(2, (bpf_int32)port);
  1086.         gen_and(tmp, b1);
  1087.         break;
  1088.  
  1089.     default:
  1090.         abort();
  1091.     }
  1092.     gen_and(b0, b1);
  1093.  
  1094.     return b1;
  1095. }
  1096.  
  1097. static struct block *
  1098. gen_port(port, ip_proto, dir)
  1099.     int port;
  1100.     int ip_proto;
  1101.     int dir;
  1102. {
  1103.     struct block *b0, *b1, *tmp;
  1104.  
  1105.     /* ether proto ip */
  1106.     b0 =  gen_linktype(ETHERTYPE_IP);
  1107.  
  1108.     switch (ip_proto) {
  1109.     case IPPROTO_UDP:
  1110.     case IPPROTO_TCP:
  1111.         b1 = gen_portop(port, ip_proto, dir);
  1112.         break;
  1113.  
  1114.     case PROTO_UNDEF:
  1115.         tmp = gen_portop(port, IPPROTO_TCP, dir);
  1116.         b1 = gen_portop(port, IPPROTO_UDP, dir);
  1117.         gen_or(tmp, b1);
  1118.         break;
  1119.  
  1120.     default:
  1121.         abort();
  1122.     }
  1123.     gen_and(b0, b1);
  1124.     return b1;
  1125. }
  1126.  
  1127. static int
  1128. lookup_proto(name, proto)
  1129.     register const char *name;
  1130.     register int proto;
  1131. {
  1132.     register int v;
  1133.  
  1134.     switch (proto) {
  1135.  
  1136.     case Q_DEFAULT:
  1137.     case Q_IP:
  1138.         v = pcap_nametoproto(name);
  1139.         if (v == PROTO_UNDEF)
  1140.             bpf_error("unknown ip proto '%s'", name);
  1141.         break;
  1142.  
  1143.     case Q_LINK:
  1144.         /* XXX should look up h/w protocol type based on linktype */
  1145.         v = pcap_nametoeproto(name);
  1146.         if (v == PROTO_UNDEF)
  1147.             bpf_error("unknown ether proto '%s'", name);
  1148.         break;
  1149.  
  1150.     default:
  1151.         v = PROTO_UNDEF;
  1152.         break;
  1153.     }
  1154.     return v;
  1155. }
  1156.  
  1157. static struct block *
  1158. gen_proto(v, proto, dir)
  1159.     int v;
  1160.     int proto;
  1161.     int dir;
  1162. {
  1163.     struct block *b0, *b1;
  1164.  
  1165.     if (dir != Q_DEFAULT)
  1166.         bpf_error("direction applied to 'proto'");
  1167.  
  1168.     switch (proto) {
  1169.     case Q_DEFAULT:
  1170.     case Q_IP:
  1171.         b0 = gen_linktype(ETHERTYPE_IP);
  1172.         b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)v);
  1173.         gen_and(b0, b1);
  1174.         return b1;
  1175.  
  1176.     case Q_ARP:
  1177.         bpf_error("arp does not encapsulate another protocol");
  1178.         /* NOTREACHED */
  1179.  
  1180.     case Q_RARP:
  1181.         bpf_error("rarp does not encapsulate another protocol");
  1182.         /* NOTREACHED */
  1183.  
  1184.     case Q_ATALK:
  1185.         bpf_error("atalk encapsulation is not specifiable");
  1186.         /* NOTREACHED */
  1187.  
  1188.     case Q_DECNET:
  1189.         bpf_error("decnet encapsulation is not specifiable");
  1190.         /* NOTREACHED */
  1191.  
  1192.     case Q_SCA:
  1193.         bpf_error("sca does not encapsulate another protocol");
  1194.         /* NOTREACHED */
  1195.  
  1196.     case Q_LAT:
  1197.         bpf_error("lat does not encapsulate another protocol");
  1198.         /* NOTREACHED */
  1199.  
  1200.     case Q_MOPRC:
  1201.         bpf_error("moprc does not encapsulate another protocol");
  1202.         /* NOTREACHED */
  1203.  
  1204.     case Q_MOPDL:
  1205.         bpf_error("mopdl does not encapsulate another protocol");
  1206.         /* NOTREACHED */
  1207.  
  1208.     case Q_LINK:
  1209.         return gen_linktype(v);
  1210.  
  1211.     case Q_UDP:
  1212.         bpf_error("'udp proto' is bogus");
  1213.         /* NOTREACHED */
  1214.  
  1215.     case Q_TCP:
  1216.         bpf_error("'tcp proto' is bogus");
  1217.         /* NOTREACHED */
  1218.  
  1219.     case Q_ICMP:
  1220.         bpf_error("'icmp proto' is bogus");
  1221.         /* NOTREACHED */
  1222.  
  1223.     case Q_IGMP:
  1224.         bpf_error("'igmp proto' is bogus");
  1225.         /* NOTREACHED */
  1226.  
  1227.     case Q_IGRP:
  1228.         bpf_error("'igrp proto' is bogus");
  1229.         /* NOTREACHED */
  1230.  
  1231.     default:
  1232.         abort();
  1233.         /* NOTREACHED */
  1234.     }
  1235.     /* NOTREACHED */
  1236. }
  1237.  
  1238. struct block *
  1239. gen_scode(name, q)
  1240.     register const char *name;
  1241.     struct qual q;
  1242. {
  1243.     int proto = q.proto;
  1244.     int dir = q.dir;
  1245.     int tproto;
  1246.     u_char *eaddr;
  1247.     bpf_u_int32 mask, addr, **alist;
  1248.     struct block *b, *tmp;
  1249.     int port, real_proto;
  1250.  
  1251.     switch (q.addr) {
  1252.  
  1253.     case Q_NET:
  1254.         addr = pcap_nametonetaddr(name);
  1255.         if (addr == 0)
  1256.             bpf_error("unknown network '%s'", name);
  1257.         /* Left justify network addr and calculate its network mask */
  1258.         mask = 0xffffffff;
  1259.         while (addr && (addr & 0xff000000) == 0) {
  1260.             addr <<= 8;
  1261.             mask <<= 8;
  1262.         }
  1263.         return gen_host(addr, mask, proto, dir);
  1264.  
  1265.     case Q_DEFAULT:
  1266.     case Q_HOST:
  1267.         if (proto == Q_LINK) {
  1268.             switch (linktype) {
  1269.  
  1270.             case DLT_EN10MB:
  1271.                 eaddr = pcap_ether_hostton(name);
  1272.                 if (eaddr == NULL)
  1273.                     bpf_error(
  1274.                         "unknown ether host '%s'", name);
  1275.                 return gen_ehostop(eaddr, dir);
  1276.  
  1277.             case DLT_FDDI:
  1278.                 eaddr = pcap_ether_hostton(name);
  1279.                 if (eaddr == NULL)
  1280.                     bpf_error(
  1281.                         "unknown FDDI host '%s'", name);
  1282.                 return gen_fhostop(eaddr, dir);
  1283.  
  1284.             default:
  1285.                 bpf_error(
  1286.             "only ethernet/FDDI supports link-level host name");
  1287.                 break;
  1288.             }
  1289.         } else if (proto == Q_DECNET) {
  1290.             unsigned short dn_addr = __pcap_nametodnaddr(name);
  1291.             /*
  1292.              * I don't think DECNET hosts can be multihomed, so
  1293.              * there is no need to build up a list of addresses
  1294.              */
  1295.             return (gen_host(dn_addr, 0, proto, dir));
  1296.         } else {
  1297.             alist = pcap_nametoaddr(name);
  1298.             if (alist == NULL || *alist == NULL)
  1299.                 bpf_error("unknown host '%s'", name);
  1300.             tproto = proto;
  1301.             if (off_linktype == -1 && tproto == Q_DEFAULT)
  1302.                 tproto = Q_IP;
  1303.             b = gen_host(**alist++, 0xffffffff, tproto, dir);
  1304.             while (*alist) {
  1305.                 tmp = gen_host(**alist++, 0xffffffff,
  1306.                            tproto, dir);
  1307.                 gen_or(b, tmp);
  1308.                 b = tmp;
  1309.             }
  1310.             return b;
  1311.         }
  1312.  
  1313.     case Q_PORT:
  1314.         if (proto != Q_DEFAULT && proto != Q_UDP && proto != Q_TCP)
  1315.             bpf_error("illegal qualifier of 'port'");
  1316.         if (pcap_nametoport(name, &port, &real_proto) == 0)
  1317.             bpf_error("unknown port '%s'", name);
  1318.         if (proto == Q_UDP) {
  1319.             if (real_proto == IPPROTO_TCP)
  1320.                 bpf_error("port '%s' is tcp", name);
  1321.             else
  1322.                 /* override PROTO_UNDEF */
  1323.                 real_proto = IPPROTO_UDP;
  1324.         }
  1325.         if (proto == Q_TCP) {
  1326.             if (real_proto == IPPROTO_UDP)
  1327.                 bpf_error("port '%s' is udp", name);
  1328.             else
  1329.                 /* override PROTO_UNDEF */
  1330.                 real_proto = IPPROTO_TCP;
  1331.         }
  1332.         return gen_port(port, real_proto, dir);
  1333.  
  1334.     case Q_GATEWAY:
  1335.         eaddr = pcap_ether_hostton(name);
  1336.         if (eaddr == NULL)
  1337.             bpf_error("unknown ether host: %s", name);
  1338.  
  1339.         alist = pcap_nametoaddr(name);
  1340.         if (alist == NULL || *alist == NULL)
  1341.             bpf_error("unknown host '%s'", name);
  1342.         return gen_gateway(eaddr, alist, proto, dir);
  1343.  
  1344.     case Q_PROTO:
  1345.         real_proto = lookup_proto(name, proto);
  1346.         if (real_proto >= 0)
  1347.             return gen_proto(real_proto, proto, dir);
  1348.         else
  1349.             bpf_error("unknown protocol: %s", name);
  1350.  
  1351.     case Q_UNDEF:
  1352.         syntax();
  1353.         /* NOTREACHED */
  1354.     }
  1355.     abort();
  1356.     /* NOTREACHED */
  1357. }
  1358.  
  1359. struct block *
  1360. gen_mcode(s1, s2, masklen, q)
  1361.     register const char *s1, *s2;
  1362.     register int masklen;
  1363.     struct qual q;
  1364. {
  1365.     register int nlen, mlen;
  1366.     bpf_u_int32 n, m;
  1367.  
  1368.     nlen = __pcap_atoin(s1, &n);
  1369.     /* Promote short ipaddr */
  1370.     n <<= 32 - nlen;
  1371.  
  1372.     if (s2 != NULL) {
  1373.         mlen = __pcap_atoin(s2, &m);
  1374.         /* Promote short ipaddr */
  1375.         m <<= 32 - mlen;
  1376.         if ((n & ~m) != 0)
  1377.             bpf_error("non-network bits set in \"%s mask %s\"",
  1378.                 s1, s2);
  1379.     } else {
  1380.         /* Convert mask len to mask */
  1381.         if (masklen > 32)
  1382.             bpf_error("mask length must be <= 32");
  1383.         m = 0xffffffff << (32 - masklen);
  1384.         if ((n & ~m) != 0)
  1385.             bpf_error("non-network bits set in \"%s/%d\"",
  1386.                 s1, masklen);
  1387.     }
  1388.  
  1389.     switch (q.addr) {
  1390.  
  1391.     case Q_NET:
  1392.         return gen_host(n, m, q.proto, q.dir);
  1393.  
  1394.     default:
  1395.         bpf_error("Mask syntax for networks only");
  1396.         /* NOTREACHED */
  1397.     }
  1398. }
  1399.  
  1400. struct block *
  1401. gen_ncode(s, v, q)
  1402.     register const char *s;
  1403.     bpf_u_int32 v;
  1404.     struct qual q;
  1405. {
  1406.     bpf_u_int32 mask;
  1407.     int proto = q.proto;
  1408.     int dir = q.dir;
  1409.     register int vlen;
  1410.  
  1411.     if (s == NULL)
  1412.         vlen = 32;
  1413.     else if (q.proto == Q_DECNET)
  1414.         vlen = __pcap_atodn(s, &v);
  1415.     else
  1416.         vlen = __pcap_atoin(s, &v);
  1417.  
  1418.     switch (q.addr) {
  1419.  
  1420.     case Q_DEFAULT:
  1421.     case Q_HOST:
  1422.     case Q_NET:
  1423.         if (proto == Q_DECNET)
  1424.             return gen_host(v, 0, proto, dir);
  1425.         else if (proto == Q_LINK) {
  1426.             bpf_error("illegal link layer address");
  1427.         } else {
  1428.             mask = 0xffffffff;
  1429.             if (s == NULL && q.addr == Q_NET) {
  1430.                 /* Promote short net number */
  1431.                 while (v && (v & 0xff000000) == 0) {
  1432.                     v <<= 8;
  1433.                     mask <<= 8;
  1434.                 }
  1435.             } else {
  1436.                 /* Promote short ipaddr */
  1437.                 v <<= 32 - vlen;
  1438.                 mask <<= 32 - vlen;
  1439.             }
  1440.             return gen_host(v, mask, proto, dir);
  1441.         }
  1442.  
  1443.     case Q_PORT:
  1444.         if (proto == Q_UDP)
  1445.             proto = IPPROTO_UDP;
  1446.         else if (proto == Q_TCP)
  1447.             proto = IPPROTO_TCP;
  1448.         else if (proto == Q_DEFAULT)
  1449.             proto = PROTO_UNDEF;
  1450.         else
  1451.             bpf_error("illegal qualifier of 'port'");
  1452.  
  1453.         return gen_port((int)v, proto, dir);
  1454.  
  1455.     case Q_GATEWAY:
  1456.         bpf_error("'gateway' requires a name");
  1457.         /* NOTREACHED */
  1458.  
  1459.     case Q_PROTO:
  1460.         return gen_proto((int)v, proto, dir);
  1461.  
  1462.     case Q_UNDEF:
  1463.         syntax();
  1464.         /* NOTREACHED */
  1465.  
  1466.     default:
  1467.         abort();
  1468.         /* NOTREACHED */
  1469.     }
  1470.     /* NOTREACHED */
  1471. }
  1472.  
  1473. struct block *
  1474. gen_ecode(eaddr, q)
  1475.     register const u_char *eaddr;
  1476.     struct qual q;
  1477. {
  1478.     if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
  1479.         if (linktype == DLT_EN10MB)
  1480.             return gen_ehostop(eaddr, (int)q.dir);
  1481.         if (linktype == DLT_FDDI)
  1482.             return gen_fhostop(eaddr, (int)q.dir);
  1483.     }
  1484.     bpf_error("ethernet address used in non-ether expression");
  1485.     /* NOTREACHED */
  1486. }
  1487.  
  1488. void
  1489. sappend(s0, s1)
  1490.     struct slist *s0, *s1;
  1491. {
  1492.     /*
  1493.      * This is definitely not the best way to do this, but the
  1494.      * lists will rarely get long.
  1495.      */
  1496.     while (s0->next)
  1497.         s0 = s0->next;
  1498.     s0->next = s1;
  1499. }
  1500.  
  1501. static struct slist *
  1502. xfer_to_x(a)
  1503.     struct arth *a;
  1504. {
  1505.     struct slist *s;
  1506.  
  1507.     s = new_stmt(BPF_LDX|BPF_MEM);
  1508.     s->s.k = a->regno;
  1509.     return s;
  1510. }
  1511.  
  1512. static struct slist *
  1513. xfer_to_a(a)
  1514.     struct arth *a;
  1515. {
  1516.     struct slist *s;
  1517.  
  1518.     s = new_stmt(BPF_LD|BPF_MEM);
  1519.     s->s.k = a->regno;
  1520.     return s;
  1521. }
  1522.  
  1523. struct arth *
  1524. gen_load(proto, index, size)
  1525.     int proto;
  1526.     struct arth *index;
  1527.     int size;
  1528. {
  1529.     struct slist *s, *tmp;
  1530.     struct block *b;
  1531.     int regno = alloc_reg();
  1532.  
  1533.     free_reg(index->regno);
  1534.     switch (size) {
  1535.  
  1536.     default:
  1537.         bpf_error("data size must be 1, 2, or 4");
  1538.  
  1539.     case 1:
  1540.         size = BPF_B;
  1541.         break;
  1542.  
  1543.     case 2:
  1544.         size = BPF_H;
  1545.         break;
  1546.  
  1547.     case 4:
  1548.         size = BPF_W;
  1549.         break;
  1550.     }
  1551.     switch (proto) {
  1552.     default:
  1553.         bpf_error("unsupported index operation");
  1554.  
  1555.     case Q_LINK:
  1556.         s = xfer_to_x(index);
  1557.         tmp = new_stmt(BPF_LD|BPF_IND|size);
  1558.         sappend(s, tmp);
  1559.         sappend(index->s, s);
  1560.         break;
  1561.  
  1562.     case Q_IP:
  1563.     case Q_ARP:
  1564.     case Q_RARP:
  1565.     case Q_ATALK:
  1566.     case Q_DECNET:
  1567.     case Q_SCA:
  1568.     case Q_LAT:
  1569.     case Q_MOPRC:
  1570.     case Q_MOPDL:
  1571.         /* XXX Note that we assume a fixed link link header here. */
  1572.         s = xfer_to_x(index);
  1573.         tmp = new_stmt(BPF_LD|BPF_IND|size);
  1574.         tmp->s.k = off_nl;
  1575.         sappend(s, tmp);
  1576.         sappend(index->s, s);
  1577.  
  1578.         b = gen_proto_abbrev(proto);
  1579.         if (index->b)
  1580.             gen_and(index->b, b);
  1581.         index->b = b;
  1582.         break;
  1583.  
  1584.     case Q_TCP:
  1585.     case Q_UDP:
  1586.     case Q_ICMP:
  1587.     case Q_IGMP:
  1588.     case Q_IGRP:
  1589.         s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
  1590.         s->s.k = off_nl;
  1591.         sappend(s, xfer_to_a(index));
  1592.         sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
  1593.         sappend(s, new_stmt(BPF_MISC|BPF_TAX));
  1594.         sappend(s, tmp = new_stmt(BPF_LD|BPF_IND|size));
  1595.         tmp->s.k = off_nl;
  1596.         sappend(index->s, s);
  1597.  
  1598.         gen_and(gen_proto_abbrev(proto), b = gen_ipfrag());
  1599.         if (index->b)
  1600.             gen_and(index->b, b);
  1601.         index->b = b;
  1602.         break;
  1603.     }
  1604.     index->regno = regno;
  1605.     s = new_stmt(BPF_ST);
  1606.     s->s.k = regno;
  1607.     sappend(index->s, s);
  1608.  
  1609.     return index;
  1610. }
  1611.  
  1612. struct block *
  1613. gen_relation(code, a0, a1, reversed)
  1614.     int code;
  1615.     struct arth *a0, *a1;
  1616.     int reversed;
  1617. {
  1618.     struct slist *s0, *s1, *s2;
  1619.     struct block *b, *tmp;
  1620.  
  1621.     s0 = xfer_to_x(a1);
  1622.     s1 = xfer_to_a(a0);
  1623.     s2 = new_stmt(BPF_ALU|BPF_SUB|BPF_X);
  1624.     b = new_block(JMP(code));
  1625.     if (code == BPF_JGT || code == BPF_JGE) {
  1626.         reversed = !reversed;
  1627.         b->s.k = 0x80000000;
  1628.     }
  1629.     if (reversed)
  1630.         gen_not(b);
  1631.  
  1632.     sappend(s1, s2);
  1633.     sappend(s0, s1);
  1634.     sappend(a1->s, s0);
  1635.     sappend(a0->s, a1->s);
  1636.  
  1637.     b->stmts = a0->s;
  1638.  
  1639.     free_reg(a0->regno);
  1640.     free_reg(a1->regno);
  1641.  
  1642.     /* 'and' together protocol checks */
  1643.     if (a0->b) {
  1644.         if (a1->b) {
  1645.             gen_and(a0->b, tmp = a1->b);
  1646.         }
  1647.         else
  1648.             tmp = a0->b;
  1649.     } else
  1650.         tmp = a1->b;
  1651.  
  1652.     if (tmp)
  1653.         gen_and(tmp, b);
  1654.  
  1655.     return b;
  1656. }
  1657.  
  1658. struct arth *
  1659. gen_loadlen()
  1660. {
  1661.     int regno = alloc_reg();
  1662.     struct arth *a = (struct arth *)newchunk(sizeof(*a));
  1663.     struct slist *s;
  1664.  
  1665.     s = new_stmt(BPF_LD|BPF_LEN);
  1666.     s->next = new_stmt(BPF_ST);
  1667.     s->next->s.k = regno;
  1668.     a->s = s;
  1669.     a->regno = regno;
  1670.  
  1671.     return a;
  1672. }
  1673.  
  1674. struct arth *
  1675. gen_loadi(val)
  1676.     int val;
  1677. {
  1678.     struct arth *a;
  1679.     struct slist *s;
  1680.     int reg;
  1681.  
  1682.     a = (struct arth *)newchunk(sizeof(*a));
  1683.  
  1684.     reg = alloc_reg();
  1685.  
  1686.     s = new_stmt(BPF_LD|BPF_IMM);
  1687.     s->s.k = val;
  1688.     s->next = new_stmt(BPF_ST);
  1689.     s->next->s.k = reg;
  1690.     a->s = s;
  1691.     a->regno = reg;
  1692.  
  1693.     return a;
  1694. }
  1695.  
  1696. struct arth *
  1697. gen_neg(a)
  1698.     struct arth *a;
  1699. {
  1700.     struct slist *s;
  1701.  
  1702.     s = xfer_to_a(a);
  1703.     sappend(a->s, s);
  1704.     s = new_stmt(BPF_ALU|BPF_NEG);
  1705.     s->s.k = 0;
  1706.     sappend(a->s, s);
  1707.     s = new_stmt(BPF_ST);
  1708.     s->s.k = a->regno;
  1709.     sappend(a->s, s);
  1710.  
  1711.     return a;
  1712. }
  1713.  
  1714. struct arth *
  1715. gen_arth(code, a0, a1)
  1716.     int code;
  1717.     struct arth *a0, *a1;
  1718. {
  1719.     struct slist *s0, *s1, *s2;
  1720.  
  1721.     s0 = xfer_to_x(a1);
  1722.     s1 = xfer_to_a(a0);
  1723.     s2 = new_stmt(BPF_ALU|BPF_X|code);
  1724.  
  1725.     sappend(s1, s2);
  1726.     sappend(s0, s1);
  1727.     sappend(a1->s, s0);
  1728.     sappend(a0->s, a1->s);
  1729.  
  1730.     free_reg(a1->regno);
  1731.  
  1732.     s0 = new_stmt(BPF_ST);
  1733.     a0->regno = s0->s.k = alloc_reg();
  1734.     sappend(a0->s, s0);
  1735.  
  1736.     return a0;
  1737. }
  1738.  
  1739. /*
  1740.  * Here we handle simple allocation of the scratch registers.
  1741.  * If too many registers are alloc'd, the allocator punts.
  1742.  */
  1743. static int regused[BPF_MEMWORDS];
  1744. static int curreg;
  1745.  
  1746. /*
  1747.  * Return the next free register.
  1748.  */
  1749. static int
  1750. alloc_reg()
  1751. {
  1752.     int n = BPF_MEMWORDS;
  1753.  
  1754.     while (--n >= 0) {
  1755.         if (regused[curreg])
  1756.             curreg = (curreg + 1) % BPF_MEMWORDS;
  1757.         else {
  1758.             regused[curreg] = 1;
  1759.             return curreg;
  1760.         }
  1761.     }
  1762.     bpf_error("too many registers needed to evaluate expression");
  1763.     /* NOTREACHED */
  1764. }
  1765.  
  1766. /*
  1767.  * Return a register to the table so it can
  1768.  * be used later.
  1769.  */
  1770. static void
  1771. free_reg(n)
  1772.     int n;
  1773. {
  1774.     regused[n] = 0;
  1775. }
  1776.  
  1777. static struct block *
  1778. gen_len(jmp, n)
  1779.     int jmp, n;
  1780. {
  1781.     struct slist *s;
  1782.     struct block *b;
  1783.  
  1784.     s = new_stmt(BPF_LD|BPF_LEN);
  1785.     b = new_block(JMP(jmp));
  1786.     b->stmts = s;
  1787.     b->s.k = n;
  1788.  
  1789.     return b;
  1790. }
  1791.  
  1792. struct block *
  1793. gen_greater(n)
  1794.     int n;
  1795. {
  1796.     return gen_len(BPF_JGE, n);
  1797. }
  1798.  
  1799. struct block *
  1800. gen_less(n)
  1801.     int n;
  1802. {
  1803.     struct block *b;
  1804.  
  1805.     b = gen_len(BPF_JGT, n);
  1806.     gen_not(b);
  1807.  
  1808.     return b;
  1809. }
  1810.  
  1811. struct block *
  1812. gen_byteop(op, idx, val)
  1813.     int op, idx, val;
  1814. {
  1815.     struct block *b;
  1816.     struct slist *s;
  1817.  
  1818.     switch (op) {
  1819.     default:
  1820.         abort();
  1821.  
  1822.     case '=':
  1823.         return gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
  1824.  
  1825.     case '<':
  1826.         b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
  1827.         b->s.code = JMP(BPF_JGE);
  1828.         gen_not(b);
  1829.         return b;
  1830.  
  1831.     case '>':
  1832.         b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
  1833.         b->s.code = JMP(BPF_JGT);
  1834.         return b;
  1835.  
  1836.     case '|':
  1837.         s = new_stmt(BPF_ALU|BPF_OR|BPF_K);
  1838.         break;
  1839.  
  1840.     case '&':
  1841.         s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
  1842.         break;
  1843.     }
  1844.     s->s.k = val;
  1845.     b = new_block(JMP(BPF_JEQ));
  1846.     b->stmts = s;
  1847.     gen_not(b);
  1848.  
  1849.     return b;
  1850. }
  1851.  
  1852. struct block *
  1853. gen_broadcast(proto)
  1854.     int proto;
  1855. {
  1856.     bpf_u_int32 hostmask;
  1857.     struct block *b0, *b1, *b2;
  1858.     static u_char ebroadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  1859.  
  1860.     switch (proto) {
  1861.  
  1862.     case Q_DEFAULT:
  1863.     case Q_LINK:
  1864.         if (linktype == DLT_EN10MB)
  1865.             return gen_ehostop(ebroadcast, Q_DST);
  1866.         if (linktype == DLT_FDDI)
  1867.             return gen_fhostop(ebroadcast, Q_DST);
  1868.         bpf_error("not a broadcast link");
  1869.         break;
  1870.  
  1871.     case Q_IP:
  1872.         b0 = gen_linktype(ETHERTYPE_IP);
  1873.         hostmask = ~netmask;
  1874.         b1 = gen_mcmp(off_nl + 16, BPF_W, (bpf_int32)0, hostmask);
  1875.         b2 = gen_mcmp(off_nl + 16, BPF_W,
  1876.                   (bpf_int32)(~0 & hostmask), hostmask);
  1877.         gen_or(b1, b2);
  1878.         gen_and(b0, b2);
  1879.         return b2;
  1880.     }
  1881.     bpf_error("only ether/ip broadcast filters supported");
  1882. }
  1883.  
  1884. struct block *
  1885. gen_multicast(proto)
  1886.     int proto;
  1887. {
  1888.     register struct block *b0, *b1;
  1889.     register struct slist *s;
  1890.  
  1891.     switch (proto) {
  1892.  
  1893.     case Q_DEFAULT:
  1894.     case Q_LINK:
  1895.         if (linktype == DLT_EN10MB) {
  1896.             /* ether[0] & 1 != 0 */
  1897.             s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
  1898.             s->s.k = 0;
  1899.             b0 = new_block(JMP(BPF_JSET));
  1900.             b0->s.k = 1;
  1901.             b0->stmts = s;
  1902.             return b0;
  1903.         }
  1904.  
  1905.         if (linktype == DLT_FDDI) {
  1906.             /* XXX TEST THIS: MIGHT NOT PORT PROPERLY XXX */
  1907.             /* fddi[1] & 1 != 0 */
  1908.             s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
  1909.             s->s.k = 1;
  1910.             b0 = new_block(JMP(BPF_JSET));
  1911.             b0->s.k = 1;
  1912.             b0->stmts = s;
  1913.             return b0;
  1914.         }
  1915.         /* Link not known to support multicasts */
  1916.         break;
  1917.  
  1918.     case Q_IP:
  1919.         b0 = gen_linktype(ETHERTYPE_IP);
  1920.         b1 = gen_cmp(off_nl + 16, BPF_B, (bpf_int32)224);
  1921.         b1->s.code = JMP(BPF_JGE);
  1922.         gen_and(b0, b1);
  1923.         return b1;
  1924.     }
  1925.     bpf_error("only IP multicast filters supported on ethernet/FDDI");
  1926. }
  1927.  
  1928. /*
  1929.  * generate command for inbound/outbound.  It's here so we can
  1930.  * make it link-type specific.  'dir' = 0 implies "inbound",
  1931.  * = 1 implies "outbound".
  1932.  */
  1933. struct block *
  1934. gen_inbound(dir)
  1935.     int dir;
  1936. {
  1937.     register struct block *b0;
  1938.  
  1939.     b0 = gen_relation(BPF_JEQ,
  1940.               gen_load(Q_LINK, gen_loadi(0), 1),
  1941.               gen_loadi(0),
  1942.               dir);
  1943.     return (b0);
  1944. }
  1945.