/* packet-sbus.c

 * Routines for Ether-S-Bus dissection

 * Copyright 2010, Christian Durrer <christian.durrer@sensemail.ch>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/conversation.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

void proto_register_sbus(void);

void proto_reg_handoff_sbus(void);

static dissector_handle_t sbus_handle;

#define SBUS_UDP_PORT   5050 /* Not IANA registered */

/* Attribute 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    */

/* Read/write block command codes*/

#define SBUS_WR_START_OF_STREAM        0x00

#define SBUS_WR_BLOCK_DATA_STREAM      0x01

#define SBUS_WR_BLOCK_END_OF_STREAM    0x02

#define SBUS_WR_ABORT_BLOCK_STREAM     0x07

#define SBUS_WR_BLOCK_DATA_BYTES       0x08

#define SBUS_RD_BLOCK_START_OF_STREAM  0X10

#define SBUS_RD_BLOCK_DATA_STREAM      0x11

#define SBUS_RD_ABORT_BLOCK_STREAM     0x17

#define SBUS_RD_BLOCK_DATA_BYTES       0x18

#define SBUS_DELETE_BLOCK              0x20

#define SBUS_GET_BLOCK_SIZE            0x21

#define SBUS_GET_PROGRAM_BLOCK_LIST    0x22

/* Read/write block types*/

#define SBUS_RD_WR_CONFIGURATION_FILE  0x20

#define SBUS_RD_WR_PROGRAM_BLOCK_FILE  0x21

#define SBUS_RD_WR_UNKNOWN_BLOCK_TYPE  0x83

/* Read/write block error codes*/

#define SBUS_RD_WR_NAK                 0x80

#define SBUS_RD_WR_NAK_INVALID_SIZE    0x8A

/* Initialize the protocol and registered fields */

static int proto_sbus;

static int hf_sbus_length;

static int hf_sbus_version;

static int hf_sbus_protocol;

static int hf_sbus_sequence;

static int hf_sbus_attribut;

static int hf_sbus_dest;

static int hf_sbus_address;

static int hf_sbus_command;

static int hf_sbus_command_extension;

static int hf_sbus_rcount;

static int hf_sbus_multimedia_length;

static int hf_sbus_sub_length;

static int hf_sbus_wcount;

static int hf_sbus_wcount_calculated;

static int hf_sbus_fio_count;

static int hf_sbus_addr_rtc;

static int hf_sbus_addr_iof;

static int hf_sbus_addr_db;

static int hf_sbus_addr_base_element;

static int hf_sbus_addr_eeprom;

static int hf_sbus_addr_prog;

static int hf_sbus_addr_68k;

static int hf_sbus_block_type;

static int hf_sbus_block_nr;

static int hf_sbus_nbr_elements;

static int hf_sbus_display_register;

static int hf_sbus_data_rtc;

static int hf_sbus_data_byte;

static int hf_sbus_data_byte_hex;

static int hf_sbus_data_iof;

static int hf_sbus_cpu_type;

static int hf_sbus_fw_version;

static int hf_sbus_sysinfo_nr;

static int hf_sbus_sysinfo0_1;

static int hf_sbus_sysinfo0_2;

static int hf_sbus_sysinfo0_3;

static int hf_sbus_sysinfo0_4;

static int hf_sbus_sysinfo0_5;

static int hf_sbus_acknackcode;

static int hf_sbus_cpu_status;

static int hf_sbus_week_day;

static int hf_sbus_date;

static int hf_sbus_time;

static int hf_sbus_crc;

static int hf_sbus_crc_status;

static int hf_sbus_flags_accu;

static int hf_sbus_flags_error;

static int hf_sbus_flags_negative;

static int hf_sbus_flags_zero;

/* Web server telegram */

static int hf_sbus_web_size;

static int hf_sbus_web_aid;

static int hf_sbus_web_seq;

/* Read/Write block telegram*/

static int hf_sbus_rdwr_block_length;

static int hf_sbus_rdwr_block_length_ext;

static int hf_sbus_rdwr_telegram_type;

static int hf_sbus_rdwr_telegram_sequence;

static int hf_sbus_rdwr_block_size;

static int hf_sbus_rdwr_block_addr;

static int hf_sbus_rdwr_file_name;

static int hf_sbus_rdwr_list_type;

static int hf_sbus_rdwr_acknakcode;

/* Request-Response tracking */

