socket9 0.1.0-alpha.1

/*-
 * socket9 - A RAW networking sockets manipulation and configration basing on 
 * strong types.
 * 
 * Copyright (C) 2021 Aleksandr Morozov, Lucia Hoffmann
 * Copyright (C) 2025 Aleksandr Morozov
 * 
 * The syslog-rs crate can be redistributed and/or modified
 * under the terms of either of the following licenses:
 *
 *   1. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016 OR
 *
 *   2. the Mozilla Public License Version 2.0 (the “MPL”) OR
 *                     
 *   3. The MIT License (MIT)
 */

#[cfg(windows)]
use std::os::windows::io::OwnedSocket;

use std::
{
    fmt, 
    io::{self, ErrorKind, IoSlice, IoSliceMut}, 
    marker::PhantomData, 
    net::{Shutdown, SocketAddr, TcpListener, TcpStream, ToSocketAddrs, UdpSocket}, 
    time::Duration
};

#[cfg(unix)]
use std::os::
{
        fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, OwnedFd, RawFd}, 
        unix::net::{UnixDatagram, UnixListener, UnixStream}
};


#[cfg(unix)]
use uds_fork::{ UnixSeqpacketConn, UnixSeqpacketListener, nonblocking::UnixSeqpacketListener as NonBlkUnixSeqpacketListener };

#[cfg(windows)]
use uds_fork::{WindowsUnixListener, WindowsUnixStream};

#[cfg(unix)]
use crate::unix::
{
    So9DomainRange
};

#[cfg(windows)]
use crate::windows::
{
    So9DomainRange
};

use crate::
{   
    POLLIN, AsOsDescr, So9MsgFlags, So9SockDwFlags, So9SockType, So9SockProtocol, Socket9ExtIp, Socket9ExtIp6, Socket9ExtIpTcp, 
    Socket9ExtIpTcpExt, Socket9ExtSo, SocketTypeImps, 
    address::
    {
        IntoSockAddrSpec, So9AddrDomain, So9AddrIntoRaw
    }, 
    socket_split::{Socket9Read, Socket9Write} 
};

use crate::address::So9SocketAddr;




/// A `marker` which indicates that the implemented element is of type
/// unix socket. So, any operations like vectored send or which are
/// related to local sockets can be applied.
/// 
/// For example [UnixDatagram].
#[cfg(unix)]
pub trait So9MarkerSockUnix{}

/// A `marker` which indicates that the implemented element does not
/// track the state of connection i.e stateless like datagrams.
/// 
/// Covers operations like `peek_from` or `recv_from` including
/// vectored.
/// 
/// For exmaple [UnixDatagram] or [UdpSocket].
pub trait So9MarkerStateless{}

/// A `marker` which indicates that the implemented element can be
/// binded to address i.e a `bind()` can be used on socket.
pub trait So9MarkerBind{}

/// A `marker` which indicates that the implemented element can be
/// set to pasive mode and it is statefull like [UnixListener] or 
/// [TcpListener].
pub trait So9MarkerListener
{
    /// A default flags which are passed as argument in [libc::accept4].
    const SOCK_ACCEPT_FLAGS: i32;

    /// A returned type in case if `accept` was successfull i.e TcpListener
    /// returns TcpStream.
    type AcceptedType: So9Marker;
}

/// A `marker` which indicates that the implemented element can be
/// `paired` i.e produced a local pair i.e [UnixDatagram]. This is 
/// related to `unix` sockets.
/// 
/// A `unix` specific thing. `windows` does not provide this feature
/// in a way `unix` does.
#[cfg(unix)]
pub trait So9MarkerPairable
{
    /// Creates a paired connection. The function should return 
    /// two [OwnedFd] i.e enspoints with `cloexec` set.
    fn pair() -> io::Result<(OwnedFd, OwnedFd)> where Self: Sized;
}

/// A `marker` which indicates that the implemented element can be 
/// `paired`. This is a specific thing for Windows.
#[cfg(windows)]
pub trait So9MarkerPairableWin: So9Marker
{
    /// Creates a paired connection. The function should return 
    /// two `Self` instances i.e enspoints with `cloexec` set.
    fn pair() -> io::Result<(Socket9<Self>, Socket9<Self>)> where Self: Sized;
}

/// A main `marker` which indicates that the element is of networking
/// type and can be used with `socket9`.
pub trait So9Marker: fmt::Debug + From<Socket9<Self>>
{
    /// A So9 socket data type; For Unix it is `OwnedFd`, for Windows `OwnedSocket`.
    type SockType: SocketTypeImps;

    /// Tells if the implemented item is a passive/active socket.
    /// In other words if this const is set to `true` the socket can
    /// be used with `listen(4)` i.e can be switched to passive mode.
    const IS_LISTENING: bool;

    /// A socket `domain`. It does not set the exaxt domain of socket i.e (AF_UNIX), 
    /// but it sets the range, because [TcpListener] may be configured to 
    /// IP4/IP6, the domain is specified in ranges or a specific can be
    /// set. 
    const SO_DOMAIN_GROUP: So9DomainRange;

    /// A socket `type` i.e `SOCK_STREAM`.
    const SO_TYPE: So9SockType;

    /// An additional flags which are used during socket creation. This flags are
    /// passed either as a `dwflags` on `windows` for `WSASocketW` or as a additional 
    /// parameters for `socket(4)` in socket type. Usually this is a `CLOEXEC` or 
    /// `NO_INHERIT`.
    const SO_DEF_FLAGS: So9SockDwFlags;

    /// A socket `protocol` i.e `IPPROTO_ICMP`. On OSX has no effect.
    const SO_PROTO: So9SockProtocol;

    /// A default flags which are set as argument in functions like starting with
    /// prefix `send_` i.e `send_with`.
    const SOCK_SND_FLAGS: So9MsgFlags;

    /// A default flags which are set as argument in functions like starting with
    /// prefix `send_vectored` i.e `send_vectored`.
    const SOCK_SND_VECT_FLAGS: So9MsgFlags;

    /// A default flags which are set as argument in functions like starting with
    /// prefix `recv_`.
    const SOCK_RCV_FLAGS: So9MsgFlags;

    /// A default flags which are set as argument in functions like starting with
    /// prefix `recv_vectored` i.e `recv_vectored`.
    const SOCK_RCV_VECT_FLAGS: So9MsgFlags;

    /// A type of the address i.e IP address or unixpath which is used with this
    /// socket type.
    /// 
    /// A native to Rust socket address type. It must implement:
    /// 
    /// * `TryFrom` [So9SocketAddr] which converts the `So9SocketAddr` back to type.
    /// 
    /// * [So9AddrIntoRaw] which converts the self into FFI address
    /// 
    /// * [So9AddrDomain] which reports the socket `domain` type.
    /// 
    /// * [IntoSockAddrSpec] which converts different types like [str] literals into `self`.
    /// 
    /// * [Clone].
    /// 
    /// The follwoing types are available as part of the crate:
    /// 
    /// * [crate::UnixSocketAddr] - a unix address
    /// 
    /// * [SocketAddr] - IP address and respectivly [std::net::SocketAddrV4] [std::net::SocketAddrV6]
    type SockAddrType: TryFrom<So9SocketAddr, Error = io::Error> + So9AddrIntoRaw + So9AddrDomain + IntoSockAddrSpec<Self::SockAddrType> + Clone + PartialEq + fmt::Debug;

    /// This is a part of a socket's `domain` type resolution. It helps to determine the
    /// exact `domain` by the provided host address i.e IP or path.
    /// 
    /// An enum of the available domains for manual socket initialization.
    /// 
    /// * [crate::So9DomainInets] for INET
    /// 
    /// * [crate::So9DomainUnix] for UNIX
    /// 
    /// For example for [TcpStream] a [crate::So9DomainInets] is issued as it provides only `AF_INET` and
    ///     `AF_INET6`.
    /// 
    /// For [UnixStream] a [crate::So9DomainUnix] is returned.
    /// 
    /// For example a [So9AddrDomain] is implemented for `SocketAddrV4` and returns
    /// a [crate::So9SockDomain::IPV4].
    type SockAddrDomain: So9AddrDomain;
}




/// Checks the FD's `protocol` is same as declared in [So9Marker] implementation.
fn check_proto<M: So9Marker>(so_proto: Option<So9SockProtocol>) -> io::Result<()>
{
    if let Some(so_pr) = so_proto 
    {
        if M::SO_PROTO != so_pr 
        {
            return Err(
                io::Error::new(ErrorKind::InvalidData, 
                    format!("so_proto mismatch exp: {:?}, rcv: {:?}", M::SO_PROTO, so_proto))
            );
        
        }
    }
    
    return Ok(());
}

