From Martin Mathieson:

a first step of cleaning up the mgcp dissector:

- re-indenting/formatting the file as it was tricky to follow
- some code simplification and commenting (more to do)
- losing some unnecessary includes (not needed under linux at least...)
- show duplicate request and response fields in tree (previously hidden)
- improved duplicate response detection
- fix a couple of problems shown by fuzz testing

svn path=/trunk/; revision=14181

2 files changed, 1614 insertions, 1427 deletions

diff --git a/plugins/mgcp/packet-mgcp.c b/plugins/mgcp/packet-mgcp.c
index 2861831534..475dbac143 100644
--- a/plugins/mgcp/packet-mgcp.c
+++ b/plugins/mgcp/packet-mgcp.c
@@ -38,17 +38,12 @@
 
 #include "moduleinfo.h"
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <gmodule.h>
 #include <ctype.h>
-#include <time.h>
 #include <string.h>
 #include <epan/packet.h>
 #include <epan/proto.h>
-#include <epan/addr_resolv.h>
 #include <epan/prefs.h>
-#include <epan/strutil.h>
 #include <epan/conversation.h>
 #include <epan/tap.h>
 #include "packet-mgcp.h"
@@ -128,78 +123,76 @@ static int hf_mgcp_req_dup = -1;
 static int hf_mgcp_rsp_dup = -1;
 
 static const value_string mgcp_return_code_vals[] = {
-
-	{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 }
+    {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 }
+    {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 }
 };
 */
 
@@ -255,33 +248,29 @@ 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, 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);
-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 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 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;
@@ -291,222 +280,238 @@ static dissector_handle_t sdp_handle;
  * Init Hash table stuff
  */
 
-typedef struct _mgcp_call_info_key {
-	guint32	transid;
-	conversation_t *conversation;
+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;
+    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);
+    return (key1->transid == key2->transid &&
+            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;
+    const mgcp_call_info_key* key = (const mgcp_call_info_key*) k;
 
-	return key->transid  + key->conversation->index;
+    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;
-  gchar *verb_name = "";
-
-  /* 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, &verb_name) || is_mgcp_rspcode(tvb,0,tvb_len)){
+    gint sectionlen;
+    guint32 num_messages;
+    gint tvb_sectionend,tvb_sectionbegin, tvb_len, tvb_current_len;
+    proto_tree *mgcp_tree, *ti;
+    gchar *verb_name = "";
+
+    /* 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;
+
     /*
-     * Loop through however many mgcp messages may be stuck in
-     * this packet using piggybacking
+     * Set the columns now, so that they'll be set correctly if we throw
+     * an exception.  We can set them later as well....
      */
-    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);
-    }
+    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);
 
     /*
-     * Add our column information after dissecting SDP
-     * in order to prevent the column info changing to reflect the SDP
-     * (when showing message count)
-     * XXX - can we do this with a fence?
+     * 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.
      */
-    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 (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));
+        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 mgcp_info_t pi_arr[5]; /* We assuming a maximum of 5 mgcp messaages per packet */
-static int pi_current=0;
+#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;
 
-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;
-  gchar *verb_name = "";
-
-  /* Initialise stat info for passing to tap */
-  pi_current++;
-  if(pi_current==5){
-      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);
+/* 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;
+    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;
 
-    /* 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
+    /*
+     * 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.
      */
-    sectionlen = tvb_sectionend;
-    proto_item_set_len(ti,sectionlen);
+    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;
 
-    /* Display the raw text of the mgcp message if desired */
+        /* 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;
+            }
+        }
 
-    /* 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);
-    }
+        /* 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);
+        /* 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);
+        }
     }
-  }
 }
 
 
@@ -515,335 +520,334 @@ dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
  * preferences are specified.
  */
 
