2010-10-25 01:43:54 +00:00
/* packet-adwin-config.c
* Routines for ADwin configuration protocol dissection
* Copyright 2010 , Thomas Boehne < TBoehne [ AT ] ADwin . 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 <string.h>
# include <glib.h>
# include <epan/packet.h>
# include <epan/proto.h>
# include <epan/emem.h>
# include <epan/dissectors/packet-tcp.h>
# include <epan/ipproto.h>
/* This is registered to a different protocol */
# define ADWIN_CONFIGURATION_PORT 7000
# define UDPStatusLENGTH 52
# define UDPExtStatusLENGTH 432
# define UDPMessageLENGTH 100
# define UDPMessageLENGTH_wrong 104
# define UDPInitAckLENGTH 96
# define UDPIXP425FlashUpdateLENGTH 92
# define UDPOutLENGTH 22
# define STATUS_WITH_BOOTLOADER 0x0001
# define STATUS_REPROGRAMMABLE 0x0002
# define STATUS_CONFIGURABLE 0x0004
# define STATUS_BOOTLOADER_BOOTS 0x0008
# define STATUS_BOOTLOADER_REPROGRAMMABLE 0x0010
# define STATUS_BOOTLOADER_RECEIVES_DATA 0x0020
# define STATUS_BOOTLOADER_REPROGRAMMING_DONE 0x0040
# define STATUS_WITH_EEPROM_SUPPORT 0x0080
static const value_string pattern_mapping [ ] = {
{ 0x12343210 , " Reset reset/socket counters " } ,
{ 0x73241291 , " Scan Netarm + IXP " } ,
{ 0x37241291 , " Scan IXP " } ,
{ 0 , NULL } ,
} ;
static const value_string config_command_mapping [ ] = {
{ 100 , " Apply all config values except MAC if MAC matches. " } ,
{ 105 , " Apply all config values including MAC if current MAC is 00:50:C2:0A:22:EE. " } ,
{ 110 , " Apply all config values including MAC. " } ,
{ 120 , " Enable/Disable bootloader if MAC matches. " } ,
{ 130 , " Write extended hardware info to EEPROM. " } ,
{ 0 , NULL } ,
} ;
static const string_string system_type_mapping [ ] = {
{ " 01 " , " Light 16 " } ,
{ " 02 " , " Gold " } ,
{ " 03 " , " Pro I " } ,
{ " 04 " , " Pro II " } ,
{ " 05 " , " Gold II " } ,
{ 0 , NULL } ,
} ;
static const string_string processor_type_mapping [ ] = {
{ " 09 " , " T9 " } ,
{ " 10 " , " T10 " } ,
{ " 11 " , " T11 " } ,
{ 0 , NULL } ,
} ;
/* add little endian number (incorrect byte-order) value to a tree */
# define ADWIN_ADD_LE(tree, field, offset, length) \
proto_tree_add_item ( tree , hf_adwin_config_ # # field , tvb , offset , \
2010-10-28 16:46:38 +00:00
length , ENC_LITTLE_ENDIAN ) ;
2010-10-25 01:43:54 +00:00
/* add big endian number (correct byte-order) value to a tree */
# define ADWIN_ADD_BE(tree, field, offset, length) \
proto_tree_add_item ( tree , hf_adwin_config_ # # field , tvb , offset , \
2010-10-28 16:46:38 +00:00
length , ENC_BIG_ENDIAN ) ;
2010-10-25 01:43:54 +00:00
/* Initialize the protocol and registered fields */
static int proto_adwin_config = - 1 ;
static int hf_adwin_config_bootloader = - 1 ;
static int hf_adwin_config_command = - 1 ;
static int hf_adwin_config_data = - 1 ;
static int hf_adwin_config_date = - 1 ;
static int hf_adwin_config_description = - 1 ;
static int hf_adwin_config_dhcp8 = - 1 ;
static int hf_adwin_config_dhcp16 = - 1 ;
static int hf_adwin_config_dhcp32 = - 1 ;
static int hf_adwin_config_filename = - 1 ;
static int hf_adwin_config_filesize = - 1 ;
static int hf_adwin_config_gateway = - 1 ;
static int hf_adwin_config_mac = - 1 ;
static int hf_adwin_config_netmask_count = - 1 ;
static int hf_adwin_config_netmask = - 1 ;
static int hf_adwin_config_password = - 1 ;
static int hf_adwin_config_path = - 1 ;
static int hf_adwin_config_pattern = - 1 ;
static int hf_adwin_config_port16 = - 1 ;
static int hf_adwin_config_port32 = - 1 ;
static int hf_adwin_config_reboot = - 1 ;
static int hf_adwin_config_scan_id = - 1 ;
static int hf_adwin_config_reply_broadcast = - 1 ;
static int hf_adwin_config_revision = - 1 ;
static int hf_adwin_config_processor_type = - 1 ;
static int hf_adwin_config_system_type = - 1 ;
static int hf_adwin_config_server_ip = - 1 ;
static int hf_adwin_config_server_version = - 1 ;
static int hf_adwin_config_server_version_beta = - 1 ;
static int hf_adwin_config_socketshutdowns = - 1 ;
static int hf_adwin_config_status = - 1 ;
static int hf_adwin_config_status_bootloader = - 1 ;
static int hf_adwin_config_status_reprogrammable = - 1 ;
static int hf_adwin_config_status_configurable = - 1 ;
static int hf_adwin_config_status_bootloader_boots = - 1 ;
static int hf_adwin_config_status_bootloader_reprogrammable = - 1 ;
static int hf_adwin_config_status_bootloader_receive = - 1 ;
static int hf_adwin_config_status_bootloader_reprogramming_done = - 1 ;
static int hf_adwin_config_status_eeprom_support = - 1 ;
static int hf_adwin_config_stream_length = - 1 ;
static int hf_adwin_config_timeout = - 1 ;
static int hf_adwin_config_timerresets = - 1 ;
static int hf_adwin_config_disk_free = - 1 ;
static int hf_adwin_config_disk_size = - 1 ;
static int hf_adwin_config_unused = - 1 ;
static int hf_adwin_config_version = - 1 ;
static int hf_adwin_config_xilinx_version = - 1 ;
/* Initialize the subtree pointers */
static gint ett_adwin_config = - 1 ;
static gint ett_adwin_config_status = - 1 ;
static gint ett_adwin_config_debug = - 1 ;
static void
dissect_UDPStatus ( tvbuff_t * tvb , proto_tree * adwin_tree )
{
proto_tree * status_tree ;
proto_tree * debug_tree ;
proto_item * st , * dt ;
if ( ! adwin_tree )
return ;
2010-10-28 16:54:04 +00:00
dt = proto_tree_add_item ( adwin_tree , proto_adwin_config , tvb , 0 , - 1 , ENC_NA ) ;
2010-10-25 01:43:54 +00:00
debug_tree = proto_item_add_subtree ( dt , ett_adwin_config_debug ) ;
proto_item_set_text ( dt , " ADwin Debug information " ) ;
ADWIN_ADD_BE ( adwin_tree , pattern , 0 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , version , 4 , 4 ) ;
st = ADWIN_ADD_BE ( adwin_tree , status , 8 , 4 ) ;
status_tree = proto_item_add_subtree ( st , ett_adwin_config_status ) ;
ADWIN_ADD_BE ( status_tree , status_bootloader , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_reprogrammable , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_configurable , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_bootloader_boots , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_bootloader_reprogrammable , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_bootloader_receive , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_bootloader_reprogramming_done , 8 , 4 ) ;
ADWIN_ADD_BE ( status_tree , status_eeprom_support , 8 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , server_version_beta , 12 , 2 ) ;
ADWIN_ADD_BE ( adwin_tree , server_version , 14 , 2 ) ;
ADWIN_ADD_BE ( adwin_tree , xilinx_version , 16 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , mac , 20 , 6 ) ;
ADWIN_ADD_LE ( debug_tree , unused , 26 , 2 ) ;
ADWIN_ADD_BE ( adwin_tree , port16 , 28 , 2 ) ;
ADWIN_ADD_LE ( adwin_tree , dhcp8 , 30 , 1 ) ;
ADWIN_ADD_LE ( adwin_tree , netmask_count , 31 , 1 ) ;
ADWIN_ADD_BE ( adwin_tree , gateway , 32 , 4 ) ;
ADWIN_ADD_LE ( debug_tree , unused , 36 , 11 ) ;
ADWIN_ADD_LE ( adwin_tree , reply_broadcast , 47 , 1 ) ;
ADWIN_ADD_LE ( adwin_tree , scan_id , 48 , 4 ) ;
}
static void
dissect_UDPExtStatus ( tvbuff_t * tvb , proto_tree * adwin_tree )
{
const gchar * processor_type , * system_type ;
if ( ! adwin_tree )
return ;
ADWIN_ADD_BE ( adwin_tree , mac , 0 , 6 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 6 , 2 ) ;
ADWIN_ADD_BE ( adwin_tree , pattern , 8 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , version , 12 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , description , 16 , 16 ) ;
ADWIN_ADD_BE ( adwin_tree , timerresets , 32 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , socketshutdowns , 36 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , disk_free , 40 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , disk_size , 44 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , date , 48 , 8 ) ;
ADWIN_ADD_LE ( adwin_tree , revision , 56 , 8 ) ;
/* add the processor type raw values to the tree, to allow filtering */
ADWIN_ADD_LE ( adwin_tree , processor_type , 64 , 2 ) ;
/* add the processor type as a pretty printed string */
processor_type = tvb_get_ephemeral_string ( tvb , 64 , 2 ) ;
processor_type = str_to_str ( processor_type , processor_type_mapping , " Unknown (%s) " ) ;
proto_tree_add_text ( adwin_tree , tvb , 64 , 2 , " Processor Type: %s " , processor_type ) ;
/* add system type as raw value and pretty printed string */
ADWIN_ADD_LE ( adwin_tree , system_type , 66 , 2 ) ;
system_type = tvb_get_ephemeral_string ( tvb , 66 , 2 ) ;
system_type = str_to_str ( system_type , system_type_mapping , " Unknown (%s) " ) ;
proto_tree_add_text ( adwin_tree , tvb , 66 , 2 , " System Type: %s " , system_type ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 68 , 364 ) ;
}
static void
dissect_UDPMessage ( tvbuff_t * tvb , proto_tree * adwin_tree )
{
const gchar * processor_type , * system_type ;
if ( ! adwin_tree )
return ;
ADWIN_ADD_LE ( adwin_tree , command , 0 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , version , 4 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , mac , 8 , 6 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 14 , 2 ) ;
ADWIN_ADD_LE ( adwin_tree , server_ip , 16 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 20 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , netmask , 24 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 28 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , gateway , 32 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 36 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , dhcp32 , 40 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , port32 , 44 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , password , 48 , 10 ) ;
ADWIN_ADD_LE ( adwin_tree , bootloader , 58 , 1 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 59 , 5 ) ;
ADWIN_ADD_LE ( adwin_tree , description , 64 , 16 ) ;
ADWIN_ADD_LE ( adwin_tree , date , 80 , 8 ) ;
ADWIN_ADD_LE ( adwin_tree , revision , 88 , 8 ) ;
/* add the processor type raw values to the tree, to allow filtering */
ADWIN_ADD_LE ( adwin_tree , processor_type , 96 , 2 ) ;
/* add the processor type as a pretty printed string */
processor_type = tvb_get_ephemeral_string ( tvb , 96 , 2 ) ;
processor_type = str_to_str ( processor_type , processor_type_mapping , " Unknown " ) ;
proto_tree_add_text ( adwin_tree , tvb , 96 , 2 , " Processor Type: %s " , processor_type ) ;
/* add system type as raw value and pretty printed string */
ADWIN_ADD_LE ( adwin_tree , system_type , 98 , 2 ) ;
system_type = tvb_get_ephemeral_string ( tvb , 98 , 2 ) ;
system_type = str_to_str ( system_type , system_type_mapping , " Unknown " ) ;
proto_tree_add_text ( adwin_tree , tvb , 98 , 2 , " System Type: %s " , system_type ) ;
}
static void
dissect_UDPInitAck ( tvbuff_t * tvb , proto_tree * adwin_tree )
{
if ( ! adwin_tree )
return ;
ADWIN_ADD_BE ( adwin_tree , pattern , 0 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , reboot , 4 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , mac , 8 , 6 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 14 , 2 ) ;
ADWIN_ADD_LE ( adwin_tree , unused , 16 , 80 ) ;
}
static void
dissect_UDPIXP425FlashUpdate ( tvbuff_t * tvb , proto_tree * adwin_tree )
{
if ( ! adwin_tree )
return ;
ADWIN_ADD_BE ( adwin_tree , pattern , 0 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , version , 4 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , scan_id , 8 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , status , 12 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , timeout , 16 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , filename , 20 , 24 ) ;
ADWIN_ADD_BE ( adwin_tree , mac , 44 , 6 ) ;
ADWIN_ADD_BE ( adwin_tree , unused , 50 , 42 ) ;
}
static void
dissect_UDPOut ( tvbuff_t * tvb , proto_tree * adwin_tree )
{
if ( ! adwin_tree )
return ;
ADWIN_ADD_LE ( adwin_tree , status , 0 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , mac , 4 , 6 ) ;
ADWIN_ADD_LE ( adwin_tree , netmask , 10 , 4 ) ;
ADWIN_ADD_BE ( adwin_tree , gateway , 14 , 4 ) ;
ADWIN_ADD_LE ( adwin_tree , dhcp16 , 18 , 2 ) ;
ADWIN_ADD_BE ( adwin_tree , port16 , 20 , 2 ) ;
}
static guint
get_adwin_TCPUpdate_len ( packet_info * pinfo _U_ , tvbuff_t * tvb , int offset )
{
/*
* Return the length of the packet . ( Doesn ' t include the length field itself )
*/
return tvb_get_ntohl ( tvb , offset ) ;
}
static void
dissect_TCPFlashUpdate ( tvbuff_t * tvb , packet_info * pinfo _U_ , proto_tree * adwin_tree )
{
gint length , offset ;
guint8 * filename ;
nstime_t tmp_time ;
tmp_time . nsecs = 0 ;
if ( ! adwin_tree )
return ;
ADWIN_ADD_BE ( adwin_tree , stream_length , 0 , 4 ) ;
offset = 4 ;
length = tvb_strnlen ( tvb , offset , - 1 ) + 1 ;
filename = tvb_get_ephemeral_string ( tvb , offset , length ) ;
if ( strncmp ( filename , " eeprom_on " , length ) = = 0 ) {
proto_tree_add_text ( adwin_tree , tvb , offset , length ,
" Enable EEPROM Support " ) ;
return ;
}
if ( strncmp ( filename , " eeprom_off " , length ) = = 0 ) {
proto_tree_add_text ( adwin_tree , tvb , offset , length ,
" Disable EEPROM Support " ) ;
return ;
}
ADWIN_ADD_BE ( adwin_tree , filename , 4 , length ) ;
offset + = length ;
length = tvb_strnlen ( tvb , 4 + length , - 1 ) + 1 ;
ADWIN_ADD_BE ( adwin_tree , path , offset , length ) ;
offset + = length ;
ADWIN_ADD_BE ( adwin_tree , filesize , offset , 4 ) ;
offset + = 4 ;
tmp_time . secs = tvb_get_ntohl ( tvb , offset ) ;
proto_tree_add_text ( adwin_tree , tvb , offset , 4 ,
" File time: %s " , abs_time_to_str ( & tmp_time , ABSOLUTE_TIME_LOCAL , TRUE ) ) ;
offset + = 4 ;
tmp_time . secs = tvb_get_ntohl ( tvb , offset ) ;
proto_tree_add_text ( adwin_tree , tvb , offset , 4 ,
" Update time: %s " , abs_time_to_str ( & tmp_time , ABSOLUTE_TIME_LOCAL , TRUE ) ) ;
offset + = 4 ;
ADWIN_ADD_BE ( adwin_tree , unused , offset , 128 ) ;
offset + = 128 ;
length = tvb_length ( tvb ) - offset ;
ADWIN_ADD_BE ( adwin_tree , data , offset , length ) ;
}
2010-10-27 00:42:02 +00:00
/* 00:50:c2:0a:2*:** */
static char mac_iab_start [ ] = { 0x00 , 0x50 , 0xc2 , 0x0a , 0x20 , 0x00 } ;
static char mac_iab_end [ ] = { 0x00 , 0x50 , 0xc2 , 0x0a , 0x2f , 0xff } ;
/* 00:22:71:**:**:** */
static char mac_oui_start [ ] = { 0x00 , 0x22 , 0x71 , 0x00 , 0x00 , 0x00 } ;
static char mac_oui_end [ ] = { 0x00 , 0x22 , 0x71 , 0xff , 0xff , 0xff } ;
/* ff:ff:ff:ff:ff:ff */
static char mac_broadcast [ ] = { 0xff , 0xff , 0xff , 0xff , 0xff , 0xff } ;
/* return TRUE if mac is in mac address range assigned to ADwin or if
* mac is broadcast */
static gboolean
is_adwin_mac_or_broadcast ( address mac )
{
if ( mac . type ! = AT_ETHER )
return FALSE ;
if ( mac . len ! = 6 ) /* length of MAC address */
return FALSE ;
if ( ( memcmp ( mac . data , mac_iab_start , mac . len ) > = 0 ) & &
( memcmp ( mac . data , mac_iab_end , mac . len ) < = 0 ) )
return TRUE ;
if ( ( memcmp ( mac . data , mac_oui_start , mac . len ) > = 0 ) & &
( memcmp ( mac . data , mac_oui_end , mac . len ) < = 0 ) )
return TRUE ;
/* adwin configuration protocol uses MAC broadcasts for
device discovery */
if ( memcmp ( mac . data , mac_broadcast , mac . len ) = = 0 )
return TRUE ;
return FALSE ;
}
2010-10-25 01:43:54 +00:00
/* Here we determine which type of packet is sent by looking at its
size . Let ' s hope that future ADwin packets always differ in size .
They probably will , since the server classifies the packets
according to their sizes , too . */
static const value_string length_mapping [ ] = {
{ UDPStatusLENGTH , " UDPStatus " } ,
{ UDPExtStatusLENGTH , " UDPExtStatus " } ,
{ UDPMessageLENGTH , " UDPMessage " } ,
{ UDPMessageLENGTH_wrong , " UDPMessage (broken - upgrade ADConfig!) " } ,
{ UDPInitAckLENGTH , " UDPInitAck " } ,
{ UDPIXP425FlashUpdateLENGTH , " UDPIXP425FlashUpdate " } ,
{ UDPOutLENGTH , " UDPOut " } ,
{ 0 , NULL } ,
} ;
/* Depending on the packet type, the appropriate dissector is called. */
static int
dissect_adwin_config ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree )
{
proto_item * ti ;
proto_tree * adwin_config_tree ;
guint32 length ;
length = tvb_reported_length ( tvb ) ;
if ( pinfo - > ipproto = = IP_PROTO_UDP & &
! ( length = = UDPStatusLENGTH
| | length = = UDPExtStatusLENGTH
| | length = = UDPMessageLENGTH
| | length = = UDPMessageLENGTH_wrong
| | length = = UDPInitAckLENGTH
| | length = = UDPIXP425FlashUpdateLENGTH
| | length = = UDPOutLENGTH ) )
2010-10-27 00:42:02 +00:00
return 0 ;
2010-10-25 01:43:54 +00:00
if ( pinfo - > ipproto = = IP_PROTO_TCP & &
! ( pinfo - > srcport = = ADWIN_CONFIGURATION_PORT
| | pinfo - > destport = = ADWIN_CONFIGURATION_PORT ) )
2010-10-27 00:42:02 +00:00
return 0 ;
2010-10-25 17:17:52 +00:00
if ( pinfo - > ipproto ! = IP_PROTO_UDP & & pinfo - > ipproto ! = IP_PROTO_TCP )
2010-10-27 00:42:02 +00:00
return 0 ;
if ( ! ( is_adwin_mac_or_broadcast ( pinfo - > dl_src ) | | is_adwin_mac_or_broadcast ( pinfo - > dl_dst ) ) )
return 0 ;
2010-10-25 01:43:54 +00:00
col_set_str ( pinfo - > cinfo , COL_PROTOCOL , " ADwin Config " ) ;
col_clear ( pinfo - > cinfo , COL_INFO ) ;
if ( tree ) {
2010-10-28 16:54:04 +00:00
ti = proto_tree_add_item ( tree , proto_adwin_config , tvb , 0 , - 1 , ENC_NA ) ;
2010-10-25 01:43:54 +00:00
adwin_config_tree = proto_item_add_subtree ( ti , ett_adwin_config ) ;
} else {
adwin_config_tree = NULL ;
}
switch ( pinfo - > ipproto ) {
case IP_PROTO_TCP :
tcp_dissect_pdus ( tvb , pinfo , tree , 1 , 4 , get_adwin_TCPUpdate_len , dissect_TCPFlashUpdate ) ;
col_set_str ( pinfo - > cinfo , COL_INFO , " TCPFlashUpdate " ) ;
break ;
case IP_PROTO_UDP :
switch ( length ) {
case UDPStatusLENGTH :
dissect_UDPStatus ( tvb , adwin_config_tree ) ;
break ;
case UDPExtStatusLENGTH :
dissect_UDPExtStatus ( tvb , adwin_config_tree ) ;
break ;
case UDPMessageLENGTH :
dissect_UDPMessage ( tvb , adwin_config_tree ) ;
break ;
case UDPMessageLENGTH_wrong : /* incorrect packet length */
/* formerly used by adconfig */
dissect_UDPMessage ( tvb , adwin_config_tree ) ;
break ;
case UDPInitAckLENGTH :
dissect_UDPInitAck ( tvb , adwin_config_tree ) ;
break ;
case UDPIXP425FlashUpdateLENGTH :
dissect_UDPIXP425FlashUpdate ( tvb , adwin_config_tree ) ;
break ;
case UDPOutLENGTH :
dissect_UDPOut ( tvb , adwin_config_tree ) ;
break ;
default :
/* Heuristics above should mean we never get here */
DISSECTOR_ASSERT_NOT_REACHED ( ) ;
}
2010-10-27 00:42:02 +00:00
if ( check_col ( pinfo - > cinfo , COL_INFO ) )
2010-10-25 01:43:54 +00:00
col_add_str ( pinfo - > cinfo , COL_INFO ,
val_to_str ( length , length_mapping ,
" Unknown ADwin Configuration packet, length: %d " ) ) ;
}
return ( tvb_reported_length ( tvb ) ) ;
}
void
proto_register_adwin_config ( void )
{
static hf_register_info hf [ ] = {
{ & hf_adwin_config_bootloader ,
{ " Enable Bootloader " , " adwin_config.bootloader " ,
FT_BOOLEAN , BASE_DEC , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_command ,
{ " Command " , " adwin_config.command " ,
FT_UINT32 , BASE_DEC , config_command_mapping , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_data ,
{ " Data " , " adwin_config.data " ,
FT_NONE , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_date ,
{ " Date " , " adwin_config.date " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_description ,
{ " Description " , " adwin_config.description " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_dhcp8 ,
{ " DHCP enabled " , " adwin_config.dhcp " ,
FT_BOOLEAN , 8 , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_dhcp16 ,
{ " DHCP enabled " , " adwin_config.dhcp " ,
FT_BOOLEAN , 16 , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_dhcp32 ,
{ " DHCP enabled " , " adwin_config.dhcp " ,
FT_BOOLEAN , 32 , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_filename ,
{ " File name " , " adwin_config.filename " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_filesize ,
{ " File size " , " adwin_config.filesize " ,
FT_INT32 , BASE_DEC , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_gateway ,
{ " Gateway IP " , " adwin_config.gateway " ,
FT_IPv4 , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_mac ,
{ " MAC address " , " adwin_config.mac " ,
FT_ETHER , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_netmask ,
{ " Netmask " , " adwin_config.netmask " ,
FT_IPv4 , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_netmask_count ,
{ " Netmask count " , " adwin_config.netmask_count " ,
FT_UINT8 , BASE_DEC , NULL , 0x0 ,
" The number of binary ones in the netmask. " , HFILL }
} ,
{ & hf_adwin_config_password ,
{ " Password " , " adwin_config.password " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
" Password to set for ADwin system. " , HFILL }
} ,
{ & hf_adwin_config_pattern ,
{ " Pattern " , " adwin_config.pattern " ,
FT_UINT32 , BASE_HEX , pattern_mapping , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_path ,
{ " Path " , " adwin_config.path " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_port16 ,
{ " Port (16bit) " , " adwin_config.port " ,
FT_UINT16 , BASE_DEC , NULL , 0x0 ,
" The server port on which the ADwin system is listening on (16bit). " , HFILL }
} ,
{ & hf_adwin_config_port32 ,
{ " Port (32bit) " , " adwin_config.port " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" The server port on which the ADwin system is listening on (32bit). " , HFILL }
} ,
{ & hf_adwin_config_reboot ,
{ " Reboot " , " adwin_config.reboot " ,
FT_BOOLEAN , 32 , NULL , 0x0 ,
" Number of system reboots. " , HFILL }
} ,
{ & hf_adwin_config_scan_id ,
{ " Scan ID " , " adwin_config.scan_id " ,
FT_UINT32 , BASE_HEX , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_reply_broadcast , /* send_normal in UDPStatus */
{ " Reply with broadcast " , " adwin_config.reply_broadcast " ,
FT_BOOLEAN , 8 , NULL , 0x0 ,
" If this bit is set, the scanned system should reply with a broadcast. " , HFILL }
} ,
{ & hf_adwin_config_revision ,
{ " Revision " , " adwin_config.revision " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_processor_type ,
{ " Processor Type (Raw value) " , " adwin_config.processor_type " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
" The DSP processor type of the ADwin system, e.g. T9, T10 or T11. " , HFILL }
} ,
{ & hf_adwin_config_system_type ,
{ " System Type (Raw value) " , " adwin_config.system_type " ,
FT_STRING , BASE_NONE , NULL , 0x0 ,
" The system type of the ADwin system, e.g. Gold, Pro or Light. " , HFILL }
} ,
{ & hf_adwin_config_server_ip ,
{ " Server IP " , " adwin_config.server_ip " ,
FT_IPv4 , BASE_NONE , NULL , 0x0 ,
" In scan replies, this is the current IP address of the ADwin system. In configuration packets, this is the new IP to be used by the ADwin system. " , HFILL }
} ,
{ & hf_adwin_config_server_version ,
{ " Server version " , " adwin_config.server_version " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" The version number of the server program. This number represents the complete firmware version, e.g. 2.74. " , HFILL }
} ,
{ & hf_adwin_config_server_version_beta ,
{ " server version (beta part) " , " adwin_config.server_version_beta " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" A non-zero value of this field indicates a beta firmware version, where this number represents the current revision. " , HFILL }
} ,
{ & hf_adwin_config_socketshutdowns ,
{ " Socket shutdowns " , " adwin_config.socketshutdowns " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" Number of socket errors that lead to a recreation of the socket (ethernet interface version 1 only). " , HFILL }
} ,
{ & hf_adwin_config_status ,
{ " Status " , " adwin_config.status " ,
FT_UINT32 , BASE_HEX , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_bootloader ,
{ " Status Bootloader " , " adwin_config.status_bootloader " ,
FT_BOOLEAN , 32 , NULL , STATUS_WITH_BOOTLOADER ,
" Indicates if the ADwin system has bootloader capabilities. " , HFILL }
} ,
{ & hf_adwin_config_status_reprogrammable ,
{ " Status Reprogrammable " ,
" adwin_config.status_reprogrammable " ,
FT_BOOLEAN , 32 , NULL , STATUS_REPROGRAMMABLE ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_configurable ,
{ " Status Configurable " , " adwin_config.status_configurable " ,
FT_BOOLEAN , 32 , NULL , STATUS_CONFIGURABLE ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_bootloader_boots ,
{ " Status Bootloader boots " ,
" adwin_config.status_bootloader_boots " ,
FT_BOOLEAN , 32 , NULL , STATUS_BOOTLOADER_BOOTS ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_bootloader_reprogrammable ,
{ " Status Bootloader reprogrammable " ,
" adwin_config.status_bootloader_reprogrammable " ,
FT_BOOLEAN , 32 , NULL , STATUS_BOOTLOADER_REPROGRAMMABLE ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_bootloader_receive ,
{ " Status Bootloader receive " ,
" adwin_config.status_bootloader_receive " ,
FT_BOOLEAN , 32 , NULL , STATUS_BOOTLOADER_RECEIVES_DATA ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_bootloader_reprogramming_done ,
{ " Status Bootloader reprogramming done " ,
" adwin_config.status_bootloader_reprogramming_done " ,
FT_BOOLEAN , 32 , NULL , STATUS_BOOTLOADER_REPROGRAMMING_DONE ,
NULL , HFILL }
} ,
{ & hf_adwin_config_status_eeprom_support ,
{ " Status EEPROM Support " ,
" adwin_config.status_eeprom_support " ,
FT_BOOLEAN , 32 , NULL , STATUS_WITH_EEPROM_SUPPORT ,
NULL , HFILL }
} ,
{ & hf_adwin_config_stream_length ,
{ " Stream length " , " adwin_config.stream_length " ,
FT_INT32 , BASE_DEC , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_timeout ,
{ " Timeout " , " adwin_config.timeout " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_timerresets ,
{ " Timer resets " , " adwin_config.timerresets " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" Counter for resets of the timer (ethernet interface version 1 only). " , HFILL }
} ,
{ & hf_adwin_config_disk_free ,
{ " Free disk space (kb) " , " adwin_config.disk_free " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" Free disk space in kb on flash (ethernet interface version 2 only). " , HFILL }
} ,
{ & hf_adwin_config_disk_size ,
{ " Disk size (kb) " , " adwin_config.disk_size " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
" Flash disk size in kb (ethernet interface version 2 only). " , HFILL }
} ,
{ & hf_adwin_config_unused ,
{ " Unused " , " adwin_config.unused " ,
FT_NONE , BASE_NONE , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_version ,
{ " Version " , " adwin_config.version " ,
FT_UINT32 , BASE_DEC , NULL , 0x0 ,
NULL , HFILL }
} ,
{ & hf_adwin_config_xilinx_version ,
{ " XILINX Version " , " adwin_config.xilinx_version " ,
FT_UINT32 , BASE_HEX , NULL , 0x0 ,
" Version of XILINX program " , HFILL }
} ,
} ;
/* Setup protocol subtree array */
static gint * ett [ ] = {
& ett_adwin_config ,
& ett_adwin_config_status ,
& ett_adwin_config_debug ,
} ;
/* Register the protocol name and description */
proto_adwin_config =
proto_register_protocol ( " ADwin configuration protocol " ,
" ADwin-Config " , " adwin_config " ) ;
/* Required function calls to register the header fields and
subtrees used */
proto_register_field_array ( proto_adwin_config , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
}
void
proto_reg_handoff_adwin_config ( void )
{
static int adwin_config_prefs_initialized = FALSE ;
if ( ! adwin_config_prefs_initialized ) {
heur_dissector_add ( " udp " , dissect_adwin_config , proto_adwin_config ) ;
heur_dissector_add ( " tcp " , dissect_adwin_config , proto_adwin_config ) ;
adwin_config_prefs_initialized = TRUE ;
}
}