/// A main instance, constructs a socket which is strictly binded to
/// `SO` generic type providing statically only specified by `markers` 
/// functionality.
/// 
/// The system is based on the stong typeing which should prevent  
/// construction of an instace from [RawFd] which does not correspond to
/// the specified `SO`.
/// 
/// `Socket9` does not allow to cast one instance of `self` to another of
/// another `SO` type. Also, it does not allow to convert owned or raw `FD`
/// to the type of `SO` if the type does not match.
/// 
/// The following `SO` types are available:
/// 
/// * [UnixListener] - which is [libc::AF_UNIX] [libc::SOCK_STREAM] passive
/// 
/// * [UnixStream] - which is [libc::AF_UNIX] [libc::SOCK_STREAM] 
/// 
/// * [TcpListener] - which is [libc::AF_INET] or [libc::AF_INET6] 
///     [libc::SOCK_STREAM] [libc::IPPROTO_TCP] passive
/// 
/// * [UnixDatagram] - which is [libc::AF_UNIX] [libc::SOCK_DGRAM]
/// 
/// * [UdpSocket] - which is [libc::AF_INET] or [libc::AF_INET6]
///    [libc::SOCK_DGRAM] [libc::IPPROTO_UDP]
/// 
/// * [UnixSeqpacketListener] - which is [libc::AF_UNIX] [libc::SOCK_SEQPACKET] 
///     passive
/// 
/// * [NonBlkUnixSeqpacketListener] - which is [libc::AF_UNIX] [libc::SOCK_SEQPACKET] 
///     passive
/// 
/// * [UnixSeqpacketConn] - which is [libc::AF_UNIX] [libc::SOCK_SEQPACKET] 
/// 
/// * [WindowsUnixListener] - (windows only) a [libc::AF_UNIX] [libc::SOCK_STREAM] 
///     listener.
/// 
/// * [WindowsUnixStream] - (windows only) [libc::AF_UNIX] [libc::SOCK_STREAM] 
///     connection.
/// 
/// Any other `SO` can be implemented by implemeting the mandatory trait [So9Marker] 
/// on a custom type outside of the crate.
/// 
/// The implementation of `Socket9` also make use of other traits which blocks
/// specific functionality which is not available for some types of sockets.
/// 
/// * [So9MarkerBind] is implemented on socket which supports address bind.
/// 
/// * [So9MarkerPairable] is implemeted on socket which supports pairing i.e
///     an interconnected endpoints.
/// 
/// * [So9MarkerPairableWin] alternatively to `So9MarkerPairable` but for 
///     windows.
/// 
/// * [So9MarkerStateless] is implemeted on socket which is stateless and can
///     send data directly on other socket.
/// 
/// * [So9MarkerSockUnix] is implemented on socket which is `unix` only.
/// 
/// * [So9MarkerListener] is implemented on socket type which can listen on port
///     or unix address or whatever. Be in active mode.
/// 
/// # Implementations
/// 
/// The `Socket9` implements [io::Read], [io::Write], [AsFd], [AsRawFd], [FromRawFd],
///     [From<Socket9<SO>] for [OwnedFd] and [TryFrom<OwnedFd>] for Socket9<SO>.
/// 
/// The [Socket9ExtSo], [Socket9ExtIp], [Socket9ExtIp6], [Socket9ExtIpTcp], 
///     [Socket9ExtIpTcpExt] are implemented for `Socket9` instance for each
///     `SO` type separatly.
/// 
/// # Examples
/// 
/// ### Converting from std socket to Socket9
/// 
/// ```ignore
/// let unix_listen = UnixSeqpacketListener::bind(&test_path).unwrap();
/// 
/// let unix_listen_conn = UnixSeqpacketConn::connect(&test_path).unwrap();
/// 
/// // convert to socket9 of the same type otherwise it will fail
/// let val = Socket9::<UnixSeqpacketConn>::try_from(OwnedFd::from(unix_listen_conn)).unwrap();
/// 
/// let unix_stream: UnixSeqpacketConn = val.into();
/// ```
/// 
/// ### Creating the socket9 pair
/// 
/// ```ignore
/// let (a, b) = Socket9::<UnixSeqpacketConn>::pair().unwrap();
/// 
/// let data = [1,2,3,4];
/// 
/// let snd_n = a.send(&data[..3]).unwrap();
/// 
/// let mut rcv_data = [0_u8; 4];
/// 
/// let rcv_n = b.recv(&mut rcv_data).unwrap();
/// ```
/// 
/// ### Creating socket9.
/// 
/// ```ignore
/// let test_path = "@socket1";
/// 
/// let rcv_part = Socket9::<UnixDatagram>::new_with_bind(&test_path).unwrap();
/// 
/// let snd_part = Socket9::<UnixDatagram>::new(So9DomainUnix::Unix).unwrap();
/// 
/// let data = [1,2,3,4];
/// 
/// let snt_n = snd_part.send_to(&data[..3], &test_path).unwrap();
/// 
/// let mut rcv_data = [0_u8; 4];
/// 
/// let rcv_n = rcv_part.recv(&mut rcv_data).unwrap();
/// ```
#[derive(Debug)]
pub struct Socket9<SO: So9Marker>
{
    /// A socket's FD.
    ofd: SO::SockType, 

    /// Phantom.
    _p: PhantomData<SO>
}

impl<SO: So9Marker> Socket9<SO>
{
    /// Creates new instance. This function just initialize the socket as you
    /// would call in C
    /// 
    /// ```C
    ///     libc::socket(so_dom.0, so_type.0, so_proto.0)
    /// ```
    /// 
    /// The argument `remote_addr_type` helps to determine which socket
    /// `domain` is required. It will not `bind` or `connect` or perform any
    /// other operations using the address. It is needed because the 
    /// `AF_INET` and `AF_INET6` are determined by the address and cannot be
    /// hardcoded.
    /// 
    /// ## SockAddrDomain
    /// 
    /// * for the sockets related to [libc::AF_UNIX] a [So9DomainUnix]
    /// 
    /// * for the sockets related to [libc::AF_INET] and [libc::AF_INET6] a
    ///     [So9DomainInets]
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// An error may occure if provided parameters are wrong or for any other
    /// reason.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let val = Socket9::<UdpSocket>::new_unbound(So9DomainInets::Inet).unwrap();
    /// ```
    pub 
    fn new_unbound(remote_addr_type: SO::SockAddrDomain) -> io::Result<Socket9<SO>>
    {
        return
            SO::SockType::new_sock(remote_addr_type.get_addr_domain(), SO::SO_TYPE, SO::SO_PROTO, SO::SO_DEF_FLAGS)
                .map(
                    |a| 
                    Self::new_internal(a),
                );
    }

    /// Creates new instance. This function just initialize the socket as it
    /// would be called in C
    /// 
    /// ```C
    ///     libc::socket(so_dom.0, so_type.0, so_proto.0)
    /// ```
    /// 
    /// The argument `remote_addr_type` helps to determine which socket
    /// `domain` is required. It will not `bind` or `connect` or perform any
    /// other operations using the address. It is needed because the 
    /// `AF_INET` and `AF_INET6` are determined by the address and cannot be
    /// hardcoded.
    /// 
    /// But in contrast with the [Self::new_unbound], it takes not the type of the
    /// address, but the reference to address itself. 
    ///
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// An error may occure if provided parameters are wrong or for any other
    /// reason.
    /// 
    /// # Example
    /// ```ignore
    /// let tcp_listen = Socket9::<TcpListener>::new_with_bind_hostname_listen("localhost:0", 128).unwrap();
    /// tcp_listen.listen(2).unwrap();
    /// let serv_addr = tcp_listen.local_addr().unwrap();
    /// 
    /// let sock = Socket9::<TcpStream>::new_unbound_into(&serv_addr).unwrap();
    /// ```
    pub 
    fn new_unbound_into<S: So9AddrDomain>(remote_addr_type: &S) -> io::Result<Socket9<SO>>
    {
        let so_dom = remote_addr_type.get_addr_domain();

        return
            SO::SockType::new_sock(so_dom, SO::SO_TYPE, SO::SO_PROTO, SO::SO_DEF_FLAGS)
                .map(
                    |a| 
                    Self::new_internal(a),
                );
    }

    /// Creates a new instance. This function just initialize the socket as it
    /// would be called in C
    /// 
    /// ```C
    ///     libc::socket(so_dom.0, so_type.0, so_proto.0)
    /// ```
    /// 
    /// The argument `remote_addr_type` helps to determine which socket
    /// `domain` is required. It will not `bind` or `connect` or perform any
    /// other operations using the address. It is needed because the 
    /// `AF_INET` and `AF_INET6` are determined by the address and cannot be
    /// hardcoded.
    /// 
    /// A trait [IntoSockAddrSpec] is responsible for that. The predictor of the 
    /// type is defined in the generic `SO`.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let sock = Socket9::<TcpStream>::new_unbound_by_addr("127.0.0.1:0").unwrap();
    /// ```
    pub 
    fn new_unbound_by_addr<S>(remote_addr_type: S) -> io::Result<Socket9<SO>>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType> 
    {
        let sa_addr = remote_addr_type.from_type()?;

        let new_sock = Self::new_with_internal(sa_addr.get_addr_domain())?;

        return Ok(new_sock);
    }

    fn new_internal(ofd: <SO as So9Marker>::SockType) -> Socket9<SO>
    {
        return 
            Self
            {
                ofd: 
                    ofd,
                _p: 
                    PhantomData,
            };
    }

    fn new_with_internal<SA: So9AddrDomain>(remote_addr_type: SA) -> io::Result<Socket9<SO>>
    {
        let new_sock = 
            SO::SockType::new_sock(remote_addr_type.get_addr_domain(), SO::SO_TYPE, SO::SO_PROTO, SO::SO_DEF_FLAGS)
                .map(
                    |a| 
                    Self::new_internal(a),
                )?;

        return Ok(new_sock);
    }

    fn bind_internal<A: So9AddrIntoRaw>(&self, addr: &A) -> io::Result<()>
    {
        self.ofd.bind_sock(addr)
    }

