// Copyright 2015 The Rust Project Developers.

//

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or

// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license

// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your

// option. This file may not be copied, modified, or distributed

// except according to those terms.

use std::cmp::min;

use std::ffi::OsStr;

#[cfg(not(target_os = "redox"))]

use std::io::IoSlice;

use std::marker::PhantomData;

use std::mem::{self, size_of, MaybeUninit};

use std::net::Shutdown;

use std::net::{Ipv4Addr, Ipv6Addr};

#[cfg(all(

    feature = "all",

    any(

        target_os = "ios",

        target_os = "visionos",

        target_os = "macos",

        target_os = "tvos",

        target_os = "watchos",

        target_os = "illumos",

        target_os = "solaris",

        target_os = "linux",

        target_os = "android",

    )

))]

use std::num::NonZeroU32;

#[cfg(all(

    feature = "all",

    any(

        target_os = "aix",

        target_os = "android",

        target_os = "freebsd",

        target_os = "ios",

        target_os = "visionos",

        target_os = "linux",

        target_os = "macos",

        target_os = "tvos",

        target_os = "watchos",

    )

))]

use std::num::NonZeroUsize;

use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};

use std::os::unix::ffi::OsStrExt;

#[cfg(feature = "all")]

use std::os::unix::net::{UnixDatagram, UnixListener, UnixStream};

use std::path::Path;

use std::ptr;

use std::time::{Duration, Instant};

use std::{io, slice};

#[cfg(not(any(

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "tvos",

    target_os = "watchos",

    target_os = "cygwin",

)))]

use libc::ssize_t;

use libc::{in6_addr, in_addr};

use crate::{Domain, Protocol, SockAddr, SockAddrStorage, TcpKeepalive, Type};

#[cfg(not(target_os = "redox"))]

use crate::{MsgHdr, MsgHdrMut, RecvFlags};

pub(crate) use std::ffi::c_int;

// Used in `Domain`.

pub(crate) use libc::{AF_INET, AF_INET6, AF_UNIX};

// Used in `Type`.

#[cfg(all(feature = "all", target_os = "linux"))]

pub(crate) use libc::SOCK_DCCP;

#[cfg(all(feature = "all", not(any(target_os = "redox", target_os = "espidf"))))]

pub(crate) use libc::SOCK_RAW;

#[cfg(all(feature = "all", not(target_os = "espidf")))]

pub(crate) use libc::SOCK_SEQPACKET;

pub(crate) use libc::{SOCK_DGRAM, SOCK_STREAM};

// Used in `Protocol`.

#[cfg(all(feature = "all", target_os = "linux"))]

pub(crate) use libc::IPPROTO_DCCP;

#[cfg(target_os = "linux")]

pub(crate) use libc::IPPROTO_MPTCP;

#[cfg(all(feature = "all", any(target_os = "freebsd", target_os = "linux")))]

pub(crate) use libc::IPPROTO_SCTP;

#[cfg(all(

    feature = "all",

    any(

        target_os = "android",

        target_os = "freebsd",

        target_os = "fuchsia",

        target_os = "linux",

    )

))]

pub(crate) use libc::IPPROTO_UDPLITE;

pub(crate) use libc::{IPPROTO_ICMP, IPPROTO_ICMPV6, IPPROTO_TCP, IPPROTO_UDP};

// Used in `SockAddr`.

#[cfg(all(feature = "all", any(target_os = "freebsd", target_os = "openbsd")))]

pub(crate) use libc::IPPROTO_DIVERT;

pub(crate) use libc::{

    sa_family_t, sockaddr, sockaddr_in, sockaddr_in6, sockaddr_storage, socklen_t,

};

// Used in `RecvFlags`.

#[cfg(not(any(target_os = "redox", target_os = "espidf")))]

pub(crate) use libc::MSG_TRUNC;

#[cfg(not(target_os = "redox"))]

pub(crate) use libc::SO_OOBINLINE;

// Used in `Socket`.

#[cfg(not(target_os = "nto"))]

pub(crate) use libc::ipv6_mreq as Ipv6Mreq;

#[cfg(all(feature = "all", target_os = "linux"))]

pub(crate) use libc::IPV6_HDRINCL;

#[cfg(all(

    feature = "all",

    not(any(

        target_os = "dragonfly",

        target_os = "fuchsia",

        target_os = "hurd",

        target_os = "illumos",

        target_os = "netbsd",

        target_os = "openbsd",

        target_os = "redox",

        target_os = "solaris",

        target_os = "haiku",

        target_os = "espidf",

        target_os = "vita",

        target_os = "cygwin",

    ))

))]

pub(crate) use libc::IPV6_RECVHOPLIMIT;

