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)
 */

/*!
# socket9 extended untilities for the networking/unix sockets and raw network sockets.

Socket9 provides an additional functionality to the provided in `std` socket and/or to the user defined.

# Implementations

There are traits which implements:

* SOL_SOCKET - trait `Socket9ExtSo`

* SOL_IP - trait `Socket9ExtSoIp`

* SOL_IPV6 - trait `Socket9ExtSoIp6`

* IPPROTO_IP - trait `Socket9ExtIp`

* IPPROTO_IPV6 - trait `Socket9ExtIp6`

* IPPROTO_TCP - trait `Socket9ExtIpTcp` + `Socket9ExtIpTcpExt`

Thise traits are implemented for
  
|Socket   | Socket9ExtSo   | Socket9ExtSoIp  | Socket9ExtSoIp6  | Socket9ExtIp  | Socket9ExtIp6 | Socket9ExtIpTcp|
|---------|----------------|-----------------|------------------|---------------|---------------|----------------|
|TcpListener| yes          | yes            | yes               | yes           | yes           | no             |
|TcpStream  | yes          | yes            | yes               | yes           | yes           | yes            |
|UdpSocket  | yes          | no             | no                | yes           | yes           | no             |
|UnixDatagram | yes        | no             | no                | no            | no            | no             |
|UnixStream   | yes        | no             | no                | no            | no            | no             |
|UnixSeqpacketConn | yes        | no             | no                | no            | no            | no             |
|UnixSeqpacketListener | yes        | no             | no                | no            | no            | no             |

 */ 
#[cfg(target_family = "unix")]
pub extern crate libc;

pub extern crate uds_fork;

#[cfg(target_family = "windows")]
pub extern crate windows_sys;

extern crate bitfield;
extern crate bitflags;

#[cfg(target_family = "unix")]
mod unix;

#[cfg(target_family = "windows")]
mod windows;

/// A common trait for the implementations in the dirs "unix", "windows".
pub mod common;

/// A common implementation for the socket.
pub mod socket;

/// A common implementation for the splitted socket into r/w.
pub mod socket_split;

/// A adress interface.
pub mod address;

pub mod socket_impls;


pub mod op_sol_socket;
mod op_iproto_ip;
mod op_sol_ip;
mod op_ipproto_ip6;
mod op_sol_ip6;
mod op_ipproto_tcp;

#[cfg(target_family = "windows")]
use std::os::windows::io::{AsRawSocket, AsSocket, BorrowedSocket, RawSocket};

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

use std::
{
    ffi::c_int, 
    io::{self}, 
    net::{Ipv4Addr, Ipv6Addr, TcpListener, TcpStream, UdpSocket}, 
    time::Duration
};



#[cfg(target_family = "unix")]
use uds_fork::{UnixSeqpacketConn, UnixSeqpacketListener};

use crate::
{
    op_ipproto_ip6::*, op_ipproto_tcp::*, op_iproto_ip::*,  
    op_sol_ip::*, op_sol_ip6::*, op_sol_socket::*
};

pub(crate) use common::{SocketTypeImps, SockTypeFromRaw};

pub use socket::*;

pub use uds_fork::{UnixSocketAddr, UnixSocketAddrRef};

pub use address::{So9DomainUnix, So9DomainInets};

#[cfg(target_family = "unix")]
pub use crate::unix::*;

#[cfg(target_family = "windows")]
pub use crate::windows::*;

/*
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum So9IpVerBind
{
    Ipv4Only,
    Ipv6Only,
    Both,
}

impl So9IpVerBind
{
    pub 
    fn is_addr_match(&self, addr: &SocketAddr) -> bool
    {
        match (self, &addr.ip())
        {
            (Self::Both, _) => 
                return true,
            (Self::Ipv4Only, IpAddr::V4(_)) =>
                return true,
            (Self::Ipv6Only, IpAddr::V6(_)) =>
                return true,
            _ => 
                return false,
        }
    }
}*/




/// A local implementation of converter [From].
pub trait LocalFrom<T>: Sized 
{
    /// Converts to this type from the input type.
    #[must_use]
    fn from(value: T) -> Self;
}

/// A `socket` `getsockopt` and `setsockopt` recs for the specific `level` and
/// `type`. A [getsockopt] and [setsockopt] uses this trait as to read and 
/// write value. 
pub trait SockOptMarker
{
    /// A `level` argument of [libc::getsockopt] and [libc::setsockopt]
    const SO_LEVEL: c_int;

    /// A `optname` argument of [libc::getsockopt] and [libc::setsockopt]
    const SO_OPTNAME: c_int;

    /// A datatype instance contains or casts to.
    type DataType;

    /// A datatype which used by OS, should match to data in the struct which
    /// implements this trait.
    type InputType;

    /// Called from the `getsockopt` to set the value.
    fn from(value: Self::InputType) -> Self where Self: Sized;

    /// Called by the user to init the instance for `setsockopt`.
    fn from_user(value: Self::DataType) -> Self where Self: Sized;

    /// Consumes instance by user.
    fn get(self) -> Self::DataType;
}

/// A 'read' marker for `getsockopt` operaion.
pub trait OptRMarker {}

/// A `write` marker for `setsockopt` operation.
pub trait OptWMarker {}

// -----

/// A trait which standartisize the `raw` and `borrowed` socket 
/// file descriptor across the different OSes. Also this
/// can be used as a marker.
/// 
/// The instance must implement [AsFd] and [AsRawFd].
#[cfg(target_family = "unix")]
pub trait AsOsDescr: AsFd + AsRawFd 
{
    fn borrowed(&self) -> BorrowedFd<'_>
    {
        self.as_fd()
    }

    fn raw(&self) -> RawFd
    {
        self.as_raw_fd()
    }
}

/// A trait which standartisize the `raw` and `borrowed` socket 
/// file descriptor across the different OSes. Also this
/// can be used as a marker.
/// 
/// The instance must implement [AsSocket] and [AsRawSocket].
#[cfg(target_family = "windows")]
pub trait AsOsDescr: AsSocket + AsRawSocket 
{
    fn borrowed(&self) -> BorrowedSocket<'_>
    {
        self.as_socket()
    }

    fn raw(&self) -> RawSocket
    {
        self.as_raw_socket()
    }
}

/// A dummy struct which is set as default for the Socket9Ext*.
#[derive(Debug)]
pub struct Dum;

/// A collection of the socket operations on the level [libc::SOL_SOCKET].
pub trait Socket9ExtSo<T = Dum>: AsOsDescr + Sized
{
    #[cfg(any(target_os = "freebsd"))]
    #[inline]
    fn get_so_label(&self) ->io::Result<<SoBroadcast as SockOptMarker>::DataType>
    {
        // https://man.freebsd.org/cgi/man.cgi?query=getsockopt&apropos=0&sektion=2&manpath=FreeBSD+15.0-RELEASE&arch=default&format=html
        compile_error!("https://github.com/lattera/freebsd/blob/401a161083850a9a4ce916f37520c084cff1543b/sys/sys/socket.h#L142");
    }

