The Tcpdump Group git mirrors - tcpdump/blob - print-pptp.c

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