| use std::convert::TryInto; |
| use std::io; |
| use std::mem::{size_of, MaybeUninit}; |
| use std::net::{self, SocketAddr}; |
| use std::os::unix::io::{AsRawFd, FromRawFd}; |
| |
| use crate::sys::unix::net::{new_socket, socket_addr, to_socket_addr}; |
| |
| pub(crate) fn new_for_addr(address: SocketAddr) -> io::Result<libc::c_int> { |
| let domain = match address { |
| SocketAddr::V4(_) => libc::AF_INET, |
| SocketAddr::V6(_) => libc::AF_INET6, |
| }; |
| new_socket(domain, libc::SOCK_STREAM) |
| } |
| |
| pub(crate) fn bind(socket: &net::TcpListener, addr: SocketAddr) -> io::Result<()> { |
| let (raw_addr, raw_addr_length) = socket_addr(&addr); |
| syscall!(bind(socket.as_raw_fd(), raw_addr.as_ptr(), raw_addr_length))?; |
| Ok(()) |
| } |
| |
| pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<()> { |
| let (raw_addr, raw_addr_length) = socket_addr(&addr); |
| |
| match syscall!(connect( |
| socket.as_raw_fd(), |
| raw_addr.as_ptr(), |
| raw_addr_length |
| )) { |
| Err(err) if err.raw_os_error() != Some(libc::EINPROGRESS) => Err(err), |
| _ => Ok(()), |
| } |
| } |
| |
| pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> { |
| let backlog = backlog.try_into().unwrap_or(i32::max_value()); |
| syscall!(listen(socket.as_raw_fd(), backlog))?; |
| Ok(()) |
| } |
| |
| pub(crate) fn set_reuseaddr(socket: &net::TcpListener, reuseaddr: bool) -> io::Result<()> { |
| let val: libc::c_int = if reuseaddr { 1 } else { 0 }; |
| syscall!(setsockopt( |
| socket.as_raw_fd(), |
| libc::SOL_SOCKET, |
| libc::SO_REUSEADDR, |
| &val as *const libc::c_int as *const libc::c_void, |
| size_of::<libc::c_int>() as libc::socklen_t, |
| ))?; |
| Ok(()) |
| } |
| |
| pub(crate) fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> { |
| let mut addr: MaybeUninit<libc::sockaddr_storage> = MaybeUninit::uninit(); |
| let mut length = size_of::<libc::sockaddr_storage>() as libc::socklen_t; |
| |
| // On platforms that support it we can use `accept4(2)` to set `NONBLOCK` |
| // and `CLOEXEC` in the call to accept the connection. |
| #[cfg(any( |
| // Android x86's seccomp profile forbids calls to `accept4(2)` |
| // See https://github.com/tokio-rs/mio/issues/1445 for details |
| all( |
| not(target_arch="x86"), |
| target_os = "android" |
| ), |
| target_os = "dragonfly", |
| target_os = "freebsd", |
| target_os = "illumos", |
| target_os = "linux", |
| target_os = "netbsd", |
| target_os = "openbsd" |
| ))] |
| let stream = { |
| syscall!(accept4( |
| listener.as_raw_fd(), |
| addr.as_mut_ptr() as *mut _, |
| &mut length, |
| libc::SOCK_CLOEXEC | libc::SOCK_NONBLOCK, |
| )) |
| .map(|socket| unsafe { net::TcpStream::from_raw_fd(socket) }) |
| }?; |
| |
| // But not all platforms have the `accept4(2)` call. Luckily BSD (derived) |
| // OSes inherit the non-blocking flag from the listener, so we just have to |
| // set `CLOEXEC`. |
| #[cfg(any( |
| all(target_arch = "x86", target_os = "android"), |
| target_os = "ios", |
| target_os = "macos", |
| target_os = "redox" |
| ))] |
| let stream = { |
| syscall!(accept( |
| listener.as_raw_fd(), |
| addr.as_mut_ptr() as *mut _, |
| &mut length |
| )) |
| .map(|socket| unsafe { net::TcpStream::from_raw_fd(socket) }) |
| .and_then(|s| { |
| syscall!(fcntl(s.as_raw_fd(), libc::F_SETFD, libc::FD_CLOEXEC))?; |
| |
| // See https://github.com/tokio-rs/mio/issues/1450 |
| #[cfg(all(target_arch = "x86", target_os = "android"))] |
| syscall!(fcntl(s.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK))?; |
| |
| Ok(s) |
| }) |
| }?; |
| |
| // This is safe because `accept` calls above ensures the address |
| // initialised. |
| unsafe { to_socket_addr(addr.as_ptr()) }.map(|addr| (stream, addr)) |
| } |