    /// Retrives the status of the socket if it is placed in the `listening` mode.
    /// 
    /// A `bool` is returned where `true` does mean `in listening mode`.
    /// 
    /// # Additional info
    /// 
    /// May return error if used on socket which cannot be set to listening mode in some
    /// OSes like Windows.
    #[inline]
    fn get_so_listening_status(&self) -> io::Result<<SoAcceptConn as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoAcceptConn, Self>(self)
                .map(|v| v.get());
    }

    /// > Retrieves the socket domain as an integer, returning a value such as AF_INET6.  
    /// > See socket(2) for details.  This socket option is read-only.
    /// 
    /// A [So9SockDomain] is returned.
    #[cfg(any(target_family = "unix"))]
    #[inline] 
    fn get_so_domain(&self) -> io::Result<<SoDomain as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoDomain, Self>(self)
                .map(|v| v.get());
    }

    /// > Retrieves the socket domain as an integer, returning a value such as AF_INET6.  
    /// > See socket(2) for details.  This socket option is read-only.
    /// 
    /// A [So9SockDomain] is returned.
    #[cfg(any(target_os = "windows"))]
    #[inline] 
    fn get_so_domain(&self) -> io::Result<<SoProtocolInfoDomain as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoProtocolInfoDomain, Self>(self)
                .map(|v| v.get());
    }

    /// > Gets the socket type as an integer (e.g., SOCK_STREAM).
    /// > This socket option is read-only.
    /// 
    /// A [So9SockType] is returned.
    #[inline] 
    fn get_so_type(&self) -> io::Result<<SoType as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoType, Self>(self)
                .map(|v| v.get());
    }

    /// > Retrieves the socket protocol as an integer, returning a 
    /// > value such as IPPROTO_SCTP.  See socket(2) for details.
    /// > This socket option is read-only.
    /// 
    /// A [So9SockProtocol] is returned.
    /// 
    /// # Additional info.
    /// 
    /// Not awailvable on OSX.
    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
    #[inline]
    fn get_so_protocol(&self) ->  io::Result<<SoProtocol as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoProtocol, Self>(self)
                .map(|v| v.get());
    }

    /// > Retrieves the socket protocol as an integer, returning a 
    /// > value such as IPPROTO_SCTP.  See socket(2) for details.
    /// > This socket option is read-only.
    /// 
    /// A [So9SockProtocol] is returned.
    #[cfg(any(target_os = "windows"))]
    #[inline]
    fn get_so_protocol(&self) ->  io::Result<<SoProtocol as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoProtocol, Self>(self)
                .map(|v| v.get());
    }

    /// > Controls generation of SIGPIPE for the socket.
    /// 
    /// Gets the value.
    /// 
    /// A `bool` is returned.
    #[cfg(any(
        target_os = "ios",
        target_os = "visionos",
        target_os = "macos",
        target_os = "tvos",
        target_os = "watchos",
        target_os = "freebsd"
    ))]
    #[inline]
    fn get_so_nosigpipe(&self) -> io::Result<<SoNoSigPipe as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoNoSigPipe, Self>(self)
                .map(|v| v.get());
    }

    /// > Controls generation of SIGPIPE for the socket.
    /// 
    /// Sets the value.
    /// 
    /// A `bool` is returned.
    #[cfg(any(
        target_os = "ios",
        target_os = "visionos",
        target_os = "macos",
        target_os = "tvos",
        target_os = "watchos",
    ))]
    #[inline]
    fn set_so_nosigpipe(&self, flag: <SoNoSigPipe as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoNoSigPipe, Self>(self, SoNoSigPipe::from_user(flag));
    }

    /// > enables permission to transmit broadcast messages
    /// 
    /// Gets the value.
    /// 
    /// A `bool` is returned.
    #[inline]
    fn get_so_broadcast(&self) -> io::Result<<SoBroadcast as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoBroadcast, Self>(self)
                .map(|v| v.get());
    }

    /// > enables permission to transmit broadcast messages
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `flag` - [bool]
    #[inline]
    fn set_so_broadcast(&self, flag: <SoBroadcast as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoBroadcast, Self>(self, SoBroadcast::from_user(flag));
    }

    /// > get and clear error on the socket (get only)
    /// 
    /// Returns [Option] where:
    /// 
    /// * [Option::Some] with [io::Error] returned by either [libc::SO_ERROR] or by
    ///     [getsockopt].
    /// 
    /// * [Option::None] with no error
    #[inline]
    fn get_so_error(&self) -> <SoError as SockOptMarker>::DataType
    {
        return 
            getsockopt::<SoError, Self>(self)
                .map_or_else(
                    |e| Some(e), 
                    |f| f.get()
                );
    }

    /// > Enable sending of keep-alive messages on connection oriented sockets.  
    /// > Expects an integer boolean flag.
    /// 
    /// Gets the value.
    /// 
    /// A `bool` is returned.
    #[inline]
    fn get_so_keepalive(&self) -> io::Result<<SoKeepAlive as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoKeepAlive, Self>(self)
                .map(|v| v.get());
    }

    /// > Enable sending of keep-alive messages on connection oriented sockets.  
    /// > Expects an integer boolean flag.
    /// 
    /// Sets the value.
    /// 
    /// A `bool` should be provided as argument.
    #[inline]
    fn set_so_keepalive(&self, flag: <SoKeepAlive as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoKeepAlive, Self>(self, SoKeepAlive::from_user(flag));
    }

    /// > Sets or gets the SO_LINGER option. The argument is a `linger` structure.
    /// >
    /// > ```c
    /// > struct linger {
    /// >   int l_onoff;    /* linger active */
    /// >   int l_linger;   /* how many seconds to linger for */
    /// > }
    /// > ```
    /// > When enabled, a close(2) or shutdown(2) will not return
    /// > until all queued messages for the socket have been
    /// > successfully sent or the linger timeout has been reached.
    /// > Otherwise, the call returns immediately and the closing is
    /// > done in the background.  When the socket is closed as part
    /// > of exit(2), it always lingers in the background.
    /// 
    /// Gets the value.
    /// 
    /// A [Option] with inner [Duration] is returned.
    #[inline]
    fn get_so_linger(&self) -> io::Result<<SoLinger as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoLinger, Self>(self)
                .map(|v| v.get());
    }

    /// > Sets or gets the SO_LINGER option. The argument is a `linger` structure.
    /// >
    /// > ```c
    /// > struct linger {
    /// >   int l_onoff;    /* linger active */
    /// >   int l_linger;   /* how many seconds to linger for */
    /// > }
    /// > ```
    /// > When enabled, a close(2) or shutdown(2) will not return
    /// > until all queued messages for the socket have been
    /// > successfully sent or the linger timeout has been reached.
    /// > Otherwise, the call returns immediately and the closing is
    /// > done in the background.  When the socket is closed as part
    /// > of exit(2), it always lingers in the background.
    /// 
    /// Sets the value.
    /// 
    /// A [Option] with inner [Duration] should be provided. 
    /// [Option::None] disables.
    #[inline]
    fn set_so_linger(&self, dur: <SoLinger as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoLinger, Self>(self, SoLinger::from_user(dur));
    }

    /// > If this option is enabled, out-of-band data is directly placed into the 
    /// > receive data stream. Otherwise, out-of-band data is passed only when 
    /// > the `MSG_OOB` flag is set during receiving.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(not(target_os = "redox"))]
    #[inline]
    fn get_so_out_of_band_inline(&self) -> io::Result<<SoOoBinLine as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoOoBinLine, Self>(self)
                .map(|v| v.get());
    }

    /// > If this option is enabled, out-of-band data is directly placed into the 
    /// > receive data stream. Otherwise, out-of-band data is passed only when 
    /// > the `MSG_OOB` flag is set during receiving.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument.
    #[cfg(not(target_os = "redox"))]
    #[inline]
    fn set_so_out_of_band_inline(&self, flag: <SoOoBinLine as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoOoBinLine, Self>(self, SoOoBinLine::from_user(flag));
    }

    /// > Enable or disable the receiving of the `SCM_CREDENTIALS` control message.
    /// > For more information, see unix(7).
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(any(target_os = "linux"))]
    #[inline]
    fn get_so_passcred(&self) -> io::Result<<SoPasscred as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoPasscred, Self>(self)
                .map(|v| v.get());
    }

    /// > Enable or disable the receiving of the `SCM_CREDENTIALS` control message.
    /// > For more information, see unix(7).
    /// 
    /// Gets the value.
    /// 
    /// A [bool] should be provided as argument.
    #[cfg(any(target_os = "linux"))]
    #[inline]
    fn set_so_passcred(&self, flag: <SoPasscred as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoPasscred, Self>(self, SoPasscred::from_user(flag));
    }

    /// > Set the protocol-defined priority for all packets to be sent on this socket.
    /// > Linux uses this value to order the networking queues: packets with a higher 
    /// > priority may be processed first depending on the selected device queueing
    /// > discipline.  Setting a priority outside the range 0 to 6 requires the 
    /// > `CAP_NET_ADMIN` capability.
    /// 
    /// Gets the value.
    /// 
    /// A [u32] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_priority(&self) -> io::Result<<SoPriority as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoPriority, Self>(self)
                .map(|v| v.get());
    }

    /// > Set the protocol-defined priority for all packets to be sent on this socket.
    /// > Linux uses this value to order the networking queues: packets with a higher 
    /// > priority may be processed first depending on the selected device queueing
    /// > discipline.  Setting a priority outside the range 0 to 6 requires the 
    /// > `CAP_NET_ADMIN` capability.
    /// 
    /// Sets the value.
    /// 
    /// A [u32] should be provided as argument.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_priority(&self, prio: <SoPriority as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoPriority, Self>(self, SoPriority::from_user(prio));
    }

    /// > Sets or gets the maximum socket receive buffer in bytes. The kernel doubles 
    /// > this value (to allow space for bookkeeping overhead) when it is set using 
    /// > setsockopt(2), and this doubled value is returned by getsockopt(2).  The
    /// > default value is set by the `/proc/sys/net/core/rmem_default file`, and 
    /// > the maximum allowed value is set by the `/proc/sys/net/core/rmem_max file`.  
    /// > The minimum (doubled) value for this option is 256.
    /// 
    /// Gets the value.
    /// 
    /// A [usize] is returned.
    #[inline]
    fn get_so_recv_buf_size(&self) -> io::Result<<SoRcvBuf as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoRcvBuf, Self>(self)
                .map(|v| v.get());
    }

    /// > Sets or gets the maximum socket receive buffer in bytes. The kernel doubles 
    /// > this value (to allow space for bookkeeping overhead) when it is set using 
    /// > setsockopt(2), and this doubled value is returned by getsockopt(2).  The
    /// > default value is set by the `/proc/sys/net/core/rmem_default file`, and 
    /// > the maximum allowed value is set by the `/proc/sys/net/core/rmem_max file`.  
    /// > The minimum (doubled) value for this option is 256.
    /// 
    /// Sets the value.
    /// 
    /// A [usize] should be provided as argument.
    #[inline]
    fn set_so_recv_buf_size(&self, size: <SoRcvBuf as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoRcvBuf, Self>(self, SoRcvBuf::from_user(size));
    }

    /// ## SO_RCVLOWAT
    /// 
    /// Linux: 
    /// > Specify the minimum number of bytes in the buffer until the socket layer will 
    /// > pass the data to the protocol (SO_SNDLOWAT) or the user on receiving (SO_RCVLOWAT).
    /// > These two values are initialized to 1.  SO_SNDLOWAT is not changeable on 
    /// > Linux (setsockopt(2) fails with the error ENOPROTOOPT).  SO_RCVLOWAT is changeable 
    /// > only since Linux 2.4.
    /// 
    /// FreeBSD: 
    /// > SO_SNDLOWAT is an option to set the minimum count for input operations.  
    /// > In  general,receive  calls will block until any (non-zero) amount of
    /// > data is received, then return with the smaller of the amount available
    /// > or  the amount requested.The default value for SO_RCVLOWAT is 1. If
    /// > SO_RCVLOWAT is set to a larger value, blocking receive calls normally
    /// > wait until they have received the smaller of the low water mark value
    /// > or the requested amount. Receive calls may still return less than the
    /// > low  water  mark if an error occurs, a signal is caught, or the type of
    /// > data next in the receive queue is different from that which was returned.
    /// 
    /// Gets the value.
    /// 
    /// A [usize] is returned.
    #[cfg(unix)]
    #[inline]
    fn get_so_recv_min_output_count(&self) -> io::Result<<SoRcvLoWat as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoRcvLoWat, Self>(self)
                .map(|v| v.get());
    }


    /// ## SO_RCVTIMEO
    /// 
    /// Linux:
    /// > Specify the receiving or sending timeouts until reporting an error.  
    /// > The argument is a struct timeval. If an input or output function 
    /// > blocks for this period of time, and data has been sent or received, the 
    /// > return value of that function will be the amount of data transferred; 
    /// > if no data has been transferred and the timeout has been reached, then
    /// > -1 is returned with errno set to `EAGAIN` or `EWOULDBLOCK`, or `EINPROGRESS` 
    /// > (for `connect(2)`) just as if the socket was specified to be nonblocking.  
    /// > If the timeout is set to zero (the default), then the operation will 
    /// > never timeout. Timeouts only have effect for system calls that perform
    /// > socket I/O (e.g., `accept(2)`, `connect(2)`, `read(2)`, `recvmsg(2)`, 
    /// > `send(2)`, `sendmsg(2)`); timeouts have no effect for `select(2)`, `poll(2)`, 
    /// > `epoll_wait(2)`, and so on.
    /// 
    /// FreeBSDL
    /// > is an option	to set a timeout value for  input  operations.
    /// > It accepts a struct timeval argument with the number of seconds and 
    /// > microseconds used  to  limit waits for input operations to complete.  In
    /// > the current implementation, this timer is  restarted  each  time  
    /// > additional  data are received by the protocol, and thus the limit is in 
    /// > effect an inactivity timer.  If a receive operation has been blocked  for
    /// > this  much  time  without  receiving additional data, it returns with a
    /// > short count or with the error EWOULDBLOCK if no data were received.
    /// 
    /// Gets the value.
    /// 
    /// A [Option] with inner [Duration] is returned. If [Option::None] is
    /// returned, does mean disabled.
    #[inline] 
    fn get_so_recv_timeout(&self) -> io::Result<<SoRcvTimeout as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoRcvTimeout, Self>(self)
                .map(|v| v.get());
    }

    /// ## SO_RCVTIMEO
    /// 
    /// Linux:
    /// > Specify the receiving or sending timeouts until reporting an error.  
    /// > The argument is a struct timeval. If an input or output function 
    /// > blocks for this period of time, and data has been sent or received, the 
    /// > return value of that function will be the amount of data transferred; 
    /// > if no data has been transferred and the timeout has been reached, then
    /// > -1 is returned with errno set to `EAGAIN` or `EWOULDBLOCK`, or `EINPROGRESS` 
    /// > (for `connect(2)`) just as if the socket was specified to be nonblocking.  
    /// > If the timeout is set to zero (the default), then the operation will 
    /// > never timeout. Timeouts only have effect for system calls that perform
    /// > socket I/O (e.g., `accept(2)`, `connect(2)`, `read(2)`, `recvmsg(2)`, 
    /// > `send(2)`, `sendmsg(2)`); timeouts have no effect for `select(2)`, `poll(2)`, 
    /// > `epoll_wait(2)`, and so on.
    /// 
    /// FreeBSDL
    /// > is an option	to set a timeout value for  input  operations.
    /// > It accepts a struct timeval argument with the number of seconds and 
    /// > microseconds used  to  limit waits for input operations to complete.  In
    /// > the current implementation, this timer is  restarted  each  time  
    /// > additional  data are received by the protocol, and thus the limit is in 
    /// > effect an inactivity timer.  If a receive operation has been blocked  for
    /// > this  much  time  without  receiving additional data, it returns with a
    /// > short count or with the error EWOULDBLOCK if no data were received.
    /// 
    /// Sets the value.
    /// 
    /// A [Option] should be provided with inner [Duration] as argument.
    /// An [Option::None] disables the timeout.
    #[inline]
    fn set_so_recv_timeout(&self, size: <SoRcvTimeout as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoRcvTimeout, Self>(self, SoRcvTimeout::from_user(size));
    }

    /// > Indicates that the rules used in validating addresses supplied in a bind(2) 
    /// > call should allow reuse of local addresses.  For AF_INET sockets this means that 
    /// > a socket may bind, except when there is an active listening socket bound to the 
    /// > address.  When the listening socket is bound to INADDR_ANY with a specific port 
    /// > then it is not possible to bind to this port for any local address.  Argument is 
    /// > an integer boolean flag.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[inline] 
    fn get_so_reuse_addr(&self) -> io::Result<<SoReuseAddr as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoReuseAddr, Self>(self)
                .map(|v| v.get());
    }

    /// > Indicates that the rules used in validating addresses supplied in a `bind(2)` 
    /// > call should allow reuse of local addresses.  For `AF_INET` sockets this means that 
    /// > a socket may bind, except when there is an active listening socket bound to the 
    /// > address.  When the listening socket is bound to `INADDR_ANY` with a specific port 
    /// > then it is not possible to bind to this port for any local address.  Argument is 
    /// > an integer boolean flag.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument.
    #[inline]
    fn set_so_reuse_addr(&self, flag: <SoReuseAddr as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoReuseAddr, Self>(self, SoReuseAddr::from_user(flag));
    }

    // --

    /// > Permits multiple AF_INET or AF_INET6 sockets to be bound to an identical socket 
    /// > address. This option must be set on each socket (including the first socket) 
    /// > prior to calling bind(2) on the socket.  To prevent port hijacking, all of
    /// > the processes binding to the same address must have the same effective UID.  
    /// > This option can be employed with both TCP and UDP sockets.
    /// >
    /// > For TCP sockets, this option allows accept(2) load distribution in 
    /// > a multi-threaded server to be improved by using a distinct listener socket 
    /// > for each thread.  This provides improved load distribution as compared to
    /// > traditional techniques such using a single accept(2)ing thread that distributes 
    /// > connections, or having multiple threads that compete to accept(2) from the same 
    /// > socket.
    /// > 
    /// > For UDP sockets, the use of this option can provide better distribution 
    /// > of incoming datagrams to multiple processes (or threads) as compared 
    /// > to the traditional technique of having multiple processes compete to receive 
    /// > datagrams on the same socket.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(unix)]
    #[inline] 
    fn get_so_reuse_port(&self) -> io::Result<<SoReusePort as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoReusePort, Self>(self)
                .map(|v| v.get());
    }

    /// > Permits multiple AF_INET or AF_INET6 sockets to be bound to an identical socket 
    /// > address. This option must be set on each socket (including the first socket) 
    /// > prior to calling bind(2) on the socket.  To prevent port hijacking, all of
    /// > the processes binding to the same address must have the same effective UID.  
    /// > This option can be employed with both TCP and UDP sockets.
    /// >
    /// > For TCP sockets, this option allows accept(2) load distribution in 
    /// > a multi-threaded server to be improved by using a distinct listener socket 
    /// > for each thread.  This provides improved load distribution as compared to
    /// > traditional techniques such using a single accept(2)ing thread that distributes 
    /// > connections, or having multiple threads that compete to accept(2) from the same 
    /// > socket.
    /// > 
    /// > For UDP sockets, the use of this option can provide better distribution 
    /// > of incoming datagrams to multiple processes (or threads) as compared 
    /// > to the traditional technique of having multiple processes compete to receive 
    /// > datagrams on the same socket.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument.
    #[cfg(unix)]
    #[inline]
    fn set_so_reuse_port(&self, flag: <SoReusePort as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoReusePort, Self>(self, SoReusePort::from_user(flag));
    }

    // --

    /// > SO_REUSEPORT_LB allows completely duplicate bindings by multiple sockets 
    /// > if they all set SO_REUSEPORT_LB before binding the port. Incoming 
    /// > TCP and UDP connections are distributed among the participating listening  
    /// > sockets based on a hash function of local port number, and foreign 
    /// > IP address and port number. A maximum of 256 sockets can be bound to
    /// > the same load-balancing group.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(target_os = "freebsd")]
    #[inline] 
    fn get_so_reuse_port_lb(&self) -> io::Result<<SoReusePortLb as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoReusePortLb, Self>(self)
                .map(|v| v.get());
    }

    /// > SO_REUSEPORT_LB allows completely duplicate bindings by multiple sockets 
    /// > if they all set SO_REUSEPORT_LB before binding the port. Incoming 
    /// > TCP and UDP connections are distributed among the participating listening  
    /// > sockets based on a hash function of local port number, and foreign 
    /// > IP address and port number. A maximum of 256 sockets can be bound to
    /// > the same load-balancing group.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument.
    #[cfg(target_os = "freebsd")]
    #[inline]
    fn set_so_reuse_port_lb(&self, flag: <SoReusePortLb as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoReusePortLb, Self>(self, SoReusePortLb::from_user(flag));
    }

    // --

    /// SO_DONTROUTE
    /// 
    /// Linux:
    /// > Don't send via a gateway, send only to directly connected hosts. 
    /// > The same effect can be achieved by setting the MSG_DONTROUTE flag on 
    /// > a socket send(2) operation.  Expects an integer boolean flag.
    /// 
    /// FreeBSD:
    /// > Indicates that outgoing messages should bypass the standard routing 
    /// > facilities. Instead, messages are directed to the appropriate network interface 
    /// > according to the network portion of the destination address.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned. 
    #[inline] 
    fn get_so_dont_route(&self) -> io::Result<<SoRDontRoute as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoRDontRoute, Self>(self)
                .map(|v| v.get());
    }

    /// SO_DONTROUTE
    /// 
    /// Linux:
    /// > Don't send via a gateway, send only to directly connected hosts. 
    /// > The same effect can be achieved by setting the MSG_DONTROUTE flag on 
    /// > a socket send(2) operation.  Expects an integer boolean flag.
    /// 
    /// FreeBSD:
    /// > Indicates that outgoing messages should bypass the standard routing 
    /// > facilities. Instead, messages are directed to the appropriate network interface 
    /// > according to the network portion of the destination address.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument.
    #[inline]
    fn set_so_dont_route(&self, flag: <SoRDontRoute as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoRDontRoute, Self>(self, SoRDontRoute::from_user(flag));
    }

    // --

    /// ## SO_SNDBUF
    /// 
    /// Linux: 
    /// > Sets or gets the maximum socket send buffer in bytes. The kernel 
    /// > doubles this value (to allow space for bookkeeping overhead) when it is 
    /// > set using `setsockopt(2)`, and this doubled value is returned by `getsockopt(2)`.  
    /// > The default value is set by the `/proc/sys/net/core/wmem_default` file
    /// > and the maximum allowed value is set by the `/proc/sys/net/core/wmem_max` file.  
    /// > The minimum (doubled) value for this option is `2048`.
    /// 
    /// FreeBSD:
    /// > `SO_SNDBUF` and `SO_RCVBUF` are options to adjust the normal buffer sizes 
    /// > allocated for output and input buffers, respectively. The buffer size may be 
    /// > increased for high-volume connections, or may  be decreased to limit 
    /// > the possible backlog of incoming data. The system places an absolute maximum 
    /// > on these values, which is accessible through the `sysctl(3)` MIB variable 
    /// > `kern.ipc.maxsockbuf`.
    /// 
    /// Gets the value.
    /// 
    /// A [usize] is returned. 
    #[inline] 
    fn get_so_send_buf_size(&self) -> io::Result<<SoSndBuf as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoSndBuf, Self>(self)
                .map(|v| v.get());
    }

    /// ## SO_SNDBUF
    /// 
    /// Linux: 
    /// > Sets or gets the maximum socket send buffer in bytes. The kernel 
    /// > doubles this value (to allow space for bookkeeping overhead) when it is 
    /// > set using `setsockopt(2)`, and this doubled value is returned by `getsockopt(2)`.  
    /// > The default value is set by the `/proc/sys/net/core/wmem_default` file
    /// > and the maximum allowed value is set by the `/proc/sys/net/core/wmem_max` file.  
    /// > The minimum (doubled) value for this option is `2048`.
    /// 
    /// FreeBSD:
    /// > `SO_SNDBUF` and `SO_RCVBUF` are options to adjust the normal buffer sizes 
    /// > allocated for output and input buffers, respectively. The buffer size may be 
    /// > increased for high-volume connections, or may  be decreased to limit 
    /// > the possible backlog of incoming data. The system places an absolute maximum 
    /// > on these values, which is accessible through the `sysctl(3)` MIB variable 
    /// > `kern.ipc.maxsockbuf`.
    /// 
    /// Sets the value.
    /// 
    /// A [usize] should be provided as argument.
    #[inline]
    fn set_so_send_buf_size(&self, sz: <SoSndBuf as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoSndBuf, Self>(self, SoSndBuf::from_user(sz));
    }

    // --

    /// ## SO_SNDLOWAT
    /// 
    /// Linux: 
    /// > Specify the minimum number of bytes in the buffer until the socket layer will 
    /// > pass the data to the protocol (SO_SNDLOWAT) or the user on receiving (SO_RCVLOWAT).
    /// > These two values are initialized to 1.  SO_SNDLOWAT is not changeable on 
    /// > Linux (setsockopt(2) fails with the error ENOPROTOOPT).  SO_RCVLOWAT is changeable 
    /// > only since Linux 2.4.
    /// 
    /// FreeBSD: 
    /// > SO_SNDLOWAT is an option to set the minimum count for output operations.  
    /// > Most output operations process all of the data supplied by the call, delivering 
    /// > data to the protocol for transmission and blocking as necessary for flow control. 
    /// > Nonblocking output operations will process as much data as permitted subject to 
    /// > flow control without blocking, but will process no data if flow control does not 
    /// > allow the smaller of the low water mark value	or the entire request to be processed. 
    /// > A `select(2)` operation testing the ability to write to a socket will return true  
    /// > only if the low water mark amount could be processed. The default value for 
    /// > `SO_SNDLOWAT` is set to a convenient size for network efficiency, often `1024`.
    /// 
    /// Gets the value.
    /// 
    /// A [usize] is returned.
    #[cfg(unix)]
    #[inline] 
    fn get_so_send_output_min_count(&self) -> io::Result<<SoSndLoWat as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoSndLoWat, Self>(self)
                .map(|v| v.get());
    }

    /// ## SO_SNDLOWAT
    /// 
    /// Linux: 
    /// > Specify the minimum number of bytes in the buffer until the socket layer will 
    /// > pass the data to the protocol (SO_SNDLOWAT) or the user on receiving (SO_RCVLOWAT).
    /// > These two values are initialized to 1.  SO_SNDLOWAT is not changeable on 
    /// > Linux (setsockopt(2) fails with the error ENOPROTOOPT).  SO_RCVLOWAT is changeable 
    /// > only since Linux 2.4.
    /// 
    /// FreeBSD: 
    /// > SO_SNDLOWAT is an option to set the minimum count for output operations.  
    /// > Most output operations process all of the data supplied by the call, delivering 
    /// > data to the protocol for transmission and blocking as necessary for flow control. 
    /// > Nonblocking output operations will process as much data as permitted subject to 
    /// > flow control without blocking, but will process no data if flow control does not 
    /// > allow the smaller of the low water mark value	or the entire request to be processed. 
    /// > A `select(2)` operation testing the ability to write to a socket will return true  
    /// > only if the low water mark amount could be processed. The default value for 
    /// > `SO_SNDLOWAT` is set to a convenient size for network efficiency, often `1024`.
    /// 
    /// Sets the value.
    /// 
    /// A [usize] should be provided as argument.
    #[cfg(unix)]
    #[inline]
    fn set_so_send_output_min_count(&self, sz: <SoSndLoWat as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoSndLoWat, Self>(self, SoSndLoWat::from_user(sz));
    }

    // --

    /// ## SO_SNDTIMEO
    /// 
    /// Linux: 
    /// > Specify the receiving or sending timeouts until reporting an error.  
    /// > The argument is a struct timeval. If an input or output function 
    /// > blocks for this period of time, and data has been sent or received, the 
    /// > return value of that function will be the amount of data transferred; 
    /// > if no data has been transferred and the timeout has been reached, then
    /// > -1 is returned with errno set to `EAGAIN` or `EWOULDBLOCK`, or `EINPROGRESS` 
    /// > (for `connect(2)`) just as if the socket was specified to be nonblocking.  
    /// > If the timeout is set to zero (the default), then the operation will 
    /// > never timeout. Timeouts only have effect for system calls that perform
    /// > socket I/O (e.g., `accept(2)`, `connect(2)`, `read(2)`, `recvmsg(2)`, 
    /// > `send(2)`, `sendmsg(2)`); timeouts have no effect for `select(2)`, `poll(2)`, 
    /// > `epoll_wait(2)`, and so on.
    /// 
    /// FreeBSD:
    /// > is an option to set a timeout value for output operations. 
    /// > It accepts a struct timeval argument with the number of seconds and mi-
    /// > croseconds used to limit waits for output operations to complete. If a
    /// > send operation has blocked for this much time, it returns with  a partial 
    /// > count or with the error EWOULDBLOCK if no data were sent. In the
    /// > current implementation, this timer is restarted  each  time  additional
    /// > data  are delivered to the protocol, implying that the limit applies to
    /// > output portions ranging in size from the low water mark to the high water 
    /// >mark for output.
    /// 
    /// Gets the value.
    /// 
    /// A [Option] with inner [Duration] is returned. If [Option::None] is
    /// returned, does mean disabled.
    #[inline] 
    fn get_so_send_timeout(&self) -> io::Result<<SoSndTimeout as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoSndTimeout, Self>(self)
                .map(|v| v.get());
    }

    /// ## SO_SNDTIMEO
    /// 
    /// Linux: 
    /// > Specify the receiving or sending timeouts until reporting an error.  
    /// > The argument is a struct timeval. If an input or output function 
    /// > blocks for this period of time, and data has been sent or received, the 
    /// > return value of that function will be the amount of data transferred; 
    /// > if no data has been transferred and the timeout has been reached, then
    /// > -1 is returned with errno set to `EAGAIN` or `EWOULDBLOCK`, or `EINPROGRESS` 
    /// > (for `connect(2)`) just as if the socket was specified to be nonblocking.  
    /// > If the timeout is set to zero (the default), then the operation will 
    /// > never timeout. Timeouts only have effect for system calls that perform
    /// > socket I/O (e.g., `accept(2)`, `connect(2)`, `read(2)`, `recvmsg(2)`, 
    /// > `send(2)`, `sendmsg(2)`); timeouts have no effect for `select(2)`, `poll(2)`, 
    /// > `epoll_wait(2)`, and so on.
    /// 
    /// FreeBSD:
    /// > is an option to set a timeout value for output operations. 
    /// > It accepts a struct timeval argument with the number of seconds and mi-
    /// > croseconds used to limit waits for output operations to complete. If a
    /// > send operation has blocked for this much time, it returns with  a partial 
    /// > count or with the error EWOULDBLOCK if no data were sent. In the
    /// > current implementation, this timer is restarted  each  time  additional
    /// > data  are delivered to the protocol, implying that the limit applies to
    /// > output portions ranging in size from the low water mark to the high water 
    /// >mark for output.
    /// 
    /// Sets the value.
    /// 
    /// A [Option] should be provided with inner [Duration] as argument.
    /// An [Option::None] disables the timeout.
    #[inline]
    fn set_so_send_timeout(&self, size: <SoSndTimeout as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoSndTimeout, Self>(self, SoSndTimeout::from_user(size));
    }    

    /// ## SO_INCOMING_CPU
    /// 
    /// Linux:
    /// > Sets or gets the CPU affinity of a socket. Expects an integer flag.
    /// > Because all of the packets for a single stream (i.e., all packets for 
    /// > the same 4-tuple) arrive on the single RX queue that is associated with 
    /// > a particular CPU, the typical use case is to employ one listening process 
    /// > per RX queue, with the incoming flow being handled by a listener on the 
    /// > same CPU that is handling the RX queue.  This provides optimal
    /// > NUMA behavior and keeps CPU caches hot.
    /// 
    /// Gets the value.
    /// 
    /// A [i32] is returned.
    #[cfg(any(target_os = "linux"))]
    #[inline]
    fn get_so_cpu_affinity(&self) -> io::Result<<SoCpuAffinity as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoCpuAffinity, Self>(self)
                .map(|v| v.get());
    }

    /// ## SO_INCOMING_CPU
    /// 
    /// Linux:
    /// > Sets or gets the CPU affinity of a socket. Expects an integer flag.
    /// > Because all of the packets for a single stream (i.e., all packets for 
    /// > the same 4-tuple) arrive on the single RX queue that is associated with 
    /// > a particular CPU, the typical use case is to employ one listening process 
    /// > per RX queue, with the incoming flow being handled by a listener on the 
    /// > same CPU that is handling the RX queue.  This provides optimal
    /// > NUMA behavior and keeps CPU caches hot.
    /// 
    /// Sets the value.
    /// 
    /// A [i32] should be provided as argument.
    #[cfg(any(target_os = "linux"))]
    #[inline]
    fn set_so_cpu_affinity(&self, size: <SoCpuAffinity as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoCpuAffinity, Self>(self, SoCpuAffinity::from_user(size));
    }   

    /// ## SO_INCOMING_NAPI_ID
    /// 
    /// Linux: 
    /// > Returns a system-level unique ID called NAPI ID that is associated with 
    /// > a RX queue on which the last packet associated with that socket is received.
    /// > This can be used by an application to split the incoming flows among worker 
    /// > threads based on the RX queue on which the packets associated with the flows 
    /// > are received.  It allows each worker thread to be associated with a NIC HW
    /// > receive queue and service all the connection requests received on that RX queue.  
    /// > This mapping between an app thread and a HW NIC queue streamlines the flow of data 
    /// > from the NIC to the application.
    /// 
    /// Gets the value.
    /// 
    /// A [u32] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_incoming_napi_id(&self) -> io::Result<<SoIncomingNapiId as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoIncomingNapiId, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_MARK
    /// 
    /// Linux:
    /// > Set the mark for each packet sent through this socket 
    /// > (similar to the netfilter MARK target but socket-based).
    /// > Changing the mark can be used for mark-based routing without netfilter or 
    /// > for packet filtering.  Setting this option requires the `CAP_NET_ADMIN` or 
    /// `CAP_NET_RAW` (since Linux 5.17) capability.
    /// 
    /// Gets the value
    /// 
    /// A [u32] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_mark(&self) -> io::Result<<SoMark as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoMark, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_MARK
    /// 
    /// Linux:
    /// > Set the mark for each packet sent through this socket 
    /// > (similar to the netfilter MARK target but socket-based).
    /// > Changing the mark can be used for mark-based routing without netfilter or 
    /// > for packet filtering.  Setting this option requires the `CAP_NET_ADMIN` or 
    /// `CAP_NET_RAW` (since Linux 5.17) capability.
    /// 
    /// Gets the value
    /// 
    /// A [u32] should be provided as argument.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_mark(&self, mark: <SoMark as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoMark, Self>(self, SoMark::from_user(mark));
    } 

    /// ## SO_BUSY_POLL
    /// 
    /// Linux: 
    /// > Sets the approximate time in microseconds to busy poll on a
    /// > blocking receive when there is no data.  Increasing this
    /// > value requires `CAP_NET_ADMIN`.  The default for this option
    /// > is controlled by the `/proc/sys/net/core/busy_read` file.
    /// > 
    /// > The value in the /proc/sys/net/core/busy_poll file
    /// > determines how long select(2) and poll(2) will busy poll
    /// > when they operate on sockets with SO_BUSY_POLL set and no
    /// > events to report are found.
    /// > 
    /// > In both cases, busy polling will only be done when the
    /// > socket last received data from a network device that
    /// > supports this option.
    /// > 
    /// > While busy polling may improve latency of some
    /// > applications, care must be taken when using it since this
    /// > will increase both CPU utilization and power usage.
    /// 
    /// Gets the value.
    /// 
    /// A [i32] sis returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_busy_poll(&self) -> io::Result<<SoBusyPoll as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoBusyPoll, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_BUSY_POLL
    /// 
    /// Linux: 
    /// > Sets the approximate time in microseconds to busy poll on a
    /// > blocking receive when there is no data.  Increasing this
    /// > value requires `CAP_NET_ADMIN`.  The default for this option
    /// > is controlled by the `/proc/sys/net/core/busy_read` file.
    /// > 
    /// > The value in the /proc/sys/net/core/busy_poll file
    /// > determines how long select(2) and poll(2) will busy poll
    /// > when they operate on sockets with SO_BUSY_POLL set and no
    /// > events to report are found.
    /// > 
    /// > In both cases, busy polling will only be done when the
    /// > socket last received data from a network device that
    /// > supports this option.
    /// > 
    /// > While busy polling may improve latency of some
    /// > applications, care must be taken when using it since this
    /// > will increase both CPU utilization and power usage.
    /// 
    /// Sets the value.
    /// 
    /// A [i32] should be provided as argument.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_busy_poll(&self, bp: <SoBusyPoll as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoBusyPoll, Self>(self, SoBusyPoll::from_user(bp));
    }

    /// ## SO_TIMESTAMP
    /// 
    /// Linux: 
    /// > Enable or disable the receiving of the `SO_TIMESTAMP` control message.
    /// > The timestamp control message is sent with level `SOL_SOCKET` and a `cmsg_type` 
    /// > of `SCM_TIMESTAMP`.  The cmsg_data field is a struct timeval indicating the 
    /// > reception time of the last packet passed to the user in this call.  See
    /// > `cmsg(3)` for details on control messages.
    /// > A socket cannot mix `SO_TIMESTAMP` and `SO_TIMESTAMPNS`: the two modes 
    /// > are mutually exclusive.
    /// 
    /// FreeBSD:
    /// > enables reception of a timestamp with datagrams
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "android"))]
    #[inline]
    fn get_so_timestamp(&self) -> io::Result<<SoTimestamp as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoTimestamp, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_TIMESTAMP
    /// 
    /// Linux: 
    /// > Enable or disable the receiving of the `SO_TIMESTAMP` control message.
    /// > The timestamp control message is sent with level `SOL_SOCKET` and a `cmsg_type` 
    /// > of `SCM_TIMESTAMP`.  The cmsg_data field is a struct timeval indicating the 
    /// > reception time of the last packet passed to the user in this call.  See
    /// > `cmsg(3)` for details on control messages.
    /// > A socket cannot mix `SO_TIMESTAMP` and `SO_TIMESTAMPNS`: the two modes 
    /// > are mutually exclusive.
    /// 
    /// FreeBSD:
    /// > enables reception of a timestamp with datagrams
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument. When set to `true` - enables.
    #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "android"))]
    #[inline]
    fn set_so_timestamp(&self, tm: <SoTimestamp as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoTimestamp, Self>(self, SoTimestamp::from_user(tm));
    }

    /// ## SO_TIMESTAMPNS
    /// 
    /// Linux:
    /// > Enable or disable the receiving of the `SO_TIMESTAMPNS` control message.  
    /// > The timestamp control message is sent with level SOL_SOCKET and a cmsg_type 
    /// > of `SCM_TIMESTAMPNS`. The cmsg_data field is a struct timespec indicating the
    /// > reception time of the last packet passed to the user in this call. 
    /// > The clock used for the timestamp is `CLOCK_REALTIME`.  See `cmsg(3)` for details 
    /// > on control messages.
    /// > A socket cannot mix `SO_TIMESTAMP` and `SO_TIMESTAMPNS`: the two modes 
    /// > are mutually exclusive.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_timestamp_ns(&self) -> io::Result<<SoTimestampNs as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoTimestampNs, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_TIMESTAMPNS
    /// 
    /// Linux:
    /// > Enable or disable the receiving of the `SO_TIMESTAMPNS` control message.  
    /// > The timestamp control message is sent with level SOL_SOCKET and a cmsg_type 
    /// > of `SCM_TIMESTAMPNS`. The cmsg_data field is a struct timespec indicating the
    /// > reception time of the last packet passed to the user in this call. 
    /// > The clock used for the timestamp is `CLOCK_REALTIME`.  See `cmsg(3)` for details 
    /// > on control messages.
    /// > A socket cannot mix `SO_TIMESTAMP` and `SO_TIMESTAMPNS`: the two modes 
    /// > are mutually exclusive.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be provided as argument. If set to `true` - enables.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_timestamp_ns(&self, tm: <SoTimestampNs as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoTimestampNs, Self>(self, SoTimestampNs::from_user(tm));
    }

    /// ## SO_SNDBUFFORCE
    /// 
    /// Linux: 
    /// > Using this socket option, a privileged (`CAP_NET_ADMIN`) process can perform 
    /// > the same task as `SO_SNDBUF`, but the `wmem_max` limit can be overridden.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_snd_buf_force(&self) -> io::Result<<SoSndBufForce as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoSndBufForce, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_SNDBUFFORCE
    /// 
    /// Linux: 
    /// > Using this socket option, a privileged (`CAP_NET_ADMIN`) process can perform 
    /// > the same task as `SO_SNDBUF`, but the `wmem_max` limit can be overridden.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be returned as argument.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_snd_buf_force(&self, size: <SoSndBufForce as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoSndBufForce, Self>(self, SoSndBufForce::from_user(size));
    }

    /// ## SO_SELECT_ERR_QUEUE
    /// 
    /// Linux: 
    /// > When this option is set on a socket, an error condition on a socket causes 
    /// > notification not only via the exceptfds set of `select(2)`.  
    /// > Similarly, `poll(2)` also returns a `POLLPRI` whenever an `POLLERR` event is returned.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned. 
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_select_err_queue(&self) -> io::Result<<SoSelectErrQue as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoSelectErrQue, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_SELECT_ERR_QUEUE
    /// 
    /// Linux: 
    /// > When this option is set on a socket, an error condition on a socket causes 
    /// > notification not only via the exceptfds set of `select(2)`.  
    /// > Similarly, `poll(2)` also returns a `POLLPRI` whenever an `POLLERR` event is returned.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be returned as argument.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_select_err_queue(&self, flag: <SoSelectErrQue as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoSelectErrQue, Self>(self, SoSelectErrQue::from_user(flag));
    }

    // ---

    /// ## SO_RXQ_OVFL
    /// 
    /// Linux: 
    /// > Indicates that an unsigned 32-bit value ancillary message (cmsg) should be attached 
    /// > to received skbs indicating the number of packets dropped by the socket since its 
    /// > creation.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned. 
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_rxq_ovfl(&self) -> io::Result<<SoRqxOvfl as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoRqxOvfl, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_RXQ_OVFL
    /// 
    /// Linux: 
    /// > Indicates that an unsigned 32-bit value ancillary message (cmsg) should be attached 
    /// > to received skbs indicating the number of packets dropped by the socket since its 
    /// > creation.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] should be returned as argument.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_rxq_ovfl(&self, flag: <SoRqxOvfl as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoRqxOvfl, Self>(self, SoRqxOvfl::from_user(flag));
    }

    // ----

    /// ## SO_PEERCRED
    /// 
    /// Linux: 
    /// > Return the credentials of the peer process connected to this socket.  
    /// > For further details, see unix(7).
    /// > https://github.com/falk-werner/peercred-example/blob/main/src/server.c
    /// 
    /// Gets the value.
    /// 
    /// A [libc::ucred] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_peercred(&self) -> io::Result<<SoPeercred as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoPeercred, Self>(self)
                .map(|v| v.get());
    } 

    // ----

    /// ## SO_PEERSEC
    /// 
    /// Linux:
    /// > Return the security context of the peer socket connected to this socket.  
    /// > For further details, see `unix(7)` and `ip(7)`.
    /// 
    /// Gets the value.
    /// 
    /// A [Vec] is returned. A max value is read into 512 bytes array.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_peersec(&self) -> io::Result<<SoPeersec as SockOptMarker>::DataType>
    {
        // todo! if a ERANGE retrned, the buffer space is too small, so in this case
        // it should be done manually by calling a getsockopt in manual mode.
        // the size argument of getsockopt will contain the length.
        // OR add a error handling function in the SockOptMarker which would 
        // get a length value and ask for retry
        return 
            getsockopt::<SoPeersec, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_PASSSEC
    /// 
    /// Linux:
    /// > Enable or disable the receiving of the `SCM_SECURITY` control message.  
    /// > For more information, see `unix(7)`.
    /// 
    /// Gets the value.
    /// 
    /// A [bool] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_passsec(&self) -> io::Result<<SoPassec as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoPassec, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_PASSSEC
    /// 
    /// Linux:
    /// > Enable or disable the receiving of the `SCM_SECURITY` control message.  
    /// > For more information, see `unix(7)`.
    /// 
    /// Sets the value.
    /// 
    /// A [bool] arg should be provided. if `true` - enables.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_passsec(&self, flag: <SoPassec as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoPassec, Self>(self, SoPassec::from_user(flag));
    }

