epan/dissectors/packet-lapdm.c

   1 /* packet-lapdm.c
   2  * Routines for LAPDm frame disassembly
   3  * Duncan Salerno <duncan.salerno@googlemail.com>
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998
   8  *
   9  * SPDX-License-Identifier: GPL-2.0-or-later
  10  */
  11
  12 /* LAPDm references:
  13  *
  14  * Mobile Station - Base Stations System (MS - BSS) Interface Data Link (DL) Layer Specification
  15  * Base Station Controller - Base Transceiver Station (BSC - BTS) interface; Layer 2 specification
  16  * http://www.3gpp.org/ftp/Specs/html-info/44006.htm
  17  *
  18  * From 3GPP TS 44.006:
  19  *
  20  * LAPDm is used for information sent on the control channels BCCH, AGCH, NCH,
  21  * PCH, FACCH, SACCH and SDCCH as defined in 3GPP TS 44.003.
  22  *
  23  * AGCH, NCH and PCH are sometimes referred to by the collective name CCCH.
  24  * FACCH, SACCH and SDCCH are, similarly, referred to by the collective name DCCH.
  25  *
  26  * Format A is used on DCCHs for frames where there is no information field.
  27  * Formats B, Bter and B4 are used on DCCHs for frames containing an information field:
  28  * Format Bter is used on request of higher layers if and only if short L2 header type 1 is
  29  * supported and a UI command is to be transmitted on SAPI 0;
  30  * Format B4 is used for UI frames transmitted by the network on SACCH;
  31  * Format B is applied in all other cases.
  32  * Format Bbis is used only on BCCH, PCH, NCH, and AGCH.
  33  * In addition there is a Format C for transmission of random access signals.
  34  *
  35  * This module currently supports A, B, B4
  36  * In the future will support Bter
  37  * Bbis and C should be supported elsewhere
  38  */
  39
  40 #include "config.h"
  41 #include "packet-lapdm.h"
  42
  43 #include <epan/packet.h>
  44 #include <epan/prefs.h>
  45 #include <epan/xdlc.h>
  46 #include <epan/reassemble.h>
  47 #include <epan/conversation.h>
  48
  49 void proto_register_lapdm(void);
  50
  51 static dissector_handle_t b4_info_handle;
  52
  53 static int proto_lapdm;
  54 static int hf_lapdm_address;
  55 static int hf_lapdm_ea;
  56 static int hf_lapdm_cr;
  57 static int hf_lapdm_sapi;
  58 static int hf_lapdm_lpd;
  59
  60 static int hf_lapdm_control;
  61 static int hf_lapdm_n_r;
  62 static int hf_lapdm_n_s;
  63 static int hf_lapdm_p;
  64 static int hf_lapdm_f;
  65 static int hf_lapdm_s_ftype;
  66 static int hf_lapdm_u_modifier_cmd;
  67 static int hf_lapdm_u_modifier_resp;
  68 static int hf_lapdm_ftype_i;
  69 static int hf_lapdm_ftype_s_u;
  70
  71 static int hf_lapdm_length;
  72 static int hf_lapdm_el;
  73 static int hf_lapdm_m;
  74 static int hf_lapdm_len;
  75
  76 /*
  77  * LAPDm fragment handling
  78  */
  79 static int hf_lapdm_fragment_data;
  80 static int hf_lapdm_fragments;
  81 static int hf_lapdm_fragment;
  82 static int hf_lapdm_fragment_overlap;
  83 static int hf_lapdm_fragment_overlap_conflicts;
  84 static int hf_lapdm_fragment_multiple_tails;
  85 static int hf_lapdm_fragment_too_long_fragment;
  86 static int hf_lapdm_fragment_error;
  87 static int hf_lapdm_fragment_count;
  88 static int hf_lapdm_reassembled_in;
  89 static int hf_lapdm_reassembled_length;
  90
  91 static int ett_lapdm;
  92 static int ett_lapdm_address;
  93 static int ett_lapdm_control;
  94 static int ett_lapdm_length;
  95 static int ett_lapdm_fragment;
  96 static int ett_lapdm_fragments;
  97
  98 static reassembly_table lapdm_reassembly_table;
  99
 100 static wmem_map_t *lapdm_last_n_s_map;
 101
 102 static dissector_table_t lapdm_sapi_dissector_table;
 103
 104 static bool reassemble_lapdm = true;
 105
 106 /*
 107  * Bits in the address field.
 108  */
 109 #define LAPDM_SAPI              0x1c    /* Service Access Point Identifier */
 110 #define LAPDM_SAPI_SHIFT        2
 111 #define LAPDM_CR                0x02    /* Command/Response bit */
 112 #define LAPDM_EA                0x01    /* First Address Extension bit */
 113 #define LAPDM_LPD               0x60    /* Link Protocol Discriminator */
 114
 115 /*
 116  * Bits in the length field.
 117  */
 118 #define LAPDM_EL                0x01    /* Extended Length = 1 */
 119 #define LAPDM_M                 0x02    /* More fragments */
 120 #define LAPDM_M_SHIFT           1
 121 #define LAPDM_LEN               0xfc    /* Length */
 122 #define LAPDM_LEN_SHIFT         2
 123
 124 #define LAPDM_HEADER_LEN 3
 125 #define LAPDM_HEADER_LEN_B4 2
 126
 127 #define LAPDM_SAPI_RR_CC_MM     0
 128 #define LAPDM_SAPI_SMS          3
 129
 130 /* Used only for U frames */
 131 static const xdlc_cf_items lapdm_cf_items = {
 132     &hf_lapdm_n_r,
 133     &hf_lapdm_n_s,
 134     &hf_lapdm_p,
 135     &hf_lapdm_f,
 136     &hf_lapdm_s_ftype,
 137     &hf_lapdm_u_modifier_cmd,
 138     &hf_lapdm_u_modifier_resp,
 139     &hf_lapdm_ftype_i,
 140     &hf_lapdm_ftype_s_u
 141 };
 142
 143 static const value_string lapdm_ea_vals[] = {
 144     { 0,                "More octets" },
 145     { 1,                "Final octet" },
 146     { 0,                NULL }
 147 };
 148
 149 static const value_string lapdm_sapi_vals[] = {
 150     { LAPDM_SAPI_RR_CC_MM,      "RR/MM/CC" },
 151     { LAPDM_SAPI_SMS,           "SMS/SS" },
 152     { 0,                        NULL }
 153 };
 154
 155 static const value_string lapdm_lpd_vals[] = {
 156     { 0,                "Normal GSM" },
 157     { 1,                "Cell broadcast service" },
 158     { 0,                NULL }
 159 };
 160
 161 static const value_string lapdm_m_vals[] = {
 162     { 0,                "Last segment" },
 163     { 1,                "More segments" },
 164     { 0,                NULL }
 165 };
 166
 167 static const value_string lapdm_el_vals[] = {
 168     { 0,                "More octets" },
 169     { 1,                "Final octet" },
 170     { 0,                NULL }
 171 };
 172
 173
 174 static const fragment_items lapdm_frag_items = {
 175     /* Fragment subtrees */
 176     &ett_lapdm_fragment,
 177     &ett_lapdm_fragments,
 178     /* Fragment fields */
 179     &hf_lapdm_fragments,
 180     &hf_lapdm_fragment,
 181     &hf_lapdm_fragment_overlap,
 182     &hf_lapdm_fragment_overlap_conflicts,
 183     &hf_lapdm_fragment_multiple_tails,
 184     &hf_lapdm_fragment_too_long_fragment,
 185     &hf_lapdm_fragment_error,
 186     &hf_lapdm_fragment_count,
 187     /* Reassembled in field */
 188     &hf_lapdm_reassembled_in,
 189     /* Reassembled length field */
 190     &hf_lapdm_reassembled_length,
 191     /* Reassembled data field */
 192     NULL,
 193     /* Tag */
 194     "fragments"
 195 };
 196
 197 static bool hdr_has_length(enum lapdm_hdr_type hdr_type)
 198 {
 199     switch (hdr_type) {
 200     case LAPDM_HDR_FMT_A:
 201     case LAPDM_HDR_FMT_B:
 202         return true;
 203     default:
 204         return false;
 205     }
 206 }
 207
 208
 209 static int
 210 dissect_lapdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
 211 {
 212     proto_tree *lapdm_tree, *addr_tree, *length_tree;
 213     proto_item *lapdm_ti, *addr_ti, *length_ti;
 214     uint8_t addr, length, header_len, cr, sapi, len, n_s;
 215     int control;
 216     bool m;
 217     tvbuff_t *payload;
 218     int available_length;
 219     bool is_response = false;
 220     enum lapdm_hdr_type hdr_type = LAPDM_HDR_FMT_B;
 221     bool is_acch = false, is_ui_frame = false;
 222
 223     if (data) {
 224         lapdm_data_t *ld = (lapdm_data_t *) data;
 225         is_acch = ld->is_acch;
 226     }
 227
 228     /* Check that there's enough data */
 229     if (tvb_captured_length(tvb) < LAPDM_HEADER_LEN_B4)
 230         return 0;
 231
 232     control = tvb_get_uint8(tvb, 1);
 233     is_ui_frame = (control & XDLC_S_U_MASK) == XDLC_U && (control & XDLC_U_MODIFIER_MASK) == XDLC_UI;
 234
 235     /* only downlink UI SACCH frames use B4 header format */
 236     if (is_acch && is_ui_frame && pinfo->p2p_dir == P2P_DIR_RECV) {
 237         hdr_type = LAPDM_HDR_FMT_B4;
 238         header_len = LAPDM_HEADER_LEN_B4;
 239         length = 0;
 240     } else {
 241         header_len = LAPDM_HEADER_LEN;
 242
 243         /* Check that there's enough data */
 244         if (tvb_captured_length(tvb) < header_len)
 245             return 0;
 246
 247         length = tvb_get_uint8(tvb, 2);
 248     }
 249
 250     col_set_str(pinfo->cinfo, COL_PROTOCOL, "LAPDm");
 251
 252     addr = tvb_get_uint8(tvb, 0);
 253
 254     cr = addr & LAPDM_CR;
 255     if (pinfo->p2p_dir == P2P_DIR_RECV) {
 256         is_response = cr ? false : true;
 257     }
 258     else if (pinfo->p2p_dir == P2P_DIR_SENT) {
 259         is_response = cr ? true : false;
 260     }
 261
 262     if (tree) {
 263         lapdm_ti = proto_tree_add_item(tree, proto_lapdm, tvb, 0, header_len, ENC_NA);
 264         lapdm_tree = proto_item_add_subtree(lapdm_ti, ett_lapdm);
 265
 266         addr_ti = proto_tree_add_uint(lapdm_tree, hf_lapdm_address, tvb, 0, 1, addr);
 267         addr_tree = proto_item_add_subtree(addr_ti, ett_lapdm_address);
 268
 269         proto_tree_add_uint(addr_tree, hf_lapdm_lpd, tvb, 0, 1, addr);
 270         proto_tree_add_uint(addr_tree, hf_lapdm_sapi, tvb, 0, 1, addr);
 271         proto_tree_add_uint(addr_tree, hf_lapdm_cr, tvb, 0, 1, addr);
 272         proto_tree_add_uint(addr_tree, hf_lapdm_ea, tvb, 0, 1, addr);
 273     }
 274     else {
 275         lapdm_ti = NULL;
 276         lapdm_tree = NULL;
 277     }
 278
 279     control = dissect_xdlc_control(tvb, 1, pinfo, lapdm_tree, hf_lapdm_control,
 280                                    ett_lapdm_control, &lapdm_cf_items, NULL /* LAPDm doesn't support extended */, NULL, NULL,
 281                                    is_response, false, false);
 282
 283     /* dissect length field (if present) */
 284     if (tree && hdr_has_length(hdr_type)) {
 285         length_ti = proto_tree_add_uint(lapdm_tree, hf_lapdm_length, tvb,
 286                                         2, 1, length);
 287         length_tree = proto_item_add_subtree(length_ti, ett_lapdm_length);
 288
 289         proto_tree_add_uint(length_tree, hf_lapdm_len, tvb, 2, 1, length);
 290         proto_tree_add_uint(length_tree, hf_lapdm_m, tvb, 2, 1, length);
 291         proto_tree_add_uint(length_tree, hf_lapdm_el, tvb, 2, 1, length);
 292     }
 293
 294     if (hdr_has_length(hdr_type)) {
 295         len = (length & LAPDM_LEN) >> LAPDM_LEN_SHIFT;
 296         m = (length & LAPDM_M) >> LAPDM_M_SHIFT;
 297     } else {
 298         len = tvb_captured_length(tvb) - header_len;
 299         m = 0;
 300     }
 301
 302     sapi = (addr & LAPDM_SAPI) >> LAPDM_SAPI_SHIFT;
 303     n_s = (control & XDLC_N_S_MASK) >> XDLC_N_S_SHIFT;
 304     available_length = tvb_captured_length(tvb) - header_len;
 305
 306     /* No point in doing anything if no payload
 307      */
 308     if( !MIN(len, available_length) )
 309         return 2;
 310
 311     payload = tvb_new_subset_length_caplen(tvb, header_len, MIN(len,available_length), len);
 312
 313     /* Potentially segmented I frame
 314      */
 315     if( (control & XDLC_I_MASK) == XDLC_I && reassemble_lapdm && !pinfo->flags.in_error_pkt )
 316     {
 317         fragment_head *fd_m = NULL;
 318         tvbuff_t *reassembled = NULL;
 319         uint32_t fragment_id;
 320         bool save_fragmented = pinfo->fragmented, add_frag;
 321
 322         pinfo->fragmented = m;
 323
 324         /* Rely on caller to provide a way to group fragments */
 325         fragment_id =  (conversation_get_id_from_elements(pinfo, CONVERSATION_GSMTAP, USE_LAST_ENDPOINT) << 4) | (sapi << 1) | pinfo->p2p_dir;
 326
 327         if (!PINFO_FD_VISITED(pinfo)) {
 328             /* Check if new N(S) is equal to previous N(S) (to avoid adding retransmissions in reassembly table)
 329                As GUINT_TO_POINTER macro does not allow to differentiate NULL from 0, use 1-8 range instead of 0-7 */
 330             unsigned *p_last_n_s = (unsigned*)wmem_map_lookup(lapdm_last_n_s_map, GUINT_TO_POINTER(fragment_id));
 331             if (GPOINTER_TO_UINT(p_last_n_s) == (unsigned)(n_s+1)) {
 332                 add_frag = false;
 333             } else {
 334                 add_frag = true;
 335                 wmem_map_insert(lapdm_last_n_s_map, GUINT_TO_POINTER(fragment_id), GUINT_TO_POINTER(n_s+1));
 336             }
 337         } else {
 338             add_frag = true;
 339         }
 340
 341         if (add_frag) {
 342             /* This doesn't seem the best way of doing it as doesn't
 343             take N(S) into account, but N(S) isn't always 0 for
 344             the first fragment!
 345             */
 346             fd_m = fragment_add_seq_next (&lapdm_reassembly_table, payload, 0,
 347                                         pinfo,
 348                                         fragment_id, /* uint32_t ID for fragments belonging together */
 349                                         NULL,
 350                                         /*n_s uint32_t fragment sequence number */
 351                                         len, /* uint32_t fragment length */
 352                                         m); /* More fragments? */
 353
 354             reassembled = process_reassembled_data(payload, 0, pinfo,
 355                                                 "Reassembled LAPDm", fd_m, &lapdm_frag_items,
 356                                                 NULL, lapdm_tree);
 357
 358             /* Reassembled into this packet
 359             */
 360             if (fd_m && pinfo->num == fd_m->reassembled_in) {
 361                 if (!dissector_try_uint(lapdm_sapi_dissector_table, sapi,
 362                                         reassembled, pinfo, tree))
 363                     call_data_dissector(reassembled, pinfo, tree);
 364
 365                 if (!PINFO_FD_VISITED(pinfo)) {
 366                     /* If reassembling is done, allow fragment_id reuse */
 367                     wmem_map_remove(lapdm_last_n_s_map, GUINT_TO_POINTER(fragment_id));
 368                 }
 369             }
 370             else {
 371                 col_append_str(pinfo->cinfo, COL_INFO, " (Fragment)");
 372                 proto_tree_add_item(lapdm_tree, hf_lapdm_fragment_data, payload, 0, -1, ENC_NA);
 373             }
 374         }
 375
 376         /* Now reset fragmentation information in pinfo
 377          */
 378         pinfo->fragmented = save_fragmented;
 379     }
 380     else if (hdr_type == LAPDM_HDR_FMT_B4)
 381     {
 382         /* B4 frames have no length octet at L2 level, but instead a L2 pseudo length octet
 383          * at L3.  We must call the proper dissector for decoding them */
 384         call_dissector(b4_info_handle, payload, pinfo, tree);
 385     }
 386     else
 387     {
 388         if (!PINFO_FD_VISITED(pinfo) && ((control & XDLC_S_U_MASK) == XDLC_U) && ((control & XDLC_U_MODIFIER_MASK) == XDLC_SABM)) {
 389             /* SABM frame; reset the last N(S) to an invalid value */
 390             uint32_t fragment_id = (conversation_get_id_from_elements(pinfo, CONVERSATION_GSMTAP, USE_LAST_ENDPOINT) << 4) | (sapi << 1) | pinfo->p2p_dir;
 391             wmem_map_insert(lapdm_last_n_s_map, GUINT_TO_POINTER(fragment_id), GUINT_TO_POINTER(0));
 392         }
 393
 394         /* Whole packet
 395            If we have some data, try and dissect it (only happens for UI, SABM, UA or I frames)
 396         */
 397         if (!dissector_try_uint(lapdm_sapi_dissector_table, sapi,
 398                                 payload, pinfo, tree))
 399             call_data_dissector(payload, pinfo, tree);
 400     }
 401     return tvb_captured_length(tvb);
 402 }
 403
 404 void
 405 proto_register_lapdm(void)
 406 {
 407     static hf_register_info hf[] = {
 408
 409         { &hf_lapdm_address,
 410           { "Address Field", "lapdm.address_field", FT_UINT8, BASE_HEX, NULL, 0x0,
 411             NULL, HFILL }},
 412
 413         { &hf_lapdm_ea,
 414           { "EA", "lapdm.ea", FT_UINT8, BASE_DEC, VALS(lapdm_ea_vals), LAPDM_EA,
 415             "Address field extension bit", HFILL }},
 416
 417         { &hf_lapdm_cr,
 418           { "C/R", "lapdm.cr", FT_UINT8, BASE_DEC, NULL, LAPDM_CR,
 419             "Command/response field bit", HFILL }},
 420
 421         { &hf_lapdm_lpd,
 422           { "LPD", "lapdm.lpd", FT_UINT8, BASE_DEC, VALS(lapdm_lpd_vals), LAPDM_LPD,
 423             "Link Protocol Discriminator", HFILL }},
 424
 425         { &hf_lapdm_sapi,
 426           { "SAPI", "lapdm.sapi", FT_UINT8, BASE_DEC, VALS(lapdm_sapi_vals), LAPDM_SAPI,
 427             "Service access point identifier", HFILL }},
 428
 429         { &hf_lapdm_control,
 430           { "Control Field", "lapdm.control_field", FT_UINT8, BASE_HEX, NULL, 0x0,
 431             NULL, HFILL }},
 432
 433         { &hf_lapdm_n_r,
 434           { "N(R)", "lapdm.control.n_r", FT_UINT8, BASE_DEC,
 435             NULL, XDLC_N_R_MASK, NULL, HFILL }},
 436
 437         { &hf_lapdm_n_s,
 438           { "N(S)", "lapdm.control.n_s", FT_UINT8, BASE_DEC,
 439             NULL, XDLC_N_S_MASK, NULL, HFILL }},
 440
 441         { &hf_lapdm_p,
 442           { "Poll", "lapdm.control.p", FT_BOOLEAN, 8,
 443             NULL, XDLC_P_F, NULL, HFILL }},
 444
 445         { &hf_lapdm_f,
 446           { "Final", "lapdm.control.f", FT_BOOLEAN, 8,
 447             NULL, XDLC_P_F, NULL, HFILL }},
 448
 449         { &hf_lapdm_s_ftype,
 450           { "Supervisory frame type", "lapdm.control.s_ftype", FT_UINT8, BASE_HEX,
 451             VALS(stype_vals), XDLC_S_FTYPE_MASK, NULL, HFILL }},
 452
 453         { &hf_lapdm_u_modifier_cmd,
 454           { "Command", "lapdm.control.u_modifier_cmd", FT_UINT8, BASE_HEX,
 455             VALS(modifier_vals_cmd), XDLC_U_MODIFIER_MASK, NULL, HFILL }},
 456
 457         { &hf_lapdm_u_modifier_resp,
 458           { "Response", "lapdm.control.u_modifier_resp", FT_UINT8, BASE_HEX,
 459             VALS(modifier_vals_resp), XDLC_U_MODIFIER_MASK, NULL, HFILL }},
 460
 461         { &hf_lapdm_ftype_i,
 462           { "Frame type", "lapdm.control.ftype", FT_UINT8, BASE_HEX,
 463             VALS(ftype_vals), XDLC_I_MASK, NULL, HFILL }},
 464
 465         { &hf_lapdm_ftype_s_u,
 466           { "Frame type", "lapdm.control.ftype", FT_UINT8, BASE_HEX,
 467             VALS(ftype_vals), XDLC_S_U_MASK, NULL, HFILL }},
 468
 469         { &hf_lapdm_length,
 470           { "Length Field", "lapdm.length_field", FT_UINT8, BASE_HEX,
 471             NULL, 0x0, NULL, HFILL }},
 472
 473         { &hf_lapdm_el,
 474           { "EL", "lapdm.el", FT_UINT8, BASE_DEC,
 475             VALS(lapdm_el_vals), LAPDM_EL, "Length indicator field extension bit", HFILL }},
 476
 477         { &hf_lapdm_m,
 478           { "M", "lapdm.m", FT_UINT8, BASE_DEC,
 479             VALS(lapdm_m_vals), LAPDM_M, "More data bit", HFILL }},
 480
 481         { &hf_lapdm_len,
 482           { "Length", "lapdm.length", FT_UINT8, BASE_DEC,
 483             NULL, LAPDM_LEN, "Length indicator", HFILL }},
 484
 485         /* Fragment reassembly
 486          */
 487         { &hf_lapdm_fragment_data,
 488           { "Fragment Data", "lapdm.fragment_data", FT_NONE, BASE_NONE,
 489             NULL, 0x00, NULL, HFILL }},
 490
 491         { &hf_lapdm_fragments,
 492           { "Message fragments", "lapdm.fragments", FT_NONE, BASE_NONE,
 493             NULL, 0x00, "LAPDm Message fragments", HFILL }},
 494
 495         { &hf_lapdm_fragment,
 496           { "Message fragment", "lapdm.fragment", FT_FRAMENUM, BASE_NONE,
 497             NULL, 0x00, "LAPDm Message fragment", HFILL }},
 498
 499         { &hf_lapdm_fragment_overlap,
 500           { "Message fragment overlap", "lapdm.fragment.overlap", FT_BOOLEAN, BASE_NONE,
 501             NULL, 0x0, "LAPDm Message fragment overlaps with other fragment(s)", HFILL }},
 502
 503         { &hf_lapdm_fragment_overlap_conflicts,
 504           { "Message fragment overlapping with conflicting data", "lapdm.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE,
 505             NULL, 0x0, "LAPDm Message fragment overlaps with conflicting data", HFILL }},
 506
 507         { &hf_lapdm_fragment_multiple_tails,
 508           { "Message has multiple tail fragments", "lapdm.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE,
 509             NULL, 0x0, "LAPDm Message fragment has multiple tail fragments", HFILL }},
 510
 511         { &hf_lapdm_fragment_too_long_fragment,
 512           { "Message fragment too long", "lapdm.fragment.too_long_fragment", FT_BOOLEAN, BASE_NONE,
 513             NULL, 0x0, "LAPDm Message fragment data goes beyond the packet end", HFILL }},
 514
 515         { &hf_lapdm_fragment_error,
 516           { "Message defragmentation error", "lapdm.fragment.error", FT_FRAMENUM, BASE_NONE,
 517             NULL, 0x00, "LAPDm Message defragmentation error due to illegal fragments", HFILL }},
 518
 519         { &hf_lapdm_fragment_count,
 520           { "Message fragment count", "lapdm.fragment.count", FT_UINT32, BASE_DEC,
 521             NULL, 0x00, NULL, HFILL }},
 522
 523         { &hf_lapdm_reassembled_in,
 524           { "Reassembled in", "lapdm.reassembled.in", FT_FRAMENUM, BASE_NONE,
 525             NULL, 0x00, "LAPDm Message has been reassembled in this packet.", HFILL }},
 526
 527         { &hf_lapdm_reassembled_length,
 528           { "Reassembled LAPDm length", "lapdm.reassembled.length", FT_UINT32, BASE_DEC,
 529             NULL, 0x00, "The total length of the reassembled payload", HFILL }}
 530
 531     };
 532     static int *ett[] = {
 533         &ett_lapdm,
 534         &ett_lapdm_address,
 535         &ett_lapdm_control,
 536         &ett_lapdm_length,
 537         &ett_lapdm_fragment,
 538         &ett_lapdm_fragments
 539     };
 540
 541     module_t *lapdm_module;
 542
 543     proto_lapdm = proto_register_protocol("Link Access Procedure, Channel Dm (LAPDm)", "LAPDm", "lapdm");
 544     proto_register_field_array (proto_lapdm, hf, array_length(hf));
 545     proto_register_subtree_array(ett, array_length(ett));
 546
 547     register_dissector("lapdm", dissect_lapdm, proto_lapdm);
 548
 549     lapdm_sapi_dissector_table = register_dissector_table("lapdm.sapi", "LAPDm SAPI", proto_lapdm, FT_UINT8, BASE_DEC);
 550
 551     lapdm_module = prefs_register_protocol(proto_lapdm, NULL);
 552     prefs_register_bool_preference(lapdm_module, "reassemble",
 553                                    "Reassemble fragmented LAPDm packets",
 554                                    "Whether the dissector should defragment LAPDm messages spanning multiple packets.",
 555                                    &reassemble_lapdm);
 556
 557     lapdm_last_n_s_map = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), g_direct_hash, g_direct_equal);
 558
 559     reassembly_table_register(&lapdm_reassembly_table,
 560                            &addresses_reassembly_table_functions);
 561
 562     /* B4 frames have no length octet at L2 level, but instead a L2 pseudo length octet
 563      * at L3.  We must call the proper dissector for decoding them, and gsm_a_ccch supports
 564      * L2 pseudo length */
 565     b4_info_handle = find_dissector_add_dependency("gsm_a_ccch", proto_lapdm);
 566 }
 567
 568 /*
 569  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 570  *
 571  * Local variables:
 572  * c-basic-offset: 4
 573  * tab-width: 8
 574  * indent-tabs-mode: nil
 575  * End:
 576  *
 577  * vi: set shiftwidth=4 tabstop=8 expandtab:
 578  * :indentSize=4:tabSize=8:noTabs=true:
 579  */