epan/dissectors/packet-v5dl.c

   1 /* packet-v5dl.c
   2  * Routines for V5 data link frame disassembly
   3  * Rolf Fiedler <rolf.fiedler@innoventif.de> using the LAPD code of
   4  * Gilbert Ramirez <gram@alumni.rice.edu>
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998
   9  *
  10  * SPDX-License-Identifier: GPL-2.0-or-later
  11  */
  12 /*
  13  * V5 Data Link Layer
  14  *
  15  * V5 references:
  16  * ETS 300 324-1
  17  * ETS 300 347-1
  18  *
  19  */
  20
  21 #include "config.h"
  22
  23 #include <epan/packet.h>
  24 #include <epan/expert.h>
  25 #include <epan/xdlc.h>
  26 #include <epan/tfs.h>
  27 #include <wsutil/array.h>
  28
  29 void proto_register_v5dl(void);
  30
  31 static int proto_v5dl;
  32 static int hf_v5dl_direction;
  33 /* static int hf_v5dl_address; */
  34 static int hf_v5dl_ef;
  35 static int hf_v5dl_eah;
  36 static int hf_v5dl_cr;
  37 static int hf_v5dl_ea1;
  38 static int hf_v5dl_eal;
  39 static int hf_v5dl_ea2;
  40 static int hf_v5dl_control;
  41 static int hf_v5dl_n_r;
  42 static int hf_v5dl_n_s;
  43 static int hf_v5dl_p;
  44 static int hf_v5dl_p_ext;
  45 static int hf_v5dl_f;
  46 static int hf_v5dl_f_ext;
  47 static int hf_v5dl_s_ftype;
  48 static int hf_v5dl_u_modifier_cmd;
  49 static int hf_v5dl_u_modifier_resp;
  50 static int hf_v5dl_ftype_i;
  51 static int hf_v5dl_ftype_s_u;
  52 static int hf_v5dl_ftype_s_u_ext;
  53 #if 0
  54 static int hf_v5dl_checksum;
  55 static int hf_v5dl_checksum_status;
  56 #endif
  57 static int ett_v5dl;
  58 static int ett_v5dl_address;
  59 static int ett_v5dl_control;
  60 /* static int ett_v5dl_checksum; */
  61
  62 static expert_field ei_v5dl_checksum;
  63
  64 static dissector_handle_t v52_handle;
  65
  66 /*
  67  * Bits in the address field.
  68  */
  69 #define V5DL_EAH                0xfc00  /* Service Access Point Identifier */
  70 #define V5DL_EAH_SHIFT          10
  71 #define V5DL_CR                 0x0200  /* Command/Response bit */
  72 #define V5DL_EA1                0x0100  /* First Address Extension bit */
  73 #define V5DL_EAL                0x00fe  /* Terminal Endpoint Identifier */
  74 #define V5DL_EAL_SHIFT          1
  75 #define V5DL_EA2                0x0001  /* Second Address Extension bit */
  76
  77 static const value_string v5dl_direction_vals[] = {
  78         { P2P_DIR_RECV,         "Network->User"},
  79         { P2P_DIR_SENT,         "User->Network"},
  80         { 0,                    NULL }
  81 };
  82
  83 static const value_string v5dl_addr_vals[] = {
  84         { 8175, "ISDN Protocol" },
  85         { 8176, "PSTN Protocol" },
  86         { 8177, "CONTROL Protocol" },
  87         { 8178, "BCC Protocol" },
  88         { 8179, "PROT Protocol" },
  89         { 8180, "Link Control Protocol" },
  90         { 8191, "VALUE RESERVED" },
  91         { 0,    NULL } };
  92
  93 /* Used only for U frames */
  94 static const xdlc_cf_items v5dl_cf_items = {
  95         NULL,
  96         NULL,
  97         &hf_v5dl_p,
  98         &hf_v5dl_f,
  99         NULL,
 100         &hf_v5dl_u_modifier_cmd,
 101         &hf_v5dl_u_modifier_resp,
 102         NULL,
 103         &hf_v5dl_ftype_s_u
 104 };
 105
 106 /* Used only for I and S frames */
 107 static const xdlc_cf_items v5dl_cf_items_ext = {
 108         &hf_v5dl_n_r,
 109         &hf_v5dl_n_s,
 110         &hf_v5dl_p_ext,
 111         &hf_v5dl_f_ext,
 112         &hf_v5dl_s_ftype,
 113         NULL,
 114         NULL,
 115         &hf_v5dl_ftype_i,
 116         &hf_v5dl_ftype_s_u_ext
 117 };
 118
 119
 120 #define MAX_V5DL_PACKET_LEN 1024
 121
 122 static int
 123 dissect_v5dl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 124 {
 125         proto_tree      *v5dl_tree, *addr_tree;
 126         proto_item      *v5dl_ti, *addr_ti;
 127         int             direction;
 128         unsigned                v5dl_header_len;
 129         uint16_t                control;
 130 #if 0
 131         proto_tree      *checksum_tree;
 132         proto_item      *checksum_ti;
 133         uint16_t                checksum, checksum_calculated;
 134         unsigned                checksum_offset;
 135 #endif
 136         uint16_t                addr, cr, eah, eal, v5addr;
 137         bool    is_response = 0;
 138 #if 0
 139         unsigned                length, reported_length;
 140 #endif
 141         tvbuff_t        *next_tvb;
 142         const char      *srcname = "?";
 143         const char      *dstname = "?";
 144
 145         col_set_str(pinfo->cinfo, COL_PROTOCOL, "V5DL");
 146         col_clear(pinfo->cinfo, COL_INFO);
 147
 148         addr = tvb_get_ntohs(tvb, 0);
 149         cr = addr & V5DL_CR;
 150         eal = (addr & V5DL_EAL) >> V5DL_EAL_SHIFT;
 151         eah = (addr & V5DL_EAH) >> V5DL_EAH_SHIFT;
 152         v5addr = (eah << 7) + eal;
 153         v5dl_header_len = 2;    /* addr */
 154
 155         direction = pinfo->p2p_dir;
 156         if (pinfo->p2p_dir == P2P_DIR_RECV) {
 157             is_response = cr ? false : true;
 158             srcname = "Network";
 159             dstname = "User";
 160         }
 161         else if (pinfo->p2p_dir == P2P_DIR_SENT) {
 162             is_response = cr ? true : false;
 163             srcname = "User";
 164             dstname = "Network";
 165         }
 166
 167         col_set_str(pinfo->cinfo, COL_RES_DL_SRC, srcname);
 168         col_set_str(pinfo->cinfo, COL_RES_DL_DST, dstname);
 169
 170         if (tree) {
 171                 proto_item *direction_ti;
 172
 173                 v5dl_ti = proto_tree_add_item(tree, proto_v5dl, tvb, 0, -1,
 174                     ENC_NA);
 175                 v5dl_tree = proto_item_add_subtree(v5dl_ti, ett_v5dl);
 176
 177                 /*
 178                  * Don't show the direction if we don't know it.
 179                  */
 180                 if (direction != P2P_DIR_UNKNOWN) {
 181                         direction_ti = proto_tree_add_uint(v5dl_tree, hf_v5dl_direction,
 182                                                            tvb, 0, 0, pinfo->p2p_dir);
 183                         proto_item_set_generated(direction_ti);
 184                 }
 185
 186                 addr_ti = proto_tree_add_uint(v5dl_tree, hf_v5dl_ef, tvb,
 187                     0, 2, v5addr);
 188                 addr_tree = proto_item_add_subtree(addr_ti, ett_v5dl_address);
 189                 proto_tree_add_uint(addr_tree, hf_v5dl_eah, tvb, 0, 1, addr);
 190                 proto_tree_add_uint(addr_tree, hf_v5dl_cr,  tvb, 0, 1, addr);
 191                 proto_tree_add_uint(addr_tree, hf_v5dl_ea1, tvb, 0, 1, addr);
 192                 proto_tree_add_uint(addr_tree, hf_v5dl_eal, tvb, 1, 1, addr);
 193                 proto_tree_add_uint(addr_tree, hf_v5dl_ea2, tvb, 1, 1, addr);
 194         }
 195         else {
 196                 v5dl_ti = NULL;
 197                 v5dl_tree = NULL;
 198         }
 199
 200         control = dissect_xdlc_control(tvb, 2, pinfo, v5dl_tree, hf_v5dl_control,
 201             ett_v5dl_control, &v5dl_cf_items, &v5dl_cf_items_ext, NULL, NULL,
 202             is_response, true, false);
 203         v5dl_header_len += XDLC_CONTROL_LEN(control, true);
 204
 205         if (tree)
 206                 proto_item_set_len(v5dl_ti, v5dl_header_len);
 207
 208         /*
 209          * XXX - the sample capture supplied with bug 7027 does not
 210          * appear to include checksums in the packets.
 211          */
 212 #if 0
 213         /*
 214          * Check the checksum, if available.
 215          * The checksum is a CCITT CRC-16 at the end of the packet, so
 216          * if we don't have the entire packet in the capture - i.e., if
 217          * tvb_captured_length(tvb) != tvb_reported_length(tvb) we can't check it.
 218          */
 219         length = tvb_captured_length(tvb);
 220         reported_length = tvb_reported_length(tvb);
 221
 222         /*
 223          * If the reported length isn't big enough for the V5DL header
 224          * and 2 bytes of checksum, the packet is malformed, as the
 225          * checksum overlaps the header.
 226          */
 227         if (reported_length < v5dl_header_len + 2)
 228                 return;
 229
 230         if (length == reported_length) {
 231                 /*
 232                  * There's no snapshot length cutting off any of the
 233                  * packet.
 234                  */
 235                 checksum_offset = reported_length - 2;
 236                 checksum_calculated = crc16_ccitt_tvb(tvb, checksum_offset);
 237                 checksum_calculated = g_htons(checksum_calculated);  /* Note: g_htons() macro may eval arg multiple times */
 238
 239                 proto_tree_add_checksum(v5dl_tree, tvb, checksum_offset, hf_v5dl_checksum, hf_v5dl_checksum_status, &ei_v5dl_checksum,
 240                                                                 pinfo, checksum_calculated, ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
 241                 /*
 242                  * Remove the V5DL header *and* the checksum.
 243                  */
 244                 next_tvb = tvb_new_subset_length_caplen(tvb, v5dl_header_len,
 245                     tvb_captured_length_remaining(tvb, v5dl_header_len) - 2,
 246                     tvb_reported_length_remaining(tvb, v5dl_header_len) - 2);
 247         } else {
 248                 /*
 249                  * Some or all of the packet is cut off by a snapshot
 250                  * length.
 251                  */
 252                 if (length == reported_length - 1) {
 253                         /*
 254                          * One byte is cut off, so there's only one
 255                          * byte of checksum in the captured data.
 256                          * Remove that byte from the captured length
 257                          * and both bytes from the reported length.
 258                          */
 259                         next_tvb = tvb_new_subset_length_caplen(tvb, v5dl_header_len,
 260                             tvb_captured_length_remaining(tvb, v5dl_header_len) - 1,
 261                             tvb_reported_length_remaining(tvb, v5dl_header_len) - 2);
 262                 } else {
 263                         /*
 264                          * Two or more bytes are cut off, so there are
 265                          * no bytes of checksum in the captured data.
 266                          * Just remove the checksum from the reported
 267                          * length.
 268                          */
 269                         next_tvb = tvb_new_subset_length_caplen(tvb, v5dl_header_len,
 270                             tvb_captured_length_remaining(tvb, v5dl_header_len),
 271                             tvb_reported_length_remaining(tvb, v5dl_header_len) - 2);
 272                 }
 273         }
 274 #else
 275         next_tvb = tvb_new_subset_remaining(tvb, v5dl_header_len);
 276 #endif
 277
 278         if (XDLC_IS_INFORMATION(control)) {
 279                 /* call V5.2 dissector */
 280                 call_dissector(v52_handle, next_tvb, pinfo, tree);
 281         }
 282         return tvb_captured_length(tvb);
 283 }
 284
 285 void
 286 proto_reg_handoff_v5dl(void);
 287
 288 void
 289 proto_register_v5dl(void)
 290 {
 291         static hf_register_info hf[] = {
 292
 293         { &hf_v5dl_direction,
 294           { "Direction", "v5dl.direction", FT_UINT8, BASE_DEC, VALS(v5dl_direction_vals), 0x0,
 295                 NULL, HFILL }},
 296
 297 #if 0
 298         { &hf_v5dl_address,
 299           { "Address Field", "v5dl.address", FT_UINT16, BASE_HEX, NULL, 0x0,
 300                 "Address", HFILL }},
 301 #endif
 302
 303         { &hf_v5dl_ef,
 304           { "EF", "v5dl.ef", FT_UINT16, BASE_DEC, VALS(v5dl_addr_vals), 0x0,
 305                 "Envelope Function Address", HFILL }},
 306
 307         { &hf_v5dl_eah,
 308           { "EAH", "v5dl.eah", FT_UINT16, BASE_DEC, NULL, V5DL_EAH,
 309                 "Envelope Address High", HFILL }},
 310
 311         { &hf_v5dl_cr,
 312           { "C/R", "v5dl.cr", FT_UINT16, BASE_DEC, NULL, V5DL_CR,
 313                 "Command/Response bit", HFILL }},
 314
 315         { &hf_v5dl_ea1,
 316           { "EA1", "v5dl.ea1", FT_UINT16, BASE_DEC, NULL, V5DL_EA1,
 317                 "First Address Extension bit", HFILL }},
 318
 319         { &hf_v5dl_eal,
 320           { "EAL", "v5dl.eal", FT_UINT16, BASE_DEC, NULL, V5DL_EAL,
 321                 "Envelope Address Low", HFILL }},
 322
 323         { &hf_v5dl_ea2,
 324           { "EA2", "v5dl.ea2", FT_UINT16, BASE_DEC, NULL, V5DL_EA2,
 325                 "Second Address Extension bit", HFILL }},
 326
 327         { &hf_v5dl_control,
 328           { "Control Field", "v5dl.control", FT_UINT16, BASE_HEX, NULL, 0x0,
 329                 NULL, HFILL }},
 330
 331         { &hf_v5dl_n_r,
 332           { "N(R)", "v5dl.control.n_r", FT_UINT16, BASE_DEC,
 333                 NULL, XDLC_N_R_EXT_MASK, NULL, HFILL }},
 334
 335         { &hf_v5dl_n_s,
 336           { "N(S)", "v5dl.control.n_s", FT_UINT16, BASE_DEC,
 337                 NULL, XDLC_N_S_EXT_MASK, NULL, HFILL }},
 338
 339         { &hf_v5dl_p,
 340           { "Poll", "v5dl.control.p", FT_BOOLEAN, 8,
 341                 TFS(&tfs_set_notset), XDLC_P_F, NULL, HFILL }},
 342
 343         { &hf_v5dl_p_ext,
 344           { "Poll", "v5dl.control.p", FT_BOOLEAN, 16,
 345                 TFS(&tfs_set_notset), XDLC_P_F_EXT, NULL, HFILL }},
 346
 347         { &hf_v5dl_f,
 348           { "Final", "v5dl.control.f", FT_BOOLEAN, 8,
 349                 TFS(&tfs_set_notset), XDLC_P_F, NULL, HFILL }},
 350
 351         { &hf_v5dl_f_ext,
 352           { "Final", "v5dl.control.f", FT_BOOLEAN, 16,
 353                 TFS(&tfs_set_notset), XDLC_P_F_EXT, NULL, HFILL }},
 354
 355         { &hf_v5dl_s_ftype,
 356           { "Supervisory frame type", "v5dl.control.s_ftype", FT_UINT16, BASE_HEX,
 357                 VALS(stype_vals), XDLC_S_FTYPE_MASK, NULL, HFILL }},
 358
 359         { &hf_v5dl_u_modifier_cmd,
 360           { "Command", "v5dl.control.u_modifier_cmd", FT_UINT8, BASE_HEX,
 361                 VALS(modifier_vals_cmd), XDLC_U_MODIFIER_MASK, NULL, HFILL }},
 362
 363         { &hf_v5dl_u_modifier_resp,
 364           { "Response", "v5dl.control.u_modifier_resp", FT_UINT8, BASE_HEX,
 365                 VALS(modifier_vals_resp), XDLC_U_MODIFIER_MASK, NULL, HFILL }},
 366
 367         { &hf_v5dl_ftype_i,
 368           { "Frame type", "v5dl.control.ftype", FT_UINT16, BASE_HEX,
 369                 VALS(ftype_vals), XDLC_I_MASK, NULL, HFILL }},
 370
 371         { &hf_v5dl_ftype_s_u,
 372           { "Frame type", "v5dl.control.ftype", FT_UINT8, BASE_HEX,
 373                 VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL }},
 374
 375         { &hf_v5dl_ftype_s_u_ext,
 376           { "Frame type", "v5dl.control.ftype", FT_UINT16, BASE_HEX,
 377                 VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL }},
 378
 379 #if 0
 380         { &hf_v5dl_checksum,
 381           { "Checksum", "v5dl.checksum", FT_UINT16, BASE_HEX,
 382                 NULL, 0x0, "Details at: https://www.wireshark.org/docs/wsug_html_chunked/ChAdvChecksums.html", HFILL }},
 383
 384         { &hf_v5dl_checksum_status,
 385           { "Checksum Status", "v5dl.checksum.status", FT_UINT8, BASE_NONE,
 386                 VALS(proto_checksum_vals), 0x0, NULL, HFILL }},
 387 #endif
 388         };
 389
 390         static int *ett[] = {
 391                 &ett_v5dl,
 392                 &ett_v5dl_address,
 393                 &ett_v5dl_control,
 394                 /* &ett_v5dl_checksum */
 395         };
 396
 397         static ei_register_info ei[] = {
 398                 { &ei_v5dl_checksum, { "v5dl.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
 399         };
 400
 401         expert_module_t* expert_v5dl;
 402
 403         proto_v5dl = proto_register_protocol("V5 Data Link Layer", "V5DL", "v5dl");
 404         proto_register_field_array (proto_v5dl, hf, array_length(hf));
 405         proto_register_subtree_array(ett, array_length(ett));
 406         expert_v5dl = expert_register_protocol(proto_v5dl);
 407         expert_register_field_array(expert_v5dl, ei, array_length(ei));
 408
 409         register_dissector("v5dl", dissect_v5dl, proto_v5dl);
 410 }
 411
 412 void
 413 proto_reg_handoff_v5dl(void)
 414 {
 415         v52_handle = find_dissector_add_dependency("v52", proto_v5dl);
 416 }
 417
 418 /*
 419  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 420  *
 421  * Local variables:
 422  * c-basic-offset: 8
 423  * tab-width: 8
 424  * indent-tabs-mode: t
 425  * End:
 426  *
 427  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 428  * :indentSize=8:tabSize=8:noTabs=false:
 429  */