html-to-markdown 2.27.2 → 2.28.0

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

@@ -0,0 +1,86 @@
+//! Simple Text Output Protocol
+//!
+//! The simple-text-output protocol provides a simple way to print text on screen. It is modeled
+//! around the old VGA-consoles, but does not carry all the old cruft. It expects a rectangular
+//! text array and allows you to move the cursor around to write Unicode symbols to screen.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x387477c2,
+    0x69c7,
+    0x11d2,
+    0x8e,
+    0x39,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Mode {
+    pub max_mode: i32,
+    pub mode: i32,
+    pub attribute: i32,
+    pub cursor_column: i32,
+    pub cursor_row: i32,
+    pub cursor_visible: crate::base::Boolean,
+}
+
+pub type ProtocolReset = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type ProtocolOutputString = eficall! {fn(
+    *mut Protocol,
+    *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type ProtocolTestString = eficall! {fn(
+    *mut Protocol,
+    *mut crate::base::Char16,
+) -> crate::base::Status};
+
+pub type ProtocolQueryMode = eficall! {fn(
+    *mut Protocol,
+    usize,
+    *mut usize,
+    *mut usize,
+) -> crate::base::Status};
+
+pub type ProtocolSetMode = eficall! {fn(
+    *mut Protocol,
+    usize,
+) -> crate::base::Status};
+
+pub type ProtocolSetAttribute = eficall! {fn(
+    *mut Protocol,
+    usize,
+) -> crate::base::Status};
+
+pub type ProtocolClearScreen = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolSetCursorPosition = eficall! {fn(
+    *mut Protocol,
+    usize,
+    usize,
+) -> crate::base::Status};
+
+pub type ProtocolEnableCursor = eficall! {fn(
+    *mut Protocol,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub reset: ProtocolReset,
+    pub output_string: ProtocolOutputString,
+    pub test_string: ProtocolTestString,
+    pub query_mode: ProtocolQueryMode,
+    pub set_mode: ProtocolSetMode,
+    pub set_attribute: ProtocolSetAttribute,
+    pub clear_screen: ProtocolClearScreen,
+    pub set_cursor_position: ProtocolSetCursorPosition,
+    pub enable_cursor: ProtocolEnableCursor,
+    pub mode: *mut Mode,
+}

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

@@ -0,0 +1,224 @@
+//! Transmission Control Protocol version 4
+//!
+//! It provides services to send and receive data streams.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x65530bc7,
+    0xa359,
+    0x410f,
+    0xb0,
+    0x10,
+    &[0x5a, 0xad, 0xc7, 0xec, 0x2b, 0x62],
+);
+
+pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x00720665,
+    0x67eb,
+    0x4a99,
+    0xba,
+    0xf7,
+    &[0xd3, 0xc3, 0x3a, 0x1c, 0x7c, 0xc9],
+);
+
+pub type ConnectionState = u32;
+
+pub const STATE_CLOSED: ConnectionState = 0x00000000;
+pub const STATE_LISTEN: ConnectionState = 0x00000001;
+pub const STATE_SYN_SENT: ConnectionState = 0x00000002;
+pub const STATE_SYN_RECEIVED: ConnectionState = 0x00000003;
+pub const STATE_ESTABLISHED: ConnectionState = 0x00000004;
+pub const STATE_FIN_WAIT1: ConnectionState = 0x00000005;
+pub const STATE_FIN_WAIT2: ConnectionState = 0x00000006;
+pub const STATE_CLOSING: ConnectionState = 0x00000007;
+pub const STATE_TIME_WAIT: ConnectionState = 0x00000008;
+pub const STATE_CLOSE_WAIT: ConnectionState = 0x00000009;
+pub const STATE_LAST_ACK: ConnectionState = 0x0000000a;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigData {
+    pub type_of_service: u8,
+    pub time_to_live: u8,
+    pub access_point: AccessPoint,
+    pub control_option: *mut r#Option,
+}
+
+impl Default for ConfigData {
+    fn default() -> Self {
+        Self {
+            type_of_service: Default::default(),
+            time_to_live: Default::default(),
+            access_point: Default::default(),
+            control_option: core::ptr::null_mut(),
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct AccessPoint {
+    pub use_default_address: crate::base::Boolean,
+    pub station_address: crate::base::Ipv4Address,
+    pub subnet_mask: crate::base::Ipv4Address,
+    pub station_port: u16,
+    pub remote_address: crate::base::Ipv4Address,
+    pub remote_port: u16,
+    pub active_flag: crate::base::Boolean,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct r#Option {
+    pub receive_buffer_size: u32,
+    pub send_buffer_size: u32,
+    pub max_syn_back_log: u32,
+    pub connection_timeout: u32,
+    pub data_retries: u32,
+    pub fin_timeout: u32,
+    pub time_wait_timeout: u32,
+    pub keep_alive_probes: u32,
+    pub keep_alive_time: u32,
+    pub keep_alive_interval: u32,
+    pub enable_nagle: crate::base::Boolean,
+    pub enable_time_stamp: crate::base::Boolean,
+    pub enable_window_scaling: crate::base::Boolean,
+    pub enable_selective_ack: crate::base::Boolean,
+    pub enable_path_mtu_discovery: crate::base::Boolean,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct CompletionToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConnectionToken {
+    pub completion_token: CompletionToken,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ListenToken {
+    pub completion_token: CompletionToken,
+    pub new_child_handle: crate::base::Handle,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct IoToken {
+    pub completion_token: CompletionToken,
+    pub packet: IoTokenPacket,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union IoTokenPacket {
+    pub rx_data: *mut ReceiveData,
+    pub tx_data: *mut TransmitData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ReceiveData<const N: usize = 0> {
+    pub urgent_flag: crate::base::Boolean,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    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,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct TransmitData<const N: usize = 0> {
+    pub push: crate::base::Boolean,
+    pub urgent: crate::base::Boolean,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct CloseToken {
+    pub completion_token: CompletionToken,
+    pub abort_on_close: crate::base::Boolean,
+}
+
+pub type ProtocolGetModeData = eficall! {fn(
+    *mut Protocol,
+    *mut ConnectionState,
+    *mut ConfigData,
+    *mut crate::protocols::ip4::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 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 ProtocolConnect = eficall! {fn(
+    *mut Protocol,
+    *mut ConnectionToken,
+) -> crate::base::Status};
+
+pub type ProtocolAccept = eficall! {fn(
+    *mut Protocol,
+    *mut ListenToken,
+) -> crate::base::Status};
+
+pub type ProtocolTransmit = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolReceive = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolClose = eficall! {fn(
+    *mut Protocol,
+    *mut CloseToken,
+) -> 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 routes: ProtocolRoutes,
+    pub connect: ProtocolConnect,
+    pub accept: ProtocolAccept,
+    pub transmit: ProtocolTransmit,
+    pub receive: ProtocolReceive,
+    pub close: ProtocolClose,
+    pub cancel: ProtocolCancel,
+    pub poll: ProtocolPoll,
+}

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

@@ -0,0 +1,202 @@
+//! Transmission Control Protocol version 6
+//!
+//! It provides services to send and receive data streams.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x46e44855,
+    0xbd60,
+    0x4ab7,
+    0xab,
+    0x0d,
+    &[0xa6, 0x79, 0xb9, 0x44, 0x7d, 0x77],
+);
+
+pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xec20eb79,
+    0x6c1a,
+    0x4664,
+    0x9a,
+    0x0d,
+    &[0xd2, 0xe4, 0xcc, 0x16, 0xd6, 0x64],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct AccessPoint {
+    pub station_address: crate::base::Ipv6Address,
+    pub station_port: u16,
+    pub remote_address: crate::base::Ipv6Address,
+    pub remote_port: u16,
+    pub active_flag: crate::base::Boolean,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct r#Option {
+    pub receive_buffer_size: u32,
+    pub send_buffer_size: u32,
+    pub max_syn_back_log: u32,
+    pub connection_timeout: u32,
+    pub data_retries: u32,
+    pub fin_timeout: u32,
+    pub time_wait_timeout: u32,
+    pub keep_alive_probes: u32,
+    pub keep_alive_time: u32,
+    pub keep_alive_interval: u32,
+    pub enable_nagle: crate::base::Boolean,
+    pub enable_time_stamp: crate::base::Boolean,
+    pub enable_window_scaling: crate::base::Boolean,
+    pub enable_selective_ack: crate::base::Boolean,
+    pub enable_path_mtu_discovery: crate::base::Boolean,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigData {
+    pub traffic_class: u8,
+    pub hop_limit: u8,
+    pub access_point: AccessPoint,
+    pub control_option: *mut r#Option,
+}
+
+pub type ConnectionState = u32;
+
+pub const STATE_CLOSED: ConnectionState = 0x00000000;
+pub const STATE_LISTEN: ConnectionState = 0x00000001;
+pub const STATE_SYN_SENT: ConnectionState = 0x00000002;
+pub const STATE_SYN_RECEIVED: ConnectionState = 0x00000003;
+pub const STATE_ESTABLISHED: ConnectionState = 0x00000004;
+pub const STATE_FIN_WAIT1: ConnectionState = 0x00000005;
+pub const STATE_FIN_WAIT2: ConnectionState = 0x00000006;
+pub const STATE_CLOSING: ConnectionState = 0x00000007;
+pub const STATE_TIME_WAIT: ConnectionState = 0x00000008;
+pub const STATE_CLOSE_WAIT: ConnectionState = 0x00000009;
+pub const STATE_LAST_ACK: ConnectionState = 0x0000000a;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct CompletionToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConnectionToken {
+    pub completion_token: CompletionToken,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ListenToken {
+    pub completion_token: CompletionToken,
+    pub new_child_handle: crate::base::Handle,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct IoToken {
+    pub completion_token: CompletionToken,
+    pub packet: IoTokenPacket,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union IoTokenPacket {
+    pub rx_data: *mut ReceiveData,
+    pub tx_data: *mut TransmitData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ReceiveData<const N: usize = 0> {
+    pub urgent_flag: crate::base::Boolean,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    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,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct TransmitData<const N: usize = 0> {
+    pub push: crate::base::Boolean,
+    pub urgent: crate::base::Boolean,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct CloseToken {
+    pub completion_token: CompletionToken,
+    pub abort_on_close: crate::base::Boolean,
+}
+
+pub type ProtocolGetModeData = eficall! {fn(
+    *mut Protocol,
+    *mut ConnectionState,
+    *mut ConfigData,
+    *mut crate::protocols::ip6::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 ProtocolConnect = eficall! {fn(
+    *mut Protocol,
+    *mut ConnectionToken,
+) -> crate::base::Status};
+
+pub type ProtocolAccept = eficall! {fn(
+    *mut Protocol,
+    *mut ListenToken,
+) -> crate::base::Status};
+
+pub type ProtocolTransmit = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolReceive = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolClose = eficall! {fn(
+    *mut Protocol,
+    *mut CloseToken,
+) -> 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 connect: ProtocolConnect,
+    pub accept: ProtocolAccept,
+    pub transmit: ProtocolTransmit,
+    pub receive: ProtocolReceive,
+    pub close: ProtocolClose,
+    pub cancel: ProtocolCancel,
+    pub poll: ProtocolPoll,
+}

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

@@ -0,0 +1,32 @@
+//! EFI Timestamp Protocol
+//!
+//! The Timestamp protocol provides a platform independent interface for
+//! retrieving a high resolution timestamp counter.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xafbfde41,
+    0x2e6e,
+    0x4262,
+    0xba,
+    0x65,
+    &[0x62, 0xb9, 0x23, 0x6e, 0x54, 0x95],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Properties {
+    pub frequency: u64,
+    pub end_value: u64,
+}
+
+pub type ProtocolGetTimestamp = eficall! {fn() -> u64};
+
+pub type ProtocolGetProperties = eficall! {fn(
+    *mut Properties,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_timestamp: ProtocolGetTimestamp,
+    pub get_properties: ProtocolGetProperties,
+}

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

@@ -0,0 +1,151 @@
+//! User Datagram Protocol V4
+//!
+//! It provides simple packet-oriented services to transmit and receive UDP packets.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x3ad9df29,
+    0x4501,
+    0x478d,
+    0xb1,
+    0xf8,
+    &[0x7f, 0x7f, 0xe7, 0x0e, 0x50, 0xf3],
+);
+
+pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x83f01464,
+    0x99bd,
+    0x45e5,
+    0xb3,
+    0x83,
+    &[0xaf, 0x63, 0x05, 0xd8, 0xe9, 0xe6],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct ConfigData {
+    pub accept_broadcast: crate::base::Boolean,
+    pub accept_promiscuous: crate::base::Boolean,
+    pub accept_any_port: crate::base::Boolean,
+    pub allow_duplicate_port: crate::base::Boolean,
+    pub type_of_service: u8,
+    pub time_to_live: u8,
+    pub do_not_fragment: crate::base::Boolean,
+    pub receive_timeout: u32,
+    pub transmit_timeout: u32,
+    pub use_default_address: crate::base::Boolean,
+    pub station_address: crate::base::Ipv4Address,
+    pub subnet_mask: crate::base::Ipv4Address,
+    pub station_port: u16,
+    pub remote_address: crate::base::Ipv4Address,
+    pub remote_port: u16,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct SessionData {
+    pub source_address: crate::base::Ipv4Address,
+    pub source_port: u16,
+    pub destination_address: crate::base::Ipv4Address,
+    pub destination_port: u16,
+}
+
+#[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)]
+pub struct ReceiveData<const N: usize = 0> {
+    pub time_stamp: crate::system::Time,
+    pub recycle_signal: crate::base::Event,
+    pub udp_session: SessionData,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct TransmitData<const N: usize = 0> {
+    pub udp_session_data: *mut SessionData,
+    pub gateway_address: *mut crate::base::Ipv4Address,
+    pub data_length: u32,
+    pub fragment_count: u32,
+    pub fragment_table: [FragmentData; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union CompletionTokenPacket {
+    pub rx_data: *mut ReceiveData,
+    pub tx_data: *mut TransmitData,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CompletionToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+    pub packet: CompletionTokenPacket,
+}
+
+pub type ProtocolGetModeData = eficall! {fn(
+    *mut Protocol,
+    *mut ConfigData,
+    *mut crate::protocols::ip4::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,
+}