diff --git a/src/crypto/noise/mod.rs b/src/crypto/noise/mod.rs index f57756849..b166d4173 100644 --- a/src/crypto/noise/mod.rs +++ b/src/crypto/noise/mod.rs @@ -571,8 +571,9 @@ impl AsyncRead for NoiseSocket { } }, None => { - let frame_size = - this.current_frame_size.take().expect("`frame_size` to exist"); + let frame_size = this.current_frame_size.take().ok_or_else(|| { + io::Error::new(io::ErrorKind::InvalidData, "frame_size missing") + })?; match buf.len() >= frame_size - NOISE_EXTRA_ENCRYPT_SPACE { true => match this.noise.read_message( @@ -599,8 +600,12 @@ impl AsyncRead for NoiseSocket { } }, false => { - let mut buffer = - this.decrypt_buffer.take().expect("buffer to exist"); + let mut buffer = this.decrypt_buffer.take().ok_or_else(|| { + io::Error::new( + io::ErrorKind::InvalidData, + "decrypt buffer missing", + ) + })?; match this.noise.read_message( &this.read_buffer[this.offset..this.offset + frame_size], diff --git a/src/transport/quic/listener.rs b/src/transport/quic/listener.rs index 77760b627..918b7c009 100644 --- a/src/transport/quic/listener.rs +++ b/src/transport/quic/listener.rs @@ -61,9 +61,9 @@ impl QuicListener { for address in addresses.into_iter() { let (listen_address, _) = Self::get_socket_address(&address)?; - let crypto_config = Arc::new(make_server_config(keypair).expect("to succeed")); + let crypto_config = Arc::new(make_server_config(keypair)?); let server_config = ServerConfig::with_crypto(crypto_config); - let listener = Endpoint::server(server_config, listen_address).unwrap(); + let listener = Endpoint::server(server_config, listen_address)?; let listen_address = listener.local_addr()?; listen_addresses.push(listen_address); diff --git a/src/transport/quic/mod.rs b/src/transport/quic/mod.rs index dfbb99c24..7e4023413 100644 --- a/src/transport/quic/mod.rs +++ b/src/transport/quic/mod.rs @@ -257,11 +257,10 @@ impl Transport for QuicTransport { return Err(Error::AddressError(AddressError::PeerIdMissing)); }; - let crypto_config = - Arc::new(make_client_config(&self.context.keypair, Some(peer)).expect("to succeed")); + let crypto_config = Arc::new(make_client_config(&self.context.keypair, Some(peer))?); let mut transport_config = quinn::TransportConfig::default(); - let timeout = - IdleTimeout::try_from(self.config.connection_open_timeout).expect("to succeed"); + let timeout = IdleTimeout::try_from(self.config.connection_open_timeout) + .map_err(|e| Error::Other(e.to_string()))?; transport_config.max_idle_timeout(Some(timeout)); let mut client_config = ClientConfig::new(crypto_config); client_config.transport_config(Arc::new(transport_config)); @@ -381,10 +380,12 @@ impl Transport for QuicTransport { peer.ok_or_else(|| DialError::AddressError(AddressError::PeerIdMissing))?; let crypto_config = - Arc::new(make_client_config(&keypair, Some(peer)).expect("to succeed")); + Arc::new(make_client_config(&keypair, Some(peer)).map_err(|_| { + DialError::NegotiationError(QuicError::InvalidCertificate.into()) + })?); let mut transport_config = quinn::TransportConfig::default(); - let timeout = - IdleTimeout::try_from(connection_open_timeout).expect("to succeed"); + let timeout = IdleTimeout::try_from(connection_open_timeout) + .map_err(|_| DialError::Timeout)?; transport_config.max_idle_timeout(Some(timeout)); let mut client_config = ClientConfig::new(crypto_config); client_config.transport_config(Arc::new(transport_config)); diff --git a/src/transport/s2n-quic/mod.rs b/src/transport/s2n-quic/mod.rs index 6237ee3f0..fdc88dc05 100644 --- a/src/transport/s2n-quic/mod.rs +++ b/src/transport/s2n-quic/mod.rs @@ -153,9 +153,10 @@ impl QuicTransport { /// Accept QUIC conenction. async fn accept_connection(&mut self, connection: Connection) -> crate::Result<()> { let connection_id = self.context.next_connection_id(); - let address = socket_addr_to_multi_addr( - &connection.remote_addr().expect("remote address to be known"), - ); + let remote_addr = connection + .remote_addr() + .map_err(|_| Error::AddressError(AddressError::AddressNotAvailable))?; + let address = socket_addr_to_multi_addr(&remote_addr); let Ok(peer) = self.rx.try_recv() else { tracing::error!(target: LOG_TARGET, "failed to receive client `PeerId` from tls verifier"); @@ -257,12 +258,12 @@ impl QuicTransport { return Err(Error::AddressError(AddressError::PeerIdMissing)); }; - let (certificate, key) = generate(&self.context.keypair).unwrap(); + let (certificate, key) = generate(&self.context.keypair)?; let provider = TlsProvider::new(key, certificate, Some(peer), None); let client = Client::builder() .with_tls(provider) - .expect("TLS provider to be enabled successfully") + .map_err(|e| Error::Other(e.to_string()))? .with_io(self.client_listen_address)? .start()?; @@ -299,7 +300,7 @@ impl Transport for QuicTransport { let provider = TlsProvider::new(key, certificate, None, Some(_tx.clone())); let server = Server::builder() .with_tls(provider) - .expect("TLS provider to be enabled successfully") + .map_err(|e| Error::Other(e.to_string()))? .with_io(listen_address)? .start()?; diff --git a/src/transport/webrtc/mod.rs b/src/transport/webrtc/mod.rs index 2fc28ffbe..e82a44afa 100644 --- a/src/transport/webrtc/mod.rs +++ b/src/transport/webrtc/mod.rs @@ -359,8 +359,15 @@ impl WebRtcTransport { "received non-stun message" ); - if let Err(error) = self.opening.get_mut(&source).expect("to exist").on_input(contents) - { + let Some(opening) = self.opening.get_mut(&source) else { + tracing::warn!( + target: LOG_TARGET, + ?source, + "connection doesn't exist for non-stun message", + ); + return Err(Error::InvalidState); + }; + if let Err(error) = opening.on_input(contents) { tracing::error!( target: LOG_TARGET, ?error, @@ -391,19 +398,18 @@ impl WebRtcTransport { ); // create new `Rtc` object for the peer and give it the received STUN message - let (mut rtc, noise_channel_id) = - self.make_rtc_client(ufrag, pass, source, self.socket.local_addr().unwrap()); + let local_addr = self.socket.local_addr()?; + let (mut rtc, noise_channel_id) = self.make_rtc_client(ufrag, pass, source, local_addr); rtc.handle_input(Input::Receive( Instant::now(), Receive { source, proto: Str0mProtocol::Udp, - destination: self.socket.local_addr().unwrap(), + destination: local_addr, contents, }, - )) - .expect("client to handle input successfully"); + ))?; let connection_id = self.context.next_connection_id(); let connection = OpeningWebRtcConnection::new( diff --git a/src/transport/webrtc/opening.rs b/src/transport/webrtc/opening.rs index f778ca843..c24408cb2 100644 --- a/src/transport/webrtc/opening.rs +++ b/src/transport/webrtc/opening.rs @@ -268,13 +268,13 @@ impl OpeningWebRtcConnection { .rtc .direct_api() .remote_dtls_fingerprint() - .expect("fingerprint to exist") + .ok_or(Error::InvalidState)? .clone() .bytes; const MULTIHASH_SHA256_CODE: u64 = 0x12; let certificate = Multihash::wrap(MULTIHASH_SHA256_CODE, &remote_fingerprint) - .expect("fingerprint's len to be 32 bytes"); + .map_err(|_| Error::InvalidData)?; let address = Multiaddr::empty() .with(Protocol::from(self.peer_address.ip()))