// ----
    /// ## SO_PEEK_OFF
    /// 
    /// Linux: 
    /// > This option, which is currently supported only for unix(7) sockets, sets 
    /// > the value of the "peek offset" for the recv(2) system call when used with 
    /// > MSG_PEEK flag.
    /// >
    /// > When this option is set to a negative value (it is set to -1 for all new sockets), 
    /// > traditional behavior is provided: recv(2) with the MSG_PEEK flag will peek 
    /// > data from the front of the queue.
    /// 
    /// Gets the value.
    /// 
    /// A [i32] is returned.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn get_so_peek_off(&self) -> io::Result<<SoPeekOff as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<SoPeekOff, Self>(self)
                .map(|v| v.get());
    } 

    /// ## SO_PEEK_OFF
    /// 
    /// Linux: 
    /// > This option, which is currently supported only for unix(7) sockets, sets 
    /// > the value of the "peek offset" for the recv(2) system call when used with 
    /// > MSG_PEEK flag.
    /// >
    /// > When this option is set to a negative value (it is set to -1 for all new sockets), 
    /// > traditional behavior is provided: recv(2) with the MSG_PEEK flag will peek 
    /// > data from the front of the queue.
    /// 
    /// Sets the value.
    /// 
    /// A [i32] argument should be provided.
    #[cfg(any(target_os = "linux", target_os = "android"))]
    #[inline]
    fn set_so_peek_off(&self, offset: <SoPeekOff as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<SoPeekOff, Self>(self, SoPeekOff::from_user(offset));
    }
}

