]> The Tcpdump Group git mirrors - tcpdump/blob - print-ppp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
from Darren Reed <[email protected]>:
[tcpdump] / print-ppp.c
1 /*
2 * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997
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 * Extensively modified by Motonori Shindo (mshindo@mshindo.net) for more
22 * complete PPP support.
23 */
24
25 /*
26 * TODO:
27 * o resolve XXX as much as possible
28 * o MP support
29 * o BAP support
30 */
31
32 #ifndef lint
33 static const char rcsid[] _U_ =
34 "@(#) $Header: /tcpdump/master/tcpdump/print-ppp.c,v 1.99 2004-07-13 15:54:05 hannes Exp $ (LBL)";
35 #endif
36
37 #ifdef HAVE_CONFIG_H
38 #include "config.h"
39 #endif
40
41 #include <tcpdump-stdinc.h>
42
43 #ifdef __bsdi__
44 #include <net/slcompress.h>
45 #include <net/if_ppp.h>
46 #endif
47
48 #include <pcap.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51
52 #include "interface.h"
53 #include "extract.h"
54 #include "addrtoname.h"
55 #include "ppp.h"
56 #include "chdlc.h"
57 #include "ethertype.h"
58 #include "oui.h"
59
60 /*
61 * The following constatns are defined by IANA. Please refer to
62 * http://www.isi.edu/in-notes/iana/assignments/ppp-numbers
63 * for the up-to-date information.
64 */
65
66 /* Protocol Codes defined in ppp.h */
67
68 struct tok ppptype2str[] = {
69 { PPP_IP, "IP" },
70 { PPP_OSI, "OSI" },
71 { PPP_NS, "NS" },
72 { PPP_DECNET, "DECNET" },
73 { PPP_APPLE, "APPLE" },
74 { PPP_IPX, "IPX" },
75 { PPP_VJC, "VJC IP" },
76 { PPP_VJNC, "VJNC IP" },
77 { PPP_BRPDU, "BRPDU" },
78 { PPP_STII, "STII" },
79 { PPP_VINES, "VINES" },
80 { PPP_MPLS_UCAST, "MPLS" },
81 { PPP_MPLS_MCAST, "MPLS" },
82 { PPP_COMP, "Compressed"},
83
84 { PPP_HELLO, "HELLO" },
85 { PPP_LUXCOM, "LUXCOM" },
86 { PPP_SNS, "SNS" },
87 { PPP_IPCP, "IPCP" },
88 { PPP_OSICP, "OSICP" },
89 { PPP_NSCP, "NSCP" },
90 { PPP_DECNETCP, "DECNETCP" },
91 { PPP_APPLECP, "APPLECP" },
92 { PPP_IPXCP, "IPXCP" },
93 { PPP_STIICP, "STIICP" },
94 { PPP_VINESCP, "VINESCP" },
95 { PPP_MPLSCP, "MPLSCP" },
96
97 { PPP_LCP, "LCP" },
98 { PPP_PAP, "PAP" },
99 { PPP_LQM, "LQM" },
100 { PPP_CHAP, "CHAP" },
101 { PPP_BACP, "BACP" },
102 { PPP_BAP, "BAP" },
103 { PPP_MP, "ML" },
104 { 0, NULL }
105 };
106
107 /* Control Protocols (LCP/IPCP/CCP etc.) Codes defined in RFC 1661 */
108
109 #define CPCODES_VEXT 0 /* Vendor-Specific (RFC2153) */
110 #define CPCODES_CONF_REQ 1 /* Configure-Request */
111 #define CPCODES_CONF_ACK 2 /* Configure-Ack */
112 #define CPCODES_CONF_NAK 3 /* Configure-Nak */
113 #define CPCODES_CONF_REJ 4 /* Configure-Reject */
114 #define CPCODES_TERM_REQ 5 /* Terminate-Request */
115 #define CPCODES_TERM_ACK 6 /* Terminate-Ack */
116 #define CPCODES_CODE_REJ 7 /* Code-Reject */
117 #define CPCODES_PROT_REJ 8 /* Protocol-Reject (LCP only) */
118 #define CPCODES_ECHO_REQ 9 /* Echo-Request (LCP only) */
119 #define CPCODES_ECHO_RPL 10 /* Echo-Reply (LCP only) */
120 #define CPCODES_DISC_REQ 11 /* Discard-Request (LCP only) */
121 #define CPCODES_ID 12 /* Identification (LCP only) RFC1570 */
122 #define CPCODES_TIME_REM 13 /* Time-Remaining (LCP only) RFC1570 */
123 #define CPCODES_RESET_REQ 14 /* Reset-Request (CCP only) RFC1962 */
124 #define CPCODES_RESET_REP 15 /* Reset-Reply (CCP only) */
125
126 struct tok cpcodes[] = {
127 {CPCODES_VEXT, "Vendor-Extension"}, /* RFC2153 */
128 {CPCODES_CONF_REQ, "Conf-Request"},
129 {CPCODES_CONF_ACK, "Conf-Ack"},
130 {CPCODES_CONF_NAK, "Conf-Nack"},
131 {CPCODES_CONF_REJ, "Conf-Reject"},
132 {CPCODES_TERM_REQ, "Term-Request"},
133 {CPCODES_TERM_ACK, "Term-Ack"},
134 {CPCODES_CODE_REJ, "Code-Reject"},
135 {CPCODES_PROT_REJ, "Prot-Reject"},
136 {CPCODES_ECHO_REQ, "Echo-Request"},
137 {CPCODES_ECHO_RPL, "Echo-Reply"},
138 {CPCODES_DISC_REQ, "Disc-Req"},
139 {CPCODES_ID, "Ident"}, /* RFC1570 */
140 {CPCODES_TIME_REM, "Time-Rem"}, /* RFC1570 */
141 {CPCODES_RESET_REQ, "Reset-Req"}, /* RFC1962 */
142 {CPCODES_RESET_REP, "Reset-Ack"}, /* RFC1962 */
143 {0, NULL}
144 };
145
146 /* LCP Config Options */
147
148 #define LCPOPT_VEXT 0
149 #define LCPOPT_MRU 1
150 #define LCPOPT_ACCM 2
151 #define LCPOPT_AP 3
152 #define LCPOPT_QP 4
153 #define LCPOPT_MN 5
154 #define LCPOPT_DEP6 6
155 #define LCPOPT_PFC 7
156 #define LCPOPT_ACFC 8
157 #define LCPOPT_FCSALT 9
158 #define LCPOPT_SDP 10
159 #define LCPOPT_NUMMODE 11
160 #define LCPOPT_DEP12 12
161 #define LCPOPT_CBACK 13
162 #define LCPOPT_DEP14 14
163 #define LCPOPT_DEP15 15
164 #define LCPOPT_DEP16 16
165 #define LCPOPT_MLMRRU 17
166 #define LCPOPT_MLSSNHF 18
167 #define LCPOPT_MLED 19
168 #define LCPOPT_PROP 20
169 #define LCPOPT_DCEID 21
170 #define LCPOPT_MPP 22
171 #define LCPOPT_LD 23
172 #define LCPOPT_LCPAOPT 24
173 #define LCPOPT_COBS 25
174 #define LCPOPT_PE 26
175 #define LCPOPT_MLHF 27
176 #define LCPOPT_I18N 28
177 #define LCPOPT_SDLOS 29
178 #define LCPOPT_PPPMUX 30
179
180 #define LCPOPT_MIN LCPOPT_VEXT
181 #define LCPOPT_MAX LCPOPT_PPPMUX
182
183 static const char *lcpconfopts[] = {
184 "Vend-Ext", /* (0) */
185 "MRU", /* (1) */
186 "ACCM", /* (2) */
187 "Auth-Prot", /* (3) */
188 "Qual-Prot", /* (4) */
189 "Magic-Num", /* (5) */
190 "deprecated(6)", /* used to be a Quality Protocol */
191 "PFC", /* (7) */
192 "ACFC", /* (8) */
193 "FCS-Alt", /* (9) */
194 "SDP", /* (10) */
195 "Num-Mode", /* (11) */
196 "deprecated(12)", /* used to be a Multi-Link-Procedure*/
197 "Call-Back", /* (13) */
198 "deprecated(14)", /* used to be a Connect-Time */
199 "deprecated(15)", /* used to be a Compund-Frames */
200 "deprecated(16)", /* used to be a Nominal-Data-Encap */
201 "MRRU", /* (17) */
202 "SSNHF", /* (18) */
203 "End-Disc", /* (19) */
204 "Proprietary", /* (20) */
205 "DCE-Id", /* (21) */
206 "MP+", /* (22) */
207 "Link-Disc", /* (23) */
208 "LCP-Auth-Opt", /* (24) */
209 "COBS", /* (25) */
210 "Prefix-elision", /* (26) */
211 "Multilink-header-Form",/* (27) */
212 "I18N", /* (28) */
213 "SDL-over-SONET/SDH", /* (29) */
214 "PPP-Muxing", /* (30) */
215 };
216
217 /* IPV6CP - to be supported */
218 /* ECP - to be supported */
219
220 /* CCP Config Options */
221
222 #define CCPOPT_OUI 0 /* RFC1962 */
223 #define CCPOPT_PRED1 1 /* RFC1962 */
224 #define CCPOPT_PRED2 2 /* RFC1962 */
225 #define CCPOPT_PJUMP 3 /* RFC1962 */
226 /* 4-15 unassigned */
227 #define CCPOPT_HPPPC 16 /* RFC1962 */
228 #define CCPOPT_STACLZS 17 /* RFC1974 */
229 #define CCPOPT_MPPC 18 /* RFC2118 */
230 #define CCPOPT_GFZA 19 /* RFC1962 */
231 #define CCPOPT_V42BIS 20 /* RFC1962 */
232 #define CCPOPT_BSDCOMP 21 /* RFC1977 */
233 /* 22 unassigned */
234 #define CCPOPT_LZSDCP 23 /* RFC1967 */
235 #define CCPOPT_MVRCA 24 /* RFC1975 */
236 #define CCPOPT_DEC 25 /* RFC1976 */
237 #define CCPOPT_DEFLATE 26 /* RFC1979 */
238 /* 27-254 unassigned */
239 #define CCPOPT_RESV 255 /* RFC1962 */
240
241 #define CCPOPT_MIN CCPOPT_OUI
242 #define CCPOPT_MAX CCPOPT_DEFLATE /* XXX: should be CCPOPT_RESV but... */
243
244 static const char *ccpconfopts[] = {
245 "OUI", /* (0) */
246 "Pred-1", /* (1) */
247 "Pred-2", /* (2) */
248 "Puddle", /* (3) */
249 "unassigned(4)", /* (4) */
250 "unassigned(5)", /* (5) */
251 "unassigned(6)", /* (6) */
252 "unassigned(7)", /* (7) */
253 "unassigned(8)", /* (8) */
254 "unassigned(9)", /* (9) */
255 "unassigned(10)", /* (10) */
256 "unassigned(11)", /* (11) */
257 "unassigned(12)", /* (12) */
258 "unassigned(13)", /* (13) */
259 "unassigned(14)", /* (14) */
260 "unassigned(15)", /* (15) */
261 "HP-PPC", /* (16) */
262 "Stac-LZS", /* (17) */
263 "MPPC", /* (18) */
264 "Gand-FZA", /* (19) */
265 "V.42bis", /* (20) */
266 "BSD-Comp", /* (21) */
267 "unassigned(22)", /* (22) */
268 "LZS-DCP", /* (23) */
269 "MVRCA", /* (24) */
270 "DEC", /* (25) */
271 "Deflate", /* (26) */
272 };
273
274 /* BACP Config Options */
275
276 #define BACPOPT_FPEER 1 /* RFC2125 */
277
278 /* SDCP - to be supported */
279
280 /* IPCP Config Options */
281
282 #define IPCPOPT_2ADDR 1 /* RFC1172, RFC1332 (deprecated) */
283 #define IPCPOPT_IPCOMP 2 /* RFC1332 */
284 #define IPCPOPT_ADDR 3 /* RFC1332 */
285 #define IPCPOPT_MOBILE4 4 /* RFC2290 */
286
287 #define IPCPOPT_PRIDNS 129 /* RFC1877 */
288 #define IPCPOPT_PRINBNS 130 /* RFC1877 */
289 #define IPCPOPT_SECDNS 131 /* RFC1877 */
290 #define IPCPOPT_SECNBNS 132 /* RFC1877 */
291
292 /* ATCP - to be supported */
293 /* OSINLCP - to be supported */
294 /* BVCP - to be supported */
295 /* BCP - to be supported */
296 /* IPXCP - to be supported */
297 /* MPLSCP - to be supported */
298
299 /* Auth Algorithms */
300
301 /* 0-4 Reserved (RFC1994) */
302 #define AUTHALG_CHAPMD5 5 /* RFC1994 */
303 #define AUTHALG_MSCHAP1 128 /* RFC2433 */
304 #define AUTHALG_MSCHAP2 129 /* RFC2795 */
305
306 /* FCS Alternatives - to be supported */
307
308 /* Multilink Endpoint Discriminator (RFC1717) */
309 #define MEDCLASS_NULL 0 /* Null Class */
310 #define MEDCLASS_LOCAL 1 /* Locally Assigned */
311 #define MEDCLASS_IPV4 2 /* Internet Protocol (IPv4) */
312 #define MEDCLASS_MAC 3 /* IEEE 802.1 global MAC address */
313 #define MEDCLASS_MNB 4 /* PPP Magic Number Block */
314 #define MEDCLASS_PSNDN 5 /* Public Switched Network Director Number */
315
316 /* PPP LCP Callback */
317 #define CALLBACK_AUTH 0 /* Location determined by user auth */
318 #define CALLBACK_DSTR 1 /* Dialing string */
319 #define CALLBACK_LID 2 /* Location identifier */
320 #define CALLBACK_E164 3 /* E.164 number */
321 #define CALLBACK_X500 4 /* X.500 distinguished name */
322 #define CALLBACK_CBCP 6 /* Location is determined during CBCP nego */
323
324 /* CHAP */
325
326 #define CHAP_CHAL 1
327 #define CHAP_RESP 2
328 #define CHAP_SUCC 3
329 #define CHAP_FAIL 4
330
331 #define CHAP_CODEMIN CHAP_CHAL
332 #define CHAP_CODEMAX CHAP_FAIL
333
334 static const char *chapcode[] = {
335 "Chal", /* (1) */
336 "Resp", /* (2) */
337 "Succ", /* (3) */
338 "Fail", /* (4) */
339 };
340
341 /* PAP */
342
343 #define PAP_AREQ 1
344 #define PAP_AACK 2
345 #define PAP_ANAK 3
346
347 #define PAP_CODEMIN PAP_AREQ
348 #define PAP_CODEMAX PAP_ANAK
349
350 static const char *papcode[] = {
351 "Auth-Req", /* (1) */
352 "Auth-Ack", /* (2) */
353 "Auth-Nak", /* (3) */
354 };
355
356 /* BAP */
357 #define BAP_CALLREQ 1
358 #define BAP_CALLRES 2
359 #define BAP_CBREQ 3
360 #define BAP_CBRES 4
361 #define BAP_LDQREQ 5
362 #define BAP_LDQRES 6
363 #define BAP_CSIND 7
364 #define BAP_CSRES 8
365
366 static void handle_ctrl_proto (u_int proto,const u_char *p, int length);
367 static void handle_chap (const u_char *p, int length);
368 static void handle_pap (const u_char *p, int length);
369 static void handle_bap (const u_char *p, int length);
370 static int print_lcp_config_options (const u_char *p, int);
371 static int print_ipcp_config_options (const u_char *p, int);
372 static int print_ccp_config_options (const u_char *p, int);
373 static int print_bacp_config_options (const u_char *p, int);
374 static void handle_ppp (u_int proto, const u_char *p, int length);
375 static void ppp_hdlc(const u_char *p, int length);
376
377 /* generic Control Protocol (e.g. LCP, IPCP, CCP, etc.) handler */
378 static void
379 handle_ctrl_proto(u_int proto, const u_char *pptr, int length)
380 {
381 const char *typestr;
382 u_int code, len;
383 int (*pfunc)(const u_char *, int);
384 int x, j;
385 const u_char *tptr;
386
387 tptr=pptr;
388
389 typestr = tok2str(ppptype2str, "unknown", proto);
390 printf("%s, ",typestr);
391
392 if (length < 4) /* FIXME weak boundary checking */
393 goto trunc;
394 TCHECK2(*tptr, 2);
395
396 code = *tptr++;
397
398 printf("%s (0x%02x), id %u",
399 tok2str(cpcodes, "Unknown Opcode",code),
400 code,
401 *tptr++); /* ID */
402
403 TCHECK2(*tptr, 2);
404 len = EXTRACT_16BITS(tptr);
405 tptr += 2;
406
407 if (length <= 4)
408 return; /* there may be a NULL confreq etc. */
409
410 switch (code) {
411 case CPCODES_VEXT:
412 if (length < 11)
413 break;
414 TCHECK2(*tptr, 4);
415 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
416 tptr += 4;
417 TCHECK2(*tptr, 3);
418 printf(" Vendor: %s (%u)",
419 tok2str(oui_values,"Unknown",EXTRACT_24BITS(tptr)),
420 EXTRACT_24BITS(tptr));
421 /* XXX: need to decode Kind and Value(s)? */
422 break;
423 case CPCODES_CONF_REQ:
424 case CPCODES_CONF_ACK:
425 case CPCODES_CONF_NAK:
426 case CPCODES_CONF_REJ:
427 x = len - 4; /* Code(1), Identifier(1) and Length(2) */
428 do {
429 switch (proto) {
430 case PPP_LCP:
431 pfunc = print_lcp_config_options;
432 break;
433 case PPP_IPCP:
434 pfunc = print_ipcp_config_options;
435 break;
436 case PPP_CCP:
437 pfunc = print_ccp_config_options;
438 break;
439 case PPP_BACP:
440 pfunc = print_bacp_config_options;
441 break;
442 default:
443 /*
444 * This should never happen, but we set
445 * "pfunc" to squelch uninitialized
446 * variable warnings from compilers.
447 */
448 pfunc = NULL;
449 break;
450 }
451
452 if (pfunc == NULL) /* catch the above null pointer if unknown CP */
453 break;
454
455 if ((j = (*pfunc)(tptr, len)) == 0)
456 break;
457 x -= j;
458 tptr += j;
459 } while (x > 0);
460 break;
461
462 case CPCODES_TERM_REQ:
463 case CPCODES_TERM_ACK:
464 /* XXX: need to decode Data? */
465 break;
466 case CPCODES_CODE_REJ:
467 /* XXX: need to decode Rejected-Packet? */
468 break;
469 case CPCODES_PROT_REJ:
470 if (length < 6)
471 break;
472 TCHECK2(*tptr, 2);
473 printf(", Rejected %s Protocol (0x%04x)",
474 tok2str(ppptype2str,"unknown", EXTRACT_16BITS(tptr)),
475 EXTRACT_16BITS(tptr));
476 /* XXX: need to decode Rejected-Information? */
477 break;
478 case CPCODES_ECHO_REQ:
479 case CPCODES_ECHO_RPL:
480 case CPCODES_DISC_REQ:
481 case CPCODES_ID:
482 if (length < 8)
483 break;
484 TCHECK2(*tptr, 4);
485 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
486 /* XXX: need to decode Data? */
487 break;
488 case CPCODES_TIME_REM:
489 if (length < 12)
490 break;
491 TCHECK2(*tptr, 4);
492 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(tptr));
493 TCHECK2(*(tptr + 4), 4);
494 printf(", Seconds-Remaining %us", EXTRACT_32BITS(tptr + 4));
495 /* XXX: need to decode Message? */
496 break;
497 default:
498 /* XXX this is dirty but we do not get the
499 * original pointer passed to the begin
500 * the PPP packet */
501 if (vflag <= 1)
502 print_unknown_data(pptr-2,"\n\t",length+2);
503 break;
504 }
505 printf(", length %u", length);
506
507 if (vflag >1)
508 print_unknown_data(pptr-2,"\n\t",length+2);
509 return;
510
511 trunc:
512 printf("[|%s]", typestr);
513 }
514
515 /* LCP config options */
516 static int
517 print_lcp_config_options(const u_char *p, int length)
518 {
519 int len, opt;
520
521 if (length < 2)
522 return 0;
523 TCHECK2(*p, 2);
524 len = p[1];
525 opt = p[0];
526 if (length < len)
527 return 0;
528 if ((opt >= LCPOPT_MIN) && (opt <= LCPOPT_MAX))
529 printf(", %s (%u)", lcpconfopts[opt],opt);
530 else {
531 printf(", unknown LCP option 0x%02x", opt);
532 return len;
533 }
534
535 switch (opt) {
536 case LCPOPT_VEXT:
537 if (len >= 6) {
538 TCHECK2(*(p + 2), 3);
539 printf(" Vendor: %s (%u)",
540 tok2str(oui_values,"Unknown",EXTRACT_24BITS(p+2)),
541 EXTRACT_24BITS(p+2));
542 #if 0
543 TCHECK(p[5]);
544 printf(", kind: 0x%02x", p[5]);
545 printf(", Value: 0x")
546 for (i = 0; i < len - 6; i++) {
547 TCHECK(p[6 + i]);
548 printf("%02x", p[6 + i]);
549 }
550 #endif
551 }
552 break;
553 case LCPOPT_MRU:
554 if (len == 4) {
555 TCHECK2(*(p + 2), 2);
556 printf(" %u", EXTRACT_16BITS(p + 2));
557 }
558 break;
559 case LCPOPT_ACCM:
560 if (len == 6) {
561 TCHECK2(*(p + 2), 4);
562 printf(" 0x%08x", EXTRACT_32BITS(p + 2));
563 }
564 break;
565 case LCPOPT_AP:
566 if (len >= 4) {
567 TCHECK2(*(p + 2), 2);
568 switch (EXTRACT_16BITS(p+2)) {
569 case PPP_PAP:
570 printf(" PAP");
571 break;
572 case PPP_CHAP:
573 printf(" CHAP");
574 TCHECK(p[4]);
575 switch (p[4]) {
576 default:
577 printf(", unknown-algorithm-%u", p[4]);
578 break;
579 case AUTHALG_CHAPMD5:
580 printf(", MD5");
581 break;
582 case AUTHALG_MSCHAP1:
583 printf(", MSCHAPv1");
584 break;
585 case AUTHALG_MSCHAP2:
586 printf(", MSCHAPv2");
587 break;
588 }
589 break;
590 case PPP_EAP:
591 printf(" EAP");
592 break;
593 case PPP_SPAP:
594 printf(" SPAP");
595 break;
596 case PPP_SPAP_OLD:
597 printf(" Old-SPAP");
598 break;
599 default:
600 printf("unknown");
601 }
602 }
603 break;
604 case LCPOPT_QP:
605 if (len >= 4) {
606 TCHECK2(*(p + 2), 2);
607 if (EXTRACT_16BITS(p+2) == PPP_LQM)
608 printf(" LQR");
609 else
610 printf(" unknown");
611 }
612 break;
613 case LCPOPT_MN:
614 if (len == 6) {
615 TCHECK2(*(p + 2), 4);
616 printf(" 0x%08x", EXTRACT_32BITS(p + 2));
617 }
618 break;
619 case LCPOPT_PFC:
620 break;
621 case LCPOPT_ACFC:
622 break;
623 case LCPOPT_LD:
624 if (len == 4) {
625 TCHECK2(*(p + 2), 2);
626 printf(" 0x%04x", EXTRACT_16BITS(p + 2));
627 }
628 break;
629 case LCPOPT_CBACK:
630 if (len < 3)
631 break;
632 TCHECK(p[2]);
633 switch (p[2]) { /* Operation */
634 case CALLBACK_AUTH:
635 printf(" UserAuth");
636 break;
637 case CALLBACK_DSTR:
638 printf(" DialString");
639 break;
640 case CALLBACK_LID:
641 printf(" LocalID");
642 break;
643 case CALLBACK_E164:
644 printf(" E.164");
645 break;
646 case CALLBACK_X500:
647 printf(" X.500");
648 break;
649 case CALLBACK_CBCP:
650 printf(" CBCP");
651 break;
652 default:
653 printf(" unknown-operation=%u", p[2]);
654 break;
655 }
656 break;
657 case LCPOPT_MLMRRU:
658 if (len == 4) {
659 TCHECK2(*(p + 2), 2);
660 printf(" %u", EXTRACT_16BITS(p + 2));
661 }
662 break;
663 case LCPOPT_MLED:
664 if (len < 3)
665 break;
666 TCHECK(p[2]);
667 switch (p[2]) { /* class */
668 case MEDCLASS_NULL:
669 printf(" Null");
670 break;
671 case MEDCLASS_LOCAL:
672 printf(" Local"); /* XXX */
673 break;
674 case MEDCLASS_IPV4:
675 if (len != 7)
676 break;
677 TCHECK2(*(p + 3), 4);
678 printf(" IPv4 %s", ipaddr_string(p + 3));
679 break;
680 case MEDCLASS_MAC:
681 if (len != 9)
682 break;
683 TCHECK(p[8]);
684 printf(" MAC %02x:%02x:%02x:%02x:%02x:%02x",
685 p[3], p[4], p[5], p[6], p[7], p[8]);
686 break;
687 case MEDCLASS_MNB:
688 printf(" Magic-Num-Block"); /* XXX */
689 break;
690 case MEDCLASS_PSNDN:
691 printf(" PSNDN"); /* XXX */
692 break;
693 }
694 break;
695
696 /* XXX: to be supported */
697 #if 0
698 case LCPOPT_DEP6:
699 case LCPOPT_FCSALT:
700 case LCPOPT_SDP:
701 case LCPOPT_NUMMODE:
702 case LCPOPT_DEP12:
703 case LCPOPT_DEP14:
704 case LCPOPT_DEP15:
705 case LCPOPT_DEP16:
706 case LCPOPT_MLSSNHF:
707 case LCPOPT_PROP:
708 case LCPOPT_DCEID:
709 case LCPOPT_MPP:
710 case LCPOPT_LCPAOPT:
711 case LCPOPT_COBS:
712 case LCPOPT_PE:
713 case LCPOPT_MLHF:
714 case LCPOPT_I18N:
715 case LCPOPT_SDLOS:
716 case LCPOPT_PPPMUX:
717 break;
718 #endif
719 }
720 return len;
721
722 trunc:
723 printf("[|lcp]");
724 return 0;
725 }
726
727 /* CHAP */
728 static void
729 handle_chap(const u_char *p, int length)
730 {
731 u_int code, len;
732 int val_size, name_size, msg_size;
733 const u_char *p0;
734 int i;
735
736 p0 = p;
737 if (length < 1) {
738 printf("[|chap]");
739 return;
740 } else if (length < 4) {
741 TCHECK(*p);
742 printf("[|chap 0x%02x]", *p);
743 return;
744 }
745
746 TCHECK(*p);
747 code = *p;
748 if ((code >= CHAP_CODEMIN) && (code <= CHAP_CODEMAX))
749 printf("%s", chapcode[code - 1]);
750 else {
751 printf("0x%02x", code);
752 return;
753 }
754 p++;
755
756 TCHECK(*p);
757 printf("(%u)", *p); /* ID */
758 p++;
759
760 TCHECK2(*p, 2);
761 len = EXTRACT_16BITS(p);
762 p += 2;
763
764 /*
765 * Note that this is a generic CHAP decoding routine. Since we
766 * don't know which flavor of CHAP (i.e. CHAP-MD5, MS-CHAPv1,
767 * MS-CHAPv2) is used at this point, we can't decode packet
768 * specifically to each algorithms. Instead, we simply decode
769 * the GCD (Gratest Common Denominator) for all algorithms.
770 */
771 switch (code) {
772 case CHAP_CHAL:
773 case CHAP_RESP:
774 if (length - (p - p0) < 1)
775 return;
776 TCHECK(*p);
777 val_size = *p; /* value size */
778 p++;
779 if (length - (p - p0) < val_size)
780 return;
781 printf(", Value ");
782 for (i = 0; i < val_size; i++) {
783 TCHECK(*p);
784 printf("%02x", *p++);
785 }
786 name_size = len - (p - p0);
787 printf(", Name ");
788 for (i = 0; i < name_size; i++) {
789 TCHECK(*p);
790 safeputchar(*p++);
791 }
792 break;
793 case CHAP_SUCC:
794 case CHAP_FAIL:
795 msg_size = len - (p - p0);
796 printf(", Msg ");
797 for (i = 0; i< msg_size; i++) {
798 TCHECK(*p);
799 safeputchar(*p++);
800 }
801 break;
802 }
803 return;
804
805 trunc:
806 printf("[|chap]");
807 }
808
809 /* PAP (see RFC 1334) */
810 static void
811 handle_pap(const u_char *p, int length)
812 {
813 u_int code, len;
814 int peerid_len, passwd_len, msg_len;
815 const u_char *p0;
816 int i;
817
818 p0 = p;
819 if (length < 1) {
820 printf("[|pap]");
821 return;
822 } else if (length < 4) {
823 TCHECK(*p);
824 printf("[|pap 0x%02x]", *p);
825 return;
826 }
827
828 TCHECK(*p);
829 code = *p;
830 if ((code >= PAP_CODEMIN) && (code <= PAP_CODEMAX))
831 printf("%s", papcode[code - 1]);
832 else {
833 printf("0x%02x", code);
834 return;
835 }
836 p++;
837
838 TCHECK(*p);
839 printf("(%u)", *p); /* ID */
840 p++;
841
842 TCHECK2(*p, 2);
843 len = EXTRACT_16BITS(p);
844 p += 2;
845
846 switch (code) {
847 case PAP_AREQ:
848 if (length - (p - p0) < 1)
849 return;
850 TCHECK(*p);
851 peerid_len = *p; /* Peer-ID Length */
852 p++;
853 if (length - (p - p0) < peerid_len)
854 return;
855 printf(", Peer ");
856 for (i = 0; i < peerid_len; i++) {
857 TCHECK(*p);
858 safeputchar(*p++);
859 }
860
861 if (length - (p - p0) < 1)
862 return;
863 TCHECK(*p);
864 passwd_len = *p; /* Password Length */
865 p++;
866 if (length - (p - p0) < passwd_len)
867 return;
868 printf(", Name ");
869 for (i = 0; i < passwd_len; i++) {
870 TCHECK(*p);
871 safeputchar(*p++);
872 }
873 break;
874 case PAP_AACK:
875 case PAP_ANAK:
876 if (length - (p - p0) < 1)
877 return;
878 TCHECK(*p);
879 msg_len = *p; /* Msg-Length */
880 p++;
881 if (length - (p - p0) < msg_len)
882 return;
883 printf(", Msg ");
884 for (i = 0; i< msg_len; i++) {
885 TCHECK(*p);
886 safeputchar(*p++);
887 }
888 break;
889 }
890 return;
891
892 trunc:
893 printf("[|pap]");
894 }
895
896 /* BAP */
897 static void
898 handle_bap(const u_char *p _U_, int length _U_)
899 {
900 /* XXX: to be supported!! */
901 }
902
903
904 /* IPCP config options */
905 static int
906 print_ipcp_config_options(const u_char *p, int length)
907 {
908 int len, opt;
909
910 if (length < 2)
911 return 0;
912 TCHECK2(*p, 2);
913 len = p[1];
914 opt = p[0];
915 if (length < len)
916 return 0;
917 switch (opt) {
918 case IPCPOPT_2ADDR: /* deprecated */
919 if (len != 10)
920 goto invlen;
921 TCHECK2(*(p + 6), 4);
922 printf(", IP-Addrs src %s, dst %s",
923 ipaddr_string(p + 2),
924 ipaddr_string(p + 6));
925 break;
926 case IPCPOPT_IPCOMP:
927 if (len < 4)
928 goto invlen;
929 printf(", IP-Comp");
930 TCHECK2(*(p + 2), 2);
931 if (EXTRACT_16BITS(p + 2) == PPP_VJC) {
932 printf(" VJ-Comp");
933 /* XXX: VJ-Comp parameters should be decoded */
934 } else
935 printf(" unknown-comp-proto=%04x", EXTRACT_16BITS(p + 2));
936 break;
937 case IPCPOPT_ADDR:
938 if (len != 6)
939 goto invlen;
940 TCHECK2(*(p + 2), 4);
941 printf(", IP-Addr %s", ipaddr_string(p + 2));
942 break;
943 case IPCPOPT_MOBILE4:
944 if (len != 6)
945 goto invlen;
946 TCHECK2(*(p + 2), 4);
947 printf(", Home-Addr %s", ipaddr_string(p + 2));
948 break;
949 case IPCPOPT_PRIDNS:
950 if (len != 6)
951 goto invlen;
952 TCHECK2(*(p + 2), 4);
953 printf(", Pri-DNS %s", ipaddr_string(p + 2));
954 break;
955 case IPCPOPT_PRINBNS:
956 if (len != 6)
957 goto invlen;
958 TCHECK2(*(p + 2), 4);
959 printf(", Pri-NBNS %s", ipaddr_string(p + 2));
960 break;
961 case IPCPOPT_SECDNS:
962 if (len != 6)
963 goto invlen;
964 TCHECK2(*(p + 2), 4);
965 printf(", Sec-DNS %s", ipaddr_string(p + 2));
966 break;
967 case IPCPOPT_SECNBNS:
968 if (len != 6)
969 goto invlen;
970 TCHECK2(*(p + 2), 4);
971 printf(", Sec-NBNS %s", ipaddr_string(p + 2));
972 break;
973 default:
974 printf(", unknown-%d", opt);
975 break;
976 }
977 return len;
978
979 invlen:
980 printf(", invalid-length-%d", opt);
981 return 0;
982
983 trunc:
984 printf("[|ipcp]");
985 return 0;
986 }
987
988 /* CCP config options */
989 static int
990 print_ccp_config_options(const u_char *p, int length)
991 {
992 int len, opt;
993
994 if (length < 2)
995 return 0;
996 TCHECK2(*p, 2);
997 len = p[1];
998 opt = p[0];
999 if (length < len)
1000 return 0;
1001 if ((opt >= CCPOPT_MIN) && (opt <= CCPOPT_MAX))
1002 printf(", %s", ccpconfopts[opt]);
1003 #if 0 /* XXX */
1004 switch (opt) {
1005 case CCPOPT_OUI:
1006 case CCPOPT_PRED1:
1007 case CCPOPT_PRED2:
1008 case CCPOPT_PJUMP:
1009 case CCPOPT_HPPPC:
1010 case CCPOPT_STACLZS:
1011 case CCPOPT_MPPC:
1012 case CCPOPT_GFZA:
1013 case CCPOPT_V42BIS:
1014 case CCPOPT_BSDCOMP:
1015 case CCPOPT_LZSDCP:
1016 case CCPOPT_MVRCA:
1017 case CCPOPT_DEC:
1018 case CCPOPT_DEFLATE:
1019 case CCPOPT_RESV:
1020 break;
1021
1022 default:
1023 printf(", unknown-%d", opt);
1024 break;
1025 }
1026 #endif
1027 return len;
1028
1029 trunc:
1030 printf("[|ccp]");
1031 return 0;
1032 }
1033
1034 /* BACP config options */
1035 static int
1036 print_bacp_config_options(const u_char *p, int length)
1037 {
1038 int len, opt;
1039
1040 if (length < 2)
1041 return 0;
1042 TCHECK2(*p, 2);
1043 len = p[1];
1044 opt = p[0];
1045 if (length < len)
1046 return 0;
1047 if (opt == BACPOPT_FPEER) {
1048 TCHECK2(*(p + 2), 4);
1049 printf(", Favored-Peer");
1050 printf(", Magic-Num 0x%08x", EXTRACT_32BITS(p + 2));
1051 } else {
1052 printf(", unknown-option-%d", opt);
1053 }
1054 return len;
1055
1056 trunc:
1057 printf("[|bacp]");
1058 return 0;
1059 }
1060
1061
1062 static void
1063 ppp_hdlc(const u_char *p, int length)
1064 {
1065 u_char *b, *s, *t, c;
1066 int i, proto;
1067 const void *se;
1068
1069 b = (u_int8_t *)malloc(length);
1070 if (b == NULL)
1071 return;
1072
1073 /*
1074 * Unescape all the data into a temporary, private, buffer.
1075 * Do this so that we dont overwrite the original packet
1076 * contents.
1077 */
1078 for (s = (u_char *)p, t = b, i = length; i > 0; i--) {
1079 c = *s++;
1080 if (c == 0x7d) {
1081 if (i > 1) {
1082 i--;
1083 c = *s++ ^ 0x20;
1084 } else
1085 continue;
1086 }
1087 *t++ = c;
1088 }
1089
1090 se = snapend;
1091 snapend = t;
1092
1093 /* now lets guess about the payload codepoint format */
1094 proto = *b; /* start with a one-octet codepoint guess */
1095
1096 switch (proto) {
1097 case PPP_IP:
1098 ip_print(b+1, t - b - 1);
1099 goto cleanup;
1100 #ifdef INET6
1101 case PPP_IPV6:
1102 ip6_print(b+1, t - b - 1);
1103 goto cleanup;
1104 #endif
1105 default: /* no luck - try next guess */
1106 break;
1107 }
1108
1109 proto = EXTRACT_16BITS(b); /* next guess - load two octets */
1110
1111 switch (proto) {
1112 case 0xff03: /* looks like a PPP frame */
1113 proto = EXTRACT_16BITS(b+2); /* load the PPP proto-id */
1114 handle_ppp(proto, b+4, t - b - 4);
1115 break;
1116 default: /* last guess - proto must be a PPP proto-id */
1117 handle_ppp(proto, b+2, t - b - 2);
1118 break;
1119 }
1120
1121 cleanup:
1122 snapend = se;
1123 free(b);
1124 return;
1125 }
1126
1127
1128 /* PPP */
1129 static void
1130 handle_ppp(u_int proto, const u_char *p, int length)
1131 {
1132 if ((proto & 0xff00) == 0x7e00) {/* is this an escape code ? */
1133 ppp_hdlc(p-1, length);
1134 return;
1135 }
1136
1137 switch (proto) {
1138 case PPP_LCP:
1139 case PPP_IPCP:
1140 case PPP_OSICP:
1141 case PPP_MPLSCP:
1142 case PPP_IPV6CP:
1143 case PPP_CCP:
1144 case PPP_BACP:
1145 handle_ctrl_proto(proto, p, length);
1146 break;
1147 case PPP_CHAP:
1148 handle_chap(p, length);
1149 break;
1150 case PPP_PAP:
1151 handle_pap(p, length);
1152 break;
1153 case PPP_BAP: /* XXX: not yet completed */
1154 handle_bap(p, length);
1155 break;
1156 case ETHERTYPE_IP: /*XXX*/
1157 case PPP_VJNC:
1158 case PPP_IP:
1159 ip_print(p, length);
1160 break;
1161 #ifdef INET6
1162 case ETHERTYPE_IPV6: /*XXX*/
1163 case PPP_IPV6:
1164 ip6_print(p, length);
1165 break;
1166 #endif
1167 case ETHERTYPE_IPX: /*XXX*/
1168 case PPP_IPX:
1169 ipx_print(p, length);
1170 break;
1171 case PPP_OSI:
1172 isoclns_print(p, length, length);
1173 break;
1174 case PPP_MPLS_UCAST:
1175 case PPP_MPLS_MCAST:
1176 mpls_print(p, length);
1177 break;
1178 case PPP_COMP:
1179 printf("compressed PPP data");
1180 break;
1181 default:
1182 printf("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
1183 print_unknown_data(p,"\n\t",length);
1184 break;
1185 }
1186 }
1187
1188 /* Standard PPP printer */
1189 u_int
1190 ppp_print(register const u_char *p, u_int length)
1191 {
1192 u_int proto;
1193 u_int olen = length; /* _o_riginal length */
1194 u_int hdr_len = 0;
1195
1196 /*
1197 * Here, we assume that p points to the Address and Control
1198 * field (if they present).
1199 */
1200 if (length < 2)
1201 goto trunc;
1202 TCHECK2(*p, 2);
1203 if (*p == PPP_ADDRESS && *(p + 1) == PPP_CONTROL) {
1204 p += 2; /* ACFC not used */
1205 length -= 2;
1206 hdr_len += 2;
1207 }
1208
1209 if (length < 2)
1210 goto trunc;
1211 TCHECK(*p);
1212 if (*p % 2) {
1213 proto = *p; /* PFC is used */
1214 p++;
1215 length--;
1216 hdr_len++;
1217 } else {
1218 TCHECK2(*p, 2);
1219 proto = EXTRACT_16BITS(p);
1220 p += 2;
1221 length -= 2;
1222 hdr_len += 2;
1223 }
1224
1225 if (eflag)
1226 printf("%s (0x%04x), length %u: ",
1227 tok2str(ppptype2str, "unknown", proto),
1228 proto,
1229 olen);
1230
1231 handle_ppp(proto, p, length);
1232 return (hdr_len);
1233 trunc:
1234 printf("[|ppp]");
1235 return (0);
1236 }
1237
1238
1239 /* PPP I/F printer */
1240 u_int
1241 ppp_if_print(const struct pcap_pkthdr *h, register const u_char *p)
1242 {
1243 register u_int length = h->len;
1244 register u_int caplen = h->caplen;
1245
1246 if (caplen < PPP_HDRLEN) {
1247 printf("[|ppp]");
1248 return (caplen);
1249 }
1250
1251 #if 0
1252 /*
1253 * XXX: seems to assume that there are 2 octets prepended to an
1254 * actual PPP frame. The 1st octet looks like Input/Output flag
1255 * while 2nd octet is unknown, at least to me
1256 * (mshindo@mshindo.net).
1257 *
1258 * That was what the original tcpdump code did.
1259 *
1260 * FreeBSD's "if_ppp.c" *does* set the first octet to 1 for outbound
1261 * packets and 0 for inbound packets - but only if the
1262 * protocol field has the 0x8000 bit set (i.e., it's a network
1263 * control protocol); it does so before running the packet through
1264 * "bpf_filter" to see if it should be discarded, and to see
1265 * if we should update the time we sent the most recent packet...
1266 *
1267 * ...but it puts the original address field back after doing
1268 * so.
1269 *
1270 * NetBSD's "if_ppp.c" doesn't set the first octet in that fashion.
1271 *
1272 * I don't know if any PPP implementation handed up to a BPF
1273 * device packets with the first octet being 1 for outbound and
1274 * 0 for inbound packets, so I (guy@alum.mit.edu) don't know
1275 * whether that ever needs to be checked or not.
1276 *
1277 * Note that NetBSD has a DLT_PPP_SERIAL, which it uses for PPP,
1278 * and its tcpdump appears to assume that the frame always
1279 * begins with an address field and a control field, and that
1280 * the address field might be 0x0f or 0x8f, for Cisco
1281 * point-to-point with HDLC framing as per section 4.3.1 of RFC
1282 * 1547, as well as 0xff, for PPP in HDLC-like framing as per
1283 * RFC 1662.
1284 *
1285 * (Is the Cisco framing in question what DLT_C_HDLC, in
1286 * BSD/OS, is?)
1287 */
1288 if (eflag)
1289 printf("%c %4d %02x ", p[0] ? 'O' : 'I', length, p[1]);
1290 #endif
1291
1292 ppp_print(p, length);
1293
1294 return (0);
1295 }
1296
1297 /*
1298 * PPP I/F printer to use if we know that RFC 1662-style PPP in HDLC-like
1299 * framing, or Cisco PPP with HDLC framing as per section 4.3.1 of RFC 1547,
1300 * is being used (i.e., we don't check for PPP_ADDRESS and PPP_CONTROL,
1301 * discard them *if* those are the first two octets, and parse the remaining
1302 * packet as a PPP packet, as "ppp_print()" does).
1303 *
1304 * This handles, for example, DLT_PPP_SERIAL in NetBSD.
1305 */
1306 u_int
1307 ppp_hdlc_if_print(const struct pcap_pkthdr *h, register const u_char *p)
1308 {
1309 register u_int length = h->len;
1310 register u_int caplen = h->caplen;
1311 u_int proto;
1312 u_int hdrlen = 0;
1313
1314 if (caplen < 2) {
1315 printf("[|ppp]");
1316 return (caplen);
1317 }
1318
1319 switch (p[0]) {
1320
1321 case PPP_ADDRESS:
1322 if (caplen < 4) {
1323 printf("[|ppp]");
1324 return (caplen);
1325 }
1326
1327 if (eflag)
1328 printf("%02x %02x %d ", p[0], p[1], length);
1329 p += 2;
1330 length -= 2;
1331 hdrlen += 2;
1332
1333 proto = EXTRACT_16BITS(p);
1334 p += 2;
1335 length -= 2;
1336 hdrlen += 2;
1337 printf("%s: ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", proto));
1338
1339 handle_ppp(proto, p, length);
1340 break;
1341
1342 case CHDLC_UNICAST:
1343 case CHDLC_BCAST:
1344 return (chdlc_if_print(h, p));
1345
1346 default:
1347 if (eflag)
1348 printf("%02x %02x %d ", p[0], p[1], length);
1349 p += 2;
1350 length -= 2;
1351 hdrlen += 2;
1352
1353 /*
1354 * XXX - NetBSD's "ppp_netbsd_serial_if_print()" treats
1355 * the next two octets as an Ethernet type; does that
1356 * ever happen?
1357 */
1358 printf("unknown addr %02x; ctrl %02x", p[0], p[1]);
1359 break;
1360 }
1361
1362 return (hdrlen);
1363 }
1364
1365 #define PPP_BSDI_HDRLEN 24
1366
1367 /* BSD/OS specific PPP printer */
1368 u_int
1369 ppp_bsdos_if_print(const struct pcap_pkthdr *h _U_, register const u_char *p _U_)
1370 {
1371 register int hdrlength;
1372 #ifdef __bsdi__
1373 register u_int length = h->len;
1374 register u_int caplen = h->caplen;
1375 u_int16_t ptype;
1376 const u_char *q;
1377 int i;
1378
1379 if (caplen < PPP_BSDI_HDRLEN) {
1380 printf("[|ppp]");
1381 return (caplen)
1382 }
1383
1384 hdrlength = 0;
1385
1386 #if 0
1387 if (p[0] == PPP_ADDRESS && p[1] == PPP_CONTROL) {
1388 if (eflag)
1389 printf("%02x %02x ", p[0], p[1]);
1390 p += 2;
1391 hdrlength = 2;
1392 }
1393
1394 if (eflag)
1395 printf("%d ", length);
1396 /* Retrieve the protocol type */
1397 if (*p & 01) {
1398 /* Compressed protocol field */
1399 ptype = *p;
1400 if (eflag)
1401 printf("%02x ", ptype);
1402 p++;
1403 hdrlength += 1;
1404 } else {
1405 /* Un-compressed protocol field */
1406 ptype = ntohs(*(u_int16_t *)p);
1407 if (eflag)
1408 printf("%04x ", ptype);
1409 p += 2;
1410 hdrlength += 2;
1411 }
1412 #else
1413 ptype = 0; /*XXX*/
1414 if (eflag)
1415 printf("%c ", p[SLC_DIR] ? 'O' : 'I');
1416 if (p[SLC_LLHL]) {
1417 /* link level header */
1418 struct ppp_header *ph;
1419
1420 q = p + SLC_BPFHDRLEN;
1421 ph = (struct ppp_header *)q;
1422 if (ph->phdr_addr == PPP_ADDRESS
1423 && ph->phdr_ctl == PPP_CONTROL) {
1424 if (eflag)
1425 printf("%02x %02x ", q[0], q[1]);
1426 ptype = ntohs(ph->phdr_type);
1427 if (eflag && (ptype == PPP_VJC || ptype == PPP_VJNC)) {
1428 printf("%s ", tok2str(ppptype2str,
1429 "proto-#%d", ptype));
1430 }
1431 } else {
1432 if (eflag) {
1433 printf("LLH=[");
1434 for (i = 0; i < p[SLC_LLHL]; i++)
1435 printf("%02x", q[i]);
1436 printf("] ");
1437 }
1438 }
1439 }
1440 if (eflag)
1441 printf("%d ", length);
1442 if (p[SLC_CHL]) {
1443 q = p + SLC_BPFHDRLEN + p[SLC_LLHL];
1444
1445 switch (ptype) {
1446 case PPP_VJC:
1447 ptype = vjc_print(q, ptype);
1448 hdrlength = PPP_BSDI_HDRLEN;
1449 p += hdrlength;
1450 switch (ptype) {
1451 case PPP_IP:
1452 ip_print(p, length);
1453 break;
1454 #ifdef INET6
1455 case PPP_IPV6:
1456 ip6_print(p, length);
1457 break;
1458 #endif
1459 case PPP_MPLS_UCAST:
1460 case PPP_MPLS_MCAST:
1461 mpls_print(p, length);
1462 break;
1463 }
1464 goto printx;
1465 case PPP_VJNC:
1466 ptype = vjc_print(q, ptype);
1467 hdrlength = PPP_BSDI_HDRLEN;
1468 p += hdrlength;
1469 switch (ptype) {
1470 case PPP_IP:
1471 ip_print(p, length);
1472 break;
1473 #ifdef INET6
1474 case PPP_IPV6:
1475 ip6_print(p, length);
1476 break;
1477 #endif
1478 case PPP_MPLS_UCAST:
1479 case PPP_MPLS_MCAST:
1480 mpls_print(p, length);
1481 break;
1482 }
1483 goto printx;
1484 default:
1485 if (eflag) {
1486 printf("CH=[");
1487 for (i = 0; i < p[SLC_LLHL]; i++)
1488 printf("%02x", q[i]);
1489 printf("] ");
1490 }
1491 break;
1492 }
1493 }
1494
1495 hdrlength = PPP_BSDI_HDRLEN;
1496 #endif
1497
1498 length -= hdrlength;
1499 p += hdrlength;
1500
1501 switch (ptype) {
1502 case PPP_IP:
1503 ip_print(p, length);
1504 break;
1505 #ifdef INET6
1506 case PPP_IPV6:
1507 ip6_print(p, length);
1508 break;
1509 #endif
1510 case PPP_MPLS_UCAST:
1511 case PPP_MPLS_MCAST:
1512 mpls_print(p, length);
1513 break;
1514 default:
1515 printf("%s ", tok2str(ppptype2str, "unknown PPP protocol (0x%04x)", ptype));
1516 }
1517
1518 printx:
1519 #else /* __bsdi */
1520 hdrlength = 0;
1521 #endif /* __bsdi__ */
1522 return (hdrlength);
1523 }
[mirror] the TCPdump network dissector