The Tcpdump Group git mirrors - tcpdump/blob - print-ether.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 2000
   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 #ifndef lint
  22 static const char rcsid[] _U_ =
  23     "@(#) $Header: /tcpdump/master/tcpdump/print-ether.c,v 1.84 2003-11-16 09:36:20 guy Exp $ (LBL)";
  24 #endif
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <tcpdump-stdinc.h>
  31
  32 #include <stdio.h>
  33 #include <pcap.h>
  34
  35 #include "interface.h"
  36 #include "addrtoname.h"
  37 #include "ethertype.h"
  38
  39 #include "ether.h"
  40
  41 const u_char *snapend;
  42
  43 const struct tok ethertype_values[] = {
  44     { ETHERTYPE_IP,             "IPv4" },
  45     { ETHERTYPE_MPLS,           "MPLS unicast" },
  46     { ETHERTYPE_MPLS_MULTI,     "MPLS multicast" },
  47     { ETHERTYPE_IPV6,           "IPv6" },
  48     { ETHERTYPE_8021Q,          "802.1Q" },
  49     { ETHERTYPE_VMAN,           "VMAN" },
  50     { ETHERTYPE_PUP,            "PUP" },
  51     { ETHERTYPE_ARP,            "ARP"},
  52     { ETHERTYPE_REVARP ,        "Reverse ARP"},
  53     { ETHERTYPE_NS,             "NS" },
  54     { ETHERTYPE_SPRITE,         "Sprite" },
  55     { ETHERTYPE_TRAIL,          "Trail" },
  56     { ETHERTYPE_MOPDL,          "MOP DL" },
  57     { ETHERTYPE_MOPRC,          "MOP RC" },
  58     { ETHERTYPE_DN,             "DN" },
  59     { ETHERTYPE_LAT,            "LAT" },
  60     { ETHERTYPE_SCA,            "SCA" },
  61     { ETHERTYPE_LANBRIDGE,      "Lanbridge" },
  62     { ETHERTYPE_DECDNS,         "DEC DNS" },
  63     { ETHERTYPE_DECDTS,         "DEC DTS" },
  64     { ETHERTYPE_VEXP,           "VEXP" },
  65     { ETHERTYPE_VPROD,          "VPROD" },
  66     { ETHERTYPE_ATALK,          "Appletalk" },
  67     { ETHERTYPE_AARP,           "Appletalk ARP" },
  68     { ETHERTYPE_IPX,            "IPX" },
  69     { ETHERTYPE_PPP,            "PPP" },
  70     { ETHERTYPE_PPPOED,         "PPPoE D" },
  71     { ETHERTYPE_PPPOES,         "PPPoE S" },
  72     { ETHERTYPE_LOOPBACK,       "Loopback" },
  73     { 0, NULL}
  74 };
  75
  76 static inline void
  77 ether_hdr_print(register const u_char *bp, u_int length)
  78 {
  79         register const struct ether_header *ep;
  80         ep = (const struct ether_header *)bp;
  81
  82         (void)printf("%s > %s",
  83                      etheraddr_string(ESRC(ep)),
  84                      etheraddr_string(EDST(ep)));
  85
  86         if (!qflag) {
  87                 if (ntohs(ep->ether_type) <= ETHERMTU)
  88                           (void)printf(", 802.3");
  89                 else
  90                           (void)printf(", ethertype %s",
  91                                        tok2str(ethertype_values,"0x%04x", ntohs(ep->ether_type)));
  92         }
  93
  94         (void)printf(", length %u: ", length);
  95 }
  96
  97 void
  98 ether_print(const u_char *p, u_int length, u_int caplen)
  99 {
 100         struct ether_header *ep;
 101         u_short ether_type;
 102         u_short extracted_ether_type;
 103
 104         if (caplen < ETHER_HDRLEN) {
 105                 printf("[|ether]");
 106                 return;
 107         }
 108
 109         if (eflag)
 110                 ether_hdr_print(p, length);
 111
 112         length -= ETHER_HDRLEN;
 113         caplen -= ETHER_HDRLEN;
 114         ep = (struct ether_header *)p;
 115         p += ETHER_HDRLEN;
 116
 117         ether_type = ntohs(ep->ether_type);
 118
 119         /*
 120          * Is it (gag) an 802.3 encapsulation?
 121          */
 122         extracted_ether_type = 0;
 123         if (ether_type <= ETHERMTU) {
 124                 /* Try to print the LLC-layer header & higher layers */
 125                 if (llc_print(p, length, caplen, ESRC(ep), EDST(ep),
 126                     &extracted_ether_type) == 0) {
 127                         /* ether_type not known, print raw packet */
 128                         if (!eflag)
 129                                 ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);
 130
 131                         if (!xflag && !qflag)
 132                                 default_print(p, caplen);
 133                 }
 134         } else if (ether_encap_print(ether_type, p, length, caplen,
 135             &extracted_ether_type) == 0) {
 136                 /* ether_type not known, print raw packet */
 137                 if (!eflag)
 138                         ether_hdr_print((u_char *)ep, length + ETHER_HDRLEN);
 139
 140                 if (!xflag && !qflag)
 141                         default_print(p, caplen);
 142         }
 143 }
 144
 145 /*
 146  * This is the top level routine of the printer.  'p' points
 147  * to the ether header of the packet, 'h->ts' is the timestamp,
 148  * 'h->length' is the length of the packet off the wire, and 'h->caplen'
 149  * is the number of bytes actually captured.
 150  */
 151 u_int
 152 ether_if_print(const struct pcap_pkthdr *h, const u_char *p)
 153 {
 154         ether_print(p, h->len, h->caplen);
 155
 156         return (ETHER_HDRLEN);
 157 }
 158
 159 /*
 160  * Prints the packet encapsulated in an Ethernet data segment
 161  * (or an equivalent encapsulation), given the Ethernet type code.
 162  *
 163  * Returns non-zero if it can do so, zero if the ethertype is unknown.
 164  *
 165  * The Ethernet type code is passed through a pointer; if it was
 166  * ETHERTYPE_8021Q, it gets updated to be the Ethernet type of
 167  * the 802.1Q payload, for the benefit of lower layers that might
 168  * want to know what it is.
 169  */
 170
 171 int
 172 ether_encap_print(u_short ether_type, const u_char *p,
 173     u_int length, u_int caplen, u_short *extracted_ether_type)
 174 {
 175  recurse:
 176         *extracted_ether_type = ether_type;
 177
 178         switch (ether_type) {
 179
 180         case ETHERTYPE_IP:
 181                 ip_print(p, length);
 182                 return (1);
 183
 184 #ifdef INET6
 185         case ETHERTYPE_IPV6:
 186                 ip6_print(p, length);
 187                 return (1);
 188 #endif /*INET6*/
 189
 190         case ETHERTYPE_ARP:
 191         case ETHERTYPE_REVARP:
 192                 arp_print(p, length, caplen);
 193                 return (1);
 194
 195         case ETHERTYPE_DN:
 196                 decnet_print(p, length, caplen);
 197                 return (1);
 198
 199         case ETHERTYPE_ATALK:
 200                 if (vflag)
 201                         fputs("et1 ", stdout);
 202                 atalk_print(p, length);
 203                 return (1);
 204
 205         case ETHERTYPE_AARP:
 206                 aarp_print(p, length);
 207                 return (1);
 208
 209         case ETHERTYPE_IPX:
 210                 printf("(NOV-ETHII) ");
 211                 ipx_print(p, length);
 212                 return (1);
 213
 214         case ETHERTYPE_8021Q:
 215                 if (eflag)
 216                     printf("vlan %u, p %u%s, ",
 217                            ntohs(*(u_int16_t *)p) & 0xfff,
 218                            ntohs(*(u_int16_t *)p) >> 13,
 219                            (ntohs(*(u_int16_t *)p) & 0x1000) ? ", CFI" : "");
 220
 221                 ether_type = ntohs(*(u_int16_t *)(p + 2));
 222                 p += 4;
 223                 length -= 4;
 224                 caplen -= 4;
 225
 226                 if (ether_type > ETHERMTU) {
 227                         if (eflag)
 228                                 printf("ethertype %s, ",
 229                                        tok2str(ethertype_values,"0x%04x", ether_type));
 230                         goto recurse;
 231                 }
 232
 233                 *extracted_ether_type = 0;
 234
 235                 if (llc_print(p, length, caplen, p - 18, p - 12,
 236                     extracted_ether_type) == 0) {
 237                                 ether_hdr_print(p - 18, length + 4);
 238                 }
 239
 240                 if (!xflag && !qflag)
 241                         default_print(p - 18, caplen + 4);
 242
 243                 return (1);
 244
 245         case ETHERTYPE_PPPOED:
 246         case ETHERTYPE_PPPOES:
 247                 pppoe_print(p, length);
 248                 return (1);
 249
 250         case ETHERTYPE_PPP:
 251                 if (length) {
 252                         printf(": ");
 253                         ppp_print(p, length);
 254                 }
 255                 return (1);
 256
 257         case ETHERTYPE_LOOPBACK:
 258                 return (1);
 259
 260         case ETHERTYPE_MPLS:
 261         case ETHERTYPE_MPLS_MULTI:
 262                 mpls_print(p, length);
 263                 return (1);
 264
 265         case ETHERTYPE_LAT:
 266         case ETHERTYPE_SCA:
 267         case ETHERTYPE_MOPRC:
 268         case ETHERTYPE_MOPDL:
 269                 /* default_print for now */
 270         default:
 271                 return (0);
 272         }
 273 }