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 /* \summary: Point-to-Point Tunnelling Protocol (PPTP) printer */
  25
  26 /* specification: RFC 2637 */
  27
  28 #include <config.h>
  29
  30 #include "netdissect-stdinc.h"
  31
  32 #include "netdissect.h"
  33 #include "extract.h"
  34
  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      /* Asynchronous */
  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         nd_uint16_t length;
  88         nd_uint16_t msg_type;
  89         nd_uint32_t magic_cookie;
  90         nd_uint16_t ctrl_msg_type;
  91         nd_uint16_t reserved0;
  92 };
  93
  94 struct pptp_msg_sccrq {
  95         nd_uint16_t proto_ver;
  96         nd_uint16_t reserved1;
  97         nd_uint32_t framing_cap;
  98         nd_uint32_t bearer_cap;
  99         nd_uint16_t max_channel;
 100         nd_uint16_t firm_rev;
 101         nd_byte     hostname[64];
 102         nd_byte     vendor[64];
 103 };
 104
 105 struct pptp_msg_sccrp {
 106         nd_uint16_t proto_ver;
 107         nd_uint8_t  result_code;
 108         nd_uint8_t  err_code;
 109         nd_uint32_t framing_cap;
 110         nd_uint32_t bearer_cap;
 111         nd_uint16_t max_channel;
 112         nd_uint16_t firm_rev;
 113         nd_byte     hostname[64];
 114         nd_byte     vendor[64];
 115 };
 116
 117 struct pptp_msg_stopccrq {
 118         nd_uint8_t  reason;
 119         nd_uint8_t  reserved1;
 120         nd_uint16_t reserved2;
 121 };
 122
 123 struct pptp_msg_stopccrp {
 124         nd_uint8_t  result_code;
 125         nd_uint8_t  err_code;
 126         nd_uint16_t reserved1;
 127 };
 128
 129 struct pptp_msg_echorq {
 130         nd_uint32_t id;
 131 };
 132
 133 struct pptp_msg_echorp {
 134         nd_uint32_t id;
 135         nd_uint8_t  result_code;
 136         nd_uint8_t  err_code;
 137         nd_uint16_t reserved1;
 138 };
 139
 140 struct pptp_msg_ocrq {
 141         nd_uint16_t call_id;
 142         nd_uint16_t call_ser;
 143         nd_uint32_t min_bps;
 144         nd_uint32_t max_bps;
 145         nd_uint32_t bearer_type;
 146         nd_uint32_t framing_type;
 147         nd_uint16_t recv_winsiz;
 148         nd_uint16_t pkt_proc_delay;
 149         nd_uint16_t phone_no_len;
 150         nd_uint16_t reserved1;
 151         nd_byte     phone_no[64];
 152         nd_byte     subaddr[64];
 153 };
 154
 155 struct pptp_msg_ocrp {
 156         nd_uint16_t call_id;
 157         nd_uint16_t peer_call_id;
 158         nd_uint8_t  result_code;
 159         nd_uint8_t  err_code;
 160         nd_uint16_t cause_code;
 161         nd_uint32_t conn_speed;
 162         nd_uint16_t recv_winsiz;
 163         nd_uint16_t pkt_proc_delay;
 164         nd_uint32_t phy_chan_id;
 165 };
 166
 167 struct pptp_msg_icrq {
 168         nd_uint16_t call_id;
 169         nd_uint16_t call_ser;
 170         nd_uint32_t bearer_type;
 171         nd_uint32_t phy_chan_id;
 172         nd_uint16_t dialed_no_len;
 173         nd_uint16_t dialing_no_len;
 174         nd_byte     dialed_no[64];              /* DNIS */
 175         nd_byte     dialing_no[64];             /* CLID */
 176         nd_byte     subaddr[64];
 177 };
 178
 179 struct pptp_msg_icrp {
 180         nd_uint16_t call_id;
 181         nd_uint16_t peer_call_id;
 182         nd_uint8_t  result_code;
 183         nd_uint8_t  err_code;
 184         nd_uint16_t recv_winsiz;
 185         nd_uint16_t pkt_proc_delay;
 186         nd_uint16_t reserved1;
 187 };
 188
 189 struct pptp_msg_iccn {
 190         nd_uint16_t peer_call_id;
 191         nd_uint16_t reserved1;
 192         nd_uint32_t conn_speed;
 193         nd_uint16_t recv_winsiz;
 194         nd_uint16_t pkt_proc_delay;
 195         nd_uint32_t framing_type;
 196 };
 197
 198 struct pptp_msg_ccrq {
 199         nd_uint16_t call_id;
 200         nd_uint16_t reserved1;
 201 };
 202
 203 struct pptp_msg_cdn {
 204         nd_uint16_t call_id;
 205         nd_uint8_t  result_code;
 206         nd_uint8_t  err_code;
 207         nd_uint16_t cause_code;
 208         nd_uint16_t reserved1;
 209         nd_byte     call_stats[128];
 210 };
 211
 212 struct pptp_msg_wen {
 213         nd_uint16_t peer_call_id;
 214         nd_uint16_t reserved1;
 215         nd_uint32_t crc_err;
 216         nd_uint32_t framing_err;
 217         nd_uint32_t hardware_overrun;
 218         nd_uint32_t buffer_overrun;
 219         nd_uint32_t timeout_err;
 220         nd_uint32_t align_err;
 221 };
 222
 223 struct pptp_msg_sli {
 224         nd_uint16_t peer_call_id;
 225         nd_uint16_t reserved1;
 226         nd_uint32_t send_accm;
 227         nd_uint32_t recv_accm;
 228 };
 229
 230 /* attributes that appear more than once in above messages:
 231
 232    Number of
 233    occurrence    attributes
 234   --------------------------------------
 235       2         uint32_t bearer_cap;
 236       2         uint32_t bearer_type;
 237       6         uint16_t call_id;
 238       2         uint16_t call_ser;
 239       2         uint16_t cause_code;
 240       2         uint32_t conn_speed;
 241       6         uint8_t err_code;
 242       2         uint16_t firm_rev;
 243       2         uint32_t framing_cap;
 244       2         uint32_t framing_type;
 245       2         u_char hostname[64];
 246       2         uint32_t id;
 247       2         uint16_t max_channel;
 248       5         uint16_t peer_call_id;
 249       2         uint32_t phy_chan_id;
 250       4         uint16_t pkt_proc_delay;
 251       2         uint16_t proto_ver;
 252       4         uint16_t recv_winsiz;
 253       2         uint8_t reserved1;
 254       9         uint16_t reserved1;
 255       6         uint8_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 #define PRINT_RESERVED_IF_NOT_ZERO_1(reserved) \
 264         if (GET_U_1(reserved)) \
 265                 ND_PRINT(" [ERROR: reserved=%u must be zero]", \
 266                          GET_U_1(reserved));
 267
 268 #define PRINT_RESERVED_IF_NOT_ZERO_2(reserved) \
 269         if (GET_BE_U_2(reserved)) \
 270                 ND_PRINT(" [ERROR: reserved=%u must be zero]", \
 271                          GET_BE_U_2(reserved));
 272
 273 /******************************************/
 274 /* Attribute-specific print out functions */
 275 /******************************************/
 276
 277 static void
 278 pptp_bearer_cap_print(netdissect_options *ndo,
 279                       const nd_uint32_t bearer_cap)
 280 {
 281         ND_PRINT(" BEARER_CAP(%s%s)",
 282                   GET_BE_U_4(bearer_cap) & PPTP_BEARER_CAP_DIGITAL_MASK ? "D" : "",
 283                   GET_BE_U_4(bearer_cap) & PPTP_BEARER_CAP_ANALOG_MASK ? "A" : "");
 284 }
 285
 286 static const struct tok pptp_btype_str[] = {
 287         { 1, "A"   }, /* Analog */
 288         { 2, "D"   }, /* Digital */
 289         { 3, "Any" },
 290         { 0, NULL }
 291 };
 292
 293 static void
 294 pptp_bearer_type_print(netdissect_options *ndo,
 295                        const nd_uint32_t bearer_type)
 296 {
 297         ND_PRINT(" BEARER_TYPE(%s)",
 298                   tok2str(pptp_btype_str, "?", GET_BE_U_4(bearer_type)));
 299 }
 300
 301 static void
 302 pptp_call_id_print(netdissect_options *ndo,
 303                    const nd_uint16_t call_id)
 304 {
 305         ND_PRINT(" CALL_ID(%u)", GET_BE_U_2(call_id));
 306 }
 307
 308 static void
 309 pptp_call_ser_print(netdissect_options *ndo,
 310                     const nd_uint16_t call_ser)
 311 {
 312         ND_PRINT(" CALL_SER_NUM(%u)", GET_BE_U_2(call_ser));
 313 }
 314
 315 static void
 316 pptp_cause_code_print(netdissect_options *ndo,
 317                       const nd_uint16_t cause_code)
 318 {
 319         ND_PRINT(" CAUSE_CODE(%u)", GET_BE_U_2(cause_code));
 320 }
 321
 322 static void
 323 pptp_conn_speed_print(netdissect_options *ndo,
 324                       const nd_uint32_t conn_speed)
 325 {
 326         ND_PRINT(" CONN_SPEED(%u)", GET_BE_U_4(conn_speed));
 327 }
 328
 329 static const struct tok pptp_errcode_str[] = {
 330         { 0, "None"          },
 331         { 1, "Not-Connected" },
 332         { 2, "Bad-Format"    },
 333         { 3, "Bad-Value"     },
 334         { 4, "No-Resource"   },
 335         { 5, "Bad-Call-ID"   },
 336         { 6, "PAC-Error"     },
 337         { 0, NULL }
 338 };
 339
 340 static void
 341 pptp_err_code_print(netdissect_options *ndo,
 342                     const nd_uint8_t err_code)
 343 {
 344         ND_PRINT(" ERR_CODE(%u", GET_U_1(err_code));
 345         if (ndo->ndo_vflag) {
 346                 ND_PRINT(":%s",
 347                          tok2str(pptp_errcode_str, "?", GET_U_1(err_code)));
 348         }
 349         ND_PRINT(")");
 350 }
 351
 352 static void
 353 pptp_firm_rev_print(netdissect_options *ndo,
 354                     const nd_uint16_t firm_rev)
 355 {
 356         ND_PRINT(" FIRM_REV(%u)", GET_BE_U_2(firm_rev));
 357 }
 358
 359 static void
 360 pptp_framing_cap_print(netdissect_options *ndo,
 361                        const nd_uint32_t framing_cap)
 362 {
 363         ND_PRINT(" FRAME_CAP(");
 364         if (GET_BE_U_4(framing_cap) & PPTP_FRAMING_CAP_ASYNC_MASK) {
 365                 ND_PRINT("A");          /* Async */
 366         }
 367         if (GET_BE_U_4(framing_cap) & PPTP_FRAMING_CAP_SYNC_MASK) {
 368                 ND_PRINT("S");          /* Sync */
 369         }
 370         ND_PRINT(")");
 371 }
 372
 373 static const struct tok pptp_ftype_str[] = {
 374         { 1, "A" }, /* Async */
 375         { 2, "S" }, /* Sync */
 376         { 3, "E" }, /* Either */
 377         { 0, NULL }
 378 };
 379
 380 static void
 381 pptp_framing_type_print(netdissect_options *ndo,
 382                         const nd_uint32_t framing_type)
 383 {
 384         ND_PRINT(" FRAME_TYPE(%s)",
 385                   tok2str(pptp_ftype_str, "?", GET_BE_U_4(framing_type)));
 386 }
 387
 388 static void
 389 pptp_hostname_print(netdissect_options *ndo,
 390                     const u_char *hostname)
 391 {
 392         ND_PRINT(" HOSTNAME(");
 393         nd_printjnp(ndo, hostname, 64);
 394         ND_PRINT(")");
 395 }
 396
 397 static void
 398 pptp_id_print(netdissect_options *ndo,
 399               const nd_uint32_t id)
 400 {
 401         ND_PRINT(" ID(%u)", GET_BE_U_4(id));
 402 }
 403
 404 static void
 405 pptp_max_channel_print(netdissect_options *ndo,
 406                        const nd_uint16_t max_channel)
 407 {
 408         ND_PRINT(" MAX_CHAN(%u)", GET_BE_U_2(max_channel));
 409 }
 410
 411 static void
 412 pptp_peer_call_id_print(netdissect_options *ndo,
 413                         const nd_uint16_t peer_call_id)
 414 {
 415         ND_PRINT(" PEER_CALL_ID(%u)", GET_BE_U_2(peer_call_id));
 416 }
 417
 418 static void
 419 pptp_phy_chan_id_print(netdissect_options *ndo,
 420                        const nd_uint32_t phy_chan_id)
 421 {
 422         ND_PRINT(" PHY_CHAN_ID(%u)", GET_BE_U_4(phy_chan_id));
 423 }
 424
 425 static void
 426 pptp_pkt_proc_delay_print(netdissect_options *ndo,
 427                           const nd_uint16_t pkt_proc_delay)
 428 {
 429         ND_PRINT(" PROC_DELAY(%u)", GET_BE_U_2(pkt_proc_delay));
 430 }
 431
 432 static void
 433 pptp_proto_ver_print(netdissect_options *ndo,
 434                      const nd_uint16_t proto_ver)
 435 {
 436         ND_PRINT(" PROTO_VER(%u.%u)",   /* Version.Revision */
 437                GET_BE_U_2(proto_ver) >> 8,
 438                GET_BE_U_2(proto_ver) & 0xff);
 439 }
 440
 441 static void
 442 pptp_recv_winsiz_print(netdissect_options *ndo,
 443                        const nd_uint16_t recv_winsiz)
 444 {
 445         ND_PRINT(" RECV_WIN(%u)", GET_BE_U_2(recv_winsiz));
 446 }
 447
 448 static const struct tok pptp_scrrp_str[] = {
 449         { 1, "Successful channel establishment"                           },
 450         { 2, "General error"                                              },
 451         { 3, "Command channel already exists"                             },
 452         { 4, "Requester is not authorized to establish a command channel" },
 453         { 5, "The protocol version of the requester is not supported"     },
 454         { 0, NULL }
 455 };
 456
 457 static const struct tok pptp_echorp_str[] = {
 458         { 1, "OK" },
 459         { 2, "General Error" },
 460         { 0, NULL }
 461 };
 462
 463 static const struct tok pptp_ocrp_str[] = {
 464         { 1, "Connected"     },
 465         { 2, "General Error" },
 466         { 3, "No Carrier"    },
 467         { 4, "Busy"          },
 468         { 5, "No Dial Tone"  },
 469         { 6, "Time-out"      },
 470         { 7, "Do Not Accept" },
 471         { 0, NULL }
 472 };
 473
 474 static const struct tok pptp_icrp_str[] = {
 475         { 1, "Connect"       },
 476         { 2, "General Error" },
 477         { 3, "Do Not Accept" },
 478         { 0, NULL }
 479 };
 480
 481 static const struct tok pptp_cdn_str[] = {
 482         { 1, "Lost Carrier"   },
 483         { 2, "General Error"  },
 484         { 3, "Admin Shutdown" },
 485         { 4, "Request"        },
 486         { 0, NULL }
 487 };
 488
 489 static void
 490 pptp_result_code_print(netdissect_options *ndo,
 491                        const nd_uint8_t result_code, int ctrl_msg_type)
 492 {
 493         ND_PRINT(" RESULT_CODE(%u", GET_U_1(result_code));
 494         if (ndo->ndo_vflag) {
 495                 const struct tok *dict =
 496                         ctrl_msg_type == PPTP_CTRL_MSG_TYPE_SCCRP    ? pptp_scrrp_str :
 497                         ctrl_msg_type == PPTP_CTRL_MSG_TYPE_StopCCRP ? pptp_echorp_str :
 498                         ctrl_msg_type == PPTP_CTRL_MSG_TYPE_ECHORP   ? pptp_echorp_str :
 499                         ctrl_msg_type == PPTP_CTRL_MSG_TYPE_OCRP     ? pptp_ocrp_str :
 500                         ctrl_msg_type == PPTP_CTRL_MSG_TYPE_ICRP     ? pptp_icrp_str :
 501                         ctrl_msg_type == PPTP_CTRL_MSG_TYPE_CDN      ? pptp_cdn_str :
 502                         NULL; /* assertion error */
 503                 if (dict != NULL)
 504                         ND_PRINT(":%s",
 505                                  tok2str(dict, "?", GET_U_1(result_code)));
 506         }
 507         ND_PRINT(")");
 508 }
 509
 510 static void
 511 pptp_subaddr_print(netdissect_options *ndo,
 512                    const u_char *subaddr)
 513 {
 514         ND_PRINT(" SUB_ADDR(");
 515         nd_printjnp(ndo, subaddr, 64);
 516         ND_PRINT(")");
 517 }
 518
 519 static void
 520 pptp_vendor_print(netdissect_options *ndo,
 521                   const u_char *vendor)
 522 {
 523         ND_PRINT(" VENDOR(");
 524         nd_printjnp(ndo, vendor, 64);
 525         ND_PRINT(")");
 526 }
 527
 528 /************************************/
 529 /* PPTP message print out functions */
 530 /************************************/
 531 static void
 532 pptp_sccrq_print(netdissect_options *ndo,
 533                  const u_char *dat)
 534 {
 535         const struct pptp_msg_sccrq *ptr = (const struct pptp_msg_sccrq *)dat;
 536
 537         pptp_proto_ver_print(ndo, ptr->proto_ver);
 538         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 539         pptp_framing_cap_print(ndo, ptr->framing_cap);
 540         pptp_bearer_cap_print(ndo, ptr->bearer_cap);
 541         pptp_max_channel_print(ndo, ptr->max_channel);
 542         pptp_firm_rev_print(ndo, ptr->firm_rev);
 543         pptp_hostname_print(ndo, ptr->hostname);
 544         pptp_vendor_print(ndo, ptr->vendor);
 545 }
 546
 547 static void
 548 pptp_sccrp_print(netdissect_options *ndo,
 549                  const u_char *dat)
 550 {
 551         const struct pptp_msg_sccrp *ptr = (const struct pptp_msg_sccrp *)dat;
 552
 553         pptp_proto_ver_print(ndo, ptr->proto_ver);
 554         pptp_result_code_print(ndo, ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP);
 555         pptp_err_code_print(ndo, ptr->err_code);
 556         pptp_framing_cap_print(ndo, ptr->framing_cap);
 557         pptp_bearer_cap_print(ndo, ptr->bearer_cap);
 558         pptp_max_channel_print(ndo, ptr->max_channel);
 559         pptp_firm_rev_print(ndo, ptr->firm_rev);
 560         pptp_hostname_print(ndo, ptr->hostname);
 561         pptp_vendor_print(ndo, ptr->vendor);
 562 }
 563
 564 static void
 565 pptp_stopccrq_print(netdissect_options *ndo,
 566                     const u_char *dat)
 567 {
 568         const struct pptp_msg_stopccrq *ptr = (const struct pptp_msg_stopccrq *)dat;
 569
 570         ND_PRINT(" REASON(%u", GET_U_1(ptr->reason));
 571         if (ndo->ndo_vflag) {
 572                 switch (GET_U_1(ptr->reason)) {
 573                 case 1:
 574                         ND_PRINT(":None");
 575                         break;
 576                 case 2:
 577                         ND_PRINT(":Stop-Protocol");
 578                         break;
 579                 case 3:
 580                         ND_PRINT(":Stop-Local-Shutdown");
 581                         break;
 582                 default:
 583                         ND_PRINT(":?");
 584                         break;
 585                 }
 586         }
 587         ND_PRINT(")");
 588         PRINT_RESERVED_IF_NOT_ZERO_1(ptr->reserved1);
 589         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved2);
 590 }
 591
 592 static void
 593 pptp_stopccrp_print(netdissect_options *ndo,
 594                     const u_char *dat)
 595 {
 596         const struct pptp_msg_stopccrp *ptr = (const struct pptp_msg_stopccrp *)dat;
 597
 598         pptp_result_code_print(ndo, ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP);
 599         pptp_err_code_print(ndo, ptr->err_code);
 600         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 601 }
 602
 603 static void
 604 pptp_echorq_print(netdissect_options *ndo,
 605                   const u_char *dat)
 606 {
 607         const struct pptp_msg_echorq *ptr = (const struct pptp_msg_echorq *)dat;
 608
 609         pptp_id_print(ndo, ptr->id);
 610 }
 611
 612 static void
 613 pptp_echorp_print(netdissect_options *ndo,
 614                   const u_char *dat)
 615 {
 616         const struct pptp_msg_echorp *ptr = (const struct pptp_msg_echorp *)dat;
 617
 618         pptp_id_print(ndo, ptr->id);
 619         pptp_result_code_print(ndo, ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP);
 620         pptp_err_code_print(ndo, ptr->err_code);
 621         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 622 }
 623
 624 static void
 625 pptp_ocrq_print(netdissect_options *ndo,
 626                 const u_char *dat)
 627 {
 628         const struct pptp_msg_ocrq *ptr = (const struct pptp_msg_ocrq *)dat;
 629
 630         pptp_call_id_print(ndo, ptr->call_id);
 631         pptp_call_ser_print(ndo, ptr->call_ser);
 632         ND_PRINT(" MIN_BPS(%u)", GET_BE_U_4(ptr->min_bps));
 633         ND_PRINT(" MAX_BPS(%u)", GET_BE_U_4(ptr->max_bps));
 634         pptp_bearer_type_print(ndo, ptr->bearer_type);
 635         pptp_framing_type_print(ndo, ptr->framing_type);
 636         pptp_recv_winsiz_print(ndo, ptr->recv_winsiz);
 637         pptp_pkt_proc_delay_print(ndo, ptr->pkt_proc_delay);
 638         ND_PRINT(" PHONE_NO_LEN(%u)", GET_BE_U_2(ptr->phone_no_len));
 639         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 640         ND_PRINT(" PHONE_NO(");
 641         nd_printjnp(ndo, ptr->phone_no,
 642                     ND_MIN(64, GET_BE_U_2(ptr->phone_no_len)));
 643         ND_PRINT(")");
 644         pptp_subaddr_print(ndo, ptr->subaddr);
 645 }
 646
 647 static void
 648 pptp_ocrp_print(netdissect_options *ndo,
 649                 const u_char *dat)
 650 {
 651         const struct pptp_msg_ocrp *ptr = (const struct pptp_msg_ocrp *)dat;
 652
 653         pptp_call_id_print(ndo, ptr->call_id);
 654         pptp_peer_call_id_print(ndo, ptr->peer_call_id);
 655         pptp_result_code_print(ndo, ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP);
 656         pptp_err_code_print(ndo, ptr->err_code);
 657         pptp_cause_code_print(ndo, ptr->cause_code);
 658         pptp_conn_speed_print(ndo, ptr->conn_speed);
 659         pptp_recv_winsiz_print(ndo, ptr->recv_winsiz);
 660         pptp_pkt_proc_delay_print(ndo, ptr->pkt_proc_delay);
 661         pptp_phy_chan_id_print(ndo, ptr->phy_chan_id);
 662 }
 663
 664 static void
 665 pptp_icrq_print(netdissect_options *ndo,
 666                 const u_char *dat)
 667 {
 668         const struct pptp_msg_icrq *ptr = (const struct pptp_msg_icrq *)dat;
 669
 670         pptp_call_id_print(ndo, ptr->call_id);
 671         pptp_call_ser_print(ndo, ptr->call_ser);
 672         pptp_bearer_type_print(ndo, ptr->bearer_type);
 673         pptp_phy_chan_id_print(ndo, ptr->phy_chan_id);
 674         ND_PRINT(" DIALED_NO_LEN(%u)", GET_BE_U_2(ptr->dialed_no_len));
 675         ND_PRINT(" DIALING_NO_LEN(%u)", GET_BE_U_2(ptr->dialing_no_len));
 676         ND_PRINT(" DIALED_NO(");
 677         nd_printjnp(ndo, ptr->dialed_no,
 678                     ND_MIN(64, GET_BE_U_2(ptr->dialed_no_len)));
 679         ND_PRINT(")");
 680         ND_PRINT(" DIALING_NO(");
 681         nd_printjnp(ndo, ptr->dialing_no,
 682                     ND_MIN(64, GET_BE_U_2(ptr->dialing_no_len)));
 683         ND_PRINT(")");
 684         pptp_subaddr_print(ndo, ptr->subaddr);
 685 }
 686
 687 static void
 688 pptp_icrp_print(netdissect_options *ndo,
 689                 const u_char *dat)
 690 {
 691         const struct pptp_msg_icrp *ptr = (const struct pptp_msg_icrp *)dat;
 692
 693         pptp_call_id_print(ndo, ptr->call_id);
 694         pptp_peer_call_id_print(ndo, ptr->peer_call_id);
 695         pptp_result_code_print(ndo, ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP);
 696         pptp_err_code_print(ndo, ptr->err_code);
 697         pptp_recv_winsiz_print(ndo, ptr->recv_winsiz);
 698         pptp_pkt_proc_delay_print(ndo, ptr->pkt_proc_delay);
 699         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 700 }
 701
 702 static void
 703 pptp_iccn_print(netdissect_options *ndo,
 704                 const u_char *dat)
 705 {
 706         const struct pptp_msg_iccn *ptr = (const struct pptp_msg_iccn *)dat;
 707
 708         pptp_peer_call_id_print(ndo, ptr->peer_call_id);
 709         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 710         pptp_conn_speed_print(ndo, ptr->conn_speed);
 711         pptp_recv_winsiz_print(ndo, ptr->recv_winsiz);
 712         pptp_pkt_proc_delay_print(ndo, ptr->pkt_proc_delay);
 713         pptp_framing_type_print(ndo, ptr->framing_type);
 714 }
 715
 716 static void
 717 pptp_ccrq_print(netdissect_options *ndo,
 718                 const u_char *dat)
 719 {
 720         const struct pptp_msg_ccrq *ptr = (const struct pptp_msg_ccrq *)dat;
 721
 722         pptp_call_id_print(ndo, ptr->call_id);
 723         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 724 }
 725
 726 static void
 727 pptp_cdn_print(netdissect_options *ndo,
 728                const u_char *dat)
 729 {
 730         const struct pptp_msg_cdn *ptr = (const struct pptp_msg_cdn *)dat;
 731
 732         pptp_call_id_print(ndo, ptr->call_id);
 733         pptp_result_code_print(ndo, ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN);
 734         pptp_err_code_print(ndo, ptr->err_code);
 735         pptp_cause_code_print(ndo, ptr->cause_code);
 736         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 737         ND_PRINT(" CALL_STATS(");
 738         nd_printjnp(ndo, ptr->call_stats, 128);
 739         ND_PRINT(")");
 740 }
 741
 742 static void
 743 pptp_wen_print(netdissect_options *ndo,
 744                const u_char *dat)
 745 {
 746         const struct pptp_msg_wen *ptr = (const struct pptp_msg_wen *)dat;
 747
 748         pptp_peer_call_id_print(ndo, ptr->peer_call_id);
 749         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 750         ND_PRINT(" CRC_ERR(%u)", GET_BE_U_4(ptr->crc_err));
 751         ND_PRINT(" FRAMING_ERR(%u)", GET_BE_U_4(ptr->framing_err));
 752         ND_PRINT(" HARDWARE_OVERRUN(%u)", GET_BE_U_4(ptr->hardware_overrun));
 753         ND_PRINT(" BUFFER_OVERRUN(%u)", GET_BE_U_4(ptr->buffer_overrun));
 754         ND_PRINT(" TIMEOUT_ERR(%u)", GET_BE_U_4(ptr->timeout_err));
 755         ND_PRINT(" ALIGN_ERR(%u)", GET_BE_U_4(ptr->align_err));
 756 }
 757
 758 static void
 759 pptp_sli_print(netdissect_options *ndo,
 760                const u_char *dat)
 761 {
 762         const struct pptp_msg_sli *ptr = (const struct pptp_msg_sli *)dat;
 763
 764         pptp_peer_call_id_print(ndo, ptr->peer_call_id);
 765         PRINT_RESERVED_IF_NOT_ZERO_2(ptr->reserved1);
 766         ND_PRINT(" SEND_ACCM(0x%08x)", GET_BE_U_4(ptr->send_accm));
 767         ND_PRINT(" RECV_ACCM(0x%08x)", GET_BE_U_4(ptr->recv_accm));
 768 }
 769
 770 void
 771 pptp_print(netdissect_options *ndo,
 772            const u_char *dat)
 773 {
 774         const struct pptp_hdr *hdr;
 775         uint32_t mc;
 776         uint16_t ctrl_msg_type;
 777
 778         ndo->ndo_protocol = "pptp";
 779         ND_PRINT(": ");
 780         nd_print_protocol(ndo);
 781
 782         hdr = (const struct pptp_hdr *)dat;
 783
 784         if (ndo->ndo_vflag) {
 785                 ND_PRINT(" Length=%u", GET_BE_U_2(hdr->length));
 786         }
 787         if (ndo->ndo_vflag) {
 788                 switch(GET_BE_U_2(hdr->msg_type)) {
 789                 case PPTP_MSG_TYPE_CTRL:
 790                         ND_PRINT(" CTRL-MSG");
 791                         break;
 792                 case PPTP_MSG_TYPE_MGMT:
 793                         ND_PRINT(" MGMT-MSG");
 794                         break;
 795                 default:
 796                         ND_PRINT(" UNKNOWN-MSG-TYPE");
 797                         break;
 798                 }
 799         }
 800
 801         mc = GET_BE_U_4(hdr->magic_cookie);
 802         if (mc != PPTP_MAGIC_COOKIE) {
 803                 ND_PRINT(" UNEXPECTED Magic-Cookie!!(%08x)", mc);
 804         }
 805         if (ndo->ndo_vflag || mc != PPTP_MAGIC_COOKIE) {
 806                 ND_PRINT(" Magic-Cookie=%08x", mc);
 807         }
 808         ctrl_msg_type = GET_BE_U_2(hdr->ctrl_msg_type);
 809         if (ctrl_msg_type < PPTP_MAX_MSGTYPE_INDEX) {
 810                 ND_PRINT(" CTRL_MSGTYPE=%s",
 811                        pptp_message_type_string[ctrl_msg_type]);
 812         } else {
 813                 ND_PRINT(" UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type);
 814         }
 815         PRINT_RESERVED_IF_NOT_ZERO_2(hdr->reserved0);
 816
 817         dat += 12;
 818
 819         switch(ctrl_msg_type) {
 820         case PPTP_CTRL_MSG_TYPE_SCCRQ:
 821                 pptp_sccrq_print(ndo, dat);
 822                 break;
 823         case PPTP_CTRL_MSG_TYPE_SCCRP:
 824                 pptp_sccrp_print(ndo, dat);
 825                 break;
 826         case PPTP_CTRL_MSG_TYPE_StopCCRQ:
 827                 pptp_stopccrq_print(ndo, dat);
 828                 break;
 829         case PPTP_CTRL_MSG_TYPE_StopCCRP:
 830                 pptp_stopccrp_print(ndo, dat);
 831                 break;
 832         case PPTP_CTRL_MSG_TYPE_ECHORQ:
 833                 pptp_echorq_print(ndo, dat);
 834                 break;
 835         case PPTP_CTRL_MSG_TYPE_ECHORP:
 836                 pptp_echorp_print(ndo, dat);
 837                 break;
 838         case PPTP_CTRL_MSG_TYPE_OCRQ:
 839                 pptp_ocrq_print(ndo, dat);
 840                 break;
 841         case PPTP_CTRL_MSG_TYPE_OCRP:
 842                 pptp_ocrp_print(ndo, dat);
 843                 break;
 844         case PPTP_CTRL_MSG_TYPE_ICRQ:
 845                 pptp_icrq_print(ndo, dat);
 846                 break;
 847         case PPTP_CTRL_MSG_TYPE_ICRP:
 848                 pptp_icrp_print(ndo, dat);
 849                 break;
 850         case PPTP_CTRL_MSG_TYPE_ICCN:
 851                 pptp_iccn_print(ndo, dat);
 852                 break;
 853         case PPTP_CTRL_MSG_TYPE_CCRQ:
 854                 pptp_ccrq_print(ndo, dat);
 855                 break;
 856         case PPTP_CTRL_MSG_TYPE_CDN:
 857                 pptp_cdn_print(ndo, dat);
 858                 break;
 859         case PPTP_CTRL_MSG_TYPE_WEN:
 860                 pptp_wen_print(ndo, dat);
 861                 break;
 862         case PPTP_CTRL_MSG_TYPE_SLI:
 863                 pptp_sli_print(ndo, dat);
 864                 break;
 865         default:
 866                 /* do nothing */
 867                 break;
 868         }
 869 }