Skip to content

Commit f8b0e56

Browse files
DirbaioDirbaio
authored
Merge pull request #506 from qiujiangkun/fix_clippy
Various clippy fix
2 parents 94f72c9 + 7dda148 commit f8b0e56

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

67 files changed

+9872
-6367
lines changed

‎benches/bench.rs

Lines changed: 43 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,24 @@
11
#![feature(test)]
22

33
mod wire {
4-
use test;
5-
#[cfg(feature = "proto-ipv6")]
6-
use smoltcp::wire::{Ipv6Address, Ipv6Repr, Ipv6Packet};
7-
#[cfg(feature = "proto-ipv4")]
8-
use smoltcp::wire::{Ipv4Address, Ipv4Repr, Ipv4Packet};
9-
use smoltcp::phy::{ChecksumCapabilities};
4+
use smoltcp::phy::ChecksumCapabilities;
105
use smoltcp::wire::{IpAddress, IpProtocol};
11-
use smoltcp::wire::{TcpRepr, TcpPacket, TcpSeqNumber, TcpControl};
12-
use smoltcp::wire::{UdpRepr, UdpPacket};
6+
#[cfg(feature = "proto-ipv4")]
7+
use smoltcp::wire::{Ipv4Address, Ipv4Packet, Ipv4Repr};
8+
#[cfg(feature = "proto-ipv6")]
9+
use smoltcp::wire::{Ipv6Address, Ipv6Packet, Ipv6Repr};
10+
use smoltcp::wire::{TcpControl, TcpPacket, TcpRepr, TcpSeqNumber};
11+
use smoltcp::wire::{UdpPacket, UdpRepr};
12+
use test;
1313

1414
#[cfg(feature = "proto-ipv6")]
15-
const SRC_ADDR: IpAddress = IpAddress::Ipv6(Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0,
16-
0, 0, 0, 0, 0, 0, 0, 1]));
15+
const SRC_ADDR: IpAddress = IpAddress::Ipv6(Ipv6Address([
16+
0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
17+
]));
1718
#[cfg(feature = "proto-ipv6")]
18-
const DST_ADDR: IpAddress = IpAddress::Ipv6(Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0,
19-
0, 0, 0, 0, 0, 0, 0, 2]));
19+
const DST_ADDR: IpAddress = IpAddress::Ipv6(Ipv6Address([
20+
0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
21+
]));
2022

