X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fonion_message%2Fmessenger.rs;h=e38a0d10f6aef42a840c9781beaa2bc540775133;hb=66011920bca3fc7aaf418734435f550ad81d7d9d;hp=b9da9246cb103bcf44eb82050bd5870f45521ae5;hpb=b9b02b48fb4dd66181f61739fa0047c29dead697;p=rust-lightning

diff --git a/lightning/src/onion_message/messenger.rs b/lightning/src/onion_message/messenger.rs
index b9da9246..e38a0d10 100644
--- a/lightning/src/onion_message/messenger.rs
+++ b/lightning/src/onion_message/messenger.rs
@@ -23,6 +23,7 @@ use super::packet::{BIG_PACKET_HOP_DATA_LEN, ForwardControlTlvs, Packet, Payload
 use super::utils;
 use util::events::OnionMessageProvider;
 use util::logger::Logger;
+use util::ser::Writeable;
 
 use core::ops::Deref;
 use sync::{Arc, Mutex};
@@ -124,6 +125,8 @@ pub enum SendError {
 	TooFewBlindedHops,
 	/// Our next-hop peer was offline or does not support onion message forwarding.
 	InvalidFirstHop,
+	/// Our next-hop peer's buffer was full or our total outbound buffer was full.
+	BufferFull,
 }
 
 impl<Signer: Sign, K: Deref, L: Deref> OnionMessenger<Signer, K, L>
@@ -171,6 +174,7 @@ impl<Signer: Sign, K: Deref, L: Deref> OnionMessenger<Signer, K, L>
 			packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?;
 
 		let mut pending_per_peer_msgs = self.pending_messages.lock().unwrap();
+		if outbound_buffer_full(&introduction_node_id, &pending_per_peer_msgs) { return Err(SendError::BufferFull) }
 		match pending_per_peer_msgs.entry(introduction_node_id) {
 			hash_map::Entry::Vacant(_) => Err(SendError::InvalidFirstHop),
 			hash_map::Entry::Occupied(mut e) => {
@@ -193,6 +197,29 @@ impl<Signer: Sign, K: Deref, L: Deref> OnionMessenger<Signer, K, L>
 	}
 }
 
+fn outbound_buffer_full(peer_node_id: &PublicKey, buffer: &HashMap<PublicKey, VecDeque<msgs::OnionMessage>>) -> bool {
+	const MAX_TOTAL_BUFFER_SIZE: usize = (1 << 20) * 128;
+	const MAX_PER_PEER_BUFFER_SIZE: usize = (1 << 10) * 256;
+	let mut total_buffered_bytes = 0;
+	let mut peer_buffered_bytes = 0;
+	for (pk, peer_buf) in buffer {
+		for om in peer_buf {
+			let om_len = om.serialized_length();
+			if pk == peer_node_id {
+				peer_buffered_bytes += om_len;
+			}
+			total_buffered_bytes += om_len;
+
+			if total_buffered_bytes >= MAX_TOTAL_BUFFER_SIZE ||
+				peer_buffered_bytes >= MAX_PER_PEER_BUFFER_SIZE
+			{
+				return true
+			}
+		}
+	}
+	false
+}
+
 impl<Signer: Sign, K: Deref, L: Deref> OnionMessageHandler for OnionMessenger<Signer, K, L>
 	where K::Target: KeysInterface<Signer = Signer>,
 	      L::Target: Logger,
@@ -255,8 +282,34 @@ impl<Signer: Sign, K: Deref, L: Deref> OnionMessageHandler for OnionMessenger<Si
 					hop_data: new_packet_bytes,
 					hmac: next_hop_hmac,
 				};
+				let onion_message = msgs::OnionMessage {
+					blinding_point: match next_blinding_override {
+						Some(blinding_point) => blinding_point,
+						None => {
+							let blinding_factor = {
+								let mut sha = Sha256::engine();
+								sha.input(&msg.blinding_point.serialize()[..]);
+								sha.input(control_tlvs_ss.as_ref());
+								Sha256::from_engine(sha).into_inner()
+							};
+							let next_blinding_point = msg.blinding_point;
+							match next_blinding_point.mul_tweak(&self.secp_ctx, &Scalar::from_be_bytes(blinding_factor).unwrap()) {
+								Ok(bp) => bp,
+								Err(e) => {
+									log_trace!(self.logger, "Failed to compute next blinding point: {}", e);
+									return
+								}
+							}
+						},
+					},
+					onion_routing_packet: outgoing_packet,
+				};
 
 				let mut pending_per_peer_msgs = self.pending_messages.lock().unwrap();
+				if outbound_buffer_full(&next_node_id, &pending_per_peer_msgs) {
+					log_trace!(self.logger, "Dropping forwarded onion message to peer {:?}: outbound buffer full", next_node_id);
+					return
+				}
 
 				#[cfg(fuzzing)]
 				pending_per_peer_msgs.entry(next_node_id).or_insert_with(VecDeque::new);
@@ -267,30 +320,7 @@ impl<Signer: Sign, K: Deref, L: Deref> OnionMessageHandler for OnionMessenger<Si
 						return
 					},
 					hash_map::Entry::Occupied(mut e) => {
-						e.get_mut().push_back(
-							msgs::OnionMessage {
-								blinding_point: match next_blinding_override {
-									Some(blinding_point) => blinding_point,
-									None => {
-										let blinding_factor = {
-											let mut sha = Sha256::engine();
-											sha.input(&msg.blinding_point.serialize()[..]);
-											sha.input(control_tlvs_ss.as_ref());
-											Sha256::from_engine(sha).into_inner()
-										};
-										let next_blinding_point = msg.blinding_point;
-										match next_blinding_point.mul_tweak(&self.secp_ctx, &Scalar::from_be_bytes(blinding_factor).unwrap()) {
-											Ok(bp) => bp,
-											Err(e) => {
-												log_trace!(self.logger, "Failed to compute next blinding point: {}", e);
-												return
-											}
-										}
-									},
-								},
-								onion_routing_packet: outgoing_packet,
-							},
-						);
+						e.get_mut().push_back(onion_message);
 						log_trace!(self.logger, "Forwarding an onion message to peer {}", next_node_id);
 					}
 				};