pub trait Socket9ExtSoIp<T = Dum>: AsOsDescr + Sized
{
    #[cfg(any(target_os = "android", target_os = "linux", target_os = "windows"))]
    #[inline]
    fn get_so_ip6_original_dst(&self) -> <SoIp6OriginalDst as SockOptMarker>::DataType
    {
        return 
            getsockopt::<SoIp6OriginalDst, Self>(self)
                .map_or_else(
                    |e| Err(e), 
                    |f| f.get()
                );
    }
}

// https://man.freebsd.org/cgi/man.cgi?query=getsockopt&apropos=0&sektion=2&manpath=FreeBSD+15.0-RELEASE&arch=default&format=html
// https://man7.org/linux/man-pages/man7/socket.7.html

/// A collection of the socket operations of level [libc::SOL_IP].
pub trait Socket9ExtSoIp6<T = Dum>: AsOsDescr + Sized
{
    #[inline]
    fn get_so_ip_original_dst(&self) -> <SoIpOriginalDst as SockOptMarker>::DataType
    {
        return 
            getsockopt::<SoIpOriginalDst, Self>(self)
                .map_or_else(
                    |e| Err(e), 
                    |f| f.get()
                );
    }
}
/// A collection of the socket operations of level [libc::IPPROTO_IP].
/// A raw sockets only.
pub trait Socket9ExtIpRaw<T = Dum>: AsOsDescr + Sized
{
    /// # IP_HDRINCL (RAW SOCKET ONLY)
    /// 
    /// Gets the value. 
    /// 
    /// # Returns
    /// 
    /// A [bool] is returned which indicates a status.
    /// 
    /// Linux:
    /// > If enabled, the user supplies an IP header in front of the
    /// > user data.  Valid only for SOCK_RAW sockets; see raw(7) for
    /// > more information.  When this flag is enabled, the values
    /// > set by IP_OPTIONS, IP_TTL, and IP_TOS are ignored.
    #[cfg(not(any(target_os = "redox")))]
    #[inline] 
    fn get_ip_header_included(&self) -> io::Result<<IpHdrincl as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpHdrincl, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_HDRINCL (RAW SOCKET ONLY)
    /// 
    /// Sets the value.
    /// 
    /// # Arguments 
    /// 
    /// * `flag` - [bool] enabled or disabled.
    /// 
    /// Linux:
    /// > If enabled, the user supplies an IP header in front of the
    /// > user data.  Valid only for SOCK_RAW sockets; see raw(7) for
    /// > more information.  When this flag is enabled, the values
    /// > set by IP_OPTIONS, IP_TTL, and IP_TOS are ignored.
    #[cfg(not(any(target_os = "redox")))]
    #[inline]
    fn set_ip_header_included(&self, flag: <IpHdrincl as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpHdrincl, Self>(self, IpHdrincl::from_user(flag));
    }  
}

