![Alexis La Goutte](/assets/img/avatar_default.png)
(Using sed : sed -i '/^ \* \$Id\$/,+1 d') Fix manually some typo (in export_object_dicom.c and crc16-plain.c) Change-Id: I4c1ae68d1c4afeace8cb195b53c715cf9e1227a8 Reviewed-on: https://code.wireshark.org/review/497 Reviewed-by: Anders Broman <a.broman58@gmail.com>
3649 lines
113 KiB
C
3649 lines
113 KiB
C
/* packet-gsm_sms.c
|
|
* Routines for GSM SMS TPDU (GSM 03.40) dissection
|
|
*
|
|
* Copyright 2003, Michael Lum <mlum [AT] telostech.com>
|
|
* In association with Telos Technology Inc.
|
|
*
|
|
* TPDU User-Data unpack routines from GNOKII.
|
|
*
|
|
* Reference [1]
|
|
* Universal Mobile Telecommunications System (UMTS);
|
|
* Technical realization of Short Message Service (SMS)
|
|
* (3GPP TS 23.040 version 5.4.0 Release 5)
|
|
*
|
|
* Header field support for TPDU Parameters added by
|
|
* Abhik Sarkar.
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <glib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/prefs.h>
|
|
#include <epan/reassemble.h>
|
|
#include <epan/to_str.h>
|
|
#include <epan/wmem/wmem.h>
|
|
|
|
#include "packet-gsm_sms.h"
|
|
|
|
void proto_register_gsm_sms(void);
|
|
|
|
#define MAX_SMS_FRAG_LEN 134
|
|
|
|
/* PROTOTYPES/FORWARDS */
|
|
|
|
#define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \
|
|
if ((edc_len) > (edc_max_len)) \
|
|
{ \
|
|
proto_tree_add_text(tree, tvb, \
|
|
offset, (edc_len) - (edc_max_len), "Extraneous Data"); \
|
|
}
|
|
|
|
#define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \
|
|
if ((sdc_len) < (sdc_min_len)) \
|
|
{ \
|
|
proto_tree_add_text(tree, tvb, \
|
|
offset, (sdc_len), "Short Data (?)"); \
|
|
return; \
|
|
}
|
|
|
|
#define EXACT_DATA_CHECK(edc_len, edc_eq_len) \
|
|
if ((edc_len) != (edc_eq_len)) \
|
|
{ \
|
|
proto_tree_add_text(tree, tvb, \
|
|
offset, (edc_len), "Unexpected Data Length"); \
|
|
return; \
|
|
}
|
|
|
|
#define SMS_SHIFTMASK(m_val, m_bitmask, m_sval); \
|
|
{ \
|
|
int _temp_val = m_val; \
|
|
int _temp_bm = m_bitmask; \
|
|
while (_temp_bm && !(_temp_bm & 0x01)) \
|
|
{ \
|
|
_temp_bm = _temp_bm >> 1; \
|
|
_temp_val = _temp_val >> 1; \
|
|
} \
|
|
m_sval = _temp_val; \
|
|
}
|
|
|
|
|
|
static const char *gsm_sms_proto_name = "GSM SMS TPDU (GSM 03.40)";
|
|
static const char *gsm_sms_proto_name_short = "GSM SMS";
|
|
|
|
/* Initialize the subtree pointers */
|
|
static gint ett_gsm_sms = -1;
|
|
static gint ett_pid = -1;
|
|
static gint ett_pi = -1;
|
|
static gint ett_fcs = -1;
|
|
static gint ett_vp = -1;
|
|
static gint ett_scts = -1;
|
|
static gint ett_dt = -1;
|
|
static gint ett_st = -1;
|
|
static gint ett_addr = -1;
|
|
static gint ett_dcs = -1;
|
|
static gint ett_ud = -1;
|
|
static gint ett_udh = -1;
|
|
|
|
static gint ett_udh_tfm = -1;
|
|
static gint ett_udh_tfc = -1;
|
|
|
|
/* Initialize the protocol and registered fields */
|
|
static int proto_gsm_sms = -1;
|
|
|
|
static gint hf_gsm_sms_coding_group_bits2 = -1;
|
|
static gint hf_gsm_sms_coding_group_bits4 = -1;
|
|
static gint hf_gsm_sms_ud_multiple_messages_msg_id = -1;
|
|
static gint hf_gsm_sms_ud_multiple_messages_msg_parts = -1;
|
|
static gint hf_gsm_sms_ud_multiple_messages_msg_part = -1;
|
|
|
|
/* TPDU Parameters */
|
|
static gint hf_gsm_sms_tp_mti_up = -1;
|
|
static gint hf_gsm_sms_tp_mti_down = -1;
|
|
static gint hf_gsm_sms_tp_mms = -1;
|
|
static gint hf_gsm_sms_tp_vpf = -1;
|
|
static gint hf_gsm_sms_tp_sri = -1;
|
|
static gint hf_gsm_sms_tp_srr = -1;
|
|
static gint hf_gsm_sms_tp_mr = -1;
|
|
static gint hf_gsm_sms_tp_oa = -1;
|
|
static gint hf_gsm_sms_tp_da = -1;
|
|
static gint hf_gsm_sms_tp_pid = -1;
|
|
static gint hf_gsm_sms_tp_dcs = -1;
|
|
static gint hf_gsm_sms_tp_ra = -1;
|
|
static gint hf_gsm_sms_tp_rp = -1;
|
|
static gint hf_gsm_sms_tp_udhi = -1;
|
|
static gint hf_gsm_sms_tp_rd = -1;
|
|
static gint hf_gsm_sms_tp_srq = -1;
|
|
static gint hf_gsm_sms_text = -1;
|
|
static gint hf_gsm_sms_tp_fail_cause = -1;
|
|
#if 0
|
|
static gint hf_gsm_sms_tp_scts = -1;
|
|
static gint hf_gsm_sms_tp_vp = -1;
|
|
static gint hf_gsm_sms_tp_dt = -1;
|
|
static gint hf_gsm_sms_tp_st = -1;
|
|
static gint hf_gsm_sms_tp_udl = -1;
|
|
static gint hf_gsm_sms_tp_mn = -1;
|
|
static gint hf_gsm_sms_tp_ct = -1;
|
|
static gint hf_gsm_sms_tp_cdl = -1;
|
|
static gint hf_gsm_sms_tp_cd = -1;
|
|
static gint hf_gsm_sms_tp_ud = -1;
|
|
#endif
|
|
|
|
static gboolean reassemble_sms = TRUE;
|
|
static char bigbuf[1024];
|
|
static proto_tree *g_tree;
|
|
|
|
/* 3GPP TS 23.038 version 7.0.0 Release 7
|
|
* The TP-Data-Coding-Scheme field, defined in 3GPP TS 23.040 [4],
|
|
* indicates the data coding scheme of the TP-UD field, and may indicate a message class.
|
|
* Any reserved codings shall be assumed to be the GSM 7 bit default alphabet
|
|
* (the same as codepoint 00000000) by a receiving entity.
|
|
* The octet is used according to a coding group which is indicated in bits 7..4.
|
|
*/
|
|
|
|
/* Coding Group Bits */
|
|
static const value_string gsm_sms_coding_group_bits_vals[] = {
|
|
{ 0, "General Data Coding indication" }, /* 00xx */
|
|
{ 1, "General Data Coding indication" }, /* 00xx */
|
|
{ 2, "General Data Coding indication" }, /* 00xx */
|
|
{ 3, "General Data Coding indication" }, /* 00xx */
|
|
{ 4, "Message Marked for Automatic Deletion Group" }, /* 01xx */
|
|
{ 5, "Message Marked for Automatic Deletion Group" }, /* 01xx */
|
|
{ 6, "Message Marked for Automatic Deletion Group" }, /* 01xx */
|
|
{ 7, "Message Marked for Automatic Deletion Group" }, /* 01xx */
|
|
{ 8, "Reserved coding groups" }, /* 1000..1011 */
|
|
{ 9, "Reserved coding groups" }, /* 1000..1011 */
|
|
{ 10, "Reserved coding groups" }, /* 1000..1011 */
|
|
{ 11, "Reserved coding groups" }, /* 1000..1011 */
|
|
{ 12, "Message Waiting Indication Group: Discard Message" }, /* 1100 */
|
|
{ 13, "Message Waiting Indication Group: Store Message" }, /* 1101 */
|
|
{ 14, "Message Waiting Indication Group: Store Message" }, /* 1110 */
|
|
{ 15, "Data coding/message class" }, /* 1111 */
|
|
{ 0, NULL },
|
|
};
|
|
static value_string_ext gsm_sms_coding_group_bits_vals_ext = VALUE_STRING_EXT_INIT(gsm_sms_coding_group_bits_vals);
|
|
|
|
static dissector_table_t gsm_sms_dissector_tbl;
|
|
/* Short Message reassembly */
|
|
static reassembly_table g_sm_reassembly_table;
|
|
static GHashTable *g_sm_fragment_params_table = NULL;
|
|
static gint ett_gsm_sms_ud_fragment = -1;
|
|
static gint ett_gsm_sms_ud_fragments = -1;
|
|
/*
|
|
* Short Message fragment handling
|
|
*/
|
|
static int hf_gsm_sms_ud_fragments = -1;
|
|
static int hf_gsm_sms_ud_fragment = -1;
|
|
static int hf_gsm_sms_ud_fragment_overlap = -1;
|
|
static int hf_gsm_sms_ud_fragment_overlap_conflicts = -1;
|
|
static int hf_gsm_sms_ud_fragment_multiple_tails = -1;
|
|
static int hf_gsm_sms_ud_fragment_too_long_fragment = -1;
|
|
static int hf_gsm_sms_ud_fragment_error = -1;
|
|
static int hf_gsm_sms_ud_fragment_count = -1;
|
|
static int hf_gsm_sms_ud_reassembled_in = -1;
|
|
static int hf_gsm_sms_ud_reassembled_length = -1;
|
|
|
|
static const fragment_items sm_frag_items = {
|
|
/* Fragment subtrees */
|
|
&ett_gsm_sms_ud_fragment,
|
|
&ett_gsm_sms_ud_fragments,
|
|
/* Fragment fields */
|
|
&hf_gsm_sms_ud_fragments,
|
|
&hf_gsm_sms_ud_fragment,
|
|
&hf_gsm_sms_ud_fragment_overlap,
|
|
&hf_gsm_sms_ud_fragment_overlap_conflicts,
|
|
&hf_gsm_sms_ud_fragment_multiple_tails,
|
|
&hf_gsm_sms_ud_fragment_too_long_fragment,
|
|
&hf_gsm_sms_ud_fragment_error,
|
|
&hf_gsm_sms_ud_fragment_count,
|
|
/* Reassembled in field */
|
|
&hf_gsm_sms_ud_reassembled_in,
|
|
/* Reassembled length field */
|
|
&hf_gsm_sms_ud_reassembled_length,
|
|
/* Reassembled data field */
|
|
NULL,
|
|
/* Tag */
|
|
"Short Message fragments"
|
|
};
|
|
|
|
typedef struct {
|
|
guint32 length;
|
|
guint8 udl;
|
|
guint8 fill_bits;
|
|
} sm_fragment_params;
|
|
|
|
static void
|
|
gsm_sms_defragment_init (void)
|
|
{
|
|
reassembly_table_init(&g_sm_reassembly_table,
|
|
&addresses_reassembly_table_functions);
|
|
if (g_sm_fragment_params_table) {
|
|
g_hash_table_destroy(g_sm_fragment_params_table);
|
|
}
|
|
g_sm_fragment_params_table = g_hash_table_new(g_direct_hash, g_direct_equal);
|
|
}
|
|
|
|
/*
|
|
* this is the GSM 03.40 definition with the bit 2
|
|
* set to 1 for uplink messages
|
|
*/
|
|
static const value_string msg_type_strings[] = {
|
|
{ 0, "SMS-DELIVER" },
|
|
{ 4, "SMS-DELIVER REPORT" },
|
|
{ 5, "SMS-SUBMIT" },
|
|
{ 1, "SMS-SUBMIT REPORT" },
|
|
{ 2, "SMS-STATUS REPORT" },
|
|
{ 6, "SMS-COMMAND" },
|
|
{ 3, "Reserved" },
|
|
{ 7, "Reserved" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const value_string msg_type_strings_sc_to_ms[] = {
|
|
{ 0, "SMS-DELIVER" },
|
|
{ 1, "SMS-SUBMIT REPORT" },
|
|
{ 2, "SMS-STATUS REPORT" },
|
|
{ 3, "Reserved" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const value_string msg_type_strings_ms_to_sc[] = {
|
|
{ 0, "SMS-DELIVER REPORT" },
|
|
{ 1, "SMS-SUBMIT" },
|
|
{ 2, "SMS-COMMAND" },
|
|
{ 3, "Reserved" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* 9.2.3.3 TP-Validity-Period-Format (TP-VPF) */
|
|
static const value_string vp_type_strings[] = {
|
|
{ 0, "TP-VP field not present"},
|
|
{ 2, "TP-VP field present - relative format"},
|
|
{ 1, "TP-VP field present - enhanced format"},
|
|
{ 3, "TP-VP field present - absolute format"},
|
|
{ 0, NULL },
|
|
};
|
|
|
|
static const true_false_string mms_bool_strings = {
|
|
"No more messages are waiting for the MS in this SC",
|
|
"More messages are waiting for the MS in this SC"
|
|
};
|
|
|
|
static const true_false_string sri_bool_strings = {
|
|
"A status report shall be returned to the SME",
|
|
"A status report shall not be returned to the SME"
|
|
};
|
|
|
|
static const true_false_string srr_bool_strings = {
|
|
"A status report is requested",
|
|
"A status report is not requested"
|
|
};
|
|
|
|
static const true_false_string udhi_bool_strings = {
|
|
"The beginning of the TP UD field contains a Header in addition to the short message",
|
|
"The TP UD field contains only the short message"
|
|
};
|
|
|
|
static const true_false_string rp_bool_strings = {
|
|
"TP Reply Path parameter is set in this SMS SUBMIT/DELIVER",
|
|
"TP Reply Path parameter is not set in this SMS SUBMIT/DELIVER"
|
|
};
|
|
|
|
static const true_false_string rd_bool_strings = {
|
|
"Instruct SC to reject duplicates",
|
|
"Instruct SC to accept duplicates"
|
|
};
|
|
|
|
static const true_false_string srq_bool_strings = {
|
|
"The SMS STATUS REPORT is the result of an SMS COMMAND e.g. an Enquiry.",
|
|
"SMS STATUS REPORT is the result of a SMS SUBMIT."
|
|
};
|
|
|
|
#define NUM_UDH_IEIS 256
|
|
static gint ett_udh_ieis[NUM_UDH_IEIS];
|
|
|
|
#define MAX_ADDR_SIZE 20
|
|
static void
|
|
dis_field_addr(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, const gchar *title)
|
|
{
|
|
static gchar digit_table[] = {"0123456789*#abc\0"};
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
const gchar *str = NULL;
|
|
guint8 oct;
|
|
guint32 offset;
|
|
guint32 numdigocts;
|
|
guint32 length, addrlength;
|
|
guint32 i, j;
|
|
gchar *addrstr;
|
|
|
|
offset = *offset_p;
|
|
|
|
addrlength = tvb_get_guint8(tvb, offset);
|
|
numdigocts = (addrlength + 1) / 2;
|
|
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
if (length <= numdigocts)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length,
|
|
"%s: Short Data (?)",
|
|
title);
|
|
|
|
*offset_p += length;
|
|
return;
|
|
}
|
|
|
|
item = proto_tree_add_text(tree, tvb,
|
|
offset, numdigocts + 2, "%s",
|
|
title);
|
|
|
|
subtree = proto_item_add_subtree(item, ett_addr);
|
|
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, 1,
|
|
"Length: %d address digits",
|
|
addrlength);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x80, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
(oct & 0x80) ? "No extension" : "Extended");
|
|
|
|
switch ((oct & 0x70) >> 4)
|
|
{
|
|
case 0x00: str = "Unknown"; break;
|
|
case 0x01: str = "International"; break;
|
|
case 0x02: str = "National"; break;
|
|
case 0x03: str = "Network specific"; break;
|
|
case 0x04: str = "Subscriber"; break;
|
|
case 0x05: str = "Alphanumeric (coded according to 3GPP TS 23.038 GSM 7-bit default alphabet)"; break;
|
|
case 0x06: str = "Abbreviated number"; break;
|
|
case 0x07: str = "Reserved for extension"; break;
|
|
default: str = "Unknown, reserved (?)"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x70, 8);
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, 1,
|
|
"%s : Type of number: (%d) %s",
|
|
bigbuf,
|
|
(oct & 0x70) >> 4,
|
|
str);
|
|
|
|
switch (oct & 0x0f)
|
|
{
|
|
case 0x00: str = "Unknown"; break;
|
|
case 0x01: str = "ISDN/telephone (E.164/E.163)"; break;
|
|
case 0x03: str = "Data numbering plan (X.121)"; break;
|
|
case 0x04: str = "Telex numbering plan"; break;
|
|
case 0x05: str = "Service Centre Specific plan"; break;
|
|
case 0x06: str = "Service Centre Specific plan"; break;
|
|
case 0x08: str = "National numbering plan"; break;
|
|
case 0x09: str = "Private numbering plan"; break;
|
|
case 0x0a: str = "ERMES numbering plan (ETSI DE/PS 3 01-3)"; break;
|
|
case 0x0f: str = "Reserved for extension"; break;
|
|
default: str = "Unknown, reserved (?)"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x0f, 8);
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, 1,
|
|
"%s : Numbering plan: (%d) %s",
|
|
bigbuf,
|
|
oct & 0x0f,
|
|
str);
|
|
|
|
offset++;
|
|
|
|
j = 0;
|
|
switch ((oct & 0x70) >> 4)
|
|
{
|
|
case 0x05: /* "Alphanumeric (coded according to 3GPP TS 23.038 GSM 7-bit default alphabet)" */
|
|
addrlength = (addrlength << 2) / 7;
|
|
addrstr = tvb_get_ts_23_038_7bits_string(wmem_packet_scope(), tvb, offset << 3,
|
|
(addrlength > MAX_ADDR_SIZE) ? MAX_ADDR_SIZE : addrlength);
|
|
break;
|
|
default:
|
|
addrstr = (gchar *)wmem_alloc(wmem_packet_scope(), numdigocts*2 + 1);
|
|
for (i = 0; i < numdigocts; i++)
|
|
{
|
|
oct = tvb_get_guint8(tvb, offset + i);
|
|
|
|
addrstr[j++] = digit_table[oct & 0x0f];
|
|
addrstr[j++] = digit_table[(oct & 0xf0) >> 4];
|
|
}
|
|
addrstr[j++] = '\0';
|
|
break;
|
|
}
|
|
|
|
if (g_ascii_strncasecmp(title, "TP-O", 4) == 0) {
|
|
proto_tree_add_string(subtree, hf_gsm_sms_tp_oa, tvb,
|
|
offset, numdigocts, addrstr);
|
|
} else if (g_ascii_strncasecmp(title, "TP-D", 4) == 0) {
|
|
proto_tree_add_string(subtree, hf_gsm_sms_tp_da, tvb,
|
|
offset, numdigocts, addrstr);
|
|
} else if (g_ascii_strncasecmp(title, "TP-R", 4) == 0) {
|
|
proto_tree_add_string(subtree, hf_gsm_sms_tp_ra, tvb,
|
|
offset, numdigocts, addrstr);
|
|
} else {
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, numdigocts, "Digits: %s", addrstr);
|
|
}
|
|
|
|
proto_item_append_text(item, " - (%s)", addrstr);
|
|
|
|
*offset_p = offset + numdigocts;
|
|
}
|
|
|
|
/* 9.2.3.7 */
|
|
/* use dis_field_addr() */
|
|
|
|
/* 9.2.3.8 */
|
|
/* use dis_field_addr() */
|
|
|
|
/* 9.2.3.9 */
|
|
static void
|
|
dis_field_pid(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 oct)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
guint8 form;
|
|
guint8 telematic;
|
|
const gchar *str = NULL;
|
|
|
|
|
|
item = proto_tree_add_item(tree, hf_gsm_sms_tp_pid, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
subtree = proto_item_add_subtree(item, ett_pid);
|
|
|
|
form = (oct & 0xc0) >> 6;
|
|
|
|
switch (form)
|
|
{
|
|
case 0:
|
|
other_decode_bitfield_value(bigbuf, oct, 0xc0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : defines formatting for subsequent bits",
|
|
bigbuf);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x20, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
(oct & 0x20) ?
|
|
"telematic interworking" :
|
|
"no telematic interworking, but SME-to-SME protocol");
|
|
|
|
if (oct & 0x20)
|
|
{
|
|
telematic = oct & 0x1f;
|
|
|
|
switch (telematic)
|
|
{
|
|
case 0x00: str = "implicit - device type is specific to this SC, or can be concluded on the basis of the address"; break;
|
|
case 0x01: str = "telex (or teletex reduced to telex format)"; break;
|
|
case 0x02: str = "group 3 telefax"; break;
|
|
case 0x03: str = "group 4 telefax"; break;
|
|
case 0x04: str = "voice telephone (i.e. conversion to speech)"; break;
|
|
case 0x05: str = "ERMES (European Radio Messaging System)"; break;
|
|
case 0x06: str = "National Paging system (known to the SC)"; break;
|
|
case 0x07: str = "Videotex (T.100 [20] /T.101 [21])"; break;
|
|
case 0x08: str = "teletex, carrier unspecified"; break;
|
|
case 0x09: str = "teletex, in PSPDN"; break;
|
|
case 0x0a: str = "teletex, in CSPDN"; break;
|
|
case 0x0b: str = "teletex, in analog PSTN"; break;
|
|
case 0x0c: str = "teletex, in digital ISDN"; break;
|
|
case 0x0d: str = "UCI (Universal Computer Interface, ETSI DE/PS 3 01-3)"; break;
|
|
case 0x10: str = "a message handling facility (known to the SC)"; break;
|
|
case 0x11: str = "any public X.400-based message handling system"; break;
|
|
case 0x12: str = "Internet Electronic Mail"; break;
|
|
case 0x1f: str = "A GSM/UMTS mobile station"; break;
|
|
default:
|
|
if ((telematic >= 0x18) &&
|
|
(telematic <= 0x1e))
|
|
{
|
|
str = "values specific to each SC";
|
|
}
|
|
else
|
|
{
|
|
str = "reserved";
|
|
}
|
|
break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x1f, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : device type: (%d) %s",
|
|
bigbuf,
|
|
telematic,
|
|
str);
|
|
}
|
|
else
|
|
{
|
|
other_decode_bitfield_value(bigbuf, oct, 0x1f, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : the SM-AL protocol being used between the SME and the MS (%d)",
|
|
bigbuf,
|
|
oct & 0x1f);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
other_decode_bitfield_value(bigbuf, oct, 0xc0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : defines formatting for subsequent bits",
|
|
bigbuf);
|
|
|
|
switch (oct & 0x3f)
|
|
{
|
|
case 0x00: str = "Short Message Type 0"; break;
|
|
case 0x01: str = "Replace Short Message Type 1"; break;
|
|
case 0x02: str = "Replace Short Message Type 2"; break;
|
|
case 0x03: str = "Replace Short Message Type 3"; break;
|
|
case 0x04: str = "Replace Short Message Type 4"; break;
|
|
case 0x05: str = "Replace Short Message Type 5"; break;
|
|
case 0x06: str = "Replace Short Message Type 6"; break;
|
|
case 0x07: str = "Replace Short Message Type 7"; break;
|
|
case 0x1e: str = "Enhanced Message Service (Obsolete)"; break;
|
|
case 0x1f: str = "Return Call Message"; break;
|
|
case 0x3c: str = "ANSI-136 R-DATA"; break;
|
|
case 0x3d: str = "ME Data download"; break;
|
|
case 0x3e: str = "ME De-personalization Short Message"; break;
|
|
case 0x3f: str = "(U)SIM Data download"; break;
|
|
default:
|
|
str = "Reserved"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x3f, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : (%d) %s",
|
|
bigbuf,
|
|
oct & 0x3f,
|
|
str);
|
|
break;
|
|
|
|
case 2:
|
|
other_decode_bitfield_value(bigbuf, oct, 0xc0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Reserved",
|
|
bigbuf);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x3f, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : undefined",
|
|
bigbuf);
|
|
break;
|
|
|
|
case 3:
|
|
other_decode_bitfield_value(bigbuf, oct, 0xc0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : bits 0-5 for SC specific use",
|
|
bigbuf);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x3f, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : SC specific",
|
|
bigbuf);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* 9.2.3.10 */
|
|
static void
|
|
dis_field_dcs(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 oct,
|
|
gboolean *seven_bit, gboolean *eight_bit, gboolean *ucs2, gboolean *compressed)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
guint8 form;
|
|
const gchar *str = NULL;
|
|
gboolean default_5_bits;
|
|
gboolean default_3_bits;
|
|
gboolean default_data;
|
|
|
|
|
|
*seven_bit = FALSE;
|
|
*eight_bit = FALSE;
|
|
*ucs2 = FALSE;
|
|
*compressed = FALSE;
|
|
|
|
item = proto_tree_add_item(tree, hf_gsm_sms_tp_dcs, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
subtree = proto_item_add_subtree(item, ett_dcs);
|
|
if (oct&0x80) {
|
|
proto_tree_add_item(subtree, hf_gsm_sms_coding_group_bits4, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
} else {
|
|
proto_tree_add_item(subtree, hf_gsm_sms_coding_group_bits2, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
if (oct == 0x00)
|
|
{
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"Special case, GSM 7 bit default alphabet");
|
|
|
|
*seven_bit = TRUE;
|
|
return;
|
|
}
|
|
|
|
default_5_bits = FALSE;
|
|
default_3_bits = FALSE;
|
|
default_data = FALSE;
|
|
form = (oct & 0xc0) >> 6;
|
|
|
|
switch (form)
|
|
{
|
|
case 0:
|
|
other_decode_bitfield_value(bigbuf, oct, 0xc0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : General Data Coding indication",
|
|
bigbuf);
|
|
|
|
default_5_bits = TRUE;
|
|
break;
|
|
|
|
case 1:
|
|
other_decode_bitfield_value(bigbuf, oct, 0xc0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Message Marked for Automatic Deletion Group",
|
|
bigbuf);
|
|
|
|
default_5_bits = TRUE;
|
|
break;
|
|
|
|
case 2:
|
|
/* use top four bits */
|
|
other_decode_bitfield_value(bigbuf, oct, 0xf0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Reserved coding groups",
|
|
bigbuf);
|
|
return;
|
|
|
|
case 3:
|
|
switch ((oct & 0x30) >> 4)
|
|
{
|
|
case 0x00: str = "Message Waiting Indication Group: Discard Message (GSM 7 bit default alphabet)";
|
|
default_3_bits = TRUE;
|
|
*seven_bit = TRUE;
|
|
break;
|
|
case 0x01: str = "Message Waiting Indication Group: Store Message (GSM 7 bit default alphabet)";
|
|
default_3_bits = TRUE;
|
|
*seven_bit = TRUE;
|
|
break;
|
|
case 0x02: str = "Message Waiting Indication Group: Store Message (uncompressed UCS2 alphabet)";
|
|
default_3_bits = TRUE;
|
|
break;
|
|
case 0x03: str = "Data coding/message class";
|
|
default_data = TRUE;
|
|
break;
|
|
}
|
|
|
|
/* use top four bits */
|
|
other_decode_bitfield_value(bigbuf, oct, 0xf0, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
str);
|
|
break;
|
|
}
|
|
|
|
if (default_5_bits)
|
|
{
|
|
other_decode_bitfield_value(bigbuf, oct, 0x20, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Text is %scompressed",
|
|
bigbuf,
|
|
(oct & 0x20) ? "" : "not ");
|
|
|
|
*compressed = (oct & 0x20) >> 5;
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x10, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
(oct & 0x10) ? "Message class is defined below" :
|
|
"Reserved, no message class");
|
|
|
|
switch ((oct & 0x0c) >> 2)
|
|
{
|
|
case 0x00: str = "GSM 7 bit default alphabet";
|
|
*seven_bit = TRUE;
|
|
break;
|
|
case 0x01: str = "8 bit data";
|
|
*eight_bit = TRUE;
|
|
break;
|
|
case 0x02: str = "UCS2 (16 bit)";
|
|
*ucs2 = TRUE;
|
|
break;
|
|
case 0x03: str = "Reserved"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x0c, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Character set: %s",
|
|
bigbuf,
|
|
str);
|
|
|
|
switch (oct & 0x03)
|
|
{
|
|
case 0x00: str = "Class 0"; break;
|
|
case 0x01: str = "Class 1 Default meaning: ME-specific"; break;
|
|
case 0x02: str = "Class 2 (U)SIM specific message"; break;
|
|
case 0x03: str = "Class 3 Default meaning: TE-specific"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x03, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Message Class: %s%s",
|
|
bigbuf,
|
|
str,
|
|
(oct & 0x10) ? "" : " (reserved)");
|
|
}
|
|
else if (default_3_bits)
|
|
{
|
|
other_decode_bitfield_value(bigbuf, oct, 0x08, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Indication Sense: %s",
|
|
bigbuf,
|
|
(oct & 0x08) ? "Set Indication Active" : "Set Indication Inactive");
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x04, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Reserved",
|
|
bigbuf);
|
|
|
|
switch (oct & 0x03)
|
|
{
|
|
case 0x00: str = "Voicemail Message Waiting"; break;
|
|
case 0x01: str = "Fax Message Waiting"; break;
|
|
case 0x02: str = "Electronic Mail Message Waiting"; break;
|
|
case 0x03: str = "Other Message Waiting"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x03, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
str);
|
|
}
|
|
else if (default_data)
|
|
{
|
|
other_decode_bitfield_value(bigbuf, oct, 0x08, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Reserved",
|
|
bigbuf);
|
|
|
|
*seven_bit = !(*eight_bit = (oct & 0x04) ? TRUE : FALSE);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x04, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Message coding: %s",
|
|
bigbuf,
|
|
(*eight_bit) ? "8 bit data" : "GSM 7 bit default alphabet");
|
|
|
|
switch (oct & 0x03)
|
|
{
|
|
case 0x00: str = "Class 0"; break;
|
|
case 0x01: str = "Class 1 Default meaning: ME-specific"; break;
|
|
case 0x02: str = "Class 2 (U)SIM specific message"; break;
|
|
case 0x03: str = "Class 3 Default meaning: TE-specific"; break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x03, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Message Class: %s",
|
|
bigbuf,
|
|
str);
|
|
}
|
|
}
|
|
|
|
static void
|
|
dis_field_scts_aux(tvbuff_t *tvb, proto_tree *tree, guint32 offset)
|
|
{
|
|
guint8 oct, oct2, oct3;
|
|
char sign;
|
|
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
oct2 = tvb_get_guint8(tvb, offset+1);
|
|
oct3 = tvb_get_guint8(tvb, offset+2);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 3,
|
|
"Year %d%d, Month %d%d, Day %d%d",
|
|
oct & 0x0f,
|
|
(oct & 0xf0) >> 4,
|
|
oct2 & 0x0f,
|
|
(oct2 & 0xf0) >> 4,
|
|
oct3 & 0x0f,
|
|
(oct3 & 0xf0) >> 4);
|
|
|
|
offset += 3;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
oct2 = tvb_get_guint8(tvb, offset+1);
|
|
oct3 = tvb_get_guint8(tvb, offset+2);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 3,
|
|
"Hour %d%d, Minutes %d%d, Seconds %d%d",
|
|
oct & 0x0f,
|
|
(oct & 0xf0) >> 4,
|
|
oct2 & 0x0f,
|
|
(oct2 & 0xf0) >> 4,
|
|
oct3 & 0x0f,
|
|
(oct3 & 0xf0) >> 4);
|
|
|
|
offset += 3;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
sign = (oct & 0x08)?'-':'+';
|
|
oct = (oct >> 4) + (oct & 0x07) * 10;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Timezone: GMT %c %d hours %d minutes",
|
|
sign, oct / 4, oct % 4 * 15);
|
|
}
|
|
|
|
/* 9.2.3.11 */
|
|
static void
|
|
dis_field_scts(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
guint32 offset;
|
|
guint32 length;
|
|
|
|
|
|
offset = *offset_p;
|
|
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
if (length < 7)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length,
|
|
"TP-Service-Centre-Time-Stamp: Short Data (?)");
|
|
|
|
*offset_p += length;
|
|
return;
|
|
}
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, 7,
|
|
"TP-Service-Centre-Time-Stamp");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_scts);
|
|
|
|
dis_field_scts_aux(tvb, subtree, *offset_p);
|
|
|
|
*offset_p += 7;
|
|
}
|
|
|
|
/* 9.2.3.12 */
|
|
static void
|
|
dis_field_vp(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 vp_form)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
guint32 offset;
|
|
guint32 length;
|
|
guint8 oct, oct2, oct3;
|
|
guint8 loc_form;
|
|
guint32 mins, hours;
|
|
gboolean done;
|
|
|
|
|
|
if (vp_form == 0x00) return;
|
|
|
|
offset = *offset_p;
|
|
subtree = tree;
|
|
|
|
done = FALSE;
|
|
do
|
|
{
|
|
switch (vp_form)
|
|
{
|
|
case 1:
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
if (length < 7)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length,
|
|
"TP-Validity-Period: Short Data (?)");
|
|
|
|
*offset_p += length;
|
|
return;
|
|
}
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, 7,
|
|
"TP-Validity-Period");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_vp);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x80, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
(oct & 0x80) ? "Extended" : "No extension");
|
|
|
|
if (oct & 0x80)
|
|
{
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset + 1, 6,
|
|
"Extension not implemented, ignored");
|
|
|
|
*offset_p += 7;
|
|
return;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x40, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
(oct & 0x40) ? "Single shot SM" : "Not single shot SM");
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x38, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Reserved",
|
|
bigbuf);
|
|
|
|
loc_form = oct & 0x7;
|
|
|
|
switch (loc_form)
|
|
{
|
|
case 0x00:
|
|
other_decode_bitfield_value(bigbuf, oct, 0x07, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : No Validity Period specified",
|
|
bigbuf);
|
|
|
|
done = TRUE;
|
|
break;
|
|
|
|
case 0x01:
|
|
other_decode_bitfield_value(bigbuf, oct, 0x07, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Validity Period Format: relative",
|
|
bigbuf);
|
|
|
|
offset++;
|
|
/* go around again */
|
|
vp_form = 2;
|
|
break;
|
|
|
|
case 0x02:
|
|
other_decode_bitfield_value(bigbuf, oct, 0x07, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Validity Period Format: relative",
|
|
bigbuf);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%d seconds",
|
|
oct);
|
|
|
|
done = TRUE;
|
|
break;
|
|
|
|
case 0x03:
|
|
other_decode_bitfield_value(bigbuf, oct, 0x07, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Validity Period Format: relative",
|
|
bigbuf);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
oct2 = tvb_get_guint8(tvb, offset+1);
|
|
oct3 = tvb_get_guint8(tvb, offset+2);
|
|
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, 3,
|
|
"Hour %d%d, Minutes %d%d, Seconds %d%d",
|
|
oct & 0x0f,
|
|
(oct & 0xf0) >> 4,
|
|
oct2 & 0x0f,
|
|
(oct2 & 0xf0) >> 4,
|
|
oct3 & 0x0f,
|
|
(oct3 & 0xf0) >> 4);
|
|
|
|
done = TRUE;
|
|
break;
|
|
|
|
default:
|
|
other_decode_bitfield_value(bigbuf, oct, 0x07, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Validity Period Format: Reserved",
|
|
bigbuf);
|
|
|
|
done = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
if (oct <= 143)
|
|
{
|
|
mins = (oct + 1) * 5;
|
|
if (mins >= 60)
|
|
{
|
|
hours = mins / 60;
|
|
mins %= 60;
|
|
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"TP-Validity-Period: %d hours %d minutes",
|
|
hours,
|
|
mins);
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"TP-Validity-Period: %d minutes",
|
|
mins);
|
|
}
|
|
}
|
|
else if ((oct >= 144) &&
|
|
(oct <= 167))
|
|
{
|
|
mins = (oct - 143) * 30;
|
|
hours = 12 + (mins / 60);
|
|
mins %= 60;
|
|
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"TP-Validity-Period: %d hours %d minutes",
|
|
hours,
|
|
mins);
|
|
}
|
|
else if ((oct >= 168) &&
|
|
(oct <= 196))
|
|
{
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"TP-Validity-Period: %d day(s)",
|
|
oct - 166);
|
|
}
|
|
else if (oct >= 197)
|
|
{
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"TP-Validity-Period: %d week(s)",
|
|
oct - 192);
|
|
}
|
|
|
|
done = TRUE;
|
|
break;
|
|
|
|
case 3:
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
if (length < 7)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length,
|
|
"TP-Validity-Period: Short Data (?)");
|
|
|
|
*offset_p += length;
|
|
return;
|
|
}
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, 7,
|
|
"TP-Validity-Period: absolute");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_vp);
|
|
|
|
dis_field_scts_aux(tvb, subtree, *offset_p);
|
|
|
|
done = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
while (!done);
|
|
|
|
if (vp_form == 2)
|
|
{
|
|
(*offset_p)++;
|
|
}
|
|
else
|
|
{
|
|
*offset_p += 7;
|
|
}
|
|
}
|
|
|
|
/* 9.2.3.13 */
|
|
static void
|
|
dis_field_dt(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
guint32 offset;
|
|
guint32 length;
|
|
|
|
|
|
offset = *offset_p;
|
|
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
if (length < 7)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length,
|
|
"TP-Discharge-Time: Short Data (?)");
|
|
|
|
*offset_p += length;
|
|
return;
|
|
}
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, 7,
|
|
"TP-Discharge-Time");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_dt);
|
|
|
|
dis_field_scts_aux(tvb, subtree, *offset_p);
|
|
|
|
*offset_p += 7;
|
|
}
|
|
|
|
/* 9.2.3.14 */
|
|
/* use dis_field_addr() */
|
|
|
|
/* 9.2.3.15 */
|
|
static void
|
|
dis_field_st(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 oct)
|
|
{
|
|
static const gchar *sc_complete = "Short message transaction completed";
|
|
static const gchar *sc_temporary = "Temporary error, SC still trying to transfer SM";
|
|
static const gchar *sc_perm = "Permanent error, SC is not making any more transfer attempts";
|
|
static const gchar *sc_tempfin = "Temporary error, SC is not making any more transfer attempts";
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
guint8 value;
|
|
const gchar *str = NULL;
|
|
const gchar *str2 = NULL;
|
|
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, 1,
|
|
"TP-Status");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_st);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x80, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Definition of bits 0-6: %s",
|
|
bigbuf,
|
|
(oct & 0x80) ? "Reserved" : "as follows");
|
|
|
|
value = oct & 0x7f;
|
|
|
|
switch (value)
|
|
{
|
|
case 0x00: str2 = sc_complete; str = "Short message received by the SME"; break;
|
|
case 0x01: str2 = sc_complete; str = "Short message forwarded by the SC to the SME but the SC is unable to confirm delivery"; break;
|
|
case 0x02: str2 = sc_complete; str = "Short message replaced by the SC Reserved values"; break;
|
|
|
|
case 0x20: str2 = sc_temporary; str = "Congestion"; break;
|
|
case 0x21: str2 = sc_temporary; str = "SME busy"; break;
|
|
case 0x22: str2 = sc_temporary; str = "No response from SME"; break;
|
|
case 0x23: str2 = sc_temporary; str = "Service rejected"; break;
|
|
case 0x24: str2 = sc_temporary; str = "Quality of service not available"; break;
|
|
case 0x25: str2 = sc_temporary; str = "Error in SME"; break;
|
|
|
|
case 0x40: str2 = sc_perm; str = "Remote procedure error"; break;
|
|
case 0x41: str2 = sc_perm; str = "Incompatible destination"; break;
|
|
case 0x42: str2 = sc_perm; str = "Connection rejected by SME"; break;
|
|
case 0x43: str2 = sc_perm; str = "Not obtainable"; break;
|
|
case 0x44: str2 = sc_perm; str = "Quality of service not available"; break;
|
|
case 0x45: str2 = sc_perm; str = "No interworking available"; break;
|
|
case 0x46: str2 = sc_perm; str = "SM Validity Period Expired"; break;
|
|
case 0x47: str2 = sc_perm; str = "SM Deleted by originating SME"; break;
|
|
case 0x48: str2 = sc_perm; str = "SM Deleted by SC Administration"; break;
|
|
case 0x49: str2 = sc_perm; str = "SM does not exist (The SM may have previously existed in the SC but the SC no longer has knowledge of it or the SM may never have previously existed in the SC)"; break;
|
|
|
|
case 0x60: str2 = sc_tempfin; str = "Congestion"; break;
|
|
case 0x61: str2 = sc_tempfin; str = "SME busy"; break;
|
|
case 0x62: str2 = sc_tempfin; str = "No response from SME"; break;
|
|
case 0x63: str2 = sc_tempfin; str = "Service rejected"; break;
|
|
case 0x64: str2 = sc_tempfin; str = "Quality of service not available"; break;
|
|
case 0x65: str2 = sc_tempfin; str = "Error in SME"; break;
|
|
|
|
default:
|
|
if ((value >= 0x03) &&
|
|
(value <= 0x0f))
|
|
{
|
|
str2 = sc_complete;
|
|
str = "Reserved";
|
|
}
|
|
else if ((value >= 0x10) &&
|
|
(value <= 0x1f))
|
|
{
|
|
str2 = sc_complete;
|
|
str = "Values specific to each SC";
|
|
}
|
|
else if ((value >= 0x26) &&
|
|
(value <= 0x2f))
|
|
{
|
|
str2 = sc_temporary;
|
|
str = "Reserved";
|
|
}
|
|
else if ((value >= 0x30) &&
|
|
(value <= 0x3f))
|
|
{
|
|
str2 = sc_temporary;
|
|
str = "Values specific to each SC";
|
|
}
|
|
else if ((value >= 0x4a) &&
|
|
(value <= 0x4f))
|
|
{
|
|
str2 = sc_perm;
|
|
str = "Reserved";
|
|
}
|
|
else if ((value >= 0x50) &&
|
|
(value <= 0x5f))
|
|
{
|
|
str2 = sc_perm;
|
|
str = "Values specific to each SC";
|
|
}
|
|
else if ((value >= 0x66) &&
|
|
(value <= 0x6f))
|
|
{
|
|
str2 = sc_tempfin;
|
|
str = "Reserved";
|
|
}
|
|
else if ((value >= 0x70) &&
|
|
(value <= 0x7f))
|
|
{
|
|
str2 = sc_tempfin;
|
|
str = "Values specific to each SC";
|
|
}
|
|
break;
|
|
}
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x7f, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : (%d) %s, %s",
|
|
bigbuf,
|
|
value,
|
|
str2,
|
|
str);
|
|
}
|
|
|
|
/* 9.2.3.16 */
|
|
#define DIS_FIELD_UDL(m_tree, m_offset) \
|
|
{ \
|
|
proto_tree_add_text(m_tree, tvb, \
|
|
m_offset, 1, \
|
|
"TP-User-Data-Length: (%d) %s", \
|
|
oct, \
|
|
oct ? "depends on Data-Coding-Scheme" : "no User-Data");\
|
|
}
|
|
|
|
/* 9.2.3.17 */
|
|
#define DIS_FIELD_RP(m_tree, m_bitmask, m_offset) \
|
|
{ \
|
|
other_decode_bitfield_value(bigbuf, oct, m_bitmask, 8); \
|
|
proto_tree_add_text(m_tree, tvb, \
|
|
m_offset, 1, \
|
|
"%s : TP-Reply-Path: parameter is %sset in this SMS-SUBMIT/DELIVER", \
|
|
bigbuf, \
|
|
(oct & m_bitmask) ? "" : "not "); \
|
|
}
|
|
|
|
/* 9.2.3.18 */
|
|
#define DIS_FIELD_MN(m_tree, m_offset) \
|
|
{ \
|
|
proto_tree_add_text(m_tree, tvb, \
|
|
m_offset, 1, \
|
|
"TP-Message-Number: %d", \
|
|
oct); \
|
|
}
|
|
|
|
/* 9.2.3.19 */
|
|
#define DIS_FIELD_CT(m_tree, m_offset) \
|
|
{ \
|
|
switch (oct) \
|
|
{ \
|
|
case 0: str = "Enquiry relating to previously submitted short message"; break; \
|
|
case 1: str = "Cancel Status Report Request relating to previously submitted short message"; break; \
|
|
case 2: str = "Delete previously submitted Short Message"; break; \
|
|
case 3: str = "Enable Status Report Request relating to previously submitted short message"; break; \
|
|
default: \
|
|
if ((oct >= 0x04) && \
|
|
(oct <= 0x1f)) \
|
|
{ \
|
|
str = "Reserved unspecified"; \
|
|
} \
|
|
else if (oct >= 0xe0) \
|
|
{ \
|
|
str = "Values specific for each SC"; \
|
|
} \
|
|
else \
|
|
{ \
|
|
str = "undefined"; \
|
|
} \
|
|
break; \
|
|
} \
|
|
proto_tree_add_text(m_tree, tvb, \
|
|
m_offset, 1, \
|
|
"TP-Command-Type: (%d), %s", \
|
|
oct, \
|
|
str); \
|
|
}
|
|
|
|
/* 9.2.3.20 */
|
|
#define DIS_FIELD_CDL(m_tree, m_offset) \
|
|
{ \
|
|
proto_tree_add_text(m_tree, tvb, \
|
|
m_offset, 1, \
|
|
"TP-Command-Data-Length: (%d)%s", \
|
|
oct, \
|
|
oct ? "" : " no Command-Data");\
|
|
}
|
|
|
|
/* 9.2.3.21 */
|
|
/* done in-line in the message functions */
|
|
|
|
/*
|
|
* 9.2.3.22 TP-Failure-Cause (TP-FCS)
|
|
*/
|
|
|
|
|
|
static const value_string gsm_sms_tp_failure_cause_values[] = {
|
|
/* 00 - 7F Reserved */
|
|
/* 80 - 8F TP-PID errors */
|
|
{ 0x80, "Telematic interworking not supported" },
|
|
{ 0x81, "Short message Type 0 not supported" },
|
|
{ 0x82, "Cannot replace short message" },
|
|
/* 83 - 8E Reserved */
|
|
{ 0x83, "Reserved" },
|
|
{ 0x84, "Reserved" },
|
|
{ 0x85, "Reserved" },
|
|
{ 0x86, "Reserved" },
|
|
{ 0x87, "Reserved" },
|
|
{ 0x88, "Reserved" },
|
|
{ 0x89, "Reserved" },
|
|
{ 0x8a, "Reserved" },
|
|
{ 0x8b, "Reserved" },
|
|
{ 0x8c, "Reserved" },
|
|
{ 0x8d, "Reserved" },
|
|
{ 0x8e, "Reserved" },
|
|
|
|
{ 0x8F, "Unspecified TP-PID error" },
|
|
/* 90 - 9F TP-DCS errors */
|
|
{ 0x90, "Data coding scheme (alphabet) not supported" },
|
|
{ 0x91, "Message class not supported" },
|
|
/* 92 - 9E Reserved */
|
|
{ 0x92, "Reserved" },
|
|
{ 0x93, "Reserved" },
|
|
{ 0x94, "Reserved" },
|
|
{ 0x95, "Reserved" },
|
|
{ 0x96, "Reserved" },
|
|
{ 0x97, "Reserved" },
|
|
{ 0x98, "Reserved" },
|
|
{ 0x99, "Reserved" },
|
|
{ 0x9a, "Reserved" },
|
|
{ 0x9b, "Reserved" },
|
|
{ 0x9c, "Reserved" },
|
|
{ 0x9d, "Reserved" },
|
|
{ 0x9e, "Reserved" },
|
|
|
|
{ 0x9F, "Unspecified TP-DCS error" },
|
|
/* A0 - AF TP-Command Errors */
|
|
{ 0xA0, "Command cannot be actioned" },
|
|
{ 0xA1, "Command unsupported" },
|
|
/* A2 - AE Reserved */
|
|
{ 0xa2, "Reserved" },
|
|
{ 0xa3, "Reserved" },
|
|
{ 0xa4, "Reserved" },
|
|
{ 0xa5, "Reserved" },
|
|
{ 0xa6, "Reserved" },
|
|
{ 0xa7, "Reserved" },
|
|
{ 0xa8, "Reserved" },
|
|
{ 0xa9, "Reserved" },
|
|
{ 0xaa, "Reserved" },
|
|
{ 0xab, "Reserved" },
|
|
{ 0xac, "Reserved" },
|
|
{ 0xad, "Reserved" },
|
|
{ 0xae, "Reserved" },
|
|
|
|
{ 0xAF, "Unspecified TP-Command error" },
|
|
{ 0xB0, "TPDU not supported" },
|
|
/* B1 - BF Reserved */
|
|
{ 0xb1, "Reserved" },
|
|
{ 0xb2, "Reserved" },
|
|
{ 0xb3, "Reserved" },
|
|
{ 0xb4, "Reserved" },
|
|
{ 0xb5, "Reserved" },
|
|
{ 0xb6, "Reserved" },
|
|
{ 0xb7, "Reserved" },
|
|
{ 0xb8, "Reserved" },
|
|
{ 0xb9, "Reserved" },
|
|
{ 0xba, "Reserved" },
|
|
{ 0xbb, "Reserved" },
|
|
{ 0xbc, "Reserved" },
|
|
{ 0xbd, "Reserved" },
|
|
{ 0xbe, "Reserved" },
|
|
{ 0xbf, "Reserved" },
|
|
|
|
{ 0xC0, "SC busy" },
|
|
{ 0xC1, "No SC subscription" },
|
|
{ 0xC2, "SC system failure" },
|
|
{ 0xC3, "Invalid SME address" },
|
|
{ 0xC4, "Destination SME barred" },
|
|
{ 0xC5, "SM Rejected-Duplicate SM" },
|
|
{ 0xC6, "TP-VPF not supported" },
|
|
{ 0xC7, "TP-VP not supported" },
|
|
/* C8 - CF Reserved */
|
|
{ 0xc8, "Reserved" },
|
|
{ 0xc9, "Reserved" },
|
|
{ 0xca, "Reserved" },
|
|
{ 0xcb, "Reserved" },
|
|
{ 0xcc, "Reserved" },
|
|
{ 0xcd, "Reserved" },
|
|
{ 0xce, "Reserved" },
|
|
{ 0xcf, "Reserved" },
|
|
|
|
{ 0xD0, "(U)SIM SMS storage full" },
|
|
{ 0xD1, "No SMS storage capability in (U)SIM" },
|
|
{ 0xD2, "Error in MS" },
|
|
{ 0xD3, "Memory Capacity Exceeded" },
|
|
{ 0xD4, "(U)SIM Application Toolkit Busy" },
|
|
{ 0xD5, "(U)SIM data download error" },
|
|
/* D6 - DF Reserved */
|
|
{ 0xd6, "Reserved" },
|
|
{ 0xd7, "Reserved" },
|
|
{ 0xd8, "Reserved" },
|
|
{ 0xd9, "Reserved" },
|
|
{ 0xda, "Reserved" },
|
|
{ 0xdb, "Reserved" },
|
|
{ 0xdc, "Reserved" },
|
|
{ 0xdd, "Reserved" },
|
|
{ 0xde, "Reserved" },
|
|
{ 0xdf, "Reserved" },
|
|
|
|
/* E0 - FE Values specific to an application */
|
|
{ 0xe0, "Value specific to an application" },
|
|
{ 0xe1, "Value specific to an application" },
|
|
{ 0xe2, "Value specific to an application" },
|
|
{ 0xe3, "Value specific to an application" },
|
|
{ 0xe4, "Value specific to an application" },
|
|
{ 0xe5, "Value specific to an application" },
|
|
{ 0xe6, "Value specific to an application" },
|
|
{ 0xe7, "Value specific to an application" },
|
|
{ 0xe8, "Value specific to an application" },
|
|
{ 0xe9, "Value specific to an application" },
|
|
{ 0xea, "Value specific to an application" },
|
|
{ 0xeb, "Value specific to an application" },
|
|
{ 0xec, "Value specific to an application" },
|
|
{ 0xed, "Value specific to an application" },
|
|
{ 0xee, "Value specific to an application" },
|
|
{ 0xef, "Value specific to an application" },
|
|
{ 0xf0, "Value specific to an application" },
|
|
{ 0xf1, "Value specific to an application" },
|
|
{ 0xf2, "Value specific to an application" },
|
|
{ 0xf3, "Value specific to an application" },
|
|
{ 0xf4, "Value specific to an application" },
|
|
{ 0xf5, "Value specific to an application" },
|
|
{ 0xf6, "Value specific to an application" },
|
|
{ 0xf7, "Value specific to an application" },
|
|
{ 0xf8, "Value specific to an application" },
|
|
{ 0xf9, "Value specific to an application" },
|
|
{ 0xfa, "Value specific to an application" },
|
|
{ 0xfb, "Value specific to an application" },
|
|
{ 0xfc, "Value specific to an application" },
|
|
{ 0xfd, "Value specific to an application" },
|
|
{ 0xfe, "Value specific to an application" },
|
|
|
|
{ 0xFF, "Unspecified error cause" },
|
|
{ 0, NULL }
|
|
};
|
|
static value_string_ext gsm_sms_tp_failure_cause_values_ext = VALUE_STRING_EXT_INIT(gsm_sms_tp_failure_cause_values);
|
|
|
|
static void
|
|
dis_field_fcs(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 oct _U_)
|
|
{
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_fail_cause, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
/* 9.2.3.23 */
|
|
#define DIS_FIELD_UDHI(m_tree, m_bitmask, m_offset, m_udhi) \
|
|
{ \
|
|
SMS_SHIFTMASK(oct & m_bitmask, m_bitmask, m_udhi); \
|
|
other_decode_bitfield_value(bigbuf, oct, m_bitmask, 8); \
|
|
proto_tree_add_text(m_tree, tvb, \
|
|
m_offset, 1, \
|
|
"%s : TP-User-Data-Header-Indicator: %s short message", \
|
|
bigbuf, \
|
|
m_udhi ? \
|
|
"The beginning of the TP-UD field contains a Header in addition to the" : \
|
|
"The TP-UD field contains only the"); \
|
|
}
|
|
|
|
/* 9.2.3.24.1 */
|
|
static void
|
|
dis_iei_csm8(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields)
|
|
{
|
|
guint8 oct;
|
|
|
|
EXACT_DATA_CHECK(length, 3);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->sm_id = oct;
|
|
proto_tree_add_uint (tree,
|
|
hf_gsm_sms_ud_multiple_messages_msg_id,
|
|
tvb, offset, 1, oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->frags = oct;
|
|
proto_tree_add_uint (tree,
|
|
hf_gsm_sms_ud_multiple_messages_msg_parts,
|
|
tvb , offset , 1, oct);
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->frag = oct;
|
|
proto_tree_add_uint (tree,
|
|
hf_gsm_sms_ud_multiple_messages_msg_part,
|
|
tvb, offset, 1, oct);
|
|
|
|
}
|
|
|
|
/* TODO 9.2.3.24.2 Special SMS Message Indication */
|
|
|
|
/* 9.2.3.24.3 */
|
|
static void
|
|
dis_iei_apa_8bit(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields)
|
|
{
|
|
const gchar *str = NULL;
|
|
guint8 oct;
|
|
|
|
|
|
EXACT_DATA_CHECK(length, 2);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->port_dst = oct;
|
|
if (oct < 240)
|
|
{
|
|
str = "Reserved";
|
|
}
|
|
else
|
|
{
|
|
str = "Available for allocation by applications";
|
|
}
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Destination port: %d, %s",
|
|
oct,
|
|
str);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->port_src = oct;
|
|
if (oct < 240)
|
|
{
|
|
str = "Reserved";
|
|
}
|
|
else
|
|
{
|
|
str = "Available for allocation by applications";
|
|
}
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Originator port: %d, %s",
|
|
oct,
|
|
str);
|
|
}
|
|
|
|
/* 9.2.3.24.4 */
|
|
static void
|
|
dis_iei_apa_16bit(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields)
|
|
{
|
|
const gchar *str = NULL;
|
|
guint32 value;
|
|
|
|
|
|
EXACT_DATA_CHECK(length, 4);
|
|
|
|
value = tvb_get_ntohs(tvb, offset);
|
|
p_udh_fields->port_dst = (guint16) value;
|
|
if (value < 16000)
|
|
{
|
|
str = "As allocated by IANA (http://www.IANA.com/)";
|
|
}
|
|
else if (value < 17000)
|
|
{
|
|
str = "Available for allocation by applications";
|
|
}
|
|
else
|
|
{
|
|
str = "Reserved";
|
|
}
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 2,
|
|
"Destination port: %d, %s",
|
|
value,
|
|
str);
|
|
|
|
offset += 2;
|
|
value = tvb_get_ntohs(tvb, offset);
|
|
p_udh_fields->port_src = (guint16) value;
|
|
if (value < 16000)
|
|
{
|
|
str = "As allocated by IANA (http://www.IANA.com/)";
|
|
}
|
|
else if (value < 17000)
|
|
{
|
|
str = "Available for allocation by applications";
|
|
}
|
|
else
|
|
{
|
|
str = "Reserved";
|
|
}
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 2,
|
|
"Originator port: %d, %s",
|
|
value,
|
|
str);
|
|
}
|
|
|
|
/* 9.2.3.24.5 */
|
|
static void
|
|
dis_iei_scp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
EXACT_DATA_CHECK(length, 1);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
if (oct & 0x01)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Status Report for short message transaction completed");
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"No Status Report for short message transaction completed");
|
|
}
|
|
|
|
if (oct & 0x02)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Status Report for permanent error when SC is not making any more transfer attempts");
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"No Status Report for permanent error when SC is not making any more transfer attempts");
|
|
}
|
|
|
|
if (oct & 0x04)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Status Report for temporary error when SC is not making any more transfer attempts");
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"No Status Report for temporary error when SC is not making any more transfer attempts");
|
|
}
|
|
|
|
if (oct & 0x08)
|
|
{
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Status Report for temporary error when SC is still trying to transfer SM");
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"No Status Report for temporary error when SC is still trying to transfer SM");
|
|
}
|
|
|
|
if (oct & 0x40)
|
|
{
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"A Status Report generated by this Short Message, due to a permanent error or last temporary error, cancels the SRR of the rest of the Short Messages in a concatenated message");
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"No activation");
|
|
}
|
|
|
|
if (oct & 0x80)
|
|
{
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Include original UDH into the Status Report");
|
|
}
|
|
else
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Do not include original UDH into the Status Report");
|
|
}
|
|
|
|
}
|
|
|
|
/* 9.2.3.24.6 */
|
|
static void
|
|
dis_iei_udh_si(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
EXACT_DATA_CHECK(length, 1);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
switch (oct)
|
|
{
|
|
case 1:
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"The following part of the UDH is created by the original sender (valid in case of Status Report)");
|
|
break;
|
|
case 2:
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"The following part of the UDH is created by the original receiver (valid in case of Status Report)");
|
|
break;
|
|
case 3:
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"The following part of the UDH is created by the SMSC (can occur in any message or report)");
|
|
break;
|
|
default:
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"The following part of the UDH is created by %d" , oct);
|
|
break;
|
|
}
|
|
}
|
|
/* 9.2.3.24.8 */
|
|
static void
|
|
dis_iei_csm16(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields)
|
|
{
|
|
guint8 oct;
|
|
guint16 oct_ref;
|
|
|
|
EXACT_DATA_CHECK(length, 4);
|
|
oct_ref = tvb_get_ntohs(tvb, offset);
|
|
p_udh_fields->sm_id = oct_ref;
|
|
proto_tree_add_uint (tree,
|
|
hf_gsm_sms_ud_multiple_messages_msg_id,
|
|
tvb, offset, 2, oct_ref);
|
|
offset+=2;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->frags = oct;
|
|
proto_tree_add_uint (tree,
|
|
hf_gsm_sms_ud_multiple_messages_msg_parts,
|
|
tvb , offset , 1, oct);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
p_udh_fields->frag = oct;
|
|
proto_tree_add_uint (tree,
|
|
hf_gsm_sms_ud_multiple_messages_msg_part,
|
|
tvb, offset, 1, oct);
|
|
}
|
|
|
|
static const value_string text_color_values[] = {
|
|
{ 0x00, "Black" },
|
|
{ 0x01, "Dark Grey" },
|
|
{ 0x02, "Dark Red" },
|
|
{ 0x03, "Dark Yellow" },
|
|
{ 0x04, "Dark Green" },
|
|
{ 0x05, "Dark Cyan" },
|
|
{ 0x06, "Dark Blue" },
|
|
{ 0x07, "Dark Magenta" },
|
|
{ 0x08, "Grey" },
|
|
{ 0x09, "White" },
|
|
{ 0x0A, "Bright Red" },
|
|
{ 0x0B, "Bright Yellow" },
|
|
{ 0x0C, "Bright Green" },
|
|
{ 0x0D, "Bright Cyan" },
|
|
{ 0x0E, "Bright Blue" },
|
|
{ 0x0F, "Bright Magenta" },
|
|
{ 0, NULL }
|
|
};
|
|
static value_string_ext text_color_values_ext = VALUE_STRING_EXT_INIT(text_color_values);
|
|
|
|
/* 9.2.3.24.10.1.1 */
|
|
static void
|
|
dis_iei_tf(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
const gchar *str = NULL;
|
|
guint8 oct;
|
|
proto_item *item;
|
|
proto_item *item_colour;
|
|
proto_tree *subtree;
|
|
proto_tree *subtree_colour;
|
|
|
|
|
|
SHORT_DATA_CHECK(length, 3);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1,
|
|
"Start position of the text formatting: %d", oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "Text formatting length: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
item = proto_tree_add_text(tree, tvb, offset, 1, "formatting mode");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_udh_tfm);
|
|
switch(oct & 0x03)
|
|
{
|
|
case 0x00:
|
|
str = "Left";
|
|
break;
|
|
case 0x01:
|
|
str = "Center";
|
|
break;
|
|
case 0x02:
|
|
str = "Right";
|
|
break;
|
|
case 0x03:
|
|
str = "Language dependent";
|
|
break;
|
|
}
|
|
|
|
proto_tree_add_text(subtree, tvb, offset, 1, "Alignment : %d %s",
|
|
oct & 0x03 , str);
|
|
|
|
switch((oct >> 2) & 0x03)
|
|
{
|
|
case 0x00:
|
|
str = "Normal";
|
|
break;
|
|
case 0x01:
|
|
str = "Large";
|
|
break;
|
|
case 0x02:
|
|
str = "Small";
|
|
break;
|
|
case 0x03:
|
|
str = "reserved";
|
|
break;
|
|
}
|
|
|
|
proto_tree_add_text(subtree, tvb, offset, 1, "Font Size : %d %s",
|
|
(oct >> 2) & 0x03 , str);
|
|
|
|
if(oct & 0x10)
|
|
str = "on";
|
|
else
|
|
str = "off";
|
|
proto_tree_add_text(subtree, tvb, offset, 1, "Style bold : %d %s",
|
|
oct & 0x10 , str);
|
|
|
|
if(oct & 0x20)
|
|
str = "on";
|
|
else
|
|
str = "off";
|
|
proto_tree_add_text(subtree, tvb, offset, 1, "Style Italic : %d %s",
|
|
oct & 0x20 , str);
|
|
|
|
if(oct & 0x40)
|
|
str = "on";
|
|
else
|
|
str = "off";
|
|
proto_tree_add_text(subtree, tvb, offset, 1, "Style Underlined : %d %s",
|
|
oct & 0x40 , str);
|
|
|
|
if(oct & 0x80)
|
|
str = "on";
|
|
else
|
|
str = "off";
|
|
proto_tree_add_text(subtree, tvb, offset, 1, "Style Strikethrough : %d %s",
|
|
oct & 0x80 , str);
|
|
|
|
offset++;
|
|
|
|
if (length > 3)
|
|
{
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
item_colour = proto_tree_add_text(tree, tvb, offset, 1, "Text Colour");
|
|
|
|
subtree_colour = proto_item_add_subtree(item_colour, ett_udh_tfc);
|
|
|
|
|
|
str = val_to_str_ext_const(oct & 0x0f, &text_color_values_ext, "Unknown");
|
|
proto_tree_add_text(subtree_colour, tvb, offset, 1,
|
|
"Foreground Colour : 0x%x %s",
|
|
oct & 0x0f , str);
|
|
|
|
str = val_to_str_ext_const((oct >> 4) & 0x0f, &text_color_values_ext, "Unknown");
|
|
proto_tree_add_text(subtree_colour,
|
|
tvb, offset, 1,
|
|
"Background Colour : 0x%x %s",
|
|
(oct >> 4) & 0x0f , str);
|
|
|
|
/*offset++;*/
|
|
}
|
|
}
|
|
|
|
/* 9.2.3.24.10.1.2 */
|
|
static void
|
|
dis_iei_ps(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
EXACT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"sound number: %d",
|
|
oct);
|
|
}
|
|
|
|
/* 9.2.3.24.10.1.3 */
|
|
static void
|
|
dis_iei_uds(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
SHORT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length - 1,
|
|
"User Defined Sound ");
|
|
}
|
|
|
|
|
|
/* 9.2.3.24.10.1.4 */
|
|
static void
|
|
dis_iei_pa(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
EXACT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"animation number: %d",
|
|
oct);
|
|
}
|
|
|
|
|
|
/* 9.2.3.24.10.1.5 */
|
|
static void
|
|
dis_iei_la(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
SHORT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length - 1,
|
|
"Large Animation ");
|
|
}
|
|
|
|
/* 9.2.3.24.10.1.6 */
|
|
static void
|
|
dis_iei_sa(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
SHORT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length - 1,
|
|
"Small Animation ");
|
|
}
|
|
|
|
|
|
/* 9.2.3.24.10.1.7 */
|
|
static void
|
|
dis_iei_lp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
SHORT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length - 1,
|
|
"Large Picture ");
|
|
}
|
|
|
|
/* 9.2.3.24.10.1.8 */
|
|
static void
|
|
dis_iei_sp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
SHORT_DATA_CHECK(length, 2);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length - 1,
|
|
"Small Picture ");
|
|
}
|
|
|
|
|
|
/* 9.2.3.24.10.1.9 */
|
|
static void
|
|
dis_iei_vp(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
SHORT_DATA_CHECK(length, 4);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"position: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Horizontal dimension: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Vertical dimension: %d",
|
|
oct);
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length - 3,
|
|
"Variable Picture ");
|
|
}
|
|
|
|
/* 9.2.3.24.10.1.10 */
|
|
static void
|
|
dis_iei_upi(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields _U_)
|
|
{
|
|
guint8 oct;
|
|
|
|
EXACT_DATA_CHECK(length, 1);
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, 1,
|
|
"Number of corresponding objects: %d",
|
|
oct);
|
|
offset++;
|
|
}
|
|
|
|
|
|
/*
|
|
* 9.2.3.24 TP-User Data (TP-UD)
|
|
* Information Element Identifier octet
|
|
*/
|
|
|
|
#if 0
|
|
/* TS 123 040 V9.3.0 (2010-10) */
|
|
static const value_string gsm_sms_tp_ud_ie_id_vals[] = {
|
|
{ 0x00, "Concatenated short messages, 8-bit reference number (SMS Control)" },
|
|
{ 0x01, "Special SMS Message Indication (SMS Control)" },
|
|
{ 0x02, "Reserved" },
|
|
{ 0x03, "Value not used to avoid misinterpretation as <LF> character" },
|
|
{ 0x04, "Application port addressing scheme, 8 bit address (SMS Control)" },
|
|
{ 0x05, "Application port addressing scheme, 16 bit address (SMS Control)" },
|
|
{ 0x06, "SMSC Control Parameters (SMS Control)" },
|
|
{ 0x07, "UDH Source Indicator (SMS Control)" },
|
|
{ 0x08, "Concatenated short message, 16-bit reference number (SMS Control)" },
|
|
{ 0x09, "Wireless Control Message Protocol (SMS Control)" },
|
|
{ 0x0A, "Text Formatting (EMS Control)" },
|
|
{ 0x0B, "Predefined Sound (EMS Content)" },
|
|
{ 0x0C, "User Defined Sound (iMelody max 128 bytes) (EMS Content)" },
|
|
{ 0x0D, "Predefined Animation (EMS Content)" },
|
|
{ 0x0E, "Large Animation (16*16 times 4 = 32*4 =128 bytes) (EMS Content)" },
|
|
{ 0x0F, "Small Animation (8*8 times 4 = 8*4 =32 bytes) (EMS Content)" },
|
|
{ 0x10, "Large Picture (32*32 = 128 bytes) (EMS Content)" },
|
|
{ 0x11, "Small Picture (16*16 = 32 bytes) (EMS Content)" },
|
|
{ 0x12, "Variable Picture (EMS Content)" },
|
|
{ 0x13, "User prompt indicator (EMS Control)" },
|
|
{ 0x14, "Extended Object (EMS Content)" },
|
|
{ 0x15, "Reused Extended Object (EMS Control)" },
|
|
{ 0x16, "Compression Control (EMS Control)" },
|
|
{ 0x17, "Object Distribution Indicator (EMS Control)" },
|
|
{ 0x18, "Standard WVG object (EMS Content)" },
|
|
{ 0x19, "Character Size WVG object (EMS Content)" },
|
|
{ 0x1A, "Extended Object Data Request Command (EMS Control)" },
|
|
/*1B-1F Reserved for future EMS features (see subclause 3.10) */
|
|
{ 0x20, "RFC 822 E-Mail Header (SMS Control)" },
|
|
{ 0x21, "Hyperlink format element (SMS Control)" },s
|
|
{ 0x22, "Reply Address Element (SMS Control)" },
|
|
{ 0x23, "Enhanced Voice Mail Information (SMS Control)" },
|
|
{ 0x24, "National Language Single Shift (SMS Control)" },
|
|
{ 0x25, "National Language Locking Shift (SMS Control)" },
|
|
/*26-6F Reserved for future use */
|
|
/*70-7F (U)SIM Toolkit Security Headers (SMS Control) */
|
|
/*80-9F SME to SME specific use (SMS Control) */
|
|
/*A0-BF Reserved for future use */
|
|
/*C0-DF SC specific use (SMS Control) */
|
|
/*E0-FF Reserved for future use */
|
|
{ 0, NULL },
|
|
};
|
|
static value_string_ext gsm_sms_tp_ud_ie_id_vals_ext = VALUE_STRING_EXT_INIT(gsm_sms_tp_ud_ie_id_vals);
|
|
#endif
|
|
|
|
static void
|
|
dis_field_ud_iei(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields)
|
|
{
|
|
void (*iei_fcn)(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 length, gsm_sms_udh_fields_t *p_udh_fields);
|
|
guint8 oct;
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
const gchar *str = NULL;
|
|
guint8 iei_len;
|
|
|
|
|
|
while (length >= 2)
|
|
{
|
|
iei_fcn = NULL;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
switch (oct)
|
|
{
|
|
case 0x00: str = "Concatenated short messages, 8-bit reference number (SMS Control)"; iei_fcn = dis_iei_csm8; break;
|
|
case 0x01: str = "Special SMS Message Indication (SMS Control)"; break;
|
|
case 0x02: str = "Reserved N/A"; break;
|
|
case 0x03: str = "Value not used to avoid misinterpretation as <LF> character N/A"; break;
|
|
case 0x04: str = "Application port addressing scheme, 8 bit address (SMS Control)"; iei_fcn = dis_iei_apa_8bit; break;
|
|
case 0x05: str = "Application port addressing scheme, 16 bit address (SMS Control)"; iei_fcn = dis_iei_apa_16bit; break;
|
|
case 0x06: str = "SMSC Control Parameters (SMS Control)"; iei_fcn = dis_iei_scp; break;
|
|
case 0x07: str = "UDH Source Indicator (SMS Control)"; iei_fcn = dis_iei_udh_si; break;
|
|
case 0x08: str = "Concatenated short message, 16-bit reference number (SMS Control)"; iei_fcn = dis_iei_csm16; break;
|
|
case 0x09: str = "Wireless Control Message Protocol (SMS Control)"; break;
|
|
case 0x0A: str = "Text Formatting (EMS Control)"; iei_fcn = dis_iei_tf;break;
|
|
case 0x0B: str = "Predefined Sound (EMS Content)"; iei_fcn = dis_iei_ps;break;
|
|
case 0x0C: str = "User Defined Sound (iMelody max 128 bytes) (EMS Content)"; iei_fcn = dis_iei_uds;break;
|
|
case 0x0D: str = "Predefined Animation (EMS Content)"; iei_fcn = dis_iei_pa;break;
|
|
case 0x0E: str = "Large Animation (16*16 times 4 = 32*4 =128 bytes) (EMS Content)"; iei_fcn = dis_iei_la;break;
|
|
case 0x0F: str = "Small Animation (8*8 times 4 = 8*4 =32 bytes) (EMS Content)"; iei_fcn = dis_iei_sa;break;
|
|
case 0x10: str = "Large Picture (32*32 = 128 bytes) (EMS Content)"; iei_fcn = dis_iei_lp;break;
|
|
case 0x11: str = "Small Picture (16*16 = 32 bytes) (EMS Content)"; iei_fcn = dis_iei_sp;break;
|
|
case 0x12: str = "Variable Picture (EMS Content)"; iei_fcn = dis_iei_vp;break;
|
|
case 0x13: str = "User prompt indicator (EMS Control)"; iei_fcn = dis_iei_upi;break;
|
|
case 0x14: str = "Extended Object (EMS Content)"; break;
|
|
case 0x15: str = "Reused Extended Object (EMS Control)"; break;
|
|
case 0x16: str = "Compression Control (EMS Control)"; break;
|
|
case 0x17: str = "Object Distribution Indicator (EMS Control)"; break;
|
|
case 0x18: str = "Standard WVG object (EMS Content)"; break;
|
|
case 0x19: str = "Character Size WVG object (EMS Content)"; break;
|
|
case 0x1A: str = "Extended Object Data Request Command (EMS Control)"; break;
|
|
case 0x20: str = "RFC 822 E-Mail Header (SMS Control)"; break;
|
|
case 0x21: str = "Hyperlink format element (SMS Control)"; break;
|
|
case 0x22: str = "Reply Address Element (SMS Control)"; break;
|
|
default:
|
|
if ((oct >= 0x1b) &&
|
|
(oct <= 0x1f))
|
|
{
|
|
str = "Reserved for future EMS features (see subclause 3.10) N/A"; break;
|
|
}
|
|
else if ((oct >= 0x23) &&
|
|
(oct <= 0x6f))
|
|
{
|
|
str = "Reserved for future use N/A"; break;
|
|
}
|
|
else if ((oct >= 0x70) &&
|
|
(oct <= 0x7f))
|
|
{
|
|
str = "(U)SIM Toolkit Security Headers (SMS Control)"; break;
|
|
}
|
|
else if ((oct >= 0x80) &&
|
|
(oct <= 0x9f))
|
|
{
|
|
str = "SME to SME specific use (SMS Control)"; break;
|
|
}
|
|
else if ((oct >= 0xa0) &&
|
|
(oct <= 0xbf))
|
|
{
|
|
str = "Reserved for future use N/A"; break;
|
|
}
|
|
else if ((oct >= 0xc0) &&
|
|
(oct <= 0xdf))
|
|
{
|
|
str = "SC specific use (SMS Control)"; break;
|
|
}
|
|
else
|
|
{
|
|
str = "Reserved for future use N/A"; break;
|
|
}
|
|
}
|
|
|
|
iei_len = tvb_get_guint8(tvb, offset + 1);
|
|
|
|
item =
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, iei_len + 2,
|
|
"IE: %s",
|
|
str);
|
|
|
|
subtree = proto_item_add_subtree(item, ett_udh_ieis[oct]);
|
|
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, 1,
|
|
"Information Element Identifier: 0x%02X",
|
|
oct);
|
|
|
|
offset++;
|
|
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, 1,
|
|
"Length: %d",
|
|
iei_len);
|
|
|
|
offset++;
|
|
|
|
if (iei_len > 0)
|
|
{
|
|
if (iei_fcn == NULL)
|
|
{
|
|
proto_tree_add_text(subtree,
|
|
tvb, offset, iei_len,
|
|
"IE Data");
|
|
}
|
|
else
|
|
{
|
|
iei_fcn(tvb, subtree, offset, iei_len, p_udh_fields);
|
|
}
|
|
}
|
|
|
|
length -= 2 + iei_len;
|
|
offset += iei_len;
|
|
}
|
|
}
|
|
|
|
void
|
|
dis_field_udh(tvbuff_t *tvb, proto_tree *tree, guint32 *offset, guint32 *length,
|
|
guint8 *udl, enum character_set cset, guint8 *fill_bits, gsm_sms_udh_fields_t *p_udh_fields)
|
|
{
|
|
guint8 oct;
|
|
proto_item *udh_item;
|
|
proto_tree *udh_subtree;
|
|
static const guint8 fill_bits_mask_gsm[7] = { 0x0, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f };
|
|
static const guint8 fill_bits_mask_ascii[7] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc };
|
|
|
|
/* step over header */
|
|
|
|
oct = tvb_get_guint8(tvb, *offset);
|
|
|
|
udh_item =
|
|
proto_tree_add_text(tree, tvb,
|
|
*offset, oct + 1,
|
|
"User-Data Header");
|
|
|
|
udh_subtree = proto_item_add_subtree(udh_item, ett_udh);
|
|
|
|
proto_tree_add_text(udh_subtree,
|
|
tvb, *offset, 1,
|
|
"User Data Header Length (%u)",
|
|
oct);
|
|
|
|
(*offset)++;
|
|
(*length)--;
|
|
|
|
dis_field_ud_iei(tvb, udh_subtree, *offset, oct, p_udh_fields);
|
|
|
|
*offset += oct;
|
|
*length -= oct;
|
|
|
|
if (cset != OTHER)
|
|
{
|
|
/* step over fill bits ? */
|
|
|
|
*fill_bits = 6 - ((oct * 8) % 7);
|
|
*udl -= (((oct + 1)*8) + *fill_bits) / 7;
|
|
if (*fill_bits)
|
|
{
|
|
oct = tvb_get_guint8(tvb, *offset);
|
|
|
|
if (cset == GSM_7BITS)
|
|
{
|
|
other_decode_bitfield_value(bigbuf, oct, fill_bits_mask_gsm[*fill_bits], 8);
|
|
}
|
|
else
|
|
{
|
|
other_decode_bitfield_value(bigbuf, oct, fill_bits_mask_ascii[*fill_bits], 8);
|
|
}
|
|
proto_tree_add_text(udh_subtree,
|
|
tvb, *offset, 1,
|
|
"%s : Fill bits",
|
|
bigbuf);
|
|
/* Note: Could add an expert item here if ((oct & fill_bits_mask[*fill_bits]) != 0) */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*udl -= oct + 1;
|
|
}
|
|
}
|
|
|
|
/* 9.2.3.24 */
|
|
#define SMS_MAX_MESSAGE_SIZE 160
|
|
static void
|
|
dis_field_ud(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset,
|
|
guint32 length, gboolean udhi, guint8 udl, gboolean seven_bit,
|
|
gboolean eight_bit, gboolean ucs2, gboolean compressed, gsm_sms_data_t *data)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
tvbuff_t *sm_tvb = NULL;
|
|
fragment_head *fd_sm = NULL;
|
|
guint8 fill_bits;
|
|
guint32 total_sms_len, len_sms, length_ucs2, i;
|
|
gchar *utf8_text = NULL;
|
|
gchar save_byte = 0, save_byte2 = 0;
|
|
|
|
gboolean reassembled = FALSE;
|
|
guint32 reassembled_in = 0;
|
|
gboolean is_fragmented = FALSE;
|
|
gboolean save_fragmented = FALSE, try_gsm_sms_ud_reassemble = FALSE;
|
|
guint32 num_labels;
|
|
|
|
sm_fragment_params *p_frag_params;
|
|
gsm_sms_udh_fields_t udh_fields;
|
|
|
|
memset(&udh_fields, 0, sizeof(udh_fields));
|
|
fill_bits = 0;
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, length,
|
|
"TP-User-Data");
|
|
subtree = proto_item_add_subtree(item, ett_ud);
|
|
|
|
if (udhi)
|
|
{
|
|
enum character_set cset;
|
|
|
|
if (data && data->stk_packing_required)
|
|
{
|
|
cset = OTHER;
|
|
}
|
|
else
|
|
{
|
|
cset = (seven_bit && !compressed) ? GSM_7BITS : OTHER;
|
|
}
|
|
|
|
dis_field_udh(tvb, subtree, &offset, &length, &udl, cset, &fill_bits, &udh_fields);
|
|
}
|
|
|
|
if (udh_fields.frags > 1)
|
|
is_fragmented = TRUE;
|
|
|
|
if ( is_fragmented && reassemble_sms)
|
|
{
|
|
try_gsm_sms_ud_reassemble = TRUE;
|
|
save_fragmented = pinfo->fragmented;
|
|
pinfo->fragmented = TRUE;
|
|
fd_sm = fragment_add_seq_check (&g_sm_reassembly_table, tvb, offset,
|
|
pinfo,
|
|
udh_fields.sm_id, /* guint32 ID for fragments belonging together */
|
|
NULL,
|
|
udh_fields.frag-1, /* guint32 fragment sequence number */
|
|
length, /* guint32 fragment length */
|
|
(udh_fields.frag != udh_fields.frags)); /* More fragments? */
|
|
if (fd_sm)
|
|
{
|
|
reassembled = TRUE;
|
|
reassembled_in = fd_sm->reassembled_in;
|
|
}
|
|
|
|
sm_tvb = process_reassembled_data(tvb, offset, pinfo,
|
|
"Reassembled Short Message", fd_sm, &sm_frag_items,
|
|
NULL, tree);
|
|
|
|
if(reassembled && pinfo->fd->num == reassembled_in)
|
|
{
|
|
/* Reassembled */
|
|
col_append_str (pinfo->cinfo, COL_INFO,
|
|
" (Short Message Reassembled)");
|
|
}
|
|
else
|
|
{
|
|
/* Not last packet of reassembled Short Message */
|
|
col_append_fstr (pinfo->cinfo, COL_INFO,
|
|
" (Short Message fragment %u of %u)", udh_fields.frag, udh_fields.frags);
|
|
}
|
|
|
|
/* Store udl and length for later decoding of reassembled SMS */
|
|
p_frag_params = wmem_new0(wmem_file_scope(), sm_fragment_params);
|
|
p_frag_params->udl = udl;
|
|
p_frag_params->fill_bits = fill_bits;
|
|
p_frag_params->length = length;
|
|
g_hash_table_insert(g_sm_fragment_params_table,
|
|
GUINT_TO_POINTER((guint)((udh_fields.sm_id<<16)|(udh_fields.frag-1))),
|
|
p_frag_params);
|
|
} /* Else: not fragmented */
|
|
if (! sm_tvb) /* One single Short Message, or not reassembled */
|
|
sm_tvb = tvb_new_subset_remaining (tvb, offset);
|
|
|
|
if (compressed)
|
|
{
|
|
proto_tree_add_text(subtree, tvb, offset, length, "Compressed data");
|
|
}
|
|
else
|
|
{
|
|
if (data && data->stk_packing_required)
|
|
{
|
|
/* STK requires SMS packing by the terminal */
|
|
/* Per 3GPP 31.111 chapter 6.4.10: */
|
|
/* It shall use the SMS default 7-bit coded alphabet */
|
|
/* as defined in TS 23.038 with bit 8 set to 0 */
|
|
if(!(reassembled && pinfo->fd->num == reassembled_in))
|
|
{
|
|
proto_tree_add_item(subtree, hf_gsm_sms_text, tvb, offset, length, ENC_ASCII|ENC_NA);
|
|
}
|
|
else
|
|
{
|
|
total_sms_len = 0;
|
|
for(i = 0 ; i < udh_fields.frags; i++)
|
|
{
|
|
p_frag_params = (sm_fragment_params*)g_hash_table_lookup(g_sm_fragment_params_table,
|
|
GUINT_TO_POINTER((guint)((udh_fields.sm_id<<16)|i)));
|
|
|
|
if (p_frag_params) {
|
|
proto_tree_add_item(subtree, hf_gsm_sms_text, sm_tvb, total_sms_len,
|
|
p_frag_params->length, ENC_ASCII|ENC_NA);
|
|
total_sms_len += p_frag_params->length;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (seven_bit)
|
|
{
|
|
if(!(reassembled && pinfo->fd->num == reassembled_in))
|
|
{
|
|
/* Show unassembled SMS */
|
|
proto_tree_add_ts_23_038_7bits_item(subtree, hf_gsm_sms_text, tvb, (offset<<3)+fill_bits,
|
|
(udl > SMS_MAX_MESSAGE_SIZE ? SMS_MAX_MESSAGE_SIZE : udl));
|
|
}
|
|
else
|
|
{
|
|
/* Show reassembled SMS. We show each fragment separately
|
|
* so that the text doesn't get truncated when we add it to
|
|
* the tree.
|
|
*/
|
|
total_sms_len = 0;
|
|
for(i = 0 ; i < udh_fields.frags; i++)
|
|
{
|
|
p_frag_params = (sm_fragment_params*)g_hash_table_lookup(g_sm_fragment_params_table,
|
|
GUINT_TO_POINTER((guint)((udh_fields.sm_id<<16)|i)));
|
|
|
|
if (p_frag_params) {
|
|
proto_tree_add_ts_23_038_7bits_item(subtree, hf_gsm_sms_text, sm_tvb,
|
|
(total_sms_len<<3)+p_frag_params->fill_bits,
|
|
(p_frag_params->udl > SMS_MAX_MESSAGE_SIZE ? SMS_MAX_MESSAGE_SIZE : p_frag_params->udl));
|
|
|
|
total_sms_len += p_frag_params->length;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (eight_bit)
|
|
{
|
|
/*proto_tree_add_text(subtree, tvb , offset , length, "%s",
|
|
tvb_format_text(tvb, offset, length)); */
|
|
if (! dissector_try_uint(gsm_sms_dissector_tbl, udh_fields.port_src, sm_tvb, pinfo, subtree))
|
|
{
|
|
if (! dissector_try_uint(gsm_sms_dissector_tbl, udh_fields.port_dst,sm_tvb, pinfo, subtree))
|
|
{
|
|
if (subtree)
|
|
{ /* Only display if needed */
|
|
proto_tree_add_text (subtree, sm_tvb, 0, -1,
|
|
"Short Message body");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (ucs2)
|
|
{
|
|
{
|
|
guint rep_len = tvb_reported_length(sm_tvb);
|
|
|
|
if (!(reassembled && pinfo->fd->num == reassembled_in))
|
|
{
|
|
/* Show unreassembled SMS */
|
|
proto_tree_add_item(subtree, hf_gsm_sms_text, sm_tvb,
|
|
0, rep_len, ENC_UCS_2|ENC_BIG_ENDIAN);
|
|
} else {
|
|
/* Show reassembled SMS. We show each fragment separately
|
|
* so that the text doesn't get truncated when we add it to
|
|
* the tree.
|
|
*
|
|
* XXX - careful with splitting UTF-8 chunks; should
|
|
* we be adding each fragment as a UCS-2 string?
|
|
*/
|
|
utf8_text = tvb_get_string_enc(wmem_packet_scope(), sm_tvb, 0, rep_len, ENC_UCS_2|ENC_BIG_ENDIAN);
|
|
len_sms = (int)strlen(utf8_text);
|
|
num_labels = len_sms / MAX_SMS_FRAG_LEN;
|
|
num_labels += (len_sms % MAX_SMS_FRAG_LEN) ? 1 : 0;
|
|
for(i = 0; i < num_labels;i++) {
|
|
if(i * MAX_SMS_FRAG_LEN < len_sms) {
|
|
/* set '\0' to byte number 134 text_node MAX size*/
|
|
save_byte = utf8_text[i * MAX_SMS_FRAG_LEN];
|
|
save_byte2 = utf8_text[i * MAX_SMS_FRAG_LEN + 1];
|
|
if(i > 0)
|
|
{
|
|
utf8_text[i * MAX_SMS_FRAG_LEN] = '\0';
|
|
utf8_text[i * MAX_SMS_FRAG_LEN + 1] = '\0';
|
|
}
|
|
|
|
length_ucs2 = MAX_SMS_FRAG_LEN;
|
|
} else
|
|
length_ucs2 = len_sms % MAX_SMS_FRAG_LEN;
|
|
|
|
proto_tree_add_string(subtree, hf_gsm_sms_text, sm_tvb,
|
|
i * MAX_SMS_FRAG_LEN, length_ucs2,
|
|
&utf8_text[i * MAX_SMS_FRAG_LEN]);
|
|
|
|
/* return the save byte to utf8 buffer*/
|
|
if(i * MAX_SMS_FRAG_LEN < len_sms) {
|
|
utf8_text[i * MAX_SMS_FRAG_LEN] = save_byte;
|
|
utf8_text[i * MAX_SMS_FRAG_LEN + 1] = save_byte2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (try_gsm_sms_ud_reassemble) /* Clean up defragmentation */
|
|
pinfo->fragmented = save_fragmented;
|
|
}
|
|
|
|
/* 9.2.3.27 */
|
|
static void
|
|
dis_field_pi(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint8 oct)
|
|
{
|
|
proto_item *item;
|
|
proto_tree *subtree;
|
|
|
|
|
|
item =
|
|
proto_tree_add_text(tree, tvb,
|
|
offset, 1,
|
|
"TP-Parameter-Indicator");
|
|
|
|
subtree = proto_item_add_subtree(item, ett_pi);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x80, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : %s",
|
|
bigbuf,
|
|
(oct & 0x80) ? "Extended" : "No extension");
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x78, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : Reserved",
|
|
bigbuf);
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x04, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : TP-UDL %spresent",
|
|
bigbuf,
|
|
(oct & 0x04) ? "" : "not ");
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x02, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : TP-DCS %spresent",
|
|
bigbuf,
|
|
(oct & 0x02) ? "" : "not ");
|
|
|
|
other_decode_bitfield_value(bigbuf, oct, 0x01, 8);
|
|
proto_tree_add_text(subtree, tvb,
|
|
offset, 1,
|
|
"%s : TP-PID %spresent",
|
|
bigbuf,
|
|
(oct & 0x01) ? "" : "not ");
|
|
}
|
|
|
|
/*
|
|
* Ref. GSM 03.40
|
|
* Section 9.2.2
|
|
*/
|
|
static void
|
|
dis_msg_deliver(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, gsm_sms_data_t *data)
|
|
{
|
|
guint32 saved_offset;
|
|
guint32 length;
|
|
guint8 oct;
|
|
guint8 udl;
|
|
gboolean seven_bit;
|
|
gboolean eight_bit;
|
|
gboolean ucs2;
|
|
gboolean compressed;
|
|
gboolean udhi;
|
|
|
|
saved_offset = offset;
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udhi = oct & 0x40;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_rp, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_udhi, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_sri, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mms, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mti_down, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
dis_field_addr(tvb, tree, &offset, "TP-Originating-Address");
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pid(tvb, tree, offset, oct);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_dcs(tvb, tree, offset, oct, &seven_bit, &eight_bit, &ucs2, &compressed);
|
|
|
|
offset++;
|
|
dis_field_scts(tvb, tree, &offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udl = oct;
|
|
|
|
DIS_FIELD_UDL(tree, offset);
|
|
|
|
if (udl > 0)
|
|
{
|
|
offset++;
|
|
|
|
dis_field_ud(tvb, pinfo, tree, offset, length - (offset - saved_offset), udhi, udl,
|
|
seven_bit, eight_bit, ucs2, compressed, data);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Ref. GSM 03.40
|
|
* Section 9.2.2
|
|
*/
|
|
static void
|
|
dis_msg_deliver_report(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, gsm_sms_data_t *data)
|
|
{
|
|
guint32 saved_offset;
|
|
guint32 length;
|
|
guint8 oct;
|
|
guint8 pi;
|
|
guint8 udl;
|
|
gboolean seven_bit = FALSE;
|
|
gboolean eight_bit = FALSE;
|
|
gboolean ucs2 = FALSE;
|
|
gboolean compressed = FALSE;
|
|
gboolean udhi;
|
|
|
|
|
|
udl = 0;
|
|
saved_offset = offset;
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udhi = oct & 0x40;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_udhi, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mms, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mti_up, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
if (length < 2)
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, length,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* there does not seem to be a way to determine that this
|
|
* deliver report is from an RP-ERROR or RP-ACK other
|
|
* than to look at the next octet
|
|
*
|
|
* FCS values are 0x80 and higher
|
|
* PI uses bit 7 as an extension indicator
|
|
*
|
|
* will assume that if bit 7 is set then this octet
|
|
* is an FCS otherwise PI
|
|
*/
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
if (oct & 0x80)
|
|
{
|
|
dis_field_fcs(tvb, tree, offset, oct);
|
|
offset++;
|
|
}
|
|
|
|
pi = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pi(tvb, tree, offset, pi);
|
|
|
|
if (pi & 0x01)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pid(tvb, tree, offset, oct);
|
|
}
|
|
|
|
if (pi & 0x02)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_dcs(tvb, tree, offset, oct, &seven_bit, &eight_bit, &ucs2, &compressed);
|
|
}
|
|
|
|
if (pi & 0x04)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udl = oct;
|
|
|
|
DIS_FIELD_UDL(tree, offset);
|
|
}
|
|
|
|
if (udl > 0)
|
|
{
|
|
offset++;
|
|
|
|
dis_field_ud(tvb, pinfo, tree, offset, length - (offset - saved_offset), udhi, udl,
|
|
seven_bit, eight_bit, ucs2, compressed, data);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Ref. GSM 03.40
|
|
* Section 9.2.2
|
|
*/
|
|
static void
|
|
dis_msg_submit(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, gsm_sms_data_t *data)
|
|
{
|
|
guint32 saved_offset;
|
|
guint32 length;
|
|
guint8 oct;
|
|
guint8 vp_form;
|
|
guint8 udl;
|
|
gboolean seven_bit;
|
|
gboolean eight_bit;
|
|
gboolean ucs2;
|
|
gboolean compressed;
|
|
gboolean udhi;
|
|
|
|
|
|
saved_offset = offset;
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udhi = oct & 0x40;
|
|
vp_form = ((oct & 0x18) >> 3);
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_rp, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_udhi, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_srr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_vpf, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_rd, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mti_up, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
dis_field_addr(tvb, tree, &offset, "TP-Destination-Address");
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pid(tvb, tree, offset, oct);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_dcs(tvb, tree, offset, oct, &seven_bit, &eight_bit, &ucs2, &compressed);
|
|
|
|
offset++;
|
|
dis_field_vp(tvb, tree, &offset, vp_form);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udl = oct;
|
|
|
|
DIS_FIELD_UDL(tree, offset);
|
|
|
|
if (udl > 0)
|
|
{
|
|
offset++;
|
|
|
|
dis_field_ud(tvb, pinfo, tree, offset, length - (offset - saved_offset), udhi, udl,
|
|
seven_bit, eight_bit, ucs2, compressed, data);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Ref. GSM 03.40
|
|
* Section 9.2.2
|
|
*/
|
|
static void
|
|
dis_msg_submit_report(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, gsm_sms_data_t *data)
|
|
{
|
|
guint32 saved_offset;
|
|
guint32 length;
|
|
guint8 oct;
|
|
guint8 pi;
|
|
guint8 udl;
|
|
gboolean seven_bit = FALSE;
|
|
gboolean eight_bit = FALSE;
|
|
gboolean ucs2 = FALSE;
|
|
gboolean compressed = FALSE;
|
|
gboolean udhi;
|
|
|
|
|
|
udl = 0;
|
|
saved_offset = offset;
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udhi = oct & 0x40;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_udhi, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mti_down, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
/*
|
|
* there does not seem to be a way to determine that this
|
|
* deliver report is from an RP-ERROR or RP-ACK other
|
|
* than to look at the next octet
|
|
*
|
|
* FCS values are 0x80 and higher
|
|
* PI uses bit 7 as an extension indicator
|
|
*
|
|
* will assume that if bit 7 is set then this octet
|
|
* is an FCS otherwise PI
|
|
*/
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
if (oct & 0x80)
|
|
{
|
|
dis_field_fcs(tvb, tree, offset, oct);
|
|
offset++;
|
|
}
|
|
|
|
pi = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pi(tvb, tree, offset, pi);
|
|
offset++;
|
|
|
|
dis_field_scts(tvb, tree, &offset);
|
|
|
|
if (pi & 0x01) {
|
|
if (length <= (offset - saved_offset)) {
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pid(tvb, tree, offset, oct);
|
|
offset++;
|
|
}
|
|
|
|
if (pi & 0x02)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_dcs(tvb, tree, offset, oct, &seven_bit, &eight_bit, &ucs2, &compressed);
|
|
offset++;
|
|
}
|
|
|
|
if (pi & 0x04)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udl = oct;
|
|
|
|
DIS_FIELD_UDL(tree, offset);
|
|
offset++;
|
|
}
|
|
|
|
if (udl > 0)
|
|
{
|
|
dis_field_ud(tvb, pinfo, tree, offset, length - (offset - saved_offset), udhi, udl,
|
|
seven_bit, eight_bit, ucs2, compressed, data);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Ref. GSM 03.40
|
|
* Section 9.2.2
|
|
*/
|
|
static void
|
|
dis_msg_status_report(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, gsm_sms_data_t *data)
|
|
{
|
|
guint32 saved_offset;
|
|
guint32 length;
|
|
guint8 oct;
|
|
guint8 pi;
|
|
guint8 udl;
|
|
gboolean seven_bit = FALSE;
|
|
gboolean eight_bit = FALSE;
|
|
gboolean ucs2 = FALSE;
|
|
gboolean compressed = FALSE;
|
|
gboolean udhi;
|
|
|
|
|
|
udl = 0;
|
|
saved_offset = offset;
|
|
length = tvb_length_remaining(tvb, offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udhi = oct & 0x40;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_udhi, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_srq, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mms, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mti_down, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
dis_field_addr(tvb, tree, &offset, "TP-Recipient-Address");
|
|
|
|
dis_field_scts(tvb, tree, &offset);
|
|
|
|
dis_field_dt(tvb, tree, &offset);
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_st(tvb, tree, offset, oct);
|
|
|
|
offset++;
|
|
/* Parameter indicating the presence of any of
|
|
* the optional parameters which follow
|
|
* 4) Mandatory if any of the optional parameters following TP-PI is present,
|
|
* otherwise optional.
|
|
*/
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
return;
|
|
}
|
|
pi = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pi(tvb, tree, offset, pi);
|
|
|
|
if (pi & 0x01)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pid(tvb, tree, offset, oct);
|
|
}
|
|
|
|
if (pi & 0x02)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_dcs(tvb, tree, offset, oct, &seven_bit, &eight_bit, &ucs2, &compressed);
|
|
}
|
|
|
|
if (pi & 0x04)
|
|
{
|
|
if (length <= (offset - saved_offset))
|
|
{
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, -1,
|
|
"Short Data (?)");
|
|
return;
|
|
}
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
udl = oct;
|
|
|
|
DIS_FIELD_UDL(tree, offset);
|
|
}
|
|
|
|
if (udl > 0)
|
|
{
|
|
offset++;
|
|
|
|
dis_field_ud(tvb, pinfo, tree, offset, length - (offset - saved_offset), udhi, udl,
|
|
seven_bit, eight_bit, ucs2, compressed, data);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Ref. GSM 03.40
|
|
* Section 9.2.2
|
|
*/
|
|
static void
|
|
dis_msg_command(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, gsm_sms_data_t *data _U_)
|
|
{
|
|
guint8 oct;
|
|
guint8 cdl;
|
|
const gchar *str = NULL;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_udhi, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_srr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mti_up, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
|
|
proto_tree_add_item(tree, hf_gsm_sms_tp_mr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
dis_field_pid(tvb, tree, offset, oct);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
DIS_FIELD_CT(tree, offset);
|
|
|
|
offset++;
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
DIS_FIELD_MN(tree, offset);
|
|
|
|
offset++;
|
|
|
|
dis_field_addr(tvb, tree, &offset, "TP-Destination-Address");
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
cdl = oct;
|
|
|
|
DIS_FIELD_CDL(tree, offset);
|
|
|
|
if (cdl > 0)
|
|
{
|
|
offset++;
|
|
|
|
proto_tree_add_text(tree,
|
|
tvb, offset, cdl,
|
|
"TP-Command-Data");
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
#define NUM_MSGS (sizeof(msg_type_strings)/sizeof(value_string))
|
|
static gint ett_msgs[NUM_MSGS];
|
|
#endif
|
|
|
|
static void (*gsm_sms_msg_fcn[])(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, gsm_sms_data_t *data) = {
|
|
dis_msg_deliver, /* SMS-DELIVER */
|
|
dis_msg_deliver_report, /* SMS-DELIVER REPORT */
|
|
dis_msg_submit, /* SMS-SUBMIT */
|
|
dis_msg_submit_report, /* SMS-SUBMIT REPORT */
|
|
dis_msg_status_report, /* SMS-STATUS REPORT */
|
|
dis_msg_command, /* SMS-COMMAND */
|
|
NULL, /* Reserved */
|
|
NULL, /* Reserved */
|
|
NULL, /* NONE */
|
|
};
|
|
|
|
/* GENERIC DISSECTOR FUNCTIONS */
|
|
|
|
static int
|
|
dissect_gsm_sms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
|
|
{
|
|
void (*msg_fcn)(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint32 offset, gsm_sms_data_t *gsm_data) = NULL;
|
|
guint32 offset;
|
|
guint8 msg_type;
|
|
guint8 oct;
|
|
gint idx;
|
|
const gchar *str = NULL;
|
|
/*gint ett_msg_idx;*/
|
|
gsm_sms_data_t *gsm_data = (gsm_sms_data_t*) data;
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, gsm_sms_proto_name_short);
|
|
|
|
/* In the interest of speed, if "tree" is NULL, don't do any work not
|
|
* necessary to generate protocol tree items.
|
|
*/
|
|
if (tree || reassemble_sms)
|
|
{
|
|
proto_item *gsm_sms_item;
|
|
proto_tree *gsm_sms_tree;
|
|
|
|
g_tree = tree;
|
|
|
|
offset = 0;
|
|
|
|
oct = tvb_get_guint8(tvb, offset);
|
|
|
|
oct &= 0x03;
|
|
msg_type = oct;
|
|
|
|
/*
|
|
* convert the 2 bit value to one based on direction
|
|
*/
|
|
msg_type |= ((pinfo->p2p_dir == P2P_DIR_RECV) ? 0x04 : 0x00);
|
|
|
|
str = try_val_to_str_idx(msg_type, msg_type_strings, &idx);
|
|
|
|
/*
|
|
* create the GSM_SMS protocol tree
|
|
*/
|
|
gsm_sms_item =
|
|
proto_tree_add_protocol_format(tree, proto_gsm_sms, tvb, 0, -1,
|
|
"%s %s",
|
|
gsm_sms_proto_name,
|
|
(str == NULL) ? "Unknown message identifier" : str);
|
|
|
|
gsm_sms_tree =
|
|
proto_item_add_subtree(gsm_sms_item, ett_gsm_sms);
|
|
|
|
if ((str == NULL) ||
|
|
(msg_type == 0x03) ||
|
|
(msg_type == 0x07))
|
|
{
|
|
return tvb_length(tvb);
|
|
}
|
|
else
|
|
{
|
|
/*ett_msg_idx = ett_msgs[idx];*/ /* XXX: Not actually used */
|
|
msg_fcn = gsm_sms_msg_fcn[idx];
|
|
}
|
|
|
|
if (msg_fcn == NULL)
|
|
{
|
|
proto_tree_add_text(gsm_sms_tree,
|
|
tvb, offset, -1,
|
|
"Message dissector not implemented");
|
|
}
|
|
else
|
|
{
|
|
(*msg_fcn)(tvb, pinfo, gsm_sms_tree, offset, gsm_data);
|
|
}
|
|
}
|
|
return tvb_length(tvb);
|
|
}
|
|
|
|
|
|
/* Register the protocol with Wireshark */
|
|
void
|
|
proto_register_gsm_sms(void)
|
|
{
|
|
guint i;
|
|
guint last_offset;
|
|
module_t *gsm_sms_module; /* Preferences for GSM SMS UD */
|
|
|
|
/* Setup list of header fields */
|
|
static hf_register_info hf[] =
|
|
{
|
|
{ &hf_gsm_sms_coding_group_bits2,
|
|
{ "Coding Group Bits", "gsm_sms.coding_group_bits2",
|
|
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &gsm_sms_coding_group_bits_vals_ext, 0xc0,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_gsm_sms_coding_group_bits4,
|
|
{ "Coding Group Bits", "gsm_sms.coding_group_bits4",
|
|
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &gsm_sms_coding_group_bits_vals_ext, 0xf0,
|
|
NULL, HFILL }
|
|
},
|
|
|
|
/*
|
|
* Short Message fragment reassembly
|
|
*/
|
|
{ &hf_gsm_sms_ud_fragments,
|
|
{ "Short Message fragments", "gsm_sms.fragments",
|
|
FT_NONE, BASE_NONE, NULL, 0x00,
|
|
"GSM Short Message fragments", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment,
|
|
{ "Short Message fragment", "gsm_sms.fragment",
|
|
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
|
|
"GSM Short Message fragment", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment_overlap,
|
|
{ "Short Message fragment overlap", "gsm_sms.fragment.overlap",
|
|
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
"GSM Short Message fragment overlaps with other fragment(s)", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment_overlap_conflicts,
|
|
{ "Short Message fragment overlapping with conflicting data", "gsm_sms.fragment.overlap.conflicts",
|
|
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
"GSM Short Message fragment overlaps with conflicting data", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment_multiple_tails,
|
|
{ "Short Message has multiple tail fragments", "gsm_sms.fragment.multiple_tails",
|
|
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
"GSM Short Message fragment has multiple tail fragments", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment_too_long_fragment,
|
|
{ "Short Message fragment too long", "gsm_sms.fragment.too_long_fragment",
|
|
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
|
|
"GSM Short Message fragment data goes beyond the packet end", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment_error,
|
|
{ "Short Message defragmentation error", "gsm_sms.fragment.error",
|
|
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
|
|
"GSM Short Message defragmentation error due to illegal fragments", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_fragment_count,
|
|
{ "Short Message fragment count", "gsm_sms.fragment.count",
|
|
FT_UINT32, BASE_DEC, NULL, 0x00,
|
|
NULL, HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_reassembled_in,
|
|
{ "Reassembled in", "gsm_sms.reassembled.in",
|
|
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
|
|
"GSM Short Message has been reassembled in this packet.", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_reassembled_length,
|
|
{ "Reassembled Short Message length", "gsm_sms.reassembled.length",
|
|
FT_UINT32, BASE_DEC, NULL, 0x00,
|
|
"The total length of the reassembled payload", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_multiple_messages_msg_id,
|
|
{ "Message identifier", "gsm_sms.udh.mm.msg_id",
|
|
FT_UINT16, BASE_DEC, NULL, 0x00,
|
|
"Identification of the message", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_multiple_messages_msg_parts,
|
|
{ "Message parts", "gsm_sms.udh.mm.msg_parts",
|
|
FT_UINT8, BASE_DEC, NULL, 0x00,
|
|
"Total number of message parts (fragments)", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_ud_multiple_messages_msg_part,
|
|
{ "Message part number", "gsm_sms.udh.mm.msg_part",
|
|
FT_UINT8, BASE_DEC, NULL, 0x00,
|
|
"Message part (fragment) sequence number", HFILL }
|
|
},
|
|
/* TPDU parameters */
|
|
{ &hf_gsm_sms_tp_mti_up,
|
|
{ "TP-MTI", "gsm_sms.tp-mti",
|
|
FT_UINT8, BASE_DEC, VALS(msg_type_strings_ms_to_sc), 0x03,
|
|
"TP-Message-Type-Indicator (in the direction MS to SC)", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_mti_down,
|
|
{ "TP-MTI", "gsm_sms.tp-mti",
|
|
FT_UINT8, BASE_DEC, VALS(msg_type_strings_sc_to_ms), 0x03,
|
|
"TP-Message-Type-Indicator (in the direction SC to MS)", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_oa,
|
|
{ "TP-OA Digits", "gsm_sms.tp-oa",
|
|
FT_STRING, BASE_NONE, NULL, 0x00,
|
|
"TP-Originating-Address Digits", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_da,
|
|
{ "TP-DA Digits", "gsm_sms.tp-da",
|
|
FT_STRING, BASE_NONE, NULL, 0x00,
|
|
"TP-Destination-Address Digits", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_ra,
|
|
{ "TP-RA Digits", "gsm_sms.tp-ra",
|
|
FT_STRING, BASE_NONE, NULL, 0x00,
|
|
"TP-Recipient-Address Digits", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_pid,
|
|
{ "TP-PID", "gsm_sms.tp-pid",
|
|
FT_UINT8, BASE_DEC, NULL, 0x00,
|
|
"TP-Protocol-Identifier", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_dcs,
|
|
{ "TP-DCS", "gsm_sms.tp-dcs",
|
|
FT_UINT8, BASE_DEC, NULL, 0x00,
|
|
"TP-Data-Coding-Scheme", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_mr,
|
|
{ "TP-MR", "gsm_sms.tp-mr",
|
|
FT_UINT8, BASE_DEC, NULL, 0x00,
|
|
"TP-Message-Reference", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_mms,
|
|
{ "TP-MMS", "gsm_sms.tp-mms",
|
|
FT_BOOLEAN, 8, TFS(&mms_bool_strings), 0x04,
|
|
"TP-More-Messages-to-Send", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_sri,
|
|
{ "TP-SRI", "gsm_sms.tp-sri",
|
|
FT_BOOLEAN, 8, TFS(&sri_bool_strings), 0x20,
|
|
"TP-Status-Report-Indication", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_srr,
|
|
{ "TP-SRR", "gsm_sms.tp-srr",
|
|
FT_BOOLEAN, 8, TFS(&srr_bool_strings), 0x20,
|
|
"TP-Status-Report-Request", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_udhi,
|
|
{ "TP-UDHI", "gsm_sms.tp-udhi",
|
|
FT_BOOLEAN, 8, TFS(&udhi_bool_strings), 0x40,
|
|
"TP-User-Data-Header-Indicator", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_rp,
|
|
{ "TP-RP", "gsm_sms.tp-rp",
|
|
FT_BOOLEAN, 8, TFS(&rp_bool_strings), 0x80,
|
|
"TP-Reply-Path", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_vpf,
|
|
{ "TP-VPF", "gsm_sms.tp-vpf",
|
|
FT_UINT8, BASE_DEC, VALS(vp_type_strings), 0x18,
|
|
"TP-Validity-Period-Format", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_rd,
|
|
{ "TP-RD", "gsm_sms.tp-rd",
|
|
FT_BOOLEAN, 8, TFS(&rd_bool_strings), 0x04,
|
|
"TP-Reject-Duplicates", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_srq,
|
|
{ "TP-SRQ", "gsm_sms.tp-srq",
|
|
FT_BOOLEAN, 8, TFS(&srq_bool_strings), 0x20,
|
|
"TP-Status-Report-Qualifier", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_text,
|
|
{ "SMS text", "gsm_sms.sms_text",
|
|
FT_STRING, STR_UNICODE, NULL, 0x00,
|
|
"The text of the SMS", HFILL }
|
|
},
|
|
{ &hf_gsm_sms_tp_fail_cause,
|
|
{ "TP-Failure-Cause (TP-FCS)", "gsm_sms.tp-fcs",
|
|
FT_UINT8, BASE_HEX_DEC|BASE_EXT_STRING, &gsm_sms_tp_failure_cause_values_ext, 0x0,
|
|
"TP-Validity-Period-Format", HFILL }
|
|
},
|
|
};
|
|
|
|
/* Setup protocol subtree array */
|
|
#define NUM_INDIVIDUAL_PARMS 14
|
|
gint *ett[NUM_INDIVIDUAL_PARMS/*+NUM_MSGS*/+NUM_UDH_IEIS+2];
|
|
|
|
ett[0] = &ett_gsm_sms;
|
|
ett[1] = &ett_pid;
|
|
ett[2] = &ett_pi;
|
|
ett[3] = &ett_fcs;
|
|
ett[4] = &ett_vp;
|
|
ett[5] = &ett_scts;
|
|
ett[6] = &ett_dt;
|
|
ett[7] = &ett_st;
|
|
ett[8] = &ett_addr;
|
|
ett[9] = &ett_dcs;
|
|
ett[10] = &ett_ud;
|
|
ett[11] = &ett_udh;
|
|
ett[12] = &ett_udh_tfm;
|
|
ett[13] = &ett_udh_tfc;
|
|
|
|
last_offset = NUM_INDIVIDUAL_PARMS;
|
|
|
|
#if 0
|
|
for (i=0; i < NUM_MSGS; i++, last_offset++)
|
|
{
|
|
ett_msgs[i] = -1;
|
|
ett[last_offset] = &ett_msgs[i];
|
|
}
|
|
#endif
|
|
|
|
for (i=0; i < NUM_UDH_IEIS; i++, last_offset++)
|
|
{
|
|
ett_udh_ieis[i] = -1;
|
|
ett[last_offset] = &ett_udh_ieis[i];
|
|
}
|
|
|
|
ett[last_offset++] = &ett_gsm_sms_ud_fragment;
|
|
ett[last_offset] = &ett_gsm_sms_ud_fragments;
|
|
|
|
/* Register the protocol name and description */
|
|
|
|
proto_gsm_sms =
|
|
proto_register_protocol(gsm_sms_proto_name, gsm_sms_proto_name_short, "gsm_sms");
|
|
|
|
|
|
proto_register_field_array(proto_gsm_sms, hf, array_length(hf));
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
gsm_sms_dissector_tbl = register_dissector_table("gsm_sms.udh.port",
|
|
"GSM SMS port IE in UDH", FT_UINT16, BASE_DEC);
|
|
|
|
gsm_sms_module = prefs_register_protocol (proto_gsm_sms, NULL);
|
|
|
|
prefs_register_obsolete_preference(gsm_sms_module,
|
|
"try_dissect_message_fragment");
|
|
prefs_register_bool_preference (gsm_sms_module, "reassemble",
|
|
"Reassemble fragmented SMS",
|
|
"Whether the dissector should reassemble SMS spanning multiple packets",
|
|
&reassemble_sms);
|
|
|
|
new_register_dissector("gsm_sms", dissect_gsm_sms, proto_gsm_sms);
|
|
|
|
/* GSM SMS UD dissector initialization routines */
|
|
register_init_routine (gsm_sms_defragment_init);
|
|
}
|
|
|
|
/*
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
*
|
|
* Local variables:
|
|
* c-basic-offset: 4
|
|
* tab-width: 8
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* vi: set shiftwidth=4 tabstop=8 expandtab:
|
|
* :indentSize=4:tabSize=8:noTabs=true:
|
|
*/
|