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
113
114
115
116
117
118
119

#![cfg(unix)]

mod common;

use std::{io::{IoSlice, IoSliceMut}, net::{TcpListener, UdpSocket}, os::unix::net::{UnixDatagram, UnixListener}, time::Duration};

use socket9::{So9Marker, So9MarkerBind, So9MarkerListener, So9MarkerStateless, So9SockDomain, Socket9, address::{IntoSockAddrSpec, So9AddrDomain, So9DomainInets, So9DomainUnix}};
use uds_fork::{UnixSeqpacketListener};

fn test_bind_listern<S: So9Marker + So9MarkerBind + So9MarkerListener, A: IntoSockAddrSpec<S::SockAddrType>>(sock: Socket9<S>, addr: A)
{
    sock.bind(&addr).unwrap();

    sock.listen(10).unwrap();

    let _ = sock.accept_timeout(Duration::from_nanos(100));
}

#[test]
fn test_listeners_marker_bind_listen_accept()
{
    let dir = common::make_temp_dir_no();

    let p1 = dir.path().join("sock1.sock");

    let unxlist = Socket9::<UnixListener>::new_unbound_by_addr(&p1).unwrap();

    test_bind_listern(unxlist, p1.as_path());


    let p1 = dir.path().join("sock2.sock");

    let unxlist = Socket9::<UnixSeqpacketListener>::new_unbound_by_addr(&p1).unwrap();

    test_bind_listern(unxlist, p1.as_path());


    let p1 = "127.0.0.1:0";

    let unxlist = Socket9::<TcpListener>::new_unbound_by_addr(p1).unwrap();

    test_bind_listern(unxlist, p1);
}

fn test_datagrams_tests<S, A>(sock: Socket9<S>, addr: A, sock2: Socket9<S>)
where 
    S: So9Marker + So9MarkerBind + So9MarkerStateless, 
    A: IntoSockAddrSpec<S::SockAddrType>
{
    sock.bind(&addr).unwrap();

    let sock_addr = sock.local_addr().unwrap();
    
    let arg_addr_type = addr.from_type().unwrap();
    let sock_addr_type = sock_addr.from_type().unwrap();

    if arg_addr_type.get_addr_domain() == So9SockDomain::UNIX 
    {
        assert_eq!(arg_addr_type.as_ref(), sock_addr_type.as_ref());
    }

    let buf = [1,2,3,4];
    let n = sock2.send_to(&buf, &sock_addr).unwrap();

    let mut rcv = [0_u8; 10];

    let rn = sock.recv(&mut rcv).unwrap();
    assert_eq!(n, rn);

    // vectored as part of stateless
    let n = sock2.send_to_vectored(&[IoSlice::new(&buf)], &sock_addr).unwrap();

    let rcv_io = IoSliceMut::new(&mut rcv);

    let rn = sock.recv_from_vectored(&mut [rcv_io]).unwrap();

    assert_eq!(n, rn.0);

    let sock_addr2 = sock2.local_addr().unwrap();
    let sock_addr_type2 = sock_addr2.from_type().unwrap();
    assert_eq!(sock_addr_type2.as_ref(), &rn.1);
    println!("{:?}", rn.1);
}

#[test]
fn test_datagram_unix()
{
    let dir = common::make_temp_dir_no();

    println!("DGRAM:");
    let p1 = dir.path().join("sock_dgram.sock");

    let unxlist = Socket9::<UnixDatagram>::new_unbound_by_addr(&p1).unwrap();
    let unxlist2 = Socket9::<UnixDatagram>::new_unbound(So9DomainUnix::Unix).unwrap();

    test_datagrams_tests(unxlist, p1.as_path(), unxlist2);


    println!("STREAM:");
    let p1 = dir.path().join("sock_stream.sock");
    let p2 = dir.path().join("sock_stream_2.sock");

    let unxlist = Socket9::<UnixDatagram>::new_unbound_by_addr(&p1).unwrap();
    let unxlist2 = Socket9::<UnixDatagram>::new_with_bind(&p2).unwrap();

    test_datagrams_tests(unxlist, p1.as_path(), unxlist2);


    println!("UDP DGRAM:");
    let p1 = "127.0.0.1:0";

    let unxlist = Socket9::<UdpSocket>::new_unbound_by_addr(p1).unwrap();
    //let unxlist2 = Socket9::<UdpSocket>::new_unbound(So9DomainInets::Inet).unwrap();
    let unxlist2 = Socket9::<UdpSocket>::new_with_bind(&"127.0.0.1:0").unwrap();

    test_datagrams_tests(unxlist, p1, unxlist2);
}

//So9MarkerPairable