html-to-markdown 2.27.2 → 2.27.3

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

@@ -0,0 +1,202 @@
+//! IPv4 Protocol
+//!
+//! It implements a simple packet-oriented interface that can be used by
+//! drivers, daemons, and applications to transmit and receive network packets.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x41d94cd2,
+    0x35b6,
+    0x455a,
+    0x82,
+    0x58,
+    &[0xd4, 0xe5, 0x13, 0x34, 0xaa, 0xdd],
+);
+
+pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xc51711e7,
+    0xb4bf,
+    0x404a,
+    0xbf,
+    0xb8,
+    &[0x0a, 0x04, 0x8e, 0xf1, 0xff, 0xe4],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigData {
+    pub default_protocol: u8,
+    pub accept_any_protocol: crate::base::Boolean,
+    pub accept_icmp_errors: crate::base::Boolean,
+    pub accept_broadcast: crate::base::Boolean,
+    pub accept_promiscuous: crate::base::Boolean,
+    pub use_default_address: crate::base::Boolean,
+    pub station_address: crate::base::Ipv4Address,
+    pub subnet_mask: crate::base::Ipv4Address,
+    pub type_of_service: u8,
+    pub time_to_live: u8,
+    pub do_not_fragment: crate::base::Boolean,
+    pub raw_data: crate::base::Boolean,
+    pub receive_timeout: u32,
+    pub transmit_timeout: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct RouteTable {
+    pub subnet_address: crate::base::Ipv4Address,
+    pub subnet_mask: crate::base::Ipv4Address,
+    pub gateway_address: crate::base::Ipv4Address,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct IcmpType {
+    pub r#type: u8,
+    pub code: u8,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ModeData {
+    pub is_started: crate::base::Boolean,
+    pub max_packet_size: u32,
+    pub config_data: ConfigData,
+    pub is_configured: crate::base::Boolean,
+    pub group_count: u32,
+    pub group_table: *mut crate::base::Ipv4Address,
+    pub route_count: u32,
+    pub route_table: *mut RouteTable,
+    pub icmp_type_count: u32,
+    pub icmp_type_list: *mut IcmpType,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CompletionToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+    pub packet: CompletionTokenPacket,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union CompletionTokenPacket {
+    pub rx_data: *mut ReceiveData,
+    pub tx_data: *mut TransmitData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ReceiveData<const N: usize = 0> {
+    pub time_stamp: crate::system::Time,
+    pub recycle_signal: crate::base::Event,
+    pub header_length: u32,
+    pub header: *mut Header,
+    pub options_length: u32,
+    pub options: *mut core::ffi::c_void,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct TransmitData<const N: usize = 0> {
+    pub destination_address: crate::base::Ipv4Address,
+    pub override_data: *mut OverrideData,
+    pub options_length: u32,
+    pub options_buffer: *mut core::ffi::c_void,
+    pub total_data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Header {
+    pub header_length_and_version: u8,
+    pub type_of_service: u8,
+    pub total_length: u16,
+    pub identification: u16,
+    pub fragmentation: u16,
+    pub time_to_live: u8,
+    pub protocol: u8,
+    pub checksum: u16,
+    pub source_address: crate::base::Ipv4Address,
+    pub destination_address: crate::base::Ipv4Address,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct FragmentData {
+    pub fragment_length: u32,
+    pub fragment_buffer: *mut core::ffi::c_void,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct OverrideData {
+    pub source_address: crate::base::Ipv4Address,
+    pub gateway_address: crate::base::Ipv4Address,
+    pub protocol: u8,
+    pub type_of_service: u8,
+    pub time_to_live: u8,
+    pub do_not_fragment: crate::base::Boolean,
+}
+
+pub type ProtocolGetModeData = eficall! {fn(
+    *mut Protocol,
+    *mut ModeData,
+    *mut crate::protocols::managed_network::ConfigData,
+    *mut crate::protocols::simple_network::Mode,
+) -> crate::base::Status};
+
+pub type ProtocolConfigure = eficall! {fn(
+    *mut Protocol,
+    *mut ConfigData,
+) -> crate::base::Status};
+
+pub type ProtocolGroups = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::Ipv4Address,
+) -> crate::base::Status};
+
+pub type ProtocolRoutes = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::Ipv4Address,
+    *mut crate::base::Ipv4Address,
+    *mut crate::base::Ipv4Address,
+) -> crate::base::Status};
+
+pub type ProtocolTransmit = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolReceive = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolCancel = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolPoll = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_mode_data: ProtocolGetModeData,
+    pub configure: ProtocolConfigure,
+    pub groups: ProtocolGroups,
+    pub routes: ProtocolRoutes,
+    pub transmit: ProtocolTransmit,
+    pub receive: ProtocolReceive,
+    pub cancel: ProtocolCancel,
+    pub poll: ProtocolPoll,
+}

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

@@ -0,0 +1,264 @@
+//! IPv6 Protocol
+//!
+//! It implements a simple packet-oriented interface that can be used by
+//! drivers, daemons, and applications to transmit and receive network packets.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x2c8759d5,
+    0x5c2d,
+    0x66ef,
+    0x92,
+    0x5f,
+    &[0xb6, 0x6c, 0x10, 0x19, 0x57, 0xe2],
+);
+
+pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xec835dd3,
+    0xfe0f,
+    0x617b,
+    0xa6,
+    0x21,
+    &[0xb3, 0x50, 0xc3, 0xe1, 0x33, 0x88],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ModeData {
+    pub is_started: crate::base::Boolean,
+    pub max_packet_size: u32,
+    pub config_data: ConfigData,
+    pub is_configured: crate::base::Boolean,
+    pub address_count: u32,
+    pub address_list: *mut AddressInfo,
+    pub group_count: u32,
+    pub group_table: *mut crate::base::Ipv6Address,
+    pub route_count: u32,
+    pub route_table: *mut RouteTable,
+    pub neighbor_count: u32,
+    pub neighbor_cache: *mut NeighborCache,
+    pub prefix_count: u32,
+    pub prefix_table: *mut AddressInfo,
+    pub icmp_type_count: u32,
+    pub icmp_type_list: *mut IcmpType,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigData {
+    pub default_protocol: u8,
+    pub accept_any_protocol: crate::base::Boolean,
+    pub accept_icmp_errors: crate::base::Boolean,
+    pub accept_promiscuous: crate::base::Boolean,
+    pub destination_address: crate::base::Ipv6Address,
+    pub station_address: crate::base::Ipv6Address,
+    pub traffic_class: u8,
+    pub hop_limit: u8,
+    pub flow_lable: u32,
+    pub receive_timeout: u32,
+    pub transmit_timeout: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct AddressInfo {
+    pub address: crate::base::Ipv6Address,
+    pub prefix_length: u8,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct RouteTable {
+    pub gateway: crate::base::Ipv6Address,
+    pub destination: crate::base::Ipv6Address,
+    pub prefix_length: u8,
+}
+
+pub type NeighborState = u32;
+
+pub const NEIGHBOR_IN_COMPLETE: NeighborState = 0x00000000;
+pub const NEIGHBOR_REACHABLE: NeighborState = 0x00000001;
+pub const NEIGHBOR_STATE: NeighborState = 0x00000002;
+pub const NEIGHBOR_DELAY: NeighborState = 0x00000003;
+pub const NEIGHBOR_PROBE: NeighborState = 0x00000004;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct NeighborCache {
+    pub neighbor: crate::base::Ipv6Address,
+    pub link_address: crate::base::MacAddress,
+    pub state: NeighborState,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct IcmpType {
+    pub r#type: u8,
+    pub code: u8,
+}
+
+pub const ICMP_V6_DEST_UNREACHABLE: u8 = 0x01;
+pub const ICMP_V6_PACKET_TOO_BIG: u8 = 0x02;
+pub const ICMP_V6_TIME_EXCEEDED: u8 = 0x03;
+pub const ICMP_V6_PARAMETER_PROBLEM: u8 = 0x04;
+
+pub const ICMP_V6_ECHO_REQUEST: u8 = 0x80;
+pub const ICMP_V6_ECHO_REPLY: u8 = 0x81;
+pub const ICMP_V6_LISTENER_QUERY: u8 = 0x82;
+pub const ICMP_V6_LISTENER_REPORT: u8 = 0x83;
+pub const ICMP_V6_LISTENER_DONE: u8 = 0x84;
+pub const ICMP_V6_ROUTER_SOLICIT: u8 = 0x85;
+pub const ICMP_V6_ROUTER_ADVERTISE: u8 = 0x86;
+pub const ICMP_V6_NEIGHBOR_SOLICIT: u8 = 0x87;
+pub const ICMP_V6_NEIGHBOR_ADVERTISE: u8 = 0x88;
+pub const ICMP_V6_REDIRECT: u8 = 0x89;
+pub const ICMP_V6_LISTENER_REPORT_2: u8 = 0x8f;
+
+pub const ICMP_V6_NO_ROUTE_TO_DEST: u8 = 0x00;
+pub const ICMP_V6_COMM_PROHIBITED: u8 = 0x01;
+pub const ICMP_V6_BEYOND_SCOPE: u8 = 0x02;
+pub const ICMP_V6_ADDR_UNREACHABLE: u8 = 0x03;
+pub const ICMP_V6_PORT_UNREACHABLE: u8 = 0x04;
+pub const ICMP_V6_SOURCE_ADDR_FAILED: u8 = 0x05;
+pub const ICMP_V6_ROUTE_REJECTED: u8 = 0x06;
+
+pub const ICMP_V6_TIMEOUT_HOP_LIMIT: u8 = 0x00;
+pub const ICMP_V6_TIMEOUT_REASSEMBLE: u8 = 0x01;
+
+pub const ICMP_V6_ERRONEOUS_HEADER: u8 = 0x00;
+pub const ICMP_V6_UNRECOGNIZE_NEXT_HDR: u8 = 0x01;
+pub const ICMP_V6_UNRECOGNIZE_OPTION: u8 = 0x02;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CompletionToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+    pub packet: CompletionTokenPacket,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union CompletionTokenPacket {
+    pub rx_data: *mut ReceiveData,
+    pub tx_data: *mut TransmitData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ReceiveData<const N: usize = 0> {
+    pub time_stamp: crate::system::Time,
+    pub recycle_signal: crate::base::Event,
+    pub header_length: u32,
+    pub header: *mut Header,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Header {
+    pub traffic_class_h_version: u8,
+    pub flow_label_h_traffic_class_l: u8,
+    pub flow_label_l: u16,
+    pub payload_length: u16,
+    pub next_header: u8,
+    pub hop_limit: u8,
+    pub source_address: crate::base::Ipv6Address,
+    pub destination_address: crate::base::Ipv6Address,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct FragmentData {
+    pub fragment_length: u32,
+    pub fragment_buffer: *mut core::ffi::c_void,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct TransmitData<const N: usize = 0> {
+    pub destination_address: *mut crate::base::Ipv6Address,
+    pub override_data: *mut OverrideData,
+    pub ext_hdrs_length: u32,
+    pub ext_hdrs: *mut core::ffi::c_void,
+    pub next_header: u8,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct OverrideData {
+    pub protocol: u8,
+    pub hop_limit: u8,
+    pub flow_label: u32,
+}
+
+pub type ProtocolGetModeData = eficall! {fn(
+    *mut Protocol,
+    *mut ModeData,
+    *mut crate::protocols::managed_network::ConfigData,
+    *mut crate::protocols::simple_network::Mode,
+) -> crate::base::Status};
+
+pub type ProtocolConfigure = eficall! {fn(
+    *mut Protocol,
+    *mut ConfigData,
+) -> crate::base::Status};
+
+pub type ProtocolGroups = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::Ipv6Address,
+) -> crate::base::Status};
+
+pub type ProtocolRoutes = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::Ipv6Address,
+    u8,
+    *mut crate::base::Ipv6Address,
+) -> crate::base::Status};
+
+pub type ProtocolNeighbors = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::Ipv6Address,
+    *mut crate::base::MacAddress,
+    u32,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type ProtocolTransmit = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolReceive = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolCancel = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolPoll = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_mode_data: ProtocolGetModeData,
+    pub configure: ProtocolConfigure,
+    pub groups: ProtocolGroups,
+    pub routes: ProtocolRoutes,
+    pub neighbors: ProtocolNeighbors,
+    pub transmit: ProtocolTransmit,
+    pub receive: ProtocolReceive,
+    pub cancel: ProtocolCancel,
+    pub poll: ProtocolPoll,
+}

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

@@ -0,0 +1,26 @@
+//! Load File Protocol
+//!
+//! The Load File protocol is used to obtain files, that are primarily boot
+//! options, from arbitrary devices.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x56ec3091,
+    0x954c,
+    0x11d2,
+    0x8e,
+    0x3f,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+pub type ProtocolLoadFile = eficall! {fn(
+  *mut Protocol,
+  *mut crate::protocols::device_path::Protocol,
+  crate::base::Boolean,
+  *mut usize,
+  *mut core::ffi::c_void
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub load_file: ProtocolLoadFile,
+}

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

@@ -0,0 +1,15 @@
+//! Load File 2 Protocol
+//!
+//! The Load File 2 protocol is used to obtain files from arbitrary devices
+//! that are not boot options.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x4006c0c1,
+    0xfcb3,
+    0x403e,
+    0x99,
+    0x6d,
+    &[0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d],
+);
+
+pub type Protocol = crate::protocols::load_file::Protocol;

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

@@ -0,0 +1,39 @@
+//! Loaded Image Protocol
+//!
+//! The loaded image protocol defines how to obtain information about a loaded image from an
+//! image handle.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x5b1b31a1,
+    0x9562,
+    0x11d2,
+    0x8e,
+    0x3f,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+pub const REVISION: u32 = 0x00001000u32;
+
+pub type ProtocolUnload = eficall! {fn(
+    crate::base::Handle,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub revision: u32,
+    pub parent_handle: crate::base::Handle,
+    pub system_table: *mut crate::system::SystemTable,
+
+    pub device_handle: crate::base::Handle,
+    pub file_path: *mut crate::protocols::device_path::Protocol,
+    pub reserved: *mut core::ffi::c_void,
+
+    pub load_options_size: u32,
+    pub load_options: *mut core::ffi::c_void,
+
+    pub image_base: *mut core::ffi::c_void,
+    pub image_size: u64,
+    pub image_code_type: crate::system::MemoryType,
+    pub image_data_type: crate::system::MemoryType,
+    pub unload: Option<ProtocolUnload>,
+}

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

@@ -0,0 +1,13 @@
+//! Loaded Image Device Path Protocol
+//!
+//! The loaded image device path protocol provides the device path of a loaded image, using the
+//! protocol structures of the device-path and loaded-image protocols.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xbc62157e,
+    0x3e33,
+    0x4fec,
+    0x99,
+    0x20,
+    &[0x2d, 0x3b, 0x36, 0xd7, 0x50, 0xdf],
+);

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

@@ -0,0 +1,147 @@
+//! Managed Network Protocol
+//!
+//! It provides raw (unformatted) asynchronous network packet I/O services.
+//! These services make it possible for multiple-event-driven drivers and
+//! applications to access and use the system network interfaces at the same
+//! time.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x7ab33a91,
+    0xace5,
+    0x4326,
+    0xb5,
+    0x72,
+    &[0xe7, 0xee, 0x33, 0xd3, 0x9f, 0x16],
+);
+
+pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xf36ff770,
+    0xa7e1,
+    0x42cf,
+    0x9e,
+    0xd2,
+    &[0x56, 0xf0, 0xf2, 0x71, 0xf4, 0x4c],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigData {
+    pub received_queue_timeout_value: u32,
+    pub transmit_queue_timeout_value: u32,
+    pub protocol_type_filter: u16,
+    pub enable_unicast_receive: crate::base::Boolean,
+    pub enable_multicast_receive: crate::base::Boolean,
+    pub enable_broadcast_receive: crate::base::Boolean,
+    pub enable_promiscuous_receive: crate::base::Boolean,
+    pub flush_queues_on_reset: crate::base::Boolean,
+    pub enable_receive_timestamps: crate::base::Boolean,
+    pub disable_background_polling: crate::base::Boolean,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CompletionToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+    pub packet: CompletionTokenPacket,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union CompletionTokenPacket {
+    pub rx_data: *mut ReceiveData,
+    pub tx_data: *mut TransmitData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ReceiveData {
+    pub timestamp: crate::system::Time,
+    pub recycle_event: crate::base::Event,
+    pub packet_length: u32,
+    pub header_length: u32,
+    pub address_length: u32,
+    pub data_length: u32,
+    pub broadcast_flag: crate::base::Boolean,
+    pub multicast_flag: crate::base::Boolean,
+    pub promiscuous_flag: crate::base::Boolean,
+    pub protocol_type: u16,
+    pub destination_address: *mut core::ffi::c_void,
+    pub source_address: *mut core::ffi::c_void,
+    pub media_header: *mut core::ffi::c_void,
+    pub packet_data: *mut core::ffi::c_void,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct TransmitData<const N: usize = 0> {
+    pub destination_address: *mut crate::base::MacAddress,
+    pub source_address: *mut crate::base::MacAddress,
+    pub protocol_type: u16,
+    pub data_length: u32,
+    pub header_length: u16,
+    pub fragment_count: u16,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct FragmentData {
+    pub fragment_length: u32,
+    pub fragment_buffer: *mut core::ffi::c_void,
+}
+
+pub type ProtocolGetModeData = eficall! {fn(
+    *mut Protocol,
+    *mut ConfigData,
+    *mut crate::protocols::simple_network::Mode,
+) -> crate::base::Status};
+
+pub type ProtocolConfigure = eficall! {fn(
+    *mut Protocol,
+    *mut ConfigData,
+) -> 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 ProtocolGroups = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+    *mut crate::base::MacAddress,
+) -> crate::base::Status};
+
+pub type ProtocolTransmit = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolReceive = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolCancel = eficall! {fn(
+    *mut Protocol,
+    *mut CompletionToken,
+) -> crate::base::Status};
+
+pub type ProtocolPoll = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_mode_data: ProtocolGetModeData,
+    pub configure: ProtocolConfigure,
+    pub mcast_ip_to_mac: ProtocolMcastIpToMac,
+    pub groups: ProtocolGroups,
+    pub transmit: ProtocolTransmit,
+    pub receive: ProtocolReceive,
+    pub cancel: ProtocolCancel,
+    pub poll: ProtocolPoll,
+}