contrib/tcpdump/print-token.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * Hacked version of print-ether.c  Larry Lile <lile@stdio.com>
  22  */
  23 #ifndef lint
  24 static const char rcsid[] =
  25     "@(#) $Header$";
  26 #endif
  27
  28 #include <sys/param.h>
  29 #include <sys/time.h>
  30 #include <sys/socket.h>
  31
  32 #if __STDC__
  33 struct mbuf;
  34 struct rtentry;
  35 #endif
  36 #include <net/if.h>
  37
  38 #include "token.h"
  39
  40 #include <netinet/in.h>
  41 #include <net/ethernet.h>
  42 #include <netinet/in_systm.h>
  43 #include <netinet/ip.h>
  44 #include <netinet/ip_var.h>
  45 #include <netinet/udp.h>
  46 #include <netinet/udp_var.h>
  47 #include <netinet/tcp.h>
  48 #include <netinet/tcpip.h>
  49
  50 #include <stdio.h>
  51 #include <pcap.h>
  52
  53 #include "interface.h"
  54 #include "addrtoname.h"
  55 #include "ethertype.h"
  56 #include "llc.h"
  57
  58 const u_char *packetp;
  59 const u_char *snapend;
  60
  61 static inline void
  62 token_print(register const u_char *bp, u_int length)
  63 {
  64         register const struct token_header *tp;
  65         register const struct llc *lp;
  66         u_short ether_type;
  67
  68         tp = (const struct token_header *)bp;
  69         lp = (struct llc *)(bp + TOKEN_HDR_LEN);
  70         if (IS_SOURCE_ROUTED)
  71                 lp = (struct llc *)(bp + TOKEN_HDR_LEN + RIF_LENGTH);
  72
  73         /*
  74          * Ethertype on ethernet is a short, but ethertype in an llc-snap has
  75          * been defined as 2 u_chars.  This is a stupid little hack to fix
  76          * this for now but something better should be done using ntohs()
  77          * XXX
  78          */
  79          ether_type = ((u_short)lp->ethertype[1] << 16) | lp->ethertype[0];
  80
  81         if (qflag)
  82                 (void)printf("%s %s %d: ",
  83                              etheraddr_string(ESRC(tp)),
  84                              etheraddr_string(EDST(tp)),
  85                              length);
  86         else
  87                 (void)printf("%s %s %s %d: ",
  88                              etheraddr_string(ESRC(tp)),
  89                              etheraddr_string(EDST(tp)),
  90                              etherproto_string(ether_type),
  91                              length);
  92 }
  93
  94 /*
  95  * This is the top level routine of the printer.  'p' is the points
  96  * to the ether header of the packet, 'tvp' is the timestamp,
  97  * 'length' is the length of the packet off the wire, and 'caplen'
  98  * is the number of bytes actually captured.
  99  */
 100 void
 101 token_if_print(u_char *user, const struct pcap_pkthdr *h, const u_char *p)
 102 {
 103         u_int caplen = h->caplen;
 104         u_int length = h->len;
 105         struct token_header *tp;
 106         u_short ether_type;
 107         extern u_short extracted_ethertype;
 108         u_int route_len = 0;
 109         struct llc *lp;
 110
 111         tp = (struct token_header *)p;
 112
 113         ts_print(&h->ts);
 114
 115         if (caplen < TOKEN_HDR_LEN) {
 116                 printf("[|token-ring]");
 117                 goto out;
 118         }
 119
 120         if (eflag)
 121                 token_print(p, length);
 122
 123         /*
 124          * Some printers want to get back at the ethernet addresses,
 125          * and/or check that they're not walking off the end of the packet.
 126          * Rather than pass them all the way down, we set these globals.
 127          */
 128         tp = (struct token_header *)p;
 129
 130         /* Adjust for source routing information in the MAC header */
 131         if (IS_SOURCE_ROUTED) {
 132                 route_len =  RIF_LENGTH;
 133         }
 134
 135         /* Set pointer to llc header, adjusted for routing information */
 136         lp = (struct llc *)(p + TOKEN_HDR_LEN + route_len);
 137
 138         packetp = p;
 139         snapend = p + caplen;
 140
 141         /* Skip over token ring MAC header */
 142         length -= TOKEN_HDR_LEN + route_len;
 143         caplen -= TOKEN_HDR_LEN + route_len;
 144         p += TOKEN_HDR_LEN + route_len;
 145
 146         ether_type = ntohs((int)lp->ethertype);
 147
 148         extracted_ethertype = 0;
 149         /* Try to print the LLC-layer header & higher layers */
 150         if (llc_print(p, length, caplen, ESRC(tp), EDST(tp)) == 0) {
 151                 /* ether_type not known, print raw packet */
 152                 if (!eflag)
 153                         token_print((u_char *)tp, length);
 154                 if (extracted_ethertype) {
 155                         printf("(LLC %s) ",
 156                        etherproto_string(htons(extracted_ethertype)));
 157                 }
 158                 if (!xflag && !qflag)
 159                         default_print(p, caplen);
 160         }
 161         if (xflag)
 162                 default_print(p, caplen);
 163  out:
 164         putchar('\n');
 165 }