use std::{
cmp,
io::{self, Read, Write},
net::{IpAddr, Shutdown, SocketAddr, ToSocketAddrs},
time::{Duration, Instant},
};
use crate::state::{
add_tcp_connection, add_tcp_listener_state, assign_tcp_stream_to_listener,
clone_tcp_listener_state, find_tcp_listener, is_ip_addr_valid, is_port_available,
mark_peer_read_shutdown, notify_peer_dropped, release_stream, remove_tcp_connection,
remove_tcp_listener_state, reserve_ephemeral_addr, wait_for_event, with_tcp_connection,
with_tcp_listener_state,
};
#[derive(Debug)]
pub struct ShimStdTcpStream {
stream_id: usize,
}
#[derive(Debug)]
pub struct ShimStdTcpListener {
bound_addr: SocketAddr,
}
enum TcpReadStatus {
Data(Vec<u8>),
Eof,
Pending { nonblocking: bool, timeout: Option<Duration> },
}
impl ShimStdTcpStream {
#[doc(alias = "std::net::TcpStream::connect")]
pub fn connect<A: ToSocketAddrs>(addr: A) -> io::Result<Self> {
let mut last_err = None;
for target in addr.to_socket_addrs()? {
match Self::connect_addr(target) {
Ok(stream) => return Ok(stream),
Err(err) => last_err = Some(err),
}
}
Err(last_err.unwrap_or_else(|| {
io::Error::new(io::ErrorKind::InvalidInput, "could not resolve to any addresses")
}))
}
#[doc(alias = "std::net::TcpStream::connect_timeout")]
pub fn connect_timeout<A: ToSocketAddrs>(addr: A, timeout: Duration) -> io::Result<Self> {
if timeout == Duration::from_secs(0) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"timeout duration must be non-zero",
));
}
Self::connect(addr)
}
pub fn peer_addr(&self) -> io::Result<SocketAddr> {
self.with_conn(|conn| Ok(conn.peer_addr))
}
pub fn local_addr(&self) -> io::Result<SocketAddr> {
self.with_conn(|conn| Ok(conn.local_addr))
}
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
self.with_conn(|conn| {
conn.nonblocking = nonblocking;
Ok(())
})
}
pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
self.with_conn(|conn| {
conn.nodelay = nodelay;
Ok(())
})
}
pub fn nodelay(&self) -> io::Result<bool> {
self.with_conn(|conn| Ok(conn.nodelay))
}
pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
self.with_conn(|conn| {
conn.ttl = ttl;
Ok(())
})
}
pub fn ttl(&self) -> io::Result<u32> {
self.with_conn(|conn| Ok(conn.ttl))
}
pub fn set_linger(&self, linger: Option<Duration>) -> io::Result<()> {
if let Some(dur) = linger {
if dur == Duration::from_secs(0) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"linger duration must be non-zero",
));
}
}
self.with_conn(|conn| {
conn.linger = linger;
Ok(())
})
}
pub fn linger(&self) -> io::Result<Option<Duration>> {
self.with_conn(|conn| Ok(conn.linger))
}
pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
if let Some(d) = timeout {
if d == Duration::from_secs(0) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"timeout duration must be non-zero",
));
}
}
self.with_conn(|conn| {
conn.read_timeout = timeout;
Ok(())
})
}
pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
self.with_conn(|conn| Ok(conn.read_timeout))
}
pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
if let Some(d) = timeout {
if d == Duration::from_secs(0) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"timeout duration must be non-zero",
));
}
}
self.with_conn(|conn| {
conn.write_timeout = timeout;
Ok(())
})
}
pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
self.with_conn(|conn| Ok(conn.write_timeout))
}
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
self.with_conn(|conn| Ok(conn.external_error.take()))
}
pub fn try_clone(&self) -> io::Result<Self> {
self.with_conn(|conn| {
conn.ref_count += 1;
Ok(())
})?;
Ok(Self {
stream_id: self.stream_id,
})
}
pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
let peer = self.with_conn(|conn| {
match how {
Shutdown::Both => {
conn.read_shutdown = true;
conn.write_shutdown = true;
}
Shutdown::Read => {
conn.read_shutdown = true;
conn.incoming.clear();
}
Shutdown::Write => {
conn.write_shutdown = true;
}
}
Ok(conn.peer_stream_id)
})?;
if let Shutdown::Write | Shutdown::Both = how {
if let Some(peer_id) = peer {
mark_peer_read_shutdown(peer_id);
}
}
Ok(())
}
pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
self.read_internal(buf, false)
}
fn read_internal(&self, buf: &mut [u8], consume: bool) -> io::Result<usize> {
if buf.is_empty() {
return Ok(0);
}
let mut deadline = None;
loop {
match self.try_read(buf.len(), consume)? {
TcpReadStatus::Data(data) => {
let len = data.len();
if len > 0 {
buf[..len].copy_from_slice(&data[..len]);
}
return Ok(len);
}
TcpReadStatus::Eof => return Ok(0),
TcpReadStatus::Pending { nonblocking, timeout } => {
if nonblocking {
return Err(io::Error::new(
io::ErrorKind::WouldBlock,
"no data available",
));
}
self.wait_for_read_ready(timeout, &mut deadline)?;
}
}
}
}
fn try_read(&self, len: usize, consume: bool) -> io::Result<TcpReadStatus> {
self.with_conn(|conn| {
if conn.is_destroyed {
return Err(io::Error::new(
io::ErrorKind::NotConnected,
"stream destroyed",
));
}
if conn.incoming.is_empty() {
if conn.read_shutdown || conn.peer_stream_id.is_none() {
return Ok(TcpReadStatus::Eof);
}
return Ok(TcpReadStatus::Pending {
nonblocking: conn.nonblocking,
timeout: conn.read_timeout,
});
}
let take = cmp::min(len, conn.incoming.len());
let mut data = Vec::with_capacity(take);
if consume {
for _ in 0..take {
if let Some(byte) = conn.incoming.pop_front() {
data.push(byte);
}
}
} else {
data.extend(conn.incoming.iter().take(take).copied());
}
Ok(TcpReadStatus::Data(data))
})
}
fn wait_for_read_ready(
&self,
timeout: Option<Duration>,
deadline: &mut Option<Instant>,
) -> io::Result<()> {
if let Some(duration) = timeout {
let now = Instant::now();
let target = match deadline {
Some(existing) => *existing,
None => {
let new_deadline = now + duration;
*deadline = Some(new_deadline);
new_deadline
}
};
if now >= target {
return Err(io::Error::new(
io::ErrorKind::WouldBlock,
"operation timed out",
));
}
let remaining = target - now;
if !wait_for_event(Some(remaining)) {
return Err(io::Error::new(
io::ErrorKind::WouldBlock,
"operation timed out",
));
}
} else {
*deadline = None;
wait_for_event(None);
}
Ok(())
}
fn connect_addr(target: SocketAddr) -> io::Result<Self> {
if !is_ip_addr_valid(target.ip()) {
return Err(io::Error::new(
io::ErrorKind::AddrNotAvailable,
"invalid target address",
));
}
let listener_addr = find_tcp_listener(target).ok_or_else(|| {
io::Error::new(io::ErrorKind::ConnectionRefused, "no listener available")
})?;
let client_ip = preferred_client_ip(&target);
let local_addr = reserve_ephemeral_addr(client_ip);
let server_ip = if listener_addr.ip().is_unspecified() {
target.ip()
} else {
listener_addr.ip()
};
let server_addr = SocketAddr::new(server_ip, listener_addr.port());
let client_stream = add_tcp_connection(local_addr, server_addr, true);
let server_stream = add_tcp_connection(server_addr, local_addr, false);
with_tcp_connection(client_stream, |conn| -> io::Result<()> {
conn.peer_stream_id = Some(server_stream);
Ok(())
})?;
with_tcp_connection(server_stream, |conn| -> io::Result<()> {
conn.peer_stream_id = Some(client_stream);
Ok(())
})?;
assign_tcp_stream_to_listener(listener_addr, server_stream);
Ok(Self {
stream_id: client_stream,
})
}
fn with_conn<T, F>(&self, func: F) -> io::Result<T>
where
F: FnOnce(&mut crate::state::TcpConnection) -> io::Result<T>,
{
with_tcp_connection(self.stream_id, func)
}
}
impl Read for ShimStdTcpStream {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.read_internal(buf, true)
}
}
impl Write for ShimStdTcpStream {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
if buf.is_empty() {
return Ok(0);
}
let peer_id = self.with_conn(|conn| {
if conn.write_shutdown {
return Err(io::Error::new(
io::ErrorKind::BrokenPipe,
"write half closed",
));
}
conn.peer_stream_id.ok_or_else(|| {
io::Error::new(io::ErrorKind::NotConnected, "no peer connected")
})
})?;
with_tcp_connection(peer_id, |peer| {
if peer.read_shutdown {
return Err(io::Error::new(
io::ErrorKind::BrokenPipe,
"peer closed the read half",
));
}
peer.incoming.extend(buf.iter().copied());
Ok(buf.len())
})
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl Drop for ShimStdTcpStream {
fn drop(&mut self) {
if let Some(peer_id) = release_stream(self.stream_id) {
notify_peer_dropped(peer_id);
}
}
}
impl ShimStdTcpListener {
#[doc(alias = "std::net::TcpListener::bind")]
pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<Self> {
for address in addr.to_socket_addrs()? {
if !is_ip_addr_valid(address.ip()) {
continue;
}
let actual_addr = if address.port() == 0 {
reserve_ephemeral_addr(address.ip())
} else if is_port_available(address.port()) {
address
} else {
continue;
};
add_tcp_listener_state(actual_addr);
return Ok(Self {
bound_addr: actual_addr,
});
}
Err(io::Error::new(
io::ErrorKind::AddrNotAvailable,
"could not bind to any addresses",
))
}
pub fn local_addr(&self) -> io::Result<SocketAddr> {
Ok(self.bound_addr)
}
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
with_tcp_listener_state(self.bound_addr, |listener| {
listener.nonblocking = nonblocking;
});
Ok(())
}
pub fn accept(&self) -> io::Result<(ShimStdTcpStream, SocketAddr)> {
loop {
let (stream_id, nonblocking, is_closed) =
with_tcp_listener_state(self.bound_addr, |listener| {
(
listener.pending_streams.pop_front(),
listener.nonblocking,
listener.is_closed,
)
});
if is_closed {
return Err(io::Error::new(
io::ErrorKind::NotConnected,
"listener closed",
));
}
if let Some(stream_id) = stream_id {
let peer_addr = with_tcp_connection(stream_id, |conn| -> io::Result<SocketAddr> {
Ok(conn.peer_addr)
})?;
return Ok((ShimStdTcpStream { stream_id }, peer_addr));
}
if nonblocking {
return Err(io::Error::new(
io::ErrorKind::WouldBlock,
"no pending connections",
));
}
wait_for_event(None);
}
}
pub fn set_ttl(&self, _ttl: u32) -> io::Result<()> {
todo!()
}
pub fn ttl(&self) -> io::Result<u32> {
todo!()
}
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
with_tcp_listener_state(self.bound_addr, |listener| Ok(listener.error.take()))
}
pub fn try_clone(&self) -> io::Result<Self> {
clone_tcp_listener_state(self.bound_addr)?;
Ok(Self {
bound_addr: self.bound_addr,
})
}
}
impl Drop for ShimStdTcpListener {
fn drop(&mut self) {
if let Some(state) = remove_tcp_listener_state(self.bound_addr) {
for stream_id in state.pending_streams {
cleanup_unaccepted_stream(stream_id);
}
}
}
}
fn cleanup_unaccepted_stream(stream_id: usize) {
if let Some(conn) = remove_tcp_connection(stream_id) {
if let Some(peer_id) = conn.peer_stream_id {
notify_peer_dropped(peer_id);
}
}
}
fn preferred_client_ip(target: &SocketAddr) -> IpAddr {
if is_ip_addr_valid(target.ip()) {
target.ip()
} else {
match target {
SocketAddr::V4(_) => IpAddr::from([127, 0, 0, 1]),
SocketAddr::V6(_) => IpAddr::from([0, 0, 0, 0, 0, 0, 0, 1]),
}
}
}