|
|
|
@ -64,6 +64,7 @@ impl Network {
|
|
|
|
let mut server = TcpListener::bind(addr).expect("Can't bind to address");
|
|
|
|
let mut server = TcpListener::bind(addr).expect("Can't bind to address");
|
|
|
|
debug!("Started node listener on {}", server.local_addr().unwrap());
|
|
|
|
debug!("Started node listener on {}", server.local_addr().unwrap());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let mut buffer = vec![0u8; 65535];
|
|
|
|
let mut events = Events::with_capacity(64);
|
|
|
|
let mut events = Events::with_capacity(64);
|
|
|
|
let mut poll = Poll::new().expect("Unable to create poll");
|
|
|
|
let mut poll = Poll::new().expect("Unable to create poll");
|
|
|
|
poll.registry().register(&mut server, SERVER, Interest::READABLE).expect("Error registering poll");
|
|
|
|
poll.registry().register(&mut server, SERVER, Interest::READABLE).expect("Error registering poll");
|
|
|
|
@ -146,7 +147,7 @@ impl Network {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
token => {
|
|
|
|
token => {
|
|
|
|
if !self.handle_connection_event(poll.registry(), event, &mut seen_blocks) {
|
|
|
|
if !self.handle_connection_event(poll.registry(), event, &mut seen_blocks, &mut buffer) {
|
|
|
|
let _ = self.peers.close_peer(poll.registry(), &token);
|
|
|
|
let _ = self.peers.close_peer(poll.registry(), &token);
|
|
|
|
let blocks = self.context.lock().unwrap().chain.get_height();
|
|
|
|
let blocks = self.context.lock().unwrap().chain.get_height();
|
|
|
|
let keys = self.context.lock().unwrap().chain.get_users_count();
|
|
|
|
let keys = self.context.lock().unwrap().chain.get_users_count();
|
|
|
|
@ -202,7 +203,7 @@ impl Network {
|
|
|
|
log_timer = Instant::now();
|
|
|
|
log_timer = Instant::now();
|
|
|
|
seen_blocks.clear();
|
|
|
|
seen_blocks.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if nodes < MAX_NODES && connect_timer.elapsed().as_secs() >= 5 {
|
|
|
|
if nodes < MAX_NODES && connect_timer.elapsed().as_secs() >= 2 {
|
|
|
|
self.peers.connect_new_peers(poll.registry(), &mut self.token, yggdrasil_only);
|
|
|
|
self.peers.connect_new_peers(poll.registry(), &mut self.token, yggdrasil_only);
|
|
|
|
connect_timer = Instant::now();
|
|
|
|
connect_timer = Instant::now();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -221,13 +222,13 @@ impl Network {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fn handle_connection_event(&mut self, registry: &Registry, event: &Event, seen_blocks: &mut HashSet<Bytes>) -> bool {
|
|
|
|
fn handle_connection_event(&mut self, registry: &Registry, event: &Event, seen_blocks: &mut HashSet<Bytes>, buf: &mut [u8]) -> bool {
|
|
|
|
if event.is_error() || (event.is_read_closed() && event.is_write_closed()) {
|
|
|
|
if event.is_error() || (event.is_read_closed() && event.is_write_closed()) {
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if event.is_readable() {
|
|
|
|
if event.is_readable() {
|
|
|
|
if !self.process_readable(registry, event, seen_blocks) {
|
|
|
|
if !self.process_readable(registry, event, seen_blocks, buf) {
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -241,8 +242,8 @@ impl Network {
|
|
|
|
true
|
|
|
|
true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fn process_readable(&mut self, registry: &Registry, event: &Event, seen_blocks: &mut HashSet<Bytes>) -> bool {
|
|
|
|
fn process_readable(&mut self, registry: &Registry, event: &Event, seen_blocks: &mut HashSet<Bytes>, buf: &mut [u8]) -> bool {
|
|
|
|
let data = {
|
|
|
|
let data_size = {
|
|
|
|
let token = event.token();
|
|
|
|
let token = event.token();
|
|
|
|
match self.peers.get_mut_peer(&token) {
|
|
|
|
match self.peers.get_mut_peer(&token) {
|
|
|
|
None => {
|
|
|
|
None => {
|
|
|
|
@ -308,18 +309,18 @@ impl Network {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
_ => {
|
|
|
|
let stream = peer.get_stream();
|
|
|
|
let stream = peer.get_stream();
|
|
|
|
read_message(stream)
|
|
|
|
read_message(stream, buf)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if let Ok(data) = data {
|
|
|
|
if let Ok(data_size) = data_size {
|
|
|
|
let data = {
|
|
|
|
let data = {
|
|
|
|
match self.peers.get_peer(&event.token()) {
|
|
|
|
match self.peers.get_peer(&event.token()) {
|
|
|
|
Some(peer) => {
|
|
|
|
Some(peer) => {
|
|
|
|
match decode_message(&data, peer.get_cipher()) {
|
|
|
|
match decode_message(&buf[0..data_size], peer.get_cipher()) {
|
|
|
|
Ok(data) => data,
|
|
|
|
Ok(data) => data,
|
|
|
|
Err(_) => {
|
|
|
|
Err(_) => {
|
|
|
|
vec![]
|
|
|
|
vec![]
|
|
|
|
@ -380,7 +381,7 @@ impl Network {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
let error = data.err().unwrap();
|
|
|
|
let error = data_size.err().unwrap();
|
|
|
|
let addr = match self.peers.get_peer(&event.token()) {
|
|
|
|
let addr = match self.peers.get_peer(&event.token()) {
|
|
|
|
None => String::from("unknown"),
|
|
|
|
None => String::from("unknown"),
|
|
|
|
Some(peer) => peer.get_addr().to_string()
|
|
|
|
Some(peer) => peer.get_addr().to_string()
|
|
|
|
@ -751,18 +752,17 @@ fn decode_message(data: &[u8], cipher: &Option<Chacha>) -> Result<Vec<u8>, chach
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fn read_message(stream: &mut TcpStream) -> Result<Vec<u8>, Error> {
|
|
|
|
fn read_message(stream: &mut TcpStream, buf: &mut [u8]) -> Result<usize, Error> {
|
|
|
|
let instant = Instant::now();
|
|
|
|
let instant = Instant::now();
|
|
|
|
let data_size = (stream.read_u16::<BigEndian>()? ^ 0xAAAA) as usize;
|
|
|
|
let data_size = (stream.read_u16::<BigEndian>()? ^ 0xAAAA) as usize;
|
|
|
|
if data_size == 0 {
|
|
|
|
if data_size == 0 {
|
|
|
|
return Err(io::Error::from(ErrorKind::InvalidInput));
|
|
|
|
return Err(io::Error::from(ErrorKind::InvalidInput));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let mut buf = vec![0u8; data_size];
|
|
|
|
|
|
|
|
let mut bytes_read = 0;
|
|
|
|
let mut bytes_read = 0;
|
|
|
|
let delay = Duration::from_millis(2);
|
|
|
|
let delay = Duration::from_millis(2);
|
|
|
|
loop {
|
|
|
|
loop {
|
|
|
|
match stream.read(&mut buf[bytes_read..]) {
|
|
|
|
match stream.read(&mut buf[bytes_read..data_size]) {
|
|
|
|
Ok(bytes) => {
|
|
|
|
Ok(bytes) => {
|
|
|
|
bytes_read += bytes;
|
|
|
|
bytes_read += bytes;
|
|
|
|
if bytes_read == data_size {
|
|
|
|
if bytes_read == data_size {
|
|
|
|
@ -777,7 +777,7 @@ fn read_message(stream: &mut TcpStream) -> Result<Vec<u8>, Error> {
|
|
|
|
thread::sleep(delay);
|
|
|
|
thread::sleep(delay);
|
|
|
|
continue;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
return Err(io::Error::from(ErrorKind::WouldBlock));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Err(ref err) if interrupted(err) => continue,
|
|
|
|
Err(ref err) if interrupted(err) => continue,
|
|
|
|
@ -788,10 +788,10 @@ fn read_message(stream: &mut TcpStream) -> Result<Vec<u8>, Error> {
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if buf.len() == data_size {
|
|
|
|
if bytes_read == data_size {
|
|
|
|
Ok(buf)
|
|
|
|
Ok(data_size)
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
Err(io::Error::from(ErrorKind::WouldBlock))
|
|
|
|
Err(io::Error::from(ErrorKind::BrokenPipe))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
Revertron
2 years ago