- updated to support draft-ietf-sigtran-m2pa-05.txt

- restructured the code.
- fixed some cosmetic bugs.

svn path=/trunk/; revision=6101

1 files changed, 127 insertions, 215 deletions

diff --git a/packet-m2pa.c b/packet-m2pa.c
index ba1feddaec..6b460e6b66 100644
--- a/packet-m2pa.c
+++ b/packet-m2pa.c
@@ -1,12 +1,12 @@
 /* packet-m2pa.c
  * Routines for MTP2 Peer Adaptation Layer dissection
  * It is hopefully (needs testing) compliant to
- * http://www.ietf.org/internet-drafts/draft-ietf-sigtran-m2pa-04.txt
+ * http://www.ietf.org/internet-drafts/draft-ietf-sigtran-m2pa-05.txt
  *
  * Copyright 2001, 2002, Jeff Morriss <jeff.morriss[AT]ulticom.com>, 
- * updated by Michael Tuexen <michael.tuexen[AT]icn.siemens.de>
+ * updated by Michael Tuexen <michael.tuexen[AT]siemens.com>
  *
- * $Id: packet-m2pa.c,v 1.10 2002/06/20 20:58:07 guy Exp $
+ * $Id: packet-m2pa.c,v 1.11 2002/08/27 19:28:23 tuexen Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -36,64 +36,120 @@
 
 #include <epan/packet.h>
 
-#define SCTP_PORT_M2PA             3565
-#define M2PA_PAYLOAD_PROTOCOL_ID   5
+#define NETWORK_BYTE_ORDER          FALSE
+#define SCTP_PORT_M2PA              3565
+#define M2PA_PAYLOAD_PROTOCOL_ID    5
+
+static int proto_m2pa      = -1;
+static int hf_version      = -1;
+static int hf_spare        = -1;
+static int hf_type         = -1;
+static int hf_class        = -1;
+static int hf_length       = -1;
+static int hf_unused       = -1;
+static int hf_bsn          = -1;
+static int hf_fsn          = -1;
+static int hf_status       = -1;
+static int hf_li_spare     = -1;
+static int hf_li_prio      = -1;
+static int hf_filler       = -1;
+static int hf_unknown_data = -1;
+
+static gint ett_m2pa       = -1;
+static gint ett_m2pa_li    = -1;
+
+static int mtp3_proto_id;
+static dissector_handle_t mtp3_handle;
 
 #define VERSION_LENGTH         1
 #define SPARE_LENGTH           1
 #define CLASS_LENGTH           1
 #define TYPE_LENGTH            1
 #define LENGTH_LENGTH          4
-#define BSN_LENGTH             2
-#define FSN_LENGTH             2
+#define UNUSED_LENGTH          1
+#define BSN_LENGTH             3
+#define FSN_LENGTH             3
 
 #define HEADER_LENGTH          (VERSION_LENGTH + SPARE_LENGTH + \
                                 CLASS_LENGTH + TYPE_LENGTH + LENGTH_LENGTH + \
-                                BSN_LENGTH + FSN_LENGTH)
+                                UNUSED_LENGTH + BSN_LENGTH + UNUSED_LENGTH + FSN_LENGTH)
 
-#define VERSION_OFFSET         0
+#define HEADER_OFFSET          0
+#define VERSION_OFFSET         HEADER_OFFSET
 #define SPARE_OFFSET           (VERSION_OFFSET + VERSION_LENGTH)
 #define CLASS_OFFSET           (SPARE_OFFSET + SPARE_LENGTH)
 #define TYPE_OFFSET            (CLASS_OFFSET + CLASS_LENGTH)
 #define LENGTH_OFFSET          (TYPE_OFFSET + TYPE_LENGTH)
-#define BSN_OFFSET             (LENGTH_OFFSET + LENGTH_LENGTH)
-#define FSN_OFFSET             (BSN_OFFSET + BSN_LENGTH)
-#define HEADER_OFFSET          VERSION_OFFSET
-#define MESSAGE_DATA_OFFSET    (HEADER_OFFSET + HEADER_LENGTH)
+#define FIRST_UNUSED_OFFSET    (LENGTH_OFFSET + LENGTH_LENGTH)
+#define BSN_OFFSET             (FIRST_UNUSED_OFFSET + UNUSED_LENGTH)
+#define SECOND_UNUSED_OFFSET   (BSN_OFFSET + BSN_LENGTH)
+#define FSN_OFFSET             (SECOND_UNUSED_OFFSET + UNUSED_LENGTH)
 
 #define PROTOCOL_VERSION_RELEASE_1        1
-static const value_string m2pa_protocol_version_values[] = {
+
+static const value_string protocol_version_values[] = {
   { PROTOCOL_VERSION_RELEASE_1,  "Release 1" },
   { 0,                           NULL } };
 
-
 #define MESSAGE_CLASS_M2PA                0xb
 
-static const value_string m2pa_message_class_values[] = {
+static const value_string message_class_values[] = {
   { MESSAGE_CLASS_M2PA,          "M2PA" },
   { 0,                           NULL } };
 
-
 #define MESSAGE_TYPE_USER_DATA            0x1
 #define MESSAGE_TYPE_LINK_STATUS          0x2
 
-static const value_string m2pa_message_type_values[] = {
+static const value_string message_type_values[] = {
   { MESSAGE_TYPE_USER_DATA,     "User Data" },
   { MESSAGE_TYPE_LINK_STATUS,   "Link Status" },
   { 0,                           NULL } };
 
+static void
+dissect_m2pa_header(tvbuff_t *header_tvb, proto_tree *m2pa_tree)
+{
+  if (m2pa_tree) {
+    proto_tree_add_item(m2pa_tree, hf_version, header_tvb, VERSION_OFFSET,       VERSION_LENGTH, NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_spare,   header_tvb, SPARE_OFFSET,         SPARE_LENGTH,   NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_class,   header_tvb, CLASS_OFFSET,         CLASS_LENGTH,   NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_type,    header_tvb, TYPE_OFFSET,          TYPE_LENGTH,    NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_length,  header_tvb, LENGTH_OFFSET,        LENGTH_LENGTH,  NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_unused,  header_tvb, FIRST_UNUSED_OFFSET,  UNUSED_LENGTH,  NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_bsn,     header_tvb, BSN_OFFSET,           BSN_LENGTH,     NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_unused,  header_tvb, SECOND_UNUSED_OFFSET, UNUSED_LENGTH,  NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_tree, hf_fsn,     header_tvb, FSN_OFFSET,           FSN_LENGTH,     NETWORK_BYTE_ORDER);
+  }
+}
 
-/* parts of User Data message */
 #define LI_OFFSET             0
 #define LI_LENGTH             1
 #define MTP3_OFFSET           (LI_OFFSET + LI_LENGTH)
