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