-static void mgcp_raw_text_add(tvbuff_t *tvb, proto_tree *tree){
-
-  gint tvb_linebegin,tvb_lineend,tvb_len,linelen;
+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);
+    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 );
+    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) {
-		g_hash_table_destroy(mgcp_calls);
-		mgcp_calls = 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) {
-		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);
-	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);
+    if (mgcp_calls != NULL)
+    {
+        g_hash_table_destroy(mgcp_calls);
+        mgcp_calls = 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)
+    {
+        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);
+    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);
 }
 
 /* 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_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_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, 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,
-    &ett_mgcp_param_connectionparam,
-  };
-  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_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_rsp_dup,
+          { "Duplicate Response", "mgcp.rsp.dup", FT_UINT32, BASE_DEC, NULL, 0x0,
+            "Duplicate Response", HFILL }},
+    };
+
+    static gint *ett[] =
+    {
+        &ett_mgcp,
+        &ett_mgcp_param,
+        &ett_mgcp_param_connectionparam,
+    };
+
+    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 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_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");
 }
 
 /* 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);
 }
 
 /*
@@ -859,38 +863,47 @@ proto_reg_handoff_mgcp(void)
  *
  * 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, gchar **verb_name)
+{
+    int returnvalue = FALSE;
+    guint8 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 (((strncasecmp(word, "EPCF", 4) == 0) && (*verb_name = "EndpointConfiguration|")) ||
+            ((strncasecmp(word, "CRCX", 4) == 0) && (*verb_name = "CreateConnection")) ||
+            ((strncasecmp(word, "MDCX", 4) == 0) && (*verb_name = "ModifyConnection")) ||
+            ((strncasecmp(word, "DLCX", 4) == 0) && (*verb_name = "DeleteConnection")) ||
+            ((strncasecmp(word, "RQNT", 4) == 0) && (*verb_name = "NotificationRequest")) ||
+            ((strncasecmp(word, "NTFY", 4) == 0) && (*verb_name = "Notify")) ||
+            ((strncasecmp(word, "AUEP", 4) == 0) && (*verb_name = "AuditEndpoint")) ||
+            ((strncasecmp(word, "AUCX", 4) == 0) && (*verb_name = "AuditConnection")) ||
+            ((strncasecmp(word, "RSIP", 4) == 0) && (*verb_name = "RestartInProgress")) ||
+            (word[0] == 'X' && is_rfc2234_alpha(word[1]) && is_rfc2234_alpha(word[2]) &&
+                               is_rfc2234_alpha(word[3]) && (*verb_name = "*Experimental*")))
+        {
+            returnvalue = TRUE;
+        }
+    }
 
-static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength, gchar **verb_name){
-  int returnvalue = FALSE;
-  guint8 word[5];
-
-  if(( maxlength >= 4) && tvb_get_nstringz0(tvb,offset,sizeof(word),word)){
-    if (((strncasecmp(word, "EPCF", 4) == 0) && (*verb_name = "EndpointConfiguration|")) ||
-        ((strncasecmp(word, "CRCX", 4) == 0) && (*verb_name = "CreateConnection")) ||
-        ((strncasecmp(word, "MDCX", 4) == 0) && (*verb_name = "ModifyConnection")) ||
-        ((strncasecmp(word, "DLCX", 4) == 0) && (*verb_name = "DeleteConnection")) ||
-        ((strncasecmp(word, "RQNT", 4) == 0) && (*verb_name = "NotificationRequest")) ||
-        ((strncasecmp(word, "NTFY", 4) == 0) && (*verb_name = "Notify")) ||
-        ((strncasecmp(word, "AUEP", 4) == 0) && (*verb_name = "AuditEndpoint")) ||
-        ((strncasecmp(word, "AUCX", 4) == 0) && (*verb_name = "AuditConnection")) ||
-        ((strncasecmp(word, "RSIP", 4) == 0) && (*verb_name = "RestartInProgress")) ||
-        (word[0] == 'X' && is_rfc2234_alpha(word[1]) && is_rfc2234_alpha(word[2]) &&
-                           is_rfc2234_alpha(word[3])  && (*verb_name = "*Experimental*")))
+    /* May be whitespace after verb code - anything else is an error.. */
+    if (returnvalue && maxlength >= 5)
     {
-      returnvalue = TRUE;
+        char next = tvb_get_guint8(tvb,4);
+        if ((next != ' ') && (next != '\t'))
+        {
+            returnvalue = FALSE;
+        }
     }
