+use crate::cmp;
use crate::ffi::CStr;
use crate::io;
use crate::io::{IoSlice, IoSliceMut};
-use libc::{self, c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK};
use crate::mem;
-use crate::net::{SocketAddr, Shutdown};
+use crate::net::{Shutdown, SocketAddr};
use crate::str;
use crate::sys::fd::FileDesc;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
use crate::time::{Duration, Instant};
-use crate::cmp;
+use libc::{self, c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK};
pub use crate::sys::{cvt, cvt_r};
pub type wrlen_t = size_t;
-
const SOCK_CLOEXEC: c_int = 0;
const SO_NOSIGPIPE: c_int = 0;
pub fn cvt_gai(err: c_int) -> io::Result<()> {
if err == 0 {
- return Ok(())
+ return Ok(());
}
// We may need to trigger a glibc workaround. See on_resolver_failure() for details.
on_resolver_failure();
if err == EAI_SYSTEM {
- return Err(io::Error::last_os_error())
+ return Err(io::Error::last_os_error());
}
let detail = unsafe {
- str::from_utf8(CStr::from_ptr(libc::gai_strerror(err)).to_bytes()).unwrap()
- .to_owned()
+ str::from_utf8(CStr::from_ptr(libc::gai_strerror(err)).to_bytes()).unwrap().to_owned()
};
- Err(io::Error::new(io::ErrorKind::Other,
- &format!("failed to lookup address information: {}",
- detail)[..]))
+ Err(io::Error::new(
+ io::ErrorKind::Other,
+ &format!("failed to lookup address information: {}", detail)[..],
+ ))
}
impl Socket {
pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
unsafe {
- // On linux we first attempt to pass the SOCK_CLOEXEC flag to
- // atomically create the socket and set it as CLOEXEC. Support for
- // this option, however, was added in 2.6.27, and we still support
- // 2.6.18 as a kernel, so if the returned error is EINVAL we
- // fallthrough to the fallback.
- if cfg!(target_os = "linux") {
- match cvt(libc::socket(fam, ty | SOCK_CLOEXEC, 0)) {
- Ok(fd) => return Ok(Socket(FileDesc::new(fd))),
- Err(ref e) if e.raw_os_error() == Some(libc::EINVAL) => {}
- Err(e) => return Err(e),
- }
- }
-
let fd = cvt(libc::socket(fam, ty, 0))?;
let fd = FileDesc::new(fd);
fd.set_cloexec()?;
}
pub fn new_pair(_fam: c_int, _ty: c_int) -> io::Result<(Socket, Socket)> {
- unimplemented!();
+ unimplemented!();
}
pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> {
Err(e) => return Err(e),
}
- let mut pollfd = libc::pollfd {
- fd: self.0.raw(),
- events: libc::POLLOUT,
- revents: 0,
- };
+ let mut pollfd = libc::pollfd { fd: self.0.raw(), events: libc::POLLOUT, revents: 0 };
if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
- return Err(io::Error::new(io::ErrorKind::InvalidInput,
- "cannot set a 0 duration timeout"));
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "cannot set a 0 duration timeout",
+ ));
}
let start = Instant::now();
}
let timeout = timeout - elapsed;
- let mut timeout = timeout.as_secs()
+ let mut timeout = timeout
+ .as_secs()
.saturating_mul(1_000)
.saturating_add(timeout.subsec_nanos() as u64 / 1_000_000);
if timeout == 0 {
// linux returns POLLOUT|POLLERR|POLLHUP for refused connections (!), so look
// for POLLHUP rather than read readiness
if pollfd.revents & libc::POLLHUP != 0 {
- let e = self.take_error()?
- .unwrap_or_else(|| {
- io::Error::new(io::ErrorKind::Other, "no error set after POLLHUP")
- });
+ let e = self.take_error()?.unwrap_or_else(|| {
+ io::Error::new(io::ErrorKind::Other, "no error set after POLLHUP")
+ });
return Err(e);
}
}
}
- pub fn accept(&self, storage: *mut sockaddr, len: *mut socklen_t)
- -> io::Result<Socket> {
- // Unfortunately the only known way right now to accept a socket and
- // atomically set the CLOEXEC flag is to use the `accept4` syscall on
- // Linux. This was added in 2.6.28, however, and because we support
- // 2.6.18 we must detect this support dynamically.
- let fd = cvt_r(|| unsafe {
- libc::accept(self.0.raw(), storage, len)
- })?;
+ pub fn accept(&self, storage: *mut sockaddr, len: *mut socklen_t) -> io::Result<Socket> {
+ let fd = cvt_r(|| unsafe { libc::accept(self.0.raw(), storage, len) })?;
let fd = FileDesc::new(fd);
fd.set_cloexec()?;
Ok(Socket(fd))
fn recv_with_flags(&self, buf: &mut [u8], flags: c_int) -> io::Result<usize> {
let ret = cvt(unsafe {
- libc::recv(self.0.raw(),
- buf.as_mut_ptr() as *mut c_void,
- buf.len(),
- flags)
+ libc::recv(self.0.raw(), buf.as_mut_ptr() as *mut c_void, buf.len(), flags)
})?;
Ok(ret as usize)
}
self.0.read_vectored(bufs)
}
- fn recv_from_with_flags(&self, buf: &mut [u8], flags: c_int)
- -> io::Result<(usize, SocketAddr)> {
+ fn recv_from_with_flags(
+ &self,
+ buf: &mut [u8],
+ flags: c_int,
+ ) -> io::Result<(usize, SocketAddr)> {
let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
let mut addrlen = mem::size_of_val(&storage) as libc::socklen_t;
let n = cvt(unsafe {
- libc::recvfrom(self.0.raw(),
- buf.as_mut_ptr() as *mut c_void,
- buf.len(),
- flags,
- &mut storage as *mut _ as *mut _,
- &mut addrlen)
+ libc::recvfrom(
+ self.0.raw(),
+ buf.as_mut_ptr() as *mut c_void,
+ buf.len(),
+ flags,
+ &mut storage as *mut _ as *mut _,
+ &mut addrlen,
+ )
})?;
Ok((n as usize, sockaddr_to_addr(&storage, addrlen as usize)?))
}
let timeout = match dur {
Some(dur) => {
if dur.as_secs() == 0 && dur.subsec_nanos() == 0 {
- return Err(io::Error::new(io::ErrorKind::InvalidInput,
- "cannot set a 0 duration timeout"));
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "cannot set a 0 duration timeout",
+ ));
}
let secs = if dur.as_secs() > libc::time_t::max_value() as u64 {
}
timeout
}
- None => {
- libc::timeval {
- tv_sec: 0,
- tv_usec: 0,
- }
- }
+ None => libc::timeval { tv_sec: 0, tv_usec: 0 },
};
setsockopt(self, libc::SOL_SOCKET, kind, timeout)
}
pub fn take_error(&self) -> io::Result<Option<io::Error>> {
let raw: c_int = getsockopt(self, libc::SOL_SOCKET, libc::SO_ERROR)?;
- if raw == 0 {
- Ok(None)
- } else {
- Ok(Some(io::Error::from_raw_os_error(raw as i32)))
- }
+ if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
}
}
impl AsInner<c_int> for Socket {
- fn as_inner(&self) -> &c_int { self.0.as_inner() }
+ fn as_inner(&self) -> &c_int {
+ self.0.as_inner()
+ }
}
impl FromInner<c_int> for Socket {
- fn from_inner(fd: c_int) -> Socket { Socket(FileDesc::new(fd)) }
+ fn from_inner(fd: c_int) -> Socket {
+ Socket(FileDesc::new(fd))
+ }
}
impl IntoInner<c_int> for Socket {
- fn into_inner(self) -> c_int { self.0.into_raw() }
+ fn into_inner(self) -> c_int {
+ self.0.into_raw()
+ }
}
// In versions of glibc prior to 2.26, there's a bug where the DNS resolver
// believe it's thread-safe).
#[cfg(target_env = "gnu")]
fn on_resolver_failure() {
-/*
+ /*
use crate::sys;
// If the version fails to parse, we treat it the same as "not glibc".
projects / rust.git / blobdiff