+#define LI_SPARE_MASK         0x3f
+#define LI_PRIORITY_MASK      0xc0
 
-/* LI is only used for (ITU national) priority in M2PA */
-#define LI_SPARE_MASK              0x3f
-#define LI_PRIORITY_MASK           0xc0
+static void
+dissect_m2pa_user_data_message(tvbuff_t *message_data_tvb, packet_info *pinfo, proto_item *m2pa_item, proto_tree *m2pa_tree, proto_tree *tree)
+{
+  proto_item *m2pa_li_item;
+  proto_tree *m2pa_li_tree;
+  tvbuff_t *payload_tvb;
 
+  if (m2pa_tree) {
+    m2pa_li_item = proto_tree_add_text(m2pa_tree, message_data_tvb, LI_OFFSET, LI_LENGTH, "Length Indicator");
+    m2pa_li_tree = proto_item_add_subtree(m2pa_li_item, ett_m2pa_li);
+    proto_tree_add_item(m2pa_li_tree, hf_li_prio,  message_data_tvb, LI_OFFSET, LI_LENGTH, NETWORK_BYTE_ORDER);
+    proto_tree_add_item(m2pa_li_tree, hf_li_spare, message_data_tvb, LI_OFFSET, LI_LENGTH, NETWORK_BYTE_ORDER);
+    /* Re-adjust length of M2PA item since it will be dissected as MTP3 */
+    proto_item_set_len(m2pa_item, HEADER_LENGTH + LI_LENGTH);
+  }
+
+  payload_tvb = tvb_new_subset(message_data_tvb, MTP3_OFFSET, -1, -1);
+  call_dissector(mtp3_handle, payload_tvb, pinfo, tree);
+  if (!(proto_is_protocol_enabled (mtp3_proto_id)))
+    if (check_col(pinfo->cinfo, COL_INFO))
+      col_append_str(pinfo->cinfo, COL_INFO, "User Data ");
+}
 
