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(unix)]
use std::os::fd::OwnedFd;
use std::
{
    io::{self, IoSlice, IoSliceMut}, 
    marker::PhantomData, 
    net::{Shutdown, TcpListener, TcpStream, UdpSocket}, 
    time::Duration
};

#[cfg(unix)]
use crate::So9MarkerSockUnix;

use crate::
{
    AsOsDescr, So9MsgFlags, So9Marker, So9MarkerStateless, Socket9, Socket9ExtIp, Socket9ExtIp6, Socket9ExtIpTcp, Socket9ExtIpTcpExt, Socket9ExtSo, SocketTypeImps, address::IntoSockAddrSpec
};

/// A `read` part of the socket. Normally this structure contains a clonned
/// FD which is discarded when performing `unsplit`. If intance is `dropped`
/// the `read` channel of the socket closes.
///
/// The inner FD is in `nonblocking` mode.
#[derive(Debug)]
pub struct Socket9Read<SO: So9Marker>
{
    /// A socket's FD.
    so9: Option<Socket9<SO>>, 

    /// A ID which helps to identify the r/w endpoints when do unsplit
    orig_fd: <SO::SockType as SocketTypeImps>::RawType,

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

impl<SO: So9Marker> Drop for Socket9Read<SO>
{
    fn drop(&mut self) 
    {
        // ignore errors
        let Some(socket) = self.so9.take()
        else { return };

        let _ = socket.shutdown(Shutdown::Read);
    }
}

impl<SO: So9Marker> Eq for Socket9Read<SO> {}

impl<SO: So9Marker> PartialEq for  Socket9Read<SO> 
{
    fn eq(&self, other: &Self) -> bool 
    {
        self.orig_fd == other.orig_fd && self._p == other._p
    }
}

impl<SO: So9Marker> PartialEq<Socket9Write<SO>> for  Socket9Read<SO> 
{
    fn eq(&self, other: &Socket9Write<SO>) -> bool 
    {
        self.orig_fd == other.orig_id
    }
}

#[cfg(unix)]
mod unix_spec_read
{
    use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};

    use super::*;

    impl<SO: So9Marker> AsFd for Socket9Read<SO>
    {
        fn as_fd(&self) -> BorrowedFd<'_> 
        {
            return self.so9.as_ref().unwrap().as_fd();
        }
    }

    impl<SO: So9Marker> AsRawFd for Socket9Read<SO>
    {
        fn as_raw_fd(&self) -> RawFd 
        {
            return self.so9.as_ref().unwrap().as_raw_fd();
        }
    }
}

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

    use super::*;

    impl<SO: So9Marker> AsSocket for Socket9Read<SO>
    {
        fn as_socket(&self) -> BorrowedSocket<'_> 
        {
            return self.so9.as_ref().unwrap().as_socket();
        }
    }

    impl<SO: So9Marker> AsRawSocket for Socket9Read<SO>
    {
        fn as_raw_socket(&self) -> RawSocket 
        {
            return self.so9.as_ref().unwrap().as_raw_socket();
        }
    }
}

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

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

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

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

impl<SO: So9Marker> Socket9Read<SO>
{
    /// Returns the socket's `local` address as type declared in
    /// `SO` [So9Marker::SockAddrType].
    #[inline]
    pub 
    fn local_addr(&self) -> io::Result<SO::SockAddrType>
    {
        self.so9.as_ref().unwrap().local_addr()
    }

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

#[cfg(unix)]
impl<SO: So9Marker> Socket9Read<SO>
{
    /// Reads the instance's socket FD `blocking` mode.
    #[inline]
    pub 
    fn is_nonblocking(&self) -> io::Result<bool>
    {
        self.so9.as_ref().unwrap().is_nonblocking()
    }

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

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

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

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

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

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

    /// Receives the data from the socket and writes it into procided mutable slice of `u8`.
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple with `received size` anf `address` is returned.
    #[inline]
    pub 
    fn recv_from(&self, buf: &mut [u8], flags: So9MsgFlags) -> io::Result<(usize, SO::SockAddrType)>
    {
        self.so9.as_ref().unwrap().recv_from(buf, flags)
    }

