Move Gateway Control Protocol (Context Tracking) into packet-h248.h

The Gateway Control Protocol (Context Tracking) is used by both H248
and MEGACO, so the functionality was refactored to epan, but should
really be kept in the dissector directory to minimize (and eventually
completely remove) the epan directory's dependence on it.

Change-Id: I387b46aecde97234086bfdb7d8c546854fa301cd
Reviewed-on: https://code.wireshark.org/review/15798
Petri-Dish: Michael Mann <mmann78@netscape.net>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Michael Mann <mmann78@netscape.net>

1 files changed, 739 insertions, 16 deletions

diff --git a/epan/dissectors/packet-h248.c b/epan/dissectors/packet-h248.c
index 38bdc079b7..f6d3fe1f49 100644
--- a/epan/dissectors/packet-h248.c
+++ b/epan/dissectors/packet-h248.c
@@ -33,10 +33,14 @@
 
 #include "config.h"
 
-#include <packet.h>
+#include <epan/packet.h>
 #include <epan/exceptions.h>
 #include <epan/tap.h>
+#include <epan/asn1.h>
+#include <epan/prefs.h>
 #include <epan/exported_pdu.h>
+#include "packet-alcap.h"
+#include "packet-ber.h"
 #include "packet-tpkt.h"
 #include "packet-mtp3.h"
 #include "packet-h248.h"
@@ -398,7 +402,7 @@ static int hf_h248_NotifyCompletion_otherReason = -1;
 static int hf_h248_NotifyCompletion_onIteration = -1;
 
 /*--- End of included file: packet-h248-hf.c ---*/
-#line 75 "./asn1/h248/packet-h248-template.c"
+#line 79 "./asn1/h248/packet-h248-template.c"
 
 /* Initialize the subtree pointers */
 static gint ett_h248 = -1;
@@ -566,7 +570,7 @@ static gint ett_h248_EventParameterV1 = -1;
 static gint ett_h248_SigParameterV1 = -1;
 
 /*--- End of included file: packet-h248-ett.c ---*/
-#line 95 "./asn1/h248/packet-h248-template.c"
+#line 99 "./asn1/h248/packet-h248-template.c"
 
 static expert_field ei_h248_errored_command = EI_INIT;
 static expert_field ei_h248_transactionId64 = EI_INIT;
@@ -575,10 +579,731 @@ static expert_field ei_h248_octet_string_expected = EI_INIT;
 
 static dissector_table_t subdissector_table;
 
