1/* 2 * Copyright (c) 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 * PPTP support contributed by Motonori Shindo (mshindo@mshindo.net) 22 */ 23 24 25#include <sys/cdefs.h> 26#ifndef lint 27#if 0 28static const char rcsid[] _U_ = 29 "@(#) Header: /tcpdump/master/tcpdump/print-pptp.c,v 1.12 2006-06-23 02:03:09 hannes Exp"; 30#else 31__RCSID("$NetBSD$"); 32#endif 33#endif 34 35#ifdef HAVE_CONFIG_H 36#include "config.h" 37#endif 38 39#include <tcpdump-stdinc.h> 40 41#include <stdio.h> 42 43#include "interface.h" 44#include "extract.h" 45 46static char tstr[] = " [|pptp]"; 47 48#define PPTP_MSG_TYPE_CTRL 1 /* Control Message */ 49#define PPTP_MSG_TYPE_MGMT 2 /* Management Message (currently not used */ 50#define PPTP_MAGIC_COOKIE 0x1a2b3c4d /* for sanity check */ 51 52#define PPTP_CTRL_MSG_TYPE_SCCRQ 1 53#define PPTP_CTRL_MSG_TYPE_SCCRP 2 54#define PPTP_CTRL_MSG_TYPE_StopCCRQ 3 55#define PPTP_CTRL_MSG_TYPE_StopCCRP 4 56#define PPTP_CTRL_MSG_TYPE_ECHORQ 5 57#define PPTP_CTRL_MSG_TYPE_ECHORP 6 58#define PPTP_CTRL_MSG_TYPE_OCRQ 7 59#define PPTP_CTRL_MSG_TYPE_OCRP 8 60#define PPTP_CTRL_MSG_TYPE_ICRQ 9 61#define PPTP_CTRL_MSG_TYPE_ICRP 10 62#define PPTP_CTRL_MSG_TYPE_ICCN 11 63#define PPTP_CTRL_MSG_TYPE_CCRQ 12 64#define PPTP_CTRL_MSG_TYPE_CDN 13 65#define PPTP_CTRL_MSG_TYPE_WEN 14 66#define PPTP_CTRL_MSG_TYPE_SLI 15 67 68#define PPTP_FRAMING_CAP_ASYNC_MASK 0x00000001 /* Aynchronous */ 69#define PPTP_FRAMING_CAP_SYNC_MASK 0x00000002 /* Synchronous */ 70 71#define PPTP_BEARER_CAP_ANALOG_MASK 0x00000001 /* Analog */ 72#define PPTP_BEARER_CAP_DIGITAL_MASK 0x00000002 /* Digital */ 73 74static const char *pptp_message_type_string[] = { 75 "NOT_DEFINED", /* 0 Not defined in the RFC2637 */ 76 "SCCRQ", /* 1 Start-Control-Connection-Request */ 77 "SCCRP", /* 2 Start-Control-Connection-Reply */ 78 "StopCCRQ", /* 3 Stop-Control-Connection-Request */ 79 "StopCCRP", /* 4 Stop-Control-Connection-Reply */ 80 "ECHORQ", /* 5 Echo Request */ 81 "ECHORP", /* 6 Echo Reply */ 82 83 "OCRQ", /* 7 Outgoing-Call-Request */ 84 "OCRP", /* 8 Outgoing-Call-Reply */ 85 "ICRQ", /* 9 Incoming-Call-Request */ 86 "ICRP", /* 10 Incoming-Call-Reply */ 87 "ICCN", /* 11 Incoming-Call-Connected */ 88 "CCRQ", /* 12 Call-Clear-Request */ 89 "CDN", /* 13 Call-Disconnect-Notify */ 90 91 "WEN", /* 14 WAN-Error-Notify */ 92 93 "SLI" /* 15 Set-Link-Info */ 94#define PPTP_MAX_MSGTYPE_INDEX 16 95}; 96 97/* common for all PPTP control messages */ 98struct pptp_hdr { 99 u_int16_t length; 100 u_int16_t msg_type; 101 u_int32_t magic_cookie; 102 u_int16_t ctrl_msg_type; 103 u_int16_t reserved0; 104}; 105 106struct pptp_msg_sccrq { 107 u_int16_t proto_ver; 108 u_int16_t reserved1; 109 u_int32_t framing_cap; 110 u_int32_t bearer_cap; 111 u_int16_t max_channel; 112 u_int16_t firm_rev; 113 u_char hostname[64]; 114 u_char vendor[64]; 115}; 116 117struct pptp_msg_sccrp { 118 u_int16_t proto_ver; 119 u_int8_t result_code; 120 u_int8_t err_code; 121 u_int32_t framing_cap; 122 u_int32_t bearer_cap; 123 u_int16_t max_channel; 124 u_int16_t firm_rev; 125 u_char hostname[64]; 126 u_char vendor[64]; 127}; 128 129struct pptp_msg_stopccrq { 130 u_int8_t reason; 131 u_int8_t reserved1; 132 u_int16_t reserved2; 133}; 134 135struct pptp_msg_stopccrp { 136 u_int8_t result_code; 137 u_int8_t err_code; 138 u_int16_t reserved1; 139}; 140 141struct pptp_msg_echorq { 142 u_int32_t id; 143}; 144 145struct pptp_msg_echorp { 146 u_int32_t id; 147 u_int8_t result_code; 148 u_int8_t err_code; 149 u_int16_t reserved1; 150}; 151 152struct pptp_msg_ocrq { 153 u_int16_t call_id; 154 u_int16_t call_ser; 155 u_int32_t min_bps; 156 u_int32_t max_bps; 157 u_int32_t bearer_type; 158 u_int32_t framing_type; 159 u_int16_t recv_winsiz; 160 u_int16_t pkt_proc_delay; 161 u_int16_t phone_no_len; 162 u_int16_t reserved1; 163 u_char phone_no[64]; 164 u_char subaddr[64]; 165}; 166 167struct pptp_msg_ocrp { 168 u_int16_t call_id; 169 u_int16_t peer_call_id; 170 u_int8_t result_code; 171 u_int8_t err_code; 172 u_int16_t cause_code; 173 u_int32_t conn_speed; 174 u_int16_t recv_winsiz; 175 u_int16_t pkt_proc_delay; 176 u_int32_t phy_chan_id; 177}; 178 179struct pptp_msg_icrq { 180 u_int16_t call_id; 181 u_int16_t call_ser; 182 u_int32_t bearer_type; 183 u_int32_t phy_chan_id; 184 u_int16_t dialed_no_len; 185 u_int16_t dialing_no_len; 186 u_char dialed_no[64]; /* DNIS */ 187 u_char dialing_no[64]; /* CLID */ 188 u_char subaddr[64]; 189}; 190 191struct pptp_msg_icrp { 192 u_int16_t call_id; 193 u_int16_t peer_call_id; 194 u_int8_t result_code; 195 u_int8_t err_code; 196 u_int16_t recv_winsiz; 197 u_int16_t pkt_proc_delay; 198 u_int16_t reserved1; 199}; 200 201struct pptp_msg_iccn { 202 u_int16_t peer_call_id; 203 u_int16_t reserved1; 204 u_int32_t conn_speed; 205 u_int16_t recv_winsiz; 206 u_int16_t pkt_proc_delay; 207 u_int32_t framing_type; 208}; 209 210struct pptp_msg_ccrq { 211 u_int16_t call_id; 212 u_int16_t reserved1; 213}; 214 215struct pptp_msg_cdn { 216 u_int16_t call_id; 217 u_int8_t result_code; 218 u_int8_t err_code; 219 u_int16_t cause_code; 220 u_int16_t reserved1; 221 u_char call_stats[128]; 222}; 223 224struct pptp_msg_wen { 225 u_int16_t peer_call_id; 226 u_int16_t reserved1; 227 u_int32_t crc_err; 228 u_int32_t framing_err; 229 u_int32_t hardware_overrun; 230 u_int32_t buffer_overrun; 231 u_int32_t timeout_err; 232 u_int32_t align_err; 233}; 234 235struct pptp_msg_sli { 236 u_int16_t peer_call_id; 237 u_int16_t reserved1; 238 u_int32_t send_accm; 239 u_int32_t recv_accm; 240}; 241 242/* attributes that appear more than once in above messages: 243 244 Number of 245 occurence attributes 246 -------------------------------------- 247 2 u_int32_t bearer_cap; 248 2 u_int32_t bearer_type; 249 6 u_int16_t call_id; 250 2 u_int16_t call_ser; 251 2 u_int16_t cause_code; 252 2 u_int32_t conn_speed; 253 6 u_int8_t err_code; 254 2 u_int16_t firm_rev; 255 2 u_int32_t framing_cap; 256 2 u_int32_t framing_type; 257 2 u_char hostname[64]; 258 2 u_int32_t id; 259 2 u_int16_t max_channel; 260 5 u_int16_t peer_call_id; 261 2 u_int32_t phy_chan_id; 262 4 u_int16_t pkt_proc_delay; 263 2 u_int16_t proto_ver; 264 4 u_int16_t recv_winsiz; 265 2 u_int8_t reserved1; 266 9 u_int16_t reserved1; 267 6 u_int8_t result_code; 268 2 u_char subaddr[64]; 269 2 u_char vendor[64]; 270 271 so I will prepare print out functions for these attributes (except for 272 reserved*). 273*/ 274 275/******************************************/ 276/* Attribute-specific print out functions */ 277/******************************************/ 278 279/* In these attribute-specific print-out functions, it't not necessary 280 to do TCHECK because they are already checked in the caller of 281 these functions. */ 282 283static void 284pptp_bearer_cap_print(const u_int32_t *bearer_cap) 285{ 286 printf(" BEARER_CAP("); 287 if (EXTRACT_32BITS(bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK) { 288 printf("D"); 289 } 290 if (EXTRACT_32BITS(bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK) { 291 printf("A"); 292 } 293 printf(")"); 294} 295 296static void 297pptp_bearer_type_print(const u_int32_t *bearer_type) 298{ 299 printf(" BEARER_TYPE("); 300 switch (EXTRACT_32BITS(bearer_type)) { 301 case 1: 302 printf("A"); /* Analog */ 303 break; 304 case 2: 305 printf("D"); /* Digital */ 306 break; 307 case 3: 308 printf("Any"); 309 break; 310 default: 311 printf("?"); 312 break; 313 } 314 printf(")"); 315} 316 317static void 318pptp_call_id_print(const u_int16_t *call_id) 319{ 320 printf(" CALL_ID(%u)", EXTRACT_16BITS(call_id)); 321} 322 323static void 324pptp_call_ser_print(const u_int16_t *call_ser) 325{ 326 printf(" CALL_SER_NUM(%u)", EXTRACT_16BITS(call_ser)); 327} 328 329static void 330pptp_cause_code_print(const u_int16_t *cause_code) 331{ 332 printf(" CAUSE_CODE(%u)", EXTRACT_16BITS(cause_code)); 333} 334 335static void 336pptp_conn_speed_print(const u_int32_t *conn_speed) 337{ 338 printf(" CONN_SPEED(%u)", EXTRACT_32BITS(conn_speed)); 339} 340 341static void 342pptp_err_code_print(const u_int8_t *err_code) 343{ 344 printf(" ERR_CODE(%u", *err_code); 345 if (vflag) { 346 switch (*err_code) { 347 case 0: 348 printf(":None"); 349 break; 350 case 1: 351 printf(":Not-Connected"); 352 break; 353 case 2: 354 printf(":Bad-Format"); 355 break; 356 case 3: 357 printf(":Bad-Valude"); 358 break; 359 case 4: 360 printf(":No-Resource"); 361 break; 362 case 5: 363 printf(":Bad-Call-ID"); 364 break; 365 case 6: 366 printf(":PAC-Error"); 367 break; 368 default: 369 printf(":?"); 370 break; 371 } 372 } 373 printf(")"); 374} 375 376static void 377pptp_firm_rev_print(const u_int16_t *firm_rev) 378{ 379 printf(" FIRM_REV(%u)", EXTRACT_16BITS(firm_rev)); 380} 381 382static void 383pptp_framing_cap_print(const u_int32_t *framing_cap) 384{ 385 printf(" FRAME_CAP("); 386 if (EXTRACT_32BITS(framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) { 387 printf("A"); /* Async */ 388 } 389 if (EXTRACT_32BITS(framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) { 390 printf("S"); /* Sync */ 391 } 392 printf(")"); 393} 394 395static void 396pptp_framing_type_print(const u_int32_t *framing_type) 397{ 398 printf(" FRAME_TYPE("); 399 switch (EXTRACT_32BITS(framing_type)) { 400 case 1: 401 printf("A"); /* Async */ 402 break; 403 case 2: 404 printf("S"); /* Sync */ 405 break; 406 case 3: 407 printf("E"); /* Either */ 408 break; 409 default: 410 printf("?"); 411 break; 412 } 413 printf(")"); 414} 415 416static void 417pptp_hostname_print(const u_char *hostname) 418{ 419 printf(" HOSTNAME(%.64s)", hostname); 420} 421 422static void 423pptp_id_print(const u_int32_t *id) 424{ 425 printf(" ID(%u)", EXTRACT_32BITS(id)); 426} 427 428static void 429pptp_max_channel_print(const u_int16_t *max_channel) 430{ 431 printf(" MAX_CHAN(%u)", EXTRACT_16BITS(max_channel)); 432} 433 434static void 435pptp_peer_call_id_print(const u_int16_t *peer_call_id) 436{ 437 printf(" PEER_CALL_ID(%u)", EXTRACT_16BITS(peer_call_id)); 438} 439 440static void 441pptp_phy_chan_id_print(const u_int32_t *phy_chan_id) 442{ 443 printf(" PHY_CHAN_ID(%u)", EXTRACT_32BITS(phy_chan_id)); 444} 445 446static void 447pptp_pkt_proc_delay_print(const u_int16_t *pkt_proc_delay) 448{ 449 printf(" PROC_DELAY(%u)", EXTRACT_16BITS(pkt_proc_delay)); 450} 451 452static void 453pptp_proto_ver_print(const u_int16_t *proto_ver) 454{ 455 printf(" PROTO_VER(%u.%u)", /* Version.Revision */ 456 EXTRACT_16BITS(proto_ver) >> 8, 457 EXTRACT_16BITS(proto_ver) & 0xff); 458} 459 460static void 461pptp_recv_winsiz_print(const u_int16_t *recv_winsiz) 462{ 463 printf(" RECV_WIN(%u)", EXTRACT_16BITS(recv_winsiz)); 464} 465 466static void 467pptp_result_code_print(const u_int8_t *result_code, int ctrl_msg_type) 468{ 469 printf(" RESULT_CODE(%u", *result_code); 470 if (vflag) { 471 switch (ctrl_msg_type) { 472 case PPTP_CTRL_MSG_TYPE_SCCRP: 473 switch (*result_code) { 474 case 1: 475 printf(":Successful channel establishment"); 476 break; 477 case 2: 478 printf(":General error"); 479 break; 480 case 3: 481 printf(":Command channel already exists"); 482 break; 483 case 4: 484 printf(":Requester is not authorized to establish a command channel"); 485 break; 486 case 5: 487 printf(":The protocol version of the requester is not supported"); 488 break; 489 default: 490 printf(":?"); 491 break; 492 } 493 break; 494 case PPTP_CTRL_MSG_TYPE_StopCCRP: 495 case PPTP_CTRL_MSG_TYPE_ECHORP: 496 switch (*result_code) { 497 case 1: 498 printf(":OK"); 499 break; 500 case 2: 501 printf(":General Error"); 502 break; 503 default: 504 printf(":?"); 505 break; 506 } 507 break; 508 case PPTP_CTRL_MSG_TYPE_OCRP: 509 switch (*result_code) { 510 case 1: 511 printf(":Connected"); 512 break; 513 case 2: 514 printf(":General Error"); 515 break; 516 case 3: 517 printf(":No Carrier"); 518 break; 519 case 4: 520 printf(":Busy"); 521 break; 522 case 5: 523 printf(":No Dial Tone"); 524 break; 525 case 6: 526 printf(":Time-out"); 527 break; 528 case 7: 529 printf(":Do Not Accept"); 530 break; 531 default: 532 printf(":?"); 533 break; 534 } 535 break; 536 case PPTP_CTRL_MSG_TYPE_ICRP: 537 switch (*result_code) { 538 case 1: 539 printf(":Connect"); 540 break; 541 case 2: 542 printf(":General Error"); 543 break; 544 case 3: 545 printf(":Do Not Accept"); 546 break; 547 default: 548 printf(":?"); 549 break; 550 } 551 break; 552 case PPTP_CTRL_MSG_TYPE_CDN: 553 switch (*result_code) { 554 case 1: 555 printf(":Lost Carrier"); 556 break; 557 case 2: 558 printf(":General Error"); 559 break; 560 case 3: 561 printf(":Admin Shutdown"); 562 break; 563 case 4: 564 printf(":Request"); 565 default: 566 printf(":?"); 567 break; 568 break; 569 } 570 default: 571 /* assertion error */ 572 break; 573 } 574 } 575 printf(")"); 576} 577 578static void 579pptp_subaddr_print(const u_char *subaddr) 580{ 581 printf(" SUB_ADDR(%.64s)", subaddr); 582} 583 584static void 585pptp_vendor_print(const u_char *vendor) 586{ 587 printf(" VENDOR(%.64s)", vendor); 588} 589 590/************************************/ 591/* PPTP message print out functions */ 592/************************************/ 593static void 594pptp_sccrq_print(const u_char *dat) 595{ 596 struct pptp_msg_sccrq *ptr = (struct pptp_msg_sccrq *)dat; 597 598 TCHECK(ptr->proto_ver); 599 pptp_proto_ver_print(&ptr->proto_ver); 600 TCHECK(ptr->reserved1); 601 TCHECK(ptr->framing_cap); 602 pptp_framing_cap_print(&ptr->framing_cap); 603 TCHECK(ptr->bearer_cap); 604 pptp_bearer_cap_print(&ptr->bearer_cap); 605 TCHECK(ptr->max_channel); 606 pptp_max_channel_print(&ptr->max_channel); 607 TCHECK(ptr->firm_rev); 608 pptp_firm_rev_print(&ptr->firm_rev); 609 TCHECK(ptr->hostname); 610 pptp_hostname_print(&ptr->hostname[0]); 611 TCHECK(ptr->vendor); 612 pptp_vendor_print(&ptr->vendor[0]); 613 614 return; 615 616trunc: 617 printf("%s", tstr); 618} 619 620static void 621pptp_sccrp_print(const u_char *dat) 622{ 623 struct pptp_msg_sccrp *ptr = (struct pptp_msg_sccrp *)dat; 624 625 TCHECK(ptr->proto_ver); 626 pptp_proto_ver_print(&ptr->proto_ver); 627 TCHECK(ptr->result_code); 628 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP); 629 TCHECK(ptr->err_code); 630 pptp_err_code_print(&ptr->err_code); 631 TCHECK(ptr->framing_cap); 632 pptp_framing_cap_print(&ptr->framing_cap); 633 TCHECK(ptr->bearer_cap); 634 pptp_bearer_cap_print(&ptr->bearer_cap); 635 TCHECK(ptr->max_channel); 636 pptp_max_channel_print(&ptr->max_channel); 637 TCHECK(ptr->firm_rev); 638 pptp_firm_rev_print(&ptr->firm_rev); 639 TCHECK(ptr->hostname); 640 pptp_hostname_print(&ptr->hostname[0]); 641 TCHECK(ptr->vendor); 642 pptp_vendor_print(&ptr->vendor[0]); 643 644 return; 645 646trunc: 647 printf("%s", tstr); 648} 649 650static void 651pptp_stopccrq_print(const u_char *dat) 652{ 653 struct pptp_msg_stopccrq *ptr = (struct pptp_msg_stopccrq *)dat; 654 655 TCHECK(ptr->reason); 656 printf(" REASON(%u", ptr->reason); 657 if (vflag) { 658 switch (ptr->reason) { 659 case 1: 660 printf(":None"); 661 break; 662 case 2: 663 printf(":Stop-Protocol"); 664 break; 665 case 3: 666 printf(":Stop-Local-Shutdown"); 667 break; 668 default: 669 printf(":?"); 670 break; 671 } 672 } 673 printf(")"); 674 TCHECK(ptr->reserved1); 675 TCHECK(ptr->reserved2); 676 677 return; 678 679trunc: 680 printf("%s", tstr); 681} 682 683static void 684pptp_stopccrp_print(const u_char *dat) 685{ 686 struct pptp_msg_stopccrp *ptr = (struct pptp_msg_stopccrp *)dat; 687 688 TCHECK(ptr->result_code); 689 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP); 690 TCHECK(ptr->err_code); 691 pptp_err_code_print(&ptr->err_code); 692 TCHECK(ptr->reserved1); 693 694 return; 695 696trunc: 697 printf("%s", tstr); 698} 699 700static void 701pptp_echorq_print(const u_char *dat) 702{ 703 struct pptp_msg_echorq *ptr = (struct pptp_msg_echorq *)dat; 704 705 TCHECK(ptr->id); 706 pptp_id_print(&ptr->id); 707 708 return; 709 710trunc: 711 printf("%s", tstr); 712} 713 714static void 715pptp_echorp_print(const u_char *dat) 716{ 717 struct pptp_msg_echorp *ptr = (struct pptp_msg_echorp *)dat; 718 719 TCHECK(ptr->id); 720 pptp_id_print(&ptr->id); 721 TCHECK(ptr->result_code); 722 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP); 723 TCHECK(ptr->err_code); 724 pptp_err_code_print(&ptr->err_code); 725 TCHECK(ptr->reserved1); 726 727 return; 728 729trunc: 730 printf("%s", tstr); 731} 732 733static void 734pptp_ocrq_print(const u_char *dat) 735{ 736 struct pptp_msg_ocrq *ptr = (struct pptp_msg_ocrq *)dat; 737 738 TCHECK(ptr->call_id); 739 pptp_call_id_print(&ptr->call_id); 740 TCHECK(ptr->call_ser); 741 pptp_call_ser_print(&ptr->call_ser); 742 TCHECK(ptr->min_bps); 743 printf(" MIN_BPS(%u)", EXTRACT_32BITS(&ptr->min_bps)); 744 TCHECK(ptr->max_bps); 745 printf(" MAX_BPS(%u)", EXTRACT_32BITS(&ptr->max_bps)); 746 TCHECK(ptr->bearer_type); 747 pptp_bearer_type_print(&ptr->bearer_type); 748 TCHECK(ptr->framing_type); 749 pptp_framing_type_print(&ptr->framing_type); 750 TCHECK(ptr->recv_winsiz); 751 pptp_recv_winsiz_print(&ptr->recv_winsiz); 752 TCHECK(ptr->pkt_proc_delay); 753 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 754 TCHECK(ptr->phone_no_len); 755 printf(" PHONE_NO_LEN(%u)", EXTRACT_16BITS(&ptr->phone_no_len)); 756 TCHECK(ptr->reserved1); 757 TCHECK(ptr->phone_no); 758 printf(" PHONE_NO(%.64s)", ptr->phone_no); 759 TCHECK(ptr->subaddr); 760 pptp_subaddr_print(&ptr->subaddr[0]); 761 762 return; 763 764trunc: 765 printf("%s", tstr); 766} 767 768static void 769pptp_ocrp_print(const u_char *dat) 770{ 771 struct pptp_msg_ocrp *ptr = (struct pptp_msg_ocrp *)dat; 772 773 TCHECK(ptr->call_id); 774 pptp_call_id_print(&ptr->call_id); 775 TCHECK(ptr->peer_call_id); 776 pptp_peer_call_id_print(&ptr->peer_call_id); 777 TCHECK(ptr->result_code); 778 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP); 779 TCHECK(ptr->err_code); 780 pptp_err_code_print(&ptr->err_code); 781 TCHECK(ptr->cause_code); 782 pptp_cause_code_print(&ptr->cause_code); 783 TCHECK(ptr->conn_speed); 784 pptp_conn_speed_print(&ptr->conn_speed); 785 TCHECK(ptr->recv_winsiz); 786 pptp_recv_winsiz_print(&ptr->recv_winsiz); 787 TCHECK(ptr->pkt_proc_delay); 788 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 789 TCHECK(ptr->phy_chan_id); 790 pptp_phy_chan_id_print(&ptr->phy_chan_id); 791 792 return; 793 794trunc: 795 printf("%s", tstr); 796} 797 798static void 799pptp_icrq_print(const u_char *dat) 800{ 801 struct pptp_msg_icrq *ptr = (struct pptp_msg_icrq *)dat; 802 803 TCHECK(ptr->call_id); 804 pptp_call_id_print(&ptr->call_id); 805 TCHECK(ptr->call_ser); 806 pptp_call_ser_print(&ptr->call_ser); 807 TCHECK(ptr->bearer_type); 808 pptp_bearer_type_print(&ptr->bearer_type); 809 TCHECK(ptr->phy_chan_id); 810 pptp_phy_chan_id_print(&ptr->phy_chan_id); 811 TCHECK(ptr->dialed_no_len); 812 printf(" DIALED_NO_LEN(%u)", EXTRACT_16BITS(&ptr->dialed_no_len)); 813 TCHECK(ptr->dialing_no_len); 814 printf(" DIALING_NO_LEN(%u)", EXTRACT_16BITS(&ptr->dialing_no_len)); 815 TCHECK(ptr->dialed_no); 816 printf(" DIALED_NO(%.64s)", ptr->dialed_no); 817 TCHECK(ptr->dialing_no); 818 printf(" DIALING_NO(%.64s)", ptr->dialing_no); 819 TCHECK(ptr->subaddr); 820 pptp_subaddr_print(&ptr->subaddr[0]); 821 822 return; 823 824trunc: 825 printf("%s", tstr); 826} 827 828static void 829pptp_icrp_print(const u_char *dat) 830{ 831 struct pptp_msg_icrp *ptr = (struct pptp_msg_icrp *)dat; 832 833 TCHECK(ptr->call_id); 834 pptp_call_id_print(&ptr->call_id); 835 TCHECK(ptr->peer_call_id); 836 pptp_peer_call_id_print(&ptr->peer_call_id); 837 TCHECK(ptr->result_code); 838 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP); 839 TCHECK(ptr->err_code); 840 pptp_err_code_print(&ptr->err_code); 841 TCHECK(ptr->recv_winsiz); 842 pptp_recv_winsiz_print(&ptr->recv_winsiz); 843 TCHECK(ptr->pkt_proc_delay); 844 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 845 TCHECK(ptr->reserved1); 846 847 return; 848 849trunc: 850 printf("%s", tstr); 851} 852 853static void 854pptp_iccn_print(const u_char *dat) 855{ 856 struct pptp_msg_iccn *ptr = (struct pptp_msg_iccn *)dat; 857 858 TCHECK(ptr->peer_call_id); 859 pptp_peer_call_id_print(&ptr->peer_call_id); 860 TCHECK(ptr->reserved1); 861 TCHECK(ptr->conn_speed); 862 pptp_conn_speed_print(&ptr->conn_speed); 863 TCHECK(ptr->recv_winsiz); 864 pptp_recv_winsiz_print(&ptr->recv_winsiz); 865 TCHECK(ptr->pkt_proc_delay); 866 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay); 867 TCHECK(ptr->framing_type); 868 pptp_framing_type_print(&ptr->framing_type); 869 870 return; 871 872trunc: 873 printf("%s", tstr); 874} 875 876static void 877pptp_ccrq_print(const u_char *dat) 878{ 879 struct pptp_msg_ccrq *ptr = (struct pptp_msg_ccrq *)dat; 880 881 TCHECK(ptr->call_id); 882 pptp_call_id_print(&ptr->call_id); 883 TCHECK(ptr->reserved1); 884 885 return; 886 887trunc: 888 printf("%s", tstr); 889} 890 891static void 892pptp_cdn_print(const u_char *dat) 893{ 894 struct pptp_msg_cdn *ptr = (struct pptp_msg_cdn *)dat; 895 896 TCHECK(ptr->call_id); 897 pptp_call_id_print(&ptr->call_id); 898 TCHECK(ptr->result_code); 899 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN); 900 TCHECK(ptr->err_code); 901 pptp_err_code_print(&ptr->err_code); 902 TCHECK(ptr->cause_code); 903 pptp_cause_code_print(&ptr->cause_code); 904 TCHECK(ptr->reserved1); 905 TCHECK(ptr->call_stats); 906 printf(" CALL_STATS(%.128s)", ptr->call_stats); 907 908 return; 909 910trunc: 911 printf("%s", tstr); 912} 913 914static void 915pptp_wen_print(const u_char *dat) 916{ 917 struct pptp_msg_wen *ptr = (struct pptp_msg_wen *)dat; 918 919 TCHECK(ptr->peer_call_id); 920 pptp_peer_call_id_print(&ptr->peer_call_id); 921 TCHECK(ptr->reserved1); 922 TCHECK(ptr->crc_err); 923 printf(" CRC_ERR(%u)", EXTRACT_32BITS(&ptr->crc_err)); 924 TCHECK(ptr->framing_err); 925 printf(" FRAMING_ERR(%u)", EXTRACT_32BITS(&ptr->framing_err)); 926 TCHECK(ptr->hardware_overrun); 927 printf(" HARDWARE_OVERRUN(%u)", EXTRACT_32BITS(&ptr->hardware_overrun)); 928 TCHECK(ptr->buffer_overrun); 929 printf(" BUFFER_OVERRUN(%u)", EXTRACT_32BITS(&ptr->buffer_overrun)); 930 TCHECK(ptr->timeout_err); 931 printf(" TIMEOUT_ERR(%u)", EXTRACT_32BITS(&ptr->timeout_err)); 932 TCHECK(ptr->align_err); 933 printf(" ALIGN_ERR(%u)", EXTRACT_32BITS(&ptr->align_err)); 934 935 return; 936 937trunc: 938 printf("%s", tstr); 939} 940 941static void 942pptp_sli_print(const u_char *dat) 943{ 944 struct pptp_msg_sli *ptr = (struct pptp_msg_sli *)dat; 945 946 TCHECK(ptr->peer_call_id); 947 pptp_peer_call_id_print(&ptr->peer_call_id); 948 TCHECK(ptr->reserved1); 949 TCHECK(ptr->send_accm); 950 printf(" SEND_ACCM(0x%08x)", EXTRACT_32BITS(&ptr->send_accm)); 951 TCHECK(ptr->recv_accm); 952 printf(" RECV_ACCM(0x%08x)", EXTRACT_32BITS(&ptr->recv_accm)); 953 954 return; 955 956trunc: 957 printf("%s", tstr); 958} 959 960void 961pptp_print(const u_char *dat) 962{ 963 const struct pptp_hdr *hdr; 964 u_int32_t mc; 965 u_int16_t ctrl_msg_type; 966 967 printf(": pptp"); 968 969 hdr = (struct pptp_hdr *)dat; 970 971 TCHECK(hdr->length); 972 if (vflag) { 973 printf(" Length=%u", EXTRACT_16BITS(&hdr->length)); 974 } 975 TCHECK(hdr->msg_type); 976 if (vflag) { 977 switch(EXTRACT_16BITS(&hdr->msg_type)) { 978 case PPTP_MSG_TYPE_CTRL: 979 printf(" CTRL-MSG"); 980 break; 981 case PPTP_MSG_TYPE_MGMT: 982 printf(" MGMT-MSG"); 983 break; 984 default: 985 printf(" UNKNOWN-MSG-TYPE"); 986 break; 987 } 988 } 989 990 TCHECK(hdr->magic_cookie); 991 mc = EXTRACT_32BITS(&hdr->magic_cookie); 992 if (mc != PPTP_MAGIC_COOKIE) { 993 printf(" UNEXPECTED Magic-Cookie!!(%08x)", mc); 994 } 995 if (vflag || mc != PPTP_MAGIC_COOKIE) { 996 printf(" Magic-Cookie=%08x", mc); 997 } 998 TCHECK(hdr->ctrl_msg_type); 999 ctrl_msg_type = EXTRACT_16BITS(&hdr->ctrl_msg_type); 1000 if (ctrl_msg_type < PPTP_MAX_MSGTYPE_INDEX) { 1001 printf(" CTRL_MSGTYPE=%s", 1002 pptp_message_type_string[ctrl_msg_type]); 1003 } else { 1004 printf(" UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type); 1005 } 1006 TCHECK(hdr->reserved0); 1007 1008 dat += 12; 1009 1010 switch(ctrl_msg_type) { 1011 case PPTP_CTRL_MSG_TYPE_SCCRQ: 1012 pptp_sccrq_print(dat); 1013 break; 1014 case PPTP_CTRL_MSG_TYPE_SCCRP: 1015 pptp_sccrp_print(dat); 1016 break; 1017 case PPTP_CTRL_MSG_TYPE_StopCCRQ: 1018 pptp_stopccrq_print(dat); 1019 break; 1020 case PPTP_CTRL_MSG_TYPE_StopCCRP: 1021 pptp_stopccrp_print(dat); 1022 break; 1023 case PPTP_CTRL_MSG_TYPE_ECHORQ: 1024 pptp_echorq_print(dat); 1025 break; 1026 case PPTP_CTRL_MSG_TYPE_ECHORP: 1027 pptp_echorp_print(dat); 1028 break; 1029 case PPTP_CTRL_MSG_TYPE_OCRQ: 1030 pptp_ocrq_print(dat); 1031 break; 1032 case PPTP_CTRL_MSG_TYPE_OCRP: 1033 pptp_ocrp_print(dat); 1034 break; 1035 case PPTP_CTRL_MSG_TYPE_ICRQ: 1036 pptp_icrq_print(dat); 1037 break; 1038 case PPTP_CTRL_MSG_TYPE_ICRP: 1039 pptp_icrp_print(dat); 1040 break; 1041 case PPTP_CTRL_MSG_TYPE_ICCN: 1042 pptp_iccn_print(dat); 1043 break; 1044 case PPTP_CTRL_MSG_TYPE_CCRQ: 1045 pptp_ccrq_print(dat); 1046 break; 1047 case PPTP_CTRL_MSG_TYPE_CDN: 1048 pptp_cdn_print(dat); 1049 break; 1050 case PPTP_CTRL_MSG_TYPE_WEN: 1051 pptp_wen_print(dat); 1052 break; 1053 case PPTP_CTRL_MSG_TYPE_SLI: 1054 pptp_sli_print(dat); 1055 break; 1056 default: 1057 /* do nothing */ 1058 break; 1059 } 1060 1061 return; 1062 1063trunc: 1064 printf("%s", tstr); 1065} 1066