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