1 use test_programs::sockets::supports_ipv6;
2 use test_programs::wasi::sockets::network::{
3     IpAddress, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress, Network,
4 };
5 use test_programs::wasi::sockets::udp::{OutgoingDatagram, UdpSocket};
6 
7 fn test_udp_sample_application(family: IpAddressFamily, bind_address: IpSocketAddress) {
8     let unspecified_addr = IpSocketAddress::new(IpAddress::new_unspecified(family), 0);
9 
10     let first_message = &[];
11     let second_message = b"Hello, world!";
12     let third_message = b"Greetings, planet!";
13 
14     let net = Network::default();
15 
16     let server = UdpSocket::new(family).unwrap();
17 
18     server.blocking_bind(&net, bind_address).unwrap();
19     let (server_incoming, _) = server.stream(None).unwrap();
20     let addr = server.local_address().unwrap();
21 
22     let client_addr = {
23         let client = UdpSocket::new(family).unwrap();
24         client.blocking_bind(&net, unspecified_addr).unwrap();
25         let (_, client_outgoing) = client.stream(Some(addr)).unwrap();
26 
27         let datagrams = [
28             OutgoingDatagram {
29                 data: first_message.to_vec(),
30                 remote_address: None,
31             },
32             OutgoingDatagram {
33                 data: second_message.to_vec(),
34                 remote_address: Some(addr),
35             },
36         ];
37         client_outgoing.blocking_send(&datagrams).unwrap();
38 
39         client.local_address().unwrap()
40     };
41 
42     {
43         // Check that we've received our sent messages.
44         let datagrams = server_incoming.blocking_receive(2..100).unwrap();
45         assert_eq!(datagrams.len(), 2);
46 
47         assert_eq!(datagrams[0].data, first_message);
48         assert_eq!(datagrams[0].remote_address, client_addr);
49 
50         assert_eq!(datagrams[1].data, second_message);
51         assert_eq!(datagrams[1].remote_address, client_addr);
52     }
53 
54     // Another client
55     {
56         let client = UdpSocket::new(family).unwrap();
57         client.blocking_bind(&net, unspecified_addr).unwrap();
58         let (_, client_outgoing) = client.stream(None).unwrap();
59 
60         let datagrams = [OutgoingDatagram {
61             data: third_message.to_vec(),
62             remote_address: Some(addr),
63         }];
64         client_outgoing.blocking_send(&datagrams).unwrap();
65     }
66 
67     {
68         // Check that we sent and received our message!
69         let datagrams = server_incoming.blocking_receive(1..100).unwrap();
70         assert_eq!(datagrams.len(), 1);
71 
72         assert_eq!(datagrams[0].data, third_message);
73     }
74 }
75 
76 fn main() {
77     test_udp_sample_application(
78         IpAddressFamily::Ipv4,
79         IpSocketAddress::Ipv4(Ipv4SocketAddress {
80             port: 0,                 // use any free port
81             address: (127, 0, 0, 1), // localhost
82         }),
83     );
84     if supports_ipv6() {
85         test_udp_sample_application(
86             IpAddressFamily::Ipv6,
87             IpSocketAddress::Ipv6(Ipv6SocketAddress {
88                 port: 0,                           // use any free port
89                 address: (0, 0, 0, 0, 0, 0, 0, 1), // localhost
90                 flow_info: 0,
91                 scope_id: 0,
92             }),
93         );
94     }
95 }
96