use secp256k1::key::{SecretKey,PublicKey};
+use ln::features::InitFeatures;
use ln::msgs;
use util::ser::{Writeable, Writer, Readable};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
channel_encryptor: PeerChannelEncryptor,
outbound: bool,
their_node_id: Option<PublicKey>,
- their_global_features: Option<msgs::GlobalFeatures>,
- their_local_features: Option<msgs::LocalFeatures>,
+ their_features: Option<InitFeatures>,
pending_outbound_buffer: LinkedList<Vec<u8>>,
pending_outbound_buffer_first_msg_offset: usize,
/// Only add to this set when noise completes:
node_id_to_descriptor: HashMap<PublicKey, Descriptor>,
}
-struct MutPeerHolder<'a, Descriptor: SocketDescriptor + 'a> {
- peers: &'a mut HashMap<Descriptor, Peer>,
- peers_needing_send: &'a mut HashSet<Descriptor>,
- node_id_to_descriptor: &'a mut HashMap<PublicKey, Descriptor>,
-}
-impl<Descriptor: SocketDescriptor> PeerHolder<Descriptor> {
- fn borrow_parts(&mut self) -> MutPeerHolder<Descriptor> {
- MutPeerHolder {
- peers: &mut self.peers,
- peers_needing_send: &mut self.peers_needing_send,
- node_id_to_descriptor: &mut self.node_id_to_descriptor,
- }
- }
-}
#[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))]
fn _check_usize_is_32_or_64() {
pub fn get_peer_node_ids(&self) -> Vec<PublicKey> {
let peers = self.peers.lock().unwrap();
peers.peers.values().filter_map(|p| {
- if !p.channel_encryptor.is_ready_for_encryption() || p.their_global_features.is_none() {
+ if !p.channel_encryptor.is_ready_for_encryption() || p.their_features.is_none() {
return None;
}
p.their_node_id
channel_encryptor: peer_encryptor,
outbound: true,
their_node_id: None,
- their_global_features: None,
- their_local_features: None,
+ their_features: None,
pending_outbound_buffer: LinkedList::new(),
pending_outbound_buffer_first_msg_offset: 0,
channel_encryptor: peer_encryptor,
outbound: false,
their_node_id: None,
- their_global_features: None,
- their_local_features: None,
+ their_features: None,
pending_outbound_buffer: LinkedList::new(),
pending_outbound_buffer_first_msg_offset: 0,
fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: Vec<u8>) -> Result<bool, PeerHandleError> {
let pause_read = {
let mut peers_lock = self.peers.lock().unwrap();
- let peers = peers_lock.borrow_parts();
+ let peers = &mut *peers_lock;
let pause_read = match peers.peers.get_mut(peer_descriptor) {
None => panic!("Descriptor for read_event is not already known to PeerManager"),
Some(peer) => {
peer.their_node_id = Some(their_node_id);
insert_node_id!();
- let mut local_features = msgs::LocalFeatures::new();
+ let mut features = InitFeatures::supported();
if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
- local_features.set_initial_routing_sync();
+ features.set_initial_routing_sync();
}
encode_and_send_msg!(msgs::Init {
- global_features: msgs::GlobalFeatures::new(),
- local_features,
+ features,
}, 16);
},
NextNoiseStep::ActThree => {
let msg_type = byte_utils::slice_to_be16(&msg_data[0..2]);
log_trace!(self, "Received message of type {} from {}", msg_type, log_pubkey!(peer.their_node_id.unwrap()));
- if msg_type != 16 && peer.their_global_features.is_none() {
+ if msg_type != 16 && peer.their_features.is_none() {
// Need an init message as first message
log_trace!(self, "Peer {} sent non-Init first message", log_pubkey!(peer.their_node_id.unwrap()));
return Err(PeerHandleError{ no_connection_possible: false });
// Connection control:
16 => {
let msg = try_potential_decodeerror!(msgs::Init::read(&mut reader));
- if msg.global_features.requires_unknown_bits() {
+ if msg.features.requires_unknown_bits() {
log_info!(self, "Peer global features required unknown version bits");
return Err(PeerHandleError{ no_connection_possible: true });
}
- if msg.local_features.requires_unknown_bits() {
+ if msg.features.requires_unknown_bits() {
log_info!(self, "Peer local features required unknown version bits");
return Err(PeerHandleError{ no_connection_possible: true });
}
- if peer.their_global_features.is_some() {
+ if peer.their_features.is_some() {
return Err(PeerHandleError{ no_connection_possible: false });
}
log_info!(self, "Received peer Init message: data_loss_protect: {}, initial_routing_sync: {}, upfront_shutdown_script: {}, unkown local flags: {}, unknown global flags: {}",
- if msg.local_features.supports_data_loss_protect() { "supported" } else { "not supported"},
- if msg.local_features.initial_routing_sync() { "requested" } else { "not requested" },
- if msg.local_features.supports_upfront_shutdown_script() { "supported" } else { "not supported"},
- if msg.local_features.supports_unknown_bits() { "present" } else { "none" },
- if msg.global_features.supports_unknown_bits() { "present" } else { "none" });
+ if msg.features.supports_data_loss_protect() { "supported" } else { "not supported"},
+ if msg.features.initial_routing_sync() { "requested" } else { "not requested" },
+ if msg.features.supports_upfront_shutdown_script() { "supported" } else { "not supported"},
+ if msg.features.supports_unknown_bits() { "present" } else { "none" },
+ if msg.features.supports_unknown_bits() { "present" } else { "none" });
- if msg.local_features.initial_routing_sync() {
+ if msg.features.initial_routing_sync() {
peer.sync_status = InitSyncTracker::ChannelsSyncing(0);
peers.peers_needing_send.insert(peer_descriptor.clone());
}
- peer.their_global_features = Some(msg.global_features);
- peer.their_local_features = Some(msg.local_features);
if !peer.outbound {
- let mut local_features = msgs::LocalFeatures::new();
+ let mut features = InitFeatures::supported();
if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND {
self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel);
- local_features.set_initial_routing_sync();
+ features.set_initial_routing_sync();
}
encode_and_send_msg!(msgs::Init {
- global_features: msgs::GlobalFeatures::new(),
- local_features,
+ features,
}, 16);
}
- self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap());
+ self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg);
+ peer.their_features = Some(msg.features);
},
17 => {
let msg = try_potential_decodeerror!(msgs::ErrorMessage::read(&mut reader));
// Channel control:
32 => {
let msg = try_potential_decodeerror!(msgs::OpenChannel::read(&mut reader));
- self.message_handler.chan_handler.handle_open_channel(&peer.their_node_id.unwrap(), peer.their_local_features.clone().unwrap(), &msg);
+ self.message_handler.chan_handler.handle_open_channel(&peer.their_node_id.unwrap(), peer.their_features.clone().unwrap(), &msg);
},
33 => {
let msg = try_potential_decodeerror!(msgs::AcceptChannel::read(&mut reader));
- self.message_handler.chan_handler.handle_accept_channel(&peer.their_node_id.unwrap(), peer.their_local_features.clone().unwrap(), &msg);
+ self.message_handler.chan_handler.handle_accept_channel(&peer.their_node_id.unwrap(), peer.their_features.clone().unwrap(), &msg);
},
34 => {
let mut events_generated = self.message_handler.chan_handler.get_and_clear_pending_msg_events();
let mut peers_lock = self.peers.lock().unwrap();
- let peers = peers_lock.borrow_parts();
+ let peers = &mut *peers_lock;
for event in events_generated.drain(..) {
macro_rules! get_peer_for_forwarding {
($node_id: expr, $handle_no_such_peer: block) => {
};
match peers.peers.get_mut(&descriptor) {
Some(peer) => {
- if peer.their_global_features.is_none() {
+ if peer.their_features.is_none() {
$handle_no_such_peer;
continue;
}
let encoded_update_msg = encode_msg!(update_msg, 258);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_global_features.is_none() ||
+ if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
!peer.should_forward_channel(msg.contents.short_channel_id) {
continue
}
let encoded_msg = encode_msg!(msg, 258);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_global_features.is_none() ||
+ if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
!peer.should_forward_channel(msg.contents.short_channel_id) {
continue
}
pub fn timer_tick_occured(&self) {
let mut peers_lock = self.peers.lock().unwrap();
{
- let peers = peers_lock.borrow_parts();
- let peers_needing_send = peers.peers_needing_send;
- let node_id_to_descriptor = peers.node_id_to_descriptor;
- let peers = peers.peers;
+ let peers = &mut *peers_lock;
+ let peers_needing_send = &mut peers.peers_needing_send;
+ let node_id_to_descriptor = &mut peers.node_id_to_descriptor;
+ let peers = &mut peers.peers;
peers.retain(|descriptor, peer| {
if peer.awaiting_pong == true {
projects / rust-lightning / blobdiff