Don't look at pinfo->pseudo_header.

On the off chance that UMTS FP traffic is being carried over a
pseudowire. :-)

Change-Id: I8db0fbe96545c08f4748bf9ec046e2dc4f2c2cc6
Reviewed-on: https://code.wireshark.org/review/13342
Reviewed-by: Guy Harris <guy@alum.mit.edu>

4 files changed, 205 insertions, 153 deletions

diff --git a/epan/dissectors/packet-rlc.c b/epan/dissectors/packet-rlc.c
index 4042fb3df0..3dae5ca0ae 100644
--- a/epan/dissectors/packet-rlc.c
+++ b/epan/dissectors/packet-rlc.c
@@ -343,13 +343,11 @@ rlc_channel_equal(gconstpointer a, gconstpointer b)
 }
 
 static int
-rlc_channel_assign(struct rlc_channel *ch, enum rlc_mode mode, packet_info *pinfo)
+rlc_channel_assign(struct rlc_channel *ch, enum rlc_mode mode, packet_info *pinfo, struct atm_phdr *atm)
 {
-    struct atm_phdr *atm;
     rlc_info        *rlcinf;
     fp_info         *fpinf;
 
-    atm = &pinfo->pseudo_header->atm;
     fpinf = (fp_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_fp, 0);
     rlcinf = (rlc_info *)p_get_proto_data(wmem_file_scope(), pinfo, proto_rlc, 0);
     if (!fpinf || !rlcinf) return -1;
@@ -374,13 +372,13 @@ rlc_channel_assign(struct rlc_channel *ch, enum rlc_mode mode, packet_info *pinf
 }
 
 static struct rlc_channel *
-rlc_channel_create(enum rlc_mode mode, packet_info *pinfo)
+rlc_channel_create(enum rlc_mode mode, packet_info *pinfo, struct atm_phdr *atm)
 {
     struct rlc_channel *ch;
     int rv;
 
     ch = (struct rlc_channel *)g_malloc0(sizeof(struct rlc_channel));
-    rv = rlc_channel_assign(ch, mode, pinfo);
+    rv = rlc_channel_assign(ch, mode, pinfo, atm);
 
     if (rv != 0) {
         /* channel assignment failed */
@@ -457,14 +455,14 @@ rlc_sdu_frags_delete(gpointer data)
 
 static int
 rlc_frag_assign(struct rlc_frag *frag, enum rlc_mode mode, packet_info *pinfo,
-        guint16 seq, guint16 li)
+        guint16 seq, guint16 li, struct atm_phdr *atm)
 {
     frag->frame_num = pinfo->fd->num;
     frag->seq       = seq;
     frag->li        = li;
     frag->len       = 0;
     frag->data      = NULL;
-    rlc_channel_assign(&frag->ch, mode, pinfo);
+    rlc_channel_assign(&frag->ch, mode, pinfo, atm);
 
     return 0;
 }
@@ -481,12 +479,13 @@ rlc_frag_assign_data(struct rlc_frag *frag, tvbuff_t *tvb,
 
 static struct rlc_frag *
 rlc_frag_create(tvbuff_t *tvb, enum rlc_mode mode, packet_info *pinfo,
-        guint16 offset, guint16 length, guint16 seq, guint16 li)
+        guint16 offset, guint16 length, guint16 seq, guint16 li,
+        struct atm_phdr *atm)
 {
     struct rlc_frag *frag;
 
     frag = (struct rlc_frag *)wmem_alloc0(wmem_file_scope(), sizeof(struct rlc_frag));
-    rlc_frag_assign(frag, mode, pinfo, seq, li);
+    rlc_frag_assign(frag, mode, pinfo, seq, li, atm);
     rlc_frag_assign_data(frag, tvb, offset, length);
 
     return frag;
@@ -880,7 +879,7 @@ printends(GList * list)
 #endif
 
 static struct rlc_frag **
-get_frags(packet_info * pinfo, struct rlc_channel * ch_lookup)
+get_frags(packet_info * pinfo, struct rlc_channel * ch_lookup, struct atm_phdr *atm)
 {
     gpointer value = NULL;
     struct rlc_frag ** frags = NULL;
@@ -889,7 +888,7 @@ get_frags(packet_info * pinfo, struct rlc_channel * ch_lookup)
         frags = (struct rlc_frag **)value;
     } else if (pinfo != NULL) {
         struct rlc_channel *ch;
-        ch = rlc_channel_create(ch_lookup->mode, pinfo);
+        ch = rlc_channel_create(ch_lookup->mode, pinfo, atm);
         frags = (struct rlc_frag **)wmem_alloc0(wmem_file_scope(), sizeof(struct rlc_frag *) * 4096);
         g_hash_table_insert(fragment_table, ch, frags);
     } else {
@@ -898,7 +897,7 @@ get_frags(packet_info * pinfo, struct rlc_channel * ch_lookup)
     return frags;
 }
 static struct rlc_seqlist *
-get_endlist(packet_info * pinfo, struct rlc_channel * ch_lookup)
+get_endlist(packet_info * pinfo, struct rlc_channel * ch_lookup, struct atm_phdr *atm)
 {
     gpointer value = NULL;
     struct rlc_seqlist * endlist = NULL;
@@ -909,7 +908,7 @@ get_endlist(packet_info * pinfo, struct rlc_channel * ch_lookup)
         struct rlc_channel * ch;
 
         endlist = wmem_new(wmem_file_scope(), struct rlc_seqlist);
-        ch = rlc_channel_create(ch_lookup->mode, pinfo);
+        ch = rlc_channel_create(ch_lookup->mode, pinfo, atm);
         endlist->fail_packet = 0;
         endlist->list = NULL;
         endlist->list = g_list_prepend(endlist->list, GINT_TO_POINTER(-1));
@@ -955,7 +954,8 @@ reassemble_sequence(struct rlc_frag ** frags, struct rlc_seqlist * endlist,
 /* Reset the specified channel's reassembly data, useful for when a sequence
  * resets on transport channel swap. */
 void
-rlc_reset_channel(enum rlc_mode mode, guint8 rbid, guint8 dir, guint32 urnti)
+rlc_reset_channel(enum rlc_mode mode, guint8 rbid, guint8 dir, guint32 urnti,
+                  struct atm_phdr *atm)
 {
     struct rlc_frag ** frags = NULL;
     struct rlc_seqlist * endlist = NULL;
@@ -966,8 +966,8 @@ rlc_reset_channel(enum rlc_mode mode, guint8 rbid, guint8 dir, guint32 urnti)
     ch_lookup.rbid = rbid;
     ch_lookup.dir = dir;
     ch_lookup.urnti = urnti;
-    frags = get_frags(NULL, &ch_lookup);
-    endlist = get_endlist(NULL, &ch_lookup);
+    frags = get_frags(NULL, &ch_lookup, atm);
+    endlist = get_endlist(NULL, &ch_lookup, atm);
     DISSECTOR_ASSERT(frags && endlist);
 
     endlist->fail_packet = 0;
@@ -985,7 +985,7 @@ rlc_reset_channel(enum rlc_mode mode, guint8 rbid, guint8 dir, guint32 urnti)
 static struct rlc_frag *
 add_fragment(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo,
          proto_tree *tree, guint16 offset, guint16 seq, guint16 num_li,
-         guint16 len, gboolean final)
+         guint16 len, gboolean final, struct atm_phdr *atm)
 {
     struct rlc_channel  ch_lookup;
     struct rlc_frag     frag_lookup, *frag = NULL;
@@ -996,10 +996,10 @@ add_fragment(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo,
     GList * element = NULL;
     int snmod;
 
-    if (rlc_channel_assign(&ch_lookup, mode, pinfo) == -1) {
+    if (rlc_channel_assign(&ch_lookup, mode, pinfo, atm) == -1) {
         return NULL;
     }
-    rlc_frag_assign(&frag_lookup, mode, pinfo, seq, num_li);
+    rlc_frag_assign(&frag_lookup, mode, pinfo, seq, num_li, atm);
     #if RLC_ADD_FRAGMENT_DEBUG_PRINT
         g_print("packet: %d, channel (%d %d %d) seq: %u, num_li: %u, offset: %u, \n", pinfo->fd->num, ch_lookup.dir, ch_lookup.rbid, ch_lookup.urnti, seq, num_li, offset);
     #endif
@@ -1021,8 +1021,8 @@ add_fragment(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo,
         return frag;
     }
 
-    frags = get_frags(pinfo, &ch_lookup);
-    endlist = get_endlist(pinfo, &ch_lookup);
+    frags = get_frags(pinfo, &ch_lookup, atm);
+    endlist = get_endlist(pinfo, &ch_lookup, atm);
 
     /* If already done reassembly */
     if (pinfo->fd->flags.visited) {
@@ -1074,7 +1074,7 @@ add_fragment(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo,
         return NULL;
     }
 
-    frag = rlc_frag_create(tvb, mode, pinfo, offset, len, seq, num_li);
+    frag = rlc_frag_create(tvb, mode, pinfo, offset, len, seq, num_li, atm);
 
     /* If frags[seq] is not NULL then we must have data from several PDUs in the
      * same RLC packet (using Length Indicators) or something has gone terribly
@@ -1190,13 +1190,14 @@ too far away from an unfinished sequence with start %u and without end.", pinfo-
  */
 static tvbuff_t *
 get_reassembled_data(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo,
-             proto_tree *tree, guint16 seq, guint16 num_li)
+             proto_tree *tree, guint16 seq, guint16 num_li,
+             struct atm_phdr *atm)
 {
     gpointer         orig_frag, orig_sdu;
     struct rlc_sdu  *sdu;
     struct rlc_frag  lookup, *frag;
 
-    rlc_frag_assign(&lookup, mode, pinfo, seq, num_li);
+    rlc_frag_assign(&lookup, mode, pinfo, seq, num_li, atm);
 
     if (!g_hash_table_lookup_extended(reassembled_table, &lookup,
         &orig_frag, &orig_sdu))
@@ -1234,19 +1235,19 @@ get_reassembled_data(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo,
 #define RLC_RETRANSMISSION_TIMEOUT 5 /* in seconds */
 static gboolean
 rlc_is_duplicate(enum rlc_mode mode, packet_info *pinfo, guint16 seq,
-         guint32 *original)
+         guint32 *original, struct atm_phdr *atm)
 {
     GList              *element;
     struct rlc_seqlist  lookup, *list;
     struct rlc_seq      seq_item, *seq_new;
     guint16 snmod;
 
-    rlc_channel_assign(&lookup.ch, mode, pinfo);
+    rlc_channel_assign(&lookup.ch, mode, pinfo, atm);
     list = (struct rlc_seqlist *)g_hash_table_lookup(sequence_table, &lookup.ch);
     if (!list) {
         /* we see this channel for the first time */
         list = (struct rlc_seqlist *)wmem_alloc0(wmem_file_scope(), sizeof(*list));
-        rlc_channel_assign(&list->ch, mode, pinfo);
+        rlc_channel_assign(&list->ch, mode, pinfo, atm);
         g_hash_table_insert(sequence_table, &list->ch, list);
     }
     seq_item.seq = seq;
@@ -1609,7 +1610,8 @@ dissect_rlc_tm(enum rlc_channel_type channel, tvbuff_t *tvb, packet_info *pinfo,
 static void
 rlc_um_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo, proto_tree *tree,
           proto_tree *top_level, enum rlc_channel_type channel, guint16 seq,
-          struct rlc_li *li, guint16 num_li, gboolean li_is_on_2_bytes)
+          struct rlc_li *li, guint16 num_li, gboolean li_is_on_2_bytes,
+          struct atm_phdr *atm)
 {
     guint8    i;
     gboolean  dissected = FALSE;
@@ -1628,8 +1630,8 @@ rlc_um_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo, proto_tree *tr
             /* a new SDU starts here, mark this seq as the first PDU. */
             struct rlc_channel  ch_lookup;
             struct rlc_seqlist * endlist = NULL;
-            if( -1 != rlc_channel_assign(&ch_lookup, RLC_UM, pinfo ) ){
-                endlist = get_endlist(pinfo, &ch_lookup);
+            if( -1 != rlc_channel_assign(&ch_lookup, RLC_UM, pinfo, atm ) ){
+                endlist = get_endlist(pinfo, &ch_lookup, atm);
                 endlist->list->data = GINT_TO_POINTER((gint)seq);
                 endlist->fail_packet=0;
             }
@@ -1644,8 +1646,8 @@ rlc_um_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo, proto_tree *tr
                     proto_tree_add_item(tree, hf_rlc_data, tvb, offs, length, ENC_NA);
                 }
                 if (global_rlc_perform_reassemby) {
-                    add_fragment(RLC_UM, tvb, pinfo, li[i].tree, offs, seq, i, length, TRUE);
-                    next_tvb = get_reassembled_data(RLC_UM, tvb, pinfo, tree, seq, i);
+                    add_fragment(RLC_UM, tvb, pinfo, li[i].tree, offs, seq, i, length, TRUE, atm);
+                    next_tvb = get_reassembled_data(RLC_UM, tvb, pinfo, tree, seq, i, atm);
                 }
                 offs += length;
             }
@@ -1658,8 +1660,8 @@ rlc_um_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo, proto_tree *tr
                 proto_tree_add_item(tree, hf_rlc_data, tvb, offs, li[i].len, ENC_NA);
             }
             if (global_rlc_perform_reassemby) {
-                add_fragment(RLC_UM, tvb, pinfo, li[i].tree, offs, seq, i, li[i].len, TRUE);
-                next_tvb = get_reassembled_data(RLC_UM, tvb, pinfo, tree, seq, i);
+                add_fragment(RLC_UM, tvb, pinfo, li[i].tree, offs, seq, i, li[i].len, TRUE, atm);
+                next_tvb = get_reassembled_data(RLC_UM, tvb, pinfo, tree, seq, i, atm);
             }
         }
         if (next_tvb) {
@@ -1677,7 +1679,7 @@ rlc_um_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo, proto_tree *tr
         }
         if (global_rlc_perform_reassemby) {
             /* add remaining data as fragment */
-            add_fragment(RLC_UM, tvb, pinfo, tree, offs, seq, i, tvb_captured_length_remaining(tvb, offs), FALSE);
+            add_fragment(RLC_UM, tvb, pinfo, tree, offs, seq, i, tvb_captured_length_remaining(tvb, offs), FALSE, atm);
             if (dissected == FALSE)
                 col_set_str(pinfo->cinfo, COL_INFO, "[RLC UM Fragment]");
         }
@@ -1821,7 +1823,7 @@ rlc_decode_li(enum rlc_mode mode, tvbuff_t *tvb, packet_info *pinfo, proto_tree
 
 static void
 dissect_rlc_um(enum rlc_channel_type channel, tvbuff_t *tvb, packet_info *pinfo,
-           proto_tree *top_level, proto_tree *tree)
+           proto_tree *top_level, proto_tree *tree, struct atm_phdr *atm)
 {
 #define MAX_LI 16
     struct rlc_li  li[MAX_LI];
@@ -1900,12 +1902,12 @@ dissect_rlc_um(enum rlc_channel_type channel, tvbuff_t *tvb, packet_info *pinfo,
     /* do not detect duplicates or reassemble, if prefiltering is done */
     if (pinfo->fd->num == 0) return;
     /* check for duplicates */
-    if (rlc_is_duplicate(RLC_UM, pinfo, seq, &orig_num) == TRUE) {
+    if (rlc_is_duplicate(RLC_UM, pinfo, seq, &orig_num, atm) == TRUE) {
         col_add_fstr(pinfo->cinfo, COL_INFO, "[RLC UM Fragment] [Duplicate]  SN=%u", seq);
         proto_tree_add_uint(tree, hf_rlc_duplicate_of, tvb, 0, 0, orig_num);
         return;
     }
-    rlc_um_reassemble(tvb, offs, pinfo, tree, top_level, channel, seq, li, num_li, li_is_on_2_bytes);
+    rlc_um_reassemble(tvb, offs, pinfo, tree, top_level, channel, seq, li, num_li, li_is_on_2_bytes, atm);
 }
 
 static void
@@ -2138,7 +2140,8 @@ static void
 rlc_am_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo,
           proto_tree *tree, proto_tree *top_level,
           enum rlc_channel_type channel, guint16 seq, gboolean poll_set, struct rlc_li *li,
-          guint16 num_li, gboolean final, gboolean li_is_on_2_bytes)
+          guint16 num_li, gboolean final, gboolean li_is_on_2_bytes,
+          struct atm_phdr *atm)
 {
     guint8    i;
     gboolean  piggyback = FALSE, dissected = FALSE;
@@ -2147,8 +2150,8 @@ rlc_am_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo,
     struct rlc_channel  ch_lookup;
     struct rlc_seqlist * endlist = NULL;
     if( 0 == seq ){ /* assuming that a new RRC Connection is established when 0==seq.  */
-        if( -1 != rlc_channel_assign(&ch_lookup, RLC_AM, pinfo ) ){
-            endlist = get_endlist(pinfo, &ch_lookup);
+        if( -1 != rlc_channel_assign(&ch_lookup, RLC_AM, pinfo, atm ) ){
+            endlist = get_endlist(pinfo, &ch_lookup, atm);
             endlist->list->data = GINT_TO_POINTER( -1);
         }
     }
@@ -2166,7 +2169,7 @@ rlc_am_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo,
                 }
                 if (i == 0) {
                     /* Insert empty RLC frag so RLC doesn't miss this seq number. */
-                    add_fragment(RLC_AM, tvb, pinfo, li[i].tree, offs, seq, i, 0, TRUE);
+                    add_fragment(RLC_AM, tvb, pinfo, li[i].tree, offs, seq, i, 0, TRUE, atm);
                 }
             }
             offs += tvb_captured_length_remaining(tvb, offs);
@@ -2175,8 +2178,8 @@ rlc_am_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo,
                 proto_tree_add_item(tree, hf_rlc_data, tvb, offs, li[i].len, ENC_NA);
             }
             if (global_rlc_perform_reassemby) {
-                add_fragment(RLC_AM, tvb, pinfo, li[i].tree, offs, seq, i, li[i].len, TRUE);
-                next_tvb = get_reassembled_data(RLC_AM, tvb, pinfo, tree, seq, i);
+                add_fragment(RLC_AM, tvb, pinfo, li[i].tree, offs, seq, i, li[i].len, TRUE, atm);
+                next_tvb = get_reassembled_data(RLC_AM, tvb, pinfo, tree, seq, i, atm);
             }
         }
         if (next_tvb) {
@@ -2197,9 +2200,9 @@ rlc_am_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo,
             }
             if (global_rlc_perform_reassemby) {
                 add_fragment(RLC_AM, tvb, pinfo, tree, offs, seq, i,
-                    tvb_captured_length_remaining(tvb,offs), final);
+                    tvb_captured_length_remaining(tvb,offs), final, atm);
                 if (final) {
-                    next_tvb = get_reassembled_data(RLC_AM, tvb, pinfo, tree, seq, i);
+                    next_tvb = get_reassembled_data(RLC_AM, tvb, pinfo, tree, seq, i, atm);
                 }
             }
         }
@@ -2220,7 +2223,7 @@ rlc_am_reassemble(tvbuff_t *tvb, guint8 offs, packet_info *pinfo,
 
 static void
 dissect_rlc_am(enum rlc_channel_type channel, tvbuff_t *tvb, packet_info *pinfo,
-           proto_tree *top_level, proto_tree *tree)
+           proto_tree *top_level, proto_tree *tree, struct atm_phdr *atm)
 {
 #define MAX_LI 16
     struct rlc_li  li[MAX_LI];
@@ -2320,7 +2323,7 @@ dissect_rlc_am(enum rlc_channel_type channel, tvbuff_t *tvb, packet_info *pinfo,
     /* do not detect duplicates or reassemble, if prefiltering is done */
     if (pinfo->fd->num == 0) return;
     /* check for duplicates, but not if already visited */
-    if (pinfo->fd->flags.visited == FALSE && rlc_is_duplicate(RLC_AM, pinfo, seq, &orig_num) == TRUE) {
+    if (pinfo->fd->flags.visited == FALSE && rlc_is_duplicate(RLC_AM, pinfo, seq, &orig_num, atm) == TRUE) {
         g_hash_table_insert(duplicate_table, GUINT_TO_POINTER(pinfo->fd->num), GUINT_TO_POINTER(orig_num));
         return;
     } else if (pinfo->fd->flags.visited == TRUE && tree) {
@@ -2333,7 +2336,7 @@ dissect_rlc_am(enum rlc_channel_type channel, tvbuff_t *tvb, packet_info *pinfo,
     }
 
     rlc_am_reassemble(tvb, offs, pinfo, tree, top_level, channel, seq, polling != 0,
-                      li, num_li, ext == 2, li_is_on_2_bytes);
+                      li, num_li, ext == 2, li_is_on_2_bytes, atm);
 }
 
 /* dissect entry functions */
@@ -2379,11 +2382,12 @@ dissect_rlc_bcch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
 }
 
 static int
-dissect_rlc_ccch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+dissect_rlc_ccch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     fp_info    *fpi;
     proto_item *ti      = NULL;
     proto_tree *subtree = NULL;
+    struct atm_phdr *atm = (struct atm_phdr *)data;
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RLC");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -2403,18 +2407,18 @@ dissect_rlc_ccch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
     } else {
         /* DL CCCH is always UM */
         proto_item_append_text(ti, " UM (CCCH)");
-        dissect_rlc_um(RLC_DL_CCCH, tvb, pinfo, tree, subtree);
+        dissect_rlc_um(RLC_DL_CCCH, tvb, pinfo, tree, subtree, atm);
     }
     return tvb_captured_length(tvb);
 }
 
 static int
-dissect_rlc_ctch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_)
+dissect_rlc_ctch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void  *data)
 {
     fp_info    *fpi;
     proto_item *ti      = NULL;
     proto_tree *subtree = NULL;
-
+    struct atm_phdr *atm = (struct atm_phdr *)data;
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RLC");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -2429,18 +2433,19 @@ dissect_rlc_ctch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * dat
 
     /* CTCH is always UM */
     proto_item_append_text(ti, " UM (CTCH)");
-    dissect_rlc_um(RLC_DL_CTCH, tvb, pinfo, tree, subtree);
+    dissect_rlc_um(RLC_DL_CTCH, tvb, pinfo, tree, subtree, atm);
     return tvb_captured_length(tvb);
 }
 
 static int