/// A collection of the socket operations of level [libc::IPPROTO_IPV6]. 
/// A raw sockets only.
pub trait Socket9ExtIp6Raw<T = Dum>: AsOsDescr + Sized
{
    
    #[cfg(not(any(target_os = "redox")))]
    #[inline] 
    fn get_ip6_header_included(&self) -> io::Result<<Ip6Hdrincl as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6Hdrincl, Self>(self)
                .map(|v| v.get());
    }

    #[cfg(not(any(target_os = "redox")))]
    #[inline]
    fn set_ip6_header_included(&self, flag: <Ip6Hdrincl as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6Hdrincl, Self>(self, Ip6Hdrincl::from_user(flag));
    }  
}

// todo https://man7.org/linux/man-pages/man7/ip.7.html
/// A collection of the socket operations of level [libc::IPPROTO_TCP]. 
pub trait Socket9ExtIp<T = Dum>: AsOsDescr + Sized
{
    #[cfg(any(
        target_os = "android",
        target_os = "linux"
    ))]
    fn get_ip_tcp_thin_linear_timeouts(&self) -> io::Result<<IpProtoTcpThinLinearTimeouts as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpProtoTcpThinLinearTimeouts, Self>(self)
                .map(|v| v.get());
    }

    #[cfg(any(
        target_os = "android",
        target_os = "linux"
    ))]
    #[inline]
    fn set_ip_tcp_thin_linear_timeouts(&self, flag: <IpProtoTcpThinLinearTimeouts as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpProtoTcpThinLinearTimeouts, Self>(self, IpProtoTcpThinLinearTimeouts::from_user(flag));
    } 

    #[cfg(any(
        target_os = "android",
        target_os = "linux"
    ))]
    fn get_ip_tcp_notsent_lowat(&self) -> io::Result<<IpProtoNotsentLowat as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpProtoNotsentLowat, Self>(self)
                .map(|v| v.get());
    }

    #[cfg(any(
        target_os = "android",
        target_os = "linux"
    ))]
    #[inline]
    fn set_ip_tcp_notsent_lowat(&self, flag: <IpProtoNotsentLowat as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpProtoNotsentLowat, Self>(self, IpProtoNotsentLowat::from_user(flag));
    } 

    /// # IP_TRANSPARENT
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [bool] is returned indicating the status of the feature.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Setting this boolean option enables transparent proxying on
    /// > this socket.  This socket option allows the calling
    /// > application to bind to a nonlocal IP address and operate
    /// > both as a client and a server with the foreign address as
    /// > the local endpoint.
    #[cfg(target_os = "linux")]
    #[inline] 
    fn get_ip_transparent(&self) -> io::Result<<IpTransparent as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpTransparent, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_TRANSPARENT
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `flag` - [bool] enables or disables.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Setting this boolean option enables transparent proxying on
    /// > this socket.  This socket option allows the calling
    /// > application to bind to a nonlocal IP address and operate
    /// > both as a client and a server with the foreign address as
    /// > the local endpoint.
    #[cfg(target_os = "linux")]
    #[inline]
    fn set_ip_transparent(&self, flag: <IpTransparent as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpTransparent, Self>(self, IpTransparent::from_user(flag));
    } 

    /// # IP_ADD_MEMBERSHIP
    /// 
    /// Sets the value.
    /// 
    /// Linux:
    /// > Join a multicast group.
    /// 
    /// # Arguments
    /// 
    /// * `multiaddr` [Ipv4Addr] - IP multicast group address
    /// 
    /// * `interface` [So9IfInder] - IP address of local interface or interface index
    #[cfg(not(any(
        target_os = "netbsd",
        target_os = "openbsd",
        target_os = "redox",
    )))]
    #[inline]
    fn ip_join_multicast(&self, multiaddr: Ipv4Addr, interface: So9IfInder) -> io::Result<()>
    {
        return 
            setsockopt
                ::<IpAddMembership, Self>(self, IpAddMembership::from_user((multiaddr, interface)));
    }

    /// # IP_DROP_MEMBERSHIP
    /// 
    /// Sets the value.
    /// 
    /// Linux: 
    /// > Leave a multicast group. Argument is an ip_mreqn or ip_mreq structure similar 
    /// > to IP_ADD_MEMBERSHIP.
    /// 
    /// # Arguments
    /// 
    /// * `multiaddr` [Ipv4Addr] - IP multicast group address
    /// 
    /// * `interface` [So9IfInder] - IP address of local interface or interface index
    #[cfg(not(any(
        target_os = "netbsd",
        target_os = "openbsd",
        target_os = "redox",
    )))]
    #[inline]
    fn ip_leave_multicast(&self, multiaddr: Ipv4Addr, interface: So9IfInder) -> io::Result<()>
    {
        return 
            setsockopt
                ::<IpDropMembership, Self>(self, IpDropMembership::from_user((multiaddr, interface)));
    }

    /// # IP_ADD_SOURCE_MEMBERSHIP
    /// 
    /// Sets the value.
    /// 
    /// Linux:
    /// > Join a multicast group and allow receiving data only from a specified source.  
    /// > Argument is an ip_mreq_source structure.
    /// 
    /// # Arguments
    /// 
    /// * `multiaddr` - IP multicast group address
    /// 
    /// * `interface` - IP address of local interface
    /// 
    /// * `source` - IP address of multicast source
    #[cfg(not(any(target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd", target_os = "redox")))]
    #[inline]
    fn ip_join_ssm(&self, multiaddr: Ipv4Addr, interface: Ipv4Addr, source: Ipv4Addr) -> io::Result<()>
    {
        return 
            setsockopt
                ::<IpAddSourceMembership, Self>(self, 
                    IpAddSourceMembership::from_user((multiaddr, interface, source))
                );
    }

    /// # IP_DROP_SOURCE_MEMBERSHIP
    /// 
    /// Sets the value.

    /// 
    /// # Arguments:
    /// 
    /// * `multiaddr` - IP multicast group address
    /// 
    /// * `interface` - IP address of local interface
    /// 
    /// * `source` - IP address of multicast source
    ///
    /// # Man 
    /// 
    /// Linux:
    /// > Leave a source-specific group—that is, stop receiving data from a given 
    /// > multicast group that come from a given source. If the application has 
    /// > subscribed to multiple sources within the same group, data from the 
    /// > remaining sources will still be delivered.  To stop receiving data from all
    /// > sources at once, use IP_DROP_MEMBERSHIP - [Self::ip_leave_multicast]. 
    #[cfg(not(any(target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd", target_os = "redox")))]
    #[inline]
    fn ip_leave_ssm(&self, multiaddr: Ipv4Addr, interface: Ipv4Addr, source: Ipv4Addr) -> io::Result<()>
    {
        return 
            setsockopt
                ::<IpDropSourceMembership, Self>(self, 
                    IpDropSourceMembership::from_user((multiaddr, interface, source))
                );
    }

    /// # IP_MULTICAST_ALL
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [bool] is returned which indicates a status.
    /// 
    /// # Man 
    /// 
    /// Linux:
    /// > This option can be used to modify the delivery policy of
    /// > multicast messages.  The argument is a boolean integer
    /// > (defaults to 1).  If set to 1, the socket will receive
    /// > messages from all the groups that have been joined globally
    /// > on the whole system.  Otherwise, it will deliver messages
    /// > only from the groups that have been explicitly joined (for
    /// > example via the IP_ADD_MEMBERSHIP option) on this
    /// > particular socket.
    #[cfg(target_os = "linux")]
    #[inline] 
    fn get_ip_multicast_all(&self) -> io::Result<<IpMulticastAll as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpMulticastAll, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_MULTICAST_ALL
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `flag` - [bool] sets the status.
    /// 
    /// # Man 
    /// 
    /// Linux:
    /// > This option can be used to modify the delivery policy of
    /// > multicast messages.  The argument is a boolean integer
    /// > (defaults to 1).  If set to 1, the socket will receive
    /// > messages from all the groups that have been joined globally
    /// > on the whole system.  Otherwise, it will deliver messages
    /// > only from the groups that have been explicitly joined (for
    /// > example via the IP_ADD_MEMBERSHIP option) on this
    /// > particular socket.
    #[cfg(target_os = "linux")]
    #[inline]
    fn set_ip_multicast_all(&self, flag: <IpMulticastAll as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpMulticastAll, Self>(self, IpMulticastAll::from_user(flag));
    } 

    /// # IP_MULTICAST_IF
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [Ipv4Addr] is returned.
    /// 
    /// # Man 
    /// 
    /// Linux:
    /// > Set the local device for a multicast socket.  The argument
    /// > for `setsockopt(2)` is an ip_mreqn structure similar to `IP_ADD_MEMBERSHIP`, or an
    /// > `in_addr` structure.  (The kernel determines which structure is being passed 
    /// > based on the size passed in optlen.)  For `getsockopt(2)`, the argument is 
    /// > an `in_addr` structure.
    #[inline] 
    fn get_ip_multicast_if(&self) -> io::Result<<IpMulticastIf as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpMulticastIf, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_MULTICAST_IF
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `intf` - [Ipv4Addr] a local device for a multicast socket.
    /// 
    /// # Man 
    /// 
    /// Linux:
    /// > Set the local device for a multicast socket.  The argument
    /// > for `setsockopt(2)` is an ip_mreqn structure similar to `IP_ADD_MEMBERSHIP`, or an
    /// > `in_addr` structure.  (The kernel determines which structure is being passed 
    /// > based on the size passed in optlen.)  For `getsockopt(2)`, the argument is 
    /// > an `in_addr` structure.
    #[inline]
    fn set_ip_multicast_if(&self, intf: <IpMulticastIf as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpMulticastIf, Self>(self, IpMulticastIf::from_user(intf));
    } 

    /// # IP_MULTICAST_LOOP
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [bool] is returned which indicates the status of the option.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or read a boolean integer argument that determines
    /// > whether sent multicast packets should be looped back to the
    /// > local sockets.
    #[inline] 
    fn get_ip_multicast_loop(&self) -> io::Result<<IpMulticastLoop as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpMulticastLoop, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_MULTICAST_LOOP
    /// 
    /// Sets the value.
    /// 
    /// # Arguemnts
    /// 
    /// * `intf` - [bool] enables or disables.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or read a boolean integer argument that determines
    /// > whether sent multicast packets should be looped back to the
    /// > local sockets.
    #[inline]
    fn set_ip_multicast_loop(&self, intf: <IpMulticastLoop as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpMulticastLoop, Self>(self, IpMulticastLoop::from_user(intf));
    } 

    /// # IP_MULTICAST_TTL
    /// 
    /// Gets the value.
    /// 
    /// # Returns 
    /// 
    /// A [u32] time-to-live value is returned for the current instance.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or read the time-to-live value of outgoing multicast
    /// > packets for this socket.  It is very important for
    /// > multicast packets to set the smallest TTL possible.  The
    /// > default is 1 which means that multicast packets don't leave
    /// > the local network unless the user program explicitly
    /// > requests it.  Argument is an integer.
    #[inline] 
    fn get_ip_multicast_ttl(&self) -> io::Result<<IpMulticastTtl as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpMulticastTtl, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_MULTICAST_TTL
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `ttl` - [u32] a time-to-live of outgoing multicast for the 
    ///     current instance.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or read the time-to-live value of outgoing multicast
    /// > packets for this socket.  It is very important for
    /// > multicast packets to set the smallest TTL possible.  The
    /// > default is 1 which means that multicast packets don't leave
    /// > the local network unless the user program explicitly
    /// > requests it.  Argument is an integer.
    #[inline]
    fn set_ip_multicast_ttl(&self, ttl: <IpMulticastTtl as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpMulticastTtl, Self>(self, IpMulticastTtl::from_user(ttl));
    } 

    /// # IP_TTL
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [u32] value is retrned which is a current time-to-live.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or retrieve the current time-to-live field that is used
    /// > in every packet sent from this socket.
    #[inline] 
    fn get_ip_ttl(&self) -> io::Result<<IpTtl as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpTtl, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_TTL
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `ttl` - [u32] a current time-to-live. 
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or retrieve the current time-to-live field that is used
    /// > in every packet sent from this socket.
    #[inline]
    fn set_ip_ttl(&self, ttl: <IpTtl as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpTtl, Self>(self, IpTtl::from_user(ttl));
    } 

    /// # IP_TOS
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [u32] is returned.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or receive the Type-Of-Service (TOS) field that is sent
    /// > with every IP packet originating from this socket.  It is
    /// > used to prioritize packets on the network.  TOS is a byte.
    /// > ...
    #[cfg(not(any(target_os = "redox", target_os = "solaris")))]
    #[inline] 
    fn get_ip_tos(&self) -> io::Result<<IpTos as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpTos, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_TOS
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// `tos` - [u32] value.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set or receive the Type-Of-Service (TOS) field that is sent
    /// > with every IP packet originating from this socket.  It is
    /// > used to prioritize packets on the network.  TOS is a byte.
    /// > ...
    #[cfg(not(any(target_os = "redox", target_os = "solaris")))]
    #[inline]
    fn set_ip_tos(&self, tos: <IpTos as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpTos, Self>(self, IpTos::from_user(tos));
    } 

    /// # IP_RECVTOS
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [bool] is returns which indicates the enabled/disabled status of
    /// the feature.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > If enabled, the `IP_TOS` ancillary message is passed with
    /// > incoming packets.  It contains a byte which specifies the
    /// > Type of Service/Precedence field of the packet header.
    /// > Expects a boolean integer flag.  Not supported for
    /// > `SOCK_STREAM` sockets.
    #[cfg(not(any(target_os = "netbsd", target_os = "dragonfly", target_os = "openbsd", target_os = "redox", target_os = "solaris")))]
    #[inline] 
    fn get_ip_recv_tos(&self) -> io::Result<<IpRecvTos as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpRecvTos, Self>(self)
                .map(|v| v.get());
    }

    /// # IP_RECVTOS
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `tos` - [bool] enables or disables feature for the current socket.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > If enabled, the `IP_TOS` ancillary message is passed with
    /// > incoming packets.  It contains a byte which specifies the
    /// > Type of Service/Precedence field of the packet header.
    /// > Expects a boolean integer flag.  Not supported for
    /// > `SOCK_STREAM` sockets.
    #[cfg(not(any(target_os = "netbsd", target_os = "dragonfly", target_os = "openbsd", target_os = "redox", target_os = "solaris")))]
    #[inline]
    fn set_ip_recv_tos(&self, tos: <IpRecvTos as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpRecvTos, Self>(self, IpRecvTos::from_user(tos));
    } 
}