    /// An implementation cover for the [ToSocketAddrs] i.e domain name resolution.
    /// 
    /// Argument `addr` is either the hostname/domain name or host address i.e
    /// IP address.
    /// 
    /// If a hostname/domainname is provided it will attempt to the `so_op`
    /// for every resolved IP address right until the first successfull 
    /// `so_op` i.e [Result::Ok].
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// Self::to_sock_addr(addr, 
    ///     |adr|
    ///     {
    ///         self.bind_internal(&adr)
    ///     }
    /// )
    /// ```
    /// 
    /// # Returns 
    /// 
    /// On success an instance of a socket is returned.
    /// 
    /// On error a error source is either a `so_op` subroutine or 
    /// the [ToSocketAddrs::to_socket_addrs]. If all rounds of `so_op` has
    /// failed, an error [ErrorKind::InvalidInput] will be returned.
    pub 
    fn to_sock_addr<A, F>(addr: A, mut so_op: F) -> io::Result<Socket9<SO>>
    where
        A: ToSocketAddrs,
        F: FnMut(SocketAddr) -> io::Result<Socket9<SO>>,
    {
        let mut err = None;
        
        for addr in addr.to_socket_addrs()?
        {
            match (so_op)(addr)
            {
                Ok(res) => 
                    return Ok(res),
                Err(e) => 
                {
                    err.replace(e);
                }
            }
        }

        return 
            err
                .map_or(
                    Err(io::Error::new(ErrorKind::InvalidInput, "could not resolve to any addresses")), 
                    |e| Err(e)
                );
    }

    /// An implementation cover for the [ToSocketAddrs] i.e domain name resolution.
    /// 
    /// Argument `addr` is either the hostname/domain name or host address i.e
    /// IP address.
    /// 
    /// If a hostname/domainname is provided it will attempt to the `so_op`
    /// for every resolved IP address right until the first successfull 
    /// `so_op` i.e [Result::Ok].
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// Self::to_sock_addr_no(addr, 
    ///     |adr|
    ///     {
    ///         self.bind_internal(&adr)
    ///     }
    /// )
    /// ```
    /// 
    /// # Returns 
    /// 
    /// On success nothing is returned.
    /// 
    /// On error a error source is either a `so_op` subroutine or 
    /// the [ToSocketAddrs::to_socket_addrs]. If all rounds of `so_op` has
    /// failed, an error [ErrorKind::InvalidInput] will be returned.
    pub 
    fn to_sock_addr_no<A, F, RET>(addr: A, mut so_op: F) -> io::Result<RET>
    where
        A: ToSocketAddrs,
        F: FnMut(SocketAddr) -> io::Result<RET>,
    {
        let mut err = None;
        
        for addr in addr.to_socket_addrs()?
        {
            match (so_op)(addr)
            {
                Ok(r) => 
                    return Ok(r),
                Err(e) => 
                {
                    err.replace(e);
                }
            }
        }

        return 
            err
                .map_or(
                    Err(io::Error::new(ErrorKind::InvalidInput, "could not resolve to any addresses")), 
                    |e| Err(e)
                );
    }
}

impl<SO: So9Marker + So9MarkerBind> Socket9<SO>
{
    /// Initializes a new instance and binds the socket to the provided address
    /// in `local_addr`. The address must correspond to the `SO` type otherwise
    /// an error will be returned.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str`, `SocketAddrV4`, `path` and other depending on the 
    /// `SO` type.
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// # Examples
    /// 
    /// ```ignore
    /// let mut tcp_stream = Socket9::<TcpStream>::new_with_bind("127.0.0.1:0").unwrap();
    /// ```
    /// 
    /// ```ignore
    /// let mut unix_stream = Socket9::<UnixStream>::new_with_bind("/tmp/sock.sock").unwrap();
    /// ```
    pub 
    fn new_with_bind<S>(local_addr: &S) -> io::Result<Socket9<SO>>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType> 
    {
        let local_addr_s = local_addr.from_type()?;

        let new_sock = Self::new_with_internal(local_addr_s.get_addr_domain())?;

        // bind socket.
        new_sock.bind_internal(local_addr_s.as_ref())?;

        return Ok(new_sock);
    }

    /// Binds the currrent instacne to specific address. Can be used after 
    /// the instance was created with any `unbounded` functions:
    /// 
    /// * [Self::new_unbound()]
    /// 
    /// * [Self::new_unbound_into()]
    /// 
    /// * [Self::new_unbound_by_addr()]
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str`, `SocketAddrV4`, `path` and other depending on the 
    /// `SO` type.
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// # Examples
    /// 
    /// ```ignore
    /// stream.bind("127.0.0.1:0").unwrap();
    /// ```
    /// 
    /// ```ignore
    /// stream.bind("/tmp/sock.sock").unwrap();
    /// ```
    pub 
    fn bind<S>(&self, sa: &S) -> io::Result<()>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        self.bind_internal(sa.from_type()?.as_ref())
    }
}

impl<SO: So9Marker + So9MarkerListener> Socket9<SO>
{
    /// Creates new passive socket which is binded to the `local_addr`
    /// and set to listening state.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str`, `SocketAddrV4`, `path` and other depending on the 
    /// `SO` type.
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// // new unix listener
    /// let unix_listen = Socket9::<UnixListener>::new_with_bind_listen("@teest",  1).unwrap();
    /// 
    /// // new tcp listener
    /// let tcp_listen = Socket9::<TcpListener>::new_with_bind_listen("0.0.0.0:0", 1).unwrap();    
    /// 
    /// // connecting to created server
    /// let tcp_listen = Socket9::<TcpListener>::new_with_bind_listen("127.0.0.1:0", 1).unwrap();
    /// 
    /// let serv_addr = tcp_listen.local_addr().unwrap();
    /// 
    /// let mut tcp_stream = Socket9::<TcpStream>::new_with_bind("127.0.0.1:0").unwrap();
    /// 
    /// tcp_stream.connect_timeout(&serv_addr, Duration::from_secs(1)).unwrap();
    /// ```
    pub 
    fn new_with_bind_listen<S>(local_addr: &S, backlog: i32) -> io::Result<Socket9<SO>>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType> 
    {
        let local_addr_s = local_addr.from_type()?;

        let new_sock = Self::new_with_internal(local_addr_s.get_addr_domain())?;

        // bind socket.
        new_sock.bind_internal(local_addr_s.as_ref())?;

        // set socket to passive mode
        new_sock.listen(backlog)?;

        return Ok(new_sock);
    }

    /// Sets the current instance's socket to passive mode (in listen state) 
    /// with the provided  `backlog` or changes the backlog size.
    /// 
    /// Corresponds to the clib function
    /// 
    /// ```C
    /// listen(fd.as_raw_fd(), backlog)     
    /// ```
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// 
    /// ```
    pub 
    fn listen(&self, backlog: i32) -> io::Result<()>
    {
        self.ofd.listen_sock(backlog)
    }

    /// Calls the `accept` or `accept4` on the socket with the pre-programmed flags.
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned.
    /// 
    /// In case of connection acceptance, the function returns the type which is specified
    /// by the implemented trait [So9MarkerListener] the type 
    /// [So9MarkerListener::AcceptedType] and the socket address which is specified by
    /// [So9Marker::SockAddrType].
    pub 
    fn accept(&self) -> io::Result<(Socket9<<SO as So9MarkerListener>::AcceptedType>, SO::SockAddrType)>
    {
        self.accept_with_flags(SO::SOCK_ACCEPT_FLAGS)
    }

    /// Calls the `accept` or `accept4` on the socket with the user provided flags.
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned.
    /// 
    /// In case of connection acceptance, the function returns the type which is specified
    /// by the implemented trait [So9MarkerListener] the type 
    /// [So9MarkerListener::AcceptedType] and the socket address which is specified by
    /// [So9Marker::SockAddrType].
    pub 
    fn accept_with_flags(&self, flags: i32) -> io::Result<(Socket9<<SO as So9MarkerListener>::AcceptedType>, SO::SockAddrType)>
    {
        self
            .ofd
            .accept_with_flags::<SO::SockAddrType, <<SO as So9MarkerListener>::AcceptedType as So9Marker>::SockType>(flags)
                .map(|(ofd, addr)| 
                    ( Socket9::<<SO as So9MarkerListener>::AcceptedType>::new_internal(ofd), addr)
                )
    }

    /// Calls the `accept` or `accept4` on the socket with the pre-programmed (defaut)
    /// flags with the timeout. 
    /// 
    /// The algoritm is the following:
    /// 
    /// * a socket is swithced to the non-blocking mode.
    /// 
    /// * a `accept` is called
    /// 
    /// * a socekt is switched to the blocking mode.
    /// 
    /// * if nothing was `accepted` a socket is polled for events with timeout, otherwise the
    /// result is returned.
    /// 
    /// * if timeout occured, the error [ErrorKind::TimedOut] will be returned or the result
    /// which can be an error.
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned. 
    /// 
    /// In case of connection acceptance, the function returns the type which is specified
    /// by the implemented trait [So9MarkerListener] the type 
    /// [So9MarkerListener::AcceptedType] and the socket address which is specified by
    /// [So9Marker::SockAddrType].
    /// 
    /// # Examples
    /// 
    /// ```ignore
    /// sock.bind(&addr).unwrap();
    /// 
    /// sock.listen(10).unwrap();
    /// 
    /// let _ = sock.accept_timeout(Duration::from_nanos(100));
    /// ```
    pub 
    fn accept_timeout(&self, timeout: Duration) -> io::Result<(Socket9<<SO as So9MarkerListener>::AcceptedType>, SO::SockAddrType)>
    {
        self.set_nonblocking(true)?;

        let res = self.accept();

        self.set_nonblocking(false)?;

        match res
        {
            Ok(r) => 
                return Ok(r),
            Err(e) => 
            {
                if e.kind() == ErrorKind::WouldBlock 
                {
                    self.ofd.poll_sock(POLLIN, timeout)?;

                    return self.accept();
                }
                else
                {
                    return Err(e);
                }
            }
        }
    }
}