static int hf_sbus_response_in;

static int hf_sbus_response_to;

static int hf_sbus_response_time;

static int hf_sbus_timeout;

static int hf_sbus_request_in;

/* Initialize the subtree pointers */

static int ett_sbus;

static int ett_sbus_ether;

static int ett_sbus_data;

static expert_field ei_sbus_retry;

static expert_field ei_sbus_telegram_not_acked;

static expert_field ei_sbus_crc_bad;

static expert_field ei_sbus_telegram_not_implemented;

static expert_field ei_sbus_no_request_telegram;

/* 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 (6 and 7 corrected C. Durrer, 20.02.2019)*/

static const value_string sbus_block_types[] = {

       {0x00, "COB"},                        /* Cyclic organization block */

       {0x01, "XOB"},                        /* Exception organization block */

       {0x02, "PB"},                         /* Program block */

       {0x03, "FB"},                         /* Function block */

       {0x04, "ST"},                         /* Step of Graftec structure*/

       {0x05, "TR"},                         /* Transition of Graftec structure*/

       {0x06, "TEXT"},                       /* Text*/

       {0x07, "DB"},                         /* Data Block*/

       {0x08, "SB"},                         /* Sequential Block (Graftec)*/

       {0x09, "DBX"},                        /* Special Data Block*/

       {0x10, "BACnet"},                     /* BACnet configuration block */

       {0x11, "CANopen"},                    /* CANopen configuration */

       {0x12, "LONIP"},                      /* LONIP configuration */

       {0x20, "Configuration file"},         /* LONIP configuration */

       {0x21, "Program block file"},         /* LONIP configuration */

       {0xFE, "All configuration blocks"},   /* all configuration blocks (delete blocks only) */

       {0xFF, "All blocks"},                 /* all blocks (incl. program blocks) (delete blocks only) */

       {0, NULL}

};

static value_string_ext sbus_block_types_ext = VALUE_STRING_EXT_INIT(sbus_block_types);

/* 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)"},

       {0x13, "Read write multi-medias"},

       {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 memory*"},

       {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 status 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"},

       {0xA9, "Read/write block data*"},

       {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 value_string_ext sbus_command_vals_ext = VALUE_STRING_EXT_INIT(sbus_command_vals);

static const value_string webserver_aid_vals[] = {

       {0x01, "Partial 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 value_string rdwrblock_vals[] = {

       {0x00, "WR block start of stream"},

       {0x01, "WR block data stream"},

       {0x02, "WR block end of stream"},

       {0x07, "Abort block WR stream"},

       {0x08, "WR block data"},

       {0x10, "RD block start of stream"},

       {0x11, "RD block data stream"},

       {0x17, "Abort block RD stream"},

       {0x18, "RD block data"},

       {0x20, "Delete block"},

       {0x21, "Get block size"},

       {0x22, "Get program block list"},

       {0, NULL}

};

static value_string_ext rdwrblock_vals_ext = VALUE_STRING_EXT_INIT(rdwrblock_vals);

static const value_string rdwrblock_sts[] = {

       {0x00, "ACK (Acknowledged)"},

       {0x01, "Data"},

       {0x02, "Busy"},

       {0x03, "End of stream"},

       {0x04, "Data EOF reached"},

       {0x80, "NAK"},

       {0x81, "NAK, unknown Tlg_Type"},

       {0x82, "NAK, not supported  Tlg_Type"},

       {0x83, "NAK, unknown Block Type"},

       {0x84, "NAK, out of sequence"},

       {0x85, "NAK, not supported Block number"},

       {0x86, "NAK, Block Size invalid (to big)"},

       {0x87, "NAK, Block Address invalid"},

       {0x88, "NAK, CRC invalid"},

       {0x89, "NAK, invalid status"},

       {0x8A, "NAK, invalid command size (w-count)"},

       {0xFF, "Abort (stream)"},

       {0, NULL}

};

static value_string_ext rdwrblock_sts_ext = VALUE_STRING_EXT_INIT(rdwrblock_sts);

static const value_string rdwrblock_list_type_vals[] = {

       {0x40, "Start request of program block"},

       {0x41, "Get next program block"},

       {0xFF, "Abort get list"},

       {0, NULL}

};

static const unsigned 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 {

       uint32_t conversation;  /*Conversation ID*/

       uint16_t sequence;      /*Sequence number of request telegram*/

} sbus_request_key;