-dissect_rlc_dcch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+dissect_rlc_dcch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_item            *ti      = NULL;
     proto_tree            *subtree = NULL;
     fp_info               *fpi;
     rlc_info              *rlci;
     enum rlc_channel_type  channel;
+    struct atm_phdr       *atm = (struct atm_phdr *)data;
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RLC");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -2463,23 +2468,24 @@ dissect_rlc_dcch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
     switch (rlci->mode[fpi->cur_tb]) {
         case RLC_UM:
             proto_item_append_text(ti, " UM (DCCH)");
-            dissect_rlc_um(channel, tvb, pinfo, tree, subtree);
+            dissect_rlc_um(channel, tvb, pinfo, tree, subtree, atm);
             break;
         case RLC_AM:
             proto_item_append_text(ti, " AM (DCCH)");
-            dissect_rlc_am(channel, tvb, pinfo, tree, subtree);
+            dissect_rlc_am(channel, tvb, pinfo, tree, subtree, atm);
             break;
     }
     return tvb_captured_length(tvb);
 }
 
 static int
-dissect_rlc_ps_dtch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+dissect_rlc_ps_dtch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_item *ti      = NULL;
     proto_tree *subtree = NULL;
     fp_info    *fpi;
     rlc_info   *rlci;
+    struct atm_phdr *atm = (struct atm_phdr *)data;
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RLC");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -2500,11 +2506,11 @@ dissect_rlc_ps_dtch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* d
     switch (rlci->mode[fpi->cur_tb]) {
         case RLC_UM:
             proto_item_append_text(ti, " UM (PS DTCH)");
-            dissect_rlc_um(RLC_PS_DTCH, tvb, pinfo, tree, subtree);
+            dissect_rlc_um(RLC_PS_DTCH, tvb, pinfo, tree, subtree, atm);
             break;
         case RLC_AM:
             proto_item_append_text(ti, " AM (PS DTCH)");
-            dissect_rlc_am(RLC_PS_DTCH, tvb, pinfo, tree, subtree);
+            dissect_rlc_am(RLC_PS_DTCH, tvb, pinfo, tree, subtree, atm);
             break;
         case RLC_TM:
             proto_item_append_text(ti, " TM (PS DTCH)");
@@ -2515,12 +2521,13 @@ dissect_rlc_ps_dtch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* d
 }
 
 static int
