X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=plugins%2Fmgcp%2Fpacket-mgcp.c;h=85f6db015eccdc1d59e78c6d9c24ee4ba6fd20ed;hb=4d005106f956ff792cd46cb90050f5ebf13f133e;hp=25f1e14eb98b09f3eda257f0fd4d7e62ccfc4802;hpb=133c26d8d697ca168f04c361ab5225aeb2c90c54;p=obnox%2Fwireshark%2Fwip.git diff --git a/plugins/mgcp/packet-mgcp.c b/plugins/mgcp/packet-mgcp.c index 25f1e14eb9..85f6db015e 100644 --- a/plugins/mgcp/packet-mgcp.c +++ b/plugins/mgcp/packet-mgcp.c @@ -1,13 +1,21 @@ /* 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 + * Copyright (c) 2004 by Thomas Anders * - * Ethereal - Network traffic analyzer - * By Gerald Combs + * Wireshark - Network traffic analyzer + * By Gerald Combs * Copyright 1999 Gerald Combs * * This program is free software; you can redistribute it and/or @@ -29,27 +37,18 @@ #include "config.h" #endif -#include "plugins/plugin_api.h" - -#include "moduleinfo.h" - -#include -#include -#include #include -#include #include #include -#include -#include "prefs.h" -#include +#include +#include +#include #include +#include #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 @@ -57,8 +56,6 @@ G_MODULE_EXPORT const gchar version[] = VERSION; #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; @@ -75,6 +72,7 @@ static int hf_mgcp_transid = -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; @@ -83,6 +81,29 @@ static int hf_mgcp_param_secondconnectionid = -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; @@ -91,6 +112,18 @@ static int hf_mgcp_param_signalreq = -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; @@ -99,19 +132,103 @@ static int hf_mgcp_param_reqinfo = -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 @@ -131,16 +248,12 @@ static int mgcp_tap = -1; * 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; /* @@ -153,34 +266,35 @@ static int callagent_tcp_port = 0; 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; @@ -190,198 +304,238 @@ 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); + } + } } @@ -389,287 +543,404 @@ dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *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); } /* @@ -681,41 +952,52 @@ proto_reg_handoff_mgcp(void) * 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 @@ -726,23 +1008,32 @@ static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength){ * 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; } /* @@ -757,15 +1048,12 @@ static gboolean is_mgcp_rspcode(tvbuff_t *tvb, gint offset, gint maxlength){ * 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. * @@ -781,154 +1069,291 @@ static gboolean is_rfc2234_alpha(guint8 c){ * 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; } @@ -948,320 +1373,380 @@ static gint tvb_parse_param(tvbuff_t* tvb, gint offset, gint len, int** hf){ * 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> ()" */ + + 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); } /* @@ -1274,56 +1759,342 @@ static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo, * 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 @@ -1339,19 +2110,28 @@ static void dissect_mgcp_params(tvbuff_t *tvb, proto_tree *tree){ * 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); } /* @@ -1374,48 +2154,49 @@ static gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength){ * 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; } /* @@ -1439,113 +2220,103 @@ static gint tvb_find_null_line(tvbuff_t* tvb, gint offset, * 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 */