dist/tcpdump/print-gre.c

   1 /*      $NetBSD$        */
   2
   3 /*      $OpenBSD: print-gre.c,v 1.6 2002/10/30 03:04:04 fgsch Exp $     */
   4
   5 /*
   6  * Copyright (c) 2002 Jason L. Wright (jason@thought.net)
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by Jason L. Wright
  20  * 4. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  27  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  28  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  29  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  32  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /*
  37  * tcpdump filter for GRE - Generic Routing Encapsulation
  38  * RFC1701 (GRE), RFC1702 (GRE IPv4), and RFC2637 (Enhanced GRE)
  39  */
  40
  41 #include <sys/cdefs.h>
  42 #ifndef lint
  43 #if 0
  44 static const char rcsid[] _U_ =
  45     "@(#) Header: /tcpdump/master/tcpdump/print-gre.c,v 1.28 2005/04/06 21:32:39 mcr Exp (LBL)";
  46 #else
  47 __RCSID("$NetBSD: tcpdump2rcsid.ex,v 1.1 2001/06/25 20:09:58 itojun Exp $");
  48 #endif
  49 #endif
  50
  51 #ifdef HAVE_CONFIG_H
  52 #include "config.h"
  53 #endif
  54
  55 #include <tcpdump-stdinc.h>
  56
  57 #include <stdio.h>
  58 #include <string.h>
  59
  60 #include "interface.h"
  61 #include "addrtoname.h"
  62 #include "extract.h"
  63
  64 #include "ip.h"
  65 #include "ethertype.h"
  66
  67 #define GRE_CP          0x8000          /* checksum present */
  68 #define GRE_RP          0x4000          /* routing present */
  69 #define GRE_KP          0x2000          /* key present */
  70 #define GRE_SP          0x1000          /* sequence# present */
  71 #define GRE_sP          0x0800          /* source routing */
  72 #define GRE_RECRS       0x0700          /* recursion count */
  73 #define GRE_AP          0x0080          /* acknowledgment# present */
  74
  75 struct tok gre_flag_values[] = {
  76     { GRE_CP, "checksum present"},
  77     { GRE_RP, "routing present"},
  78     { GRE_KP, "key present"},
  79     { GRE_SP, "sequence# present"},
  80     { GRE_sP, "source routing present"},
  81     { GRE_RECRS, "recursion count"},
  82     { GRE_AP, "ack present"},
  83     { 0, NULL }
  84 };
  85
  86 #define GRE_VERS_MASK   0x0007          /* protocol version */
  87
  88 /* source route entry types */
  89 #define GRESRE_IP       0x0800          /* IP */
  90 #define GRESRE_ASN      0xfffe          /* ASN */
  91
  92 void gre_print_0(const u_char *, u_int);
  93 void gre_print_1(const u_char *, u_int);
  94 void gre_sre_print(u_int16_t, u_int8_t, u_int8_t, const u_char *, u_int);
  95 void gre_sre_ip_print(u_int8_t, u_int8_t, const u_char *, u_int);
  96 void gre_sre_asn_print(u_int8_t, u_int8_t, const u_char *, u_int);
  97
  98 void
  99 gre_print(const u_char *bp, u_int length)
 100 {
 101         u_int len = length, vers;
 102
 103         if (len < 2) {
 104                 printf("[|gre]");
 105                 return;
 106         }
 107         vers = EXTRACT_16BITS(bp) & GRE_VERS_MASK;
 108         printf("GREv%u",vers);
 109
 110         switch(vers) {
 111         case 0:
 112             gre_print_0(bp, len);
 113             break;
 114         case 1:
 115             gre_print_1(bp, len);
 116             break;
 117         default:
 118             printf(" ERROR: unknown-version");
 119             break;
 120         }
 121         return;
 122
 123 }
 124
 125 void
 126 gre_print_0(const u_char *bp, u_int length)
 127 {
 128         u_int len = length;
 129         u_int16_t flags, prot;
 130
 131         flags = EXTRACT_16BITS(bp);
 132         if (vflag)
 133             printf(", Flags [%s]",
 134                    bittok2str(gre_flag_values,"none",flags));
 135
 136         len -= 2;
 137         bp += 2;
 138
 139         if (len < 2)
 140                 goto trunc;
 141         prot = EXTRACT_16BITS(bp);
 142         len -= 2;
 143         bp += 2;
 144
 145         if ((flags & GRE_CP) | (flags & GRE_RP)) {
 146                 if (len < 2)
 147                         goto trunc;
 148                 if (vflag)
 149                         printf(", sum 0x%x", EXTRACT_16BITS(bp));
 150                 bp += 2;
 151                 len -= 2;
 152
 153                 if (len < 2)
 154                         goto trunc;
 155                 printf(", off 0x%x", EXTRACT_16BITS(bp));
 156                 bp += 2;
 157                 len -= 2;
 158         }
 159
 160         if (flags & GRE_KP) {
 161                 if (len < 4)
 162                         goto trunc;
 163                 printf(", key=0x%x", EXTRACT_32BITS(bp));
 164                 bp += 4;
 165                 len -= 4;
 166         }
 167
 168         if (flags & GRE_SP) {
 169                 if (len < 4)
 170                         goto trunc;
 171                 printf(", seq %u", EXTRACT_32BITS(bp));
 172                 bp += 4;
 173                 len -= 4;
 174         }
 175
 176         if (flags & GRE_RP) {
 177                 for (;;) {
 178                         u_int16_t af;
 179                         u_int8_t sreoff;
 180                         u_int8_t srelen;
 181
 182                         if (len < 4)
 183                                 goto trunc;
 184                         af = EXTRACT_16BITS(bp);
 185                         sreoff = *(bp + 2);
 186                         srelen = *(bp + 3);
 187                         bp += 4;
 188                         len -= 4;
 189
 190                         if (af == 0 && srelen == 0)
 191                                 break;
 192
 193                         gre_sre_print(af, sreoff, srelen, bp, len);
 194
 195                         if (len < srelen)
 196                                 goto trunc;
 197                         bp += srelen;
 198                         len -= srelen;
 199                 }
 200         }
 201
 202         if (eflag)
 203             printf(", proto %s (0x%04x)",
 204                    tok2str(ethertype_values,"unknown",prot),
 205                    prot);
 206
 207         printf(", length %u",length);
 208
 209         if (vflag < 1)
 210             printf(": "); /* put in a colon as protocol demarc */
 211         else
 212             printf("\n\t"); /* if verbose go multiline */
 213
 214         switch (prot) {
 215         case ETHERTYPE_IP:
 216                 ip_print(gndo, bp, len);
 217                 break;
 218 #ifdef INET6
 219         case ETHERTYPE_IPV6:
 220                 ip6_print(bp, len);
 221                 break;
 222 #endif
 223         case ETHERTYPE_MPLS:
 224                 mpls_print(bp, len);
 225                 break;
 226         case ETHERTYPE_IPX:
 227                 ipx_print(bp, len);
 228                 break;
 229         case ETHERTYPE_ATALK:
 230                 atalk_print(bp, len);
 231                 break;
 232         case ETHERTYPE_GRE_ISO:
 233                 isoclns_print(bp, len, len);
 234                 break;
 235         default:
 236                 printf("gre-proto-0x%x", prot);
 237         }
 238         return;
 239
 240 trunc:
 241         printf("[|gre]");
 242 }
 243
 244 void
 245 gre_print_1(const u_char *bp, u_int length)
 246 {
 247         u_int len = length;
 248         u_int16_t flags, prot;
 249
 250         flags = EXTRACT_16BITS(bp);
 251         len -= 2;
 252         bp += 2;
 253
 254         if (vflag)
 255             printf(", Flags [%s]",
 256                    bittok2str(gre_flag_values,"none",flags));
 257
 258         if (len < 2)
 259                 goto trunc;
 260         prot = EXTRACT_16BITS(bp);
 261         len -= 2;
 262         bp += 2;
 263
 264
 265         if (flags & GRE_KP) {
 266                 u_int32_t k;
 267
 268                 if (len < 4)
 269                         goto trunc;
 270                 k = EXTRACT_32BITS(bp);
 271                 printf(", call %d", k & 0xffff);
 272                 len -= 4;
 273                 bp += 4;
 274         }
 275
 276         if (flags & GRE_SP) {
 277                 if (len < 4)
 278                         goto trunc;
 279                 printf(", seq %u", EXTRACT_32BITS(bp));
 280                 bp += 4;
 281                 len -= 4;
 282         }
 283
 284         if (flags & GRE_AP) {
 285                 if (len < 4)
 286                         goto trunc;
 287                 printf(", ack %u", EXTRACT_32BITS(bp));
 288                 bp += 4;
 289                 len -= 4;
 290         }
 291
 292         if ((flags & GRE_SP) == 0)
 293                 printf(", no-payload");
 294
 295         if (eflag)
 296             printf(", proto %s (0x%04x)",
 297                    tok2str(ethertype_values,"unknown",prot),
 298                    prot);
 299
 300         printf(", length %u",length);
 301
 302         if ((flags & GRE_SP) == 0)
 303             return;
 304
 305         if (vflag < 1)
 306             printf(": "); /* put in a colon as protocol demarc */
 307         else
 308             printf("\n\t"); /* if verbose go multiline */
 309
 310         switch (prot) {
 311         case ETHERTYPE_PPP:
 312                 ppp_print(bp, len);
 313                 break;
 314         default:
 315                 printf("gre-proto-0x%x", prot);
 316                 break;
 317         }
 318         return;
 319
 320 trunc:
 321         printf("[|gre]");
 322 }
 323
 324 void
 325 gre_sre_print(u_int16_t af, u_int8_t sreoff, u_int8_t srelen,
 326     const u_char *bp, u_int len)
 327 {
 328         switch (af) {
 329         case GRESRE_IP:
 330                 printf(", (rtaf=ip");
 331                 gre_sre_ip_print(sreoff, srelen, bp, len);
 332                 printf(") ");
 333                 break;
 334         case GRESRE_ASN:
 335                 printf(", (rtaf=asn");
 336                 gre_sre_asn_print(sreoff, srelen, bp, len);
 337                 printf(") ");
 338                 break;
 339         default:
 340                 printf(", (rtaf=0x%x) ", af);
 341         }
 342 }
 343 void
 344 gre_sre_ip_print(u_int8_t sreoff, u_int8_t srelen, const u_char *bp, u_int len)
 345 {
 346         struct in_addr a;
 347         const u_char *up = bp;
 348
 349         if (sreoff & 3) {
 350                 printf(", badoffset=%u", sreoff);
 351                 return;
 352         }
 353         if (srelen & 3) {
 354                 printf(", badlength=%u", srelen);
 355                 return;
 356         }
 357         if (sreoff >= srelen) {
 358                 printf(", badoff/len=%u/%u", sreoff, srelen);
 359                 return;
 360         }
 361
 362         for (;;) {
 363                 if (len < 4 || srelen == 0)
 364                         return;
 365
 366                 memcpy(&a, bp, sizeof(a));
 367                 printf(" %s%s",
 368                     ((bp - up) == sreoff) ? "*" : "",
 369                     inet_ntoa(a));
 370
 371                 bp += 4;
 372                 len -= 4;
 373                 srelen -= 4;
 374         }
 375 }
 376
 377 void
 378 gre_sre_asn_print(u_int8_t sreoff, u_int8_t srelen, const u_char *bp, u_int len)
 379 {
 380         const u_char *up = bp;
 381
 382         if (sreoff & 1) {
 383                 printf(", badoffset=%u", sreoff);
 384                 return;
 385         }
 386         if (srelen & 1) {
 387                 printf(", badlength=%u", srelen);
 388                 return;
 389         }
 390         if (sreoff >= srelen) {
 391                 printf(", badoff/len=%u/%u", sreoff, srelen);
 392                 return;
 393         }
 394
 395         for (;;) {
 396                 if (len < 2 || srelen == 0)
 397                         return;
 398
 399                 printf(" %s%x",
 400                     ((bp - up) == sreoff) ? "*" : "",
 401                     EXTRACT_16BITS(bp));
 402
 403                 bp += 2;
 404                 len -= 2;
 405                 srelen -= 2;
 406         }
 407 }