Debian Codegraph @

.cargo/vendor/r-efi/src/protocols/tcp6.rs

raw
1 //! Transmission Control Protocol version 6
2 //!
3 //! It provides services to send and receive data streams.
4
5 pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
6 0x46e44855,
7 0xbd60,
8 0x4ab7,
9 0xab,
10 0x0d,
11 &[0xa6, 0x79, 0xb9, 0x44, 0x7d, 0x77],
12 );
13
14 pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
15 0xec20eb79,
16 0x6c1a,
17 0x4664,
18 0x9a,
19 0x0d,
20 &[0xd2, 0xe4, 0xcc, 0x16, 0xd6, 0x64],
21 );
22
23 #[repr(C)]
24 #[derive(Clone, Copy, Debug)]
25 pub struct AccessPoint {
26 pub station_address: crate::base::Ipv6Address,
27 pub station_port: u16,
28 pub remote_address: crate::base::Ipv6Address,
29 pub remote_port: u16,
30 pub active_flag: crate::base::Boolean,
31 }
32
33 #[repr(C)]
34 #[derive(Clone, Copy, Debug)]
35 pub struct r#Option {
36 pub receive_buffer_size: u32,
37 pub send_buffer_size: u32,
38 pub max_syn_back_log: u32,
39 pub connection_timeout: u32,
40 pub data_retries: u32,
41 pub fin_timeout: u32,
42 pub time_wait_timeout: u32,
43 pub keep_alive_probes: u32,
44 pub keep_alive_time: u32,
45 pub keep_alive_interval: u32,
46 pub enable_nagle: crate::base::Boolean,
47 pub enable_time_stamp: crate::base::Boolean,
48 pub enable_window_scaling: crate::base::Boolean,
49 pub enable_selective_ack: crate::base::Boolean,
50 pub enable_path_mtu_discovery: crate::base::Boolean,
51 }
52
53 #[repr(C)]
54 #[derive(Clone, Copy, Debug)]
55 pub struct ConfigData {
56 pub traffic_class: u8,
57 pub hop_limit: u8,
58 pub access_point: AccessPoint,
59 pub control_option: *mut r#Option,
60 }
61
62 pub type ConnectionState = u32;
63
64 pub const STATE_CLOSED: ConnectionState = 0x00000000;
65 pub const STATE_LISTEN: ConnectionState = 0x00000001;
66 pub const STATE_SYN_SENT: ConnectionState = 0x00000002;
67 pub const STATE_SYN_RECEIVED: ConnectionState = 0x00000003;
68 pub const STATE_ESTABLISHED: ConnectionState = 0x00000004;
69 pub const STATE_FIN_WAIT1: ConnectionState = 0x00000005;
70 pub const STATE_FIN_WAIT2: ConnectionState = 0x00000006;
71 pub const STATE_CLOSING: ConnectionState = 0x00000007;
72 pub const STATE_TIME_WAIT: ConnectionState = 0x00000008;
73 pub const STATE_CLOSE_WAIT: ConnectionState = 0x00000009;
74 pub const STATE_LAST_ACK: ConnectionState = 0x0000000a;
75
76 #[repr(C)]
77 #[derive(Clone, Copy, Debug)]
78 pub struct CompletionToken {
79 pub event: crate::base::Event,
80 pub status: crate::base::Status,
81 }
82
83 #[repr(C)]
84 #[derive(Clone, Copy, Debug)]
85 pub struct ConnectionToken {
86 pub completion_token: CompletionToken,
87 }
88
89 #[repr(C)]
90 #[derive(Clone, Copy, Debug)]
91 pub struct ListenToken {
92 pub completion_token: CompletionToken,
93 pub new_child_handle: crate::base::Handle,
94 }
95
96 #[repr(C)]
97 #[derive(Clone, Copy)]
98 pub struct IoToken {
99 pub completion_token: CompletionToken,
100 pub packet: IoTokenPacket,
101 }
102
103 #[repr(C)]
104 #[derive(Clone, Copy)]
105 pub union IoTokenPacket {
106 pub rx_data: *mut ReceiveData,
107 pub tx_data: *mut TransmitData,
108 }
109
110 #[repr(C)]
111 #[derive(Clone, Copy, Debug)]
112 pub struct ReceiveData<const N: usize = 0> {
113 pub urgent_flag: crate::base::Boolean,
114 pub data_length: u32,
115 pub fragment_count: u32,
116 pub fragment_table: [FragmentData; N],
117 }
118
119 #[repr(C)]
120 #[derive(Clone, Copy, Debug)]
121 pub struct FragmentData {
122 pub fragment_length: u32,
123 pub fragment_buffer: *mut core::ffi::c_void,
124 }
125
126 #[repr(C)]
127 #[derive(Clone, Copy, Debug)]
128 pub struct TransmitData<const N: usize = 0> {
129 pub push: crate::base::Boolean,
130 pub urgent: crate::base::Boolean,
131 pub data_length: u32,
132 pub fragment_count: u32,
133 pub fragment_table: [FragmentData; N],
134 }
135
136 #[repr(C)]
137 #[derive(Clone, Copy, Debug)]
138 pub struct CloseToken {
139 pub completion_token: CompletionToken,
140 pub abort_on_close: crate::base::Boolean,
141 }
142
143 pub type ProtocolGetModeData = eficall! {fn(
144 *mut Protocol,
145 *mut ConnectionState,
146 *mut ConfigData,
147 *mut crate::protocols::ip6::ModeData,
148 *mut crate::protocols::managed_network::ConfigData,
149 *mut crate::protocols::simple_network::Mode,
150 ) -> crate::base::Status};
151
152 pub type ProtocolConfigure = eficall! {fn(
153 *mut Protocol,
154 *mut ConfigData,
155 ) -> crate::base::Status};
156
157 pub type ProtocolConnect = eficall! {fn(
158 *mut Protocol,
159 *mut ConnectionToken,
160 ) -> crate::base::Status};
161
162 pub type ProtocolAccept = eficall! {fn(
163 *mut Protocol,
164 *mut ListenToken,
165 ) -> crate::base::Status};
166
167 pub type ProtocolTransmit = eficall! {fn(
168 *mut Protocol,
169 *mut IoToken,
170 ) -> crate::base::Status};
171
172 pub type ProtocolReceive = eficall! {fn(
173 *mut Protocol,
174 *mut IoToken,
175 ) -> crate::base::Status};
176
177 pub type ProtocolClose = eficall! {fn(
178 *mut Protocol,
179 *mut CloseToken,
180 ) -> crate::base::Status};
181
182 pub type ProtocolCancel = eficall! {fn(
183 *mut Protocol,
184 *mut CompletionToken,
185 ) -> crate::base::Status};
186
187 pub type ProtocolPoll = eficall! {fn(
188 *mut Protocol,
189 ) -> crate::base::Status};
190
191 #[repr(C)]
192 pub struct Protocol {
193 pub get_mode_data: ProtocolGetModeData,
194 pub configure: ProtocolConfigure,
195 pub connect: ProtocolConnect,
196 pub accept: ProtocolAccept,
197 pub transmit: ProtocolTransmit,
198 pub receive: ProtocolReceive,
199 pub close: ProtocolClose,
200 pub cancel: ProtocolCancel,
201 pub poll: ProtocolPoll,
202 }