1#![allow(non_snake_case)]
2#![allow(non_upper_case_globals)]
3#![allow(non_camel_case_types)]
4
5use crate::h_protocol::*;
6use crate::h_win32::ENetBuffer;
7use std::any::Any;
8use std::collections::VecDeque;
9use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, UdpSocket};
10
11pub const ENET_VERSION_MAJOR: u32 = 1;
12pub const ENET_VERSION_MINOR: u32 = 3;
13pub const ENET_VERSION_PATCH: u32 = 18;
14
15pub const fn ENET_VERSION_CREATE(major: u32, minor: u32, patch: u32) -> u32 {
16 ((major) << 16) | ((minor) << 8) | (patch)
17}
18
19pub const fn ENET_VERSION_GET_MAJOR(version: u32) -> u32 {
20 ((version) >> 16) & 0xFF
21}
22
23pub const fn ENET_VERSION_GET_MINOR(version: u32) -> u32 {
24 ((version) >> 8) & 0xFF
25}
26
27pub const fn ENET_VERSION_GET_PATCH(version: u32) -> u32 {
28 (version) & 0xFF
29}
30
31pub const ENET_VERSION: u32 =
32 ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH);
33
34#[repr(u32)]
35pub enum ENetSocketType {
36 ENET_SOCKET_TYPE_STREAM = 1,
37 ENET_SOCKET_TYPE_DATAGRAM = 2,
38}
39
40#[repr(u32)]
41pub enum ENetSocketWait {
42 ENET_SOCKET_WAIT_NONE = 0,
43 ENET_SOCKET_WAIT_SEND = 1 << 0,
44 ENET_SOCKET_WAIT_RECEIVE = 1 << 1,
45 ENET_SOCKET_WAIT_INTERRUPT = 1 << 2,
46}
47
48#[repr(u32)]
49pub enum ENetSocketOption {
50 ENET_SOCKOPT_NONBLOCK = 1,
51 ENET_SOCKOPT_BROADCAST = 2,
52 ENET_SOCKOPT_RCVBUF = 3,
53 ENET_SOCKOPT_SNDBUF = 4,
54 ENET_SOCKOPT_REUSEADDR = 5,
55 ENET_SOCKOPT_RCVTIMEO = 6,
56 ENET_SOCKOPT_SNDTIMEO = 7,
57 ENET_SOCKOPT_ERROR = 8,
58 ENET_SOCKOPT_NODELAY = 9,
59 ENET_SOCKOPT_TTL = 10,
60 ENET_SOCKOPT_IPV6_ONLY = 11,
61}
62
63#[repr(u32)]
64pub enum ENetSocketShutdown {
65 ENET_SOCKET_SHUTDOWN_READ = 0,
66 ENET_SOCKET_SHUTDOWN_WRITE = 1,
67 ENET_SOCKET_SHUTDOWN_READ_WRITE = 2,
68}
69
70pub const ENET_HOST_ANY: [u8; 16] = [0; 16];
71pub const ENET_HOST_BROADCAST: [u8; 16] =
72 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255];
73pub const ENET_PORT_ANY: u32 = 0;
74
75#[derive(Copy, Clone, Eq, PartialEq, Hash)]
76pub struct ENetAddress {
77 pub host: [u8; 16],
78 pub port: u16,
79 pub scopeID: u32,
80}
81
82impl ENetAddress {
83 pub fn new() -> ENetAddress {
84 ENetAddress {
85 host: [0; 16],
86 port: 0,
87 scopeID: 0,
88 }
89 }
90
91 pub fn is_ipv4(&self) -> bool {
92 self.host[0..10].iter().all(|&b| b == 0) && self.host[10..12] == [0xFF, 0xFF]
93 }
94
95 pub fn is_ipv6(&self) -> bool {
96 !self.is_ipv4()
97 }
98
99 pub fn try_into(&self, socket: UdpSocket) -> Option<SocketAddr> {
100 match socket.local_addr() {
101 Ok(addr) => {
102 return if addr.is_ipv6() {
103 Some(self.into_ipv6())
104 } else {
105 self.try_into_ipv4()
106 }
107 }
108
109 Err(_) => {}
110 }
111
112 None
113 }
114
115 pub fn try_into_ipv4(&self) -> Option<SocketAddr> {
116 if self.is_ipv4() {
117 return Some(self.into_ipv4());
118 }
119
120 None
121 }
122
123 pub fn into_ipv4(self) -> SocketAddr {
124 let bytes: [u8; 4] = self.host[12..16].try_into().unwrap();
125 let ipv4 = Ipv4Addr::from(bytes);
126 SocketAddr::V4(SocketAddrV4::new(ipv4, self.port))
127 }
128
129 pub fn into_ipv6(self) -> SocketAddr {
130 let ipv6 = Ipv6Addr::from(self.host);
131 SocketAddr::V6(SocketAddrV6::new(ipv6, self.port, 0, self.scopeID))
132 }
133}
134
135impl From<SocketAddr> for ENetAddress {
136 fn from(addr: SocketAddr) -> ENetAddress {
137 let mut host = [0u8; 16];
138
139 match addr {
140 SocketAddr::V4(ipv4) => {
141 host[10..12].copy_from_slice(&[0xFF, 0xFF]);
142 host[12..16].copy_from_slice(&ipv4.ip().octets());
143 ENetAddress {
144 host,
145 port: ipv4.port(),
146 scopeID: 0,
147 }
148 }
149
150 SocketAddr::V6(ipv6) => {
151 host.copy_from_slice(&ipv6.ip().octets());
152 ENetAddress {
153 host,
154 port: ipv6.port(),
155 scopeID: ipv6.scope_id(),
156 }
157 }
158 }
159 }
160}
161
162impl Into<SocketAddr> for ENetAddress {
163 fn into(self) -> SocketAddr {
164 if self.is_ipv4() {
165 self.into_ipv4()
166 } else {
167 self.into_ipv6()
168 }
169 }
170}
171
172#[repr(u32)]
173pub enum ENetPacketFlag {
174 ENET_PACKET_FLAG_RELIABLE = 1 << 0,
175 ENET_PACKET_FLAG_UNSEQUENCED = 1 << 1,
176 ENET_PACKET_FLAG_NO_ALLOCATE = 1 << 2,
177 ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = 1 << 3,
178 ENET_PACKET_FLAG_SENT = 1 << 8,
179}
180
181pub struct ENetPacket {
182 pub referenceCount: usize,
183 pub flags: u32,
184 pub data: Vec<u8>,
185 pub freeCallback: Option<fn()>,
186 pub userData: Option<fn(Box<dyn Any>)>,
187}
188
189pub struct ENetAcknowledgement {
190 pub sentTime: u32,
191 pub command: ENetProtocol,
192}
193
194pub struct ENetOutgoingCommand {
195 pub reliableSequenceNumber: u16,
196 pub unreliableSequenceNumber: u16,
197 pub sentTime: u32,
198 pub roundTripTimeout: u32,
199 pub queueTime: u32,
200 pub fragmentOffset: u32,
201 pub fragmentLength: u16,
202 pub sendAttempts: u16,
203 pub command: ENetProtocol,
204 pub packet: ENetPacket,
205}
206
207pub struct ENetIncomingCommand {
208 pub reliableSequenceNumber: u16,
209 pub unreliableSequenceNumber: u16,
210 pub command: ENetProtocol,
211 pub fragmentCount: u32,
212 pub fragmentsRemaining: u32,
213 pub fragments: VecDeque<u32>,
214 pub packet: ENetPacket,
215}
216
217#[repr(u32)]
218pub enum ENetPeerState {
219 ENET_PEER_STATE_DISCONNECTED = 0,
220 ENET_PEER_STATE_CONNECTING = 1,
221 ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2,
222 ENET_PEER_STATE_CONNECTION_PENDING = 3,
223 ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4,
224 ENET_PEER_STATE_CONNECTED = 5,
225 ENET_PEER_STATE_DISCONNECT_LATER = 6,
226 ENET_PEER_STATE_DISCONNECTING = 7,
227 ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
228 ENET_PEER_STATE_ZOMBIE = 9,
229}
230
231pub const ENET_BUFFER_MAXIMUM: u32 = 1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS;
232
233pub const ENET_HOST_RECEIVE_BUFFER_SIZE: u32 = 256 * 1024;
234pub const ENET_HOST_SEND_BUFFER_SIZE: u32 = 256 * 1024;
235pub const ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL: u32 = 1000;
236pub const ENET_HOST_DEFAULT_MTU: u32 = 1392;
237pub const ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE: u32 = 32 * 1024 * 1024;
238pub const ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA: u32 = 32 * 1024 * 1024;
239pub const ENET_PEER_DEFAULT_ROUND_TRIP_TIME: u32 = 500;
240pub const ENET_PEER_DEFAULT_PACKET_THROTTLE: u32 = 32;
241pub const ENET_PEER_PACKET_THROTTLE_SCALE: u32 = 32;
242pub const ENET_PEER_PACKET_THROTTLE_COUNTER: u32 = 7;
243pub const ENET_PEER_PACKET_THROTTLE_ACCELERATION: u32 = 2;
244pub const ENET_PEER_PACKET_THROTTLE_DECELERATION: u32 = 2;
245pub const ENET_PEER_PACKET_THROTTLE_INTERVAL: u32 = 5000;
246pub const ENET_PEER_PACKET_LOSS_SCALE: u32 = 1 << 16;
247pub const ENET_PEER_PACKET_LOSS_INTERVAL: u32 = 10000;
248pub const ENET_PEER_WINDOW_SIZE_SCALE: u32 = 64 * 1024;
249pub const ENET_PEER_TIMEOUT_LIMIT: u32 = 32;
250pub const ENET_PEER_TIMEOUT_MINIMUM: u32 = 5000;
251pub const ENET_PEER_TIMEOUT_MAXIMUM: u32 = 30000;
252pub const ENET_PEER_PING_INTERVAL: u32 = 500;
253pub const ENET_PEER_UNSEQUENCED_WINDOWS: u32 = 64;
254pub const ENET_PEER_UNSEQUENCED_WINDOW_SIZE: u32 = 1024;
255pub const ENET_PEER_FREE_UNSEQUENCED_WINDOWS: u32 = 32;
256pub const ENET_PEER_RELIABLE_WINDOWS: u32 = 16;
257pub const ENET_PEER_RELIABLE_WINDOW_SIZE: u32 = 0x1000;
258pub const ENET_PEER_FREE_RELIABLE_WINDOWS: u32 = 8;
259
260pub struct ENetChannel {
261 pub outgoingReliableSequenceNumber: u16,
262 pub outgoingUnreliableSequenceNumber: u16,
263 pub usedReliableWindows: u16,
264 pub reliableWindows: [u16; ENET_PEER_RELIABLE_WINDOWS as usize],
265 pub incomingReliableSequenceNumber: u16,
266 pub incomingUnreliableSequenceNumber: u16,
267 pub incomingReliableCommands: Vec<ENetIncomingCommand>,
268 pub incomingUnreliableCommands: Vec<ENetIncomingCommand>,
269}
270
271#[repr(u32)]
272pub enum ENetPeerFlag {
273 ENET_PEER_FLAG_NEEDS_DISPATCH = 1 << 0,
274 ENET_PEER_FLAG_CONTINUE_SENDING = 1 << 1,
275}
276
277pub struct ENetPeer<'a> {
278 pub host: &'a mut ENetHost<'a>,
279 pub outgoingPeerID: u16,
280 pub incomingPeerID: u16,
281 pub connectID: u32,
282 pub outgoingSessionID: u8,
283 pub incomingSessionID: u8,
284 pub address: ENetAddress,
285 pub data: Option<Box<dyn Any>>,
286 pub state: ENetPeerState,
287 pub channels: Vec<ENetChannel>,
288 pub channelCount: usize,
289 pub incomingBandwidth: u32,
290 pub outgoingBandwidth: u32,
291 pub incomingBandwidthThrottleEpoch: u32,
292 pub outgoingBandwidthThrottleEpoch: u32,
293 pub incomingDataTotal: u32,
294 pub outgoingDataTotal: u32,
295 pub lastSendTime: u32,
296 pub lastReceiveTime: u32,
297 pub nextTimeout: u32,
298 pub earliestTimeout: u32,
299 pub packetLossEpoch: u32,
300 pub packetsSent: u32,
301 pub packetsLost: u32,
302 pub packetLoss: u32,
303 pub packetLossVariance: u32,
304 pub packetThrottle: u32,
305 pub packetThrottleLimit: u32,
306 pub packetThrottleCounter: u32,
307 pub packetThrottleEpoch: u32,
308 pub packetThrottleAcceleration: u32,
309 pub packetThrottleDeceleration: u32,
310 pub packetThrottleInterval: u32,
311 pub pingInterval: u32,
312 pub timeoutLimit: u32,
313 pub timeoutMinimum: u32,
314 pub timeoutMaximum: u32,
315 pub lastRoundTripTime: u32,
316 pub lowestRoundTripTime: u32,
317 pub lastRoundTripTimeVariance: u32,
318 pub highestRoundTripTimeVariance: u32,
319 pub roundTripTime: u32,
320 pub roundTripTimeVariance: u32,
321 pub mtu: u32,
322 pub windowSize: u32,
323 pub reliableDataInTransit: u32,
324 pub outgoingReliableSequenceNumber: u16,
325 pub acknowledgements: VecDeque<ENetAcknowledgement>,
326 pub sentReliableCommands: VecDeque<ENetOutgoingCommand>,
327 pub outgoingSendReliableCommands: VecDeque<ENetOutgoingCommand>,
328 pub outgoingCommands: VecDeque<ENetOutgoingCommand>,
329 pub dispatchedCommands: VecDeque<ENetIncomingCommand>,
330 pub flags: u16,
331 pub reserved: u16,
332 pub incomingUnsequencedGroup: u16,
333 pub outgoingUnsequencedGroup: u16,
334 pub unsequencedWindow: [u32; (ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32) as usize],
335 pub eventData: u32,
336 pub totalWaitingData: usize,
337}
338
339pub struct ENetCompressor {
340 pub context: Option<Box<dyn Any>>,
341 pub compress: Option<fn(Option<Box<dyn Any>>, &mut [Vec<u8>], usize, usize, &mut [u8], usize) -> usize>,
342 pub decompress: Option<fn(Option<&Box<dyn Any>>, &[u8], usize, &mut [u8], usize) -> usize>,
343 pub destroy: Option<fn(Option<Box<dyn Any>>)>,
344}
345
346impl ENetCompressor {
347 pub fn new() -> ENetCompressor {
348 ENetCompressor{
349 context: None,
350 compress: None,
351 decompress: None,
352 destroy: None,
353 }
354 }
355}
356
357pub struct ENetHost<'a> {
358 pub socket: UdpSocket,
359 pub address: ENetAddress,
360 pub incomingBandwidth: u32,
361 pub outgoingBandwidth: u32,
362 pub bandwidthThrottleEpoch: u32,
363 pub mtu: u32,
364 pub randomSeed: u32,
365 pub recalculateBandwidthLimits: i32,
366 pub peers: Vec<ENetPeer<'a>>,
367 pub channelLimit: usize,
368 pub serviceTime: u32,
369 pub dispatchQueue: Vec<u16>,
370 pub totalQueued: u32,
371 pub packetSize: usize,
372 pub headerFlags: u16,
373 pub commands: [ENetProtocol; ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS as usize],
374 pub commandCount: usize,
375 pub buffers: [ENetBuffer<'a>; ENET_BUFFER_MAXIMUM as usize],
376 pub bufferCount: usize,
377 pub checksum: Option<fn(&mut [Vec<u8>], usize) -> u32>,
378 pub compressor: ENetCompressor,
379 pub packetData: [[u8; ENET_PROTOCOL_MAXIMUM_MTU as usize]; 2],
380 pub receivedAddress: ENetAddress,
381 pub receivedData: usize,
382 pub receivedDataLength: usize,
383 pub totalSentData: u32,
384 pub totalSentPackets: u32,
385 pub totalReceivedData: u32,
386 pub totalReceivedPackets: u32,
387 pub intercept: Option<fn(&mut ENetHost, &mut ENetEvent) -> i32>,
388 pub connectedPeers: usize,
389 pub bandwidthLimitedPeers: usize,
390 pub duplicatePeers: usize,
391 pub maximumPacketSize: usize,
392 pub maximumWaitingData: usize,
393}
394
395#[repr(u32)]
396pub enum ENetEventType {
397 ENET_EVENT_TYPE_NONE = 0,
398 ENET_EVENT_TYPE_CONNECT = 1,
399 ENET_EVENT_TYPE_DISCONNECT = 2,
400 ENET_EVENT_TYPE_RECEIVE = 3,
401}
402
403pub enum ENetEvent {
404 NONE {
405 peer: u16,
406 channelID: u8,
407 data: u32,
408 },
409
410 CONNECT {
411 peer: u16,
412 channelID: u8,
413 data: u32,
414 },
415
416 DISCONNECT {
417 peer: u16,
418 channelID: u8,
419 data: u32,
420 },
421
422 RECEIVE {
423 peer: u16,
424 channelID: u8,
425 data: u32,
426 packet: ENetPacket,
427 },
428}