Revert "[WIP]"

This reverts commit 2b892e6.

client/network/src/protocol/generic_proto/behaviour.rs

@@ -688,9 +688,7 @@ impl GenericProto {
 				self.events.push_back(NetworkBehaviourAction::NotifyHandler {
 					peer_id: occ_entry.key().clone(),
 					handler: NotifyHandler::All,
-					event: NotifsHandlerIn::Enable {
-						send_legacy_handshake: true,
-					},
+					event: NotifsHandlerIn::Enable,
 				});
 				*occ_entry.into_mut() = PeerState::Enabled { open };
 			},
@@ -709,9 +707,7 @@ impl GenericProto {
 				self.events.push_back(NetworkBehaviourAction::NotifyHandler {
 					peer_id: occ_entry.key().clone(),
 					handler: NotifyHandler::All,
-					event: NotifsHandlerIn::Enable {
-						send_legacy_handshake: true,
-					},
+					event: NotifsHandlerIn::Enable,
 				});
 				*occ_entry.into_mut() = PeerState::Enabled { open: SmallVec::new() };
 			},
@@ -831,9 +827,7 @@ impl GenericProto {
 				self.events.push_back(NetworkBehaviourAction::NotifyHandler {
 					peer_id: incoming.peer_id,
 					handler: NotifyHandler::All,
-					event: NotifsHandlerIn::Enable {
-						send_legacy_handshake: true,
-					},
+					event: NotifsHandlerIn::Enable,
 				});
 				*state = PeerState::Enabled { open: SmallVec::new() };
 			}
@@ -913,9 +907,7 @@ impl NetworkBehaviour for GenericProto {
 				self.events.push_back(NetworkBehaviourAction::NotifyHandler {
 					peer_id: peer_id.clone(),
 					handler: NotifyHandler::One(*conn),
-					event: NotifsHandlerIn::Enable {
-						send_legacy_handshake: true,
-					}
+					event: NotifsHandlerIn::Enable
 				});
 			}
 
@@ -975,9 +967,7 @@ impl NetworkBehaviour for GenericProto {
 				self.events.push_back(NetworkBehaviourAction::NotifyHandler {
 					peer_id: peer_id.clone(),
 					handler: NotifyHandler::One(*conn),
-					event: NotifsHandlerIn::Enable {
-						send_legacy_handshake: false,
-					}
+					event: NotifsHandlerIn::Enable
 				});
 			}
 
@@ -1419,15 +1409,11 @@ impl NetworkBehaviour for GenericProto {
 
 				PeerState::DisabledPendingEnable { timer, open, .. } if *timer == delay_id => {
 					debug!(target: "sub-libp2p", "Handler({:?}) <= Enable (ban expired)", peer_id);
-					for (index_in_open, open) in open.iter().enumerate() {
-						self.events.push_back(NetworkBehaviourAction::NotifyHandler {
-							peer_id: peer_id.clone(),
-							handler: NotifyHandler::One(*open),
-							event: NotifsHandlerIn::Enable {
-								send_legacy_handshake: index_in_open == 0,
-							},
-						});
-					}
+					self.events.push_back(NetworkBehaviourAction::NotifyHandler {
+						peer_id,
+						handler: NotifyHandler::All,
+						event: NotifsHandlerIn::Enable,
+					});
 					*peer_state = PeerState::Enabled { open: mem::replace(open, Default::default()) };
 				}
 

client/network/src/protocol/generic_proto/handler/group.rs

@@ -148,20 +148,7 @@ impl IntoProtocolsHandler for NotifsHandlerProto {
 #[derive(Debug, Clone)]
 pub enum NotifsHandlerIn {
 	/// The node should start using custom protocols.
-	Enable {
-		/// In the legacy protocol, the `Status` message (that serves as a handshake) is only ever
-		/// sent on the first substream that is open with a given peer. If a second substream with
-		/// that same peer is later opened (no matter whether it is on the same connection or a
-		/// different one), no `Status` message is sent.
-		///
-		/// This flag indicates whether or not this connection should send a `Status` message.
-		///
-		/// Note that this only concerns the `Status` message that our node sends out. Whatever
-		/// the value of this flag is, we should always propagate any `Status` sent by the remote,
-		/// and consider as successful the lack of `Status` message. If it the role of the upper
-		/// layers to properly enforce the uniqueness of the `Status` message sent by the remote.
-		send_legacy_handshake: bool,
-	},
+	Enable,
 
 	/// The node should stop using custom protocols.
 	Disable,
@@ -344,12 +331,12 @@ impl ProtocolsHandler for NotifsHandler {
 
 	fn inject_event(&mut self, message: NotifsHandlerIn) {
 		match message {
-			NotifsHandlerIn::Enable { send_legacy_handshake } => {
+			NotifsHandlerIn::Enable => {
 				if let EnabledState::Enabled = self.enabled {
 					debug!("enabling already-enabled handler");
 				}
 				self.enabled = EnabledState::Enabled;
-				self.legacy.inject_event(LegacyProtoHandlerIn::Enable { send_legacy_handshake });
+				self.legacy.inject_event(LegacyProtoHandlerIn::Enable);
 				for (handler, initial_message) in &mut self.out_handlers {
 					// We create `initial_message` on a separate line to be sure that the lock
 					// is released as soon as possible.

client/network/src/protocol/generic_proto/handler/legacy.rs

@@ -200,10 +200,7 @@ enum ProtocolState {
 #[derive(Debug)]
 pub enum LegacyProtoHandlerIn {
 	/// The node should start using custom protocols.
-	Enable {
-		/// See the documentation of this flag in the parent module.
-		send_legacy_handshake: bool,
-	},
+	Enable,
 
 	/// The node should stop using custom protocols.
 	Disable,
@@ -222,9 +219,8 @@ pub enum LegacyProtoHandlerOut {
 	CustomProtocolOpen {
 		/// Version of the protocol that has been opened.
 		version: u8,
-		/// First message that has been sent to us.
-		/// This can be a "Status" message, or a non-"Status" message in case this is not the
-		/// first substream that's been opened, but this out of the concern of this code.
+		/// Handshake message that has been sent to us.
+		/// This is normally a "Status" message, but this out of the concern of this code.
 		received_handshake: Vec<u8>,
 		/// The connected endpoint.
 		endpoint: ConnectedPoint,
@@ -274,7 +270,7 @@ impl LegacyProtoHandler {
 	}
 
 	/// Enables the handler.
-	fn enable(&mut self, send_legacy_handshake: bool) {
+	fn enable(&mut self) {
 		self.state = match mem::replace(&mut self.state, ProtocolState::Poisoned) {
 			ProtocolState::Poisoned => {
 				error!(target: "sub-libp2p", "Handler with {:?} is in poisoned state",
@@ -564,8 +560,7 @@ impl ProtocolsHandler for LegacyProtoHandler {
 	fn inject_event(&mut self, message: LegacyProtoHandlerIn) {
 		match message {
 			LegacyProtoHandlerIn::Disable => self.disable(),
-			LegacyProtoHandlerIn::Enable { send_legacy_handshake } =>
-				self.enable(send_legacy_handshake),
+			LegacyProtoHandlerIn::Enable => self.enable(),
 			LegacyProtoHandlerIn::SendCustomMessage { message } =>
 				self.send_message(message),
 		}