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