/src/libstd/sys/unix/net.rs
Rust | 424 lines | 320 code | 55 blank | 49 comment | 53 complexity | 202d80526f69d366c8ad2153adc7f793 MD5 | raw file
- // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
- // file at the top-level directory of this distribution and at
- // http://rust-lang.org/COPYRIGHT.
- //
- // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
- // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
- // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
- // option. This file may not be copied, modified, or distributed
- // except according to those terms.
- use ffi::CStr;
- use io;
- use libc::{self, c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK};
- use mem;
- use net::{SocketAddr, Shutdown};
- use str;
- use sys::fd::FileDesc;
- use sys_common::{AsInner, FromInner, IntoInner};
- use sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
- use time::{Duration, Instant};
- use cmp;
- pub use sys::{cvt, cvt_r};
- pub extern crate libc as netc;
- pub type wrlen_t = size_t;
- // See below for the usage of SOCK_CLOEXEC, but this constant is only defined on
- // Linux currently (e.g. support doesn't exist on other platforms). In order to
- // get name resolution to work and things to compile we just define a dummy
- // SOCK_CLOEXEC here for other platforms. Note that the dummy constant isn't
- // actually ever used (the blocks below are wrapped in `if cfg!` as well.
- #[cfg(target_os = "linux")]
- use libc::SOCK_CLOEXEC;
- #[cfg(not(target_os = "linux"))]
- const SOCK_CLOEXEC: c_int = 0;
- // Another conditional contant for name resolution: Macos et iOS use
- // SO_NOSIGPIPE as a setsockopt flag to disable SIGPIPE emission on socket.
- // Other platforms do otherwise.
- #[cfg(target_vendor = "apple")]
- use libc::SO_NOSIGPIPE;
- #[cfg(not(target_vendor = "apple"))]
- const SO_NOSIGPIPE: c_int = 0;
- pub struct Socket(FileDesc);
- pub fn init() {}
- pub fn cvt_gai(err: c_int) -> io::Result<()> {
- if err == 0 {
- 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())
- }
- let detail = unsafe {
- 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)[..]))
- }
- impl Socket {
- pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
- let fam = match *addr {
- SocketAddr::V4(..) => libc::AF_INET,
- SocketAddr::V6(..) => libc::AF_INET6,
- };
- Socket::new_raw(fam, ty)
- }
- 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()?;
- let socket = Socket(fd);
- if cfg!(target_vendor = "apple") {
- setsockopt(&socket, libc::SOL_SOCKET, SO_NOSIGPIPE, 1)?;
- }
- Ok(socket)
- }
- }
- pub fn new_pair(fam: c_int, ty: c_int) -> io::Result<(Socket, Socket)> {
- unsafe {
- let mut fds = [0, 0];
- // Like above, see if we can set cloexec atomically
- if cfg!(target_os = "linux") {
- match cvt(libc::socketpair(fam, ty | SOCK_CLOEXEC, 0, fds.as_mut_ptr())) {
- Ok(_) => {
- return Ok((Socket(FileDesc::new(fds[0])), Socket(FileDesc::new(fds[1]))));
- }
- Err(ref e) if e.raw_os_error() == Some(libc::EINVAL) => {},
- Err(e) => return Err(e),
- }
- }
- cvt(libc::socketpair(fam, ty, 0, fds.as_mut_ptr()))?;
- let a = FileDesc::new(fds[0]);
- let b = FileDesc::new(fds[1]);
- a.set_cloexec()?;
- b.set_cloexec()?;
- Ok((Socket(a), Socket(b)))
- }
- }
- pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> {
- self.set_nonblocking(true)?;
- let r = unsafe {
- let (addrp, len) = addr.into_inner();
- cvt(libc::connect(self.0.raw(), addrp, len))
- };
- self.set_nonblocking(false)?;
- match r {
- Ok(_) => return Ok(()),
- // there's no ErrorKind for EINPROGRESS :(
- Err(ref e) if e.raw_os_error() == Some(libc::EINPROGRESS) => {}
- Err(e) => return Err(e),
- }
- 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"));
- }
- let start = Instant::now();
- loop {
- let elapsed = start.elapsed();
- if elapsed >= timeout {
- return Err(io::Error::new(io::ErrorKind::TimedOut, "connection timed out"));
- }
- let timeout = timeout - elapsed;
- let mut timeout = timeout.as_secs()
- .saturating_mul(1_000)
- .saturating_add(timeout.subsec_nanos() as u64 / 1_000_000);
- if timeout == 0 {
- timeout = 1;
- }
- let timeout = cmp::min(timeout, c_int::max_value() as u64) as c_int;
- match unsafe { libc::poll(&mut pollfd, 1, timeout) } {
- -1 => {
- let err = io::Error::last_os_error();
- if err.kind() != io::ErrorKind::Interrupted {
- return Err(err);
- }
- }
- 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")
- });
- return Err(e);
- }
- return Ok(());
- }
- }
- }
- }
- 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.
- if cfg!(target_os = "linux") {
- weak! {
- fn accept4(c_int, *mut sockaddr, *mut socklen_t, c_int) -> c_int
- }
- if let Some(accept) = accept4.get() {
- let res = cvt_r(|| unsafe {
- accept(self.0.raw(), storage, len, SOCK_CLOEXEC)
- });
- match res {
- Ok(fd) => return Ok(Socket(FileDesc::new(fd))),
- Err(ref e) if e.raw_os_error() == Some(libc::ENOSYS) => {}
- Err(e) => return Err(e),
- }
- }
- }
- let fd = cvt_r(|| unsafe {
- libc::accept(self.0.raw(), storage, len)
- })?;
- let fd = FileDesc::new(fd);
- fd.set_cloexec()?;
- Ok(Socket(fd))
- }
- pub fn duplicate(&self) -> io::Result<Socket> {
- self.0.duplicate().map(Socket)
- }
- 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)
- })?;
- Ok(ret as usize)
- }
- pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
- self.recv_with_flags(buf, 0)
- }
- pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
- self.recv_with_flags(buf, MSG_PEEK)
- }
- 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)
- })?;
- Ok((n as usize, sockaddr_to_addr(&storage, addrlen as usize)?))
- }
- pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
- self.recv_from_with_flags(buf, 0)
- }
- pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
- self.recv_from_with_flags(buf, MSG_PEEK)
- }
- pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
- self.0.write(buf)
- }
- pub fn set_timeout(&self, dur: Option<Duration>, kind: libc::c_int) -> io::Result<()> {
- 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"));
- }
- let secs = if dur.as_secs() > libc::time_t::max_value() as u64 {
- libc::time_t::max_value()
- } else {
- dur.as_secs() as libc::time_t
- };
- let mut timeout = libc::timeval {
- tv_sec: secs,
- tv_usec: (dur.subsec_nanos() / 1000) as libc::suseconds_t,
- };
- if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
- timeout.tv_usec = 1;
- }
- timeout
- }
- None => {
- libc::timeval {
- tv_sec: 0,
- tv_usec: 0,
- }
- }
- };
- setsockopt(self, libc::SOL_SOCKET, kind, timeout)
- }
- pub fn timeout(&self, kind: libc::c_int) -> io::Result<Option<Duration>> {
- let raw: libc::timeval = getsockopt(self, libc::SOL_SOCKET, kind)?;
- if raw.tv_sec == 0 && raw.tv_usec == 0 {
- Ok(None)
- } else {
- let sec = raw.tv_sec as u64;
- let nsec = (raw.tv_usec as u32) * 1000;
- Ok(Some(Duration::new(sec, nsec)))
- }
- }
- pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
- let how = match how {
- Shutdown::Write => libc::SHUT_WR,
- Shutdown::Read => libc::SHUT_RD,
- Shutdown::Both => libc::SHUT_RDWR,
- };
- cvt(unsafe { libc::shutdown(self.0.raw(), how) })?;
- Ok(())
- }
- pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
- setsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY, nodelay as c_int)
- }
- pub fn nodelay(&self) -> io::Result<bool> {
- let raw: c_int = getsockopt(self, libc::IPPROTO_TCP, libc::TCP_NODELAY)?;
- Ok(raw != 0)
- }
- pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
- let mut nonblocking = nonblocking as libc::c_int;
- cvt(unsafe { libc::ioctl(*self.as_inner(), libc::FIONBIO, &mut nonblocking) }).map(|_| ())
- }
- 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)))
- }
- }
- }
- impl AsInner<c_int> for Socket {
- 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)) }
- }
- impl IntoInner<c_int> for Socket {
- 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
- // will cache the contents of /etc/resolv.conf, so changes to that file on disk
- // can be ignored by a long-running program. That can break DNS lookups on e.g.
- // laptops where the network comes and goes. See
- // https://sourceware.org/bugzilla/show_bug.cgi?id=984. Note however that some
- // distros including Debian have patched glibc to fix this for a long time.
- //
- // A workaround for this bug is to call the res_init libc function, to clear
- // the cached configs. Unfortunately, while we believe glibc's implementation
- // of res_init is thread-safe, we know that other implementations are not
- // (https://github.com/rust-lang/rust/issues/43592). Code here in libstd could
- // try to synchronize its res_init calls with a Mutex, but that wouldn't
- // protect programs that call into libc in other ways. So instead of calling
- // res_init unconditionally, we call it only when we detect we're linking
- // against glibc version < 2.26. (That is, when we both know its needed and
- // believe it's thread-safe).
- #[cfg(target_env = "gnu")]
- fn on_resolver_failure() {
- use sys;
- // If the version fails to parse, we treat it the same as "not glibc".
- if let Some(version) = sys::os::glibc_version() {
- if version < (2, 26) {
- unsafe { libc::res_init() };
- }
- }
- }
- #[cfg(not(target_env = "gnu"))]
- fn on_resolver_failure() {}
- #[cfg(all(test, taget_env = "gnu"))]
- mod test {
- use super::*;
- #[test]
- fn test_res_init() {
- // This mostly just tests that the weak linkage doesn't panic wildly...
- res_init_if_glibc_before_2_26().unwrap();
- }
- #[test]
- fn test_parse_glibc_version() {
- let cases = [
- ("0.0", Some((0, 0))),
- ("01.+2", Some((1, 2))),
- ("3.4.5.six", Some((3, 4))),
- ("1", None),
- ("1.-2", None),
- ("1.foo", None),
- ("foo.1", None),
- ];
- for &(version_str, parsed) in cases.iter() {
- assert_eq!(parsed, parse_glibc_version(version_str));
- }
- }
- }