socket9 0.1.0-alpha.1

Extended untilities for the networking/unix sockets and raw network sockets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use std::{io::{self, ErrorKind}, net::SocketAddr};

#[repr(transparent)]
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct So9SockDomain(pub libc::c_int);

impl So9SockDomain
{
    /// Not specified 
    pub const UNSPEC: Self = Self(0);
    
    /// [libc::AF_INET] type.
    pub const IPV4: Self = Self(libc::AF_INET);
    
    /// [libc::AF_INET6] type.
    pub const IPV6: Self = Self(libc::AF_INET6);
    
    /// [libc::AF_UNIX] type.
    pub const UNIX: Self = Self(libc::AF_UNIX);

    /// [libc::AF_PACKET] type.
    #[cfg(any(target_os = "android", target_os = "linux"))]
    pub const PACKET: Self = Self(libc::AF_PACKET);

    /// [libc::AF_VSOCK] type.
    #[cfg(any(target_os = "android", target_os = "linux"))]
    pub const VSOCK: Self = Self(libc::AF_VSOCK);
}

impl From<u16> for So9SockDomain
{
    fn from(value: u16) -> Self 
    {
        return Self(value as libc::c_int);
    }
}

impl From<So9DomainRange> for So9SockDomain
{
    fn from(domain: So9DomainRange) -> Self 
    {
        match domain
        {
            So9DomainRange::DoInets => todo!(),
            So9DomainRange::DoUnixs => todo!(),
            So9DomainRange::DoOther(_) => todo!(),
        }
    }
}

impl From<SocketAddr> for So9SockDomain
{
    fn from(sa: SocketAddr) -> Self 
    {
        if sa.is_ipv4() == true
        {
            return Self::IPV4;
        }
        else
        {
            return Self::IPV6;
        }
    }
}


/// Determins the socket's possible range of domains i.e `AF_INET` and `AF_INET6` and
/// `AF_UNIX`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum So9DomainRange
{
    /// A AF_INET | AF_INET6
    DoInets,

    /// A AF_UNIX only
    DoUnixs,

    /// Other, specific
    DoOther(libc::sa_family_t)
}

impl So9DomainRange
{
    pub(crate) 
    fn check_fam(&self, sock_fam: So9SockDomain) -> io::Result<()>
    {
        match (self, sock_fam.0 as i32)
        {
            (Self::DoInets, libc::AF_INET | libc::AF_INET6) |
            (Self::DoUnixs, libc::AF_UNIX) => 
                return Ok(()), 
            (Self::DoOther(other), sf) if *other as i32 == sf =>
                return Ok(()),
            (Self::DoInets, sf) => 
                return Err(
                    io::Error::new(ErrorKind::InvalidData, 
                        format!("sock_fam {} does not belong to Inets group", sf))
                ),
            (Self::DoUnixs, sf) => 
                return Err(
                    io::Error::new(ErrorKind::InvalidData, 
                        format!("sock_fam {} does not belong to Unixs group", sf))
                ),
            (Self::DoOther(other), sf) =>
                return Err(
                    io::Error::new(ErrorKind::InvalidData, 
                        format!("sock_fam {} does not belong to Other group {}", sf, other))
                ), 
        }
    }
}