    /// Receives the data from the socket and writes it into procided mutable slice of `u8` before
    /// the specific tiemout.
    /// Also returning the remote host info which is defined in the `SO` generic 
    /// [So9Marker::SockAddrType].
    /// 
    /// # Returns 
    /// 
    /// The [io::Result] is returned.
    /// 
    /// On success, a tuple with `received size` anf `address` is returned.
    #[inline]
    pub 
    fn recv_from_timeout(&self, buf: &mut [u8], flags: So9MsgFlags, timeout: Duration) -> io::Result<(usize, SO::SockAddrType)>
    {
        self.so9.as_ref().unwrap().recv_from_flags_timeout(buf, flags, timeout)
    }
}

impl<SO: So9Marker> Socket9Read<SO>
{
    pub(crate) 
    fn new(so9: Socket9<SO>, orig_fd: <SO::SockType as SocketTypeImps>::RawType) -> Self
    {
        return 
            Self
            {
                so9: Some(so9),
                orig_fd: orig_fd,
                _p: PhantomData,
            };
    }

    pub(crate) 
    fn take(mut self) -> Socket9<SO>
    {
        return self.so9.take().unwrap();
    }
}

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

// -- tcp listen
impl Socket9ExtSo for Socket9Read<TcpListener> {}
impl Socket9ExtIp for Socket9Read<TcpListener> {}
impl Socket9ExtIp6 for Socket9Read<TcpListener> {}

// -- tcp --
impl Socket9ExtSo for Socket9Read<TcpStream> {}
impl Socket9ExtIp for Socket9Read<TcpStream> {}
impl Socket9ExtIp6 for Socket9Read<TcpStream> {}
impl Socket9ExtIpTcp for Socket9Read<TcpStream> {}
impl Socket9ExtIpTcpExt for Socket9Read<TcpStream> {}

// -- udp socket--
impl Socket9ExtSo for Socket9Read<UdpSocket> {}
impl Socket9ExtIp for Socket9Read<UdpSocket> {}
impl Socket9ExtIp6 for Socket9Read<UdpSocket> {}

#[cfg(unix)]
pub mod unix_things
{
    use std::os::
    { 
        unix::net::{UnixDatagram, UnixListener, UnixStream}
    };

    use uds_fork::{UnixSeqpacketConn, UnixSeqpacketListener};

    use super::*;

    // -- unix datagram
    impl Socket9ExtSo for Socket9Read<UnixDatagram> {}

    // -- unix stream
    impl Socket9ExtSo for Socket9Read<UnixStream> {}

    // -- unix listener
    impl Socket9ExtSo for Socket9Read<UnixListener> {}

    // -- UnixSeqpacketListener --
    impl Socket9ExtSo for Socket9Read<UnixSeqpacketListener> {}

    // -- UnixSeqpacketConn --
    impl Socket9ExtSo for Socket9Read<UnixSeqpacketConn> {}
}

// -----------

/// A `write` part of the socket. Normally this structure contains a original
/// FD, not the clonend one. If intance is `dropped` the `write` channel of 
/// the socket closes.
/// 
/// The inner FD is in `nonblocking` mode.
#[derive(Debug)]
pub struct Socket9Write<SO: So9Marker>
{
    /// A socket's FD.
    so9: Option<Socket9<SO>>, 

    /// A ID which helps to identify the r/w endpoints when do unsplit
    orig_id: <SO::SockType as SocketTypeImps>::RawType,

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

impl<SO: So9Marker> Drop for Socket9Write<SO>
{
    fn drop(&mut self) 
    {
        let Some(so9) = self.so9.take()
        else { return };

        // ignore errors
        let _ = so9.shutdown(Shutdown::Write);
    }
}

#[cfg(unix)]
mod unix_spec_write
{
    
    use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};