#[cfg(not(any(

    target_os = "dragonfly",

    target_os = "fuchsia",

    target_os = "hurd",

    target_os = "illumos",

    target_os = "netbsd",

    target_os = "openbsd",

    target_os = "redox",

    target_os = "solaris",

    target_os = "haiku",

    target_os = "espidf",

    target_os = "vita",

)))]

pub(crate) use libc::IPV6_RECVTCLASS;

#[cfg(all(feature = "all", not(any(target_os = "redox", target_os = "espidf"))))]

pub(crate) use libc::IP_HDRINCL;

#[cfg(not(any(

    target_os = "aix",

    target_os = "dragonfly",

    target_os = "fuchsia",

    target_os = "illumos",

    target_os = "netbsd",

    target_os = "openbsd",

    target_os = "redox",

    target_os = "solaris",

    target_os = "haiku",

    target_os = "hurd",

    target_os = "nto",

    target_os = "espidf",

    target_os = "vita",

    target_os = "cygwin",

)))]

pub(crate) use libc::IP_RECVTOS;

#[cfg(not(any(

    target_os = "fuchsia",

    target_os = "redox",

    target_os = "solaris",

    target_os = "haiku",

    target_os = "illumos",

)))]

pub(crate) use libc::IP_TOS;

#[cfg(not(any(

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "tvos",

    target_os = "watchos",

)))]

pub(crate) use libc::SO_LINGER;

#[cfg(any(

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "tvos",

    target_os = "watchos",

))]

pub(crate) use libc::SO_LINGER_SEC as SO_LINGER;

#[cfg(any(target_os = "linux", target_os = "cygwin"))]

pub(crate) use libc::SO_PASSCRED;

#[cfg(all(

    feature = "all",

    any(target_os = "linux", target_os = "android", target_os = "fuchsia")

))]

pub(crate) use libc::SO_PRIORITY;

pub(crate) use libc::{

    ip_mreq as IpMreq, linger, IPPROTO_IP, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF,

    IPV6_MULTICAST_LOOP, IPV6_UNICAST_HOPS, IPV6_V6ONLY, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP,

    IP_MULTICAST_IF, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TTL, MSG_OOB, MSG_PEEK, SOL_SOCKET,

    SO_BROADCAST, SO_ERROR, SO_KEEPALIVE, SO_RCVBUF, SO_RCVTIMEO, SO_REUSEADDR, SO_SNDBUF,

    SO_SNDTIMEO, SO_TYPE, TCP_NODELAY,

};

#[cfg(not(any(

    target_os = "dragonfly",

    target_os = "haiku",

    target_os = "hurd",

    target_os = "netbsd",

    target_os = "openbsd",

    target_os = "redox",

    target_os = "fuchsia",

    target_os = "nto",

    target_os = "espidf",

    target_os = "vita",

)))]

pub(crate) use libc::{

    ip_mreq_source as IpMreqSource, IP_ADD_SOURCE_MEMBERSHIP, IP_DROP_SOURCE_MEMBERSHIP,

};

#[cfg(not(any(

    target_os = "dragonfly",

    target_os = "freebsd",

    target_os = "haiku",

    target_os = "illumos",

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "netbsd",

    target_os = "nto",

    target_os = "openbsd",

    target_os = "solaris",

    target_os = "tvos",

    target_os = "watchos",

)))]

pub(crate) use libc::{IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP};

#[cfg(any(

    target_os = "dragonfly",

    target_os = "freebsd",

    target_os = "haiku",

    target_os = "illumos",

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "netbsd",

    target_os = "openbsd",

    target_os = "solaris",

    target_os = "tvos",

    target_os = "watchos",

))]

pub(crate) use libc::{

    IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP, IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP,

};

#[cfg(all(

    feature = "all",

    any(

        target_os = "android",

        target_os = "dragonfly",

        target_os = "freebsd",

        target_os = "fuchsia",

        target_os = "illumos",

        target_os = "ios",

        target_os = "visionos",

        target_os = "linux",

        target_os = "macos",

        target_os = "netbsd",

        target_os = "tvos",

        target_os = "watchos",

        target_os = "cygwin",

    )

))]

pub(crate) use libc::{TCP_KEEPCNT, TCP_KEEPINTVL};

// See this type in the Windows file.

pub(crate) type Bool = c_int;

#[cfg(any(

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "nto",

    target_os = "tvos",

    target_os = "watchos",

))]

use libc::TCP_KEEPALIVE as KEEPALIVE_TIME;

#[cfg(not(any(

    target_os = "haiku",

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "nto",

    target_os = "openbsd",

    target_os = "tvos",

    target_os = "watchos",

    target_os = "vita",

)))]