-dissect_rlc_dch_unknown(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+dissect_rlc_dch_unknown(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_item *ti      = NULL;
     proto_tree *subtree = NULL;
     fp_info    *fpi;
     rlc_info   *rlci;
+    struct atm_phdr *atm = (struct atm_phdr *)data;
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "RLC");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -2538,11 +2545,11 @@ dissect_rlc_dch_unknown(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, voi
     switch (rlci->mode[fpi->cur_tb]) {
         case RLC_UM:
             proto_item_append_text(ti, " UM (Unknown)");
-            dissect_rlc_um(RLC_UNKNOWN_CH, tvb, pinfo, tree, subtree);
+            dissect_rlc_um(RLC_UNKNOWN_CH, tvb, pinfo, tree, subtree, atm);
             break;
         case RLC_AM:
             proto_item_append_text(ti, " AM (Unknown)");
-            dissect_rlc_am(RLC_UNKNOWN_CH, tvb, pinfo, tree, subtree);
+            dissect_rlc_am(RLC_UNKNOWN_CH, tvb, pinfo, tree, subtree, atm);
             break;
         case RLC_TM:
             proto_item_append_text(ti, " TM (Unknown)");
@@ -2555,7 +2562,7 @@ dissect_rlc_dch_unknown(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, voi
 
 /* Heuristic dissector looks for supported framing protocol (see wiki page)  */
 static gboolean
-dissect_rlc_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+dissect_rlc_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     gint        offset             = 0;
     fp_info    *fpi;
@@ -2569,6 +2576,7 @@ dissect_rlc_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data
     gboolean    rlcModePresent     = FALSE;
     proto_item *ti                 = NULL;
     proto_tree *subtree            = NULL;
+    struct atm_phdr *atm           = (struct atm_phdr *)data;
 
     /* Do this again on re-dissection to re-discover offset of actual PDU */
 
@@ -2680,10 +2688,10 @@ dissect_rlc_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data
 
             if (rlci->mode[fpi->cur_tb] == RLC_AM) {
                 proto_item_append_text(ti, " AM");
-                dissect_rlc_am(RLC_UNKNOWN_CH, rlc_tvb, pinfo, tree, subtree);
+                dissect_rlc_am(RLC_UNKNOWN_CH, rlc_tvb, pinfo, tree, subtree, atm);
             } else if (rlci->mode[fpi->cur_tb] == RLC_UM) {
                 proto_item_append_text(ti, " UM");
-                dissect_rlc_um(RLC_UNKNOWN_CH, rlc_tvb, pinfo, tree, subtree);
+                dissect_rlc_um(RLC_UNKNOWN_CH, rlc_tvb, pinfo, tree, subtree, atm);
             } else {
                 proto_item_append_text(ti, " TM");
                 dissect_rlc_tm(RLC_UNKNOWN_CH, rlc_tvb, pinfo, tree, subtree);
diff --git a/epan/dissectors/packet-rlc.h b/epan/dissectors/packet-rlc.h
index f58c1ae52a..31820495a0 100644
--- a/epan/dissectors/packet-rlc.h
+++ b/epan/dissectors/packet-rlc.h
@@ -22,6 +22,8 @@
 #ifndef PACKET_RLC_H
 #define PACKET_RLC_H
 
+#include <wiretap/wtap.h>
+
 /* Do not change enum order and append only to keep
    backward compatibility with UDP framing format */
 enum rlc_mode {
@@ -52,7 +54,7 @@ typedef struct rlc_info
 
 /* Reset the specified channel's reassembly data, useful for when a sequence
  * resets on transport channel swap. */
-void rlc_reset_channel(enum rlc_mode mode, guint8 rbid, guint8 dir, guint32 urnti);
+void rlc_reset_channel(enum rlc_mode mode, guint8 rbid, guint8 dir, guint32 urnti, struct atm_phdr *atm);
 
 /* Tells other functions if this packet is ciphered or not */
 gboolean rlc_is_ciphered(packet_info * pinfo);
diff --git a/epan/dissectors/packet-umts_fp.c b/epan/dissectors/packet-umts_fp.c
index f83a981806..ae3ff612fb 100644
--- a/epan/dissectors/packet-umts_fp.c
+++ b/epan/dissectors/packet-umts_fp.c
@@ -479,12 +479,15 @@ static const value_string common_control_frame_type_vals[] = {
 /* Dissect message parts */
 static int dissect_tb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                            int offset, struct fp_info *p_fp_info,
-                           dissector_handle_t *data_handle);
+                           dissector_handle_t *data_handle,
+                           void *data);
 
 static int dissect_macd_pdu_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                 int offset, guint16 length, guint16 number_of_pdus, struct fp_info *p_fp_info);
+                                 int offset, guint16 length, guint16 number_of_pdus, struct fp_info *p_fp_info,
+                                 void *data);
 static int dissect_macd_pdu_data_type_2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                        int offset, guint16 length, guint16 number_of_pdus, struct fp_info * fpi);
+                                        int offset, guint16 length, guint16 number_of_pdus, struct fp_info * fpi,
+                                        void *data);
 
 static int dissect_crci_bits(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                              fp_info *p_fp_info, int offset);
@@ -522,15 +525,18 @@ static int dissect_common_dynamic_pusch_assignment(packet_info *pinfo, proto_tre
 
 /* Dissect common channel types */
 static void dissect_rach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                      int offset, struct fp_info *p_fp_info);
+                                      int offset, struct fp_info *p_fp_info,
+                                      void *data);
 static void dissect_fach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                      int offset, struct fp_info *p_fp_info);