    use super::*;

    impl<SO: So9Marker> AsFd for Socket9Write<SO>
    {
        fn as_fd(&self) -> BorrowedFd<'_> 
        {
            return self.so9.as_ref().unwrap().as_fd();
        }
    }


    impl<SO: So9Marker> AsRawFd for Socket9Write<SO>
    {
        fn as_raw_fd(&self) -> RawFd 
        {
            return self.so9.as_ref().unwrap().as_raw_fd();
        }
    }
}

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

    use crate::{So9Marker, socket_split::Socket9Write};

    impl<SO: So9Marker> AsSocket for Socket9Write<SO>
    {
        fn as_socket(&self) -> BorrowedSocket<'_> 
        {
            return self.so9.as_ref().unwrap().as_socket();
        }
    }

    impl<SO: So9Marker> AsRawSocket for Socket9Write<SO>
    {
        fn as_raw_socket(&self) -> RawSocket 
        {
            return self.so9.as_ref().unwrap().as_raw_socket();
        }
    }
}


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

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

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

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

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

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

impl<SO: So9Marker> Socket9Write<SO>
{
    pub(crate) 
    fn new(so9: Socket9<SO>, orig_id: <SO::SockType as SocketTypeImps>::RawType) -> Self
    {
        return 
            Self
            {
                so9: Some(so9),
                orig_id: orig_id,
                _p: PhantomData,
            };
    }

    pub(crate) 
    fn take(mut self) -> Socket9<SO>
    {
        return self.so9.take().unwrap();
    }
}

impl<SO: So9Marker> Socket9Write<SO>
{
    /// Returns the socket's `local` address as type declared in
    /// `SO` [So9Marker::SockAddrType].
    #[inline]
    pub 
    fn local_addr(&self) -> io::Result<SO::SockAddrType>
    {
        self.so9.as_ref().unwrap().local_addr()
    }

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

#[cfg(unix)]
impl<SO: So9Marker> Socket9Write<SO>
{
    /// Reads the instance's socket FD `blocking` mode.
    #[inline]
    pub 
    fn is_nonblocking(&self) -> io::Result<bool>
    {
        self.so9.as_ref().unwrap().is_nonblocking()
    }

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

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

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

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

}

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

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

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

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

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

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

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

// -- tcp listen
impl Socket9ExtSo for Socket9Write<TcpListener> {}
impl Socket9ExtIp for Socket9Write<TcpListener> {}
impl Socket9ExtIp6 for Socket9Write<TcpListener> {}

// -- tcp --
impl Socket9ExtSo for Socket9Write<TcpStream> {}
impl Socket9ExtIp for Socket9Write<TcpStream> {}
impl Socket9ExtIp6 for Socket9Write<TcpStream> {}
impl Socket9ExtIpTcp for Socket9Write<TcpStream> {}
impl Socket9ExtIpTcpExt for Socket9Write<TcpStream> {}

// -- udp socket--
impl Socket9ExtSo for Socket9Write<UdpSocket> {}
impl Socket9ExtIp for Socket9Write<UdpSocket> {}
impl Socket9ExtIp6 for Socket9Write<UdpSocket> {}

#[cfg(unix)]
pub mod unix_things_w
{
    use std::os::
    {
        unix::net::{UnixDatagram, UnixListener, UnixStream}
    };

    use uds_fork::{UnixSeqpacketConn, UnixSeqpacketListener};

    use super::*;

    // -- unix datagram
    impl Socket9ExtSo for Socket9Write<UnixDatagram> {}

    // -- unix stream
    impl Socket9ExtSo for Socket9Write<UnixStream> {}

    // -- unix listener
    impl Socket9ExtSo for Socket9Write<UnixListener> {}

    // -- UnixSeqpacketListener --
    impl Socket9ExtSo for Socket9Write<UnixSeqpacketListener> {}

    // -- UnixSeqpacketConn --
    impl Socket9ExtSo for Socket9Write<UnixSeqpacketConn> {}
}