/* packet-canopen.c * Routines for CANopen dissection * Copyright 2011, Yegor Yefremov * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * SPDX-License-Identifier: GPL-2.0-or-later */ #include "config.h" #include #include "packet-socketcan.h" void proto_register_canopen(void); void proto_reg_handoff_canopen(void); static dissector_handle_t canopen_handle; /* Initialize the protocol and registered fields */ static int proto_canopen; static int hf_canopen_cob_id; static int hf_canopen_function_code; static int hf_canopen_node_id; static int hf_canopen_pdo_data; static int hf_canopen_pdo_data_string; static int hf_canopen_sdo_cmd; static int hf_canopen_sdo_cmd_ccs; static int hf_canopen_sdo_cmd_scs; static int hf_canopen_sdo_cmd_ccs5_subcommand; static int hf_canopen_sdo_cmd_scs5_subcommand; static int hf_canopen_sdo_cmd_ccs6_subcommand; static int hf_canopen_sdo_cmd_scs6_subcommand; static int hf_canopen_sdo_cmd_block_crc_support; static int hf_canopen_sdo_cmd_block_s; static int hf_canopen_sdo_cmd_block_n; static int hf_canopen_sdo_cmd_block_blksize; static int hf_canopen_sdo_cmd_block_pst; static int hf_canopen_sdo_cmd_block_ackseq; static int hf_canopen_sdo_cmd_toggle; static int hf_canopen_sdo_cmd_updown_n; static int hf_canopen_sdo_cmd_updown_c; static int hf_canopen_sdo_cmd_init_n; static int hf_canopen_sdo_cmd_init_e; static int hf_canopen_sdo_cmd_init_s; static int hf_canopen_sdo_main_idx; static int hf_canopen_sdo_sub_idx; static int hf_canopen_sdo_data; static int hf_canopen_sdo_abort_code; static int hf_canopen_reserved; static int hf_canopen_em_err_code; static int hf_canopen_em_err_reg; static int hf_canopen_em_err_reg_ge; static int hf_canopen_em_err_reg_cu; static int hf_canopen_em_err_reg_vo; static int hf_canopen_em_err_reg_te; static int hf_canopen_em_err_reg_co; static int hf_canopen_em_err_reg_de; static int hf_canopen_em_err_reg_re; static int hf_canopen_em_err_reg_ma; static int hf_canopen_em_err_field; static int hf_canopen_nmt_ctrl_cs; static int hf_canopen_nmt_ctrl_node_id; static int hf_canopen_nmt_guard_state; static int hf_canopen_nmt_guard_toggle; static int hf_canopen_sync_counter; static int hf_canopen_lss_cs; static int hf_canopen_lss_addr_vendor; static int hf_canopen_lss_addr_product; static int hf_canopen_lss_addr_revision; static int hf_canopen_lss_addr_revision_low; static int hf_canopen_lss_addr_revision_high; static int hf_canopen_lss_addr_serial; static int hf_canopen_lss_addr_serial_low; static int hf_canopen_lss_addr_serial_high; static int* hf_canopen_lss_addr_ident[] = { &hf_canopen_lss_addr_vendor, &hf_canopen_lss_addr_product, &hf_canopen_lss_addr_revision_low, &hf_canopen_lss_addr_revision_high, &hf_canopen_lss_addr_serial_low, &hf_canopen_lss_addr_serial_high }; static int* hf_canopen_lss_addr_inquire[] = { &hf_canopen_lss_addr_vendor, &hf_canopen_lss_addr_product, &hf_canopen_lss_addr_revision, &hf_canopen_lss_addr_serial }; static int hf_canopen_lss_fastscan_id; static int hf_canopen_lss_fastscan_check; static int hf_canopen_lss_fastscan_sub; static int hf_canopen_lss_fastscan_next; static int hf_canopen_lss_switch_mode; static int hf_canopen_lss_nid; static int hf_canopen_lss_conf_id_err_code; static int hf_canopen_lss_conf_bt_err_code; static int hf_canopen_lss_store_conf_err_code; static int hf_canopen_lss_spec_err; static int hf_canopen_lss_bt_tbl_selector; static int hf_canopen_lss_bt_tbl_index; static int hf_canopen_lss_abt_delay; static int hf_canopen_time_stamp; static int hf_canopen_time_stamp_ms; static int hf_canopen_time_stamp_days; /* Download segment request (ccs=0) decode mask */ static int * const sdo_cmd_fields_ccs0[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_toggle, &hf_canopen_sdo_cmd_updown_n, &hf_canopen_sdo_cmd_updown_c, NULL }; /* Initiate download request (ccs=1) decode mask */ static int * const sdo_cmd_fields_ccs1[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_init_n, &hf_canopen_sdo_cmd_init_e, &hf_canopen_sdo_cmd_init_s, NULL }; /* Initiate upload request (ccs=2) decode mask */ static int * const sdo_cmd_fields_ccs2[] = { &hf_canopen_sdo_cmd_ccs, NULL }; /* Download segment request (ccs=3) decode mask */ static int * const sdo_cmd_fields_ccs3[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_toggle, NULL }; /* */ static int * const sdo_cmd_fields_ccs4[] = { &hf_canopen_sdo_cmd_ccs, NULL }; /* Block upload (ccs=5,cs=0) decode mask */ static int * const sdo_cmd_fields_ccs5_subcommand0[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_block_crc_support, &hf_canopen_sdo_cmd_ccs5_subcommand, NULL }; /* Block upload (ccs=5,cs=1,2,3) decode mask */ static int * const sdo_cmd_fields_ccs5_subcommand1[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_ccs5_subcommand, NULL }; /* Block download (ccs=6,cs=0) decode mask */ static int * const sdo_cmd_fields_ccs6_subcommand0[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_block_crc_support, &hf_canopen_sdo_cmd_block_s, &hf_canopen_sdo_cmd_ccs6_subcommand, NULL }; /* Block download (ccs=6,cs=1) decode mask */ static int * const sdo_cmd_fields_ccs6_subcommand1[] = { &hf_canopen_sdo_cmd_ccs, &hf_canopen_sdo_cmd_block_n, &hf_canopen_sdo_cmd_ccs6_subcommand, NULL }; static int * const *_sdo_cmd_fields_ccs[] = { sdo_cmd_fields_ccs0, sdo_cmd_fields_ccs1, sdo_cmd_fields_ccs2, sdo_cmd_fields_ccs3, sdo_cmd_fields_ccs4, }; static int * const *_sdo_cmd_fields_ccs5[] = { sdo_cmd_fields_ccs5_subcommand0, sdo_cmd_fields_ccs5_subcommand1, sdo_cmd_fields_ccs5_subcommand1, sdo_cmd_fields_ccs5_subcommand1 }; static int * const *_sdo_cmd_fields_ccs6[] = { sdo_cmd_fields_ccs6_subcommand0, sdo_cmd_fields_ccs6_subcommand1 }; /* Emergency error register decode mask */ static int * const em_err_reg_fields[] = { &hf_canopen_em_err_reg_ge, &hf_canopen_em_err_reg_cu, &hf_canopen_em_err_reg_vo, &hf_canopen_em_err_reg_te, &hf_canopen_em_err_reg_co, &hf_canopen_em_err_reg_de, &hf_canopen_em_err_reg_re, &hf_canopen_em_err_reg_ma, NULL }; /* (scs=0) decode mask */ static int * const sdo_cmd_fields_scs0[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_toggle, &hf_canopen_sdo_cmd_updown_n, &hf_canopen_sdo_cmd_updown_c, NULL }; /* (scs=1) decode mask */ static int * const sdo_cmd_fields_scs1[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_toggle, NULL }; /* (scs=2) decode mask */ static int * const sdo_cmd_fields_scs2[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_init_n, &hf_canopen_sdo_cmd_init_e, &hf_canopen_sdo_cmd_init_s, NULL }; /* (scs=3) decode mask */ static int * const sdo_cmd_fields_scs3[] = { &hf_canopen_sdo_cmd_scs, NULL }; /* (scs=4) decode mask */ static int * const sdo_cmd_fields_scs4[] = { &hf_canopen_sdo_cmd_scs, NULL }; /* (scs=5,ss=0) decode mask */ static int * const sdo_cmd_fields_scs5_subcommand0[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_block_crc_support, &hf_canopen_sdo_cmd_scs5_subcommand, NULL }; /* (scs=5,ss=1,2) decode mask */ static int * const sdo_cmd_fields_scs5_subcommand1[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_scs5_subcommand, NULL }; /* (scs=6,ss=0) decode mask */ static int * const sdo_cmd_fields_scs6_subcommand0[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_block_crc_support, &hf_canopen_sdo_cmd_block_s, &hf_canopen_sdo_cmd_scs6_subcommand, NULL }; /* (scs=6,ss=1) decode mask */ static int * const sdo_cmd_fields_scs6_subcommand1[] = { &hf_canopen_sdo_cmd_scs, &hf_canopen_sdo_cmd_block_n, &hf_canopen_sdo_cmd_scs6_subcommand, NULL }; static int * const *_sdo_cmd_fields_scs[] = { sdo_cmd_fields_scs0, sdo_cmd_fields_scs1, sdo_cmd_fields_scs2, sdo_cmd_fields_scs3, sdo_cmd_fields_scs4 }; static int * const *_sdo_cmd_fields_scs5[] = { sdo_cmd_fields_scs5_subcommand0, sdo_cmd_fields_scs5_subcommand1, sdo_cmd_fields_scs5_subcommand1, }; static int * const *_sdo_cmd_fields_scs6[] = { sdo_cmd_fields_scs6_subcommand0, sdo_cmd_fields_scs6_subcommand1 }; /* Initialize the subtree pointers */ static gint ett_canopen; static gint ett_canopen_cob; static gint ett_canopen_type; static gint ett_canopen_sdo_cmd; static gint ett_canopen_em_er; /* broadcast messages */ #define FC_NMT 0x0 #define FC_SYNC 0x1 #define FC_TIME_STAMP 0x2 /* point-to-point messages */ #define FC_EMERGENCY 0x1 #define FC_PDO1_TX 0x3 #define FC_PDO1_RX 0x4 #define FC_PDO2_TX 0x5 #define FC_PDO2_RX 0x6 #define FC_PDO3_TX 0x7 #define FC_PDO3_RX 0x8 #define FC_PDO4_TX 0x9 #define FC_PDO4_RX 0xA #define FC_DEFAULT_SDO_TX 0xB #define FC_DEFAULT_SDO_RX 0xC #define FC_NMT_ERR_CONTROL 0xE static const value_string CAN_open_bcast_msg_type_vals[] = { { FC_NMT, "NMT"}, { FC_SYNC, "SYNC"}, { FC_TIME_STAMP, "TIME STAMP"}, { 0, NULL} }; static const value_string CAN_open_p2p_msg_type_vals[] = { { FC_EMERGENCY, "EMCY"}, { FC_PDO1_TX, "PDO1 (tx)"}, { FC_PDO1_RX, "PDO1 (rx)"}, { FC_PDO2_TX, "PDO2 (tx)"}, { FC_PDO2_RX, "PDO2 (rx)"}, { FC_PDO3_TX, "PDO3 (tx)"}, { FC_PDO3_RX, "PDO3 (rx)"}, { FC_PDO4_TX, "PDO4 (tx)"}, { FC_PDO4_RX, "PDO4 (rx)"}, { FC_DEFAULT_SDO_TX, "Default-SDO (tx)"}, { FC_DEFAULT_SDO_RX, "Default-SDO (rx)"}, { FC_NMT_ERR_CONTROL, "NMT Error Control"}, { 0, NULL} }; /* message types */ #define MT_UNKNOWN 0 #define MT_NMT_CTRL 1 #define MT_SYNC 2 #define MT_TIME_STAMP 3 #define MT_EMERGENCY 4 #define MT_PDO 5 #define MT_SDO 6 #define MT_NMT_ERR_CTRL 7 #define MT_LSS_MASTER 10 #define MT_LSS_SLAVE 11 /* TIME STAMP conversion defines */ #define TS_DAYS_BETWEEN_1970_AND_1984 5113 #define TS_SECONDS_IN_PER_DAY 86400 #define TS_NANOSEC_PER_MSEC 1000000 /* SDO command specifier */ #define SDO_CCS_DOWN_SEG_REQ 0 #define SDO_CCS_INIT_DOWN_REQ 1 #define SDO_CCS_INIT_UP_REQ 2 #define SDO_CCS_UP_SEQ_REQ 3 #define SDO_CCS_BLOCK_UP 5 #define SDO_CCS_BLOCK_DOWN 6 #define SDO_SCS_UP_SEQ_RESP 0 #define SDO_SCS_DOWN_SEG_RESP 1 #define SDO_SCS_INIT_UP_RESP 2 #define SDO_SCS_INIT_DOWN_RESP 3 #define SDO_SCS_BLOCK_DOWN 5 #define SDO_SCS_BLOCK_UP 6 #define SDO_CS_ABORT_TRANSFER 4 static const range_string obj_dict[] = { { 0x0000, 0x0000, "not used"}, { 0x0001, 0x001F, "Static data types"}, { 0x0020, 0x003F, "Complex data types"}, { 0x0040, 0x005F, "Manufacturer-specific complex data types"}, { 0x0060, 0x025F, "Device profile specific data types"}, { 0x0260, 0x03FF, "reserved"}, { 0x0400, 0x0FFF, "reserved"}, { 0x1000, 0x1000, "Device type"}, { 0x1001, 0x1001, "Error register"}, { 0x1002, 0x1002, "Manufacturer status register"}, { 0x1003, 0x1003, "Pre-defined error field"}, { 0x1004, 0x1004, "Communication profile area"}, { 0x1005, 0x1005, "COB-ID SYNC message"}, { 0x1006, 0x1006, "Communication cycle period"}, { 0x1007, 0x1007, "Synchronous window length"}, { 0x1008, 0x1008, "Manufacturer device name"}, { 0x1009, 0x1009, "Manufacturer hardware version"}, { 0x100A, 0x100A, "Manufacturer software version"}, { 0x100B, 0x100B, "Communication profile area"}, { 0x100C, 0x100C, "Guard time"}, { 0x100D, 0x100D, "Life time factor"}, { 0x100E, 0x100F, "Communication profile area"}, { 0x1010, 0x1010, "Store parameters"}, { 0x1011, 0x1011, "Restore default parameters"}, { 0x1012, 0x1012, "COB-ID time stamp object"}, { 0x1013, 0x1013, "High resolution time stamp"}, { 0x1014, 0x1014, "COB-ID EMCY"}, { 0x1015, 0x1015, "Inhibit time EMCY"}, { 0x1016, 0x1016, "Consumer heartbeat time"}, { 0x1017, 0x1017, "Producer heartbeat time"}, { 0x1018, 0x1018, "Identity object"}, { 0x1019, 0x1019, "Synchronous counter overflow value"}, { 0x101A, 0x101F, "Communication profile area"}, { 0x1020, 0x1020, "Verify configuration"}, { 0x1021, 0x1021, "Store EDS"}, { 0x1022, 0x1022, "Store format"}, { 0x1023, 0x1023, "OS command"}, { 0x1024, 0x1024, "OS command mode"}, { 0x1025, 0x1025, "OS debugger interface"}, { 0x1026, 0x1026, "OS prompt"}, { 0x1027, 0x1027, "Module list"}, { 0x1028, 0x1028, "Emergency consumer object"}, { 0x1029, 0x1029, "Error behavior object"}, { 0x102A, 0x11FF, "Communication profile area"}, { 0x1200, 0x127F, "SDO server parameter"}, { 0x1280, 0x12FF, "SDO client parameter"}, { 0x1300, 0x13FF, "Communication profile area"}, { 0x1400, 0x15FF, "RPDO communication parameter"}, { 0x1600, 0x17FF, "RPDO mapping parameter"}, { 0x1800, 0x19FF, "TPDO communication parameter"}, { 0x1A00, 0x1BFF, "TPDO mapping parameter"}, { 0x1C00, 0x1FBF, "Communication profile area"}, { 0x1FA0, 0x1FCF, "Object scanner list"}, { 0x1FD0, 0x1FFF, "Object dispatching list"}, { 0x2000, 0x5FFF, "Manufacturer-specific profile area"}, { 0x6000, 0x67FF, "Standardized profile area 1st logical device"}, { 0x6800, 0x6FFF, "Standardized profile area 2nd logical device"}, { 0x7000, 0x77FF, "Standardized profile area 3rd logical device"}, { 0x7800, 0x7FFF, "Standardized profile area 4th logical device"}, { 0x8000, 0x87FF, "Standardized profile area 5th logical device"}, { 0x8800, 0x8FFF, "Standardized profile area 6th logical device"}, { 0x9000, 0x97FF, "Standardized profile area 7th logical device"}, { 0x9800, 0x9FFF, "Standardized profile area 8th logical device"}, { 0xA000, 0xAFFF, "Standardized network variable area"}, { 0xB000, 0xBFFF, "Standardized system variable area"}, { 0xC000, 0xFFFF, "reserved"}, { 0, 0, NULL} }; /* EMCY error codes */ static const range_string em_err_code[] = { { 0x0000, 0x00FF, "Error reset or no error"}, { 0x1000, 0x10FF, "Generic error"}, { 0x2000, 0x20FF, "Current"}, { 0x2100, 0x21FF, "Current, CANopen device input side"}, { 0x2200, 0x22FF, "Current inside the CANopen device"}, { 0x2300, 0x23FF, "Current, CANopen device output side"}, { 0x3000, 0x30FF, "Voltage"}, { 0x3100, 0x31FF, "Mains voltage"}, { 0x3200, 0x32FF, "Voltage inside the CANopen device"}, { 0x3300, 0x33FF, "Output voltage"}, { 0x4000, 0x40FF, "Temperature"}, { 0x4100, 0x41FF, "Ambient temperature"}, { 0x4200, 0x42FF, "CANopen device temperature"}, { 0x5000, 0x50FF, "CANopen device hardware"}, { 0x6000, 0x60FF, "CANopen device software"}, { 0x6100, 0x61FF, "Internal software"}, { 0x6200, 0x62FF, "User software"}, { 0x6300, 0x63FF, "Data set"}, { 0x7000, 0x70FF, "Additional modules"}, { 0x8000, 0x80FF, "Monitoring"}, { 0x8100, 0x810F, "Communication"}, { 0x8110, 0x8110, "Communication - CAN overrun (objects lost)"}, { 0x8111, 0x811F, "Communication"}, { 0x8120, 0x8120, "Communication - CAN in error passive mode"}, { 0x8121, 0x812F, "Communication"}, { 0x8130, 0x8130, "Communication - Life guard error or heartbeat error"}, { 0x8131, 0x813F, "Communication"}, { 0x8140, 0x8140, "Communication - recovered from bus off"}, { 0x8141, 0x814F, "Communication"}, { 0x8150, 0x8150, "Communication - CAN-ID collision"}, { 0x8151, 0x81FF, "Communication"}, { 0x8200, 0x820F, "Protocol error"}, { 0x8210, 0x8210, "Protocol error - PDO not processed due to length error"}, { 0x8211, 0x821F, "Protocol error"}, { 0x8220, 0x8220, "Protocol error - PDO length exceeded"}, { 0x8221, 0x822F, "Protocol error"}, { 0x8230, 0x8230, "Protocol error - DAM MPDO not processed, destination object not available"}, { 0x8231, 0x823F, "Protocol error"}, { 0x8240, 0x8240, "Protocol error - Unexpected SYNC data length"}, { 0x8241, 0x824F, "Protocol error"}, { 0x8250, 0x8250, "Protocol error - RPDO timeout"}, { 0x8251, 0x82FF, "Protocol error"}, { 0x9000, 0x90FF, "External error"}, { 0xF000, 0xF0FF, "Additional functions"}, { 0xFF00, 0xFFFF, "CANopen device specific"}, { 0, 0, NULL} }; /* NMT command specifiers */ static const value_string nmt_ctrl_cs[] = { { 0x01, "Start remote node"}, { 0x02, "Stop remote node"}, { 0x80, "Enter pre-operational state"}, { 0x81, "Reset node"}, { 0x82, "Reset communication"}, { 0, NULL} }; /* NMT states */ static const value_string nmt_guard_state[] = { { 0x00, "Boot-up"}, { 0x04, "Stopped"}, { 0x05, "Operational"}, { 0x7F, "Pre-operational"}, { 0, NULL} }; /* SDO Client command specifier */ static const value_string sdo_ccs[] = { { 0x00, "Download segment request"}, { 0x01, "Initiate download request"}, { 0x02, "Initiate upload request"}, { 0x03, "Upload segment request"}, { 0x04, "Abort transfer"}, { 0x05, "Block upload"}, { 0x06, "Block download"}, { 0, NULL} }; /* SDO Server command specifier */ static const value_string sdo_scs[] = { { 0x00, "Upload segment response"}, { 0x01, "Download segment response"}, { 0x02, "Initiate upload response"}, { 0x03, "Initiate download response"}, { 0x04, "Abort transfer"}, { 0x05, "Block download"}, { 0x06, "Block upload"}, { 0, NULL} }; /* SDO client subcommand meaning */ static const value_string sdo_client_subcommand_meaning[] = { { 0x00, "Initiate upload/download request"}, { 0x01, "End block upload/download request"}, { 0x02, "Block upload response"}, { 0x03, "Start upload"}, { 0, NULL} }; /* SDO server subcommand meaning */ static const value_string sdo_server_subcommand_meaning[] = { { 0x00, "Initiate upload/download response"}, { 0x01, "End block upload/download response"}, { 0x02, "Block download response"}, { 0, NULL} }; static const value_string sdo_abort_code[] = { { 0x05030000, "Toggle bit not alternated"}, { 0x05040000, "SDO protocol timed out"}, { 0x05040001, "Client/server command specifier not valid or unknown"}, { 0x05040002, "Invalid block size"}, { 0x05040003, "Invalid sequence number"}, { 0x05040004, "CRC error"}, { 0x05040005, "Out of memory"}, { 0x06010000, "Unsupported access to an object"}, { 0x06010001, "Attempt to read a write only object"}, { 0x06010002, "Attempt to write a read only object"}, { 0x06020000, "Object does not exist in the object dictionary"}, { 0x06040041, "Object cannot be mapped to the PDO"}, { 0x06040042, "The number and length of the objects to be mapped would exceed PDO length"}, { 0x06040043, "General parameter incompatibility reason"}, { 0x06040047, "General internal incompatibility in the device"}, { 0x06060000, "Access failed due to an hardware error"}, { 0x06070010, "Data type does not match, length of service parameter does not match"}, { 0x06070012, "Data type does not match, length of service parameter too high"}, { 0x06070013, "Data type does not match, length of service parameter too low"}, { 0x06090011, "Sub-index does not exist"}, { 0x06090030, "Invalid value for parameter"}, { 0x06090031, "Value of parameter written too high"}, { 0x06090032, "Value of parameter written too low"}, { 0x06090036, "Maximum value is less than minimum value"}, { 0x060A0023, "Resource not available: SDO connection"}, { 0x08000000, "General error"}, { 0x08000020, "Data cannot be transferred or stored to the application"}, { 0x08000021, "Data cannot be transferred or stored to the application because of local control"}, { 0x08000022, "Data cannot be transferred or stored to the application because of the present device state"}, { 0x08000023, "Object dictionary dynamic generation fails or no object dictionary is present"}, { 0x08000024, "No data available"}, { 0, NULL} }; /* LSS COB-IDs */ #define LSS_MASTER_CAN_ID 0x7E5 #define LSS_SLAVE_CAN_ID 0x7E4 /* LSS Switch state services */ #define LSS_CS_SWITCH_GLOBAL 0x04 #define LSS_CS_SWITCH_SELECTIVE_VENDOR 0x40 #define LSS_CS_SWITCH_SELECTIVE_PRODUCT 0x41 #define LSS_CS_SWITCH_SELECTIVE_REVISION 0x42 #define LSS_CS_SWITCH_SELECTIVE_SERIAL 0x43 #define LSS_CS_SWITCH_SELECTIVE_RESP 0x44 /* LSS Configuration services */ #define LSS_CS_CONF_NODE_ID 0x11 #define LSS_CS_CONF_BIT_TIMING 0x13 #define LSS_CS_CONF_ACT_BIT_TIMING 0x15 #define LSS_CS_CONF_STORE 0x17 /* LSS Inquire services */ #define LSS_CS_INQ_VENDOR_ID 0x5A #define LSS_CS_INQ_PRODUCT_CODE 0x5B #define LSS_CS_INQ_REV_NUMBER 0x5C #define LSS_CS_INQ_SERIAL_NUMBER 0x5D #define LSS_CS_INQ_NODE_ID 0x5E /* LSS Identification services */ #define LSS_CS_IDENT_REMOTE_VENDOR 0x46 #define LSS_CS_IDENT_REMOTE_PRODUCT 0x47 #define LSS_CS_IDENT_REMOTE_REV_LOW 0x48 #define LSS_CS_IDENT_REMOTE_REV_HIGH 0x49 #define LSS_CS_IDENT_REMOTE_SERIAL_LOW 0x4A #define LSS_CS_IDENT_REMOTE_SERIAL_HIGH 0x4B #define LSS_CS_IDENT_REMOTE_NON_CONF 0x4C #define LSS_CS_IDENT_SLAVE 0x4F #define LSS_CS_IDENT_NON_CONF_SLAVE 0x50 #define LSS_CS_IDENT_FASTSCAN 0x51 /* LSS command specifier */ static const value_string lss_cs_code[] = { { 0x04, "Switch state global protocol"}, { 0x11, "Configure node-ID protocol"}, { 0x13, "Configure bit timing protocol"}, { 0x15, "Activate bit timing parameters protocol"}, { 0x17, "Store configuration protocol"}, { 0x40, "Switch state selective protocol"}, { 0x41, "Switch state selective protocol"}, { 0x42, "Switch state selective protocol"}, { 0x43, "Switch state selective protocol"}, { 0x44, "Switch state selective protocol"}, { 0x46, "Identify remote slave protocol"}, { 0x47, "Identify remote slave protocol"}, { 0x48, "Identify remote slave protocol"}, { 0x49, "Identify remote slave protocol"}, { 0x4A, "Identify remote slave protocol"}, { 0x4B, "Identify remote slave protocol"}, { 0x4C, "Identify non-configured remote slave protocol"}, { 0x4F, "Identify slave protocol"}, { 0x50, "Identify non-configured slave protocol"}, { 0x51, "LSS Fastscan protocol"}, { 0x5A, "Inquire identity vendor-ID protocol"}, { 0x5B, "Inquire identity product code protocol"}, { 0x5C, "Inquire identity revision number protocol"}, { 0x5D, "Inquire identity serial number protocol"}, { 0x5E, "Inquire node-ID protocol"}, { 0, NULL} }; static const value_string lss_fastscan_subnext[] = { { 0x0, "Vendor-ID"}, { 0x1, "Product code"}, { 0x2, "Revision number"}, { 0x3, "Serial number"}, { 0, NULL} }; static const value_string lss_switch_mode[] = { { 0x0, "Waiting state"}, { 0x1, "Configuration state"}, { 0, NULL} }; static const value_string lss_conf_id_err_code[] = { { 0x00, "Protocol successfully completed"}, { 0x01, "NID out of range"}, { 0xFF, "Implementation specific error"}, { 0, NULL} }; static const value_string lss_conf_bt_err_code[] = { { 0x00, "Protocol successfully completed"}, { 0x01, "Bit rate not supported"}, { 0xFF, "Implementation specific error"}, { 0, NULL} }; static const value_string lss_store_conf_err_code[] = { { 0x00, "Protocol successfully completed"}, { 0x01, "Store configuration not supported"}, { 0x02, "Storage media access erro"}, { 0xFF, "Implementation specific error"}, { 0, NULL} }; static const value_string bit_timing_tbl[] = { { 0x00, "1000 kbit/s"}, { 0x01, "800 kbit/s"}, { 0x02, "500 kbit/s"}, { 0x03, "250 kbit/s"}, { 0x04, "125 kbit/s"}, { 0x05, "Reserved"}, { 0x06, "50 kbit/s"}, { 0x07, "20 kbit/s"}, { 0x08, "10 kbit/s"}, { 0x09, "Auto bit rate detection"}, { 0, NULL} }; static const value_string lss_id_remote_slave[] = { { 0x46, "Vendor-ID"}, { 0x47, "Product-code"}, { 0x48, "Revision-number (low)"}, { 0x49, "Revision-number (high)"}, { 0x4A, "Serial-number (low)"}, { 0x4B, "Serial-number (high)"}, { 0, NULL} }; static const value_string lss_inquire_id[] = { { 0x5A, "Vendor-ID"}, { 0x5B, "Product-code"}, { 0x5C, "Revision-number"}, { 0x5D, "Serial-number"}, { 0x5E, "Node-ID"}, { 0, NULL} }; static guint canopen_detect_msg_type(guint function_code, guint node_id) { switch (function_code) { case FC_NMT: return MT_NMT_CTRL; break; case FC_SYNC: if (node_id == 0) { return MT_SYNC; } else { return MT_EMERGENCY; } break; case FC_TIME_STAMP: return MT_TIME_STAMP; break; case FC_PDO1_TX: return MT_PDO; break; case FC_PDO1_RX: return MT_PDO; break; case FC_PDO2_TX: return MT_PDO; break; case FC_PDO2_RX: return MT_PDO; break; case FC_PDO3_TX: return MT_PDO; break; case FC_PDO3_RX: return MT_PDO; break; case FC_PDO4_TX: return MT_PDO; break; case FC_PDO4_RX: return MT_PDO; break; case FC_DEFAULT_SDO_TX: return MT_SDO; break; case FC_DEFAULT_SDO_RX: return MT_SDO; break; case FC_NMT_ERR_CONTROL: return MT_NMT_ERR_CTRL; break; case LSS_MASTER_CAN_ID >> 7: if (node_id == (LSS_MASTER_CAN_ID & 0x7F)) { return MT_LSS_MASTER; } else if (node_id == (LSS_SLAVE_CAN_ID & 0x7F)) { return MT_LSS_SLAVE; } return MT_UNKNOWN; break; default: return MT_UNKNOWN; break; } } static inline int * const * sdo_cmd_fields_scs(guint cs, guint subcommand) { if (cs < array_length(_sdo_cmd_fields_scs)) return _sdo_cmd_fields_scs[cs]; else if(cs == SDO_SCS_BLOCK_DOWN && subcommand < array_length(_sdo_cmd_fields_scs5)) return _sdo_cmd_fields_scs5[subcommand]; else if(cs == SDO_SCS_BLOCK_UP && subcommand < array_length(_sdo_cmd_fields_scs6)) return _sdo_cmd_fields_scs6[subcommand]; return NULL; } static inline int * const * sdo_cmd_fields_ccs(guint cs, guint subcommand) { if (cs < array_length(_sdo_cmd_fields_ccs)) return _sdo_cmd_fields_ccs[cs]; else if (cs == SDO_CCS_BLOCK_UP && subcommand < array_length(_sdo_cmd_fields_ccs5)) return _sdo_cmd_fields_ccs5[subcommand]; else if (cs == SDO_CCS_BLOCK_DOWN && subcommand < array_length(_sdo_cmd_fields_ccs6)) return _sdo_cmd_fields_ccs6[subcommand]; return NULL; } static void dissect_sdo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *canopen_type_tree, guint function_code) { int offset = 0; /*number of data bytes*/ guint8 sdo_data = 0; /*Field existence*/ guint8 sdo_mux = 0, sdo_pst = 0; /*sdo values used to choose dissector*/ guint8 sdo_cs = 0, sdo_subcommand = 0; int * const *sdo_cmd_fields; /* get SDO command specifier */ sdo_cs = tvb_get_bits8(tvb, 0, 3); if (function_code == FC_DEFAULT_SDO_RX) { col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str(sdo_cs, sdo_ccs, "Unknown (0x%x)")); switch (sdo_cs) { case SDO_CCS_DOWN_SEG_REQ: sdo_mux = 0; sdo_data = 7; break; case SDO_CCS_INIT_DOWN_REQ: sdo_mux = 1; sdo_data = 4; break; case SDO_CCS_INIT_UP_REQ: sdo_mux = 1; sdo_data = 0; break; case SDO_CCS_UP_SEQ_REQ: sdo_mux = 0; sdo_data = 0; break; case SDO_CS_ABORT_TRANSFER: sdo_mux = 1; sdo_data = 4; break; case SDO_CCS_BLOCK_UP: sdo_subcommand = tvb_get_bits8(tvb, 6, 2); if(sdo_subcommand == 0) { sdo_mux = 1; /*only the client sends pst*/ sdo_pst = 1; } /*check unused field is empty, otherwise it could be a data block segment (TODO: add segment decoding)*/ if(tvb_get_bits8(tvb, 3, 3) != 0) return; break; case SDO_CCS_BLOCK_DOWN: sdo_subcommand = tvb_get_bits8(tvb, 7, 1); if(sdo_subcommand == 0) { sdo_mux = 1; sdo_data = 4; /*check unused field is empty, otherwise it could be a data block segment (TODO: add segment decoding)*/ if(tvb_get_bits8(tvb, 3, 3) != 0) return; } else { sdo_data = 2; /*check unused field is empty, otherwise it could be a data block segment (TODO: add segment decoding)*/ if(tvb_get_bits8(tvb, 6, 1) != 0) return; } break; default: return; } sdo_cmd_fields = sdo_cmd_fields_ccs(sdo_cs,sdo_subcommand); } else { col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str(sdo_cs, sdo_scs, "Unknown (0x%x)")); switch (sdo_cs) { case SDO_SCS_UP_SEQ_RESP: sdo_mux = 0; sdo_data = 7; break; case SDO_SCS_DOWN_SEG_RESP: sdo_mux = 0; sdo_data = 0; break; case SDO_SCS_INIT_UP_RESP: sdo_mux = 1; sdo_data = 4; break; case SDO_SCS_INIT_DOWN_RESP: sdo_mux = 1; sdo_data = 0; break; case SDO_CS_ABORT_TRANSFER: sdo_mux = 1; sdo_data = 4; break; case SDO_SCS_BLOCK_DOWN: sdo_subcommand = tvb_get_bits8(tvb, 6, 2); if(sdo_subcommand == 0) { sdo_mux = 1; } /*check unused field is empty, otherwise it could be a data block segment (TODO: add segment decoding)*/ if(tvb_get_bits8(tvb, 3, 3) != 0) return; break; case SDO_SCS_BLOCK_UP: sdo_subcommand = tvb_get_bits8(tvb, 7, 1); if(sdo_subcommand == 0) { sdo_mux = 1; sdo_data = 4; /*check unused field is empty, otherwise it could be a data block segment (TODO: add segment decoding)*/ if(tvb_get_bits8(tvb, 3, 3) != 0) return; } else { sdo_data = 2; /*check unused field is empty, otherwise it could be a data block segment (TODO: add segment decoding)*/ if(tvb_get_bits8(tvb, 6, 1) != 0) return; } break; default: return; } sdo_cmd_fields = sdo_cmd_fields_scs(sdo_cs,sdo_subcommand); } if (sdo_cmd_fields == NULL) { proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_cmd, tvb, 0, 1, ENC_LITTLE_ENDIAN); /* XXX Add expert info */ return; } proto_tree_add_bitmask(canopen_type_tree, tvb, offset, hf_canopen_sdo_cmd, ett_canopen_sdo_cmd, sdo_cmd_fields, ENC_LITTLE_ENDIAN); offset++; if (sdo_mux) { /* decode mux */ proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_main_idx, tvb, offset, 2, ENC_LITTLE_ENDIAN); offset += 2; proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_sub_idx, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; } if (sdo_cs == SDO_CS_ABORT_TRANSFER) { /* SDO abort transfer */ proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_abort_code, tvb, offset, 4, ENC_LITTLE_ENDIAN); return; } if (sdo_cs == 5) { /*SDO_SCS_BLOCK_DOWN or SDO_CCS_BLOCK_UP*/ if(sdo_subcommand == 2) { /*decode ackseq byte)*/ proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_cmd_block_ackseq, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; } if(sdo_subcommand == 0 || sdo_subcommand == 2) { /*decode blksize byte)*/ proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_cmd_block_blksize, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; } } if (sdo_pst) { /*decode pst byte)*/ proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_cmd_block_pst, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; } if (sdo_data) { proto_tree_add_item(canopen_type_tree, hf_canopen_sdo_data, tvb, offset, sdo_data, ENC_NA); offset += sdo_data; } if(offset < 8) { /* Reserved */ proto_tree_add_item(canopen_type_tree, hf_canopen_reserved, tvb, offset, 8 - offset, ENC_NA); } } static void dissect_lss(tvbuff_t *tvb, packet_info *pinfo, proto_tree *canopen_type_tree, guint msg_type_id) { int offset = 0; int reserved = 0; guint8 lss_cs; guint8 lss_bc_mask; guint16 lss_abt_delay; proto_tree_add_item(canopen_type_tree, hf_canopen_lss_cs, tvb, offset, 1, ENC_LITTLE_ENDIAN); /* LSS command specifier */ lss_cs = tvb_get_guint8(tvb, offset); col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str(lss_cs, lss_cs_code, "Unknown (0x%x)")); offset++; if (msg_type_id == MT_LSS_MASTER) { /* Master commands */ switch (lss_cs) { case LSS_CS_SWITCH_GLOBAL: col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str(tvb_get_guint8(tvb, offset), lss_switch_mode, "Unknown (0x%x)")); proto_tree_add_item(canopen_type_tree, hf_canopen_lss_switch_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 6; break; case LSS_CS_SWITCH_SELECTIVE_VENDOR: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_addr_vendor, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; reserved = 3; break; case LSS_CS_SWITCH_SELECTIVE_PRODUCT: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_addr_product, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; reserved = 3; break; case LSS_CS_SWITCH_SELECTIVE_REVISION: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_addr_revision, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; reserved = 3; break; case LSS_CS_SWITCH_SELECTIVE_SERIAL: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_addr_serial, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; reserved = 3; break; case LSS_CS_CONF_NODE_ID: col_append_fstr(pinfo->cinfo, COL_INFO, ": 0x%02x", tvb_get_guint8(tvb, offset)); proto_tree_add_item(canopen_type_tree, hf_canopen_lss_nid, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 6; break; case LSS_CS_CONF_BIT_TIMING: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_bt_tbl_selector, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; /* XXX Note that current dissector only works for table selector 0x00 (CiA 301 Table 1) */ col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str(tvb_get_guint8(tvb, offset), bit_timing_tbl, "Unknown (0x%x)")); proto_tree_add_item(canopen_type_tree, hf_canopen_lss_bt_tbl_index, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 5; break; case LSS_CS_CONF_ACT_BIT_TIMING: lss_abt_delay = tvb_get_letohl(tvb, offset); col_append_fstr(pinfo->cinfo, COL_INFO, ": %d ms", lss_abt_delay); proto_tree_add_uint_format_value(canopen_type_tree, hf_canopen_lss_abt_delay, tvb, offset, 2, lss_abt_delay, "%d ms (0x%02x)", lss_abt_delay, lss_abt_delay); offset += 2; reserved = 5; break; case LSS_CS_CONF_STORE: case LSS_CS_INQ_VENDOR_ID: case LSS_CS_INQ_PRODUCT_CODE: case LSS_CS_INQ_REV_NUMBER: case LSS_CS_INQ_SERIAL_NUMBER: case LSS_CS_INQ_NODE_ID: reserved = 7; break; case LSS_CS_IDENT_REMOTE_VENDOR: case LSS_CS_IDENT_REMOTE_PRODUCT: case LSS_CS_IDENT_REMOTE_REV_LOW: case LSS_CS_IDENT_REMOTE_REV_HIGH: case LSS_CS_IDENT_REMOTE_SERIAL_LOW: case LSS_CS_IDENT_REMOTE_SERIAL_HIGH: col_append_fstr(pinfo->cinfo, COL_INFO, ", %s 0x%08x", val_to_str_const(lss_cs, lss_id_remote_slave, "(Unknown)"), tvb_get_letohl(tvb, offset)); proto_tree_add_item(canopen_type_tree, *hf_canopen_lss_addr_ident[lss_cs - LSS_CS_IDENT_REMOTE_VENDOR], tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; reserved = 3; break; case LSS_CS_IDENT_REMOTE_NON_CONF: reserved = 7; break; case LSS_CS_IDENT_FASTSCAN: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_fastscan_id, tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; lss_bc_mask = tvb_get_guint8(tvb, offset); if (lss_bc_mask == 0x80) { proto_tree_add_uint_format_value(canopen_type_tree, hf_canopen_lss_fastscan_check, tvb, offset, 1, lss_bc_mask, "All LSS slaves (0x%02x)", lss_bc_mask); } else if (lss_bc_mask < 32) { proto_tree_add_uint_format_value(canopen_type_tree, hf_canopen_lss_fastscan_check, tvb, offset, 1, lss_bc_mask, "0x%x (0x%02x)", ~((1 << lss_bc_mask) - 1), lss_bc_mask); } else { proto_tree_add_uint_format_value(canopen_type_tree, hf_canopen_lss_fastscan_check, tvb, offset, 1, lss_bc_mask, "Reserved (0x%02x)", lss_bc_mask); } offset++; proto_tree_add_item(canopen_type_tree, hf_canopen_lss_fastscan_sub, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; proto_tree_add_item(canopen_type_tree, hf_canopen_lss_fastscan_next, tvb, offset, 1, ENC_LITTLE_ENDIAN); break; default: /* invalid command specifier */ return; } } else { /* Slave commands */ switch (lss_cs) { case LSS_CS_SWITCH_SELECTIVE_RESP: reserved = 7; break; case LSS_CS_CONF_NODE_ID: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_conf_id_err_code, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; proto_tree_add_item(canopen_type_tree, hf_canopen_lss_spec_err, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 5; break; case LSS_CS_CONF_BIT_TIMING: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_conf_bt_err_code, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; proto_tree_add_item(canopen_type_tree, hf_canopen_lss_spec_err, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 5; break; case LSS_CS_CONF_STORE: proto_tree_add_item(canopen_type_tree, hf_canopen_lss_store_conf_err_code, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; proto_tree_add_item(canopen_type_tree, hf_canopen_lss_spec_err, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 5; break; case LSS_CS_INQ_VENDOR_ID: case LSS_CS_INQ_PRODUCT_CODE: case LSS_CS_INQ_REV_NUMBER: case LSS_CS_INQ_SERIAL_NUMBER: col_append_fstr(pinfo->cinfo, COL_INFO, ", %s 0x%08x", val_to_str_const(lss_cs, lss_inquire_id, "(Unknown)"), tvb_get_letohl(tvb, offset)); proto_tree_add_item(canopen_type_tree, *hf_canopen_lss_addr_inquire[lss_cs - LSS_CS_INQ_VENDOR_ID], tvb, offset, 4, ENC_LITTLE_ENDIAN); offset += 4; reserved = 3; break; case LSS_CS_INQ_NODE_ID: col_append_fstr(pinfo->cinfo, COL_INFO, ", %s 0x%08x", val_to_str_const(lss_cs, lss_inquire_id, "(Unknown)"), tvb_get_letohl(tvb, offset)); proto_tree_add_item(canopen_type_tree, hf_canopen_lss_nid, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; reserved = 6; break; case LSS_CS_IDENT_SLAVE: reserved = 7; break; case LSS_CS_IDENT_NON_CONF_SLAVE: reserved = 7; break; default: /* invalid command specifier */ return; } } if (reserved) { proto_tree_add_item(canopen_type_tree, hf_canopen_reserved, tvb, offset, reserved, ENC_NA); } } /* Code to actually dissect the packets */ static int dissect_canopen(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) { guint function_code; guint node_id; guint32 time_stamp_msec; guint32 time_stamp_days; struct can_info can_info; guint msg_type_id; nstime_t time_stamp; gint can_data_len = tvb_reported_length(tvb); const gchar *function_code_str; int offset = 0; guint8 nmt_node_id; proto_item *ti, *cob_ti; proto_tree *canopen_tree; proto_tree *canopen_cob_tree; proto_tree *canopen_type_tree; DISSECTOR_ASSERT(data); can_info = *((struct can_info*)data); if (can_info.id & (CAN_ERR_FLAG | CAN_RTR_FLAG | CAN_EFF_FLAG)) { /* Error, RTR and frames with extended ids are not for us. */ return 0; } col_set_str(pinfo->cinfo, COL_PROTOCOL, "CANopen"); col_clear(pinfo->cinfo, COL_INFO); node_id = can_info.id & 0x7F; function_code = (can_info.id >> 7) & 0x0F; msg_type_id = canopen_detect_msg_type(function_code, node_id); if (msg_type_id == MT_LSS_MASTER) { function_code_str = "LSS (Master)"; col_add_str(pinfo->cinfo, COL_INFO, function_code_str); } else if (msg_type_id == MT_LSS_SLAVE) { function_code_str = "LSS (Slave)"; col_add_str(pinfo->cinfo, COL_INFO, function_code_str); } else { if (node_id == 0 ) { /* broadcast */ function_code_str = val_to_str(function_code, CAN_open_bcast_msg_type_vals, "Unknown (%u)"); col_add_fstr(pinfo->cinfo, COL_INFO, "%s", function_code_str); } else { /* point-to-point */ function_code_str = val_to_str(function_code, CAN_open_p2p_msg_type_vals, "Unknown (%u)"); col_add_fstr(pinfo->cinfo, COL_INFO, "%s", function_code_str); } } ti = proto_tree_add_item(tree, proto_canopen, tvb, 0, tvb_reported_length(tvb), ENC_NA); canopen_tree = proto_item_add_subtree(ti, ett_canopen); /* add COB-ID with function code and node id */ cob_ti = proto_tree_add_uint(canopen_tree, hf_canopen_cob_id, tvb, 0, 0, can_info.id); canopen_cob_tree = proto_item_add_subtree(cob_ti, ett_canopen_cob); /* add function code */ ti = proto_tree_add_uint(canopen_cob_tree, hf_canopen_function_code, tvb, 0, 0, can_info.id); proto_item_set_generated(ti); /* add node id */ ti = proto_tree_add_uint(canopen_cob_tree, hf_canopen_node_id, tvb, 0, 0, can_info.id); proto_item_set_generated(ti); /* add CANopen frame type */ canopen_type_tree = proto_tree_add_subtree_format(canopen_tree, tvb, 0, tvb_reported_length(tvb), ett_canopen_type, NULL, "Type: %s", function_code_str); switch(msg_type_id) { case MT_NMT_CTRL: col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str(tvb_get_guint8(tvb, offset), nmt_ctrl_cs, "Unknown (0x%x)")); proto_tree_add_item(canopen_type_tree, hf_canopen_nmt_ctrl_cs, tvb, offset, 1, ENC_LITTLE_ENDIAN); offset++; nmt_node_id = tvb_get_guint8(tvb, offset); if (nmt_node_id == 0x00) { col_append_fstr(pinfo->cinfo, COL_INFO, " [All]"); } else { col_append_fstr(pinfo->cinfo, COL_INFO, " [0x%x]", nmt_node_id); } proto_tree_add_item(canopen_type_tree, hf_canopen_nmt_ctrl_node_id, tvb, offset, 1, ENC_LITTLE_ENDIAN); break; case MT_NMT_ERR_CTRL: if (tvb_reported_length(tvb) > 0) { col_append_fstr(pinfo->cinfo, COL_INFO, ": %s", val_to_str_const(tvb_get_bits8(tvb, 1, 7), nmt_guard_state, "(Unknown)")); proto_tree_add_item(canopen_type_tree, hf_canopen_nmt_guard_toggle, tvb, offset, 1, ENC_LITTLE_ENDIAN); proto_tree_add_item(canopen_type_tree, hf_canopen_nmt_guard_state, tvb, offset, 1, ENC_LITTLE_ENDIAN); } col_append_fstr(pinfo->cinfo, COL_INFO, " [0x%x]", node_id); break; case MT_SYNC: /* Show optional counter parameter if present */ if (tvb_reported_length(tvb) > 0) { col_append_fstr(pinfo->cinfo, COL_INFO, " [%d]", tvb_get_guint8(tvb, offset)); proto_tree_add_item(canopen_type_tree, hf_canopen_sync_counter, tvb, offset, 1, ENC_LITTLE_ENDIAN); } break; case MT_TIME_STAMP: /* calculate the real time stamp */ time_stamp_msec = tvb_get_letohl(tvb, offset); time_stamp_days = tvb_get_letohs(tvb, offset + 4); time_stamp.secs = (time_stamp_days + TS_DAYS_BETWEEN_1970_AND_1984) * TS_SECONDS_IN_PER_DAY + (time_stamp_msec / 1000); time_stamp.nsecs = (time_stamp_msec % 1000) * TS_NANOSEC_PER_MSEC; proto_tree_add_time(canopen_type_tree, hf_canopen_time_stamp, tvb, offset, 6, &time_stamp); proto_tree_add_uint(canopen_type_tree, hf_canopen_time_stamp_ms, tvb, offset, 4, time_stamp_msec); offset += 4; proto_tree_add_uint(canopen_type_tree, hf_canopen_time_stamp_days, tvb, offset, 2, time_stamp_days); break; case MT_EMERGENCY: proto_tree_add_item(canopen_type_tree, hf_canopen_em_err_code, tvb, offset, 2, ENC_LITTLE_ENDIAN); offset += 2; proto_tree_add_bitmask(canopen_type_tree, tvb, offset, hf_canopen_em_err_reg, ett_canopen_em_er, em_err_reg_fields, ENC_LITTLE_ENDIAN); offset++; proto_tree_add_item(canopen_type_tree, hf_canopen_em_err_field, tvb, offset, 5, ENC_NA); break; case MT_PDO: if (can_data_len != 0) { proto_tree_add_item(canopen_type_tree, hf_canopen_pdo_data, tvb, offset, can_data_len, ENC_NA); } else { proto_tree_add_string(canopen_type_tree, hf_canopen_pdo_data_string, tvb, offset, 0, "empty"); } break; case MT_SDO: dissect_sdo(tvb, pinfo, canopen_type_tree, function_code); break; case MT_LSS_MASTER: case MT_LSS_SLAVE: dissect_lss(tvb, pinfo, canopen_type_tree, msg_type_id); break; } return tvb_reported_length(tvb); } /* Register the protocol with Wireshark */ void proto_register_canopen(void) { static hf_register_info hf[] = { /* COB-ID */ { &hf_canopen_cob_id, { "COB-ID", "canopen.cob_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_function_code, { "Function code", "canopen.function_code", FT_UINT32, BASE_HEX, NULL, 0x00000780, NULL, HFILL } }, { &hf_canopen_node_id, { "Node-ID", "canopen.node_id", FT_UINT32, BASE_HEX, NULL, 0x7F, NULL, HFILL } }, { &hf_canopen_pdo_data, { "Data", "canopen.pdo.data.bytes", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_pdo_data_string, { "Data", "canopen.pdo.data.string", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } }, /* SDO */ { &hf_canopen_sdo_cmd, { "SDO command byte", "canopen.sdo.cmd", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_sdo_cmd_ccs, { "Client command specifier", "canopen.sdo.ccs", FT_UINT8, BASE_DEC, VALS(sdo_ccs), 0xE0, NULL, HFILL } }, { &hf_canopen_sdo_cmd_scs, { "Server command specifier", "canopen.sdo.scs", FT_UINT8, BASE_DEC, VALS(sdo_scs), 0xE0, NULL, HFILL } }, { &hf_canopen_sdo_cmd_ccs5_subcommand, { "Client subcommand", "canopen.sdo.cs", FT_UINT8, BASE_DEC, VALS(sdo_client_subcommand_meaning), 0x03, NULL, HFILL } }, { &hf_canopen_sdo_cmd_scs5_subcommand, { "Server command specifier", "canopen.sdo.ss", FT_UINT8, BASE_DEC, VALS(sdo_server_subcommand_meaning), 0x03, NULL, HFILL } }, { &hf_canopen_sdo_cmd_ccs6_subcommand, { "Client subcommand", "canopen.sdo.cs", FT_UINT8, BASE_DEC, VALS(sdo_client_subcommand_meaning), 0x01, NULL, HFILL } }, { &hf_canopen_sdo_cmd_scs6_subcommand, { "Server command specifier", "canopen.sdo.ss", FT_UINT8, BASE_DEC, VALS(sdo_server_subcommand_meaning), 0x01, NULL, HFILL } }, { &hf_canopen_sdo_cmd_block_crc_support, { "CRC support", "canopen.sdo.crc_support", FT_BOOLEAN, 8, NULL, 0x04, "toggle", HFILL } }, { &hf_canopen_sdo_cmd_block_s, { "Data set size indicated", "canopen.sdo.s", FT_BOOLEAN, 8, NULL, 0x02, "toggle", HFILL } }, { &hf_canopen_sdo_cmd_block_n, { "Non-data byte", "canopen.sdo.n", FT_UINT8, BASE_DEC, NULL, 0x1C, "toggle", HFILL } }, { &hf_canopen_sdo_cmd_block_ackseq, { "Number of segments acknowledged", "canopen.sdo.ackseq", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_sdo_cmd_block_blksize, { "Number of segments per block", "canopen.sdo.blksize", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_sdo_cmd_block_pst, { "Protocol switch threshold (bytes)", "canopen.sdo.pst", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_sdo_cmd_toggle, { "Toggle bit", "canopen.sdo.toggle", FT_UINT8, BASE_DEC, NULL, 0x10, "toggle", HFILL }}, { &hf_canopen_sdo_cmd_updown_n, { "Non-data bytes", "canopen.sdo.n", FT_UINT8, BASE_DEC, NULL, 0x0E, "toggle", HFILL }}, { &hf_canopen_sdo_cmd_updown_c, { "No more segments", "canopen.sdo.c", FT_BOOLEAN, 8, NULL, 0x01, "toggle", HFILL }}, { &hf_canopen_sdo_cmd_init_n, { "Non-data bytes", "canopen.sdo.n", FT_UINT8, BASE_DEC, NULL, 0x0C, "toggle", HFILL }}, { &hf_canopen_sdo_cmd_init_e, { "Expedited transfer", "canopen.sdo.e", FT_BOOLEAN, 8, NULL, 0x02, "toggle", HFILL }}, { &hf_canopen_sdo_cmd_init_s, { "Data set size indicated", "canopen.sdo.s", FT_BOOLEAN, 8, NULL, 0x01, "toggle", HFILL }}, { &hf_canopen_sdo_main_idx, { "OD main-index", "canopen.sdo.main_idx", FT_UINT16, BASE_HEX|BASE_RANGE_STRING, RVALS(obj_dict), 0x0, NULL, HFILL } }, { &hf_canopen_sdo_sub_idx, { "OD sub-index", "canopen.sdo.sub_idx", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_sdo_data, { "Data", "canopen.sdo.data.bytes", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_sdo_abort_code, { "Abort code", "canopen.sdo.abort_code", FT_UINT32, BASE_HEX, VALS(sdo_abort_code), 0x0, NULL, HFILL } }, { &hf_canopen_reserved, { "Reserved", "canopen.reserved", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } }, { &hf_canopen_em_err_code, { "Error code", "canopen.em.err_code", FT_UINT16, BASE_HEX|BASE_RANGE_STRING, RVALS(em_err_code), 0x0, NULL, HFILL } }, { &hf_canopen_em_err_reg, { "Error register", "canopen.em.err_reg", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_em_err_reg_ge, { "Generic error", "canopen.em.err_reg_ge", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL } }, { &hf_canopen_em_err_reg_cu, { "Current", "canopen.em.err_reg_cu", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL } }, { &hf_canopen_em_err_reg_vo, { "Voltage", "canopen.em.err_reg_vo", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL } }, { &hf_canopen_em_err_reg_te, { "Temperature", "canopen.em.err_reg_te", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL } }, { &hf_canopen_em_err_reg_co, { "Communication error (overrun, error state)", "canopen.em.err_reg_co", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL } }, { &hf_canopen_em_err_reg_de, { "Device profile specific", "canopen.em.err_reg_de", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL } }, { &hf_canopen_em_err_reg_re, { "Reserved (must be false)", "canopen.em.err_reg_re", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL } }, { &hf_canopen_em_err_reg_ma, { "Manufacturer specific", "canopen.em.err_reg_ma", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL } }, { &hf_canopen_em_err_field, { "Manufacturer specific error field", "canopen.em.err_field", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_nmt_ctrl_cs, { "Command specifier", "canopen.nmt_ctrl.cd", FT_UINT8, BASE_HEX, VALS(nmt_ctrl_cs), 0x0, NULL, HFILL } }, { &hf_canopen_nmt_ctrl_node_id, { "Node-ID", "canopen.nmt_ctrl.node_id", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_nmt_guard_toggle, { "Reserved/Toggle", "canopen.nmt_guard.toggle", FT_UINT8, BASE_DEC, NULL, 0x80, NULL, HFILL } }, { &hf_canopen_nmt_guard_state, { "State", "canopen.nmt_guard.state", FT_UINT8, BASE_HEX, VALS(nmt_guard_state), 0x7F, NULL, HFILL } }, /* SYNC */ { &hf_canopen_sync_counter, { "Counter", "canopen.sync.counter", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, /* LSS */ { &hf_canopen_lss_cs, { "Command specifier", "canopen.lss.cs", FT_UINT8, BASE_HEX, VALS(lss_cs_code), 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_vendor, { "Vendor-ID", "canopen.lss.addr.vendor", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_product, { "Product-code", "canopen.lss.addr.product", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_revision, { "Revision-number", "canopen.lss.addr.revision", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_revision_low, { "Revision-number (low)", "canopen.lss.addr.revision_low", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_revision_high, { "Revision-number (high)", "canopen.lss.addr.revision_high", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_serial, { "Serial-number", "canopen.lss.addr.serial", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_serial_low, { "Serial-number (low)", "canopen.lss.addr.serial_low", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_addr_serial_high, { "Serial-number (high)", "canopen.lss.addr.serial_high", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_fastscan_id, { "IDNumber", "canopen.lss.fastscan.id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_fastscan_check, { "Bit Check", "canopen.lss.fastscan.check", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_fastscan_sub, { "LSS Sub", "canopen.lss.fastscan.sub", FT_UINT8, BASE_HEX, VALS(lss_fastscan_subnext), 0x0, NULL, HFILL } }, { &hf_canopen_lss_fastscan_next, { "LSS Next", "canopen.lss.fastscan.next", FT_UINT8, BASE_HEX, VALS(lss_fastscan_subnext), 0x0, NULL, HFILL } }, { &hf_canopen_lss_switch_mode, { "Mode", "canopen.lss.switch.mode", FT_UINT8, BASE_HEX, VALS(lss_switch_mode), 0x0, NULL, HFILL } }, { &hf_canopen_lss_nid, { "NID", "canopen.lss.nid", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_conf_id_err_code, { "Error code", "canopen.lss.conf_id.err_code", FT_UINT8, BASE_HEX, VALS(lss_conf_id_err_code), 0x0, NULL, HFILL } }, { &hf_canopen_lss_conf_bt_err_code, { "Error code", "canopen.lss.conf_bt.err_code", FT_UINT8, BASE_HEX, VALS(lss_conf_bt_err_code), 0x0, NULL, HFILL } }, { &hf_canopen_lss_store_conf_err_code, { "Error code", "canopen.lss.store_conf.err_code", FT_UINT8, BASE_HEX, VALS(lss_store_conf_err_code), 0x0, NULL, HFILL } }, { &hf_canopen_lss_spec_err, { "Spec-error", "canopen.lss.spec_err", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_bt_tbl_selector, { "Table selector", "canopen.lss.bt.tbl_selector", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_lss_bt_tbl_index, { "Table index", "canopen.lss.bt.tbl_index", FT_UINT8, BASE_HEX, VALS(bit_timing_tbl), 0x0, NULL, HFILL } }, { &hf_canopen_lss_abt_delay, { "Switch delay", "canopen.lss.abt_delay", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_time_stamp, { "Time stamp", "canopen.time_stamp", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_time_stamp_ms, { "Time, after Midnight in Milliseconds", "canopen.time_stamp_ms", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_canopen_time_stamp_days, { "Current day since 1 Jan 1984", "canopen.time_stamp_days", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }, }; static gint *ett[] = { &ett_canopen, &ett_canopen_cob, &ett_canopen_type, &ett_canopen_sdo_cmd, &ett_canopen_em_er }; proto_canopen = proto_register_protocol("CANopen", "CANOPEN", "canopen"); proto_register_field_array(proto_canopen, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); canopen_handle = register_dissector("canopen", dissect_canopen, proto_canopen ); } void proto_reg_handoff_canopen(void) { dissector_add_for_decode_as("can.subdissector", canopen_handle ); } /* * Editor modelines - https://www.wireshark.org/tools/modelines.html * * Local variables: * c-basic-offset: 4 * tab-width: 8 * indent-tabs-mode: nil * End: * * vi: set shiftwidth=4 tabstop=8 expandtab: * :indentSize=4:tabSize=8:noTabs=true: */