use libc::TCP_KEEPIDLE as KEEPALIVE_TIME;

/// Helper macro to execute a system call that returns an `io::Result`.

macro_rules! syscall {

    ($fn: ident ( $($arg: expr),* $(,)* ) ) => {{

        #[allow(unused_unsafe)]

        let res = unsafe { libc::$fn($($arg, )*) };

        if res == -1 {

            Err(std::io::Error::last_os_error())

        } else {

            Ok(res)

        }

    }};

}

/// Maximum size of a buffer passed to system call like `recv` and `send`.

#[cfg(not(any(

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "tvos",

    target_os = "watchos",

    target_os = "cygwin",

)))]

const MAX_BUF_LEN: usize = ssize_t::MAX as usize;

// The maximum read limit on most posix-like systems is `SSIZE_MAX`, with the

// man page quoting that if the count of bytes to read is greater than

// `SSIZE_MAX` the result is "unspecified".

//

// On macOS, however, apparently the 64-bit libc is either buggy or

// intentionally showing odd behavior by rejecting any read with a size larger

// than or equal to INT_MAX. To handle both of these the read size is capped on

// both platforms.

#[cfg(any(

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "tvos",

    target_os = "watchos",

    target_os = "cygwin",

))]

const MAX_BUF_LEN: usize = c_int::MAX as usize - 1;

// TCP_CA_NAME_MAX isn't defined in user space include files(not in libc)

#[cfg(all(feature = "all", any(target_os = "freebsd", target_os = "linux")))]

const TCP_CA_NAME_MAX: usize = 16;

#[cfg(any(

    all(

        target_os = "linux",

        any(

            target_env = "gnu",

            all(target_env = "uclibc", target_pointer_width = "64")

        )

    ),

    target_os = "android",

))]

type IovLen = usize;

#[cfg(any(

    all(

        target_os = "linux",

        any(

            target_env = "musl",

            target_env = "ohos",

            all(target_env = "uclibc", target_pointer_width = "32")

        )

    ),

    target_os = "aix",

    target_os = "dragonfly",

    target_os = "freebsd",

    target_os = "fuchsia",

    target_os = "haiku",

    target_os = "hurd",

    target_os = "illumos",

    target_os = "ios",

    target_os = "visionos",

    target_os = "macos",

    target_os = "netbsd",

    target_os = "nto",

    target_os = "openbsd",

    target_os = "solaris",

    target_os = "tvos",

    target_os = "watchos",

    target_os = "espidf",

    target_os = "vita",

    target_os = "cygwin",

))]

type IovLen = c_int;

/// Unix only API.

impl Domain {

    /// Domain for low-level packet interface, corresponding to `AF_PACKET`.

    #[cfg(all(

        feature = "all",

        any(target_os = "android", target_os = "fuchsia", target_os = "linux")

    ))]

    pub const PACKET: Domain = Domain(libc::AF_PACKET);

    /// Domain for low-level VSOCK interface, corresponding to `AF_VSOCK`.

    #[cfg(all(feature = "all", any(target_os = "android", target_os = "linux")))]

    pub const VSOCK: Domain = Domain(libc::AF_VSOCK);

}

impl_debug!(

    Domain,

    libc::AF_INET,

    libc::AF_INET6,

    libc::AF_UNIX,

    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]

    libc::AF_PACKET,

    #[cfg(any(target_os = "android", target_os = "linux"))]

    libc::AF_VSOCK,

    libc::AF_UNSPEC, // = 0.

);

/// Unix only API.

impl Type {

    /// Set `SOCK_NONBLOCK` on the `Type`.

    #[cfg(all(

        feature = "all",

        any(

            target_os = "android",

            target_os = "dragonfly",

            target_os = "freebsd",

            target_os = "fuchsia",

            target_os = "illumos",

            target_os = "linux",

            target_os = "netbsd",

            target_os = "openbsd",

            target_os = "cygwin",

        )

    ))]

    pub const fn nonblocking(self) -> Type {

        Type(self.0 | libc::SOCK_NONBLOCK)

    }

    /// Set `SOCK_CLOEXEC` on the `Type`.

    #[cfg(all(

        feature = "all",

        any(

            target_os = "android",

            target_os = "dragonfly",

            target_os = "freebsd",

            target_os = "fuchsia",

            target_os = "hurd",

            target_os = "illumos",

            target_os = "linux",

            target_os = "netbsd",

            target_os = "openbsd",

            target_os = "redox",

            target_os = "solaris",

            target_os = "cygwin",

        )

    ))]

    pub const fn cloexec(self) -> Type {

        self._cloexec()

    }

    #[cfg(any(

        target_os = "android",

        target_os = "dragonfly",

        target_os = "freebsd",

        target_os = "fuchsia",

        target_os = "hurd",

        target_os = "illumos",

        target_os = "linux",

        target_os = "netbsd",

        target_os = "openbsd",

        target_os = "redox",

        target_os = "solaris",

        target_os = "cygwin",

    ))]

    pub(crate) const fn _cloexec(self) -> Type {

        Type(self.0 | libc::SOCK_CLOEXEC)

    }

}