-/* parts of Link Status message */
 #define STATUS_LENGTH    4
 #define STATUS_OFFSET    0
 #define FILLER_OFFSET    (STATUS_OFFSET + STATUS_LENGTH)
@@ -109,126 +165,45 @@ static const value_string m2pa_message_type_values[] = {
 #define STATUS_OUT_OF_SERVICE         9
 #define STATUS_IN_SERVICE            10
 
-static const value_string m2pa_link_status_values[] = {
-  { STATUS_ALIGNMENT,                   "Alignment" },
-  { STATUS_PROVING_NORMAL,              "Proving Normal" },
-  { STATUS_PROVING_EMERGENCY,           "Proving Emergency" },
-  { STATUS_READY,                       "Ready" },    
-  { STATUS_PROCESSOR_OUTAGE,            "Processor Outage" },
-  { STATUS_PROCESSOR_OUTAGE_ENDED,      "Processor Outage Ended" },
-  { STATUS_BUSY,                        "Busy" },
-  { STATUS_BUSY_ENDED,                  "Busy Ended" },
-  { STATUS_OUT_OF_SERVICE,              "Out of Service" },
-  { STATUS_IN_SERVICE,                  "In Service" },
-  { 0,                                  NULL } };
-
-
-/* Initialize the protocol and registered fields */
-static int proto_m2pa = -1;
-static int hf_m2pa_version = -1;
-static int hf_m2pa_spare = -1;
-static int hf_m2pa_type = -1;
-static int hf_m2pa_class = -1;
-static int hf_m2pa_length = -1;
-static int hf_m2pa_bsn = -1;
-static int hf_m2pa_fsn = -1;
-static int hf_m2pa_status = -1;
-static int hf_m2pa_li_spare = -1;
-static int hf_m2pa_li_prio = -1;
-static int hf_m2pa_filler = -1;
-static int hf_m2pa_unknown_data = -1;
-/* Initialize the subtree pointers */
-static gint ett_m2pa = -1;
-static gint ett_m2pa_li = -1;
-
-static dissector_handle_t mtp3_handle;
-
-static void
-dissect_m2pa_user_data_message(tvbuff_t *message_data_tvb, packet_info *pinfo, proto_item *m2pa_item, proto_tree *m2pa_tree, proto_tree *tree)
-{
-  proto_item *m2pa_li_item;
-  proto_tree *m2pa_li_tree;
-  tvbuff_t *payload_tvb;
-  guint8 li;
-  guint32 payload_length;
-
-  payload_length = tvb_length(message_data_tvb) - LI_LENGTH;
-
-  if (m2pa_tree) {
-    li = tvb_get_guint8(message_data_tvb, LI_OFFSET);
-    m2pa_li_item = proto_tree_add_text(m2pa_tree, message_data_tvb, LI_OFFSET, LI_LENGTH, "Length Indicator");
-    m2pa_li_tree = proto_item_add_subtree(m2pa_li_item, ett_m2pa_li);
-    proto_tree_add_uint(m2pa_li_tree, hf_m2pa_li_prio,  message_data_tvb, LI_OFFSET, LI_LENGTH, li);
-    proto_tree_add_uint(m2pa_li_tree, hf_m2pa_li_spare, message_data_tvb, LI_OFFSET, LI_LENGTH, li);
-
-    /* Re-adjust length of M2PA item since it will be dissected as MTP3 */
-    proto_item_set_len(m2pa_item, HEADER_LENGTH + LI_LENGTH);
-  };
-
-  payload_tvb = tvb_new_subset(message_data_tvb, MTP3_OFFSET, payload_length, payload_length);
-  call_dissector(mtp3_handle, payload_tvb, pinfo, tree);
-}
+static const value_string link_status_values[] = {
+  { STATUS_ALIGNMENT,                "Alignment" },
+  { STATUS_PROVING_NORMAL,           "Proving Normal" },
+  { STATUS_PROVING_EMERGENCY,        "Proving Emergency" },
+  { STATUS_READY,                    "Ready" },    
+  { STATUS_PROCESSOR_OUTAGE,         "Processor Outage" },
+  { STATUS_PROCESSOR_OUTAGE_ENDED,   "Processor Outage Ended" },
+  { STATUS_BUSY,                     "Busy" },
+  { STATUS_BUSY_ENDED,               "Busy Ended" },
+  { STATUS_OUT_OF_SERVICE,           "Out of Service" },
+  { STATUS_IN_SERVICE,               "In Service" },
+  { 0,                               NULL } };
 
 static void
-dissect_m2pa_link_status_message(tvbuff_t *message_data_tvb, proto_tree *m2pa_tree)
+dissect_m2pa_link_status_message(tvbuff_t *message_data_tvb, packet_info *pinfo, proto_tree *m2pa_tree)
 {
-  guint32 status;
   guint16 filler_length;
   
+  if (check_col(pinfo->cinfo, COL_INFO))
+    col_append_str(pinfo->cinfo, COL_INFO, "Link status ");
   if (m2pa_tree) {
-    status        = tvb_get_ntohl (message_data_tvb, STATUS_OFFSET);
     filler_length = tvb_length(message_data_tvb) - STATUS_LENGTH;
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_status, message_data_tvb, STATUS_OFFSET, STATUS_LENGTH, status);
+    proto_tree_add_item(m2pa_tree, hf_status, message_data_tvb, STATUS_OFFSET, STATUS_LENGTH, NETWORK_BYTE_ORDER);
     if (filler_length > 0)
-      proto_tree_add_bytes(m2pa_tree, hf_m2pa_filler, message_data_tvb, FILLER_OFFSET, filler_length,
-                           tvb_get_ptr(message_data_tvb, FILLER_OFFSET, filler_length));
-  };
-
-}
-
-static void
-dissect_m2pa_unknown_message(tvbuff_t *message_data_tvb, proto_tree *m2pa_tree)
-{
-  guint32 message_data_length;
-  
-  if (m2pa_tree) {
-    message_data_length = tvb_length(message_data_tvb);
-    proto_tree_add_bytes(m2pa_tree, hf_m2pa_unknown_data, message_data_tvb, 0, message_data_length,
-                         tvb_get_ptr(message_data_tvb, 0, message_data_length));
+      proto_tree_add_item(m2pa_tree, hf_filler, message_data_tvb, FILLER_OFFSET, filler_length, NETWORK_BYTE_ORDER);
   }
 }
 
 static void
