1pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
6 0x65530bc7,
7 0xa359,
8 0x410f,
9 0xb0,
10 0x10,
11 &[0x5a, 0xad, 0xc7, 0xec, 0x2b, 0x62],
12);
13
14pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
15 0x00720665,
16 0x67eb,
17 0x4a99,
18 0xba,
19 0xf7,
20 &[0xd3, 0xc3, 0x3a, 0x1c, 0x7c, 0xc9],
21);
22
23pub type ConnectionState = u32;
24
25pub const STATE_CLOSED: ConnectionState = 0x00000000;
26pub const STATE_LISTEN: ConnectionState = 0x00000001;
27pub const STATE_SYN_SENT: ConnectionState = 0x00000002;
28pub const STATE_SYN_RECEIVED: ConnectionState = 0x00000003;
29pub const STATE_ESTABLISHED: ConnectionState = 0x00000004;
30pub const STATE_FIN_WAIT1: ConnectionState = 0x00000005;
31pub const STATE_FIN_WAIT2: ConnectionState = 0x00000006;
32pub const STATE_CLOSING: ConnectionState = 0x00000007;
33pub const STATE_TIME_WAIT: ConnectionState = 0x00000008;
34pub const STATE_CLOSE_WAIT: ConnectionState = 0x00000009;
35pub const STATE_LAST_ACK: ConnectionState = 0x0000000a;
36
37#[repr(C)]
38#[derive(Clone, Copy, Debug)]
39pub struct ConfigData {
40 pub type_of_service: u8,
41 pub time_to_live: u8,
42 pub access_point: AccessPoint,
43 pub control_option: *mut r#Option,
44}
45
46impl Default for ConfigData {
47 fn default() -> Self {
48 Self {
49 type_of_service: Default::default(),
50 time_to_live: Default::default(),
51 access_point: Default::default(),
52 control_option: core::ptr::null_mut(),
53 }
54 }
55}
56
57#[repr(C)]
58#[derive(Clone, Copy, Debug, Default)]
59pub struct AccessPoint {
60 pub use_default_address: crate::base::Boolean,
61 pub station_address: crate::base::Ipv4Address,
62 pub subnet_mask: crate::base::Ipv4Address,
63 pub station_port: u16,
64 pub remote_address: crate::base::Ipv4Address,
65 pub remote_port: u16,
66 pub active_flag: crate::base::Boolean,
67}
68
69#[repr(C)]
70#[derive(Clone, Copy, Debug)]
71pub struct r#Option {
72 pub receive_buffer_size: u32,
73 pub send_buffer_size: u32,
74 pub max_syn_back_log: u32,
75 pub connection_timeout: u32,
76 pub data_retries: u32,
77 pub fin_timeout: u32,
78 pub time_wait_timeout: u32,
79 pub keep_alive_probes: u32,
80 pub keep_alive_time: u32,
81 pub keep_alive_interval: u32,
82 pub enable_nagle: crate::base::Boolean,
83 pub enable_time_stamp: crate::base::Boolean,
84 pub enable_window_scaling: crate::base::Boolean,
85 pub enable_selective_ack: crate::base::Boolean,
86 pub enable_path_mtu_discovery: crate::base::Boolean,
87}
88
89#[repr(C)]
90#[derive(Clone, Copy, Debug)]
91pub struct CompletionToken {
92 pub event: crate::base::Event,
93 pub status: crate::base::Status,
94}
95
96#[repr(C)]
97#[derive(Clone, Copy, Debug)]
98pub struct ConnectionToken {
99 pub completion_token: CompletionToken,
100}
101
102#[repr(C)]
103#[derive(Clone, Copy, Debug)]
104pub struct ListenToken {
105 pub completion_token: CompletionToken,
106 pub new_child_handle: crate::base::Handle,
107}
108
109#[repr(C)]
110#[derive(Clone, Copy)]
111pub struct IoToken {
112 pub completion_token: CompletionToken,
113 pub packet: IoTokenPacket,
114}
115
116#[repr(C)]
117#[derive(Clone, Copy)]
118pub union IoTokenPacket {
119 pub rx_data: *mut ReceiveData,
120 pub tx_data: *mut TransmitData,
121}
122
123#[repr(C)]
124#[derive(Clone, Copy, Debug)]
125pub struct ReceiveData<const N: usize = 0> {
126 pub urgent_flag: crate::base::Boolean,
127 pub data_length: u32,
128 pub fragment_count: u32,
129 pub fragment_table: [FragmentData; N],
130}
131
132#[repr(C)]
133#[derive(Clone, Copy, Debug)]
134pub struct FragmentData {
135 pub fragment_length: u32,
136 pub fragment_buffer: *mut core::ffi::c_void,
137}
138
139#[repr(C)]
140#[derive(Clone, Copy, Debug)]
141pub struct TransmitData<const N: usize = 0> {
142 pub push: crate::base::Boolean,
143 pub urgent: crate::base::Boolean,
144 pub data_length: u32,
145 pub fragment_count: u32,
146 pub fragment_table: [FragmentData; N],
147}
148
149#[repr(C)]
150#[derive(Clone, Copy, Debug)]
151pub struct CloseToken {
152 pub completion_token: CompletionToken,
153 pub abort_on_close: crate::base::Boolean,
154}
155
156pub type ProtocolGetModeData = eficall! {fn(
157 *mut Protocol,
158 *mut ConnectionState,
159 *mut ConfigData,
160 *mut crate::protocols::ip4::ModeData,
161 *mut crate::protocols::managed_network::ConfigData,
162 *mut crate::protocols::simple_network::Mode,
163) -> crate::base::Status};
164
165pub type ProtocolConfigure = eficall! {fn(
166 *mut Protocol,
167 *mut ConfigData,
168) -> crate::base::Status};
169
170pub type ProtocolRoutes = eficall! {fn(
171 *mut Protocol,
172 crate::base::Boolean,
173 *mut crate::base::Ipv4Address,
174 *mut crate::base::Ipv4Address,
175 *mut crate::base::Ipv4Address,
176) -> crate::base::Status};
177
178pub type ProtocolConnect = eficall! {fn(
179 *mut Protocol,
180 *mut ConnectionToken,
181) -> crate::base::Status};
182
183pub type ProtocolAccept = eficall! {fn(
184 *mut Protocol,
185 *mut ListenToken,
186) -> crate::base::Status};
187
188pub type ProtocolTransmit = eficall! {fn(
189 *mut Protocol,
190 *mut IoToken,
191) -> crate::base::Status};
192
193pub type ProtocolReceive = eficall! {fn(
194 *mut Protocol,
195 *mut IoToken,
196) -> crate::base::Status};
197
198pub type ProtocolClose = eficall! {fn(
199 *mut Protocol,
200 *mut CloseToken,
201) -> crate::base::Status};
202
203pub type ProtocolCancel = eficall! {fn(
204 *mut Protocol,
205 *mut CompletionToken,
206) -> crate::base::Status};
207
208pub type ProtocolPoll = eficall! {fn(
209 *mut Protocol,
210) -> crate::base::Status};
211
212#[repr(C)]
213pub struct Protocol {
214 pub get_mode_data: ProtocolGetModeData,
215 pub configure: ProtocolConfigure,
216 pub routes: ProtocolRoutes,
217 pub connect: ProtocolConnect,
218 pub accept: ProtocolAccept,
219 pub transmit: ProtocolTransmit,
220 pub receive: ProtocolReceive,
221 pub close: ProtocolClose,
222 pub cancel: ProtocolCancel,
223 pub poll: ProtocolPoll,
224}