Ethereal-dev: [Ethereal-dev] Re: Patch for new dissector plugin for Ether-S-Bus telegrams modi
Note: This archive is from the project's previous web site, ethereal.com. This list is no longer active.
From: Christian Durrer <Christian.durrer@xxxxxxxxxxxx>
Date: Thu, 15 Jun 2006 20:24:50 +0200
Hi, thank you for your feedback. I finally managed to modify my code by - using symbols instead of hardcoded command codes - removing the debug code - removing the last set in the patch - adding the Makefile.common in the plugins dir Could you please have a look at it and if it is ok, check it in? Thanx, chris On Sun, 2006-06-04 at 12:00 -0500, ethereal-dev-request@xxxxxxxxxxxx wrote: > Send Ethereal-dev mailing list submissions to > ethereal-dev@xxxxxxxxxxxx > > To subscribe or unsubscribe via the World Wide Web, visit > http://www.ethereal.com/mailman/listinfo/ethereal-dev > or, via email, send a message with subject or body 'help' to > ethereal-dev-request@xxxxxxxxxxxx > > You can reach the person managing the list at > ethereal-dev-owner@xxxxxxxxxxxx > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Ethereal-dev digest..." > > > Reply-To: Ethereal development <ethereal-dev@xxxxxxxxxxxx> > > Today's Topics: > > 1. Re: Patch for new dissector plugin for Ether-S-Bus telegrams > (Jaap Keuter) > 2. Re: ieee802.11 AID calculation patch (Joerg Mayer) > 3. one more h245/per alignment issue (Cvetan Ivanov) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Sun, 4 Jun 2006 13:32:17 +0200 (CEST) > From: Jaap Keuter <jaap.keuter@xxxxxxxxx> > Subject: Re: [Ethereal-dev] Patch for new dissector plugin for > Ether-S-Bus telegrams > To: Ethereal development <ethereal-dev@xxxxxxxxxxxx> > Message-ID: <20060604131759.K47378-100000@xxxxxxxxxxxxx> > Content-Type: TEXT/PLAIN; charset=US-ASCII > > Hi, > > This looks pretty good, thanks. > > A few small remark though: > 1. could you use meaningfull symbols in the code i.s.o. hardcoded values. > I'm refering to code like this: > > + if (((request_val->cmd_code) == 0x00) || > + ((request_val->cmd_code) == 0x06) || > + ((request_val->cmd_code) == 0x07) || > + ((request_val->cmd_code) == 0x1E) || > + ((request_val->cmd_code) == 0x1F) || > + ((request_val->cmd_code) == 0xA1)){ > > 2. Could you clean up the code a bit by removing the debug code from it > > 3. The last change in the set is superflous. > > Thanx, > Jaap > > > > On Sat, 3 Jun 2006, Christian Durrer wrote: > > > Hi, > > > > I hope this is the right place to send a patch for a new dissector > > plugin. The telegram it dissects are for the communication between PLCs > > (Programmable logic controller) from the company Saia Burgess Controls > > Ltd. (http://www.start-controls.com, http://www.saia-burgess.com or > > http://www.sbc-support.ch). The protocol is named Ether-S-Bus (the PLCs > > are called PCD2, PCD3, PCD4). > > We developped this dissector for easyer debugging of networks containing > > our contollers. > > > > The patch was created against Ethereal Version 1.1.0 (SVN Rev 18189). I > > tested it with various capture files (which some of them also fuzzed). > > The VariousSBus is one of them. > > > > I also would like to make you a big compliment! Ethereal is a great > > tool! > > > > I'm available for any your questions > > > > With best regards > > > > Christian Durrer > > > > End of Ethereal-dev Digest, Vol 38, Issue 7 > *******************************************
Index: /ethereal/configure.in =================================================================== --- /ethereal/configure.in (revision 18189) +++ /ethereal/configure.in (working copy) @@ -1340,6 +1340,7 @@ plugins/rlm/Makefile plugins/rtnet/Makefile plugins/rudp/Makefile + plugins/sbus/Makefile plugins/stats_tree/Makefile plugins/v5ua/Makefile tools/Makefile Index: /ethereal/Makefile.am =================================================================== --- /ethereal/Makefile.am (revision 18189) +++ /ethereal/Makefile.am (working copy) @@ -209,6 +209,7 @@ plugins/rlm/rlm.la \ plugins/rtnet/rtnet.la \ plugins/rudp/rudp.la \ + plugins/sbus/sbus.la \ plugins/stats_tree/stats_tree.la \ plugins/v5ua/v5ua.la @@ -249,6 +250,7 @@ "-dlopen" plugins/rlm/rlm.la \ "-dlopen" plugins/rtnet/rtnet.la \ "-dlopen" plugins/rudp/rudp.la \ + "-dlopen" plugins/sbus/sbus.la \ "-dlopen" plugins/stats_tree/stats_tree.la \ "-dlopen" plugins/v5ua/v5ua.la Index: /ethereal/plugins/Makefile.nmake =================================================================== --- /ethereal/plugins/Makefile.nmake (revision 18189) +++ /ethereal/plugins/Makefile.nmake (working copy) @@ -30,6 +30,7 @@ rlm \ rtnet \ rudp \ + sbus \ stats_tree \ v5ua @@ -151,6 +152,11 @@ $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake cd .. +sbus:: + cd sbus + $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake + cd .. + stats_tree:: cd stats_tree $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake @@ -209,6 +215,8 @@ $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake clean cd ../rudp $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake clean + cd ../sbus + $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake clean cd ../stats_tree $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake clean cd ../v5ua @@ -262,6 +270,8 @@ $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake distclean cd ../rudp $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake distclean + cd ../sbus + $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake distclean cd ../stats_tree $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake distclean cd ../v5ua @@ -313,6 +323,8 @@ $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake maintainer-clean cd ../rudp $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake maintainer-clean + cd ../sbus + $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake maintainer-clean cd ../stats_tree $(MAKE) /$(MAKEFLAGS) -f Makefile.nmake maintainer-clean cd ../v5ua @@ -353,6 +365,7 @@ xcopy rlm\*.dll $(VERSION) /d xcopy rtnet\*.dll $(VERSION) /d xcopy rudp\*.dll $(VERSION) /d + xcopy sbus\*.dll $(VERSION) /d xcopy stats_tree\*.dll $(VERSION) /d xcopy v5ua\*.dll $(VERSION) /d !ENDIF Index: /ethereal/plugins/Makefile.am =================================================================== --- /ethereal/plugins/Makefile.am (revision 18189) +++ /ethereal/plugins/Makefile.am (working copy) @@ -52,6 +52,7 @@ rlm \ rtnet \ rudp \ + sbus \ stats_tree \ v5ua Index: /ethereal/plugins/sbus/packet-sbus.c =================================================================== --- /ethereal/plugins/sbus/packet-sbus.c (revision 0) +++ /ethereal/plugins/sbus/packet-sbus.c (revision 0) @@ -0,0 +1,1687 @@ +/* packet-sbus.c + * Routines for Ether-S-Bus dissection + * Copyright 2006, Christian Durrer <christian.durrer@xxxxxxxxxxxx> + * + * $Id: README.developer 13926 2005-03-26 23:31:35Z guy $ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@xxxxxxxxxxxx> + * 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 <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <glib.h> +#include <gmodule.h> +#include <epan/packet.h> +#include <epan/prefs.h> +#include <epan/conversation.h> + +#ifndef ENABLE_STATIC +G_MODULE_EXPORT const gchar version[] = "0.0.4"; +#endif + +/* Number of entries in the memeory chunk array (for conversation)*/ +#define SBUS_MEMCHUNKSIZE 20 +/* Attribut values*/ +#define SBUS_REQUEST 0x00 +#define SBUS_RESPONSE 0x01 +#define SBUS_ACKNAK 0x02 + +/*SBus command codes*/ +#define SBUS_RD_COUNTER 0x00 +#define SBUS_RD_DISPLAY_REGISTER 0x01 +#define SBUS_RD_FLAG 0x02 +#define SBUS_RD_INPUT 0x03 +#define SBUS_RD_RTC 0x04 +#define SBUS_RD_OUTPUT 0x05 +#define SBUS_RD_REGISTER 0x06 +#define SBUS_RD_TIMER 0x07 +#define SBUS_WR_COUNTER 0x0A +#define SBUS_WR_FLAG 0x0B +#define SBUS_WR_RTC 0x0C +#define SBUS_WR_OUTPUT 0x0D +#define SBUS_WR_REGISTER 0x0E +#define SBUS_WR_TIMER 0x0F +#define SBUS_RDWR_MULTI_MEDIAS 0x13 +#define SBUS_RD_PCD_STATUS_CPU0 0x14 +#define SBUS_RD_PCD_STATUS_CPU1 0x15 +#define SBUS_RD_PCD_STATUS_CPU2 0x16 +#define SBUS_RD_PCD_STATUS_CPU3 0x17 +#define SBUS_RD_PCD_STATUS_CPU4 0x18 +#define SBUS_RD_PCD_STATUS_CPU5 0x19 +#define SBUS_RD_PCD_STATUS_CPU6 0x1A +#define SBUS_RD_PCD_STATUS_OWN 0x1B +#define SBUS_RD_SBUS_STN_NBR 0x1D +#define SBUS_RD_USER_MEMORY 0x1E +#define SBUS_RD_PROGRAM_LINE 0x1F +#define SBUS_RD_PROGRAM_VERSION 0x20 +#define SBUS_RD_TEXT 0x21 +#define SBUS_RD_ACTIVE_TRANSITION 0x22 +#define SBUS_WR_USER_MEMORY 0x23 +#define SBUS_WR_PROGRAM_LINE 0x24 +#define SBUS_WR_TEXT 0x25 +#define SBUS_RUN_PROCEDURE_CPU0 0x28 +#define SBUS_RUN_PROCEDURE_CPU1 0x29 +#define SBUS_RUN_PROCEDURE_CPU2 0x2A +#define SBUS_RUN_PROCEDURE_CPU3 0x2B +#define SBUS_RUN_PROCEDURE_CPU4 0x2C +#define SBUS_RUN_PROCEDURE_CPU5 0x2D +#define SBUS_RUN_PROCEDURE_CPU6 0x2E +#define SBUS_RUN_PROCEDURE_OWN 0x2F +#define SBUS_RUN_PROCEDURE_ALL 0x30 +#define SBUS_RESTART_COLD_CPU1 0x32 +#define SBUS_RESTART_COLD_CPU2 0x33 +#define SBUS_RESTART_COLD_CPU3 0x34 +#define SBUS_RESTART_COLD_CPU4 0x35 +#define SBUS_RESTART_COLD_CPU5 0x36 +#define SBUS_RESTART_COLD_CPU6 0x37 +#define SBUS_RESTART_COLD_OWN 0x38 +#define SBUS_RESTART_COLD_ALL 0x39 +#define SBUS_STOP_PROCEDURE_CPU0 0x3C +#define SBUS_STOP_PROCEDURE_CPU1 0x3D +#define SBUS_STOP_PROCEDURE_CPU2 0x3E +#define SBUS_STOP_PROCEDURE_CPU3 0x3F +#define SBUS_STOP_PROCEDURE_CPU4 0x40 +#define SBUS_STOP_PROCEDURE_CPU5 0x41 +#define SBUS_STOP_PROCEDURE_CPU6 0x42 +#define SBUS_STOP_PROCEDURE_OWN 0x43 +#define SBUS_STOP_PROCEDURE_ALL 0x44 +#define SBUS_RD_STATUSFLAG_ACCU 0x46 +#define SBUS_RD_BYTE 0x47 +#define SBUS_RD_HALT_FAILURE_REG 0x48 +#define SBUS_RD_INDEX_REGISTER 0x49 +#define SBUS_RD_INSTRUCTION_POINTER 0x4A +#define SBUS_FIND_HISTORY 0x4B +#define SBUS_WR_STATUSFLAG_ACCU 0x50 +#define SBUS_WR_BYTE 0x51 +#define SBUS_WR_INDEX_REGISTER 0x52 +#define SBUS_WR_INSTRUCTION_POINTER 0x53 +#define SBUS_CLEAR_ALL 0x5A +#define SBUS_CLEAR_FLAGS 0x5B +#define SBUS_CLEAR_OUTPUTS 0x5C +#define SBUS_CLEAR_REGISTERS 0x5D +#define SBUS_CLEAR_TIMERS 0x5E +#define SBUS_RESTART_WARM_CPU1 0x64 +#define SBUS_RESTART_WARM_CPU2 0x65 +#define SBUS_RESTART_WARM_CPU3 0x66 +#define SBUS_RESTART_WARM_CPU4 0x67 +#define SBUS_RESTART_WARM_CPU5 0x68 +#define SBUS_RESTART_WARM_CPU6 0x69 +#define SBUS_RESTART_WARM_OWN 0x6A +#define SBUS_RESTART_WARM_ALL 0x6B +#define SBUS_CHANGE_BLOCK 0x6E +#define SBUS_CLEAR_HISTORY_FAILURE 0x6F +#define SBUS_DELETE_PROGRAM_LINE 0x70 +#define SBUS_GO_CONDITIONAL 0x71 +#define SBUS_INSERT_PROGRAM_LINE 0x72 +#define SBUS_LOCAL_CYCLE 0x73 +#define SBUS_ALL_CYCLES 0x74 +#define SBUS_MAKE_TEXT 0x75 +#define SBUS_EXECUTE_SINGLE_INSTR 0x76 +#define SBUS_SINGLE_STEP 0x77 +#define SBUS_XOB_17_INTERRUPT 0x82 +#define SBUS_XOB_18_INTERRUPT 0x83 +#define SBUS_XOB_19_INTERRUPT 0x84 +#define SBUS_RD_HANGUP_TIMEOUT 0x91 +#define SBUS_RD_DATA_BLOCK 0x96 +#define SBUS_WR_DATA_BLOCK 0x97 +#define SBUS_MAKE_DATA_BLOCK 0x98 +#define SBUS_CLEAR_DATA_BLOCK 0x99 +#define SBUS_CLEAR_TEXT 0x9A +#define SBUS_RD_BLOCK_ADDRESSES 0x9B +#define SBUS_RD_BLOCK_SIZES 0x9C +#define SBUS_RD_CURRENT_BLOCK 0x9D +#define SBUS_RD_CALL_STACK 0x9E +#define SBUS_RD_DBX 0x9F +#define SBUS_RD_USER_EEPROM_REGISTER 0xA1 +#define SBUS_WR_USER_EEPROM_REGISTER 0xA3 +#define SBUS_ERASE_FLASH 0xA5 +#define SBUS_RESTART_COLD_FLAG 0xA6 +#define SBUS_WR_SYSTEM_BUFFER 0xA7 +#define SBUS_RD_SYSTEM_BUFFER 0xA8 +#define SBUS_RD_WR_PCD_BLOCK 0xA9 +#define SBUS_GET_DIAGNOSTIC 0xAA +#define SBUS_RD_SYSTEM_INFORMATION 0xAB +#define SBUS_CHANGE_BLOCKS_ON_RUN 0xAC +#define SBUS_FLASHCARD_TELEGRAM 0xAD +#define SBUS_DOWNLOAD_FIRMWARE 0xAE +#define SBUS_WEB_SERVER_SERIAL_COMM 0xAF + +/* Bitfield in the arithmetic flags and accu*/ +#define F_ACCU (1<<0) /* Accumulator of PCD */ +#define F_ERROR (1<<1) /* Error flag of PCD */ +#define F_NEGATIVE (1<<2) /* Negative arithmetic status flag*/ +#define F_ZERO (1<<3) /* Zero arithmetic status flag */ + +/* Bitfield in the system information*/ +/*#define F_EMPTY (1<<0) always 0 */ +#define F_MEMSIZE (1<<1) /* Memory size information*/ +#define F_TRACE (1<<2) /* Trace buffer feature */ +#define F_INFO_B1 (1<<3) /* EEPROM information of slot B1*/ +#define F_INFO_B2 (1<<4) /* EEPROM information of slot B2*/ +#define F_PGU_BAUD (1<<5) /* PGU baudrate can be switched*/ + +/* Forward declaration we need below */ +void proto_reg_handoff_sbus(void); + +/* Initialize the protocol and registered fields */ +static int proto_sbus = -1; +static int hf_sbus_length = -1; +static int hf_sbus_version = -1; +static int hf_sbus_protocol = -1; +static int hf_sbus_sequence = -1; +static int hf_sbus_attribut = -1; +static int hf_sbus_dest = -1; +static int hf_sbus_address = -1; +static int hf_sbus_command = -1; +static int hf_sbus_command_extension = -1; +static int hf_sbus_rcount = -1; +static int hf_sbus_wcount = -1; +static int hf_sbus_wcount_calculated = -1; +static int hf_sbus_fio_count = -1; +static int hf_sbus_addr_rtc = -1; +static int hf_sbus_addr_iof = -1; +static int hf_sbus_addr_eeprom = -1; +static int hf_sbus_addr_prog = -1; +static int hf_sbus_addr_68k = -1; +static int hf_sbus_block_type = -1; +static int hf_sbus_block_nr = -1; +static int hf_sbus_nbr_elements = -1; +static int hf_sbus_display_register = -1; +static int hf_sbus_data_rtc = -1; +static int hf_sbus_data_byte = -1; +static int hf_sbus_data_byte_hex = -1; +static int hf_sbus_data_iof = -1; +static int hf_sbus_cpu_type = -1; +static int hf_sbus_fw_version = -1; +static int hf_sbus_sysinfo_nr = -1; +static int hf_sbus_sysinfo0_1 = -1; +static int hf_sbus_sysinfo0_2 = -1; +static int hf_sbus_sysinfo0_3 = -1; +static int hf_sbus_sysinfo0_4 = -1; +static int hf_sbus_sysinfo0_5 = -1; +static int hf_sbus_sysinfo_length = -1; +static int hf_sbus_f_module_type = -1; +static int hf_sbus_harware_version = -1; +static int hf_sbus_hardware_modification = -1; +static int hf_sbus_various = -1; +static int hf_sbus_acknackcode = -1; +static int hf_sbus_cpu_status = -1; +static int hf_sbus_week_day = -1; +static int hf_sbus_date = -1; +static int hf_sbus_time = -1; +static int hf_sbus_crc = -1; +static int hf_sbus_crc_bad = -1; +static int hf_sbus_flags_accu = -1; +static int hf_sbus_flags_error = -1; +static int hf_sbus_flags_negative = -1; +static int hf_sbus_flags_zero = -1; +/* Web server telegram */ +static int hf_sbus_web_size = -1; +static int hf_sbus_web_aid = -1; +static int hf_sbus_web_seq = -1; + +/* Initialize the subtree pointers */ +static gint ett_sbus = -1; +static gint ett_sbus_ether = -1; +static gint ett_sbus_data = -1; + +/* True/False strings*/ +static const true_false_string tfs_sbus_flags= { + "Is high", + "Is low" +}; + +static const true_false_string tfs_sbus_present= { + "Is present", + "Is not present" +}; + +/* value to string definitions*/ +/* telegram types*/ +static const value_string sbus_att_vals[] = { + {0, "Request"}, + {1, "Response"}, + {2, "ACK/NAK"}, + {0, NULL}, +}; +/* Block types*/ +static const value_string sbus_block_types[] = { + {0x00, "COB"}, + {0x01, "XOB"}, + {0x02, "PB"}, + {0x03, "FB"}, + {0x04, "ST"}, + {0x05, "TR"}, + {0x04, "TEXT"}, + {0x05, "DB"}, + {0x08, "SB"}, + {0, NULL}, +}; +/* ACK NAK values*/ +static const value_string sbus_CPU_status[] = { + {0x43, "C"}, + {0x44, "D"}, + {0x48, "Halt"}, + {0x52, "Run"}, + {0x53, "Stop"}, + {0x58, "X, Exceptional Intermediate Status (MODEMS+)"}, + {0, NULL}, +}; +/* CPU status*/ +static const value_string sbus_ack_nak_vals[] = { + {0, "ACK (Acknowledged)"}, + {1, "NAK, no reason specified"}, + {2, "NAK, because of password"}, + {3, "NAK, PGU port is in reduced protocol"}, + {4, "NAK, PGU port is already used"}, + {0, NULL}, +}; +/* S-Bus commands*/ +static const value_string sbus_command_vals[] = { + {0x00, "Read counter(s)"}, + {0x01, "Read display register"}, + {0x02, "Read flag(s)"}, + {0x03, "Read input(s)"}, + {0x04, "Read real time clock"}, + {0x05, "Read output(s)"}, + {0x06, "Read register(s)"}, + {0x07, "Read timer(s)"}, + {0x0A, "Write counter(s)"}, + {0x0B, "Write flag(s)"}, + {0x0C, "Write real time clock"}, + {0x0D, "Write output(s)"}, + {0x0E, "Write register(s)"}, + {0x0F, "Write timer(s)"}, + {0x14, "Read PCD status, CPU 0"}, + {0x15, "Read PCD status, CPU 1"}, + {0x16, "Read PCD status, CPU 2"}, + {0x17, "Read PCD status, CPU 3"}, + {0x18, "Read PCD status, CPU 4"}, + {0x19, "Read PCD status, CPU 5"}, + {0x1A, "Read PCD status, CPU 6"}, + {0x1B, "Read PCD status (own)"}, + {0x1D, "Read S-Bus station number"}, + {0x1E, "Read user memory*"}, + {0x1F, "Read program line*"}, + {0x20, "Read firmware version"}, + {0x21, "Read text*"}, + {0x22, "Read active transition*"}, + {0x23, "Write user memeory*"}, + {0x24, "Write program line*"}, + {0x25, "Write text*"}, + {0x28, "Run procedure*, CPU 0"}, + {0x29, "Run procedure*, CPU 1"}, + {0x2A, "Run procedure*, CPU 2"}, + {0x2B, "Run procedure*, CPU 3"}, + {0x2C, "Run procedure*, CPU 4"}, + {0x2D, "Run procedure*, CPU 5"}, + {0x2E, "Run procedure*, CPU 6"}, + {0x2F, "Run procedure* (own CPU)"}, + {0x30, "Run procedure* (All CPUs)"}, + {0x32, "Restart cold CPU 1*"}, + {0x33, "Restart cold CPU 2*"}, + {0x34, "Restart cold CPU 3*"}, + {0x35, "Restart cold CPU 4*"}, + {0x36, "Restart cold CPU 5*"}, + {0x37, "Restart cold CPU 6*"}, + {0x38, "Restart cold own CPU*"}, + {0x39, "Restart cold all CPUs*"}, + {0x3C, "Stop procedure*, CPU 0"}, + {0x3D, "Stop procedure*, CPU 1"}, + {0x3E, "Stop procedure*, CPU 2"}, + {0x3F, "Stop procedure*, CPU 3"}, + {0x40, "Stop procedure*, CPU 4"}, + {0x41, "Stop procedure*, CPU 5"}, + {0x42, "Stop procedure*, CPU 6"}, + {0x43, "Stop procedure*, (own CPU)"}, + {0x44, "Stop procedure*, (All CPUs)"}, + {0x46, "Read arithmetic status and ACCU*"}, + {0x47, "Read byte"}, + {0x48, "Read halt failure register*"}, + {0x49, "Read index register*"}, + {0x4A, "Read instruction pointer*"}, + {0x4B, "Find history*"}, + {0x50, "Write arithmetic staus and ACCU*"}, + {0x51, "Write byte*"}, + {0x52, "Write index register"}, + {0x53, "Write instruction pointer*"}, + {0x5A, "Clear all (F, O, R, T)*"}, + {0x5B, "Clear flags*"}, + {0x5C, "Clear outputs*"}, + {0x5D, "Clear registers*"}, + {0x5E, "Clear timers*"}, + {0x64, "Restart warm CPU 1*"}, + {0x65, "Restart warm CPU 2*"}, + {0x66, "Restart warm CPU 3*"}, + {0x67, "Restart warm CPU 4*"}, + {0x68, "Restart warm CPU 5*"}, + {0x69, "Restart warm CPU 6*"}, + {0x6A, "Restart warm (own CPU)*"}, + {0x6B, "Restart warm (All CPUs)*"}, + {0x6E, "Change block*"}, + {0x6F, "Clear history failure*"}, + {0x70, "Delete program line*"}, + {0x71, "Go conditional*"}, + {0x72, "Insert program line*"}, + {0x73, "Local cycles*"}, + {0x74, "All cycles*"}, + {0x75, "Make text*"}, + {0x76, "Execute single instruction*"}, + {0x77, "Single step*"}, + {0x82, "XOB 17 interrupt"}, + {0x83, "XOB 18 interrupt"}, + {0x84, "XOB 19 interrupt"}, + {0x91, "Read hangup timeout"}, + {0x96, "Read data block"}, + {0x97, "Write data block"}, + {0x98, "Make data block*"}, + {0x99, "Clear data block*"}, + {0x9A, "Clear text*"}, + {0x9B, "Read block address"}, + {0x9C, "Read block sizes"}, + {0x9D, "Read current block*"}, + {0x9E, "Read call stack*"}, + {0x9F, "Read DBX"}, + {0xA1, "Read user EEPROM register"}, + {0xA3, "Write user EEPROM register"}, + {0xA5, "Erase flash*"}, + {0xA6, "Restart cold flag*"}, + {0xA7, "Write system buffer"}, + {0xA8, "Read system buffer"}, + {0xAA, "Get diagnostic*"}, + {0xAB, "Read system information*"}, + {0xAC, "Changes blocks on run*"}, + {0xAD, "Flashcard telegram*"}, + {0xAE, "Download FW*"}, + {0xAF, "Web server serial communication*"}, + {0, NULL}, +}; + +static const value_string webserver_aid_vals[] = { + {0x01, "Partitial request"}, + {0x02, "Request end"}, + {0x07, "Get Data"}, + {0x10, "Transfer OK"}, + {0x11, "Partial answer"}, + {0x12, "Last part of answer"}, + {0x13, "Server not ready"}, + {0, NULL} +}; + +static const guint crc_table[] = { + 0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef, + 0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de, + 0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d, + 0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc, + 0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b, + 0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a, + 0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49, + 0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78, + 0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067, + 0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256, + 0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405, + 0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634, + 0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3, + 0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92, + 0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1, + 0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0 +}; + +/* Conversion values passing structure*/ +typedef struct { + guint32 conversation; /*Conversation ID*/ + guint16 sequence; /*Sequence number of request telegram*/ +} sbus_request_key; + +typedef struct { + guint8 cmd_code; /*command code from request*/ + guint8 count; /*rcount value*/ + guint8 sysinfo; /*system information number (or command in other telegrams)*/ +} sbus_request_val; + +/* The GMemChunk base structure (for conversations)*/ +static GHashTable *sbus_request_hash = NULL; +static GMemChunk *sbus_request_keys = NULL; +static GMemChunk *sbus_request_vals = NULL; + +static guint crc_calc (guint crc, guint val) +{ + int index; + guint ncrc; + + index = (((crc >> 8) ^ val) & 0xff); + ncrc = crc_table[index] ^ ((crc << 8) & 0xffff); + + return ncrc; +} + +/* Hash functions*/ +static gint sbus_equal(gconstpointer v, gconstpointer w) +{ + sbus_request_key *v1 = (sbus_request_key *)v; + sbus_request_key *v2 = (sbus_request_key *)w; + + if (v1->conversation == v2->conversation && + v1->sequence == v2->sequence) { + return 1; + } + return 0; +} + +static guint sbus_hash(gconstpointer v) +{ + sbus_request_key *key = (sbus_request_key *)v; + guint val; + val = key->conversation + key->sequence; + return val; +} + +/*Protocol initialisation*/ +static void sbus_init_protocol(void){ + if (sbus_request_hash){ + g_hash_table_destroy(sbus_request_hash); + } + if (sbus_request_keys){ + g_mem_chunk_destroy(sbus_request_keys); + } + if (sbus_request_vals){ + g_mem_chunk_destroy(sbus_request_vals); + } + sbus_request_hash = g_hash_table_new(sbus_hash, sbus_equal); + sbus_request_keys = g_mem_chunk_new("sbus_request_keys", + sizeof(sbus_request_key), + SBUS_MEMCHUNKSIZE * sizeof(sbus_request_key), + G_ALLOC_AND_FREE); + sbus_request_vals = g_mem_chunk_new("sbus_request_vals", + sizeof(sbus_request_val), + SBUS_MEMCHUNKSIZE * sizeof(sbus_request_val), + G_ALLOC_AND_FREE); +} + +/*Dissect the telegram*/ +static void +dissect_sbus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + +/* Set up structures needed to add the protocol subtree and manage it */ + proto_item *ti, *et, *dt; + proto_tree *sbus_tree, *ethsbus_tree, *sbusdata_tree; + + gboolean interpreted; /*for indication of interpreted telegrams*/ + gint i; /*for CRC calculation*/ + gint j; /*for CRC calculation*/ + gint offset; + gint sbus_eth_len; + guint sbus_crc_calc; + guint8 sbus_version; + guint8 sbus_attribut; + guint8 sbus_media_cnt; + guint8 sbus_fio_cnt; + guint8 sbus_cmd_code; + /*guint8 sbus_hash_cmd_code;*/ + guint8 sbus_web_size; + guint8 sbus_web_aid; + guint8 sbus_web_seq; + guint8 sbus_sysinfo_number; + /*guint8 sbus_sysinfolenght;*/ + guint32 sbus_binarymasked; + guint32 sbus_binaries; + guint16 sbus_ack_code; + /* guint32 sbus_length;*/ + /* guint32 sbus_sequence;*/ + guint32 sbus_show_bin; + guint32 sbus_helper; + guint32 sbus_helper1; + guint32 sbus_helper2; + char *tmp_string; + +/* Set up conversations*/ + conversation_t *conversation = NULL; + sbus_request_key request_key, *new_request_key; + sbus_request_val *request_val = NULL; + + conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, pinfo->destport, 0); + + if (!conversation){ + /* create new conversation*/ + conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, pinfo->destport, 0); + } + + request_key.conversation = conversation->index; + request_key.sequence = tvb_get_ntohs(tvb,6); + + request_val = (sbus_request_val *) g_hash_table_lookup(sbus_request_hash, + &request_key); + /* Only allocate a new hash element when it's a request*/ + sbus_attribut = tvb_get_guint8(tvb,8); + + if ( !request_val && sbus_attribut == 0 ) {/* request telegram */ + + new_request_key = g_mem_chunk_alloc(sbus_request_keys); + *new_request_key = request_key; + + request_val = g_mem_chunk_alloc(sbus_request_vals); + request_val->cmd_code=tvb_get_guint8(tvb,10); + + if (((request_val->cmd_code) == 0xA1) || + ((request_val->cmd_code) == 0xA3)){ + request_val->count=((tvb_get_guint8(tvb,12))+1); + } + else {request_val->count=((tvb_get_guint8(tvb,11))+1);} + + /*Enter system info*/ + if ((request_val->cmd_code) == 0xAB){ + request_val->sysinfo=(tvb_get_guint8(tvb,12)); + } + else {request_val->sysinfo=0x0;} + + g_hash_table_insert(sbus_request_hash, new_request_key, request_val); + } +/* End of attaching data to hash table*/ + +/* 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, "S-Bus"); + + if (check_col(pinfo->cinfo, COL_INFO)) + col_clear(pinfo->cinfo, COL_INFO); + offset = 0 ; + + if (check_col(pinfo->cinfo, COL_INFO)) { + + +/* sbus_ack_code = tvb_get_ntohs(tvb,10);*/ + switch (sbus_attribut){ + case SBUS_REQUEST: + sbus_cmd_code = tvb_get_guint8(tvb,10); + + /* Special treatment of web server request + * as is is very helpful to see more information in the packetlist */ + if (sbus_cmd_code == 0xAF) { + sbus_web_aid = tvb_get_guint8(tvb,12); + sbus_web_seq = tvb_get_guint8(tvb, 13); + + col_add_fstr(pinfo->cinfo, COL_INFO, + "Web Server Request: %s (Seq No: %d)", + val_to_str(sbus_web_aid, + webserver_aid_vals, "Unknown Request!"), + sbus_web_seq); + } else { + /* All other requests */ + col_add_fstr(pinfo->cinfo, COL_INFO, + "Request: %s", val_to_str(sbus_cmd_code, + sbus_command_vals, "Unknown Command!")); + } + break; + + case SBUS_RESPONSE: + /* Special treatment of web server request + * as is is very helpful to see more information in the packetlist */ + if (request_val && ((request_val->cmd_code) == SBUS_WEB_SERVER_SERIAL_COMM)) { + sbus_web_aid = tvb_get_guint8(tvb,10); + col_add_fstr(pinfo->cinfo, COL_INFO, + "Response: %s (Seq No: %d)", + val_to_str(sbus_web_aid, + webserver_aid_vals, "Unknown Request!"), + sbus_web_seq); + + } else { + col_set_str(pinfo->cinfo, COL_INFO, "Response"); + } + break; + + case SBUS_ACKNAK: + sbus_ack_code = tvb_get_ntohs(tvb,9); + col_add_fstr(pinfo->cinfo, COL_INFO, + "%s", val_to_str(sbus_ack_code, + sbus_ack_nak_vals, + "Unknown NAK response code!")); + break; + + default: + break; + } + + } +/* create display subtree for the protocol */ + if (tree) { + + ti = proto_tree_add_item(tree, proto_sbus, tvb, 0, -1, FALSE); + + sbus_tree = proto_item_add_subtree(ti, ett_sbus); + +/*Add subtree for Ether-S-Bus header*/ + et = proto_tree_add_text(sbus_tree, tvb, 0, 8, "Ether-S-Bus header"); + ethsbus_tree = proto_item_add_subtree(et, ett_sbus_ether); + sbus_version = tvb_get_guint8(tvb,0x4); + +/* add an item to the subtree*/ + sbus_eth_len = tvb_get_ntohl(tvb,offset); + proto_tree_add_item(ethsbus_tree, + hf_sbus_length, tvb, offset, 4, FALSE); + offset += 4; + + proto_tree_add_item(ethsbus_tree, + hf_sbus_version, tvb, offset, 1, FALSE); + offset += 1; + + proto_tree_add_item(ethsbus_tree, + hf_sbus_protocol, tvb, offset, 1, FALSE); + offset += 1; + + proto_tree_add_item(ethsbus_tree, + hf_sbus_sequence, tvb, offset, 2, FALSE); + offset += 2; + +/* Continue adding stuff to the main tree*/ + proto_tree_add_item(sbus_tree, + hf_sbus_attribut, tvb, offset, 1, FALSE); + offset += 1; + + sbus_attribut = tvb_get_guint8(tvb,8); + if (sbus_attribut == SBUS_REQUEST){ + interpreted = FALSE; + proto_tree_add_item(sbus_tree, + hf_sbus_dest, tvb, offset, 1, FALSE); + offset += 1; + sbus_cmd_code = tvb_get_guint8(tvb,10); + proto_tree_add_item(sbus_tree, + hf_sbus_command, tvb, offset, 1, FALSE); + offset += 1; + + /*Read Counter, Register or Timer*/ + if ((sbus_cmd_code == SBUS_RD_COUNTER) || + (sbus_cmd_code == SBUS_RD_REGISTER) || + (sbus_cmd_code == SBUS_RD_TIMER)){ + sbus_media_cnt = (tvb_get_guint8(tvb,11))+1; + proto_tree_add_uint(sbus_tree, + hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_rtc, tvb, offset, 2, FALSE); + offset += 2; + interpreted = TRUE; + } + /*Read Flag, Input or Output*/ + if ((sbus_cmd_code == SBUS_RD_FLAG) || + (sbus_cmd_code == SBUS_RD_INPUT) || + (sbus_cmd_code == SBUS_RD_OUTPUT)){ + sbus_media_cnt = (tvb_get_guint8(tvb,11))+1; + proto_tree_add_uint(sbus_tree, + hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_iof, tvb, offset, 2, FALSE); + offset += 2; + interpreted = TRUE; + } + /*Write Register Timer Counter*/ + if ((sbus_cmd_code == SBUS_WR_COUNTER) || + (sbus_cmd_code == SBUS_WR_REGISTER) || + (sbus_cmd_code == SBUS_WR_TIMER)){ + sbus_media_cnt = (tvb_get_guint8(tvb,11)); + sbus_media_cnt = ((sbus_media_cnt - 1)/4); + proto_tree_add_uint(sbus_tree, + hf_sbus_wcount_calculated, tvb, offset, + 1, sbus_media_cnt); + proto_tree_add_item(sbus_tree, + hf_sbus_wcount, tvb, offset, 1, FALSE); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_rtc, tvb, offset, 2, FALSE); + offset += 2; + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + ((sbus_media_cnt) * 4),"Data"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=((sbus_media_cnt)); i>0; i--){ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_rtc, tvb, offset, + 4, FALSE); + offset += 4; + + } + interpreted = TRUE; + } + /* Write flags and outputs*/ + if ((sbus_cmd_code == SBUS_WR_FLAG) || + (sbus_cmd_code == SBUS_WR_OUTPUT)){ + sbus_media_cnt = (tvb_get_guint8(tvb,11)); + sbus_media_cnt = ((sbus_media_cnt - 2 )); + sbus_fio_cnt = (tvb_get_guint8(tvb,14)); + sbus_fio_cnt = ((sbus_fio_cnt + 1 )); + proto_tree_add_uint(sbus_tree, + hf_sbus_wcount_calculated, tvb, offset, + 1, sbus_media_cnt); + proto_tree_add_item(sbus_tree, + hf_sbus_wcount, tvb, offset, 1, FALSE); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_iof, tvb, offset, 2, FALSE); + offset += 2; + proto_tree_add_uint(sbus_tree, + hf_sbus_fio_count, tvb, offset, 1, sbus_fio_cnt); + offset += 1; + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + (sbus_media_cnt),"Data"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i= sbus_media_cnt; i>0; i--){ + + sbus_helper = 1; + sbus_show_bin = 0; + sbus_binarymasked = 0x01; + sbus_binaries = tvb_get_guint8(tvb, offset); + for (j=0; j<8; j++){ + if ((sbus_binarymasked & sbus_binaries) != 0) { + sbus_show_bin = (sbus_show_bin + sbus_helper); + } + sbus_binarymasked = sbus_binarymasked<<1; + sbus_helper = 10 * sbus_helper; + } + + proto_tree_add_uint_format(sbusdata_tree, + hf_sbus_data_iof, tvb, offset, 1, sbus_show_bin, + "Binary data: %08u", sbus_show_bin); + offset += 1; + + } + interpreted = TRUE; + } + /* Request: Write Real time clock*/ + if (sbus_cmd_code == SBUS_WR_RTC){ + sbus_helper = tvb_get_guint8(tvb, (offset +5)); /*hours*/ + sbus_helper1 = tvb_get_guint8(tvb, (offset +6)); /*minutes*/ + sbus_helper2 = tvb_get_guint8(tvb, (offset +7)); /*seconds*/ + proto_tree_add_text(sbus_tree, tvb, (offset +5), 3, + "Time (HH:MM:SS): %02x:%02x:%02x", sbus_helper, sbus_helper1, sbus_helper2); + sbus_helper = tvb_get_guint8(tvb, (offset +2)); /*year*/ + sbus_helper1 = tvb_get_guint8(tvb, (offset +3)); /*month*/ + sbus_helper2 = tvb_get_guint8(tvb, (offset +4)); /*day*/ + proto_tree_add_text(sbus_tree, tvb, (offset +2), 3, + "Date (YY/MM/DD): %02x/%02x/%02x", sbus_helper, sbus_helper1, sbus_helper2); + sbus_helper = tvb_get_guint8(tvb, (offset)); /*year-week*/ + sbus_helper1 = tvb_get_guint8(tvb, (offset +1)); /*week-day*/ + proto_tree_add_text(sbus_tree, tvb, offset, 2, + "Calendar week: %x, Week day: %x", sbus_helper, sbus_helper1); + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + 8, "Clock data"); + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + + proto_tree_add_item(sbusdata_tree, + hf_sbus_week_day, tvb, offset, 2, FALSE); + offset += 2; + proto_tree_add_item(sbusdata_tree, + hf_sbus_date, tvb, offset, 3, FALSE); + offset += 3; + proto_tree_add_item(sbusdata_tree, + hf_sbus_time, tvb, offset, 3, FALSE); + offset += 3; + interpreted = TRUE; + } + + + /* Read user memory or program line*/ + if ((sbus_cmd_code == SBUS_RD_USER_MEMORY) || + (sbus_cmd_code == SBUS_RD_PROGRAM_LINE)){ + sbus_media_cnt = (tvb_get_guint8(tvb,11))+1; + proto_tree_add_uint(sbus_tree, + hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_prog, tvb, offset, 3, FALSE); + offset += 3; + interpreted = TRUE; + } + + /*Write user memory*/ + if (sbus_cmd_code == SBUS_WR_USER_MEMORY){ + sbus_media_cnt = (tvb_get_guint8(tvb,11)); + sbus_media_cnt = ((sbus_media_cnt - 2)/4); + proto_tree_add_uint(sbus_tree, + hf_sbus_wcount_calculated, tvb, offset, + 1, sbus_media_cnt); + proto_tree_add_item(sbus_tree, + hf_sbus_wcount, tvb, offset, 1, FALSE); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_68k, tvb, offset, 3, FALSE); + offset += 3; + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + ((sbus_media_cnt) * 4),"Program lines"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=((sbus_media_cnt)); i>0; i--){ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_rtc, tvb, offset, + 4, FALSE); + offset += 4; + + } + interpreted = TRUE; + } + + /* Read byte*/ + if (sbus_cmd_code == SBUS_RD_BYTE){ + sbus_media_cnt = (tvb_get_guint8(tvb,11))+1; + proto_tree_add_uint(sbus_tree, + hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_68k, tvb, offset, 3, FALSE); + offset += 3; + interpreted = TRUE; + } + + /* Write byte */ + if (sbus_cmd_code == SBUS_WR_BYTE){ + sbus_media_cnt = (tvb_get_guint8(tvb,11)); + sbus_media_cnt = ((sbus_media_cnt - 2)); + proto_tree_add_uint(sbus_tree, + hf_sbus_wcount_calculated, tvb, offset, + 1, sbus_media_cnt); + proto_tree_add_item(sbus_tree, + hf_sbus_wcount, tvb, offset, 1, FALSE); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_68k, tvb, offset, 3, FALSE); + offset += 3; + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + ((sbus_media_cnt) * 4),"Data (bytes)"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=((sbus_media_cnt)); i>0; i--){ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_byte, tvb, offset, + 1, FALSE); + offset += 1; + } + interpreted = TRUE; + } + + /*Read EEPROM register*/ + if (sbus_cmd_code == SBUS_RD_USER_EEPROM_REGISTER){ + sbus_media_cnt = (tvb_get_guint8(tvb,12))+1; + proto_tree_add_item(sbus_tree, + hf_sbus_command_extension, tvb, offset, 1, FALSE); + offset += 1; + proto_tree_add_uint(sbus_tree, + hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_addr_eeprom, tvb, offset, 2, FALSE); + offset += 2; + interpreted = TRUE; + } + + /*Request for reading system info + Syinfo 05 is not implemented as no serial baud is possible*/ + if (sbus_cmd_code == SBUS_RD_SYSTEM_INFORMATION){ + sbus_sysinfo_number = (tvb_get_guint8(tvb,13)); + proto_tree_add_item(sbus_tree, + hf_sbus_sysinfo_nr, tvb, offset, 1, FALSE); + offset += 1; + sbus_sysinfo_number = (tvb_get_guint8(tvb,14)); + proto_tree_add_item(sbus_tree, + hf_sbus_sysinfo_nr, tvb, offset, 1, FALSE); + offset += 1; + interpreted = TRUE; + } + + /* WebServer Request */ + if (sbus_cmd_code == SBUS_WEB_SERVER_SERIAL_COMM) { + sbus_web_size = tvb_get_guint8(tvb,11); + sbus_web_aid = tvb_get_guint8(tvb,12); + sbus_web_seq = tvb_get_guint8(tvb,13); + + proto_tree_add_item(sbus_tree, + hf_sbus_web_size, tvb, offset, + 1, sbus_web_size); + offset += 1; + + proto_tree_add_item(sbus_tree, + hf_sbus_web_aid, tvb, offset, + 1, sbus_web_aid); + offset += 1; + + proto_tree_add_item(sbus_tree, + hf_sbus_web_seq, tvb, offset, + 1, sbus_web_seq); + offset += 1; + + if (sbus_web_size > 1) { + dt = proto_tree_add_text(sbus_tree, tvb, offset, + (sbus_web_size - 1),"Data (bytes)"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=sbus_web_size -1 ; i>0; i--){ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_byte, tvb, offset, + 1, FALSE); + offset += 1; + } + } + interpreted = TRUE; + } + +/*Inform that command was not dissected and add remaining length*/ + if ((interpreted == FALSE) && (sbus_eth_len > 13)){ /*13 bytes is the minimal length of a request telegram...*/ + sbus_helper = sbus_eth_len - (offset + 2); + proto_tree_add_text(sbus_tree, tvb, offset, sbus_helper, + "This telegram isn't implemented in the dissector."); + offset = offset + sbus_helper; + } + } + +/* Response dissection*/ + if (request_val && sbus_attribut == SBUS_RESPONSE) { + interpreted = FALSE; + /* Response: 32 bit values*/ + if (((request_val->cmd_code) == SBUS_RD_COUNTER) || /*32 bit vals (R,T,C)*/ + ((request_val->cmd_code) == SBUS_RD_REGISTER) || + ((request_val->cmd_code) == SBUS_RD_TIMER) || + ((request_val->cmd_code) == SBUS_RD_USER_MEMORY) || /* User Memory */ + ((request_val->cmd_code) == SBUS_RD_PROGRAM_LINE) || /* Program line */ + ((request_val->cmd_code) == SBUS_RD_USER_EEPROM_REGISTER)){ /* EEPROM reg*/ + + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + ((request_val->count) * 4),"Data"); +/*printf("Debug5\n");*/ + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); +/*printf("Debug6\n");*/ + for (i=(request_val->count); i>0; i--){ + + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_rtc, tvb, offset, + 4, FALSE); + offset += 4; + } + interpreted = TRUE; + } + /* Response: PCD Display register*/ + if ((request_val->cmd_code) == SBUS_RD_DISPLAY_REGISTER){ + proto_tree_add_item(sbus_tree, + hf_sbus_display_register, tvb, offset, 4, FALSE); + offset += 4; + interpreted = TRUE; + } + /* Add binary data I, O, F*/ + if (((request_val->cmd_code) == SBUS_RD_FLAG) || + ((request_val->cmd_code) == SBUS_RD_INPUT) || + ((request_val->cmd_code) == SBUS_RD_OUTPUT)){ + + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + (((request_val->count) + 7) / 8), "Data"); + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + + for (i=(((request_val->count) + 7) / 8); i>0; i--){ + + sbus_helper = 1; + sbus_show_bin = 0; + sbus_binarymasked = 0x01; + sbus_binaries = tvb_get_guint8(tvb, offset); + for (j=0; j<8; j++){ + if ((sbus_binarymasked & sbus_binaries) != 0) { + sbus_show_bin = (sbus_show_bin + sbus_helper); + } + sbus_binarymasked = sbus_binarymasked<<1; + sbus_helper = 10 * sbus_helper; + } + + proto_tree_add_uint_format(sbusdata_tree, + hf_sbus_data_iof, tvb, offset, 1, sbus_show_bin, + "Binary data: %08u", sbus_show_bin); + offset += 1; + } + interpreted = TRUE; + } + + /* Response: Real time clock value*/ + if ((request_val->cmd_code) == SBUS_RD_RTC){ + sbus_helper = tvb_get_guint8(tvb, (offset +5)); /*hours*/ + sbus_helper1 = tvb_get_guint8(tvb, (offset +6)); /*minutes*/ + sbus_helper2 = tvb_get_guint8(tvb, (offset +7)); /*seconds*/ + proto_tree_add_text(sbus_tree, tvb, (offset +5), 3, + "Time (HH:MM:SS): %02x:%02x:%02x", sbus_helper, sbus_helper1, sbus_helper2); + sbus_helper = tvb_get_guint8(tvb, (offset +2)); /*year*/ + sbus_helper1 = tvb_get_guint8(tvb, (offset +3)); /*month*/ + sbus_helper2 = tvb_get_guint8(tvb, (offset +4)); /*day*/ + proto_tree_add_text(sbus_tree, tvb, (offset +2), 3, + "Date (YY/MM/DD): %02x/%02x/%02x", sbus_helper, sbus_helper1, sbus_helper2); + sbus_helper = tvb_get_guint8(tvb, (offset)); /*year-week*/ + sbus_helper1 = tvb_get_guint8(tvb, (offset +1)); /*week-day*/ + proto_tree_add_text(sbus_tree, tvb, offset, 2, + "Calendar week: %x, Week day: %x", sbus_helper, sbus_helper1); + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + 8, "Clock data"); + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + + proto_tree_add_item(sbusdata_tree, + hf_sbus_week_day, tvb, offset, 2, FALSE); + offset += 2; + proto_tree_add_item(sbusdata_tree, + hf_sbus_date, tvb, offset, 3, FALSE); + offset += 3; + proto_tree_add_item(sbusdata_tree, + hf_sbus_time, tvb, offset, 3, FALSE); + offset += 3; + interpreted = TRUE; + } + + /* Response: CPU status, the command codes 14..1B are concerned*/ + if (((request_val->cmd_code) > 0x13) && + ((request_val->cmd_code) < 0x1C)){ + proto_tree_add_item(sbus_tree, + hf_sbus_cpu_status, tvb, offset, 1, FALSE); + offset += 1; + interpreted = TRUE; + } + + /* Response: Station address*/ + if (((request_val->cmd_code) == SBUS_RD_SBUS_STN_NBR)){ + proto_tree_add_item(sbus_tree, + hf_sbus_address, tvb, offset, 1, FALSE); + offset += 1; + interpreted = TRUE; + } + + /* Response: Firmware version */ + if (((request_val->cmd_code) == SBUS_RD_PROGRAM_VERSION)){ + /*PCD type*/ + tmp_string = tvb_get_string(tvb, offset, 5); + proto_tree_add_string(sbus_tree, + hf_sbus_cpu_type, tvb, offset, 5, tmp_string); + offset += 5; + g_free(tmp_string); + /*FW version*/ + tmp_string = tvb_get_string(tvb , offset, 3); + proto_tree_add_string(sbus_tree, + hf_sbus_fw_version, tvb, offset, 3, tmp_string); + offset += 4; + g_free(tmp_string); + interpreted = TRUE; + } + + /* Response for Status Flags*/ + if ((request_val->cmd_code) == SBUS_RD_STATUSFLAG_ACCU){ + + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + 1,"ACCU and arithmetic status"); + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + + proto_tree_add_item(sbusdata_tree, hf_sbus_flags_accu, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_flags_error, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_flags_negative, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_flags_zero, + tvb, offset, 1, FALSE); + offset +=1; + interpreted = TRUE; + } + + /* Response for Read byte */ + if ((request_val->cmd_code) == SBUS_RD_BYTE){ + + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + (request_val->count),"Data (bytes)"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=(request_val->count); i>0; i--){ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_byte, tvb, offset, + 1, FALSE); + offset += 1; + } + interpreted = TRUE; + } + + /* Response for Read Index register */ + if ((request_val->cmd_code) == SBUS_RD_INDEX_REGISTER){ + + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + 2,"Data (hex bytes)"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=0; i<2; i++){ /*2 bytes*/ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_byte_hex, tvb, offset, + 1, FALSE); + offset += 1; + } + interpreted = TRUE; + } + + /* Response: Instruction pointer*/ + if (((request_val->cmd_code) == SBUS_RD_INSTRUCTION_POINTER)){ + proto_tree_add_item(sbus_tree, + hf_sbus_addr_prog, tvb, offset, 3, FALSE); + offset += 3; + interpreted = TRUE; + } + + /*Response for Find History*/ + if (((request_val->cmd_code) == SBUS_FIND_HISTORY)){ + proto_tree_add_item(sbus_tree, + hf_sbus_addr_68k, tvb, offset, 3, FALSE); + offset += 3; + proto_tree_add_item(sbus_tree, + hf_sbus_nbr_elements, tvb, offset, 2, FALSE); + offset += 2; + interpreted = TRUE; + } + + /* Response: Read current block*/ + if (((request_val->cmd_code) == SBUS_RD_CURRENT_BLOCK)){ + proto_tree_add_item(sbus_tree, + hf_sbus_block_type, tvb, offset, 1, FALSE); + offset += 1; + proto_tree_add_item(sbus_tree, + hf_sbus_block_nr, tvb, offset, 2, FALSE); + offset += 2; + interpreted = TRUE; + } + + /* Response: Read system infomation (without interpretation of module info)*/ + if (((request_val->cmd_code) == SBUS_RD_SYSTEM_INFORMATION)){ + if (((request_val->sysinfo) == 0x00)){ /*sysinfo 0*/ + offset +=1; /* this byte is always 0x01*/ + /*Add subtree for Data*/ + dt = proto_tree_add_text(sbus_tree, tvb, offset, + 1,"System info"); + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + + proto_tree_add_item(sbusdata_tree, hf_sbus_sysinfo0_1, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_sysinfo0_2, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_sysinfo0_3, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_sysinfo0_4, + tvb, offset, 1, FALSE); + proto_tree_add_item(sbusdata_tree, hf_sbus_sysinfo0_5, + tvb, offset, 1, FALSE); + offset +=1; + interpreted = TRUE; + } + } + + /* Response: Webserver request */ + if (((request_val->cmd_code) == SBUS_WEB_SERVER_SERIAL_COMM)) { + sbus_web_size = tvb_get_guint8(tvb, 9); + sbus_web_aid = tvb_get_guint8(tvb,10); + sbus_web_seq = tvb_get_guint8(tvb,11); + + proto_tree_add_item(sbus_tree, + hf_sbus_web_size, tvb, offset, + 1, sbus_web_size); + offset += 1; + + proto_tree_add_item(sbus_tree, + hf_sbus_web_aid, tvb, offset, + 1, sbus_web_aid); + offset += 1; + + if (sbus_web_size > 1) { + proto_tree_add_item(sbus_tree, + hf_sbus_web_seq, tvb, offset, + 1, sbus_web_seq); + offset += 1; + + dt = proto_tree_add_text(sbus_tree, tvb, offset, + (sbus_web_size - 2),"Data (bytes)"); + + sbusdata_tree = proto_item_add_subtree(dt, ett_sbus_data); + for (i=sbus_web_size - 2 ; i>0; i--){ + proto_tree_add_item(sbusdata_tree, + hf_sbus_data_byte, tvb, offset, + 1, FALSE); + offset += 1; + } + } + interpreted = TRUE; + } + + /*Inform that response was not dissected and add remaining length*/ + if (interpreted == FALSE){ + sbus_helper = sbus_eth_len - (offset + 2); + proto_tree_add_text(sbus_tree, tvb, offset, sbus_helper, + "This telegram isn't implemented in the dissector."); + offset = offset + sbus_helper; + } + } + + if (sbus_attribut == SBUS_ACKNAK){ + proto_tree_add_item(sbus_tree, + hf_sbus_acknackcode, tvb, offset, 2, FALSE); + offset += 2; + } + + /* Calclulate CRC */ + sbus_crc_calc = 0; + for (i = 0; i < sbus_eth_len - 2; i++) + sbus_crc_calc = crc_calc (sbus_crc_calc, tvb_get_guint8(tvb, i)); + /*Show CRC and add hidden item for wrong CRC*/ + sbus_helper = tvb_get_ntohs(tvb, offset); + if (sbus_helper == sbus_crc_calc){ + proto_tree_add_uint_format(sbus_tree, + hf_sbus_crc, tvb, offset, 2, sbus_helper, + "Checksum: 0x%04x (correct)", sbus_helper); + } + else { + proto_tree_add_uint_format(sbus_tree, + hf_sbus_crc, tvb, offset, 2, sbus_helper, + "Checksum: 0x%04x (NOT correct)", sbus_helper); + proto_tree_add_boolean_hidden(sbus_tree, + hf_sbus_crc_bad, tvb, offset + 2, 2, TRUE); + } + offset += 2; /*now at the end of the telegram*/ + } +/*End of dissect_sbus*/ +} + +/* Register the protocol with Ethereal */ + +void +proto_register_sbus(void) +{ + +/* Setup list of header fields See Section 1.6.1 for details*/ + static hf_register_info hf[] = { + { &hf_sbus_length, + { "Length (bytes)", "sbus.len", + FT_UINT32, BASE_DEC, NULL, 0, + "SAIA Ether-S-Bus telegram length", HFILL } + }, + { &hf_sbus_version, + { "Version", "sbus.vers", + FT_UINT8, BASE_DEC, NULL, 0, + "SAIA Ether-S-Bus version", HFILL } + }, + { &hf_sbus_protocol, + { "Protocol type", "sbus.proto", + FT_UINT8, BASE_DEC, NULL, 0, + "SAIA Ether-S-Bus protocol type", HFILL } + }, + { &hf_sbus_sequence, + { "Sequence", "sbus.seq", + FT_UINT16, BASE_DEC, NULL, 0, + "SAIA Ether-S-Bus sequence number", HFILL } + }, + + { &hf_sbus_attribut, + { "Telegram attribute", "sbus.att", + FT_UINT8, BASE_HEX, VALS(sbus_att_vals), 0, + "SAIA Ether-S-Bus telegram attribute, indicating type of telegram", HFILL } + }, + + { &hf_sbus_dest, + { "Destination", "sbus.destination", + FT_UINT8, BASE_DEC, NULL, 0, + "SAIA S-Bus destination address", HFILL } + }, + + { &hf_sbus_address, + { "S-Bus address", "sbus.address", + FT_UINT8, BASE_DEC, NULL, 0, + "SAIA S-Bus station address", HFILL } + }, + + { &hf_sbus_command, + { "Command", "sbus.cmd", + FT_UINT8, BASE_HEX, VALS(sbus_command_vals), 0, + "SAIA S-Bus command", HFILL } + }, + + { &hf_sbus_command_extension, + { "Command extension", "sbus.cmd_extn", + FT_UINT8, BASE_HEX, NULL, 0, + "SAIA S-Bus command extension", HFILL } + }, + + { &hf_sbus_rcount, + { "R-count", "sbus.rcount", + FT_UINT8, BASE_DEC, NULL, 0, + "Number of elements expected in response", HFILL } + }, + + { &hf_sbus_wcount, + { "W-count (raw)", "sbus.wcount", + FT_UINT8, BASE_DEC, NULL, 0, + "Number of bytes to be written", HFILL } + }, + + { &hf_sbus_wcount_calculated, + { "W-count (32 bit values)", "sbus.wcount_calc", + FT_UINT8, BASE_DEC, NULL, 0, + "Number of elements to be written", HFILL } + }, + + { &hf_sbus_fio_count, + { "FIO Count (amount of bits)", "sbus.fio_count", + FT_UINT8, BASE_DEC, NULL, 0, + "Number of binary elements to be written", HFILL } + }, + + + { &hf_sbus_addr_rtc, + { "Base address RTC", "sbus.addr_RTC", + FT_UINT16, BASE_DEC, NULL, 0, + "Base address of 32 bit elements to read", HFILL } + }, + + { &hf_sbus_addr_iof, + { "Base address IOF", "sbus.addr_IOF", + FT_UINT16, BASE_DEC, NULL, 0, + "Base address of binary elements to read", HFILL } + }, + + { &hf_sbus_addr_eeprom, + { "Base address of EEPROM register", "sbus.addr_EEPROM", + FT_UINT16, BASE_DEC, NULL, 0, + "Base address of 32 bit EEPROM register to read or write", HFILL } + }, + + { &hf_sbus_addr_prog, + { "Base address of user memory or program lines", "sbus.addr_prog", + FT_UINT24, BASE_DEC, NULL, 0, + "Base address of the user memory or program lines (read or write)", HFILL } + }, + + { &hf_sbus_addr_68k, + { "Base address of bytes", "sbus.addr_prog", + FT_UINT24, BASE_HEX, NULL, 0, + "Base address of bytes to read or write (68k address)", HFILL } + }, + + { &hf_sbus_block_type, + { "Block type", "sbus.block_type", + FT_UINT8, BASE_HEX, VALS(sbus_block_types), 0, + "Program block type read", HFILL } + }, + + { &hf_sbus_block_nr, + { "Block/Element nr", "sbus.block_nr", + FT_UINT16, BASE_DEC, NULL, 0, + "Program block / DatatBlock number", HFILL } + }, + + { &hf_sbus_nbr_elements, + { "Number of elements", "sbus.nbr_elements", + FT_UINT16, BASE_DEC, NULL, 0, + "Number of elements or characters", HFILL } + }, + + + { &hf_sbus_display_register, + { "PCD Display register", "sbus.data_display_register", + FT_UINT32, BASE_DEC, NULL, 0, + "The PCD display register (32 bit value)", HFILL } + }, + + { &hf_sbus_data_rtc, + { "S-Bus 32-bit data", "sbus.data_rtc", + FT_UINT32, BASE_DEC, NULL, 0, + "One regiser/timer of counter (32 bit value)", HFILL } + }, + + { &hf_sbus_data_byte, + { "Data bytes", "sbus.data_byte", + FT_UINT8, BASE_DEC, NULL, 0, + "One byte from PCD", HFILL } + }, + + { &hf_sbus_data_byte_hex, + { "Data bytes (hex)", "sbus.data_byte_hex", + FT_UINT8, BASE_HEX, NULL, 0, + "One byte from PCD (hexadecimal)", HFILL } + }, + + { &hf_sbus_data_iof, + { "S-Bus binary data", "sbus.data_iof", + FT_UINT32, BASE_DEC, NULL, 0, + "8 binaries", HFILL } + }, + + { &hf_sbus_cpu_type, + { "PCD type", "sbus.pcd_type", + FT_STRING, BASE_NONE, NULL, 0, + "PCD type (short form)", HFILL } + }, + + { &hf_sbus_fw_version, + { "Firmware version", "sbus.fw_version", + FT_STRING, BASE_NONE, NULL, 0, + "Firmware version of the PCD or module", HFILL } + }, + + { &hf_sbus_sysinfo_nr, + { "System information number", "sbus.sysinfo", + FT_UINT8, BASE_HEX, NULL, 0, + "System information number (extension to command code)", HFILL } + }, + + { &hf_sbus_sysinfo0_1, + { "Mem size info", "sbus.sysinfo0.mem", + FT_BOOLEAN, 8, TFS(&tfs_sbus_present), F_MEMSIZE, + "Availability of memory size information", HFILL } + }, + { &hf_sbus_sysinfo0_2, + { "Trace buffer", "sbus.sysinfo0.trace", + FT_BOOLEAN, 8, TFS(&tfs_sbus_present), F_TRACE, + "Availability of trace buffer feature", HFILL } + }, + { &hf_sbus_sysinfo0_3, + { "Slot B1", "sbus.sysinfo0.b1", + FT_BOOLEAN, 8, TFS(&tfs_sbus_present), F_INFO_B1, + "Presence of EEPROM information on slot B1", HFILL } + }, + { &hf_sbus_sysinfo0_4, + { "Slot B2", "sbus.sysinfo0.b2", + FT_BOOLEAN, 8, TFS(&tfs_sbus_present), F_INFO_B2, + "Presence of EEPROM information on slot B2", HFILL } + }, + { &hf_sbus_sysinfo0_5, + { "PGU baud", "sbus.sysinfo0.pgubaud", + FT_BOOLEAN, 8, TFS(&tfs_sbus_present), F_PGU_BAUD, + "Availability of PGU baud switch feature", HFILL } + }, + + { &hf_sbus_sysinfo_length, + { "System information length", "sbus.sysinfo_length", + FT_UINT8, BASE_HEX, NULL, 0, + "System information length in response", HFILL } + }, + + { &hf_sbus_f_module_type, + { "F-module type", "sbus.fmodule_type", + FT_STRING, BASE_NONE, NULL, 0, + "Module type mounted on B1/2 slot", HFILL } + }, + + { &hf_sbus_harware_version, + { "Hardware version", "sbus.hw_version", + FT_STRING, BASE_NONE, NULL, 0, + "Hardware version of the PCD or the module", HFILL } + }, + + { &hf_sbus_hardware_modification, + { "Hardware modification", "sbus.hw_modification", + FT_UINT8, BASE_DEC, NULL, 0, + "Hardware modification of the PCD or module", HFILL } + }, + + { &hf_sbus_various, + { "Varous data", "sbus.various", + FT_NONE, BASE_NONE, NULL, 0, + "Various data contained in telegrams but nobody will search for it", HFILL } + }, + + + { &hf_sbus_acknackcode, + { "ACK/NAK code", "sbus.nakcode", + FT_UINT16, BASE_HEX, VALS(sbus_ack_nak_vals), 0, + "SAIA S-Bus ACK/NAK response", HFILL } + }, + + { &hf_sbus_cpu_status, + { "CPU status", "sbus.CPU_status", + FT_UINT8, BASE_HEX, VALS(sbus_CPU_status), 0, + "SAIA PCD CPU status", HFILL } + }, + + + { &hf_sbus_week_day, + { "RTC calendar week and week day", "sbus.rtc.week_day", + FT_UINT16, BASE_HEX, NULL, 0, + "Calendar week and week day number of the real time clock", HFILL } + }, + + { &hf_sbus_date, + { "RTC date (YYMMDD)", "sbus.rtc.date", + FT_UINT24, BASE_HEX, NULL, 0, + "Year, month and day of the real time clock", HFILL } + }, + + { &hf_sbus_time, + { "RTC time (HHMMSS)", "sbus.rtc.time", + FT_UINT24, BASE_HEX, NULL, 0, + "Time of the real time clock", HFILL } + }, + + { &hf_sbus_web_size, + { "Web server packet size", "sbus.web.size", + FT_UINT8, BASE_HEX, NULL, 0, + "Web server packet size", HFILL } + }, + + { &hf_sbus_web_aid, + { "AID", "sbus.web.aid", + FT_UINT8, BASE_HEX, NULL, 0, + "Web server command/status code (AID)", HFILL } + }, + + { &hf_sbus_web_seq, + { "Sequence", "sbus.web.seq", + FT_UINT8, BASE_HEX, NULL, 0, + "Web server sequence nr (PACK_N)", HFILL } + }, + + { &hf_sbus_crc, + { "Checksum", "sbus.crc", + FT_UINT16, BASE_HEX, NULL, 0, + "CRC 16", HFILL } + }, + + { &hf_sbus_crc_bad, + { "Bad Checksum", "sbus.crc_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, + "A bad checksum in the telegram", HFILL }}, + + { &hf_sbus_flags_accu, + { "ACCU", "sbus.flags.accu", + FT_BOOLEAN, 8, TFS(&tfs_sbus_flags), F_ACCU, + "PCD Accumulator", HFILL } + }, + + { &hf_sbus_flags_error, + { "Error flag", "sbus.flags.error", + FT_BOOLEAN, 8, TFS(&tfs_sbus_flags), F_ERROR, + "PCD error flag", HFILL } + }, + + { &hf_sbus_flags_negative, + { "N-flag", "sbus.flags.nflag", + FT_BOOLEAN, 8, TFS(&tfs_sbus_flags), F_NEGATIVE, + "Negative status flag", HFILL } + }, + + { &hf_sbus_flags_zero, + { "Z-flag", "sbus.flags.zflag", + FT_BOOLEAN, 8, TFS(&tfs_sbus_flags), F_ZERO, + "Zero status flag", HFILL } + }, + }; + +/* Setup protocol subtree array */ + static gint *ett[] = { + &ett_sbus, + &ett_sbus_ether, + &ett_sbus_data, + }; + +/* Register the protocol name and description */ + proto_sbus = proto_register_protocol("SAIA S-Bus", + "SBUS", "sbus"); + +/* Required function calls to register the header fields and subtrees used */ + proto_register_field_array(proto_sbus, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + register_init_routine(&sbus_init_protocol); +} + +void +proto_reg_handoff_sbus(void) +{ + dissector_handle_t sbus_handle; + + sbus_handle = create_dissector_handle(dissect_sbus, + proto_sbus); + dissector_add("udp.port", 5050, sbus_handle); +} + +/* Stuff to register the dissector when it's used as a dll or shared library */ +#ifndef ENABLE_STATIC +G_MODULE_EXPORT void +plugin_register(void) +{ + static int inited = 0; + + /* register the sbus protocol, protocol fields, and subtrees */ + if (proto_sbus == -1 ) { /*was !inited before CD051017*/ + /* execute protocol initialization only once */ + proto_register_sbus(); + inited = 1; + } +} + +G_MODULE_EXPORT void +plugin_reg_handoff(void) +{ + proto_reg_handoff_sbus(); +} +#endif Index: /ethereal/plugins/sbus/Makefile.common =================================================================== --- /ethereal/plugins/sbus/Makefile.common (revision 0) +++ /ethereal/plugins/sbus/Makefile.common (revision 0) @@ -0,0 +1,33 @@ +# Makefile.common for Ether-S-Bus plugin +# Contains the stuff from Makefile.am and Makefile.nmake that is +# a) common to both files and +# b) portable between both files +# +# $Id: Makefile.common 17961 2006-04-22 20:26:16Z guy $ +# +# Ethereal - Network traffic analyzer +# By Gerald Combs <gerald@xxxxxxxxxxxx> +# 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. + +# the name of the plugin +PLUGIN_NAME = sbus + +# the dissector sources (without any helpers) +DISSECTOR_SRC = \ + packet-sbus.c + +# corresponding headers Index: /ethereal/plugins/sbus/authors =================================================================== --- /ethereal/plugins/sbus/authors (revision 0) +++ /ethereal/plugins/sbus/authors (revision 0) @@ -0,0 +1,3 @@ +Author : +Christian Durrer <christian.durrer@xxxxxxxxxxxx> + Index: /ethereal/plugins/sbus/ChangeLog =================================================================== --- /ethereal/plugins/sbus/ChangeLog (revision 0) +++ /ethereal/plugins/sbus/ChangeLog (revision 0) @@ -0,0 +1,2 @@ +$Id: ChangeLog 11400 2004-07-18 00:24:25Z guy $ + Index: /ethereal/plugins/sbus/Makefile.nmake =================================================================== --- /ethereal/plugins/sbus/Makefile.nmake (revision 0) +++ /ethereal/plugins/sbus/Makefile.nmake (revision 0) @@ -0,0 +1,31 @@ +# +# $Id: Makefile.nmake 13596 2005-03-05 06:28:10Z lroland $ +# + +include ..\..\config.nmake + +############### no need to modify below this line ######### + +CFLAGS=/DHAVE_CONFIG_H /I../.. /I../../wiretap $(GLIB_CFLAGS) \ + /I$(PCAP_DIR)\include -D_U_="" $(LOCAL_CFLAGS) + +LDFLAGS = /NOLOGO /INCREMENTAL:no /MACHINE:I386 $(LOCAL_LDFLAGS) + +!IFDEF ENABLE_LIBETHEREAL +LINK_PLUGIN_WITH=..\..\epan\libethereal.lib +CFLAGS=/DHAVE_WIN32_LIBETHEREAL_LIB /D_NEED_VAR_IMPORT_ $(CFLAGS) + +OBJECTS=packet-sbus.obj + +sbus.dll sbus.exp sbus.lib : $(OBJECTS) $(LINK_PLUGIN_WITH) + link -dll /out:sbus.dll $(LDFLAGS) $(OBJECTS) $(LINK_PLUGIN_WITH) \ + $(GLIB_LIBS) + +!ENDIF + +clean: + rm -f $(OBJECTS) sbus.dll sbus.exp sbus.lib *.pdb + +distclean: clean + +maintainer-clean: distclean Index: /ethereal/plugins/sbus/moduleinfo.h =================================================================== --- /ethereal/plugins/sbus/moduleinfo.h (revision 0) +++ /ethereal/plugins/sbus/moduleinfo.h (revision 0) @@ -0,0 +1,17 @@ +/* Included *after* config.h, in order to re-define these macros */ + +#ifdef PACKAGE +#undef PACKAGE +#endif + +/* Name of package */ +#define PACKAGE "sbus" + + +#ifdef VERSION +#undef VERSION +#endif + +/* Version number of package */ +#define VERSION "0.0.4" + Index: /ethereal/plugins/sbus/copying =================================================================== --- /ethereal/plugins/sbus/copying (revision 0) +++ /ethereal/plugins/sbus/copying (revision 0) @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + 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 + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. Index: /ethereal/plugins/sbus/Makefile.am =================================================================== --- /ethereal/plugins/sbus/Makefile.am (revision 0) +++ /ethereal/plugins/sbus/Makefile.am (revision 0) @@ -0,0 +1,44 @@ +# Makefile.am +# Automake file for Ethereal/ACN +# +# $Id: Makefile.am 11400 2004-07-18 00:24:25Z guy $ +# +# Ethereal - Network traffic analyzer +# By Gerald Combs <gerald@xxxxxxxxxxxx> +# 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. +# + +INCLUDES = -I$(top_srcdir) + +plugindir = @plugindir@ + +plugin_LTLIBRARIES = sbus.la +sbus_la_SOURCES = packet-sbus.c moduleinfo.h +sbus_la_LDFLAGS = -module -avoid-version +sbus_la_LIBADD = @PLUGIN_LIBS@ + +# Libs must be cleared, or else libtool won't create a shared module. +# If your module needs to be linked against any particular libraries, +# add them here. +LIBS = + +CLEANFILES = \ + sbus \ + *~ + +EXTRA_DIST = \ + Makefile.nmake
_______________________________________________ Ethereal-dev mailing list Ethereal-dev@xxxxxxxxxxxx http://www.ethereal.com/mailman/listinfo/ethereal-dev
- Follow-Ups:
- Prev by Date: Re: [Ethereal-dev] Problems linking ethereal-0.99 on solaris 8
- Next by Date: [Ethereal-dev] win32 dll debugging
- Previous by thread: Re: [Ethereal-dev] Problems linking ethereal-0.99 on solaris 8
- Next by thread: Re: [Ethereal-dev] Re: Patch for new dissector plugin for Ether-S-Bus telegrams modified (Jaap Keuter)
- Index(es):