/* packet-mgcp.c
* Routines for mgcp packet disassembly
* RFC 2705
+ * RFC 3435 (obsoletes 2705): Media Gateway Control Protocol (MGCP) Version 1.0
+ * RFC 3660: Basic MGCP Packages
+ * RFC 3661: MGCP Return Code Usage
+ * NCS 1.0: PacketCable Network-Based Call Signaling Protocol Specification,
+ * PKT-SP-EC-MGCP-I09-040113, January 13, 2004, Cable Television
+ * Laboratories, Inc., http://www.PacketCable.com/
+ * www.iana.org/assignments/mgcp-localconnectionoptions
*
- * $Id: packet-mgcp.c,v 1.43 2003/12/05 09:25:41 guy Exp $
+ * $Id$
*
* Copyright (c) 2000 by Ed Warnicke <hagbard@physics.rutgers.edu>
+ * Copyright (c) 2004 by Thomas Anders <thomas.anders [AT] blue-cable.de>
*
- * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@ethereal.com>
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
* Copyright 1999 Gerald Combs
*
* This program is free software; you can redistribute it and/or
#include "config.h"
#endif
-#include "plugins/plugin_api.h"
-
-#include "moduleinfo.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <gmodule.h>
#include <ctype.h>
-#include <time.h>
#include <string.h>
#include <epan/packet.h>
-#include <epan/resolv.h>
-#include "prefs.h"
-#include <epan/strutil.h>
+#include <epan/emem.h>
+#include <epan/proto.h>
+#include <epan/prefs.h>
#include <epan/conversation.h>
+#include <epan/tap.h>
#include "packet-mgcp.h"
-#include "plugins/plugin_api_defs.h"
-
-#ifndef ENABLE_STATIC
-G_MODULE_EXPORT const gchar version[] = VERSION;
+#ifdef NEED_G_ASCII_STRCASECMP_H
+#include "g_ascii_strcasecmp.h"
#endif
#define TCP_PORT_MGCP_GATEWAY 2427
#define TCP_PORT_MGCP_CALLAGENT 2727
#define UDP_PORT_MGCP_CALLAGENT 2727
-void proto_reg_handoff_mgcp(void);
-
/* Define the mgcp proto */
static int proto_mgcp = -1;
static int hf_mgcp_version = -1;
static int hf_mgcp_rsp_rspcode = -1;
static int hf_mgcp_rsp_rspstring = -1;
+static int hf_mgcp_params = -1;
static int hf_mgcp_param_rspack = -1;
static int hf_mgcp_param_bearerinfo = -1;
static int hf_mgcp_param_callid = -1;
static int hf_mgcp_param_notifiedentity = -1;
static int hf_mgcp_param_requestid = -1;
static int hf_mgcp_param_localconnoptions = -1;
+static int hf_mgcp_param_localconnoptions_p = -1;
+static int hf_mgcp_param_localconnoptions_a = -1;
+static int hf_mgcp_param_localconnoptions_s = -1;
+static int hf_mgcp_param_localconnoptions_e = -1;
+static int hf_mgcp_param_localconnoptions_scrtp = -1;
+static int hf_mgcp_param_localconnoptions_scrtcp = -1;
+static int hf_mgcp_param_localconnoptions_b = -1;
+static int hf_mgcp_param_localconnoptions_esccd = -1;
+static int hf_mgcp_param_localconnoptions_escci = -1;
+static int hf_mgcp_param_localconnoptions_dqgi = -1;
+static int hf_mgcp_param_localconnoptions_dqrd = -1;
+static int hf_mgcp_param_localconnoptions_dqri = -1;
+static int hf_mgcp_param_localconnoptions_dqrr = -1;
+static int hf_mgcp_param_localconnoptions_k = -1;
+static int hf_mgcp_param_localconnoptions_gc = -1;
+static int hf_mgcp_param_localconnoptions_fmtp = -1;
+static int hf_mgcp_param_localconnoptions_nt = -1;
+static int hf_mgcp_param_localconnoptions_ofmtp = -1;
+static int hf_mgcp_param_localconnoptions_r = -1;
+static int hf_mgcp_param_localconnoptions_t = -1;
+static int hf_mgcp_param_localconnoptions_rcnf = -1;
+static int hf_mgcp_param_localconnoptions_rdir = -1;
+static int hf_mgcp_param_localconnoptions_rsh = -1;
static int hf_mgcp_param_connectionmode = -1;
static int hf_mgcp_param_reqevents = -1;
static int hf_mgcp_param_restartmethod = -1;
static int hf_mgcp_param_digitmap = -1;
static int hf_mgcp_param_observedevent = -1;
static int hf_mgcp_param_connectionparam = -1;
+static int hf_mgcp_param_connectionparam_ps = -1;
+static int hf_mgcp_param_connectionparam_os = -1;
+static int hf_mgcp_param_connectionparam_pr = -1;
+static int hf_mgcp_param_connectionparam_or = -1;
+static int hf_mgcp_param_connectionparam_pl = -1;
+static int hf_mgcp_param_connectionparam_ji = -1;
+static int hf_mgcp_param_connectionparam_la = -1;
+static int hf_mgcp_param_connectionparam_pcrps = -1;
+static int hf_mgcp_param_connectionparam_pcros = -1;
+static int hf_mgcp_param_connectionparam_pcrpl = -1;
+static int hf_mgcp_param_connectionparam_pcrji = -1;
+static int hf_mgcp_param_connectionparam_x = -1;
static int hf_mgcp_param_reasoncode = -1;
static int hf_mgcp_param_eventstates = -1;
static int hf_mgcp_param_specificendpoint = -1;
static int hf_mgcp_param_quarantinehandling = -1;
static int hf_mgcp_param_detectedevents = -1;
static int hf_mgcp_param_capabilities = -1;
-static int hf_mgcp_param_extention = -1;
+static int hf_mgcp_param_maxmgcpdatagram = -1;
+static int hf_mgcp_param_packagelist = -1;
+static int hf_mgcp_param_extension = -1;
+static int hf_mgcp_param_extension_critical = -1;
static int hf_mgcp_param_invalid = -1;
static int hf_mgcp_messagecount = -1;
static int hf_mgcp_dup = -1;
static int hf_mgcp_req_dup = -1;
+static int hf_mgcp_req_dup_frame = -1;
static int hf_mgcp_rsp_dup = -1;
+static int hf_mgcp_rsp_dup_frame = -1;
+
+static const value_string mgcp_return_code_vals[] = {
+ {000, "Response Acknowledgement"},
+ {100, "The transaction is currently being executed. An actual completion message will follow on later."},
+ {101, "The transaction has been queued for execution. An actual completion message will follow later."},
+ {200, "The requested transaction was executed normally."},
+ {250, "The connection was deleted."},
+ {400, "The transaction could not be executed, due to a transient error."},
+ {401, "The phone is already off hook"},
+ {402, "The phone is already on hook"},
+ {403, "The transaction could not be executed, because the endpoint does not have sufficient resources at this time"},
+ {404, "Insufficient bandwidth at this time"},
+ {405, "The transaction could not be executed, because the endpoint is \"restarting\"."},
+ {406, "Transaction time-out. The transaction did not complete in a reasonable period of time and has been aborted."},
+ {407, "Transaction aborted. The transaction was aborted by some external action, e.g., a ModifyConnection command aborted by a DeleteConnection command."},
+ {409, "The transaction could not be executed because of internal overload."},
+ {410, "No endpoint available. A valid \"any of\" wildcard was used, however there was no endpoint available to satisfy the request."},
+ {500, "The transaction could not be executed, because the endpoint is unknown."},
+ {501, "The transaction could not be executed, because the endpoint is not ready."},
+ {502, "The transaction could not be executed, because the endpoint does not have sufficient resources"},
+ {503, "\"All of\" wildcard too complicated."},
+ {504, "Unknown or unsupported command."},
+ {505, "Unsupported RemoteConnectionDescriptor."},
+ {506, "Unable to satisfy both LocalConnectionOptions and RemoteConnectionDescriptor."},
+ {507, "Unsupported functionality."},
+ {508, "Unknown or unsupported quarantine handling."},
+ {509, "Error in RemoteConnectionDescriptor."},
+ {510, "The transaction could not be executed, because a protocol error was detected."},
+ {511, "The transaction could not be executed, because the command contained an unrecognized extension."},
+ {512, "The transaction could not be executed, because the gateway is not equipped to detect one of the requested events."},
+ {513, "The transaction could not be executed, because the gateway is not equipped to generate one of the requested signals."},
+ {514, "The transaction could not be executed, because the gateway cannot send the specified announcement."},
+ {515, "The transaction refers to an incorrect connection-id (may have been already deleted)"},
+ {516, "The transaction refers to an unknown call-id."},
+ {517, "Unsupported or invalid mode."},
+ {518, "Unsupported or unknown package."},
+ {519, "Endpoint does not have a digit map."},
+ {520, "The transaction could not be executed, because the endpoint is 'restarting'."},
+ {521, "Endpoint redirected to another Call Agent."},
+ {522, "No such event or signal."},
+ {523, "Unknown action or illegal combination of actions"},
+ {524, "Internal inconsistency in LocalConnectionOptions"},
+ {525, "Unknown extension in LocalConnectionOptions"},
+ {526, "Insufficient bandwidth"},
+ {527, "Missing RemoteConnectionDescriptor"},
+ {528, "Incompatible protocol version"},
+ {529, "Internal hardware failure"},
+ {530, "CAS signaling protocol error."},
+ {531, "failure of a grouping of trunks (e.g. facility failure)."},
+ {532, "Unsupported value(s) in LocalConnectionOptions."},
+ {533, "Response too large."},
+ {534, "Codec negotiation failure."},
+ {535, "Packetization period not supported"},
+ {536, "Unknown or unsupported RestartMethod"},
+ {537, "Unknown or unsupported digit map extension"},
+ {538, "Event/signal parameter error (e.g., missing, erroneous, unsupported, unknown, etc.)"},
+ {539, "Invalid or unsupported command parameter."},
+ {540, "Per endpoint connection limit exceeded."},
+ {541, "Invalid or unsupported LocalConnectionOptions"},
+ {0, NULL }
+};
+
+/* TODO: add/use when tested/have capture to test with */
+/*
+static const value_string mgcp_reason_code_vals[] = {
+ {0, "Endpoint state is normal"},
+ {900, "Endpoint malfunctioning."},
+ {901, "Endpoint taken out-of-service."},
+ {902, "Loss of lower layer connectivity (e.g., downstream sync)."},
+ {903, "QoS resource reservation was lost."},
+ {904, "Manual intervention."},
+ {905, "Facility failure (e.g., DS-0 failure)."},
+ {0, NULL }
+};
+*/
+
/*
* Define the trees for mgcp
- * We need one for MGCP itself and one for the MGCP paramters
+ * We need one for MGCP itself, one for the MGCP paramters and one
+ * for each of the dissected parameters
*/
static int ett_mgcp = -1;
static int ett_mgcp_param = -1;
+static int ett_mgcp_param_connectionparam = -1;
+static int ett_mgcp_param_localconnectionoptions = -1;
/*
* Define the tap for mgcp
* global_mgcp_raw_text determines whether we are going to display
* the raw text of the mgcp message, much like the HTTP dissector does.
*
- * global_mgcp_dissect_tree determines whether we are going to display
- * a detailed tree that expresses a somewhat more semantically meaningful
- * decode.
*/
-static int global_mgcp_gateway_tcp_port = TCP_PORT_MGCP_GATEWAY;
-static int global_mgcp_gateway_udp_port = UDP_PORT_MGCP_GATEWAY;
-static int global_mgcp_callagent_tcp_port = TCP_PORT_MGCP_CALLAGENT;
-static int global_mgcp_callagent_udp_port = UDP_PORT_MGCP_CALLAGENT;
+static guint global_mgcp_gateway_tcp_port = TCP_PORT_MGCP_GATEWAY;
+static guint global_mgcp_gateway_udp_port = UDP_PORT_MGCP_GATEWAY;
+static guint global_mgcp_callagent_tcp_port = TCP_PORT_MGCP_CALLAGENT;
+static guint global_mgcp_callagent_udp_port = UDP_PORT_MGCP_CALLAGENT;
static gboolean global_mgcp_raw_text = FALSE;
-static gboolean global_mgcp_dissect_tree = TRUE;
static gboolean global_mgcp_message_count = FALSE;
/*
static int callagent_udp_port = 0;
/* Some basic utility functions that are specific to this dissector */
-static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength);
+static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength, const gchar **verb_name);
static gboolean is_mgcp_rspcode(tvbuff_t *tvb, gint offset, gint maxlength);
-static gint tvb_parse_param(tvbuff_t *tvb, gint offset, gint maxlength,
- int** hf);
+static gint tvb_parse_param(tvbuff_t *tvb, gint offset, gint maxlength, int** hf);
/*
* The various functions that either dissect some
* subpart of MGCP. These aren't really proto dissectors but they
* are written in the same style.
*/
-static void dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo,
- proto_tree *tree,proto_tree *mgcp_tree, proto_tree *ti);
-static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo,
- proto_tree *tree, mgcp_info_t *mi);
-static void dissect_mgcp_params(tvbuff_t *tvb,
- proto_tree *tree);
-static void mgcp_raw_text_add(tvbuff_t *tvb,
- proto_tree *tree);
+static void dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ proto_tree *mgcp_tree, proto_tree *ti);
+static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
+static void dissect_mgcp_params(tvbuff_t *tvb, proto_tree *tree);
+static void dissect_mgcp_connectionparams(proto_tree *parent_tree, tvbuff_t *tvb,
+ gint offset, gint param_type_len,
+ gint param_val_len);
+static void dissect_mgcp_localconnectionoptions(proto_tree *parent_tree, tvbuff_t *tvb,
+ gint offset, gint param_type_len,
+ gint param_val_len);
+
+static void mgcp_raw_text_add(tvbuff_t *tvb, proto_tree *tree);
/*
* Some functions which should be moved to a library
* as I think that people may find them of general usefulness.
*/
static gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength);
-static gint tvb_find_null_line(tvbuff_t* tvb, gint offset, gint len,
- gint* next_offset);
-static gint tvb_find_dot_line(tvbuff_t* tvb, gint offset,
- gint len, gint* next_offset);
+static gint tvb_find_null_line(tvbuff_t* tvb, gint offset, gint len, gint* next_offset);
+static gint tvb_find_dot_line(tvbuff_t* tvb, gint offset, gint len, gint* next_offset);
static gboolean is_rfc2234_alpha(guint8 c);
static dissector_handle_t sdp_handle;
* Init Hash table stuff
*/
-typedef struct _mgcp_call_info_key {
- guint32 transid;
+typedef struct _mgcp_call_info_key
+{
+ guint32 transid;
conversation_t *conversation;
} mgcp_call_info_key;
static GMemChunk *mgcp_call_info_key_chunk;
-
static GMemChunk *mgcp_call_info_value_chunk;
-
static GHashTable *mgcp_calls;
-/* compare 2 keys */
-static gint
-mgcp_call_equal(gconstpointer k1, gconstpointer k2)
+/* Compare 2 keys */
+static gint mgcp_call_equal(gconstpointer k1, gconstpointer k2)
{
const mgcp_call_info_key* key1 = (const mgcp_call_info_key*) k1;
const mgcp_call_info_key* key2 = (const mgcp_call_info_key*) k2;
return (key1->transid == key2->transid &&
- key1->conversation == key2->conversation);
+ key1->conversation == key2->conversation);
}
-
-/* calculate a hash key */
-static guint
-mgcp_call_hash(gconstpointer k)
+/* Calculate a hash key */
+static guint mgcp_call_hash(gconstpointer k)
{
const mgcp_call_info_key* key = (const mgcp_call_info_key*) k;
- return key->transid + (guint32)(key->conversation);
+ return key->transid + key->conversation->index;
}
-/*
- * dissect_mgcp - The dissector for the Media Gateway Control Protocol
- */
-static void
-dissect_mgcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+
+/************************************************************************
+ * dissect_mgcp - The dissector for the Media Gateway Control Protocol
+ ************************************************************************/
+static void dissect_mgcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
- gint sectionlen;
- guint32 num_messages;
- gint tvb_sectionend,tvb_sectionbegin, tvb_len, tvb_current_len;
- proto_tree *mgcp_tree, *ti;
-
- /* Initialize variables */
- tvb_sectionend = 0;
- tvb_sectionbegin = tvb_sectionend;
- sectionlen = 0;
- tvb_len = tvb_length(tvb);
- tvb_current_len = tvb_len;
- num_messages = 0;
- mgcp_tree = NULL;
- ti = NULL;
-
- /*
- * Set the columns now, so that they'll be set correctly if we throw
- * an exception. We can set them later as well....
- */
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
- col_add_str(pinfo->cinfo, COL_PROTOCOL, "MGCP");
- if (check_col(pinfo->cinfo, COL_INFO))
- col_clear(pinfo->cinfo, COL_INFO);
-
- /*
- * Check to see whether we're really dealing with MGCP by looking
- * for a valid MGCP verb or response code. This isn't infallible,
- * but its cheap and its better than nothing.
- */
- if(is_mgcp_verb(tvb,0,tvb_len) || is_mgcp_rspcode(tvb,0,tvb_len)){
- /*
- * Loop through however many mgcp messages may be stuck in
- * this packet using piggybacking
- */
- do{
- num_messages++;
- if(tree){
- /* Create out mgcp subtree */
- ti = proto_tree_add_item(tree,proto_mgcp,tvb,0,0, FALSE);
- mgcp_tree = proto_item_add_subtree(ti, ett_mgcp);
- }
-
- sectionlen = tvb_find_dot_line(tvb, tvb_sectionbegin, -1,
- &tvb_sectionend);
- if( sectionlen != -1){
- dissect_mgcp_message(tvb_new_subset(tvb, tvb_sectionbegin,
- sectionlen, -1),
- pinfo, tree, mgcp_tree,ti);
+ gint sectionlen;
+ guint32 num_messages;
+ gint tvb_sectionend,tvb_sectionbegin, tvb_len, tvb_current_len;
+ proto_tree *mgcp_tree, *ti;
+ const gchar *verb_name = "";
+
+ /* Initialize variables */
+ tvb_sectionend = 0;
tvb_sectionbegin = tvb_sectionend;
- }
- else {
- break;
- }
- } while(tvb_sectionend < tvb_len );
- if(mgcp_tree){
- proto_tree_add_uint_hidden(mgcp_tree, hf_mgcp_messagecount, tvb,
- 0 ,0 , num_messages);
- }
-
- /*
- * Add our column information we do this after dissecting SDP
- * in order to prevent the column info changing to reflect the SDP.
- * XXX - can we do this with a fence?
- */
- tvb_sectionbegin = 0;
- if (check_col(pinfo->cinfo, COL_PROTOCOL)){
- if( global_mgcp_message_count == TRUE ){
- if(num_messages > 1){
- col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "MGCP (%i messages)",num_messages);
- }
- else {
- col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "MGCP (%i message)",num_messages);
+ sectionlen = 0;
+ tvb_len = tvb_length(tvb);
+ tvb_current_len = tvb_len;
+ num_messages = 0;
+ mgcp_tree = NULL;
+ ti = NULL;
+
+ /*
+ * Set the columns now, so that they'll be set correctly if we throw
+ * an exception. We can set them later as well....
+ */
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ col_add_str(pinfo->cinfo, COL_PROTOCOL, "MGCP");
+ if (check_col(pinfo->cinfo, COL_INFO))
+ col_clear(pinfo->cinfo, COL_INFO);
+
+ /*
+ * Check to see whether we're really dealing with MGCP by looking
+ * for a valid MGCP verb or response code. This isn't infallible,
+ * but its cheap and its better than nothing.
+ */
+ if (is_mgcp_verb(tvb,0,tvb_len, &verb_name) || is_mgcp_rspcode(tvb,0,tvb_len))
+ {
+ /*
+ * Loop through however many mgcp messages may be stuck in
+ * this packet using piggybacking
+ */
+ do
+ {
+ num_messages++;
+ if (tree)
+ {
+ /* Create our mgcp subtree */
+ ti = proto_tree_add_item(tree,proto_mgcp,tvb,0,0, FALSE);
+ mgcp_tree = proto_item_add_subtree(ti, ett_mgcp);
+ }
+
+ sectionlen = tvb_find_dot_line(tvb, tvb_sectionbegin, -1, &tvb_sectionend);
+ if (sectionlen != -1)
+ {
+ dissect_mgcp_message(tvb_new_subset(tvb, tvb_sectionbegin,
+ sectionlen, -1),
+ pinfo, tree, mgcp_tree,ti);
+ tvb_sectionbegin = tvb_sectionend;
+ }
+ else
+ {
+ break;
+ }
+ } while (tvb_sectionend < tvb_len);
+
+ if (mgcp_tree)
+ {
+ proto_tree_add_uint_hidden(mgcp_tree, hf_mgcp_messagecount, tvb,
+ 0 ,0 , num_messages);
+ }
+
+ /*
+ * Add our column information after dissecting SDP
+ * in order to prevent the column info changing to reflect the SDP
+ * (when showing message count)
+ */
+ tvb_sectionbegin = 0;
+ if (check_col(pinfo->cinfo, COL_PROTOCOL))
+ {
+ if (global_mgcp_message_count == TRUE )
+ {
+ if (num_messages > 1)
+ {
+ col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "MGCP (%i messages)",num_messages);
+ }
+ else
+ {
+ col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "MGCP (%i message)",num_messages);
+ }
+ }
+ }
+
+ if (check_col(pinfo->cinfo, COL_INFO))
+ {
+ sectionlen = tvb_find_line_end(tvb, tvb_sectionbegin,-1,
+ &tvb_sectionend,FALSE);
+ col_prepend_fstr(pinfo->cinfo, COL_INFO, "%s",
+ tvb_format_text(tvb, tvb_sectionbegin, sectionlen));
+ }
}
- }
- else {
- col_add_str(pinfo->cinfo, COL_PROTOCOL, "MGCP");
- }
- }
-
- if (check_col(pinfo->cinfo, COL_INFO) ){
- sectionlen = tvb_find_line_end(tvb, tvb_sectionbegin,-1,
- &tvb_sectionend,FALSE);
- col_prepend_fstr(pinfo->cinfo, COL_INFO, "%s",
- tvb_format_text(tvb,tvb_sectionbegin,sectionlen));
- }
- }
}
-static void
-dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
- proto_tree *mgcp_tree, proto_tree *ti){
-
- /* Declare variables */
- gint sectionlen;
- gint tvb_sectionend,tvb_sectionbegin, tvb_len, tvb_current_len;
- tvbuff_t *next_tvb;
- static mgcp_info_t mi;
-
- /* Initialize variables */
- tvb_sectionend = 0;
- tvb_sectionbegin = tvb_sectionend;
- sectionlen = 0;
- tvb_len = tvb_length(tvb);
- tvb_current_len = tvb_len;
-
- /*
- * Check to see whether we're really dealing with MGCP by looking
- * for a valid MGCP verb or response code. This isn't infallible,
- * but its cheap and its better than nothing.
- */
- if(is_mgcp_verb(tvb,0,tvb_len) || is_mgcp_rspcode(tvb,0,tvb_len)){
- /* dissect first line */
- tvb_sectionbegin = 0;
- tvb_current_len = tvb_len;
- tvb_sectionend = tvb_sectionbegin;
- sectionlen = tvb_find_line_end(tvb,0,-1,&tvb_sectionend,FALSE);
- if( sectionlen > 0){
- dissect_mgcp_firstline(tvb_new_subset(tvb, tvb_sectionbegin,
- sectionlen,-1), pinfo,
- mgcp_tree, &mi);
- }
- tvb_sectionbegin = tvb_sectionend;
-
- /* dissect params */
- if(tvb_sectionbegin < tvb_len){
- sectionlen = tvb_find_null_line(tvb, tvb_sectionbegin, -1,
- &tvb_sectionend);
- dissect_mgcp_params(tvb_new_subset(tvb, tvb_sectionbegin,
- sectionlen, -1),
- mgcp_tree);
- tvb_sectionbegin = tvb_sectionend;
- }
-
- /* set the mgcp payload length correctly so we don't include the
- * encapsulated SDP
- */
- sectionlen = tvb_sectionend;
- proto_item_set_len(ti,sectionlen);
-
- /* Display the raw text of the mgcp message if desired */
-
- /* Do we want to display the raw text of our MGCP packet? */
- if(global_mgcp_raw_text) {
- if (tree)
- mgcp_raw_text_add(tvb, mgcp_tree);
- }
-
- /* dissect sdp payload */
- if( tvb_sectionend < tvb_len){
- next_tvb = tvb_new_subset(tvb, tvb_sectionend, -1, -1);
- call_dissector(sdp_handle, next_tvb, pinfo, tree);
- }
- }
+#define MAX_MGCP_MESSAGES_IN_PACKET 5
+static mgcp_info_t pi_arr[MAX_MGCP_MESSAGES_IN_PACKET];
+static int pi_current = 0;
+static mgcp_info_t *mi;
+
+/* Dissect an individual MGCP message */
+static void dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+ proto_tree *mgcp_tree, proto_tree *ti)
+{
+ /* Declare variables */
+ gint sectionlen;
+ gint tvb_sectionend,tvb_sectionbegin, tvb_len, tvb_current_len;
+ tvbuff_t *next_tvb;
+ const gchar *verb_name = "";
+
+ /* Initialise stat info for passing to tap */
+ pi_current++;
+ if (pi_current == MAX_MGCP_MESSAGES_IN_PACKET)
+ {
+ /* Overwrite info in first struct if run out of space... */
+ pi_current = 0;
+ }
+ mi = &pi_arr[pi_current];
+
+
+ mi->mgcp_type = MGCP_OTHERS;
+ mi->code[0] = '\0';
+ mi->transid = 0;
+ mi->req_time.secs = 0;
+ mi->req_time.nsecs = 0;
+ mi->is_duplicate = FALSE;
+ mi->request_available = FALSE;
+ mi->req_num = 0;
+ mi->endpointId = NULL;
+ mi->observedEvents = NULL;
+ mi->rspcode = 0;
+ mi->signalReq = NULL;
+ mi->hasDigitMap = FALSE;
+
+ /* Initialize variables */
+ tvb_sectionend = 0;
+ tvb_sectionbegin = tvb_sectionend;
+ sectionlen = 0;
+ tvb_len = tvb_length(tvb);
+ tvb_current_len = tvb_len;
+
+ /*
+ * Check to see whether we're really dealing with MGCP by looking
+ * for a valid MGCP verb or response code. This isn't infallible,
+ * but its cheap and its better than nothing.
+ */
+ if (is_mgcp_verb(tvb,0,tvb_len,&verb_name) || is_mgcp_rspcode(tvb,0,tvb_len))
+ {
+ /* dissect first line */
+ tvb_sectionbegin = 0;
+ tvb_current_len = tvb_len;
+ tvb_sectionend = tvb_sectionbegin;
+ sectionlen = tvb_find_line_end(tvb,0,-1,&tvb_sectionend,FALSE);
+ if (sectionlen > 0)
+ {
+ dissect_mgcp_firstline(tvb_new_subset(tvb, tvb_sectionbegin,
+ sectionlen,-1), pinfo,
+ mgcp_tree);
+ }
+ tvb_sectionbegin = tvb_sectionend;
+
+ /* Dissect params */
+ if (tvb_sectionbegin < tvb_len)
+ {
+ sectionlen = tvb_find_null_line(tvb, tvb_sectionbegin, -1,
+ &tvb_sectionend);
+ if (sectionlen > 0)
+ {
+ dissect_mgcp_params(tvb_new_subset(tvb, tvb_sectionbegin, sectionlen, -1),
+ mgcp_tree);
+ tvb_sectionbegin = tvb_sectionend;
+ }
+ }
+
+ /* Set the mgcp payload length correctly so we don't include any
+ encapsulated SDP */
+ sectionlen = tvb_sectionend;
+ proto_item_set_len(ti,sectionlen);
+
+ /* Display the raw text of the mgcp message if desired */
+
+ /* Do we want to display the raw text of our MGCP packet? */
+ if (global_mgcp_raw_text)
+ {
+ if (tree)
+ mgcp_raw_text_add(tvb, mgcp_tree);
+ }
+
+ /* Dissect sdp payload */
+ if (tvb_sectionend < tvb_len)
+ {
+ next_tvb = tvb_new_subset(tvb, tvb_sectionend, -1, -1);
+ call_dissector(sdp_handle, next_tvb, pinfo, tree);
+ }
+ }
}
* Add the raw text of the message to the dissect tree if appropriate
* preferences are specified.
*/
-
-static void mgcp_raw_text_add(tvbuff_t *tvb, proto_tree *tree){
-
- gint tvb_linebegin,tvb_lineend,tvb_len,linelen;
-
- tvb_linebegin = 0;
- tvb_len = tvb_length(tvb);
-
- do {
- tvb_find_line_end(tvb,tvb_linebegin,-1,&tvb_lineend,FALSE);
- linelen = tvb_lineend - tvb_linebegin;
- proto_tree_add_text(tree, tvb, tvb_linebegin, linelen,
- "%s", tvb_format_text(tvb,tvb_linebegin,
- linelen));
- tvb_linebegin = tvb_lineend;
- } while ( tvb_lineend < tvb_len );
+static void mgcp_raw_text_add(tvbuff_t *tvb, proto_tree *tree)
+{
+ gint tvb_linebegin,tvb_lineend,tvb_len,linelen;
+
+ tvb_linebegin = 0;
+ tvb_len = tvb_length(tvb);
+
+ do
+ {
+ tvb_find_line_end(tvb,tvb_linebegin,-1,&tvb_lineend,FALSE);
+ linelen = tvb_lineend - tvb_linebegin;
+ proto_tree_add_text(tree, tvb, tvb_linebegin, linelen, "%s",
+ tvb_format_text(tvb, tvb_linebegin, linelen));
+ tvb_linebegin = tvb_lineend;
+ } while (tvb_lineend < tvb_len);
}
/* Discard and init any state we've saved */
-
-static void
-mgcp_init_protocol(void)
+static void mgcp_init_protocol(void)
{
- if (mgcp_calls != NULL) {
+ if (mgcp_calls != NULL)
+ {
g_hash_table_destroy(mgcp_calls);
mgcp_calls = NULL;
}
- if (mgcp_call_info_key_chunk != NULL) {
+ if (mgcp_call_info_key_chunk != NULL)
+ {
g_mem_chunk_destroy(mgcp_call_info_key_chunk);
mgcp_call_info_key_chunk = NULL;
}
- if (mgcp_call_info_value_chunk != NULL) {
+ if (mgcp_call_info_value_chunk != NULL)
+ {
g_mem_chunk_destroy(mgcp_call_info_value_chunk);
mgcp_call_info_value_chunk = NULL;
}
mgcp_calls = g_hash_table_new(mgcp_call_hash, mgcp_call_equal);
mgcp_call_info_key_chunk = g_mem_chunk_new("call_info_key_chunk",
- sizeof(mgcp_call_info_key),
- 200 * sizeof(mgcp_call_info_key),
- G_ALLOC_ONLY);
+ sizeof(mgcp_call_info_key),
+ 200 * sizeof(mgcp_call_info_key),
+ G_ALLOC_ONLY);
mgcp_call_info_value_chunk = g_mem_chunk_new("call_info_value_chunk",
- sizeof(mgcp_call_t),
- 200 * sizeof(mgcp_call_t),
- G_ALLOC_ONLY);
+ sizeof(mgcp_call_t),
+ 200 * sizeof(mgcp_call_t),
+ G_ALLOC_ONLY);
}
/* Register all the bits needed with the filtering engine */
-
-void
-proto_register_mgcp(void)
+void proto_register_mgcp(void)
{
- static hf_register_info hf[] = {
- { &hf_mgcp_req,
- { "Request", "mgcp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "True if MGCP request", HFILL }},
- { &hf_mgcp_rsp,
- { "Response", "mgcp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
- "TRUE if MGCP response", HFILL }},
- { &hf_mgcp_req_frame,
- { "Request Frame", "mgcp.reqframe", FT_FRAMENUM, BASE_NONE, NULL, 0,
- "Request Frame", HFILL }},
- { &hf_mgcp_rsp_frame,
- { "Response Frame", "mgcp.rspframe", FT_FRAMENUM, BASE_NONE, NULL, 0,
- "Response Frame", HFILL }},
- { &hf_mgcp_time,
- { "Time from request", "mgcp.time", FT_RELATIVE_TIME, BASE_NONE, NULL, 0,
- "Timedelta between Request and Response", HFILL }},
- { &hf_mgcp_req_verb,
- { "Verb", "mgcp.req.verb", FT_STRING, BASE_DEC, NULL, 0x0,
- "Name of the verb", HFILL }},
- { &hf_mgcp_req_endpoint,
- { "Endpoint", "mgcp.req.endpoint", FT_STRING, BASE_DEC, NULL, 0x0,
- "Endpoint referenced by the message", HFILL }},
- { &hf_mgcp_transid,
- { "Transaction ID", "mgcp.transid", FT_STRING, BASE_DEC, NULL, 0x0,
- "Transaction ID of this message", HFILL }},
- { &hf_mgcp_version,
- { "Version", "mgcp.version", FT_STRING, BASE_DEC, NULL, 0x0,
- "MGCP Version", HFILL }},
- { &hf_mgcp_rsp_rspcode,
- { "Response Code", "mgcp.rsp.rspcode", FT_STRING, BASE_DEC, NULL, 0x0,
- "Response Code", HFILL }},
- { &hf_mgcp_rsp_rspstring,
- { "Response String", "mgcp.rsp.rspstring", FT_STRING, BASE_DEC, NULL,
- 0x0, "Response String", HFILL }},
- { &hf_mgcp_param_rspack,
- { "ResponseAck (K)", "mgcp.param.rspack", FT_STRING, BASE_DEC, NULL,
- 0x0, "Response Ack", HFILL }},
- { &hf_mgcp_param_bearerinfo,
- { "BearerInformation (B)", "mgcp.param.bearerinfo", FT_STRING, BASE_DEC,
- NULL, 0x0, "Bearer Information", HFILL }},
- { &hf_mgcp_param_callid,
- { "CallId (C)", "mgcp.param.callid", FT_STRING, BASE_DEC, NULL, 0x0,
- "Call Id", HFILL }},
- { &hf_mgcp_param_connectionid,
- {"ConnectionIdentifier (I)", "mgcp.param.connectionid", FT_STRING,
- BASE_DEC, NULL, 0x0, "Connection Identifier", HFILL }},
- { &hf_mgcp_param_secondconnectionid,
- { "SecondConnectionID (I2)", "mgcp.param.secondconnectionid", FT_STRING,
- BASE_DEC, NULL, 0x0, "Second Connection Identifier", HFILL }},
- { &hf_mgcp_param_notifiedentity,
- { "NotifiedEntity (N)", "mgcp.param.notifiedentity", FT_STRING, BASE_DEC,
- NULL, 0x0, "Notified Entity", HFILL }},
- { &hf_mgcp_param_requestid,
- { "RequestIdentifier (X)", "mgcp.param.requestid", FT_STRING, BASE_DEC,
- NULL, 0x0, "Request Identifier", HFILL }},
- { &hf_mgcp_param_localconnoptions,
- { "LocalConnectionOptions (L)", "mgcp.param.localconnectionoptions",
- FT_STRING, BASE_DEC, NULL, 0x0, "Local Connection Options", HFILL }},
- { &hf_mgcp_param_connectionmode,
- { "ConnectionMode (M)", "mgcp.param.connectionmode", FT_STRING, BASE_DEC,
- NULL, 0x0, "Connection Mode", HFILL }},
- { &hf_mgcp_param_reqevents,
- { "RequestedEvents (R)", "mgcp.param.reqevents", FT_STRING, BASE_DEC,
- NULL, 0x0, "Requested Events", HFILL }},
- { &hf_mgcp_param_signalreq,
- { "SignalRequests (S)", "mgcp.param.signalreq", FT_STRING, BASE_DEC,
- NULL, 0x0, "Signal Request", HFILL }},
- { &hf_mgcp_param_restartmethod,
- { "RestartMethod (RM)", "mgcp.param.restartmethod", FT_STRING, BASE_DEC,
- NULL, 0x0, "Restart Method", HFILL }},
- { &hf_mgcp_param_restartdelay,
- { "RestartDelay (RD)", "mgcp.param.restartdelay", FT_STRING, BASE_DEC,
- NULL, 0x0, "Restart Delay", HFILL }},
- { &hf_mgcp_param_digitmap,
- { "DigitMap (D)", "mgcp.param.digitmap", FT_STRING, BASE_DEC, NULL, 0x0,
- "Digit Map", HFILL }},
- { &hf_mgcp_param_observedevent,
- { "ObservedEvents (O)", "mgcp.param.observedevents", FT_STRING,
- BASE_DEC, NULL, 0x0, "Observed Events", HFILL }},
- { &hf_mgcp_param_connectionparam,
- { "ConnectionParameters (P)", "mgcp.param.connectionparam", FT_STRING,
- BASE_DEC, NULL, 0x0, "Connection Parameters", HFILL }},
- { &hf_mgcp_param_reasoncode,
- { "ReasonCode (E)", "mgcp.param.reasoncode", FT_STRING, BASE_DEC,
- NULL, 0x0, "Reason Code", HFILL }},
- { &hf_mgcp_param_eventstates,
- { "EventStates (ES)", "mgcp.param.eventstates", FT_STRING, BASE_DEC,
- NULL, 0x0, "Event States", HFILL }},
- { &hf_mgcp_param_specificendpoint,
- { "SpecificEndpointID (Z)", "mgcp.param.specificendpointid", FT_STRING,
- BASE_DEC, NULL, 0x0, "Specific Endpoint ID", HFILL }},
- { &hf_mgcp_param_secondendpointid,
- { "SecondEndpointID (Z2)", "mgcp.param.secondendpointid", FT_STRING,
- BASE_DEC, NULL, 0x0, "Second Endpoing ID", HFILL }},
- { &hf_mgcp_param_reqinfo,
- { "RequestedInfo (F)", "mgcp.param.reqinfo", FT_STRING, BASE_DEC,
- NULL, 0x0,"Requested Info", HFILL }},
- { &hf_mgcp_param_quarantinehandling,
- { "QuarantineHandling (Q)", "mgcp.param.quarantinehandling", FT_STRING,
- BASE_DEC, NULL, 0x0, "Quarantine Handling", HFILL }},
- { &hf_mgcp_param_detectedevents,
- { "DetectedEvents (T)", "mgcp.param.detectedevents", FT_STRING, BASE_DEC,
- NULL, 0x0, "Detected Events", HFILL }},
- { &hf_mgcp_param_capabilities,
- { "Capabilities (A)", "mgcp.param.capabilities", FT_STRING, BASE_DEC,
- NULL, 0x0, "Capabilities", HFILL }},
- { &hf_mgcp_param_extention,
- { "Extention Parameter (X-*)", "mgcp.param.extention", FT_STRING,
- BASE_DEC, NULL, 0x0, "Extension Parameter", HFILL }},
- { &hf_mgcp_param_invalid,
- { "Invalid Parameter", "mgcp.param.invalid", FT_STRING,
- BASE_DEC, NULL, 0x0, "Invalid Parameter", HFILL }},
- { &hf_mgcp_messagecount,
- { "MGCP Message Count", "mgcp.messagecount", FT_UINT32,
- BASE_DEC, NULL, 0x0, "Number of MGCP message in a packet", HFILL }},
- { &hf_mgcp_dup,
- { "Duplicate Message", "mgcp.dup", FT_UINT32, BASE_DEC,
- NULL, 0, "Duplicate Message", HFILL }},
- { &hf_mgcp_req_dup,
- { "Duplicate Request", "mgcp.req.dup", FT_UINT32, BASE_DEC,
- NULL, 0, "Duplicate Request", HFILL }},
- { &hf_mgcp_rsp_dup,
- { "Duplicate Response", "mgcp.rsp.dup", FT_UINT32, BASE_DEC,
- NULL, 0, "Duplicate Response", HFILL }},
- /* Add more fields here */
- };
- static gint *ett[] = {
- &ett_mgcp,
- &ett_mgcp_param,
- };
- module_t *mgcp_module;
-
- proto_mgcp = proto_register_protocol("Media Gateway Control Protocol",
- "MGCP", "mgcp");
-
- proto_register_field_array(proto_mgcp, hf, array_length(hf));
- proto_register_subtree_array(ett, array_length(ett));
- register_init_routine(&mgcp_init_protocol);
-
- /* Register our configuration options for , particularly our ports */
-
- mgcp_module = prefs_register_protocol(proto_mgcp, proto_reg_handoff_mgcp);
-
- prefs_register_uint_preference(mgcp_module, "tcp.gateway_port",
- "MGCP Gateway TCP Port",
- "Set the UDP port for gateway messages "
- "(if other than the default of 2427)",
- 10, &global_mgcp_gateway_tcp_port);
-
- prefs_register_uint_preference(mgcp_module, "udp.gateway_port",
- "MGCP Gateway UDP Port",
- "Set the TCP port for gateway messages "
- "(if other than the default of 2427)",
- 10, &global_mgcp_gateway_udp_port);
-
- prefs_register_uint_preference(mgcp_module, "tcp.callagent_port",
- "MGCP Callagent TCP Port",
- "Set the TCP port for callagent messages "
- "(if other than the default of 2727)",
- 10, &global_mgcp_callagent_tcp_port);
-
- prefs_register_uint_preference(mgcp_module, "udp.callagent_port",
- "MGCP Callagent UDP Port",
- "Set the UDP port for callagent messages "
- "(if other than the default of 2727)",
- 10, &global_mgcp_callagent_udp_port);
-
-
- prefs_register_bool_preference(mgcp_module, "display_raw_text",
- "Display raw text for MGCP message",
- "Specifies that the raw text of the "
- "MGCP message should be displayed "
- "instead of (or in addition to) the "
- "dissection tree",
- &global_mgcp_raw_text);
-
- prefs_register_bool_preference(mgcp_module, "display_dissect_tree",
- "Display tree dissection for MGCP message",
- "Specifies that the dissection tree of the "
- "MGCP message should be displayed "
- "instead of (or in addition to) the "
- "raw text",
- &global_mgcp_dissect_tree);
-
- prefs_register_bool_preference(mgcp_module, "display_mgcp_message_count",
- "Display the number of MGCP messages",
- "Display the number of MGCP messages "
- "found in a packet in the protocol column.",
- &global_mgcp_message_count);
-
- mgcp_tap = register_tap("mgcp");
+ static hf_register_info hf[] =
+ {
+ { &hf_mgcp_req,
+ { "Request", "mgcp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "True if MGCP request", HFILL }},
+ { &hf_mgcp_rsp,
+ { "Response", "mgcp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
+ "TRUE if MGCP response", HFILL }},
+ { &hf_mgcp_req_frame,
+ { "Request Frame", "mgcp.reqframe", FT_FRAMENUM, BASE_NONE, NULL, 0,
+ "Request Frame", HFILL }},
+ { &hf_mgcp_rsp_frame,
+ { "Response Frame", "mgcp.rspframe", FT_FRAMENUM, BASE_NONE, NULL, 0,
+ "Response Frame", HFILL }},
+ { &hf_mgcp_time,
+ { "Time from request", "mgcp.time", FT_RELATIVE_TIME, BASE_NONE, NULL, 0,
+ "Timedelta between Request and Response", HFILL }},
+ { &hf_mgcp_req_verb,
+ { "Verb", "mgcp.req.verb", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Name of the verb", HFILL }},
+ { &hf_mgcp_req_endpoint,
+ { "Endpoint", "mgcp.req.endpoint", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Endpoint referenced by the message", HFILL }},
+ { &hf_mgcp_transid,
+ { "Transaction ID", "mgcp.transid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Transaction ID of this message", HFILL }},
+ { &hf_mgcp_version,
+ { "Version", "mgcp.version", FT_STRING, BASE_DEC, NULL, 0x0,
+ "MGCP Version", HFILL }},
+ { &hf_mgcp_rsp_rspcode,
+ { "Response Code", "mgcp.rsp.rspcode", FT_UINT32, BASE_DEC, VALS(mgcp_return_code_vals), 0x0,
+ "Response Code", HFILL }},
+ { &hf_mgcp_rsp_rspstring,
+ { "Response String", "mgcp.rsp.rspstring", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Response String", HFILL }},
+ { &hf_mgcp_params,
+ { "Parameters", "mgcp.params", FT_NONE, 0, NULL, 0x0,
+ "MGCP parameters", HFILL }},
+ { &hf_mgcp_param_rspack,
+ { "ResponseAck (K)", "mgcp.param.rspack", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Response Ack", HFILL }},
+ { &hf_mgcp_param_bearerinfo,
+ { "BearerInformation (B)", "mgcp.param.bearerinfo", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Bearer Information", HFILL }},
+ { &hf_mgcp_param_callid,
+ { "CallId (C)", "mgcp.param.callid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Call Id", HFILL }},
+ { &hf_mgcp_param_connectionid,
+ {"ConnectionIdentifier (I)", "mgcp.param.connectionid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Connection Identifier", HFILL }},
+ { &hf_mgcp_param_secondconnectionid,
+ { "SecondConnectionID (I2)", "mgcp.param.secondconnectionid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Second Connection Identifier", HFILL }},
+ { &hf_mgcp_param_notifiedentity,
+ { "NotifiedEntity (N)", "mgcp.param.notifiedentity", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Notified Entity", HFILL }},
+ { &hf_mgcp_param_requestid,
+ { "RequestIdentifier (X)", "mgcp.param.requestid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Request Identifier", HFILL }},
+ { &hf_mgcp_param_localconnoptions,
+ { "LocalConnectionOptions (L)", "mgcp.param.localconnectionoptions", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Local Connection Options", HFILL }},
+ { &hf_mgcp_param_localconnoptions_p,
+ { "Packetization period (p)", "mgcp.param.localconnectionoptions.p", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Packetization period", HFILL }},
+ { &hf_mgcp_param_localconnoptions_a,
+ { "Codecs (a)", "mgcp.param.localconnectionoptions.a", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Codecs", HFILL }},
+ { &hf_mgcp_param_localconnoptions_s,
+ { "Silence Suppression (s)", "mgcp.param.localconnectionoptions.s", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Silence Suppression", HFILL }},
+ { &hf_mgcp_param_localconnoptions_e,
+ { "Echo Cancellation (e)", "mgcp.param.localconnectionoptions.e", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Echo Cancellation", HFILL }},
+ { &hf_mgcp_param_localconnoptions_scrtp,
+ { "RTP ciphersuite (sc-rtp)", "mgcp.param.localconnectionoptions.scrtp", FT_STRING, BASE_DEC, NULL, 0x0,
+ "RTP ciphersuite", HFILL }},
+ { &hf_mgcp_param_localconnoptions_scrtcp,
+ { "RTCP ciphersuite (sc-rtcp)", "mgcp.param.localconnectionoptions.scrtcp", FT_STRING, BASE_DEC, NULL, 0x0,
+ "RTCP ciphersuite", HFILL }},
+ { &hf_mgcp_param_localconnoptions_b,
+ { "Bandwidth (b)", "mgcp.param.localconnectionoptions.b", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Bandwidth", HFILL }},
+ { &hf_mgcp_param_localconnoptions_esccd,
+ { "Content Destination (es-ccd)", "mgcp.param.localconnectionoptions.esccd", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Content Destination", HFILL }},
+ { &hf_mgcp_param_localconnoptions_escci,
+ { "Content Identifier (es-cci)", "mgcp.param.localconnectionoptions.escci", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Content Identifier", HFILL }},
+ { &hf_mgcp_param_localconnoptions_dqgi,
+ { "D-QoS GateID (dq-gi)", "mgcp.param.localconnectionoptions.dqgi", FT_STRING, BASE_DEC, NULL, 0x0,
+ "D-QoS GateID", HFILL }},
+ { &hf_mgcp_param_localconnoptions_dqrd,
+ { "D-QoS Reserve Destination (dq-rd)", "mgcp.param.localconnectionoptions.dqrd", FT_STRING, BASE_DEC, NULL, 0x0,
+ "D-QoS Reserve Destination", HFILL }},
+ { &hf_mgcp_param_localconnoptions_dqri,
+ { "D-QoS Resource ID (dq-ri)", "mgcp.param.localconnectionoptions.dqri", FT_STRING, BASE_DEC, NULL, 0x0,
+ "D-QoS Resource ID", HFILL }},
+ { &hf_mgcp_param_localconnoptions_dqrr,
+ { "D-QoS Resource Reservation (dq-rr)", "mgcp.param.localconnectionoptions.dqrr", FT_STRING, BASE_DEC, NULL, 0x0,
+ "D-QoS Resource Reservation", HFILL }},
+ { &hf_mgcp_param_localconnoptions_k,
+ { "Encryption Key (k)", "mgcp.param.localconnectionoptions.k", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Encryption Key", HFILL }},
+ { &hf_mgcp_param_localconnoptions_gc,
+ { "Gain Control (gc)", "mgcp.param.localconnectionoptions.gc", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Gain Control", HFILL }},
+ { &hf_mgcp_param_localconnoptions_fmtp,
+ { "Media Format (fmtp)", "mgcp.param.localconnectionoptions.fmtp", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Media Format", HFILL }},
+ { &hf_mgcp_param_localconnoptions_nt,
+ { "Network Type (nt)", "mgcp.param.localconnectionoptions.nt", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Network Type", HFILL }},
+ { &hf_mgcp_param_localconnoptions_ofmtp,
+ { "Optional Media Format (o-fmtp)", "mgcp.param.localconnectionoptions.ofmtp", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Optional Media Format", HFILL }},
+ { &hf_mgcp_param_localconnoptions_r,
+ { "Resource Reservation (r)", "mgcp.param.localconnectionoptions.r", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Resource Reservation", HFILL }},
+ { &hf_mgcp_param_localconnoptions_t,
+ { "Type of Service (r)", "mgcp.param.localconnectionoptions.t", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Type of Service", HFILL }},
+ { &hf_mgcp_param_localconnoptions_rcnf,
+ { "Reservation Confirmation (r-cnf)", "mgcp.param.localconnectionoptions.rcnf", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Reservation Confirmation", HFILL }},
+ { &hf_mgcp_param_localconnoptions_rdir,
+ { "Reservation Direction (r-dir)", "mgcp.param.localconnectionoptions.rdir", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Reservation Direction", HFILL }},
+ { &hf_mgcp_param_localconnoptions_rsh,
+ { "Resource Sharing (r-sh)", "mgcp.param.localconnectionoptions.rsh", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Resource Sharing", HFILL }},
+ { &hf_mgcp_param_connectionmode,
+ { "ConnectionMode (M)", "mgcp.param.connectionmode", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Connection Mode", HFILL }},
+ { &hf_mgcp_param_reqevents,
+ { "RequestedEvents (R)", "mgcp.param.reqevents", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Requested Events", HFILL }},
+ { &hf_mgcp_param_signalreq,
+ { "SignalRequests (S)", "mgcp.param.signalreq", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Signal Request", HFILL }},
+ { &hf_mgcp_param_restartmethod,
+ { "RestartMethod (RM)", "mgcp.param.restartmethod", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Restart Method", HFILL }},
+ { &hf_mgcp_param_restartdelay,
+ { "RestartDelay (RD)", "mgcp.param.restartdelay", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Restart Delay", HFILL }},
+ { &hf_mgcp_param_digitmap,
+ { "DigitMap (D)", "mgcp.param.digitmap", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Digit Map", HFILL }},
+ { &hf_mgcp_param_observedevent,
+ { "ObservedEvents (O)", "mgcp.param.observedevents", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Observed Events", HFILL }},
+ { &hf_mgcp_param_connectionparam,
+ { "ConnectionParameters (P)", "mgcp.param.connectionparam", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Connection Parameters", HFILL }},
+ { &hf_mgcp_param_connectionparam_ps,
+ { "Packets sent (PS)", "mgcp.param.connectionparam.ps", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Packets sent (P:PS)", HFILL }},
+ { &hf_mgcp_param_connectionparam_os,
+ { "Octets sent (OS)", "mgcp.param.connectionparam.os", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Octets sent (P:OS)", HFILL }},
+ { &hf_mgcp_param_connectionparam_pr,
+ { "Packets received (PR)", "mgcp.param.connectionparam.pr", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Packets received (P:PR)", HFILL }},
+ { &hf_mgcp_param_connectionparam_or,
+ { "Octets received (OR)", "mgcp.param.connectionparam.or", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Octets received (P:OR)", HFILL }},
+ { &hf_mgcp_param_connectionparam_pl,
+ { "Packets lost (PL)", "mgcp.param.connectionparam.pl", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Packets lost (P:PL)", HFILL }},
+ { &hf_mgcp_param_connectionparam_ji,
+ { "Jitter (JI)", "mgcp.param.connectionparam.ji", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Average inter-packet arrival jitter in milliseconds (P:JI)", HFILL }},
+ { &hf_mgcp_param_connectionparam_la,
+ { "Latency (LA)", "mgcp.param.connectionparam.la", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Average latency in milliseconds (P:LA)", HFILL }},
+ { &hf_mgcp_param_connectionparam_pcrps,
+ { "Remote Packets sent (PC/RPS)", "mgcp.param.connectionparam.pcrps", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Remote Packets sent (P:PC/RPS)", HFILL }},
+ { &hf_mgcp_param_connectionparam_pcros,
+ { "Remote Octets sent (PC/ROS)", "mgcp.param.connectionparam.pcros", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Remote Octets sent (P:PC/ROS)", HFILL }},
+ { &hf_mgcp_param_connectionparam_pcrpl,
+ { "Remote Packets lost (PC/RPL)", "mgcp.param.connectionparam.pcrpl", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Remote Packets lost (P:PC/RPL)", HFILL }},
+ { &hf_mgcp_param_connectionparam_pcrji,
+ { "Remote Jitter (PC/RJI)", "mgcp.param.connectionparam.pcrji", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Remote Jitter (P:PC/RJI)", HFILL }},
+ { &hf_mgcp_param_connectionparam_x,
+ { "Vendor Extension", "mgcp.param.connectionparam.x", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Vendor Extension (P:X-*)", HFILL }},
+ { &hf_mgcp_param_reasoncode,
+ { "ReasonCode (E)", "mgcp.param.reasoncode", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Reason Code", HFILL }},
+ { &hf_mgcp_param_eventstates,
+ { "EventStates (ES)", "mgcp.param.eventstates", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Event States", HFILL }},
+ { &hf_mgcp_param_specificendpoint,
+ { "SpecificEndpointID (Z)", "mgcp.param.specificendpointid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Specific Endpoint ID", HFILL }},
+ { &hf_mgcp_param_secondendpointid,
+ { "SecondEndpointID (Z2)", "mgcp.param.secondendpointid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Second Endpoing ID", HFILL }},
+ { &hf_mgcp_param_reqinfo,
+ { "RequestedInfo (F)", "mgcp.param.reqinfo", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Requested Info", HFILL }},
+ { &hf_mgcp_param_quarantinehandling,
+ { "QuarantineHandling (Q)", "mgcp.param.quarantinehandling", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Quarantine Handling", HFILL }},
+ { &hf_mgcp_param_detectedevents,
+ { "DetectedEvents (T)", "mgcp.param.detectedevents", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Detected Events", HFILL }},
+ { &hf_mgcp_param_capabilities,
+ { "Capabilities (A)", "mgcp.param.capabilities", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Capabilities", HFILL }},
+ { &hf_mgcp_param_maxmgcpdatagram,
+ {"MaxMGCPDatagram (MD)", "mgcp.param.maxmgcpdatagram", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Maximum MGCP Datagram size", HFILL }},
+ { &hf_mgcp_param_packagelist,
+ {"PackageList (PL)", "mgcp.param.packagelist", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Package List", HFILL }},
+ { &hf_mgcp_param_extension,
+ { "Extension Parameter (non-critical)", "mgcp.param.extension", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Extension Parameter", HFILL }},
+ { &hf_mgcp_param_extension_critical,
+ { "Extension Parameter (critical)", "mgcp.param.extensioncritical", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Critical Extension Parameter", HFILL }},
+ { &hf_mgcp_param_invalid,
+ { "Invalid Parameter", "mgcp.param.invalid", FT_STRING, BASE_DEC, NULL, 0x0,
+ "Invalid Parameter", HFILL }},
+ { &hf_mgcp_messagecount,
+ { "MGCP Message Count", "mgcp.messagecount", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Number of MGCP message in a packet", HFILL }},
+ { &hf_mgcp_dup,
+ { "Duplicate Message", "mgcp.dup", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Duplicate Message", HFILL }},
+ { &hf_mgcp_req_dup,
+ { "Duplicate Request", "mgcp.req.dup", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Duplicate Request", HFILL }},
+ { &hf_mgcp_req_dup_frame,
+ { "Original Request Frame", "mgcp.req.dup.frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ "Frame containing original request", HFILL }},
+ { &hf_mgcp_rsp_dup,
+ { "Duplicate Response", "mgcp.rsp.dup", FT_UINT32, BASE_DEC, NULL, 0x0,
+ "Duplicate Response", HFILL }},
+ { &hf_mgcp_rsp_dup_frame,
+ { "Original Response Frame", "mgcp.rsp.dup.frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
+ "Frame containing original response", HFILL }},
+ };
+
+ static gint *ett[] =
+ {
+ &ett_mgcp,
+ &ett_mgcp_param,
+ &ett_mgcp_param_connectionparam,
+ &ett_mgcp_param_localconnectionoptions
+ };
+
+ module_t *mgcp_module;
+
+ /* Register protocol */
+ proto_mgcp = proto_register_protocol("Media Gateway Control Protocol", "MGCP", "mgcp");
+ proto_register_field_array(proto_mgcp, hf, array_length(hf));
+ proto_register_subtree_array(ett, array_length(ett));
+ register_init_routine(&mgcp_init_protocol);
+
+ register_dissector("mgcp", dissect_mgcp, proto_mgcp);
+
+ /* Register our configuration options */
+ mgcp_module = prefs_register_protocol(proto_mgcp, proto_reg_handoff_mgcp);
+
+ prefs_register_uint_preference(mgcp_module, "tcp.gateway_port",
+ "MGCP Gateway TCP Port",
+ "Set the UDP port for gateway messages "
+ "(if other than the default of 2427)",
+ 10, &global_mgcp_gateway_tcp_port);
+
+ prefs_register_uint_preference(mgcp_module, "udp.gateway_port",
+ "MGCP Gateway UDP Port",
+ "Set the TCP port for gateway messages "
+ "(if other than the default of 2427)",
+ 10, &global_mgcp_gateway_udp_port);
+
+ prefs_register_uint_preference(mgcp_module, "tcp.callagent_port",
+ "MGCP Callagent TCP Port",
+ "Set the TCP port for callagent messages "
+ "(if other than the default of 2727)",
+ 10, &global_mgcp_callagent_tcp_port);
+
+ prefs_register_uint_preference(mgcp_module, "udp.callagent_port",
+ "MGCP Callagent UDP Port",
+ "Set the UDP port for callagent messages "
+ "(if other than the default of 2727)",
+ 10, &global_mgcp_callagent_udp_port);
+
+
+ prefs_register_bool_preference(mgcp_module, "display_raw_text",
+ "Display raw text for MGCP message",
+ "Specifies that the raw text of the "
+ "MGCP message should be displayed "
+ "instead of (or in addition to) the "
+ "dissection tree",
+ &global_mgcp_raw_text);
+
+ prefs_register_obsolete_preference(mgcp_module, "display_dissect_tree");
+
+ prefs_register_bool_preference(mgcp_module, "display_mgcp_message_count",
+ "Display the number of MGCP messages",
+ "Display the number of MGCP messages "
+ "found in a packet in the protocol column.",
+ &global_mgcp_message_count);
+
+ mgcp_tap = register_tap("mgcp");
}
/* The registration hand-off routine */
-void
-proto_reg_handoff_mgcp(void)
+void proto_reg_handoff_mgcp(void)
{
- static int mgcp_prefs_initialized = FALSE;
- static dissector_handle_t mgcp_handle;
-
- /*
- * Get a handle for the SDP dissector.
- */
- sdp_handle = find_dissector("sdp");
-
- if (!mgcp_prefs_initialized) {
- mgcp_handle = create_dissector_handle(dissect_mgcp, proto_mgcp);
- mgcp_prefs_initialized = TRUE;
- }
- else {
- dissector_delete("tcp.port", gateway_tcp_port, mgcp_handle);
- dissector_delete("udp.port", gateway_udp_port, mgcp_handle);
- dissector_delete("tcp.port", callagent_tcp_port, mgcp_handle);
- dissector_delete("udp.port", callagent_udp_port, mgcp_handle);
- }
-
- /* Set our port number for future use */
-
- gateway_tcp_port = global_mgcp_gateway_tcp_port;
- gateway_udp_port = global_mgcp_gateway_udp_port;
-
- callagent_tcp_port = global_mgcp_callagent_tcp_port;
- callagent_udp_port = global_mgcp_callagent_udp_port;
-
- dissector_add("tcp.port", global_mgcp_gateway_tcp_port, mgcp_handle);
- dissector_add("udp.port", global_mgcp_gateway_udp_port, mgcp_handle);
- dissector_add("tcp.port", global_mgcp_callagent_tcp_port, mgcp_handle);
- dissector_add("udp.port", global_mgcp_callagent_udp_port, mgcp_handle);
+ static int mgcp_prefs_initialized = FALSE;
+ static dissector_handle_t mgcp_handle;
+
+ /* Get a handle for the SDP dissector. */
+ sdp_handle = find_dissector("sdp");
+ if (!mgcp_prefs_initialized)
+ {
+ mgcp_handle = create_dissector_handle(dissect_mgcp, proto_mgcp);
+ mgcp_prefs_initialized = TRUE;
+ }
+ else
+ {
+ dissector_delete("tcp.port", gateway_tcp_port, mgcp_handle);
+ dissector_delete("udp.port", gateway_udp_port, mgcp_handle);
+ dissector_delete("tcp.port", callagent_tcp_port, mgcp_handle);
+ dissector_delete("udp.port", callagent_udp_port, mgcp_handle);
+ }
+
+ /* Set our port number for future use */
+ gateway_tcp_port = global_mgcp_gateway_tcp_port;
+ gateway_udp_port = global_mgcp_gateway_udp_port;
+
+ callagent_tcp_port = global_mgcp_callagent_tcp_port;
+ callagent_udp_port = global_mgcp_callagent_udp_port;
+
+ dissector_add("tcp.port", global_mgcp_gateway_tcp_port, mgcp_handle);
+ dissector_add("udp.port", global_mgcp_gateway_udp_port, mgcp_handle);
+ dissector_add("tcp.port", global_mgcp_callagent_tcp_port, mgcp_handle);
+ dissector_add("udp.port", global_mgcp_callagent_udp_port, mgcp_handle);
}
/*
* offset - The offset in tvb at which we are looking for a MGCP verb
* maxlength - The maximum distance from offset we may look for the
* characters that make up a MGCP verb.
+ * verb_name - The name for the verb code found (output)
*
* Return: TRUE if there is an MGCP verb at offset in tvb, otherwise FALSE
*/
+static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength, const gchar **verb_name)
+{
+ int returnvalue = FALSE;
+ gchar word[5];
+
+ /* Read the string into 'word' and see if it looks like the start of a verb */
+ if ((maxlength >= 4) && tvb_get_nstringz0(tvb, offset, sizeof(word), word))
+ {
+ if (((g_ascii_strncasecmp(word, "EPCF", 4) == 0) && (*verb_name = "EndpointConfiguration")) ||
+ ((g_ascii_strncasecmp(word, "CRCX", 4) == 0) && (*verb_name = "CreateConnection")) ||
+ ((g_ascii_strncasecmp(word, "MDCX", 4) == 0) && (*verb_name = "ModifyConnection")) ||
+ ((g_ascii_strncasecmp(word, "DLCX", 4) == 0) && (*verb_name = "DeleteConnection")) ||
+ ((g_ascii_strncasecmp(word, "RQNT", 4) == 0) && (*verb_name = "NotificationRequest")) ||
+ ((g_ascii_strncasecmp(word, "NTFY", 4) == 0) && (*verb_name = "Notify")) ||
+ ((g_ascii_strncasecmp(word, "AUEP", 4) == 0) && (*verb_name = "AuditEndpoint")) ||
+ ((g_ascii_strncasecmp(word, "AUCX", 4) == 0) && (*verb_name = "AuditConnection")) ||
+ ((g_ascii_strncasecmp(word, "RSIP", 4) == 0) && (*verb_name = "RestartInProgress")) ||
+ ((g_ascii_strncasecmp(word, "MESG", 4) == 0) && (*verb_name = "Message")) ||
+ (word[0] == 'X' && is_rfc2234_alpha(word[1]) && is_rfc2234_alpha(word[2]) &&
+ is_rfc2234_alpha(word[3]) && (*verb_name = "*Experimental*")))
+ {
+ returnvalue = TRUE;
+ }
+ }
+
+ /* May be whitespace after verb code - anything else is an error.. */
+ if (returnvalue && maxlength >= 5)
+ {
+ char next = tvb_get_guint8(tvb,4);
+ if ((next != ' ') && (next != '\t'))
+ {
+ returnvalue = FALSE;
+ }
+ }
-static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength){
- int returnvalue = FALSE;
- guint8 word[5];
-
- if(( maxlength >= 4) && tvb_get_nstringz0(tvb,offset,sizeof(word),word)){
- if (strncasecmp(word, "EPCF", 4) == 0 ||
- strncasecmp(word, "CRCX", 4) == 0 ||
- strncasecmp(word, "MDCX", 4) == 0 ||
- strncasecmp(word, "DLCX", 4) == 0 ||
- strncasecmp(word, "RQNT", 4) == 0 ||
- strncasecmp(word, "NTFY", 4) == 0 ||
- strncasecmp(word, "AUEP", 4) == 0 ||
- strncasecmp(word, "AUCX", 4) == 0 ||
- strncasecmp(word, "RSIP", 4) == 0 ||
- (word[0] == 'X' && is_rfc2234_alpha(word[1]) && is_rfc2234_alpha(word[2]) &&
- is_rfc2234_alpha(word[3]))
- ){
- returnvalue = TRUE;
- }
- }
- if( returnvalue && maxlength >= 5 &&
- (word[0] = tvb_get_guint8(tvb,4)) != ' ' && word[0] != '\t'){
- returnvalue = FALSE;
- }
- return returnvalue;
+ return returnvalue;
}
/*
* is_mgcp_rspcode - A function for determining whether something which
- * looks roughly like a MGCP response code is at
- * offset in tvb
+ * looks roughly like a MGCP response code (3-digit number)
+ * is at 'offset' in tvb
*
* Parameters:
* tvb - The tvbuff in which we are looking for an MGCP response code
* Return: TRUE if there is an MGCP response code at offset in tvb,
* otherwise FALSE
*/
+static gboolean is_mgcp_rspcode(tvbuff_t *tvb, gint offset, gint maxlength)
+{
+ int returnvalue = FALSE;
+ guint8 word[4];
+
+ /* Do 1st 3 characters look like digits? */
+ if (maxlength >= 3)
+ {
+ tvb_get_nstringz0(tvb, offset, sizeof(word), word);
+ if (isdigit(word[0]) && isdigit(word[1]) && isdigit(word[2]))
+ {
+ returnvalue = TRUE;
+ }
+ }
-static gboolean is_mgcp_rspcode(tvbuff_t *tvb, gint offset, gint maxlength){
- int returnvalue = FALSE;
- guint8 word[4];
- if(maxlength >= 3){
- tvb_get_nstringz0(tvb,offset,sizeof(word),word);
- if( isdigit(word[0]) &&
- isdigit(word[1]) &&
- isdigit(word[2])){
- returnvalue = TRUE;
- }
- }
- if( returnvalue && maxlength >= 4 &&
- (word[0] = tvb_get_guint8(tvb,3)) != ' ' && word[0] != '\t'){
- returnvalue = FALSE;
- }
- return returnvalue;
+ /* Maybe some white space after the 3rd digit - anything else is an error */
+ if (returnvalue && maxlength >= 4)
+ {
+ char next = tvb_get_guint8(tvb, 3);
+ if ((next != ' ') && (next != '\t'))
+ {
+ returnvalue = FALSE;
+ }
+ }
+
+ return returnvalue;
}
/*
* Return: TRUE if c is an upper or lower case alphabetical character,
* FALSE otherwise.
*/
-
-static gboolean is_rfc2234_alpha(guint8 c){
- int returnvalue = FALSE;
- if(( c <= 'Z' && c >= 'A' ) || (c <= 'z' && c >= 'a')){
- returnvalue = TRUE;
- }
- return returnvalue;
+static gboolean is_rfc2234_alpha(guint8 c)
+{
+ return ((c <= 'Z' && c >= 'A' ) || (c <= 'z' && c >= 'a'));
}
+
/*
* tvb_parse_param - Parse the MGCP param into a type and a value.
*
* Returns: The offset in tvb where the value of the MGCP parameter
* begins.
*/
-static gint tvb_parse_param(tvbuff_t* tvb, gint offset, gint len, int** hf){
- gint returnvalue, tvb_current_offset,counter;
- guint8 tempchar;
- tvb_current_offset = offset;
- returnvalue = -1;
- *hf = NULL;
- if(len > 0){
- tempchar = tvb_get_guint8(tvb,tvb_current_offset);
- switch(tempchar){
- case 'K':
- *hf = &hf_mgcp_param_rspack;
- break;
- case 'B':
- *hf = &hf_mgcp_param_bearerinfo;
- break;
- case 'C':
- *hf = &hf_mgcp_param_callid;
- break;
- case 'I':
- tvb_current_offset++;
- if(len > (tvb_current_offset - offset) &&
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':'){
- *hf = &hf_mgcp_param_connectionid;
- tvb_current_offset--;
- }
- else if ( tempchar == '2'){
- *hf = &hf_mgcp_param_secondconnectionid;
- }
- break;
- case 'N':
- *hf = &hf_mgcp_param_notifiedentity;
- break;
- case 'X':
- tvb_current_offset++;
- if(len > (tvb_current_offset - offset) &&
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':'){
- *hf = &hf_mgcp_param_requestid;
- }
- else if(len > (tvb_current_offset - offset) && (
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == '-' ||
- tempchar == '+')){
- tvb_current_offset++;
- for(counter = 1;(counter <= 6) && (len > (counter + tvb_current_offset
- - offset))
- && ( is_rfc2234_alpha(tempchar =
- tvb_get_guint8(tvb,
- tvb_current_offset+counter))
- || isdigit(tempchar));counter++);
- if(tempchar == ':'){
- tvb_current_offset += counter;
- *hf = &hf_mgcp_param_extention;
+static gint tvb_parse_param(tvbuff_t* tvb, gint offset, gint len, int** hf)
+{
+ gint returnvalue = -1, tvb_current_offset,counter;
+ guint8 tempchar, plus_minus;
+ gchar **buf;
+
+ tvb_current_offset = offset;
+ *hf = NULL;
+ buf=NULL;
+
+ if (len > 0)
+ {
+ tempchar = tvb_get_guint8(tvb,tvb_current_offset);
+
+ switch (tempchar)
+ {
+ case 'K':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_rspack;
+ break;
+ case 'B':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_bearerinfo;
+ break;
+ case 'C':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_callid;
+ break;
+ case 'I':
+ tvb_current_offset++;
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_connectionid;
+ tvb_current_offset--;
+ }
+ else
+ if (tempchar == '2')
+ {
+ *hf = &hf_mgcp_param_secondconnectionid;
+ }
+ break;
+ case 'N':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_notifiedentity;
+ break;
+ case 'X':
+ /* Move past 'X' */
+ tvb_current_offset++;
+
+ /* X: is RequestIdentifier */
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_requestid;
+ tvb_current_offset--;
+ }
+
+ /* X+...: or X-....: are vendor extension parameters */
+ else
+ if (len > (tvb_current_offset - offset) &&
+ ((plus_minus = tvb_get_guint8(tvb,tvb_current_offset)) == '-' ||
+ (plus_minus == '+')))
+ {
+ /* Move past + or - */
+ tvb_current_offset++;
+
+ /* Keep going, through possible vendor param name */
+ for (counter = 1;
+ ((len > (counter + tvb_current_offset-offset)) &&
+ (is_rfc2234_alpha(tempchar = tvb_get_guint8(tvb, tvb_current_offset+counter)) ||
+ isdigit(tempchar))) ;
+ counter++);
+
+ if (tempchar == ':')
+ {
+ /* Looks like a valid vendor param name */
+ tvb_current_offset += counter;
+ switch (plus_minus)
+ {
+ case '+':
+ *hf = &hf_mgcp_param_extension_critical;
+ break;
+ case '-':
+ *hf = &hf_mgcp_param_extension;
+ break;
+ }
+ }
+ }
+ break;
+ case 'L':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_localconnoptions;
+ break;
+ case 'M':
+ tvb_current_offset++;
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_connectionmode;
+ tvb_current_offset--;
+ }
+ else
+ if (tempchar == 'D')
+ {
+ *hf = &hf_mgcp_param_maxmgcpdatagram;
+ }
+ break;
+ case 'R':
+ tvb_current_offset++;
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_reqevents;
+ tvb_current_offset--;
+ }
+ else
+ if ( tempchar == 'M')
+ {
+ *hf = &hf_mgcp_param_restartmethod;
+ }
+ else
+ if (tempchar == 'D')
+ {
+ *hf = &hf_mgcp_param_restartdelay;
+ }
+ break;
+ case 'S':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_signalreq;
+ buf = &(mi->signalReq);
+ break;
+ case 'D':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_digitmap;
+ mi->hasDigitMap = TRUE;
+ break;
+ case 'O':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_observedevent;
+ buf = &(mi->observedEvents);
+ break;
+ case 'P':
+ tvb_current_offset++;
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_connectionparam;
+ tvb_current_offset--;
+ }
+ else
+ if ( tempchar == 'L')
+ {
+ *hf = &hf_mgcp_param_packagelist;
+ }
+ break;
+ case 'E':
+ tvb_current_offset++;
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_reasoncode;
+ tvb_current_offset--;
+ }
+ else
+ if ( tempchar == 'S')
+ {
+ *hf = &hf_mgcp_param_eventstates;
+ }
+ break;
+ case 'Z':
+ tvb_current_offset++;
+ if (len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ *hf = &hf_mgcp_param_specificendpoint;
+ tvb_current_offset--;
+ }
+ else
+ if (tempchar == '2')
+ {
+ *hf = &hf_mgcp_param_secondendpointid;
+ }
+ break;
+ case 'F':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_reqinfo;
+ break;
+ case 'Q':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_quarantinehandling;
+ break;
+ case 'T':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_detectedevents;
+ break;
+ case 'A':
+ if (tvb_get_guint8(tvb,tvb_current_offset+1) != ':')
+ {
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+ *hf = &hf_mgcp_param_capabilities;
+ break;
+
+ default:
+ *hf = &hf_mgcp_param_invalid;
+ break;
+ }
+
+ /* Move to (hopefully) the colon */
+ tvb_current_offset++;
+
+ /* Add a recognised parameter type if we have one */
+ if (*hf != NULL && len > (tvb_current_offset - offset) &&
+ (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':')
+ {
+ tvb_current_offset++;
+ tvb_current_offset = tvb_skip_wsp(tvb,tvb_current_offset, (len - tvb_current_offset + offset));
+ returnvalue = tvb_current_offset;
+
+ /* set the observedEvents or signalReq used in Voip Calls analysis */
+ if (buf != NULL) {
+ *buf = tvb_get_ephemeral_string(tvb, tvb_current_offset, (len - tvb_current_offset + offset));
+ }
+ }
}
- }
- tvb_current_offset--;
- break;
- case 'L':
- *hf = &hf_mgcp_param_localconnoptions;
- break;
- case 'M':
- *hf = &hf_mgcp_param_connectionmode;
- break;
- case 'R':
- tvb_current_offset++;
- if(len > (tvb_current_offset - offset) &&
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':'){
- *hf = &hf_mgcp_param_reqevents;
- tvb_current_offset--;
- }
- else if ( tempchar == 'M'){
- *hf = &hf_mgcp_param_restartmethod;
- }
- else if ( tempchar == 'D'){
- *hf = &hf_mgcp_param_restartdelay;
- }
- break;
- case 'S':
- *hf = &hf_mgcp_param_signalreq;
- break;
- case 'D':
- *hf = &hf_mgcp_param_digitmap;
- break;
- case 'O':
- *hf = &hf_mgcp_param_observedevent;
- break;
- case 'P':
- *hf = &hf_mgcp_param_connectionparam;
- break;
- case 'E':
- tvb_current_offset++;
- if(len > (tvb_current_offset - offset) &&
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':'){
- *hf = &hf_mgcp_param_reasoncode;
- tvb_current_offset--;
- }
- else if ( tempchar == 'S'){
- *hf = &hf_mgcp_param_eventstates;
- }
- break;
- case 'Z':
- tvb_current_offset++;
- if(len > (tvb_current_offset - offset) &&
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':'){
- *hf = &hf_mgcp_param_specificendpoint;
- tvb_current_offset--;
- }
- else if ( tempchar == '2'){
- *hf = &hf_mgcp_param_secondendpointid;
- }
- break;
- case 'F':
- *hf = &hf_mgcp_param_reqinfo;
- break;
-
- case 'Q':
- *hf = &hf_mgcp_param_quarantinehandling;
- break;
-
- case 'T':
- *hf = &hf_mgcp_param_detectedevents;
- break;
-
- case 'A':
- *hf = &hf_mgcp_param_capabilities;
- break;
- default:
- *hf = &hf_mgcp_param_invalid;
- break;
- }
-
- tvb_current_offset++;
- if(*hf != NULL && len > (tvb_current_offset - offset) &&
- (tempchar = tvb_get_guint8(tvb,tvb_current_offset)) == ':'){
- tvb_current_offset++;
- tvb_current_offset = tvb_skip_wsp(tvb,tvb_current_offset,
- (len - tvb_current_offset + offset));
- returnvalue = tvb_current_offset;
- }
- else {
- *hf = &hf_mgcp_param_invalid;
- }
- }
- else{
- *hf = &hf_mgcp_param_invalid;
- }
- if(*hf == &hf_mgcp_param_invalid){
- returnvalue = offset;
- }
- return returnvalue;
+ else
+ {
+ /* Was an empty line */
+ *hf = &hf_mgcp_param_invalid;
+ }
+
+ /* For these types, show the whole line */
+ if ((*hf == &hf_mgcp_param_invalid) ||
+ (*hf == &hf_mgcp_param_extension) || (*hf == &hf_mgcp_param_extension_critical))
+ {
+ returnvalue = offset;
+ }
+
+ return returnvalue;
}
* tree - The tree from which to hang the structured information parsed
* from the first line of the MGCP message.
*/
-static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo,
- proto_tree *tree, mgcp_info_t *mi){
- gint tvb_current_offset,tvb_previous_offset,tvb_len,tvb_current_len;
- gint tokennum, tokenlen;
- char *transid = NULL;
- char *code = NULL;
- mgcp_type_t mgcp_type = MGCP_OTHERS;
- conversation_t* conversation;
- mgcp_call_info_key mgcp_call_key;
- mgcp_call_info_key *new_mgcp_call_key = NULL;
- mgcp_call_t *mgcp_call = NULL;
- nstime_t delta;
-
- static address null_address = { AT_NONE, 0, NULL };
- proto_item* (*my_proto_tree_add_string)(proto_tree*, int, tvbuff_t*, gint,
- gint, const char*);
- tvb_previous_offset = 0;
- tvb_len = tvb_length(tvb);
- tvb_current_len = tvb_len;
- tvb_current_offset = tvb_previous_offset;
- mi->is_duplicate = FALSE;
- mi->request_available = FALSE;
-
- if(tree){
- tokennum = 0;
-
- if(global_mgcp_dissect_tree){
- my_proto_tree_add_string = proto_tree_add_string;
- }
- else{
- my_proto_tree_add_string = proto_tree_add_string_hidden;
- }
-
- do {
- tvb_current_len = tvb_length_remaining(tvb,tvb_previous_offset);
- tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset,
- tvb_current_len, ' ');
- if(tvb_current_offset == -1){
- tvb_current_offset = tvb_len;
- tokenlen = tvb_current_len;
- }
- else{
- tokenlen = tvb_current_offset - tvb_previous_offset;
- }
- if(tokennum == 0){
- code = tvb_format_text(tvb,tvb_previous_offset,tokenlen);
- strncpy(mi->code,code,4);
- mi->code[4] = '\0';
- if(is_mgcp_verb(tvb,tvb_previous_offset,tvb_current_len)){
- mgcp_type = MGCP_REQUEST;
- my_proto_tree_add_string(tree,hf_mgcp_req_verb, tvb,
- tvb_previous_offset, tokenlen,
- code);
- }
- else if (is_mgcp_rspcode(tvb,tvb_previous_offset,tvb_current_len)){
- mgcp_type = MGCP_RESPONSE;
- my_proto_tree_add_string(tree,hf_mgcp_rsp_rspcode, tvb,
- tvb_previous_offset, tokenlen,
- code);
- }
- else {
- break;
- }
- }
- if(tokennum == 1){
- transid = tvb_format_text(tvb,tvb_previous_offset,tokenlen);
- /* XXX - what if this isn't a valid text string? */
- mi->transid = atol(transid);
- my_proto_tree_add_string(tree,hf_mgcp_transid, tvb,
- tvb_previous_offset, tokenlen,
- transid);
- }
- if(tokennum == 2){
- if(mgcp_type == MGCP_REQUEST){
- my_proto_tree_add_string(tree,hf_mgcp_req_endpoint, tvb,
- tvb_previous_offset, tokenlen,
- tvb_format_text(tvb, tvb_previous_offset,
- tokenlen));
- }
- else if(mgcp_type == MGCP_RESPONSE){
- if(tvb_current_offset < tvb_len){
- tokenlen = tvb_find_line_end(tvb, tvb_previous_offset,
- -1,&tvb_current_offset,FALSE);
- }
- else{
- tokenlen = tvb_current_len;
- }
- my_proto_tree_add_string(tree, hf_mgcp_rsp_rspstring, tvb,
- tvb_previous_offset, tokenlen,
- tvb_format_text(tvb, tvb_previous_offset,
- tokenlen));
- break;
- }
- }
- if( (tokennum == 3 && mgcp_type == MGCP_REQUEST) ){
- if(tvb_current_offset < tvb_len ){
- tokenlen = tvb_find_line_end(tvb, tvb_previous_offset,
- -1,&tvb_current_offset,FALSE);
- }
- else{
- tokenlen = tvb_current_len;
- }
- my_proto_tree_add_string(tree,hf_mgcp_version, tvb,
- tvb_previous_offset, tokenlen,
- tvb_format_text(tvb,tvb_previous_offset,
- tokenlen));
- break;
- }
- if(tvb_current_offset < tvb_len){
- tvb_previous_offset = tvb_skip_wsp(tvb, tvb_current_offset,
- tvb_current_len);
- }
- tokennum++;
- } while( tvb_current_offset < tvb_len && tvb_previous_offset < tvb_len
- && tokennum <= 3);
-
- switch (mgcp_type){
- case MGCP_RESPONSE:
- proto_tree_add_boolean_hidden(tree, hf_mgcp_rsp, tvb, 0, 0, TRUE);
- /* Check for MGCP response. A response must match a call that
- we've seen, and the response must be sent to the same
- port and address that the call came from, and must
- come from the port to which the call was sent.
-
- If the transport is connection-oriented (we check, for
- now, only for "pinfo->ptype" of PT_TCP), we take
- into account the address from which the call was sent
- and the address to which the call was sent, because
- the addresses of the two endpoints should be the same
- for all calls and replies.
-
- If the transport is connectionless, we don't worry
- about the address to which the call was sent and from
- which the reply was sent, because there's no
- guarantee that the reply will come from the address
- to which the call was sent. */
- if (pinfo->ptype == PT_TCP) {
- conversation = find_conversation(&pinfo->src,
- &pinfo->dst, pinfo->ptype, pinfo->srcport,
- pinfo->destport, 0);
- } else {
- /*
- * XXX - can we just use NO_ADDR_B? Unfortunately,
- * you currently still have to pass a non-null
- * pointer for the second address argument even
- * if you do that.
- */
- conversation = find_conversation(&null_address,
- &pinfo->dst, pinfo->ptype, pinfo->srcport,
- pinfo->destport, 0);
- }
- if (conversation != NULL) {
- /* look only for matching request, if
- matching conversation is available. */
- mgcp_call_key.transid = mi->transid;
- mgcp_call_key.conversation = conversation;
- mgcp_call = g_hash_table_lookup(mgcp_calls, &mgcp_call_key);
- if(mgcp_call) {
- /* Indicate the frame to which this is a reply. */
- if(mgcp_call->req_num){
- mi->request_available = TRUE;
- mgcp_call->responded = TRUE;
- strcpy(mi->code,mgcp_call->code);
- proto_tree_add_uint_format(tree, hf_mgcp_req_frame,
- tvb, 0, 0, mgcp_call->req_num,
- "This is a response to a request in frame %u",
- mgcp_call->req_num);
- delta.secs= pinfo->fd->abs_secs-mgcp_call->req_time.secs;
- delta.nsecs=pinfo->fd->abs_usecs*1000-mgcp_call->req_time.nsecs;
- if(delta.nsecs<0){
- delta.nsecs+=1000000000;
- delta.secs--;
+static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+ gint tvb_current_offset,tvb_previous_offset,tvb_len,tvb_current_len;
+ gint tokennum, tokenlen;
+ char *transid = NULL;
+ char *code = NULL;
+ char *endpointId = NULL;
+ mgcp_type_t mgcp_type = MGCP_OTHERS;
+ conversation_t* conversation;
+ mgcp_call_info_key mgcp_call_key;
+ mgcp_call_info_key *new_mgcp_call_key = NULL;
+ mgcp_call_t *mgcp_call = NULL;
+ nstime_t delta;
+ gint rspcode = 0;
+ const gchar *verb_description = "";
+ char code_with_verb[64] = ""; /* To fit "<4-letter-code> (<longest-verb>)" */
+
+ static address null_address = { AT_NONE, 0, NULL };
+ tvb_previous_offset = 0;
+ tvb_len = tvb_length(tvb);
+ tvb_current_len = tvb_len;
+ tvb_current_offset = tvb_previous_offset;
+ mi->is_duplicate = FALSE;
+ mi->request_available = FALSE;
+
+ if (tree)
+ {
+ tokennum = 0;
+
+ do
+ {
+ tvb_current_len = tvb_length_remaining(tvb,tvb_previous_offset);
+ tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_current_len, ' ');
+ if (tvb_current_offset == -1)
+ {
+ tvb_current_offset = tvb_len;
+ tokenlen = tvb_current_len;
+ }
+ else
+ {
+ tokenlen = tvb_current_offset - tvb_previous_offset;
+ }
+ if (tokennum == 0)
+ {
+ if (tokenlen > 4)
+ THROW(ReportedBoundsError);
+ code = tvb_format_text(tvb,tvb_previous_offset,tokenlen);
+ strncpy(mi->code,code,4);
+ mi->code[4] = '\0';
+ if (is_mgcp_verb(tvb,tvb_previous_offset,tvb_current_len,&verb_description))
+ {
+ mgcp_type = MGCP_REQUEST;
+ if (verb_description != NULL)
+ {
+ /* Can show verb along with code if known */
+ sprintf(code_with_verb, "%s (%s)", code, verb_description);
+ }
+
+ proto_tree_add_string_format(tree, hf_mgcp_req_verb, tvb,
+ tvb_previous_offset, tokenlen,
+ code, "%s",
+ strlen(code_with_verb) ? code_with_verb : code);
+ }
+ else
+ if (is_mgcp_rspcode(tvb,tvb_previous_offset,tvb_current_len))
+ {
+ mgcp_type = MGCP_RESPONSE;
+ rspcode = atoi(code);
+ mi->rspcode = rspcode;
+ proto_tree_add_uint(tree,hf_mgcp_rsp_rspcode, tvb,
+ tvb_previous_offset, tokenlen, rspcode);
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (tokennum == 1)
+ {
+ transid = tvb_format_text(tvb,tvb_previous_offset,tokenlen);
+ /* XXX - what if this isn't a valid text string? */
+ mi->transid = atol(transid);
+ proto_tree_add_string(tree, hf_mgcp_transid, tvb,
+ tvb_previous_offset, tokenlen, transid);
+ }
+ if (tokennum == 2)
+ {
+ if (mgcp_type == MGCP_REQUEST)
+ {
+ endpointId = tvb_format_text(tvb, tvb_previous_offset,tokenlen);
+ mi->endpointId = ep_strdup(endpointId);
+ proto_tree_add_string(tree,hf_mgcp_req_endpoint, tvb,
+ tvb_previous_offset, tokenlen, endpointId);
+ }
+ else
+ if (mgcp_type == MGCP_RESPONSE)
+ {
+ if (tvb_current_offset < tvb_len)
+ {
+ tokenlen = tvb_find_line_end(tvb, tvb_previous_offset,
+ -1, &tvb_current_offset, FALSE);
+ }
+ else
+ {
+ tokenlen = tvb_current_len;
+ }
+ proto_tree_add_string(tree, hf_mgcp_rsp_rspstring, tvb,
+ tvb_previous_offset, tokenlen,
+ tvb_format_text(tvb, tvb_previous_offset,
+ tokenlen));
+ break;
+ }
+ }
+
+ if ((tokennum == 3 && mgcp_type == MGCP_REQUEST))
+ {
+ if (tvb_current_offset < tvb_len )
+ {
+ tokenlen = tvb_find_line_end(tvb, tvb_previous_offset,
+ -1, &tvb_current_offset,FALSE);
+ }
+ else
+ {
+ tokenlen = tvb_current_len;
}
- proto_tree_add_time(tree, hf_mgcp_time, tvb, 0, 0,
- &delta);
+ proto_tree_add_string(tree,hf_mgcp_version, tvb,
+ tvb_previous_offset, tokenlen,
+ tvb_format_text(tvb,tvb_previous_offset,
+ tokenlen));
+ break;
}
+ if (tvb_current_offset < tvb_len)
+ {
+ tvb_previous_offset = tvb_skip_wsp(tvb, tvb_current_offset,
+ tvb_current_len);
+ }
+ tokennum++;
+ } while (tvb_current_offset < tvb_len && tvb_previous_offset < tvb_len && tokennum <= 3);
+
+ switch (mgcp_type)
+ {
+ case MGCP_RESPONSE:
+ proto_tree_add_boolean_hidden(tree, hf_mgcp_rsp, tvb, 0, 0, TRUE);
+ /* Check for MGCP response. A response must match a call that
+ we've seen, and the response must be sent to the same
+ port and address that the call came from, and must
+ come from the port to which the call was sent.
+
+ If the transport is connection-oriented (we check, for
+ now, only for "pinfo->ptype" of PT_TCP), we take
+ into account the address from which the call was sent
+ and the address to which the call was sent, because
+ the addresses of the two endpoints should be the same
+ for all calls and replies.
+
+ If the transport is connectionless, we don't worry
+ about the address to which the call was sent and from
+ which the reply was sent, because there's no
+ guarantee that the reply will come from the address
+ to which the call was sent. */
+ if (pinfo->ptype == PT_TCP)
+ {
+ conversation = find_conversation(pinfo->fd->num, &pinfo->src,
+ &pinfo->dst, pinfo->ptype, pinfo->srcport,
+ pinfo->destport, 0);
+ }
+ else
+ {
+ /* XXX - can we just use NO_ADDR_B? Unfortunately,
+ * you currently still have to pass a non-null
+ * pointer for the second address argument even
+ * if you do that.
+ */
+ conversation = find_conversation(pinfo->fd->num, &null_address,
+ &pinfo->dst, pinfo->ptype, pinfo->srcport,
+ pinfo->destport, 0);
+ }
+ if (conversation != NULL)
+ {
+ /* Look only for matching request, if
+ matching conversation is available. */
+ mgcp_call_key.transid = mi->transid;
+ mgcp_call_key.conversation = conversation;
+ mgcp_call = g_hash_table_lookup(mgcp_calls, &mgcp_call_key);
+ if (mgcp_call)
+ {
+ /* Indicate the frame to which this is a reply. */
+ if (mgcp_call->req_num)
+ {
+ proto_item* item;
+ mi->request_available = TRUE;
+ mgcp_call->responded = TRUE;
+ mi->req_num = mgcp_call->req_num;
+ strcpy(mi->code,mgcp_call->code);
+ item = proto_tree_add_uint_format(tree, hf_mgcp_req_frame,
+ tvb, 0, 0, mgcp_call->req_num,
+ "This is a response to a request in frame %u",
+ mgcp_call->req_num);
+ PROTO_ITEM_SET_GENERATED(item);
+ nstime_delta(&delta, &pinfo->fd->abs_ts, &mgcp_call->req_time);
+ item = proto_tree_add_time(tree, hf_mgcp_time, tvb, 0, 0, &delta);
+ PROTO_ITEM_SET_GENERATED(item);
+ }
- if (mgcp_call->rsp_num == 0) {
- /* We have not yet seen a response to that call, so
- this must be the first response; remember its
- frame number. */
- mgcp_call->rsp_num = pinfo->fd->num;
- } else {
- /* We have seen a response to this call - but was it
- *this* response? */
- if (mgcp_call->rsp_num != pinfo->fd->num) {
- /* No, so it's a duplicate response.
- Mark it as such. */
- mi->is_duplicate = TRUE;
- if (check_col(pinfo->cinfo, COL_INFO)) {
- col_append_fstr(pinfo->cinfo, COL_INFO,
- ", Duplicate Response %u",mi->transid);
- if (tree) {
- proto_tree_add_uint_hidden(tree,
- hf_mgcp_dup, tvb, 0,0, mi->transid);
- proto_tree_add_uint_hidden(tree,
- hf_mgcp_rsp_dup, tvb, 0,0, mi->transid);
+ if (mgcp_call->rsp_num == 0)
+ {
+ /* We have not yet seen a response to that call, so
+ this must be the first response; remember its
+ frame number. */
+ mgcp_call->rsp_num = pinfo->fd->num;
+ }
+ else
+ {
+ /* We have seen a response to this call - but was it
+ *this* response? (disregard provisional responses) */
+ if ((mgcp_call->rsp_num != pinfo->fd->num) &&
+ (mi->rspcode >= 200) &&
+ (mi->rspcode == mgcp_call->rspcode))
+ {
+ /* No, so it's a duplicate response. Mark it as such. */
+ mi->is_duplicate = TRUE;
+ if (check_col(pinfo->cinfo, COL_INFO))
+ {
+ col_append_fstr(pinfo->cinfo, COL_INFO,
+ ", Duplicate Response %u",
+ mi->transid);
+ }
+ if (tree)
+ {
+ proto_item* item;
+ proto_tree_add_uint_hidden(tree, hf_mgcp_dup, tvb, 0,0, mi->transid);
+ item = proto_tree_add_uint(tree, hf_mgcp_rsp_dup,
+ tvb, 0, 0, mi->transid);
+ PROTO_ITEM_SET_GENERATED(item);
+ item = proto_tree_add_uint(tree, hf_mgcp_rsp_dup_frame,
+ tvb, 0, 0, mgcp_call->rsp_num);
+ PROTO_ITEM_SET_GENERATED(item);
+ }
+ }
}
+ /* Now store the response code (after comparison above) */
+ mgcp_call->rspcode = mi->rspcode;
+ }
+ }
+ break;
+ case MGCP_REQUEST:
+ proto_tree_add_boolean_hidden(tree, hf_mgcp_req, tvb, 0, 0, TRUE);
+ /* Keep track of the address and port whence the call came,
+ * and the port to which the call is being sent, so that
+ * we can match up calls with replies.
+ *
+ * If the transport is connection-oriented (we check, for
+ * now, only for "pinfo->ptype" of PT_TCP), we take
+ * into account the address from which the call was sent
+ * and the address to which the call was sent, because
+ * the addresses of the two endpoints should be the same
+ * for all calls and replies.
+ *
+ * If the transport is connectionless, we don't worry
+ * about the address to which the call was sent and from
+ * which the reply was sent, because there's no
+ * guarantee that the reply will come from the address
+ * to which the call was sent.
+ */
+ if (pinfo->ptype == PT_TCP)
+ {
+ conversation = find_conversation(pinfo->fd->num, &pinfo->src,
+ &pinfo->dst, pinfo->ptype, pinfo->srcport,
+ pinfo->destport, 0);
+ }
+ else
+ {
+ /*
+ * XXX - can we just use NO_ADDR_B? Unfortunately,
+ * you currently still have to pass a non-null
+ * pointer for the second address argument even
+ * if you do that.
+ */
+ conversation = find_conversation(pinfo->fd->num, &pinfo->src,
+ &null_address, pinfo->ptype, pinfo->srcport,
+ pinfo->destport, 0);
+ }
+ if (conversation == NULL)
+ {
+ /* It's not part of any conversation - create a new one. */
+ if (pinfo->ptype == PT_TCP)
+ {
+ conversation = conversation_new(pinfo->fd->num, &pinfo->src,
+ &pinfo->dst, pinfo->ptype, pinfo->srcport,
+ pinfo->destport, 0);
+ }
+ else
+ {
+ conversation = conversation_new(pinfo->fd->num, &pinfo->src,
+ &null_address, pinfo->ptype, pinfo->srcport,
+ pinfo->destport, 0);
}
}
- }
- }
- }
- break;
- case MGCP_REQUEST:
- proto_tree_add_boolean_hidden(tree, hf_mgcp_req, tvb, 0, 0, TRUE);
- /* Keep track of the address and port whence the call came,
- and the port to which the call is being sent, so that
- we can match up calls with replies.
-
- If the transport is connection-oriented (we check, for
- now, only for "pinfo->ptype" of PT_TCP), we take
- into account the address from which the call was sent
- and the address to which the call was sent, because
- the addresses of the two endpoints should be the same
- for all calls and replies.
-
- If the transport is connectionless, we don't worry
- about the address to which the call was sent and from
- which the reply was sent, because there's no
- guarantee that the reply will come from the address
- to which the call was sent. */
- if (pinfo->ptype == PT_TCP) {
- conversation = find_conversation(&pinfo->src,
- &pinfo->dst, pinfo->ptype, pinfo->srcport,
- pinfo->destport, 0);
- } else {
- /*
- * XXX - can we just use NO_ADDR_B? Unfortunately,
- * you currently still have to pass a non-null
- * pointer for the second address argument even
- * if you do that.
- */
- conversation = find_conversation(&pinfo->src,
- &null_address, pinfo->ptype, pinfo->srcport,
- pinfo->destport, 0);
- }
- if (conversation == NULL) {
- /* It's not part of any conversation - create a new
- one. */
- if (pinfo->ptype == PT_TCP) {
- conversation = conversation_new(&pinfo->src,
- &pinfo->dst, pinfo->ptype, pinfo->srcport,
- pinfo->destport, 0);
- } else {
- conversation = conversation_new(&pinfo->src,
- &null_address, pinfo->ptype, pinfo->srcport,
- pinfo->destport, 0);
- }
- }
- /* prepare the key data */
- mgcp_call_key.transid = mi->transid;
- mgcp_call_key.conversation = conversation;
-
- /* look up the request */
- mgcp_call = g_hash_table_lookup(mgcp_calls, &mgcp_call_key);
- if (mgcp_call != NULL) {
- /* We've seen a request with this TRANSID, with the same
- source and destination, before - but was it
- *this* request? */
- if (pinfo->fd->num != mgcp_call->req_num) {
- /* No, so it's a duplicate request.
- Mark it as such. */
- mi->is_duplicate = TRUE;
- if (check_col(pinfo->cinfo, COL_INFO)) {
- col_append_fstr(pinfo->cinfo, COL_INFO,
- ", Duplicate Request %u",mi->transid);
- if (tree) {
- proto_tree_add_uint_hidden(tree,
- hf_mgcp_dup, tvb, 0,0, mi->transid);
- proto_tree_add_uint_hidden(tree,
- hf_mgcp_req_dup, tvb, 0,0, mi->transid);
+ /* Prepare the key data */
+ mgcp_call_key.transid = mi->transid;
+ mgcp_call_key.conversation = conversation;
+
+ /* Look up the request */
+ mgcp_call = g_hash_table_lookup(mgcp_calls, &mgcp_call_key);
+ if (mgcp_call != NULL)
+ {
+ /* We've seen a request with this TRANSID, with the same
+ source and destination, before - but was it
+ *this* request? */
+ if (pinfo->fd->num != mgcp_call->req_num)
+ {
+ /* No, so it's a duplicate request. Mark it as such. */
+ mi->is_duplicate = TRUE;
+ mi->req_num = mgcp_call->req_num;
+ if (check_col(pinfo->cinfo, COL_INFO))
+ {
+ col_append_fstr(pinfo->cinfo, COL_INFO,
+ ", Duplicate Request %u",
+ mi->transid);
+ }
+ if (tree)
+ {
+ proto_item* item;
+ proto_tree_add_uint_hidden(tree, hf_mgcp_dup, tvb, 0,0, mi->transid);
+ item = proto_tree_add_uint(tree, hf_mgcp_req_dup, tvb, 0,0, mi->transid);
+ PROTO_ITEM_SET_GENERATED(item);
+ item = proto_tree_add_uint(tree, hf_mgcp_req_dup_frame, tvb, 0,0, mi->req_num);
+ PROTO_ITEM_SET_GENERATED(item);
+ }
+ }
}
- }
+ else
+ {
+ /* Prepare the value data.
+ "req_num" and "rsp_num" are frame numbers;
+ frame numbers are 1-origin, so we use 0
+ to mean "we don't yet know in which frame
+ the reply for this call appears". */
+ new_mgcp_call_key = g_mem_chunk_alloc(mgcp_call_info_key_chunk);
+ *new_mgcp_call_key = mgcp_call_key;
+ mgcp_call = g_mem_chunk_alloc(mgcp_call_info_value_chunk);
+ mgcp_call->req_num = pinfo->fd->num;
+ mgcp_call->rsp_num = 0;
+ mgcp_call->transid = mi->transid;
+ mgcp_call->responded = FALSE;
+ mgcp_call->req_time=pinfo->fd->abs_ts;
+ strcpy(mgcp_call->code,mi->code);
+
+ /* Store it */
+ g_hash_table_insert(mgcp_calls, new_mgcp_call_key, mgcp_call);
+ }
+ if (mgcp_call && mgcp_call->rsp_num)
+ {
+ proto_item* item = proto_tree_add_uint_format(tree, hf_mgcp_rsp_frame,
+ tvb, 0, 0, mgcp_call->rsp_num,
+ "The response to this request is in frame %u",
+ mgcp_call->rsp_num);
+ PROTO_ITEM_SET_GENERATED(item);
+ }
+ break;
+ default:
+ break;
+ }
+
+ mi->mgcp_type = mgcp_type;
+ if (mgcp_call)
+ {
+ mi->req_time.secs=mgcp_call->req_time.secs;
+ mi->req_time.nsecs=mgcp_call->req_time.nsecs;
}
}
- else {
- /* Prepare the value data.
- "req_num" and "rsp_num" are frame numbers;
- frame numbers are 1-origin, so we use 0
- to mean "we don't yet know in which frame
- the reply for this call appears". */
- new_mgcp_call_key = g_mem_chunk_alloc(mgcp_call_info_key_chunk);
- *new_mgcp_call_key = mgcp_call_key;
- mgcp_call = g_mem_chunk_alloc(mgcp_call_info_value_chunk);
- mgcp_call->req_num = pinfo->fd->num;
- mgcp_call->rsp_num = 0;
- mgcp_call->transid = mi->transid;
- mgcp_call->responded = FALSE;
- mgcp_call->req_time.secs=pinfo->fd->abs_secs;
- mgcp_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
- strcpy(mgcp_call->code,mi->code);
-
- /* store it */
- g_hash_table_insert(mgcp_calls, new_mgcp_call_key, mgcp_call);
- }
- if(mgcp_call && mgcp_call->rsp_num){
- proto_tree_add_uint_format(tree, hf_mgcp_rsp_frame,
- tvb, 0, 0, mgcp_call->rsp_num,
- "The response to this request is in frame %u",
- mgcp_call->rsp_num);
- }
- break;
- default:
- break;
- }
- mi->mgcp_type = mgcp_type;
- if(mgcp_call) {
- mi->req_time.secs=mgcp_call->req_time.secs;
- mi->req_time.nsecs=mgcp_call->req_time.nsecs;
- }
- }
- tap_queue_packet(mgcp_tap, pinfo, mi);
+
+ tap_queue_packet(mgcp_tap, pinfo, mi);
}
/*
* tvb - The tvb containing the parameters of an MGCP message. This
* tvb is presumed to ONLY contain the part of the MGCP
* message which contains the MGCP parameters.
- * pinfo - The packet info for the packet. This is not really used
- * by this function but is passed through so as to retain the
- * style of a dissector.
* tree - The tree from which to hang the structured information parsed
* from the parameters of the MGCP message.
*/
-static void dissect_mgcp_params(tvbuff_t *tvb, proto_tree *tree){
- int linelen, tokenlen, *my_param;
- gint tvb_lineend,tvb_current_len, tvb_linebegin,tvb_len;
- gint tvb_tokenbegin;
- proto_tree *mgcp_param_ti, *mgcp_param_tree;
- proto_item* (*my_proto_tree_add_string)(proto_tree*, int, tvbuff_t*, gint,
- gint, const char*);
-
- tvb_len = tvb_length(tvb);
- tvb_linebegin = 0;
- tvb_current_len = tvb_length_remaining(tvb,tvb_linebegin);
- tvb_lineend = tvb_linebegin;
-
- if(tree){
- if(global_mgcp_dissect_tree){
- my_proto_tree_add_string = proto_tree_add_string;
- mgcp_param_ti = proto_tree_add_item(tree, proto_mgcp, tvb,
- tvb_linebegin, tvb_len, FALSE);
- proto_item_set_text(mgcp_param_ti, "Parameters");
- mgcp_param_tree = proto_item_add_subtree(mgcp_param_ti, ett_mgcp_param);
- }
- else{
- my_proto_tree_add_string = proto_tree_add_string_hidden;
- mgcp_param_tree = tree;
- mgcp_param_ti = NULL;
- }
-
- /* Parse the parameters */
- while(tvb_lineend < tvb_len){
- linelen = tvb_find_line_end(tvb, tvb_linebegin, -1,&tvb_lineend,FALSE);
- tvb_tokenbegin = tvb_parse_param(tvb, tvb_linebegin, linelen,
- &my_param);
- if( my_param != NULL ){
- tokenlen = tvb_find_line_end(tvb,tvb_tokenbegin,-1,&tvb_lineend,FALSE);
- my_proto_tree_add_string(mgcp_param_tree,*my_param, tvb,
- tvb_linebegin, linelen,
- tvb_format_text(tvb,tvb_tokenbegin,
- tokenlen));
- }
- tvb_linebegin = tvb_lineend;
- }
- }
+static void dissect_mgcp_params(tvbuff_t *tvb, proto_tree *tree)
+{
+ int linelen, tokenlen, *my_param;
+ gint tvb_lineend,tvb_current_len, tvb_linebegin,tvb_len,old_lineend;
+ gint tvb_tokenbegin;
+ proto_tree *mgcp_param_ti, *mgcp_param_tree;
+
+ tvb_len = tvb_length(tvb);
+ tvb_linebegin = 0;
+ tvb_current_len = tvb_length_remaining(tvb,tvb_linebegin);
+ tvb_lineend = tvb_linebegin;
+
+ if (tree)
+ {
+ mgcp_param_ti = proto_tree_add_item(tree, hf_mgcp_params, tvb,
+ tvb_linebegin, tvb_len, FALSE);
+ proto_item_set_text(mgcp_param_ti, "Parameters");
+ mgcp_param_tree = proto_item_add_subtree(mgcp_param_ti, ett_mgcp_param);
+
+ /* Parse the parameters */
+ while (tvb_lineend < tvb_len)
+ {
+ old_lineend = tvb_lineend;
+ linelen = tvb_find_line_end(tvb, tvb_linebegin, -1,&tvb_lineend,FALSE);
+ tvb_tokenbegin = tvb_parse_param(tvb, tvb_linebegin, linelen, &my_param);
+
+ if (my_param)
+ {
+ if (*my_param == hf_mgcp_param_connectionparam)
+ {
+ tokenlen = tvb_find_line_end(tvb,tvb_tokenbegin,-1,&tvb_lineend,FALSE);
+ dissect_mgcp_connectionparams(mgcp_param_tree, tvb, tvb_linebegin,
+ tvb_tokenbegin - tvb_linebegin, tokenlen);
+ }
+ else
+ if (*my_param == hf_mgcp_param_localconnoptions)
+ {
+ tokenlen = tvb_find_line_end(tvb,tvb_tokenbegin,-1,&tvb_lineend,FALSE);
+ dissect_mgcp_localconnectionoptions(mgcp_param_tree, tvb, tvb_linebegin,
+ tvb_tokenbegin - tvb_linebegin, tokenlen);
+ }
+ else
+ {
+ tokenlen = tvb_find_line_end(tvb,tvb_tokenbegin,-1,&tvb_lineend,FALSE);
+ proto_tree_add_string(mgcp_param_tree,*my_param, tvb,
+ tvb_linebegin, linelen,
+ tvb_format_text(tvb,tvb_tokenbegin, tokenlen));
+ }
+ }
+
+ tvb_linebegin = tvb_lineend;
+ /* Its a infinite loop if we didn't advance (or went backwards) */
+ if (old_lineend >= tvb_lineend)
+ {
+ THROW(ReportedBoundsError);
+ }
+ }
+ }
+}
+
+/* Dissect the connection params */
+static void
+dissect_mgcp_connectionparams(proto_tree *parent_tree, tvbuff_t *tvb, gint offset, gint param_type_len, gint param_val_len)
+{
+ proto_tree *tree = parent_tree;
+ proto_item *item = NULL;
+
+ gchar *tokenline = NULL;
+ gchar **tokens = NULL;
+ gchar **typval = NULL;
+ guint i = 0;
+ guint tokenlen = 0;
+ int hf_uint = -1;
+ int hf_string = -1;
+
+ if (parent_tree)
+ {
+ item = proto_tree_add_item(parent_tree, hf_mgcp_param_connectionparam, tvb, offset, param_type_len+param_val_len, FALSE);
+ tree = proto_item_add_subtree(item, ett_mgcp_param_connectionparam);
+ }
+
+ /* The P: line */
+ offset += param_type_len; /* skip the P: */
+ tokenline = tvb_get_ephemeral_string(tvb, offset, param_val_len);
+
+ /* Split into type=value pairs separated by comma */
+ tokens = ep_strsplit(tokenline, ",", -1);
+
+ for (i = 0; tokens[i] != NULL; i++)
+ {
+ tokenlen = strlen(tokens[i]);
+ typval = ep_strsplit(tokens[i], "=", 2);
+ if ((typval[0] != NULL) && (typval[1] != NULL))
+ {
+ if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PS"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_ps;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "OS"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_os;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PR"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_pr;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "OR"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_or;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PL"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_pl;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "JI"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_ji;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "LA"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_la;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PC/RPS"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_pcrps;
+ } else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PC/ROS"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_pcros;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PC/RPL"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_pcrpl;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "PC/RJI"))
+ {
+ hf_uint = hf_mgcp_param_connectionparam_pcrji;
+ }
+ else if (!g_ascii_strncasecmp(g_strstrip(typval[0]), "X-", 2))
+ {
+ hf_string = hf_mgcp_param_connectionparam_x;
+ }
+ else
+ {
+ hf_uint = -1;
+ hf_string = -1;
+ }
+
+ if (tree)
+ {
+ if (hf_uint != -1)
+ {
+ proto_tree_add_uint(tree, hf_uint, tvb, offset, tokenlen, atol(typval[1]));
+ }
+ else if (hf_string != -1)
+ {
+ proto_tree_add_string(tree, hf_string, tvb, offset, tokenlen, g_strstrip(typval[1]));
+ }
+ else
+ {
+ proto_tree_add_text(tree, tvb, offset, tokenlen, "Unknown parameter: %s", tokens[i]);
+ }
+ }
+ }
+ else if (tree)
+ {
+ proto_tree_add_text(tree, tvb, offset, tokenlen, "Malformed parameter: %s", tokens[i]);
+ }
+ offset += tokenlen + 1; /* 1 extra for the delimiter */
+ }
+
}
+/* Dissect the local connection option */
+static void
+dissect_mgcp_localconnectionoptions(proto_tree *parent_tree, tvbuff_t *tvb, gint offset, gint param_type_len, gint param_val_len)
+{
+ proto_tree *tree = parent_tree;
+ proto_item *item = NULL;
+
+ gchar *tokenline = NULL;
+ gchar **tokens = NULL;
+ gchar **typval = NULL;
+ guint i = 0;
+ guint tokenlen = 0;
+ int hf_uint = -1;
+ int hf_string = -1;
+
+ if (parent_tree)
+ {
+ item = proto_tree_add_item(parent_tree, hf_mgcp_param_localconnoptions, tvb, offset, param_type_len+param_val_len, FALSE);
+ tree = proto_item_add_subtree(item, ett_mgcp_param_localconnectionoptions);
+ }
+
+ /* The L: line */
+ offset += param_type_len; /* skip the L: */
+ tokenline = tvb_get_ephemeral_string(tvb, offset, param_val_len);
+
+ /* Split into type=value pairs separated by comma */
+ tokens = ep_strsplit(tokenline, ",", -1);
+ for (i = 0; tokens[i] != NULL; i++)
+ {
+ hf_uint = -1;
+ hf_string = -1;
+
+ tokenlen = strlen(tokens[i]);
+ typval = ep_strsplit(tokens[i], ":", 2);
+ if ((typval[0] != NULL) && (typval[1] != NULL))
+ {
+ if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "p"))
+ {
+ hf_uint = hf_mgcp_param_localconnoptions_p;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "a"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_a;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "s"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_s;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "e"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_e;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "sc-rtp"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_scrtp;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "sc-rtcp"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_scrtcp;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "b"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_b;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "es-ccd"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_esccd;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "es-cci"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_escci;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "dq-gi"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_dqgi;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "dq-rd"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_dqrd;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "dq-ri"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_dqri;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "dq-rr"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_dqrr;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "k"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_k;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "gc"))
+ {
+ hf_uint = hf_mgcp_param_localconnoptions_gc;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "fmtp"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_fmtp;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "nt"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_nt;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "o-fmtp"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_ofmtp;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "r"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_r;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "t"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_t;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "r-cnf"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_rcnf;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "r-dir"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_rdir;
+ }
+ else if (!g_ascii_strcasecmp(g_strstrip(typval[0]), "r-sh"))
+ {
+ hf_string = hf_mgcp_param_localconnoptions_rsh;
+ }
+ else
+ {
+ hf_uint = -1;
+ hf_string = -1;
+ }
+
+ /* Add item */
+ if (tree)
+ {
+ if (hf_uint != -1)
+ {
+ proto_tree_add_uint(tree, hf_uint, tvb, offset, tokenlen, atol(typval[1]));
+ }
+ else if (hf_string != -1)
+ {
+ proto_tree_add_string(tree, hf_string, tvb, offset, tokenlen, g_strstrip(typval[1]));
+ }
+ else
+ {
+ proto_tree_add_text(tree, tvb, offset, tokenlen, "Unknown parameter: %s", tokens[i]);
+ }
+ }
+ }
+ else if (tree)
+ {
+ proto_tree_add_text(tree, tvb, offset, tokenlen, "Malformed parameter: %s", tokens[i]);
+ }
+ offset += tokenlen + 1; /* 1 extra for the delimiter */
+ }
+}
+
+
+
/*
* tvb_skip_wsp - Returns the position in tvb of the first non-whitespace
* character following offset or offset + maxlength -1 whichever
* character following offset or offset + maxlength -1 whichever
* is smaller.
*/
-static gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength){
- gint counter = offset;
- gint end = offset + maxlength,tvb_len;
- guint8 tempchar;
- tvb_len = tvb_length(tvb);
- end = offset + maxlength;
- if(end >= tvb_len){
- end = tvb_len;
- }
- for(counter = offset; counter < end &&
- ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
- tempchar == '\t');counter++);
- return (counter);
+static gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength)
+{
+ gint counter = offset;
+ gint end = offset + maxlength,tvb_len;
+ guint8 tempchar;
+
+ /* Get the length remaining */
+ tvb_len = tvb_length(tvb);
+ end = offset + maxlength;
+ if (end >= tvb_len)
+ {
+ end = tvb_len;
+ }
+
+ /* Skip past spaces and tabs until run out or meet something else */
+ for (counter = offset;
+ counter < end &&
+ ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
+ tempchar == '\t');
+ counter++);
+
+ return (counter);
}
/*
* Returns: The length from offset to the first character BEFORE
* the null line..
*/
-static gint tvb_find_null_line(tvbuff_t* tvb, gint offset,
- gint len, gint* next_offset){
- gint tvb_lineend,tvb_current_len,tvb_linebegin,maxoffset;
- guint tempchar;
-
- tvb_linebegin = offset;
- tvb_lineend = tvb_linebegin;
-
- /* Simple setup to allow for the traditional -1 search to the end
- * of the tvbuff
- */
- if(len != -1){
- tvb_current_len = len;
- }
- else{
- tvb_current_len = tvb_length_remaining(tvb,offset);
- }
- maxoffset = (tvb_current_len - 1) + offset;
-
- /*
- * Loop around until we either find a line begining with a carriage return
- * or newline character or until we hit the end of the tvbuff.
- */
- do {
- tvb_linebegin = tvb_lineend;
- tvb_current_len = tvb_length_remaining(tvb,tvb_linebegin);
- tvb_find_line_end(tvb, tvb_linebegin, tvb_current_len, &tvb_lineend,FALSE);
- tempchar = tvb_get_guint8(tvb,tvb_linebegin);
- }
- while( tempchar != '\r' && tempchar != '\n' &&
- tvb_lineend <= maxoffset);
-
- *next_offset = tvb_lineend;
-
- if( tvb_lineend <= maxoffset ) {
- tvb_current_len = tvb_linebegin - offset;
- }
- else {
- tvb_current_len = tvb_length_remaining(tvb,offset);
- }
-
- return (tvb_current_len);
+static gint tvb_find_null_line(tvbuff_t* tvb, gint offset, gint len, gint* next_offset)
+{
+ gint tvb_lineend,tvb_current_len,tvb_linebegin,maxoffset;
+ guint tempchar;
+
+ tvb_linebegin = offset;
+ tvb_lineend = tvb_linebegin;
+
+ /* Simple setup to allow for the traditional -1 search to the end of the tvbuff */
+ if (len != -1)
+ {
+ tvb_current_len = len;
+ }
+ else
+ {
+ tvb_current_len = tvb_length_remaining(tvb,offset);
+ }
+
+ maxoffset = (tvb_current_len - 1) + offset;
+
+ /* Loop around until we either find a line begining with a carriage return
+ or newline character or until we hit the end of the tvbuff. */
+ do
+ {
+ tvb_linebegin = tvb_lineend;
+ tvb_current_len = tvb_length_remaining(tvb,tvb_linebegin);
+ tvb_find_line_end(tvb, tvb_linebegin, tvb_current_len, &tvb_lineend,FALSE);
+ tempchar = tvb_get_guint8(tvb,tvb_linebegin);
+ } while (tempchar != '\r' && tempchar != '\n' && tvb_lineend <= maxoffset);
+
+
+ *next_offset = tvb_lineend;
+
+ if (tvb_lineend <= maxoffset)
+ {
+ tvb_current_len = tvb_linebegin - offset;
+ }
+ else
+ {
+ tvb_current_len = tvb_length_remaining(tvb,offset);
+ }
+
+ return tvb_current_len;
}
/*
* the dot line or -1 if the character at offset is a .
* followed by a newline or a carriage return.
*/
-static gint tvb_find_dot_line(tvbuff_t* tvb, gint offset,
- gint len, gint* next_offset){
- gint tvb_current_offset, tvb_current_len, maxoffset,tvb_len;
- guint8 tempchar;
-
- tvb_current_offset = offset;
- tvb_current_len = len;
- tvb_len = tvb_length(tvb);
-
- if(len == -1){
- maxoffset = ( tvb_len - 1 );
- }
- else {
- maxoffset = (len - 1 ) + offset;
- }
- tvb_current_offset = offset -1;
- do {
- tvb_current_offset = tvb_find_guint8(tvb, tvb_current_offset+1,
- tvb_current_len, '.');
- tvb_current_len = maxoffset - tvb_current_offset + 1;
- /*
- * if we didn't find a . then break out of the loop
- */
- if(tvb_current_offset == -1){
- break;
- }
- /* do we have and characters following the . ? */
- if( tvb_current_offset < maxoffset ) {
- tempchar = tvb_get_guint8(tvb,tvb_current_offset+1);
- /*
- * are the characters that follow the dot a newline or carriage return ?
- */
- if(tempchar == '\r' || tempchar == '\n'){
- /*
- * do we have any charaters that proceed the . ?
- */
- if( tvb_current_offset == 0 ){
- break;
- }
- else {
- tempchar = tvb_get_guint8(tvb,tvb_current_offset-1);
- /*
- * are the characters that follow the dot a newline or a carriage
- * return ?
- */
- if(tempchar == '\r' || tempchar == '\n'){
- break;
- }
+static gint tvb_find_dot_line(tvbuff_t* tvb, gint offset, gint len, gint* next_offset)
+{
+ gint tvb_current_offset, tvb_current_len, maxoffset,tvb_len;
+ guint8 tempchar;
+ tvb_current_offset = offset;
+ tvb_current_len = len;
+ tvb_len = tvb_length(tvb);
+
+ if (len == -1)
+ {
+ maxoffset = tvb_len - 1;
}
- }
- }
- else if ( tvb_current_offset == maxoffset ) {
- if( tvb_current_offset == 0 ){
- break;
- }
- else {
- tempchar = tvb_get_guint8(tvb,tvb_current_offset-1);
- if(tempchar == '\r' || tempchar == '\n'){
- break;
+ else
+ {
+ maxoffset = (len - 1) + offset;
}
- }
- }
- } while (tvb_current_offset < maxoffset);
- /*
- * so now we either have the tvb_current_offset of a . in a dot line
- * or a tvb_current_offset of -1
- */
- if(tvb_current_offset == -1){
- tvb_current_offset = maxoffset +1;
- *next_offset = maxoffset + 1;
- }
- else {
- tvb_find_line_end(tvb,tvb_current_offset,tvb_current_len,next_offset,FALSE);
- }
-
- if( tvb_current_offset == offset ){
- tvb_current_len = -1;
- }
- else {
- tvb_current_len = tvb_current_offset - offset;
- }
- return tvb_current_len;
-}
+ tvb_current_offset = offset -1;
+
+ do
+ {
+ tvb_current_offset = tvb_find_guint8(tvb, tvb_current_offset+1,
+ tvb_current_len, '.');
+ tvb_current_len = maxoffset - tvb_current_offset + 1;
+
+ /* If we didn't find a . then break out of the loop */
+ if (tvb_current_offset == -1)
+ {
+ break;
+ }
-/* Start the functions we need for the plugin stuff */
+ /* Do we have and characters following the . ? */
+ if (tvb_current_offset < maxoffset)
+ {
+ tempchar = tvb_get_guint8(tvb,tvb_current_offset+1);
+ /* Are the characters that follow the dot a newline or carriage return ? */
+ if (tempchar == '\r' || tempchar == '\n')
+ {
+ /* Do we have any charaters that proceed the . ? */
+ if (tvb_current_offset == 0)
+ {
+ break;
+ }
+ else
+ {
+ tempchar = tvb_get_guint8(tvb,tvb_current_offset-1);
+
+ /* Are the characters that follow the dot a newline or a
+ carriage return ? */
+ if (tempchar == '\r' || tempchar == '\n')
+ {
+ break;
+ }
+ }
+ }
+ }
+ else
+ if (tvb_current_offset == maxoffset)
+ {
+ if (tvb_current_offset == 0)
+ {
+ break;
+ }
+ else
+ {
+ tempchar = tvb_get_guint8(tvb,tvb_current_offset-1);
+ if (tempchar == '\r' || tempchar == '\n')
+ {
+ break;
+ }
+ }
+ }
+ } while (tvb_current_offset < maxoffset);
-#ifndef ENABLE_STATIC
-G_MODULE_EXPORT void
-plugin_reg_handoff(void){
- proto_reg_handoff_mgcp();
-}
+ /*
+ * So now we either have the tvb_current_offset of a . in a dot line
+ * or a tvb_current_offset of -1
+ */
+ if (tvb_current_offset == -1)
+ {
+ tvb_current_offset = maxoffset +1;
+ *next_offset = maxoffset + 1;
+ }
+ else
+ {
+ tvb_find_line_end(tvb,tvb_current_offset,tvb_current_len,next_offset,FALSE);
+ }
-G_MODULE_EXPORT void
-plugin_init(plugin_address_table_t *pat
-#ifndef PLUGINS_NEED_ADDRESS_TABLE
-_U_
-#endif
-){
- /* initialise the table of pointers needed in Win32 DLLs */
- plugin_address_table_init(pat);
- /* register the new protocol, protocol fields, and subtrees */
- if (proto_mgcp == -1) { /* execute protocol initialization only once */
- proto_register_mgcp();
- }
-}
+ if (tvb_current_offset == offset)
+ {
+ tvb_current_len = -1;
+ }
+ else
+ {
+ tvb_current_len = tvb_current_offset - offset;
+ }
-#endif
+ return tvb_current_len;
+}
-/* End the functions we need for plugin stuff */
git.samba.org / obnox / wireshark / wip.git / blobdiff