1use std::net::SocketAddr;
13use std::pin::Pin;
14use std::sync::Arc;
15use std::task::{Context, Poll};
16
17use bytes::Bytes;
18use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
19
20use crate::error::{Error, Result};
21
22#[derive(Debug, Clone, Copy, PartialEq, Eq)]
24pub enum TransportKind {
25 Tcp,
27 Unix,
29 Tls,
31 TlsUnix,
33 Quic,
42}
43
44#[derive(Debug, Clone)]
49pub struct TlsInfo {
50 pub alpn_protocol: Option<String>,
52 pub tls_version: Option<String>,
54 pub cipher_suite: Option<String>,
56 pub server_name: Option<String>,
58}
59
60#[derive(Debug, Clone)]
66pub struct ConnectionMetadata {
67 pub local_addr: Option<SocketAddr>,
69 pub peer_addr: Option<SocketAddr>,
71 pub transport_kind: TransportKind,
73 pub tls_info: Option<TlsInfo>,
75}
76
77impl Default for ConnectionMetadata {
78 fn default() -> Self {
79 Self {
80 local_addr: None,
81 peer_addr: None,
82 transport_kind: TransportKind::Tcp,
83 tls_info: None,
84 }
85 }
86}
87
88#[cfg(feature = "tls-rustls")]
95pub(crate) fn tls_info_from_rustls(
96 conn: &rustls::ClientConnection,
97 server_name: Option<String>,
98) -> TlsInfo {
99 TlsInfo {
100 alpn_protocol: conn
101 .alpn_protocol()
102 .map(|p| String::from_utf8_lossy(p).into_owned()),
103 tls_version: conn.protocol_version().map(|v| format!("{v:?}")),
104 cipher_suite: conn.negotiated_cipher_suite().map(|c| format!("{c:?}")),
105 server_name,
106 }
107}
108
109pub struct UpgradedStream {
123 inner: UpgradedStreamInner,
124 metadata: Arc<ConnectionMetadata>,
125 connection_guard: Option<Box<dyn Send>>,
128 leading_data: Bytes,
132}
133
134#[derive(Debug, Clone, Copy, PartialEq, Eq)]
139pub enum UpgradedStreamVariant {
140 Tcp,
142 Tls,
144 Adapter,
146}
147
148enum UpgradedStreamInner {
150 Tcp(tokio::net::TcpStream),
152 #[cfg(feature = "tls-rustls")]
154 Tls(Box<tokio_rustls::client::TlsStream<tokio::net::TcpStream>>),
155 Adapter(Pin<Box<dyn TokioIoBox>>),
157}
158
159pub(crate) trait TokioIoBox:
162 tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin
163{
164}
165impl<T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin> TokioIoBox for T {}
166
167impl AsyncRead for UpgradedStreamInner {
168 fn poll_read(
169 mut self: Pin<&mut Self>,
170 cx: &mut Context<'_>,
171 buf: &mut ReadBuf<'_>,
172 ) -> Poll<std::io::Result<()>> {
173 match &mut *self {
174 UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_read(cx, buf),
175 #[cfg(feature = "tls-rustls")]
176 UpgradedStreamInner::Tls(s) => Pin::new(s).poll_read(cx, buf),
177 UpgradedStreamInner::Adapter(a) => a.as_mut().poll_read(cx, buf),
178 }
179 }
180}
181
182impl AsyncWrite for UpgradedStreamInner {
183 fn poll_write(
184 mut self: Pin<&mut Self>,
185 cx: &mut Context<'_>,
186 buf: &[u8],
187 ) -> Poll<std::io::Result<usize>> {
188 match &mut *self {
189 UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_write(cx, buf),
190 #[cfg(feature = "tls-rustls")]
191 UpgradedStreamInner::Tls(s) => Pin::new(s).poll_write(cx, buf),
192 UpgradedStreamInner::Adapter(a) => a.as_mut().poll_write(cx, buf),
193 }
194 }
195
196 fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
197 match &mut *self {
198 UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_flush(cx),
199 #[cfg(feature = "tls-rustls")]
200 UpgradedStreamInner::Tls(s) => Pin::new(s).poll_flush(cx),
201 UpgradedStreamInner::Adapter(a) => a.as_mut().poll_flush(cx),
202 }
203 }
204
205 fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
206 match &mut *self {
207 UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_shutdown(cx),
208 #[cfg(feature = "tls-rustls")]
209 UpgradedStreamInner::Tls(s) => Pin::new(s).poll_shutdown(cx),
210 UpgradedStreamInner::Adapter(a) => a.as_mut().poll_shutdown(cx),
211 }
212 }
213}
214
215impl UpgradedStream {
216 pub fn from_tcp(stream: tokio::net::TcpStream, leading_data: Bytes) -> Self {
222 let metadata = Arc::new(ConnectionMetadata {
223 local_addr: stream.local_addr().ok(),
224 peer_addr: stream.peer_addr().ok(),
225 transport_kind: TransportKind::Tcp,
226 tls_info: None,
227 });
228 Self {
229 inner: UpgradedStreamInner::Tcp(stream),
230 metadata,
231 leading_data,
232 connection_guard: None,
233 }
234 }
235
236 pub(crate) fn from_adapter(
243 adapter: impl TokioIoBox + 'static,
244 leading_data: Bytes,
245 metadata: Arc<ConnectionMetadata>,
246 ) -> Self {
247 let pinned: Pin<Box<dyn TokioIoBox>> = Box::pin(adapter);
248 Self {
249 inner: UpgradedStreamInner::Adapter(pinned),
250 metadata,
251 leading_data,
252 connection_guard: None,
253 }
254 }
255
256 pub(crate) fn hold_connection_guard(&mut self, guard: Box<dyn Send>) {
258 self.connection_guard = Some(guard);
259 }
260
261 #[cfg(feature = "tls-rustls")]
263 pub fn from_tls(
264 stream: tokio_rustls::client::TlsStream<tokio::net::TcpStream>,
265 leading_data: Bytes,
266 tls_info: TlsInfo,
267 ) -> Self {
268 let (inner_tcp, _) = stream.get_ref();
271 let local_addr = inner_tcp.local_addr().ok();
272 let peer_addr = inner_tcp.peer_addr().ok();
273 let metadata = Arc::new(ConnectionMetadata {
274 local_addr,
275 peer_addr,
276 transport_kind: TransportKind::Tls,
277 tls_info: Some(tls_info),
278 });
279 Self {
280 inner: UpgradedStreamInner::Tls(Box::new(stream)),
281 metadata,
282 leading_data,
283 connection_guard: None,
284 }
285 }
286
287 #[must_use]
289 pub fn metadata(&self) -> &Arc<ConnectionMetadata> {
290 &self.metadata
291 }
292
293 #[must_use]
299 pub fn variant(&self) -> UpgradedStreamVariant {
300 match &self.inner {
301 UpgradedStreamInner::Tcp(_) => UpgradedStreamVariant::Tcp,
302 #[cfg(feature = "tls-rustls")]
303 UpgradedStreamInner::Tls(_) => UpgradedStreamVariant::Tls,
304 UpgradedStreamInner::Adapter(_) => UpgradedStreamVariant::Adapter,
305 }
306 }
307
308 #[must_use]
314 pub fn leading_data(&self) -> &Bytes {
315 &self.leading_data
316 }
317
318 pub fn take_leading_data(&mut self) -> Bytes {
320 std::mem::take(&mut self.leading_data)
321 }
322
323 pub async fn read(&mut self, max_bytes: usize) -> Result<Bytes> {
331 if !self.leading_data.is_empty() {
333 let available = self.leading_data.len().min(max_bytes);
334 return Ok(self.leading_data.split_to(available));
335 }
336 let mut buf = vec![0u8; max_bytes];
337 let n = tokio::io::AsyncReadExt::read(self, &mut buf)
338 .await
339 .map_err(|e| Error::Io(std::sync::Arc::new(e)))?;
340 if n == 0 {
341 Ok(Bytes::new())
342 } else {
343 Ok(Bytes::copy_from_slice(&buf[..n]))
344 }
345 }
346
347 pub async fn write_all(&mut self, buf: &[u8]) -> Result<()> {
353 tokio::io::AsyncWriteExt::write_all(self, buf)
354 .await
355 .map_err(|e| Error::Io(std::sync::Arc::new(e)))
356 }
357
358 pub async fn flush(&mut self) -> Result<()> {
364 tokio::io::AsyncWriteExt::flush(self)
365 .await
366 .map_err(|e| Error::Io(std::sync::Arc::new(e)))
367 }
368
369 pub async fn close(&mut self) -> Result<()> {
376 let _ = tokio::io::AsyncWriteExt::shutdown(self).await;
377 Ok(())
378 }
379
380 #[cfg(feature = "tls-rustls")]
397 pub async fn start_tls(
398 mut self,
399 tls_connector: &tokio_rustls::TlsConnector,
400 server_name: &str,
401 ) -> Result<Self> {
402 let tcp = match std::mem::replace(
403 &mut self.inner,
404 UpgradedStreamInner::Adapter(Box::pin(tokio::io::duplex(0).0)),
408 ) {
409 UpgradedStreamInner::Tcp(s) => s,
410 UpgradedStreamInner::Tls(_) => {
411 return Err(Error::Tls("stream is already TLS-wrapped".into()));
412 }
413 UpgradedStreamInner::Adapter(_) => {
414 return Err(Error::Tls(
415 "cannot start TLS on an opaque adapter stream; \
416 use a concrete TcpStream-backed UpgradedStream"
417 .into(),
418 ));
419 }
420 };
421
422 let sn = crate::transport::direct_connector::tls_server_name(server_name)
423 .map_err(|e| Error::Tls(format!("invalid server name '{server_name}': {e}")))?;
424
425 let tls_stream = tls_connector
426 .connect(sn, tcp)
427 .await
428 .map_err(|e| Error::Tls(format!("TLS handshake failed: {e}")))?;
429
430 let (inner_tcp, connection_info) = tls_stream.get_ref();
432 let tls_info = tls_info_from_rustls(connection_info, Some(server_name.to_owned()));
433
434 let local_addr = inner_tcp.local_addr().ok();
435 let peer_addr = inner_tcp.peer_addr().ok();
436
437 let metadata = Arc::new(ConnectionMetadata {
438 local_addr,
439 peer_addr,
440 transport_kind: TransportKind::Tls,
441 tls_info: Some(tls_info),
442 });
443
444 Ok(UpgradedStream {
445 inner: UpgradedStreamInner::Tls(Box::new(tls_stream)),
446 metadata,
447 leading_data: std::mem::take(&mut self.leading_data),
450 connection_guard: self.connection_guard.take(),
451 })
452 }
453}
454
455impl AsyncRead for UpgradedStream {
456 fn poll_read(
457 mut self: Pin<&mut Self>,
458 cx: &mut Context<'_>,
459 buf: &mut ReadBuf<'_>,
460 ) -> Poll<std::io::Result<()>> {
461 if !self.leading_data.is_empty() {
463 let available = self.leading_data.len().min(buf.remaining());
464 let chunk = self.leading_data.split_to(available);
465 buf.put_slice(&chunk);
466 return Poll::Ready(Ok(()));
467 }
468 Pin::new(&mut self.inner).poll_read(cx, buf)
469 }
470}
471
472impl AsyncWrite for UpgradedStream {
473 fn poll_write(
474 mut self: Pin<&mut Self>,
475 cx: &mut Context<'_>,
476 buf: &[u8],
477 ) -> Poll<std::io::Result<usize>> {
478 Pin::new(&mut self.inner).poll_write(cx, buf)
479 }
480
481 fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
482 Pin::new(&mut self.inner).poll_flush(cx)
483 }
484
485 fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
486 Pin::new(&mut self.inner).poll_shutdown(cx)
487 }
488}
489
490pub enum NetworkStream {
510 Upgraded(UpgradedStream),
512 Metadata(Arc<ConnectionMetadata>),
518}
519
520impl NetworkStream {
521 #[must_use]
523 pub fn metadata(&self) -> &Arc<ConnectionMetadata> {
524 match self {
525 NetworkStream::Upgraded(s) => s.metadata(),
526 NetworkStream::Metadata(m) => m,
527 }
528 }
529
530 #[must_use]
532 pub fn is_upgraded(&self) -> bool {
533 matches!(self, NetworkStream::Upgraded(_))
534 }
535
536 #[must_use]
538 pub fn as_upgraded(&self) -> Option<&UpgradedStream> {
539 match self {
540 NetworkStream::Upgraded(s) => Some(s),
541 NetworkStream::Metadata(_) => None,
542 }
543 }
544
545 pub fn as_upgraded_mut(&mut self) -> Option<&mut UpgradedStream> {
547 match self {
548 NetworkStream::Upgraded(s) => Some(s),
549 NetworkStream::Metadata(_) => None,
550 }
551 }
552
553 pub fn into_upgraded(self) -> Option<UpgradedStream> {
555 match self {
556 NetworkStream::Upgraded(s) => Some(s),
557 NetworkStream::Metadata(_) => None,
558 }
559 }
560}
561
562#[derive(Debug, Clone)]
564pub struct ExtraInfo {
565 pub client_addr: Option<SocketAddr>,
567 pub server_addr: Option<SocketAddr>,
569 pub tls_info: Option<TlsInfo>,
571}
572
573impl ExtraInfo {
574 #[must_use]
576 pub fn from_metadata(meta: &ConnectionMetadata) -> Self {
577 Self {
578 client_addr: meta.local_addr,
579 server_addr: meta.peer_addr,
580 tls_info: meta.tls_info.clone(),
581 }
582 }
583}
584
585#[cfg(test)]
586mod tests {
587 use super::*;
588
589 #[test]
590 fn connection_metadata_default() {
591 let meta = ConnectionMetadata::default();
592 assert!(meta.local_addr.is_none());
593 assert!(meta.peer_addr.is_none());
594 assert_eq!(meta.transport_kind, TransportKind::Tcp);
595 assert!(meta.tls_info.is_none());
596 }
597
598 #[test]
599 fn network_stream_metadata_only() {
600 let meta = Arc::new(ConnectionMetadata {
601 local_addr: Some("127.0.0.1:12345".parse().unwrap()),
602 peer_addr: Some("93.184.216.34:443".parse().unwrap()),
603 transport_kind: TransportKind::Tls,
604 tls_info: Some(TlsInfo {
605 alpn_protocol: Some("h2".into()),
606 tls_version: Some("TLSv1.3".into()),
607 cipher_suite: Some("TLS_AES_256_GCM_SHA384".into()),
608 server_name: Some("example.com".into()),
609 }),
610 });
611 let ns = NetworkStream::Metadata(meta.clone());
612 assert!(!ns.is_upgraded());
613 assert!(ns.as_upgraded().is_none());
614 let info = ns.metadata();
615 assert_eq!(info.local_addr.unwrap().port(), 12345);
616 assert_eq!(info.peer_addr.unwrap().port(), 443);
617 }
618
619 #[test]
620 fn extra_info_from_metadata() {
621 let meta = ConnectionMetadata {
622 local_addr: Some("127.0.0.1:1000".parse().unwrap()),
623 peer_addr: Some("10.0.0.1:443".parse().unwrap()),
624 transport_kind: TransportKind::Tcp,
625 tls_info: None,
626 };
627 let info = ExtraInfo::from_metadata(&meta);
628 assert_eq!(info.client_addr.unwrap().port(), 1000);
629 assert_eq!(info.server_addr.unwrap().port(), 443);
630 assert!(info.tls_info.is_none());
631 }
632}