leyoda/rqbit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Cargo clippy: fix the majority of errors

Browse source
This commit is contained in:
Igor Katson 2022-12-08 20:20:23 +00:00
parent 871d927596
commit 6968a4e449
No known key found for this signature in database
GPG key ID: B4EC22B66D61A3F5
19 changed files with 69 additions and 91 deletions
Download patch file Download diff file Expand all files Collapse all files

12
crates/bencode/src/serde_bencode_de.rs
View file

@ -113,12 +113,12 @@ impl std::fmt::Display for ErrorContext {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut it = self.field_stack.iter(); let mut it = self.field_stack.iter();
if let Some(field) = it.next() { if let Some(field) = it.next() {
write!(f, "\"{}\"", field)?; write!(f, "\"{field}\"")?;
} else { } else {
return Ok(()); return Ok(());
} }
for field in self.field_stack.iter().skip(1) { for field in self.field_stack.iter().skip(1) {
write!(f, " -> \"{}\"", field)?; write!(f, " -> \"{field}\"")?;
} }
f.write_str(": ") f.write_str(": ")
} }
@ -134,7 +134,7 @@ impl std::fmt::Display for ErrorKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { match self {
ErrorKind::Other(err) => err.fmt(f), ErrorKind::Other(err) => err.fmt(f),
ErrorKind::NotSupported(s) => write!(f, "{} is not supported by bencode", s), ErrorKind::NotSupported(s) => write!(f, "{s} is not supported by bencode"),
} }
} }
} }
@ -183,7 +183,7 @@ impl Error {
} }
fn set_context(mut self, de: &BencodeDeserializer<'_>) -> Self { fn set_context(mut self, de: &BencodeDeserializer<'_>) -> Self {
self.context = ErrorContext { self.context = ErrorContext {
field_stack: de.field_context.iter().map(|s| format!("{}", s)).collect(), field_stack: de.field_context.iter().map(|s| format!("{s}")).collect(),
}; };
self self
} }
@ -427,7 +427,7 @@ impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut BencodeDeserializer<'de>
} }
self.buf = self.buf.get(1..).unwrap_or_default(); self.buf = self.buf.get(1..).unwrap_or_default();
visitor visitor
.visit_seq(SeqAccess { de: &mut self }) .visit_seq(SeqAccess { de: self })
.map_err(|e: Self::Error| e.set_context(self)) .map_err(|e: Self::Error| e.set_context(self))
} }
@ -459,7 +459,7 @@ impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut BencodeDeserializer<'de>
} }
self.buf = self.buf.get(1..).unwrap_or_default(); self.buf = self.buf.get(1..).unwrap_or_default();
visitor visitor
.visit_map(MapAccess { de: &mut self }) .visit_map(MapAccess { de: self })
.map_err(|e: Self::Error| e.set_context(self)) .map_err(|e: Self::Error| e.set_context(self))
} }

4
crates/bencode/src/serde_bencode_ser.rs
View file

@ -12,7 +12,7 @@ pub enum SerErrorKind {
impl std::fmt::Display for SerErrorKind { impl std::fmt::Display for SerErrorKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { match self {
SerErrorKind::Other(e) => write!(f, "{}", e), SerErrorKind::Other(e) => write!(f, "{e}"),
} }
} }
} }
@ -84,7 +84,7 @@ impl<W: std::io::Write> BencodeSerializer<W> {
self.write_raw(&[byte]) self.write_raw(&[byte])
} }
fn write_number<N: std::fmt::Display>(&mut self, number: N) -> Result<(), SerError> { fn write_number<N: std::fmt::Display>(&mut self, number: N) -> Result<(), SerError> {
self.write_fmt(format_args!("i{}e", number)) self.write_fmt(format_args!("i{number}e"))
} }
fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), SerError> { fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), SerError> {
if !self.hack_no_bytestring_prefix { if !self.hack_no_bytestring_prefix {

6
crates/buffers/src/lib.rs
View file

@ -29,7 +29,7 @@ struct HexBytes<'a>(&'a [u8]);
impl<'a> std::fmt::Display for HexBytes<'a> { impl<'a> std::fmt::Display for HexBytes<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for byte in self.0 { for byte in self.0 {
write!(f, "{:02x?}", byte)?; write!(f, "{byte:02x?}")?;
} }
Ok(()) Ok(())
} }
@ -44,9 +44,9 @@ fn debug_bytes(b: &[u8], f: &mut std::fmt::Formatter<'_>, debug_strings: bool) -
// A test if all chars are "printable". // A test if all chars are "printable".
if s.chars().all(|c| c.escape_debug().len() == 1) { if s.chars().all(|c| c.escape_debug().len() == 1) {
if debug_strings { if debug_strings {
return write!(f, "{:?}", s); return write!(f, "{s:?}");
} else { } else {
return write!(f, "{}", s); return write!(f, "{s}");
} }
} }
} }