-dissect_m2pa_header(tvbuff_t *header_tvb, packet_info *pinfo, proto_tree *m2pa_tree)
-{
-  guint8  version, spare, class, type;
-  guint16 bsn, fsn;
-  guint32 length;
-
-  version        = tvb_get_guint8(header_tvb, VERSION_OFFSET);
-  spare          = tvb_get_guint8(header_tvb, SPARE_OFFSET);
-  class          = tvb_get_guint8(header_tvb, CLASS_OFFSET);
-  type           = tvb_get_guint8(header_tvb, TYPE_OFFSET);
-  length         = tvb_get_ntohl(header_tvb,  LENGTH_OFFSET);
-  bsn            = tvb_get_ntohs(header_tvb,  BSN_OFFSET);
-  fsn            = tvb_get_ntohs(header_tvb,  FSN_OFFSET);
-
-  if (check_col(pinfo->cinfo, COL_INFO)) {
-    col_append_str(pinfo->cinfo, COL_INFO, val_to_str(type, m2pa_message_type_values, "Invalid"));
-    col_append_str(pinfo->cinfo, COL_INFO, " ");
-  };
-
-  if (m2pa_tree) {
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_version, header_tvb, VERSION_OFFSET, VERSION_LENGTH, version);
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_spare, header_tvb, SPARE_OFFSET, SPARE_LENGTH, spare);
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_type, header_tvb, TYPE_OFFSET, TYPE_LENGTH, type);
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_class, header_tvb, CLASS_OFFSET, CLASS_LENGTH, class);
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_length, header_tvb, LENGTH_OFFSET, LENGTH_LENGTH, length);
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_bsn, header_tvb, BSN_OFFSET, BSN_LENGTH, bsn);
-    proto_tree_add_uint(m2pa_tree, hf_m2pa_fsn, header_tvb, FSN_OFFSET, FSN_LENGTH, fsn);
-  };
+dissect_m2pa_unknown_message(tvbuff_t *message_data_tvb, packet_info *pinfo, proto_tree *m2pa_tree)
+{  
+  if (check_col(pinfo->cinfo, COL_INFO))
+    col_append_str(pinfo->cinfo, COL_INFO, "Unknown ");
+  if (m2pa_tree)
+    proto_tree_add_item(m2pa_tree, hf_unknown_data, message_data_tvb, 0, tvb_length(message_data_tvb), NETWORK_BYTE_ORDER);
 }
 
+#define MESSAGE_DATA_OFFSET (HEADER_OFFSET + HEADER_LENGTH)
+
 static void
 dissect_m2pa_message_data(tvbuff_t *message_tvb, packet_info *pinfo, proto_item *m2pa_item, proto_tree *m2pa_tree, proto_tree *tree)
 {
@@ -246,11 +221,11 @@ dissect_m2pa_message_data(tvbuff_t *message_tvb, packet_info *pinfo, proto_item
     break;
 
   case MESSAGE_TYPE_LINK_STATUS:
-    dissect_m2pa_link_status_message(message_data_tvb, m2pa_tree);
+    dissect_m2pa_link_status_message(message_data_tvb, pinfo, m2pa_tree);
     break;
 
   default:
-    dissect_m2pa_unknown_message(message_data_tvb, m2pa_tree);
+    dissect_m2pa_unknown_message(message_data_tvb, pinfo, m2pa_tree);
   }
 
 }
@@ -260,9 +235,8 @@ dissect_m2pa_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_item *m2pa
   tvbuff_t *header_tvb;
 
   header_tvb = tvb_new_subset(message_tvb, HEADER_OFFSET, HEADER_LENGTH, HEADER_LENGTH);
-  dissect_m2pa_header(header_tvb, pinfo, m2pa_tree);
+  dissect_m2pa_header(header_tvb, m2pa_tree);
   dissect_m2pa_message_data(message_tvb, pinfo, m2pa_item, m2pa_tree, tree);
-
 }
 
 static void
@@ -271,14 +245,10 @@ dissect_m2pa(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
   proto_item *m2pa_item;
   proto_tree *m2pa_tree;
 
-  /* make entry in the Protocol column on summary display */
   if (check_col(pinfo->cinfo, COL_PROTOCOL))
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "M2PA");
 
-  /* In the interest of speed, if "tree" is NULL, don't do any work not
-     necessary to generate protocol tree items. */
   if (tree) {
-    /* create the m2pa protocol tree */
     m2pa_item = proto_tree_add_item(tree, proto_m2pa, tvb, 0, -1, FALSE);
     m2pa_tree = proto_item_add_subtree(m2pa_item, ett_m2pa);
   } else {
@@ -286,105 +256,47 @@ dissect_m2pa(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
     m2pa_tree = NULL;
   };
 
-  /* dissect the message */
   dissect_m2pa_message(tvb, pinfo, m2pa_item, m2pa_tree, tree);
 }
 
