renet
/
renet
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove braces that were previously needed to workaround SocketRef borrow issues.

master
Dario Nieuwenhuis 2021-10-21 04:11:41 +02:00
parent f8cc1eacbe
commit 8c43fdd443
9 changed files with 407 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
examples/benchmark.rs
View File

@ -119,42 +119,38 @@ fn main() {
} }
// tcp:1234: emit data // tcp:1234: emit data
{ let socket = iface.get_socket::<TcpSocket>(tcp1_handle);
let socket = iface.get_socket::<TcpSocket>(tcp1_handle); if !socket.is_open() {
if !socket.is_open() { socket.listen(1234).unwrap();
socket.listen(1234).unwrap(); }
}
if socket.can_send() { if socket.can_send() {
if processed < AMOUNT { if processed < AMOUNT {
let length = socket let length = socket
.send(|buffer| { .send(|buffer| {
let length = cmp::min(buffer.len(), AMOUNT - processed); let length = cmp::min(buffer.len(), AMOUNT - processed);
(length, length) (length, length)
}) })
.unwrap(); .unwrap();
processed += length; processed += length;
}
} }
} }
// tcp:1235: sink data // tcp:1235: sink data
{ let socket = iface.get_socket::<TcpSocket>(tcp2_handle);
let socket = iface.get_socket::<TcpSocket>(tcp2_handle); if !socket.is_open() {
if !socket.is_open() { socket.listen(1235).unwrap();
socket.listen(1235).unwrap(); }
}
if socket.can_recv() { if socket.can_recv() {
if processed < AMOUNT { if processed < AMOUNT {
let length = socket let length = socket
.recv(|buffer| { .recv(|buffer| {
let length = cmp::min(buffer.len(), AMOUNT - processed); let length = cmp::min(buffer.len(), AMOUNT - processed);
(length, length) (length, length)
}) })
.unwrap(); .unwrap();
processed += length; processed += length;
}
} }
} }

74
examples/client.rs
View File

@ -54,10 +54,8 @@ fn main() {
let tcp_handle = iface.add_socket(tcp_socket); let tcp_handle = iface.add_socket(tcp_socket);
{ let socket = iface.get_socket::<TcpSocket>(tcp_handle);
let socket = iface.get_socket::<TcpSocket>(tcp_handle); socket.connect((address, port), 49500).unwrap();
socket.connect((address, port), 49500).unwrap();
}
let mut tcp_active = false; let mut tcp_active = false;
loop { loop {
@ -69,43 +67,41 @@ fn main() {
} }
} }
{ let socket = iface.get_socket::<TcpSocket>(tcp_handle);
let socket = iface.get_socket::<TcpSocket>(tcp_handle); if socket.is_active() && !tcp_active {
if socket.is_active() && !tcp_active { debug!("connected");
debug!("connected"); } else if !socket.is_active() && tcp_active {
} else if !socket.is_active() && tcp_active { debug!("disconnected");
debug!("disconnected"); break;
break; }
} tcp_active = socket.is_active();
tcp_active = socket.is_active();
if socket.may_recv() { if socket.may_recv() {
let data = socket let data = socket
.recv(|data| { .recv(|data| {
let mut data = data.to_owned(); let mut data = data.to_owned();
if !data.is_empty() { if !data.is_empty() {
debug!( debug!(
"recv data: {:?}", "recv data: {:?}",
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
); );
data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat(); data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
data.reverse(); data.reverse();
data.extend(b"\n"); data.extend(b"\n");
} }
(data.len(), data) (data.len(), data)
}) })
.unwrap(); .unwrap();
if socket.can_send() && !data.is_empty() { if socket.can_send() && !data.is_empty() {
debug!( debug!(
"send data: {:?}", "send data: {:?}",
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
); );
socket.send_slice(&data[..]).unwrap(); socket.send_slice(&data[..]).unwrap();
}
} else if socket.may_send() {
debug!("close");
socket.close();
} }
} else if socket.may_send() {
debug!("close");
socket.close();
} }
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");