8
crates/dht/src/bprotocol.rs
View file

@ -509,7 +509,7 @@ mod tests {
const WHAT_IS_THAT: &[u8]= b"64313a6164323a696432303abd7b477cfbcd10f30b705da20201e7101d8df155393a696e666f5f6861736832303acab507494d02ebb1178b38f2e9d7be299c86b86265313a71393a6765745f7065657273313a74323a0007313a79313a7165"; const WHAT_IS_THAT: &[u8]= b"64313a6164323a696432303abd7b477cfbcd10f30b705da20201e7101d8df155393a696e666f5f6861736832303acab507494d02ebb1178b38f2e9d7be299c86b86265313a71393a6765745f7065657273313a74323a0007313a79313a7165";
fn write(filename: &str, data: &[u8]) { fn write(filename: &str, data: &[u8]) {
let full = format!("/tmp/{}.bin", filename); let full = format!("/tmp/{filename}.bin");
let mut f = std::fs::OpenOptions::new() let mut f = std::fs::OpenOptions::new()
.create(true) .create(true)
.write(true) .write(true)
@ -519,7 +519,7 @@ mod tests {
} }
fn debug_hex_bencode(name: &str, data: &[u8]) { fn debug_hex_bencode(name: &str, data: &[u8]) {
println!("{}", name); println!("{name}");
let data = hex::decode(data).unwrap(); let data = hex::decode(data).unwrap();
println!( println!(
@ -544,8 +544,8 @@ mod tests {
bprotocol::serialize_message(&mut buf, transaction_id, version, ip, kind).unwrap(); bprotocol::serialize_message(&mut buf, transaction_id, version, ip, kind).unwrap();
if buf.as_slice() != data { if buf.as_slice() != data {
write(&format!("{}-serialized", name), buf.as_slice()); write(&format!("{name}-serialized"), buf.as_slice());
write(&format!("{}-expected", name), data); write(&format!("{name}-expected"), data);
panic!( panic!(
"{} results don't match, dumped to /tmp/{}-*.bin", "{} results don't match, dumped to /tmp/{}-*.bin",
name, name name, name

10
crates/dht/src/persistence.rs
View file

@ -34,8 +34,8 @@ fn dump_dht(dht: &Dht, filename: &Path, tempfile_name: &Path) -> anyhow::Result<
.truncate(true) .truncate(true)
.create(true) .create(true)
.write(true) .write(true)
.open(&tempfile_name) .open(tempfile_name)
.with_context(|| format!("error opening {:?}", tempfile_name))?; .with_context(|| format!("error opening {tempfile_name:?}"))?;
let addr = dht.listen_addr(); let addr = dht.listen_addr();
match dht match dht
@ -46,13 +46,13 @@ fn dump_dht(dht: &Dht, filename: &Path, tempfile_name: &Path) -> anyhow::Result<
} }
Err(e) => { Err(e) => {
return Err(e).with_context(|| { return Err(e).with_context(|| {
format!("error serializing DHT routing table to {:?}", tempfile_name) format!("error serializing DHT routing table to {tempfile_name:?}")
}) })
} }
} }
std::fs::rename(tempfile_name, filename) std::fs::rename(tempfile_name, filename)
.with_context(|| format!("error renaming {:?} to {:?}", tempfile_name, filename)) .with_context(|| format!("error renaming {tempfile_name:?} to {filename:?}"))
} }
impl PersistentDht { impl PersistentDht {
@ -92,7 +92,7 @@ impl PersistentDht {
} }
Err(e) => match e.kind() { Err(e) => match e.kind() {
std::io::ErrorKind::NotFound => None, std::io::ErrorKind::NotFound => None,
_ => return Err(e).with_context(|| format!("error reading {:?}", config_filename)), _ => return Err(e).with_context(|| format!("error reading {config_filename:?}")),
}, },
}; };
let (listen_addr, routing_table) = de let (listen_addr, routing_table) = de

2
crates/librqbit/src/dht_utils.rs
View file

@ -50,7 +50,7 @@ pub async fn read_metainfo_from_peer_receiver<A: Stream<Item = SocketAddr> + Unp
BlockingSpawner::new(true), BlockingSpawner::new(true),
) )
.await .await
.with_context(|| format!("error reading metainfo from {}", addr)); .with_context(|| format!("error reading metainfo from {addr}"));
drop(token); drop(token);
ret ret
} }

