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