impl<SO: So9Marker<SockAddrType = SocketAddr> + So9MarkerListener> Socket9<SO>
{
    /// Creates new passive socket which is binded to the `addr`and set to listening 
    /// state.
    /// 
    /// # Generics
    /// 
    /// * `A` - [ToSocketAddrs] an argument `addr` is attemted to be converted to
    /// the [SocketAddr] if a domain name is provided.
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// For possible errors, please see [Socket9::to_sock_addr].
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let tcp_listen = Socket9::<TcpListener>::new_with_bind_hostname_listen("localhost:0", 128).unwrap();
    /// ```
    pub 
    fn new_with_bind_hostname_listen<A>(addr: A, backlog: i32) -> io::Result<Socket9<SO>>
    where 
        A: ToSocketAddrs
    {
        Self::to_sock_addr(addr, 
            |addr|
            {
                Socket9::<SO>::new_with_bind_listen(&addr, backlog)
            }
        )
    }
}

impl<SO: So9Marker<SockAddrType = SocketAddr> + So9MarkerBind> Socket9<SO>
{
    /// Initializes a new instance and binds the new instance to the `addr`
    /// which can be either "host" or "domain". 
    /// 
    /// # Arguments
    /// 
    /// `addr` implements a [ToSocketAddrs].
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned with the new instance in case of success.
    /// 
    /// For possible errors, see [Socket9::to_sock_addr].
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let tcp_listen = 
    ///     Socket9::<TcpListener>::new_with_bind_hostname_listen("localhost:0", 128).unwrap();
    /// ```
    pub 
    fn new_with_bind_host<A>(addr: A) -> io::Result<Socket9<SO>>
    where 
        A: ToSocketAddrs
    {
        Self::to_sock_addr(addr, 
            |addr|
            {
                Socket9::<SO>::new_with_bind(&addr)
            }
        )
    }

    /// Binds the currrent instacne to specific address - `addr`.
    /// 
    /// # Arguments
    /// 
    /// `addr` implements a [ToSocketAddrs].
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned with the new instance in case of success.
    /// 
    /// For possible errors, see [Socket9::to_sock_addr].
    pub 
    fn bind_host<A>(&self, addr: A) -> io::Result<()>
    where 
        A: ToSocketAddrs
    {
        Self::to_sock_addr_no(addr, 
            |addr|
            {
                self.bind_internal(&addr)
            }
        )
     
    }
}

impl<SO: So9Marker<SockAddrType = SocketAddr>> Socket9<SO>
{
    /// Attempts to connect tot he `addr`
    pub 
    fn connect_host_unbound<A>(addr: A) -> io::Result<Self>
    where 
        A: ToSocketAddrs
    {
        Self::to_sock_addr(addr, 
            |addr|
            {
                Self::connect_unbound(&addr)
            }
        )
    }

    pub 
    fn connect_host<A: ToSocketAddrs>(&self, addr: A) -> io::Result<()>
    {
        Self::to_sock_addr_no(addr, 
            |addr|
            {
                self.connect(&addr)
            }
        )
    }

    pub 
    fn connect_host_timeout<A: ToSocketAddrs>(&self, addr: A, timeout: Duration) -> io::Result<()>
    {
        Self::to_sock_addr_no(addr, 
            |addr|
            {
                self.connect_timeout(&addr, timeout)
            }
        )
    }


}

impl<SO: So9Marker> Socket9<SO>
{
    /// Creates an new unbounded instance of the socket type `SO` and attempts to 
    /// connect to the remote host `dst_addr`.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str`, `SocketAddrV4`, `path` and other depending on the 
    /// `SO` type.
    /// 
    /// # Returns
    /// 
    /// An [io::Result] is returned.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let mut tcp_stream = Socket9::<TcpStream>::connect_unbound(&"localhost:80").unwrap();
    /// 
    /// let client_addr = tcp_stream.local_addr().unwrap();
    /// ```
    pub 
    fn connect_unbound<S>(dst_addr: S) -> io::Result<Self>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        let addr = dst_addr.from_type()?;

        let sock = Self::new_unbound_into(addr.as_ref())?;

        sock.connect(dst_addr)?;

        return Ok(sock);
    }

    /// Attempts to connect to the `dst_addr` - a destination address using existing 
    /// instance.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned.
    /// 
    /// # Examples
    /// 
    /// ```ignore
    /// let snd_dg = Socket9::<UnixDatagram>::new_unbound(So9DomainUnix::Unix).unwrap();
    /// 
    /// snd_dg.connect(test_path_snd).unwrap();
    /// ```
    pub 
    fn connect<S>(&self, dst_addr: S) -> io::Result<()>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        self.ofd.connect_sock(dst_addr.from_type()?.as_ref())
    }

    /// Attempts to connect to the `dst_addr` - a destination address before
    /// the specified timeout.
    /// 
    /// The algoritm is the following:
    /// 
    /// * a socket is swithced to the non-blocking mode.
    /// 
    /// * a `connect` is called
    /// 
    /// * a socekt is switched to the blocking mode.
    /// 
    /// * if connection is in progress a socket is polled for events with timeout, otherwise the
    /// result is returned.
    /// 
    /// * if timeout occured, the error [ErrorKind::TimedOut] will be returned or the result
    /// which can be an error.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned.
    /// 
    /// # Examples
    /// 
    /// ```ignore
    /// let tcp_conn = Socket9::<TcpStream>::new_unbound(So9DomainInets::Inet).unwrap();
    /// 
    /// tcp_conn.connect_timeout("127.0.0.2:8889", Duration::from_millis(200)).unwrap();
    /// ```
    pub 
    fn connect_timeout<S>(&self, dst_addr: S, timeout: Duration) -> io::Result<()>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        self.set_nonblocking(true)?;

        let res = self.connect(dst_addr);

        self.set_nonblocking(false)?;

        let poll_res = 
            if let Err(e) = res
            {
                #[cfg(unix)]
                let einprogress = 
                    e.raw_os_error() == Some(libc::EINPROGRESS);

                #[cfg(windows)]
                let einprogress = false;

                if e.kind() == ErrorKind::WouldBlock || einprogress == true
                {
                    self.ofd.poll_connect_sock(timeout)
                }
                else
                {
                    Err(e)
                }
            }
            else
            {
                Ok(())
            };

        return poll_res;
    }
}

#[cfg(unix)]
impl<SO: So9Marker<SockType = OwnedFd> + So9MarkerPairable> Socket9<SO>
{
    /// Creates a pair of interconnected endpoints. See the [So9Marker::SO_DEF_FLAGS]
    /// for the each `SO` type. In this case the `SO` is limited to the sockets
    /// which are [OwnedFd].
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned.
    /// 
    /// In case of success, a socket pair is returned.
    pub 
    fn pair() -> io::Result<(Self, Self)>
    {
        let (a, b) = SO::pair()?;

        let a = Socket9::<SO>::try_from(a)?;
        let b = Socket9::<SO>::try_from(b)?;

        a.set_cloexec_sock(true)?;
        b.set_cloexec_sock(true)?;

        return Ok((a, b));
    }
}

#[cfg(windows)]
impl<SO: So9Marker + So9MarkerPairableWin> Socket9<SO>
{
    /// Creates a pair of interconnected endpoints. See the [So9Marker::SO_DEF_FLAGS]
    /// for the each `SO` type. In this case the `SO` is limited to the sockets
    /// which implements [So9MarkerPairableWin].
    /// 
    /// # Returns
    /// 
    /// A [io::Result] is returned.
    /// 
    /// In case of success, a socket pair is returned.
    pub 
    fn pair() -> io::Result<(Self, Self)>
    {
        let (a, b) = SO::pair()?;


        a.set_cloexec_sock(true)?;
        b.set_cloexec_sock(true)?;

        return Ok((a, b));
    }
}

impl<SO: So9Marker> Socket9<SO>
{
    /// Returns the socket's `local` address as type declared in
    /// `SO` [So9Marker::SockAddrType].
    pub 
    fn local_addr(&self) -> io::Result<SO::SockAddrType>
    {
        self.ofd.get_socket_local_addr()
    }

    /// Returns the socket's `remote` address as type declared in
    /// `SO` [So9Marker::SockAddrType].
    pub 
    fn peer_addr(&self) -> io::Result<SO::SockAddrType>
    {
        self.ofd.get_socket_peer_addr()
    }

    /// Attempts to clone the current instance's socket, where on
    /// success returning a clonned instance.
    pub 
    fn try_clone(&self) -> io::Result<Socket9<SO>>
    {
        let ofd = self.ofd.try_clone_sock(SO::SO_DEF_FLAGS)?;
   
        return Ok( 
            Self
            { 
                ofd: 
                    ofd, 
                _p: 
                    PhantomData 
            });
    }
/*
    /// Returns the previous status.
    fn switch_to_nonblocking(&self) -> io::Result<bool>
    {
        let nonblk = self.is_nonblocking()?;

        if nonblk == false
        {
            self.set_nonblocking(true)?;
        }

        return Ok(nonblk);
    }
    */