+                                      int offset, struct fp_info *p_fp_info,
+                                      void *data);
 static void dissect_dsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                       int offset, struct fp_info *p_fp_info);
 static void dissect_usch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                       int offset, struct fp_info *p_fp_info);
 static void dissect_pch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                     int offset, struct fp_info *p_fp_info);
+                                     int offset, struct fp_info *p_fp_info,
+                                     void *data);
 static void dissect_cpch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                       int offset, struct fp_info *p_fp_info);
 static void dissect_bch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
@@ -538,11 +544,15 @@ static void dissect_bch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tr
 static void dissect_iur_dsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                           int offset, struct fp_info *p_fp_info);
 static void dissect_hsdsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                        int offset, struct fp_info *p_fp_info);
+                                        int offset, struct fp_info *p_fp_info,
+                                        void *data);
 static void dissect_hsdsch_type_2_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                               int offset, struct fp_info *p_fp_info);
+                                               int offset, struct fp_info *p_fp_info,
+                                               void *data);
 static void dissect_hsdsch_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                               int offset, struct fp_info *p_fp_info);
+                                               int offset,
+                                               struct fp_info *p_fp_info,
+                                               void *data);
 
 /* Dissect DCH control messages */
 static int dissect_dch_timing_adjustment(proto_tree *tree, packet_info *pinfo,
@@ -573,17 +583,22 @@ static void dissect_dch_control_frame(proto_tree *tree, packet_info *pinfo, tvbu
 
 /* Dissect a DCH channel */
 static void dissect_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                     int offset, struct fp_info *p_fp_info);
+                                     int offset, struct fp_info *p_fp_info,
+                                     void *data);
 
 /* Dissect dedicated channels */
 static void dissect_e_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                        int offset, struct fp_info *p_fp_info,