impl_debug!(

    Type,

    libc::SOCK_STREAM,

    libc::SOCK_DGRAM,

    #[cfg(all(feature = "all", target_os = "linux"))]

    libc::SOCK_DCCP,

    #[cfg(not(any(target_os = "redox", target_os = "espidf")))]

    libc::SOCK_RAW,

    #[cfg(not(any(target_os = "redox", target_os = "haiku", target_os = "espidf")))]

    libc::SOCK_RDM,

    #[cfg(not(target_os = "espidf"))]

    libc::SOCK_SEQPACKET,

    /* TODO: add these optional bit OR-ed flags:

    #[cfg(any(

        target_os = "android",

        target_os = "dragonfly",

        target_os = "freebsd",

        target_os = "fuchsia",

        target_os = "linux",

        target_os = "netbsd",

        target_os = "openbsd"

    ))]

    libc::SOCK_NONBLOCK,

    #[cfg(any(

        target_os = "android",

        target_os = "dragonfly",

        target_os = "freebsd",

        target_os = "fuchsia",

        target_os = "linux",

        target_os = "netbsd",

        target_os = "openbsd"

    ))]

    libc::SOCK_CLOEXEC,

    */

);

impl_debug!(

    Protocol,

    libc::IPPROTO_ICMP,

    libc::IPPROTO_ICMPV6,

    libc::IPPROTO_TCP,

    libc::IPPROTO_UDP,

    #[cfg(target_os = "linux")]

    libc::IPPROTO_MPTCP,

    #[cfg(all(feature = "all", target_os = "linux"))]

    libc::IPPROTO_DCCP,

    #[cfg(all(feature = "all", any(target_os = "freebsd", target_os = "linux")))]

    libc::IPPROTO_SCTP,

    #[cfg(all(

        feature = "all",

        any(

            target_os = "android",

            target_os = "freebsd",

            target_os = "fuchsia",

            target_os = "linux",

        )

    ))]

    libc::IPPROTO_UDPLITE,

    #[cfg(all(feature = "all", any(target_os = "freebsd", target_os = "openbsd")))]

    libc::IPPROTO_DIVERT,

);

/// Unix-only API.

#[cfg(not(target_os = "redox"))]

impl RecvFlags {

    /// Check if the message terminates a record.

    ///

    /// Not all socket types support the notion of records. For socket types

    /// that do support it (such as [`SEQPACKET`]), a record is terminated by

    /// sending a message with the end-of-record flag set.

    ///

    /// On Unix this corresponds to the `MSG_EOR` flag.

    ///

    /// [`SEQPACKET`]: Type::SEQPACKET

    #[cfg(not(target_os = "espidf"))]

    pub const fn is_end_of_record(self) -> bool {

        self.0 & libc::MSG_EOR != 0

    }

    /// Check if the message contains out-of-band data.

    ///

    /// This is useful for protocols where you receive out-of-band data

    /// mixed in with the normal data stream.

    ///

    /// On Unix this corresponds to the `MSG_OOB` flag.

    pub const fn is_out_of_band(self) -> bool {

        self.0 & libc::MSG_OOB != 0

    }

    /// Check if the confirm flag is set.

    ///

    /// This is used by SocketCAN to indicate a frame was sent via the

    /// socket it is received on. This flag can be interpreted as a

    /// 'transmission confirmation'.

    ///

    /// On Unix this corresponds to the `MSG_CONFIRM` flag.

    #[cfg(all(feature = "all", any(target_os = "android", target_os = "linux")))]

    pub const fn is_confirm(self) -> bool {

        self.0 & libc::MSG_CONFIRM != 0

    }

    /// Check if the don't route flag is set.

    ///

    /// This is used by SocketCAN to indicate a frame was created

    /// on the local host.

    ///

    /// On Unix this corresponds to the `MSG_DONTROUTE` flag.

    #[cfg(all(

        feature = "all",

        any(target_os = "android", target_os = "linux", target_os = "cygwin"),

    ))]

    pub const fn is_dontroute(self) -> bool {

        self.0 & libc::MSG_DONTROUTE != 0

    }

}

#[cfg(not(target_os = "redox"))]

impl std::fmt::Debug for RecvFlags {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        let mut s = f.debug_struct("RecvFlags");

