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 static const char tstr[] = " [|l2tp]";
  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 */
 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                 ND_PRINT((ndo, "%c", *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((ndo, "%02x", *dat++));
 281         }
 282 }
 283
 284 static void
 285 print_16bits_val(netdissect_options *ndo, const uint16_t *dat)
 286 {
 287         ND_PRINT((ndo, "%u", EXTRACT_16BITS(dat)));
 288 }
 289
 290 static void
 291 print_32bits_val(netdissect_options *ndo, const uint32_t *dat)
 292 {
 293         ND_PRINT((ndo, "%lu", (u_long)EXTRACT_32BITS(dat)));
 294 }
 295
 296 /***********************************/
 297 /* AVP-specific print out routines */
 298 /***********************************/
 299 static void
 300 l2tp_msgtype_print(netdissect_options *ndo, const u_char *dat)
 301 {
 302         const uint16_t *ptr = (const uint16_t *)dat;
 303
 304         ND_PRINT((ndo, "%s", tok2str(l2tp_msgtype2str, "MSGTYPE-#%u",
 305             EXTRACT_16BITS(ptr))));
 306 }
 307
 308 static void
 309 l2tp_result_code_print(netdissect_options *ndo, const u_char *dat, u_int length)
 310 {
 311         const uint16_t *ptr = (const uint16_t *)dat;
 312
 313         ND_PRINT((ndo, "%u", EXTRACT_16BITS(ptr))); ptr++;      /* Result Code */
 314         if (length > 2) {                               /* Error Code (opt) */
 315                 ND_PRINT((ndo, "/%u", EXTRACT_16BITS(ptr))); ptr++;
 316         }
 317         if (length > 4) {                               /* Error Message (opt) */
 318                 ND_PRINT((ndo, " "));
 319                 print_string(ndo, (const u_char *)ptr, length - 4);
 320         }
 321 }
 322
 323 static void
 324 l2tp_proto_ver_print(netdissect_options *ndo, const uint16_t *dat)
 325 {
 326         ND_PRINT((ndo, "%u.%u", (EXTRACT_16BITS(dat) >> 8),
 327             (EXTRACT_16BITS(dat) & 0xff)));
 328 }
 329
 330 static void
 331 l2tp_framing_cap_print(netdissect_options *ndo, const u_char *dat)
 332 {
 333         const uint32_t *ptr = (const uint32_t *)dat;
 334
 335         if (EXTRACT_32BITS(ptr) &  L2TP_FRAMING_CAP_ASYNC_MASK) {
 336                 ND_PRINT((ndo, "A"));
 337         }
 338         if (EXTRACT_32BITS(ptr) &  L2TP_FRAMING_CAP_SYNC_MASK) {
 339                 ND_PRINT((ndo, "S"));
 340         }
 341 }
 342
 343 static void
 344 l2tp_bearer_cap_print(netdissect_options *ndo, const u_char *dat)
 345 {
 346         const uint32_t *ptr = (const uint32_t *)dat;
 347
 348         if (EXTRACT_32BITS(ptr) &  L2TP_BEARER_CAP_ANALOG_MASK) {
 349                 ND_PRINT((ndo, "A"));
 350         }
 351         if (EXTRACT_32BITS(ptr) &  L2TP_BEARER_CAP_DIGITAL_MASK) {
 352                 ND_PRINT((ndo, "D"));
 353         }
 354 }
 355
 356 static void
 357 l2tp_q931_cc_print(netdissect_options *ndo, const u_char *dat, u_int length)
 358 {
 359         print_16bits_val(ndo, (const uint16_t *)dat);
 360         ND_PRINT((ndo, ", %02x", dat[2]));
 361         if (length > 3) {
 362                 ND_PRINT((ndo, " "));
 363                 print_string(ndo, dat+3, length-3);
 364         }
 365 }
 366
 367 static void
 368 l2tp_bearer_type_print(netdissect_options *ndo, const u_char *dat)
 369 {
 370         const uint32_t *ptr = (const uint32_t *)dat;
 371
 372         if (EXTRACT_32BITS(ptr) &  L2TP_BEARER_TYPE_ANALOG_MASK) {
 373                 ND_PRINT((ndo, "A"));
 374         }
 375         if (EXTRACT_32BITS(ptr) &  L2TP_BEARER_TYPE_DIGITAL_MASK) {
 376                 ND_PRINT((ndo, "D"));
 377         }
 378 }
 379
 380 static void
 381 l2tp_framing_type_print(netdissect_options *ndo, const u_char *dat)
 382 {
 383         const uint32_t *ptr = (const uint32_t *)dat;
 384
 385         if (EXTRACT_32BITS(ptr) &  L2TP_FRAMING_TYPE_ASYNC_MASK) {
 386                 ND_PRINT((ndo, "A"));
 387         }
 388         if (EXTRACT_32BITS(ptr) &  L2TP_FRAMING_TYPE_SYNC_MASK) {
 389                 ND_PRINT((ndo, "S"));
 390         }
 391 }
 392
 393 static void
 394 l2tp_packet_proc_delay_print(netdissect_options *ndo)
 395 {
 396         ND_PRINT((ndo, "obsolete"));
 397 }
 398
 399 static void
 400 l2tp_proxy_auth_type_print(netdissect_options *ndo, const u_char *dat)
 401 {
 402         const uint16_t *ptr = (const uint16_t *)dat;
 403
 404         ND_PRINT((ndo, "%s", tok2str(l2tp_authentype2str,
 405                              "AuthType-#%u", EXTRACT_16BITS(ptr))));
 406 }
 407
 408 static void
 409 l2tp_proxy_auth_id_print(netdissect_options *ndo, const u_char *dat)
 410 {
 411         const uint16_t *ptr = (const uint16_t *)dat;
 412
 413         ND_PRINT((ndo, "%u", EXTRACT_16BITS(ptr) & L2TP_PROXY_AUTH_ID_MASK));
 414 }
 415
 416 static void
 417 l2tp_call_errors_print(netdissect_options *ndo, const u_char *dat)
 418 {
 419         const uint16_t *ptr = (const uint16_t *)dat;
 420         uint16_t val_h, val_l;
 421
 422         ptr++;          /* skip "Reserved" */
 423
 424         val_h = EXTRACT_16BITS(ptr); ptr++;
 425         val_l = EXTRACT_16BITS(ptr); ptr++;
 426         ND_PRINT((ndo, "CRCErr=%u ", (val_h<<16) + val_l));
 427
 428         val_h = EXTRACT_16BITS(ptr); ptr++;
 429         val_l = EXTRACT_16BITS(ptr); ptr++;
 430         ND_PRINT((ndo, "FrameErr=%u ", (val_h<<16) + val_l));
 431
 432         val_h = EXTRACT_16BITS(ptr); ptr++;
 433         val_l = EXTRACT_16BITS(ptr); ptr++;
 434         ND_PRINT((ndo, "HardOver=%u ", (val_h<<16) + val_l));
 435
 436         val_h = EXTRACT_16BITS(ptr); ptr++;
 437         val_l = EXTRACT_16BITS(ptr); ptr++;
 438         ND_PRINT((ndo, "BufOver=%u ", (val_h<<16) + val_l));
 439
 440         val_h = EXTRACT_16BITS(ptr); ptr++;
 441         val_l = EXTRACT_16BITS(ptr); ptr++;
 442         ND_PRINT((ndo, "Timeout=%u ", (val_h<<16) + val_l));
 443
 444         val_h = EXTRACT_16BITS(ptr); ptr++;
 445         val_l = EXTRACT_16BITS(ptr); ptr++;
 446         ND_PRINT((ndo, "AlignErr=%u ", (val_h<<16) + val_l));
 447 }
 448
 449 static void
 450 l2tp_accm_print(netdissect_options *ndo, const u_char *dat)
 451 {
 452         const uint16_t *ptr = (const uint16_t *)dat;
 453         uint16_t val_h, val_l;
 454
 455         ptr++;          /* skip "Reserved" */
 456
 457         val_h = EXTRACT_16BITS(ptr); ptr++;
 458         val_l = EXTRACT_16BITS(ptr); ptr++;
 459         ND_PRINT((ndo, "send=%08x ", (val_h<<16) + val_l));
 460
 461         val_h = EXTRACT_16BITS(ptr); ptr++;
 462         val_l = EXTRACT_16BITS(ptr); ptr++;
 463         ND_PRINT((ndo, "recv=%08x ", (val_h<<16) + val_l));
 464 }
 465
 466 static void
 467 l2tp_ppp_discon_cc_print(netdissect_options *ndo, const u_char *dat, u_int length)
 468 {
 469         const uint16_t *ptr = (const uint16_t *)dat;
 470
 471         ND_PRINT((ndo, "%04x, ", EXTRACT_16BITS(ptr))); ptr++;  /* Disconnect Code */
 472         ND_PRINT((ndo, "%04x ",  EXTRACT_16BITS(ptr))); ptr++;  /* Control Protocol Number */
 473         ND_PRINT((ndo, "%s", tok2str(l2tp_cc_direction2str,
 474                              "Direction-#%u", *((const u_char *)ptr++))));
 475
 476         if (length > 5) {
 477                 ND_PRINT((ndo, " "));
 478                 print_string(ndo, (const u_char *)ptr, length-5);
 479         }
 480 }
 481
 482 static void
 483 l2tp_avp_print(netdissect_options *ndo, const u_char *dat, int length)
 484 {
 485         u_int len;
 486         const uint16_t *ptr = (const uint16_t *)dat;
 487         uint16_t attr_type;
 488         int hidden = FALSE;
 489
 490         if (length <= 0) {
 491                 return;
 492         }
 493
 494         ND_PRINT((ndo, " "));
 495
 496         ND_TCHECK(*ptr);        /* Flags & Length */
 497         len = EXTRACT_16BITS(ptr) & L2TP_AVP_HDR_LEN_MASK;
 498
 499         /* If it is not long enough to contain the header, we'll give up. */
 500         if (len < 6)
 501                 goto trunc;
 502
 503         /* If it goes past the end of the remaining length of the packet,
 504            we'll give up. */
 505         if (len > (u_int)length)
 506                 goto trunc;
 507
 508         /* If it goes past the end of the remaining length of the captured
 509            data, we'll give up. */
 510         ND_TCHECK2(*ptr, len);
 511         /* After this point, no need to worry about truncation */
 512
 513         if (EXTRACT_16BITS(ptr) & L2TP_AVP_HDR_FLAG_MANDATORY) {
 514                 ND_PRINT((ndo, "*"));
 515         }
 516         if (EXTRACT_16BITS(ptr) & L2TP_AVP_HDR_FLAG_HIDDEN) {
 517                 hidden = TRUE;
 518                 ND_PRINT((ndo, "?"));
 519         }
 520         ptr++;
 521
 522         if (EXTRACT_16BITS(ptr)) {
 523                 /* Vendor Specific Attribute */
 524                 ND_PRINT((ndo, "VENDOR%04x:", EXTRACT_16BITS(ptr))); ptr++;
 525                 ND_PRINT((ndo, "ATTR%04x", EXTRACT_16BITS(ptr))); ptr++;
 526                 ND_PRINT((ndo, "("));
 527                 print_octets(ndo, (const u_char *)ptr, len-6);
 528                 ND_PRINT((ndo, ")"));
 529         } else {
 530                 /* IETF-defined Attributes */
 531                 ptr++;
 532                 attr_type = EXTRACT_16BITS(ptr); ptr++;
 533                 ND_PRINT((ndo, "%s", tok2str(l2tp_avp2str, "AVP-#%u", attr_type)));
 534                 ND_PRINT((ndo, "("));
 535                 if (hidden) {
 536                         ND_PRINT((ndo, "???"));
 537                 } else {
 538                         switch (attr_type) {
 539                         case L2TP_AVP_MSGTYPE:
 540                                 l2tp_msgtype_print(ndo, (const u_char *)ptr);
 541                                 break;
 542                         case L2TP_AVP_RESULT_CODE:
 543                                 l2tp_result_code_print(ndo, (const u_char *)ptr, len-6);
 544                                 break;
 545                         case L2TP_AVP_PROTO_VER:
 546                                 l2tp_proto_ver_print(ndo, ptr);
 547                                 break;
 548                         case L2TP_AVP_FRAMING_CAP:
 549                                 l2tp_framing_cap_print(ndo, (const u_char *)ptr);
 550                                 break;
 551                         case L2TP_AVP_BEARER_CAP:
 552                                 l2tp_bearer_cap_print(ndo, (const u_char *)ptr);
 553                                 break;
 554                         case L2TP_AVP_TIE_BREAKER:
 555                                 print_octets(ndo, (const u_char *)ptr, 8);
 556                                 break;
 557                         case L2TP_AVP_FIRM_VER:
 558                         case L2TP_AVP_ASSND_TUN_ID:
 559                         case L2TP_AVP_RECV_WIN_SIZE:
 560                         case L2TP_AVP_ASSND_SESS_ID:
 561                                 print_16bits_val(ndo, ptr);
 562                                 break;
 563                         case L2TP_AVP_HOST_NAME:
 564                         case L2TP_AVP_VENDOR_NAME:
 565                         case L2TP_AVP_CALLING_NUMBER:
 566                         case L2TP_AVP_CALLED_NUMBER:
 567                         case L2TP_AVP_SUB_ADDRESS:
 568                         case L2TP_AVP_PROXY_AUTH_NAME:
 569                         case L2TP_AVP_PRIVATE_GRP_ID:
 570                                 print_string(ndo, (const u_char *)ptr, len-6);
 571                                 break;
 572                         case L2TP_AVP_CHALLENGE:
 573                         case L2TP_AVP_INI_RECV_LCP:
 574                         case L2TP_AVP_LAST_SENT_LCP:
 575                         case L2TP_AVP_LAST_RECV_LCP:
 576                         case L2TP_AVP_PROXY_AUTH_CHAL:
 577                         case L2TP_AVP_PROXY_AUTH_RESP:
 578                         case L2TP_AVP_RANDOM_VECTOR:
 579                                 print_octets(ndo, (const u_char *)ptr, len-6);
 580                                 break;
 581                         case L2TP_AVP_Q931_CC:
 582                                 l2tp_q931_cc_print(ndo, (const u_char *)ptr, len-6);
 583                                 break;
 584                         case L2TP_AVP_CHALLENGE_RESP:
 585                                 print_octets(ndo, (const u_char *)ptr, 16);
 586                                 break;
 587                         case L2TP_AVP_CALL_SER_NUM:
 588                         case L2TP_AVP_MINIMUM_BPS:
 589                         case L2TP_AVP_MAXIMUM_BPS:
 590                         case L2TP_AVP_TX_CONN_SPEED:
 591                         case L2TP_AVP_PHY_CHANNEL_ID:
 592                         case L2TP_AVP_RX_CONN_SPEED:
 593                                 print_32bits_val(ndo, (const uint32_t *)ptr);
 594                                 break;
 595                         case L2TP_AVP_BEARER_TYPE:
 596                                 l2tp_bearer_type_print(ndo, (const u_char *)ptr);
 597                                 break;
 598                         case L2TP_AVP_FRAMING_TYPE:
 599                                 l2tp_framing_type_print(ndo, (const u_char *)ptr);
 600                                 break;
 601                         case L2TP_AVP_PACKET_PROC_DELAY:
 602                                 l2tp_packet_proc_delay_print(ndo);
 603                                 break;
 604                         case L2TP_AVP_PROXY_AUTH_TYPE:
 605                                 l2tp_proxy_auth_type_print(ndo, (const u_char *)ptr);
 606                                 break;
 607                         case L2TP_AVP_PROXY_AUTH_ID:
 608                                 l2tp_proxy_auth_id_print(ndo, (const u_char *)ptr);
 609                                 break;
 610                         case L2TP_AVP_CALL_ERRORS:
 611                                 l2tp_call_errors_print(ndo, (const u_char *)ptr);
 612                                 break;
 613                         case L2TP_AVP_ACCM:
 614                                 l2tp_accm_print(ndo, (const u_char *)ptr);
 615                                 break;
 616                         case L2TP_AVP_SEQ_REQUIRED:
 617                                 break;  /* No Attribute Value */
 618                         case L2TP_AVP_PPP_DISCON_CC:
 619                                 l2tp_ppp_discon_cc_print(ndo, (const u_char *)ptr, len-6);
 620                                 break;
 621                         default:
 622                                 break;
 623                         }
 624                 }
 625                 ND_PRINT((ndo, ")"));
 626         }
 627
 628         l2tp_avp_print(ndo, dat+len, length-len);
 629         return;
 630
 631  trunc:
 632         ND_PRINT((ndo, "|..."));
 633 }
 634
 635
 636 void
 637 l2tp_print(netdissect_options *ndo, const u_char *dat, u_int length)
 638 {
 639         const u_char *ptr = dat;
 640         u_int cnt = 0;                  /* total octets consumed */
 641         uint16_t pad;
 642         int flag_t, flag_l, flag_s, flag_o;
 643         uint16_t l2tp_len;
 644
 645         flag_t = flag_l = flag_s = flag_o = FALSE;
 646
 647         ND_TCHECK2(*ptr, 2);    /* Flags & Version */
 648         if ((EXTRACT_16BITS(ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2TP) {
 649                 ND_PRINT((ndo, " l2tp:"));
 650         } else if ((EXTRACT_16BITS(ptr) & L2TP_VERSION_MASK) == L2TP_VERSION_L2F) {
 651                 ND_PRINT((ndo, " l2f:"));
 652                 return;         /* nothing to do */
 653         } else {
 654                 ND_PRINT((ndo, " Unknown Version, neither L2F(1) nor L2TP(2)"));
 655                 return;         /* nothing we can do */
 656         }
 657
 658         ND_PRINT((ndo, "["));
 659         if (EXTRACT_16BITS(ptr) & L2TP_FLAG_TYPE) {
 660                 flag_t = TRUE;
 661                 ND_PRINT((ndo, "T"));
 662         }
 663         if (EXTRACT_16BITS(ptr) & L2TP_FLAG_LENGTH) {
 664                 flag_l = TRUE;
 665                 ND_PRINT((ndo, "L"));
 666         }
 667         if (EXTRACT_16BITS(ptr) & L2TP_FLAG_SEQUENCE) {
 668                 flag_s = TRUE;
 669                 ND_PRINT((ndo, "S"));
 670         }
 671         if (EXTRACT_16BITS(ptr) & L2TP_FLAG_OFFSET) {
 672                 flag_o = TRUE;
 673                 ND_PRINT((ndo, "O"));
 674         }
 675         if (EXTRACT_16BITS(ptr) & L2TP_FLAG_PRIORITY)
 676                 ND_PRINT((ndo, "P"));
 677         ND_PRINT((ndo, "]"));
 678
 679         ptr += 2;
 680         cnt += 2;
 681
 682         if (flag_l) {
 683                 ND_TCHECK2(*ptr, 2);    /* Length */
 684                 l2tp_len = EXTRACT_16BITS(ptr);
 685                 ptr += 2;
 686                 cnt += 2;
 687         } else {
 688                 l2tp_len = 0;
 689         }
 690
 691         ND_TCHECK2(*ptr, 2);            /* Tunnel ID */
 692         ND_PRINT((ndo, "(%u/", EXTRACT_16BITS(ptr)));
 693         ptr += 2;
 694         cnt += 2;
 695         ND_TCHECK2(*ptr, 2);            /* Session ID */
 696         ND_PRINT((ndo, "%u)",  EXTRACT_16BITS(ptr)));
 697         ptr += 2;
 698         cnt += 2;
 699
 700         if (flag_s) {
 701                 ND_TCHECK2(*ptr, 2);    /* Ns */
 702                 ND_PRINT((ndo, "Ns=%u,", EXTRACT_16BITS(ptr)));
 703                 ptr += 2;
 704                 cnt += 2;
 705                 ND_TCHECK2(*ptr, 2);    /* Nr */
 706                 ND_PRINT((ndo, "Nr=%u",  EXTRACT_16BITS(ptr)));
 707                 ptr += 2;
 708                 cnt += 2;
 709         }
 710
 711         if (flag_o) {
 712                 ND_TCHECK2(*ptr, 2);    /* Offset Size */
 713                 pad =  EXTRACT_16BITS(ptr);
 714                 ptr += (2 + pad);
 715                 cnt += (2 + pad);
 716         }
 717
 718         if (flag_l) {
 719                 if (length < l2tp_len) {
 720                         ND_PRINT((ndo, " Length %u larger than packet", l2tp_len));
 721                         return;
 722                 }
 723                 length = l2tp_len;
 724         }
 725         if (length < cnt) {
 726                 ND_PRINT((ndo, " Length %u smaller than header length", length));
 727                 return;
 728         }
 729         if (flag_t) {
 730                 if (!flag_l) {
 731                         ND_PRINT((ndo, " No length"));
 732                         return;
 733                 }
 734                 if (length - cnt == 0) {
 735                         ND_PRINT((ndo, " ZLB"));
 736                 } else {
 737                         l2tp_avp_print(ndo, ptr, length - cnt);
 738                 }
 739         } else {
 740                 ND_PRINT((ndo, " {"));
 741                 ppp_print(ndo, ptr, length - cnt);
 742                 ND_PRINT((ndo, "}"));
 743         }
 744
 745         return;
 746
 747  trunc:
 748         ND_PRINT((ndo, "%s", tstr));
 749 }