35
crates/librqbit/src/file_ops.rs
View file

@ -34,12 +34,8 @@ pub fn update_hash_from_file<Sha1: ISha1>(
let mut read = 0; let mut read = 0;
while bytes_to_read > 0 { while bytes_to_read > 0 {
let chunk = std::cmp::min(buf.len(), bytes_to_read); let chunk = std::cmp::min(buf.len(), bytes_to_read);
file.read_exact(&mut buf[..chunk]).with_context(|| { file.read_exact(&mut buf[..chunk])
format!( .with_context(|| format!("failed reading chunk of size {chunk}, read so far {read}"))?;
"failed reading chunk of size {}, read so far {}",
chunk, read
)
})?;
bytes_to_read -= chunk; bytes_to_read -= chunk;
read += chunk; read += chunk;
hash.update(&buf[..chunk]); hash.update(&buf[..chunk]);
@ -93,7 +89,7 @@ impl<'a, Sha1Impl: ISha1> FileOps<'a, Sha1Impl> {
self.len - self.processed_bytes self.len - self.processed_bytes
} }
fn mark_processed_bytes(&mut self, bytes: u64) { fn mark_processed_bytes(&mut self, bytes: u64) {
self.processed_bytes += bytes as u64 self.processed_bytes += bytes
} }
} }
let mut file_iterator = self let mut file_iterator = self
@ -247,16 +243,12 @@ impl<'a, Sha1Impl: ISha1> FileOps<'a, Sha1Impl> {
file_g file_g
.seek(SeekFrom::Start(absolute_offset)) .seek(SeekFrom::Start(absolute_offset))
.with_context(|| { .with_context(|| {
format!( format!("error seeking to {absolute_offset}, file id: {file_idx}")
"error seeking to {}, file id: {}",
absolute_offset, file_idx
)
})?; })?;
update_hash_from_file(&mut file_g, &mut h, &mut buf, to_read_in_file).with_context( update_hash_from_file(&mut file_g, &mut h, &mut buf, to_read_in_file).with_context(
|| { || {
format!( format!(
"error reading {} bytes, file_id: {} (\"{:?}\")", "error reading {to_read_in_file} bytes, file_id: {file_idx} (\"{name:?}\")"
to_read_in_file, file_idx, name
) )
}, },
)?; )?;
@ -315,18 +307,12 @@ impl<'a, Sha1Impl: ISha1> FileOps<'a, Sha1Impl> {
file_g file_g
.seek(SeekFrom::Start(absolute_offset)) .seek(SeekFrom::Start(absolute_offset))
.with_context(|| { .with_context(|| {
format!( format!("error seeking to {absolute_offset}, file id: {file_idx}")
"error seeking to {}, file id: {}",
absolute_offset, file_idx
)
})?; })?;
file_g file_g
.read_exact(&mut buf[..to_read_in_file]) .read_exact(&mut buf[..to_read_in_file])
.with_context(|| { .with_context(|| {
format!( format!("error reading {file_idx} bytes, file_id: {to_read_in_file}")
"error reading {} bytes, file_id: {}",
file_idx, to_read_in_file
)
})?; })?;
buf = &mut buf[to_read_in_file..]; buf = &mut buf[to_read_in_file..];
@ -376,14 +362,11 @@ impl<'a, Sha1Impl: ISha1> FileOps<'a, Sha1Impl> {
file_g file_g
.seek(SeekFrom::Start(absolute_offset)) .seek(SeekFrom::Start(absolute_offset))
.with_context(|| { .with_context(|| {
format!( format!("error seeking to {absolute_offset} in file {file_idx} (\"{name:?}\")")
"error seeking to {} in file {} (\"{:?}\")",
absolute_offset, file_idx, name
)
})?; })?;
file_g file_g
.write_all(&buf[..to_write]) .write_all(&buf[..to_write])
.with_context(|| format!("error writing to file {} (\"{:?}\")", file_idx, name))?; .with_context(|| format!("error writing to file {file_idx} (\"{name:?}\")"))?;
buf = &buf[to_write..]; buf = &buf[to_write..];
if buf.is_empty() { if buf.is_empty() {
break; break;

10
crates/librqbit/src/http_api_client.rs
View file

@ -15,12 +15,10 @@ async fn check_response(r: reqwest::Response) -> anyhow::Result<reqwest::Respons
} }
let status = r.status(); let status = r.status();
let url = r.url().clone(); let url = r.url().clone();
let body = r.text().await.with_context(|| { let body = r
format!( .text()
"cannot read response body for request to {} ({})", .await
url, status, .with_context(|| format!("cannot read response body for request to {url} ({status})"))?;
)
})?;
anyhow::bail!("{} -> {}: {}", url, status, body) anyhow::bail!("{} -> {}: {}", url, status, body)
} }

2
crates/librqbit/src/peer_info_reader/mod.rs
View file

@ -110,7 +110,7 @@ impl HandlerLocked {
anyhow::bail!("already received piece {}", index); anyhow::bail!("already received piece {}", index);
} }
let offset_end = offset + size; let offset_end = offset + size;
(&mut self.buffer[offset..offset_end]).copy_from_slice(data); self.buffer[offset..offset_end].copy_from_slice(data);
self.received_pieces[index as usize] = true; self.received_pieces[index as usize] = true;
if self.received_pieces.iter().all(|p| *p) { if self.received_pieces.iter().all(|p| *p) {

10
crates/librqbit/src/session.rs
View file

@ -72,14 +72,14 @@ pub struct Session {
async fn torrent_from_url(url: &str) -> anyhow::Result<TorrentMetaV1Owned> { async fn torrent_from_url(url: &str) -> anyhow::Result<TorrentMetaV1Owned> {
let response = reqwest::get(url) let response = reqwest::get(url)
.await .await
.with_context(|| format!("error downloading torrent metadata from {}", url))?; .with_context(|| format!("error downloading torrent metadata from {url}"))?;
if !response.status().is_success() { if !response.status().is_success() {
anyhow::bail!("GET {} returned {}", url, response.status()) anyhow::bail!("GET {} returned {}", url, response.status())
} }
let b = response let b = response
.bytes() .bytes()
.await .await
.with_context(|| format!("error reading repsonse body from {}", url))?; .with_context(|| format!("error reading repsonse body from {url}"))?;
torrent_from_bytes(&b).context("error decoding torrent") torrent_from_bytes(&b).context("error decoding torrent")
} }
@ -91,9 +91,9 @@ fn torrent_from_file(filename: &str) -> anyhow::Result<TorrentMetaV1Owned> {
.context("error reading stdin")?; .context("error reading stdin")?;
} else { } else {
File::open(filename) File::open(filename)
.with_context(|| format!("error opening {}", filename))? .with_context(|| format!("error opening {filename}"))?
.read_to_end(&mut buf) .read_to_end(&mut buf)
.with_context(|| format!("error reading {}", filename))?; .with_context(|| format!("error reading {filename}"))?;
} }
torrent_from_bytes(&buf).context("error decoding torrent") torrent_from_bytes(&buf).context("error decoding torrent")
} }
@ -107,7 +107,7 @@ fn compute_only_files<ByteBuf: AsRef<[u8]>>(
for (idx, (filename, _)) in torrent.iter_filenames_and_lengths()?.enumerate() { for (idx, (filename, _)) in torrent.iter_filenames_and_lengths()?.enumerate() {
let full_path = filename let full_path = filename
.to_pathbuf() .to_pathbuf()
.with_context(|| format!("filename of file {} is not valid utf8", idx))?; .with_context(|| format!("filename of file {idx} is not valid utf8"))?;
if filename_re.is_match(full_path.to_str().unwrap()) { if filename_re.is_match(full_path.to_str().unwrap()) {
only_files.push(idx); only_files.push(idx);
} }

2
crates/librqbit/src/torrent_manager.rs
View file

@ -116,7 +116,7 @@ impl TorrentManagerHandle {
pub fn add_tracker(&self, url: Url) -> bool { pub fn add_tracker(&self, url: Url) -> bool {
let mgr = self.manager.clone(); let mgr = self.manager.clone();
if mgr.trackers.lock().insert(url.clone()) { if mgr.trackers.lock().insert(url.clone()) {
spawn(format!("tracker monitor {}", url), async move { spawn(format!("tracker monitor {url}"), async move {
mgr.single_tracker_monitor(url).await mgr.single_tracker_monitor(url).await
}); });
true true

8
crates/librqbit/src/torrent_state.rs
View file

@ -723,7 +723,7 @@ impl PeerHandler {
} }
fn on_bitfield(&self, handle: PeerHandle, bitfield: ByteString) -> anyhow::Result<()> { fn on_bitfield(&self, handle: PeerHandle, bitfield: ByteString) -> anyhow::Result<()> {
if bitfield.len() != self.state.lengths.piece_bitfield_bytes() as usize { if bitfield.len() != self.state.lengths.piece_bitfield_bytes() {
anyhow::bail!( anyhow::bail!(
"dropping {} as its bitfield has unexpected size. Got {}, expected {}", "dropping {} as its bitfield has unexpected size. Got {}, expected {}",
handle, handle,
@ -754,7 +754,7 @@ impl PeerHandler {
// Additional spawn per peer, not good. // Additional spawn per peer, not good.
spawn( spawn(
format!("peer_chunk_requester({})", handle), format!("peer_chunk_requester({handle})"),
self.clone().task_peer_chunk_requester(handle), self.clone().task_peer_chunk_requester(handle),
); );
Ok(()) Ok(())
@ -984,7 +984,7 @@ impl PeerHandler {
.state .state
.file_ops() .file_ops()
.check_piece(handle, chunk_info.piece_index, &chunk_info) .check_piece(handle, chunk_info.piece_index, &chunk_info)
.with_context(|| format!("error checking piece={}", index))? .with_context(|| format!("error checking piece={index}"))?
{ {
true => { true => {
let piece_len = let piece_len =
@ -1036,7 +1036,7 @@ impl PeerHandler {
}; };
Ok::<_, anyhow::Error>(()) Ok::<_, anyhow::Error>(())
}) })
.with_context(|| format!("error processing received chunk {:?}", chunk_info))?; .with_context(|| format!("error processing received chunk {chunk_info:?}"))?;
Ok(()) Ok(())
} }
} }

10
crates/librqbit/src/tracker_comms.rs
View file

@ -127,7 +127,7 @@ where
where where
E: serde::de::Error, E: serde::de::Error,
{ {
IpAddr::from_str(v).map_err(|e| E::custom(format!("cannot parse ip: {}", e))) IpAddr::from_str(v).map_err(|e| E::custom(format!("cannot parse ip: {e}")))
} }
} }
de.deserialize_str(Visitor {}) de.deserialize_str(Visitor {})
@ -185,16 +185,16 @@ impl TrackerRequest {
write!(s, "&compact={}", if self.compact { 1 } else { 0 }).unwrap(); write!(s, "&compact={}", if self.compact { 1 } else { 0 }).unwrap();
write!(s, "&no_peer_id={}", if self.no_peer_id { 1 } else { 0 }).unwrap(); write!(s, "&no_peer_id={}", if self.no_peer_id { 1 } else { 0 }).unwrap();
if let Some(ip) = &self.ip { if let Some(ip) = &self.ip {
write!(s, "&ip={}", ip).unwrap(); write!(s, "&ip={ip}").unwrap();
} }
if let Some(numwant) = &self.numwant { if let Some(numwant) = &self.numwant {
write!(s, "&numwant={}", numwant).unwrap(); write!(s, "&numwant={numwant}").unwrap();
} }
if let Some(key) = &self.key { if let Some(key) = &self.key {
write!(s, "&key={}", key).unwrap(); write!(s, "&key={key}").unwrap();
} }
if let Some(trackerid) = &self.trackerid { if let Some(trackerid) = &self.trackerid {
write!(s, "&trackerid={}", trackerid).unwrap(); write!(s, "&trackerid={trackerid}").unwrap();
} }
s s
} }

2
crates/librqbit_core/src/id20.rs
View file

@ -22,7 +22,7 @@ impl std::fmt::Debug for Id20 {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "<")?; write!(f, "<")?;
for byte in self.0 { for byte in self.0 {
write!(f, "{:02x?}", byte)?; write!(f, "{byte:02x?}")?;
} }
write!(f, ">")?; write!(f, ">")?;
Ok(()) Ok(())

2
crates/librqbit_core/src/lengths.rs
View file

@ -85,7 +85,7 @@ impl Lengths {
if total_length == 0 { if total_length == 0 {
anyhow::bail!("torrent with 0 length") anyhow::bail!("torrent with 0 length")
} }
let total_pieces = ceil_div_u64(total_length as u64, piece_length as u64) as u32; let total_pieces = ceil_div_u64(total_length, piece_length as u64) as u32;
Ok(Self { Ok(Self {
chunk_length, chunk_length,
piece_length, piece_length,

6
crates/librqbit_core/src/peer_id.rs
View file

@ -31,7 +31,7 @@ fn try_decode_azureus_style(p: &Id20) -> Option<AzureusStyle> {
return None; return None;
} }
let mut version = ['0'; 4]; let mut version = ['0'; 4];
for (i, c) in (&p[3..7]).iter().copied().enumerate() { for (i, c) in p[3..7].iter().copied().enumerate() {
version[i] = c as char; version[i] = c as char;
} }
let kind = AzureusStyleKind::from_bytes(p[1], p[2]); let kind = AzureusStyleKind::from_bytes(p[1], p[2]);
@ -51,9 +51,9 @@ pub fn generate_peer_id() -> Id20 {
let mut peer_id = [0u8; 20]; let mut peer_id = [0u8; 20];
let u = uuid::Uuid::new_v4(); let u = uuid::Uuid::new_v4();
(&mut peer_id[4..20]).copy_from_slice(&u.as_bytes()[..]); peer_id[4..20].copy_from_slice(&u.as_bytes()[..]);
(&mut peer_id[..8]).copy_from_slice(b"-rQ0001-"); peer_id[..8].copy_from_slice(b"-rQ0001-");
Id20(peer_id) Id20(peer_id)
} }

4
crates/librqbit_core/src/torrent_metainfo.rs
View file

@ -76,8 +76,8 @@ where
{ {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self.to_string() { match self.to_string() {
Ok(s) => write!(f, "{:?}", s), Ok(s) => write!(f, "{s:?}"),
Err(e) => write!(f, "<{:?}>", e), Err(e) => write!(f, "<{e:?}>"),
} }
} }
} }

2
crates/peer_binary_protocol/src/extended/mod.rs
View file

@ -73,7 +73,7 @@ impl<'a, ByteBuf: 'a + std::hash::Hash + Eq + Serialize> ExtendedMessage<ByteBuf
where where
ByteBuf: Deserialize<'a> + From<&'a [u8]>, ByteBuf: Deserialize<'a> + From<&'a [u8]>,
{ {
let emsg_id = buf.get(0).copied().ok_or_else(|| { let emsg_id = buf.first().copied().ok_or_else(|| {
MessageDeserializeError::Other(anyhow::anyhow!( MessageDeserializeError::Other(anyhow::anyhow!(
"cannot deserialize extended message: can't read first byte" "cannot deserialize extended message: can't read first byte"
)) ))

25
crates/peer_binary_protocol/src/lib.rs
View file

@ -119,12 +119,11 @@ impl std::fmt::Display for MessageDeserializeError {
MessageDeserializeError::NotEnoughData(b, name) => { MessageDeserializeError::NotEnoughData(b, name) => {
write!( write!(
f, f,
"not enough data to deserialize {}: expected at least {} more bytes", "not enough data to deserialize {name}: expected at least {b} more bytes"
name, b
) )
} }
MessageDeserializeError::UnsupportedMessageId(msg_id) => { MessageDeserializeError::UnsupportedMessageId(msg_id) => {
write!(f, "unsupported message id {}", msg_id) write!(f, "unsupported message id {msg_id}")
} }
MessageDeserializeError::IncorrectLenPrefix { MessageDeserializeError::IncorrectLenPrefix {
received, received,
@ -132,8 +131,7 @@ impl std::fmt::Display for MessageDeserializeError {
msg_id, msg_id,
} => write!( } => write!(
f, f,
"incorrect len prefix for message id {}, expected {}, received {}", "incorrect len prefix for message id {msg_id}, expected {expected}, received {received}"
msg_id, expected, received
), ),
MessageDeserializeError::OtherBincode { MessageDeserializeError::OtherBincode {
error, error,
@ -142,10 +140,9 @@ impl std::fmt::Display for MessageDeserializeError {
len_prefix, len_prefix,
} => write!( } => write!(
f, f,
"error deserializing {} (msg_id={}, len_prefix={}): {:?}", "error deserializing {name} (msg_id={msg_id}, len_prefix={len_prefix}): {error:?}"
name, msg_id, len_prefix, error
), ),
MessageDeserializeError::Other(e) => write!(f, "{}", e), MessageDeserializeError::Other(e) => write!(f, "{e}"),
} }
} }
} }
@ -272,7 +269,7 @@ where
Message::Request(request) => { Message::Request(request) => {
const MSG_LEN: usize = PREAMBLE_LEN + 12; const MSG_LEN: usize = PREAMBLE_LEN + 12;
out.resize(MSG_LEN, 0); out.resize(MSG_LEN, 0);
debug_assert_eq!((&out[PREAMBLE_LEN..]).len(), 12); debug_assert_eq!(out[PREAMBLE_LEN..].len(), 12);
ser.serialize_into(&mut out[PREAMBLE_LEN..], request) ser.serialize_into(&mut out[PREAMBLE_LEN..], request)
.unwrap(); .unwrap();
Ok(MSG_LEN) Ok(MSG_LEN)
@ -281,7 +278,7 @@ where
let block_len = b.as_ref().len(); let block_len = b.as_ref().len();
let msg_len = PREAMBLE_LEN + block_len; let msg_len = PREAMBLE_LEN + block_len;
out.resize(msg_len, 0); out.resize(msg_len, 0);
(&mut out[PREAMBLE_LEN..PREAMBLE_LEN + block_len]).copy_from_slice(b.as_ref()); out[PREAMBLE_LEN..PREAMBLE_LEN + block_len].copy_from_slice(b.as_ref());
Ok(msg_len) Ok(msg_len)
} }
Message::Choke | Message::Unchoke | Message::Interested | Message::NotInterested => { Message::Choke | Message::Unchoke | Message::Interested | Message::NotInterested => {
@ -382,7 +379,7 @@ where
} }
MSGID_HAVE => { MSGID_HAVE => {
let expected_len = 4; let expected_len = 4;
match rest.get(..expected_len as usize) { match rest.get(..expected_len) {
Some(h) => Ok((Message::Have(BE::read_u32(h)), PREAMBLE_LEN + expected_len)), Some(h) => Ok((Message::Have(BE::read_u32(h)), PREAMBLE_LEN + expected_len)),
None => { None => {
let missing = expected_len - rest.len(); let missing = expected_len - rest.len();
@ -399,7 +396,7 @@ where
}); });
} }
let expected_len = len_prefix as usize - 1; let expected_len = len_prefix as usize - 1;
match rest.get(..expected_len as usize) { match rest.get(..expected_len) {
Some(bitfield) => Ok(( Some(bitfield) => Ok((
Message::Bitfield(ByteBuf::from(bitfield)), Message::Bitfield(ByteBuf::from(bitfield)),
PREAMBLE_LEN + expected_len, PREAMBLE_LEN + expected_len,
@ -412,7 +409,7 @@ where
} }
MSGID_REQUEST => { MSGID_REQUEST => {
let expected_len = 12; let expected_len = 12;
match rest.get(..expected_len as usize) { match rest.get(..expected_len) {
Some(b) => { Some(b) => {
let request = decoder_config.deserialize::<Request>(b).unwrap(); let request = decoder_config.deserialize::<Request>(b).unwrap();
Ok((Message::Request(request), PREAMBLE_LEN + expected_len)) Ok((Message::Request(request), PREAMBLE_LEN + expected_len))
@ -509,7 +506,7 @@ impl<'a> Handshake<'a> {
} }
pub fn deserialize(b: &[u8]) -> Result<(Handshake<'_>, usize), MessageDeserializeError> { pub fn deserialize(b: &[u8]) -> Result<(Handshake<'_>, usize), MessageDeserializeError> {
let pstr_len = *b let pstr_len = *b
.get(0) .first()
.ok_or(MessageDeserializeError::NotEnoughData(1, "handshake"))?; .ok_or(MessageDeserializeError::NotEnoughData(1, "handshake"))?;
let expected_len = 1usize + pstr_len as usize + 48; let expected_len = 1usize + pstr_len as usize + 48;
let hbuf = b let hbuf = b