        #[cfg(not(target_os = "espidf"))]

        s.field("is_end_of_record", &self.is_end_of_record());

        s.field("is_out_of_band", &self.is_out_of_band());

        #[cfg(not(target_os = "espidf"))]

        s.field("is_truncated", &self.is_truncated());

        #[cfg(all(feature = "all", any(target_os = "android", target_os = "linux")))]

        s.field("is_confirm", &self.is_confirm());

        #[cfg(all(

            feature = "all",

            any(target_os = "android", target_os = "linux", target_os = "cygwin"),

        ))]

        s.field("is_dontroute", &self.is_dontroute());

        s.finish()

    }

}

#[repr(transparent)]

pub struct MaybeUninitSlice<'a> {

    vec: libc::iovec,

    _lifetime: PhantomData<&'a mut [MaybeUninit<u8>]>,

}

unsafe impl<'a> Send for MaybeUninitSlice<'a> {}

unsafe impl<'a> Sync for MaybeUninitSlice<'a> {}

impl<'a> MaybeUninitSlice<'a> {

    pub(crate) fn new(buf: &'a mut [MaybeUninit<u8>]) -> MaybeUninitSlice<'a> {

        MaybeUninitSlice {

            vec: libc::iovec {

                iov_base: buf.as_mut_ptr().cast(),

                iov_len: buf.len(),

            },

            _lifetime: PhantomData,

        }

    }

    pub(crate) fn as_slice(&self) -> &[MaybeUninit<u8>] {

        unsafe { slice::from_raw_parts(self.vec.iov_base.cast(), self.vec.iov_len) }

    }

    pub(crate) fn as_mut_slice(&mut self) -> &mut [MaybeUninit<u8>] {

        unsafe { slice::from_raw_parts_mut(self.vec.iov_base.cast(), self.vec.iov_len) }

    }

}

/// Returns the offset of the `sun_path` member of the passed unix socket address.

pub(crate) fn offset_of_path(storage: &libc::sockaddr_un) -> usize {

    let base = storage as *const _ as usize;

    let path = ptr::addr_of!(storage.sun_path) as usize;

    path - base

}

#[allow(unsafe_op_in_unsafe_fn)]

pub(crate) fn unix_sockaddr(path: &Path) -> io::Result<SockAddr> {

    let mut storage = SockAddrStorage::zeroed();

    let len = {

        // SAFETY: sockaddr_un is one of the sockaddr_* types defined by this platform.

        let storage = unsafe { storage.view_as::<libc::sockaddr_un>() };

        let bytes = path.as_os_str().as_bytes();

        let too_long = match bytes.first() {

            None => false,

            // linux abstract namespaces aren't null-terminated

            Some(&0) => bytes.len() > storage.sun_path.len(),

            Some(_) => bytes.len() >= storage.sun_path.len(),

        };

        if too_long {

            return Err(io::Error::new(

                io::ErrorKind::InvalidInput,

                "path must be shorter than SUN_LEN",

            ));

        }

        storage.sun_family = libc::AF_UNIX as sa_family_t;

        // SAFETY: `bytes` and `addr.sun_path` are not overlapping and

        // both point to valid memory.

        // `storage` was initialized to zero above, so the path is

        // already NULL terminated.

        unsafe {

            ptr::copy_nonoverlapping(

                bytes.as_ptr(),

                storage.sun_path.as_mut_ptr().cast(),

                bytes.len(),

            );

        }

        let sun_path_offset = offset_of_path(storage);

        sun_path_offset

            + bytes.len()

            + match bytes.first() {

                Some(&0) | None => 0,

                Some(_) => 1,

            }

    };

    Ok(unsafe { SockAddr::new(storage, len as socklen_t) })

}

// Used in `MsgHdr`.

#[cfg(not(target_os = "redox"))]

pub(crate) use libc::msghdr;

#[cfg(not(target_os = "redox"))]

pub(crate) fn set_msghdr_name(msg: &mut msghdr, name: &SockAddr) {

    msg.msg_name = name.as_ptr() as *mut _;

    msg.msg_namelen = name.len();

}

#[cfg(not(target_os = "redox"))]

#[allow(clippy::unnecessary_cast)] // IovLen type can be `usize`.

pub(crate) fn set_msghdr_iov(msg: &mut msghdr, ptr: *mut libc::iovec, len: usize) {

    msg.msg_iov = ptr;

    msg.msg_iovlen = min(len, IovLen::MAX as usize) as IovLen;

}

#[cfg(not(target_os = "redox"))]

pub(crate) fn set_msghdr_control(msg: &mut msghdr, ptr: *mut libc::c_void, len: usize) {

    msg.msg_control = ptr;

    msg.msg_controllen = len as _;

}

#[cfg(not(target_os = "redox"))]

pub(crate) fn set_msghdr_flags(msg: &mut msghdr, flags: c_int) {

    msg.msg_flags = flags;

}

#[cfg(not(target_os = "redox"))]

pub(crate) fn msghdr_flags(msg: &msghdr) -> RecvFlags {

    RecvFlags(msg.msg_flags)

}

#[cfg(not(target_os = "redox"))]

pub(crate) fn msghdr_control_len(msg: &msghdr) -> usize {

    msg.msg_controllen as _

}

/// Unix only API.

impl SockAddr {

