Sweetbread/Alfis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed multiple clippy warnings.

Browse Source
This commit is contained in:
Revertron
2021-12-25 18:40:36 +01:00
parent d776cca5b3
commit 797584c516
29 changed files with 313 additions and 360 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/p2p/message.rs
+3 -5
View File
@@ -2,6 +2,7 @@ extern crate serde;
extern crate serde_json;
use serde::{Deserialize, Serialize};
use serde_cbor::Error;
use crate::Bytes;
@@ -21,11 +22,8 @@ pub enum Message {
}
impl Message {
pub fn from_bytes(bytes: Vec<u8>) -> Result<Self, ()> {
match serde_cbor::from_slice(bytes.as_slice()) {
Ok(cmd) => Ok(cmd),
Err(_) => Err(())
}
pub fn from_bytes(bytes: Vec<u8>) -> Result<Message, Error> {
serde_cbor::from_slice(bytes.as_slice())
}
pub fn hand(app_version: &str, origin: &str, version: u32, public: bool, rand_id: &str) -> Self {
src/p2p/network.rs
+65 -76
View File
@@ -69,7 +69,7 @@ impl Network {
poll.registry().register(&mut server, SERVER, Interest::READABLE).expect("Error registering poll");
// Starting peer connections to bootstrap nodes
self.peers.connect_peers(&peers_addrs, &poll.registry(), &mut self.token, yggdrasil_only);
self.peers.connect_peers(&peers_addrs, poll.registry(), &mut self.token, yggdrasil_only);
let mut ui_timer = Instant::now();
let mut log_timer = Instant::now();
@@ -83,7 +83,7 @@ impl Network {
if self.peers.get_peers_count() == 0 && bootstrap_timer.elapsed().as_secs() > 60 {
warn!("Restarting swarm connections...");
// Starting peer connections to bootstrap nodes
self.peers.connect_peers(&peers_addrs, &poll.registry(), &mut self.token, yggdrasil_only);
self.peers.connect_peers(&peers_addrs, poll.registry(), &mut self.token, yggdrasil_only);
bootstrap_timer = Instant::now();
last_events_time = Instant::now();
}
@@ -102,45 +102,42 @@ impl Network {
//debug!("Event for server socket {} is {:?}", event.token().0, &event);
// If this is an event for the server, it means a connection is ready to be accepted.
let connection = server.accept();
match connection {
Ok((mut stream, mut address)) => {
// Checking if it is an ipv4-mapped ipv6 if yes convert to ipv4
if address.is_ipv6() {
if let IpAddr::V6(ipv6) = address.ip() {
if let Some(ipv4) = ipv6.to_ipv4() {
address = SocketAddr::V4(SocketAddrV4::new(ipv4, address.port()))
}
if let Ok((mut stream, mut address)) = connection {
// Checking if it is an ipv4-mapped ipv6 if yes convert to ipv4
if address.is_ipv6() {
if let IpAddr::V6(ipv6) = address.ip() {
if let Some(ipv4) = ipv6.to_ipv4() {
address = SocketAddr::V4(SocketAddrV4::new(ipv4, address.port()))
}
}
if self.peers.is_ignored(&address.ip()) {
debug!("Ignoring connection from banned {:?}", &address.ip());
continue;
}
if yggdrasil_only && !is_yggdrasil(&address.ip()) {
debug!("Dropping connection from Internet");
stream.shutdown(Shutdown::Both).unwrap_or_else(|e| {
warn!("Error in shutdown, {}", e);
});
let _ = poll.registry().reregister(&mut server, SERVER, Interest::READABLE);
continue;
}
//debug!("Accepted connection from: {} to local IP: {}", address, local_ip);
let token = self.next_token();
poll.registry().register(&mut stream, token, Interest::READABLE).expect("Error registering poll");
let peer = Peer::new(address, stream, State::Connected, true);
self.peers.add_peer(token, peer);
}
Err(_) => {}
if self.peers.is_ignored(&address.ip()) {
debug!("Ignoring connection from banned {:?}", &address.ip());
continue;
}
if yggdrasil_only && !is_yggdrasil(&address.ip()) {
debug!("Dropping connection from Internet");
stream.shutdown(Shutdown::Both).unwrap_or_else(|e| {
warn!("Error in shutdown, {}", e);
});
let _ = poll.registry().reregister(&mut server, SERVER, Interest::READABLE);
continue;
}
//debug!("Accepted connection from: {} to local IP: {}", address, local_ip);
let token = self.next_token();
poll.registry().register(&mut stream, token, Interest::READABLE).expect("Error registering poll");
let peer = Peer::new(address, stream, State::Connected, true);
self.peers.add_peer(token, peer);
}
if let Err(e) = poll.registry().reregister(&mut server, SERVER, Interest::READABLE) {
panic!("Error reregistering server token!\n{}", e);
}
}
token => {
if !self.handle_connection_event(&poll.registry(), &event) {
if !self.handle_connection_event(poll.registry(), event) {
let _ = self.peers.close_peer(poll.registry(), &token);
let blocks = self.context.lock().unwrap().chain.get_height();
let keys = self.context.lock().unwrap().chain.get_users_count();
@@ -227,8 +224,8 @@ impl Network {
}
match peer.get_state().clone() {
State::Connected => {
let mut stream = peer.get_stream();
return match read_client_handshake(&mut stream) {
let stream = peer.get_stream();
return match read_client_handshake(stream) {
Ok(key) => {
let mut buf = [0u8; 32];
buf.copy_from_slice(key.as_slice());
@@ -251,8 +248,8 @@ impl Network {
};
}
State::ServerHandshake => {
let mut stream = peer.get_stream();
return match read_server_handshake(&mut stream) {
let stream = peer.get_stream();
return match read_server_handshake(stream) {
Ok(data) => {
if data.len() != 32 + 12 {
warn!("Server handshake of {} bytes instead of {}", data.len(), 32 + 12);
@@ -278,19 +275,18 @@ impl Network {
};
}
_ => {
let mut stream = peer.get_stream();
read_message(&mut stream)
let stream = peer.get_stream();
read_message(stream)
}
}
}
}
};
if data.is_ok() {
if let Ok(data) = data {
let data = {
match self.peers.get_peer(&event.token()) {
Some(peer) => {
let data = data.unwrap();
match decode_message(&data, peer.get_cipher()) {
Ok(data) => data,
Err(_) => {
@@ -344,9 +340,9 @@ impl Network {
}
}
}
Err(_) => {
Err(e) => {
let peer = self.peers.get_peer(&event.token()).unwrap();
warn!("Error deserializing message from {}", &peer.get_addr());
warn!("Error deserializing message from {}: {}", &peer.get_addr(), e.to_string());
return false;
}
}
@@ -368,7 +364,7 @@ impl Network {
Some(peer) => {
match peer.get_state().clone() {
State::Connecting => {
if send_client_handshake(&mut peer.get_stream(), self.public_key.as_bytes()).is_err() {
if send_client_handshake(peer.get_stream(), self.public_key.as_bytes()).is_err() {
return false;
}
peer.set_state(State::ServerHandshake);
@@ -442,18 +438,16 @@ impl Network {
if self.peers.is_our_own_connect(&rand_id) {
warn!("Detected loop connect");
State::SendLoop
} else if origin.eq(my_origin) && version == my_version {
let peer = self.peers.get_mut_peer(token).unwrap();
peer.set_public(public);
peer.set_active(true);
debug!("Incoming v{} on {}", &app_version, peer.get_addr().ip());
let app_version = self.context.lock().unwrap().app_version.clone();
State::message(Message::shake(&app_version, &origin, version, me_public, &my_id, my_height))
} else {
if origin.eq(my_origin) && version == my_version {
let peer = self.peers.get_mut_peer(token).unwrap();
peer.set_public(public);
peer.set_active(true);
debug!("Incoming v{} on {}", &app_version, peer.get_addr().ip());
let app_version = self.context.lock().unwrap().app_version.clone();
State::message(Message::shake(&app_version, &origin, version, me_public, &my_id, my_height))
} else {
warn!("Handshake from unsupported chain or version");
State::Banned
}
warn!("Handshake from unsupported chain or version");
State::Banned
}
}
Message::Shake { app_version, origin, version, public, rand_id, height } => {
@@ -516,20 +510,18 @@ impl Network {
info!("Hashes are different, requesting block {} from {}", my_height, peer.get_addr().ip());
info!("My hash: {:?}, their hash: {:?}", &my_hash, &hash);
State::message(Message::GetBlock { index: my_height })
} else if active_count < MAX_NODES && random::<u8>() < 50 {
debug!("Requesting more peers from {}", peer.get_addr().ip());
State::message(Message::GetPeers)
} else {
if active_count < MAX_NODES && random::<u8>() < 50 {
debug!("Requesting more peers from {}", peer.get_addr().ip());
State::message(Message::GetPeers)
} else {
State::idle()
}
State::idle()
}
}
Message::GetPeers => {
let addr = {
let peer = self.peers.get_mut_peer(token).unwrap();
peer.set_active(true);
peer.get_addr().clone()
peer.get_addr()
};
State::message(Message::Peers { peers: self.peers.get_peers_for_exchange(&addr) })
}
@@ -584,7 +576,7 @@ impl Network {
// If we have some consequent blocks in a bucket of 'future blocks', we add them
while let Some(block) = self.future_blocks.remove(&next_index) {
if context.chain.check_new_block(&block) == BlockQuality::Good {
info!("Added block {} from future blocks", next_index);
debug!("Added block {} from future blocks", next_index);
context.chain.add_block(block);
} else {
warn!("Block {} in future blocks is bad!", block.index);
@@ -656,21 +648,18 @@ impl Network {
fn subscribe_to_bus(running: Arc<AtomicBool>) {
use crate::event::Event;
register(move |_uuid, e| {
match e {
Event::ActionQuit => {
running.store(false, Ordering::SeqCst);
return false;
}
_ => {}
if let Event::ActionQuit = e {
running.store(false, Ordering::SeqCst);
return false;
}
true
});
}
fn encode_bytes(data: &Vec<u8>, cipher: &Option<Chacha>) -> Result<Vec<u8>, chacha20poly1305::aead::Error> {
fn encode_bytes(data: &[u8], cipher: &Option<Chacha>) -> Result<Vec<u8>, chacha20poly1305::aead::Error> {
match cipher {
None => Ok(data.clone()),
Some(chacha) => chacha.encrypt(data.as_slice())
None => Ok(data.to_owned()),
Some(chacha) => chacha.encrypt(data)
}
}
@@ -695,10 +684,10 @@ fn encode_message(message: &Message, cipher: &Option<Chacha>) -> Result<Vec<u8>,
}
}
fn decode_message(data: &Vec<u8>, cipher: &Option<Chacha>) -> Result<Vec<u8>, chacha20poly1305::aead::Error> {
fn decode_message(data: &[u8], cipher: &Option<Chacha>) -> Result<Vec<u8>, chacha20poly1305::aead::Error> {
match cipher {
None => Ok(data.clone()),
Some(chacha) => chacha.decrypt(data.as_slice())
None => Ok(data.to_owned()),
Some(chacha) => chacha.decrypt(data)
}
}
@@ -804,13 +793,13 @@ fn read_server_handshake(stream: &mut TcpStream) -> Result<Vec<u8>, Error> {
}
}
fn send_message(connection: &mut TcpStream, data: &Vec<u8>) -> io::Result<()> {
fn send_message(connection: &mut TcpStream, data: &[u8]) -> io::Result<()> {
let data_len = data.len() as u16;
//debug!("Sending {} bytes", data_len);
//debug!("Message: {:?}", to_hex(&data));
let mut buf: Vec<u8> = Vec::with_capacity(data.len() + 2);
buf.write_u16::<BigEndian>(data_len ^ 0xAAAA)?;
buf.write_all(&data)?;
buf.write_all(data)?;
connection.write_all(&buf)?;
connection.flush()
}
src/p2p/peer.rs
+1 -1
View File
@@ -57,7 +57,7 @@ impl Peer {
}
pub fn get_addr(&self) -> SocketAddr {
self.addr.clone()
self.addr
}
pub fn get_stream(&mut self) -> &mut TcpStream {
src/p2p/peers.rs
+75 -79
View File
@@ -53,51 +53,48 @@ impl Peers {
pub fn close_peer(&mut self, registry: &Registry, token: &Token) {
let peer = self.peers.get_mut(token);
match peer {
Some(peer) => {
let stream = peer.get_stream();
let _ = stream.shutdown(Shutdown::Both);
let _ = registry.deregister(stream);
match peer.get_state() {
State::Connecting => {
debug!("Peer connection {} to {:?} has timed out", &token.0, &peer.get_addr());
}
State::Connected => {
debug!("Peer connection {} to {:?} disconnected", &token.0, &peer.get_addr());
}
State::Idle { .. } | State::Message { .. } => {
debug!("Peer connection {} to {:?} disconnected", &token.0, &peer.get_addr());
}
State::Error => {
debug!("Peer connection {} to {:?} has shut down on error", &token.0, &peer.get_addr());
}
State::Banned => {
debug!("Peer connection {} to {:?} has shut down, banned", &token.0, &peer.get_addr());
self.ignored.insert(peer.get_addr().ip().clone());
}
State::Offline { .. } => {
debug!("Peer connection {} to {:?} is offline", &token.0, &peer.get_addr());
}
State::SendLoop => {
debug!("Peer connection {} from {:?} is a loop", &token.0, &peer.get_addr());
}
State::Loop => {
debug!("Peer connection {} to {:?} is a loop", &token.0, &peer.get_addr());
}
State::Twin => {
debug!("Peer connection {} to {:?} is a twin", &token.0, &peer.get_addr());
}
State::ServerHandshake => {
debug!("Peer connection {} from {:?} didn't shake hands", &token.0, &peer.get_addr());
}
State::HandshakeFinished => {
debug!("Peer connection {} from {:?} shook hands, but then failed", &token.0, &peer.get_addr());
}
if let Some(peer) = peer {
let stream = peer.get_stream();
let _ = stream.shutdown(Shutdown::Both);
let _ = registry.deregister(stream);
match peer.get_state() {
State::Connecting => {
debug!("Peer connection {} to {:?} has timed out", &token.0, &peer.get_addr());
}
State::Connected => {
debug!("Peer connection {} to {:?} disconnected", &token.0, &peer.get_addr());
}
State::Idle { .. } | State::Message { .. } => {
debug!("Peer connection {} to {:?} disconnected", &token.0, &peer.get_addr());
}
State::Error => {
debug!("Peer connection {} to {:?} has shut down on error", &token.0, &peer.get_addr());
}
State::Banned => {
debug!("Peer connection {} to {:?} has shut down, banned", &token.0, &peer.get_addr());
self.ignored.insert(peer.get_addr().ip());
}
State::Offline { .. } => {
debug!("Peer connection {} to {:?} is offline", &token.0, &peer.get_addr());
}
State::SendLoop => {
debug!("Peer connection {} from {:?} is a loop", &token.0, &peer.get_addr());
}
State::Loop => {
debug!("Peer connection {} to {:?} is a loop", &token.0, &peer.get_addr());
}
State::Twin => {
debug!("Peer connection {} to {:?} is a twin", &token.0, &peer.get_addr());
}
State::ServerHandshake => {
debug!("Peer connection {} from {:?} didn't shake hands", &token.0, &peer.get_addr());
}
State::HandshakeFinished => {
debug!("Peer connection {} from {:?} shook hands, but then failed", &token.0, &peer.get_addr());
}
self.peers.remove(token);
}
None => {}
self.peers.remove(token);
}
}
@@ -129,16 +126,14 @@ impl Peers {
if self.peers
.iter()
.find(|(_token, peer)| peer.get_addr().ip() == addr.ip())
.is_some() {
.any(|(_token, peer)| peer.get_addr().ip() == addr.ip()) {
//debug!("Skipping address from exchange: {}", &addr);
continue;
}
if self.new_peers
.iter()
.find(|a| a.ip().eq(&addr.ip()))
.is_some() {
.any(|a| a.ip().eq(&addr.ip())) {
//debug!("Skipping address from exchange: {}", &addr);
continue;
}
@@ -223,13 +218,13 @@ impl Peers {
if !peer.get_state().is_loop() {
peer.set_state(State::Banned);
}
let ip = peer.get_addr().ip().clone();
let ip = peer.get_addr().ip();
self.close_peer(registry, token);
self.ignored.insert(ip);
match self.peers
.iter()
.find(|(_, p)| p.get_addr().ip() == ip)
.map(|(t, _)| t.clone()) {
.map(|(t, _)| *t) {
None => {}
Some(t) => {
self.close_peer(registry, &t);
@@ -240,7 +235,7 @@ impl Peers {
pub fn ignore_ip(&mut self, ip: &IpAddr) {
info!("Adding {} to ignored peers", &ip);
self.ignored.insert(ip.clone());
self.ignored.insert(*ip);
}
pub fn skip_peer_connection(&self, addr: &SocketAddr) -> bool {
@@ -257,22 +252,19 @@ impl Peers {
let random_time = random::<u64>() % PING_PERIOD;
for (token, peer) in self.peers.iter_mut() {
match peer.get_state() {
State::Idle { from } => {
if from.elapsed().as_secs() >= PING_PERIOD + random_time {
// Sometimes we check for new peers instead of pinging
let message = if nodes < MAX_NODES && random::<bool>() {
Message::GetPeers
} else {
Message::ping(height, hash.clone())
};
if let State::Idle { from } = peer.get_state() {
if from.elapsed().as_secs() >= PING_PERIOD + random_time {
// Sometimes we check for new peers instead of pinging
let message = if nodes < MAX_NODES && random::<bool>() {
Message::GetPeers
} else {
Message::ping(height, hash.clone())
};
peer.set_state(State::message(message));
let stream = peer.get_stream();
registry.reregister(stream, token.clone(), Interest::WRITABLE).unwrap();
}
peer.set_state(State::message(message));
let stream = peer.get_stream();
registry.reregister(stream, *token, Interest::WRITABLE).unwrap();
}
_ => {}
}
}
@@ -283,11 +275,9 @@ impl Peers {
}
// If someone has more blocks we sync
if nodes >= MIN_CONNECTED_NODES_START_SYNC {
if height < max_height {
let count = min(max_height - height, nodes as u64);
self.ask_blocks_from_peers(registry, height, height + count, have_blocks);
}
if nodes >= MIN_CONNECTED_NODES_START_SYNC && height < max_height {
let count = min(max_height - height, nodes as u64);
self.ask_blocks_from_peers(registry, height, height + count, have_blocks);
}
// If someone has less blocks (we mined a new block) we send a ping with our height
@@ -300,7 +290,7 @@ impl Peers {
None => {}
Some((token, peer)) => {
debug!("Peer {} is behind, sending ping", &peer.get_addr().ip());
registry.reregister(peer.get_stream(), token.clone(), Interest::WRITABLE).unwrap();
registry.reregister(peer.get_stream(), *token, Interest::WRITABLE).unwrap();
peer.set_state(State::message(Message::Ping { height, hash }));
self.update_behind_ping_time();
}
@@ -323,9 +313,9 @@ impl Peers {
for (token, peer) in self.peers.iter_mut() {
if peer.get_state().need_reconnect() {
let addr = peer.get_addr();
if let Ok(mut stream) = TcpStream::connect(addr.clone()) {
if let Ok(mut stream) = TcpStream::connect(addr) {
debug!("Trying to reconnect to peer {}, count {}", &addr, peer.reconnects());
registry.register(&mut stream, token.clone(), Interest::WRITABLE).unwrap();
registry.register(&mut stream, *token, Interest::WRITABLE).unwrap();
peer.set_state(State::Connecting);
peer.inc_reconnects();
peer.set_stream(stream);
@@ -346,7 +336,7 @@ impl Peers {
None => {}
Some((token, peer)) => {
debug!("Peer {} is higher than we are, requesting block {}", &peer.get_addr().ip(), height + 1);
registry.reregister(peer.get_stream(), token.clone(), Interest::WRITABLE).unwrap();
registry.reregister(peer.get_stream(), *token, Interest::WRITABLE).unwrap();
peer.set_state(State::message(Message::GetBlock { index: height + 1 }));
}
}
@@ -366,7 +356,7 @@ impl Peers {
continue;
}
debug!("Peer {} is higher than we are, requesting block {}", &peer.get_addr().ip(), index);
registry.reregister(peer.get_stream(), token.clone(), Interest::WRITABLE).unwrap();
registry.reregister(peer.get_stream(), *token, Interest::WRITABLE).unwrap();
peer.set_state(State::message(Message::GetBlock { index }));
index += 1;
if index > max_height {
@@ -390,7 +380,7 @@ impl Peers {
}
/// Connecting to configured (bootstrap) peers
pub fn connect_peers(&mut self, peers_addrs: &Vec<String>, registry: &Registry, unique_token: &mut Token, yggdrasil_only: bool) {
pub fn connect_peers(&mut self, peers_addrs: &[String], registry: &Registry, unique_token: &mut Token, yggdrasil_only: bool) {
let mut set = HashSet::new();
for peer in peers_addrs.iter() {
info!("Resolving address {}", peer);
@@ -405,7 +395,7 @@ impl Peers {
break;
}
while addresses.len() > 0 {
while !addresses.is_empty() {
let addr = addresses.remove(0);
if !set.contains(&addr) {
match self.connect_peer(&addr, registry, unique_token, yggdrasil_only) {
@@ -420,7 +410,7 @@ impl Peers {
}
// Copy others to new_peers, to connect later
if addresses.len() > 0 {
if !addresses.is_empty() {
self.new_peers.append(&mut addresses);
}
}
@@ -435,13 +425,13 @@ impl Peers {
return Err(io::Error::from(io::ErrorKind::InvalidInput));
}
trace!("Connecting to peer {}", &addr);
match TcpStream::connect(addr.clone()) {
match TcpStream::connect(*addr) {
Ok(mut stream) => {
//stream.set_nodelay(true)?;
let token = next(unique_token);
trace!("Created connection {}, to peer {}", &token.0, &addr);
registry.register(&mut stream, token, Interest::WRITABLE).unwrap();
let mut peer = Peer::new(addr.clone(), stream, State::Connecting, false);
let mut peer = Peer::new(*addr, stream, State::Connecting, false);
peer.set_public(true);
self.peers.insert(token, peer);
Ok(())
@@ -459,6 +449,12 @@ impl Peers {
}
}
impl Default for Peers {
fn default() -> Self {
Self::new()
}
}
/// Gets new token from old token, mutating the last
pub fn next(current: &mut Token) -> Token {
let next = current.0;
src/p2p/state.rs
+2 -9
View File
@@ -33,18 +33,11 @@ impl State {
}
pub fn is_idle(&self) -> bool {
match self {
State::Idle { .. } => true,
_ => false
}
matches!(self, State::Idle { .. })
}
pub fn is_loop(&self) -> bool {
match self {
State::Loop { .. } => true,
State::SendLoop { .. } => true,
_ => false
}
matches!(self, State::Loop { .. } | State::SendLoop { .. })
}
pub fn disabled(&self) -> bool {