b5837e378573a2e0f9282e95d186a9b78a3750ba
[dragonfly.git] / 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  */