开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
gencode.c
资源名称：nessus-libraries_2.2.10.orig.tar.gz　[点击查看]
上传用户：tjescc
上传日期：2021-02-23
资源大小：419k
文件大小：37k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

gencode.c：源码内容
  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: /usr/local/cvs/nessus-libraries/libpcap-nessus/gencode.c,v 1.3 2003/02/06 20:28:07 renaud Exp $ (LBL)";
  24. #endif
  26. #include <sys/types.h>
  27. #include <sys/socket.h>
  28. #include <sys/time.h>
  30. #if __STDC__
  31. struct mbuf;
  32. struct rtentry;
  33. #endif
  35. #include <net/if.h>
  37. #include <netinet/in.h>
  38. #include <netinet/if_ether.h>
  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
  49. #include "pcap-int.h"
  51. #include "ethertype.h"
  52. #include "gencode.h"
  53. #include "ppp.h"
  54. #include "pcap-namedb.h"
  56. #include "gnuc.h"
  57. #ifdef HAVE_OS_PROTO_H
  58. #include "os-proto.h"
  59. #endif
  61. #define JMP(c) ((c)|BPF_JMP|BPF_K)
  63. /* Locals */
  64. static jmp_buf top_ctx;
  65. static pcap_t *bpf_pcap;
  67. /* XXX */
  68. #ifdef PCAP_FDDIPAD
  69. int pcap_fddipad = PCAP_FDDIPAD;
  70. #else
  71. int pcap_fddipad;
  72. #endif
  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;
  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. }
  98. static void init_linktype(int);
  100. static int alloc_reg(void);
  101. static void free_reg(int);
  103. static struct block *root;
  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. };
  118. static struct chunk chunks[NCHUNKS];
  119. static int cur_chunk;
  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);
  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);
  153. static void *
  154. newchunk(n)
  155. u_int n;
  156. {
  157. struct chunk *cp;
  158. int k, size;
  160. /* XXX Round up to nearest long. */
  161. n = (n + sizeof(long) - 1) & ~(sizeof(long) - 1);
  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. }
  179. static void
  180. freechunks()
  181. {
  182. int i;
  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. }
  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);
  202. strcpy(cp, s);
  203. return (cp);
  204. }
  206. static inline struct block *
  207. new_block(code)
  208. int code;
  209. {
  210. struct block *p;
  212. p = (struct block *)newchunk(sizeof(*p));
  213. p->s.code = code;
  214. p->head = p;
  216. return p;
  217. }
  219. static inline struct slist *
  220. new_stmt(code)
  221. int code;
  222. {
  223. struct slist *p;
  225. p = (struct slist *)newchunk(sizeof(*p));
  226. p->s.code = code;
  228. return p;
  229. }
  231. static struct block *
  232. gen_retblk(v)
  233. int v;
  234. {
  235. struct block *b = new_block(BPF_RET|BPF_K);
  237. b->s.k = v;
  238. return b;
  239. }
  241. static inline void
  242. syntax()
  243. {
  244. bpf_error("syntax error in filter expression");
  245. }
  247. static bpf_u_int32 netmask;
  248. static int snaplen;
  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;
  257. n_errors = 0;
  258. root = NULL;
  259. bpf_pcap = p;
  260. if (setjmp(top_ctx)) {
  261. freechunks();
  262. return (-1);
  263. }
  265. netmask = mask;
  266. snaplen = pcap_snapshot(p);
  268. lex_init(buf ? buf : "");
  269. init_linktype(pcap_datalink(p));
  270. (void)pcap_parse();
  272. if (n_errors)
  273. syntax();
  275. if (root == NULL)
  276. root = gen_retblk(snaplen);
  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;
  287. freechunks();
  288. return (0);
  289. }
  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;
  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. }
  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;
  325. /* Find end of list. */
  326. while (*p)
  327. p = !((*p)->sense) ? &JT(*p) : &JF(*p);
  329. /* Concatenate the lists. */
  330. *p = b1;
  331. }
  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. }
  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. }
  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. }
  366. void
  367. gen_not(b)
  368. struct block *b;
  369. {
  370. b->sense = !b->sense;
  371. }
  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;
  381. s = new_stmt(BPF_LD|BPF_ABS|size);
  382. s->s.k = offset;
  384. b = new_block(JMP(BPF_JEQ));
  385. b->stmts = s;
  386. b->s.k = v;
  388. return b;
  389. }
  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;
  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. }
  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;
  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];
  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];
  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. }
  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;
  455. static void
  456. init_linktype(type)
  457. int type;
  458. {
  459. linktype = type;
  461. switch (type) {
  463. case DLT_EN10MB:
  464. off_linktype = 12;
  465. off_nl = 14;
  466. return;
  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;
  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;
  484. case DLT_NULL:
  485. off_linktype = 0;
  486. off_nl = 4;
  487. return;
  489. case DLT_PPP:
  490. off_linktype = 2;
  491. off_nl = 4;
  492. return;
  494. case DLT_PPP_BSDOS:
  495. off_linktype = 5;
  496. off_nl = 24;
  497. return;
  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;
  515. case DLT_IEEE802:
  516. off_linktype = 20;
  517. off_nl = 22;
  518. return;
  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;
  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. }
  538. static struct block *
  539. gen_uncond(rsense)
  540. int rsense;
  541. {
  542. struct block *b;
  543. struct slist *s;
  545. s = new_stmt(BPF_LD|BPF_IMM);
  546. s->s.k = !rsense;
  547. b = new_block(JMP(BPF_JEQ));
  548. b->stmts = s;
  550. return b;
  551. }
  553. static inline struct block *
  554. gen_true()
  555. {
  556. return gen_uncond(1);
  557. }
  559. static inline struct block *
  560. gen_false()
  561. {
  562. return gen_uncond(0);
  563. }
  565. static struct block *
  566. gen_linktype(proto)
  567. register int proto;
  568. {
  569. struct block *b0, *b1;
  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();
  575. switch (linktype) {
  577. case DLT_SLIP:
  578. return gen_false();
  580. case DLT_PPP:
  581. if (proto == ETHERTYPE_IP)
  582. proto = PPP_IP; /* XXX was 0x21 */
  583. break;
  585. case DLT_PPP_BSDOS:
  586. switch (proto) {
  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;
  596. case ETHERTYPE_DN:
  597. proto = PPP_DECNET;
  598. break;
  600. case ETHERTYPE_ATALK:
  601. proto = PPP_APPLE;
  602. break;
  604. case ETHERTYPE_NS:
  605. proto = PPP_NS;
  606. break;
  607. }
  608. break;
  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. }
  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;
  630. switch (dir) {
  632. case Q_SRC:
  633. offset = src_off;
  634. break;
  636. case Q_DST:
  637. offset = dst_off;
  638. break;
  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;
  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;
  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. }
  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;
  669. switch (dir) {
  670. case Q_SRC:
  671. return gen_bcmp(6, 6, eaddr);
  673. case Q_DST:
  674. return gen_bcmp(0, 6, eaddr);
  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;
  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. }
  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;
  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
  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
  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;
  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. }
  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 */
  763. switch (dir) {
  765. case Q_DST:
  766. offset_sh = 1; /* follows flags */
  767. offset_lh = 7; /* flgs,darea,dsubarea,HIORD */
  768. break;
  770. case Q_SRC:
  771. offset_sh = 3; /* follows flags, dstnode */
  772. offset_lh = 15; /* flgs,darea,dsubarea,did,sarea,ssub,HIORD */
  773. break;
  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;
  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;
  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);
  818. /* Combine with test for linktype */
  819. gen_and(b0, b1);
  820. return b1;
  821. }
  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;
  832. switch (proto) {
  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;
  842. case Q_IP:
  843. return gen_hostop(addr, mask, dir, ETHERTYPE_IP,
  844.   off_nl + 12, off_nl + 16);
  846. case Q_RARP:
  847. return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP,
  848.   off_nl + 14, off_nl + 24);
  850. case Q_ARP:
  851. return gen_hostop(addr, mask, dir, ETHERTYPE_ARP,
  852.   off_nl + 14, off_nl + 24);
  854. case Q_TCP:
  855. bpf_error("'tcp' modifier applied to host");
  857. case Q_UDP:
  858. bpf_error("'udp' modifier applied to host");
  860. case Q_ICMP:
  861. bpf_error("'icmp' modifier applied to host");
  863. case Q_IGMP:
  864. bpf_error("'igmp' modifier applied to host");
  866. case Q_IGRP:
  867. bpf_error("'igrp' modifier applied to host");
  869. case Q_ATALK:
  870. bpf_error("ATALK host filtering not implemented");
  872. case Q_DECNET:
  873. return gen_dnhostop(addr, dir, off_nl);
  875. case Q_SCA:
  876. bpf_error("SCA host filtering not implemented");
  878. case Q_LAT:
  879. bpf_error("LAT host filtering not implemented");
  881. case Q_MOPDL:
  882. bpf_error("MOPDL host filtering not implemented");
  884. case Q_MOPRC:
  885. bpf_error("MOPRC host filtering not implemented");
  887. default:
  888. abort();
  889. }
  890. /* NOTREACHED */
  891. }
  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;
  902. if (dir != 0)
  903. bpf_error("direction applied to 'gateway'");
  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");
  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. }
  932. struct block *
  933. gen_proto_abbrev(proto)
  934. int proto;
  935. {
  936. struct block *b0, *b1;
  938. switch (proto) {
  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;
  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;
  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;
  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;
  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;
  973. case Q_IP:
  974. b1 =  gen_linktype(ETHERTYPE_IP);
  975. break;
  977. case Q_ARP:
  978. b1 =  gen_linktype(ETHERTYPE_ARP);
  979. break;
  981. case Q_RARP:
  982. b1 =  gen_linktype(ETHERTYPE_REVARP);
  983. break;
  985. case Q_LINK:
  986. bpf_error("link layer applied in wrong context");
  988. case Q_ATALK:
  989. b1 =  gen_linktype(ETHERTYPE_ATALK);
  990. break;
  992. case Q_DECNET:
  993. b1 =  gen_linktype(ETHERTYPE_DN);
  994. break;
  996. case Q_SCA:
  997. b1 =  gen_linktype(ETHERTYPE_SCA);
  998. break;
  1000. case Q_LAT:
  1001. b1 =  gen_linktype(ETHERTYPE_LAT);
  1002. break;
  1004. case Q_MOPDL:
  1005. b1 =  gen_linktype(ETHERTYPE_MOPDL);
  1006. break;
  1008. case Q_MOPRC:
  1009. b1 =  gen_linktype(ETHERTYPE_MOPRC);
  1010. break;
  1012. default:
  1013. abort();
  1014. }
  1015. return b1;
  1016. }
  1018. static struct block *
  1019. gen_ipfrag()
  1020. {
  1021. struct slist *s;
  1022. struct block *b;
  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);
  1032. return b;
  1033. }
  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;
  1043. s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
  1044. s->s.k = off_nl;
  1046. s->next = new_stmt(BPF_LD|BPF_IND|BPF_H);
  1047. s->next->s.k = off_nl + off;
  1049. b = new_block(JMP(BPF_JEQ));
  1050. b->stmts = s;
  1051. b->s.k = v;
  1053. return b;
  1054. }
  1056. struct block *
  1057. gen_portop(port, proto, dir)
  1058. int port, proto, dir;
  1059. {
  1060. struct block *b0, *b1, *tmp;
  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);
  1067. switch (dir) {
  1068. case Q_SRC:
  1069. b1 = gen_portatom(0, (bpf_int32)port);
  1070. break;
  1072. case Q_DST:
  1073. b1 = gen_portatom(2, (bpf_int32)port);
  1074. break;
  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;
  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;
  1089. default:
  1090. abort();
  1091. }
  1092. gen_and(b0, b1);
  1094. return b1;
  1095. }
  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;
  1105. /* ether proto ip */
  1106. b0 =  gen_linktype(ETHERTYPE_IP);
  1108. switch (ip_proto) {
  1109. case IPPROTO_UDP:
  1110. case IPPROTO_TCP:
  1111. b1 = gen_portop(port, ip_proto, dir);
  1112. break;
  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;
  1120. default:
  1121. abort();
  1122. }
  1123. gen_and(b0, b1);
  1124. return b1;
  1125. }
  1127. static int
  1128. lookup_proto(name, proto)
  1129. register const char *name;
  1130. register int proto;
  1131. {
  1132. register int v;
  1134. switch (proto) {
  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;
  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;
  1150. default:
  1151. v = PROTO_UNDEF;
  1152. break;
  1153. }
  1154. return v;
  1155. }
  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;
  1165. if (dir != Q_DEFAULT)
  1166. bpf_error("direction applied to 'proto'");
  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;
  1176. case Q_ARP:
  1177. bpf_error("arp does not encapsulate another protocol");
  1178. /* NOTREACHED */
  1180. case Q_RARP:
  1181. bpf_error("rarp does not encapsulate another protocol");
  1182. /* NOTREACHED */
  1184. case Q_ATALK:
  1185. bpf_error("atalk encapsulation is not specifiable");
  1186. /* NOTREACHED */
  1188. case Q_DECNET:
  1189. bpf_error("decnet encapsulation is not specifiable");
  1190. /* NOTREACHED */
  1192. case Q_SCA:
  1193. bpf_error("sca does not encapsulate another protocol");
  1194. /* NOTREACHED */
  1196. case Q_LAT:
  1197. bpf_error("lat does not encapsulate another protocol");
  1198. /* NOTREACHED */
  1200. case Q_MOPRC:
  1201. bpf_error("moprc does not encapsulate another protocol");
  1202. /* NOTREACHED */
  1204. case Q_MOPDL:
  1205. bpf_error("mopdl does not encapsulate another protocol");
  1206. /* NOTREACHED */
  1208. case Q_LINK:
  1209. return gen_linktype(v);
  1211. case Q_UDP:
  1212. bpf_error("'udp proto' is bogus");
  1213. /* NOTREACHED */
  1215. case Q_TCP:
  1216. bpf_error("'tcp proto' is bogus");
  1217. /* NOTREACHED */
  1219. case Q_ICMP:
  1220. bpf_error("'icmp proto' is bogus");
  1221. /* NOTREACHED */
  1223. case Q_IGMP:
  1224. bpf_error("'igmp proto' is bogus");
  1225. /* NOTREACHED */
  1227. case Q_IGRP:
  1228. bpf_error("'igrp proto' is bogus");
  1229. /* NOTREACHED */
  1231. default:
  1232. abort();
  1233. /* NOTREACHED */
  1234. }
  1235. /* NOTREACHED */
  1236. }
  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;
  1251. switch (q.addr) {
  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);
  1265. case Q_DEFAULT:
  1266. case Q_HOST:
  1267. if (proto == Q_LINK) {
  1268. switch (linktype) {
  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);
  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);
  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. }
  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);
  1334. case Q_GATEWAY:
  1335. eaddr = pcap_ether_hostton(name);
  1336. if (eaddr == NULL)
  1337. bpf_error("unknown ether host: %s", name);
  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);
  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);
  1351. case Q_UNDEF:
  1352. syntax();
  1353. /* NOTREACHED */
  1354. }
  1355. abort();
  1356. /* NOTREACHED */
  1357. }
  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;
  1368. nlen = __pcap_atoin(s1, &n);
  1369. /* Promote short ipaddr */
  1370. n <<= 32 - nlen;
  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. }
  1389. switch (q.addr) {
  1391. case Q_NET:
  1392. return gen_host(n, m, q.proto, q.dir);
  1394. default:
  1395. bpf_error("Mask syntax for networks only");
  1396. /* NOTREACHED */
  1397. }
  1398. }
  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;
  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);
  1418. switch (q.addr) {
  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. }
  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'");
  1453. return gen_port((int)v, proto, dir);
  1455. case Q_GATEWAY:
  1456. bpf_error("'gateway' requires a name");
  1457. /* NOTREACHED */
  1459. case Q_PROTO:
  1460. return gen_proto((int)v, proto, dir);
  1462. case Q_UNDEF:
  1463. syntax();
  1464. /* NOTREACHED */
  1466. default:
  1467. abort();
  1468. /* NOTREACHED */
  1469. }
  1470. /* NOTREACHED */
  1471. }
  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. }
  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. }
  1501. static struct slist *
  1502. xfer_to_x(a)
  1503. struct arth *a;
  1504. {
  1505. struct slist *s;
  1507. s = new_stmt(BPF_LDX|BPF_MEM);
  1508. s->s.k = a->regno;
  1509. return s;
  1510. }
  1512. static struct slist *
  1513. xfer_to_a(a)
  1514. struct arth *a;
  1515. {
  1516. struct slist *s;
  1518. s = new_stmt(BPF_LD|BPF_MEM);
  1519. s->s.k = a->regno;
  1520. return s;
  1521. }
  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();
  1533. free_reg(index->regno);
  1534. switch (size) {
  1536. default:
  1537. bpf_error("data size must be 1, 2, or 4");
  1539. case 1:
  1540. size = BPF_B;
  1541. break;
  1543. case 2:
  1544. size = BPF_H;
  1545. break;
  1547. case 4:
  1548. size = BPF_W;
  1549. break;
  1550. }
  1551. switch (proto) {
  1552. default:
  1553. bpf_error("unsupported index operation");
  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;
  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);
  1578. b = gen_proto_abbrev(proto);
  1579. if (index->b)
  1580. gen_and(index->b, b);
  1581. index->b = b;
  1582. break;
  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);
  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);
  1609. return index;
  1610. }
  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;
  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);
  1632. sappend(s1, s2);
  1633. sappend(s0, s1);
  1634. sappend(a1->s, s0);
  1635. sappend(a0->s, a1->s);
  1637. b->stmts = a0->s;
  1639. free_reg(a0->regno);
  1640. free_reg(a1->regno);
  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;
  1652. if (tmp)
  1653. gen_and(tmp, b);
  1655. return b;
  1656. }
  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;
  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;
  1671. return a;
  1672. }
  1674. struct arth *
  1675. gen_loadi(val)
  1676. int val;
  1677. {
  1678. struct arth *a;
  1679. struct slist *s;
  1680. int reg;
  1682. a = (struct arth *)newchunk(sizeof(*a));
  1684. reg = alloc_reg();
  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;
  1693. return a;
  1694. }
  1696. struct arth *
  1697. gen_neg(a)
  1698. struct arth *a;
  1699. {
  1700. struct slist *s;
  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);
  1711. return a;
  1712. }
  1714. struct arth *
  1715. gen_arth(code, a0, a1)
  1716. int code;
  1717. struct arth *a0, *a1;
  1718. {
  1719. struct slist *s0, *s1, *s2;
  1721. s0 = xfer_to_x(a1);
  1722. s1 = xfer_to_a(a0);
  1723. s2 = new_stmt(BPF_ALU|BPF_X|code);
  1725. sappend(s1, s2);
  1726. sappend(s0, s1);
  1727. sappend(a1->s, s0);
  1728. sappend(a0->s, a1->s);
  1730. free_reg(a1->regno);
  1732. s0 = new_stmt(BPF_ST);
  1733. a0->regno = s0->s.k = alloc_reg();
  1734. sappend(a0->s, s0);
  1736. return a0;
  1737. }
  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;
  1746. /*
  1747.  * Return the next free register.
  1748.  */
  1749. static int
  1750. alloc_reg()
  1751. {
  1752. int n = BPF_MEMWORDS;
  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. }
  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. }
  1777. static struct block *
  1778. gen_len(jmp, n)
  1779. int jmp, n;
  1780. {
  1781. struct slist *s;
  1782. struct block *b;
  1784. s = new_stmt(BPF_LD|BPF_LEN);
  1785. b = new_block(JMP(jmp));
  1786. b->stmts = s;
  1787. b->s.k = n;
  1789. return b;
  1790. }
  1792. struct block *
  1793. gen_greater(n)
  1794. int n;
  1795. {
  1796. return gen_len(BPF_JGE, n);
  1797. }
  1799. struct block *
  1800. gen_less(n)
  1801. int n;
  1802. {
  1803. struct block *b;
  1805. b = gen_len(BPF_JGT, n);
  1806. gen_not(b);
  1808. return b;
  1809. }
  1811. struct block *
  1812. gen_byteop(op, idx, val)
  1813. int op, idx, val;
  1814. {
  1815. struct block *b;
  1816. struct slist *s;
  1818. switch (op) {
  1819. default:
  1820. abort();
  1822. case '=':
  1823. return gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
  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;
  1831. case '>':
  1832. b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
  1833. b->s.code = JMP(BPF_JGT);
  1834. return b;
  1836. case '|':
  1837. s = new_stmt(BPF_ALU|BPF_OR|BPF_K);
  1838. break;
  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);
  1849. return b;
  1850. }
  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 };
  1860. switch (proto) {
  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;
  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. }
  1884. struct block *
  1885. gen_multicast(proto)
  1886. int proto;
  1887. {
  1888. register struct block *b0, *b1;
  1889. register struct slist *s;
  1891. switch (proto) {
  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. }
  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;
  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. }
  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;
  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. }