source: rtems-libbsd/freebsd/contrib/libpcap/gencode.c @ 8440506

4.115-freebsd-12freebsd-9.3
Last change on this file since 8440506 was 8440506, checked in by Chris Johns <chrisj@…>, on Jun 15, 2015 at 7:42:23 AM

Add tcpdump and libpcap.

  • Update the file builder generator to handle generator specific cflags and includes. The tcpdump and libpcap have localised headers and need specific headers paths to see them. There are also module specific flags and these need to be passed to the lex and yacc generators.
  • Add the tcpdump support.
  • Property mode set to 100644
File size: 195.3 KB
Line 
1#include <machine/rtems-bsd-user-space.h>
2
3/*#define CHASE_CHAIN*/
4/*
5 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
6 *      The Regents of the University of California.  All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that: (1) source code distributions
10 * retain the above copyright notice and this paragraph in its entirety, (2)
11 * distributions including binary code include the above copyright notice and
12 * this paragraph in its entirety in the documentation or other materials
13 * provided with the distribution, and (3) all advertising materials mentioning
14 * features or use of this software display the following acknowledgement:
15 * ``This product includes software developed by the University of California,
16 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
17 * the University nor the names of its contributors may be used to endorse
18 * or promote products derived from this software without specific prior
19 * written permission.
20 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
21 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
22 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
23 *
24 * $FreeBSD$
25 */
26#ifndef lint
27static const char rcsid[] _U_ =
28    "@(#) $Header: /tcpdump/master/libpcap/gencode.c,v 1.309 2008-12-23 20:13:29 guy Exp $ (LBL)";
29#endif
30
31#ifdef HAVE_CONFIG_H
32#include "config.h"
33#endif
34
35#ifdef WIN32
36#include <pcap-stdinc.h>
37#else /* WIN32 */
38#if HAVE_INTTYPES_H
39#include <inttypes.h>
40#elif HAVE_STDINT_H
41#include <stdint.h>
42#endif
43#ifdef HAVE_SYS_BITYPES_H
44#include <sys/bitypes.h>
45#endif
46#include <rtems/bsd/sys/types.h>
47#include <sys/socket.h>
48#endif /* WIN32 */
49
50/*
51 * XXX - why was this included even on UNIX?
52 */
53#ifdef __MINGW32__
54#include "ip6_misc.h"
55#endif
56
57#ifndef WIN32
58
59#ifdef __NetBSD__
60#include <rtems/bsd/sys/param.h>
61#endif
62
63#include <netinet/in.h>
64#include <arpa/inet.h>
65
66#endif /* WIN32 */
67
68#include <stdlib.h>
69#include <string.h>
70#include <memory.h>
71#include <setjmp.h>
72#include <stdarg.h>
73
74#ifdef MSDOS
75#include "pcap-dos.h"
76#endif
77
78#include "pcap-int.h"
79
80#include "ethertype.h"
81#include "nlpid.h"
82#include "llc.h"
83#include "gencode.h"
84#include "ieee80211.h"
85#include "atmuni31.h"
86#include "sunatmpos.h"
87#include "ppp.h"
88#include "pcap/sll.h"
89#include "pcap/ipnet.h"
90#include "arcnet.h"
91#if defined(PF_PACKET) && defined(SO_ATTACH_FILTER)
92#include <linux/types.h>
93#include <linux/if_packet.h>
94#include <linux/filter.h>
95#endif
96#ifdef HAVE_NET_PFVAR_H
97#include <sys/socket.h>
98#include <net/if.h>
99#include <net/pfvar.h>
100#include <net/if_pflog.h>
101#endif
102#ifndef offsetof
103#define offsetof(s, e) ((size_t)&((s *)0)->e)
104#endif
105#ifdef INET6
106#ifndef WIN32
107#include <netdb.h>      /* for "struct addrinfo" */
108#endif /* WIN32 */
109#endif /*INET6*/
110#include <pcap/namedb.h>
111
112#define ETHERMTU        1500
113
114#ifndef IPPROTO_HOPOPTS
115#define IPPROTO_HOPOPTS 0
116#endif
117#ifndef IPPROTO_ROUTING
118#define IPPROTO_ROUTING 43
119#endif
120#ifndef IPPROTO_FRAGMENT
121#define IPPROTO_FRAGMENT 44
122#endif
123#ifndef IPPROTO_DSTOPTS
124#define IPPROTO_DSTOPTS 60
125#endif
126#ifndef IPPROTO_SCTP
127#define IPPROTO_SCTP 132
128#endif
129
130#ifdef HAVE_OS_PROTO_H
131#include "os-proto.h"
132#endif
133
134#define JMP(c) ((c)|BPF_JMP|BPF_K)
135
136/* Locals */
137static jmp_buf top_ctx;
138static pcap_t *bpf_pcap;
139
140/* Hack for updating VLAN, MPLS, and PPPoE offsets. */
141#ifdef WIN32
142static u_int    orig_linktype = (u_int)-1, orig_nl = (u_int)-1, label_stack_depth = (u_int)-1;
143#else
144static u_int    orig_linktype = -1U, orig_nl = -1U, label_stack_depth = -1U;
145#endif
146
147/* XXX */
148#ifdef PCAP_FDDIPAD
149static int      pcap_fddipad;
150#endif
151
152/* VARARGS */
153void
154bpf_error(const char *fmt, ...)
155{
156        va_list ap;
157
158        va_start(ap, fmt);
159        if (bpf_pcap != NULL)
160                (void)vsnprintf(pcap_geterr(bpf_pcap), PCAP_ERRBUF_SIZE,
161                    fmt, ap);
162        va_end(ap);
163        longjmp(top_ctx, 1);
164        /* NOTREACHED */
165}
166
167static void init_linktype(pcap_t *);
168
169static void init_regs(void);
170static int alloc_reg(void);
171static void free_reg(int);
172
173static struct block *root;
174
175/*
176 * Value passed to gen_load_a() to indicate what the offset argument
177 * is relative to.
178 */
179enum e_offrel {
180        OR_PACKET,      /* relative to the beginning of the packet */
181        OR_LINK,        /* relative to the beginning of the link-layer header */
182        OR_MACPL,       /* relative to the end of the MAC-layer header */
183        OR_NET,         /* relative to the network-layer header */
184        OR_NET_NOSNAP,  /* relative to the network-layer header, with no SNAP header at the link layer */
185        OR_TRAN_IPV4,   /* relative to the transport-layer header, with IPv4 network layer */
186        OR_TRAN_IPV6    /* relative to the transport-layer header, with IPv6 network layer */
187};
188
189#ifdef INET6
190/*
191 * As errors are handled by a longjmp, anything allocated must be freed
192 * in the longjmp handler, so it must be reachable from that handler.
193 * One thing that's allocated is the result of pcap_nametoaddrinfo();
194 * it must be freed with freeaddrinfo().  This variable points to any
195 * addrinfo structure that would need to be freed.
196 */
197static struct addrinfo *ai;
198#endif
199
200/*
201 * We divy out chunks of memory rather than call malloc each time so
202 * we don't have to worry about leaking memory.  It's probably
203 * not a big deal if all this memory was wasted but if this ever
204 * goes into a library that would probably not be a good idea.
205 *
206 * XXX - this *is* in a library....
207 */
208#define NCHUNKS 16
209#define CHUNK0SIZE 1024
210struct chunk {
211        u_int n_left;
212        void *m;
213};
214
215static struct chunk chunks[NCHUNKS];
216static int cur_chunk;
217
218static void *newchunk(u_int);
219static void freechunks(void);
220static inline struct block *new_block(int);
221static inline struct slist *new_stmt(int);
222static struct block *gen_retblk(int);
223static inline void syntax(void);
224
225static void backpatch(struct block *, struct block *);
226static void merge(struct block *, struct block *);
227static struct block *gen_cmp(enum e_offrel, u_int, u_int, bpf_int32);
228static struct block *gen_cmp_gt(enum e_offrel, u_int, u_int, bpf_int32);
229static struct block *gen_cmp_ge(enum e_offrel, u_int, u_int, bpf_int32);
230static struct block *gen_cmp_lt(enum e_offrel, u_int, u_int, bpf_int32);
231static struct block *gen_cmp_le(enum e_offrel, u_int, u_int, bpf_int32);
232static struct block *gen_mcmp(enum e_offrel, u_int, u_int, bpf_int32,
233    bpf_u_int32);
234static struct block *gen_bcmp(enum e_offrel, u_int, u_int, const u_char *);
235static struct block *gen_ncmp(enum e_offrel, bpf_u_int32, bpf_u_int32,
236    bpf_u_int32, bpf_u_int32, int, bpf_int32);
237static struct slist *gen_load_llrel(u_int, u_int);
238static struct slist *gen_load_macplrel(u_int, u_int);
239static struct slist *gen_load_a(enum e_offrel, u_int, u_int);
240static struct slist *gen_loadx_iphdrlen(void);
241static struct block *gen_uncond(int);
242static inline struct block *gen_true(void);
243static inline struct block *gen_false(void);
244static struct block *gen_ether_linktype(int);
245static struct block *gen_ipnet_linktype(int);
246static struct block *gen_linux_sll_linktype(int);
247static struct slist *gen_load_prism_llprefixlen(void);
248static struct slist *gen_load_avs_llprefixlen(void);
249static struct slist *gen_load_radiotap_llprefixlen(void);
250static struct slist *gen_load_ppi_llprefixlen(void);
251static void insert_compute_vloffsets(struct block *);
252static struct slist *gen_llprefixlen(void);
253static struct slist *gen_off_macpl(void);
254static int ethertype_to_ppptype(int);
255static struct block *gen_linktype(int);
256static struct block *gen_snap(bpf_u_int32, bpf_u_int32);
257static struct block *gen_llc_linktype(int);
258static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
259#ifdef INET6
260static struct block *gen_hostop6(struct in6_addr *, struct in6_addr *, int, int, u_int, u_int);
261#endif
262static struct block *gen_ahostop(const u_char *, int);
263static struct block *gen_ehostop(const u_char *, int);
264static struct block *gen_fhostop(const u_char *, int);
265static struct block *gen_thostop(const u_char *, int);
266static struct block *gen_wlanhostop(const u_char *, int);
267static struct block *gen_ipfchostop(const u_char *, int);
268static struct block *gen_dnhostop(bpf_u_int32, int);
269static struct block *gen_mpls_linktype(int);
270static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int, int);
271#ifdef INET6
272static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int, int);
273#endif
274#ifndef INET6
275static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
276#endif
277static struct block *gen_ipfrag(void);
278static struct block *gen_portatom(int, bpf_int32);
279static struct block *gen_portrangeatom(int, bpf_int32, bpf_int32);
280static struct block *gen_portatom6(int, bpf_int32);
281static struct block *gen_portrangeatom6(int, bpf_int32, bpf_int32);
282struct block *gen_portop(int, int, int);
283static struct block *gen_port(int, int, int);
284struct block *gen_portrangeop(int, int, int, int);
285static struct block *gen_portrange(int, int, int, int);
286struct block *gen_portop6(int, int, int);
287static struct block *gen_port6(int, int, int);
288struct block *gen_portrangeop6(int, int, int, int);
289static struct block *gen_portrange6(int, int, int, int);
290static int lookup_proto(const char *, int);
291static struct block *gen_protochain(int, int, int);
292static struct block *gen_proto(int, int, int);
293static struct slist *xfer_to_x(struct arth *);
294static struct slist *xfer_to_a(struct arth *);
295static struct block *gen_mac_multicast(int);
296static struct block *gen_len(int, int);
297static struct block *gen_check_802_11_data_frame(void);
298
299static struct block *gen_ppi_dlt_check(void);
300static struct block *gen_msg_abbrev(int type);
301
302static void *
303newchunk(n)
304        u_int n;
305{
306        struct chunk *cp;
307        int k;
308        size_t size;
309
310#ifndef __NetBSD__
311        /* XXX Round up to nearest long. */
312        n = (n + sizeof(long) - 1) & ~(sizeof(long) - 1);
313#else
314        /* XXX Round up to structure boundary. */
315        n = ALIGN(n);
316#endif
317
318        cp = &chunks[cur_chunk];
319        if (n > cp->n_left) {
320                ++cp, k = ++cur_chunk;
321                if (k >= NCHUNKS)
322                        bpf_error("out of memory");
323                size = CHUNK0SIZE << k;
324                cp->m = (void *)malloc(size);
325                if (cp->m == NULL)
326                        bpf_error("out of memory");
327                memset((char *)cp->m, 0, size);
328                cp->n_left = size;
329                if (n > size)
330                        bpf_error("out of memory");
331        }
332        cp->n_left -= n;
333        return (void *)((char *)cp->m + cp->n_left);
334}
335
336static void
337freechunks()
338{
339        int i;
340
341        cur_chunk = 0;
342        for (i = 0; i < NCHUNKS; ++i)
343                if (chunks[i].m != NULL) {
344                        free(chunks[i].m);
345                        chunks[i].m = NULL;
346                }
347}
348
349/*
350 * A strdup whose allocations are freed after code generation is over.
351 */
352char *
353sdup(s)
354        register const char *s;
355{
356        int n = strlen(s) + 1;
357        char *cp = newchunk(n);
358
359        strlcpy(cp, s, n);
360        return (cp);
361}
362
363static inline struct block *
364new_block(code)
365        int code;
366{
367        struct block *p;
368
369        p = (struct block *)newchunk(sizeof(*p));
370        p->s.code = code;
371        p->head = p;
372
373        return p;
374}
375
376static inline struct slist *
377new_stmt(code)
378        int code;
379{
380        struct slist *p;
381
382        p = (struct slist *)newchunk(sizeof(*p));
383        p->s.code = code;
384
385        return p;
386}
387
388static struct block *
389gen_retblk(v)
390        int v;
391{
392        struct block *b = new_block(BPF_RET|BPF_K);
393
394        b->s.k = v;
395        return b;
396}
397
398static inline void
399syntax()
400{
401        bpf_error("syntax error in filter expression");
402}
403
404static bpf_u_int32 netmask;
405static int snaplen;
406int no_optimize;
407#ifdef WIN32
408static int
409pcap_compile_unsafe(pcap_t *p, struct bpf_program *program,
410             const char *buf, int optimize, bpf_u_int32 mask);
411
412int
413pcap_compile(pcap_t *p, struct bpf_program *program,
414             const char *buf, int optimize, bpf_u_int32 mask)
415{
416        int result;
417
418        EnterCriticalSection(&g_PcapCompileCriticalSection);
419
420        result = pcap_compile_unsafe(p, program, buf, optimize, mask);
421
422        LeaveCriticalSection(&g_PcapCompileCriticalSection);
423
424        return result;
425}
426
427static int
428pcap_compile_unsafe(pcap_t *p, struct bpf_program *program,
429             const char *buf, int optimize, bpf_u_int32 mask)
430#else /* WIN32 */
431int
432pcap_compile(pcap_t *p, struct bpf_program *program,
433             const char *buf, int optimize, bpf_u_int32 mask)
434#endif /* WIN32 */
435{
436#if __rtems__
437        int n_errors;
438#else
439        extern int n_errors;
440#endif
441        const char * volatile xbuf = buf;
442        u_int len;
443
444        /*
445         * If this pcap_t hasn't been activated, it doesn't have a
446         * link-layer type, so we can't use it.
447         */
448        if (!p->activated) {
449                snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
450                    "not-yet-activated pcap_t passed to pcap_compile");
451                return (-1);
452        }
453        no_optimize = 0;
454        n_errors = 0;
455        root = NULL;
456        bpf_pcap = p;
457        init_regs();
458        if (setjmp(top_ctx)) {
459#ifdef INET6
460                if (ai != NULL) {
461                        freeaddrinfo(ai);
462                        ai = NULL;
463                }
464#endif
465                lex_cleanup();
466                freechunks();
467                return (-1);
468        }
469
470        netmask = mask;
471
472        snaplen = pcap_snapshot(p);
473        if (snaplen == 0) {
474                snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
475                         "snaplen of 0 rejects all packets");
476                return -1;
477        }
478
479        lex_init(xbuf ? xbuf : "");
480        init_linktype(p);
481        (void)pcap_parse();
482
483        if (n_errors)
484                syntax();
485
486        if (root == NULL)
487                root = gen_retblk(snaplen);
488
489        if (optimize && !no_optimize) {
490                bpf_optimize(&root);
491                if (root == NULL ||
492                    (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
493                        bpf_error("expression rejects all packets");
494        }
495        program->bf_insns = icode_to_fcode(root, &len);
496        program->bf_len = len;
497
498        lex_cleanup();
499        freechunks();
500        return (0);
501}
502
503/*
504 * entry point for using the compiler with no pcap open
505 * pass in all the stuff that is needed explicitly instead.
506 */
507int
508pcap_compile_nopcap(int snaplen_arg, int linktype_arg,
509                    struct bpf_program *program,
510             const char *buf, int optimize, bpf_u_int32 mask)
511{
512        pcap_t *p;
513        int ret;
514
515        p = pcap_open_dead(linktype_arg, snaplen_arg);
516        if (p == NULL)
517                return (-1);
518        ret = pcap_compile(p, program, buf, optimize, mask);
519        pcap_close(p);
520        return (ret);
521}
522
523/*
524 * Clean up a "struct bpf_program" by freeing all the memory allocated
525 * in it.
526 */
527void
528pcap_freecode(struct bpf_program *program)
529{
530        program->bf_len = 0;
531        if (program->bf_insns != NULL) {
532                free((char *)program->bf_insns);
533                program->bf_insns = NULL;
534        }
535}
536
537/*
538 * Backpatch the blocks in 'list' to 'target'.  The 'sense' field indicates
539 * which of the jt and jf fields has been resolved and which is a pointer
540 * back to another unresolved block (or nil).  At least one of the fields
541 * in each block is already resolved.
542 */
543static void
544backpatch(list, target)
545        struct block *list, *target;
546{
547        struct block *next;
548
549        while (list) {
550                if (!list->sense) {
551                        next = JT(list);
552                        JT(list) = target;
553                } else {
554                        next = JF(list);
555                        JF(list) = target;
556                }
557                list = next;
558        }
559}
560
561/*
562 * Merge the lists in b0 and b1, using the 'sense' field to indicate
563 * which of jt and jf is the link.
564 */
565static void
566merge(b0, b1)
567        struct block *b0, *b1;
568{
569        register struct block **p = &b0;
570
571        /* Find end of list. */
572        while (*p)
573                p = !((*p)->sense) ? &JT(*p) : &JF(*p);
574
575        /* Concatenate the lists. */
576        *p = b1;
577}
578
579void
580finish_parse(p)
581        struct block *p;
582{
583        struct block *ppi_dlt_check;
584
585        /*
586         * Insert before the statements of the first (root) block any
587         * statements needed to load the lengths of any variable-length
588         * headers into registers.
589         *
590         * XXX - a fancier strategy would be to insert those before the
591         * statements of all blocks that use those lengths and that
592         * have no predecessors that use them, so that we only compute
593         * the lengths if we need them.  There might be even better
594         * approaches than that.
595         *
596         * However, those strategies would be more complicated, and
597         * as we don't generate code to compute a length if the
598         * program has no tests that use the length, and as most
599         * tests will probably use those lengths, we would just
600         * postpone computing the lengths so that it's not done
601         * for tests that fail early, and it's not clear that's
602         * worth the effort.
603         */
604        insert_compute_vloffsets(p->head);
605
606        /*
607         * For DLT_PPI captures, generate a check of the per-packet
608         * DLT value to make sure it's DLT_IEEE802_11.
609         */
610        ppi_dlt_check = gen_ppi_dlt_check();
611        if (ppi_dlt_check != NULL)
612                gen_and(ppi_dlt_check, p);
613
614        backpatch(p, gen_retblk(snaplen));
615        p->sense = !p->sense;
616        backpatch(p, gen_retblk(0));
617        root = p->head;
618}
619
620void
621gen_and(b0, b1)
622        struct block *b0, *b1;
623{
624        backpatch(b0, b1->head);
625        b0->sense = !b0->sense;
626        b1->sense = !b1->sense;
627        merge(b1, b0);
628        b1->sense = !b1->sense;
629        b1->head = b0->head;
630}
631
632void
633gen_or(b0, b1)
634        struct block *b0, *b1;
635{
636        b0->sense = !b0->sense;
637        backpatch(b0, b1->head);
638        b0->sense = !b0->sense;
639        merge(b1, b0);
640        b1->head = b0->head;
641}
642
643void
644gen_not(b)
645        struct block *b;
646{
647        b->sense = !b->sense;
648}
649
650static struct block *
651gen_cmp(offrel, offset, size, v)
652        enum e_offrel offrel;
653        u_int offset, size;
654        bpf_int32 v;
655{
656        return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JEQ, 0, v);
657}
658
659static struct block *
660gen_cmp_gt(offrel, offset, size, v)
661        enum e_offrel offrel;
662        u_int offset, size;
663        bpf_int32 v;
664{
665        return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 0, v);
666}
667
668static struct block *
669gen_cmp_ge(offrel, offset, size, v)
670        enum e_offrel offrel;
671        u_int offset, size;
672        bpf_int32 v;
673{
674        return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 0, v);
675}
676
677static struct block *
678gen_cmp_lt(offrel, offset, size, v)
679        enum e_offrel offrel;
680        u_int offset, size;
681        bpf_int32 v;
682{
683        return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 1, v);
684}
685
686static struct block *
687gen_cmp_le(offrel, offset, size, v)
688        enum e_offrel offrel;
689        u_int offset, size;
690        bpf_int32 v;
691{
692        return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);
693}
694
695static struct block *
696gen_mcmp(offrel, offset, size, v, mask)
697        enum e_offrel offrel;
698        u_int offset, size;
699        bpf_int32 v;
700        bpf_u_int32 mask;
701{
702        return gen_ncmp(offrel, offset, size, mask, BPF_JEQ, 0, v);
703}
704
705static struct block *
706gen_bcmp(offrel, offset, size, v)
707        enum e_offrel offrel;
708        register u_int offset, size;
709        register const u_char *v;
710{
711        register struct block *b, *tmp;
712
713        b = NULL;
714        while (size >= 4) {
715                register const u_char *p = &v[size - 4];
716                bpf_int32 w = ((bpf_int32)p[0] << 24) |
717                    ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
718
719                tmp = gen_cmp(offrel, offset + size - 4, BPF_W, w);
720                if (b != NULL)
721                        gen_and(b, tmp);
722                b = tmp;
723                size -= 4;
724        }
725        while (size >= 2) {
726                register const u_char *p = &v[size - 2];
727                bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
728
729                tmp = gen_cmp(offrel, offset + size - 2, BPF_H, w);
730                if (b != NULL)
731                        gen_and(b, tmp);
732                b = tmp;
733                size -= 2;
734        }
735        if (size > 0) {
736                tmp = gen_cmp(offrel, offset, BPF_B, (bpf_int32)v[0]);
737                if (b != NULL)
738                        gen_and(b, tmp);
739                b = tmp;
740        }
741        return b;
742}
743
744/*
745 * AND the field of size "size" at offset "offset" relative to the header
746 * specified by "offrel" with "mask", and compare it with the value "v"
747 * with the test specified by "jtype"; if "reverse" is true, the test
748 * should test the opposite of "jtype".
749 */
750static struct block *
751gen_ncmp(offrel, offset, size, mask, jtype, reverse, v)
752        enum e_offrel offrel;
753        bpf_int32 v;
754        bpf_u_int32 offset, size, mask, jtype;
755        int reverse;
756{
757        struct slist *s, *s2;
758        struct block *b;
759
760        s = gen_load_a(offrel, offset, size);
761
762        if (mask != 0xffffffff) {
763                s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
764                s2->s.k = mask;
765                sappend(s, s2);
766        }
767
768        b = new_block(JMP(jtype));
769        b->stmts = s;
770        b->s.k = v;
771        if (reverse && (jtype == BPF_JGT || jtype == BPF_JGE))
772                gen_not(b);
773        return b;
774}
775
776/*
777 * Various code constructs need to know the layout of the data link
778 * layer.  These variables give the necessary offsets from the beginning
779 * of the packet data.
780 */
781
782/*
783 * This is the offset of the beginning of the link-layer header from
784 * the beginning of the raw packet data.
785 *
786 * It's usually 0, except for 802.11 with a fixed-length radio header.
787 * (For 802.11 with a variable-length radio header, we have to generate
788 * code to compute that offset; off_ll is 0 in that case.)
789 */
790static u_int off_ll;
791
792/*
793 * If there's a variable-length header preceding the link-layer header,
794 * "reg_off_ll" is the register number for a register containing the
795 * length of that header, and therefore the offset of the link-layer
796 * header from the beginning of the raw packet data.  Otherwise,
797 * "reg_off_ll" is -1.
798 */
799static int reg_off_ll;
800
801/*
802 * This is the offset of the beginning of the MAC-layer header from
803 * the beginning of the link-layer header.
804 * It's usually 0, except for ATM LANE, where it's the offset, relative
805 * to the beginning of the raw packet data, of the Ethernet header, and
806 * for Ethernet with various additional information.
807 */
808static u_int off_mac;
809
810/*
811 * This is the offset of the beginning of the MAC-layer payload,
812 * from the beginning of the raw packet data.
813 *
814 * I.e., it's the sum of the length of the link-layer header (without,
815 * for example, any 802.2 LLC header, so it's the MAC-layer
816 * portion of that header), plus any prefix preceding the
817 * link-layer header.
818 */
819static u_int off_macpl;
820
821/*
822 * This is 1 if the offset of the beginning of the MAC-layer payload
823 * from the beginning of the link-layer header is variable-length.
824 */
825static int off_macpl_is_variable;
826
827/*
828 * If the link layer has variable_length headers, "reg_off_macpl"
829 * is the register number for a register containing the length of the
830 * link-layer header plus the length of any variable-length header
831 * preceding the link-layer header.  Otherwise, "reg_off_macpl"
832 * is -1.
833 */
834static int reg_off_macpl;
835
836/*
837 * "off_linktype" is the offset to information in the link-layer header
838 * giving the packet type.  This offset is relative to the beginning
839 * of the link-layer header (i.e., it doesn't include off_ll).
840 *
841 * For Ethernet, it's the offset of the Ethernet type field.
842 *
843 * For link-layer types that always use 802.2 headers, it's the
844 * offset of the LLC header.
845 *
846 * For PPP, it's the offset of the PPP type field.
847 *
848 * For Cisco HDLC, it's the offset of the CHDLC type field.
849 *
850 * For BSD loopback, it's the offset of the AF_ value.
851 *
852 * For Linux cooked sockets, it's the offset of the type field.
853 *
854 * It's set to -1 for no encapsulation, in which case, IP is assumed.
855 */
856static u_int off_linktype;
857
858/*
859 * TRUE if "pppoes" appeared in the filter; it causes link-layer type
860 * checks to check the PPP header, assumed to follow a LAN-style link-
861 * layer header and a PPPoE session header.
862 */
863static int is_pppoes = 0;
864
865/*
866 * TRUE if the link layer includes an ATM pseudo-header.
867 */
868static int is_atm = 0;
869
870/*
871 * TRUE if "lane" appeared in the filter; it causes us to generate
872 * code that assumes LANE rather than LLC-encapsulated traffic in SunATM.
873 */
874static int is_lane = 0;
875
876/*
877 * These are offsets for the ATM pseudo-header.
878 */
879static u_int off_vpi;
880static u_int off_vci;
881static u_int off_proto;
882
883/*
884 * These are offsets for the MTP2 fields.
885 */
886static u_int off_li;
887
888/*
889 * These are offsets for the MTP3 fields.
890 */
891static u_int off_sio;
892static u_int off_opc;
893static u_int off_dpc;
894static u_int off_sls;
895
896/*
897 * This is the offset of the first byte after the ATM pseudo_header,
898 * or -1 if there is no ATM pseudo-header.
899 */
900static u_int off_payload;
901
902/*
903 * These are offsets to the beginning of the network-layer header.
904 * They are relative to the beginning of the MAC-layer payload (i.e.,
905 * they don't include off_ll or off_macpl).
906 *
907 * If the link layer never uses 802.2 LLC:
908 *
909 *      "off_nl" and "off_nl_nosnap" are the same.
910 *
911 * If the link layer always uses 802.2 LLC:
912 *
913 *      "off_nl" is the offset if there's a SNAP header following
914 *      the 802.2 header;
915 *
916 *      "off_nl_nosnap" is the offset if there's no SNAP header.
917 *
918 * If the link layer is Ethernet:
919 *
920 *      "off_nl" is the offset if the packet is an Ethernet II packet
921 *      (we assume no 802.3+802.2+SNAP);
922 *
923 *      "off_nl_nosnap" is the offset if the packet is an 802.3 packet
924 *      with an 802.2 header following it.
925 */
926static u_int off_nl;
927static u_int off_nl_nosnap;
928
929static int linktype;
930
931static void
932init_linktype(p)
933        pcap_t *p;
934{
935        linktype = pcap_datalink(p);
936#ifdef PCAP_FDDIPAD
937        pcap_fddipad = p->fddipad;
938#endif
939
940        /*
941         * Assume it's not raw ATM with a pseudo-header, for now.
942         */
943        off_mac = 0;
944        is_atm = 0;
945        is_lane = 0;
946        off_vpi = -1;
947        off_vci = -1;
948        off_proto = -1;
949        off_payload = -1;
950
951        /*
952         * And that we're not doing PPPoE.
953         */
954        is_pppoes = 0;
955
956        /*
957         * And assume we're not doing SS7.
958         */
959        off_li = -1;
960        off_sio = -1;
961        off_opc = -1;
962        off_dpc = -1;
963        off_sls = -1;
964
965        /*
966         * Also assume it's not 802.11.
967         */
968        off_ll = 0;
969        off_macpl = 0;
970        off_macpl_is_variable = 0;
971
972        orig_linktype = -1;
973        orig_nl = -1;
974        label_stack_depth = 0;
975
976        reg_off_ll = -1;
977        reg_off_macpl = -1;
978
979        switch (linktype) {
980
981        case DLT_ARCNET:
982                off_linktype = 2;
983                off_macpl = 6;
984                off_nl = 0;             /* XXX in reality, variable! */
985                off_nl_nosnap = 0;      /* no 802.2 LLC */
986                return;
987
988        case DLT_ARCNET_LINUX:
989                off_linktype = 4;
990                off_macpl = 8;
991                off_nl = 0;             /* XXX in reality, variable! */
992                off_nl_nosnap = 0;      /* no 802.2 LLC */
993                return;
994
995        case DLT_EN10MB:
996                off_linktype = 12;
997                off_macpl = 14;         /* Ethernet header length */
998                off_nl = 0;             /* Ethernet II */
999                off_nl_nosnap = 3;      /* 802.3+802.2 */
1000                return;
1001
1002        case DLT_SLIP:
1003                /*
1004                 * SLIP doesn't have a link level type.  The 16 byte
1005                 * header is hacked into our SLIP driver.
1006                 */
1007                off_linktype = -1;
1008                off_macpl = 16;
1009                off_nl = 0;
1010                off_nl_nosnap = 0;      /* no 802.2 LLC */
1011                return;
1012
1013        case DLT_SLIP_BSDOS:
1014                /* XXX this may be the same as the DLT_PPP_BSDOS case */
1015                off_linktype = -1;
1016                /* XXX end */
1017                off_macpl = 24;
1018                off_nl = 0;
1019                off_nl_nosnap = 0;      /* no 802.2 LLC */
1020                return;
1021
1022        case DLT_NULL:
1023        case DLT_LOOP:
1024                off_linktype = 0;
1025                off_macpl = 4;
1026                off_nl = 0;
1027                off_nl_nosnap = 0;      /* no 802.2 LLC */
1028                return;
1029
1030        case DLT_ENC:
1031                off_linktype = 0;
1032                off_macpl = 12;
1033                off_nl = 0;
1034                off_nl_nosnap = 0;      /* no 802.2 LLC */
1035                return;
1036
1037        case DLT_PPP:
1038        case DLT_PPP_PPPD:
1039        case DLT_C_HDLC:                /* BSD/OS Cisco HDLC */
1040        case DLT_PPP_SERIAL:            /* NetBSD sync/async serial PPP */
1041                off_linktype = 2;
1042                off_macpl = 4;
1043                off_nl = 0;
1044                off_nl_nosnap = 0;      /* no 802.2 LLC */
1045                return;
1046
1047        case DLT_PPP_ETHER:
1048                /*
1049                 * This does no include the Ethernet header, and
1050                 * only covers session state.
1051                 */
1052                off_linktype = 6;
1053                off_macpl = 8;
1054                off_nl = 0;
1055                off_nl_nosnap = 0;      /* no 802.2 LLC */
1056                return;
1057
1058        case DLT_PPP_BSDOS:
1059                off_linktype = 5;
1060                off_macpl = 24;
1061                off_nl = 0;
1062                off_nl_nosnap = 0;      /* no 802.2 LLC */
1063                return;
1064
1065        case DLT_FDDI:
1066                /*
1067                 * FDDI doesn't really have a link-level type field.
1068                 * We set "off_linktype" to the offset of the LLC header.
1069                 *
1070                 * To check for Ethernet types, we assume that SSAP = SNAP
1071                 * is being used and pick out the encapsulated Ethernet type.
1072                 * XXX - should we generate code to check for SNAP?
1073                 */
1074                off_linktype = 13;
1075#ifdef PCAP_FDDIPAD
1076                off_linktype += pcap_fddipad;
1077#endif
1078                off_macpl = 13;         /* FDDI MAC header length */
1079#ifdef PCAP_FDDIPAD
1080                off_macpl += pcap_fddipad;
1081#endif
1082                off_nl = 8;             /* 802.2+SNAP */
1083                off_nl_nosnap = 3;      /* 802.2 */
1084                return;
1085
1086        case DLT_IEEE802:
1087                /*
1088                 * Token Ring doesn't really have a link-level type field.
1089                 * We set "off_linktype" to the offset of the LLC header.
1090                 *
1091                 * To check for Ethernet types, we assume that SSAP = SNAP
1092                 * is being used and pick out the encapsulated Ethernet type.
1093                 * XXX - should we generate code to check for SNAP?
1094                 *
1095                 * XXX - the header is actually variable-length.
1096                 * Some various Linux patched versions gave 38
1097                 * as "off_linktype" and 40 as "off_nl"; however,
1098                 * if a token ring packet has *no* routing
1099                 * information, i.e. is not source-routed, the correct
1100                 * values are 20 and 22, as they are in the vanilla code.
1101                 *
1102                 * A packet is source-routed iff the uppermost bit
1103                 * of the first byte of the source address, at an
1104                 * offset of 8, has the uppermost bit set.  If the
1105                 * packet is source-routed, the total number of bytes
1106                 * of routing information is 2 plus bits 0x1F00 of
1107                 * the 16-bit value at an offset of 14 (shifted right
1108                 * 8 - figure out which byte that is).
1109                 */
1110                off_linktype = 14;
1111                off_macpl = 14;         /* Token Ring MAC header length */
1112                off_nl = 8;             /* 802.2+SNAP */
1113                off_nl_nosnap = 3;      /* 802.2 */
1114                return;
1115
1116        case DLT_IEEE802_11:
1117        case DLT_PRISM_HEADER:
1118        case DLT_IEEE802_11_RADIO_AVS:
1119        case DLT_IEEE802_11_RADIO:
1120                /*
1121                 * 802.11 doesn't really have a link-level type field.
1122                 * We set "off_linktype" to the offset of the LLC header.
1123                 *
1124                 * To check for Ethernet types, we assume that SSAP = SNAP
1125                 * is being used and pick out the encapsulated Ethernet type.
1126                 * XXX - should we generate code to check for SNAP?
1127                 *
1128                 * We also handle variable-length radio headers here.
1129                 * The Prism header is in theory variable-length, but in
1130                 * practice it's always 144 bytes long.  However, some
1131                 * drivers on Linux use ARPHRD_IEEE80211_PRISM, but
1132                 * sometimes or always supply an AVS header, so we
1133                 * have to check whether the radio header is a Prism
1134                 * header or an AVS header, so, in practice, it's
1135                 * variable-length.
1136                 */
1137                off_linktype = 24;
1138                off_macpl = 0;          /* link-layer header is variable-length */
1139                off_macpl_is_variable = 1;
1140                off_nl = 8;             /* 802.2+SNAP */
1141                off_nl_nosnap = 3;      /* 802.2 */
1142                return;
1143
1144        case DLT_PPI:
1145                /*
1146                 * At the moment we treat PPI the same way that we treat
1147                 * normal Radiotap encoded packets. The difference is in
1148                 * the function that generates the code at the beginning
1149                 * to compute the header length.  Since this code generator
1150                 * of PPI supports bare 802.11 encapsulation only (i.e.
1151                 * the encapsulated DLT should be DLT_IEEE802_11) we
1152                 * generate code to check for this too.
1153                 */
1154                off_linktype = 24;
1155                off_macpl = 0;          /* link-layer header is variable-length */
1156                off_macpl_is_variable = 1;
1157                off_nl = 8;             /* 802.2+SNAP */
1158                off_nl_nosnap = 3;      /* 802.2 */
1159                return;
1160
1161        case DLT_ATM_RFC1483:
1162        case DLT_ATM_CLIP:      /* Linux ATM defines this */
1163                /*
1164                 * assume routed, non-ISO PDUs
1165                 * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)
1166                 *
1167                 * XXX - what about ISO PDUs, e.g. CLNP, ISIS, ESIS,
1168                 * or PPP with the PPP NLPID (e.g., PPPoA)?  The
1169                 * latter would presumably be treated the way PPPoE
1170                 * should be, so you can do "pppoe and udp port 2049"
1171                 * or "pppoa and tcp port 80" and have it check for
1172                 * PPPo{A,E} and a PPP protocol of IP and....
1173                 */
1174                off_linktype = 0;
1175                off_macpl = 0;          /* packet begins with LLC header */
1176                off_nl = 8;             /* 802.2+SNAP */
1177                off_nl_nosnap = 3;      /* 802.2 */
1178                return;
1179
1180        case DLT_SUNATM:
1181                /*
1182                 * Full Frontal ATM; you get AALn PDUs with an ATM
1183                 * pseudo-header.
1184                 */
1185                is_atm = 1;
1186                off_vpi = SUNATM_VPI_POS;
1187                off_vci = SUNATM_VCI_POS;
1188                off_proto = PROTO_POS;
1189                off_mac = -1;   /* assume LLC-encapsulated, so no MAC-layer header */
1190                off_payload = SUNATM_PKT_BEGIN_POS;
1191                off_linktype = off_payload;
1192                off_macpl = off_payload;        /* if LLC-encapsulated */
1193                off_nl = 8;             /* 802.2+SNAP */
1194                off_nl_nosnap = 3;      /* 802.2 */
1195                return;
1196
1197        case DLT_RAW:
1198        case DLT_IPV4:
1199        case DLT_IPV6:
1200                off_linktype = -1;
1201                off_macpl = 0;
1202                off_nl = 0;
1203                off_nl_nosnap = 0;      /* no 802.2 LLC */
1204                return;
1205
1206        case DLT_LINUX_SLL:     /* fake header for Linux cooked socket */
1207                off_linktype = 14;
1208                off_macpl = 16;
1209                off_nl = 0;
1210                off_nl_nosnap = 0;      /* no 802.2 LLC */
1211                return;
1212
1213        case DLT_LTALK:
1214                /*
1215                 * LocalTalk does have a 1-byte type field in the LLAP header,
1216                 * but really it just indicates whether there is a "short" or
1217                 * "long" DDP packet following.
1218                 */
1219                off_linktype = -1;
1220                off_macpl = 0;
1221                off_nl = 0;
1222                off_nl_nosnap = 0;      /* no 802.2 LLC */
1223                return;
1224
1225        case DLT_IP_OVER_FC:
1226                /*
1227                 * RFC 2625 IP-over-Fibre-Channel doesn't really have a
1228                 * link-level type field.  We set "off_linktype" to the
1229                 * offset of the LLC header.
1230                 *
1231                 * To check for Ethernet types, we assume that SSAP = SNAP
1232                 * is being used and pick out the encapsulated Ethernet type.
1233                 * XXX - should we generate code to check for SNAP? RFC
1234                 * 2625 says SNAP should be used.
1235                 */
1236                off_linktype = 16;
1237                off_macpl = 16;
1238                off_nl = 8;             /* 802.2+SNAP */
1239                off_nl_nosnap = 3;      /* 802.2 */
1240                return;
1241
1242        case DLT_FRELAY:
1243                /*
1244                 * XXX - we should set this to handle SNAP-encapsulated
1245                 * frames (NLPID of 0x80).
1246                 */
1247                off_linktype = -1;
1248                off_macpl = 0;
1249                off_nl = 0;
1250                off_nl_nosnap = 0;      /* no 802.2 LLC */
1251                return;
1252
1253                /*
1254                 * the only BPF-interesting FRF.16 frames are non-control frames;
1255                 * Frame Relay has a variable length link-layer
1256                 * so lets start with offset 4 for now and increments later on (FIXME);
1257                 */
1258        case DLT_MFR:
1259                off_linktype = -1;
1260                off_macpl = 0;
1261                off_nl = 4;
1262                off_nl_nosnap = 0;      /* XXX - for now -> no 802.2 LLC */
1263                return;
1264
1265        case DLT_APPLE_IP_OVER_IEEE1394:
1266                off_linktype = 16;
1267                off_macpl = 18;
1268                off_nl = 0;
1269                off_nl_nosnap = 0;      /* no 802.2 LLC */
1270                return;
1271
1272        case DLT_SYMANTEC_FIREWALL:
1273                off_linktype = 6;
1274                off_macpl = 44;
1275                off_nl = 0;             /* Ethernet II */
1276                off_nl_nosnap = 0;      /* XXX - what does it do with 802.3 packets? */
1277                return;
1278
1279#ifdef HAVE_NET_PFVAR_H
1280        case DLT_PFLOG:
1281                off_linktype = 0;
1282                off_macpl = PFLOG_HDRLEN;
1283                off_nl = 0;
1284                off_nl_nosnap = 0;      /* no 802.2 LLC */
1285                return;
1286#endif
1287
1288        case DLT_JUNIPER_MFR:
1289        case DLT_JUNIPER_MLFR:
1290        case DLT_JUNIPER_MLPPP:
1291        case DLT_JUNIPER_PPP:
1292        case DLT_JUNIPER_CHDLC:
1293        case DLT_JUNIPER_FRELAY:
1294                off_linktype = 4;
1295                off_macpl = 4;
1296                off_nl = 0;
1297                off_nl_nosnap = -1;     /* no 802.2 LLC */
1298                return;
1299
1300        case DLT_JUNIPER_ATM1:
1301                off_linktype = 4;       /* in reality variable between 4-8 */
1302                off_macpl = 4;  /* in reality variable between 4-8 */
1303                off_nl = 0;
1304                off_nl_nosnap = 10;
1305                return;
1306
1307        case DLT_JUNIPER_ATM2:
1308                off_linktype = 8;       /* in reality variable between 8-12 */
1309                off_macpl = 8;  /* in reality variable between 8-12 */
1310                off_nl = 0;
1311                off_nl_nosnap = 10;
1312                return;
1313
1314                /* frames captured on a Juniper PPPoE service PIC
1315                 * contain raw ethernet frames */
1316        case DLT_JUNIPER_PPPOE:
1317        case DLT_JUNIPER_ETHER:
1318                off_macpl = 14;
1319                off_linktype = 16;
1320                off_nl = 18;            /* Ethernet II */
1321                off_nl_nosnap = 21;     /* 802.3+802.2 */
1322                return;
1323
1324        case DLT_JUNIPER_PPPOE_ATM:
1325                off_linktype = 4;
1326                off_macpl = 6;
1327                off_nl = 0;
1328                off_nl_nosnap = -1;     /* no 802.2 LLC */
1329                return;
1330
1331        case DLT_JUNIPER_GGSN:
1332                off_linktype = 6;
1333                off_macpl = 12;
1334                off_nl = 0;
1335                off_nl_nosnap = -1;     /* no 802.2 LLC */
1336                return;
1337
1338        case DLT_JUNIPER_ES:
1339                off_linktype = 6;
1340                off_macpl = -1;         /* not really a network layer but raw IP addresses */
1341                off_nl = -1;            /* not really a network layer but raw IP addresses */
1342                off_nl_nosnap = -1;     /* no 802.2 LLC */
1343                return;
1344
1345        case DLT_JUNIPER_MONITOR:
1346                off_linktype = 12;
1347                off_macpl = 12;
1348                off_nl = 0;             /* raw IP/IP6 header */
1349                off_nl_nosnap = -1;     /* no 802.2 LLC */
1350                return;
1351
1352        case DLT_JUNIPER_SERVICES:
1353                off_linktype = 12;
1354                off_macpl = -1;         /* L3 proto location dep. on cookie type */
1355                off_nl = -1;            /* L3 proto location dep. on cookie type */
1356                off_nl_nosnap = -1;     /* no 802.2 LLC */
1357                return;
1358
1359        case DLT_JUNIPER_VP:
1360                off_linktype = 18;
1361                off_macpl = -1;
1362                off_nl = -1;
1363                off_nl_nosnap = -1;
1364                return;
1365
1366        case DLT_JUNIPER_ST:
1367                off_linktype = 18;
1368                off_macpl = -1;
1369                off_nl = -1;
1370                off_nl_nosnap = -1;
1371                return;
1372
1373        case DLT_JUNIPER_ISM:
1374                off_linktype = 8;
1375                off_macpl = -1;
1376                off_nl = -1;
1377                off_nl_nosnap = -1;
1378                return;
1379
1380        case DLT_JUNIPER_VS:
1381        case DLT_JUNIPER_SRX_E2E:
1382        case DLT_JUNIPER_FIBRECHANNEL:
1383        case DLT_JUNIPER_ATM_CEMIC:
1384                off_linktype = 8;
1385                off_macpl = -1;
1386                off_nl = -1;
1387                off_nl_nosnap = -1;
1388                return;
1389
1390        case DLT_MTP2:
1391                off_li = 2;
1392                off_sio = 3;
1393                off_opc = 4;
1394                off_dpc = 4;
1395                off_sls = 7;
1396                off_linktype = -1;
1397                off_macpl = -1;
1398                off_nl = -1;
1399                off_nl_nosnap = -1;
1400                return;
1401
1402        case DLT_MTP2_WITH_PHDR:
1403                off_li = 6;
1404                off_sio = 7;
1405                off_opc = 8;
1406                off_dpc = 8;
1407                off_sls = 11;
1408                off_linktype = -1;
1409                off_macpl = -1;
1410                off_nl = -1;
1411                off_nl_nosnap = -1;
1412                return;
1413
1414        case DLT_ERF:
1415                off_li = 22;
1416                off_sio = 23;
1417                off_opc = 24;
1418                off_dpc = 24;
1419                off_sls = 27;
1420                off_linktype = -1;
1421                off_macpl = -1;
1422                off_nl = -1;
1423                off_nl_nosnap = -1;
1424                return;
1425
1426        case DLT_PFSYNC:
1427                off_linktype = -1;
1428                off_macpl = 4;
1429                off_nl = 0;
1430                off_nl_nosnap = 0;
1431                return;
1432
1433        case DLT_AX25_KISS:
1434                /*
1435                 * Currently, only raw "link[N:M]" filtering is supported.
1436                 */
1437                off_linktype = -1;      /* variable, min 15, max 71 steps of 7 */
1438                off_macpl = -1;
1439                off_nl = -1;            /* variable, min 16, max 71 steps of 7 */
1440                off_nl_nosnap = -1;     /* no 802.2 LLC */
1441                off_mac = 1;            /* step over the kiss length byte */
1442                return;
1443
1444        case DLT_IPNET:
1445                off_linktype = 1;
1446                off_macpl = 24;         /* ipnet header length */
1447                off_nl = 0;
1448                off_nl_nosnap = -1;
1449                return;
1450
1451        case DLT_NETANALYZER:
1452                off_mac = 4;            /* MAC header is past 4-byte pseudo-header */
1453                off_linktype = 16;      /* includes 4-byte pseudo-header */
1454                off_macpl = 18;         /* pseudo-header+Ethernet header length */
1455                off_nl = 0;             /* Ethernet II */
1456                off_nl_nosnap = 3;      /* 802.3+802.2 */
1457                return;
1458
1459        case DLT_NETANALYZER_TRANSPARENT:
1460                off_mac = 12;           /* MAC header is past 4-byte pseudo-header, preamble, and SFD */
1461                off_linktype = 24;      /* includes 4-byte pseudo-header+preamble+SFD */
1462                off_macpl = 26;         /* pseudo-header+preamble+SFD+Ethernet header length */
1463                off_nl = 0;             /* Ethernet II */
1464                off_nl_nosnap = 3;      /* 802.3+802.2 */
1465                return;
1466
1467        default:
1468                /*
1469                 * For values in the range in which we've assigned new
1470                 * DLT_ values, only raw "link[N:M]" filtering is supported.
1471                 */
1472                if (linktype >= DLT_MATCHING_MIN &&
1473                    linktype <= DLT_MATCHING_MAX) {
1474                        off_linktype = -1;
1475                        off_macpl = -1;
1476                        off_nl = -1;
1477                        off_nl_nosnap = -1;
1478                        return;
1479                }
1480
1481        }
1482        bpf_error("unknown data link type %d", linktype);
1483        /* NOTREACHED */
1484}
1485
1486/*
1487 * Load a value relative to the beginning of the link-layer header.
1488 * The link-layer header doesn't necessarily begin at the beginning
1489 * of the packet data; there might be a variable-length prefix containing
1490 * radio information.
1491 */
1492static struct slist *
1493gen_load_llrel(offset, size)
1494        u_int offset, size;
1495{
1496        struct slist *s, *s2;
1497
1498        s = gen_llprefixlen();
1499
1500        /*
1501         * If "s" is non-null, it has code to arrange that the X register
1502         * contains the length of the prefix preceding the link-layer
1503         * header.
1504         *
1505         * Otherwise, the length of the prefix preceding the link-layer
1506         * header is "off_ll".
1507         */
1508        if (s != NULL) {
1509                /*
1510                 * There's a variable-length prefix preceding the
1511                 * link-layer header.  "s" points to a list of statements
1512                 * that put the length of that prefix into the X register.
1513                 * do an indirect load, to use the X register as an offset.
1514                 */
1515                s2 = new_stmt(BPF_LD|BPF_IND|size);
1516                s2->s.k = offset;
1517                sappend(s, s2);
1518        } else {
1519                /*
1520                 * There is no variable-length header preceding the
1521                 * link-layer header; add in off_ll, which, if there's
1522                 * a fixed-length header preceding the link-layer header,
1523                 * is the length of that header.
1524                 */
1525                s = new_stmt(BPF_LD|BPF_ABS|size);
1526                s->s.k = offset + off_ll;
1527        }
1528        return s;
1529}
1530
1531/*
1532 * Load a value relative to the beginning of the MAC-layer payload.
1533 */
1534static struct slist *
1535gen_load_macplrel(offset, size)
1536        u_int offset, size;
1537{
1538        struct slist *s, *s2;
1539
1540        s = gen_off_macpl();
1541
1542        /*
1543         * If s is non-null, the offset of the MAC-layer payload is
1544         * variable, and s points to a list of instructions that
1545         * arrange that the X register contains that offset.
1546         *
1547         * Otherwise, the offset of the MAC-layer payload is constant,
1548         * and is in off_macpl.
1549         */
1550        if (s != NULL) {
1551                /*
1552                 * The offset of the MAC-layer payload is in the X
1553                 * register.  Do an indirect load, to use the X register
1554                 * as an offset.
1555                 */
1556                s2 = new_stmt(BPF_LD|BPF_IND|size);
1557                s2->s.k = offset;
1558                sappend(s, s2);
1559        } else {
1560                /*
1561                 * The offset of the MAC-layer payload is constant,
1562                 * and is in off_macpl; load the value at that offset
1563                 * plus the specified offset.
1564                 */
1565                s = new_stmt(BPF_LD|BPF_ABS|size);
1566                s->s.k = off_macpl + offset;
1567        }
1568        return s;
1569}
1570
1571/*
1572 * Load a value relative to the beginning of the specified header.
1573 */
1574static struct slist *
1575gen_load_a(offrel, offset, size)
1576        enum e_offrel offrel;
1577        u_int offset, size;
1578{
1579        struct slist *s, *s2;
1580
1581        switch (offrel) {
1582
1583        case OR_PACKET:
1584                s = new_stmt(BPF_LD|BPF_ABS|size);
1585                s->s.k = offset;
1586                break;
1587
1588        case OR_LINK:
1589                s = gen_load_llrel(offset, size);
1590                break;
1591
1592        case OR_MACPL:
1593                s = gen_load_macplrel(offset, size);
1594                break;
1595
1596        case OR_NET:
1597                s = gen_load_macplrel(off_nl + offset, size);
1598                break;
1599
1600        case OR_NET_NOSNAP:
1601                s = gen_load_macplrel(off_nl_nosnap + offset, size);
1602                break;
1603
1604        case OR_TRAN_IPV4:
1605                /*
1606                 * Load the X register with the length of the IPv4 header
1607                 * (plus the offset of the link-layer header, if it's
1608                 * preceded by a variable-length header such as a radio
1609                 * header), in bytes.
1610                 */
1611                s = gen_loadx_iphdrlen();
1612
1613                /*
1614                 * Load the item at {offset of the MAC-layer payload} +
1615                 * {offset, relative to the start of the MAC-layer
1616                 * paylod, of the IPv4 header} + {length of the IPv4 header} +
1617                 * {specified offset}.
1618                 *
1619                 * (If the offset of the MAC-layer payload is variable,
1620                 * it's included in the value in the X register, and
1621                 * off_macpl is 0.)
1622                 */
1623                s2 = new_stmt(BPF_LD|BPF_IND|size);
1624                s2->s.k = off_macpl + off_nl + offset;
1625                sappend(s, s2);
1626                break;
1627
1628        case OR_TRAN_IPV6:
1629                s = gen_load_macplrel(off_nl + 40 + offset, size);
1630                break;
1631
1632        default:
1633                abort();
1634                return NULL;
1635        }
1636        return s;
1637}
1638
1639/*
1640 * Generate code to load into the X register the sum of the length of
1641 * the IPv4 header and any variable-length header preceding the link-layer
1642 * header.
1643 */
1644static struct slist *
1645gen_loadx_iphdrlen()
1646{
1647        struct slist *s, *s2;
1648
1649        s = gen_off_macpl();
1650        if (s != NULL) {
1651                /*
1652                 * There's a variable-length prefix preceding the
1653                 * link-layer header, or the link-layer header is itself
1654                 * variable-length.  "s" points to a list of statements
1655                 * that put the offset of the MAC-layer payload into
1656                 * the X register.
1657                 *
1658                 * The 4*([k]&0xf) addressing mode can't be used, as we
1659                 * don't have a constant offset, so we have to load the
1660                 * value in question into the A register and add to it
1661                 * the value from the X register.
1662                 */
1663                s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
1664                s2->s.k = off_nl;
1665                sappend(s, s2);
1666                s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
1667                s2->s.k = 0xf;
1668                sappend(s, s2);
1669                s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
1670                s2->s.k = 2;
1671                sappend(s, s2);
1672
1673                /*
1674                 * The A register now contains the length of the
1675                 * IP header.  We need to add to it the offset of
1676                 * the MAC-layer payload, which is still in the X
1677                 * register, and move the result into the X register.
1678                 */
1679                sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
1680                sappend(s, new_stmt(BPF_MISC|BPF_TAX));
1681        } else {
1682                /*
1683                 * There is no variable-length header preceding the
1684                 * link-layer header, and the link-layer header is
1685                 * fixed-length; load the length of the IPv4 header,
1686                 * which is at an offset of off_nl from the beginning
1687                 * of the MAC-layer payload, and thus at an offset
1688                 * of off_mac_pl + off_nl from the beginning of the
1689                 * raw packet data.
1690                 */
1691                s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
1692                s->s.k = off_macpl + off_nl;
1693        }
1694        return s;
1695}
1696
1697static struct block *
1698gen_uncond(rsense)
1699        int rsense;
1700{
1701        struct block *b;
1702        struct slist *s;
1703
1704        s = new_stmt(BPF_LD|BPF_IMM);
1705        s->s.k = !rsense;
1706        b = new_block(JMP(BPF_JEQ));
1707        b->stmts = s;
1708
1709        return b;
1710}
1711
1712static inline struct block *
1713gen_true()
1714{
1715        return gen_uncond(1);
1716}
1717
1718static inline struct block *
1719gen_false()
1720{
1721        return gen_uncond(0);
1722}
1723
1724/*
1725 * Byte-swap a 32-bit number.
1726 * ("htonl()" or "ntohl()" won't work - we want to byte-swap even on
1727 * big-endian platforms.)
1728 */
1729#define SWAPLONG(y) \
1730((((y)&0xff)<<24) | (((y)&0xff00)<<8) | (((y)&0xff0000)>>8) | (((y)>>24)&0xff))
1731
1732/*
1733 * Generate code to match a particular packet type.
1734 *
1735 * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
1736 * value, if <= ETHERMTU.  We use that to determine whether to
1737 * match the type/length field or to check the type/length field for
1738 * a value <= ETHERMTU to see whether it's a type field and then do
1739 * the appropriate test.
1740 */
1741static struct block *
1742gen_ether_linktype(proto)
1743        register int proto;
1744{
1745        struct block *b0, *b1;
1746
1747        switch (proto) {
1748
1749        case LLCSAP_ISONS:
1750        case LLCSAP_IP:
1751        case LLCSAP_NETBEUI:
1752                /*
1753                 * OSI protocols and NetBEUI always use 802.2 encapsulation,
1754                 * so we check the DSAP and SSAP.
1755                 *
1756                 * LLCSAP_IP checks for IP-over-802.2, rather
1757                 * than IP-over-Ethernet or IP-over-SNAP.
1758                 *
1759                 * XXX - should we check both the DSAP and the
1760                 * SSAP, like this, or should we check just the
1761                 * DSAP, as we do for other types <= ETHERMTU
1762                 * (i.e., other SAP values)?
1763                 */
1764                b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1765                gen_not(b0);
1766                b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)
1767                             ((proto << 8) | proto));
1768                gen_and(b0, b1);
1769                return b1;
1770
1771        case LLCSAP_IPX:
1772                /*
1773                 * Check for;
1774                 *
1775                 *      Ethernet_II frames, which are Ethernet
1776                 *      frames with a frame type of ETHERTYPE_IPX;
1777                 *
1778                 *      Ethernet_802.3 frames, which are 802.3
1779                 *      frames (i.e., the type/length field is
1780                 *      a length field, <= ETHERMTU, rather than
1781                 *      a type field) with the first two bytes
1782                 *      after the Ethernet/802.3 header being
1783                 *      0xFFFF;
1784                 *
1785                 *      Ethernet_802.2 frames, which are 802.3
1786                 *      frames with an 802.2 LLC header and
1787                 *      with the IPX LSAP as the DSAP in the LLC
1788                 *      header;
1789                 *
1790                 *      Ethernet_SNAP frames, which are 802.3
1791                 *      frames with an LLC header and a SNAP
1792                 *      header and with an OUI of 0x000000
1793                 *      (encapsulated Ethernet) and a protocol
1794                 *      ID of ETHERTYPE_IPX in the SNAP header.
1795                 *
1796                 * XXX - should we generate the same code both
1797                 * for tests for LLCSAP_IPX and for ETHERTYPE_IPX?
1798                 */
1799
1800                /*
1801                 * This generates code to check both for the
1802                 * IPX LSAP (Ethernet_802.2) and for Ethernet_802.3.
1803                 */
1804                b0 = gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
1805                b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)0xFFFF);
1806                gen_or(b0, b1);
1807
1808                /*
1809                 * Now we add code to check for SNAP frames with
1810                 * ETHERTYPE_IPX, i.e. Ethernet_SNAP.
1811                 */
1812                b0 = gen_snap(0x000000, ETHERTYPE_IPX);
1813                gen_or(b0, b1);
1814
1815                /*
1816                 * Now we generate code to check for 802.3
1817                 * frames in general.
1818                 */
1819                b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1820                gen_not(b0);
1821
1822                /*
1823                 * Now add the check for 802.3 frames before the
1824                 * check for Ethernet_802.2 and Ethernet_802.3,
1825                 * as those checks should only be done on 802.3
1826                 * frames, not on Ethernet frames.
1827                 */
1828                gen_and(b0, b1);
1829
1830                /*
1831                 * Now add the check for Ethernet_II frames, and
1832                 * do that before checking for the other frame
1833                 * types.
1834                 */
1835                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
1836                    (bpf_int32)ETHERTYPE_IPX);
1837                gen_or(b0, b1);
1838                return b1;
1839
1840        case ETHERTYPE_ATALK:
1841        case ETHERTYPE_AARP:
1842                /*
1843                 * EtherTalk (AppleTalk protocols on Ethernet link
1844                 * layer) may use 802.2 encapsulation.
1845                 */
1846
1847                /*
1848                 * Check for 802.2 encapsulation (EtherTalk phase 2?);
1849                 * we check for an Ethernet type field less than
1850                 * 1500, which means it's an 802.3 length field.
1851                 */
1852                b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1853                gen_not(b0);
1854
1855                /*
1856                 * 802.2-encapsulated ETHERTYPE_ATALK packets are
1857                 * SNAP packets with an organization code of
1858                 * 0x080007 (Apple, for Appletalk) and a protocol
1859                 * type of ETHERTYPE_ATALK (Appletalk).
1860                 *
1861                 * 802.2-encapsulated ETHERTYPE_AARP packets are
1862                 * SNAP packets with an organization code of
1863                 * 0x000000 (encapsulated Ethernet) and a protocol
1864                 * type of ETHERTYPE_AARP (Appletalk ARP).
1865                 */
1866                if (proto == ETHERTYPE_ATALK)
1867                        b1 = gen_snap(0x080007, ETHERTYPE_ATALK);
1868                else    /* proto == ETHERTYPE_AARP */
1869                        b1 = gen_snap(0x000000, ETHERTYPE_AARP);
1870                gen_and(b0, b1);
1871
1872                /*
1873                 * Check for Ethernet encapsulation (Ethertalk
1874                 * phase 1?); we just check for the Ethernet
1875                 * protocol type.
1876                 */
1877                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
1878
1879                gen_or(b0, b1);
1880                return b1;
1881
1882        default:
1883                if (proto <= ETHERMTU) {
1884                        /*
1885                         * This is an LLC SAP value, so the frames
1886                         * that match would be 802.2 frames.
1887                         * Check that the frame is an 802.2 frame
1888                         * (i.e., that the length/type field is
1889                         * a length field, <= ETHERMTU) and
1890                         * then check the DSAP.
1891                         */
1892                        b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
1893                        gen_not(b0);
1894                        b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,
1895                            (bpf_int32)proto);
1896                        gen_and(b0, b1);
1897                        return b1;
1898                } else {
1899                        /*
1900                         * This is an Ethernet type, so compare
1901                         * the length/type field with it (if
1902                         * the frame is an 802.2 frame, the length
1903                         * field will be <= ETHERMTU, and, as
1904                         * "proto" is > ETHERMTU, this test
1905                         * will fail and the frame won't match,
1906                         * which is what we want).
1907                         */
1908                        return gen_cmp(OR_LINK, off_linktype, BPF_H,
1909                            (bpf_int32)proto);
1910                }
1911        }
1912}
1913
1914/*
1915 * "proto" is an Ethernet type value and for IPNET, if it is not IPv4
1916 * or IPv6 then we have an error.
1917 */
1918static struct block *
1919gen_ipnet_linktype(proto)
1920        register int proto;
1921{
1922        switch (proto) {
1923
1924        case ETHERTYPE_IP:
1925                return gen_cmp(OR_LINK, off_linktype, BPF_B,
1926                    (bpf_int32)IPH_AF_INET);
1927                /* NOTREACHED */
1928
1929        case ETHERTYPE_IPV6:
1930                return gen_cmp(OR_LINK, off_linktype, BPF_B,
1931                    (bpf_int32)IPH_AF_INET6);
1932                /* NOTREACHED */
1933
1934        default:
1935                break;
1936        }
1937
1938        return gen_false();
1939}
1940
1941/*
1942 * Generate code to match a particular packet type.
1943 *
1944 * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
1945 * value, if <= ETHERMTU.  We use that to determine whether to
1946 * match the type field or to check the type field for the special
1947 * LINUX_SLL_P_802_2 value and then do the appropriate test.
1948 */
1949static struct block *
1950gen_linux_sll_linktype(proto)
1951        register int proto;
1952{
1953        struct block *b0, *b1;
1954
1955        switch (proto) {
1956
1957        case LLCSAP_ISONS:
1958        case LLCSAP_IP:
1959        case LLCSAP_NETBEUI:
1960                /*
1961                 * OSI protocols and NetBEUI always use 802.2 encapsulation,
1962                 * so we check the DSAP and SSAP.
1963                 *
1964                 * LLCSAP_IP checks for IP-over-802.2, rather
1965                 * than IP-over-Ethernet or IP-over-SNAP.
1966                 *
1967                 * XXX - should we check both the DSAP and the
1968                 * SSAP, like this, or should we check just the
1969                 * DSAP, as we do for other types <= ETHERMTU
1970                 * (i.e., other SAP values)?
1971                 */
1972                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
1973                b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)
1974                             ((proto << 8) | proto));
1975                gen_and(b0, b1);
1976                return b1;
1977
1978        case LLCSAP_IPX:
1979                /*
1980                 *      Ethernet_II frames, which are Ethernet
1981                 *      frames with a frame type of ETHERTYPE_IPX;
1982                 *
1983                 *      Ethernet_802.3 frames, which have a frame
1984                 *      type of LINUX_SLL_P_802_3;
1985                 *
1986                 *      Ethernet_802.2 frames, which are 802.3
1987                 *      frames with an 802.2 LLC header (i.e, have
1988                 *      a frame type of LINUX_SLL_P_802_2) and
1989                 *      with the IPX LSAP as the DSAP in the LLC
1990                 *      header;
1991                 *
1992                 *      Ethernet_SNAP frames, which are 802.3
1993                 *      frames with an LLC header and a SNAP
1994                 *      header and with an OUI of 0x000000
1995                 *      (encapsulated Ethernet) and a protocol
1996                 *      ID of ETHERTYPE_IPX in the SNAP header.
1997                 *
1998                 * First, do the checks on LINUX_SLL_P_802_2
1999                 * frames; generate the check for either
2000                 * Ethernet_802.2 or Ethernet_SNAP frames, and
2001                 * then put a check for LINUX_SLL_P_802_2 frames
2002                 * before it.
2003                 */
2004                b0 = gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
2005                b1 = gen_snap(0x000000, ETHERTYPE_IPX);
2006                gen_or(b0, b1);
2007                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
2008                gen_and(b0, b1);
2009
2010                /*
2011                 * Now check for 802.3 frames and OR that with
2012                 * the previous test.
2013                 */
2014                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_3);
2015                gen_or(b0, b1);
2016
2017                /*
2018                 * Now add the check for Ethernet_II frames, and
2019                 * do that before checking for the other frame
2020                 * types.
2021                 */
2022                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
2023                    (bpf_int32)ETHERTYPE_IPX);
2024                gen_or(b0, b1);
2025                return b1;
2026
2027        case ETHERTYPE_ATALK:
2028        case ETHERTYPE_AARP:
2029                /*
2030                 * EtherTalk (AppleTalk protocols on Ethernet link
2031                 * layer) may use 802.2 encapsulation.
2032                 */
2033
2034                /*
2035                 * Check for 802.2 encapsulation (EtherTalk phase 2?);
2036                 * we check for the 802.2 protocol type in the
2037                 * "Ethernet type" field.
2038                 */
2039                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
2040
2041                /*
2042                 * 802.2-encapsulated ETHERTYPE_ATALK packets are
2043                 * SNAP packets with an organization code of
2044                 * 0x080007 (Apple, for Appletalk) and a protocol
2045                 * type of ETHERTYPE_ATALK (Appletalk).
2046                 *
2047                 * 802.2-encapsulated ETHERTYPE_AARP packets are
2048                 * SNAP packets with an organization code of
2049                 * 0x000000 (encapsulated Ethernet) and a protocol
2050                 * type of ETHERTYPE_AARP (Appletalk ARP).
2051                 */
2052                if (proto == ETHERTYPE_ATALK)
2053                        b1 = gen_snap(0x080007, ETHERTYPE_ATALK);
2054                else    /* proto == ETHERTYPE_AARP */
2055                        b1 = gen_snap(0x000000, ETHERTYPE_AARP);
2056                gen_and(b0, b1);
2057
2058                /*
2059                 * Check for Ethernet encapsulation (Ethertalk
2060                 * phase 1?); we just check for the Ethernet
2061                 * protocol type.
2062                 */
2063                b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
2064
2065                gen_or(b0, b1);
2066                return b1;
2067
2068        default:
2069                if (proto <= ETHERMTU) {
2070                        /*
2071                         * This is an LLC SAP value, so the frames
2072                         * that match would be 802.2 frames.
2073                         * Check for the 802.2 protocol type
2074                         * in the "Ethernet type" field, and
2075                         * then check the DSAP.
2076                         */
2077                        b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
2078                            LINUX_SLL_P_802_2);
2079                        b1 = gen_cmp(OR_LINK, off_macpl, BPF_B,
2080                             (bpf_int32)proto);
2081                        gen_and(b0, b1);
2082                        return b1;
2083                } else {
2084                        /*
2085                         * This is an Ethernet type, so compare
2086                         * the length/type field with it (if
2087                         * the frame is an 802.2 frame, the length
2088                         * field will be <= ETHERMTU, and, as
2089                         * "proto" is > ETHERMTU, this test
2090                         * will fail and the frame won't match,
2091                         * which is what we want).
2092                         */
2093                        return gen_cmp(OR_LINK, off_linktype, BPF_H,
2094                            (bpf_int32)proto);
2095                }
2096        }
2097}
2098
2099static struct slist *
2100gen_load_prism_llprefixlen()
2101{
2102        struct slist *s1, *s2;
2103        struct slist *sjeq_avs_cookie;
2104        struct slist *sjcommon;
2105
2106        /*
2107         * This code is not compatible with the optimizer, as
2108         * we are generating jmp instructions within a normal
2109         * slist of instructions
2110         */
2111        no_optimize = 1;
2112
2113        /*
2114         * Generate code to load the length of the radio header into
2115         * the register assigned to hold that length, if one has been
2116         * assigned.  (If one hasn't been assigned, no code we've
2117         * generated uses that prefix, so we don't need to generate any
2118         * code to load it.)
2119         *
2120         * Some Linux drivers use ARPHRD_IEEE80211_PRISM but sometimes
2121         * or always use the AVS header rather than the Prism header.
2122         * We load a 4-byte big-endian value at the beginning of the
2123         * raw packet data, and see whether, when masked with 0xFFFFF000,
2124         * it's equal to 0x80211000.  If so, that indicates that it's
2125         * an AVS header (the masked-out bits are the version number).
2126         * Otherwise, it's a Prism header.
2127         *
2128         * XXX - the Prism header is also, in theory, variable-length,
2129         * but no known software generates headers that aren't 144
2130         * bytes long.
2131         */
2132        if (reg_off_ll != -1) {
2133                /*
2134                 * Load the cookie.
2135                 */
2136                s1 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2137                s1->s.k = 0;
2138
2139                /*
2140                 * AND it with 0xFFFFF000.
2141                 */
2142                s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
2143                s2->s.k = 0xFFFFF000;
2144                sappend(s1, s2);
2145
2146                /*
2147                 * Compare with 0x80211000.
2148                 */
2149                sjeq_avs_cookie = new_stmt(JMP(BPF_JEQ));
2150                sjeq_avs_cookie->s.k = 0x80211000;
2151                sappend(s1, sjeq_avs_cookie);
2152
2153                /*
2154                 * If it's AVS:
2155                 *
2156                 * The 4 bytes at an offset of 4 from the beginning of
2157                 * the AVS header are the length of the AVS header.
2158                 * That field is big-endian.
2159                 */
2160                s2 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2161                s2->s.k = 4;
2162                sappend(s1, s2);
2163                sjeq_avs_cookie->s.jt = s2;
2164
2165                /*
2166                 * Now jump to the code to allocate a register
2167                 * into which to save the header length and
2168                 * store the length there.  (The "jump always"
2169                 * instruction needs to have the k field set;
2170                 * it's added to the PC, so, as we're jumping
2171                 * over a single instruction, it should be 1.)
2172                 */
2173                sjcommon = new_stmt(JMP(BPF_JA));
2174                sjcommon->s.k = 1;
2175                sappend(s1, sjcommon);
2176
2177                /*
2178                 * Now for the code that handles the Prism header.
2179                 * Just load the length of the Prism header (144)
2180                 * into the A register.  Have the test for an AVS
2181                 * header branch here if we don't have an AVS header.
2182                 */
2183                s2 = new_stmt(BPF_LD|BPF_W|BPF_IMM);
2184                s2->s.k = 144;
2185                sappend(s1, s2);
2186                sjeq_avs_cookie->s.jf = s2;
2187
2188                /*
2189                 * Now allocate a register to hold that value and store
2190                 * it.  The code for the AVS header will jump here after
2191                 * loading the length of the AVS header.
2192                 */
2193                s2 = new_stmt(BPF_ST);
2194                s2->s.k = reg_off_ll;
2195                sappend(s1, s2);
2196                sjcommon->s.jf = s2;
2197
2198                /*
2199                 * Now move it into the X register.
2200                 */
2201                s2 = new_stmt(BPF_MISC|BPF_TAX);
2202                sappend(s1, s2);
2203
2204                return (s1);
2205        } else
2206                return (NULL);
2207}
2208
2209static struct slist *
2210gen_load_avs_llprefixlen()
2211{
2212        struct slist *s1, *s2;
2213
2214        /*
2215         * Generate code to load the length of the AVS header into
2216         * the register assigned to hold that length, if one has been
2217         * assigned.  (If one hasn't been assigned, no code we've
2218         * generated uses that prefix, so we don't need to generate any
2219         * code to load it.)
2220         */
2221        if (reg_off_ll != -1) {
2222                /*
2223                 * The 4 bytes at an offset of 4 from the beginning of
2224                 * the AVS header are the length of the AVS header.
2225                 * That field is big-endian.
2226                 */
2227                s1 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2228                s1->s.k = 4;
2229
2230                /*
2231                 * Now allocate a register to hold that value and store
2232                 * it.
2233                 */
2234                s2 = new_stmt(BPF_ST);
2235                s2->s.k = reg_off_ll;
2236                sappend(s1, s2);
2237
2238                /*
2239                 * Now move it into the X register.
2240                 */
2241                s2 = new_stmt(BPF_MISC|BPF_TAX);
2242                sappend(s1, s2);
2243
2244                return (s1);
2245        } else
2246                return (NULL);
2247}
2248
2249static struct slist *
2250gen_load_radiotap_llprefixlen()
2251{
2252        struct slist *s1, *s2;
2253
2254        /*
2255         * Generate code to load the length of the radiotap header into
2256         * the register assigned to hold that length, if one has been
2257         * assigned.  (If one hasn't been assigned, no code we've
2258         * generated uses that prefix, so we don't need to generate any
2259         * code to load it.)
2260         */
2261        if (reg_off_ll != -1) {
2262                /*
2263                 * The 2 bytes at offsets of 2 and 3 from the beginning
2264                 * of the radiotap header are the length of the radiotap
2265                 * header; unfortunately, it's little-endian, so we have
2266                 * to load it a byte at a time and construct the value.
2267                 */
2268
2269                /*
2270                 * Load the high-order byte, at an offset of 3, shift it
2271                 * left a byte, and put the result in the X register.
2272                 */
2273                s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2274                s1->s.k = 3;
2275                s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
2276                sappend(s1, s2);
2277                s2->s.k = 8;
2278                s2 = new_stmt(BPF_MISC|BPF_TAX);
2279                sappend(s1, s2);
2280
2281                /*
2282                 * Load the next byte, at an offset of 2, and OR the
2283                 * value from the X register into it.
2284                 */
2285                s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2286                sappend(s1, s2);
2287                s2->s.k = 2;
2288                s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
2289                sappend(s1, s2);
2290
2291                /*
2292                 * Now allocate a register to hold that value and store
2293                 * it.
2294                 */
2295                s2 = new_stmt(BPF_ST);
2296                s2->s.k = reg_off_ll;
2297                sappend(s1, s2);
2298
2299                /*
2300                 * Now move it into the X register.
2301                 */
2302                s2 = new_stmt(BPF_MISC|BPF_TAX);
2303                sappend(s1, s2);
2304
2305                return (s1);
2306        } else
2307                return (NULL);
2308}
2309
2310/*
2311 * At the moment we treat PPI as normal Radiotap encoded
2312 * packets. The difference is in the function that generates
2313 * the code at the beginning to compute the header length.
2314 * Since this code generator of PPI supports bare 802.11
2315 * encapsulation only (i.e. the encapsulated DLT should be
2316 * DLT_IEEE802_11) we generate code to check for this too;
2317 * that's done in finish_parse().
2318 */
2319static struct slist *
2320gen_load_ppi_llprefixlen()
2321{
2322        struct slist *s1, *s2;
2323
2324        /*
2325         * Generate code to load the length of the radiotap header
2326         * into the register assigned to hold that length, if one has
2327         * been assigned.
2328         */
2329        if (reg_off_ll != -1) {
2330                /*
2331                 * The 2 bytes at offsets of 2 and 3 from the beginning
2332                 * of the radiotap header are the length of the radiotap
2333                 * header; unfortunately, it's little-endian, so we have
2334                 * to load it a byte at a time and construct the value.
2335                 */
2336
2337                /*
2338                 * Load the high-order byte, at an offset of 3, shift it
2339                 * left a byte, and put the result in the X register.
2340                 */
2341                s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2342                s1->s.k = 3;
2343                s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
2344                sappend(s1, s2);
2345                s2->s.k = 8;
2346                s2 = new_stmt(BPF_MISC|BPF_TAX);
2347                sappend(s1, s2);
2348
2349                /*
2350                 * Load the next byte, at an offset of 2, and OR the
2351                 * value from the X register into it.
2352                 */
2353                s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2354                sappend(s1, s2);
2355                s2->s.k = 2;
2356                s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
2357                sappend(s1, s2);
2358
2359                /*
2360                 * Now allocate a register to hold that value and store
2361                 * it.
2362                 */
2363                s2 = new_stmt(BPF_ST);
2364                s2->s.k = reg_off_ll;
2365                sappend(s1, s2);
2366
2367                /*
2368                 * Now move it into the X register.
2369                 */
2370                s2 = new_stmt(BPF_MISC|BPF_TAX);
2371                sappend(s1, s2);
2372
2373                return (s1);
2374        } else
2375                return (NULL);
2376}
2377
2378/*
2379 * Load a value relative to the beginning of the link-layer header after the 802.11
2380 * header, i.e. LLC_SNAP.
2381 * The link-layer header doesn't necessarily begin at the beginning
2382 * of the packet data; there might be a variable-length prefix containing
2383 * radio information.
2384 */
2385static struct slist *
2386gen_load_802_11_header_len(struct slist *s, struct slist *snext)
2387{
2388        struct slist *s2;
2389        struct slist *sjset_data_frame_1;
2390        struct slist *sjset_data_frame_2;
2391        struct slist *sjset_qos;
2392        struct slist *sjset_radiotap_flags;
2393        struct slist *sjset_radiotap_tsft;
2394        struct slist *sjset_tsft_datapad, *sjset_notsft_datapad;
2395        struct slist *s_roundup;
2396
2397        if (reg_off_macpl == -1) {
2398                /*
2399                 * No register has been assigned to the offset of
2400                 * the MAC-layer payload, which means nobody needs
2401                 * it; don't bother computing it - just return
2402                 * what we already have.
2403                 */
2404                return (s);
2405        }
2406
2407        /*
2408         * This code is not compatible with the optimizer, as
2409         * we are generating jmp instructions within a normal
2410         * slist of instructions
2411         */
2412        no_optimize = 1;
2413
2414        /*
2415         * If "s" is non-null, it has code to arrange that the X register
2416         * contains the length of the prefix preceding the link-layer
2417         * header.
2418         *
2419         * Otherwise, the length of the prefix preceding the link-layer
2420         * header is "off_ll".
2421         */
2422        if (s == NULL) {
2423                /*
2424                 * There is no variable-length header preceding the
2425                 * link-layer header.
2426                 *
2427                 * Load the length of the fixed-length prefix preceding
2428                 * the link-layer header (if any) into the X register,
2429                 * and store it in the reg_off_macpl register.
2430                 * That length is off_ll.
2431                 */
2432                s = new_stmt(BPF_LDX|BPF_IMM);
2433                s->s.k = off_ll;
2434        }
2435
2436        /*
2437         * The X register contains the offset of the beginning of the
2438         * link-layer header; add 24, which is the minimum length
2439         * of the MAC header for a data frame, to that, and store it
2440         * in reg_off_macpl, and then load the Frame Control field,
2441         * which is at the offset in the X register, with an indexed load.
2442         */
2443        s2 = new_stmt(BPF_MISC|BPF_TXA);
2444        sappend(s, s2);
2445        s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
2446        s2->s.k = 24;
2447        sappend(s, s2);
2448        s2 = new_stmt(BPF_ST);
2449        s2->s.k = reg_off_macpl;
2450        sappend(s, s2);
2451
2452        s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
2453        s2->s.k = 0;
2454        sappend(s, s2);
2455
2456        /*
2457         * Check the Frame Control field to see if this is a data frame;
2458         * a data frame has the 0x08 bit (b3) in that field set and the
2459         * 0x04 bit (b2) clear.
2460         */
2461        sjset_data_frame_1 = new_stmt(JMP(BPF_JSET));
2462        sjset_data_frame_1->s.k = 0x08;
2463        sappend(s, sjset_data_frame_1);
2464
2465        /*
2466         * If b3 is set, test b2, otherwise go to the first statement of
2467         * the rest of the program.
2468         */
2469        sjset_data_frame_1->s.jt = sjset_data_frame_2 = new_stmt(JMP(BPF_JSET));
2470        sjset_data_frame_2->s.k = 0x04;
2471        sappend(s, sjset_data_frame_2);
2472        sjset_data_frame_1->s.jf = snext;
2473
2474        /*
2475         * If b2 is not set, this is a data frame; test the QoS bit.
2476         * Otherwise, go to the first statement of the rest of the
2477         * program.
2478         */
2479        sjset_data_frame_2->s.jt = snext;
2480        sjset_data_frame_2->s.jf = sjset_qos = new_stmt(JMP(BPF_JSET));
2481        sjset_qos->s.k = 0x80;  /* QoS bit */
2482        sappend(s, sjset_qos);
2483
2484        /*
2485         * If it's set, add 2 to reg_off_macpl, to skip the QoS
2486         * field.
2487         * Otherwise, go to the first statement of the rest of the
2488         * program.
2489         */
2490        sjset_qos->s.jt = s2 = new_stmt(BPF_LD|BPF_MEM);
2491        s2->s.k = reg_off_macpl;
2492        sappend(s, s2);
2493        s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_IMM);
2494        s2->s.k = 2;
2495        sappend(s, s2);
2496        s2 = new_stmt(BPF_ST);
2497        s2->s.k = reg_off_macpl;
2498        sappend(s, s2);
2499
2500        /*
2501         * If we have a radiotap header, look at it to see whether
2502         * there's Atheros padding between the MAC-layer header
2503         * and the payload.
2504         *
2505         * Note: all of the fields in the radiotap header are
2506         * little-endian, so we byte-swap all of the values
2507         * we test against, as they will be loaded as big-endian
2508         * values.
2509         */
2510        if (linktype == DLT_IEEE802_11_RADIO) {
2511                /*
2512                 * Is the IEEE80211_RADIOTAP_FLAGS bit (0x0000002) set
2513                 * in the presence flag?
2514                 */
2515                sjset_qos->s.jf = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_W);
2516                s2->s.k = 4;
2517                sappend(s, s2);
2518
2519                sjset_radiotap_flags = new_stmt(JMP(BPF_JSET));
2520                sjset_radiotap_flags->s.k = SWAPLONG(0x00000002);
2521                sappend(s, sjset_radiotap_flags);
2522
2523                /*
2524                 * If not, skip all of this.
2525                 */
2526                sjset_radiotap_flags->s.jf = snext;
2527
2528                /*
2529                 * Otherwise, is the IEEE80211_RADIOTAP_TSFT bit set?
2530                 */
2531                sjset_radiotap_tsft = sjset_radiotap_flags->s.jt =
2532                    new_stmt(JMP(BPF_JSET));
2533                sjset_radiotap_tsft->s.k = SWAPLONG(0x00000001);
2534                sappend(s, sjset_radiotap_tsft);
2535
2536                /*
2537                 * If IEEE80211_RADIOTAP_TSFT is set, the flags field is
2538                 * at an offset of 16 from the beginning of the raw packet
2539                 * data (8 bytes for the radiotap header and 8 bytes for
2540                 * the TSFT field).
2541                 *
2542                 * Test whether the IEEE80211_RADIOTAP_F_DATAPAD bit (0x20)
2543                 * is set.
2544                 */
2545                sjset_radiotap_tsft->s.jt = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_B);
2546                s2->s.k = 16;
2547                sappend(s, s2);
2548
2549                sjset_tsft_datapad = new_stmt(JMP(BPF_JSET));
2550                sjset_tsft_datapad->s.k = 0x20;
2551                sappend(s, sjset_tsft_datapad);
2552
2553                /*
2554                 * If IEEE80211_RADIOTAP_TSFT is not set, the flags field is
2555                 * at an offset of 8 from the beginning of the raw packet
2556                 * data (8 bytes for the radiotap header).
2557                 *
2558                 * Test whether the IEEE80211_RADIOTAP_F_DATAPAD bit (0x20)
2559                 * is set.
2560                 */
2561                sjset_radiotap_tsft->s.jf = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_B);
2562                s2->s.k = 8;
2563                sappend(s, s2);
2564
2565                sjset_notsft_datapad = new_stmt(JMP(BPF_JSET));
2566                sjset_notsft_datapad->s.k = 0x20;
2567                sappend(s, sjset_notsft_datapad);
2568
2569                /*
2570                 * In either case, if IEEE80211_RADIOTAP_F_DATAPAD is
2571                 * set, round the length of the 802.11 header to
2572                 * a multiple of 4.  Do that by adding 3 and then
2573                 * dividing by and multiplying by 4, which we do by
2574                 * ANDing with ~3.
2575                 */
2576                s_roundup = new_stmt(BPF_LD|BPF_MEM);
2577                s_roundup->s.k = reg_off_macpl;
2578                sappend(s, s_roundup);
2579                s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_IMM);
2580                s2->s.k = 3;
2581                sappend(s, s2);
2582                s2 = new_stmt(BPF_ALU|BPF_AND|BPF_IMM);
2583                s2->s.k = ~3;
2584                sappend(s, s2);
2585                s2 = new_stmt(BPF_ST);
2586                s2->s.k = reg_off_macpl;
2587                sappend(s, s2);
2588
2589                sjset_tsft_datapad->s.jt = s_roundup;
2590                sjset_tsft_datapad->s.jf = snext;
2591                sjset_notsft_datapad->s.jt = s_roundup;
2592                sjset_notsft_datapad->s.jf = snext;
2593        } else
2594                sjset_qos->s.jf = snext;
2595
2596        return s;
2597}
2598
2599static void
2600insert_compute_vloffsets(b)
2601        struct block *b;
2602{
2603        struct slist *s;
2604
2605        /*
2606         * For link-layer types that have a variable-length header
2607         * preceding the link-layer header, generate code to load
2608         * the offset of the link-layer header into the register
2609         * assigned to that offset, if any.
2610         */
2611        switch (linktype) {
2612
2613        case DLT_PRISM_HEADER:
2614                s = gen_load_prism_llprefixlen();
2615                break;
2616
2617        case DLT_IEEE802_11_RADIO_AVS:
2618                s = gen_load_avs_llprefixlen();
2619                break;
2620
2621        case DLT_IEEE802_11_RADIO:
2622                s = gen_load_radiotap_llprefixlen();
2623                break;
2624
2625        case DLT_PPI:
2626                s = gen_load_ppi_llprefixlen();
2627                break;
2628
2629        default:
2630                s = NULL;
2631                break;
2632        }
2633
2634        /*
2635         * For link-layer types that have a variable-length link-layer
2636         * header, generate code to load the offset of the MAC-layer
2637         * payload into the register assigned to that offset, if any.
2638         */
2639        switch (linktype) {
2640
2641        case DLT_IEEE802_11:
2642        case DLT_PRISM_HEADER:
2643        case DLT_IEEE802_11_RADIO_AVS:
2644        case DLT_IEEE802_11_RADIO:
2645        case DLT_PPI:
2646                s = gen_load_802_11_header_len(s, b->stmts);
2647                break;
2648        }
2649
2650        /*
2651         * If we have any offset-loading code, append all the
2652         * existing statements in the block to those statements,
2653         * and make the resulting list the list of statements
2654         * for the block.
2655         */
2656        if (s != NULL) {
2657                sappend(s, b->stmts);
2658                b->stmts = s;
2659        }
2660}
2661
2662static struct block *
2663gen_ppi_dlt_check(void)
2664{
2665        struct slist *s_load_dlt;
2666        struct block *b;
2667
2668        if (linktype == DLT_PPI)
2669        {
2670                /* Create the statements that check for the DLT
2671                 */
2672                s_load_dlt = new_stmt(BPF_LD|BPF_W|BPF_ABS);
2673                s_load_dlt->s.k = 4;
2674
2675                b = new_block(JMP(BPF_JEQ));
2676
2677                b->stmts = s_load_dlt;
2678                b->s.k = SWAPLONG(DLT_IEEE802_11);
2679        }
2680        else
2681        {
2682                b = NULL;
2683        }
2684
2685        return b;
2686}
2687
2688static struct slist *
2689gen_prism_llprefixlen(void)
2690{
2691        struct slist *s;
2692
2693        if (reg_off_ll == -1) {
2694                /*
2695                 * We haven't yet assigned a register for the length
2696                 * of the radio header; allocate one.
2697                 */
2698                reg_off_ll = alloc_reg();
2699        }
2700
2701        /*
2702         * Load the register containing the radio length
2703         * into the X register.
2704         */
2705        s = new_stmt(BPF_LDX|BPF_MEM);
2706        s->s.k = reg_off_ll;
2707        return s;
2708}
2709
2710static struct slist *
2711gen_avs_llprefixlen(void)
2712{
2713        struct slist *s;
2714
2715        if (reg_off_ll == -1) {
2716                /*
2717                 * We haven't yet assigned a register for the length
2718                 * of the AVS header; allocate one.
2719                 */
2720                reg_off_ll = alloc_reg();
2721        }
2722
2723        /*
2724         * Load the register containing the AVS length
2725         * into the X register.
2726         */
2727        s = new_stmt(BPF_LDX|BPF_MEM);
2728        s->s.k = reg_off_ll;
2729        return s;
2730}
2731
2732static struct slist *
2733gen_radiotap_llprefixlen(void)
2734{
2735        struct slist *s;
2736
2737        if (reg_off_ll == -1) {
2738                /*
2739                 * We haven't yet assigned a register for the length
2740                 * of the radiotap header; allocate one.
2741                 */
2742                reg_off_ll = alloc_reg();
2743        }
2744
2745        /*
2746         * Load the register containing the radiotap length
2747         * into the X register.
2748         */
2749        s = new_stmt(BPF_LDX|BPF_MEM);
2750        s->s.k = reg_off_ll;
2751        return s;
2752}
2753
2754/*
2755 * At the moment we treat PPI as normal Radiotap encoded
2756 * packets. The difference is in the function that generates
2757 * the code at the beginning to compute the header length.
2758 * Since this code generator of PPI supports bare 802.11
2759 * encapsulation only (i.e. the encapsulated DLT should be
2760 * DLT_IEEE802_11) we generate code to check for this too.
2761 */
2762static struct slist *
2763gen_ppi_llprefixlen(void)
2764{
2765        struct slist *s;
2766
2767        if (reg_off_ll == -1) {
2768                /*
2769                 * We haven't yet assigned a register for the length
2770                 * of the radiotap header; allocate one.
2771                 */
2772                reg_off_ll = alloc_reg();
2773        }
2774
2775        /*
2776         * Load the register containing the PPI length
2777         * into the X register.
2778         */
2779        s = new_stmt(BPF_LDX|BPF_MEM);
2780        s->s.k = reg_off_ll;
2781        return s;
2782}
2783
2784/*
2785 * Generate code to compute the link-layer header length, if necessary,
2786 * putting it into the X register, and to return either a pointer to a
2787 * "struct slist" for the list of statements in that code, or NULL if
2788 * no code is necessary.
2789 */
2790static struct slist *
2791gen_llprefixlen(void)
2792{
2793        switch (linktype) {
2794
2795        case DLT_PRISM_HEADER:
2796                return gen_prism_llprefixlen();
2797
2798        case DLT_IEEE802_11_RADIO_AVS:
2799                return gen_avs_llprefixlen();
2800
2801        case DLT_IEEE802_11_RADIO:
2802                return gen_radiotap_llprefixlen();
2803
2804        case DLT_PPI:
2805                return gen_ppi_llprefixlen();
2806
2807        default:
2808                return NULL;
2809        }
2810}
2811
2812/*
2813 * Generate code to load the register containing the offset of the
2814 * MAC-layer payload into the X register; if no register for that offset
2815 * has been allocated, allocate it first.
2816 */
2817static struct slist *
2818gen_off_macpl(void)
2819{
2820        struct slist *s;
2821
2822        if (off_macpl_is_variable) {
2823                if (reg_off_macpl == -1) {
2824                        /*
2825                         * We haven't yet assigned a register for the offset
2826                         * of the MAC-layer payload; allocate one.
2827                         */
2828                        reg_off_macpl = alloc_reg();
2829                }
2830
2831                /*
2832                 * Load the register containing the offset of the MAC-layer
2833                 * payload into the X register.
2834                 */
2835                s = new_stmt(BPF_LDX|BPF_MEM);
2836                s->s.k = reg_off_macpl;
2837                return s;
2838        } else {
2839                /*
2840                 * That offset isn't variable, so we don't need to
2841                 * generate any code.
2842                 */
2843                return NULL;
2844        }
2845}
2846
2847/*
2848 * Map an Ethernet type to the equivalent PPP type.
2849 */
2850static int
2851ethertype_to_ppptype(proto)
2852        int proto;
2853{
2854        switch (proto) {
2855
2856        case ETHERTYPE_IP:
2857                proto = PPP_IP;
2858                break;
2859
2860        case ETHERTYPE_IPV6:
2861                proto = PPP_IPV6;
2862                break;
2863
2864        case ETHERTYPE_DN:
2865                proto = PPP_DECNET;
2866                break;
2867
2868        case ETHERTYPE_ATALK:
2869                proto = PPP_APPLE;
2870                break;
2871
2872        case ETHERTYPE_NS:
2873                proto = PPP_NS;
2874                break;
2875
2876        case LLCSAP_ISONS:
2877                proto = PPP_OSI;
2878                break;
2879
2880        case LLCSAP_8021D:
2881                /*
2882                 * I'm assuming the "Bridging PDU"s that go
2883                 * over PPP are Spanning Tree Protocol
2884                 * Bridging PDUs.
2885                 */
2886                proto = PPP_BRPDU;
2887                break;
2888
2889        case LLCSAP_IPX:
2890                proto = PPP_IPX;
2891                break;
2892        }
2893        return (proto);
2894}
2895
2896/*
2897 * Generate code to match a particular packet type by matching the
2898 * link-layer type field or fields in the 802.2 LLC header.
2899 *
2900 * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
2901 * value, if <= ETHERMTU.
2902 */
2903static struct block *
2904gen_linktype(proto)
2905        register int proto;
2906{
2907        struct block *b0, *b1, *b2;
2908
2909        /* are we checking MPLS-encapsulated packets? */
2910        if (label_stack_depth > 0) {
2911                switch (proto) {
2912                case ETHERTYPE_IP:
2913                case PPP_IP:
2914                        /* FIXME add other L3 proto IDs */
2915                        return gen_mpls_linktype(Q_IP);
2916
2917                case ETHERTYPE_IPV6:
2918                case PPP_IPV6:
2919                        /* FIXME add other L3 proto IDs */
2920                        return gen_mpls_linktype(Q_IPV6);
2921
2922                default:
2923                        bpf_error("unsupported protocol over mpls");
2924                        /* NOTREACHED */
2925                }
2926        }
2927
2928        /*
2929         * Are we testing PPPoE packets?
2930         */
2931        if (is_pppoes) {
2932                /*
2933                 * The PPPoE session header is part of the
2934                 * MAC-layer payload, so all references
2935                 * should be relative to the beginning of
2936                 * that payload.
2937                 */
2938
2939                /*
2940                 * We use Ethernet protocol types inside libpcap;
2941                 * map them to the corresponding PPP protocol types.
2942                 */
2943                proto = ethertype_to_ppptype(proto);
2944                return gen_cmp(OR_MACPL, off_linktype, BPF_H, (bpf_int32)proto);
2945        }
2946
2947        switch (linktype) {
2948
2949        case DLT_EN10MB:
2950        case DLT_NETANALYZER:
2951        case DLT_NETANALYZER_TRANSPARENT:
2952                return gen_ether_linktype(proto);
2953                /*NOTREACHED*/
2954                break;
2955
2956        case DLT_C_HDLC:
2957                switch (proto) {
2958
2959                case LLCSAP_ISONS:
2960                        proto = (proto << 8 | LLCSAP_ISONS);
2961                        /* fall through */
2962
2963                default:
2964                        return gen_cmp(OR_LINK, off_linktype, BPF_H,
2965                            (bpf_int32)proto);
2966                        /*NOTREACHED*/
2967                        break;
2968                }
2969                break;
2970
2971        case DLT_IEEE802_11:
2972        case DLT_PRISM_HEADER:
2973        case DLT_IEEE802_11_RADIO_AVS:
2974        case DLT_IEEE802_11_RADIO:
2975        case DLT_PPI:
2976                /*
2977                 * Check that we have a data frame.
2978                 */
2979                b0 = gen_check_802_11_data_frame();
2980
2981                /*
2982                 * Now check for the specified link-layer type.
2983                 */
2984                b1 = gen_llc_linktype(proto);
2985                gen_and(b0, b1);
2986                return b1;
2987                /*NOTREACHED*/
2988                break;
2989
2990        case DLT_FDDI:
2991                /*
2992                 * XXX - check for asynchronous frames, as per RFC 1103.
2993                 */
2994                return gen_llc_linktype(proto);
2995                /*NOTREACHED*/
2996                break;
2997
2998        case DLT_IEEE802:
2999                /*
3000                 * XXX - check for LLC PDUs, as per IEEE 802.5.
3001                 */
3002                return gen_llc_linktype(proto);
3003                /*NOTREACHED*/
3004                break;
3005
3006        case DLT_ATM_RFC1483:
3007        case DLT_ATM_CLIP:
3008        case DLT_IP_OVER_FC:
3009                return gen_llc_linktype(proto);
3010                /*NOTREACHED*/
3011                break;
3012
3013        case DLT_SUNATM:
3014                /*
3015                 * If "is_lane" is set, check for a LANE-encapsulated
3016                 * version of this protocol, otherwise check for an
3017                 * LLC-encapsulated version of this protocol.
3018                 *
3019                 * We assume LANE means Ethernet, not Token Ring.
3020                 */
3021                if (is_lane) {
3022                        /*
3023                         * Check that the packet doesn't begin with an
3024                         * LE Control marker.  (We've already generated
3025                         * a test for LANE.)
3026                         */
3027                        b0 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
3028                            0xFF00);
3029                        gen_not(b0);
3030
3031                        /*
3032                         * Now generate an Ethernet test.
3033                         */
3034                        b1 = gen_ether_linktype(proto);
3035                        gen_and(b0, b1);
3036                        return b1;
3037                } else {
3038                        /*
3039                         * Check for LLC encapsulation and then check the
3040                         * protocol.
3041                         */
3042                        b0 = gen_atmfield_code(A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
3043                        b1 = gen_llc_linktype(proto);
3044                        gen_and(b0, b1);
3045                        return b1;
3046                }
3047                /*NOTREACHED*/
3048                break;
3049
3050        case DLT_LINUX_SLL:
3051                return gen_linux_sll_linktype(proto);
3052                /*NOTREACHED*/
3053                break;
3054
3055        case DLT_SLIP:
3056        case DLT_SLIP_BSDOS:
3057        case DLT_RAW:
3058                /*
3059                 * These types don't provide any type field; packets
3060                 * are always IPv4 or IPv6.
3061                 *
3062                 * XXX - for IPv4, check for a version number of 4, and,
3063                 * for IPv6, check for a version number of 6?
3064                 */
3065                switch (proto) {
3066
3067                case ETHERTYPE_IP:
3068                        /* Check for a version number of 4. */
3069                        return gen_mcmp(OR_LINK, 0, BPF_B, 0x40, 0xF0);
3070
3071                case ETHERTYPE_IPV6:
3072                        /* Check for a version number of 6. */
3073                        return gen_mcmp(OR_LINK, 0, BPF_B, 0x60, 0xF0);
3074
3075                default:
3076                        return gen_false();             /* always false */
3077                }
3078                /*NOTREACHED*/
3079                break;
3080
3081        case DLT_IPV4:
3082                /*
3083                 * Raw IPv4, so no type field.
3084                 */
3085                if (proto == ETHERTYPE_IP)
3086                        return gen_true();              /* always true */
3087
3088                /* Checking for something other than IPv4; always false */
3089                return gen_false();
3090                /*NOTREACHED*/
3091                break;
3092
3093        case DLT_IPV6:
3094                /*
3095                 * Raw IPv6, so no type field.
3096                 */
3097                if (proto == ETHERTYPE_IPV6)
3098                        return gen_true();              /* always true */
3099
3100                /* Checking for something other than IPv6; always false */
3101                return gen_false();
3102                /*NOTREACHED*/
3103                break;
3104
3105        case DLT_PPP:
3106        case DLT_PPP_PPPD:
3107        case DLT_PPP_SERIAL:
3108        case DLT_PPP_ETHER:
3109                /*
3110                 * We use Ethernet protocol types inside libpcap;
3111                 * map them to the corresponding PPP protocol types.
3112                 */
3113                proto = ethertype_to_ppptype(proto);
3114                return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
3115                /*NOTREACHED*/
3116                break;
3117
3118        case DLT_PPP_BSDOS:
3119                /*
3120                 * We use Ethernet protocol types inside libpcap;
3121                 * map them to the corresponding PPP protocol types.
3122                 */
3123                switch (proto) {
3124
3125                case ETHERTYPE_IP:
3126                        /*
3127                         * Also check for Van Jacobson-compressed IP.
3128                         * XXX - do this for other forms of PPP?
3129                         */
3130                        b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_IP);
3131                        b1 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJC);
3132                        gen_or(b0, b1);
3133                        b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJNC);
3134                        gen_or(b1, b0);
3135                        return b0;
3136
3137                default:
3138                        proto = ethertype_to_ppptype(proto);
3139                        return gen_cmp(OR_LINK, off_linktype, BPF_H,
3140                                (bpf_int32)proto);
3141                }
3142                /*NOTREACHED*/
3143                break;
3144
3145        case DLT_NULL:
3146        case DLT_LOOP:
3147        case DLT_ENC:
3148                /*
3149                 * For DLT_NULL, the link-layer header is a 32-bit
3150                 * word containing an AF_ value in *host* byte order,
3151                 * and for DLT_ENC, the link-layer header begins
3152                 * with a 32-bit work containing an AF_ value in
3153                 * host byte order.
3154                 *
3155                 * In addition, if we're reading a saved capture file,
3156                 * the host byte order in the capture may not be the
3157                 * same as the host byte order on this machine.
3158                 *
3159                 * For DLT_LOOP, the link-layer header is a 32-bit
3160                 * word containing an AF_ value in *network* byte order.
3161                 *
3162                 * XXX - AF_ values may, unfortunately, be platform-
3163                 * dependent; for example, FreeBSD's AF_INET6 is 24
3164                 * whilst NetBSD's and OpenBSD's is 26.
3165                 *
3166                 * This means that, when reading a capture file, just
3167                 * checking for our AF_INET6 value won't work if the
3168                 * capture file came from another OS.
3169                 */
3170                switch (proto) {
3171
3172                case ETHERTYPE_IP:
3173                        proto = AF_INET;
3174                        break;
3175
3176#ifdef INET6
3177                case ETHERTYPE_IPV6:
3178                        proto = AF_INET6;
3179                        break;
3180#endif
3181
3182                default:
3183                        /*
3184                         * Not a type on which we support filtering.
3185                         * XXX - support those that have AF_ values
3186                         * #defined on this platform, at least?
3187                         */
3188                        return gen_false();
3189                }
3190
3191                if (linktype == DLT_NULL || linktype == DLT_ENC) {
3192                        /*
3193                         * The AF_ value is in host byte order, but
3194                         * the BPF interpreter will convert it to
3195                         * network byte order.
3196                         *
3197                         * If this is a save file, and it's from a
3198                         * machine with the opposite byte order to
3199                         * ours, we byte-swap the AF_ value.
3200                         *
3201                         * Then we run it through "htonl()", and
3202                         * generate code to compare against the result.
3203                         */
3204                        if (bpf_pcap->sf.rfile != NULL &&
3205                            bpf_pcap->sf.swapped)
3206                                proto = SWAPLONG(proto);
3207                        proto = htonl(proto);
3208                }
3209                return (gen_cmp(OR_LINK, 0, BPF_W, (bpf_int32)proto));
3210
3211#ifdef HAVE_NET_PFVAR_H
3212        case DLT_PFLOG:
3213                /*
3214                 * af field is host byte order in contrast to the rest of
3215                 * the packet.
3216                 */
3217                if (proto == ETHERTYPE_IP)
3218                        return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
3219                            BPF_B, (bpf_int32)AF_INET));
3220                else if (proto == ETHERTYPE_IPV6)
3221                        return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
3222                            BPF_B, (bpf_int32)AF_INET6));
3223                else
3224                        return gen_false();
3225                /*NOTREACHED*/
3226                break;
3227#endif /* HAVE_NET_PFVAR_H */
3228
3229        case DLT_ARCNET:
3230        case DLT_ARCNET_LINUX:
3231                /*
3232                 * XXX should we check for first fragment if the protocol
3233                 * uses PHDS?
3234                 */
3235                switch (proto) {
3236
3237                default:
3238                        return gen_false();
3239
3240                case ETHERTYPE_IPV6:
3241                        return (gen_cmp(OR_LINK, off_linktype, BPF_B,
3242                                (bpf_int32)ARCTYPE_INET6));
3243
3244                case ETHERTYPE_IP:
3245                        b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3246                                     (bpf_int32)ARCTYPE_IP);
3247                        b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3248                                     (bpf_int32)ARCTYPE_IP_OLD);
3249                        gen_or(b0, b1);
3250                        return (b1);
3251
3252                case ETHERTYPE_ARP:
3253                        b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3254                                     (bpf_int32)ARCTYPE_ARP);
3255                        b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
3256                                     (bpf_int32)ARCTYPE_ARP_OLD);
3257                        gen_or(b0, b1);
3258                        return (b1);
3259
3260                case ETHERTYPE_REVARP:
3261                        return (gen_cmp(OR_LINK, off_linktype, BPF_B,
3262                                        (bpf_int32)ARCTYPE_REVARP));
3263
3264                case ETHERTYPE_ATALK:
3265                        return (gen_cmp(OR_LINK, off_linktype, BPF_B,
3266                                        (bpf_int32)ARCTYPE_ATALK));
3267                }
3268                /*NOTREACHED*/
3269                break;
3270
3271        case DLT_LTALK:
3272                switch (proto) {
3273                case ETHERTYPE_ATALK:
3274                        return gen_true();
3275                default:
3276                        return gen_false();
3277                }
3278                /*NOTREACHED*/
3279                break;
3280
3281        case DLT_FRELAY:
3282                /*
3283                 * XXX - assumes a 2-byte Frame Relay header with
3284                 * DLCI and flags.  What if the address is longer?
3285                 */
3286                switch (proto) {
3287
3288                case ETHERTYPE_IP:
3289                        /*
3290                         * Check for the special NLPID for IP.
3291                         */
3292                        return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0xcc);
3293
3294                case ETHERTYPE_IPV6:
3295                        /*
3296                         * Check for the special NLPID for IPv6.
3297                         */
3298                        return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0x8e);
3299
3300                case LLCSAP_ISONS:
3301                        /*
3302                         * Check for several OSI protocols.
3303                         *
3304                         * Frame Relay packets typically have an OSI
3305                         * NLPID at the beginning; we check for each
3306                         * of them.
3307                         *
3308                         * What we check for is the NLPID and a frame
3309                         * control field of UI, i.e. 0x03 followed
3310                         * by the NLPID.
3311                         */
3312                        b0 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
3313                        b1 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
3314                        b2 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);
3315                        gen_or(b1, b2);
3316                        gen_or(b0, b2);
3317                        return b2;
3318
3319                default:
3320                        return gen_false();
3321                }
3322                /*NOTREACHED*/
3323                break;
3324
3325        case DLT_MFR:
3326                bpf_error("Multi-link Frame Relay link-layer type filtering not implemented");
3327
3328        case DLT_JUNIPER_MFR:
3329        case DLT_JUNIPER_MLFR:
3330        case DLT_JUNIPER_MLPPP:
3331        case DLT_JUNIPER_ATM1:
3332        case DLT_JUNIPER_ATM2:
3333        case DLT_JUNIPER_PPPOE:
3334        case DLT_JUNIPER_PPPOE_ATM:
3335        case DLT_JUNIPER_GGSN:
3336        case DLT_JUNIPER_ES:
3337        case DLT_JUNIPER_MONITOR:
3338        case DLT_JUNIPER_SERVICES:
3339        case DLT_JUNIPER_ETHER:
3340        case DLT_JUNIPER_PPP:
3341        case DLT_JUNIPER_FRELAY:
3342        case DLT_JUNIPER_CHDLC:
3343        case DLT_JUNIPER_VP:
3344        case DLT_JUNIPER_ST:
3345        case DLT_JUNIPER_ISM:
3346        case DLT_JUNIPER_VS:
3347        case DLT_JUNIPER_SRX_E2E:
3348        case DLT_JUNIPER_FIBRECHANNEL:
3349        case DLT_JUNIPER_ATM_CEMIC:
3350
3351                /* just lets verify the magic number for now -
3352                 * on ATM we may have up to 6 different encapsulations on the wire
3353                 * and need a lot of heuristics to figure out that the payload
3354                 * might be;
3355                 *
3356                 * FIXME encapsulation specific BPF_ filters
3357                 */
3358                return gen_mcmp(OR_LINK, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
3359
3360        case DLT_IPNET:
3361                return gen_ipnet_linktype(proto);
3362
3363        case DLT_LINUX_IRDA:
3364                bpf_error("IrDA link-layer type filtering not implemented");
3365
3366        case DLT_DOCSIS:
3367                bpf_error("DOCSIS link-layer type filtering not implemented");
3368
3369        case DLT_MTP2:
3370        case DLT_MTP2_WITH_PHDR:
3371                bpf_error("MTP2 link-layer type filtering not implemented");
3372
3373        case DLT_ERF:
3374                bpf_error("ERF link-layer type filtering not implemented");
3375
3376        case DLT_PFSYNC:
3377                bpf_error("PFSYNC link-layer type filtering not implemented");
3378
3379        case DLT_LINUX_LAPD:
3380                bpf_error("LAPD link-layer type filtering not implemented");
3381
3382        case DLT_USB:
3383        case DLT_USB_LINUX:
3384        case DLT_USB_LINUX_MMAPPED:
3385                bpf_error("USB link-layer type filtering not implemented");
3386
3387        case DLT_BLUETOOTH_HCI_H4:
3388        case DLT_BLUETOOTH_HCI_H4_WITH_PHDR:
3389                bpf_error("Bluetooth link-layer type filtering not implemented");
3390
3391        case DLT_CAN20B:
3392        case DLT_CAN_SOCKETCAN:
3393                bpf_error("CAN link-layer type filtering not implemented");
3394
3395        case DLT_IEEE802_15_4:
3396        case DLT_IEEE802_15_4_LINUX:
3397        case DLT_IEEE802_15_4_NONASK_PHY:
3398        case DLT_IEEE802_15_4_NOFCS:
3399                bpf_error("IEEE 802.15.4 link-layer type filtering not implemented");
3400
3401        case DLT_IEEE802_16_MAC_CPS_RADIO:
3402                bpf_error("IEEE 802.16 link-layer type filtering not implemented");
3403
3404        case DLT_SITA:
3405                bpf_error("SITA link-layer type filtering not implemented");
3406
3407        case DLT_RAIF1:
3408                bpf_error("RAIF1 link-layer type filtering not implemented");
3409
3410        case DLT_IPMB:
3411                bpf_error("IPMB link-layer type filtering not implemented");
3412
3413        case DLT_AX25_KISS:
3414                bpf_error("AX.25 link-layer type filtering not implemented");
3415        }
3416
3417        /*
3418         * All the types that have no encapsulation should either be
3419         * handled as DLT_SLIP, DLT_SLIP_BSDOS, and DLT_RAW are, if
3420         * all packets are IP packets, or should be handled in some
3421         * special case, if none of them are (if some are and some
3422         * aren't, the lack of encapsulation is a problem, as we'd
3423         * have to find some other way of determining the packet type).
3424         *
3425         * Therefore, if "off_linktype" is -1, there's an error.
3426         */
3427        if (off_linktype == (u_int)-1)
3428                abort();
3429
3430        /*
3431         * Any type not handled above should always have an Ethernet
3432         * type at an offset of "off_linktype".
3433         */
3434        return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
3435}
3436
3437/*
3438 * Check for an LLC SNAP packet with a given organization code and
3439 * protocol type; we check the entire contents of the 802.2 LLC and
3440 * snap headers, checking for DSAP and SSAP of SNAP and a control
3441 * field of 0x03 in the LLC header, and for the specified organization
3442 * code and protocol type in the SNAP header.
3443 */
3444static struct block *
3445gen_snap(orgcode, ptype)
3446        bpf_u_int32 orgcode;
3447        bpf_u_int32 ptype;
3448{
3449        u_char snapblock[8];
3450
3451        snapblock[0] = LLCSAP_SNAP;     /* DSAP = SNAP */
3452        snapblock[1] = LLCSAP_SNAP;     /* SSAP = SNAP */
3453        snapblock[2] = 0x03;            /* control = UI */
3454        snapblock[3] = (orgcode >> 16); /* upper 8 bits of organization code */
3455        snapblock[4] = (orgcode >> 8);  /* middle 8 bits of organization code */
3456        snapblock[5] = (orgcode >> 0);  /* lower 8 bits of organization code */
3457        snapblock[6] = (ptype >> 8);    /* upper 8 bits of protocol type */
3458        snapblock[7] = (ptype >> 0);    /* lower 8 bits of protocol type */
3459        return gen_bcmp(OR_MACPL, 0, 8, snapblock);
3460}
3461
3462/*
3463 * Generate code to match a particular packet type, for link-layer types
3464 * using 802.2 LLC headers.
3465 *
3466 * This is *NOT* used for Ethernet; "gen_ether_linktype()" is used
3467 * for that - it handles the D/I/X Ethernet vs. 802.3+802.2 issues.
3468 *
3469 * "proto" is an Ethernet type value, if > ETHERMTU, or an LLC SAP
3470 * value, if <= ETHERMTU.  We use that to determine whether to
3471 * match the DSAP or both DSAP and LSAP or to check the OUI and
3472 * protocol ID in a SNAP header.
3473 */
3474static struct block *
3475gen_llc_linktype(proto)
3476        int proto;
3477{
3478        /*
3479         * XXX - handle token-ring variable-length header.
3480         */
3481        switch (proto) {
3482
3483        case LLCSAP_IP:
3484        case LLCSAP_ISONS:
3485        case LLCSAP_NETBEUI:
3486                /*
3487                 * XXX - should we check both the DSAP and the
3488                 * SSAP, like this, or should we check just the
3489                 * DSAP, as we do for other types <= ETHERMTU
3490                 * (i.e., other SAP values)?
3491                 */
3492                return gen_cmp(OR_MACPL, 0, BPF_H, (bpf_u_int32)
3493                             ((proto << 8) | proto));
3494
3495        case LLCSAP_IPX:
3496                /*
3497                 * XXX - are there ever SNAP frames for IPX on
3498                 * non-Ethernet 802.x networks?
3499                 */
3500                return gen_cmp(OR_MACPL, 0, BPF_B,
3501                    (bpf_int32)LLCSAP_IPX);
3502
3503        case ETHERTYPE_ATALK:
3504                /*
3505                 * 802.2-encapsulated ETHERTYPE_ATALK packets are
3506                 * SNAP packets with an organization code of
3507                 * 0x080007 (Apple, for Appletalk) and a protocol
3508                 * type of ETHERTYPE_ATALK (Appletalk).
3509                 *
3510                 * XXX - check for an organization code of
3511                 * encapsulated Ethernet as well?
3512                 */
3513                return gen_snap(0x080007, ETHERTYPE_ATALK);
3514
3515        default:
3516                /*
3517                 * XXX - we don't have to check for IPX 802.3
3518                 * here, but should we check for the IPX Ethertype?
3519                 */
3520                if (proto <= ETHERMTU) {
3521                        /*
3522                         * This is an LLC SAP value, so check
3523                         * the DSAP.
3524                         */
3525                        return gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)proto);
3526                } else {
3527                        /*
3528                         * This is an Ethernet type; we assume that it's
3529                         * unlikely that it'll appear in the right place
3530                         * at random, and therefore check only the
3531                         * location that would hold the Ethernet type
3532                         * in a SNAP frame with an organization code of
3533                         * 0x000000 (encapsulated Ethernet).
3534                         *
3535                         * XXX - if we were to check for the SNAP DSAP and
3536                         * LSAP, as per XXX, and were also to check for an
3537                         * organization code of 0x000000 (encapsulated
3538                         * Ethernet), we'd do
3539                         *
3540                         *      return gen_snap(0x000000, proto);
3541                         *
3542                         * here; for now, we don't, as per the above.
3543                         * I don't know whether it's worth the extra CPU
3544                         * time to do the right check or not.
3545                         */
3546                        return gen_cmp(OR_MACPL, 6, BPF_H, (bpf_int32)proto);
3547                }
3548        }
3549}
3550
3551static struct block *
3552gen_hostop(addr, mask, dir, proto, src_off, dst_off)
3553        bpf_u_int32 addr;
3554        bpf_u_int32 mask;
3555        int dir, proto;
3556        u_int src_off, dst_off;
3557{
3558        struct block *b0, *b1;
3559        u_int offset;
3560
3561        switch (dir) {
3562
3563        case Q_SRC:
3564                offset = src_off;
3565                break;
3566
3567        case Q_DST:
3568                offset = dst_off;
3569                break;
3570
3571        case Q_AND:
3572                b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
3573                b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
3574                gen_and(b0, b1);
3575                return b1;
3576
3577        case Q_OR:
3578        case Q_DEFAULT:
3579                b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
3580                b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
3581                gen_or(b0, b1);
3582                return b1;
3583
3584        default:
3585                abort();
3586        }
3587        b0 = gen_linktype(proto);
3588        b1 = gen_mcmp(OR_NET, offset, BPF_W, (bpf_int32)addr, mask);
3589        gen_and(b0, b1);
3590        return b1;
3591}
3592
3593#ifdef INET6
3594static struct block *
3595gen_hostop6(addr, mask, dir, proto, src_off, dst_off)
3596        struct in6_addr *addr;
3597        struct in6_addr *mask;
3598        int dir, proto;
3599        u_int src_off, dst_off;
3600{
3601        struct block *b0, *b1;
3602        u_int offset;
3603        u_int32_t *a, *m;
3604
3605        switch (dir) {
3606
3607        case Q_SRC:
3608                offset = src_off;
3609                break;
3610
3611        case Q_DST:
3612                offset = dst_off;
3613                break;
3614
3615        case Q_AND:
3616                b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
3617                b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
3618                gen_and(b0, b1);
3619                return b1;
3620
3621        case Q_OR:
3622        case Q_DEFAULT:
3623                b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
3624                b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
3625                gen_or(b0, b1);
3626                return b1;
3627
3628        default:
3629                abort();
3630        }
3631        /* this order is important */
3632        a = (u_int32_t *)addr;
3633        m = (u_int32_t *)mask;
3634        b1 = gen_mcmp(OR_NET, offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
3635        b0 = gen_mcmp(OR_NET, offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
3636        gen_and(b0, b1);
3637        b0 = gen_mcmp(OR_NET, offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
3638        gen_and(b0, b1);
3639        b0 = gen_mcmp(OR_NET, offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
3640        gen_and(b0, b1);
3641        b0 = gen_linktype(proto);
3642        gen_and(b0, b1);
3643        return b1;
3644}
3645#endif
3646
3647static struct block *
3648gen_ehostop(eaddr, dir)
3649        register const u_char *eaddr;
3650        register int dir;
3651{
3652        register struct block *b0, *b1;
3653
3654        switch (dir) {
3655        case Q_SRC:
3656                return gen_bcmp(OR_LINK, off_mac + 6, 6, eaddr);
3657
3658        case Q_DST:
3659                return gen_bcmp(OR_LINK, off_mac + 0, 6, eaddr);
3660
3661        case Q_AND:
3662                b0 = gen_ehostop(eaddr, Q_SRC);
3663                b1 = gen_ehostop(eaddr, Q_DST);
3664                gen_and(b0, b1);
3665                return b1;
3666
3667        case Q_DEFAULT:
3668        case Q_OR:
3669                b0 = gen_ehostop(eaddr, Q_SRC);
3670                b1 = gen_ehostop(eaddr, Q_DST);
3671                gen_or(b0, b1);
3672                return b1;
3673
3674        case Q_ADDR1:
3675                bpf_error("'addr1' is only supported on 802.11 with 802.11 headers");
3676                break;
3677
3678        case Q_ADDR2:
3679                bpf_error("'addr2' is only supported on 802.11 with 802.11 headers");
3680                break;
3681
3682        case Q_ADDR3:
3683                bpf_error("'addr3' is only supported on 802.11 with 802.11 headers");
3684                break;
3685
3686        case Q_ADDR4:
3687                bpf_error("'addr4' is only supported on 802.11 with 802.11 headers");
3688                break;
3689
3690        case Q_RA:
3691                bpf_error("'ra' is only supported on 802.11 with 802.11 headers");
3692                break;
3693
3694        case Q_TA:
3695                bpf_error("'ta' is only supported on 802.11 with 802.11 headers");
3696                break;
3697        }
3698        abort();
3699        /* NOTREACHED */
3700}
3701
3702/*
3703 * Like gen_ehostop, but for DLT_FDDI
3704 */
3705static struct block *
3706gen_fhostop(eaddr, dir)
3707        register const u_char *eaddr;
3708        register int dir;
3709{
3710        struct block *b0, *b1;
3711
3712        switch (dir) {
3713        case Q_SRC:
3714#ifdef PCAP_FDDIPAD
3715                return gen_bcmp(OR_LINK, 6 + 1 + pcap_fddipad, 6, eaddr);
3716#else
3717                return gen_bcmp(OR_LINK, 6 + 1, 6, eaddr);
3718#endif
3719
3720        case Q_DST:
3721#ifdef PCAP_FDDIPAD
3722                return gen_bcmp(OR_LINK, 0 + 1 + pcap_fddipad, 6, eaddr);
3723#else
3724                return gen_bcmp(OR_LINK, 0 + 1, 6, eaddr);
3725#endif
3726
3727        case Q_AND:
3728                b0 = gen_fhostop(eaddr, Q_SRC);
3729                b1 = gen_fhostop(eaddr, Q_DST);
3730                gen_and(b0, b1);
3731                return b1;
3732
3733        case Q_DEFAULT:
3734        case Q_OR:
3735                b0 = gen_fhostop(eaddr, Q_SRC);
3736                b1 = gen_fhostop(eaddr, Q_DST);
3737                gen_or(b0, b1);
3738                return b1;
3739
3740        case Q_ADDR1:
3741                bpf_error("'addr1' is only supported on 802.11");
3742                break;
3743
3744        case Q_ADDR2:
3745                bpf_error("'addr2' is only supported on 802.11");
3746                break;
3747
3748        case Q_ADDR3:
3749                bpf_error("'addr3' is only supported on 802.11");
3750                break;
3751
3752        case Q_ADDR4:
3753                bpf_error("'addr4' is only supported on 802.11");
3754                break;
3755
3756        case Q_RA:
3757                bpf_error("'ra' is only supported on 802.11");
3758                break;
3759
3760        case Q_TA:
3761                bpf_error("'ta' is only supported on 802.11");
3762                break;
3763        }
3764        abort();
3765        /* NOTREACHED */
3766}
3767
3768/*
3769 * Like gen_ehostop, but for DLT_IEEE802 (Token Ring)
3770 */
3771static struct block *
3772gen_thostop(eaddr, dir)
3773        register const u_char *eaddr;
3774        register int dir;
3775{
3776        register struct block *b0, *b1;
3777
3778        switch (dir) {
3779        case Q_SRC:
3780                return gen_bcmp(OR_LINK, 8, 6, eaddr);
3781
3782        case Q_DST:
3783                return gen_bcmp(OR_LINK, 2, 6, eaddr);
3784
3785        case Q_AND:
3786                b0 = gen_thostop(eaddr, Q_SRC);
3787                b1 = gen_thostop(eaddr, Q_DST);
3788                gen_and(b0, b1);
3789                return b1;
3790
3791        case Q_DEFAULT:
3792        case Q_OR:
3793                b0 = gen_thostop(eaddr, Q_SRC);
3794                b1 = gen_thostop(eaddr, Q_DST);
3795                gen_or(b0, b1);
3796                return b1;
3797
3798        case Q_ADDR1:
3799                bpf_error("'addr1' is only supported on 802.11");
3800                break;
3801
3802        case Q_ADDR2:
3803                bpf_error("'addr2' is only supported on 802.11");
3804                break;
3805
3806        case Q_ADDR3:
3807                bpf_error("'addr3' is only supported on 802.11");
3808                break;
3809
3810        case Q_ADDR4:
3811                bpf_error("'addr4' is only supported on 802.11");
3812                break;
3813
3814        case Q_RA:
3815                bpf_error("'ra' is only supported on 802.11");
3816                break;
3817
3818        case Q_TA:
3819                bpf_error("'ta' is only supported on 802.11");
3820                break;
3821        }
3822        abort();
3823        /* NOTREACHED */
3824}
3825
3826/*
3827 * Like gen_ehostop, but for DLT_IEEE802_11 (802.11 wireless LAN) and
3828 * various 802.11 + radio headers.
3829 */
3830static struct block *
3831gen_wlanhostop(eaddr, dir)
3832        register const u_char *eaddr;
3833        register int dir;
3834{
3835        register struct block *b0, *b1, *b2;
3836        register struct slist *s;
3837
3838#ifdef ENABLE_WLAN_FILTERING_PATCH
3839        /*
3840         * TODO GV 20070613
3841         * We need to disable the optimizer because the optimizer is buggy
3842         * and wipes out some LD instructions generated by the below
3843         * code to validate the Frame Control bits
3844         */
3845        no_optimize = 1;
3846#endif /* ENABLE_WLAN_FILTERING_PATCH */
3847
3848        switch (dir) {
3849        case Q_SRC:
3850                /*
3851                 * Oh, yuk.
3852                 *
3853                 *      For control frames, there is no SA.
3854                 *
3855                 *      For management frames, SA is at an
3856                 *      offset of 10 from the beginning of
3857                 *      the packet.
3858                 *
3859                 *      For data frames, SA is at an offset
3860                 *      of 10 from the beginning of the packet
3861                 *      if From DS is clear, at an offset of
3862                 *      16 from the beginning of the packet
3863                 *      if From DS is set and To DS is clear,
3864                 *      and an offset of 24 from the beginning
3865                 *      of the packet if From DS is set and To DS
3866                 *      is set.
3867                 */
3868
3869                /*
3870                 * Generate the tests to be done for data frames
3871                 * with From DS set.
3872                 *
3873                 * First, check for To DS set, i.e. check "link[1] & 0x01".
3874                 */
3875                s = gen_load_a(OR_LINK, 1, BPF_B);
3876                b1 = new_block(JMP(BPF_JSET));
3877                b1->s.k = 0x01; /* To DS */
3878                b1->stmts = s;
3879
3880                /*
3881                 * If To DS is set, the SA is at 24.
3882                 */
3883                b0 = gen_bcmp(OR_LINK, 24, 6, eaddr);
3884                gen_and(b1, b0);
3885
3886                /*
3887                 * Now, check for To DS not set, i.e. check
3888                 * "!(link[1] & 0x01)".
3889                 */
3890                s = gen_load_a(OR_LINK, 1, BPF_B);
3891                b2 = new_block(JMP(BPF_JSET));
3892                b2->s.k = 0x01; /* To DS */
3893                b2->stmts = s;
3894                gen_not(b2);
3895
3896                /*
3897                 * If To DS is not set, the SA is at 16.
3898                 */
3899                b1 = gen_bcmp(OR_LINK, 16, 6, eaddr);
3900                gen_and(b2, b1);
3901
3902                /*
3903                 * Now OR together the last two checks.  That gives
3904                 * the complete set of checks for data frames with
3905                 * From DS set.
3906                 */
3907                gen_or(b1, b0);
3908
3909                /*
3910                 * Now check for From DS being set, and AND that with
3911                 * the ORed-together checks.
3912                 */
3913                s = gen_load_a(OR_LINK, 1, BPF_B);
3914                b1 = new_block(JMP(BPF_JSET));
3915                b1->s.k = 0x02; /* From DS */
3916                b1->stmts = s;
3917                gen_and(b1, b0);
3918
3919                /*
3920                 * Now check for data frames with From DS not set.
3921                 */
3922                s = gen_load_a(OR_LINK, 1, BPF_B);
3923                b2 = new_block(JMP(BPF_JSET));
3924                b2->s.k = 0x02; /* From DS */
3925                b2->stmts = s;
3926                gen_not(b2);
3927
3928                /*
3929                 * If From DS isn't set, the SA is at 10.
3930                 */
3931                b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
3932                gen_and(b2, b1);
3933
3934                /*
3935                 * Now OR together the checks for data frames with
3936                 * From DS not set and for data frames with From DS
3937                 * set; that gives the checks done for data frames.
3938                 */
3939                gen_or(b1, b0);
3940
3941                /*
3942                 * Now check for a data frame.
3943                 * I.e, check "link[0] & 0x08".
3944                 */
3945                s = gen_load_a(OR_LINK, 0, BPF_B);
3946                b1 = new_block(JMP(BPF_JSET));
3947                b1->s.k = 0x08;
3948                b1->stmts = s;
3949
3950                /*
3951                 * AND that with the checks done for data frames.
3952                 */
3953                gen_and(b1, b0);
3954
3955                /*
3956                 * If the high-order bit of the type value is 0, this
3957                 * is a management frame.
3958                 * I.e, check "!(link[0] & 0x08)".
3959                 */
3960                s = gen_load_a(OR_LINK, 0, BPF_B);
3961                b2 = new_block(JMP(BPF_JSET));
3962                b2->s.k = 0x08;
3963                b2->stmts = s;
3964                gen_not(b2);
3965
3966                /*
3967                 * For management frames, the SA is at 10.
3968                 */
3969                b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
3970                gen_and(b2, b1);
3971
3972                /*
3973                 * OR that with the checks done for data frames.
3974                 * That gives the checks done for management and
3975                 * data frames.
3976                 */
3977                gen_or(b1, b0);
3978
3979                /*
3980                 * If the low-order bit of the type value is 1,
3981                 * this is either a control frame or a frame
3982                 * with a reserved type, and thus not a
3983                 * frame with an SA.
3984                 *
3985                 * I.e., check "!(link[0] & 0x04)".
3986                 */
3987                s = gen_load_a(OR_LINK, 0, BPF_B);
3988                b1 = new_block(JMP(BPF_JSET));
3989                b1->s.k = 0x04;
3990                b1->stmts = s;
3991                gen_not(b1);
3992
3993                /*
3994                 * AND that with the checks for data and management
3995                 * frames.
3996                 */
3997                gen_and(b1, b0);
3998                return b0;
3999
4000        case Q_DST:
4001                /*
4002                 * Oh, yuk.
4003                 *
4004                 *      For control frames, there is no DA.
4005                 *
4006                 *      For management frames, DA is at an
4007                 *      offset of 4 from the beginning of
4008                 *      the packet.
4009                 *
4010                 *      For data frames, DA is at an offset
4011                 *      of 4 from the beginning of the packet
4012                 *      if To DS is clear and at an offset of
4013                 *      16 from the beginning of the packet
4014                 *      if To DS is set.
4015                 */
4016
4017                /*
4018                 * Generate the tests to be done for data frames.
4019                 *
4020                 * First, check for To DS set, i.e. "link[1] & 0x01".
4021                 */
4022                s = gen_load_a(OR_LINK, 1, BPF_B);
4023                b1 = new_block(JMP(BPF_JSET));
4024                b1->s.k = 0x01; /* To DS */
4025                b1->stmts = s;
4026
4027                /*
4028                 * If To DS is set, the DA is at 16.
4029                 */
4030                b0 = gen_bcmp(OR_LINK, 16, 6, eaddr);
4031                gen_and(b1, b0);
4032
4033                /*
4034                 * Now, check for To DS not set, i.e. check
4035                 * "!(link[1] & 0x01)".
4036                 */
4037                s = gen_load_a(OR_LINK, 1, BPF_B);
4038                b2 = new_block(JMP(BPF_JSET));
4039                b2->s.k = 0x01; /* To DS */
4040                b2->stmts = s;
4041                gen_not(b2);
4042
4043                /*
4044                 * If To DS is not set, the DA is at 4.
4045                 */
4046                b1 = gen_bcmp(OR_LINK, 4, 6, eaddr);
4047                gen_and(b2, b1);
4048
4049                /*
4050                 * Now OR together the last two checks.  That gives
4051                 * the complete set of checks for data frames.
4052                 */
4053                gen_or(b1, b0);
4054
4055                /*
4056                 * Now check for a data frame.
4057                 * I.e, check "link[0] & 0x08".
4058                 */
4059                s = gen_load_a(OR_LINK, 0, BPF_B);
4060                b1 = new_block(JMP(BPF_JSET));
4061                b1->s.k = 0x08;
4062                b1->stmts = s;
4063
4064                /*
4065                 * AND that with the checks done for data frames.
4066                 */
4067                gen_and(b1, b0);
4068
4069                /*
4070                 * If the high-order bit of the type value is 0, this
4071                 * is a management frame.
4072                 * I.e, check "!(link[0] & 0x08)".
4073                 */
4074                s = gen_load_a(OR_LINK, 0, BPF_B);
4075                b2 = new_block(JMP(BPF_JSET));
4076                b2->s.k = 0x08;
4077                b2->stmts = s;
4078                gen_not(b2);
4079
4080                /*
4081                 * For management frames, the DA is at 4.
4082                 */
4083                b1 = gen_bcmp(OR_LINK, 4, 6, eaddr);
4084                gen_and(b2, b1);
4085
4086                /*
4087                 * OR that with the checks done for data frames.
4088                 * That gives the checks done for management and
4089                 * data frames.
4090                 */
4091                gen_or(b1, b0);
4092
4093                /*
4094                 * If the low-order bit of the type value is 1,
4095                 * this is either a control frame or a frame
4096                 * with a reserved type, and thus not a
4097                 * frame with an SA.
4098                 *
4099                 * I.e., check "!(link[0] & 0x04)".
4100                 */
4101                s = gen_load_a(OR_LINK, 0, BPF_B);
4102                b1 = new_block(JMP(BPF_JSET));
4103                b1->s.k = 0x04;
4104                b1->stmts = s;
4105                gen_not(b1);
4106
4107                /*
4108                 * AND that with the checks for data and management
4109                 * frames.
4110                 */
4111                gen_and(b1, b0);
4112                return b0;
4113
4114        case Q_RA:
4115                /*
4116                 * Not present in management frames; addr1 in other
4117                 * frames.
4118                 */
4119
4120                /*
4121                 * If the high-order bit of the type value is 0, this
4122                 * is a management frame.
4123                 * I.e, check "(link[0] & 0x08)".
4124                 */
4125                s = gen_load_a(OR_LINK, 0, BPF_B);
4126                b1 = new_block(JMP(BPF_JSET));
4127                b1->s.k = 0x08;
4128                b1->stmts = s;
4129
4130                /*
4131                 * Check addr1.
4132                 */
4133                b0 = gen_bcmp(OR_LINK, 4, 6, eaddr);
4134
4135                /*
4136                 * AND that with the check of addr1.
4137                 */
4138                gen_and(b1, b0);
4139                return (b0);
4140
4141        case Q_TA:
4142                /*
4143                 * Not present in management frames; addr2, if present,
4144                 * in other frames.
4145                 */
4146
4147                /*
4148                 * Not present in CTS or ACK control frames.
4149                 */
4150                b0 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
4151                        IEEE80211_FC0_TYPE_MASK);
4152                gen_not(b0);
4153                b1 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
4154                        IEEE80211_FC0_SUBTYPE_MASK);
4155                gen_not(b1);
4156                b2 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
4157                        IEEE80211_FC0_SUBTYPE_MASK);
4158                gen_not(b2);
4159                gen_and(b1, b2);
4160                gen_or(b0, b2);
4161
4162                /*
4163                 * If the high-order bit of the type value is 0, this
4164                 * is a management frame.
4165                 * I.e, check "(link[0] & 0x08)".
4166                 */
4167                s = gen_load_a(OR_LINK, 0, BPF_B);
4168                b1 = new_block(JMP(BPF_JSET));
4169                b1->s.k = 0x08;
4170                b1->stmts = s;
4171
4172                /*
4173                 * AND that with the check for frames other than
4174                 * CTS and ACK frames.
4175                 */
4176                gen_and(b1, b2);
4177
4178                /*
4179                 * Check addr2.
4180                 */
4181                b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
4182                gen_and(b2, b1);
4183                return b1;
4184
4185        /*
4186         * XXX - add BSSID keyword?
4187         */
4188        case Q_ADDR1:
4189                return (gen_bcmp(OR_LINK, 4, 6, eaddr));
4190
4191        case Q_ADDR2:
4192                /*
4193                 * Not present in CTS or ACK control frames.
4194                 */
4195                b0 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
4196                        IEEE80211_FC0_TYPE_MASK);
4197                gen_not(b0);
4198                b1 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
4199                        IEEE80211_FC0_SUBTYPE_MASK);
4200                gen_not(b1);
4201                b2 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
4202                        IEEE80211_FC0_SUBTYPE_MASK);
4203                gen_not(b2);
4204                gen_and(b1, b2);
4205                gen_or(b0, b2);
4206                b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
4207                gen_and(b2, b1);
4208                return b1;
4209
4210        case Q_ADDR3:
4211                /*
4212                 * Not present in control frames.
4213                 */
4214                b0 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
4215                        IEEE80211_FC0_TYPE_MASK);
4216                gen_not(b0);
4217                b1 = gen_bcmp(OR_LINK, 16, 6, eaddr);
4218                gen_and(b0, b1);
4219                return b1;
4220
4221        case Q_ADDR4:
4222                /*
4223                 * Present only if the direction mask has both "From DS"
4224                 * and "To DS" set.  Neither control frames nor management
4225                 * frames should have both of those set, so we don't
4226                 * check the frame type.
4227                 */
4228                b0 = gen_mcmp(OR_LINK, 1, BPF_B,
4229                        IEEE80211_FC1_DIR_DSTODS, IEEE80211_FC1_DIR_MASK);
4230                b1 = gen_bcmp(OR_LINK, 24, 6, eaddr);
4231                gen_and(b0, b1);
4232                return b1;
4233
4234        case Q_AND:
4235                b0 = gen_wlanhostop(eaddr, Q_SRC);
4236                b1 = gen_wlanhostop(eaddr, Q_DST);
4237                gen_and(b0, b1);
4238                return b1;
4239
4240        case Q_DEFAULT:
4241        case Q_OR:
4242                b0 = gen_wlanhostop(eaddr, Q_SRC);
4243                b1 = gen_wlanhostop(eaddr, Q_DST);
4244                gen_or(b0, b1);
4245                return b1;
4246        }
4247        abort();
4248        /* NOTREACHED */
4249}
4250
4251/*
4252 * Like gen_ehostop, but for RFC 2625 IP-over-Fibre-Channel.
4253 * (We assume that the addresses are IEEE 48-bit MAC addresses,
4254 * as the RFC states.)
4255 */
4256static struct block *
4257gen_ipfchostop(eaddr, dir)
4258        register const u_char *eaddr;
4259        register int dir;
4260{
4261        register struct block *b0, *b1;
4262
4263        switch (dir) {
4264        case Q_SRC:
4265                return gen_bcmp(OR_LINK, 10, 6, eaddr);
4266
4267        case Q_DST:
4268                return gen_bcmp(OR_LINK, 2, 6, eaddr);
4269
4270        case Q_AND:
4271                b0 = gen_ipfchostop(eaddr, Q_SRC);
4272                b1 = gen_ipfchostop(eaddr, Q_DST);
4273                gen_and(b0, b1);
4274                return b1;
4275
4276        case Q_DEFAULT:
4277        case Q_OR:
4278                b0 = gen_ipfchostop(eaddr, Q_SRC);
4279                b1 = gen_ipfchostop(eaddr, Q_DST);
4280                gen_or(b0, b1);
4281                return b1;
4282
4283        case Q_ADDR1:
4284                bpf_error("'addr1' is only supported on 802.11");
4285                break;
4286
4287        case Q_ADDR2:
4288                bpf_error("'addr2' is only supported on 802.11");
4289                break;
4290
4291        case Q_ADDR3:
4292                bpf_error("'addr3' is only supported on 802.11");
4293                break;
4294
4295        case Q_ADDR4:
4296                bpf_error("'addr4' is only supported on 802.11");
4297                break;
4298
4299        case Q_RA:
4300                bpf_error("'ra' is only supported on 802.11");
4301                break;
4302
4303        case Q_TA:
4304                bpf_error("'ta' is only supported on 802.11");
4305                break;
4306        }
4307        abort();
4308        /* NOTREACHED */
4309}
4310
4311/*
4312 * This is quite tricky because there may be pad bytes in front of the
4313 * DECNET header, and then there are two possible data packet formats that
4314 * carry both src and dst addresses, plus 5 packet types in a format that
4315 * carries only the src node, plus 2 types that use a different format and
4316 * also carry just the src node.
4317 *
4318 * Yuck.
4319 *
4320 * Instead of doing those all right, we just look for data packets with
4321 * 0 or 1 bytes of padding.  If you want to look at other packets, that
4322 * will require a lot more hacking.
4323 *
4324 * To add support for filtering on DECNET "areas" (network numbers)
4325 * one would want to add a "mask" argument to this routine.  That would
4326 * make the filter even more inefficient, although one could be clever
4327 * and not generate masking instructions if the mask is 0xFFFF.
4328 */
4329static struct block *
4330gen_dnhostop(addr, dir)
4331        bpf_u_int32 addr;
4332        int dir;
4333{
4334        struct block *b0, *b1, *b2, *tmp;
4335        u_int offset_lh;        /* offset if long header is received */
4336        u_int offset_sh;        /* offset if short header is received */
4337
4338        switch (dir) {
4339
4340        case Q_DST:
4341                offset_sh = 1;  /* follows flags */
4342                offset_lh = 7;  /* flgs,darea,dsubarea,HIORD */
4343                break;
4344
4345        case Q_SRC:
4346                offset_sh = 3;  /* follows flags, dstnode */
4347                offset_lh = 15; /* flgs,darea,dsubarea,did,sarea,ssub,HIORD */
4348                break;
4349
4350        case Q_AND:
4351                /* Inefficient because we do our Calvinball dance twice */
4352                b0 = gen_dnhostop(addr, Q_SRC);
4353                b1 = gen_dnhostop(addr, Q_DST);
4354                gen_and(b0, b1);
4355                return b1;
4356
4357        case Q_OR:
4358        case Q_DEFAULT:
4359                /* Inefficient because we do our Calvinball dance twice */
4360                b0 = gen_dnhostop(addr, Q_SRC);
4361                b1 = gen_dnhostop(addr, Q_DST);
4362                gen_or(b0, b1);
4363                return b1;
4364
4365        case Q_ISO:
4366                bpf_error("ISO host filtering not implemented");
4367
4368        default:
4369                abort();
4370        }
4371        b0 = gen_linktype(ETHERTYPE_DN);
4372        /* Check for pad = 1, long header case */
4373        tmp = gen_mcmp(OR_NET, 2, BPF_H,
4374            (bpf_int32)ntohs(0x0681), (bpf_int32)ntohs(0x07FF));
4375        b1 = gen_cmp(OR_NET, 2 + 1 + offset_lh,
4376            BPF_H, (bpf_int32)ntohs((u_short)addr));
4377        gen_and(tmp, b1);
4378        /* Check for pad = 0, long header case */
4379        tmp = gen_mcmp(OR_NET, 2, BPF_B, (bpf_int32)0x06, (bpf_int32)0x7);
4380        b2 = gen_cmp(OR_NET, 2 + offset_lh, BPF_H, (bpf_int32)ntohs((u_short)addr));
4381        gen_and(tmp, b2);
4382        gen_or(b2, b1);
4383        /* Check for pad = 1, short header case */
4384        tmp = gen_mcmp(OR_NET, 2, BPF_H,
4385            (bpf_int32)ntohs(0x0281), (bpf_int32)ntohs(0x07FF));
4386        b2 = gen_cmp(OR_NET, 2 + 1 + offset_sh, BPF_H, (bpf_int32)ntohs((u_short)addr));
4387        gen_and(tmp, b2);
4388        gen_or(b2, b1);
4389        /* Check for pad = 0, short header case */
4390        tmp = gen_mcmp(OR_NET, 2, BPF_B, (bpf_int32)0x02, (bpf_int32)0x7);
4391        b2 = gen_cmp(OR_NET, 2 + offset_sh, BPF_H, (bpf_int32)ntohs((u_short)addr));
4392        gen_and(tmp, b2);
4393        gen_or(b2, b1);
4394
4395        /* Combine with test for linktype */
4396        gen_and(b0, b1);
4397        return b1;
4398}
4399
4400/*
4401 * Generate a check for IPv4 or IPv6 for MPLS-encapsulated packets;
4402 * test the bottom-of-stack bit, and then check the version number
4403 * field in the IP header.
4404 */
4405static struct block *
4406gen_mpls_linktype(proto)
4407        int proto;
4408{
4409        struct block *b0, *b1;
4410
4411        switch (proto) {
4412
4413        case Q_IP:
4414                /* match the bottom-of-stack bit */
4415                b0 = gen_mcmp(OR_NET, -2, BPF_B, 0x01, 0x01);
4416                /* match the IPv4 version number */
4417                b1 = gen_mcmp(OR_NET, 0, BPF_B, 0x40, 0xf0);
4418                gen_and(b0, b1);
4419                return b1;
4420
4421       case Q_IPV6:
4422                /* match the bottom-of-stack bit */
4423                b0 = gen_mcmp(OR_NET, -2, BPF_B, 0x01, 0x01);
4424                /* match the IPv4 version number */
4425                b1 = gen_mcmp(OR_NET, 0, BPF_B, 0x60, 0xf0);
4426                gen_and(b0, b1);
4427                return b1;
4428
4429       default:
4430                abort();
4431        }
4432}
4433
4434static struct block *
4435gen_host(addr, mask, proto, dir, type)
4436        bpf_u_int32 addr;
4437        bpf_u_int32 mask;
4438        int proto;
4439        int dir;
4440        int type;
4441{
4442        struct block *b0, *b1;
4443        const char *typestr;
4444
4445        if (type == Q_NET)
4446                typestr = "net";
4447        else
4448                typestr = "host";
4449
4450        switch (proto) {
4451
4452        case Q_DEFAULT:
4453                b0 = gen_host(addr, mask, Q_IP, dir, type);
4454                /*
4455                 * Only check for non-IPv4 addresses if we're not
4456                 * checking MPLS-encapsulated packets.
4457                 */
4458                if (label_stack_depth == 0) {
4459                        b1 = gen_host(addr, mask, Q_ARP, dir, type);
4460                        gen_or(b0, b1);
4461                        b0 = gen_host(addr, mask, Q_RARP, dir, type);
4462                        gen_or(b1, b0);
4463                }
4464                return b0;
4465
4466        case Q_IP:
4467                return gen_hostop(addr, mask, dir, ETHERTYPE_IP, 12, 16);
4468
4469        case Q_RARP:
4470                return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP, 14, 24);
4471
4472        case Q_ARP:
4473                return gen_hostop(addr, mask, dir, ETHERTYPE_ARP, 14, 24);
4474
4475        case Q_TCP:
4476                bpf_error("'tcp' modifier applied to %s", typestr);
4477
4478        case Q_SCTP:
4479                bpf_error("'sctp' modifier applied to %s", typestr);
4480
4481        case Q_UDP:
4482                bpf_error("'udp' modifier applied to %s", typestr);
4483
4484        case Q_ICMP:
4485                bpf_error("'icmp' modifier applied to %s", typestr);
4486
4487        case Q_IGMP:
4488                bpf_error("'igmp' modifier applied to %s", typestr);
4489
4490        case Q_IGRP:
4491                bpf_error("'igrp' modifier applied to %s", typestr);
4492
4493        case Q_PIM:
4494                bpf_error("'pim' modifier applied to %s", typestr);
4495
4496        case Q_VRRP:
4497                bpf_error("'vrrp' modifier applied to %s", typestr);
4498
4499        case Q_CARP:
4500                bpf_error("'carp' modifier applied to %s", typestr);
4501
4502        case Q_ATALK:
4503                bpf_error("ATALK host filtering not implemented");
4504
4505        case Q_AARP:
4506                bpf_error("AARP host filtering not implemented");
4507
4508        case Q_DECNET:
4509                return gen_dnhostop(addr, dir);
4510
4511        case Q_SCA:
4512                bpf_error("SCA host filtering not implemented");
4513
4514        case Q_LAT:
4515                bpf_error("LAT host filtering not implemented");
4516
4517        case Q_MOPDL:
4518                bpf_error("MOPDL host filtering not implemented");
4519
4520        case Q_MOPRC:
4521                bpf_error("MOPRC host filtering not implemented");
4522
4523        case Q_IPV6:
4524                bpf_error("'ip6' modifier applied to ip host");
4525
4526        case Q_ICMPV6:
4527                bpf_error("'icmp6' modifier applied to %s", typestr);
4528
4529        case Q_AH:
4530                bpf_error("'ah' modifier applied to %s", typestr);
4531
4532        case Q_ESP:
4533                bpf_error("'esp' modifier applied to %s", typestr);
4534
4535        case Q_ISO:
4536                bpf_error("ISO host filtering not implemented");
4537
4538        case Q_ESIS:
4539                bpf_error("'esis' modifier applied to %s", typestr);
4540
4541        case Q_ISIS:
4542                bpf_error("'isis' modifier applied to %s", typestr);
4543
4544        case Q_CLNP:
4545                bpf_error("'clnp' modifier applied to %s", typestr);
4546
4547        case Q_STP:
4548                bpf_error("'stp' modifier applied to %s", typestr);
4549
4550        case Q_IPX:
4551                bpf_error("IPX host filtering not implemented");
4552
4553        case Q_NETBEUI:
4554                bpf_error("'netbeui' modifier applied to %s", typestr);
4555
4556        case Q_RADIO:
4557                bpf_error("'radio' modifier applied to %s", typestr);
4558
4559        default:
4560                abort();
4561        }
4562        /* NOTREACHED */
4563}
4564
4565#ifdef INET6
4566static struct block *
4567gen_host6(addr, mask, proto, dir, type)
4568        struct in6_addr *addr;
4569        struct in6_addr *mask;
4570        int proto;
4571        int dir;
4572        int type;
4573{
4574        const char *typestr;
4575
4576        if (type == Q_NET)
4577                typestr = "net";
4578        else
4579                typestr = "host";
4580
4581        switch (proto) {
4582
4583        case Q_DEFAULT:
4584                return gen_host6(addr, mask, Q_IPV6, dir, type);
4585
4586        case Q_IP:
4587                bpf_error("'ip' modifier applied to ip6 %s", typestr);
4588
4589        case Q_RARP:
4590                bpf_error("'rarp' modifier applied to ip6 %s", typestr);
4591
4592        case Q_ARP:
4593                bpf_error("'arp' modifier applied to ip6 %s", typestr);
4594
4595        case Q_SCTP:
4596                bpf_error("'sctp' modifier applied to %s", typestr);
4597
4598        case Q_TCP:
4599                bpf_error("'tcp' modifier applied to %s", typestr);
4600
4601        case Q_UDP:
4602                bpf_error("'udp' modifier applied to %s", typestr);
4603
4604        case Q_ICMP:
4605                bpf_error("'icmp' modifier applied to %s", typestr);
4606
4607        case Q_IGMP:
4608                bpf_error("'igmp' modifier applied to %s", typestr);
4609
4610        case Q_IGRP:
4611                bpf_error("'igrp' modifier applied to %s", typestr);
4612
4613        case Q_PIM:
4614                bpf_error("'pim' modifier applied to %s", typestr);
4615
4616        case Q_VRRP:
4617                bpf_error("'vrrp' modifier applied to %s", typestr);
4618
4619        case Q_CARP:
4620                bpf_error("'carp' modifier applied to %s", typestr);
4621
4622        case Q_ATALK:
4623                bpf_error("ATALK host filtering not implemented");
4624
4625        case Q_AARP:
4626                bpf_error("AARP host filtering not implemented");
4627
4628        case Q_DECNET:
4629                bpf_error("'decnet' modifier applied to ip6 %s", typestr);
4630
4631        case Q_SCA:
4632                bpf_error("SCA host filtering not implemented");
4633
4634        case Q_LAT:
4635                bpf_error("LAT host filtering not implemented");
4636
4637        case Q_MOPDL:
4638                bpf_error("MOPDL host filtering not implemented");
4639
4640        case Q_MOPRC:
4641                bpf_error("MOPRC host filtering not implemented");
4642
4643        case Q_IPV6:
4644                return gen_hostop6(addr, mask, dir, ETHERTYPE_IPV6, 8, 24);
4645
4646        case Q_ICMPV6:
4647                bpf_error("'icmp6' modifier applied to %s", typestr);
4648
4649        case Q_AH:
4650                bpf_error("'ah' modifier applied to %s", typestr);
4651
4652        case Q_ESP:
4653                bpf_error("'esp' modifier applied to %s", typestr);
4654
4655        case Q_ISO:
4656                bpf_error("ISO host filtering not implemented");
4657
4658        case Q_ESIS:
4659                bpf_error("'esis' modifier applied to %s", typestr);
4660
4661        case Q_ISIS:
4662                bpf_error("'isis' modifier applied to %s", typestr);
4663
4664        case Q_CLNP:
4665                bpf_error("'clnp' modifier applied to %s", typestr);
4666
4667        case Q_STP:
4668                bpf_error("'stp' modifier applied to %s", typestr);
4669
4670        case Q_IPX:
4671                bpf_error("IPX host filtering not implemented");
4672
4673        case Q_NETBEUI:
4674                bpf_error("'netbeui' modifier applied to %s", typestr);
4675
4676        case Q_RADIO:
4677                bpf_error("'radio' modifier applied to %s", typestr);
4678
4679        default:
4680                abort();
4681        }
4682        /* NOTREACHED */
4683}
4684#endif
4685
4686#ifndef INET6
4687static struct block *
4688gen_gateway(eaddr, alist, proto, dir)
4689        const u_char *eaddr;
4690        bpf_u_int32 **alist;
4691        int proto;
4692        int dir;
4693{
4694        struct block *b0, *b1, *tmp;
4695
4696        if (dir != 0)
4697                bpf_error("direction applied to 'gateway'");
4698
4699        switch (proto) {
4700        case Q_DEFAULT:
4701        case Q_IP:
4702        case Q_ARP:
4703        case Q_RARP:
4704                switch (linktype) {
4705                case DLT_EN10MB:
4706                case DLT_NETANALYZER:
4707                case DLT_NETANALYZER_TRANSPARENT:
4708                        b0 = gen_ehostop(eaddr, Q_OR);
4709                        break;
4710                case DLT_FDDI:
4711                        b0 = gen_fhostop(eaddr, Q_OR);
4712                        break;
4713                case DLT_IEEE802:
4714                        b0 = gen_thostop(eaddr, Q_OR);
4715                        break;
4716                case DLT_IEEE802_11:
4717                case DLT_PRISM_HEADER:
4718                case DLT_IEEE802_11_RADIO_AVS:
4719                case DLT_IEEE802_11_RADIO:
4720                case DLT_PPI:
4721                        b0 = gen_wlanhostop(eaddr, Q_OR);
4722                        break;
4723                case DLT_SUNATM:
4724                        if (!is_lane)
4725                                bpf_error(
4726                                    "'gateway' supported only on ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel");
4727                        /*
4728                         * Check that the packet doesn't begin with an
4729                         * LE Control marker.  (We've already generated
4730                         * a test for LANE.)
4731                         */
4732                        b1 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS,
4733                            BPF_H, 0xFF00);
4734                        gen_not(b1);
4735
4736                        /*
4737                         * Now check the MAC address.
4738                         */
4739                        b0 = gen_ehostop(eaddr, Q_OR);
4740                        gen_and(b1, b0);
4741                        break;
4742                case DLT_IP_OVER_FC:
4743                        b0 = gen_ipfchostop(eaddr, Q_OR);
4744                        break;
4745                default:
4746                        bpf_error(
4747                            "'gateway' supported only on ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel");
4748                }
4749                b1 = gen_host(**alist++, 0xffffffff, proto, Q_OR, Q_HOST);
4750                while (*alist) {
4751                        tmp = gen_host(**alist++, 0xffffffff, proto, Q_OR,
4752                            Q_HOST);
4753                        gen_or(b1, tmp);
4754                        b1 = tmp;
4755                }
4756                gen_not(b1);
4757                gen_and(b0, b1);
4758                return b1;
4759        }
4760        bpf_error("illegal modifier of 'gateway'");
4761        /* NOTREACHED */
4762}
4763#endif
4764
4765struct block *
4766gen_proto_abbrev(proto)
4767        int proto;
4768{
4769        struct block *b0;
4770        struct block *b1;
4771
4772        switch (proto) {
4773
4774        case Q_SCTP:
4775                b1 = gen_proto(IPPROTO_SCTP, Q_IP, Q_DEFAULT);
4776                b0 = gen_proto(IPPROTO_SCTP, Q_IPV6, Q_DEFAULT);
4777                gen_or(b0, b1);
4778                break;
4779
4780        case Q_TCP:
4781                b1 = gen_proto(IPPROTO_TCP, Q_IP, Q_DEFAULT);
4782                b0 = gen_proto(IPPROTO_TCP, Q_IPV6, Q_DEFAULT);
4783                gen_or(b0, b1);
4784                break;
4785
4786        case Q_UDP:
4787                b1 = gen_proto(IPPROTO_UDP, Q_IP, Q_DEFAULT);
4788                b0 = gen_proto(IPPROTO_UDP, Q_IPV6, Q_DEFAULT);
4789                gen_or(b0, b1);
4790                break;
4791
4792        case Q_ICMP:
4793                b1 = gen_proto(IPPROTO_ICMP, Q_IP, Q_DEFAULT);
4794                break;
4795
4796#ifndef IPPROTO_IGMP
4797#define IPPROTO_IGMP    2
4798#endif
4799
4800        case Q_IGMP:
4801                b1 = gen_proto(IPPROTO_IGMP, Q_IP, Q_DEFAULT);
4802                break;
4803
4804#ifndef IPPROTO_IGRP
4805#define IPPROTO_IGRP    9
4806#endif
4807        case Q_IGRP:
4808                b1 = gen_proto(IPPROTO_IGRP, Q_IP, Q_DEFAULT);
4809                break;
4810
4811#ifndef IPPROTO_PIM
4812#define IPPROTO_PIM     103
4813#endif
4814
4815        case Q_PIM:
4816                b1 = gen_proto(IPPROTO_PIM, Q_IP, Q_DEFAULT);
4817                b0 = gen_proto(IPPROTO_PIM, Q_IPV6, Q_DEFAULT);
4818                gen_or(b0, b1);
4819                break;
4820
4821#ifndef IPPROTO_VRRP
4822#define IPPROTO_VRRP    112
4823#endif
4824
4825        case Q_VRRP:
4826                b1 = gen_proto(IPPROTO_VRRP, Q_IP, Q_DEFAULT);
4827                break;
4828
4829#ifndef IPPROTO_CARP
4830#define IPPROTO_CARP    112
4831#endif
4832
4833        case Q_CARP:
4834                b1 = gen_proto(IPPROTO_CARP, Q_IP, Q_DEFAULT);
4835                break;
4836
4837        case Q_IP:
4838                b1 =  gen_linktype(ETHERTYPE_IP);
4839                break;
4840
4841        case Q_ARP:
4842                b1 =  gen_linktype(ETHERTYPE_ARP);
4843                break;
4844
4845        case Q_RARP:
4846                b1 =  gen_linktype(ETHERTYPE_REVARP);
4847                break;
4848
4849        case Q_LINK:
4850                bpf_error("link layer applied in wrong context");
4851
4852        case Q_ATALK:
4853                b1 =  gen_linktype(ETHERTYPE_ATALK);
4854                break;
4855
4856        case Q_AARP:
4857                b1 =  gen_linktype(ETHERTYPE_AARP);
4858                break;
4859
4860        case Q_DECNET:
4861                b1 =  gen_linktype(ETHERTYPE_DN);
4862                break;
4863
4864        case Q_SCA:
4865                b1 =  gen_linktype(ETHERTYPE_SCA);
4866                break;
4867
4868        case Q_LAT:
4869                b1 =  gen_linktype(ETHERTYPE_LAT);
4870                break;
4871
4872        case Q_MOPDL:
4873                b1 =  gen_linktype(ETHERTYPE_MOPDL);
4874                break;
4875
4876        case Q_MOPRC:
4877                b1 =  gen_linktype(ETHERTYPE_MOPRC);
4878                break;
4879
4880        case Q_IPV6:
4881                b1 = gen_linktype(ETHERTYPE_IPV6);
4882                break;
4883
4884#ifndef IPPROTO_ICMPV6
4885#define IPPROTO_ICMPV6  58
4886#endif
4887        case Q_ICMPV6:
4888                b1 = gen_proto(IPPROTO_ICMPV6, Q_IPV6, Q_DEFAULT);
4889                break;
4890
4891#ifndef IPPROTO_AH
4892#define IPPROTO_AH      51
4893#endif
4894        case Q_AH:
4895                b1 = gen_proto(IPPROTO_AH, Q_IP, Q_DEFAULT);
4896                b0 = gen_proto(IPPROTO_AH, Q_IPV6, Q_DEFAULT);
4897                gen_or(b0, b1);
4898                break;
4899
4900#ifndef IPPROTO_ESP
4901#define IPPROTO_ESP     50
4902#endif
4903        case Q_ESP:
4904                b1 = gen_proto(IPPROTO_ESP, Q_IP, Q_DEFAULT);
4905                b0 = gen_proto(IPPROTO_ESP, Q_IPV6, Q_DEFAULT);
4906                gen_or(b0, b1);
4907                break;
4908
4909        case Q_ISO:
4910                b1 = gen_linktype(LLCSAP_ISONS);
4911                break;
4912
4913        case Q_ESIS:
4914                b1 = gen_proto(ISO9542_ESIS, Q_ISO, Q_DEFAULT);
4915                break;
4916
4917        case Q_ISIS:
4918                b1 = gen_proto(ISO10589_ISIS, Q_ISO, Q_DEFAULT);
4919                break;
4920
4921        case Q_ISIS_L1: /* all IS-IS Level1 PDU-Types */
4922                b0 = gen_proto(ISIS_L1_LAN_IIH, Q_ISIS, Q_DEFAULT);
4923                b1 = gen_proto(ISIS_PTP_IIH, Q_ISIS, Q_DEFAULT); /* FIXME extract the circuit-type bits */
4924                gen_or(b0, b1);
4925                b0 = gen_proto(ISIS_L1_LSP, Q_ISIS, Q_DEFAULT);
4926                gen_or(b0, b1);
4927                b0 = gen_proto(ISIS_L1_CSNP, Q_ISIS, Q_DEFAULT);
4928                gen_or(b0, b1);
4929                b0 = gen_proto(ISIS_L1_PSNP, Q_ISIS, Q_DEFAULT);
4930                gen_or(b0, b1);
4931                break;
4932
4933        case Q_ISIS_L2: /* all IS-IS Level2 PDU-Types */
4934                b0 = gen_proto(ISIS_L2_LAN_IIH, Q_ISIS, Q_DEFAULT);
4935                b1 = gen_proto(ISIS_PTP_IIH, Q_ISIS, Q_DEFAULT); /* FIXME extract the circuit-type bits */
4936                gen_or(b0, b1);
4937                b0 = gen_proto(ISIS_L2_LSP, Q_ISIS, Q_DEFAULT);
4938                gen_or(b0, b1);
4939                b0 = gen_proto(ISIS_L2_CSNP, Q_ISIS, Q_DEFAULT);
4940                gen_or(b0, b1);
4941                b0 = gen_proto(ISIS_L2_PSNP, Q_ISIS, Q_DEFAULT);
4942                gen_or(b0, b1);
4943                break;
4944
4945        case Q_ISIS_IIH: /* all IS-IS Hello PDU-Types */
4946                b0 = gen_proto(ISIS_L1_LAN_IIH, Q_ISIS, Q_DEFAULT);
4947                b1 = gen_proto(ISIS_L2_LAN_IIH, Q_ISIS, Q_DEFAULT);
4948                gen_or(b0, b1);
4949                b0 = gen_proto(ISIS_PTP_IIH, Q_ISIS, Q_DEFAULT);
4950                gen_or(b0, b1);
4951                break;
4952
4953        case Q_ISIS_LSP:
4954                b0 = gen_proto(ISIS_L1_LSP, Q_ISIS, Q_DEFAULT);
4955                b1 = gen_proto(ISIS_L2_LSP, Q_ISIS, Q_DEFAULT);
4956                gen_or(b0, b1);
4957                break;
4958
4959        case Q_ISIS_SNP:
4960                b0 = gen_proto(ISIS_L1_CSNP, Q_ISIS, Q_DEFAULT);
4961                b1 = gen_proto(ISIS_L2_CSNP, Q_ISIS, Q_DEFAULT);
4962                gen_or(b0, b1);
4963                b0 = gen_proto(ISIS_L1_PSNP, Q_ISIS, Q_DEFAULT);
4964                gen_or(b0, b1);
4965                b0 = gen_proto(ISIS_L2_PSNP, Q_ISIS, Q_DEFAULT);
4966                gen_or(b0, b1);
4967                break;
4968
4969        case Q_ISIS_CSNP:
4970                b0 = gen_proto(ISIS_L1_CSNP, Q_ISIS, Q_DEFAULT);
4971                b1 = gen_proto(ISIS_L2_CSNP, Q_ISIS, Q_DEFAULT);
4972                gen_or(b0, b1);
4973                break;
4974
4975        case Q_ISIS_PSNP:
4976                b0 = gen_proto(ISIS_L1_PSNP, Q_ISIS, Q_DEFAULT);
4977                b1 = gen_proto(ISIS_L2_PSNP, Q_ISIS, Q_DEFAULT);
4978                gen_or(b0, b1);
4979                break;
4980
4981        case Q_CLNP:
4982                b1 = gen_proto(ISO8473_CLNP, Q_ISO, Q_DEFAULT);
4983                break;
4984
4985        case Q_STP:
4986                b1 = gen_linktype(LLCSAP_8021D);
4987                break;
4988
4989        case Q_IPX:
4990                b1 = gen_linktype(LLCSAP_IPX);
4991                break;
4992
4993        case Q_NETBEUI:
4994                b1 = gen_linktype(LLCSAP_NETBEUI);
4995                break;
4996
4997        case Q_RADIO:
4998                bpf_error("'radio' is not a valid protocol type");
4999
5000        default:
5001                abort();
5002        }
5003        return b1;
5004}
5005
5006static struct block *
5007gen_ipfrag()
5008{
5009        struct slist *s;
5010        struct block *b;
5011
5012        /* not IPv4 frag other than the first frag */
5013        s = gen_load_a(OR_NET, 6, BPF_H);
5014        b = new_block(JMP(BPF_JSET));
5015        b->s.k = 0x1fff;
5016        b->stmts = s;
5017        gen_not(b);
5018
5019        return b;
5020}
5021
5022/*
5023 * Generate a comparison to a port value in the transport-layer header
5024 * at the specified offset from the beginning of that header.
5025 *
5026 * XXX - this handles a variable-length prefix preceding the link-layer
5027 * header, such as the radiotap or AVS radio prefix, but doesn't handle
5028 * variable-length link-layer headers (such as Token Ring or 802.11
5029 * headers).
5030 */
5031static struct block *
5032gen_portatom(off, v)
5033        int off;
5034        bpf_int32 v;
5035{
5036        return gen_cmp(OR_TRAN_IPV4, off, BPF_H, v);
5037}
5038
5039static struct block *
5040gen_portatom6(off, v)
5041        int off;
5042        bpf_int32 v;
5043{
5044        return gen_cmp(OR_TRAN_IPV6, off, BPF_H, v);
5045}
5046
5047struct block *
5048gen_portop(port, proto, dir)
5049        int port, proto, dir;
5050{
5051        struct block *b0, *b1, *tmp;
5052
5053        /* ip proto 'proto' and not a fragment other than the first fragment */
5054        tmp = gen_cmp(OR_NET, 9, BPF_B, (bpf_int32)proto);
5055        b0 = gen_ipfrag();
5056        gen_and(tmp, b0);
5057
5058        switch (dir) {
5059        case Q_SRC:
5060                b1 = gen_portatom(0, (bpf_int32)port);
5061                break;
5062
5063        case Q_DST:
5064                b1 = gen_portatom(2, (bpf_int32)port);
5065                break;
5066
5067        case Q_OR:
5068        case Q_DEFAULT:
5069                tmp = gen_portatom(0, (bpf_int32)port);
5070                b1 = gen_portatom(2, (bpf_int32)port);
5071                gen_or(tmp, b1);
5072                break;
5073
5074        case Q_AND:
5075                tmp = gen_portatom(0, (bpf_int32)port);
5076                b1 = gen_portatom(2, (bpf_int32)port);
5077                gen_and(tmp, b1);
5078                break;
5079
5080        default:
5081                abort();
5082        }
5083        gen_and(b0, b1);
5084
5085        return b1;
5086}
5087
5088static struct block *
5089gen_port(port, ip_proto, dir)
5090        int port;
5091        int ip_proto;
5092        int dir;
5093{
5094        struct block *b0, *b1, *tmp;
5095
5096        /*
5097         * ether proto ip
5098         *
5099         * For FDDI, RFC 1188 says that SNAP encapsulation is used,
5100         * not LLC encapsulation with LLCSAP_IP.
5101         *
5102         * For IEEE 802 networks - which includes 802.5 token ring
5103         * (which is what DLT_IEEE802 means) and 802.11 - RFC 1042
5104         * says that SNAP encapsulation is used, not LLC encapsulation
5105         * with LLCSAP_IP.
5106         *
5107         * For LLC-encapsulated ATM/"Classical IP", RFC 1483 and
5108         * RFC 2225 say that SNAP encapsulation is used, not LLC
5109         * encapsulation with LLCSAP_IP.
5110         *
5111         * So we always check for ETHERTYPE_IP.
5112         */
5113        b0 =  gen_linktype(ETHERTYPE_IP);
5114
5115        switch (ip_proto) {
5116        case IPPROTO_UDP:
5117        case IPPROTO_TCP:
5118        case IPPROTO_SCTP:
5119                b1 = gen_portop(port, ip_proto, dir);
5120                break;
5121
5122        case PROTO_UNDEF:
5123                tmp = gen_portop(port, IPPROTO_TCP, dir);
5124                b1 = gen_portop(port, IPPROTO_UDP, dir);
5125                gen_or(tmp, b1);
5126                tmp = gen_portop(port, IPPROTO_SCTP, dir);
5127                gen_or(tmp, b1);
5128                break;
5129
5130        default:
5131                abort();
5132        }
5133        gen_and(b0, b1);
5134        return b1;
5135}
5136
5137struct block *
5138gen_portop6(port, proto, dir)
5139        int port, proto, dir;
5140{
5141        struct block *b0, *b1, *tmp;
5142
5143        /* ip6 proto 'proto' */
5144        /* XXX - catch the first fragment of a fragmented packet? */
5145        b0 = gen_cmp(OR_NET, 6, BPF_B, (bpf_int32)proto);
5146
5147        switch (dir) {
5148        case Q_SRC:
5149                b1 = gen_portatom6(0, (bpf_int32)port);
5150                break;
5151
5152        case Q_DST:
5153                b1 = gen_portatom6(2, (bpf_int32)port);
5154                break;
5155
5156        case Q_OR:
5157        case Q_DEFAULT:
5158                tmp = gen_portatom6(0, (bpf_int32)port);
5159                b1 = gen_portatom6(2, (bpf_int32)port);
5160                gen_or(tmp, b1);
5161                break;
5162
5163        case Q_AND:
5164                tmp = gen_portatom6(0, (bpf_int32)port);
5165                b1 = gen_portatom6(2, (bpf_int32)port);
5166                gen_and(tmp, b1);
5167                break;
5168
5169        default:
5170                abort();
5171        }
5172        gen_and(b0, b1);
5173
5174        return b1;
5175}
5176
5177static struct block *
5178gen_port6(port, ip_proto, dir)
5179        int port;
5180        int ip_proto;
5181        int dir;
5182{
5183        struct block *b0, *b1, *tmp;
5184
5185        /* link proto ip6 */
5186        b0 =  gen_linktype(ETHERTYPE_IPV6);
5187
5188        switch (ip_proto) {
5189        case IPPROTO_UDP:
5190        case IPPROTO_TCP:
5191        case IPPROTO_SCTP:
5192                b1 = gen_portop6(port, ip_proto, dir);
5193                break;
5194
5195        case PROTO_UNDEF:
5196                tmp = gen_portop6(port, IPPROTO_TCP, dir);
5197                b1 = gen_portop6(port, IPPROTO_UDP, dir);
5198                gen_or(tmp, b1);
5199                tmp = gen_portop6(port, IPPROTO_SCTP, dir);
5200                gen_or(tmp, b1);
5201                break;
5202
5203        default:
5204                abort();
5205        }
5206        gen_and(b0, b1);
5207        return b1;
5208}
5209
5210/* gen_portrange code */
5211static struct block *
5212gen_portrangeatom(off, v1, v2)
5213        int off;
5214        bpf_int32 v1, v2;
5215{
5216        struct block *b1, *b2;
5217
5218        if (v1 > v2) {
5219                /*
5220                 * Reverse the order of the ports, so v1 is the lower one.
5221                 */
5222                bpf_int32 vtemp;
5223
5224                vtemp = v1;
5225                v1 = v2;
5226                v2 = vtemp;
5227        }
5228
5229        b1 = gen_cmp_ge(OR_TRAN_IPV4, off, BPF_H, v1);
5230        b2 = gen_cmp_le(OR_TRAN_IPV4, off, BPF_H, v2);
5231
5232        gen_and(b1, b2);
5233
5234        return b2;
5235}
5236
5237struct block *
5238gen_portrangeop(port1, port2, proto, dir)
5239        int port1, port2;
5240        int proto;
5241        int dir;
5242{
5243        struct block *b0, *b1, *tmp;
5244
5245        /* ip proto 'proto' and not a fragment other than the first fragment */
5246        tmp = gen_cmp(OR_NET, 9, BPF_B, (bpf_int32)proto);
5247        b0 = gen_ipfrag();
5248        gen_and(tmp, b0);
5249
5250        switch (dir) {
5251        case Q_SRC:
5252                b1 = gen_portrangeatom(0, (bpf_int32)port1, (bpf_int32)port2);
5253                break;
5254
5255        case Q_DST:
5256                b1 = gen_portrangeatom(2, (bpf_int32)port1, (bpf_int32)port2);
5257                break;
5258
5259        case Q_OR:
5260        case Q_DEFAULT:
5261                tmp = gen_portrangeatom(0, (bpf_int32)port1, (bpf_int32)port2);
5262                b1 = gen_portrangeatom(2, (bpf_int32)port1, (bpf_int32)port2);
5263                gen_or(tmp, b1);
5264                break;
5265
5266        case Q_AND:
5267                tmp = gen_portrangeatom(0, (bpf_int32)port1, (bpf_int32)port2);
5268                b1 = gen_portrangeatom(2, (bpf_int32)port1, (bpf_int32)port2);
5269                gen_and(tmp, b1);
5270                break;
5271
5272        default:
5273                abort();
5274        }
5275        gen_and(b0, b1);
5276
5277        return b1;
5278}
5279
5280static struct block *
5281gen_portrange(port1, port2, ip_proto, dir)
5282        int port1, port2;
5283        int ip_proto;
5284        int dir;
5285{
5286        struct block *b0, *b1, *tmp;
5287
5288        /* link proto ip */
5289        b0 =  gen_linktype(ETHERTYPE_IP);
5290
5291        switch (ip_proto) {
5292        case IPPROTO_UDP:
5293        case IPPROTO_TCP:
5294        case IPPROTO_SCTP:
5295                b1 = gen_portrangeop(port1, port2, ip_proto, dir);
5296                break;
5297
5298        case PROTO_UNDEF:
5299                tmp = gen_portrangeop(port1, port2, IPPROTO_TCP, dir);
5300                b1 = gen_portrangeop(port1, port2, IPPROTO_UDP, dir);
5301                gen_or(tmp, b1);
5302                tmp = gen_portrangeop(port1, port2, IPPROTO_SCTP, dir);
5303                gen_or(tmp, b1);
5304                break;
5305
5306        default:
5307                abort();
5308        }
5309        gen_and(b0, b1);
5310        return b1;
5311}
5312
5313static struct block *
5314gen_portrangeatom6(off, v1, v2)
5315        int off;
5316        bpf_int32 v1, v2;
5317{
5318        struct block *b1, *b2;
5319
5320        if (v1 > v2) {
5321                /*
5322                 * Reverse the order of the ports, so v1 is the lower one.
5323                 */
5324                bpf_int32 vtemp;
5325
5326                vtemp = v1;
5327                v1 = v2;
5328                v2 = vtemp;
5329        }
5330
5331        b1 = gen_cmp_ge(OR_TRAN_IPV6, off, BPF_H, v1);
5332        b2 = gen_cmp_le(OR_TRAN_IPV6, off, BPF_H, v2);
5333
5334        gen_and(b1, b2);
5335
5336        return b2;
5337}
5338
5339struct block *
5340gen_portrangeop6(port1, port2, proto, dir)
5341        int port1, port2;
5342        int proto;
5343        int dir;
5344{
5345        struct block *b0, *b1, *tmp;
5346
5347        /* ip6 proto 'proto' */
5348        /* XXX - catch the first fragment of a fragmented packet? */
5349        b0 = gen_cmp(OR_NET, 6, BPF_B, (bpf_int32)proto);
5350
5351        switch (dir) {
5352        case Q_SRC:
5353                b1 = gen_portrangeatom6(0, (bpf_int32)port1, (bpf_int32)port2);
5354                break;
5355
5356        case Q_DST:
5357                b1 = gen_portrangeatom6(2, (bpf_int32)port1, (bpf_int32)port2);
5358                break;
5359
5360        case Q_OR:
5361        case Q_DEFAULT:
5362                tmp = gen_portrangeatom6(0, (bpf_int32)port1, (bpf_int32)port2);
5363                b1 = gen_portrangeatom6(2, (bpf_int32)port1, (bpf_int32)port2);
5364                gen_or(tmp, b1);
5365                break;
5366
5367        case Q_AND:
5368                tmp = gen_portrangeatom6(0, (bpf_int32)port1, (bpf_int32)port2);
5369                b1 = gen_portrangeatom6(2, (bpf_int32)port1, (bpf_int32)port2);
5370                gen_and(tmp, b1);
5371                break;
5372
5373        default:
5374                abort();
5375        }
5376        gen_and(b0, b1);
5377
5378        return b1;
5379}
5380
5381static struct block *
5382gen_portrange6(port1, port2, ip_proto, dir)
5383        int port1, port2;
5384        int ip_proto;
5385        int dir;
5386{
5387        struct block *b0, *b1, *tmp;
5388
5389        /* link proto ip6 */
5390        b0 =  gen_linktype(ETHERTYPE_IPV6);
5391
5392        switch (ip_proto) {
5393        case IPPROTO_UDP:
5394        case IPPROTO_TCP:
5395        case IPPROTO_SCTP:
5396                b1 = gen_portrangeop6(port1, port2, ip_proto, dir);
5397                break;
5398
5399        case PROTO_UNDEF:
5400                tmp = gen_portrangeop6(port1, port2, IPPROTO_TCP, dir);
5401                b1 = gen_portrangeop6(port1, port2, IPPROTO_UDP, dir);
5402                gen_or(tmp, b1);
5403                tmp = gen_portrangeop6(port1, port2, IPPROTO_SCTP, dir);
5404                gen_or(tmp, b1);
5405                break;
5406
5407        default:
5408                abort();
5409        }
5410        gen_and(b0, b1);
5411        return b1;
5412}
5413
5414static int
5415lookup_proto(name, proto)
5416        register const char *name;
5417        register int proto;
5418{
5419        register int v;
5420
5421        switch (proto) {
5422
5423        case Q_DEFAULT:
5424        case Q_IP:
5425        case Q_IPV6:
5426                v = pcap_nametoproto(name);
5427                if (v == PROTO_UNDEF)
5428                        bpf_error("unknown ip proto '%s'", name);
5429                break;
5430
5431        case Q_LINK:
5432                /* XXX should look up h/w protocol type based on linktype */
5433                v = pcap_nametoeproto(name);
5434                if (v == PROTO_UNDEF) {
5435                        v = pcap_nametollc(name);
5436                        if (v == PROTO_UNDEF)
5437                                bpf_error("unknown ether proto '%s'", name);
5438                }
5439                break;
5440
5441        case Q_ISO:
5442                if (strcmp(name, "esis") == 0)
5443                        v = ISO9542_ESIS;
5444                else if (strcmp(name, "isis") == 0)
5445                        v = ISO10589_ISIS;
5446                else if (strcmp(name, "clnp") == 0)
5447                        v = ISO8473_CLNP;
5448                else
5449                        bpf_error("unknown osi proto '%s'", name);
5450                break;
5451
5452        default:
5453                v = PROTO_UNDEF;
5454                break;
5455        }
5456        return v;
5457}
5458
5459#if 0
5460struct stmt *
5461gen_joinsp(s, n)
5462        struct stmt **s;
5463        int n;
5464{
5465        return NULL;
5466}
5467#endif
5468
5469static struct block *
5470gen_protochain(v, proto, dir)
5471        int v;
5472        int proto;
5473        int dir;
5474{
5475#ifdef NO_PROTOCHAIN
5476        return gen_proto(v, proto, dir);
5477#else
5478        struct block *b0, *b;
5479        struct slist *s[100];
5480        int fix2, fix3, fix4, fix5;
5481        int ahcheck, again, end;
5482        int i, max;
5483        int reg2 = alloc_reg();
5484
5485        memset(s, 0, sizeof(s));
5486        fix2 = fix3 = fix4 = fix5 = 0;
5487
5488        switch (proto) {
5489        case Q_IP:
5490        case Q_IPV6:
5491                break;
5492        case Q_DEFAULT:
5493                b0 = gen_protochain(v, Q_IP, dir);
5494                b = gen_protochain(v, Q_IPV6, dir);
5495                gen_or(b0, b);
5496                return b;
5497        default:
5498                bpf_error("bad protocol applied for 'protochain'");
5499                /*NOTREACHED*/
5500        }
5501
5502        /*
5503         * We don't handle variable-length prefixes before the link-layer
5504         * header, or variable-length link-layer headers, here yet.
5505         * We might want to add BPF instructions to do the protochain
5506         * work, to simplify that and, on platforms that have a BPF
5507         * interpreter with the new instructions, let the filtering
5508         * be done in the kernel.  (We already require a modified BPF
5509         * engine to do the protochain stuff, to support backward
5510         * branches, and backward branch support is unlikely to appear
5511         * in kernel BPF engines.)
5512         */
5513        switch (linktype) {
5514
5515        case DLT_IEEE802_11:
5516        case DLT_PRISM_HEADER:
5517        case DLT_IEEE802_11_RADIO_AVS:
5518        case DLT_IEEE802_11_RADIO:
5519        case DLT_PPI:
5520                bpf_error("'protochain' not supported with 802.11");
5521        }
5522
5523        no_optimize = 1; /*this code is not compatible with optimzer yet */
5524
5525        /*
5526         * s[0] is a dummy entry to protect other BPF insn from damage
5527         * by s[fix] = foo with uninitialized variable "fix".  It is somewhat
5528         * hard to find interdependency made by jump table fixup.
5529         */
5530        i = 0;
5531        s[i] = new_stmt(0);     /*dummy*/
5532        i++;
5533
5534        switch (proto) {
5535        case Q_IP:
5536                b0 = gen_linktype(ETHERTYPE_IP);
5537
5538                /* A = ip->ip_p */
5539                s[i] = new_stmt(BPF_LD|BPF_ABS|BPF_B);
5540                s[i]->s.k = off_macpl + off_nl + 9;
5541                i++;
5542                /* X = ip->ip_hl << 2 */
5543                s[i] = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
5544                s[i]->s.k = off_macpl + off_nl;
5545                i++;
5546                break;
5547
5548        case Q_IPV6:
5549                b0 = gen_linktype(ETHERTYPE_IPV6);
5550
5551                /* A = ip6->ip_nxt */
5552                s[i] = new_stmt(BPF_LD|BPF_ABS|BPF_B);
5553                s[i]->s.k = off_macpl + off_nl + 6;
5554                i++;
5555                /* X = sizeof(struct ip6_hdr) */
5556                s[i] = new_stmt(BPF_LDX|BPF_IMM);
5557                s[i]->s.k = 40;
5558                i++;
5559                break;
5560
5561        default:
5562                bpf_error("unsupported proto to gen_protochain");
5563                /*NOTREACHED*/
5564        }
5565
5566        /* again: if (A == v) goto end; else fall through; */
5567        again = i;
5568        s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5569        s[i]->s.k = v;
5570        s[i]->s.jt = NULL;              /*later*/
5571        s[i]->s.jf = NULL;              /*update in next stmt*/
5572        fix5 = i;
5573        i++;
5574
5575#ifndef IPPROTO_NONE
5576#define IPPROTO_NONE    59
5577#endif
5578        /* if (A == IPPROTO_NONE) goto end */
5579        s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5580        s[i]->s.jt = NULL;      /*later*/
5581        s[i]->s.jf = NULL;      /*update in next stmt*/
5582        s[i]->s.k = IPPROTO_NONE;
5583        s[fix5]->s.jf = s[i];
5584        fix2 = i;
5585        i++;
5586
5587        if (proto == Q_IPV6) {
5588                int v6start, v6end, v6advance, j;
5589
5590                v6start = i;
5591                /* if (A == IPPROTO_HOPOPTS) goto v6advance */
5592                s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5593                s[i]->s.jt = NULL;      /*later*/
5594                s[i]->s.jf = NULL;      /*update in next stmt*/
5595                s[i]->s.k = IPPROTO_HOPOPTS;
5596                s[fix2]->s.jf = s[i];
5597                i++;
5598                /* if (A == IPPROTO_DSTOPTS) goto v6advance */
5599                s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5600                s[i]->s.jt = NULL;      /*later*/
5601                s[i]->s.jf = NULL;      /*update in next stmt*/
5602                s[i]->s.k = IPPROTO_DSTOPTS;
5603                i++;
5604                /* if (A == IPPROTO_ROUTING) goto v6advance */
5605                s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5606                s[i]->s.jt = NULL;      /*later*/
5607                s[i]->s.jf = NULL;      /*update in next stmt*/
5608                s[i]->s.k = IPPROTO_ROUTING;
5609                i++;
5610                /* if (A == IPPROTO_FRAGMENT) goto v6advance; else goto ahcheck; */
5611                s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5612                s[i]->s.jt = NULL;      /*later*/
5613                s[i]->s.jf = NULL;      /*later*/
5614                s[i]->s.k = IPPROTO_FRAGMENT;
5615                fix3 = i;
5616                v6end = i;
5617                i++;
5618
5619                /* v6advance: */
5620                v6advance = i;
5621
5622                /*
5623                 * in short,
5624                 * A = P[X + packet head];
5625                 * X = X + (P[X + packet head + 1] + 1) * 8;
5626                 */
5627                /* A = P[X + packet head] */
5628                s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
5629                s[i]->s.k = off_macpl + off_nl;
5630                i++;
5631                /* MEM[reg2] = A */
5632                s[i] = new_stmt(BPF_ST);
5633                s[i]->s.k = reg2;
5634                i++;
5635                /* A = P[X + packet head + 1]; */
5636                s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
5637                s[i]->s.k = off_macpl + off_nl + 1;
5638                i++;
5639                /* A += 1 */
5640                s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
5641                s[i]->s.k = 1;
5642                i++;
5643                /* A *= 8 */
5644                s[i] = new_stmt(BPF_ALU|BPF_MUL|BPF_K);
5645                s[i]->s.k = 8;
5646                i++;
5647                /* A += X */
5648                s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_X);
5649                s[i]->s.k = 0;
5650                i++;
5651                /* X = A; */
5652                s[i] = new_stmt(BPF_MISC|BPF_TAX);
5653                i++;
5654                /* A = MEM[reg2] */
5655                s[i] = new_stmt(BPF_LD|BPF_MEM);
5656                s[i]->s.k = reg2;
5657                i++;
5658
5659                /* goto again; (must use BPF_JA for backward jump) */
5660                s[i] = new_stmt(BPF_JMP|BPF_JA);
5661                s[i]->s.k = again - i - 1;
5662                s[i - 1]->s.jf = s[i];
5663                i++;
5664
5665                /* fixup */
5666                for (j = v6start; j <= v6end; j++)
5667                        s[j]->s.jt = s[v6advance];
5668        } else {
5669                /* nop */
5670                s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
5671                s[i]->s.k = 0;
5672                s[fix2]->s.jf = s[i];
5673                i++;
5674        }
5675
5676        /* ahcheck: */
5677        ahcheck = i;
5678        /* if (A == IPPROTO_AH) then fall through; else goto end; */
5679        s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
5680        s[i]->s.jt = NULL;      /*later*/
5681        s[i]->s.jf = NULL;      /*later*/
5682        s[i]->s.k = IPPROTO_AH;
5683        if (fix3)
5684                s[fix3]->s.jf = s[ahcheck];
5685        fix4 = i;
5686        i++;
5687
5688        /*
5689         * in short,
5690         * A = P[X];
5691         * X = X + (P[X + 1] + 2) * 4;
5692         */
5693        /* A = X */
5694        s[i - 1]->s.jt = s[i] = new_stmt(BPF_MISC|BPF_TXA);
5695        i++;
5696        /* A = P[X + packet head]; */
5697        s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
5698        s[i]->s.k = off_macpl + off_nl;
5699        i++;
5700        /* MEM[reg2] = A */
5701        s[i] = new_stmt(BPF_ST);
5702        s[i]->s.k = reg2;
5703        i++;
5704        /* A = X */
5705        s[i - 1]->s.jt = s[i] = new_stmt(BPF_MISC|BPF_TXA);
5706        i++;
5707        /* A += 1 */
5708        s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
5709        s[i]->s.k = 1;
5710        i++;
5711        /* X = A */
5712        s[i] = new_stmt(BPF_MISC|BPF_TAX);
5713        i++;
5714        /* A = P[X + packet head] */
5715        s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
5716        s[i]->s.k = off_macpl + off_nl;
5717        i++;
5718        /* A += 2 */
5719        s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
5720        s[i]->s.k = 2;
5721        i++;
5722        /* A *= 4 */
5723        s[i] = new_stmt(BPF_ALU|BPF_MUL|BPF_K);
5724        s[i]->s.k = 4;
5725        i++;
5726        /* X = A; */
5727        s[i] = new_stmt(BPF_MISC|BPF_TAX);
5728        i++;
5729        /* A = MEM[reg2] */
5730        s[i] = new_stmt(BPF_LD|BPF_MEM);
5731        s[i]->s.k = reg2;
5732        i++;
5733
5734        /* goto again; (must use BPF_JA for backward jump) */
5735        s[i] = new_stmt(BPF_JMP|BPF_JA);
5736        s[i]->s.k = again - i - 1;
5737        i++;
5738
5739        /* end: nop */
5740        end = i;
5741        s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
5742        s[i]->s.k = 0;
5743        s[fix2]->s.jt = s[end];
5744        s[fix4]->s.jf = s[end];
5745        s[fix5]->s.jt = s[end];
5746        i++;
5747
5748        /*
5749         * make slist chain
5750         */
5751        max = i;
5752        for (i = 0; i < max - 1; i++)
5753                s[i]->next = s[i + 1];
5754        s[max - 1]->next = NULL;
5755
5756        /*
5757         * emit final check
5758         */
5759        b = new_block(JMP(BPF_JEQ));
5760        b->stmts = s[1];        /*remember, s[0] is dummy*/
5761        b->s.k = v;
5762
5763        free_reg(reg2);
5764
5765        gen_and(b0, b);
5766        return b;
5767#endif
5768}
5769
5770static struct block *
5771gen_check_802_11_data_frame()
5772{
5773        struct slist *s;
5774        struct block *b0, *b1;
5775
5776        /*
5777         * A data frame has the 0x08 bit (b3) in the frame control field set
5778         * and the 0x04 bit (b2) clear.
5779         */
5780        s = gen_load_a(OR_LINK, 0, BPF_B);
5781        b0 = new_block(JMP(BPF_JSET));
5782        b0->s.k = 0x08;
5783        b0->stmts = s;
5784
5785        s = gen_load_a(OR_LINK, 0, BPF_B);
5786        b1 = new_block(JMP(BPF_JSET));
5787        b1->s.k = 0x04;
5788        b1->stmts = s;
5789        gen_not(b1);
5790
5791        gen_and(b1, b0);
5792
5793        return b0;
5794}
5795
5796/*
5797 * Generate code that checks whether the packet is a packet for protocol
5798 * <proto> and whether the type field in that protocol's header has
5799 * the value <v>, e.g. if <proto> is Q_IP, it checks whether it's an
5800 * IP packet and checks the protocol number in the IP header against <v>.
5801 *
5802 * If <proto> is Q_DEFAULT, i.e. just "proto" was specified, it checks
5803 * against Q_IP and Q_IPV6.
5804 */
5805static struct block *
5806gen_proto(v, proto, dir)
5807        int v;
5808        int proto;
5809        int dir;
5810{
5811        struct block *b0, *b1;
5812#ifndef CHASE_CHAIN
5813        struct block *b2;
5814#endif
5815
5816        if (dir != Q_DEFAULT)
5817                bpf_error("direction applied to 'proto'");
5818
5819        switch (proto) {
5820        case Q_DEFAULT:
5821                b0 = gen_proto(v, Q_IP, dir);
5822                b1 = gen_proto(v, Q_IPV6, dir);
5823                gen_or(b0, b1);
5824                return b1;
5825
5826        case Q_IP:
5827                /*
5828                 * For FDDI, RFC 1188 says that SNAP encapsulation is used,
5829                 * not LLC encapsulation with LLCSAP_IP.
5830                 *
5831                 * For IEEE 802 networks - which includes 802.5 token ring
5832                 * (which is what DLT_IEEE802 means) and 802.11 - RFC 1042
5833                 * says that SNAP encapsulation is used, not LLC encapsulation
5834                 * with LLCSAP_IP.
5835                 *
5836                 * For LLC-encapsulated ATM/"Classical IP", RFC 1483 and
5837                 * RFC 2225 say that SNAP encapsulation is used, not LLC
5838                 * encapsulation with LLCSAP_IP.
5839                 *
5840                 * So we always check for ETHERTYPE_IP.
5841                 */
5842                b0 = gen_linktype(ETHERTYPE_IP);
5843#ifndef CHASE_CHAIN
5844                b1 = gen_cmp(OR_NET, 9, BPF_B, (bpf_int32)v);
5845#else
5846                b1 = gen_protochain(v, Q_IP);
5847#endif
5848                gen_and(b0, b1);
5849                return b1;
5850
5851        case Q_ISO:
5852                switch (linktype) {
5853
5854                case DLT_FRELAY:
5855                        /*
5856                         * Frame Relay packets typically have an OSI
5857                         * NLPID at the beginning; "gen_linktype(LLCSAP_ISONS)"
5858                         * generates code to check for all the OSI
5859                         * NLPIDs, so calling it and then adding a check
5860                         * for the particular NLPID for which we're
5861                         * looking is bogus, as we can just check for
5862                         * the NLPID.
5863                         *
5864                         * What we check for is the NLPID and a frame
5865                         * control field value of UI, i.e. 0x03 followed
5866                         * by the NLPID.
5867                         *
5868                         * XXX - assumes a 2-byte Frame Relay header with
5869                         * DLCI and flags.  What if the address is longer?
5870                         *
5871                         * XXX - what about SNAP-encapsulated frames?
5872                         */
5873                        return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | v);
5874                        /*NOTREACHED*/
5875                        break;
5876
5877                case DLT_C_HDLC:
5878                        /*
5879                         * Cisco uses an Ethertype lookalike - for OSI,
5880                         * it's 0xfefe.
5881                         */
5882                        b0 = gen_linktype(LLCSAP_ISONS<<8 | LLCSAP_ISONS);
5883                        /* OSI in C-HDLC is stuffed with a fudge byte */
5884                        b1 = gen_cmp(OR_NET_NOSNAP, 1, BPF_B, (long)v);
5885                        gen_and(b0, b1);
5886                        return b1;
5887
5888                default:
5889                        b0 = gen_linktype(LLCSAP_ISONS);
5890                        b1 = gen_cmp(OR_NET_NOSNAP, 0, BPF_B, (long)v);
5891                        gen_and(b0, b1);
5892                        return b1;
5893                }
5894
5895        case Q_ISIS:
5896                b0 = gen_proto(ISO10589_ISIS, Q_ISO, Q_DEFAULT);
5897                /*
5898                 * 4 is the offset of the PDU type relative to the IS-IS
5899                 * header.
5900                 */
5901                b1 = gen_cmp(OR_NET_NOSNAP, 4, BPF_B, (long)v);
5902                gen_and(b0, b1);
5903                return b1;
5904
5905        case Q_ARP:
5906                bpf_error("arp does not encapsulate another protocol");
5907                /* NOTREACHED */
5908
5909        case Q_RARP:
5910                bpf_error("rarp does not encapsulate another protocol");
5911                /* NOTREACHED */
5912
5913        case Q_ATALK:
5914                bpf_error("atalk encapsulation is not specifiable");
5915                /* NOTREACHED */
5916
5917        case Q_DECNET:
5918                bpf_error("decnet encapsulation is not specifiable");
5919                /* NOTREACHED */
5920
5921        case Q_SCA:
5922                bpf_error("sca does not encapsulate another protocol");
5923                /* NOTREACHED */
5924
5925        case Q_LAT:
5926                bpf_error("lat does not encapsulate another protocol");
5927                /* NOTREACHED */
5928
5929        case Q_MOPRC:
5930                bpf_error("moprc does not encapsulate another protocol");
5931                /* NOTREACHED */
5932
5933        case Q_MOPDL:
5934                bpf_error("mopdl does not encapsulate another protocol");
5935                /* NOTREACHED */
5936
5937        case Q_LINK:
5938                return gen_linktype(v);
5939
5940        case Q_UDP:
5941                bpf_error("'udp proto' is bogus");
5942                /* NOTREACHED */
5943
5944        case Q_TCP:
5945                bpf_error("'tcp proto' is bogus");
5946                /* NOTREACHED */
5947
5948        case Q_SCTP:
5949                bpf_error("'sctp proto' is bogus");
5950                /* NOTREACHED */
5951
5952        case Q_ICMP:
5953                bpf_error("'icmp proto' is bogus");
5954                /* NOTREACHED */
5955
5956        case Q_IGMP:
5957                bpf_error("'igmp proto' is bogus");
5958                /* NOTREACHED */
5959
5960        case Q_IGRP:
5961                bpf_error("'igrp proto' is bogus");
5962                /* NOTREACHED */
5963
5964        case Q_PIM:
5965                bpf_error("'pim proto' is bogus");
5966                /* NOTREACHED */
5967
5968        case Q_VRRP:
5969                bpf_error("'vrrp proto' is bogus");
5970                /* NOTREACHED */
5971
5972        case Q_CARP:
5973                bpf_error("'carp proto' is bogus");
5974                /* NOTREACHED */
5975
5976        case Q_IPV6:
5977                b0 = gen_linktype(ETHERTYPE_IPV6);
5978#ifndef CHASE_CHAIN
5979                /*
5980                 * Also check for a fragment header before the final
5981                 * header.
5982                 */
5983                b2 = gen_cmp(OR_NET, 6, BPF_B, IPPROTO_FRAGMENT);
5984                b1 = gen_cmp(OR_NET, 40, BPF_B, (bpf_int32)v);
5985                gen_and(b2, b1);
5986                b2 = gen_cmp(OR_NET, 6, BPF_B, (bpf_int32)v);
5987                gen_or(b2, b1);
5988#else
5989                b1 = gen_protochain(v, Q_IPV6);
5990#endif
5991                gen_and(b0, b1);
5992                return b1;
5993
5994        case Q_ICMPV6:
5995                bpf_error("'icmp6 proto' is bogus");
5996
5997        case Q_AH:
5998                bpf_error("'ah proto' is bogus");
5999
6000        case Q_ESP:
6001                bpf_error("'ah proto' is bogus");
6002
6003        case Q_STP:
6004                bpf_error("'stp proto' is bogus");
6005
6006        case Q_IPX:
6007                bpf_error("'ipx proto' is bogus");
6008
6009        case Q_NETBEUI:
6010                bpf_error("'netbeui proto' is bogus");
6011
6012        case Q_RADIO:
6013                bpf_error("'radio proto' is bogus");
6014
6015        default:
6016                abort();
6017                /* NOTREACHED */
6018        }
6019        /* NOTREACHED */
6020}
6021
6022struct block *
6023gen_scode(name, q)
6024        register const char *name;
6025        struct qual q;
6026{
6027        int proto = q.proto;
6028        int dir = q.dir;
6029        int tproto;
6030        u_char *eaddr;
6031        bpf_u_int32 mask, addr;
6032#ifndef INET6
6033        bpf_u_int32 **alist;
6034#else
6035        int tproto6;
6036        struct sockaddr_in *sin4;
6037        struct sockaddr_in6 *sin6;
6038        struct addrinfo *res, *res0;
6039        struct in6_addr mask128;
6040#endif /*INET6*/
6041        struct block *b, *tmp;
6042        int port, real_proto;
6043        int port1, port2;
6044
6045        switch (q.addr) {
6046
6047        case Q_NET:
6048                addr = pcap_nametonetaddr(name);
6049                if (addr == 0)
6050                        bpf_error("unknown network '%s'", name);
6051                /* Left justify network addr and calculate its network mask */
6052                mask = 0xffffffff;
6053                while (addr && (addr & 0xff000000) == 0) {
6054                        addr <<= 8;
6055                        mask <<= 8;
6056                }
6057                return gen_host(addr, mask, proto, dir, q.addr);
6058
6059        case Q_DEFAULT:
6060        case Q_HOST:
6061                if (proto == Q_LINK) {
6062                        switch (linktype) {
6063
6064                        case DLT_EN10MB:
6065                        case DLT_NETANALYZER:
6066                        case DLT_NETANALYZER_TRANSPARENT:
6067                                eaddr = pcap_ether_hostton(name);
6068                                if (eaddr == NULL)
6069                                        bpf_error(
6070                                            "unknown ether host '%s'", name);
6071                                b = gen_ehostop(eaddr, dir);
6072                                free(eaddr);
6073                                return b;
6074
6075                        case DLT_FDDI:
6076                                eaddr = pcap_ether_hostton(name);
6077                                if (eaddr == NULL)
6078                                        bpf_error(
6079                                            "unknown FDDI host '%s'", name);
6080                                b = gen_fhostop(eaddr, dir);
6081                                free(eaddr);
6082                                return b;
6083
6084                        case DLT_IEEE802:
6085                                eaddr = pcap_ether_hostton(name);
6086                                if (eaddr == NULL)
6087                                        bpf_error(
6088                                            "unknown token ring host '%s'", name);
6089                                b = gen_thostop(eaddr, dir);
6090                                free(eaddr);
6091                                return b;
6092
6093                        case DLT_IEEE802_11:
6094                        case DLT_PRISM_HEADER:
6095                        case DLT_IEEE802_11_RADIO_AVS:
6096                        case DLT_IEEE802_11_RADIO:
6097                        case DLT_PPI:
6098                                eaddr = pcap_ether_hostton(name);
6099                                if (eaddr == NULL)
6100                                        bpf_error(
6101                                            "unknown 802.11 host '%s'", name);
6102                                b = gen_wlanhostop(eaddr, dir);
6103                                free(eaddr);
6104                                return b;
6105
6106                        case DLT_IP_OVER_FC:
6107                                eaddr = pcap_ether_hostton(name);
6108                                if (eaddr == NULL)
6109                                        bpf_error(
6110                                            "unknown Fibre Channel host '%s'", name);
6111                                b = gen_ipfchostop(eaddr, dir);
6112                                free(eaddr);
6113                                return b;
6114
6115                        case DLT_SUNATM:
6116                                if (!is_lane)
6117                                        break;
6118
6119                                /*
6120                                 * Check that the packet doesn't begin
6121                                 * with an LE Control marker.  (We've
6122                                 * already generated a test for LANE.)
6123                                 */
6124                                tmp = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS,
6125                                    BPF_H, 0xFF00);
6126                                gen_not(tmp);
6127
6128                                eaddr = pcap_ether_hostton(name);
6129                                if (eaddr == NULL)
6130                                        bpf_error(
6131                                            "unknown ether host '%s'", name);
6132                                b = gen_ehostop(eaddr, dir);
6133                                gen_and(tmp, b);
6134                                free(eaddr);
6135                                return b;
6136                        }
6137
6138                        bpf_error("only ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel supports link-level host name");
6139                } else if (proto == Q_DECNET) {
6140                        unsigned short dn_addr = __pcap_nametodnaddr(name);
6141                        /*
6142                         * I don't think DECNET hosts can be multihomed, so
6143                         * there is no need to build up a list of addresses
6144                         */
6145                        return (gen_host(dn_addr, 0, proto, dir, q.addr));
6146                } else {
6147#ifndef INET6
6148                        alist = pcap_nametoaddr(name);
6149                        if (alist == NULL || *alist == NULL)
6150                                bpf_error("unknown host '%s'", name);
6151                        tproto = proto;
6152                        if (off_linktype == (u_int)-1 && tproto == Q_DEFAULT)
6153                                tproto = Q_IP;
6154                        b = gen_host(**alist++, 0xffffffff, tproto, dir, q.addr);
6155                        while (*alist) {
6156                                tmp = gen_host(**alist++, 0xffffffff,
6157                                               tproto, dir, q.addr);
6158                                gen_or(b, tmp);
6159                                b = tmp;
6160                        }
6161                        return b;
6162#else
6163                        memset(&mask128, 0xff, sizeof(mask128));
6164                        res0 = res = pcap_nametoaddrinfo(name);
6165                        if (res == NULL)
6166                                bpf_error("unknown host '%s'", name);
6167                        ai = res;
6168                        b = tmp = NULL;
6169                        tproto = tproto6 = proto;
6170                        if (off_linktype == -1 && tproto == Q_DEFAULT) {
6171                                tproto = Q_IP;
6172                                tproto6 = Q_IPV6;
6173                        }
6174                        for (res = res0; res; res = res->ai_next) {
6175                                switch (res->ai_family) {
6176                                case AF_INET:
6177                                        if (tproto == Q_IPV6)
6178                                                continue;
6179
6180                                        sin4 = (struct sockaddr_in *)
6181                                                res->ai_addr;
6182                                        tmp = gen_host(ntohl(sin4->sin_addr.s_addr),
6183                                                0xffffffff, tproto, dir, q.addr);
6184                                        break;
6185                                case AF_INET6:
6186                                        if (tproto6 == Q_IP)
6187                                                continue;
6188
6189                                        sin6 = (struct sockaddr_in6 *)
6190                                                res->ai_addr;
6191                                        tmp = gen_host6(&sin6->sin6_addr,
6192                                                &mask128, tproto6, dir, q.addr);
6193                                        break;
6194                                default:
6195                                        continue;
6196                                }
6197                                if (b)
6198                                        gen_or(b, tmp);
6199                                b = tmp;
6200                        }
6201                        ai = NULL;
6202                        freeaddrinfo(res0);
6203                        if (b == NULL) {
6204                                bpf_error("unknown host '%s'%s", name,
6205                                    (proto == Q_DEFAULT)
6206                                        ? ""
6207                                        : " for specified address family");
6208                        }
6209                        return b;
6210#endif /*INET6*/
6211                }
6212
6213        case Q_PORT:
6214                if (proto != Q_DEFAULT &&
6215                    proto != Q_UDP && proto != Q_TCP && proto != Q_SCTP)
6216                        bpf_error("illegal qualifier of 'port'");
6217                if (pcap_nametoport(name, &port, &real_proto) == 0)
6218                        bpf_error("unknown port '%s'", name);
6219                if (proto == Q_UDP) {
6220                        if (real_proto == IPPROTO_TCP)
6221                                bpf_error("port '%s' is tcp", name);
6222                        else if (real_proto == IPPROTO_SCTP)
6223                                bpf_error("port '%s' is sctp", name);
6224                        else
6225                                /* override PROTO_UNDEF */
6226                                real_proto = IPPROTO_UDP;
6227                }
6228                if (proto == Q_TCP) {
6229                        if (real_proto == IPPROTO_UDP)
6230                                bpf_error("port '%s' is udp", name);
6231
6232                        else if (real_proto == IPPROTO_SCTP)
6233                                bpf_error("port '%s' is sctp", name);
6234                        else
6235                                /* override PROTO_UNDEF */
6236                                real_proto = IPPROTO_TCP;
6237                }
6238                if (proto == Q_SCTP) {
6239                        if (real_proto == IPPROTO_UDP)
6240                                bpf_error("port '%s' is udp", name);
6241
6242                        else if (real_proto == IPPROTO_TCP)
6243                                bpf_error("port '%s' is tcp", name);
6244                        else
6245                                /* override PROTO_UNDEF */
6246                                real_proto = IPPROTO_SCTP;
6247                }
6248                if (port < 0)
6249                        bpf_error("illegal port number %d < 0", port);
6250                if (port > 65535)
6251                        bpf_error("illegal port number %d > 65535", port);
6252                b = gen_port(port, real_proto, dir);
6253                gen_or(gen_port6(port, real_proto, dir), b);
6254                return b;
6255
6256        case Q_PORTRANGE:
6257                if (proto != Q_DEFAULT &&
6258                    proto != Q_UDP && proto != Q_TCP && proto != Q_SCTP)
6259                        bpf_error("illegal qualifier of 'portrange'");
6260                if (pcap_nametoportrange(name, &port1, &port2, &real_proto) == 0)
6261                        bpf_error("unknown port in range '%s'", name);
6262                if (proto == Q_UDP) {
6263                        if (real_proto == IPPROTO_TCP)
6264                                bpf_error("port in range '%s' is tcp", name);
6265                        else if (real_proto == IPPROTO_SCTP)
6266                                bpf_error("port in range '%s' is sctp", name);
6267                        else
6268                                /* override PROTO_UNDEF */
6269                                real_proto = IPPROTO_UDP;
6270                }
6271                if (proto == Q_TCP) {
6272                        if (real_proto == IPPROTO_UDP)
6273                                bpf_error("port in range '%s' is udp", name);
6274                        else if (real_proto == IPPROTO_SCTP)
6275                                bpf_error("port in range '%s' is sctp", name);
6276                        else
6277                                /* override PROTO_UNDEF */
6278                                real_proto = IPPROTO_TCP;
6279                }
6280                if (proto == Q_SCTP) {
6281                        if (real_proto == IPPROTO_UDP)
6282                                bpf_error("port in range '%s' is udp", name);
6283                        else if (real_proto == IPPROTO_TCP)
6284                                bpf_error("port in range '%s' is tcp", name);
6285                        else
6286                                /* override PROTO_UNDEF */
6287                                real_proto = IPPROTO_SCTP;
6288                }
6289                if (port1 < 0)
6290                        bpf_error("illegal port number %d < 0", port1);
6291                if (port1 > 65535)
6292                        bpf_error("illegal port number %d > 65535", port1);
6293                if (port2 < 0)
6294                        bpf_error("illegal port number %d < 0", port2);
6295                if (port2 > 65535)
6296                        bpf_error("illegal port number %d > 65535", port2);
6297
6298                b = gen_portrange(port1, port2, real_proto, dir);
6299                gen_or(gen_portrange6(port1, port2, real_proto, dir), b);
6300                return b;
6301
6302        case Q_GATEWAY:
6303#ifndef INET6
6304                eaddr = pcap_ether_hostton(name);
6305                if (eaddr == NULL)
6306                        bpf_error("unknown ether host: %s", name);
6307
6308                alist = pcap_nametoaddr(name);
6309                if (alist == NULL || *alist == NULL)
6310                        bpf_error("unknown host '%s'", name);
6311                b = gen_gateway(eaddr, alist, proto, dir);
6312                free(eaddr);
6313                return b;
6314#else
6315                bpf_error("'gateway' not supported in this configuration");
6316#endif /*INET6*/
6317
6318        case Q_PROTO:
6319                real_proto = lookup_proto(name, proto);
6320                if (real_proto >= 0)
6321                        return gen_proto(real_proto, proto, dir);
6322                else
6323                        bpf_error("unknown protocol: %s", name);
6324
6325        case Q_PROTOCHAIN:
6326                real_proto = lookup_proto(name, proto);
6327                if (real_proto >= 0)
6328                        return gen_protochain(real_proto, proto, dir);
6329                else
6330                        bpf_error("unknown protocol: %s", name);
6331
6332        case Q_UNDEF:
6333                syntax();
6334                /* NOTREACHED */
6335        }
6336        abort();
6337        /* NOTREACHED */
6338}
6339
6340struct block *
6341gen_mcode(s1, s2, masklen, q)
6342        register const char *s1, *s2;
6343        register int masklen;
6344        struct qual q;
6345{
6346        register int nlen, mlen;
6347        bpf_u_int32 n, m;
6348
6349        nlen = __pcap_atoin(s1, &n);
6350        /* Promote short ipaddr */
6351        n <<= 32 - nlen;
6352
6353        if (s2 != NULL) {
6354                mlen = __pcap_atoin(s2, &m);
6355                /* Promote short ipaddr */
6356                m <<= 32 - mlen;
6357                if ((n & ~m) != 0)
6358                        bpf_error("non-network bits set in \"%s mask %s\"",
6359                            s1, s2);
6360        } else {
6361                /* Convert mask len to mask */
6362                if (masklen > 32)
6363                        bpf_error("mask length must be <= 32");
6364                if (masklen == 0) {
6365                        /*
6366                         * X << 32 is not guaranteed by C to be 0; it's
6367                         * undefined.
6368                         */
6369                        m = 0;
6370                } else
6371                        m = 0xffffffff << (32 - masklen);
6372                if ((n & ~m) != 0)
6373                        bpf_error("non-network bits set in \"%s/%d\"",
6374                            s1, masklen);
6375        }
6376
6377        switch (q.addr) {
6378
6379        case Q_NET:
6380                return gen_host(n, m, q.proto, q.dir, q.addr);
6381
6382        default:
6383                bpf_error("Mask syntax for networks only");
6384                /* NOTREACHED */
6385        }
6386        /* NOTREACHED */
6387        return NULL;
6388}
6389
6390struct block *
6391gen_ncode(s, v, q)
6392        register const char *s;
6393        bpf_u_int32 v;
6394        struct qual q;
6395{
6396        bpf_u_int32 mask;
6397        int proto = q.proto;
6398        int dir = q.dir;
6399        register int vlen;
6400
6401        if (s == NULL)
6402                vlen = 32;
6403        else if (q.proto == Q_DECNET)
6404                vlen = __pcap_atodn(s, &v);
6405        else
6406                vlen = __pcap_atoin(s, &v);
6407
6408        switch (q.addr) {
6409
6410        case Q_DEFAULT:
6411        case Q_HOST:
6412        case Q_NET:
6413                if (proto == Q_DECNET)
6414                        return gen_host(v, 0, proto, dir, q.addr);
6415                else if (proto == Q_LINK) {
6416                        bpf_error("illegal link layer address");
6417                } else {
6418                        mask = 0xffffffff;
6419                        if (s == NULL && q.addr == Q_NET) {
6420                                /* Promote short net number */
6421                                while (v && (v & 0xff000000) == 0) {
6422                                        v <<= 8;
6423                                        mask <<= 8;
6424                                }
6425                        } else {
6426                                /* Promote short ipaddr */
6427                                v <<= 32 - vlen;
6428                                mask <<= 32 - vlen;
6429                        }
6430                        return gen_host(v, mask, proto, dir, q.addr);
6431                }
6432
6433        case Q_PORT:
6434                if (proto == Q_UDP)
6435                        proto = IPPROTO_UDP;
6436                else if (proto == Q_TCP)
6437                        proto = IPPROTO_TCP;
6438                else if (proto == Q_SCTP)
6439                        proto = IPPROTO_SCTP;
6440                else if (proto == Q_DEFAULT)
6441                        proto = PROTO_UNDEF;
6442                else
6443                        bpf_error("illegal qualifier of 'port'");
6444
6445                if (v > 65535)
6446                        bpf_error("illegal port number %u > 65535", v);
6447
6448            {
6449                struct block *b;
6450                b = gen_port((int)v, proto, dir);
6451                gen_or(gen_port6((int)v, proto, dir), b);
6452                return b;
6453            }
6454
6455        case Q_PORTRANGE:
6456                if (proto == Q_UDP)
6457                        proto = IPPROTO_UDP;
6458                else if (proto == Q_TCP)
6459                        proto = IPPROTO_TCP;
6460                else if (proto == Q_SCTP)
6461                        proto = IPPROTO_SCTP;
6462                else if (proto == Q_DEFAULT)
6463                        proto = PROTO_UNDEF;
6464                else
6465                        bpf_error("illegal qualifier of 'portrange'");
6466
6467                if (v > 65535)
6468                        bpf_error("illegal port number %u > 65535", v);
6469
6470            {
6471                struct block *b;
6472                b = gen_portrange((int)v, (int)v, proto, dir);
6473                gen_or(gen_portrange6((int)v, (int)v, proto, dir), b);
6474                return b;
6475            }
6476
6477        case Q_GATEWAY:
6478                bpf_error("'gateway' requires a name");
6479                /* NOTREACHED */
6480
6481        case Q_PROTO:
6482                return gen_proto((int)v, proto, dir);
6483
6484        case Q_PROTOCHAIN:
6485                return gen_protochain((int)v, proto, dir);
6486
6487        case Q_UNDEF:
6488                syntax();
6489                /* NOTREACHED */
6490
6491        default:
6492                abort();
6493                /* NOTREACHED */
6494        }
6495        /* NOTREACHED */
6496}
6497
6498#ifdef INET6
6499struct block *
6500gen_mcode6(s1, s2, masklen, q)
6501        register const char *s1, *s2;
6502        register int masklen;
6503        struct qual q;
6504{
6505        struct addrinfo *res;
6506        struct in6_addr *addr;
6507        struct in6_addr mask;
6508        struct block *b;
6509        u_int32_t *a, *m;
6510
6511        if (s2)
6512                bpf_error("no mask %s supported", s2);
6513
6514        res = pcap_nametoaddrinfo(s1);
6515        if (!res)
6516                bpf_error("invalid ip6 address %s", s1);
6517        ai = res;
6518        if (res->ai_next)
6519                bpf_error("%s resolved to multiple address", s1);
6520        addr = &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
6521
6522        if (sizeof(mask) * 8 < masklen)
6523                bpf_error("mask length must be <= %u", (unsigned int)(sizeof(mask) * 8));
6524        memset(&mask, 0, sizeof(mask));
6525        memset(&mask, 0xff, masklen / 8);
6526        if (masklen % 8) {
6527                mask.s6_addr[masklen / 8] =
6528                        (0xff << (8 - masklen % 8)) & 0xff;
6529        }
6530
6531        a = (u_int32_t *)addr;
6532        m = (u_int32_t *)&mask;
6533        if ((a[0] & ~m[0]) || (a[1] & ~m[1])
6534         || (a[2] & ~m[2]) || (a[3] & ~m[3])) {
6535                bpf_error("non-network bits set in \"%s/%d\"", s1, masklen);
6536        }
6537
6538        switch (q.addr) {
6539
6540        case Q_DEFAULT:
6541        case Q_HOST:
6542                if (masklen != 128)
6543                        bpf_error("Mask syntax for networks only");
6544                /* FALLTHROUGH */
6545
6546        case Q_NET:
6547                b = gen_host6(addr, &mask, q.proto, q.dir, q.addr);
6548                ai = NULL;
6549                freeaddrinfo(res);
6550                return b;
6551
6552        default:
6553                bpf_error("invalid qualifier against IPv6 address");
6554                /* NOTREACHED */
6555        }
6556        return NULL;
6557}
6558#endif /*INET6*/
6559
6560struct block *
6561gen_ecode(eaddr, q)
6562        register const u_char *eaddr;
6563        struct qual q;
6564{
6565        struct block *b, *tmp;
6566
6567        if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
6568                switch (linktype) {
6569                case DLT_EN10MB:
6570                case DLT_NETANALYZER:
6571                case DLT_NETANALYZER_TRANSPARENT:
6572                        return gen_ehostop(eaddr, (int)q.dir);
6573                case DLT_FDDI:
6574                        return gen_fhostop(eaddr, (int)q.dir);
6575                case DLT_IEEE802:
6576                        return gen_thostop(eaddr, (int)q.dir);
6577                case DLT_IEEE802_11:
6578                case DLT_PRISM_HEADER:
6579                case DLT_IEEE802_11_RADIO_AVS:
6580                case DLT_IEEE802_11_RADIO:
6581                case DLT_PPI:
6582                        return gen_wlanhostop(eaddr, (int)q.dir);
6583                case DLT_SUNATM:
6584                        if (is_lane) {
6585                                /*
6586                                 * Check that the packet doesn't begin with an
6587                                 * LE Control marker.  (We've already generated
6588                                 * a test for LANE.)
6589                                 */
6590                                tmp = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
6591                                        0xFF00);
6592                                gen_not(tmp);
6593
6594                                /*
6595                                 * Now check the MAC address.
6596                                 */
6597                                b = gen_ehostop(eaddr, (int)q.dir);
6598                                gen_and(tmp