/* packet-smpp.c

 * Routines for Short Message Peer to Peer dissection

 * Copyright 2001, Tom Uijldert.

 *

 * Data Coding Scheme decoding for GSM (SMS and CBS),

 * provided by Olivier Biot.

 *

 * Dissection of multiple SMPP PDUs within one packet

 * provided by Chris Wilson.

 *

 * Statistics support using Stats Tree API

 * provided by Abhik Sarkar

 *

 * Support for SMPP 5.0

 * introduced by Abhik Sarkar

 *

 * Support for Huawei SMPP+ extensions

 * introduced by Xu Bo and enhanced by Abhik Sarkar

 *

 * Enhanced error code handling

 * provided by Stipe Tolj from Kannel.

 *

 * Refer to the AUTHORS file or the AUTHORS section in the man page

 * for contacting the author(s) of this file.

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 *

 * ----------

 *

 * Dissector of an SMPP (Short Message Peer to Peer) PDU, as defined by the

 * SMS forum (www.smsforum.net) in "SMPP protocol specification v3.4"

 * (document version: 12-Oct-1999 Issue 1.2)

 */

#include "config.h"

#include <errno.h>

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/exceptions.h>

#include <epan/stats_tree.h>

#include <epan/prefs.h>

#include <epan/exported_pdu.h>

#include <epan/conversation.h>

#include <epan/proto_data.h>

#include <wsutil/time_util.h>

#include "packet-tcp.h"

#include "packet-tls.h"

#include "packet-smpp.h"

#include <epan/strutil.h>

#define SMPP_FIXED_HEADER_LENGTH  16

#define SMPP_MIN_LENGTH SMPP_FIXED_HEADER_LENGTH

/* Forward declarations         */

void proto_register_smpp(void);

void proto_reg_handoff_smpp(void);

static int exported_pdu_tap = -1;

/*

 * Initialize the protocol and registered fields

 *

 * Fixed header section

 */

static int proto_smpp;

static int st_smpp_ops                                = -1;

static int st_smpp_req                                = -1;

static int st_smpp_res                                = -1;

static int st_smpp_res_status                         = -1;

static int hf_smpp_command_id;

static int hf_smpp_command_request;

static int hf_smpp_command_response;

static int hf_smpp_command_length;

static int hf_smpp_command_status;

static int hf_smpp_sequence_number;

/*

 * Fixed body section

 */

static int hf_smpp_system_id;

static int hf_smpp_password;

static int hf_smpp_system_type;

static int hf_smpp_interface_version;

static int hf_smpp_addr_ton;

static int hf_smpp_addr_npi;

static int hf_smpp_address_range;

static int hf_smpp_service_type;

static int hf_smpp_source_addr_ton;

static int hf_smpp_source_addr_npi;

static int hf_smpp_source_addr;

static int hf_smpp_dest_addr_ton;

static int hf_smpp_dest_addr_npi;

static int hf_smpp_destination_addr;

static int hf_smpp_esm_submit_msg_mode;

static int hf_smpp_esm_submit_msg_type;

static int hf_smpp_esm_submit_features;

static int hf_smpp_protocol_id;

static int hf_smpp_priority_flag;

static int hf_smpp_schedule_delivery_time;

static int hf_smpp_schedule_delivery_time_r;

static int hf_smpp_validity_period;

static int hf_smpp_validity_period_r;

static int hf_smpp_regdel_receipt;

static int hf_smpp_regdel_acks;

static int hf_smpp_regdel_notif;

static int hf_smpp_replace_if_present_flag;

static int hf_smpp_data_coding;

static int hf_smpp_sm_default_msg_id;

static int hf_smpp_sm_length;

static int hf_smpp_short_message;

static int hf_smpp_short_message_bin;

static int hf_smpp_message_id;

static int hf_smpp_dlist;

static int hf_smpp_dlist_resp;

static int hf_smpp_dl_name;

static int hf_smpp_final_date;

static int hf_smpp_final_date_r;

static int hf_smpp_message_state;

static int hf_smpp_error_code;

static int hf_smpp_error_status_code;

static int hf_smpp_esme_addr_ton;

static int hf_smpp_esme_addr_npi;

static int hf_smpp_esme_addr;

/*

 * Optional parameter section

 */

static int hf_smpp_opt_params;

static int hf_smpp_opt_param;

static int hf_smpp_opt_param_tag;

static int hf_smpp_opt_param_len;

static int hf_smpp_vendor_op;

static int hf_smpp_reserved_op;

static int hf_smpp_dest_addr_subunit;

static int hf_smpp_dest_network_type;

static int hf_smpp_dest_bearer_type;

static int hf_smpp_dest_telematics_id;

static int hf_smpp_source_addr_subunit;

static int hf_smpp_source_network_type;

static int hf_smpp_source_bearer_type;

static int hf_smpp_source_telematics_id;

static int hf_smpp_qos_time_to_live;

static int hf_smpp_payload_type;

static int hf_smpp_additional_status_info_text;

static int hf_smpp_receipted_message_id;

static int hf_smpp_msg_wait_ind;

static int hf_smpp_msg_wait_type;

static int hf_smpp_privacy_indicator;

static int hf_smpp_source_subaddress;

static int hf_smpp_dest_subaddress;

static int hf_smpp_user_message_reference;

static int hf_smpp_user_response_code;

static int hf_smpp_source_port;

static int hf_smpp_destination_port;

static int hf_smpp_sar_msg_ref_num;

static int hf_smpp_language_indicator;

static int hf_smpp_sar_total_segments;

static int hf_smpp_sar_segment_seqnum;

static int hf_smpp_SC_interface_version;

static int hf_smpp_callback_num_pres;

static int hf_smpp_callback_num_scrn;

static int hf_smpp_callback_num_atag;

static int hf_smpp_number_of_messages;

static int hf_smpp_callback_num;

static int hf_smpp_dpf_result;

static int hf_smpp_set_dpf;

static int hf_smpp_ms_availability_status;

static int hf_smpp_network_error_type;

static int hf_smpp_network_error_code;

static int hf_smpp_message_payload;

static int hf_smpp_delivery_failure_reason;

