contrib/tcpdump-3.9/print-juniper.c

   1 /*
   2  * Redistribution and use in source and binary forms, with or without
   3  * modification, are permitted provided that: (1) source code
   4  * distributions retain the above copyright notice and this paragraph
   5  * in its entirety, and (2) distributions including binary code include
   6  * the above copyright notice and this paragraph in its entirety in
   7  * the documentation or other materials provided with the distribution.
   8  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
   9  * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
  10  * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  11  * FOR A PARTICULAR PURPOSE.
  12  *
  13  * Original code by Hannes Gredler (hannes@juniper.net)
  14  */
  15
  16 #ifndef lint
  17 static const char rcsid[] _U_ =
  18     "@(#) $Header: /tcpdump/master/tcpdump/print-juniper.c,v 1.8.2.22 2006/05/10 22:42:46 guy Exp $ (LBL)";
  19 #endif
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <tcpdump-stdinc.h>
  26
  27 #include <pcap.h>
  28 #include <stdio.h>
  29
  30 #include "interface.h"
  31 #include "addrtoname.h"
  32 #include "extract.h"
  33 #include "ppp.h"
  34 #include "llc.h"
  35 #include "nlpid.h"
  36 #include "ethertype.h"
  37 #include "atm.h"
  38
  39 #define JUNIPER_BPF_OUT           0       /* Outgoing packet */
  40 #define JUNIPER_BPF_IN            1       /* Incoming packet */
  41 #define JUNIPER_BPF_PKT_IN        0x1     /* Incoming packet */
  42 #define JUNIPER_BPF_NO_L2         0x2     /* L2 header stripped */
  43 #define JUNIPER_BPF_EXT           0x80    /* extensions present */
  44 #define JUNIPER_MGC_NUMBER        0x4d4743 /* = "MGC" */
  45
  46 #define JUNIPER_LSQ_COOKIE_RE         (1 << 3)
  47 #define JUNIPER_LSQ_COOKIE_DIR        (1 << 2)
  48 #define JUNIPER_LSQ_L3_PROTO_SHIFT     4
  49 #define JUNIPER_LSQ_L3_PROTO_MASK     (0x17 << JUNIPER_LSQ_L3_PROTO_SHIFT)
  50 #define JUNIPER_LSQ_L3_PROTO_IPV4     (0 << JUNIPER_LSQ_L3_PROTO_SHIFT)
  51 #define JUNIPER_LSQ_L3_PROTO_IPV6     (1 << JUNIPER_LSQ_L3_PROTO_SHIFT)
  52 #define JUNIPER_LSQ_L3_PROTO_MPLS     (2 << JUNIPER_LSQ_L3_PROTO_SHIFT)
  53 #define JUNIPER_LSQ_L3_PROTO_ISO      (3 << JUNIPER_LSQ_L3_PROTO_SHIFT)
  54 #define AS_PIC_COOKIE_LEN 8
  55
  56 #define JUNIPER_IPSEC_O_ESP_ENCRYPT_ESP_AUTHEN_TYPE 1
  57 #define JUNIPER_IPSEC_O_ESP_ENCRYPT_AH_AUTHEN_TYPE 2
  58 #define JUNIPER_IPSEC_O_ESP_AUTHENTICATION_TYPE 3
  59 #define JUNIPER_IPSEC_O_AH_AUTHENTICATION_TYPE 4
  60 #define JUNIPER_IPSEC_O_ESP_ENCRYPTION_TYPE 5
  61
  62 static struct tok juniper_ipsec_type_values[] = {
  63     { JUNIPER_IPSEC_O_ESP_ENCRYPT_ESP_AUTHEN_TYPE, "ESP ENCR-AUTH" },
  64     { JUNIPER_IPSEC_O_ESP_ENCRYPT_AH_AUTHEN_TYPE, "ESP ENCR-AH AUTH" },
  65     { JUNIPER_IPSEC_O_ESP_AUTHENTICATION_TYPE, "ESP AUTH" },
  66     { JUNIPER_IPSEC_O_AH_AUTHENTICATION_TYPE, "AH AUTH" },
  67     { JUNIPER_IPSEC_O_ESP_ENCRYPTION_TYPE, "ESP ENCR" },
  68     { 0, NULL}
  69 };
  70
  71 static struct tok juniper_direction_values[] = {
  72     { JUNIPER_BPF_IN,  "In"},
  73     { JUNIPER_BPF_OUT, "Out"},
  74     { 0, NULL}
  75 };
  76
  77 struct juniper_cookie_table_t {
  78     u_int32_t pictype;          /* pic type */
  79     u_int8_t  cookie_len;       /* cookie len */
  80     const char *s;              /* pic name */
  81 };
  82
  83 static struct juniper_cookie_table_t juniper_cookie_table[] = {
  84 #ifdef DLT_JUNIPER_ATM1
  85     { DLT_JUNIPER_ATM1,  4, "ATM1"},
  86 #endif
  87 #ifdef DLT_JUNIPER_ATM2
  88     { DLT_JUNIPER_ATM2,  8, "ATM2"},
  89 #endif
  90 #ifdef DLT_JUNIPER_MLPPP
  91     { DLT_JUNIPER_MLPPP, 2, "MLPPP"},
  92 #endif
  93 #ifdef DLT_JUNIPER_MLFR
  94     { DLT_JUNIPER_MLFR,  2, "MLFR"},
  95 #endif
  96 #ifdef DLT_JUNIPER_MFR
  97     { DLT_JUNIPER_MFR,   4, "MFR"},
  98 #endif
  99 #ifdef DLT_JUNIPER_PPPOE
 100     { DLT_JUNIPER_PPPOE, 0, "PPPoE"},
 101 #endif
 102 #ifdef DLT_JUNIPER_PPPOE_ATM
 103     { DLT_JUNIPER_PPPOE_ATM, 0, "PPPoE ATM"},
 104 #endif
 105 #ifdef DLT_JUNIPER_GGSN
 106     { DLT_JUNIPER_GGSN, 8, "GGSN"},
 107 #endif
 108 #ifdef DLT_JUNIPER_MONITOR
 109     { DLT_JUNIPER_MONITOR, 8, "MONITOR"},
 110 #endif
 111 #ifdef DLT_JUNIPER_SERVICES
 112     { DLT_JUNIPER_SERVICES, 8, "AS"},
 113 #endif
 114 #ifdef DLT_JUNIPER_ES
 115     { DLT_JUNIPER_ES, 0, "ES"},
 116 #endif
 117     { 0, 0, NULL }
 118 };
 119
 120 struct juniper_l2info_t {
 121     u_int32_t length;
 122     u_int32_t caplen;
 123     u_int32_t pictype;
 124     u_int8_t direction;
 125     u_int8_t header_len;
 126     u_int8_t cookie_len;
 127     u_int8_t cookie_type;
 128     u_int8_t cookie[8];
 129     u_int8_t bundle;
 130     u_int16_t proto;
 131 };
 132
 133 #define LS_COOKIE_ID            0x54
 134 #define AS_COOKIE_ID            0x47
 135 #define LS_MLFR_COOKIE_LEN      4
 136 #define ML_MLFR_COOKIE_LEN      2
 137 #define LS_MFR_COOKIE_LEN       6
 138 #define ATM1_COOKIE_LEN         4
 139 #define ATM2_COOKIE_LEN         8
 140
 141 #define ATM2_PKT_TYPE_MASK  0x70
 142 #define ATM2_GAP_COUNT_MASK 0x3F
 143
 144 #define JUNIPER_PROTO_NULL          1
 145 #define JUNIPER_PROTO_IPV4          2
 146 #define JUNIPER_PROTO_IPV6          6
 147
 148 #define MFR_BE_MASK 0xc0
 149
 150 static struct tok juniper_protocol_values[] = {
 151     { JUNIPER_PROTO_NULL, "Null" },
 152     { JUNIPER_PROTO_IPV4, "IPv4" },
 153     { JUNIPER_PROTO_IPV6, "IPv6" },
 154     { 0, NULL}
 155 };
 156
 157 int ip_heuristic_guess(register const u_char *, u_int);
 158 int juniper_ppp_heuristic_guess(register const u_char *, u_int);
 159 static int juniper_parse_header (const u_char *, const struct pcap_pkthdr *, struct juniper_l2info_t *);
 160
 161 #ifdef DLT_JUNIPER_GGSN
 162 u_int
 163 juniper_ggsn_print(const struct pcap_pkthdr *h, register const u_char *p)
 164 {
 165         struct juniper_l2info_t l2info;
 166         struct juniper_ggsn_header {
 167             u_int8_t svc_id;
 168             u_int8_t flags_len;
 169             u_int8_t proto;
 170             u_int8_t flags;
 171             u_int8_t vlan_id[2];
 172             u_int8_t res[2];
 173         };
 174         const struct juniper_ggsn_header *gh;
 175
 176         l2info.pictype = DLT_JUNIPER_GGSN;
 177         if(juniper_parse_header(p, h, &l2info) == 0)
 178             return l2info.header_len;
 179
 180         p+=l2info.header_len;
 181         gh = (struct juniper_ggsn_header *)p;
 182
 183         if (eflag)
 184             printf("proto %s (%u), vlan %u: ",
 185                    tok2str(juniper_protocol_values,"Unknown",gh->proto),
 186                    gh->proto,
 187                    EXTRACT_16BITS(&gh->vlan_id[0]));
 188
 189         switch (gh->proto) {
 190         case JUNIPER_PROTO_IPV4:
 191             ip_print(gndo, p, l2info.length);
 192             break;
 193 #ifdef INET6
 194         case JUNIPER_PROTO_IPV6:
 195             ip6_print(p, l2info.length);
 196             break;
 197 #endif /* INET6 */
 198         default:
 199             if (!eflag)
 200                 printf("unknown GGSN proto (%u)", gh->proto);
 201         }
 202
 203         return l2info.header_len;
 204 }
 205 #endif
 206
 207 #ifdef DLT_JUNIPER_ES
 208 u_int
 209 juniper_es_print(const struct pcap_pkthdr *h, register const u_char *p)
 210 {
 211         struct juniper_l2info_t l2info;
 212         struct juniper_ipsec_header {
 213             u_int8_t sa_index[2];
 214             u_int8_t ttl;
 215             u_int8_t type;
 216             u_int8_t spi[4];
 217             u_int8_t src_ip[4];
 218             u_int8_t dst_ip[4];
 219         };
 220         u_int rewrite_len,es_type_bundle;
 221         const struct juniper_ipsec_header *ih;
 222
 223         l2info.pictype = DLT_JUNIPER_ES;
 224         if(juniper_parse_header(p, h, &l2info) == 0)
 225             return l2info.header_len;
 226
 227         p+=l2info.header_len;
 228         ih = (struct juniper_ipsec_header *)p;
 229
 230         switch (ih->type) {
 231         case JUNIPER_IPSEC_O_ESP_ENCRYPT_ESP_AUTHEN_TYPE:
 232         case JUNIPER_IPSEC_O_ESP_ENCRYPT_AH_AUTHEN_TYPE:
 233             rewrite_len = 0;
 234             es_type_bundle = 1;
 235             break;
 236         case JUNIPER_IPSEC_O_ESP_AUTHENTICATION_TYPE:
 237         case JUNIPER_IPSEC_O_AH_AUTHENTICATION_TYPE:
 238         case JUNIPER_IPSEC_O_ESP_ENCRYPTION_TYPE:
 239             rewrite_len = 16;
 240             es_type_bundle = 0;
 241         default:
 242             printf("ES Invalid type %u, length %u",
 243                    ih->type,
 244                    l2info.length);
 245             return l2info.header_len;
 246         }
 247
 248         l2info.length-=rewrite_len;
 249         p+=rewrite_len;
 250
 251         if (eflag) {
 252             if (!es_type_bundle) {
 253                 printf("ES SA, index %u, ttl %u type %s (%u), spi %u, Tunnel %s > %s, length %u\n",
 254                        EXTRACT_16BITS(&ih->sa_index),
 255                        ih->ttl,
 256                        tok2str(juniper_ipsec_type_values,"Unknown",ih->type),
 257                        ih->type,
 258                        EXTRACT_32BITS(&ih->spi),
 259                        ipaddr_string(EXTRACT_32BITS(&ih->src_ip)),
 260                        ipaddr_string(EXTRACT_32BITS(&ih->dst_ip)),
 261                        l2info.length);
 262             } else {
 263                 printf("ES SA, index %u, ttl %u type %s (%u), length %u\n",
 264                        EXTRACT_16BITS(&ih->sa_index),
 265                        ih->ttl,
 266                        tok2str(juniper_ipsec_type_values,"Unknown",ih->type),
 267                        ih->type,
 268                        l2info.length);
 269             }
 270         }
 271
 272         ip_print(gndo, p, l2info.length);
 273         return l2info.header_len;
 274 }
 275 #endif
 276
 277 #ifdef DLT_JUNIPER_MONITOR
 278 u_int
 279 juniper_monitor_print(const struct pcap_pkthdr *h, register const u_char *p)
 280 {
 281         struct juniper_l2info_t l2info;
 282         struct juniper_monitor_header {
 283             u_int8_t pkt_type;
 284             u_int8_t padding;
 285             u_int8_t iif[2];
 286             u_int8_t service_id[4];
 287         };
 288         const struct juniper_monitor_header *mh;
 289
 290         l2info.pictype = DLT_JUNIPER_MONITOR;
 291         if(juniper_parse_header(p, h, &l2info) == 0)
 292             return l2info.header_len;
 293
 294         p+=l2info.header_len;
 295         mh = (struct juniper_monitor_header *)p;
 296
 297         if (eflag)
 298             printf("service-id %u, iif %u, pkt-type %u: ",
 299                    EXTRACT_32BITS(&mh->service_id),
 300                    EXTRACT_16BITS(&mh->iif),
 301                    mh->pkt_type);
 302
 303         /* no proto field - lets guess by first byte of IP header*/
 304         ip_heuristic_guess(p, l2info.length);
 305
 306         return l2info.header_len;
 307 }
 308 #endif
 309
 310 #ifdef DLT_JUNIPER_SERVICES
 311 u_int
 312 juniper_services_print(const struct pcap_pkthdr *h, register const u_char *p)
 313 {
 314         struct juniper_l2info_t l2info;
 315         struct juniper_services_header {
 316             u_int8_t svc_id;
 317             u_int8_t flags_len;
 318             u_int8_t svc_set_id[2];
 319             u_int8_t dir_iif[4];
 320         };
 321         const struct juniper_services_header *sh;
 322
 323         l2info.pictype = DLT_JUNIPER_SERVICES;
 324         if(juniper_parse_header(p, h, &l2info) == 0)
 325             return l2info.header_len;
 326
 327         p+=l2info.header_len;
 328         sh = (struct juniper_services_header *)p;
 329
 330         if (eflag)
 331             printf("service-id %u flags 0x%02x service-set-id 0x%04x iif %u: ",
 332                    sh->svc_id,
 333                    sh->flags_len,
 334                    EXTRACT_16BITS(&sh->svc_set_id),
 335                    EXTRACT_24BITS(&sh->dir_iif[1]));
 336
 337         /* no proto field - lets guess by first byte of IP header*/
 338         ip_heuristic_guess(p, l2info.length);
 339
 340         return l2info.header_len;
 341 }
 342 #endif
 343
 344 #ifdef DLT_JUNIPER_PPPOE
 345 u_int
 346 juniper_pppoe_print(const struct pcap_pkthdr *h, register const u_char *p)
 347 {
 348         struct juniper_l2info_t l2info;
 349
 350         l2info.pictype = DLT_JUNIPER_PPPOE;
 351         if(juniper_parse_header(p, h, &l2info) == 0)
 352             return l2info.header_len;
 353
 354         p+=l2info.header_len;
 355         /* this DLT contains nothing but raw ethernet frames */
 356         ether_print(p, l2info.length, l2info.caplen);
 357         return l2info.header_len;
 358 }
 359 #endif
 360
 361 #ifdef DLT_JUNIPER_ETHER
 362 u_int
 363 juniper_ether_print(const struct pcap_pkthdr *h, register const u_char *p)
 364 {
 365         struct juniper_l2info_t l2info;
 366
 367         l2info.pictype = DLT_JUNIPER_ETHER;
 368         if(juniper_parse_header(p, h, &l2info) == 0)
 369             return l2info.header_len;
 370
 371         p+=l2info.header_len;
 372         /* this DLT contains nothing but raw Ethernet frames */
 373         ether_print(p, l2info.length, l2info.caplen);
 374         return l2info.header_len;
 375 }
 376 #endif
 377
 378 #ifdef DLT_JUNIPER_PPP
 379 u_int
 380 juniper_ppp_print(const struct pcap_pkthdr *h, register const u_char *p)
 381 {
 382         struct juniper_l2info_t l2info;
 383
 384         l2info.pictype = DLT_JUNIPER_PPP;
 385         if(juniper_parse_header(p, h, &l2info) == 0)
 386             return l2info.header_len;
 387
 388         p+=l2info.header_len;
 389         /* this DLT contains nothing but raw ppp frames */
 390         ppp_print(p, l2info.length);
 391         return l2info.header_len;
 392 }
 393 #endif
 394
 395 #ifdef DLT_JUNIPER_FRELAY
 396 u_int
 397 juniper_frelay_print(const struct pcap_pkthdr *h, register const u_char *p)
 398 {
 399         struct juniper_l2info_t l2info;
 400
 401         l2info.pictype = DLT_JUNIPER_FRELAY;
 402         if(juniper_parse_header(p, h, &l2info) == 0)
 403             return l2info.header_len;
 404
 405         p+=l2info.header_len;
 406         /* this DLT contains nothing but raw frame-relay frames */
 407         fr_print(p, l2info.length);
 408         return l2info.header_len;
 409 }
 410 #endif
 411
 412 #ifdef DLT_JUNIPER_CHDLC
 413 u_int
 414 juniper_chdlc_print(const struct pcap_pkthdr *h, register const u_char *p)
 415 {
 416         struct juniper_l2info_t l2info;
 417
 418         l2info.pictype = DLT_JUNIPER_CHDLC;
 419         if(juniper_parse_header(p, h, &l2info) == 0)
 420             return l2info.header_len;
 421
 422         p+=l2info.header_len;
 423         /* this DLT contains nothing but raw c-hdlc frames */
 424         chdlc_print(p, l2info.length);
 425         return l2info.header_len;
 426 }
 427 #endif
 428
 429 #ifdef DLT_JUNIPER_PPPOE_ATM
 430 u_int
 431 juniper_pppoe_atm_print(const struct pcap_pkthdr *h, register const u_char *p)
 432 {
 433         struct juniper_l2info_t l2info;
 434         u_int16_t extracted_ethertype;
 435
 436         l2info.pictype = DLT_JUNIPER_PPPOE_ATM;
 437         if(juniper_parse_header(p, h, &l2info) == 0)
 438             return l2info.header_len;
 439
 440         p+=l2info.header_len;
 441
 442         extracted_ethertype = EXTRACT_16BITS(p);
 443         /* this DLT contains nothing but raw PPPoE frames,
 444          * prepended with a type field*/
 445         if (ether_encap_print(extracted_ethertype,
 446                               p+ETHERTYPE_LEN,
 447                               l2info.length-ETHERTYPE_LEN,
 448                               l2info.caplen-ETHERTYPE_LEN,
 449                               &extracted_ethertype) == 0)
 450             /* ether_type not known, probably it wasn't one */
 451             printf("unknown ethertype 0x%04x", extracted_ethertype);
 452
 453         return l2info.header_len;
 454 }
 455 #endif
 456
 457 #ifdef DLT_JUNIPER_MLPPP
 458 u_int
 459 juniper_mlppp_print(const struct pcap_pkthdr *h, register const u_char *p)
 460 {
 461         struct juniper_l2info_t l2info;
 462
 463         l2info.pictype = DLT_JUNIPER_MLPPP;
 464         if(juniper_parse_header(p, h, &l2info) == 0)
 465             return l2info.header_len;
 466
 467         /* suppress Bundle-ID if frame was captured on a child-link
 468          * best indicator if the cookie looks like a proto */
 469         if (eflag &&
 470             EXTRACT_16BITS(&l2info.cookie) != PPP_OSI &&
 471             EXTRACT_16BITS(&l2info.cookie) !=  (PPP_ADDRESS << 8 | PPP_CONTROL))
 472             printf("Bundle-ID %u: ",l2info.bundle);
 473
 474         p+=l2info.header_len;
 475
 476         /* first try the LSQ protos */
 477         switch(l2info.proto) {
 478         case JUNIPER_LSQ_L3_PROTO_IPV4:
 479             /* IP traffic going to the RE would not have a cookie
 480              * -> this must be incoming IS-IS over PPP
 481              */
 482             if (l2info.cookie[4] == (JUNIPER_LSQ_COOKIE_RE|JUNIPER_LSQ_COOKIE_DIR))
 483                 ppp_print(p, l2info.length);
 484             else
 485                 ip_print(gndo, p, l2info.length);
 486             return l2info.header_len;
 487 #ifdef INET6
 488         case JUNIPER_LSQ_L3_PROTO_IPV6:
 489             ip6_print(p,l2info.length);
 490             return l2info.header_len;
 491 #endif
 492         case JUNIPER_LSQ_L3_PROTO_MPLS:
 493             mpls_print(p,l2info.length);
 494             return l2info.header_len;
 495         case JUNIPER_LSQ_L3_PROTO_ISO:
 496             isoclns_print(p,l2info.length,l2info.caplen);
 497             return l2info.header_len;
 498         default:
 499             break;
 500         }
 501
 502         /* zero length cookie ? */
 503         switch (EXTRACT_16BITS(&l2info.cookie)) {
 504         case PPP_OSI:
 505             ppp_print(p-2,l2info.length+2);
 506             break;
 507         case (PPP_ADDRESS << 8 | PPP_CONTROL): /* fall through */
 508         default:
 509             ppp_print(p,l2info.length);
 510             break;
 511         }
 512
 513         return l2info.header_len;
 514 }
 515 #endif
 516
 517
 518 #ifdef DLT_JUNIPER_MFR
 519 u_int
 520 juniper_mfr_print(const struct pcap_pkthdr *h, register const u_char *p)
 521 {
 522         struct juniper_l2info_t l2info;
 523
 524         l2info.pictype = DLT_JUNIPER_MFR;
 525         if(juniper_parse_header(p, h, &l2info) == 0)
 526             return l2info.header_len;
 527
 528         p+=l2info.header_len;
 529
 530         /* child-link ? */
 531         if (l2info.cookie_len == 0) {
 532             mfr_print(p,l2info.length);
 533             return l2info.header_len;
 534         }
 535
 536         /* first try the LSQ protos */
 537         if (l2info.cookie_len == AS_PIC_COOKIE_LEN) {
 538             switch(l2info.proto) {
 539             case JUNIPER_LSQ_L3_PROTO_IPV4:
 540                 ip_print(gndo, p, l2info.length);
 541                 return l2info.header_len;
 542 #ifdef INET6
 543             case JUNIPER_LSQ_L3_PROTO_IPV6:
 544                 ip6_print(p,l2info.length);
 545                 return l2info.header_len;
 546 #endif
 547             case JUNIPER_LSQ_L3_PROTO_MPLS:
 548                 mpls_print(p,l2info.length);
 549                 return l2info.header_len;
 550             case JUNIPER_LSQ_L3_PROTO_ISO:
 551                 isoclns_print(p,l2info.length,l2info.caplen);
 552                 return l2info.header_len;
 553             default:
 554                 break;
 555             }
 556             return l2info.header_len;
 557         }
 558
 559         /* suppress Bundle-ID if frame was captured on a child-link */
 560         if (eflag && EXTRACT_32BITS(l2info.cookie) != 1) printf("Bundle-ID %u, ",l2info.bundle);
 561         switch (l2info.proto) {
 562         case (LLCSAP_ISONS<<8 | LLCSAP_ISONS):
 563             isoclns_print(p+1, l2info.length-1, l2info.caplen-1);
 564             break;
 565         case (LLC_UI<<8 | NLPID_Q933):
 566         case (LLC_UI<<8 | NLPID_IP):
 567         case (LLC_UI<<8 | NLPID_IP6):
 568             /* pass IP{4,6} to the OSI layer for proper link-layer printing */
 569             isoclns_print(p-1, l2info.length+1, l2info.caplen+1);
 570             break;
 571         default:
 572             printf("unknown protocol 0x%04x, length %u",l2info.proto, l2info.length);
 573         }
 574
 575         return l2info.header_len;
 576 }
 577 #endif
 578
 579 #ifdef DLT_JUNIPER_MLFR
 580 u_int
 581 juniper_mlfr_print(const struct pcap_pkthdr *h, register const u_char *p)
 582 {
 583         struct juniper_l2info_t l2info;
 584
 585         l2info.pictype = DLT_JUNIPER_MLFR;
 586         if(juniper_parse_header(p, h, &l2info) == 0)
 587             return l2info.header_len;
 588
 589         p+=l2info.header_len;
 590
 591         /* suppress Bundle-ID if frame was captured on a child-link */
 592         if (eflag && EXTRACT_32BITS(l2info.cookie) != 1) printf("Bundle-ID %u, ",l2info.bundle);
 593         switch (l2info.proto) {
 594         case (LLC_UI):
 595         case (LLC_UI<<8):
 596             isoclns_print(p, l2info.length, l2info.caplen);
 597             break;
 598         case (LLC_UI<<8 | NLPID_Q933):
 599         case (LLC_UI<<8 | NLPID_IP):
 600         case (LLC_UI<<8 | NLPID_IP6):
 601             /* pass IP{4,6} to the OSI layer for proper link-layer printing */
 602             isoclns_print(p-1, l2info.length+1, l2info.caplen+1);
 603             break;
 604         default:
 605             printf("unknown protocol 0x%04x, length %u",l2info.proto, l2info.length);
 606         }
 607
 608         return l2info.header_len;
 609 }
 610 #endif
 611
 612 /*
 613  *     ATM1 PIC cookie format
 614  *
 615  *     +-----+-------------------------+-------------------------------+
 616  *     |fmtid|     vc index            |  channel  ID                  |
 617  *     +-----+-------------------------+-------------------------------+
 618  */
 619
 620 #ifdef DLT_JUNIPER_ATM1
 621 u_int
 622 juniper_atm1_print(const struct pcap_pkthdr *h, register const u_char *p)
 623 {
 624         u_int16_t extracted_ethertype;
 625
 626         struct juniper_l2info_t l2info;
 627
 628         l2info.pictype = DLT_JUNIPER_ATM1;
 629         if(juniper_parse_header(p, h, &l2info) == 0)
 630             return l2info.header_len;
 631
 632         p+=l2info.header_len;
 633
 634         if (l2info.cookie[0] == 0x80) { /* OAM cell ? */
 635             oam_print(p,l2info.length,ATM_OAM_NOHEC);
 636             return l2info.header_len;
 637         }
 638
 639         if (EXTRACT_24BITS(p) == 0xfefe03 || /* NLPID encaps ? */
 640             EXTRACT_24BITS(p) == 0xaaaa03) { /* SNAP encaps ? */
 641
 642             if (llc_print(p, l2info.length, l2info.caplen, NULL, NULL,
 643                           &extracted_ethertype) != 0)
 644                 return l2info.header_len;
 645         }
 646
 647         if (p[0] == 0x03) { /* Cisco style NLPID encaps ? */
 648             isoclns_print(p + 1, l2info.length - 1, l2info.caplen - 1);
 649             /* FIXME check if frame was recognized */
 650             return l2info.header_len;
 651         }
 652
 653         if(ip_heuristic_guess(p, l2info.length) != 0) /* last try - vcmux encaps ? */
 654             return l2info.header_len;
 655
 656         return l2info.header_len;
 657 }
 658 #endif
 659
 660 /*
 661  *     ATM2 PIC cookie format
 662  *
 663  *     +-------------------------------+---------+---+-----+-----------+
 664  *     |     channel ID                |  reserv |AAL| CCRQ| gap cnt   |
 665  *     +-------------------------------+---------+---+-----+-----------+
 666  */
 667
 668 #ifdef DLT_JUNIPER_ATM2
 669 u_int
 670 juniper_atm2_print(const struct pcap_pkthdr *h, register const u_char *p)
 671 {
 672         u_int16_t extracted_ethertype;
 673
 674         struct juniper_l2info_t l2info;
 675
 676         l2info.pictype = DLT_JUNIPER_ATM2;
 677         if(juniper_parse_header(p, h, &l2info) == 0)
 678             return l2info.header_len;
 679
 680         p+=l2info.header_len;
 681
 682         if (l2info.cookie[7] & ATM2_PKT_TYPE_MASK) { /* OAM cell ? */
 683             oam_print(p,l2info.length,ATM_OAM_NOHEC);
 684             return l2info.header_len;
 685         }
 686
 687         if (EXTRACT_24BITS(p) == 0xfefe03 || /* NLPID encaps ? */
 688             EXTRACT_24BITS(p) == 0xaaaa03) { /* SNAP encaps ? */
 689
 690             if (llc_print(p, l2info.length, l2info.caplen, NULL, NULL,
 691                           &extracted_ethertype) != 0)
 692                 return l2info.header_len;
 693         }
 694
 695         if (l2info.direction != JUNIPER_BPF_PKT_IN && /* ether-over-1483 encaps ? */
 696             (EXTRACT_32BITS(l2info.cookie) & ATM2_GAP_COUNT_MASK)) {
 697             ether_print(p, l2info.length, l2info.caplen);
 698             return l2info.header_len;
 699         }
 700
 701         if (p[0] == 0x03) { /* Cisco style NLPID encaps ? */
 702             isoclns_print(p + 1, l2info.length - 1, l2info.caplen - 1);
 703             /* FIXME check if frame was recognized */
 704             return l2info.header_len;
 705         }
 706
 707         if(juniper_ppp_heuristic_guess(p, l2info.length) != 0) /* PPPoA vcmux encaps ? */
 708             return l2info.header_len;
 709
 710         if(ip_heuristic_guess(p, l2info.length) != 0) /* last try - vcmux encaps ? */
 711             return l2info.header_len;
 712
 713         return l2info.header_len;
 714 }
 715 #endif
 716
 717
 718 /* try to guess, based on all PPP protos that are supported in
 719  * a juniper router if the payload data is encapsulated using PPP */
 720 int
 721 juniper_ppp_heuristic_guess(register const u_char *p, u_int length) {
 722
 723     switch(EXTRACT_16BITS(p)) {
 724     case PPP_IP :
 725     case PPP_OSI :
 726     case PPP_MPLS_UCAST :
 727     case PPP_MPLS_MCAST :
 728     case PPP_IPCP :
 729     case PPP_OSICP :
 730     case PPP_MPLSCP :
 731     case PPP_LCP :
 732     case PPP_PAP :
 733     case PPP_CHAP :
 734     case PPP_ML :
 735 #ifdef INET6
 736     case PPP_IPV6 :
 737     case PPP_IPV6CP :
 738 #endif
 739         ppp_print(p, length);
 740         break;
 741
 742     default:
 743         return 0; /* did not find a ppp header */
 744         break;
 745     }
 746     return 1; /* we printed a ppp packet */
 747 }
 748
 749 int
 750 ip_heuristic_guess(register const u_char *p, u_int length) {
 751
 752     switch(p[0]) {
 753     case 0x45:
 754     case 0x46:
 755     case 0x47:
 756     case 0x48:
 757     case 0x49:
 758     case 0x4a:
 759     case 0x4b:
 760     case 0x4c:
 761     case 0x4d:
 762     case 0x4e:
 763     case 0x4f:
 764             ip_print(gndo, p, length);
 765             break;
 766 #ifdef INET6
 767     case 0x60:
 768     case 0x61:
 769     case 0x62:
 770     case 0x63:
 771     case 0x64:
 772     case 0x65:
 773     case 0x66:
 774     case 0x67:
 775     case 0x68:
 776     case 0x69:
 777     case 0x6a:
 778     case 0x6b:
 779     case 0x6c:
 780     case 0x6d:
 781     case 0x6e:
 782     case 0x6f:
 783         ip6_print(p, length);
 784         break;
 785 #endif
 786     default:
 787         return 0; /* did not find a ip header */
 788         break;
 789     }
 790     return 1; /* we printed an v4/v6 packet */
 791 }
 792
 793 static int
 794 juniper_parse_header (const u_char *p, const struct pcap_pkthdr *h, struct juniper_l2info_t *l2info) {
 795
 796     struct juniper_cookie_table_t *lp = juniper_cookie_table;
 797     u_int idx, offset;
 798 #ifdef DLT_JUNIPER_ATM2
 799     u_int32_t control_word;
 800 #endif
 801
 802     l2info->header_len = 0;
 803     l2info->cookie_len = 0;
 804     l2info->proto = 0;
 805
 806
 807     l2info->length = h->len;
 808     l2info->caplen = h->caplen;
 809     l2info->direction = p[3]&JUNIPER_BPF_PKT_IN;
 810
 811     TCHECK2(p[0],4);
 812     if (EXTRACT_24BITS(p) != JUNIPER_MGC_NUMBER) { /* magic number found ? */
 813         printf("no magic-number found!");
 814         return 0;
 815     }
 816
 817     if (eflag) /* print direction */
 818         printf("%3s ",tok2str(juniper_direction_values,"---",l2info->direction));
 819
 820     /* extensions present ?  - calculate how much bytes to skip */
 821     if ((p[3] & JUNIPER_BPF_EXT ) == JUNIPER_BPF_EXT ) {
 822         offset = 6 + EXTRACT_16BITS(p+4);
 823         if (eflag>1)
 824             printf("ext-len %u, ",EXTRACT_16BITS(p+4));
 825     } else
 826         offset = 4;
 827
 828     if ((p[3] & JUNIPER_BPF_NO_L2 ) == JUNIPER_BPF_NO_L2 ) {
 829         if (eflag)
 830             printf("no-L2-hdr, ");
 831
 832         /* there is no link-layer present -
 833          * perform the v4/v6 heuristics
 834          * to figure out what it is
 835          */
 836         TCHECK2(p[offset+4],1);
 837         if(ip_heuristic_guess(p+offset+4,l2info->length-(offset+4)) == 0)
 838             printf("no IP-hdr found!");
 839
 840         l2info->header_len=offset+4;
 841         return 0; /* stop parsing the output further */
 842
 843     }
 844     l2info->header_len = offset;
 845     p+=l2info->header_len;
 846     l2info->length -= l2info->header_len;
 847     l2info->caplen -= l2info->header_len;
 848
 849     /* search through the cookie table and copy values matching for our PIC type */
 850     while (lp->s != NULL) {
 851         if (lp->pictype == l2info->pictype) {
 852
 853             l2info->cookie_len += lp->cookie_len;
 854
 855             switch (p[0]) {
 856             case LS_COOKIE_ID:
 857                 l2info->cookie_type = LS_COOKIE_ID;
 858                 l2info->cookie_len += 2;
 859                 break;
 860             case AS_COOKIE_ID:
 861                 l2info->cookie_type = AS_COOKIE_ID;
 862                 l2info->cookie_len = 8;
 863                 break;
 864
 865             default:
 866                 l2info->bundle = l2info->cookie[0];
 867                 break;
 868             }
 869
 870
 871 #ifdef DLT_JUNIPER_MFR
 872             /* MFR child links don't carry cookies */
 873             if (l2info->pictype == DLT_JUNIPER_MFR &&
 874                 (p[0] & MFR_BE_MASK) == MFR_BE_MASK) {
 875                 l2info->cookie_len = 0;
 876             }
 877 #endif
 878
 879             l2info->header_len += l2info->cookie_len;
 880             l2info->length -= l2info->cookie_len;
 881             l2info->caplen -= l2info->cookie_len;
 882
 883             if (eflag)
 884                 printf("%s-PIC, cookie-len %u",
 885                        lp->s,
 886                        l2info->cookie_len);
 887
 888             if (l2info->cookie_len > 0) {
 889                 TCHECK2(p[0],l2info->cookie_len);
 890                 if (eflag)
 891                     printf(", cookie 0x");
 892                 for (idx = 0; idx < l2info->cookie_len; idx++) {
 893                     l2info->cookie[idx] = p[idx]; /* copy cookie data */
 894                     if (eflag) printf("%02x",p[idx]);
 895                 }
 896             }
 897
 898             if (eflag) printf(": "); /* print demarc b/w L2/L3*/
 899
 900
 901             l2info->proto = EXTRACT_16BITS(p+l2info->cookie_len);
 902             break;
 903         }
 904         ++lp;
 905     }
 906     p+=l2info->cookie_len;
 907
 908     /* DLT_ specific parsing */
 909     switch(l2info->pictype) {
 910 #ifdef DLT_JUNIPER_MLPPP
 911     case DLT_JUNIPER_MLPPP:
 912         switch (l2info->cookie_type) {
 913         case LS_COOKIE_ID:
 914             l2info->bundle = l2info->cookie[1];
 915             break;
 916         case AS_COOKIE_ID:
 917             l2info->bundle = (EXTRACT_16BITS(&l2info->cookie[6])>>3)&0xfff;
 918             l2info->proto = (l2info->cookie[5])&JUNIPER_LSQ_L3_PROTO_MASK;
 919             break;
 920         default:
 921             l2info->bundle = l2info->cookie[0];
 922             break;
 923         }
 924         break;
 925 #endif
 926 #ifdef DLT_JUNIPER_MLFR
 927     case DLT_JUNIPER_MLFR:
 928         switch (l2info->cookie_type) {
 929         case LS_COOKIE_ID:
 930             l2info->bundle = l2info->cookie[1];
 931             l2info->proto = EXTRACT_16BITS(p);
 932             l2info->header_len += 2;
 933             l2info->length -= 2;
 934             l2info->caplen -= 2;
 935             break;
 936         case AS_COOKIE_ID:
 937             l2info->bundle = (EXTRACT_16BITS(&l2info->cookie[6])>>3)&0xfff;
 938             l2info->proto = (l2info->cookie[5])&JUNIPER_LSQ_L3_PROTO_MASK;
 939             break;
 940         default:
 941             l2info->bundle = l2info->cookie[0];
 942             l2info->header_len += 2;
 943             l2info->length -= 2;
 944             l2info->caplen -= 2;
 945             break;
 946         }
 947         break;
 948 #endif
 949 #ifdef DLT_JUNIPER_MFR
 950     case DLT_JUNIPER_MFR:
 951         switch (l2info->cookie_type) {
 952         case LS_COOKIE_ID:
 953             l2info->bundle = l2info->cookie[1];
 954             l2info->proto = EXTRACT_16BITS(p);
 955             l2info->header_len += 2;
 956             l2info->length -= 2;
 957             l2info->caplen -= 2;
 958             break;
 959         case AS_COOKIE_ID:
 960             l2info->bundle = (EXTRACT_16BITS(&l2info->cookie[6])>>3)&0xfff;
 961             l2info->proto = (l2info->cookie[5])&JUNIPER_LSQ_L3_PROTO_MASK;
 962             break;
 963         default:
 964             l2info->bundle = l2info->cookie[0];
 965             break;
 966         }
 967         break;
 968 #endif
 969 #ifdef DLT_JUNIPER_ATM2
 970     case DLT_JUNIPER_ATM2:
 971         TCHECK2(p[0],4);
 972         /* ATM cell relay control word present ? */
 973         if (l2info->cookie[7] & ATM2_PKT_TYPE_MASK) {
 974             control_word = EXTRACT_32BITS(p);
 975             /* some control word heuristics */
 976             switch(control_word) {
 977             case 0: /* zero control word */
 978             case 0x08000000: /* < JUNOS 7.4 control-word */
 979             case 0x08380000: /* cntl word plus cell length (56) >= JUNOS 7.4*/
 980                 l2info->header_len += 4;
 981                 break;
 982             default:
 983                 break;
 984             }
 985
 986             if (eflag)
 987                 printf("control-word 0x%08x ", control_word);
 988         }
 989         break;
 990 #endif
 991 #ifdef DLT_JUNIPER_ATM1
 992     case DLT_JUNIPER_ATM1:
 993         break;
 994 #endif
 995 #ifdef DLT_JUNIPER_PPP
 996     case DLT_JUNIPER_PPP:
 997         break;
 998 #endif
 999 #ifdef DLT_JUNIPER_CHDLC
1000     case DLT_JUNIPER_CHDLC:
1001         break;
1002 #endif
1003 #ifdef DLT_JUNIPER_ETHER
1004     case DLT_JUNIPER_ETHER:
1005         break;
1006 #endif
1007 #ifdef DLT_JUNIPER_FRELAY
1008     case DLT_JUNIPER_FRELAY:
1009         break;
1010 #endif
1011
1012     default:
1013         printf("Unknown Juniper DLT_ type %u: ", l2info->pictype);
1014         break;
1015     }
1016
1017     if (eflag > 1)
1018         printf("hlen %u, proto 0x%04x, ",l2info->header_len,l2info->proto);
1019
1020     return 1; /* everything went ok so far. continue parsing */
1021  trunc:
1022     printf("[|juniper_hdr], length %u",h->len);
1023     return 0;
1024 }
1025
1026
1027 /*
1028  * Local Variables:
1029  * c-style: whitesmith
1030  * c-basic-offset: 4
1031  * End:
1032  */