//todo https://man7.org/linux/man-pages/man7/ipv6.7.html
/// A collection of the socket operations of level [libc::IPPROTO_IPV6]. 
pub trait Socket9ExtIp6<T = Dum>: AsOsDescr + Sized
{
    /// # IPV6_ADD_MEMBERSHIP
    /// 
    /// Joins the multicast group.
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `mu_addr` - [Ipv6Addr] - multicast address
    /// 
    /// * `intrf` - [u32] - interface number
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Control membership in multicast groups.
    #[inline] 
    fn ip6_join_multicast(&self, mu_addr: Ipv6Addr, intrf: u32) -> io::Result<()>
    {
        return 
            setsockopt
                ::<Ip6AddMembership, Self>(self, Ip6AddMembership::from_user((mu_addr, intrf)));
    }

    /// # IPV6_DROP_MEMBERSHIP
    /// 
    /// Leaves the multicast group.
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `mu_addr` - [Ipv6Addr] - multicast address
    /// 
    /// * `intrf` - [u32] - interface number
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Control membership in multicast groups. 
    #[inline] 
    fn ip6_leave_multicast(&self, mu_addr: Ipv6Addr, intrf: u32) -> io::Result<()>
    {
        return 
            setsockopt
                ::<Ip6DropMembership, Self>(self, Ip6DropMembership::from_user((mu_addr, intrf)));
    }


