@@ -39,12 +39,12 @@ use bitcoin::hashes::sha256::Hash as Sha256;
39
39
use bitcoin::hashes::sha256::HashEngine as Sha256Engine;
40
40
use bitcoin::hashes::{HashEngine, Hash};
41
41
use ln::peers::outbound_queue::OutboundQueue;
42
- use ln::peers::transport::Transport;
42
+ use ln::peers::transport::{PayloadQueuer, Transport} ;
43
43
44
44
const MSG_BUFF_SIZE: usize = 10;
45
45
46
- /// Interface PeerHandler uses to interact with the Transport object
47
- pub(super) trait ITransport {
46
+ /// Interface PeerManager uses to interact with the Transport object
47
+ pub(super) trait ITransport: MessageQueuer {
48
48
/// Instantiate the new outbound Transport
49
49
fn new_outbound(initiator_static_private_key: &SecretKey, responder_static_public_key: &PublicKey, initiator_ephemeral_private_key: &SecretKey) -> Self;
50
50
@@ -65,41 +65,16 @@ pub(super) trait ITransport {
65
65
66
66
/// Returns all Messages that have been received and can be parsed by the Transport
67
67
fn drain_messages<L: Deref>(&mut self, logger: L) -> Result<Vec<Message>, PeerHandleError> where L::Target: Logger;
68
+ }
68
69
70
+ /// Interface PeerManager uses to queue message to send. Used primarily to restrict the interface in
71
+ /// specific contexts. e.g. Only queueing during read_event(). No flushing allowed.
72
+ pub(super) trait MessageQueuer {
69
73
/// Encodes, encrypts, and enqueues a message to the outbound queue. Panics if the connection is
70
74
/// not established yet.
71
75
fn enqueue_message<M: Encode + Writeable, Q: PayloadQueuer, L: Deref>(&mut self, message: &M, output_buffer: &mut Q, logger: L) where L::Target: Logger;
72
76
}
73
77
74
-
75
- /// Trait representing a container that allows enqueuing of Vec<[u8]>
76
- pub(super) trait PayloadQueuer {
77
- /// Enqueue item to the queue
78
- fn push_back(&mut self, item: Vec<u8>);
79
-
80
- /// Returns true if the queue is empty
81
- fn is_empty(&self) -> bool;
82
-
83
- /// Returns the amount of available space in queue
84
- fn queue_space(&self) -> usize;
85
- }
86
-
87
- /// Implement &mut PayloadQueuer passthroughs
88
- impl<'a, T> PayloadQueuer for &'a mut T where
89
- T: PayloadQueuer {
90
- fn push_back(&mut self, item: Vec<u8>) {
91
- T::push_back(self, item)
92
- }
93
-
94
- fn is_empty(&self) -> bool {
95
- T::is_empty(self)
96
- }
97
-
98
- fn queue_space(&self) -> usize {
99
- T::queue_space(self)
100
- }
101
- }
102
-
103
78
/// Trait representing a container that can try to flush data through a SocketDescriptor
104
79
pub(super) trait SocketDescriptorFlusher {
105
80
/// Write previously enqueued data to the SocketDescriptor. A return of false indicates the
@@ -520,10 +495,10 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
520
495
521
496
fn do_attempt_write_data<Q: PayloadQueuer + SocketDescriptorFlusher>(
522
497
&self,
523
- descriptor: &mut Descriptor,
524
- sync_status: &mut InitSyncTracker,
525
- transport : &mut impl ITransport ,
526
- pending_outbound_buffer: &mut Q) {
498
+ descriptor: &mut Descriptor,
499
+ sync_status: &mut InitSyncTracker,
500
+ message_queuer : &mut impl MessageQueuer ,
501
+ pending_outbound_buffer: &mut Q) {
527
502
while !pending_outbound_buffer.is_blocked() {
528
503
let queue_space = pending_outbound_buffer.queue_space();
529
504
if queue_space > 0 {
@@ -533,12 +508,12 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
533
508
let steps = ((queue_space + 2) / 3) as u8;
534
509
let all_messages = self.message_handler.route_handler.get_next_channel_announcements(c, steps);
535
510
for &(ref announce, ref update_a_option, ref update_b_option) in all_messages.iter() {
536
- transport .enqueue_message(announce, pending_outbound_buffer, &*self.logger);
511
+ message_queuer .enqueue_message(announce, pending_outbound_buffer, &*self.logger);
537
512
if let &Some(ref update_a) = update_a_option {
538
- transport .enqueue_message(update_a, pending_outbound_buffer, &*self.logger);
513
+ message_queuer .enqueue_message(update_a, pending_outbound_buffer, &*self.logger);
539
514
}
540
515
if let &Some(ref update_b) = update_b_option {
541
- transport .enqueue_message(update_b, pending_outbound_buffer, &*self.logger);
516
+ message_queuer .enqueue_message(update_b, pending_outbound_buffer, &*self.logger);
542
517
}
543
518
*sync_status = InitSyncTracker::ChannelsSyncing(announce.contents.short_channel_id + 1);
544
519
}
@@ -550,7 +525,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
550
525
let steps = queue_space as u8;
551
526
let all_messages = self.message_handler.route_handler.get_next_node_announcements(None, steps);
552
527
for msg in all_messages.iter() {
553
- transport .enqueue_message(msg, pending_outbound_buffer, &*self.logger);
528
+ message_queuer .enqueue_message(msg, pending_outbound_buffer, &*self.logger);
554
529
*sync_status = InitSyncTracker::NodesSyncing(msg.contents.node_id);
555
530
}
556
531
if all_messages.is_empty() || all_messages.len() != steps as usize {
@@ -562,7 +537,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
562
537
let steps = queue_space as u8;
563
538
let all_messages = self.message_handler.route_handler.get_next_node_announcements(Some(&key), steps);
564
539
for msg in all_messages.iter() {
565
- transport .enqueue_message(msg, pending_outbound_buffer, &*self.logger);
540
+ message_queuer .enqueue_message(msg, pending_outbound_buffer, &*self.logger);
566
541
*sync_status = InitSyncTracker::NodesSyncing(msg.contents.node_id);
567
542
}
568
543
if all_messages.is_empty() || all_messages.len() != steps as usize {
@@ -613,8 +588,8 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
613
588
}
614
589
615
590
/// Append a message to a peer's pending outbound/write buffer, and update the map of peers needing sends accordingly.
616
- fn enqueue_message<M: Encode + Writeable>(&self, peers_needing_send: &mut HashSet<Descriptor>, transport : &mut impl ITransport , output_buffer: &mut impl PayloadQueuer, descriptor: &Descriptor, message: &M) {
617
- transport .enqueue_message(message, output_buffer, &*self.logger);
591
+ fn enqueue_message<M: Encode + Writeable>(&self, peers_needing_send: &mut HashSet<Descriptor>, message_queuer : &mut impl MessageQueuer , output_buffer: &mut impl PayloadQueuer, descriptor: &Descriptor, message: &M) {
592
+ message_queuer .enqueue_message(message, output_buffer, &*self.logger);
618
593
peers_needing_send.insert(descriptor.clone());
619
594
}
620
595
@@ -705,7 +680,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
705
680
}
706
681
}
707
682
708
- if let Err(handling_error) = self.handle_message(peers_needing_send, peer_descriptor, message, outbound, sync_status, awaiting_pong, their_features, transport, pending_outbound_buffer) {
683
+ if let Err(handling_error) = self.handle_message(peers_needing_send, peer_descriptor, message, outbound, sync_status, awaiting_pong, their_features, transport.get_their_node_id(), transport , pending_outbound_buffer) {
709
684
match handling_error {
710
685
MessageHandlingError::PeerHandleError(e) => { return Err(e) },
711
686
MessageHandlingError::LightningError(e) => {
@@ -730,15 +705,16 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
730
705
sync_status: &mut InitSyncTracker,
731
706
awaiting_pong: &mut bool,
732
707
their_features: &mut Option<InitFeatures>,
733
- transport: &mut impl ITransport,
708
+ their_node_id: PublicKey,
709
+ message_queuer: &mut impl MessageQueuer,
734
710
pending_outbound_buffer: &mut impl PayloadQueuer
735
711
) -> Result<(), MessageHandlingError> {
736
- log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(transport.get_their_node_id() ));
712
+ log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(&their_node_id ));
737
713
738
714
// Need an Init as first message
739
715
if let wire::Message::Init(_) = message {
740
716
} else if their_features.is_none() {
741
- log_trace!(self.logger, "Peer {} sent non-Init first message", log_pubkey!(transport.get_their_node_id() ));
717
+ log_trace!(self.logger, "Peer {} sent non-Init first message", log_pubkey!(&their_node_id ));
742
718
return Err(PeerHandleError{ no_connection_possible: false }.into());
743
719
}
744
720
@@ -771,21 +747,21 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
771
747
peers_needing_send.insert(peer_descriptor.clone());
772
748
}
773
749
if !msg.features.supports_static_remote_key() {
774
- log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(transport.get_their_node_id() ));
750
+ log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(&their_node_id ));
775
751
return Err(PeerHandleError{ no_connection_possible: true }.into());
776
752
}
777
753
778
754
if !outbound {
779
755
let mut features = InitFeatures::known();
780
- if !self.message_handler.route_handler.should_request_full_sync(&transport.get_their_node_id() ) {
756
+ if !self.message_handler.route_handler.should_request_full_sync(&their_node_id ) {
781
757
features.clear_initial_routing_sync();
782
758
}
783
759
784
760
let resp = msgs::Init { features };
785
- self.enqueue_message(peers_needing_send, transport , pending_outbound_buffer, &peer_descriptor, &resp);
761
+ self.enqueue_message(peers_needing_send, message_queuer , pending_outbound_buffer, &peer_descriptor, &resp);
786
762
}
787
763
788
- self.message_handler.chan_handler.peer_connected(&transport.get_their_node_id() , &msg);
764
+ self.message_handler.chan_handler.peer_connected(&their_node_id , &msg);
789
765
*their_features = Some(msg.features);
790
766
},
791
767
wire::Message::Error(msg) => {
@@ -798,11 +774,11 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
798
774
}
799
775
800
776
if data_is_printable {
801
- log_debug!(self.logger, "Got Err message from {}: {}", log_pubkey!(transport.get_their_node_id() ), msg.data);
777
+ log_debug!(self.logger, "Got Err message from {}: {}", log_pubkey!(&their_node_id ), msg.data);
802
778
} else {
803
- log_debug!(self.logger, "Got Err message from {} with non-ASCII error message", log_pubkey!(transport.get_their_node_id() ));
779
+ log_debug!(self.logger, "Got Err message from {} with non-ASCII error message", log_pubkey!(&their_node_id ));
804
780
}
805
- self.message_handler.chan_handler.handle_error(&transport.get_their_node_id() , &msg);
781
+ self.message_handler.chan_handler.handle_error(&their_node_id , &msg);
806
782
if msg.channel_id == [0; 32] {
807
783
return Err(PeerHandleError{ no_connection_possible: true }.into());
808
784
}
@@ -811,7 +787,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
811
787
wire::Message::Ping(msg) => {
812
788
if msg.ponglen < 65532 {
813
789
let resp = msgs::Pong { byteslen: msg.ponglen };
814
- self.enqueue_message(peers_needing_send, transport , pending_outbound_buffer, &peer_descriptor, &resp);
790
+ self.enqueue_message(peers_needing_send, message_queuer , pending_outbound_buffer, &peer_descriptor, &resp);
815
791
}
816
792
},
817
793
wire::Message::Pong(_msg) => {
@@ -820,59 +796,59 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, L: Deref, TransportImpl
820
796
821
797
// Channel messages:
822
798
wire::Message::OpenChannel(msg) => {
823
- self.message_handler.chan_handler.handle_open_channel(&transport.get_their_node_id() , their_features.clone().unwrap(), &msg);
799
+ self.message_handler.chan_handler.handle_open_channel(&their_node_id , their_features.clone().unwrap(), &msg);
824
800
},
825
801
wire::Message::AcceptChannel(msg) => {
826
- self.message_handler.chan_handler.handle_accept_channel(&transport.get_their_node_id() , their_features.clone().unwrap(), &msg);
802
+ self.message_handler.chan_handler.handle_accept_channel(&their_node_id , their_features.clone().unwrap(), &msg);
827
803
},
828
804
829
805
wire::Message::FundingCreated(msg) => {
830
- self.message_handler.chan_handler.handle_funding_created(&transport.get_their_node_id() , &msg);
806
+ self.message_handler.chan_handler.handle_funding_created(&their_node_id , &msg);
831
807
},
832
808
wire::Message::FundingSigned(msg) => {
833
- self.message_handler.chan_handler.handle_funding_signed(&transport.get_their_node_id() , &msg);
809
+ self.message_handler.chan_handler.handle_funding_signed(&their_node_id , &msg);
834
810
},
835
811
wire::Message::FundingLocked(msg) => {
836
- self.message_handler.chan_handler.handle_funding_locked(&transport.get_their_node_id() , &msg);
812
+ self.message_handler.chan_handler.handle_funding_locked(&their_node_id , &msg);
837
813
},
838
814
839
815
wire::Message::Shutdown(msg) => {
840
- self.message_handler.chan_handler.handle_shutdown(&transport.get_their_node_id() , &msg);
816
+ self.message_handler.chan_handler.handle_shutdown(&their_node_id , &msg);
841
817
},
842
818
wire::Message::ClosingSigned(msg) => {
843
- self.message_handler.chan_handler.handle_closing_signed(&transport.get_their_node_id() , &msg);
819
+ self.message_handler.chan_handler.handle_closing_signed(&their_node_id , &msg);
844
820
},
845
821
846
822
// Commitment messages:
847
823
wire::Message::UpdateAddHTLC(msg) => {
848
- self.message_handler.chan_handler.handle_update_add_htlc(&transport.get_their_node_id() , &msg);
824
+ self.message_handler.chan_handler.handle_update_add_htlc(&their_node_id , &msg);
849
825
},
850
826
wire::Message::UpdateFulfillHTLC(msg) => {
851
- self.message_handler.chan_handler.handle_update_fulfill_htlc(&transport.get_their_node_id() , &msg);
827
+ self.message_handler.chan_handler.handle_update_fulfill_htlc(&their_node_id , &msg);
852
828
},
853
829
wire::Message::UpdateFailHTLC(msg) => {
854
- self.message_handler.chan_handler.handle_update_fail_htlc(&transport.get_their_node_id() , &msg);
830
+ self.message_handler.chan_handler.handle_update_fail_htlc(&their_node_id , &msg);
855
831
},
856
832
wire::Message::UpdateFailMalformedHTLC(msg) => {
857
- self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&transport.get_their_node_id() , &msg);
833
+ self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&their_node_id , &msg);
858
834
},
859
835
860
836
wire::Message::CommitmentSigned(msg) => {
861
- self.message_handler.chan_handler.handle_commitment_signed(&transport.get_their_node_id() , &msg);
837
+ self.message_handler.chan_handler.handle_commitment_signed(&their_node_id , &msg);
862
838
},
863
839
wire::Message::RevokeAndACK(msg) => {
864
- self.message_handler.chan_handler.handle_revoke_and_ack(&transport.get_their_node_id() , &msg);
840
+ self.message_handler.chan_handler.handle_revoke_and_ack(&their_node_id , &msg);
865
841
},
866
842
wire::Message::UpdateFee(msg) => {
867
- self.message_handler.chan_handler.handle_update_fee(&transport.get_their_node_id() , &msg);
843
+ self.message_handler.chan_handler.handle_update_fee(&their_node_id , &msg);
868
844
},
869
845
wire::Message::ChannelReestablish(msg) => {
870
- self.message_handler.chan_handler.handle_channel_reestablish(&transport.get_their_node_id() , &msg);
846
+ self.message_handler.chan_handler.handle_channel_reestablish(&their_node_id , &msg);
871
847
},
872
848
873
849
// Routing messages:
874
850
wire::Message::AnnouncementSignatures(msg) => {
875
- self.message_handler.chan_handler.handle_announcement_signatures(&transport.get_their_node_id() , &msg);
851
+ self.message_handler.chan_handler.handle_announcement_signatures(&their_node_id , &msg);
876
852
},
877
853
wire::Message::ChannelAnnouncement(msg) => {
878
854
let should_forward = match self.message_handler.route_handler.handle_channel_announcement(&msg) {
0 commit comments