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