-static wmem_tree_t* msgs = NULL;
-static wmem_tree_t* trxs = NULL;
-static wmem_tree_t* ctxs_by_trx = NULL;
-static wmem_tree_t* ctxs = NULL;
+/* Gateway Control Protocol -- Context Tracking */
+
+const value_string gcp_cmd_type[] = {
+    { GCP_CMD_NONE,               "NoCommand"},
+    { GCP_CMD_ADD_REQ,            "addReq"},
+    { GCP_CMD_MOVE_REQ,           "moveReq"},
+    { GCP_CMD_MOD_REQ,            "modReq"},
+    { GCP_CMD_SUB_REQ,            "subtractReq"},
+    { GCP_CMD_AUDITCAP_REQ,       "auditCapRequest"},
+    { GCP_CMD_AUDITVAL_REQ,       "auditValueRequest"},
+    { GCP_CMD_NOTIFY_REQ,         "notifyReq"},
+    { GCP_CMD_SVCCHG_REQ,         "serviceChangeReq"},
+    { GCP_CMD_TOPOLOGY_REQ,       "topologyReq"},
+    { GCP_CMD_CTX_ATTR_AUDIT_REQ, "ctxAttrAuditReq"},
+    { GCP_CMD_ADD_REPLY,          "addReply"},
+    { GCP_CMD_MOVE_REPLY,         "moveReply"},
+    { GCP_CMD_MOD_REPLY,          "modReply"},
+    { GCP_CMD_SUB_REPLY,          "subtractReply"},
+    { GCP_CMD_AUDITCAP_REPLY,     "auditCapReply"},
+    { GCP_CMD_AUDITVAL_REPLY,     "auditValReply"},
+    { GCP_CMD_NOTIFY_REPLY,       "notifyReply"},
+    { GCP_CMD_SVCCHG_REPLY,       "serviceChangeReply"},
+    { GCP_CMD_TOPOLOGY_REPLY,     "topologyReply"},
+    { 0, NULL }
+};
+
+const value_string gcp_term_types[] = {
+    { GCP_TERM_TYPE_AAL1,        "aal1" },
+    { GCP_TERM_TYPE_AAL2,        "aal2" },
+    { GCP_TERM_TYPE_AAL1_STRUCT, "aal1struct" },
+    { GCP_TERM_TYPE_IP_RTP,      "ipRtp" },
+    { GCP_TERM_TYPE_TDM,         "tdm" },
+    { 0, NULL }
+};
+
+static wmem_tree_t* gcp_msgs = NULL;
+static wmem_tree_t* gcp_trxs = NULL;
+static wmem_tree_t* gcp_ctxs_by_trx = NULL;
+static wmem_tree_t* gcp_ctxs = NULL;
+
+gcp_msg_t* gcp_msg(packet_info* pinfo, int o, gboolean keep_persistent_data) {
+    gcp_msg_t* m;
+    guint32 framenum = (guint32)pinfo->num;
+    guint32 offset = (guint32)o;
+    address* src = &(pinfo->src);
+    address* dst = &(pinfo->dst);
+    address* lo_addr;
+    address* hi_addr;
+
+    if (keep_persistent_data) {
+        wmem_tree_key_t key[3];
+
+        key[0].length = 1;
+        key[0].key = &(framenum);
+        key[1].length = 1;
+        key[1].key = &offset;
+        key[2].length = 0;
+        key[2].key =NULL;
+
+        if (( m = (gcp_msg_t *)wmem_tree_lookup32_array(gcp_msgs,key) )) {
+            m->committed = TRUE;
+            return m;
+        } else {
+            m = wmem_new(wmem_file_scope(), gcp_msg_t);
+            m->framenum = framenum;
+            m->time = pinfo->abs_ts;
+            m->trxs = NULL;
+            m->committed = FALSE;
+
+            wmem_tree_insert32_array(gcp_msgs,key,m);
+        }
+    } else {
+        m = wmem_new0(wmem_packet_scope(), gcp_msg_t);
+        m->framenum = framenum;
+        m->trxs = NULL;
+        m->committed = FALSE;
+    }
+
+    if (cmp_address(src, dst) < 0)  {
+        lo_addr = src;
+        hi_addr = dst;
+    } else {
+        lo_addr = dst;
+        hi_addr = src;
+    }
+
+    switch(lo_addr->type) {
+        case AT_NONE:
+            m->lo_addr = 0;
+            m->hi_addr = 0;
+            break;
+        case AT_IPv4:
+            memcpy((guint8*)&(m->hi_addr),hi_addr->data,4);
+            memcpy((guint8*)&(m->lo_addr),lo_addr->data,4);
+            break;
+        case AT_SS7PC:
+            m->hi_addr = mtp3_pc_hash((const mtp3_addr_pc_t *)hi_addr->data);
+            m->lo_addr = mtp3_pc_hash((const mtp3_addr_pc_t *)lo_addr->data);
+            break;
+        default:
+            /* XXX: heuristic and error prone */
+            m->hi_addr = g_str_hash(address_to_str(wmem_packet_scope(), hi_addr));
+            m->lo_addr = g_str_hash(address_to_str(wmem_packet_scope(), lo_addr));
+        break;
+    }
+
+    return m;
+}
+
+gcp_trx_t* gcp_trx(gcp_msg_t* m ,guint32 t_id , gcp_trx_type_t type, gboolean keep_persistent_data) {
+    gcp_trx_t* t = NULL;
+    gcp_trx_msg_t* trxmsg;
+
+    if ( !m ) return NULL;
+
+    if (keep_persistent_data) {
+        if (m->committed) {
+
+            for ( trxmsg = m->trxs; trxmsg; trxmsg = trxmsg->next) {
+                if (trxmsg->trx && trxmsg->trx->id == t_id) {
+                    return trxmsg->trx;
+                }
+            }
+            DISSECTOR_ASSERT_NOT_REACHED();
+        } else {
+            wmem_tree_key_t key[4];
+
+            key[0].length = 1;
+            key[0].key = &(m->hi_addr);
+            key[1].length = 1;
+            key[1].key = &(m->lo_addr);
+            key[2].length = 1;
+            key[2].key = &(t_id);
+            key[3].length = 0;
+            key[3].key = NULL;
+
+            trxmsg = wmem_new(wmem_file_scope(), gcp_trx_msg_t);
+            t = (gcp_trx_t *)wmem_tree_lookup32_array(gcp_trxs,key);
+
+            if (!t) {
+                t = wmem_new(wmem_file_scope(), gcp_trx_t);
+                t->initial = m;
+                t->id = t_id;
+                t->type = type;
+                t->pendings = 0;
+                t->error = 0;
+                t->cmds = NULL;
+
+                wmem_tree_insert32_array(gcp_trxs,key,t);
+            }
+
+            /* XXX: request, reply and ack + point to frames where they are */
+            switch ( type ) {
+                case GCP_TRX_PENDING:
+                    t->pendings++;
+                    break;
+                default:
+                    break;
+            }
+
+        }
+    } else {
+        t = wmem_new(wmem_packet_scope(), gcp_trx_t);
+        trxmsg = wmem_new(wmem_packet_scope(), gcp_trx_msg_t);
+        t->initial = NULL;
+        t->id = t_id;
+        t->type = type;
+        t->pendings = 0;
+        t->error = 0;
+        t->cmds = NULL;
+    }
+
+    DISSECTOR_ASSERT(trxmsg);
+
+    trxmsg->trx = t;
+    trxmsg->next = NULL;
+    trxmsg->last = trxmsg;
+
+    if (m->trxs) {
+        m->trxs->last = m->trxs->last->next = trxmsg;
+    } else {
+        m->trxs = trxmsg;
+    }
+
+    return t;
+}
+
+
+gcp_ctx_t* gcp_ctx(gcp_msg_t* m, gcp_trx_t* t, guint32 c_id, gboolean persistent) {
+    gcp_ctx_t* context = NULL;
+    gcp_ctx_t** context_p = NULL;
+
+    if ( !m || !t ) return NULL;
+
+    if (persistent) {
+
+        wmem_tree_key_t ctx_key[4];
+        wmem_tree_key_t trx_key[4];
+
+        ctx_key[0].length = 1;
+        ctx_key[0].key = &(m->hi_addr);
+        ctx_key[1].length = 1;
+        ctx_key[1].key = &(m->lo_addr);
+        ctx_key[2].length = 1;
+        ctx_key[2].key = &(c_id);
+        ctx_key[3].length = 0;
+        ctx_key[3].key = NULL;
+
+        trx_key[0].length = 1;
+        trx_key[0].key = &(m->hi_addr);
+        trx_key[1].length = 1;
+        trx_key[1].key = &(m->lo_addr);
+        trx_key[2].length = 1;
+        trx_key[2].key = &(t->id);
+        trx_key[3].length = 0;
+        trx_key[3].key = NULL;
+
+        if (m->committed) {
+            if (( context = (gcp_ctx_t *)wmem_tree_lookup32_array(gcp_ctxs_by_trx,trx_key) )) {
+                return context;
+            } if ((context_p = (gcp_ctx_t **)wmem_tree_lookup32_array(gcp_ctxs,ctx_key))) {
+                context = *context_p;
+
+                do {
+                    if (context->initial->framenum <= m->framenum) {
+                        return context;
+                    }
+                } while(( context = context->prev ));
+
+                DISSECTOR_ASSERT(! "a context should exist");
+            }
+        } else {
+            if (c_id == CHOOSE_CONTEXT) {
+                if (! ( context = (gcp_ctx_t *)wmem_tree_lookup32_array(gcp_ctxs_by_trx,trx_key))) {
+                    context = wmem_new(wmem_file_scope(), gcp_ctx_t);
+                    context->initial = m;
+                    context->cmds = NULL;
+                    context->id = c_id;
+                    context->terms.last = &(context->terms);
+                    context->terms.next = NULL;
+                    context->terms.term = NULL;
+
+                    wmem_tree_insert32_array(gcp_ctxs_by_trx,trx_key,context);
+                }
+            } else {
+                if (( context = (gcp_ctx_t *)wmem_tree_lookup32_array(gcp_ctxs_by_trx,trx_key) )) {
+                    if (( context_p = (gcp_ctx_t **)wmem_tree_lookup32_array(gcp_ctxs,ctx_key) )) {
+                        if (context != *context_p) {
+                            if(context->id != CHOOSE_CONTEXT) {
+                                context = wmem_new(wmem_file_scope(), gcp_ctx_t);
+                            }
+                            context->initial = m;
+                            context->id = c_id;
+                            context->cmds = NULL;
+                            context->terms.last = &(context->terms);
+                            context->terms.next = NULL;
+                            context->terms.term = NULL;
+
+                            context->prev = *context_p;
+                            *context_p = context;
+                        }
+                    } else {
+                        context_p = wmem_new(wmem_file_scope(), gcp_ctx_t*);
+                        *context_p = context;
+                        context->initial = m;
+                        context->id = c_id;
+                        wmem_tree_insert32_array(gcp_ctxs,ctx_key,context_p);
+                    }
+                } else if (! ( context_p = (gcp_ctx_t**)wmem_tree_lookup32_array(gcp_ctxs,ctx_key) )) {
+                    context = wmem_new(wmem_file_scope(), gcp_ctx_t);
+                    context->initial = m;
+                    context->id = c_id;
+                    context->cmds = NULL;
+                    context->terms.last = &(context->terms);
+                    context->terms.next = NULL;
+                    context->terms.term = NULL;
+
+                    context_p = wmem_new(wmem_file_scope(), gcp_ctx_t*);
+                    *context_p = context;
+                    wmem_tree_insert32_array(gcp_ctxs,ctx_key,context_p);
+                } else {
+                    context = *context_p;
+                }
+            }
+        }
+    } else {
+        context = wmem_new(wmem_packet_scope(), gcp_ctx_t);
+        context->initial = m;
+        context->cmds = NULL;
+        context->id = c_id;
+        context->terms.last = &(context->terms);
+        context->terms.next = NULL;
+        context->terms.term = NULL;
+    }
+
+    return context;
+}
+
+gcp_cmd_t* gcp_cmd(gcp_msg_t* m, gcp_trx_t* t, gcp_ctx_t* c, gcp_cmd_type_t type, guint offset, gboolean persistent) {
+    gcp_cmd_t* cmd;
+    gcp_cmd_msg_t* cmdtrx;
+    gcp_cmd_msg_t* cmdctx;
+
+    if ( !m || !t || !c ) return NULL;
+
+    if (persistent) {
+        if (m->committed) {
+            DISSECTOR_ASSERT(t->cmds != NULL);
+
+            for (cmdctx = t->cmds; cmdctx; cmdctx = cmdctx->next) {
+                cmd = cmdctx->cmd;
+                if (cmd->msg == m && cmd->offset == offset) {
+                    return cmd;
+                }
+            }
+
+            DISSECTOR_ASSERT(!"called for a command that does not exist!");
+
+            return NULL;
+        } else {
+            cmd = wmem_new(wmem_file_scope(), gcp_cmd_t);
+            cmdtrx = wmem_new(wmem_file_scope(), gcp_cmd_msg_t);
+            cmdctx = wmem_new(wmem_file_scope(), gcp_cmd_msg_t);
+        }
+    } else {
+        cmd = wmem_new(wmem_packet_scope(), gcp_cmd_t);
+        cmdtrx = wmem_new(wmem_packet_scope(), gcp_cmd_msg_t);
+        cmdctx = wmem_new(wmem_packet_scope(), gcp_cmd_msg_t);
+    }
+
+    cmd->type = type;
+    cmd->offset = offset;
+    cmd->terms.term = NULL;
+    cmd->terms.next = NULL;
+    cmd->terms.last = &(cmd->terms);
+    cmd->str = NULL;
+    cmd->msg = m;
+    if ((type != GCP_CMD_NONE) && (!persistent)){
+        cmd->str = val_to_str_const(type, gcp_cmd_type, "Unknown");
+    }
+    cmd->trx = t;
+    cmd->ctx = c;
+    cmd->error = 0;
+
+    cmdctx->cmd = cmdtrx->cmd = cmd;
+    cmdctx->next =  cmdtrx->next = NULL;
+    cmdctx->last = cmdtrx->last = NULL;
+
+    if (t->cmds) {
+        t->cmds->last->next = cmdtrx;
+        t->cmds->last = cmdtrx;
+    } else {
+        t->cmds = cmdtrx;
+        t->cmds->last = cmdtrx;
+    }
+
+    if (c->cmds) {
+        c->cmds->last->next = cmdctx;
+        c->cmds->last = cmdctx;
+    } else {
+        c->cmds = cmdctx;
+        c->cmds->last = cmdctx;
+    }
+
+    return cmd;
+}
+
+gcp_term_t* gcp_cmd_add_term(gcp_msg_t* m, gcp_trx_t* tr, gcp_cmd_t* c, gcp_term_t* t, gcp_wildcard_t wildcard, gboolean persistent) {
+    gcp_terms_t* ct;
+    gcp_terms_t* ct2;
+
+    static gcp_term_t all_terms = {"$",(const guint8*)"",1,GCP_TERM_TYPE_UNKNOWN,NULL,NULL,NULL};
+
+    if ( !c ) return NULL;
+
+    if ( wildcard == GCP_WILDCARD_CHOOSE) {
+        return &all_terms;
+    }
+
+    if (persistent) {
+        if ( c->msg->committed ) {
+            if (wildcard == GCP_WILDCARD_ALL) {
+                for (ct = c->ctx->terms.next; ct; ct = ct->next) {
+                    /* XXX not handling more wilcards in one msg */
+                    if ( ct->term->start == m ) {
+                        return ct->term;
+                    }
+                }
+                return NULL;
+            } else {
+                for (ct = c->ctx->terms.next; ct; ct = ct->next) {
+                    if ( g_str_equal(ct->term->str,t->str) ) {
+                        return ct->term;
+                    }
+                }
+                return NULL;
+            }
+        } else {
+
+            for (ct = c->ctx->terms.next; ct; ct = ct->next) {
+                if ( g_str_equal(ct->term->str,t->str) || ct->term->start == m) {
+                    break;
+                }
+            }
+
+            if ( ! ct ) {
+
+                if (wildcard == GCP_WILDCARD_ALL) {
+                    ct = wmem_new(wmem_file_scope(), gcp_terms_t);
+                    ct->next = NULL;
+                    ct->term = wmem_new0(wmem_file_scope(), gcp_term_t);
+
+                    ct->term->start = m;
+                    ct->term->str = "*";
+                    ct->term->buffer = NULL;
+                    ct->term->len = 0;
+
+                    c->terms.last = c->terms.last->next = ct;
+
+                    ct2 = wmem_new0(wmem_file_scope(), gcp_terms_t);
+                    ct2->term = ct->term;
+
+                    c->ctx->terms.last->next = ct2;
+                    c->ctx->terms.last = ct2;
+
+                    return ct->term;
+                } else {
+                    for (ct = c->ctx->terms.next; ct; ct = ct->next) {
+                        /* XXX not handling more wilcards in one msg */
+                        if ( ct->term->buffer == NULL && tr->cmds->cmd->msg == ct->term->start ) {
+                            ct->term->str = wmem_strdup(wmem_file_scope(), t->str);
+                            ct->term->buffer = (const guint8 *)wmem_memdup(wmem_file_scope(), t->buffer,t->len);
+                            ct->term->len = t->len;
+
+                            ct2 = wmem_new0(wmem_file_scope(), gcp_terms_t);
+                            ct2->term = ct->term;
+
+                            c->terms.last = c->terms.last->next = ct2;
+
+                            return ct->term;
+                        }
+
+                        if  ( g_str_equal(ct->term->str,t->str) ) {
+                            ct2 = wmem_new0(wmem_file_scope(), gcp_terms_t);
+                            ct2->term = ct->term;
+
+                            c->terms.last = c->terms.last->next = ct2;
+
+                            return ct->term;
+                        }
+                    }
+
+                    ct = wmem_new(wmem_file_scope(), gcp_terms_t);
+                    ct->next = NULL;
+                    ct->term = wmem_new0(wmem_file_scope(), gcp_term_t);
+
+                    ct->term->start = m;
+                    ct->term->str = wmem_strdup(wmem_file_scope(), t->str);
+                    ct->term->buffer = (const guint8 *)wmem_memdup(wmem_file_scope(), t->buffer,t->len);
+                    ct->term->len = t->len;
+
+                    ct2 = wmem_new0(wmem_file_scope(), gcp_terms_t);
+                    ct2->term = ct->term;
+
+                    c->terms.last = c->terms.last->next = ct2;
+
+                    ct2 = wmem_new0(wmem_file_scope(), gcp_terms_t);
+                    ct2->term = ct->term;
+
+                    c->ctx->terms.last = c->ctx->terms.last->next = ct2;
+
+                    return ct->term;
+                }
+            } else {
+                ct2 = wmem_new0(wmem_file_scope(), gcp_terms_t);
+                ct2->term = ct->term;
+
+                c->terms.last = c->terms.last->next = ct2;
+                return ct->term;
+            }
+
+            DISSECTOR_ASSERT_NOT_REACHED();
+        }
+    } else {
+        ct = wmem_new(wmem_packet_scope(), gcp_terms_t);
+        ct->term = t;
+        ct->next = NULL;
+        c->terms.last = c->terms.last->next = ct;
+
+        return t;
+    }
+
+}
+
+static const gchar* gcp_cmd_to_str(gcp_cmd_t* c, gboolean persistent) {
+    const gchar* s;
+    gcp_terms_t* term;
+
+    if ( !c ) return "-";
+
+    switch (c->type) {
+        case GCP_CMD_NONE:
+            return "-";
+            break;
+        case GCP_CMD_ADD_REQ:
+            s = "AddReq {";
+            break;
+        case GCP_CMD_MOVE_REQ:
+            s = "MoveReq {";
+            break;
+        case GCP_CMD_MOD_REQ:
+            s = "ModReq {";
+            break;
+        case GCP_CMD_SUB_REQ:
+            s = "SubReq {";
+            break;
+        case GCP_CMD_AUDITCAP_REQ:
+            s = "AuditCapReq {";
+            break;
+        case GCP_CMD_AUDITVAL_REQ:
+            s = "AuditValReq {";
+            break;
+        case GCP_CMD_NOTIFY_REQ:
+            s = "NotifyReq {";
+            break;
+        case GCP_CMD_SVCCHG_REQ:
+            s = "SvcChgReq {";
+            break;
+        case GCP_CMD_TOPOLOGY_REQ:
+            s = "TopologyReq {";
+            break;
+        case GCP_CMD_CTX_ATTR_AUDIT_REQ:
+            s = "CtxAttribAuditReq {";
+            break;
+        case GCP_CMD_ADD_REPLY:
+            s = "AddReply {";
+            break;
+        case GCP_CMD_MOVE_REPLY:
+            s = "MoveReply {";
+            break;
+        case GCP_CMD_MOD_REPLY:
+            s = "ModReply {";
+            break;
+        case GCP_CMD_SUB_REPLY:
+            s = "SubReply {";
+            break;
+        case GCP_CMD_AUDITCAP_REPLY:
+            s = "AuditCapReply {";
+            break;
+        case GCP_CMD_AUDITVAL_REPLY:
+            s = "AuditValReply {";
+            break;
+        case GCP_CMD_NOTIFY_REPLY:
+            s = "NotifyReply {";
+            break;
+        case GCP_CMD_SVCCHG_REPLY:
+            s = "SvcChgReply {";
+            break;
+        case GCP_CMD_TOPOLOGY_REPLY:
+            s = "TopologyReply {";
+            break;
+        case GCP_CMD_REPLY:
+            s = "ActionReply {";
+            break;
+        case GCP_CMD_OTHER_REQ:
+            s = "Request {";
+            break;
+        default:
+            s = "-";
+            break;
+    }
+
+    for (term = c->terms.next; term; term = term->next) {
+        s = wmem_strdup_printf(wmem_packet_scope(), "%s %s",s,term->term->str);
+    }
+
+    if (c->error) {
+        s = wmem_strdup_printf(wmem_packet_scope(), "%s Error=%i",s,c->error);
+    }
+
+    s = wmem_strdup_printf(wmem_packet_scope(), "%s }", s);
+
+    if (persistent) {
+        if (! c->str) c->str = wmem_strdup(wmem_file_scope(), s);
+    } else {
+        c->str = s;
+    }
+
+    return s;
+}
+
+static const gchar* gcp_trx_to_str(gcp_msg_t* m, gcp_trx_t* t, gboolean persistent) {
+    gchar* s;
+    gcp_cmd_msg_t* c;
+
+    if ( !m || !t ) return "-";
+
+    s = wmem_strdup_printf(wmem_packet_scope(), "T %x { ",t->id);
+
+    if (t->cmds) {
+        if (t->cmds->cmd->ctx) {
+            s = wmem_strdup_printf(wmem_packet_scope(), "%s C %x {",s,t->cmds->cmd->ctx->id);
+
+            for (c = t->cmds; c; c = c->next) {
+                if (c->cmd->msg == m) {
+                    s = wmem_strdup_printf(wmem_packet_scope(), "%s %s",s,gcp_cmd_to_str(c->cmd,persistent));
+                }
+            }
+
+            s = wmem_strdup_printf(wmem_packet_scope(), "%s %s",s,"}");
+        }
+    }
+
+    if (t->error) {
+        s = wmem_strdup_printf(wmem_packet_scope(), "%s Error=%i",s,t->error);
+    }
+
+    return wmem_strdup_printf(wmem_packet_scope(), "%s %s",s,"}");
+}
+
+const gchar* gcp_msg_to_str(gcp_msg_t* m, gboolean persistent) {
+    gcp_trx_msg_t* t;
+    const gchar* s = "";
+
+    if ( !m ) return "-";
+
+    for (t = m->trxs; t; t = t->next) {
+        s = wmem_strdup_printf(wmem_packet_scope(), "%s %s",s,gcp_trx_to_str(m,t->trx, persistent));
+    }
+
+    return s;
+}
+
+typedef struct _gcp_ctxs_t {
+    struct _gcp_ctx_t* ctx;
+    struct _gcp_ctxs_t* next;
+} gcp_ctxs_t;
+
+/*static const gchar* trx_types[] = {"None","Req","Reply","Pending","Ack"};*/
+
+void gcp_analyze_msg(proto_tree* gcp_tree, packet_info* pinfo, tvbuff_t* gcp_tvb, gcp_msg_t* m, gcp_hf_ett_t* ids, expert_field* command_err) {
+    gcp_trx_msg_t* t;
+    gcp_ctxs_t contexts = {NULL,NULL};
+    gcp_ctxs_t* ctx_node;
+    gcp_cmd_msg_t* c;
+
+
+    for (t = m->trxs; t; t = t->next) {
+        for (c = t->trx->cmds; c; c = c->next) {
+            gcp_ctx_t* ctx = c->cmd->ctx;
+
+            for (ctx_node = contexts.next; ctx_node; ctx_node = ctx_node->next) {
+                if (ctx_node->ctx->id == ctx->id) {
+                    break;
+                }
+            }
+
+            if (! ctx_node) {
+                ctx_node = wmem_new(wmem_packet_scope(), gcp_ctxs_t);
+                ctx_node->ctx = ctx;
+                ctx_node->next = contexts.next;
+                contexts.next = ctx_node;
+            }
+        }
+    }
+
+    for (ctx_node = contexts.next; ctx_node; ctx_node = ctx_node->next) {
+        gcp_ctx_t* ctx = ctx_node->ctx;
+        proto_item* ctx_item = proto_tree_add_uint(gcp_tree,ids->hf.ctx,gcp_tvb,0,0,ctx->id);
+        proto_tree* ctx_tree = proto_item_add_subtree(ctx_item,ids->ett.ctx);
+        gcp_terms_t *ctx_term;
+
+        PROTO_ITEM_SET_GENERATED(ctx_item);
+
+        if (ctx->cmds) {
+            proto_tree* history_tree = proto_tree_add_subtree(ctx_tree,gcp_tvb,0,0,ids->ett.ctx_cmds,NULL,"[ Command History ]");
+
+            for (c = ctx->cmds; c; c = c->next) {
+                proto_item* cmd_item = proto_tree_add_uint(history_tree,ids->hf.ctx_cmd,gcp_tvb,0,0,c->cmd->msg->framenum);
+                if (c->cmd->str) proto_item_append_text(cmd_item,"  %s ",c->cmd->str);
+                PROTO_ITEM_SET_GENERATED(cmd_item);
+                if (c->cmd->error) {
+                    expert_add_info(pinfo, cmd_item, command_err);
+                }
+            }
+        }
+
+        if (( ctx_term = ctx->terms.next )) {
+            proto_tree* terms_tree = proto_tree_add_subtree(ctx_tree,gcp_tvb,0,0,ids->ett.ctx_terms,NULL,"[ Terminations Used ]");
+
+            for (; ctx_term; ctx_term = ctx_term->next ) {
+                if ( ctx_term->term && ctx_term->term->str) {
+                    proto_item* pi = proto_tree_add_string(terms_tree,ids->hf.ctx_term,gcp_tvb,0,0,ctx_term->term->str);
+                    proto_tree* term_tree = proto_item_add_subtree(pi,ids->ett.ctx_term);
+
+                    PROTO_ITEM_SET_GENERATED(pi);
+
+                    if (ctx_term->term->type) {
+                        pi = proto_tree_add_uint(term_tree,ids->hf.ctx_term_type,gcp_tvb,0,0,ctx_term->term->type);
+                        PROTO_ITEM_SET_GENERATED(pi);
+                    }
+
+                    if (ctx_term->term->bir) {
+                        pi = proto_tree_add_string(term_tree,ids->hf.ctx_term_bir,gcp_tvb,0,0,ctx_term->term->bir);
+                        PROTO_ITEM_SET_GENERATED(pi);
+                    }
+
+                    if (ctx_term->term->nsap) {
+                        pi = proto_tree_add_string(term_tree,ids->hf.ctx_term_nsap,gcp_tvb,0,0,ctx_term->term->nsap);
+                        PROTO_ITEM_SET_GENERATED(pi);
+                    }
+
+                    if (ctx_term->term->bir && ctx_term->term->nsap) {
+                        gchar* tmp_key = wmem_strdup_printf(wmem_packet_scope(), "%s:%s",ctx_term->term->nsap,ctx_term->term->bir);
+                        gchar* key = g_ascii_strdown(tmp_key, -1);
+                        alcap_tree_from_bearer_key(term_tree, gcp_tvb, pinfo, key);
+                        g_free(key);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/* END Gateway Control Protocol -- Context Tracking */
 
 static gboolean keep_persistent_data = FALSE;
 static guint    global_udp_port = 2945;
@@ -5365,7 +6090,7 @@ dissect_h248_SigParameterV1(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int of
 
 
 /*--- End of included file: packet-h248-fn.c ---*/
-#line 1443 "./asn1/h248/packet-h248-template.c"
+#line 2168 "./asn1/h248/packet-h248-template.c"
 
 static int dissect_h248_tpkt(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) {
     dissect_tpkt_encap(tvb, pinfo, tree, h248_desegment, h248_handle);
@@ -6791,7 +7516,7 @@ void proto_register_h248(void) {
         NULL, HFILL }},
 
 /*--- End of included file: packet-h248-hfarr.c ---*/
-#line 1612 "./asn1/h248/packet-h248-template.c"
+#line 2337 "./asn1/h248/packet-h248-template.c"
 
         GCP_HF_ARR_ELEMS("h248",h248_arrel)
 
@@ -6957,7 +7682,7 @@ void proto_register_h248(void) {
     &ett_h248_SigParameterV1,
 
 /*--- End of included file: packet-h248-ettarr.c ---*/
-#line 1630 "./asn1/h248/packet-h248-template.c"
+#line 2355 "./asn1/h248/packet-h248-template.c"
     };
 
     static ei_register_info ei[] = {
@@ -7003,14 +7728,12 @@ void proto_register_h248(void) {
                                    "Desegment H.248 messages that span more TCP segments",
                                    &h248_desegment);
 
-    msgs        = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
-    trxs        = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
-    ctxs_by_trx = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
-    ctxs        = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
+    gcp_msgs        = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
+    gcp_trxs        = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
+    gcp_ctxs_by_trx = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
+    gcp_ctxs        = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
 
     h248_tap = register_tap("h248");
-
-    gcp_init();
 }
 
 /*--- proto_reg_handoff_h248 -------------------------------------------*/