#include "packet-usb.h"
#include "packet-mausb.h"
#include "packet-usbip.h"
+#include "packet-netmon.h"
/* protocols and header fields */
static int proto_usb = -1;
+static int proto_usbport = -1;
/* USB pseudoheader fields, both FreeBSD and Linux */
static int hf_usb_totlen = -1;
static int hf_usb_darwin_iso_frame_number = -1;
static int hf_usb_darwin_iso_timestamp = -1;
+/* NetMon */
+static int hf_usbport_event_id = -1;
+static int hf_usbport_device_object = -1;
+static int hf_usbport_pci_bus = -1;
+static int hf_usbport_pci_device = -1;
+static int hf_usbport_pci_function = -1;
+static int hf_usbport_pci_vendor_id = -1;
+static int hf_usbport_pci_device_id = -1;
+static int hf_usbport_port_path_depth = -1;
+static int hf_usbport_port_path0 = -1;
+static int hf_usbport_port_path1 = -1;
+static int hf_usbport_port_path2 = -1;
+static int hf_usbport_port_path3 = -1;
+static int hf_usbport_port_path4 = -1;
+static int hf_usbport_port_path5 = -1;
+static int hf_usbport_device_handle = -1;
+static int hf_usbport_device_speed = -1;
+static int hf_usbport_endpoint = -1;
+static int hf_usbport_pipehandle = -1;
+static int hf_usbport_endpoint_desc_length = -1;
+static int hf_usbport_endpoint_desc_type = -1;
+static int hf_usbport_endpoint_address = -1;
+static int hf_usbport_bm_attributes = -1;
+static int hf_usbport_max_packet_size = -1;
+static int hf_usbport_interval = -1;
+static int hf_usbport_irp = -1;
+static int hf_usbport_urb = -1;
+static int hf_usbport_urb_transfer_data = -1;
+static int hf_usbport_urb_header_length = -1;
+static int hf_usbport_urb_header_function = -1;
+static int hf_usbport_urb_header_status = -1;
+static int hf_usbport_urb_header_usbddevice_handle = -1;
+static int hf_usbport_urb_header_usbdflags = -1;
+static int hf_usbport_urb_configuration_desc = -1;
+static int hf_usbport_urb_configuration_handle = -1;
+static int hf_usbport_urb_pipe_handle = -1;
+static int hf_usbport_urb_xferflags = -1;
+static int hf_usbport_urb_transfer_buffer_length = -1;
+static int hf_usbport_urb_transfer_buffer = -1;
+static int hf_usbport_urb_transfer_buffer_mdl = -1;
+static int hf_usbport_urb_reserved_mbz = -1;
+static int hf_usbport_urb_reserved_hcd = -1;
+static int hf_usbport_urb_reserved = -1;
+
static gint ett_usb_hdr = -1;
static gint ett_usb_setup_hdr = -1;
static gint ett_usb_isodesc = -1;
static gint ett_usb_xferstatus = -1;
static gint ett_usb_frame = -1;
static gint ett_usb_frame_flags = -1;
+static gint ett_usbport = -1;
+static gint ett_usbport_host_controller = -1;
+static gint ett_usbport_path = -1;
+static gint ett_usbport_device = -1;
+static gint ett_usbport_endpoint = -1;
+static gint ett_usbport_endpoint_desc = -1;
+static gint ett_usbport_urb = -1;
static expert_field ei_usb_bLength_even = EI_INIT;
static expert_field ei_usb_bLength_too_short = EI_INIT;
static expert_field ei_usb_desc_length_invalid = EI_INIT;
static expert_field ei_usb_invalid_setup = EI_INIT;
+static expert_field ei_usbport_invalid_path_depth = EI_INIT;
+
static int usb_address_type = -1;
static const int *usb_endpoint_fields[] = {
static value_string_ext usb_darwin_status_vals_ext = VALUE_STRING_EXT_INIT(darwin_usb_status_vals);
+static const value_string netmon_event_id_vals[] = {
+ {1, "USBPORT_ETW_EVENT_HC_ADD USBPORT_ETW_EVENT_HC_ADD"},
+ {2, "USBPORT_ETW_EVENT_HC_REMOVAL USBPORT_ETW_EVENT_HC_REMOVAL"},
+ {3, "USBPORT_ETW_EVENT_HC_INFORMATION USBPORT_ETW_EVENT_HC_INFORMATION"},
+ {4, "USBPORT_ETW_EVENT_HC_START USBPORT_ETW_EVENT_HC_START"},
+ {5, "USBPORT_ETW_EVENT_HC_STOP USBPORT_ETW_EVENT_HC_STOP"},
+ {6, "USBPORT_ETW_EVENT_HC_SUSPEND USBPORT_ETW_EVENT_HC_SUSPEND"},
+ {7, "USBPORT_ETW_EVENT_HC_RESUME USBPORT_ETW_EVENT_HC_RESUME"},
+ {8, "USBPORT_ETW_EVENT_HC_ASYNC_SCHEDULE_ENABLE"},
+ {9, "USBPORT_ETW_EVENT_HC_ASYNC_SCHEDULE_DISABLE"},
+ {10, "USBPORT_ETW_EVENT_HC_PERIODIC_SCHEDULE_ENABLE"},
+ {11, "USBPORT_ETW_EVENT_HC_PERIODIC_SCHEDULE_DISABLE"},
+ {12, "USBPORT_ETW_EVENT_DEVICE_CREATE"},
+ {13, "USBPORT_ETW_EVENT_DEVICE_INITIALIZE"},
+ {14, "USBPORT_ETW_EVENT_DEVICE_REMOVAL"},
+ {15, "USBPORT_ETW_EVENT_DEVICE_INFORMATION"},
+ {16, "USBPORT_ETW_EVENT_DEVICE_IDLE_STATE_SET"},
+ {17, "USBPORT_ETW_EVENT_DEVICE_IDLE_STATE_CLEAR"},
+ {18, "USBPORT_ETW_EVENT_ENDPOINT_OPEN"},
+ {19, "USBPORT_ETW_EVENT_ENDPOINT_CLOSE USBPORT_ETW_EVENT_ENDPOINT_CLOSE"},
+ {20, "USBPORT_ETW_EVENT_ENDPOINT_INFORMATION"},
+ {21, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SELECT_CONFIGURATION"},
+ {22, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SELECT_INTERFACE"},
+ {23, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_CURRENT_FRAME_NUMBER"},
+ {24, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CONTROL_TRANSFER"},
+ {25, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CONTROL_TRANSFER_EX"},
+ {26, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER"},
+ {27, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_ISOCH_TRANSFER"},
+ {28, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE"},
+ {29, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_DESCRIPTOR_TO_DEVICE"},
+ {30, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_DESCRIPTOR_FROM_ENDPOINT"},
+ {31, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_DESCRIPTOR_TO_ENDPOINT"},
+ {32, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACE"},
+ {33, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_DESCRIPTOR_TO_INTERFACE"},
+ {34, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_FEATURE_TO_DEVICE"},
+ {35, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_FEATURE_TO_INTERFACE"},
+ {36, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_FEATURE_TO_ENDPOINT"},
+ {37, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLEAR_FEATURE_TO_DEVICE"},
+ {38, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLEAR_FEATURE_TO_INTERFACE"},
+ {39, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLEAR_FEATURE_TO_ENDPOINT"},
+ {40, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLEAR_FEATURE_TO_OTHER"},
+ {41, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_FEATURE_TO_OTHER"},
+ {42, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_STATUS_FROM_DEVICE"},
+ {43, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_STATUS_FROM_INTERFACE"},
+ {44, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_STATUS_FROM_ENDPOINT"},
+ {45, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_STATUS_FROM_OTHER"},
+ {46, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_VENDOR_DEVICE"},
+ {47, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_VENDOR_INTERFACE"},
+ {48, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_VENDOR_ENDPOINT"},
+ {49, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLASS_DEVICE"},
+ {50, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLASS_INTERFACE"},
+ {51, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLASS_ENDPOINT"},
+ {52, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_CLASS_OTHER"},
+ {53, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_VENDOR_OTHER"},
+ {54, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_ABORT_PIPE"},
+ {55, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL"},
+ {56, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SYNC_RESET_PIPE"},
+ {57, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SYNC_CLEAR_STALL"},
+ {58, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_CONFIGURATION"},
+ {59, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_INTERFACE"},
+ {60, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_MS_FEATURE_DESCRIPTOR"},
+ {61, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_TAKE_FRAME_LENGTH_CONTROL"},
+ {62, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_RELEASE_FRAME_LENGTH_CONTROL"},
+ {63, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_GET_FRAME_LENGTH"},
+ {64, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_SET_FRAME_LENGTH"},
+ {65, "USBPORT_ETW_EVENT_DISPATCH_URB_FUNCTION_RESERVED"},
+ {66, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_CONTROL_TRANSFER"},
+ {67, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_CONTROL_TRANSFER_EX"},
+ {68, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_CONTROL_TRANSFER_DATA"},
+ {69, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_CONTROL_TRANSFER_EX_DATA"},
+ {70, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER"},
+ {71, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER_DATA"},
+ {72, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_ISOCH_TRANSFER"},
+ {73, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_ISOCH_TRANSFER_DATA"},
+ {74, "USBPORT_ETW_EVENT_INTERNAL_URB_FUNCTION_CONTROL_TRANSFER"},
+ {75, "USBPORT_ETW_EVENT_COMPLETE_INTERNAL_URB_FUNCTION_CONTROL_TRANSFER"},
+ {76, "USBPORT_ETW_EVENT_COMPLETE_INTERNAL_URB_FUNCTION_CONTROL_TRANSFER_DATA"},
+ {77, "USBPORT_ETW_EVENT_COMPLETE_URB_FUNCTION_ABORT_PIPE"},
+ {78, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_HEADER_LENGTH_WARNING"},
+ {79, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_FUNCTION"},
+ {80, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_HEADER_LENGTH"},
+ {81, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_DEVICE_HANDLE"},
+ {82, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_FUNCTION_NOT_SUPPORTED"},
+ {83, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_FUNCTION_RESERVED"},
+ {84, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_DUE_TO_HC_SUSPEND"},
+ {85, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_URB_LINK"},
+ {86, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_PIPE_HANDLE"},
+ {87, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_ZERO_BW_PIPE_HANDLE"},
+ {88, "USBPORT_ETW_EVENT_DISPATCH_URB_NOP_ZERO_BW_PIPE_HANDLE_REQUEST"},
+ {89, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_CONTROL_TRANSFER_ENDPOINT"},
+ {90, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_CONTROL_TRANSFER_BUFFER_LENGTH"},
+ {91, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_BULK_OR_INTERRUPT_TRANSFER_ENDPOINT"},
+ {92, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_BULK_OR_INTERRUPT_TRANSFER_BUFFER_LENGTH"},
+ {93, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_ISOCHRONOUS_TRANSFER_ENDPOINT"},
+ {94, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_NULL_TRANSFER_BUFFER_AND_MDL"},
+ {95, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_NON_NULL_TRANSFER_BUFFER_MDL"},
+ {96, "USBPORT_ETW_EVENT_DISPATCH_URB_ALLOCATE_MDL_FAILURE"},
+ {97, "USBPORT_ETW_EVENT_DISPATCH_URB_ALLOCATE_TRANSFER_CONTEXT_FAILURE"},
+ {98, "USBPORT_ETW_EVENT_DISPATCH_URB_NOP_ROOTHUB_PIPE_HANDLE_REQUEST"},
+ {99, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_ISOCHRONOUS_ZERO_LENGTH"},
+ {100, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_ISOCHRONOUS_NUM_PACKETS"},
+ {101, "USBPORT_ETW_EVENT_DISPATCH_URB_INVALID_ISOCHRONOUS_START_FRAME"},
+ {102, "USBPORT_ETW_EVENT_IRP_CANCEL"},
+ {103, "USBPORT_ETW_EVENT_USBUSER_OP_RAW_RESET_PORT_DISPATCH"},
+ {104, "USBPORT_ETW_EVENT_USBUSER_OP_RAW_RESET_PORT_STATUS1"},
+ {105, "USBPORT_ETW_EVENT_USBUSER_OP_RAW_RESET_PORT_STATUS2"},
+ {106, "USBPORT_ETW_EVENT_USBUSER_OP_RAW_RESET_PORT_STATUS3"},
+ {107, "USBPORT_ETW_EVENT_USBUSER_OP_RAW_RESET_PORT_COMPLETE"},
+ {108, "USBPORT_ETW_EVENT_USBUSER_OP_SEND_ONE_PACKET_DISPATCH"},
+ {109, "USBPORT_ETW_EVENT_USBUSER_OP_SEND_ONE_PACKET_DISPATCH_DATA"},
+ {110, "USBPORT_ETW_EVENT_USBUSER_OP_SEND_ONE_PACKET_TIMEOUT"},
+ {111, "USBPORT_ETW_EVENT_USBUSER_OP_SEND_ONE_PACKET_COMPLETE"},
+ {112, "USBPORT_ETW_EVENT_USBUSER_OP_SEND_ONE_PACKET_COMPLETE_DATA"},
+ {113, "USBPORT_ETW_EVENT_CODE_EXECUTION_TIME"},
+ {114, "USBPORT_ETW_EVENT_PUT_SGLIST_EXECUTION_TIME"},
+ {115, "USBPORT_ETW_EVENT_BUILD_SGLIST_EXECUTION_TIME"},
+ {1024, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_DISPATCH"},
+ {1025, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_COMPLETE"},
+ {1026, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_COMPLETE_ERROR_1"},
+ {1027, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_COMPLETE_ERROR_2"},
+ {1028, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_COMPLETE_ERROR_3"},
+ {1029, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_COMPLETE_ERROR_4"},
+ {1030, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_START_COMPLETE_ERROR_5"},
+ {1031, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_STOP_DISPATCH"},
+ {1032, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_STOP_COMPLETE"},
+ {1033, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_SUSPEND_DISPATCH"},
+ {1034, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_SUSPEND_COMPLETE"},
+ {1035, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_DISPATCH"},
+ {1036, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE"},
+ {1037, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE_ERROR_1"},
+ {1038, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE_ERROR_2"},
+ {1039, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE_ERROR_3"},
+ {1040, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE_ERROR_4"},
+ {1041, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE_ERROR_5"},
+ {1042, "USBPORT_ETW_EVENT_HC_EHCI_MINIPORT_RESUME_COMPLETE_ERROR_6"},
+ {2048, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_DISPATCH"},
+ {2049, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_COMPLETE"},
+ {2050, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_COMPLETE_ERROR_1"},
+ {2051, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_COMPLETE_ERROR_2"},
+ {2052, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_COMPLETE_ERROR_3"},
+ {2053, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_COMPLETE_ERROR_4"},
+ {2054, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_START_COMPLETE_ERROR_5"},
+ {2055, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_STOP_DISPATCH"},
+ {2056, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_STOP_COMPLETE"},
+ {2057, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_SUSPEND_DISPATCH"},
+ {2058, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_SUSPEND_COMPLETE"},
+ {2059, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_DISPATCH"},
+ {2060, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_COMPLETE"},
+ {2061, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_COMPLETE_ERROR_1"},
+ {2062, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_COMPLETE_ERROR_2"},
+ {2063, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_COMPLETE_ERROR_3"},
+ {2064, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_COMPLETE_ERROR_4"},
+ {2065, "USBPORT_ETW_EVENT_HC_OHCI_MINIPORT_RESUME_COMPLETE_ERROR_5"},
+ {3072, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_START_DISPATCH"},
+ {3073, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_START_COMPLETE"},
+ {3074, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_START_COMPLETE_ERROR_1"},
+ {3075, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_START_COMPLETE_ERROR_2"},
+ {3076, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_START_COMPLETE_ERROR_3"},
+ {3077, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_START_COMPLETE_ERROR_4"},
+ {3078, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_STOP_DISPATCH"},
+ {3079, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_STOP_COMPLETE"},
+ {3080, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_SUSPEND_DISPATCH"},
+ {3081, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_SUSPEND_COMPLETE"},
+ {3082, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_DISPATCH"},
+ {3083, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_COMPLETE"},
+ {3084, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_COMPLETE_ERROR_1"},
+ {3085, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_COMPLETE_ERROR_2"},
+ {3086, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_COMPLETE_ERROR_3"},
+ {3087, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_COMPLETE_ERROR_4"},
+ {3088, "USBPORT_ETW_EVENT_HC_UHCI_MINIPORT_RESUME_COMPLETE_ERROR_5"},
+ {3089, "USBPORT_ETW_EVENT_RTPM_TRANSITION"},
+ {3090, "USBPORT_ETW_EVENT_DISPATCH_WAIT_WAKE"},
+ {3091, "USBPORT_ETW_EVENT_COMPLETE_WAIT_WAKE"},
+ {0, NULL}
+};
+static value_string_ext netmon_event_id_vals_ext = VALUE_STRING_EXT_INIT(netmon_event_id_vals);
+
+static const value_string netmon_urb_function_vals[] = {
+ {0x0000, "SELECT_CONFIGURATION"},
+ {0x0001, "SELECT_INTERFACE"},
+ {0x0002, "ABORT_PIPE"},
+ {0x0003, "TAKE_FRAME_LENGTH_CONTROL"},
+ {0x0004, "RELEASE_FRAME_LENGTH_CONTROL"},
+ {0x0005, "GET_FRAME_LENGTH"},
+ {0x0006, "SET_FRAME_LENGTH"},
+ {0x0007, "GET_CURRENT_FRAME_NUMBER"},
+ {0x0008, "CONTROL_TRANSFER"},
+ {0x0009, "BULK_OR_INTERRUPT_TRANSFER"},
+ {0x000A, "ISOCH_TRANSFER"},
+ {0x000B, "GET_DESCRIPTOR_FROM_DEVICE"},
+ {0x000C, "SET_DESCRIPTOR_TO_DEVICE"},
+ {0x000D, "SET_FEATURE_TO_DEVICE"},
+ {0x000E, "SET_FEATURE_TO_INTERFACE"},
+ {0x000F, "SET_FEATURE_TO_ENDPOINT"},
+ {0x0010, "CLEAR_FEATURE_TO_DEVICE"},
+ {0x0011, "CLEAR_FEATURE_TO_INTERFACE"},
+ {0x0012, "CLEAR_FEATURE_TO_ENDPOINT"},
+ {0x0013, "GET_STATUS_FROM_DEVICE"},
+ {0x0014, "GET_STATUS_FROM_INTERFACE"},
+ {0x0015, "GET_STATUS_FROM_ENDPOINT"},
+ {0x0016, "RESERVED"},
+ {0x0017, "VENDOR_DEVICE"},
+ {0x0018, "VENDOR_INTERFACE"},
+ {0x0019, "VENDOR_ENDPOINT"},
+ {0x001A, "CLASS_DEVICE"},
+ {0x001B, "CLASS_INTERFACE"},
+ {0x001C, "CLASS_ENDPOINT"},
+ {0x001D, "RESERVE_0X001D"},
+ {0x001E, "SYNC_RESET_PIPE_AND_CLEAR_STALL"},
+ {0x001F, "CLASS_OTHER"},
+ {0x0020, "VENDOR_OTHER"},
+ {0x0021, "GET_STATUS_FROM_OTHER"},
+ {0x0022, "CLEAR_FEATURE_TO_OTHER"},
+ {0x0023, "SET_FEATURE_TO_OTHER"},
+ {0x0024, "GET_DESCRIPTOR_FROM_ENDPOINT"},
+ {0x0025, "SET_DESCRIPTOR_TO_ENDPOINT"},
+ {0x0026, "GET_CONFIGURATION"},
+ {0x0027, "GET_INTERFACE"},
+ {0x0028, "GET_DESCRIPTOR_FROM_INTERFACE"},
+ {0x0029, "SET_DESCRIPTOR_TO_INTERFACE"},
+ {0x002A, "GET_MS_FEATURE_DESCRIPTOR"},
+ {0x0030, "SYNC_RESET_PIPE"},
+ {0x0031, "SYNC_CLEAR_STALL"},
+ {0x0032, "CONTROL_TRANSFER_EX"},
+ {0x0035, "OPEN_STATIC_STREAMS"},
+ {0x0036, "CLOSE_STATIC_STREAMS"},
+ {0x0037, "BULK_OR_INTERRUPT_TRANSFER_USING_CHAINED_MDL"},
+ {0x0038, "ISOCH_TRANSFER_USING_CHAINED_MDL"},
+ {0, NULL}
+};
+static value_string_ext netmon_urb_function_vals_ext = VALUE_STRING_EXT_INIT(netmon_urb_function_vals);
+
+
void proto_register_usb(void);
void proto_reg_handoff_usb(void);
return tvb_captured_length(tvb);
}
+static void
+netmon_etl_field(proto_tree *tree, tvbuff_t *tvb, int* offset, int hf, guint16 flags)
+{
+ if (flags & EVENT_HEADER_FLAG_64_BIT_HEADER) {
+ /* XXX - This seems to be how values are displayed in Network Monitor */
+ guint64 value = tvb_get_letoh64(tvb, *offset) & 0xFFFFFFFF;
+ proto_tree_add_uint64(tree, hf, tvb, *offset, 8, value);
+ (*offset) += 8;
+ } else {
+ proto_tree_add_item(tree, hf, tvb, *offset, 4, ENC_LITTLE_ENDIAN);
+ (*offset) += 4;
+ }
+}
+
+static int
+netmon_HostController2(proto_tree *tree, tvbuff_t *tvb, int offset, guint16 flags)
+{
+ proto_tree *host_tree;
+
+ host_tree = proto_tree_add_subtree(tree, tvb, offset, (flags & EVENT_HEADER_FLAG_64_BIT_HEADER) ? 20 : 16, ett_usbport_host_controller, NULL, "HostController");
+ netmon_etl_field(host_tree, tvb, &offset, hf_usbport_device_object, flags);
+
+ proto_tree_add_item(host_tree, hf_usbport_pci_bus, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+ offset += 4;
+ proto_tree_add_item(host_tree, hf_usbport_pci_device, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ proto_tree_add_item(host_tree, hf_usbport_pci_function, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ proto_tree_add_item(host_tree, hf_usbport_pci_vendor_id, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ proto_tree_add_item(host_tree, hf_usbport_pci_device_id, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+
+ return offset;
+}
+
+static int
+netmon_UsbPortPath(proto_tree *tree, tvbuff_t *tvb, int offset, packet_info *pinfo)
+{
+ proto_item *path_item, *depth_item;
+ proto_tree *path_tree;
+ guint32 path_depth, path0, path1, path2, path3, path4, path5;
+
+ path_tree = proto_tree_add_subtree(tree, tvb, offset, 28, ett_usbport_path, &path_item, "PortPath: ");
+ depth_item = proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path_depth, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path_depth);
+ offset += 4;
+ proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path0, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path0);
+ offset += 4;
+ proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path1, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path1);
+ offset += 4;
+ proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path2, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path2);
+ offset += 4;
+ proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path3, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path3);
+ offset += 4;
+ proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path4, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path4);
+ offset += 4;
+ proto_tree_add_item_ret_uint(path_tree, hf_usbport_port_path5, tvb, offset, 4, ENC_LITTLE_ENDIAN, &path5);
+ offset += 4;
+ if (path_depth == 0) {
+ proto_item_append_text(path_item, "-");
+ }
+ if (path_depth > 0) {
+ proto_item_append_text(path_item, "%d", path0);
+ }
+ if (path_depth > 1) {
+ proto_item_append_text(path_item, ",%d", path1);
+ }
+ if (path_depth > 2) {
+ proto_item_append_text(path_item, ",%d", path2);
+ }
+ if (path_depth > 3) {
+ proto_item_append_text(path_item, ",%d", path3);
+ }
+ if (path_depth > 4) {
+ proto_item_append_text(path_item, ",%d", path4);
+ }
+ if (path_depth > 5) {
+ proto_item_append_text(path_item, ",%d", path5);
+ }
+ if (path_depth > 6) {
+ expert_add_info(pinfo, depth_item, &ei_usbport_invalid_path_depth);
+ }
+
+ return offset;
+}
+
+static int
+netmon_fid_USBPORT_Device(proto_tree *tree, tvbuff_t *tvb, int offset, guint16 flags, packet_info *pinfo)
+{
+ proto_item *device_item;
+ proto_tree *device_tree;
+
+ device_tree = proto_tree_add_subtree(tree, tvb, offset, 4, ett_usbport_device, &device_item, "Device");
+ netmon_etl_field(device_tree, tvb, &offset, hf_usbport_device_handle, flags);
+ proto_tree_add_item(device_tree, hf_usb_idVendor, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ proto_tree_add_item(device_tree, hf_usb_idProduct, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ offset = netmon_UsbPortPath(device_tree, tvb, offset, pinfo);
+ proto_tree_add_item(device_tree, hf_usbport_device_speed, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+ offset += 4;
+ proto_tree_add_item(device_tree, hf_usb_device_address, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+ offset += 4;
+
+ return offset;
+}
+
+static int
+netmon_fid_USBPORT_Endpoint(proto_tree *tree, tvbuff_t *tvb, int offset, guint16 flags)
+{
+ proto_tree *endpoint_tree;
+
+ endpoint_tree = proto_tree_add_subtree(tree, tvb, offset, (flags & EVENT_HEADER_FLAG_64_BIT_HEADER) ? 24 : 12, ett_usbport_endpoint, NULL, "Endpoint");
+ netmon_etl_field(endpoint_tree, tvb, &offset, hf_usbport_endpoint, flags);
+ netmon_etl_field(endpoint_tree, tvb, &offset, hf_usbport_pipehandle, flags);
+ netmon_etl_field(endpoint_tree, tvb, &offset, hf_usbport_device_handle, flags);
+
+ return offset;
+}
+
+static int
+netmon_fid_USBPORT_Endpoint_Descriptor(proto_tree *tree, tvbuff_t *tvb, int offset)
+{
+ proto_tree *endpoint_desc_tree;
+
+ endpoint_desc_tree = proto_tree_add_subtree(tree, tvb, offset, 7, ett_usbport_endpoint_desc, NULL, "Endpoint Decriptor");
+ proto_tree_add_item(endpoint_desc_tree, hf_usbport_endpoint_desc_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);
+ offset += 1;
+ proto_tree_add_item(endpoint_desc_tree, hf_usbport_endpoint_desc_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
+ offset += 1;
+ proto_tree_add_item(endpoint_desc_tree, hf_usbport_endpoint_address, tvb, offset, 1, ENC_LITTLE_ENDIAN);
+ offset += 1;
+ proto_tree_add_item(endpoint_desc_tree, hf_usbport_bm_attributes, tvb, offset, 1, ENC_LITTLE_ENDIAN);
+ offset += 1;
+ proto_tree_add_item(endpoint_desc_tree, hf_usbport_max_packet_size, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ proto_tree_add_item(endpoint_desc_tree, hf_usbport_interval, tvb, offset, 1, ENC_LITTLE_ENDIAN);
+ offset += 1;
+
+ return offset;
+}
+
+static int
+netmon_URB(proto_tree *tree, tvbuff_t *tvb, int offset, guint16 flags)
+{
+ proto_item *urb_item;
+ proto_tree *urb_tree;
+ guint32 func;
+ int i, start_offset = offset;
+
+ urb_tree = proto_tree_add_subtree(tree, tvb, offset, 8, ett_usbport_urb, &urb_item, "URB");
+ proto_tree_add_item(urb_tree, hf_usbport_urb_header_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ offset += 2;
+ proto_tree_add_item_ret_uint(urb_tree, hf_usbport_urb_header_function, tvb, offset, 2, ENC_LITTLE_ENDIAN, &func);
+ proto_item_append_text(urb_item, ": %s", val_to_str_ext_const(func, &netmon_urb_function_vals_ext, "Unknown"));
+ offset += 2;
+ proto_tree_add_item(urb_tree, hf_usbport_urb_header_status, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+ offset += 4;
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_header_usbddevice_handle, flags);
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_header_usbdflags, flags);
+
+ switch (func)
+ {
+ case 0x0000:
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_configuration_desc, flags);
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_configuration_handle, flags);
+ break;
+ case 0x0008: //URB_FUNCTION_CONTROL_TRANSFER
+ case 0x0009: //URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER
+ case 0x000A: //URB_FUNCTION_ISOCH_TRANSFER
+ case 0x000B: //URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE
+ case 0x000C: //URB_FUNCTION_SET_DESCRIPTOR_TO_DEVICE
+ case 0x000D: //URB_FUNCTION_SET_FEATURE_TO_DEVICE
+ case 0x000E: //URB_FUNCTION_SET_FEATURE_TO_INTERFACE
+ case 0x000F: //URB_FUNCTION_SET_FEATURE_TO_ENDPOINT
+ case 0x0010: //URB_FUNCTION_CLEAR_FEATURE_TO_DEVICE
+ case 0x0011: //URB_FUNCTION_CLEAR_FEATURE_TO_INTERFACE
+ case 0x0012: //URB_FUNCTION_CLEAR_FEATURE_TO_ENDPOINT
+ case 0x0013: //URB_FUNCTION_GET_STATUS_FROM_DEVICE
+ case 0x0014: //URB_FUNCTION_GET_STATUS_FROM_INTERFACE
+ case 0x0015: //URB_FUNCTION_GET_STATUS_FROM_ENDPOINT
+ case 0x0017: //URB_FUNCTION_VENDOR_DEVICE
+ case 0x0018: //URB_FUNCTION_VENDOR_INTERFACE
+ case 0x0019: //URB_FUNCTION_VENDOR_ENDPOINT
+ case 0x001A: //URB_FUNCTION_CLASS_DEVICE
+ case 0x001B: //URB_FUNCTION_CLASS_INTERFACE
+ case 0x001C: //URB_FUNCTION_CLASS_ENDPOINT
+ case 0x001F: //URB_FUNCTION_CLASS_OTHER
+ case 0x0020: //URB_FUNCTION_VENDOR_OTHER
+ case 0x0021: //URB_FUNCTION_GET_STATUS_FROM_OTHER
+ case 0x0022: //URB_FUNCTION_CLEAR_FEATURE_TO_OTHER
+ case 0x0023: //URB_FUNCTION_SET_FEATURE_TO_OTHER
+ case 0x0024: //URB_FUNCTION_GET_DESCRIPTOR_FROM_ENDPOINT
+ case 0x0025: //URB_FUNCTION_SET_DESCRIPTOR_TO_ENDPOINT
+ case 0x0026: //URB_FUNCTION_GET_CONFIGURATION
+ case 0x0027: //URB_FUNCTION_GET_INTERFACE
+ case 0x0028: //URB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACE
+ case 0x0029: //URB_FUNCTION_SET_DESCRIPTOR_TO_INTERFACE
+ case 0x002A: //URB_FUNCTION_GET_MS_FEATURE_DESCRIPTOR
+ case 0x0032: //URB_FUNCTION_CONTROL_TRANSFER_EX
+ case 0x0037: //URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER_USING_CHAINED_MDL
+ case 0x0038: //URB_FUNCTION_ISOCH_TRANSFER_USING_CHAINED_MDL
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_pipe_handle, flags);
+ proto_tree_add_bitmask(urb_tree, tvb, offset, hf_usbport_urb_xferflags, ett_usb_xferflags,
+ usb_xferflags_fields, ENC_LITTLE_ENDIAN);
+ offset += 4;
+ proto_tree_add_item(urb_tree, hf_usbport_urb_transfer_buffer_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+ offset += 4;
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_transfer_buffer, flags);
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_transfer_buffer_mdl, flags);
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_reserved_mbz, flags);
+ for (i = 0; i < 8; i++)
+ {
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_reserved_hcd, flags);
+ }
+ break;
+
+ case 0x0002: //URB_FUNCTION_ABORT_PIPE
+ case 0x001E: //URB_FUNCTION_SYNC_RESET_PIPE_AND_CLEAR_STALL
+ case 0x0030: //URB_FUNCTION_SYNC_RESET_PIPE
+ case 0x0031: //URB_FUNCTION_SYNC_CLEAR_STALL
+ case 0x0036: //URB_FUNCTION_CLOSE_STATIC_STREAMS
+ netmon_etl_field(urb_tree, tvb, &offset, hf_usbport_urb_pipe_handle, flags);
+ proto_tree_add_item(urb_tree, hf_usbport_urb_reserved, tvb, offset, 4, ENC_LITTLE_ENDIAN);
+ offset += 4;
+ break;
+ }
+
+ proto_item_set_len(urb_item, offset-start_offset);
+ return offset;
+}
+
+static int
+dissect_netmon_usb_port(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent, void* data)
+{
+ proto_item *ti, *generated;
+ proto_tree *usb_port_tree;
+ int offset = 0;
+ struct netmon_provider_id_data *provider_id_data = (struct netmon_provider_id_data*)data;
+
+ DISSECTOR_ASSERT(provider_id_data != NULL);
+
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "USBPort");
+ col_clear(pinfo->cinfo, COL_INFO);
+
+ ti = proto_tree_add_item(parent, proto_usbport, tvb, 0, -1, ENC_NA);
+ usb_port_tree = proto_item_add_subtree(ti, ett_usbport);
+
+ generated = proto_tree_add_uint(usb_port_tree, hf_usbport_event_id, tvb, 0, 0, provider_id_data->event_id);
+ PROTO_ITEM_SET_GENERATED(generated);
+
+ switch (provider_id_data->event_id)
+ {
+ case 71:
+ offset = netmon_HostController2(usb_port_tree, tvb, offset, provider_id_data->event_flags);
+ offset = netmon_fid_USBPORT_Device(usb_port_tree, tvb, offset, provider_id_data->event_flags, pinfo);
+ offset = netmon_fid_USBPORT_Endpoint(usb_port_tree, tvb, offset, provider_id_data->event_flags);
+ offset = netmon_fid_USBPORT_Endpoint_Descriptor(usb_port_tree, tvb, offset);
+ netmon_etl_field(usb_port_tree, tvb, &offset, hf_usbport_irp, provider_id_data->event_flags);
+ netmon_etl_field(usb_port_tree, tvb, &offset, hf_usbport_urb, provider_id_data->event_flags);
+ offset = netmon_URB(usb_port_tree, tvb, offset, provider_id_data->event_flags);
+ proto_tree_add_item(usb_port_tree, hf_usbport_urb_transfer_data, tvb, offset, 2, ENC_LITTLE_ENDIAN);
+ break;
+ }
+
+ return tvb_captured_length(tvb);
+}
+
void
dissect_usb_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent,
usb_header_t header_type, void *extra_data)
FT_STRING, STR_ASCII, NULL, 0x0,
NULL, HFILL }
}
- };
+ };
+
+ static hf_register_info hf_usbport[] = {
+ { &hf_usbport_event_id,
+ { "Event ID", "usbport.event_id",
+ FT_UINT32, BASE_DEC_HEX|BASE_EXT_STRING, &netmon_event_id_vals_ext, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_device_object,
+ { "Device Object", "usbport.device_object",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_pci_bus,
+ { "PCI Bus", "usbport.pci_bus",
+ FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_pci_device,
+ { "PCI Bus", "usbport.pci_device",
+ FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_pci_function,
+ { "PCI Function", "usbport.pci_function",
+ FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_pci_vendor_id,
+ { "PCI Vendor ID", "usbport.pci_vendor_id",
+ FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_pci_device_id,
+ { "PCI Device ID", "usbport.pci_device_id",
+ FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path_depth,
+ { "Path Depth", "usbport.port_path_depth",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path0,
+ { "Path0", "usbport.port_path0",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path1,
+ { "Path1", "usbport.port_path1",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path2,
+ { "Path2", "usbport.port_path2",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path3,
+ { "Path3", "usbport.port_path3",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path4,
+ { "Path4", "usbport.port_path4",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_port_path5,
+ { "Path5", "usbport.port_path5",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_device_handle,
+ { "Device Handle", "usbport.device_handle",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_device_speed,
+ { "Device Speed", "usbport.device_speed",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_endpoint,
+ { "Endpoint", "usbport.endpoint",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_pipehandle,
+ { "Pipe Handle", "usbport.pipehandle",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_endpoint_desc_length,
+ { "Length", "usbport.endpoint_desc_length",
+ FT_UINT8, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_endpoint_desc_type,
+ { "Description Type", "usbport.endpoint_desc_type",
+ FT_UINT8, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_endpoint_address,
+ { "Endpoint Address", "usbport.endpoint_address",
+ FT_UINT8, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_bm_attributes,
+ { "bmAttributes", "usbport.bm_attributes",
+ FT_UINT8, BASE_DEC_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_max_packet_size,
+ { "Max Packet Size", "usbport.max_packet_size",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_interval,
+ { "Interval", "usbport.interval",
+ FT_UINT8, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_irp,
+ { "IRP", "usbport.irp",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb,
+ { "URB", "usbport.urb",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_transfer_data,
+ { "URB Transfer data", "usbport.urb_transfer_data",
+ FT_UINT_BYTES, BASE_NONE, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_header_length,
+ { "URB Header Length", "usbport.urb_header_length",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_header_function,
+ { "URB Header Function", "usbport.urb_header_function",
+ FT_UINT16, BASE_DEC|BASE_EXT_STRING, &netmon_urb_function_vals_ext, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_header_status,
+ { "URB Header Status", "usbport.urb_header_status",
+ FT_UINT16, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_header_usbddevice_handle,
+ { "URB Header Device Handle", "usbport.urb_header_usbddevice_handle",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_header_usbdflags,
+ { "URB Header Flags", "usbport.urb_header_usbdflags",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_configuration_desc,
+ { "URB Configuration Description", "usbport.urb_configuration_desc",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_configuration_handle,
+ { "URB Configuration Handle", "usbport.urb_configuration_handle",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_pipe_handle,
+ { "URB Pipe Handle", "usbport.urb_pipe_handle",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_xferflags,
+ { "URB Transfer Flags", "usbport.urb_xferflags",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_transfer_buffer_length,
+ { "URB Transfer Buffer Length", "usbport.urb_transfer_buffer_length",
+ FT_UINT32, BASE_DEC, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_transfer_buffer,
+ { "URB Transfer Buffer", "usbport.urb_transfer_buffer",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_transfer_buffer_mdl,
+ { "URB Transfer Buffer MDL", "usbport.urb_transfer_buffer_mdl",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_reserved_mbz,
+ { "URB Reserved MBZ", "usbport.urb_reserved_mbz",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_reserved_hcd,
+ { "URB Reserved HCD", "usbport.urb_reserved_hcd",
+ FT_UINT64, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ { &hf_usbport_urb_reserved,
+ { "URB Reserved", "usbport.urb_reserved",
+ FT_UINT32, BASE_HEX, NULL, 0x0,
+ NULL, HFILL }
+ },
+ };
static gint *usb_subtrees[] = {
&ett_usb_hdr,
&ett_configuration_bmAttributes,
&ett_configuration_bEndpointAddress,
&ett_endpoint_bmAttributes,
- &ett_endpoint_wMaxPacketSize
+ &ett_endpoint_wMaxPacketSize,
+ };
+
+ static gint *usbport_subtrees[] = {
+ &ett_usbport,
+ &ett_usbport_host_controller,
+ &ett_usbport_path,
+ &ett_usbport_device,
+ &ett_usbport_endpoint,
+ &ett_usbport_endpoint_desc,
+ &ett_usbport_urb,
};
static ei_register_info ei[] = {
{ &ei_usb_desc_length_invalid, { "usb.desc_length.invalid", PI_MALFORMED, PI_ERROR, "Invalid descriptor length", EXPFILL }},
{ &ei_usb_invalid_setup, { "usb.setup.invalid", PI_MALFORMED, PI_ERROR, "Only control URBs may contain a setup packet", EXPFILL }}
};
+ static ei_register_info ei_usbport[] = {
+ { &ei_usbport_invalid_path_depth, { "usbport.path_depth.invalid", PI_PROTOCOL, PI_WARN, "Invalid path depth", EXPFILL }},
+ };
- expert_module_t* expert_usb;
+ expert_module_t *expert_usb, *expert_usbport;
proto_usb = proto_register_protocol("USB", "USB", "usb");
+ proto_usbport = proto_register_protocol("USBPort", "USBPort", "usbport");
+
proto_register_field_array(proto_usb, hf, array_length(hf));
+ proto_register_field_array(proto_usbport, hf_usbport, array_length(hf_usbport));
proto_register_subtree_array(usb_subtrees, array_length(usb_subtrees));
+ proto_register_subtree_array(usbport_subtrees, array_length(usbport_subtrees));
expert_usb = expert_register_protocol(proto_usb);
expert_register_field_array(expert_usb, ei, array_length(ei));
+ expert_usbport = expert_register_protocol(proto_usbport);
+ expert_register_field_array(expert_usbport, ei_usbport, array_length(ei_usbport));
device_to_product_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
device_to_protocol_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
dissector_handle_t win32_usb_handle;
dissector_handle_t freebsd_usb_handle;
dissector_handle_t darwin_usb_handle;
+ dissector_handle_t netmon_usb_port_handle;
+ static guid_key usb_port_key = {{ 0xc88a4ef5, 0xd048, 0x4013, { 0x94, 0x08, 0xe0, 0x4b, 0x7d, 0xb2, 0x81, 0x4a }}, 0 };
linux_usb_handle = create_dissector_handle(dissect_linux_usb, proto_usb);
linux_usb_mmapped_handle = create_dissector_handle(dissect_linux_usb_mmapped,
dissector_add_uint("wtap_encap", WTAP_ENCAP_USBPCAP, win32_usb_handle);
dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_FREEBSD, freebsd_usb_handle);
dissector_add_uint("wtap_encap", WTAP_ENCAP_USB_DARWIN, darwin_usb_handle);
+
+ netmon_usb_port_handle = create_dissector_handle( dissect_netmon_usb_port, proto_usbport);
+ dissector_add_guid( "netmon.provider_id", &usb_port_key, netmon_usb_port_handle);
+
}
/*
git.samba.org / metze / wireshark / wip.git / commitdiff