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