itsscb/smoltcp
1
0
Fork 0
mirror of https://github.com/smoltcp-rs/smoltcp.git synced 2026-03-23 15:15:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

iface: borrow the SocketSet instead of owning.

Browse Source
This commit is contained in:
Dario Nieuwenhuis
2022-05-21 02:40:15 +02:00
parent 875238e3ac
commit b71ffcb6cc
15 changed files with 208 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
examples/benchmark.rs
View File

@@ -11,7 +11,7 @@ use std::os::unix::io::AsRawFd;
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;
use smoltcp::iface::{InterfaceBuilder, NeighborCache};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, SocketSet};
use smoltcp::phy::{wait as phy_wait, Device, Medium};
use smoltcp::socket::tcp;
use smoltcp::time::{Duration, Instant};
@@ -94,7 +94,7 @@ fn main() {
let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
let ip_addrs = [IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)];
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![]).ip_addrs(ip_addrs);
let mut builder = InterfaceBuilder::new(device).ip_addrs(ip_addrs);
if medium == Medium::Ethernet {
builder = builder
.hardware_addr(ethernet_addr.into())
@@ -102,15 +102,16 @@ fn main() {
}
let mut iface = builder.finalize();
let tcp1_handle = iface.add_socket(tcp1_socket);
let tcp2_handle = iface.add_socket(tcp2_socket);
let mut sockets = SocketSet::new(vec![]);
let tcp1_handle = sockets.add(tcp1_socket);
let tcp2_handle = sockets.add(tcp2_socket);
let default_timeout = Some(Duration::from_millis(1000));
thread::spawn(move || client(mode));
let mut processed = 0;
while !CLIENT_DONE.load(Ordering::SeqCst) {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
@@ -118,7 +119,7 @@ fn main() {
}
// tcp:1234: emit data
let socket = iface.get_socket::<tcp::Socket>(tcp1_handle);
let socket = sockets.get::<tcp::Socket>(tcp1_handle);
if !socket.is_open() {
socket.listen(1234).unwrap();
}
@@ -136,7 +137,7 @@ fn main() {
}
// tcp:1235: sink data
let socket = iface.get_socket::<tcp::Socket>(tcp2_handle);
let socket = sockets.get::<tcp::Socket>(tcp2_handle);
if !socket.is_open() {
socket.listen(1235).unwrap();
}
@@ -153,7 +154,7 @@ fn main() {
}
}
match iface.poll_at(timestamp) {
match iface.poll_at(timestamp, &sockets) {
Some(poll_at) if timestamp < poll_at => {
phy_wait(fd, Some(poll_at - timestamp)).expect("wait error");
}

19
examples/client.rs
View File

@@ -5,7 +5,7 @@ use std::collections::BTreeMap;
use std::os::unix::io::AsRawFd;
use std::str::{self, FromStr};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes, SocketSet};
use smoltcp::phy::{wait as phy_wait, Device, Medium};
use smoltcp::socket::tcp;
use smoltcp::time::Instant;
@@ -42,7 +42,7 @@ fn main() {
routes.add_default_ipv4_route(default_v4_gw).unwrap();
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.routes(routes);
if medium == Medium::Ethernet {
@@ -52,22 +52,25 @@ fn main() {
}
let mut iface = builder.finalize();
let tcp_handle = iface.add_socket(tcp_socket);
let mut sockets = SocketSet::new(vec![]);
let tcp_handle = sockets.add(tcp_socket);
let (socket, cx) = iface.get_socket_and_context::<tcp::Socket>(tcp_handle);
socket.connect(cx, (address, port), 49500).unwrap();
let socket = sockets.get::<tcp::Socket>(tcp_handle);
socket
.connect(iface.context(), (address, port), 49500)
.unwrap();
let mut tcp_active = false;
loop {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
}
}
let socket = iface.get_socket::<tcp::Socket>(tcp_handle);
let socket = sockets.get::<tcp::Socket>(tcp_handle);
if socket.is_active() && !tcp_active {
debug!("connected");
} else if !socket.is_active() && tcp_active {
@@ -104,6 +107,6 @@ fn main() {
socket.close();
}
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
}
}

13
examples/dhcp_client.rs
View File

@@ -5,7 +5,7 @@ use log::*;
use std::collections::BTreeMap;
use std::os::unix::io::AsRawFd;
use smoltcp::iface::{Interface, InterfaceBuilder, NeighborCache, Routes};
use smoltcp::iface::{Interface, InterfaceBuilder, NeighborCache, Routes, SocketSet};
use smoltcp::socket::dhcpv4;
use smoltcp::time::Instant;
use smoltcp::wire::{EthernetAddress, IpCidr, Ipv4Address, Ipv4Cidr};
@@ -34,7 +34,7 @@ fn main() {
let routes = Routes::new(&mut routes_storage[..]);
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.routes(routes);
if medium == Medium::Ethernet {
@@ -52,15 +52,16 @@ fn main() {
// IMPORTANT: This should be removed in production.
dhcp_socket.set_max_lease_duration(Some(Duration::from_secs(10)));
let dhcp_handle = iface.add_socket(dhcp_socket);
let mut sockets = SocketSet::new(vec![]);
let dhcp_handle = sockets.add(dhcp_socket);
loop {
let timestamp = Instant::now();
if let Err(e) = iface.poll(timestamp) {
if let Err(e) = iface.poll(timestamp, &mut sockets) {
debug!("poll error: {}", e);
}
let event = iface.get_socket::<dhcpv4::Socket>(dhcp_handle).poll();
let event = sockets.get::<dhcpv4::Socket>(dhcp_handle).poll();
match event {
None => {}
Some(dhcpv4::Event::Configured(config)) => {
@@ -90,7 +91,7 @@ fn main() {
}
}
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
}
}

19
examples/dns.rs
View File

@@ -7,7 +7,7 @@ extern crate smoltcp;
mod utils;
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes, SocketSet};
use smoltcp::phy::Device;
use smoltcp::phy::{wait as phy_wait, Medium};
use smoltcp::socket::dns::{self, GetQueryResultError};
@@ -55,7 +55,7 @@ fn main() {
routes.add_default_ipv6_route(default_v6_gw).unwrap();
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.routes(routes);
if medium == Medium::Ethernet {
@@ -65,24 +65,25 @@ fn main() {
}
let mut iface = builder.finalize();
let dns_handle = iface.add_socket(dns_socket);
let mut sockets = SocketSet::new(vec![]);
let dns_handle = sockets.add(dns_socket);
let (socket, cx) = iface.get_socket_and_context::<dns::Socket>(dns_handle);
let query = socket.start_query(cx, name).unwrap();
let socket = sockets.get::<dns::Socket>(dns_handle);
let query = socket.start_query(iface.context(), name).unwrap();
loop {
let timestamp = Instant::now();
debug!("timestamp {:?}", timestamp);
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
}
}
match iface
.get_socket::<dns::Socket>(dns_handle)
match sockets
.get::<dns::Socket>(dns_handle)
.get_query_result(query)
{
Ok(addrs) => {
@@ -93,6 +94,6 @@ fn main() {
Err(e) => panic!("query failed: {:?}", e),
}
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
}
}

14
examples/httpclient.rs
View File

@@ -6,7 +6,7 @@ use std::os::unix::io::AsRawFd;
use std::str::{self, FromStr};
use url::Url;
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes, SocketSet};
use smoltcp::phy::{wait as phy_wait, Device, Medium};
use smoltcp::socket::tcp;
use smoltcp::time::Instant;
@@ -48,7 +48,7 @@ fn main() {
routes.add_default_ipv6_route(default_v6_gw).unwrap();
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.routes(routes);
if medium == Medium::Ethernet {
@@ -58,7 +58,8 @@ fn main() {
}
let mut iface = builder.finalize();
let tcp_handle = iface.add_socket(tcp_socket);
let mut sockets = SocketSet::new(vec![]);
let tcp_handle = sockets.add(tcp_socket);
enum State {
Connect,
@@ -69,14 +70,15 @@ fn main() {
loop {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
}
}
let (socket, cx) = iface.get_socket_and_context::<tcp::Socket>(tcp_handle);
let socket = sockets.get::<tcp::Socket>(tcp_handle);
let cx = iface.context();
state = match state {
State::Connect if !socket.is_active() => {
@@ -115,6 +117,6 @@ fn main() {
_ => state,
};
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
}
}

20
examples/loopback.rs
View File

@@ -9,7 +9,7 @@ mod utils;
use core::str;
use log::{debug, error, info};
use smoltcp::iface::{InterfaceBuilder, NeighborCache};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, SocketSet};
use smoltcp::phy::{Loopback, Medium};
use smoltcp::socket::tcp;
use smoltcp::time::{Duration, Instant};
@@ -86,8 +86,7 @@ fn main() {
let mut neighbor_cache = NeighborCache::new(&mut neighbor_cache_entries[..]);
let mut ip_addrs = [IpCidr::new(IpAddress::v4(127, 0, 0, 1), 8)];
let mut sockets: [_; 2] = Default::default();
let mut iface = InterfaceBuilder::new(device, &mut sockets[..])
let mut iface = InterfaceBuilder::new(device)
.hardware_addr(EthernetAddress::default().into())
.neighbor_cache(neighbor_cache)
.ip_addrs(ip_addrs)
@@ -113,21 +112,23 @@ fn main() {
tcp::Socket::new(tcp_rx_buffer, tcp_tx_buffer)
};
let server_handle = iface.add_socket(server_socket);
let client_handle = iface.add_socket(client_socket);
let mut sockets: [_; 2] = Default::default();
let mut sockets = SocketSet::new(&mut sockets[..]);
let server_handle = sockets.add(server_socket);
let client_handle = sockets.add(client_socket);
let mut did_listen = false;
let mut did_connect = false;
let mut done = false;
while !done && clock.elapsed() < Instant::from_millis(10_000) {
match iface.poll(clock.elapsed()) {
match iface.poll(clock.elapsed(), &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
}
}
let mut socket = iface.get_socket::<tcp::Socket>(server_handle);
let mut socket = sockets.get::<tcp::Socket>(server_handle);
if !socket.is_active() && !socket.is_listening() {
if !did_listen {
debug!("listening");
@@ -145,7 +146,8 @@ fn main() {
done = true;
}
let (mut socket, cx) = iface.get_socket_and_context::<tcp::Socket>(client_handle);
let mut socket = sockets.get::<tcp::Socket>(client_handle);
let cx = iface.context();
if !socket.is_open() {
if !did_connect {
debug!("connecting");
@@ -162,7 +164,7 @@ fn main() {
socket.close();
}
match iface.poll_delay(clock.elapsed()) {
match iface.poll_delay(clock.elapsed(), &sockets) {
Some(Duration::ZERO) => debug!("resuming"),
Some(delay) => {
debug!("sleeping for {} ms", delay);

18
examples/multicast.rs
View File

@@ -4,7 +4,7 @@ use log::debug;
use std::collections::BTreeMap;
use std::os::unix::io::AsRawFd;
use smoltcp::iface::{InterfaceBuilder, NeighborCache};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, SocketSet};
use smoltcp::phy::wait as phy_wait;
use smoltcp::socket::{raw, udp};
use smoltcp::time::Instant;
@@ -34,7 +34,7 @@ fn main() {
let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x02]);
let ip_addr = IpCidr::new(IpAddress::from(local_addr), 24);
let mut ipv4_multicast_storage = [None; 1];
let mut iface = InterfaceBuilder::new(device, vec![])
let mut iface = InterfaceBuilder::new(device)
.hardware_addr(ethernet_addr.into())
.neighbor_cache(neighbor_cache)
.ip_addrs([ip_addr])
@@ -47,6 +47,8 @@ fn main() {
.join_multicast_group(Ipv4Address::from_bytes(&MDNS_GROUP), now)
.unwrap();
let mut sockets = SocketSet::new(vec![]);
// Must fit at least one IGMP packet
let raw_rx_buffer = raw::PacketBuffer::new(vec![raw::PacketMetadata::EMPTY; 2], vec![0; 512]);
// Will not send IGMP
@@ -57,25 +59,25 @@ fn main() {
raw_rx_buffer,
raw_tx_buffer,
);
let raw_handle = iface.add_socket(raw_socket);
let raw_handle = sockets.add(raw_socket);
// Must fit mDNS payload of at least one packet
let udp_rx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY; 4], vec![0; 1024]);
// Will not send mDNS
let udp_tx_buffer = udp::PacketBuffer::new(vec![udp::PacketMetadata::EMPTY], vec![0; 0]);
let udp_socket = udp::Socket::new(udp_rx_buffer, udp_tx_buffer);
let udp_handle = iface.add_socket(udp_socket);
let udp_handle = sockets.add(udp_socket);
loop {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
}
}
let socket = iface.get_socket::<raw::Socket>(raw_handle);
let socket = sockets.get::<raw::Socket>(raw_handle);
if socket.can_recv() {
// For display purposes only - normally we wouldn't process incoming IGMP packets
@@ -92,7 +94,7 @@ fn main() {
}
}
let socket = iface.get_socket::<udp::Socket>(udp_handle);
let socket = sockets.get::<udp::Socket>(udp_handle);
if !socket.is_open() {
socket.bind(MDNS_PORT).unwrap()
}
@@ -106,6 +108,6 @@ fn main() {
.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, &sockets)).expect("wait error");
}
}

12
examples/ping.rs
View File

@@ -2,6 +2,7 @@ mod utils;
use byteorder::{ByteOrder, NetworkEndian};
use log::debug;
use smoltcp::iface::SocketSet;
use std::cmp;
use std::collections::BTreeMap;
use std::collections::HashMap;
@@ -127,7 +128,7 @@ fn main() {
routes.add_default_ipv6_route(default_v6_gw).unwrap();
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.routes(routes);
if medium == Medium::Ethernet {
@@ -137,7 +138,8 @@ fn main() {
}
let mut iface = builder.finalize();
let icmp_handle = iface.add_socket(icmp_socket);
let mut sockets = SocketSet::new(vec![]);
let icmp_handle = sockets.add(icmp_socket);
let mut send_at = Instant::from_millis(0);
let mut seq_no = 0;
@@ -148,7 +150,7 @@ fn main() {
loop {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
@@ -156,7 +158,7 @@ fn main() {
}
let timestamp = Instant::now();
let socket = iface.get_socket::<icmp::Socket>(icmp_handle);
let socket = sockets.get::<icmp::Socket>(icmp_handle);
if !socket.is_open() {
socket.bind(icmp::Endpoint::Ident(ident)).unwrap();
send_at = timestamp;
@@ -255,7 +257,7 @@ fn main() {
}
let timestamp = Instant::now();
match iface.poll_at(timestamp) {
match iface.poll_at(timestamp, &sockets) {
Some(poll_at) if timestamp < poll_at => {
let resume_at = cmp::min(poll_at, send_at);
phy_wait(fd, Some(resume_at - timestamp)).expect("wait error");

29
examples/server.rs
View File

@@ -6,7 +6,7 @@ use std::fmt::Write;
use std::os::unix::io::AsRawFd;
use std::str;
use smoltcp::iface::{InterfaceBuilder, NeighborCache};
use smoltcp::iface::{InterfaceBuilder, NeighborCache, SocketSet};
use smoltcp::phy::{wait as phy_wait, Device, Medium};
use smoltcp::socket::{tcp, udp};
use smoltcp::time::{Duration, Instant};
@@ -54,7 +54,7 @@ fn main() {
];
let medium = device.capabilities().medium;
let mut builder = InterfaceBuilder::new(device, vec![]).ip_addrs(ip_addrs);
let mut builder = InterfaceBuilder::new(device).ip_addrs(ip_addrs);
if medium == Medium::Ethernet {
builder = builder
.hardware_addr(ethernet_addr.into())
@@ -62,16 +62,17 @@ fn main() {
}
let mut iface = builder.finalize();
let udp_handle = iface.add_socket(udp_socket);
let tcp1_handle = iface.add_socket(tcp1_socket);
let tcp2_handle = iface.add_socket(tcp2_socket);
let tcp3_handle = iface.add_socket(tcp3_socket);
let tcp4_handle = iface.add_socket(tcp4_socket);
let mut sockets = SocketSet::new(vec![]);
let udp_handle = sockets.add(udp_socket);
let tcp1_handle = sockets.add(tcp1_socket);
let tcp2_handle = sockets.add(tcp2_socket);
let tcp3_handle = sockets.add(tcp3_socket);
let tcp4_handle = sockets.add(tcp4_socket);
let mut tcp_6970_active = false;
loop {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
@@ -79,7 +80,7 @@ fn main() {
}
// udp:6969: respond "hello"
let socket = iface.get_socket::<udp::Socket>(udp_handle);
let socket = sockets.get::<udp::Socket>(udp_handle);
if !socket.is_open() {
socket.bind(6969).unwrap()
}
@@ -105,7 +106,7 @@ fn main() {
}
// tcp:6969: respond "hello"
let socket = iface.get_socket::<tcp::Socket>(tcp1_handle);
let socket = sockets.get::<tcp::Socket>(tcp1_handle);
if !socket.is_open() {
socket.listen(6969).unwrap();
}
@@ -118,7 +119,7 @@ fn main() {
}
// tcp:6970: echo with reverse
let socket = iface.get_socket::<tcp::Socket>(tcp2_handle);
let socket = sockets.get::<tcp::Socket>(tcp2_handle);
if !socket.is_open() {
socket.listen(6970).unwrap()
}
@@ -160,7 +161,7 @@ fn main() {
}
// tcp:6971: sinkhole
let socket = iface.get_socket::<tcp::Socket>(tcp3_handle);
let socket = sockets.get::<tcp::Socket>(tcp3_handle);
if !socket.is_open() {
socket.listen(6971).unwrap();
socket.set_keep_alive(Some(Duration::from_millis(1000)));
@@ -181,7 +182,7 @@ fn main() {
}
// tcp:6972: fountain
let socket = iface.get_socket::<tcp::Socket>(tcp4_handle);
let socket = sockets.get::<tcp::Socket>(tcp4_handle);
if !socket.is_open() {
socket.listen(6972).unwrap()
}
@@ -200,6 +201,6 @@ fn main() {
.unwrap();
}
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
}
}

19
examples/sixlowpan.rs
View File

@@ -47,7 +47,7 @@ use std::collections::BTreeMap;
use std::os::unix::io::AsRawFd;
use std::str;
use smoltcp::iface::{FragmentsCache, InterfaceBuilder, NeighborCache};
use smoltcp::iface::{FragmentsCache, InterfaceBuilder, NeighborCache, SocketSet};
use smoltcp::phy::{wait as phy_wait, Medium, RawSocket};
use smoltcp::socket::tcp;
use smoltcp::socket::udp;
@@ -89,7 +89,7 @@ fn main() {
let mut out_packet_buffer = [0u8; 1280];
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.pan_id(Ieee802154Pan(0xbeef));
builder = builder
@@ -99,10 +99,11 @@ fn main() {
.sixlowpan_out_packet_cache(&mut out_packet_buffer[..]);
let mut iface = builder.finalize();
let udp_handle = iface.add_socket(udp_socket);
let tcp_handle = iface.add_socket(tcp_socket);
let mut sockets = SocketSet::new(vec![]);
let udp_handle = sockets.add(udp_socket);
let tcp_handle = sockets.add(tcp_socket);
let socket = iface.get_socket::<tcp::Socket>(tcp_handle);
let socket = sockets.get::<tcp::Socket>(tcp_handle);
socket.listen(50000).unwrap();
let mut tcp_active = false;
@@ -112,7 +113,7 @@ fn main() {
let mut poll = true;
while poll {
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(r) => poll = r,
Err(e) => {
debug!("poll error: {}", e);
@@ -122,7 +123,7 @@ fn main() {
}
// udp:6969: respond "hello"
let socket = iface.get_socket::<udp::Socket>(udp_handle);
let socket = sockets.get::<udp::Socket>(udp_handle);
if !socket.is_open() {
socket.bind(6969).unwrap()
}
@@ -148,7 +149,7 @@ fn main() {
socket.send_slice(&buffer[..len], endpoint).unwrap();
}
let socket = iface.get_socket::<tcp::Socket>(tcp_handle);
let socket = sockets.get::<tcp::Socket>(tcp_handle);
if socket.is_active() && !tcp_active {
debug!("connected");
} else if !socket.is_active() && tcp_active {
@@ -182,6 +183,6 @@ fn main() {
socket.close();
}
phy_wait(fd, iface.poll_delay(timestamp)).expect("wait error");
phy_wait(fd, iface.poll_delay(timestamp, &sockets)).expect("wait error");
}
}

17
examples/sixlowpan_benchmark.rs
View File

@@ -48,7 +48,7 @@ use std::collections::BTreeMap;
use std::os::unix::io::AsRawFd;
use std::str;
use smoltcp::iface::{FragmentsCache, InterfaceBuilder, NeighborCache};
use smoltcp::iface::{FragmentsCache, InterfaceBuilder, NeighborCache, SocketSet};
use smoltcp::phy::{wait as phy_wait, Medium, RawSocket};
use smoltcp::socket::tcp;
use smoltcp::wire::{Ieee802154Pan, IpAddress, IpCidr};
@@ -167,7 +167,7 @@ fn main() {
let cache = FragmentsCache::new(vec![], BTreeMap::new());
let mut builder = InterfaceBuilder::new(device, vec![])
let mut builder = InterfaceBuilder::new(device)
.ip_addrs(ip_addrs)
.pan_id(Ieee802154Pan(0xbeef));
builder = builder
@@ -177,8 +177,9 @@ fn main() {
.sixlowpan_out_packet_cache(vec![]);
let mut iface = builder.finalize();
let tcp1_handle = iface.add_socket(tcp1_socket);
let tcp2_handle = iface.add_socket(tcp2_socket);
let mut sockets = SocketSet::new(vec![]);
let tcp1_handle = sockets.add(tcp1_socket);
let tcp2_handle = sockets.add(tcp2_socket);
let default_timeout = Some(Duration::from_millis(1000));
@@ -187,7 +188,7 @@ fn main() {
while !CLIENT_DONE.load(Ordering::SeqCst) {
let timestamp = Instant::now();
match iface.poll(timestamp) {
match iface.poll(timestamp, &mut sockets) {
Ok(_) => {}
Err(e) => {
debug!("poll error: {}", e);
@@ -195,7 +196,7 @@ fn main() {
}
// tcp:1234: emit data
let socket = iface.get_socket::<tcp::Socket>(tcp1_handle);
let socket = sockets.get::<tcp::Socket>(tcp1_handle);
if !socket.is_open() {
socket.listen(1234).unwrap();
}
@@ -211,7 +212,7 @@ fn main() {
}
// tcp:1235: sink data
let socket = iface.get_socket::<tcp::Socket>(tcp2_handle);
let socket = sockets.get::<tcp::Socket>(tcp2_handle);
if !socket.is_open() {
socket.listen(1235).unwrap();
}
@@ -226,7 +227,7 @@ fn main() {
processed += length;
}
match iface.poll_at(timestamp) {
match iface.poll_at(timestamp, &sockets) {
Some(poll_at) if timestamp < poll_at => {
phy_wait(fd, Some(poll_at - timestamp)).expect("wait error");
}