From 3fa26fd80e39e50adad2a475ef3c9c4a0796922b Mon Sep 17 00:00:00 2001 From: Jake McGinty Date: Thu, 3 May 2018 15:42:25 -0700 Subject: timers: create Timers struct to store more detailed timer info --- src/interface/peer_server.rs | 12 ++++++------ src/peer.rs | 40 ++++++++++++++++++++++++---------------- 2 files changed, 30 insertions(+), 22 deletions(-) diff --git a/src/interface/peer_server.rs b/src/interface/peer_server.rs index 95970df..15268ff 100644 --- a/src/interface/peer_server.rs +++ b/src/interface/peer_server.rs @@ -312,7 +312,7 @@ impl PeerServer { } self.send_to_peer((endpoint, init_packet))?; - peer.last_sent_init = Timestamp::now(); + peer.timers.handshake_initialized = Timestamp::now(); let when = *REKEY_TIMEOUT; self.timer.send_after(when, TimerMessage::Rekey(peer_ref.clone(), new_index)); Ok(new_index) @@ -328,11 +328,11 @@ impl PeerServer { match peer.find_session(our_index) { Some((_, SessionType::Next)) => { - if peer.last_sent_init.elapsed() < *REKEY_TIMEOUT { - let wait = *REKEY_TIMEOUT - peer.last_sent_init.elapsed(); + if peer.timers.handshake_initialized.elapsed() < *REKEY_TIMEOUT { + let wait = *REKEY_TIMEOUT - peer.timers.handshake_initialized.elapsed(); self.timer.send_after(wait, Rekey(peer_ref.clone(), our_index)); bail!("too soon since last init sent, waiting {:?} ({})", wait, our_index); - } else if peer.last_tun_queue.elapsed() > *REKEY_ATTEMPT_TIME { + } else if peer.timers.egress_queued.elapsed() > *REKEY_ATTEMPT_TIME { peer.sessions.next = None; bail!("REKEY_ATTEMPT_TIME exceeded, destroying session ({})", our_index); } @@ -385,7 +385,7 @@ impl PeerServer { let mut peer = peer_ref.borrow_mut(); { if peer.info.keepalive.is_none() { - bail!("no persistent keepalive set for peer."); + bail!("no persistent keepalive set for peer (likely unset between the time the timer was started and now)."); } let (_, session_type) = peer.find_session(our_index).ok_or_else(|| err_msg("missing session for timer"))?; @@ -403,7 +403,7 @@ impl PeerServer { Wipe(peer_ref) => { let mut peer = peer_ref.borrow_mut(); let mut state = self.shared_state.borrow_mut(); - if peer.last_handshake.elapsed() >= *WIPE_AFTER_TIME { + if peer.timers.handshake_completed.elapsed() >= *WIPE_AFTER_TIME { info!("wiping all old sessions due to staleness timeout for peer {}", peer.info); for index in peer.sessions.wipe() { let _ = state.index_map.remove(&index); diff --git a/src/peer.rs b/src/peer.rs index f01ac5e..752253a 100644 --- a/src/peer.rs +++ b/src/peer.rs @@ -22,11 +22,9 @@ use udp::Endpoint; pub struct Peer { pub info : PeerInfo, pub sessions : Sessions, + pub timers : Timers, pub tx_bytes : u64, pub rx_bytes : u64, - pub last_sent_init : Timestamp, - pub last_tun_queue : Timestamp, - pub last_handshake : Timestamp, pub last_handshake_tai64n : Option, pub outgoing_queue : VecDeque, pub cookie : cookie::Generator, @@ -48,6 +46,16 @@ pub enum SessionTransition { NoTransition, Transition(Option) } +#[derive(Default)] +pub struct Timers { + pub data_sent : Timestamp, + pub data_received : Timestamp, + pub authenticated_received : Timestamp, + pub authenticated_traversed : Timestamp, + pub egress_queued : Timestamp, + pub handshake_completed : Timestamp, + pub handshake_initialized : Timestamp, +} pub struct Session { pub noise : snow::Session, @@ -151,11 +159,9 @@ impl Peer { info, cookie, sessions : Default::default(), + timers : Default::default(), tx_bytes : Default::default(), rx_bytes : Default::default(), - last_sent_init : Default::default(), - last_tun_queue : Default::default(), - last_handshake : Default::default(), last_handshake_tai64n : Default::default(), outgoing_queue : Default::default(), } @@ -175,7 +181,7 @@ impl Peer { pub fn queue_egress(&mut self, packet: UtunPacket) { if self.outgoing_queue.len() < MAX_QUEUED_PACKETS { self.outgoing_queue.push_back(packet); - self.last_tun_queue = Timestamp::now(); + self.timers.egress_queued = Timestamp::now(); } else { debug!("dropping pending egress packet because the queue is full"); } @@ -189,11 +195,11 @@ impl Peer { debug!("needs new handshake: no current session"); return true; } - if sending && self.last_handshake.elapsed() > *REKEY_AFTER_TIME { + if sending && self.timers.handshake_completed.elapsed() > *REKEY_AFTER_TIME { debug!("needs new handshake: sending after REKEY_AFTER_TIME"); return true; } - if !sending && self.last_handshake.elapsed() > *REKEY_AFTER_TIME_RECV { + if !sending && self.timers.handshake_completed.elapsed() > *REKEY_AFTER_TIME_RECV { debug!("needs new handshake: receiving after RECV_REKEY_AFTER_TIME"); return true; } @@ -313,13 +319,15 @@ impl Peer { } pub fn process_incoming_handshake_response(&mut self, addr: Endpoint, packet: &Response) -> Result, Error> { - let mut session = mem::replace(&mut self.sessions.next, None).ok_or_else(|| err_msg("no next session"))?; - let _ = session.noise.read_message(packet.noise_bytes(), &mut [])?; + let mut session = mem::replace(&mut self.sessions.next, None).ok_or_else(|| err_msg("no next session"))?; + let _ = session.noise.read_message(packet.noise_bytes(), &mut [])?; + session = session.into_transport_mode()?; session.their_index = packet.their_index(); session.birthday = Timestamp::now(); - self.last_handshake = Timestamp::now(); - self.info.endpoint = Some(addr); + + self.timers.handshake_completed = Timestamp::now(); + self.info.endpoint = Some(addr); let current = mem::replace(&mut self.sessions.current, Some(session)); let dead = mem::replace(&mut self.sessions.past, current); @@ -363,7 +371,7 @@ impl Peer { let current = std::mem::replace(&mut self.sessions.current, next); let dead = std::mem::replace(&mut self.sessions.past, current); - self.last_handshake = Timestamp::now(); + self.timers.handshake_completed = Timestamp::now(); SessionTransition::Transition(dead.map(|session| session.our_index)) } else { @@ -414,8 +422,8 @@ impl Peer { } s.push_str(&format!("tx_bytes={}\nrx_bytes={}\n", self.tx_bytes, self.rx_bytes)); - if self.last_handshake.is_set() { - if let Ok(time) = (SystemTime::now() - self.last_handshake.elapsed()).duration_since(UNIX_EPOCH) { + if self.timers.handshake_completed.is_set() { + if let Ok(time) = (SystemTime::now() - self.timers.handshake_completed.elapsed()).duration_since(UNIX_EPOCH) { s.push_str(&format!("last_handshake_time_sec={}\nlast_handshake_time_nsec={}\n", time.as_secs(), time.subsec_nanos())); } else { -- cgit v1.2.3-59-g8ed1b