use std::net::SocketAddr;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use bytes::Bytes;
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use crate::error::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransportKind {
Tcp,
Unix,
Tls,
TlsUnix,
Quic,
}
#[derive(Debug, Clone)]
pub struct TlsInfo {
pub alpn_protocol: Option<String>,
pub tls_version: Option<String>,
pub cipher_suite: Option<String>,
pub server_name: Option<String>,
}
#[derive(Debug, Clone)]
pub struct ConnectionMetadata {
pub local_addr: Option<SocketAddr>,
pub peer_addr: Option<SocketAddr>,
pub transport_kind: TransportKind,
pub tls_info: Option<TlsInfo>,
}
impl Default for ConnectionMetadata {
fn default() -> Self {
Self {
local_addr: None,
peer_addr: None,
transport_kind: TransportKind::Tcp,
tls_info: None,
}
}
}
#[cfg(feature = "tls-rustls")]
pub(crate) fn tls_info_from_rustls(
conn: &rustls::ClientConnection,
server_name: Option<String>,
) -> TlsInfo {
TlsInfo {
alpn_protocol: conn
.alpn_protocol()
.map(|p| String::from_utf8_lossy(p).into_owned()),
tls_version: conn.protocol_version().map(|v| format!("{v:?}")),
cipher_suite: conn.negotiated_cipher_suite().map(|c| format!("{c:?}")),
server_name,
}
}
pub struct UpgradedStream {
inner: UpgradedStreamInner,
metadata: Arc<ConnectionMetadata>,
connection_guard: Option<Box<dyn Send>>,
leading_data: Bytes,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UpgradedStreamVariant {
Tcp,
Tls,
Adapter,
}
enum UpgradedStreamInner {
Tcp(tokio::net::TcpStream),
#[cfg(feature = "tls-rustls")]
Tls(Box<tokio_rustls::client::TlsStream<tokio::net::TcpStream>>),
Adapter(Pin<Box<dyn TokioIoBox>>),
}
pub(crate) trait TokioIoBox:
tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin
{
}
impl<T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + Unpin> TokioIoBox for T {}
impl AsyncRead for UpgradedStreamInner {
fn poll_read(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<std::io::Result<()>> {
match &mut *self {
UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_read(cx, buf),
#[cfg(feature = "tls-rustls")]
UpgradedStreamInner::Tls(s) => Pin::new(s).poll_read(cx, buf),
UpgradedStreamInner::Adapter(a) => a.as_mut().poll_read(cx, buf),
}
}
}
impl AsyncWrite for UpgradedStreamInner {
fn poll_write(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<std::io::Result<usize>> {
match &mut *self {
UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_write(cx, buf),
#[cfg(feature = "tls-rustls")]
UpgradedStreamInner::Tls(s) => Pin::new(s).poll_write(cx, buf),
UpgradedStreamInner::Adapter(a) => a.as_mut().poll_write(cx, buf),
}
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
match &mut *self {
UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_flush(cx),
#[cfg(feature = "tls-rustls")]
UpgradedStreamInner::Tls(s) => Pin::new(s).poll_flush(cx),
UpgradedStreamInner::Adapter(a) => a.as_mut().poll_flush(cx),
}
}
fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
match &mut *self {
UpgradedStreamInner::Tcp(s) => Pin::new(s).poll_shutdown(cx),
#[cfg(feature = "tls-rustls")]
UpgradedStreamInner::Tls(s) => Pin::new(s).poll_shutdown(cx),
UpgradedStreamInner::Adapter(a) => a.as_mut().poll_shutdown(cx),
}
}
}
impl UpgradedStream {
pub fn from_tcp(stream: tokio::net::TcpStream, leading_data: Bytes) -> Self {
let metadata = Arc::new(ConnectionMetadata {
local_addr: stream.local_addr().ok(),
peer_addr: stream.peer_addr().ok(),
transport_kind: TransportKind::Tcp,
tls_info: None,
});
Self {
inner: UpgradedStreamInner::Tcp(stream),
metadata,
leading_data,
connection_guard: None,
}
}
pub(crate) fn from_adapter(
adapter: impl TokioIoBox + 'static,
leading_data: Bytes,
metadata: Arc<ConnectionMetadata>,
) -> Self {
let pinned: Pin<Box<dyn TokioIoBox>> = Box::pin(adapter);
Self {
inner: UpgradedStreamInner::Adapter(pinned),
metadata,
leading_data,
connection_guard: None,
}
}
pub(crate) fn hold_connection_guard(&mut self, guard: Box<dyn Send>) {
self.connection_guard = Some(guard);
}
#[cfg(feature = "tls-rustls")]
pub fn from_tls(
stream: tokio_rustls::client::TlsStream<tokio::net::TcpStream>,
leading_data: Bytes,
tls_info: TlsInfo,
) -> Self {
let (inner_tcp, _) = stream.get_ref();
let local_addr = inner_tcp.local_addr().ok();
let peer_addr = inner_tcp.peer_addr().ok();
let metadata = Arc::new(ConnectionMetadata {
local_addr,
peer_addr,
transport_kind: TransportKind::Tls,
tls_info: Some(tls_info),
});
Self {
inner: UpgradedStreamInner::Tls(Box::new(stream)),
metadata,
leading_data,
connection_guard: None,
}
}
#[must_use]
pub fn metadata(&self) -> &Arc<ConnectionMetadata> {
&self.metadata
}
#[must_use]
pub fn variant(&self) -> UpgradedStreamVariant {
match &self.inner {
UpgradedStreamInner::Tcp(_) => UpgradedStreamVariant::Tcp,
#[cfg(feature = "tls-rustls")]
UpgradedStreamInner::Tls(_) => UpgradedStreamVariant::Tls,
UpgradedStreamInner::Adapter(_) => UpgradedStreamVariant::Adapter,
}
}
#[must_use]
pub fn leading_data(&self) -> &Bytes {
&self.leading_data
}
pub fn take_leading_data(&mut self) -> Bytes {
std::mem::take(&mut self.leading_data)
}
pub async fn read(&mut self, max_bytes: usize) -> Result<Bytes> {
if !self.leading_data.is_empty() {
let available = self.leading_data.len().min(max_bytes);
return Ok(self.leading_data.split_to(available));
}
let mut buf = vec![0u8; max_bytes];
let n = tokio::io::AsyncReadExt::read(self, &mut buf)
.await
.map_err(|e| Error::Io(std::sync::Arc::new(e)))?;
if n == 0 {
Ok(Bytes::new())
} else {
Ok(Bytes::copy_from_slice(&buf[..n]))
}
}
pub async fn write_all(&mut self, buf: &[u8]) -> Result<()> {
tokio::io::AsyncWriteExt::write_all(self, buf)
.await
.map_err(|e| Error::Io(std::sync::Arc::new(e)))
}
pub async fn flush(&mut self) -> Result<()> {
tokio::io::AsyncWriteExt::flush(self)
.await
.map_err(|e| Error::Io(std::sync::Arc::new(e)))
}
pub async fn close(&mut self) -> Result<()> {
if let Err(e) = tokio::io::AsyncWriteExt::shutdown(self).await {
#[cfg(feature = "tracing")]
tracing::debug!("eggfetch: network stream shutdown error: {e}");
#[cfg(not(feature = "tracing"))]
let _ = &e;
}
Ok(())
}
#[cfg(feature = "tls-rustls")]
pub async fn start_tls(
mut self,
tls_connector: &tokio_rustls::TlsConnector,
server_name: &str,
) -> Result<Self> {
let tcp = match std::mem::replace(
&mut self.inner,
UpgradedStreamInner::Adapter(Box::pin(tokio::io::duplex(0).0)),
) {
UpgradedStreamInner::Tcp(s) => s,
UpgradedStreamInner::Tls(_) => {
return Err(Error::Tls("stream is already TLS-wrapped".into()));
}
UpgradedStreamInner::Adapter(_) => {
return Err(Error::Tls(
"cannot start TLS on an opaque adapter stream; \
use a concrete TcpStream-backed UpgradedStream"
.into(),
));
}
};
let sn = crate::transport::direct_connector::tls_server_name(server_name)
.map_err(|e| Error::Tls(format!("invalid server name '{server_name}': {e}")))?;
let tls_stream = tls_connector
.connect(sn, tcp)
.await
.map_err(|e| Error::Tls(format!("TLS handshake failed: {e}")))?;
let (inner_tcp, connection_info) = tls_stream.get_ref();
let tls_info = tls_info_from_rustls(connection_info, Some(server_name.to_owned()));
let local_addr = inner_tcp.local_addr().ok();
let peer_addr = inner_tcp.peer_addr().ok();
let metadata = Arc::new(ConnectionMetadata {
local_addr,
peer_addr,
transport_kind: TransportKind::Tls,
tls_info: Some(tls_info),
});
Ok(UpgradedStream {
inner: UpgradedStreamInner::Tls(Box::new(tls_stream)),
metadata,
leading_data: std::mem::take(&mut self.leading_data),
connection_guard: self.connection_guard.take(),
})
}
}
impl AsyncRead for UpgradedStream {
fn poll_read(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<std::io::Result<()>> {
if !self.leading_data.is_empty() {
let available = self.leading_data.len().min(buf.remaining());
let chunk = self.leading_data.split_to(available);
buf.put_slice(&chunk);
return Poll::Ready(Ok(()));
}
Pin::new(&mut self.inner).poll_read(cx, buf)
}
}
impl AsyncWrite for UpgradedStream {
fn poll_write(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.inner).poll_write(cx, buf)
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.inner).poll_flush(cx)
}
fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.inner).poll_shutdown(cx)
}
}
pub enum NetworkStream {
Upgraded(UpgradedStream),
Metadata(Arc<ConnectionMetadata>),
}
impl NetworkStream {
#[must_use]
pub fn metadata(&self) -> &Arc<ConnectionMetadata> {
match self {
NetworkStream::Upgraded(s) => s.metadata(),
NetworkStream::Metadata(m) => m,
}
}
#[must_use]
pub fn is_upgraded(&self) -> bool {
matches!(self, NetworkStream::Upgraded(_))
}
#[must_use]
pub fn as_upgraded(&self) -> Option<&UpgradedStream> {
match self {
NetworkStream::Upgraded(s) => Some(s),
NetworkStream::Metadata(_) => None,
}
}
pub fn as_upgraded_mut(&mut self) -> Option<&mut UpgradedStream> {
match self {
NetworkStream::Upgraded(s) => Some(s),
NetworkStream::Metadata(_) => None,
}
}
pub fn into_upgraded(self) -> Option<UpgradedStream> {
match self {
NetworkStream::Upgraded(s) => Some(s),
NetworkStream::Metadata(_) => None,
}
}
}
#[derive(Debug, Clone)]
pub struct ExtraInfo {
pub client_addr: Option<SocketAddr>,
pub server_addr: Option<SocketAddr>,
pub tls_info: Option<TlsInfo>,
}
impl ExtraInfo {
#[must_use]
pub fn from_metadata(meta: &ConnectionMetadata) -> Self {
Self {
client_addr: meta.local_addr,
server_addr: meta.peer_addr,
tls_info: meta.tls_info.clone(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn connection_metadata_default() {
let meta = ConnectionMetadata::default();
assert!(meta.local_addr.is_none());
assert!(meta.peer_addr.is_none());
assert_eq!(meta.transport_kind, TransportKind::Tcp);
assert!(meta.tls_info.is_none());
}
#[test]
fn network_stream_metadata_only() {
let meta = Arc::new(ConnectionMetadata {
local_addr: Some("127.0.0.1:12345".parse().unwrap()),
peer_addr: Some("93.184.216.34:443".parse().unwrap()),
transport_kind: TransportKind::Tls,
tls_info: Some(TlsInfo {
alpn_protocol: Some("h2".into()),
tls_version: Some("TLSv1.3".into()),
cipher_suite: Some("TLS_AES_256_GCM_SHA384".into()),
server_name: Some("example.com".into()),
}),
});
let ns = NetworkStream::Metadata(meta.clone());
assert!(!ns.is_upgraded());
assert!(ns.as_upgraded().is_none());
let info = ns.metadata();
assert_eq!(info.local_addr.unwrap().port(), 12345);
assert_eq!(info.peer_addr.unwrap().port(), 443);
}
#[test]
fn extra_info_from_metadata() {
let meta = ConnectionMetadata {
local_addr: Some("127.0.0.1:1000".parse().unwrap()),
peer_addr: Some("10.0.0.1:443".parse().unwrap()),
transport_kind: TransportKind::Tcp,
tls_info: None,
};
let info = ExtraInfo::from_metadata(&meta);
assert_eq!(info.client_addr.unwrap().port(), 1000);
assert_eq!(info.server_addr.unwrap().port(), 443);
assert!(info.tls_info.is_none());
}
}