]> The Tcpdump Group git mirrors - tcpdump/blob - print-pptp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
print-pptp: add a missing break
[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 break;
555 default:
556 printf(":?");
557 break;
558 }
559 break;
560 default:
561 /* assertion error */
562 break;
563 }
564 }
565 printf(")");
566 }
567
568 static void
569 pptp_subaddr_print(const u_char *subaddr)
570 {
571 printf(" SUB_ADDR(%.64s)", subaddr);
572 }
573
574 static void
575 pptp_vendor_print(const u_char *vendor)
576 {
577 printf(" VENDOR(%.64s)", vendor);
578 }
579
580 /************************************/
581 /* PPTP message print out functions */
582 /************************************/
583 static void
584 pptp_sccrq_print(const u_char *dat)
585 {
586 struct pptp_msg_sccrq *ptr = (struct pptp_msg_sccrq *)dat;
587
588 TCHECK(ptr->proto_ver);
589 pptp_proto_ver_print(&ptr->proto_ver);
590 TCHECK(ptr->reserved1);
591 TCHECK(ptr->framing_cap);
592 pptp_framing_cap_print(&ptr->framing_cap);
593 TCHECK(ptr->bearer_cap);
594 pptp_bearer_cap_print(&ptr->bearer_cap);
595 TCHECK(ptr->max_channel);
596 pptp_max_channel_print(&ptr->max_channel);
597 TCHECK(ptr->firm_rev);
598 pptp_firm_rev_print(&ptr->firm_rev);
599 TCHECK(ptr->hostname);
600 pptp_hostname_print(&ptr->hostname[0]);
601 TCHECK(ptr->vendor);
602 pptp_vendor_print(&ptr->vendor[0]);
603
604 return;
605
606 trunc:
607 printf("%s", tstr);
608 }
609
610 static void
611 pptp_sccrp_print(const u_char *dat)
612 {
613 struct pptp_msg_sccrp *ptr = (struct pptp_msg_sccrp *)dat;
614
615 TCHECK(ptr->proto_ver);
616 pptp_proto_ver_print(&ptr->proto_ver);
617 TCHECK(ptr->result_code);
618 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_SCCRP);
619 TCHECK(ptr->err_code);
620 pptp_err_code_print(&ptr->err_code);
621 TCHECK(ptr->framing_cap);
622 pptp_framing_cap_print(&ptr->framing_cap);
623 TCHECK(ptr->bearer_cap);
624 pptp_bearer_cap_print(&ptr->bearer_cap);
625 TCHECK(ptr->max_channel);
626 pptp_max_channel_print(&ptr->max_channel);
627 TCHECK(ptr->firm_rev);
628 pptp_firm_rev_print(&ptr->firm_rev);
629 TCHECK(ptr->hostname);
630 pptp_hostname_print(&ptr->hostname[0]);
631 TCHECK(ptr->vendor);
632 pptp_vendor_print(&ptr->vendor[0]);
633
634 return;
635
636 trunc:
637 printf("%s", tstr);
638 }
639
640 static void
641 pptp_stopccrq_print(const u_char *dat)
642 {
643 struct pptp_msg_stopccrq *ptr = (struct pptp_msg_stopccrq *)dat;
644
645 TCHECK(ptr->reason);
646 printf(" REASON(%u", ptr->reason);
647 if (vflag) {
648 switch (ptr->reason) {
649 case 1:
650 printf(":None");
651 break;
652 case 2:
653 printf(":Stop-Protocol");
654 break;
655 case 3:
656 printf(":Stop-Local-Shutdown");
657 break;
658 default:
659 printf(":?");
660 break;
661 }
662 }
663 printf(")");
664 TCHECK(ptr->reserved1);
665 TCHECK(ptr->reserved2);
666
667 return;
668
669 trunc:
670 printf("%s", tstr);
671 }
672
673 static void
674 pptp_stopccrp_print(const u_char *dat)
675 {
676 struct pptp_msg_stopccrp *ptr = (struct pptp_msg_stopccrp *)dat;
677
678 TCHECK(ptr->result_code);
679 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_StopCCRP);
680 TCHECK(ptr->err_code);
681 pptp_err_code_print(&ptr->err_code);
682 TCHECK(ptr->reserved1);
683
684 return;
685
686 trunc:
687 printf("%s", tstr);
688 }
689
690 static void
691 pptp_echorq_print(const u_char *dat)
692 {
693 struct pptp_msg_echorq *ptr = (struct pptp_msg_echorq *)dat;
694
695 TCHECK(ptr->id);
696 pptp_id_print(&ptr->id);
697
698 return;
699
700 trunc:
701 printf("%s", tstr);
702 }
703
704 static void
705 pptp_echorp_print(const u_char *dat)
706 {
707 struct pptp_msg_echorp *ptr = (struct pptp_msg_echorp *)dat;
708
709 TCHECK(ptr->id);
710 pptp_id_print(&ptr->id);
711 TCHECK(ptr->result_code);
712 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ECHORP);
713 TCHECK(ptr->err_code);
714 pptp_err_code_print(&ptr->err_code);
715 TCHECK(ptr->reserved1);
716
717 return;
718
719 trunc:
720 printf("%s", tstr);
721 }
722
723 static void
724 pptp_ocrq_print(const u_char *dat)
725 {
726 struct pptp_msg_ocrq *ptr = (struct pptp_msg_ocrq *)dat;
727
728 TCHECK(ptr->call_id);
729 pptp_call_id_print(&ptr->call_id);
730 TCHECK(ptr->call_ser);
731 pptp_call_ser_print(&ptr->call_ser);
732 TCHECK(ptr->min_bps);
733 printf(" MIN_BPS(%u)", EXTRACT_32BITS(&ptr->min_bps));
734 TCHECK(ptr->max_bps);
735 printf(" MAX_BPS(%u)", EXTRACT_32BITS(&ptr->max_bps));
736 TCHECK(ptr->bearer_type);
737 pptp_bearer_type_print(&ptr->bearer_type);
738 TCHECK(ptr->framing_type);
739 pptp_framing_type_print(&ptr->framing_type);
740 TCHECK(ptr->recv_winsiz);
741 pptp_recv_winsiz_print(&ptr->recv_winsiz);
742 TCHECK(ptr->pkt_proc_delay);
743 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);
744 TCHECK(ptr->phone_no_len);
745 printf(" PHONE_NO_LEN(%u)", EXTRACT_16BITS(&ptr->phone_no_len));
746 TCHECK(ptr->reserved1);
747 TCHECK(ptr->phone_no);
748 printf(" PHONE_NO(%.64s)", ptr->phone_no);
749 TCHECK(ptr->subaddr);
750 pptp_subaddr_print(&ptr->subaddr[0]);
751
752 return;
753
754 trunc:
755 printf("%s", tstr);
756 }
757
758 static void
759 pptp_ocrp_print(const u_char *dat)
760 {
761 struct pptp_msg_ocrp *ptr = (struct pptp_msg_ocrp *)dat;
762
763 TCHECK(ptr->call_id);
764 pptp_call_id_print(&ptr->call_id);
765 TCHECK(ptr->peer_call_id);
766 pptp_peer_call_id_print(&ptr->peer_call_id);
767 TCHECK(ptr->result_code);
768 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_OCRP);
769 TCHECK(ptr->err_code);
770 pptp_err_code_print(&ptr->err_code);
771 TCHECK(ptr->cause_code);
772 pptp_cause_code_print(&ptr->cause_code);
773 TCHECK(ptr->conn_speed);
774 pptp_conn_speed_print(&ptr->conn_speed);
775 TCHECK(ptr->recv_winsiz);
776 pptp_recv_winsiz_print(&ptr->recv_winsiz);
777 TCHECK(ptr->pkt_proc_delay);
778 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);
779 TCHECK(ptr->phy_chan_id);
780 pptp_phy_chan_id_print(&ptr->phy_chan_id);
781
782 return;
783
784 trunc:
785 printf("%s", tstr);
786 }
787
788 static void
789 pptp_icrq_print(const u_char *dat)
790 {
791 struct pptp_msg_icrq *ptr = (struct pptp_msg_icrq *)dat;
792
793 TCHECK(ptr->call_id);
794 pptp_call_id_print(&ptr->call_id);
795 TCHECK(ptr->call_ser);
796 pptp_call_ser_print(&ptr->call_ser);
797 TCHECK(ptr->bearer_type);
798 pptp_bearer_type_print(&ptr->bearer_type);
799 TCHECK(ptr->phy_chan_id);
800 pptp_phy_chan_id_print(&ptr->phy_chan_id);
801 TCHECK(ptr->dialed_no_len);
802 printf(" DIALED_NO_LEN(%u)", EXTRACT_16BITS(&ptr->dialed_no_len));
803 TCHECK(ptr->dialing_no_len);
804 printf(" DIALING_NO_LEN(%u)", EXTRACT_16BITS(&ptr->dialing_no_len));
805 TCHECK(ptr->dialed_no);
806 printf(" DIALED_NO(%.64s)", ptr->dialed_no);
807 TCHECK(ptr->dialing_no);
808 printf(" DIALING_NO(%.64s)", ptr->dialing_no);
809 TCHECK(ptr->subaddr);
810 pptp_subaddr_print(&ptr->subaddr[0]);
811
812 return;
813
814 trunc:
815 printf("%s", tstr);
816 }
817
818 static void
819 pptp_icrp_print(const u_char *dat)
820 {
821 struct pptp_msg_icrp *ptr = (struct pptp_msg_icrp *)dat;
822
823 TCHECK(ptr->call_id);
824 pptp_call_id_print(&ptr->call_id);
825 TCHECK(ptr->peer_call_id);
826 pptp_peer_call_id_print(&ptr->peer_call_id);
827 TCHECK(ptr->result_code);
828 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_ICRP);
829 TCHECK(ptr->err_code);
830 pptp_err_code_print(&ptr->err_code);
831 TCHECK(ptr->recv_winsiz);
832 pptp_recv_winsiz_print(&ptr->recv_winsiz);
833 TCHECK(ptr->pkt_proc_delay);
834 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);
835 TCHECK(ptr->reserved1);
836
837 return;
838
839 trunc:
840 printf("%s", tstr);
841 }
842
843 static void
844 pptp_iccn_print(const u_char *dat)
845 {
846 struct pptp_msg_iccn *ptr = (struct pptp_msg_iccn *)dat;
847
848 TCHECK(ptr->peer_call_id);
849 pptp_peer_call_id_print(&ptr->peer_call_id);
850 TCHECK(ptr->reserved1);
851 TCHECK(ptr->conn_speed);
852 pptp_conn_speed_print(&ptr->conn_speed);
853 TCHECK(ptr->recv_winsiz);
854 pptp_recv_winsiz_print(&ptr->recv_winsiz);
855 TCHECK(ptr->pkt_proc_delay);
856 pptp_pkt_proc_delay_print(&ptr->pkt_proc_delay);
857 TCHECK(ptr->framing_type);
858 pptp_framing_type_print(&ptr->framing_type);
859
860 return;
861
862 trunc:
863 printf("%s", tstr);
864 }
865
866 static void
867 pptp_ccrq_print(const u_char *dat)
868 {
869 struct pptp_msg_ccrq *ptr = (struct pptp_msg_ccrq *)dat;
870
871 TCHECK(ptr->call_id);
872 pptp_call_id_print(&ptr->call_id);
873 TCHECK(ptr->reserved1);
874
875 return;
876
877 trunc:
878 printf("%s", tstr);
879 }
880
881 static void
882 pptp_cdn_print(const u_char *dat)
883 {
884 struct pptp_msg_cdn *ptr = (struct pptp_msg_cdn *)dat;
885
886 TCHECK(ptr->call_id);
887 pptp_call_id_print(&ptr->call_id);
888 TCHECK(ptr->result_code);
889 pptp_result_code_print(&ptr->result_code, PPTP_CTRL_MSG_TYPE_CDN);
890 TCHECK(ptr->err_code);
891 pptp_err_code_print(&ptr->err_code);
892 TCHECK(ptr->cause_code);
893 pptp_cause_code_print(&ptr->cause_code);
894 TCHECK(ptr->reserved1);
895 TCHECK(ptr->call_stats);
896 printf(" CALL_STATS(%.128s)", ptr->call_stats);
897
898 return;
899
900 trunc:
901 printf("%s", tstr);
902 }
903
904 static void
905 pptp_wen_print(const u_char *dat)
906 {
907 struct pptp_msg_wen *ptr = (struct pptp_msg_wen *)dat;
908
909 TCHECK(ptr->peer_call_id);
910 pptp_peer_call_id_print(&ptr->peer_call_id);
911 TCHECK(ptr->reserved1);
912 TCHECK(ptr->crc_err);
913 printf(" CRC_ERR(%u)", EXTRACT_32BITS(&ptr->crc_err));
914 TCHECK(ptr->framing_err);
915 printf(" FRAMING_ERR(%u)", EXTRACT_32BITS(&ptr->framing_err));
916 TCHECK(ptr->hardware_overrun);
917 printf(" HARDWARE_OVERRUN(%u)", EXTRACT_32BITS(&ptr->hardware_overrun));
918 TCHECK(ptr->buffer_overrun);
919 printf(" BUFFER_OVERRUN(%u)", EXTRACT_32BITS(&ptr->buffer_overrun));
920 TCHECK(ptr->timeout_err);
921 printf(" TIMEOUT_ERR(%u)", EXTRACT_32BITS(&ptr->timeout_err));
922 TCHECK(ptr->align_err);
923 printf(" ALIGN_ERR(%u)", EXTRACT_32BITS(&ptr->align_err));
924
925 return;
926
927 trunc:
928 printf("%s", tstr);
929 }
930
931 static void
932 pptp_sli_print(const u_char *dat)
933 {
934 struct pptp_msg_sli *ptr = (struct pptp_msg_sli *)dat;
935
936 TCHECK(ptr->peer_call_id);
937 pptp_peer_call_id_print(&ptr->peer_call_id);
938 TCHECK(ptr->reserved1);
939 TCHECK(ptr->send_accm);
940 printf(" SEND_ACCM(0x%08x)", EXTRACT_32BITS(&ptr->send_accm));
941 TCHECK(ptr->recv_accm);
942 printf(" RECV_ACCM(0x%08x)", EXTRACT_32BITS(&ptr->recv_accm));
943
944 return;
945
946 trunc:
947 printf("%s", tstr);
948 }
949
950 void
951 pptp_print(const u_char *dat)
952 {
953 const struct pptp_hdr *hdr;
954 u_int32_t mc;
955 u_int16_t ctrl_msg_type;
956
957 printf(": pptp");
958
959 hdr = (struct pptp_hdr *)dat;
960
961 TCHECK(hdr->length);
962 if (vflag) {
963 printf(" Length=%u", EXTRACT_16BITS(&hdr->length));
964 }
965 TCHECK(hdr->msg_type);
966 if (vflag) {
967 switch(EXTRACT_16BITS(&hdr->msg_type)) {
968 case PPTP_MSG_TYPE_CTRL:
969 printf(" CTRL-MSG");
970 break;
971 case PPTP_MSG_TYPE_MGMT:
972 printf(" MGMT-MSG");
973 break;
974 default:
975 printf(" UNKNOWN-MSG-TYPE");
976 break;
977 }
978 }
979
980 TCHECK(hdr->magic_cookie);
981 mc = EXTRACT_32BITS(&hdr->magic_cookie);
982 if (mc != PPTP_MAGIC_COOKIE) {
983 printf(" UNEXPECTED Magic-Cookie!!(%08x)", mc);
984 }
985 if (vflag || mc != PPTP_MAGIC_COOKIE) {
986 printf(" Magic-Cookie=%08x", mc);
987 }
988 TCHECK(hdr->ctrl_msg_type);
989 ctrl_msg_type = EXTRACT_16BITS(&hdr->ctrl_msg_type);
990 if (ctrl_msg_type < PPTP_MAX_MSGTYPE_INDEX) {
991 printf(" CTRL_MSGTYPE=%s",
992 pptp_message_type_string[ctrl_msg_type]);
993 } else {
994 printf(" UNKNOWN_CTRL_MSGTYPE(%u)", ctrl_msg_type);
995 }
996 TCHECK(hdr->reserved0);
997
998 dat += 12;
999
1000 switch(ctrl_msg_type) {
1001 case PPTP_CTRL_MSG_TYPE_SCCRQ:
1002 pptp_sccrq_print(dat);
1003 break;
1004 case PPTP_CTRL_MSG_TYPE_SCCRP:
1005 pptp_sccrp_print(dat);
1006 break;
1007 case PPTP_CTRL_MSG_TYPE_StopCCRQ:
1008 pptp_stopccrq_print(dat);
1009 break;
1010 case PPTP_CTRL_MSG_TYPE_StopCCRP:
1011 pptp_stopccrp_print(dat);
1012 break;
1013 case PPTP_CTRL_MSG_TYPE_ECHORQ:
1014 pptp_echorq_print(dat);
1015 break;
1016 case PPTP_CTRL_MSG_TYPE_ECHORP:
1017 pptp_echorp_print(dat);
1018 break;
1019 case PPTP_CTRL_MSG_TYPE_OCRQ:
1020 pptp_ocrq_print(dat);
1021 break;
1022 case PPTP_CTRL_MSG_TYPE_OCRP:
1023 pptp_ocrp_print(dat);
1024 break;
1025 case PPTP_CTRL_MSG_TYPE_ICRQ:
1026 pptp_icrq_print(dat);
1027 break;
1028 case PPTP_CTRL_MSG_TYPE_ICRP:
1029 pptp_icrp_print(dat);
1030 break;
1031 case PPTP_CTRL_MSG_TYPE_ICCN:
1032 pptp_iccn_print(dat);
1033 break;
1034 case PPTP_CTRL_MSG_TYPE_CCRQ:
1035 pptp_ccrq_print(dat);
1036 break;
1037 case PPTP_CTRL_MSG_TYPE_CDN:
1038 pptp_cdn_print(dat);
1039 break;
1040 case PPTP_CTRL_MSG_TYPE_WEN:
1041 pptp_wen_print(dat);
1042 break;
1043 case PPTP_CTRL_MSG_TYPE_SLI:
1044 pptp_sli_print(dat);
1045 break;
1046 default:
1047 /* do nothing */
1048 break;
1049 }
1050
1051 return;
1052
1053 trunc:
1054 printf("%s", tstr);
1055 }
[mirror] the TCPdump network dissector