compio-net 0.12.2

Networking IO for compio
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use compio_io::ancillary::{AncillaryBuf, ReturnFlags};
use compio_net::UdpSocket;

#[compio_macros::test]
async fn connect() {
    const MSG: &str = "foo bar baz";

    let passive = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive_addr = passive.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.connect(passive_addr).await.unwrap();
    active.send(MSG).await.0.unwrap();

    let (_, buffer) = passive.recv(Vec::with_capacity(20)).await.unwrap();
    assert_eq!(MSG.as_bytes(), &buffer);
    assert_eq!(active.local_addr().unwrap(), active_addr);
    assert_eq!(active.peer_addr().unwrap(), passive_addr);
}

#[compio_macros::test]
async fn send_to() {
    const MSG: &str = "foo bar baz";

    macro_rules! must_success {
        ($r:expr, $expect_addr:expr) => {
            let res = $r;
            assert_eq!(res.0.unwrap().1, $expect_addr);
            assert_eq!(res.1, MSG.as_bytes());
        };
    }

    let passive1 = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive1_addr = passive1.local_addr().unwrap();

    let passive01 = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
    let passive01_addr = passive01.local_addr().unwrap();

    let passive2 = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive2_addr = passive2.local_addr().unwrap();

    let passive3 = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive3_addr = passive3.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.send_to(MSG, &passive01_addr).await.0.unwrap();
    active.send_to(MSG, &passive1_addr).await.0.unwrap();
    active.send_to(MSG, &passive2_addr).await.0.unwrap();
    active.send_to(MSG, &passive3_addr).await.0.unwrap();

    must_success!(
        passive1.recv_from(Vec::with_capacity(20)).await,
        active_addr
    );
    must_success!(
        passive2.recv_from(Vec::with_capacity(20)).await,
        active_addr
    );
    must_success!(
        passive3.recv_from(Vec::with_capacity(20)).await,
        active_addr
    );
}

#[compio_macros::test]
async fn send_recv_vectored() {
    const MSG1: &str = "foobar";
    const MSG2: [u8; 5] = [1, 2, 3, 4, 5];
    let msg2: Vec<u8> = Vec::from(MSG2);

    let passive = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive_addr = passive.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.connect(passive_addr).await.unwrap();
    active.send_vectored((MSG1, (msg2,))).await.0.unwrap();

    let recv_buf: [u8; 6] = [0; 6];
    let (_, buffer) = passive
        .recv_vectored((recv_buf, (Vec::with_capacity(20),)))
        .await
        .unwrap();

    assert_eq!(MSG1.as_bytes(), &buffer.0);
    assert_eq!(MSG2, buffer.1.0.as_slice());
    assert_eq!(active.local_addr().unwrap(), active_addr);
    assert_eq!(active.peer_addr().unwrap(), passive_addr);
}

#[compio_macros::test]
async fn recv_msg_flags() {
    const MSG: &str = "foo bar baz";

    let passive = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive_addr = passive.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.send_to(MSG, passive_addr).await.0.unwrap();

    let ((n, control_len, addr, flags), (buffer, _control)) = passive
        .recv_msg(Vec::with_capacity(20), AncillaryBuf::<64>::new())
        .await
        .unwrap();
    assert_eq!(MSG.as_bytes(), &buffer);
    assert_eq!(n, MSG.len());
    assert_eq!(control_len, 0);
    assert_eq!(addr, active_addr);
    assert_eq!(flags, ReturnFlags::empty());

    active.send_to(MSG, passive_addr).await.0.unwrap();

    let ((n, control_len, addr, flags), (buffer, _control)) = passive
        .recv_msg_vectored(
            ([0; 4], (Vec::with_capacity(20),)),
            AncillaryBuf::<64>::new(),
        )
        .await
        .unwrap();
    assert_eq!(&buffer.0, &MSG.as_bytes()[..4]);
    assert_eq!(buffer.1.0.as_slice(), &MSG.as_bytes()[4..]);
    assert_eq!(n, MSG.len());
    assert_eq!(control_len, 0);
    assert_eq!(addr, active_addr);
    assert_eq!(flags, ReturnFlags::empty());
}

#[cfg(any(target_os = "linux", target_os = "android"))]
#[compio_macros::test]
async fn recv_msg_flags_truncated_datagram() {
    const MSG: &[u8] = b"foo bar baz";

    let passive = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let passive_addr = passive.local_addr().unwrap();

    let active = UdpSocket::bind("127.0.0.1:0").await.unwrap();
    let active_addr = active.local_addr().unwrap();

    active.send_to(MSG, passive_addr).await.0.unwrap();

    let ((_n, _control_len, addr, flags), (buffer, _control)) = passive
        .recv_msg(Vec::with_capacity(3), AncillaryBuf::<64>::new())
        .await
        .unwrap();
    assert_eq!(&MSG[..buffer.len()], buffer.as_slice());
    assert_eq!(addr, active_addr);
    assert!(flags.contains(ReturnFlags::TRUNC));
}