/* packet-vxi11.c * Routines for VXI-11 (TCP/IP Instrument Protocol) dissection. * * Wireshark - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * VXI-11 protocol dissector * By Jens Kilian * Copyright 2009 Verigy Deutschland GmbH * * SPDX-License-Identifier: GPL-2.0-or-later */ #include "config.h" #include "packet-rpc.h" #include /* * For the protocol specifications, see * http://www.vxibus.org/files/VXI_Specs/VXI-11.zip * * This dissector handles the basic Network Instrument protocol as defined * in VXI-11, and parts of the TCP/IP-IEEE 488.1 Interface spec (VXI-11.2). */ /* Core protocol. */ #define VXI11_CORE_ADDRESS_FAMILY_TCP 0 #define VXI11_CORE_ADDRESS_FAMILY_UDP 1 #define VXI11_CORE_CMD_SEND_COMMAND 0x020000 #define VXI11_CORE_CMD_BUS_STATUS 0x020001 #define VXI11_CORE_CMD_ATN_CONTROL 0x020002 #define VXI11_CORE_CMD_REN_CONTROL 0x020003 #define VXI11_CORE_CMD_PASS_CONTROL 0x020004 #define VXI11_CORE_CMD_BUS_ADDRESS 0x02000a #define VXI11_CORE_CMD_IFC_CONTROL 0x020010 #define VXI11_CORE_ERROR_NO_ERROR 0 #define VXI11_CORE_ERROR_SYNTAX_ERROR 1 #define VXI11_CORE_ERROR_DEVICE_NOT_ACCESSIBLE 3 #define VXI11_CORE_ERROR_INVALID_ID 4 #define VXI11_CORE_ERROR_PARAMETER_ERROR 5 #define VXI11_CORE_ERROR_CHANNEL_NOT_ESTABLISHED 6 #define VXI11_CORE_ERROR_OPERATION_NOT_SUPPORTED 8 #define VXI11_CORE_ERROR_OUT_OF_RESOURCES 9 #define VXI11_CORE_ERROR_DEVICE_LOCKED 11 #define VXI11_CORE_ERROR_NO_LOCK_HELD 12 #define VXI11_CORE_ERROR_IO_TIMEOUT 15 #define VXI11_CORE_ERROR_IO_ERROR 17 #define VXI11_CORE_ERROR_INVALID_ADDRESS 21 #define VXI11_CORE_ERROR_ABORT 23 #define VXI11_CORE_ERROR_CHANNEL_ALREADY_ESTABLISHED 29 #define VXI11_CORE_FLAG_WAITLOCK (1 << 0) #define VXI11_CORE_FLAG_END (1 << 3) #define VXI11_CORE_FLAG_TERMCHRSET (1 << 7) #define VXI11_CORE_REASON_REQCNT (1 << 0) #define VXI11_CORE_REASON_CHR (1 << 1) #define VXI11_CORE_REASON_END (1 << 2) #define VXI11_CORE_PROC_NULL 0 #define VXI11_CORE_PROC_CREATE_LINK 10 #define VXI11_CORE_PROC_DEVICE_WRITE 11 #define VXI11_CORE_PROC_DEVICE_READ 12 #define VXI11_CORE_PROC_DEVICE_READSTB 13 #define VXI11_CORE_PROC_DEVICE_TRIGGER 14 #define VXI11_CORE_PROC_DEVICE_CLEAR 15 #define VXI11_CORE_PROC_DEVICE_REMOTE 16 #define VXI11_CORE_PROC_DEVICE_LOCAL 17 #define VXI11_CORE_PROC_DEVICE_LOCK 18 #define VXI11_CORE_PROC_DEVICE_UNLOCK 19 #define VXI11_CORE_PROC_DEVICE_ENABLE_SRQ 20 #define VXI11_CORE_PROC_DEVICE_DOCMD 22 #define VXI11_CORE_PROC_DESTROY_LINK 23 #define VXI11_CORE_PROC_CREATE_INTR_CHAN 25 #define VXI11_CORE_PROC_DESTROY_INTR_CHAN 26 #define VXI11_CORE_PROGRAM 0x0607AF #define VXI11_CORE_VERSION 1 #define MAX_DATA_SHOW_SIZE 70 void proto_register_vxi11_core(void); void proto_reg_handoff_vxi11_core(void); void proto_register_vxi11_async(void); void proto_reg_handoff_vxi11_async(void); void proto_register_vxi11_intr(void); void proto_reg_handoff_vxi11_intr(void); static int proto_vxi11_core; static int ett_vxi11_core; static int ett_vxi11_core_flags; static int ett_vxi11_core_reason; static int hf_vxi11_core_procedure_v1; static int hf_vxi11_core_abort_port; static int hf_vxi11_core_client_id; static int hf_vxi11_core_cmd; static int hf_vxi11_core_data; static int hf_vxi11_core_device; static int hf_vxi11_core_enable; static int hf_vxi11_core_error; static int hf_vxi11_core_flags; static int hf_vxi11_core_flag_wait_lock; static int hf_vxi11_core_flag_end; static int hf_vxi11_core_flag_term_chr_set; static int hf_vxi11_core_handle; static int hf_vxi11_core_host_addr; static int hf_vxi11_core_host_port; static int hf_vxi11_core_io_timeout; static int hf_vxi11_core_lid; static int hf_vxi11_core_lock_device; static int hf_vxi11_core_lock_timeout; static int hf_vxi11_core_max_recv_size; static int hf_vxi11_core_network_order; static int hf_vxi11_core_prog_family; static int hf_vxi11_core_prog_num; static int hf_vxi11_core_prog_vers; static int hf_vxi11_core_reason; static int hf_vxi11_core_reason_req_cnt; static int hf_vxi11_core_reason_chr; static int hf_vxi11_core_reason_end; static int hf_vxi11_core_size; static int hf_vxi11_core_stb; static int hf_vxi11_core_term_char; static const value_string vxi11_core_error_vals[] = { { VXI11_CORE_ERROR_NO_ERROR, "No Error" }, { VXI11_CORE_ERROR_SYNTAX_ERROR, "Syntax Error" }, { VXI11_CORE_ERROR_DEVICE_NOT_ACCESSIBLE, "Device Not Accessible" }, { VXI11_CORE_ERROR_INVALID_ID, "Invalid ID" }, { VXI11_CORE_ERROR_PARAMETER_ERROR, "Parameter Error" }, { VXI11_CORE_ERROR_CHANNEL_NOT_ESTABLISHED, "Channel Not Established" }, { VXI11_CORE_ERROR_OPERATION_NOT_SUPPORTED, "Operation Not Supported" }, { VXI11_CORE_ERROR_OUT_OF_RESOURCES, "Out Of Resources" }, { VXI11_CORE_ERROR_DEVICE_LOCKED, "Device Locked" }, { VXI11_CORE_ERROR_NO_LOCK_HELD, "No Lock Held" }, { VXI11_CORE_ERROR_IO_TIMEOUT, "I/O Timeout" }, { VXI11_CORE_ERROR_IO_ERROR, "I/O Error" }, { VXI11_CORE_ERROR_INVALID_ADDRESS, "Invalid Address" }, { VXI11_CORE_ERROR_ABORT, "Abort" }, { VXI11_CORE_ERROR_CHANNEL_ALREADY_ESTABLISHED, "Channel Already Established" }, { 0, NULL } }; static const value_string vxi11_core_cmd_vals[] = { { VXI11_CORE_CMD_SEND_COMMAND, "SEND_COMMAND" }, { VXI11_CORE_CMD_BUS_STATUS, "BUS_STATUS" }, { VXI11_CORE_CMD_ATN_CONTROL, "ATN_CONTROL" }, { VXI11_CORE_CMD_REN_CONTROL, "REN_CONTROL" }, { VXI11_CORE_CMD_PASS_CONTROL, "PASS_CONTROL" }, { VXI11_CORE_CMD_BUS_ADDRESS, "BUS_ADDRESS" }, { VXI11_CORE_CMD_IFC_CONTROL, "IFC_CONTROL" }, { 0, NULL } }; /* Asynchronous-abort protocol. */ #define VXI11_ASYNC_PROC_NULL 0 #define VXI11_ASYNC_PROC_DEVICE_ABORT 1 #define VXI11_ASYNC_PROGRAM 0x0607B0 #define VXI11_ASYNC_VERSION 1 static int proto_vxi11_async; static int ett_vxi11_async; static int hf_vxi11_async_procedure_v1; /* Interrupt protocol. */ #define VXI11_INTR_PROC_NULL 0 #define VXI11_INTR_PROC_DEVICE_INTR_SRQ 30 #define VXI11_INTR_PROGRAM 0x0607B1 #define VXI11_INTR_VERSION 1 static int proto_vxi11_intr; static int ett_vxi11_intr; static int hf_vxi11_intr_procedure_v1; static int hf_vxi11_intr_handle; /* Helper routines for dissecting common fields. */ static int dissect_error(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, const char *packet_type, uint32_t *error) { const char *errstr; *error = tvb_get_ntohl(tvb, offset); errstr = val_to_str(*error, vxi11_core_error_vals, "Error %d"); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_error, offset); proto_item_append_text(tree, " (%s) %s", packet_type, errstr); col_append_fstr(pinfo->cinfo, COL_INFO, " %s", errstr); return offset; } static int dissect_flags(tvbuff_t *tvb, int offset, proto_tree *tree) { if (tree) { uint32_t flags = tvb_get_ntohl(tvb, offset); proto_item *flags_item = proto_tree_add_item(tree, hf_vxi11_core_flags, tvb, offset, 4, ENC_BIG_ENDIAN); if (flags_item) { proto_tree *flags_tree = proto_item_add_subtree(flags_item, ett_vxi11_core_flags); proto_tree_add_item(flags_tree, hf_vxi11_core_flag_wait_lock, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(flags_tree, hf_vxi11_core_flag_end, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(flags_tree, hf_vxi11_core_flag_term_chr_set, tvb, offset, 4, ENC_BIG_ENDIAN); if (flags != 0) { wmem_strbuf_t *strbuf = wmem_strbuf_create(wmem_packet_scope()); if (flags & VXI11_CORE_FLAG_WAITLOCK) { wmem_strbuf_append(strbuf, "WAIT_LOCK, "); } if (flags & VXI11_CORE_FLAG_END) { wmem_strbuf_append(strbuf, "END, "); } if (flags & VXI11_CORE_FLAG_TERMCHRSET) { wmem_strbuf_append(strbuf, "TERM_CHR_SET, "); } wmem_strbuf_truncate(strbuf, wmem_strbuf_get_len(strbuf) - 2); proto_item_append_text(flags_item, " (%s)", wmem_strbuf_get_str(strbuf)); } } } return offset + 4; } static int dissect_reason(tvbuff_t *tvb, int offset, proto_tree *tree) { if (tree) { uint32_t reason = tvb_get_ntohl(tvb, offset); proto_item *reason_item = proto_tree_add_item(tree, hf_vxi11_core_reason, tvb, offset, 4, ENC_BIG_ENDIAN); if (reason_item) { proto_tree *reason_tree = proto_item_add_subtree(reason_item, ett_vxi11_core_reason); proto_tree_add_item(reason_tree, hf_vxi11_core_reason_req_cnt, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(reason_tree, hf_vxi11_core_reason_chr, tvb, offset, 4, ENC_BIG_ENDIAN); proto_tree_add_item(reason_tree, hf_vxi11_core_reason_end, tvb, offset, 4, ENC_BIG_ENDIAN); if (reason != 0) { wmem_strbuf_t *strbuf = wmem_strbuf_create(wmem_packet_scope()); if (reason & VXI11_CORE_REASON_REQCNT) { wmem_strbuf_append(strbuf, "REQ_CNT, "); } if (reason & VXI11_CORE_REASON_CHR) { wmem_strbuf_append(strbuf, "CHR, "); } if (reason & VXI11_CORE_REASON_END) { wmem_strbuf_append(strbuf, "END, "); } wmem_strbuf_truncate(strbuf, wmem_strbuf_get_len(strbuf) - 2); proto_item_append_text(reason_item, " (%s)", wmem_strbuf_get_str(strbuf)); } } } return offset + 4; } /* Dissectors for individual RPC requests and responses. */ static int dissect_create_link_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { const char *str; int offset = 0; offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_client_id, offset); offset = dissect_rpc_bool(tvb, tree, hf_vxi11_core_lock_device, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lock_timeout, offset); offset = dissect_rpc_string(tvb, tree, hf_vxi11_core_device, offset, &str); proto_item_append_text(tree, " (Create_LinkParms) %s", str); col_append_fstr(pinfo->cinfo, COL_INFO, " %s", str); return offset; } static int dissect_create_link_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t error, lid; int offset = 0; offset = dissect_error(tvb, offset, pinfo, tree, "Create_LinkResp", &error); lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_abort_port, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_max_recv_size, offset); if (error == VXI11_CORE_ERROR_NO_ERROR) { proto_item_append_text(tree, " LID=%d", lid); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); } return offset; } static int dissect_device_SRQ_parms(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_) { int offset = dissect_rpc_opaque_data(tvb, 0, tree, NULL, hf_vxi11_intr_handle, false, 0, false, NULL, NULL); proto_item_append_text(tree, " (Device_SrqParms)"); return offset; } static int dissect_device_docmd_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t lid, cmd; const char *cmdstr; int offset = 0; lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_flags(tvb, offset, tree); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_io_timeout, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lock_timeout, offset); cmd = tvb_get_ntohl(tvb, offset); cmdstr = val_to_str(cmd, vxi11_core_cmd_vals, "Unknown(0x%x)"); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_cmd, offset); offset = dissect_rpc_bool(tvb, tree, hf_vxi11_core_network_order, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_size, offset); offset = dissect_rpc_opaque_data(tvb, offset, tree, NULL, hf_vxi11_core_data, false, 0, false, NULL, NULL); proto_item_append_text(tree, " (Device_DocmdParms) LID=%d CMD=%s", lid, cmdstr); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d CMD=%s", lid, cmdstr); return offset; } static int dissect_device_docmd_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t error; int offset = 0; offset = dissect_error(tvb, offset, pinfo, tree, "Device_DocmdResp", &error); offset = dissect_rpc_opaque_data(tvb, offset, tree, NULL, hf_vxi11_core_data, false, 0, false, NULL, NULL); return offset; } static int dissect_device_enable_SRQ_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { int offset = 0; uint32_t lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_rpc_bool(tvb, tree, hf_vxi11_core_enable, offset); offset = dissect_rpc_opaque_data(tvb, offset, tree, NULL, hf_vxi11_core_handle, false, 0, false, NULL, NULL); proto_item_append_text(tree, " (Device_EnableSrqParms) LID=%d", lid); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); return offset; } static int dissect_device_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t error; return dissect_error(tvb, 0, pinfo, tree, "Device_Error", &error); } static int dissect_device_generic_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { int offset = 0; uint32_t lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_flags(tvb, offset, tree); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_io_timeout, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lock_timeout, offset); proto_item_append_text(tree, " (Device_GenericParms) LID=%d", lid); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); return offset; } static int dissect_device_link(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { int offset = 0; uint32_t lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); proto_item_append_text(tree, " (Device_Link) LID=%d", lid); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); return offset; } static int dissect_device_lock_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { int offset = 0; uint32_t lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_flags(tvb, offset, tree); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lock_timeout, offset); proto_item_append_text(tree, " (Device_LockParms) LID=%d", lid); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); return offset; } static int dissect_device_read_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { int offset = 0; uint32_t lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_size, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_io_timeout, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lock_timeout, offset); offset = dissect_flags(tvb, offset, tree); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_term_char, offset); proto_item_append_text(tree, " (Device_ReadParms) LID=%d", lid); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); return offset; } static int dissect_device_read_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t error; int offset = 0; uint32_t datalength = 0; offset = dissect_error(tvb, offset, pinfo, tree, "Device_ReadResp", &error); offset = dissect_reason(tvb, offset, tree); datalength = tvb_get_ntohl( tvb, offset); if(MAX_DATA_SHOW_SIZE <=datalength) datalength = MAX_DATA_SHOW_SIZE; col_append_fstr( pinfo->cinfo, COL_INFO," %s",tvb_format_text(pinfo->pool, tvb, offset+4,(uint32_t) datalength)); offset = dissect_rpc_opaque_data(tvb, offset, tree, NULL, hf_vxi11_core_data, false, 0, false, NULL, NULL); return offset; } static int dissect_device_readstb_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t error, stb; int offset = 0; offset = dissect_error(tvb, offset, pinfo, tree, "Device_ReadStbResp", &error); stb = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_stb, offset); if (error == VXI11_CORE_ERROR_NO_ERROR) { proto_item_append_text(tree, " STB=0x%02x", stb); col_append_fstr(pinfo->cinfo, COL_INFO, " STB=0x%02x", stb); } return offset; } static int dissect_device_remote_func(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t port; const char *addrstr; int offset = 0; addrstr = tvb_ip_to_str(pinfo->pool, tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_host_addr, offset); port = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_host_port, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_prog_num, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_prog_vers, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_prog_family, offset); proto_item_append_text(tree, " (Device_RemoteFunc) %s:%d", addrstr, port); col_append_fstr(pinfo->cinfo, COL_INFO, " %s:%d", addrstr, port); return offset; } static int dissect_device_write_parms(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t datalength = 0; int offset = 0; uint32_t lid = tvb_get_ntohl(tvb, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lid, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_io_timeout, offset); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_lock_timeout, offset); offset = dissect_flags(tvb, offset, tree); col_append_fstr(pinfo->cinfo, COL_INFO, " LID=%d", lid); datalength = tvb_get_ntohl( tvb, offset); if(MAX_DATA_SHOW_SIZE <=datalength) datalength = MAX_DATA_SHOW_SIZE; col_append_fstr( pinfo->cinfo, COL_INFO," %s",tvb_format_text(pinfo->pool, tvb, offset+4,(uint32_t) datalength)); offset = dissect_rpc_opaque_data(tvb, offset, tree, NULL, hf_vxi11_core_data, false, 0, false, NULL, NULL); proto_item_append_text(tree, " (Device_WriteParms) LID=%d", lid); return offset; } static int dissect_device_write_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) { uint32_t error; int offset = 0; offset = dissect_error(tvb, offset, pinfo, tree, "Device_WriteResp", &error); offset = dissect_rpc_uint32(tvb, tree, hf_vxi11_core_size, offset); return offset; } /* Initialization & registration. */ void proto_register_vxi11_core(void) { static const value_string vxi11_core_v1_proc_vals[] = { { VXI11_CORE_PROC_NULL, "NULL" }, { VXI11_CORE_PROC_CREATE_LINK, "CREATE_LINK" }, { VXI11_CORE_PROC_DEVICE_WRITE, "DEVICE_WRITE" }, { VXI11_CORE_PROC_DEVICE_READ, "DEVICE_READ" }, { VXI11_CORE_PROC_DEVICE_READSTB, "DEVICE_READSTB" }, { VXI11_CORE_PROC_DEVICE_TRIGGER, "DEVICE_TRIGGER" }, { VXI11_CORE_PROC_DEVICE_CLEAR, "DEVICE_CLEAR" }, { VXI11_CORE_PROC_DEVICE_REMOTE, "DEVICE_REMOTE" }, { VXI11_CORE_PROC_DEVICE_LOCAL, "DEVICE_LOCAL" }, { VXI11_CORE_PROC_DEVICE_LOCK, "DEVICE_LOCK" }, { VXI11_CORE_PROC_DEVICE_UNLOCK, "DEVICE_UNLOCK" }, { VXI11_CORE_PROC_DEVICE_ENABLE_SRQ, "DEVICE_ENABLE_SRQ" }, { VXI11_CORE_PROC_DEVICE_DOCMD, "DEVICE_DOCMD" }, { VXI11_CORE_PROC_DESTROY_LINK, "DESTROY_LINK" }, { VXI11_CORE_PROC_CREATE_INTR_CHAN, "CREATE_INTR_CHAN" }, { VXI11_CORE_PROC_DESTROY_INTR_CHAN, "DESTROY_INTR_CHAN" }, { 0, NULL } }; static const value_string vxi11_core_addr_family_vals[] = { { VXI11_CORE_ADDRESS_FAMILY_TCP, "TCP" }, { VXI11_CORE_ADDRESS_FAMILY_UDP, "UDP" }, { 0, NULL } }; static hf_register_info vxi11_core_hf[] = { { &hf_vxi11_core_procedure_v1, { "V1 Procedure", "vxi11_core.procedure_v1", FT_UINT32, BASE_DEC, VALS(vxi11_core_v1_proc_vals), 0, NULL, HFILL } }, { &hf_vxi11_core_abort_port, { "Abort Port", "vxi11_core.abort_port", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_client_id, { "Client ID", "vxi11_core.client_id", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_cmd, { "Command", "vxi11_core.cmd", FT_UINT32, BASE_HEX, VALS(vxi11_core_cmd_vals), 0, NULL, HFILL } }, { &hf_vxi11_core_data, { "Data", "vxi11_core.data", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_device, { "Device Name", "vxi11_core.device", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_enable, { "Enable", "vxi11_core.enable", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0, NULL, HFILL } }, { &hf_vxi11_core_error, { "Error Code", "vxi11_core.error", FT_UINT32, BASE_DEC, VALS(vxi11_core_error_vals), 0, NULL, HFILL } }, { &hf_vxi11_core_flags, { "Flags", "vxi11_core.flags", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_flag_wait_lock, { "Wait Until Locked", "vxi11_core.flags.wait_lock", FT_BOOLEAN, 32, NULL, VXI11_CORE_FLAG_WAITLOCK, NULL, HFILL } }, { &hf_vxi11_core_flag_end, { "Set EOI", "vxi11_core.flags.end", FT_BOOLEAN, 32, NULL, VXI11_CORE_FLAG_END, NULL, HFILL } }, { &hf_vxi11_core_flag_term_chr_set, { "Termination Character Set", "vxi11_core.flags.term_chr_set", FT_BOOLEAN, 32, NULL, VXI11_CORE_FLAG_TERMCHRSET, NULL, HFILL } }, { &hf_vxi11_core_handle, { "Handle", "vxi11_core.handle", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_host_addr, { "Host Address", "vxi11_core.host_addr", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_host_port, { "Host Port", "vxi11_core.host_port", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_io_timeout, { "I/O Timeout", "vxi11_core.io_timeout", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_lid, { "Link ID", "vxi11_core.lid", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_lock_device, { "Lock Device", "vxi11_core.lock_device", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0, NULL, HFILL } }, { &hf_vxi11_core_lock_timeout, { "Lock Timeout", "vxi11_core.lock_timeout", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_max_recv_size, { "Maximum Receive Size", "vxi11_core.max_recv_size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_network_order, { "Network Byte Order", "vxi11_core.network_order", FT_BOOLEAN, BASE_NONE, TFS(&tfs_yes_no), 0, NULL, HFILL } }, { &hf_vxi11_core_prog_family, { "Address Family", "vxi11_core.prog_family", FT_UINT32, BASE_DEC, VALS(vxi11_core_addr_family_vals), 0, NULL, HFILL } }, { &hf_vxi11_core_prog_num, { "Program", "vxi11_core.prog_num", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_prog_vers, { "Version", "vxi11_core.prog_vers", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_reason, { "Reason", "vxi11_core.reason", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_reason_req_cnt, { "Requested Count Reached", "vxi11_core.reason.req_cnt", FT_BOOLEAN, 32, NULL, VXI11_CORE_REASON_REQCNT, NULL, HFILL } }, { &hf_vxi11_core_reason_chr, { "Termination Character Seen", "vxi11_core.reason.chr", FT_BOOLEAN, 32, NULL, VXI11_CORE_REASON_CHR, NULL, HFILL } }, { &hf_vxi11_core_reason_end, { "EOI Set", "vxi11_core.reason.end", FT_BOOLEAN, 32, NULL, VXI11_CORE_REASON_END, NULL, HFILL } }, { &hf_vxi11_core_size, { "Size", "vxi11_core.size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_stb, { "Status Byte", "vxi11_core.stb", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } }, { &hf_vxi11_core_term_char, { "Termination Character", "vxi11_core.term_char", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } } }; static int *vxi11_core_ett[] = { &ett_vxi11_core, &ett_vxi11_core_flags, &ett_vxi11_core_reason }; proto_vxi11_core = proto_register_protocol("VXI-11 Core Protocol", "VXI-11 Core", "vxi11_core"); proto_register_field_array(proto_vxi11_core, vxi11_core_hf, array_length(vxi11_core_hf)); proto_register_subtree_array(vxi11_core_ett, array_length(vxi11_core_ett)); } void proto_reg_handoff_vxi11_core(void) { /* proc number, "proc name", dissect_request, dissect_reply */ static const vsff vxi111_core_proc[] = { { VXI11_CORE_PROC_NULL, "NULL", dissect_rpc_void, dissect_rpc_void }, { VXI11_CORE_PROC_CREATE_LINK, "CREATE_LINK", dissect_create_link_parms, dissect_create_link_resp }, { VXI11_CORE_PROC_DEVICE_WRITE, "DEVICE_WRITE", dissect_device_write_parms, dissect_device_write_resp }, { VXI11_CORE_PROC_DEVICE_READ, "DEVICE_READ", dissect_device_read_parms, dissect_device_read_resp }, { VXI11_CORE_PROC_DEVICE_READSTB, "DEVICE_READSTB", dissect_device_generic_parms, dissect_device_readstb_resp }, { VXI11_CORE_PROC_DEVICE_TRIGGER, "DEVICE_TRIGGER", dissect_device_generic_parms, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_CLEAR, "DEVICE_CLEAR", dissect_device_generic_parms, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_REMOTE, "DEVICE_REMOTE", dissect_device_generic_parms, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_LOCAL, "DEVICE_LOCAL", dissect_device_generic_parms, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_LOCK, "DEVICE_LOCK", dissect_device_lock_parms, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_UNLOCK, "DEVICE_UNLOCK", dissect_device_link, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_ENABLE_SRQ, "DEVICE_ENABLE_SRQ", dissect_device_enable_SRQ_parms, dissect_device_error }, { VXI11_CORE_PROC_DEVICE_DOCMD, "DEVICE_DOCMD", dissect_device_docmd_parms, dissect_device_docmd_resp }, { VXI11_CORE_PROC_DESTROY_LINK, "DESTROY_LINK", dissect_device_link, dissect_device_error }, { VXI11_CORE_PROC_CREATE_INTR_CHAN, "CREATE_INTR_CHAN", dissect_device_remote_func, dissect_device_error }, { VXI11_CORE_PROC_DESTROY_INTR_CHAN, "DESTROY_INTR_CHAN", dissect_rpc_void, dissect_device_error }, { 0, NULL, NULL, NULL } }; static const rpc_prog_vers_info vxi11_core_vers_info[] = { { VXI11_CORE_VERSION, vxi111_core_proc, &hf_vxi11_core_procedure_v1 }, }; rpc_init_prog(proto_vxi11_core, VXI11_CORE_PROGRAM, ett_vxi11_core, G_N_ELEMENTS(vxi11_core_vers_info), vxi11_core_vers_info); } void proto_register_vxi11_async(void) { static const value_string vxi11_async_v1_proc_vals[] = { { VXI11_ASYNC_PROC_NULL, "NULL" }, { VXI11_ASYNC_PROC_DEVICE_ABORT, "DEVICE_ABORT" }, { 0, NULL } }; static hf_register_info vxi11_async_hf[] = { { &hf_vxi11_async_procedure_v1, { "V1 Procedure", "vxi11_async.procedure_v1", FT_UINT32, BASE_DEC, VALS(vxi11_async_v1_proc_vals), 0, NULL, HFILL } } }; static int *vxi11_async_ett[] = { &ett_vxi11_async, }; proto_vxi11_async = proto_register_protocol("VXI-11 Asynchronous Abort", "VXI-11 Async", "vxi11_async"); proto_register_field_array(proto_vxi11_async, vxi11_async_hf, array_length(vxi11_async_hf)); proto_register_subtree_array(vxi11_async_ett, array_length(vxi11_async_ett)); } void proto_reg_handoff_vxi11_async(void) { static const vsff vxi111_async_proc[] = { { VXI11_ASYNC_PROC_NULL, "NULL", dissect_rpc_void, dissect_rpc_void }, { VXI11_ASYNC_PROC_DEVICE_ABORT, "DEVICE_ABORT", dissect_device_link, dissect_device_error }, { 0, NULL, NULL, NULL } }; static const rpc_prog_vers_info vxi11_async_vers_info[] = { { VXI11_ASYNC_VERSION, vxi111_async_proc, &hf_vxi11_async_procedure_v1 }, }; rpc_init_prog(proto_vxi11_async, VXI11_ASYNC_PROGRAM, ett_vxi11_async, G_N_ELEMENTS(vxi11_async_vers_info), vxi11_async_vers_info); } void proto_register_vxi11_intr(void) { static const value_string vxi11_intr_v1_proc_vals[] = { { VXI11_INTR_PROC_NULL, "NULL" }, { VXI11_INTR_PROC_DEVICE_INTR_SRQ, "DEVICE_INTR_SRQ" }, { 0, NULL } }; static hf_register_info vxi11_intr_hf[] = { { &hf_vxi11_intr_procedure_v1, { "V1 Procedure", "vxi11_intr.procedure_v1", FT_UINT32, BASE_DEC, VALS(vxi11_intr_v1_proc_vals), 0, NULL, HFILL } }, { &hf_vxi11_intr_handle, { "Handle", "vxi11_intr.handle", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL } } }; static int *vxi11_intr_ett[] = { &ett_vxi11_intr, }; proto_vxi11_intr = proto_register_protocol("VXI-11 Interrupt", "VXI-11 Intr", "vxi11_intr"); proto_register_field_array(proto_vxi11_intr, vxi11_intr_hf, array_length(vxi11_intr_hf)); proto_register_subtree_array(vxi11_intr_ett, array_length(vxi11_intr_ett)); } void proto_reg_handoff_vxi11_intr(void) { static const vsff vxi111_intr_proc[] = { { VXI11_INTR_PROC_NULL, "NULL", dissect_rpc_void, dissect_rpc_void }, { VXI11_INTR_PROC_DEVICE_INTR_SRQ, "DEVICE_INTR_SRQ", dissect_device_SRQ_parms, dissect_rpc_void }, { 0, NULL, NULL, NULL } }; static const rpc_prog_vers_info vxi11_intr_vers_info[] = { { VXI11_INTR_VERSION, vxi111_intr_proc, &hf_vxi11_intr_procedure_v1 }, }; rpc_init_prog(proto_vxi11_intr, VXI11_INTR_PROGRAM, ett_vxi11_intr, G_N_ELEMENTS(vxi11_intr_vers_info), vxi11_intr_vers_info); } /* * 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: */