    /// Attempts to clone the socket and return the read and write portion as separate 
    /// instances. Also this function switches the mode of the socket to `nonblocking`
    /// because simultaniously calling `read` or `write` in blocking mode will block 
    /// the threadIt does not `shutdown` the `read` on `write` portion and same in 
    /// reverse. However, if one of the portions will be `dropped` this side if r or w
    /// will be shutdown. 
    /// 
    /// So both `socket9read` and `socket9write` shares the same `FD` and the MT access
    /// is controlled by the OS.
    /// 
    /// # Returns
    /// 
    /// The [Result] is returned with tuples:
    /// 
    /// * [Result::Ok] is returned with tuple ([Socket9Read], [Socket9Write])
    /// 
    /// * [Result::Err] is returned with tuple ([Socket9], [io::Error]) where
    ///     0 - instance self, 1 - error description.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let so9udp = Socket9::<UdpSocket>::new_with_bind(&"127.0.0.1:0").unwrap();
    /// 
    /// let so9udp_lo = so9udp.local_addr().unwrap();
    /// 
    /// let (r, w) = so9udp.try_split().unwrap();
    /// ```
    pub 
    fn try_split(self) -> Result<(Socket9Read<SO>, Socket9Write<SO>), (Self, io::Error)>
    {
        // this function returns the previous status, so if it was false, then
        // it will be restores in case of error.
        if let Err(e) = self.set_nonblocking(true)
        {
            return Err((self, e));
        }

        // try clone the FD
        let clonned = 
            match self.try_clone()
            {
                Ok(r) => r,
                Err(e) =>
                { 
                    if let Err(e) = self.set_nonblocking(false)
                    {
                        return Err((self, e));
                    }

                    return Err((self, e));
                },
            };

        let orig_fd = self.ofd.get_raw();

        let write_p = Socket9Write::<SO>::new(self, orig_fd);
        let read_p = Socket9Read::<SO>::new(clonned, orig_fd);

        return Ok((read_p, write_p));
    }

    /// Attempts to upslit previously splitted FD.
    pub 
    fn try_unsplit(so9r: Socket9Read<SO>, so9w: Socket9Write<SO>) -> io::Result<Self>
    {
        if so9r != so9w
        {
            return Err(
                io::Error::new(ErrorKind::Other, 
                    format!("read protion belongs to other write portion: {:?} {:?}",
                        so9r, so9w)
                )
            )
        }

        // taking without droppint, otherwise it will close the read portion
        let _ = so9r.take();

        // taking the write part without dropping too and return it.
        let so9write = so9w.take();

        return Ok(so9write);
    }

    /// Reads the instance's socket FD `blocking` mode.
    #[cfg(unix)]
    pub 
    fn is_nonblocking(&self) -> io::Result<bool>
    {
        self.ofd.is_nonblocking_sock()
    }

    /// Alters the instance's socket FD `blocking` mode.
    pub 
    fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()>
    {
        self.ofd.set_nonblocking_sock(nonblocking)
    }

    /// Alters the instance's socket FD `cloexec` flag.
    pub 
    fn set_cloexec_sock(&self, cloexec: bool) -> io::Result<()>
    {
        self.ofd.set_cloexec_sock(cloexec)
    }

    /// Reads the instance's socket FD `cloexec` status.
    #[cfg(unix)]
    pub 
    fn is_cloexec_sock(&self) -> io::Result<bool>
    {
        self.ofd.is_cloexec_sock()
    }

    /// Shutdowns the socket partially or fully. The [Shutdown]
    /// specifies which part of the socket to shutdown.
    pub 
    fn shutdown(&self, how: Shutdown) -> io::Result<()>
    {
        self.ofd.shutdown_sock(how)
    }

    /// Performs a generic `send` operation of the provided buffer to
    /// the remote host. This function provides the `flags` from the 
    /// `SO`generic which implements [So9Marker::SOCK_SND_FLAGS].
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes written to the socket is returned.
    pub 
    fn send(&self, data: &[u8]) -> Result<usize, io::Error> 
    {
        self.send_with_flags(data, SO::SOCK_SND_FLAGS)
    }

    /// Performs a generic `send` operation of the provided buffer to
    /// the remote host. User should provide the `flags` which will be passed 
    /// to `libc::send` function.
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes written to the socket is returned.
    pub 
    fn send_with_flags(&self, data: &[u8], flags: So9MsgFlags) -> Result<usize, io::Error> 
    {
        self.ofd.send_with_flags(data, flags)
    }

    /// Performes a `vectorized` send of [IoSlice] slice. This function
    /// calls the `libc::writev`.
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes written to the socket is returned.
    pub 
    fn send_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> 
    {
        self.ofd.send_vectored(bufs)
    }

    /// Receives a data from socket to provided mutable slie of `u8`. 
    /// This function provides the `flags` from the `SO`generic which implements 
    /// [So9Marker::SOCK_RCV_FLAGS].
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes read into the buffer is returned.
    pub 
    fn recv(&self, buffer: &mut[u8]) -> Result<usize, io::Error> 
    {
        self.recv_with_flags(buffer, SO::SOCK_RCV_FLAGS.bits())
    }

    /// Receives a data from socket to provided mutable slie of `u8`. 
    /// User should provide the `flags` which will be passed 
    /// to `libc::send` function.
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes read into the buffer is returned.
    pub 
    fn recv_with_flags(&self, buffer: &mut[u8], flags: i32) -> Result<usize, io::Error> 
    {
        self.ofd.recv_with_flags(buffer, flags)
    }

    /// Receives an io_slices to the provided mutable slice of [IoSliceMut].
    /// Based on the `libc::readv`.
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes read into the buffer is returned.
    pub 
    fn recv_vectored(&self,  bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> 
    {
        self.ofd.recv_vectored_flags(bufs, 0).map(|(sz, _)| sz)
    }

    /// Peeks the data from the socket into the provided buffer without removing
    /// it from the socket.
    /// 
    /// # Returns 
    /// 
    /// An amount of bytes read into the buffer is returned.
    pub 
    fn peek(&self, buf: &mut [u8]) -> io::Result<usize> 
    {
        self.recv_with_flags(buf, SO::SOCK_RCV_FLAGS.union(So9MsgFlags::MSG_PEEK).bits())
    }
}

impl<SO: So9Marker<SockAddrType = SocketAddr> + So9MarkerStateless> Socket9<SO>
{
    /// Sends the data from the provided buffer to specified destination
    /// `addr_to`. This function uses the flags from the implementation of
    /// the `SO` generic [So9Marker::SOCK_SND_FLAGS].
    /// 
    /// # Generics
    /// 
    /// `A` - [ToSocketAddrs] for the `SO` [So9Marker::SockAddrType] of type [SocketAddr].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written
    /// bytes is returned.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let snd_part = Socket9::<UnixDatagram>::new(So9DomainUnix::Unix).unwrap();
    /// 
    /// let data = [1,2,3,4];
    /// let snt_n = snd_part.send_to(&data[..3], &test_path).unwrap();
    /// ```
    pub 
    fn send_to_host<A>(&self, buf: &[u8], addr_to: A) -> io::Result<usize>
    where 
        A: ToSocketAddrs
    {
        self.send_to_host_with_flags(buf, addr_to, SO::SOCK_SND_FLAGS.bits())
    }

    /// Sends the data from the provided buffer to specified destination
    /// `addr_to`. This function requires user to provide a `flags` which 
    /// will be passed to `libc::sendto`.
    /// 
    /// # Generics
    /// 
    /// `A` - [ToSocketAddrs] for the `SO` [So9Marker::SockAddrType] of type [SocketAddr].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written
    /// bytes is returned.
    pub 
    fn send_to_host_with_flags<A>(&self, buf: &[u8], addr_to: A, flags: i32) -> io::Result<usize>
    where 
        A: ToSocketAddrs
    {
        Self::to_sock_addr_no(addr_to, 
            |addr|
            {
                self.send_to_with_flags(buf, &addr, flags)
            }
        )
    }