-                                       gboolean is_common, rlc_info  *rlcinf);
+                                       gboolean is_common, rlc_info  *rlcinf,
+                                       void *data);
 
 static void dissect_e_dch_t2_or_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                                     int offset, struct fp_info *p_fp_info,
                                                     int number_of_subframes,
-                                                    gboolean is_common, guint16 header_crc, proto_item * header_crc_pi);
+                                                    gboolean is_common,
+                                                    guint16 header_crc,
+                                                    proto_item * header_crc_pi,
+                                                    void *data);
 
 /* Main dissection function */
 static int dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data);
@@ -676,7 +691,7 @@ static gboolean verify_header_crc_edch(tvbuff_t * tvb, packet_info * pinfo, prot
 static int
 dissect_tb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                 int offset, struct fp_info *p_fp_info,
-                dissector_handle_t *data_handle)
+                dissector_handle_t *data_handle, void *data)
 {
     int         chan, num_tbs   = 0;
     int         bit_offset      = 0;
@@ -764,7 +779,7 @@ dissect_tb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
                     /****************/
                     /* TODO: maybe this decision can be based only on info available in fp_info */
-                    call_dissector(*data_handle, next_tvb, pinfo, top_level_tree);
+                    call_dissector_with_data(*data_handle, next_tvb, pinfo, top_level_tree, data);
                     dissected = TRUE;
                 } else {
                     proto_tree_add_expert(tree, pinfo, &ei_fp_crci_no_subdissector, tvb, offset + bit_offset/8,
@@ -807,7 +822,8 @@ dissect_tb_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
    Length is in bits, and payload is offset by 4 bits of padding */
 static int
 dissect_macd_pdu_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                      int offset, guint16 length, guint16 number_of_pdus, struct fp_info *p_fp_info)
+                      int offset, guint16 length, guint16 number_of_pdus,
+                      struct fp_info *p_fp_info, void *data)
 {
     int         pdu;
     int         bit_offset = 0;
@@ -847,7 +863,7 @@ dissect_macd_pdu_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
             tvbuff_t *next_tvb;
             next_tvb = tvb_new_subset(tvb, offset + bit_offset/8,
                                       ((bit_offset % 8) + length + 7)/8, -1);
-            call_dissector(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree);
+            call_dissector_with_data(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree, data);
             dissected = TRUE;
         }
 
@@ -880,7 +896,8 @@ dissect_macd_pdu_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
    Length is in bytes, and payload is byte-aligned (no padding) */
 static int
 dissect_macd_pdu_data_type_2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                             int offset, guint16 length, guint16 number_of_pdus, struct fp_info *fpi)
+                             int offset, guint16 length, guint16 number_of_pdus,
+                             struct fp_info *fpi, void *data)
 {
     int         pdu;
     proto_item *pdus_ti      = NULL;
@@ -913,7 +930,7 @@ dissect_macd_pdu_data_type_2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree
 
 
             fpi->cur_tb = pdu;    /*Set proper pdu index for MAC and higher layers*/
-            call_dissector(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree);
+            call_dissector_with_data(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree, data);
             dissected = TRUE;
         }
 
@@ -1445,7 +1462,7 @@ dissect_common_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 /* Dissect a RACH channel */
 static void
 dissect_rach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                          int offset, struct fp_info *p_fp_info)
+                          int offset, struct fp_info *p_fp_info, void *data)
 {
     gboolean is_control_frame;
     guint16 header_crc = 0;
@@ -1520,7 +1537,7 @@ dissect_rach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         header_length = offset;
 
         /* TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_rach_handle);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_rach_handle, data);
 
         /* CRCIs */
         offset = dissect_crci_bits(tvb, pinfo, tree, p_fp_info, offset);
@@ -1700,7 +1717,7 @@ dissect_rach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 /* Dissect a FACH channel */
 static void
 dissect_fach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                          int offset, struct fp_info *p_fp_info)
+                          int offset, struct fp_info *p_fp_info, void *data)
 {
     gboolean is_control_frame;
     guint16 header_crc = 0;
@@ -1748,7 +1765,7 @@ dissect_fach_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         header_length = offset;
 
         /* TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_fach_handle);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_fach_handle, data);
 
         /* New IE flags (if it looks as though they are present) */
         if ((p_fp_info->release == 7) &&
@@ -1848,7 +1865,7 @@ dissect_dsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         }
         header_length = offset;
         /* TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, NULL);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, NULL, NULL);
 
         /* Spare Extension and Payload CRC */
         dissect_spare_extension_and_crc(tvb, pinfo, tree, 1, offset, header_length);
@@ -1903,7 +1920,7 @@ dissect_usch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         offset++;
         header_length = offset;
         /* TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, NULL);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, NULL, NULL);
 
         /* QE */
         proto_tree_add_item(tree, hf_fp_quality_estimate, tvb, offset, 1, ENC_BIG_ENDIAN);
@@ -1940,7 +1957,7 @@ dissect_usch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 /* Dissect a PCH channel  */
 static void
 dissect_pch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                         int offset, struct fp_info *p_fp_info)
+                         int offset, struct fp_info *p_fp_info, void *data)
 {
     gboolean is_control_frame;
     guint16  pch_cfn;
@@ -1999,7 +2016,7 @@ dissect_pch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         }
 
         /* TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_pch_handle);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_pch_handle, data);
 
         if (preferences_header_checksum) {
             verify_header_crc(tvb, pinfo, header_crc_pi, header_crc, header_length);
@@ -2053,7 +2070,7 @@ dissect_cpch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         offset++;
         header_length = offset; /* XXX this might be wrong */
         /* TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, NULL);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, NULL, NULL);
 
         /* CRCIs */
         offset = dissect_crci_bits(tvb, pinfo, tree, p_fp_info, offset);
@@ -2456,7 +2473,7 @@ dissect_dch_control_frame(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb,
 /* Dissect a DCH channel       */
 static void
 dissect_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                         int offset, struct fp_info *p_fp_info)
+                         int offset, struct fp_info *p_fp_info, void *data)
 {
     gboolean is_control_frame;
     guint8   cfn;
@@ -2504,7 +2521,7 @@ dissect_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         }
         header_length = offset;
         /* Dissect TB data */
