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