socket9 0.1.0-alpha.1

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

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

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


use std::
{
    io::{self}, 
    net::{SocketAddr, TcpListener, TcpStream, UdpSocket}
};



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

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

use uds_fork::UnixSocketAddr;
#[cfg(windows)]
use windows_sys::Win32::Networking::WinSock::WSA_FLAG_NO_HANDLE_INHERIT;


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

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

use crate::
{   
    So9Marker, So9MarkerBind, So9MarkerListener, So9MarkerStateless, So9MsgFlags, 
    So9SockDwFlags, So9SockProtocol, So9SockType, 
    address::
    {
        So9DomainInets, So9DomainUnix
    } 
};

/// A unix only implementations.
#[cfg(unix)]
pub mod unix_only
{
    use crate::
    {
        So9Marker, So9MarkerBind, So9MarkerListener, So9MarkerPairable, So9MarkerSockUnix, 
        So9MarkerStateless
    };

    use super::*;

    // ----- An implementation for UnixListener ------
    impl So9Marker for UnixListener
    {
        type SockType = OwnedFd;

        const IS_LISTENING: bool = true;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::STREAM;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
        
        
    }

    impl So9MarkerBind for UnixListener {}

    impl So9MarkerListener for UnixListener 
    {
        const SOCK_ACCEPT_FLAGS: i32 = libc::SOCK_CLOEXEC;

        type AcceptedType = UnixStream;
    }

    // ----- An implementaton for UnixStream ------
    impl So9Marker for UnixStream 
    {
        type SockType = OwnedFd;

        const IS_LISTENING: bool = false;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::STREAM;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerBind for UnixStream {}

    impl So9MarkerStateless for UnixStream {}


    impl So9MarkerPairable for UnixStream
    {
        fn pair() -> io::Result<(OwnedFd, OwnedFd)> where Self: Sized 
        {
            UnixStream::pair().map(|(a, b)| (OwnedFd::from(a), OwnedFd::from(b)))
        }
    }

    // ----- An implementaton for UnixDatagram ------
    impl So9Marker for UnixDatagram
    {
        type SockType = OwnedFd;

        const IS_LISTENING: bool = false;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::DGRAM;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerStateless for UnixDatagram {}

    impl So9MarkerPairable for UnixDatagram
    {
        fn pair() -> io::Result<(OwnedFd, OwnedFd)> where Self: Sized 
        {
            UnixDatagram::pair().map(|(a, b)| (OwnedFd::from(a), OwnedFd::from(b)))
        }
    }

    impl So9MarkerBind for UnixDatagram{}

    impl So9MarkerSockUnix for UnixDatagram{}

    // ----- An implementaton for UnixSeqpacketListener ------
    impl So9Marker for UnixSeqpacketListener
    {
        type SockType = OwnedFd;

        const IS_LISTENING: bool = true;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::SEQPACKET;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerBind for UnixSeqpacketListener{}

    impl So9MarkerListener for UnixSeqpacketListener 
    {
        const SOCK_ACCEPT_FLAGS: i32 = libc::SOCK_CLOEXEC;

        type AcceptedType = UnixSeqpacketConn;
    }

    
    // ----- An implementaton for NonBlkUnixSeqpacketListener ------
    impl So9Marker for NonBlkUnixSeqpacketListener
    {
        type SockType = OwnedFd;

        const IS_LISTENING: bool = true;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::SEQPACKET;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerBind for NonBlkUnixSeqpacketListener{}

    impl So9MarkerListener for NonBlkUnixSeqpacketListener 
    {
        const SOCK_ACCEPT_FLAGS: i32 = libc::SOCK_CLOEXEC;

        type AcceptedType = NonBlkUnixSeqpacketListener;
    }

    
    // ----- An implementaton for UnixSeqpacketConn ------
    impl So9Marker for UnixSeqpacketConn
    {
        type SockType = OwnedFd;

        const IS_LISTENING: bool = false;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::SEQPACKET;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::MSG_NOSIGNAL.union(So9MsgFlags::MSG_EOR);

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::MSG_NOSIGNAL.union(So9MsgFlags::MSG_EOR);

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::MSG_NOSIGNAL;

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::MSG_NOSIGNAL;

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerBind for UnixSeqpacketConn{}

    impl So9MarkerPairable for UnixSeqpacketConn
    {
        fn pair() -> io::Result<(OwnedFd, OwnedFd)> where Self: Sized 
        {
            UnixSeqpacketConn::pair().map(|(a, b)| (OwnedFd::from(a), OwnedFd::from(b)))
        }
    }
}

/// A windows only implementations.
#[cfg(windows)]
pub mod windows_only
{
    use windows_sys::Win32::Networking::WinSock::WSA_FLAG_NO_HANDLE_INHERIT;

    use crate::{So9MarkerPairableWin, Socket9};

    use super::*;
    
    // ----- An implementation for WinUnixListener ------

    impl So9Marker for WindowsUnixListener
    {
        type SockType = OwnedSocket;