    /// Constructs a `SockAddr` with the family `AF_VSOCK` and the provided CID/port.

    ///

    /// # Errors

    ///

    /// This function can never fail. In a future version of this library it will be made

    /// infallible.

    #[allow(unsafe_op_in_unsafe_fn)]

    #[cfg(all(feature = "all", any(target_os = "android", target_os = "linux")))]

    pub fn vsock(cid: u32, port: u32) -> SockAddr {

        let mut storage = SockAddrStorage::zeroed();

        {

            // SAFETY: sockaddr_vm is one of the sockaddr_* types defined by this platform.

            let storage = unsafe { storage.view_as::<libc::sockaddr_vm>() };

            storage.svm_family = libc::AF_VSOCK as sa_family_t;

            storage.svm_cid = cid;

            storage.svm_port = port;

        }

        unsafe { SockAddr::new(storage, mem::size_of::<libc::sockaddr_vm>() as socklen_t) }

    }

    /// Returns this address VSOCK CID/port if it is in the `AF_VSOCK` family,

    /// otherwise return `None`.

    #[cfg(all(feature = "all", any(target_os = "android", target_os = "linux")))]

    pub fn as_vsock_address(&self) -> Option<(u32, u32)> {

        if self.family() == libc::AF_VSOCK as sa_family_t {

            // Safety: if the ss_family field is AF_VSOCK then storage must be a sockaddr_vm.

            let addr = unsafe { &*(self.as_ptr() as *const libc::sockaddr_vm) };

            Some((addr.svm_cid, addr.svm_port))

        } else {

            None

        }

    }

    /// Returns true if this address is an unnamed address from the `AF_UNIX` family (for local

    /// interprocess communication), false otherwise.

    pub fn is_unnamed(&self) -> bool {

        self.as_sockaddr_un()

            .map(|storage| {

                self.len() == offset_of_path(storage) as _

                    // On some non-linux platforms a zeroed path is returned for unnamed.

                    // Abstract addresses only exist on Linux.

                    // NOTE: although Fuchsia does define `AF_UNIX` it's not actually implemented.

                    // See https://github.com/rust-lang/socket2/pull/403#discussion_r1123557978

                    || (cfg!(not(any(target_os = "linux", target_os = "android", target_os = "cygwin")))

                    && storage.sun_path[0] == 0)

            })

            .unwrap_or_default()

    }

    /// Returns the underlying `sockaddr_un` object if this addres is from the `AF_UNIX` family,

    /// otherwise returns `None`.

    pub(crate) fn as_sockaddr_un(&self) -> Option<&libc::sockaddr_un> {

        self.is_unix().then(|| {

            // SAFETY: if unix socket, i.e. the `ss_family` field is `AF_UNIX` then storage must be

            // a `sockaddr_un`.

            unsafe { &*self.as_ptr().cast::<libc::sockaddr_un>() }

        })

    }

    /// Get the length of the path bytes of the address, not including the terminating or initial

    /// (for abstract names) null byte.

    ///

    /// Should not be called on unnamed addresses.

    fn path_len(&self, storage: &libc::sockaddr_un) -> usize {

        debug_assert!(!self.is_unnamed());

        self.len() as usize - offset_of_path(storage) - 1

    }

    /// Get a u8 slice for the bytes of the pathname or abstract name.

    ///

    /// Should not be called on unnamed addresses.

    fn path_bytes(&self, storage: &libc::sockaddr_un, abstract_name: bool) -> &[u8] {

        debug_assert!(!self.is_unnamed());

        // SAFETY: the pointed objects of type `i8` have the same memory layout as `u8`. The path is

        // the last field in the storage and so its length is equal to

        //          TOTAL_LENGTH - OFFSET_OF_PATH -1

        // Where the 1 is either a terminating null if we have a pathname address, or the initial

        // null byte, if it's an abstract name address. In the latter case, the path bytes start

        // after the initial null byte, hence the `offset`.

        // There is no safe way to convert a `&[i8]` to `&[u8]`

        unsafe {

            slice::from_raw_parts(

                (storage.sun_path.as_ptr() as *const u8).offset(abstract_name as isize),

                self.path_len(storage),

            )

        }

    }