74
examples/httpclient.rs
View File

@ -76,46 +76,44 @@ fn main() {
} }
} }
{ let socket = iface.get_socket::<TcpSocket>(tcp_handle);
let socket = iface.get_socket::<TcpSocket>(tcp_handle);
state = match state { state = match state {
State::Connect if !socket.is_active() => { State::Connect if !socket.is_active() => {
debug!("connecting"); debug!("connecting");
let local_port = 49152 + rand::random::<u16>() % 16384; let local_port = 49152 + rand::random::<u16>() % 16384;
socket socket
.connect((address, url.port().unwrap_or(80)), local_port) .connect((address, url.port().unwrap_or(80)), local_port)
.unwrap(); .unwrap();
State::Request State::Request
}
State::Request if socket.may_send() => {
debug!("sending request");
let http_get = "GET ".to_owned() + url.path() + " HTTP/1.1\r\n";
socket.send_slice(http_get.as_ref()).expect("cannot send");
let http_host = "Host: ".to_owned() + url.host_str().unwrap() + "\r\n";
socket.send_slice(http_host.as_ref()).expect("cannot send");
socket
.send_slice(b"Connection: close\r\n")
.expect("cannot send");
socket.send_slice(b"\r\n").expect("cannot send");
State::Response
}
State::Response if socket.can_recv() => {
socket
.recv(|data| {
println!("{}", str::from_utf8(data).unwrap_or("(invalid utf8)"));
(data.len(), ())
})
.unwrap();
State::Response
}
State::Response if !socket.may_recv() => {
debug!("received complete response");
break;
}
_ => state,
} }
} State::Request if socket.may_send() => {
debug!("sending request");
let http_get = "GET ".to_owned() + url.path() + " HTTP/1.1\r\n";
socket.send_slice(http_get.as_ref()).expect("cannot send");
let http_host = "Host: ".to_owned() + url.host_str().unwrap() + "\r\n";
socket.send_slice(http_host.as_ref()).expect("cannot send");
socket
.send_slice(b"Connection: close\r\n")
.expect("cannot send");
socket.send_slice(b"\r\n").expect("cannot send");
State::Response
}
State::Response if socket.can_recv() => {
socket
.recv(|data| {
println!("{}", str::from_utf8(data).unwrap_or("(invalid utf8)"));
(data.len(), ())
})
.unwrap();
State::Response
}
State::Response if !socket.may_recv() => {
debug!("received complete response");
break;
}
_ => state,
};
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
} }

66
examples/loopback.rs
View File

