Remove "text2pcap-scanner.obj" and "tools\lemon\lemon.obj" when a "nmake
[obnox/wireshark/wip.git] / packet-m2pa.c
1 /* packet-m2pa.c
2  * Routines for MTP2 Peer Adaptation Layer dissection
3  * It is hopefully (needs testing) compliant to
4  * http://www.ietf.org/internet-drafts/draft-ietf-sigtran-m2pa-02.txt
5  *
6  * Copyright 2001, Jeff Morriss <jeff.morriss[AT]ulticom.com>
7  *
8  * $Id: packet-m2pa.c,v 1.1 2001/06/21 22:25:51 guy Exp $
9  *
10  * Ethereal - Network traffic analyzer
11  * By Gerald Combs <gerald@ethereal.com>
12  * Copyright 1998 Gerald Combs
13  *
14  * Copied from packet-m3ua.c
15  * 
16  * This program is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU General Public License
18  * as published by the Free Software Foundation; either version 2
19  * of the License, or (at your option) any later version.
20  * 
21  * This program is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  * 
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29  */
30
31 #ifdef HAVE_CONFIG_H
32 # include "config.h"
33 #endif
34
35 #include <stdio.h>
36 #include <stdlib.h>
37
38
39 #ifdef HAVE_SYS_TYPES_H
40 # include <sys/types.h>
41 #endif
42
43 #ifdef HAVE_NETINET_IN_H
44 # include <netinet/in.h>
45 #endif
46
47 #include <string.h>
48 #include <glib.h>
49
50 #ifdef NEED_SNPRINTF_H
51 # include "snprintf.h"
52 #endif
53
54 #include "packet.h"
55 #include "prefs.h"
56
57 /* Warning:  Neither of these are standardized yet! */
58 #define SCTP_PORT_M2PA 2904
59 #define M2PA_PAYLOAD_PROTOCOL_ID   5
60
61 #define VERSION_LENGTH         1
62 #define SPARE_LENGTH           1
63 #define MESSAGE_TYPE_LENGTH    2
64 #define MESSAGE_LENGTH_LENGTH  4
65 #define COMMON_HEADER_LENGTH   (VERSION_LENGTH + SPARE_LENGTH + \
66                                 MESSAGE_TYPE_LENGTH + MESSAGE_LENGTH_LENGTH)
67
68 #define VERSION_OFFSET         0
69 #define SPARE_OFFSET           (VERSION_OFFSET + VERSION_LENGTH)
70 #define MESSAGE_TYPE_OFFSET    (SPARE_OFFSET + SPARE_LENGTH)
71 #define MESSAGE_LENGTH_OFFSET  (MESSAGE_TYPE_OFFSET + MESSAGE_TYPE_LENGTH)
72
73
74 #define PROTOCOL_VERSION_RELEASE_1        1
75 static const value_string m2pa_protocol_version_values[] = {
76   { PROTOCOL_VERSION_RELEASE_1,  "Release 1" },
77   { 0,                           NULL } };
78
79
80 #define MESSAGE_TYPE_USER_DATA            0x0601
81 #define MESSAGE_TYPE_LINK_STATUS          0x0602
82 static const value_string m2pa_message_type_values[] = {
83   { MESSAGE_TYPE_USER_DATA,     "User Data" },
84   { MESSAGE_TYPE_LINK_STATUS,   "Link Status" },
85   { 0,                           NULL } };
86
87
88 /* parts of User Data message */
89 #define LI_OFFSET             0
90 #define LI_LENGTH             1
91 #define USER_OFFSET           (LI_OFFSET + LI_LENGTH)
92
93 /* LI is only used for (ITU national) priority in M2PA */
94 #define LI_SPARE_MASK              0xfc
95 #define LI_PRIORITY_MASK           0x3
96
97
98 /* parts of Link Status message */
99 #define STATUS_LENGTH    4
100 #define STATUS_OFFSET    0
101
102 #define STATUS_IS        1
103 #define STATUS_PO        2
104 #define STATUS_POE       3
105 #define STATUS_BUSY      4
106 #define STATUS_BUSY_E    5
107 static const value_string m2pa_link_status_values[] = {
108   { STATUS_IS,      "In Service" },
109   { STATUS_PO,      "Processor Outage" },
110   { STATUS_POE,     "Processor Outage Ended" },
111   { STATUS_BUSY,    "Busy" },
112   { STATUS_BUSY_E,  "Busy Ended" },
113   { 0,              NULL } };
114
115
116 /* Initialize the protocol and registered fields */
117 static int proto_m2pa = -1;
118 static int hf_m2pa_version = -1;
119 static int hf_m2pa_spare = -1;
120 static int hf_m2pa_message_type = -1;
121 static int hf_m2pa_message_length = -1;
122 static int hf_m2pa_ls_status = -1;
123 static int hf_m2pa_data_li = -1;
124 static int hf_m2pa_data_li_spare = -1;
125 static int hf_m2pa_data_li_prio = -1;
126
127 /* Initialize the subtree pointers */
128 static gint ett_m2pa = -1;
129 static gint ett_m2pa_message_ud = -1;
130 static gint ett_m2pa_message_ud_li = -1;
131 static gint ett_m2pa_message_ls = -1;
132
133 static dissector_handle_t mtp3_handle;
134
135 static void
136 dissect_m2pa_unknown_message(tvbuff_t *message_tvb, packet_info *pinfo,
137                              proto_tree *m2pa_tree, guint32 message_length,
138                              guint16 message_type)
139 {
140
141   if (check_col(pinfo->fd, COL_INFO)) {
142     col_set_str(pinfo->fd, COL_INFO,
143                 val_to_str(message_type, m2pa_message_type_values, "Unknown"));
144   };
145
146   if (m2pa_tree) {
147     proto_tree_add_text(m2pa_tree, message_tvb, 0, message_length,
148                         "Unknown message (%u byte%s)",
149                         message_length, plurality(message_length, "", "s"));
150   };
151
152 }
153
154
155 static void
156 dissect_m2pa_link_status_message(tvbuff_t *message_tvb, packet_info *pinfo,
157                                  proto_tree *m2pa_tree, guint16 message_type)
158 {
159   guint32 status;
160   proto_item *m2pa_ls_item;
161   proto_tree *m2pa_ls_tree;
162
163   status = tvb_get_ntohl (message_tvb, STATUS_OFFSET);
164
165   if (check_col(pinfo->fd, COL_INFO)) {
166     col_set_str(pinfo->fd, COL_INFO,
167                 val_to_str(message_type, m2pa_message_type_values, "unknown"));
168
169     col_append_str(pinfo->fd, COL_INFO, " (");
170     col_append_str(pinfo->fd, COL_INFO,
171                    val_to_str(status, m2pa_link_status_values, "unknown"));
172     col_append_str(pinfo->fd, COL_INFO, ")");
173   };
174
175   if (m2pa_tree) {
176     /* create the link status message tree */
177     m2pa_ls_item = proto_tree_add_text(m2pa_tree, message_tvb, 0,
178                                        STATUS_LENGTH,
179                                        val_to_str(message_type,
180                                                   m2pa_message_type_values,
181                                                   "Unknown"));
182     m2pa_ls_tree = proto_item_add_subtree(m2pa_ls_item, ett_m2pa_message_ls);
183
184     /* add the components of the link status message to the protocol tree */
185     proto_tree_add_uint(m2pa_ls_tree, hf_m2pa_ls_status,
186                                           message_tvb, STATUS_OFFSET,
187                                           STATUS_LENGTH, status);
188   };
189
190 }
191
192
193 static void
194 dissect_m2pa_user_data_message(tvbuff_t *message_tvb, packet_info *pinfo,
195                                proto_item *m2pa_item, proto_tree *m2pa_tree,
196                                guint32 message_length, proto_tree *tree,
197                                guint16 message_type)
198 {
199   proto_item *m2pa_ud_item;
200   proto_tree *m2pa_ud_tree;
201   proto_item *m2pa_ud_li_item;
202   proto_tree *m2pa_ud_li_tree;
203   tvbuff_t *payload_tvb;
204   guint8 li;
205   guint32 payload_length;
206
207   li = tvb_get_guint8(message_tvb, LI_OFFSET);
208   payload_length = message_length - LI_LENGTH;
209
210   if (m2pa_tree) {
211     /* create the user data message tree */
212     m2pa_ud_item = proto_tree_add_item(m2pa_tree, proto_m2pa, message_tvb, 0,
213                                        tvb_length(message_tvb), FALSE);
214     m2pa_ud_tree = proto_item_add_subtree(m2pa_ud_item, ett_m2pa_message_ud);
215
216     /* add the components of the user data message to the protocol tree */
217     /* LI */
218     m2pa_ud_li_item = proto_tree_add_uint(m2pa_ud_tree, hf_m2pa_data_li,
219                                           message_tvb, LI_OFFSET, LI_LENGTH,
220                                           li);
221     m2pa_ud_li_tree = proto_item_add_subtree(m2pa_ud_li_item,
222                                              ett_m2pa_message_ud_li);
223     proto_tree_add_uint(m2pa_ud_li_tree, hf_m2pa_data_li_spare, message_tvb,
224                         LI_OFFSET, LI_LENGTH, li);
225     proto_tree_add_uint(m2pa_ud_li_tree, hf_m2pa_data_li_prio, message_tvb,
226                         LI_OFFSET, LI_LENGTH, li);
227
228     proto_item_set_text(m2pa_ud_item, "Protocol data (SS7 message of %u byte%s)",
229                         payload_length, plurality(payload_length, "", "s"));
230
231     /* Re-adjust length of M2PA item since it will be dissected as MTP3 */
232     proto_item_set_len(m2pa_item, COMMON_HEADER_LENGTH + LI_LENGTH);
233
234   };
235
236   payload_tvb = tvb_new_subset(message_tvb, USER_OFFSET, payload_length,
237                                payload_length);
238   call_dissector(mtp3_handle, payload_tvb, pinfo, tree);
239
240 }
241
242 static void
243 dissect_m2pa_message(tvbuff_t *tvb, packet_info *pinfo, proto_item *m2pa_item,
244                      proto_tree *m2pa_tree, proto_tree *tree)
245 {
246   guint8  version, spare;
247   guint16 message_type;
248   guint32 message_length;
249   tvbuff_t *message_tvb;
250
251   /* Extract the common header */
252   version        = tvb_get_guint8(tvb, VERSION_OFFSET);
253   spare          = tvb_get_guint8(tvb, SPARE_OFFSET);
254   message_type   = tvb_get_ntohs(tvb, MESSAGE_TYPE_OFFSET);
255   message_length = tvb_get_ntohl(tvb, MESSAGE_LENGTH_OFFSET);
256
257   if (m2pa_tree) {
258     /* add the components of the common header to the protocol tree */
259     proto_tree_add_uint(m2pa_tree, hf_m2pa_version, tvb, VERSION_OFFSET,
260                         VERSION_LENGTH, version);
261     proto_tree_add_uint(m2pa_tree, hf_m2pa_spare,
262                         tvb, SPARE_OFFSET, SPARE_LENGTH,
263                         spare);
264     proto_tree_add_uint(m2pa_tree, hf_m2pa_message_type, tvb,
265                         MESSAGE_TYPE_OFFSET, MESSAGE_TYPE_LENGTH,
266                         message_type);
267     proto_tree_add_uint(m2pa_tree, hf_m2pa_message_length,
268                         tvb, MESSAGE_LENGTH_OFFSET, MESSAGE_LENGTH_LENGTH,
269                         message_length);
270   };
271
272   /* create a tvb for the message */
273   message_tvb = tvb_new_subset(tvb, COMMON_HEADER_LENGTH, message_length,
274                                message_length);
275
276   switch(message_type) {
277   case MESSAGE_TYPE_USER_DATA:
278     dissect_m2pa_user_data_message(message_tvb, pinfo, m2pa_item, m2pa_tree,
279                                    message_length, tree, message_type);
280       break;
281
282   case MESSAGE_TYPE_LINK_STATUS:
283     dissect_m2pa_link_status_message(message_tvb, pinfo, m2pa_tree,
284                                      message_type);
285     break;
286
287   default:
288     dissect_m2pa_unknown_message(message_tvb, pinfo, m2pa_tree,
289                                  message_length, message_type);
290   }
291
292 }
293
294 static void
295 dissect_m2pa(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
296 {
297   proto_item *m2pa_item;
298   proto_tree *m2pa_tree;
299
300   /* make entry in the Protocol column on summary display */
301   if (check_col(pinfo->fd, COL_PROTOCOL))
302     col_set_str(pinfo->fd, COL_PROTOCOL, "M2PA");
303
304   /* Clear entries in Info column on summary display */
305   if (check_col(pinfo->fd, COL_INFO))
306     col_clear(pinfo->fd, COL_INFO);
307
308   /* In the interest of speed, if "tree" is NULL, don't do any work not
309      necessary to generate protocol tree items. */
310   if (tree) {
311     /* create the m2pa protocol tree */
312     m2pa_item = proto_tree_add_item(tree, proto_m2pa, tvb, 0,
313                                     COMMON_HEADER_LENGTH, FALSE);
314     m2pa_tree = proto_item_add_subtree(m2pa_item, ett_m2pa);
315   } else {
316     m2pa_item = NULL;
317     m2pa_tree = NULL;
318   };
319
320   /* dissect the message */
321   dissect_m2pa_message(tvb, pinfo, m2pa_item, m2pa_tree, tree);
322 }
323
324 /* Register the protocol with Ethereal */
325 void
326 proto_register_m2pa(void)
327 {
328
329   /* Setup list of header fields */
330   static hf_register_info hf[] = {
331     { &hf_m2pa_version,
332       { "Version", "m2pa.version",
333         FT_UINT8, BASE_DEC, VALS(m2pa_protocol_version_values), 0x0,
334         "", HFILL}
335     },
336     { &hf_m2pa_spare,
337       { "Spare", "m2pa.spare",
338         FT_UINT8, BASE_HEX, NULL, 0x0,
339         "", HFILL}
340     },
341     { &hf_m2pa_message_type,
342       { "Message Type", "m2pa.message_type",
343         FT_UINT16, BASE_HEX, VALS(m2pa_message_type_values), 0x0,
344         "", HFILL}
345     },
346     { &hf_m2pa_message_length,
347       { "Message length", "m2pa.message_length",
348         FT_UINT32, BASE_DEC, NULL, 0x0,
349         "", HFILL}
350     },
351     { &hf_m2pa_ls_status,
352       { "Link Status Status", "m2pa.status",
353         FT_UINT32, BASE_DEC, VALS(m2pa_link_status_values), 0x0,
354         "", HFILL}
355     },
356     { &hf_m2pa_data_li,
357       { "Length Indicator", "m2pa.li",
358         FT_UINT8, BASE_HEX, NULL, 0x0,
359         "", HFILL}
360     },
361     { &hf_m2pa_data_li_spare,
362       { "Spare", "m2pa.li.spare",
363         FT_UINT8, BASE_HEX, NULL, LI_SPARE_MASK,
364         "", HFILL}
365     },
366     { &hf_m2pa_data_li_prio,
367       { "Priority", "m2pa.li.prio",
368         FT_UINT8, BASE_HEX, NULL, LI_PRIORITY_MASK,
369         "", HFILL}
370     }
371   };
372
373   /* Setup protocol subtree array */
374   static gint *ett[] = {
375     &ett_m2pa,
376     &ett_m2pa_message_ud,
377     &ett_m2pa_message_ud_li,
378     &ett_m2pa_message_ls
379   };
380
381   /* Register the protocol name and description */
382   proto_m2pa = proto_register_protocol("MTP2 Peer Adaptation Layer",
383                                       "M2PA", "m2pa");
384
385   /* Required function calls to register the header fields and subtrees used */
386   proto_register_field_array(proto_m2pa, hf, array_length(hf));
387   proto_register_subtree_array(ett, array_length(ett));
388
389 };
390
391 void
392 proto_reg_handoff_m2pa(void)
393 {
394   /*
395    *  Get a handle for the MTP3 dissector.
396    */
397   mtp3_handle = find_dissector("mtp3");
398
399   dissector_add("sctp.ppi",  M2PA_PAYLOAD_PROTOCOL_ID,
400                 dissect_m2pa, proto_m2pa);
401   dissector_add("sctp.port", SCTP_PORT_M2PA, dissect_m2pa, proto_m2pa);
402 }