forked from osmocom/wireshark
![T. Scholz](/assets/img/avatar_default.png)
New implemented functions for profinet plug-in to read cyclic RTC1 data frames more detailed and further to dissect PROFIsafe on PROFINET frames. New functions include: - Reading the PROFINET "Ident OK" Frame for detailed module information, as ModuleIdentNr., SubModuleIdentNr., etc. total dynamically - Improved the existing dissection of fParameter with usage of GSDML-files, as the indexnumber for those parameters can change - Reading a GSDML-file for further module-information, such as PROFIsafe Module, etc. - Aded new pnio protocol preferences, in which the user can define its own network path to his GSDML-files, so that Wireshark is able to read those files for detailed information output. - Added new filter functions for PROFINET and PROFIsafe - All gained and saved information will be used to dissect the cyclic PROFINET frames Bug: 12216 Change-Id: I379da1d349fa099047953042f1aa30450bee5b30 Reviewed-on: https://code.wireshark.org/review/14119 Petri-Dish: Jim Young <jim.young.ws@gmail.com> Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org> Reviewed-by: Birol Capa <birol.capa@siemens.com> Reviewed-by: Michael Mann <mmann78@netscape.net>
380 lines
9.8 KiB
C
380 lines
9.8 KiB
C
/* packet-pn.c
|
|
* Common functions for other PROFINET protocols like IO, CBA, DCP, ...
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1999 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/expert.h>
|
|
#include <epan/wmem/wmem.h>
|
|
#include <epan/dissectors/packet-dcerpc.h>
|
|
|
|
#include "packet-pn.h"
|
|
|
|
|
|
|
|
static int hf_pn_padding = -1;
|
|
static int hf_pn_undecoded_data = -1;
|
|
static int hf_pn_user_data = -1;
|
|
static int hf_pn_user_bytes = -1;
|
|
static int hf_pn_frag_bytes = -1;
|
|
static int hf_pn_malformed = -1;
|
|
|
|
static expert_field ei_pn_undecoded_data = EI_INIT;
|
|
|
|
/* Initialize PNIO RTC1 stationInfo memory */
|
|
void
|
|
init_pnio_rtc1_station(stationInfo *station_info) {
|
|
station_info->iocs_data_in = wmem_list_new(wmem_file_scope());
|
|
station_info->iocs_data_out = wmem_list_new(wmem_file_scope());
|
|
station_info->ioobject_data_in = wmem_list_new(wmem_file_scope());
|
|
station_info->ioobject_data_out = wmem_list_new(wmem_file_scope());
|
|
station_info->diff_module = wmem_list_new(wmem_file_scope());
|
|
}
|
|
|
|
/* dissect an 8 bit unsigned integer */
|
|
int
|
|
dissect_pn_uint8(tvbuff_t *tvb, gint offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint8 *pdata)
|
|
{
|
|
guint8 data;
|
|
|
|
data = tvb_get_guint8 (tvb, offset);
|
|
if (tree) {
|
|
proto_tree_add_uint(tree, hfindex, tvb, offset, 1, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
return offset + 1;
|
|
}
|
|
|
|
/* dissect a 16 bit unsigned integer; return the item through a pointer as well */
|
|
int
|
|
dissect_pn_uint16_ret_item(tvbuff_t *tvb, gint offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint16 *pdata, proto_item ** new_item)
|
|
{
|
|
guint16 data;
|
|
proto_item *item = NULL;
|
|
|
|
data = tvb_get_ntohs (tvb, offset);
|
|
|
|
if (tree) {
|
|
item = proto_tree_add_uint(tree, hfindex, tvb, offset, 2, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
if (new_item)
|
|
*new_item = item;
|
|
return offset + 2;
|
|
}
|
|
|
|
/* dissect a 16 bit unsigned integer */
|
|
int
|
|
dissect_pn_uint16(tvbuff_t *tvb, gint offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint16 *pdata)
|
|
{
|
|
guint16 data;
|
|
|
|
data = tvb_get_ntohs (tvb, offset);
|
|
|
|
if (tree) {
|
|
proto_tree_add_uint(tree, hfindex, tvb, offset, 2, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
return offset + 2;
|
|
}
|
|
|
|
/* dissect a 32 bit unsigned integer */
|
|
int
|
|
dissect_pn_uint32(tvbuff_t *tvb, gint offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint32 *pdata)
|
|
{
|
|
guint32 data;
|
|
|
|
data = tvb_get_ntohl (tvb, offset);
|
|
|
|
if (tree) {
|
|
proto_tree_add_uint(tree, hfindex, tvb, offset, 4, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
return offset+4;
|
|
}
|
|
|
|
/* dissect a 16 bit signed integer */
|
|
int
|
|
dissect_pn_int16(tvbuff_t *tvb, gint offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, gint16 *pdata)
|
|
{
|
|
gint16 data;
|
|
|
|
data = tvb_get_ntohs (tvb, offset);
|
|
|
|
if (tree) {
|
|
proto_tree_add_int(tree, hfindex, tvb, offset, 2, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
return offset + 2;
|
|
}
|
|
|
|
/* dissect a 32 bit signed integer */
|
|
int
|
|
dissect_pn_int32(tvbuff_t *tvb, gint offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, gint32 *pdata)
|
|
{
|
|
gint32 data;
|
|
|
|
data = tvb_get_ntohl (tvb, offset);
|
|
|
|
if (tree) {
|
|
proto_tree_add_int(tree, hfindex, tvb, offset, 4, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
return offset + 4;
|
|
}
|
|
|
|
/* dissect a 24bit OUI (IEC organizational unique id) */
|
|
int
|
|
dissect_pn_oid(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint32 *pdata)
|
|
{
|
|
guint32 data;
|
|
|
|
data = tvb_get_ntoh24(tvb, offset);
|
|
|
|
if (tree) {
|
|
proto_tree_add_uint(tree, hfindex, tvb, offset, 3, data);
|
|
}
|
|
if (pdata)
|
|
*pdata = data;
|
|
return offset + 3;
|
|
}
|
|
|
|
/* dissect a 6 byte MAC address */
|
|
int
|
|
dissect_pn_mac(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint8 *pdata)
|
|
{
|
|
guint8 data[6];
|
|
|
|
tvb_memcpy(tvb, data, offset, 6);
|
|
if(tree)
|
|
proto_tree_add_ether(tree, hfindex, tvb, offset, 6, data);
|
|
|
|
if (pdata)
|
|
memcpy(pdata, data, 6);
|
|
|
|
return offset + 6;
|
|
}
|
|
|
|
/* dissect an IPv4 address */
|
|
int
|
|
dissect_pn_ipv4(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, guint32 *pdata)
|
|
{
|
|
guint32 data;
|
|
|
|
data = tvb_get_ipv4(tvb, offset);
|
|
if(tree)
|
|
proto_tree_add_ipv4(tree, hfindex, tvb, offset, 4, data);
|
|
|
|
if (pdata)
|
|
*pdata = data;
|
|
|
|
return offset + 4;
|
|
}
|
|
|
|
/* dissect a 16 byte UUID address */
|
|
int
|
|
dissect_pn_uuid(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int hfindex, e_guid_t *uuid)
|
|
{
|
|
guint8 drep[2] = { 0,0 };
|
|
|
|
offset = dissect_dcerpc_uuid_t(tvb, offset, pinfo, tree, drep,
|
|
hfindex, uuid);
|
|
|
|
return offset;
|
|
}
|
|
|
|
/* "dissect" some bytes still undecoded (with Expert warning) */
|
|
int
|
|
dissect_pn_undecoded(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, guint32 length)
|
|
{
|
|
proto_item *item;
|
|
|
|
|
|
item = proto_tree_add_string_format(tree, hf_pn_undecoded_data, tvb, offset, length, "data",
|
|
"Undecoded Data: %d bytes", length);
|
|
|
|
expert_add_info_format(pinfo, item, &ei_pn_undecoded_data,
|
|
"Undecoded Data, %u bytes", length);
|
|
|
|
return offset + length;
|
|
}
|
|
|
|
/* "dissect" some user bytes */
|
|
int
|
|
dissect_pn_user_data_bytes(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, guint32 length, int iSelect)
|
|
{
|
|
if (tree) {
|
|
if(iSelect == FRAG_DATA)
|
|
proto_tree_add_item(tree, hf_pn_frag_bytes, tvb, offset, length, ENC_NA);
|
|
else
|
|
proto_tree_add_item(tree, hf_pn_user_bytes, tvb, offset, length, ENC_NA);
|
|
}
|
|
return offset + length;
|
|
}
|
|
|
|
int
|
|
dissect_pn_user_data(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, guint32 length, const char *text)
|
|
{
|
|
if (tree && length != 0) {
|
|
proto_tree_add_string_format(tree, hf_pn_user_data, tvb, offset, length, "data",
|
|
"%s: %d bytes", text, length);
|
|
}
|
|
return offset + length;
|
|
}
|
|
|
|
/* packet is malformed, mark it as such */
|
|
int
|
|
dissect_pn_malformed(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, guint32 length)
|
|
{
|
|
proto_tree_add_item(tree, hf_pn_malformed, tvb, 0, 10000, ENC_NA);
|
|
|
|
return offset + length;
|
|
}
|
|
|
|
|
|
/* dissect some padding data (with the given length) */
|
|
int
|
|
dissect_pn_padding(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
|
|
proto_tree *tree, int length)
|
|
{
|
|
proto_tree_add_string_format(tree, hf_pn_padding, tvb, offset, length, "data",
|
|
"Padding: %u byte", length);
|
|
|
|
return offset + length;
|
|
}
|
|
|
|
/* align offset to 4 */
|
|
int
|
|
dissect_pn_align4(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
|
|
{
|
|
guint padding = 0;
|
|
|
|
|
|
if (offset % 4) {
|
|
padding = 4 - (offset % 4);
|
|
|
|
proto_tree_add_string_format(tree, hf_pn_padding, tvb, offset, padding, "data",
|
|
"Padding: %u byte", padding);
|
|
}
|
|
|
|
return offset + padding;
|
|
}
|
|
|
|
/* append the given info text to item and column */
|
|
void
|
|
pn_append_info(packet_info *pinfo, proto_item *dcp_item, const char *text)
|
|
{
|
|
col_append_str(pinfo->cinfo, COL_INFO, text);
|
|
|
|
proto_item_append_text(dcp_item, "%s", text);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
init_pn (int proto)
|
|
{
|
|
static hf_register_info hf[] = {
|
|
{ &hf_pn_padding,
|
|
{ "Padding", "pn.padding",
|
|
FT_STRING, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_pn_undecoded_data,
|
|
{ "Undecoded Data", "pn.undecoded",
|
|
FT_STRING, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_pn_user_data,
|
|
{ "User Data", "pn.user_data",
|
|
FT_STRING, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_pn_user_bytes,
|
|
{ "Substitute Data", "pn.user_bytes",
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_pn_frag_bytes,
|
|
{ "Fragment Data", "pn.frag_bytes",
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }},
|
|
|
|
{ &hf_pn_malformed,
|
|
{ "Malformed", "pn_rt.malformed",
|
|
FT_BYTES, BASE_NONE, NULL, 0x0,
|
|
NULL, HFILL }}
|
|
|
|
};
|
|
|
|
/*static gint *ett[] = {
|
|
};*/
|
|
|
|
static ei_register_info ei[] = {
|
|
{ &ei_pn_undecoded_data, { "pn.undecoded_data", PI_UNDECODED, PI_WARN, "Undecoded Data", EXPFILL }},
|
|
};
|
|
|
|
expert_module_t* expert_pn;
|
|
|
|
|
|
proto_register_field_array (proto, hf, array_length (hf));
|
|
/*proto_register_subtree_array (ett, array_length (ett));*/
|
|
expert_pn = expert_register_protocol(proto);
|
|
expert_register_field_array(expert_pn, ei, array_length(ei));
|
|
}
|
|
|
|
/*
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
*
|
|
* Local variables:
|
|
* c-basic-offset: 4
|
|
* tab-width: 8
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* vi: set shiftwidth=4 tabstop=8 expandtab:
|
|
* :indentSize=4:tabSize=8:noTabs=true:
|
|
*/
|