769 lines
26 KiB
C
769 lines
26 KiB
C
/* packet-vocallonet.c
|
|
* Routines for vocallonet dissection
|
|
* Copyright 2004, Ocatasic inc.
|
|
*
|
|
* $Id: README.developer 11475 2004-07-23 01:37:35Z guy $
|
|
*
|
|
* Ethereal - Network traffic analyzer
|
|
* By Gerald Combs <gerald@ethereal.com>
|
|
* 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>
|
|
#include <epan/prefs.h>
|
|
#include <epan/expert.h>
|
|
#include <epan/ipproto.h>
|
|
|
|
#include "../include/moduleinfo.h"
|
|
#include "../../../include/oct_ws_macro.h"
|
|
#include "../../../include/oct_ws_priv.h"
|
|
|
|
#include <color.h>
|
|
#include <color_filters.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <gmodule.h>
|
|
|
|
#include <octvocnet_pkt.h>
|
|
|
|
/* Define version if we are not building Wireshark statically */
|
|
|
|
/* Initialize the protocol and registered fields */
|
|
static int proto_vocallonet = -1;
|
|
|
|
static int hf_vocallonet_format = -1;
|
|
static int hf_vocallonet_trace_flag = -1;
|
|
static int hf_vocallonet_api_type = -1;
|
|
static int hf_vocallonet_size = -1;
|
|
|
|
static int proto_vocallonet_control = -1;
|
|
|
|
static int hf_vocallonet_control_destination_fifo_id = -1;
|
|
static int hf_vocallonet_control_source_fifo_id = -1;
|
|
static int hf_vocallonet_control_socket_id = -1;
|
|
|
|
/* Packet data external fields (formats a-q) */
|
|
static int proto_vocallonet_data = -1;
|
|
static int hf_vocallonet_data_socket_handle = -1;
|
|
static int proto_vocallonet_d_frag_data = -1;
|
|
static int proto_vocallonet_ev_data = -1;
|
|
static int proto_vocallonet_f_data = -1;
|
|
|
|
|
|
/* Packet format A fields (ethernet) */
|
|
/* None other than already defined */
|
|
|
|
/* Packet data fields (formats b-f) */
|
|
static int hf_vocallonet_data_logical_object_handle = -1;
|
|
static int hf_vocallonet_data_packet_port = -1;
|
|
static int hf_vocallonet_data_dest_fifo_id = -1;
|
|
|
|
/* Packet format D fields (voice) */
|
|
static int hf_vocallonet_d_frag_SequenceId = -1;
|
|
static int hf_vocallonet_d_frag_TransfertTotalSize = -1;
|
|
static int hf_vocallonet_d_frag_FragmentTotalNum = -1;
|
|
static int hf_vocallonet_d_frag_FragmentId = -1;
|
|
static int hf_vocallonet_d_frag_FragmentDataOffset = -1;
|
|
static int hf_vocallonet_d_frag_FragmentDataSize = -1;
|
|
static int hf_vocallonet_d_frag_UserId = -1;
|
|
|
|
/* Packet format F fields (raw) */
|
|
static int hf_vocallonet_f_timestamp = -1;
|
|
static int hf_vocallonet_f_subtype = -1;
|
|
|
|
/* fields defining a subtree */
|
|
static gint ett_vocallonet = -1;
|
|
|
|
static gint ett_vocallonet_control = -1;
|
|
static gint ett_vocallonet_data = -1;
|
|
static gint ett_vocallonet_d_frag_data = -1;
|
|
static gint ett_vocallonet_f_data = -1;
|
|
|
|
|
|
typedef enum {
|
|
PACKET_F_UNSPECIFIED,
|
|
PACKET_F_LAPD
|
|
} Version_Type;
|
|
|
|
static gint packet_f_decode = PACKET_F_UNSPECIFIED;
|
|
|
|
|
|
static dissector_handle_t data_handle;
|
|
|
|
static dissector_handle_t lapd_handle;
|
|
static dissector_handle_t octvc1_ctrl_handle;
|
|
static dissector_handle_t octvc1_event_handle;
|
|
static dissector_handle_t octpkt_handle;
|
|
|
|
|
|
|
|
|
|
// TODO
|
|
#define cOCTVOCNET_PKT_API_TYPE_ENUM_OCTVC1 0
|
|
|
|
const value_string vocallonet_api_type_vals[] =
|
|
{
|
|
{ cOCTVOCNET_PKT_API_TYPE_ENUM_OCTVC1, "OCTVC1" },
|
|
{ 0, NULL },
|
|
};
|
|
const value_string vocallonet_format_vals[] =
|
|
{
|
|
{ cOCTVOCNET_PKT_FORMAT_CTRL, "Control packet" },
|
|
{ cOCTVOCNET_PKT_FORMAT_F, "Format F: Raw Data Packet" },
|
|
{ cOCTVOCNET_PKT_FORMAT_DATA_FRAGMENT, "Format DATA_FRAGMENT: Data Packet (allow fragment)" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
const value_string vocallonet_d_encoding_type_vals[] =
|
|
{
|
|
|
|
{ 0, NULL },
|
|
};
|
|
|
|
const value_string vocallonet_f_subtype_vals[] =
|
|
{
|
|
{ cOCTVOCNET_PKT_SUBTYPE_UNSPECIFIED, "Unspecified" },
|
|
{ cOCTVOCNET_PKT_SUBTYPE_API_EVENT, "API Event" },
|
|
{ cOCTVOCNET_PKT_SUBTYPE_MODULE_DATA, "Module Data" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
#define VOCALLONET_TRACE_BIT(octet) ((octet) & 0x80)
|
|
#define VOCALLONET_TOTAL_PACKET_SIZE(uint16) ((uint16) & 0x07ff)
|
|
#define VOCALLONET_API_TYPE(octet) (((octet) & 0x78) >> 3 )
|
|
|
|
#define VOCALLONET_F_SUBTYPE(uint32) ((uint32) & 0x0000000f)
|
|
#define VOCALLONET_F_EVENT_ID_BASE(uint32) ((uint32) & 0x0fff0000)
|
|
#define VOCALLONET_F_EVENT_ID_CODE(uint32) ((uint32) & 0x0000ffff)
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Code to dissect the Vocallo data packet header
|
|
*
|
|
**************************************************************************/
|
|
static void dissect_vocallonet_packet_data(tvbuff_t *tvb, proto_item *ti,
|
|
proto_tree *vocallonet_tree, unsigned int offset)
|
|
{
|
|
unsigned int packet_offset = offset;
|
|
guint32 logical_object_handle;
|
|
guint32 packet_port;
|
|
guint32 dest_fifo;
|
|
proto_tree* vocallonet_data_tree = NULL;
|
|
unsigned int layer_length = 0;
|
|
|
|
/* dissect the common packet data */
|
|
logical_object_handle = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(logical_object_handle);
|
|
layer_length += sizeof(logical_object_handle);
|
|
|
|
packet_port = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(packet_port);
|
|
layer_length += sizeof(packet_port);
|
|
|
|
dest_fifo = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(dest_fifo);
|
|
layer_length += sizeof(dest_fifo);
|
|
|
|
if (vocallonet_tree) {
|
|
|
|
/* Add the subtree for struct tOCTVOCNET_PKT_DATA_HEADER under struct tOCTVOCNET_PKT_HEADER */
|
|
ti = proto_tree_add_item( vocallonet_tree, proto_vocallonet_data, tvb, packet_offset-layer_length, packet_offset-offset, FALSE );
|
|
vocallonet_data_tree = proto_item_add_subtree( ti, ett_vocallonet_data );
|
|
|
|
/* Scroll back to the beginning of the packet */
|
|
packet_offset = offset;
|
|
|
|
proto_tree_add_uint( vocallonet_data_tree, hf_vocallonet_data_logical_object_handle, tvb,
|
|
packet_offset, sizeof(logical_object_handle), logical_object_handle );
|
|
packet_offset += sizeof(logical_object_handle);
|
|
|
|
proto_tree_add_uint( vocallonet_data_tree, hf_vocallonet_data_packet_port, tvb,
|
|
packet_offset, sizeof(packet_port), packet_port );
|
|
packet_offset += sizeof(packet_port);
|
|
|
|
proto_tree_add_uint( vocallonet_data_tree, hf_vocallonet_data_dest_fifo_id, tvb,
|
|
packet_offset, sizeof(dest_fifo), dest_fifo );
|
|
packet_offset += sizeof(dest_fifo);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Code to actually dissect the Vocallo control packet header
|
|
*
|
|
**************************************************************************/
|
|
static void dissect_vocallonet_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
{
|
|
proto_item* ti = NULL;
|
|
proto_tree* vocallonet_control_tree = NULL;
|
|
unsigned int packet_offset = 0;
|
|
guint32 destination_fifo_id;
|
|
guint32 source_fifo_id;
|
|
guint32 socket_id;
|
|
tOctWsPrivateData * pPrivData = (tOctWsPrivateData *)pinfo->private_data;
|
|
|
|
/* Finish dissecting the external packet header */
|
|
destination_fifo_id = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(destination_fifo_id);
|
|
source_fifo_id = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(source_fifo_id);
|
|
|
|
socket_id = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(socket_id);
|
|
|
|
if ( check_col(pinfo->cinfo, COL_PROTOCOL) )
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "OCTVOCNET_PKT_FORMAT_CTRL");
|
|
|
|
if ( tree )
|
|
{
|
|
/* Add the subtree for struct tOCTVOCNET_PKT_CTL_HEADER */
|
|
ti = proto_tree_add_item( tree, proto_vocallonet_control, tvb, 0, -1, FALSE );
|
|
vocallonet_control_tree = proto_item_add_subtree( ti, ett_vocallonet_control );
|
|
|
|
/* Scroll back to the beginning of the packet */
|
|
packet_offset = 0;
|
|
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_control_destination_fifo_id, tvb,
|
|
packet_offset, 4, destination_fifo_id );
|
|
packet_offset += sizeof(destination_fifo_id);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_control_source_fifo_id, tvb,
|
|
packet_offset, 4, source_fifo_id );
|
|
packet_offset += sizeof(source_fifo_id);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_control_socket_id, tvb,
|
|
packet_offset, 4, socket_id );
|
|
packet_offset += sizeof(socket_id);
|
|
|
|
}
|
|
|
|
if (tvb_reported_length_remaining(tvb, packet_offset) > 0)
|
|
{
|
|
tvb = tvb_new_subset(tvb, packet_offset, -1, -1);
|
|
|
|
switch( pPrivData->api_type )
|
|
{
|
|
case cOCTVOCNET_PKT_API_TYPE_ENUM_OCTVC1:
|
|
if( octvc1_ctrl_handle )
|
|
call_dissector(octvc1_ctrl_handle, tvb, pinfo, vocallonet_control_tree);
|
|
else
|
|
call_dissector(data_handle, tvb, pinfo, vocallonet_control_tree);
|
|
break;
|
|
|
|
default:
|
|
/* Dump the rest in raw format */
|
|
call_dissector(data_handle, tvb, pinfo, vocallonet_control_tree);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Code to actually dissect the Vocallo F format data packet header
|
|
*
|
|
**************************************************************************/
|
|
static void dissect_vocallonet_f_packet(tvbuff_t *tvb, proto_item *ti, packet_info *pinfo,
|
|
proto_tree *vocallonet_tree, unsigned int offset,
|
|
proto_tree *vocallonet_tree2 ,guint16 f_padding )
|
|
{
|
|
unsigned int packet_offset = offset;
|
|
guint32 timestamp;
|
|
guint32 subtype;
|
|
proto_tree* vocallonet_control_tree = NULL;
|
|
unsigned int layer_offset = 0;
|
|
tOctWsPrivateData * pPrivData = (tOctWsPrivateData *)pinfo->private_data;
|
|
|
|
/* Add summary display for the Vocallonet packet */
|
|
if ( check_col( pinfo->cinfo, COL_INFO) )
|
|
{
|
|
col_add_fstr( pinfo->cinfo, COL_INFO,
|
|
"OCTVOCNET F-packet format(%d), Size=%u bytes%s",
|
|
pPrivData->format,
|
|
pPrivData->total_packet_size,
|
|
pPrivData->trace_flag ? ", Trace" : "");
|
|
}
|
|
|
|
/* First, dissect the packet data fields */
|
|
dissect_vocallonet_packet_data(tvb, ti, vocallonet_tree2, packet_offset);
|
|
packet_offset += sizeof(tOCTVOCNET_PKT_DATA_HEADER); //
|
|
layer_offset = packet_offset;
|
|
|
|
timestamp = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(timestamp);
|
|
|
|
subtype = tvb_get_ntohl( tvb, packet_offset );
|
|
subtype = VOCALLONET_F_SUBTYPE(subtype);
|
|
packet_offset += sizeof(subtype);
|
|
|
|
if (vocallonet_tree)
|
|
{
|
|
|
|
/* Add the subtree for struct tOCTVOCNET_PKT_DATA_F_HEADER */
|
|
ti = proto_tree_add_item( vocallonet_tree, proto_vocallonet_f_data, tvb, layer_offset, pPrivData->total_packet_size - layer_offset, FALSE );
|
|
vocallonet_control_tree = proto_item_add_subtree( ti, ett_vocallonet_control );
|
|
|
|
|
|
/* Scroll back to the beginning of the packet */
|
|
packet_offset = offset + sizeof(tOCTVOCNET_PKT_DATA_HEADER);
|
|
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_f_timestamp, tvb,
|
|
packet_offset, sizeof(timestamp), timestamp );
|
|
packet_offset += sizeof(timestamp);
|
|
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_f_subtype, tvb,
|
|
packet_offset, sizeof(subtype), subtype );
|
|
packet_offset += sizeof(subtype);
|
|
}
|
|
|
|
/* Dissect the rest according to the packet subtype */
|
|
switch(subtype)
|
|
{
|
|
case cOCTVOCNET_PKT_SUBTYPE_API_EVENT:
|
|
{
|
|
if (tvb_reported_length_remaining(tvb, packet_offset) > 0)
|
|
{
|
|
tvb = tvb_new_subset(tvb, packet_offset, -1, -1);
|
|
|
|
switch( pPrivData->api_type )
|
|
{
|
|
case cOCTVOCNET_PKT_API_TYPE_ENUM_OCTVC1:
|
|
if( octvc1_event_handle )
|
|
call_dissector(octvc1_event_handle, tvb, pinfo, vocallonet_control_tree);
|
|
else
|
|
call_dissector(data_handle, tvb, pinfo, vocallonet_tree);
|
|
break;
|
|
|
|
default:
|
|
/* If any bytes remain, send it to the generic data dissector */
|
|
call_dissector(data_handle, tvb, pinfo, vocallonet_tree);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case cOCTVOCNET_PKT_SUBTYPE_UNSPECIFIED:
|
|
if( packet_f_decode == PACKET_F_LAPD )
|
|
{
|
|
guint32 length_remaining = tvb_reported_length_remaining(tvb, packet_offset);
|
|
if ( length_remaining > 0 )
|
|
{
|
|
tvb = tvb_new_subset(tvb, packet_offset, length_remaining - f_padding, length_remaining - f_padding );
|
|
call_dissector(lapd_handle , tvb, pinfo, vocallonet_tree);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case cOCTVOCNET_PKT_SUBTYPE_MODULE_DATA:
|
|
default:
|
|
{
|
|
/* If any bytes remain, send it to the generic data dissector */
|
|
if (tvb_reported_length_remaining(tvb, packet_offset) > 0)
|
|
{
|
|
tvb = tvb_new_subset(tvb, packet_offset, -1, -1);
|
|
call_dissector(data_handle, tvb, pinfo, vocallonet_tree);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Code to actually dissect the Vocallo Data_Fragment format data packet header
|
|
*
|
|
**************************************************************************/
|
|
static void dissect_vocallonet_data_fragment_packet(tvbuff_t *tvb, proto_item *ti, packet_info *pinfo,
|
|
proto_tree *vocallonet_tree, unsigned int offset,
|
|
proto_tree *vocallonet_tree2 ,guint16 f_padding )
|
|
{
|
|
unsigned int packet_offset = offset;
|
|
guint32 ulSequenceId;
|
|
guint32 ulTransfertTotalSize;
|
|
guint32 ulFragmentTotalNum;
|
|
guint32 ulFragmentId;
|
|
guint32 ulFragmentDataOffset;
|
|
guint32 ulFragmentDataSize;
|
|
guint32 ulUserId;
|
|
|
|
proto_tree* vocallonet_control_tree = NULL;
|
|
unsigned int layer_offset = 0;
|
|
tOctWsPrivateData * pPrivData = (tOctWsPrivateData *)pinfo->private_data;
|
|
|
|
/* Add summary display for the Vocallonet packet */
|
|
if ( check_col( pinfo->cinfo, COL_INFO) )
|
|
{
|
|
col_add_fstr( pinfo->cinfo, COL_INFO,
|
|
"OCTVOCNET DATA_FRAG-packet format(%d), Size=%u bytes%s",
|
|
pPrivData->format,
|
|
pPrivData->total_packet_size,
|
|
pPrivData->trace_flag ? ", Trace" : "");
|
|
}
|
|
|
|
/* First, dissect the packet f fields */
|
|
dissect_vocallonet_f_packet(tvb, ti, pinfo, vocallonet_tree, offset, vocallonet_tree2, f_padding);
|
|
|
|
packet_offset += sizeof(tOCTVOCNET_PKT_DATA_F_HEADER); //
|
|
layer_offset = packet_offset;
|
|
|
|
ulSequenceId = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulSequenceId);
|
|
ulTransfertTotalSize = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulTransfertTotalSize);
|
|
ulFragmentTotalNum = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulFragmentTotalNum);
|
|
ulFragmentId = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulFragmentId);
|
|
ulFragmentDataOffset = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulFragmentDataOffset);
|
|
ulFragmentDataSize = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulFragmentDataSize);
|
|
ulUserId = tvb_get_ntohl( tvb, packet_offset );
|
|
packet_offset += sizeof(ulUserId);
|
|
|
|
if (vocallonet_tree)
|
|
{
|
|
|
|
/* Add the subtree for struct tOCTVOCNET_PKT_DATA_F_HEADER */
|
|
ti = proto_tree_add_item( vocallonet_tree, proto_vocallonet_f_data, tvb, layer_offset, pPrivData->total_packet_size - layer_offset, FALSE );
|
|
vocallonet_control_tree = proto_item_add_subtree( ti, ett_vocallonet_control );
|
|
|
|
|
|
/* Scroll back to the beginning of the packet */
|
|
packet_offset = offset + sizeof(tOCTVOCNET_PKT_DATA_F_HEADER);
|
|
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_SequenceId, tvb, packet_offset, sizeof(ulSequenceId), ulSequenceId );
|
|
packet_offset += sizeof(ulSequenceId);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_TransfertTotalSize, tvb, packet_offset, sizeof(ulTransfertTotalSize), ulTransfertTotalSize );
|
|
packet_offset += sizeof(ulTransfertTotalSize);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_FragmentTotalNum, tvb, packet_offset, sizeof(ulFragmentTotalNum), ulFragmentTotalNum );
|
|
packet_offset += sizeof(ulFragmentTotalNum);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_FragmentId, tvb, packet_offset, sizeof(ulFragmentId), ulFragmentId );
|
|
packet_offset += sizeof(ulFragmentId);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_FragmentDataOffset, tvb, packet_offset, sizeof(ulFragmentDataOffset), ulFragmentDataOffset );
|
|
packet_offset += sizeof(ulFragmentDataOffset);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_FragmentDataSize, tvb, packet_offset, sizeof(ulFragmentDataSize), ulFragmentDataSize );
|
|
packet_offset += sizeof(ulFragmentDataSize);
|
|
proto_tree_add_uint( vocallonet_control_tree, hf_vocallonet_d_frag_UserId, tvb, packet_offset, sizeof(ulUserId), ulUserId );
|
|
packet_offset += sizeof(ulUserId);
|
|
|
|
}
|
|
}
|
|
/*************************************************************************
|
|
*
|
|
* Code to actually dissect the Vocallo common packet header
|
|
*
|
|
**************************************************************************/
|
|
static void dissect_vocallonet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
{
|
|
proto_item* ti = NULL;
|
|
proto_tree* vocallonet_tree = tree;
|
|
unsigned int offset = 0;
|
|
guint8 format;
|
|
tOctWsPrivateData *pPrivData;
|
|
|
|
/* Should be set by octpkt dissector */
|
|
if( pinfo->private_data == NULL )
|
|
{
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "OCTVOCNET_PKT_FORMAT ERROR" );
|
|
|
|
expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR, "OCTVOCNET_PKT_FORMAT ERROR" );
|
|
call_dissector(data_handle, tvb, pinfo, tree);
|
|
return;
|
|
}
|
|
|
|
/* Make entries in Protocol column and Info column on summary display */
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "OCTVOCNET_PKT_FORMAT" );
|
|
|
|
pPrivData = (tOctWsPrivateData *)pinfo->private_data;
|
|
format = pPrivData->format;
|
|
|
|
|
|
/* Dissect the relevant packet format */
|
|
switch( format )
|
|
{
|
|
case cOCTVOCNET_PKT_FORMAT_CTRL:
|
|
{
|
|
/* Append to get funny size...? */
|
|
if( pPrivData->total_packet_size )
|
|
{
|
|
tvb = tvb_new_subset(tvb, offset, -1, -1);
|
|
dissect_vocallonet_control(tvb, pinfo, tree);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case cOCTVOCNET_PKT_FORMAT_DATA_FRAGMENT:
|
|
{
|
|
dissect_vocallonet_data_fragment_packet(tvb, ti, pinfo, tree, offset, vocallonet_tree, pPrivData->padding);
|
|
}
|
|
break;
|
|
|
|
case cOCTVOCNET_PKT_FORMAT_F:
|
|
{
|
|
dissect_vocallonet_f_packet(tvb, ti, pinfo, tree, offset, vocallonet_tree, pPrivData->padding);
|
|
}
|
|
break;
|
|
|
|
|
|
default:
|
|
{
|
|
/* If any bytes remain, send it to the generic data dissector */
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
{
|
|
tvb = tvb_new_subset(tvb, offset, -1, -1);
|
|
call_dissector(data_handle, tvb, pinfo, tree);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* Code to register the protocol with Wireshark
|
|
*
|
|
**************************************************************************/
|
|
void proto_register_vocallonet(void)
|
|
{
|
|
/* Setup list of header fields */
|
|
static hf_register_info hf_vocallonet[] =
|
|
{
|
|
{ &hf_vocallonet_format,
|
|
{ "Format", "vocallonet.format",
|
|
FT_UINT32, BASE_HEX, VALS(vocallonet_format_vals), 0xff000000,
|
|
"Vocallonet packet format", HFILL }
|
|
},
|
|
{ &hf_vocallonet_trace_flag,
|
|
{ "Trace", "vocallonet.trace_flag",
|
|
FT_BOOLEAN, 32, NULL, 0x00800000,
|
|
"Debug trace flag", HFILL }
|
|
},
|
|
{ &hf_vocallonet_api_type,
|
|
{ "API Type", "vocallonet.api_type",
|
|
FT_UINT32, BASE_HEX, VALS(vocallonet_api_type_vals), 0x00007800,
|
|
"API Type", HFILL }
|
|
},
|
|
|
|
{ &hf_vocallonet_size,
|
|
{ "Size", "vocallonet.size_in_bytes",
|
|
FT_UINT32, BASE_DEC, NULL, 0x000003ff,
|
|
"Total bit length", HFILL }
|
|
}
|
|
};
|
|
|
|
|
|
static hf_register_info hf_vocallonet_data[] =
|
|
{
|
|
/* Common packet data fields */
|
|
{ &hf_vocallonet_data_logical_object_handle,
|
|
{ "Object Handle ", "vocallonet.data.logical_object_handle",
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
"Logical object handle ", HFILL }
|
|
},
|
|
{ &hf_vocallonet_data_packet_port,
|
|
{ "Logical Object Packet Port Packet", "vocallonet.data.packet_port",
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
"Packet port index", HFILL }
|
|
},
|
|
{ &hf_vocallonet_data_dest_fifo_id,
|
|
{ "Destination FIFO ID", "vocallonet.data.dest_fifo_id",
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
"Destination FIFO ID", HFILL }
|
|
},
|
|
};
|
|
|
|
|
|
|
|
|
|
static hf_register_info hf_vocallonet_f_data[] =
|
|
{
|
|
/* Packet format F fields (raw) */
|
|
{ &hf_vocallonet_f_timestamp,
|
|
{ "Timestamp", "vocallonet.f.timestamp",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet timestamp", HFILL }
|
|
},
|
|
{ &hf_vocallonet_f_subtype,
|
|
{ "Subtype", "vocallonet.f.subtype",
|
|
FT_UINT32, BASE_HEX, VALS(vocallonet_f_subtype_vals), 0,
|
|
"Packet subtype", HFILL }
|
|
},
|
|
};
|
|
|
|
static hf_register_info hf_vocallonet_d_frag_data[] =
|
|
{
|
|
/* Packet format F fields (raw) */
|
|
{ &hf_vocallonet_d_frag_SequenceId,
|
|
{ "SequenceId", "vocallonet.d_frag.SequenceId",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet SequenceId", HFILL }
|
|
},
|
|
{ &hf_vocallonet_d_frag_TransfertTotalSize,
|
|
{ "TransfertTotalSize", "vocallonet.d_frag.TransfertTotalSize",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet TransfertTotalSize", HFILL }
|
|
},
|
|
{ &hf_vocallonet_d_frag_FragmentTotalNum,
|
|
{ "FragmentTotalNum", "vocallonet.d_frag.FragmentTotalNum",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet FragmentTotalNum", HFILL }
|
|
},
|
|
{ &hf_vocallonet_d_frag_FragmentId,
|
|
{ "FragmentId", "vocallonet.d_frag.FragmentId",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet FragmentId", HFILL }
|
|
},
|
|
{ &hf_vocallonet_d_frag_FragmentDataOffset,
|
|
{ "FragmentDataOffset", "vocallonet.d_frag.FragmentDataOffset",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet FragmentDataOffset", HFILL }
|
|
},
|
|
{ &hf_vocallonet_d_frag_FragmentDataSize,
|
|
{ "FragmentDataSize", "vocallonet.d_frag.FragmentDataSize",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet FragmentDataSize", HFILL }
|
|
},
|
|
{ &hf_vocallonet_d_frag_UserId,
|
|
{ "UserId", "vocallonet.d_frag.UserId",
|
|
FT_UINT32, BASE_HEX, NULL, 0,
|
|
"Packet UserId", HFILL }
|
|
},
|
|
};
|
|
|
|
|
|
static hf_register_info hf_vocallonet_control[] = {
|
|
|
|
{ &hf_vocallonet_control_destination_fifo_id,
|
|
{ "Destination Fifo Id", "vocallonet.control.destination_fifo_id",
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
"Destination fifo id", HFILL }
|
|
},
|
|
{ &hf_vocallonet_control_source_fifo_id,
|
|
{ "Source Fifo Id", "vocallonet.control.source_fifo_id",
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
"Source fifo id", HFILL }
|
|
},
|
|
{ &hf_vocallonet_control_socket_id,
|
|
{ "Socket Id", "vocallonet.control.socket_id",
|
|
FT_UINT32, BASE_HEX, NULL, 0x0,
|
|
"Return socket Id", HFILL }
|
|
},
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Setup protocol subtree array */
|
|
static gint* ett[] =
|
|
{
|
|
|
|
&ett_vocallonet,
|
|
&ett_vocallonet_control,
|
|
&ett_vocallonet_data,
|
|
&ett_vocallonet_d_frag_data,
|
|
&ett_vocallonet_f_data,
|
|
|
|
};
|
|
|
|
|
|
|
|
module_t *vocallonet_module;
|
|
|
|
static enum_val_t options[] = {
|
|
{ "Unspecified", "Unspecified", PACKET_F_UNSPECIFIED },
|
|
{ "Lapd", "Lapd", PACKET_F_LAPD },
|
|
{ NULL, NULL, 0 }
|
|
};
|
|
|
|
/* Register the protocol name and description */
|
|
proto_vocallonet = proto_register_protocol( "Vocallonet packets",
|
|
"Octasic Vocallonet", "vocallonet");
|
|
|
|
proto_vocallonet_control = proto_register_protocol("Vocallo control packets",
|
|
"Octasic Vocallonet Control", "vocallonet_ctrl");
|
|
|
|
proto_vocallonet_data = proto_register_protocol( "Vocallo data packet",
|
|
"Octasic Vocallonet Data", "vocallonet_data");
|
|
|
|
|
|
proto_vocallonet_d_frag_data = proto_register_protocol( "Vocallo Data_Frag format data packet",
|
|
"Octasic Vocallonet Data_Frag", "vocallonet_frag_data");
|
|
|
|
proto_vocallonet_f_data = proto_register_protocol( "Vocallo F format data packet",
|
|
"Octasic Vocallonet F-Data", "vocallonet_f_data");
|
|
|
|
proto_vocallonet_ev_data = proto_register_protocol( "Vocallo Event format packet",
|
|
"Octasic Vocallonet Event", "vocallonet_ev_data");
|
|
|
|
vocallonet_module = prefs_register_protocol(proto_vocallonet, NULL);
|
|
prefs_register_enum_preference(vocallonet_module, "packet_f", "Packet F unspecified decode", "Type of F packet", &packet_f_decode, options, FALSE);
|
|
|
|
|
|
/* Required function calls to register the header fields and subtrees used */
|
|
proto_register_field_array( proto_vocallonet, hf_vocallonet, array_length(hf_vocallonet) );
|
|
proto_register_field_array( proto_vocallonet_control, hf_vocallonet_control, array_length(hf_vocallonet_control) );
|
|
|
|
proto_register_field_array( proto_vocallonet_data, hf_vocallonet_data, array_length(hf_vocallonet_data) );
|
|
proto_register_field_array( proto_vocallonet_d_frag_data, hf_vocallonet_d_frag_data, array_length(hf_vocallonet_d_frag_data) );
|
|
proto_register_field_array( proto_vocallonet_f_data, hf_vocallonet_f_data, array_length(hf_vocallonet_f_data) );
|
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
register_dissector("vocallonet", dissect_vocallonet, proto_vocallonet);
|
|
|
|
}
|
|
|
|
/*************************************************************************
|
|
*
|
|
* 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_vocallonet(void)
|
|
{
|
|
data_handle = find_dissector("data");
|
|
octvc1_ctrl_handle = find_dissector("Octvc1_Ctrl");
|
|
|
|
octvc1_event_handle = find_dissector("Octvc1_Event");
|
|
octpkt_handle = find_dissector("OctPkt");
|
|
|
|
}
|
|
|