2 * Copyright (c) 1991, 1993, 1994, 1995, 1996, 1997
3 * The Regents of the University of California. All rights reserved.
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
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.
21 * L2TP support contributed by Motonori Shindo (mshindo@mshindo.net)
25 static const char rcsid[] _U_ =
26 "@(#) $Header: /tcpdump/master/tcpdump/print-l2tp.c,v 1.20 2006-06-23 02:03:09 hannes Exp $";
33 #include <tcpdump-stdinc.h>
38 #include "interface.h"
41 static char tstr[] = " [|l2tp]";
43 #define L2TP_MSGTYPE_SCCRQ 1 /* Start-Control-Connection-Request */
44 #define L2TP_MSGTYPE_SCCRP 2 /* Start-Control-Connection-Reply */
45 #define L2TP_MSGTYPE_SCCCN 3 /* Start-Control-Connection-Connected */
46 #define L2TP_MSGTYPE_STOPCCN 4 /* Stop-Control-Connection-Notification */
47 #define L2TP_MSGTYPE_HELLO 6 /* Hello */
48 #define L2TP_MSGTYPE_OCRQ 7 /* Outgoing-Call-Request */
49 #define L2TP_MSGTYPE_OCRP 8 /* Outgoing-Call-Reply */
50 #define L2TP_MSGTYPE_OCCN 9 /* Outgoing-Call-Connected */
51 #define L2TP_MSGTYPE_ICRQ 10 /* Incoming-Call-Request */
52 #define L2TP_MSGTYPE_ICRP 11 /* Incoming-Call-Reply */
53 #define L2TP_MSGTYPE_ICCN 12 /* Incoming-Call-Connected */
54 #define L2TP_MSGTYPE_CDN 14 /* Call-Disconnect-Notify */
55 #define L2TP_MSGTYPE_WEN 15 /* WAN-Error-Notify */
56 #define L2TP_MSGTYPE_SLI 16 /* Set-Link-Info */
58 static struct tok l2tp_msgtype2str[] = {
59 { L2TP_MSGTYPE_SCCRQ, "SCCRQ" },
60 { L2TP_MSGTYPE_SCCRP, "SCCRP" },
61 { L2TP_MSGTYPE_SCCCN, "SCCCN" },
62 { L2TP_MSGTYPE_STOPCCN, "StopCCN" },
63 { L2TP_MSGTYPE_HELLO, "HELLO" },
64 { L2TP_MSGTYPE_OCRQ, "OCRQ" },
65 { L2TP_MSGTYPE_OCRP, "OCRP" },
66 { L2TP_MSGTYPE_OCCN, "OCCN" },
67 { L2TP_MSGTYPE_ICRQ, "ICRQ" },
68 { L2TP_MSGTYPE_ICRP, "ICRP" },
69 { L2TP_MSGTYPE_ICCN, "ICCN" },
70 { L2TP_MSGTYPE_CDN, "CDN" },
71 { L2TP_MSGTYPE_WEN, "WEN" },
72 { L2TP_MSGTYPE_SLI, "SLI" },
76 #define L2TP_AVP_MSGTYPE 0 /* Message Type */
77 #define L2TP_AVP_RESULT_CODE 1 /* Result Code */
78 #define L2TP_AVP_PROTO_VER 2 /* Protocol Version */
79 #define L2TP_AVP_FRAMING_CAP 3 /* Framing Capabilities */
80 #define L2TP_AVP_BEARER_CAP 4 /* Bearer Capabilities */
81 #define L2TP_AVP_TIE_BREAKER 5 /* Tie Breaker */
82 #define L2TP_AVP_FIRM_VER 6 /* Firmware Revision */
83 #define L2TP_AVP_HOST_NAME 7 /* Host Name */
84 #define L2TP_AVP_VENDOR_NAME 8 /* Vendor Name */
85 #define L2TP_AVP_ASSND_TUN_ID 9 /* Assigned Tunnel ID */
86 #define L2TP_AVP_RECV_WIN_SIZE 10 /* Receive Window Size */
87 #define L2TP_AVP_CHALLENGE 11 /* Challenge */
88 #define L2TP_AVP_Q931_CC 12 /* Q.931 Cause Code */
89 #define L2TP_AVP_CHALLENGE_RESP 13 /* Challenge Response */
90 #define L2TP_AVP_ASSND_SESS_ID 14 /* Assigned Session ID */
91 #define L2TP_AVP_CALL_SER_NUM 15 /* Call Serial Number */
92 #define L2TP_AVP_MINIMUM_BPS 16 /* Minimum BPS */
93 #define L2TP_AVP_MAXIMUM_BPS 17 /* Maximum BPS */
94 #define L2TP_AVP_BEARER_TYPE 18 /* Bearer Type */
95 #define L2TP_AVP_FRAMING_TYPE 19 /* Framing Type */
96 #define L2TP_AVP_PACKET_PROC_DELAY 20 /* Packet Processing Delay (OBSOLETE) */
97 #define L2TP_AVP_CALLED_NUMBER 21 /* Called Number */
98 #define L2TP_AVP_CALLING_NUMBER 22 /* Calling Number */
99 #define L2TP_AVP_SUB_ADDRESS 23 /* Sub-Address */
100 #define L2TP_AVP_TX_CONN_SPEED 24 /* (Tx) Connect Speed */
101 #define L2TP_AVP_PHY_CHANNEL_ID 25 /* Physical Channel ID */
102 #define L2TP_AVP_INI_RECV_LCP 26 /* Initial Received LCP CONFREQ */
103 #define L2TP_AVP_LAST_SENT_LCP 27 /* Last Sent LCP CONFREQ */
104 #define L2TP_AVP_LAST_RECV_LCP 28 /* Last Received LCP CONFREQ */
105 #define L2TP_AVP_PROXY_AUTH_TYPE 29 /* Proxy Authen Type */
106 #define L2TP_AVP_PROXY_AUTH_NAME 30 /* Proxy Authen Name */
107 #define L2TP_AVP_PROXY_AUTH_CHAL 31 /* Proxy Authen Challenge */
108 #define L2TP_AVP_PROXY_AUTH_ID 32 /* Proxy Authen ID */
109 #define L2TP_AVP_PROXY_AUTH_RESP 33 /* Proxy Authen Response */
110 #define L2TP_AVP_CALL_ERRORS 34 /* Call Errors */
111 #define L2TP_AVP_ACCM 35 /* ACCM */
112 #define L2TP_AVP_RANDOM_VECTOR 36 /* Random Vector */
113 #define L2TP_AVP_PRIVATE_GRP_ID 37 /* Private Group ID */
114 #define L2TP_AVP_RX_CONN_SPEED 38 /* (Rx) Connect Speed */
115 #define L2TP_AVP_SEQ_REQUIRED 39 /* Sequencing Required */
116 #define L2TP_AVP_PPP_DISCON_CC 46 /* PPP Disconnect Cause Code */
118 static struct tok l2tp_avp2str[] = {
119 { L2TP_AVP_MSGTYPE, "MSGTYPE" },
120 { L2TP_AVP_RESULT_CODE, "RESULT_CODE" },
121 { L2TP_AVP_PROTO_VER, "PROTO_VER" },
122 { L2TP_AVP_FRAMING_CAP, "FRAMING_CAP" },
123 { L2TP_AVP_BEARER_CAP, "BEARER_CAP" },
124 { L2TP_AVP_TIE_BREAKER, "TIE_BREAKER" },
125 { L2TP_AVP_FIRM_VER, "FIRM_VER" },
126 { L2TP_AVP_HOST_NAME, "HOST_NAME" },
127 { L2TP_AVP_VENDOR_NAME, "VENDOR_NAME" },
128 { L2TP_AVP_ASSND_TUN_ID, "ASSND_TUN_ID" },
129 { L2TP_AVP_RECV_WIN_SIZE, "RECV_WIN_SIZE" },
130 { L2TP_AVP_CHALLENGE, "CHALLENGE" },
131 { L2TP_AVP_Q931_CC, "Q931_CC", },
132 { L2TP_AVP_CHALLENGE_RESP, "CHALLENGE_RESP" },
133 { L2TP_AVP_ASSND_SESS_ID, "ASSND_SESS_ID" },
134 { L2TP_AVP_CALL_SER_NUM, "CALL_SER_NUM" },
135 { L2TP_AVP_MINIMUM_BPS, "MINIMUM_BPS" },
136 { L2TP_AVP_MAXIMUM_BPS, "MAXIMUM_BPS" },
137 { L2TP_AVP_BEARER_TYPE, "BEARER_TYPE" },
138 { L2TP_AVP_FRAMING_TYPE, "FRAMING_TYPE" },
139 { L2TP_AVP_PACKET_PROC_DELAY, "PACKET_PROC_DELAY" },
140 { L2TP_AVP_CALLED_NUMBER, "CALLED_NUMBER" },
141 { L2TP_AVP_CALLING_NUMBER, "CALLING_NUMBER" },
142 { L2TP_AVP_SUB_ADDRESS, "SUB_ADDRESS" },
143 { L2TP_AVP_TX_CONN_SPEED, "TX_CONN_SPEED" },
144 { L2TP_AVP_PHY_CHANNEL_ID, "PHY_CHANNEL_ID" },
145 { L2TP_AVP_INI_RECV_LCP, "INI_RECV_LCP" },
146 { L2TP_AVP_LAST_SENT_LCP, "LAST_SENT_LCP" },
147 { L2TP_AVP_LAST_RECV_LCP, "LAST_RECV_LCP" },
148 { L2TP_AVP_PROXY_AUTH_TYPE, "PROXY_AUTH_TYPE" },
149 { L2TP_AVP_PROXY_AUTH_NAME, "PROXY_AUTH_NAME" },
150 { L2TP_AVP_PROXY_AUTH_CHAL, "PROXY_AUTH_CHAL" },
151 { L2TP_AVP_PROXY_AUTH_ID, "PROXY_AUTH_ID" },
152 { L2TP_AVP_PROXY_AUTH_RESP, "PROXY_AUTH_RESP" },
153 { L2TP_AVP_CALL_ERRORS, "CALL_ERRORS" },
154 { L2TP_AVP_ACCM, "ACCM" },
155 { L2TP_AVP_RANDOM_VECTOR, "RANDOM_VECTOR" },
156 { L2TP_AVP_PRIVATE_GRP_ID, "PRIVATE_GRP_ID" },
157 { L2TP_AVP_RX_CONN_SPEED, "RX_CONN_SPEED" },
158 { L2TP_AVP_SEQ_REQUIRED, "SEQ_REQUIRED" },
159 { L2TP_AVP_PPP_DISCON_CC, "PPP_DISCON_CC" },
163 static struct tok l2tp_authentype2str[] = {
164 { L2TP_AUTHEN_TYPE_RESERVED, "Reserved" },
165 { L2TP_AUTHEN_TYPE_TEXTUAL, "Textual" },
166 { L2TP_AUTHEN_TYPE_CHAP, "CHAP" },
167 { L2TP_AUTHEN_TYPE_PAP, "PAP" },
168 { L2TP_AUTHEN_TYPE_NO_AUTH, "No Auth" },
169 { L2TP_AUTHEN_TYPE_MSCHAPv1, "MS-CHAPv1" },
173 #define L2TP_PPP_DISCON_CC_DIRECTION_GLOBAL 0
174 #define L2TP_PPP_DISCON_CC_DIRECTION_AT_PEER 1
175 #define L2TP_PPP_DISCON_CC_DIRECTION_AT_LOCAL 2
177 static struct tok l2tp_cc_direction2str[] = {
178 { L2TP_PPP_DISCON_CC_DIRECTION_GLOBAL, "global error" },
179 { L2TP_PPP_DISCON_CC_DIRECTION_AT_PEER, "at peer" },
180 { L2TP_PPP_DISCON_CC_DIRECTION_AT_LOCAL,"at local" },
185 static char *l2tp_result_code_StopCCN[] = {
187 "General request to clear control connection",
188 "General error--Error Code indicates the problem",
189 "Control channel already exists",
190 "Requester is not authorized to establish a control channel",
191 "The protocol version of the requester is not supported",
192 "Requester is being shut down",
193 "Finite State Machine error"
194 #define L2TP_MAX_RESULT_CODE_STOPCC_INDEX 8
199 static char *l2tp_result_code_CDN[] = {
201 "Call disconnected due to loss of carrier",
202 "Call disconnected for the reason indicated in error code",
203 "Call disconnected for administrative reasons",
204 "Call failed due to lack of appropriate facilities being " \
205 "available (temporary condition)",
206 "Call failed due to lack of appropriate facilities being " \
207 "available (permanent condition)",
208 "Invalid destination",
209 "Call failed due to no carrier detected",
210 "Call failed due to detection of a busy signal",
211 "Call failed due to lack of a dial tone",
212 "Call was not established within time allotted by LAC",
213 "Call was connected but no appropriate framing was detected"
214 #define L2TP_MAX_RESULT_CODE_CDN_INDEX 12
219 static char *l2tp_error_code_general[] = {
221 "No control connection exists yet for this LAC-LNS pair",
223 "One of the field values was out of range or " \
224 "reserved field was non-zero"
225 "Insufficient resources to handle this operation now",
226 "The Session ID is invalid in this context",
227 "A generic vendor-specific error occurred in the LAC",
229 #define L2TP_MAX_ERROR_CODE_GENERAL_INDEX 8
233 /******************************/
234 /* generic print out routines */
235 /******************************/
237 print_string(const u_char *dat, u_int length)
240 for (i=0; i<length; i++) {
241 printf("%c", *dat++);
246 print_octets(const u_char *dat, u_int length)
249 for (i=0; i<length; i++) {
250 printf("%02x", *dat++);
255 print_16bits_val(const u_int16_t *dat)
257 printf("%u", EXTRACT_16BITS(dat));
261 print_32bits_val(const u_int32_t *dat)
263 printf("%lu", (u_long)EXTRACT_32BITS(dat));
266 /***********************************/
267 /* AVP-specific print out routines */
268 /***********************************/
270 l2tp_msgtype_print(const u_char *dat)
272 u_int16_t *ptr = (u_int16_t*)dat;
274 printf("%s", tok2str(l2tp_msgtype2str, "MSGTYPE-#%u",
275 EXTRACT_16BITS(ptr)));
279 l2tp_result_code_print(const u_char *dat, u_int length)
281 u_int16_t *ptr = (u_int16_t *)dat;
283 printf("%u", EXTRACT_16BITS(ptr)); ptr++; /* Result Code */
284 if (length > 2) { /* Error Code (opt) */
285 printf("/%u", EXTRACT_16BITS(ptr)); ptr++;
287 if (length > 4) { /* Error Message (opt) */
289 print_string((u_char *)ptr, length - 4);
294 l2tp_proto_ver_print(const u_int16_t *dat)
296 printf("%u.%u", (EXTRACT_16BITS(dat) >> 8),
297 (EXTRACT_16BITS(dat) & 0xff));
301 l2tp_framing_cap_print(const u_char *dat)
303 u_int32_t *ptr = (u_int32_t *)dat;
305 if (EXTRACT_32BITS(ptr) & L2TP_FRAMING_CAP_ASYNC_MASK) {
308 if (EXTRACT_32BITS(ptr) & L2TP_FRAMING_CAP_SYNC_MASK) {
314 l2tp_bearer_cap_print(const u_char *dat)
316 u_int32_t *ptr = (u_int32_t *)dat;
318 if (EXTRACT_32BITS(ptr) & L2TP_BEARER_CAP_ANALOG_MASK) {
321 if (EXTRACT_32BITS(ptr) & L2TP_BEARER_CAP_DIGITAL_MASK) {
327 l2tp_q931_cc_print(const u_char *dat, u_int length)
329 print_16bits_val((u_int16_t *)dat);
330 printf(", %02x", dat[2]);
333 print_string(dat+3, length-3);
338 l2tp_bearer_type_print(const u_char *dat)
340 u_int32_t *ptr = (u_int32_t *)dat;
342 if (EXTRACT_32BITS(ptr) & L2TP_BEARER_TYPE_ANALOG_MASK) {
345 if (EXTRACT_32BITS(ptr) & L2TP_BEARER_TYPE_DIGITAL_MASK) {
351 l2tp_framing_type_print(const u_char *dat)
353 u_int32_t *ptr = (u_int32_t *)dat;
355 if (EXTRACT_32BITS(ptr) & L2TP_FRAMING_TYPE_ASYNC_MASK) {
358 if (EXTRACT_32BITS(ptr) & L2TP_FRAMING_TYPE_SYNC_MASK) {
364 l2tp_packet_proc_delay_print(void)
370 l2tp_proxy_auth_type_print(const u_char *dat)
372 u_int16_t *ptr = (u_int16_t *)dat;
374 printf("%s", tok2str(l2tp_authentype2str,
375 "AuthType-#%u", EXTRACT_16BITS(ptr)));
379 l2tp_proxy_auth_id_print(const u_char *dat)
381 u_int16_t *ptr = (u_int16_t *)dat;
383 printf("%u", EXTRACT_16BITS(ptr) & L2TP_PROXY_AUTH_ID_MASK);
387 l2tp_call_errors_print(const u_char *dat)
389 u_int16_t *ptr = (u_int16_t *)dat;
390 u_int16_t val_h, val_l;
392 ptr++; /* skip "Reserved" */
394 val_h = EXTRACT_16BITS(ptr); ptr++;
395 val_l = EXTRACT_16BITS(ptr); ptr++;
396 printf("CRCErr=%u ", (val_h<<16) + val_l);
398 val_h = EXTRACT_16BITS(ptr); ptr++;
399 val_l = EXTRACT_16BITS(ptr); ptr++;
400 printf("FrameErr=%u ", (val_h<<16) + val_l);
402 val_h = EXTRACT_16BITS(ptr); ptr++;
403 val_l = EXTRACT_16BITS(ptr); ptr++;
404 printf("HardOver=%u ", (val_h<<16) + val_l);
406 val_h = EXTRACT_16BITS(ptr); ptr++;
407 val_l = EXTRACT_16BITS(ptr); ptr++;
408 printf("BufOver=%u ", (val_h<<16) + val_l);
410 val_h = EXTRACT_16BITS(ptr); ptr++;
411 val_l = EXTRACT_16BITS(ptr); ptr++;
412 printf("Timeout=%u ", (val_h<<16) + val_l);
414 val_h = EXTRACT_16BITS(ptr); ptr++;
415 val_l = EXTRACT_16BITS(ptr); ptr++;
416 printf("AlignErr=%u ", (val_h<<16) + val_l);
420 l2tp_accm_print(const u_char *dat)
422 u_int16_t *ptr = (u_int16_t *)dat;
423 u_int16_t val_h, val_l;
425 ptr++; /* skip "Reserved" */
427 val_h = EXTRACT_16BITS(ptr); ptr++;
428 val_l = EXTRACT_16BITS(ptr); ptr++;
429 printf("send=%08x ", (val_h<<16) + val_l);
431 val_h = EXTRACT_16BITS(ptr); ptr++;
432 val_l = EXTRACT_16BITS(ptr); ptr++;
433 printf("recv=%08x ", (val_h<<16) + val_l);
437 l2tp_ppp_discon_cc_print(const u_char *dat, u_int length)
439 u_int16_t *ptr = (u_int16_t *)dat;
441 printf("%04x, ", EXTRACT_16BITS(ptr)); ptr++; /* Disconnect Code */
442 printf("%04x ", EXTRACT_16BITS(ptr)); ptr++; /* Control Protocol Number */
443 printf("%s", tok2str(l2tp_cc_direction2str,
444 "Direction-#%u", *((u_char *)ptr++)));
448 print_string((const u_char *)ptr, length-5);
453 l2tp_avp_print(const u_char *dat, int length)
456 const u_int16_t *ptr = (u_int16_t *)dat;
466 TCHECK(*ptr); /* Flags & Length */
467 len = EXTRACT_16BITS(ptr) & L2TP_AVP_HDR_LEN_MASK;
469 /* If it is not long enough to contain the header, we'll give up. */
473 /* If it goes past the end of the remaining length of the packet,
475 if (len > (u_int)length)
478 /* If it goes past the end of the remaining length of the captured
479 data, we'll give up. */
481 /* After this point, no need to worry about truncation */
483 if (EXTRACT_16BITS(ptr) & L2TP_AVP_HDR_FLAG_MANDATORY) {
486 if (EXTRACT_16BITS(ptr) & L2TP_AVP_HDR_FLAG_HIDDEN) {
492 if (EXTRACT_16BITS(ptr)) {
493 /* Vendor Specific Attribute */
494 printf("VENDOR%04x:", EXTRACT_16BITS(ptr)); ptr++;
495 printf("ATTR%04x", EXTRACT_16BITS(ptr)); ptr++;
497 print_octets((u_char *)ptr, len-6);
500 /* IETF-defined Attributes */
502 attr_type = EXTRACT_16BITS(ptr); ptr++;
503 printf("%s", tok2str(l2tp_avp2str, "AVP-#%u", attr_type));
509 case L2TP_AVP_MSGTYPE:
510 l2tp_msgtype_print((u_char *)ptr);
512 case L2TP_AVP_RESULT_CODE:
513 l2tp_result_code_print((u_char *)ptr, len-6);
515 case L2TP_AVP_PROTO_VER:
516 l2tp_proto_ver_print(ptr);
518 case L2TP_AVP_FRAMING_CAP:
519 l2tp_framing_cap_print((u_char *)ptr);
521 case L2TP_AVP_BEARER_CAP:
522 l2tp_bearer_cap_print((u_char *)ptr);
524 case L2TP_AVP_TIE_BREAKER:
525 print_octets((u_char *)ptr, 8);
527 case L2TP_AVP_FIRM_VER:
528 case L2TP_AVP_ASSND_TUN_ID:
529 case L2TP_AVP_RECV_WIN_SIZE:
530 case L2TP_AVP_ASSND_SESS_ID:
531 print_16bits_val(ptr);
533 case L2TP_AVP_HOST_NAME:
534 case L2TP_AVP_VENDOR_NAME:
535 case L2TP_AVP_CALLING_NUMBER:
536 case L2TP_AVP_CALLED_NUMBER:
537 case L2TP_AVP_SUB_ADDRESS:
538 case L2TP_AVP_PROXY_AUTH_NAME:
539 case L2TP_AVP_PRIVATE_GRP_ID:
540 print_string((u_char *)ptr, len-6);
542 case L2TP_AVP_CHALLENGE:
543 case L2TP_AVP_INI_RECV_LCP:
544 case L2TP_AVP_LAST_SENT_LCP:
545 case L2TP_AVP_LAST_RECV_LCP:
546 case L2TP_AVP_PROXY_AUTH_CHAL:
547 case L2TP_AVP_PROXY_AUTH_RESP:
548 case L2TP_AVP_RANDOM_VECTOR:
549 print_octets((u_char *)ptr, len-6);
551 case L2TP_AVP_Q931_CC:
552 l2tp_q931_cc_print((u_char *)ptr, len-6);
554 case L2TP_AVP_CHALLENGE_RESP:
555 print_octets((u_char *)ptr, 16);
557 case L2TP_AVP_CALL_SER_NUM:
558 case L2TP_AVP_MINIMUM_BPS:
559 case L2TP_AVP_MAXIMUM_BPS:
560 case L2TP_AVP_TX_CONN_SPEED:
561 case L2TP_AVP_PHY_CHANNEL_ID:
562 case L2TP_AVP_RX_CONN_SPEED:
563 print_32bits_val((u_int32_t *)ptr);
565 case L2TP_AVP_BEARER_TYPE:
566 l2tp_bearer_type_print((u_char *)ptr);
568 case L2TP_AVP_FRAMING_TYPE:
569 l2tp_framing_type_print((u_char *)ptr);
571 case L2TP_AVP_PACKET_PROC_DELAY:
572 l2tp_packet_proc_delay_print();
574 case L2TP_AVP_PROXY_AUTH_TYPE:
575 l2tp_proxy_auth_type_print((u_char *)ptr);
577 case L2TP_AVP_PROXY_AUTH_ID:
578 l2tp_proxy_auth_id_print((u_char *)ptr);
580 case L2TP_AVP_CALL_ERRORS:
581 l2tp_call_errors_print((u_char *)ptr);
584 l2tp_accm_print((u_char *)ptr);
586 case L2TP_AVP_SEQ_REQUIRED:
587 break; /* No Attribute Value */
588 case L2TP_AVP_PPP_DISCON_CC:
589 l2tp_ppp_discon_cc_print((u_char *)ptr, len-6);
598 l2tp_avp_print(dat+len, length-len);
607 l2tp_print(const u_char *dat, u_int length)
609 const u_char *ptr = dat;
610 u_int cnt = 0; /* total octets consumed */
612 int flag_t, flag_l, flag_s, flag_o;
615 flag_t = flag_l = flag_s = flag_o = FALSE;
617 TCHECK2(*ptr, 2); /* Flags & Version */
618 if ((EXTRACT_16BITS(ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2TP) {
620 } else if ((EXTRACT_16BITS(ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2F) {
622 return; /* nothing to do */
624 printf(" Unknown Version, neither L2F(1) nor L2TP(2)");
625 return; /* nothing we can do */
629 if (EXTRACT_16BITS(ptr) & L2TP_FLAG_TYPE) {
633 if (EXTRACT_16BITS(ptr) & L2TP_FLAG_LENGTH) {
637 if (EXTRACT_16BITS(ptr) & L2TP_FLAG_SEQUENCE) {
641 if (EXTRACT_16BITS(ptr) & L2TP_FLAG_OFFSET) {
645 if (EXTRACT_16BITS(ptr) & L2TP_FLAG_PRIORITY)
653 TCHECK2(*ptr, 2); /* Length */
654 l2tp_len = EXTRACT_16BITS(ptr);
661 TCHECK2(*ptr, 2); /* Tunnel ID */
662 printf("(%u/", EXTRACT_16BITS(ptr));
665 TCHECK2(*ptr, 2); /* Session ID */
666 printf("%u)", EXTRACT_16BITS(ptr));
671 TCHECK2(*ptr, 2); /* Ns */
672 printf("Ns=%u,", EXTRACT_16BITS(ptr));
675 TCHECK2(*ptr, 2); /* Nr */
676 printf("Nr=%u", EXTRACT_16BITS(ptr));
682 TCHECK2(*ptr, 2); /* Offset Size */
683 pad = EXTRACT_16BITS(ptr);
689 if (length < l2tp_len) {
690 printf(" Length %u larger than packet", l2tp_len);
696 printf(" Length %u smaller than header length", length);
701 printf(" No length");
704 if (length - cnt == 0) {
707 l2tp_avp_print(ptr, length - cnt);
711 ppp_print(ptr, length - cnt);