]> The Tcpdump Group git mirrors - tcpdump/blob - print-l2tp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
updates/bug fixes from Motonori Shindo <[email protected]>
[tcpdump] / print-l2tp.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 * L2TP support contributed by Motonori Shindo (mshindo@mshindo.net)
22 */
23
24 #ifndef lint
25 static const char rcsid[] =
26 "@(#) $Header: /tcpdump/master/tcpdump/print-l2tp.c,v 1.7 2000-07-01 03:48:44 assar Exp $";
27 #endif
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include <stdio.h>
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <netinet/in.h>
37 #include <arpa/inet.h>
38
39 #include "l2tp.h"
40 #include "interface.h"
41
42 static char tstr[] = " [|l2tp]";
43
44 #ifndef TRUE
45 #define TRUE 1
46 #endif
47
48 #ifndef FALSE
49 #define FALSE 0
50 #endif
51
52 static char *l2tp_message_type_string[] = {
53 "RESERVED_0", /* 0 Reserved */
54 "SCCRQ", /* 1 Start-Control-Connection-Request */
55 "SCCRP", /* 2 Start-Control-Connection-Reply */
56 "SCCCN", /* 3 Start-Control-Connection-Connected */
57 "StopCCN", /* 4 Stop-Control-Connection-Notification */
58 "RESERVED_5", /* 5 Reserved */
59 "HELLO", /* 6 Hello */
60 "OCRQ", /* 7 Outgoing-Call-Request */
61 "OCRP", /* 8 Outgoing-Call-Reply */
62 "OCCN", /* 9 Outgoing-Call-Connected */
63 "ICRQ", /* 10 Incoming-Call-Request */
64 "ICRP", /* 11 Incoming-Call-Reply */
65 "ICCN", /* 12 Incoming-Call-Connected */
66 "RESERVED_13", /* 13 Reserved */
67 "CDN", /* 14 Call-Disconnect-Notify */
68 "WEN", /* 15 WAN-Error-Notify */
69 "SLI" /* 16 Set-Link-Info */
70 #define L2TP_MAX_MSGTYPE_INDEX 17
71 };
72
73 static void l2tp_msgtype_print(const u_char *dat, u_int length);
74 static void l2tp_result_code_print(const u_char *dat, u_int length);
75 static void l2tp_proto_ver_print(const u_char *dat, u_int length);
76 static void l2tp_framing_cap_print(const u_char *dat, u_int length);
77 static void l2tp_bearer_cap_print(const u_char *dat, u_int length);
78 static void l2tp_tie_breaker_print(const u_char *dat, u_int length);
79 static void l2tp_firm_ver_print(const u_char *dat, u_int length);
80 static void l2tp_host_name_print(const u_char *dat, u_int length);
81 static void l2tp_vendor_name_print(const u_char *dat, u_int length);
82 static void l2tp_assnd_tun_id_print(const u_char *dat, u_int length);
83 static void l2tp_recv_win_size_print(const u_char *dat, u_int length);
84 static void l2tp_challenge_print(const u_char *dat, u_int length);
85 static void l2tp_q931_cc_print(const u_char *dat, u_int length);
86 static void l2tp_challenge_resp_print(const u_char *dat, u_int length);
87 static void l2tp_assnd_sess_id_print(const u_char *dat, u_int length);
88 static void l2tp_call_ser_num_print(const u_char *dat, u_int length);
89 static void l2tp_minimum_bps_print(const u_char *dat, u_int length);
90 static void l2tp_maximum_bps_print(const u_char *dat, u_int length);
91 static void l2tp_bearer_type_print(const u_char *dat, u_int length);
92 static void l2tp_framing_type_print(const u_char *dat, u_int length);
93 static void l2tp_packet_proc_delay_print(const u_char *dat, u_int length);
94 static void l2tp_called_number_print(const u_char *dat, u_int length);
95 static void l2tp_calling_number_print(const u_char *dat, u_int length);
96 static void l2tp_sub_address_print(const u_char *dat, u_int length);
97 static void l2tp_tx_conn_speed_print(const u_char *dat, u_int length);
98 static void l2tp_phy_channel_id_print(const u_char *dat, u_int length);
99 static void l2tp_ini_recv_lcp_print(const u_char *dat, u_int length);
100 static void l2tp_last_sent_lcp_print(const u_char *dat, u_int length);
101 static void l2tp_last_recv_lcp_print(const u_char *dat, u_int length);
102 static void l2tp_proxy_auth_type_print(const u_char *dat, u_int length);
103 static void l2tp_proxy_auth_name_print(const u_char *dat, u_int length);
104 static void l2tp_proxy_auth_chal_print(const u_char *dat, u_int length);
105 static void l2tp_proxy_auth_id_print(const u_char *dat, u_int length);
106 static void l2tp_proxy_auth_resp_print(const u_char *dat, u_int length);
107 static void l2tp_call_errors_print(const u_char *dat, u_int length);
108 static void l2tp_accm_print(const u_char *dat, u_int length);
109 static void l2tp_random_vector_print(const u_char *dat, u_int length);
110 static void l2tp_private_grp_id_print(const u_char *dat, u_int length);
111 static void l2tp_rx_conn_speed_print(const u_char *dat, u_int length);
112 static void l2tp_seq_required_print(const u_char *dat, u_int length);
113 static void l2tp_avp_print(const u_char *dat, u_int length);
114
115 static struct l2tp_avp_vec l2tp_avp[] = {
116 {"MSGTYPE", l2tp_msgtype_print}, /* 0 Message Type */
117 {"RESULT_CODE", l2tp_result_code_print}, /* 1 Result Code */
118 {"PROTO_VER", l2tp_proto_ver_print}, /* 2 Protocol Version */
119 {"FRAMING_CAP", l2tp_framing_cap_print}, /* 3 Framing Capabilities */
120 {"BEARER_CAP", l2tp_bearer_cap_print}, /* 4 Bearer Capabilities */
121 {"TIE_BREAKER", l2tp_tie_breaker_print}, /* 5 Tie Breaker */
122 {"FIRM_VER", l2tp_firm_ver_print}, /* 6 Firmware Revision */
123 {"HOST_NAME", l2tp_host_name_print}, /* 7 Host Name */
124 {"VENDOR_NAME", l2tp_vendor_name_print}, /* 8 Vendor Name */
125 {"ASSND_TUN_ID", l2tp_assnd_tun_id_print}, /* 9 Assigned Tunnel ID */
126 {"RECV_WIN_SIZE", l2tp_recv_win_size_print}, /* 10 Receive Window Size */
127 {"CHALLENGE", l2tp_challenge_print}, /* 11 Challenge */
128 {"Q931_CC", l2tp_q931_cc_print}, /* 12 Q.931 Cause Code */
129 {"CHALLENGE_RESP", l2tp_challenge_resp_print},/* 13 Challenge Response */
130 {"ASSND_SESS_ID", l2tp_assnd_sess_id_print}, /* 14 Assigned Session ID */
131 {"CALL_SER_NUM", l2tp_call_ser_num_print}, /* 15 Call Serial Number */
132 {"MINIMUM_BPS", l2tp_minimum_bps_print},/* 16 Minimum BPS */
133 {"MAXIMUM_BPS", l2tp_maximum_bps_print}, /* 17 Maximum BPS */
134 {"BEARER_TYPE", l2tp_bearer_type_print},/* 18 Bearer Type */
135 {"FRAMING_TYPE", l2tp_framing_type_print}, /* 19 Framing Type */
136 {"PACKET_PROC_DELAY", l2tp_packet_proc_delay_print}, /* 20 Packet Processing Delay (OBSOLETE) */
137 {"CALLED_NUMBER", l2tp_called_number_print}, /* 21 Called Number */
138 {"CALLING_NUMBER", l2tp_calling_number_print},/* 22 Calling Number */
139 {"SUB_ADDRESS", l2tp_sub_address_print},/* 23 Sub-Address */
140 {"TX_CONN_SPEED", l2tp_tx_conn_speed_print}, /* 24 (Tx) Connect Speed */
141 {"PHY_CHANNEL_ID", l2tp_phy_channel_id_print},/* 25 Physical Channel ID */
142 {"INI_RECV_LCP", l2tp_ini_recv_lcp_print}, /* 26 Initial Received LCP CONFREQ */
143 {"LAST_SENT_LCP", l2tp_last_sent_lcp_print}, /* 27 Last Sent LCP CONFREQ */
144 {"LAST_RECV_LCP", l2tp_last_recv_lcp_print}, /* 28 Last Received LCP CONFREQ */
145 {"PROXY_AUTH_TYPE", l2tp_proxy_auth_type_print},/* 29 Proxy Authen Type */
146 {"PROXY_AUTH_NAME", l2tp_proxy_auth_name_print},/* 30 Proxy Authen Name */
147 {"PROXY_AUTH_CHAL", l2tp_proxy_auth_chal_print},/* 31 Proxy Authen Challenge */
148 {"PROXY_AUTH_ID", l2tp_proxy_auth_id_print}, /* 32 Proxy Authen ID */
149 {"PROXY_AUTH_RESP", l2tp_proxy_auth_resp_print},/* 33 Proxy Authen Response */
150 {"CALL_ERRORS", l2tp_call_errors_print}, /* 34 Call Errors */
151 {"ACCM", l2tp_accm_print}, /* 35 ACCM */
152 {"RANDOM_VECTOR", l2tp_random_vector_print}, /* 36 Random Vector */
153 {"PRIVATE_GRP_ID", l2tp_private_grp_id_print},/* 37 Private Group ID */
154 {"RX_CONN_SPEED", l2tp_rx_conn_speed_print}, /* 38 (Rx) Connect Speed */
155 {"SEQ_REQUIRED", l2tp_seq_required_print}, /* 39 Sequencing Required */
156 #define L2TP_MAX_AVP_INDEX 40
157 };
158
159 #if 0
160 static char *l2tp_result_code_StopCCN[] = {
161 "Reserved",
162 "General request to clear control connection",
163 "General error--Error Code indicates the problem",
164 "Control channel already exists",
165 "Requester is not authorized to establish a control channel",
166 "The protocol version of the requester is not supported",
167 "Requester is being shut down",
168 "Finite State Machine error"
169 #define L2TP_MAX_RESULT_CODE_STOPCC_INDEX 8
170 };
171 #endif
172
173 #if 0
174 static char *l2tp_result_code_CDN[] = {
175 "Reserved",
176 "Call disconnected due to loss of carrier",
177 "Call disconnected for the reason indicated in error code",
178 "Call disconnected for administrative reasons",
179 "Call failed due to lack of appropriate facilities being " \
180 "available (temporary condition)",
181 "Call failed due to lack of appropriate facilities being " \
182 "available (permanent condition)",
183 "Invalid destination",
184 "Call failed due to no carrier detected",
185 "Call failed due to detection of a busy signal",
186 "Call failed due to lack of a dial tone",
187 "Call was not established within time allotted by LAC",
188 "Call was connected but no appropriate framing was detected"
189 #define L2TP_MAX_RESULT_CODE_CDN_INDEX 12
190 };
191 #endif
192
193 #if 0
194 static char *l2tp_error_code_general[] = {
195 "No general error",
196 "No control connection exists yet for this LAC-LNS pair",
197 "Length is wrong",
198 "One of the field values was out of range or " \
199 "reserved field was non-zero"
200 "Insufficient resources to handle this operation now",
201 "The Session ID is invalid in this context",
202 "A generic vendor-specific error occurred in the LAC",
203 "Try another"
204 #define L2TP_MAX_ERROR_CODE_GENERAL_INDEX 8
205 };
206 #endif
207
208 /******************************/
209 /* generic print out routines */
210 /******************************/
211 static void
212 print_string(const u_char *dat, u_int length)
213 {
214 int i;
215 for (i=0; i<length; i++) {
216 printf("%c", *dat++);
217 }
218 }
219
220 static void
221 print_octets(const u_char *dat, u_int length)
222 {
223 int i;
224 for (i=0; i<length; i++) {
225 printf("%02x", *dat++);
226 }
227 }
228
229 static void
230 print_short(const u_short *dat)
231 {
232 printf("%u", ntohs(*dat));
233 }
234
235 static void
236 print_int(const u_int *dat)
237 {
238 printf("%lu", (u_long)ntohl(*dat));
239 }
240
241 /**********************************/
242 /* AVP-specific print out routines*/
243 /**********************************/
244 static void
245 l2tp_msgtype_print(const u_char *dat, u_int length)
246 {
247 u_short *ptr = (u_short *)dat;
248
249 if (ntohs(*ptr) < L2TP_MAX_MSGTYPE_INDEX) {
250 printf("%s", l2tp_message_type_string[ntohs(*ptr)]);
251 }
252 }
253
254 static void
255 l2tp_result_code_print(const u_char *dat, u_int length)
256 {
257 /* we just print out the result and error code number */
258 u_short *ptr = (u_short *)dat;
259
260 if (length == 2) { /* result code */
261 printf("%u", ntohs(*ptr));
262 } else if (length == 4) { /* result & error code */
263 printf("%u/%u", ntohs(*ptr), ntohs(*(ptr+1)));
264 } else if (length > 4) { /* result & error code & msg */
265 printf("%u/%u ", ntohs(*ptr), ntohs(*(ptr+1)));
266 print_string((u_char *)(ptr+2), length - 4);
267 }
268 }
269
270 static void
271 l2tp_proto_ver_print(const u_char *dat, u_int length)
272 {
273 printf("%d.%d", *dat, *(dat+1));
274 }
275
276
277 static void
278 l2tp_framing_cap_print(const u_char *dat, u_int length)
279 {
280 u_int *ptr = (u_int *)dat;
281
282 if (ntohl(*ptr) & L2TP_FRAMING_CAP_ASYNC_MASK) {
283 printf("A");
284 }
285 if (ntohl(*ptr) & L2TP_FRAMING_CAP_SYNC_MASK) {
286 printf("S");
287 }
288 }
289
290 static void
291 l2tp_bearer_cap_print(const u_char *dat, u_int length)
292 {
293 u_int *ptr = (u_int *)dat;
294
295 if (ntohl(*ptr) & L2TP_BEARER_CAP_ANALOG_MASK) {
296 printf("A");
297 }
298 if (ntohl(*ptr) & L2TP_BEARER_CAP_DIGITAL_MASK) {
299 printf("D");
300 }
301 }
302
303 static void
304 l2tp_tie_breaker_print(const u_char *dat, u_int length)
305 {
306 print_octets(dat, 8); /* Tie Break Value is 64bits long */
307 }
308
309 static void
310 l2tp_firm_ver_print(const u_char *dat, u_int length)
311 {
312 print_short((u_short *)dat);
313 }
314
315 static void
316 l2tp_host_name_print(const u_char *dat, u_int length)
317 {
318 print_string(dat, length);
319 }
320
321 static void
322 l2tp_vendor_name_print(const u_char *dat, u_int length)
323 {
324 print_string(dat, length);
325 }
326
327 static void
328 l2tp_assnd_tun_id_print(const u_char *dat, u_int length)
329 {
330 print_short((u_short *)dat);
331 }
332
333 static void
334 l2tp_recv_win_size_print(const u_char *dat, u_int length)
335 {
336 print_short((u_short *)dat);
337 }
338
339 static void
340 l2tp_challenge_print(const u_char *dat, u_int length)
341 {
342 print_octets(dat, length);
343 }
344
345 static void
346 l2tp_q931_cc_print(const u_char *dat, u_int length)
347 {
348 print_short((u_short *)dat);
349 printf(", %02x", dat[2]);
350 if (length > 3) {
351 printf(" ");
352 print_string(dat+3, length-3);
353 }
354 }
355
356 static void
357 l2tp_challenge_resp_print(const u_char *dat, u_int length)
358 {
359 print_octets(dat, 16); /* XXX length should be 16? */
360 }
361
362 static void
363 l2tp_assnd_sess_id_print(const u_char *dat, u_int length)
364 {
365 print_short((u_short *)dat);
366 }
367
368 static void
369 l2tp_call_ser_num_print(const u_char *dat, u_int length)
370 {
371 print_int((u_int *)dat);
372 }
373
374 static void
375 l2tp_minimum_bps_print(const u_char *dat, u_int length)
376 {
377 print_int((u_int *)dat);
378 }
379
380 static void
381 l2tp_maximum_bps_print(const u_char *dat, u_int length)
382 {
383 print_int((u_int *)dat);
384 }
385
386 static void
387 l2tp_bearer_type_print(const u_char *dat, u_int length)
388 {
389 u_int *ptr = (u_int *)dat;
390
391 if (ntohl(*ptr) & L2TP_BEARER_TYPE_ANALOG_MASK) {
392 printf("A");
393 }
394 if (ntohl(*ptr) & L2TP_BEARER_TYPE_DIGITAL_MASK) {
395 printf("D");
396 }
397 }
398
399 static void
400 l2tp_framing_type_print(const u_char *dat, u_int length)
401 {
402 u_int *ptr = (u_int *)dat;
403
404 if (ntohl(*ptr) & L2TP_FRAMING_TYPE_ASYNC_MASK) {
405 printf("A");
406 }
407 if (ntohl(*ptr) & L2TP_FRAMING_TYPE_SYNC_MASK) {
408 printf("S");
409 }
410 }
411
412 static void
413 l2tp_packet_proc_delay_print(const u_char *dat, u_int length)
414 {
415 printf("obsolete");
416 }
417
418 static void
419 l2tp_called_number_print(const u_char *dat, u_int length)
420 {
421 print_string(dat, length);
422 }
423
424 static void
425 l2tp_calling_number_print(const u_char *dat, u_int length)
426 {
427 print_string(dat, length);
428 }
429
430 static void
431 l2tp_sub_address_print(const u_char *dat, u_int length)
432 {
433 print_string(dat, length);
434 }
435
436 static void
437 l2tp_tx_conn_speed_print(const u_char *dat, u_int length)
438 {
439 print_int((u_int *)dat);
440 }
441
442 static void
443 l2tp_phy_channel_id_print(const u_char *dat, u_int length)
444 {
445 print_int((u_int *)dat);
446 }
447
448 static void
449 l2tp_ini_recv_lcp_print(const u_char *dat, u_int length)
450 {
451 print_octets(dat, length);
452 }
453
454 static void
455 l2tp_last_sent_lcp_print(const u_char *dat, u_int length)
456 {
457 print_octets(dat, length);
458 }
459
460 static void
461 l2tp_last_recv_lcp_print(const u_char *dat, u_int length)
462 {
463 print_octets(dat, length);
464 }
465
466 static void
467 l2tp_proxy_auth_type_print(const u_char *dat, u_int length)
468 {
469 u_short *ptr = (u_short *)dat;
470
471 switch (ntohs(*ptr)) {
472 case L2TP_AUTHEN_TYPE_RESERVED:
473 printf("Reserved");
474 break;
475 case L2TP_AUTHEN_TYPE_TEXTUAL:
476 printf("Textual");
477 break;
478 case L2TP_AUTHEN_TYPE_CHAP:
479 printf("CHAP");
480 break;
481 case L2TP_AUTHEN_TYPE_PAP:
482 printf("PAP");
483 break;
484 case L2TP_AUTHEN_TYPE_NO_AUTH:
485 printf("No Auth");
486 break;
487 case L2TP_AUTHEN_TYPE_MSCHAP:
488 printf("MS-CHAP");
489 break;
490 default:
491 printf("unknown");
492 }
493 }
494
495 static void
496 l2tp_proxy_auth_name_print(const u_char *dat, u_int length)
497 {
498 print_octets(dat, length);
499 }
500
501 static void
502 l2tp_proxy_auth_chal_print(const u_char *dat, u_int length)
503 {
504 print_octets(dat, length);
505 }
506
507 static void
508 l2tp_proxy_auth_id_print(const u_char *dat, u_int length)
509 {
510 u_short *ptr = (u_short *)dat;
511
512 printf("%u", ntohs(*ptr) & L2TP_PROXY_AUTH_ID_MASK);
513 }
514
515 static void
516 l2tp_proxy_auth_resp_print(const u_char *dat, u_int length)
517 {
518 print_octets(dat, length);
519 }
520
521 static void
522 l2tp_call_errors_print(const u_char *dat, u_int length)
523 {
524 struct l2tp_call_errors *ptr = (struct l2tp_call_errors *)dat;
525
526 printf("CRCErr=%d FrameErr=%d HardOver=%d BufOver=%d ",
527 ptr->crc_errs,
528 ptr->framing_errs,
529 ptr->hardware_overruns,
530 ptr->buffer_overruns);
531 printf("Timeout=%d AlingErr=%d",
532 ptr->timeout_errs,
533 ptr->alignment_errs);
534 }
535
536 static void
537 l2tp_accm_print(const u_char *dat, u_int length)
538 {
539 struct l2tp_accm *ptr = (struct l2tp_accm *)dat;
540
541 printf("send=%x recv=%x", ptr->send_accm, ptr->recv_accm);
542 }
543
544 static void
545 l2tp_random_vector_print(const u_char *dat, u_int length)
546 {
547 print_octets(dat, length);
548 }
549
550 static void
551 l2tp_private_grp_id_print(const u_char *dat, u_int length)
552 {
553 print_string(dat, length);
554 /* XXX print_octets is more appropriate?? */
555 }
556
557 static void
558 l2tp_rx_conn_speed_print(const u_char *dat, u_int length)
559 {
560 print_int((u_int *)dat);
561 }
562
563 static void
564 l2tp_seq_required_print(const u_char *dat, u_int length)
565 {
566 return;
567 }
568
569 static void
570 l2tp_avp_print(const u_char *dat, u_int length)
571 {
572 u_int len;
573 const u_short *ptr = (u_short *)dat;
574 int hidden = FALSE;
575
576 printf(" ");
577 if (length > 0 && (snapend - dat) >= 2) {
578 /* there must be at least two octets for the length
579 to be decoded */
580 if ((len = (ntohs(*ptr) & L2TP_AVP_HDR_LEN_MASK)) <=
581 (snapend - dat)) {
582 if (ntohs(*ptr) & L2TP_AVP_HDR_FLAG_MANDATORY) {
583 printf("*");
584 }
585 if (ntohs(*ptr) & L2TP_AVP_HDR_FLAG_HIDDEN) {
586 hidden = TRUE;
587 printf("?");
588 }
589 } else {
590 printf("|...");
591 return;
592 }
593 ptr++;
594
595 if (ntohs(*ptr)) {
596 /* Vendor Specific Attribute */
597 printf("VENDOR%04x:", ntohs(*ptr));
598 ptr++;
599 printf("ATTR%04x", ntohs(*ptr));
600 printf("(");
601 print_octets((u_char *)ptr+2, len-6);
602 printf(")");
603 } else {
604 /* IETF-defined Attribute */
605 ptr++;
606 if (ntohs(*ptr) < L2TP_MAX_AVP_INDEX) {
607 printf("%s", l2tp_avp[ntohs(*ptr)].name);
608 printf("(");
609 if (!hidden) {
610 (l2tp_avp[ntohs(*ptr)].print)
611 ((u_char *)ptr+2, len-6);
612 } else {
613 printf("???");
614 }
615 printf(")");
616 } else {
617 printf(" invalid AVP %u", ntohs(*ptr));
618 }
619 }
620
621 l2tp_avp_print(dat + len, length - len);
622 } else if (length == 0) {
623 return;
624 } else {
625 printf("|...");
626 }
627 }
628
629
630 void
631 l2tp_print(const u_char *dat, u_int length)
632 {
633 const u_short *ptr = (u_short *)dat;
634 u_int cnt = 0; /* total octets consumed */
635 u_short pad;
636 int flag_t, flag_l, flag_s, flag_o, flag_p;
637 u_short l2tp_len;
638
639 flag_t = flag_l = flag_s = flag_o = flag_p = FALSE;
640
641 if (min(length, snapend - dat) - 6 < 0) {
642 /* flag/ver, tunnel_id, session_id must be present for
643 this packet to be properly decoded */
644 printf("%s", tstr);
645 return;
646 }
647
648 if ((ntohs(*ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2TP) {
649 printf(" l2tp:");
650 } else if ((ntohs(*ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2F) {
651 printf(" l2f:");
652 return; /* nothing to do */
653 } else {
654 printf(" Unknown Version, neither L2F(1) nor L2TP(2)");
655 return; /* nothing we can do */
656 }
657
658 printf("[");
659 if (ntohs(*ptr) & L2TP_FLAG_TYPE) {
660 flag_t = TRUE;
661 printf("T");
662 }
663 if (ntohs(*ptr) & L2TP_FLAG_LENGTH) {
664 flag_l = TRUE;
665 printf("L");
666 }
667 if (ntohs(*ptr) & L2TP_FLAG_SEQUENCE) {
668 flag_s = TRUE;
669 printf("S");
670 }
671 if (ntohs(*ptr) & L2TP_FLAG_OFFSET) {
672 flag_o = TRUE;
673 printf("O");
674 }
675 if (ntohs(*ptr) & L2TP_FLAG_PRIORITY) {
676 flag_p = TRUE;
677 printf("P");
678 }
679 printf("]");
680
681 ptr++;
682 cnt += 2;
683
684 if (flag_l) {
685 l2tp_len = ntohs(*ptr++); /* XXX need to consider
686 truncation ?? */
687 cnt += 2;
688 } else {
689 l2tp_len = 0;
690 }
691
692 printf("(%u/", ntohs(*ptr++)); /* Tunnel ID */
693 printf("%u)", ntohs(*ptr++)); /* Session ID */
694 cnt += 4;
695
696 if (flag_s) {
697 printf("Ns=%u,", ntohs(*ptr++));
698 printf("Nr=%u", ntohs(*ptr++));
699 cnt += 4;
700 }
701
702 if (flag_o) {
703 pad = ntohs(*ptr++);
704 ptr += pad / sizeof(*ptr);
705 cnt += (2 + pad);
706 }
707
708 if (flag_t) {
709 if (length - cnt == 0) {
710 printf(" ZLB");
711 } else {
712 l2tp_avp_print((u_char *)ptr, length - cnt);
713 }
714 } else {
715 #if 0
716 printf(" {");
717 ppp_hdlc_print((u_char *)ptr, length - cnt);
718 printf("}");
719 #else
720 printf("[hdlc|]");
721 #endif
722 }
723 }
[mirror] the TCPdump network dissector