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

examples/benchmark.rs

@@ -119,42 +119,38 @@ fn main() {
         }
 
         // tcp:1234: emit data
-        {
-            let socket = iface.get_socket::<TcpSocket>(tcp1_handle);
-            if !socket.is_open() {
-                socket.listen(1234).unwrap();
-            }
+        let socket = iface.get_socket::<TcpSocket>(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::<TcpSocket>(tcp2_handle);
-            if !socket.is_open() {
-                socket.listen(1235).unwrap();
-            }
+        let socket = iface.get_socket::<TcpSocket>(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;
             }
         }
 

examples/client.rs

@@ -54,10 +54,8 @@ fn main() {
 
     let tcp_handle = iface.add_socket(tcp_socket);
 
-    {
-        let socket = iface.get_socket::<TcpSocket>(tcp_handle);
-        socket.connect((address, port), 49500).unwrap();
-    }
+    let socket = iface.get_socket::<TcpSocket>(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::<TcpSocket>(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::<Vec<_>>().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();
+        let socket = iface.get_socket::<TcpSocket>(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::<Vec<_>>().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");

examples/httpclient.rs

@@ -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::Connect if !socket.is_active() => {
-                    debug!("connecting");
-                    let local_port = 49152 + rand::random::<u16>() % 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::<u16>() % 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");
     }

examples/loopback.rs

@@ -135,46 +135,42 @@ fn main() {
             }
         }
 
-        {
-            let mut socket = iface.get_socket::<TcpSocket>(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::<TcpSocket>(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;
-            }
+        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::<TcpSocket>(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;
-                }
+        let mut socket = iface.get_socket::<TcpSocket>(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();
-            }
+        if socket.can_send() {
+            debug!("sending");
+            socket.send_slice(b"0123456789abcdef").unwrap();
+            socket.close();
         }
 
         match iface.poll_delay(clock.elapsed()) {

examples/multicast.rs

@@ -77,35 +77,32 @@ fn main() {
             }
         }
 
-        {
-            let socket = iface.get_socket::<RawSocket>(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));
-            }
+        let socket = iface.get_socket::<RawSocket>(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));
         }
-        {
-            let socket = iface.get_socket::<UdpSocket>(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::<UdpSocket>(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");

examples/ping.rs

@@ -155,108 +155,105 @@ fn main() {
             }
         }
 
-        {
-            let timestamp = Instant::now();
-            let socket = iface.get_socket::<IcmpSocket>(icmp_handle);
-            if !socket.is_open() {
-                socket.bind(IcmpEndpoint::Ident(ident)).unwrap();
-                send_at = timestamp;
-            }
+        let timestamp = Instant::now();
+        let socket = iface.get_socket::<IcmpSocket>(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;
+                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!(),
             }
 
-            if socket.can_recv() {
-                let (payload, _) = socket.recv().unwrap();
+            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!(),
+            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
+                    );
                 }
-            }
-
-            waiting_queue.retain(|seq, from| {
-                if timestamp - *from < timeout {
-                    true
-                } else {
-                    println!("From {} icmp_seq={} timeout", remote_addr, seq);
-                    false
+                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!(),
+            }
+        }
 
-            if seq_no == count as u16 && waiting_queue.is_empty() {
-                break;
+        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();

examples/server.rs

@@ -80,135 +80,125 @@ fn main() {
         }
 
         // udp:6969: respond "hello"
-        {
-            let socket = iface.get_socket::<UdpSocket>(udp_handle);
-            if !socket.is_open() {
-                socket.bind(6969).unwrap()
-            }
+        let socket = iface.get_socket::<UdpSocket>(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::<TcpSocket>(tcp1_handle);
-            if !socket.is_open() {
-                socket.listen(6969).unwrap();
-            }
+        let socket = iface.get_socket::<TcpSocket>(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::<TcpSocket>(tcp2_handle);
-            if !socket.is_open() {
-                socket.listen(6970).unwrap()
-            }
+        let socket = iface.get_socket::<TcpSocket>(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.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::<Vec<_>>().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.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::<Vec<_>>().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::<TcpSocket>(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::<TcpSocket>(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::<TcpSocket>(tcp4_handle);
-            if !socket.is_open() {
-                socket.listen(6972).unwrap()
-            }
+        let socket = iface.get_socket::<TcpSocket>(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");

examples/sixlowpan.rs

@@ -100,31 +100,29 @@ fn main() {
         }
 
         // udp:6969: respond "hello"
-        {
-            let socket = iface.get_socket::<UdpSocket>(udp_handle);
-            if !socket.is_open() {
-                socket.bind(6969).unwrap()
-            }
+        let socket = iface.get_socket::<UdpSocket>(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");

src/iface/interface.rs

@@ -2942,13 +2942,11 @@ mod test {
             hop_limit: 0x40,
         });
 
-        {
-            // Bind the socket to port 68
-            let socket = iface.get_socket::<UdpSocket>(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::<UdpSocket>(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::<UdpSocket>(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::<UdpSocket>(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::<IcmpSocket>(socket_handle);
-            // Bind to the ID 0x1234
-            assert_eq!(socket.bind(IcmpEndpoint::Ident(ident)), Ok(()));
-        }
+        let socket = iface.get_socket::<IcmpSocket>(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::<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
         let echo_reply = Icmpv4Repr::EchoReply {
@@ -3493,17 +3479,15 @@ mod test {
             Ok(Some(IpPacket::Icmpv4((ipv4_reply, echo_reply))))
         );
 
-        {
-            let socket = iface.get_socket::<IcmpSocket>(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::<IcmpSocket>(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::<UdpSocket>(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::<UdpSocket>(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::<UdpSocket>(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::<UdpSocket>(udp_socket_handle);
+        assert!(socket.can_recv());
+        assert_eq!(
+            socket.recv(),
+            Ok((&UDP_PAYLOAD[..], IpEndpoint::new(src_addr.into(), 67)))
+        );
     }
 }