epan/dissectors/packet-gsmtap.c

   1 /* packet-gsmtap.c
   2  * Routines for GSMTAP captures
   3  *
   4  * (C) 2008-2013 by Harald Welte <laforge@gnumonks.org>
   5  * (C) 2011 by Holger Hans Peter Freyther
   6  *
   7  * $Id$
   8  *
   9  * Wireshark - Network traffic analyzer
  10  * By Gerald Combs <gerald@wireshark.org>
  11  * Copyright 1998 Gerald Combs
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 /* GSMTAP is a generic header format for GSM protocol captures,
  29  * it uses the IANA-assigned UDP port number 4729 and carries
  30  * payload in various formats of GSM interfaces such as Um MAC
  31  * blocks or Um bursts.
  32  *
  33  * Example programs generating GSMTAP data are airprobe
  34  * (http://airprobe.org/) or OsmocomBB (http://bb.osmocom.org/)
  35  *
  36  * It has also been used for Tetra by the OsmocomTETRA project.
  37  * (http://tetra.osmocom.org/)
  38  *
  39  * GSMTAP also carries payload in various formats of WiMAX interfaces.
  40  * It uses the wimax plugin to decode the WiMAX bursts.
  41  */
  42
  43 #include "config.h"
  44
  45 #include <glib.h>
  46 #include <epan/packet.h>
  47 #include <epan/prefs.h>
  48
  49 #include "packet-tetra.h"
  50 #include "packet-rrc.h"
  51
  52 void proto_register_gsmtap(void);
  53 void proto_reg_handoff_gsmtap(void);
  54
  55 /* ====== DO NOT MAKE UNAPPROVED MODIFICATIONS HERE ===== */
  56 /* The following types and definitions are imported from libosmocore,
  57  * the original source of the GSMTAP format.
  58  *
  59  * prior to getting them accepted/included into the official Osmocom
  60  * GSMTAP definition, available from
  61  * http://cgit.osmocom.org/cgit/libosmocore/tree/include/osmocom/core/gsmtap.h
  62  *
  63  * The GSMTAP maintainer can be contacted via the
  64  * openbsc@lists.osmocom.org mailing list, or by private e-mail
  65  * to laforge@gnumonks.org
  66  */
  67 /* ====== DO NOT MAKE UNAPPROVED MODIFICATIONS HERE ===== */
  68 #define GSMTAP_TYPE_UM                          0x01
  69 #define GSMTAP_TYPE_ABIS                        0x02
  70 #define GSMTAP_TYPE_UM_BURST            0x03    /* raw burst bits */
  71 #define GSMTAP_TYPE_SIM                         0x04
  72 #define GSMTAP_TYPE_TETRA_I1            0x05    /* tetra air interface */
  73 #define GSMTAP_TTPE_TETRA_I1_BURST      0x06    /* tetra air interface */
  74 #define GSMTAP_TYPE_WMX_BURST           0x07    /* WiMAX burst */
  75 #define GSMTAP_TYPE_GB_LLC                      0x08 /* GPRS Gb interface: LLC */
  76 #define GSMTAP_TYPE_GB_SNDCP            0x09 /* GPRS Gb interface: SNDCP */
  77 #define GSMTAP_TYPE_GMR1_UM                             0x0a    /* GMR-1 L2 packets */
  78 #define GSMTAP_TYPE_UMTS_RLC_MAC        0x0b
  79 #define GSMTAP_TYPE_UMTS_RRC            0x0c
  80
  81 /* ====== DO NOT MAKE UNAPPROVED MODIFICATIONS HERE ===== */
  82 #define GSMTAP_BURST_UNKNOWN            0x00
  83 #define GSMTAP_BURST_FCCH                       0x01
  84 #define GSMTAP_BURST_PARTIAL_SCH        0x02
  85 #define GSMTAP_BURST_SCH                        0x03
  86 #define GSMTAP_BURST_CTS_SCH            0x04
  87 #define GSMTAP_BURST_COMPACT_SCH        0x05
  88 #define GSMTAP_BURST_NORMAL                     0x06
  89 #define GSMTAP_BURST_DUMMY                      0x07
  90 #define GSMTAP_BURST_ACCESS                     0x08
  91 #define GSMTAP_BURST_NONE                       0x09
  92 /* WiMAX bursts */
  93 #define GSMTAP_BURST_CDMA_CODE          0x10    /* WiMAX CDMA Code Attribute burst */
  94 #define GSMTAP_BURST_FCH                0x11    /* WiMAX FCH burst */
  95 #define GSMTAP_BURST_FFB                0x12    /* WiMAX Fast Feedback burst */
  96 #define GSMTAP_BURST_PDU                0x13    /* WiMAX PDU burst */
  97 #define GSMTAP_BURST_HACK               0x14    /* WiMAX HARQ ACK burst */
  98 #define GSMTAP_BURST_PHY_ATTRIBUTES     0x15    /* WiMAX PHY Attributes burst */
  99
 100 /* ====== DO NOT MAKE UNAPPROVED MODIFICATIONS HERE ===== */
 101 /* sub-types for TYPE_UM */
 102 #define GSMTAP_CHANNEL_UNKNOWN    0x00
 103 #define GSMTAP_CHANNEL_BCCH       0x01
 104 #define GSMTAP_CHANNEL_CCCH       0x02
 105 #define GSMTAP_CHANNEL_RACH       0x03
 106 #define GSMTAP_CHANNEL_AGCH       0x04
 107 #define GSMTAP_CHANNEL_PCH        0x05
 108 #define GSMTAP_CHANNEL_SDCCH      0x06
 109 #define GSMTAP_CHANNEL_SDCCH4     0x07
 110 #define GSMTAP_CHANNEL_SDCCH8     0x08
 111 #define GSMTAP_CHANNEL_TCH_F      0x09
 112 #define GSMTAP_CHANNEL_TCH_H      0x0a
 113 #define GSMTAP_CHANNEL_PACCH      0x0b
 114 #define GSMTAP_CHANNEL_CBCH52     0x0c
 115 #define GSMTAP_CHANNEL_PDCH       0x0d
 116 #define GSMTAP_CHANNEL_PTCCH      0x0e
 117 #define GSMTAP_CHANNEL_CBCH51     0x0f
 118
 119 /* GPRS Coding Scheme CS1..4 */
 120 #define GSMTAP_GPRS_CS_BASE     0x20
 121 #define GSMTAP_GPRS_CS(N)       (GSMTAP_GPRS_CS_BASE + N)
 122 /* (E) GPRS Coding Scheme MCS0..9 */
 123 #define GSMTAP_GPRS_MCS_BASE    0x30
 124 #define GSMTAP_GPRS_MCS(N)      (GSMTAP_GPRS_MCS_BASE + N)
 125
 126 #define GSMTAP_CHANNEL_ACCH       0x80
 127
 128 /* ====== DO NOT MAKE UNAPPROVED MODIFICATIONS HERE ===== */
 129 /* sub-types for TYPE_TETRA_AIR */
 130 #define GSMTAP_TETRA_BSCH                       0x01
 131 #define GSMTAP_TETRA_AACH                       0x02
 132 #define GSMTAP_TETRA_SCH_HU                     0x03
 133 #define GSMTAP_TETRA_SCH_HD                     0x04
 134 #define GSMTAP_TETRA_SCH_F                      0x05
 135 #define GSMTAP_TETRA_BNCH                       0x06
 136 #define GSMTAP_TETRA_STCH                       0x07
 137 #define GSMTAP_TETRA_TCH_F                      0x08
 138
 139 /* ====== DO NOT MAKE UNAPPROVED MODIFICATIONS HERE ===== */
 140 /* sub-types for TYPE_GMR1 */
 141 #define GSMTAP_GMR1_UNKNOWN                     0x00
 142 #define GSMTAP_GMR1_BCCH                        0x01
 143 #define GSMTAP_GMR1_CCCH                        0x02    /* either AGCH or PCH */
 144 #define GSMTAP_GMR1_PCH                         0x03
 145 #define GSMTAP_GMR1_AGCH                        0x04
 146 #define GSMTAP_GMR1_BACH                        0x05
 147 #define GSMTAP_GMR1_RACH                        0x06
 148 #define GSMTAP_GMR1_CBCH                        0x07
 149 #define GSMTAP_GMR1_SDCCH                       0x08
 150 #define GSMTAP_GMR1_TACCH                       0x09
 151 #define GSMTAP_GMR1_GBCH                        0x0a
 152
 153 #define GSMTAP_GMR1_SACCH                       0x01    /* to be combined with _TCH{6,9}   */
 154 #define GSMTAP_GMR1_FACCH                       0x02    /* to be combines with _TCH{3,6,9} */
 155 #define GSMTAP_GMR1_DKAB                        0x03    /* to be combined with _TCH3 */
 156 #define GSMTAP_GMR1_TCH3                        0x10
 157 #define GSMTAP_GMR1_TCH6                        0x14
 158 #define GSMTAP_GMR1_TCH9                        0x18
 159
 160 #define GSMTAP_ARFCN_F_PCS                      0x8000
 161 #define GSMTAP_ARFCN_F_UPLINK           0x4000
 162 #define GSMTAP_ARFCN_MASK                       0x3fff
 163
 164 #define GSMTAP_UDP_PORT                         4729
 165
 166 /* This is the header as it is used by gsmtap-generating software.
 167  * It is not used by the wireshark dissector and provided for reference only.
 168 struct gsmtap_hdr {
 169         guint8 version;         // version, set to 0x01 currently
 170         guint8 hdr_len;         // length in number of 32bit words
 171         guint8 type;            // see GSMTAP_TYPE_*
 172         guint8 timeslot;        // timeslot (0..7 on Um)
 173
 174         guint16 arfcn;          // ARFCN (frequency)
 175         gint8 signal_dbm;       // signal level in dBm
 176         gint8 snr_db;           // signal/noise ratio in dB
 177
 178         guint32 frame_number;   // GSM Frame Number (FN)
 179
 180         guint8 sub_type;        // Type of burst/channel, see above
 181         guint8 antenna_nr;      // Antenna Number
 182         guint8 sub_slot;        // sub-slot within timeslot
 183         guint8 res;             // reserved for future use (RFU)
 184 }
 185  */
 186
 187 static int proto_gsmtap = -1;
 188
 189 static int hf_gsmtap_version = -1;
 190 static int hf_gsmtap_hdrlen = -1;
 191 static int hf_gsmtap_type = -1;
 192 static int hf_gsmtap_timeslot = -1;
 193 static int hf_gsmtap_subslot = -1;
 194 static int hf_gsmtap_arfcn = -1;
 195 static int hf_gsmtap_uplink = -1;
 196 static int hf_gsmtap_noise_dbm = -1;
 197 static int hf_gsmtap_signal_dbm = -1;
 198 static int hf_gsmtap_frame_nr = -1;
 199 static int hf_gsmtap_burst_type = -1;
 200 static int hf_gsmtap_channel_type = -1;
 201 static int hf_gsmtap_tetra_channel_type = -1;
 202 static int hf_gsmtap_gmr1_channel_type = -1;
 203 static int hf_gsmtap_antenna = -1;
 204
 205 static int hf_sacch_l1h_power_lev = -1;
 206 static int hf_sacch_l1h_fpc = -1;
 207 static int hf_sacch_l1h_ta = -1;
 208
 209 static gint ett_gsmtap = -1;
 210
 211 enum {
 212         GSMTAP_SUB_DATA = 0,
 213         GSMTAP_SUB_UM,
 214         GSMTAP_SUB_UM_LAPDM,
 215         GSMTAP_SUB_UM_RLC_MAC_UL,
 216         GSMTAP_SUB_UM_RLC_MAC_DL,
 217         GSMTAP_SUB_LLC,
 218         GSMTAP_SUB_SNDCP,
 219         GSMTAP_SUB_ABIS,
 220         /* WiMAX sub handles */
 221         GSMTAP_SUB_CDMA_CODE,
 222         GSMTAP_SUB_FCH,
 223         GSMTAP_SUB_FFB,
 224         GSMTAP_SUB_PDU,
 225         GSMTAP_SUB_HACK,
 226         GSMTAP_SUB_PHY_ATTRIBUTES,
 227         GSMTAP_SUB_CBCH,
 228         GSMTAP_SUB_SIM,
 229         /* GMR-1 sub handles */
 230         GSMTAP_SUB_GMR1_BCCH,
 231         GSMTAP_SUB_GMR1_CCCH,
 232         GSMTAP_SUB_GMR1_LAPSAT,
 233         GSMTAP_SUB_GMR1_RACH,
 234         /* UMTS */
 235         GSMTAP_SUB_UMTS_RLC_MAC,
 236         GSMTAP_SUB_UMTS_RRC,
 237
 238         GSMTAP_SUB_MAX
 239 };
 240
 241 enum {
 242         GSMTAP_RRC_SUB_DL_DCCH_Message = 0,
 243         GSMTAP_RRC_SUB_UL_DCCH_Message,
 244         GSMTAP_RRC_SUB_DL_CCCH_Message,
 245         GSMTAP_RRC_SUB_UL_CCCH_Message,
 246         GSMTAP_RRC_SUB_PCCH_Message,
 247         GSMTAP_RRC_SUB_DL_SHCCH_Message,
 248         GSMTAP_RRC_SUB_UL_SHCCH_Message,
 249         GSMTAP_RRC_SUB_BCCH_FACH_Message,
 250         GSMTAP_RRC_SUB_BCCH_BCH_Message,
 251         GSMTAP_RRC_SUB_MCCH_Message,
 252         GSMTAP_RRC_SUB_MSCH_Message,
 253         GSMTAP_RRC_SUB_HandoverToUTRANCommand,
 254         GSMTAP_RRC_SUB_InterRATHandoverInfo,
 255         GSMTAP_RRC_SUB_SystemInformation_BCH,
 256         GSMTAP_RRC_SUB_System_Information_Container,
 257         GSMTAP_RRC_SUB_UE_RadioAccessCapabilityInfo,
 258         GSMTAP_RRC_SUB_MasterInformationBlock,
 259         GSMTAP_RRC_SUB_SysInfoType1,
 260         GSMTAP_RRC_SUB_SysInfoType2,
 261         GSMTAP_RRC_SUB_SysInfoType3,
 262         GSMTAP_RRC_SUB_SysInfoType4,
 263         GSMTAP_RRC_SUB_SysInfoType5,
 264         GSMTAP_RRC_SUB_SysInfoType5bis,
 265         GSMTAP_RRC_SUB_SysInfoType6,
 266         GSMTAP_RRC_SUB_SysInfoType7,
 267         GSMTAP_RRC_SUB_SysInfoType8,
 268         GSMTAP_RRC_SUB_SysInfoType9,
 269         GSMTAP_RRC_SUB_SysInfoType10,
 270         GSMTAP_RRC_SUB_SysInfoType11,
 271         GSMTAP_RRC_SUB_SysInfoType11bis,
 272         GSMTAP_RRC_SUB_SysInfoType12,
 273         GSMTAP_RRC_SUB_SysInfoType13,
 274         GSMTAP_RRC_SUB_SysInfoType13_1,
 275         GSMTAP_RRC_SUB_SysInfoType13_2,
 276         GSMTAP_RRC_SUB_SysInfoType13_3,
 277         GSMTAP_RRC_SUB_SysInfoType13_4,
 278         GSMTAP_RRC_SUB_SysInfoType14,
 279         GSMTAP_RRC_SUB_SysInfoType15,
 280         GSMTAP_RRC_SUB_SysInfoType15bis,
 281         GSMTAP_RRC_SUB_SysInfoType15_1,
 282         GSMTAP_RRC_SUB_SysInfoType15_1bis,
 283         GSMTAP_RRC_SUB_SysInfoType15_2,
 284         GSMTAP_RRC_SUB_SysInfoType15_2bis,
 285         GSMTAP_RRC_SUB_SysInfoType15_2ter,
 286         GSMTAP_RRC_SUB_SysInfoType15_3,
 287         GSMTAP_RRC_SUB_SysInfoType15_3bis,
 288         GSMTAP_RRC_SUB_SysInfoType15_4,
 289         GSMTAP_RRC_SUB_SysInfoType15_5,
 290         GSMTAP_RRC_SUB_SysInfoType15_6,
 291         GSMTAP_RRC_SUB_SysInfoType15_7,
 292         GSMTAP_RRC_SUB_SysInfoType15_8,
 293         GSMTAP_RRC_SUB_SysInfoType16,
 294         GSMTAP_RRC_SUB_SysInfoType17,
 295         GSMTAP_RRC_SUB_SysInfoType18,
 296         GSMTAP_RRC_SUB_SysInfoType19,
 297         GSMTAP_RRC_SUB_SysInfoType20,
 298         GSMTAP_RRC_SUB_SysInfoType21,
 299         GSMTAP_RRC_SUB_SysInfoType22,
 300         GSMTAP_RRC_SUB_SysInfoTypeSB1,
 301         GSMTAP_RRC_SUB_SysInfoTypeSB2,
 302         GSMTAP_RRC_SUB_ToTargetRNC_Container,
 303         GSMTAP_RRC_SUB_TargetRNC_ToSourceRNC_Container,
 304
 305         GSMTAP_RRC_SUB_MAX
 306 };
 307
 308 static dissector_handle_t sub_handles[GSMTAP_SUB_MAX];
 309 static dissector_handle_t rrc_sub_handles[GSMTAP_RRC_SUB_MAX];
 310
 311 static dissector_table_t gsmtap_dissector_table;
 312
 313 static const value_string gsmtap_bursts[] = {
 314         { GSMTAP_BURST_UNKNOWN,         "UNKNOWN" },
 315         { GSMTAP_BURST_FCCH,            "FCCH" },
 316         { GSMTAP_BURST_PARTIAL_SCH,     "PARTIAL SCH" },
 317         { GSMTAP_BURST_SCH,                     "SCH" },
 318         { GSMTAP_BURST_CTS_SCH,         "CTS SCH" },
 319         { GSMTAP_BURST_COMPACT_SCH,     "COMPACT SCH" },
 320         { GSMTAP_BURST_NORMAL,          "NORMAL" },
 321         { GSMTAP_BURST_DUMMY,           "DUMMY" },
 322         { GSMTAP_BURST_ACCESS,          "RACH" },
 323         /* WiMAX bursts */
 324         { GSMTAP_BURST_CDMA_CODE,       "CDMA Code"  },
 325         { GSMTAP_BURST_FCH,             "FCH"  },
 326         { GSMTAP_BURST_FFB,             "Fast Feedback" },
 327         { GSMTAP_BURST_PDU,             "PDU" },
 328         { GSMTAP_BURST_HACK,            "HACK" },
 329         { GSMTAP_BURST_PHY_ATTRIBUTES,  "PHY Attributes" },
 330         { 0,                            NULL },
 331 };
 332
 333 static const value_string gsmtap_channels[] = {
 334         { GSMTAP_CHANNEL_UNKNOWN,       "UNKNOWN" },
 335         { GSMTAP_CHANNEL_BCCH,          "BCCH" },
 336         { GSMTAP_CHANNEL_CCCH,          "CCCH" },
 337         { GSMTAP_CHANNEL_RACH,          "RACH" },
 338         { GSMTAP_CHANNEL_AGCH,          "AGCH" },
 339         { GSMTAP_CHANNEL_PCH,           "PCH" },
 340         { GSMTAP_CHANNEL_SDCCH,         "SDCCH" },
 341         { GSMTAP_CHANNEL_SDCCH4,        "SDCCH/4" },
 342         { GSMTAP_CHANNEL_SDCCH8,        "SDCCH/8" },
 343         { GSMTAP_CHANNEL_TCH_F,         "FACCH/F" },
 344         { GSMTAP_CHANNEL_TCH_H,         "FACCH/H" },
 345         { GSMTAP_CHANNEL_PACCH,         "PACCH" },
 346         { GSMTAP_CHANNEL_CBCH52,    "CBCH" },
 347         { GSMTAP_CHANNEL_PDCH,      "PDCH" },
 348         { GSMTAP_CHANNEL_PTCCH,     "PTTCH" },
 349         { GSMTAP_CHANNEL_CBCH51,    "CBCH" },
 350
 351     { GSMTAP_CHANNEL_ACCH|
 352           GSMTAP_CHANNEL_SDCCH,         "LSACCH" },
 353         { GSMTAP_CHANNEL_ACCH|
 354           GSMTAP_CHANNEL_SDCCH4,        "SACCH/4" },
 355         { GSMTAP_CHANNEL_ACCH|
 356           GSMTAP_CHANNEL_SDCCH8,        "SACCH/8" },
 357         { GSMTAP_CHANNEL_ACCH|
 358           GSMTAP_CHANNEL_TCH_F,         "SACCH/F" },
 359         { GSMTAP_CHANNEL_ACCH|
 360           GSMTAP_CHANNEL_TCH_H,         "SACCH/H" },
 361         { 0,                            NULL },
 362 };
 363
 364 static const value_string gsmtap_tetra_channels[] = {
 365         { GSMTAP_TETRA_BSCH,            "BSCH"   },
 366         { GSMTAP_TETRA_AACH,            "AACH"   },
 367         { GSMTAP_TETRA_SCH_HU,          "SCH/HU" },
 368         { GSMTAP_TETRA_SCH_HD,          "SCH/HD" },
 369         { GSMTAP_TETRA_SCH_F,           "SCH/F"  },
 370         { GSMTAP_TETRA_BNCH,            "BNCH"   },
 371         { GSMTAP_TETRA_STCH,            "STCH"   },
 372         { GSMTAP_TETRA_TCH_F,           "AACH"   },
 373         { 0,                            NULL     },
 374 };
 375
 376 static const value_string gsmtap_gmr1_channels[] = {
 377         { GSMTAP_GMR1_BCCH,             "BCCH" },
 378         { GSMTAP_GMR1_CCCH,             "CCCH" },
 379         { GSMTAP_GMR1_PCH,              "PCH" },
 380         { GSMTAP_GMR1_AGCH,             "AGCH" },
 381         { GSMTAP_GMR1_BACH,             "BACH" },
 382         { GSMTAP_GMR1_RACH,             "RACH" },
 383         { GSMTAP_GMR1_CBCH,             "CBCH" },
 384         { GSMTAP_GMR1_SDCCH,            "SDCCH" },
 385         { GSMTAP_GMR1_TACCH,            "TACCH" },
 386         { GSMTAP_GMR1_GBCH,             "GBCH" },
 387         { GSMTAP_GMR1_TCH3,             "TCH3" },
 388         { GSMTAP_GMR1_TCH3|
 389           GSMTAP_GMR1_FACCH,            "FACCH3" },
 390         { GSMTAP_GMR1_TCH3|
 391           GSMTAP_GMR1_DKAB,             "DKAB" },
 392         { GSMTAP_GMR1_TCH6,             "TCH6" },
 393         { GSMTAP_GMR1_TCH6|
 394           GSMTAP_GMR1_FACCH,            "FACCH6" },
 395         { GSMTAP_GMR1_TCH6|
 396           GSMTAP_GMR1_SACCH,            "SACCH6" },
 397         { GSMTAP_GMR1_TCH9,             "TCH9" },
 398         { GSMTAP_GMR1_TCH9|
 399           GSMTAP_GMR1_FACCH,            "FACCH9" },
 400         { GSMTAP_GMR1_TCH9|
 401           GSMTAP_GMR1_SACCH,            "SACCH9" },
 402         { 0,                            NULL },
 403 };
 404
 405 /* the mapping is not complete */
 406 static const int gsmtap_to_tetra[9] = {
 407         0,
 408         TETRA_CHAN_BSCH,
 409         TETRA_CHAN_AACH,
 410         TETRA_CHAN_SCH_HU,
 411         0,
 412         TETRA_CHAN_SCH_F,
 413         TETRA_CHAN_BNCH,
 414         TETRA_CHAN_STCH,
 415         0
 416 };
 417
 418 static const value_string gsmtap_types[] = {
 419         { GSMTAP_TYPE_UM,       "GSM Um (MS<->BTS)" },
 420         { GSMTAP_TYPE_ABIS,     "GSM Abis (BTS<->BSC)" },
 421         { GSMTAP_TYPE_UM_BURST, "GSM Um burst (MS<->BTS)" },
 422         { GSMTAP_TYPE_SIM,      "SIM" },
 423         { GSMTAP_TYPE_TETRA_I1, "TETRA V+D"},
 424         { GSMTAP_TTPE_TETRA_I1_BURST, "TETRA V+D burst"},
 425         { GSMTAP_TYPE_WMX_BURST,"WiMAX burst" },
 426         { GSMTAP_TYPE_GMR1_UM, "GMR-1 air interfeace (MES-MS<->GTS)" },
 427         { GSMTAP_TYPE_UMTS_RLC_MAC,     "UMTS RLC/MAC" },
 428         { GSMTAP_TYPE_UMTS_RRC,         "UMTS RRC" },
 429         { 0,                    NULL },
 430 };
 431
 432 /* dissect a SACCH L1 header which is included in the first 2 bytes
 433  * of every SACCH frame (according to TS 04.04) */
 434 static void
 435 dissect_sacch_l1h(tvbuff_t *tvb, proto_tree *tree)
 436 {
 437         proto_item *ti;
 438         proto_tree *l1h_tree = NULL;
 439
 440         if (!tree)
 441                 return;
 442
 443         ti = proto_tree_add_protocol_format(tree, proto_gsmtap, tvb, 0, 2,
 444                         "SACCH L1 Header, Power Level: %u, Timing Advance: %u",
 445                         tvb_get_guint8(tvb, 0) & 0x1f,
 446                         tvb_get_guint8(tvb, 1));
 447         l1h_tree = proto_item_add_subtree(ti, ett_gsmtap);
 448         /* Power Level */
 449         proto_tree_add_item(l1h_tree, hf_sacch_l1h_power_lev, tvb, 0, 1, ENC_BIG_ENDIAN);
 450         /* Fast Power Control */
 451         proto_tree_add_item(l1h_tree, hf_sacch_l1h_fpc, tvb, 0, 1, ENC_BIG_ENDIAN);
 452         /* Acutal Timing Advance */
 453         proto_tree_add_item(l1h_tree, hf_sacch_l1h_ta, tvb, 1, 1, ENC_BIG_ENDIAN);
 454 }
 455
 456
 457 static void
 458 handle_tetra(int channel _U_, tvbuff_t *payload_tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_)
 459 {
 460         int tetra_chan;
 461         if (channel < 0 || channel > GSMTAP_TETRA_TCH_F)
 462                 return;
 463
 464         tetra_chan = gsmtap_to_tetra[channel];
 465         if (tetra_chan <= 0)
 466                 return;
 467
 468         tetra_dissect_pdu(tetra_chan, TETRA_DOWNLINK, payload_tvb, tree, pinfo);
 469 }
 470
 471 /* dissect a GSMTAP header and hand payload off to respective dissector */
 472 static void
 473 dissect_gsmtap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 474 {
 475         int sub_handle, rrc_sub_handle = 0, len, offset = 0;
 476         proto_item *ti;
 477         proto_tree *gsmtap_tree = NULL;
 478         tvbuff_t *payload_tvb, *l1h_tvb = NULL;
 479         guint8 hdr_len, type, sub_type, timeslot, subslot;
 480         guint16 arfcn;
 481
 482         len = tvb_length(tvb);
 483
 484         hdr_len = tvb_get_guint8(tvb, offset + 1) <<2;
 485         type = tvb_get_guint8(tvb, offset + 2);
 486         timeslot = tvb_get_guint8(tvb, offset + 3);
 487         arfcn = tvb_get_ntohs(tvb, offset + 4);
 488         sub_type = tvb_get_guint8(tvb, offset + 12);
 489         subslot = tvb_get_guint8(tvb, offset + 14);
 490
 491         /* In case of a SACCH, there is a two-byte L1 header in front
 492          * of the packet (see TS 04.04) */
 493         if (type == GSMTAP_TYPE_UM &&
 494             sub_type & GSMTAP_CHANNEL_ACCH) {
 495                 l1h_tvb = tvb_new_subset(tvb, hdr_len, 2, 2);
 496                 payload_tvb = tvb_new_subset(tvb, hdr_len+2, len-(hdr_len+2),
 497                                              len-(hdr_len+2));
 498         } else {
 499                 payload_tvb = tvb_new_subset(tvb, hdr_len, len-hdr_len,
 500                                              len-hdr_len);
 501         }
 502
 503         /* We don't want any UDP related info left in the INFO field, as the
 504          * gsm_a_dtap dissector will not clear but only append */
 505         col_clear(pinfo->cinfo, COL_INFO);
 506
 507         col_set_str(pinfo->cinfo, COL_PROTOCOL, "GSMTAP");
 508
 509         /* Some GSMTAP types are completely unrelated to the Um air interface */
 510         if (dissector_try_uint(gsmtap_dissector_table, type, payload_tvb,
 511                                pinfo, tree))
 512                 return;
 513
 514         if (arfcn & GSMTAP_ARFCN_F_UPLINK) {
 515                 col_append_str(pinfo->cinfo, COL_RES_NET_SRC, "MS");
 516                 col_append_str(pinfo->cinfo, COL_RES_NET_DST, "BTS");
 517                 /* p2p_dir is used by the LAPDm dissector */
 518                 pinfo->p2p_dir = P2P_DIR_SENT;
 519         } else {
 520                 col_set_str(pinfo->cinfo, COL_RES_NET_SRC, "BTS");
 521                 switch (sub_type & ~GSMTAP_CHANNEL_ACCH) {
 522                 case GSMTAP_CHANNEL_BCCH:
 523                 case GSMTAP_CHANNEL_CCCH:
 524                 case GSMTAP_CHANNEL_PCH:
 525                 case GSMTAP_CHANNEL_AGCH:
 526                 case GSMTAP_CHANNEL_CBCH51:
 527         case GSMTAP_CHANNEL_CBCH52:
 528                         col_set_str(pinfo->cinfo, COL_RES_NET_DST, "Broadcast");
 529                         break;
 530                 default:
 531                         col_set_str(pinfo->cinfo, COL_RES_NET_DST, "MS");
 532                         break;
 533                 }
 534                 /* p2p_dir is used by the LAPDm dissector */
 535                 pinfo->p2p_dir = P2P_DIR_RECV;
 536         }
 537
 538         /* Try to build an identifier of different 'streams' */
 539         /* (AFCN _cant_ be used because of hopping */
 540         pinfo->circuit_id = (timeslot << 3) | subslot;
 541
 542         if (tree) {
 543                 guint8 channel;
 544                 const char *channel_str;
 545                 channel = tvb_get_guint8(tvb, offset+12);
 546                 if (type == GSMTAP_TYPE_TETRA_I1)
 547                         channel_str = val_to_str(channel, gsmtap_tetra_channels, "Unknown: %d");
 548                 else if (type == GSMTAP_TYPE_GMR1_UM)
 549                         channel_str = val_to_str(channel, gsmtap_gmr1_channels, "Unknown: %d");
 550                 else
 551                         channel_str = val_to_str(channel, gsmtap_channels, "Unknown: %d");
 552
 553                 ti = proto_tree_add_protocol_format(tree, proto_gsmtap, tvb, 0, hdr_len,
 554                         "GSM TAP Header, ARFCN: %u (%s), TS: %u, Channel: %s (%u)",
 555                         arfcn & GSMTAP_ARFCN_MASK,
 556                         arfcn & GSMTAP_ARFCN_F_UPLINK ? "Uplink" : "Downlink",
 557                         tvb_get_guint8(tvb, offset+3),
 558                         channel_str,
 559                         tvb_get_guint8(tvb, offset+14));
 560                 gsmtap_tree = proto_item_add_subtree(ti, ett_gsmtap);
 561                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_version,
 562                                     tvb, offset, 1, ENC_BIG_ENDIAN);
 563                 proto_tree_add_uint_format_value(gsmtap_tree, hf_gsmtap_hdrlen,
 564                                     tvb, offset+1, 1, hdr_len,
 565                                     "%u bytes", hdr_len);
 566                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_type,
 567                                     tvb, offset+2, 1, ENC_BIG_ENDIAN);
 568                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_timeslot,
 569                                     tvb, offset+3, 1, ENC_BIG_ENDIAN);
 570                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_arfcn,
 571                                     tvb, offset+4, 2, ENC_BIG_ENDIAN);
 572                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_uplink,
 573                                     tvb, offset+4, 2, ENC_BIG_ENDIAN);
 574                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_noise_dbm,
 575                                     tvb, offset+6, 1, ENC_BIG_ENDIAN);
 576                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_signal_dbm,
 577                                     tvb, offset+7, 1, ENC_BIG_ENDIAN);
 578                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_frame_nr,
 579                                     tvb, offset+8, 4, ENC_BIG_ENDIAN);
 580                 if (type == GSMTAP_TYPE_UM_BURST)
 581                         proto_tree_add_item(gsmtap_tree, hf_gsmtap_burst_type,
 582                                             tvb, offset+12, 1, ENC_BIG_ENDIAN);
 583                 else if (type == GSMTAP_TYPE_UM)
 584                         proto_tree_add_item(gsmtap_tree, hf_gsmtap_channel_type,
 585                                             tvb, offset+12, 1, ENC_BIG_ENDIAN);
 586                 else if (type == GSMTAP_TYPE_TETRA_I1)
 587                         proto_tree_add_item(gsmtap_tree, hf_gsmtap_tetra_channel_type,
 588                                             tvb, offset+12, 1, ENC_BIG_ENDIAN);
 589                 else if (type == GSMTAP_TYPE_WMX_BURST)
 590                         proto_tree_add_item(gsmtap_tree, hf_gsmtap_burst_type,
 591                                             tvb, offset+12, 1, ENC_BIG_ENDIAN);
 592                 else if (type == GSMTAP_TYPE_GMR1_UM)
 593                         proto_tree_add_item(gsmtap_tree, hf_gsmtap_gmr1_channel_type,
 594                                             tvb, offset+12, 1, ENC_BIG_ENDIAN);
 595                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_antenna,
 596                                     tvb, offset+13, 1, ENC_BIG_ENDIAN);
 597                 proto_tree_add_item(gsmtap_tree, hf_gsmtap_subslot,
 598                                     tvb, offset+14, 1, ENC_BIG_ENDIAN);
 599         }
 600
 601         switch (type) {
 602         case GSMTAP_TYPE_UMTS_RRC:
 603                 sub_handle = GSMTAP_SUB_UMTS_RRC;
 604                 rrc_sub_handle = sub_type;
 605                 if (rrc_sub_handle >= GSMTAP_RRC_SUB_MAX) {
 606                         sub_handle = GSMTAP_SUB_DATA;
 607                 }
 608                 /* make entry in the Protocol column on summary display.
 609                  * Normally, the RRC dissector would be doing this, but
 610                  * we are bypassing dissect_rrc() and directly call a
 611                  * sub-dissector */
 612                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "RRC");
 613                 break;
 614         case GSMTAP_TYPE_UM:
 615                 if (l1h_tvb)
 616                         dissect_sacch_l1h(l1h_tvb, tree);
 617                 switch (sub_type & ~GSMTAP_CHANNEL_ACCH) {
 618                 case GSMTAP_CHANNEL_BCCH:
 619                 case GSMTAP_CHANNEL_CCCH:
 620                 case GSMTAP_CHANNEL_PCH:
 621                 case GSMTAP_CHANNEL_AGCH:
 622                         /* FIXME: we might want to skip idle frames */
 623                         sub_handle = GSMTAP_SUB_UM;
 624                         break;
 625                 case GSMTAP_CHANNEL_SDCCH:
 626                 case GSMTAP_CHANNEL_SDCCH4:
 627                 case GSMTAP_CHANNEL_SDCCH8:
 628                 case GSMTAP_CHANNEL_TCH_F:
 629                 case GSMTAP_CHANNEL_TCH_H:
 630                         sub_handle = GSMTAP_SUB_UM_LAPDM;
 631                         break;
 632                 case GSMTAP_CHANNEL_PACCH:
 633                         if (pinfo->p2p_dir == P2P_DIR_SENT) {
 634                                 sub_handle = GSMTAP_SUB_UM_RLC_MAC_UL;
 635                         }
 636                         else
 637                         {
 638                                 sub_handle = GSMTAP_SUB_UM_RLC_MAC_DL;
 639                         }
 640                         break;
 641
 642                 case GSMTAP_CHANNEL_CBCH51:
 643                 case GSMTAP_CHANNEL_CBCH52:
 644                         sub_handle = GSMTAP_SUB_CBCH;
 645                         break;
 646
 647                 case GSMTAP_CHANNEL_RACH:
 648                 default:
 649                         sub_handle = GSMTAP_SUB_DATA;
 650                         break;
 651                 }
 652                 break;
 653         case GSMTAP_TYPE_ABIS:
 654                 sub_handle = GSMTAP_SUB_ABIS;
 655                 break;
 656         case GSMTAP_TYPE_GB_LLC:
 657                 sub_handle = GSMTAP_SUB_LLC;
 658                 break;
 659         case GSMTAP_TYPE_GB_SNDCP:
 660                 sub_handle = GSMTAP_SUB_SNDCP;
 661                 break;
 662         case GSMTAP_TYPE_TETRA_I1:
 663                 handle_tetra(tvb_get_guint8(tvb, offset+12), payload_tvb, pinfo, tree);
 664                 return;
 665         case GSMTAP_TYPE_WMX_BURST:
 666                 switch (sub_type) {
 667                 case GSMTAP_BURST_CDMA_CODE:
 668                         sub_handle = GSMTAP_SUB_CDMA_CODE;
 669                         break;
 670                 case GSMTAP_BURST_FCH:
 671                         sub_handle = GSMTAP_SUB_FCH;
 672                         break;
 673                 case GSMTAP_BURST_FFB:
 674                         sub_handle = GSMTAP_SUB_FFB;
 675                         break;
 676                 case GSMTAP_BURST_PDU:
 677                         sub_handle = GSMTAP_SUB_PDU;
 678                         break;
 679                 case GSMTAP_BURST_HACK:
 680                         sub_handle = GSMTAP_SUB_HACK;
 681                         break;
 682                 case GSMTAP_BURST_PHY_ATTRIBUTES:
 683                         sub_handle = GSMTAP_SUB_PHY_ATTRIBUTES;
 684                         break;
 685                 default:
 686                         sub_handle = GSMTAP_SUB_DATA;
 687                         break;
 688                 }
 689                 break;
 690         case GSMTAP_TYPE_GMR1_UM:
 691                 switch (sub_type) {
 692                 case GSMTAP_GMR1_BCCH:
 693                         sub_handle = GSMTAP_SUB_GMR1_BCCH;
 694                         break;
 695                 case GSMTAP_GMR1_CCCH:
 696                 case GSMTAP_GMR1_AGCH:
 697                 case GSMTAP_GMR1_PCH:
 698                         sub_handle = GSMTAP_SUB_GMR1_CCCH;
 699                         break;
 700                 case GSMTAP_GMR1_SDCCH:
 701                 case GSMTAP_GMR1_TCH3 | GSMTAP_GMR1_FACCH:
 702                 case GSMTAP_GMR1_TCH6 | GSMTAP_GMR1_FACCH:
 703                 case GSMTAP_GMR1_TCH9 | GSMTAP_GMR1_FACCH:
 704                         sub_handle = GSMTAP_SUB_GMR1_LAPSAT;
 705                         break;
 706                 case GSMTAP_GMR1_RACH:
 707                         sub_handle = GSMTAP_SUB_GMR1_RACH;
 708                         break;
 709                 default:
 710                         sub_handle = GSMTAP_SUB_DATA;
 711                         break;
 712                 }
 713                 break;
 714         case GSMTAP_TYPE_UM_BURST:
 715         default:
 716                 sub_handle = GSMTAP_SUB_DATA;
 717                 break;
 718         }
 719         if (sub_handle == GSMTAP_SUB_UMTS_RRC)
 720                 call_dissector(rrc_sub_handles[rrc_sub_handle], payload_tvb,
 721                                pinfo, tree);
 722         else
 723                 call_dissector(sub_handles[sub_handle], payload_tvb, pinfo, tree);
 724 }
 725
 726 static const true_false_string sacch_l1h_fpc_mode_vals = {
 727         "In use",
 728         "Not in use"
 729 };
 730
 731 void
 732 proto_register_gsmtap(void)
 733 {
 734         static hf_register_info hf[] = {
 735                 { &hf_gsmtap_version, { "Version", "gsmtap.version",
 736                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 737                 { &hf_gsmtap_hdrlen, { "Header Length", "gsmtap.hdr_len",
 738                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 739                 { &hf_gsmtap_type, { "Payload Type", "gsmtap.type",
 740                   FT_UINT8, BASE_DEC, VALS(gsmtap_types), 0, NULL, HFILL } },
 741                 { &hf_gsmtap_timeslot, { "Time Slot", "gsmtap.ts",
 742                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 743                 { &hf_gsmtap_arfcn, { "ARFCN", "gsmtap.arfcn",
 744                   FT_UINT16, BASE_DEC, NULL, GSMTAP_ARFCN_MASK, NULL, HFILL } },
 745                 { &hf_gsmtap_uplink, { "Uplink", "gsmtap.uplink",
 746                   FT_UINT16, BASE_DEC, NULL, GSMTAP_ARFCN_F_UPLINK, NULL, HFILL } },
 747                 { &hf_gsmtap_noise_dbm, { "Signal/Noise Ratio (dB)", "gsmtap.snr_db",
 748                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 749                 { &hf_gsmtap_signal_dbm, { "Signal Level (dBm)", "gsmtap.signal_dbm",
 750                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 751                 { &hf_gsmtap_frame_nr, { "GSM Frame Number", "gsmtap.frame_nr",
 752                   FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } },
 753                 { &hf_gsmtap_burst_type, { "Burst Type", "gsmtap.burst_type",
 754                   FT_UINT8, BASE_DEC, VALS(gsmtap_bursts), 0, NULL, HFILL }},
 755                 { &hf_gsmtap_channel_type, { "Channel Type", "gsmtap.chan_type",
 756                   FT_UINT8, BASE_DEC, VALS(gsmtap_channels), 0, NULL, HFILL }},
 757                 { &hf_gsmtap_tetra_channel_type, { "Channel Type", "gsmtap.tetra_chan_type",
 758                   FT_UINT8, BASE_DEC, VALS(gsmtap_tetra_channels), 0, NULL, HFILL }},
 759                 { &hf_gsmtap_gmr1_channel_type, { "Channel Type", "gsmtap.gmr1_chan_type",
 760                   FT_UINT8, BASE_DEC, VALS(gsmtap_gmr1_channels), 0, NULL, HFILL }},
 761                 { &hf_gsmtap_antenna, { "Antenna Number", "gsmtap.antenna",
 762                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 763                 { &hf_gsmtap_subslot, { "Sub-Slot", "gsmtap.sub_slot",
 764                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 765
 766                 { &hf_sacch_l1h_power_lev, { "MS power level", "gsmtap.sacch_l1.power_lev",
 767                   FT_UINT8, BASE_DEC, NULL, 0x1f, NULL, HFILL } },
 768                 { &hf_sacch_l1h_fpc, { "FPC", "gsmtap.sacch_l1.fpc",
 769                   FT_BOOLEAN, 8, TFS(&sacch_l1h_fpc_mode_vals), 0x04,
 770                   NULL, HFILL } },
 771                 { &hf_sacch_l1h_ta, { "Actual Timing Advance", "gsmtap.sacch_l1.ta",
 772                   FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
 773         };
 774         static gint *ett[] = {
 775                 &ett_gsmtap
 776         };
 777
 778         proto_gsmtap = proto_register_protocol("GSM Radiotap", "GSMTAP", "gsmtap");
 779         proto_register_field_array(proto_gsmtap, hf, array_length(hf));
 780         proto_register_subtree_array(ett, array_length(ett));
 781
 782         gsmtap_dissector_table = register_dissector_table("gsmtap.type",
 783                                                 "GSMTAP type", FT_UINT8, BASE_HEX);
 784 }
 785
 786 void
 787 proto_reg_handoff_gsmtap(void)
 788 {
 789         dissector_handle_t gsmtap_handle;
 790
 791         sub_handles[GSMTAP_SUB_DATA] = find_dissector("data");
 792         sub_handles[GSMTAP_SUB_UM] = find_dissector("gsm_a_ccch");
 793         sub_handles[GSMTAP_SUB_UM_LAPDM] = find_dissector("lapdm");
 794         sub_handles[GSMTAP_SUB_UM_RLC_MAC_UL] = find_dissector("gsm_rlcmac_ul");
 795         sub_handles[GSMTAP_SUB_UM_RLC_MAC_DL] = find_dissector("gsm_rlcmac_dl");
 796         sub_handles[GSMTAP_SUB_LLC] = find_dissector("llcgprs");
 797         sub_handles[GSMTAP_SUB_SNDCP] = find_dissector("sndcp");
 798         sub_handles[GSMTAP_SUB_ABIS] = find_dissector("gsm_a_dtap");
 799         sub_handles[GSMTAP_SUB_CDMA_CODE] = find_dissector("wimax_cdma_code_burst_handler");
 800         sub_handles[GSMTAP_SUB_FCH] = find_dissector("wimax_fch_burst_handler");
 801         sub_handles[GSMTAP_SUB_FFB] = find_dissector("wimax_ffb_burst_handler");
 802         sub_handles[GSMTAP_SUB_PDU] = find_dissector("wimax_pdu_burst_handler");
 803         sub_handles[GSMTAP_SUB_HACK] = find_dissector("wimax_hack_burst_handler");
 804         sub_handles[GSMTAP_SUB_PHY_ATTRIBUTES] = find_dissector("wimax_phy_attributes_burst_handler");
 805         sub_handles[GSMTAP_SUB_CBCH] = find_dissector("gsm_cbch");
 806         sub_handles[GSMTAP_SUB_GMR1_BCCH] = find_dissector("gmr1_bcch");
 807         sub_handles[GSMTAP_SUB_GMR1_CCCH] = find_dissector("gmr1_ccch");
 808         sub_handles[GSMTAP_SUB_GMR1_LAPSAT] = find_dissector("lapsat");
 809         sub_handles[GSMTAP_SUB_GMR1_RACH] = find_dissector("gmr1_rach");
 810         sub_handles[GSMTAP_SUB_UMTS_RRC] = find_dissector("rrc");
 811
 812         rrc_sub_handles[GSMTAP_RRC_SUB_DL_DCCH_Message] = find_dissector("rrc.dl.dcch");
 813         rrc_sub_handles[GSMTAP_RRC_SUB_UL_DCCH_Message] = find_dissector("rrc.ul.dcch");
 814         rrc_sub_handles[GSMTAP_RRC_SUB_DL_CCCH_Message] = find_dissector("rrc.dl.ccch");
 815         rrc_sub_handles[GSMTAP_RRC_SUB_UL_CCCH_Message] = find_dissector("rrc.ul.ccch");
 816         rrc_sub_handles[GSMTAP_RRC_SUB_PCCH_Message] = find_dissector("rrc.pcch");
 817         rrc_sub_handles[GSMTAP_RRC_SUB_DL_SHCCH_Message] = find_dissector("rrc.dl.shcch");
 818         rrc_sub_handles[GSMTAP_RRC_SUB_UL_SHCCH_Message] = find_dissector("rrc.ul.shcch");
 819         rrc_sub_handles[GSMTAP_RRC_SUB_BCCH_FACH_Message] = find_dissector("rrc.bcch.fach");
 820         rrc_sub_handles[GSMTAP_RRC_SUB_BCCH_BCH_Message] = find_dissector("rrc.bcch.bch");
 821         rrc_sub_handles[GSMTAP_RRC_SUB_MCCH_Message] = find_dissector("rrc.mcch");
 822         rrc_sub_handles[GSMTAP_RRC_SUB_MSCH_Message] = find_dissector("rrc.msch");
 823         rrc_sub_handles[GSMTAP_RRC_SUB_HandoverToUTRANCommand] = find_dissector("rrc.irat.ho_to_utran_cmd");
 824         rrc_sub_handles[GSMTAP_RRC_SUB_InterRATHandoverInfo] = find_dissector("rrc.irat.irat_ho_info");
 825         rrc_sub_handles[GSMTAP_RRC_SUB_SystemInformation_BCH] = find_dissector("rrc.sysinfo");
 826         rrc_sub_handles[GSMTAP_RRC_SUB_System_Information_Container] = find_dissector("rrc.sysinfo.cont");
 827         rrc_sub_handles[GSMTAP_RRC_SUB_UE_RadioAccessCapabilityInfo] = find_dissector("rrc.ue_radio_access_cap_info");
 828         rrc_sub_handles[GSMTAP_RRC_SUB_MasterInformationBlock] = find_dissector("rrc.si.mib");
 829         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType1] = find_dissector("rrc.si.sib1");
 830         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType2] = find_dissector("rrc.si.sib2");
 831         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType3] = find_dissector("rrc.si.sib3");
 832         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType4] = find_dissector("rrc.si.sib4");
 833         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType5] = find_dissector("rrc.si.sib5");
 834         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType5bis] = find_dissector("rrc.si.sib5bis");
 835         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType6] = find_dissector("rrc.si.sib6");
 836         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType7] = find_dissector("rrc.si.sib7");
 837         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType8] = find_dissector("rrc.si.sib8");
 838         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType9] = find_dissector("rrc.si.sib9");
 839         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType10] = find_dissector("rrc.si.sib10");
 840         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType11] = find_dissector("rrc.si.sib11");
 841         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType11bis] = find_dissector("rrc.si.sib11bis");
 842         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType12] = find_dissector("rrc.si.sib12");
 843         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType13] = find_dissector("rrc.si.sib13");
 844         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType13_1] = find_dissector("rrc.si.sib13-1");
 845         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType13_2] = find_dissector("rrc.si.sib13-2");
 846         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType13_3] = find_dissector("rrc.si.sib13-3");
 847         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType13_4] = find_dissector("rrc.si.sib13-4");
 848         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType14] = find_dissector("rrc.si.sib14");
 849         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15] = find_dissector("rrc.si.sib15");
 850         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15bis] = find_dissector("rrc.si.sib15bis");
 851         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_1] = find_dissector("rrc.si.sib15-1");
 852         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_1bis] = find_dissector("rrc.si.sib15-1bis");
 853         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_2] = find_dissector("rrc.si.sib15-2");
 854         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_2bis] = find_dissector("rrc.si.sib15-2bis");
 855         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_2ter] = find_dissector("rrc.si.sib15-2ter");
 856         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_3] = find_dissector("rrc.si.sib15-3");
 857         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_3bis] = find_dissector("rrc.si.sib15-3bis");
 858         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_4] = find_dissector("rrc.si.sib15-4");
 859         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_5] = find_dissector("rrc.si.sib15-5");
 860         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_6] = find_dissector("rrc.si.sib15-6");
 861         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_7] = find_dissector("rrc.si.sib15-7");
 862         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType15_8] = find_dissector("rrc.si.sib15-8");
 863         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType16] = find_dissector("rrc.si.sib16");
 864         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType17] = find_dissector("rrc.si.sib17");
 865         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType18] = find_dissector("rrc.si.sib18");
 866         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType19] = find_dissector("rrc.si.sib19");
 867         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType20] = find_dissector("rrc.si.sib20");
 868         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType21] = find_dissector("rrc.si.sib21");
 869         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoType22] = find_dissector("rrc.si.sib22");
 870         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoTypeSB1] = find_dissector("rrc.si.sb1");
 871         rrc_sub_handles[GSMTAP_RRC_SUB_SysInfoTypeSB2] = find_dissector("rrc.si.sb2");
 872         rrc_sub_handles[GSMTAP_RRC_SUB_ToTargetRNC_Container] = find_dissector("rrc.s_to_trnc_cont");
 873         rrc_sub_handles[GSMTAP_RRC_SUB_TargetRNC_ToSourceRNC_Container] = find_dissector("rrc.t_to_srnc_cont");
 874
 875         gsmtap_handle = create_dissector_handle(dissect_gsmtap, proto_gsmtap);
 876         dissector_add_uint("udp.port", GSMTAP_UDP_PORT, gsmtap_handle);
 877 }