2123
#[cfg(all(not(feature = "proto-ipv6"), feature = "proto-ipv4"))]
2224
const SRC_ADDR: IpAddress = IpAddress::Ipv4(Ipv4Address([192, 168, 1, 1]));
@@ -26,54 +28,62 @@ mod wire {
2628
#[bench]
2729
#[cfg(any(feature = "proto-ipv6", feature = "proto-ipv4"))]
2830
fn bench_emit_tcp(b: &mut test::Bencher) {
29-
static PAYLOAD_BYTES: [u8; 400] =
30-
[0x2a; 400];
31+
static PAYLOAD_BYTES: [u8; 400] = [0x2a; 400];
3132
let repr = TcpRepr {
32-
src_port: 48896,
33-
dst_port: 80,
34-
seq_number: TcpSeqNumber(0x01234567),
35-
ack_number: None,
36-
window_len: 0x0123,
37-
control: TcpControl::Syn,
33+
src_port: 48896,
34+
dst_port: 80,
35+
seq_number: TcpSeqNumber(0x01234567),
36+
ack_number: None,
37+
window_len: 0x0123,
38+
control: TcpControl::Syn,
3839
max_seg_size: None,
3940
window_scale: None,
40-
payload: &PAYLOAD_BYTES
41+
payload: &PAYLOAD_BYTES,
4142
};
4243
let mut bytes = vec![0xa5; repr.buffer_len()];
4344

4445
b.iter(|| {
4546
let mut packet = TcpPacket::new(&mut bytes);
46-
repr.emit(&mut packet, &SRC_ADDR, &DST_ADDR, &ChecksumCapabilities::default());
47+
repr.emit(
48+
&mut packet,
49+
&SRC_ADDR,
50+
&DST_ADDR,
51+
&ChecksumCapabilities::default(),
52+
);
4753
});
4854
}
4955

5056
#[bench]
5157
#[cfg(any(feature = "proto-ipv6", feature = "proto-ipv4"))]
5258
fn bench_emit_udp(b: &mut test::Bencher) {
53-
static PAYLOAD_BYTES: [u8; 400] =
54-
[0x2a; 400];
59+
static PAYLOAD_BYTES: [u8; 400] = [0x2a; 400];
5560
let repr = UdpRepr {
5661
src_port: 48896,
5762
dst_port: 80,
58-
payload: &PAYLOAD_BYTES
63+
payload: &PAYLOAD_BYTES,
5964
};
6065
let mut bytes = vec![0xa5; repr.buffer_len()];
6166

6267
b.iter(|| {
6368
let mut packet = UdpPacket::new(&mut bytes);
64-
repr.emit(&mut packet, &SRC_ADDR, &DST_ADDR, &ChecksumCapabilities::default());
69+
repr.emit(
70+
&mut packet,
71+
&SRC_ADDR,
72+
&DST_ADDR,
73+
&ChecksumCapabilities::default(),
74+
);
6575
});
6676
}
6777

6878
#[bench]
6979
#[cfg(feature = "proto-ipv4")]
7080
fn bench_emit_ipv4(b: &mut test::Bencher) {
7181
let repr = Ipv4Repr {
72-
src_addr: Ipv4Address([192, 168, 1, 1]),
73-
dst_addr: Ipv4Address([192, 168, 1, 2]),
74-
protocol: IpProtocol::Tcp,
82+
src_addr: Ipv4Address([192, 168, 1, 1]),
83+
dst_addr: Ipv4Address([192, 168, 1, 2]),
84+
protocol: IpProtocol::Tcp,
7585
payload_len: 100,
76-
hop_limit: 64
86+
hop_limit: 64,
7787
};
7888
let mut bytes = vec![0xa5; repr.buffer_len()];
7989

@@ -87,13 +97,11 @@ mod wire {
8797
#[cfg(feature = "proto-ipv6")]
8898
fn bench_emit_ipv6(b: &mut test::Bencher) {
8999
let repr = Ipv6Repr {
90-
src_addr: Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0,
91-
0, 0, 0, 0, 0, 0, 0, 1]),
92-
dst_addr: Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0,
93-
0, 0, 0, 0, 0, 0, 0, 2]),
100+
src_addr: Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),
101+
dst_addr: Ipv6Address([0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]),
94102
next_header: IpProtocol::Tcp,
95103
payload_len: 100,
96-
hop_limit: 64
104+
hop_limit: 64,
97105
};
98106
let mut bytes = vec![0xa5; repr.buffer_len()];
99107

‎examples/benchmark.rs

Lines changed: 33 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -2,28 +2,34 @@
22

33
mod utils;
44

5+
use log::debug;
56
use std::cmp;
67
use std::collections::BTreeMap;
7-
use std::sync::atomic::{Ordering, AtomicBool};
8-
use std::thread;
98
use std::io::{Read, Write};
109
use std::net::TcpStream;
1110
use std::os::unix::io::AsRawFd;
12-
use log::debug;
11+
use std::sync::atomic::{AtomicBool, Ordering};
12+
use std::thread;
1313

14-
use smoltcp::phy::{Device, Medium, wait as phy_wait};
15-
use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
16-
use smoltcp::iface::{NeighborCache, InterfaceBuilder};
14+
use smoltcp::iface::{InterfaceBuilder, NeighborCache};
15+
use smoltcp::phy::{wait as phy_wait, Device, Medium};
1716
use smoltcp::socket::SocketSet;
1817
use smoltcp::socket::{TcpSocket, TcpSocketBuffer};
1918
use smoltcp::time::{Duration, Instant};
19+
use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
2020