    /// # IPV6_MULTICAST_HOPS
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [i32] is returned.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set the multicast hop limit for the socket.  Argument is a
    /// > pointer to an integer.  -1 in the value means use the route
    /// > default, otherwise it should be between 0 and 255.
    #[inline] 
    fn get_ip6_multicast_hops(&self) -> io::Result<<Ip6MulticastHops as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6MulticastHops, Self>(self)
                .map(|v| v.get());
    }

    /// # IPV6_MULTICAST_HOPS
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `hops` - [i32] value.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set the multicast hop limit for the socket.  Argument is a
    /// > pointer to an integer.  -1 in the value means use the route
    /// > default, otherwise it should be between 0 and 255.
    #[inline]
    fn set_ip6_multicast_hops(&self, hops: <Ip6MulticastHops as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6MulticastHops, Self>(self, Ip6MulticastHops::from_user(hops));
    } 

    /// # IPV6_MULTICAST_IF
    /// 
    /// Gets the value.
    /// 
    /// # Returns 
    /// 
    /// A [u32] is returned (interface index).
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set the device for outgoing multicast packets on the socket. 
    /// > This is allowed only for `SOCK_DGRAM` and `SOCK_RAW` socket.  
    /// > The argument is a pointer to an interface index
    #[cfg(target_os = "linux")]
    #[inline] 
    fn get_ip6_multicast_all(&self) -> io::Result<<Ip6MulticastAll as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6MulticastAll, Self>(self)
                .map(|v| v.get());
    }

    /// # IPV6_MULTICAST_IF
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `flag` - a [u32] interface index.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set the device for outgoing multicast packets on the socket. 
    /// > This is allowed only for `SOCK_DGRAM` and `SOCK_RAW` socket.  
    /// > The argument is a pointer to an interface index
    #[cfg(target_os = "linux")]
    #[inline]
    fn set_ip6_multicast_all(&self, flag: <Ip6MulticastAll as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6MulticastAll, Self>(self, Ip6MulticastAll::from_user(flag));
    } 

    /// # IPV6_MULTICAST_LOOP
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [bool] is returned.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Control whether the socket sees multicast packets that it
    /// > has send itself.  Argument is a pointer to boolean.
    #[inline] 
    fn get_ip6_multicast_if(&self) -> io::Result<<Ip6MulticastIf as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6MulticastIf, Self>(self)
                .map(|v| v.get());
    }

    /// # IPV6_MULTICAST_LOOP
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `flag` - [bool] a status of the feature.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Control whether the socket sees multicast packets that it
    /// > has send itself.  Argument is a pointer to boolean.
    #[inline]
    fn set_ip6_multicast_if(&self, flag: <Ip6MulticastIf as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6MulticastIf, Self>(self, Ip6MulticastIf::from_user(flag));
    } 

    #[inline] 
    fn get_ip6_multicast_loop(&self) -> io::Result<<Ip6MulticastLoop as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6MulticastLoop, Self>(self)
                .map(|v| v.get());
    }

    #[inline]
    fn set_ip6_multicast_loop(&self, flag: <Ip6MulticastLoop as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6MulticastLoop, Self>(self, Ip6MulticastLoop::from_user(flag));
    } 

    /// # IPV6_UNICAST_HOPS
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [i32] is returned (unicast hop limit for the socket).
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set the unicast hop limit for the socket.  Argument is a
    /// > pointer to an integer.  -1 in the value means use the route
    /// > default, otherwise it should be between 0 and 255.
    #[inline] 
    fn get_ip6_unicast_hops(&self) -> io::Result<<Ip6UnicastHops as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6UnicastHops, Self>(self)
                .map(|v| v.get());
    }

    /// # IPV6_UNICAST_HOPS
    /// 
    /// Sets the value.
    /// 
    /// # Arguments 
    /// 
    /// * `hops` - [i32] sets the hop limit.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > Set the unicast hop limit for the socket.  Argument is a
    /// > pointer to an integer.  -1 in the value means use the route
    /// > default, otherwise it should be between 0 and 255. 
    #[inline]
    fn set_ip6_unicast_hops(&self, hops: <Ip6UnicastHops as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6UnicastHops, Self>(self, Ip6UnicastHops::from_user(hops));
    } 

    /// # IPV6_V6ONLY
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [bool] is returned. 
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > If this flag is set to true (nonzero), then the socket is
    /// > restricted to sending and receiving IPv6 packets only.  In
    /// > this case, an IPv4 and an IPv6 application can bind to a
    /// > single port at the same time.
    /// > If this flag is set to false (zero), then the socket can be
    /// > used to send and receive packets to and from an IPv6
    /// > address or an IPv4-mapped IPv6 address.
    #[inline] 
    fn get_ip6_only(&self) -> io::Result<<Ip6V6Only as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6V6Only, Self>(self)
                .map(|v| v.get());
    }

    /// # IPV6_V6ONLY
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// `flag` - [bool] enables or disables feature.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > If this flag is set to true (nonzero), then the socket is
    /// > restricted to sending and receiving IPv6 packets only.  In
    /// > this case, an IPv4 and an IPv6 application can bind to a
    /// > single port at the same time.
    /// > If this flag is set to false (zero), then the socket can be
    /// > used to send and receive packets to and from an IPv6
    /// > address or an IPv4-mapped IPv6 address.
    #[inline]
    fn set_ip6_only(&self, flag: <Ip6V6Only as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6V6Only, Self>(self, Ip6V6Only::from_user(flag));
    } 

    #[cfg(not(any(
        target_os = "dragonfly",
        target_os = "netbsd",
        target_os = "openbsd",
        target_os = "redox",
        target_os = "solaris"
    )))]
    #[inline] 
    fn get_ip6_recv_tclass(&self) -> io::Result<<Ip6RecvTclass as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6RecvTclass, Self>(self)
                .map(|v| v.get());
    }

    #[cfg(not(any(
        target_os = "dragonfly",
        target_os = "netbsd",
        target_os = "openbsd",
        target_os = "redox",
        target_os = "solaris"
    )))]
    #[inline]
    fn set_ip6_recv_tclass(&self, flag: <Ip6RecvTclass as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6RecvTclass, Self>(self, Ip6RecvTclass::from_user(flag));
    } 

    #[cfg(
        not(any(
            windows,
            target_os = "dragonfly",
            target_os = "netbsd",
            target_os = "openbsd",
            target_os = "redox",
            target_os = "solaris",
        ))
    )]
    #[inline] 
    fn get_ip6_recv_hoplimit(&self) -> io::Result<<Ip6RecvHopLimit as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<Ip6RecvHopLimit, Self>(self)
                .map(|v| v.get());
    }

    #[cfg(
        not(any(
            windows,
            target_os = "dragonfly",
            target_os = "netbsd",
            target_os = "openbsd",
            target_os = "redox",
            target_os = "solaris",
        ))
    )]
    #[inline]
    fn set_ip6_recv_hoplimit(&self, hop_lim: <Ip6RecvHopLimit as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<Ip6RecvHopLimit, Self>(self, Ip6RecvHopLimit::from_user(hop_lim));
    } 
}

