2008-01-10 16:43:48 +00:00
|
|
|
/* XXX see bug 1852:
|
|
|
|
*
|
|
|
|
* packet-gsm_map.c: There are 1174 display filter fields registered. Most are
|
|
|
|
* prefixed appropriately as "gsm_map", but many others are prefixed as
|
|
|
|
* "gsm_old", or even "gad", "gsm_ss", or with no prefix at all. I don't know
|
|
|
|
* if the ones with "gsm_old" are simply obsolete display filter fields or if
|
|
|
|
* they should be prefixed as "gsm_map.old." or what. Similar uncertainties
|
|
|
|
* for the others. Someone more knowledgeable than I am with respect to this
|
|
|
|
* dissector should provide a patch for it.
|
|
|
|
*/
|
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
/* packet-gsm_map-template.c
|
|
|
|
* Routines for GSM MobileApplication packet dissection
|
2007-06-15 16:20:35 +00:00
|
|
|
* including GSM SS.
|
2010-01-01 22:29:28 +00:00
|
|
|
* Copyright 2004 - 2010 , Anders Broman <anders.broman [AT] ericsson.com>
|
2005-01-24 22:33:36 +00:00
|
|
|
* Based on the dissector by:
|
|
|
|
* Felix Fei <felix.fei [AT] utstar.com>
|
|
|
|
* and Michael Lum <mlum [AT] telostech.com>
|
2004-11-02 01:19:23 +00:00
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2004-11-02 01:19:23 +00:00
|
|
|
* 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
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2009-10-09 21:03:07 +00:00
|
|
|
* References GSM MAP:
|
2007-06-15 16:20:35 +00:00
|
|
|
* ETSI TS 129 002
|
2007-02-16 21:02:19 +00:00
|
|
|
* Updated to ETSI TS 129 002 V7.5.0 (3GPP TS 29.002 V7.5.0 (2006-09) Release 7)
|
2008-02-05 06:10:34 +00:00
|
|
|
* Updated to ETSI TS 129 002 V8.4.0 (3GPP TS 29.002 V8.1.0 (2007-06) Release 8)
|
2007-06-15 16:20:35 +00:00
|
|
|
* References GSM SS
|
2007-06-15 16:26:08 +00:00
|
|
|
* References: 3GPP TS 24.080
|
2004-11-02 01:19:23 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 01:29:52 +00:00
|
|
|
#include "config.h"
|
2004-11-02 01:19:23 +00:00
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
#include <epan/packet.h>
|
2005-01-24 22:33:36 +00:00
|
|
|
#include <epan/prefs.h>
|
2004-11-02 01:19:23 +00:00
|
|
|
#include <epan/tap.h>
|
2013-06-19 20:43:03 +00:00
|
|
|
#include <epan/wmem/wmem.h>
|
2007-08-25 01:14:24 +00:00
|
|
|
#include <epan/oids.h>
|
2009-08-21 20:32:50 +00:00
|
|
|
#include <epan/expert.h>
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2013-12-03 22:16:49 +00:00
|
|
|
#include <stdlib.h>
|
2004-11-02 01:19:23 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
2007-05-01 22:05:11 +00:00
|
|
|
#include <epan/asn1.h>
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-ber.h"
|
2007-02-19 06:09:33 +00:00
|
|
|
#include "packet-per.h"
|
2005-02-03 21:22:09 +00:00
|
|
|
#include "packet-q931.h"
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-gsm_map.h"
|
2008-08-04 16:11:17 +00:00
|
|
|
#include "packet-gsm_a_common.h"
|
2005-12-17 16:55:45 +00:00
|
|
|
#include "packet-tcap.h"
|
2006-05-03 18:57:32 +00:00
|
|
|
#include "packet-e164.h"
|
2006-01-31 05:46:36 +00:00
|
|
|
#include "packet-e212.h"
|
2006-03-27 18:48:33 +00:00
|
|
|
#include "packet-smpp.h"
|
|
|
|
#include "packet-gsm_sms.h"
|
2007-02-19 06:09:33 +00:00
|
|
|
#include "packet-ranap.h"
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2005-06-07 05:49:57 +00:00
|
|
|
#define PNAME "GSM Mobile Application"
|
2004-11-02 01:19:23 +00:00
|
|
|
#define PSNAME "GSM_MAP"
|
|
|
|
#define PFNAME "gsm_map"
|
|
|
|
|
2013-03-28 07:34:13 +00:00
|
|
|
void proto_register_gsm_map(void);
|
|
|
|
void proto_reg_handoff_gsm_map(void);
|
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
/* Initialize the protocol and registered fields */
|
2009-10-11 16:24:29 +00:00
|
|
|
static int proto_gsm_map = -1;
|
|
|
|
static int proto_gsm_map_dialogue = -1;
|
2007-02-20 19:37:06 +00:00
|
|
|
|
2008-01-11 07:29:27 +00:00
|
|
|
static int hf_gsm_map_old_Component_PDU = -1;
|
2006-03-23 16:58:50 +00:00
|
|
|
static int hf_gsm_map_getPassword = -1;
|
2005-01-26 20:07:35 +00:00
|
|
|
static int hf_gsm_map_currentPassword = -1;
|
|
|
|
static int hf_gsm_map_extension = -1;
|
|
|
|
static int hf_gsm_map_nature_of_number = -1;
|
|
|
|
static int hf_gsm_map_number_plan = -1;
|
2005-07-11 19:24:30 +00:00
|
|
|
static int hf_gsm_map_address_digits = -1;
|
2007-06-10 19:04:12 +00:00
|
|
|
static int hf_gsm_map_TBCD_digits = -1;
|
2005-01-26 20:07:35 +00:00
|
|
|
static int hf_gsm_map_Ss_Status_unused = -1;
|
|
|
|
static int hf_gsm_map_Ss_Status_q_bit = -1;
|
|
|
|
static int hf_gsm_map_Ss_Status_p_bit = -1;
|
|
|
|
static int hf_gsm_map_Ss_Status_r_bit = -1;
|
|
|
|
static int hf_gsm_map_Ss_Status_a_bit = -1;
|
2005-07-11 19:24:30 +00:00
|
|
|
static int hf_gsm_map_notification_to_forwarding_party = -1;
|
|
|
|
static int hf_gsm_map_redirecting_presentation = -1;
|
|
|
|
static int hf_gsm_map_notification_to_calling_party = -1;
|
|
|
|
static int hf_gsm_map_forwarding_reason = -1;
|
|
|
|
static int hf_gsm_map_pdp_type_org = -1;
|
|
|
|
static int hf_gsm_map_etsi_pdp_type_number = -1;
|
|
|
|
static int hf_gsm_map_ietf_pdp_type_number = -1;
|
2006-01-19 18:20:14 +00:00
|
|
|
static int hf_gsm_map_ext_qos_subscribed_pri = -1;
|
|
|
|
|
|
|
|
static int hf_gsm_map_qos_traffic_cls = -1;
|
|
|
|
static int hf_gsm_map_qos_del_order = -1;
|
|
|
|
static int hf_gsm_map_qos_del_of_err_sdu = -1;
|
|
|
|
static int hf_gsm_map_qos_ber = -1;
|
|
|
|
static int hf_gsm_map_qos_sdu_err_rat = -1;
|
|
|
|
static int hf_gsm_map_qos_traff_hdl_pri = -1;
|
|
|
|
static int hf_gsm_map_qos_max_sdu = -1;
|
|
|
|
static int hf_gsm_map_max_brate_ulink = -1;
|
|
|
|
static int hf_gsm_map_max_brate_dlink = -1;
|
|
|
|
static int hf_gsm_map_qos_transfer_delay = -1;
|
|
|
|
static int hf_gsm_map_guaranteed_max_brate_ulink = -1;
|
|
|
|
static int hf_gsm_map_guaranteed_max_brate_dlink = -1;
|
2006-01-20 19:39:38 +00:00
|
|
|
static int hf_gsm_map_GSNAddress_IPv4 = -1;
|
2007-02-19 06:09:33 +00:00
|
|
|
static int hf_gsm_map_ranap_service_Handover = -1;
|
2008-01-11 07:29:27 +00:00
|
|
|
static int hf_gsm_map_IntegrityProtectionInformation = -1;
|
|
|
|
static int hf_gsm_map_EncryptionInformation = -1;
|
|
|
|
static int hf_gsm_map_ss_SS_UserData = -1;
|
2008-01-06 21:55:30 +00:00
|
|
|
static int hf_gsm_map_cbs_coding_grp = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp0_lang = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp1_lang = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp2_lang = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp3_lang = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp4_7_comp = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp4_7_class_ind = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp4_7_char_set = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp4_7_class = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp15_mess_code = -1;
|
|
|
|
static int hf_gsm_map_cbs_coding_grp15_class = -1;
|
2008-09-12 09:11:28 +00:00
|
|
|
static int hf_gsm_map_tmsi = -1;
|
2008-10-09 18:57:35 +00:00
|
|
|
static int hf_gsm_map_ie_tag = -1;
|
2008-10-10 12:08:28 +00:00
|
|
|
static int hf_gsm_map_len = -1;
|
|
|
|
static int hf_gsm_map_disc_par = -1;
|
|
|
|
static int hf_gsm_map_dlci = -1;
|
2011-06-20 10:29:46 +00:00
|
|
|
static int hf_gsm_apn_str = -1;
|
2012-03-07 12:06:16 +00:00
|
|
|
static int hf_gsm_map_locationnumber_odd_even = -1;
|
|
|
|
static int hf_gsm_map_locationnumber_nai = -1;
|
|
|
|
static int hf_gsm_map_locationnumber_inn = -1;
|
2012-11-29 20:15:37 +00:00
|
|
|
static int hf_gsm_map_locationnumber_npi = -1;
|
2012-03-07 12:06:16 +00:00
|
|
|
static int hf_gsm_map_locationnumber_apri = -1;
|
|
|
|
static int hf_gsm_map_locationnumber_screening_ind = -1;
|
|
|
|
static int hf_gsm_map_locationnumber_digits = -1;
|
2012-08-21 15:14:50 +00:00
|
|
|
static int hf_gsm_map_ericsson_locationInformation_rat = -1;
|
|
|
|
static int hf_gsm_map_ericsson_locationInformation_lac = -1;
|
|
|
|
static int hf_gsm_map_ericsson_locationInformation_ci = -1;
|
|
|
|
static int hf_gsm_map_ericsson_locationInformation_sac = -1;
|
2014-08-08 13:19:29 +00:00
|
|
|
static int hf_gsm_map_ussd_string = -1;
|
2008-01-06 21:55:30 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-gsm_map-hf.c"
|
|
|
|
|
|
|
|
/* Initialize the subtree pointers */
|
|
|
|
static gint ett_gsm_map = -1;
|
|
|
|
static gint ett_gsm_map_InvokeId = -1;
|
|
|
|
static gint ett_gsm_map_InvokePDU = -1;
|
|
|
|
static gint ett_gsm_map_ReturnResultPDU = -1;
|
2005-02-09 21:54:57 +00:00
|
|
|
static gint ett_gsm_map_ReturnErrorPDU = -1;
|
2004-11-02 01:19:23 +00:00
|
|
|
static gint ett_gsm_map_ReturnResult_result = -1;
|
2005-02-09 21:54:57 +00:00
|
|
|
static gint ett_gsm_map_ReturnError_result = -1;
|
2004-11-02 01:19:23 +00:00
|
|
|
static gint ett_gsm_map_GSMMAPPDU = -1;
|
2006-01-19 18:20:14 +00:00
|
|
|
static gint ett_gsm_map_ext_qos_subscribed = -1;
|
2006-01-22 21:16:33 +00:00
|
|
|
static gint ett_gsm_map_pdptypenumber = -1;
|
2009-10-09 21:03:07 +00:00
|
|
|
static gint ett_gsm_map_RAIdentity = -1;
|
2006-01-31 05:46:36 +00:00
|
|
|
static gint ett_gsm_map_LAIFixedLength = -1;
|
2006-05-03 18:57:32 +00:00
|
|
|
static gint ett_gsm_map_isdn_address_string = -1;
|
2006-06-02 16:58:22 +00:00
|
|
|
static gint ett_gsm_map_geo_desc = -1;
|
2006-07-11 19:46:52 +00:00
|
|
|
static gint ett_gsm_map_LongSignalInfo = -1;
|
|
|
|
static gint ett_gsm_map_RadioResourceInformation =-1;
|
2007-07-04 13:27:44 +00:00
|
|
|
static gint ett_gsm_map_MSNetworkCapability =-1;
|
|
|
|
static gint ett_gsm_map_MSRadioAccessCapability = -1;
|
2007-12-05 21:58:58 +00:00
|
|
|
static gint ett_gsm_map_externalsignalinfo = -1;
|
2008-01-06 21:55:30 +00:00
|
|
|
static gint ett_gsm_map_cbs_data_coding = -1;
|
2008-03-25 21:49:55 +00:00
|
|
|
static gint ett_gsm_map_GlobalCellId = -1;
|
|
|
|
static gint ett_gsm_map_GeographicalInformation = -1;
|
2011-06-20 10:29:46 +00:00
|
|
|
static gint ett_gsm_map_apn_str = -1;
|
2012-03-07 12:06:16 +00:00
|
|
|
static gint ett_gsm_map_LocationNumber = -1;
|
2012-08-21 15:14:50 +00:00
|
|
|
static gint ett_gsm_map_ericsson_locationInformation = -1;
|
2014-08-08 13:19:29 +00:00
|
|
|
static gint ett_gsm_map_extention_data = -1;
|
2005-02-09 21:54:57 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-gsm_map-ett.c"
|
|
|
|
|
2013-06-03 03:42:36 +00:00
|
|
|
static expert_field ei_gsm_map_unknown_sequence3 = EI_INIT;
|
|
|
|
static expert_field ei_gsm_map_unknown_sequence = EI_INIT;
|
|
|
|
static expert_field ei_gsm_map_unknown_parameter = EI_INIT;
|
|
|
|
static expert_field ei_gsm_map_unknown_invokeData = EI_INIT;
|
2014-08-08 13:19:29 +00:00
|
|
|
static expert_field ei_gsm_map_undecoded = EI_INIT;
|
2013-06-03 03:42:36 +00:00
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
static dissector_handle_t gsm_sms_handle; /* SMS TPDU */
|
|
|
|
static dissector_handle_t data_handle;
|
|
|
|
static dissector_handle_t ranap_handle;
|
|
|
|
static dissector_handle_t dtap_handle;
|
|
|
|
static dissector_handle_t map_handle;
|
2014-11-22 16:54:54 +00:00
|
|
|
static dissector_handle_t bssap_handle;
|
2014-03-14 16:39:52 +00:00
|
|
|
static dissector_table_t map_prop_arg_opcode_table; /* prorietary operation codes */
|
|
|
|
static dissector_table_t map_prop_res_opcode_table; /* prorietary operation codes */
|
|
|
|
static dissector_table_t map_prop_err_opcode_table; /* prorietary operation codes */
|
2005-01-24 22:33:36 +00:00
|
|
|
/* Preferenc settings default */
|
2005-03-17 22:08:09 +00:00
|
|
|
#define MAX_SSN 254
|
|
|
|
static range_t *global_ssn_range;
|
2012-07-10 11:39:06 +00:00
|
|
|
#define APPLICATON_CONTEXT_FROM_TRACE 0
|
|
|
|
static gint pref_application_context_version = APPLICATON_CONTEXT_FROM_TRACE;
|
2012-08-21 09:32:04 +00:00
|
|
|
static gboolean pref_ericsson_proprietary_ext = FALSE;
|
2005-01-24 22:33:36 +00:00
|
|
|
|
|
|
|
/* Global variables */
|
2005-12-19 19:34:52 +00:00
|
|
|
static guint32 opcode=0;
|
|
|
|
static guint32 errorCode;
|
2005-01-24 22:33:36 +00:00
|
|
|
static proto_tree *top_tree;
|
2005-03-28 02:53:49 +00:00
|
|
|
static int application_context_version;
|
2009-10-09 21:03:07 +00:00
|
|
|
static guint ProtocolId;
|
2009-10-09 21:06:56 +00:00
|
|
|
static guint AccessNetworkProtocolId;
|
|
|
|
static const char *obj_id = NULL;
|
2005-02-09 21:54:57 +00:00
|
|
|
static int gsm_map_tap = -1;
|
2014-10-09 20:48:59 +00:00
|
|
|
static guint8 gsmmap_pdu_type = 0;
|
|
|
|
static guint8 gsm_map_pdu_size = 0;
|
2005-02-09 21:54:57 +00:00
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
#define SMS_ENCODING_NOT_SET 0
|
|
|
|
#define SMS_ENCODING_7BIT 1
|
|
|
|
#define SMS_ENCODING_8BIT 2
|
|
|
|
#define SMS_ENCODING_UCS2 3
|
|
|
|
#define SMS_ENCODING_7BIT_LANG 4
|
|
|
|
#define SMS_ENCODING_UCS2_LANG 5
|
2008-01-06 21:55:30 +00:00
|
|
|
|
|
|
|
static guint8 sms_encoding;
|
|
|
|
|
2005-12-19 19:34:52 +00:00
|
|
|
/* Forward declarations */
|
2007-05-13 20:58:29 +00:00
|
|
|
static int dissect_invokeData(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx);
|
|
|
|
static int dissect_returnResultData(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx);
|
|
|
|
static int dissect_returnErrorData(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx);
|
2014-03-04 11:32:50 +00:00
|
|
|
const gchar* gsm_map_opr_code(guint32 val, proto_item *item);
|
2005-12-19 19:34:52 +00:00
|
|
|
|
2006-01-20 19:39:38 +00:00
|
|
|
/* Value strings */
|
|
|
|
|
|
|
|
const value_string gsm_map_PDP_Type_Organisation_vals[] = {
|
|
|
|
{ 0, "ETSI" },
|
|
|
|
{ 1, "IETF" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
const value_string gsm_map_ietf_defined_pdp_vals[] = {
|
|
|
|
{ 0x21, "IPv4 Address" },
|
|
|
|
{ 0x57, "IPv6 Address" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
const value_string gsm_map_etsi_defined_pdp_vals[] = {
|
|
|
|
{ 1, "PPP" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2008-10-11 11:06:58 +00:00
|
|
|
static const value_string gsm_map_tag_vals[] = {
|
|
|
|
{ 0x4, "Bearer Capability" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2008-10-10 12:08:28 +00:00
|
|
|
static const value_string gsm_map_disc_par_vals[] = {
|
|
|
|
{ 0, "Not Transparent" },
|
|
|
|
{ 1, "Transparent" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2012-08-21 15:14:50 +00:00
|
|
|
static const value_string gsm_map_ericsson_locationInformation_rat_vals[] = {
|
|
|
|
{ 0x0, "GSM" },
|
|
|
|
{ 0x1, "UMTS" },
|
|
|
|
{ 0x2, "LTE" },
|
|
|
|
{ 0xf, "No information" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2012-03-07 12:06:16 +00:00
|
|
|
|
|
|
|
/* ITU-T Q.763 (12/1999)
|
|
|
|
* 3.30 Location number
|
|
|
|
*/
|
|
|
|
/* b) Nature of address indicator */
|
|
|
|
static const range_string gsm_map_na_vals[] = {
|
|
|
|
{ 0, 0, "spare" },
|
|
|
|
{ 1, 1, "reserved for subscriber number (national use)" },
|
|
|
|
{ 2, 2, "reserved for unknown (national use)" },
|
|
|
|
{ 3, 3, "national (significant) number (national use)" },
|
|
|
|
{ 4, 4, "international number" },
|
|
|
|
{ 5, 0x6f, "spare" },
|
|
|
|
{ 0x70, 0x7e, "spare" },
|
|
|
|
{ 0x70, 0x7e, "reserved for national use" },
|
|
|
|
{ 0x7f, 0x7f, "spare" },
|
|
|
|
{ 0, 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
/* d) Numbering plan indicator */
|
|
|
|
static const value_string gsm_map_np_vals[] = {
|
|
|
|
{ 0, "spare" },
|
|
|
|
{ 1, "ISDN (telephony) numbering plan (ITU-T Recommendation E.164)" },
|
|
|
|
{ 2, "spare" },
|
|
|
|
{ 3, "Data numbering plan (ITU-T Recommendation X.121) (national use)" },
|
|
|
|
{ 4, "Telex numbering plan (ITU-T Recommendation F.69) (national use)" },
|
|
|
|
{ 5, "private numbering plan" },
|
|
|
|
{ 6, "reserved for national use" },
|
|
|
|
{ 7, "spare" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
/*
|
|
|
|
* e) Address presentation restricted indicator
|
|
|
|
*/
|
|
|
|
static const value_string gsm_map_addr_pres_rest_vals[] = {
|
|
|
|
{ 0, "presentation allowed" },
|
|
|
|
{ 1, "presentation restricted" },
|
|
|
|
{ 2, "address not available (national use)" },
|
|
|
|
{ 3, "spare" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
/* f) Screening indicator */
|
|
|
|
static const value_string gsm_map_screening_ind_vals[] = {
|
|
|
|
{ 0, "reserved" },
|
|
|
|
{ 1, "user provided, verified and passed" },
|
|
|
|
{ 2, "reserved" },
|
|
|
|
{ 3, "network provided" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2006-01-20 19:39:38 +00:00
|
|
|
/* returns value in kb/s */
|
|
|
|
static guint
|
|
|
|
gsm_map_calc_bitrate(guint8 value){
|
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
guint8 granularity;
|
|
|
|
guint returnvalue;
|
|
|
|
|
|
|
|
if (value == 0xff)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
granularity = value >> 6;
|
|
|
|
returnvalue = value & 0x7f;
|
|
|
|
switch (granularity){
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
returnvalue = ((returnvalue - 0x40) << 3)+64;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
returnvalue = (returnvalue << 6)+576;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
returnvalue = (returnvalue << 6)+576;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return returnvalue;
|
2005-01-21 22:49:13 +00:00
|
|
|
|
2006-01-20 19:39:38 +00:00
|
|
|
}
|
2006-01-19 18:20:14 +00:00
|
|
|
|
2009-10-09 21:03:07 +00:00
|
|
|
static void
|
2008-01-04 12:39:52 +00:00
|
|
|
dissect_gsm_map_ext_qos_subscribed(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree _U_, asn1_ctx_t *actx){
|
2014-03-14 16:39:52 +00:00
|
|
|
int offset = 0;
|
|
|
|
proto_tree *subtree;
|
|
|
|
guint8 octet;
|
|
|
|
guint16 value;
|
|
|
|
|
|
|
|
subtree = proto_item_add_subtree(actx->created_item, ett_gsm_map_ext_qos_subscribed);
|
|
|
|
/* OCTET 1:
|
|
|
|
Allocation/Retention Priority (This octet encodes each priority level defined in
|
|
|
|
23.107 as the binary value of the priority level, declaration in 29.060)
|
|
|
|
Octets 2-9 are coded according to 3GPP TS 24.008[35] Quality of Service Octets
|
|
|
|
6-13.
|
|
|
|
*/
|
|
|
|
/* Allocation/Retention Priority */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_ext_qos_subscribed_pri, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Quality of Service Octets 6-13.( Octet 2 - 9 Here) */
|
|
|
|
|
|
|
|
/* Traffic class, octet 6 (see 3GPP TS 23.107) Bits 8 7 6 */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_traffic_cls, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
/* Delivery order, octet 6 (see 3GPP TS 23.107) Bits 5 4 */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_del_order, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
/* Delivery of erroneous SDUs, octet 6 (see 3GPP TS 23.107) Bits 3 2 1 */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_del_of_err_sdu, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Maximum SDU size, octet 7 (see 3GPP TS 23.107) */
|
|
|
|
octet = tvb_get_guint8(tvb,offset);
|
|
|
|
switch (octet){
|
|
|
|
case 0:
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_uint_format_value(subtree, hf_gsm_map_qos_max_sdu, tvb, offset, 1, octet, "Reserved");
|
2014-03-14 16:39:52 +00:00
|
|
|
break;
|
|
|
|
case 0x93:
|
|
|
|
value = 1502;
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_qos_max_sdu, tvb, offset, 1, value);
|
|
|
|
break;
|
|
|
|
case 0x98:
|
|
|
|
value = 1510;
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_qos_max_sdu, tvb, offset, 1, value);
|
|
|
|
break;
|
|
|
|
case 0x99:
|
|
|
|
value = 1532;
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_qos_max_sdu, tvb, offset, 1, value);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (octet<0x97){
|
|
|
|
value = octet * 10;
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_qos_max_sdu, tvb, offset, 1, value);
|
|
|
|
}else{
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_uint_format_value(subtree, hf_gsm_map_qos_max_sdu, tvb, offset, 1, octet, "0x%x not defined in TS 24.008", octet);
|
2014-03-14 16:39:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Maximum bit rate for uplink, octet 8 */
|
|
|
|
octet = tvb_get_guint8(tvb,offset);
|
|
|
|
if (octet == 0 ){
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_uint_format_value(subtree, hf_gsm_map_max_brate_ulink, tvb, offset, 1, octet, "Reserved" );
|
2014-03-14 16:39:52 +00:00
|
|
|
}else{
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_max_brate_ulink, tvb, offset, 1, gsm_map_calc_bitrate(octet));
|
|
|
|
}
|
|
|
|
offset++;
|
|
|
|
/* Maximum bit rate for downlink, octet 9 (see 3GPP TS 23.107) */
|
|
|
|
octet = tvb_get_guint8(tvb,offset);
|
|
|
|
if (octet == 0 ){
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_uint_format_value(subtree, hf_gsm_map_max_brate_dlink, tvb, offset, 1, octet, "Reserved" );
|
2014-03-14 16:39:52 +00:00
|
|
|
}else{
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_max_brate_dlink, tvb, offset, 1, gsm_map_calc_bitrate(octet));
|
|
|
|
}
|
|
|
|
offset++;
|
|
|
|
/* Residual Bit Error Rate (BER), octet 10 (see 3GPP TS 23.107) Bits 8 7 6 5 */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_ber, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
/* SDU error ratio, octet 10 (see 3GPP TS 23.107) */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_sdu_err_rat, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Transfer delay, octet 11 (See 3GPP TS 23.107) Bits 8 7 6 5 4 3 */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_transfer_delay, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
/* Traffic handling priority, octet 11 (see 3GPP TS 23.107) Bits 2 1 */
|
|
|
|
proto_tree_add_item(subtree, hf_gsm_map_qos_traff_hdl_pri, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Guaranteed bit rate for uplink, octet 12 (See 3GPP TS 23.107)
|
|
|
|
Coding is identical to that of Maximum bit rate for uplink.
|
|
|
|
*/
|
|
|
|
octet = tvb_get_guint8(tvb,offset);
|
|
|
|
if (octet == 0 ){
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_uint_format_value(subtree, hf_gsm_map_guaranteed_max_brate_ulink, tvb, offset, 1, octet, "Reserved" );
|
2014-03-14 16:39:52 +00:00
|
|
|
}else{
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_guaranteed_max_brate_ulink, tvb, offset, 1, gsm_map_calc_bitrate(octet));
|
|
|
|
}
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Guaranteed bit rate for downlink, octet 13(See 3GPP TS 23.107)
|
|
|
|
Coding is identical to that of Maximum bit rate for uplink.
|
|
|
|
*/
|
|
|
|
octet = tvb_get_guint8(tvb,offset);
|
|
|
|
if (octet == 0 ){
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_uint_format_value(subtree, hf_gsm_map_guaranteed_max_brate_dlink, tvb, offset, 1, octet, "Reserved" );
|
2014-03-14 16:39:52 +00:00
|
|
|
}else{
|
|
|
|
proto_tree_add_uint(subtree, hf_gsm_map_guaranteed_max_brate_dlink, tvb, offset, 1, gsm_map_calc_bitrate(octet));
|
|
|
|
}
|
2006-01-19 18:20:14 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-05-17 20:09:48 +00:00
|
|
|
#define ELLIPSOID_POINT 0
|
2008-10-27 21:57:36 +00:00
|
|
|
#define ELLIPSOID_POINT_WITH_UNCERT_CIRC 1
|
|
|
|
#define ELLIPSOID_POINT_WITH_UNCERT_ELLIPSE 3
|
|
|
|
#define POLYGON 5
|
|
|
|
#define ELLIPSOID_POINT_WITH_ALT 8
|
|
|
|
#define ELLIPSOID_POINT_WITH_ALT_AND_UNCERT_ELLIPSOID 9
|
|
|
|
#define ELLIPSOID_ARC 10
|
|
|
|
/*
|
|
|
|
4 3 2 1
|
|
|
|
0 0 0 0 Ellipsoid Point
|
|
|
|
0 0 0 1 Ellipsoid point with uncertainty Circle
|
|
|
|
0 0 1 1 Ellipsoid point with uncertainty Ellipse
|
2009-10-09 21:03:07 +00:00
|
|
|
0 1 0 1 Polygon
|
2008-10-27 21:57:36 +00:00
|
|
|
1 0 0 0 Ellipsoid point with altitude
|
|
|
|
1 0 0 1 Ellipsoid point with altitude and uncertainty Ellipsoid
|
|
|
|
1 0 1 0 Ellipsoid Arc
|
|
|
|
other values reserved for future use
|
|
|
|
*/
|
2006-05-17 20:09:48 +00:00
|
|
|
|
|
|
|
/* TS 23 032 Table 2a: Coding of Type of Shape */
|
2014-03-15 13:31:14 +00:00
|
|
|
#if 0
|
2006-05-17 20:09:48 +00:00
|
|
|
static const value_string type_of_shape_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ ELLIPSOID_POINT, "Ellipsoid Point"},
|
|
|
|
{ ELLIPSOID_POINT_WITH_UNCERT_CIRC, "Ellipsoid point with uncertainty Circle"},
|
|
|
|
{ ELLIPSOID_POINT_WITH_UNCERT_ELLIPSE, "Ellipsoid point with uncertainty Ellipse"},
|
|
|
|
{ POLYGON, "Polygon"},
|
|
|
|
{ ELLIPSOID_POINT_WITH_ALT, "Ellipsoid point with altitude"},
|
|
|
|
{ ELLIPSOID_POINT_WITH_ALT_AND_UNCERT_ELLIPSOID, "Ellipsoid point with altitude and uncertainty Ellipsoid"},
|
|
|
|
{ ELLIPSOID_ARC, "Ellipsoid Arc"},
|
|
|
|
{ 0, NULL }
|
2006-05-17 20:09:48 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* 3GPP TS 23.032 7.3.1 */
|
|
|
|
static const value_string sign_of_latitude_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "North"},
|
|
|
|
{ 1, "South"},
|
|
|
|
{ 0, NULL }
|
2006-05-17 20:09:48 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string dir_of_alt_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "Altitude expresses height"},
|
|
|
|
{ 1, "Altitude expresses depth"},
|
|
|
|
{ 0, NULL }
|
2006-05-17 20:09:48 +00:00
|
|
|
};
|
2014-03-15 13:31:14 +00:00
|
|
|
#endif
|
2006-05-17 20:09:48 +00:00
|
|
|
|
2008-01-06 21:55:30 +00:00
|
|
|
static const value_string gsm_map_cbs_data_coding_scheme_coding_grp_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "Coding Group 0(Language using the GSM 7 bit default alphabet)" },
|
|
|
|
{ 1, "Coding Group 1" },
|
|
|
|
{ 2, "Coding Group 2" },
|
|
|
|
{ 3, "Coding Group 3" },
|
|
|
|
{ 4, "General Data Coding indication" },
|
|
|
|
{ 5, "General Data Coding indication" },
|
|
|
|
{ 6, "General Data Coding indication" },
|
|
|
|
{ 7, "General Data Coding indication" },
|
|
|
|
{ 8, "Reserved" },
|
|
|
|
{ 9, "Message with User Data Header (UDH) structure" },
|
|
|
|
{ 10,"Reserved" },
|
|
|
|
{ 11,"Reserved" },
|
|
|
|
{ 12,"Reserved" },
|
|
|
|
{ 13,"Reserved" },
|
|
|
|
{ 14,"Defined by the WAP Forum" },
|
|
|
|
{ 15,"Data coding / message handling" },
|
|
|
|
{ 0, NULL}
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_cbs_data_coding_scheme_coding_grp_vals_ext = VALUE_STRING_EXT_INIT(gsm_map_cbs_data_coding_scheme_coding_grp_vals);
|
|
|
|
|
2009-10-09 21:03:07 +00:00
|
|
|
/* Coding group 0
|
2008-01-06 21:55:30 +00:00
|
|
|
* Bits 3..0 indicate the language:
|
|
|
|
*/
|
|
|
|
static const value_string gsm_map_cbs_coding_grp0_lang_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "German"},
|
|
|
|
{ 1, "English"},
|
|
|
|
{ 2, "Italian"},
|
|
|
|
{ 3, "French"},
|
|
|
|
{ 4, "Spanish"},
|
|
|
|
{ 5, "Dutch"},
|
|
|
|
{ 6, "Swedish"},
|
|
|
|
{ 7, "Danish"},
|
|
|
|
{ 8, "Portuguese"},
|
|
|
|
{ 9, "Finnish"},
|
|
|
|
{ 10, "Norwegian"},
|
|
|
|
{ 11, "Greek"},
|
|
|
|
{ 12, "Turkish"},
|
|
|
|
{ 13, "Hungarian"},
|
|
|
|
{ 14, "Polish"},
|
|
|
|
{ 15, "Language unspecified"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_cbs_coding_grp0_lang_vals_ext = VALUE_STRING_EXT_INIT(gsm_map_cbs_coding_grp0_lang_vals);
|
2008-01-06 21:55:30 +00:00
|
|
|
|
|
|
|
static const value_string gsm_map_cbs_coding_grp1_lang_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "GSM 7 bit default alphabet; message preceded by language indication"},
|
|
|
|
{ 1, "UCS2; message preceded by language indication"},
|
|
|
|
{ 2, "Reserved"},
|
|
|
|
{ 3, "Reserved"},
|
|
|
|
{ 4, "Reserved"},
|
|
|
|
{ 5, "Reserved"},
|
|
|
|
{ 6, "Reserved"},
|
|
|
|
{ 7, "Reserved"},
|
|
|
|
{ 8, "Reserved"},
|
|
|
|
{ 9, "Reserved"},
|
|
|
|
{ 10, "Reserved"},
|
|
|
|
{ 11, "Reserved"},
|
|
|
|
{ 12, "Reserved"},
|
|
|
|
{ 13, "Reserved"},
|
|
|
|
{ 14, "Reserved"},
|
|
|
|
{ 15, "Reserved"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_cbs_coding_grp1_lang_vals_ext = VALUE_STRING_EXT_INIT(gsm_map_cbs_coding_grp1_lang_vals);
|
|
|
|
|
2008-01-06 21:55:30 +00:00
|
|
|
static const value_string gsm_map_cbs_coding_grp2_lang_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "Czech"},
|
|
|
|
{ 1, "Hebrew"},
|
|
|
|
{ 2, "Arabic"},
|
|
|
|
{ 3, "Russian"},
|
|
|
|
{ 4, "Icelandic"},
|
|
|
|
{ 5, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 6, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 7, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 8, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 9, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 10, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 11, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 12, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 13, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 14, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 15, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_cbs_coding_grp2_lang_vals_ext = VALUE_STRING_EXT_INIT(gsm_map_cbs_coding_grp2_lang_vals);
|
|
|
|
|
2008-01-06 21:55:30 +00:00
|
|
|
static const value_string gsm_map_cbs_coding_grp3_lang_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 1, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 2, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 3, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 4, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 5, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 6, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 7, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 8, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 9, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 10, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 11, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 12, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 13, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 14, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 15, "Reserved for other languages using the GSM 7 bit default alphabet, with unspecified handling at the MS"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_cbs_coding_grp3_lang_vals_ext = VALUE_STRING_EXT_INIT(gsm_map_cbs_coding_grp3_lang_vals);
|
2008-01-06 21:55:30 +00:00
|
|
|
|
|
|
|
static const true_false_string gsm_map_cbs_coding_grp4_7_comp_vals = {
|
|
|
|
"The text is compressed using the compression algorithm defined in 3GPP TS 23.042",
|
|
|
|
"The text is uncompressed"
|
|
|
|
};
|
|
|
|
|
|
|
|
static const true_false_string gsm_map_cbs_coding_grp4_7_class_ind_vals = {
|
|
|
|
"Bits 1 to 0 have a message class meaning",
|
|
|
|
"Bits 1 to 0 are reserved and have no message class meaning"
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Bits 3 and 2 indicate the character set being used, as follows: */
|
|
|
|
|
|
|
|
static const value_string gsm_map_cbs_coding_grp4_7_char_set_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "GSM 7 bit default alphabet"},
|
|
|
|
{ 1, "8 bit data"},
|
|
|
|
{ 2, "UCS2 (16 bit)"},
|
|
|
|
{ 3, "Reserved"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string gsm_map_cbs_coding_grp4_7_class_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "Class 0"},
|
|
|
|
{ 1, "Class 1 Default meaning: ME-specific"},
|
|
|
|
{ 2, "Class 2 (U)SIM specific message"},
|
|
|
|
{ 3, "Class 3 Default meaning: TE-specific (see 3GPP TS 27.005"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string gsm_map_cbs_coding_grp15_mess_code_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "GSM 7 bit default alphabet"},
|
|
|
|
{ 1, "8 bit data"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string gsm_map_cbs_coding_grp15_class_vals[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0, "GSM 7 bit default alphabet"},
|
|
|
|
{ 1, "8 bit data"},
|
|
|
|
{ 0, NULL }
|
2008-01-06 21:55:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* 3GPP TS 23.038 version 7.0.0 Release 7 */
|
2008-03-19 19:11:33 +00:00
|
|
|
guint8
|
2012-01-26 19:51:48 +00:00
|
|
|
dissect_cbs_data_coding_scheme(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint16 offset)
|
2008-01-06 21:55:30 +00:00
|
|
|
{
|
2014-03-14 16:39:52 +00:00
|
|
|
guint8 octet;
|
|
|
|
guint8 coding_grp;
|
|
|
|
guint8 character_set;
|
|
|
|
|
|
|
|
octet = tvb_get_guint8(tvb,offset);
|
|
|
|
coding_grp = octet >>4;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
|
|
|
|
sms_encoding = SMS_ENCODING_NOT_SET;
|
|
|
|
switch (coding_grp){
|
|
|
|
case 0:
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp0_lang, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp1_lang, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
if ((octet & 0x0f)== 0){
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT_LANG;
|
|
|
|
}else{
|
|
|
|
sms_encoding = SMS_ENCODING_UCS2_LANG;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp2_lang, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp3_lang, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT;
|
|
|
|
break;
|
|
|
|
/* Coding_grp 01xx */
|
|
|
|
case 4:
|
|
|
|
/* FALLTHRU */
|
|
|
|
case 5:
|
|
|
|
/* FALLTHRU */
|
|
|
|
case 6:
|
|
|
|
/* FALLTHRU */
|
|
|
|
case 7:
|
|
|
|
/* FALLTHRU */
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp4_7_comp, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp4_7_class_ind, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp4_7_char_set, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
if ((octet & 0x10)== 0x10){
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp4_7_class, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
}
|
|
|
|
/* Bits 3 and 2 indicate the character set being used, */
|
|
|
|
character_set = (octet&0x0c)>>2;
|
|
|
|
switch (character_set){
|
|
|
|
case 0:
|
|
|
|
/* GSM 7 bit default alphabet */
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
/* 8 bit data */
|
|
|
|
sms_encoding = SMS_ENCODING_8BIT;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
/* UCS2 (16 bit) */
|
|
|
|
sms_encoding = SMS_ENCODING_UCS2;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
/* Reserved */
|
|
|
|
sms_encoding = SMS_ENCODING_NOT_SET;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 8:
|
|
|
|
/* Reserved coding groups */
|
|
|
|
break;
|
|
|
|
case 9:
|
|
|
|
/* Message with User Data Header (UDH) structure:*/
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp4_7_char_set, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp4_7_class, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
character_set = (octet&0x0c)>>2;
|
|
|
|
switch (character_set){
|
|
|
|
case 0:
|
|
|
|
/* GSM 7 bit default alphabet */
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
/* 8 bit data */
|
|
|
|
sms_encoding = SMS_ENCODING_8BIT;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
/* UCS2 (16 bit) */
|
|
|
|
sms_encoding = SMS_ENCODING_UCS2;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
/* Reserved */
|
|
|
|
sms_encoding = SMS_ENCODING_NOT_SET;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 10:
|
|
|
|
/* FALLTHRU */
|
|
|
|
case 11:
|
|
|
|
/* FALLTHRU */
|
|
|
|
case 12:
|
|
|
|
/* FALLTHRU */
|
|
|
|
case 13:
|
|
|
|
/* FALLTHRU */
|
|
|
|
/* 1010..1101 Reserved coding groups */
|
|
|
|
break;
|
|
|
|
case 14:
|
|
|
|
/* Defined by the WAP Forum
|
|
|
|
* "Wireless Datagram Protocol Specification", Wireless Application Protocol Forum Ltd.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
case 15:
|
|
|
|
/* Data coding / message handling */
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp15_mess_code, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_cbs_coding_grp15_class, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
character_set = (octet&0x04)>>2;
|
|
|
|
if (character_set == 0){
|
|
|
|
sms_encoding = SMS_ENCODING_7BIT;
|
|
|
|
}else{
|
|
|
|
sms_encoding = SMS_ENCODING_8BIT;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sms_encoding;
|
2008-01-06 21:55:30 +00:00
|
|
|
}
|
2009-01-15 20:55:24 +00:00
|
|
|
void
|
2014-08-26 12:49:24 +00:00
|
|
|
dissect_gsm_map_msisdn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
2009-01-15 20:55:24 +00:00
|
|
|
{
|
2014-03-14 16:39:52 +00:00
|
|
|
const char *digit_str;
|
|
|
|
guint8 octet;
|
|
|
|
guint8 na;
|
|
|
|
guint8 np;
|
2009-01-15 20:55:24 +00:00
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
proto_tree_add_item(tree, hf_gsm_map_extension, tvb, 0,1,ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_nature_of_number, tvb, 0,1,ENC_BIG_ENDIAN);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_map_number_plan, tvb, 0,1,ENC_BIG_ENDIAN);
|
2009-01-15 20:55:24 +00:00
|
|
|
|
2014-06-19 19:55:27 +00:00
|
|
|
if(tvb_reported_length(tvb)==1)
|
2014-03-14 16:39:52 +00:00
|
|
|
return;
|
2012-10-21 15:01:23 +00:00
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
octet = tvb_get_guint8(tvb,0);
|
2014-08-26 12:49:24 +00:00
|
|
|
/* nature of address indicator */
|
2014-03-14 16:39:52 +00:00
|
|
|
na = (octet & 0x70)>>4;
|
2014-08-26 12:49:24 +00:00
|
|
|
/* numbering plan indicator */
|
2014-03-14 16:39:52 +00:00
|
|
|
np = octet & 0x0f;
|
2014-08-26 12:49:24 +00:00
|
|
|
switch(np){
|
|
|
|
case 1:
|
|
|
|
/* ISDN/Telephony Numbering Plan (Rec ITU-T E.164) */
|
|
|
|
switch(na){
|
|
|
|
case 1:
|
|
|
|
/* international number */
|
|
|
|
dissect_e164_msisdn(tvb, tree, 1, tvb_reported_length(tvb)-1, E164_ENC_BCD);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
digit_str = tvb_bcd_dig_to_wmem_packet_str(tvb, 1, -1, NULL, FALSE);
|
|
|
|
proto_tree_add_string(tree, hf_gsm_map_address_digits, tvb, 1, -1, digit_str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
/* land mobile numbering plan (ITU-T Rec E.212) */
|
|
|
|
dissect_e212_imsi(tvb, pinfo, tree, 1, tvb_reported_length(tvb)-1, FALSE);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
digit_str = tvb_bcd_dig_to_wmem_packet_str(tvb, 1, -1, NULL, FALSE);
|
|
|
|
proto_tree_add_string(tree, hf_gsm_map_address_digits, tvb, 1, -1, digit_str);
|
|
|
|
break;
|
|
|
|
}
|
2009-01-15 20:55:24 +00:00
|
|
|
|
|
|
|
}
|
2008-01-06 21:55:30 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-gsm_map-fn.c"
|
|
|
|
|
2007-04-23 21:26:27 +00:00
|
|
|
/* Specific translation for MAP V3 */
|
2007-06-20 21:54:40 +00:00
|
|
|
const value_string gsm_map_V1V2_opr_code_strings[] = {
|
|
|
|
{ 44, "forwardSM" },
|
|
|
|
{ 45, "sendRoutingInfoForSM" },
|
|
|
|
{ 46, "forwardSM" },
|
2007-04-23 21:26:27 +00:00
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
/* Generic translation for MAP operation */
|
2004-11-02 01:19:23 +00:00
|
|
|
const value_string gsm_map_opr_code_strings[] = {
|
2007-08-29 06:13:40 +00:00
|
|
|
#include "packet-gsm_map-table.c"
|
2004-11-02 01:19:23 +00:00
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2014-03-15 13:31:14 +00:00
|
|
|
|
|
|
|
#if 0
|
2005-02-11 22:43:24 +00:00
|
|
|
static const value_string gsm_map_err_code_string_vals[] = {
|
2007-08-29 06:13:40 +00:00
|
|
|
#include "packet-gsm_map-table.c"
|
2005-02-11 22:43:24 +00:00
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2014-03-15 13:31:14 +00:00
|
|
|
#endif
|
|
|
|
|
2005-01-26 20:07:35 +00:00
|
|
|
static const true_false_string gsm_map_extension_value = {
|
|
|
|
"No Extension",
|
|
|
|
"Extension"
|
|
|
|
};
|
|
|
|
static const value_string gsm_map_nature_of_number_values[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0x00, "unknown" },
|
|
|
|
{ 0x01, "International Number" },
|
|
|
|
{ 0x02, "National Significant Number" },
|
|
|
|
{ 0x03, "Network Specific Number" },
|
|
|
|
{ 0x04, "Subscriber Number" },
|
|
|
|
{ 0x05, "Reserved" },
|
|
|
|
{ 0x06, "Abbreviated Number" },
|
|
|
|
{ 0x07, "Reserved for extension" },
|
|
|
|
{ 0, NULL }
|
2005-01-26 20:07:35 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_nature_of_number_values_ext = VALUE_STRING_EXT_INIT(gsm_map_nature_of_number_values);
|
|
|
|
|
2005-01-26 20:07:35 +00:00
|
|
|
static const value_string gsm_map_number_plan_values[] = {
|
2014-03-14 16:39:52 +00:00
|
|
|
{ 0x00, "unknown" },
|
|
|
|
{ 0x01, "ISDN/Telephony Numbering (Rec ITU-T E.164)" },
|
|
|
|
{ 0x02, "spare" },
|
|
|
|
{ 0x03, "Data Numbering (ITU-T Rec. X.121)" },
|
|
|
|
{ 0x04, "Telex Numbering (ITU-T Rec. F.69)" },
|
|
|
|
{ 0x05, "spare" },
|
|
|
|
{ 0x06, "Land Mobile Numbering (ITU-T Rec. E.212)" },
|
|
|
|
{ 0x07, "spare" },
|
|
|
|
{ 0x08, "National Numbering" },
|
|
|
|
{ 0x09, "Private Numbering" },
|
|
|
|
{ 0x0a, "spare" },
|
|
|
|
{ 0x0b, "spare" },
|
|
|
|
{ 0x0c, "spare" },
|
|
|
|
{ 0x0d, "spare" },
|
|
|
|
{ 0x0e, "spare" },
|
|
|
|
{ 0x0f, "Reserved for extension" },
|
|
|
|
{ 0, NULL }
|
2005-01-26 20:07:35 +00:00
|
|
|
};
|
2011-01-12 07:36:55 +00:00
|
|
|
static value_string_ext gsm_map_number_plan_values_ext = VALUE_STRING_EXT_INIT(gsm_map_number_plan_values);
|
2005-01-26 20:07:35 +00:00
|
|
|
|
|
|
|
static const true_false_string gsm_map_Ss_Status_q_bit_values = {
|
|
|
|
"Quiescent",
|
|
|
|
"Operative"
|
|
|
|
};
|
|
|
|
static const true_false_string gsm_map_Ss_Status_p_values = {
|
|
|
|
"Provisioned",
|
|
|
|
"Not Provisioned"
|
|
|
|
};
|
|
|
|
static const true_false_string gsm_map_Ss_Status_r_values = {
|
|
|
|
"Registered",
|
|
|
|
"Not Registered"
|
|
|
|
};
|
|
|
|
static const true_false_string gsm_map_Ss_Status_a_values = {
|
|
|
|
"Active",
|
|
|
|
"not Active"
|
|
|
|
};
|
|
|
|
|
2007-04-23 21:26:27 +00:00
|
|
|
/*
|
|
|
|
* Translate the MAP operation code value to a text string
|
|
|
|
* Take into account the MAP version for ForwardSM
|
|
|
|
*/
|
2014-03-04 11:32:50 +00:00
|
|
|
const gchar* gsm_map_opr_code(guint32 val, proto_item *item) {
|
2009-10-09 21:03:07 +00:00
|
|
|
switch (val) {
|
2007-04-23 21:26:27 +00:00
|
|
|
case 44: /*mt-forwardSM*/
|
2014-03-14 16:39:52 +00:00
|
|
|
/* FALLTHRU */
|
2007-04-23 21:26:27 +00:00
|
|
|
case 46: /*mo-forwardSM*/
|
2014-03-14 16:39:52 +00:00
|
|
|
/* FALLTHRU */
|
2007-06-20 21:54:40 +00:00
|
|
|
if (application_context_version < 3) {
|
2014-03-04 11:32:50 +00:00
|
|
|
proto_item_set_text(item, "%s (%d)", val_to_str_const(val, gsm_map_V1V2_opr_code_strings, "Unknown GSM-MAP opcode"), val);
|
2011-09-29 15:23:23 +00:00
|
|
|
return val_to_str_const(val, gsm_map_V1V2_opr_code_strings, "Unknown GSM-MAP opcode");
|
2007-04-23 21:26:27 +00:00
|
|
|
}
|
|
|
|
/* Else use the default map operation translation */
|
|
|
|
default:
|
2011-09-29 15:23:23 +00:00
|
|
|
return val_to_str_ext_const(val, &gsm_old_GSMMAPOperationLocalvalue_vals_ext, "Unknown GSM-MAP opcode");
|
2007-04-23 21:26:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-20 19:37:06 +00:00
|
|
|
/* Prototype for a decoding function */
|
2007-02-20 20:21:49 +00:00
|
|
|
typedef int (* dissect_function_t)( gboolean,
|
2014-03-14 16:39:52 +00:00
|
|
|
tvbuff_t *,
|
|
|
|
int ,
|
|
|
|
asn1_ctx_t *,
|
|
|
|
proto_tree *,
|
|
|
|
int);
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2007-02-20 19:37:06 +00:00
|
|
|
/*
|
|
|
|
* Dissect Multiple Choice Message
|
|
|
|
* This function is used to decode a message, when several encoding may be used.
|
|
|
|
* For exemple, in the last MAP version, the Cancel Location is defined like this:
|
|
|
|
* CancelLocationArg ::= [3] IMPLICIT SEQUENCE
|
|
|
|
* But in the previous MAP version, it was a CHOICE between a SEQUENCE and an IMSI
|
|
|
|
* As ASN1 encoders (or software) still uses the old encoding, this function allows
|
|
|
|
* the decoding of both versions.
|
2009-10-09 21:03:07 +00:00
|
|
|
* Moreover, some optimizations (or bad practice ?) in ASN1 encoder, removes the
|
2007-02-20 19:37:06 +00:00
|
|
|
* SEQUENCE tag, when only one parameter is present in the SEQUENCE.
|
|
|
|
* This explain why the function expects 3 parameters:
|
|
|
|
* - a [3] SEQUENCE corresponding the recent ASN1 MAP encoding
|
|
|
|
* - a SEQUENCE for old style
|
|
|
|
* - and a single parameter, for old version or optimizations
|
|
|
|
*
|
2009-10-09 21:03:07 +00:00
|
|
|
* The analyze of the first ASN1 tag, indicate what kind of decoding should be used,
|
2007-02-20 19:37:06 +00:00
|
|
|
* if the decoding function is provided (so not a NULL function)
|
|
|
|
*/
|
|
|
|
static int dissect_mc_message(tvbuff_t *tvb,
|
2014-03-14 16:39:52 +00:00
|
|
|
int offset,
|
|
|
|
asn1_ctx_t *actx,
|
|
|
|
proto_tree *tree,
|
|
|
|
gboolean implicit_param _U_, dissect_function_t parameter, int hf_index_param _U_,
|
|
|
|
gboolean implicit_seq _U_, dissect_function_t sequence, int hf_index_seq _U_,
|
|
|
|
gboolean implicit_seq3 _U_, dissect_function_t sequence3, int hf_index_seq3 _U_ )
|
2007-02-20 19:37:06 +00:00
|
|
|
{
|
|
|
|
guint8 octet;
|
2006-02-18 23:29:51 +00:00
|
|
|
gint8 bug_class;
|
|
|
|
gboolean bug_pc, bug_ind_field;
|
|
|
|
gint32 bug_tag;
|
2007-02-20 19:37:06 +00:00
|
|
|
guint32 bug_len;
|
|
|
|
|
|
|
|
octet = tvb_get_guint8(tvb,0);
|
|
|
|
if ( (octet & 0xf) == 3) {
|
|
|
|
/* XXX asn2wrs can not yet handle tagged assignment yes so this
|
|
|
|
* XXX is some conformance file magic to work around that bug
|
|
|
|
*/
|
|
|
|
offset = get_ber_identifier(tvb, offset, &bug_class, &bug_pc, &bug_tag);
|
2007-08-24 07:12:04 +00:00
|
|
|
offset = get_ber_length(tvb, offset, &bug_len, &bug_ind_field);
|
2007-02-20 19:37:06 +00:00
|
|
|
if (sequence3 != NULL) {
|
2007-05-13 20:58:29 +00:00
|
|
|
offset= (sequence3) (implicit_seq3, tvb, offset, actx, tree, hf_index_seq3);
|
2007-02-20 19:37:06 +00:00
|
|
|
} else {
|
2013-07-03 02:59:31 +00:00
|
|
|
proto_tree_add_expert(tree, actx->pinfo, &ei_gsm_map_unknown_sequence3, tvb, offset, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
}
|
|
|
|
} else if (octet == 0x30) {
|
|
|
|
if (sequence != NULL) {
|
2007-12-05 20:16:02 +00:00
|
|
|
offset= (sequence) (implicit_seq, tvb, 0, actx, tree, hf_index_seq);
|
2007-02-20 19:37:06 +00:00
|
|
|
} else {
|
2013-07-03 02:59:31 +00:00
|
|
|
proto_tree_add_expert(tree, actx->pinfo, &ei_gsm_map_unknown_sequence, tvb, offset, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (parameter != NULL) {
|
2007-05-13 20:58:29 +00:00
|
|
|
offset= (parameter) (implicit_param, tvb, offset, actx, tree, hf_index_param);
|
2007-02-20 19:37:06 +00:00
|
|
|
} else {
|
2013-07-03 02:59:31 +00:00
|
|
|
proto_tree_add_expert(tree, actx->pinfo, &ei_gsm_map_unknown_parameter, tvb, offset, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2007-05-13 20:58:29 +00:00
|
|
|
static int dissect_invokeData(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx) {
|
2009-10-09 21:03:07 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
switch(opcode){
|
2009-10-09 21:03:07 +00:00
|
|
|
case 2: /*updateLocation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_UpdateLocationArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 3: /*cancelLocation*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_Identity, hf_gsm_map_ms_identity,
|
|
|
|
FALSE, dissect_gsm_map_Identity, hf_gsm_map_ms_identity,
|
|
|
|
TRUE , dissect_gsm_map_ms_CancelLocationArg, -1);/*undefined*/
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 4: /*provideRoamingNumber*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_ProvideRoamingNumberArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 5: /*noteSubscriberDataModified*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_NoteSubscriberDataModifiedArg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 6: /*resumeCallHandling*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_ResumeCallHandlingArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 7: /*insertSubscriberData*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_InsertSubscriberDataArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 8: /*deleteSubscriberData*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_DeleteSubscriberDataArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* TODO find out why this isn't in the ASN1 file */
|
|
|
|
/* reserved sendParameters (9) */
|
2004-11-02 01:19:23 +00:00
|
|
|
case 10: /*registerSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_RegisterSS_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 11: /*eraseSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_ForBS_Code(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 12: /*activateSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_ForBS_Code(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 13: /*deactivateSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_ForBS_Code(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 14: /*interrogateSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_ForBS_Code(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-25 17:25:44 +00:00
|
|
|
case 15: /*authenticationFailureReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AuthenticationFailureReportArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 16: /*SS-protocol notifySS*/
|
|
|
|
offset=dissect_gsm_ss_NotifySS_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 17: /*registerPassword*/
|
2007-05-13 20:58:29 +00:00
|
|
|
offset=dissect_gsm_map_SS_Code(FALSE, tvb, offset, actx, tree, hf_gsm_map_ss_Code);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 18: /*getPassword*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_GetPasswordArg(FALSE, tvb, offset, actx, tree, hf_gsm_map_getPassword);
|
|
|
|
break;
|
|
|
|
case 19: /* SS-Protocol processUnstructuredSS-Data (19) */
|
2008-01-11 07:29:27 +00:00
|
|
|
offset=dissect_gsm_ss_SS_UserData(FALSE, tvb, offset, actx, tree, hf_gsm_map_ss_SS_UserData);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-25 17:25:44 +00:00
|
|
|
case 20: /*releaseResources*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_ReleaseResourcesArg(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 21: /*mt-ForwardSM-VGCS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_MT_ForwardSM_VGCS_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 22: /*sendRoutingInfo*/
|
2014-03-14 16:39:52 +00:00
|
|
|
if (application_context_version == 3){
|
|
|
|
offset=dissect_gsm_map_ch_SendRoutingInfoArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
}else{
|
|
|
|
offset=dissect_gsm_old_SendRoutingInfoArgV2(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 23: /*updateGprsLocation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_UpdateGprsLocationArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 24: /*sendRoutingInfoForGprs*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_SendRoutingInfoForGprsArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 25: /*failureReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_FailureReportArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 26: /*noteMsPresentForGprs*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_NoteMsPresentForGprsArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* undefined 27 */
|
|
|
|
/* reserved performHandover (28) */
|
2004-11-02 01:19:23 +00:00
|
|
|
case 29: /*sendEndSignal*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_old_Bss_APDU, -1,
|
|
|
|
TRUE , dissect_gsm_map_ms_SendEndSignal_Arg, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* reserved performSubsequentHandover (30) */
|
|
|
|
case 31: /*provideSIWFSNumber*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_ProvideSIWFSNumberArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 32: /*sIWFSSignallingModify*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_SIWFSSignallingModifyArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 33: /*processAccessSignalling*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_old_Bss_APDU, -1,
|
|
|
|
TRUE , dissect_gsm_map_ms_ProcessAccessSignalling_Arg, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 34: /*forwardAccessSignalling*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_old_Bss_APDU, -1,
|
|
|
|
TRUE , dissect_gsm_map_ms_ForwardAccessSignalling_Arg, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* reserved noteInternalHandover (35) */
|
2013-12-08 22:02:12 +00:00
|
|
|
case 36: /*cancelVcsgLocation*/
|
|
|
|
offset=dissect_gsm_map_ms_CancelVcsgLocationArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 37: /*reset*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_ResetArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 38: /*forwardCheckSS-Indication*/
|
|
|
|
return offset;
|
|
|
|
break;
|
|
|
|
case 39: /*prepareGroupCall*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_gr_PrepareGroupCallArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 40: /*sendGroupCallEndSignal*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset = dissect_gsm_map_gr_SendGroupCallEndSignalArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 41: /*processGroupCallSignalling*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset = dissect_gsm_map_gr_ProcessGroupCallSignallingArg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
|
|
|
case 42: /*forwardGroupCallSignalling*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_gr_ForwardGroupCallSignallingArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 43: /*checkIMEI*/
|
2012-08-21 09:32:04 +00:00
|
|
|
if (pref_ericsson_proprietary_ext) {
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
|
|
|
FALSE, dissect_gsm_map_IMEI, hf_gsm_map_ms_imei,
|
2012-08-21 10:40:04 +00:00
|
|
|
FALSE, dissect_gsm_map_ericsson_EnhancedCheckIMEI_Arg, -1,
|
2012-08-21 09:32:04 +00:00
|
|
|
TRUE , NULL, -1); /* no [3] SEQUENCE */
|
|
|
|
} else {
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
|
|
|
FALSE, dissect_gsm_map_IMEI, hf_gsm_map_ms_imei,
|
|
|
|
FALSE, dissect_gsm_map_ms_CheckIMEI_Arg, -1,
|
|
|
|
TRUE , NULL, -1); /* no [3] SEQUENCE */
|
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-04-23 21:26:27 +00:00
|
|
|
case 44: /*mt-forwardSM(v3) or ForwardSM(v1/v2)*/
|
|
|
|
if (application_context_version == 3)
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_MT_ForwardSM_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2007-04-23 21:26:27 +00:00
|
|
|
else {
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_ForwardSM_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2007-04-23 21:26:27 +00:00
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 45: /*sendRoutingInfoForSM*/
|
2014-03-13 16:01:23 +00:00
|
|
|
if (application_context_version == 1) {
|
|
|
|
offset=dissect_gsm_old_RoutingInfoForSM_ArgV1(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
} else {
|
|
|
|
offset=dissect_gsm_map_sm_RoutingInfoForSM_Arg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-04-23 21:26:27 +00:00
|
|
|
case 46: /*mo-forwardSM(v3) or ForwardSM(v1/v2)*/
|
|
|
|
if (application_context_version == 3)
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_MO_ForwardSM_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2007-04-23 21:26:27 +00:00
|
|
|
else {
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_ForwardSM_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2007-04-23 21:26:27 +00:00
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 47: /*reportSM-DeliveryStatus*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_ReportSM_DeliveryStatusArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* reserved noteSubscriberPresent (48) */
|
2009-10-09 21:03:07 +00:00
|
|
|
/* reserved alertServiceCentreWithoutResult (49)
|
2014-03-14 16:39:52 +00:00
|
|
|
* ETS 300 599: December 2000 (GSM 09.02 version 4.19.1)
|
|
|
|
* -- alertServiceCentreWithoutResult must not be used in
|
|
|
|
* -- version greater 1
|
|
|
|
*/
|
2008-02-16 17:04:59 +00:00
|
|
|
case 49:
|
2014-03-14 16:39:52 +00:00
|
|
|
offset = dissect_gsm_map_sm_AlertServiceCentreArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 50: /*activateTraceMode*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_om_ActivateTraceModeArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 51: /*deactivateTraceMode*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_om_DeactivateTraceModeArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* reserved traceSubscriberActivity (52) */
|
2014-02-26 19:29:17 +00:00
|
|
|
|
2013-12-08 22:02:12 +00:00
|
|
|
case 53: /* UpdateVcsgLocation 53 */
|
|
|
|
offset=dissect_gsm_map_ms_UpdateVcsgLocationArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2008-04-17 07:47:02 +00:00
|
|
|
case 54: /*beginSubscriberActivity*/
|
2010-01-01 22:29:28 +00:00
|
|
|
offset=dissect_gsm_old_BeginSubscriberActivityArg(FALSE, tvb, offset, actx, tree, -1);
|
2008-04-17 07:47:02 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 55: /*sendIdentification*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_TMSI, hf_gsm_map_tmsi,
|
|
|
|
FALSE, dissect_gsm_map_ms_SendIdentificationArg, -1,
|
|
|
|
TRUE, NULL, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2009-10-09 21:03:07 +00:00
|
|
|
case 56: /*sendAuthenticationInfo*/
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_IMSI, hf_gsm_map_imsi,
|
|
|
|
FALSE, dissect_gsm_map_ms_SendAuthenticationInfoArg, -1,
|
|
|
|
TRUE, NULL, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 57: /*restoreData*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_RestoreDataArg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 58: /*sendIMSI*/
|
2007-05-13 20:58:29 +00:00
|
|
|
offset = dissect_gsm_map_ISDN_AddressString(FALSE, tvb, offset, actx, tree, hf_gsm_map_msisdn);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 59: /*processUnstructuredSS-Request*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_USSD_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 60: /*unstructuredSS-Request*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_USSD_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 61: /*unstructuredSS-Notify*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_USSD_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-02-23 23:13:57 +00:00
|
|
|
case 62: /*AnyTimeSubscriptionInterrogation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AnyTimeSubscriptionInterrogationArg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 63: /*informServiceCentre*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_InformServiceCentreArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 64: /*alertServiceCentre*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_AlertServiceCentreArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-02-23 23:13:57 +00:00
|
|
|
case 65: /*AnyTimeModification*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AnyTimeModificationArg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 66: /*readyForSM*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_ReadyForSM_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 67: /*purgeMS*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_IMSI, hf_gsm_map_imsi,
|
|
|
|
FALSE, dissect_gsm_old_PurgeMSArgV2, -1, /*undefined*/
|
|
|
|
TRUE , dissect_gsm_map_ms_PurgeMS_Arg, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 68: /*prepareHandover*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_old_PrepareHO_ArgOld, -1,
|
|
|
|
TRUE, dissect_gsm_map_ms_PrepareHO_Arg, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 69: /*prepareSubsequentHandover*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, NULL, -1,
|
|
|
|
TRUE, dissect_gsm_map_ms_PrepareSubsequentHO_Arg, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 70: /*provideSubscriberInfo*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_ProvideSubscriberInfoArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 71: /*anyTimeInterrogation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AnyTimeInterrogationArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 72: /*ss-InvocationNotificatio*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_InvocationNotificationArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 73: /*setReportingState*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_SetReportingStateArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 74: /*statusReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_StatusReportArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 75: /*remoteUserFree*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_RemoteUserFreeArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 76: /*registerCC-Entry*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_RegisterCC_EntryArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 77: /*eraseCC-Entry*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_EraseCC_EntryArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-26 11:01:04 +00:00
|
|
|
case 78: /*secureTransportClass1*/
|
|
|
|
case 79: /*secureTransportClass1*/
|
|
|
|
case 80: /*secureTransportClass1*/
|
|
|
|
case 81: /*secureTransportClass1*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_SecureTransportArg(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-26 11:01:04 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
/* undefined 82 */
|
2004-11-02 01:19:23 +00:00
|
|
|
case 83: /*provideSubscriberLocation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_lcs_ProvideSubscriberLocation_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 84: /*sendGroupCallInfo*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_gr_SendGroupCallInfoArg(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 85: /*sendRoutingInfoForLCS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_lcs_RoutingInfoForLCS_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 86: /*subscriberLocationReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_lcs_SubscriberLocationReport_Arg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-25 17:25:44 +00:00
|
|
|
case 87: /*ist-Alert*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_IST_AlertArg(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
|
|
|
case 88: /*ist-Command*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_IST_CommandArg(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
|
|
|
case 89: /*noteMM-Event*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_NoteMM_EventArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 109: /*SS-protocol lcs-PeriodicLocationCancellation*/
|
|
|
|
offset=dissect_gsm_ss_LCS_PeriodicLocationCancellationArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 110: /*SS-protocol lcs-LocationUpdate*/
|
|
|
|
offset=dissect_gsm_ss_LCS_LocationUpdateArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 111: /*SS-protocol lcs-PeriodicLocationRequest*/
|
|
|
|
offset=dissect_gsm_ss_LCS_PeriodicLocationRequestArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 112: /*SS-protocol lcs-AreaEventCancellation*/
|
|
|
|
offset=dissect_gsm_ss_LCS_AreaEventCancellationArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 113: /*SS-protocol lcs-AreaEventReport*/
|
|
|
|
offset=dissect_gsm_ss_LCS_AreaEventReportArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 114: /*SS-protocol lcs-AreaEventRequest*/
|
|
|
|
offset=dissect_gsm_ss_LCS_AreaEventRequestArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 115: /*SS-protocol lcs-MOLR*/
|
|
|
|
offset=dissect_gsm_ss_LCS_MOLRArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 116: /*SS-protocol lcs-LocationNotification*/
|
|
|
|
offset=dissect_gsm_ss_LocationNotificationArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 117: /*SS-protocol callDeflection*/
|
|
|
|
offset=dissect_gsm_ss_CallDeflectionArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 118: /*SS-protocol userUserService*/
|
|
|
|
offset=dissect_gsm_ss_UserUserServiceArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 119: /*SS-protocol accessRegisterCCEntry*/
|
|
|
|
offset=dissect_gsm_ss_AccessRegisterCCEntryArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 120: /*SS-protocol forwardCUG-Info*/
|
2014-03-14 16:39:52 +00:00
|
|
|
application_context_version = 3;
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_ss_ForwardCUG_InfoArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 121: /*SS-protocol splitMPTY no Argument*/
|
|
|
|
break;
|
|
|
|
case 122: /*SS-protocol retrieveMPTY no Argument*/
|
|
|
|
break;
|
|
|
|
case 123: /*SS-protocol holdMPTY no Argument*/
|
|
|
|
break;
|
|
|
|
case 124: /*SS-protocol buildMPTY no Argument*/
|
|
|
|
break;
|
|
|
|
case 125: /*SS-protocol forwardChargeAdvice*/
|
|
|
|
offset=dissect_gsm_ss_ForwardChargeAdviceArg(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 126: /*SS-protocol explicitCT no Argument*/
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
default:
|
2011-09-29 15:23:23 +00:00
|
|
|
if(!dissector_try_uint(map_prop_arg_opcode_table, (guint8)opcode, tvb, actx->pinfo, tree)){
|
2013-09-09 21:55:57 +00:00
|
|
|
proto_tree_add_expert_format(tree, actx->pinfo, &ei_gsm_map_unknown_invokeData,
|
2013-07-03 23:43:26 +00:00
|
|
|
tvb, offset, -1, "Unknown invokeData %d", opcode);
|
2014-03-14 16:39:52 +00:00
|
|
|
}
|
2014-08-19 12:24:13 +00:00
|
|
|
offset+= tvb_reported_length_remaining(tvb,offset);
|
2014-03-14 16:39:52 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
}
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-13 20:58:29 +00:00
|
|
|
static int dissect_returnResultData(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx) {
|
2006-02-18 23:29:51 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
switch(opcode){
|
2009-10-09 21:03:07 +00:00
|
|
|
case 2: /*updateLocation*/
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_IMSI, hf_gsm_map_imsi,
|
|
|
|
FALSE, dissect_gsm_map_ms_UpdateLocationRes, -1,
|
|
|
|
TRUE , NULL, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 3: /*cancelLocation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_CancelLocationRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 4: /*provideRoamingNumber*/
|
Fix for Bug Packet details have errors when decode MAP V2 PRN_ACK msg
https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=5076
Use:
/*
* Dissect Multiple Choice Message
* This function is used to decode a message, when several encoding may be used.
* For exemple, in the last MAP version, the Cancel Location is defined like this:
* CancelLocationArg ::= [3] IMPLICIT SEQUENCE
* But in the previous MAP version, it was a CHOICE between a SEQUENCE and an IMSI
* As ASN1 encoders (or software) still uses the old encoding, this function allows
* the decoding of both versions.
* Moreover, some optimizations (or bad practice ?) in ASN1 encoder, removes the
* SEQUENCE tag, when only one parameter is present in the SEQUENCE.
* This explain why the function expects 3 parameters:
* - a [3] SEQUENCE corresponding the recent ASN1 MAP encoding
* - a SEQUENCE for old style
* - and a single parameter, for old version or optimizations
*
* The analyze of the first ASN1 tag, indicate what kind of decoding should be used,
* if the decoding function is provided (so not a NULL function)
*/
svn path=/trunk/; revision=34001
2010-08-29 17:34:44 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_ISDN_AddressString, hf_gsm_map_msisdn,
|
|
|
|
FALSE, dissect_gsm_map_ch_ProvideRoamingNumberRes, -1,
|
|
|
|
TRUE , NULL, -1);/*undefined*/
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
|
|
|
case 5: /*noteSubscriberDataModified*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_NoteSubscriberDataModifiedRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 6: /*resumeCallHandling*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_ResumeCallHandlingRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 7: /*insertSubscriberData*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_InsertSubscriberDataRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 8: /*deleteSubscriberData*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_DeleteSubscriberDataRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2014-03-14 16:39:52 +00:00
|
|
|
/* TODO find out why this isn't in the ASN1 file
|
2004-11-02 01:19:23 +00:00
|
|
|
case 9: sendParameters
|
2007-05-13 20:58:29 +00:00
|
|
|
offset=dissect_gsm_map_DeleteSubscriberDataArg(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2014-03-14 16:39:52 +00:00
|
|
|
*/
|
2004-11-02 01:19:23 +00:00
|
|
|
case 10: /*registerSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_Info(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 11: /*eraseSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_Info(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 12: /*activateSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_Info(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 13: /*deactivateSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_Info(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 14: /*interrogateSS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_InterrogateSS_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-25 17:25:44 +00:00
|
|
|
case 15: /*authenticationFailureReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AuthenticationFailureReportRes(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 17: /*registerPassword*/
|
2007-02-16 21:02:19 +00:00
|
|
|
/* change hf_gsm_map_ss_Code to something with password */
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_NewPassword(FALSE, tvb, offset, actx, tree, hf_gsm_map_ss_Code);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 18: /*getPassword*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_CurrentPassword(FALSE, tvb, offset, actx, tree, hf_gsm_map_currentPassword);
|
|
|
|
break;
|
|
|
|
case 19: /* SS-Protocol processUnstructuredSS-Data (19) */
|
2008-01-11 07:29:27 +00:00
|
|
|
offset=dissect_gsm_ss_SS_UserData(FALSE, tvb, offset, actx, tree, hf_gsm_map_ss_SS_UserData);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-25 17:25:44 +00:00
|
|
|
case 20: /*releaseResources*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_ReleaseResourcesRes(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 21: /*mt-ForwardSM-VGCS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_MT_ForwardSM_VGCS_Res(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2009-10-09 21:03:07 +00:00
|
|
|
case 22: /*sendRoutingInfo*/
|
2014-03-14 16:39:52 +00:00
|
|
|
if (application_context_version == 3){
|
|
|
|
/* If the tag is missing use SendRoutingInfoRes_U */
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_map_ch_SendRoutingInfoRes_U, -1,
|
|
|
|
TRUE , dissect_gsm_map_ch_SendRoutingInfoRes, -1);
|
|
|
|
}else{
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
|
|
|
FALSE, dissect_gsm_map_IMSI, hf_gsm_map_imsi,
|
|
|
|
FALSE, dissect_gsm_old_SendRoutingInfoResV2, -1,
|
|
|
|
TRUE , dissect_gsm_map_ch_SendRoutingInfoRes, -1);
|
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 23: /*updateGprsLocation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_UpdateGprsLocationRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 24: /*sendRoutingInfoForGprs*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_SendRoutingInfoForGprsRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 25: /*failureReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_FailureReportRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 26: /*noteMsPresentForGprs*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_NoteMsPresentForGprsRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2004-11-02 01:25:05 +00:00
|
|
|
case 29: /*sendEndSignal*/
|
2014-03-14 16:39:52 +00:00
|
|
|
/* Taken from MAP-MobileServiceOperations{ 0 identified-organization (4) etsi (0) mobileDomain
|
|
|
|
* (0) gsm-Network (1) modules (3) map-MobileServiceOperations (5) version9 (9) }
|
|
|
|
*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_SendEndSignal_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-20 19:37:06 +00:00
|
|
|
case 31: /*provideSIWFSNumber*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_ProvideSIWFSNumberRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-20 19:37:06 +00:00
|
|
|
case 32: /*provideSIWFSSignallingModify*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_SIWFSSignallingModifyRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2013-12-08 22:02:12 +00:00
|
|
|
case 36: /*cancelVcsgLocation*/
|
|
|
|
offset=dissect_gsm_map_ms_CancelVcsgLocationRes(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 39: /*prepareGroupCall*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_gr_PrepareGroupCallRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 40: /*sendGroupCallEndSignal*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_gr_SendGroupCallEndSignalRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2009-10-09 21:03:07 +00:00
|
|
|
case 43: /*checkIMEI*/
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_ms_EquipmentStatus, hf_gsm_map_ms_equipmentStatus,
|
|
|
|
FALSE, dissect_gsm_map_ms_CheckIMEI_Res, -1,
|
|
|
|
TRUE, NULL, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-05-10 20:06:04 +00:00
|
|
|
case 44: /*mt-forwardSM*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_MT_ForwardSM_Res(FALSE, tvb, offset, actx, tree, -1);
|
2005-05-10 20:06:04 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 45: /*sendRoutingInfoForSM*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_RoutingInfoForSM_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 46: /*mo-forwardSM*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_MO_ForwardSM_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 47: /*reportSM-DeliveryStatus*/
|
2011-02-07 17:44:34 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_ISDN_AddressString, hf_gsm_map_sm_storedMSISDN,
|
|
|
|
FALSE, dissect_gsm_map_sm_ReportSM_DeliveryStatusRes, -1,
|
|
|
|
FALSE, NULL, -1);/*undefined*/
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2007-06-10 19:04:12 +00:00
|
|
|
case 48: /*noteSubscriberPresent*/
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 50: /*activateTraceMode*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_om_ActivateTraceModeRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 51: /*deactivateTraceMode*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_om_DeactivateTraceModeRes(FALSE, tvb, offset, actx, tree, -1);
|
2013-12-08 22:02:12 +00:00
|
|
|
break;
|
|
|
|
case 53: /* UpdateVcsgLocation 53 */
|
|
|
|
offset=dissect_gsm_map_ms_UpdateVcsgLocationRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-20 19:37:06 +00:00
|
|
|
case 55: /*sendIdentification */
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, dissect_gsm_map_IMSI, hf_gsm_map_imsi,
|
|
|
|
FALSE, dissect_gsm_old_SendIdentificationResV2, -1,/*undefined*/
|
|
|
|
TRUE, dissect_gsm_map_ms_SendIdentificationRes, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2009-10-09 21:03:07 +00:00
|
|
|
case 56: /*sendAuthenticationInfo*/
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_old_SendAuthenticationInfoResOld, -1,
|
|
|
|
TRUE , dissect_gsm_map_ms_SendAuthenticationInfoRes, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 57: /*restoreData*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_RestoreDataRes(FALSE, tvb, offset, actx, tree, -1);
|
2005-04-21 21:37:23 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 58: /*sendIMSI*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_IMSI(FALSE, tvb, offset, actx, tree, hf_gsm_map_ms_imsi);
|
2005-04-21 21:37:23 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 59: /*unstructuredSS-Request*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_USSD_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 60: /*unstructuredSS-Request*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_USSD_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 61: /*unstructuredSS-Notify*/
|
|
|
|
/* TRUE ? */
|
2014-08-08 13:19:29 +00:00
|
|
|
proto_tree_add_expert_format(tree, actx->pinfo, &ei_gsm_map_unknown_invokeData, tvb, offset, -1, "Unknown returnResultData blob");
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-02-23 23:13:57 +00:00
|
|
|
case 62: /*AnyTimeSubscriptionInterrogation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AnyTimeSubscriptionInterrogationRes(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 64: /*alertServiceCentre*/
|
|
|
|
/* TRUE */
|
|
|
|
break;
|
2005-02-23 23:13:57 +00:00
|
|
|
case 65: /*AnyTimeModification*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AnyTimeModificationRes(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 66: /*readyForSM*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_sm_ReadyForSM_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 67: /*purgeMS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_PurgeMS_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2009-10-09 21:03:07 +00:00
|
|
|
case 68: /*prepareHandover*/
|
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, dissect_gsm_old_PrepareHO_ResOld, -1,
|
|
|
|
TRUE , dissect_gsm_map_ms_PrepareHO_Res, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 69: /*prepareSubsequentHandover*/
|
2009-10-09 21:03:07 +00:00
|
|
|
offset=dissect_mc_message(tvb, offset, actx, tree,
|
2014-03-14 16:39:52 +00:00
|
|
|
FALSE, NULL, -1,
|
|
|
|
FALSE, NULL, -1,
|
|
|
|
TRUE , dissect_gsm_map_ms_PrepareSubsequentHO_Res, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 70: /*provideSubscriberInfo*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_ProvideSubscriberInfoRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 71: /*anyTimeInterrogation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_AnyTimeInterrogationRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 72: /*ss-InvocationNotificatio*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_InvocationNotificationRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 73: /*setReportingState*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_SetReportingStateRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 74: /*statusReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_StatusReportRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 75: /*remoteUserFree*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_RemoteUserFreeRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 76: /*registerCC-Entry*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_RegisterCC_EntryRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 77: /*eraseCC-Entry*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ss_EraseCC_EntryRes(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-26 11:01:04 +00:00
|
|
|
case 78: /*secureTransportClass1*/
|
2005-06-28 21:14:09 +00:00
|
|
|
case 79: /*secureTransportClass2*/
|
|
|
|
case 80: /*secureTransportClass3*/
|
|
|
|
case 81: /*secureTransportClass4*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_old_SecureTransportRes(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-26 11:01:04 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 83: /*provideSubscriberLocation*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_lcs_ProvideSubscriberLocation_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 84: /*sendGroupCallInfo*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_gr_SendGroupCallInfoRes(FALSE, tvb, offset, actx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
case 85: /*sendRoutingInfoForLCS*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_lcs_RoutingInfoForLCS_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
|
|
|
case 86: /*subscriberLocationReport*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_lcs_SubscriberLocationReport_Res(FALSE, tvb, offset, actx, tree, -1);
|
2004-11-02 01:19:23 +00:00
|
|
|
break;
|
2005-06-25 17:25:44 +00:00
|
|
|
case 87: /*ist-Alert*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_IST_AlertRes(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
|
|
|
case 88: /*ist-Command*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ch_IST_CommandRes(FALSE, tvb, offset, actx, tree, -1);
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
|
|
|
case 89: /*noteMM-Event*/
|
2007-06-10 19:04:12 +00:00
|
|
|
offset=dissect_gsm_map_ms_NoteMM_EventRes(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 109: /*SS-protocol lcs-PeriodicLocationCancellation*/
|
2014-03-14 16:39:52 +00:00
|
|
|
/* No parameter */
|
2007-06-10 19:04:12 +00:00
|
|
|
break;
|
|
|
|
case 110: /*SS-protocol lcs-LocationUpdate*/
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_ss_LCS_LocationUpdateRes(FALSE, tvb, offset, actx, tree, -1);
|
2007-06-10 19:04:12 +00:00
|
|
|
break;
|
|
|
|
case 111: /*SS-protocol lcs-PeriodicLocationRequest*/
|
|
|
|
offset=dissect_gsm_ss_LCS_PeriodicLocationRequestRes(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 112: /*SS-protocol lcs-AreaEventCancellation*/
|
|
|
|
break;
|
|
|
|
case 113: /*SS-protocol lcs-AreaEventReport*/
|
|
|
|
break;
|
|
|
|
case 114: /*SS-protocol lcs-AreaEventRequest No RESULT data*/
|
|
|
|
break;
|
|
|
|
case 115: /*SS-protocol lcs-MOLR*/
|
|
|
|
offset=dissect_gsm_ss_LCS_MOLRRes(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 116: /*SS-protocol lcs-LocationNotification*/
|
|
|
|
offset=dissect_gsm_ss_LocationNotificationRes(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 117: /*SS-protocol callDeflection no RESULT*/
|
|
|
|
break;
|
|
|
|
case 118: /*SS-protocol userUserService no RESULT*/
|
2005-06-25 17:25:44 +00:00
|
|
|
break;
|
2007-06-10 19:04:12 +00:00
|
|
|
case 119: /*SS-protocol accessRegisterCCEntry*/
|
|
|
|
offset=dissect_gsm_map_ss_RegisterCC_EntryRes(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
|
|
|
case 120: /*SS-protocol forwardCUG-Info*/
|
2014-03-14 16:39:52 +00:00
|
|
|
/* No RETURN RESULT*/
|
2007-06-10 19:04:12 +00:00
|
|
|
break;
|
|
|
|
case 121: /*SS-protocol splitMPTY no RESULT*/
|
|
|
|
break;
|
|
|
|
case 122: /*SS-protocol retrieveMPTY no RESULT*/
|
|
|
|
break;
|
|
|
|
case 123: /*SS-protocol holdMPTY no RESULT*/
|
|
|
|
break;
|
|
|
|
case 124: /*SS-protocol buildMPTY no RESULT*/
|
|
|
|
break;
|
|
|
|
case 125: /*SS-protocol forwardChargeAdvice no RESULT*/
|
|
|
|
break;
|
|
|
|
case 126: /*SS-protocol explicitCT no RESULT*/
|
|
|
|
break;
|
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
default:
|
2011-09-29 15:23:23 +00:00
|
|
|
if(!dissector_try_uint(map_prop_res_opcode_table, (guint8)opcode, tvb, actx->pinfo, tree)){
|
2013-09-09 21:55:57 +00:00
|
|
|
proto_tree_add_expert_format(tree, actx->pinfo, &ei_gsm_map_unknown_invokeData,
|
2013-07-03 23:43:26 +00:00
|
|
|
tvb, offset, -1, "Unknown returnResultData %d", opcode);
|
2011-09-29 15:23:23 +00:00
|
|
|
}
|
2014-08-19 12:24:13 +00:00
|
|
|
offset+= tvb_reported_length_remaining(tvb,offset);
|
2011-09-29 15:23:23 +00:00
|
|
|
break;
|
2004-11-02 01:19:23 +00:00
|
|
|
}
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2005-02-11 22:43:24 +00:00
|
|
|
|
2005-02-09 21:54:57 +00:00
|
|
|
|
2007-05-13 20:58:29 +00:00
|
|
|
static int dissect_returnErrorData(proto_tree *tree, tvbuff_t *tvb, int offset, asn1_ctx_t *actx) {
|
2009-10-09 21:03:07 +00:00
|
|
|
|
2005-12-19 19:34:52 +00:00
|
|
|
switch(errorCode){
|
|
|
|
case 1: /* UnknownSubscriberParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_UnknownSubscriberParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 4: /* SecureTransportErrorParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_old_SecureTransportErrorParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 5: /* UnidentifiedSubParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_UnidentifiedSubParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 6: /* AbsentSubscriberSM-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_AbsentSubscriberSM_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 8: /* RoamingNotAllowedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_RoamingNotAllowedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 9: /* IllegalSubscriberParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_IllegalSubscriberParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 10: /* BearerServNotProvParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_BearerServNotProvParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 11: /* TeleservNotProvParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_TeleservNotProvParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 12: /* IllegalEquipmentParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_IllegalEquipmentParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 13: /* CallBarredParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_CallBarredParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 14: /* ForwardingViolationParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ForwardingViolationParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 15: /* CUG-RejectParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_CUG_RejectParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 16: /* IllegalSS-OperationParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_IllegalSS_OperationParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 17: /* SS-ErrorStatus */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_ss_SS_Status(FALSE, tvb, offset, actx, tree, hf_gsm_map_ss_ss_Status);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 18: /* SS-NotAvailableParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_SS_NotAvailableParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 19: /* SS-SubscriptionViolationParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_SS_SubscriptionViolationParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 20: /* SS-IncompatibilityCause */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_SS_IncompatibilityCause(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 21: /* FacilityNotSupParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_FacilityNotSupParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2007-02-16 21:02:19 +00:00
|
|
|
case 22: /* OngoingGroupCallParam */
|
2011-03-27 14:02:42 +00:00
|
|
|
offset=dissect_gsm_map_er_OngoingGroupCallParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 27: /* AbsentSubscriberParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_AbsentSubscriberParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 28: /* IncompatibleTerminalParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_IncompatibleTerminalParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 29: /* ShortTermDenialParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ShortTermDenialParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 30: /* LongTermDenialParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_LongTermDenialParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 31: /* SubBusyForMT-SMS-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_SubBusyForMT_SMS_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 32: /* SM-DeliveryFailureCause */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_SM_DeliveryFailureCause(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 33: /* MessageWaitListFullParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_MessageWaitListFullParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 34: /* SystemFailureParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_SystemFailureParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 35: /* DataMissingParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_DataMissingParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 36: /* UnexpectedDataParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_UnexpectedDataParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 37: /* PW-RegistrationFailureCause */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_PW_RegistrationFailureCause(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 39: /* NoRoamingNbParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_NoRoamingNbParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 40: /* TracingBufferFullParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_TracingBufferFullParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 42: /* TargetCellOutsideGCA-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_TargetCellOutsideGCA_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 44: /* NumberChangedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_NumberChangedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 45: /* BusySubscriberParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_BusySubscriberParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 46: /* NoSubscriberReplyParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_NoSubscriberReplyParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 47: /* ForwardingFailedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ForwardingFailedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 48: /* OR-NotAllowedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_OR_NotAllowedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 49: /* ATI-NotAllowedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ATI_NotAllowedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 50: /* NoGroupCallNbParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_NoGroupCallNbParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 51: /* ResourceLimitationParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ResourceLimitationParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 52: /* UnauthorizedRequestingNetwork-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_UnauthorizedRequestingNetwork_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 53: /* UnauthorizedLCSClient-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_UnauthorizedLCSClient_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 54: /* PositionMethodFailure-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_PositionMethodFailure_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 58: /* UnknownOrUnreachableLCSClient-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_UnknownOrUnreachableLCSClient_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 59: /* MM-EventNotSupported-Param */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_MM_EventNotSupported_Param(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 60: /* ATSI-NotAllowedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ATSI_NotAllowedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 61: /* ATM-NotAllowedParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_ATM_NotAllowedParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
case 62: /* InformationNotAvailableParam */
|
2014-03-14 16:39:52 +00:00
|
|
|
offset=dissect_gsm_map_er_InformationNotAvailableParam(FALSE, tvb, offset, actx, tree, -1);
|
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
default:
|
2011-09-29 15:23:23 +00:00
|
|
|
if(!dissector_try_uint(map_prop_err_opcode_table, (guint8)opcode, tvb, actx->pinfo, tree)){
|
2013-09-09 21:55:57 +00:00
|
|
|
proto_tree_add_expert_format(tree, actx->pinfo, &ei_gsm_map_unknown_invokeData,
|
2013-07-03 23:43:26 +00:00
|
|
|
tvb, offset, -1, "Unknown returnErrorData %d", opcode);
|
2011-09-29 15:23:23 +00:00
|
|
|
}
|
2014-08-19 12:24:13 +00:00
|
|
|
offset+= tvb_reported_length_remaining(tvb,offset);
|
2007-02-20 19:37:06 +00:00
|
|
|
break;
|
2005-12-19 19:34:52 +00:00
|
|
|
}
|
2005-02-09 21:54:57 +00:00
|
|
|
return offset;
|
|
|
|
}
|
2007-02-16 21:02:19 +00:00
|
|
|
|
|
|
|
/* Private extension container for PLMN Data */
|
|
|
|
static void dissect_gsm_mapext_PlmnContainer(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2007-05-13 20:58:29 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
2009-10-09 21:03:07 +00:00
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
2007-02-16 21:02:19 +00:00
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_gsm_old_PlmnContainer_U, NULL, "MAP Ext. Plmn Container");
|
|
|
|
|
2007-06-10 19:04:12 +00:00
|
|
|
dissect_gsm_old_PlmnContainer(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
2007-02-16 21:02:19 +00:00
|
|
|
}
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
static void dissect_NokiaMAP_ext_SriResExtension(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2013-11-26 20:29:17 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_SriResExtension_U, NULL, "Nokia Extension");
|
2013-11-26 20:29:17 +00:00
|
|
|
dissect_NokiaMAP_Extensions_SriResExtension(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
static void dissect_NokiaMAP_ext_CanLocArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_CanLocArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_CanLocArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_ATMargExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_ATMargExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_ATMargExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_DTMargExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_DTMargExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_DTMargExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_NumberPorted(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_NumberPorted(FALSE, tvb, 0, &asn1_ctx, parent_tree, -1);
|
2014-01-03 13:29:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_ATMresExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_ATMresExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_ATMresExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_AbsentSubscriberExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
|
|
|
asn1_ctx_t asn1_ctx;
|
2014-01-04 10:06:04 +00:00
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_AbsentSubscriberExt(FALSE, tvb, 0, &asn1_ctx, parent_tree, -1);
|
2014-01-03 13:29:48 +00:00
|
|
|
}
|
2013-11-26 20:29:17 +00:00
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
static void dissect_NokiaMAP_ext_SriForSMArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_SriForSMArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_SriForSMArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
2014-01-04 10:06:04 +00:00
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_ReportSMDelStatArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_ReportSMDelStatArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_ReportSMDelStatArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_UdlArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_UdlArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_UdlArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_RoamNotAllowedExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_RoamNotAllowedExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_RoamNotAllowedExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_MO_ForwardSM_ArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_MO_ForwardSM_ArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_MO_ForwardSM_ArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_ErrOlcmInfoTableExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_ErrOlcmInfoTableExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_ErrOlcmInfoTableExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_RoutingCategoryExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_RoutingCategoryExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_RoutingCategoryExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_AnyTimeModArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-04 10:06:04 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_AnyTimeModArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-04 10:06:04 +00:00
|
|
|
dissect_NokiaMAP_Extensions_AnyTimeModArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_ExtensionType(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
dissect_NokiaMAP_Extensions_ExtensionType(FALSE, tvb, 0, &asn1_ctx, parent_tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_AccessTypeExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
|
|
|
dissect_NokiaMAP_Extensions_AccessTypeExt(FALSE, tvb, 0, &asn1_ctx, parent_tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_AccessSubscriptionListExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
|
|
|
dissect_NokiaMAP_Extensions_AccessSubscriptionListExt(FALSE, tvb, 0, &asn1_ctx, parent_tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_AllowedServiceData(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
|
|
|
dissect_NokiaMAP_Extensions_AllowedServiceData(FALSE, tvb, 0, &asn1_ctx, parent_tree, -1);
|
|
|
|
}
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
static void dissect_NokiaMAP_ext_SriExtension(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2013-11-26 20:29:17 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_SriExtension_U, NULL, "Nokia Extension");
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
dissect_NokiaMAP_Extensions_SriExtension(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
static void dissect_NokiaMAP_ExtraSignalInfo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_ExtraSignalInfo_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_ExtraSignalInfo(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
static void dissect_NokiaMAP_ext_SS_DataExtension(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2013-11-26 20:29:17 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_SS_DataExtension_U, NULL, "Nokia Extension");
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
dissect_NokiaMAP_Extensions_SS_DataExtension(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_HOExtension(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2013-11-26 20:29:17 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_HO_Ext_U, NULL, "Nokia Extension");
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
dissect_NokiaMAP_Extensions_HO_Ext(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_UlResExtension(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2013-11-26 20:29:17 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_UlResExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
dissect_NokiaMAP_Extensions_UlResExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void dissect_NokiaMAP_ext_IsdArgExtension(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2013-11-26 20:29:17 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_IsdArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2013-11-26 20:29:17 +00:00
|
|
|
dissect_NokiaMAP_Extensions_IsdArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
static void dissect_NokiaMAP_ext_DsdArgExt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree) {
|
2014-06-21 01:35:40 +00:00
|
|
|
proto_tree *tree;
|
2014-01-03 13:29:48 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
/* create display subtree for the protocol */
|
2014-06-21 01:35:40 +00:00
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, 0, -1, ett_NokiaMAP_Extensions_DsdArgExt_U, NULL, "Nokia Extension");
|
|
|
|
|
2014-01-03 13:29:48 +00:00
|
|
|
dissect_NokiaMAP_Extensions_DsdArgExt(FALSE, tvb, 0, &asn1_ctx, tree, -1);
|
|
|
|
}
|
2007-02-16 21:02:19 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
static int
|
2013-10-28 13:36:49 +00:00
|
|
|
dissect_gsm_map_GSMMAPPDU(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset, asn1_ctx_t *actx, proto_tree *tree,
|
|
|
|
int hf_index _U_, struct tcap_private_t * p_private_tcap) {
|
2005-02-03 21:22:09 +00:00
|
|
|
|
2005-08-17 09:43:16 +00:00
|
|
|
char *version_ptr;
|
2005-02-03 21:22:09 +00:00
|
|
|
|
2005-03-28 02:53:49 +00:00
|
|
|
opcode = 0;
|
2012-07-10 11:39:06 +00:00
|
|
|
if (pref_application_context_version == APPLICATON_CONTEXT_FROM_TRACE) {
|
2014-03-14 16:39:52 +00:00
|
|
|
application_context_version = 0;
|
|
|
|
if (p_private_tcap != NULL){
|
|
|
|
if (p_private_tcap->acv==TRUE ){
|
|
|
|
version_ptr = strrchr((const char*)p_private_tcap->oid,'.');
|
|
|
|
if (version_ptr){
|
|
|
|
application_context_version = atoi(version_ptr+1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-07-10 11:39:06 +00:00
|
|
|
}else{
|
2014-03-14 16:39:52 +00:00
|
|
|
application_context_version = pref_application_context_version;
|
2005-03-28 02:53:49 +00:00
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
|
|
|
|
gsmmap_pdu_type = tvb_get_guint8(tvb, offset)&0x0f;
|
|
|
|
/* Get the length and add 2 */
|
|
|
|
gsm_map_pdu_size = tvb_get_guint8(tvb, offset+1)+2;
|
|
|
|
|
2013-10-29 14:09:20 +00:00
|
|
|
col_set_str(actx->pinfo->cinfo, COL_INFO, val_to_str_const(gsmmap_pdu_type, gsm_old_Component_vals, "Unknown GSM-MAP Component"));
|
|
|
|
col_append_str(actx->pinfo->cinfo, COL_INFO, " ");
|
2008-01-11 07:29:27 +00:00
|
|
|
offset = dissect_gsm_old_Component(FALSE, tvb, 0, actx, tree, hf_gsm_map_old_Component_PDU);
|
2005-12-19 19:34:52 +00:00
|
|
|
/*
|
2005-07-21 21:12:09 +00:00
|
|
|
offset = dissect_ber_choice(pinfo, tree, tvb, offset,
|
2005-06-26 05:48:50 +00:00
|
|
|
GSMMAPPDU_choice, hf_index, ett_gsm_map_GSMMAPPDU, NULL);
|
2005-12-19 19:34:52 +00:00
|
|
|
*/
|
2004-11-02 01:19:23 +00:00
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
2013-10-28 13:36:49 +00:00
|
|
|
static int
|
|
|
|
dissect_gsm_map(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* data)
|
2004-11-02 01:19:23 +00:00
|
|
|
{
|
2014-03-14 16:39:52 +00:00
|
|
|
proto_item *item=NULL;
|
|
|
|
proto_tree *tree=NULL;
|
2005-06-26 19:56:52 +00:00
|
|
|
/* Used for gsm_map TAP */
|
2014-03-14 16:39:52 +00:00
|
|
|
static gsm_map_tap_rec_t tap_rec;
|
|
|
|
gint op_idx;
|
2013-10-28 13:36:49 +00:00
|
|
|
struct tcap_private_t * p_private_tcap = (struct tcap_private_t *)data;
|
2014-03-14 16:39:52 +00:00
|
|
|
asn1_ctx_t asn1_ctx;
|
2007-05-13 20:58:29 +00:00
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2009-08-09 07:59:51 +00:00
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "GSM MAP");
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2005-06-26 19:56:52 +00:00
|
|
|
top_tree = parent_tree;
|
2005-12-17 16:55:45 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
/* create display subtree for the protocol */
|
2013-10-28 13:36:49 +00:00
|
|
|
item = proto_tree_add_item(parent_tree, proto_gsm_map, tvb, 0, -1, ENC_NA);
|
|
|
|
tree = proto_item_add_subtree(item, ett_gsm_map);
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2013-10-28 13:36:49 +00:00
|
|
|
dissect_gsm_map_GSMMAPPDU(FALSE, tvb, 0, &asn1_ctx, tree, -1, p_private_tcap);
|
2013-03-29 00:26:23 +00:00
|
|
|
try_val_to_str_idx(opcode, gsm_map_opr_code_strings, &op_idx);
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2013-03-24 21:53:53 +00:00
|
|
|
if (op_idx != -1) {
|
|
|
|
tap_rec.invoke = (gsmmap_pdu_type == 1) ? TRUE : FALSE;
|
|
|
|
tap_rec.opr_code_idx = op_idx;
|
|
|
|
tap_rec.size = gsm_map_pdu_size;
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2013-03-24 21:53:53 +00:00
|
|
|
tap_queue_packet(gsm_map_tap, pinfo, &tap_rec);
|
|
|
|
}
|
2013-10-28 13:36:49 +00:00
|
|
|
|
2014-06-19 19:55:27 +00:00
|
|
|
return tvb_captured_length(tvb);
|
2004-11-02 01:19:23 +00:00
|
|
|
}
|
|
|
|
|
2014-11-22 16:54:54 +00:00
|
|
|
static int
|
|
|
|
dissect_gsm_map_sccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* data)
|
|
|
|
{
|
|
|
|
proto_item *item=NULL;
|
|
|
|
proto_tree *tree=NULL;
|
|
|
|
/* Used for gsm_map TAP */
|
|
|
|
static gsm_map_tap_rec_t tap_rec;
|
|
|
|
gint op_idx;
|
|
|
|
asn1_ctx_t asn1_ctx;
|
|
|
|
|
|
|
|
asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
|
|
|
|
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "GSM MAP");
|
|
|
|
|
|
|
|
top_tree = parent_tree;
|
|
|
|
|
|
|
|
/* create display subtree for the protocol */
|
|
|
|
item = proto_tree_add_item(parent_tree, proto_gsm_map, tvb, 0, -1, ENC_NA);
|
|
|
|
tree = proto_item_add_subtree(item, ett_gsm_map);
|
|
|
|
|
|
|
|
/* Save the sccp_msg_info_t data (if present) because it can't be passed
|
|
|
|
through function calls */
|
|
|
|
p_add_proto_data(pinfo->pool, pinfo, proto_gsm_map, pinfo->curr_layer_num, data);
|
|
|
|
|
|
|
|
dissect_gsm_map_GSMMAPPDU(FALSE, tvb, 0, &asn1_ctx, tree, -1, NULL);
|
|
|
|
try_val_to_str_idx(opcode, gsm_map_opr_code_strings, &op_idx);
|
|
|
|
|
|
|
|
if (op_idx != -1) {
|
|
|
|
tap_rec.invoke = (gsmmap_pdu_type == 1) ? TRUE : FALSE;
|
|
|
|
tap_rec.opr_code_idx = op_idx;
|
|
|
|
tap_rec.size = gsm_map_pdu_size;
|
|
|
|
|
|
|
|
tap_queue_packet(gsm_map_tap, pinfo, &tap_rec);
|
|
|
|
}
|
|
|
|
|
|
|
|
return tvb_captured_length(tvb);
|
|
|
|
}
|
|
|
|
|
2005-08-03 20:51:54 +00:00
|
|
|
const value_string ssCode_vals[] = {
|
2004-11-02 01:19:23 +00:00
|
|
|
{ 0x00, "allSS - all SS" },
|
|
|
|
{ 0x10 ,"allLineIdentificationSS - all line identification SS" },
|
|
|
|
{ 0x11 ,"clip - calling line identification presentation" },
|
|
|
|
{ 0x12 ,"clir - calling line identification restriction" },
|
|
|
|
{ 0x13 ,"colp - connected line identification presentation" },
|
|
|
|
{ 0x14 ,"colr - connected line identification restriction" },
|
|
|
|
{ 0x15 ,"mci - malicious call identification" },
|
2010-12-06 01:34:58 +00:00
|
|
|
{ 0x18 ,"allNameIdentificationSS - all name identification SS" },
|
2004-11-02 01:19:23 +00:00
|
|
|
{ 0x19 ,"cnap - calling name presentation" },
|
|
|
|
{ 0x20 ,"allForwardingSS - all forwarding SS" },
|
|
|
|
{ 0x21 ,"cfu - call forwarding unconditional" },
|
|
|
|
{ 0x28 ,"allCondForwardingSS - all conditional forwarding SS" },
|
|
|
|
{ 0x29 ,"cfb - call forwarding busy" },
|
|
|
|
{ 0x2a ,"cfnry - call forwarding on no reply" },
|
|
|
|
{ 0x2b ,"cfnrc - call forwarding on mobile subscriber not reachable" },
|
|
|
|
{ 0x24 ,"cd - call deflection" },
|
|
|
|
{ 0x30 ,"allCallOfferingSS - all call offering SS includes also all forwarding SS" },
|
|
|
|
{ 0x31 ,"ect - explicit call transfer" },
|
|
|
|
{ 0x32 ,"mah - mobile access hunting" },
|
|
|
|
{ 0x40 ,"allCallCompletionSS - all Call completion SS" },
|
|
|
|
{ 0x41 ,"cw - call waiting" },
|
|
|
|
{ 0x42 ,"hold - call hold" },
|
|
|
|
{ 0x43 ,"ccbs-A - completion of call to busy subscribers, originating side" },
|
|
|
|
{ 0x44 ,"ccbs-B - completion of call to busy subscribers, destination side" },
|
|
|
|
{ 0x45 ,"mc - multicall" },
|
|
|
|
{ 0x50 ,"allMultiPartySS - all multiparty SS" },
|
|
|
|
{ 0x51 ,"multiPTY - multiparty" },
|
|
|
|
{ 0x60 ,"allCommunityOfInterestSS - all community of interest SS" },
|
|
|
|
{ 0x61 ,"cug - closed user group" },
|
|
|
|
{ 0x70 ,"allChargingSS - all charging SS" },
|
|
|
|
{ 0x71 ,"aoci - advice of charge information" },
|
|
|
|
{ 0x72 ,"aocc - advice of charge charging" },
|
|
|
|
{ 0x80 ,"allAdditionalInfoTransferSS - all additional information transfer SS" },
|
|
|
|
{ 0x81 ,"uus1 - UUS1 user-to-user signalling" },
|
|
|
|
{ 0x82 ,"uus2 - UUS2 user-to-user signalling" },
|
|
|
|
{ 0x83 ,"uus3 - UUS3 user-to-user signalling" },
|
|
|
|
{ 0x90 ,"allCallRestrictionSS - all Callrestriction SS" },
|
|
|
|
{ 0x91 ,"barringOfOutgoingCalls" },
|
|
|
|
{ 0x92 ,"baoc - barring of all outgoing calls" },
|
|
|
|
{ 0x93 ,"boic - barring of outgoing international calls" },
|
|
|
|
{ 0x94 ,"boicExHC - barring of outgoing international calls except those directed to the home PLMN" },
|
|
|
|
{ 0x99 ,"barringOfIncomingCalls" },
|
|
|
|
{ 0x9a ,"baic - barring of all incoming calls" },
|
|
|
|
{ 0x9b ,"bicRoam - barring of incoming calls when roaming outside home PLMN Country" },
|
|
|
|
{ 0xf0 ,"allPLMN-specificSS" },
|
|
|
|
{ 0xa0 ,"allCallPrioritySS - all call priority SS" },
|
|
|
|
{ 0xa1 ,"emlpp - enhanced Multilevel Precedence Pre-emption (EMLPP) service" },
|
|
|
|
{ 0xb0 ,"allLCSPrivacyException - all LCS Privacy Exception Classes" },
|
|
|
|
{ 0xb1 ,"universal - allow location by any LCS client" },
|
|
|
|
{ 0xb2 ,"callrelated - allow location by any value added LCS client to which a call is established from the target MS" },
|
|
|
|
{ 0xb3 ,"callunrelated - allow location by designated external value added LCS clients" },
|
|
|
|
{ 0xb4 ,"plmnoperator - allow location by designated PLMN operator LCS clients" },
|
2007-02-16 21:02:19 +00:00
|
|
|
{ 0xb5 ,"serviceType - allow location by LCS clients of a designated LCS service type" },
|
2004-11-02 01:19:23 +00:00
|
|
|
{ 0xc0 ,"allMOLR-SS - all Mobile Originating Location Request Classes" },
|
|
|
|
{ 0xc1 ,"basicSelfLocation - allow an MS to request its own location" },
|
|
|
|
{ 0xc2 ,"autonomousSelfLocation - allow an MS to perform self location without interaction with the PLMN for a predetermined period of time" },
|
|
|
|
{ 0xc3 ,"transferToThirdParty - allow an MS to request transfer of its location to another LCS client" },
|
|
|
|
|
|
|
|
{ 0xf1 ,"plmn-specificSS-1" },
|
|
|
|
{ 0xf2 ,"plmn-specificSS-2" },
|
|
|
|
{ 0xf3 ,"plmn-specificSS-3" },
|
|
|
|
{ 0xf4 ,"plmn-specificSS-4" },
|
|
|
|
{ 0xf5 ,"plmn-specificSS-5" },
|
|
|
|
{ 0xf6 ,"plmn-specificSS-6" },
|
|
|
|
{ 0xf7 ,"plmn-specificSS-7" },
|
|
|
|
{ 0xf8 ,"plmn-specificSS-8" },
|
|
|
|
{ 0xf9 ,"plmn-specificSS-9" },
|
|
|
|
{ 0xfa ,"plmn-specificSS-a" },
|
|
|
|
{ 0xfb ,"plmn-specificSS-b" },
|
|
|
|
{ 0xfc ,"plmn-specificSS-c" },
|
|
|
|
{ 0xfd ,"plmn-specificSS-d" },
|
|
|
|
{ 0xfe ,"plmn-specificSS-e" },
|
|
|
|
{ 0xff ,"plmn-specificSS-f" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string Teleservice_vals[] = {
|
|
|
|
{0x00, "allTeleservices" },
|
|
|
|
{0x10, "allSpeechTransmissionServices" },
|
|
|
|
{0x11, "telephony" },
|
|
|
|
{0x12, "emergencyCalls" },
|
|
|
|
{0x20, "allShortMessageServices" },
|
|
|
|
{0x21, "shortMessageMT-PP" },
|
|
|
|
{0x22, "shortMessageMO-PP" },
|
|
|
|
{0x60, "allFacsimileTransmissionServices" },
|
|
|
|
{0x61, "facsimileGroup3AndAlterSpeech" },
|
|
|
|
{0x62, "automaticFacsimileGroup3" },
|
|
|
|
{0x63, "facsimileGroup4" },
|
|
|
|
|
|
|
|
{0x70, "allDataTeleservices" },
|
|
|
|
{0x80, "allTeleservices-ExeptSMS" },
|
|
|
|
|
|
|
|
{0x90, "allVoiceGroupCallServices" },
|
|
|
|
{0x91, "voiceGroupCall" },
|
|
|
|
{0x92, "voiceBroadcastCall" },
|
|
|
|
|
|
|
|
{0xd0, "allPLMN-specificTS" },
|
|
|
|
{0xd1, "plmn-specificTS-1" },
|
|
|
|
{0xd2, "plmn-specificTS-2" },
|
|
|
|
{0xd3, "plmn-specificTS-3" },
|
|
|
|
{0xd4, "plmn-specificTS-4" },
|
|
|
|
{0xd5, "plmn-specificTS-5" },
|
|
|
|
{0xd6, "plmn-specificTS-6" },
|
|
|
|
{0xd7, "plmn-specificTS-7" },
|
|
|
|
{0xd8, "plmn-specificTS-8" },
|
|
|
|
{0xd9, "plmn-specificTS-9" },
|
|
|
|
{0xda, "plmn-specificTS-A" },
|
|
|
|
{0xdb, "plmn-specificTS-B" },
|
|
|
|
{0xdc, "plmn-specificTS-C" },
|
|
|
|
{0xdd, "plmn-specificTS-D" },
|
|
|
|
{0xde, "plmn-specificTS-E" },
|
|
|
|
{0xdf, "plmn-specificTS-F" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2005-03-17 22:08:09 +00:00
|
|
|
|
2005-04-15 08:29:50 +00:00
|
|
|
static const value_string Bearerservice_vals[] = {
|
|
|
|
{0x00, "allBearerServices" },
|
|
|
|
{0x10, "allDataCDA-Services" },
|
|
|
|
{0x11, "dataCDA-300bps" },
|
|
|
|
{0x12, "dataCDA-1200bps" },
|
|
|
|
{0x13, "dataCDA-1200-75bps" },
|
|
|
|
{0x14, "dataCDA-2400bps" },
|
|
|
|
{0x15, "dataCDA-4800bps" },
|
|
|
|
{0x16, "dataCDA-9600bps" },
|
|
|
|
{0x17, "general-dataCDA" },
|
|
|
|
|
|
|
|
{0x18, "allDataCDS-Services" },
|
|
|
|
{0x1A, "dataCDS-1200bps" },
|
|
|
|
{0x1C, "dataCDS-2400bps" },
|
|
|
|
{0x1D, "dataCDS-4800bps" },
|
|
|
|
{0x1E, "dataCDS-9600bps" },
|
|
|
|
{0x1F, "general-dataCDS" },
|
|
|
|
|
|
|
|
{0x20, "allPadAccessCA-Services" },
|
|
|
|
{0x21, "padAccessCA-300bps" },
|
|
|
|
{0x22, "padAccessCA-1200bps" },
|
|
|
|
{0x23, "padAccessCA-1200-75bps" },
|
|
|
|
{0x24, "padAccessCA-2400bps" },
|
|
|
|
{0x25, "padAccessCA-4800bps" },
|
|
|
|
{0x26, "padAccessCA-9600bps" },
|
|
|
|
{0x27, "general-padAccessCA" },
|
|
|
|
|
|
|
|
{0x28, "allDataPDS-Services" },
|
|
|
|
{0x2C, "dataPDS-2400bps" },
|
|
|
|
{0x2D, "dataPDS-4800bps" },
|
|
|
|
{0x2E, "dataPDS-9600bps" },
|
|
|
|
{0x2F, "general-dataPDS" },
|
|
|
|
|
|
|
|
{0x30, "allAlternateSpeech-DataCDA" },
|
|
|
|
{0x38, "allAlternateSpeech-DataCDS" },
|
|
|
|
{0x40, "allSpeechFollowedByDataCDA" },
|
|
|
|
{0x48, "allSpeechFollowedByDataCDS" },
|
|
|
|
|
|
|
|
{0x50, "allDataCircuitAsynchronous" },
|
|
|
|
{0x60, "allAsynchronousServices" },
|
|
|
|
{0x58, "allDataCircuitSynchronous" },
|
|
|
|
{0x68, "allSynchronousServices" },
|
|
|
|
|
|
|
|
{0xD0, "allPLMN-specificBS" },
|
|
|
|
{0xD1, "plmn-specificBS-1" },
|
|
|
|
{0xD2, "plmn-specificBS-2" },
|
|
|
|
{0xD3, "plmn-specificBS-3" },
|
|
|
|
{0xD4, "plmn-specificBS-4" },
|
|
|
|
{0xD5, "plmn-specificBS-5" },
|
|
|
|
{0xD6, "plmn-specificBS-6" },
|
|
|
|
{0xD7, "plmn-specificBS-7" },
|
|
|
|
{0xD8, "plmn-specificBS-8" },
|
|
|
|
{0xD9, "plmn-specificBS-9" },
|
|
|
|
{0xDA, "plmn-specificBS-A" },
|
|
|
|
{0xDB, "plmn-specificBS-B" },
|
|
|
|
{0xDC, "plmn-specificBS-C" },
|
|
|
|
{0xDD, "plmn-specificBS-D" },
|
|
|
|
{0xDE, "plmn-specificBS-E" },
|
|
|
|
{0xDF, "plmn-specificBS-F" },
|
|
|
|
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
2009-10-09 21:03:07 +00:00
|
|
|
/* ForwardingOptions
|
2005-07-11 19:24:30 +00:00
|
|
|
|
|
|
|
-- bit 8: notification to forwarding party
|
|
|
|
-- 0 no notification
|
|
|
|
-- 1 notification
|
|
|
|
*/
|
|
|
|
static const true_false_string notification_value = {
|
|
|
|
"Notification",
|
|
|
|
"No notification"
|
|
|
|
};
|
|
|
|
/*
|
|
|
|
-- bit 7: redirecting presentation
|
|
|
|
-- 0 no presentation
|
|
|
|
-- 1 presentation
|
|
|
|
*/
|
|
|
|
static const true_false_string redirecting_presentation_value = {
|
|
|
|
"Presentation",
|
|
|
|
"No presentationn"
|
|
|
|
};
|
|
|
|
/*
|
|
|
|
-- bit 6: notification to calling party
|
|
|
|
-- 0 no notification
|
|
|
|
-- 1 notification
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
-- bit 5: 0 (unused)
|
|
|
|
-- bits 43: forwarding reason
|
|
|
|
-- 00 ms not reachable
|
|
|
|
-- 01 ms busy
|
|
|
|
-- 10 no reply
|
|
|
|
-- 11 unconditional when used in a SRI Result,
|
|
|
|
-- or call deflection when used in a RCH Argument
|
|
|
|
*/
|
|
|
|
static const value_string forwarding_reason_values[] = {
|
|
|
|
{0x0, "ms not reachable" },
|
|
|
|
{0x1, "ms busy" },
|
|
|
|
{0x2, "no reply" },
|
|
|
|
{0x3, "unconditional when used in a SRI Result or call deflection when used in a RCH Argument" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
/*
|
|
|
|
-- bits 21: 00 (unused)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static const value_string pdp_type_org_values[] = {
|
|
|
|
{0x0, "ETSI" },
|
|
|
|
{0x1, "IETF" },
|
|
|
|
{0xf, "Empty PDP type" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string etsi_pdp_type_number_values[] = {
|
|
|
|
{0x0, "Reserved, used in earlier version of this protocol" },
|
|
|
|
{0x1, "PPP" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static const value_string ietf_pdp_type_number_values[] = {
|
|
|
|
{0x21, "IPv4 Address" },
|
|
|
|
{0x57, "IPv6 Address" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
ChargingCharacteristics ::= OCTET STRING (SIZE (2))
|
|
|
|
-- Octets are coded according to 3GPP TS 32.015.
|
|
|
|
-- From 3GPP TS 32.015.
|
|
|
|
--
|
|
|
|
-- Descriptions for the bits of the flag set:
|
|
|
|
--
|
|
|
|
-- Bit 1: H (Hot billing) := '00000001'B
|
|
|
|
-- Bit 2: F (Flat rate) := '00000010'B
|
|
|
|
-- Bit 3: P (Prepaid service) := '00000100'B
|
|
|
|
-- Bit 4: N (Normal billing) := '00001000'B
|
|
|
|
-- Bit 5: - (Reserved, set to 0) := '00010000'B
|
|
|
|
-- Bit 6: - (Reserved, set to 0) := '00100000'B
|
|
|
|
-- Bit 7: - (Reserved, set to 0) := '01000000'B
|
|
|
|
-- Bit 8: - (Reserved, set to 0) := '10000000'B
|
|
|
|
*/
|
|
|
|
static const value_string chargingcharacteristics_values[] = {
|
|
|
|
{0x1, "H (Hot billing)" },
|
|
|
|
{0x2, "F (Flat rate)" },
|
|
|
|
{0x4, "P (Prepaid service)" },
|
|
|
|
{0x8, "N (Normal billing)" },
|
|
|
|
{ 0, NULL }
|
|
|
|
};
|
2008-01-30 17:11:06 +00:00
|
|
|
|
2005-01-24 22:33:36 +00:00
|
|
|
/*--- proto_reg_handoff_gsm_map ---------------------------------------*/
|
2005-03-17 22:08:09 +00:00
|
|
|
static void range_delete_callback(guint32 ssn)
|
|
|
|
{
|
2014-03-14 16:39:52 +00:00
|
|
|
if (ssn) {
|
|
|
|
delete_itu_tcap_subdissector(ssn, map_handle);
|
|
|
|
}
|
2005-03-17 22:08:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void range_add_callback(guint32 ssn)
|
|
|
|
{
|
2014-03-14 16:39:52 +00:00
|
|
|
if (ssn) {
|
|
|
|
add_itu_tcap_subdissector(ssn, map_handle);
|
|
|
|
}
|
2005-03-17 22:08:09 +00:00
|
|
|
}
|
|
|
|
|
2005-01-24 22:33:36 +00:00
|
|
|
void proto_reg_handoff_gsm_map(void) {
|
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
static gboolean map_prefs_initialized = FALSE;
|
|
|
|
static range_t *ssn_range;
|
|
|
|
|
|
|
|
if (!map_prefs_initialized) {
|
|
|
|
map_prefs_initialized = TRUE;
|
|
|
|
data_handle = find_dissector("data");
|
|
|
|
ranap_handle = find_dissector("ranap");
|
|
|
|
dtap_handle = find_dissector("gsm_a_dtap");
|
|
|
|
gsm_sms_handle = find_dissector("gsm_sms");
|
2014-11-22 16:54:54 +00:00
|
|
|
bssap_handle = find_dissector("gsm_a_bssmap");
|
2014-03-14 16:39:52 +00:00
|
|
|
|
|
|
|
map_handle = find_dissector("gsm_map");
|
|
|
|
oid_add_from_string("itu(0) administration(2) japan(440)","0.2.440" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.1.3", map_handle, proto_gsm_map,"networkLocUpContext-v3");
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.1.2", map_handle, proto_gsm_map,"networkLocUpContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.1.1", map_handle, proto_gsm_map,"networkLocUpContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.2.3", map_handle, proto_gsm_map,"locationCancellationContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.2.2", map_handle, proto_gsm_map,"locationCancellationContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.2.1", map_handle, proto_gsm_map,"locationCancellationContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.3.3", map_handle, proto_gsm_map,"roamingNumberEnquiryContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.3.2", map_handle, proto_gsm_map,"roamingNumberEnquiryContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.3.1", map_handle, proto_gsm_map,"roamingNumberEnquiryContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.4.3", map_handle, proto_gsm_map,"istAlertingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.5.3", map_handle, proto_gsm_map,"locationInfoRetrievalContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.5.2", map_handle, proto_gsm_map,"locationInfoRetrievalContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.5.1", map_handle, proto_gsm_map,"locationInfoRetrievalContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.6.4", map_handle, proto_gsm_map,"callControlTransferContext-v4" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.6.3", map_handle, proto_gsm_map,"callControlTransferContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.7.3", map_handle, proto_gsm_map,"reportingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.8.3", map_handle, proto_gsm_map,"callCompletionContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.9.3", map_handle, proto_gsm_map,"serviceTerminationContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.10.2", map_handle, proto_gsm_map,"resetContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.10.1", map_handle, proto_gsm_map,"resetContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.11.3", map_handle, proto_gsm_map,"handoverControlContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.11.2", map_handle, proto_gsm_map,"handoverControlContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.11.1", map_handle, proto_gsm_map,"handoverControlContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.12.3", map_handle, proto_gsm_map,"sIWFSAllocationContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.13.3", map_handle, proto_gsm_map,"equipmentMngtContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.13.2", map_handle, proto_gsm_map,"equipmentMngtContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.13.1", map_handle, proto_gsm_map,"equipmentMngtContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.14.3", map_handle, proto_gsm_map,"infoRetrievalContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.14.2", map_handle, proto_gsm_map,"infoRetrievalContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.14.1", map_handle, proto_gsm_map,"infoRetrievalContext-v1" );
|
|
|
|
/* fallback to infoRetrieval(14) version1(1) and not interVlrInfoRetrieval(15) version1(1) */
|
|
|
|
/*register_ber_oid_dissector_handle("0.4.0.0.1.0.15.1", map_handle, proto_gsm_map,"map-ac interVlrInfoRetrieval(15) version1(1)" );*/
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.15.2", map_handle, proto_gsm_map,"interVlrInfoRetrievalContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.15.3", map_handle, proto_gsm_map,"interVlrInfoRetrievalContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.16.3", map_handle, proto_gsm_map,"subscriberDataMngtContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.16.2", map_handle, proto_gsm_map,"subscriberDataMngtContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.16.1", map_handle, proto_gsm_map,"subscriberDataMngtContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.17.3", map_handle, proto_gsm_map,"tracingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.17.2", map_handle, proto_gsm_map,"tracingContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.17.1", map_handle, proto_gsm_map,"tracingContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.18.2", map_handle, proto_gsm_map,"networkFunctionalSsContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.18.1", map_handle, proto_gsm_map,"networkFunctionalSsContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.19.2", map_handle, proto_gsm_map,"networkUnstructuredSsContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.20.3", map_handle, proto_gsm_map,"shortMsgGatewayContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.20.2", map_handle, proto_gsm_map,"shortMsgGatewayContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.20.1", map_handle, proto_gsm_map,"shortMsgGatewayContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.21.3", map_handle, proto_gsm_map,"shortMsgMO-RelayContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.21.2", map_handle, proto_gsm_map,"shortMsgMO-RelayContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.21.1", map_handle, proto_gsm_map,"shortMsgRelayContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.22.3", map_handle, proto_gsm_map,"subscriberDataModificationNotificationContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.23.2", map_handle, proto_gsm_map,"shortMsgAlertContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.23.1", map_handle, proto_gsm_map,"shortMsgAlertContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.24.3", map_handle, proto_gsm_map,"mwdMngtContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.24.2", map_handle, proto_gsm_map,"mwdMngtContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.24.1", map_handle, proto_gsm_map,"mwdMngtContext-v1" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.25.3", map_handle, proto_gsm_map,"shortMsgMT-RelayContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.25.2", map_handle, proto_gsm_map,"shortMsgMT-RelayContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.26.2", map_handle, proto_gsm_map,"imsiRetrievalContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.27.2", map_handle, proto_gsm_map,"msPurgingContext-v2" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.27.3", map_handle, proto_gsm_map,"msPurgingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.28.3", map_handle, proto_gsm_map,"subscriberInfoEnquiryContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.29.3", map_handle, proto_gsm_map,"anyTimeInfoEnquiryContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.31.3", map_handle, proto_gsm_map,"groupCallControlContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.32.3", map_handle, proto_gsm_map,"gprsLocationUpdateContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.33.4", map_handle, proto_gsm_map,"gprsLocationInfoRetrievalContext-v4" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.33.3", map_handle, proto_gsm_map,"gprsLocationInfoRetrievalContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.34.3", map_handle, proto_gsm_map,"failureReportContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.35.3", map_handle, proto_gsm_map,"gprsNotifyContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.36.3", map_handle, proto_gsm_map,"ss-InvocationNotificationContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.37.3", map_handle, proto_gsm_map,"locationSvcGatewayContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.38.3", map_handle, proto_gsm_map,"locationSvcEnquiryContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.39.3", map_handle, proto_gsm_map,"authenticationFailureReportContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.40.3", map_handle, proto_gsm_map,"secureTransportHandlingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.41.3", map_handle, proto_gsm_map,"shortMsgMT-Relay-VGCS-Context-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.42.3", map_handle, proto_gsm_map,"mm-EventReportingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.43.3", map_handle, proto_gsm_map,"anyTimeInfoHandlingContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.44.3", map_handle, proto_gsm_map,"resourceManagementContext-v3" );
|
|
|
|
register_ber_oid_dissector_handle("0.4.0.0.1.0.45.3", map_handle, proto_gsm_map,"groupCallInfoRetrievalContext-v3" );
|
|
|
|
/* Private extension container */
|
|
|
|
register_ber_oid_dissector("1.3.12.2.1006.53.2.1.3", dissect_gsm_mapext_PlmnContainer, proto_gsm_map,"alcatel-E10-MAP-extension-PlmnContainer" );
|
|
|
|
register_ber_oid_dissector("0.34.0",dissect_NokiaMAP_ext_IsdArgExtension,proto_gsm_map,"Nokia ISD Extension");
|
|
|
|
register_ber_oid_dissector("0.34.1",dissect_NokiaMAP_ext_DsdArgExt,proto_gsm_map,"Nokia Dsd Extension");
|
|
|
|
register_ber_oid_dissector("0.34.2",dissect_NokiaMAP_ext_UlResExtension,proto_gsm_map,"Nokia Location Update Extension");
|
|
|
|
register_ber_oid_dissector("0.34.4",dissect_NokiaMAP_ext_SS_DataExtension,proto_gsm_map,"Nokia SS Data Extension");
|
|
|
|
register_ber_oid_dissector("0.34.5",dissect_NokiaMAP_ext_SriExtension,proto_gsm_map,"Nokia SRI Request Extension");
|
|
|
|
register_ber_oid_dissector("0.34.6",dissect_NokiaMAP_ExtraSignalInfo,proto_gsm_map,"Nokia ExtraSignalInfo Extension");
|
|
|
|
register_ber_oid_dissector("0.34.7",dissect_NokiaMAP_ext_SriResExtension,proto_gsm_map,"Nokia SRI Response Extension");
|
|
|
|
register_ber_oid_dissector("0.34.10",dissect_NokiaMAP_ext_CanLocArgExt,proto_gsm_map,"Nokia Cancel Location Extension");
|
|
|
|
register_ber_oid_dissector("0.34.11",dissect_NokiaMAP_ext_ATMargExt,proto_gsm_map,"Nokia ATM Extension");
|
|
|
|
register_ber_oid_dissector("0.34.12",dissect_NokiaMAP_ext_DTMargExt,proto_gsm_map,"Nokia DTM Extension");
|
|
|
|
register_ber_oid_dissector("0.34.13",dissect_NokiaMAP_ext_NumberPorted,proto_gsm_map,"Nokia NumberPorted Extension");
|
|
|
|
register_ber_oid_dissector("0.34.15",dissect_NokiaMAP_ext_HOExtension,proto_gsm_map,"Nokia HandOver Extension");
|
|
|
|
register_ber_oid_dissector("0.34.16",dissect_NokiaMAP_ext_ATMresExt,proto_gsm_map,"Nokia ATMres Extension");
|
|
|
|
register_ber_oid_dissector("0.34.17",dissect_NokiaMAP_ext_AbsentSubscriberExt,proto_gsm_map,"Nokia AbsentSubscriber Extension");
|
|
|
|
register_ber_oid_dissector("0.34.18",dissect_NokiaMAP_ext_SriForSMArgExt,proto_gsm_map,"Nokia SriForSM Extension");
|
|
|
|
register_ber_oid_dissector("0.34.19",dissect_NokiaMAP_ext_ReportSMDelStatArgExt,proto_gsm_map,"Nokia ReportSMDelStatt Extension");
|
|
|
|
register_ber_oid_dissector("0.34.20",dissect_NokiaMAP_ext_UdlArgExt,proto_gsm_map,"Nokia Udl Extension");
|
|
|
|
register_ber_oid_dissector("0.34.21",dissect_NokiaMAP_ext_RoamNotAllowedExt,proto_gsm_map,"Nokia RoamNotAllowed Extension");
|
|
|
|
register_ber_oid_dissector("0.34.22",dissect_NokiaMAP_ext_MO_ForwardSM_ArgExt,proto_gsm_map,"Nokia MO-ForwardSM Extension");
|
|
|
|
register_ber_oid_dissector("0.34.23",dissect_NokiaMAP_ext_ErrOlcmInfoTableExt,proto_gsm_map,"Nokia ErrOlcmInfoTable Extension");
|
|
|
|
register_ber_oid_dissector("0.34.25",dissect_NokiaMAP_ext_RoutingCategoryExt,proto_gsm_map,"Nokia Routing Category Extension");
|
|
|
|
register_ber_oid_dissector("0.34.26",dissect_NokiaMAP_ext_AnyTimeModArgExt,proto_gsm_map,"Nokia AnyTimeMod Extension");
|
|
|
|
|
|
|
|
register_ber_oid_dissector("1.2.826.0.1249.58.1.0",dissect_NokiaMAP_ext_ExtensionType,proto_gsm_map,"Nokia ExtensionType Extension");
|
|
|
|
|
|
|
|
register_ber_oid_dissector("1.3.12.2.1107.3.66.1.1",dissect_NokiaMAP_ext_AccessTypeExt,proto_gsm_map,"Nokia AccessTypeExt Extension");
|
|
|
|
register_ber_oid_dissector("1.3.12.2.1107.3.66.1.3",dissect_NokiaMAP_ext_AccessSubscriptionListExt,proto_gsm_map,"Nokia AccessSubscriptionListExt Extension");
|
|
|
|
register_ber_oid_dissector("1.3.12.2.1107.3.66.1.6",dissect_NokiaMAP_ext_AllowedServiceData,proto_gsm_map,"Nokia AllowedServiceData Extension");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
range_foreach(ssn_range, range_delete_callback);
|
|
|
|
g_free(ssn_range);
|
|
|
|
}
|
2014-02-26 19:29:17 +00:00
|
|
|
|
2014-03-14 16:39:52 +00:00
|
|
|
ssn_range = range_copy(global_ssn_range);
|
|
|
|
range_foreach(ssn_range, range_add_callback);
|
2005-01-24 22:33:36 +00:00
|
|
|
|
|
|
|
}
|
2004-11-02 01:19:23 +00:00
|
|
|
|
|
|
|
/*--- proto_register_gsm_map -------------------------------------------*/
|
|
|
|
void proto_register_gsm_map(void) {
|
2014-03-14 16:39:52 +00:00
|
|
|
module_t *gsm_map_module;
|
|
|
|
expert_module_t* expert_gsm_map;
|
2004-11-02 01:19:23 +00:00
|
|
|
|
|
|
|
/* List of fields */
|
|
|
|
static hf_register_info hf[] = {
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_old_Component_PDU,
|
|
|
|
{ "Component", "gsm_map.old.Component",
|
|
|
|
FT_UINT32, BASE_DEC, VALS(gsm_old_Component_vals), 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_getPassword,
|
|
|
|
{ "getPassword", "gsm_map.getPassword",
|
2009-04-23 18:58:18 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_old_GetPasswordArg_vals), 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_currentPassword,
|
|
|
|
{ "currentPassword", "gsm_map.currentPassword",
|
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_extension,
|
|
|
|
{ "Extension", "gsm_map.extension",
|
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_extension_value), 0x80,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_nature_of_number,
|
|
|
|
{ "Nature of number", "gsm_map.nature_of_number",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8, BASE_HEX|BASE_EXT_STRING, &gsm_map_nature_of_number_values_ext, 0x70,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_number_plan,
|
|
|
|
{ "Number plan", "gsm_map.number_plan",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8, BASE_HEX|BASE_EXT_STRING, &gsm_map_number_plan_values_ext, 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_address_digits,
|
|
|
|
{ "Address digits", "gsm_map.address.digits",
|
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_TBCD_digits,
|
2012-08-20 12:47:47 +00:00
|
|
|
{ "TBCD digits", "gsm_map.tbcd_digits",
|
2008-11-04 22:01:35 +00:00
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_Ss_Status_unused,
|
|
|
|
{ "Unused", "gsm_map.unused",
|
|
|
|
FT_UINT8, BASE_HEX, NULL, 0xf0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_Ss_Status_q_bit,
|
|
|
|
{ "Q bit", "gsm_map.ss_status_q_bit",
|
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_Ss_Status_q_bit_values), 0x08,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_Ss_Status_p_bit,
|
|
|
|
{ "P bit", "gsm_map.ss_status_p_bit",
|
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_Ss_Status_p_values), 0x04,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_Ss_Status_r_bit,
|
|
|
|
{ "R bit", "gsm_map.ss_status_r_bit",
|
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_Ss_Status_r_values), 0x02,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_Ss_Status_a_bit,
|
|
|
|
{ "A bit", "gsm_map.ss_status_a_bit",
|
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_Ss_Status_a_values), 0x01,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_notification_to_forwarding_party,
|
|
|
|
{ "Notification to forwarding party", "gsm_map.notification_to_forwarding_party",
|
|
|
|
FT_BOOLEAN, 8, TFS(¬ification_value), 0x80,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_redirecting_presentation,
|
|
|
|
{ "Redirecting presentation", "gsm_map.redirecting_presentation",
|
|
|
|
FT_BOOLEAN, 8, TFS(&redirecting_presentation_value), 0x40,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_notification_to_calling_party,
|
|
|
|
{ "Notification to calling party", "gsm_map.notification_to_clling_party",
|
|
|
|
FT_BOOLEAN, 8, TFS(¬ification_value), 0x20,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_forwarding_reason,
|
|
|
|
{ "Forwarding reason", "gsm_map.forwarding_reason",
|
|
|
|
FT_UINT8, BASE_HEX, VALS(forwarding_reason_values), 0x0c,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_pdp_type_org,
|
|
|
|
{ "PDP Type Organization", "gsm_map.pdp_type_org",
|
|
|
|
FT_UINT8, BASE_HEX, VALS(pdp_type_org_values), 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_etsi_pdp_type_number,
|
2013-03-27 21:41:56 +00:00
|
|
|
{ "PDP Type Number", "gsm_map.pdp_type_number",
|
2008-11-04 22:01:35 +00:00
|
|
|
FT_UINT8, BASE_HEX, VALS(etsi_pdp_type_number_values), 0,
|
|
|
|
"ETSI PDP Type Number", HFILL }},
|
|
|
|
{ &hf_gsm_map_ietf_pdp_type_number,
|
|
|
|
{ "PDP Type Number", "gsm_map.ietf_pdp_type_number",
|
|
|
|
FT_UINT8, BASE_HEX, VALS(ietf_pdp_type_number_values), 0,
|
|
|
|
"IETF PDP Type Number", HFILL }},
|
|
|
|
{ &hf_gsm_map_ext_qos_subscribed_pri,
|
|
|
|
{ "Allocation/Retention priority", "gsm_map.ext_qos_subscribed_pri",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0xff,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_traffic_cls,
|
|
|
|
{ "Traffic class", "gsm_map.qos.traffic_cls",
|
2012-08-01 09:44:57 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_a_sm_qos_traffic_cls_vals), 0xe0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_del_order,
|
|
|
|
{ "Delivery order", "gsm_map.qos.del_order",
|
2012-08-01 09:44:57 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_a_sm_qos_traffic_cls_vals), 0x18,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_del_of_err_sdu,
|
|
|
|
{ "Delivery of erroneous SDUs", "gsm_map.qos.del_of_err_sdu",
|
2012-08-01 09:44:57 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_a_sm_qos_del_of_err_sdu_vals), 0x03,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_ber,
|
|
|
|
{ "Residual Bit Error Rate (BER)", "gsm_map.qos.ber",
|
2012-08-01 09:44:57 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_a_sm_qos_ber_vals), 0xf0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_sdu_err_rat,
|
|
|
|
{ "SDU error ratio", "gsm_map.qos.sdu_err_rat",
|
2012-08-01 09:44:57 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_a_sm_qos_sdu_err_rat_vals), 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_traff_hdl_pri,
|
|
|
|
{ "Traffic handling priority", "gsm_map.qos.traff_hdl_pri",
|
2012-08-01 09:44:57 +00:00
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_a_sm_qos_traff_hdl_pri_vals), 0x03,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2009-10-09 21:03:07 +00:00
|
|
|
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_qos_max_sdu,
|
|
|
|
{ "Maximum SDU size", "gsm_map.qos.max_sdu",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_max_brate_ulink,
|
|
|
|
{ "Maximum bit rate for uplink in kbit/s", "gsm_map.qos.max_brate_ulink",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Maximum bit rate for uplink", HFILL }},
|
|
|
|
{ &hf_gsm_map_max_brate_dlink,
|
|
|
|
{ "Maximum bit rate for downlink in kbit/s", "gsm_map.qos.max_brate_dlink",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Maximum bit rate for downlink", HFILL }},
|
|
|
|
{ &hf_gsm_map_qos_transfer_delay,
|
|
|
|
{ "Transfer delay (Raw data see TS 24.008 for interpretation)", "gsm_map.qos.transfer_delay",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0xfc,
|
|
|
|
"Transfer delay", HFILL }},
|
|
|
|
{ &hf_gsm_map_guaranteed_max_brate_ulink,
|
|
|
|
{ "Guaranteed bit rate for uplink in kbit/s", "gsm_map.qos.brate_ulink",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Guaranteed bit rate for uplink", HFILL }},
|
|
|
|
{ &hf_gsm_map_guaranteed_max_brate_dlink,
|
|
|
|
{ "Guaranteed bit rate for downlink in kbit/s", "gsm_map.qos.brate_dlink",
|
|
|
|
FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
|
|
"Guaranteed bit rate for downlink", HFILL }},
|
|
|
|
{ &hf_gsm_map_GSNAddress_IPv4,
|
|
|
|
{ "GSN-Address IPv4", "gsm_map.gsnaddress_ipv4",
|
|
|
|
FT_IPv4, BASE_NONE, NULL, 0,
|
|
|
|
"IPAddress IPv4", HFILL }},
|
|
|
|
{ &hf_gsm_map_ranap_service_Handover,
|
|
|
|
{ "service-Handover", "gsm_map.ranap.service_Handover",
|
|
|
|
FT_UINT32, BASE_DEC, VALS(ranap_Service_Handover_vals), 0,
|
|
|
|
"gsm_map.ranap.Service_Handover", HFILL }},
|
|
|
|
{ &hf_gsm_map_IntegrityProtectionInformation,
|
|
|
|
{ "IntegrityProtectionInformation", "gsm_map.ranap.IntegrityProtectionInformation",
|
|
|
|
FT_NONE, BASE_NONE, NULL, 0,
|
|
|
|
"gsm_map.ranap.IntegrityProtectionInformation", HFILL }},
|
|
|
|
{ &hf_gsm_map_EncryptionInformation,
|
|
|
|
{ "EncryptionInformation", "gsm_map.ranap.EncryptionInformation",
|
|
|
|
FT_NONE, BASE_NONE, NULL, 0,
|
|
|
|
"gsm_map.ranap.EncryptionInformation", HFILL }},
|
|
|
|
{ &hf_gsm_map_ss_SS_UserData,
|
|
|
|
{ "SS-UserData", "gsm_ss.SS_UserData",
|
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
"gsm_map.ss.SS_UserData", HFILL }},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp,
|
|
|
|
{ "Coding Group","gsm_map.cbs.coding_grp",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8,BASE_DEC|BASE_EXT_STRING, &gsm_map_cbs_data_coding_scheme_coding_grp_vals_ext, 0xf0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp0_lang,
|
|
|
|
{ "Language","gsm_map.cbs.coding_grp0_lang",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8,BASE_DEC|BASE_EXT_STRING, &gsm_map_cbs_coding_grp0_lang_vals_ext, 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp1_lang,
|
|
|
|
{ "Language","gsm_map.cbs.coding_grp1_lang",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8,BASE_DEC|BASE_EXT_STRING, &gsm_map_cbs_coding_grp1_lang_vals_ext, 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp2_lang,
|
|
|
|
{ "Language","gsm_map.cbs.coding_grp2_lang",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8,BASE_DEC|BASE_EXT_STRING, &gsm_map_cbs_coding_grp2_lang_vals_ext, 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp3_lang,
|
|
|
|
{ "Language","gsm_map.cbs.coding_grp3_lang",
|
2011-01-12 07:36:55 +00:00
|
|
|
FT_UINT8,BASE_DEC|BASE_EXT_STRING, &gsm_map_cbs_coding_grp3_lang_vals_ext, 0x0f,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp4_7_comp,
|
|
|
|
{ "Compressed indicator","gsm_map.cbs.coding_grp4_7_comp",
|
2009-10-09 21:03:07 +00:00
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_cbs_coding_grp4_7_comp_vals), 0x20,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp4_7_class_ind,
|
|
|
|
{ "Message Class present","gsm_map.cbs.coding_grp4_7_class_ind",
|
2009-10-09 21:03:07 +00:00
|
|
|
FT_BOOLEAN, 8, TFS(&gsm_map_cbs_coding_grp4_7_class_ind_vals), 0x10,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp4_7_char_set,
|
|
|
|
{ "Character set being used","gsm_map.cbs.coding_grp4_7_char_set",
|
2009-10-09 21:03:07 +00:00
|
|
|
FT_UINT8,BASE_DEC, VALS(gsm_map_cbs_coding_grp4_7_char_set_vals), 0x0c,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp4_7_class,
|
|
|
|
{ "Message Class","gsm_map.cbs.coding_grp4_7_class",
|
2009-10-09 21:03:07 +00:00
|
|
|
FT_UINT8,BASE_DEC, VALS(gsm_map_cbs_coding_grp4_7_class_vals), 0x03,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp15_mess_code,
|
|
|
|
{ "Message coding","gsm_map.cbs.cbs_coding_grp15_mess_code",
|
2009-10-09 21:03:07 +00:00
|
|
|
FT_UINT8,BASE_DEC, VALS(gsm_map_cbs_coding_grp15_mess_code_vals), 0x04,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_cbs_coding_grp15_class,
|
|
|
|
{ "Message Class","gsm_map.cbs.gsm_map_cbs_coding_grp15_class",
|
2009-10-09 21:03:07 +00:00
|
|
|
FT_UINT8,BASE_DEC, VALS(gsm_map_cbs_coding_grp15_class_vals), 0x03,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }
|
2008-11-04 22:01:35 +00:00
|
|
|
},
|
|
|
|
{ &hf_gsm_map_tmsi,
|
|
|
|
{ "tmsi", "gsm_map.tmsi",
|
2009-06-24 01:40:54 +00:00
|
|
|
FT_BYTES, BASE_NONE, NULL, 0,
|
2008-11-04 22:01:35 +00:00
|
|
|
"gsm_map.TMSI", HFILL }},
|
2009-10-09 21:03:07 +00:00
|
|
|
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_ie_tag,
|
|
|
|
{ "Tag", "gsm_map.ie_tag",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_map_tag_vals), 0,
|
|
|
|
"GSM 04.08 tag", HFILL }},
|
|
|
|
{ &hf_gsm_map_len,
|
|
|
|
{ "Length", "gsm_map.length",
|
|
|
|
FT_UINT8, BASE_DEC, NULL, 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_disc_par,
|
|
|
|
{ "Discrimination parameter", "gsm_map.disc_par",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_map_disc_par_vals), 0,
|
2009-06-24 01:40:54 +00:00
|
|
|
NULL, HFILL }},
|
2008-11-04 22:01:35 +00:00
|
|
|
{ &hf_gsm_map_dlci,
|
2013-03-27 20:44:47 +00:00
|
|
|
{ "DLCI", "gsm_map.dlci",
|
2008-11-04 22:01:35 +00:00
|
|
|
FT_UINT8, BASE_DEC, NULL, 0,
|
|
|
|
"Data Link Connection Indicator", HFILL }},
|
2011-06-20 10:29:46 +00:00
|
|
|
{ &hf_gsm_apn_str,
|
|
|
|
{ "APN", "gsm_map.apn_str",
|
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
NULL, HFILL }},
|
2013-03-27 21:41:56 +00:00
|
|
|
{ &hf_gsm_map_locationnumber_odd_even,
|
2012-03-07 12:06:16 +00:00
|
|
|
{ "Odd/Even", "gsm_map.locationnumber.odd_even",
|
|
|
|
FT_BOOLEAN, 8, NULL, 0x80,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_gsm_map_locationnumber_nai,
|
|
|
|
{ "Nature of address indicator", "gsm_map.locationnumber.nai",
|
2012-05-19 19:05:36 +00:00
|
|
|
FT_UINT8, BASE_RANGE_STRING | BASE_DEC, RVALS(gsm_map_na_vals), 0x3f,
|
2012-03-07 12:06:16 +00:00
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_gsm_map_locationnumber_inn,
|
|
|
|
{ "Internal Network Number indicator (INN)", "gsm_map.locationnumber.inn",
|
|
|
|
FT_BOOLEAN, 8, NULL, 0x80,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_gsm_map_locationnumber_npi,
|
|
|
|
{ "Numbering plan indicator", "gsm_map.locationnumber.npi",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_map_np_vals), 0x30,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_gsm_map_locationnumber_apri,
|
|
|
|
{ "Address presentation restricted indicator", "gsm_map.locationnumber.apri",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_map_addr_pres_rest_vals), 0x0c,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_gsm_map_locationnumber_screening_ind,
|
|
|
|
{ "Screening indicator", "gsm_map.locationnumber.screening_ind",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_map_screening_ind_vals), 0x03,
|
|
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_gsm_map_locationnumber_digits,
|
2012-08-21 10:40:04 +00:00
|
|
|
{ "Address digits", "gsm_map.locationnumber.digits",
|
2012-03-07 12:06:16 +00:00
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
NULL, HFILL }},
|
2012-08-21 15:14:50 +00:00
|
|
|
{ &hf_gsm_map_ericsson_locationInformation_rat,
|
|
|
|
{ "RAT", "gsm_map.ericsson.locationInformation.rat",
|
|
|
|
FT_UINT8, BASE_DEC, VALS(gsm_map_ericsson_locationInformation_rat_vals), 0,
|
|
|
|
"Radio Access Technology", HFILL }},
|
|
|
|
{ &hf_gsm_map_ericsson_locationInformation_lac,
|
|
|
|
{ "LAC", "gsm_map.ericsson.locationInformation.lac",
|
|
|
|
FT_UINT16, BASE_DEC_HEX, NULL, 0,
|
|
|
|
"Location Area Code", HFILL }},
|
|
|
|
{ &hf_gsm_map_ericsson_locationInformation_ci,
|
|
|
|
{ "CI", "gsm_map.ericsson.locationInformation.ci",
|
|
|
|
FT_UINT16, BASE_DEC_HEX, NULL, 0,
|
|
|
|
"Cell Identity", HFILL }},
|
|
|
|
{ &hf_gsm_map_ericsson_locationInformation_sac,
|
|
|
|
{ "SAC", "gsm_map.ericsson.locationInformation.sac",
|
|
|
|
FT_UINT16, BASE_DEC_HEX, NULL, 0,
|
|
|
|
"Service Area Code", HFILL }},
|
2014-08-08 13:19:29 +00:00
|
|
|
{ &hf_gsm_map_ussd_string,
|
|
|
|
{ "USSD String", "gsm_map.ussd_string",
|
|
|
|
FT_STRING, BASE_NONE, NULL, 0,
|
|
|
|
NULL, HFILL }},
|
|
|
|
|
2007-02-19 06:09:33 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-gsm_map-hfarr.c"
|
|
|
|
};
|
|
|
|
|
|
|
|
/* List of subtrees */
|
|
|
|
static gint *ett[] = {
|
|
|
|
&ett_gsm_map,
|
|
|
|
&ett_gsm_map_InvokeId,
|
|
|
|
&ett_gsm_map_InvokePDU,
|
|
|
|
&ett_gsm_map_ReturnResultPDU,
|
2008-11-04 22:01:35 +00:00
|
|
|
&ett_gsm_map_ReturnErrorPDU,
|
2004-11-02 01:19:23 +00:00
|
|
|
&ett_gsm_map_ReturnResult_result,
|
2008-11-04 22:01:35 +00:00
|
|
|
&ett_gsm_map_ReturnError_result,
|
2004-11-02 01:19:23 +00:00
|
|
|
&ett_gsm_map_GSMMAPPDU,
|
2008-11-04 22:01:35 +00:00
|
|
|
&ett_gsm_map_ext_qos_subscribed,
|
|
|
|
&ett_gsm_map_pdptypenumber,
|
|
|
|
&ett_gsm_map_RAIdentity,
|
|
|
|
&ett_gsm_map_LAIFixedLength,
|
|
|
|
&ett_gsm_map_isdn_address_string,
|
|
|
|
&ett_gsm_map_geo_desc,
|
|
|
|
&ett_gsm_map_LongSignalInfo,
|
|
|
|
&ett_gsm_map_RadioResourceInformation,
|
|
|
|
&ett_gsm_map_MSNetworkCapability,
|
|
|
|
&ett_gsm_map_MSRadioAccessCapability,
|
|
|
|
&ett_gsm_map_externalsignalinfo,
|
|
|
|
&ett_gsm_map_cbs_data_coding,
|
|
|
|
&ett_gsm_map_GlobalCellId,
|
|
|
|
&ett_gsm_map_GeographicalInformation,
|
2012-08-21 15:14:50 +00:00
|
|
|
&ett_gsm_map_apn_str,
|
|
|
|
&ett_gsm_map_LocationNumber,
|
|
|
|
&ett_gsm_map_ericsson_locationInformation,
|
2014-08-08 13:19:29 +00:00
|
|
|
&ett_gsm_map_extention_data,
|
2006-01-22 21:16:33 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
#include "packet-gsm_map-ettarr.c"
|
|
|
|
};
|
|
|
|
|
2013-06-03 03:42:36 +00:00
|
|
|
static ei_register_info ei[] = {
|
|
|
|
{ &ei_gsm_map_unknown_sequence3, { "gsm_map.unknown.sequence3", PI_UNDECODED, PI_ERROR, "Unknown or not implemented [3] sequence", EXPFILL }},
|
|
|
|
{ &ei_gsm_map_unknown_sequence, { "gsm_map.unknown.sequence", PI_UNDECODED, PI_ERROR, "Unknown or not implemented sequence", EXPFILL }},
|
|
|
|
{ &ei_gsm_map_unknown_parameter, { "gsm_map.unknown.parameter", PI_UNDECODED, PI_ERROR, "Unknown or not implemented parameter", EXPFILL }},
|
|
|
|
{ &ei_gsm_map_unknown_invokeData, { "gsm_map.unknown.invokeData", PI_MALFORMED, PI_WARN, "Unknown invokeData", EXPFILL }},
|
2014-08-08 13:19:29 +00:00
|
|
|
{ &ei_gsm_map_undecoded, { "gsm_map.undecoded", PI_UNDECODED, PI_WARN, "If you want this decoded send the packet to Wireshark-dev", EXPFILL }},
|
2013-06-03 03:42:36 +00:00
|
|
|
};
|
|
|
|
|
2012-11-29 20:15:37 +00:00
|
|
|
static const enum_val_t application_context_modes[] = {
|
2012-07-10 11:39:06 +00:00
|
|
|
{"Use Application Context from the trace", "Use application context from the trace", APPLICATON_CONTEXT_FROM_TRACE},
|
|
|
|
{"Treat as AC 1", "Treat as AC 1", 1},
|
|
|
|
{"Treat as AC 2", "Treat as AC 2", 2},
|
|
|
|
{"Treat as AC 3", "Treat as AC 3", 3},
|
|
|
|
{NULL, NULL, -1}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
/* Register protocol */
|
2007-06-10 19:04:12 +00:00
|
|
|
proto_gsm_map_dialogue =proto_gsm_map = proto_register_protocol(PNAME, PSNAME, PFNAME);
|
2007-04-03 19:08:00 +00:00
|
|
|
|
2013-10-28 13:36:49 +00:00
|
|
|
new_register_dissector("gsm_map", dissect_gsm_map, proto_gsm_map);
|
2014-11-22 16:54:54 +00:00
|
|
|
new_register_dissector("gsm_map_sccp", dissect_gsm_map_sccp, proto_gsm_map);
|
2009-10-09 21:03:07 +00:00
|
|
|
|
2004-11-02 01:19:23 +00:00
|
|
|
/* Register fields and subtrees */
|
|
|
|
proto_register_field_array(proto_gsm_map, hf, array_length(hf));
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2013-06-03 03:42:36 +00:00
|
|
|
expert_gsm_map = expert_register_protocol(proto_gsm_map);
|
|
|
|
expert_register_field_array(expert_gsm_map, ei, array_length(ei));
|
2004-11-02 01:19:23 +00:00
|
|
|
|
2013-09-09 21:55:57 +00:00
|
|
|
map_prop_arg_opcode_table = register_dissector_table("gsm_map.prop.arg.opcode", "GSM_MAP Proprietary Arg Opcodes", FT_UINT8, BASE_DEC);
|
|
|
|
map_prop_res_opcode_table = register_dissector_table("gsm_map.prop.res.opcode", "GSM_MAP Proprietary Res Opcodes", FT_UINT8, BASE_DEC);
|
|
|
|
map_prop_err_opcode_table = register_dissector_table("gsm_map.prop.err.opcode", "GSM_MAP Proprietary Err Opcodes", FT_UINT8, BASE_DEC);
|
2011-09-29 15:23:23 +00:00
|
|
|
|
2005-03-17 22:08:09 +00:00
|
|
|
gsm_map_tap = register_tap("gsm_map");
|
2006-03-30 16:46:36 +00:00
|
|
|
|
2007-06-10 19:04:12 +00:00
|
|
|
#include "packet-gsm_map-dis-tab.c" */
|
2007-10-31 21:24:16 +00:00
|
|
|
oid_add_from_string("ericsson-gsm-Map-Ext","1.2.826.0.1249.58.1.0" );
|
2007-10-31 23:11:15 +00:00
|
|
|
oid_add_from_string("accessTypeNotAllowed-id","1.3.12.2.1107.3.66.1.2");
|
|
|
|
/*oid_add_from_string("map-ac networkLocUp(1) version3(3)","0.4.0.0.1.0.1.3" );
|
2005-06-14 13:35:24 +00:00
|
|
|
*
|
|
|
|
* Register our configuration options, particularly our ssn:s
|
|
|
|
* Set default SSNs
|
|
|
|
*/
|
2005-03-17 22:08:09 +00:00
|
|
|
range_convert_str(&global_ssn_range, "6-9", MAX_SSN);
|
|
|
|
|
|
|
|
gsm_map_module = prefs_register_protocol(proto_gsm_map, proto_reg_handoff_gsm_map);
|
|
|
|
|
|
|
|
prefs_register_range_preference(gsm_map_module, "tcap.ssn", "TCAP SSNs",
|
2014-03-14 16:39:52 +00:00
|
|
|
"TCAP Subsystem numbers used for GSM MAP",
|
|
|
|
&global_ssn_range, MAX_SSN);
|
2012-07-10 11:39:06 +00:00
|
|
|
|
|
|
|
prefs_register_enum_preference(gsm_map_module, "application.context.version",
|
2014-03-14 16:39:52 +00:00
|
|
|
"Application context version",
|
|
|
|
"How to treat Application context",
|
|
|
|
&pref_application_context_version, application_context_modes, APPLICATON_CONTEXT_FROM_TRACE);
|
2012-07-10 11:39:06 +00:00
|
|
|
|
2012-08-21 09:32:04 +00:00
|
|
|
prefs_register_bool_preference(gsm_map_module, "ericsson.proprietary.extensions",
|
2014-03-14 16:39:52 +00:00
|
|
|
"Dissect Ericsson proprietary extensions",
|
|
|
|
"When enabled, dissector will use the non 3GPP standard extensions from Ericsson (that can override the standard ones)",
|
|
|
|
&pref_ericsson_proprietary_ext);
|
2004-11-02 01:19:23 +00:00
|
|
|
}
|