From Daniel Willmann: dissector for EIA-852 protocol (Component Network over IP)

Attached is a dissector for CN/IP protocol described in EIA-852. It is mainly
used to encapsulate and send Lontalk (EIA-709.1) or EIA-600 frames over UDP (or
TCP).

This dissector can only decode the common header and data frames can be decoded
by further dissectors.

https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=5907

svn path=/trunk/; revision=37596

diff --git a/AUTHORS b/AUTHORS
index 8849e716d14e1065ba59a6cb11bb0bbf7b11669e..e401fc59781fee7a66470ecfc5f7edcfa4c9598f 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -3278,6 +3278,11 @@ Florian Fainelli <florian [AT] openwrt.org> {
        HomePlug AV protocol dissector
 }
 
+Daniel  Willmann       <daniel [AT] totalueberwachung.de> {
+       CN/IP (EIA-852) protocol dissector
+}
+
+
 and by:
 
 Pavel Roskin            <proski [AT] gnu.org>

diff --git a/epan/CMakeLists.txt b/epan/CMakeLists.txt
index 29990a6a700e68d3f254be16f9e90230b2719e5b..96c4ac40f072b9448090f8b40f5665601ece5105 100644 (file)
--- a/epan/CMakeLists.txt
+++ b/epan/CMakeLists.txt
@@ -195,6 +195,7 @@ set(ASN1_DISSECTOR_SRC
        dissectors/packet-cmip.c
        dissectors/packet-cmp.c
        dissectors/packet-cms.c
+       dissectors/packet-cnip.c
        dissectors/packet-crmf.c
        dissectors/packet-dap.c
        dissectors/packet-disp.c

diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common
index 4c8340a9532488d645aeba97811d34c42a85dbef..d3f830a6029dd5744890c36274aa58848de818b0 100644 (file)
--- a/epan/dissectors/Makefile.common
+++ b/epan/dissectors/Makefile.common
@@ -317,6 +317,7 @@ DISSECTOR_SRC = \
        packet-clip.c           \
        packet-clnp.c           \
        packet-cmpp.c           \
+       packet-cnip.c           \
        packet-collectd.c       \
        packet-componentstatus.c \
        packet-cops.c           \

diff --git a/epan/dissectors/packet-cnip.c b/epan/dissectors/packet-cnip.c
new file mode 100644 (file)
index 0000000..befc7a9
--- /dev/null
+++ b/epan/dissectors/packet-cnip.c
@@ -0,0 +1,261 @@
+/* packet-cnip.c
+ * Traffic analyzer for the CN/IP (EIA-852) protocol
+ * Daniel Willmann <daniel@totalueberwachung.de>
+ * (c) 2011 Daniel Willmann
+ *
+ * $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 <glib.h>
+
+#include <epan/packet.h>
+#include <epan/expert.h>
+
+#define DATA_PACKET    0x01
+
+static const value_string type_tuple[]=
+{
+       {0x01, "Data Packet"},
+       {0x63, "Device Configuration Request"},
+       {0x03, "Device Registration"},
+       {0x71, "Device Configuration"},
+       {0x64, "Channel Membership Request"},
+       {0x04, "Channel Membership"},
+       {0x66, "Send List Request"},
+       {0x06, "Send List"},
+       {0x68, "Channel Routing Request"},
+       {0x08, "Channel Routing"},
+       {0x07, "Acknowledge"},
+       {0x7F, "Segment"},
+       {0x60, "Status/Health/Statistics Request"},
+       {0x70, "Status/Health/Statistics Response"},
+       {0, NULL}
+};
+
+void proto_reg_handoff_cnip(void);
+
+static gint hf_cnip_len                        = -1;
+static gint hf_cnip_ver                        = -1;
+static gint hf_cnip_type               = -1;
+static gint hf_cnip_exth               = -1;
+static gint hf_cnip_pf                 = -1;
+static gint hf_cnip_pf_sec             = -1;
+static gint hf_cnip_pf_pcode           = -1;
+static gint hf_cnip_vcode              = -1;
+static gint hf_cnip_sessid             = -1;
+static gint hf_cnip_seqno              = -1;
+static gint hf_cnip_tstamp             = -1;
+
+static gint proto_cnip                 = -1;
+
+static gint ett_cnip                   = -1;
+static gint ett_pf                     = -1;
+
+static dissector_table_t cnip_dissector_table;
+static dissector_handle_t data_handle;
+
+static void dissect_cnip (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+       tvbuff_t *next_tvb;
+       gint offset;
+       gint type, exth_len, pf_pcode;
+
+       proto_tree *ti;
+       proto_tree *cnip_tree;
+
+       col_set_str(pinfo->cinfo, COL_PROTOCOL, "CN/IP");
+       col_clear(pinfo->cinfo, COL_INFO);
+
+       type = tvb_get_guint8(tvb, 3);
+       if (check_col(pinfo->cinfo, COL_INFO))
+       {
+               col_add_fstr(pinfo->cinfo, COL_INFO,"Priority: %s Type: %s",
+                            (pinfo->destport == 1629 )? "urgent":"normal",
+                            val_to_str_const(type, type_tuple, "Unknown"));
+       }
+
+       exth_len = tvb_get_guint8(tvb, 4);
+       pf_pcode = tvb_get_guint8(tvb, 5) & 0x1F;
+
+       if (tree) {
+               offset = 0;
+
+               /* Take whole packet for now, we'll adjust it later */
+               ti = proto_tree_add_item(tree, proto_cnip, tvb, offset, -1, FALSE);
+               cnip_tree = proto_item_add_subtree(ti, ett_cnip);
+
+               proto_tree_add_item(cnip_tree, hf_cnip_len, tvb, offset, 2, FALSE);
+               offset += 2;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_ver, tvb, offset, 1, FALSE);
+               offset += 1;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_type, tvb, offset, 1, FALSE);
+               offset += 1;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_exth, tvb, offset, 1, FALSE);
+               offset += 1;
+
+               {
+                       static const gint *pf_fields[] = {
+                               &hf_cnip_pf_sec,
+                               &hf_cnip_pf_pcode,
+                               NULL
+                       };
+                       proto_tree_add_bitmask(cnip_tree, tvb, offset, hf_cnip_pf,
+                                               ett_pf, pf_fields, FALSE);
+               }
+               offset += 1;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_vcode, tvb, offset, 2, FALSE);
+               offset += 2;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_sessid, tvb, offset, 4, FALSE);
+               offset += 4;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_seqno, tvb, offset, 4, FALSE);
+               offset += 4;
+
+               proto_tree_add_item(cnip_tree, hf_cnip_tstamp, tvb, offset, 4, FALSE);
+               offset += 4;
+
+               /* Jump over any unknown header extensions */
+               offset += 4 * exth_len;
+
+               proto_item_set_len(ti, offset);
+
+               if (type != DATA_PACKET) {
+                       expert_add_info_format(pinfo, cnip_tree,
+                                              PI_UNDECODED, PI_WARN,
+                                              "This dissector doesn't yet decode packets of type %s (0x%x)",
+                                              val_to_str_const(type, type_tuple, "Unknown"), type);
+               }
+
+       } else {
+               offset = 20 + 4*exth_len;
+       }
+
+       next_tvb = tvb_new_subset_remaining(tvb, offset);
+
+       /* Try subdissectors only for data packets*/
+       if (type == DATA_PACKET) {
+               if (dissector_try_uint(cnip_dissector_table, pf_pcode, next_tvb, pinfo, tree))
+                       return;
+       }
+
+       call_dissector(data_handle, next_tvb, pinfo, tree);
+
+       return;
+
+}
+
+void proto_register_cnip(void)
+{
+       static hf_register_info hf[] =
+       {
+               {&hf_cnip_len,
+                       {"Packet length", "cnip.len",
+                       FT_UINT16, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_ver,
+                       {"Version", "cnip.ver",
+                       FT_UINT8, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_type,
+                       {"Packet type", "cnip.type",
+                       FT_UINT8, BASE_HEX, VALS(type_tuple), 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_exth,
+                       {"Ext. Header Size", "cnip.exth",
+                       FT_UINT8, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_pf,
+                       {"Protocol Flags", "cnip.pf",
+                       FT_UINT8, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_pf_sec,
+                       {"Protocol Flags", "cnip.sec",
+                       FT_UINT8, BASE_DEC, NULL, 0x20,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_pf_pcode,
+                       {"Protocol Code", "cnip.protocol",
+                       FT_UINT8, BASE_DEC, NULL, 0x1F,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_vcode,
+                       {"Vendor Code", "cnip.vendorcode",
+                       FT_UINT16, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_sessid,
+                       {"Session ID", "cnip.sessid",
+                       FT_UINT32, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_seqno,
+                       {"Sequence Number", "cnip.seqno",
+                       FT_UINT32, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               },
+               {&hf_cnip_tstamp,
+                       {"Time Stamp", "cnip.tstamp",
+                       FT_UINT32, BASE_DEC, NULL, 0,
+                       NULL, HFILL }
+               }
+       };
+
+       static gint *ett[] =
+       {
+               &ett_cnip,
+               &ett_pf
+       };
+
+       proto_cnip = proto_register_protocol("Component Network over IP",
+                       "CN/IP", "cnip");
+
+       proto_register_field_array(proto_cnip, hf, array_length (hf));
+       proto_register_subtree_array(ett, array_length (ett));
+
+       /* Register table for subdissectors */
+       cnip_dissector_table = register_dissector_table("cnip.protocol",
+                       "CN/IP Protocol", FT_UINT8, BASE_DEC);
+}
+
+void proto_reg_handoff_cnip(void)
+{
+       dissector_handle_t cnip_handle;
+
+       cnip_handle = create_dissector_handle(dissect_cnip, proto_cnip);
+       data_handle = find_dissector("data");
+
+       dissector_add_uint ("udp.port", 1628, cnip_handle);
+       dissector_add_uint ("udp.port", 1629, cnip_handle);
+}