Wireshark · Ethereal-dev: Re: [Ethereal-dev] Voip Calls analysis and Graph analysis

[Lars Roland <lars.roland@xxxxxxx>]

Having a short look at the patch, I have to disagree on an 
implementation detail:

I don't like to have the mgcp dissector allocating a mgcp_info_t 
structure for each dissection of an mgcp packet without freeing it. This 
could be considered to be a big memory leak.
Instead use a static array of mgcp_info_t structures. You can take the 
h225 or the q931 dissector as an example of such an implementation.

Regards,
Lars

LEGO schrieb:
> Do you have any capture on which to test it?
>
> Luis
>
> On Fri, 18 Feb 2005 13:00:00 -0700, Alejandro Vaquero
> <alejandrovaquero@xxxxxxxxx> wrote:
>
> > Hi All,
> >    find attached a patch to add MGCP calls to the "Voip Analysis". The
> > implementation is oriented to MGCP Residential Gateways.
> >
> > Regards
> > Alejandro
> >
> >
> > Index: gtk/voip_calls_dlg.c
> > ===================================================================
> > --- gtk/voip_calls_dlg.c        (revision 13359)
> > +++ gtk/voip_calls_dlg.c        (working copy)
> > @@ -173,6 +173,7 @@
> >        remove_tap_listener_q931_calls();
> >        remove_tap_listener_sdp_calls();
> >        remove_tap_listener_rtp();
> > +       remove_tap_listener_mgcp_calls();
> > }
> >
> > /****************************************************************************/
> > @@ -672,6 +673,7 @@
> >        q931_calls_init_tap();
> >        sdp_calls_init_tap();
> >        rtp_init_tap();
> > +       mgcp_calls_init_tap();
> >
> >        /* init the Graph Analysys */
> >        graph_analysis_data = graph_analysis_init();
> > Index: gtk/voip_calls.c
> > ===================================================================
> > --- gtk/voip_calls.c    (revision 13359)
> > +++ gtk/voip_calls.c    (working copy)
> > @@ -52,6 +52,7 @@
> > #include <epan/dissectors/packet-h245.h>
> > #include <epan/dissectors/packet-q931.h>
> > #include <epan/dissectors/packet-sdp.h>
> > +#include <plugins/mgcp/packet-mgcp.h>
> > #include <epan/dissectors/packet-rtp.h>
> > #include "rtp_pt.h"
> >
> > @@ -69,8 +70,9 @@
> > #include <string.h>
> >
> > -char *voip_call_state_name[6]={
> > +char *voip_call_state_name[7]={
> >        "CALL SETUP",
> > +       "RINGING",
> >        "IN CALL",
> >        "CANCELLED",
> >        "COMPLETED",
> > @@ -79,10 +81,11 @@
> >        };
> >
> > /* defines whether we can consider the call active */
> > -char *voip_protocol_name[3]={
> > +char *voip_protocol_name[4]={
> >        "SIP",
> >        "ISUP",
> > -       "H323"
> > +       "H323",
> > +       "MGCP"
> >        };
> >
> > @@ -90,7 +93,7 @@
> > /****************************************************************************/
> > /* the one and only global voip_calls_tapinfo_t structure */
> > static voip_calls_tapinfo_t the_tapinfo_struct =
> > -       {0, NULL, 0, NULL, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, 0, 0};
> > +       {0, NULL, 0, NULL, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, 0, 0, 0};
> >
> > /* the one and only global voip_rtp_tapinfo_t structure */
> > static voip_rtp_tapinfo_t the_tapinfo_rtp_struct =
> > @@ -1446,6 +1449,8 @@
> >        have_H245dg_tap_listener=FALSE;
> > }
> >
> > +static gchar *sdp_summary = NULL;
> > +static guint32 sdp_frame_num = 0;
> >
> > /****************************************************************************/
> > /****************************TAP for SDP PROTOCOL ***************************/
> > @@ -1456,11 +1461,16 @@
> > {
> >        voip_calls_tapinfo_t *tapinfo = &the_tapinfo_struct;
> >        const sdp_packet_info *pi = SDPinfo;
> > -       char summary_str[50];
> > -
> > +
> > +       /* There are protocols like MGCP where the SDP is called before the tap for the
> > +          MGCP packet, in those cases we assign the SPD summary to global lastSDPsummary
> > +          to use it later
> > +       */
> > +       g_free(sdp_summary);
> > +       sdp_frame_num = pinfo->fd->num;
> >        /* Append to graph the SDP summary if the packet exists */
> > -       g_snprintf(summary_str, 50, "SDP (%s)", pi->summary_str);
> > -       append_to_frame_graph(tapinfo, pinfo->fd->num, summary_str, NULL);
> > +       sdp_summary = g_strdup_printf("SDP (%s)", pi->summary_str);
> > +       append_to_frame_graph(tapinfo, pinfo->fd->num, sdp_summary, NULL);
> >
> >        return 1;  /* refresh output */
> > }
> > @@ -1513,9 +1523,374 @@
> >
> > +/****************************************************************************/
> > +/* ***************************TAP for MGCP **********************************/
> > +/****************************************************************************/
> >
> > +/*
> > +   This function will look for a signal/event in the SignalReq/ObsEvent string
> > +   and return true if it is found
> > +*/
> > +boolean isSignal(gchar *signal, gchar *signalStr)
> > +{
> > +       gint i;
> > +       gchar **resultArray;
> > +
> > +       /* if there is no signalStr, just return false */
> > +       if (signalStr == NULL) return FALSE;
> >
> > +       /* if are both "blank" return true */
> > +       if ( (*signal == '\0') &&  (*signalStr == '\0') ) return TRUE;
> > +
> > +       /* look for signal in signalSre */
> > +       resultArray = g_strsplit(signalStr, ",", 10);
> > +
> > +       for (i = 0; resultArray[i]; i++) {
> > +               g_strstrip(resultArray[i]);
> > +               if (strcmp(resultArray[i], signal) == 0) return TRUE;
> > +       }
> > +
> > +       g_strfreev(resultArray);
> > +
> > +       return FALSE;
> > +}
> > +
> > +/*
> > +   This function will get the Caller ID info and replace the current string
> > +   This is how it looks the caller Id: rg, ci(02/16/08/29, "3035550002","Ale Sipura 2")
> > +*/
> > +void mgcpCallerID(gchar *signalStr, gchar **callerId)
> > +{
> > +       gint i;
> > +       gchar **resultArray;
> > +       gchar **arrayStr;
> > +
> > +       /* if there is no signalStr, just return false */
> > +       if (signalStr == NULL) return;
> > +
> > +       arrayStr = g_strsplit(signalStr, "\"", 10);
> > +
> > +       if (arrayStr[0] == NULL) return;
> > +
> > +       /* look for the ci signal */
> > +       resultArray = g_strsplit_set(arrayStr[0], ",(", 10);
> > +
> > +       for (i = 0; resultArray[i]; i++) {
> > +               g_strstrip(resultArray[i]);
> > +               if (strcmp(resultArray[i], "ci") == 0){
> > +                       if (arrayStr[1] != NULL){
> > +                               /* free the previous "From" field of the call, and assign the new */
> > +                               g_free(*callerId);
> > +                               *callerId = g_strdup(arrayStr[1]);
> > +                       }
> > +                       g_strfreev(arrayStr);
> > +                       g_strfreev(resultArray);
> > +                       return;
> > +               }
> > +       }
> > +
> > +       g_strfreev(arrayStr);
> > +       g_strfreev(resultArray);
> > +
> > +       return;
> > +}
> > +
> > +
> > +/*
> > +   This function will get the Dialed Digits and replace the current string
> > +   This is how it looks the dialed digits 5,5,5,0,0,0,2,#,*
> > +*/
> > +void mgcpDialedDigits(gchar *signalStr, gchar **dialedDigits)
> > +{
> > +       gchar *tmpStr;
> > +       gchar resultStr[50];
> > +       gint i,j;
> > +
> > +       /* if there is no signalStr, just return false */
> > +       if (signalStr == NULL) return;
> > +
> > +       tmpStr = g_strdup(signalStr);
> > +
> > +       tmpStr = g_strcanon(tmpStr, "123456790#*", '?');
> > +
> > +       for (i = 0, j = 0; tmpStr[i] && i<50; i++) {
> > +               if (tmpStr[i] != '?')
> > +                       resultStr[j++] = tmpStr[i];
> > +       }
> > +       resultStr[j] = '\0';
> > +
> > +       if (*resultStr == '\0') return;
> > +
> > +       g_free(*dialedDigits);
> > +       *dialedDigits = g_strdup(resultStr);
> > +       g_free(tmpStr);
> > +
> > +       return;
> > +}
> > +
> > +
> > +
> > /****************************************************************************/
> > +/* whenever a MGCP packet is seen by the tap listener */
> > +static int
> > +MGCPcalls_packet( void *ptr _U_, packet_info *pinfo, epan_dissect_t *edt _U_, const void *MGCPinfo)
> > +{
> > +       voip_calls_tapinfo_t *tapinfo = &the_tapinfo_struct;
> > +
> > +       voip_calls_info_t *tmp_listinfo;
> > +       voip_calls_info_t *strinfo = NULL;
> > +       mgcp_calls_info_t *tmp_mgcpinfo;
> > +       GList* list;
> > +       GList* listGraph;
> > +       gchar *frame_label = NULL;
> > +       gchar *comment = NULL;
> > +       graph_analysis_item_t *gai;
> > +       boolean new = FALSE;
> > +       boolean fromEndpoint = FALSE; /* true for calls originated in Endpoints, false for calls from MGC */
> > +       gdouble diff_time;
> > +
> > +       const mgcp_info_t *pi = MGCPinfo;
> > +
> > +
> > +       if ((pi->mgcp_type == MGCP_REQUEST) && !pi->is_duplicate ){
> > +               /* check wether we already have a call with this Endpoint and it is active*/
> > +               list = g_list_first(tapinfo->strinfo_list);
> > +               while (list)
> > +               {
> > +                       tmp_listinfo=list->data;
> > +                       if ((tmp_listinfo->protocol == VOIP_MGCP) && (tmp_listinfo->call_active_state == VOIP_ACTIVE)){
> > +                               tmp_mgcpinfo = tmp_listinfo->prot_info;
> > +                               if (pi->endpointId != NULL){
> > +                                       if (g_ascii_strcasecmp(tmp_mgcpinfo->endpointId,pi->endpointId)==0){
> > +                                               /*
> > +                                                  check first if it is an ended call. We consider an ended call after 1sec we don't
> > +                                                  get a packet in this Endpoint and the call has been released
> > +                                               */
> > +                                               diff_time = (pinfo->fd->rel_secs + (double)pinfo->fd->rel_secs/1000000) - (tmp_listinfo->stop_sec + (double)tmp_listinfo->stop_usec/1000000);
> > +                                               if ( ((tmp_listinfo->call_state == VOIP_CANCELLED) || (tmp_listinfo->call_state == VOIP_COMPLETED)  || (tmp_listinfo->call_state == VOIP_REJECTED)) && (diff_time > 1) ){
> > +                                                       tmp_listinfo->call_active_state = VOIP_INACTIVE;
> > +                                               } else {
> > +                                                       strinfo = (voip_calls_info_t*)(list->data);
> > +                                                       break;
> > +                                               }
> > +                                       }
> > +                               }
> > +                       }
> > +                       list = g_list_next (list);
> > +               }
> > +
> > +               /* there is no call with this Endpoint, lets see if this a new call or not */
> > +               if (strinfo == NULL){
> > +                       if ( (strcmp(pi->code, "NTFY") == 0) && isSignal("hd", pi->observedEvents) ){ /* off hook transition */
> > +                               /* this is a new call from the Endpoint */
> > +                               fromEndpoint = TRUE;
> > +                               new = TRUE;
> > +                       } else if (strcmp(pi->code, "CRCX") == 0){
> > +                               /* this is a new call from the MGC */
> > +                               fromEndpoint = FALSE;
> > +                               new = TRUE;
> > +                       }
> > +                       if (!new) return 0;
> > +               }
> > +       } else if ( ((pi->mgcp_type == MGCP_RESPONSE) && pi->request_available) ||
> > +                       ((pi->mgcp_type == MGCP_REQUEST) && pi->is_duplicate) ) {
> > +               /* if it is a response OR if it is a duplicated Request, lets look in the Graph if thre is a request that match */
> > +               listGraph = g_list_first(tapinfo->graph_analysis->list);
> > +               while (listGraph)
> > +               {
> > +                       gai = listGraph->data;
> > +                       if (gai->frame_num == pi->req_num){
> > +                               /* there is a request that match, so look the associated call with this call_num */
> > +                               list = g_list_first(tapinfo->strinfo_list);
> > +                               while (list)
> > +                               {
> > +                                       tmp_listinfo=list->data;
> > +                                       if (tmp_listinfo->protocol == VOIP_MGCP){
> > +                                               if (tmp_listinfo->call_num == gai->conv_num){
> > +                                                       tmp_mgcpinfo = tmp_listinfo->prot_info;
> > +                                                       strinfo = (voip_calls_info_t*)(list->data);
> > +                                                       break;
> > +                                               }
> > +                                       }
> > +                                       list = g_list_next (list);
> > +                               }
> > +                               if (strinfo != NULL) break;
> > +                       }
> > +                       listGraph = g_list_next(listGraph);
> > +               }
> > +               /* if there is not a matching request, just return */
> > +               if (strinfo == NULL) return 0;
> > +       } else return 0;
> > +
> > +       /* not in the list? then create a new entry */
> > +       if (strinfo==NULL){
> > +               strinfo = g_malloc(sizeof(voip_calls_info_t));
> > +               strinfo->call_active_state = VOIP_ACTIVE;
> > +               strinfo->call_state = VOIP_CALL_SETUP;
> > +               if (fromEndpoint) {
> > +                       strinfo->from_identity=g_strdup(pi->endpointId);
> > +                       strinfo->to_identity=g_strdup("");
> > +               } else {
> > +                       strinfo->from_identity=g_strdup("");
> > +                       strinfo->to_identity=g_strdup(pi->endpointId);
> > +               }
> > +               g_memmove(&(strinfo->initial_speaker), pinfo->src.data, 4);
> > +               strinfo->first_frame_num=pinfo->fd->num;
> > +               strinfo->selected=FALSE;
> > +               strinfo->start_sec=pinfo->fd->rel_secs;
> > +               strinfo->start_usec=pinfo->fd->rel_usecs;
> > +               strinfo->protocol=VOIP_MGCP;
> > +               strinfo->prot_info=g_malloc(sizeof(mgcp_calls_info_t));
> > +               tmp_mgcpinfo=strinfo->prot_info;
> > +               tmp_mgcpinfo->endpointId = g_strdup(pi->endpointId);
> > +               tmp_mgcpinfo->fromEndpoint = fromEndpoint;
> > +               strinfo->npackets = 0;
> > +               strinfo->call_num = tapinfo->ncalls++;
> > +               tapinfo->strinfo_list = g_list_append(tapinfo->strinfo_list, strinfo);
> > +       }
> > +
> > +       /* change call state and add to graph */
> > +       switch (pi->mgcp_type)
> > +       {
> > +       case MGCP_REQUEST:
> > +               if ( (strcmp(pi->code, "NTFY") == 0) && (pi->observedEvents != NULL) ){
> > +                       frame_label = g_strdup_printf("%s ObsEvt:%s",pi->code, pi->observedEvents);
> > +
> > +                       if (tmp_mgcpinfo->fromEndpoint){
> > +                               /* use the Dialed digits to fill the "To" for the call */
> > +                               mgcpDialedDigits(pi->observedEvents, &(strinfo->to_identity));
> > +
> > +                       /* from MGC and the user picked up, the call is connected */
> > +                       } else if (isSignal("hd", pi->observedEvents))
> > +                               strinfo->call_state=VOIP_IN_CALL;
> > +
> > +                       /* hung up signal */
> > +                       if (isSignal("hu", pi->observedEvents)) {
> > +                               if ((strinfo->call_state == VOIP_CALL_SETUP) || (strinfo->call_state == VOIP_RINGING)){
> > +                                       strinfo->call_state = VOIP_CANCELLED;
> > +                               } else {
> > +                                       strinfo->call_state = VOIP_COMPLETED;
> > +                               }
> > +                       }
> > +
> > +               } else if (strcmp(pi->code, "RQNT") == 0) {
> > +                       /* for calls from Endpoint: if there is a "no signal" RQNT and the call was RINGING, we assume this is the CONNECT */
> > +                       if ( tmp_mgcpinfo->fromEndpoint && isSignal("", pi->signalReq) && (strinfo->call_state == VOIP_RINGING) ) {
> > +                                       strinfo->call_state = VOIP_IN_CALL;
> > +                       }
> > +
> > +                       /* if there is ringback or ring tone, change state to ringing */
> > +                       if ( isSignal("rg", pi->signalReq) || isSignal("rt", pi->signalReq) ) {
> > +                                       strinfo->call_state = VOIP_RINGING;
> > +                       }
> > +
> > +                       /* if there is a Busy or ReorderTone, and the call was Ringing or Setup the call is Rejected */
> > +                       if ( (isSignal("ro", pi->signalReq) || isSignal("bz", pi->signalReq)) && ((strinfo->call_state == VOIP_CALL_SETUP) || (strinfo->call_state = VOIP_RINGING)) ) {
> > +                                       strinfo->call_state = VOIP_REJECTED;
> > +                       }
> > +
> > +                       if (pi->signalReq != NULL)
> > +                               frame_label = g_strdup_printf("%s%sSigReq:%s",pi->code, (pi->hasDigitMap == TRUE)?" DigitMap ":"", pi->signalReq);
> > +                       else
> > +                               frame_label = g_strdup_printf("%s%s",pi->code, (pi->hasDigitMap == TRUE)?" DigitMap ":"");
> > +
> > +                       /* use the CallerID info to fill the "From" for the call */
> > +                       if (!tmp_mgcpinfo->fromEndpoint) mgcpCallerID(pi->signalReq, &(strinfo->from_identity));
> > +
> > +               } else if (strcmp(pi->code, "DLCX") == 0) {
> > +                       /*
> > +                         if there is a DLCX in a call To an Endpoint and the call was not connected, we use
> > +                         the DLCX as the end of the call
> > +                       */
> > +                       if (!tmp_mgcpinfo->fromEndpoint){
> > +                               if ((strinfo->call_state == VOIP_CALL_SETUP) || (strinfo->call_state == VOIP_RINGING)){
> > +                                       strinfo->call_state = VOIP_CANCELLED;
> > +                               }
> > +                       }
> > +               }
> > +
> > +               if (frame_label == NULL) frame_label = g_strdup_printf("%s",pi->code);
> > +               break;
> > +       case MGCP_RESPONSE:
> > +               frame_label = g_strdup_printf("%d (%s)",pi->rspcode, pi->code);
> > +               break;
> > +       }
> > +
> > +
> > +       comment = g_strdup_printf("MGCP %s %s%s", tmp_mgcpinfo->endpointId, (pi->mgcp_type == MGCP_REQUEST)?"Request":"Response", pi->is_duplicate?" Duplicate":"");
> > +
> > +       strinfo->stop_sec=pinfo->fd->rel_secs;
> > +       strinfo->stop_usec=pinfo->fd->rel_usecs;
> > +       strinfo->last_frame_num=pinfo->fd->num;
> > +       ++(strinfo->npackets);
> > +       /* increment the packets counter of all calls */
> > +       ++(tapinfo->npackets);
> > +
> > +       /* add to the graph */
> > +       add_to_graph(tapinfo, pinfo, frame_label, comment, strinfo->call_num);
> > +       g_free(comment);
> > +       g_free(frame_label);
> > +
> > +       /* add SDP info if apply */
> > +       if ( (sdp_summary != NULL) && (sdp_frame_num == pinfo->fd->num) ){
> > +                       append_to_frame_graph(tapinfo, pinfo->fd->num, sdp_summary, NULL);
> > +                       g_free(sdp_summary);
> > +                       sdp_summary = NULL;
> > +       }
> > +
> > +       return 1;  /* refresh output */
> > +}
> > +
> > +
> > +/****************************************************************************/
> > +/* TAP INTERFACE */
> > +/****************************************************************************/
> > +static gboolean have_MGCP_tap_listener=FALSE;
> > +/****************************************************************************/
> > +void
> > +mgcp_calls_init_tap(void)
> > +{
> > +       GString *error_string;
> > +
> > +       if(have_MGCP_tap_listener==FALSE)
> > +       {
> > +               /* don't register tap listener, if we have it already */
> > +               /* we send an empty filter, to force a non null "tree" in the mgcp dissector */
> > +               error_string = register_tap_listener("mgcp", &(the_tapinfo_struct.mgcp_dummy), strdup(""),
> > +                       voip_calls_dlg_reset,
> > +                       MGCPcalls_packet,
> > +                       voip_calls_dlg_draw
> > +                       );
> > +               if (error_string != NULL) {
> > +                       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
> > +                                     error_string->str);
> > +                       g_string_free(error_string, TRUE);
> > +                       exit(1);
> > +               }
> > +               have_MGCP_tap_listener=TRUE;
> > +       }
> > +}
> > +
> > +
> > +
> > +/* XXX just copied from gtk/rpc_stat.c */
> > +void protect_thread_critical_region(void);
> > +void unprotect_thread_critical_region(void);
> > +
> > +/****************************************************************************/
> > +void
> > +remove_tap_listener_mgcp_calls(void)
> > +{
> > +       protect_thread_critical_region();
> > +       remove_tap_listener(&(the_tapinfo_struct.mgcp_dummy));
> > +       unprotect_thread_critical_region();
> > +
> > +       have_MGCP_tap_listener=FALSE;
> > +}
> > +
> > +
> > +
> > +/****************************************************************************/
> > /* ***************************TAP for OTHER PROTOCOL **********************************/
> > /****************************************************************************/
> >
> > Index: gtk/voip_calls.h
> > ===================================================================
> > --- gtk/voip_calls.h    (revision 13359)
> > +++ gtk/voip_calls.h    (working copy)
> > @@ -44,6 +44,7 @@
> > /* defines voip call state */
> > typedef enum _voip_call_state {
> >         VOIP_CALL_SETUP,
> > +               VOIP_RINGING,
> >         VOIP_IN_CALL,
> >         VOIP_CANCELLED,
> >         VOIP_COMPLETED,
> > @@ -51,7 +52,7 @@
> >                VOIP_UNKNOWN
> > } voip_call_state;
> >
> > -extern char *voip_call_state_name[6];
> > +extern char *voip_call_state_name[7];
> >
> > typedef enum _voip_call_active_state {
> >                VOIP_ACTIVE,
> > @@ -61,10 +62,11 @@
> > typedef enum _voip_protocol {
> >                VOIP_SIP,
> >                VOIP_ISUP,
> > -               VOIP_H323
> > +               VOIP_H323,
> > +               VOIP_MGCP
> > } voip_protocol;
> >
> > -extern char *voip_protocol_name[3];
> > +extern char *voip_protocol_name[4];
> >
> > /* defines specific SIP data */
> >
> > @@ -81,13 +83,13 @@
> > } sip_calls_info_t;
> >
> > /* defines specific ISUP data */
> > -
> > typedef struct _isup_calls_info {
> >        guint16                 cic;
> >        guint32                 opc, dpc;
> >        guint8                  ni;
> > } isup_calls_info_t;
> >
> > +/* defines specific H245 data */
> > typedef struct _h245_address {
> >        guint32 h245_address;
> >        guint16 h245_port;
> > @@ -107,6 +109,13 @@
> >        guint requestSeqNum;
> > } h323_calls_info_t;
> >
> > +/* defines specific MGCP data */
> > +typedef struct _mgcp_calls_info {
> > +       gchar *endpointId;
> > +       gboolean fromEndpoint; /* true if the call was originated from the Endpoint, false for calls from MGC */
> > +} mgcp_calls_info_t;
> > +
> > +
> > /* defines a voip call */
> > typedef struct _voip_calls_info {
> >        voip_call_state call_state;
> > @@ -149,6 +158,7 @@
> >        int mtp3_dummy;
> >        int isup_dummy;
> >        int q931_dummy;
> > +       int mgcp_dummy;
> > } voip_calls_tapinfo_t;
> >
> > @@ -197,6 +207,7 @@
> > void q931_calls_init_tap(void);
> > void sdp_calls_init_tap(void);
> > void rtp_init_tap(void);
> > +void mgcp_calls_init_tap(void);
> >
> > /*
> > @@ -211,6 +222,7 @@
> > void remove_tap_listener_q931_calls(void);
> > void remove_tap_listener_sdp_calls(void);
> > void remove_tap_listener_rtp(void);
> > +void remove_tap_listener_mgcp_calls(void);
> >
> > /*
> > * Retrieves a constant reference to the unique info structure of the voip_calls tap listener.
> > Index: plugins/mgcp/packet-mgcp.h
> > ===================================================================
> > --- plugins/mgcp/packet-mgcp.h  (revision 13359)
> > +++ plugins/mgcp/packet-mgcp.h  (working copy)
> > @@ -40,6 +40,12 @@
> >   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 */
> > Index: plugins/mgcp/packet-mgcp.c
> > ===================================================================
> > --- plugins/mgcp/packet-mgcp.c  (revision 13359)
> > +++ plugins/mgcp/packet-mgcp.c  (working copy)
> > @@ -226,7 +226,7 @@
> > static void dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo,
> >                                 proto_tree *tree,proto_tree *mgcp_tree, proto_tree *ti);
> > static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo,
> > -                                  proto_tree *tree, mgcp_info_t *mi);
> > +                                  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);
> > @@ -377,6 +377,7 @@
> >     }
> >   }
> > }
> > +static mgcp_info_t *mi;
> >
> > static void
> > dissect_mgcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
> > @@ -386,8 +387,23 @@
> >   gint sectionlen;
> >   gint tvb_sectionend,tvb_sectionbegin, tvb_len, tvb_current_len;
> >   tvbuff_t *next_tvb;
> > -  static mgcp_info_t mi;
> >
> > +  /* Initialise stat info for passing to tap */
> > +  mi = g_malloc(sizeof(mgcp_info_t));
> > +  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;
> > @@ -409,7 +425,7 @@
> >     if( sectionlen > 0){
> >       dissect_mgcp_firstline(tvb_new_subset(tvb, tvb_sectionbegin,
> >                                            sectionlen,-1), pinfo,
> > -                            mgcp_tree, &mi);
> > +                            mgcp_tree);
> >     }
> >     tvb_sectionbegin = tvb_sectionend;
> >
> > @@ -882,8 +898,10 @@
> > static gint tvb_parse_param(tvbuff_t* tvb, gint offset, gint len, int** hf){
> >   gint returnvalue, tvb_current_offset,counter;
> >   guint8 tempchar;
> > +  gchar **buf;
> >   tvb_current_offset = offset;
> > -  returnvalue = -1;
> > +  returnvalue = -1;
> > +  buf = NULL;
> >   *hf = NULL;
> >   if(len > 0){
> >     tempchar = tvb_get_guint8(tvb,tvb_current_offset);
> > @@ -956,12 +974,15 @@
> >       break;
> >     case 'S':
> >       *hf = &hf_mgcp_param_signalreq;
> > +         buf = &(mi->signalReq);
> >       break;
> >     case 'D':
> >       *hf = &hf_mgcp_param_digitmap;
> > +         mi->hasDigitMap = TRUE;
> >       break;
> >     case 'O':
> >       *hf = &hf_mgcp_param_observedevent;
> > +         buf = &(mi->observedEvents);
> >       break;
> >     case 'P':
> >       *hf = &hf_mgcp_param_connectionparam;
> > @@ -1015,6 +1036,9 @@
> >       tvb_current_offset = tvb_skip_wsp(tvb,tvb_current_offset,
> >                                        (len - tvb_current_offset + offset));
> >       returnvalue = tvb_current_offset;
> > +         if (buf != NULL) {
> > +                 *buf = tvb_get_string(tvb, tvb_current_offset, (len - tvb_current_offset + offset));
> > +         }
> >     }
> >     else {
> >       *hf = &hf_mgcp_param_invalid;
> > @@ -1050,11 +1074,12 @@
> >
> > static void dissect_mgcp_firstline(tvbuff_t *tvb, packet_info *pinfo,
> > -                                  proto_tree *tree, mgcp_info_t *mi){
> > +                                  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;
> > @@ -1107,6 +1132,7 @@
> >        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);
> > @@ -1126,10 +1152,11 @@
> >       }
> >       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,
> > -                                  tvb_format_text(tvb, tvb_previous_offset,
> > -                                                  tokenlen));
> > +                                  endpointId);
> >        }
> >        else if(mgcp_type == MGCP_RESPONSE){
> >          if(tvb_current_offset < tvb_len){
> > @@ -1214,6 +1241,7 @@
> >                        if(mgcp_call->req_num){
> >                                mi->request_available = TRUE;
> >                                mgcp_call->responded = TRUE;
> > +                               mi->req_num = mgcp_call->req_num;
> >                                strcpy(mi->code,mgcp_call->code);
> >                                proto_tree_add_uint_format(tree, hf_mgcp_req_frame,
> >                                    tvb, 0, 0, mgcp_call->req_num,
> > @@ -1317,6 +1345,7 @@
> >                        /* 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);
> > @@ -1345,7 +1374,6 @@
> >                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);
> >        }
> >
> >
> > _______________________________________________
> > Ethereal-dev mailing list
> > Ethereal-dev@xxxxxxxxxxxx
> > http://www.ethereal.com/mailman/listinfo/ethereal-dev
>
>
> _______________________________________________
> Ethereal-dev mailing list
> Ethereal-dev@xxxxxxxxxxxx
> http://www.ethereal.com/mailman/listinfo/ethereal-dev