@ -135,48 +135,44 @@ fn main() {
} }
} }
{ let mut socket = iface.get_socket::<TcpSocket>(server_handle);
let mut socket = iface.get_socket::<TcpSocket>(server_handle); if !socket.is_active() && !socket.is_listening() {
if !socket.is_active() && !socket.is_listening() { if !did_listen {
if !did_listen { debug!("listening");
debug!("listening"); socket.listen(1234).unwrap();
socket.listen(1234).unwrap(); did_listen = true;
did_listen = true;
}
}
if socket.can_recv() {
debug!(
"got {:?}",
socket.recv(|buffer| { (buffer.len(), str::from_utf8(buffer).unwrap()) })
);
socket.close();
done = true;
} }
} }
{ if socket.can_recv() {
let mut socket = iface.get_socket::<TcpSocket>(client_handle); debug!(
if !socket.is_open() { "got {:?}",
if !did_connect { socket.recv(|buffer| { (buffer.len(), str::from_utf8(buffer).unwrap()) })
debug!("connecting"); );
socket socket.close();
.connect( done = true;
(IpAddress::v4(127, 0, 0, 1), 1234), }
(IpAddress::Unspecified, 65000),
)
.unwrap();
did_connect = true;
}
}
if socket.can_send() { let mut socket = iface.get_socket::<TcpSocket>(client_handle);
debug!("sending"); if !socket.is_open() {
socket.send_slice(b"0123456789abcdef").unwrap(); if !did_connect {
socket.close(); debug!("connecting");
socket
.connect(
(IpAddress::v4(127, 0, 0, 1), 1234),
(IpAddress::Unspecified, 65000),
)
.unwrap();
did_connect = true;
} }
} }
if socket.can_send() {
debug!("sending");
socket.send_slice(b"0123456789abcdef").unwrap();
socket.close();
}
match iface.poll_delay(clock.elapsed()) { match iface.poll_delay(clock.elapsed()) {
Some(Duration::ZERO) => debug!("resuming"), Some(Duration::ZERO) => debug!("resuming"),
Some(delay) => { Some(delay) => {

49
examples/multicast.rs
View File

@ -77,35 +77,32 @@ fn main() {
} }
} }
{ let socket = iface.get_socket::<RawSocket>(raw_handle);
let socket = iface.get_socket::<RawSocket>(raw_handle);
if socket.can_recv() { if socket.can_recv() {
// For display purposes only - normally we wouldn't process incoming IGMP packets // For display purposes only - normally we wouldn't process incoming IGMP packets
// in the application layer // in the application layer
socket socket
.recv() .recv()
.and_then(Ipv4Packet::new_checked) .and_then(Ipv4Packet::new_checked)
.and_then(|ipv4_packet| IgmpPacket::new_checked(ipv4_packet.payload())) .and_then(|ipv4_packet| IgmpPacket::new_checked(ipv4_packet.payload()))
.and_then(|igmp_packet| IgmpRepr::parse(&igmp_packet)) .and_then(|igmp_packet| IgmpRepr::parse(&igmp_packet))
.map(|igmp_repr| println!("IGMP packet: {:?}", igmp_repr)) .map(|igmp_repr| println!("IGMP packet: {:?}", igmp_repr))
.unwrap_or_else(|e| println!("Recv IGMP error: {:?}", e)); .unwrap_or_else(|e| println!("Recv IGMP error: {:?}", e));
}
} }
{
let socket = iface.get_socket::<UdpSocket>(udp_handle);
if !socket.is_open() {
socket.bind(MDNS_PORT).unwrap()
}
if socket.can_recv() { let socket = iface.get_socket::<UdpSocket>(udp_handle);
socket if !socket.is_open() {
.recv() socket.bind(MDNS_PORT).unwrap()
.map(|(data, sender)| { }
println!("mDNS traffic: {} UDP bytes from {}", data.len(), sender)
}) if socket.can_recv() {
.unwrap_or_else(|e| println!("Recv UDP error: {:?}", e)); socket
} .recv()
.map(|(data, sender)| {
println!("mDNS traffic: {} UDP bytes from {}", data.len(), sender)
})
.unwrap_or_else(|e| println!("Recv UDP error: {:?}", e));
} }
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");

185
examples/ping.rs
View File

@ -155,110 +155,107 @@ fn main() {
} }
} }
{ let timestamp = Instant::now();
let timestamp = Instant::now(); let socket = iface.get_socket::<IcmpSocket>(icmp_handle);
let socket = iface.get_socket::<IcmpSocket>(icmp_handle); if !socket.is_open() {
if !socket.is_open() { socket.bind(IcmpEndpoint::Ident(ident)).unwrap();
socket.bind(IcmpEndpoint::Ident(ident)).unwrap(); send_at = timestamp;
send_at = timestamp; }
}
if socket.can_send() && seq_no < count as u16 && send_at <= timestamp { if socket.can_send() && seq_no < count as u16 && send_at <= timestamp {
NetworkEndian::write_i64(&mut echo_payload, timestamp.total_millis()); NetworkEndian::write_i64(&mut echo_payload, timestamp.total_millis());
match remote_addr { match remote_addr {
IpAddress::Ipv4(_) => { IpAddress::Ipv4(_) => {
let (icmp_repr, mut icmp_packet) = send_icmp_ping!( let (icmp_repr, mut icmp_packet) = send_icmp_ping!(
Icmpv4Repr, Icmpv4Repr,
Icmpv4Packet, Icmpv4Packet,
ident, ident,
seq_no, seq_no,
echo_payload, echo_payload,
socket, socket,
remote_addr remote_addr
); );
icmp_repr.emit(&mut icmp_packet, &device_caps.checksum); icmp_repr.emit(&mut icmp_packet, &device_caps.checksum);
}
IpAddress::Ipv6(_) => {
let (icmp_repr, mut icmp_packet) = send_icmp_ping!(
Icmpv6Repr,
Icmpv6Packet,
ident,
seq_no,
echo_payload,
socket,
remote_addr
);
icmp_repr.emit(
&src_ipv6,
&remote_addr,
&mut icmp_packet,
&device_caps.checksum,
);
}
_ => unimplemented!(),
} }
IpAddress::Ipv6(_) => {
waiting_queue.insert(seq_no, timestamp); let (icmp_repr, mut icmp_packet) = send_icmp_ping!(
seq_no += 1; Icmpv6Repr,
send_at += interval; Icmpv6Packet,
} ident,
seq_no,
if socket.can_recv() { echo_payload,
let (payload, _) = socket.recv().unwrap(); socket,
remote_addr
match remote_addr { );
IpAddress::Ipv4(_) => { icmp_repr.emit(
let icmp_packet = Icmpv4Packet::new_checked(&payload).unwrap(); &src_ipv6,
let icmp_repr = &remote_addr,
Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap(); &mut icmp_packet,
get_icmp_pong!( &device_caps.checksum,
Icmpv4Repr, );
icmp_repr,
payload,
waiting_queue,
remote_addr,
timestamp,
received
);
}
IpAddress::Ipv6(_) => {
let icmp_packet = Icmpv6Packet::new_checked(&payload).unwrap();
let icmp_repr = Icmpv6Repr::parse(
&remote_addr,
&src_ipv6,
&icmp_packet,
&device_caps.checksum,
)
.unwrap();
get_icmp_pong!(
Icmpv6Repr,
icmp_repr,
payload,
waiting_queue,
remote_addr,
timestamp,
received
);
}
_ => unimplemented!(),
} }
_ => unimplemented!(),
} }
waiting_queue.retain(|seq, from| { waiting_queue.insert(seq_no, timestamp);
if timestamp - *from < timeout { seq_no += 1;
true send_at += interval;
} else { }
println!("From {} icmp_seq={} timeout", remote_addr, seq);
false if socket.can_recv() {
let (payload, _) = socket.recv().unwrap();
match remote_addr {
IpAddress::Ipv4(_) => {
let icmp_packet = Icmpv4Packet::new_checked(&payload).unwrap();
let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap();
get_icmp_pong!(
Icmpv4Repr,
icmp_repr,
payload,
waiting_queue,
remote_addr,
timestamp,
received
);
} }
}); IpAddress::Ipv6(_) => {
let icmp_packet = Icmpv6Packet::new_checked(&payload).unwrap();
if seq_no == count as u16 && waiting_queue.is_empty() { let icmp_repr = Icmpv6Repr::parse(
break; &remote_addr,
&src_ipv6,
&icmp_packet,
&device_caps.checksum,
)
.unwrap();
get_icmp_pong!(
Icmpv6Repr,
icmp_repr,
payload,
waiting_queue,
remote_addr,
timestamp,
received
);
}
_ => unimplemented!(),
} }
} }
waiting_queue.retain(|seq, from| {
if timestamp - *from < timeout {
true
} else {
println!("From {} icmp_seq={} timeout", remote_addr, seq);
false
}
});
if seq_no == count as u16 && waiting_queue.is_empty() {
break;
}
let timestamp = Instant::now(); let timestamp = Instant::now();
match iface.poll_at(timestamp) { match iface.poll_at(timestamp) {
Some(poll_at) if timestamp < poll_at => { Some(poll_at) if timestamp < poll_at => {

202
examples/server.rs
View File

@ -80,135 +80,125 @@ fn main() {
} }
// udp:6969: respond "hello" // udp:6969: respond "hello"
{ let socket = iface.get_socket::<UdpSocket>(udp_handle);
let socket = iface.get_socket::<UdpSocket>(udp_handle); if !socket.is_open() {
if !socket.is_open() { socket.bind(6969).unwrap()
socket.bind(6969).unwrap() }
}
let client = match socket.recv() { let client = match socket.recv() {
Ok((data, endpoint)) => { Ok((data, endpoint)) => {
debug!(
"udp:6969 recv data: {:?} from {}",
str::from_utf8(data).unwrap(),
endpoint
);
Some(endpoint)
}
Err(_) => None,
};
if let Some(endpoint) = client {
let data = b"hello\n";
debug!( debug!(
"udp:6969 send data: {:?}", "udp:6969 recv data: {:?} from {}",
str::from_utf8(data.as_ref()).unwrap() str::from_utf8(data).unwrap(),
endpoint
); );
socket.send_slice(data, endpoint).unwrap(); Some(endpoint)
} }
Err(_) => None,
};
if let Some(endpoint) = client {
let data = b"hello\n";
debug!(
"udp:6969 send data: {:?}",
str::from_utf8(data.as_ref()).unwrap()
);
socket.send_slice(data, endpoint).unwrap();
} }
// tcp:6969: respond "hello" // tcp:6969: respond "hello"
{ let socket = iface.get_socket::<TcpSocket>(tcp1_handle);
let socket = iface.get_socket::<TcpSocket>(tcp1_handle); if !socket.is_open() {
if !socket.is_open() { socket.listen(6969).unwrap();
socket.listen(6969).unwrap(); }
}
if socket.can_send() { if socket.can_send() {
debug!("tcp:6969 send greeting"); debug!("tcp:6969 send greeting");
writeln!(socket, "hello").unwrap(); writeln!(socket, "hello").unwrap();
debug!("tcp:6969 close"); debug!("tcp:6969 close");
socket.close(); socket.close();
}
} }
// tcp:6970: echo with reverse // tcp:6970: echo with reverse
{ let socket = iface.get_socket::<TcpSocket>(tcp2_handle);
let socket = iface.get_socket::<TcpSocket>(tcp2_handle); if !socket.is_open() {
if !socket.is_open() { socket.listen(6970).unwrap()
socket.listen(6970).unwrap() }
}
if socket.is_active() && !tcp_6970_active { if socket.is_active() && !tcp_6970_active {
debug!("tcp:6970 connected"); debug!("tcp:6970 connected");
} else if !socket.is_active() && tcp_6970_active { } else if !socket.is_active() && tcp_6970_active {
debug!("tcp:6970 disconnected"); debug!("tcp:6970 disconnected");
} }
tcp_6970_active = socket.is_active(); tcp_6970_active = socket.is_active();
if socket.may_recv() { if socket.may_recv() {
let data = socket let data = socket
.recv(|buffer| { .recv(|buffer| {
let recvd_len = buffer.len(); let recvd_len = buffer.len();
let mut data = buffer.to_owned(); let mut data = buffer.to_owned();
if !data.is_empty() { if !data.is_empty() {
debug!( debug!(
"tcp:6970 recv data: {:?}", "tcp:6970 recv data: {:?}",
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
); );
data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat(); data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
data.reverse(); data.reverse();
data.extend(b"\n"); data.extend(b"\n");
} }
(recvd_len, data) (recvd_len, data)
}) })
.unwrap(); .unwrap();
if socket.can_send() && !data.is_empty() { if socket.can_send() && !data.is_empty() {
debug!( debug!(
"tcp:6970 send data: {:?}", "tcp:6970 send data: {:?}",
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
); );
socket.send_slice(&data[..]).unwrap(); socket.send_slice(&data[..]).unwrap();
}
} else if socket.may_send() {
debug!("tcp:6970 close");
socket.close();
} }
} else if socket.may_send() {
debug!("tcp:6970 close");
socket.close();
} }
// tcp:6971: sinkhole // tcp:6971: sinkhole
{ let socket = iface.get_socket::<TcpSocket>(tcp3_handle);
let socket = iface.get_socket::<TcpSocket>(tcp3_handle); if !socket.is_open() {
if !socket.is_open() { socket.listen(6971).unwrap();
socket.listen(6971).unwrap(); socket.set_keep_alive(Some(Duration::from_millis(1000)));
socket.set_keep_alive(Some(Duration::from_millis(1000))); socket.set_timeout(Some(Duration::from_millis(2000)));
socket.set_timeout(Some(Duration::from_millis(2000))); }
}
if socket.may_recv() { if socket.may_recv() {
socket socket
.recv(|buffer| { .recv(|buffer| {
if !buffer.is_empty() { if !buffer.is_empty() {
debug!("tcp:6971 recv {:?} octets", buffer.len()); debug!("tcp:6971 recv {:?} octets", buffer.len());
} }
(buffer.len(), ()) (buffer.len(), ())
}) })
.unwrap(); .unwrap();
} else if socket.may_send() { } else if socket.may_send() {
socket.close(); socket.close();
}
} }
// tcp:6972: fountain // tcp:6972: fountain
{ let socket = iface.get_socket::<TcpSocket>(tcp4_handle);
let socket = iface.get_socket::<TcpSocket>(tcp4_handle); if !socket.is_open() {
if !socket.is_open() { socket.listen(6972).unwrap()
socket.listen(6972).unwrap() }
}
if socket.may_send() { if socket.may_send() {
socket socket
.send(|data| { .send(|data| {
if !data.is_empty() { if !data.is_empty() {
debug!("tcp:6972 send {:?} octets", data.len()); debug!("tcp:6972 send {:?} octets", data.len());
for (i, b) in data.iter_mut().enumerate() { for (i, b) in data.iter_mut().enumerate() {
*b = (i % 256) as u8; *b = (i % 256) as u8;
}
} }
(data.len(), ()) }
}) (data.len(), ())
.unwrap(); })
} .unwrap();
} }
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");

40
examples/sixlowpan.rs
View File

@ -100,31 +100,29 @@ fn main() {
} }
// udp:6969: respond "hello" // udp:6969: respond "hello"
{ let socket = iface.get_socket::<UdpSocket>(udp_handle);
let socket = iface.get_socket::<UdpSocket>(udp_handle); if !socket.is_open() {
if !socket.is_open() { socket.bind(6969).unwrap()
socket.bind(6969).unwrap() }
}
let client = match socket.recv() { let client = match socket.recv() {
Ok((data, endpoint)) => { Ok((data, endpoint)) => {
debug!(
"udp:6969 recv data: {:?} from {}",
str::from_utf8(data).unwrap(),
endpoint
);
Some(endpoint)
}
Err(_) => None,
};
if let Some(endpoint) = client {
let data = b"hello\n";
debug!( debug!(
"udp:6969 send data: {:?}", "udp:6969 recv data: {:?} from {}",
str::from_utf8(data.as_ref()).unwrap() str::from_utf8(data).unwrap(),
endpoint
); );
socket.send_slice(data, endpoint).unwrap(); Some(endpoint)
} }
Err(_) => None,
};
if let Some(endpoint) = client {
let data = b"hello\n";
debug!(
"udp:6969 send data: {:?}",
str::from_utf8(data.as_ref()).unwrap()
);
socket.send_slice(data, endpoint).unwrap();
} }
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");

119
src/iface/interface.rs
View File

@ -2942,13 +2942,11 @@ mod test {
hop_limit: 0x40, hop_limit: 0x40,
}); });
{ // Bind the socket to port 68
// Bind the socket to port 68 let socket = iface.get_socket::<UdpSocket>(socket_handle);
let socket = iface.get_socket::<UdpSocket>(socket_handle); assert_eq!(socket.bind(68), Ok(()));
assert_eq!(socket.bind(68), Ok(())); assert!(!socket.can_recv());
assert!(!socket.can_recv()); assert!(socket.can_send());
assert!(socket.can_send());
}
udp_repr.emit( udp_repr.emit(
&mut packet, &mut packet,
@ -2968,16 +2966,14 @@ mod test {
Ok(None) Ok(None)
); );
{ // Make sure the payload to the UDP packet processed by process_udp is
// Make sure the payload to the UDP packet processed by process_udp is // appended to the bound sockets rx_buffer
// appended to the bound sockets rx_buffer let socket = iface.get_socket::<UdpSocket>(socket_handle);
let socket = iface.get_socket::<UdpSocket>(socket_handle); assert!(socket.can_recv());
assert!(socket.can_recv()); assert_eq!(
assert_eq!( socket.recv(),
socket.recv(), Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_ip.into(), 67)))
Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_ip.into(), 67))) );
);
}
} }
#[test] #[test]
@ -3194,10 +3190,8 @@ mod test {
frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_dst_addr(EthernetAddress::BROADCAST);
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Arp); frame.set_ethertype(EthernetProtocol::Arp);
{ let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
let mut packet = ArpPacket::new_unchecked(frame.payload_mut()); repr.emit(&mut packet);
repr.emit(&mut packet);
}
let cx = iface.context(Instant::from_secs(0)); let cx = iface.context(Instant::from_secs(0));
@ -3255,15 +3249,13 @@ mod test {
frame.set_dst_addr(EthernetAddress([0x33, 0x33, 0x00, 0x00, 0x00, 0x00])); frame.set_dst_addr(EthernetAddress([0x33, 0x33, 0x00, 0x00, 0x00, 0x00]));
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Ipv6); frame.set_ethertype(EthernetProtocol::Ipv6);
{ ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default());
ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); solicit.emit(
solicit.emit( &remote_ip_addr.into(),
&remote_ip_addr.into(), &local_ip_addr.solicited_node().into(),
&local_ip_addr.solicited_node().into(), &mut Icmpv6Packet::new_unchecked(&mut frame.payload_mut()[ip_repr.buffer_len()..]),
&mut Icmpv6Packet::new_unchecked(&mut frame.payload_mut()[ip_repr.buffer_len()..]), &ChecksumCapabilities::default(),
&ChecksumCapabilities::default(), );
);
}
let icmpv6_expected = Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert { let icmpv6_expected = Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert {
flags: NdiscNeighborFlags::SOLICITED, flags: NdiscNeighborFlags::SOLICITED,
@ -3326,10 +3318,8 @@ mod test {
frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_dst_addr(EthernetAddress::BROADCAST);
frame.set_src_addr(remote_hw_addr); frame.set_src_addr(remote_hw_addr);
frame.set_ethertype(EthernetProtocol::Arp); frame.set_ethertype(EthernetProtocol::Arp);
{ let mut packet = ArpPacket::new_unchecked(frame.payload_mut());
let mut packet = ArpPacket::new_unchecked(frame.payload_mut()); repr.emit(&mut packet);
repr.emit(&mut packet);
}
let cx = iface.context(Instant::from_secs(0)); let cx = iface.context(Instant::from_secs(0));
@ -3442,11 +3432,9 @@ mod test {
let seq_no = 0x5432; let seq_no = 0x5432;
let echo_data = &[0xff; 16]; let echo_data = &[0xff; 16];
{ let socket = iface.get_socket::<IcmpSocket>(socket_handle);
let socket = iface.get_socket::<IcmpSocket>(socket_handle); // Bind to the ID 0x1234
// Bind to the ID 0x1234 assert_eq!(socket.bind(IcmpEndpoint::Ident(ident)), Ok(()));
assert_eq!(socket.bind(IcmpEndpoint::Ident(ident)), Ok(()));
}
// Ensure the ident we bound to and the ident of the packet are the same. // Ensure the ident we bound to and the ident of the packet are the same.
let mut bytes = [0xff; 24]; let mut bytes = [0xff; 24];
@ -3470,9 +3458,7 @@ mod test {
// Open a socket and ensure the packet is handled due to the listening // Open a socket and ensure the packet is handled due to the listening
// socket. // socket.
{ assert!(!iface.get_socket::<IcmpSocket>(socket_handle).can_recv());
assert!(!iface.get_socket::<IcmpSocket>(socket_handle).can_recv());
}
// Confirm we still get EchoReply from `smoltcp` even with the ICMP socket listening // Confirm we still get EchoReply from `smoltcp` even with the ICMP socket listening
let echo_reply = Icmpv4Repr::EchoReply { let echo_reply = Icmpv4Repr::EchoReply {
@ -3493,17 +3479,15 @@ mod test {
Ok(Some(IpPacket::Icmpv4((ipv4_reply, echo_reply)))) Ok(Some(IpPacket::Icmpv4((ipv4_reply, echo_reply))))
); );
{ let socket = iface.get_socket::<IcmpSocket>(socket_handle);
let socket = iface.get_socket::<IcmpSocket>(socket_handle); assert!(socket.can_recv());
assert!(socket.can_recv()); assert_eq!(
assert_eq!( socket.recv(),
socket.recv(), Ok((
Ok(( icmp_data,
icmp_data, IpAddress::Ipv4(Ipv4Address::new(0x7f, 0x00, 0x00, 0x02))
IpAddress::Ipv4(Ipv4Address::new(0x7f, 0x00, 0x00, 0x02)) ))
)) );
);
}
} }
#[test] #[test]
@ -3854,13 +3838,12 @@ mod test {
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; 15]); let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketMetadata::EMPTY], vec![0; 15]);
let udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer); let udp_socket = UdpSocket::new(udp_rx_buffer, udp_tx_buffer);
let udp_socket_handle = iface.add_socket(udp_socket); let udp_socket_handle = iface.add_socket(udp_socket);
{
// Bind the socket to port 68 // Bind the socket to port 68
let socket = iface.get_socket::<UdpSocket>(udp_socket_handle); let socket = iface.get_socket::<UdpSocket>(udp_socket_handle);
assert_eq!(socket.bind(68), Ok(())); assert_eq!(socket.bind(68), Ok(()));
assert!(!socket.can_recv()); assert!(!socket.can_recv());
assert!(socket.can_send()); assert!(socket.can_send());
}
let packets = 1; let packets = 1;
let raw_rx_buffer = let raw_rx_buffer =
@ -3927,14 +3910,12 @@ mod test {
Ok(None) Ok(None)
); );
{ // Make sure the UDP socket can still receive in presence of a Raw socket that handles UDP
// Make sure the UDP socket can still receive in presence of a Raw socket that handles UDP let socket = iface.get_socket::<UdpSocket>(udp_socket_handle);
let socket = iface.get_socket::<UdpSocket>(udp_socket_handle); assert!(socket.can_recv());
assert!(socket.can_recv()); assert_eq!(
assert_eq!( socket.recv(),
socket.recv(), Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_addr.into(), 67)))
Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_addr.into(), 67))) );
);
}
} }
} }