Fix various typos and spelling errors.
[obnox/wireshark/wip.git] / 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.",