use ln::msgs;
use ln::msgs::ChannelMessageHandler;
use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
-use util::ser::VecWriter;
+use util::ser::{VecWriter, Writeable};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use ln::wire;
use ln::wire::Encode;
}
}
+enum AnnouncementMsg {
+ ChanUpdate(msgs::ChannelUpdate),
+ ChanAnnounce(msgs::ChannelAnnouncement),
+ NodeAnnounce(msgs::NodeAnnouncement),
+}
+
struct PeerHolder<Descriptor: SocketDescriptor> {
peers: HashMap<Descriptor, Peer>,
/// Added to by do_read_event for cases where we pushed a message onto the send buffer but
peers_needing_send: HashSet<Descriptor>,
/// Only add to this set when noise completes:
node_id_to_descriptor: HashMap<PublicKey, Descriptor>,
+ pending_broadcasts: Vec<(PublicKey, AnnouncementMsg)>,
}
#[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))]
peers: Mutex::new(PeerHolder {
peers: HashMap::new(),
peers_needing_send: HashSet::new(),
- node_id_to_descriptor: HashMap::new()
+ node_id_to_descriptor: HashMap::new(),
+ pending_broadcasts: Vec::new(),
}),
our_node_secret,
ephemeral_key_midstate,
}
}
+ /// Append a message to a peer's pending outbound/write buffer, and update the map of peers needing sends accordingly.
+ fn enqueue_message<M: Encode + Writeable>(&self, peers_needing_send: &mut HashSet<Descriptor>, peer: &mut Peer, descriptor: Descriptor, message: &M) {
+ let mut buffer = VecWriter(Vec::new());
+ wire::write(message, &mut buffer).unwrap(); // crash if the write failed
+ let encoded_message = buffer.0;
+
+ log_trace!(self.logger, "Enqueueing message of type {} to {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
+ peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_message[..]));
+ peers_needing_send.insert(descriptor);
+ }
+
fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result<bool, PeerHandleError> {
let pause_read = {
let mut peers_lock = self.peers.lock().unwrap();
if peer.pending_read_buffer_pos == peer.pending_read_buffer.len() {
peer.pending_read_buffer_pos = 0;
- macro_rules! encode_and_send_msg {
- ($msg: expr) => {
- {
- log_trace!(self.logger, "Encoding and sending message of type {} to {}", $msg.type_id(), log_pubkey!(peer.their_node_id.unwrap()));
- peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(&$msg)[..]));
- peers.peers_needing_send.insert(peer_descriptor.clone());
- }
- }
- }
-
macro_rules! try_potential_handleerror {
($thing: expr) => {
match $thing {
},
msgs::ErrorAction::SendErrorMessage { msg } => {
log_trace!(self.logger, "Got Err handling message, sending Error message because {}", e.err);
- encode_and_send_msg!(msg);
+ self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &msg);
continue;
},
}
}
let resp = msgs::Init { features };
- encode_and_send_msg!(resp);
+ self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
},
NextNoiseStep::ActThree => {
let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..]));
}
let resp = msgs::Init { features };
- encode_and_send_msg!(resp);
+ self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
}
self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg);
wire::Message::Ping(msg) => {
if msg.ponglen < 65532 {
let resp = msgs::Pong { byteslen: msg.ponglen };
- encode_and_send_msg!(resp);
+ self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
}
},
wire::Message::Pong(_msg) => {
let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_announcement(&msg));
if should_forward {
- // TODO: forward msg along to all our other peers!
+ peers.pending_broadcasts.push((peer.their_node_id.unwrap().clone(), AnnouncementMsg::ChanAnnounce(msg)));
}
},
wire::Message::NodeAnnouncement(msg) => {
let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_node_announcement(&msg));
if should_forward {
- // TODO: forward msg along to all our other peers!
+ peers.pending_broadcasts.push((peer.their_node_id.unwrap().clone(), AnnouncementMsg::NodeAnnounce(msg)));
}
},
wire::Message::ChannelUpdate(msg) => {
let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg));
if should_forward {
- // TODO: forward msg along to all our other peers!
+ peers.pending_broadcasts.push((peer.their_node_id.unwrap().clone(), AnnouncementMsg::ChanUpdate(msg)));
}
},
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 = &mut *peers_lock;
+
+ macro_rules! broadcast_msgs {
+ ({ $($except_check: stmt), * }, { $($encoded_msg: expr), * }) => { {
+ for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
+ if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() {
+ continue
+ }
+ match peer.their_node_id {
+ None => continue,
+ Some(their_node_id) => {
+ $(
+ if { $except_check }(&peer, their_node_id) { continue }
+ )*
+ }
+ }
+ $(peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&$encoded_msg));)*
+ self.do_attempt_write_data(&mut (*descriptor).clone(), peer);
+ }
+ } }
+ }
+
+ for (from_node_id, broadcast) in peers.pending_broadcasts.drain(..) {
+ match broadcast {
+ AnnouncementMsg::ChanUpdate(msg) => {
+ let encoded_msg = encode_msg!(&msg);
+ broadcast_msgs!({ |peer: & &mut Peer, _| !peer.should_forward_channel_announcement(msg.contents.short_channel_id),
+ |_, their_node_id| their_node_id == from_node_id },
+ { encoded_msg });
+ },
+ AnnouncementMsg::ChanAnnounce(msg) => {
+ let encoded_msg = encode_msg!(&msg);
+ broadcast_msgs!({ |peer: & &mut Peer, _| !peer.should_forward_channel_announcement(msg.contents.short_channel_id),
+ |_, their_node_id| their_node_id == msg.contents.node_id_1,
+ |_, their_node_id| their_node_id == msg.contents.node_id_2,
+ |_, their_node_id| their_node_id == from_node_id },
+ { encoded_msg });
+ },
+ AnnouncementMsg::NodeAnnounce(msg) => {
+ let encoded_msg = encode_msg!(&msg);
+
+ broadcast_msgs!({ |peer: & &mut Peer, _| !peer.should_forward_node_announcement(msg.contents.node_id),
+ |_, their_node_id| their_node_id == msg.contents.node_id,
+ |_, their_node_id| their_node_id == from_node_id },
+ { encoded_msg });
+ }
+ }
+ }
+
for event in events_generated.drain(..) {
macro_rules! get_peer_for_forwarding {
($node_id: expr, $handle_no_such_peer: block) => {
if self.message_handler.route_handler.handle_channel_announcement(msg).is_ok() && self.message_handler.route_handler.handle_channel_update(update_msg).is_ok() {
let encoded_msg = encode_msg!(msg);
let encoded_update_msg = encode_msg!(update_msg);
-
- for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
- !peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
- continue
- }
- match peer.their_node_id {
- None => continue,
- Some(their_node_id) => {
- if their_node_id == msg.contents.node_id_1 || their_node_id == msg.contents.node_id_2 {
- continue
- }
- }
- }
- peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
- peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_update_msg[..]));
- self.do_attempt_write_data(&mut (*descriptor).clone(), peer);
- }
+ broadcast_msgs!({ |peer: & &mut Peer, _| !peer.should_forward_channel_announcement(msg.contents.short_channel_id),
+ |_, their_node_id| their_node_id == msg.contents.node_id_1,
+ |_, their_node_id| their_node_id == msg.contents.node_id_2 },
+ { encoded_msg, encoded_update_msg });
}
},
MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
if self.message_handler.route_handler.handle_node_announcement(msg).is_ok() {
let encoded_msg = encode_msg!(msg);
- for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
- !peer.should_forward_node_announcement(msg.contents.node_id) {
- continue
- }
- peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
- self.do_attempt_write_data(&mut (*descriptor).clone(), peer);
- }
+ broadcast_msgs!({ |peer: & &mut Peer, _| !peer.should_forward_node_announcement(msg.contents.node_id),
+ |_, their_node_id| their_node_id == msg.contents.node_id },
+ { encoded_msg });
}
},
MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
if self.message_handler.route_handler.handle_channel_update(msg).is_ok() {
let encoded_msg = encode_msg!(msg);
- for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() ||
- !peer.should_forward_channel_announcement(msg.contents.short_channel_id) {
- continue
- }
- peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
- self.do_attempt_write_data(&mut (*descriptor).clone(), peer);
- }
+ broadcast_msgs!({ |peer: & &mut Peer, _| !peer.should_forward_channel_announcement(msg.contents.short_channel_id) },
+ { encoded_msg });
}
},
MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => {