From Guido Reismueller:

packet-mdd.c
- TLV 15 fixed

packet-tlv.c
- Added Support for DOCSIS 3.0 TLVs (38-66)

Added Support for the following DOCSIS 3.0 MAC Management Messages
- DBC-REQ (packet-dbcreq.c)
- DBC-RSP (packet-dbcrsp.c)
- DBC-ACK (packet-dbcack.c)
- CM-CTRL-REQ (packet-cmctrlreq.c)
- CM-CTRL-RSP (packet-cmctrlrsp.c)
- DPV-REQ (packet-dpvreq.c)
- DPV-RSP (packet-dpvrsp.c)

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@35193 f5534014-38df-0310-8fa8-9805f1628bb7

diff --git a/plugins/docsis/CMakeLists.txt b/plugins/docsis/CMakeLists.txt
index 7dd2e39463f03c2cc4eb61453a692a33a7df7a47..d97267b784523d73b1dbd32db39c628f6a33a635 100644 (file)
--- a/plugins/docsis/CMakeLists.txt
+++ b/plugins/docsis/CMakeLists.txt
@@ -26,11 +26,18 @@ set(DISSECTOR_SRC
        packet-bpkmattr.c
        packet-bpkmreq.c
        packet-bpkmrsp.c
+       packet-cmctrlreq.c
+       packet-cmctrlrsp.c
        packet-intrngreq.c
+       packet-dbcreq.c
+       packet-dbcrsp.c
+       packet-dbcack.c
        packet-dccack.c
        packet-dccreq.c
        packet-dccrsp.c
        packet-dcd.c
+       packet-dpvreq.c
+       packet-dpvrsp.c
        packet-docsis.c
        packet-dsaack.c
        packet-dsareq.c
@@ -52,6 +59,7 @@ set(DISSECTOR_SRC
        packet-rngrsp.c
        packet-sync.c
        packet-tlv.c
+       packet-tlv-cmctrl.c
        packet-type29ucd.c
        packet-uccreq.c
        packet-uccrsp.c

diff --git a/plugins/docsis/Makefile.common b/plugins/docsis/Makefile.common
index f2cd514f9cfef118ce5f3ed2d37a131ba988eb8e..f44eae876551a9608886dbd795cf3dbec5a2b739 100644 (file)
--- a/plugins/docsis/Makefile.common
+++ b/plugins/docsis/Makefile.common
@@ -32,11 +32,18 @@ DISSECTOR_SRC = \
        packet-bpkmattr.c \
        packet-bpkmreq.c \
        packet-bpkmrsp.c \
+       packet-cmctrlreq.c \
+       packet-cmctrlrsp.c \
        packet-intrngreq.c \
+       packet-dbcreq.c \
+       packet-dbcrsp.c \
+       packet-dbcack.c \
        packet-dccack.c \
        packet-dccreq.c \
        packet-dccrsp.c \
        packet-dcd.c \
+       packet-dpvreq.c \
+       packet-dpvrsp.c \
        packet-docsis.c \
        packet-dsaack.c \
        packet-dsareq.c \
@@ -58,6 +65,7 @@ DISSECTOR_SRC = \
        packet-rngrsp.c \
        packet-sync.c \
        packet-tlv.c \
+       packet-tlv-cmctrl.c \
        packet-type29ucd.c \
        packet-uccreq.c \
        packet-uccrsp.c \
@@ -66,4 +74,5 @@ DISSECTOR_SRC = \
 
 # corresponding headers
 DISSECTOR_INCLUDES =   \
-       packet-tlv.h
+       packet-tlv.h \
+       exceptions.h

diff --git a/plugins/docsis/packet-cmctrlreq.c b/plugins/docsis/packet-cmctrlreq.c
new file mode 100644 (file)
index 0000000..a745634
--- /dev/null
+++ b/plugins/docsis/packet-cmctrlreq.c
@@ -0,0 +1,122 @@
+/* packet-cmctrlreq.c
+ * Routines for DOCSIS 3.0 CM Control Request Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_cmctrlreq = -1;
+static int hf_docsis_cmctrlreq_tranid = -1;
+static dissector_handle_t cmctrl_tlv_handle;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_cmctrlreq = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_cmctrlreq (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *it;
+  proto_tree *cmctrlreq_tree = NULL;
+  guint16 transid;
+  tvbuff_t *next_tvb;
+
+  transid = tvb_get_ntohs (tvb, 0);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "CM Control Request: Transaction-Id = %u", transid);
+
+  if (tree)
+    {
+      it =
+       proto_tree_add_protocol_format (tree, proto_docsis_cmctrlreq, tvb, 0, -1,
+                                       "CM Control Request");
+      cmctrlreq_tree = proto_item_add_subtree (it, ett_docsis_cmctrlreq);
+      proto_tree_add_item (cmctrlreq_tree, hf_docsis_cmctrlreq_tranid, tvb, 0, 2,
+                          FALSE);
+
+    }
+    /* Call Dissector for Appendix C TLV's */
+    next_tvb = tvb_new_subset_remaining (tvb, 2);
+    call_dissector (cmctrl_tlv_handle, next_tvb, pinfo, cmctrlreq_tree);
+}
+
+
+
+
+/* Register the protocol with Wireshark */
+
+/* this format is require because a script is used to build the C function
+   that calls all the protocol registration.
+*/
+
+void
+proto_register_docsis_cmctrlreq (void)
+{
+
+/* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_cmctrlreq_tranid,
+     {"Transaction Id", "docsis_cmctrlreq.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_cmctrlreq,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_cmctrlreq =
+    proto_register_protocol ("DOCSIS CM Control Request",
+                            "DOCSIS CM-CTRL-REQ", "docsis_cmctrlreq");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_cmctrlreq, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_cmctrlreq", dissect_cmctrlreq, proto_docsis_cmctrlreq);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_cmctrlreq (void)
+{
+  dissector_handle_t docsis_cmctrlreq_handle;
+
+  docsis_cmctrlreq_handle = find_dissector ("docsis_cmctrlreq");
+  cmctrl_tlv_handle = find_dissector ("cmctrl_tlv");
+  dissector_add ("docsis_mgmt", 0x2A, docsis_cmctrlreq_handle);
+}

diff --git a/plugins/docsis/packet-cmctrlrsp.c b/plugins/docsis/packet-cmctrlrsp.c
new file mode 100644 (file)
index 0000000..88b3911
--- /dev/null
+++ b/plugins/docsis/packet-cmctrlrsp.c
@@ -0,0 +1,130 @@
+/* packet-cmctrlrsp.c
+ * Routines for DOCSIS 3.0 CM Control Response Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+#define RNGRSP_TIMING 1
+#define RNGRSP_PWR_LEVEL_ADJ 2
+#define RNGRSP_OFFSET_FREQ_ADJ 3
+#define RNGRSP_TRANSMIT_EQ_ADJ 4
+#define RNGRSP_RANGING_STATUS 5
+#define RNGRSP_DOWN_FREQ_OVER 6
+#define RNGRSP_UP_CHID_OVER 7
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_cmctrlrsp = -1;
+static int hf_docsis_cmctrlrsp_tranid = -1;
+static dissector_handle_t cmctrl_tlv_handle;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_cmctrlrsp = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_cmctrlrsp (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *it;
+  proto_tree *cmctrlrsp_tree = NULL;
+  guint16 transid;
+  tvbuff_t *next_tvb;
+
+  transid = tvb_get_ntohs (tvb, 0);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "CM Control Response: Transaction-Id = %u", transid);
+
+  if (tree)
+    {
+      it =
+       proto_tree_add_protocol_format (tree, proto_docsis_cmctrlrsp, tvb, 0, -1,
+                                       "CM Control Response");
+      cmctrlrsp_tree = proto_item_add_subtree (it, ett_docsis_cmctrlrsp);
+      proto_tree_add_item (cmctrlrsp_tree, hf_docsis_cmctrlrsp_tranid, tvb, 0, 2,
+                          FALSE);
+
+    }
+    /* Call Dissector for Appendix C TLV's */
+    next_tvb = tvb_new_subset_remaining (tvb, 2);
+    call_dissector (cmctrl_tlv_handle, next_tvb, pinfo, cmctrlrsp_tree);
+}
+
+
+
+
+/* Register the protocol with Wireshark */
+
+/* this format is require because a script is used to build the C function
+   that calls all the protocol registration.
+*/
+
+void
+proto_register_docsis_cmctrlrsp (void)
+{
+
+/* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_cmctrlrsp_tranid,
+     {"Transaction Id", "docsis_cmctrlrsp.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_cmctrlrsp,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_cmctrlrsp =
+    proto_register_protocol ("DOCSIS CM Control Response",
+                            "DOCSIS CM-CTRL-RSP", "docsis_cmctrlrsp");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_cmctrlrsp, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_cmctrlrsp", dissect_cmctrlrsp, proto_docsis_cmctrlrsp);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_cmctrlrsp (void)
+{
+  dissector_handle_t docsis_cmctrlrsp_handle;
+
+  docsis_cmctrlrsp_handle = find_dissector ("docsis_cmctrlrsp");
+  cmctrl_tlv_handle = find_dissector ("cmctrl_tlv");
+  dissector_add ("docsis_mgmt", 0x2B, docsis_cmctrlrsp_handle);
+}

diff --git a/plugins/docsis/packet-dbcack.c b/plugins/docsis/packet-dbcack.c
new file mode 100644 (file)
index 0000000..cb726c4
--- /dev/null
+++ b/plugins/docsis/packet-dbcack.c
@@ -0,0 +1,117 @@
+/* packet-dbcack.c
+ * Routines for DOCSIS 3.0 Dynamic Bonding Change Acknowledge Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_dbcack = -1;
+static int hf_docsis_dbcack_tranid = -1;
+static dissector_handle_t docsis_tlv_handle;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_dbcack = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_dbcack (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *dbcack_item;
+  proto_tree *dbcack_tree = NULL;
+  guint16 transid;
+  tvbuff_t *next_tvb;
+
+  transid = tvb_get_ntohs (tvb, 0);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "Dynamic Bonding Change Acknowledge: Tran-Id = %u", transid);
+
+  if (tree)
+  {
+    dbcack_item = proto_tree_add_protocol_format (tree, proto_docsis_dbcack,
+                                                                                  tvb, 0, -1,
+                                                                                  "Dynamic Bonding Change Acknowledge");
+    dbcack_tree = proto_item_add_subtree (dbcack_item, ett_docsis_dbcack);
+    proto_tree_add_item (dbcack_tree, hf_docsis_dbcack_tranid,
+                                                  tvb, 0, 2, FALSE);
+  }
+  /* Call Dissector for Appendix C TLV's */
+  next_tvb = tvb_new_subset_remaining (tvb, 2);
+  call_dissector (docsis_tlv_handle, next_tvb, pinfo, dbcack_tree);
+}
+
+/* Register the protocol with Wireshark */
+
+/*
+ * this format is required because a script is used to build the C function
+ * that calls all the protocol registration.
+ */
+void
+proto_register_docsis_dbcack (void)
+{
+  /* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_dbcack_tranid,
+     {"Transaction Id", "docsis_dbcack.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_dbcack,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_dbcack = proto_register_protocol ("DOCSIS Dynamic Bonding Change Acknowledge",
+                                                "DOCSIS DBC-ACK",
+                                                "docsis_dbcack");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_dbcack, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_dbcack", dissect_dbcack, proto_docsis_dbcack);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_dbcack (void)
+{
+  dissector_handle_t docsis_dbcack_handle;
+
+  docsis_dbcack_handle = find_dissector ("docsis_dbcack");
+  docsis_tlv_handle = find_dissector ("docsis_tlv");
+  dissector_add ("docsis_mgmt", 0x26, docsis_dbcack_handle);
+}

diff --git a/plugins/docsis/packet-dbcreq.c b/plugins/docsis/packet-dbcreq.c
new file mode 100644 (file)
index 0000000..20061a7
--- /dev/null
+++ b/plugins/docsis/packet-dbcreq.c
@@ -0,0 +1,133 @@
+/* packet-dbcreq.c
+ * Routines for DOCSIS 3.0 Dynamic Bonding Change Request Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_dbcreq = -1;
+static int hf_docsis_dbcreq_tranid = -1;
+static int hf_docsis_dbcreq_number_of_fragments = -1;
+static int hf_docsis_dbcreq_fragment_sequence_number = -1;
+static dissector_handle_t docsis_tlv_handle;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_dbcreq = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_dbcreq (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *dbcreq_item;
+  proto_tree *dbcreq_tree = NULL;
+  guint16 transid;
+  tvbuff_t *next_tvb;
+
+  transid = tvb_get_ntohs (tvb, 0);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "Dynamic Bonding Change Request: Tran-Id = %u", transid);
+
+  if (tree)
+  {
+    dbcreq_item = proto_tree_add_protocol_format (tree, proto_docsis_dbcreq,
+                                                                                  tvb, 0, -1,
+                                                                                  "Dynamic Bonding Change Request");
+    dbcreq_tree = proto_item_add_subtree (dbcreq_item, ett_docsis_dbcreq);
+    proto_tree_add_item (dbcreq_tree, hf_docsis_dbcreq_tranid,
+                                                  tvb, 0, 2, FALSE);
+    proto_tree_add_item( dbcreq_tree, hf_docsis_dbcreq_number_of_fragments,
+                                                  tvb, 2, 1, FALSE );
+    proto_tree_add_item( dbcreq_tree, hf_docsis_dbcreq_fragment_sequence_number ,
+                                                  tvb, 3, 1, FALSE );
+  }
+  /* Call Dissector for Appendix C TLV's */
+  next_tvb = tvb_new_subset_remaining (tvb, 4);
+  call_dissector (docsis_tlv_handle, next_tvb, pinfo, dbcreq_tree);
+}
+
+/* Register the protocol with Wireshark */
+
+/*
+ * this format is required because a script is used to build the C function
+ * that calls all the protocol registration.
+ */
+void
+proto_register_docsis_dbcreq (void)
+{
+  /* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_dbcreq_tranid,
+     {"Transaction Id", "docsis_dbcreq.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dbcreq_number_of_fragments,
+     {"Number of Fragments", "docsis_dbcreq.number_of_fragments",
+      FT_UINT8, BASE_HEX_DEC, NULL, 0x0,
+      NULL, HFILL}
+    },
+    {&hf_docsis_dbcreq_fragment_sequence_number,
+     {"Fragment Seq No", "docsis_dbcreq.fragment_sequence_number",
+      FT_UINT8, BASE_HEX_DEC, NULL, 0x0,
+      NULL, HFILL}
+    },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_dbcreq,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_dbcreq = proto_register_protocol ("DOCSIS Dynamic Bonding Change Request",
+                                                "DOCSIS DBC-REQ",
+                                                "docsis_dbcreq");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_dbcreq, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_dbcreq", dissect_dbcreq, proto_docsis_dbcreq);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_dbcreq (void)
+{
+  dissector_handle_t docsis_dbcreq_handle;
+
+  docsis_dbcreq_handle = find_dissector ("docsis_dbcreq");
+  docsis_tlv_handle = find_dissector ("docsis_tlv");
+  dissector_add ("docsis_mgmt", 0x24, docsis_dbcreq_handle);
+}

diff --git a/plugins/docsis/packet-dbcrsp.c b/plugins/docsis/packet-dbcrsp.c
new file mode 100644 (file)
index 0000000..13d8fab
--- /dev/null
+++ b/plugins/docsis/packet-dbcrsp.c
@@ -0,0 +1,130 @@
+/* packet-dbcrsp.c
+ * Routines for DOCSIS 3.0 Dynamic Bonding Change Response Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+extern value_string docsis_conf_code[];
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_dbcrsp = -1;
+static int hf_docsis_dbcrsp_tranid = -1;
+static int hf_docsis_dbcrsp_conf_code = -1;
+static dissector_handle_t docsis_tlv_handle;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_dbcrsp = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_dbcrsp (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *dbcrsp_item;
+  proto_tree *dbcrsp_tree = NULL;
+  guint16 transid;
+  guint8 confcode;
+  tvbuff_t *next_tvb;
+
+  transid = tvb_get_ntohs (tvb, 0);
+  confcode = tvb_get_guint8 (tvb, 2);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "Dynamic Bonding Change Response: Tran-Id = %u (%s)", transid,
+                val_to_str (confcode, docsis_conf_code, "%d"));
+
+  if (tree)
+  {
+    dbcrsp_item = proto_tree_add_protocol_format (tree, proto_docsis_dbcrsp,
+                                                                                  tvb, 0, -1,
+                                                                                  "Dynamic Bonding Change Response");
+    dbcrsp_tree = proto_item_add_subtree (dbcrsp_item, ett_docsis_dbcrsp);
+    proto_tree_add_item (dbcrsp_tree, hf_docsis_dbcrsp_tranid,
+                                                  tvb, 0, 2, FALSE);
+    proto_tree_add_item( dbcrsp_tree, hf_docsis_dbcrsp_conf_code,
+                                                  tvb, 2, 1, FALSE );
+  }
+  /* Call Dissector for Appendix C TLV's */
+  next_tvb = tvb_new_subset_remaining (tvb, 3);
+  call_dissector (docsis_tlv_handle, next_tvb, pinfo, dbcrsp_tree);
+}
+
+/* Register the protocol with Wireshark */
+
+/*
+ * this format is required because a script is used to build the C function
+ * that calls all the protocol registration.
+ */
+void
+proto_register_docsis_dbcrsp (void)
+{
+  /* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_dbcrsp_tranid,
+     {"Transaction Id", "docsis_dbcrsp.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dbcrsp_conf_code,
+     {"Confirmation Code", "docsis_dbcrsp.conf_code",
+      FT_UINT8, BASE_DEC, VALS (docsis_conf_code), 0x0,
+      NULL, HFILL}
+    },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_dbcrsp,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_dbcrsp = proto_register_protocol ("DOCSIS Dynamic Bonding Change Response",
+                                                "DOCSIS DBC-RSP",
+                                                "docsis_dbcrsp");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_dbcrsp, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_dbcrsp", dissect_dbcrsp, proto_docsis_dbcrsp);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_dbcrsp (void)
+{
+  dissector_handle_t docsis_dbcrsp_handle;
+
+  docsis_dbcrsp_handle = find_dissector ("docsis_dbcrsp");
+  docsis_tlv_handle = find_dissector ("docsis_tlv");
+  dissector_add ("docsis_mgmt", 0x25, docsis_dbcrsp_handle);
+}

diff --git a/plugins/docsis/packet-dpvreq.c b/plugins/docsis/packet-dpvreq.c
new file mode 100644 (file)
index 0000000..91668e3
--- /dev/null
+++ b/plugins/docsis/packet-dpvreq.c
@@ -0,0 +1,182 @@
+/* packet-dpvreq.c
+ * Routines for DOCSIS 3.0 DOCSIS Path Verify Response Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_dpvreq = -1;
+static int hf_docsis_dpvreq_tranid = -1;
+static int hf_docsis_dpvreq_dschan = -1;
+static int hf_docsis_dpvreq_flags = -1;
+static int hf_docsis_dpvreq_us_sf = -1;
+static int hf_docsis_dpvreq_n = -1;
+static int hf_docsis_dpvreq_start = -1;
+static int hf_docsis_dpvreq_end = -1;
+static int hf_docsis_dpvreq_ts_start = -1;
+static int hf_docsis_dpvreq_ts_end = -1;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_dpvreq = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_dpvreq (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *it;
+  proto_tree *dpvreq_tree = NULL;
+  guint16 transid;
+  guint8 dschan;
+
+  transid = tvb_get_ntohs (tvb, 0);
+  dschan = tvb_get_guint8 (tvb, 2);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "DOCSIS Path Verify Request: Transaction-Id = %u DS-Ch %d", 
+               transid, dschan);
+
+  if (tree)
+    {
+      it =
+       proto_tree_add_protocol_format (tree, proto_docsis_dpvreq, tvb, 0, -1,
+                                       "DPV Request");
+      dpvreq_tree = proto_item_add_subtree (it, ett_docsis_dpvreq);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_tranid, tvb, 
+                         0, 2, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_dschan, tvb, 
+                         2, 1, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_flags, tvb, 
+                         3, 1, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_us_sf, tvb, 
+                         4, 4, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_n, tvb, 
+                         8, 2, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_start, tvb, 
+                         10, 1, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_end, tvb, 
+                         11, 1, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_ts_start, tvb, 
+                         12, 4, FALSE);
+      proto_tree_add_item (dpvreq_tree, hf_docsis_dpvreq_ts_end, tvb, 
+                         16, 4, FALSE);
+    }
+}
+
+
+
+
+/* Register the protocol with Wireshark */
+
+/* this format is require because a script is used to build the C function
+   that calls all the protocol registration.
+*/
+
+void
+proto_register_docsis_dpvreq (void)
+{
+
+/* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_dpvreq_tranid,
+     {"Transaction Id", "docsis_dpvreq.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_dschan,
+     {"Downstream Channel ID", "docsis_dpvreq.dschan",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_flags,
+     {"Flags", "docsis_dpvreq.flags",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_us_sf,
+     {"Upstream Service Flow ID", "docsis_dpvreq.us_sf",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_n,
+     {"N (Measurement avaraging factor)", "docsis_dpvreq.n",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_start,
+     {"Start Reference Point", "docsis_dpvreq.start",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_end,
+     {"End Reference Point", "docsis_dpvreq.end",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_ts_start,
+     {"Timestamp Start", "docsis_dpvreq.ts_start",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvreq_ts_end,
+     {"Timestamp End", "docsis_dpvreq.ts_end",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_dpvreq,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_dpvreq =
+    proto_register_protocol ("DOCSIS Path Verify Request",
+                            "DOCSIS DPV-REQ", "docsis_dpvreq");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_dpvreq, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_dpvreq", dissect_dpvreq, proto_docsis_dpvreq);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_dpvreq (void)
+{
+  dissector_handle_t docsis_dpvreq_handle;
+
+  docsis_dpvreq_handle = find_dissector ("docsis_dpvreq");
+  dissector_add ("docsis_mgmt", 0x27, docsis_dpvreq_handle);
+}

diff --git a/plugins/docsis/packet-dpvrsp.c b/plugins/docsis/packet-dpvrsp.c
new file mode 100644 (file)
index 0000000..96cd5b7
--- /dev/null
+++ b/plugins/docsis/packet-dpvrsp.c
@@ -0,0 +1,182 @@
+/* packet-dpvrsp.c
+ * Routines for DOCSIS 3.0 DOCSIS Path Verify Request Message dissection.
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+/* Initialize the protocol and registered fields */
+static int proto_docsis_dpvrsp = -1;
+static int hf_docsis_dpvrsp_tranid = -1;
+static int hf_docsis_dpvrsp_dschan = -1;
+static int hf_docsis_dpvrsp_flags = -1;
+static int hf_docsis_dpvrsp_us_sf = -1;
+static int hf_docsis_dpvrsp_n = -1;
+static int hf_docsis_dpvrsp_start = -1;
+static int hf_docsis_dpvrsp_end = -1;
+static int hf_docsis_dpvrsp_ts_start = -1;
+static int hf_docsis_dpvrsp_ts_end = -1;
+
+/* Initialize the subtree pointers */
+static gint ett_docsis_dpvrsp = -1;
+
+/* Code to actually dissect the packets */
+static void
+dissect_dpvrsp (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
+{
+  proto_item *it;
+  proto_tree *dpvrsp_tree = NULL;
+  guint16 transid;
+  guint8 dschan;
+
+  transid = tvb_get_ntohs (tvb, 0);
+  dschan = tvb_get_guint8 (tvb, 2);
+
+  col_clear (pinfo->cinfo, COL_INFO);
+  col_add_fstr (pinfo->cinfo, COL_INFO,
+           "DOCSIS Path Verify Response: Transaction-Id = %u DS-Ch %d", 
+               transid, dschan);
+
+  if (tree)
+    {
+      it =
+       proto_tree_add_protocol_format (tree, proto_docsis_dpvrsp, tvb, 0, -1,
+                                       "DPV Response");
+      dpvrsp_tree = proto_item_add_subtree (it, ett_docsis_dpvrsp);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_tranid, tvb, 
+                         0, 2, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_dschan, tvb, 
+                         2, 1, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_flags, tvb, 
+                         3, 1, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_us_sf, tvb, 
+                         4, 4, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_n, tvb, 
+                         8, 2, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_start, tvb, 
+                         10, 1, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_end, tvb, 
+                         11, 1, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_ts_start, tvb, 
+                         12, 4, FALSE);
+      proto_tree_add_item (dpvrsp_tree, hf_docsis_dpvrsp_ts_end, tvb, 
+                         16, 4, FALSE);
+    }
+}
+
+
+
+
+/* Register the protocol with Wireshark */
+
+/* this format is require because a script is used to build the C function
+   that calls all the protocol registration.
+*/
+
+void
+proto_register_docsis_dpvrsp (void)
+{
+
+/* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_docsis_dpvrsp_tranid,
+     {"Transaction Id", "docsis_dpvrsp.tranid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_dschan,
+     {"Downstream Channel ID", "docsis_dpvrsp.dschan",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_flags,
+     {"Flags", "docsis_dpvrsp.flags",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_us_sf,
+     {"Upstream Service Flow ID", "docsis_dpvrsp.us_sf",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_n,
+     {"N (Measurement avaraging factor)", "docsis_dpvrsp.n",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_start,
+     {"Start Reference Point", "docsis_dpvrsp.start",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_end,
+     {"End Reference Point", "docsis_dpvrsp.end",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_ts_start,
+     {"Timestamp Start", "docsis_dpvrsp.ts_start",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_dpvrsp_ts_end,
+     {"Timestamp End", "docsis_dpvrsp.ts_end",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      NULL, HFILL}
+     },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_docsis_dpvrsp,
+  };
+
+/* Register the protocol name and description */
+  proto_docsis_dpvrsp =
+    proto_register_protocol ("DOCSIS Path Verify Response",
+                            "DOCSIS DPV-RSP", "docsis_dpvrsp");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_docsis_dpvrsp, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("docsis_dpvrsp", dissect_dpvrsp, proto_docsis_dpvrsp);
+}
+
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_docsis_dpvrsp (void)
+{
+  dissector_handle_t docsis_dpvrsp_handle;
+
+  docsis_dpvrsp_handle = find_dissector ("docsis_dpvrsp");
+  dissector_add ("docsis_mgmt", 0x28, docsis_dpvrsp_handle);
+}

diff --git a/plugins/docsis/packet-macmgmt.c b/plugins/docsis/packet-macmgmt.c
index f4e9c814cbf978e4263a0649921be9c220b8985b..934f181d3aeb289b5f93aae06740995e6f183e4f 100644 (file)
--- a/plugins/docsis/packet-macmgmt.c
+++ b/plugins/docsis/packet-macmgmt.c
@@ -59,7 +59,21 @@
 #define MGT_UP_DIS 28
 #define MGT_TYPE29UCD 29
 #define MGT_INIT_RNG_REQ 30
+#define MGT_TEST_REQ 31
+#define MGT_DS_CH_DESC 32
+#define MGT_MDD 33
 #define MGT_B_INIT_RNG_REQ 34
+#define MGT_TYPE35UCD 35
+#define MGT_DBC_REQ 36
+#define MGT_DBC_RSP 37
+#define MGT_DBC_ACK 38
+#define MGT_DPV_REQ 39
+#define MGT_DPV_RSP 40
+#define MGT_CM_STATUS 41
+#define MGT_CM_CTRL_REQ 42
+#define MGT_CM_CTRL_RSP 43
+#define MGT_REG_REQ_MP 44
+#define MGT_REG_RSP_MP 45
 
 
 /* Initialize the protocol and registered fields */
@@ -86,6 +100,7 @@ static const value_string mgmt_type_vals[] = {
   {MGT_SYNC, "Timing Synchronisation"},
   {MGT_UCD, "Upstream Channel Descriptor"},
   {MGT_TYPE29UCD, "Upstream Channel Descriptor Type 29"},
+  {MGT_TYPE35UCD, "Upstream Channel Descriptor Type 35"},
   {MGT_MAP, "Upstream Bandwidth Allocation"},
   {MGT_RNG_REQ, "Ranging Request"},
   {MGT_RNG_RSP, "Ranging Response"},
@@ -113,7 +128,20 @@ static const value_string mgmt_type_vals[] = {
   {MGT_DCI_RSP, "Device Class Identification Response"},
   {MGT_UP_DIS, "Upstream Channel Disable"},
   {MGT_INIT_RNG_REQ, "Initial Ranging Request"},
+  {MGT_TEST_REQ, "Test Request Message"},
+  {MGT_DS_CH_DESC, "Downstream Channel Descriptor"},
+  {MGT_MDD, "MAC Domain Descriptor"},
   {MGT_B_INIT_RNG_REQ, "Bonded Initial Ranging Request"},
+  {MGT_DBC_REQ, "Dynamic Bonding Change Request"},
+  {MGT_DBC_RSP, "Dynamic Bonding Change Response"},
+  {MGT_DBC_ACK, "Dynamic Bonding Change Acknowledge"},
+  {MGT_DPV_REQ, "DOCSIS Path Verify Request"},
+  {MGT_DPV_RSP, "DOCSIS Path Verify Response"},
+  {MGT_CM_STATUS, "CM Status Report"},
+  {MGT_CM_CTRL_REQ, "CM Control Request"},
+  {MGT_CM_CTRL_RSP, "CM Control Response"},
+  {MGT_REG_REQ_MP, "Multipart Registration Request"},
+  {MGT_REG_RSP_MP, "Multipart Registration Response"},
   {0, NULL}
 };
 
@@ -177,8 +205,6 @@ dissect_macmgmt (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
     return;
   else
     call_dissector (data_handle, payload_tvb, pinfo, tree);
-
-
 }
 
 

diff --git a/plugins/docsis/packet-mdd.c b/plugins/docsis/packet-mdd.c
index a4e70043edd46420c0a0d345056fc8caac5a75b0..daaaeb249107d2886dde64332f3e56b7114898e3 100644 (file)
--- a/plugins/docsis/packet-mdd.c
+++ b/plugins/docsis/packet-mdd.c
@@ -171,6 +171,8 @@ static const value_string mdd_tlv_vals[] = {
         {CM_STATUS_EVENT_CONTROL  , "CM-STATUS Event Control"},
         {UPSTREAM_TRANSMIT_POWER_REPORTING  , "Upstream Transmit Power Reporting"},
         {DSG_DA_TO_DSID_ASSOCIATION_ENTRY  , "DSG DA-to-DSID Association Entry"},
+        {CM_STATUS_EVENT_ENABLE_NON_CHANNEL_SPECIFIC_EVENTS  , 
+               "CM-STATUS Event Enable for Non-Channel-Specific-Events"},
        {0, NULL}
 };
 
@@ -516,9 +518,11 @@ dissect_mdd (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
                                        break;
                                case CM_STATUS_EVENT_ENABLE_NON_CHANNEL_SPECIFIC_EVENTS:
                                        subpos = pos + 2;
-                                       proto_tree_add_item (tlv_tree, hf_docsis_mdd_cm_status_event_enable_non_channel_specific_events_sequence_out_of_range, tvb, subpos + 2 , 2,FALSE);
-                                       proto_tree_add_item (tlv_tree, hf_docsis_mdd_cm_status_event_enable_non_channel_specific_events_cm_operating_on_battery_backup, tvb, subpos + 2 , 2,FALSE);
-                                       proto_tree_add_item (tlv_tree, hf_docsis_mdd_cm_status_event_enable_non_channel_specific_events_cm_returned_to_ac_power, tvb, subpos + 2 , 2,FALSE);
+                                       tlv_sub_item = proto_tree_add_text (tlv_tree, tvb, subpos, 2, "CM-STATUS Event Enable Bitmask for Non-Channel-Specific Events");
+                                       tlv_sub_tree = proto_item_add_subtree (tlv_sub_item, ett_sub_tlv);
+                                       proto_tree_add_item (tlv_sub_tree, hf_docsis_mdd_cm_status_event_enable_non_channel_specific_events_sequence_out_of_range, tvb, subpos, 2,FALSE);
+                                       proto_tree_add_item (tlv_sub_tree, hf_docsis_mdd_cm_status_event_enable_non_channel_specific_events_cm_operating_on_battery_backup, tvb, subpos , 2,FALSE);
+                                       proto_tree_add_item (tlv_sub_tree, hf_docsis_mdd_cm_status_event_enable_non_channel_specific_events_cm_returned_to_ac_power, tvb, subpos , 2,FALSE);
                                        break;
                        }
                        pos += length + 2;
@@ -725,6 +729,7 @@ void proto_register_docsis_mdd (void)
                FT_UINT16, BASE_DEC, NULL, 0x0400,
                "CM-STATUS event non-channel-event Cm returned to AC power", HFILL}
                },
+
        };
 
        /* Setup protocol subtree array */

diff --git a/plugins/docsis/packet-tlv-cmctrl.c b/plugins/docsis/packet-tlv-cmctrl.c
new file mode 100644 (file)
index 0000000..b466ac4
--- /dev/null
+++ b/plugins/docsis/packet-tlv-cmctrl.c
@@ -0,0 +1,355 @@
+/* packet-tlv-cmctrl.c
+ * Routines to Dissect TLV's for CM-Control Messages
+ * Copyright 2010, Guido Reismueller <g.reismueller[AT]avm.de>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <epan/packet.h>
+
+#define CM_CTRL_MUTE 1
+#define CM_CTRL_MUTE_TIMEOUT 2
+#define CM_CTRL_REINIT 3
+#define CM_CTRL_DISABLE_FWD 4
+#define CM_CTRL_DS_EVENT 5
+#define CM_CTRL_US_EVENT 6
+#define CM_CTRL_EVENT 7
+
+#define DS_EVENT_CH_ID 1
+#define DS_EVENT_MASK 2
+
+#define US_EVENT_CH_ID 1
+#define US_EVENT_MASK 2
+
+static int proto_cmctrl_tlv = -1;
+static int hf_cmctrl_tlv_mute = -1;
+static int hf_cmctrl_tlv_mute_timeout = -1;
+static int hf_cmctrl_tlv_reinit = -1;
+static int hf_cmctrl_tlv_disable_fwd = -1;
+static int hf_cmctrl_tlv_ds_event = -1;
+static int hf_cmctrl_tlv_us_event = -1;
+static int hf_cmctrl_tlv_event = -1;
+
+static int hf_ds_event_ch_id = -1;
+static int hf_ds_event_mask = -1;
+
+static int hf_us_event_ch_id = -1;
+static int hf_us_event_mask = -1;
+
+static gint ett_cmctrl_tlv = -1;
+static gint ett_cmctrl_tlv_ds_event = -1;
+static gint ett_cmctrl_tlv_us_event = -1;
+
+
+static void
+dissect_ds_event(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *event_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Override Downstream Status Event Event Mask (Length = %u)", len);
+  event_tree = proto_item_add_subtree (it, ett_cmctrl_tlv_ds_event);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case DS_EVENT_CH_ID:
+      if (length == 1)
+       {
+         proto_tree_add_item (event_tree, hf_ds_event_ch_id,
+                              tvb, pos, length, FALSE);
+       }
+      else
+       {
+         THROW (ReportedBoundsError);
+       }
+         break;
+       case DS_EVENT_MASK:
+      if (length == 2)
+       {
+         proto_tree_add_item (event_tree, hf_ds_event_mask,
+                              tvb, pos, length, FALSE);
+       }
+      else
+       {
+         THROW (ReportedBoundsError);
+       }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_us_event(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *event_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Override Upstream Status Enable Event Mask (Length = %u)", len);
+  event_tree = proto_item_add_subtree (it, ett_cmctrl_tlv_us_event);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case US_EVENT_CH_ID:
+      if (length == 1)
+       {
+         proto_tree_add_item (event_tree, hf_us_event_ch_id,
+                              tvb, pos, length, FALSE);
+       }
+      else
+       {
+         THROW (ReportedBoundsError);
+       }
+         break;
+       case US_EVENT_MASK:
+      if (length == 2)
+       {
+         proto_tree_add_item (event_tree, hf_us_event_mask,
+                              tvb, pos, length, FALSE);
+       }
+      else
+       {
+         THROW (ReportedBoundsError);
+       }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_cmctrl_tlv (tvbuff_t * tvb, packet_info * pinfo _U_, proto_tree * tree)
+{
+
+  proto_item *it;
+  proto_tree *tlv_tree;
+  int pos = 0;
+  gint total_len;
+  guint8 type, length;
+
+  total_len = tvb_reported_length_remaining (tvb, 0);
+
+  it =
+       proto_tree_add_protocol_format (tree, proto_cmctrl_tlv, tvb, 0,
+                                       total_len, "TLV Data");
+      tlv_tree = proto_item_add_subtree (it, ett_cmctrl_tlv);
+
+    while (pos < total_len)
+       {
+         type = tvb_get_guint8 (tvb, pos++);
+         length = tvb_get_guint8 (tvb, pos++);
+         switch (type)
+           {
+           case CM_CTRL_MUTE:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_mute,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case CM_CTRL_MUTE_TIMEOUT:
+             if (length == 4 || length == 1) /* response TLV always with len 1 */
+               {
+                 proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_mute_timeout,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+                 break;
+               case CM_CTRL_REINIT:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_reinit,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+               case CM_CTRL_DISABLE_FWD:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_disable_fwd,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+               case CM_CTRL_DS_EVENT:
+             if (length == 1)
+                    proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_ds_event,
+                                      tvb, pos, length, FALSE);
+             else
+                    dissect_ds_event(tvb, tlv_tree, pos, length);
+             break;
+               case CM_CTRL_US_EVENT:
+             if (length == 1)
+                    proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_ds_event,
+                                      tvb, pos, length, FALSE);
+             else
+                    dissect_us_event(tvb, tlv_tree, pos, length);
+             break;
+               case CM_CTRL_EVENT:
+             if (length == 2 || length == 1) /* response TLV always with len 1 */
+               {
+                 proto_tree_add_item (tlv_tree, hf_cmctrl_tlv_event,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+
+               } /* switch */
+         pos = pos + length;
+       } /* while */
+}
+
+/* Register the protocol with Wireshark */
+
+/* this format is require because a script is used to build the C function
+   that calls all the protocol registration.
+*/
+
+
+void
+proto_register_cmctrl_tlv (void)
+{
+
+/* Setup list of header fields  See Section 1.6.1 for details*/
+  static hf_register_info hf[] = {
+    {&hf_cmctrl_tlv_mute,
+     {"1 Upstream Channel RF Mute", "cmctrl_tlv.mute",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Upstream Channel RF Mute", HFILL}
+     },
+    {&hf_cmctrl_tlv_mute_timeout,
+     {"2 RF Mute Timeout Interval", "cmctrl_tlv.mute_timeout",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "RF Mute Timeout Interval", HFILL}
+     },
+    {&hf_cmctrl_tlv_reinit,
+     {"3 CM Reinitialize", "cmctrl_tlv.reinit",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "CM Reinitialize", HFILL}
+     },
+    {&hf_cmctrl_tlv_disable_fwd,
+     {"4 Disable Forwarding", "cmctrl_tlv.disable_fwd",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Disable Forwarding", HFILL}
+     },
+    {&hf_cmctrl_tlv_ds_event,
+     {"5 Override Downstream Events", "cmctrl_tlv.ds_event",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Override Downstream Events", HFILL}
+     },
+    {&hf_ds_event_ch_id,
+     {".1 Downstream Channel ID", "cmctrl_tlv.ds_event.chid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Downstream Channel ID", HFILL}
+     },
+    {&hf_ds_event_mask,
+     {".2 Downstream Status Event Enable Bitmask", "cmctrl_tlv.ds_event.mask",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Downstream Status Event Enable Bitmask", HFILL}
+     },
+    {&hf_cmctrl_tlv_us_event,
+     {"6 Override Upstream Events", "cmctrl_tlv.us_event",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Override Downstream Events", HFILL}
+     },
+    {&hf_us_event_ch_id,
+     {".1 Upstream Channel ID", "cmctrl_tlv.us_event.chid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Upstream Channel ID", HFILL}
+     },
+    {&hf_us_event_mask,
+     {".2 Upstream Status Event Enable Bitmask", "cmctrl_tlv.us_event.mask",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Upstream Status Event Enable Bitmask", HFILL}
+     },
+    {&hf_cmctrl_tlv_event,
+     {"7 Override Non-Channel-Specific Events", "cmctrl_tlv.event",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Override Non-Channel-Specific Events", HFILL}
+     },
+  };
+
+/* Setup protocol subtree array */
+  static gint *ett[] = {
+    &ett_cmctrl_tlv,
+    &ett_cmctrl_tlv_ds_event,
+    &ett_cmctrl_tlv_us_event,
+  };
+
+/* Register the protocol name and description */
+  proto_cmctrl_tlv = proto_register_protocol ("DOCSIS CM-CTRL TLV's",
+                                             "DOCSIS CM-CTRL TLVs", "cmctrl_tlv");
+
+/* Required function calls to register the header fields and subtrees used */
+  proto_register_field_array (proto_cmctrl_tlv, hf, array_length (hf));
+  proto_register_subtree_array (ett, array_length (ett));
+
+  register_dissector ("cmctrl_tlv", dissect_cmctrl_tlv, proto_cmctrl_tlv);
+}
+
+/* If this dissector uses sub-dissector registration add a registration routine.
+   This format is required because a script is used to find these routines and
+   create the code that calls these routines.
+*/
+void
+proto_reg_handoff_cmctrl_tlv (void)
+{
+  dissector_handle_t cmctrl_tlv_handle;
+
+  cmctrl_tlv_handle = find_dissector ("cmctrl_tlv");
+
+  dissector_add ("docsis", 0xFE, cmctrl_tlv_handle);
+}
+

diff --git a/plugins/docsis/packet-tlv.c b/plugins/docsis/packet-tlv.c
index c73e37c917bd601071f92922ef46b8380df79120..c664c9948d2fee1fcd73389e7a27e539e879cc6d 100644 (file)
--- a/plugins/docsis/packet-tlv.c
+++ b/plugins/docsis/packet-tlv.c
@@ -39,6 +39,7 @@
 
 /* Initialize the protocol and registered fields */
 static dissector_handle_t docsis_vsif_handle;
+static dissector_handle_t docsis_ucd_handle;
 
 
 static int proto_docsis_tlv = -1;
@@ -85,6 +86,28 @@ static int hf_docsis_tlv_subs_mgmt_ctrl = -1;
 static int hf_docsis_tlv_subs_mgmt_ip_table = -1;
 static int hf_docsis_tlv_subs_mgmt_ip_entry = -1;
 static int hf_docsis_tlv_subs_mgmt_filter_grps = -1;
+static int hf_docsis_tlv_snmpv3_ntfy_rcvr = -1;
+static int hf_docsis_tlv_enable_20_mode = -1;
+static int hf_docsis_tlv_enable_test_modes = -1;
+static int hf_docsis_tlv_ds_ch_list = -1;
+static int hf_docsis_tlv_mc_mac_address = -1;
+static int hf_docsis_tlv_dut_filter = -1;
+static int hf_docsis_tlv_tcc = -1;
+static int hf_docsis_tlv_sid_cl = -1;
+static int hf_docsis_tlv_rcp = -1;
+static int hf_docsis_tlv_rcc = -1;
+static int hf_docsis_tlv_dsid = -1;
+static int hf_docsis_tlv_sec_assoc = -1;
+static int hf_docsis_tlv_init_ch_timeout = -1;
+static int hf_docsis_tlv_ch_asgn = -1;
+static int hf_docsis_tlv_cm_init_reason = -1;
+static int hf_docsis_tlv_sw_upg_srvr_ipv6 = -1;
+static int hf_docsis_tlv_tftp_prov_cm_ipv6_addr = -1;
+static int hf_docsis_tlv_us_drop_clfy = -1;
+static int hf_docsis_tlv_subs_mgmt_ipv6_lst = -1;
+static int hf_docsis_tlv_us_drop_clfy_group_id = -1;
+static int hf_docsis_tlv_subs_mgmt_ctrl_max_cpe_ipv6 = -1;
+static int hf_docsis_tlv_cmts_mc_sess_enc = -1;
 
 static int hf_docsis_tlv_cos_id = -1;
 static int hf_docsis_tlv_cos_sid = -1;
@@ -194,6 +217,131 @@ static int hf_docsis_tlv_phs_err_param = -1;
 static int hf_docsis_tlv_phs_err_code = -1;
 static int hf_docsis_tlv_phs_err_msg = -1;
 
+static int hf_docsis_tlv_ds_ch_list_single = -1;
+static int hf_docsis_tlv_ds_ch_list_range = -1;
+static int hf_docsis_tlv_ds_ch_list_default_timeout = -1;
+
+static int hf_docsis_tlv_single_ch_timeout = -1;
+static int hf_docsis_tlv_single_ch_freq = -1;
+
+static int hf_docsis_tlv_freq_rng_timeout = -1;
+static int hf_docsis_tlv_freq_rng_start = -1;
+static int hf_docsis_tlv_freq_rng_end = -1;
+static int hf_docsis_tlv_freq_rng_step = -1;
+
+static int hf_docsis_tlv_dut_filter_control = -1;
+static int hf_docsis_tlv_dut_filter_cmim = -1;
+
+static int hf_docsis_tlv_tcc_refid = -1;
+static int hf_docsis_tlv_tcc_us_ch_action= -1;
+static int hf_docsis_tlv_tcc_us_ch_id= -1;
+static int hf_docsis_tlv_tcc_new_us_ch_id= -1;
+static int hf_docsis_tlv_tcc_ucd = -1;
+static int hf_docsis_tlv_tcc_rng_sid= -1;
+static int hf_docsis_tlv_tcc_init_tech= -1;
+static int hf_docsis_tlv_tcc_rng_parms= -1;
+static int hf_docsis_tlv_tcc_dyn_rng_win= -1;
+static int hf_docsis_tlv_tcc_err = -1;
+
+static int hf_docsis_rng_parms_us_ch_id = -1;
+static int hf_docsis_rng_parms_time_off_int = -1;
+static int hf_docsis_rng_parms_time_off_frac = -1;
+static int hf_docsis_rng_parms_power_off = -1;
+static int hf_docsis_rng_parms_freq_off = -1;
+
+static int hf_docsis_tcc_err_subtype = -1;
+static int hf_docsis_tcc_err_code = -1;
+static int hf_docsis_tcc_err_msg = -1;
+
+static int hf_docsis_sid_cl_sf_id = -1;
+static int hf_docsis_sid_cl_enc = -1;
+static int hf_docsis_sid_cl_so_crit = -1;
+
+static int hf_docsis_sid_cl_enc_id = -1;
+static int hf_docsis_sid_cl_enc_map = -1;
+
+static int hf_docsis_sid_cl_map_us_ch_id = -1;
+static int hf_docsis_sid_cl_map_sid = -1;
+static int hf_docsis_sid_cl_map_action = -1;
+
+static int hf_docsis_sid_cl_so_max_req = -1;
+static int hf_docsis_sid_cl_so_max_out_bytes = -1;
+static int hf_docsis_sid_cl_so_max_req_bytes = -1;
+static int hf_docsis_sid_cl_so_max_time = -1;
+
+static int hf_docsis_tlv_rcp_id = -1;
+static int hf_docsis_tlv_rcp_name = -1;
+static int hf_docsis_tlv_rcp_freq_spc = -1;
+static int hf_docsis_tlv_rcp_rcv_mod_enc = -1;
+static int hf_docsis_tlv_rcp_rcv_ch = -1;
+static int hf_docsis_tlv_rcp_ven_spec = -1; 
+
+static int hf_docsis_rcv_mod_enc_idx = -1;
+static int hf_docsis_rcv_mod_enc_adj_ch = -1;
+static int hf_docsis_rcv_mod_enc_ch_bl_rng = -1;
+static int hf_docsis_rcv_mod_enc_ctr_freq_asgn = -1;
+static int hf_docsis_rcv_mod_enc_rsq_ch_subs_cap = -1;
+static int hf_docsis_rcv_mod_enc_conn = -1;
+static int hf_docsis_rcv_mod_enc_phy_layr_parms = -1;
+
+static int hf_docsis_rcc_rcv_mod_enc_idx = -1;
+static int hf_docsis_rcc_rcv_mod_enc_ctr_freq_asgn = -1;
+static int hf_docsis_rcc_rcv_mod_enc_conn = -1;
+
+static int hf_docsis_ch_bl_rng_min_ctr_freq = -1;
+static int hf_docsis_ch_bl_rng_max_ctr_freq = -1;
+
+static int hf_docsis_rcv_ch_idx = -1;
+static int hf_docsis_rcv_ch_conn = -1;
+static int hf_docsis_rcv_ch_conn_off = -1;
+static int hf_docsis_rcv_ch_prim_ds_ch_ind = -1;
+
+static int hf_docsis_rcc_rcv_ch_idx = -1;
+static int hf_docsis_rcc_rcv_ch_conn = -1;
+static int hf_docsis_rcc_rcv_ch_ctr_freq_asgn = -1;
+static int hf_docsis_rcc_rcv_ch_prim_ds_ch_ind = -1;
+
+static int hf_docsis_tlv_rcc_id = -1;
+static int hf_docsis_tlv_rcc_rcv_mod_enc = -1;
+static int hf_docsis_tlv_rcc_rcv_ch = -1;
+static int hf_docsis_tlv_rcc_part_serv_ds_ch = -1;
+static int hf_docsis_tlv_rcc_ven_spec = -1; 
+static int hf_docsis_tlv_rcc_err = -1; 
+
+static int hf_docsis_tlv_rcc_err_mod_or_ch = -1;
+static int hf_docsis_tlv_rcc_err_idx = -1;
+static int hf_docsis_tlv_rcc_err_param = -1;
+static int hf_docsis_tlv_rcc_err_code = -1;
+static int hf_docsis_tlv_rcc_err_msg = -1;
+
+static int hf_docsis_tlv_dsid_id = -1;
+static int hf_docsis_tlv_dsid_action = -1;
+static int hf_docsis_tlv_dsid_ds_reseq = -1;
+static int hf_docsis_tlv_dsid_mc = -1;
+
+static int hf_docsis_ds_reseq_dsid = -1;
+static int hf_docsis_ds_reseq_ch_lst = -1;
+static int hf_docsis_ds_reseq_wait_time = -1;
+static int hf_docsis_ds_reseq_warn_thresh = -1;
+static int hf_docsis_ds_reseq_ho_timer = -1;
+
+static int hf_docsis_tlv_dsid_mc_addr = -1;
+static int hf_docsis_tlv_dsid_mc_cmim = -1;
+static int hf_docsis_tlv_dsid_mc_group = -1;
+static int hf_docsis_tlv_dsid_mc_phs = -1;
+
+static int hf_docsis_mc_addr_action = -1;
+static int hf_docsis_mc_addr_addr = -1;
+
+static int hf_docsis_tlv_sec_assoc_action = -1;
+static int hf_docsis_tlv_sec_assoc_desc = -1;
+
+static int hf_docsis_ch_asgn_us_ch_id = -1;
+static int hf_docsis_ch_asgn_rx_freq = -1;
+
+static int hf_docsis_cmts_mc_sess_enc_grp = -1;
+static int hf_docsis_cmts_mc_sess_enc_src = -1;
+
 /* Initialize the subtree pointers */
 static gint ett_docsis_tlv = -1;
 static gint ett_docsis_tlv_cos = -1;
@@ -209,6 +357,33 @@ static gint ett_docsis_tlv_reqxmitpol = -1;
 static gint ett_docsis_tlv_sflow_err = -1;
 static gint ett_docsis_tlv_svc_unavail = -1;
 static gint ett_docsis_tlv_snmpv3_kick = -1;
+static gint ett_docsis_tlv_ds_ch_list = -1;
+static gint ett_docsis_tlv_ds_ch_list_single = -1;
+static gint ett_docsis_tlv_ds_ch_list_range = -1;
+static gint ett_docsis_tlv_dut_filter = -1;
+static gint ett_docsis_tlv_tcc = -1;
+static gint ett_docsis_tlv_tcc_ucd = -1;
+static gint ett_docsis_tlv_tcc_rng_parms = -1;
+static gint ett_docsis_tlv_tcc_err = -1;
+static gint ett_docsis_tlv_sid_cl = -1;
+static gint ett_docsis_tlv_sid_cl_enc = -1;
+static gint ett_docsis_tlv_sid_cl_enc_map = -1;
+static gint ett_docsis_tlv_sid_cl_so = -1;
+static gint ett_docsis_tlv_rcp = -1;
+static gint ett_docsis_tlv_rcp_rcv_mod_enc = -1;
+static gint ett_docsis_tlv_rcp_ch_bl_rng = -1;
+static gint ett_docsis_tlv_rcp_rcv_ch = -1;
+static gint ett_docsis_tlv_rcc = -1;
+static gint ett_docsis_tlv_rcc_rcv_mod_enc = -1;
+static gint ett_docsis_tlv_rcc_rcv_ch = -1;
+static gint ett_docsis_tlv_rcc_err = -1;
+static gint ett_docsis_tlv_dsid = -1;
+static gint ett_docsis_tlv_dsid_ds_reseq = -1;
+static gint ett_docsis_tlv_dsid_mc = -1;
+static gint ett_docsis_tlv_dsid_mc_addr = -1;
+static gint ett_docsis_tlv_sec_assoc = -1;
+static gint ett_docsis_tlv_ch_asgn = -1;
+static gint ett_docsis_cmts_mc_sess_enc = -1;
 
 static const true_false_string on_off_tfs = {
   "On",
@@ -334,7 +509,78 @@ const value_string docsis_conf_code[] = {
   {0, NULL}
 };
 
+static const value_string us_ch_action_vals[] = {
+  {0, "No Action"},
+  {1, "Add"},
+  {2, "Change"},
+  {3, "Delete"},
+  {4, "Replace"},
+  {5, "Re-range"},
+  {0, NULL},
+};
+
+static const value_string init_tech_vals[] = {
+  {0, "reserved"},
+  {1, "Perform broadcast initial ranging before normal ops"},
+  {2, "Perform unicast ranging before normal ops"},
+  {3, "Perform either broadcast or unicast ranging before normal ops"},
+  {4, "Use new channel directly without reinitializing or ranging"},
+  {0, NULL},
+};
+
+static const value_string sid_ch_map_vals[] = {
+  {0, "reserved"},
+  {1, "Add"},
+  {2, "Delete"},
+  {0, NULL},
+};
+
+static const value_string mod_or_ch_vals[] = {
+  {0, "reserved"},
+  {1, "reserved"},
+  {2, "reserved"},
+  {3, "reserved"},
+  {4, "Receive Module"},
+  {5, "Receive Channel"},
+  {0, NULL},
+};
+
+static const value_string dsid_action_vals[] = {
+  {0, "Add"},
+  {1, "Change"},
+  {2, "Delete"},
+  {0, NULL},
+};
 
+static const value_string add_del_vals[] = {
+  {0, "Add"},
+  {1, "Delete"},
+  {0, NULL},
+};
+
+static const value_string init_reason_vals[] = {
+  {0, "reserved"},
+  {1, "Power On"},
+  {2, "T17 Lost Sync"},
+  {3, "All Upstream Failed"},
+  {4, "Bad DHCP Ack"},
+  {5, "Link Local Address in use"},
+  {6, "T6 Expired"},
+  {7, "REG-RSP not ok"},
+  {8, "BAD RCC/TCC"},
+  {9, "Failed Primary Downstream"},
+  {10, "TCS failed on all upstreams"},
+  {11, "reserved"},
+  {12, "reserved"},
+  {13, "reserved"},
+  {14, "reserved"},
+  {15, "MTCM Change"},
+  {16, "T4 Expired"},
+  {17, "No Primary SF on US Channel"},
+  {18, "CM Control Init"},
+  {19, "Dynamic Range Window Violation"},
+  {0, NULL},
+};
 
 /* Code to actually dissect the packets */
 static void
@@ -1766,101 +2012,1604 @@ dissect_snmpv3_kickstart(tvbuff_t * tvb, proto_tree *tree, int start, guint16 le
 }
 
 static void
-dissect_tlv (tvbuff_t * tvb, packet_info * pinfo _U_, proto_tree * tree)
+dissect_ds_ch_list_single (tvbuff_t * tvb, proto_tree * tree, 
+                                  int start, guint16 len)
 {
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *single_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "1 Single Downstream Channel (Length = %u)", len);
+  single_tree = proto_item_add_subtree (it, ett_docsis_tlv_ds_ch_list_single);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case SINGLE_CH_TIMEOUT:
+         if (length == 2)
+           {
+             proto_tree_add_item (single_tree, hf_docsis_tlv_single_ch_timeout, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case SINGLE_CH_FREQ:
+         if (length == 4)
+           {
+             proto_tree_add_item (single_tree, hf_docsis_tlv_single_ch_freq, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    }  /* switch */
+      pos = pos + length;
+  }                            /* while */
+}
 
+static void
+dissect_ds_ch_list_range (tvbuff_t * tvb, proto_tree * tree, 
+                                  int start, guint16 len)
+{
+  guint8 type, length;
   proto_item *it;
-  proto_tree *tlv_tree;
-  int pos = 0;
-  gint total_len;
+  proto_tree *range_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "2 Downstream Frequency Range (Length = %u)", len);
+  range_tree = proto_item_add_subtree (it, ett_docsis_tlv_ds_ch_list_range);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case FREQ_RNG_TIMEOUT:
+         if (length == 2)
+           {
+             proto_tree_add_item (range_tree, hf_docsis_tlv_freq_rng_timeout, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case FREQ_RNG_START:
+         if (length == 4)
+           {
+             proto_tree_add_item (range_tree, hf_docsis_tlv_freq_rng_start, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case FREQ_RNG_END:
+         if (length == 4)
+           {
+             proto_tree_add_item (range_tree, hf_docsis_tlv_freq_rng_end, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case FREQ_RNG_STEP:
+         if (length == 4)
+           {
+             proto_tree_add_item (range_tree, hf_docsis_tlv_freq_rng_step, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    }                          /* switch */
+      pos = pos + length;
+  }                            /* while */
+}
+
+static void
+dissect_dut_filter (tvbuff_t * tvb, proto_tree * tree, 
+                                  int start, guint16 len)
+{
   guint8 type, length;
-  guint16 x;
-  tvbuff_t *vsif_tvb;
+  proto_item *it;
+  proto_tree *dut_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Downstream Unencrypted Traffic (Length = %u)", len);
+  dut_tree = proto_item_add_subtree (it, ett_docsis_tlv_dut_filter);
 
-  total_len = tvb_reported_length_remaining (tvb, 0);
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case DUT_CONTROL:
+         if (length == 1)
+           {
+             proto_tree_add_item (dut_tree, hf_docsis_tlv_dut_filter_control, tvb,
+                                  pos, length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case DUT_CMIM:
+         proto_tree_add_item (dut_tree, hf_docsis_tlv_dut_filter_cmim, tvb,
+                                  pos, length, FALSE);
+         break;
+    }                          /* switch */
+      pos = pos + length;
+  }                            /* while */
+}
+
+static void
+dissect_ds_ch_list(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *dschlst_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "41 Downstream Channel List (Length = %u)", len);
+  dschlst_tree = proto_item_add_subtree (it, ett_docsis_tlv_ds_ch_list);
 
+  while (pos < (start + len))
     {
-      it =
-       proto_tree_add_protocol_format (tree, proto_docsis_tlv, tvb, 0,
-                                       total_len, "TLV Data");
-      tlv_tree = proto_item_add_subtree (it, ett_docsis_tlv);
-      while (pos < total_len)
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
        {
-         type = tvb_get_guint8 (tvb, pos++);
-         length = tvb_get_guint8 (tvb, pos++);
-         switch (type)
+       case DS_CH_LIST_SINGLE:
+      dissect_ds_ch_list_single(tvb, dschlst_tree, pos, length);
+         break;
+       case DS_CH_LIST_RANGE:
+      dissect_ds_ch_list_range(tvb, dschlst_tree, pos, length);
+         break;
+       case DS_CH_LIST_DEFAULT_TIMEOUT:
+         if (length == 2)
            {
-           case TLV_DOWN_FREQ:
-             /* This is ugly.  There are multiple type 1 TLV's that may appear
-              * in the TLV data, the problem is that they are dependent on
-              * message type.  */
-             if (length == 4)
-               proto_tree_add_item (tlv_tree, hf_docsis_tlv_down_freq, tvb,
-                                    pos, length, FALSE);
-             else if (length == 1)
-               proto_tree_add_item (tlv_tree, hf_docsis_tlv_rng_tech, tvb,
-                                    pos, length, FALSE);
-             else
-               dissect_doc10cos (tvb, tlv_tree, pos, length);
-             break;
-           case TLV_CHNL_ID:
-             if (length == 1)
-               {
-                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_upstream_chid,
-                                      tvb, pos, length, FALSE);
-               }
-             else
-               {
-                 THROW (ReportedBoundsError);
-               }
-             break;
-           case TLV_NET_ACCESS:
-             if (length == 1)
-               {
-                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_net_access,
-                                      tvb, pos, length, FALSE);
-               }
-             else
-               {
-                 THROW (ReportedBoundsError);
-               }
-             break;
-           case TLV_COS:
-             dissect_cos (tvb, tlv_tree, pos, length);
-             break;
-           case TLV_MODEM_CAP:
-             dissect_modemcap (tvb, tlv_tree, pos, length);
-             break;
-           case TLV_CM_MIC:
-             if (length == 16)
-               {
-                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_cm_mic, tvb,
-                                      pos, length, FALSE);
-               }
-             else
-               {
-                 THROW (ReportedBoundsError);
-               }
-             break;
-           case TLV_CMTS_MIC:
-             if (length == 16)
-               {
-                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_cmts_mic, tvb,
-                                      pos, length, FALSE);
-               }
-             else
-               {
-                 THROW (ReportedBoundsError);
-               }
-             break;
-           case TLV_VENDOR_ID:
-             if (length == 3)
-               {
-                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_vendor_id, tvb,
-                                      pos, length, FALSE);
-               }
-             else
-               {
+             proto_tree_add_item (dschlst_tree,
+                                  hf_docsis_tlv_ds_ch_list_default_timeout, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_tcc_err(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *tccerr_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "TCC Error Encodings (Length = %u)", len);
+  tccerr_tree = proto_item_add_subtree (it, ett_docsis_tlv_tcc_err);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case TCC_ERR_SUBTYPE:
+      proto_tree_add_item (tccerr_tree,
+              hf_docsis_tcc_err_subtype, tvb,
+                  pos, length, FALSE);
+         break;
+       case TCC_ERR_CODE:
+         if (length == 1)
+           {
+             proto_tree_add_item (tccerr_tree,
+                                  hf_docsis_tcc_err_code, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TCC_ERR_MSG:
+      proto_tree_add_item (tccerr_tree,
+              hf_docsis_tcc_err_msg, tvb,
+                  pos, length, FALSE);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_tcc_rng_parms(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rngparm_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Ranging Parameters (Length = %u)", len);
+  rngparm_tree = proto_item_add_subtree (it, ett_docsis_tlv_tcc_rng_parms);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case RNG_PARMS_US_CH_ID:
+         if (length == 1)
+           {
+             proto_tree_add_item (rngparm_tree,
+                                  hf_docsis_rng_parms_us_ch_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RNG_PARMS_TIME_OFF_INT:
+         if (length == 4)
+           {
+             proto_tree_add_item (rngparm_tree,
+                                  hf_docsis_rng_parms_time_off_int, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RNG_PARMS_TIME_OFF_FRAC:
+         if (length == 1)
+           {
+             proto_tree_add_item (rngparm_tree,
+                                  hf_docsis_rng_parms_time_off_frac, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RNG_PARMS_POWER_OFF:
+         if (length == 1)
+           {
+             proto_tree_add_item (rngparm_tree,
+                                  hf_docsis_rng_parms_power_off, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RNG_PARMS_FREQ_OFF:
+         if (length == 1)
+           {
+             proto_tree_add_item (rngparm_tree,
+                                  hf_docsis_rng_parms_freq_off, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_sid_cl_so_crit(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *crit_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "SID Cluster Switchover Criteria (Length = %u)", len);
+  crit_tree = proto_item_add_subtree (it, ett_docsis_tlv_sid_cl_so);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case SID_CL_SO_MAX_REQ:
+         if (length == 1)
+           {
+             proto_tree_add_item (crit_tree,
+                                  hf_docsis_sid_cl_so_max_req, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_SO_MAX_OUT_BYTES:
+         if (length == 4)
+           {
+             proto_tree_add_item (crit_tree,
+                                  hf_docsis_sid_cl_so_max_out_bytes, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_SO_MAX_REQ_BYTES:
+         if (length == 4)
+           {
+             proto_tree_add_item (crit_tree,
+                                  hf_docsis_sid_cl_so_max_req_bytes, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_SO_MAX_TIME:
+         if (length == 2)
+           {
+             proto_tree_add_item (crit_tree,
+                                  hf_docsis_sid_cl_so_max_time, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_sid_cl_enc_map(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *map_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "SID-to-Channel Mapping (Length = %u)", len);
+  map_tree = proto_item_add_subtree (it, ett_docsis_tlv_sid_cl_enc_map);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case SID_CL_MAP_US_CH_ID:
+         if (length == 1)
+           {
+             proto_tree_add_item (map_tree,
+                                  hf_docsis_sid_cl_map_us_ch_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_MAP_SID:
+         if (length == 2)
+           {
+             proto_tree_add_item (map_tree,
+                                  hf_docsis_sid_cl_map_sid, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_MAP_ACTION:
+         if (length == 1)
+           {
+             proto_tree_add_item (map_tree,
+                                  hf_docsis_sid_cl_map_action, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_sid_cl_enc(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *enc_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "SID Cluster Encoding (Length = %u)", len);
+  enc_tree = proto_item_add_subtree (it, ett_docsis_tlv_sid_cl_enc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case SID_CL_ENC_ID:
+         if (length == 1)
+           {
+             proto_tree_add_item (enc_tree,
+                                  hf_docsis_sid_cl_enc_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_ENC_MAP:
+         if (length == 10)
+            dissect_sid_cl_enc_map(tvb, enc_tree, pos, length);
+         else
+             THROW (ReportedBoundsError);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_sid_cl(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *sid_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "47 Service Flow SID Cluster Assignments (Length = %u)", len);
+  sid_tree = proto_item_add_subtree (it, ett_docsis_tlv_sid_cl);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case SID_CL_SF_ID:
+         if (length == 4)
+           {
+             proto_tree_add_item (sid_tree,
+                                  hf_docsis_sid_cl_sf_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case SID_CL_ENC:
+         dissect_sid_cl_enc(tvb, sid_tree, pos, length);
+         break;
+    case SID_CL_SO_CRIT:
+         dissect_sid_cl_so_crit(tvb, sid_tree, pos, length);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_tcc(tvbuff_t * tvb, packet_info * pinfo _U_, 
+                   proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *tcc_tree;
+  int pos = start;
+  tvbuff_t *ucd_tvb;
+
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "46 Transmit Channel Configuration (Length = %u)", len);
+  tcc_tree = proto_item_add_subtree (it, ett_docsis_tlv_tcc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case TLV_TCC_REFID:
+         if (length == 1)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_refid, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_US_CH_ACTION:
+         if (length == 1)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_us_ch_action, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_US_CH_ID:
+         if (length == 1)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_us_ch_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_NEW_US_CH_ID:
+         if (length == 1)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_new_us_ch_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_UCD:
+         ucd_tvb = tvb_new_subset (tvb, pos, length, length);
+         call_dissector (docsis_ucd_handle, ucd_tvb, pinfo, tcc_tree);
+         break;
+       case TLV_TCC_RNG_SID:
+         if (length == 2)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_rng_sid, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_INIT_TECH:
+         if (length == 1)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_init_tech, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_RNG_PARMS:
+         dissect_tcc_rng_parms(tvb, tcc_tree, pos, length);
+         break;
+       case TLV_TCC_DYN_RNG_WIN:
+         if (length == 1)
+           {
+             proto_tree_add_item (tcc_tree,
+                                  hf_docsis_tlv_tcc_dyn_rng_win, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_TCC_ERR:
+         dissect_tcc_err(tvb, tcc_tree, pos, length);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_ch_bl_rng(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *chblrng_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Receive Module Channel Block Range (Length = %u)", len);
+  chblrng_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcp_ch_bl_rng);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case CH_BL_RNG_MIN_CTR_FREQ:
+         if (length == 4)
+           {
+             proto_tree_add_item (chblrng_tree,
+                                  hf_docsis_ch_bl_rng_min_ctr_freq, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case CH_BL_RNG_MAX_CTR_FREQ:
+         if (length == 4)
+           {
+             proto_tree_add_item (chblrng_tree,
+                                  hf_docsis_ch_bl_rng_max_ctr_freq, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_rcp_rcv_mod(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rcvmod_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Receive Module Capability (Length = %u)", len);
+  rcvmod_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcp_rcv_mod_enc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case RCV_MOD_ENC_IDX:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvmod_tree,
+                                  hf_docsis_rcv_mod_enc_idx, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCV_MOD_ENC_CH_BL_RNG:
+         dissect_ch_bl_rng(tvb, rcvmod_tree, pos, length);
+         break;
+       case RCV_MOD_ENC_CTR_FREQ_ASGN:
+         if (length == 4)
+           {
+             proto_tree_add_item (rcvmod_tree,
+                                  hf_docsis_rcv_mod_enc_ctr_freq_asgn, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RCV_MOD_ENC_RSQ_CH_SUBS_CAP:
+         proto_tree_add_item (rcvmod_tree,
+                  hf_docsis_rcv_mod_enc_rsq_ch_subs_cap, tvb, pos,
+                  length, FALSE);
+         break;
+       case RCV_MOD_ENC_CONN:
+         proto_tree_add_item (rcvmod_tree,
+                  hf_docsis_rcv_mod_enc_conn, tvb, pos,
+                  length, FALSE);
+         break;
+       case RCV_MOD_ENC_PHY_LAYR_PARMS:
+         proto_tree_add_item (rcvmod_tree,
+                  hf_docsis_rcv_mod_enc_phy_layr_parms, tvb, pos,
+                  length, FALSE);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_rcp_rcv_ch(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rcvch_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Receive Channels (Length = %u)", len);
+  rcvch_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcp_rcv_ch);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case RCV_CH_IDX:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvch_tree,
+                                  hf_docsis_rcv_ch_idx, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCV_CH_CONN:
+         proto_tree_add_item (rcvch_tree,
+                          hf_docsis_rcv_ch_conn, tvb, pos,
+                          length, FALSE);
+         break;
+    case RCV_CH_CONN_OFF:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvch_tree,
+                                  hf_docsis_rcv_ch_conn_off, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCV_CH_PRIM_DS_CH_IND:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvch_tree,
+                                  hf_docsis_rcv_ch_prim_ds_ch_ind, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+
+static void
+dissect_rcp(tvbuff_t * tvb, packet_info * pinfo _U_, 
+                       proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rcp_tree;
+  int pos = start;
+  tvbuff_t *vsif_tvb;
+
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                         "48 Receive Channel Profile (Length = %u)", len);
+  rcp_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcp);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case TLV_RCP_ID:
+         if (length == 5)
+           {
+             proto_tree_add_item (rcp_tree,
+                                  hf_docsis_tlv_rcp_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_RCP_NAME:
+         if (length <= 15)
+           {
+             proto_tree_add_item (rcp_tree,
+                                  hf_docsis_tlv_rcp_name, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_RCP_FREQ_SPC:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcp_tree,
+                                  hf_docsis_tlv_rcp_freq_spc, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_RCP_RCV_MOD_ENC:
+         dissect_rcp_rcv_mod(tvb, rcp_tree, pos, length);
+         break;
+       case TLV_RCP_RCV_CH:
+         dissect_rcp_rcv_ch(tvb, rcp_tree, pos, length);
+         break;
+       case TLV_RCP_VEN_SPEC:
+         vsif_tvb = tvb_new_subset (tvb, pos, length, length);
+         call_dissector (docsis_vsif_handle, vsif_tvb, pinfo, rcp_tree);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_rcc_rcv_mod(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rcvmod_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Receive Module Assignment (Length = %u)", len);
+  rcvmod_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcc_rcv_mod_enc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case RCV_MOD_ENC_IDX:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvmod_tree,
+                                  hf_docsis_rcc_rcv_mod_enc_idx, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RCV_MOD_ENC_CTR_FREQ_ASGN:
+         if (length == 4)
+           {
+             proto_tree_add_item (rcvmod_tree,
+                                  hf_docsis_rcc_rcv_mod_enc_ctr_freq_asgn, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case RCV_MOD_ENC_CONN:
+         proto_tree_add_item (rcvmod_tree,
+                  hf_docsis_rcc_rcv_mod_enc_conn, tvb, pos,
+                  length, FALSE);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_rcc_rcv_ch(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rcvch_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Receive Channels (Length = %u)", len);
+  rcvch_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcc_rcv_ch);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case RCV_CH_IDX:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvch_tree,
+                                  hf_docsis_rcc_rcv_ch_idx, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCV_CH_CONN:
+         proto_tree_add_item (rcvch_tree,
+                          hf_docsis_rcc_rcv_ch_conn, tvb, pos,
+                          length, FALSE);
+         break;
+    case RCV_CH_CTR_FREQ_ASGN:
+         if (length == 4)
+           {
+             proto_tree_add_item (rcvch_tree,
+                                  hf_docsis_rcc_rcv_ch_ctr_freq_asgn, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCV_CH_PRIM_DS_CH_IND:
+         if (length == 1)
+           {
+             proto_tree_add_item (rcvch_tree,
+                                  hf_docsis_rcc_rcv_ch_prim_ds_ch_ind, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_rcc_err(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *err_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "RCC Error Encodings (Length = %u)", len);
+  err_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcc_rcv_ch);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case RCC_ERR_MOD_OR_CH:
+         if (length == 1)
+           {
+             proto_tree_add_item (err_tree,
+                                  hf_docsis_tlv_rcc_err_mod_or_ch, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCC_ERR_IDX:
+         if (length == 1)
+           {
+             proto_tree_add_item (err_tree,
+                                  hf_docsis_tlv_rcc_err_idx, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCC_ERR_PARAM:
+         if (length == 1)
+           {
+             proto_tree_add_item (err_tree,
+                                  hf_docsis_tlv_rcc_err_param, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCC_ERR_CODE:
+         if (length == 1)
+           {
+             proto_tree_add_item (err_tree,
+                                  hf_docsis_tlv_rcc_err_code, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case RCC_ERR_MSG:
+      proto_tree_add_item (err_tree,
+                          hf_docsis_tlv_rcc_err_msg, tvb, pos,
+                          length, FALSE);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_rcc(tvbuff_t * tvb, packet_info * pinfo _U_, 
+                       proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *rcc_tree;
+  int pos = start;
+  tvbuff_t *vsif_tvb;
+
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                         "49 Receive Channel Configuration (Length = %u)", len);
+  rcc_tree = proto_item_add_subtree (it, ett_docsis_tlv_rcc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+       case TLV_RCP_ID:
+         if (length == 5)
+           {
+             proto_tree_add_item (rcc_tree,
+                                  hf_docsis_tlv_rcc_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case TLV_RCP_RCV_MOD_ENC:
+         dissect_rcc_rcv_mod(tvb, rcc_tree, pos, length);
+         break;
+       case TLV_RCP_RCV_CH:
+         dissect_rcc_rcv_ch(tvb, rcc_tree, pos, length);
+         break;
+       case TLV_RCP_VEN_SPEC:
+         vsif_tvb = tvb_new_subset (tvb, pos, length, length);
+         call_dissector (docsis_vsif_handle, vsif_tvb, pinfo, rcc_tree);
+         break;
+       case TLV_RCC_ERR:
+         dissect_rcc_err(tvb, rcc_tree, pos, length);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_dsid_ds_reseq(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *dsid_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Resequencing DSID (Length = %u)", len);
+  dsid_tree = proto_item_add_subtree (it, ett_docsis_tlv_dsid_ds_reseq);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case DS_RESEQ_DSID:
+         if (length == 1)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_ds_reseq_dsid, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case DS_RESEQ_CH_LST:
+         proto_tree_add_item (dsid_tree,
+                          hf_docsis_ds_reseq_ch_lst, tvb, pos,
+                          length, FALSE);
+         break;
+    case DS_RESEQ_WAIT_TIME:
+         if (length == 1)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_ds_reseq_wait_time, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case DS_RESEQ_WARN_THRESH:
+         if (length == 1)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_ds_reseq_warn_thresh, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case DS_RESEQ_HO_TIMER:
+         if (length == 2)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_ds_reseq_ho_timer, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_dsid_mc_addr(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *dsid_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Client MAC Address Encodings (Length = %u)", len);
+  dsid_tree = proto_item_add_subtree (it, ett_docsis_tlv_dsid_mc_addr);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case MC_ADDR_ACTION:
+         if (length == 1)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_mc_addr_action, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       case MC_ADDR_ADDR:
+         if (length == 6)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_mc_addr_addr, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_dsid_mc(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *dsid_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "Multicast Encodings (Length = %u)", len);
+  dsid_tree = proto_item_add_subtree (it, ett_docsis_tlv_dsid_mc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case TLV_DSID_MC_ADDR:
+         dissect_dsid_mc_addr(tvb, dsid_tree, pos, length);
+         break;
+    case TLV_DSID_MC_CMIM:
+         proto_tree_add_item (dsid_tree,
+                          hf_docsis_tlv_dsid_mc_cmim, tvb, pos,
+                          length, FALSE);
+         break;
+    case TLV_DSID_MC_GROUP:
+         proto_tree_add_item (dsid_tree,
+                          hf_docsis_tlv_dsid_mc_group, tvb, pos,
+                          length, FALSE);
+         break;
+    case TLV_DSID_MC_PHS:
+         dissect_phs(tvb, dsid_tree, pos, length);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_dsid(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *dsid_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "50 DSID Encodings (Length = %u)", len);
+  dsid_tree = proto_item_add_subtree (it, ett_docsis_tlv_dsid);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case TLV_DSID_ID:
+         if (length == 3)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_tlv_dsid_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case TLV_DSID_ACTION:
+         if (length == 1)
+           {
+             proto_tree_add_item (dsid_tree,
+                                  hf_docsis_tlv_dsid_action, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case TLV_DSID_DS_RESEQ:
+         dissect_dsid_ds_reseq(tvb, dsid_tree, pos, length);
+         break;
+    case TLV_DSID_MC:
+         dissect_dsid_mc(tvb, dsid_tree, pos, length);
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_sec_assoc(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *sec_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "51 Security Association Encodings (Length = %u)", len);
+  sec_tree = proto_item_add_subtree (it, ett_docsis_tlv_dsid);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case TLV_SEC_ASSOC_ACTION:
+         if (length == 1)
+           {
+             proto_tree_add_item (sec_tree,
+                                  hf_docsis_tlv_sec_assoc_action, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case TLV_SEC_ASSOC_DESC:
+         if (length == 14)
+           {
+             proto_tree_add_item (sec_tree,
+                                  hf_docsis_tlv_sec_assoc_desc, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_ch_asgn(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *asgn_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "56 Channel Assignment Configuration Settings (Length = %u)", len);
+  asgn_tree = proto_item_add_subtree (it, ett_docsis_tlv_ch_asgn);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case TLV_CH_ASGN_US_CH_ID:
+         if (length == 1)
+           {
+             proto_tree_add_item (asgn_tree,
+                                  hf_docsis_ch_asgn_us_ch_id, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case TLV_CH_ASGN_RX_FREQ:
+         if (length == 4)
+           {
+             proto_tree_add_item (asgn_tree,
+                                  hf_docsis_ch_asgn_rx_freq, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+static void
+dissect_cmts_mc_sess_enc(tvbuff_t * tvb, proto_tree *tree, int start, guint16 len) 
+{
+  guint8 type, length;
+  proto_item *it;
+  proto_tree *mc_tree;
+  int pos = start;
+  it =
+    proto_tree_add_text (tree, tvb, start, len,
+                        "64 CMTS Static Multicast Session Encoding (Length = %u)", len);
+  mc_tree = proto_item_add_subtree (it, ett_docsis_cmts_mc_sess_enc);
+
+  while (pos < (start + len))
+    {
+      type = tvb_get_guint8 (tvb, pos++);
+      length = tvb_get_guint8 (tvb, pos++);
+      switch (type)
+       {
+    case CMTS_MC_SESS_ENC_GRP:
+         if (length == 4 || length == 16)
+           {
+             proto_tree_add_item (mc_tree,
+                                  hf_docsis_cmts_mc_sess_enc_grp, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+    case CMTS_MC_SESS_ENC_SRC:
+         if (length == 4 || length == 16)
+           {
+             proto_tree_add_item (mc_tree,
+                                  hf_docsis_cmts_mc_sess_enc_src, tvb, pos,
+                                  length, FALSE);
+           }
+         else
+           {
+             THROW (ReportedBoundsError);
+           }
+         break;
+       }                       /* switch */
+      pos = pos + length;
+    }                          /* while */
+}
+
+
+static void
+dissect_tlv (tvbuff_t * tvb, packet_info * pinfo _U_, proto_tree * tree)
+{
+
+  proto_item *it;
+  proto_tree *tlv_tree;
+  int pos = 0;
+  gint total_len;
+  guint8 type, length;
+  guint16 x;
+  tvbuff_t *vsif_tvb;
+
+  total_len = tvb_reported_length_remaining (tvb, 0);
+
+    {
+      it =
+       proto_tree_add_protocol_format (tree, proto_docsis_tlv, tvb, 0,
+                                       total_len, "TLV Data");
+      tlv_tree = proto_item_add_subtree (it, ett_docsis_tlv);
+      while (pos < total_len)
+       {
+         type = tvb_get_guint8 (tvb, pos++);
+         length = tvb_get_guint8 (tvb, pos++);
+         switch (type)
+           {
+           case TLV_DOWN_FREQ:
+             /* This is ugly.  There are multiple type 1 TLV's that may appear
+              * in the TLV data, the problem is that they are dependent on
+              * message type.  */
+             if (length == 4)
+               proto_tree_add_item (tlv_tree, hf_docsis_tlv_down_freq, tvb,
+                                    pos, length, FALSE);
+             else if (length == 1)
+               proto_tree_add_item (tlv_tree, hf_docsis_tlv_rng_tech, tvb,
+                                    pos, length, FALSE);
+             else
+               dissect_doc10cos (tvb, tlv_tree, pos, length);
+             break;
+           case TLV_CHNL_ID:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_upstream_chid,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case TLV_NET_ACCESS:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_net_access,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case TLV_COS:
+             dissect_cos (tvb, tlv_tree, pos, length);
+             break;
+           case TLV_MODEM_CAP:
+             dissect_modemcap (tvb, tlv_tree, pos, length);
+             break;
+           case TLV_CM_MIC:
+             if (length == 16)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_cm_mic, tvb,
+                                      pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case TLV_CMTS_MIC:
+             if (length == 16)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_cmts_mic, tvb,
+                                      pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case TLV_VENDOR_ID:
+             if (length == 3)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_vendor_id, tvb,
+                                      pos, length, FALSE);
+               }
+             else
+               {
                  THROW (ReportedBoundsError);
                }
              break;
@@ -2053,15 +3802,150 @@ dissect_tlv (tvbuff_t * tvb, packet_info * pinfo _U_, proto_tree * tree)
                  THROW (ReportedBoundsError);
                }
              break;
-           case TLV_SUBS_MGMT_FLTR:
-             proto_tree_add_item (tlv_tree,
-                                  hf_docsis_tlv_subs_mgmt_filter_grps,
-                                  tvb, pos, length, FALSE);
-             break;
-           case TLV_VENDOR_SPEC:
-             vsif_tvb = tvb_new_subset (tvb, pos, length, length);
-             call_dissector (docsis_vsif_handle, vsif_tvb, pinfo, tlv_tree);
+           case TLV_SUBS_MGMT_FLTR:
+             proto_tree_add_item (tlv_tree,
+                                  hf_docsis_tlv_subs_mgmt_filter_grps,
+                                  tvb, pos, length, FALSE);
+             break;
+               case TLV_SNMPV3_NTFY_RCVR:
+                 proto_tree_add_item(tlv_tree,
+                                 hf_docsis_tlv_snmpv3_ntfy_rcvr,
+                                 tvb, pos, length, FALSE);
+                 break;
+           case TLV_ENABLE_20_MODE:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_enable_20_mode,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case TLV_ENABLE_TEST_MODES:
+             if (length == 1)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_enable_test_modes,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+               case TLV_DS_CH_LIST:
+                 dissect_ds_ch_list(tvb, tlv_tree, pos, length);
+                 break;
+               case TLV_MC_MAC_ADDRESS:
+             if (length == 6)
+             {
+                   proto_tree_add_item(tlv_tree, hf_docsis_tlv_mc_mac_address,
+                                 tvb, pos, length, FALSE);
+             }
+             else
+             {
+               THROW (ReportedBoundsError);
+             }
+                 break;
+           case TLV_VENDOR_SPEC:
+             vsif_tvb = tvb_new_subset (tvb, pos, length, length);
+             call_dissector (docsis_vsif_handle, vsif_tvb, pinfo, tlv_tree);
+             break;
+               case TLV_DUT_FILTER:
+                 dissect_dut_filter(tvb, tlv_tree, pos, length);
+                 break;
+               case TLV_TCC:
+                 dissect_tcc(tvb, pinfo, tlv_tree, pos, length);
+                 break;
+               case TLV_SID_CL:
+                 dissect_sid_cl(tvb, tlv_tree, pos, length);
+                 break;
+               case TLV_RCP:
+                 dissect_rcp(tvb, pinfo, tlv_tree, pos, length);
+                 break;
+               case TLV_RCC:
+                 dissect_rcc(tvb, pinfo, tlv_tree, pos, length);
+                 break;
+               case TLV_DSID:
+                 dissect_dsid(tvb, tlv_tree, pos, length);
+                 break;
+               case TLV_SEC_ASSOC:
+                 dissect_sec_assoc(tvb, tlv_tree, pos, length);
+                 break;
+               case TLV_INIT_CH_TIMEOUT:
+             if (length == 2)
+             {
+                   proto_tree_add_item(tlv_tree, hf_docsis_tlv_init_ch_timeout,
+                                 tvb, pos, length, FALSE);
+             }
+             else
+             {
+               THROW (ReportedBoundsError);
+             }
+                 break;
+               case TLV_CH_ASGN:
+                 dissect_ch_asgn(tvb, tlv_tree, pos, length);
+                 break;
+               case TLV_CM_INIT_REASON:
+             if (length == 1)
+             {
+                   proto_tree_add_item(tlv_tree, hf_docsis_tlv_cm_init_reason,
+                                 tvb, pos, length, FALSE);
+             }
+             else
+             {
+               THROW (ReportedBoundsError);
+             }
+                 break;
+           case TLV_SW_UPG_SRVR_IPV6:
+             if (length == 16)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_sw_upg_srvr_ipv6,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+             break;
+           case TLV_TFTP_PROV_CM_IPV6_ADDR:
+             if (length == 16)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_tftp_prov_cm_ipv6_addr,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
              break;
+               case TLV_US_DROP_CLFY:
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_us_drop_clfy,
+                                      tvb, pos, length, FALSE);
+                 break;
+               case TLV_SUBS_MGMT_IPV6_LST:
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_subs_mgmt_ipv6_lst,
+                                      tvb, pos, length, FALSE);
+                 break;
+               case TLV_US_DROP_CLFY_GROUP_ID:
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_us_drop_clfy_group_id,
+                                      tvb, pos, length, FALSE);
+                 break;
+               case TLV_SUBS_MGMT_CTRL_MAX_CPE_IPV6:
+             if (length == 2)
+               {
+                 proto_tree_add_item (tlv_tree, hf_docsis_tlv_subs_mgmt_ctrl_max_cpe_ipv6,
+                                      tvb, pos, length, FALSE);
+               }
+             else
+               {
+                 THROW (ReportedBoundsError);
+               }
+                 break;
+               case TLV_CMTS_MC_SESS_ENC:
+                 dissect_cmts_mc_sess_enc(tvb, tlv_tree, pos, length);
+                 break;
            case TLV_END:
              break;
            }                   /* switch(type) */
@@ -2781,6 +4665,76 @@ proto_register_docsis_tlv (void)
       FT_BYTES, BASE_NONE, NULL, 0x0,
       "Subscriber Management Filter Groups", HFILL}
      },
+    {&hf_docsis_tlv_snmpv3_ntfy_rcvr,
+     {"38 SNMPv3 Notification Receiver", "docsis_tlv.snmpv3ntfy",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "SNMPv3 Notification Receiver", HFILL}
+     },
+    {&hf_docsis_tlv_enable_20_mode,
+     {"39 Enable 2.0 Mode", "docsis_tlv.enable20mode",
+      FT_BOOLEAN, BASE_NONE, TFS (&ena_dis_tfs), 0x0,
+      "Enable 2.0 Mode", HFILL}
+     },
+    {&hf_docsis_tlv_enable_test_modes,
+     {"40 Enable Test Modes", "docsis_tlv.enabletestmodes",
+      FT_BOOLEAN, BASE_NONE, TFS (&ena_dis_tfs), 0x0,
+      "Enable Test Modes", HFILL}
+     },
+    {&hf_docsis_tlv_ds_ch_list,
+     {"41 Downstream Channel List", "docsis_tlv.dschlist",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_tlv_ds_ch_list_single,
+     {".1 Single Downstream Channel", "docsis_tlv.dschlist.single",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_tlv_single_ch_timeout,
+     {"..1 Timeout", "docsis_tlv.dschlist.single.timeout",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Timeout", HFILL}
+     },
+    {&hf_docsis_tlv_single_ch_freq,
+     {"..2 Timeout", "docsis_tlv.dschlist.single.freq",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Timeout", HFILL}
+     },
+    {&hf_docsis_tlv_ds_ch_list_range,
+     {".2 Downstream Frequency Range", "docsis_tlv.dschlist.range",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      NULL, HFILL}
+     },
+    {&hf_docsis_tlv_freq_rng_timeout,
+     {"..1 Timeout", "docsis_tlv.dschlist.range.timeout",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Timeout", HFILL}
+     },
+    {&hf_docsis_tlv_freq_rng_start,
+     {"..2 Frequency Start", "docsis_tlv.dschlist.range.start",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Frequency Start", HFILL}
+     },
+    {&hf_docsis_tlv_freq_rng_end,
+     {"..3 Frequency Start", "docsis_tlv.dschlist.range.end",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Frequency End", HFILL}
+     },
+    {&hf_docsis_tlv_freq_rng_step,
+     {"..4 Frequency Step Size", "docsis_tlv.dschlist.range.step",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Frequency Step Size", HFILL}
+     },
+    {&hf_docsis_tlv_ds_ch_list_default_timeout,
+     {".3 Default Scanning Timeout", "docsis_tlv.dschlist.defaulttimeout",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Default Scanning Timeout", HFILL}
+     },
+    {&hf_docsis_tlv_mc_mac_address,
+     {"42 Static Multicast MAC Address", "docsis_tlv.mcmac",
+      FT_ETHER, BASE_NONE, NULL, 0x0,
+      "Static Multicast MAC Address", HFILL}
+     },
     {&hf_docsis_tlv_vendor_spec,
      {"43 Vendor Specific Encodings", "docsis_tlv.vendorspec",
       FT_BYTES, BASE_NONE, NULL, 0x0,
@@ -2791,6 +4745,601 @@ proto_register_docsis_tlv (void)
       FT_UINT8, BASE_DEC, VALS (rng_tech_vals), 0x0,
       NULL, HFILL}
      },
+    {&hf_docsis_tlv_dut_filter,
+     {"45 Downstream Unencrypted Traffic Filtering Encoding", 
+               "docsis_tlv.dut",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Downstream Unencrypted Traffic Filtering Encoding", HFILL}
+     },
+    {&hf_docsis_tlv_dut_filter_control,
+     {".1 DUT Control", "docsis_tlv.dut.control",
+      FT_BOOLEAN, BASE_NONE, TFS (&ena_dis_tfs), 0x0,
+      "DUT Control", HFILL}
+     },
+    {&hf_docsis_tlv_dut_filter_cmim,
+     {".2 DUT CMIM", "docsis_tlv.dut.cmim",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "DUT CMIM", HFILL}
+     },
+    {&hf_docsis_tlv_tcc,
+     {"46 Transmit Channel Configuration", 
+               "docsis_tlv.tcc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Transmit Channel Configuration", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_refid,
+     {".1 TCC Reference ID", "docsis_tlv.tcc.refid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "TCC Reference ID", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_us_ch_action,
+     {".2 Upstream Channel Action", "docsis_tlv.tcc.uschact",
+      FT_UINT8, BASE_DEC, VALS (us_ch_action_vals), 0x0,
+      "Upstream Channel Action", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_us_ch_id,
+     {".3 Upstream Channel ID", "docsis_tlv.tcc.uschid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Upstream Channel ID", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_new_us_ch_id,
+     {".4 New Upstream Channel ID", "docsis_tlv.tcc.newuschid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "New Upstream Channel ID", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_ucd,
+     {".5 Upstream Channel Decsriptor", "docsis_tlv.tcc.ucd",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Upstream Channel Descriptor", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_rng_sid,
+     {".6 Ranging SID", "docsis_tlv.tcc.rngsid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Ranging SID", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_init_tech,
+     {".7 Initialization Technique", "docsis_tlv.tcc.inittech",
+      FT_UINT8, BASE_DEC, VALS (init_tech_vals), 0x0,
+      "Initialization Technique", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_rng_parms,
+     {".8 Ranging Parameters", "docsis_tlv.tcc.rngparms",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Ranging Parameters", HFILL}
+     },
+    {&hf_docsis_rng_parms_us_ch_id,
+     {"..1 Ranging Reference Channel ID", "docsis_tlv.tcc.rngparms.uschid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Upstream Channel ID", HFILL}
+     },
+    {&hf_docsis_rng_parms_time_off_int,
+     {"..2 Timing Offset, Integer Part", "docsis_tlv.tcc.rngparms.timeoffint",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Timing Offset, Integer Part", HFILL}
+     },
+    {&hf_docsis_rng_parms_time_off_frac,
+     {"..3 Timing Offset, Fractional Part", "docsis_tlv.tcc.rngparms.timeofffrac",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Timing Offset, Fractional Part", HFILL}
+     },
+    {&hf_docsis_rng_parms_power_off,
+     {"..4 Power Offset", "docsis_tlv.tcc.rngparms.poweroff",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Power Offset", HFILL}
+     },
+    {&hf_docsis_rng_parms_freq_off,
+     {"..5 Frequency Offset", "docsis_tlv.tcc.rngparms.freqoff",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Frequency Offset", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_dyn_rng_win,
+     {".9 Dynamic Range Window", "docsis_tlv.tcc.dynrngwin",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Dynamic Range Window", HFILL}
+     },
+    {&hf_docsis_tlv_tcc_err,
+     {".10 TCC Error Encodings", "docsis_tlv.tcc.err",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "TCC Error Encodings", HFILL}
+     },
+    {&hf_docsis_tcc_err_subtype,
+     {"..1 TCC Subtype", "docsis_tlv.tcc.err.subtype",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "TCC Subtype", HFILL}
+     },
+    {&hf_docsis_tcc_err_code,
+     {"..2 Error Code", "docsis_tlv.tcc.err.code",
+      FT_UINT8, BASE_DEC, VALS(docsis_conf_code), 0x0,
+      "Error Code", HFILL}
+     },
+    {&hf_docsis_tcc_err_msg,
+     {"..3 Error Message", "docsis_tlv.tcc.err.msg",
+      FT_STRINGZ, BASE_NONE, NULL, 0x0,
+      "Error Message", HFILL}
+     },
+    {&hf_docsis_tlv_sid_cl,
+     {"47 Service Flow SID Cluster Assignments", 
+               "docsis_tlv.sid",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Service Flow SID Cluster Assignments", HFILL}
+     },
+    {&hf_docsis_sid_cl_sf_id,
+     {".1 Service Flow ID", "docsis_tlv.sid.sfid",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Upstream Channel ID", HFILL}
+     },
+    {&hf_docsis_sid_cl_enc,
+     {".2 SID Cluster Encodings", 
+               "docsis_tlv.sid.enc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "SID Cluster Encodings", HFILL}
+     },
+    {&hf_docsis_sid_cl_enc_id,
+     {"..1 SID Cluster ID", 
+               "docsis_tlv.sid.enc.id",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "SID Cluster ID", HFILL}
+     },
+    {&hf_docsis_sid_cl_enc_map,
+     {"..2 SID-to-Channel Mapping", 
+               "docsis_tlv.sid.enc.map",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "SID Cluster ID", HFILL}
+     },
+    {&hf_docsis_sid_cl_map_us_ch_id,
+     {"...1 Upstraem Channel ID", 
+               "docsis_tlv.sid.enc.map.uschid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Upstream Channel ID", HFILL}
+     },
+    {&hf_docsis_sid_cl_map_sid,
+     {"...2 SID", 
+               "docsis_tlv.sid.enc.map.sid",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "SID", HFILL}
+     },
+    {&hf_docsis_sid_cl_map_action,
+     {"...3 SID-to-Channel Mapping Action", 
+               "docsis_tlv.sid.enc.map.action",
+      FT_UINT8, BASE_DEC, VALS (sid_ch_map_vals), 0x0,
+      "SID-to-Channel Mapping Action", HFILL}
+     },
+    {&hf_docsis_sid_cl_so_crit,
+     {".3 SID Cluster Switchover Criteria", 
+               "docsis_tlv.sid.socrit",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "SID Cluster Switchover Criteria", HFILL}
+     },
+    {&hf_docsis_sid_cl_so_max_req,
+     {"..1 Maximum Requests per SID Cluster", 
+               "docsis_tlv.sid.socrit.maxreq",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Maximum Requests per SID Cluster", HFILL}
+     },
+    {&hf_docsis_sid_cl_so_max_out_bytes,
+     {"..2 Maximum Outstanding Bytes per SID Cluster", 
+               "docsis_tlv.sid.socrit.maxoutbytes",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Maximum Outstanding Bytes per SID Cluster", HFILL}
+     },
+    {&hf_docsis_sid_cl_so_max_req_bytes,
+     {"..3 Maximum Total Bytes Requested per SID Cluster", 
+               "docsis_tlv.sid.socrit.maxreqbytes",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Maximum Total Bytes Requested per SID Cluster", HFILL}
+     },
+    {&hf_docsis_sid_cl_so_max_time,
+     {"..4 Maximum Time in the SID Cluster", 
+               "docsis_tlv.sid.socrit.maxtime",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Maximum Time in the SID Cluster", HFILL}
+     },
+    {&hf_docsis_tlv_rcp,
+     {"48 Receive Channel Profile", 
+               "docsis_tlv.rcp",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Channel Profile", HFILL}
+     },
+    {&hf_docsis_tlv_rcp_id,
+     {".1 RCP-ID", "docsis_tlv.rcp.id",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "RCP-ID", HFILL}
+     },
+    {&hf_docsis_tlv_rcp_name,
+     {".2 RCP Name", "docsis_tlv.rcp.name",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "RCP Name", HFILL}
+     },
+    {&hf_docsis_tlv_rcp_freq_spc,
+     {".3 RCP Center Frequency Spacing", "docsis_tlv.rcp.freq_spc",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "RCP Center Frequency Spacing", HFILL}
+     },
+    {&hf_docsis_tlv_rcp_rcv_mod_enc,
+     {".4 Receive Module Capability", "docsis_tlv.rcp.rcv_mod_enc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Module Encoding", HFILL}
+     },
+    {&hf_docsis_rcv_mod_enc_idx,
+     {"..1 Receive Module Index", "docsis_tlv.rcp.rcv_mod_enc.idx",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Receive Module Index", HFILL}
+     },
+    {&hf_docsis_rcv_mod_enc_adj_ch,
+     {"..2 Adjacent Channels", "docsis_tlv.rcp.rcv_mod_enc.adj_ch",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Adjacent Channels", HFILL}
+     },
+    {&hf_docsis_rcv_mod_enc_ch_bl_rng,
+     {"..3 Channel Block Range", "docsis_tlv.rcp.rcv_mod_enc.ch_bl_rng",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Channel Block Range", HFILL}
+     },
+    {&hf_docsis_ch_bl_rng_min_ctr_freq,
+     {"...1 Minimum Center Frequency", 
+      "docsis_tlv.rcp.rcv_mod_enc.ch_bl_rng.min_ctr_freq",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Minimum Center Frequency", HFILL}
+     },
+    {&hf_docsis_ch_bl_rng_max_ctr_freq,
+     {"...2 Maximum Center Frequency", 
+      "docsis_tlv.rcp.rcv_mod_enc.ch_bl_rng.max_ctr_freq",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Maximum Center Frequency", HFILL}
+     },
+    {&hf_docsis_rcv_mod_enc_rsq_ch_subs_cap ,
+     {"..5 Resequencing Channel Subset Capability", 
+      "docsis_tlv.rcp.rcv_mod_enc.rsq_ch_subs_cap",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Resequencing Channel Subset Capability", HFILL}
+     },
+    {&hf_docsis_rcv_mod_enc_conn ,
+     {"..6 Receive Module Connectivity", 
+      "docsis_tlv.rcp.rcv_mod_enc.conn",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Module Connectivity", HFILL}
+     },
+    {&hf_docsis_rcv_mod_enc_phy_layr_parms,
+     {"..7 Physical Layer Parameter", 
+      "docsis_tlv.rcp.rcv_mod_enc.phy_layr_parms",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Physical Layer Parameter", HFILL}
+     },
+    {&hf_docsis_tlv_rcp_rcv_ch,
+     {".5 Receive Channel", "docsis_tlv.rcp.rcv_ch",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Channel", HFILL}
+     },
+    {&hf_docsis_rcv_ch_idx,
+     {"..1 Receive Channel Index", "docsis_tlv.rcp.rcv_ch.idx",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Receive Channel Index", HFILL}
+     },
+    {&hf_docsis_rcv_ch_conn,
+     {"..2 Receive Channel Connectivity", "docsis_tlv.rcp.rcv_ch.conn",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Channel Connectivity", HFILL}
+     },
+    {&hf_docsis_rcv_ch_conn_off,
+     {"..3 Receive Channel Connected Offset", 
+      "docsis_tlv.rcp.rcv_ch.conn_off",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Receive Channel Connected Offset", HFILL}
+     },
+    {&hf_docsis_rcv_ch_prim_ds_ch_ind,
+     {"..5 Primary Downstream Channel Indicator", 
+      "docsis_tlv.rcp.rcv_ch.prim_ds_ch_ind",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Primary Downstream Channel Indicator", HFILL}
+     },
+    {&hf_docsis_tlv_rcp_ven_spec,
+     {".43 Vendor Specific Encodings", "docsis_tlv.rcp.vendorspec",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Vendor Specific Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_rcc,
+     {"49 Receive Channel Configuration", 
+               "docsis_tlv.rcc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Channel Configuration", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_id,
+     {".1 Assigned RCP-ID", "docsis_tlv.rcc.id",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Assigned RCP-ID", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_rcv_mod_enc,
+     {".4 Receive Module Assignment", "docsis_tlv.rcc.rcv_mod_enc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Module Assignment", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_mod_enc_idx,
+     {"..1 Receive Module Index", "docsis_tlv.rcc.rcc_rcv_mod_enc.idx",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Receive Module Index", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_mod_enc_ctr_freq_asgn,
+     {"..4 First Channel Center Frequency Assignment", 
+      "docsis_tlv.rcc.rcv_mod_enc.ctr_freq_asgn",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "First Channel Center Frequency Assignment", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_mod_enc_conn ,
+     {"..6 Receive Module Connectivity", 
+      "docsis_tlv.rcc.rcv_mod_enc.conn",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Module Connectivity", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_rcv_ch,
+     {".5 Receive Channel", "docsis_tlv.rcc.rcv_ch",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Channel", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_ch_idx,
+     {"..1 Receive Channel Index", "docsis_tlv.rcc.rcv_ch.idx",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Receive Channel Index", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_ch_conn,
+     {"..2 Receive Channel Connectivity", "docsis_tlv.rcc.rcv_ch.conn",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Receive Channel Connectivity", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_ch_ctr_freq_asgn,
+     {"..4 Receive Channel Center Frequency Assignment", 
+      "docsis_tlv.rcc.rcv_ch.ctr_freq_asgn",
+      FT_UINT32, BASE_DEC, NULL, 0x0,
+      "Receive Channel Center Frequency Assignment", HFILL}
+     },
+    {&hf_docsis_rcc_rcv_ch_prim_ds_ch_ind,
+     {"..5 Primary Downstream Channel Indicator", 
+      "docsis_tlv.rcc.rcv_ch.prim_ds_ch_ind",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Primary Downstream Channel Indicator", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_part_serv_ds_ch,
+     {".6 Partial Service Downstream Channels", 
+      "docsis_tlv.rcc.part_serv_ds_ch",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Partial Service Downstream Channels", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_ven_spec,
+     {".43 Vendor Specific Encodings", "docsis_tlv.rcc.vendorspec",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Vendor Specific Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_err,
+     {".254 RCC Error Encodings", "docsis_tlv.rcc.err",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "RCC Error Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_err_mod_or_ch,
+     {".1 Receive Modul or Receive Channel", 
+      "docsis_tlv.rcc.err.mod_or_ch",
+      FT_UINT8, BASE_DEC, VALS (mod_or_ch_vals), 0x0,
+      "Receive Modul or Receive Channel", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_err_idx,
+     {".2 Receive Modul/Channel Index", 
+      "docsis_tlv.rcc.err.idx",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Receive Modul/Channel Index", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_err_param,
+     {".3 Reported Parameter", 
+      "docsis_tlv.rcc.err.param",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Reported Parameter", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_err_code,
+     {".4 Error Code", 
+      "docsis_tlv.rcc.err.code",
+      FT_UINT8, BASE_DEC, VALS (docsis_conf_code), 0x0,
+      "Error Code", HFILL}
+     },
+    {&hf_docsis_tlv_rcc_err_msg,
+     {".5 Error Message", 
+      "docsis_tlv.rcc.err.msg",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Error Message", HFILL}
+     },
+    {&hf_docsis_tlv_dsid,
+     {"50 DSID Encodings", 
+               "docsis_tlv.dsid",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "DSID Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_id,
+     {".1 Downstream Service Identifier (DSID)", 
+      "docsis_tlv.dsid.id",
+      FT_UINT24, BASE_DEC, NULL, 0x0,
+      "Downstream Service Identifier (DSID)", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_action,
+     {".2 DSID Action", 
+      "docsis_tlv.dsid.action",
+      FT_UINT8, BASE_DEC, VALS (dsid_action_vals), 0x0,
+      "DSID Action", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_ds_reseq,
+     {".3 Downstream Resequencing Encodings", 
+               "docsis_tlv.dsid.ds_reseq",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Downstream Resequencing Encodings", HFILL}
+     },
+    {&hf_docsis_ds_reseq_dsid,
+     {"..1 Resequencing DSID", 
+      "docsis_tlv.dsid.ds_reseq.dsid",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Resequencing DSID", HFILL}
+     },
+    {&hf_docsis_ds_reseq_ch_lst,
+     {"..2 Downstream Resequencing Channel List", 
+      "docsis_tlv.dsid.ds_reseq.ch_lst",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Downstream Resequencing Channel List", HFILL}
+     },
+    {&hf_docsis_ds_reseq_wait_time,
+     {"..3 Downstream Resequencing Wait Time", 
+      "docsis_tlv.dsid.ds_reseq.wait_time",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Downstream Resequencing Wait Time", HFILL}
+     },
+    {&hf_docsis_ds_reseq_warn_thresh,
+     {"..4 Resequencing Warn Threshold", 
+      "docsis_tlv.dsid.ds_reseq.warn_thresh",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Resequencing Warn Threshold", HFILL}
+     },
+    {&hf_docsis_ds_reseq_ho_timer,
+     {"..5 CM-Status max. Event Hold-Off Timer (Out-of-Range Events)", 
+      "docsis_tlv.dsid.ds_reseq.ho_timer",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "CM-Status max. Event Hold-Off Timer (Out-of-Range Events)", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_mc,
+     {".4 Multicast Encodings", 
+               "docsis_tlv.dsid.mc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Multicast Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_mc_addr,
+     {"..1 Client MAC Address Encodings",
+               "docsis_tlv.dsid.mc.addr",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Client MAC Address Encodings", HFILL}
+     },
+    {&hf_docsis_mc_addr_action,
+     {"...1 Client MAC Address Action",
+               "docsis_tlv.dsid.mc.addr.action",
+      FT_UINT8, BASE_DEC, VALS (add_del_vals), 0x0,
+      "Client MAC Address Action", HFILL}
+     },
+    {&hf_docsis_mc_addr_addr,
+     {"...2 Client MAC Address",
+               "docsis_tlv.dsid.mc.addr.addr",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Client MAC Address", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_mc_cmim,
+     {"..2 Multicast CM Interface Mask",
+               "docsis_tlv.dsid.mc.cmim",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Multicast CM Interface Mask", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_mc_group,
+     {"..3 Multicast Group MAC Addresses",
+               "docsis_tlv.dsid.mc.group",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Multicast Group MAC Addresses", HFILL}
+     },
+    {&hf_docsis_tlv_dsid_mc_phs,
+     {"..26 Payload Header Suppression Encodings",
+               "docsis_tlv.dsid.mc.phs",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Payload Header Suppression Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_sec_assoc,
+     {"51 Security Association Encodings", 
+               "docsis_tlv.sec_assoc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Security Association Encodings", HFILL}
+     },
+    {&hf_docsis_tlv_sec_assoc_action,
+     {".1 SA Action", 
+               "docsis_tlv.sec_assoc.action",
+      FT_UINT8, BASE_DEC, VALS (add_del_vals), 0x0,
+      "SA Action", HFILL}
+     },
+    {&hf_docsis_tlv_sec_assoc_desc,
+     {".23 SA Descriptor", 
+               "docsis_tlv.sec_assoc.desc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "SA Descriptor", HFILL}
+     },
+    {&hf_docsis_tlv_init_ch_timeout,
+     {"52 Intializing Channel Timeout", 
+               "docsis_tlv.init_ch_timeout",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Intializing Channel Timeout", HFILL}
+     },
+    {&hf_docsis_tlv_ch_asgn,
+     {"56 Channel Assignment Configuration Settings", 
+               "docsis_tlv.ch_asgn",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Channel Assignment Configuration Settings", HFILL}
+     },
+    {&hf_docsis_ch_asgn_us_ch_id,
+     {".1 Upstream Channel ID", 
+               "docsis_tlv.ch_asgn.us_ch_id",
+      FT_UINT8, BASE_DEC, NULL, 0x0,
+      "Upstream Channel ID", HFILL}
+     },
+    {&hf_docsis_ch_asgn_rx_freq,
+     {".2 Rx Frequency", 
+               "docsis_tlv.ch_asgn.rx_freq",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Rx Frequency", HFILL}
+     },
+    {&hf_docsis_tlv_cm_init_reason,
+     {"57 CM Initialization Reason", 
+               "docsis_tlv.cm_init_reason",
+      FT_UINT16, BASE_DEC, VALS (init_reason_vals), 0x0,
+      "CM Initialization Reason", HFILL}
+     },
+    {&hf_docsis_tlv_sw_upg_srvr_ipv6,
+     {"58 Software Upgrade Server IPv6", "docsis_tlv.sw_upg_srvr_ipv6",
+      FT_IPv6, BASE_NONE, NULL, 0x0,
+      "Software Upgrade Server IPv6", HFILL}
+     },
+    {&hf_docsis_tlv_tftp_prov_cm_ipv6_addr,
+     {"59 TFTP Server Provisioned Modem IPv6 Address", 
+      "docsis_tlv.tftp_prov_cm_ipv6_addr",
+      FT_IPv6, BASE_NONE, NULL, 0x0,
+      "TFTP Server Provisioned Modem IPv6 Address", HFILL}
+     },
+    {&hf_docsis_tlv_us_drop_clfy,
+     {"60 Upstream Drop Packet Classification Encoding", 
+      "docsis_tlv.us_drop_clfy",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Upstream Drop Packet Classification Encoding", HFILL}
+     },
+    {&hf_docsis_tlv_subs_mgmt_ipv6_lst,
+     {"61 Subscriber Management CPE IPv6 Prefix List", 
+      "docsis_tlv.subs_mgmt_ipv6_lst",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Subscriber Management CPE IPv6 Prefix List", HFILL}
+     },
+    {&hf_docsis_tlv_us_drop_clfy_group_id,
+     {"62 Upstream Drop Classifier Group ID", 
+      "docsis_tlv.us_drop_clfy_group_id",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "Upstream Drop Classifier Group ID", HFILL}
+     },
+    {&hf_docsis_tlv_subs_mgmt_ctrl_max_cpe_ipv6,
+     {"63 Subscriber Management Control Max CPE IPv6 Prefix", 
+      "docsis_tlv.subs_mgmt_ctrl_max_cpe_ipv6",
+      FT_UINT16, BASE_DEC, NULL, 0x0,
+      "Subscriber Management Control Max CPE IPv6 Prefix", HFILL}
+     },
+    {&hf_docsis_tlv_cmts_mc_sess_enc,
+     {"64 CMTS Static Multicast Session Encoding", 
+      "docsis_tlv.cmts_mc_sess_enc",
+      FT_BYTES, BASE_NONE, NULL, 0x0,
+      "CMTS Static Multicast Session Encoding", HFILL}
+     },
+    {&hf_docsis_cmts_mc_sess_enc_grp,
+     {".1 Multicast Group Address", 
+      "docsis_tlv.cmts_mc_sess_enc.grp",
+      FT_IPXNET, BASE_NONE, NULL, 0x0,
+      "Multicast Group Address", HFILL}
+     },
+    {&hf_docsis_cmts_mc_sess_enc_src,
+     {".2 Source IP Address", 
+      "docsis_tlv.cmts_mc_sess_enc.src",
+      FT_IPXNET, BASE_NONE, NULL, 0x0,
+      "Source IP Address", HFILL}
+     },
   };
 
 /* Setup protocol subtree array */
@@ -2809,6 +5358,32 @@ proto_register_docsis_tlv (void)
     &ett_docsis_tlv_phs_err,
     &ett_docsis_tlv_svc_unavail,
     &ett_docsis_tlv_snmpv3_kick,
+       &ett_docsis_tlv_ds_ch_list,
+       &ett_docsis_tlv_ds_ch_list_single,
+       &ett_docsis_tlv_ds_ch_list_range,
+       &ett_docsis_tlv_tcc,
+       &ett_docsis_tlv_tcc_ucd,
+       &ett_docsis_tlv_tcc_rng_parms,
+       &ett_docsis_tlv_tcc_err,
+    &ett_docsis_tlv_sid_cl,
+    &ett_docsis_tlv_sid_cl_enc,
+    &ett_docsis_tlv_sid_cl_enc_map,
+    &ett_docsis_tlv_sid_cl_so,
+    &ett_docsis_tlv_rcp,
+    &ett_docsis_tlv_rcp_rcv_mod_enc,
+    &ett_docsis_tlv_rcp_ch_bl_rng,
+    &ett_docsis_tlv_rcp_rcv_ch,
+    &ett_docsis_tlv_rcc,
+    &ett_docsis_tlv_rcc_rcv_mod_enc,
+    &ett_docsis_tlv_rcc_rcv_ch,
+    &ett_docsis_tlv_rcc_err,
+    &ett_docsis_tlv_dsid,
+    &ett_docsis_tlv_dsid_ds_reseq,
+    &ett_docsis_tlv_dsid_mc,
+    &ett_docsis_tlv_dsid_mc_addr,
+    &ett_docsis_tlv_sec_assoc,
+    &ett_docsis_tlv_ch_asgn,
+       &ett_docsis_cmts_mc_sess_enc,
   };
 
 /* Register the protocol name and description */
@@ -2834,6 +5409,7 @@ proto_reg_handoff_docsis_tlv (void)
 
   docsis_tlv_handle = find_dissector ("docsis_tlv");
   docsis_vsif_handle = find_dissector("docsis_vsif");
+  docsis_ucd_handle = find_dissector("docsis_ucd");
 
   dissector_add ("docsis", 0xFF, docsis_tlv_handle);
 

diff --git a/plugins/docsis/packet-tlv.h b/plugins/docsis/packet-tlv.h
index c8a1381abf84de850365be0fe37c26391edf848e..ba91325e1ee334a2265d8fade613762b5382c824 100644 (file)
--- a/plugins/docsis/packet-tlv.h
+++ b/plugins/docsis/packet-tlv.h
@@ -66,7 +66,34 @@
 #define TLV_SUBS_MGMT_CTRL 35
 #define TLV_SUBS_MGMT_CPE 36
 #define TLV_SUBS_MGMT_FLTR 37
-#define TLV_VENDOR_SPEC 43
+#define TLV_SNMPV3_NTFY_RCVR 38
+#define TLV_ENABLE_20_MODE 39
+#define TLV_ENABLE_TEST_MODES 40
+#define TLV_DS_CH_LIST 41
+#define TLV_MC_MAC_ADDRESS 42
+#define TLV_VENDOR_SPEC 43 /* Vendor Specific is actually 44 ? */
+#define TLV_DUT_FILTER 45
+#define TLV_TCC 46
+#define TLV_SID_CL 47
+#define TLV_RCP 48
+#define TLV_RCC 49
+#define TLV_DSID 50
+#define TLV_SEC_ASSOC 51
+#define TLV_INIT_CH_TIMEOUT 52
+#define TLV_SNMPV1V2_COEX 53
+#define TLV_SNMPV3_ACC_VIEW 54
+#define TLV_SNMP_CPE_ACC_CTRL 55
+#define TLV_CH_ASGN 56
+#define TLV_CM_INIT_REASON 57
+#define TLV_SW_UPG_SRVR_IPV6 58
+#define TLV_TFTP_PROV_CM_IPV6_ADDR 59
+#define TLV_US_DROP_CLFY 60
+#define TLV_SUBS_MGMT_IPV6_LST 61
+#define TLV_US_DROP_CLFY_GROUP_ID 62
+#define TLV_SUBS_MGMT_CTRL_MAX_CPE_IPV6 63
+#define TLV_CMTS_MC_SESS_ENC 64
+#define TLV_L2VPN_MAC_AGING 65
+#define TLV_MGMT_EVENT_CTRL 66
 #define TLV_END 255
 
 /* Define DOCSIS 1.0 Class Of Service Configuration Types
@@ -226,4 +253,187 @@
 #define PHS_ERR_CODE 2
 #define PHS_ERR_MSG 3
 
+
+/* Define DS Channel List sub-types
+ * These are subtypes of TLV_DS_CHANNEL_LIST (41)
+ */
+#define DS_CH_LIST_SINGLE 1
+#define DS_CH_LIST_RANGE 2
+#define DS_CH_LIST_DEFAULT_TIMEOUT 3
+
+/* Define Singe Downstream Channel sub-types
+ * These are subtypes of DS_CH_LIST_SINGLE (41.1)
+ */
+#define SINGLE_CH_TIMEOUT 1
+#define SINGLE_CH_FREQ 2
+
+/* Define Singe Downstream Channel sub-types
+ * These are subtypes of DS_CH_LIST_RANGE (41.2)
+ */
+#define FREQ_RNG_TIMEOUT 1
+#define FREQ_RNG_START 2
+#define FREQ_RNG_END 3
+#define FREQ_RNG_STEP 4
+
+/* Define DUT sub-types
+ * These are subtypes of TLV_DUT_FILTER (45)
+ */
+#define DUT_CONTROL 1
+#define DUT_CMIM 2
+
+/* Define TCC sub-types
+ * These are subtypes of TLV_TCC (46)
+ */
+#define TLV_TCC_REFID 1
+#define TLV_TCC_US_CH_ACTION 2
+#define TLV_TCC_US_CH_ID 3
+#define TLV_TCC_NEW_US_CH_ID 4
+#define TLV_TCC_UCD 5
+#define TLV_TCC_RNG_SID 6
+#define TLV_TCC_INIT_TECH 7
+#define TLV_TCC_RNG_PARMS 8
+#define TLV_TCC_DYN_RNG_WIN 9
+#define TLV_TCC_ERR 254
+
+/* Define TLV_TCC_RNG_PARMS sub-types
+ * These are subtypes of TLV_TCC_RNG_PARMS (46.8)
+ */
+#define RNG_PARMS_US_CH_ID 1
+#define RNG_PARMS_TIME_OFF_INT 2
+#define RNG_PARMS_TIME_OFF_FRAC 3
+#define RNG_PARMS_POWER_OFF 4
+#define RNG_PARMS_FREQ_OFF 5
+
+/* Define TLV_TCC_ERR sub-types
+ * These are subtypes of TLV_TCC_ERR (46.254)
+ */
+#define TCC_ERR_SUBTYPE 1
+#define TCC_ERR_CODE 2
+#define TCC_ERR_MSG 3
+
+/* Define TLV_SID_CLUSTER sub-types
+ * These are subtypes of TLV_SID_CLUSTER (47)
+ */
+#define SID_CL_SF_ID 1
+#define SID_CL_ENC 2
+#define SID_CL_SO_CRIT 3
+
+/* Define SID_CL_ENC sub-types
+ * These are subtypes of SID_CL_ENC (47.2)
+ */
+#define SID_CL_ENC_ID 1
+#define SID_CL_ENC_MAP 2
+
+/* Define SID_CL_ENC_MAP sub-types
+ * These are subtypes of SID_CL_ENC_MAP (47.2.2)
+ */
+#define SID_CL_MAP_US_CH_ID 1
+#define SID_CL_MAP_SID 2
+#define SID_CL_MAP_ACTION 3
+
+/* Define SID_CL_SO_CRIT sub-types
+ * These are subtypes of SID_CL_SO_CRIT (47.3)
+ */
+#define SID_CL_SO_MAX_REQ 1
+#define SID_CL_SO_MAX_OUT_BYTES 2
+#define SID_CL_SO_MAX_REQ_BYTES 3
+#define SID_CL_SO_MAX_TIME 4
+
+/* Define TLV_RCP sub-types
+ * These are subtypes of TLV_RCP (48)
+ */
+#define TLV_RCP_ID 1
+#define TLV_RCP_NAME 2
+#define TLV_RCP_FREQ_SPC 3
+#define TLV_RCP_RCV_MOD_ENC 4
+#define TLV_RCP_RCV_CH 5
+#define TLV_RCP_VEN_SPEC 43
+#define TLV_RCC_ERR 254
+
+/* Define TLV_RCP_RCV_MOD_ENC sub-types
+ * These are subtypes of TLV_RCP_RCV_MOD_ENC (48.4)
+ */
+#define RCV_MOD_ENC_IDX 1
+#define RCV_MOD_ENC_ADJ_CH 2
+#define RCV_MOD_ENC_CH_BL_RNG 3
+#define RCV_MOD_ENC_CTR_FREQ_ASGN 4
+#define RCV_MOD_ENC_RSQ_CH_SUBS_CAP 5
+#define RCV_MOD_ENC_CONN 6
+#define RCV_MOD_ENC_PHY_LAYR_PARMS 7
+
+/* Define RCV_MOD_ENC_CH_BL_RNG sub-types
+ * These are subtypes of RCV_MOD_ENC_CH_BL_RNG (48.4.3)
+ */
+#define CH_BL_RNG_MIN_CTR_FREQ 1
+#define CH_BL_RNG_MAX_CTR_FREQ 2
+
+/* Define TLV_RCP_RCV_CH sub-types
+ * These are subtypes of TLV_RCP_RCV_CH (48.5)
+ */
+#define RCV_CH_IDX 1
+#define RCV_CH_CONN 2
+#define RCV_CH_CONN_OFF 3
+#define RCV_CH_CTR_FREQ_ASGN 4
+#define RCV_CH_PRIM_DS_CH_IND 5
+
+/* Define TLV_RCC_ERR sub-types
+ * These are subtypes of TLV_RCC_ERR (49.254)
+ */
+#define RCC_ERR_MOD_OR_CH 1
+#define RCC_ERR_IDX 2
+#define RCC_ERR_PARAM 3
+#define RCC_ERR_CODE 4
+#define RCC_ERR_MSG 5
+
+
+/* Define TLV_DSID sub-types
+ * These are subtypes of TLV_DSID (50)
+ */
+#define TLV_DSID_ID 1
+#define TLV_DSID_ACTION 2
+#define TLV_DSID_DS_RESEQ 3
+#define TLV_DSID_MC 4
+
+/* Define TLV_DSID_DS_RESEQ sub-types
+ * These are subtypes of TLV_DSID_DS_RESEQ (50.3)
+ */
+#define DS_RESEQ_DSID 1
+#define DS_RESEQ_CH_LST 2
+#define DS_RESEQ_WAIT_TIME 3
+#define DS_RESEQ_WARN_THRESH 4
+#define DS_RESEQ_HO_TIMER 5
+
+/* Define TLV_DSID_MC sub-types
+ * These are subtypes of TLV_DSID_DS_MC (50.4)
+ */
+
+#define TLV_DSID_MC_ADDR 1
+#define TLV_DSID_MC_CMIM 2
+#define TLV_DSID_MC_GROUP 3
+#define TLV_DSID_MC_PHS 26
+
+/* Define TLV_DSID_MC_ADDR sub-types
+ * These are subtypes of TLV_DSID_MC_ADDR (50.4.1)
+ */
+#define MC_ADDR_ACTION 1
+#define MC_ADDR_ADDR 2
+
+/* Define TLV_SEC_ASSOC sub-types
+ * These are subtypes of TLV_SEC_ASSOC (51)
+ */
+#define TLV_SEC_ASSOC_ACTION 1
+#define TLV_SEC_ASSOC_DESC 2
+
+/* Define TLV_CH_ASGN sub-types
+ * These are subtypes of TLV_CH_ASGN (56)
+ */
+#define TLV_CH_ASGN_US_CH_ID 1
+#define TLV_CH_ASGN_RX_FREQ 2
+
+/* Define TLV_CMTS_MC_SESS_ENC sub-types
+ * These are subtypes of TLV_CMTS_MC_SESS_ENC (64)
+ */
+#define CMTS_MC_SESS_ENC_GRP 1
+#define CMTS_MC_SESS_ENC_SRC 2
+
 #endif