-  }
-  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
@@ -901,23 +914,32 @@ static gboolean is_mgcp_verb(tvbuff_t *tvb, gint offset, gint maxlength, gchar *
  * 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];
 
-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;
+    /* 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;
+        }
+    }
+  
+    /* 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;
+        }
     }
-  }
-  if( returnvalue && maxlength >= 4 &&
-      (word[0] = tvb_get_guint8(tvb,3)) != ' ' && word[0] != '\t'){
-    returnvalue = FALSE;
-  }
-  return returnvalue;
+
+    return returnvalue;
 }
 
 /*
@@ -932,15 +954,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.
  *
@@ -958,199 +977,219 @@ static gboolean is_rfc2234_alpha(guint8 c){
  */
 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;
-  tvb_current_offset = offset;
-  *hf = NULL;
-
-  if(len > 0){
-    tempchar = tvb_get_guint8(tvb,tvb_current_offset);
+    gint returnvalue = -1, tvb_current_offset,counter;
+    guint8 tempchar, plus_minus;
+    tvb_current_offset = offset;
+    *hf = NULL;
 
-    switch(tempchar)
+    if (len > 0)
     {
-    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':
-      /* Move past 'X' */
-      tvb_current_offset++;
+        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':
+                /* 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++;
+                /* 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':
+                *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':
+                *hf = &hf_mgcp_param_signalreq;
+                break;
+            case 'D':
+                *hf = &hf_mgcp_param_digitmap;
+                mi->hasDigitMap = TRUE;
+                break;
+            case 'O':
+                *hf = &hf_mgcp_param_observedevent;
+                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':
+                *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;
+        }
 
-        /* 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++);
+        /* Move to (hopefully) the colon */
+        tvb_current_offset++;
 
-        if (tempchar == ':')
+        /* 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)) == ':')
         {
-          /* 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;
-          }
+            tvb_current_offset++;
+            tvb_current_offset = tvb_skip_wsp(tvb,tvb_current_offset, (len - tvb_current_offset + offset));
+            returnvalue = tvb_current_offset;
         }
-      }
-      break;
-    case 'L':
-      *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':
-      *hf = &hf_mgcp_param_signalreq;
-      break;
-    case 'D':
-      *hf = &hf_mgcp_param_digitmap;
-      mi->hasDigitMap = TRUE;
-      break;
-    case 'O':
-      *hf = &hf_mgcp_param_observedevent;
-      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':
-      *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;
+    }
+    else
+    {
+        /* Was an empty line */
+        *hf = &hf_mgcp_param_invalid;
     }
 
-    /* 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)) == ':') //||
+    /* For these types, show the whole line */
+    if ((*hf == &hf_mgcp_param_invalid) ||
+        (*hf == &hf_mgcp_param_extension) || (*hf == &hf_mgcp_param_extension_critical))
     {
-      tvb_current_offset++;
-      tvb_current_offset = tvb_skip_wsp(tvb,tvb_current_offset, (len - tvb_current_offset + offset));
-      returnvalue = tvb_current_offset;
+        returnvalue = offset;
     }
-  }
-  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;
+
+    return returnvalue;
 }
 
 