static int hf_smpp_more_messages_to_send;

static int hf_smpp_ussd_service_op;

static int hf_smpp_display_time;

static int hf_smpp_sms_signal;

static int hf_smpp_ms_validity;

static int hf_smpp_alert_on_message_delivery_null;

static int hf_smpp_alert_on_message_delivery_type;

static int hf_smpp_its_reply_type;

static int hf_smpp_its_session_number;

static int hf_smpp_its_session_sequence;

static int hf_smpp_its_session_ind;

/* Optional Parameters introduced in SMPP 5.0   */

static int hf_smpp_congestion_state;

static int hf_smpp_billing_identification;

static int hf_smpp_dest_addr_np_country;

static int hf_smpp_dest_addr_np_information;

static int hf_smpp_dest_addr_np_resolution;

static int hf_smpp_source_network_id;

static int hf_smpp_source_node_id;

static int hf_smpp_dest_network_id;

static int hf_smpp_dest_node_id;

/* Optional Parameters for Cell Broadcast Operations */

static int hf_smpp_broadcast_channel_indicator;

static int hf_smpp_broadcast_content_type_nw;

static int hf_smpp_broadcast_content_type_type;

static int hf_smpp_broadcast_content_type_info;

static int hf_smpp_broadcast_message_class;

static int hf_smpp_broadcast_rep_num;

static int hf_smpp_broadcast_frequency_interval_unit;

static int hf_smpp_broadcast_frequency_interval_value;

static int hf_smpp_broadcast_area_identifier;

static int hf_smpp_broadcast_area_identifier_format;

static int hf_smpp_broadcast_error_status;

static int hf_smpp_broadcast_area_success;

static int hf_smpp_broadcast_end_time;

static int hf_smpp_broadcast_end_time_r;

static int hf_smpp_broadcast_service_group;

/*

 * Data Coding Scheme section

 */

static int hf_smpp_dcs_sms_coding_group;

static int hf_smpp_dcs_reserved;

static int hf_smpp_dcs_charset;

static int hf_smpp_dcs_class;

static int hf_smpp_dcs_wait_ind;

static int hf_smpp_dcs_reserved2;

static int hf_smpp_dcs_wait_type;

/*

 * Huawei SMPP+ extensions

 */

static int hf_huawei_smpp_smsc_addr;

static int hf_huawei_smpp_msc_addr_noa;

static int hf_huawei_smpp_msc_addr_npi;

static int hf_huawei_smpp_msc_addr;

static int hf_huawei_smpp_mo_mt_flag;

static int hf_huawei_smpp_length_auth;

static int hf_huawei_smpp_sm_id;

static int hf_huawei_smpp_service_id;

static int hf_huawei_smpp_operation_result;

static int hf_huawei_smpp_notify_mode;

static int hf_huawei_smpp_delivery_result;

/*

 * Request/response tracking

 */

static int hf_smpp_response_in;

static int hf_smpp_request_in;

static int hf_smpp_response_time;

static expert_field ei_smpp_message_payload_duplicate;

static expert_field ei_smpp_date_time_decoding_failed;

/* Initialize the subtree pointers */

static int ett_smpp;

static int ett_dlist;

static int ett_dlist_resp;

static int ett_opt_params;

static int ett_opt_param;

static int ett_dcs;

static dissector_handle_t smpp_handle;

/* Reassemble SMPP TCP segments */

static bool reassemble_over_tcp = true;

static bool smpp_gsm7_unpacked = true;

typedef enum {

  DECODE_AS_DEFAULT    =   0,

  DECODE_AS_ASCII      =   1,

  DECODE_AS_OCTET      =   2, /* 8-bit binary */

  DECODE_AS_ISO_8859_1 =   3,

  DECODE_AS_ISO_8859_5 =   6,

  DECODE_AS_ISO_8859_8 =   7,

  DECODE_AS_UCS2       =   8,

  DECODE_AS_KSC5601    =  14, /* Korean, EUC-KR as in ANSI 637 */

  DECODE_AS_GSM7       = 241, /* One of many GSM DCS values that means GSM7 */

} SMPP_DCS_Type;

/* ENC_NA is the same as ENC_ASCII, so use an artificial value to mean

 * "treat this as 8-bit binary / FT_BYTES, not a string."

 */

#define DO_NOT_DECODE UINT_MAX

/* Default preference whether to decode the SMS over SMPP when DCS = 0 */

static int smpp_decode_dcs_0_sms = DO_NOT_DECODE;

/* Tap */

static int smpp_tap;

#define SMPP_COMMAND_ID_GENERIC_NACK        0x00000000

#define SMPP_COMMAND_ID_BIND_RECEIVER       0x00000001

#define SMPP_COMMAND_ID_BIND_TRANSMITTER    0x00000002

#define SMPP_COMMAND_ID_QUERY_SM            0x00000003

#define SMPP_COMMAND_ID_SUBMIT_SM           0x00000004

#define SMPP_COMMAND_ID_DELIVER_SM          0x00000005

#define SMPP_COMMAND_ID_UNBIND              0x00000006

#define SMPP_COMMAND_ID_REPLACE_SM          0x00000007

#define SMPP_COMMAND_ID_CANCEL_SM           0x00000008

#define SMPP_COMMAND_ID_BIND_TRANSCEIVER    0x00000009

#define SMPP_COMMAND_ID_OUTBIND             0x0000000B

#define SMPP_COMMAND_ID_ENQUIRE_LINK        0x00000015

#define SMPP_COMMAND_ID_SUBMIT_MULTI        0x00000021

#define SMPP_COMMAND_ID_ALERT_NOTIFICATION  0x00000102

#define SMPP_COMMAND_ID_DATA_SM             0x00000103

/* Introduced in SMPP 5.0 */

#define SMPP_COMMAND_ID_BROADCAST_SM        0x00000111

#define SMPP_COMMAND_ID_QUERY_BROADCAST_SM  0x00000112

#define SMPP_COMMAND_ID_CANCEL_BROADCAST_SM 0x00000113

/* Huawei SMPP+ extensions */

#define SMPP_COMMAND_ID_HUAWEI_AUTH_ACC     0x01000001

