]> The Tcpdump Group git mirrors - tcpdump/blob - print-l2tp.c
projects / tcpdump / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix a typo
[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 /* \summary: Layer Two Tunneling Protocol (L2TP) printer */
25
26 /* specification: RFC 2661 */
27
28 #include <config.h>
29
30 #include "netdissect-stdinc.h"
31
32 #define ND_LONGJMP_FROM_TCHECK
33 #include "netdissect.h"
34 #include "extract.h"
35
36 #define L2TP_FLAG_TYPE 0x8000 /* Type (0=Data, 1=Control) */
37 #define L2TP_FLAG_LENGTH 0x4000 /* Length */
38 #define L2TP_FLAG_SEQUENCE 0x0800 /* Sequence */
39 #define L2TP_FLAG_OFFSET 0x0200 /* Offset */
40 #define L2TP_FLAG_PRIORITY 0x0100 /* Priority */
41
42 #define L2TP_VERSION_MASK 0x000f /* Version Mask */
43 #define L2TP_VERSION_L2F 0x0001 /* L2F */
44 #define L2TP_VERSION_L2TP 0x0002 /* L2TP */
45
46 #define L2TP_AVP_HDR_FLAG_MANDATORY 0x8000 /* Mandatory Flag */
47 #define L2TP_AVP_HDR_FLAG_HIDDEN 0x4000 /* Hidden Flag */
48 #define L2TP_AVP_HDR_LEN_MASK 0x03ff /* Length Mask */
49
50 #define L2TP_FRAMING_CAP_SYNC_MASK 0x00000001 /* Synchronous */
51 #define L2TP_FRAMING_CAP_ASYNC_MASK 0x00000002 /* Asynchronous */
52
53 #define L2TP_FRAMING_TYPE_SYNC_MASK 0x00000001 /* Synchronous */
54 #define L2TP_FRAMING_TYPE_ASYNC_MASK 0x00000002 /* Asynchronous */
55
56 #define L2TP_BEARER_CAP_DIGITAL_MASK 0x00000001 /* Digital */
57 #define L2TP_BEARER_CAP_ANALOG_MASK 0x00000002 /* Analog */
58
59 #define L2TP_BEARER_TYPE_DIGITAL_MASK 0x00000001 /* Digital */
60 #define L2TP_BEARER_TYPE_ANALOG_MASK 0x00000002 /* Analog */
61
62 /* Authen Type */
63 #define L2TP_AUTHEN_TYPE_RESERVED 0x0000 /* Reserved */
64 #define L2TP_AUTHEN_TYPE_TEXTUAL 0x0001 /* Textual username/password exchange */
65 #define L2TP_AUTHEN_TYPE_CHAP 0x0002 /* PPP CHAP */
66 #define L2TP_AUTHEN_TYPE_PAP 0x0003 /* PPP PAP */
67 #define L2TP_AUTHEN_TYPE_NO_AUTH 0x0004 /* No Authentication */
68 #define L2TP_AUTHEN_TYPE_MSCHAPv1 0x0005 /* MSCHAPv1 */
69
70 #define L2TP_PROXY_AUTH_ID_MASK 0x00ff
71
72
73 #define L2TP_MSGTYPE_SCCRQ 1 /* Start-Control-Connection-Request */
74 #define L2TP_MSGTYPE_SCCRP 2 /* Start-Control-Connection-Reply */
75 #define L2TP_MSGTYPE_SCCCN 3 /* Start-Control-Connection-Connected */
76 #define L2TP_MSGTYPE_STOPCCN 4 /* Stop-Control-Connection-Notification */
77 #define L2TP_MSGTYPE_HELLO 6 /* Hello */
78 #define L2TP_MSGTYPE_OCRQ 7 /* Outgoing-Call-Request */
79 #define L2TP_MSGTYPE_OCRP 8 /* Outgoing-Call-Reply */
80 #define L2TP_MSGTYPE_OCCN 9 /* Outgoing-Call-Connected */
81 #define L2TP_MSGTYPE_ICRQ 10 /* Incoming-Call-Request */
82 #define L2TP_MSGTYPE_ICRP 11 /* Incoming-Call-Reply */
83 #define L2TP_MSGTYPE_ICCN 12 /* Incoming-Call-Connected */
84 #define L2TP_MSGTYPE_CDN 14 /* Call-Disconnect-Notify */
85 #define L2TP_MSGTYPE_WEN 15 /* WAN-Error-Notify */
86 #define L2TP_MSGTYPE_SLI 16 /* Set-Link-Info */
87
88 static const struct tok l2tp_msgtype2str[] = {
89 { L2TP_MSGTYPE_SCCRQ, "SCCRQ" },
90 { L2TP_MSGTYPE_SCCRP, "SCCRP" },
91 { L2TP_MSGTYPE_SCCCN, "SCCCN" },
92 { L2TP_MSGTYPE_STOPCCN, "StopCCN" },
93 { L2TP_MSGTYPE_HELLO, "HELLO" },
94 { L2TP_MSGTYPE_OCRQ, "OCRQ" },
95 { L2TP_MSGTYPE_OCRP, "OCRP" },
96 { L2TP_MSGTYPE_OCCN, "OCCN" },
97 { L2TP_MSGTYPE_ICRQ, "ICRQ" },
98 { L2TP_MSGTYPE_ICRP, "ICRP" },
99 { L2TP_MSGTYPE_ICCN, "ICCN" },
100 { L2TP_MSGTYPE_CDN, "CDN" },
101 { L2TP_MSGTYPE_WEN, "WEN" },
102 { L2TP_MSGTYPE_SLI, "SLI" },
103 { 0, NULL }
104 };
105
106 #define L2TP_AVP_MSGTYPE 0 /* Message Type */
107 #define L2TP_AVP_RESULT_CODE 1 /* Result Code */
108 #define L2TP_AVP_PROTO_VER 2 /* Protocol Version */
109 #define L2TP_AVP_FRAMING_CAP 3 /* Framing Capabilities */
110 #define L2TP_AVP_BEARER_CAP 4 /* Bearer Capabilities */
111 #define L2TP_AVP_TIE_BREAKER 5 /* Tie Breaker */
112 #define L2TP_AVP_FIRM_VER 6 /* Firmware Revision */
113 #define L2TP_AVP_HOST_NAME 7 /* Host Name */
114 #define L2TP_AVP_VENDOR_NAME 8 /* Vendor Name */
115 #define L2TP_AVP_ASSND_TUN_ID 9 /* Assigned Tunnel ID */
116 #define L2TP_AVP_RECV_WIN_SIZE 10 /* Receive Window Size */
117 #define L2TP_AVP_CHALLENGE 11 /* Challenge */
118 #define L2TP_AVP_Q931_CC 12 /* Q.931 Cause Code */
119 #define L2TP_AVP_CHALLENGE_RESP 13 /* Challenge Response */
120 #define L2TP_AVP_ASSND_SESS_ID 14 /* Assigned Session ID */
121 #define L2TP_AVP_CALL_SER_NUM 15 /* Call Serial Number */
122 #define L2TP_AVP_MINIMUM_BPS 16 /* Minimum BPS */
123 #define L2TP_AVP_MAXIMUM_BPS 17 /* Maximum BPS */
124 #define L2TP_AVP_BEARER_TYPE 18 /* Bearer Type */
125 #define L2TP_AVP_FRAMING_TYPE 19 /* Framing Type */
126 #define L2TP_AVP_PACKET_PROC_DELAY 20 /* Packet Processing Delay (OBSOLETE) */
127 #define L2TP_AVP_CALLED_NUMBER 21 /* Called Number */
128 #define L2TP_AVP_CALLING_NUMBER 22 /* Calling Number */
129 #define L2TP_AVP_SUB_ADDRESS 23 /* Sub-Address */
130 #define L2TP_AVP_TX_CONN_SPEED 24 /* (Tx) Connect Speed */
131 #define L2TP_AVP_PHY_CHANNEL_ID 25 /* Physical Channel ID */
132 #define L2TP_AVP_INI_RECV_LCP 26 /* Initial Received LCP CONFREQ */
133 #define L2TP_AVP_LAST_SENT_LCP 27 /* Last Sent LCP CONFREQ */
134 #define L2TP_AVP_LAST_RECV_LCP 28 /* Last Received LCP CONFREQ */
135 #define L2TP_AVP_PROXY_AUTH_TYPE 29 /* Proxy Authen Type */
136 #define L2TP_AVP_PROXY_AUTH_NAME 30 /* Proxy Authen Name */
137 #define L2TP_AVP_PROXY_AUTH_CHAL 31 /* Proxy Authen Challenge */
138 #define L2TP_AVP_PROXY_AUTH_ID 32 /* Proxy Authen ID */
139 #define L2TP_AVP_PROXY_AUTH_RESP 33 /* Proxy Authen Response */
140 #define L2TP_AVP_CALL_ERRORS 34 /* Call Errors */
141 #define L2TP_AVP_ACCM 35 /* ACCM */
142 #define L2TP_AVP_RANDOM_VECTOR 36 /* Random Vector */
143 #define L2TP_AVP_PRIVATE_GRP_ID 37 /* Private Group ID */
144 #define L2TP_AVP_RX_CONN_SPEED 38 /* (Rx) Connect Speed */
145 #define L2TP_AVP_SEQ_REQUIRED 39 /* Sequencing Required */
146 #define L2TP_AVP_PPP_DISCON_CC 46 /* PPP Disconnect Cause Code - RFC 3145 */
147
148 static const struct tok l2tp_avp2str[] = {
149 { L2TP_AVP_MSGTYPE, "MSGTYPE" },
150 { L2TP_AVP_RESULT_CODE, "RESULT_CODE" },
151 { L2TP_AVP_PROTO_VER, "PROTO_VER" },
152 { L2TP_AVP_FRAMING_CAP, "FRAMING_CAP" },
153 { L2TP_AVP_BEARER_CAP, "BEARER_CAP" },
154 { L2TP_AVP_TIE_BREAKER, "TIE_BREAKER" },
155 { L2TP_AVP_FIRM_VER, "FIRM_VER" },
156 { L2TP_AVP_HOST_NAME, "HOST_NAME" },
157 { L2TP_AVP_VENDOR_NAME, "VENDOR_NAME" },
158 { L2TP_AVP_ASSND_TUN_ID, "ASSND_TUN_ID" },
159 { L2TP_AVP_RECV_WIN_SIZE, "RECV_WIN_SIZE" },
160 { L2TP_AVP_CHALLENGE, "CHALLENGE" },
161 { L2TP_AVP_Q931_CC, "Q931_CC", },
162 { L2TP_AVP_CHALLENGE_RESP, "CHALLENGE_RESP" },
163 { L2TP_AVP_ASSND_SESS_ID, "ASSND_SESS_ID" },
164 { L2TP_AVP_CALL_SER_NUM, "CALL_SER_NUM" },
165 { L2TP_AVP_MINIMUM_BPS, "MINIMUM_BPS" },
166 { L2TP_AVP_MAXIMUM_BPS, "MAXIMUM_BPS" },
167 { L2TP_AVP_BEARER_TYPE, "BEARER_TYPE" },
168 { L2TP_AVP_FRAMING_TYPE, "FRAMING_TYPE" },
169 { L2TP_AVP_PACKET_PROC_DELAY, "PACKET_PROC_DELAY" },
170 { L2TP_AVP_CALLED_NUMBER, "CALLED_NUMBER" },
171 { L2TP_AVP_CALLING_NUMBER, "CALLING_NUMBER" },
172 { L2TP_AVP_SUB_ADDRESS, "SUB_ADDRESS" },
173 { L2TP_AVP_TX_CONN_SPEED, "TX_CONN_SPEED" },
174 { L2TP_AVP_PHY_CHANNEL_ID, "PHY_CHANNEL_ID" },
175 { L2TP_AVP_INI_RECV_LCP, "INI_RECV_LCP" },
176 { L2TP_AVP_LAST_SENT_LCP, "LAST_SENT_LCP" },
177 { L2TP_AVP_LAST_RECV_LCP, "LAST_RECV_LCP" },
178 { L2TP_AVP_PROXY_AUTH_TYPE, "PROXY_AUTH_TYPE" },
179 { L2TP_AVP_PROXY_AUTH_NAME, "PROXY_AUTH_NAME" },
180 { L2TP_AVP_PROXY_AUTH_CHAL, "PROXY_AUTH_CHAL" },
181 { L2TP_AVP_PROXY_AUTH_ID, "PROXY_AUTH_ID" },
182 { L2TP_AVP_PROXY_AUTH_RESP, "PROXY_AUTH_RESP" },
183 { L2TP_AVP_CALL_ERRORS, "CALL_ERRORS" },
184 { L2TP_AVP_ACCM, "ACCM" },
185 { L2TP_AVP_RANDOM_VECTOR, "RANDOM_VECTOR" },
186 { L2TP_AVP_PRIVATE_GRP_ID, "PRIVATE_GRP_ID" },
187 { L2TP_AVP_RX_CONN_SPEED, "RX_CONN_SPEED" },
188 { L2TP_AVP_SEQ_REQUIRED, "SEQ_REQUIRED" },
189 { L2TP_AVP_PPP_DISCON_CC, "PPP_DISCON_CC" },
190 { 0, NULL }
191 };
192
193 static const struct tok l2tp_authentype2str[] = {
194 { L2TP_AUTHEN_TYPE_RESERVED, "Reserved" },
195 { L2TP_AUTHEN_TYPE_TEXTUAL, "Textual" },
196 { L2TP_AUTHEN_TYPE_CHAP, "CHAP" },
197 { L2TP_AUTHEN_TYPE_PAP, "PAP" },
198 { L2TP_AUTHEN_TYPE_NO_AUTH, "No Auth" },
199 { L2TP_AUTHEN_TYPE_MSCHAPv1, "MS-CHAPv1" },
200 { 0, NULL }
201 };
202
203 #define L2TP_PPP_DISCON_CC_DIRECTION_GLOBAL 0
204 #define L2TP_PPP_DISCON_CC_DIRECTION_AT_PEER 1
205 #define L2TP_PPP_DISCON_CC_DIRECTION_AT_LOCAL 2
206
207 static const struct tok l2tp_cc_direction2str[] = {
208 { L2TP_PPP_DISCON_CC_DIRECTION_GLOBAL, "global error" },
209 { L2TP_PPP_DISCON_CC_DIRECTION_AT_PEER, "at peer" },
210 { L2TP_PPP_DISCON_CC_DIRECTION_AT_LOCAL,"at local" },
211 { 0, NULL }
212 };
213
214 #if 0
215 static char *l2tp_result_code_StopCCN[] = {
216 "Reserved",
217 "General request to clear control connection",
218 "General error--Error Code indicates the problem",
219 "Control channel already exists",
220 "Requester is not authorized to establish a control channel",
221 "The protocol version of the requester is not supported",
222 "Requester is being shut down",
223 "Finite State Machine error"
224 #define L2TP_MAX_RESULT_CODE_STOPCC_INDEX 8
225 };
226 #endif
227
228 #if 0
229 static char *l2tp_result_code_CDN[] = {
230 "Reserved",
231 "Call disconnected due to loss of carrier",
232 "Call disconnected for the reason indicated in error code",
233 "Call disconnected for administrative reasons",
234 "Call failed due to lack of appropriate facilities being "
235 "available (temporary condition)",
236 "Call failed due to lack of appropriate facilities being "
237 "available (permanent condition)",
238 "Invalid destination",
239 "Call failed due to no carrier detected",
240 "Call failed due to detection of a busy signal",
241 "Call failed due to lack of a dial tone",
242 "Call was not established within time allotted by LAC",
243 "Call was connected but no appropriate framing was detected"
244 #define L2TP_MAX_RESULT_CODE_CDN_INDEX 12
245 };
246 #endif
247
248 #if 0
249 static char *l2tp_error_code_general[] = {
250 "No general error",
251 "No control connection exists yet for this LAC-LNS pair",
252 "Length is wrong",
253 "One of the field values was out of range or "
254 "reserved field was non-zero"
255 "Insufficient resources to handle this operation now",
256 "The Session ID is invalid in this context",
257 "A generic vendor-specific error occurred in the LAC",
258 "Try another"
259 #define L2TP_MAX_ERROR_CODE_GENERAL_INDEX 8
260 };
261 #endif
262
263 /******************************/
264 /* generic print out routines */
265 /******************************/
266 static void
267 print_string(netdissect_options *ndo, const u_char *dat, u_int length)
268 {
269 u_int i;
270 for (i=0; i<length; i++) {
271 fn_print_char(ndo, GET_U_1(dat));
272 dat++;
273 }
274 }
275
276 static void
277 print_octets(netdissect_options *ndo, const u_char *dat, u_int length)
278 {
279 u_int i;
280 for (i=0; i<length; i++) {
281 ND_PRINT("%02x", GET_U_1(dat));
282 dat++;
283 }
284 }
285
286 static void
287 print_16bits_val(netdissect_options *ndo, const uint8_t *dat)
288 {
289 ND_PRINT("%u", GET_BE_U_2(dat));
290 }
291
292 static void
293 print_32bits_val(netdissect_options *ndo, const uint8_t *dat)
294 {
295 ND_PRINT("%u", GET_BE_U_4(dat));
296 }
297
298 /***********************************/
299 /* AVP-specific print out routines */
300 /***********************************/
301 static void
302 l2tp_msgtype_print(netdissect_options *ndo, const u_char *dat, u_int length)
303 {
304 if (length < 2) {
305 ND_PRINT("AVP too short");
306 return;
307 }
308 ND_PRINT("%s", tok2str(l2tp_msgtype2str, "MSGTYPE-#%u",
309 GET_BE_U_2(dat)));
310 }
311
312 static void
313 l2tp_result_code_print(netdissect_options *ndo, const u_char *dat, u_int length)
314 {
315 /* Result Code */
316 if (length < 2) {
317 ND_PRINT("AVP too short");
318 return;
319 }
320 ND_PRINT("%u", GET_BE_U_2(dat));
321 dat += 2;
322 length -= 2;
323
324 /* Error Code (opt) */
325 if (length == 0)
326 return;
327 if (length < 2) {
328 ND_PRINT(" AVP too short");
329 return;
330 }
331 ND_PRINT("/%u", GET_BE_U_2(dat));
332 dat += 2;
333 length -= 2;
334
335 /* Error Message (opt) */
336 if (length == 0)
337 return;
338 ND_PRINT(" ");
339 print_string(ndo, dat, length);
340 }
341
342 static void
343 l2tp_proto_ver_print(netdissect_options *ndo, const u_char *dat, u_int length)
344 {
345 if (length < 2) {
346 ND_PRINT("AVP too short");
347 return;
348 }
349 ND_PRINT("%u.%u", (GET_BE_U_2(dat) >> 8),
350 (GET_BE_U_2(dat) & 0xff));
351 }
352
353 static void
354 l2tp_framing_cap_print(netdissect_options *ndo, const u_char *dat, u_int length)
355 {
356 if (length < 4) {
357 ND_PRINT("AVP too short");
358 return;
359 }
360 if (GET_BE_U_4(dat) & L2TP_FRAMING_CAP_ASYNC_MASK) {
361 ND_PRINT("A");
362 }
363 if (GET_BE_U_4(dat) & L2TP_FRAMING_CAP_SYNC_MASK) {
364 ND_PRINT("S");
365 }
366 }
367
368 static void
369 l2tp_bearer_cap_print(netdissect_options *ndo, const u_char *dat, u_int length)
370 {
371 if (length < 4) {
372 ND_PRINT("AVP too short");
373 return;
374 }
375 if (GET_BE_U_4(dat) & L2TP_BEARER_CAP_ANALOG_MASK) {
376 ND_PRINT("A");
377 }
378 if (GET_BE_U_4(dat) & L2TP_BEARER_CAP_DIGITAL_MASK) {
379 ND_PRINT("D");
380 }
381 }
382
383 static void
384 l2tp_q931_cc_print(netdissect_options *ndo, const u_char *dat, u_int length)
385 {
386 if (length < 3) {
387 ND_PRINT("AVP too short");
388 return;
389 }
390 print_16bits_val(ndo, dat);
391 ND_PRINT(", %02x", GET_U_1(dat + 2));
392 dat += 3;
393 length -= 3;
394 if (length != 0) {
395 ND_PRINT(" ");
396 print_string(ndo, dat, length);
397 }
398 }
399
400 static void
401 l2tp_bearer_type_print(netdissect_options *ndo, const u_char *dat, u_int length)
402 {
403 if (length < 4) {
404 ND_PRINT("AVP too short");
405 return;
406 }
407 if (GET_BE_U_4(dat) & L2TP_BEARER_TYPE_ANALOG_MASK) {
408 ND_PRINT("A");
409 }
410 if (GET_BE_U_4(dat) & L2TP_BEARER_TYPE_DIGITAL_MASK) {
411 ND_PRINT("D");
412 }
413 }
414
415 static void
416 l2tp_framing_type_print(netdissect_options *ndo, const u_char *dat, u_int length)
417 {
418 if (length < 4) {
419 ND_PRINT("AVP too short");
420 return;
421 }
422 if (GET_BE_U_4(dat) & L2TP_FRAMING_TYPE_ASYNC_MASK) {
423 ND_PRINT("A");
424 }
425 if (GET_BE_U_4(dat) & L2TP_FRAMING_TYPE_SYNC_MASK) {
426 ND_PRINT("S");
427 }
428 }
429
430 static void
431 l2tp_packet_proc_delay_print(netdissect_options *ndo)
432 {
433 ND_PRINT("obsolete");
434 }
435
436 static void
437 l2tp_proxy_auth_type_print(netdissect_options *ndo, const u_char *dat, u_int length)
438 {
439 if (length < 2) {
440 ND_PRINT("AVP too short");
441 return;
442 }
443 ND_PRINT("%s", tok2str(l2tp_authentype2str,
444 "AuthType-#%u", GET_BE_U_2(dat)));
445 }
446
447 static void
448 l2tp_proxy_auth_id_print(netdissect_options *ndo, const u_char *dat, u_int length)
449 {
450 if (length < 2) {
451 ND_PRINT("AVP too short");
452 return;
453 }
454 ND_PRINT("%u", GET_BE_U_2(dat) & L2TP_PROXY_AUTH_ID_MASK);
455 }
456
457 static void
458 l2tp_call_errors_print(netdissect_options *ndo, const u_char *dat, u_int length)
459 {
460 uint32_t val;
461
462 if (length < 2) {
463 ND_PRINT("AVP too short");
464 return;
465 }
466 dat += 2; /* skip "Reserved" */
467 length -= 2;
468
469 if (length < 4) {
470 ND_PRINT("AVP too short");
471 return;
472 }
473 val = GET_BE_U_4(dat); dat += 4; length -= 4;
474 ND_PRINT("CRCErr=%u ", val);
475
476 if (length < 4) {
477 ND_PRINT("AVP too short");
478 return;
479 }
480 val = GET_BE_U_4(dat); dat += 4; length -= 4;
481 ND_PRINT("FrameErr=%u ", val);
482
483 if (length < 4) {
484 ND_PRINT("AVP too short");
485 return;
486 }
487 val = GET_BE_U_4(dat); dat += 4; length -= 4;
488 ND_PRINT("HardOver=%u ", val);
489
490 if (length < 4) {
491 ND_PRINT("AVP too short");
492 return;
493 }
494 val = GET_BE_U_4(dat); dat += 4; length -= 4;
495 ND_PRINT("BufOver=%u ", val);
496
497 if (length < 4) {
498 ND_PRINT("AVP too short");
499 return;
500 }
501 val = GET_BE_U_4(dat); dat += 4; length -= 4;
502 ND_PRINT("Timeout=%u ", val);
503
504 if (length < 4) {
505 ND_PRINT("AVP too short");
506 return;
507 }
508 val = GET_BE_U_4(dat); dat += 4; length -= 4;
509 ND_PRINT("AlignErr=%u ", val);
510 }
511
512 static void
513 l2tp_accm_print(netdissect_options *ndo, const u_char *dat, u_int length)
514 {
515 uint32_t val;
516
517 if (length < 2) {
518 ND_PRINT("AVP too short");
519 return;
520 }
521 dat += 2; /* skip "Reserved" */
522 length -= 2;
523
524 if (length < 4) {
525 ND_PRINT("AVP too short");
526 return;
527 }
528 val = GET_BE_U_4(dat); dat += 4; length -= 4;
529 ND_PRINT("send=%08x ", val);
530
531 if (length < 4) {
532 ND_PRINT("AVP too short");
533 return;
534 }
535 val = GET_BE_U_4(dat); dat += 4; length -= 4;
536 ND_PRINT("recv=%08x ", val);
537 }
538
539 static void
540 l2tp_ppp_discon_cc_print(netdissect_options *ndo, const u_char *dat, u_int length)
541 {
542 if (length < 5) {
543 ND_PRINT("AVP too short");
544 return;
545 }
546 /* Disconnect Code */
547 ND_PRINT("%04x, ", GET_BE_U_2(dat));
548 dat += 2;
549 length -= 2;
550 /* Control Protocol Number */
551 ND_PRINT("%04x ", GET_BE_U_2(dat));
552 dat += 2;
553 length -= 2;
554 /* Direction */
555 ND_PRINT("%s", tok2str(l2tp_cc_direction2str,
556 "Direction-#%u", GET_U_1(dat)));
557 dat++;
558 length--;
559
560 if (length != 0) {
561 ND_PRINT(" ");
562 print_string(ndo, (const u_char *)dat, length);
563 }
564 }
565
566 static u_int
567 l2tp_avp_print(netdissect_options *ndo, const u_char *dat, u_int length)
568 {
569 u_int len;
570 uint16_t attr_type;
571 int hidden = FALSE;
572
573 ND_PRINT(" ");
574 /* Flags & Length */
575 len = GET_BE_U_2(dat) & L2TP_AVP_HDR_LEN_MASK;
576
577 /* If it is not long enough to contain the header, we'll give up. */
578 ND_ICHECKMSG_U("AVP length", len, <, 6);
579
580 /* If it goes past the end of the remaining length of the packet,
581 we'll give up. */
582 if (len > length) {
583 ND_PRINT(" (len > %u)", length);
584 goto invalid;
585 }
586
587 /* If it goes past the end of the remaining length of the captured
588 data, we'll give up. */
589 ND_TCHECK_LEN(dat, len);
590
591 /*
592 * After this point, we don't need to check whether we go past
593 * the length of the captured data; however, we *do* need to
594 * check whether we go past the end of the AVP.
595 */
596
597 if (GET_BE_U_2(dat) & L2TP_AVP_HDR_FLAG_MANDATORY) {
598 ND_PRINT("*");
599 }
600 if (GET_BE_U_2(dat) & L2TP_AVP_HDR_FLAG_HIDDEN) {
601 hidden = TRUE;
602 ND_PRINT("?");
603 }
604 dat += 2;
605
606 if (GET_BE_U_2(dat)) {
607 /* Vendor Specific Attribute */
608 ND_PRINT("VENDOR%04x:", GET_BE_U_2(dat)); dat += 2;
609 ND_PRINT("ATTR%04x", GET_BE_U_2(dat)); dat += 2;
610 ND_PRINT("(");
611 print_octets(ndo, dat, len-6);
612 ND_PRINT(")");
613 } else {
614 /* IETF-defined Attributes */
615 dat += 2;
616 attr_type = GET_BE_U_2(dat); dat += 2;
617 ND_PRINT("%s", tok2str(l2tp_avp2str, "AVP-#%u", attr_type));
618 ND_PRINT("(");
619 if (hidden) {
620 ND_PRINT("???");
621 } else {
622 switch (attr_type) {
623 case L2TP_AVP_MSGTYPE:
624 l2tp_msgtype_print(ndo, dat, len-6);
625 break;
626 case L2TP_AVP_RESULT_CODE:
627 l2tp_result_code_print(ndo, dat, len-6);
628 break;
629 case L2TP_AVP_PROTO_VER:
630 l2tp_proto_ver_print(ndo, dat, len-6);
631 break;
632 case L2TP_AVP_FRAMING_CAP:
633 l2tp_framing_cap_print(ndo, dat, len-6);
634 break;
635 case L2TP_AVP_BEARER_CAP:
636 l2tp_bearer_cap_print(ndo, dat, len-6);
637 break;
638 case L2TP_AVP_TIE_BREAKER:
639 if (len-6 < 8) {
640 ND_PRINT("AVP too short");
641 break;
642 }
643 print_octets(ndo, dat, 8);
644 break;
645 case L2TP_AVP_FIRM_VER:
646 case L2TP_AVP_ASSND_TUN_ID:
647 case L2TP_AVP_RECV_WIN_SIZE:
648 case L2TP_AVP_ASSND_SESS_ID:
649 if (len-6 < 2) {
650 ND_PRINT("AVP too short");
651 break;
652 }
653 print_16bits_val(ndo, dat);
654 break;
655 case L2TP_AVP_HOST_NAME:
656 case L2TP_AVP_VENDOR_NAME:
657 case L2TP_AVP_CALLING_NUMBER:
658 case L2TP_AVP_CALLED_NUMBER:
659 case L2TP_AVP_SUB_ADDRESS:
660 case L2TP_AVP_PROXY_AUTH_NAME:
661 case L2TP_AVP_PRIVATE_GRP_ID:
662 print_string(ndo, dat, len-6);
663 break;
664 case L2TP_AVP_CHALLENGE:
665 case L2TP_AVP_INI_RECV_LCP:
666 case L2TP_AVP_LAST_SENT_LCP:
667 case L2TP_AVP_LAST_RECV_LCP:
668 case L2TP_AVP_PROXY_AUTH_CHAL:
669 case L2TP_AVP_PROXY_AUTH_RESP:
670 case L2TP_AVP_RANDOM_VECTOR:
671 print_octets(ndo, dat, len-6);
672 break;
673 case L2TP_AVP_Q931_CC:
674 l2tp_q931_cc_print(ndo, dat, len-6);
675 break;
676 case L2TP_AVP_CHALLENGE_RESP:
677 if (len-6 < 16) {
678 ND_PRINT("AVP too short");
679 break;
680 }
681 print_octets(ndo, dat, 16);
682 break;
683 case L2TP_AVP_CALL_SER_NUM:
684 case L2TP_AVP_MINIMUM_BPS:
685 case L2TP_AVP_MAXIMUM_BPS:
686 case L2TP_AVP_TX_CONN_SPEED:
687 case L2TP_AVP_PHY_CHANNEL_ID:
688 case L2TP_AVP_RX_CONN_SPEED:
689 if (len-6 < 4) {
690 ND_PRINT("AVP too short");
691 break;
692 }
693 print_32bits_val(ndo, dat);
694 break;
695 case L2TP_AVP_BEARER_TYPE:
696 l2tp_bearer_type_print(ndo, dat, len-6);
697 break;
698 case L2TP_AVP_FRAMING_TYPE:
699 l2tp_framing_type_print(ndo, dat, len-6);
700 break;
701 case L2TP_AVP_PACKET_PROC_DELAY:
702 l2tp_packet_proc_delay_print(ndo);
703 break;
704 case L2TP_AVP_PROXY_AUTH_TYPE:
705 l2tp_proxy_auth_type_print(ndo, dat, len-6);
706 break;
707 case L2TP_AVP_PROXY_AUTH_ID:
708 l2tp_proxy_auth_id_print(ndo, dat, len-6);
709 break;
710 case L2TP_AVP_CALL_ERRORS:
711 l2tp_call_errors_print(ndo, dat, len-6);
712 break;
713 case L2TP_AVP_ACCM:
714 l2tp_accm_print(ndo, dat, len-6);
715 break;
716 case L2TP_AVP_SEQ_REQUIRED:
717 break; /* No Attribute Value */
718 case L2TP_AVP_PPP_DISCON_CC:
719 l2tp_ppp_discon_cc_print(ndo, dat, len-6);
720 break;
721 default:
722 break;
723 }
724 }
725 ND_PRINT(")");
726 }
727
728 return (len);
729
730 invalid:
731 return (0);
732 }
733
734
735 void
736 l2tp_print(netdissect_options *ndo, const u_char *dat, u_int length)
737 {
738 const u_char *ptr = dat;
739 u_int cnt = 0; /* total octets consumed */
740 uint16_t pad;
741 int flag_t, flag_l, flag_s, flag_o;
742 uint16_t l2tp_len;
743
744 ndo->ndo_protocol = "l2tp";
745 flag_t = flag_l = flag_s = flag_o = FALSE;
746
747 if ((GET_BE_U_2(ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2TP) {
748 ND_PRINT(" l2tp:");
749 } else if ((GET_BE_U_2(ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2F) {
750 ND_PRINT(" l2f:");
751 return; /* nothing to do */
752 } else {
753 ND_PRINT(" Unknown Version, neither L2F(1) nor L2TP(2)");
754 return; /* nothing we can do */
755 }
756
757 ND_PRINT("[");
758 if (GET_BE_U_2(ptr) & L2TP_FLAG_TYPE) {
759 flag_t = TRUE;
760 ND_PRINT("T");
761 }
762 if (GET_BE_U_2(ptr) & L2TP_FLAG_LENGTH) {
763 flag_l = TRUE;
764 ND_PRINT("L");
765 }
766 if (GET_BE_U_2(ptr) & L2TP_FLAG_SEQUENCE) {
767 flag_s = TRUE;
768 ND_PRINT("S");
769 }
770 if (GET_BE_U_2(ptr) & L2TP_FLAG_OFFSET) {
771 flag_o = TRUE;
772 ND_PRINT("O");
773 }
774 if (GET_BE_U_2(ptr) & L2TP_FLAG_PRIORITY)
775 ND_PRINT("P");
776 ND_PRINT("]");
777
778 ptr += 2;
779 cnt += 2;
780
781 if (flag_l) {
782 l2tp_len = GET_BE_U_2(ptr);
783 ptr += 2;
784 cnt += 2;
785 } else {
786 l2tp_len = 0;
787 }
788 /* Tunnel ID */
789 ND_PRINT("(%u/", GET_BE_U_2(ptr));
790 ptr += 2;
791 cnt += 2;
792 /* Session ID */
793 ND_PRINT("%u)", GET_BE_U_2(ptr));
794 ptr += 2;
795 cnt += 2;
796
797 if (flag_s) {
798 ND_PRINT("Ns=%u,", GET_BE_U_2(ptr));
799 ptr += 2;
800 cnt += 2;
801 ND_PRINT("Nr=%u", GET_BE_U_2(ptr));
802 ptr += 2;
803 cnt += 2;
804 }
805
806 if (flag_o) { /* Offset Size */
807 pad = GET_BE_U_2(ptr);
808 /* Offset padding octets in packet buffer? */
809 ND_TCHECK_LEN(ptr + 2, pad);
810 ptr += (2 + pad);
811 cnt += (2 + pad);
812 }
813
814 if (flag_l) {
815 if (length < l2tp_len) {
816 ND_PRINT(" Length %u larger than packet", l2tp_len);
817 goto invalid;
818 }
819 length = l2tp_len;
820 }
821 if (length < cnt) {
822 ND_PRINT(" Length %u smaller than header length", length);
823 goto invalid;
824 }
825 if (flag_t) {
826 if (!flag_l) {
827 ND_PRINT(" No length");
828 goto invalid;
829 }
830 if (length - cnt == 0) {
831 ND_PRINT(" ZLB");
832 } else {
833 /*
834 * Print AVPs.
835 */
836 while (length - cnt != 0) {
837 u_int avp_length;
838
839 avp_length = l2tp_avp_print(ndo, ptr, length - cnt);
840 if (avp_length == 0) {
841 goto invalid;
842 }
843 cnt += avp_length;
844 ptr += avp_length;
845 }
846 }
847 } else {
848 ND_PRINT(" {");
849 ppp_print(ndo, ptr, length - cnt);
850 ND_PRINT("}");
851 }
852 return;
853 invalid:
854 nd_print_invalid(ndo);
855 }
[mirror] the TCPdump network dissector