1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
use std::io;
use std::mem::size_of;
use std::net::{self, SocketAddr};
use std::time::Duration;
use std::os::windows::io::FromRawSocket;
use std::os::windows::raw::SOCKET as StdSocket; // winapi uses usize, stdlib uses u32/u64.
use winapi::ctypes::{c_char, c_int, c_ushort};
use winapi::shared::minwindef::{BOOL, TRUE, FALSE};
use winapi::um::winsock2::{
self, closesocket, linger, setsockopt, PF_INET, PF_INET6, SOCKET, SOCKET_ERROR,
SOCK_STREAM, SOL_SOCKET, SO_LINGER, SO_REUSEADDR,
};
use crate::sys::windows::net::{init, new_socket, socket_addr};
pub(crate) type TcpSocket = SOCKET;
pub(crate) fn new_v4_socket() -> io::Result<TcpSocket> {
init();
new_socket(PF_INET, SOCK_STREAM)
}
pub(crate) fn new_v6_socket() -> io::Result<TcpSocket> {
init();
new_socket(PF_INET6, SOCK_STREAM)
}
pub(crate) fn bind(socket: TcpSocket, addr: SocketAddr) -> io::Result<()> {
use winsock2::bind;
let (raw_addr, raw_addr_length) = socket_addr(&addr);
syscall!(
bind(socket, raw_addr, raw_addr_length),
PartialEq::eq,
SOCKET_ERROR
)?;
Ok(())
}
pub(crate) fn connect(socket: TcpSocket, addr: SocketAddr) -> io::Result<net::TcpStream> {
use winsock2::connect;
let (raw_addr, raw_addr_length) = socket_addr(&addr);
let res = syscall!(
connect(socket, raw_addr, raw_addr_length),
PartialEq::eq,
SOCKET_ERROR
);
match res {
Err(err) if err.kind() != io::ErrorKind::WouldBlock => {
Err(err)
}
_ => {
Ok(unsafe { net::TcpStream::from_raw_socket(socket as StdSocket) })
}
}
}
pub(crate) fn listen(socket: TcpSocket, backlog: u32) -> io::Result<net::TcpListener> {
use winsock2::listen;
use std::convert::TryInto;
let backlog = backlog.try_into().unwrap_or(i32::max_value());
syscall!(listen(socket, backlog), PartialEq::eq, SOCKET_ERROR)?;
Ok(unsafe { net::TcpListener::from_raw_socket(socket as StdSocket) })
}
pub(crate) fn close(socket: TcpSocket) {
let _ = unsafe { closesocket(socket) };
}
pub(crate) fn set_reuseaddr(socket: TcpSocket, reuseaddr: bool) -> io::Result<()> {
let val: BOOL = if reuseaddr { TRUE } else { FALSE };
match unsafe { setsockopt(
socket,
SOL_SOCKET,
SO_REUSEADDR,
&val as *const _ as *const c_char,
size_of::<BOOL>() as c_int,
) } {
SOCKET_ERROR => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub(crate) fn set_linger(socket: TcpSocket, dur: Option<Duration>) -> io::Result<()> {
let val: linger = linger {
l_onoff: if dur.is_some() { 1 } else { 0 },
l_linger: dur.map(|dur| dur.as_secs() as c_ushort).unwrap_or_default(),
};
match unsafe { setsockopt(
socket,
SOL_SOCKET,
SO_LINGER,
&val as *const _ as *const c_char,
size_of::<linger>() as c_int,
) } {
SOCKET_ERROR => Err(io::Error::last_os_error()),
_ => Ok(()),
}
}
pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> {
// The non-blocking state of `listener` is inherited. See
// https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept#remarks.
listener.accept()
}
|