#define SMPP_COMMAND_ID_HUAWEI_SM_RESULT_NOTIFY 0X01000002

#define SMPP_COMMAND_ID_RESPONSE_MASK       0x80000000

#define SMPP_UDHI_MASK 0x40

/*

 * Value-arrays for field-contents

 */

static const value_string vals_command_id[] = {         /* Operation    */

    { SMPP_COMMAND_ID_BIND_RECEIVER, "Bind_receiver" },

    { SMPP_COMMAND_ID_BIND_TRANSMITTER, "Bind_transmitter" },

    { SMPP_COMMAND_ID_QUERY_SM, "Query_sm" },

    { SMPP_COMMAND_ID_SUBMIT_SM, "Submit_sm" },

    { SMPP_COMMAND_ID_DELIVER_SM, "Deliver_sm" },

    { SMPP_COMMAND_ID_UNBIND, "Unbind" },

    { SMPP_COMMAND_ID_REPLACE_SM, "Replace_sm" },

    { SMPP_COMMAND_ID_CANCEL_SM, "Cancel_sm" },

    { SMPP_COMMAND_ID_BIND_TRANSCEIVER, "Bind_transceiver" },

    { SMPP_COMMAND_ID_OUTBIND, "Outbind" },

    { SMPP_COMMAND_ID_ENQUIRE_LINK, "Enquire_link" },

    { SMPP_COMMAND_ID_SUBMIT_MULTI, "Submit_multi" },

    { SMPP_COMMAND_ID_ALERT_NOTIFICATION, "Alert_notification" },

    { SMPP_COMMAND_ID_DATA_SM, "Data_sm" },

    { SMPP_COMMAND_ID_BROADCAST_SM, "Broadcast_sm" },

    { SMPP_COMMAND_ID_QUERY_BROADCAST_SM, "Query_broadcast_sm" },

    { SMPP_COMMAND_ID_CANCEL_BROADCAST_SM, "Cancel_broadcast_sm" },

    { SMPP_COMMAND_ID_HUAWEI_AUTH_ACC, "Auth_acc" },

    { SMPP_COMMAND_ID_HUAWEI_SM_RESULT_NOTIFY, "Sm_result_notify" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_GENERIC_NACK, "Generic_nack" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_BIND_RECEIVER, "Bind_receiver - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_BIND_TRANSMITTER, "Bind_transmitter - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_QUERY_SM, "Query_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_SUBMIT_SM, "Submit_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_DELIVER_SM, "Deliver_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_UNBIND, "Unbind - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_REPLACE_SM, "Replace_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_CANCEL_SM, "Cancel_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_BIND_TRANSCEIVER, "Bind_transceiver - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_ENQUIRE_LINK, "Enquire_link - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_SUBMIT_MULTI, "Submit_multi - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_DATA_SM, "Data_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_BROADCAST_SM, "Broadcast_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_QUERY_BROADCAST_SM, "Query_broadcast_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_CANCEL_BROADCAST_SM, "Cancel_broadcast_sm - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_HUAWEI_AUTH_ACC, "Auth_acc - resp" },

    { SMPP_COMMAND_ID_RESPONSE_MASK|SMPP_COMMAND_ID_HUAWEI_SM_RESULT_NOTIFY, "Sm_result_notify - resp" },

    { 0, NULL }

};

static const range_string rvals_command_status[] = {     /* Status       */

    { 0x00000000, 0x00000000, "Ok" },

    { 0x00000001, 0x00000001, "Message length is invalid" },

    { 0x00000002, 0x00000002, "Command length is invalid" },

    { 0x00000003, 0x00000003, "Invalid command ID" },

    { 0x00000004, 0x00000004, "Incorrect BIND status for given command" },

    { 0x00000005, 0x00000005, "ESME already in bound state" },

    { 0x00000006, 0x00000006, "Invalid priority flag" },

    { 0x00000007, 0x00000007, "Invalid registered delivery flag" },

    { 0x00000008, 0x00000008, "System error" },

    { 0x00000009, 0x00000009, "[Reserved]" },

    { 0x0000000A, 0x0000000A, "Invalid source address" },

    { 0x0000000B, 0x0000000B, "Invalid destination address" },

    { 0x0000000C, 0x0000000C, "Message ID is invalid" },

    { 0x0000000D, 0x0000000D, "Bind failed" },

    { 0x0000000E, 0x0000000E, "Invalid password" },

    { 0x0000000F, 0x0000000F, "Invalid system ID" },

    { 0x00000010, 0x00000010, "[Reserved]" },

    { 0x00000011, 0x00000011, "Cancel SM failed" },

    { 0x00000012, 0x00000012, "[Reserved]" },

    { 0x00000013, 0x00000013, "Replace SM failed" },

    { 0x00000014, 0x00000014, "Message queue full" },

    { 0x00000015, 0x00000015, "Invalid service type" },

    { 0x00000016, 0x00000032, "[Reserved]" },

    { 0x00000033, 0x00000033, "Invalid number of destinations" },

    { 0x00000034, 0x00000034, "Invalid distribution list name" },

    { 0x00000035, 0x0000003F, "[Reserved]" },

    { 0x00000040, 0x00000040, "Destination flag is invalid (submit_multi)" },

    { 0x00000041, 0x00000041, "[Reserved]" },

    { 0x00000042, 0x00000042, "Invalid 'submit with replace' request" },

    { 0x00000043, 0x00000043, "Invalid esm_class field data" },

    { 0x00000044, 0x00000044, "Cannot submit to distribution list" },

    { 0x00000045, 0x00000045, "submit_sm or submit_multi failed" },

    { 0x00000046, 0x00000047, "[Reserved]" },

    { 0x00000048, 0x00000048, "Invalid source address TON" },

    { 0x00000049, 0x00000049, "Invalid source address NPI" },

    { 0x00000050, 0x00000050, "Invalid destination address TON" },

    { 0x00000051, 0x00000051, "Invalid destination address NPI" },

    { 0x00000052, 0x00000052, "[Reserved]" },

    { 0x00000053, 0x00000053, "Invalid system_type field" },

    { 0x00000054, 0x00000054, "Invalid replace_if_present flag" },

    { 0x00000055, 0x00000055, "Invalid number of messages" },

    { 0x00000056, 0x00000057, "[Reserved]" },

    { 0x00000058, 0x00000058, "Throttling error (ESME exceeded allowed message limits)" },

    { 0x00000059, 0x00000060, "[Reserved]" },

    { 0x00000061, 0x00000061, "Invalid scheduled delivery time" },

    { 0x00000062, 0x00000062, "Invalid message validity period (expiry time)" },

    { 0x00000063, 0x00000063, "Predefined message invalid or not found" },

    { 0x00000064, 0x00000064, "ESME receiver temporary app error code" },

    { 0x00000065, 0x00000065, "ESME receiver permanent app error code" },

    { 0x00000066, 0x00000066, "ESME receiver reject message error code" },

    { 0x00000067, 0x00000067, "query_sm request failed" },

    { 0x00000068, 0x000000BF, "[Reserved]" },

    { 0x000000C0, 0x000000C0, "Error in the optional part of the PDU body" },

    { 0x000000C1, 0x000000C1, "Optional parameter not allowed" },

    { 0x000000C2, 0x000000C2, "Invalid parameter length" },

    { 0x000000C3, 0x000000C3, "Expected optional parameter missing" },

    { 0x000000C4, 0x000000C4, "Invalid optional parameter  value" },

    { 0x000000C5, 0x000000FD, "[Reserved]" },

    { 0x000000FE, 0x000000FE, "(Transaction) Delivery failure (used for data_sm_resp)" },

    { 0x000000FF, 0x000000FF, "Unknown error" },

    /* Introduced in SMPP 5.0 */

    { 0x00000100, 0x00000100, "ESME Not authorised to use specified service_type." },

    { 0x00000101, 0x00000101, "ESME Prohibited from using specified operation."},

    { 0x00000102, 0x00000102, "Specified service_type is unavailable." },

    { 0x00000103, 0x00000103, "Specified service_type is denied." },

    { 0x00000104, 0x00000104, "Invalid Data Coding Scheme." },

    { 0x00000105, 0x00000105, "Source Address Sub unit is Invalid." },

    { 0x00000106, 0x00000106, "Destination Address Sub unit is Invalid." },

    { 0x00000107, 0x00000107, "Broadcast Frequency Interval is invalid." },

    { 0x00000108, 0x00000108, "Broadcast Alias Name is invalid." },

    { 0x00000109, 0x00000109, "Broadcast Area Format is invalid." },

    { 0x0000010A, 0x0000010A, "Number of Broadcast Areas is invalid." },

    { 0x0000010B, 0x0000010B, "Broadcast Content Type is invalid." },

    { 0x0000010C, 0x0000010C, "Broadcast Message Class is invalid." },

    { 0x0000010D, 0x0000010D, "broadcast_sm operation failed." },

    { 0x0000010E, 0x0000010E, "query_broadcast_sm operation failed." },

    { 0x0000010F, 0x0000010F, "cancel_broadcast_sm operation failed." },

    { 0x00000110, 0x00000110, "Number of Repeated Broadcasts is invalid." },

    { 0x00000111, 0x00000111, "Broadcast Service Group is invalid." },

    { 0x00000112, 0x00000112, "Broadcast Channel Indicator is invalid." },

    { 0x00000400, 0x000004FF, "[Vendor-specific Error]" },

    { 0x00000500, 0xFFFFFFFF, "[Reserved]" },

    { 0, 0, NULL }

};

static const value_string vals_tlv_tags[] = {

    { 0x0005, "dest_addr_subunit" },

    { 0x0006, "dest_network_type" },

    { 0x0007, "dest_bearer_type" },

    { 0x0008, "dest_telematics_id" },

    { 0x000D, "source_addr_subunit" },

    { 0x000E, "source_network_type" },

    { 0x000F, "source_bearer_type" },

    { 0x0010, "source_telematics_id" },

    { 0x0017, "qos_time_to_live" },

    { 0x0019, "payload_type" },

    { 0x001D, "additional_status_info_text" },

    { 0x001E, "receipted_message_id" },

    { 0x0030, "ms_msg_wait_facilities" },

    { 0x0201, "privacy_indicator" },

    { 0x0202, "source_subaddress" },

    { 0x0203, "dest_subaddress" },

    { 0x0204, "user_message_reference" },

    { 0x0205, "user_response_code" },

    { 0x020A, "source_port" },

    { 0x020B, "dest_port" },

    { 0x020C, "sar_msg_ref_num" },

    { 0x020D, "language_indicator" },

    { 0x020E, "sar_total_segments" },

    { 0x020F, "sar_segment_seqnum" },

    { 0x0210, "sc_interface_version" },

    { 0x0302, "callback_num_pres_ind" },

    { 0x0303, "callback_num_atag" },

    { 0x0304, "number_of_messages" },

    { 0x0381, "callback_num" },

    { 0x0420, "dpf_result" },

    { 0x0421, "set_dpf" },

    { 0x0422, "ms_availability_status" },

    { 0x0423, "network_error_code" },

    { 0x0424, "message_payload" },

    { 0x0425, "delivery_failure_reason" },

    { 0x0426, "more_messages_to_send" },

    { 0x0427, "message_state" },

    { 0x0428, "congestion_state" },

    { 0x0501, "ussd_service_op" },

    { 0x0600, "broadcast_channel_indicator" },

    { 0x0601, "broadcast_content_type" },

    { 0x0602, "broadcast_content_type_info" },

    { 0x0603, "broadcast_message_class" },

    { 0x0604, "broadcast_rep_num" },

    { 0x0605, "broadcast_frequency_interval" },

    { 0x0606, "broadcast_area_identifier" },

    { 0x0607, "broadcast_error_status" },

    { 0x0608, "broadcast_area_success" },

    { 0x0609, "broadcast_end_time" },

    { 0x060A, "broadcast_service_group" },

    { 0x060B, "billing_identification" },

    { 0x060D, "source_network_id" },

    { 0x060E, "dest_network_id" },

    { 0x060F, "source_node_id" },

    { 0x0610, "dest_node_id" },

    { 0x0611, "dest_addr_np_resolution" },

    { 0x0612, "dest_addr_np_information" },

    { 0x0613, "dest_addr_np_country" },

    { 0x1201, "display_time" },

    { 0x1203, "sms_signal" },

    { 0x1204, "ms_validity" },

    { 0x130C, "alert_on_message_delivery" },

    { 0x1380, "its_reply_type" },

    { 0x1383, "its_session_info" },

    { 0, NULL }

};

static const value_string vals_addr_ton[] = {

    { 0, "Unknown" },

    { 1, "International" },

    { 2, "National" },

    { 3, "Network specific" },

    { 4, "Subscriber number" },

    { 5, "Alphanumeric" },

    { 6, "Abbreviated" },

    { 0, NULL }

};

static const value_string vals_addr_npi[] = {

    {  0, "Unknown" },

    {  1, "ISDN (E163/E164)" },

    {  3, "Data (X.121)" },

    {  4, "Telex (F.69)" },

    {  6, "Land mobile (E.212)" },

    {  8, "National" },

    {  9, "Private" },

    { 10, "ERMES" },

    { 14, "Internet (IP)" },

    { 18, "WAP client Id" },

    {  0, NULL }

};

static const value_string vals_esm_submit_msg_mode[] = {

    {  0x0, "Default SMSC mode" },

    {  0x1, "Datagram mode" },

    {  0x2, "Forward mode" },

    {  0x3, "Store and forward mode" },

    {  0, NULL }

};

static const value_string vals_esm_submit_msg_type[] = {

    {  0x0, "Default message type" },

    {  0x1, "Short message contains SMSC Delivery Receipt" },

    {  0x2, "Short message contains (E)SME delivery acknowledgement" },

    {  0x3, "Reserved" },

    {  0x4, "Short message contains (E)SME manual/user acknowledgement" },

    {  0x5, "Reserved" },

    {  0x6, "Short message contains conversation abort" },

    {  0x7, "Reserved" },

    {  0x8, "Short message contains intermediate delivery notification" },

    {  0, NULL }

};

static const value_string vals_esm_submit_features[] = {

    {  0x0, "No specific features selected" },

    {  0x1, "UDHI indicator" },

    {  0x2, "Reply path" },

    {  0x3, "UDHI and reply path" },

    {  0, NULL }

};

static const value_string vals_priority_flag[] = {

    {  0, "GSM: None      ANSI-136: Bulk         IS-95: Normal" },

    {  1, "GSM: priority  ANSI-136: Normal       IS-95: Interactive" },

    {  2, "GSM: priority  ANSI-136: Urgent       IS-95: Urgent" },

    {  3, "GSM: priority  ANSI-136: Very Urgent  IS-95: Emergency" },

    {  0, NULL }

};

static const value_string vals_regdel_receipt[] = {

    {  0x0, "No SMSC delivery receipt requested" },

    {  0x1, "Delivery receipt requested (for success or failure)" },

    {  0x2, "Delivery receipt requested (for failure)" },

    {  0x3, "Reserved in version <= 3.4; Delivery receipt requested (for success) in 5.0" },

    {  0, NULL }

};

static const value_string vals_regdel_acks[] = {

    {  0x0, "No recipient SME acknowledgement requested" },

    {  0x1, "SME delivery acknowledgement requested" },

    {  0x2, "SME manual/user acknowledgement requested" },

    {  0x3, "Both delivery and manual/user acknowledgement requested" },

    {  0, NULL }

};

static const value_string vals_regdel_notif[] = {

    {  0x0, "No intermediate notification requested" },

    {  0x1, "Intermediate notification requested" },

    {  0, NULL }

};

static const value_string vals_replace_if_present_flag[] = {

    {  0x0, "Don't replace" },

    {  0x1, "Replace" },

    {  0, NULL }

};

static const range_string rvals_data_coding[] = {

    {    0,    0, "SMSC default alphabet" },

    {    1,    1, "IA5 (CCITT T.50)/ASCII (ANSI X3.4)" },

    {    2,    2, "Octet unspecified (8-bit binary)" },

    {    3,    3, "Latin 1 (ISO-8859-1)" },

    {    4,    4, "Octet unspecified (8-bit binary)" },

    {    5,    5, "JIS (X 0208-1990)" },

    {    6,    6, "Cyrillic (ISO-8859-5)" },

    {    7,    7, "Latin/Hebrew (ISO-8859-8)" },

    {    8,    8, "UCS2 (ISO/IEC-10646)" },

    {    9,    9, "Pictogram Encoding" },

    {   10,   10, "ISO-2022-JP (Music codes)" },

    {   11,   12, "Reserved" },

    {   13,   13, "Extended Kanji JIS (X 0212-1990)" },

    {   14,   14, "KS C 5601" },

    {   15, 0xBF, "Reserved" },

    { 0xC0, 0xEF, "GSM MWI control - see [GSM 03.38]" },

    { 0xF0, 0xFF, "GSM message class control - see [GSM 03.38]" },

    {    0,    0, NULL }

};

static const value_string vals_message_state[] = {

    {  1, "ENROUTE" },

    {  2, "DELIVERED" },

    {  3, "EXPIRED" },

    {  4, "DELETED" },

    {  5, "UNDELIVERABLE" },

    {  6, "ACCEPTED" },

    {  7, "UNKNOWN" },

    {  8, "REJECTED" },

    {  0, NULL }

};

static const value_string vals_addr_subunit[] = {

    {  0, "Unknown -default-" },

    {  1, "MS Display" },

    {  2, "Mobile equipment" },

    {  3, "Smart card 1" },

    {  4, "External unit 1" },

    {  0, NULL }

};

static const value_string vals_network_type[] = {

    {  0, "Unknown" },

    {  1, "GSM" },

    {  2, "ANSI-136/TDMA" },

    {  3, "IS-95/CDMA" },

    {  4, "PDC" },

    {  5, "PHS" },

    {  6, "iDEN" },

    {  7, "AMPS" },

    {  8, "Paging network" },

    {  0, NULL }

};

static const value_string vals_bearer_type[] = {

    {  0, "Unknown" },

    {  1, "SMS" },

    {  2, "Circuit Switched Data (CSD)" },

    {  3, "Packet data" },

    {  4, "USSD" },

    {  5, "CDPD" },

    {  6, "DataTAC" },

    {  7, "FLEX/ReFLEX" },

    {  8, "Cell Broadcast" },

    {  0, NULL }

};

static const value_string vals_payload_type[] = {

    {  0, "Default" },

    {  1, "WCMP message" },

    {  0, NULL }

};

static const value_string vals_privacy_indicator[] = {

    {  0, "Not restricted -default-" },

    {  1, "Restricted" },

    {  2, "Confidential" },

    {  3, "Secret" },

    {  0, NULL }

};

static const value_string vals_language_indicator[] = {

    {  0, "Unspecified -default-" },

    {  1, "english" },

    {  2, "french" },

    {  3, "spanish" },

    {  4, "german" },

    {  5, "portuguese" },

    {  0, NULL }

};

static const value_string vals_display_time[] = {

    {  0, "Temporary" },

    {  1, "Default -default-" },

    {  2, "Invoke" },

    {  0, NULL }

};

static const value_string vals_ms_validity[] = {

    {  0, "Store indefinitely -default-" },

    {  1, "Power down" },

    {  2, "SID based registration area" },

    {  3, "Display only" },

    {  0, NULL }

};

static const value_string vals_dpf_result[] = {

    {  0, "DPF not set" },

    {  1, "DPF set" },

    {  0, NULL }

};

static const value_string vals_set_dpf[] = {

    {  0, "Not requested (Set DPF for delivery failure)" },

    {  1, "Requested (Set DPF for delivery failure)" },

    {  0, NULL }

};

static const value_string vals_ms_availability_status[] = {

    {  0, "Available -default-" },

    {  1, "Denied" },

    {  2, "Unavailable" },

    {  0, NULL }

};

static const value_string vals_delivery_failure_reason[] = {

    {  0, "Destination unavailable" },

    {  1, "Destination address invalid" },

    {  2, "Permanent network error" },

    {  3, "Temporary network error" },

    {  0, NULL }

};

static const value_string vals_more_messages_to_send[] = {

    {  0, "No more messages" },

    {  1, "More messages -default-" },

    {  0, NULL }

};

static const value_string vals_its_reply_type[] = {

    {  0, "Digit" },

    {  1, "Number" },

    {  2, "Telephone no." },

    {  3, "Password" },

    {  4, "Character line" },

    {  5, "Menu" },

    {  6, "Date" },

    {  7, "Time" },

    {  8, "Continue" },

    {  0, NULL }

};

static const value_string vals_ussd_service_op[] = {

    {  0, "PSSD indication" },

    {  1, "PSSR indication" },

    {  2, "USSR request" },

    {  3, "USSN request" },

    { 16, "PSSD response" },

    { 17, "PSSR response" },

    { 18, "USSR confirm" },

    { 19, "USSN confirm" },

    {  0, NULL }

};

static const value_string vals_msg_wait_ind[] = {

    {  0, "Set indication inactive" },

    {  1, "Set indication active" },

    {  0, NULL }

};

static const value_string vals_msg_wait_type[] = {

    {  0, "Voicemail message waiting" },

    {  1, "Fax message waiting" },

    {  2, "Electronic mail message waiting" },

    {  3, "Other message waiting" },

    {  0, NULL }

};

static const value_string vals_callback_num_pres[] = {

    {  0, "Presentation allowed" },

    {  1, "Presentation restricted" },

    {  2, "Number not available" },

    {  3, "[Reserved]" },

    {  0, NULL }

};

static const value_string vals_callback_num_scrn[] = {

    {  0, "User provided, not screened" },

    {  1, "User provided, verified and passed" },

    {  2, "User provided, verified and failed" },

    {  3, "Network provided" },

    {  0, NULL }

};

static const value_string vals_network_error_type[] = {

    {  1, "ANSI-136 (Access Denied Reason)" },

    {  2, "IS-95 (Access Denied Reason)" },

    {  3, "GSM" },

    {  4, "[Reserved] in <= 3.4; ANSI 136 Cause Code in 5.0" },

    {  5, "[Reserved] in <= 3.4; IS 95 Cause Code in 5.0" },

    {  6, "[Reserved] in <= 3.4; ANSI-41 Error in 5.0" },

    {  7, "[Reserved] in <= 3.4; SMPP Error in 5.0" },

    {  8, "[Reserved] in <= 3.4; Message Center Specific in 5.0" },

    {  0, NULL }

};

static const value_string vals_its_session_ind[] = {

    {  0, "End of session indicator inactive" },

    {  1, "End of session indicator active" },

    {  0, NULL }

};

/* Data Coding Scheme: see 3GPP TS 23.040 and 3GPP TS 23.038.

 * Note values below 0x0C are not used in SMPP. */

static const value_string vals_dcs_sms_coding_group[] = {

#if 0

    { 0x00, "SMS DCS: General Data Coding indication - Uncompressed text, no message class" },

    { 0x01, "SMS DCS: General Data Coding indication - Uncompressed text" },

    { 0x02, "SMS DCS: General Data Coding indication - Compressed text, no message class" },

    { 0x03, "SMS DCS: General Data Coding indication - Compressed text" },

    { 0x04, "SMS DCS: Message Marked for Automatic Deletion - Uncompressed text, no message class" },

    { 0x05, "SMS DCS: Message Marked for Automatic Deletion - Uncompressed text" },

    { 0x06, "SMS DCS: Message Marked for Automatic Deletion - Compressed text, no message class" },

    { 0x07, "SMS DCS: Message Marked for Automatic Deletion - Compressed text" },

    { 0x08, "SMS DCS: Reserved" },

    { 0x09, "SMS DCS: Reserved" },

    { 0x0A, "SMS DCS: Reserved" },

    { 0x0B, "SMS DCS: Reserved" },

#endif

    { 0x0C, "SMS DCS: Message Waiting Indication - Discard Message" },

    { 0x0D, "SMS DCS: Message Waiting Indication - Store Message (GSM 7-bit default alphabet)" },

    { 0x0E, "SMS DCS: Message Waiting Indication - Store Message (UCS-2 character set)" },

    { 0x0F, "SMS DCS: Data coding / message class" },

    { 0x00, NULL }

};

static const value_string vals_dcs_charset[] = {

    { 0x00, "GSM 7-bit default alphabet" },

    { 0x01, "8-bit data" },

    { 0x00, NULL }

};

static const value_string vals_dcs_class[] = {

    { 0x00, "Class 0" },

    { 0x01, "Class 1 - ME specific" },

    { 0x02, "Class 2 - (U)SIM specific" },

    { 0x03, "Class 3 - TE specific" },

    { 0x00, NULL }

};

static const value_string vals_alert_on_message_delivery[] = {

    { 0x00, "Use mobile default alert (Default)" },

    { 0x01, "Use low-priority alert" },

    { 0x02, "Use medium-priority alert" },

    { 0x03, "Use high-priority alert" },

    { 0x00, NULL }

};

static const range_string vals_congestion_state[] = {

    {0,     0,      "Idle"},

    {1,     29,     "Low Load"},

    {30,    49,     "Medium Load"},

    {50,    79,     "High Load"},

    {80,    89,     "Optimum Load"}, /*Specs says 80-90, but that is probably a mistake */

    {90,    99,     "Nearing Congestion"},

    {100,   100,    "Congested / Maximum Load"},

    { 0,    0,      NULL }

};

static const range_string vals_broadcast_channel_indicator[] = {

    {0,     0,      "Basic Broadcast Channel (Default)"},

    {1,     1,      "Extended Broadcast Channel"},

    {2,     255,    "[Reserved]"},

    { 0,    0,      NULL }

};

static const value_string vals_broadcast_message_class[] = {

    {0, "No Class Specified (default)"},

    {1, "Class 1 (User Defined)"},

    {2, "Class 2 (User Defined)"},

    {3, "Class 3 (Terminal Equipment)"},

    {0, NULL }

};

static const range_string vals_broadcast_area_success[] = {

    {0,     100,    "%"},

    {101,   254,    "[Reserved]"},

    {255,   255,    "Information not available"},

    { 0,    0,      NULL }

};

static const value_string vals_broadcast_content_type_nw[] = {

    {0,     "Generic"},

    {1,     "GSM [23041]"},

    {2,     "TDMA [IS824][ANSI-41]"},

    {3,     "CDMA [IS824][IS637]"},

    {0,     NULL }

};

static const value_string vals_broadcast_content_type_type[] = {

    {0x0000,        "[System Service] Index"},

    {0x0001,        "[System Service] Emergency Broadcasts"},

    {0x0002,        "[System Service] IRDB Download"},

    {0x0010,        "[News Service] News Flashes"},

    {0x0011,        "[News Service] General News (Local)"},

    {0x0012,        "[News Service] General News (Regional)"},

    {0x0013,        "[News Service] General News (National)"},

    {0x0014,        "[News Service] General News (International)"},

    {0x0015,        "[News Service] Business/Financial News (Local)"},

    {0x0016,        "[News Service] Business/Financial News (Regional)"},

    {0x0017,        "[News Service] Business/Financial News (National)"},

    {0x0018,        "[News Service] Business/Financial News (International)"},

    {0x0019,        "[News Service] Sports News (Local)"},

    {0x001A,        "[News Service] Sports News (Regional)"},

    {0x001B,        "[News Service] Sports News (National)"},

    {0x001C,        "[News Service] Sports News (International)"},

    {0x001D,        "[News Service] Entertainment News (Local)"},

    {0x001E,        "[News Service] Entertainment News (Regional)"},

    {0x001F,        "[News Service] Entertainment News (National)"},

    {0x0020,        "[News Service] Entertainment News (International)"},

    {0x0021,        "[Subscriber Information Services] Medical/Health/Hospitals"},

    {0x0022,        "[Subscriber Information Services] Doctors"},

    {0x0023,        "[Subscriber Information Services] Pharmacy"},

    {0x0030,        "[Subscriber Information Services] Local Traffic/Road Reports"},

    {0x0031,        "[Subscriber Information Services] Long Distance Traffic/Road Reports"},

    {0x0032,        "[Subscriber Information Services] Taxis"},

    {0x0033,        "[Subscriber Information Services] Weather"},

    {0x0034,        "[Subscriber Information Services] Local Airport Flight Schedules"},

    {0x0035,        "[Subscriber Information Services] Restaurants"},

    {0x0036,        "[Subscriber Information Services] Lodgings"},

    {0x0037,        "[Subscriber Information Services] Retail Directory"},

    {0x0038,        "[Subscriber Information Services] Advertisements"},

    {0x0039,        "[Subscriber Information Services] Stock Quotes"},

    {0x0040,        "[Subscriber Information Services] Employment Opportunities"},

    {0x0041,        "[Subscriber Information Services] Technology News"},

    {0x0070,        "[Carrier Information Services] District (Base Station Info)"},

    {0x0071,        "[Carrier Information Services] Network Information"},

    {0x0080,        "[Subscriber Care Services] Operator Services"},

    {0x0081,        "[Subscriber Care Services] Directory Enquiries (National)"},

    {0x0082,        "[Subscriber Care Services] Directory Enquiries (International)"},

    {0x0083,        "[Subscriber Care Services] Customer Care (National)"},

    {0x0084,        "[Subscriber Care Services] Customer Care (International)"},

    {0x0085,        "[Subscriber Care Services] Local Date/Time/Time Zone"},

    {0x0100,        "[Multi Category Services] Multi Category Services"},

    {0x0000,        NULL }

};

static const value_string vals_broadcast_frequency_interval_unit[] = {

    {0x00,  "As frequently as possible"},

    {0x08,  "seconds"},

    {0x09,  "minutes"},

    {0x0A,  "hours"},

    {0x0B,  "days"},

    {0x0C,  "weeks"},

    {0x0D,  "months"},

    {0x0E,  "years"},

    {0x00,  NULL }

};

static const value_string vals_dest_addr_np_resolution[] = {

    {0x00,  "query has not been performed (default)"},

    {0x01,  "query has been performed, number not ported"},

    {0x02,  "query has been performed, number ported"},

    {0x00,  NULL }

};

static const range_string vals_broadcast_area_identifier_format[] = {

    {0,   0, "Alias / Name"},

    {1,   1, "Ellipsoid Arc"},

    {2,   2, "Polygon"},

    {3, 255, "[Reserved]"},

    {0, 0,  NULL }

};

/* Huawei SMPP+ extensions */

static const value_string vals_mo_mt_flag[] = {

    { 0x01, "MO" },

    { 0x02, "MT" },

    { 0x03, "Reserved" },

    { 0x00, NULL }

};

static const value_string vals_operation_result[] = {

    { 0x00, "Successful" },

    { 0x01, "Protocol is not supported" },

    { 0x0a, "Others" },

    { 0x0b, "MO account does not exist" },

    { 0x0c, "MT account does not exist" },

    { 0x0d, "MO account state is abnormal" },

    { 0x0e, "MT account state is abnormal" },

    { 0x0f, "MO account balance is not enough" },

    { 0x10, "MT account balance is not enough" },

    { 0x11, "MO VAS is not supported" },

    { 0x12, "MT VAS is not supported" },

    { 0x13, "MO user is post-paid user and checked success" },

    { 0x14, "MT user is post-paid user and checked success" },

    { 0x15, "MO post-paid user status is incorrect" },

    { 0x16, "MT post-paid user status is incorrect" },

    { 0x17, "MO post-paid user account balance is not sufficient" },

    { 0x18, "MT post-paid user account balance is not sufficient" },

    { 0x19, "MO post-paid user value-added services are not supported" },

    { 0x1a, "MT post-paid user value-added services are not supported" },

    { 0x00, NULL }

};

static const value_string vals_notify_mode[] = {

    { 0x01, "Deliver the report when it's successful or failed" },

    { 0x02, "Deliver the report only when it's failed" },

    { 0x03, "Deliver the report only when it's successful" },

    { 0x04, "Never deliver the report" },

    { 0x00, NULL }

};

static const value_string vals_delivery_result[] = {

    { 0x00, "Successful" },

    { 0x01, "Unsuccessful" },

    { 0x00, NULL }

};

static const value_string vals_msc_addr_noa    [] = {

    { 0x00, "Spare" },

    { 0x01, "Subscriber number" },

    { 0x02, "Unknown" },

    { 0x03, "National number" },

    { 0x04, "International" },

    { 0x00, NULL }

};

static const value_string vals_msc_addr_npi    [] = {

    { 0x00, "Spare" },

    { 0x01, "ISDN (Telephony) numbering plan (Recommendation E.164)" },

    { 0x02, "Spare" },

    { 0x03, "Data numbering plan (Recommendation X.121) (national use)" },

    { 0x04, "Telex numbering plan (Recommendation F.69) (national use)" },

    { 0x05, "Reserved for national use" },

    { 0x06, "Reserved for national use" },

    { 0x07, "Spare" },

    { 0x00, NULL }

};

static int * const regdel_fields[] = {

    &hf_smpp_regdel_receipt,

    &hf_smpp_regdel_acks,

    &hf_smpp_regdel_notif,

    NULL

};

static int * const submit_msg_fields[] = {

    &hf_smpp_esm_submit_msg_mode,

    &hf_smpp_esm_submit_msg_type,

    &hf_smpp_esm_submit_features,

    NULL

};

/* Structures for request/response tracking */

typedef struct _smpp_session_t {

        wmem_multimap_t *rr_map;    /* Multimap to track request/response pairs

                                       as sequence numbers _might_ be reused

                                       according to SMPP 5.0 section 2.6.2 */

} smpp_session_t;

/*

 * A data structure to track a SMPP request/response pair.

 * Note: The protocol spec doesn't use the term "transaction", but we are using

 * it here anyway...

 */

typedef struct _smpp_txn_t {

        uint32_t req_frame;       /* Frame number in which request was seen */

        uint32_t res_frame;       /* Frame number in which response was seen */

        nstime_t req_time;        /* Time when request was seen */

        nstime_t res_time;        /* Time when response was seen */

} smpp_txn_t;

/* The same sequence number might be used in either direction in the same

 * session. So, we need to track the sequence numbers by direction.

 */

typedef struct _smpp_txn_key_t {

        address src_addr;

        address dst_addr;

        unsigned sequence_number;

} smpp_txn_key_t;

static dissector_handle_t gsm_sms_handle;

static smpp_data_t *

get_smpp_data(packet_info *pinfo)

{

    smpp_data_t *smpp_data = NULL;

    smpp_data = (smpp_data_t*)p_get_proto_data(pinfo->pool, pinfo, proto_smpp, 0);

    if (!smpp_data) {

        smpp_data = wmem_new0(pinfo->pool, smpp_data_t);

        p_add_proto_data(pinfo->pool, pinfo, proto_smpp, 0, smpp_data);

    }

    return smpp_data;

}

/*

 * For Stats Tree

 */

static void

smpp_stats_tree_init(stats_tree* st)

{

    st_smpp_ops = stats_tree_create_node(st, "SMPP Operations", 0, STAT_DT_INT, true);

    st_smpp_req = stats_tree_create_node(st, "SMPP Requests", st_smpp_ops, STAT_DT_INT, true);

    st_smpp_res = stats_tree_create_node(st, "SMPP Responses", st_smpp_ops, STAT_DT_INT, true);

    st_smpp_res_status = stats_tree_create_node(st, "SMPP Response Status", 0, STAT_DT_INT, true);

}

static tap_packet_status

smpp_stats_tree_per_packet(stats_tree *st, /* st as it was passed to us */

                           packet_info *pinfo,

                           epan_dissect_t *edt _U_,

                           const void *p,

                           tap_flags_t flags _U_) /* Used for getting SMPP command_id values */

{

    const smpp_tap_rec_t* tap_rec = (const smpp_tap_rec_t*)p;

    tick_stat_node(st, "SMPP Operations", 0, true);