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

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

use windows_sys::Win32::Networking::WinSock::{ADDRESS_FAMILY, AF_INET, AF_INET6, AF_UNIX, WSAPROTOCOL_INFOW};

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

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

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

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


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(ADDRESS_FAMILY)
}

impl So9DomainRange
{
    pub(crate) 
    fn check_fam(&self, sock_fam: So9SockDomain) -> io::Result<()>
    {
        match (self, sock_fam.0)
        {
            (Self::DoInets, AF_INET | AF_INET6) |
            (Self::DoUnixs, AF_UNIX) => 
                return Ok(()), 
            (Self::DoOther(other), sf) if *other == 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))
                ), 
        }
    }
}