typedef struct {

    uint8_t cmd_code; /*multimedia command code*/

    uint8_t count;    /*rcount of sub-request*/

} sbus_subrequest;

typedef struct {

       uint8_t cmd_code;       /*command code from request*/

       uint8_t count;          /*rcount value*/

       uint8_t sysinfo;        /*system information number*/

       uint8_t block_tlg;      /*telegram type of RD/WR block telegrams*/

       uint8_t retry_count;    /*number of retries*/

       uint32_t req_frame;     /*frame number of last request*/

       uint32_t resp_frame;    /*frame number of response*/

       nstime_t req_time;     /*time of the last request*/

       uint8_t mm_request_count;       /*multi-media subrequest count*/

       wmem_list_t *sbus_subrequests; /*list containing sub requests of multi-media request*/

} sbus_request_val;

/* The hash structure (for conversations)*/

static wmem_map_t *sbus_request_hash;

static unsigned crc_calc (unsigned crc, unsigned val)

{

       int indx;

       unsigned ncrc;

       indx = (((crc >> 8) ^ val) & 0xff);

       ncrc = crc_table[indx] ^ ((crc << 8) & 0xffff);

       return ncrc;

}

/* Hash functions*/

static int sbus_equal(const void *v, const void *w)

{

       const sbus_request_key *v1 = (const sbus_request_key *)v;

       const sbus_request_key *v2 = (const sbus_request_key *)w;

       if (v1->conversation == v2->conversation &&

           v1->sequence == v2->sequence) {

              return 1;

       }

       return 0;

}

static unsigned sbus_hash(const void *v)

{

       const sbus_request_key *key = (const sbus_request_key *)v;

       unsigned val;

       val = key->conversation + key->sequence;

       return val;

}

/* check whether the packet looks like SBUS or not */

static bool

is_sbus_pdu(tvbuff_t *tvb)

{

       uint32_t length;

       /* we need at least 8 bytes to determine whether this is sbus or

          not*/

       if(tvb_captured_length(tvb)<8){

              return false;

       }

       /* the length must be >= 8 bytes to accommodate the header,

          it also must be <65536 to fit inside a udp packet

       */

       length=tvb_get_ntohl(tvb, 0);

       if ( (length<8) || (length>65535) ) {

              return false;

       }

       if (tvb_reported_length(tvb) != length) {

              return false;

       }

       /* First four byte indicate the length which must be at least 12 bytes*/

       if (tvb_get_ntohl(tvb, 0) < 12) {

              return false;

       }

       /* Fifth byte indicates protocol version which can be 0 or 1*/

       if (tvb_get_uint8(tvb, 4) > 0x01) {

              return false;

       }

       /* Sixth byte indicates protocol type and must be 0*/

       if ( tvb_get_uint8(tvb, 5) > 0x01 ) {

              return false;

       }

       /* Seventh and eighth bytes indicate the packet sequence number and can

          be 0 to 65565 (--> check does not make sense)*/

       /* Ninth byte the "attributes character" and must be either 0, 1 or 2

          (request, response or ACK/NAK)*/

       if (tvb_get_uint8(tvb, 8) > 0x02 ) {

              return false;

       }

       return true;

}

/*add the tree structure for one request media type to the tree*/

static int add_media_access_to_tree(int sbus_cmd_code, tvbuff_t *tvb, proto_tree *tree, int offset)