-        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_dch_handle);
+        offset = dissect_tb_data(tvb, pinfo, tree, offset, p_fp_info, &mac_fdd_dch_handle, data);
 
         /* QE (uplink only) */
         if (p_fp_info->is_uplink) {
@@ -2530,7 +2547,8 @@ dissect_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 static void
 dissect_e_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                            int offset, struct fp_info *p_fp_info,
-                           gboolean is_common, rlc_info  *rlcinf)
+                           gboolean is_common, rlc_info  *rlcinf,
+                           void *data)
 {
     gboolean is_control_frame;
     guint8   number_of_subframes;
@@ -2622,7 +2640,9 @@ dissect_e_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
         /* Remainder of T2 or common data frames differ here... */
         if (p_fp_info->edch_type == 1) {
             dissect_e_dch_t2_or_common_channel_info(tvb, pinfo, tree, offset, p_fp_info,
-                                                    number_of_subframes, is_common, header_crc, header_crc_pi);
+                                                    number_of_subframes,
+                                                    is_common, header_crc,
+                                                    header_crc_pi, data);
             return;
         }
 
@@ -2821,7 +2841,7 @@ dissect_e_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                         p_fp_info->cur_tb = macd_idx;    /*Set the transport block index (NOTE: This and not subnum is used in MAC dissector!)*/
 
                         /* TODO: use maces_tree? */
-                        call_dissector(mac_fdd_edch_handle, next_tvb, pinfo, top_level_tree);
+                        call_dissector_with_data(mac_fdd_edch_handle, next_tvb, pinfo, top_level_tree, data);
                         dissected = TRUE;
                     }
                     else {
@@ -2879,7 +2899,11 @@ dissect_e_dch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 static void
 dissect_e_dch_t2_or_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                         int offset, struct fp_info *p_fp_info,
-                                        int number_of_subframes, gboolean is_common, guint16 header_crc, proto_item * header_crc_pi)
+                                        int number_of_subframes,
+                                        gboolean is_common,
+                                        guint16 header_crc,
+                                        proto_item * header_crc_pi,
+                                        void *data)
 {
     int      n;
     int      pdu_no;
@@ -3047,7 +3071,7 @@ dissect_e_dch_t2_or_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto
             /* Call MAC for this PDU if configured to */
             if (preferences_call_mac_dissectors) {
                 p_add_proto_data(wmem_file_scope(), pinfo, proto_umts_mac, 0, mac_is_info);
-                call_dissector(mac_fdd_edch_type2_handle, tvb_new_subset_remaining(tvb, offset), pinfo, top_level_tree);
+                call_dissector_with_data(mac_fdd_edch_type2_handle, tvb_new_subset_remaining(tvb, offset), pinfo, top_level_tree, data);
             }
             else {
                 /* Still show data if not decoding as MAC PDU */
@@ -3078,7 +3102,7 @@ dissect_e_dch_t2_or_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto
 /* described in R5 and R6, and frame type 1 in Release 7. */
 static void
 dissect_hsdsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                            int offset, struct fp_info *p_fp_info)
+                            int offset, struct fp_info *p_fp_info, void *data)
 {
     gboolean is_control_frame;
     guint header_length = 0;
@@ -3204,7 +3228,7 @@ dissect_hsdsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
         /* MAC-d PDUs */
         offset = dissect_macd_pdu_data(tvb, pinfo, tree, offset, pdu_length,
-                                       number_of_pdus, p_fp_info);
+                                       number_of_pdus, p_fp_info, data);
 
         col_append_fstr(pinfo->cinfo, COL_INFO, "  %ux%u-bit PDUs  User-Buffer-Size=%u",
                         number_of_pdus, pdu_length, user_buffer_size);
@@ -3272,7 +3296,8 @@ dissect_hsdsch_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 /* frame type 3 (IuR only?)               */
 static void
 dissect_hsdsch_type_2_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                   int offset, struct fp_info *p_fp_info)
+                                   int offset, struct fp_info *p_fp_info,
+                                   void *data)
 {
     gboolean is_control_frame;
     guint16 header_crc = 0;
@@ -3488,7 +3513,8 @@ dissect_hsdsch_type_2_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree
             /* Add PDU block header subtree */
             offset = dissect_macd_pdu_data_type_2(tvb, pinfo, tree, offset,
                                                   (guint16)pdu_length[n],
-                                                  (guint16)no_of_pdus[n], p_fp_info);
+                                                  (guint16)no_of_pdus[n],
+                                                  p_fp_info, data);
         }
         if (preferences_header_checksum) {
             verify_header_crc(tvb, pinfo, header_crc_pi, header_crc, header_length);
@@ -3512,7 +3538,9 @@ dissect_hsdsch_type_2_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree
 */
 static
 void dissect_hsdsch_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-                                               int offset, struct fp_info *p_fp_info) {
+                                        int offset, struct fp_info *p_fp_info,
+                                        void *data)
+{
     gboolean is_control_frame;
     guint16 header_crc = 0;
     proto_item * header_crc_pi = NULL;
@@ -3702,7 +3730,7 @@ void dissect_hsdsch_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto
                      * BCCH with transparent MAC layer. Therefore skip right to
                      * rlc_bcch and hope for the best. */
                     next_tvb = tvb_new_subset_length(tvb, offset, (gint)pdu_length[n]);
-                    call_dissector(rlc_bcch_handle, next_tvb, pinfo, top_level_tree);
+                    call_dissector_with_data(rlc_bcch_handle, next_tvb, pinfo, top_level_tree, data);
                     offset += (gint)pdu_length[n];
                 } else { /* Else go for CCCH UM, this seems to work. */
                     p_fp_info->hsdsch_entity = ehs; /* HSDSCH type 2 */
@@ -3714,10 +3742,6 @@ void dissect_hsdsch_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto
                     macinf->macdflow_id[j] = p_fp_info->hsdsch_macflowd_id;
                     macinf->ctmux[j] = FALSE;
 
-
-
-
-
                     rlcinf->li_size[j] = RLC_LI_7BITS;
                     rlcinf->ciphered[j] = FALSE;
                     rlcinf->deciphered[j] = FALSE;
@@ -3725,10 +3749,7 @@ void dissect_hsdsch_common_channel_info(tvbuff_t *tvb, packet_info *pinfo, proto
                     rlcinf->urnti[j] = p_fp_info->channel; /*We need to fake urnti*/
 
                     next_tvb = tvb_new_subset_length(tvb, offset, (gint)pdu_length[n]);
-                    call_dissector(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree);
-
-
-
+                    call_dissector_with_data(mac_fdd_hsdsch_handle, next_tvb, pinfo, top_level_tree, data);
 
                     offset += (gint)pdu_length[n];
                 }
@@ -4182,7 +4203,7 @@ fp_set_per_packet_inf_from_conv(umts_fp_conversation_info_t *p_conv_data,
 /*****************************/
 /* Main dissection function. */
 static int
-dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+dissect_fp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_tree       *fp_tree;
     proto_item       *ti;
@@ -4358,14 +4379,17 @@ dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
         case CHANNEL_RACH_TDD:
         case CHANNEL_RACH_TDD_128:
         case CHANNEL_RACH_FDD:
-            dissect_rach_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+            dissect_rach_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info,
+                                      data);
             break;
         case CHANNEL_DCH:
-            dissect_dch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+            dissect_dch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info,
+                                     data);
             break;
         case CHANNEL_FACH_FDD:
         case CHANNEL_FACH_TDD:
-            dissect_fach_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+            dissect_fach_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info,
+                                      data);
             break;
         case CHANNEL_DSCH_FDD:
         case CHANNEL_DSCH_TDD:
@@ -4376,7 +4400,8 @@ dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
             dissect_usch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
             break;
         case CHANNEL_PCH:
-            dissect_pch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+            dissect_pch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info,
+                                     data);
             break;
         case CHANNEL_CPCH:
             dissect_cpch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
@@ -4398,21 +4423,21 @@ dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
                 case entity_not_specified:
                 case hs:
                     /* This is the pre-R7 default */
-                    dissect_hsdsch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+                    dissect_hsdsch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info, data);
                     break;
                 case ehs:
