X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=rust-lightning;a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=c02e351bef3bc1169d6cdfffb054e6ef611d51f9;hp=dc3c37c41fc3abeda9afdbce193147aba01beb4e;hb=2ce646f575b2f81e4f0f56a4ca0f11551866279e;hpb=d4ad57b7e65f206bc40989eaef7ce2efe9428935

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index dc3c37c4..c02e351b 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -12,7 +12,7 @@ use ln::features::InitFeatures;
 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;
@@ -151,6 +151,12 @@ impl Peer {
 	}
 }
 
+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
@@ -158,6 +164,7 @@ struct PeerHolder<Descriptor: SocketDescriptor> {
 	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")))]
@@ -226,7 +233,8 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 			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,
@@ -459,6 +467,17 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 		}
 	}
 
+	/// 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();
@@ -481,16 +500,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 						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 {
@@ -508,7 +517,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 												},
 												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;
 												},
 											}
@@ -554,7 +563,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 									}
 
 									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[..]));
@@ -653,7 +662,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 													}
 
 													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);
@@ -682,7 +691,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 											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) => {
@@ -749,21 +758,21 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 												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)));
 												}
 											},
 
@@ -807,6 +816,54 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 			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) => {
@@ -969,24 +1026,10 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 						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 } => {
@@ -994,14 +1037,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 						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 } => {
@@ -1009,14 +1047,8 @@ impl<Descriptor: SocketDescriptor, CM: Deref, L: Deref> PeerManager<Descriptor,
 						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 } => {