]> The Tcpdump Group git mirrors - tcpdump/blob - print-pptp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
protected osi_print_cksum is more general fashion
[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 }
[mirror] the TCPdump network dissector