fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &msgs::ChannelReestablish) {
ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id);
}
+ // msgs::ChannelUpdate does not contain the channel_id field, so we just drop them.
+ fn handle_channel_update(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelUpdate) {}
fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {}
fn peer_connected(&self, _their_node_id: &PublicKey, _msg: &msgs::Init) {}
fn handle_error(&self, _their_node_id: &PublicKey, _msg: &msgs::ErrorMessage) {}
struct Peer {
channel_encryptor: PeerChannelEncryptor,
- outbound: bool,
their_node_id: Option<PublicKey>,
their_features: Option<InitFeatures>,
let mut peers = self.peers.lock().unwrap();
if peers.peers.insert(descriptor, Peer {
channel_encryptor: peer_encryptor,
- outbound: true,
their_node_id: None,
their_features: None,
let mut peers = self.peers.lock().unwrap();
if peers.peers.insert(descriptor, Peer {
channel_encryptor: peer_encryptor,
- outbound: false,
their_node_id: None,
their_features: None,
peer.pending_read_is_header = true;
peer.their_node_id = Some(their_node_id);
insert_node_id!();
+ let features = InitFeatures::known();
+ let resp = msgs::Init { features };
+ self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &resp);
},
NextNoiseStep::NoiseComplete => {
if peer.pending_read_is_header {
return Err(PeerHandleError{ no_connection_possible: true }.into());
}
- if !peer.outbound {
- let features = InitFeatures::known();
- let resp = msgs::Init { features };
- self.enqueue_message(peers_needing_send, peer, peer_descriptor.clone(), &resp);
- }
-
self.message_handler.route_handler.sync_routing_table(&peer.their_node_id.unwrap(), &msg);
self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg);
}
},
wire::Message::ChannelUpdate(msg) => {
+ self.message_handler.chan_handler.handle_channel_update(&peer.their_node_id.unwrap(), &msg);
let should_forward = match self.message_handler.route_handler.handle_channel_update(&msg) {
Ok(v) => v,
Err(e) => { return Err(e.into()); },
// buffer by doing things like announcing channels on another node. We should be willing to
// drop optional-ish messages when send buffers get full!
+ let mut peers_lock = self.peers.lock().unwrap();
let mut events_generated = self.message_handler.chan_handler.get_and_clear_pending_msg_events();
events_generated.append(&mut self.message_handler.route_handler.get_and_clear_pending_msg_events());
- let mut peers_lock = self.peers.lock().unwrap();
let peers = &mut *peers_lock;
for event in events_generated.drain(..) {
macro_rules! get_peer_for_forwarding {