d0581574818a29f00f8d478058f38a8212922588
[obnox/wireshark/wip.git] / epan / dissectors / packet-mmse.c
1 /* packet-mmse.c
2  * Routines for MMS Message Encapsulation dissection
3  * Copyright 2001, Tom Uijldert <tom.uijldert@cmg.nl>
4  * Copyright 2004, Olivier Biot
5  *
6  * $Id$
7  *
8  * Wireshark - Network traffic analyzer
9  * By Gerald Combs <gerald@wireshark.org>
10  * Copyright 1998 Gerald Combs
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25  * ----------
26  *
27  * Dissector of an encoded Multimedia message PDU, as defined by the WAPForum
28  * (http://www.wapforum.org) in "WAP-209-MMSEncapsulation-20020105-a".
29  * Subsequent releases of MMS are in control of the Open Mobile Alliance (OMA):
30  * Dissection of MMS 1.1 as in OMA-MMS-ENC-v1.1.
31  * Dissection of MMS 1.2 as in OMA-MMS-ENC-v1.2 (not finished yet).
32  */
33
34 /* This file has been edited with 8-space tabs and 4-space indentation */
35
36 #ifdef HAVE_CONFIG_H
37 # include "config.h"
38 #endif
39
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43
44 #include <glib.h>
45
46 #include <epan/packet.h>
47 #include <epan/strutil.h>
48 #include "packet-wap.h"
49 #include "packet-wsp.h"
50 /* #include "packet-mmse.h" */          /* We autoregister      */
51 #include <epan/emem.h>
52
53 #define MM_QUOTE                0x7F    /* Quoted string        */
54
55 #define MMS_CONTENT_TYPE        0x3E    /* WINA-value for mms-message   */
56
57 /* General-purpose debug logger.
58  * Requires double parentheses because of variable arguments of printf().
59  *
60  * Enable debug logging for MMSE by defining AM_CFLAGS
61  * so that it contains "-DDEBUG_mmse"
62  */
63 #ifdef DEBUG_mmse
64 #define DebugLog(x) \
65         g_print("%s:%u: ", __FILE__, __LINE__); \
66         g_print x
67 #else
68 #define DebugLog(x) ;
69 #endif
70
71
72 /*
73  * Forward declarations
74  */
75 static void dissect_mmse_standalone(tvbuff_t *, packet_info *, proto_tree *);
76 static void dissect_mmse_encapsulated(tvbuff_t *, packet_info *, proto_tree *);
77 static void dissect_mmse(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
78         guint8 pdut, const char *message_type);
79
80 /*
81  * Header field values
82  */
83 /* MMS 1.0 */
84 #define MM_BCC_HDR              0x81    /* Bcc                  */
85 #define MM_CC_HDR               0x82    /* Cc                   */
86 #define MM_CLOCATION_HDR        0x83    /* X-Mms-Content-Location       */
87 #define MM_CTYPE_HDR            0x84    /* Content-Type         */
88 #define MM_DATE_HDR             0x85    /* Date                         */
89 #define MM_DREPORT_HDR          0x86    /* X-Mms-Delivery-Report        */
90 #define MM_DTIME_HDR            0x87    /* X-Mms-Delivery-Time          */
91 #define MM_EXPIRY_HDR           0x88    /* X-Mms-Expiry                 */
92 #define MM_FROM_HDR             0x89    /* From                         */
93 #define MM_MCLASS_HDR           0x8A    /* X-Mms-Message-Class          */
94 #define MM_MID_HDR              0x8B    /* Message-ID                   */
95 #define MM_MTYPE_HDR            0x8C    /* X-Mms-Message-Type           */
96 #define MM_VERSION_HDR          0x8D    /* X-Mms-MMS-Version            */
97 #define MM_MSIZE_HDR            0x8E    /* X-Mms-Message-Size           */
98 #define MM_PRIORITY_HDR         0x8F    /* X-Mms-Priority               */
99 #define MM_RREPLY_HDR           0x90    /* X-Mms-Read-Reply             */
100 #define MM_RALLOWED_HDR         0x91    /* X-Mms-Report-Allowed         */
101 #define MM_RSTATUS_HDR          0x92    /* X-Mms-Response-Status        */
102 #define MM_RTEXT_HDR            0x93    /* X-Mms-Response-Text          */
103 #define MM_SVISIBILITY_HDR      0x94    /* X-Mms-Sender-Visibility      */
104 #define MM_STATUS_HDR           0x95    /* X-Mms-Status                 */
105 #define MM_SUBJECT_HDR          0x96    /* Subject                      */
106 #define MM_TO_HDR               0x97    /* To                           */
107 #define MM_TID_HDR              0x98    /* X-Mms-Transaction-Id         */
108 /* MMS 1.1 */
109 #define MM_RETRIEVE_STATUS_HDR  0x99    /* X-Mms-Retrieve-Status        */
110 #define MM_RETRIEVE_TEXT_HDR    0x9A    /* X-Mms-Retrieve-Text          */
111 #define MM_READ_STATUS_HDR      0x9B    /* X-Mms-Read-Status            */
112 #define MM_REPLY_CHARGING_HDR   0x9C    /* X-Mms-Reply-Charging         */
113 #define MM_REPLY_CHARGING_DEADLINE_HDR  \
114                                 0x9D    /* X-Mms-Reply-Charging-Deadline*/
115 #define MM_REPLY_CHARGING_ID_HDR        \
116                                 0x9E    /* X-Mms-Reply-Charging-ID      */
117 #define MM_REPLY_CHARGING_SIZE_HDR      \
118                                 0x9F    /* X-Mms-Reply-Charging-Size    */
119 #define MM_PREV_SENT_BY_HDR     0xA0    /* X-Mms-Previously-Sent-By     */
120 #define MM_PREV_SENT_DATE_HDR   0xA1    /* X-Mms-Previously-Sent-Date   */
121 /* MMS 1.2 */
122 #define MM_STORE_HDR            0xA2    /* X-Mms-Store                  */
123 #define MM_MM_STATE_HDR         0xA3    /* X-Mms-MM-State               */
124 #define MM_MM_FLAGS_HDR         0xA4    /* X-Mms-MM-Flags               */
125 #define MM_STORE_STATUS_HDR     0xA5    /* X-Mms-Store-Status           */
126 #define MM_STORE_STATUS_TEXT_HDR        \
127                                 0xA6    /* X-Mms-Store-Status-Text      */
128 #define MM_STORED_HDR           0xA7    /* X-Mms-Stored                 */
129 #define MM_ATTRIBUTES_HDR       0xA8    /* X-Mms-Attributes             */
130 #define MM_TOTALS_HDR           0xA9    /* X-Mms-Totals                 */
131 #define MM_MBOX_TOTALS_HDR      0xAA    /* X-Mms-Mbox-Totals            */
132 #define MM_QUOTAS_HDR           0xAB    /* X-Mms-Quotas                 */
133 #define MM_MBOX_QUOTAS_HDR      0xAC    /* X-Mms-Mbox-Quotas            */
134 #define MM_MBOX_MSG_COUNT_HDR   0xAD    /* X-Mms-Message-Count          */
135 #define MM_CONTENT_HDR          0xAE    /* Content                      */
136 #define MM_START_HDR            0xAF    /* X-Mms-Start                  */
137 #define MM_ADDITIONAL_HDR       0xB0    /* Additional-headers           */
138 #define MM_DISTRIBUION_IND_HDR  0xB1    /* X-Mms-Distribution-Indcator  */
139 #define MM_ELEMENT_DESCR_HDR    0xB2    /* X-Mms-Element-Descriptor     */
140 #define MM_LIMIT_HDR            0xB3    /* X-Mms-Limit                  */
141
142 static const value_string vals_mm_header_names[] = {
143         /* MMS 1.0 */
144         { MM_BCC_HDR,                   "Bcc" },
145         { MM_CC_HDR,                    "Cc" },
146         { MM_CLOCATION_HDR,             "X-Mms-Content-Location" },
147         { MM_CTYPE_HDR,                 "X-Mms-Content-Type" },
148         { MM_DATE_HDR,                  "Date" },
149         { MM_DREPORT_HDR,               "X-Mms-Delivery-Report" },
150         { MM_DTIME_HDR,                 "X-Mms-Delivery-Time" },
151         { MM_EXPIRY_HDR,                "X-Mms-Expiry" },
152         { MM_FROM_HDR,                  "From" },
153         { MM_MCLASS_HDR,                "X-Mms-Message-Class" },
154         { MM_MID_HDR,                   "Message-ID" },
155         { MM_MTYPE_HDR,                 "X-Mms-Message-Type" },
156         { MM_VERSION_HDR,               "X-Mms-MMS-Version" },
157         { MM_MSIZE_HDR,                 "X-Mms-Message-Size" },
158         { MM_PRIORITY_HDR,              "X-Mms-Priority" },
159         { MM_RREPLY_HDR,                "X-Mms-Read-Reply" },
160         { MM_RALLOWED_HDR,              "X-Mms-Report-Allowed" },
161         { MM_RSTATUS_HDR,               "X-Mms-Response-Status" },
162         { MM_RTEXT_HDR,                 "X-Mms-Response-Text" },
163         { MM_SVISIBILITY_HDR,           "X-Mms-Sender-Visibility" },
164         { MM_STATUS_HDR,                "X-Mms-Status" },
165         { MM_SUBJECT_HDR,               "Subject" },
166         { MM_TO_HDR,                    "To" },
167         { MM_TID_HDR,                   "X-Mms-Transaction-Id" },
168         /* MMS 1.1 */
169         { MM_RETRIEVE_STATUS_HDR,       "X-Mms-Retrieve-Status" },
170         { MM_RETRIEVE_TEXT_HDR,         "X-Mms-Retrieve-Text" },
171         { MM_READ_STATUS_HDR,           "X-Mms-Read-Status" },
172         { MM_REPLY_CHARGING_HDR,        "X-Mms-Reply-Charging" },
173         { MM_REPLY_CHARGING_DEADLINE_HDR,
174                                         "X-Mms-Reply-Charging-Deadline" },
175         { MM_REPLY_CHARGING_ID_HDR,     "X-Mms-Reply-Charging-ID" },
176         { MM_REPLY_CHARGING_SIZE_HDR,   "X-Mms-Reply-Charging-Size" },
177         { MM_PREV_SENT_BY_HDR,          "X-Mms-Previously-Sent-By" },
178         { MM_PREV_SENT_DATE_HDR,        "X-Mms-Previously-Sent-Date" },
179         /* MMS 1.2 */
180         { MM_STORE_HDR,                 "X-Mms-Store" },
181         { MM_MM_STATE_HDR,              "X-Mms-MM-State " },
182         { MM_MM_FLAGS_HDR,              "X-Mms-MM-Flags " },
183         { MM_STORE_STATUS_HDR,          "X-Mms-Store-Status" },
184         { MM_STORE_STATUS_TEXT_HDR,     "X-Mms-Store-Status-Text" },
185         { MM_STORED_HDR,                "X-Mms-Stored" },
186         { MM_ATTRIBUTES_HDR,            "X-Mms-Attributes" },
187         { MM_TOTALS_HDR,                "X-Mms-Totals" },
188         { MM_MBOX_TOTALS_HDR,           "X-Mms-Mbox-Totals" },
189         { MM_QUOTAS_HDR,                "X-Mms-Quotas" },
190         { MM_MBOX_QUOTAS_HDR,           "X-Mms-Mbox-Quotas" },
191         { MM_MBOX_MSG_COUNT_HDR,        "X-Mms-Message-Count" },
192         { MM_CONTENT_HDR,               "Content" },
193         { MM_START_HDR,                 "X-Mms-Start" },
194         { MM_ADDITIONAL_HDR,            "Additional-headers" },
195         { MM_DISTRIBUION_IND_HDR,       "X-Mms-Distribution-Indcator" },
196         { MM_ELEMENT_DESCR_HDR,         "X-Mms-Element-Descriptor" },
197         { MM_LIMIT_HDR,                 "X-Mms-Limit" },
198
199         { 0x00, NULL },
200 };
201 /*
202  * Initialize the protocol and registered fields
203  */
204 static int proto_mmse = -1;
205
206 static int hf_mmse_message_type         = -1;
207 static int hf_mmse_transaction_id       = -1;
208 static int hf_mmse_mms_version          = -1;
209 static int hf_mmse_bcc                  = -1;
210 static int hf_mmse_cc                   = -1;
211 static int hf_mmse_content_location     = -1;
212 static int hf_mmse_date                 = -1;
213 static int hf_mmse_delivery_report      = -1;
214 static int hf_mmse_delivery_time_abs    = -1;
215 static int hf_mmse_delivery_time_rel    = -1;
216 static int hf_mmse_expiry_abs           = -1;
217 static int hf_mmse_expiry_rel           = -1;
218 static int hf_mmse_from                 = -1;
219 static int hf_mmse_message_class_id     = -1;
220 static int hf_mmse_message_class_str    = -1;
221 static int hf_mmse_message_id           = -1;
222 static int hf_mmse_message_size         = -1;
223 static int hf_mmse_priority             = -1;
224 static int hf_mmse_read_reply           = -1;
225 static int hf_mmse_report_allowed       = -1;
226 static int hf_mmse_response_status      = -1;
227 static int hf_mmse_response_text        = -1;
228 static int hf_mmse_sender_visibility    = -1;
229 static int hf_mmse_status               = -1;
230 static int hf_mmse_subject              = -1;
231 static int hf_mmse_to                   = -1;
232 static int hf_mmse_content_type         = -1;
233 static int hf_mmse_ffheader             = -1;
234 /* MMSE 1.1 */
235 static int hf_mmse_read_report          = -1;
236 static int hf_mmse_retrieve_status      = -1;
237 static int hf_mmse_retrieve_text        = -1;
238 static int hf_mmse_read_status          = -1;
239 static int hf_mmse_reply_charging       = -1;
240 static int hf_mmse_reply_charging_deadline      = -1;
241 static int hf_mmse_reply_charging_id    = -1;
242 static int hf_mmse_reply_charging_size  = -1;
243 static int hf_mmse_prev_sent_by = -1;
244 static int hf_mmse_prev_sent_by_fwd_count       = -1;
245 static int hf_mmse_prev_sent_by_address = -1;
246 static int hf_mmse_prev_sent_date       = -1;
247 static int hf_mmse_prev_sent_date_fwd_count     = -1;
248 static int hf_mmse_prev_sent_date_date  = -1;
249
250 /*
251  * Initialize the subtree pointers
252  */
253 static gint ett_mmse                    = -1;
254 static gint ett_mmse_hdr_details        = -1;
255
256 /*
257  * Valuestrings for PDU types
258  */
259 /* MMS 1.0 */
260 #define PDU_M_SEND_REQ          0x80
261 #define PDU_M_SEND_CONF         0x81
262 #define PDU_M_NOTIFICATION_IND  0x82
263 #define PDU_M_NOTIFYRESP_IND    0x83
264 #define PDU_M_RETRIEVE_CONF     0x84
265 #define PDU_M_ACKNOWLEDGE_IND   0x85
266 #define PDU_M_DELIVERY_IND      0x86
267 /* MMS 1.1 */
268 #define PDU_M_READ_REC_IND      0x87
269 #define PDU_M_READ_ORIG_IND     0x88
270 #define PDU_M_FORWARD_REQ       0x89
271 #define PDU_M_FORWARD_CONF      0x8A
272 /* MMS 1.2 */
273 #define PDU_M_MBOX_STORE_REQ    0x8B
274 #define PDU_M_MBOX_STORE_CONF   0x8C
275 #define PDU_M_MBOX_VIEW_REQ     0x8D
276 #define PDU_M_MBOX_VIEW_CONF    0x8E
277 #define PDU_M_MBOX_UPLOAD_REQ   0x8F
278 #define PDU_M_MBOX_UPLOAD_CONF  0x90
279 #define PDU_M_MBOX_DELETE_REQ   0x91
280 #define PDU_M_MBOX_DELETE_CONF  0x92
281 #define PDU_M_MBOX_DESCR        0x93
282
283 #define pdu_has_content(pdut) \
284         (  ((pdut) == PDU_M_SEND_REQ) \
285         || ((pdut) == PDU_M_DELIVERY_IND) \
286         || ((pdut) == PDU_M_RETRIEVE_CONF) \
287         || ((pdut) == PDU_M_MBOX_VIEW_CONF) \
288         || ((pdut) == PDU_M_MBOX_DESCR) \
289         || ((pdut) == PDU_M_MBOX_UPLOAD_REQ) \
290         )
291
292 static const value_string vals_message_type[] = {
293     /* MMS 1.0 */
294     { PDU_M_SEND_REQ,           "m-send-req" },
295     { PDU_M_SEND_CONF,          "m-send-conf" },
296     { PDU_M_NOTIFICATION_IND,   "m-notification-ind" },
297     { PDU_M_NOTIFYRESP_IND,     "m-notifyresp-ind" },
298     { PDU_M_RETRIEVE_CONF,      "m-retrieve-conf" },
299     { PDU_M_ACKNOWLEDGE_IND,    "m-acknowledge-ind" },
300     { PDU_M_DELIVERY_IND,       "m-delivery-ind" },
301     /* MMS 1.1 */
302     { PDU_M_READ_REC_IND,       "m-read-rec-ind" },
303     { PDU_M_READ_ORIG_IND,      "m-read-orig-ind" },
304     { PDU_M_FORWARD_REQ,        "m-forward-req" },
305     { PDU_M_FORWARD_CONF,       "m-forward-conf" },
306     /* MMS 1.2 */
307     { PDU_M_MBOX_STORE_REQ,     "m-mbox-store-req" },
308     { PDU_M_MBOX_STORE_CONF,    "m-mbox-store-conf" },
309     { PDU_M_MBOX_VIEW_REQ,      "m-mbox-view-req" },
310     { PDU_M_MBOX_VIEW_CONF,     "m-mbox-view-conf" },
311     { PDU_M_MBOX_UPLOAD_REQ,    "m-mbox-upload-req" },
312     { PDU_M_MBOX_UPLOAD_CONF,   "m-mbox-upload-conf" },
313     { PDU_M_MBOX_DELETE_REQ,    "m-mbox-delete-req" },
314     { PDU_M_MBOX_DELETE_CONF,   "m-mbox-delete-conf" },
315     { PDU_M_MBOX_DESCR,         "m-mbox-descr" },
316     { 0x00, NULL },
317 };
318
319 static const value_string vals_yes_no[] = {
320     { 0x80, "Yes" },
321     { 0x81, "No" },
322     { 0x00, NULL },
323 };
324
325 static const value_string vals_message_class[] = {
326     { 0x80, "Personal" },
327     { 0x81, "Advertisement" },
328     { 0x82, "Informational" },
329     { 0x83, "Auto" },
330     { 0x00, NULL },
331 };
332
333 static const value_string vals_priority[] = {
334     { 0x80, "Low" },
335     { 0x81, "Normal" },
336     { 0x82, "High" },
337     { 0x00, NULL },
338 };
339
340 static const value_string vals_response_status[] = {
341     /* MMS 1.0 - obsolete as from MMS 1.1 */
342     { 0x80, "Ok" },
343     { 0x81, "Unspecified" },
344     { 0x82, "Service denied" },
345     { 0x83, "Message format corrupt" },
346     { 0x84, "Sending address unresolved" },
347     { 0x85, "Message not found" },
348     { 0x86, "Network problem" },
349     { 0x87, "Content not accepted" },
350     { 0x88, "Unsupported message" },
351
352     /*
353      * Transient errors
354      */
355     /* MMS 1.1 */
356     { 0xC0, "Transient failure" },
357     { 0xC1, "Transient: Sending address unresolved" },
358     { 0xC2, "Transient: Message not found" },
359     { 0xC3, "Transient: Network problem" },
360     /* MMS 1.2 */
361     { 0xC4, "Transient: Partial success" },
362
363     /*
364      * Permanent errors
365      */
366     /* MMS 1.1 */
367     { 0xE0, "Permanent failure" },
368     { 0xE1, "Permanent: Service denied" },
369     { 0xE2, "Permanent: Message format corrupt" },
370     { 0xE3, "Permanent: Sending address unresolved" },
371     { 0xE4, "Permanent: Message not found" },
372     { 0xE5, "Permanent: Content not accepted" },
373     { 0xE6, "Permanent: Reply charging limitations not met" },
374     { 0xE7, "Permanent: Reply charging request not accepted" },
375     { 0xE8, "Permanent: Reply charging forwarding denied" },
376     { 0xE9, "Permanent: Reply charging not supported" },
377     /* MMS 1.2 */
378     { 0xEA, "Permanent: Address hiding not supported" },
379     
380     { 0x00, NULL },
381 };
382
383 static const value_string vals_sender_visibility[] = {
384     { 0x80, "Hide" },
385     { 0x81, "Show" },
386     { 0x00, NULL },
387 };
388
389 static const value_string vals_message_status[] = {
390     /* MMS 1.0 */
391     { 0x80, "Expired" },
392     { 0x81, "Retrieved" },
393     { 0x82, "Rejected" },
394     { 0x83, "Deferred" },
395     { 0x84, "Unrecognized" },
396     /* MMS 1.1 */
397     { 0x85, "Indeterminate" },
398     { 0x86, "Forwarded" },
399     /* MMS 1.2 */
400     { 0x87, "Unreachable" },
401     
402     { 0x00, NULL },
403 };
404
405 static const value_string vals_retrieve_status[] = {
406     /*
407      * Transient errors
408      */
409     /* MMS 1.1 */
410     { 0xC0, "Transient failure" },
411     { 0xC1, "Transient: Message not found" },
412     { 0xC2, "Transient: Network problem" },
413
414     /*
415      * Permanent errors
416      */
417     /* MMS 1.1 */
418     { 0xE0, "Permanent failure" },
419     { 0xE1, "Permanent: Service denied" },
420     { 0xE2, "Permanent: Message not found" },
421     { 0xE3, "Permanent: Content unsupported" },
422
423     { 0x00, NULL },
424 };
425
426 static const value_string vals_read_status[] = {
427     { 0x80, "Read" },
428     { 0x81, "Deleted without being read" },
429
430     { 0x00, NULL },
431 };
432
433 static const value_string vals_reply_charging[] = {
434     { 0x80, "Requested" },
435     { 0x81, "Requested text only" },
436     { 0x82, "Accepted" },
437     { 0x83, "Accepted text only" },
438
439     { 0x00, NULL },
440 };
441
442 static const value_string vals_reply_charging_deadline[] = {
443     { 0x80, "Absolute" },
444     { 0x81, "Relative" },
445
446     { 0x00, NULL },
447 };
448
449 /*!
450  * Decodes a Text-string from the protocol data
451  *      Text-string = [Quote] *TEXT End-of-string
452  *      Quote       = <Octet 127>
453  *      End-of-string = <Octet 0>
454  *
455  * \todo Shouldn't we be sharing this with WSP (packet-wap.c)?
456  *
457  * \param       tvb     The buffer with PDU-data
458  * \param       offset  Offset within that buffer
459  * \param       strval  Pointer to variable into which to put pointer to
460  *                      buffer allocated to hold the text; must be freed
461  *                      when no longer used
462  *
463  * \return              The length in bytes of the entire field
464  */
465 static guint
466 get_text_string(tvbuff_t *tvb, guint offset, char **strval)
467 {
468     guint        len;
469
470     DebugLog(("get_text_string(tvb = %p, offset = %u, **strval) - start\n", 
471                 tvb, offset));
472     len = tvb_strsize(tvb, offset);
473     DebugLog((" [1] tvb_strsize(tvb, offset) == %u\n", len));
474     if (tvb_get_guint8(tvb, offset) == MM_QUOTE)
475         *strval = (char *)tvb_memcpy(tvb, ep_alloc(len-1), offset+1, len-1);
476     else
477         *strval = (char *)tvb_memcpy(tvb, ep_alloc(len), offset, len);
478     DebugLog((" [3] Return(len) == %u\n", len));
479     return len;
480 }
481
482 /*!
483  * Decodes a Value-length from the protocol data.
484  *      Value-length = Short-length | (Length-quote Length)
485  *      Short-length = <Any octet 0-30>
486  *      Length-quote = <Octet 31>
487  *      Length       = Uintvar-integer
488  *
489  * \todo Shouldn't we be sharing this with WSP (packet-wap.c)?
490  *
491  * \param       tvb             The buffer with PDU-data
492  * \param       offset          Offset within that buffer
493  * \param       byte_count      Returns the length in bytes of
494  *                              the "Value-length" field.
495  *
496  * \return                      The actual value of "Value-length"
497  */
498 static guint
499 get_value_length(tvbuff_t *tvb, guint offset, guint *byte_count)
500 {
501     guint        field;
502
503     field = tvb_get_guint8(tvb, offset++);
504     if (field < 31)
505         *byte_count = 1;
506     else {                      /* Must be 31 so, Uintvar follows       */
507         field = tvb_get_guintvar(tvb, offset, byte_count);
508         (*byte_count)++;
509     }
510     return field;
511 }
512
513 /*!
514  * Decodes an Encoded-string-value from the protocol data
515  *      Encoded-string-value = Text-string | Value-length Char-set Text-string
516  *
517  * \param       tvb     The buffer with PDU-data
518  * \param       offset  Offset within that buffer
519  * \param       strval  Pointer to variable into which to put pointer to
520  *                      buffer allocated to hold the text; must be freed
521  *                      when no longer used
522  *
523  * \return              The length in bytes of the entire field
524  */
525 static guint
526 get_encoded_strval(tvbuff_t *tvb, guint offset, char **strval)
527 {
528     guint        field;
529     guint        length;
530     guint        count;
531
532     field = tvb_get_guint8(tvb, offset);
533
534     if (field < 32) {
535         length = get_value_length(tvb, offset, &count);
536         if (length < 2) {
537             *strval = "";
538         } else {
539             /* \todo    Something with "Char-set", skip for now */
540             *strval = (char *)tvb_get_ephemeral_string(tvb, offset + count + 1, length - 1);
541         }
542         return count + length;
543     } else
544         return get_text_string(tvb, offset, strval);
545 }
546
547 /*!
548  * Decodes a Long-integer from the protocol data
549  *      Long-integer = Short-length Multi-octet-integer
550  *      Short-length = <Any octet 0-30>
551  *      Multi-octet-integer = 1*30OCTET
552  *
553  * \todo Shouldn't we be sharing this with WSP (packet-wap.c)?
554  *
555  * \param       tvb             The buffer with PDU-data
556  * \param       offset          Offset within that buffer
557  * \param       byte_count      Returns the length in bytes of the field
558  *
559  * \return                      The value of the Long-integer
560  *
561  * \note        A maximum of 4-byte integers will be handled.
562  */
563 static guint
564 get_long_integer(tvbuff_t *tvb, guint offset, guint *byte_count)
565 {
566     guint        val;
567
568     *byte_count = tvb_get_guint8(tvb, offset++);
569     switch (*byte_count) {
570         case 1:
571             val = tvb_get_guint8(tvb, offset);
572             break;
573         case 2:
574             val = tvb_get_ntohs(tvb, offset);
575             break;
576         case 3:
577             val = tvb_get_ntoh24(tvb, offset);
578             break;
579         case 4:
580             val = tvb_get_ntohl(tvb, offset);
581             break;
582         default:
583             val = 0;
584             break;
585     }
586     (*byte_count)++;
587     return val;
588 }
589
590 /*!
591  * Decodes an Integer-value from the protocol data
592  *      Integer-value = Short-integer | Long-integer
593  *      Short-integer = OCTET
594  *      Long-integer = Short-length Multi-octet-integer
595  *      Short-length = <Any octet 0-30>
596  *      Multi-octet-integer = 1*30OCTET
597  *
598  * \todo Shouldn't we be sharing this with WSP (packet-wap.c)?
599  *
600  * \param       tvb             The buffer with PDU-data
601  * \param       offset          Offset within that buffer
602  * \param       byte_count      Returns the length in bytes of the field
603  *
604  * \return                      The value of the Long-integer
605  *
606  * \note        A maximum of 4-byte integers will be handled.
607  */
608 static guint
609 get_integer_value(tvbuff_t *tvb, guint offset, guint *byte_count)
610 {
611     guint        val;
612     guint8 peek;
613
614     peek = tvb_get_guint8(tvb, offset++);
615     if (peek & 0x80) {
616         val = peek & 0x7F;
617         *byte_count = 1;
618         return val;
619     } else {
620         *byte_count = peek;
621         switch (peek) {
622         case 1:
623             val = tvb_get_guint8(tvb, offset);
624             break;
625         case 2:
626             val = tvb_get_ntohs(tvb, offset);
627             break;
628         case 3:
629             val = tvb_get_ntoh24(tvb, offset);
630             break;
631         case 4:
632             val = tvb_get_ntohl(tvb, offset);
633             break;
634         default:
635             val = 0;
636             break;
637         }
638     }
639     (*byte_count)++;
640     return val;
641 }
642
643 /* Code to actually dissect the packets */
644 static gboolean
645 dissect_mmse_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
646 {
647     guint8       pdut;
648
649         DebugLog(("dissect_mmse_heur()\n"));
650     /*
651      * Check if data makes sense for it to be dissected as MMSE:  Message-type
652      * field must make sense and followed by either Transaction-Id
653      * or MMS-Version header
654      */
655     if (tvb_get_guint8(tvb, 0) != MM_MTYPE_HDR)
656         return FALSE;
657     pdut = tvb_get_guint8(tvb, 1);
658     if (match_strval(pdut, vals_message_type) == NULL)
659         return FALSE;
660     if ((tvb_get_guint8(tvb, 2) != MM_TID_HDR) &&
661         (tvb_get_guint8(tvb, 2) != MM_VERSION_HDR))
662         return FALSE;
663     dissect_mmse_standalone(tvb, pinfo, tree);
664     return TRUE;
665 }
666
667 static void
668 dissect_mmse_standalone(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
669 {
670     guint8       pdut;
671     const char   *message_type;
672
673     DebugLog(("dissect_mmse_standalone() - START (Packet %u)\n",
674                 pinfo->fd->num));
675
676     pdut = tvb_get_guint8(tvb, 1);
677     message_type = val_to_str(pdut, vals_message_type, "Unknown type %u");
678
679     /* Make entries in Protocol column and Info column on summary display */
680     if (check_col(pinfo->cinfo, COL_PROTOCOL))
681         col_set_str(pinfo->cinfo, COL_PROTOCOL, "MMSE");
682
683     if (check_col(pinfo->cinfo, COL_INFO)) {
684         col_clear(pinfo->cinfo, COL_INFO);
685         col_add_fstr(pinfo->cinfo, COL_INFO, "MMS %s", message_type);
686     }
687
688     dissect_mmse(tvb, pinfo, tree, pdut, message_type);
689 }
690
691 static void
692 dissect_mmse_encapsulated(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
693 {
694     guint8       pdut;
695     const char   *message_type;
696
697     DebugLog(("dissect_mmse_encapsulated() - START (Packet %u)\n",
698                 pinfo->fd->num));
699
700     pdut = tvb_get_guint8(tvb, 1);
701     message_type = val_to_str(pdut, vals_message_type, "Unknown type %u");
702
703     /* Make entries in Info column on summary display */
704     if (check_col(pinfo->cinfo, COL_INFO)) {
705         col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "(MMS %s)",
706                 message_type);
707     }
708
709     dissect_mmse(tvb, pinfo, tree, pdut, message_type);
710 }
711
712 static void
713 dissect_mmse(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint8 pdut,
714         const char *message_type)
715 {
716     guint        offset;
717     guint8       field = 0;
718     char         *strval;
719     guint        length;
720     guint        count;
721     guint8       version = 0x80; /* Default to MMSE 1.0 */
722
723     /* Set up structures needed to add the protocol subtree and manage it */
724     proto_item  *ti = NULL;
725     proto_tree  *mmse_tree = NULL;
726
727     DebugLog(("dissect_mmse() - START (Packet %u)\n", pinfo->fd->num));
728
729     /* If tree == NULL then we are only interested in protocol dissection
730      * up to reassembly and handoff to subdissectors if applicable; the
731      * columns must be set appropriately too.
732      * If tree != NULL then we also want to display the protocol tree
733      * with its fields.
734      * 
735      * In the interest of speed, skip protocol tree item generation
736      * if tree is NULL.
737      */
738     if (tree) {
739         DebugLog(("tree != NULL\n"));
740
741         ti = proto_tree_add_item(tree, proto_mmse, tvb, 0, -1, FALSE);
742         proto_item_append_text(ti, ", Type: %s", message_type);
743         /* create display subtree for the protocol */
744         mmse_tree = proto_item_add_subtree(ti, ett_mmse);
745
746         /* Report PDU-type      */
747         proto_tree_add_uint(mmse_tree, hf_mmse_message_type, tvb, 0, 2, pdut);
748     }
749
750     offset = 2;                 /* Skip Message-Type    */
751
752     /*
753      * Cycle through MMS-headers
754      *
755      * NOTE - some PDUs may convey content which can be handed off
756      *        to subdissectors.
757      */
758     if (tree || pdu_has_content(pdut)) {
759         while ((offset < tvb_reported_length(tvb)) &&
760                (field = tvb_get_guint8(tvb, offset++)) != MM_CTYPE_HDR)
761         {
762             DebugLog(("\tField =  0x%02X (offset = %u): %s\n",
763                         field, offset,
764                         val_to_str(field, vals_mm_header_names,
765                             "Unknown MMS header 0x%02X")));
766             switch (field)
767             {
768                 case MM_TID_HDR:                /* Text-string  */
769                     length = get_text_string(tvb, offset, &strval);
770                     if (tree) {
771                         proto_tree_add_string(mmse_tree, hf_mmse_transaction_id,
772                                 tvb, offset - 1, length + 1,strval);
773                     }
774                     offset += length;
775                     break;
776                 case MM_VERSION_HDR:            /* nibble-Major/nibble-minor*/
777                     version = tvb_get_guint8(tvb, offset++);
778                     if (tree) {
779                         guint8   major, minor;
780
781                         major = (version & 0x70) >> 4;
782                         minor = version & 0x0F;
783                         if (minor == 0x0F)
784                             strval = g_strdup_printf("%u", major);
785                         else
786                             strval = g_strdup_printf("%u.%u", major, minor);
787                         proto_tree_add_string(mmse_tree, hf_mmse_mms_version,
788                                 tvb, offset - 2, 2, strval);
789                         g_free(strval);
790                     }
791                     break;
792                 case MM_BCC_HDR:                /* Encoded-string-value */
793                     length = get_encoded_strval(tvb, offset, &strval);
794                     if (tree) {
795                         proto_tree_add_string(mmse_tree, hf_mmse_bcc, tvb,
796                                 offset - 1, length + 1, strval);
797                     }
798                     offset += length;
799                     break;
800                 case MM_CC_HDR:                 /* Encoded-string-value */
801                     length = get_encoded_strval(tvb, offset, &strval);
802                     if (tree) {
803                         proto_tree_add_string(mmse_tree, hf_mmse_cc, tvb,
804                                 offset - 1, length + 1, strval);
805                     }
806                     offset += length;
807                     break;
808                 case MM_CLOCATION_HDR:          /* Uri-value            */
809                     if (pdut == PDU_M_MBOX_DELETE_CONF) {
810                         /* General form with length */
811                         length = tvb_get_guint8(tvb, offset);
812                         if (length == 0x1F) {
813                             guint length_len = 0;
814                             length = tvb_get_guintvar(tvb, offset + 1,
815                                     &length_len);
816                             length += 1 + length_len;
817                         } else {
818                             length += 1;
819                         }
820                         if (tree) {
821                             tvb_ensure_bytes_exist(tvb, offset - 1, length + 1);
822                             proto_tree_add_string(mmse_tree,
823                                     hf_mmse_content_location,
824                                     tvb, offset - 1, length + 1,
825                                     "<Undecoded value for m-mbox-delete-conf>");
826                         }
827                     } else {
828                         length = get_text_string(tvb, offset, &strval);
829                         if (tree) {
830                             proto_tree_add_string(mmse_tree,
831                                     hf_mmse_content_location,
832                                     tvb, offset - 1, length + 1, strval);
833                         }
834                     }
835                     offset += length;
836                     break;
837                 case MM_DATE_HDR:               /* Long-integer         */
838                     {
839                         guint            tval;
840                         nstime_t         tmptime;
841
842                         tval = get_long_integer(tvb, offset, &count);
843                         tmptime.secs = tval;
844                         tmptime.nsecs = 0;
845                         if (tree) {
846                             tvb_ensure_bytes_exist(tvb, offset - 1, count + 1);
847                             proto_tree_add_time(mmse_tree, hf_mmse_date, tvb,
848                                     offset - 1, count + 1, &tmptime);
849                         }
850                     }
851                     offset += count;
852                     break;
853                 case MM_DREPORT_HDR:            /* Yes|No               */
854                     field = tvb_get_guint8(tvb, offset++);
855                     if (tree) {
856                         proto_tree_add_uint(mmse_tree,
857                                 hf_mmse_delivery_report,
858                                 tvb, offset - 2, 2, field);
859                     }
860                     break;
861                 case MM_DTIME_HDR:
862                     /*
863                      * Value-length(Absolute-token Date-value|
864                      *              Relative-token Delta-seconds-value)
865                      */
866                     length = get_value_length(tvb, offset, &count);
867                     field = tvb_get_guint8(tvb, offset + count);
868                     if (tree) {
869                         guint            tval;
870                         nstime_t         tmptime;
871                         guint            cnt;
872
873                         tval =  get_long_integer(tvb, offset + count + 1, &cnt);
874                         tmptime.secs = tval;
875                         tmptime.nsecs = 0;
876
877                         tvb_ensure_bytes_exist(tvb, offset - 1, length + count + 1);
878                         if (field == 0x80)
879                             proto_tree_add_time(mmse_tree,
880                                     hf_mmse_delivery_time_abs,
881                                     tvb, offset - 1,
882                                     length + count + 1, &tmptime);
883                         else
884                             proto_tree_add_time(mmse_tree,
885                                     hf_mmse_delivery_time_rel,
886                                     tvb, offset - 1,
887                                     length + count + 1, &tmptime);
888                     }
889                     offset += length + count;
890                     break;
891                 case MM_EXPIRY_HDR:
892                     /*
893                      * Value-length(Absolute-token Date-value|
894                      *              Relative-token Delta-seconds-value)
895                      */
896                     length = get_value_length(tvb, offset, &count);
897                     field = tvb_get_guint8(tvb, offset + count);
898                     if (tree) {
899                         guint            tval;
900                         nstime_t         tmptime;
901                         guint            cnt;
902
903                         tval = get_long_integer(tvb, offset + count + 1, &cnt);
904                         tmptime.secs = tval;
905                         tmptime.nsecs = 0;
906
907                         tvb_ensure_bytes_exist(tvb, offset - 1, length + count + 1);
908                         if (field == 0x80)
909                             proto_tree_add_time(mmse_tree, hf_mmse_expiry_abs,
910                                     tvb, offset - 1,
911                                     length + count + 1, &tmptime);
912                         else
913                             proto_tree_add_time(mmse_tree, hf_mmse_expiry_rel,
914                                     tvb, offset - 1,
915                                     length + count + 1, &tmptime);
916                     }
917                     offset += length + count;
918                     break;
919                 case MM_FROM_HDR:
920                     /*
921                      * Value-length(Address-present-token Encoded-string-value
922                      *              |Insert-address-token)
923                      */
924                     length = get_value_length(tvb, offset, &count);
925                     if (tree) {
926                         field = tvb_get_guint8(tvb, offset + count);
927                         tvb_ensure_bytes_exist(tvb, offset - 1, length + count + 1);
928                         if (field == 0x81) {
929                             proto_tree_add_string(mmse_tree, hf_mmse_from, tvb,
930                                     offset-1, length + count + 1,
931                                     "<insert address>");
932                         } else {
933                             (void) get_encoded_strval(tvb, offset + count + 1,
934                                                       &strval);
935                             proto_tree_add_string(mmse_tree, hf_mmse_from, tvb,
936                                     offset-1, length + count + 1, strval);
937                         }
938                     }
939                     offset += length + count;
940                     break;
941                 case MM_MCLASS_HDR:
942                     /*
943                      * Class-identifier|Text-string
944                      */
945                     field = tvb_get_guint8(tvb, offset);
946                     if (field & 0x80) {
947                         offset++;
948                         if (tree) {
949                             proto_tree_add_uint(mmse_tree,
950                                     hf_mmse_message_class_id,
951                                     tvb, offset - 2, 2, field);
952                         }
953                     } else {
954                         length = get_text_string(tvb, offset, &strval);
955                         if (tree) {
956                             proto_tree_add_string(mmse_tree,
957                                     hf_mmse_message_class_str,
958                                     tvb, offset - 1, length + 1,
959                                     strval);
960                         }
961                         offset += length;
962                     }
963                     break;
964                 case MM_MID_HDR:                /* Text-string          */
965                     length = get_text_string(tvb, offset, &strval);
966                     if (tree) {
967                         proto_tree_add_string(mmse_tree, hf_mmse_message_id,
968                                 tvb, offset - 1, length + 1, strval);
969                     }
970                     offset += length;
971                     break;
972                 case MM_MSIZE_HDR:              /* Long-integer         */
973                     length = get_long_integer(tvb, offset, &count);
974                     if (tree) {
975                         proto_tree_add_uint(mmse_tree, hf_mmse_message_size,
976                                 tvb, offset - 1, count + 1, length);
977                     }
978                     offset += count;
979                     break;
980                 case MM_PRIORITY_HDR:           /* Low|Normal|High      */
981                     field = tvb_get_guint8(tvb, offset++);
982                     if (tree) {
983                         proto_tree_add_uint(mmse_tree, hf_mmse_priority, tvb,
984                                 offset - 2, 2, field);
985                     }
986                     break;
987                 case MM_RREPLY_HDR:             /* Yes|No               */
988                     field = tvb_get_guint8(tvb, offset++);
989                     if (tree) {
990                         if (version == 0x80) { /* MMSE 1.0 */
991                             proto_tree_add_uint(mmse_tree, hf_mmse_read_reply,
992                                     tvb, offset - 2, 2, field);
993                         } else {
994                             proto_tree_add_uint(mmse_tree, hf_mmse_read_report,
995                                     tvb, offset - 2, 2, field);
996                         }
997                     }
998                     break;
999                 case MM_RALLOWED_HDR:           /* Yes|No               */
1000                     field = tvb_get_guint8(tvb, offset++);
1001                     if (tree) {
1002                         proto_tree_add_uint(mmse_tree, hf_mmse_report_allowed,
1003                                 tvb, offset - 2, 2, field);
1004                     }
1005                     break;
1006                 case MM_RSTATUS_HDR:
1007                     field = tvb_get_guint8(tvb, offset++);
1008                     if (tree) {
1009                         proto_tree_add_uint(mmse_tree, hf_mmse_response_status,
1010                                 tvb, offset - 2, 2, field);
1011                     }
1012                     break;
1013                 case MM_RTEXT_HDR:              /* Encoded-string-value */
1014                     if (pdut == PDU_M_MBOX_DELETE_CONF) {
1015                         /* General form with length */
1016                         length = tvb_get_guint8(tvb, offset);
1017                         if (length == 0x1F) {
1018                             guint length_len = 0;
1019                             length = tvb_get_guintvar(tvb, offset + 1,
1020                                     &length_len);
1021                             length += 1 + length_len;
1022                         } else {
1023                             length += 1;
1024                         }
1025                         if (tree) {
1026                             proto_tree_add_string(mmse_tree,
1027                                     hf_mmse_content_location,
1028                                     tvb, offset - 1, length + 1,
1029                                     "<Undecoded value for m-mbox-delete-conf>");
1030                         }
1031                     } else {
1032                         length = get_encoded_strval(tvb, offset, &strval);
1033                         if (tree) {
1034                             proto_tree_add_string(mmse_tree,
1035                                     hf_mmse_response_text, tvb, offset - 1,
1036                                     length + 1, strval);
1037                         }
1038                     }
1039                     offset += length;
1040                     break;
1041                 case MM_SVISIBILITY_HDR:        /* Hide|Show            */
1042                     field = tvb_get_guint8(tvb, offset++);
1043                     if (tree) {
1044                         proto_tree_add_uint(mmse_tree,hf_mmse_sender_visibility,
1045                                 tvb, offset - 2, 2, field);
1046                     }
1047                     break;
1048                 case MM_STATUS_HDR:
1049                     field = tvb_get_guint8(tvb, offset++);
1050                     if (tree) {
1051                         proto_tree_add_uint(mmse_tree, hf_mmse_status, tvb,
1052                                 offset - 2, 2, field);
1053                     }
1054                     break;
1055                 case MM_SUBJECT_HDR:            /* Encoded-string-value */
1056                     length = get_encoded_strval(tvb, offset, &strval);
1057                     if (tree) {
1058                         proto_tree_add_string(mmse_tree, hf_mmse_subject, tvb,
1059                                 offset - 1, length + 1, strval);
1060                     }
1061                     offset += length;
1062                     break;
1063                 case MM_TO_HDR:                 /* Encoded-string-value */
1064                     length = get_encoded_strval(tvb, offset, &strval);
1065                     if (tree) {
1066                         proto_tree_add_string(mmse_tree, hf_mmse_to, tvb,
1067                                 offset - 1, length + 1, strval);
1068                     }
1069                     offset += length;
1070                     break;
1071
1072                 /*
1073                  * MMS Encapsulation 1.1
1074                  */
1075                 case MM_RETRIEVE_STATUS_HDR:    /* Well-known-value */
1076                     field = tvb_get_guint8(tvb, offset++);
1077                     if (tree) {
1078                         proto_tree_add_uint(mmse_tree, hf_mmse_retrieve_status,
1079                                 tvb, offset - 2, 2, field);
1080                     }
1081                     break;
1082                 case MM_RETRIEVE_TEXT_HDR:
1083                     if (pdut == PDU_M_MBOX_DELETE_CONF) {
1084                         /* General form with length */
1085                         length = tvb_get_guint8(tvb, offset);
1086                         if (length == 0x1F) {
1087                             guint length_len = 0;
1088                             length = tvb_get_guintvar(tvb, offset + 1,
1089                                     &length_len);
1090                             length += 1 + length_len;
1091                         } else {
1092                             length += 1;
1093                         }
1094                         if (tree) {
1095                             proto_tree_add_string(mmse_tree,
1096                                     hf_mmse_content_location,
1097                                     tvb, offset - 1, length + 1,
1098                                     "<Undecoded value for m-mbox-delete-conf>");
1099                         }
1100                     } else {
1101                         /* Encoded-string-value */
1102                         length = get_encoded_strval(tvb, offset, &strval);
1103                         if (tree) {
1104                             proto_tree_add_string(mmse_tree,
1105                                     hf_mmse_retrieve_text, tvb, offset - 1,
1106                                     length + 1, strval);
1107                         }
1108                     }
1109                     offset += length;
1110                     break;
1111                 case MM_READ_STATUS_HDR:        /* Well-known-value */
1112                     field = tvb_get_guint8(tvb, offset++);
1113                     if (tree) {
1114                         proto_tree_add_uint(mmse_tree, hf_mmse_read_status,
1115                                 tvb, offset - 2, 2, field);
1116                     }
1117                     break;
1118                 case MM_REPLY_CHARGING_HDR:     /* Well-known-value */
1119                     field = tvb_get_guint8(tvb, offset++);
1120                     if (tree) {
1121                         proto_tree_add_uint(mmse_tree, hf_mmse_reply_charging,
1122                                 tvb, offset - 2, 2, field);
1123                     }
1124                     break;
1125                 case MM_REPLY_CHARGING_DEADLINE_HDR:    /* Well-known-value */
1126                     field = tvb_get_guint8(tvb, offset++);
1127                     if (tree) {
1128                         proto_tree_add_uint(mmse_tree,
1129                                 hf_mmse_reply_charging_deadline,
1130                                 tvb, offset - 2, 2, field);
1131                     }
1132                     break;
1133                 case MM_REPLY_CHARGING_ID_HDR:  /* Text-string */
1134                     length = get_text_string(tvb, offset, &strval);
1135                     if (tree) {
1136                         proto_tree_add_string(mmse_tree,
1137                                 hf_mmse_reply_charging_id,
1138                                 tvb, offset - 1, length + 1, strval);
1139                     }
1140                     offset += length;
1141                     break;
1142                 case MM_REPLY_CHARGING_SIZE_HDR:        /* Long-integer */
1143                     length = get_long_integer(tvb, offset, &count);
1144                     if (tree) {
1145                         proto_tree_add_uint(mmse_tree,
1146                                 hf_mmse_reply_charging_size,
1147                                 tvb, offset - 1, count + 1, length);
1148                     }
1149                     offset += count;
1150                     break;
1151                 case MM_PREV_SENT_BY_HDR:
1152                     /* Value-length Integer-value Encoded-string-value */
1153                     length = get_value_length(tvb, offset, &count);
1154                     if (tree) {
1155                         guint32 fwd_count, count1, count2;                      
1156                         proto_tree *subtree = NULL;
1157                         proto_item *ti = NULL;
1158                         /* 1. Forwarded-count-value := Integer-value */
1159                         fwd_count = get_integer_value(tvb, offset + count,
1160                             &count1);
1161                         /* 2. Encoded-string-value */
1162                         count2 = get_encoded_strval(tvb,
1163                                 offset + count + count1, &strval);
1164                         /* Now render the fields */
1165                         ti = proto_tree_add_string_format(mmse_tree,
1166                                 hf_mmse_prev_sent_by,
1167                                 tvb, offset - 1, 1 + count + length,
1168                                 strval, "%s (Forwarded-count=%u)",
1169                                 format_text(strval, strlen(strval)),
1170                                 fwd_count);
1171                         subtree = proto_item_add_subtree(ti,
1172                                 ett_mmse_hdr_details);
1173                         proto_tree_add_uint(subtree,
1174                                 hf_mmse_prev_sent_by_fwd_count,
1175                                 tvb, offset + count, count1, fwd_count);
1176                         proto_tree_add_string(subtree,
1177                                 hf_mmse_prev_sent_by_address,
1178                                 tvb, offset + count + count1, count2, strval);
1179                     }
1180                     offset += length + count;
1181                     break;
1182                 case MM_PREV_SENT_DATE_HDR:
1183                     /* Value-Length Forwarded-count-value Date-value */
1184                     length = get_value_length(tvb, offset, &count);
1185                     if (tree) {
1186                         guint32 fwd_count, count1, count2;                      
1187                         guint            tval;
1188                         nstime_t         tmptime;
1189                         proto_tree *subtree = NULL;
1190                         proto_item *ti = NULL;
1191                         /* 1. Forwarded-count-value := Integer-value */
1192                         fwd_count = get_integer_value(tvb, offset + count,
1193                             &count1);
1194                         /* 2. Date-value := Long-integer */
1195                         tval = get_long_integer(tvb, offset + count + count1,
1196                                 &count2);
1197                         tmptime.secs = tval;
1198                         tmptime.nsecs = 0;
1199                         strval = abs_time_to_str(&tmptime);
1200                         /* Now render the fields */
1201                         tvb_ensure_bytes_exist(tvb, offset - 1, length + count + 1);
1202                         ti = proto_tree_add_string_format(mmse_tree,
1203                                 hf_mmse_prev_sent_date,
1204                                 tvb, offset - 1, 1 + count + length,
1205                                 strval, "%s (Forwarded-count=%u)",
1206                                 format_text(strval, strlen(strval)),
1207                                 fwd_count);
1208                         subtree = proto_item_add_subtree(ti,
1209                                 ett_mmse_hdr_details);
1210                         proto_tree_add_uint(subtree,
1211                                 hf_mmse_prev_sent_date_fwd_count,
1212                                 tvb, offset + count, count1, fwd_count);
1213                         proto_tree_add_string(subtree,
1214                                 hf_mmse_prev_sent_date_date,
1215                                 tvb, offset + count + count1, count2, strval);
1216                     }
1217                     offset += length + count;
1218                     break;
1219
1220                 /* MMS Encapsulation 1.2 */
1221
1222                 default:
1223                     if (field & 0x80) { /* Well-known WSP header encoding */
1224                         guint8 peek = tvb_get_guint8(tvb, offset);
1225                         const char *hdr_name = val_to_str(field, vals_mm_header_names,
1226                                 "Unknown field (0x%02x)");
1227                         DebugLog(("\t\tUndecoded well-known header: %s\n",
1228                                     hdr_name));
1229
1230                         if (peek & 0x80) { /* Well-known value */
1231                             length = 1;
1232                             if (tree) {
1233                                 proto_tree_add_text(mmse_tree, tvb, offset - 1,
1234                                         length + 1,
1235                                         "%s: <Well-known value 0x%02x>"
1236                                         " (not decoded)",
1237                                         hdr_name, peek);
1238                             }
1239                         } else if ((peek == 0) || (peek >= 0x20)) { /* Text */
1240                             length = get_text_string(tvb, offset, &strval);
1241                             if (tree) {
1242                                 proto_tree_add_text(mmse_tree, tvb, offset - 1,
1243                                         length + 1, "%s: %s (Not decoded)",
1244                                         hdr_name,
1245                                         format_text(strval, strlen(strval)));
1246                             }
1247                         } else { /* General form with length */
1248                             if (peek == 0x1F) { /* Value length in guintvar */
1249                                 guint length_len = 0;
1250                                 length = 1 + tvb_get_guintvar(tvb, offset + 1,
1251                                         &length_len);
1252                                 length += length_len;
1253                             } else { /* Value length in octet */
1254                                 length = 1 + tvb_get_guint8(tvb, offset);
1255                             }
1256                             if (tree) {
1257                                 proto_tree_add_text(mmse_tree, tvb, offset - 1,
1258                                         length + 1, "%s: "
1259                                         "<Value in general form> (not decoded)",
1260                                         hdr_name);
1261                             }
1262                         }
1263                         offset += length;
1264                     } else { /* Literal WSP header encoding */
1265                         guint    length2;
1266                         char     *strval2;
1267
1268                         --offset;
1269                         length = get_text_string(tvb, offset, &strval);
1270                         DebugLog(("\t\tUndecoded literal header: %s\n",
1271                                     strval));
1272                         length2= get_text_string(tvb, offset+length, &strval2);
1273
1274                         if (tree) {
1275                             proto_tree_add_string_format(mmse_tree,
1276                                     hf_mmse_ffheader, tvb, offset,
1277                                     length + length2,
1278                                     (const char *) tvb_get_ptr(
1279                                             tvb, offset, length + length2),
1280                                     "%s: %s",
1281                                     format_text(strval, strlen(strval)),
1282                                     format_text(strval2, strlen(strval2)));
1283                         }
1284                         offset += length + length2;
1285                     }
1286                     break;
1287             }
1288             DebugLog(("\tEnd(case)\n"));
1289         }
1290         DebugLog(("\tEnd(switch)\n"));
1291         if (field == MM_CTYPE_HDR) {
1292             /*
1293              * Eeehh, we're now actually back to good old WSP content-type
1294              * encoding. Let's steal that from the WSP-dissector.
1295              */
1296             tvbuff_t    *tmp_tvb;
1297             guint        type;
1298             const char  *type_str;
1299
1300             DebugLog(("Content-Type: [from WSP dissector]\n"));
1301             DebugLog(("Calling add_content_type() in WSP dissector\n"));
1302             offset = add_content_type(mmse_tree, tvb, offset, &type, &type_str);
1303             DebugLog(("Generating new TVB subset (offset = %u)\n", offset));
1304             tmp_tvb = tvb_new_subset(tvb, offset, -1, -1);
1305             DebugLog(("Add POST data\n"));
1306             add_post_data(mmse_tree, tmp_tvb, type, type_str, pinfo);
1307             DebugLog(("Done!\n"));
1308         }
1309     } else {
1310         DebugLog(("tree == NULL and PDU has no potential content\n"));
1311     }
1312
1313     /* If this protocol has a sub-dissector call it here, see section 1.8 */
1314     DebugLog(("dissect_mmse() - END\n"));
1315 }
1316
1317
1318 /* Register the protocol with Wireshark */
1319
1320 /* this format is required because a script is used to build the C function
1321  * that calls all the protocol registration.
1322  */
1323 void
1324 proto_register_mmse(void)
1325 {
1326     /* Setup list of header fields  See Section 1.6.1 for details       */
1327     static hf_register_info hf[] = {
1328         {   &hf_mmse_message_type,
1329             {   "X-Mms-Message-Type", "mmse.message_type",
1330                 FT_UINT8, BASE_HEX, VALS(vals_message_type), 0x00,
1331                 "Specifies the transaction type. Effectively defines PDU.",
1332                 HFILL
1333             }
1334         },
1335         {   &hf_mmse_transaction_id,
1336             {   "X-Mms-Transaction-ID", "mmse.transaction_id",
1337                 FT_STRING, BASE_NONE, NULL, 0x00,
1338                 "A unique identifier for this transaction. "
1339                 "Identifies request and corresponding response only.",
1340                 HFILL
1341             }
1342         },
1343         {   &hf_mmse_mms_version,
1344             {   "X-Mms-MMS-Version", "mmse.mms_version",
1345                 FT_STRING, BASE_NONE, NULL, 0x00,
1346                 "Version of the protocol used.",
1347                 HFILL
1348             }
1349         },
1350         {   &hf_mmse_bcc,
1351             {   "Bcc", "mmse.bcc",
1352                 FT_STRING, BASE_NONE, NULL, 0x00,
1353                 "Blind carbon copy.",
1354                 HFILL
1355             }
1356         },
1357         {   &hf_mmse_cc,
1358             {   "Cc", "mmse.cc",
1359                 FT_STRING, BASE_NONE, NULL, 0x00,
1360                 "Carbon copy.",
1361                 HFILL
1362             }
1363         },
1364         {   &hf_mmse_content_location,
1365             {   "X-Mms-Content-Location", "mmse.content_location",
1366                 FT_STRING, BASE_NONE, NULL, 0x00,
1367                 "Defines the location of the message.",
1368                 HFILL
1369             }
1370         },
1371         {   &hf_mmse_date,
1372             {   "Date", "mmse.date",
1373                 FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00,
1374                 "Arrival timestamp of the message or sending timestamp.",
1375                 HFILL
1376             }
1377         },
1378         {   &hf_mmse_delivery_report,
1379             {   "X-Mms-Delivery-Report", "mmse.delivery_report",
1380                 FT_UINT8, BASE_HEX, VALS(vals_yes_no), 0x00,
1381                 "Whether a report of message delivery is wanted or not.",
1382                 HFILL
1383             }
1384         },
1385         {   &hf_mmse_delivery_time_abs,
1386             {   "X-Mms-Delivery-Time", "mmse.delivery_time.abs",
1387                 FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00,
1388                 "The time at which message delivery is desired.",
1389                 HFILL
1390             }
1391         },
1392         {   &hf_mmse_delivery_time_rel,
1393             {   "X-Mms-Delivery-Time", "mmse.delivery_time.rel",
1394                 FT_RELATIVE_TIME, BASE_NONE, NULL, 0x00,
1395                 "The desired message delivery delay.",
1396                 HFILL
1397             }
1398         },
1399         {   &hf_mmse_expiry_abs,
1400             {   "X-Mms-Expiry", "mmse.expiry.abs",
1401                 FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00,
1402                 "Time when message expires and need not be delivered anymore.",
1403                 HFILL
1404             }
1405         },
1406         {   &hf_mmse_expiry_rel,
1407             {   "X-Mms-Expiry", "mmse.expiry.rel",
1408                 FT_RELATIVE_TIME, BASE_NONE, NULL, 0x00,
1409                 "Delay before message expires and need not be delivered anymore.",
1410                 HFILL
1411             }
1412         },
1413         {   &hf_mmse_from,
1414             {   "From", "mmse.from",
1415                 FT_STRING, BASE_NONE, NULL, 0x00,
1416                 "Address of the message sender.",
1417                 HFILL
1418             }
1419         },
1420         {   &hf_mmse_message_class_id,
1421             {   "X-Mms-Message-Class", "mmse.message_class.id",
1422                 FT_UINT8, BASE_HEX, VALS(vals_message_class), 0x00,
1423                 "Of what category is the message.",
1424                 HFILL
1425             }
1426         },
1427         {   &hf_mmse_message_class_str,
1428             {   "X-Mms-Message-Class", "mmse.message_class.str",
1429                 FT_STRING, BASE_NONE, NULL, 0x00,
1430                 "Of what category is the message.",
1431                 HFILL
1432             }
1433         },
1434         {   &hf_mmse_message_id,
1435             {   "Message-Id", "mmse.message_id",
1436                 FT_STRING, BASE_NONE, NULL, 0x00,
1437                 "Unique identification of the message.",
1438                 HFILL
1439             }
1440         },
1441         {   &hf_mmse_message_size,
1442             {   "X-Mms-Message-Size", "mmse.message_size",
1443                 FT_UINT32, BASE_DEC, NULL, 0x00,
1444                 "The size of the message in octets.",
1445                 HFILL
1446             }
1447         },
1448         {   &hf_mmse_priority,
1449             {   "X-Mms-Priority", "mmse.priority",
1450                 FT_UINT8, BASE_HEX, VALS(vals_priority), 0x00,
1451                 "Priority of the message.",
1452                 HFILL
1453             }
1454         },
1455         {   &hf_mmse_read_reply,
1456             {   "X-Mms-Read-Reply", "mmse.read_reply",
1457                 FT_UINT8, BASE_HEX, VALS(vals_yes_no), 0x00,
1458                 "Whether a read report from every recipient is wanted.",
1459                 HFILL
1460             }
1461         },
1462         {   &hf_mmse_read_report,
1463             {   "X-Mms-Read-Report", "mmse.read_report",
1464                 FT_UINT8, BASE_HEX, VALS(vals_yes_no), 0x00,
1465                 "Whether a read report from every recipient is wanted.",
1466                 HFILL
1467             }
1468         },
1469         {   &hf_mmse_report_allowed,
1470             {   "X-Mms-Report-Allowed", "mmse.report_allowed",
1471                 FT_UINT8, BASE_HEX, VALS(vals_yes_no), 0x00,
1472                 "Sending of delivery report allowed or not.",
1473                 HFILL
1474             }
1475         },
1476         {   &hf_mmse_response_status,
1477             {   "Response-Status", "mmse.response_status",
1478                 FT_UINT8, BASE_HEX, VALS(vals_response_status), 0x00,
1479                 "MMS-specific result of a message submission or retrieval.",
1480                 HFILL
1481             }
1482         },
1483         {   &hf_mmse_response_text,
1484             {   "Response-Text", "mmse.response_text",
1485                 FT_STRING, BASE_NONE, NULL, 0x00,
1486                 "Additional information on MMS-specific result.",
1487                 HFILL
1488             }
1489         },
1490         {   &hf_mmse_sender_visibility,
1491             {   "Sender-Visibility", "mmse.sender_visibility",
1492                 FT_UINT8, BASE_HEX, VALS(vals_sender_visibility), 0x00,
1493                 "Disclose sender identity to receiver or not.",
1494                 HFILL
1495             }
1496         },
1497         {   &hf_mmse_status,
1498             {   "Status", "mmse.status",
1499                 FT_UINT8, BASE_HEX, VALS(vals_message_status), 0x00,
1500                 "Current status of the message.",
1501                 HFILL
1502             }
1503         },
1504         {   &hf_mmse_subject,
1505             {   "Subject", "mmse.subject",
1506                 FT_STRING, BASE_NONE, NULL, 0x00,
1507                 "Subject of the message.",
1508                 HFILL
1509             }
1510         },
1511         {   &hf_mmse_to,
1512             {   "To", "mmse.to",
1513                 FT_STRING, BASE_NONE, NULL, 0x00,
1514                 "Recipient(s) of the message.",
1515                 HFILL
1516             }
1517         },
1518         {   &hf_mmse_content_type,
1519             {   "Data", "mmse.content_type",
1520                 FT_NONE, BASE_NONE, NULL, 0x00,
1521                 "Media content of the message.",
1522                 HFILL
1523             }
1524         },
1525         {   &hf_mmse_ffheader,
1526             {   "Free format (not encoded) header", "mmse.ffheader",
1527                 FT_STRING, BASE_NONE, NULL, 0x00,
1528                 "Application header without corresponding encoding.",
1529                 HFILL
1530             }
1531         },
1532         /* MMSE 1.1 */
1533         {   &hf_mmse_retrieve_status,
1534             {   "X-Mms-Retrieve-Status", "mmse.retrieve_status",
1535                 FT_UINT8, BASE_HEX, VALS(vals_retrieve_status), 0x00,
1536                 "MMS-specific result of a message retrieval.",
1537                 HFILL
1538             }
1539         },
1540         {   &hf_mmse_retrieve_text,
1541             {   "X-Mms-Retrieve-Text", "mmse.retrieve_text",
1542                 FT_STRING, BASE_NONE, NULL, 0x00,
1543                 "Status text of a MMS message retrieval.",
1544                 HFILL
1545             }
1546         },
1547         {   &hf_mmse_read_status,
1548             {   "X-Mms-Read-Status", "mmse.read_status",
1549                 FT_UINT8, BASE_HEX, VALS(vals_read_status), 0x00,
1550                 "MMS-specific message read status.",
1551                 HFILL
1552             }
1553         },
1554         {   &hf_mmse_reply_charging,
1555             {   "X-Mms-Reply-Charging", "mmse.reply_charging",
1556                 FT_UINT8, BASE_HEX, VALS(vals_reply_charging), 0x00,
1557                 "MMS-specific message reply charging method.",
1558                 HFILL
1559             }
1560         },
1561         {   &hf_mmse_reply_charging_deadline,
1562             {   "X-Mms-Reply-Charging-Deadline", "mmse.reply_charging_deadline",
1563                 FT_UINT8, BASE_HEX, VALS(vals_reply_charging_deadline), 0x00,
1564                 "MMS-specific message reply charging deadline type.",
1565                 HFILL
1566             }
1567         },
1568         {   &hf_mmse_reply_charging_id,
1569             {   "X-Mms-Reply-Charging-Id", "mmse.reply_charging_id",
1570                 FT_STRING, BASE_NONE, NULL, 0x00,
1571                 "Unique reply charging identification of the message.",
1572                 HFILL
1573             }
1574         },
1575         {   &hf_mmse_reply_charging_size,
1576             {   "X-Mms-Reply-Charging-Size", "mmse.reply_charging_size",
1577                 FT_UINT32, BASE_DEC, NULL, 0x00,
1578                 "The size of the reply charging in octets.",
1579                 HFILL
1580             }
1581         },
1582         {   &hf_mmse_prev_sent_by,
1583             {   "X-Mms-Previously-Sent-By", "mmse.previously_sent_by",
1584                 FT_STRING, BASE_NONE, NULL, 0x00,
1585                 "Indicates that the MM has been previously sent by this user.",
1586                 HFILL
1587             }
1588         },
1589         {   &hf_mmse_prev_sent_by_fwd_count,
1590             {   "Forward Count", "mmse.previously_sent_by.forward_count",
1591                 FT_UINT32, BASE_DEC, NULL, 0x00,
1592                 "Forward count of the previously sent MM.",
1593                 HFILL
1594             }
1595         },
1596         {   &hf_mmse_prev_sent_by_address,
1597             {   "Address", "mmse.previously_sent_by.address",
1598                 FT_STRING, BASE_NONE, NULL, 0x00,
1599                 "Indicates from whom the MM has been previously sent.",
1600                 HFILL
1601             }
1602         },
1603         {   &hf_mmse_prev_sent_date,
1604             {   "X-Mms-Previously-Sent-Date", "mmse.previously_sent_date",
1605                 FT_STRING, BASE_NONE, NULL, 0x00,
1606                 "Indicates the date that the MM has been previously sent.",
1607                 HFILL
1608             }
1609         },
1610         {   &hf_mmse_prev_sent_date_fwd_count,
1611             {   "Forward Count", "mmse.previously_sent_date.forward_count",
1612                 FT_UINT32, BASE_DEC, NULL, 0x00,
1613                 "Forward count of the previously sent MM.",
1614                 HFILL
1615             }
1616         },
1617         {   &hf_mmse_prev_sent_date_date,
1618             {   "Date", "mmse.previously_sent_date.date",
1619                 FT_STRING, BASE_NONE, NULL, 0x00,
1620                 "Time when the MM has been previously sent.",
1621                 HFILL
1622             }
1623         },
1624
1625
1626
1627     };
1628     /* Setup protocol subtree array */
1629     static gint *ett[] = {
1630         &ett_mmse,
1631         &ett_mmse_hdr_details,
1632     };
1633
1634     /* Register the protocol name and description */
1635     proto_mmse = proto_register_protocol("MMS Message Encapsulation",
1636                                          "MMSE", "mmse");
1637
1638     /* Required function calls to register header fields and subtrees used */
1639     proto_register_field_array(proto_mmse, hf, array_length(hf));
1640     proto_register_subtree_array(ett, array_length(ett));
1641 }
1642
1643 /* If this dissector uses sub-dissector registration add registration routine.
1644  * This format is required because a script is used to find these routines and
1645  * create the code that calls these routines.
1646  */
1647 void
1648 proto_reg_handoff_mmse(void)
1649 {
1650     dissector_handle_t mmse_standalone_handle;
1651     dissector_handle_t mmse_encapsulated_handle;
1652
1653     heur_dissector_add("wsp", dissect_mmse_heur, proto_mmse);
1654     mmse_standalone_handle = create_dissector_handle(
1655             dissect_mmse_standalone, proto_mmse);
1656     mmse_encapsulated_handle = create_dissector_handle(
1657             dissect_mmse_encapsulated, proto_mmse);
1658         /* As the media types for WSP and HTTP are the same, the WSP dissector
1659          * uses the same string dissector table as the HTTP protocol. */
1660     dissector_add_string("media_type",
1661             "application/vnd.wap.mms-message", mmse_standalone_handle);
1662     dissector_add_string("multipart_media_type",
1663             "application/vnd.wap.mms-message", mmse_encapsulated_handle);
1664 }