epan/dissectors/packet-smpp.c

   1 /* packet-smpp.c
   2  * Routines for Short Message Peer to Peer dissection
   3  * Copyright 2001, Tom Uijldert.
   4  *
   5  * Data Coding Scheme decoding for GSM (SMS and CBS),
   6  * provided by Olivier Biot.
   7  *
   8  * Dissection of multiple SMPP PDUs within one packet
   9  * provided by Chris Wilson.
  10  *
  11  * Statistics support using Stats Tree API
  12  * provided by Abhik Sarkar
  13  *
  14  * Support for SMPP 5.0
  15  * introduced by Abhik Sarkar
  16  *
  17  * $Id$
  18  *
  19  * Refer to the AUTHORS file or the AUTHORS section in the man page
  20  * for contacting the author(s) of this file.
  21  *
  22  * Wireshark - Network traffic analyzer
  23  * By Gerald Combs <gerald@wireshark.org>
  24  * Copyright 1998 Gerald Combs
  25  *
  26  * This program is free software; you can redistribute it and/or
  27  * modify it under the terms of the GNU General Public License
  28  * as published by the Free Software Foundation; either version 2
  29  * of the License, or (at your option) any later version.
  30  *
  31  * This program is distributed in the hope that it will be useful,
  32  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  33  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  34  * GNU General Public License for more details.
  35  *
  36  * You should have received a copy of the GNU General Public License
  37  * along with this program; if not, write to the Free Software
  38  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  39  * ----------
  40  *
  41  * Dissector of an SMPP (Short Message Peer to Peer) PDU, as defined by the
  42  * SMS forum (www.smsforum.net) in "SMPP protocol specification v3.4"
  43  * (document version: 12-Oct-1999 Issue 1.2)
  44  */
  45
  46 #ifdef HAVE_CONFIG_H
  47 # include "config.h"
  48 #endif
  49
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <string.h>
  53 #include <time.h>
  54
  55 #include <glib.h>
  56
  57 #include <epan/packet.h>
  58 #include <epan/tap.h>
  59 #include <epan/stats_tree.h>
  60
  61 #include <epan/prefs.h>
  62 #include <epan/emem.h>
  63 #include "packet-tcp.h"
  64 #include "packet-smpp.h"
  65
  66 /* General-purpose debug logger.
  67  * Requires double parentheses because of variable arguments of printf().
  68  *
  69  * Enable debug logging for SMPP by defining AM_CFLAGS
  70  * so that it contains "-DDEBUG_smpp"
  71  */
  72 #ifdef DEBUG_smpp
  73 #define DebugLog(x) \
  74     g_print("%s:%u: ", __FILE__, __LINE__);     \
  75     g_print x
  76 #else
  77 #define DebugLog(x) ;
  78 #endif
  79
  80 #define SMPP_MIN_LENGTH 16
  81
  82 /* Forward declarations         */
  83 static void dissect_smpp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
  84 static guint get_smpp_pdu_len(packet_info *pinfo, tvbuff_t *tvb, int offset);
  85 static void dissect_smpp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
  86
  87 /*
  88  * Initialize the protocol and registered fields
  89  *
  90  * Fixed header section
  91  */
  92 static int proto_smpp                           = -1;
  93
  94 static int st_smpp_ops                          = -1;
  95 static int st_smpp_req                          = -1;
  96 static int st_smpp_res                          = -1;
  97 static int st_smpp_res_status                   = -1;
  98
  99 static int hf_smpp_command_id                   = -1;
 100 static int hf_smpp_command_length               = -1;
 101 static int hf_smpp_command_status               = -1;
 102 static int hf_smpp_sequence_number              = -1;
 103
 104 /*
 105  * Fixed body section
 106  */
 107 static int hf_smpp_system_id                    = -1;
 108 static int hf_smpp_password                     = -1;
 109 static int hf_smpp_system_type                  = -1;
 110 static int hf_smpp_interface_version            = -1;
 111 static int hf_smpp_addr_ton                     = -1;
 112 static int hf_smpp_addr_npi                     = -1;
 113 static int hf_smpp_address_range                = -1;
 114 static int hf_smpp_service_type                 = -1;
 115 static int hf_smpp_source_addr_ton              = -1;
 116 static int hf_smpp_source_addr_npi              = -1;
 117 static int hf_smpp_source_addr                  = -1;
 118 static int hf_smpp_dest_addr_ton                = -1;
 119 static int hf_smpp_dest_addr_npi                = -1;
 120 static int hf_smpp_destination_addr             = -1;
 121 static int hf_smpp_esm_submit_msg_mode          = -1;
 122 static int hf_smpp_esm_submit_msg_type          = -1;
 123 static int hf_smpp_esm_submit_features          = -1;
 124 static int hf_smpp_protocol_id                  = -1;
 125 static int hf_smpp_priority_flag                = -1;
 126 static int hf_smpp_schedule_delivery_time       = -1;
 127 static int hf_smpp_schedule_delivery_time_r     = -1;
 128 static int hf_smpp_validity_period              = -1;
 129 static int hf_smpp_validity_period_r            = -1;
 130 static int hf_smpp_regdel_receipt               = -1;
 131 static int hf_smpp_regdel_acks                  = -1;
 132 static int hf_smpp_regdel_notif                 = -1;
 133 static int hf_smpp_replace_if_present_flag      = -1;
 134 static int hf_smpp_data_coding                  = -1;
 135 static int hf_smpp_sm_default_msg_id            = -1;
 136 static int hf_smpp_sm_length                    = -1;
 137 static int hf_smpp_short_message                = -1;
 138 static int hf_smpp_message_id                   = -1;
 139 static int hf_smpp_dlist                        = -1;
 140 static int hf_smpp_dlist_resp                   = -1;
 141 static int hf_smpp_dl_name                      = -1;
 142 static int hf_smpp_final_date                   = -1;
 143 static int hf_smpp_final_date_r                 = -1;
 144 static int hf_smpp_message_state                = -1;
 145 static int hf_smpp_error_code                   = -1;
 146 static int hf_smpp_error_status_code            = -1;
 147 static int hf_smpp_esme_addr_ton                = -1;
 148 static int hf_smpp_esme_addr_npi                = -1;
 149 static int hf_smpp_esme_addr                    = -1;
 150
 151 /*
 152  * Optional parameter section
 153  */
 154 static int hf_smpp_opt_params                   = -1;
 155 static int hf_smpp_opt_param                    = -1;
 156 static int hf_smpp_opt_param_tag                = -1;
 157 static int hf_smpp_opt_param_len                = -1;
 158 static int hf_smpp_vendor_op                    = -1;
 159 static int hf_smpp_reserved_op                  = -1;
 160
 161 static int hf_smpp_dest_addr_subunit            = -1;
 162 static int hf_smpp_dest_network_type            = -1;
 163 static int hf_smpp_dest_bearer_type             = -1;
 164 static int hf_smpp_dest_telematics_id           = -1;
 165 static int hf_smpp_source_addr_subunit          = -1;
 166 static int hf_smpp_source_network_type          = -1;
 167 static int hf_smpp_source_bearer_type           = -1;
 168 static int hf_smpp_source_telematics_id         = -1;
 169 static int hf_smpp_qos_time_to_live             = -1;
 170 static int hf_smpp_payload_type                 = -1;
 171 static int hf_smpp_additional_status_info_text  = -1;
 172 static int hf_smpp_receipted_message_id         = -1;
 173 static int hf_smpp_msg_wait_ind                 = -1;
 174 static int hf_smpp_msg_wait_type                = -1;
 175 static int hf_smpp_privacy_indicator            = -1;
 176 static int hf_smpp_source_subaddress            = -1;
 177 static int hf_smpp_dest_subaddress              = -1;
 178 static int hf_smpp_user_message_reference       = -1;
 179 static int hf_smpp_user_response_code           = -1;
 180 static int hf_smpp_source_port                  = -1;
 181 static int hf_smpp_destination_port             = -1;
 182 static int hf_smpp_sar_msg_ref_num              = -1;
 183 static int hf_smpp_language_indicator           = -1;
 184 static int hf_smpp_sar_total_segments           = -1;
 185 static int hf_smpp_sar_segment_seqnum           = -1;
 186 static int hf_smpp_SC_interface_version         = -1;
 187 static int hf_smpp_callback_num_pres            = -1;
 188 static int hf_smpp_callback_num_scrn            = -1;
 189 static int hf_smpp_callback_num_atag            = -1;
 190 static int hf_smpp_number_of_messages           = -1;
 191 static int hf_smpp_callback_num                 = -1;
 192 static int hf_smpp_dpf_result                   = -1;
 193 static int hf_smpp_set_dpf                      = -1;
 194 static int hf_smpp_ms_availability_status       = -1;
 195 static int hf_smpp_network_error_type           = -1;
 196 static int hf_smpp_network_error_code           = -1;
 197 static int hf_smpp_message_payload              = -1;
 198 static int hf_smpp_delivery_failure_reason      = -1;
 199 static int hf_smpp_more_messages_to_send        = -1;
 200 static int hf_smpp_ussd_service_op              = -1;
 201 static int hf_smpp_display_time                 = -1;
 202 static int hf_smpp_sms_signal                   = -1;
 203 static int hf_smpp_ms_validity                  = -1;
 204 static int hf_smpp_alert_on_message_delivery_null       = -1;
 205 static int hf_smpp_alert_on_message_delivery    = -1;
 206 static int hf_smpp_its_reply_type               = -1;
 207 static int hf_smpp_its_session_number           = -1;
 208 static int hf_smpp_its_session_sequence         = -1;
 209 static int hf_smpp_its_session_ind              = -1;
 210
 211 /* Optional Parameters introduced in SMPP 5.0   */
 212 static int hf_smpp_congestion_state             = -1;
 213 static int hf_smpp_billing_identification       = -1;
 214 static int hf_smpp_dest_addr_np_country         = -1;
 215 static int hf_smpp_dest_addr_np_information     = -1;
 216 static int hf_smpp_dest_addr_np_resolution      = -1;
 217 static int hf_smpp_source_network_id            = -1;
 218 static int hf_smpp_source_node_id               = -1;
 219 static int hf_smpp_dest_network_id              = -1;
 220 static int hf_smpp_dest_node_id                 = -1;
 221 /* Optional Parameters for Cell Broadcast Operations */
 222 static int hf_smpp_broadcast_channel_indicator  = -1;
 223 static int hf_smpp_broadcast_content_type_nw    = -1;
 224 static int hf_smpp_broadcast_content_type_type  = -1;
 225 static int hf_smpp_broadcast_content_type_info  = -1;
 226 static int hf_smpp_broadcast_message_class      = -1;
 227 static int hf_smpp_broadcast_rep_num            = -1;
 228 static int hf_smpp_broadcast_frequency_interval_unit    = -1;
 229 static int hf_smpp_broadcast_frequency_interval_value   = -1;
 230 static int hf_smpp_broadcast_area_identifier    = -1;
 231 static int hf_smpp_broadcast_area_identifier_format     = -1;
 232 static int hf_smpp_broadcast_error_status       = -1;
 233 static int hf_smpp_broadcast_area_success       = -1;
 234 static int hf_smpp_broadcast_end_time           = -1;
 235 static int hf_smpp_broadcast_end_time_r         = -1;
 236 static int hf_smpp_broadcast_service_group      = -1;
 237
 238 /*
 239  * Data Coding Scheme section
 240  */
 241 static int hf_smpp_dcs = -1;
 242 static int hf_smpp_dcs_sms_coding_group = -1;
 243 static int hf_smpp_dcs_text_compression = -1;
 244 static int hf_smpp_dcs_class_present = -1;
 245 static int hf_smpp_dcs_charset = -1;
 246 static int hf_smpp_dcs_class = -1;
 247 static int hf_smpp_dcs_cbs_coding_group = -1;
 248 static int hf_smpp_dcs_cbs_language = -1;
 249 static int hf_smpp_dcs_wap_charset = -1;
 250 static int hf_smpp_dcs_wap_class = -1;
 251 static int hf_smpp_dcs_cbs_class = -1;
 252
 253 /* Initialize the subtree pointers */
 254 static gint ett_smpp            = -1;
 255 static gint ett_dlist           = -1;
 256 static gint ett_dlist_resp      = -1;
 257 static gint ett_opt_params      = -1;
 258 static gint ett_opt_param       = -1;
 259 static gint ett_dcs             = -1;
 260
 261 /* Reassemble SMPP TCP segments */
 262 static gboolean reassemble_over_tcp = TRUE;
 263
 264 /* Tap */
 265 static int smpp_tap             = -1;
 266
 267 /*
 268  * Value-arrays for field-contents
 269  */
 270 static const value_string vals_command_id[] = {         /* Operation    */
 271     { 0x80000000, "Generic_nack" },
 272     { 0x00000001, "Bind_receiver" },
 273     { 0x80000001, "Bind_receiver - resp" },
 274     { 0x00000002, "Bind_transmitter" },
 275     { 0x80000002, "Bind_transmitter - resp" },
 276     { 0x00000003, "Query_sm" },
 277     { 0x80000003, "Query_sm - resp" },
 278     { 0x00000004, "Submit_sm" },
 279     { 0x80000004, "Submit_sm - resp" },
 280     { 0x00000005, "Deliver_sm" },
 281     { 0x80000005, "Deliver_sm - resp" },
 282     { 0x00000006, "Unbind" },
 283     { 0x80000006, "Unbind - resp" },
 284     { 0x00000007, "Replace_sm" },
 285     { 0x80000007, "Replace_sm - resp" },
 286     { 0x00000008, "Cancel_sm" },
 287     { 0x80000008, "Cancel_sm - resp" },
 288     { 0x00000009, "Bind_transceiver" },
 289     { 0x80000009, "Bind_transceiver - resp" },
 290     { 0x0000000B, "Outbind" },
 291     { 0x00000015, "Enquire_link" },
 292     { 0x80000015, "Enquire_link - resp" },
 293     { 0x00000021, "Submit_multi" },
 294     { 0x80000021, "Submit_multi - resp" },
 295     { 0x00000102, "Alert_notification" },
 296     { 0x00000103, "Data_sm" },
 297     { 0x80000103, "Data_sm - resp" },
 298     /* Introduced in SMPP 5.0 */
 299     { 0x00000111, "Broadcast_sm" },
 300     { 0x80000111, "Broadcast_sm - resp" },
 301     { 0x00000112, "Query_broadcast_sm" },
 302     { 0x80000112, "Query_broadcast_sm - resp" },
 303     { 0x00000113, "Cancel_broadcast_sm" },
 304     { 0x80000113, "Cancel_broadcast_sm - resp" },
 305     { 0, NULL }
 306 };
 307
 308 static const value_string vals_command_status[] = {     /* Status       */
 309     { 0x00000000, "Ok" },
 310     { 0x00000001, "Message length is invalid" },
 311     { 0x00000002, "Command length is invalid" },
 312     { 0x00000003, "Invalid command ID" },
 313     { 0x00000004, "Incorrect BIND status for given command" },
 314     { 0x00000005, "ESME already in bound state" },
 315     { 0x00000006, "Invalid priority flag" },
 316     { 0x00000007, "Invalid registered delivery flag" },
 317     { 0x00000008, "System error" },
 318     { 0x00000009, "[Reserved]" },
 319     { 0x0000000A, "Invalid source address" },
 320     { 0x0000000B, "Invalid destination address" },
 321     { 0x0000000C, "Message ID is invalid" },
 322     { 0x0000000D, "Bind failed" },
 323     { 0x0000000E, "Invalid password" },
 324     { 0x0000000F, "Invalid system ID" },
 325     { 0x00000010, "[Reserved]" },
 326     { 0x00000011, "Cancel SM failed" },
 327     { 0x00000012, "[Reserved]" },
 328     { 0x00000013, "Replace SM failed" },
 329     { 0x00000014, "Message queue full" },
 330     { 0x00000015, "Invalid service type" },
 331     { 0x00000033, "Invalid number of destinations" },
 332     { 0x00000034, "Invalid distribution list name" },
 333     { 0x00000040, "Destination flag is invalid (submit_multi)" },
 334     { 0x00000041, "[Reserved]" },
 335     { 0x00000042, "Invalid 'submit with replace' request" },
 336     { 0x00000043, "Invalid esm_class field data" },
 337     { 0x00000044, "Cannot submit to distribution list" },
 338     { 0x00000045, "submit_sm or submit_multi failed" },
 339     { 0x00000046, "[Reserved]" },
 340     { 0x00000047, "[Reserved]" },
 341     { 0x00000048, "Invalid source address TON" },
 342     { 0x00000049, "Invalid source address NPI" },
 343     { 0x00000050, "Invalid destination address TON" },
 344     { 0x00000051, "Invalid destination address NPI" },
 345     { 0x00000052, "[Reserved]" },
 346     { 0x00000053, "Invalid system_type field" },
 347     { 0x00000054, "Invalid replace_if_present flag" },
 348     { 0x00000055, "Invalid number of messages" },
 349     { 0x00000056, "[Reserved]" },
 350     { 0x00000057, "[Reserved]" },
 351     { 0x00000058, "Throttling error (ESME exceeded allowed message limits)" },
 352     { 0x00000059, "[Reserved]" },
 353     { 0x00000060, "[Reserved]" },
 354     { 0x00000061, "Invalid scheduled delivery time" },
 355     { 0x00000062, "Invalid message validity period (expiry time)" },
 356     { 0x00000063, "Predefined message invalid or not found" },
 357     { 0x00000064, "ESME receiver temporary app error code" },
 358     { 0x00000065, "ESME receiver permanent app error code" },
 359     { 0x00000066, "ESME receiver reject message error code" },
 360     { 0x00000067, "query_sm request failed" },
 361     { 0x000000C0, "Error in the optional part of the PDU body" },
 362     { 0x000000C1, "Optional parameter not allowed" },
 363     { 0x000000C2, "Invalid parameter length" },
 364     { 0x000000C3, "Expected optional parameter missing" },
 365     { 0x000000C4, "Invalid optional parameter  value" },
 366     { 0x000000FE, "(Transaction) Delivery failure (used for data_sm_resp)" },
 367     { 0x000000FF, "Unknown error" },
 368     /* Introduced in SMPP 5.0 */
 369     { 0x00000100, "ESME Not authorised to use specified service_type." },
 370     { 0x00000101, "ESME Prohibited from using specified operation."},
 371     { 0x00000102, "Specified service_type is unavailable." },
 372     { 0x00000103, "Specified service_type is denied." },
 373     { 0x00000104, "Invalid Data Coding Scheme." },
 374     { 0x00000105, "Source Address Sub unit is Invalid." },
 375     { 0x00000106, "Destination Address Sub unit is Invalid." },
 376     { 0x00000107, "Broadcast Frequency Interval is invalid." },
 377     { 0x00000108, "Broadcast Alias Name is invalid." },
 378     { 0x00000109, "Broadcast Area Format is invalid." },
 379     { 0x0000010A, "Number of Broadcast Areas is invalid." },
 380     { 0x0000010B, "Broadcast Content Type is invalid." },
 381     { 0x0000010C, "Broadcast Message Class is invalid." },
 382     { 0x0000010D, "broadcast_sm operation failed." },
 383     { 0x0000010E, "query_broadcast_sm operation failed." },
 384     { 0x0000010F, "cancel_broadcast_sm operation failed." },
 385     { 0x00000110, "Number of Repeated Broadcasts is invalid." },
 386     { 0x00000111, "Broadcast Service Group is invalid." },
 387     { 0x00000112, "Broadcast Channel Indicator is invalid." },
 388     { 0, NULL }
 389 };
 390
 391 static const value_string vals_tlv_tags[] = {
 392     { 0x0005, "dest_addr_subunit" },
 393     { 0x0006, "dest_network_type" },
 394     { 0x0007, "dest_bearer_type" },
 395     { 0x0008, "dest_telematics_id" },
 396     { 0x000D, "source_addr_subunit" },
 397     { 0x000E, "source_network_type" },
 398     { 0x000F, "source_bearer_type" },
 399     { 0x0010, "source_telematics_id" },
 400     { 0x0017, "qos_time_to_live" },
 401     { 0x0019, "payload_type" },
 402     { 0x001D, "additional_status_info_text" },
 403     { 0x001E, "receipted_message_id" },
 404     { 0x0030, "ms_msg_wait_facilities" },
 405     { 0x0201, "privacy_indicator" },
 406     { 0x0202, "source_subaddress" },
 407     { 0x0203, "dest_subaddress" },
 408     { 0x0204, "user_message_reference" },
 409     { 0x0205, "user_response_code" },
 410     { 0x020A, "source_port" },
 411     { 0x020B, "dest_port" },
 412     { 0x020C, "sar_msg_ref_num" },
 413     { 0x020D, "language_indicator" },
 414     { 0x020E, "sar_total_segments" },
 415     { 0x020F, "sar_segment_seqnum" },
 416     { 0x0210, "sc_interface_version" },
 417     { 0x0302, "callback_num_pres_ind" },
 418     { 0x0303, "callback_num_atag" },
 419     { 0x0304, "number_of_messages" },
 420     { 0x0381, "callback_num" },
 421     { 0x0420, "dpf_result" },
 422     { 0x0421, "set_dpf" },
 423     { 0x0422, "ms_availability_status" },
 424     { 0x0423, "network_error_code" },
 425     { 0x0424, "message_payload" },
 426     { 0x0425, "delivery_failure_reason" },
 427     { 0x0426, "more_messages_to_send" },
 428     { 0x0427, "message_state" },
 429     { 0x0428, "congestion_state" },
 430     { 0x0501, "ussd_service_op" },
 431     { 0x0600, "broadcast_channel_indicator" },
 432     { 0x0601, "broadcast_content_type" },
 433     { 0x0602, "broadcast_content_type_info" },
 434     { 0x0603, "broadcast_message_class" },
 435     { 0x0604, "broadcast_rep_num" },
 436     { 0x0605, "broadcast_frequency_interval" },
 437     { 0x0606, "broadcast_area_identifier" },
 438     { 0x0607, "broadcast_error_status" },
 439     { 0x0608, "broadcast_area_success" },
 440     { 0x0609, "broadcast_end_time" },
 441     { 0x060A, "broadcast_service_group" },
 442     { 0x060B, "billing_identification" },
 443     { 0x060D, "source_network_id" },
 444     { 0x060E, "dest_network_id" },
 445     { 0x060F, "source_node_id" },
 446     { 0x0610, "dest_node_id" },
 447     { 0x0611, "dest_addr_np_resolution" },
 448     { 0x0612, "dest_addr_np_information" },
 449     { 0x0613, "dest_addr_np_country" },
 450     { 0x1201, "display_time" },
 451     { 0x1203, "sms_signal" },
 452     { 0x1204, "ms_validity" },
 453     { 0x130C, "alert_on_message_delivery" },
 454     { 0x1380, "its_reply_type" },
 455     { 0x1383, "its_session_info" },
 456     { 0, NULL }
 457 };
 458
 459 static const value_string vals_addr_ton[] = {
 460     { 0, "Unknown" },
 461     { 1, "International" },
 462     { 2, "National" },
 463     { 3, "Network specific" },
 464     { 4, "Subscriber number" },
 465     { 5, "Alphanumeric" },
 466     { 6, "Abbreviated" },
 467     { 0, NULL }
 468 };
 469
 470 static const value_string vals_addr_npi[] = {
 471     {  0, "Unknown" },
 472     {  1, "ISDN (E163/E164)" },
 473     {  3, "Data (X.121)" },
 474     {  4, "Telex (F.69)" },
 475     {  6, "Land mobile (E.212)" },
 476     {  8, "National" },
 477     {  9, "Private" },
 478     { 10, "ERMES" },
 479     { 14, "Internet (IP)" },
 480     { 18, "WAP client Id" },
 481     {  0, NULL }
 482 };
 483
 484 static const value_string vals_esm_submit_msg_mode[] = {
 485     {  0x0, "Default SMSC mode" },
 486     {  0x1, "Datagram mode" },
 487     {  0x2, "Forward mode" },
 488     {  0x3, "Store and forward mode" },
 489     {  0, NULL }
 490 };
 491
 492 static const value_string vals_esm_submit_msg_type[] = {
 493     {  0x0, "Default message type" },
 494     {  0x1, "Short message contains SMSC Delivery Receipt" },
 495     {  0x2, "Short message contains (E)SME delivery acknowledgement" },
 496     {  0x3, "Reserved" },
 497     {  0x4, "Short message contains (E)SME manual/user acknowledgement" },
 498     {  0x5, "Reserved" },
 499     {  0x6, "Short message contains conversation abort" },
 500     {  0x7, "Reserved" },
 501     {  0x8, "Short message contains intermediate delivery notification" },
 502     {  0, NULL }
 503 };
 504
 505 static const value_string vals_esm_submit_features[] = {
 506     {  0x0, "No specific features selected" },
 507     {  0x1, "UDHI indicator" },
 508     {  0x2, "Reply path" },
 509     {  0x3, "UDHI and reply path" },
 510     {  0, NULL }
 511 };
 512
 513 static const value_string vals_priority_flag[] = {
 514     {  0, "GSM: None      ANSI-136: Bulk         IS-95: Normal" },
 515     {  1, "GSM: priority  ANSI-136: Normal       IS-95: Interactive" },
 516     {  2, "GSM: priority  ANSI-136: Urgent       IS-95: Urgent" },
 517     {  3, "GSM: priority  ANSI-136: Very Urgent  IS-95: Emergency" },
 518     {  0, NULL }
 519 };
 520
 521 static const value_string vals_regdel_receipt[] = {
 522     {  0x0, "No SMSC delivery receipt requested" },
 523     {  0x1, "Delivery receipt requested (for success or failure)" },
 524     {  0x2, "Delivery receipt requested (for failure)" },
 525     {  0x3, "Reserved in version <= 3.4; Delivery receipt requested (for success) in 5.0" },
 526     {  0, NULL }
 527 };
 528
 529 static const value_string vals_regdel_acks[] = {
 530     {  0x0, "No recipient SME acknowledgement requested" },
 531     {  0x1, "SME delivery acknowledgement requested" },
 532     {  0x2, "SME manual/user acknowledgement requested" },
 533     {  0x3, "Both delivery and manual/user acknowledgement requested" },
 534     {  0, NULL }
 535 };
 536
 537 static const value_string vals_regdel_notif[] = {
 538     {  0x0, "No intermediate notification requested" },
 539     {  0x1, "Intermediate notification requested" },
 540     {  0, NULL }
 541 };
 542
 543 static const value_string vals_replace_if_present_flag[] = {
 544     {  0x0, "Don't replace" },
 545     {  0x1, "Replace" },
 546     {  0, NULL }
 547 };
 548
 549 static const value_string vals_data_coding[] = {
 550     {  0, "SMSC default alphabet" },
 551     {  1, "IA5 (CCITT T.50/ASCII (ANSI X3.4)" },
 552     {  2, "Octet unspecified (8-bit binary)" },
 553     {  3, "Latin 1 (ISO-8859-1)" },
 554     {  4, "Octet unspecified (8-bit binary)" },
 555     {  5, "JIS (X 0208-1990)" },
 556     {  6, "Cyrillic (ISO-8859-5)" },
 557     {  7, "Latin/Hebrew (ISO-8859-8)" },
 558     {  8, "UCS2 (ISO/IEC-10646)" },
 559     {  9, "Pictogram encoding" },
 560     {  10, "ISO-2022-JP (Music codes)" },
 561     {  11, "reserved" },
 562     {  12, "reserved" },
 563     {  13, "Extended Kanji JIS(X 0212-1990)" },
 564     {  14, "KS C 5601" },
 565     /*! \TODO Rest to be defined (bitmask?) according GSM 03.38 */
 566     {  0, NULL }
 567 };
 568
 569 static const value_string vals_message_state[] = {
 570     {  1, "ENROUTE" },
 571     {  2, "DELIVERED" },
 572     {  3, "EXPIRED" },
 573     {  4, "DELETED" },
 574     {  5, "UNDELIVERABLE" },
 575     {  6, "ACCEPTED" },
 576     {  7, "UNKNOWN" },
 577     {  8, "REJECTED" },
 578     {  0, NULL }
 579 };
 580
 581 static const value_string vals_addr_subunit[] = {
 582     {  0, "Unknown -default-" },
 583     {  1, "MS Display" },
 584     {  2, "Mobile equipment" },
 585     {  3, "Smart card 1" },
 586     {  4, "External unit 1" },
 587     {  0, NULL }
 588 };
 589
 590 static const value_string vals_network_type[] = {
 591     {  0, "Unknown" },
 592     {  1, "GSM" },
 593     {  2, "ANSI-136/TDMA" },
 594     {  3, "IS-95/CDMA" },
 595     {  4, "PDC" },
 596     {  5, "PHS" },
 597     {  6, "iDEN" },
 598     {  7, "AMPS" },
 599     {  8, "Paging network" },
 600     {  0, NULL }
 601 };
 602
 603 static const value_string vals_bearer_type[] = {
 604     {  0, "Unknown" },
 605     {  1, "SMS" },
 606     {  2, "Circuit Switched Data (CSD)" },
 607     {  3, "Packet data" },
 608     {  4, "USSD" },
 609     {  5, "CDPD" },
 610     {  6, "DataTAC" },
 611     {  7, "FLEX/ReFLEX" },
 612     {  8, "Cell Broadcast" },
 613     {  0, NULL }
 614 };
 615
 616 static const value_string vals_payload_type[] = {
 617     {  0, "Default" },
 618     {  1, "WCMP message" },
 619     {  0, NULL }
 620 };
 621
 622 static const value_string vals_privacy_indicator[] = {
 623     {  0, "Not restricted -default-" },
 624     {  1, "Restricted" },
 625     {  2, "Confidential" },
 626     {  3, "Secret" },
 627     {  0, NULL }
 628 };
 629
 630 static const value_string vals_language_indicator[] = {
 631     {  0, "Unspecified -default-" },
 632     {  1, "english" },
 633     {  2, "french" },
 634     {  3, "spanish" },
 635     {  4, "german" },
 636     {  5, "portuguese" },
 637     {  0, NULL }
 638 };
 639
 640 static const value_string vals_display_time[] = {
 641     {  0, "Temporary" },
 642     {  1, "Default -default-" },
 643     {  2, "Invoke" },
 644     {  0, NULL }
 645 };
 646
 647 static const value_string vals_ms_validity[] = {
 648     {  0, "Store indefinitely -default-" },
 649     {  1, "Power down" },
 650     {  2, "SID based registration area" },
 651     {  3, "Display only" },
 652     {  0, NULL }
 653 };
 654
 655 static const value_string vals_dpf_result[] = {
 656     {  0, "DPF not set" },
 657     {  1, "DPF set" },
 658     {  0, NULL }
 659 };
 660
 661 static const value_string vals_set_dpf[] = {
 662     {  0, "Not requested (Set DPF for delivery failure)" },
 663     {  1, "Requested (Set DPF for delivery failure)" },
 664     {  0, NULL }
 665 };
 666
 667 static const value_string vals_ms_availability_status[] = {
 668     {  0, "Available -default-" },
 669     {  1, "Denied" },
 670     {  2, "Unavailable" },
 671     {  0, NULL }
 672 };
 673
 674 static const value_string vals_delivery_failure_reason[] = {
 675     {  0, "Destination unavailable" },
 676     {  1, "Destination address invalid" },
 677     {  2, "Permanent network error" },
 678     {  3, "Temporary network error" },
 679     {  0, NULL }
 680 };
 681
 682 static const value_string vals_more_messages_to_send[] = {
 683     {  0, "No more messages" },
 684     {  1, "More messages -default-" },
 685     {  0, NULL }
 686 };
 687
 688 static const value_string vals_its_reply_type[] = {
 689     {  0, "Digit" },
 690     {  1, "Number" },
 691     {  2, "Telephone no." },
 692     {  3, "Password" },
 693     {  4, "Character line" },
 694     {  5, "Menu" },
 695     {  6, "Date" },
 696     {  7, "Time" },
 697     {  8, "Continue" },
 698     {  0, NULL }
 699 };
 700
 701 static const value_string vals_ussd_service_op[] = {
 702     {  0, "PSSD indication" },
 703     {  1, "PSSR indication" },
 704     {  2, "USSR request" },
 705     {  3, "USSN request" },
 706     { 16, "PSSD response" },
 707     { 17, "PSSR response" },
 708     { 18, "USSR confirm" },
 709     { 19, "USSN confirm" },
 710     {  0, NULL }
 711 };
 712
 713 static const value_string vals_msg_wait_ind[] = {
 714     {  0, "Set indication inactive" },
 715     {  1, "Set indication active" },
 716     {  0, NULL }
 717 };
 718
 719 static const value_string vals_msg_wait_type[] = {
 720     {  0, "Voicemail message waiting" },
 721     {  1, "Fax message waiting" },
 722     {  2, "Electronic mail message waiting" },
 723     {  3, "Other message waiting" },
 724     {  0, NULL }
 725 };
 726
 727 static const value_string vals_callback_num_pres[] = {
 728     {  0, "Presentation allowed" },
 729     {  1, "Presentation restricted" },
 730     {  2, "Number not available" },
 731     {  3, "[Reserved]" },
 732     {  0, NULL }
 733 };
 734
 735 static const value_string vals_callback_num_scrn[] = {
 736     {  0, "User provided, not screened" },
 737     {  1, "User provided, verified and passed" },
 738     {  2, "User provided, verified and failed" },
 739     {  3, "Network provided" },
 740     {  0, NULL }
 741 };
 742
 743 static const value_string vals_network_error_type[] = {
 744     {  1, "ANSI-136 (Access Denied Reason)" },
 745     {  2, "IS-95 (Access Denied Reason)" },
 746     {  3, "GSM" },
 747     {  4, "[Reserved] in <= 3.4; ANSI 136 Cause Code in 5.0" },
 748     {  5, "[Reserved] in <= 3.4; IS 95 Cause Code in 5.0" },
 749     {  6, "[Reserved] in <= 3.4; ANSI-41 Error in 5.0" },
 750     {  7, "[Reserved] in <= 3.4; SMPP Error in 5.0" },
 751     {  8, "[Reserved] in <= 3.4; Message Center Specific in 5.0" },
 752     {  0, NULL }
 753 };
 754
 755 static const value_string vals_its_session_ind[] = {
 756     {  0, "End of session indicator inactive" },
 757     {  1, "End of session indicator active" },
 758     {  0, NULL }
 759 };
 760
 761 /* Data Coding Scheme: see 3GPP TS 23.040 and 3GPP TS 23.038 */
 762 static const value_string vals_dcs_sms_coding_group[] = {
 763     { 0x00, "SMS DCS: General Data Coding indication - Uncompressed text, no message class" },
 764     { 0x01, "SMS DCS: General Data Coding indication - Uncompressed text" },
 765     { 0x02, "SMS DCS: General Data Coding indication - Compressed text, no message class" },
 766     { 0x03, "SMS DCS: General Data Coding indication - Compressed text" },
 767     { 0x04, "SMS DCS: Message Marked for Automatic Deletion - Uncompressed text, no message class" },
 768     { 0x05, "SMS DCS: Message Marked for Automatic Deletion - Uncompressed text" },
 769     { 0x06, "SMS DCS: Message Marked for Automatic Deletion - Compressed text, no message class" },
 770     { 0x07, "SMS DCS: Message Marked for Automatic Deletion - Compressed text" },
 771     { 0x08, "SMS DCS: Reserved" },
 772     { 0x09, "SMS DCS: Reserved" },
 773     { 0x0A, "SMS DCS: Reserved" },
 774     { 0x0B, "SMS DCS: Reserved" },
 775     { 0x0C, "SMS DCS: Message Waiting Indication - Discard Message" },
 776     { 0x0D, "SMS DCS: Message Waiting Indication - Store Message (GSM 7-bit default alphabet)" },
 777     { 0x0E, "SMS DCS: Message Waiting Indication - Store Message (UCS-2 character set)" },
 778     { 0x0F, "SMS DCS: Data coding / message class" },
 779     { 0x00, NULL }
 780 };
 781
 782 static const true_false_string tfs_dcs_text_compression = {
 783     "Compressed text",
 784     "Uncompressed text"
 785 };
 786
 787 static const true_false_string tfs_dcs_class_present = {
 788     "Message class is present",
 789     "No message class"
 790 };
 791
 792 static const value_string vals_dcs_charset[] = {
 793     { 0x00, "GSM 7-bit default alphabet" },
 794     { 0x01, "8-bit data" },
 795     { 0x02, "UCS-2 (16-bit) data" },
 796     { 0x03, "Reserved" },
 797     { 0x00, NULL }
 798 };
 799
 800 static const value_string vals_dcs_class[] = {
 801     { 0x00, "Class 0" },
 802     { 0x01, "Class 1 - ME specific" },
 803     { 0x02, "Class 2 - (U)SIM specific" },
 804     { 0x03, "Class 3 - TE specific" },
 805     { 0x00, NULL }
 806 };
 807
 808 static const value_string vals_dcs_cbs_coding_group[] = {
 809     { 0x00, "CBS DCS: Language using the GSM 7-bit default alphabet" },
 810     { 0x01, "CBS DCS: Language indication at beginning of message" },
 811     { 0x02, "CBS DCS: Language using the GSM 7-bit default alphabet" },
 812     { 0x03, "CBS DCS: Reserved" },
 813     { 0x04, "CBS DCS: General Data Coding indication - Uncompressed text, no message class" },
 814     { 0x05, "CBS DCS: General Data Coding indication - Uncompressed text" },
 815     { 0x06, "CBS DCS: General Data Coding indication - Compressed text, no message class" },
 816     { 0x07, "CBS DCS: General Data Coding indication - Compressed text" },
 817     { 0x08, "CBS DCS: Reserved" },
 818     { 0x09, "CBS DCS: Message with User Data Header structure" },
 819     { 0x0A, "CBS DCS: Reserved" },
 820     { 0x0B, "CBS DCS: Reserved" },
 821     { 0x0C, "CBS DCS: Reserved" },
 822     { 0x0D, "CBS DCS: Reserved" },
 823     { 0x0E, "CBS DCS: Defined by the WAP Forum" },
 824     { 0x0F, "SMS DCS: Data coding / message class" },
 825     { 0x00, NULL }
 826 };
 827
 828 static const value_string vals_dcs_cbs_language[] = {
 829     { 0x00, "German" },
 830     { 0x01, "English" },
 831     { 0x02, "Italian" },
 832     { 0x03, "French" },
 833     { 0x04, "Spanish" },
 834     { 0x05, "Dutch" },
 835     { 0x06, "Swedish" },
 836     { 0x07, "Danish" },
 837     { 0x08, "Portuguese" },
 838     { 0x09, "Finnish" },
 839     { 0x0A, "Norwegian" },
 840     { 0x0B, "Greek" },
 841     { 0x0C, "Turkish" },
 842     { 0x0D, "Hungarian" },
 843     { 0x0E, "Polish" },
 844     { 0x0F, "Language not specified" },
 845     { 0x10, "GSM 7-bit default alphabet - message preceded by language indication" },
 846     { 0x11, "UCS-2 (16-bit) - message preceded by language indication" },
 847     { 0x20, "Czech" },
 848     { 0x21, "Hebrew" },
 849     { 0x22, "Arabic" },
 850     { 0x23, "Russian" },
 851     { 0x24, "Icelandic" },
 852     { 0x00, NULL }
 853 };
 854
 855 static const value_string vals_dcs_cbs_class[] = {
 856     { 0x00, "No message class" },
 857     { 0x01, "Class 1 - User defined" },
 858     { 0x02, "Class 2 - User defined" },
 859     { 0x03, "Class 3 - TE specific" },
 860     { 0x00, NULL }
 861 };
 862
 863 static const value_string vals_dcs_wap_class[] = {
 864     { 0x00, "No message class" },
 865     { 0x01, "Class 1 - ME specific" },
 866     { 0x02, "Class 2 - (U)SIM specific" },
 867     { 0x03, "Class 3 - TE specific" },
 868     { 0x00, NULL }
 869 };
 870
 871 static const value_string vals_dcs_wap_charset[] = {
 872     { 0x00, "Reserved" },
 873     { 0x01, "8-bit data" },
 874     { 0x02, "Reserved" },
 875     { 0x03, "Reserved" },
 876     { 0x00, NULL }
 877 };
 878
 879 static const value_string vals_alert_on_message_delivery[] = {
 880     { 0x00, "Use mobile default alert (Default)" },
 881     { 0x01, "Use low-priority alert" },
 882     { 0x02, "Use medium-priority alert" },
 883     { 0x03, "Use high-priority alert" },
 884     { 0x00, NULL }
 885 };
 886
 887 static const range_string vals_congestion_state[] = {
 888     {0,     0,      "Idle"},
 889     {1,     29,     "Low Load"},
 890     {30,    49,     "Medium Load"},
 891     {50,    79,     "High Load"},
 892     {80,    89,     "Optimum Load"}, /*Specs says 80-90, but that is probably a mistake */
 893     {90,    99,     "Nearing Congestion"},
 894     {100,   100,    "Congested / Maximum Load"},
 895     { 0,    0,      NULL }
 896 };
 897
 898 static const range_string vals_broadcast_channel_indicator[] = {
 899     {0,     0,      "Basic Broadcast Channel (Default)"},
 900     {1,     1,      "Extended Broadcast Channel"},
 901     {2,     255,    "[Reserved]"},
 902     { 0,    0,      NULL }
 903 };
 904
 905 static const value_string vals_broadcast_message_class[] = {
 906     {0, "No Class Specified (default)"},
 907     {1, "Class 1 (User Defined)"},
 908     {2, "Class 2 (User Defined)"},
 909     {3, "Class 3 (Terminal Equipment)"},
 910     {0, NULL }
 911 };
 912
 913 static const range_string vals_broadcast_area_success[] = {
 914     {0,     100,    "%"},
 915     {101,   254,    "[Reserved]"},
 916     {255,   255,    "Information not available"},
 917     { 0,    0,      NULL }
 918 };
 919
 920 static const value_string vals_broadcast_content_type_nw[] = {
 921     {0,     "Generic"},
 922     {1,     "GSM [23041]"},
 923     {2,     "TDMA [IS824][ANSI-41]"},
 924     {3,     "CDMA [IS824][IS637]"},
 925     {0,     NULL }
 926 };
 927
 928 static const value_string vals_broadcast_content_type_type[] = {
 929     {0x0000,        "[System Service] Index"},
 930     {0x0001,        "[System Service] Emergency Broadcasts"},
 931     {0x0002,        "[System Service] IRDB Download"},
 932     {0x0010,        "[News Service] News Flashes"},
 933     {0x0011,        "[News Service] General News (Local)"},
 934     {0x0012,        "[News Service] General News (Regional)"},
 935     {0x0013,        "[News Service] General News (National)"},
 936     {0x0014,        "[News Service] General News (Internationa)"},
 937     {0x0015,        "[News Service] Business/Financial News (Local)"},
 938     {0x0016,        "[News Service] Business/Financial News (Regional)"},
 939     {0x0017,        "[News Service] Business/Financial News (National)"},
 940     {0x0018,        "[News Service] Business/Financial News (International)"},
 941     {0x0019,        "[News Service] Sports News (Local)"},
 942     {0x001A,        "[News Service] Sports News (Regional)"},
 943     {0x001B,        "[News Service] Sports News (National)"},
 944     {0x001C,        "[News Service] Sports News (International)"},
 945     {0x001D,        "[News Service] Entertainment News (Local)"},
 946     {0x001E,        "[News Service] Entertainment News (Regional)"},
 947     {0x001F,        "[News Service] Entertainment News (National)"},
 948     {0x0020,        "[News Service] Entertainment News (International)"},
 949     {0x0021,        "[Subscriber Information Services] Medical/Health/Hospitals"},
 950     {0x0022,        "[Subscriber Information Services] Doctors"},
 951     {0x0023,        "[Subscriber Information Services] Pharmacy"},
 952     {0x0030,        "[Subscriber Information Services] Local Traffic/Road Reports"},
 953     {0x0031,        "[Subscriber Information Services] Long Distance Traffic/Road Reports"},
 954     {0x0032,        "[Subscriber Information Services] Taxis"},
 955     {0x0033,        "[Subscriber Information Services] Weather"},
 956     {0x0034,        "[Subscriber Information Services] Local Airport Flight Schedules"},
 957     {0x0035,        "[Subscriber Information Services] Restaurants"},
 958     {0x0036,        "[Subscriber Information Services] Lodgings"},
 959     {0x0037,        "[Subscriber Information Services] Retail Directory"},
 960     {0x0038,        "[Subscriber Information Services] Advertisements"},
 961     {0x0039,        "[Subscriber Information Services] Stock Quotes"},
 962     {0x0040,        "[Subscriber Information Services] Employment Opportunities"},
 963     {0x0041,        "[Subscriber Information Services] Technology News"},
 964     {0x0070,        "[Carrier Information Services] District (Base Station Info)"},
 965     {0x0071,        "[Carrier Information Services] Network Information"},
 966     {0x0080,        "[Subscriber Care Services] Operator Services"},
 967     {0x0081,        "[Subscriber Care Services] Directory Enquiries (National)"},
 968     {0x0082,        "[Subscriber Care Services] Directory Enquiries (International)"},
 969     {0x0083,        "[Subscriber Care Services] Customer Care (National)"},
 970     {0x0084,        "[Subscriber Care Services] Customer Care (International)"},
 971     {0x0085,        "[Subscriber Care Services] Local Date/Time/Time Zone"},
 972     {0x0100,        "[Multi Category Services] Multi Category Services"},
 973     {0x0000,        NULL }
 974 };
 975
 976 static const value_string vals_broadcast_frequency_interval_unit[] = {
 977     {0x00,  "As frequently as possible"},
 978     {0x08,  "seconds"},
 979     {0x09,  "minutes"},
 980     {0x0A,  "hours"},
 981     {0x0B,  "days"},
 982     {0x0C,  "weeks"},
 983     {0x0D,  "months"},
 984     {0x0E,  "years"},
 985     {0x00,  NULL }
 986 };
 987
 988 static const value_string vals_dest_addr_np_resolution[] = {
 989     {0x00,  "query has not been performed (default)"},
 990     {0x01,  "query has been performed, number not ported"},
 991     {0x02,  "query has been performed, number ported"},
 992     {0x00,  NULL }
 993 };
 994
 995 static const range_string vals_broadcast_area_identifier_format[] = {
 996     {0, 0, "Alias / Name"},
 997     {1, 1, "Ellipsoid Arc"},
 998     {2, 2, "Polygon"},
 999     {3, 255, "[Reserved]"},
1000     {0, 0,  NULL }
1001 };
1002
1003 static dissector_handle_t gsm_sms_handle;
1004
1005 /*
1006  * For Stats Tree
1007  */
1008 void
1009 smpp_stats_tree_init(stats_tree* st)
1010 {
1011     st_smpp_ops = stats_tree_create_node(st, "SMPP Operations", 0, TRUE);
1012     st_smpp_req = stats_tree_create_node(st, "SMPP Requests", st_smpp_ops, TRUE);
1013     st_smpp_res = stats_tree_create_node(st, "SMPP Responses", st_smpp_ops, TRUE);
1014     st_smpp_res_status = stats_tree_create_node(st, "SMPP Response Status", 0, TRUE);
1015
1016 }
1017
1018 int
1019 smpp_stats_tree_per_packet(stats_tree *st, /* st as it was passed to us */
1020                            packet_info *pinfo _U_,
1021                            epan_dissect_t *edt _U_,
1022                            const void *p) /* Used for getting SMPP command_id values */
1023 {
1024     smpp_tap_rec_t* tap_rec = (smpp_tap_rec_t*)p;
1025
1026     tick_stat_node(st, "SMPP Operations", 0, TRUE);
1027
1028     if ((tap_rec->command_id & 0x80000000) == 0x80000000) /* Response */
1029     {
1030         tick_stat_node(st, "SMPP Responses", st_smpp_ops, TRUE);
1031         tick_stat_node(st, val_to_str(tap_rec->command_id, vals_command_id, "Unknown 0x%08x"), st_smpp_res, FALSE);
1032
1033         tick_stat_node(st, "SMPP Response Status", 0, TRUE);
1034         tick_stat_node(st, val_to_str(tap_rec->command_status, vals_command_status, "Unknown 0x%08x"), st_smpp_res_status, FALSE);
1035
1036     }
1037     else  /* Request */
1038     {
1039         tick_stat_node(st, "SMPP Requests", st_smpp_ops, TRUE);
1040         tick_stat_node(st, val_to_str(tap_rec->command_id, vals_command_id, "Unknown 0x%08x"), st_smpp_req, FALSE);
1041     }
1042
1043     return 1;
1044 }
1045
1046 /*!
1047  * SMPP equivalent of mktime() (3). Convert date to standard 'time_t' format
1048  *
1049  * \param       datestr The SMPP-formatted date to convert
1050  * \param       secs    Returns the 'time_t' equivalent
1051  * \param       nsecs   Returns the additional nano-seconds
1052  *
1053  * \return              Whether time is specified relative or absolute
1054  * \retval      TRUE    Relative time
1055  * \retval      FALSE   Absolute time
1056  */
1057 static gboolean
1058 smpp_mktime(const char *datestr, time_t *secs, int *nsecs)
1059 {
1060     struct tm    r_time;
1061     time_t       t_diff;
1062     gboolean     relative = (datestr[15] == 'R') ? TRUE : FALSE;
1063
1064     r_time.tm_year = 10 * (datestr[0] - '0') + (datestr[1] - '0');
1065     /*
1066      * Y2K rollover date as recommended in appendix C
1067      */
1068     if (r_time.tm_year < 38)
1069         r_time.tm_year += 100;
1070     r_time.tm_mon  = 10 * (datestr[2] - '0') + (datestr[3] - '0');
1071     r_time.tm_mon--;
1072     r_time.tm_mday = 10 * (datestr[4] - '0') + (datestr[5] - '0');
1073     r_time.tm_hour = 10 * (datestr[6] - '0') + (datestr[7] - '0');
1074     r_time.tm_min  = 10 * (datestr[8] - '0') + (datestr[9] - '0');
1075     r_time.tm_sec  = 10 * (datestr[10] - '0') + (datestr[11] - '0');
1076     r_time.tm_isdst = -1;
1077
1078     if (relative == FALSE) {
1079         *secs = mktime(&r_time);
1080         *nsecs = (datestr[12] - '0') * 100000000;
1081         t_diff = (10 * (datestr[13] - '0') + (datestr[14] - '0')) * 900;
1082         if (datestr[15] == '+')
1083             *secs += t_diff;
1084         else if (datestr[15] == '-')
1085             *secs -= t_diff;
1086     } else {
1087         *secs = r_time.tm_sec + 60 *
1088             (r_time.tm_min + 60 *
1089              (r_time.tm_hour + 24 *
1090               r_time.tm_mday));
1091         *nsecs = 0;
1092     }
1093
1094     return relative;
1095 }
1096
1097 /*!
1098  * Scanning routines to add standard types (byte, int, string...) to the
1099  * protocol tree.
1100  *
1101  * \param       tree    The protocol tree to add to
1102  * \param       tvb     Buffer containing the data
1103  * \param       field   Actual field whose value needs displaying
1104  * \param       offset  Location of field in buffer, returns location of
1105  *                      next field
1106  */
1107 static void
1108 smpp_handle_string(proto_tree *tree, tvbuff_t *tvb, int field, int *offset)
1109 {
1110     guint        len;
1111
1112     len = tvb_strsize(tvb, *offset);
1113     if (len > 1) {
1114         proto_tree_add_string(tree, field, tvb, *offset, len,
1115                               (const char *) tvb_get_ptr(tvb, *offset, len));
1116     }
1117     (*offset) += len;
1118 }
1119
1120 /* NOTE - caller must free the returned string! */
1121 static char *
1122 smpp_handle_string_return(proto_tree *tree, tvbuff_t *tvb, int field, int *offset)
1123 {
1124     gint         len;
1125     char        *str;
1126
1127     len = tvb_strsize(tvb, *offset);
1128     if (len > 1) {
1129         str = (char *)tvb_get_ephemeral_stringz(tvb, *offset, &len);
1130         proto_tree_add_string(tree, field, tvb, *offset, len, str);
1131     } else {
1132         str = "";
1133     }
1134     (*offset) += len;
1135     return str;
1136 }
1137
1138 static void
1139 smpp_handle_string_z(proto_tree *tree, tvbuff_t *tvb, int field, int *offset,
1140                 const char *null_string)
1141 {
1142     gint         len;
1143
1144     len = tvb_strsize(tvb, *offset);
1145     if (len > 1) {
1146         proto_tree_add_string(tree, field, tvb, *offset, len,
1147                 (const char *)tvb_get_ptr(tvb, *offset, len));
1148     } else {
1149         proto_tree_add_string(tree, field, tvb, *offset, len, null_string);
1150     }
1151     (*offset) += len;
1152 }
1153
1154 static void
1155 smpp_handle_int1(proto_tree *tree, tvbuff_t *tvb, int field, int *offset)
1156 {
1157     guint8       val;
1158
1159     val = tvb_get_guint8(tvb, *offset);
1160     proto_tree_add_uint(tree, field, tvb, *offset, 1, val);
1161     (*offset)++;
1162 }
1163
1164 static void
1165 smpp_handle_int2(proto_tree *tree, tvbuff_t *tvb, int field, int *offset)
1166 {
1167     guint        val;
1168
1169     val = tvb_get_ntohs(tvb, *offset);
1170     proto_tree_add_uint(tree, field, tvb, *offset, 2, val);
1171     (*offset) += 2;
1172 }
1173
1174 static void
1175 smpp_handle_int4(proto_tree *tree, tvbuff_t *tvb, int field, int *offset)
1176 {
1177     guint        val;
1178
1179     val = tvb_get_ntohl(tvb, *offset);
1180     proto_tree_add_uint(tree, field, tvb, *offset, 4, val);
1181     (*offset) += 4;
1182 }
1183
1184 static void
1185 smpp_handle_time(proto_tree *tree, tvbuff_t *tvb,
1186                  int field, int field_R, int *offset)
1187 {
1188     char         *strval;
1189     gint         len;
1190     nstime_t     tmptime;
1191
1192     strval = (char *) tvb_get_ephemeral_stringz(tvb, *offset, &len);
1193     if (*strval)
1194     {
1195         if (len >= 16)
1196         {
1197             if (smpp_mktime(strval, &tmptime.secs, &tmptime.nsecs))
1198                 proto_tree_add_time(tree, field_R, tvb, *offset, len, &tmptime);
1199             else
1200                 proto_tree_add_time(tree, field, tvb, *offset, len, &tmptime);
1201         }
1202         else
1203         {
1204             proto_tree_add_text(tree, tvb, *offset, len, "Invalid time: %s", strval);
1205         }
1206     }
1207     *offset += len;
1208 }
1209
1210 /*!
1211  * Scanning routine to handle the destination-list of 'submit_multi'
1212  *
1213  * \param       tree    The protocol tree to add to
1214  * \param       tvb     Buffer containing the data
1215  * \param       offset  Location of field in buffer, returns location of
1216  *                      next field
1217  */
1218 static void
1219 smpp_handle_dlist(proto_tree *tree, tvbuff_t *tvb, int *offset)
1220 {
1221     guint8       entries;
1222     int          tmpoff = *offset;
1223     proto_item  *sub_tree = NULL;
1224     guint8       dest_flag;
1225
1226     if ((entries = tvb_get_guint8(tvb, tmpoff++)))
1227     {
1228         sub_tree = proto_tree_add_item(tree, hf_smpp_dlist,
1229                                         tvb, *offset, 1, FALSE);
1230         proto_item_add_subtree(sub_tree, ett_dlist);
1231     }
1232     while (entries--)
1233     {
1234         dest_flag = tvb_get_guint8(tvb, tmpoff++);
1235         if (dest_flag == 1)                     /* SME address  */
1236         {
1237             smpp_handle_int1(sub_tree, tvb, hf_smpp_dest_addr_ton, &tmpoff);
1238             smpp_handle_int1(sub_tree, tvb, hf_smpp_dest_addr_npi, &tmpoff);
1239             smpp_handle_string(sub_tree,tvb,hf_smpp_destination_addr,&tmpoff);
1240         }
1241         else                                    /* Distribution list    */
1242         {
1243             smpp_handle_string(sub_tree, tvb, hf_smpp_dl_name, &tmpoff);
1244         }
1245     }
1246     *offset = tmpoff;
1247 }
1248
1249 /*!
1250  * Scanning routine to handle the destination result list
1251  * of 'submit_multi_resp'
1252  *
1253  * \param       tree    The protocol tree to add to
1254  * \param       tvb     Buffer containing the data
1255  * \param       offset  Location of field in buffer, returns location of
1256  *                      next field
1257  */
1258 static void
1259 smpp_handle_dlist_resp(proto_tree *tree, tvbuff_t *tvb, int *offset)
1260 {
1261     guint8       entries;
1262     int          tmpoff = *offset;
1263     proto_item  *sub_tree = NULL;
1264
1265     if ((entries = tvb_get_guint8(tvb, tmpoff++)))
1266     {
1267         sub_tree = proto_tree_add_item(tree, hf_smpp_dlist_resp,
1268                                        tvb, *offset, 1, FALSE);
1269         proto_item_add_subtree(sub_tree, ett_dlist_resp);
1270     }
1271     while (entries--)
1272     {
1273         smpp_handle_int1(sub_tree, tvb, hf_smpp_dest_addr_ton, &tmpoff);
1274         smpp_handle_int1(sub_tree, tvb, hf_smpp_dest_addr_npi, &tmpoff);
1275         smpp_handle_string(sub_tree,tvb,hf_smpp_destination_addr,&tmpoff);
1276         smpp_handle_int4(sub_tree, tvb, hf_smpp_error_status_code, &tmpoff);
1277     }
1278     *offset = tmpoff;
1279 }
1280
1281 /*!
1282  * Scanning routine to handle all optional parameters of SMPP-operations.
1283  * The parameters have the format Tag Length Value (TLV), with a 2-byte tag
1284  * and 2-byte length.
1285  *
1286  * \param       tree    The protocol tree to add to
1287  * \param       tvb     Buffer containing the data
1288  * \param       offset  Location of field in buffer, returns location of
1289  *                      next field
1290  */
1291 static void
1292 smpp_handle_tlv(proto_tree *tree, tvbuff_t *tvb, int *offset)
1293 {
1294     proto_item  *tlvs_tree = NULL;
1295
1296     if (tvb_reported_length_remaining(tvb, *offset) >= 1)
1297     {
1298         tlvs_tree = proto_tree_add_item(tree, hf_smpp_opt_params,
1299                                        tvb, *offset, -1, FALSE);
1300         proto_item_add_subtree(tlvs_tree, ett_opt_params);
1301     }
1302
1303     while (tvb_reported_length_remaining(tvb, *offset) >= 1)
1304     {
1305         proto_item *sub_tree;
1306         guint16  tag;
1307         guint16  length;
1308
1309         guint8   field;
1310         guint16  field16;
1311         guint8   major, minor;
1312         char     *strval=NULL;
1313
1314         tag = tvb_get_ntohs(tvb, *offset);
1315         length = tvb_get_ntohs(tvb, (*offset+2));
1316
1317         sub_tree = proto_tree_add_none_format(tlvs_tree, hf_smpp_opt_param,
1318                                               tvb, *offset, length+4,
1319                                               "Optional parameter: %s (0x%04x)",
1320                                               val_to_str(tag, vals_tlv_tags, "0x%04x"), tag);
1321         proto_item_add_subtree(sub_tree, ett_opt_param);
1322         proto_tree_add_uint(sub_tree,hf_smpp_opt_param_tag,tvb,*offset,2,tag);
1323         proto_tree_add_uint(sub_tree,hf_smpp_opt_param_len,tvb,*offset+2,2,length);
1324
1325         *offset += 4;
1326
1327         switch (tag) {
1328             case  0x0005:       /* dest_addr_subunit    */
1329                 smpp_handle_int1(sub_tree, tvb,
1330                                  hf_smpp_dest_addr_subunit, offset);
1331                 break;
1332             case  0x0006:       /* dest_network_type    */
1333                 smpp_handle_int1(sub_tree, tvb,
1334                                  hf_smpp_dest_network_type, offset);
1335                 break;
1336             case  0x0007:       /* dest_bearer_type     */
1337                 smpp_handle_int1(sub_tree, tvb,
1338                                  hf_smpp_dest_bearer_type, offset);
1339                 break;
1340             case  0x0008:       /* dest_telematics_id   */
1341                 smpp_handle_int2(sub_tree, tvb,
1342                                  hf_smpp_dest_telematics_id, offset);
1343                 break;
1344             case  0x000D:       /* source_addr_subunit  */
1345                 smpp_handle_int1(sub_tree, tvb,
1346                                  hf_smpp_source_addr_subunit, offset);
1347                 break;
1348             case  0x000E:       /* source_network_type  */
1349                 smpp_handle_int1(sub_tree, tvb,
1350                                  hf_smpp_source_network_type, offset);
1351                 break;
1352             case  0x000F:       /* source_bearer_type   */
1353                 smpp_handle_int1(sub_tree, tvb,
1354                                  hf_smpp_source_bearer_type, offset);
1355                 break;
1356             case  0x0010:       /* source_telematics_id */
1357                 smpp_handle_int2(sub_tree, tvb,
1358                                  hf_smpp_source_telematics_id, offset);
1359                 break;
1360             case  0x0017:       /* qos_time_to_live     */
1361                 smpp_handle_int4(sub_tree, tvb,
1362                                  hf_smpp_qos_time_to_live, offset);
1363                 break;
1364             case  0x0019:       /* payload_type */
1365                 smpp_handle_int1(sub_tree, tvb,
1366                                  hf_smpp_payload_type, offset);
1367                 break;
1368             case  0x001D:       /* additional_status_info_text  */
1369                 smpp_handle_string(sub_tree, tvb,
1370                                    hf_smpp_additional_status_info_text, offset);
1371                 break;
1372             case  0x001E:       /* receipted_message_id */
1373                 smpp_handle_string(sub_tree, tvb,
1374                                    hf_smpp_receipted_message_id, offset);
1375                 break;
1376             case  0x0030:       /* ms_msg_wait_facilities       */
1377                 field = tvb_get_guint8(tvb, *offset);
1378                 proto_tree_add_item(sub_tree, hf_smpp_msg_wait_ind,
1379                                     tvb, *offset, 1, field);
1380                 proto_tree_add_item(sub_tree, hf_smpp_msg_wait_type,
1381                                     tvb, *offset, 1, field);
1382                 (*offset)++;
1383                 break;
1384             case  0x0201:       /* privacy_indicator    */
1385                 smpp_handle_int1(sub_tree, tvb,
1386                                  hf_smpp_privacy_indicator, offset);
1387                 break;
1388             case  0x0202:       /* source_subaddress    */
1389                 if (length) {
1390                     proto_tree_add_item(sub_tree, hf_smpp_source_subaddress,
1391                                     tvb, *offset, length, FALSE);
1392                     (*offset) += length;
1393                 }
1394                 break;
1395             case  0x0203:       /* dest_subaddress      */
1396                 if (length) {
1397                     proto_tree_add_item(sub_tree, hf_smpp_dest_subaddress,
1398                                     tvb, *offset, length, FALSE);
1399                     (*offset) += length;
1400                 }
1401                 break;
1402             case  0x0204:       /* user_message_reference       */
1403                 smpp_handle_int2(sub_tree, tvb,
1404                                  hf_smpp_user_message_reference, offset);
1405                 break;
1406             case  0x0205:       /* user_response_code   */
1407                 smpp_handle_int1(sub_tree, tvb,
1408                                  hf_smpp_user_response_code, offset);
1409                 break;
1410             case  0x020A:       /* source_port  */
1411                 smpp_handle_int2(sub_tree, tvb,
1412                                  hf_smpp_source_port, offset);
1413                 break;
1414             case  0x020B:       /* destination_port     */
1415                 smpp_handle_int2(sub_tree, tvb,
1416                                  hf_smpp_destination_port, offset);
1417                 break;
1418             case  0x020C:       /* sar_msg_ref_num      */
1419                 smpp_handle_int2(sub_tree, tvb,
1420                                  hf_smpp_sar_msg_ref_num, offset);
1421                 break;
1422             case  0x020D:       /* language_indicator   */
1423                 smpp_handle_int1(sub_tree, tvb,
1424                                  hf_smpp_language_indicator, offset);
1425                 break;
1426             case  0x020E:       /* sar_total_segments   */
1427                 smpp_handle_int1(sub_tree, tvb,
1428                                  hf_smpp_sar_total_segments, offset);
1429                 break;
1430             case  0x020F:       /* sar_segment_seqnum   */
1431                 smpp_handle_int1(sub_tree, tvb,
1432                                  hf_smpp_sar_segment_seqnum, offset);
1433                 break;
1434             case  0x0210:       /* SC_interface_version */
1435                 field = tvb_get_guint8(tvb, *offset);
1436                 minor = field & 0x0F;
1437                 major = (field & 0xF0) >> 4;
1438                 strval=ep_strdup_printf("%u.%u", major, minor);
1439                 proto_tree_add_string(sub_tree, hf_smpp_SC_interface_version,
1440                                       tvb, *offset, 1, strval);
1441                 (*offset)++;
1442                 break;
1443             case  0x0302:       /* callback_num_pres_ind        */
1444                 field = tvb_get_guint8(tvb, *offset);
1445                 proto_tree_add_item(sub_tree, hf_smpp_callback_num_pres,
1446                                     tvb, *offset, 1, field);
1447                 proto_tree_add_item(sub_tree, hf_smpp_callback_num_scrn,
1448                                     tvb, *offset, 1, field);
1449                 (*offset)++;
1450                 break;
1451             case  0x0303:       /* callback_num_atag    */
1452                 if (length)
1453                     proto_tree_add_item(sub_tree, hf_smpp_callback_num_atag,
1454                                         tvb, *offset, length, FALSE);
1455                 (*offset) += length;
1456                 break;
1457             case  0x0304:       /* number_of_messages   */
1458                 smpp_handle_int1(sub_tree, tvb,
1459                                  hf_smpp_number_of_messages, offset);
1460                 break;
1461             case  0x0381:       /* callback_num */
1462                 if (length)
1463                     proto_tree_add_item(sub_tree, hf_smpp_callback_num,
1464                                         tvb, *offset, length, FALSE);
1465                 (*offset) += length;
1466                 break;
1467             case  0x0420:       /* dpf_result   */
1468                 smpp_handle_int1(sub_tree, tvb,
1469                                  hf_smpp_dpf_result, offset);
1470                 break;
1471             case  0x0421:       /* set_dpf      */
1472                 smpp_handle_int1(sub_tree, tvb,
1473                                  hf_smpp_set_dpf, offset);
1474                 break;
1475             case  0x0422:       /* ms_availability_status       */
1476                 smpp_handle_int1(sub_tree, tvb,
1477                                  hf_smpp_ms_availability_status, offset);
1478                 break;
1479             case  0x0423:       /* network_error_code   */
1480                 smpp_handle_int1(sub_tree, tvb,
1481                                  hf_smpp_network_error_type, offset);
1482                 smpp_handle_int2(sub_tree, tvb,
1483                                  hf_smpp_network_error_code, offset);
1484                 break;
1485             case  0x0424:       /* message_payload      */
1486                 if (length)
1487                     proto_tree_add_item(sub_tree, hf_smpp_message_payload,
1488                                         tvb, *offset, length, FALSE);
1489                 (*offset) += length;
1490                 break;
1491             case  0x0425:       /* delivery_failure_reason      */
1492                 smpp_handle_int1(sub_tree, tvb,
1493                                  hf_smpp_delivery_failure_reason, offset);
1494                 break;
1495             case  0x0426:       /* more_messages_to_send        */
1496                 smpp_handle_int1(sub_tree, tvb,
1497                                  hf_smpp_more_messages_to_send, offset);
1498                 break;
1499             case  0x0427:       /* message_state        */
1500                 smpp_handle_int1(sub_tree, tvb,
1501                                  hf_smpp_message_state, offset);
1502                 break;
1503             case        0x0428: /* congestion_state */
1504                 smpp_handle_int1(sub_tree, tvb,
1505                                  hf_smpp_congestion_state, offset);
1506
1507                 break;
1508             case  0x0501:       /* ussd_service_op      */
1509                 smpp_handle_int1(sub_tree, tvb,
1510                                  hf_smpp_ussd_service_op, offset);
1511                 break;
1512             case 0x0600:        /* broadcast_channel_indicator */
1513                 smpp_handle_int1(sub_tree, tvb,
1514                                  hf_smpp_broadcast_channel_indicator, offset);
1515                 break;
1516             case 0x0601:        /* broadcast_content_type */
1517                 field = tvb_get_guint8(tvb, *offset);
1518                 proto_tree_add_uint(sub_tree, hf_smpp_broadcast_content_type_nw, tvb, *offset, 1, field);
1519                 (*offset)++;
1520                 field16 = tvb_get_ntohs(tvb, *offset);
1521                 proto_tree_add_uint(sub_tree, hf_smpp_broadcast_content_type_type, tvb, *offset, 2, field16);
1522                 (*offset) += 2;
1523                 break;
1524             case 0x0602:        /* broadcast_content_type_info */
1525                 if (length)
1526                     proto_tree_add_item(sub_tree, hf_smpp_broadcast_content_type_info,
1527                                         tvb, *offset, length, FALSE);
1528                 (*offset) += length;
1529                 break;
1530             case 0x0603:        /* broadcast_message_class */
1531                 smpp_handle_int1(sub_tree, tvb,
1532                                 hf_smpp_broadcast_message_class, offset);
1533                 break;
1534             case 0x0604:        /* broadcast_rep_num */
1535                 smpp_handle_int1(sub_tree, tvb,
1536                                 hf_smpp_broadcast_rep_num, offset);
1537                 break;
1538             case 0x0605:        /* broadcast_frequency_interval */
1539                 field = tvb_get_guint8(tvb, *offset);
1540                 proto_tree_add_uint(sub_tree, hf_smpp_broadcast_frequency_interval_unit, tvb, *offset, 1, field);
1541                 (*offset)++;
1542                 field16 = tvb_get_ntohs(tvb, *offset);
1543                 proto_tree_add_uint(sub_tree, hf_smpp_broadcast_frequency_interval_value, tvb, *offset, 2, field16);
1544                 (*offset) += 2;
1545                 break;
1546             case 0x0606:        /* broadcast_area_identifier */
1547                 field = tvb_get_guint8(tvb, *offset);
1548                 proto_tree_add_uint(sub_tree, hf_smpp_broadcast_area_identifier_format, tvb, *offset, 1, field);
1549                 proto_tree_add_item(sub_tree, hf_smpp_broadcast_area_identifier,
1550                                         tvb, *offset, length, FALSE);
1551                 (*offset) += length;
1552                 break;
1553             case 0x0607:        /* broadcast_error_status */
1554                 smpp_handle_int4(sub_tree, tvb,
1555                                 hf_smpp_broadcast_error_status, offset);
1556                 break;
1557             case 0x0608:        /* broadcast_area_success */
1558                 smpp_handle_int1(sub_tree, tvb,
1559                                 hf_smpp_broadcast_area_success, offset);
1560                 break;
1561             case 0x0609:        /* broadcast_end_time */
1562                 smpp_handle_time(sub_tree, tvb, hf_smpp_broadcast_end_time,
1563                                 hf_smpp_broadcast_end_time_r, offset);
1564                 break;
1565             case 0x060A:        /* broadcast_service_group */
1566                 if (length)
1567                     proto_tree_add_item(sub_tree, hf_smpp_broadcast_service_group,
1568                                         tvb, *offset, length, FALSE);
1569                 (*offset) += length;
1570                 break;
1571             case 0x060B:        /* billing_identification */
1572                 if (length)
1573                     proto_tree_add_item(sub_tree, hf_smpp_billing_identification,
1574                                         tvb, *offset, length, FALSE);
1575                 (*offset) += length;
1576                 break;
1577             /* 0x060C is skipped in the specs for some reason :-? */
1578             case 0x060D:        /* source_network_id */
1579                 smpp_handle_string_z(sub_tree, tvb, hf_smpp_source_network_id,
1580                                 offset, "Empty!");
1581                 break;
1582             case 0x060E:        /* dest_network_id */
1583                 smpp_handle_string_z(sub_tree, tvb, hf_smpp_dest_network_id,
1584                                 offset, "Empty!");
1585                 break;
1586             case 0x060F:        /* source_node_id */
1587                 if (length)
1588                     proto_tree_add_item(sub_tree, hf_smpp_source_node_id,
1589                                         tvb, *offset, length, FALSE);
1590                 (*offset) += length;
1591                 break;
1592             case 0x0610:        /* dest_node_id */
1593                 if (length)
1594                     proto_tree_add_item(sub_tree, hf_smpp_dest_node_id,
1595                                         tvb, *offset, length, FALSE);
1596                 (*offset) += length;
1597                 break;
1598             case 0x0611:        /* dest_addr_np_resolution */
1599                 smpp_handle_int1(sub_tree, tvb,
1600                                 hf_smpp_dest_addr_np_resolution, offset);
1601                 break;
1602             case 0x0612:        /* dest_addr_np_information */
1603                 if (length)
1604                     proto_tree_add_item(sub_tree, hf_smpp_dest_addr_np_information,
1605                                         tvb, *offset, length, FALSE);
1606                 (*offset) += length;
1607                 break;
1608             case 0x0613:        /* dest_addr_np_country */
1609                 /* TODO : Fetch values from packet-e164? */
1610                 if (length)
1611                     proto_tree_add_item(sub_tree, hf_smpp_dest_addr_np_country,
1612                                         tvb, *offset, length, FALSE);
1613                 (*offset) += length;
1614                 break;
1615             case  0x1201:       /* display_time */
1616                 smpp_handle_int1(sub_tree, tvb,
1617                                  hf_smpp_display_time, offset);
1618                 break;
1619             case  0x1203:       /* sms_signal   */
1620                 smpp_handle_int2(sub_tree, tvb,
1621                                  hf_smpp_sms_signal, offset);
1622                 /*! \todo Fill as per TIA/EIA-136-710-A         */
1623                 break;
1624             case  0x1204:       /* ms_validity  */
1625                 smpp_handle_int1(sub_tree, tvb,
1626                                  hf_smpp_ms_validity, offset);
1627                 break;
1628             case  0x130C:       /* alert_on_message_delivery    */
1629                 if (length == 0) {
1630                         proto_tree_add_item(sub_tree,
1631                                     hf_smpp_alert_on_message_delivery_null,
1632                                     tvb, *offset, length, FALSE);
1633                 } else {
1634                         smpp_handle_int1(sub_tree, tvb,
1635                                     hf_smpp_alert_on_message_delivery, offset);
1636                 }
1637                 break;
1638             case  0x1380:       /* its_reply_type       */
1639                 smpp_handle_int1(sub_tree, tvb,
1640                                  hf_smpp_its_reply_type, offset);
1641                 break;
1642             case  0x1383:       /* its_session_info     */
1643                 smpp_handle_int1(sub_tree, tvb,
1644                                  hf_smpp_its_session_number, offset);
1645                 field = tvb_get_guint8(tvb, *offset);
1646                 proto_tree_add_item(sub_tree, hf_smpp_its_session_sequence,
1647                                     tvb, *offset, 1, field);
1648                 proto_tree_add_item(sub_tree, hf_smpp_its_session_ind,
1649                                     tvb, *offset, 1, field);
1650                 (*offset)++;
1651                 break;
1652
1653             default:
1654                 /* TODO : Hopefully to be implemented soon - handle vendor specific TLVs
1655                  * from a dictionary before treating them as unknown! */
1656                 if ((tag >= 0x1400) && (tag <= 0x3FFF)) {
1657                     proto_tree_add_item(sub_tree, hf_smpp_vendor_op, tvb,
1658                                         *offset, length, FALSE);
1659                 } else {
1660                     proto_tree_add_item(sub_tree, hf_smpp_reserved_op, tvb,
1661                                         *offset, length, FALSE);
1662                 }
1663
1664                 proto_item_append_text(sub_tree,": %s", tvb_bytes_to_str(tvb,*offset,length));
1665                 (*offset) += length;
1666                 break;
1667         }
1668     }
1669 }
1670
1671 void
1672 smpp_handle_dcs(proto_tree *tree, tvbuff_t *tvb, int *offset)
1673 {
1674     guint8       val;
1675     int off = *offset;
1676     proto_item *subtree = NULL;
1677
1678     val = tvb_get_guint8(tvb, off);
1679     subtree = proto_tree_add_uint(tree,
1680                                   hf_smpp_data_coding, tvb, off, 1, val);
1681     proto_item_add_subtree(subtree, ett_dcs);
1682     /* SMPP Data Coding Scheme */
1683     proto_tree_add_uint(subtree, hf_smpp_dcs, tvb, off, 1, val);
1684     /* GSM SMS Data Coding Scheme */
1685     proto_tree_add_text(subtree, tvb, off, 1,
1686                         "GSM SMS Data Coding");
1687     proto_tree_add_uint(subtree,
1688                         hf_smpp_dcs_sms_coding_group, tvb, off, 1, val);
1689     if (val>>6 == 2) { /* Reserved */
1690         ;
1691     } else if (val < 0xF0) {
1692         proto_tree_add_boolean(subtree,
1693                                hf_smpp_dcs_text_compression, tvb, off, 1, val);
1694         proto_tree_add_boolean(subtree,
1695                                hf_smpp_dcs_class_present, tvb, off, 1, val);
1696         proto_tree_add_uint(subtree,
1697                             hf_smpp_dcs_charset, tvb, off, 1, val);
1698         if (val & 0x10)
1699             proto_tree_add_uint(subtree,
1700                                 hf_smpp_dcs_class, tvb, off, 1, val);
1701     } else {
1702         if (val & 0x08)
1703             proto_tree_add_text(subtree, tvb, off, 1,
1704                                 "SMPP: Bit .... 1... should be 0 (reserved)");
1705         proto_tree_add_uint(subtree,
1706                             hf_smpp_dcs_charset, tvb, off, 1, val);
1707         proto_tree_add_uint(subtree,
1708                             hf_smpp_dcs_class, tvb, off, 1, val);
1709     }
1710     /* Cell Broadcast Service (CBS) Data Coding Scheme */
1711     proto_tree_add_text(subtree, tvb, off, 1,
1712                         "GSM CBS Data Coding");
1713     proto_tree_add_uint(subtree,
1714                         hf_smpp_dcs_cbs_coding_group, tvb, off, 1, val);
1715     if (val < 0x40) { /* Language specified */
1716         proto_tree_add_uint(subtree,
1717                             hf_smpp_dcs_cbs_language, tvb, off, 1, val);
1718     } else if (val>>6 == 1) { /* General Data Coding indication */
1719         proto_tree_add_boolean(subtree,
1720                                hf_smpp_dcs_text_compression, tvb, off, 1, val);
1721         proto_tree_add_boolean(subtree,
1722                                hf_smpp_dcs_class_present, tvb, off, 1, val);
1723         proto_tree_add_uint(subtree,
1724                             hf_smpp_dcs_charset, tvb, off, 1, val);
1725         if (val & 0x10)
1726             proto_tree_add_uint(subtree,
1727                                 hf_smpp_dcs_class, tvb, off, 1, val);
1728     } else if (val>>6 == 2) { /* Message with UDH structure */
1729         proto_tree_add_uint(subtree,
1730                             hf_smpp_dcs_charset, tvb, off, 1, val);
1731         proto_tree_add_uint(subtree,
1732                             hf_smpp_dcs_class, tvb, off, 1, val);
1733     } else if (val>>4 == 14) { /* WAP Forum */
1734         proto_tree_add_uint(subtree,
1735                             hf_smpp_dcs_wap_charset, tvb, off, 1, val);
1736         proto_tree_add_uint(subtree,
1737                             hf_smpp_dcs_wap_class, tvb, off, 1, val);
1738     } else if (val>>4 == 15) { /* Data coding / message handling */
1739         if (val & 0x08)
1740             proto_tree_add_text(subtree, tvb, off, 1,
1741                                 "SMPP: Bit .... 1... should be 0 (reserved)");
1742         proto_tree_add_uint(subtree,
1743                             hf_smpp_dcs_charset, tvb, off, 1, val);
1744         proto_tree_add_uint(subtree,
1745                             hf_smpp_dcs_cbs_class, tvb, off, 1, val);
1746     }
1747
1748     (*offset)++;
1749 }
1750
1751 /*!
1752  * The next set of routines handle the different operations, associated
1753  * with SMPP.
1754  */
1755 static void
1756 bind_receiver(proto_tree *tree, tvbuff_t *tvb)
1757 {
1758     int          offset = 0;
1759     guint8       field;
1760     guint8       major, minor;
1761     char         *strval;
1762
1763     smpp_handle_string(tree, tvb, hf_smpp_system_id, &offset);
1764     smpp_handle_string(tree, tvb, hf_smpp_password, &offset);
1765     smpp_handle_string(tree, tvb, hf_smpp_system_type, &offset);
1766     field = tvb_get_guint8(tvb, offset++);
1767     minor = field & 0x0F;
1768     major = (field & 0xF0) >> 4;
1769     strval=ep_strdup_printf("%u.%u", major, minor);
1770     proto_tree_add_string(tree, hf_smpp_interface_version, tvb,
1771                           offset - 1, 1, strval);
1772     smpp_handle_int1(tree, tvb, hf_smpp_addr_ton, &offset);
1773     smpp_handle_int1(tree, tvb, hf_smpp_addr_npi, &offset);
1774     smpp_handle_string(tree, tvb, hf_smpp_address_range, &offset);
1775 }
1776
1777 #define bind_transmitter(a, b) bind_receiver(a, b)
1778
1779 static void
1780 query_sm(proto_tree *tree, tvbuff_t *tvb)
1781 {
1782     int          offset = 0;
1783
1784     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
1785     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
1786     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
1787     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
1788 }
1789
1790 #define bind_transceiver(a, b) bind_receiver(a, b)
1791
1792 static void
1793 outbind(proto_tree *tree, tvbuff_t *tvb)
1794 {
1795     int          offset = 0;
1796
1797     smpp_handle_string(tree, tvb, hf_smpp_system_id, &offset);
1798     smpp_handle_string(tree, tvb, hf_smpp_password, &offset);
1799 }
1800
1801 static void
1802 submit_sm(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo,
1803                 proto_tree *top_tree)
1804 {
1805     tvbuff_t    *tvb_msg;
1806     int          offset = 0;
1807     guint8       flag, udhi;
1808     guint8       length;
1809     char *src_str = NULL;
1810     char *dst_str = NULL;
1811     address save_src, save_dst;
1812
1813     smpp_handle_string_z(tree, tvb, hf_smpp_service_type, &offset, "(Default)");
1814     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
1815     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
1816     src_str = smpp_handle_string_return(tree, tvb, hf_smpp_source_addr, &offset);
1817     smpp_handle_int1(tree, tvb, hf_smpp_dest_addr_ton, &offset);
1818     smpp_handle_int1(tree, tvb, hf_smpp_dest_addr_npi, &offset);
1819     dst_str = smpp_handle_string_return(tree, tvb, hf_smpp_destination_addr, &offset);
1820     flag = tvb_get_guint8(tvb, offset);
1821     udhi = flag & 0x40;
1822     proto_tree_add_item(tree, hf_smpp_esm_submit_msg_mode,
1823                         tvb, offset, 1, flag);
1824     proto_tree_add_item(tree, hf_smpp_esm_submit_msg_type,
1825                         tvb, offset, 1, flag);
1826     proto_tree_add_item(tree, hf_smpp_esm_submit_features,
1827                         tvb, offset, 1, flag);
1828     offset++;
1829     smpp_handle_int1(tree, tvb, hf_smpp_protocol_id, &offset);
1830     smpp_handle_int1(tree, tvb, hf_smpp_priority_flag, &offset);
1831     if (tvb_get_guint8(tvb,offset)) {
1832         smpp_handle_time(tree, tvb, hf_smpp_schedule_delivery_time,
1833                          hf_smpp_schedule_delivery_time_r, &offset);
1834     } else { /* Time = NULL means Immediate delivery */
1835         proto_tree_add_text(tree, tvb, offset++, 1,
1836                             "Scheduled delivery time: Immediate delivery");
1837     }
1838     if (tvb_get_guint8(tvb,offset)) {
1839         smpp_handle_time(tree, tvb, hf_smpp_validity_period,
1840                          hf_smpp_validity_period_r, &offset);
1841     } else { /* Time = NULL means SMSC default validity */
1842         proto_tree_add_text(tree, tvb, offset++, 1,
1843                             "Validity period: SMSC default validity period");
1844     }
1845     flag = tvb_get_guint8(tvb, offset);
1846     proto_tree_add_item(tree, hf_smpp_regdel_receipt, tvb, offset, 1, flag);
1847     proto_tree_add_item(tree, hf_smpp_regdel_acks, tvb, offset, 1, flag);
1848     proto_tree_add_item(tree, hf_smpp_regdel_notif, tvb, offset, 1, flag);
1849     offset++;
1850     smpp_handle_int1(tree, tvb, hf_smpp_replace_if_present_flag, &offset);
1851         smpp_handle_dcs(tree, tvb, &offset);
1852     smpp_handle_int1(tree, tvb, hf_smpp_sm_default_msg_id, &offset);
1853     length = tvb_get_guint8(tvb, offset);
1854     proto_tree_add_uint(tree, hf_smpp_sm_length, tvb, offset++, 1, length);
1855     if (length)
1856     {
1857         proto_tree_add_item(tree, hf_smpp_short_message,
1858                             tvb, offset, length, FALSE);
1859         if (udhi) /* UDHI indicator present */
1860         {
1861             DebugLog(("UDHI present - set addresses\n"));
1862             /* Save original addresses */
1863             SET_ADDRESS(&save_src, pinfo->src.type, pinfo->src.len, pinfo->src.data);
1864             SET_ADDRESS(&save_dst, pinfo->dst.type, pinfo->dst.len, pinfo->dst.data);
1865             /* Set SMPP source and destination address */
1866             SET_ADDRESS(&(pinfo->src), AT_STRINGZ, 1+(int)strlen(src_str), src_str);
1867             SET_ADDRESS(&(pinfo->dst), AT_STRINGZ, 1+(int)strlen(dst_str), dst_str);
1868             tvb_msg = tvb_new_subset (tvb, offset,
1869                     MIN(length, tvb_reported_length(tvb) - offset), length);
1870             call_dissector (gsm_sms_handle, tvb_msg, pinfo, top_tree);
1871             /* Restore original addresses */
1872             SET_ADDRESS(&(pinfo->src), save_src.type, save_src.len, save_src.data );
1873             SET_ADDRESS(&(pinfo->dst), save_dst.type, save_dst.len, save_dst.data);
1874         }
1875         offset += length;
1876     }
1877     /* Get rid of SMPP text string addresses */
1878     smpp_handle_tlv(tree, tvb, &offset);
1879 }
1880
1881 #define deliver_sm(a, b, c, d) submit_sm(a, b, c, d)
1882
1883 static void
1884 replace_sm(proto_tree *tree, tvbuff_t *tvb)
1885 {
1886     int          offset = 0;
1887     guint8       flag;
1888     guint8       length;
1889
1890     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
1891     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
1892     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
1893     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
1894         if (tvb_get_guint8(tvb,offset)) {
1895     smpp_handle_time(tree, tvb, hf_smpp_schedule_delivery_time,
1896                                 hf_smpp_schedule_delivery_time_r, &offset);
1897         } else { /* Time = NULL */
1898                 proto_tree_add_text(tree, tvb, offset++, 1,
1899                                 "Scheduled delivery time: Keep initial delivery time setting");
1900         }
1901         if (tvb_get_guint8(tvb,offset)) {
1902     smpp_handle_time(tree, tvb, hf_smpp_validity_period,
1903                                 hf_smpp_validity_period_r, &offset);
1904         } else { /* Time = NULL */
1905                 proto_tree_add_text(tree, tvb, offset++, 1,
1906                                 "Validity period: Keep initial validity period setting");
1907         }
1908     flag = tvb_get_guint8(tvb, offset);
1909     proto_tree_add_item(tree, hf_smpp_regdel_receipt, tvb, offset, 1, flag);
1910     proto_tree_add_item(tree, hf_smpp_regdel_acks, tvb, offset, 1, flag);
1911     proto_tree_add_item(tree, hf_smpp_regdel_notif, tvb, offset, 1, flag);
1912     offset++;
1913     smpp_handle_int1(tree, tvb, hf_smpp_sm_default_msg_id, &offset);
1914     length = tvb_get_guint8(tvb, offset);
1915     proto_tree_add_uint(tree, hf_smpp_sm_length, tvb, offset++, 1, length);
1916     if (length)
1917         proto_tree_add_item(tree, hf_smpp_short_message,
1918                             tvb, offset, length, FALSE);
1919     offset += length;
1920 }
1921
1922 static void
1923 cancel_sm(proto_tree *tree, tvbuff_t *tvb)
1924 {
1925     int          offset = 0;
1926
1927     smpp_handle_string_z(tree, tvb, hf_smpp_service_type, &offset, "(Default)");
1928     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
1929     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
1930     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
1931     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
1932     smpp_handle_int1(tree, tvb, hf_smpp_dest_addr_ton, &offset);
1933     smpp_handle_int1(tree, tvb, hf_smpp_dest_addr_npi, &offset);
1934     smpp_handle_string(tree, tvb, hf_smpp_destination_addr, &offset);
1935 }
1936
1937 static void
1938 submit_multi(proto_tree *tree, tvbuff_t *tvb)
1939 {
1940     int          offset = 0;
1941     guint8       flag;
1942     guint8       length;
1943
1944     smpp_handle_string_z(tree, tvb, hf_smpp_service_type, &offset, "(Default)");
1945     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
1946     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
1947     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
1948
1949     smpp_handle_dlist(tree, tvb, &offset);
1950
1951     flag = tvb_get_guint8(tvb, offset);
1952     proto_tree_add_item(tree, hf_smpp_esm_submit_msg_mode,
1953             tvb, offset, 1, flag);
1954     proto_tree_add_item(tree, hf_smpp_esm_submit_msg_type,
1955             tvb, offset, 1, flag);
1956     proto_tree_add_item(tree, hf_smpp_esm_submit_features,
1957             tvb, offset, 1, flag);
1958     offset++;
1959     smpp_handle_int1(tree, tvb, hf_smpp_protocol_id, &offset);
1960     smpp_handle_int1(tree, tvb, hf_smpp_priority_flag, &offset);
1961     if (tvb_get_guint8(tvb,offset)) {
1962         smpp_handle_time(tree, tvb, hf_smpp_schedule_delivery_time,
1963                 hf_smpp_schedule_delivery_time_r, &offset);
1964     } else { /* Time = NULL means Immediate delivery */
1965         proto_tree_add_text(tree, tvb, offset++, 1,
1966                 "Scheduled delivery time: Immediate delivery");
1967     }
1968     if (tvb_get_guint8(tvb,offset)) {
1969         smpp_handle_time(tree, tvb, hf_smpp_validity_period,
1970                 hf_smpp_validity_period_r, &offset);
1971     } else { /* Time = NULL means SMSC default validity */
1972         proto_tree_add_text(tree, tvb, offset++, 1,
1973                 "Validity period: SMSC default validity period");
1974     }
1975     flag = tvb_get_guint8(tvb, offset);
1976     proto_tree_add_item(tree, hf_smpp_regdel_receipt, tvb, offset, 1, flag);
1977     proto_tree_add_item(tree, hf_smpp_regdel_acks, tvb, offset, 1, flag);
1978     proto_tree_add_item(tree, hf_smpp_regdel_notif, tvb, offset, 1, flag);
1979     offset++;
1980     smpp_handle_int1(tree, tvb, hf_smpp_replace_if_present_flag, &offset);
1981     smpp_handle_dcs(tree, tvb, &offset);
1982     smpp_handle_int1(tree, tvb, hf_smpp_sm_default_msg_id, &offset);
1983     length = tvb_get_guint8(tvb, offset);
1984     proto_tree_add_uint(tree, hf_smpp_sm_length, tvb, offset++, 1, length);
1985     if (length)
1986         proto_tree_add_item(tree, hf_smpp_short_message,
1987                 tvb, offset, length, FALSE);
1988     offset += length;
1989     smpp_handle_tlv(tree, tvb, &offset);
1990 }
1991
1992 static void
1993 alert_notification(proto_tree *tree, tvbuff_t *tvb)
1994 {
1995     int          offset = 0;
1996
1997     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
1998     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
1999     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
2000     smpp_handle_int1(tree, tvb, hf_smpp_esme_addr_ton, &offset);
2001     smpp_handle_int1(tree, tvb, hf_smpp_esme_addr_npi, &offset);
2002     smpp_handle_string(tree, tvb, hf_smpp_esme_addr, &offset);
2003     smpp_handle_tlv(tree, tvb, &offset);
2004 }
2005
2006 static void
2007 data_sm(proto_tree *tree, tvbuff_t *tvb)
2008 {
2009     int          offset = 0;
2010     guint8       flag;
2011
2012     smpp_handle_string_z(tree, tvb, hf_smpp_service_type, &offset, "(Default)");
2013     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
2014     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
2015     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
2016     smpp_handle_int1(tree, tvb, hf_smpp_dest_addr_ton, &offset);
2017     smpp_handle_int1(tree, tvb, hf_smpp_dest_addr_npi, &offset);
2018     smpp_handle_string(tree, tvb, hf_smpp_destination_addr, &offset);
2019     flag = tvb_get_guint8(tvb, offset);
2020     proto_tree_add_item(tree, hf_smpp_esm_submit_msg_mode,
2021                         tvb, offset, 1, flag);
2022     proto_tree_add_item(tree, hf_smpp_esm_submit_msg_type,
2023                         tvb, offset, 1, flag);
2024     proto_tree_add_item(tree, hf_smpp_esm_submit_features,
2025                         tvb, offset, 1, flag);
2026     offset++;
2027     flag = tvb_get_guint8(tvb, offset);
2028     proto_tree_add_item(tree, hf_smpp_regdel_receipt, tvb, offset, 1, flag);
2029     proto_tree_add_item(tree, hf_smpp_regdel_acks, tvb, offset, 1, flag);
2030     proto_tree_add_item(tree, hf_smpp_regdel_notif, tvb, offset, 1, flag);
2031     offset++;
2032         smpp_handle_dcs(tree, tvb, &offset);
2033     smpp_handle_tlv(tree, tvb, &offset);
2034 }
2035
2036 /*
2037  * Request operations introduced in the SMPP 5.0
2038  */
2039 static void
2040 broadcast_sm(proto_tree *tree, tvbuff_t *tvb)
2041 {
2042     int          offset = 0;
2043
2044     smpp_handle_string_z(tree, tvb, hf_smpp_service_type, &offset, "(Default)");
2045     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
2046     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
2047     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
2048     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2049     smpp_handle_int1(tree, tvb, hf_smpp_priority_flag, &offset);
2050     if (tvb_get_guint8(tvb,offset)) {
2051         smpp_handle_time(tree, tvb, hf_smpp_schedule_delivery_time,
2052                 hf_smpp_schedule_delivery_time_r, &offset);
2053     } else { /* Time = NULL means Immediate delivery */
2054         proto_tree_add_text(tree, tvb, offset++, 1,
2055                 "Scheduled delivery time: Immediate delivery");
2056     }
2057     if (tvb_get_guint8(tvb,offset)) {
2058         smpp_handle_time(tree, tvb, hf_smpp_validity_period,
2059                 hf_smpp_validity_period_r, &offset);
2060     } else { /* Time = NULL means SMSC default validity */
2061         proto_tree_add_text(tree, tvb, offset++, 1,
2062                 "Validity period: SMSC default validity period");
2063     }
2064     smpp_handle_int1(tree, tvb, hf_smpp_replace_if_present_flag, &offset);
2065     smpp_handle_dcs(tree, tvb, &offset);
2066     smpp_handle_int1(tree, tvb, hf_smpp_sm_default_msg_id, &offset);
2067     smpp_handle_tlv(tree, tvb, &offset);
2068 }
2069
2070 static void
2071 query_broadcast_sm(proto_tree *tree, tvbuff_t *tvb)
2072 {
2073     int          offset = 0;
2074
2075     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2076     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
2077     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
2078     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
2079     smpp_handle_tlv(tree, tvb, &offset);
2080 }
2081
2082 static void
2083 cancel_broadcast_sm(proto_tree *tree, tvbuff_t *tvb)
2084 {
2085     int          offset = 0;
2086
2087     smpp_handle_string_z(tree, tvb, hf_smpp_service_type, &offset, "(Default)");
2088     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2089     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_ton, &offset);
2090     smpp_handle_int1(tree, tvb, hf_smpp_source_addr_npi, &offset);
2091     smpp_handle_string(tree, tvb, hf_smpp_source_addr, &offset);
2092     smpp_handle_tlv(tree, tvb, &offset);
2093 }
2094
2095 /*!
2096  * The next set of routines handle the different operation-responses,
2097  * associated with SMPP.
2098  */
2099 static void
2100 bind_receiver_resp(proto_tree *tree, tvbuff_t *tvb)
2101 {
2102     int          offset = 0;
2103
2104     smpp_handle_string(tree, tvb, hf_smpp_system_id, &offset);
2105     smpp_handle_tlv(tree, tvb, &offset);
2106 }
2107
2108 #define bind_transmitter_resp(a, b) bind_receiver_resp(a, b)
2109
2110 static void
2111 query_sm_resp(proto_tree *tree, tvbuff_t *tvb)
2112 {
2113     int          offset = 0;
2114
2115     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2116     smpp_handle_time(tree, tvb, hf_smpp_final_date,
2117                                 hf_smpp_final_date_r, &offset);
2118     smpp_handle_int1(tree, tvb, hf_smpp_message_state, &offset);
2119     smpp_handle_int1(tree, tvb, hf_smpp_error_code, &offset);
2120 }
2121
2122 #define bind_transceiver_resp(a, b) bind_receiver_resp(a, b)
2123
2124 static void
2125 submit_sm_resp(proto_tree *tree, tvbuff_t *tvb)
2126 {
2127     int          offset = 0;
2128
2129     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2130     smpp_handle_tlv(tree, tvb, &offset);
2131 }
2132
2133 #define deliver_sm_resp(a, b) submit_sm_resp(a, b)
2134
2135 static void
2136 submit_multi_resp(proto_tree *tree, tvbuff_t *tvb)
2137 {
2138     int          offset = 0;
2139
2140     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2141     smpp_handle_dlist_resp(tree, tvb, &offset);
2142     smpp_handle_tlv(tree, tvb, &offset);
2143 }
2144
2145 static void
2146 data_sm_resp(proto_tree *tree, tvbuff_t *tvb)
2147 {
2148     int          offset = 0;
2149
2150     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2151     smpp_handle_tlv(tree, tvb, &offset);
2152 }
2153
2154 #define broadcast_sm_resp(a, b) submit_sm_resp(a, b)
2155
2156 static void
2157 query_broadcast_sm_resp(proto_tree *tree, tvbuff_t *tvb)
2158 {
2159     int          offset = 0;
2160
2161     smpp_handle_string(tree, tvb, hf_smpp_message_id, &offset);
2162     smpp_handle_tlv(tree, tvb, &offset);
2163 }
2164
2165
2166 /*
2167  * A 'heuristic dissector' that attemtps to establish whether we have
2168  * a genuine SMPP PDU here.
2169  * Only works when:
2170  *      at least the fixed header is there
2171  *      it has a correct overall PDU length
2172  *      it is a 'well-known' operation
2173  *      has a 'well-known' status
2174  */
2175 static gboolean
2176 dissect_smpp_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
2177 {
2178     guint        command_id;            /* SMPP command         */
2179     guint        command_status;        /* Status code          */
2180     guint        command_length;        /* length of PDU        */
2181
2182     if (tvb_reported_length(tvb) < SMPP_MIN_LENGTH)     /* Mandatory header     */
2183         return FALSE;
2184     command_length = tvb_get_ntohl(tvb, 0);
2185     if (command_length > 64 * 1024 || command_length < SMPP_MIN_LENGTH)
2186         return FALSE;
2187     command_id = tvb_get_ntohl(tvb, 4);         /* Only known commands  */
2188     if (match_strval(command_id, vals_command_id) == NULL)
2189         return FALSE;
2190     command_status = tvb_get_ntohl(tvb, 8);     /* ..with known status  */
2191     if (match_strval(command_status, vals_command_status) == NULL)
2192         return FALSE;
2193     dissect_smpp(tvb, pinfo, tree);
2194     return TRUE;
2195 }
2196
2197 static guint
2198 get_smpp_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset)
2199 {
2200     return tvb_get_ntohl(tvb, offset);
2201 }
2202
2203 /*
2204  * This global SMPP variable is used to determine whether the PDU to dissect
2205  * is the first SMPP PDU in the packet (or reassembled buffer), requiring
2206  * different column update code than subsequent SMPP PDUs within this packet
2207  * (or reassembled buffer).
2208  *
2209  * FIXME - This approach is NOT dissection multi-thread safe!
2210  */
2211 static gboolean first = TRUE;
2212
2213 static void
2214 dissect_smpp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
2215 {
2216     first = TRUE;
2217     if (pinfo->ptype == PT_TCP) {       /* are we running on top of TCP */
2218         tcp_dissect_pdus(tvb, pinfo, tree,
2219                 reassemble_over_tcp,    /* Do we try to reassemble      */
2220                 16,                     /* Length of fixed header       */
2221                 get_smpp_pdu_len,       /* Function returning PDU len   */
2222                 dissect_smpp_pdu);      /* PDU dissector                */
2223     } else {                            /* no? probably X.25            */
2224         guint32 offset = 0;
2225         while (tvb_reported_length_remaining(tvb, offset) > 0) {
2226             guint16 pdu_len = tvb_get_ntohl(tvb, offset);
2227             gint pdu_real_len = tvb_length_remaining(tvb, offset);
2228             tvbuff_t *pdu_tvb;
2229
2230             if (pdu_len < 1)
2231                 THROW(ReportedBoundsError);
2232
2233             if (pdu_real_len <= 0)
2234                 return;
2235             if (pdu_real_len > pdu_len)
2236                 pdu_real_len = pdu_len;
2237             pdu_tvb = tvb_new_subset(tvb, offset, pdu_real_len, pdu_len);
2238             dissect_smpp_pdu(pdu_tvb, pinfo, tree);
2239             offset += pdu_len;
2240             first = FALSE;
2241         }
2242     }
2243 }
2244
2245
2246 /* Dissect a single SMPP PDU contained within "tvb". */
2247 static void
2248 dissect_smpp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
2249 {
2250     int          offset = 0;            /* Offset within tvbuff */
2251     guint        command_length;        /* length of PDU        */
2252     guint        command_id;            /* SMPP command         */
2253     guint        command_status;        /* Status code          */
2254     guint        sequence_number;       /* ...of command        */
2255     smpp_tap_rec_t* tap_rec;            /* Tap record           */
2256     const gchar *command_str;
2257     const gchar *command_status_str = NULL;
2258     /* Set up structures needed to add the protocol subtree and manage it */
2259     proto_item  *ti = NULL;
2260     proto_tree  *smpp_tree = NULL;
2261
2262     /*
2263      * Safety: don't even try to dissect the PDU
2264      * when the mandatory header isn't present.
2265      */
2266     if (tvb_reported_length(tvb) < SMPP_MIN_LENGTH)
2267         return;
2268     command_length = tvb_get_ntohl(tvb, offset);
2269     offset += 4;
2270     command_id = tvb_get_ntohl(tvb, offset);
2271     command_str = val_to_str(command_id, vals_command_id,
2272             "(Unknown SMPP Operation 0x%08X)");
2273     offset += 4;
2274     command_status = tvb_get_ntohl(tvb, offset);
2275     if (command_id & 0x80000000) {
2276         command_status_str = val_to_str(command_status, vals_command_status,
2277                 "(Reserved Error 0x%08X)");
2278     }
2279     offset += 4;
2280     sequence_number = tvb_get_ntohl(tvb, offset);
2281     offset += 4;
2282
2283     /*
2284      * Update the protocol column.
2285      */
2286     if (first == TRUE) {
2287         col_set_str(pinfo->cinfo, COL_PROTOCOL, "SMPP");
2288     }
2289
2290     /*
2291      * Create display subtree for the protocol
2292      */
2293     if (tree) {
2294         ti = proto_tree_add_item (tree, proto_smpp, tvb, 0, tvb->length, FALSE);
2295         smpp_tree = proto_item_add_subtree (ti, ett_smpp);
2296     }
2297
2298     /*
2299      * Cycle over the encapsulated PDUs
2300      */
2301     {
2302         tvbuff_t *pdu_tvb;
2303
2304         /*
2305          * Make entries in the Info column on the summary display
2306          */
2307         if (check_col(pinfo->cinfo, COL_INFO)) {
2308             if (first == TRUE) {
2309                 /*
2310                  * First PDU - We already computed the fixed header
2311                  */
2312                 col_clear(pinfo->cinfo, COL_INFO);
2313                 col_add_fstr(pinfo->cinfo, COL_INFO, "SMPP %s", command_str);
2314                 first = FALSE;
2315             } else {
2316                 /*
2317                  * Subsequent PDUs
2318                  */
2319                 col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", command_str);
2320             }
2321             /*
2322              * Display command status of responses in Info column
2323              */
2324             if (command_id & 0x80000000) {
2325                 col_append_fstr(pinfo->cinfo, COL_INFO, ": \"%s\"",
2326                         command_status_str);
2327             }
2328         }
2329
2330         /*
2331          * Create a tvb for the current PDU.
2332          * Physical length: at most command_length
2333          * Reported length: command_length
2334          */
2335         if (tvb_length_remaining(tvb, offset - 16 + command_length) > 0) {
2336             pdu_tvb = tvb_new_subset(tvb, offset - 16,
2337                     command_length,     /* Physical length */
2338                     command_length);    /* Length reported by the protocol */
2339         } else {
2340             pdu_tvb = tvb_new_subset(tvb, offset - 16,
2341                     tvb_length_remaining(tvb, offset - 16),/* Physical length */
2342                     command_length);    /* Length reported by the protocol */
2343         }
2344
2345         /*
2346          * Dissect the PDU
2347          *
2348          * If "tree" is NULL, Wireshark is only interested in creation
2349          * of conversations, reassembly and subdissection but not in
2350          * the detailed protocol tree.
2351          * In the interest of speed, skip the generation of protocol tree
2352          * items when "tree" is NULL.
2353          *
2354          * The only PDU which requires subdissection currently is the
2355          * sm_submit PDU (command ID = 0x00000004).
2356          */
2357         if (tree || (command_id == 4))
2358         {
2359             /*
2360              * Create display subtree for the PDU
2361              */
2362             if (tree) {
2363                 proto_tree_add_uint(smpp_tree, hf_smpp_command_length,
2364                         pdu_tvb, 0, 4, command_length);
2365                 proto_tree_add_uint(smpp_tree, hf_smpp_command_id,
2366                         pdu_tvb, 4, 4, command_id);
2367                 proto_item_append_text(ti, ", Command: %s", command_str);
2368
2369                 /*
2370                  * Status is only meaningful with responses
2371                  */
2372                 if (command_id & 0x80000000) {
2373                     proto_tree_add_uint(smpp_tree, hf_smpp_command_status,
2374                             pdu_tvb, 8, 4, command_status);
2375                     proto_item_append_text (ti, ", Status: \"%s\"",
2376                             command_status_str);
2377                 }
2378                 proto_tree_add_uint(smpp_tree, hf_smpp_sequence_number,
2379                         pdu_tvb, 12, 4, sequence_number);
2380                 proto_item_append_text(ti, ", Seq: %u, Len: %u",
2381                         sequence_number, command_length);
2382             }
2383
2384             /*
2385              * End of fixed header.
2386              * Don't dissect variable part if it is shortened.
2387              *
2388              * FIXME - We then do not report a Short Frame or Malformed Packet
2389              */
2390             if (command_length <= tvb_reported_length(pdu_tvb))
2391             {
2392                 tvbuff_t *tmp_tvb = tvb_new_subset(pdu_tvb, 16,
2393                         -1, command_length - 16);
2394                 if (command_id & 0x80000000)
2395                 {
2396                     switch (command_id & 0x7FFFFFFF) {
2397                         /*
2398                          * All of these only have a fixed header
2399                          */
2400                         case   0:       /* Generic nack         */
2401                         case   6:       /* Unbind resp          */
2402                         case   7:       /* Replace SM resp      */
2403                         case   8:       /* Cancel SM resp       */
2404                         case  21:       /* Enquire link resp    */
2405                         case 275:       /* Cancel Broadcast SM resp */
2406                             break;
2407                         /* FIXME: The body of the response PDUs are only
2408                          * only dissected if the request was successful.
2409                          * However, in SMPP 5.0 some responses might
2410                          * contain body to provide additional information
2411                          * about the error. This needs to be handled.
2412                          */
2413                         case   1:
2414                             if (!command_status)
2415                                 bind_receiver_resp(smpp_tree, tmp_tvb);
2416                             break;
2417                         case   2:
2418                             if (!command_status)
2419                                 bind_transmitter_resp(smpp_tree, tmp_tvb);
2420                             break;
2421                         case   3:
2422                             if (!command_status)
2423                                 query_sm_resp(smpp_tree, tmp_tvb);
2424                             break;
2425                         case   4:
2426                             if (!command_status)
2427                                 submit_sm_resp(smpp_tree, tmp_tvb);
2428                             break;
2429                         case   5:
2430                             if (!command_status)
2431                                 deliver_sm_resp(smpp_tree, tmp_tvb);
2432                             break;
2433                         case   9:
2434                             if (!command_status)
2435                                 bind_transceiver_resp(smpp_tree, tmp_tvb);
2436                             break;
2437                         case  33:
2438                             if (!command_status)
2439                                 submit_multi_resp(smpp_tree, tmp_tvb);
2440                             break;
2441                         case 259:
2442                             if (!command_status)
2443                                 data_sm_resp(smpp_tree, tmp_tvb);
2444                             break;
2445                         case 273:
2446                             if (!command_status)
2447                                 broadcast_sm_resp(smpp_tree, tmp_tvb);
2448                             break;
2449                         case 274:
2450                             if (!command_status)
2451                                 query_broadcast_sm_resp(smpp_tree, tmp_tvb);
2452                             break;
2453                         default:
2454                             break;
2455                     } /* switch (command_id & 0x7FFFFFFF) */
2456                 }
2457                 else
2458                 {
2459                     switch (command_id) {
2460                         case   1:
2461                             bind_receiver(smpp_tree, tmp_tvb);
2462                             break;
2463                         case   2:
2464                             bind_transmitter(smpp_tree, tmp_tvb);
2465                             break;
2466                         case   3:
2467                             query_sm(smpp_tree, tmp_tvb);
2468                             break;
2469                         case   4:
2470                             submit_sm(smpp_tree, tmp_tvb, pinfo, tree);
2471                             break;
2472                         case   5:
2473                             deliver_sm(smpp_tree, tmp_tvb, pinfo, tree);
2474                             break;
2475                         case   6:       /* Unbind               */
2476                         case  21:       /* Enquire link         */
2477                             break;
2478                         case   7:
2479                             replace_sm(smpp_tree, tmp_tvb);
2480                             break;
2481                         case   8:
2482                             cancel_sm(smpp_tree, tmp_tvb);
2483                             break;
2484                         case   9:
2485                             bind_transceiver(smpp_tree, tmp_tvb);
2486                             break;
2487                         case  11:
2488                             outbind(smpp_tree, tmp_tvb);
2489                             break;
2490                         case  33:
2491                             submit_multi(smpp_tree, tmp_tvb);
2492                             break;
2493                         case  258:
2494                             alert_notification(smpp_tree, tmp_tvb);
2495                             break;
2496                         case  259:
2497                             data_sm(smpp_tree, tmp_tvb);
2498                             break;
2499                         case 273:
2500                             broadcast_sm(smpp_tree, tmp_tvb);
2501                             break;
2502                         case 274:
2503                             query_broadcast_sm(smpp_tree, tmp_tvb);
2504                             break;
2505                         case 275:
2506                             cancel_broadcast_sm(smpp_tree, tmp_tvb);
2507                             break;
2508                         default:
2509                             break;
2510                     } /* switch (command_id) */
2511                 } /* if (command_id & 0x80000000) */
2512
2513             } /* if (command_length <= tvb_reported_length(pdu_tvb)) */
2514             offset += command_length;
2515         } /* if (tree || (command_id == 4)) */
2516
2517         /* Queue packet for Tap */
2518         tap_rec = ep_alloc0(sizeof(smpp_tap_rec_t));
2519         tap_rec->command_id = command_id;
2520         tap_rec->command_status = command_status;
2521         tap_queue_packet(smpp_tap, pinfo, tap_rec);
2522
2523         first = FALSE;
2524     }
2525
2526     return;
2527 }
2528
2529
2530 /* Register the protocol with Wireshark */
2531 void
2532 proto_register_smpp(void)
2533 {
2534     module_t *smpp_module; /* Preferences for SMPP */
2535
2536     /* Setup list of header fields      */
2537     static hf_register_info hf[] = {
2538         {   &hf_smpp_command_length,
2539             {   "Length", "smpp.command_length",
2540                 FT_UINT32, BASE_DEC, NULL, 0x00,
2541                 "Total length of the SMPP PDU.",
2542                 HFILL
2543             }
2544         },
2545         {   &hf_smpp_command_id,
2546             {   "Operation", "smpp.command_id",
2547                 FT_UINT32, BASE_HEX, VALS(vals_command_id), 0x00,
2548                 "Defines the SMPP PDU.",
2549                 HFILL
2550             }
2551         },
2552         {   &hf_smpp_command_status,
2553             {   "Result", "smpp.command_status",
2554                 FT_UINT32, BASE_HEX, VALS(vals_command_status), 0x00,
2555                 "Indicates success or failure of the SMPP request.",
2556                 HFILL
2557             }
2558         },
2559         {   &hf_smpp_sequence_number,
2560             {   "Sequence #", "smpp.sequence_number",
2561                 FT_UINT32, BASE_DEC, NULL, 0x00,
2562                 "A number to correlate requests with responses.",
2563                 HFILL
2564             }
2565         },
2566         {   &hf_smpp_system_id,
2567             {   "System ID", "smpp.system_id",
2568                 FT_STRING, BASE_NONE, NULL, 0x00,
2569                 "Identifies a system.",
2570                 HFILL
2571             }
2572         },
2573         {   &hf_smpp_password,
2574             {   "Password", "smpp.password",
2575                 FT_STRING, BASE_NONE, NULL, 0x00,
2576                 "Password used for authentication.",
2577                 HFILL
2578             }
2579         },
2580         {   &hf_smpp_system_type,
2581             {   "System type", "smpp.system_type",
2582                 FT_STRING, BASE_NONE, NULL, 0x00,
2583                 "Categorizes the system.",
2584                 HFILL
2585             }
2586         },
2587         {   &hf_smpp_interface_version,
2588             {   "Version (if)", "smpp.interface_version",
2589                 FT_STRING, BASE_NONE, NULL, 0x00,
2590                 "Version of SMPP interface supported.",
2591                 HFILL
2592             }
2593         },
2594         {   &hf_smpp_service_type,
2595             {   "Service type", "smpp.service_type",
2596                 FT_STRING, BASE_NONE, NULL, 0x00,
2597                 "SMS application service associated with the message.",
2598                 HFILL
2599             }
2600         },
2601         {   &hf_smpp_addr_ton,
2602             {   "Type of number", "smpp.addr_ton",
2603                 FT_UINT8, BASE_HEX, VALS(vals_addr_ton), 0x00,
2604                 "Indicates the type of number, given in the address.",
2605                 HFILL
2606             }
2607         },
2608         {   &hf_smpp_source_addr_ton,
2609             {   "Type of number (originator)", "smpp.source_addr_ton",
2610                 FT_UINT8, BASE_HEX, VALS(vals_addr_ton), 0x00,
2611                 "Indicates originator type of number, given in the address.",
2612                 HFILL
2613             }
2614         },
2615         {   &hf_smpp_dest_addr_ton,
2616             {   "Type of number (recipient)", "smpp.dest_addr_ton",
2617                 FT_UINT8, BASE_HEX, VALS(vals_addr_ton), 0x00,
2618                 "Indicates recipient type of number, given in the address.",
2619                 HFILL
2620             }
2621         },
2622         {   &hf_smpp_addr_npi,
2623             {   "Numbering plan indicator", "smpp.addr_npi",
2624                 FT_UINT8, BASE_HEX, VALS(vals_addr_npi), 0x00,
2625                 "Gives the numbering plan this address belongs to.",
2626                 HFILL
2627             }
2628         },
2629         {   &hf_smpp_source_addr_npi,
2630             {   "Numbering plan indicator (originator)", "smpp.source_addr_npi",
2631                 FT_UINT8, BASE_HEX, VALS(vals_addr_npi), 0x00,
2632                 "Gives originator numbering plan this address belongs to.",
2633                 HFILL
2634             }
2635         },
2636         {   &hf_smpp_dest_addr_npi,
2637             {   "Numbering plan indicator (recipient)", "smpp.dest_addr_npi",
2638                 FT_UINT8, BASE_HEX, VALS(vals_addr_npi), 0x00,
2639                 "Gives recipient numbering plan this address belongs to.",
2640                 HFILL
2641             }
2642         },
2643         {   &hf_smpp_address_range,
2644             {   "Address", "smpp.address_range",
2645                 FT_STRING, BASE_NONE, NULL, 0x00,
2646                 "Given address or address range.",
2647                 HFILL
2648             }
2649         },
2650         {   &hf_smpp_source_addr,
2651             {   "Originator address", "smpp.source_addr",
2652                 FT_STRING, BASE_NONE, NULL, 0x00,
2653                 "Address of SME originating this message.",
2654                 HFILL
2655             }
2656         },
2657         {   &hf_smpp_destination_addr,
2658             {   "Recipient address", "smpp.destination_addr",
2659                 FT_STRING, BASE_NONE, NULL, 0x00,
2660                 "Address of SME receiving this message.",
2661                 HFILL
2662             }
2663         },
2664         {   &hf_smpp_esm_submit_msg_mode,
2665             {   "Messaging mode", "smpp.esm.submit.msg_mode",
2666                 FT_UINT8, BASE_HEX, VALS(vals_esm_submit_msg_mode), 0x03,
2667                 "Mode attribute for this message.",
2668                 HFILL
2669             }
2670         },
2671         {   &hf_smpp_esm_submit_msg_type,
2672             {   "Message type", "smpp.esm.submit.msg_type",
2673                 FT_UINT8, BASE_HEX, VALS(vals_esm_submit_msg_type), 0x3C,
2674                 "Type attribute for this message.",
2675                 HFILL
2676             }
2677         },
2678         {   &hf_smpp_esm_submit_features,
2679             {   "GSM features", "smpp.esm.submit.features",
2680                 FT_UINT8, BASE_HEX, VALS(vals_esm_submit_features), 0xC0,
2681                 "GSM network specific features.",
2682                 HFILL
2683             }
2684         },
2685         /*! \todo Get proper values from GSM-spec.      */
2686         {   &hf_smpp_protocol_id,
2687             {   "Protocol id.", "smpp.protocol_id",
2688                 FT_UINT8, BASE_HEX, NULL, 0x00,
2689                 "Protocol identifier according GSM 03.40.",
2690                 HFILL
2691             }
2692         },
2693         {   &hf_smpp_priority_flag,
2694             {   "Priority level", "smpp.priority_flag",
2695                 FT_UINT8, BASE_HEX, VALS(vals_priority_flag), 0x00,
2696                 "The priority level of the short message.",
2697                 HFILL
2698             }
2699         },
2700         {   &hf_smpp_schedule_delivery_time,
2701             {   "Scheduled delivery time", "smpp.schedule_delivery_time",
2702                 FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00,
2703                 "Scheduled time for delivery of short message.",
2704                 HFILL
2705             }
2706         },
2707         {   &hf_smpp_schedule_delivery_time_r,
2708             {   "Scheduled delivery time", "smpp.schedule_delivery_time_r",
2709                 FT_RELATIVE_TIME, BASE_NONE, NULL, 0x00,
2710                 "Scheduled time for delivery of short message.",
2711                 HFILL
2712             }
2713         },
2714         {   &hf_smpp_validity_period,
2715             {   "Validity period", "smpp.validity_period",
2716                 FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00,
2717                 "Validity period of this message.",
2718                 HFILL
2719             }
2720         },
2721         {   &hf_smpp_validity_period_r,
2722             {   "Validity period", "smpp.validity_period_r",
2723                 FT_RELATIVE_TIME, BASE_NONE, NULL, 0x00,
2724                 "Validity period of this message.",
2725                 HFILL
2726             }
2727         },
2728         {   &hf_smpp_regdel_receipt,
2729             {   "Delivery receipt", "smpp.regdel.receipt",
2730                 FT_UINT8, BASE_HEX, VALS(vals_regdel_receipt), 0x03,
2731                 "SMSC delivery receipt request.",
2732                 HFILL
2733             }
2734         },
2735         {   &hf_smpp_regdel_acks,
2736             {   "Message type", "smpp.regdel.acks",
2737                 FT_UINT8, BASE_HEX, VALS(vals_regdel_acks), 0x0C,
2738                 "SME acknowledgement request.",
2739                 HFILL
2740             }
2741         },
2742         {   &hf_smpp_regdel_notif,
2743             {   "Intermediate notif", "smpp.regdel.notif",
2744                 FT_UINT8, BASE_HEX, VALS(vals_regdel_notif), 0x10,
2745                 "Intermediate notification request.",
2746                 HFILL
2747             }
2748         },
2749         {   &hf_smpp_replace_if_present_flag,
2750             {   "Replace", "smpp.replace_if_present_flag",
2751                 FT_UINT8, BASE_HEX, VALS(vals_replace_if_present_flag), 0x01,
2752                 "Replace the short message with this one or not.",
2753                 HFILL
2754             }
2755         },
2756         {   &hf_smpp_data_coding,
2757             {   "Data coding", "smpp.data_coding",
2758                 FT_UINT8, BASE_HEX, NULL, 0x00,
2759                 "Defines the encoding scheme of the message.",
2760                 HFILL
2761             }
2762         },
2763         {   &hf_smpp_sm_default_msg_id,
2764             {   "Predefined message", "smpp.sm_default_msg_id",
2765                 FT_UINT8, BASE_DEC, NULL, 0x00,
2766                 "Index of a predefined ('canned') short message.",
2767                 HFILL
2768             }
2769         },
2770         {   &hf_smpp_sm_length,
2771             {   "Message length", "smpp.sm_length",
2772                 FT_UINT8, BASE_DEC, NULL, 0x00,
2773                 "Length of the message content.",
2774                 HFILL
2775             }
2776         },
2777         {   &hf_smpp_short_message,
2778             {   "Message", "smpp.message",
2779                 FT_NONE, BASE_NONE, NULL, 0x00,
2780                 "The actual message or data.",
2781                 HFILL
2782             }
2783         },
2784         {   &hf_smpp_message_id,
2785             {   "Message id.", "smpp.message_id",
2786                 FT_STRING, BASE_NONE, NULL, 0x00,
2787                 "Identifier of the submitted short message.",
2788                 HFILL
2789             }
2790         },
2791         {   &hf_smpp_dlist,
2792             {   "Destination list", "smpp.dlist",
2793                 FT_NONE, BASE_NONE, NULL, 0x00,
2794                 "The list of destinations for a short message.",
2795                 HFILL
2796             }
2797         },
2798         {   &hf_smpp_dlist_resp,
2799             {   "Unsuccessful delivery list", "smpp.dlist_resp",
2800                 FT_NONE, BASE_NONE, NULL, 0x00,
2801                 "The list of unsuccessful deliveries to destinations.",
2802                 HFILL
2803             }
2804         },
2805         {   &hf_smpp_dl_name,
2806             {   "Distr. list name", "smpp.dl_name",
2807                 FT_STRING, BASE_NONE, NULL, 0x00,
2808                 "The name of the distribution list.",
2809                 HFILL
2810             }
2811         },
2812         {   &hf_smpp_final_date,
2813             {   "Final date", "smpp.final_date",
2814                 FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00,
2815                 "Date-time when the queried message reached a final state.",
2816                 HFILL
2817             }
2818         },
2819         {   &hf_smpp_final_date_r,
2820             {   "Final date", "smpp.final_date_r",
2821                 FT_RELATIVE_TIME, BASE_NONE, NULL, 0x00,
2822                 "Date-time when the queried message reached a final state.",
2823                 HFILL
2824             }
2825         },
2826         {   &hf_smpp_message_state,
2827             {   "Message state", "smpp.message_state",
2828                 FT_UINT8, BASE_DEC, VALS(vals_message_state), 0x00,
2829                 "Specifies the status of the queried short message.",
2830                 HFILL
2831             }
2832         },
2833         {   &hf_smpp_error_code,
2834             {   "Error code", "smpp.error_code",
2835                 FT_UINT8, BASE_DEC, NULL, 0x00,
2836                 "Network specific error code defining reason for failure.",
2837                 HFILL
2838             }
2839         },
2840         {   &hf_smpp_error_status_code,
2841             {   "Status", "smpp.error_status_code",
2842                 FT_UINT32, BASE_HEX, VALS(vals_command_status), 0x00,
2843                 "Indicates success/failure of request for this address.",
2844                 HFILL
2845             }
2846         },
2847         {   &hf_smpp_esme_addr_ton,
2848             {   "Type of number (ESME)", "smpp.esme_addr_ton",
2849                 FT_UINT8, BASE_HEX, VALS(vals_addr_ton), 0x00,
2850                 "Indicates recipient type of number, given in the address.",
2851                 HFILL
2852             }
2853         },
2854         {   &hf_smpp_esme_addr_npi,
2855             {   "Numbering plan indicator (ESME)", "smpp.esme_addr_npi",
2856                 FT_UINT8, BASE_HEX, VALS(vals_addr_npi), 0x00,
2857                 "Gives the numbering plan this address belongs to.",
2858                 HFILL
2859             }
2860         },
2861         {   &hf_smpp_esme_addr,
2862             {   "ESME address", "smpp.esme_addr",
2863                 FT_STRING, BASE_NONE, NULL, 0x00,
2864                 "Address of ESME originating this message.",
2865                 HFILL
2866             }
2867         },
2868         {   &hf_smpp_dest_addr_subunit,
2869             {   "Subunit destination", "smpp.dest_addr_subunit",
2870                 FT_UINT8, BASE_HEX, VALS(vals_addr_subunit), 0x00,
2871                 "Subunit address within mobile to route message to.",
2872                 HFILL
2873             }
2874         },
2875         {   &hf_smpp_source_addr_subunit,
2876             {   "Subunit origin", "smpp.source_addr_subunit",
2877                 FT_UINT8, BASE_HEX, VALS(vals_addr_subunit), 0x00,
2878                 "Subunit address within mobile that generated the message.",
2879                 HFILL
2880             }
2881         },
2882         {   &hf_smpp_dest_network_type,
2883             {   "Destination network", "smpp.dest_network_type",
2884                 FT_UINT8, BASE_HEX, VALS(vals_network_type), 0x00,
2885                 "Network associated with the destination address.",
2886                 HFILL
2887             }
2888         },
2889         {   &hf_smpp_source_network_type,
2890             {   "Originator network", "smpp.source_network_type",
2891                 FT_UINT8, BASE_HEX, VALS(vals_network_type), 0x00,
2892                 "Network associated with the originator address.",
2893                 HFILL
2894             }
2895         },
2896         {   &hf_smpp_dest_bearer_type,
2897             {   "Destination bearer", "smpp.dest_bearer_type",
2898                 FT_UINT8, BASE_HEX, VALS(vals_bearer_type), 0x00,
2899                 "Desired bearer for delivery of message.",
2900                 HFILL
2901             }
2902         },
2903         {   &hf_smpp_source_bearer_type,
2904             {   "Originator bearer", "smpp.source_bearer_type",
2905                 FT_UINT8, BASE_HEX, VALS(vals_bearer_type), 0x00,
2906                 "Bearer over which the message originated.",
2907                 HFILL
2908             }
2909         },
2910         {   &hf_smpp_dest_telematics_id,
2911             {   "Telematic interworking (dest)", "smpp.dest_telematics_id",
2912                 FT_UINT16, BASE_HEX, NULL, 0x00,
2913                 "Telematic interworking to be used for message delivery.",
2914                 HFILL
2915             }
2916         },
2917         {   &hf_smpp_source_telematics_id,
2918             {   "Telematic interworking (orig)", "smpp.source_telematics_id",
2919                 FT_UINT16, BASE_HEX, NULL, 0x00,
2920                 "Telematic interworking used for message submission.",
2921                 HFILL
2922             }
2923         },
2924         {   &hf_smpp_qos_time_to_live,
2925             {   "Validity period", "smpp.qos_time_to_live",
2926                 FT_UINT32, BASE_DEC, NULL, 0x00,
2927                 "Number of seconds to retain message before expiry.",
2928                 HFILL
2929             }
2930         },
2931         {   &hf_smpp_payload_type,
2932             {   "Payload", "smpp.payload_type",
2933                 FT_UINT8, BASE_DEC, VALS(vals_payload_type), 0x00,
2934                 "PDU type contained in the message payload.",
2935                 HFILL
2936             }
2937         },
2938         {   &hf_smpp_additional_status_info_text,
2939             {   "Information", "smpp.additional_status_info_text",
2940                 FT_STRING, BASE_NONE, NULL, 0x00,
2941                 "Description of the meaning of a response PDU.",
2942                 HFILL
2943             }
2944         },
2945         {   &hf_smpp_receipted_message_id,
2946             {   "SMSC identifier", "smpp.receipted_message_id",
2947                 FT_STRING, BASE_NONE, NULL, 0x00,
2948                 "SMSC handle of the message being received.",
2949                 HFILL
2950             }
2951         },
2952         {   &hf_smpp_privacy_indicator,
2953             {   "Privacy indicator", "smpp.privacy_indicator",
2954                 FT_UINT8, BASE_DEC, VALS(vals_privacy_indicator), 0x00,
2955                 "Indicates the privacy level of the message.",
2956                 HFILL
2957             }
2958         },
2959     {   &hf_smpp_source_subaddress,
2960             {   "Source Subaddress", "smpp.source_subaddress",
2961                 FT_BYTES, BASE_NONE, NULL, 0x00,
2962                 NULL,
2963                 HFILL
2964             }
2965         },
2966     {   &hf_smpp_dest_subaddress,
2967             {   "Destination Subaddress", "smpp.dest_subaddress",
2968                 FT_BYTES, BASE_NONE, NULL, 0x00,
2969                 NULL,
2970                 HFILL
2971             }
2972         },
2973     {   &hf_smpp_user_message_reference,
2974             {   "Message reference", "smpp.user_message_reference",
2975                 FT_UINT16, BASE_HEX, NULL, 0x00,
2976                 "Reference to the message, assigned by the user.",
2977                 HFILL
2978             }
2979         },
2980         {   &hf_smpp_user_response_code,
2981             {   "Application response code", "smpp.user_response_code",
2982                 FT_UINT8, BASE_HEX, NULL, 0x00,
2983                 "A response code set by the user.",
2984                 HFILL
2985             }
2986         },
2987         {   &hf_smpp_language_indicator,
2988             {   "Language", "smpp.language_indicator",
2989                 FT_UINT8, BASE_DEC, VALS(vals_language_indicator), 0x00,
2990                 "Indicates the language of the short message.",
2991                 HFILL
2992             }
2993         },
2994         {   &hf_smpp_source_port,
2995             {   "Source port", "smpp.source_port",
2996                 FT_UINT16, BASE_HEX, NULL, 0x00,
2997                 "Application port associated with the source of the message.",
2998                 HFILL
2999             }
3000         },
3001         {   &hf_smpp_destination_port,
3002             {   "Destination port", "smpp.destination_port",
3003                 FT_UINT16, BASE_HEX, NULL, 0x00,
3004                 "Application port associated with the destination of the message.",
3005                 HFILL
3006             }
3007         },
3008         {   &hf_smpp_sar_msg_ref_num,
3009             {   "SAR reference number", "smpp.sar_msg_ref_num",
3010                 FT_UINT16, BASE_DEC, NULL, 0x00,
3011                 "Reference number for a concatenated short message.",
3012                 HFILL
3013             }
3014         },
3015         {   &hf_smpp_sar_total_segments,
3016             {   "SAR size", "smpp.sar_total_segments",
3017                 FT_UINT16, BASE_DEC, NULL, 0x00,
3018                 "Number of segments of a concatenated short message.",
3019                 HFILL
3020             }
3021         },
3022         {   &hf_smpp_sar_segment_seqnum,
3023             {   "SAR sequence number", "smpp.sar_segment_seqnum",
3024                 FT_UINT8, BASE_DEC, NULL, 0x00,
3025                 "Segment number within a concatenated short message.",
3026                 HFILL
3027             }
3028         },
3029         {   &hf_smpp_display_time,
3030             {   "Display time", "smpp.display_time",
3031                 FT_UINT8, BASE_DEC, VALS(vals_display_time), 0x00,
3032                 "Associates a display time with the message on the handset.",
3033                 HFILL
3034             }
3035         },
3036         {   &hf_smpp_sms_signal,
3037             {   "SMS signal", "smpp.sms_signal",
3038                 FT_UINT16, BASE_HEX, NULL, 0x00,
3039                 "Alert the user according to the information contained within this information element.",
3040                 HFILL
3041             }
3042         },
3043         {   &hf_smpp_ms_validity,
3044             {   "Validity info", "smpp.ms_validity",
3045                 FT_UINT8, BASE_DEC, VALS(vals_ms_validity), 0x00,
3046                 "Associates validity info with the message on the handset.",
3047                 HFILL
3048             }
3049         },
3050         {   &hf_smpp_dpf_result,
3051             {   "Delivery pending set?", "smpp.dpf_result",
3052                 FT_UINT8, BASE_DEC, VALS(vals_dpf_result), 0x00,
3053                 "Indicates whether Delivery Pending Flag was set.",
3054                 HFILL
3055             }
3056         },
3057         {   &hf_smpp_set_dpf,
3058             {   "Request DPF set", "smpp.set_dpf",
3059                 FT_UINT8, BASE_DEC, VALS(vals_set_dpf), 0x00,
3060                 "Request to set the DPF for certain failure scenario's.",
3061                 HFILL
3062             }
3063         },
3064         {   &hf_smpp_ms_availability_status,
3065             {   "Availability status", "smpp.ms_availability_status",
3066                 FT_UINT8, BASE_DEC, VALS(vals_ms_availability_status), 0x00,
3067                 "Indicates the availability state of the handset.",
3068                 HFILL
3069             }
3070         },
3071         {   &hf_smpp_delivery_failure_reason,
3072             {   "Delivery failure reason", "smpp.delivery_failure_reason",
3073                 FT_UINT8, BASE_DEC, VALS(vals_delivery_failure_reason), 0x00,
3074                 "Indicates the reason for a failed delivery attempt.",
3075                 HFILL
3076             }
3077         },
3078         {   &hf_smpp_more_messages_to_send,
3079             {   "More messages?", "smpp.more_messages_to_send",
3080                 FT_UINT8, BASE_DEC, VALS(vals_more_messages_to_send), 0x00,
3081                 "Indicates more messages pending for the same destination.",
3082                 HFILL
3083             }
3084         },
3085         {   &hf_smpp_number_of_messages,
3086             {   "Number of messages", "smpp.number_of_messages",
3087                 FT_UINT8, BASE_DEC, NULL, 0x00,
3088                 "Indicates number of messages stored in a mailbox.",
3089                 HFILL
3090             }
3091         },
3092         {   &hf_smpp_its_reply_type,
3093             {   "Reply method", "smpp.its_reply_type",
3094                 FT_UINT8, BASE_DEC, VALS(vals_its_reply_type), 0x00,
3095                 "Indicates the handset reply method on message receipt.",
3096                 HFILL
3097             }
3098         },
3099         {   &hf_smpp_ussd_service_op,
3100             {   "USSD service operation", "smpp.ussd_service_op",
3101                 FT_UINT8, BASE_DEC, VALS(vals_ussd_service_op), 0x00,
3102                 "Indicates the USSD service operation.",
3103                 HFILL
3104             }
3105         },
3106         {   &hf_smpp_vendor_op,
3107             {   "Value", "smpp.vendor_op",
3108                 FT_BYTES, BASE_NONE, NULL, 0x00,
3109                 "A supplied optional parameter specific to an SMSC-vendor.",
3110                 HFILL
3111             }
3112         },
3113         {   &hf_smpp_reserved_op,
3114             {   "Value", "smpp.reserved_op",
3115                 FT_BYTES, BASE_NONE, NULL, 0x00,
3116                 "An optional parameter that is reserved in this version.",
3117                 HFILL
3118             }
3119         },
3120         {   &hf_smpp_msg_wait_ind,
3121             {   "Indication", "smpp.msg_wait.ind",
3122                 FT_UINT8, BASE_HEX, VALS(vals_msg_wait_ind), 0x80,
3123                 "Indicates to the handset that a message is waiting.",
3124                 HFILL
3125             }
3126         },
3127         {   &hf_smpp_msg_wait_type,
3128             {   "Type", "smpp.msg_wait.type",
3129                 FT_UINT8, BASE_HEX, VALS(vals_msg_wait_type), 0x03,
3130                 "Indicates type of message that is waiting.",
3131                 HFILL
3132             }
3133         },
3134         {   &hf_smpp_SC_interface_version,
3135             {   "SMSC-supported version", "smpp.SC_interface_version",
3136                 FT_STRING, BASE_NONE, NULL, 0x00,
3137                 "Version of SMPP interface supported by the SMSC.",
3138                 HFILL
3139             }
3140         },
3141         {   &hf_smpp_callback_num_pres,
3142             {   "Presentation", "smpp.callback_num.pres",
3143                 FT_UINT8, BASE_HEX, VALS(vals_callback_num_pres), 0x0C,
3144                 "Controls the presentation indication.",
3145                 HFILL
3146             }
3147         },
3148         {   &hf_smpp_callback_num_scrn,
3149             {   "Screening", "smpp.callback_num.scrn",
3150                 FT_UINT8, BASE_HEX, VALS(vals_callback_num_scrn), 0x03,
3151                 "Controls screening of the callback-number.",
3152                 HFILL
3153             }
3154         },
3155         {   &hf_smpp_callback_num_atag,
3156             {   "Callback number - alphanumeric display tag",
3157                 "smpp.callback_num_atag",
3158                 FT_NONE, BASE_NONE, NULL, 0x00,
3159                 "Associates an alphanumeric display with call back number.",
3160                 HFILL
3161             }
3162         },
3163         {   &hf_smpp_callback_num,
3164             {   "Callback number", "smpp.callback_num",
3165                 FT_NONE, BASE_NONE, NULL, 0x00,
3166                 "Associates a call back number with the message.",
3167                 HFILL
3168             }
3169         },
3170         {   &hf_smpp_network_error_type,
3171             {   "Error type", "smpp.network_error.type",
3172                 FT_UINT8, BASE_DEC, VALS(vals_network_error_type), 0x00,
3173                 "Indicates the network type.",
3174                 HFILL
3175             }
3176         },
3177         {   &hf_smpp_network_error_code,
3178             {   "Error code", "smpp.network_error.code",
3179                 FT_UINT16, BASE_HEX, NULL, 0x00,
3180                 "Gives the actual network error code.",
3181                 HFILL
3182             }
3183         },
3184         {   &hf_smpp_message_payload,
3185             {   "Payload", "smpp.message_payload",
3186                 FT_NONE, BASE_NONE, NULL, 0x00,
3187                 "Short message user data.",
3188                 HFILL
3189             }
3190         },
3191         {   &hf_smpp_alert_on_message_delivery_null,
3192             {   "Alert on delivery", "smpp.alert_on_message_delivery",
3193                 FT_NONE, BASE_NONE, NULL, 0x00,
3194                 "Instructs the handset to alert user on message delivery.",
3195                 HFILL
3196             }
3197         },
3198         {   &hf_smpp_alert_on_message_delivery,
3199             {   "Alert on delivery", "smpp.alert_on_message_delivery",
3200                 FT_UINT8, BASE_DEC, VALS(vals_alert_on_message_delivery), 0x00,
3201                 "Instructs the handset to alert user on message delivery.",
3202                 HFILL
3203             }
3204         },
3205         {   &hf_smpp_its_session_number,
3206             {   "Session number", "smpp.its_session.number",
3207                 FT_UINT8, BASE_DEC, NULL, 0x00,
3208                 "Session number of interactive teleservice.",
3209                 HFILL
3210             }
3211         },
3212         {   &hf_smpp_its_session_sequence,
3213             {   "Sequence number", "smpp.its_session.sequence",
3214                 FT_UINT8, BASE_HEX, NULL, 0xFE,
3215                 "Sequence number of the dialogue unit.",
3216                 HFILL
3217             }
3218         },
3219         {   &hf_smpp_its_session_ind,
3220             {   "Session indicator", "smpp.its_session.ind",
3221                 FT_UINT8, BASE_HEX, VALS(vals_its_session_ind), 0x01,
3222                 "Indicates whether this message is end of conversation.",
3223                 HFILL
3224             }
3225         },
3226         {   &hf_smpp_opt_params,
3227             {   "Optional parameters", "smpp.opt_params",
3228                 FT_NONE, BASE_NONE, NULL, 0x00,
3229                 "The list of optional parameters in this operation.",
3230                 HFILL
3231             }
3232         },
3233         {   &hf_smpp_opt_param,
3234             {   "Optional parameter", "smpp.opt_param",
3235                 FT_NONE, BASE_NONE, NULL, 0x00,
3236                 NULL,
3237                 HFILL
3238             }
3239         },
3240         {   &hf_smpp_opt_param_tag,
3241             {   "Tag", "smpp.opt_param_tag",
3242                 FT_UINT16, BASE_HEX, NULL, 0x00,
3243                 "Optional parameter intentifier tag",
3244                 HFILL
3245             }
3246         },
3247         {   &hf_smpp_opt_param_len,
3248             {   "Length", "smpp.opt_param_len",
3249                 FT_UINT16, BASE_DEC, NULL, 0x00,
3250                 "Optional parameter length",
3251                 HFILL
3252             }
3253         },
3254
3255         /*
3256          * Data Coding Scheme
3257          */
3258         {       &hf_smpp_dcs,
3259                 { "SMPP Data Coding Scheme", "smpp.dcs",
3260                 FT_UINT8, BASE_HEX, VALS(vals_data_coding), 0x00,
3261                 "Data Coding Scheme according to SMPP.",
3262                 HFILL
3263             }
3264         },
3265         {       &hf_smpp_dcs_sms_coding_group,
3266                 {       "DCS Coding Group for SMS", "smpp.dcs.sms_coding_group",
3267                         FT_UINT8, BASE_HEX, VALS(vals_dcs_sms_coding_group), 0xF0,
3268                         "Data Coding Scheme coding group for GSM Short Message Service.",
3269                         HFILL
3270                 }
3271         },
3272         {       &hf_smpp_dcs_text_compression,
3273                 {       "DCS Text compression", "smpp.dcs.text_compression",
3274                         FT_BOOLEAN, 8, TFS(&tfs_dcs_text_compression), 0x20,
3275                         "Indicates if text compression is used.", HFILL
3276                 }
3277         },
3278         {       &hf_smpp_dcs_class_present,
3279                 {       "DCS Class present", "smpp.dcs.class_present",
3280                         FT_BOOLEAN, 8, TFS(&tfs_dcs_class_present), 0x10,
3281                         "Indicates if the message class is present (defined).", HFILL
3282                 }
3283         },
3284         {       &hf_smpp_dcs_charset,
3285                 {       "DCS Character set", "smpp.dcs.charset",
3286                         FT_UINT8, BASE_HEX, VALS(vals_dcs_charset), 0x0C,
3287                         "Specifies the character set used in the message.", HFILL
3288                 }
3289         },
3290         {       &hf_smpp_dcs_class,
3291                 {       "DCS Message class", "smpp.dcs.class",
3292                         FT_UINT8, BASE_HEX, VALS(vals_dcs_class), 0x03,
3293                         "Specifies the message class.", HFILL
3294                 }
3295         },
3296         {       &hf_smpp_dcs_cbs_coding_group,
3297                 {       "DCS Coding Group for CBS", "smpp.dcs.cbs_coding_group",
3298                         FT_UINT8, BASE_HEX, VALS(vals_dcs_cbs_coding_group), 0xF0,
3299                         "Data Coding Scheme coding group for GSM Cell Broadcast Service.",
3300                         HFILL
3301                 }
3302         },
3303         {       &hf_smpp_dcs_cbs_language,
3304                 {       "DCS CBS Message language", "smpp.dcs.cbs_language",
3305                         FT_UINT8, BASE_HEX, VALS(vals_dcs_cbs_language), 0x3F,
3306                         "Language of the GSM Cell Broadcast Service message.", HFILL
3307                 }
3308         },
3309         {       &hf_smpp_dcs_cbs_class,
3310                 {       "DCS CBS Message class", "smpp.dcs.cbs_class",
3311                         FT_UINT8, BASE_HEX, VALS(vals_dcs_cbs_class), 0x03,
3312                         "Specifies the message class for GSM Cell Broadcast Service, for the Data coding / message handling code group.", HFILL
3313                 }
3314         },
3315         {       &hf_smpp_dcs_wap_charset,
3316                 {       "DCS Message coding", "smpp.dcs.wap_coding",
3317                         FT_UINT8, BASE_HEX, VALS(vals_dcs_wap_charset), 0x0C,
3318                         "Specifies the used message encoding, as specified by the WAP Forum (WAP over GSM USSD).", HFILL
3319                 }
3320         },
3321         {       &hf_smpp_dcs_wap_class,
3322                 {       "DCS CBS Message class", "smpp.dcs.wap_class",
3323                         FT_UINT8, BASE_HEX, VALS(vals_dcs_wap_class), 0x03,
3324                         "Specifies the message class for GSM Cell Broadcast Service, as specified by the WAP Forum (WAP over GSM USSD).", HFILL
3325                 }
3326         },
3327         /* Changes in SMPP 5.0 */
3328         {       &hf_smpp_congestion_state,
3329                 {       "Congestion State", "smpp.congestion_state",
3330                         FT_UINT8, BASE_DEC | BASE_RANGE_STRING, RVALS(vals_congestion_state), 0x00,
3331                         "Congestion info between ESME and MC for flow control/cong. control", HFILL
3332                 }
3333         },
3334         {       &hf_smpp_billing_identification,
3335                 {       "Billing Identification", "smpp.billing_id",
3336                         FT_BYTES, BASE_NONE, NULL, 0x00,
3337                         "Billing identification info", HFILL
3338                 }
3339         },
3340         {       &hf_smpp_dest_addr_np_country,
3341                 {       "Destination Country Code", "smpp.dest_addr_np_country",
3342                         FT_BYTES, BASE_NONE, NULL, 0x00,
3343                         "Destination Country Code (E.164 Region Code)", HFILL
3344                 }
3345         },
3346         {       &hf_smpp_dest_addr_np_information,
3347                 {       "Number Portability information", "smpp.dest_addr_np_info",
3348                         FT_BYTES, BASE_NONE, NULL, 0x00,
3349                         NULL, HFILL
3350                 }
3351         },
3352         {       &hf_smpp_dest_addr_np_resolution,
3353                 {       "Number Portability query information", "smpp.dest_addr_np_resolution",
3354                         FT_UINT8, BASE_DEC, VALS(vals_dest_addr_np_resolution), 0x00,
3355                         "Number Portability query information - method used to resolve number", HFILL
3356                 }
3357         },
3358         {       &hf_smpp_source_network_id,
3359                 {       "Source Network ID", "smpp.source_network_id",
3360                         FT_STRING, BASE_NONE, NULL, 0x00,
3361                         "Unique ID for a network or ESME operator", HFILL
3362                 }
3363         },
3364         {       &hf_smpp_source_node_id,
3365                 {       "Source Node ID", "smpp.source_node_id",
3366                         FT_BYTES, BASE_NONE, NULL, 0x00,
3367                         "Unique ID for a ESME or MC node", HFILL
3368                 }
3369         },
3370         {       &hf_smpp_dest_network_id,
3371                 {       "Destination Network ID", "smpp.dest_network_id",
3372                         FT_STRING, BASE_NONE, NULL, 0x00,
3373                         "Unique ID for a network or ESME operator", HFILL
3374                 }
3375         },
3376         {       &hf_smpp_dest_node_id,
3377                 {       "Destination Node ID", "smpp.dest_node_id",
3378                         FT_BYTES, BASE_NONE, NULL, 0x00,
3379                         "Unique ID for a ESME or MC node", HFILL
3380                 }
3381         },
3382         {       &hf_smpp_broadcast_channel_indicator,
3383                 {       "Cell Broadcast channel", "smpp.broadcast_channel_indicator",
3384                         FT_UINT8, BASE_DEC | BASE_RANGE_STRING, RVALS(vals_broadcast_channel_indicator), 0x00,
3385                         NULL, HFILL
3386                 }
3387         },
3388         {       &hf_smpp_broadcast_content_type_nw,
3389                 {       "Broadcast Content Type - Network Tag", "smpp.broadcast_content_type.nw",
3390                         FT_UINT8, BASE_DEC, VALS(vals_broadcast_content_type_nw), 0x00,
3391                         "Cell Broadcast content type", HFILL
3392                 }
3393         },
3394         {       &hf_smpp_broadcast_content_type_type,
3395                 {       "Broadcast Content Type - Content Type", "smpp.broadcast_content_type.type",
3396                         FT_UINT16, BASE_HEX, VALS(vals_broadcast_content_type_type), 0x00,
3397                         "Cell Broadcast content type", HFILL
3398                 }
3399         },
3400         {       &hf_smpp_broadcast_content_type_info,
3401                 {       "Broadcast Content Type Info", "smpp.broadcast_content_type.type",
3402                         FT_BYTES, BASE_NONE, NULL, 0x00,
3403                         "Cell Broadcast content type Info", HFILL
3404                 }
3405         },
3406         {       &hf_smpp_broadcast_message_class,
3407                 {       "Broadcast Message Class", "smpp.broadcast_message_class",
3408                         FT_UINT8, BASE_HEX, VALS(vals_broadcast_message_class), 0x00,
3409                         "Cell Broadcast Message Class", HFILL
3410                 }
3411         },
3412         {       &hf_smpp_broadcast_rep_num,
3413                 {       "Broadcast Message - Number of repetitions requested", "smpp.broadcast_rep_num",
3414                         FT_UINT16, BASE_DEC, NULL, 0x00,
3415                         "Cell Broadcast Message - Number of repetitions requested", HFILL
3416                 }
3417         },
3418         {       &hf_smpp_broadcast_frequency_interval_unit,
3419                 {       "Broadcast Message - frequency interval - Unit", "smpp.broadcast_frequency_interval.unit",
3420                         FT_UINT8, BASE_HEX, VALS(vals_broadcast_frequency_interval_unit), 0x00,
3421                         "Cell Broadcast Message - frequency interval at which broadcast must be repeated", HFILL
3422                 }
3423         },
3424         {       &hf_smpp_broadcast_frequency_interval_value,
3425                 {       "Broadcast Message - frequency interval - Unit", "smpp.broadcast_frequency_interval.value",
3426                         FT_UINT16, BASE_DEC, NULL, 0x00,
3427                         "Cell Broadcast Message - frequency interval at which broadcast must be repeated", HFILL
3428                 }
3429         },
3430         {       &hf_smpp_broadcast_area_identifier,
3431                 {       "Broadcast Message - Area Identifier", "smpp.broadcast_area_identifier",
3432                         FT_BYTES, BASE_NONE, NULL, 0x00,
3433                         "Cell Broadcast Message - Area Identifier", HFILL
3434                 }
3435         },
3436         {       &hf_smpp_broadcast_area_identifier_format,
3437                 {       "Broadcast Message - Area Identifier Format", "smpp.broadcast_area_identifier.format",
3438                         FT_UINT8, BASE_HEX | BASE_RANGE_STRING, RVALS(vals_broadcast_area_identifier_format), 0x00,
3439                         "Cell Broadcast Message - Area Identifier Format", HFILL
3440                 }
3441         },
3442         {       &hf_smpp_broadcast_error_status,
3443                 {       "Broadcast Message - Error Status", "smpp.broadcast_error_status",
3444                         FT_UINT32, BASE_HEX, VALS(vals_command_status), 0x00,
3445                         "Cell Broadcast Message - Error Status", HFILL
3446                 }
3447         },
3448         {       &hf_smpp_broadcast_area_success,
3449                 {       "Broadcast Message - Area Success", "smpp.broadcast_area_success",
3450                         FT_UINT8, BASE_DEC | BASE_RANGE_STRING, RVALS(vals_broadcast_area_success), 0x00,
3451                         "Cell Broadcast Message - success rate indicator (ratio) - No. of BTS which accepted Message:Total BTS", HFILL
3452                 }
3453         },
3454         {       &hf_smpp_broadcast_end_time,
3455                 {       "Broadcast Message - End Time", "smpp.broadcast_end_time",
3456                         FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00,
3457                         "Cell Broadcast Message - Date and time at which MC set the state of the message to terminated", HFILL
3458                 }
3459         },
3460         {       &hf_smpp_broadcast_end_time_r,
3461                 {       "Broadcast Message - End Time", "smpp.broadcast_end_time_r",
3462                         FT_RELATIVE_TIME, BASE_NONE, NULL, 0x00,
3463                         "Cell Broadcast Message - Date and time at which MC set the state of the message to terminated", HFILL
3464                 }
3465         },
3466         {       &hf_smpp_broadcast_service_group,
3467                 {       "Broadcast Message - Service Group", "smpp.broadcast_service_group",
3468                         FT_BYTES, BASE_NONE, NULL, 0x00,
3469                         "Cell Broadcast Message - Service Group", HFILL
3470                 }
3471         }
3472     };
3473     /* Setup protocol subtree array */
3474     static gint *ett[] = {
3475         &ett_smpp,
3476         &ett_dlist,
3477         &ett_dlist_resp,
3478         &ett_opt_params,
3479         &ett_opt_param,
3480         &ett_dcs,
3481     };
3482     DebugLog(("Registering SMPP dissector\n"));
3483     /* Register the protocol name and description */
3484     proto_smpp = proto_register_protocol("Short Message Peer to Peer",
3485                                          "SMPP", "smpp");
3486
3487     /* Required function calls to register header fields and subtrees used */
3488     proto_register_field_array(proto_smpp, hf, array_length(hf));
3489     proto_register_subtree_array(ett, array_length(ett));
3490
3491     /* Allow other dissectors to find this one by name. */
3492     register_dissector("smpp", dissect_smpp, proto_smpp);
3493
3494     /* Register for tapping */
3495     smpp_tap = register_tap("smpp");
3496
3497     /* Preferences */
3498     smpp_module = prefs_register_protocol (proto_smpp, NULL);
3499     prefs_register_bool_preference (smpp_module,
3500             "reassemble_smpp_over_tcp",
3501             "Reassemble SMPP over TCP messages spanning multiple TCP segments",
3502             "Whether the SMPP dissector should reassemble messages spanning multiple TCP segments."
3503             " To use this option, you must also enable "
3504             "\"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",
3505             &reassemble_over_tcp);
3506 }
3507
3508 /*
3509  * If dissector uses sub-dissector registration add a registration routine.
3510  * This format is required because a script is used to find these routines and
3511  * create the code that calls these routines.
3512  */
3513 void
3514 proto_reg_handoff_smpp(void)
3515 {
3516     dissector_handle_t smpp_handle;
3517
3518     /*
3519      * SMPP can be spoken on any port under TCP or X.25
3520      * ...how *do* we do that under X.25?
3521      *
3522      * We can register the heuristic SMPP dissector with X.25, for one
3523      * thing.  We don't currently have any mechanism to allow the user
3524      * to specify that a given X.25 circuit is to be dissected as SMPP,
3525      * however.
3526      */
3527     smpp_handle = find_dissector("smpp");
3528     dissector_add_handle("tcp.port", smpp_handle);
3529     heur_dissector_add("tcp", dissect_smpp_heur, proto_smpp);
3530     heur_dissector_add("x.25", dissect_smpp_heur, proto_smpp);
3531
3532     /* Required for call_dissector() */
3533     DebugLog(("Finding gsm-sms-ud subdissector\n"));
3534     gsm_sms_handle = find_dissector("gsm-sms-ud");
3535     DISSECTOR_ASSERT(gsm_sms_handle);
3536
3537     /* Tapping setup */
3538     stats_tree_register_with_group("smpp","smpp_commands", "SM_PP Operations", 0,
3539                                    smpp_stats_tree_per_packet, smpp_stats_tree_init,
3540                                    NULL, REGISTER_STAT_GROUP_TELEPHONY);
3541 }