        const IS_LISTENING: bool = true;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::STREAM;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::NO_HNDL_INHERIT.union(So9SockDwFlags::OVERALPPED);

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerListener for WindowsUnixListener 
    {
        const SOCK_ACCEPT_FLAGS: i32 = WSA_FLAG_NO_HANDLE_INHERIT as i32;

        type AcceptedType = WindowsUnixStream;
    }

    impl So9MarkerBind for WindowsUnixListener {}


    // ----- An implementaton for WindowsUnixStream ------
    impl So9MarkerPairableWin for WindowsUnixStream
    {
        fn pair() -> io::Result<(Socket9<WindowsUnixStream>, Socket9<WindowsUnixStream>)> where Self: Sized 
        {
            let (a, b) = WindowsUnixStream::pair()?;

            return Ok(
                ( 
                    Socket9::<WindowsUnixStream>::try_from(OwnedSocket::from(a))?,
                    Socket9::<WindowsUnixStream>::try_from(OwnedSocket::from(b))?
                )
            );
        }
    }

    impl So9Marker for WindowsUnixStream 
    {
        type SockType = OwnedSocket;

        const IS_LISTENING: bool = false;

        const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoUnixs;

        const SO_TYPE: So9SockType = So9SockType::STREAM;

        const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::NO_HNDL_INHERIT.union(So9SockDwFlags::OVERALPPED);

        const SO_PROTO: So9SockProtocol = So9SockProtocol::NONE;

        const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

        type SockAddrType = UnixSocketAddr;

        type SockAddrDomain = So9DomainUnix;
    }

    impl So9MarkerBind for WindowsUnixStream {}

    impl So9MarkerStateless for WindowsUnixStream {}
}


// ----- An implementaton for TcpListener ------
impl So9Marker for TcpListener 
{
    #[cfg(unix)]
    type SockType = OwnedFd;


    #[cfg(windows)]
    type SockType = OwnedSocket;

    const IS_LISTENING: bool = true;

    const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoInets;

    const SO_TYPE: So9SockType = So9SockType::STREAM;

    #[cfg(unix)]
    const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

    #[cfg(windows)]
    const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::NO_HNDL_INHERIT.union(So9SockDwFlags::OVERALPPED);

    const SO_PROTO: So9SockProtocol = So9SockProtocol::TCP;

    const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    type SockAddrType = SocketAddr;

    type SockAddrDomain = So9DomainInets;
}

impl So9MarkerListener for TcpListener
{
    #[cfg(unix)]
    const SOCK_ACCEPT_FLAGS: i32 = libc::SOCK_CLOEXEC;

    #[cfg(windows)]
    const SOCK_ACCEPT_FLAGS: i32 = WSA_FLAG_NO_HANDLE_INHERIT as i32;

    type AcceptedType = TcpStream;
}

impl So9MarkerBind for TcpListener {}

// ----- An implementaton for TcpStream ------
impl So9Marker for TcpStream 
{
     #[cfg(unix)]
    type SockType = OwnedFd;
    
    #[cfg(windows)]
    type SockType = OwnedSocket;

    const IS_LISTENING: bool = false;

    const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoInets;

    const SO_TYPE: So9SockType = So9SockType::STREAM;

    #[cfg(unix)]
    const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

    #[cfg(windows)]
    const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::NO_HNDL_INHERIT.union(So9SockDwFlags::OVERALPPED);

    const SO_PROTO: So9SockProtocol = So9SockProtocol::TCP;

    const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    type SockAddrType = SocketAddr;

    type SockAddrDomain = So9DomainInets;
}

impl So9MarkerBind for TcpStream{}


// ----- An implementaton for UdpSocket ------

/// UDP supports vectored send however in one attempt a max 65507 (on Linux)
/// can be transmitted, so all your IoSlices (in total) must be less than 
/// 65507
impl So9Marker for UdpSocket
{
    #[cfg(unix)]
    type SockType = OwnedFd;

    #[cfg(windows)]
    type SockType = OwnedSocket;

    const IS_LISTENING: bool = false;

    const SO_DOMAIN_GROUP: So9DomainRange = So9DomainRange::DoInets;

    const SO_TYPE: So9SockType = So9SockType::DGRAM;

    #[cfg(unix)]
    const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::CLOEXEC;

    #[cfg(windows)]
    const SO_DEF_FLAGS: So9SockDwFlags = So9SockDwFlags::NO_HNDL_INHERIT.union(So9SockDwFlags::OVERALPPED);

    const SO_PROTO: So9SockProtocol = So9SockProtocol::UDP;

    const SOCK_SND_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_SND_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_RCV_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    const SOCK_RCV_VECT_FLAGS: So9MsgFlags = So9MsgFlags::empty();

    type SockAddrType = SocketAddr;

    type SockAddrDomain = So9DomainInets;
}

impl So9MarkerBind for UdpSocket{}

impl So9MarkerStateless for UdpSocket {}



// ----- impl end ------