    /// Returns this address as Unix `SocketAddr` if it is an `AF_UNIX` pathname

    /// address, otherwise returns `None`.

    pub fn as_unix(&self) -> Option<std::os::unix::net::SocketAddr> {

        let path = self.as_pathname()?;

        // SAFETY: we can represent this as a valid pathname, then so can the

        // standard library.

        Some(std::os::unix::net::SocketAddr::from_pathname(path).unwrap())

    }

    /// Returns this address as a `Path` reference if it is an `AF_UNIX`

    /// pathname address, otherwise returns `None`.

    pub fn as_pathname(&self) -> Option<&Path> {

        self.as_sockaddr_un().and_then(|storage| {

            (self.len() > offset_of_path(storage) as _ && storage.sun_path[0] != 0).then(|| {

                let path_slice = self.path_bytes(storage, false);

                Path::new::<OsStr>(OsStrExt::from_bytes(path_slice))

            })

        })

    }

    /// Returns this address as a slice of bytes representing an abstract address if it is an

    /// `AF_UNIX` abstract address, otherwise returns `None`.

    ///

    /// Abstract addresses are a Linux extension, so this method returns `None` on all non-Linux

    /// platforms.

    pub fn as_abstract_namespace(&self) -> Option<&[u8]> {

        // NOTE: although Fuchsia does define `AF_UNIX` it's not actually implemented.

        // See https://github.com/rust-lang/socket2/pull/403#discussion_r1123557978

        #[cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin"))]

        {

            self.as_sockaddr_un().and_then(|storage| {

                (self.len() > offset_of_path(storage) as _ && storage.sun_path[0] == 0)

                    .then(|| self.path_bytes(storage, true))

            })

        }

        #[cfg(not(any(target_os = "linux", target_os = "android", target_os = "cygwin")))]

        None

    }

}

pub(crate) type Socket = std::os::fd::OwnedFd;

pub(crate) type RawSocket = c_int;

pub(crate) unsafe fn socket_from_raw(socket: RawSocket) -> Socket {

    Socket::from_raw_fd(socket)

}

pub(crate) fn socket_as_raw(socket: &Socket) -> RawSocket {

    socket.as_raw_fd()

}

pub(crate) fn socket_into_raw(socket: Socket) -> RawSocket {

    socket.into_raw_fd()

}

pub(crate) fn socket(family: c_int, ty: c_int, protocol: c_int) -> io::Result<RawSocket> {

    syscall!(socket(family, ty, protocol))

}

#[cfg(all(feature = "all", unix))]

pub(crate) fn socketpair(family: c_int, ty: c_int, protocol: c_int) -> io::Result<[RawSocket; 2]> {

    let mut fds = [0, 0];

    syscall!(socketpair(family, ty, protocol, fds.as_mut_ptr())).map(|_| fds)

}

pub(crate) fn bind(fd: RawSocket, addr: &SockAddr) -> io::Result<()> {

    syscall!(bind(fd, addr.as_ptr().cast::<sockaddr>(), addr.len() as _)).map(|_| ())

}

pub(crate) fn connect(fd: RawSocket, addr: &SockAddr) -> io::Result<()> {

    syscall!(connect(fd, addr.as_ptr().cast::<sockaddr>(), addr.len())).map(|_| ())

}

pub(crate) fn poll_connect(socket: &crate::Socket, timeout: Duration) -> io::Result<()> {

    let start = Instant::now();

    let mut pollfd = libc::pollfd {

        fd: socket.as_raw(),

        events: libc::POLLIN | libc::POLLOUT,

        revents: 0,

    };

    loop {

        let elapsed = start.elapsed();

        if elapsed >= timeout {

            return Err(io::ErrorKind::TimedOut.into());

        }

        let timeout = (timeout - elapsed).as_millis();

        let timeout = timeout.clamp(1, c_int::MAX as u128) as c_int;

        match syscall!(poll(&mut pollfd, 1, timeout)) {

            Ok(0) => return Err(io::ErrorKind::TimedOut.into()),

            Ok(_) => {

                // Error or hang up indicates an error (or failure to connect).

                if (pollfd.revents & libc::POLLHUP) != 0 || (pollfd.revents & libc::POLLERR) != 0 {

                    match socket.take_error() {

                        Ok(Some(err)) | Err(err) => return Err(err),

                        Ok(None) => {

                            return Err(io::Error::new(

                                io::ErrorKind::Other,

                                "no error set after POLLHUP",

                            ))

                        }

                    }

                }

                return Ok(());

            }

            // Got interrupted, try again.

            Err(ref err) if err.kind() == io::ErrorKind::Interrupted => continue,

            Err(err) => return Err(err),

        }

    }

}

pub(crate) fn listen(fd: RawSocket, backlog: c_int) -> io::Result<()> {

    syscall!(listen(fd, backlog)).map(|_| ())

}

pub(crate) fn accept(fd: RawSocket) -> io::Result<(RawSocket, SockAddr)> {

    // Safety: `accept` initialises the `SockAddr` for us.

    unsafe { SockAddr::try_init(|storage, len| syscall!(accept(fd, storage.cast(), len))) }

}

pub(crate) fn getsockname(fd: RawSocket) -> io::Result<SockAddr> {

    // Safety: `accept` initialises the `SockAddr` for us.

    unsafe { SockAddr::try_init(|storage, len| syscall!(getsockname(fd, storage.cast(), len))) }

        .map(|(_, addr)| addr)

}

pub(crate) fn getpeername(fd: RawSocket) -> io::Result<SockAddr> {

    // Safety: `accept` initialises the `SockAddr` for us.

    unsafe { SockAddr::try_init(|storage, len| syscall!(getpeername(fd, storage.cast(), len))) }

        .map(|(_, addr)| addr)

}

pub(crate) fn try_clone(fd: RawSocket) -> io::Result<RawSocket> {

    syscall!(fcntl(fd, libc::F_DUPFD_CLOEXEC, 0))

}

#[cfg(all(feature = "all", unix, not(target_os = "vita")))]

pub(crate) fn nonblocking(fd: RawSocket) -> io::Result<bool> {

    let file_status_flags = fcntl_get(fd, libc::F_GETFL)?;

    Ok((file_status_flags & libc::O_NONBLOCK) != 0)

}

#[cfg(all(feature = "all", target_os = "vita"))]

pub(crate) fn nonblocking(fd: RawSocket) -> io::Result<bool> {

    unsafe {

        getsockopt::<Bool>(fd, libc::SOL_SOCKET, libc::SO_NONBLOCK).map(|non_block| non_block != 0)

    }

}

#[cfg(not(target_os = "vita"))]

pub(crate) fn set_nonblocking(fd: RawSocket, nonblocking: bool) -> io::Result<()> {

    if nonblocking {

        fcntl_add(fd, libc::F_GETFL, libc::F_SETFL, libc::O_NONBLOCK)

    } else {

        fcntl_remove(fd, libc::F_GETFL, libc::F_SETFL, libc::O_NONBLOCK)

    }

}

#[cfg(target_os = "vita")]

pub(crate) fn set_nonblocking(fd: RawSocket, nonblocking: bool) -> io::Result<()> {

    unsafe {

        setsockopt(

            fd,

            libc::SOL_SOCKET,

            libc::SO_NONBLOCK,

            nonblocking as c_int,

        )

    }

}

pub(crate) fn shutdown(fd: RawSocket, how: Shutdown) -> io::Result<()> {

    let how = match how {

        Shutdown::Write => libc::SHUT_WR,

        Shutdown::Read => libc::SHUT_RD,

        Shutdown::Both => libc::SHUT_RDWR,

    };

    syscall!(shutdown(fd, how)).map(|_| ())

}

pub(crate) fn recv(fd: RawSocket, buf: &mut [MaybeUninit<u8>], flags: c_int) -> io::Result<usize> {

    syscall!(recv(

        fd,

        buf.as_mut_ptr().cast(),

        min(buf.len(), MAX_BUF_LEN),

        flags,

    ))

    .map(|n| n as usize)

}

pub(crate) fn recv_from(

    fd: RawSocket,

    buf: &mut [MaybeUninit<u8>],

    flags: c_int,

) -> io::Result<(usize, SockAddr)> {

    // Safety: `recvfrom` initialises the `SockAddr` for us.

    unsafe {

        SockAddr::try_init(|addr, addrlen| {

            syscall!(recvfrom(

                fd,

                buf.as_mut_ptr().cast(),

                min(buf.len(), MAX_BUF_LEN),

                flags,

                addr.cast(),

                addrlen

            ))

            .map(|n| n as usize)

        })

    }

}

pub(crate) fn peek_sender(fd: RawSocket) -> io::Result<SockAddr> {

    // Unix-like platforms simply truncate the returned data, so this implementation is trivial.

    // However, for Windows this requires suppressing the `WSAEMSGSIZE` error,

    // so that requires a different approach.

    // NOTE: macOS does not populate `sockaddr` if you pass a zero-sized buffer.

    let (_, sender) = recv_from(fd, &mut [MaybeUninit::uninit(); 8], MSG_PEEK)?;

    Ok(sender)

}