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