    /// Sends the datafrom the provided [IoSlice] buffer to specified destination
    /// `addr_to`. 
    /// 
    /// Make sure that the total length of `ioslice` messages does not exceed the
    /// maximumm size, for example the [UdpSocket] can do vectored send, but the 
    /// maximum length is `65507`. 
    /// 
    /// ```ignore
    /// let p1 = "127.0.0.1:0";
    /// let sender = Socket9::<UdpSocket>::new_with_bind(&p1).unwrap();
    /// 
    /// let buf0 = vec![1_u8; 65307];
    /// let buf1 = vec![2_u8; 200];
    /// 
    /// let n = 
    ///     sender
    ///         .send_to_vectored(&[IoSlice::new(&buf0), IoSlice::new(&buf1)], &sock_addr_rcv)
    ///         .unwrap();
    /// ```
    /// The argument `flags` will be passed from the hardcoded value in `SO` type 
    /// [So9Marker::SOCK_SND_VECT_FLAGS].
    /// 
    /// # Generics
    /// 
    /// `A` - [ToSocketAddrs] for the `SO` [So9Marker::SockAddrType] of type [SocketAddr].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written bytes is returned.
    pub 
    fn send_to_host_vectored<A>(&self, buffers: &[IoSlice<'_>], addr_to: A)  -> io::Result<usize>
    where 
        A: ToSocketAddrs
    {
        self.send_to_host_vectored_with_flags(buffers, addr_to, SO::SOCK_SND_VECT_FLAGS)
    }

    /// Sends the datafrom the provided [IoSlice] buffer to specified destination
    /// `addr_to`. 
    /// 
    /// Make sure that the total length of `ioslice` messages does not exceed the
    /// maximumm size, for example the [UdpSocket] can do vectored send, but the 
    /// maximum length is `65507`. 
    /// 
    /// ```ignore
    /// let p1 = "127.0.0.1:0";
    /// let sender = Socket9::<UdpSocket>::new_with_bind(&p1).unwrap();
    /// 
    /// let buf0 = vec![1_u8; 65307];
    /// let buf1 = vec![2_u8; 200];
    /// 
    /// let n = 
    ///     sender
    ///         .send_to_vectored(&[IoSlice::new(&buf0), IoSlice::new(&buf1)], &sock_addr_rcv)
    ///         .unwrap();
    /// ```
    /// The argument `flags` must be provided by the user.
    /// 
    /// # Generics
    /// 
    /// `A` - [ToSocketAddrs] for the `SO` [So9Marker::SockAddrType] of type [SocketAddr].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written bytes is returned.
    pub 
    fn send_to_host_vectored_with_flags<A>(&self, buffers: &[IoSlice<'_>], addr_to: A, flags: So9MsgFlags)  -> io::Result<usize>
    where 
        A: ToSocketAddrs
    {
        Self::to_sock_addr_no(addr_to, 
            |addr|
            {
                self.ofd.send_to_sock_vect(&addr, buffers, flags.bits())
            }   
        )     
    }
}

impl<SO: So9Marker + So9MarkerStateless> Socket9<SO> 
{
    /// Peeks the data from the socket and writes it into provided mutable slice of `u8`
    /// without removing the data from socket and also returning the remote host info which
    /// is defined in the `SO` generic [So9Marker::SockAddrType].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple is returned with:
    /// 
    /// * `received size` [usize]
    /// 
    /// * `address` [So9Marker::SockAddrType]
    pub 
    fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SO::SockAddrType)>
    {
        self.recv_from(buf, SO::SOCK_RCV_FLAGS.union(So9MsgFlags::MSG_PEEK))
    }

    /// Receives the data from the socket and writes it into provided mutable slice of `u8`.
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple is returned with:
    /// 
    /// * `received size` [usize]
    /// 
    /// * `address` [So9Marker::SockAddrType]
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let so9udp = Socket9::<UdpSocket>::try_unsplit(r, w).unwrap();
    /// 
    /// let mut rcv_buf: [u8; 10] = [0_u8; 10];
    /// let (rcv_n, rcv_addr) = so9udp.recv_from(&mut rcv_buf, So9MsgFlags::empty()).unwrap();
    /// ```
    pub 
    fn recv_from(&self, buf: &mut [u8], flags: So9MsgFlags) -> io::Result<(usize, SO::SockAddrType)>
    {
        self.ofd.recv_from(buf, flags.bits())
    }

    /// Receives the data from the socket and writes it into provided mutable slice of `u8` before
    /// the specific tiemout.
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple is returned with:
    /// 
    /// * `received size` [usize]
    /// 
    /// * `address` [So9Marker::SockAddrType]
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let rcv_part = Socket9::<UnixDatagram>::new_with_bind(&test_path_rcv).unwrap();
    /// 
    /// let mut rcv_data = [0_u8; 4];
    /// let rcv = rcv_part.recv_from_flags_timeout(&mut rcv_data, So9MsgFlags::empty(), Duration::from_secs(1)).unwrap();
    /// ```
    pub 
    fn recv_from_flags_timeout(&self, buf: &mut [u8], flags: So9MsgFlags, timeout: Duration) -> io::Result<(usize, SO::SockAddrType)>
    {
        let Err(e) = self.ofd.poll_sock(POLLIN, timeout)
        else
        {
            return self.recv_from(buf, flags);
        };

        return Err(e);
    }

    /// Receives vectored the data from the socket and writes it into provided mutable [IoSliceMut].
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// The `flags` are used from the `SO` const declaration, see [So9Marker::SOCK_RCV_VECT_FLAGS].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple is returned with:
    /// 
    /// * `received size` [usize]
    /// 
    /// * `address` [So9Marker::SockAddrType]
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let mut rbuf0 = vec![0_u8; 65307];
    /// let mut rbuf1 = vec![0_u8; 1000];
    /// 
    /// let rcv_io0 = IoSliceMut::new(&mut rbuf0);
    /// let rcv_io1 = IoSliceMut::new(&mut rbuf1);
    /// 
    /// let rn = receiver.recv_from_vectored(&mut [rcv_io0, rcv_io1]).unwrap();
    /// ```
    pub 
    fn recv_from_vectored(&self, buffers: &mut[IoSliceMut]) -> io::Result<(usize, SO::SockAddrType)>
    {
        self
            .recv_from_flags_vectored(buffers, SO::SOCK_RCV_VECT_FLAGS)
            .map(|(sz, _, from)| (sz, from))
    }

    /// Receives vectored the data from the socket and writes it into provided mutable [IoSliceMut].
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// The `flags` [So9MsgFlags] are provided by the user.
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple is returned with: 
    /// 
    /// * `received size` [usize] 
    /// 
    /// * `flags` - [So9MsgFlags] 
    /// 
    /// * `address` - [So9Marker::SockAddrType]
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let mut rbuf0 = vec![0_u8; 65307];
    /// let mut rbuf1 = vec![0_u8; 1000];
    /// 
    /// let rcv_io0 = IoSliceMut::new(&mut rbuf0);
    /// let rcv_io1 = IoSliceMut::new(&mut rbuf1);
    /// 
    /// let rn = receiver.recv_from_vectored(&mut [rcv_io0, rcv_io1]).unwrap();
    /// ```
    pub 
    fn recv_from_flags_vectored(&self, buffers: &mut[IoSliceMut], flags: So9MsgFlags) -> io::Result<(usize, So9MsgFlags, SO::SockAddrType)>
    {
        self
            .ofd
            .recv_vect_from_flags(buffers, true, flags.bits())
            .map(|(sz, flags, from)| (sz, flags, from.unwrap()))
    }

    /// Receives vectored the data from the socket and writes it into provided mutable [IoSliceMut]
    /// with the receive timeout.
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// The `flags` [So9MsgFlags] are provided by the user.
    /// 
    /// The `timeout` is a [Duration] timeout.
    /// 
    /// A `poll` is used for the socket polling for events.
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple is returned with: 
    /// 
    /// * `received size` [usize] 
    /// 
    /// * `flags` - [So9MsgFlags] 
    /// 
    /// * `address` - [So9Marker::SockAddrType]
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let mut rbuf0 = vec![0_u8; 65307];
    /// let mut rbuf1 = vec![0_u8; 1000];
    /// 
    /// let rcv_io0 = IoSliceMut::new(&mut rbuf0);
    /// let rcv_io1 = IoSliceMut::new(&mut rbuf1);
    /// 
    /// let rn = receiver.recv_from_vectored(&mut [rcv_io0, rcv_io1]).unwrap();
    /// ```
    pub 
    fn recv_from_flags_vectored_timeout(&self, buffers: &mut[IoSliceMut], flags: So9MsgFlags, timeout: Duration) -> io::Result<(usize, So9MsgFlags, SO::SockAddrType)>
    {
        let Err(e) = self.ofd.poll_sock(POLLIN, timeout)
        else
        {
            return self.recv_from_flags_vectored(buffers, flags);
        };

        return Err(e);
    }

    /// Sends the data from the provided buffer to specified destination
    /// `addr_to`. This function uses the flags from the implementation of
    /// the `SO` generic [So9Marker::SOCK_SND_FLAGS].
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written
    /// bytes is returned.
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let snd_part = Socket9::<UnixDatagram>::new(So9DomainUnix::Unix).unwrap();
    /// 
    /// let data = [1,2,3,4];
    /// let snt_n = snd_part.send_to(&data[..3], &test_path).unwrap();
    /// ```
    pub 
    fn send_to<S>(&self, buf: &[u8], addr_to: &S) -> io::Result<usize>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        self.send_to_with_flags(buf, addr_to, SO::SOCK_SND_FLAGS.bits())
    }

    /// Sends the data from the provided buffer to specified destination
    /// `addr_to`. This function requires user to provide a `flags` which 
    /// will be passed to `libc::sendto`.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written
    /// bytes is returned.
    pub 
    fn send_to_with_flags<S>(&self, buf: &[u8], addr_to: &S, flags: i32) -> io::Result<usize>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        let addr = addr_to.from_type()?;

        self.ofd.send_to_sock(addr.as_ref(), buf, flags)
    }

    /// Sends the datafrom the provided [IoSlice] buffer to specified destination
    /// `addr_to`. 
    /// 
    /// Make sure that the total length of `ioslice` messages does not exceed the
    /// maximumm size, for example the [UdpSocket] can do vectored send, but the 
    /// maximum length is `65507`. 
    /// 
    /// ```ignore
    /// let p1 = "127.0.0.1:0";
    /// let sender = Socket9::<UdpSocket>::new_with_bind(&p1).unwrap();
    /// 
    /// let buf0 = vec![1_u8; 65307];
    /// let buf1 = vec![2_u8; 200];
    /// 
    /// let n = 
    ///     sender
    ///         .send_to_vectored(&[IoSlice::new(&buf0), IoSlice::new(&buf1)], &sock_addr_rcv)
    ///         .unwrap();
    /// ```
    /// The argument `flags` will be passed from the hardcoded value in `SO` type 
    /// [So9Marker::SOCK_SND_VECT_FLAGS].
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written bytes is returned.
    pub 
    fn send_to_vectored<S>(&self, buffers: &[IoSlice<'_>], addr_to: &S)  -> io::Result<usize>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        self.send_to_vectored_with_flags(buffers, addr_to, SO::SOCK_SND_VECT_FLAGS)
    }

    /// Sends the datafrom the provided [IoSlice] buffer to specified destination
    /// `addr_to`. 
    /// 
    /// Make sure that the total length of `ioslice` messages does not exceed the
    /// maximumm size, for example the [UdpSocket] can do vectored send, but the 
    /// maximum length is `65507`. 
    /// 
    /// # Example
    /// 
    /// ```ignore
    /// let p1 = "127.0.0.1:0";
    /// let sender = Socket9::<UdpSocket>::new_with_bind(&p1).unwrap();
    /// 
    /// let buf0 = vec![1_u8; 65307];
    /// let buf1 = vec![2_u8; 200];
    /// 
    /// let n = sender.send_to_vectored(&[IoSlice::new(&buf0), IoSlice::new(&buf1)], &sock_addr_rcv).unwrap();
    /// ```
    /// 
    /// The argument `flags` should be provided by the user.
    /// 
    /// # Generics
    /// 
    /// `S` - [IntoSockAddrSpec] for the `SO` declared type. It accepts the
    /// address as type `str` or `path` depending on the `SO`.
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned. On success the amount of written bytes is returned.
    pub 
    fn send_to_vectored_with_flags<S>(&self, buffers: &[IoSlice<'_>], addr_to: &S, flags: So9MsgFlags)  -> io::Result<usize>
    where 
        S: IntoSockAddrSpec<SO::SockAddrType>
    {
        let addr = addr_to.from_type()?;

        self.ofd.send_to_sock_vect(addr.as_ref(), buffers, flags.bits())
    }
}

#[cfg(unix)]
impl<SO: So9Marker + So9MarkerSockUnix> Socket9<SO> 
{
    /// Sends a packet assembled from multiple byte slices. This is a `unix` specific
    /// type of message which uses a [libc::sendmsg].  This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_SND_VECT_FLAGS].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the amount of sent bytes
    /// is returned.
    pub 
    fn send_vectored_with(&self, slices: &[IoSlice]) -> io::Result<usize> 
    {
        self.send_vectored_with_flags(slices, SO::SOCK_SND_VECT_FLAGS)
    }

    /// Sends a packet assembled from multiple byte slices. This is a `unix` specific
    /// type of message which uses a [libc::sendmsg].  This function requires that 
    /// the user provides the flags which will be passed to `sendmsg`.
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the amount of sent bytes
    /// is returned.
    pub 
    fn send_vectored_with_flags(&self, slices: &[IoSlice], flags: So9MsgFlags) -> io::Result<usize> 
    {
        self.ofd.send_vect_with_flags::<SO::SockAddrType>(slices, None,flags.bits())
    }
}

#[cfg(unix)]
impl<SO: So9Marker + So9MarkerSockUnix> Socket9<SO> 
{
    /// Transfers the `FD` over the wire to other endpoint. This is a `unix` specific
    /// type of message which uses a [libc::sendmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_SND_FLAGS].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the amount of sent bytes
    /// is returned.
    pub 
    fn send_fd(&self, fd: OwnedFd) -> io::Result<usize>
    {
        self.send_fd_with_flags(fd, SO::SOCK_SND_FLAGS)
    }

    /// Transfers the `FD` over the wire to other endpoint.This is a `unix` specific
    /// type of message which uses a [libc::sendmsg]. This function requires that 
    /// the user provides the flags which will be passed to `sendmsg`.
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the amount of sent bytes
    /// is returned.
    pub 
    fn send_fd_with_flags(&self, fd: OwnedFd, flags: So9MsgFlags) -> io::Result<usize>
    {
        self.ofd.send_fd_with_flags(fd, flags.bits())
    }

    /// Reads a packet into multiple buffers. This is a `unix` specific
    /// type of message which uses a [libc::recvmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_RCV_VECT_FLAGS].
    /// 
    /// This function does not return flags, and does not check if message was truncated.
    /// For this purpose, use [Self::recv_vectored_flags].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the amount of read bytes
    /// is returned.
    pub 
    fn recv_vectored_with(&self, buffers: &mut[IoSliceMut]) -> io::Result<usize> 
    {
        self.recv_vectored_flags(buffers, SO::SOCK_RCV_VECT_FLAGS)
            .map(|(sz, _)| sz)
    }

    /// Reads a packet into multiple buffers. This is a `unix` specific
    /// type of message which uses a [libc::recvmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_RCV_VECT_FLAGS].
    /// 
    /// This function returns the sender address which is of type implemented in 
    /// generic `SO` [So9Marker::SockAddrType].
    /// 
    /// This function does not return flags, and does not check if message was truncated.
    /// For this purpose, use [Self::recv_vectored_flags].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the tuple is returned with
    /// amount of read bytes read and a source_address.
    pub 
    fn recv_vectored_from(&self,  buffers: &mut[IoSliceMut]) -> io::Result<(usize, SO::SockAddrType)> 
    {
        self.recv_vectored_from_flags(buffers, SO::SOCK_RCV_VECT_FLAGS)
            .map(|(sz, _, from)| (sz, from))
    }

    /// Reads a packet into multiple buffers. This is a `unix` specific
    /// type of message which uses a [libc::recvmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_RCV_VECT_FLAGS].
    /// 
    /// This function returns flags which comes together in tuple and has type 
    /// [MsgFlags].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the tuple is returned with
    /// amount of read bytes read and flags.
    pub 
    fn recv_vectored_flags(&self,  buffers: &mut[IoSliceMut], flags: So9MsgFlags) -> io::Result<(usize, So9MsgFlags)> 
    {
        self
            .ofd
            .recv_vect_from_flags::<SO::SockAddrType>(buffers, false, flags.bits())
            .map(|(sz, msg_flags, _)| (sz, msg_flags))
    }

    /// Reads a packet into multiple buffers. This is a `unix` specific
    /// type of message which uses a [libc::recvmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_RCV_VECT_FLAGS].
    /// 
    /// This function returns the sender address which is of type implemented in 
    /// generic `SO` [So9Marker::SockAddrType].
    /// 
    /// This function returns flags which comes together in tuple and has type 
    /// [MsgFlags].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the tuple is returned with
    /// amount of read bytes read, flags and source_address.
    pub 
    fn recv_vectored_from_flags(&self, buffers: &mut[IoSliceMut], flags: So9MsgFlags) -> io::Result<(usize, So9MsgFlags, SO::SockAddrType)> 
    {
        self
            .ofd
            .recv_vect_from_flags::<SO::SockAddrType>(buffers, true, flags.bits())
            .map(
                |(sz, msg_flags, sa_opt)| 
                (sz, msg_flags, sa_opt.unwrap())
            )
    }

    /// Receives the `FD` over the wire from other endpoint. This is a `unix` specific
    /// type of message which uses a [libc::recvmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_RCV_FLAGS].
    /// 
    /// This function does not return flags, and does not check if message was truncated.
    /// For this purpose, use [Self::recv_fd_with_flags].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the `FD` as [OwnedFd]
    /// is returned.
    pub 
    fn recv_fd(&self) -> io::Result<OwnedFd>
    {
        self.recv_fd_with_flags(SO::SOCK_RCV_FLAGS)
            .map(|(ofd, _)| ofd)
    }

    /// Receives the `FD` over the wire from other endpoint. This is a `unix` specific
    /// type of message which uses a [libc::recvmsg]. This function uses the flags from 
    /// the implementation of the `SO` generic [So9Marker::SOCK_RCV_FLAGS].
    /// 
    /// This function returns flags which comes together in tuple and has type 
    /// [MsgFlags].
    /// 
    /// # Returns
    /// 
    /// The [io::Result] is returned, where on success the tuple is provided
    /// with the received `FD` [OwnedFd] and [MsgFlags] with msg status.
    pub 
    fn recv_fd_with_flags(&self, flags: So9MsgFlags) -> io::Result<(OwnedFd, So9MsgFlags)>
    {
        self
            .ofd
            .recv_fd(flags.bits())
    }
}

impl<SO: So9Marker> io::Read for Socket9<SO> 
{
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> 
    {
        self.recv(buf)
    }

    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> 
    {
        self.recv_vectored(bufs)
    }
}

impl<'temp, SO: So9Marker> io::Read for &'temp Socket9<SO> 
{
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> 
    {
        self.recv(buf)
    }

    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> 
    {
        self.recv_vectored(bufs)
    }
}

impl<SO: So9Marker> io::Write for Socket9<SO> 
{
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> 
    {
        self.send(buf)
    }

    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> 
    {
        self.send_vectored(bufs)
    }

    fn flush(&mut self) -> io::Result<()> 
    {
        Ok(())
    }
}

impl<'temp, SO: So9Marker> io::Write for &'temp Socket9<SO>
{
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> 
    {
        self.send(buf)
    }

    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> 
    {
        self.send_vectored(bufs)
    }

    fn flush(&mut self) -> io::Result<()> 
    {
        Ok(())
    }
}

#[cfg(unix)]
pub mod unix_socket9
{
    use super::*;

    impl<SO: So9Marker<SockType = OwnedFd>> FromRawFd for Socket9<SO>
    {
        /// Attempts to create an [OwnedFd] from the provided [RawFd] and
        /// instantiate it as inner type of `Socket9` of generic type
        /// `SO`. In case if verification of FD's domain, type and protocol,
        /// mode fails, this function will `panic`.
        /// 
        /// # Panic
        /// 
        /// This function `panics` on verification fail.
        unsafe 
        fn from_raw_fd(fd: RawFd) -> Self 
        {
            let ofd = unsafe { OwnedFd::from_raw_fd(fd) };

            return Socket9::<SO>::try_from(ofd).unwrap();
        }
    }

    impl<SO: So9Marker> AsFd for Socket9<SO>
    {
        fn as_fd(&self) -> BorrowedFd<'_> 
        {
            return self.ofd.as_fd();
        }
    }

    impl<SO: So9Marker> AsRawFd for Socket9<SO>
    {
        fn as_raw_fd(&self) -> RawFd 
        {
            return self.ofd.as_raw_fd();
        }
    }

    impl<SO: So9Marker<SockType = OwnedFd>> From<Socket9<SO>> for OwnedFd
    {
        fn from(value: Socket9<SO>) -> Self 
        {
            return value.ofd;
        }
    }


    impl<SO: So9Marker<SockType = OwnedFd>> TryFrom<OwnedFd> for Socket9<SO>
    {
        type Error = io::Error;

        /// Tries to instantiate the provided `ofd`. If the following checks
        /// fails, the function returns error. The data is matched against
        /// the implementation of trait [So9Marker] of the generic `SO` and
        /// `fd` probing.
        /// 
        /// * checks the mode of the FD: passive, static.
        /// 
        /// * checks the domain
        /// 
        /// * checks the type
        /// 
        /// * checks the protocol (if appliciable)
        /// 
        /// # Returns 
        /// 
        /// The [io::Result] is returned.
        fn try_from(ofd: OwnedFd) -> Result<Socket9<SO>, Self::Error> 
        {
            let inst = 
                Self
                {
                    ofd: 
                        ofd,
                    _p: 
                        PhantomData,
                };

            let is_accepting = inst.ofd.get_so_listening_status()?;

            if SO::IS_LISTENING != is_accepting
            {
                return Err(
                    io::Error::new(ErrorKind::InvalidData, 
                        format!("expected listening: {}, got: {}", SO::IS_LISTENING, is_accepting))
                );
            }

            let sock_fam = inst.ofd.get_socket_addr_type()?;

            // verify that the domain matches
            SO::SO_DOMAIN_GROUP.check_fam(sock_fam)?;

            // check the so_type matching
            let so_type = inst.ofd.get_so_type()?; 
            
            if so_type != SO::SO_TYPE 
            {
                return Err(
                    io::Error::new(ErrorKind::InvalidData, 
                        format!("expected sock type: {}, got: {}", SO::SO_TYPE, so_type))
                );
            }

            // this one is optional OS to OS, so check if Some is returned
            // check proto
            check_proto::<SO>(inst.ofd.get_socket_proto()?)?;
            
            

            return Ok(inst);
        }
    }
}

#[cfg(windows)]
pub mod unix_socket9
{
    use std::os::windows::io::{AsRawSocket, AsSocket, BorrowedSocket, FromRawSocket, RawSocket};

    use super::*;

    impl<SO: So9Marker<SockType = OwnedSocket>> FromRawSocket for Socket9<SO>
    {
        /// Attempts to create an [OwnedFd] from the provided [RawFd] and
        /// instantiate it as inner type of `Socket9` of generic type
        /// `SO`. In case if verification of FD's domain, type and protocol,
        /// mode fails, this function will `panic`.
        /// 
        /// # Panic
        /// 
        /// This function `panics` on verification fail.        
        unsafe 
        fn from_raw_socket(sock: RawSocket) -> Self 
        {
            let ofd = unsafe { OwnedSocket::from_raw_socket(sock) };

            return Socket9::<SO>::try_from(ofd).unwrap();
        }
        
    }

    impl<SO: So9Marker> AsSocket for Socket9<SO>
    {
        fn as_socket(&self) -> BorrowedSocket<'_> 
        {
            return self.ofd.as_socket();
        }
    }

    impl<SO: So9Marker> AsRawSocket for Socket9<SO>
    {
        fn as_raw_socket(&self) -> RawSocket 
        {
            return self.ofd.as_raw_socket();
        }
    }

    impl<SO: So9Marker<SockType = OwnedSocket>> From<Socket9<SO>> for OwnedSocket
    {
        fn from(value: Socket9<SO>) -> Self 
        {
            return value.ofd;
        }
    }


    impl<SO: So9Marker<SockType = OwnedSocket>> TryFrom<OwnedSocket> for Socket9<SO>
    {
        type Error = io::Error;

        /// Tries to instantiate the provided `ofd`. If the following checks
        /// fails, the function returns error. The data is matched against
        /// the implementation of trait [So9Marker] of the generic `SO` and
        /// `fd` probing.
        /// 
        /// * checks the mode of the FD: passive, static.
        /// 
        /// * checks the domain
        /// 
        /// * checks the type
        /// 
        /// * checks the protocol (if appliciable)
        /// 
        /// # Returns 
        /// 
        /// The [io::Result] is returned.
        fn try_from(ofd: OwnedSocket) -> Result<Socket9<SO>, Self::Error> 
        {
            let inst = 
                Self
                {
                    ofd: 
                        ofd,
                    _p: 
                        PhantomData,
                };

            let sock_fam = inst.ofd.get_socket_addr_type()?;

            // verify that the domain matches
            SO::SO_DOMAIN_GROUP.check_fam(sock_fam)?;

            // check the so_type matching
            let sotype = inst.ofd.get_so_type()?;

            if sotype != SO::SO_TYPE
            {
                return Err(
                    io::Error::new(ErrorKind::InvalidData, 
                        format!("expected sock type: {}, got: {}", SO::SO_TYPE, sotype))
                );
            }

            if sotype == So9SockType::STREAM
            {
                let is_accepting = inst.ofd.get_so_listening_status()?;

                if SO::IS_LISTENING != is_accepting
                {
                    return Err(
                        io::Error::new(ErrorKind::InvalidData, 
                            format!("expected listening: {}, got: {}", SO::IS_LISTENING, is_accepting))
                    );
                }
            }

            // this one is optional OS to OS, so check if Some is returned
            // check proto
            check_proto::<SO>(inst.ofd.get_socket_proto()?)?;


            return Ok(inst);
        }
    }
}

impl<SO: So9Marker> AsOsDescr for Socket9<SO>{}

// -- tcp listen

impl From<Socket9<TcpListener>> for TcpListener
{
    fn from(value: Socket9<TcpListener>) -> Self 
    {
        return TcpListener::from(value.ofd);
    }
}

impl Socket9ExtSo for Socket9<TcpListener> {}
impl Socket9ExtIp for Socket9<TcpListener> {}
impl Socket9ExtIp6 for Socket9<TcpListener> {}

// -- tcp --

impl From<Socket9<TcpStream>> for TcpStream
{
    fn from(value: Socket9<TcpStream>) -> Self 
    {
        return TcpStream::from(value.ofd);
    }
}

impl Socket9ExtSo for Socket9<TcpStream> {}
impl Socket9ExtIp for Socket9<TcpStream> {}
impl Socket9ExtIp6 for Socket9<TcpStream> {}
impl Socket9ExtIpTcp for Socket9<TcpStream> {}
impl Socket9ExtIpTcpExt for Socket9<TcpStream> {}


// -- udp socket--

impl From<Socket9<UdpSocket>> for UdpSocket
{
    fn from(value: Socket9<UdpSocket>) -> Self 
    {
        return UdpSocket::from(value.ofd);
    }
}

impl Socket9ExtSo for Socket9<UdpSocket> {}
impl Socket9ExtIp for Socket9<UdpSocket> {}
impl Socket9ExtIp6 for Socket9<UdpSocket> {}

#[cfg(windows)]
pub mod windows_from_so9
{
    use std::os::windows::io::IntoRawSocket;

    use super::*;

    // -- win unix stream

    impl From<Socket9<WindowsUnixStream>> for WindowsUnixStream
    {
        fn from(value: Socket9<WindowsUnixStream>) -> Self 
        {
            return WindowsUnixStream::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<WindowsUnixStream> {}

    // -- win unix listener

    impl From<Socket9<WindowsUnixListener>> for WindowsUnixListener
    {
        fn from(value: Socket9<WindowsUnixListener>) -> Self 
        {
            return WindowsUnixListener::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<WindowsUnixListener> {}
}

#[cfg(unix)]
pub mod unix_from_so9
{
    use super::*;
    // -- unix datagram

    impl From<Socket9<UnixDatagram>> for UnixDatagram
    {
        fn from(value: Socket9<UnixDatagram>) -> Self 
        {
            return UnixDatagram::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<UnixDatagram> {}

    // -- unix stream

    impl From<Socket9<UnixStream>> for UnixStream
    {
        fn from(value: Socket9<UnixStream>) -> Self 
        {
            return UnixStream::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<UnixStream> {}

    // -- unix listener

    impl From<Socket9<UnixListener>> for UnixListener
    {
        fn from(value: Socket9<UnixListener>) -> Self 
        {
            return UnixListener::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<UnixListener> {}

    // -- UnixSeqpacketListener --

    impl From<Socket9<UnixSeqpacketListener>> for UnixSeqpacketListener
    {
        fn from(value: Socket9<UnixSeqpacketListener>) -> Self 
        {
            return UnixSeqpacketListener::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<UnixSeqpacketListener> {}

    // -- UnixSeqpacketConn --

    impl From<Socket9<UnixSeqpacketConn>> for UnixSeqpacketConn
    {
        fn from(value: Socket9<UnixSeqpacketConn>) -> Self 
        {
            return UnixSeqpacketConn::from(value.ofd);
        }
    }

    impl Socket9ExtSo for Socket9<UnixSeqpacketConn> {}


    impl From<Socket9<NonBlkUnixSeqpacketListener>> for NonBlkUnixSeqpacketListener
    {
        fn from(value: Socket9<NonBlkUnixSeqpacketListener>) -> Self 
        {
            return NonBlkUnixSeqpacketListener::from(value.ofd);
        }
    }
}




#[cfg(test)]
mod test_socket_int
{
    use crate::So9SockDomain;

    use super::*;

    #[test]
    fn check_domain_range()
    {
        So9DomainRange::DoUnixs.check_fam(So9SockDomain::UNIX).unwrap();
        
        assert_eq!(So9DomainRange::DoUnixs.check_fam(So9SockDomain::IPV4).is_err(),
            true);

        So9DomainRange::DoInets.check_fam(So9SockDomain::IPV4).unwrap();
        So9DomainRange::DoInets.check_fam(So9SockDomain::IPV6).unwrap();
        
        assert_eq!(So9DomainRange::DoInets.check_fam(So9SockDomain::UNIX).is_err(),
            true);

      /*  assert_eq!(So9DomainRange::DoOther(SockDomain::VSOCK.0 as u16).check_fam(SockDomain::UNIX).is_err(),
            true);
        assert_eq!(So9DomainRange::DoOther(SockDomain::VSOCK.0 as u16).check_fam(SockDomain::VSOCK).is_err(),
            false);*/
    }

    
}