0acb7a329a
Some of the stuff (e.g., rarpd, bootpd, dhcpd etc., libsa) still will only support Ethernet. Tcpdump itself should be ok, but libpcap needs lot of work. For the detailed change history, look at the commit log entries for the is-newarp branch.
288 lines
7.1 KiB
Plaintext
288 lines
7.1 KiB
Plaintext
%{
|
|
/* $NetBSD: grammar.y,v 1.4 1997/03/15 18:34:03 is Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that: (1) source code distributions
|
|
* retain the above copyright notice and this paragraph in its entirety, (2)
|
|
* distributions including binary code include the above copyright notice and
|
|
* this paragraph in its entirety in the documentation or other materials
|
|
* provided with the distribution, and (3) all advertising materials mentioning
|
|
* features or use of this software display the following acknowledgement:
|
|
* ``This product includes software developed by the University of California,
|
|
* Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
|
|
* the University nor the names of its contributors may be used to endorse
|
|
* or promote products derived from this software without specific prior
|
|
* written permission.
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
*/
|
|
#ifndef lint
|
|
static char rcsid[] =
|
|
"@(#) Header: grammar.y,v 1.54 96/07/17 00:11:34 leres Exp (LBL)";
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/socket.h>
|
|
|
|
#if __STDC__
|
|
struct mbuf;
|
|
struct rtentry;
|
|
#endif
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <netinet/in.h>
|
|
#ifdef __NetBSD__
|
|
#include <net/if_ether.h>
|
|
#else
|
|
#include <netinet/if_ether.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "pcap-int.h"
|
|
|
|
#include "gencode.h"
|
|
#include <pcap-namedb.h>
|
|
|
|
#include "gnuc.h"
|
|
#ifdef HAVE_OS_PROTO_H
|
|
#include "os-proto.h"
|
|
#endif
|
|
|
|
#define QSET(q, p, d, a) (q).proto = (p),\
|
|
(q).dir = (d),\
|
|
(q).addr = (a)
|
|
|
|
int n_errors = 0;
|
|
|
|
static struct qual qerr = { Q_UNDEF, Q_UNDEF, Q_UNDEF, Q_UNDEF };
|
|
|
|
static void
|
|
yyerror(char *msg)
|
|
{
|
|
++n_errors;
|
|
bpf_error(msg);
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
#ifndef YYBISON
|
|
int yyparse(void);
|
|
|
|
int
|
|
pcap_parse()
|
|
{
|
|
return (yyparse());
|
|
}
|
|
#endif
|
|
|
|
%}
|
|
|
|
%union {
|
|
int i;
|
|
bpf_u_int32 h;
|
|
u_char *e;
|
|
char *s;
|
|
struct stmt *stmt;
|
|
struct arth *a;
|
|
struct {
|
|
struct qual q;
|
|
struct block *b;
|
|
} blk;
|
|
struct block *rblk;
|
|
}
|
|
|
|
%type <blk> expr id nid pid term rterm qid
|
|
%type <blk> head
|
|
%type <i> pqual dqual aqual ndaqual
|
|
%type <a> arth narth
|
|
%type <i> byteop pname pnum relop irelop
|
|
%type <blk> and or paren not null prog
|
|
%type <rblk> other
|
|
|
|
%token DST SRC HOST GATEWAY
|
|
%token NET MASK PORT LESS GREATER PROTO BYTE
|
|
%token ARP RARP IP TCP UDP ICMP IGMP IGRP
|
|
%token ATALK DECNET LAT SCA MOPRC MOPDL
|
|
%token TK_BROADCAST TK_MULTICAST
|
|
%token NUM INBOUND OUTBOUND
|
|
%token LINK
|
|
%token GEQ LEQ NEQ
|
|
%token ID EID HID
|
|
%token LSH RSH
|
|
%token LEN
|
|
|
|
%type <s> ID
|
|
%type <e> EID
|
|
%type <s> HID
|
|
%type <i> NUM
|
|
|
|
%left OR AND
|
|
%nonassoc '!'
|
|
%left '|'
|
|
%left '&'
|
|
%left LSH RSH
|
|
%left '+' '-'
|
|
%left '*' '/'
|
|
%nonassoc UMINUS
|
|
%%
|
|
prog: null expr
|
|
{
|
|
finish_parse($2.b);
|
|
}
|
|
| null
|
|
;
|
|
null: /* null */ { $$.q = qerr; }
|
|
;
|
|
expr: term
|
|
| expr and term { gen_and($1.b, $3.b); $$ = $3; }
|
|
| expr and id { gen_and($1.b, $3.b); $$ = $3; }
|
|
| expr or term { gen_or($1.b, $3.b); $$ = $3; }
|
|
| expr or id { gen_or($1.b, $3.b); $$ = $3; }
|
|
;
|
|
and: AND { $$ = $<blk>0; }
|
|
;
|
|
or: OR { $$ = $<blk>0; }
|
|
;
|
|
id: nid
|
|
| pnum { $$.b = gen_ncode(NULL, (bpf_u_int32)$1,
|
|
$$.q = $<blk>0.q); }
|
|
| paren pid ')' { $$ = $2; }
|
|
;
|
|
nid: ID { $$.b = gen_scode($1, $$.q = $<blk>0.q); }
|
|
| HID '/' NUM { $$.b = gen_mcode($1, NULL, $3,
|
|
$$.q = $<blk>0.q); }
|
|
| HID MASK HID { $$.b = gen_mcode($1, $3, 0,
|
|
$$.q = $<blk>0.q); }
|
|
| HID {
|
|
/* Decide how to parse HID based on proto */
|
|
$$.q = $<blk>0.q;
|
|
switch ($$.q.proto) {
|
|
case Q_DECNET:
|
|
$$.b = gen_ncode($1, 0, $$.q);
|
|
break;
|
|
default:
|
|
$$.b = gen_ncode($1, 0, $$.q);
|
|
break;
|
|
}
|
|
}
|
|
| EID { $$.b = gen_ecode($1, $$.q = $<blk>0.q); }
|
|
| not id { gen_not($2.b); $$ = $2; }
|
|
;
|
|
not: '!' { $$ = $<blk>0; }
|
|
;
|
|
paren: '(' { $$ = $<blk>0; }
|
|
;
|
|
pid: nid
|
|
| qid and id { gen_and($1.b, $3.b); $$ = $3; }
|
|
| qid or id { gen_or($1.b, $3.b); $$ = $3; }
|
|
;
|
|
qid: pnum { $$.b = gen_ncode(NULL, (bpf_u_int32)$1,
|
|
$$.q = $<blk>0.q); }
|
|
| pid
|
|
;
|
|
term: rterm
|
|
| not term { gen_not($2.b); $$ = $2; }
|
|
;
|
|
head: pqual dqual aqual { QSET($$.q, $1, $2, $3); }
|
|
| pqual dqual { QSET($$.q, $1, $2, Q_DEFAULT); }
|
|
| pqual aqual { QSET($$.q, $1, Q_DEFAULT, $2); }
|
|
| pqual PROTO { QSET($$.q, $1, Q_DEFAULT, Q_PROTO); }
|
|
| pqual ndaqual { QSET($$.q, $1, Q_DEFAULT, $2); }
|
|
;
|
|
rterm: head id { $$ = $2; }
|
|
| paren expr ')' { $$.b = $2.b; $$.q = $1.q; }
|
|
| pname { $$.b = gen_proto_abbrev($1); $$.q = qerr; }
|
|
| arth relop arth { $$.b = gen_relation($2, $1, $3, 0);
|
|
$$.q = qerr; }
|
|
| arth irelop arth { $$.b = gen_relation($2, $1, $3, 1);
|
|
$$.q = qerr; }
|
|
| other { $$.b = $1; $$.q = qerr; }
|
|
;
|
|
/* protocol level qualifiers */
|
|
pqual: pname
|
|
| { $$ = Q_DEFAULT; }
|
|
;
|
|
/* 'direction' qualifiers */
|
|
dqual: SRC { $$ = Q_SRC; }
|
|
| DST { $$ = Q_DST; }
|
|
| SRC OR DST { $$ = Q_OR; }
|
|
| DST OR SRC { $$ = Q_OR; }
|
|
| SRC AND DST { $$ = Q_AND; }
|
|
| DST AND SRC { $$ = Q_AND; }
|
|
;
|
|
/* address type qualifiers */
|
|
aqual: HOST { $$ = Q_HOST; }
|
|
| NET { $$ = Q_NET; }
|
|
| PORT { $$ = Q_PORT; }
|
|
;
|
|
/* non-directional address type qualifiers */
|
|
ndaqual: GATEWAY { $$ = Q_GATEWAY; }
|
|
;
|
|
pname: LINK { $$ = Q_LINK; }
|
|
| IP { $$ = Q_IP; }
|
|
| ARP { $$ = Q_ARP; }
|
|
| RARP { $$ = Q_RARP; }
|
|
| TCP { $$ = Q_TCP; }
|
|
| UDP { $$ = Q_UDP; }
|
|
| ICMP { $$ = Q_ICMP; }
|
|
| IGMP { $$ = Q_IGMP; }
|
|
| IGRP { $$ = Q_IGRP; }
|
|
| ATALK { $$ = Q_ATALK; }
|
|
| DECNET { $$ = Q_DECNET; }
|
|
| LAT { $$ = Q_LAT; }
|
|
| SCA { $$ = Q_SCA; }
|
|
| MOPDL { $$ = Q_MOPDL; }
|
|
| MOPRC { $$ = Q_MOPRC; }
|
|
;
|
|
other: pqual TK_BROADCAST { $$ = gen_broadcast($1); }
|
|
| pqual TK_MULTICAST { $$ = gen_multicast($1); }
|
|
| LESS NUM { $$ = gen_less($2); }
|
|
| GREATER NUM { $$ = gen_greater($2); }
|
|
| BYTE NUM byteop NUM { $$ = gen_byteop($3, $2, $4); }
|
|
| INBOUND { $$ = gen_inbound(0); }
|
|
| OUTBOUND { $$ = gen_inbound(1); }
|
|
;
|
|
relop: '>' { $$ = BPF_JGT; }
|
|
| GEQ { $$ = BPF_JGE; }
|
|
| '=' { $$ = BPF_JEQ; }
|
|
;
|
|
irelop: LEQ { $$ = BPF_JGT; }
|
|
| '<' { $$ = BPF_JGE; }
|
|
| NEQ { $$ = BPF_JEQ; }
|
|
;
|
|
arth: pnum { $$ = gen_loadi($1); }
|
|
| narth
|
|
;
|
|
narth: pname '[' arth ']' { $$ = gen_load($1, $3, 1); }
|
|
| pname '[' arth ':' NUM ']' { $$ = gen_load($1, $3, $5); }
|
|
| arth '+' arth { $$ = gen_arth(BPF_ADD, $1, $3); }
|
|
| arth '-' arth { $$ = gen_arth(BPF_SUB, $1, $3); }
|
|
| arth '*' arth { $$ = gen_arth(BPF_MUL, $1, $3); }
|
|
| arth '/' arth { $$ = gen_arth(BPF_DIV, $1, $3); }
|
|
| arth '&' arth { $$ = gen_arth(BPF_AND, $1, $3); }
|
|
| arth '|' arth { $$ = gen_arth(BPF_OR, $1, $3); }
|
|
| arth LSH arth { $$ = gen_arth(BPF_LSH, $1, $3); }
|
|
| arth RSH arth { $$ = gen_arth(BPF_RSH, $1, $3); }
|
|
| '-' arth %prec UMINUS { $$ = gen_neg($2); }
|
|
| paren narth ')' { $$ = $2; }
|
|
| LEN { $$ = gen_loadlen(); }
|
|
;
|
|
byteop: '&' { $$ = '&'; }
|
|
| '|' { $$ = '|'; }
|
|
| '<' { $$ = '<'; }
|
|
| '>' { $$ = '>'; }
|
|
| '=' { $$ = '='; }
|
|
;
|
|
pnum: NUM
|
|
| paren pnum ')' { $$ = $2; }
|
|
;
|
|
%%
|