From 8c43fdd4433a90370b14d4f91e000b9f36b194a5 Mon Sep 17 00:00:00 2001 From: Dario Nieuwenhuis Date: Thu, 21 Oct 2021 04:11:41 +0200 Subject: [PATCH] Remove braces that were previously needed to workaround SocketRef borrow issues. --- examples/benchmark.rs | 56 ++++++------ examples/client.rs | 74 +++++++-------- examples/httpclient.rs | 74 ++++++++------- examples/loopback.rs | 66 +++++++------- examples/multicast.rs | 49 +++++----- examples/ping.rs | 185 +++++++++++++++++++------------------ examples/server.rs | 202 ++++++++++++++++++++--------------------- examples/sixlowpan.rs | 40 ++++---- src/iface/interface.rs | 119 ++++++++++-------------- 9 files changed, 407 insertions(+), 458 deletions(-) diff --git a/examples/benchmark.rs b/examples/benchmark.rs index 9ba3d29..f9142c2 100644 --- a/examples/benchmark.rs +++ b/examples/benchmark.rs @@ -119,42 +119,38 @@ fn main() { } // tcp:1234: emit data - { - let socket = iface.get_socket::(tcp1_handle); - if !socket.is_open() { - socket.listen(1234).unwrap(); - } + let socket = iface.get_socket::(tcp1_handle); + if !socket.is_open() { + socket.listen(1234).unwrap(); + } - if socket.can_send() { - if processed < AMOUNT { - let length = socket - .send(|buffer| { - let length = cmp::min(buffer.len(), AMOUNT - processed); - (length, length) - }) - .unwrap(); - processed += length; - } + if socket.can_send() { + if processed < AMOUNT { + let length = socket + .send(|buffer| { + let length = cmp::min(buffer.len(), AMOUNT - processed); + (length, length) + }) + .unwrap(); + processed += length; } } // tcp:1235: sink data - { - let socket = iface.get_socket::(tcp2_handle); - if !socket.is_open() { - socket.listen(1235).unwrap(); - } + let socket = iface.get_socket::(tcp2_handle); + if !socket.is_open() { + socket.listen(1235).unwrap(); + } - if socket.can_recv() { - if processed < AMOUNT { - let length = socket - .recv(|buffer| { - let length = cmp::min(buffer.len(), AMOUNT - processed); - (length, length) - }) - .unwrap(); - processed += length; - } + if socket.can_recv() { + if processed < AMOUNT { + let length = socket + .recv(|buffer| { + let length = cmp::min(buffer.len(), AMOUNT - processed); + (length, length) + }) + .unwrap(); + processed += length; } } diff --git a/examples/client.rs b/examples/client.rs index f096174..00e7c70 100644 --- a/examples/client.rs +++ b/examples/client.rs @@ -54,10 +54,8 @@ fn main() { let tcp_handle = iface.add_socket(tcp_socket); - { - let socket = iface.get_socket::(tcp_handle); - socket.connect((address, port), 49500).unwrap(); - } + let socket = iface.get_socket::(tcp_handle); + socket.connect((address, port), 49500).unwrap(); let mut tcp_active = false; loop { @@ -69,43 +67,41 @@ fn main() { } } - { - let socket = iface.get_socket::(tcp_handle); - if socket.is_active() && !tcp_active { - debug!("connected"); - } else if !socket.is_active() && tcp_active { - debug!("disconnected"); - break; - } - tcp_active = socket.is_active(); + let socket = iface.get_socket::(tcp_handle); + if socket.is_active() && !tcp_active { + debug!("connected"); + } else if !socket.is_active() && tcp_active { + debug!("disconnected"); + break; + } + tcp_active = socket.is_active(); - if socket.may_recv() { - let data = socket - .recv(|data| { - let mut data = data.to_owned(); - if !data.is_empty() { - debug!( - "recv data: {:?}", - str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") - ); - data = data.split(|&b| b == b'\n').collect::>().concat(); - data.reverse(); - data.extend(b"\n"); - } - (data.len(), data) - }) - .unwrap(); - if socket.can_send() && !data.is_empty() { - debug!( - "send data: {:?}", - str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") - ); - socket.send_slice(&data[..]).unwrap(); - } - } else if socket.may_send() { - debug!("close"); - socket.close(); + if socket.may_recv() { + let data = socket + .recv(|data| { + let mut data = data.to_owned(); + if !data.is_empty() { + debug!( + "recv data: {:?}", + str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") + ); + data = data.split(|&b| b == b'\n').collect::>().concat(); + data.reverse(); + data.extend(b"\n"); + } + (data.len(), data) + }) + .unwrap(); + if socket.can_send() && !data.is_empty() { + debug!( + "send data: {:?}", + str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") + ); + socket.send_slice(&data[..]).unwrap(); } + } else if socket.may_send() { + debug!("close"); + socket.close(); } phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); diff --git a/examples/httpclient.rs b/examples/httpclient.rs index 0ced70f..d1370c1 100644 --- a/examples/httpclient.rs +++ b/examples/httpclient.rs @@ -76,46 +76,44 @@ fn main() { } } - { - let socket = iface.get_socket::(tcp_handle); + let socket = iface.get_socket::(tcp_handle); - state = match state { - State::Connect if !socket.is_active() => { - debug!("connecting"); - let local_port = 49152 + rand::random::() % 16384; - socket - .connect((address, url.port().unwrap_or(80)), local_port) - .unwrap(); - 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 = match state { + State::Connect if !socket.is_active() => { + debug!("connecting"); + let local_port = 49152 + rand::random::() % 16384; + socket + .connect((address, url.port().unwrap_or(80)), local_port) + .unwrap(); + 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, + }; phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); } diff --git a/examples/loopback.rs b/examples/loopback.rs index d08f1d4..9b8abf3 100644 --- a/examples/loopback.rs +++ b/examples/loopback.rs @@ -135,48 +135,44 @@ fn main() { } } - { - let mut socket = iface.get_socket::(server_handle); - if !socket.is_active() && !socket.is_listening() { - if !did_listen { - debug!("listening"); - socket.listen(1234).unwrap(); - did_listen = true; - } - } - - if socket.can_recv() { - debug!( - "got {:?}", - socket.recv(|buffer| { (buffer.len(), str::from_utf8(buffer).unwrap()) }) - ); - socket.close(); - done = true; + let mut socket = iface.get_socket::(server_handle); + if !socket.is_active() && !socket.is_listening() { + if !did_listen { + debug!("listening"); + socket.listen(1234).unwrap(); + did_listen = true; } } - { - let mut socket = iface.get_socket::(client_handle); - if !socket.is_open() { - if !did_connect { - debug!("connecting"); - socket - .connect( - (IpAddress::v4(127, 0, 0, 1), 1234), - (IpAddress::Unspecified, 65000), - ) - .unwrap(); - did_connect = true; - } - } + if socket.can_recv() { + debug!( + "got {:?}", + socket.recv(|buffer| { (buffer.len(), str::from_utf8(buffer).unwrap()) }) + ); + socket.close(); + done = true; + } - if socket.can_send() { - debug!("sending"); - socket.send_slice(b"0123456789abcdef").unwrap(); - socket.close(); + let mut socket = iface.get_socket::(client_handle); + if !socket.is_open() { + if !did_connect { + 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()) { Some(Duration::ZERO) => debug!("resuming"), Some(delay) => { diff --git a/examples/multicast.rs b/examples/multicast.rs index e3f2fc6..b92115b 100644 --- a/examples/multicast.rs +++ b/examples/multicast.rs @@ -77,35 +77,32 @@ fn main() { } } - { - let socket = iface.get_socket::(raw_handle); + let socket = iface.get_socket::(raw_handle); - if socket.can_recv() { - // For display purposes only - normally we wouldn't process incoming IGMP packets - // in the application layer - socket - .recv() - .and_then(Ipv4Packet::new_checked) - .and_then(|ipv4_packet| IgmpPacket::new_checked(ipv4_packet.payload())) - .and_then(|igmp_packet| IgmpRepr::parse(&igmp_packet)) - .map(|igmp_repr| println!("IGMP packet: {:?}", igmp_repr)) - .unwrap_or_else(|e| println!("Recv IGMP error: {:?}", e)); - } + if socket.can_recv() { + // For display purposes only - normally we wouldn't process incoming IGMP packets + // in the application layer + socket + .recv() + .and_then(Ipv4Packet::new_checked) + .and_then(|ipv4_packet| IgmpPacket::new_checked(ipv4_packet.payload())) + .and_then(|igmp_packet| IgmpRepr::parse(&igmp_packet)) + .map(|igmp_repr| println!("IGMP packet: {:?}", igmp_repr)) + .unwrap_or_else(|e| println!("Recv IGMP error: {:?}", e)); } - { - let socket = iface.get_socket::(udp_handle); - if !socket.is_open() { - socket.bind(MDNS_PORT).unwrap() - } - if socket.can_recv() { - socket - .recv() - .map(|(data, sender)| { - println!("mDNS traffic: {} UDP bytes from {}", data.len(), sender) - }) - .unwrap_or_else(|e| println!("Recv UDP error: {:?}", e)); - } + let socket = iface.get_socket::(udp_handle); + if !socket.is_open() { + socket.bind(MDNS_PORT).unwrap() + } + + if socket.can_recv() { + 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"); diff --git a/examples/ping.rs b/examples/ping.rs index b4e9038..66fad82 100644 --- a/examples/ping.rs +++ b/examples/ping.rs @@ -155,110 +155,107 @@ fn main() { } } - { - let timestamp = Instant::now(); - let socket = iface.get_socket::(icmp_handle); - if !socket.is_open() { - socket.bind(IcmpEndpoint::Ident(ident)).unwrap(); - send_at = timestamp; - } + let timestamp = Instant::now(); + let socket = iface.get_socket::(icmp_handle); + if !socket.is_open() { + socket.bind(IcmpEndpoint::Ident(ident)).unwrap(); + send_at = timestamp; + } - if socket.can_send() && seq_no < count as u16 && send_at <= timestamp { - NetworkEndian::write_i64(&mut echo_payload, timestamp.total_millis()); + if socket.can_send() && seq_no < count as u16 && send_at <= timestamp { + NetworkEndian::write_i64(&mut echo_payload, timestamp.total_millis()); - match remote_addr { - IpAddress::Ipv4(_) => { - let (icmp_repr, mut icmp_packet) = send_icmp_ping!( - Icmpv4Repr, - Icmpv4Packet, - ident, - seq_no, - echo_payload, - socket, - remote_addr - ); - 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!(), + match remote_addr { + IpAddress::Ipv4(_) => { + let (icmp_repr, mut icmp_packet) = send_icmp_ping!( + Icmpv4Repr, + Icmpv4Packet, + ident, + seq_no, + echo_payload, + socket, + remote_addr + ); + icmp_repr.emit(&mut icmp_packet, &device_caps.checksum); } - - waiting_queue.insert(seq_no, timestamp); - seq_no += 1; - send_at += interval; - } - - 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(); - 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!(), + 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!(), } - waiting_queue.retain(|seq, from| { - if timestamp - *from < timeout { - true - } else { - println!("From {} icmp_seq={} timeout", remote_addr, seq); - false + waiting_queue.insert(seq_no, timestamp); + seq_no += 1; + send_at += interval; + } + + 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 + ); } - }); - - if seq_no == count as u16 && waiting_queue.is_empty() { - break; + 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!(), } } + 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(); match iface.poll_at(timestamp) { Some(poll_at) if timestamp < poll_at => { diff --git a/examples/server.rs b/examples/server.rs index c2abb18..d518b33 100644 --- a/examples/server.rs +++ b/examples/server.rs @@ -80,135 +80,125 @@ fn main() { } // udp:6969: respond "hello" - { - let socket = iface.get_socket::(udp_handle); - if !socket.is_open() { - socket.bind(6969).unwrap() - } + let socket = iface.get_socket::(udp_handle); + if !socket.is_open() { + socket.bind(6969).unwrap() + } - let client = match socket.recv() { - 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"; + let client = match socket.recv() { + Ok((data, endpoint)) => { debug!( - "udp:6969 send data: {:?}", - str::from_utf8(data.as_ref()).unwrap() + "udp:6969 recv data: {:?} from {}", + 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" - { - let socket = iface.get_socket::(tcp1_handle); - if !socket.is_open() { - socket.listen(6969).unwrap(); - } + let socket = iface.get_socket::(tcp1_handle); + if !socket.is_open() { + socket.listen(6969).unwrap(); + } - if socket.can_send() { - debug!("tcp:6969 send greeting"); - writeln!(socket, "hello").unwrap(); - debug!("tcp:6969 close"); - socket.close(); - } + if socket.can_send() { + debug!("tcp:6969 send greeting"); + writeln!(socket, "hello").unwrap(); + debug!("tcp:6969 close"); + socket.close(); } // tcp:6970: echo with reverse - { - let socket = iface.get_socket::(tcp2_handle); - if !socket.is_open() { - socket.listen(6970).unwrap() - } + let socket = iface.get_socket::(tcp2_handle); + if !socket.is_open() { + socket.listen(6970).unwrap() + } - if socket.is_active() && !tcp_6970_active { - debug!("tcp:6970 connected"); - } else if !socket.is_active() && tcp_6970_active { - debug!("tcp:6970 disconnected"); - } - tcp_6970_active = socket.is_active(); + if socket.is_active() && !tcp_6970_active { + debug!("tcp:6970 connected"); + } else if !socket.is_active() && tcp_6970_active { + debug!("tcp:6970 disconnected"); + } + tcp_6970_active = socket.is_active(); - if socket.may_recv() { - let data = socket - .recv(|buffer| { - let recvd_len = buffer.len(); - let mut data = buffer.to_owned(); - if !data.is_empty() { - debug!( - "tcp:6970 recv data: {:?}", - str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") - ); - data = data.split(|&b| b == b'\n').collect::>().concat(); - data.reverse(); - data.extend(b"\n"); - } - (recvd_len, data) - }) - .unwrap(); - if socket.can_send() && !data.is_empty() { - debug!( - "tcp:6970 send data: {:?}", - str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") - ); - socket.send_slice(&data[..]).unwrap(); - } - } else if socket.may_send() { - debug!("tcp:6970 close"); - socket.close(); + if socket.may_recv() { + let data = socket + .recv(|buffer| { + let recvd_len = buffer.len(); + let mut data = buffer.to_owned(); + if !data.is_empty() { + debug!( + "tcp:6970 recv data: {:?}", + str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") + ); + data = data.split(|&b| b == b'\n').collect::>().concat(); + data.reverse(); + data.extend(b"\n"); + } + (recvd_len, data) + }) + .unwrap(); + if socket.can_send() && !data.is_empty() { + debug!( + "tcp:6970 send data: {:?}", + str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)") + ); + socket.send_slice(&data[..]).unwrap(); } + } else if socket.may_send() { + debug!("tcp:6970 close"); + socket.close(); } // tcp:6971: sinkhole - { - let socket = iface.get_socket::(tcp3_handle); - if !socket.is_open() { - socket.listen(6971).unwrap(); - socket.set_keep_alive(Some(Duration::from_millis(1000))); - socket.set_timeout(Some(Duration::from_millis(2000))); - } + let socket = iface.get_socket::(tcp3_handle); + if !socket.is_open() { + socket.listen(6971).unwrap(); + socket.set_keep_alive(Some(Duration::from_millis(1000))); + socket.set_timeout(Some(Duration::from_millis(2000))); + } - if socket.may_recv() { - socket - .recv(|buffer| { - if !buffer.is_empty() { - debug!("tcp:6971 recv {:?} octets", buffer.len()); - } - (buffer.len(), ()) - }) - .unwrap(); - } else if socket.may_send() { - socket.close(); - } + if socket.may_recv() { + socket + .recv(|buffer| { + if !buffer.is_empty() { + debug!("tcp:6971 recv {:?} octets", buffer.len()); + } + (buffer.len(), ()) + }) + .unwrap(); + } else if socket.may_send() { + socket.close(); } // tcp:6972: fountain - { - let socket = iface.get_socket::(tcp4_handle); - if !socket.is_open() { - socket.listen(6972).unwrap() - } + let socket = iface.get_socket::(tcp4_handle); + if !socket.is_open() { + socket.listen(6972).unwrap() + } - if socket.may_send() { - socket - .send(|data| { - if !data.is_empty() { - debug!("tcp:6972 send {:?} octets", data.len()); - for (i, b) in data.iter_mut().enumerate() { - *b = (i % 256) as u8; - } + if socket.may_send() { + socket + .send(|data| { + if !data.is_empty() { + debug!("tcp:6972 send {:?} octets", data.len()); + for (i, b) in data.iter_mut().enumerate() { + *b = (i % 256) as u8; } - (data.len(), ()) - }) - .unwrap(); - } + } + (data.len(), ()) + }) + .unwrap(); } phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error"); diff --git a/examples/sixlowpan.rs b/examples/sixlowpan.rs index c653d66..234b964 100644 --- a/examples/sixlowpan.rs +++ b/examples/sixlowpan.rs @@ -100,31 +100,29 @@ fn main() { } // udp:6969: respond "hello" - { - let socket = iface.get_socket::(udp_handle); - if !socket.is_open() { - socket.bind(6969).unwrap() - } + let socket = iface.get_socket::(udp_handle); + if !socket.is_open() { + socket.bind(6969).unwrap() + } - let client = match socket.recv() { - 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"; + let client = match socket.recv() { + Ok((data, endpoint)) => { debug!( - "udp:6969 send data: {:?}", - str::from_utf8(data.as_ref()).unwrap() + "udp:6969 recv data: {:?} from {}", + 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"); diff --git a/src/iface/interface.rs b/src/iface/interface.rs index ac7c43b..7860899 100644 --- a/src/iface/interface.rs +++ b/src/iface/interface.rs @@ -2942,13 +2942,11 @@ mod test { hop_limit: 0x40, }); - { - // Bind the socket to port 68 - let socket = iface.get_socket::(socket_handle); - assert_eq!(socket.bind(68), Ok(())); - assert!(!socket.can_recv()); - assert!(socket.can_send()); - } + // Bind the socket to port 68 + let socket = iface.get_socket::(socket_handle); + assert_eq!(socket.bind(68), Ok(())); + assert!(!socket.can_recv()); + assert!(socket.can_send()); udp_repr.emit( &mut packet, @@ -2968,16 +2966,14 @@ mod test { Ok(None) ); - { - // Make sure the payload to the UDP packet processed by process_udp is - // appended to the bound sockets rx_buffer - let socket = iface.get_socket::(socket_handle); - assert!(socket.can_recv()); - assert_eq!( - socket.recv(), - Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_ip.into(), 67))) - ); - } + // Make sure the payload to the UDP packet processed by process_udp is + // appended to the bound sockets rx_buffer + let socket = iface.get_socket::(socket_handle); + assert!(socket.can_recv()); + assert_eq!( + socket.recv(), + Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_ip.into(), 67))) + ); } #[test] @@ -3194,10 +3190,8 @@ mod test { frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_src_addr(remote_hw_addr); frame.set_ethertype(EthernetProtocol::Arp); - { - let mut packet = ArpPacket::new_unchecked(frame.payload_mut()); - repr.emit(&mut packet); - } + let mut packet = ArpPacket::new_unchecked(frame.payload_mut()); + repr.emit(&mut packet); 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_src_addr(remote_hw_addr); frame.set_ethertype(EthernetProtocol::Ipv6); - { - ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); - solicit.emit( - &remote_ip_addr.into(), - &local_ip_addr.solicited_node().into(), - &mut Icmpv6Packet::new_unchecked(&mut frame.payload_mut()[ip_repr.buffer_len()..]), - &ChecksumCapabilities::default(), - ); - } + ip_repr.emit(frame.payload_mut(), &ChecksumCapabilities::default()); + solicit.emit( + &remote_ip_addr.into(), + &local_ip_addr.solicited_node().into(), + &mut Icmpv6Packet::new_unchecked(&mut frame.payload_mut()[ip_repr.buffer_len()..]), + &ChecksumCapabilities::default(), + ); let icmpv6_expected = Icmpv6Repr::Ndisc(NdiscRepr::NeighborAdvert { flags: NdiscNeighborFlags::SOLICITED, @@ -3326,10 +3318,8 @@ mod test { frame.set_dst_addr(EthernetAddress::BROADCAST); frame.set_src_addr(remote_hw_addr); frame.set_ethertype(EthernetProtocol::Arp); - { - let mut packet = ArpPacket::new_unchecked(frame.payload_mut()); - repr.emit(&mut packet); - } + let mut packet = ArpPacket::new_unchecked(frame.payload_mut()); + repr.emit(&mut packet); let cx = iface.context(Instant::from_secs(0)); @@ -3442,11 +3432,9 @@ mod test { let seq_no = 0x5432; let echo_data = &[0xff; 16]; - { - let socket = iface.get_socket::(socket_handle); - // Bind to the ID 0x1234 - assert_eq!(socket.bind(IcmpEndpoint::Ident(ident)), Ok(())); - } + let socket = iface.get_socket::(socket_handle); + // Bind to the ID 0x1234 + assert_eq!(socket.bind(IcmpEndpoint::Ident(ident)), Ok(())); // Ensure the ident we bound to and the ident of the packet are the same. let mut bytes = [0xff; 24]; @@ -3470,9 +3458,7 @@ mod test { // Open a socket and ensure the packet is handled due to the listening // socket. - { - assert!(!iface.get_socket::(socket_handle).can_recv()); - } + assert!(!iface.get_socket::(socket_handle).can_recv()); // Confirm we still get EchoReply from `smoltcp` even with the ICMP socket listening let echo_reply = Icmpv4Repr::EchoReply { @@ -3493,17 +3479,15 @@ mod test { Ok(Some(IpPacket::Icmpv4((ipv4_reply, echo_reply)))) ); - { - let socket = iface.get_socket::(socket_handle); - assert!(socket.can_recv()); - assert_eq!( - socket.recv(), - Ok(( - icmp_data, - IpAddress::Ipv4(Ipv4Address::new(0x7f, 0x00, 0x00, 0x02)) - )) - ); - } + let socket = iface.get_socket::(socket_handle); + assert!(socket.can_recv()); + assert_eq!( + socket.recv(), + Ok(( + icmp_data, + IpAddress::Ipv4(Ipv4Address::new(0x7f, 0x00, 0x00, 0x02)) + )) + ); } #[test] @@ -3854,13 +3838,12 @@ mod test { 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_handle = iface.add_socket(udp_socket); - { - // Bind the socket to port 68 - let socket = iface.get_socket::(udp_socket_handle); - assert_eq!(socket.bind(68), Ok(())); - assert!(!socket.can_recv()); - assert!(socket.can_send()); - } + + // Bind the socket to port 68 + let socket = iface.get_socket::(udp_socket_handle); + assert_eq!(socket.bind(68), Ok(())); + assert!(!socket.can_recv()); + assert!(socket.can_send()); let packets = 1; let raw_rx_buffer = @@ -3927,14 +3910,12 @@ mod test { Ok(None) ); - { - // Make sure the UDP socket can still receive in presence of a Raw socket that handles UDP - let socket = iface.get_socket::(udp_socket_handle); - assert!(socket.can_recv()); - assert_eq!( - socket.recv(), - Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_addr.into(), 67))) - ); - } + // Make sure the UDP socket can still receive in presence of a Raw socket that handles UDP + let socket = iface.get_socket::(udp_socket_handle); + assert!(socket.can_recv()); + assert_eq!( + socket.recv(), + Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_addr.into(), 67))) + ); } }