@@ -1170,340 +1209,396 @@ 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)
+{
+    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;
+    gchar *verb_description = "";
+    char code_with_verb[64] = "";  /* To fit "<4-letter-code> (<longest-verb>)" */
+
+    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;
 
- 
-
-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;
-  gchar *verb_description = "";
-  char code_with_verb[64] = "";  /* To fit "<4-letter-code> (<longest-verb>)" */
-
-  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;
-    }
+    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){
-        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);
-	my_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 = g_strdup(endpointId);
-	  my_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;
-	  }
-	  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->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);    
-				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--;
-				}
-				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);
-						}
-					}
-				}
-			}
-		}
-	}
-      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);
-		}
-	}
-
-	/* 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_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);
-				}
-			}
-		}
-	}
-	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_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;
+        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,&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);
+                my_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 = g_strdup(endpointId);
+                    my_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;
+                    }
+                    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->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);    
+                            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--;
+                            }
+                            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? (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);                                                        
+                                }
+                            }
+                        }
+                        /* 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);
+                    }
+                }
+
+                /* 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);
+                        }
+                    }
+                }
+                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_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;
+        }
     }
-  }
-  tap_queue_packet(mgcp_tap, pinfo, mi);
+
+    tap_queue_packet(mgcp_tap, pinfo, mi);
 }
 
 /*
@@ -1519,141 +1614,199 @@ static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo,
  * 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, old_lineend;
-  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, 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);
-    }
-    else{
-      my_proto_tree_add_string = proto_tree_add_string_hidden;
-      mgcp_param_tree = tree;
-      mgcp_param_ti = NULL;
-    }
+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;
+    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, 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);
+        }
+        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){
-      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 && *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 {
-	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;
-      if (old_lineend <= tvb_lineend)
-        THROW(ReportedBoundsError);
+        /* 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
+                {
+                    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;
+            /* Its a infinite loop if we didn't advance (or went backwards) */
+            if (old_lineend >= tvb_lineend)
+            {
+                THROW(ReportedBoundsError);
+            }
+        }
     }
-  }
 }
 
 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;
-  proto_item* (*my_proto_tree_add_uint)(proto_tree*, int, tvbuff_t*, gint, gint, guint32) = NULL;
-  proto_item* (*my_proto_tree_add_string)(proto_tree*, int, tvbuff_t*, gint, gint, const char*) = NULL;
-  proto_item* (*my_proto_tree_add_text)(proto_tree*, tvbuff_t*, gint, gint, const char *, ...) = 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) {
-    if (global_mgcp_dissect_tree){
-      my_proto_tree_add_uint = proto_tree_add_uint;
-      my_proto_tree_add_string = proto_tree_add_string;
-      my_proto_tree_add_text = proto_tree_add_text;
-      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);
-    } else {
-      my_proto_tree_add_uint = proto_tree_add_uint_hidden;
-      my_proto_tree_add_string = proto_tree_add_string_hidden;
-      my_proto_tree_add_text = NULL;
+    proto_tree *tree = parent_tree;
+    proto_item *item = NULL;
+    proto_item* (*my_proto_tree_add_uint)(proto_tree*, int, tvbuff_t*, gint, gint, guint32) = NULL;
+    proto_item* (*my_proto_tree_add_string)(proto_tree*, int, tvbuff_t*, gint, gint, const char*) = NULL;
+    proto_item* (*my_proto_tree_add_text)(proto_tree*, tvbuff_t*, gint, gint, const char *, ...) = 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)
+    {
+        if (global_mgcp_dissect_tree)
+        {
+            my_proto_tree_add_uint = proto_tree_add_uint;
+            my_proto_tree_add_string = proto_tree_add_string;
+            my_proto_tree_add_text = proto_tree_add_text;
+            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);
+        }
+        else
+        {
+            my_proto_tree_add_uint = proto_tree_add_uint_hidden;
+            my_proto_tree_add_string = proto_tree_add_string_hidden;
+            my_proto_tree_add_text = NULL;
+        }
     }