-                    dissect_hsdsch_type_2_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+                    dissect_hsdsch_type_2_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info, data);
                     break;
                 default:
                     /* Report Error */
-                     expert_add_info(pinfo, NULL, &ei_fp_hsdsch_entity_not_specified);
+                    expert_add_info(pinfo, NULL, &ei_fp_hsdsch_entity_not_specified);
                     break;
             }
             break;
         case CHANNEL_HSDSCH_COMMON:
             expert_add_info(pinfo, NULL, &ei_fp_hsdsch_common_experimental_support);
             /*if (FALSE)*/
-            dissect_hsdsch_common_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info);
+            dissect_hsdsch_common_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info, data);
 
             break;
         case CHANNEL_HSDSCH_COMMON_T3:
@@ -4432,7 +4457,8 @@ dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
         case CHANNEL_EDCH:
         case CHANNEL_EDCH_COMMON:
             dissect_e_dch_channel_info(tvb, pinfo, fp_tree, offset, p_fp_info,
-                                       p_fp_info->channel == CHANNEL_EDCH_COMMON, rlcinf);
+                                       p_fp_info->channel == CHANNEL_EDCH_COMMON,
+                                       rlcinf, data);
             break;
 
         default:
@@ -4442,6 +4468,18 @@ dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
     return tvb_captured_length(tvb);
 }
 
+static int
+dissect_fp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+    return dissect_fp_common(tvb, pinfo, tree, NULL);
+}
+
+static int
+dissect_fp_aal2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
+{
+    return dissect_fp_common(tvb, pinfo, tree, data);
+}
+
 #ifdef UMTS_FP_USE_UAT
 UAT_VS_DEF(uat_umts_fp_ep_and_ch_records, protocol, uat_umts_fp_ep_and_ch_record_t, guint8, UMTS_FP_IPV4, "IPv4")
 UAT_CSTRING_CB_DEF(uat_umts_fp_ep_and_ch_records, srcIP, uat_umts_fp_ep_and_ch_record_t)
@@ -5636,6 +5674,8 @@ void proto_register_fp(void)
 
 void proto_reg_handoff_fp(void)
 {
+    dissector_handle_t fp_aal2_handle;
+
     rlc_bcch_handle           = find_dissector("rlc.bcch");
     mac_fdd_rach_handle       = find_dissector("mac.fdd.rach");
     mac_fdd_fach_handle       = find_dissector("mac.fdd.fach");
@@ -5646,7 +5686,9 @@ void proto_reg_handoff_fp(void)
     mac_fdd_hsdsch_handle     = find_dissector("mac.fdd.hsdsch");
 
     heur_dissector_add("udp", heur_dissect_fp, "FP over UDP", "fp_udp", proto_fp, HEURISTIC_DISABLE);
-    dissector_add_uint("atm.aal2.type", TRAF_UMTS_FP, fp_handle);
+
+    fp_aal2_handle = create_dissector_handle(dissect_fp_aal2, proto_fp);
+    dissector_add_uint("atm.aal2.type", TRAF_UMTS_FP, fp_aal2_handle);
 }
 
 /*
diff --git a/epan/dissectors/packet-umts_mac.c b/epan/dissectors/packet-umts_mac.c
index 51e4067f9b..8f21d3070b 100644
--- a/epan/dissectors/packet-umts_mac.c
+++ b/epan/dissectors/packet-umts_mac.c
@@ -259,7 +259,7 @@ static guint16 tree_add_common_dcch_dtch_fields(tvbuff_t *tvb, packet_info *pinf
     return bitoffs;
 }
 
-static int dissect_mac_fdd_pch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_pch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_tree *pch_tree = NULL;
     proto_item *channel_type;
@@ -275,11 +275,11 @@ static int dissect_mac_fdd_pch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tr
         channel_type = proto_tree_add_uint(pch_tree, hf_mac_channel, tvb, 0, 0, MAC_PCCH);
         PROTO_ITEM_SET_GENERATED(channel_type);
     }
-    call_dissector(rlc_pcch_handle, tvb, pinfo, tree);
+    call_dissector_with_data(rlc_pcch_handle, tvb, pinfo, tree, data);
     return tvb_captured_length(tvb);
 }
 
-static int dissect_mac_fdd_rach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_rach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     guint8         tctf;
     guint8         chan;
@@ -327,7 +327,7 @@ static int dissect_mac_fdd_rach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
             PROTO_ITEM_SET_GENERATED(channel_type);
             next_tvb = tvb_new_octet_aligned(tvb, bitoffs, fpinf->chan_tf_size[chan] - bitoffs);
             add_new_data_source(pinfo, next_tvb, "Octet-Aligned CCCH Data");
-            call_dissector(rlc_ccch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ccch_handle, next_tvb, pinfo, tree, data);
             break;
         case TCTF_DCCH_DTCH_RACH_FDD:
             /*Set RLC Mode/MAC content based on the L-CHID derived from the C/T flag*/
@@ -342,7 +342,7 @@ static int dissect_mac_fdd_rach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
                     PROTO_ITEM_SET_GENERATED(channel_type);
                     next_tvb = tvb_new_octet_aligned(tvb, bitoffs, fpinf->chan_tf_size[chan] - bitoffs);
                     add_new_data_source(pinfo, next_tvb, "Octet-Aligned DCCH Data");
-                    call_dissector(rlc_dcch_handle, next_tvb, pinfo, tree);
+                    call_dissector_with_data(rlc_dcch_handle, next_tvb, pinfo, tree, data);
                     break;
                 case MAC_CONTENT_PS_DTCH:
                     proto_item_append_text(ti, " (PS DTCH)");
@@ -350,7 +350,7 @@ static int dissect_mac_fdd_rach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
                     PROTO_ITEM_SET_GENERATED(channel_type);
                     next_tvb = tvb_new_octet_aligned(tvb, bitoffs, fpinf->chan_tf_size[chan] - bitoffs);
                     add_new_data_source(pinfo, next_tvb, "Octet-Aligned DTCH Data");
-                    call_dissector(rlc_ps_dtch_handle, next_tvb, pinfo, tree);
+                    call_dissector_with_data(rlc_ps_dtch_handle, next_tvb, pinfo, tree, data);
                     break;
                 case MAC_CONTENT_CS_DTCH:
                     proto_item_append_text(ti, " (CS DTCH)");
@@ -368,7 +368,7 @@ static int dissect_mac_fdd_rach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
     return tvb_captured_length(tvb);
 }
 
-static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     guint8         hdr, tctf;
     guint16        bitoffs   = 0;
@@ -419,7 +419,7 @@ static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
             PROTO_ITEM_SET_GENERATED(channel_type);
             /* CCCH over FACH is always octet aligned */
             next_tvb = tvb_new_subset_remaining(tvb, 1);
-            call_dissector(rlc_ccch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ccch_handle, next_tvb, pinfo, tree, data);
             break;
         case TCTF_DCCH_DTCH_FACH_FDD:
 
@@ -435,7 +435,7 @@ static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
                     PROTO_ITEM_SET_GENERATED(channel_type);
                     next_tvb = tvb_new_octet_aligned(tvb, bitoffs, fpinf->chan_tf_size[chan] - bitoffs);
                     add_new_data_source(pinfo, next_tvb, "Octet-Aligned DCCH Data");
-                    call_dissector(rlc_dcch_handle, next_tvb, pinfo, tree);
+                    call_dissector_with_data(rlc_dcch_handle, next_tvb, pinfo, tree, data);
                     break;
                 case MAC_CONTENT_PS_DTCH:
                     proto_item_append_text(ti, " (PS DTCH)");
@@ -443,7 +443,7 @@ static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
                     PROTO_ITEM_SET_GENERATED(channel_type);
                     next_tvb = tvb_new_octet_aligned(tvb, bitoffs, fpinf->chan_tf_size[chan] - bitoffs);
                     add_new_data_source(pinfo, next_tvb, "Octet-Aligned DCCH Data");