2121
const AMOUNT: usize = 1_000_000_000;
2222

23-
enum Client { Reader, Writer }
23+
enum Client {
24+
Reader,
25+
Writer,
26+
}
2427

2528
fn client(kind: Client) {
26-
let port = match kind { Client::Reader => 1234, Client::Writer => 1235 };
29+
let port = match kind {
30+
Client::Reader => 1234,
31+
Client::Writer => 1235,
32+
};
2733
let mut stream = TcpStream::connect(("192.168.69.1", port)).unwrap();
2834
let mut buffer = vec![0; 1_000_000];
2935

@@ -42,7 +48,7 @@ fn client(kind: Client) {
4248
// print!("(P:{})", result);
4349
processed += result
4450
}
45-
Err(err) => panic!("cannot process: {}", err)
51+
Err(err) => panic!("cannot process: {}", err),
4652
}
4753
}
4854

@@ -69,11 +75,11 @@ fn main() {
6975
let mut matches = utils::parse_options(&opts, free);
7076
let device = utils::parse_tuntap_options(&mut matches);
7177
let fd = device.as_raw_fd();
72-
let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/false);
78+
let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
7379
let mode = match matches.free[0].as_ref() {
7480
"reader" => Client::Reader,
7581
"writer" => Client::Writer,
76-
_ => panic!("invalid mode")
82+
_ => panic!("invalid mode"),
7783
};
7884

