diff options
| author | Guy Harris <guy@alum.mit.edu> | 2003-10-30 07:00:18 +0000 |
|---|---|---|
| committer | Guy Harris <guy@alum.mit.edu> | 2003-10-30 07:00:18 +0000 |
| commit | 8e67a430e874b6d9a370aabf34f9eabdb9c6412d (patch) | |
| tree | be65a2ac16aee55b151a0c66fd419795e3c353e7 /packet-gsm_a.c | |
| parent | 2a6b337ad84603441153ab82af1408ca44802fe7 (diff) | |
From Michael Lum:
GSM BSSMAP (GSM 08.08) support
GSM DTAP (3GPP TS 24.008) support
GSM SMS (3GPP TS 24.011) support
GSM SS (3GPP TS 24.080) support
GSM SMS TPDU (3GPP TS 23.040) support
svn path=/trunk/; revision=8826
Diffstat (limited to 'packet-gsm_a.c')
| -rw-r--r-- | packet-gsm_a.c | 9780 |
1 files changed, 9780 insertions, 0 deletions
diff --git a/packet-gsm_a.c b/packet-gsm_a.c new file mode 100644 index 0000000000..6dcf479621 --- /dev/null +++ b/packet-gsm_a.c @@ -0,0 +1,9780 @@ +/* packet-gsm_a.c + * Routines for GSM A Interface (BSSMAP/DTAP) dissection + * + * Copyright 2003, Michael Lum <mlum [AT] telostech.com> + * In association with Telos Technology Inc. + * + * Title 3GPP Other + * + * Reference [1] + * Mobile radio interface signalling layer 3; + * General Aspects + * (3GPP TS 24.007 version 3.9.0 Release 1999) + * + * Reference [2] + * Mobile-services Switching Centre - Base Station System + * (MSC - BSS) interface; + * Layer 3 specification + * (GSM 08.08 version 7.7.0 Release 1998) TS 100 590 v7.7.0 + * + * Reference [3] + * Mobile radio interface Layer 3 specification; + * Core network protocols; + * Stage 3 + * (3GPP TS 24.008 version 4.7.0 Release 4) + * + * Reference [4] + * Mobile radio interface layer 3 specification; + * Radio Resource Control Protocol + * (GSM 04.18 version 8.4.1 Release 1999) + * + * Reference [5] + * Point-to-Point (PP) Short Message Service (SMS) + * support on mobile radio interface + * (3GPP TS 24.011 version 4.1.1 Release 4) + * + * Reference [6] + * Mobile radio Layer 3 supplementary service specification; + * Formats and coding + * (3GPP TS 24.080 version 4.3.0 Release 4) + * + * $Id: packet-gsm_a.c,v 1.1 2003/10/30 07:00:18 guy Exp $ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <gmodule.h> + +#ifdef HAVE_SYS_TYPES_H +# include <sys/types.h> +#endif + +#ifdef HAVE_NETINET_IN_H +# include <netinet/in.h> +#endif + +#include <string.h> + +#include "epan/packet.h" +#include "prefs.h" + +#include "packet-bssap.h" + +/* PROTOTYPES/FORWARDS */ + +static void (*dtap_msg_rr_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len); + +static const value_string gsm_bssmap_msg_strings[] = { + { 0x01, "Assignment Request" }, + { 0x02, "Assignment Complete" }, + { 0x03, "Assignment Failure" }, + { 0x10, "Handover Request" }, + { 0x11, "Handover Required" }, + { 0x12, "Handover Request Acknowledge" }, + { 0x13, "Handover Command" }, + { 0x14, "Handover Complete" }, + { 0x15, "Handover Succeeded" }, + { 0x16, "Handover Failure" }, + { 0x17, "Handover Performed" }, + { 0x18, "Handover Candidate Enquire" }, + { 0x19, "Handover Candidate Response" }, + { 0x1a, "Handover Required Reject" }, + { 0x1b, "Handover Detect" }, + { 0x20, "Clear Command" }, + { 0x21, "Clear Complete" }, + { 0x22, "Clear Request" }, + { 0x23, "Reserved" }, + { 0x24, "Reserved" }, + { 0x25, "SAPI 'n' Reject" }, + { 0x26, "Confusion" }, + { 0x28, "Suspend" }, + { 0x29, "Resume" }, + { 0x2a, "Connection Oriented Information" }, + { 0x2b, "Perform Location Request" }, + { 0x2c, "LSA Information" }, + { 0x2d, "Perform Location Response" }, + { 0x2e, "Perform Location Abort" }, + { 0x30, "Reset" }, + { 0x31, "Reset Acknowledge" }, + { 0x32, "Overload" }, + { 0x33, "Reserved" }, + { 0x34, "Reset Circuit" }, + { 0x35, "Reset Circuit Acknowledge" }, + { 0x36, "MSC Invoke Trace" }, + { 0x37, "BSS Invoke Trace" }, + { 0x3a, "Connectionless Information" }, + { 0x40, "Block" }, + { 0x41, "Blocking Acknowledge" }, + { 0x42, "Unblock" }, + { 0x43, "Unblocking Acknowledge" }, + { 0x44, "Circuit Group Block" }, + { 0x45, "Circuit Group Blocking Acknowledge" }, + { 0x46, "Circuit Group Unblock" }, + { 0x47, "Circuit Group Unblocking Acknowledge" }, + { 0x48, "Unequipped Circuit" }, + { 0x4e, "Change Circuit" }, + { 0x4f, "Change Circuit Acknowledge" }, + { 0x50, "Resource Request" }, + { 0x51, "Resource Indication" }, + { 0x52, "Paging" }, + { 0x53, "Cipher Mode Command" }, + { 0x54, "Classmark Update" }, + { 0x55, "Cipher Mode Complete" }, + { 0x56, "Queuing Indication" }, + { 0x57, "Complete Layer 3 Information" }, + { 0x58, "Classmark Request" }, + { 0x59, "Cipher Mode Reject" }, + { 0x5a, "Load Indication" }, + { 0x04, "VGCS/VBS Setup" }, + { 0x05, "VGCS/VBS Setup Ack" }, + { 0x06, "VGCS/VBS Setup Refuse" }, + { 0x07, "VGCS/VBS Assignment Request" }, + { 0x1c, "VGCS/VBS Assignment Result" }, + { 0x1d, "VGCS/VBS Assignment Failure" }, + { 0x1e, "VGCS/VBS Queuing Indication" }, + { 0x1f, "Uplink Request" }, + { 0x27, "Uplink Request Acknowledge" }, + { 0x49, "Uplink Request Confirmation" }, + { 0x4a, "Uplink Release Indication" }, + { 0x4b, "Uplink Reject Command" }, + { 0x4c, "Uplink Release Command" }, + { 0x4d, "Uplink Seized Command" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_mm_strings[] = { + { 0x01, "IMSI Detach Indication" }, + { 0x02, "Location Updating Accept" }, + { 0x04, "Location Updating Reject" }, + { 0x08, "Location Updating Request" }, + { 0x11, "Authentication Reject" }, + { 0x12, "Authentication Request" }, + { 0x14, "Authentication Response" }, + { 0x1c, "Authentication Failure" }, + { 0x18, "Identity Request" }, + { 0x19, "Identity Response" }, + { 0x1a, "TMSI Reallocation Command" }, + { 0x1b, "TMSI Reallocation Complete" }, + { 0x21, "CM Service Accept" }, + { 0x22, "CM Service Reject" }, + { 0x23, "CM Service Abort" }, + { 0x24, "CM Service Request" }, + { 0x25, "CM Service Prompt" }, + { 0x26, "Reserved: was allocated in earlier phases of the protocol" }, + { 0x28, "CM Re-establishment Request" }, + { 0x29, "Abort" }, + { 0x30, "MM Null" }, + { 0x31, "MM Status" }, + { 0x32, "MM Information" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_rr_strings[] = { + { 0x3c, "RR Initialisation Request" }, + { 0x3b, "Additional Assignment" }, + { 0x3f, "Immediate Assignment" }, + { 0x39, "Immediate Assignment Extended" }, + { 0x3a, "Immediate Assignment Reject" }, + + { 0x48, "DTM Assignment Failure" }, + { 0x49, "DTM Reject" }, + { 0x4a, "DTM Request" }, + { 0x4b, "Main DCCH Assignment Command" }, + { 0x4c, "Packet Assignment Command" }, + + { 0x35, "Ciphering Mode Command" }, + { 0x32, "Ciphering Mode Complete" }, + + { 0x30, "Configuration Change Command" }, + { 0x31, "Configuration Change Ack." }, + { 0x33, "Configuration Change Reject" }, + + { 0x2e, "Assignment Command" }, + { 0x29, "Assignment Complete" }, + { 0x2f, "Assignment Failure" }, + { 0x2b, "Handover Command" }, + { 0x2c, "Handover Complete" }, + { 0x28, "Handover Failure" }, + { 0x2d, "Physical Information" }, + { 0x4d, "DTM Assignment Command" }, + + { 0x08, "RR-cell Change Order" }, + { 0x23, "PDCH Assignment Command" }, + + { 0x0d, "Channel Release" }, + { 0x0a, "Partial Release" }, + { 0x0f, "Partial Release Complete" }, + + { 0x21, "Paging Request Type 1" }, + { 0x22, "Paging Request Type 2" }, + { 0x24, "Paging Request Type 3" }, + { 0x27, "Paging Response" }, + { 0x20, "Notification/NCH" }, + { 0x25, "Reserved" }, + { 0x26, "Notification/Response" }, + + { 0x0b, "Reserved" }, + +/* { 0xc0, "Utran Classmark Change" }, CONFLICTS WITH Handover To UTRAN Command */ + { 0xc1, "UE RAB Preconfiguration" }, + { 0xc2, "cdma2000 Classmark Change" }, + + { 0x18, "System Information Type 8" }, + { 0x19, "System Information Type 1" }, + { 0x1a, "System Information Type 2" }, + { 0x1b, "System Information Type 3" }, + { 0x1c, "System Information Type 4" }, + { 0x1d, "System Information Type 5" }, + { 0x1e, "System Information Type 6" }, + { 0x1f, "System Information Type 7" }, + + { 0x02, "System Information Type 2bis" }, + { 0x03, "System Information Type 2ter" }, + { 0x07, "System Information Type 2quater" }, + { 0x05, "System Information Type 5bis" }, + { 0x06, "System Information Type 5ter" }, + { 0x04, "System Information Type 9" }, + { 0x00, "System Information Type 13" }, + + { 0x3d, "System Information Type 16" }, + { 0x3e, "System Information Type 17" }, + + { 0x40, "System Information Type 18" }, + { 0x41, "System Information Type 19" }, + { 0x42, "System Information Type 20" }, + + { 0x10, "Channel Mode Modify" }, + { 0x12, "RR Status" }, + { 0x17, "Channel Mode Modify Acknowledge" }, + { 0x14, "Frequency Redefinition" }, + { 0x15, "Measurement Report" }, + { 0x16, "Classmark Change" }, + { 0x13, "Classmark Enquiry" }, + { 0x36, "Extended Measurement Report" }, + { 0x37, "Extended Measurement Order" }, + { 0x34, "GPRS Suspension Request" }, + + { 0x09, "VGCS Uplink Grant" }, + { 0x0e, "Uplink Release" }, + { 0x0c, "Reserved" }, + { 0x2a, "Uplink Busy" }, + { 0x11, "Talker Indication" }, + + { 0xc0, "UTRAN Classmark Change/Handover To UTRAN Command" }, /* spec conflict */ + + { 0x38, "Application Information" }, + + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_cc_strings[] = { + { 0x01, "Alerting" }, + { 0x08, "Call Confirmed" }, + { 0x02, "Call Proceeding" }, + { 0x07, "Connect" }, + { 0x0f, "Connect Acknowledge" }, + { 0x0e, "Emergency Setup" }, + { 0x03, "Progress" }, + { 0x04, "CC-Establishment" }, + { 0x06, "CC-Establishment Confirmed" }, + { 0x0b, "Recall" }, + { 0x09, "Start CC" }, + { 0x05, "Setup" }, + { 0x17, "Modify" }, + { 0x1f, "Modify Complete" }, + { 0x13, "Modify Reject" }, + { 0x10, "User Information" }, + { 0x18, "Hold" }, + { 0x19, "Hold Acknowledge" }, + { 0x1a, "Hold Reject" }, + { 0x1c, "Retrieve" }, + { 0x1d, "Retrieve Acknowledge" }, + { 0x1e, "Retrieve Reject" }, + { 0x25, "Disconnect" }, + { 0x2d, "Release" }, + { 0x2a, "Release Complete" }, + { 0x39, "Congestion Control" }, + { 0x3e, "Notify" }, + { 0x3d, "Status" }, + { 0x34, "Status Enquiry" }, + { 0x35, "Start DTMF" }, + { 0x31, "Stop DTMF" }, + { 0x32, "Stop DTMF Acknowledge" }, + { 0x36, "Start DTMF Acknowledge" }, + { 0x37, "Start DTMF Reject" }, + { 0x3a, "Facility" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_gmm_strings[] = { + { 0x01, "Attach Request" }, + { 0x02, "Attach Accept" }, + { 0x03, "Attach Complete" }, + { 0x04, "Attach Reject" }, + { 0x05, "Detach Request" }, + { 0x06, "Detach Accept" }, + { 0x08, "Routing Area Update Request" }, + { 0x09, "Routing Area Update Accept" }, + { 0x0a, "Routing Area Update Complete" }, + { 0x0b, "Routing Area Update Reject" }, + { 0x0c, "Service Request" }, + { 0x0d, "Service Accept" }, + { 0x0e, "Service Reject" }, + { 0x10, "P-TMSI Reallocation Command" }, + { 0x11, "P-TMSI Reallocation Complete" }, + { 0x12, "Authentication and Ciphering Req" }, + { 0x13, "Authentication and Ciphering Resp" }, + { 0x14, "Authentication and Ciphering Rej" }, + { 0x1c, "Authentication and Ciphering Failure" }, + { 0x15, "Identity Request" }, + { 0x16, "Identity Response" }, + { 0x20, "GMM Status" }, + { 0x21, "GMM Information" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_sms_strings[] = { + { 0x01, "CP-DATA" }, + { 0x04, "CP-ACK" }, + { 0x10, "CP-ERROR" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_sm_strings[] = { + { 0x41, "Activate PDP Context Request" }, + { 0x42, "Activate PDP Context Accept" }, + { 0x43, "Activate PDP Context Reject" }, + { 0x44, "Request PDP Context Activation" }, + { 0x45, "Request PDP Context Activation rej." }, + { 0x46, "Deactivate PDP Context Request" }, + { 0x47, "Deactivate PDP Context Accept" }, + { 0x48, "Modify PDP Context Request(Network to MS direction)" }, + { 0x49, "Modify PDP Context Accept (MS to network direction)" }, + { 0x4a, "Modify PDP Context Request(MS to network direction)" }, + { 0x4b, "Modify PDP Context Accept (Network to MS direction)" }, + { 0x4c, "Modify PDP Context Reject" }, + { 0x4d, "Activate Secondary PDP Context Request" }, + { 0x4e, "Activate Secondary PDP Context Accept" }, + { 0x4f, "Activate Secondary PDP Context Reject" }, + { 0x50, "Reserved: was allocated in earlier phases of the protocol" }, + { 0x51, "Reserved: was allocated in earlier phases of the protocol" }, + { 0x52, "Reserved: was allocated in earlier phases of the protocol" }, + { 0x53, "Reserved: was allocated in earlier phases of the protocol" }, + { 0x54, "Reserved: was allocated in earlier phases of the protocol" }, + { 0x55, "SM Status" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_msg_ss_strings[] = { + { 0x2a, "Release Complete" }, + { 0x3a, "Facility" }, + { 0x3b, "Register" }, + { 0, NULL }, +}; + +static const value_string gsm_rp_msg_strings[] = { + { 0x00, "RP-DATA (MS to Network)" }, + { 0x01, "RP-DATA (Network to MS)" }, + { 0x02, "RP-ACK (MS to Network)" }, + { 0x03, "RP-ACK (Network to MS)" }, + { 0x04, "RP-ERROR (MS to Network)" }, + { 0x05, "RP-ERROR (Network to MS)" }, + { 0x06, "RP-SMMA (MS to Network)" }, + { 0, NULL }, +}; + +static const value_string gsm_bssmap_elem_strings[] = { + { 0x01, "Circuit Identity Code" }, + { 0x02, "Reserved" }, + { 0x03, "Resource Available" }, + { 0x04, "Cause" }, + { 0x05, "Cell Identifier" }, + { 0x06, "Priority" }, + { 0x07, "Layer 3 Header Information" }, + { 0x08, "IMSI" }, + { 0x09, "TMSI" }, + { 0x0a, "Encryption Information" }, + { 0x0b, "Channel Type" }, + { 0x0c, "Periodicity" }, + { 0x0d, "Extended Resource Indicator" }, + { 0x0e, "Number Of MSs" }, + { 0x0f, "Reserved" }, + { 0x10, "Reserved" }, + { 0x11, "Reserved" }, + { 0x12, "Classmark Information Type 2" }, + { 0x13, "Classmark Information Type 3" }, + { 0x14, "Interference Band To Be Used" }, + { 0x15, "RR Cause" }, + { 0x16, "Reserved" }, + { 0x17, "Layer 3 Information" }, + { 0x18, "DLCI" }, + { 0x19, "Downlink DTX Flag" }, + { 0x1a, "Cell Identifier List" }, + { 0x1b, "Response Request" }, + { 0x1c, "Resource Indication Method" }, + { 0x1d, "Classmark Information Type 1" }, + { 0x1e, "Circuit Identity Code List" }, + { 0x1f, "Diagnostic" }, + { 0x20, "Layer 3 Message Contents" }, + { 0x21, "Chosen Channel" }, + { 0x22, "Total Resource Accessible" }, + { 0x23, "Cipher Response Mode" }, + { 0x24, "Channel Needed" }, + { 0x25, "Trace Type" }, + { 0x26, "TriggerID" }, + { 0x27, "Trace Reference" }, + { 0x28, "TransactionID" }, + { 0x29, "Mobile Identity" }, + { 0x2a, "OMCID" }, + { 0x2b, "Forward Indicator" }, + { 0x2c, "Chosen Encryption Algorithm" }, + { 0x2d, "Circuit Pool" }, + { 0x2e, "Circuit Pool List" }, + { 0x2f, "Time Indication" }, + { 0x30, "Resource Situation" }, + { 0x31, "Current Channel Type 1" }, + { 0x32, "Queueing Indicator" }, + { 0x40, "Speech Version" }, + { 0x33, "Assignment Requirement" }, + { 0x35, "Talker Flag" }, + { 0x36, "Connection Release Requested" }, + { 0x37, "Group Call Reference" }, + { 0x38, "eMLPP Priority" }, + { 0x39, "Configuration Evolution Indication" }, + { 0x3a, "Old BSS to New BSS Information" }, + { 0x3b, "LSA Identifier" }, + { 0x3c, "LSA Identifier List" }, + { 0x3d, "LSA Information" }, + { 0x3e, "LCS QoS" }, + { 0x3f, "LSA access control suppression" }, + { 0x43, "LCS Priority" }, + { 0x44, "Location Type" }, + { 0x45, "Location Estimate" }, + { 0x46, "Positioning Data" }, + { 0x47, "LCS Cause" }, + { 0x48, "LCS Client Type" }, + { 0x49, "APDU" }, + { 0x4a, "Network Element Identity" }, + { 0x4b, "GPS Assistance Data" }, + { 0x4c, "Deciphering Keys" }, + { 0x4d, "Return Error Request" }, + { 0x4e, "Return Error Cause" }, + { 0x4f, "Segmentation" }, + { 0, NULL }, +}; + +static const value_string gsm_dtap_elem_strings[] = { + /* Common Information Elements 10.5.1 */ + { 0x00, "Cell Identity" }, + { 0x00, "Ciphering Key Sequence Number" }, + { 0x00, "Location Area Identification" }, + { 0x00, "Mobile Identity" }, + { 0x00, "Mobile Station Classmark 1" }, + { 0x00, "Mobile Station Classmark 2" }, + { 0x00, "Mobile Station Classmark 3" }, + { 0x00, "Descriptive group or broadcast call reference" }, + { 0x00, "Group Cipher Key Number" }, + { 0x00, "PD and SAPI $(CCBS)$" }, + { 0x00, "Priority Level" }, + { 0x00, "PLMN List" }, + /* Radio Resource Management Information Elements 10.5.2, most are from 10.5.1 */ + { 0x00, "RR Cause" }, + /* Mobility Management Information Elements 10.5.3 */ + { 0x00, "Authentication Parameter RAND" }, + { 0x00, "Authentication Parameter AUTN (UMTS authentication challenge only)" }, + { 0x00, "Authentication Response Parameter" }, + { 0x00, "Authentication Response Parameter (extension) (UMTS authentication challenge only)" }, + { 0x00, "Authentication Failure Parameter (UMTS authentication challenge only)" }, + { 0x00, "CM Service Type" }, + { 0x00, "Identity Type" }, + { 0x00, "Location Updating Type" }, + { 0x00, "Network Name" }, + { 0x00, "Reject Cause" }, + { 0x00, "Follow-on Proceed" }, + { 0x00, "Time Zone" }, + { 0x00, "Time Zone and Time" }, + { 0x00, "CTS Permission" }, + { 0x00, "LSA Identifier" }, + { 0x00, "Daylight Saving Time" }, + /* Call Control Information Elements 10.5.4 */ + { 0x00, "Auxiliary States" }, + { 0x00, "Bearer Capability" }, + { 0x00, "Call Control Capabilities" }, + { 0x00, "Call State" }, + { 0x00, "Called Party BCD Number" }, + { 0x00, "Called Party Subaddress" }, + { 0x00, "Calling Party BCD Number" }, + { 0x00, "Calling Party Subaddress" }, + { 0x00, "Cause" }, + { 0x00, "CLIR Suppression" }, + { 0x00, "CLIR Invocation" }, + { 0x00, "Congestion Level" }, + { 0x00, "Connected Number" }, + { 0x00, "Connected Subaddress" }, + { 0x00, "Facility" }, + { 0x00, "High Layer Compatibility" }, + { 0x00, "Keypad Facility" }, + { 0x00, "Low Layer Compatibility" }, + { 0x00, "More Data" }, + { 0x00, "Notification Indicator" }, + { 0x00, "Progress Indicator" }, + { 0x00, "Recall type $(CCBS)$" }, + { 0x00, "Redirecting Party BCD Number" }, + { 0x00, "Redirecting Party Subaddress" }, + { 0x00, "Repeat Indicator" }, + { 0x00, "Reverse Call Setup Direction" }, + { 0x00, "SETUP Container $(CCBS)$" }, + { 0x00, "Signal" }, + { 0x00, "SS Version Indicator" }, + { 0x00, "User-user" }, + { 0x00, "Alerting Pattern $(NIA)$" }, + { 0x00, "Allowed Actions $(CCBS)$" }, + { 0x00, "Stream Identifier" }, + { 0x00, "Network Call Control Capabilities" }, + { 0x00, "Cause of No CLI" }, + { 0x00, "Immediate Modification Indicator" }, + { 0x00, "Supported Codec List" }, + { 0x00, "Service Category" }, + /* GPRS Mobility Management Information Elements 10.5.5 */ + { 0x00, "Attach Result" }, + { 0x00, "Attach Type" }, + { 0x00, "TMSI Status" }, + { 0x00, "Detach Type" }, + { 0x00, "DRX Parameter" }, + { 0x00, "Force to Standby" }, + { 0x00, "P-TMSI Signature" }, + { 0x00, "P-TMSI Signature 2" }, + { 0x00, "Identity Type 2" }, + { 0x00, "IMEISV Request" }, + { 0x00, "Receive N-PDU Numbers List" }, + { 0x00, "MS Network Capability" }, + { 0x00, "MS Radio Access Capability" }, + { 0x00, "GMM Cause" }, + { 0x00, "Routing Area Identification" }, + { 0x00, "Update Result" }, + { 0x00, "A&C Reference Number" }, + { 0x00, "Service Type" }, + { 0x00, "Cell Notification" }, + { 0x00, "Network Feature Support" }, + /* Short Message Service Information Elements [5] 8.1.4 */ + { 0x00, "CP-User Data" }, + { 0x00, "CP-Cause" }, + /* Short Message Service Information Elements [5] 8.2 */ + { 0x00, "RP-Message Reference" }, + { 0x00, "RP-Origination Address" }, + { 0x00, "RP-Destination Address" }, + { 0x00, "RP-User Data" }, + { 0x00, "RP-Cause" }, + /* Session Management Information Elements 10.5.6 */ + { 0x00, "Access Point Name" }, + { 0x00, "Network Service Access Point Identifier" }, + { 0x00, "Protocol Configuration Options" }, + { 0x00, "Packet Data Protocol Address" }, + { 0x00, "Quality Of Service" }, + { 0x00, "SM Cause" }, + { 0x00, "Linked TI" }, + { 0x00, "LLC Service Access Point Identifier" }, + { 0x00, "Tear Down Indicator" }, + { 0x00, "Packet Flow Identifier" }, + { 0x00, "Traffic Flow Template" }, + /* GPRS Common Information Elements 10.5.7 */ + { 0x00, "PDP Context Status" }, + { 0x00, "Radio Priority" }, + { 0x00, "GPRS Timer" }, + { 0x00, "GPRS Timer 2" }, + { 0, NULL }, +}; + +static const gchar *pd_str[] = { + "Group Call Control", + "Broadcast Call Control", + "Reserved: was allocated in earlier phases of the protocol", + "Call Control; call related SS messages", + "GPRS Transparent Transport Protocol (GTTP)", + "Mobility Management messages", + "Radio Resources Management messages", + "Unknown", + "GPRS Mobility Management messages", + "SMS messages", + "GPRS Session Management messages", + "Non call related SS messages", + "Location Services", + "Unknown", + "Reserved for extension of the PD to one octet length", + "Reserved for tests procedures" +}; + +static const value_string bssap_cc_values[] = { + { 0x00, "not further specified" }, + { 0x80, "FACCH or SDCCH" }, + { 0xc0, "SACCH" }, + { 0, NULL } }; + +static const value_string bssap_sapi_values[] = { + { 0x00, "RR/MM/CC" }, + { 0x03, "SMS" }, + { 0, NULL } }; + +static const gchar *cell_disc_str[] = { + "The whole Cell Global Identification, CGI, is used to identify the cells", + "Location Area Code, LAC, and Cell Identify, CI, is used to identify the cells", + "Cell Identity, CI, is used to identify the cells", + "No cell is associated with the transaction", + "Location Area Identification, LAI, is used to identify all cells within a Location Area", + "Location Area Code, LAC, is used to identify all cells within a location area", + "All cells on the BSS are identified" +}; +#define NUM_CELL_DISC_STR (sizeof(cell_disc_str)/sizeof(gchar *)) + +#define DTAP_PD_MASK 0x0f +#define DTAP_SKIP_MASK 0xf0 +#define DTAP_TI_MASK DTAP_SKIP_MASK +#define DTAP_TIE_PRES_MASK 0x07 /* after TI shifted to right */ +#define DTAP_TIE_MASK 0x7f + +#define DTAP_MM_IEI_MASK 0x3f +#define DTAP_RR_IEI_MASK 0xff +#define DTAP_CC_IEI_MASK 0x3f +#define DTAP_GMM_IEI_MASK 0xff +#define DTAP_SMS_IEI_MASK 0xff +#define DTAP_SM_IEI_MASK 0xff +#define DTAP_SS_IEI_MASK 0x3f + +/* Initialize the protocol and registered fields */ +static int proto_a_bssmap = -1; +static int proto_a_dtap = -1; +static int proto_a_rp = -1; + +static int hf_gsm_a_none = -1; +static int hf_gsm_a_bssmap_msg_type = -1; +static int hf_gsm_a_dtap_msg_mm_type = -1; +static int hf_gsm_a_dtap_msg_rr_type = -1; +static int hf_gsm_a_dtap_msg_cc_type = -1; +static int hf_gsm_a_dtap_msg_gmm_type = -1; +static int hf_gsm_a_dtap_msg_sms_type = -1; +static int hf_gsm_a_dtap_msg_sm_type = -1; +static int hf_gsm_a_dtap_msg_ss_type = -1; +static int hf_gsm_a_rp_msg_type = -1; +static int hf_gsm_a_length = -1; +static int hf_gsm_a_bssmap_elem_id = -1; +static int hf_gsm_a_dtap_elem_id = -1; +static int hf_gsm_a_imsi = -1; +static int hf_gsm_a_tmsi = -1; +static int hf_gsm_a_imei = -1; +static int hf_gsm_a_imeisv = -1; +static int hf_gsm_a_cld_party_bcd_num = -1; +static int hf_gsm_a_clg_party_bcd_num = -1; +static int hf_gsm_a_cell_ci = -1; +static int hf_gsm_a_cell_lac = -1; +static int hf_gsm_a_dlci_cc = -1; +static int hf_gsm_a_dlci_spare = -1; +static int hf_gsm_a_dlci_sapi = -1; + +/* Initialize the subtree pointers */ +static gint ett_bssmap_msg = -1; +static gint ett_dtap_msg = -1; +static gint ett_rp_msg = -1; +static gint ett_elems = -1; +static gint ett_elem = -1; +static gint ett_dtap_oct_1 = -1; +static gint ett_cm_srvc_type = -1; +static gint ett_gsm_enc_info = -1; +static gint ett_cell_list = -1; +static gint ett_dlci = -1; + +static char a_bigbuf[1024]; +static gchar a_add_string[1024]; + +static dissector_handle_t data_handle; +static dissector_handle_t bssmap_handle; +static dissector_handle_t dtap_handle; +static dissector_handle_t rp_handle; +static dissector_table_t sms_dissector_table; /* SMS TPDU */ + +static packet_info *g_pinfo; +static proto_tree *g_tree; + +/* + * current RP message type + */ +static gint gsm_a_rp_type; + +/* + * this should be set on a per message basis, if possible + */ +#define IS_UPLINK_FALSE 0 +#define IS_UPLINK_TRUE 1 +#define IS_UPLINK_UNKNOWN 2 +static gint is_uplink; + + +typedef struct dgt_set_t +{ + unsigned char out[15]; +} +dgt_set_t; + +static dgt_set_t Dgt_mbcd = { + { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e */ + '0','1','2','3','4','5','6','7','8','9','*','#','a','b','c' + } +}; + +static dgt_set_t Dgt_tbcd = { + { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e */ + '0','1','2','3','4','5','6','7','8','9','?','B','C','*','#' + } +}; + +static dgt_set_t Dgt_msid = { + { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e */ + '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?' + } +}; + +/* FUNCTIONS */ + +/* + * Unpack BCD input pattern into output ASCII pattern + * + * Input Pattern is supplied using the same format as the digits + * + * Returns: length of unpacked pattern + */ +static int +my_dgt_tbcd_unpack( + char *out, /* ASCII pattern out */ + guchar *in, /* packed pattern in */ + int num_octs, /* Number of octets to unpack */ + dgt_set_t *dgt /* Digit definitions */ + ) +{ + int cnt = 0; + unsigned char i; + + while (num_octs) + { + /* + * unpack first value in byte + */ + i = *in++; + *out++ = dgt->out[i & 0x0f]; + cnt++; + + /* + * unpack second value in byte + */ + i >>= 4; + + if (i == 0x0f) /* odd number bytes - hit filler */ + break; + + *out++ = dgt->out[i]; + cnt++; + num_octs--; + } + + *out = '\0'; + + return(cnt); +} + +/* Generate, into "buf", a string showing the bits of a bitfield. + * Return a pointer to the character after that string. + */ +static char * +my_decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width) +{ + int i; + guint32 bit; + char *p; + + i = 0; + p = buf; + bit = 1 << (width - 1); + + for (;;) + { + if (mask & bit) + { + /* This bit is part of the field. Show its value. */ + if (val & bit) + { + *p++ = '1'; + } + else + { + *p++ = '0'; + } + } + else + { + /* This bit is not part of the field. */ + *p++ = '.'; + } + + bit >>= 1; + i++; + + if (i >= width) break; + + if (i % 4 == 0) *p++ = ' '; + } + + *p = '\0'; + + return(p); +} + +static gchar * +my_match_strval(guint32 val, const value_string *vs, gint *idx) +{ + gint i = 0; + + while (vs[i].strptr) + { + if (vs[i].value == val) + { + *idx = i; + return(vs[i].strptr); + } + + i++; + } + + *idx = -1; + return(NULL); +} + +/* ELEMENT FUNCTIONS */ + +#define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \ + if ((edc_len) > (edc_max_len)) \ + { \ + proto_tree_add_text(tree, tvb, \ + curr_offset, (edc_len) - (edc_max_len), "Extraneous Data"); \ + curr_offset += ((edc_len) - (edc_max_len)); \ + } + +#define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \ + if ((sdc_len) < (sdc_min_len)) \ + { \ + proto_tree_add_text(tree, tvb, \ + curr_offset, (sdc_len), "Short Data (?)"); \ + curr_offset += (sdc_len); \ + return(curr_offset - offset); \ + } + +#define EXACT_DATA_CHECK(edc_len, edc_eq_len) \ + if ((edc_len) != (edc_eq_len)) \ + { \ + proto_tree_add_text(tree, tvb, \ + curr_offset, (edc_len), "Unexpected Data Length"); \ + curr_offset += (edc_len); \ + return(curr_offset - offset); \ + } + +#define NO_MORE_DATA_CHECK(nmdc_len) \ + if ((nmdc_len) == (curr_offset - offset)) return(nmdc_len); + +/* + * Decode the MCC/MNC from 3 octets in 'octs' + */ +static void +mcc_mnc_aux(guint8 *octs, gchar *mcc, gchar *mnc) +{ + if ((octs[0] & 0x0f) <= 9) + { + mcc[0] = Dgt_tbcd.out[octs[0] & 0x0f]; + } + else + { + mcc[0] = (octs[0] & 0x0f) + 55; + } + + if (((octs[0] & 0xf0) >> 4) <= 9) + { + mcc[1] = Dgt_tbcd.out[(octs[0] & 0xf0) >> 4]; + } + else + { + mcc[1] = ((octs[0] & 0xf0) >> 4) + 55; + } + + if ((octs[1] & 0x0f) <= 9) + { + mcc[2] = Dgt_tbcd.out[octs[1] & 0x0f]; + } + else + { + mcc[2] = (octs[1] & 0x0f) + 55; + } + + mcc[3] = '\0'; + + if (((octs[1] & 0xf0) >> 4) <= 9) + { + mnc[2] = Dgt_tbcd.out[(octs[1] & 0xf0) >> 4]; + } + else + { + mnc[2] = ((octs[1] & 0xf0) >> 4) + 55; + } + + if ((octs[2] & 0x0f) <= 9) + { + mnc[0] = Dgt_tbcd.out[octs[2] & 0x0f]; + } + else + { + mnc[0] = (octs[2] & 0x0f) + 55; + } + + if (((octs[2] & 0xf0) >> 4) <= 9) + { + mnc[1] = Dgt_tbcd.out[(octs[2] & 0xf0) >> 4]; + } + else + { + mnc[1] = ((octs[2] & 0xf0) >> 4) + 55; + } + + if (mnc[1] == 'F') + { + /* + * only a 1 digit MNC (very old) + */ + mnc[1] = '\0'; + } + else if (mnc[2] == 'F') + { + /* + * only a 2 digit MNC + */ + mnc[2] = '\0'; + } + else + { + mnc[3] = '\0'; + } +} + +typedef enum +{ + BE_CIC, /* Circuit Identity Code */ + BE_RSVD_1, /* Reserved */ + BE_RES_AVAIL, /* Resource Available */ + BE_CAUSE, /* Cause */ + BE_CELL_ID, /* Cell Identifier */ + BE_PRIO, /* Priority */ + BE_L3_HEADER_INFO, /* Layer 3 Header Information */ + BE_IMSI, /* IMSI */ + BE_TMSI, /* TMSI */ + BE_ENC_INFO, /* Encryption Information */ + BE_CHAN_TYPE, /* Channel Type */ + BE_PERIODICITY, /* Periodicity */ + BE_EXT_RES_IND, /* Extended Resource Indicator */ + BE_NUM_MS, /* Number Of MSs */ + BE_RSVD_2, /* Reserved */ + BE_RSVD_3, /* Reserved */ + BE_RSVD_4, /* Reserved */ + BE_CM_INFO_2, /* Classmark Information Type 2 */ + BE_CM_INFO_3, /* Classmark Information Type 3 */ + BE_INT_BAND, /* Interference Band To Be Used */ + BE_RR_CAUSE, /* RR Cause */ + BE_RSVD_5, /* Reserved */ + BE_L3_INFO, /* Layer 3 Information */ + BE_DLCI, /* DLCI */ + BE_DOWN_DTX_FLAG, /* Downlink DTX Flag */ + BE_CELL_ID_LIST, /* Cell Identifier List */ + BE_RESP_REQ, /* Response Request */ + BE_RES_IND_METHOD, /* Resource Indication Method */ + BE_CM_INFO_1, /* Classmark Information Type 1 */ + BE_CIC_LIST, /* Circuit Identity Code List */ + BE_DIAG, /* Diagnostic */ + BE_L3_MSG, /* Layer 3 Message Contents */ + BE_CHOSEN_CHAN, /* Chosen Channel */ + BE_TOT_RES_ACC, /* Total Resource Accessible */ + BE_CIPH_RESP_MODE, /* Cipher Response Mode */ + BE_CHAN_NEEDED, /* Channel Needed */ + BE_TRACE_TYPE, /* Trace Type */ + BE_TRIGGERID, /* TriggerID */ + BE_TRACE_REF, /* Trace Reference */ + BE_TRANSID, /* TransactionID */ + BE_MID, /* Mobile Identity */ + BE_OMCID, /* OMCID */ + BE_FOR_IND, /* Forward Indicator */ + BE_CHOSEN_ENC_ALG, /* Chosen Encryption Algorithm */ + BE_CCT_POOL, /* Circuit Pool */ + BE_CCT_POOL_LIST, /* Circuit Pool List */ + BE_TIME_IND, /* Time Indication */ + BE_RES_SIT, /* Resource Situation */ + BE_CURR_CHAN_1, /* Current Channel Type 1 */ + BE_QUE_IND, /* Queueing Indicator */ + BE_SPEECH_VER, /* Speech Version */ + BE_ASS_REQ, /* Assignment Requirement */ + BE_TALKER_FLAG, /* Talker Flag */ + BE_CONN_REL_REQ, /* Connection Release Requested */ + BE_GROUP_CALL_REF, /* Group Call Reference */ + BE_EMLPP_PRIO, /* eMLPP Priority */ + BE_CONF_EVO_IND, /* Configuration Evolution Indication */ + BE_OLD2NEW_INFO, /* Old BSS to New BSS Information */ + BE_LSA_ID, /* LSA Identifier */ + BE_LSA_ID_LIST, /* LSA Identifier List */ + BE_LSA_INFO, /* LSA Information */ + BE_LCS_QOS, /* LCS QoS */ + BE_LSA_ACC_CTRL, /* LSA access control suppression */ + BE_LCS_PRIO, /* LCS Priority */ + BE_LOC_TYPE, /* Location Type */ + BE_LOC_EST, /* Location Estimate */ + BE_POS_DATA, /* Positioning Data */ + BE_LCS_CAUSE, /* LCS Cause */ + BE_LCS_CLIENT, /* LCS Client Type */ + BE_APDU, /* APDU */ + BE_NE_ID, /* Network Element Identity */ + BE_GSP_ASSIST_DATA, /* GPS Assistance Data */ + BE_DECIPH_KEYS, /* Deciphering Keys */ + BE_RET_ERR_REQ, /* Return Error Request */ + BE_RET_ERR_CAUSE, /* Return Error Cause */ + BE_SEG, /* Segmentation */ + BE_NONE, /* NONE */ +} +bssmap_elem_idx_t; + +#define NUM_GSM_BSSMAP_ELEM (sizeof(gsm_bssmap_elem_strings)/sizeof(value_string)) +static gint ett_gsm_bssmap_elem[NUM_GSM_BSSMAP_ELEM]; + +/* + * [2] 3.2.2.2 + */ +static guint8 +be_cic(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + guint32 value; + + len = len; + curr_offset = offset; + + value = tvb_get_ntohs(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, value, 0xffe0, 16); + proto_tree_add_text(tree, + tvb, curr_offset, 2, + "%s : PCM Multiplexer: %d", + a_bigbuf, + (value & 0xffe0) >> 5); + + my_decode_bitfield_value(a_bigbuf, value, 0x001f, 16); + proto_tree_add_text(tree, + tvb, curr_offset, 2, + "%s : Timeslot: %d", + a_bigbuf, + value & 0x001f); + + curr_offset += 2; + + sprintf(add_string, " - (%1$d) (0x%1$04x)", value); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.5 + */ +static guint8 +be_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 value; + guint32 curr_offset; + gchar *str = NULL; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension: %s", + a_bigbuf, + (oct & 0x80) ? "extended" : "not extended"); + + if (oct & 0x80) + { + /* 2 octet cause */ + + if ((oct & 0x0f) == 0x00) + { + /* national cause */ + switch ((oct & 0x70) >> 4) + { + case 0: str = "Normal Event"; break; + case 1: str = "Normal Event"; break; + case 2: str = "Resource Unavailable"; break; + case 3: str = "Service or option not available"; break; + case 4: str = "Service or option not implemented"; break; + case 5: str = "Invalid message (e.g., parameter out of range)"; break; + case 6: str = "Protocol error"; break; + default: + str = "Interworking"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cause Class: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : National Cause", + a_bigbuf); + + curr_offset++; + + proto_tree_add_text(tree, tvb, curr_offset, 1, + "Cause Value"); + + curr_offset++; + + strcpy(add_string, " - (National Cause)"); + } + else + { + value = tvb_get_guint8(tvb, curr_offset + 1); + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cause (MSB): %d", + a_bigbuf, + ((oct & 0x7f) << 8) | value); + + curr_offset++; + + my_decode_bitfield_value(a_bigbuf, value, 0xff, 8); + proto_tree_add_text(tree, tvb, curr_offset, 1, + "%s : Cause (LSB)", + a_bigbuf); + + curr_offset++; + } + } + else + { + switch (oct) + { + case 0x00: str = "Radio interface message failure"; break; + case 0x01: str = "Radio interface failure"; break; + case 0x02: str = "Uplink quality"; break; + case 0x03: str = "Uplink strength"; break; + case 0x04: str = "Downlink quality"; break; + case 0x05: str = "Downlink strength"; break; + case 0x06: str = "Distance"; break; + case 0x07: str = "O and M intervention"; break; + case 0x08: str = "Response to MSC invocation"; break; + case 0x09: str = "Call control"; break; + case 0x0a: str = "Radio interface failure, reversion to old channel"; break; + case 0x0b: str = "Handover successful"; break; + case 0x0c: str = "Better Cell"; break; + case 0x0d: str = "Directed Retry"; break; + case 0x0e: str = "Joined group call channel"; break; + case 0x0f: str = "Traffic"; break; + + case 0x20: str = "Equipment failure"; break; + case 0x21: str = "No radio resource available"; break; + case 0x22: str = "Requested terrestrial resource unavailable"; break; + case 0x23: str = "CCCH overload"; break; + case 0x24: str = "Processor overload"; break; + case 0x25: str = "BSS not equipped"; break; + case 0x26: str = "MS not equipped"; break; + case 0x27: str = "Invalid cell"; break; + case 0x28: str = "Traffic Load"; break; + case 0x29: str = "Preemption"; break; + + case 0x30: str = "Requested transcoding/rate adaption unavailable"; break; + case 0x31: str = "Circuit pool mismatch"; break; + case 0x32: str = "Switch circuit pool"; break; + case 0x33: str = "Requested speech version unavailable"; break; + case 0x34: str = "LSA not allowed"; break; + + case 0x40: str = "Ciphering algorithm not supported"; break; + + case 0x50: str = "Terrestrial circuit already allocated"; break; + case 0x51: str = "Invalid message contents"; break; + case 0x52: str = "Information element or field missing"; break; + case 0x53: str = "Incorrect value"; break; + case 0x54: str = "Unknown Message type"; break; + case 0x55: str = "Unknown Information Element"; break; + + case 0x60: str = "Protocol Error between BSS and MSC"; break; + case 0x61: str = "VGCS/VBS call non existent"; break; + + default: + if ((oct >= 0x10) && (oct <= 0x17)) { str = "Reserved for international use"; } + else if ((oct >= 0x18) && (oct <= 0x1f)) { str = "Reserved for national use"; } + else if ((oct >= 0x2a) && (oct <= 0x2f)) { str = "Reserved for national use"; } + else if ((oct >= 0x35) && (oct <= 0x3f)) { str = "Reserved for international use"; } + else if ((oct >= 0x41) && (oct <= 0x47)) { str = "Reserved for international use"; } + else if ((oct >= 0x48) && (oct <= 0x4f)) { str = "Reserved for national use"; } + else if ((oct >= 0x56) && (oct <= 0x57)) { str = "Reserved for international use"; } + else if ((oct >= 0x58) && (oct <= 0x5f)) { str = "Reserved for national use"; } + else if ((oct >= 0x62) && (oct <= 0x67)) { str = "Reserved for international use"; } + else if ((oct >= 0x68) && (oct <= 0x6f)) { str = "Reserved for national use"; } + else if ((oct >= 0x70) && (oct <= 0x77)) { str = "Reserved for international use"; } + else if ((oct >= 0x78) && (oct <= 0x7f)) { str = "Reserved for national use"; } + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cause: (%d) %s", + a_bigbuf, + oct & 0x7f, + str); + + curr_offset++; + + sprintf(add_string, " - (%d) %s", oct & 0x7f, str); + } + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.7 + */ +static guint8 +be_tmsi(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + guint32 value; + + curr_offset = offset; + + value = tvb_get_ntohl(tvb, curr_offset); + + proto_tree_add_uint(tree, hf_gsm_a_tmsi, + tvb, curr_offset, 4, + value); + + sprintf(add_string, " - (0x%04x)", value); + + curr_offset += 4; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.9 + */ +static guint8 +be_l3_header_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, DTAP_PD_MASK, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Protocol Discriminator: %s", + a_bigbuf, + pd_str[oct & DTAP_PD_MASK]); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : TI flag: %s", + a_bigbuf, + ((oct & 0x08) ? "allocated by receiver" : "allocated by sender")); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : TIO: %d", + a_bigbuf, + oct & 0x07); + + curr_offset++; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.10 + */ +static guint8 +be_enc_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 mask; + guint8 alg_id; + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + mask = 0x80; + alg_id = 7; + + do + { + my_decode_bitfield_value(a_bigbuf, oct, mask, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : GSM A5/%d: %spermitted", + a_bigbuf, + alg_id, + (mask & oct) ? "" : "not "); + + mask >>= 1; + alg_id--; + } + while (mask != 0x01); + + my_decode_bitfield_value(a_bigbuf, oct, mask, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : No encryption: %spermitted", + a_bigbuf, + (mask & oct) ? "" : "not "); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Key"); + + curr_offset += len - (curr_offset - offset); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.11 + */ +static guint8 +be_chan_type(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 sdi; + guint8 num_chan; + guint32 curr_offset; + gchar *str; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + sdi = oct & 0x0f; + switch (sdi) + { + case 1: str = "Speech"; break; + case 2: str = "Data"; break; + case 3: str = "Signalling"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Speech/Data Indicator: %s", + a_bigbuf, + str); + + sprintf(add_string, " - (%s)", str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + if (sdi == 0x01) + { + /* speech */ + + switch (oct) + { + case 0x08: str = "Full rate TCH channel Bm. Prefer full rate TCH"; break; + case 0x09: str = "Half rate TCH channel Lm. Prefer half rate TCH"; break; + case 0x0a: str = "Full or Half rate channel, Full rate preferred changes allowed after first allocation"; break; + case 0x0b: str = "Full or Half rate channel, Half rate preferred changes allowed after first allocation"; break; + case 0x1a: str = "Full or Half rate channel, Full rate preferred changes between full and half rate not allowed after first allocation"; break; + case 0x1b: str = "Full or Half rate channel, Half rate preferred changes between full and half rate not allowed after first allocation"; break; + case 0x0f: str = "Full or Half rate channel, changes allowed after first allocation"; break; + case 0x1f: str = "Full or Half rate channel, changes between full and half rate not allowed after first allocation"; break; + default: + str = "Reserved"; + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Channel Rate and Type: %s", + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + do + { + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension: %s", + a_bigbuf, + (oct & 0x80) ? "extended" : "not extended"); + + switch (oct & 0x7f) + { + case 0x01: str = "GSM speech full rate version 1"; break; + case 0x11: str = "GSM speech full rate version 2"; break; + case 0x21: str = "GSM speech full rate version 3 (AMR)"; break; + + case 0x05: str = "GSM speech half rate version 1"; break; + case 0x15: str = "GSM speech half rate version 2"; break; + case 0x25: str = "GSM speech half rate version 3 (AMR)"; break; + + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Speech version identifier: %s", + a_bigbuf, + str); + + curr_offset++; + } + while ((len - (curr_offset - offset)) > 0); + } + else if (sdi == 0x02) + { + /* data */ + + num_chan = 0; + + switch (oct) + { + case 0x08: str = "Full rate TCH channel Bm"; break; + case 0x09: str = "Half rate TCH channel Lm"; break; + case 0x0a: str = "Full or Half rate TCH channel, Full rate preferred, changes allowed also after first channel allocation as a result of the request"; break; + case 0x0b: str = "Full or Half rate TCH channel, Half rate preferred, changes allowed also after first channel allocation as a result of the request"; break; + case 0x1a: str = "Full or Half rate TCH channel, Full rate preferred, changes not allowed after first channel allocation as a result of the request"; break; + case 0x1b: str = "Full or Half rate TCH channel. Half rate preferred, changes not allowed after first channel allocation as a result of the request"; break; + default: + if ((oct >= 0x20) && (oct <= 0x27)) + { + str = "Full rate TCH channels in a multislot configuration, changes by the BSS of the the number of TCHs and if applicable the used radio interface rate per channel allowed after first channel allocation as a result of the request"; + + num_chan = (oct - 0x20) + 1; + } + else if ((oct >= 0x30) && (oct <= 0x37)) + { + str = "Full rate TCH channels in a multislot configuration, changes by the BSS of the number of TCHs or the used radio interface rate per channel not allowed after first channel allocation as a result of the request"; + + num_chan = (oct - 0x30) + 1; + } + else + { + str = "Reserved"; + } + break; + } + + if (num_chan > 0) + { + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Channel Rate and Type: Max channels %d, %s", + num_chan, + str); + } + else + { + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Channel Rate and Type: %s", + str); + } + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension: %s", + a_bigbuf, + (oct & 0x80) ? "extended" : "not extended"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x40, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : %sTransparent service", + a_bigbuf, + (oct & 0x40) ? "Non-" : ""); + + if (num_chan == 0) + { + if (oct & 0x40) + { + /* non-transparent */ + + switch (oct & 0x3f) + { + case 0x00: str = "12 kbit/s if the channel is a full rate TCH, or 6 kbit/s if the channel is a half rate TCH"; break; + case 0x18: str = "14.5 kbit/s"; break; + case 0x10: str = "12 kbits/s"; break; + case 0x11: str = "6 kbits/s"; break; + default: + str = "Reserved"; + break; + } + } + else + { + switch (oct & 0x3f) + { + case 0x18: str = "14.4 kbit/s"; break; + case 0x10: str = "9.6kbit/s"; break; + case 0x11: str = "4.8kbit/s"; break; + case 0x12: str = "2.4kbit/s"; break; + case 0x13: str = "1.2Kbit/s"; break; + case 0x14: str = "600 bit/s"; break; + case 0x15: str = "1200/75 bit/s (1200 network-to-MS / 75 MS-to-network)"; break; + default: + str = "Reserved"; + break; + } + } + } + else + { + if (oct & 0x40) + { + /* non-transparent */ + + switch (oct & 0x3f) + { + case 0x16: str = "58 kbit/s (4x14.5 kbit/s)"; break; + case 0x14: str = "48.0 / 43.5 kbit/s (4x12 kbit/s or 3x14.5 kbit/s)"; break; + case 0x13: str = "36.0 / 29.0 kbit/s (3x12 kbit/s or 2x14.5 kbit/s)"; break; + case 0x12: str = "24.0 / 24.0 (4x6 kbit/s or 2x12 kbit/s)"; break; + case 0x11: str = "18.0 / 14.5 kbit/s (3x6 kbit/s or 1x14.5 kbit/s)"; break; + case 0x10: str = "12.0 / 12.0 kbit/s (2x6 kbit/s or 1x12 kbit/s)"; break; + default: + str = "Reserved"; + break; + } + } + else + { + switch (oct & 0x3f) + { + case 0x1f: str = "64 kbit/s, bit transparent"; break; + case 0x1e: str = "56 kbit/s, bit transparent"; break; + case 0x1d: str = "56 kbit/s"; break; + case 0x1c: str = "48 kbit/s"; break; + case 0x1b: str = "38.4 kbit/s"; break; + case 0x1a: str = "28.8 kbit/s"; break; + case 0x19: str = "19.2 kbit/s"; break; + case 0x18: str = "14.4 kbit/s"; break; + case 0x10: str = "9.6 kbit/s"; break; + default: + str = "Reserved"; + break; + } + } + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Rate: %s", + a_bigbuf, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension: %s", + a_bigbuf, + (oct & 0x80) ? "extended" : "not extended"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + if (num_chan == 0) + { + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : 14.5 kbit/s (TCH/F14.4) %sallowed", + a_bigbuf, + (oct & 0x08) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x04, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : 12.0 kbit/s (TCH F/9.6) %sallowed", + a_bigbuf, + (oct & 0x02) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : 6.0 kbit/s (TCH F/4.8) %sallowed", + a_bigbuf, + (oct & 0x01) ? "" : "not "); + } + else + { + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : 14.5/14.4 kbit/s (TCH/F14.4) %sallowed", + a_bigbuf, + (oct & 0x08) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x04, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : 12.0/9.6 kbit/s (TCH F/9.6) %sallowed", + a_bigbuf, + (oct & 0x02) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : 6.0/4.8 kbit/s (TCH F/4.8) %sallowed", + a_bigbuf, + (oct & 0x01) ? "" : "not "); + } + + curr_offset++; + } + else if (sdi == 0x03) + { + /* signalling */ + + switch (oct) + { + case 0x00: str = "SDCCH or Full rate TCH channel Bm or Half rate TCH channel Lm"; break; + case 0x01: str = "SDCCH"; break; + case 0x02: str = "SDCCH or Full rate TCH channel Bm"; break; + case 0x03: str = "SDCCH or Half rate TCH channel Lm"; break; + case 0x08: str = "Full rate TCH channel Bm"; break; + case 0x09: str = "Half rate TCH channel Lm"; break; + case 0x0a: str = "Full or Half rate TCH channel, Full rate preferred, changes allowed also after first channel allocation as a result of the request"; break; + case 0x0b: str = "Full or Half rate TCH channel, Half rate preferred, changes allowed also after first channel allocation as a result of the request"; break; + case 0x1a: str = "Full or Half rate TCH channel, Full rate preferred, changes not allowed after first channel allocation as a result of the request"; break; + case 0x1b: str = "Full or Half rate TCH channel. Half rate preferred, changes not allowed after first channel allocation as a result of the request"; break; + default: + str = "Reserved"; + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Channel Rate and Type: %s", + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Spare"); + + curr_offset += len - (curr_offset - offset); + } + else + { + /* unknown format */ + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Unknown format"); + + curr_offset += len - (curr_offset - offset); + } + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.17 + * Formats everything after the discriminator, shared function + */ +static guint8 +be_cell_id_aux(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, guint8 disc) +{ + guint8 octs[3]; + guint32 value; + guint32 curr_offset; + gchar mcc[4]; + gchar mnc[4]; + + add_string[0] = '\0'; + curr_offset = offset; + + switch (disc) + { + case 0x00: + /* FALLTHRU */ + + case 0x04: + octs[0] = tvb_get_guint8(tvb, curr_offset); + octs[1] = tvb_get_guint8(tvb, curr_offset + 1); + octs[2] = tvb_get_guint8(tvb, curr_offset + 2); + + mcc_mnc_aux(octs, mcc, mnc); + + proto_tree_add_text(tree, + tvb, curr_offset, 3, + "Mobile Country Code (MCC): %s, Mobile Network Code (MNC): %s", + mcc, + mnc); + + curr_offset += 3; + + /* FALLTHRU */ + + case 0x01: + case 0x05: + + /* LAC */ + + value = tvb_get_ntohs(tvb, curr_offset); + + proto_tree_add_uint(tree, hf_gsm_a_cell_lac, tvb, + curr_offset, 2, value); + + curr_offset += 2; + + sprintf(add_string, " - LAC (0x%04x)", value); + + if ((disc == 0x04) || (disc == 0x05)) break; + + /* FALLTHRU */ + + case 0x02: + + /* CI */ + + value = tvb_get_ntohs(tvb, curr_offset); + + proto_tree_add_uint(tree, hf_gsm_a_cell_ci, tvb, + curr_offset, 2, value); + + curr_offset += 2; + + if (add_string[0] == '\0') + { + sprintf(add_string, " - CI (%d)", value); + } + else + { + sprintf(add_string, "%s/CI (%d)", add_string, value); + } + break; + + default: + proto_tree_add_text(tree, tvb, curr_offset, len - 1, + "Cell ID - Unknown format"); + + curr_offset += (len - 1); + break; + } + + return(curr_offset - offset); +} + +static guint8 +be_cell_id(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 disc; + guint32 curr_offset; + const gchar *str = NULL; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + disc = oct & 0x0f; + + if (disc >= (gint) NUM_CELL_DISC_STR) + { + str = "Unknown"; + } + else + { + str = cell_disc_str[disc]; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cell Identification Discriminator: (%d) %s", + a_bigbuf, + disc, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + curr_offset += + be_cell_id_aux(tvb, tree, curr_offset, len - (curr_offset - offset), add_string, disc); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.18 + */ +static guint8 +be_prio(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x40, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Preemption Capability Indicator (PCI): this allocation request %s preempt an existing connection", + a_bigbuf, + (oct & 0x40) ? "may" : "shall not"); + + switch ((oct & 0x3c) >> 2) + { + case 0x00: str = "Spare"; break; + case 0x0f: str = "priority not used"; break; + default: + str = "1 is highest"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x3c, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Priority Level: (%d) %s", + a_bigbuf, + (oct & 0x3c) >> 2, + str); + + sprintf(add_string, " - (%d)", (oct & 0x3c) >> 2); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Queuing Allowed Indicator (QA): queuing %sallowed", + a_bigbuf, + (oct & 0x02) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Preemption Vulnerability Indicator (PVI): this connection %s be preempted by another allocation request", + a_bigbuf, + (oct & 0x01) ? "might" : "shall not"); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.24 + */ +static guint8 +be_l3_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + tvbuff_t *l3_tvb; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, tvb, curr_offset, len, + "Layer 3 Information value"); + + /* + * dissect the embedded DTAP message + */ + l3_tvb = tvb_new_subset(tvb, curr_offset, len, len); + + call_dissector(dtap_handle, l3_tvb, g_pinfo, g_tree); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.25 + */ +static guint8 +be_dlci(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + proto_item *item = NULL; + proto_tree *subtree = NULL; + + len = len; + add_string = add_string; + curr_offset = offset; + + item = + proto_tree_add_text(tree, tvb, curr_offset, 1, + "Data Link Connection Identifier"); + + subtree = proto_item_add_subtree(item, ett_dlci); + + oct = tvb_get_guint8(tvb, curr_offset); + + proto_tree_add_uint(subtree, hf_gsm_a_dlci_cc, tvb, curr_offset, 1, oct); + proto_tree_add_uint(subtree, hf_gsm_a_dlci_spare, tvb, curr_offset, 1, oct); + proto_tree_add_uint(subtree, hf_gsm_a_dlci_sapi, tvb, curr_offset, 1, oct); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.26 + */ +static guint8 +be_down_dtx_flag(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint oct; + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xfe, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : BSS is %s to activate DTX in the downlink direction", + a_bigbuf, + (oct & 0x01) ? "forbidden" : "allowed"); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.27 + */ +static guint8 +be_cell_id_list(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 consumed; + guint8 disc; + guint8 num_cells; + guint32 curr_offset; + proto_item *item = NULL; + proto_tree *subtree = NULL; + const gchar *str = NULL; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + disc = oct & 0x0f; + + if (disc >= (gint) NUM_CELL_DISC_STR) + { + str = "Unknown"; + } + else + { + str = cell_disc_str[disc]; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cell Identification Discriminator: (%d) %s", + a_bigbuf, + disc, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + num_cells = 0; + do + { + item = + proto_tree_add_text(tree, + tvb, curr_offset, -1, + "Cell %d", + num_cells + 1); + + subtree = proto_item_add_subtree(item, ett_cell_list); + + add_string[0] = '\0'; + consumed = + be_cell_id_aux(tvb, subtree, curr_offset, len - (curr_offset - offset), add_string, disc); + + if (add_string[0] != '\0') + { + proto_item_append_text(item, add_string); + } + + proto_item_set_len(item, consumed); + + curr_offset += consumed; + + num_cells++; + } + while ((len - (curr_offset - offset)) > 0); + + sprintf(add_string, " - %d cell%s", + num_cells, plurality(num_cells, "", "s")); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.33 + */ +static guint8 +be_chosen_chan(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str = NULL; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch ((oct & 0xf0) >> 4) + { + case 0: str = "No channel mode indication"; break; + case 9: str = "Speech (full rate or half rate)"; break; + case 14: str = "Data, 14.5 kbit/s radio interface rate"; break; + case 11: str = "Data, 12.0 kbit/s radio interface rate"; break; + case 12: str = "Data, 6.0 kbit/s radio interface rate"; break; + case 13: str = "Data, 3.6 kbit/s radio interface rate"; break; + case 8: str = "Signalling only"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Channel mode: %s", + a_bigbuf, + str); + + switch (oct & 0x0f) + { + case 0: str = "None"; break; + case 1: str = "SDCCH"; break; + case 8: str = "1 Full rate TCH"; break; + case 9: str = "1 Half rate TCH"; break; + case 10: str = "2 Full Rate TCHs"; break; + case 11: str = "3 Full Rate TCHs"; break; + case 12: str = "4 Full Rate TCHs"; break; + case 13: str = "5 Full Rate TCHs"; break; + case 14: str = "6 Full Rate TCHs"; break; + case 15: str = "7 Full Rate TCHs"; break; + case 4: str = "8 Full Rate TCHs"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Channel: %s", + a_bigbuf, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.34 + */ +static guint8 +be_ciph_resp_mode(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xfe, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : IMEISV must %sbe included by the mobile station", + a_bigbuf, + (oct & 0x01) ? "" : "not "); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.35 + */ +static guint8 +be_l3_msg(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + tvbuff_t *l3_tvb; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, tvb, curr_offset, len, + "Layer 3 Message Contents"); + + /* + * dissect the embedded DTAP message + */ + l3_tvb = tvb_new_subset(tvb, curr_offset, len, len); + + call_dissector(dtap_handle, l3_tvb, g_pinfo, g_tree); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.43 + */ +static guint8 +be_for_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str = NULL; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x0f) + { + case 1: str = "forward to subsequent BSS, no trace at MSC"; break; + case 2: str = "forward to subsequent BSS, and trace at MSC"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : %s", + a_bigbuf, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.44 + */ +static guint8 +be_chosen_enc_alg(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str = NULL; + + len = len; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct) + { + case 0x01: str = "No encryption used"; break; + case 0x02: str = "GSM A5/1"; break; + case 0x03: str = "GSM A5/2"; break; + case 0x04: str = "GSM A5/3"; break; + case 0x05: str = "GSM A5/4"; break; + case 0x06: str = "GSM A5/5"; break; + case 0x07: str = "GSM A5/6"; break; + case 0x08: str = "GSM A5/7"; break; + default: + str = "Reserved"; + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Algorithm Identifier: %s", + str); + + curr_offset++; + + sprintf(add_string, " - %s", str); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.45 + */ +static guint8 +be_cct_pool(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str = NULL; + + len = len; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + if (oct <= 32) + { + str = ""; + } + else if ((oct >= 0x80) && (oct <= 0x8f)) + { + str = ", for national/local use"; + } + else + { + str = ", reserved for future international use"; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Circuit pool number: %d%s", + oct, + str); + + curr_offset++; + + sprintf(add_string, " - (%d)", oct); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.49 + */ +static guint8 +be_curr_chan_1(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch ((oct & 0xf0) >> 4) + { + case 0x00: str = "Signalling only"; break; + case 0x01: str = "Speech (full rate or half rate)"; break; + case 0x06: str = "Data, 14.5 kbit/s radio interface rate"; break; + case 0x03: str = "Data, 12.0 kbit/s radio interface rate"; break; + case 0x04: str = "Data, 6.0 kbit/s radio interface rate"; break; + case 0x05: str = "Data, 3.6 kbit/s radio interface rate"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Channel Mode: %s", + a_bigbuf, + str); + + switch (oct & 0x0f) + { + case 0x01: str = "SDCCH"; break; + case 0x08: str = "1 Full rate TCH"; break; + case 0x09: str = "1 Half rate TCH"; break; + case 0x0a: str = "2 Full Rate TCHs"; break; + case 0x0b: str = "3 Full Rate TCHs"; break; + case 0x0c: str = "4 Full Rate TCHs"; break; + case 0x0d: str = "5 Full Rate TCHs"; break; + case 0x0e: str = "6 Full Rate TCHs"; break; + case 0x0f: str = "7 Full Rate TCHs"; break; + case 0x04: str = "8 Full Rate TCHs"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Channel: (%d) %s", + a_bigbuf, + oct & 0x0f, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.50 + */ +static guint8 +be_que_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : qri: it is recommended %sto allow queuing", + a_bigbuf, + (oct & 0x02) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.51 + */ +static guint8 +be_speech_ver(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str = NULL; + gchar *short_str = NULL; + + len = len; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x7f) + { + case 0x01: str = "GSM speech full rate version 1"; short_str = "FR1"; break; + case 0x11: str = "GSM speech full rate version 2"; short_str = "FR2"; break; + case 0x21: str = "GSM speech full rate version 3 (AMR)"; short_str = "FR3 (AMR)"; break; + + case 0x05: str = "GSM speech half rate version 1"; short_str = "HR1"; break; + case 0x15: str = "GSM speech half rate version 2"; short_str = "HR2"; break; + case 0x25: str = "GSM speech half rate version 3 (AMR)"; short_str = "HR3 (AMR)"; break; + + default: + str = "Reserved"; + short_str = str; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Speech version identifier: %s", + a_bigbuf, + str); + + curr_offset++; + + sprintf(add_string, " - (%s)", short_str); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [2] 3.2.2.68 + */ +static guint8 +be_apdu(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, tvb, curr_offset, len, + "APDU"); + + /* + * dissect the embedded APDU message + * if someone writes a TS 09.31 dissector + */ + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +typedef enum +{ + /* Common Information Elements 10.5.1 */ + DE_CELL_ID, /* Cell Identity */ + DE_CIPH_KEY_SEQ_NUM, /* Ciphering Key Sequence Number */ + DE_LAI, /* Location Area Identification */ + DE_MID, /* Mobile Identity */ + DE_MS_CM_1, /* Mobile Station Classmark 1 */ + DE_MS_CM_2, /* Mobile Station Classmark 2 */ + DE_MS_CM_3, /* Mobile Station Classmark 3 */ + DE_D_GB_CALL_REF, /* Descriptive group or broadcast call reference */ + DE_G_CIPH_KEY_NUM, /* Group Cipher Key Number */ + DE_PD_SAPI, /* PD and SAPI $(CCBS)$ */ + DE_PRIO, /* Priority Level */ + DE_PLMN_LIST, /* PLMN List */ + /* Radio Resource Management Information Elements 10.5.2, most are from 10.5.1 */ + DE_RR_CAUSE, /* RR Cause */ + /* Mobility Management Information Elements 10.5.3 */ + DE_AUTH_PARAM_RAND, /* Authentication Parameter RAND */ + DE_AUTH_PARAM_AUTN, /* Authentication Parameter AUTN (UMTS authentication challenge only) */ + DE_AUTH_RESP_PARAM, /* Authentication Response Parameter */ + DE_AUTH_RESP_PARAM_EXT, /* Authentication Response Parameter (extension) (UMTS authentication challenge only) */ + DE_AUTH_FAIL_PARAM, /* Authentication Failure Parameter (UMTS authentication challenge only) */ + DE_CM_SRVC_TYPE, /* CM Service Type */ + DE_ID_TYPE, /* Identity Type */ + DE_LOC_UPD_TYPE, /* Location Updating Type */ + DE_NETWORK_NAME, /* Network Name */ + DE_REJ_CAUSE, /* Reject Cause */ + DE_FOP, /* Follow-on Proceed */ + DE_TIME_ZONE, /* Time Zone */ + DE_TIME_ZONE_TIME, /* Time Zone and Time */ + DE_CTS_PERM, /* CTS Permission */ + DE_LSA_ID, /* LSA Identifier */ + DE_DAY_SAVING_TIME, /* Daylight Saving Time */ + /* Call Control Information Elements 10.5.4 */ + DE_AUX_STATES, /* Auxiliary States */ + DE_BEARER_CAP, /* Bearer Capability */ + DE_CC_CAP, /* Call Control Capabilities */ + DE_CALL_STATE, /* Call State */ + DE_CLD_PARTY_BCD_NUM, /* Called Party BCD Number */ + DE_CLD_PARTY_SUB_ADDR, /* Called Party Subaddress */ + DE_CLG_PARTY_BCD_NUM, /* Calling Party BCD Number */ + DE_CLG_PARTY_SUB_ADDR, /* Calling Party Subaddress */ + DE_CAUSE, /* Cause */ + DE_CLIR_SUP, /* CLIR Suppression */ + DE_CLIR_INV, /* CLIR Invocation */ + DE_CONGESTION, /* Congestion Level */ + DE_CONN_NUM, /* Connected Number */ + DE_CONN_SUB_ADDR, /* Connected Subaddress */ + DE_FACILITY, /* Facility */ + DE_HLC, /* High Layer Compatibility */ + DE_KEYPAD_FACILITY, /* Keypad Facility */ + DE_LLC, /* Low Layer Compatibility */ + DE_MORE_DATA, /* More Data */ + DE_NOT_IND, /* Notification Indicator */ + DE_PROG_IND, /* Progress Indicator */ + DE_RECALL_TYPE, /* Recall type $(CCBS)$ */ + DE_RED_PARTY_BCD_NUM, /* Redirecting Party BCD Number */ + DE_RED_PARTY_SUB_ADDR, /* Redirecting Party Subaddress */ + DE_REPEAT_IND, /* Repeat Indicator */ + DE_REV_CALL_SETUP_DIR, /* Reverse Call Setup Direction */ + DE_SETUP_CONTAINER, /* SETUP Container $(CCBS)$ */ + DE_SIGNAL, /* Signal */ + DE_SS_VER_IND, /* SS Version Indicator */ + DE_USER_USER, /* User-user */ + DE_ALERT_PATTERN, /* Alerting Pattern $(NIA)$ */ + DE_ALLOWED_ACTIONS, /* Allowed Actions $(CCBS)$ */ + DE_SI, /* Stream Identifier */ + DE_NET_CC_CAP, /* Network Call Control Capabilities */ + DE_CAUSE_NO_CLI, /* Cause of No CLI */ + DE_IMM_MOD_IND, /* Immediate Modification Indicator */ + DE_SUP_CODEC_LIST, /* Supported Codec List */ + DE_SRVC_CAT, /* Service Category */ + /* GPRS Mobility Management Information Elements 10.5.5 */ + DE_ATTACH_RES, /* Attach Result */ + DE_ATTACH_TYPE, /* Attach Type */ + DE_TMSI_STAT, /* TMSI Status */ + DE_DETACH_TYPE, /* Detach Type */ + DE_DRX_PARAM, /* DRX Parameter */ + DE_FORCE_TO_STAND, /* Force to Standby */ + DE_P_TMSI_SIG, /* P-TMSI Signature */ + DE_P_TMSI_SIG_2, /* P-TMSI Signature 2 */ + DE_ID_TYPE_2, /* Identity Type 2 */ + DE_IMEISV_REQ, /* IMEISV Request */ + DE_REC_N_PDU_NUM_LIST, /* Receive N-PDU Numbers List */ + DE_MS_NET_CAP, /* MS Network Capability */ + DE_MS_RAD_ACC_CAP, /* MS Radio Access Capability */ + DE_GMM_CAUSE, /* GMM Cause */ + DE_RAI, /* Routing Area Identification */ + DE_UPD_RES, /* Update Result */ + DE_AC_REF_NUM, /* A&C Reference Number */ + DE_SRVC_TYPE, /* Service Type */ + DE_CELL_NOT, /* Cell Notification */ + DE_NET_FEAT_SUP, /* Network Feature Support */ + /* Short Message Service Information Elements [5] 8.1.4 */ + DE_CP_USER_DATA, /* CP-User Data */ + DE_CP_CAUSE, /* CP-Cause */ + /* Short Message Service Information Elements [5] 8.2 */ + DE_RP_MESSAGE_REF, /* RP-Message Reference */ + DE_RP_ORIG_ADDR, /* RP-Origination Address */ + DE_RP_DEST_ADDR, /* RP-Destination Address */ + DE_RP_USER_DATA, /* RP-User Data */ + DE_RP_CAUSE, /* RP-Cause */ + /* Session Management Information Elements 10.5.6 */ + DE_ACC_POINT_NAME, /* Access Point Name */ + DE_NET_SAPI, /* Network Service Access Point Identifier */ + DE_PRO_CONF_OPT, /* Protocol Configuration Options */ + DE_PD_PRO_ADDR, /* Packet Data Protocol Address */ + DE_QOS, /* Quality Of Service */ + DE_SM_CAUSE, /* SM Cause */ + DE_LINKED_TI, /* Linked TI */ + DE_LLC_SAPI, /* LLC Service Access Point Identifier */ + DE_TEAR_DOWN_IND, /* Tear Down Indicator */ + DE_PACKET_FLOW_ID, /* Packet Flow Identifier */ + DE_TRAFFIC_FLOW_TEMPLATE, /* Traffic Flow Template */ + /* GPRS Common Information Elements 10.5.7 */ + DE_PDP_CONTEXT_STAT, /* PDP Context Status */ + DE_RAD_PRIO, /* Radio Priority */ + DE_GPRS_TIMER, /* GPRS Timer */ + DE_GPRS_TIMER_2, /* GPRS Timer 2 */ + DE_NONE, /* NONE */ +} +dtap_elem_idx_t; + +#define NUM_GSM_DTAP_ELEM (sizeof(gsm_dtap_elem_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_elem[NUM_GSM_DTAP_ELEM]; + +/* + * [3] 10.5.1.1 + */ +static guint8 +de_cell_id(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + curr_offset = offset; + + curr_offset += + be_cell_id_aux(tvb, tree, offset, len, add_string, 0x02); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.3 + */ +static guint8 +de_lai(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 octs[3]; + guint16 value; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + gchar mcc[4]; + gchar mnc[4]; + + len = len; + add_string = add_string; + curr_offset = offset; + + octs[0] = tvb_get_guint8(tvb, curr_offset); + octs[1] = tvb_get_guint8(tvb, curr_offset + 1); + octs[2] = tvb_get_guint8(tvb, curr_offset + 2); + + mcc_mnc_aux(octs, mcc, mnc); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 5, + gsm_dtap_elem_strings[DE_LAI].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_LAI]); + + proto_tree_add_text(subtree, + tvb, curr_offset, 3, + "Mobile Country Code (MCC): %s, Mobile Network Code (MNC): %s", + mcc, + mnc); + + curr_offset += 3; + + value = tvb_get_ntohs(tvb, curr_offset); + + proto_tree_add_text(subtree, + tvb, curr_offset, 2, + "Location Area Code (LAC): 0x%04x (%d)", + value, + value); + + proto_item_append_text(item, " - LAC (0x%04x)", value); + + curr_offset += 2; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.4 + */ +static guint8 +de_mid(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + guint8 *poctets; + guint32 value; + gboolean odd; + + curr_offset = offset; + odd = FALSE; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct & 0x07) + { + case 0: /* No Identity */ + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Unused", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Odd/Even Indicator: %s", + a_bigbuf, + (oct & 0x08) ? "ODD" : "EVEN"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of Identity: No Identity Code", + a_bigbuf); + + strcpy(add_string, " - No Identity Code"); + + curr_offset++; + + if (len > 1) + { + proto_tree_add_text(tree, tvb, curr_offset, len - 1, + "Format not supported"); + } + + curr_offset += len - 1; + break; + + case 3: /* IMEISV */ + + /* FALLTHRU */ + + case 1: /* IMSI */ + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Identity Digit 1: %c", + a_bigbuf, + Dgt_msid.out[(oct & 0xf0) >> 4]); + + odd = oct & 0x08; + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Odd/Even Indicator: %s", + a_bigbuf, + odd ? "ODD" : "EVEN"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of Identity: %s", + a_bigbuf, + ((oct & 0x07) == 3) ? "IMEISV" : "IMSI"); + + a_bigbuf[0] = Dgt_msid.out[(oct & 0xf0) >> 4]; + curr_offset++; + + poctets = tvb_get_string(tvb, curr_offset, len - (curr_offset - offset)); + + my_dgt_tbcd_unpack(&a_bigbuf[1], poctets, len - (curr_offset - offset), + &Dgt_msid); + g_free(poctets); + + proto_tree_add_string_format(tree, + ((oct & 0x07) == 3) ? hf_gsm_a_imeisv : hf_gsm_a_imsi, + tvb, curr_offset, len - (curr_offset - offset), + a_bigbuf, + "BCD Digits: %s", + a_bigbuf); + + sprintf(add_string, " - %s (%s)", + ((oct & 0x07) == 3) ? "IMEISV" : "IMSI", + a_bigbuf); + + curr_offset += len - (curr_offset - offset); + + if (!odd) + { + oct = tvb_get_guint8(tvb, curr_offset - 1); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset - 1, 1, + "%s : Filler", + a_bigbuf); + } + break; + + case 2: /* IMEI */ + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Identity Digit 1: %c", + a_bigbuf, + Dgt_msid.out[(oct & 0xf0) >> 4]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Odd/Even Indicator: %s", + a_bigbuf, + (oct & 0x08) ? "ODD" : "EVEN"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of Identity: IMEI", + a_bigbuf); + + a_bigbuf[0] = Dgt_msid.out[(oct & 0xf0) >> 4]; + curr_offset++; + + poctets = tvb_get_string(tvb, curr_offset, len - (curr_offset - offset)); + + my_dgt_tbcd_unpack(&a_bigbuf[1], poctets, len - (curr_offset - offset), + &Dgt_msid); + g_free(poctets); + + proto_tree_add_string_format(tree, + hf_gsm_a_imei, + tvb, curr_offset, len - (curr_offset - offset), + a_bigbuf, + "BCD Digits: %s", + a_bigbuf); + + sprintf(add_string, " - IMEI (%s)", a_bigbuf); + + curr_offset += len - (curr_offset - offset); + break; + + case 4: /* TMSI/P-TMSI */ + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Unused", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Odd/Even Indicator: %s", + a_bigbuf, + (oct & 0x08) ? "ODD" : "EVEN"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of Identity: TMSI/P-TMSI", + a_bigbuf); + + curr_offset++; + + value = tvb_get_ntohl(tvb, curr_offset); + + proto_tree_add_uint(tree, hf_gsm_a_tmsi, + tvb, curr_offset, 4, + value); + + sprintf(add_string, " - TMSI/P-TMSI (0x%04x)", value); + + curr_offset += 4; + break; + + default: /* Reserved */ + proto_tree_add_text(tree, tvb, curr_offset, len, + "Format Unknown"); + + strcpy(add_string, " - Format Unknown"); + + curr_offset += len; + break; + } + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.5 + */ +static guint8 +de_ms_cm_1(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_MS_CM_1].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_MS_CM_1]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch ((oct & 0x60) >> 5) + { + case 0: str = "Reserved for GSM phase 1"; break; + case 1: str = "Used by GSM phase 2 mobile stations"; break; + case 2: str = "Used by mobile stations supporting R99 or later versions of the protocol"; break; + default: + str = "Reserved for future use"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x60, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Revision Level: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x10, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : ES IND: Controlled Early Classmark Sending is %simplemented", + a_bigbuf, + (oct & 0x10) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : A5/1: encryption algorithm A5/1 %savailable", + a_bigbuf, + (oct & 0x08) ? "not " : ""); + + switch (oct & 0x07) + { + case 0: str = "Class 1"; break; + case 1: str = "Class 2"; break; + case 2: str = "Class 3"; break; + case 3: str = "Class 4"; break; + case 4: str = "Class 5"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : RF power capability: %s", + a_bigbuf, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.6 + */ +static guint8 +de_ms_cm_2(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch ((oct & 0x60) >> 5) + { + case 0: str = "Reserved for GSM phase 1"; break; + case 1: str = "Used by GSM phase 2 mobile stations"; break; + case 2: str = "Used by mobile stations supporting R99 or later versions of the protocol"; break; + default: + str = "Reserved for future use"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x60, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Revision Level: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x10, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : ES IND: Controlled Early Classmark Sending is %simplemented", + a_bigbuf, + (oct & 0x10) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : A5/1: encryption algorithm A5/1 %savailable", + a_bigbuf, + (oct & 0x08) ? "not " : ""); + + switch (oct & 0x07) + { + case 0: str = "Class 1"; break; + case 1: str = "Class 2"; break; + case 2: str = "Class 3"; break; + case 3: str = "Class 4"; break; + case 4: str = "Class 5"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : RF power capability: %s", + a_bigbuf, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x40, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : PS capability (pseudo-synchronization capability): %spresent", + a_bigbuf, + (oct & 0x40) ? "" : "not "); + + switch ((oct & 0x30) >> 4) + { + case 0: str = "Default value for phase 1"; break; + case 1: str = "Capability of handling of ellipsis notation and phase 2 error handling"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x30, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : SS Screening Indicator: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : SM capability (MT SMS pt to pt capability): MS %s MT SMS", + a_bigbuf, + (oct & 0x08) ? "supports" : "does not support"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x04, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : VBS notification reception: %s", + a_bigbuf, + (oct & 0x04) ? "VBS capability and notifications wanted" : + "no VBS capability or no notifications wanted"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : VGCS notification reception: %s", + a_bigbuf, + (oct & 0x02) ? "VGCS capability and notifications wanted" : + "no VGCS capability or no notifications wanted"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : FC Frequency Capability", + a_bigbuf); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : CM3: %s", + a_bigbuf, + (oct & 0x80) ? + "The MS supports options that are indicated in classmark 3 IE" : + "The MS does not support any options that are indicated in CM3"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x40, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x20, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : LCS VA capability: LCS value added location request notification capability %ssupported", + a_bigbuf, + (oct & 0x20) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x10, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : UCS2 treatment: %s", + a_bigbuf, + (oct & 0x10) ? + "the ME has no preference between the use of the default alphabet and the use of UCS2" : + "the ME has a preference for the default alphabet (defined in 3GPP TS 03.38) over UCS2"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : SoLSA: the ME %s SoLSA", + a_bigbuf, + (oct & 0x08) ? "supports" : "does not support"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x04, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : CMSP (CM Service Prompt): %s", + a_bigbuf, + (oct & 0x04) ? + "'Network initiated MO CM connection request' supported for at least one CM protocol" : + "'Network initiated MO CM connection request' not supported"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : A5/3: encryption algorithm A5/3 %savailable", + a_bigbuf, + (oct & 0x02) ? "" : "not "); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : A5/2: encryption algorithm A5/2 %savailable", + a_bigbuf, + (oct & 0x01) ? "" : "not "); + + curr_offset++; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.9 + */ +static guint8 +de_d_gb_call_ref(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 value; + guint32 curr_offset; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + value = tvb_get_ntohl(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, value, 0xffffffe0, 32); + proto_tree_add_text(tree, tvb, curr_offset, 4, + "%s : Group or Broadcast call reference: %d (0x%04x)", + a_bigbuf, + (value & 0xffffffe0) >> 5, + (value & 0xffffffe0) >> 5); + + my_decode_bitfield_value(a_bigbuf, value, 0x00000010, 32); + proto_tree_add_text(tree, tvb, curr_offset, 4, + "%s : SF Service Flag: %s", + a_bigbuf, + (value & 0x00000010) ? + "VGCS (Group call reference)" : "VBS (Broadcast call reference)"); + + my_decode_bitfield_value(a_bigbuf, value, 0x00000008, 32); + proto_tree_add_text(tree, tvb, curr_offset, 4, + "%s : AF Acknowledgement Flag: acknowledgment is %srequired", + a_bigbuf, + (value & 0x00000008) ? "" : "not "); + + switch (value & 0x00000007) + { + case 1: str = "call priority level 4"; break; + case 2: str = "call priority level 3"; break; + case 3: str = "call priority level 2"; break; + case 4: str = "call priority level 1"; break; + case 5: str = "call priority level 0"; break; + case 6: str = "call priority level B"; break; + case 7: str = "call priority level A"; break; + default: + str = "no priority applied"; + break; + } + + my_decode_bitfield_value(a_bigbuf, value, 0x00000007, 32); + proto_tree_add_text(tree, tvb, curr_offset, 4, + "%s : Call Priority: %s", + a_bigbuf, + str); + + curr_offset += 4; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, curr_offset, 1, + "%s : Ciphering Information", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.10a + */ +static guint8 +de_pd_sapi(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_PD_SAPI].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_PD_SAPI]); + + my_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8); + proto_tree_add_text(subtree, tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch ((oct & 0x30) >> 4) + { + case 0: str = "SAPI 0"; break; + case 3: str = "SAPI 3"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x30, 8); + proto_tree_add_text(subtree, tvb, curr_offset, 1, + "%s : SAPI (Sevice Access Point Identifier): %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(subtree, tvb, curr_offset, 1, + "%s : PD (Protocol Discriminator): %s", + a_bigbuf, + pd_str[oct & 0x0f]); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.11 + */ +static guint8 +de_prio(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x07) + { + case 1: str = "Call priority level 4"; break; + case 2: str = "Call priority level 3"; break; + case 3: str = "Call priority level 2"; break; + case 4: str = "Call priority level 1"; break; + case 5: str = "Call priority level 0"; break; + case 6: str = "Call priority level B"; break; + case 7: str = "Call priority level A"; break; + default: + str = "No priority applied"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : %s", + a_bigbuf, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.1.13 + */ +static guint8 +de_plmn_list(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 octs[3]; + guint32 curr_offset; + gchar mcc[4]; + gchar mnc[4]; + guint8 num_plmn; + + add_string = add_string; + curr_offset = offset; + + num_plmn = 0; + while ((len - (curr_offset - offset)) >= 3) + { + octs[0] = tvb_get_guint8(tvb, curr_offset); + octs[1] = tvb_get_guint8(tvb, curr_offset + 1); + octs[2] = tvb_get_guint8(tvb, curr_offset + 2); + + mcc_mnc_aux(octs, mcc, mnc); + + proto_tree_add_text(tree, + tvb, curr_offset, 3, + "PLMN[%d] Mobile Country Code (MCC): %s, Mobile Network Code (MNC): %s", + num_plmn + 1, + mcc, + mnc); + + curr_offset += 3; + + num_plmn++; + } + + sprintf(add_string, " - %d PLMN%s", + num_plmn, plurality(num_plmn, "", "s")); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.2.31 + */ +static guint8 +de_rr_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct) + { + case 0x00: str = "Normal event"; break; + case 0x01: str = "Abnormal release, unspecified"; break; + case 0x02: str = "Abnormal release, channel unacceptable"; break; + case 0x03: str = "Abnormal release, timer expired"; break; + case 0x04: str = "Abnormal release, no activity on the radio path"; break; + case 0x05: str = "Preemptive release"; break; + case 0x08: str = "Handover impossible, timing advance out of range"; break; + case 0x09: str = "Channel mode unacceptable"; break; + case 0x0a: str = "Frequency not implemented"; break; + case 0x41: str = "Call already cleared"; break; + case 0x5f: str = "Semantically incorrect message"; break; + case 0x60: str = "Invalid mandatory information"; break; + case 0x61: str = "Message type non-existent or not implemented"; break; + case 0x62: str = "Message type not compatible with protocol state"; break; + case 0x64: str = "Conditional IE error"; break; + case 0x65: str = "No cell allocation available"; break; + case 0x6f: str = "Protocol error unspecified"; break; + default: + str = "Reserved, treat as Normal event"; + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "RR Cause value: 0x%02x (%d) %s", + oct, + oct, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.1 + */ +static guint8 +de_auth_param_rand(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + +/* + * 12 octets == 128 bits + */ +#define AUTH_PARAM_RAND_LEN 12 + + proto_tree_add_text(tree, + tvb, curr_offset, AUTH_PARAM_RAND_LEN, + "RAND value"); + + curr_offset += AUTH_PARAM_RAND_LEN; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.1.1 + */ +static guint8 +de_auth_param_autn(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, + tvb, curr_offset, len, + "AUTN value"); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.2 + */ +static guint8 +de_auth_resp_param(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + +/* + * 4 octets == 32 bits + */ +#define AUTH_PARAM_RESP_LEN 4 + + proto_tree_add_text(tree, + tvb, curr_offset, AUTH_PARAM_RESP_LEN, + "SRES value"); + + curr_offset += AUTH_PARAM_RESP_LEN; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.2.1 + */ +static guint8 +de_auth_resp_param_ext(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, + tvb, curr_offset, len, + "RES (extension) value"); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.2.2 + */ +static guint8 +de_auth_fail_param(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, + tvb, curr_offset, len, + "AUTS value"); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.5a + */ +static guint8 +de_network_name(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + switch ((oct & 0x70) >> 4) + { + case 0x00: str = "Cell Broadcast data coding scheme, GSM default alphabet, language unspecified, defined in 3GPP TS 03.38"; break; + case 0x01: str = "UCS2 (16 bit)"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Coding Scheme: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Add CI: The MS should %s", + a_bigbuf, + (oct & 0x08) ? + "add the letters for the Country's Initials and a separator (e.g. a space) to the text string" : + "The MS should not add the letters for the Country's Initials to the text string"); + + switch (oct & 0x07) + { + case 1: str = "bit 8 is spare and set to '0' in octet n"; break; + case 2: str = "bits 7 and 8 are spare and set to '0' in octet n"; break; + case 3: str = "bits 6 to 8(inclusive) are spare and set to '0' in octet n"; break; + case 4: str = "bits 5 to 8(inclusive) are spare and set to '0' in octet n"; break; + case 5: str = "bits 4 to 8(inclusive) are spare and set to '0' in octet n"; break; + case 6: str = "bits 3 to 8(inclusive) are spare and set to '0' in octet n"; break; + case 7: str = "bits 2 to 8(inclusive) are spare and set to '0' in octet n"; break; + default: + str = "this field carries no information about the number of spare bits in octet n"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Number of spare bits in last octet: %s", + a_bigbuf, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - 1, + "Text string encoded according to Coding Scheme"); + + curr_offset += len - 1; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.6 + */ +static guint8 +de_rej_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct) + { + case 0x02: str = "IMSI unknown in HLR"; break; + case 0x03: str = "Illegal MS"; break; + case 0x04: str = "IMSI unknown in VLR"; break; + case 0x05: str = "IMEI not accepted"; break; + case 0x06: str = "Illegal ME"; break; + case 0x0b: str = "PLMN not allowed"; break; + case 0x0c: str = "Location Area not allowed"; break; + case 0x0d: str = "Roaming not allowed in this location area"; break; + case 0x0f: str = "No Suitable Cells In Location Area"; break; + case 0x11: str = "Network failure"; break; + case 0x14: str = "MAC failure"; break; + case 0x15: str = "Synch failure"; break; + case 0x16: str = "Congestion"; break; + case 0x17: str = "GSM authentication unacceptable"; break; + case 0x20: str = "Service option not supported"; break; + case 0x21: str = "Requested service option not subscribed"; break; + case 0x22: str = "Service option temporarily out of order"; break; + case 0x26: str = "Call cannot be identified"; break; + case 0x5f: str = "Semantically incorrect message"; break; + case 0x60: str = "Invalid mandatory information"; break; + case 0x61: str = "Message type non-existent or not implemented"; break; + case 0x62: str = "Message type not compatible with the protocol state"; break; + case 0x63: str = "Information element non-existent or not implemented"; break; + case 0x64: str = "Conditional IE error"; break; + case 0x65: str = "Message not compatible with the protocol state"; break; + case 0x6f: str = "Protocol error, unspecified"; break; + default: + switch (is_uplink) + { + case IS_UPLINK_FALSE: + str = "Service option temporarily out of order"; + break; + default: + str = "Protocol error, unspecified"; + break; + } + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Reject Cause value: 0x%02x (%d) %s", + oct, + oct, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.8 + */ +static guint8 +de_time_zone(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Time Zone: 0x%02x (%d)", + oct, + oct); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.9 + */ +static guint8 +de_time_zone_time(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct, oct2, oct3; + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + oct2 = tvb_get_guint8(tvb, curr_offset+1); + oct3 = tvb_get_guint8(tvb, curr_offset+2); + + proto_tree_add_text(tree, + tvb, curr_offset, 3, + "Year %d%d, Month %d%d, Day %d%d", + oct & 0x0f, + (oct & 0xf0) >> 4, + oct2 & 0x0f, + (oct2 & 0xf0) >> 4, + oct3 & 0x0f, + (oct3 & 0xf0) >> 4); + + curr_offset += 3; + + oct = tvb_get_guint8(tvb, curr_offset); + oct2 = tvb_get_guint8(tvb, curr_offset+1); + oct3 = tvb_get_guint8(tvb, curr_offset+2); + + proto_tree_add_text(tree, + tvb, curr_offset, 3, + "Hour %d%d, Minutes %d%d, Seconds %d%d", + oct & 0x0f, + (oct & 0xf0) >> 4, + oct2 & 0x0f, + (oct2 & 0xf0) >> 4, + oct3 & 0x0f, + (oct3 & 0xf0) >> 4); + + curr_offset += 3; + + oct = tvb_get_guint8(tvb, curr_offset); + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Time Zone: 0x%02x (%d)", + oct, + oct); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.11 + */ +static guint8 +de_lsa_id(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, + tvb, curr_offset, len, + "LSA ID"); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.3.12 + */ +static guint8 +de_day_saving_time(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x03) + { + case 0: str = "No adjustment for Daylight Saving Time"; break; + case 1: str = "+1 hour adjustment for Daylight Saving Time"; break; + case 2: str = "+2 hours adjustment for Daylight Saving Time"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x03, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : %s", + a_bigbuf, + str); + + curr_offset++; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.4 + */ +static guint8 +de_aux_states(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch ((oct & 0x0c) >> 2) + { + case 0: str = "Idle"; break; + case 1: str = "Hold request"; break; + case 2: str = "Call held"; break; + default: + str = "Retrieve request"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Hold auxiliary state: %s", + a_bigbuf, + str); + + switch (oct & 0x03) + { + case 0: str = "Idle"; break; + case 1: str = "MPTY request"; break; + case 2: str = "Call in MPTY"; break; + default: + str = "Split request"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x03, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Multi party auxiliary state: %s", + a_bigbuf, + str); + + curr_offset++; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.5a + */ +static guint8 +de_cc_cap(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + + switch ((oct & 0xf0) >> 4) + { + case 0: + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Maximum number of supported bearers: 1", + a_bigbuf); + break; + + default: + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Maximum number of supported bearers: %d", + a_bigbuf, + (oct & 0xf0) >> 4); + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x02, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : PCP: the mobile station %s the Prolonged Clearing Procedure", + a_bigbuf, + (oct & 0x02) ? "supports" : "does not support"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x01, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : DTMF: %s", + a_bigbuf, + (oct & 0x01) ? + "the mobile station supports DTMF as specified in subclause 5.5.7 of TS 24.008" : + "reserved for earlier versions of the protocol"); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Maximum number of speech bearers: %d", + a_bigbuf, + oct & 0x0f); + + curr_offset++; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.6 + */ +static guint8 +de_call_state(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CALL_STATE].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CALL_STATE]); + + switch ((oct & 0xc0) >> 6) + { + case 0: str = "Coding as specified in ITU-T Rec. Q.931"; break; + case 1: str = "Reserved for other international standards"; break; + case 2: str = "National standard"; break; + default: + str = "Standard defined for the GSM PLMNS"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Coding standard: %s", + a_bigbuf, + str); + + switch (oct & 0x3f) + { + case 0x00: str = "UO - null NO - null"; break; + case 0x02: str = "U0.1- MM connection pending N0.1- MM connection pending"; break; + case 0x22: str = "U0.2- CC prompt present N0.2- CC connection pending"; break; + case 0x23: str = "U0.3- Wait for network information N0.3- Network answer pending"; break; + case 0x24: str = "U0.4- CC-Establishment present N0.4- CC-Establishment present"; break; + case 0x25: str = "U0.5- CC-Establishment confirmed N0.5- CC-Establishment confirmed"; break; + case 0x26: str = "U0.6- Recall present N0.6- Recall present"; break; + case 0x01: str = "U1 - call initiated N1 - call initiated"; break; + case 0x03: str = "U3 - mobile originating call proceeding N3 - mobile originating call proceeding"; break; + case 0x04: str = "U4 - call delivered N4 - call delivered"; break; + case 0x06: str = "U6 - call present N6 - call present"; break; + case 0x07: str = "U7 - call received N7 - call received"; break; + case 0x08: str = "U8 - connect request N8 - connect request"; break; + case 0x09: str = "U9 - mobile terminating call confirmed N9 - mobile terminating call confirmed"; break; + case 0x0a: str = "U10- active N10- active"; break; + case 0x0b: str = "U11- disconnect request"; break; + case 0x0c: str = "U12- disconnect indication N12-disconnect indication"; break; + case 0x13: str = "U19- release request N19- release request"; break; + case 0x1a: str = "U26- mobile originating modify N26- mobile originating modify"; break; + case 0x1b: str = "U27- mobile terminating modify N27- mobile terminating modify"; break; + case 0x1c: str = " N28- connect indication"; break; + default: + str = "Unknown"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Call state value: %s", + a_bigbuf, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.7 + */ +static guint8 +de_cld_party_bcd_num(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 ton; + guint8 *poctets; + guint32 curr_offset; + gchar *str; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + ton = (oct & 0x70) >> 4; + switch (ton) + { + case 0: str = "Unknown"; break; + case 1: str = "International number"; break; + case 2: str = "National number"; break; + case 3: str = "Network specific number"; break; + case 4: str = "Dedicated access, short code"; break; + case 7: str = "Reserved for extension"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of number: %s", + a_bigbuf, + str); + + if ((ton == 0) || + (ton == 1) || + (ton == 2) || + (ton == 4)) + { + switch (oct & 0x0f) + { + case 0: str = "Unknown"; break; + case 1: str = "ISDN/telephony numbering plan (Rec. E.164/E.163)"; break; + case 3: str = "Data numbering plan (Recommendation X.121)"; break; + case 4: str = "Telex numbering plan (Recommendation F.69)"; break; + case 8: str = "National numbering plan"; break; + case 9: str = "Private numbering plan"; break; + case 11: str = "Reserved for CTS (see 3GPP TS 44.056)"; break; + case 15: str = "Reserved for extension"; break; + default: + str = "Reserved"; + break; + } + } + else + { + str = "not applicable"; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Numbering plan identification: %s", + a_bigbuf, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + poctets = tvb_get_string(tvb, curr_offset, len - (curr_offset - offset)); + + my_dgt_tbcd_unpack(a_bigbuf, poctets, len - (curr_offset - offset), + &Dgt_mbcd); + g_free(poctets); + + proto_tree_add_string_format(tree, hf_gsm_a_cld_party_bcd_num, + tvb, curr_offset, len - (curr_offset - offset), + a_bigbuf, + "BCD Digits: %s", + a_bigbuf); + + curr_offset += len - (curr_offset - offset); + + sprintf(add_string, " - (%s)", a_bigbuf); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.8 + */ +static guint8 +de_cld_party_sub_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + switch ((oct & 0x70) >> 4) + { + case 0: str = "NSAP (X.213/ISO 8348 AD2)"; break; + case 2: str = "User specified"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of subaddress: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Odd/Even indicator: %s", + a_bigbuf, + (oct & 0x08) ? + "odd number of address signals" : "even number of address signals"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Subaddress information"); + + curr_offset += len - (curr_offset - offset); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.9 + */ +static guint8 +de_clg_party_bcd_num(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 ton; + guint8 *poctets; + guint32 curr_offset; + gchar *str; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + ton = (oct & 0x70) >> 4; + switch (ton) + { + case 0: str = "Unknown"; break; + case 1: str = "International number"; break; + case 2: str = "National number"; break; + case 3: str = "Network specific number"; break; + case 4: str = "Dedicated access, short code"; break; + case 7: str = "Reserved for extension"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of number: %s", + a_bigbuf, + str); + + if ((ton == 0) || + (ton == 1) || + (ton == 2) || + (ton == 4)) + { + switch (oct & 0x0f) + { + case 0: str = "Unknown"; break; + case 1: str = "ISDN/telephony numbering plan (Rec. E.164/E.163)"; break; + case 3: str = "Data numbering plan (Recommendation X.121)"; break; + case 4: str = "Telex numbering plan (Recommendation F.69)"; break; + case 8: str = "National numbering plan"; break; + case 9: str = "Private numbering plan"; break; + case 11: str = "Reserved for CTS (see 3GPP TS 44.056)"; break; + case 15: str = "Reserved for extension"; break; + default: + str = "Reserved"; + break; + } + } + else + { + str = "not applicable"; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Numbering plan identification: %s", + a_bigbuf, + str); + + curr_offset++; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + switch ((oct & 0x60) >> 5) + { + case 0: str = "Presentation allowed"; break; + case 1: str = "Presentation restricted"; break; + case 2: str = "Number not available due to interworking"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x60, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Presentation indicator: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x1c, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x03) + { + case 0: str = "User-provided, not screened"; break; + case 1: str = "User-provided, verified and passed"; break; + case 2: str = "User-provided, verified and failed"; break; + default: + str = "Network provided"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x03, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Screening indicator: %s", + a_bigbuf, + str); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + poctets = tvb_get_string(tvb, curr_offset, len - (curr_offset - offset)); + + my_dgt_tbcd_unpack(a_bigbuf, poctets, len - (curr_offset - offset), + &Dgt_mbcd); + g_free(poctets); + + proto_tree_add_string_format(tree, hf_gsm_a_clg_party_bcd_num, + tvb, curr_offset, len - (curr_offset - offset), + a_bigbuf, + "BCD Digits: %s", + a_bigbuf); + + curr_offset += len - (curr_offset - offset); + + sprintf(add_string, " - (%s)", a_bigbuf); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.10 + */ +static guint8 +de_clg_party_sub_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + switch ((oct & 0x70) >> 4) + { + case 0: str = "NSAP (X.213/ISO 8348 AD2)"; break; + case 2: str = "User specified"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Type of subaddress: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Odd/Even indicator: %s", + a_bigbuf, + (oct & 0x08) ? + "odd number of address signals" : "even number of address signals"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + curr_offset++; + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Subaddress information"); + + curr_offset += len - (curr_offset - offset); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.11 + */ +static guint8 +de_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint8 cause; + guint32 curr_offset; + gchar *str; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension: %s", + a_bigbuf, + (oct & 0x80) ? "not extended" : "extended"); + + switch ((oct & 0x60) >> 5) + { + case 0: str = "Coding as specified in ITU-T Rec. Q.931"; break; + case 1: str = "Reserved for other international standards"; break; + case 2: str = "National standard"; break; + default: + str = "Standard defined for the GSM PLMNS"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x60, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Coding standard: %s", + a_bigbuf, + str); + + my_decode_bitfield_value(a_bigbuf, oct, 0x10, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x0f) + { + case 0: str = "User"; break; + case 1: str = "Private network serving the local user"; break; + case 2: str = "Public network serving the local user"; break; + case 3: str = "Transit network"; break; + case 4: str = "Public network serving the remote user"; break; + case 5: str = "Private network serving the remote user"; break; + case 7: str = "International network"; break; + case 10: str = "Network beyond interworking point"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Location: %s", + a_bigbuf, + str); + + curr_offset++; + + oct = tvb_get_guint8(tvb, curr_offset); + + if (!(oct & 0x80)) + { + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Recommendation", + a_bigbuf); + + curr_offset++; + + oct = tvb_get_guint8(tvb, curr_offset); + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension", + a_bigbuf); + + cause = oct & 0x7f; + switch (cause) + { + case 1: str = "Unassigned (unallocated) number"; break; + case 3: str = "No route to destination"; break; + case 6: str = "Channel unacceptable"; break; + case 8: str = "Operator determined barring"; break; + case 16: str = "Normal call clearing"; break; + case 17: str = "User busy"; break; + case 18: str = "No user responding"; break; + case 19: str = "User alerting, no answer"; break; + case 21: str = "Call rejected"; break; + case 22: str = "Number changed"; break; + case 25: str = "Pre-emption"; break; + case 26: str = "Non selected user clearing"; break; + case 27: str = "Destination out of order"; break; + case 28: str = "Invalid number format (incomplete number)"; break; + case 29: str = "Facility rejected"; break; + case 30: str = "Response to STATUS ENQUIRY"; break; + case 31: str = "Normal, unspecified"; break; + case 34: str = "No circuit/channel available"; break; + case 38: str = "Network out of order"; break; + case 41: str = "Temporary failure"; break; + case 42: str = "Switching equipment congestion"; break; + case 43: str = "Access information discarded"; break; + case 44: str = "requested circuit/channel not available"; break; + case 47: str = "Resources unavailable, unspecified"; break; + case 49: str = "Quality of service unavailable"; break; + case 50: str = "Requested facility not subscribed"; break; + case 55: str = "Incoming calls barred within the CUG"; break; + case 57: str = "Bearer capability not authorized"; break; + case 58: str = "Bearer capability not presently available"; break; + case 63: str = "Service or option not available, unspecified"; break; + case 65: str = "Bearer service not implemented"; break; + case 68: str = "ACM equal to or greater than ACMmax"; break; + case 69: str = "Requested facility not implemented"; break; + case 70: str = "Only restricted digital information bearer capability is available"; break; + case 79: str = "Service or option not implemented, unspecified"; break; + case 81: str = "Invalid transaction identifier value"; break; + case 87: str = "User not member of CUG"; break; + case 88: str = "Incompatible destination"; break; + case 91: str = "Invalid transit network selection"; break; + case 95: str = "Semantically incorrect message"; break; + case 96: str = "Invalid mandatory information"; break; + case 97: str = "Message type non-existent or not implemented"; break; + case 98: str = "Message type not compatible with protocol state"; break; + case 99: str = "Information element non-existent or not implemented"; break; + case 100: str = "Conditional IE error"; break; + case 101: str = "Message not compatible with protocol state"; break; + case 102: str = "Recovery on timer expiry"; break; + case 111: str = "Protocol error, unspecified"; break; + case 127: str = "Interworking, unspecified"; break; + default: + if (cause <= 31) { str = "Treat as Normal, unspecified"; } + else if ((cause >= 32) && (cause <= 47)) { str = "Treat as Resources unavailable, unspecified"; } + else if ((cause >= 48) && (cause <= 63)) { str = "Treat as Service or option not available, unspecified"; } + else if ((cause >= 64) && (cause <= 79)) { str = "Treat as Service or option not implemented, unspecified"; } + else if ((cause >= 80) && (cause <= 95)) { str = "Treat as Semantically incorrect message"; } + else if ((cause >= 96) && (cause <= 111)) { str = "Treat as Protocol error, unspecified"; } + else if ((cause >= 112) && (cause <= 127)) { str = "Treat as Interworking, unspecified"; } + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cause: (%d) %s", + a_bigbuf, + cause, + str); + + curr_offset++; + + sprintf(add_string, " - (%d) %s", cause, str); + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Diagnostics"); + + curr_offset += len - (curr_offset - offset); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.17 + */ +static guint8 +de_keypad_facility(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch ((oct & 0x60) >> 5) + { + case 0: str = "Coding as specified in ITU-T Rec. Q.931"; break; + case 1: str = "Reserved for other international standards"; break; + case 2: str = "National standard"; break; + default: + str = "Standard defined for the GSM PLMNS"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Keypad information: %c", + a_bigbuf, + oct & 0x7f); + + curr_offset++; + + sprintf(add_string, " - %c", oct & 0x7f); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [3] 10.5.4.22 + */ +static guint8 +de_repeat_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct & 0x0f) + { + case 1: str = "Circular for successive selection 'mode 1 alternate mode 2'"; break; + case 2: str = "Support of fallback mode 1 preferred, mode 2 selected if setup of mode 1 fails"; break; + case 3: str = "Reserved: was allocated in earlier phases of the protocol"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : %s", + a_bigbuf, + str); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [6] 3.7.2 + */ +static guint8 +de_ss_ver_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct) + { + case 0: str = "Phase 2 service, ellipsis notation, and phase 2 error handling is supported"; break; + case 1: str = "SS-Protocol version 3 is supported, and phase 2 error handling is supported"; break; + default: + str = "Reserved"; + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s", + str); + + curr_offset++; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [5] 8.1.4.1 + */ +static guint8 +de_cp_user_data(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + tvbuff_t *rp_tvb; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, tvb, curr_offset, len, + "RPDU"); + + /* + * dissect the embedded RP message + */ + rp_tvb = tvb_new_subset(tvb, curr_offset, len, len); + + call_dissector(rp_handle, rp_tvb, g_pinfo, g_tree); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [5] 8.1.4.2 + */ +static guint8 +de_cp_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + len = len; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + switch (oct) + { + case 17: str = "Network failure"; break; + case 22: str = "Congestion"; break; + case 81: str = "Invalid Transaction Identifier value"; break; + case 95: str = "Semantically incorrect message"; break; + case 96: str = "Invalid mandatory information"; break; + case 97: str = "Message type non-existent or not implemented"; break; + case 98: str = "Message not compatible with the short message protocol state"; break; + case 99: str = "Information element non-existent or not implemented"; break; + case 111: str = "Protocol error, unspecified"; break; + default: + str = "Reserved, treat as Protocol error, unspecified"; + break; + } + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "Cause: (%d) %s", + oct, + str); + + curr_offset++; + + sprintf(add_string, " - (%d) %s", oct, str); + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [5] 8.2.3 + */ +static guint8 +de_rp_message_ref(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + + len = len; + add_string = add_string; + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "RP-Message Reference: 0x%02x (%d)", + oct, + oct); + + curr_offset++; + + /* no length check possible */ + + return(curr_offset - offset); +} + +/* + * [5] 8.2.5.1 + */ +static guint8 +de_rp_orig_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + return(de_cld_party_bcd_num(tvb, tree, offset, len, add_string)); +} + +/* + * [5] 8.2.5.2 + */ +static guint8 +de_rp_dest_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + return(de_cld_party_bcd_num(tvb, tree, offset, len, add_string)); +} + +/* + * [5] 8.2.5.3 + */ +static guint8 +de_rp_user_data(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint32 curr_offset; + tvbuff_t *tpdu_tvb; + + add_string = add_string; + curr_offset = offset; + + proto_tree_add_text(tree, tvb, curr_offset, len, + "TPDU"); + + /* + * dissect the embedded TPDU message + */ + tpdu_tvb = tvb_new_subset(tvb, curr_offset, len, len); + + dissector_try_port(sms_dissector_table, gsm_a_rp_type, tpdu_tvb, g_pinfo, g_tree); + + curr_offset += len; + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +/* + * [5] 8.2.5.4 + */ +static guint8 +de_rp_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) +{ + guint8 oct; + guint32 curr_offset; + gchar *str; + + curr_offset = offset; + + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Extension: %s", + a_bigbuf, + (oct & 0x80) ? "extended" : "not extended"); + + switch (oct & 0x7f) + { + case 1: str = "Unassigned (unallocated) number"; break; + case 8: str = "Operator determined barring"; break; + case 10: str = "Call barred"; break; + case 11: str = "Reserved"; break; + case 21: str = "Short message transfer rejected"; break; + case 22: str = "Memory capacity exceeded"; break; + case 27: str = "Destination out of order"; break; + case 28: str = "Unidentified subscriber"; break; + case 29: str = "Facility rejected"; break; + case 30: str = "Unknown subscriber"; break; + case 38: str = "Network out of order"; break; + case 41: str = "Temporary failure"; break; + case 42: str = "Congestion"; break; + case 47: str = "Resources unavailable, unspecified"; break; + case 50: str = "Requested facility not subscribed"; break; + case 69: str = "Requested facility not implemented"; break; + case 81: str = "Invalid short message transfer reference value"; break; + case 95: str = "Semantically incorrect message"; break; + case 96: str = "Invalid mandatory information"; break; + case 97: str = "Message type non-existent or not implemented"; break; + case 98: str = "Message not compatible with short message protocol state"; break; + case 99: str = "Information element non-existent or not implemented"; break; + case 111: str = "Protocol error, unspecified"; break; + case 127: str = "Interworking, unspecified"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Cause: (%d) %s", + a_bigbuf, + oct & 0x7f, + str); + + curr_offset++; + + sprintf(add_string, " - (%d) %s", oct & 0x7f, str); + + NO_MORE_DATA_CHECK(len); + + proto_tree_add_text(tree, + tvb, curr_offset, len - (curr_offset - offset), + "Diagnostic field"); + + curr_offset += len - (curr_offset - offset); + + EXTRANEOUS_DATA_CHECK(len, curr_offset - offset); + + return(curr_offset - offset); +} + +static guint8 (*bssmap_elem_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) = { + be_cic, /* Circuit Identity Code */ + NULL, /* Reserved */ + NULL, /* Resource Available */ + be_cause, /* Cause */ + be_cell_id, /* Cell Identifier */ + be_prio, /* Priority */ + be_l3_header_info, /* Layer 3 Header Information */ + de_mid, /* IMSI */ + be_tmsi, /* TMSI */ + be_enc_info, /* Encryption Information */ + be_chan_type, /* Channel Type */ + NULL, /* Periodicity */ + NULL, /* Extended Resource Indicator */ + NULL, /* Number Of MSs */ + NULL, /* Reserved */ + NULL, /* Reserved */ + NULL, /* Reserved */ + de_ms_cm_2, /* Classmark Information Type 2 */ + NULL, /* Classmark Information Type 3 */ + NULL, /* Interference Band To Be Used */ + de_rr_cause, /* RR Cause */ + NULL, /* Reserved */ + be_l3_info, /* Layer 3 Information */ + be_dlci, /* DLCI */ + be_down_dtx_flag, /* Downlink DTX Flag */ + be_cell_id_list, /* Cell Identifier List */ + NULL /* no associated data */, /* Response Request */ + NULL, /* Resource Indication Method */ + de_ms_cm_1, /* Classmark Information Type 1 */ + NULL, /* Circuit Identity Code List */ + NULL, /* Diagnostic */ + be_l3_msg, /* Layer 3 Message Contents */ + be_chosen_chan, /* Chosen Channel */ + NULL, /* Total Resource Accessible */ + be_ciph_resp_mode, /* Cipher Response Mode */ + NULL, /* Channel Needed */ + NULL, /* Trace Type */ + NULL, /* TriggerID */ + NULL, /* Trace Reference */ + NULL, /* TransactionID */ + de_mid, /* Mobile Identity */ + NULL, /* OMCID */ + be_for_ind, /* Forward Indicator */ + be_chosen_enc_alg, /* Chosen Encryption Algorithm */ + be_cct_pool, /* Circuit Pool */ + NULL, /* Circuit Pool List */ + NULL, /* Time Indication */ + NULL, /* Resource Situation */ + be_curr_chan_1, /* Current Channel Type 1 */ + be_que_ind, /* Queueing Indicator */ + be_speech_ver, /* Speech Version */ + NULL, /* Assignment Requirement */ + NULL /* no associated data */, /* Talker Flag */ + NULL /* no associated data */, /* Connection Release Requested */ + NULL, /* Group Call Reference */ + NULL, /* eMLPP Priority */ + NULL, /* Configuration Evolution Indication */ + NULL /* no decode required */, /* Old BSS to New BSS Information */ + NULL, /* LSA Identifier */ + NULL, /* LSA Identifier List */ + NULL, /* LSA Information */ + NULL, /* LCS QoS */ + NULL, /* LSA access control suppression */ + NULL, /* LCS Priority */ + NULL, /* Location Type */ + NULL, /* Location Estimate */ + NULL, /* Positioning Data */ + NULL, /* LCS Cause */ + NULL, /* LCS Client Type */ + be_apdu, /* APDU */ + NULL, /* Network Element Identity */ + NULL, /* GPS Assistance Data */ + NULL, /* Deciphering Keys */ + NULL, /* Return Error Request */ + NULL, /* Return Error Cause */ + NULL, /* Segmentation */ + NULL, /* NONE */ +}; + +static guint8 (*dtap_elem_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string) = { + /* Common Information Elements 10.5.1 */ + de_cell_id, /* Cell Identity */ + NULL /* handled inline */, /* Ciphering Key Sequence Number */ + de_lai, /* Location Area Identification */ + de_mid, /* Mobile Identity */ + de_ms_cm_1, /* Mobile Station Classmark 1 */ + de_ms_cm_2, /* Mobile Station Classmark 2 */ + NULL, /* Mobile Station Classmark 3 */ + de_d_gb_call_ref, /* Descriptive group or broadcast call reference */ + NULL /* handled inline */, /* Group Cipher Key Number */ + de_pd_sapi, /* PD and SAPI $(CCBS)$ */ + de_prio /* handled inline */, /* Priority Level */ + de_plmn_list, /* PLMN List */ + /* Radio Resource Management Information Elements 10.5.2, most are from 10.5.1 */ + de_rr_cause, /* RR Cause */ + /* Mobility Management Information Elements 10.5.3 */ + de_auth_param_rand, /* Authentication Parameter RAND */ + de_auth_param_autn, /* Authentication Parameter AUTN (UMTS authentication challenge only) */ + de_auth_resp_param, /* Authentication Response Parameter */ + de_auth_resp_param_ext, /* Authentication Response Parameter (extension) (UMTS authentication challenge only) */ + de_auth_fail_param, /* Authentication Failure Parameter (UMTS authentication challenge only) */ + NULL /* handled inline */, /* CM Service Type */ + NULL /* handled inline */, /* Identity Type */ + NULL /* handled inline */, /* Location Updating Type */ + de_network_name, /* Network Name */ + de_rej_cause, /* Reject Cause */ + NULL /* no associated data */, /* Follow-on Proceed */ + de_time_zone, /* Time Zone */ + de_time_zone_time, /* Time Zone and Time */ + NULL /* no associated data */, /* CTS Permission */ + de_lsa_id, /* LSA Identifier */ + de_day_saving_time, /* Daylight Saving Time */ + /* Call Control Information Elements 10.5.4 */ + de_aux_states, /* Auxiliary States */ + NULL, /* Bearer Capability */ + de_cc_cap, /* Call Control Capabilities */ + de_call_state, /* Call State */ + de_cld_party_bcd_num, /* Called Party BCD Number */ + de_cld_party_sub_addr, /* Called Party Subaddress */ + de_clg_party_bcd_num, /* Calling Party BCD Number */ + de_clg_party_sub_addr, /* Calling Party Subaddress */ + de_cause, /* Cause */ + NULL /* no associated data */, /* CLIR Suppression */ + NULL /* no associated data */, /* CLIR Invocation */ + NULL /* handled inline */, /* Congestion Level */ + NULL, /* Connected Number */ + NULL, /* Connected Subaddress */ + NULL, /* Facility */ + NULL, /* High Layer Compatibility */ + de_keypad_facility, /* Keypad Facility */ + NULL, /* Low Layer Compatibility */ + NULL, /* More Data */ + NULL, /* Notification Indicator */ + NULL, /* Progress Indicator */ + NULL, /* Recall type $(CCBS)$ */ + NULL, /* Redirecting Party BCD Number */ + NULL, /* Redirecting Party Subaddress */ + de_repeat_ind, /* Repeat Indicator */ + NULL /* no associated data */, /* Reverse Call Setup Direction */ + NULL, /* SETUP Container $(CCBS)$ */ + NULL, /* Signal */ + de_ss_ver_ind, /* SS Version Indicator */ + NULL, /* User-user */ + NULL, /* Alerting Pattern $(NIA)$ */ + NULL, /* Allowed Actions $(CCBS)$ */ + NULL, /* Stream Identifier */ + NULL, /* Network Call Control Capabilities */ + NULL, /* Cause of No CLI */ + NULL, /* Immediate Modification Indicator */ + NULL, /* Supported Codec List */ + NULL, /* Service Category */ + /* GPRS Mobility Management Information Elements 10.5.5 */ + NULL, /* Attach Result */ + NULL, /* Attach Type */ + NULL, /* TMSI Status */ + NULL, /* Detach Type */ + NULL, /* DRX Parameter */ + NULL, /* Force to Standby */ + NULL, /* P-TMSI Signature */ + NULL, /* P-TMSI Signature 2 */ + NULL, /* Identity Type 2 */ + NULL, /* IMEISV Request */ + NULL, /* Receive N-PDU Numbers List */ + NULL, /* MS Network Capability */ + NULL, /* MS Radio Access Capability */ + NULL, /* GMM Cause */ + NULL, /* Routing Area Identification */ + NULL, /* Update Result */ + NULL, /* A&C Reference Number */ + NULL, /* Service Type */ + NULL, /* Cell Notification */ + NULL, /* Network Feature Support */ + /* Short Message Service Information Elements [5] 8.1.4 */ + de_cp_user_data, /* CP-User Data */ + de_cp_cause, /* CP-Cause */ + /* Short Message Service Information Elements [5] 8.2 */ + de_rp_message_ref, /* RP-Message Reference */ + de_rp_orig_addr, /* RP-Origination Address */ + de_rp_dest_addr, /* RP-Destination Address */ + de_rp_user_data, /* RP-User Data */ + de_rp_cause, /* RP-Cause */ + /* Session Management Information Elements 10.5.6 */ + NULL, /* Access Point Name */ + NULL, /* Network Service Access Point Identifier */ + NULL, /* Protocol Configuration Options */ + NULL, /* Packet Data Protocol Address */ + NULL, /* Quality Of Service */ + NULL, /* SM Cause */ + NULL, /* Linked TI */ + NULL, /* LLC Service Access Point Identifier */ + NULL, /* Tear Down Indicator */ + NULL, /* Packet Flow Identifier */ + NULL, /* Traffic Flow Template */ + /* GPRS Common Information Elements 10.5.7 */ + NULL, /* PDP Context Status */ + NULL, /* Radio Priority */ + NULL, /* GPRS Timer */ + NULL, /* GPRS Timer 2 */ + NULL, /* NONE */ +}; + +#define SET_ELEM_VARS(SEV_pdu_type, SEV_elem_names, SEV_elem_ett, SEV_elem_funcs) \ + switch (SEV_pdu_type) \ + { \ + case BSSAP_PDU_TYPE_BSSMAP: \ + SEV_elem_names = gsm_bssmap_elem_strings; \ + SEV_elem_ett = ett_gsm_bssmap_elem; \ + SEV_elem_funcs = bssmap_elem_fcn; \ + break; \ + case BSSAP_PDU_TYPE_DTAP: \ + SEV_elem_names = gsm_dtap_elem_strings; \ + SEV_elem_ett = ett_gsm_dtap_elem; \ + SEV_elem_funcs = dtap_elem_fcn; \ + break; \ + default: \ + proto_tree_add_text(tree, \ + tvb, curr_offset, -1, \ + "Unknown PDU type (%d)", SEV_pdu_type); \ + return(consumed); \ + } + +/* + * Type Length Value (TLV) element dissector + */ +static guint8 +elem_tlv(tvbuff_t *tvb, proto_tree *tree, guint8 iei, gint pdu_type, int idx, guint32 offset, guint len, gchar *name_add) +{ + guint8 oct, parm_len; + guint8 consumed; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + const value_string *elem_names; + gint *elem_ett; + guint8 (**elem_funcs)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string); + + len = len; + curr_offset = offset; + consumed = 0; + + SET_ELEM_VARS(pdu_type, elem_names, elem_ett, elem_funcs); + + oct = tvb_get_guint8(tvb, curr_offset); + + if (oct == iei) + { + parm_len = tvb_get_guint8(tvb, curr_offset + 1); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, parm_len + 2, + "%s%s", + elem_names[idx].strptr, + (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add); + + subtree = proto_item_add_subtree(item, elem_ett[idx]); + + proto_tree_add_uint(subtree, + (BSSAP_PDU_TYPE_BSSMAP == pdu_type) ? hf_gsm_a_bssmap_elem_id : hf_gsm_a_dtap_elem_id, tvb, + curr_offset, 1, oct); + + proto_tree_add_uint(subtree, hf_gsm_a_length, tvb, + curr_offset + 1, 1, parm_len); + + if (parm_len > 0) + { + if (elem_funcs[idx] == NULL) + { + proto_tree_add_text(subtree, + tvb, curr_offset + 2, parm_len, + "Element Value"); + + consumed = parm_len; + } + else + { + a_add_string[0] = '\0'; + consumed = + (*elem_funcs[idx])(tvb, subtree, curr_offset + 2, + parm_len, a_add_string); + + if (a_add_string[0] != '\0') + { + proto_item_append_text(item, a_add_string); + a_add_string[0] = '\0'; + } + } + } + + consumed += 2; + } + + return(consumed); +} + +/* + * Type Value (TV) element dissector + * + * Length cannot be used in these functions, big problem if a element dissector + * is not defined for these. + */ +static guint8 +elem_tv(tvbuff_t *tvb, proto_tree *tree, guint8 iei, gint pdu_type, int idx, guint32 offset, gchar *name_add) +{ + guint8 oct; + guint8 consumed; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + const value_string *elem_names; + gint *elem_ett; + guint8 (**elem_funcs)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string); + + curr_offset = offset; + consumed = 0; + + SET_ELEM_VARS(pdu_type, elem_names, elem_ett, elem_funcs); + + oct = tvb_get_guint8(tvb, curr_offset); + + if (oct == iei) + { + item = + proto_tree_add_text(tree, + tvb, curr_offset, -1, + "%s%s", + elem_names[idx].strptr, + (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add); + + subtree = proto_item_add_subtree(item, elem_ett[idx]); + + proto_tree_add_uint(subtree, + (BSSAP_PDU_TYPE_BSSMAP == pdu_type) ? hf_gsm_a_bssmap_elem_id : hf_gsm_a_dtap_elem_id, tvb, + curr_offset, 1, oct); + + if (elem_funcs[idx] == NULL) + { + /* BAD THING, CANNOT DETERMINE LENGTH */ + + proto_tree_add_text(subtree, + tvb, curr_offset + 1, 1, + "No element dissector, rest of dissection may be incorrect"); + + consumed = 1; + } + else + { + a_add_string[0] = '\0'; + consumed = (*elem_funcs[idx])(tvb, subtree, curr_offset + 1, -1, a_add_string); + + if (a_add_string[0] != '\0') + { + proto_item_append_text(item, a_add_string); + a_add_string[0] = '\0'; + } + } + + consumed++; + + proto_item_set_len(item, consumed); + } + + return(consumed); +} + +/* + * Type Value (TV) element dissector + * Where top half nibble is IEI and bottom half nibble is value. + * + * Length cannot be used in these functions, big problem if a element dissector + * is not defined for these. + */ +static guint8 +elem_tv_short(tvbuff_t *tvb, proto_tree *tree, guint8 iei, gint pdu_type, int idx, guint32 offset, gchar *name_add) +{ + guint8 oct; + guint8 consumed; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + const value_string *elem_names; + gint *elem_ett; + guint8 (**elem_funcs)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string); + + curr_offset = offset; + consumed = 0; + + SET_ELEM_VARS(pdu_type, elem_names, elem_ett, elem_funcs); + + oct = tvb_get_guint8(tvb, curr_offset); + + if ((oct & 0xf0) == (iei & 0xf0)) + { + item = + proto_tree_add_text(tree, + tvb, curr_offset, -1, + "%s%s", + elem_names[idx].strptr, + (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add); + + subtree = proto_item_add_subtree(item, elem_ett[idx]); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Element ID", + a_bigbuf); + + if (elem_funcs[idx] == NULL) + { + /* BAD THING, CANNOT DETERMINE LENGTH */ + + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "No element dissector, rest of dissection may be incorrect"); + + consumed++; + } + else + { + a_add_string[0] = '\0'; + consumed = (*elem_funcs[idx])(tvb, subtree, curr_offset, -1, a_add_string); + + if (a_add_string[0] != '\0') + { + proto_item_append_text(item, a_add_string); + a_add_string[0] = '\0'; + } + } + + proto_item_set_len(item, consumed); + } + + return(consumed); +} + +/* + * Type (T) element dissector + */ +static guint8 +elem_t(tvbuff_t *tvb, proto_tree *tree, guint8 iei, gint pdu_type, int idx, guint32 offset, gchar *name_add) +{ + guint8 oct; + guint32 curr_offset; + guint8 consumed; + const value_string *elem_names; + gint *elem_ett; + guint8 (**elem_funcs)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string); + + curr_offset = offset; + consumed = 0; + + SET_ELEM_VARS(pdu_type, elem_names, elem_ett, elem_funcs); + + oct = tvb_get_guint8(tvb, curr_offset); + + if (oct == iei) + { + proto_tree_add_uint_format(tree, + (BSSAP_PDU_TYPE_BSSMAP == pdu_type) ? hf_gsm_a_bssmap_elem_id : hf_gsm_a_dtap_elem_id, tvb, + curr_offset, 1, oct, + "%s%s", + elem_names[idx].strptr, + (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add); + + consumed = 1; + } + + return(consumed); +} + +/* + * Length Value (LV) element dissector + */ +static guint8 +elem_lv(tvbuff_t *tvb, proto_tree *tree, gint pdu_type, int idx, guint32 offset, guint len, gchar *name_add) +{ + guint8 parm_len; + guint8 consumed; + guint32 curr_offset; + proto_tree *subtree; + proto_item *item; + const value_string *elem_names; + gint *elem_ett; + guint8 (**elem_funcs)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string); + + len = len; + curr_offset = offset; + consumed = 0; + + SET_ELEM_VARS(pdu_type, elem_names, elem_ett, elem_funcs); + + parm_len = tvb_get_guint8(tvb, curr_offset); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, parm_len + 1, + "%s%s", + elem_names[idx].strptr, + (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add); + + subtree = proto_item_add_subtree(item, elem_ett[idx]); + + proto_tree_add_uint(subtree, hf_gsm_a_length, tvb, + curr_offset, 1, parm_len); + + if (parm_len > 0) + { + if (elem_funcs[idx] == NULL) + { + proto_tree_add_text(subtree, + tvb, curr_offset + 1, parm_len, + "Element Value"); + + consumed = parm_len; + } + else + { + a_add_string[0] = '\0'; + consumed = + (*elem_funcs[idx])(tvb, subtree, curr_offset + 1, + parm_len, a_add_string); + + if (a_add_string[0] != '\0') + { + proto_item_append_text(item, a_add_string); + a_add_string[0] = '\0'; + } + } + } + + return(consumed + 1); +} + +/* + * Value (V) element dissector + * + * Length cannot be used in these functions, big problem if a element dissector + * is not defined for these. + */ +static guint8 +elem_v(tvbuff_t *tvb, proto_tree *tree, gint pdu_type, int idx, guint32 offset) +{ + guint8 consumed; + guint32 curr_offset; + const value_string *elem_names; + gint *elem_ett; + guint8 (**elem_funcs)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string); + + curr_offset = offset; + consumed = 0; + + SET_ELEM_VARS(pdu_type, elem_names, elem_ett, elem_funcs); + + if (elem_funcs[idx] == NULL) + { + /* BAD THING, CANNOT DETERMINE LENGTH */ + + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "No element dissector, rest of dissection may be incorrect"); + + consumed = 1; + } + else + { + a_add_string[0] = '\0'; + consumed = (*elem_funcs[idx])(tvb, tree, curr_offset, -1, a_add_string); + a_add_string[0] = '\0'; + } + + return(consumed); +} + +#define ELEM_MAND_TLV(EMT_iei, EMT_pdu_type, EMT_elem_idx, EMT_elem_name_addition) \ +{\ + if ((consumed = elem_tlv(tvb, tree, EMT_iei, EMT_pdu_type, EMT_elem_idx, curr_offset, curr_len, EMT_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + else \ + { \ + proto_tree_add_text(tree, \ + tvb, curr_offset, 0, \ + "Missing Mandatory element (0x%02x) %s%s, rest of dissection is suspect", \ + EMT_iei, \ + (EMT_pdu_type == BSSAP_PDU_TYPE_BSSMAP) ? \ + gsm_bssmap_elem_strings[EMT_elem_idx].strptr : gsm_dtap_elem_strings[EMT_elem_idx].strptr, \ + (EMT_elem_name_addition == NULL) || (EMT_elem_name_addition[0] == '\0') ? "" : EMT_elem_name_addition \ + ); \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_OPT_TLV(EOT_iei, EOT_pdu_type, EOT_elem_idx, EOT_elem_name_addition) \ +{\ + if ((consumed = elem_tlv(tvb, tree, EOT_iei, EOT_pdu_type, EOT_elem_idx, curr_offset, curr_len, EOT_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_MAND_TV(EMT_iei, EMT_pdu_type, EMT_elem_idx, EMT_elem_name_addition) \ +{\ + if ((consumed = elem_tv(tvb, tree, EMT_iei, EMT_pdu_type, EMT_elem_idx, curr_offset, EMT_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + else \ + { \ + proto_tree_add_text(tree, \ + tvb, curr_offset, 0, \ + "Missing Mandatory element (0x%02x) %s%s, rest of dissection is suspect", \ + EMT_iei, \ + (EMT_pdu_type == BSSAP_PDU_TYPE_BSSMAP) ? \ + gsm_bssmap_elem_strings[EMT_elem_idx].strptr : gsm_dtap_elem_strings[EMT_elem_idx].strptr, \ + (EMT_elem_name_addition == NULL) || (EMT_elem_name_addition[0] == '\0') ? "" : EMT_elem_name_addition \ + ); \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_OPT_TV(EOT_iei, EOT_pdu_type, EOT_elem_idx, EOT_elem_name_addition) \ +{\ + if ((consumed = elem_tv(tvb, tree, EOT_iei, EOT_pdu_type, EOT_elem_idx, curr_offset, EOT_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_OPT_TV_SHORT(EOT_iei, EOT_pdu_type, EOT_elem_idx, EOT_elem_name_addition) \ +{\ + if ((consumed = elem_tv_short(tvb, tree, EOT_iei, EOT_pdu_type, EOT_elem_idx, curr_offset, EOT_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_OPT_T(EOT_iei, EOT_pdu_type, EOT_elem_idx, EOT_elem_name_addition) \ +{\ + if ((consumed = elem_t(tvb, tree, EOT_iei, EOT_pdu_type, EOT_elem_idx, curr_offset, EOT_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_MAND_LV(EML_pdu_type, EML_elem_idx, EML_elem_name_addition) \ +{\ + if ((consumed = elem_lv(tvb, tree, EML_pdu_type, EML_elem_idx, curr_offset, curr_len, EML_elem_name_addition)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + else \ + { \ + /* Mandatory, but nothing we can do */ \ + } \ + if (curr_len <= 0) return; \ +} + +#define ELEM_MAND_V(EMV_pdu_type, EMV_elem_idx) \ +{\ + if ((consumed = elem_v(tvb, tree, EMV_pdu_type, EMV_elem_idx, curr_offset)) > 0) \ + { \ + curr_offset += consumed; \ + curr_len -= consumed; \ + } \ + else \ + { \ + /* Mandatory, but nothing we can do */ \ + } \ + if (curr_len <= 0) return; \ +} + + +/* MESSAGE FUNCTIONS */ + +/* + * [2] 3.2.1.1 + */ +static void +bssmap_ass_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CHAN_TYPE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHAN_TYPE, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_L3_HEADER_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_HEADER_INFO, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_PRIO].value, BSSAP_PDU_TYPE_BSSMAP, BE_PRIO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_DOWN_DTX_FLAG].value, BSSAP_PDU_TYPE_BSSMAP, BE_DOWN_DTX_FLAG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_INT_BAND].value, BSSAP_PDU_TYPE_BSSMAP, BE_INT_BAND, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CM_INFO_2].value, BSSAP_PDU_TYPE_BSSMAP, BE_CM_INFO_2, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_GROUP_CALL_REF].value, BSSAP_PDU_TYPE_BSSMAP, BE_GROUP_CALL_REF, ""); + + ELEM_OPT_T(gsm_bssmap_elem_strings[BE_TALKER_FLAG].value, BSSAP_PDU_TYPE_BSSMAP, BE_TALKER_FLAG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_LSA_ACC_CTRL].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_ACC_CTRL, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.2 + */ +static void +bssmap_ass_complete(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_RR_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_RR_CAUSE, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_CHAN].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_CHAN, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_ENC_ALG].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_ENC_ALG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CCT_POOL].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_SPEECH_VER].value, BSSAP_PDU_TYPE_BSSMAP, BE_SPEECH_VER, " (Chosen)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_LSA_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.3 + */ +static void +bssmap_ass_failure(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_RR_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_RR_CAUSE, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CCT_POOL].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CCT_POOL_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.4 + */ +static void +bssmap_block(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_T(gsm_bssmap_elem_strings[BE_CONN_REL_REQ].value, BSSAP_PDU_TYPE_BSSMAP, BE_CONN_REL_REQ, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.5 + */ +static void +bssmap_block_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.6 + */ +static void +bssmap_unblock(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_T(gsm_bssmap_elem_strings[BE_CONN_REL_REQ].value, BSSAP_PDU_TYPE_BSSMAP, BE_CONN_REL_REQ, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.7 + */ +static void +bssmap_unblock_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.8 + */ +static void +bssmap_ho_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CHAN_TYPE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHAN_TYPE, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_ENC_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_ENC_INFO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CM_INFO_1].value, BSSAP_PDU_TYPE_BSSMAP, BE_CM_INFO_1, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CM_INFO_2].value, BSSAP_PDU_TYPE_BSSMAP, BE_CM_INFO_2, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, " (Serving)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_PRIO].value, BSSAP_PDU_TYPE_BSSMAP, BE_PRIO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_DOWN_DTX_FLAG].value, BSSAP_PDU_TYPE_BSSMAP, BE_DOWN_DTX_FLAG, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, " (Target)"); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_INT_BAND].value, BSSAP_PDU_TYPE_BSSMAP, BE_INT_BAND, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CM_INFO_3].value, BSSAP_PDU_TYPE_BSSMAP, BE_CM_INFO_3, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CURR_CHAN_1].value, BSSAP_PDU_TYPE_BSSMAP, BE_CURR_CHAN_1, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_SPEECH_VER].value, BSSAP_PDU_TYPE_BSSMAP, BE_SPEECH_VER, " (Used)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_GROUP_CALL_REF].value, BSSAP_PDU_TYPE_BSSMAP, BE_GROUP_CALL_REF, ""); + + ELEM_OPT_T(gsm_bssmap_elem_strings[BE_TALKER_FLAG].value, BSSAP_PDU_TYPE_BSSMAP, BE_TALKER_FLAG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CONF_EVO_IND].value, BSSAP_PDU_TYPE_BSSMAP, BE_CONF_EVO_IND, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_ENC_ALG].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_ENC_ALG, " (Serving)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_OLD2NEW_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_OLD2NEW_INFO, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_LSA_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_INFO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_LSA_ACC_CTRL].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_ACC_CTRL, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.9 + */ +static void +bssmap_ho_reqd(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_OPT_T(gsm_bssmap_elem_strings[BE_RESP_REQ].value, BSSAP_PDU_TYPE_BSSMAP, BE_RESP_REQ, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID_LIST, " (Preferred)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CCT_POOL_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL_LIST, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CURR_CHAN_1].value, BSSAP_PDU_TYPE_BSSMAP, BE_CURR_CHAN_1, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_SPEECH_VER].value, BSSAP_PDU_TYPE_BSSMAP, BE_SPEECH_VER, " (Used)"); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_QUE_IND].value, BSSAP_PDU_TYPE_BSSMAP, BE_QUE_IND, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_OLD2NEW_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_OLD2NEW_INFO, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.10 + */ +static void +bssmap_ho_req_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_L3_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_INFO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_CHAN].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_CHAN, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_ENC_ALG].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_ENC_ALG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CCT_POOL].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_SPEECH_VER].value, BSSAP_PDU_TYPE_BSSMAP, BE_SPEECH_VER, " (Chosen)"); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_LSA_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.11 + */ +static void +bssmap_ho_cmd(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_L3_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_INFO, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.12 + */ +static void +bssmap_ho_complete(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_RR_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_RR_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.14 + */ +static void +bssmap_ho_cand_enq(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_NUM_MS].value, BSSAP_PDU_TYPE_BSSMAP, BE_NUM_MS, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID_LIST, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.15 + */ +static void +bssmap_ho_cand_resp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_NUM_MS].value, BSSAP_PDU_TYPE_BSSMAP, BE_NUM_MS, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.16 + */ +static void +bssmap_ho_failure(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_RR_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_RR_CAUSE, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CCT_POOL].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CCT_POOL_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CCT_POOL_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.19 + */ +static void +bssmap_paging(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_IMSI].value, BSSAP_PDU_TYPE_BSSMAP, BE_IMSI, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_TMSI].value, BSSAP_PDU_TYPE_BSSMAP, BE_TMSI, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID_LIST, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CHAN_NEEDED].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHAN_NEEDED, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_EMLPP_PRIO].value, BSSAP_PDU_TYPE_BSSMAP, BE_EMLPP_PRIO, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.20 + */ +static void +bssmap_clear_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.21 + */ +static void +bssmap_clear_cmd(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_L3_HEADER_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_HEADER_INFO, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.23 + */ +static void +bssmap_reset(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_UNKNOWN; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.25 + */ +static void +bssmap_ho_performed(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_CHAN].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_CHAN, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_ENC_ALG].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_ENC_ALG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_SPEECH_VER].value, BSSAP_PDU_TYPE_BSSMAP, BE_SPEECH_VER, " (Chosen)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_LSA_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.26 + */ +static void +bssmap_overload(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.29 + */ +static void +bssmap_cm_upd(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CM_INFO_2].value, BSSAP_PDU_TYPE_BSSMAP, BE_CM_INFO_2, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CM_INFO_3].value, BSSAP_PDU_TYPE_BSSMAP, BE_CM_INFO_3, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.30 + */ +static void +bssmap_ciph_mode_cmd(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_L3_HEADER_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_HEADER_INFO, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_ENC_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_ENC_INFO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CIPH_RESP_MODE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIPH_RESP_MODE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.31 + */ +static void +bssmap_ciph_mode_complete(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_L3_MSG].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_MSG, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_ENC_ALG].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_ENC_ALG, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.32 + */ +static void +bssmap_cl3_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint8 consumed; + guint32 curr_offset; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_L3_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_L3_INFO, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CHOSEN_CHAN].value, BSSAP_PDU_TYPE_BSSMAP, BE_CHOSEN_CHAN, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_LSA_ID_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_ID_LIST, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_APDU].value, BSSAP_PDU_TYPE_BSSMAP, BE_APDU, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.34 + */ +static void +bssmap_sapi_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint8 consumed; + guint32 curr_offset; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_DLCI].value, BSSAP_PDU_TYPE_BSSMAP, BE_DLCI, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.37 + */ +static void +bssmap_ho_reqd_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.38 + */ +static void +bssmap_reset_cct(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.39 + */ +static void +bssmap_reset_cct_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.41 + */ +static void +bssmap_cct_group_block(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.42 + */ +static void +bssmap_cct_group_block_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.43 + */ +static void +bssmap_cct_group_unblock(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.44 + */ +static void +bssmap_cct_group_unblock_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.45 + */ +static void +bssmap_confusion(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_DIAG].value, BSSAP_PDU_TYPE_BSSMAP, BE_DIAG, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.47 + */ +static void +bssmap_unequipped_cct(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + ELEM_OPT_TV(gsm_bssmap_elem_strings[BE_CIC_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.48 + */ +static void +bssmap_ciph_mode_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.49 + */ +static void +bssmap_load_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_TIME_IND].value, BSSAP_PDU_TYPE_BSSMAP, BE_TIME_IND, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID, ""); + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CELL_ID_LIST].value, BSSAP_PDU_TYPE_BSSMAP, BE_CELL_ID_LIST, " (Target)"); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_RES_SIT].value, BSSAP_PDU_TYPE_BSSMAP, BE_RES_SIT, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.66 + */ +static void +bssmap_change_cct(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_CAUSE].value, BSSAP_PDU_TYPE_BSSMAP, BE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.67 + */ +static void +bssmap_change_cct_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(gsm_bssmap_elem_strings[BE_CIC].value, BSSAP_PDU_TYPE_BSSMAP, BE_CIC, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.69 + */ +static void +bssmap_lsa_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_LSA_INFO].value, BSSAP_PDU_TYPE_BSSMAP, BE_LSA_INFO, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [2] 3.2.1.70 + */ +static void +bssmap_conn_oriented(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TLV(gsm_bssmap_elem_strings[BE_APDU].value, BSSAP_PDU_TYPE_BSSMAP, BE_APDU, ""); + + ELEM_OPT_TLV(gsm_bssmap_elem_strings[BE_SEG].value, BSSAP_PDU_TYPE_BSSMAP, BE_SEG, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +#define NUM_GSM_BSSMAP_MSG (sizeof(gsm_bssmap_msg_strings)/sizeof(value_string)) +static gint ett_gsm_bssmap_msg[NUM_GSM_BSSMAP_MSG]; +static void (*bssmap_msg_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + bssmap_ass_req, /* Assignment Request */ + bssmap_ass_complete, /* Assignment Complete */ + bssmap_ass_failure, /* Assignment Failure */ + bssmap_ho_req, /* Handover Request */ + bssmap_ho_reqd, /* Handover Required */ + bssmap_ho_req_ack, /* Handover Request Acknowledge */ + bssmap_ho_cmd, /* Handover Command */ + bssmap_ho_complete, /* Handover Complete */ + NULL /* no associated data */, /* Handover Succeeded */ + bssmap_ho_failure, /* Handover Failure */ + bssmap_ho_performed, /* Handover Performed */ + bssmap_ho_cand_enq, /* Handover Candidate Enquire */ + bssmap_ho_cand_resp, /* Handover Candidate Response */ + bssmap_ho_reqd_rej, /* Handover Required Reject */ + NULL /* no associated data */, /* Handover Detect */ + bssmap_clear_cmd, /* Clear Command */ + NULL /* no associated data */, /* Clear Complete */ + bssmap_clear_req, /* Clear Request */ + NULL, /* Reserved */ + NULL, /* Reserved */ + bssmap_sapi_rej, /* SAPI 'n' Reject */ + bssmap_confusion, /* Confusion */ + NULL, /* Suspend */ + NULL, /* Resume */ + bssmap_conn_oriented, /* Connection Oriented Information */ + NULL, /* Perform Location Request */ + bssmap_lsa_info, /* LSA Information */ + NULL, /* Perform Location Response */ + NULL, /* Perform Location Abort */ + bssmap_reset, /* Reset */ + NULL /* no associated data */, /* Reset Acknowledge */ + bssmap_overload, /* Overload */ + NULL, /* Reserved */ + bssmap_reset_cct, /* Reset Circuit */ + bssmap_reset_cct_ack, /* Reset Circuit Acknowledge */ + NULL, /* MSC Invoke Trace */ + NULL, /* BSS Invoke Trace */ + NULL, /* Connectionless Information */ + bssmap_block, /* Block */ + bssmap_block_ack, /* Blocking Acknowledge */ + bssmap_unblock, /* Unblock */ + bssmap_unblock_ack, /* Unblocking Acknowledge */ + bssmap_cct_group_block, /* Circuit Group Block */ + bssmap_cct_group_block_ack, /* Circuit Group Blocking Acknowledge */ + bssmap_cct_group_unblock, /* Circuit Group Unblock */ + bssmap_cct_group_unblock_ack, /* Circuit Group Unblocking Acknowledge */ + bssmap_unequipped_cct, /* Unequipped Circuit */ + bssmap_change_cct, /* Change Circuit */ + bssmap_change_cct_ack, /* Change Circuit Acknowledge */ + NULL, /* Resource Request */ + NULL, /* Resource Indication */ + bssmap_paging, /* Paging */ + bssmap_ciph_mode_cmd, /* Cipher Mode Command */ + bssmap_cm_upd, /* Classmark Update */ + bssmap_ciph_mode_complete, /* Cipher Mode Complete */ + NULL /* no associated data */, /* Queuing Indication */ + bssmap_cl3_info, /* Complete Layer 3 Information */ + NULL /* no associated data */, /* Classmark Request */ + bssmap_ciph_mode_rej, /* Cipher Mode Reject */ + bssmap_load_ind, /* Load Indication */ + NULL, /* VGCS/VBS Setup */ + NULL, /* VGCS/VBS Setup Ack */ + NULL, /* VGCS/VBS Setup Refuse */ + NULL, /* VGCS/VBS Assignment Request */ + NULL, /* VGCS/VBS Assignment Result */ + NULL, /* VGCS/VBS Assignment Failure */ + NULL, /* VGCS/VBS Queuing Indication */ + NULL, /* Uplink Request */ + NULL, /* Uplink Request Acknowledge */ + NULL, /* Uplink Request Confirmation */ + NULL, /* Uplink Release Indication */ + NULL, /* Uplink Reject Command */ + NULL, /* Uplink Release Command */ + NULL, /* Uplink Seized Command */ + NULL, /* NONE */ +}; + +/* + * [4] 9.2.2 + */ +static void +dtap_mm_auth_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + guint8 oct; + proto_tree *subtree; + proto_item *item; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + /* + * special dissection for Cipher Key Sequence Number + */ + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CIPH_KEY_SEQ_NUM].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CIPH_KEY_SEQ_NUM]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + + switch (oct & 0x07) + { + case 0x07: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: No key is available", + a_bigbuf); + break; + + default: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: %d", + a_bigbuf, + oct & 0x07); + break; + } + + curr_offset++; + curr_len--; + + if (curr_len <= 0) return; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_AUTH_PARAM_RAND); + + ELEM_OPT_TLV(0x20, BSSAP_PDU_TYPE_DTAP, DE_AUTH_PARAM_AUTN, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.2.3 + */ +static void +dtap_mm_auth_resp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_AUTH_RESP_PARAM); + + ELEM_OPT_TLV(0x21, BSSAP_PDU_TYPE_DTAP, DE_AUTH_RESP_PARAM_EXT, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.2.3a + */ +static void +dtap_mm_auth_fail(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_REJ_CAUSE); + + ELEM_OPT_TLV(0x22, BSSAP_PDU_TYPE_DTAP, DE_AUTH_FAIL_PARAM, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.4 + */ +static void +dtap_mm_cm_reestab_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + guint8 oct; + proto_tree *subtree; + proto_item *item; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + /* + * special dissection for Cipher Key Sequence Number + */ + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CIPH_KEY_SEQ_NUM].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CIPH_KEY_SEQ_NUM]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + + switch (oct & 0x07) + { + case 0x07: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: No key is available", + a_bigbuf); + break; + + default: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: %d", + a_bigbuf, + oct & 0x07); + break; + } + + curr_offset++; + curr_len--; + + if (curr_len <= 0) return; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MS_CM_2, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + ELEM_OPT_TV(0x13, BSSAP_PDU_TYPE_DTAP, DE_LAI, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.5a + */ +static void +dtap_mm_cm_srvc_prompt(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_PD_SAPI); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.2.6 + */ +static void +dtap_mm_cm_srvc_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_REJ_CAUSE); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.2.8 + */ +static void +dtap_mm_abort(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_REJ_CAUSE); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.9 + */ +static void +dtap_mm_cm_srvc_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + guint8 oct; + proto_tree *subtree; + proto_item *item; + gchar *str; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + /* + * special dissection for CM Service Type + */ + oct = tvb_get_guint8(tvb, curr_offset); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CIPH_KEY_SEQ_NUM].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CIPH_KEY_SEQ_NUM]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + + switch ((oct & 0x70) >> 4) + { + case 0x07: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: No key is available", + a_bigbuf); + break; + + default: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: %d", + a_bigbuf, + (oct & 0x70) >> 4); + break; + } + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CM_SRVC_TYPE].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CM_SRVC_TYPE]); + + switch (oct & 0x0f) + { + case 0x01: str = "Mobile originating call establishment or packet mode connection establishment"; break; + case 0x02: str = "Emergency call establishment"; break; + case 0x04: str = "Short message service"; break; + case 0x08: str = "Supplementary service activation"; break; + case 0x09: str = "Voice group call establishment"; break; + case 0x0a: str = "Voice broadcast call establishment"; break; + case 0x0b: str = "Location Services"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Service Type: (%d) %s", + a_bigbuf, + oct & 0x0f, + str); + + curr_offset++; + curr_len--; + + if (curr_len <= 0) return; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MS_CM_2, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + ELEM_OPT_TV_SHORT(0x80, BSSAP_PDU_TYPE_DTAP, DE_PRIO, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.10 + */ +static void +dtap_mm_id_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint8 oct; + guint32 curr_offset; + guint curr_len; + proto_tree *subtree; + proto_item *item; + gchar *str; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + /* + * special dissection for Identity Type + */ + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_ID_TYPE].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_ID_TYPE]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x07) + { + case 1: str = "IMSI"; break; + case 2: str = "IMEI"; break; + case 3: str = "IMEISV"; break; + case 4: str = "TMSI"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Type of identity: %s", + a_bigbuf, + str); + + curr_offset++; + curr_len--; + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.11 + */ +static void +dtap_mm_id_resp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.12 + */ +static void +dtap_mm_imsi_det_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_MS_CM_1); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.13 + */ +static void +dtap_mm_loc_upd_acc(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_LAI); + + ELEM_OPT_TLV(0x17, BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + ELEM_OPT_T(0xa1, BSSAP_PDU_TYPE_DTAP, DE_FOP, ""); + + ELEM_OPT_T(0xa2, BSSAP_PDU_TYPE_DTAP, DE_CTS_PERM, ""); + + ELEM_OPT_TLV(0x4a, BSSAP_PDU_TYPE_DTAP, DE_PLMN_LIST, " Equivalent"); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.14 + */ +static void +dtap_mm_loc_upd_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_REJ_CAUSE); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.15 + */ +static void +dtap_mm_loc_upd_req(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + guint8 oct; + proto_tree *subtree; + proto_item *item; + gchar *str; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + /* + * special dissection for Location Updating Type + */ + oct = tvb_get_guint8(tvb, curr_offset); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CIPH_KEY_SEQ_NUM].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CIPH_KEY_SEQ_NUM]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x80, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x70, 8); + + switch ((oct & 0x70) >> 4) + { + case 0x07: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: No key is available", + a_bigbuf); + break; + + default: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: %d", + a_bigbuf, + (oct & 0x70) >> 4); + break; + } + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_LOC_UPD_TYPE].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_LOC_UPD_TYPE]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Follow-On Request (FOR): %s", + a_bigbuf, + (oct & 0x08) ? "Follow-on request pending" : "No follow-on request pending"); + + my_decode_bitfield_value(a_bigbuf, oct, 0x04, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + switch (oct & 0x03) + { + case 0: str = "Normal"; break; + case 1: str = "Periodic"; break; + case 2: str = "IMSI attach"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x03, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Updating Type: %s", + a_bigbuf, + str); + + proto_item_append_text(item, " - %s", str); + + curr_offset++; + curr_len--; + + if (curr_len <= 0) return; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_LAI); + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_MS_CM_1); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + ELEM_OPT_TLV(0x33, BSSAP_PDU_TYPE_DTAP, DE_MS_CM_2, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.1.15a + */ +static void +dtap_mm_mm_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TLV(0x43, BSSAP_PDU_TYPE_DTAP, DE_NETWORK_NAME, " - Full Name"); + + ELEM_OPT_TLV(0x45, BSSAP_PDU_TYPE_DTAP, DE_NETWORK_NAME, " - Short Name"); + + ELEM_OPT_TV(0x46, BSSAP_PDU_TYPE_DTAP, DE_TIME_ZONE, " - Local"); + + ELEM_OPT_TV(0x47, BSSAP_PDU_TYPE_DTAP, DE_TIME_ZONE_TIME, " - Universal Time and Local Time Zone"); + + ELEM_OPT_TLV(0x48, BSSAP_PDU_TYPE_DTAP, DE_LSA_ID, ""); + + ELEM_OPT_TLV(0x49, BSSAP_PDU_TYPE_DTAP, DE_DAY_SAVING_TIME, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.1.16 + */ +static void +dtap_mm_mm_status(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_REJ_CAUSE); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [3] 9.2.17 + */ +static void +dtap_mm_tmsi_realloc_cmd(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_LAI); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.1.25 + */ +static void +dtap_rr_paging_resp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + guint8 oct; + proto_tree *subtree; + proto_item *item; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + /* + * special dissection for Cipher Key Sequence Number + */ + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CIPH_KEY_SEQ_NUM].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CIPH_KEY_SEQ_NUM]); + + my_decode_bitfield_value(a_bigbuf, oct, 0x08, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct, 0x07, 8); + + switch (oct & 0x07) + { + case 0x07: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: No key is available", + a_bigbuf); + break; + + default: + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Ciphering Key Sequence Number: %d", + a_bigbuf, + oct & 0x07); + break; + } + + curr_offset++; + curr_len--; + + if (curr_len <= 0) return; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MS_CM_2, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_MID, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.1.29 + */ +static void +dtap_rr_rr_status(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RR_CAUSE); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.1 + */ +static void +dtap_cc_alerting(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x1e, BSSAP_PDU_TYPE_DTAP, DE_PROG_IND, ""); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.2 + */ +static void +dtap_cc_call_conf(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TV_SHORT(0xd0, BSSAP_PDU_TYPE_DTAP, DE_REPEAT_IND, " BC repeat indicator"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 1"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 2"); + + ELEM_OPT_TLV(0x08, BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_OPT_TLV(0x15, BSSAP_PDU_TYPE_DTAP, DE_CC_CAP, ""); + + ELEM_OPT_TLV(0x2d, BSSAP_PDU_TYPE_DTAP, DE_SI, ""); + + ELEM_OPT_TLV(0x40, BSSAP_PDU_TYPE_DTAP, DE_SUP_CODEC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.3 + */ +static void +dtap_cc_call_proceed(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_OPT_TV_SHORT(0xd0, BSSAP_PDU_TYPE_DTAP, DE_REPEAT_IND, " BC repeat indicator"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 1"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 2"); + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x1e, BSSAP_PDU_TYPE_DTAP, DE_PROG_IND, ""); + + ELEM_OPT_TV_SHORT(0x80, BSSAP_PDU_TYPE_DTAP, DE_PRIO, ""); + + ELEM_OPT_TLV(0x2f, BSSAP_PDU_TYPE_DTAP, DE_NET_CC_CAP, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.4 + */ +static void +dtap_cc_congestion_control(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + guint8 oct; + proto_tree *subtree; + proto_item *item; + gchar *str; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + /* + * special dissection for Congestion Level + */ + oct = tvb_get_guint8(tvb, curr_offset); + + my_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, + tvb, curr_offset, 1, + "%s : Spare", + a_bigbuf); + + item = + proto_tree_add_text(tree, + tvb, curr_offset, 1, + gsm_dtap_elem_strings[DE_CONGESTION].strptr); + + subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CONGESTION]); + + switch (oct & 0x0f) + { + case 0: str = "Receiver ready"; break; + case 15: str = "Receiver not ready"; break; + default: + str = "Reserved"; + break; + } + + my_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8); + proto_tree_add_text(subtree, + tvb, curr_offset, 1, + "%s : Congestion level: %s", + a_bigbuf, + str); + + curr_offset++; + curr_len--; + + if (curr_len <= 0) return; + + ELEM_OPT_TLV(0x08, BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.5 + */ +static void +dtap_cc_connect(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x1e, BSSAP_PDU_TYPE_DTAP, DE_PROG_IND, ""); + + ELEM_OPT_TLV(0x4c, BSSAP_PDU_TYPE_DTAP, DE_CONN_NUM, ""); + + ELEM_OPT_TLV(0x4d, BSSAP_PDU_TYPE_DTAP, DE_CONN_SUB_ADDR, ""); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + ELEM_OPT_TLV(0x2d, BSSAP_PDU_TYPE_DTAP, DE_SI, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.7 + */ +static void +dtap_cc_disconnect(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x1e, BSSAP_PDU_TYPE_DTAP, DE_PROG_IND, ""); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + ELEM_OPT_TLV(0x7b, BSSAP_PDU_TYPE_DTAP, DE_ALLOWED_ACTIONS, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.8 + */ +static void +dtap_cc_emerg_setup(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, ""); + + ELEM_OPT_TLV(0x2d, BSSAP_PDU_TYPE_DTAP, DE_SI, ""); + + ELEM_OPT_TLV(0x40, BSSAP_PDU_TYPE_DTAP, DE_SUP_CODEC_LIST, ""); + + ELEM_OPT_TLV(0x2e, BSSAP_PDU_TYPE_DTAP, DE_SRVC_CAT, " Emergency"); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.9 + */ +static void +dtap_cc_facility(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.12 + */ +static void +dtap_cc_hold_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.13 + */ +static void +dtap_cc_modify(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, ""); + + ELEM_OPT_TLV(0x7c, BSSAP_PDU_TYPE_DTAP, DE_LLC, ""); + + ELEM_OPT_TLV(0x7d, BSSAP_PDU_TYPE_DTAP, DE_HLC, ""); + + ELEM_OPT_T(0xa3, BSSAP_PDU_TYPE_DTAP, DE_REV_CALL_SETUP_DIR, ""); + + ELEM_OPT_T(0xa4, BSSAP_PDU_TYPE_DTAP, DE_IMM_MOD_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.14 + */ +static void +dtap_cc_modify_complete(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, ""); + + ELEM_OPT_TLV(0x7c, BSSAP_PDU_TYPE_DTAP, DE_LLC, ""); + + ELEM_OPT_TLV(0x7d, BSSAP_PDU_TYPE_DTAP, DE_HLC, ""); + + ELEM_OPT_T(0xa3, BSSAP_PDU_TYPE_DTAP, DE_REV_CALL_SETUP_DIR, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.15 + */ +static void +dtap_cc_modify_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_OPT_TLV(0x7c, BSSAP_PDU_TYPE_DTAP, DE_LLC, ""); + + ELEM_OPT_TLV(0x7d, BSSAP_PDU_TYPE_DTAP, DE_HLC, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.16 + */ +static void +dtap_cc_notify(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_NOT_IND); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.17 + */ +static void +dtap_cc_progress(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_PROG_IND, ""); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.17a + */ +static void +dtap_cc_cc_est(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_SETUP_CONTAINER, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.17b + */ +static void +dtap_cc_cc_est_conf(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TV_SHORT(0xd0, BSSAP_PDU_TYPE_DTAP, DE_REPEAT_IND, " Repeat indicator"); + + ELEM_MAND_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 1"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 2"); + + ELEM_OPT_TLV(0x08, BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_OPT_TLV(0x40, BSSAP_PDU_TYPE_DTAP, DE_SUP_CODEC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.18 + */ +static void +dtap_cc_release(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TLV(0x08, BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_OPT_TLV(0x08, BSSAP_PDU_TYPE_DTAP, DE_CAUSE, " 2"); + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.18a + */ +static void +dtap_cc_recall(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RECALL_TYPE); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.19 + */ +static void +dtap_cc_release_complete(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_OPT_TLV(0x08, BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.22 + */ +static void +dtap_cc_retrieve_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.23 + */ +static void +dtap_cc_setup(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_OPT_TV_SHORT(0xd0, BSSAP_PDU_TYPE_DTAP, DE_REPEAT_IND, " BC repeat indicator"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 1"); + + ELEM_OPT_TLV(0x04, BSSAP_PDU_TYPE_DTAP, DE_BEARER_CAP, " 2"); + + ELEM_OPT_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x1e, BSSAP_PDU_TYPE_DTAP, DE_PROG_IND, ""); + + ELEM_OPT_TV(0x34, BSSAP_PDU_TYPE_DTAP, DE_SIGNAL, ""); + + ELEM_OPT_TLV(0x5c, BSSAP_PDU_TYPE_DTAP, DE_CLG_PARTY_BCD_NUM, ""); + + ELEM_OPT_TLV(0x5d, BSSAP_PDU_TYPE_DTAP, DE_CLG_PARTY_SUB_ADDR, ""); + + ELEM_OPT_TLV(0x5e, BSSAP_PDU_TYPE_DTAP, DE_CLD_PARTY_BCD_NUM, ""); + + ELEM_OPT_TLV(0x6d, BSSAP_PDU_TYPE_DTAP, DE_CLD_PARTY_SUB_ADDR, ""); + + ELEM_OPT_TLV(0x74, BSSAP_PDU_TYPE_DTAP, DE_RED_PARTY_BCD_NUM, ""); + + ELEM_OPT_TLV(0x75, BSSAP_PDU_TYPE_DTAP, DE_RED_PARTY_SUB_ADDR, ""); + + ELEM_OPT_TV_SHORT(0xd0, BSSAP_PDU_TYPE_DTAP, DE_REPEAT_IND, " LLC repeat indicator"); + + ELEM_OPT_TLV(0x7c, BSSAP_PDU_TYPE_DTAP, DE_LLC, " 1"); + + ELEM_OPT_TLV(0x7c, BSSAP_PDU_TYPE_DTAP, DE_LLC, " 2"); + + ELEM_OPT_TV_SHORT(0xd0, BSSAP_PDU_TYPE_DTAP, DE_REPEAT_IND, " HLC repeat indicator"); + + ELEM_OPT_TLV(0x7d, BSSAP_PDU_TYPE_DTAP, DE_HLC, " 1"); + + ELEM_OPT_TLV(0x7d, BSSAP_PDU_TYPE_DTAP, DE_HLC, " 2"); + + ELEM_OPT_TLV(0x7e, BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + /* downlink only */ + + ELEM_OPT_TV_SHORT(0x80, BSSAP_PDU_TYPE_DTAP, DE_PRIO, ""); + + ELEM_OPT_TLV(0x19, BSSAP_PDU_TYPE_DTAP, DE_ALERT_PATTERN, ""); + + ELEM_OPT_TLV(0x2f, BSSAP_PDU_TYPE_DTAP, DE_NET_CC_CAP, ""); + + ELEM_OPT_TLV(0x3a, BSSAP_PDU_TYPE_DTAP, DE_CAUSE_NO_CLI, ""); + + /* uplink only */ + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + ELEM_OPT_T(0xa1, BSSAP_PDU_TYPE_DTAP, DE_FOP, ""); + + ELEM_OPT_T(0xa2, BSSAP_PDU_TYPE_DTAP, DE_CTS_PERM, ""); + + ELEM_OPT_TLV(0x15, BSSAP_PDU_TYPE_DTAP, DE_CC_CAP, ""); + + ELEM_OPT_TLV(0x1d, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, " $(CCBS)$ (advanced recall alignment)"); + + ELEM_OPT_TLV(0x1b, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, " (recall alignment Not essential) $(CCBS)$"); + + ELEM_OPT_TLV(0x2d, BSSAP_PDU_TYPE_DTAP, DE_SI, ""); + + ELEM_OPT_TLV(0x40, BSSAP_PDU_TYPE_DTAP, DE_SUP_CODEC_LIST, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.23a + */ +static void +dtap_cc_start_cc(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_OPT_TLV(0x15, BSSAP_PDU_TYPE_DTAP, DE_CC_CAP, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.24 + */ +static void +dtap_cc_start_dtmf(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TV(0x2c, BSSAP_PDU_TYPE_DTAP, DE_KEYPAD_FACILITY, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.25 + */ +static void +dtap_cc_start_dtmf_ack(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_TV(0x2c, BSSAP_PDU_TYPE_DTAP, DE_KEYPAD_FACILITY, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.26 + */ +static void +dtap_cc_start_dtmf_rej(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.27 + */ +static void +dtap_cc_status(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CAUSE, ""); + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_CALL_STATE); + + ELEM_OPT_TLV(0x24, BSSAP_PDU_TYPE_DTAP, DE_AUX_STATES, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [4] 9.3.31 + */ +static void +dtap_cc_user_info(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_USER_USER, ""); + + ELEM_OPT_T(0xa0, BSSAP_PDU_TYPE_DTAP, DE_MORE_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [6] 2.4.2 + */ +static void +dtap_ss_register(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_TLV(0x1c, BSSAP_PDU_TYPE_DTAP, DE_FACILITY, ""); + + ELEM_OPT_TLV(0x7f, BSSAP_PDU_TYPE_DTAP, DE_SS_VER_IND, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.2.1 + */ +static void +dtap_sms_cp_data(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_CP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.2.3 + */ +static void +dtap_sms_cp_error(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_CP_CAUSE); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.1.1 + */ +static void +rp_data_n_ms(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + g_pinfo->p2p_dir = P2P_DIR_SENT; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_ORIG_ADDR, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_DEST_ADDR, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.1.2 + */ +static void +rp_data_ms_n(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + g_pinfo->p2p_dir = P2P_DIR_RECV; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_ORIG_ADDR, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_DEST_ADDR, ""); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.2 + */ +static void +rp_smma(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.3 + */ +static void +rp_ack_n_ms(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + g_pinfo->p2p_dir = P2P_DIR_SENT; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + ELEM_OPT_TLV(0x41, BSSAP_PDU_TYPE_DTAP, DE_RP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.3 + */ +static void +rp_ack_ms_n(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + g_pinfo->p2p_dir = P2P_DIR_RECV; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + ELEM_OPT_TLV(0x41, BSSAP_PDU_TYPE_DTAP, DE_RP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.4 + */ +static void +rp_error_n_ms(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_FALSE; + g_pinfo->p2p_dir = P2P_DIR_SENT; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_CAUSE, ""); + + ELEM_OPT_TLV(0x41, BSSAP_PDU_TYPE_DTAP, DE_RP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +/* + * [5] 7.3.4 + */ +static void +rp_error_ms_n(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) +{ + guint32 curr_offset; + guint32 consumed; + guint curr_len; + + curr_offset = offset; + curr_len = len; + + is_uplink = IS_UPLINK_TRUE; + g_pinfo->p2p_dir = P2P_DIR_RECV; + + ELEM_MAND_V(BSSAP_PDU_TYPE_DTAP, DE_RP_MESSAGE_REF); + + ELEM_MAND_LV(BSSAP_PDU_TYPE_DTAP, DE_RP_CAUSE, ""); + + ELEM_OPT_TLV(0x41, BSSAP_PDU_TYPE_DTAP, DE_RP_USER_DATA, ""); + + EXTRANEOUS_DATA_CHECK(curr_len, 0); +} + +#define NUM_GSM_DTAP_MSG_MM (sizeof(gsm_dtap_msg_mm_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_mm[NUM_GSM_DTAP_MSG_MM]; +static void (*dtap_msg_mm_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + dtap_mm_imsi_det_ind, /* IMSI Detach Indication */ + dtap_mm_loc_upd_acc, /* Location Updating Accept */ + dtap_mm_loc_upd_rej, /* Location Updating Reject */ + dtap_mm_loc_upd_req, /* Location Updating Request */ + NULL /* no associated data */, /* Authentication Reject */ + dtap_mm_auth_req, /* Authentication Request */ + dtap_mm_auth_resp, /* Authentication Response */ + dtap_mm_auth_fail, /* Authentication Failure */ + dtap_mm_id_req, /* Identity Request */ + dtap_mm_id_resp, /* Identity Response */ + dtap_mm_tmsi_realloc_cmd, /* TMSI Reallocation Command */ + NULL /* no associated data */, /* TMSI Reallocation Complete */ + NULL /* no associated data */, /* CM Service Accept */ + dtap_mm_cm_srvc_rej, /* CM Service Reject */ + NULL /* no associated data */, /* CM Service Abort */ + dtap_mm_cm_srvc_req, /* CM Service Request */ + dtap_mm_cm_srvc_prompt, /* CM Service Prompt */ + NULL, /* Reserved: was allocated in earlier phases of the protocol */ + dtap_mm_cm_reestab_req, /* CM Re-establishment Request */ + dtap_mm_abort, /* Abort */ + NULL /* no associated data */, /* MM Null */ + dtap_mm_mm_status, /* MM Status */ + dtap_mm_mm_info, /* MM Information */ + NULL, /* NONE */ +}; + +#define NUM_GSM_DTAP_MSG_RR (sizeof(gsm_dtap_msg_rr_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_rr[NUM_GSM_DTAP_MSG_RR]; +static void (*dtap_msg_rr_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + NULL, /* RR Initialisation Request */ + NULL, /* Additional Assignment */ + NULL, /* Immediate Assignment */ + NULL, /* Immediate Assignment Extended */ + NULL, /* Immediate Assignment Reject */ + + NULL, /* DTM Assignment Failure */ + NULL, /* DTM Reject */ + NULL, /* DTM Request */ + NULL, /* Main DCCH Assignment Command */ + NULL, /* Packet Assignment Command */ + + NULL, /* Ciphering Mode Command */ + NULL, /* Ciphering Mode Complete */ + + NULL, /* Configuration Change Command */ + NULL, /* Configuration Change Ack. */ + NULL, /* Configuration Change Reject */ + + NULL, /* Assignment Command */ + NULL, /* Assignment Complete */ + NULL, /* Assignment Failure */ + NULL, /* Handover Command */ + NULL, /* Handover Complete */ + NULL, /* Handover Failure */ + NULL, /* Physical Information */ + NULL, /* DTM Assignment Command */ + + NULL, /* RR-cell Change Order */ + NULL, /* PDCH Assignment Command */ + + NULL, /* Channel Release */ + NULL, /* Partial Release */ + NULL, /* Partial Release Complete */ + + NULL, /* Paging Request Type 1 */ + NULL, /* Paging Request Type 2 */ + NULL, /* Paging Request Type 3 */ + dtap_rr_paging_resp, /* Paging Response */ + NULL, /* Notification/NCH */ + NULL, /* Reserved */ + NULL, /* Notification/Response */ + + NULL, /* Reserved */ + +/* NULL, * Utran Classmark Change * CONFLICTS WITH Handover To UTRAN Command */ + NULL, /* UE RAB Preconfiguration */ + NULL, /* cdma2000 Classmark Change */ + + NULL, /* System Information Type 8 */ + NULL, /* System Information Type 1 */ + NULL, /* System Information Type 2 */ + NULL, /* System Information Type 3 */ + NULL, /* System Information Type 4 */ + NULL, /* System Information Type 5 */ + NULL, /* System Information Type 6 */ + NULL, /* System Information Type 7 */ + + NULL, /* System Information Type 2bis */ + NULL, /* System Information Type 2ter */ + NULL, /* System Information Type 2quater */ + NULL, /* System Information Type 5bis */ + NULL, /* System Information Type 5ter */ + NULL, /* System Information Type 9 */ + NULL, /* System Information Type 13 */ + + NULL, /* System Information Type 16 */ + NULL, /* System Information Type 17 */ + + NULL, /* System Information Type 18 */ + NULL, /* System Information Type 19 */ + NULL, /* System Information Type 20 */ + + NULL, /* Channel Mode Modify */ + dtap_rr_rr_status, /* RR Status */ + NULL, /* Channel Mode Modify Acknowledge */ + NULL, /* Frequency Redefinition */ + NULL, /* Measurement Report */ + NULL, /* Classmark Change */ + NULL, /* Classmark Enquiry */ + NULL, /* Extended Measurement Report */ + NULL, /* Extended Measurement Order */ + NULL, /* GPRS Suspension Request */ + + NULL, /* VGCS Uplink Grant */ + NULL, /* Uplink Release */ + NULL, /* Reserved */ + NULL, /* Uplink Busy */ + NULL, /* Talker Indication */ + + NULL, /* UTRAN Classmark Change/Handover To UTRAN Command */ /* spec conflict */ + + NULL, /* Application Information */ + + NULL, /* NONE */ +}; + +#define NUM_GSM_DTAP_MSG_CC (sizeof(gsm_dtap_msg_cc_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_cc[NUM_GSM_DTAP_MSG_CC]; +static void (*dtap_msg_cc_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + dtap_cc_alerting, /* Alerting */ + dtap_cc_call_conf, /* Call Confirmed */ + dtap_cc_call_proceed, /* Call Proceeding */ + dtap_cc_connect, /* Connect */ + NULL /* no associated data */, /* Connect Acknowledge */ + dtap_cc_emerg_setup, /* Emergency Setup */ + dtap_cc_progress, /* Progress */ + dtap_cc_cc_est, /* CC-Establishment */ + dtap_cc_cc_est_conf, /* CC-Establishment Confirmed */ + dtap_cc_recall, /* Recall */ + dtap_cc_start_cc, /* Start CC */ + dtap_cc_setup, /* Setup */ + dtap_cc_modify, /* Modify */ + dtap_cc_modify_complete, /* Modify Complete */ + dtap_cc_modify_rej, /* Modify Reject */ + dtap_cc_user_info, /* User Information */ + NULL /* no associated data */, /* Hold */ + NULL /* no associated data */, /* Hold Acknowledge */ + dtap_cc_hold_rej, /* Hold Reject */ + NULL /* no associated data */, /* Retrieve */ + NULL /* no associated data */, /* Retrieve Acknowledge */ + dtap_cc_retrieve_rej, /* Retrieve Reject */ + dtap_cc_disconnect, /* Disconnect */ + dtap_cc_release, /* Release */ + dtap_cc_release_complete, /* Release Complete */ + dtap_cc_congestion_control, /* Congestion Control */ + dtap_cc_notify, /* Notify */ + dtap_cc_status, /* Status */ + NULL /* no associated data */, /* Status Enquiry */ + dtap_cc_start_dtmf, /* Start DTMF */ + NULL /* no associated data */, /* Stop DTMF */ + NULL /* no associated data */, /* Stop DTMF Acknowledge */ + dtap_cc_start_dtmf_ack, /* Start DTMF Acknowledge */ + dtap_cc_start_dtmf_rej, /* Start DTMF Reject */ + dtap_cc_facility, /* Facility */ + NULL, /* NONE */ +}; + +#define NUM_GSM_DTAP_MSG_GMM (sizeof(gsm_dtap_msg_gmm_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_gmm[NUM_GSM_DTAP_MSG_GMM]; +static void (*dtap_msg_gmm_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + NULL, /* Attach Request */ + NULL, /* Attach Accept */ + NULL, /* Attach Complete */ + NULL, /* Attach Reject */ + NULL, /* Detach Request */ + NULL, /* Detach Accept */ + NULL, /* Routing Area Update Request */ + NULL, /* Routing Area Update Accept */ + NULL, /* Routing Area Update Complete */ + NULL, /* Routing Area Update Reject */ + NULL, /* Service Request */ + NULL, /* Service Accept */ + NULL, /* Service Reject */ + NULL, /* P-TMSI Reallocation Command */ + NULL, /* P-TMSI Reallocation Complete */ + NULL, /* Authentication and Ciphering Req */ + NULL, /* Authentication and Ciphering Resp */ + NULL, /* Authentication and Ciphering Rej */ + NULL, /* Authentication and Ciphering Failure */ + NULL, /* Identity Request */ + NULL, /* Identity Response */ + NULL, /* GMM Status */ + NULL, /* GMM Information */ + NULL, /* NONE */ +}; + +#define NUM_GSM_DTAP_MSG_SMS (sizeof(gsm_dtap_msg_sms_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_sms[NUM_GSM_DTAP_MSG_SMS]; +static void (*dtap_msg_sms_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + dtap_sms_cp_data, /* CP-DATA */ + NULL /* no associated data */, /* CP-ACK */ + dtap_sms_cp_error, /* CP-ERROR */ + NULL, /* NONE */ +}; + +#define NUM_GSM_DTAP_MSG_SM (sizeof(gsm_dtap_msg_sm_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_sm[NUM_GSM_DTAP_MSG_SM]; +static void (*dtap_msg_sm_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + NULL, /* Activate PDP Context Request */ + NULL, /* Activate PDP Context Accept */ + NULL, /* Activate PDP Context Reject */ + NULL, /* Request PDP Context Activation */ + NULL, /* Request PDP Context Activation rej. */ + NULL, /* Deactivate PDP Context Request */ + NULL, /* Deactivate PDP Context Accept */ + NULL, /* Modify PDP Context Request(Network to MS direction) */ + NULL, /* Modify PDP Context Accept (MS to network direction) */ + NULL, /* Modify PDP Context Request(MS to network direction) */ + NULL, /* Modify PDP Context Accept (Network to MS direction) */ + NULL, /* Modify PDP Context Reject */ + NULL, /* Activate Secondary PDP Context Request */ + NULL, /* Activate Secondary PDP Context Accept */ + NULL, /* Activate Secondary PDP Context Reject */ + NULL, /* Reserved: was allocated in earlier phases of the protocol */ + NULL, /* Reserved: was allocated in earlier phases of the protocol */ + NULL, /* Reserved: was allocated in earlier phases of the protocol */ + NULL, /* Reserved: was allocated in earlier phases of the protocol */ + NULL, /* Reserved: was allocated in earlier phases of the protocol */ + NULL, /* SM Status */ + NULL, /* NONE */ +}; + +#define NUM_GSM_DTAP_MSG_SS (sizeof(gsm_dtap_msg_ss_strings)/sizeof(value_string)) +static gint ett_gsm_dtap_msg_ss[NUM_GSM_DTAP_MSG_SS]; +static void (*dtap_msg_ss_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + dtap_cc_release_complete, /* Release Complete */ + dtap_cc_facility, /* Facility */ + dtap_ss_register, /* Register */ + NULL, /* NONE */ +}; + +#define NUM_GSM_RP_MSG (sizeof(gsm_rp_msg_strings)/sizeof(value_string)) +static gint ett_gsm_rp_msg[NUM_GSM_RP_MSG]; +static void (*rp_msg_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len) = { + rp_data_ms_n, /* RP-DATA (MS to Network) */ + rp_data_n_ms, /* RP-DATA (Network to MS */ + rp_ack_ms_n, /* RP-ACK (MS to Network) */ + rp_ack_n_ms, /* RP-ACK (Network to MS) */ + rp_error_ms_n, /* RP-ERROR (MS to Network) */ + rp_error_n_ms, /* RP-ERROR (Network to MS) */ + rp_smma, /* RP-SMMA (MS to Network) */ + NULL, /* NONE */ +}; + +/* GENERIC DISSECTOR FUNCTIONS */ + +static void +dissect_rp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 oct; + guint32 offset, saved_offset; + guint32 len; + gint idx; + proto_item *rp_item = NULL; + proto_tree *rp_tree = NULL; + gchar *str; + + + if (!proto_is_protocol_enabled(proto_a_rp)) + { + call_dissector(data_handle, tvb, pinfo, tree); + return; + } + + if (check_col(pinfo->cinfo, COL_INFO)) + { + col_append_str(pinfo->cinfo, COL_INFO, "(RP) "); + } + + /* + * In the interest of speed, if "tree" is NULL, don't do any work + * not necessary to generate protocol tree items. + */ + if (!tree) + { + return; + } + + offset = 0; + saved_offset = offset; + + g_pinfo = pinfo; + g_tree = tree; + + len = tvb_length(tvb); + + /* + * add RP message name + */ + oct = tvb_get_guint8(tvb, offset++); + + str = my_match_strval((guint32) oct, gsm_rp_msg_strings, &idx); + + /* + * create the protocol tree + */ + if (str == NULL) + { + rp_item = + proto_tree_add_protocol_format(tree, proto_a_rp, tvb, 0, len, + "GSM A-I/F RP - Unknown RP Message Type (0x%02x)", + oct); + + rp_tree = proto_item_add_subtree(rp_item, ett_rp_msg); + } + else + { + gsm_a_rp_type = oct; + + rp_item = + proto_tree_add_protocol_format(tree, proto_a_rp, tvb, 0, -1, + "GSM A-I/F RP - %s", + str); + + rp_tree = proto_item_add_subtree(rp_item, ett_gsm_rp_msg[idx]); + + if (check_col(pinfo->cinfo, COL_INFO)) + { + col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", str); + } + } + + /* + * add RP message name + */ + proto_tree_add_uint_format(rp_tree, hf_gsm_a_rp_msg_type, + tvb, saved_offset, 1, oct, "Message Type"); + + if (str == NULL) return; + + if ((len - offset) <= 0) return; + + /* + * decode elements + */ + if (rp_msg_fcn[idx] == NULL) + { + proto_tree_add_text(rp_tree, + tvb, offset, len - offset, + "Message Elements"); + } + else + { + (*rp_msg_fcn[idx])(tvb, rp_tree, offset, len - offset); + } +} + + +static void +dissect_bssmap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + guint8 oct; + guint32 offset, saved_offset; + guint32 len; + gint idx; + proto_item *bssmap_item = NULL; + proto_tree *bssmap_tree = NULL; + gchar *str; + + + if (!proto_is_protocol_enabled(proto_a_bssmap)) + { + call_dissector(data_handle, tvb, pinfo, tree); + return; + } + + if (check_col(pinfo->cinfo, COL_INFO)) + { + col_append_str(pinfo->cinfo, COL_INFO, "(BSSMAP) "); + } + + /* + * In the interest of speed, if "tree" is NULL, don't do any work + * not necessary to generate protocol tree items. + */ + if (!tree) + { + return; + } + + offset = 0; + saved_offset = offset; + + g_pinfo = pinfo; + g_tree = tree; + + len = tvb_length(tvb); + + /* + * add BSSMAP message name + */ + oct = tvb_get_guint8(tvb, offset++); + + str = my_match_strval((guint32) oct, gsm_bssmap_msg_strings, &idx); + + /* + * create the protocol tree + */ + if (str == NULL) + { + bssmap_item = + proto_tree_add_protocol_format(tree, proto_a_bssmap, tvb, 0, len, + "GSM A-I/F BSSMAP - Unknown BSSMAP Message Type (0x%02x)", + oct); + + bssmap_tree = proto_item_add_subtree(bssmap_item, ett_bssmap_msg); + } + else + { + bssmap_item = + proto_tree_add_protocol_format(tree, proto_a_bssmap, tvb, 0, -1, + "GSM A-I/F BSSMAP - %s", + str); + + bssmap_tree = proto_item_add_subtree(bssmap_item, ett_gsm_bssmap_msg[idx]); + + if (check_col(pinfo->cinfo, COL_INFO)) + { + col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", str); + } + } + + /* + * add BSSMAP message name + */ + proto_tree_add_uint_format(bssmap_tree, hf_gsm_a_bssmap_msg_type, + tvb, saved_offset, 1, oct, "Message Type"); + + if (str == NULL) return; + + if ((len - offset) <= 0) return; + + /* + * decode elements + */ + if (bssmap_msg_fcn[idx] == NULL) + { + proto_tree_add_text(bssmap_tree, + tvb, offset, len - offset, + "Message Elements"); + } + else + { + (*bssmap_msg_fcn[idx])(tvb, bssmap_tree, offset, len - offset); + } +} + + +static void +dissect_dtap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + void (*msg_fcn)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len); + guint8 oct; + guint8 pd; + guint32 offset; + guint32 len; + guint32 oct_1, oct_2; + gint idx; + proto_item *dtap_item = NULL; + proto_tree *dtap_tree = NULL; + proto_item *oct_1_item = NULL; + proto_tree *pd_tree = NULL; + gchar *msg_str; + const gchar *str; + gint ett_tree; + gint ti; + int hf_idx; + + + if (!proto_is_protocol_enabled(proto_a_dtap)) + { + call_dissector(data_handle, tvb, pinfo, tree); + return; + } + + len = tvb_length(tvb); + + if (len < 2) + { + /* + * too short to be DTAP + */ + call_dissector(data_handle, tvb, pinfo, tree); + return; + } + + if (check_col(pinfo->cinfo, COL_INFO)) + { + col_append_str(pinfo->cinfo, COL_INFO, "(DTAP) "); + } + + /* + * In the interest of speed, if "tree" is NULL, don't do any work + * not necessary to generate protocol tree items. + */ + if (!tree) + { + return; + } + + offset = 0; + oct_2 = 0; + + g_pinfo = pinfo; + g_tree = tree; + + /* + * get protocol discriminator + */ + oct_1 = tvb_get_guint8(tvb, offset++); + + if ((((oct_1 & DTAP_TI_MASK) >> 4) & DTAP_TIE_PRES_MASK) == DTAP_TIE_PRES_MASK) + { + /* + * eventhough we don't know if a TI should be in the message yet + * we rely on the TI/SKIP indicator to be 0 to avoid taking this + * octet + */ + oct_2 = tvb_get_guint8(tvb, offset++); + } + + oct = tvb_get_guint8(tvb, offset); + + pd = oct_1 & DTAP_PD_MASK; + ti = -1; + msg_str = NULL; + ett_tree = -1; + hf_idx = -1; + msg_fcn = NULL; + + /* + * octet 1 + */ + switch (pd) + { + case 3: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_CC_IEI_MASK), gsm_dtap_msg_cc_strings, &idx); + ett_tree = ett_gsm_dtap_msg_cc[idx]; + hf_idx = hf_gsm_a_dtap_msg_cc_type; + msg_fcn = dtap_msg_cc_fcn[idx]; + ti = (oct_1 & DTAP_TI_MASK) >> 4; + break; + + case 5: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_MM_IEI_MASK), gsm_dtap_msg_mm_strings, &idx); + ett_tree = ett_gsm_dtap_msg_mm[idx]; + hf_idx = hf_gsm_a_dtap_msg_mm_type; + msg_fcn = dtap_msg_mm_fcn[idx]; + break; + + case 6: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_RR_IEI_MASK), gsm_dtap_msg_rr_strings, &idx); + ett_tree = ett_gsm_dtap_msg_rr[idx]; + hf_idx = hf_gsm_a_dtap_msg_rr_type; + msg_fcn = dtap_msg_rr_fcn[idx]; + break; + + case 8: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_GMM_IEI_MASK), gsm_dtap_msg_gmm_strings, &idx); + ett_tree = ett_gsm_dtap_msg_gmm[idx]; + hf_idx = hf_gsm_a_dtap_msg_gmm_type; + msg_fcn = dtap_msg_gmm_fcn[idx]; + break; + + case 9: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_SMS_IEI_MASK), gsm_dtap_msg_sms_strings, &idx); + ett_tree = ett_gsm_dtap_msg_sms[idx]; + hf_idx = hf_gsm_a_dtap_msg_sms_type; + msg_fcn = dtap_msg_sms_fcn[idx]; + ti = (oct_1 & DTAP_TI_MASK) >> 4; + break; + + case 10: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_SM_IEI_MASK), gsm_dtap_msg_sm_strings, &idx); + ett_tree = ett_gsm_dtap_msg_sm[idx]; + hf_idx = hf_gsm_a_dtap_msg_sm_type; + msg_fcn = dtap_msg_sm_fcn[idx]; + ti = (oct_1 & DTAP_TI_MASK) >> 4; + break; + + case 11: + str = pd_str[pd]; + msg_str = my_match_strval((guint32) (oct & DTAP_SS_IEI_MASK), gsm_dtap_msg_ss_strings, &idx); + ett_tree = ett_gsm_dtap_msg_ss[idx]; + hf_idx = hf_gsm_a_dtap_msg_ss_type; + msg_fcn = dtap_msg_ss_fcn[idx]; + ti = (oct_1 & DTAP_TI_MASK) >> 4; + break; + + default: + str = pd_str[pd]; + break; + } + + /* + * create the protocol tree + */ + if (msg_str == NULL) + { + dtap_item = + proto_tree_add_protocol_format(tree, proto_a_dtap, tvb, 0, len, + "GSM A-I/F DTAP - Unknown DTAP Message Type (0x%02x)", + oct); + + dtap_tree = proto_item_add_subtree(dtap_item, ett_dtap_msg); + } + else + { + dtap_item = + proto_tree_add_protocol_format(tree, proto_a_dtap, tvb, 0, -1, + "GSM A-I/F DTAP - %s", + msg_str); + + dtap_tree = proto_item_add_subtree(dtap_item, ett_tree); + + if (check_col(pinfo->cinfo, COL_INFO)) + { + col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", msg_str); + } + } + + oct_1_item = + proto_tree_add_text(dtap_tree, + tvb, 0, 1, + "Protocol Discriminator: %s", + str); + + pd_tree = proto_item_add_subtree(oct_1_item, ett_dtap_oct_1); + + if (ti == -1) + { + my_decode_bitfield_value(a_bigbuf, oct_1, 0xf0, 8); + proto_tree_add_text(pd_tree, + tvb, 0, 1, + "%s : Skip Indicator", + a_bigbuf); + } + else + { + my_decode_bitfield_value(a_bigbuf, oct_1, 0x80, 8); + proto_tree_add_text(pd_tree, + tvb, 0, 1, + "%s : TI flag: %s", + a_bigbuf, + ((oct_1 & 0x80) ? "allocated by receiver" : "allocated by sender")); + + if ((ti & DTAP_TIE_PRES_MASK) == DTAP_TIE_PRES_MASK) + { + /* ti is extended to next octet */ + + my_decode_bitfield_value(a_bigbuf, oct_1, 0x70, 8); + proto_tree_add_text(pd_tree, + tvb, 0, 1, + "%s : TIO: The TI value is given by the TIE in octet 2", + a_bigbuf); + } + else + { + my_decode_bitfield_value(a_bigbuf, oct_1, 0x70, 8); + proto_tree_add_text(pd_tree, + tvb, 0, 1, + "%s : TIO: %d", + a_bigbuf, + ti & DTAP_TIE_PRES_MASK); + } + } + + my_decode_bitfield_value(a_bigbuf, oct_1, DTAP_PD_MASK, 8); + proto_tree_add_text(pd_tree, + tvb, 0, 1, + "%s : Protocol Discriminator: %d", + a_bigbuf, + pd); + + if ((ti != -1) && + (ti & DTAP_TIE_PRES_MASK) == DTAP_TIE_PRES_MASK) + { + my_decode_bitfield_value(a_bigbuf, oct_2, 0x80, 8); + proto_tree_add_text(pd_tree, + tvb, 1, 1, + "%s : Extension", + a_bigbuf); + + my_decode_bitfield_value(a_bigbuf, oct_2, DTAP_TIE_MASK, 8); + proto_tree_add_text(pd_tree, + tvb, 1, 1, + "%s : TIE: %d", + a_bigbuf, + oct_2 & DTAP_TIE_MASK); + } + + /* + * XXX + * N(SD) + */ + + /* + * add DTAP message name + */ + proto_tree_add_uint_format(dtap_tree, hf_idx, + tvb, offset, 1, oct, + "Message Type"); + + offset++; + + if (msg_str == NULL) return; + + if ((len - offset) <= 0) return; + + /* + * decode elements + */ + if (msg_fcn == NULL) + { + proto_tree_add_text(dtap_tree, + tvb, offset, len - offset, + "Message Elements"); + } + else + { + (*msg_fcn)(tvb, dtap_tree, offset, len - offset); + } +} + + +/* Register the protocol with Ethereal */ +void +proto_register_gsm_a(void) +{ + guint i; + guint last_offset; + + /* Setup list of header fields */ + + static hf_register_info hf[] = + { + { &hf_gsm_a_bssmap_msg_type, + { "BSSMAP Message Type", "gsm_a.bssmap_msgtype", + FT_UINT8, BASE_HEX, VALS(gsm_bssmap_msg_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_mm_type, + { "DTAP Mobility Management Message Type", "gsm_a.dtap_msg_mm_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_mm_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_rr_type, + { "DTAP Radio Resources Management Message Type", "gsm_a.dtap_msg_rr_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_rr_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_cc_type, + { "DTAP Call Control Message Type", "gsm_a.dtap_msg_cc_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_cc_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_gmm_type, + { "DTAP GPRS Mobility Management Message Type", "gsm_a.dtap_msg_gmm_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_gmm_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_sms_type, + { "DTAP Short Message Service Message Type", "gsm_a.dtap_msg_sms_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_sms_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_sm_type, + { "DTAP GPRS Session Management Message Type", "gsm_a.dtap_msg_sm_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_sm_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_dtap_msg_ss_type, + { "DTAP Non call Supplementary Service Message Type", "gsm_a.dtap_msg_ss_type", + FT_UINT8, BASE_HEX, VALS(gsm_dtap_msg_ss_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_rp_msg_type, + { "RP Message Type", "gsm_a.rp_msg_type", + FT_UINT8, BASE_HEX, VALS(gsm_rp_msg_strings), 0x0, + "", HFILL } + }, + { &hf_gsm_a_bssmap_elem_id, + { "Element ID", "gsm_a_bssmap.elem_id", + FT_UINT8, BASE_DEC, NULL, 0, + "", HFILL } + }, + { &hf_gsm_a_dtap_elem_id, + { "Element ID", "gsm_a_dtap.elem_id", + FT_UINT8, BASE_DEC, NULL, 0, + "", HFILL } + }, + { &hf_gsm_a_length, + { "Length", "gsm_a.len", + FT_UINT8, BASE_DEC, NULL, 0, + "", HFILL } + }, + { &hf_gsm_a_none, + { "Sub tree", "gsm_a.none", + FT_NONE, 0, 0, 0, + "", HFILL } + }, + { &hf_gsm_a_imsi, + { "IMSI", "gsm_a.imsi", + FT_STRING, BASE_DEC, 0, 0, + "", HFILL } + }, + { &hf_gsm_a_tmsi, + { "TMSI/P-TMSI", "gsm_a.tmsi", + FT_UINT32, BASE_HEX, 0, 0x0, + "", HFILL } + }, + { &hf_gsm_a_imei, + { "IMEI", "gsm_a.imei", + FT_STRING, BASE_DEC, 0, 0, + "", HFILL } + }, + { &hf_gsm_a_imeisv, + { "IMEISV", "gsm_a.imeisv", + FT_STRING, BASE_DEC, 0, 0, + "", HFILL } + }, + { &hf_gsm_a_cld_party_bcd_num, + { "Called Party BCD Number", "gsm_a.cld_party_bcd_num", + FT_STRING, BASE_DEC, 0, 0, + "", HFILL } + }, + { &hf_gsm_a_clg_party_bcd_num, + { "Calling Party BCD Number", "gsm_a.clg_party_bcd_num", + FT_STRING, BASE_DEC, 0, 0, + "", HFILL } + }, + { &hf_gsm_a_cell_ci, + { "Cell CI", "gsm_a.cell_ci", + FT_UINT16, BASE_HEX, 0, 0x0, + "", HFILL } + }, + { &hf_gsm_a_cell_lac, + { "Cell LAC", "gsm_a.cell_lac", + FT_UINT16, BASE_HEX, 0, 0x0, + "", HFILL } + }, + { &hf_gsm_a_dlci_cc, + { "Control Channel", "bssap.dlci.cc", + FT_UINT8, BASE_HEX, VALS(bssap_cc_values), 0xc0, + "", HFILL}}, + { &hf_gsm_a_dlci_spare, + { "Spare", "bssap.dlci.spare", + FT_UINT8, BASE_HEX, NULL, 0x38, + "", HFILL}}, + { &hf_gsm_a_dlci_sapi, + { "SAPI", "bssap.dlci.sapi", + FT_UINT8, BASE_HEX, VALS(bssap_sapi_values), 0x07, + "", HFILL}}, + }; + + /* Setup protocol subtree array */ +#define NUM_INDIVIDUAL_ELEMS 10 + static gint *ett[NUM_INDIVIDUAL_ELEMS + NUM_GSM_BSSMAP_MSG + + NUM_GSM_DTAP_MSG_MM + NUM_GSM_DTAP_MSG_RR + NUM_GSM_DTAP_MSG_CC + + NUM_GSM_DTAP_MSG_GMM + NUM_GSM_DTAP_MSG_SMS + + NUM_GSM_DTAP_MSG_SM + NUM_GSM_DTAP_MSG_SS + NUM_GSM_RP_MSG + + NUM_GSM_BSSMAP_ELEM + NUM_GSM_DTAP_ELEM]; + + memset((void *) ett, -1, sizeof(ett)); + + ett[0] = &ett_bssmap_msg; + ett[1] = &ett_dtap_msg; + ett[2] = &ett_rp_msg; + ett[3] = &ett_elems; + ett[4] = &ett_elem; + ett[5] = &ett_dtap_oct_1; + ett[6] = &ett_cm_srvc_type; + ett[7] = &ett_gsm_enc_info; + ett[8] = &ett_cell_list; + ett[9] = &ett_dlci; + + last_offset = NUM_INDIVIDUAL_ELEMS; + + for (i=0; i < NUM_GSM_BSSMAP_MSG; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_bssmap_msg[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_MM; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_mm[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_RR; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_rr[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_CC; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_cc[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_GMM; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_gmm[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_SMS; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_sms[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_SM; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_sm[i]; + } + + for (i=0; i < NUM_GSM_DTAP_MSG_SS; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_msg_ss[i]; + } + + for (i=0; i < NUM_GSM_RP_MSG; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_rp_msg[i]; + } + + for (i=0; i < NUM_GSM_BSSMAP_ELEM; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_bssmap_elem[i]; + } + + for (i=0; i < NUM_GSM_DTAP_ELEM; i++, last_offset++) + { + ett[last_offset] = &ett_gsm_dtap_elem[i]; + } + + /* Register the protocol name and description */ + + proto_a_bssmap = + proto_register_protocol("GSM A-I/F BSSMAP", "GSM BSSMAP", "gsm_a_bssmap"); + + proto_register_field_array(proto_a_bssmap, hf, array_length(hf)); + + proto_a_dtap = + proto_register_protocol("GSM A-I/F DTAP", "GSM DTAP", "gsm_a_dtap"); + + proto_a_rp = + proto_register_protocol("GSM A-I/F RP", "GSM RP", "gsm_a_rp"); + + sms_dissector_table = + register_dissector_table("gsm_a.sms_tpdu", "GSM SMS TPDU", + FT_UINT8, BASE_DEC); + + proto_register_subtree_array(ett, array_length(ett)); +} + + +void +proto_reg_handoff_gsm_a(void) +{ + + bssmap_handle = create_dissector_handle(dissect_bssmap, proto_a_bssmap); + dtap_handle = create_dissector_handle(dissect_dtap, proto_a_dtap); + rp_handle = create_dissector_handle(dissect_rp, proto_a_rp); + + dissector_add("bssap.pdu_type", BSSAP_PDU_TYPE_BSSMAP, bssmap_handle); + dissector_add("bssap.pdu_type", BSSAP_PDU_TYPE_DTAP, dtap_handle); + + data_handle = find_dissector("data"); +} |