-  }
-  /* the P: line */
-  offset += param_type_len; /* skip the P: */
-  tokenline = tvb_get_string(tvb, offset, param_val_len);
-  /* split into type=value pairs separated by comma */
-  tokens = g_strsplit(tokenline, ",", -1);
-  for (i = 0; tokens[i] != NULL; i++) {
-    tokenlen = strlen(tokens[i]);
-    typval = g_strsplit(tokens[i], "=", 2);
-    if ((typval[0] != NULL) && (typval[1] != NULL)) {
-      if (!strcasecmp(g_strstrip(typval[0]), "PS")) {
-	hf_uint = hf_mgcp_param_connectionparam_ps;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "OS")) {
-	hf_uint = hf_mgcp_param_connectionparam_os;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "PR")) {
-	hf_uint = hf_mgcp_param_connectionparam_pr;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "OR")) {
-	hf_uint = hf_mgcp_param_connectionparam_or;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "PL")) {
-	hf_uint = hf_mgcp_param_connectionparam_pl;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "JI")) {
-	hf_uint = hf_mgcp_param_connectionparam_ji;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "LA")) {
-	hf_uint = hf_mgcp_param_connectionparam_la;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "PC/RPS")) {
-	hf_uint = hf_mgcp_param_connectionparam_pcrps;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "PC/ROS")) {
-	hf_uint = hf_mgcp_param_connectionparam_pcros;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "PC/RPL")) {
-	hf_uint = hf_mgcp_param_connectionparam_pcrpl;
-      } else if (!strcasecmp(g_strstrip(typval[0]), "PC/RJI")) {
-	hf_uint = hf_mgcp_param_connectionparam_pcrji;
-      } else if (!strncasecmp(g_strstrip(typval[0]), "X-", 2)) {
-	hf_string = hf_mgcp_param_connectionparam_x;
-      } else {
-	hf_uint = -1;
-	hf_string = -1;
-      }
-      if (hf_uint != -1) {
-	if (my_proto_tree_add_uint) my_proto_tree_add_uint(tree, hf_uint, tvb, offset, tokenlen, atol(typval[1]));
-      } else if (hf_string != -1) {
-	if (my_proto_tree_add_string) my_proto_tree_add_string(tree, hf_string, tvb, offset, tokenlen, g_strstrip(typval[1]));
-      } else {
-	if (my_proto_tree_add_text) proto_tree_add_text(tree, tvb, offset, tokenlen, "Unknown parameter: %s", tokens[i]);
-      }
-    } else {
-      if (my_proto_tree_add_text) proto_tree_add_text(tree, tvb, offset, tokenlen, "Malformed parameter: %s", tokens[i]);
+    /* The P: line */
+    offset += param_type_len; /* skip the P: */
+    tokenline = tvb_get_string(tvb, offset, param_val_len);
+
+    /* Split into type=value pairs separated by comma */
+    tokens = g_strsplit(tokenline, ",", -1);
+    for (i = 0; tokens[i] != NULL; i++)
+    {
+        tokenlen = strlen(tokens[i]);
+        typval = g_strsplit(tokens[i], "=", 2);
+        if ((typval[0] != NULL) && (typval[1] != NULL))
+        {
+            if (!strcasecmp(g_strstrip(typval[0]), "PS"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_ps;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "OS"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_os;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "PR"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_pr;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "OR"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_or;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "PL"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_pl;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "JI"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_ji;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "LA"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_la;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "PC/RPS"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_pcrps;
+            } else if (!strcasecmp(g_strstrip(typval[0]), "PC/ROS"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_pcros;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "PC/RPL"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_pcrpl;
+            }
+            else if (!strcasecmp(g_strstrip(typval[0]), "PC/RJI"))
+            {
+                hf_uint = hf_mgcp_param_connectionparam_pcrji;
+            }
+            else if (!strncasecmp(g_strstrip(typval[0]), "X-", 2))
+            {
+                hf_string = hf_mgcp_param_connectionparam_x;
+            }
+            else
+            {
+                hf_uint = -1;
+                hf_string = -1;
+            }
+
+            if (hf_uint != -1)
+            {
+                if (my_proto_tree_add_uint)
+                    my_proto_tree_add_uint(tree, hf_uint, tvb, offset, tokenlen, atol(typval[1]));
+            }
+            else if (hf_string != -1)
+            {
+                if (my_proto_tree_add_string)
+                    my_proto_tree_add_string(tree, hf_string, tvb, offset, tokenlen, g_strstrip(typval[1]));
+            }
+            else
+            {
+                if (my_proto_tree_add_text)
+                    proto_tree_add_text(tree, tvb, offset, tokenlen, "Unknown parameter: %s", tokens[i]);
+            }
+        }
+        else {
+            if (my_proto_tree_add_text)
+                proto_tree_add_text(tree, tvb, offset, tokenlen, "Malformed parameter: %s", tokens[i]);
+        }
+        offset += tokenlen + 1; /* 1 extra for the delimiter */
     }
-    offset += tokenlen+1; /* 1 extra for the delimiter */
-  }
-  g_strfreev(typval);
-  g_strfreev(tokens);
-  g_free(tokenline);
+
+    g_strfreev(typval);
+    g_strfreev(tokens);
+    g_free(tokenline);
 }
 
+
 /*
  * tvb_skip_wsp - Returns the position in tvb of the first non-whitespace
  *                character following offset or offset + maxlength -1 whichever
@@ -1669,19 +1822,28 @@ dissect_mgcp_connectionparams(proto_tree *parent_tree, tvbuff_t *tvb, gint offse
  *          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);
 }
 
 /*
@@ -1704,48 +1866,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;
 }
 
 /*
@@ -1769,88 +1932,104 @@ 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;
+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;
+                    }
+                }
+            }
+        }
+        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);
+
+    
     /*
-     * if we didn't find a . then break out of the loop
+     * 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){
-      break;
+    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);
     }
-    /* 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;
-	  }
-	}
-      }
+
+    if (tvb_current_offset == offset)
+    {
+        tvb_current_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
+    {
+        tvb_current_len = tvb_current_offset - 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;
+
+    return tvb_current_len;
 }
 
 /* Start the functions we need for the plugin stuff */
@@ -1860,15 +2039,18 @@ static gint tvb_find_dot_line(tvbuff_t* tvb, gint offset,
 G_MODULE_EXPORT void
 plugin_register(void)
 {
-  /* register the new protocol, protocol fields, and subtrees */
-  if (proto_mgcp == -1) { /* execute protocol initialization only once */
-    proto_register_mgcp();
-  }
+    /* Register the new protocol, protocol fields, and subtrees */
+    if (proto_mgcp == -1)
+    { 
+        /* Execute protocol initialization only once */
+        proto_register_mgcp();
+    }
 }
 
 G_MODULE_EXPORT void
-plugin_reg_handoff(void){
-  proto_reg_handoff_mgcp();
+plugin_reg_handoff(void)
+{
+    proto_reg_handoff_mgcp();
 }
 
 #endif
diff --git a/plugins/mgcp/packet-mgcp.h b/plugins/mgcp/packet-mgcp.h
index 1ee4c435ad..1fa5157e04 100644
--- a/plugins/mgcp/packet-mgcp.h
+++ b/plugins/mgcp/packet-mgcp.h
@@ -26,34 +26,39 @@
  */
  
  /* A simple MGCP type that is occasionally handy */
-typedef enum _mgcp_type {
-  MGCP_REQUEST,
-  MGCP_RESPONSE,
-  MGCP_OTHERS
+typedef enum _mgcp_type
+{
+    MGCP_REQUEST,
+    MGCP_RESPONSE,
+    MGCP_OTHERS
 } mgcp_type_t;
 
 /* Container for tapping relevant data */
-typedef struct _mgcp_info_t {
-  mgcp_type_t mgcp_type;
-  char code[5];
-  guint32 transid;
-  nstime_t req_time;
-  gboolean is_duplicate;
-  gboolean request_available;
-  guint32	req_num;	/* frame number request seen */
-  gchar *endpointId;
-  gchar *observedEvents;
-  guint32 rspcode;
-  gchar *signalReq;
-  gboolean hasDigitMap;
+typedef struct _mgcp_info_t
+{
+    mgcp_type_t mgcp_type;
+    char code[5];
+    guint32 transid;
+    nstime_t req_time;
+    gboolean is_duplicate;
+    gboolean request_available;
+    guint32 req_num; /* frame number request seen */
+    gchar *endpointId;
+    gchar *observedEvents;
+    guint32 rspcode;
+    gchar *signalReq;
+    gboolean hasDigitMap;
 } mgcp_info_t;
 
 /* Item of request list */
-typedef struct _mgcp_call_t {
-	guint32 transid;
-	char code[5];
-	guint32	req_num;	/* frame number request seen */
-	guint32	rsp_num;	/* frame number response seen */
-	nstime_t req_time;
-	gboolean responded;
-} mgcp_call_t;	
+typedef struct _mgcp_call_t
+{
+    guint32 transid;
+    char code[5];
+    guint32 req_num; /* frame number request seen */
+    guint32 rsp_num; /* frame number response seen */
+    guint32 rspcode;
+    nstime_t req_time;
+    gboolean responded;
+} mgcp_call_t;
+