home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / ip / trace / tcpdump-2.2.1 / tcpgram.y < prev    next >
Encoding:
Lex Description  |  1992-03-17  |  6.0 KB  |  233 lines
  1. %{
  2. /*
  3.  * Copyright (c) 1988-1990 The Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that: (1) source code distributions
  8.  * retain the above copyright notice and this paragraph in its entirety, (2)
  9.  * distributions including binary code include the above copyright notice and
  10.  * this paragraph in its entirety in the documentation or other materials
  11.  * provided with the distribution, and (3) all advertising materials mentioning
  12.  * features or use of this software display the following acknowledgement:
  13.  * ``This product includes software developed by the University of California,
  14.  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  15.  * the University nor the names of its contributors may be used to endorse
  16.  * or promote products derived from this software without specific prior
  17.  * written permission.
  18.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  19.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  20.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21.  *
  22.  * Grammar for tcpdump.
  23.  */
  24. #ifndef lint
  25. static char rcsid[] =
  26.     "@(#) $Header: tcpgram.y,v 1.29 92/03/17 13:45:08 mccanne Exp $ (LBL)";
  27. #endif
  28.  
  29. #include <stdio.h>
  30. #include <sys/types.h>
  31. #include <sys/socket.h>
  32. #include <net/if.h>
  33. #include <netinet/in.h>
  34. #include <netinet/if_ether.h>
  35.  
  36. #include "interface.h"
  37.  
  38. #include <sys/time.h>
  39. #include <net/bpf.h>
  40.  
  41. #include "gencode.h"
  42.  
  43. #define QSET(q, p, d, a) (q).proto = (p),\
  44.              (q).dir = (d),\
  45.              (q).addr = (a)
  46.  
  47. int n_errors = 0;
  48.  
  49. static struct qual qerr = { Q_UNDEF, Q_UNDEF, Q_UNDEF, Q_UNDEF };
  50.  
  51. static void
  52. yyerror()
  53. {
  54.     ++n_errors;
  55. }
  56.  
  57. %}
  58.  
  59. %union {
  60.     int i;
  61.     u_long h;
  62.     u_char *e;
  63.     char *s;
  64.     struct stmt *stmt;
  65.     struct arth *a;
  66.     struct {
  67.         struct qual q;
  68.         struct block *b;
  69.     } blk;
  70.     struct block *rblk;
  71. }
  72.  
  73. %type    <blk>    expr id nid pid term rterm qid
  74. %type    <blk>    head
  75. %type    <i>    pqual dqual aqual ndaqual
  76. %type    <a>    arth narth
  77. %type    <i>    byteop pname pnum relop irelop
  78. %type    <blk>    and or paren not null prog
  79. %type    <rblk>    other
  80.  
  81. %token  DST SRC HOST GATEWAY
  82. %token  NET PORT LESS GREATER PROTO BYTE
  83. %token  ARP RARP IP TCP UDP ICMP
  84. %token  TK_BROADCAST TK_MULTICAST
  85. %token  NUM
  86. %token  LINK
  87. %token    GEQ LEQ NEQ
  88. %token    ID EID HID
  89. %token    LSH RSH
  90. %token  LEN
  91.  
  92. %type    <s> ID
  93. %type    <e> EID
  94. %type    <h> HID
  95. %type    <i> NUM
  96.  
  97. %left OR AND
  98. %nonassoc  '!'
  99. %left '|'
  100. %left '&' 
  101. %left LSH RSH
  102. %left '+' '-'
  103. %left '*' '/'
  104. %nonassoc UMINUS
  105. %%
  106. prog:      null expr
  107. { 
  108.     finish_parse($2.b);
  109. }
  110.     | null
  111.     ;
  112. null:      /* null */        { $$.q = qerr; }
  113.     ;
  114. expr:      term
  115.     | expr and term        { gen_and($1.b, $3.b); $$ = $3; }
  116.     | expr and id        { gen_and($1.b, $3.b); $$ = $3; }
  117.     | expr or term        { gen_or($1.b, $3.b); $$ = $3; }
  118.     | expr or id        { gen_or($1.b, $3.b); $$ = $3; }
  119.     ;
  120. and:      AND            { $$ = $<blk>0; }
  121.     ;
  122. or:      OR            { $$ = $<blk>0; }
  123.     ;
  124. id:      nid
  125.     | pnum            { $$.b = gen_ncode((u_long)$1,
  126.                            $$.q = $<blk>0.q); }
  127.     | paren pid ')'        { $$ = $2; }
  128.     ;
  129. nid:      ID            { $$.b = gen_scode($1, $$.q = $<blk>0.q); }
  130.     | HID            { $$.b = gen_ncode($1, $$.q = $<blk>0.q); }
  131.     | EID            { $$.b = gen_ecode($1, $$.q = $<blk>0.q); }
  132.     | not id        { gen_not($2.b); $$ = $2; }
  133.     ;
  134. not:      '!'            { $$ = $<blk>0; }
  135.     ;
  136. paren:      '('            { $$ = $<blk>0; }
  137.     ;
  138. pid:      nid
  139.     | qid and id        { gen_and($1.b, $3.b); $$ = $3; }
  140.     | qid or id        { gen_or($1.b, $3.b); $$ = $3; }
  141.     ;
  142. qid:      pnum            { $$.b = gen_ncode((u_long)$1, 
  143.                            $$.q = $<blk>0.q); }
  144.     | pid
  145.     ;
  146. term:      rterm
  147.     | not term        { gen_not($2.b); $$ = $2; }
  148.     ;
  149. head:      pqual dqual aqual    { QSET($$.q, $1, $2, $3); }
  150.     | pqual dqual        { QSET($$.q, $1, $2, Q_DEFAULT); }
  151.     | pqual aqual        { QSET($$.q, $1, Q_DEFAULT, $2); }
  152.     | pqual PROTO        { QSET($$.q, $1, Q_DEFAULT, Q_PROTO); }
  153.     | pqual ndaqual        { QSET($$.q, $1, Q_DEFAULT, $2); }
  154.     ;
  155. rterm:      head id        { $$ = $2; }
  156.     | paren expr ')'    { $$.b = $2.b; $$.q = $1.q; }
  157.     | pname            { $$.b = gen_proto_abbrev($1); $$.q = qerr; }
  158.     | arth relop arth    { $$.b = gen_relation($2, $1, $3, 0); 
  159.                   $$.q = qerr; }
  160.     | arth irelop arth    { $$.b = gen_relation($2, $1, $3, 1); 
  161.                   $$.q = qerr; }
  162.     | other            { $$.b = $1; $$.q = qerr; }
  163.     ;
  164. /* protocol level qualifiers */
  165. pqual:      pname
  166.     |            { $$ = Q_DEFAULT; }
  167.     ;
  168. /* 'direction' qualifiers */
  169. dqual:      SRC            { $$ = Q_SRC; }
  170.     | DST            { $$ = Q_DST; }
  171.     | SRC OR DST        { $$ = Q_OR; }
  172.     | DST OR SRC        { $$ = Q_OR; }
  173.     | SRC AND DST        { $$ = Q_AND; }
  174.     | DST AND SRC        { $$ = Q_AND; }
  175.     ;
  176. /* address type qualifiers */
  177. aqual:      HOST            { $$ = Q_HOST; }
  178.     | NET            { $$ = Q_NET; }
  179.     | PORT            { $$ = Q_PORT; }
  180.     ;
  181. /* non-directional address type qualifiers */
  182. ndaqual:  GATEWAY         { $$ = Q_GATEWAY; }
  183.     ;
  184. pname:      LINK            { $$ = Q_LINK; }
  185.     | IP            { $$ = Q_IP; }
  186.     | ARP            { $$ = Q_ARP; }
  187.     | RARP            { $$ = Q_RARP; }
  188.     | TCP            { $$ = Q_TCP; }
  189.     | UDP            { $$ = Q_UDP; }
  190.     | ICMP            { $$ = Q_ICMP; }
  191.     ;
  192. other:      pqual TK_BROADCAST    { $$ = gen_broadcast($1); }
  193.     | pqual TK_MULTICAST    { $$ = gen_multicast($1); }
  194.     | LESS NUM        { $$ = gen_less($2); }
  195.     | GREATER NUM        { $$ = gen_greater($2); }
  196.     | BYTE NUM byteop NUM    { $$ = gen_byteop($3, $2, $4); }
  197.     ;
  198. relop:      '>'            { $$ = BPF_JGT; }
  199.     | GEQ            { $$ = BPF_JGE; }
  200.     | '='            { $$ = BPF_JEQ; }
  201.     ;
  202. irelop:      LEQ            { $$ = BPF_JGT; }
  203.     | '<'            { $$ = BPF_JGE; }
  204.     | NEQ            { $$ = BPF_JEQ; }
  205.     ;
  206. arth:      pnum            { $$ = gen_loadi($1); }
  207.     | narth
  208.     ;
  209. narth:      pname '[' arth ']'        { $$ = gen_load($1, $3, 1); }
  210.     | pname '[' arth ':' NUM ']'    { $$ = gen_load($1, $3, $5); }
  211.     | arth '+' arth            { $$ = gen_arth(BPF_ADD, $1, $3); }
  212.     | arth '-' arth            { $$ = gen_arth(BPF_SUB, $1, $3); }
  213.     | arth '*' arth            { $$ = gen_arth(BPF_MUL, $1, $3); }
  214.     | arth '/' arth            { $$ = gen_arth(BPF_DIV, $1, $3); }
  215.     | arth '&' arth            { $$ = gen_arth(BPF_AND, $1, $3); }
  216.     | arth '|' arth            { $$ = gen_arth(BPF_OR, $1, $3); }
  217.     | arth LSH arth            { $$ = gen_arth(BPF_LSH, $1, $3); }
  218.     | arth RSH arth            { $$ = gen_arth(BPF_RSH, $1, $3); }
  219.     | '-' arth %prec UMINUS        { $$ = gen_neg($2); }
  220.     | paren narth ')'        { $$ = $2; }
  221.     | LEN                { $$ = gen_loadlen(); }
  222.     ;
  223. byteop:      '&'            { $$ = '&'; }
  224.     | '|'            { $$ = '|'; }
  225.     | '<'            { $$ = '<'; }
  226.     | '>'            { $$ = '>'; }
  227.     | '='            { $$ = '='; }
  228.     ;
  229. pnum:      NUM
  230.     | paren pnum ')'    { $$ = $2; }
  231.     ;
  232. %%
  233.