mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-25 07:17:40 +01:00
Code Issues Projects Releases Packages Wiki Activity

migrate peer_handler to use Writeable

Browse source 
added inplace byte_utils
This commit is contained in:
Yuntai Kyong 2018-09-10 16:13:26 +09:00 • committed by Matt Corallo
parent 63cb37d346
commit 3e89106163
1 changed files with 33 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/ln/peer_handler.rs
View file

@ -1,7 +1,7 @@
use secp256k1::key::{SecretKey,PublicKey}; use secp256k1::key::{SecretKey,PublicKey};
use ln::msgs; use ln::msgs;
use ln::msgs::{MsgEncodable,MsgDecodable}; use util::ser::{Writer, Reader, Writeable, Readable};
use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep}; use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
use util::byte_utils; use util::byte_utils;
use util::events::{EventsProvider,Event}; use util::events::{EventsProvider,Event};
@ -113,15 +113,15 @@ pub struct PeerManager<Descriptor: SocketDescriptor> {
} }
macro_rules! encode_msg { macro_rules! encode_msg {
($msg: expr, $msg_code: expr) => { ($msg: expr, $msg_code: expr) => {{
{ let mut w = Writer::new(::std::io::Cursor::new(vec![]));
let just_msg = $msg.encode(); 0u16.write(&mut w).unwrap();
let mut encoded_msg = Vec::with_capacity(just_msg.len() + 2); $msg.write(&mut w).unwrap();
encoded_msg.extend_from_slice(&byte_utils::be16_to_array($msg_code)); let mut msg = w.into_inner().into_inner();
encoded_msg.extend_from_slice(&just_msg[..]); let len = msg.len();
encoded_msg msg[..2].copy_from_slice(&byte_utils::be16_to_array(len as u16 - 2));
} msg
} }}
} }
//TODO: Really should do something smarter for this //TODO: Really should do something smarter for this
@ -365,7 +365,6 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError{ no_connection_possible: false }), msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError{ no_connection_possible: false }),
msgs::DecodeError::Io(_) => return Err(PeerHandleError{ no_connection_possible: false }), msgs::DecodeError::Io(_) => return Err(PeerHandleError{ no_connection_possible: false }),
msgs::DecodeError::InvalidValue => return Err(PeerHandleError{ no_connection_possible: false }), msgs::DecodeError::InvalidValue => return Err(PeerHandleError{ no_connection_possible: false }),
msgs::DecodeError::InvalidLength => return Err(PeerHandleError{ no_connection_possible: false }),
} }
} }
}; };
@ -438,10 +437,11 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
// Need an init message as first message // Need an init message as first message
return Err(PeerHandleError{ no_connection_possible: false }); return Err(PeerHandleError{ no_connection_possible: false });
} }
let mut reader = Reader::new(::std::io::Cursor::new(&msg_data[2..]));
match msg_type { match msg_type {
// Connection control: // Connection control:
16 => { 16 => {
let msg = try_potential_decodeerror!(msgs::Init::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::Init::read(&mut reader));
if msg.global_features.requires_unknown_bits() { if msg.global_features.requires_unknown_bits() {
return Err(PeerHandleError{ no_connection_possible: true }); return Err(PeerHandleError{ no_connection_possible: true });
} }
@ -467,7 +467,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
} }
}, },
17 => { 17 => {
let msg = try_potential_decodeerror!(msgs::ErrorMessage::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::ErrorMessage::read(&mut reader));
let mut data_is_printable = true; let mut data_is_printable = true;
for b in msg.data.bytes() { for b in msg.data.bytes() {
if b < 32 || b > 126 { if b < 32 || b > 126 {
@ -488,38 +488,38 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
}, },
18 => { 18 => {
let msg = try_potential_decodeerror!(msgs::Ping::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::Ping::read(&mut reader));
if msg.ponglen < 65532 { if msg.ponglen < 65532 {
let resp = msgs::Pong { byteslen: msg.ponglen }; let resp = msgs::Pong { byteslen: msg.ponglen };
encode_and_send_msg!(resp, 19); encode_and_send_msg!(resp, 19);
} }
}, },
19 => { 19 => {
try_potential_decodeerror!(msgs::Pong::decode(&msg_data[2..])); try_potential_decodeerror!(msgs::Pong::read(&mut reader));
}, },
// Channel control: // Channel control:
32 => { 32 => {
let msg = try_potential_decodeerror!(msgs::OpenChannel::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::OpenChannel::read(&mut reader));
let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_open_channel(&peer.their_node_id.unwrap(), &msg)); let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_open_channel(&peer.their_node_id.unwrap(), &msg));
encode_and_send_msg!(resp, 33); encode_and_send_msg!(resp, 33);
}, },
33 => { 33 => {
let msg = try_potential_decodeerror!(msgs::AcceptChannel::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::AcceptChannel::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_accept_channel(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_accept_channel(&peer.their_node_id.unwrap(), &msg));
}, },
34 => { 34 => {
let msg = try_potential_decodeerror!(msgs::FundingCreated::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::FundingCreated::read(&mut reader));
let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_created(&peer.their_node_id.unwrap(), &msg)); let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_created(&peer.their_node_id.unwrap(), &msg));
encode_and_send_msg!(resp, 35); encode_and_send_msg!(resp, 35);
}, },
35 => { 35 => {
let msg = try_potential_decodeerror!(msgs::FundingSigned::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::FundingSigned::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_signed(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_signed(&peer.their_node_id.unwrap(), &msg));
}, },
36 => { 36 => {
let msg = try_potential_decodeerror!(msgs::FundingLocked::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::FundingLocked::read(&mut reader));
let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_locked(&peer.their_node_id.unwrap(), &msg)); let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_locked(&peer.their_node_id.unwrap(), &msg));
match resp_option { match resp_option {
Some(resp) => encode_and_send_msg!(resp, 259), Some(resp) => encode_and_send_msg!(resp, 259),
@ -528,7 +528,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
}, },
38 => { 38 => {
let msg = try_potential_decodeerror!(msgs::Shutdown::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::Shutdown::read(&mut reader));
let resp_options = try_potential_handleerror!(self.message_handler.chan_handler.handle_shutdown(&peer.their_node_id.unwrap(), &msg)); let resp_options = try_potential_handleerror!(self.message_handler.chan_handler.handle_shutdown(&peer.their_node_id.unwrap(), &msg));
if let Some(resp) = resp_options.0 { if let Some(resp) = resp_options.0 {
encode_and_send_msg!(resp, 38); encode_and_send_msg!(resp, 38);
@ -538,7 +538,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
} }
}, },
39 => { 39 => {
let msg = try_potential_decodeerror!(msgs::ClosingSigned::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::ClosingSigned::read(&mut reader));
let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_closing_signed(&peer.their_node_id.unwrap(), &msg)); let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_closing_signed(&peer.their_node_id.unwrap(), &msg));
if let Some(resp) = resp_option { if let Some(resp) = resp_option {
encode_and_send_msg!(resp, 39); encode_and_send_msg!(resp, 39);
@ -546,27 +546,27 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
}, },
128 => { 128 => {
let msg = try_potential_decodeerror!(msgs::UpdateAddHTLC::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::UpdateAddHTLC::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_update_add_htlc(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_add_htlc(&peer.their_node_id.unwrap(), &msg));
}, },
130 => { 130 => {
let msg = try_potential_decodeerror!(msgs::UpdateFulfillHTLC::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::UpdateFulfillHTLC::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fulfill_htlc(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fulfill_htlc(&peer.their_node_id.unwrap(), &msg));
}, },
131 => { 131 => {
let msg = try_potential_decodeerror!(msgs::UpdateFailHTLC::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::UpdateFailHTLC::read(&mut reader));
let chan_update = try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg)); let chan_update = try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg));
if let Some(update) = chan_update { if let Some(update) = chan_update {
self.message_handler.route_handler.handle_htlc_fail_channel_update(&update); self.message_handler.route_handler.handle_htlc_fail_channel_update(&update);
} }
}, },
135 => { 135 => {
let msg = try_potential_decodeerror!(msgs::UpdateFailMalformedHTLC::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::UpdateFailMalformedHTLC::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&peer.their_node_id.unwrap(), &msg));
}, },
132 => { 132 => {
let msg = try_potential_decodeerror!(msgs::CommitmentSigned::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::CommitmentSigned::read(&mut reader));
let resps = try_potential_handleerror!(self.message_handler.chan_handler.handle_commitment_signed(&peer.their_node_id.unwrap(), &msg)); let resps = try_potential_handleerror!(self.message_handler.chan_handler.handle_commitment_signed(&peer.their_node_id.unwrap(), &msg));
encode_and_send_msg!(resps.0, 133); encode_and_send_msg!(resps.0, 133);
if let Some(resp) = resps.1 { if let Some(resp) = resps.1 {
@ -574,7 +574,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
} }
}, },
133 => { 133 => {
let msg = try_potential_decodeerror!(msgs::RevokeAndACK::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::RevokeAndACK::read(&mut reader));
let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_revoke_and_ack(&peer.their_node_id.unwrap(), &msg)); let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_revoke_and_ack(&peer.their_node_id.unwrap(), &msg));
match resp_option { match resp_option {
Some(resps) => { Some(resps) => {
@ -593,18 +593,18 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
} }
}, },
134 => { 134 => {
let msg = try_potential_decodeerror!(msgs::UpdateFee::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::UpdateFee::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fee(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fee(&peer.their_node_id.unwrap(), &msg));
}, },
136 => { }, // TODO: channel_reestablish 136 => { }, // TODO: channel_reestablish
// Routing control: // Routing control:
259 => { 259 => {
let msg = try_potential_decodeerror!(msgs::AnnouncementSignatures::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::AnnouncementSignatures::read(&mut reader));
try_potential_handleerror!(self.message_handler.chan_handler.handle_announcement_signatures(&peer.their_node_id.unwrap(), &msg)); try_potential_handleerror!(self.message_handler.chan_handler.handle_announcement_signatures(&peer.their_node_id.unwrap(), &msg));
}, },
256 => { 256 => {
let msg = try_potential_decodeerror!(msgs::ChannelAnnouncement::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::ChannelAnnouncement::read(&mut reader));
let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_announcement(&msg)); let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_announcement(&msg));
if should_forward { if should_forward {
@ -612,7 +612,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
} }
}, },
257 => { 257 => {
let msg = try_potential_decodeerror!(msgs::NodeAnnouncement::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::NodeAnnouncement::read(&mut reader));
let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_node_announcement(&msg)); let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_node_announcement(&msg));
if should_forward { if should_forward {
@ -620,7 +620,7 @@ impl<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
} }
}, },
258 => { 258 => {
let msg = try_potential_decodeerror!(msgs::ChannelUpdate::decode(&msg_data[2..])); let msg = try_potential_decodeerror!(msgs::ChannelUpdate::read(&mut reader));
let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg)); let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg));
if should_forward { if should_forward {