-                    call_dissector(rlc_ps_dtch_handle, next_tvb, pinfo, tree);
+                    call_dissector_with_data(rlc_ps_dtch_handle, next_tvb, pinfo, tree, data);
                     break;
                 case MAC_CONTENT_CS_DTCH:
                     proto_item_append_text(ti, " (CS DTCH)");
@@ -461,7 +461,7 @@ static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
             PROTO_ITEM_SET_GENERATED(channel_type);
             /* CTCH over FACH is always octet aligned */
             next_tvb = tvb_new_subset_remaining(tvb, 1);
-            call_dissector(rlc_ctch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ctch_handle, next_tvb, pinfo, tree, data);
             break;
         /* july 5: Added support for BCCH*/
         case TCTF_BCCH_FACH_FDD:
@@ -481,7 +481,7 @@ static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
             }
             rrcinf->msgtype[fpinf->cur_tb] = RRC_MESSAGE_TYPE_BCCH_FACH;
 
-            call_dissector(rrc_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rrc_handle, next_tvb, pinfo, tree, data);
 
             break;
         case TCTF_MSCH_FACH_FDD:
@@ -497,7 +497,7 @@ static int dissect_mac_fdd_fach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
     return tvb_captured_length(tvb);
 }
 
-static int dissect_mac_fdd_dch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_dch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     guint16        pos;
     guint8         bitoffs  = 0;
@@ -560,7 +560,7 @@ static int dissect_mac_fdd_dch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tr
             /*Transport channel printout*/
             channel_type = proto_tree_add_uint(dch_tree, hf_mac_trch_id, tvb, 0, 0, macinf->trchid[pos]);
             PROTO_ITEM_SET_GENERATED(channel_type);
-            call_dissector(rlc_dcch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_dcch_handle, next_tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_PS_DTCH:
             proto_item_append_text(ti, " (PS DTCH)");
@@ -574,7 +574,7 @@ static int dissect_mac_fdd_dch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tr
 
             channel_type = proto_tree_add_uint(dch_tree, hf_mac_channel, tvb, 0, 0, MAC_DTCH);
             PROTO_ITEM_SET_GENERATED(channel_type);
-            call_dissector(rlc_ps_dtch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ps_dtch_handle, next_tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_CS_DTCH:
             proto_item_append_text(ti, " (CS DTCH)");
@@ -921,16 +921,16 @@ static void ss_interpretation(tvbuff_t * tvb, proto_tree * tree, guint8 ss, guin
     }
 }
 
-static void call_rlc(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, proto_item * ti, guint8 lchid)
+static void call_rlc(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, proto_item * ti, guint8 lchid, void *data)
 {
     switch (lchId_type_table[lchid]) {
         case MAC_CONTENT_DCCH:
             proto_item_append_text(ti, " (DCCH)");
-            call_dissector(rlc_dcch_handle, tvb, pinfo, tree);
+            call_dissector_with_data(rlc_dcch_handle, tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_PS_DTCH:
             proto_item_append_text(ti, " (PS DTCH)");
-            call_dissector(rlc_ps_dtch_handle, tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ps_dtch_handle, tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_CS_DTCH:
             proto_item_append_text(ti, " (CS DTCH)");
@@ -946,7 +946,7 @@ static void call_rlc(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree, pro
 /*
  * Dissect a MAC-is PDU.
  */
-static int dissect_mac_fdd_edch_type2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_edch_type2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     guint sdu_no, subframe_bytes = 0, offset = 0;
     guint8 ss;
@@ -996,7 +996,7 @@ static int dissect_mac_fdd_edch_type2(tvbuff_t *tvb, packet_info *pinfo, proto_t
 
         asm_tvb = mac_is_add_fragment(tvb, pinfo, macis_sdu_tree, lchid, p_fp_info->com_context_id, offset, ss, tsn, sdu_no, mac_is_info->number_of_mac_is_sdus, sdulength);
         if (asm_tvb != NULL) {
-            call_rlc(asm_tvb, pinfo, tree, ti, lchid);
+            call_rlc(asm_tvb, pinfo, tree, ti, lchid, data);
         }
 
         offset += sdulength;
@@ -1011,7 +1011,7 @@ static int dissect_mac_fdd_edch_type2(tvbuff_t *tvb, packet_info *pinfo, proto_t
     return tvb_captured_length(tvb);
 }
 
-static int dissect_mac_fdd_edch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_edch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_tree    *edch_tree = NULL;
     proto_item    *channel_type;
@@ -1047,7 +1047,7 @@ static int dissect_mac_fdd_edch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
             PROTO_ITEM_SET_GENERATED(channel_type);
 
 
-            call_dissector(rlc_dcch_handle, tvb, pinfo, tree);
+            call_dissector_with_data(rlc_dcch_handle, tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_PS_DTCH:
             proto_item_append_text(ti, " (PS DTCH)");
@@ -1059,7 +1059,7 @@ static int dissect_mac_fdd_edch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *t
             channel_type = proto_tree_add_uint(edch_tree, hf_mac_channel, tvb, 0, 0, MAC_DTCH);
             PROTO_ITEM_SET_GENERATED(channel_type);
 
-            call_dissector(rlc_ps_dtch_handle, tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ps_dtch_handle, tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_CS_DTCH:
             proto_item_append_text(ti, " (CS DTCH)");
@@ -1141,7 +1141,7 @@ static void dissect_mac_fdd_hsdsch_common(tvbuff_t *tvb, packet_info *pinfo, pro
  * no re-alignment is necessary
  * If no C/T is present, the whole payload will be left-shifted by 4 bit
  */
-static int dissect_mac_fdd_hsdsch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static int dissect_mac_fdd_hsdsch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 {
     proto_tree    *hsdsch_tree = NULL;
     proto_item    *channel_type;
@@ -1211,7 +1211,7 @@ static int dissect_mac_fdd_hsdsch(tvbuff_t *tvb, packet_info *pinfo, proto_tree
             /*Set the MACd-Flow ID*/
             channel_type = proto_tree_add_uint(hsdsch_tree, hf_mac_macdflowd_id, tvb, 0, 0, macinf->macdflow_id[pos]);
             PROTO_ITEM_SET_GENERATED(channel_type);
-            call_dissector(rlc_ccch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ccch_handle, next_tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_DCCH:
             proto_item_append_text(ti, " (DCCH)");
@@ -1236,7 +1236,7 @@ static int dissect_mac_fdd_hsdsch(tvbuff_t *tvb, packet_info *pinfo, proto_tree
             /*Set the MACd-Flow ID*/
             channel_type = proto_tree_add_uint(hsdsch_tree, hf_mac_macdflowd_id, tvb, 0, 0, macinf->macdflow_id[pos]);
             PROTO_ITEM_SET_GENERATED(channel_type);
-            call_dissector(rlc_dcch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_dcch_handle, next_tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_PS_DTCH:
             proto_item_append_text(ti, " (PS DTCH)");
@@ -1261,7 +1261,7 @@ static int dissect_mac_fdd_hsdsch(tvbuff_t *tvb, packet_info *pinfo, proto_tree
             channel_type = proto_tree_add_uint(hsdsch_tree, hf_mac_macdflowd_id, tvb, 0, 0, macinf->macdflow_id[pos]);
             PROTO_ITEM_SET_GENERATED(channel_type);
 
-            call_dissector(rlc_ps_dtch_handle, next_tvb, pinfo, tree);
+            call_dissector_with_data(rlc_ps_dtch_handle, next_tvb, pinfo, tree, data);
             break;
         case MAC_CONTENT_CS_DTCH:
             proto_item_append_text(ti, " (CS DTCH)");