Debian Codegraph @

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

raw
1 //! IPv4 Protocol
2 //!
3 //! It implements a simple packet-oriented interface that can be used by
4 //! drivers, daemons, and applications to transmit and receive network packets.
5
6 pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
7 0x41d94cd2,
8 0x35b6,
9 0x455a,
10 0x82,
11 0x58,
12 &[0xd4, 0xe5, 0x13, 0x34, 0xaa, 0xdd],
13 );
14
15 pub const SERVICE_BINDING_PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
16 0xc51711e7,
17 0xb4bf,
18 0x404a,
19 0xbf,
20 0xb8,
21 &[0x0a, 0x04, 0x8e, 0xf1, 0xff, 0xe4],
22 );
23
24 #[repr(C)]
25 #[derive(Clone, Copy, Debug)]
26 pub struct ConfigData {
27 pub default_protocol: u8,
28 pub accept_any_protocol: crate::base::Boolean,
29 pub accept_icmp_errors: crate::base::Boolean,
30 pub accept_broadcast: crate::base::Boolean,
31 pub accept_promiscuous: crate::base::Boolean,
32 pub use_default_address: crate::base::Boolean,
33 pub station_address: crate::base::Ipv4Address,
34 pub subnet_mask: crate::base::Ipv4Address,
35 pub type_of_service: u8,
36 pub time_to_live: u8,
37 pub do_not_fragment: crate::base::Boolean,
38 pub raw_data: crate::base::Boolean,
39 pub receive_timeout: u32,
40 pub transmit_timeout: u32,
41 }
42
43 #[repr(C)]
44 #[derive(Clone, Copy, Debug)]
45 pub struct RouteTable {
46 pub subnet_address: crate::base::Ipv4Address,
47 pub subnet_mask: crate::base::Ipv4Address,
48 pub gateway_address: crate::base::Ipv4Address,
49 }
50
51 #[repr(C)]
52 #[derive(Clone, Copy, Debug)]
53 pub struct IcmpType {
54 pub r#type: u8,
55 pub code: u8,
56 }
57
58 #[repr(C)]
59 #[derive(Clone, Copy, Debug)]
60 pub struct ModeData {
61 pub is_started: crate::base::Boolean,
62 pub max_packet_size: u32,
63 pub config_data: ConfigData,
64 pub is_configured: crate::base::Boolean,
65 pub group_count: u32,
66 pub group_table: *mut crate::base::Ipv4Address,
67 pub route_count: u32,
68 pub route_table: *mut RouteTable,
69 pub icmp_type_count: u32,
70 pub icmp_type_list: *mut IcmpType,
71 }
72
73 #[repr(C)]
74 #[derive(Clone, Copy)]
75 pub struct CompletionToken {
76 pub event: crate::base::Event,
77 pub status: crate::base::Status,
78 pub packet: CompletionTokenPacket,
79 }
80
81 #[repr(C)]
82 #[derive(Clone, Copy)]
83 pub union CompletionTokenPacket {
84 pub rx_data: *mut ReceiveData,
85 pub tx_data: *mut TransmitData,
86 }
87
88 #[repr(C)]
89 #[derive(Clone, Copy, Debug)]
90 pub struct ReceiveData<const N: usize = 0> {
91 pub time_stamp: crate::system::Time,
92 pub recycle_signal: crate::base::Event,
93 pub header_length: u32,
94 pub header: *mut Header,
95 pub options_length: u32,
96 pub options: *mut core::ffi::c_void,
97 pub data_length: u32,
98 pub fragment_count: u32,
99 pub fragment_table: [FragmentData; N],
100 }
101
102 #[repr(C)]
103 #[derive(Clone, Copy, Debug)]
104 pub struct TransmitData<const N: usize = 0> {
105 pub destination_address: crate::base::Ipv4Address,
106 pub override_data: *mut OverrideData,
107 pub options_length: u32,
108 pub options_buffer: *mut core::ffi::c_void,
109 pub total_data_length: u32,
110 pub fragment_count: u32,
111 pub fragment_table: [FragmentData; N],
112 }
113
114 #[repr(C)]
115 #[derive(Clone, Copy, Debug)]
116 pub struct Header {
117 pub header_length_and_version: u8,
118 pub type_of_service: u8,
119 pub total_length: u16,
120 pub identification: u16,
121 pub fragmentation: u16,
122 pub time_to_live: u8,
123 pub protocol: u8,
124 pub checksum: u16,
125 pub source_address: crate::base::Ipv4Address,
126 pub destination_address: crate::base::Ipv4Address,
127 }
128
129 #[repr(C)]
130 #[derive(Clone, Copy, Debug)]
131 pub struct FragmentData {
132 pub fragment_length: u32,
133 pub fragment_buffer: *mut core::ffi::c_void,
134 }
135
136 #[repr(C)]
137 #[derive(Clone, Copy, Debug)]
138 pub struct OverrideData {
139 pub source_address: crate::base::Ipv4Address,
140 pub gateway_address: crate::base::Ipv4Address,
141 pub protocol: u8,
142 pub type_of_service: u8,
143 pub time_to_live: u8,
144 pub do_not_fragment: crate::base::Boolean,
145 }
146
147 pub type ProtocolGetModeData = eficall! {fn(
148 *mut Protocol,
149 *mut ModeData,
150 *mut crate::protocols::managed_network::ConfigData,
151 *mut crate::protocols::simple_network::Mode,
152 ) -> crate::base::Status};
153
154 pub type ProtocolConfigure = eficall! {fn(
155 *mut Protocol,
156 *mut ConfigData,
157 ) -> crate::base::Status};
158
159 pub type ProtocolGroups = eficall! {fn(
160 *mut Protocol,
161 crate::base::Boolean,
162 *mut crate::base::Ipv4Address,
163 ) -> crate::base::Status};
164
165 pub type ProtocolRoutes = eficall! {fn(
166 *mut Protocol,
167 crate::base::Boolean,
168 *mut crate::base::Ipv4Address,
169 *mut crate::base::Ipv4Address,
170 *mut crate::base::Ipv4Address,
171 ) -> crate::base::Status};
172
173 pub type ProtocolTransmit = eficall! {fn(
174 *mut Protocol,
175 *mut CompletionToken,
176 ) -> crate::base::Status};
177
178 pub type ProtocolReceive = eficall! {fn(
179 *mut Protocol,
180 *mut CompletionToken,
181 ) -> crate::base::Status};
182
183 pub type ProtocolCancel = eficall! {fn(
184 *mut Protocol,
185 *mut CompletionToken,
186 ) -> crate::base::Status};
187
188 pub type ProtocolPoll = eficall! {fn(
189 *mut Protocol,
190 ) -> crate::base::Status};
191
192 #[repr(C)]
193 pub struct Protocol {
194 pub get_mode_data: ProtocolGetModeData,
195 pub configure: ProtocolConfigure,
196 pub groups: ProtocolGroups,
197 pub routes: ProtocolRoutes,
198 pub transmit: ProtocolTransmit,
199 pub receive: ProtocolReceive,
200 pub cancel: ProtocolCancel,
201 pub poll: ProtocolPoll,
202 }