-/* Register the protocol with Ethereal */
 void
 proto_register_m2pa(void)
 {
-
-  /* Setup list of header fields */
   static hf_register_info hf[] = {
-    { &hf_m2pa_version,
-      { "Version", "m2pa.version",
-	      FT_UINT8, BASE_DEC, VALS(m2pa_protocol_version_values), 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_spare,
-      { "Spare", "m2pa.spare",
-	      FT_UINT8, BASE_HEX, NULL, 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_type,
-      { "Message Type", "m2pa.type",
-	      FT_UINT8, BASE_DEC, VALS(m2pa_message_type_values), 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_class,
-      { "Message Class", "m2pa.class",
-	      FT_UINT8, BASE_DEC, VALS(m2pa_message_class_values), 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_length,
-      { "Message length", "m2pa.length",
-	      FT_UINT32, BASE_DEC, NULL, 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_bsn,
-      { "BSN", "m2pa.bsn",
-	      FT_UINT16, BASE_DEC, NULL, 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_fsn,
-      { "FSN", "m2pa.fsn",
-	      FT_UINT16, BASE_DEC, NULL, 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_li_spare,
-      { "Spare", "m2pa.li_spare",
-	      FT_UINT8, BASE_HEX, NULL, LI_SPARE_MASK,
-        "", HFILL}
-    },
-    { &hf_m2pa_li_prio,
-      { "Priority", "m2pa.li_priority",
-	      FT_UINT8, BASE_HEX, NULL, LI_PRIORITY_MASK,
-	      "", HFILL}
-    },
-    { &hf_m2pa_status,
-      { "Link Status Status", "m2pa.status",
-	      FT_UINT32, BASE_DEC, VALS(m2pa_link_status_values), 0x0,
-	      "", HFILL}
-    },
-    { &hf_m2pa_filler,
-      { "Filler", "m2pa.filler",
-	       FT_BYTES, BASE_NONE, NULL, 0x0,          
-	       "", HFILL }
-    },
-    { &hf_m2pa_unknown_data,
-      { "Unknown Data", "m2pa.unknown_data",
-	       FT_BYTES, BASE_NONE, NULL, 0x0,          
-	       "", HFILL }
-    }
+    { &hf_version,      { "Version",        "m2pa.version",      FT_UINT8,  BASE_DEC,  VALS(protocol_version_values), 0x0,              "", HFILL} },
+    { &hf_spare,        { "Spare",          "m2pa.spare",        FT_UINT8,  BASE_HEX,  NULL,                          0x0,              "", HFILL} },
+    { &hf_type,         { "Message Type",   "m2pa.type",         FT_UINT8,  BASE_DEC,  VALS(message_type_values),     0x0,              "", HFILL} },
+    { &hf_class,        { "Message Class",  "m2pa.class",        FT_UINT8,  BASE_DEC,  VALS(message_class_values),    0x0,              "", HFILL} },
+    { &hf_length,       { "Message length", "m2pa.length",       FT_UINT32, BASE_DEC,  NULL,                          0x0,              "", HFILL} },
+    { &hf_unused,       { "Unused",         "m2pa.unused",       FT_UINT8,  BASE_DEC,  NULL,                          0x0,              "", HFILL} },
+    { &hf_bsn,          { "BSN",            "m2pa.bsn",          FT_UINT24, BASE_DEC,  NULL,                          0x0,              "", HFILL} },
+    { &hf_fsn,          { "FSN",            "m2pa.fsn",          FT_UINT24, BASE_DEC,  NULL,                          0x0,              "", HFILL} },
+    { &hf_li_spare,     { "Spare",          "m2pa.li_spare",     FT_UINT8,  BASE_HEX,  NULL,                          LI_SPARE_MASK,    "", HFILL} },
+    { &hf_li_prio,      { "Priority",       "m2pa.li_priority",  FT_UINT8,  BASE_HEX,  NULL,                          LI_PRIORITY_MASK, "", HFILL} },
+    { &hf_status,       { "Link Status",    "m2pa.status",       FT_UINT32, BASE_DEC,  VALS(link_status_values),      0x0,              "", HFILL} },
+    { &hf_filler,       { "Filler",         "m2pa.filler",       FT_BYTES,  BASE_NONE, NULL,                          0x0,              "", HFILL } },
+    { &hf_unknown_data, { "Unknown Data",   "m2pa.unknown_data", FT_BYTES,  BASE_NONE, NULL,                          0x0,              "", HFILL } }
   };
 
-  /* Setup protocol subtree array */
   static gint *ett[] = {
     &ett_m2pa,
     &ett_m2pa_li
   };
 
-  /* Register the protocol name and description */
-  proto_m2pa = proto_register_protocol("MTP2 Peer Adaptation Layer", "M2PA", "m2pa");
+  proto_m2pa = proto_register_protocol("MTP2 Peer Adaptation Layer (draft-ietf-sigtran-m2pa-05.txt)", "M2PA", "m2pa");
 
-  /* Required function calls to register the header fields and subtrees used */
   proto_register_field_array(proto_m2pa, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
-
-};
+}
 
 void
 proto_reg_handoff_m2pa(void)
 {
   dissector_handle_t m2pa_handle;
 
-  /*
-   *  Get a handle for the MTP3 dissector.
-   */
-  mtp3_handle = find_dissector("mtp3");
-
-  m2pa_handle = create_dissector_handle(dissect_m2pa, proto_m2pa);
+  mtp3_handle   = find_dissector("mtp3");
+  mtp3_proto_id = proto_get_id_by_filter_name("mtp3");
+  m2pa_handle   = create_dissector_handle(dissect_m2pa, proto_m2pa);
   dissector_add("sctp.ppi",  M2PA_PAYLOAD_PROTOCOL_ID, m2pa_handle);
-  dissector_add("sctp.port", SCTP_PORT_M2PA, m2pa_handle);
-}
+  dissector_add("sctp.port", SCTP_PORT_M2PA,           m2pa_handle);
+}
\ No newline at end of file