html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/r-efi-5.3.0/src/protocols/shell.rs

@@ -0,0 +1,295 @@
+//! Shell Protocol
+//!
+//! Provides shell services to UEFI applications.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x6302d008,
+    0x7f9b,
+    0x4f30,
+    0x87,
+    0xac,
+    &[0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e],
+);
+
+pub const MAJOR_VERSION: u32 = 0x00000002;
+pub const MINOR_VERSION: u32 = 0x00000002;
+
+pub type FileHandle = *mut core::ffi::c_void;
+
+pub type DeviceNameFlags = u32;
+pub const DEVICE_NAME_USE_COMPONENT_NAME: DeviceNameFlags = 0x00000001;
+pub const DEVICE_NAME_USE_DEVICE_PATH: DeviceNameFlags = 0x00000002;
+
+#[repr(C)]
+pub struct ListEntry {
+    pub flink: *mut ListEntry,
+    pub blink: *mut ListEntry,
+}
+
+#[repr(C)]
+pub struct FileInfo {
+    pub link: ListEntry,
+    pub status: crate::base::Status,
+    pub full_name: *mut crate::base::Char16,
+    pub file_name: *mut crate::base::Char16,
+    pub handle: FileHandle,
+    pub info: *mut crate::protocols::file::Info,
+}
+
+pub type Execute = eficall! {fn(
+    *mut crate::base::Handle,
+    *mut crate::base::Char16,
+    *mut *mut crate::base::Char16,
+    *mut crate::base::Status,
+) -> crate::base::Status};
+
+pub type GetEnv = eficall! {fn(
+    *mut crate::base::Char16,
+) -> *mut crate::base::Char16};
+
+pub type SetEnv = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut crate::base::Char16,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type GetAlias = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut crate::base::Boolean,
+) -> *mut crate::base::Char16};
+
+pub type SetAlias = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut crate::base::Char16,
+    crate::base::Boolean,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type GetHelpText = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut crate::base::Char16,
+    *mut *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type GetDevicePathFromMap = eficall! {fn(
+    *mut crate::base::Char16,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type GetMapFromDevicePath = eficall! {fn(
+    *mut *mut crate::protocols::device_path::Protocol,
+) -> *mut crate::base::Char16};
+
+pub type GetDevicePathFromFilePath = eficall! {fn(
+    *mut crate::base::Char16,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type GetFilePathFromDevicePath = eficall! {fn(
+    *mut crate::protocols::device_path::Protocol,
+) -> *mut crate::base::Char16};
+
+pub type SetMap = eficall! {fn(
+    *mut crate::protocols::device_path::Protocol,
+    *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type GetCurDir = eficall! {fn(
+    *mut crate::base::Char16,
+) -> *mut crate::base::Char16};
+
+pub type SetCurDir = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type OpenFileList = eficall! {fn(
+    *mut crate::base::Char16,
+    u64,
+    *mut *mut FileInfo,
+) -> crate::base::Status};
+
+pub type FreeFileList = eficall! {fn(
+    *mut *mut FileInfo,
+) -> crate::base::Status};
+
+pub type RemoveDupInFileList = eficall! {fn(
+    *mut *mut FileInfo,
+) -> crate::base::Status};
+
+pub type BatchIsActive = eficall! {fn() -> crate::base::Boolean};
+
+pub type IsRootShell = eficall! {fn() -> crate::base::Boolean};
+
+pub type EnablePageBreak = eficall! {fn()};
+
+pub type DisablePageBreak = eficall! {fn()};
+
+pub type GetPageBreak = eficall! {fn() -> crate::base::Boolean};
+
+pub type GetDeviceName = eficall! {fn(
+    crate::base::Handle,
+    DeviceNameFlags,
+    *mut crate::base::Char8,
+    *mut *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type GetFileInfo = eficall! {fn(
+    FileHandle,
+) -> *mut crate::protocols::file::Info};
+
+pub type SetFileInfo = eficall! {fn(
+    FileHandle,
+    *mut crate::protocols::file::Info
+) -> crate::base::Status};
+
+pub type OpenFileByName = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut FileHandle,
+    u64,
+) -> crate::base::Status};
+
+pub type CloseFile = eficall! {fn(
+    FileHandle,
+) -> crate::base::Status};
+
+pub type CreateFile = eficall! {fn(
+    *mut crate::base::Char16,
+    u64,
+    *mut FileHandle,
+) -> crate::base::Status};
+
+pub type ReadFile = eficall! {fn(
+    FileHandle,
+    *mut usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type WriteFile = eficall! {fn(
+    FileHandle,
+    *mut usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type DeleteFile = eficall! {fn(
+    FileHandle,
+) -> crate::base::Status};
+
+pub type DeleteFileByName = eficall! {fn(
+    *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type GetFilePosition = eficall! {fn(
+    FileHandle,
+    *mut u64,
+) -> crate::base::Status};
+
+pub type SetFilePosition = eficall! {fn(
+    FileHandle,
+    u64,
+) -> crate::base::Status};
+
+pub type FlushFile = eficall! {fn(
+    FileHandle,
+) -> crate::base::Status};
+
+pub type FindFiles = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut *mut FileInfo,
+) -> crate::base::Status};
+
+pub type FindFilesInDir = eficall! {fn(
+    FileHandle,
+    *mut *mut FileInfo,
+) -> crate::base::Status};
+
+pub type GetFileSize = eficall! {fn(
+    FileHandle,
+    *mut u64,
+) -> crate::base::Status};
+
+pub type OpenRoot = eficall! {fn(
+    *mut crate::protocols::device_path::Protocol,
+    *mut FileHandle,
+) -> crate::base::Status};
+
+pub type OpenRootByHandle = eficall! {fn(
+    crate::base::Handle,
+    *mut FileHandle,
+) -> crate::base::Status};
+
+pub type RegisterGuidName = eficall! {fn(
+    *mut crate::base::Guid,
+    *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type GetGuidName = eficall! {fn(
+    *mut crate::base::Guid,
+    *mut *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type GetGuidFromName = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut crate::base::Guid,
+) -> crate::base::Status};
+
+pub type GetEnvEx = eficall! {fn(
+    *mut crate::base::Char16,
+    *mut u32,
+) -> *mut crate::base::Char16};
+
+#[repr(C)]
+pub struct Protocol {
+    pub execute: Execute,
+    pub get_env: GetEnv,
+    pub set_env: SetEnv,
+    pub get_alias: GetAlias,
+    pub set_alias: SetAlias,
+    pub get_help_text: GetHelpText,
+    pub get_device_path_from_map: GetDevicePathFromMap,
+    pub get_map_from_device_path: GetMapFromDevicePath,
+    pub get_device_path_from_file_path: GetDevicePathFromFilePath,
+    pub get_file_path_from_device_path: GetFilePathFromDevicePath,
+    pub set_map: SetMap,
+
+    pub get_cur_dir: GetCurDir,
+    pub set_cur_dir: SetCurDir,
+    pub open_file_list: OpenFileList,
+    pub free_file_list: FreeFileList,
+    pub remove_dup_in_file_list: RemoveDupInFileList,
+
+    pub batch_is_active: BatchIsActive,
+    pub is_root_shell: IsRootShell,
+    pub enable_page_break: EnablePageBreak,
+    pub disable_page_break: DisablePageBreak,
+    pub get_page_break: GetPageBreak,
+    pub get_device_name: GetDeviceName,
+
+    pub get_file_info: GetFileInfo,
+    pub set_file_info: SetFileInfo,
+    pub open_file_by_name: OpenFileByName,
+    pub close_file: CloseFile,
+    pub create_file: CreateFile,
+    pub read_file: ReadFile,
+    pub write_file: WriteFile,
+    pub delete_file: DeleteFile,
+    pub delete_file_by_name: DeleteFileByName,
+    pub get_file_position: GetFilePosition,
+    pub set_file_position: SetFilePosition,
+    pub flush_file: FlushFile,
+    pub find_files: FindFiles,
+    pub find_files_in_dir: FindFilesInDir,
+    pub get_file_size: GetFileSize,
+
+    pub open_root: OpenRoot,
+    pub open_root_by_handle: OpenRootByHandle,
+
+    pub execution_break: crate::base::Event,
+
+    pub major_version: u32,
+    pub minor_version: u32,
+    pub register_guid_name: RegisterGuidName,
+    pub get_guid_name: GetGuidName,
+    pub get_guid_from_name: GetGuidFromName,
+
+    // Shell 2.1
+    pub get_env_ex: GetEnvEx,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/shell_dynamic_command.rs

@@ -0,0 +1,33 @@
+//! Shell Dynamic Command Protocol
+//!
+//! Defined in UEFI Shell Specification, Section 2.4
+
+use super::{shell, shell_parameters};
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x3c7200e9,
+    0x005f,
+    0x4ea4,
+    0x87,
+    0xde,
+    &[0xa3, 0xdf, 0xac, 0x8a, 0x27, 0xc3],
+);
+
+pub type CommandHandler = eficall! {fn(
+    *mut Protocol,
+    *mut crate::system::SystemTable,
+    *mut shell_parameters::Protocol,
+    *mut shell::Protocol,
+) -> crate::base::Status};
+
+pub type CommandGetHelp = eficall! {fn(
+    *mut Protocol,
+    *mut crate::base::Char8,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub command_name: *mut crate::base::Char16,
+    pub handler: CommandHandler,
+    pub get_help: CommandGetHelp,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/shell_parameters.rs

@@ -0,0 +1,23 @@
+//! Shell Parameters Protocol
+//!
+//! Defined in the UEFI Shell Specification, Section 2.3.
+
+use super::shell;
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x752f3136,
+    0x4e16,
+    0x4fdc,
+    0xa2,
+    0x2a,
+    &[0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca],
+);
+
+#[repr(C)]
+pub struct Protocol {
+    pub argv: *mut *mut crate::base::Char16,
+    pub argc: usize,
+    pub std_in: shell::FileHandle,
+    pub std_out: shell::FileHandle,
+    pub std_err: shell::FileHandle,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/simple_file_system.rs

@@ -0,0 +1,26 @@
+//! Simple File System Protocol
+//!
+//! Provides the `open_volume` function returning a file protocol representing the root directory
+//! of a filesystem.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x964e5b22,
+    0x6459,
+    0x11d2,
+    0x8e,
+    0x39,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+pub const REVISION: u64 = 0x0000000000010000u64;
+
+pub type ProtocolOpenVolume = eficall! {fn(
+    *mut Protocol,
+    *mut *mut crate::protocols::file::Protocol,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub revision: u64,
+    pub open_volume: ProtocolOpenVolume,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/simple_network.rs

@@ -0,0 +1,196 @@
+//! Simple Network Protocol
+//!
+//! The simple network protcol provides services to initialize a network interface, transmit
+//! packets, receive packets, and close a network interface.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xa19832b9,
+    0xac25,
+    0x11d3,
+    0x9a,
+    0x2d,
+    &[0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d],
+);
+
+pub const REVISION: u64 = 0x0000000000010000u64;
+
+pub const MAX_MCAST_FILTER_CNT: usize = 16;
+
+pub const RECEIVE_UNICAST: u32 = 0x00000001u32;
+pub const RECEIVE_MULTICAST: u32 = 0x00000002u32;
+pub const RECEIVE_BROADCAST: u32 = 0x00000004u32;
+pub const RECEIVE_PROMISCUOUS: u32 = 0x00000008u32;
+pub const RECEIVE_PROMISCUOUS_MULTICAST: u32 = 0x00000010u32;
+
+pub const RECEIVE_INTERRUPT: u32 = 0x00000001u32;
+pub const TRANSMIT_INTERRUPT: u32 = 0x00000002u32;
+pub const COMMAND_INTERRUPT: u32 = 0x00000004u32;
+pub const SOFTWARE_INTERRUPT: u32 = 0x000000008u32;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Mode {
+    pub state: u32,
+    pub hw_address_size: u32,
+    pub media_header_size: u32,
+    pub max_packet_size: u32,
+    pub nvram_size: u32,
+    pub nvram_access_size: u32,
+    pub receive_filter_mask: u32,
+    pub receive_filter_setting: u32,
+    pub max_mcast_filter_count: u32,
+    pub mcast_filter_count: u32,
+    pub mcast_filter: [crate::base::MacAddress; MAX_MCAST_FILTER_CNT],
+    pub current_address: crate::base::MacAddress,
+    pub broadcast_address: crate::base::MacAddress,
+    pub permanent_address: crate::base::MacAddress,
+    pub if_type: u8,
+    pub mac_address_changeable: crate::base::Boolean,
+    pub multiple_tx_supported: crate::base::Boolean,
+    pub media_present_supported: crate::base::Boolean,
+    pub media_present: crate::base::Boolean,
+}
+
+pub type State = u32;
+
+pub const STOPPED: State = 0x00000000;
+pub const STARTED: State = 0x00000001;
+pub const INITIALIZED: State = 0x00000002;
+pub const MAX_STATE: State = 0x00000003;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Statistics {
+    pub rx_total_frames: u64,
+    pub rx_good_frames: u64,
+    pub rx_undersize_frames: u64,
+    pub rx_oversize_frames: u64,
+    pub rx_dropped_frames: u64,
+    pub rx_unicast_frames: u64,
+    pub rx_broadcast_frames: u64,
+    pub rx_multicast_frames: u64,
+    pub rx_crc_error_frames: u64,
+    pub rx_total_bytes: u64,
+    pub tx_total_frames: u64,
+    pub tx_good_frames: u64,
+    pub tx_undersize_frames: u64,
+    pub tx_oversize_frames: u64,
+    pub tx_dropped_frames: u64,
+    pub tx_unicast_frames: u64,
+    pub tx_broadcast_frames: u64,
+    pub tx_multicast_frames: u64,
+    pub tx_crc_error_frames: u64,
+    pub tx_total_bytes: u64,
+    pub collisions: u64,
+    pub unsupported_protocol: u64,
+    pub rx_duplicated_frames: u64,
+    pub rx_decrypt_error_frames: u64,
+    pub tx_error_frames: u64,
+    pub tx_retry_frames: u64,
+}
+
+pub type ProtocolStart = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolStop = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolInitialize = eficall! {fn(
+    *mut Protocol,
+    usize,
+    usize,
+) -> crate::base::Status};
+
+pub type ProtocolReset = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type ProtocolShutdown = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolReceiveFilters = eficall! {fn(
+    *mut Protocol,
+    u32,
+    u32,
+    crate::base::Boolean,
+    usize,
+    *mut crate::base::MacAddress,
+) -> crate::base::Status};
+
+pub type ProtocolStationAddress = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::MacAddress,
+) -> crate::base::Status};
+
+pub type ProtocolStatistics = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut usize,
+    *mut Statistics,
+) -> crate::base::Status};
+
+pub type ProtocolMcastIpToMac = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::IpAddress,
+    *mut crate::base::MacAddress,
+) -> crate::base::Status};
+
+pub type ProtocolNvData = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    usize,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolGetStatus = eficall! {fn(
+    *mut Protocol,
+    *mut u32,
+    *mut *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolTransmit = eficall! {fn(
+    *mut Protocol,
+    usize,
+    usize,
+    *mut core::ffi::c_void,
+    *mut crate::base::MacAddress,
+    *mut crate::base::MacAddress,
+    *mut u16,
+) -> crate::base::Status};
+
+pub type ProtocolReceive = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+    *mut usize,
+    *mut core::ffi::c_void,
+    *mut crate::base::MacAddress,
+    *mut crate::base::MacAddress,
+    *mut u16,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub revision: u64,
+    pub start: ProtocolStart,
+    pub stop: ProtocolStop,
+    pub initialize: ProtocolInitialize,
+    pub reset: ProtocolReset,
+    pub shutdown: ProtocolShutdown,
+    pub receive_filters: ProtocolReceiveFilters,
+    pub station_address: ProtocolStationAddress,
+    pub statistics: ProtocolStatistics,
+    pub mcast_ip_to_mac: ProtocolMcastIpToMac,
+    pub nv_data: ProtocolNvData,
+    pub get_status: ProtocolGetStatus,
+    pub transmit: ProtocolTransmit,
+    pub receive: ProtocolReceive,
+    pub wait_for_packet: crate::base::Event,
+    pub mode: *mut Mode,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/simple_text_input.rs

@@ -0,0 +1,38 @@
+//! Simple Text Input Protocol
+//!
+//! The simple-text-input protocol defines how to read basic key-strokes. It is limited to
+//! non-modifiers and lacks any detailed reporting. It is mostly useful for debugging and admin
+//! interaction.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x387477c1,
+    0x69c7,
+    0x11d2,
+    0x8e,
+    0x39,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct InputKey {
+    pub scan_code: u16,
+    pub unicode_char: crate::base::Char16,
+}
+
+pub type ProtocolReset = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type ProtocolReadKeyStroke = eficall! {fn(
+    *mut Protocol,
+    *mut InputKey,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub reset: ProtocolReset,
+    pub read_key_stroke: ProtocolReadKeyStroke,
+    pub wait_for_key: crate::base::Event,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/simple_text_input_ex.rs

@@ -0,0 +1,85 @@
+//! Extended Simple Text Input Protocol
+//!
+//! The simple-text-input-ex protocol extends the simple-text-input protocol by allowing more
+//! details reporting about modifiers, etc.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xdd9e7534,
+    0x7762,
+    0x4698,
+    0x8c,
+    0x14,
+    &[0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa],
+);
+
+pub const SHIFT_STATE_VALID: u32 = 0x80000000u32;
+pub const RIGHT_SHIFT_PRESSED: u32 = 0x00000001u32;
+pub const LEFT_SHIFT_PRESSED: u32 = 0x00000002u32;
+pub const RIGHT_CONTROL_PRESSED: u32 = 0x00000004u32;
+pub const LEFT_CONTROL_PRESSED: u32 = 0x00000008u32;
+pub const RIGHT_ALT_PRESSED: u32 = 0x00000010u32;
+pub const LEFT_ALT_PRESSED: u32 = 0x00000020u32;
+pub const RIGHT_LOGO_PRESSED: u32 = 0x00000040u32;
+pub const LEFT_LOGO_PRESSED: u32 = 0x00000080u32;
+pub const MENU_KEY_PRESSED: u32 = 0x00000100u32;
+pub const SYS_REQ_PRESSED: u32 = 0x00000200u32;
+
+pub const TOGGLE_STATE_VALID: u8 = 0x80u8;
+pub const KEY_STATE_EXPOSED: u8 = 0x40u8;
+pub const SCROLL_LOCK_ACTIVE: u8 = 0x01u8;
+pub const NUM_LOCK_ACTIVE: u8 = 0x02u8;
+pub const CAPS_LOCK_ACTIVE: u8 = 0x04u8;
+
+pub type KeyToggleState = u8;
+pub type KeyNotifyFunction = eficall! {fn(*mut KeyData) -> crate::base::Status};
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct KeyState {
+    pub key_shift_state: u32,
+    pub key_toggle_state: KeyToggleState,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct KeyData {
+    pub key: crate::protocols::simple_text_input::InputKey,
+    pub key_state: KeyState,
+}
+
+pub type ProtocolReset = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type ProtocolReadKeyStrokeEx = eficall! {fn(
+    *mut Protocol,
+    *mut KeyData,
+) -> crate::base::Status};
+
+pub type ProtocolSetState = eficall! {fn(
+    *mut Protocol,
+    *mut KeyToggleState,
+) -> crate::base::Status};
+
+pub type ProtocolRegisterKeyNotify = eficall! {fn(
+    *mut Protocol,
+    *mut KeyData,
+    KeyNotifyFunction,
+    *mut *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolUnregisterKeyNotify = eficall! {fn(
+    *mut Protocol,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub reset: ProtocolReset,
+    pub read_key_stroke_ex: ProtocolReadKeyStrokeEx,
+    pub wait_for_key_ex: crate::base::Event,
+    pub set_state: ProtocolSetState,
+    pub register_key_notify: ProtocolRegisterKeyNotify,
+    pub unregister_key_notify: ProtocolUnregisterKeyNotify,
+}