{

       int i, j;

       int sbus_media_cnt;

       proto_tree *sub_tree;

       uint8_t sbus_fio_cnt;

       uint32_t sbus_binaries;

       uint32_t sbus_binarymasked;

       uint32_t sbus_show_bin;

       uint32_t sbus_helper;

       switch (sbus_cmd_code) {

                            /*Read Counter, Register or Timer*/

               case SBUS_RD_COUNTER:

               case SBUS_RD_REGISTER:

               case SBUS_RD_TIMER:

                       sbus_media_cnt = (tvb_get_uint8(tvb,offset))+1;

                       proto_tree_add_uint(tree,

                                           hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt);

                       offset += 1;

                       proto_tree_add_item(tree,

                                           hf_sbus_addr_rtc, tvb, offset, 2, ENC_BIG_ENDIAN);

                       offset += 2;

                       break;

                                   /*Read Flag, Input or Output*/

               case SBUS_RD_FLAG:

               case SBUS_RD_INPUT:

               case SBUS_RD_OUTPUT:

                        sbus_media_cnt = (tvb_get_uint8(tvb,offset))+1;

                        proto_tree_add_uint(tree,

                                   hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt);

                        offset += 1;

                        proto_tree_add_item(tree,

                                   hf_sbus_addr_iof, tvb, offset, 2, ENC_BIG_ENDIAN);

                        offset += 2;

                       break;

                                   /*Write Register Timer Counter*/

               case SBUS_WR_COUNTER:

               case SBUS_WR_REGISTER:

               case SBUS_WR_TIMER:

                       sbus_media_cnt = (tvb_get_uint8(tvb,offset));

                       sbus_media_cnt = ((sbus_media_cnt - 1)/4);

                       proto_tree_add_uint(tree,

                                           hf_sbus_wcount_calculated, tvb, offset,

                                           1, sbus_media_cnt);

                       proto_tree_add_item(tree,

                                           hf_sbus_wcount, tvb, offset, 1, ENC_BIG_ENDIAN);

                       offset += 1;

                       proto_tree_add_item(tree,

                                           hf_sbus_addr_rtc, tvb, offset, 2, ENC_BIG_ENDIAN);

                       offset += 2;

                       /*Add subtree for Data*/

                       sub_tree = proto_tree_add_subtree(tree, tvb, offset,

                                                ((sbus_media_cnt) * 4), ett_sbus_data, NULL, "Data");

                       for (i=((sbus_media_cnt)); i>0; i--) {

                              proto_tree_add_item(sub_tree,

                                  hf_sbus_data_rtc, tvb, offset,

                                   4, ENC_BIG_ENDIAN);

                              offset += 4;

                       }

                       break;

                                   /* Write flags and outputs*/

               case SBUS_WR_FLAG:

               case SBUS_WR_OUTPUT:

                       sbus_media_cnt = (tvb_get_uint8(tvb,offset));

                       sbus_media_cnt = (sbus_media_cnt - 2);

                       proto_tree_add_uint(tree,

                                   hf_sbus_wcount_calculated, tvb, offset,

                                   1, sbus_media_cnt);

                       proto_tree_add_item(tree,

                                   hf_sbus_wcount, tvb, offset, 1, ENC_BIG_ENDIAN);

                       offset += 1;

                       proto_tree_add_item(tree,

                                   hf_sbus_addr_iof, tvb, offset, 2, ENC_BIG_ENDIAN);

                       offset += 2;

                       sbus_fio_cnt = (tvb_get_uint8(tvb,offset));

                       sbus_fio_cnt = ((sbus_fio_cnt + 1));

                       proto_tree_add_uint(tree,

                                   hf_sbus_fio_count, tvb, offset, 1, sbus_fio_cnt);

                       offset += 1;

                       /*Add subtree for Data*/

                       sub_tree = proto_tree_add_subtree(tree, tvb, offset,

                                   sbus_media_cnt, ett_sbus_data, NULL, "Data");

                       for (i=sbus_media_cnt; i>0; i--) {

                                   sbus_helper = 1;

                                   sbus_show_bin = 0;

                                   sbus_binarymasked = 0x01;

                                   sbus_binaries = tvb_get_uint8(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(sub_tree,

                                                    hf_sbus_data_iof, tvb, offset, 1, sbus_show_bin,

                                                    "Binary data: %08u", sbus_show_bin);

                                   offset += 1;

                       }

                       break;

               case SBUS_RD_DATA_BLOCK:

                       sbus_media_cnt = (tvb_get_uint8(tvb,offset))+1;

                       proto_tree_add_uint(tree,

                                           hf_sbus_rcount, tvb, offset, 1, sbus_media_cnt);

                       offset += 1;

                       proto_tree_add_item(tree,

                                           hf_sbus_addr_db, tvb, offset, 2, ENC_BIG_ENDIAN);

                       offset += 2;

                       /*add base element address*/

                       proto_tree_add_item(tree,

                                           hf_sbus_addr_base_element, tvb, offset, 2, ENC_BIG_ENDIAN);

                       offset += 2;

                       break;

              }

       return offset;

}

/*add the tree structure for one response media type to the tree*/

static int add_media_response_to_tree(int cmd_code, int count, tvbuff_t *tvb, proto_tree *tree, int offset)

{

       int i, j;

       proto_tree *sub_tree;

       uint32_t sbus_binaries;

       uint32_t sbus_binarymasked;

       uint32_t sbus_show_bin;

       uint32_t sbus_helper;

       switch (cmd_code) {

               /*Add subtree for Data*/

               case SBUS_RD_COUNTER:

               case SBUS_RD_REGISTER:

               case SBUS_RD_TIMER:

               case SBUS_RD_USER_MEMORY:

               case SBUS_RD_PROGRAM_LINE:

               case SBUS_RD_USER_EEPROM_REGISTER:

               case SBUS_RD_DATA_BLOCK:

                      sub_tree = proto_tree_add_subtree(tree, tvb, offset,

                                               (count * 4), ett_sbus_data, NULL, "Data");

                      for (i=count; i>0; i--) {

                             proto_tree_add_item(sub_tree,

                                                 hf_sbus_data_rtc, tvb, offset,

                                                 4, ENC_BIG_ENDIAN);

                             offset += 4;

                                   }

                      break;

               /* Add binary data I, O, F*/

               case SBUS_RD_FLAG:

               case SBUS_RD_INPUT:

               case SBUS_RD_OUTPUT:

                      /*Add subtree for Data*/

                      sub_tree = proto_tree_add_subtree(tree, tvb, offset,

                                               (((count) + 7) / 8), ett_sbus_data, NULL, "Data");

                      for (i=(((count) + 7) / 8); i>0; i--) {

                             sbus_helper = 1;

                             sbus_show_bin = 0;

                             sbus_binarymasked = 0x01;

                             sbus_binaries = tvb_get_uint8(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(sub_tree,

                                                  hf_sbus_data_iof, tvb, offset, 1, sbus_show_bin,

                                                  "Binary data: %08u", sbus_show_bin);

                       offset += 1;

                       }

                       break;

              }

       return offset;

}

static int get_response_length(int cmd_code, int count)

{

       int length;

       length = 0;

       switch (cmd_code) {

               /*Get length of 32 bit data*/

               case SBUS_RD_COUNTER:

               case SBUS_RD_REGISTER:

               case SBUS_RD_TIMER:

               case SBUS_RD_USER_MEMORY:

               case SBUS_RD_PROGRAM_LINE:

               case SBUS_RD_USER_EEPROM_REGISTER:

               case SBUS_RD_DATA_BLOCK:

                      length = count * 4;

                      break;

               /* Get length of binary data I, O, F*/

               case SBUS_RD_FLAG:

               case SBUS_RD_INPUT:

               case SBUS_RD_OUTPUT:

                      length = ((count) + 7) / 8;

                      break;

              }

       return length;

}

static int add_sbus_subrequest(tvbuff_t *tvb, wmem_list_t *request_list, int offset)

{

       /*append subrequest info to requests lists and return number of sub-requests*/

       int subrequest_count;

       int internal_wcount;

       int internal_subwcount;

       int internal_offset;

       int internal_last_offset;

       internal_offset = offset;

       subrequest_count = 0;

       internal_wcount = tvb_get_uint8(tvb,internal_offset);

       internal_last_offset = internal_wcount + offset + 1; /*check for new sub requests until this end offset*/

       for(int i=0; i < 64; i +=1){   /*max sub-requests number is 64*/

              if (internal_last_offset > internal_offset) {

                     sbus_subrequest *sub_req;

                     sub_req = wmem_new(wmem_file_scope(), sbus_subrequest);

                     internal_offset += 1; /*move to the next sub-request wcount*/

                     internal_subwcount = tvb_get_uint8(tvb,internal_offset);

                     internal_offset += 1;

                     sub_req->cmd_code = tvb_get_uint8(tvb,internal_offset);

                     internal_offset += 1;

                     sub_req->count = tvb_get_uint8(tvb,internal_offset) + 1;

                     internal_offset += internal_subwcount -1;

                     subrequest_count += 1;

                     wmem_list_append(request_list, sub_req);

              }

       }

       return subrequest_count;

}

/*Dissect the telegram*/

static int

dissect_sbus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

/* Set up structures needed to add the protocol subtree and manage it */

       proto_item *ti, *hi;

       proto_tree *sbus_tree, *ethsbus_tree, *sbusdata_tree, *sbus_multimedia_tree;

       int i;        /*for CRC calculation*/

       int offset;

       int sbus_end_multimedia;

       int sbus_eth_len;

       unsigned sbus_crc_calc;

       uint8_t sbus_attribut;

       uint8_t sbus_media_cnt;

       sbus_subrequest *mm_sub_req;

       wmem_list_frame_t *frame;

       uint8_t sbus_multimedia_total;

       uint8_t sbus_multimedia_cnt;

       uint8_t sbus_multimedia_cmd;

       uint8_t sbus_multimedia_att;

       uint8_t sbus_multimedia_bytes;

       uint8_t sbus_cmd_code;

       uint8_t sbus_web_size;

       uint8_t sbus_web_aid;

       uint8_t sbus_web_seq;

       uint8_t sbus_rdwr_type;

       uint8_t sbus_rdwr_sequence;

       uint8_t sbus_rdwr_block_tlg;

       uint8_t sbus_rdwr_block_type;

       uint8_t sbus_rdwr_ack_nak;

       uint8_t sbus_quint8_helper0;

       uint16_t sbus_ack_code;

       uint32_t sbus_rdwr_length;

       uint32_t sbus_helper;

       uint32_t sbus_helper1;

       uint32_t sbus_helper2;

       char *tmp_string;

       nstime_t ns; /*we use this for the response time*/

/* Set up conversations*/

       conversation_t *conversation;

       sbus_request_key request_key, *new_request_key;

       sbus_request_val *request_val;

       /*sbus_multimedia_requests *multimedia_requests;*/

       /* does this look like an sbus pdu? */

       if(!is_sbus_pdu(tvb)){

           return 0;

       }

/* Make entries in Protocol column and Info column on summary display */

       col_set_str(pinfo->cinfo, COL_PROTOCOL, "S-Bus");

       col_clear(pinfo->cinfo, COL_INFO);

       conversation = find_or_create_conversation(pinfo);

       request_key.conversation = conversation->conv_index;

       request_key.sequence = tvb_get_ntohs(tvb,6);

       request_val = (sbus_request_val *) wmem_map_lookup(sbus_request_hash,

                            &request_key);

       /*Get type of telegram for finding retries

        *As we are storing the info in a hash table we need to update the info

        *also in case this is no retry*/

       sbus_attribut = tvb_get_uint8(tvb,8);

       if (request_val && sbus_attribut == SBUS_REQUEST) {

              if (request_val->req_frame < pinfo->num){ /*a retry; req_frame smaller this frame*/

                     request_val->retry_count +=1;

              }

              else { /*we have a conversation but this is not a retry so we store the packet info*/

                     request_val->retry_count = 0;

                     request_val->req_frame = pinfo->num; /*store actual frame nr.*/

                     request_val->req_time = pinfo->abs_ts;

              }

       }

       if (request_val && (sbus_attribut == SBUS_RESPONSE ||

                                      sbus_attribut == SBUS_ACKNAK)) { /*a response*/

            request_val->resp_frame = pinfo->num; /*so store this frame nr.*/

       }

       /* Only allocate a new hash element when it's a request*/

       sbus_attribut = tvb_get_uint8(tvb,8);

       if ( !request_val && sbus_attribut == 0 ) {/* request telegram */

              new_request_key = wmem_new(wmem_file_scope(), sbus_request_key);

              *new_request_key = request_key;

              request_val = wmem_new(wmem_file_scope(), sbus_request_val);

              request_val->cmd_code=tvb_get_uint8(tvb,10);

              request_val->retry_count=0;

              request_val->req_frame = pinfo->num; /*store actual frame nr.*/

              request_val->req_time = pinfo->abs_ts;

              request_val->resp_frame = 0; /*response frame is not known yet*/

              request_val->mm_request_count = 0; /*init to 0 in case it is no multi media request*/

              if (((request_val->cmd_code) == SBUS_RD_USER_EEPROM_REGISTER) ||

                  ((request_val->cmd_code) == SBUS_WR_USER_EEPROM_REGISTER)) {

                     request_val->count=((tvb_get_uint8(tvb,12))+1);

              } else if ((request_val->cmd_code) == SBUS_RDWR_MULTI_MEDIAS) {

                     request_val->count=tvb_get_uint8(tvb,11);      /*length of all sub requests in bytes*/

                     /*create list for sub requests to be able to process response frame later on*/

                     request_val->sbus_subrequests = wmem_list_new(wmem_file_scope());

                     /*add the sub requests to the list*/

                     request_val->mm_request_count = add_sbus_subrequest(tvb, request_val->sbus_subrequests, 11);