Merge branch 'vendor/LIBPCAP'
[dragonfly.git] / contrib / libpcap / gencode.c
1 /*#define CHASE_CHAIN*/
2 /*
3  * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
4  *      The Regents of the University of California.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that: (1) source code distributions
8  * retain the above copyright notice and this paragraph in its entirety, (2)
9  * distributions including binary code include the above copyright notice and
10  * this paragraph in its entirety in the documentation or other materials
11  * provided with the distribution, and (3) all advertising materials mentioning
12  * features or use of this software display the following acknowledgement:
13  * ``This product includes software developed by the University of California,
14  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
15  * the University nor the names of its contributors may be used to endorse
16  * or promote products derived from this software without specific prior
17  * written permission.
18  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21  */
22 #ifndef lint
23 static const char rcsid[] _U_ =
24     "@(#) $Header: /tcpdump/master/libpcap/gencode.c,v 1.309 2008-12-23 20:13:29 guy Exp $ (LBL)";
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #ifdef WIN32
32 #include <pcap-stdinc.h>
33 #else /* WIN32 */
34 #if HAVE_INTTYPES_H
35 #include <inttypes.h>
36 #elif HAVE_STDINT_H
37 #include <stdint.h>
38 #endif
39 #ifdef HAVE_SYS_BITYPES_H
40 #include <sys/bitypes.h>
41 #endif
42 #include <sys/types.h>
43 #include <sys/socket.h>
44 #endif /* WIN32 */
45
46 /*
47  * XXX - why was this included even on UNIX?
48  */
49 #ifdef __MINGW32__
50 #include "ip6_misc.h"
51 #endif
52
53 #ifndef WIN32
54
55 #ifdef __NetBSD__
56 #include <sys/param.h>
57 #endif
58
59 #include <netinet/in.h>
60 #include <arpa/inet.h>
61
62 #endif /* WIN32 */
63
64 #include <stdlib.h>
65 #include <string.h>
66 #include <memory.h>
67 #include <setjmp.h>
68 #include <stdarg.h>
69
70 #ifdef MSDOS
71 #include "pcap-dos.h"
72 #endif
73
74 #include "pcap-int.h"
75
76 #include "ethertype.h"
77 #include "nlpid.h"
78 #include "llc.h"
79 #include "gencode.h"
80 #include <netproto/802_11/ieee80211.h>
81 #include "atmuni31.h"
82 #include "sunatmpos.h"
83 #include "ppp.h"
84 #include "pcap/sll.h"
85 #include "pcap/ipnet.h"
86 #include "arcnet.h"
87 #ifdef HAVE_NET_PFVAR_H
88 #include <sys/socket.h>
89 #include <net/if.h>
90 #include <net/if_var.h>
91 #include <net/pf/pfvar.h>
92 #include <net/pf/if_pflog.h>
93 #endif
94 #ifndef offsetof
95 #define offsetof(s, e) ((size_t)&((s *)0)->e)
96 #endif
97 #ifdef INET6
98 #ifndef WIN32
99 #include <netdb.h>      /* for "struct addrinfo" */
100 #endif /* WIN32 */
101 #endif /*INET6*/
102 #include <pcap/namedb.h>
103
104 #include <netproto/802_11/ieee80211_radiotap.h>
105
106 #define ETHERMTU        1500
107
108 #ifndef IPPROTO_SCTP
109 #define IPPROTO_SCTP 132
110 #endif
111
112 #ifdef HAVE_OS_PROTO_H
113 #include "os-proto.h"
114 #endif
115
116 #define JMP(c) ((c)|BPF_JMP|BPF_K)
117
118 /* Locals */
119 static jmp_buf top_ctx;
120 static pcap_t *bpf_pcap;
121
122 /* Hack for updating VLAN, MPLS, and PPPoE offsets. */
123 #ifdef WIN32
124 static u_int    orig_linktype = (u_int)-1, orig_nl = (u_int)-1, label_stack_depth = (u_int)-1;
125 #else
126 static u_int    orig_linktype = -1U, orig_nl = -1U, label_stack_depth = -1U;
127 #endif
128
129 /* XXX */
130 #ifdef PCAP_FDDIPAD
131 static int      pcap_fddipad;
132 #endif
133
134 /* VARARGS */
135 void
136 bpf_error(const char *fmt, ...)
137 {
138         va_list ap;
139
140         va_start(ap, fmt);
141         if (bpf_pcap != NULL)
142                 (void)vsnprintf(pcap_geterr(bpf_pcap), PCAP_ERRBUF_SIZE,
143                     fmt, ap);
144         va_end(ap);
145         longjmp(top_ctx, 1);
146         /* NOTREACHED */
147 }
148
149 static void init_linktype(pcap_t *);
150
151 static void init_regs(void);
152 static int alloc_reg(void);
153 static void free_reg(int);
154
155 static struct block *root;
156
157 /*
158  * Value passed to gen_load_a() to indicate what the offset argument
159  * is relative to.
160  */
161 enum e_offrel {
162         OR_PACKET,      /* relative to the beginning of the packet */
163         OR_LINK,        /* relative to the beginning of the link-layer header */
164         OR_MACPL,       /* relative to the end of the MAC-layer header */
165         OR_NET,         /* relative to the network-layer header */
166         OR_NET_NOSNAP,  /* relative to the network-layer header, with no SNAP header at the link layer */
167         OR_TRAN_IPV4,   /* relative to the transport-layer header, with IPv4 network layer */
168         OR_TRAN_IPV6    /* relative to the transport-layer header, with IPv6 network layer */
169 };
170
171 #ifdef INET6
172 /*
173  * As errors are handled by a longjmp, anything allocated must be freed
174  * in the longjmp handler, so it must be reachable from that handler.
175  * One thing that's allocated is the result of pcap_nametoaddrinfo();
176  * it must be freed with freeaddrinfo().  This variable points to any
177  * addrinfo structure that would need to be freed.
178  */
179 static struct addrinfo *ai;
180 #endif
181
182 /*
183  * We divy out chunks of memory rather than call malloc each time so
184  * we don't have to worry about leaking memory.  It's probably
185  * not a big deal if all this memory was wasted but if this ever
186  * goes into a library that would probably not be a good idea.
187  *
188  * XXX - this *is* in a library....
189  */
190 #define NCHUNKS 16
191 #define CHUNK0SIZE 1024
192 struct chunk {
193         u_int n_left;
194         void *m;
195 };
196
197 static struct chunk chunks[NCHUNKS];
198 static int cur_chunk;
199
200 static void *newchunk(u_int);
201 static void freechunks(void);
202 static inline struct block *new_block(int);
203 static inline struct slist *new_stmt(int);
204 static struct block *gen_retblk(int);
205 static inline void syntax(void);
206
207 static void backpatch(struct block *, struct block *);
208 static void merge(struct block *, struct block *);
209 static struct block *gen_cmp(enum e_offrel, u_int, u_int, bpf_int32);
210 static struct block *gen_cmp_gt(enum e_offrel, u_int, u_int, bpf_int32);
211 static struct block *gen_cmp_ge(enum e_offrel, u_int, u_int, bpf_int32);
212 static struct block *gen_cmp_lt(enum e_offrel, u_int, u_int, bpf_int32);
213 static struct block *gen_cmp_le(enum e_offrel, u_int, u_int, bpf_int32);
214 static struct block *gen_mcmp(enum e_offrel, u_int, u_int, bpf_int32,
215     bpf_u_int32);
216 static struct block *gen_bcmp(enum e_offrel, u_int, u_int, const u_char *);
217 static struct block *gen_ncmp(enum e_offrel, bpf_u_int32, bpf_u_int32,
218     bpf_u_int32, bpf_u_int32, int, bpf_int32);
219 static struct slist *gen_load_llrel(u_int, u_int);
220 static struct slist *gen_load_macplrel(u_int, u_int);
221 static struct slist *gen_load_a(enum e_offrel, u_int, u_int);
222 static struct slist *gen_loadx_iphdrlen(void);
223 static struct block *gen_uncond(int);
224 static inline struct block *gen_true(void);
225 static inline struct block *gen_false(void);
226 static struct block *gen_ether_linktype(int);
227 static struct block *gen_ipnet_linktype(int);
228 static struct block *gen_linux_sll_linktype(int);
229 static struct slist *gen_load_prism_llprefixlen(void);
230 static struct slist *gen_load_avs_llprefixlen(void);
231 static struct slist *gen_load_radiotap_llprefixlen(void);
232 static struct slist *gen_load_ppi_llprefixlen(void);
233 static void insert_compute_vloffsets(struct block *);
234 static struct slist *gen_llprefixlen(void);
235 static struct slist *gen_off_macpl(void);
236 static int ethertype_to_ppptype(int);
237 static struct block *gen_linktype(int);
238 static struct block *gen_snap(bpf_u_int32, bpf_u_int32);
239 static struct block *gen_llc_linktype(int);
240 static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
241 #ifdef INET6
242 static struct block *gen_hostop6(struct in6_addr *, struct in6_addr *, int, int, u_int, u_int);
243 #endif
244 static struct block *gen_ahostop(const u_char *, int);
245 static struct block *gen_ehostop(const u_char *, int);
246 static struct block *gen_fhostop(const u_char *, int);
247 static struct block *gen_thostop(const u_char *, int);
248 static struct block *gen_wlanhostop(const u_char *, int);
249 static struct block *gen_ipfchostop(const u_char *, int);
250 static struct block *gen_dnhostop(bpf_u_int32, int);
251 static struct block *gen_mpls_linktype(int);
252 static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int, int);
253 #ifdef INET6
254 static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int, int);
255 #endif
256 #ifndef INET6
257 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
258 #endif
259 static struct block *gen_ipfrag(void);
260 static struct block *gen_portatom(int, bpf_int32);
261 static struct block *gen_portrangeatom(int, bpf_int32, bpf_int32);
262 #ifdef INET6
263 static struct block *gen_portatom6(int, bpf_int32);
264 static struct block *gen_portrangeatom6(int, bpf_int32, bpf_int32);
265 #endif
266 struct block *gen_portop(int, int, int);
267 static struct block *gen_port(int, int, int);
268 struct block *gen_portrangeop(int, int, int, int);
269 static struct block *gen_portrange(int, int, int, int);
270 #ifdef INET6
271 struct block *gen_portop6(int, int, int);
272 static struct block *gen_port6(int, int, int);
273 struct block *gen_portrangeop6(int, int, int, int);
274 static struct block *gen_portrange6(int, int, int, int);
275 #endif
276 static int lookup_proto(const char *, int);
277 static struct block *gen_protochain(int, int, int);
278 static struct block *gen_proto(int, int, int);
279 static struct slist *xfer_to_x(struct arth *);
280 static struct slist *xfer_to_a(struct arth *);
281 static struct block *gen_mac_multicast(int);
282 static struct block *gen_len(int, int);
283 static struct block *gen_check_802_11_data_frame(void);
284
285 static struct block *gen_ppi_dlt_check(void);
286 static struct block *gen_msg_abbrev(int type);
287
288 static void *
289 newchunk(n)
290         u_int n;
291 {
292         struct chunk *cp;
293         int k;
294         size_t size;
295
296 #ifndef __NetBSD__
297         /* XXX Round up to nearest long. */
298         n = (n + sizeof(long) - 1) & ~(sizeof(long) - 1);
299 #else
300         /* XXX Round up to structure boundary. */
301         n = ALIGN(n);
302 #endif
303
304         cp = &chunks[cur_chunk];
305         if (n > cp->n_left) {
306                 ++cp, k = ++cur_chunk;
307                 if (k >= NCHUNKS)
308                         bpf_error("out of memory");
309                 size = CHUNK0SIZE << k;
310                 cp->m = (void *)malloc(size);
311                 if (cp->m == NULL)
312                         bpf_error("out of memory");
313                 memset((char *)cp->m, 0, size);
314                 cp->n_left = size;
315                 if (n > size)
316                         bpf_error("out of memory");
317         }
318         cp->n_left -= n;
319         return (void *)((char *)cp->m + cp->n_left);
320 }
321
322 static void
323 freechunks()
324 {
325         int i;
326
327         cur_chunk = 0;
328         for (i = 0; i < NCHUNKS; ++i)
329                 if (chunks[i].m != NULL) {
330                         free(chunks[i].m);
331                         chunks[i].m = NULL;
332                 }
333 }
334
335 /*
336  * A strdup whose allocations are freed after code generation is over.
337  */
338 char *
339 sdup(s)
340         register const char *s;
341 {
342         int n = strlen(s) + 1;
343         char *cp = newchunk(n);
344
345         strlcpy(cp, s, n);
346         return (cp);
347 }
348
349 static inline struct block *
350 new_block(code)
351         int code;
352 {
353         struct block *p;
354
355         p = (struct block *)newchunk(sizeof(*p));
356         p->s.code = code;
357         p->head = p;
358
359         return p;
360 }
361
362 static inline struct slist *
363 new_stmt(code)
364         int code;
365 {
366         struct slist *p;
367
368         p = (struct slist *)newchunk(sizeof(*p));
369         p->s.code = code;
370
371         return p;
372 }
373
374 static struct block *
375 gen_retblk(v)
376         int v;
377 {
378         struct block *b = new_block(BPF_RET|BPF_K);
379
380         b->s.k = v;
381         return b;
382 }
383
384 static inline void
385 syntax()
386 {
387         bpf_error("syntax error in filter expression");
388 }
389
390 static bpf_u_int32 netmask;
391 static int snaplen;
392 int no_optimize;
393 #ifdef WIN32
394 static int
395 pcap_compile_unsafe(pcap_t *p, struct bpf_program *program,
396              const char *buf, int optimize, bpf_u_int32 mask);
397
398 int
399 pcap_compile(pcap_t *p, struct bpf_program *program,
400              const char *buf, int optimize, bpf_u_int32 mask)
401 {
402         int result;
403
404         EnterCriticalSection(&g_PcapCompileCriticalSection);
405
406         result = pcap_compile_unsafe(p, program, buf, optimize, mask);
407
408         LeaveCriticalSection(&g_PcapCompileCriticalSection);
409         
410         return result;
411 }
412
413 static int
414 pcap_compile_unsafe(pcap_t *p, struct bpf_program *program,
415              const char *buf, int optimize, bpf_u_int32 mask)
416 #else /* WIN32 */
417 int
418 pcap_compile(pcap_t *p, struct bpf_program *program,
419              const char *buf, int optimize, bpf_u_int32 mask)
420 #endif /* WIN32 */
421 {
422         extern int n_errors;
423         const char * volatile xbuf = buf;
424         int len;
425
426         no_optimize = 0;
427         n_errors = 0;
428         root = NULL;
429         bpf_pcap = p;
430         init_regs();
431         if (setjmp(top_ctx)) {
432 #ifdef INET6
433                 if (ai != NULL) {
434                         freeaddrinfo(ai);
435                         ai = NULL;
436                 }
437 #endif
438                 lex_cleanup();
439                 freechunks();
440                 return (-1);
441         }
442
443         netmask = mask;
444
445         snaplen = pcap_snapshot(p);
446         if (snaplen == 0) {
447                 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
448                          "snaplen of 0 rejects all packets");
449                 return -1;
450         }
451
452         lex_init(xbuf ? xbuf : "");
453         init_linktype(p);
454         (void)pcap_parse();
455
456         if (n_errors)
457                 syntax();
458
459         if (root == NULL)
460                 root = gen_retblk(snaplen);
461
462         if (optimize && !no_optimize) {
463                 bpf_optimize(&root);
464                 if (root == NULL ||
465                     (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
466                         bpf_error("expression rejects all packets");
467         }
468         program->bf_insns = icode_to_fcode(root, &len);
469         program->bf_len = len;
470
471         lex_cleanup();
472         freechunks();
473         return (0);
474 }
475
476 /*
477  * entry point for using the compiler with no pcap open
478  * pass in all the stuff that is needed explicitly instead.
479  */
480 int
481 pcap_compile_nopcap(int snaplen_arg, int linktype_arg,
482                     struct bpf_program *program,
483              const char *buf, int optimize, bpf_u_int32 mask)
484 {
485         pcap_t *p;
486         int ret;
487
488         p = pcap_open_dead(linktype_arg, snaplen_arg);
489         if (p == NULL)
490                 return (-1);
491         ret = pcap_compile(p, program, buf, optimize, mask);
492         pcap_close(p);
493         return (ret);
494 }
495
496 /*
497  * Clean up a "struct bpf_program" by freeing all the memory allocated
498  * in it.
499  */
500 void
501 pcap_freecode(struct bpf_program *program)
502 {
503         program->bf_len = 0;
504         if (program->bf_insns != NULL) {
505                 free((char *)program->bf_insns);
506                 program->bf_insns = NULL;
507         }
508 }
509
510 /*
511  * Backpatch the blocks in 'list' to 'target'.  The 'sense' field indicates
512  * which of the jt and jf fields has been resolved and which is a pointer
513  * back to another unresolved block (or nil).  At least one of the fields
514  * in each block is already resolved.
515  */
516 static void
517 backpatch(list, target)
518         struct block *list, *target;
519 {
520         struct block *next;
521
522         while (list) {
523                 if (!list->sense) {
524                         next = JT(list);
525                         JT(list) = target;
526                 } else {
527                         next = JF(list);
528                         JF(list) = target;
529                 }
530                 list = next;
531         }
532 }
533
534 /*
535  * Merge the lists in b0 and b1, using the 'sense' field to indicate
536  * which of jt and jf is the link.
537  */
538 static void
539 merge(b0, b1)
540         struct block *b0, *b1;
541 {
542         register struct block **p = &b0;
543
544         /* Find end of list. */
545         while (*p)
546                 p = !((*p)->sense) ? &JT(*p) : &JF(*p);
547
548         /* Concatenate the lists. */
549         *p = b1;
550 }
551
552 void
553 finish_parse(p)
554         struct block *p;
555 {
556         struct block *ppi_dlt_check;
557
558         /*
559          * Insert before the statements of the first (root) block any
560          * statements needed to load the lengths of any variable-length
561          * headers into registers.
562          *
563          * XXX - a fancier strategy would be to insert those before the
564          * statements of all blocks that use those lengths and that
565          * have no predecessors that use them, so that we only compute
566          * the lengths if we need them.  There might be even better
567          * approaches than that.
568          *
569          * However, those strategies would be more complicated, and
570          * as we don't generate code to compute a length if the
571          * program has no tests that use the length, and as most
572          * tests will probably use those lengths, we would just
573          * postpone computing the lengths so that it's not done
574          * for tests that fail early, and it's not clear that's
575          * worth the effort.
576          */
577         insert_compute_vloffsets(p->head);
578         
579         /*
580          * For DLT_PPI captures, generate a check of the per-packet
581          * DLT value to make sure it's DLT_IEEE802_11.
582          */
583         ppi_dlt_check = gen_ppi_dlt_check();
584         if (ppi_dlt_check != NULL)
585                 gen_and(ppi_dlt_check, p);
586
587         backpatch(p, gen_retblk(snaplen));
588         p->sense = !p->sense;
589         backpatch(p, gen_retblk(0));
590         root = p->head;
591 }
592
593 void
594 gen_and(b0, b1)
595         struct block *b0, *b1;
596 {
597         backpatch(b0, b1->head);
598         b0->sense = !b0->sense;
599         b1->sense = !b1->sense;
600         merge(b1, b0);
601         b1->sense = !b1->sense;
602         b1->head = b0->head;
603 }
604
605 void
606 gen_or(b0, b1)
607         struct block *b0, *b1;
608 {
609         b0->sense = !b0->sense;
610         backpatch(b0, b1->head);
611         b0->sense = !b0->sense;
612         merge(b1, b0);
613         b1->head = b0->head;
614 }
615
616 void
617 gen_not(b)
618         struct block *b;
619 {
620         b->sense = !b->sense;
621 }
622
623 static struct block *
624 gen_cmp(offrel, offset, size, v)
625         enum e_offrel offrel;
626         u_int offset, size;
627         bpf_int32 v;
628 {
629         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JEQ, 0, v);
630 }
631
632 static struct block *
633 gen_cmp_gt(offrel, offset, size, v)
634         enum e_offrel offrel;
635         u_int offset, size;
636         bpf_int32 v;
637 {
638         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 0, v);
639 }
640
641 static struct block *
642 gen_cmp_ge(offrel, offset, size, v)
643         enum e_offrel offrel;
644         u_int offset, size;
645         bpf_int32 v;
646 {
647         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 0, v);
648 }
649
650 static struct block *
651 gen_cmp_lt(offrel, offset, size, v)
652         enum e_offrel offrel;
653         u_int offset, size;
654         bpf_int32 v;
655 {
656         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 1, v);
657 }
658
659 static struct block *
660 gen_cmp_le(offrel, offset, size, v)
661         enum e_offrel offrel;
662         u_int offset, size;
663         bpf_int32 v;
664 {
665         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);
666 }
667
668 static struct block *
669 gen_mcmp(offrel, offset, size, v, mask)
670         enum e_offrel offrel;
671         u_int offset, size;
672         bpf_int32 v;
673         bpf_u_int32 mask;
674 {
675         return gen_ncmp(offrel, offset, size, mask, BPF_JEQ, 0, v);
676 }
677
678 static struct block *
679 gen_bcmp(offrel, offset, size, v)
680         enum e_offrel offrel;
681         register u_int offset, size;
682         register const u_char *v;
683 {
684         register struct block *b, *tmp;
685
686         b = NULL;
687         while (size >= 4) {
688                 register const u_char *p = &v[size - 4];
689                 bpf_int32 w = ((bpf_int32)p[0] << 24) |
690                     ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
691
692                 tmp = gen_cmp(offrel, offset + size - 4, BPF_W, w);
693                 if (b != NULL)
694                         gen_and(b, tmp);
695                 b = tmp;
696                 size -= 4;
697         }
698         while (size >= 2) {
699                 register const u_char *p = &v[size - 2];
700                 bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
701
702                 tmp = gen_cmp(offrel, offset + size - 2, BPF_H, w);
703                 if (b != NULL)
704                         gen_and(b, tmp);
705                 b = tmp;
706                 size -= 2;
707         }
708         if (size > 0) {
709                 tmp = gen_cmp(offrel, offset, BPF_B, (bpf_int32)v[0]);
710                 if (b != NULL)
711                         gen_and(b, tmp);
712                 b = tmp;
713         }
714         return b;
715 }
716
717 /*
718  * AND the field of size "size" at offset "offset" relative to the header
719  * specified by "offrel" with "mask", and compare it with the value "v"
720  * with the test specified by "jtype"; if "reverse" is true, the test
721  * should test the opposite of "jtype".
722  */
723 static struct block *
724 gen_ncmp(offrel, offset, size, mask, jtype, reverse, v)
725         enum e_offrel offrel;
726         bpf_int32 v;
727         bpf_u_int32 offset, size, mask, jtype;
728         int reverse;
729 {
730         struct slist *s, *s2;
731         struct block *b;
732
733         s = gen_load_a(offrel, offset, size);
734
735         if (mask != 0xffffffff) {
736                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
737                 s2->s.k = mask;
738                 sappend(s, s2);
739         }
740
741         b = new_block(JMP(jtype));
742         b->stmts = s;
743         b->s.k = v;
744         if (reverse && (jtype == BPF_JGT || jtype == BPF_JGE))
745                 gen_not(b);
746         return b;
747 }
748
749 /*
750  * Various code constructs need to know the layout of the data link
751  * layer.  These variables give the necessary offsets from the beginning
752  * of the packet data.
753  */
754
755 /*
756  * This is the offset of the beginning of the link-layer header from
757  * the beginning of the raw packet data.
758  *
759  * It's usually 0, except for 802.11 with a fixed-length radio header.
760  * (For 802.11 with a variable-length radio header, we have to generate
761  * code to compute that offset; off_ll is 0 in that case.)
762  */
763 static u_int off_ll;
764
765 /*
766  * If there's a variable-length header preceding the link-layer header,
767  * "reg_off_ll" is the register number for a register containing the
768  * length of that header, and therefore the offset of the link-layer
769  * header from the beginning of the raw packet data.  Otherwise,
770  * "reg_off_ll" is -1.
771  */
772 static int reg_off_ll;
773
774 /*
775  * This is the offset of the beginning of the MAC-layer header from
776  * the beginning of the link-layer header.
777  * It's usually 0, except for ATM LANE, where it's the offset, relative
778  * to the beginning of the raw packet data, of the Ethernet header, and
779  * for Ethernet with various additional information.
780  */
781 static u_int off_mac;
782
783 /*
784  * This is the offset of the beginning of the MAC-layer payload,
785  * from the beginning of the raw packet data.
786  *
787  * I.e., it's the sum of the length of the link-layer header (without,
788  * for example, any 802.2 LLC header, so it's the MAC-layer
789  * portion of that header), plus any prefix preceding the
790  * link-layer header.
791  */
792 static u_int off_macpl;
793
794 /*
795  * This is 1 if the offset of the beginning of the MAC-layer payload
796  * from the beginning of the link-layer header is variable-length.
797  */
798 static int off_macpl_is_variable;
799
800 /*
801  * If the link layer has variable_length headers, "reg_off_macpl"
802  * is the register number for a register containing the length of the
803  * link-layer header plus the length of any variable-length header
804  * preceding the link-layer header.  Otherwise, "reg_off_macpl"
805  * is -1.
806  */
807 static int reg_off_macpl;
808
809 /*
810  * "off_linktype" is the offset to information in the link-layer header
811  * giving the packet type.  This offset is relative to the beginning
812  * of the link-layer header (i.e., it doesn't include off_ll).
813  *
814  * For Ethernet, it's the offset of the Ethernet type field.
815  *
816  * For link-layer types that always use 802.2 headers, it's the
817  * offset of the LLC header.
818  *
819  * For PPP, it's the offset of the PPP type field.
820  *
821  * For Cisco HDLC, it's the offset of the CHDLC type field.
822  *
823  * For BSD loopback, it's the offset of the AF_ value.
824  *
825  * For Linux cooked sockets, it's the offset of the type field.
826  *
827  * It's set to -1 for no encapsulation, in which case, IP is assumed.
828  */
829 static u_int off_linktype;
830
831 /*
832  * TRUE if "pppoes" appeared in the filter; it causes link-layer type
833  * checks to check the PPP header, assumed to follow a LAN-style link-
834  * layer header and a PPPoE session header.
835  */
836 static int is_pppoes = 0;
837
838 /*
839  * TRUE if the link layer includes an ATM pseudo-header.
840  */
841 static int is_atm = 0;
842
843 /*
844  * TRUE if "lane" appeared in the filter; it causes us to generate
845  * code that assumes LANE rather than LLC-encapsulated traffic in SunATM.
846  */
847 static int is_lane = 0;
848
849 /*
850  * These are offsets for the ATM pseudo-header.
851  */
852 static u_int off_vpi;
853 static u_int off_vci;
854 static u_int off_proto;
855
856 /*
857  * These are offsets for the MTP2 fields.
858  */
859 static u_int off_li;
860
861 /*
862  * These are offsets for the MTP3 fields.
863  */
864 static u_int off_sio;
865 static u_int off_opc;
866 static u_int off_dpc;
867 static u_int off_sls;
868
869 /*
870  * This is the offset of the first byte after the ATM pseudo_header,
871  * or -1 if there is no ATM pseudo-header.
872  */
873 static u_int off_payload;
874
875 /*
876  * These are offsets to the beginning of the network-layer header.
877  * They are relative to the beginning of the MAC-layer payload (i.e.,
878  * they don't include off_ll or off_macpl).
879  *
880  * If the link layer never uses 802.2 LLC:
881  *
882  *      "off_nl" and "off_nl_nosnap" are the same.
883  *
884  * If the link layer always uses 802.2 LLC:
885  *
886  *      "off_nl" is the offset if there's a SNAP header following
887  *      the 802.2 header;
888  *
889  *      "off_nl_nosnap" is the offset if there's no SNAP header.
890  *
891  * If the link layer is Ethernet:
892  *
893  *      "off_nl" is the offset if the packet is an Ethernet II packet
894  *      (we assume no 802.3+802.2+SNAP);
895  *
896  *      "off_nl_nosnap" is the offset if the packet is an 802.3 packet
897  *      with an 802.2 header following it.
898  */
899 static u_int off_nl;
900 static u_int off_nl_nosnap;
901
902 static int linktype;
903
904 static void
905 init_linktype(p)
906         pcap_t *p;
907 {
908         linktype = pcap_datalink(p);
909 #ifdef PCAP_FDDIPAD
910         pcap_fddipad = p->fddipad;
911 #endif
912
913         /*
914          * Assume it's not raw ATM with a pseudo-header, for now.
915          */
916         off_mac = 0;
917         is_atm = 0;
918         is_lane = 0;
919         off_vpi = -1;
920         off_vci = -1;
921         off_proto = -1;
922         off_payload = -1;
923
924         /*
925          * And that we're not doing PPPoE.
926          */
927         is_pppoes = 0;
928
929         /*
930          * And assume we're not doing SS7.
931          */
932         off_li = -1;
933         off_sio = -1;
934         off_opc = -1;
935         off_dpc = -1;
936         off_sls = -1;
937
938         /*
939          * Also assume it's not 802.11.
940          */
941         off_ll = 0;
942         off_macpl = 0;
943         off_macpl_is_variable = 0;
944
945         orig_linktype = -1;
946         orig_nl = -1;
947         label_stack_depth = 0;
948
949         reg_off_ll = -1;
950         reg_off_macpl = -1;
951
952         switch (linktype) {
953
954         case DLT_ARCNET:
955                 off_linktype = 2;
956                 off_macpl = 6;
957                 off_nl = 0;             /* XXX in reality, variable! */
958                 off_nl_nosnap = 0;      /* no 802.2 LLC */
959                 return;
960
961         case DLT_ARCNET_LINUX:
962                 off_linktype = 4;
963                 off_macpl = 8;
964                 off_nl = 0;             /* XXX in reality, variable! */
965                 off_nl_nosnap = 0;      /* no 802.2 LLC */
966                 return;
967
968         case DLT_EN10MB:
969                 off_linktype = 12;
970                 off_macpl = 14;         /* Ethernet header length */
971                 off_nl = 0;             /* Ethernet II */
972                 off_nl_nosnap = 3;      /* 802.3+802.2 */
973                 return;
974
975         case DLT_SLIP:
976                 /*
977                  * SLIP doesn't have a link level type.  The 16 byte
978                  * header is hacked into our SLIP driver.
979                  */
980                 off_linktype = -1;
981                 off_macpl = 16;
982                 off_nl = 0;
983                 off_nl_nosnap = 0;      /* no 802.2 LLC */
984                 return;
985
986         case DLT_SLIP_BSDOS:
987                 /* XXX this may be the same as the DLT_PPP_BSDOS case */
988                 off_linktype = -1;
989                 /* XXX end */
990                 off_macpl = 24;
991                 off_nl = 0;
992                 off_nl_nosnap = 0;      /* no 802.2 LLC */
993                 return;
994
995         case DLT_NULL:
996         case DLT_LOOP:
997                 off_linktype = 0;
998                 off_macpl = 4;
999                 off_nl = 0;
1000                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1001                 return;
1002
1003         case DLT_ENC:
1004                 off_linktype = 0;
1005                 off_macpl = 12;
1006                 off_nl = 0;
1007                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1008                 return;
1009
1010         case DLT_PPP:
1011         case DLT_PPP_PPPD:
1012         case DLT_C_HDLC:                /* BSD/OS Cisco HDLC */
1013         case DLT_PPP_SERIAL:            /* NetBSD sync/async serial PPP */
1014                 off_linktype = 2;
1015                 off_macpl = 4;
1016                 off_nl = 0;
1017                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1018                 return;
1019
1020         case DLT_PPP_ETHER:
1021                 /*
1022                  * This does no include the Ethernet header, and
1023                  * only covers session state.
1024                  */
1025                 off_linktype = 6;
1026                 off_macpl = 8;
1027                 off_nl = 0;
1028                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1029                 return;
1030
1031         case DLT_PPP_BSDOS:
1032                 off_linktype = 5;
1033                 off_macpl = 24;
1034                 off_nl = 0;
1035                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1036                 return;
1037
1038         case DLT_FDDI:
1039                 /*
1040                  * FDDI doesn't really have a link-level type field.
1041                  * We set "off_linktype" to the offset of the LLC header.
1042                  *
1043                  * To check for Ethernet types, we assume that SSAP = SNAP
1044                  * is being used and pick out the encapsulated Ethernet type.
1045                  * XXX - should we generate code to check for SNAP?
1046                  */
1047                 off_linktype = 13;
1048 #ifdef PCAP_FDDIPAD
1049                 off_linktype += pcap_fddipad;
1050 #endif
1051                 off_macpl = 13;         /* FDDI MAC header length */
1052 #ifdef PCAP_FDDIPAD
1053                 off_macpl += pcap_fddipad;
1054 #endif
1055                 off_nl = 8;             /* 802.2+SNAP */
1056                 off_nl_nosnap = 3;      /* 802.2 */
1057                 return;
1058
1059         case DLT_IEEE802:
1060                 /*
1061                  * Token Ring doesn't really have a link-level type field.
1062                  * We set "off_linktype" to the offset of the LLC header.
1063                  *
1064                  * To check for Ethernet types, we assume that SSAP = SNAP
1065                  * is being used and pick out the encapsulated Ethernet type.
1066                  * XXX - should we generate code to check for SNAP?
1067                  *
1068                  * XXX - the header is actually variable-length.
1069                  * Some various Linux patched versions gave 38
1070                  * as "off_linktype" and 40 as "off_nl"; however,
1071                  * if a token ring packet has *no* routing
1072                  * information, i.e. is not source-routed, the correct
1073                  * values are 20 and 22, as they are in the vanilla code.
1074                  *
1075                  * A packet is source-routed iff the uppermost bit
1076                  * of the first byte of the source address, at an
1077                  * offset of 8, has the uppermost bit set.  If the
1078                  * packet is source-routed, the total number of bytes
1079                  * of routing information is 2 plus bits 0x1F00 of
1080                  * the 16-bit value at an offset of 14 (shifted right
1081                  * 8 - figure out which byte that is).
1082                  */
1083                 off_linktype = 14;
1084                 off_macpl = 14;         /* Token Ring MAC header length */
1085                 off_nl = 8;             /* 802.2+SNAP */
1086                 off_nl_nosnap = 3;      /* 802.2 */
1087                 return;
1088
1089         case DLT_IEEE802_11:
1090         case DLT_PRISM_HEADER:
1091         case DLT_IEEE802_11_RADIO_AVS:
1092         case DLT_IEEE802_11_RADIO:
1093                 /*
1094                  * 802.11 doesn't really have a link-level type field.
1095                  * We set "off_linktype" to the offset of the LLC header.
1096                  *
1097                  * To check for Ethernet types, we assume that SSAP = SNAP
1098                  * is being used and pick out the encapsulated Ethernet type.
1099                  * XXX - should we generate code to check for SNAP?
1100                  *
1101                  * We also handle variable-length radio headers here.
1102                  * The Prism header is in theory variable-length, but in
1103                  * practice it's always 144 bytes long.  However, some
1104                  * drivers on Linux use ARPHRD_IEEE80211_PRISM, but
1105                  * sometimes or always supply an AVS header, so we
1106                  * have to check whether the radio header is a Prism
1107                  * header or an AVS header, so, in practice, it's
1108                  * variable-length.
1109                  */
1110                 off_linktype = 24;
1111                 off_macpl = 0;          /* link-layer header is variable-length */
1112                 off_macpl_is_variable = 1;
1113                 off_nl = 8;             /* 802.2+SNAP */
1114                 off_nl_nosnap = 3;      /* 802.2 */
1115                 return;
1116
1117         case DLT_PPI:
1118                 /* 
1119                  * At the moment we treat PPI the same way that we treat
1120                  * normal Radiotap encoded packets. The difference is in
1121                  * the function that generates the code at the beginning
1122                  * to compute the header length.  Since this code generator
1123                  * of PPI supports bare 802.11 encapsulation only (i.e.
1124                  * the encapsulated DLT should be DLT_IEEE802_11) we
1125                  * generate code to check for this too.
1126                  */
1127                 off_linktype = 24;
1128                 off_macpl = 0;          /* link-layer header is variable-length */
1129                 off_macpl_is_variable = 1;
1130                 off_nl = 8;             /* 802.2+SNAP */
1131                 off_nl_nosnap = 3;      /* 802.2 */
1132                 return;
1133
1134         case DLT_ATM_RFC1483:
1135         case DLT_ATM_CLIP:      /* Linux ATM defines this */
1136                 /*
1137                  * assume routed, non-ISO PDUs
1138                  * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)
1139                  *
1140                  * XXX - what about ISO PDUs, e.g. CLNP, ISIS, ESIS,
1141                  * or PPP with the PPP NLPID (e.g., PPPoA)?  The
1142                  * latter would presumably be treated the way PPPoE
1143                  * should be, so you can do "pppoe and udp port 2049"
1144                  * or "pppoa and tcp port 80" and have it check for
1145                  * PPPo{A,E} and a PPP protocol of IP and....
1146                  */
1147                 off_linktype = 0;
1148                 off_macpl = 0;          /* packet begins with LLC header */
1149                 off_nl = 8;             /* 802.2+SNAP */
1150                 off_nl_nosnap = 3;      /* 802.2 */
1151                 return;
1152
1153         case DLT_SUNATM:
1154                 /*
1155                  * Full Frontal ATM; you get AALn PDUs with an ATM
1156                  * pseudo-header.
1157                  */
1158                 is_atm = 1;
1159                 off_vpi = SUNATM_VPI_POS;
1160                 off_vci = SUNATM_VCI_POS;
1161                 off_proto = PROTO_POS;
1162                 off_mac = -1;   /* assume LLC-encapsulated, so no MAC-layer header */
1163                 off_payload = SUNATM_PKT_BEGIN_POS;
1164                 off_linktype = off_payload;
1165                 off_macpl = off_payload;        /* if LLC-encapsulated */
1166                 off_nl = 8;             /* 802.2+SNAP */
1167                 off_nl_nosnap = 3;      /* 802.2 */
1168                 return;
1169
1170         case DLT_RAW:
1171         case DLT_IPV4:
1172         case DLT_IPV6:
1173                 off_linktype = -1;
1174                 off_macpl = 0;
1175                 off_nl = 0;
1176                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1177                 return;
1178
1179         case DLT_LINUX_SLL:     /* fake header for Linux cooked socket */
1180                 off_linktype = 14;
1181                 off_macpl = 16;
1182                 off_nl = 0;
1183                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1184                 return;
1185
1186         case DLT_LTALK:
1187                 /*
1188                  * LocalTalk does have a 1-byte type field in the LLAP header,
1189                  * but really it just indicates whether there is a "short" or
1190                  * "long" DDP packet following.
1191                  */
1192                 off_linktype = -1;
1193                 off_macpl = 0;
1194                 off_nl = 0;
1195                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1196                 return;
1197
1198         case DLT_IP_OVER_FC:
1199                 /*
1200                  * RFC 2625 IP-over-Fibre-Channel doesn't really have a
1201                  * link-level type field.  We set "off_linktype" to the
1202                  * offset of the LLC header.
1203                  *
1204                  * To check for Ethernet types, we assume that SSAP = SNAP
1205                  * is being used and pick out the encapsulated Ethernet type.
1206                  * XXX - should we generate code to check for SNAP? RFC
1207                  * 2625 says SNAP should be used.
1208                  */
1209                 off_linktype = 16;
1210                 off_macpl = 16;
1211                 off_nl = 8;             /* 802.2+SNAP */
1212                 off_nl_nosnap = 3;      /* 802.2 */
1213                 return;
1214
1215         case DLT_FRELAY:
1216                 /*
1217                  * XXX - we should set this to handle SNAP-encapsulated
1218                  * frames (NLPID of 0x80).
1219                  */
1220                 off_linktype = -1;
1221                 off_macpl = 0;
1222                 off_nl = 0;
1223                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1224                 return;
1225
1226                 /*
1227                  * the only BPF-interesting FRF.16 frames are non-control frames;
1228                  * Frame Relay has a variable length link-layer
1229                  * so lets start with offset 4 for now and increments later on (FIXME);
1230                  */
1231         case DLT_MFR:
1232                 off_linktype = -1;
1233                 off_macpl = 0;
1234                 off_nl = 4;
1235                 off_nl_nosnap = 0;      /* XXX - for now -> no 802.2 LLC */
1236                 return;
1237
1238         case DLT_APPLE_IP_OVER_IEEE1394:
1239                 off_linktype = 16;
1240                 off_macpl = 18;
1241                 off_nl = 0;
1242                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1243                 return;
1244
1245         case DLT_SYMANTEC_FIREWALL:
1246                 off_linktype = 6;
1247                 off_macpl = 44;
1248                 off_nl = 0;             /* Ethernet II */
1249                 off_nl_nosnap = 0;      /* XXX - what does it do with 802.3 packets? */
1250                 return;
1251
1252 #ifdef HAVE_NET_PFVAR_H
1253         case DLT_PFLOG:
1254                 off_linktype = 0;
1255                 off_macpl = PFLOG_HDRLEN;
1256                 off_nl = 0;
1257                 off_nl_nosnap = 0;      /* no 802.2 LLC */
1258                 return;
1259 #endif
1260
1261         case DLT_JUNIPER_MFR:
1262         case DLT_JUNIPER_MLFR:
1263         case DLT_JUNIPER_MLPPP:
1264         case DLT_JUNIPER_PPP:
1265         case DLT_JUNIPER_CHDLC:
1266         case DLT_JUNIPER_FRELAY:
1267                 off_linktype = 4;
1268                 off_macpl = 4;
1269                 off_nl = 0;
1270                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1271                 return;
1272
1273         case DLT_JUNIPER_ATM1:
1274                 off_linktype = 4;       /* in reality variable between 4-8 */
1275                 off_macpl = 4;  /* in reality variable between 4-8 */
1276                 off_nl = 0;
1277                 off_nl_nosnap = 10;
1278                 return;
1279
1280         case DLT_JUNIPER_ATM2:
1281                 off_linktype = 8;       /* in reality variable between 8-12 */
1282                 off_macpl = 8;  /* in reality variable between 8-12 */
1283                 off_nl = 0;
1284                 off_nl_nosnap = 10;
1285                 return;
1286
1287                 /* frames captured on a Juniper PPPoE service PIC
1288                  * contain raw ethernet frames */
1289         case DLT_JUNIPER_PPPOE:
1290         case DLT_JUNIPER_ETHER:
1291                 off_macpl = 14;
1292                 off_linktype = 16;
1293                 off_nl = 18;            /* Ethernet II */
1294                 off_nl_nosnap = 21;     /* 802.3+802.2 */
1295                 return;
1296
1297         case DLT_JUNIPER_PPPOE_ATM:
1298                 off_linktype = 4;
1299                 off_macpl = 6;
1300                 off_nl = 0;
1301                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1302                 return;
1303
1304         case DLT_JUNIPER_GGSN:
1305                 off_linktype = 6;
1306                 off_macpl = 12;
1307                 off_nl = 0;
1308                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1309                 return;
1310
1311         case DLT_JUNIPER_ES:
1312                 off_linktype = 6;
1313                 off_macpl = -1;         /* not really a network layer but raw IP addresses */
1314                 off_nl = -1;            /* not really a network layer but raw IP addresses */
1315                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1316                 return;
1317
1318         case DLT_JUNIPER_MONITOR:
1319                 off_linktype = 12;
1320                 off_macpl = 12;
1321                 off_nl = 0;             /* raw IP/IP6 header */
1322                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1323                 return;
1324
1325         case DLT_JUNIPER_SERVICES:
1326                 off_linktype = 12;
1327                 off_macpl = -1;         /* L3 proto location dep. on cookie type */
1328                 off_nl = -1;            /* L3 proto location dep. on cookie type */
1329                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1330                 return;
1331
1332         case DLT_JUNIPER_VP:
1333                 off_linktype = 18;
1334                 off_macpl = -1;
1335                 off_nl = -1;
1336                 off_nl_nosnap = -1;
1337                 return;
1338
1339         case DLT_JUNIPER_ST:
1340                 off_linktype = 18;
1341                 off_macpl = -1;
1342                 off_nl = -1;
1343                 off_nl_nosnap = -1;
1344                 return;
1345
1346         case DLT_JUNIPER_ISM:
1347                 off_linktype = 8;
1348                 off_macpl = -1;
1349                 off_nl = -1;
1350                 off_nl_nosnap = -1;
1351                 return;
1352
1353         case DLT_JUNIPER_VS:
1354         case DLT_JUNIPER_SRX_E2E:
1355         case DLT_JUNIPER_FIBRECHANNEL:
1356         case DLT_JUNIPER_ATM_CEMIC:
1357                 off_linktype = 8;
1358                 off_macpl = -1;
1359                 off_nl = -1;
1360                 off_nl_nosnap = -1;
1361                 return;
1362
1363         case DLT_MTP2:
1364                 off_li = 2;
1365                 off_sio = 3;
1366                 off_opc = 4;
1367                 off_dpc = 4;
1368                 off_sls = 7;
1369                 off_linktype = -1;
1370                 off_macpl = -1;
1371                 off_nl = -1;
1372                 off_nl_nosnap = -1;
1373                 return;
1374
1375         case DLT_MTP2_WITH_PHDR:
1376                 off_li = 6;
1377                 off_sio = 7;
1378                 off_opc = 8;
1379                 off_dpc = 8;
1380                 off_sls = 11;
1381                 off_linktype = -1;
1382                 off_macpl = -1;
1383                 off_nl = -1;
1384                 off_nl_nosnap = -1;
1385                 return;
1386
1387         case DLT_ERF:
1388                 off_li = 22;
1389                 off_sio = 23;
1390                 off_opc = 24;
1391                 off_dpc = 24;
1392                 off_sls = 27;
1393                 off_linktype = -1;
1394                 off_macpl = -1;
1395                 off_nl = -1;
1396                 off_nl_nosnap = -1;
1397                 return;
1398
1399 #ifdef DLT_PFSYNC
1400         case DLT_PFSYNC:
1401                 off_linktype = -1;
1402                 off_macpl = 4;
1403                 off_nl = 0;
1404                 off_nl_nosnap = 0;
1405                 return;
1406 #endif
1407
1408         case DLT_AX25_KISS:
1409                 /*
1410                  * Currently, only raw "link[N:M]" filtering is supported.
1411                  */
1412                 off_linktype = -1;      /* variable, min 15, max 71 steps of 7 */
1413                 off_macpl = -1;
1414                 off_nl = -1;            /* variable, min 16, max 71 steps of 7 */
1415                 off_nl_nosnap = -1;     /* no 802.2 LLC */
1416                 off_mac = 1;            /* step over the kiss length byte */
1417                 return;
1418
1419         case DLT_IPNET:
1420                 off_linktype = 1;
1421                 off_macpl = 24;         /* ipnet header length */
1422                 off_nl = 0;
1423                 off_nl_nosnap = -1;
1424                 return;
1425
1426         case DLT_NETANALYZER:
1427                 off_mac = 4;            /* MAC header is past 4-byte pseudo-header */
1428                 off_linktype = 16;      /* includes 4-byte pseudo-header */
1429                 off_macpl = 18;         /* pseudo-header+Ethernet header length */
1430                 off_nl = 0;             /* Ethernet II */
1431                 off_nl_nosnap = 3;      /* 802.3+802.2 */
1432                 return;
1433
1434         case DLT_NETANALYZER_TRANSPARENT:
1435                 off_mac = 12;           /* MAC header is past 4-byte pseudo-header, preamble, and SFD */
1436                 off_linktype = 24;      /* includes 4-byte pseudo-header+preamble+SFD */
1437                 off_macpl = 26;         /* pseudo-header+preamble+SFD+Ethernet header length */
1438                 off_nl = 0;             /* Ethernet II */
1439                 off_nl_nosnap = 3;      /* 802.3+802.2 */
1440                 return;
1441
1442         default:
1443                 /*
1444                  * For values in the range in which we've assigned new
1445                  * DLT_ values, only raw "link[N:M]" filtering is supported.
1446                  */
1447                 if (linktype >= DLT_MATCHING_MIN &&
1448                     linktype <= DLT_MATCHING_MAX) {
1449                         off_linktype = -1;
1450                         off_macpl = -1;
1451                         off_nl = -1;
1452                         off_nl_nosnap = -1;
1453                         return;
1454                 }
1455
1456         }
1457         bpf_error("unknown data link type %d", linktype);
1458         /* NOTREACHED */
1459 }
1460
1461 /*
1462  * Load a value relative to the beginning of the link-layer header.
1463  * The link-layer header doesn't necessarily begin at the beginning
1464  * of the packet data; there might be a variable-length prefix containing
1465  * radio information.
1466  */
1467 static struct slist *
1468 gen_load_llrel(offset, size)
1469         u_int offset, size;
1470 {
1471         struct slist *s, *s2;
1472
1473         s = gen_llprefixlen();
1474
1475         /*
1476          * If "s" is non-null, it has code to arrange that the X register
1477          * contains the length of the prefix preceding the link-layer
1478          * header.
1479          *
1480          * Otherwise, the length of the prefix preceding the link-layer
1481          * header is "off_ll".
1482          */
1483         if (s != NULL) {
1484                 /*
1485                  * There's a variable-length prefix preceding the
1486                  * link-layer header.  "s" points to a list of statements
1487                  * that put the length of that prefix into the X register.
1488                  * do an indirect load, to use the X register as an offset.
1489                  */
1490                 s2 = new_stmt(BPF_LD|BPF_IND|size);
1491                 s2->s.k = offset;
1492                 sappend(s, s2);
1493         } else {
1494                 /*
1495                  * There is no variable-length header preceding the
1496                  * link-layer header; add in off_ll, which, if there's
1497                  * a fixed-length header preceding the link-layer header,
1498                  * is the length of that header.
1499                  */
1500                 s = new_stmt(BPF_LD|BPF_ABS|size);
1501                 s->s.k = offset + off_ll;
1502         }
1503         return s;
1504 }
1505
1506 /*
1507  * Load a value relative to the beginning of the MAC-layer payload.
1508  */
1509 static struct slist *
1510 gen_load_macplrel(offset, size)
1511         u_int offset, size;
1512 {
1513         struct slist *s, *s2;
1514
1515         s = gen_off_macpl();
1516
1517         /*
1518          * If s is non-null, the offset of the MAC-layer payload is
1519          * variable, and s points to a list of instructions that
1520          * arrange that the X register contains that offset.
1521          *
1522          * Otherwise, the offset of the MAC-layer payload is constant,
1523          * and is in off_macpl.
1524          */
1525         if (s != NULL) {
1526                 /*
1527                  * The offset of the MAC-layer payload is in the X
1528                  * register.  Do an indirect load, to use the X register
1529                  * as an offset.
1530                  */
1531                 s2 = new_stmt(BPF_LD|BPF_IND|size);
1532                 s2->s.k = offset;
1533                 sappend(s, s2);
1534         } else {
1535                 /*
1536                  * The offset of the MAC-layer payload is constant,
1537                  * and is in off_macpl; load the value at that offset
1538                  * plus the specified offset.
1539                  */
1540                 s = new_stmt(BPF_LD|BPF_ABS|size);
1541                 s->s.k = off_macpl + offset;
1542         }
1543         return s;
1544 }
1545
1546 /*
1547  * Load a value relative to the beginning of the specified header.
1548  */
1549 static struct slist *
1550 gen_load_a(offrel, offset, size)
1551         enum e_offrel offrel;
1552         u_int offset, size;
1553 {
1554         struct slist *s, *s2;
1555
1556         switch (offrel) {
1557
1558         case OR_PACKET:
1559                 s = new_stmt(BPF_LD|BPF_ABS|size);
1560                 s->s.k = offset;
1561                 break;
1562
1563         case OR_LINK:
1564                 s = gen_load_llrel(offset, size);
1565                 break;
1566
1567         case OR_MACPL:
1568                 s = gen_load_macplrel(offset, size);
1569                 break;
1570
1571         case OR_NET:
1572                 s = gen_load_macplrel(off_nl + offset, size);
1573                 break;
1574
1575         case OR_NET_NOSNAP:
1576                 s = gen_load_macplrel(off_nl_nosnap + offset, size);
1577                 break;
1578
1579         case OR_TRAN_IPV4:
1580                 /*
1581                  * Load the X register with the length of the IPv4 header
1582                  * (plus the offset of the link-layer header, if it's
1583                  * preceded by a variable-length header such as a radio
1584                  * header), in bytes.
1585                  */
1586                 s = gen_loadx_iphdrlen();
1587
1588                 /*
1589                  * Load the item at {offset of the MAC-layer payload} +
1590                  * {offset, relative to the start of the MAC-layer
1591                  * paylod, of the IPv4 header} + {length of the IPv4 header} +
1592                  * {specified offset}.
1593                  *
1594                  * (If the offset of the MAC-layer payload is variable,
1595                  * it's included in the value in the X register, and
1596                  * off_macpl is 0.)
1597                  */
1598                 s2 = new_stmt(BPF_LD|BPF_IND|size);
1599                 s2->s.k = off_macpl + off_nl + offset;
1600                 sappend(s, s2);
1601                 break;
1602
1603         case OR_TRAN_IPV6:
1604                 s = gen_load_macplrel(off_nl + 40 + offset, size);
1605                 break;
1606
1607         default:
1608                 abort();
1609                 return NULL;
1610         }
1611         return s;
1612 }
1613
1614 /*
1615  * Generate code to load into the X register the sum of the length of
1616  * the IPv4 header and any variable-length header preceding the link-layer
1617  * header.
1618  */
1619 static struct slist *
1620 gen_loadx_iphdrlen()
1621 {
1622         struct slist *s, *s2;
1623
1624         s = gen_off_macpl();
1625         if (s != NULL) {
1626                 /*
1627                  * There's a variable-length prefix preceding the
1628                  * link-layer header, or the link-layer header is itself
1629                  * variable-length.  "s" points to a list of statements
1630                  * that put the offset of the MAC-layer payload into
1631                  * the X register.
1632                  *
1633                  * The 4*([k]&0xf) addressing mode can't be used, as we
1634                  * don't have a constant offset, so we have to load the
1635                  * value in question into the A register and add to it
1636                  * the value from the X register.
1637                  */
1638                 s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
1639                 s2->s.k = off_nl;
1640                 sappend(s, s2);
1641                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
1642                 s2->s.k = 0xf;
1643                 sappend(s, s2);
1644                 s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
1645                 s2->s.k = 2;
1646                 sappend(s, s2);
1647
1648                 /*
1649                  * The A register now contains the length of the
1650                  * IP header.  We need to add to it the offset of
1651                  * the MAC-layer payload, which is still in the X
1652                  * register, and move the result into the X register.
1653                  */
1654                 sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
1655                 sappend(s, new_stmt(BPF_MISC|BPF_TAX));
1656         } else {
1657                 /*
1658                  * There is no variable-length header preceding the
1659                  * link-layer header, and the link-layer header is
1660                  * fixed-length; load the length of the IPv4 header,
1661                  * which is at an offset of off_nl from the beginning
1662                  * of the MAC-layer payload, and thus at an offset
1663                  * of off_mac_pl + off_nl from the beginning of the
1664                  * raw packet data.
1665                  */
1666                 s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
1667                 s->s.k = off_macpl + off_nl;
1668         }
1669         return s;
1670 }
1671
1672 static struct block *
1673 gen_uncond(rsense)
1674         int rsense;
1675 {
1676         struct block *b;
1677         struct slist *s;
1678
1679         s = new_stmt(BPF_LD|BPF_IMM);
1680         s->s.k = !rsense;
1681         b = new_block(JMP(BPF_JEQ));
1682         b->stmts = s;
1683
1684         return b;
1685 }
1686
1687 static inline struct block *
1688 gen_true()
1689 {
1690         return gen_uncond(1);
1691 }
1692
1693 static inline struct block *
1694 gen_false()
1695 {
1696         return gen_uncond(0);
1697 }
1698
1699 /*
1700  * Byte-swap a 32-bit number.
1701  * ("htonl()" or "ntohl()" won't work - we want to byte-swap even on
1702  * big-endian platforms.)
1703  */
1704 #define SWAPLONG(y) \
1705 ((((y)&0xff)<<24) | (((y)&0xff00)<<8) | (((y)&0xff0000)>>8) | (((y)>>24)&0xff))
1706
1707 /*
1708  * Generate code to match a particular packet type.
1709  *
1710  * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
1711  * value, if <= ETHERMTU.  We use that to determine whether to
1712  * match the type/length field or to check the type/length field for
1713  * a value <= ETHERMTU to see whether it's a type field and then do
1714  * the appropriate test.
1715  */
1716 static struct block *
1717 gen_ether_linktype(proto)
1718         register int proto;
1719 {
1720         struct block *b0, *b1;
1721
1722         switch (proto) {
1723
1724         case LLCSAP_ISONS:
1725         case LLCSAP_IP:
1726         case LLCSAP_NETBEUI:
1727                 /*
1728                  * OSI protocols and NetBEUI always use 802.2 encapsulation,
1729                  * so we check the DSAP and SSAP.
1730                  *
1731                  * LLCSAP_IP checks for IP-over-802.2, rather
1732                  * than IP-over-Ethernet or IP-over-SNAP.
1733                  *
1734                  * XXX - should we check both the DSAP and the
1735                  * SSAP, like this, or should we check just the
1736                  * DSAP, as we do for other types <= ETHERMTU
1737                  * (i.e., other SAP values)?
1738                  */
1739                 b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1740                 gen_not(b0);
1741                 b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)
1742                              ((proto << 8) | proto));
1743                 gen_and(b0, b1);
1744                 return b1;
1745
1746         case LLCSAP_IPX:
1747                 /*
1748                  * Check for;
1749                  *
1750                  *      Ethernet_II frames, which are Ethernet
1751                  *      frames with a frame type of ETHERTYPE_IPX;
1752                  *
1753                  *      Ethernet_802.3 frames, which are 802.3
1754                  *      frames (i.e., the type/length field is
1755                  *      a length field, <= ETHERMTU, rather than
1756                  *      a type field) with the first two bytes
1757                  *      after the Ethernet/802.3 header being
1758                  *      0xFFFF;
1759                  *
1760                  *      Ethernet_802.2 frames, which are 802.3
1761                  *      frames with an 802.2 LLC header and
1762                  *      with the IPX LSAP as the DSAP in the LLC
1763                  *      header;
1764                  *
1765                  *      Ethernet_SNAP frames, which are 802.3
1766                  *      frames with an LLC header and a SNAP
1767                  *      header and with an OUI of 0x000000
1768                  *      (encapsulated Ethernet) and a protocol
1769                  *      ID of ETHERTYPE_IPX in the SNAP header.
1770                  *
1771                  * XXX - should we generate the same code both
1772                  * for tests for LLCSAP_IPX and for ETHERTYPE_IPX?
1773                  */
1774
1775                 /*
1776                  * This generates code to check both for the
1777                  * IPX LSAP (Ethernet_802.2) and for Ethernet_802.3.
1778                  */
1779                 b0 = gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
1780                 b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)0xFFFF);
1781                 gen_or(b0, b1);
1782
1783                 /*
1784                  * Now we add code to check for SNAP frames with
1785                  * ETHERTYPE_IPX, i.e. Ethernet_SNAP.
1786                  */
1787                 b0 = gen_snap(0x000000, ETHERTYPE_IPX);
1788                 gen_or(b0, b1);
1789
1790                 /*
1791                  * Now we generate code to check for 802.3
1792                  * frames in general.
1793                  */
1794                 b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1795                 gen_not(b0);
1796
1797                 /*
1798                  * Now add the check for 802.3 frames before the
1799                  * check for Ethernet_802.2 and Ethernet_802.3,
1800                  * as those checks should only be done on 802.3
1801                  * frames, not on Ethernet frames.
1802                  */
1803                 gen_and(b0, b1);
1804
1805                 /*
1806                  * Now add the check for Ethernet_II frames, and
1807                  * do that before checking for the other frame
1808                  * types.
1809                  */
1810                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
1811                     (bpf_int32)ETHERTYPE_IPX);
1812                 gen_or(b0, b1);
1813                 return b1;
1814
1815         case ETHERTYPE_ATALK:
1816         case ETHERTYPE_AARP:
1817                 /*
1818                  * EtherTalk (AppleTalk protocols on Ethernet link
1819                  * layer) may use 802.2 encapsulation.
1820                  */
1821
1822                 /*
1823                  * Check for 802.2 encapsulation (EtherTalk phase 2?);
1824                  * we check for an Ethernet type field less than
1825                  * 1500, which means it's an 802.3 length field.
1826                  */
1827                 b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1828                 gen_not(b0);
1829
1830                 /*
1831                  * 802.2-encapsulated ETHERTYPE_ATALK packets are
1832                  * SNAP packets with an organization code of
1833                  * 0x080007 (Apple, for Appletalk) and a protocol
1834                  * type of ETHERTYPE_ATALK (Appletalk).
1835                  *
1836                  * 802.2-encapsulated ETHERTYPE_AARP packets are
1837                  * SNAP packets with an organization code of
1838                  * 0x000000 (encapsulated Ethernet) and a protocol
1839                  * type of ETHERTYPE_AARP (Appletalk ARP).
1840                  */
1841                 if (proto == ETHERTYPE_ATALK)
1842                         b1 = gen_snap(0x080007, ETHERTYPE_ATALK);
1843                 else    /* proto == ETHERTYPE_AARP */
1844                         b1 = gen_snap(0x000000, ETHERTYPE_AARP);
1845                 gen_and(b0, b1);
1846
1847                 /*
1848                  * Check for Ethernet encapsulation (Ethertalk
1849                  * phase 1?); we just check for the Ethernet
1850                  * protocol type.
1851                  */
1852                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
1853
1854                 gen_or(b0, b1);
1855                 return b1;
1856
1857         default:
1858                 if (proto <= ETHERMTU) {
1859                         /*
1860                          * This is an LLC SAP value, so the frames
1861                          * that match would be 802.2 frames.
1862                          * Check that the frame is an 802.2 frame
1863                          * (i.e., that the length/type field is
1864                          * a length field, <= ETHERMTU) and
1865                          * then check the DSAP.
1866                          */
1867                         b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1868                         gen_not(b0);
1869                         b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,
1870                             (bpf_int32)proto);
1871                         gen_and(b0, b1);
1872                         return b1;
1873                 } else {
1874                         /*
1875                          * This is an Ethernet type, so compare
1876                          * the length/type field with it (if
1877                          * the frame is an 802.2 frame, the length
1878                          * field will be <= ETHERMTU, and, as
1879                          * "proto" is > ETHERMTU, this test
1880                          * will fail and the frame won't match,
1881                          * which is what we want).
1882                          */
1883                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
1884                             (bpf_int32)proto);
1885                 }
1886         }
1887 }
1888
1889 /*
1890  * "proto" is an Ethernet type value and for IPNET, if it is not IPv4
1891  * or IPv6 then we have an error.
1892  */
1893 static struct block *
1894 gen_ipnet_linktype(proto)
1895         register int proto;
1896 {
1897         switch (proto) {
1898
1899         case ETHERTYPE_IP:
1900                 return gen_cmp(OR_LINK, off_linktype, BPF_B,
1901                     (bpf_int32)IPH_AF_INET);
1902                 /* NOTREACHED */
1903
1904         case ETHERTYPE_IPV6:
1905                 return gen_cmp(OR_LINK, off_linktype, BPF_B,
1906                     (bpf_int32)IPH_AF_INET6);
1907                 /* NOTREACHED */
1908
1909         default:
1910                 break;
1911         }
1912
1913         return gen_false();
1914 }
1915
1916 /*
1917  * Generate code to match a particular packet type.
1918  *
1919  * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
1920  * value, if <= ETHERMTU.  We use that to determine whether to
1921  * match the type field or to check the type field for the special
1922  * LINUX_SLL_P_802_2 value and then do the appropriate test.
1923  */
1924 static struct block *
1925 gen_linux_sll_linktype(proto)
1926         register int proto;
1927 {
1928         struct block *b0, *b1;
1929
1930         switch (proto) {
1931
1932         case LLCSAP_ISONS:
1933         case LLCSAP_IP:
1934         case LLCSAP_NETBEUI:
1935                 /*
1936                  * OSI protocols and NetBEUI always use 802.2 encapsulation,
1937                  * so we check the DSAP and SSAP.
1938                  *
1939                  * LLCSAP_IP checks for IP-over-802.2, rather
1940                  * than IP-over-Ethernet or IP-over-SNAP.
1941                  *
1942                  * XXX - should we check both the DSAP and the
1943                  * SSAP, like this, or should we check just the
1944                  * DSAP, as we do for other types <= ETHERMTU
1945                  * (i.e., other SAP values)?
1946                  */
1947                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
1948                 b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)
1949                              ((proto << 8) | proto));
1950                 gen_and(b0, b1);
1951                 return b1;
1952
1953         case LLCSAP_IPX:
1954                 /*
1955                  *      Ethernet_II frames, which are Ethernet
1956                  *      frames with a frame type of ETHERTYPE_IPX;
1957                  *
1958                  *      Ethernet_802.3 frames, which have a frame
1959                  *      type of LINUX_SLL_P_802_3;
1960                  *
1961                  *      Ethernet_802.2 frames, which are 802.3
1962                  *      frames with an 802.2 LLC header (i.e, have
1963                  *      a frame type of LINUX_SLL_P_802_2) and
1964                  *      with the IPX LSAP as the DSAP in the LLC
1965                  *      header;
1966                  *
1967                  *      Ethernet_SNAP frames, which are 802.3
1968                  *      frames with an LLC header and a SNAP
1969                  *      header and with an OUI of 0x000000
1970                  *      (encapsulated Ethernet) and a protocol
1971                  *      ID of ETHERTYPE_IPX in the SNAP header.
1972                  *
1973                  * First, do the checks on LINUX_SLL_P_802_2
1974                  * frames; generate the check for either
1975                  * Ethernet_802.2 or Ethernet_SNAP frames, and
1976                  * then put a check for LINUX_SLL_P_802_2 frames
1977                  * before it.
1978                  */
1979                 b0 = gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
1980                 b1 = gen_snap(0x000000, ETHERTYPE_IPX);
1981                 gen_or(b0, b1);
1982                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
1983                 gen_and(b0, b1);
1984
1985                 /*
1986                  * Now check for 802.3 frames and OR that with
1987                  * the previous test.
1988                  */
1989                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_3);
1990                 gen_or(b0, b1);
1991
1992                 /*
1993                  * Now add the check for Ethernet_II frames, and
1994                  * do that before checking for the other frame
1995                  * types.
1996                  */
1997                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
1998                     (bpf_int32)ETHERTYPE_IPX);
1999                 gen_or(b0, b1);
2000                 return b1;
2001
2002         case ETHERTYPE_ATALK:
2003         case ETHERTYPE_AARP:
2004                 /*
2005                  * EtherTalk (AppleTalk protocols on Ethernet link
2006                  * layer) may use 802.2 encapsulation.
2007                  */
2008
2009                 /*
2010                  * Check for 802.2 encapsulation (EtherTalk phase 2?);
2011                  * we check for the 802.2 protocol type in the
2012                  * "Ethernet type" field.
2013                  */
2014                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
2015
2016                 /*
2017                  * 802.2-encapsulated ETHERTYPE_ATALK packets are
2018                  * SNAP packets with an organization code of
2019                  * 0x080007 (Apple, for Appletalk) and a protocol
2020                  * type of ETHERTYPE_ATALK (Appletalk).
2021                  *
2022                  * 802.2-encapsulated ETHERTYPE_AARP packets are
2023                  * SNAP packets with an organization code of
2024                  * 0x000000 (encapsulated Ethernet) and a protocol
2025                  * type of ETHERTYPE_AARP (Appletalk ARP).
2026                  */
2027                 if (proto == ETHERTYPE_ATALK)
2028                         b1 = gen_snap(0x080007, ETHERTYPE_ATALK);
2029                 else    /* proto == ETHERTYPE_AARP */
2030                         b1 = gen_snap(0x000000, ETHERTYPE_AARP);
2031                 gen_and(b0, b1);
2032
2033                 /*
2034                  * Check for Ethernet encapsulation (Ethertalk
2035                  * phase 1?); we just check for the Ethernet
2036                  * protocol type.
2037                  */
2038                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
2039
2040                 gen_or(b0, b1);
2041                 return b1;
2042
2043         default:
2044                 if (proto <= ETHERMTU) {
2045                         /*
2046                          * This is an LLC SAP value, so the frames
2047                          * that match would be 802.2 frames.
2048                          * Check for the 802.2 protocol type
2049                          * in the "Ethernet type" field, and
2050                          * then check the DSAP.
2051                          */
2052                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
2053                             LINUX_SLL_P_802_2);
2054                         b1 = gen_cmp(OR_LINK, off_macpl, BPF_B,
2055                              (bpf_int32)proto);
2056                         gen_and(b0, b1);
2057                         return b1;
2058                 } else {
2059                         /*
2060                          * This is an Ethernet type, so compare
2061                          * the length/type field with it (if
2062                          * the frame is an 802.2 frame, the length
2063                          * field will be <= ETHERMTU, and, as
2064                          * "proto" is > ETHERMTU, this test
2065                          * will fail and the frame won't match,
2066                          * which is what we want).
2067                          */
2068                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
2069                             (bpf_int32)proto);
2070                 }
2071         }
2072 }
2073
2074 static struct slist *
2075 gen_load_prism_llprefixlen()
2076 {
2077         struct slist *s1, *s2;
2078         struct slist *sjeq_avs_cookie;
2079         struct slist *sjcommon;
2080
2081         /*
2082          * This code is not compatible with the optimizer, as
2083          * we are generating jmp instructions within a normal
2084          * slist of instructions
2085          */
2086         no_optimize = 1;
2087
2088         /*
2089          * Generate code to load the length of the radio header into
2090          * the register assigned to hold that length, if one has been
2091          * assigned.  (If one hasn't been assigned, no code we've
2092          * generated uses that prefix, so we don't need to generate any
2093          * code to load it.)
2094          *
2095          * Some Linux drivers use ARPHRD_IEEE80211_PRISM but sometimes
2096          * or always use the AVS header rather than the Prism header.
2097          * We load a 4-byte big-endian value at the beginning of the
2098          * raw packet data, and see whether, when masked with 0xFFFFF000,
2099          * it's equal to 0x80211000.  If so, that indicates that it's
2100          * an AVS header (the masked-out bits are the version number).
2101          * Otherwise, it's a Prism header.
2102          *
2103          * XXX - the Prism header is also, in theory, variable-length,
2104          * but no known software generates headers that aren't 144
2105          * bytes long.
2106          */
2107         if (reg_off_ll != -1) {
2108                 /*
2109                  * Load the cookie.
2110                  */
2111                 s1 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2112                 s1->s.k = 0;
2113
2114                 /*
2115                  * AND it with 0xFFFFF000.
2116                  */
2117                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
2118                 s2->s.k = 0xFFFFF000;
2119                 sappend(s1, s2);
2120
2121                 /*
2122                  * Compare with 0x80211000.
2123                  */
2124                 sjeq_avs_cookie = new_stmt(JMP(BPF_JEQ));
2125                 sjeq_avs_cookie->s.k = 0x80211000;
2126                 sappend(s1, sjeq_avs_cookie);
2127
2128                 /*
2129                  * If it's AVS:
2130                  *
2131                  * The 4 bytes at an offset of 4 from the beginning of
2132                  * the AVS header are the length of the AVS header.
2133                  * That field is big-endian.
2134                  */
2135                 s2 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2136                 s2->s.k = 4;
2137                 sappend(s1, s2);
2138                 sjeq_avs_cookie->s.jt = s2;
2139
2140                 /*
2141                  * Now jump to the code to allocate a register
2142                  * into which to save the header length and
2143                  * store the length there.  (The "jump always"
2144                  * instruction needs to have the k field set;
2145                  * it's added to the PC, so, as we're jumping
2146                  * over a single instruction, it should be 1.)
2147                  */
2148                 sjcommon = new_stmt(JMP(BPF_JA));
2149                 sjcommon->s.k = 1;
2150                 sappend(s1, sjcommon);
2151
2152                 /*
2153                  * Now for the code that handles the Prism header.
2154                  * Just load the length of the Prism header (144)
2155                  * into the A register.  Have the test for an AVS
2156                  * header branch here if we don't have an AVS header.
2157                  */
2158                 s2 = new_stmt(BPF_LD|BPF_W|BPF_IMM);
2159                 s2->s.k = 144;
2160                 sappend(s1, s2);
2161                 sjeq_avs_cookie->s.jf = s2;
2162
2163                 /*
2164                  * Now allocate a register to hold that value and store
2165                  * it.  The code for the AVS header will jump here after
2166                  * loading the length of the AVS header.
2167                  */
2168                 s2 = new_stmt(BPF_ST);
2169                 s2->s.k = reg_off_ll;
2170                 sappend(s1, s2);
2171                 sjcommon->s.jf = s2;
2172
2173                 /*
2174                  * Now move it into the X register.
2175                  */
2176                 s2 = new_stmt(BPF_MISC|BPF_TAX);
2177                 sappend(s1, s2);
2178
2179                 return (s1);
2180         } else
2181                 return (NULL);
2182 }
2183
2184 static struct slist *
2185 gen_load_avs_llprefixlen()
2186 {
2187         struct slist *s1, *s2;
2188
2189         /*
2190          * Generate code to load the length of the AVS header into
2191          * the register assigned to hold that length, if one has been
2192          * assigned.  (If one hasn't been assigned, no code we've
2193          * generated uses that prefix, so we don't need to generate any
2194          * code to load it.)
2195          */
2196         if (reg_off_ll != -1) {
2197                 /*
2198                  * The 4 bytes at an offset of 4 from the beginning of
2199                  * the AVS header are the length of the AVS header.
2200                  * That field is big-endian.
2201                  */
2202                 s1 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2203                 s1->s.k = 4;
2204
2205                 /*
2206                  * Now allocate a register to hold that value and store
2207                  * it.
2208                  */
2209                 s2 = new_stmt(BPF_ST);
2210                 s2->s.k = reg_off_ll;
2211                 sappend(s1, s2);
2212
2213                 /*
2214                  * Now move it into the X register.
2215                  */
2216                 s2 = new_stmt(BPF_MISC|BPF_TAX);
2217                 sappend(s1, s2);
2218
2219                 return (s1);
2220         } else
2221                 return (NULL);
2222 }
2223
2224 static struct slist *
2225 gen_load_radiotap_llprefixlen()
2226 {
2227         struct slist *s1, *s2;
2228
2229         /*
2230          * Generate code to load the length of the radiotap header into
2231          * the register assigned to hold that length, if one has been
2232          * assigned.  (If one hasn't been assigned, no code we've
2233          * generated uses that prefix, so we don't need to generate any
2234          * code to load it.)
2235          */
2236         if (reg_off_ll != -1) {
2237                 /*
2238                  * The 2 bytes at offsets of 2 and 3 from the beginning
2239                  * of the radiotap header are the length of the radiotap
2240                  * header; unfortunately, it's little-endian, so we have
2241                  * to load it a byte at a time and construct the value.
2242                  */
2243
2244                 /*
2245                  * Load the high-order byte, at an offset of 3, shift it
2246                  * left a byte, and put the result in the X register.
2247                  */
2248                 s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2249                 s1->s.k = 3;
2250                 s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
2251                 sappend(s1, s2);
2252                 s2->s.k = 8;
2253                 s2 = new_stmt(BPF_MISC|BPF_TAX);
2254                 sappend(s1, s2);
2255
2256                 /*
2257                  * Load the next byte, at an offset of 2, and OR the
2258                  * value from the X register into it.
2259                  */
2260                 s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2261                 sappend(s1, s2);
2262                 s2->s.k = 2;
2263                 s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
2264                 sappend(s1, s2);
2265
2266                 /*
2267                  * Now allocate a register to hold that value and store
2268                  * it.
2269                  */
2270                 s2 = new_stmt(BPF_ST);
2271                 s2->s.k = reg_off_ll;
2272                 sappend(s1, s2);
2273
2274                 /*
2275                  * Now move it into the X register.
2276                  */
2277                 s2 = new_stmt(BPF_MISC|BPF_TAX);
2278                 sappend(s1, s2);
2279
2280                 return (s1);
2281         } else
2282                 return (NULL);
2283 }
2284
2285 /* 
2286  * At the moment we treat PPI as normal Radiotap encoded
2287  * packets. The difference is in the function that generates
2288  * the code at the beginning to compute the header length.
2289  * Since this code generator of PPI supports bare 802.11
2290  * encapsulation only (i.e. the encapsulated DLT should be
2291  * DLT_IEEE802_11) we generate code to check for this too;
2292  * that's done in finish_parse().
2293  */
2294 static struct slist *
2295 gen_load_ppi_llprefixlen()
2296 {
2297         struct slist *s1, *s2;
2298         
2299         /*
2300          * Generate code to load the length of the radiotap header
2301          * into the register assigned to hold that length, if one has
2302          * been assigned.
2303          */
2304         if (reg_off_ll != -1) {
2305                 /*
2306                  * The 2 bytes at offsets of 2 and 3 from the beginning
2307                  * of the radiotap header are the length of the radiotap
2308                  * header; unfortunately, it's little-endian, so we have
2309                  * to load it a byte at a time and construct the value.
2310                  */
2311
2312                 /*
2313                  * Load the high-order byte, at an offset of 3, shift it
2314                  * left a byte, and put the result in the X register.
2315                  */
2316                 s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2317                 s1->s.k = 3;
2318                 s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
2319                 sappend(s1, s2);
2320                 s2->s.k = 8;
2321                 s2 = new_stmt(BPF_MISC|BPF_TAX);
2322                 sappend(s1, s2);
2323
2324                 /*
2325                  * Load the next byte, at an offset of 2, and OR the
2326                  * value from the X register into it.
2327                  */
2328                 s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2329                 sappend(s1, s2);
2330                 s2->s.k = 2;
2331                 s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
2332                 sappend(s1, s2);
2333
2334                 /*
2335                  * Now allocate a register to hold that value and store
2336                  * it.
2337                  */
2338                 s2 = new_stmt(BPF_ST);
2339                 s2->s.k = reg_off_ll;
2340                 sappend(s1, s2);
2341
2342                 /*
2343                  * Now move it into the X register.
2344                  */
2345                 s2 = new_stmt(BPF_MISC|BPF_TAX);
2346                 sappend(s1, s2);
2347
2348                 return (s1);
2349         } else
2350                 return (NULL);
2351 }
2352
2353 /*
2354  * Load a value relative to the beginning of the link-layer header after the 802.11
2355  * header, i.e. LLC_SNAP.
2356  * The link-layer header doesn't necessarily begin at the beginning
2357  * of the packet data; there might be a variable-length prefix containing
2358  * radio information.
2359  */
2360 static struct slist *
2361 gen_load_802_11_header_len(struct slist *s, struct slist *snext)
2362 {
2363         struct slist *s2;
2364         struct slist *sjset_data_frame_1;
2365         struct slist *sjset_data_frame_2;
2366         struct slist *sjset_qos;
2367         struct slist *sjset_radiotap_flags;
2368         struct slist *sjset_radiotap_tsft;
2369         struct slist *sjset_tsft_datapad, *sjset_notsft_datapad;
2370         struct slist *s_roundup;
2371
2372         if (reg_off_macpl == -1) {
2373                 /*
2374                  * No register has been assigned to the offset of
2375                  * the MAC-layer payload, which means nobody needs
2376                  * it; don't bother computing it - just return
2377                  * what we already have.
2378                  */
2379                 return (s);
2380         }
2381
2382         /*
2383          * This code is not compatible with the optimizer, as
2384          * we are generating jmp instructions within a normal
2385          * slist of instructions
2386          */
2387         no_optimize = 1;
2388         
2389         /*
2390          * If "s" is non-null, it has code to arrange that the X register
2391          * contains the length of the prefix preceding the link-layer
2392          * header.
2393          *
2394          * Otherwise, the length of the prefix preceding the link-layer
2395          * header is "off_ll".
2396          */
2397         if (s == NULL) {
2398                 /*
2399                  * There is no variable-length header preceding the
2400                  * link-layer header.
2401                  *
2402                  * Load the length of the fixed-length prefix preceding
2403                  * the link-layer header (if any) into the X register,
2404                  * and store it in the reg_off_macpl register.
2405                  * That length is off_ll.
2406                  */
2407                 s = new_stmt(BPF_LDX|BPF_IMM);
2408                 s->s.k = off_ll;
2409         }
2410
2411         /*
2412          * The X register contains the offset of the beginning of the
2413          * link-layer header; add 24, which is the minimum length
2414          * of the MAC header for a data frame, to that, and store it
2415          * in reg_off_macpl, and then load the Frame Control field,
2416          * which is at the offset in the X register, with an indexed load.
2417          */
2418         s2 = new_stmt(BPF_MISC|BPF_TXA);
2419         sappend(s, s2);
2420         s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
2421         s2->s.k = 24;
2422         sappend(s, s2);
2423         s2 = new_stmt(BPF_ST);
2424         s2->s.k = reg_off_macpl;
2425         sappend(s, s2);
2426
2427         s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
2428         s2->s.k = 0;
2429         sappend(s, s2);
2430
2431         /*
2432          * Check the Frame Control field to see if this is a data frame;
2433          * a data frame has the 0x08 bit (b3) in that field set and the
2434          * 0x04 bit (b2) clear.
2435          */
2436         sjset_data_frame_1 = new_stmt(JMP(BPF_JSET));
2437         sjset_data_frame_1->s.k = 0x08;
2438         sappend(s, sjset_data_frame_1);
2439                 
2440         /*
2441          * If b3 is set, test b2, otherwise go to the first statement of
2442          * the rest of the program.
2443          */
2444         sjset_data_frame_1->s.jt = sjset_data_frame_2 = new_stmt(JMP(BPF_JSET));
2445         sjset_data_frame_2->s.k = 0x04;
2446         sappend(s, sjset_data_frame_2);
2447         sjset_data_frame_1->s.jf = snext;
2448
2449         /*
2450          * If b2 is not set, this is a data frame; test the QoS bit.
2451          * Otherwise, go to the first statement of the rest of the
2452          * program.
2453          */
2454         sjset_data_frame_2->s.jt = snext;
2455         sjset_data_frame_2->s.jf = sjset_qos = new_stmt(JMP(BPF_JSET));
2456         sjset_qos->s.k = 0x80;  /* QoS bit */
2457         sappend(s, sjset_qos);
2458                 
2459         /*
2460          * If it's set, add 2 to reg_off_macpl, to skip the QoS
2461          * field.
2462          * Otherwise, go to the first statement of the rest of the
2463          * program.
2464          */
2465         sjset_qos->s.jt = s2 = new_stmt(BPF_LD|BPF_MEM);
2466         s2->s.k = reg_off_macpl;
2467         sappend(s, s2);
2468         s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_IMM);
2469         s2->s.k = 2;
2470         sappend(s, s2);
2471         s2 = new_stmt(BPF_ST);
2472         s2->s.k = reg_off_macpl;
2473         sappend(s, s2);
2474
2475         /*
2476          * If we have a radiotap header, look at it to see whether
2477          * there's Atheros padding between the MAC-layer header
2478          * and the payload.
2479          *
2480          * Note: all of the fields in the radiotap header are
2481          * little-endian, so we byte-swap all of the values
2482          * we test against, as they will be loaded as big-endian
2483          * values.
2484          */
2485         if (linktype == DLT_IEEE802_11_RADIO) {
2486                 /*
2487                  * Is the IEEE80211_RADIOTAP_FLAGS bit (0x0000002) set
2488                  * in the presence flag?
2489                  */
2490                 sjset_qos->s.jf = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_W);
2491                 s2->s.k = 4;
2492                 sappend(s, s2);
2493
2494                 sjset_radiotap_flags = new_stmt(JMP(BPF_JSET));
2495                 sjset_radiotap_flags->s.k = SWAPLONG(0x00000002);
2496                 sappend(s, sjset_radiotap_flags);
2497
2498                 /*
2499                  * If not, skip all of this.
2500                  */
2501                 sjset_radiotap_flags->s.jf = snext;
2502
2503                 /*
2504                  * Otherwise, is the IEEE80211_RADIOTAP_TSFT bit set?
2505                  */
2506                 sjset_radiotap_tsft = sjset_radiotap_flags->s.jt =
2507                     new_stmt(JMP(BPF_JSET));
2508                 sjset_radiotap_tsft->s.k = SWAPLONG(0x00000001);
2509                 sappend(s, sjset_radiotap_tsft);
2510
2511                 /*
2512                  * If IEEE80211_RADIOTAP_TSFT is set, the flags field is
2513                  * at an offset of 16 from the beginning of the raw packet
2514                  * data (8 bytes for the radiotap header and 8 bytes for
2515                  * the TSFT field).
2516                  *
2517                  * Test whether the IEEE80211_RADIOTAP_F_DATAPAD bit (0x20)
2518                  * is set.
2519                  */
2520                 sjset_radiotap_tsft->s.jt = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_B);
2521                 s2->s.k = 16;
2522                 sappend(s, s2);
2523
2524                 sjset_tsft_datapad = new_stmt(JMP(BPF_JSET));
2525                 sjset_tsft_datapad->s.k = 0x20;
2526                 sappend(s, sjset_tsft_datapad);
2527
2528                 /*
2529                  * If IEEE80211_RADIOTAP_TSFT is not set, the flags field is
2530                  * at an offset of 8 from the beginning of the raw packet
2531                  * data (8 bytes for the radiotap header).
2532                  *
2533                  * Test whether the IEEE80211_RADIOTAP_F_DATAPAD bit (0x20)
2534                  * is set.
2535                  */
2536                 sjset_radiotap_tsft->s.jf = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_B);
2537                 s2->s.k = 8;
2538                 sappend(s, s2);
2539
2540                 sjset_notsft_datapad = new_stmt(JMP(BPF_JSET));
2541                 sjset_notsft_datapad->s.k = 0x20;
2542                 sappend(s, sjset_notsft_datapad);
2543
2544                 /*
2545                  * In either case, if IEEE80211_RADIOTAP_F_DATAPAD is
2546                  * set, round the length of the 802.11 header to
2547                  * a multiple of 4.  Do that by adding 3 and then
2548                  * dividing by and multiplying by 4, which we do by
2549                  * ANDing with ~3.
2550                  */
2551                 s_roundup = new_stmt(BPF_LD|BPF_MEM);
2552                 s_roundup->s.k = reg_off_macpl;
2553                 sappend(s, s_roundup);
2554                 s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_IMM);
2555                 s2->s.k = 3;
2556                 sappend(s, s2);
2557                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_IMM);
2558                 s2->s.k = ~3;
2559                 sappend(s, s2);
2560                 s2 = new_stmt(BPF_ST);
2561                 s2->s.k = reg_off_macpl;
2562                 sappend(s, s2);
2563
2564                 sjset_tsft_datapad->s.jt = s_roundup;
2565                 sjset_tsft_datapad->s.jf = snext;
2566                 sjset_notsft_datapad->s.jt = s_roundup;
2567                 sjset_notsft_datapad->s.jf = snext;
2568         } else
2569                 sjset_qos->s.jf = snext;
2570
2571         return s;
2572 }
2573
2574 static void
2575 insert_compute_vloffsets(b)
2576         struct block *b;
2577 {
2578         struct slist *s;
2579
2580         /*
2581          * For link-layer types that have a variable-length header
2582          * preceding the link-layer header, generate code to load
2583          * the offset of the link-layer header into the register
2584          * assigned to that offset, if any.
2585          */
2586         switch (linktype) {
2587
2588         case DLT_PRISM_HEADER:
2589                 s = gen_load_prism_llprefixlen();
2590                 break;
2591
2592         case DLT_IEEE802_11_RADIO_AVS:
2593                 s = gen_load_avs_llprefixlen();
2594                 break;
2595
2596         case DLT_IEEE802_11_RADIO:
2597                 s = gen_load_radiotap_llprefixlen();
2598                 break;
2599
2600         case DLT_PPI:
2601                 s = gen_load_ppi_llprefixlen();
2602                 break;
2603
2604         default:
2605                 s = NULL;
2606                 break;
2607         }
2608
2609         /*
2610          * For link-layer types that have a variable-length link-layer
2611          * header, generate code to load the offset of the MAC-layer
2612          * payload into the register assigned to that offset, if any.
2613          */
2614         switch (linktype) {
2615
2616         case DLT_IEEE802_11:
2617         case DLT_PRISM_HEADER:
2618         case DLT_IEEE802_11_RADIO_AVS:
2619         case DLT_IEEE802_11_RADIO:
2620         case DLT_PPI:
2621                 s = gen_load_802_11_header_len(s, b->stmts);
2622                 break;
2623         }
2624
2625         /*
2626          * If we have any offset-loading code, append all the
2627          * existing statements in the block to those statements,
2628          * and make the resulting list the list of statements
2629          * for the block.
2630          */
2631         if (s != NULL) {
2632                 sappend(s, b->stmts);
2633                 b->stmts = s;
2634         }
2635 }
2636
2637 static struct block *
2638 gen_ppi_dlt_check(void)
2639 {
2640         struct slist *s_load_dlt;
2641         struct block *b;
2642
2643         if (linktype == DLT_PPI)
2644         {
2645                 /* Create the statements that check for the DLT
2646                  */
2647                 s_load_dlt = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2648                 s_load_dlt->s.k = 4;
2649
2650                 b = new_block(JMP(BPF_JEQ));
2651
2652                 b->stmts = s_load_dlt;
2653                 b->s.k = SWAPLONG(DLT_IEEE802_11);
2654         }
2655         else
2656         {
2657                 b = NULL;
2658         }
2659
2660         return b;
2661 }
2662
2663 static struct slist *
2664 gen_prism_llprefixlen(void)
2665 {
2666         struct slist *s;
2667
2668         if (reg_off_ll == -1) {
2669                 /*
2670                  * We haven't yet assigned a register for the length
2671                  * of the radio header; allocate one.
2672                  */
2673                 reg_off_ll = alloc_reg();
2674         }
2675
2676         /*
2677          * Load the register containing the radio length
2678          * into the X register.
2679          */
2680         s = new_stmt(BPF_LDX|BPF_MEM);
2681         s->s.k = reg_off_ll;
2682         return s;
2683 }
2684
2685 static struct slist *
2686 gen_avs_llprefixlen(void)
2687 {
2688         struct slist *s;
2689
2690         if (reg_off_ll == -1) {
2691                 /*
2692                  * We haven't yet assigned a register for the length
2693                  * of the AVS header; allocate one.
2694                  */
2695                 reg_off_ll = alloc_reg();
2696         }
2697
2698         /*
2699          * Load the register containing the AVS length
2700          * into the X register.
2701          */
2702         s = new_stmt(BPF_LDX|BPF_MEM);
2703         s->s.k = reg_off_ll;
2704         return s;
2705 }
2706
2707 static struct slist *
2708 gen_radiotap_llprefixlen(void)
2709 {
2710         struct slist *s;
2711
2712         if (reg_off_ll == -1) {
2713                 /*
2714                  * We haven't yet assigned a register for the length
2715                  * of the radiotap header; allocate one.
2716                  */
2717                 reg_off_ll = alloc_reg();
2718         }
2719
2720         /*
2721          * Load the register containing the radiotap length
2722          * into the X register.
2723          */
2724         s = new_stmt(BPF_LDX|BPF_MEM);
2725         s->s.k = reg_off_ll;
2726         return s;
2727 }
2728
2729 /* 
2730  * At the moment we treat PPI as normal Radiotap encoded
2731  * packets. The difference is in the function that generates
2732  * the code at the beginning to compute the header length.
2733  * Since this code generator of PPI supports bare 802.11
2734  * encapsulation only (i.e. the encapsulated DLT should be
2735  * DLT_IEEE802_11) we generate code to check for this too.
2736  */
2737 static struct slist *
2738 gen_ppi_llprefixlen(void)
2739 {
2740         struct slist *s;
2741
2742         if (reg_off_ll == -1) {
2743                 /*
2744                  * We haven't yet assigned a register for the length
2745                  * of the radiotap header; allocate one.
2746                  */
2747                 reg_off_ll = alloc_reg();
2748         }
2749
2750         /*
2751          * Load the register containing the PPI length
2752          * into the X register.
2753          */
2754         s = new_stmt(BPF_LDX|BPF_MEM);
2755         s->s.k = reg_off_ll;
2756         return s;
2757 }
2758
2759 /*
2760  * Generate code to compute the link-layer header length, if necessary,
2761  * putting it into the X register, and to return either a pointer to a
2762  * "struct slist" for the list of statements in that code, or NULL if
2763  * no code is necessary.
2764  */
2765 static struct slist *
2766 gen_llprefixlen(void)
2767 {
2768         switch (linktype) {
2769
2770         case DLT_PRISM_HEADER:
2771                 return gen_prism_llprefixlen();
2772
2773         case DLT_IEEE802_11_RADIO_AVS:
2774                 return gen_avs_llprefixlen();
2775
2776         case DLT_IEEE802_11_RADIO:
2777                 return gen_radiotap_llprefixlen();
2778
2779         case DLT_PPI:
2780                 return gen_ppi_llprefixlen();
2781
2782         default:
2783                 return NULL;
2784         }
2785 }
2786
2787 /*
2788  * Generate code to load the register containing the offset of the
2789  * MAC-layer payload into the X register; if no register for that offset
2790  * has been allocated, allocate it first.
2791  */
2792 static struct slist *
2793 gen_off_macpl(void)
2794 {
2795         struct slist *s;
2796
2797         if (off_macpl_is_variable) {
2798                 if (reg_off_macpl == -1) {
2799                         /*
2800                          * We haven't yet assigned a register for the offset
2801                          * of the MAC-layer payload; allocate one.
2802                          */
2803                         reg_off_macpl = alloc_reg();
2804                 }
2805
2806                 /*
2807                  * Load the register containing the offset of the MAC-layer
2808                  * payload into the X register.
2809                  */
2810                 s = new_stmt(BPF_LDX|BPF_MEM);
2811                 s->s.k = reg_off_macpl;
2812                 return s;
2813         } else {
2814                 /*
2815                  * That offset isn't variable, so we don't need to
2816                  * generate any code.
2817                  */
2818                 return NULL;
2819         }
2820 }
2821
2822 /*
2823  * Map an Ethernet type to the equivalent PPP type.
2824  */
2825 static int
2826 ethertype_to_ppptype(proto)
2827         int proto;
2828 {
2829         switch (proto) {
2830
2831         case ETHERTYPE_IP:
2832                 proto = PPP_IP;
2833                 break;
2834
2835 #ifdef INET6
2836         case ETHERTYPE_IPV6:
2837                 proto = PPP_IPV6;
2838                 break;
2839 #endif
2840
2841         case ETHERTYPE_DN:
2842                 proto = PPP_DECNET;
2843                 break;
2844
2845         case ETHERTYPE_ATALK:
2846                 proto = PPP_APPLE;
2847                 break;
2848
2849         case ETHERTYPE_NS:
2850                 proto = PPP_NS;
2851                 break;
2852
2853         case LLCSAP_ISONS:
2854                 proto = PPP_OSI;
2855                 break;
2856
2857         case LLCSAP_8021D:
2858                 /*
2859                  * I'm assuming the "Bridging PDU"s that go
2860                  * over PPP are Spanning Tree Protocol
2861                  * Bridging PDUs.
2862                  */
2863                 proto = PPP_BRPDU;
2864                 break;
2865
2866         case LLCSAP_IPX:
2867                 proto = PPP_IPX;
2868                 break;
2869         }
2870         return (proto);
2871 }
2872
2873 /*
2874  * Generate code to match a particular packet type by matching the
2875  * link-layer type field or fields in the 802.2 LLC header.
2876  *
2877  * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
2878  * value, if <= ETHERMTU.
2879  */
2880 static struct block *
2881 gen_linktype(proto)
2882         register int proto;
2883 {
2884         struct block *b0, *b1, *b2;
2885
2886         /* are we checking MPLS-encapsulated packets? */
2887         if (label_stack_depth > 0) {
2888                 switch (proto) {
2889                 case ETHERTYPE_IP:
2890                 case PPP_IP:
2891                         /* FIXME add other L3 proto IDs */
2892                         return gen_mpls_linktype(Q_IP); 
2893
2894                 case ETHERTYPE_IPV6:
2895                 case PPP_IPV6:
2896                         /* FIXME add other L3 proto IDs */
2897                         return gen_mpls_linktype(Q_IPV6); 
2898
2899                 default:
2900                         bpf_error("unsupported protocol over mpls");
2901                         /* NOTREACHED */
2902                 }
2903         }
2904
2905         /*
2906          * Are we testing PPPoE packets?
2907          */
2908         if (is_pppoes) {
2909                 /*
2910                  * The PPPoE session header is part of the
2911                  * MAC-layer payload, so all references
2912                  * should be relative to the beginning of
2913                  * that payload.
2914                  */
2915
2916                 /*
2917                  * We use Ethernet protocol types inside libpcap;
2918                  * map them to the corresponding PPP protocol types.
2919                  */
2920                 proto = ethertype_to_ppptype(proto);
2921                 return gen_cmp(OR_MACPL, off_linktype, BPF_H, (bpf_int32)proto);
2922         }
2923
2924         switch (linktype) {
2925
2926         case DLT_EN10MB:
2927         case DLT_NETANALYZER:
2928         case DLT_NETANALYZER_TRANSPARENT:
2929                 return gen_ether_linktype(proto);
2930                 /*NOTREACHED*/
2931                 break;
2932
2933         case DLT_C_HDLC:
2934                 switch (proto) {
2935
2936                 case LLCSAP_ISONS:
2937                         proto = (proto << 8 | LLCSAP_ISONS);
2938                         /* fall through */
2939
2940                 default:
2941                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
2942                             (bpf_int32)proto);
2943                         /*NOTREACHED*/
2944                         break;
2945                 }
2946                 break;
2947
2948         case DLT_IEEE802_11:
2949         case DLT_PRISM_HEADER:
2950         case DLT_IEEE802_11_RADIO_AVS:
2951         case DLT_IEEE802_11_RADIO:
2952         case DLT_PPI:
2953                 /*
2954                  * Check that we have a data frame.
2955                  */
2956                 b0 = gen_check_802_11_data_frame();
2957
2958                 /*
2959                  * Now check for the specified link-layer type.
2960                  */
2961                 b1 = gen_llc_linktype(proto);
2962                 gen_and(b0, b1);
2963                 return b1;
2964                 /*NOTREACHED*/
2965                 break;
2966
2967         case DLT_FDDI:
2968                 /*
2969                  * XXX - check for asynchronous frames, as per RFC 1103.
2970                  */
2971                 return gen_llc_linktype(proto);
2972                 /*NOTREACHED*/
2973                 break;
2974
2975         case DLT_IEEE802:
2976                 /*
2977                  * XXX - check for LLC PDUs, as per IEEE 802.5.
2978                  */
2979                 return gen_llc_linktype(proto);
2980                 /*NOTREACHED*/
2981                 break;
2982
2983         case DLT_ATM_RFC1483:
2984         case DLT_ATM_CLIP:
2985         case DLT_IP_OVER_FC:
2986                 return gen_llc_linktype(proto);
2987                 /*NOTREACHED*/
2988                 break;
2989
2990         case DLT_SUNATM:
2991                 /*
2992                  * If "is_lane" is set, check for a LANE-encapsulated
2993                  * version of this protocol, otherwise check for an
2994                  * LLC-encapsulated version of this protocol.
2995                  *
2996                  * We assume LANE means Ethernet, not Token Ring.
2997                  */
2998                 if (is_lane) {
2999                         /*
3000                          * Check that the packet doesn't begin with an
3001                          * LE Control marker.  (We've already generated
3002                          * a test for LANE.)
3003                          */
3004                         b0 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
3005                             0xFF00);
3006                         gen_not(b0);
3007
3008                         /*
3009                          * Now generate an Ethernet test.
3010                          */
3011                         b1 = gen_ether_linktype(proto);
3012                         gen_and(b0, b1);
3013                         return b1;
3014                 } else {
3015                         /*
3016                          * Check for LLC encapsulation and then check the
3017                          * protocol.
3018                          */
3019                         b0 = gen_atmfield_code(A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
3020                         b1 = gen_llc_linktype(proto);
3021                         gen_and(b0, b1);
3022                         return b1;
3023                 }
3024                 /*NOTREACHED*/
3025                 break;
3026
3027         case DLT_LINUX_SLL:
3028                 return gen_linux_sll_linktype(proto);
3029                 /*NOTREACHED*/
3030                 break;
3031
3032         case DLT_SLIP:
3033         case DLT_SLIP_BSDOS:
3034         case DLT_RAW:
3035                 /*
3036                  * These types don't provide any type field; packets
3037                  * are always IPv4 or IPv6.
3038                  *
3039                  * XXX - for IPv4, check for a version number of 4, and,
3040                  * for IPv6, check for a version number of 6?
3041                  */
3042                 switch (proto) {
3043
3044                 case ETHERTYPE_IP:
3045                         /* Check for a version number of 4. */
3046                         return gen_mcmp(OR_LINK, 0, BPF_B, 0x40, 0xF0);
3047 #ifdef INET6
3048                 case ETHERTYPE_IPV6:
3049                         /* Check for a version number of 6. */
3050                         return gen_mcmp(OR_LINK, 0, BPF_B, 0x60, 0xF0);
3051 #endif
3052
3053                 default:
3054                         return gen_false();             /* always false */
3055                 }
3056                 /*NOTREACHED*/
3057                 break;
3058
3059         case DLT_IPV4:
3060                 /*
3061                  * Raw IPv4, so no type field.
3062                  */
3063                 if (proto == ETHERTYPE_IP)
3064                         return gen_true();              /* always true */
3065
3066                 /* Checking for something other than IPv4; always false */
3067                 return gen_false();
3068                 /*NOTREACHED*/
3069                 break;
3070
3071         case DLT_IPV6:
3072                 /*
3073                  * Raw IPv6, so no type field.
3074                  */
3075 #ifdef INET6
3076                 if (proto == ETHERTYPE_IPV6)
3077                         return gen_true();              /* always true */
3078 #endif
3079
3080                 /* Checking for something other than IPv6; always false */
3081                 return gen_false();
3082                 /*NOTREACHED*/
3083                 break;
3084
3085         case DLT_PPP:
3086         case DLT_PPP_PPPD:
3087         case DLT_PPP_SERIAL:
3088         case DLT_PPP_ETHER:
3089                 /*
3090                  * We use Ethernet protocol types inside libpcap;
3091                  * map them to the corresponding PPP protocol types.
3092                  */
3093                 proto = ethertype_to_ppptype(proto);
3094                 return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
3095                 /*NOTREACHED*/
3096                 break;
3097
3098         case DLT_PPP_BSDOS:
3099                 /*
3100                  * We use Ethernet protocol types inside libpcap;
3101                  * map them to the corresponding PPP protocol types.
3102                  */
3103                 switch (proto) {
3104
3105                 case ETHERTYPE_IP:
3106                         /*
3107                          * Also check for Van Jacobson-compressed IP.
3108                          * XXX - do this for other forms of PPP?
3109                          */
3110                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_IP);
3111                         b1 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJC);
3112                         gen_or(b0, b1);
3113                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJNC);
3114                         gen_or(b1, b0);
3115                         return b0;
3116
3117                 default:
3118                         proto = ethertype_to_ppptype(proto);
3119                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
3120                                 (bpf_int32)proto);
3121                 }
3122                 /*NOTREACHED*/
3123                 break;
3124
3125         case DLT_NULL:
3126         case DLT_LOOP:
3127         case DLT_ENC:
3128                 /*
3129                  * For DLT_NULL, the link-layer header is a 32-bit
3130                  * word containing an AF_ value in *host* byte order,
3131                  * and for DLT_ENC, the link-layer header begins
3132                  * with a 32-bit work containing an AF_ value in
3133                  * host byte order.
3134                  *
3135                  * In addition, if we're reading a saved capture file,
3136                  * the host byte order in the capture may not be the
3137                  * same as the host byte order on this machine.
3138                  *
3139                  * For DLT_LOOP, the link-layer header is a 32-bit
3140                  * word containing an AF_ value in *network* byte order.
3141                  *
3142                  * XXX - AF_ values may, unfortunately, be platform-
3143                  * dependent; for example, FreeBSD's AF_INET6 is 24
3144                  * whilst NetBSD's and OpenBSD's is 26.
3145                  *
3146                  * This means that, when reading a capture file, just
3147                  * checking for our AF_INET6 value won't work if the
3148                  * capture file came from another OS.
3149                  */
3150                 switch (proto) {
3151
3152                 case ETHERTYPE_IP:
3153                         proto = AF_INET;
3154                         break;
3155
3156 #ifdef INET6
3157                 case ETHERTYPE_IPV6:
3158                         proto = AF_INET6;
3159                         break;
3160 #endif
3161
3162                 default:
3163                         /*
3164                          * Not a type on which we support filtering.
3165                          * XXX - support those that have AF_ values
3166                          * #defined on this platform, at least?
3167                          */
3168                         return gen_false();
3169                 }
3170
3171                 if (linktype == DLT_NULL || linktype == DLT_ENC) {
3172                         /*
3173                          * The AF_ value is in host byte order, but
3174                          * the BPF interpreter will convert it to
3175                          * network byte order.
3176                          *
3177                          * If this is a save file, and it's from a
3178                          * machine with the opposite byte order to
3179                          * ours, we byte-swap the AF_ value.
3180                          *
3181                          * Then we run it through "htonl()", and
3182                          * generate code to compare against the result.
3183                          */
3184                         if (bpf_pcap->sf.rfile != NULL &&
3185                             bpf_pcap->sf.swapped)
3186                                 proto = SWAPLONG(proto);
3187                         proto = htonl(proto);
3188                 }
3189                 return (gen_cmp(OR_LINK, 0, BPF_W, (bpf_int32)proto));
3190
3191 #ifdef HAVE_NET_PFVAR_H
3192         case DLT_PFLOG:
3193                 /*
3194                  * af field is host byte order in contrast to the rest of
3195                  * the packet.
3196                  */
3197                 if (proto == ETHERTYPE_IP)
3198                         return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
3199                             BPF_B, (bpf_int32)AF_INET));
3200 #ifdef INET6
3201                 else if (proto == ETHERTYPE_IPV6)
3202                         return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
3203                             BPF_B, (bpf_int32)AF_INET6));
3204 #endif /* INET6 */
3205                 else
3206                         return gen_false();
3207                 /*NOTREACHED*/
3208                 break;
3209 #endif /* HAVE_NET_PFVAR_H */
3210
3211         case DLT_ARCNET:
3212         case DLT_ARCNET_LINUX:
3213                 /*
3214                  * XXX should we check for first fragment if the protocol
3215                  * uses PHDS?
3216                  */
3217                 switch (proto) {
3218
3219                 default:
3220                         return gen_false();
3221
3222 #ifdef INET6
3223                 case ETHERTYPE_IPV6:
3224                         return (gen_cmp(OR_LINK, off_linktype, BPF_B,
3225                                 (bpf_int32)ARCTYPE_INET6));
3226 #endif /* INET6 */
3227
3228                 case ETHERTYPE_IP:
3229                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3230                                      (bpf_int32)ARCTYPE_IP);
3231                         b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3232                                      (bpf_int32)ARCTYPE_IP_OLD);
3233                         gen_or(b0, b1);
3234                         return (b1);
3235
3236                 case ETHERTYPE_ARP:
3237                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3238                                      (bpf_int32)ARCTYPE_ARP);
3239                         b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3240                                      (bpf_int32)ARCTYPE_ARP_OLD);
3241                         gen_or(b0, b1);
3242                         return (b1);
3243
3244                 case ETHERTYPE_REVARP:
3245                         return (gen_cmp(OR_LINK, off_linktype, BPF_B,
3246                                         (bpf_int32)ARCTYPE_REVARP));
3247
3248                 case ETHERTYPE_ATALK:
3249                         return (gen_cmp(OR_LINK, off_linktype, BPF_B,
3250                                         (bpf_int32)ARCTYPE_ATALK));
3251                 }
3252                 /*NOTREACHED*/
3253                 break;
3254
3255         case DLT_LTALK:
3256                 switch (proto) {
3257                 case ETHERTYPE_ATALK:
3258                         return gen_true();
3259                 default:
3260                         return gen_false();
3261                 }
3262                 /*NOTREACHED*/
3263                 break;
3264
3265         case DLT_FRELAY:
3266                 /*
3267                  * XXX - assumes a 2-byte Frame Relay header with
3268                  * DLCI and flags.  What if the address is longer?
3269                  */
3270                 switch (proto) {
3271
3272                 case ETHERTYPE_IP:
3273                         /*
3274                          * Check for the special NLPID for IP.
3275                          */
3276                         return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0xcc);
3277
3278 #ifdef INET6
3279                 case ETHERTYPE_IPV6:
3280                         /*
3281                          * Check for the special NLPID for IPv6.
3282                          */
3283                         return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0x8e);
3284 #endif
3285
3286                 case LLCSAP_ISONS:
3287                         /*
3288                          * Check for several OSI protocols.
3289                          *
3290                          * Frame Relay packets typically have an OSI
3291                          * NLPID at the beginning; we check for each
3292                          * of them.
3293                          *
3294                          * What we check for is the NLPID and a frame
3295                          * control field of UI, i.e. 0x03 followed
3296                          * by the NLPID.
3297                          */
3298                         b0 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
3299                         b1 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
3300                         b2 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);
3301                         gen_or(b1, b2);
3302                         gen_or(b0, b2);
3303                         return b2;
3304
3305                 default:
3306                         return gen_false();
3307                 }
3308                 /*NOTREACHED*/
3309                 break;
3310
3311         case DLT_MFR:
3312                 bpf_error("Multi-link Frame Relay link-layer type filtering not implemented");
3313
3314         case DLT_JUNIPER_MFR:
3315         case DLT_JUNIPER_MLFR:
3316         case DLT_JUNIPER_MLPPP:
3317         case DLT_JUNIPER_ATM1:
3318         case DLT_JUNIPER_ATM2:
3319         case DLT_JUNIPER_PPPOE:
3320         case DLT_JUNIPER_PPPOE_ATM:
3321         case DLT_JUNIPER_GGSN:
3322         case DLT_JUNIPER_ES:
3323         case DLT_JUNIPER_MONITOR:
3324         case DLT_JUNIPER_SERVICES:
3325         case DLT_JUNIPER_ETHER:
3326         case DLT_JUNIPER_PPP:
3327         case DLT_JUNIPER_FRELAY:
3328         case DLT_JUNIPER_CHDLC:
3329         case DLT_JUNIPER_VP:
3330         case DLT_JUNIPER_ST:
3331         case DLT_JUNIPER_ISM:
3332         case DLT_JUNIPER_VS:
3333         case DLT_JUNIPER_SRX_E2E:
3334         case DLT_JUNIPER_FIBRECHANNEL:
3335         case DLT_JUNIPER_ATM_CEMIC:
3336
3337                 /* just lets verify the magic number for now -
3338                  * on ATM we may have up to 6 different encapsulations on the wire
3339                  * and need a lot of heuristics to figure out that the payload
3340                  * might be;
3341                  *
3342                  * FIXME encapsulation specific BPF_ filters
3343                  */
3344                 return gen_mcmp(OR_LINK, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
3345
3346         case DLT_IPNET:
3347                 return gen_ipnet_linktype(proto);
3348
3349         case DLT_LINUX_IRDA:
3350                 bpf_error("IrDA link-layer type filtering not implemented");
3351
3352         case DLT_DOCSIS:
3353                 bpf_error("DOCSIS link-layer type filtering not implemented");
3354
3355         case DLT_MTP2:
3356         case DLT_MTP2_WITH_PHDR:
3357                 bpf_error("MTP2 link-layer type filtering not implemented");
3358
3359         case DLT_ERF:
3360                 bpf_error("ERF link-layer type filtering not implemented");
3361
3362 #ifdef DLT_PFSYNC
3363         case DLT_PFSYNC:
3364                 bpf_error("PFSYNC link-layer type filtering not implemented");
3365 #endif
3366
3367         case DLT_LINUX_LAPD:
3368                 bpf_error("LAPD link-layer type filtering not implemented");
3369
3370         case DLT_USB:
3371         case DLT_USB_LINUX:
3372         case DLT_USB_LINUX_MMAPPED:
3373                 bpf_error("USB link-layer type filtering not implemented");
3374
3375         case DLT_BLUETOOTH_HCI_H4:
3376         case DLT_BLUETOOTH_HCI_H4_WITH_PHDR:
3377                 bpf_error("Bluetooth link-layer type filtering not implemented");
3378
3379         case DLT_CAN20B:
3380         case DLT_CAN_SOCKETCAN:
3381                 bpf_error("CAN link-layer type filtering not implemented");
3382
3383         case DLT_IEEE802_15_4:
3384         case DLT_IEEE802_15_4_LINUX:
3385         case DLT_IEEE802_15_4_NONASK_PHY:
3386         case DLT_IEEE802_15_4_NOFCS:
3387                 bpf_error("IEEE 802.15.4 link-layer type filtering not implemented");
3388
3389         case DLT_IEEE802_16_MAC_CPS_RADIO:
3390                 bpf_error("IEEE 802.16 link-layer type filtering not implemented");
3391
3392         case DLT_SITA:
3393                 bpf_error("SITA link-layer type filtering not implemented");
3394
3395         case DLT_RAIF1:
3396                 bpf_error("RAIF1 link-layer type filtering not implemented");
3397
3398         case DLT_IPMB:
3399                 bpf_error("IPMB link-layer type filtering not implemented");
3400
3401         case DLT_AX25_KISS:
3402                 bpf_error("AX.25 link-layer type filtering not implemented");
3403         }
3404
3405         /*
3406          * All the types that have no encapsulation should either be
3407          * handled as DLT_SLIP, DLT_SLIP_BSDOS, and DLT_RAW are, if
3408          * all packets are IP packets, or should be handled in some
3409          * special case, if none of them are (if some are and some
3410          * aren't, the lack of encapsulation is a problem, as we'd
3411          * have to find some other way of determining the packet type).
3412          *
3413          * Therefore, if "off_linktype" is -1, there's an error.
3414          */
3415         if (off_linktype == (u_int)-1)
3416                 abort();
3417
3418         /*
3419          * Any type not handled above should always have an Ethernet
3420          * type at an offset of "off_linktype".
3421          */
3422         return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
3423 }
3424
3425 /*
3426  * Check for an LLC SNAP packet with a given organization code and
3427  * protocol type; we check the entire contents of the 802.2 LLC and
3428  * snap headers, checking for DSAP and SSAP of SNAP and a control
3429  * field of 0x03 in the LLC header, and for the specified organization
3430  * code and protocol type in the SNAP header.
3431  */
3432 static struct block *
3433 gen_snap(orgcode, ptype)
3434         bpf_u_int32 orgcode;
3435         bpf_u_int32 ptype;
3436 {
3437         u_char snapblock[8];
3438
3439         snapblock[0] = LLCSAP_SNAP;     /* DSAP = SNAP */
3440         snapblock[1] = LLCSAP_SNAP;     /* SSAP = SNAP */
3441         snapblock[2] = 0x03;            /* control = UI */
3442         snapblock[3] = (orgcode >> 16); /* upper 8 bits of organization code */
3443         snapblock[4] = (orgcode >> 8);  /* middle 8 bits of organization code */
3444         snapblock[5] = (orgcode >> 0);  /* lower 8 bits of organization code */
3445         snapblock[6] = (ptype >> 8);    /* upper 8 bits of protocol type */
3446         snapblock[7] = (ptype >> 0);    /* lower 8 bits of protocol type */
3447         return gen_bcmp(OR_MACPL, 0, 8, snapblock);
3448 }
3449
3450 /*
3451  * Generate code to match a particular packet type, for link-layer types
3452  * using 802.2 LLC headers.
3453  *
3454  * This is *NOT* used for Ethernet; "gen_ether_linktype()" is used
3455  * for that - it handles the D/I/X Ethernet vs. 802.3+802.2 issues.
3456  *
3457  * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
3458  * value, if <= ETHERMTU.  We use that to determine whether to
3459  * match the DSAP or both DSAP and LSAP or to check the OUI and
3460  * protocol ID in a SNAP header.
3461  */
3462 static struct block *
3463 gen_llc_linktype(proto)
3464         int proto;
3465 {
3466         /*
3467          * XXX - handle token-ring variable-length header.
3468          */
3469         switch (proto) {
3470
3471         case LLCSAP_IP:
3472         case LLCSAP_ISONS:
3473         case LLCSAP_NETBEUI:
3474                 /*
3475                  * XXX - should we check both the DSAP and the
3476                  * SSAP, like this, or should we check just the
3477                  * DSAP, as we do for other types <= ETHERMTU
3478                  * (i.e., other SAP values)?
3479                  */
3480                 return gen_cmp(OR_MACPL, 0, BPF_H, (bpf_u_int32)
3481                              ((proto << 8) | proto));
3482
3483         case LLCSAP_IPX:
3484                 /*
3485                  * XXX - are there ever SNAP frames for IPX on
3486                  * non-Ethernet 802.x networks?
3487                  */
3488                 return gen_cmp(OR_MACPL, 0, BPF_B,
3489                     (bpf_int32)LLCSAP_IPX);
3490
3491         case ETHERTYPE_ATALK:
3492                 /*
3493                  * 802.2-encapsulated ETHERTYPE_ATALK packets are
3494                  * SNAP packets with an organization code of
3495                  * 0x080007 (Apple, for Appletalk) and a protocol
3496                  * type of ETHERTYPE_ATALK (Appletalk).
3497                  *
3498                  * XXX - check for an organization code of
3499                  * encapsulated Ethernet as well?
3500                  */
3501                 return gen_snap(0x080007, ETHERTYPE_ATALK);
3502
3503         default:
3504                 /*
3505                  * XXX - we don't have to check for IPX 802.3
3506                  * here, but should we check for the IPX Ethertype?
3507                  */
3508                 if (proto <= ETHERMTU) {
3509                         /*
3510                          * This is an LLC SAP value, so check
3511                          * the DSAP.
3512                          */
3513                         return gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)proto);
3514                 } else {
3515                         /*
3516                          * This is an Ethernet type; we assume that it's
3517                          * unlikely that it'll appear in the right place
3518                          * at random, and therefore check only the
3519                          * location that would hold the Ethernet type
3520                          * in a SNAP frame with an organization code of
3521                          * 0x000000 (encapsulated Ethernet).
3522                          *
3523                          * XXX - if we were to check for the SNAP DSAP and
3524                          * LSAP, as per XXX, and were also to check for an
3525                          * organization code of 0x000000 (encapsulated
3526                          * Ethernet), we'd do
3527                          *
3528                          *      return gen_snap(0x000000, proto);
3529                          *
3530                          * here; for now, we don't, as per the above.
3531                          * I don't know whether it's worth the extra CPU
3532                          * time to do the right check or not.
3533                          */
3534                         return gen_cmp(OR_MACPL, 6, BPF_H, (bpf_int32)proto);
3535                 }
3536         }
3537 }
3538
3539 static struct block *
3540 gen_hostop(addr, mask, dir, proto, src_off, dst_off)
3541         bpf_u_int32 addr;
3542         bpf_u_int32 mask;
3543         int dir, proto;
3544         u_int src_off, dst_off;
3545 {
3546         struct block *b0, *b1;
3547         u_int offset;
3548
3549         switch (dir) {
3550
3551         case Q_SRC:
3552                 offset = src_off;
3553                 break;
3554
3555         case Q_DST:
3556                 offset = dst_off;
3557                 break;
3558
3559         case Q_AND:
3560                 b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
3561                 b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
3562                 gen_and(b0, b1);
3563                 return b1;
3564
3565         case Q_OR:
3566         case Q_DEFAULT:
3567                 b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
3568                 b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
3569                 gen_or(b0, b1);
3570                 return b1;
3571
3572         default:
3573                 abort();
3574         }
3575         b0 = gen_linktype(proto);
3576         b1 = gen_mcmp(OR_NET, offset, BPF_W, (bpf_int32)addr, mask);
3577         gen_and(b0, b1);
3578         return b1;
3579 }
3580
3581 #ifdef INET6
3582 static struct block *
3583 gen_hostop6(addr, mask, dir, proto, src_off, dst_off)
3584         struct in6_addr *addr;
3585         struct in6_addr *mask;
3586         int dir, proto;
3587         u_int src_off, dst_off;
3588 {
3589         struct block *b0, *b1;
3590         u_int offset;
3591         u_int32_t *a, *m;
3592
3593         switch (dir) {
3594
3595         case Q_SRC:
3596                 offset = src_off;
3597                 break;
3598
3599         case Q_DST:
3600                 offset = dst_off;
3601                 break;
3602
3603         case Q_AND:
3604                 b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
3605                 b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
3606                 gen_and(b0, b1);
3607                 return b1;
3608
3609         case Q_OR:
3610         case Q_DEFAULT:
3611                 b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
3612                 b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
3613                 gen_or(b0, b1);
3614                 return b1;
3615
3616         default:
3617                 abort();
3618         }
3619         /* this order is important */
3620         a = (u_int32_t *)addr;
3621         m = (u_int32_t *)mask;
3622         b1 = gen_mcmp(OR_NET, offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
3623         b0 = gen_mcmp(OR_NET, offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
3624         gen_and(b0, b1);
3625         b0 = gen_mcmp(OR_NET, offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
3626         gen_and(b0, b1);
3627         b0 = gen_mcmp(OR_NET, offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
3628         gen_and(b0, b1);
3629         b0 = gen_linktype(proto);
3630         gen_and(b0, b1);
3631         return b1;
3632 }
3633 #endif /*INET6*/
3634
3635 static struct block *
3636 gen_ehostop(eaddr, dir)
3637         register const u_char *eaddr;
3638         register int dir;
3639 {
3640         register struct block *b0, *b1;
3641
3642         switch (dir) {
3643         case Q_SRC:
3644                 return gen_bcmp(OR_LINK, off_mac + 6, 6, eaddr);
3645
3646         case Q_DST:
3647                 return gen_bcmp(OR_LINK, off_mac + 0, 6, eaddr);
3648
3649         case Q_AND:
3650                 b0 = gen_ehostop(eaddr, Q_SRC);
3651                 b1 = gen_ehostop(eaddr, Q_DST);
3652                 gen_and(b0, b1);
3653                 return b1;
3654
3655         case Q_DEFAULT:
3656         case Q_OR:
3657                 b0 = gen_ehostop(eaddr, Q_SRC);
3658                 b1 = gen_ehostop(eaddr, Q_DST);
3659                 gen_or(b0, b1);
3660                 return b1;
3661
3662         case Q_ADDR1:
3663                 bpf_error("'addr1' is only supported on 802.11 with 802.11 headers");
3664                 break;
3665
3666         case Q_ADDR2:
3667                 bpf_error("'addr2' is only supported on 802.11 with 802.11 headers");
3668                 break;
3669
3670         case Q_ADDR3:
3671                 bpf_error("'addr3' is only supported on 802.11 with 802.11 headers");
3672                 break;
3673
3674         case Q_ADDR4:
3675                 bpf_error("'addr4' is only supported on 802.11 with 802.11 headers");
3676                 break;
3677
3678         case Q_RA:
3679                 bpf_error("'ra' is only supported on 802.11 with 802.11 headers");
3680                 break;
3681
3682         case Q_TA:
3683                 bpf_error("'ta' is only supported on 802.11 with 802.11 headers");
3684                 break;
3685         }
3686         abort();
3687         /* NOTREACHED */
3688 }
3689
3690 /*
3691  * Like gen_ehostop, but for DLT_FDDI
3692  */
3693 static struct block *
3694 gen_fhostop(eaddr, dir)
3695         register const u_char *eaddr;
3696         register int dir;
3697 {
3698         struct block *b0, *b1;
3699
3700         switch (dir) {
3701         case Q_SRC:
3702 #ifdef PCAP_FDDIPAD
3703                 return gen_bcmp(OR_LINK, 6 + 1 + pcap_fddipad, 6, eaddr);
3704 #else
3705                 return gen_bcmp(OR_LINK, 6 + 1, 6, eaddr);
3706 #endif
3707
3708         case Q_DST:
3709 #ifdef PCAP_FDDIPAD
3710                 return gen_bcmp(OR_LINK, 0 + 1 + pcap_fddipad, 6, eaddr);
3711 #else
3712                 return gen_bcmp(OR_LINK, 0 + 1, 6, eaddr);
3713 #endif
3714
3715         case Q_AND:
3716                 b0 = gen_fhostop(eaddr, Q_SRC);
3717                 b1 = gen_fhostop(eaddr, Q_DST);
3718                 gen_and(b0, b1);
3719                 return b1;
3720
3721         case Q_DEFAULT:
3722         case Q_OR:
3723                 b0 = gen_fhostop(eaddr, Q_SRC);
3724                 b1 = gen_fhostop(eaddr, Q_DST);
3725                 gen_or(b0, b1);
3726                 return b1;
3727
3728         case Q_ADDR1:
3729                 bpf_error("'addr1' is only supported on 802.11");
3730                 break;
3731
3732         case Q_ADDR2:
3733                 bpf_error("'addr2' is only supported on 802.11");
3734                 break;
3735
3736         case Q_ADDR3:
3737                 bpf_error("'addr3' is only supported on 802.11");
3738                 break;
3739
3740         case Q_ADDR4:
3741                 bpf_error("'addr4' is only supported on 802.11");
3742                 break;
3743
3744         case Q_RA:
3745                 bpf_error("'ra' is only supported on 802.11");
3746                 break;
3747
3748         case Q_TA:
3749                 bpf_error("'ta' is only supported on 802.11");
3750                 break;
3751         }
3752         abort();
3753         /* NOTREACHED */
3754 }
3755
3756 /*
3757  * Like gen_ehostop, but for DLT_IEEE802 (Token Ring)
3758  */
3759 static struct block *
3760 gen_thostop(eaddr, dir)
3761         register const u_char *eaddr;
3762         register int dir;
3763 {
3764         register struct block *b0, *b1;
3765
3766         switch (dir) {
3767         case Q_SRC:
3768                 return gen_bcmp(OR_LINK, 8, 6, eaddr);
3769
3770         case Q_DST:
3771                 return gen_bcmp(OR_LINK, 2, 6, eaddr);
3772
3773         case Q_AND:
3774                 b0 = gen_thostop(eaddr, Q_SRC);
3775                 b1 = gen_thostop(eaddr, Q_DST);
3776                 gen_and(b0, b1);
3777                 return b1;
3778
3779         case Q_DEFAULT:
3780         case Q_OR:
3781                 b0 = gen_thostop(eaddr, Q_SRC);
3782                 b1 = gen_thostop(eaddr, Q_DST);
3783                 gen_or(b0, b1);
3784                 return b1;
3785
3786         case Q_ADDR1:
3787                 bpf_error("'addr1' is only supported on 802.11");
3788                 break;
3789
3790         case Q_ADDR2:
3791                 bpf_error("'addr2' is only supported on 802.11");
3792                 break;
3793
3794         case Q_ADDR3:
3795                 bpf_error("'addr3' is only supported on 802.11");
3796                 break;
3797
3798         case Q_ADDR4:
3799                 bpf_error("'addr4' is only supported on 802.11");
3800                 break;
3801
3802         case Q_RA:
3803                 bpf_error("'ra' is only supported on 802.11");
3804                 break;
3805
3806         case Q_TA:
3807                 bpf_error("'ta' is only supported on 802.11");
3808                 break;
3809         }
3810         abort();
3811         /* NOTREACHED */
3812 }
3813
3814 /*
3815  * Like gen_ehostop, but for DLT_IEEE802_11 (802.11 wireless LAN) and
3816  * various 802.11 + radio headers.
3817  */
3818 static struct block *
3819 gen_wlanhostop(eaddr, dir)
3820         register const u_char *eaddr;
3821         register int dir;
3822 {
3823         register struct block *b0, *b1, *b2;
3824         register struct slist *s;
3825
3826 #ifdef ENABLE_WLAN_FILTERING_PATCH
3827         /*
3828          * TODO GV 20070613
3829          * We need to disable the optimizer because the optimizer is buggy
3830          * and wipes out some LD instructions generated by the below
3831          * code to validate the Frame Control bits
3832          */
3833         no_optimize = 1;
3834 #endif /* ENABLE_WLAN_FILTERING_PATCH */
3835
3836         switch (dir) {
3837         case Q_SRC:
3838                 /*
3839                  * Oh, yuk.
3840                  *
3841                  *      For control frames, there is no SA.
3842                  *
3843                  *      For management frames, SA is at an
3844                  *      offset of 10 from the beginning of
3845                  *      the packet.
3846                  *
3847                  *      For data frames, SA is at an offset
3848                  *      of 10 from the beginning of the packet
3849                  *      if From DS is clear, at an offset of
3850                  *      16 from the beginning of the packet
3851                  *      if From DS is set and To DS is clear,
3852                  *      and an offset of 24 from the beginning
3853                  *      of the packet if From DS is set and To DS
3854                  *      is set.
3855                  */
3856
3857                 /*
3858                  * Generate the tests to be done for data frames
3859                  * with From DS set.
3860                  *
3861                  * First, check for To DS set, i.e. check "link[1] & 0x01".
3862                  */
3863                 s = gen_load_a(OR_LINK, 1, BPF_B);
3864                 b1 = new_block(JMP(BPF_JSET));
3865                 b1->s.k = 0x01; /* To DS */
3866                 b1->stmts = s;
3867
3868                 /*
3869                  * If To DS is set, the SA is at 24.
3870                  */
3871                 b0 = gen_bcmp(OR_LINK, 24, 6, eaddr);
3872                 gen_and(b1, b0);
3873
3874                 /*
3875                  * Now, check for To DS not set, i.e. check
3876                  * "!(link[1] & 0x01)".
3877                  */
3878                 s = gen_load_a(OR_LINK, 1, BPF_B);
3879                 b2 = new_block(JMP(BPF_JSET));
3880                 b2->s.k = 0x01; /* To DS */
3881                 b2->stmts = s;
3882                 gen_not(b2);
3883
3884                 /*
3885                  * If To DS is not set, the SA is at 16.
3886                  */
3887                 b1 = gen_bcmp(OR_LINK, 16, 6, eaddr);
3888                 gen_and(b2, b1);
3889
3890                 /*
3891                  * Now OR together the last two checks.  That gives
3892                  * the complete set of checks for data frames with
3893                  * From DS set.
3894                  */
3895                 gen_or(b1, b0);
3896
3897                 /*
3898                  * Now check for From DS being set, and AND that with
3899                  * the ORed-together checks.
3900                  */
3901                 s = gen_load_a(OR_LINK, 1, BPF_B);
3902                 b1 = new_block(JMP(BPF_JSET));
3903                 b1->s.k = 0x02; /* From DS */
3904                 b1->stmts = s;
3905                 gen_and(b1, b0);
3906
3907                 /*
3908                  * Now check for data frames with From DS not set.
3909                  */
3910                 s = gen_load_a(OR_LINK, 1, BPF_B);
3911                 b2 = new_block(JMP(BPF_JSET));
3912                 b2->s.k = 0x02; /* From DS */
3913                 b2->stmts = s;
3914                 gen_not(b2);
3915
3916                 /*
3917                  * If From DS isn't set, the SA is at 10.
3918                  */
3919                 b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
3920                 gen_and(b2, b1);
3921
3922                 /*
3923                  * Now OR together the checks for data frames with
3924                  * From DS not set and for data frames with From DS
3925                  * set; that gives the checks done for data frames.
3926                  */
3927                 gen_or(b1, b0);
3928
3929                 /*
3930                  * Now check for a data frame.
3931                  * I.e, check "link[0] & 0x08".
3932                  */
3933                 s = gen_load_a(OR_LINK, 0, BPF_B);
3934                 b1 = new_block(JMP(BPF_JSET));
3935                 b1->s.k = 0x08;
3936                 b1->stmts = s;
3937
3938                 /*
3939                  * AND that with the checks done for data frames.
3940                  */
3941                 gen_and(b1, b0);
3942
3943                 /*
3944                  * If the high-order bit of the type value is 0, this
3945                  * is a management frame.
3946                  * I.e, check "!(link[0] & 0x08)".
3947                  */
3948                 s = gen_load_a(OR_LINK, 0, BPF_B);
3949                 b2 = new_block(JMP(BPF_JSET));
3950                 b2->s.k = 0x08;
3951                 b2->stmts = s;
3952                 gen_not(b2);
3953
3954                 /*
3955                  * For management frames, the SA is at 10.
3956                  */
3957                 b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
3958                 gen_and(b2, b1);
3959
3960                 /*
3961                  * OR that with the checks done for data frames.
3962                  * That gives the checks done for management and
3963                  * data frames.
3964                  */
3965                 gen_or(b1, b0);
3966
3967                 /*
3968                  * If the low-order bit of the type value is 1,
3969                  * this is either a control frame or a frame
3970                  * with a reserved type, and thus not a
3971                  * frame with an SA.
3972                  *
3973                  * I.e., check "!(link[0] & 0x04)".
3974                  */
3975                 s = gen_load_a(OR_LINK, 0, BPF_B);
3976                 b1 = new_block(JMP(BPF_JSET));
3977                 b1->s.k = 0x04;
3978                 b1->stmts = s;
3979                 gen_not(b1);
3980
3981                 /*
3982                  * AND that with the checks for data and management
3983                  * frames.
3984                  */
3985                 gen_and(b1, b0);
3986                 return b0;
3987
3988         case Q_DST:
3989                 /*
3990                  * Oh, yuk.
3991                  *
3992                  *      For control frames, there is no DA.
3993                  *
3994                  *      For management frames, DA is at an
3995                  *      offset of 4 from the beginning of
3996                  *      the packet.
3997                  *
3998                  *      For data frames, DA is at an offset
3999                  *      of 4 from the beginning of the packet
4000                  *      if To DS is clear and at an offset of
4001                  *      16 from the beginning of the packet
4002                  *      if To DS is set.
4003                  */
4004
4005                 /*
4006                  * Generate the tests to be done for data frames.
4007                  *
4008                  * First, check for To DS set, i.e. "link[1] & 0x01".
4009                  */
4010                 s = gen_load_a(OR_LINK, 1, BPF_B);
4011                 b1 = new_block(JMP(BPF_JSET));
4012                 b1->s.k = 0x01; /* To DS */
4013                 b1->stmts = s;
4014
4015                 /*
4016                  * If To DS is set, the DA is at 16.