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