/// A collection of the socket operations of level [libc::IPPROTO_TCP]. 
/// Extended.
pub trait Socket9ExtIpTcpExt<T = Dum>: AsOsDescr + Sized + Socket9ExtSo<T>
{
    /// # TCP_KEEPIDLE, TCP_KEEPALIVE
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `time_idle` - 
    /// 
    /// * `time_interval` - 
    /// 
    /// * `retries` - 
    /// 
    /// # Man
    /// 
    /// Linux: 
    /// > The time (in seconds) the connection needs to remain idle
    /// > before TCP starts sending keepalive probes, if the socket
    /// > option `SO_KEEPALIVE` has been set on this socket.  This
    /// > option should not be used in code intended to be portable.
    #[inline]
    fn set_tcp_keepalive(&self, time_idle: Option<Duration>, time_interval: Option<Duration>, retries: Option<u32>) -> io::Result<()>
    {
        self.set_so_keepalive(true)?;

        #[cfg(not(any(target_os = "openbsd")))]
        if let Some(ti) = time_idle
        {
            setsockopt::<IpProtoKeepIdleAliveW, Self>(self, IpProtoKeepIdleAliveW::from_user(ti))?;
        }

        #[cfg(any(
            target_os = "ios",
            target_os = "android",
            target_os = "dragonfly",
            target_os = "freebsd",
            target_os = "linux",
            target_os = "macos",
            target_os = "netbsd",
            target_os = "tvos",
        ))]
        if let Some(ti) = time_interval
        {
            setsockopt::<IpProtoKeepIntvl, Self>(self, IpProtoKeepIntvl::from_user(ti))?;
        }

        #[cfg(any(
            target_os = "ios",
            target_os = "android",
            target_os = "dragonfly",
            target_os = "freebsd",
            target_os = "linux",
            target_os = "macos",
            target_os = "netbsd",
            target_os = "tvos",
        ))]
        if let Some(retr) = retries
        {
            setsockopt::<IpProtoKeepCnt, Self>(self, IpProtoKeepCnt::from_user(retr))?;
        }

        return Ok(());
    }
}

pub trait Socket9ExtIpTcp<T = Dum>: AsOsDescr + Sized
{
    /// # TCP_KEEPIDLE, TCP_KEEPALIVE
    /// 
    /// Gets the value.
    /// 
    /// # Returns 
    /// 
    /// A [Duration] is returned.
    /// 
    /// # Man
    /// 
    /// Linux: 
    /// > The time (in seconds) the connection needs to remain idle
    /// > before TCP starts sending keepalive probes, if the socket
    /// > option `SO_KEEPALIVE` has been set on this socket.  This
    /// > option should not be used in code intended to be portable.
    #[cfg(not(target_os = "openbsd"))]
    #[inline]
    fn get_tcp_keepalive_time(&self) -> io::Result<<IpProtoKeepIdleAliveR as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpProtoKeepIdleAliveR, Self>(self)
                .map(|v| v.get());
    }

    /// # TCP_KEEPINTVL
    /// 
    /// Gets the value.
    /// 
    /// # Returnes
    /// 
    /// A [Duration] is returned.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > The time (in seconds) between individual keepalive probes.
    /// > This option should not be used in code intended to be portable.
    #[cfg(any(
        target_os = "ios",
        target_os = "android",
        target_os = "dragonfly",
        target_os = "freebsd",
        target_os = "linux",
        target_os = "macos",
        target_os = "netbsd",
        target_os = "tvos",
    ))]
    #[inline]
    fn get_tcp_keepalive_interval(&self) -> io::Result<<IpProtoKeepIntvl as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpProtoKeepIntvl, Self>(self)
                .map(|v| v.get());
    }

    /// # TCP_KEEPCNT
    /// 
    /// Gets the value.
    /// 
    /// # Returns
    /// 
    /// A [u32] is returned with the maximum number of keepalive probes.
    /// 
    /// # Man
    /// 
    /// Linux: 
    /// > The maximum number of keepalive probes TCP should send
    /// > before dropping the connection.  This option should not be
    /// > used in code intended to be portable.
    #[cfg(any(
        target_os = "ios",
        target_os = "android",
        target_os = "dragonfly",
        target_os = "freebsd",
        target_os = "linux",
        target_os = "macos",
        target_os = "netbsd",
        target_os = "tvos",
    ))]
    #[inline]
    fn get_tcp_keepalive_retries(&self) -> io::Result<<IpProtoKeepCnt as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpProtoKeepCnt, Self>(self)
                .map(|v| v.get());
    }

    /// # TCP_NODELAY
    /// 
    /// Gets the value.
    /// 
    /// # Returnes
    /// 
    /// A [bool] is returned indicating the status of the feature.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > If set, disable the Nagle algorithm.  This means that
    /// > segments are always sent as soon as possible, even if there
    /// > is only a small amount of data.
    /// > ...  
    #[inline] 
    fn get_tcp_nodelay(&self) -> io::Result<<IpProtoNodelay as SockOptMarker>::DataType>
    {
        return 
            getsockopt::<IpProtoNodelay, Self>(self)
                .map(|v| v.get());
    }

    /// # TCP_NODELAY
    /// 
    /// Sets the value.
    /// 
    /// # Arguments
    /// 
    /// * `flag` - [bool] enables od disables feature.
    /// 
    /// # Man
    /// 
    /// Linux:
    /// > If set, disable the Nagle algorithm.  This means that
    /// > segments are always sent as soon as possible, even if there
    /// > is only a small amount of data.
    /// > ...  
    #[inline]
    fn set_tcp_nodelay(&self, flag: <IpProtoNodelay as SockOptMarker>::DataType) -> io::Result<()>
    {
        return 
            setsockopt::<IpProtoNodelay, Self>(self, IpProtoNodelay::from_user(flag));
    } 

    // ---

}



#[cfg(target_family = "unix")]
mod unix_os
{
    use super::*;

    impl AsOsDescr for OwnedFd {}
    impl AsOsDescr for TcpListener {}
    impl AsOsDescr for UdpSocket {}
    impl AsOsDescr for TcpStream {}
    impl AsOsDescr for UnixDatagram {}
    impl AsOsDescr for UnixStream {}
    impl AsOsDescr for UnixSeqpacketConn {}
    impl AsOsDescr for UnixSeqpacketListener {}

    //impl Socket9ExtSo for OwnedFd {}

    impl Socket9ExtSo for UnixDatagram {}
    impl Socket9ExtSo for UnixStream {}
    impl Socket9ExtSo for UnixSeqpacketConn {}
    impl Socket9ExtSo for UnixSeqpacketListener {}
}

#[cfg(target_family = "windows")]
mod windows_os
{
    use std::os::windows::io::OwnedSocket;

    use super::*;
    
    impl AsOsDescr for OwnedSocket {}

    impl AsOsDescr for TcpListener {}
    impl AsOsDescr for UdpSocket {}
    impl AsOsDescr for TcpStream {}
}


impl Socket9ExtSo for TcpListener {}
impl Socket9ExtSo for UdpSocket {}
impl Socket9ExtSo for TcpStream {}

impl Socket9ExtSoIp for TcpListener {}
impl Socket9ExtSoIp6 for TcpListener {}

impl Socket9ExtIp for TcpListener{}
impl Socket9ExtIp for UdpSocket {}
impl Socket9ExtIp for TcpStream {}


impl Socket9ExtIp6 for TcpListener{}
impl Socket9ExtIp6 for UdpSocket {}
impl Socket9ExtIp6 for TcpStream {}

impl Socket9ExtIpTcp for TcpStream{}
impl Socket9ExtIpTcpExt for TcpStream {}