7985
thread::spawn(move || client(mode));
@@ -91,8 +97,7 @@ fn main() {
9197
let ethernet_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
9298
let ip_addrs = [IpCidr::new(IpAddress::v4(192, 168, 69, 1), 24)];
9399
let medium = device.capabilities().medium;
94-
let mut builder = InterfaceBuilder::new(device)
95-
.ip_addrs(ip_addrs);
100+
let mut builder = InterfaceBuilder::new(device).ip_addrs(ip_addrs);
96101
if medium == Medium::Ethernet {
97102
builder = builder
98103
.ethernet_addr(ethernet_addr)
@@ -109,13 +114,12 @@ fn main() {
109114
while !CLIENT_DONE.load(Ordering::SeqCst) {
110115
let timestamp = Instant::now();
111116
match iface.poll(&mut sockets, timestamp) {
112-
Ok(_) => {},
117+
Ok(_) => {}
113118
Err(e) => {
114-
debug!("poll error: {}",e);
119+
debug!("poll error: {}", e);
115120
}
116121
}
117122

118-
119123
// tcp:1234: emit data
120124
{
121125
let mut socket = sockets.get::<TcpSocket>(tcp1_handle);
@@ -125,10 +129,12 @@ fn main() {
125129

126130
if socket.can_send() {
127131
if processed < AMOUNT {
128-
let length = socket.send(|buffer| {
129-
let length = cmp::min(buffer.len(), AMOUNT - processed);
130-
(length, length)
131-
}).unwrap();
132+
let length = socket
133+
.send(|buffer| {
134+
let length = cmp::min(buffer.len(), AMOUNT - processed);
135+
(length, length)
136+
})
137+
.unwrap();
132138
processed += length;
133139
}
134140
}
@@ -143,10 +149,12 @@ fn main() {
143149

144150
if socket.can_recv() {
145151
if processed < AMOUNT {
146-
let length = socket.recv(|buffer| {
147-
let length = cmp::min(buffer.len(), AMOUNT - processed);
148-
(length, length)
149-
}).unwrap();
152+
let length = socket
153+
.recv(|buffer| {
154+
let length = cmp::min(buffer.len(), AMOUNT - processed);
155+
(length, length)
156+
})
157+
.unwrap();
150158
processed += length;
151159
}
152160
}
@@ -155,7 +163,7 @@ fn main() {
155163
match iface.poll_at(&sockets, timestamp) {
156164
Some(poll_at) if timestamp < poll_at => {
157165
phy_wait(fd, Some(poll_at - timestamp)).expect("wait error");
158-
},
166+
}
159167
Some(_) => (),
160168
None => {
161169
phy_wait(fd, default_timeout).expect("wait error");

‎examples/client.rs

Lines changed: 30 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
11
mod utils;
22

3-
use std::str::{self, FromStr};
3+
use log::debug;
44
use std::collections::BTreeMap;
55
use std::os::unix::io::AsRawFd;
6-
use log::debug;
6+
use std::str::{self, FromStr};
77

8-
use smoltcp::phy::{Device, Medium, wait as phy_wait};
9-
use smoltcp::wire::{EthernetAddress, Ipv4Address, IpAddress, IpCidr};
10-
use smoltcp::iface::{NeighborCache, InterfaceBuilder, Routes};
8+
use smoltcp::iface::{InterfaceBuilder, NeighborCache, Routes};
9+
use smoltcp::phy::{wait as phy_wait, Device, Medium};
1110
use smoltcp::socket::{SocketSet, TcpSocket, TcpSocketBuffer};
1211
use smoltcp::time::Instant;
12+
use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr, Ipv4Address};
1313

1414
fn main() {
1515
utils::setup_logging("");
@@ -24,7 +24,7 @@ fn main() {
2424
let device = utils::parse_tuntap_options(&mut matches);
2525

2626
let fd = device.as_raw_fd();
27-
let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/false);
27+
let device = utils::parse_middleware_options(&mut matches, device, /*loopback=*/ false);
2828
let address = IpAddress::from_str(&matches.free[0]).expect("invalid address format");
2929
let port = u16::from_str(&matches.free[1]).expect("invalid port format");
3030

@@ -40,11 +40,11 @@ fn main() {
4040
let mut routes_storage = [None; 1];
4141
let mut routes = Routes::new(&mut routes_storage[..]);
4242
routes.add_default_ipv4_route(default_v4_gw).unwrap();
43-
43+
4444
let medium = device.capabilities().medium;
4545
let mut builder = InterfaceBuilder::new(device)
46-
.ip_addrs(ip_addrs)
47-
.routes(routes);
46+
.ip_addrs(ip_addrs)
47+
.routes(routes);
4848
if medium == Medium::Ethernet {
4949
builder = builder
5050
.ethernet_addr(ethernet_addr)
@@ -64,7 +64,7 @@ fn main() {
6464
loop {
6565
let timestamp = Instant::now();
6666
match iface.poll(&mut sockets, timestamp) {
67-
Ok(_) => {},
67+
Ok(_) => {}
6868
Err(e) => {
6969
debug!("poll error: {}", e);
7070
}
@@ -76,25 +76,31 @@ fn main() {
7676
debug!("connected");
7777
} else if !socket.is_active() && tcp_active {
7878
debug!("disconnected");
79-
break
79+
break;
8080
}
8181
tcp_active = socket.is_active();
8282

8383
if socket.may_recv() {
84-
let data = socket.recv(|data| {
85-
let mut data = data.to_owned();
86-
if !data.is_empty() {
87-
debug!("recv data: {:?}",
88-
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)"));
89-
data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
90-
data.reverse();
91-
data.extend(b"\n");
92-
}
93-
(data.len(), data)
94-
}).unwrap();
84+
let data = socket
85+
.recv(|data| {
86+
let mut data = data.to_owned();
87+
if !data.is_empty() {
88+
debug!(
89+
"recv data: {:?}",
90+
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
91+
);
92+
data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
93+
data.reverse();
94+
data.extend(b"\n");
95+
}
96+
(data.len(), data)
97+
})
98+
.unwrap();
9599
if socket.can_send() && !data.is_empty() {
96-
debug!("send data: {:?}",
97-
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)"));
100+
debug!(
101+
"send data: {:?}",
102+
str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)")
103+
);
98104
socket.send_slice(&data[..]).unwrap();
99105
}
100106
} else if socket.may_send() {

0 commit comments

Comments
 (0)