use std::fmt;
use std::future::Future;
use std::net::SocketAddr;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use http::Uri;
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use tower_service::Service;
use crate::error::Error;
#[cfg(feature = "tls-rustls")]
pub(crate) fn tls_server_name(
host: &str,
) -> std::result::Result<tokio_rustls::rustls::pki_types::ServerName<'static>, String> {
let ip_host = host
.strip_prefix('[')
.and_then(|value| value.strip_suffix(']'))
.unwrap_or(host);
if let Ok(ip) = ip_host.parse::<std::net::IpAddr>() {
return Ok(tokio_rustls::rustls::pki_types::ServerName::IpAddress(
ip.into(),
));
}
tokio_rustls::rustls::pki_types::ServerName::try_from(host.to_owned())
.map_err(|error| error.to_string())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SocketOptionKind {
TcpNoDelay,
KeepAlive,
ReceiveBuffer,
SendBuffer,
}
pub(crate) struct DirectConnectError {
kind: crate::transport::ConnectFailureKind,
message: String,
source: Option<std::io::Error>,
}
impl DirectConnectError {
pub(crate) fn new(
kind: crate::transport::ConnectFailureKind,
message: String,
source: Option<std::io::Error>,
) -> Self {
Self {
kind,
message,
source,
}
}
pub(crate) const fn kind(&self) -> crate::transport::ConnectFailureKind {
self.kind
}
pub(crate) fn message(&self) -> &str {
&self.message
}
}
fn classify_tcp_failures(attempted: usize, refused: usize) -> crate::transport::ConnectFailureKind {
if attempted > 0 && attempted == refused {
crate::transport::ConnectFailureKind::ConnectionRefused
} else {
crate::transport::ConnectFailureKind::Connect
}
}
impl fmt::Debug for DirectConnectError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DirectConnectError")
.field("kind", &self.kind)
.field("message", &self.message)
.field("source", &self.source.as_ref().map(|_| "<redacted>"))
.finish()
}
}
impl fmt::Display for DirectConnectError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for DirectConnectError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
self.source
.as_ref()
.map(|source| source as &(dyn std::error::Error + 'static))
}
}
#[derive(Debug, Clone)]
pub struct SocketOption {
pub level: i32,
pub option: i32,
pub value: Vec<u8>,
pub kind: Option<SocketOptionKind>,
}
#[derive(Debug, Clone)]
pub struct DirectConnectorConfig {
pub(crate) local_address: Option<SocketAddr>,
pub(crate) socket_options: Vec<SocketOption>,
}
impl DirectConnectorConfig {}
fn apply_socket_option(
socket: &tokio::net::TcpSocket,
opt: &SocketOption,
) -> std::result::Result<(), Error> {
if opt.value.len() < 4 {
return Err(Error::Connect(format!(
"socket option value too short: expected at least 4 bytes, got {}",
opt.value.len()
)));
}
match opt.kind {
Some(SocketOptionKind::TcpNoDelay) => {
let val = i32::from_ne_bytes([opt.value[0], opt.value[1], opt.value[2], opt.value[3]]);
socket
.set_nodelay(val != 0)
.map_err(|e| Error::Connect(format!("failed to set TCP_NODELAY: {e}")))?;
}
Some(SocketOptionKind::KeepAlive) => {
let val = i32::from_ne_bytes([opt.value[0], opt.value[1], opt.value[2], opt.value[3]]);
socket
.set_keepalive(val != 0)
.map_err(|e| Error::Connect(format!("failed to set SO_KEEPALIVE: {e}")))?;
}
Some(SocketOptionKind::ReceiveBuffer) => {
let val = u32::from_ne_bytes([opt.value[0], opt.value[1], opt.value[2], opt.value[3]]);
socket
.set_recv_buffer_size(val)
.map_err(|e| Error::Connect(format!("failed to set SO_RCVBUF: {e}")))?;
}
Some(SocketOptionKind::SendBuffer) => {
let val = u32::from_ne_bytes([opt.value[0], opt.value[1], opt.value[2], opt.value[3]]);
socket
.set_send_buffer_size(val)
.map_err(|e| Error::Connect(format!("failed to set SO_SNDBUF: {e}")))?;
}
_ => {
return Err(Error::Connect(format!(
"unsupported socket option: level={}, option={}",
opt.level, opt.option
)));
}
}
Ok(())
}
pub(crate) enum DirectStream {
Tcp(tokio::net::TcpStream),
#[cfg(feature = "tls-rustls")]
Tls(Box<tokio_rustls::client::TlsStream<tokio::net::TcpStream>>),
}
impl AsyncRead for DirectStream {
fn poll_read(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<std::io::Result<()>> {
match &mut *self {
DirectStream::Tcp(s) => Pin::new(s).poll_read(cx, buf),
#[cfg(feature = "tls-rustls")]
DirectStream::Tls(s) => Pin::new(s).poll_read(cx, buf),
}
}
}
impl AsyncWrite for DirectStream {
fn poll_write(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<std::io::Result<usize>> {
match &mut *self {
DirectStream::Tcp(s) => Pin::new(s).poll_write(cx, buf),
#[cfg(feature = "tls-rustls")]
DirectStream::Tls(s) => Pin::new(s).poll_write(cx, buf),
}
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
match &mut *self {
DirectStream::Tcp(s) => Pin::new(s).poll_flush(cx),
#[cfg(feature = "tls-rustls")]
DirectStream::Tls(s) => Pin::new(s).poll_flush(cx),
}
}
fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
match &mut *self {
DirectStream::Tcp(s) => Pin::new(s).poll_shutdown(cx),
#[cfg(feature = "tls-rustls")]
DirectStream::Tls(s) => Pin::new(s).poll_shutdown(cx),
}
}
}
impl hyper_util::client::legacy::connect::Connection for DirectStream {
fn connected(&self) -> hyper_util::client::legacy::connect::Connected {
#[cfg(feature = "tls-rustls")]
let mut connected = hyper_util::client::legacy::connect::Connected::new();
#[cfg(not(feature = "tls-rustls"))]
let connected = hyper_util::client::legacy::connect::Connected::new();
#[cfg(feature = "tls-rustls")]
if let Self::Tls(tls) = self {
if super::negotiated_http2(tls.get_ref().1.alpn_protocol()) {
connected = connected.negotiated_h2();
}
}
connected
}
}
#[cfg(feature = "tls-rustls")]
type TlsConnector = tokio_rustls::TlsConnector;
#[cfg(not(feature = "tls-rustls"))]
type TlsConnector = ();
#[allow(
dead_code,
reason = "connector metadata helpers are exercised by integration tests; upgrade path uses from_tcp/from_tls directly"
)]
impl DirectStream {
pub(crate) fn local_addr(&self) -> Option<SocketAddr> {
match self {
Self::Tcp(s) => s.local_addr().ok(),
#[cfg(feature = "tls-rustls")]
Self::Tls(s) => s.get_ref().0.local_addr().ok(),
}
}
pub(crate) fn peer_addr(&self) -> Option<SocketAddr> {
match self {
Self::Tcp(s) => s.peer_addr().ok(),
#[cfg(feature = "tls-rustls")]
Self::Tls(s) => s.get_ref().0.peer_addr().ok(),
}
}
pub(crate) fn tls_info(
&self,
server_name: Option<String>,
) -> Option<crate::network_stream::TlsInfo> {
#[cfg(not(feature = "tls-rustls"))]
let _ = server_name;
match self {
Self::Tcp(_) => None,
#[cfg(feature = "tls-rustls")]
Self::Tls(s) => Some(crate::network_stream::tls_info_from_rustls(
s.get_ref().1,
server_name,
)),
}
}
pub(crate) fn connection_metadata(
&self,
server_name: Option<String>,
) -> crate::network_stream::ConnectionMetadata {
let tls_info = self.tls_info(server_name);
let kind = if tls_info.is_some() {
crate::network_stream::TransportKind::Tls
} else {
crate::network_stream::TransportKind::Tcp
};
crate::network_stream::ConnectionMetadata {
local_addr: self.local_addr(),
peer_addr: self.peer_addr(),
transport_kind: kind,
tls_info,
}
}
}
#[derive(Clone)]
pub(crate) struct DirectConnector {
config: DirectConnectorConfig,
tls: Option<Arc<TlsConnector>>,
sni_hostname: Option<String>,
resolved_addresses: Option<Arc<[SocketAddr]>>,
metrics: Option<Arc<crate::transport::metrics::TransportMetrics>>,
}
impl DirectConnector {
#[allow(
dead_code,
reason = "kept for unit tests and one-off connectors without metrics; client paths use with_metrics"
)]
pub(crate) fn new(config: DirectConnectorConfig, tls: Option<TlsConnector>) -> Self {
Self {
config,
tls: tls.map(Arc::new),
sni_hostname: None,
resolved_addresses: None,
metrics: None,
}
}
pub(crate) fn with_metrics(
config: DirectConnectorConfig,
tls: Option<TlsConnector>,
metrics: Arc<crate::transport::metrics::TransportMetrics>,
) -> Self {
Self {
config,
tls: tls.map(Arc::new),
sni_hostname: None,
resolved_addresses: None,
metrics: Some(metrics),
}
}
pub(crate) fn with_sni(&self, sni_hostname: String) -> Self {
Self {
config: self.config.clone(),
tls: self.tls.clone(),
sni_hostname: Some(sni_hostname),
resolved_addresses: self.resolved_addresses.clone(),
metrics: self.metrics.clone(),
}
}
pub(crate) fn with_resolved_target(
&self,
target: &crate::transport_hints::ResolvedTarget,
) -> Self {
Self {
config: self.config.clone(),
tls: self.tls.clone(),
sni_hostname: self.sni_hostname.clone(),
resolved_addresses: Some(target.addresses_shared()),
metrics: self.metrics.clone(),
}
}
}
impl Service<Uri> for DirectConnector {
type Response = hyper_util::rt::TokioIo<DirectStream>;
type Error = Box<dyn std::error::Error + Send + Sync>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
#[allow(
clippy::too_many_lines,
reason = "the address resolution, the per-address socket setup, the connect retry, the failure classification and the TLS handshake are one ordered dial sequence"
)]
fn call(&mut self, dst: Uri) -> Self::Future {
let config = self.config.clone();
#[cfg(feature = "tls-rustls")]
let tls = self.tls.clone();
#[cfg(feature = "tls-rustls")]
let sni_hostname = self.sni_hostname.clone();
let resolved_addresses = self.resolved_addresses.clone();
let metrics = self.metrics.clone();
Box::pin(async move {
if let Some(ref m) = metrics {
m.record_direct_attempt();
if resolved_addresses.is_none() {
m.record_direct_dns_attempt();
}
}
let host = dst
.host()
.ok_or_else(|| -> Box<dyn std::error::Error + Send + Sync> {
Error::Connect("no hostname in URI".into()).into()
})?
.to_owned();
let port = dst.port_u16().unwrap_or_else(|| {
if dst.scheme_str() == Some("https") {
443
} else {
80
}
});
let is_https = dst.scheme_str() == Some("https");
let addresses = if let Some(addresses) = resolved_addresses {
addresses.to_vec()
} else {
match tokio::net::lookup_host((host.as_str(), port)).await {
Ok(addrs) => addrs.collect(),
Err(e) => {
if let Some(ref m) = metrics {
m.record_direct_dns_failure();
m.record_direct_failure();
}
return Err(Box::new(DirectConnectError::new(
crate::transport::ConnectFailureKind::Dns,
format!("DNS resolution failed for {host}: {e}"),
Some(e),
))
as Box<dyn std::error::Error + Send + Sync>);
}
}
};
let mut attempted = 0usize;
let mut refused = 0;
let mut last_error: Option<(String, std::io::Error)> = None;
let mut tokio_stream = None;
for addr in addresses {
if let Some(local_addr) = config.local_address {
if local_addr.is_ipv4() != addr.is_ipv4() {
continue;
}
}
let socket = if addr.is_ipv4() {
tokio::net::TcpSocket::new_v4()
} else {
tokio::net::TcpSocket::new_v6()
}
.map_err(|e| -> Box<dyn std::error::Error + Send + Sync> {
Error::Connect(format!("failed to create socket: {e}")).into()
})?;
for opt in &config.socket_options {
if let Err(error) = apply_socket_option(&socket, opt) {
return Err(error.into());
}
}
if let Some(local_addr) = config.local_address {
if let Err(error) = socket.bind(local_addr) {
attempted += 1;
last_error = Some((error.to_string(), error));
continue;
}
}
attempted += 1;
match socket.connect(addr).await {
Ok(stream) => {
tokio_stream = Some(stream);
break;
}
Err(error) => {
if error.kind() == std::io::ErrorKind::ConnectionRefused {
refused += 1;
}
last_error = Some((format!("{addr}: {error}"), error));
}
}
}
let Some(tokio_stream) = tokio_stream else {
if let Some(ref m) = metrics {
m.record_direct_failure();
}
let (last_message, source) = last_error.map_or_else(
|| ("no compatible addresses".into(), None),
|(message, error)| (message, Some(error)),
);
let kind = classify_tcp_failures(attempted, refused);
return Err(Box::new(DirectConnectError::new(
kind,
format!("TCP connect to {host}:{port} failed: {last_message}"),
source,
))
as Box<dyn std::error::Error + Send + Sync>);
};
if let Some(ref m) = metrics {
m.record_direct_success();
}
let has_nodelay = config
.socket_options
.iter()
.any(|opt| opt.kind == Some(SocketOptionKind::TcpNoDelay));
if !has_nodelay {
tokio_stream.set_nodelay(true).map_err(
|e| -> Box<dyn std::error::Error + Send + Sync> {
Error::Connect(format!("failed to set TCP_NODELAY: {e}")).into()
},
)?;
}
#[cfg(feature = "tls-rustls")]
let direct_stream = if is_https {
let tls_connector =
tls.ok_or_else(|| -> Box<dyn std::error::Error + Send + Sync> {
Error::Connect("HTTPS requested but TLS connector not configured".into())
.into()
})?;
let tls_host = sni_hostname.as_deref().unwrap_or(&host);
let server_name = tls_server_name(tls_host).map_err(
|e| -> Box<dyn std::error::Error + Send + Sync> {
Error::Tls(format!("invalid server name '{tls_host}': {e}")).into()
},
)?;
if let Some(ref m) = metrics {
m.record_direct_tls_attempt();
}
let stream = match tls_connector.connect(server_name, tokio_stream).await {
Ok(s) => s,
Err(e) => {
if let Some(ref m) = metrics {
m.record_direct_tls_failure();
}
return Err(Box::new(Error::Tls(format!("TLS handshake failed: {e}")))
as Box<dyn std::error::Error + Send + Sync>);
}
};
DirectStream::Tls(Box::new(stream))
} else {
DirectStream::Tcp(tokio_stream)
};
#[cfg(not(feature = "tls-rustls"))]
let direct_stream = if is_https {
return Err(Box::new(Error::Tls(
"HTTPS requested but the tls-rustls feature is disabled".into(),
))
as Box<dyn std::error::Error + Send + Sync>);
} else {
DirectStream::Tcp(tokio_stream)
};
Ok(hyper_util::rt::TokioIo::new(direct_stream))
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn connector_config_is_clone() {
let config = DirectConnectorConfig {
local_address: None,
socket_options: vec![SocketOption {
level: 0,
option: 0,
value: 1i32.to_ne_bytes().to_vec(),
kind: Some(SocketOptionKind::TcpNoDelay),
}],
};
let _cloned = config.clone();
}
#[test]
fn socket_option_stores_raw_value() {
let opt = SocketOption {
level: 0,
option: 0,
value: 1i32.to_ne_bytes().to_vec(),
kind: Some(SocketOptionKind::TcpNoDelay),
};
assert_eq!(opt.value.len(), 4);
}
#[test]
fn tls_server_name_accepts_ip_literals() {
assert!(tls_server_name("127.0.0.1").is_ok());
assert!(tls_server_name("::1").is_ok());
assert!(tls_server_name("[::1]").is_ok());
}
#[test]
fn apply_socket_option_nodelay() {
let socket = tokio::net::TcpSocket::new_v4().unwrap();
let opt = SocketOption {
level: 0,
option: 0,
value: 1i32.to_ne_bytes().to_vec(),
kind: Some(SocketOptionKind::TcpNoDelay),
};
apply_socket_option(&socket, &opt).unwrap();
}
#[test]
fn apply_socket_option_keepalive() {
let socket = tokio::net::TcpSocket::new_v4().unwrap();
let opt = SocketOption {
level: 0,
option: 0,
value: 1i32.to_ne_bytes().to_vec(),
kind: Some(SocketOptionKind::KeepAlive),
};
apply_socket_option(&socket, &opt).unwrap();
}
#[test]
fn apply_socket_option_unrecognized_returns_error() {
let socket = tokio::net::TcpSocket::new_v4().unwrap();
let opt = SocketOption {
level: 999,
option: 999,
value: vec![0, 1, 2, 3],
kind: None,
};
let err = apply_socket_option(&socket, &opt).unwrap_err();
assert_eq!(err.kind(), "connect");
assert!(err.to_string().contains("unsupported socket option"));
}
#[test]
fn apply_socket_option_short_value_returns_error() {
let socket = tokio::net::TcpSocket::new_v4().unwrap();
let opt = SocketOption {
level: 0,
option: 0,
value: vec![1],
kind: Some(SocketOptionKind::TcpNoDelay),
};
let err = apply_socket_option(&socket, &opt).unwrap_err();
assert_eq!(err.kind(), "connect");
assert!(err.to_string().contains("too short"));
}
#[test]
fn tcp_failure_classification_requires_all_attempts_to_be_refused() {
assert_eq!(
classify_tcp_failures(2, 2),
crate::transport::ConnectFailureKind::ConnectionRefused
);
assert_eq!(
classify_tcp_failures(2, 1),
crate::transport::ConnectFailureKind::Connect
);
assert_eq!(
classify_tcp_failures(0, 0),
crate::transport::ConnectFailureKind::Connect
);
}
#[test]
fn direct_dns_error_keeps_private_structured_category() {
let error = DirectConnectError::new(
crate::transport::ConnectFailureKind::Dns,
"DNS resolution failed".into(),
Some(std::io::Error::new(
std::io::ErrorKind::AddrNotAvailable,
"synthetic resolver failure",
)),
);
assert_eq!(error.kind(), crate::transport::ConnectFailureKind::Dns);
assert_eq!(error.to_string(), "DNS resolution failed");
assert!(std::error::Error::source(&error).is_some());
}
}