Hyper

https://docs.rs/hyper
Admin
Hyper is a fast and correct HTTP implementation in Rust, serving as a building block for libraries...
Tokens:167,543
Snippets:701
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Windows system proxy setup with registry

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/proxy/matcher.rs.html

Windows system proxy setup: reads the Internet Settings registry key, checks ProxyEnable, and fills builder.http, builder.https, and builder.no from ProxyServer and ProxyOverride. The helper converts IPv4 wildcard entries (e.g., "*.example.com") to CIDR notation and joins them with commas.

```rust
fn ipv4_wildcard_to_cidr(value: &str) -> Option<String> {
    let parts = value.split('.').collect::<Vec<_>>();
    let wildcard = parts.iter().position(|part| *part == "*")?;

    if wildcard == 0 || wildcard > 3 || parts[wildcard..].iter().any(|part| *part != "*") {
        return None;
    }

    let mut octets = [0; 4];
    for (index, part) in parts[..wildcard].iter().enumerate() {
        octets[index] = part.parse().ok()?;
    }

    Some(format!(
        "{}.{}.{}.{}/{}",
        octets[0],
        octets[1],
        octets[2],
        octets[3],
        wildcard * 8
    ))
}
```

```rust
pub(super) fn normalize_proxy_override(value: &str) -> String {
    value
        .split(';')
        .map(|entry| {
            let entry = entry.trim();
            ipv4_wildcard_to_cidr(entry).unwrap_or_else(|| entry.to_string())
        })
        .collect::<Vec<_>>()
        .join(",")
        .replace("*.", "")
}
```

```rust
pub(super) fn with_system(builder: &mut super::Builder) {
    let settings = if let Ok(settings) = windows_registry::CURRENT_USER
        .open("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
    {
        settings
    } else {
        return;
    };

    if settings.get_u32("ProxyEnable").unwrap_or(0) == 0 {
        return;
    }

    if let Ok(val) = settings.get_string("ProxyServer") {
        if builder.http.is_empty() {
            builder.http = val.clone();
        }
        if builder.https.is_empty() {
            builder.https = val;
        }
    }

    if builder.no.is_empty() {
        if let Ok(val) = settings.get_string("ProxyOverride") {
            builder.no = normalize_proxy_override(&val);
        }
    }
}
```

--------------------------------

### DomainMatcher test setup

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/proxy/matcher.rs.html

Test setup for DomainMatcher: creates a matcher with a list of domain strings. The test is named test_domain_matcher and uses the super::* import.

```rust
let domains = vec![".foo.bar".into(), "bar.foo".into()];
let matcher = DomainMatcher(domains);
```

--------------------------------

### Server construction with configuration options

Source: https://docs.rs/hyper/latest/src/hyper/proto/h2/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Builds an HTTP/2 server from a config, applying optional settings like max concurrent streams, header table size, and enabling CONNECT protocol. Sets up ping configuration with adaptive window and keep-alive settings.

```rust
141            .max_local_error_reset_streams(config.max_local_error_reset_streams)
142            .max_send_buffer_size(config.max_send_buffer_size);
143        if let Some(max) = config.max_concurrent_streams {
144            builder.max_concurrent_streams(max);
145        }
146        if let Some(max) = config.max_pending_accept_reset_streams {
147            builder.max_pending_accept_reset_streams(max);
148        }
149        if let Some(size) = config.header_table_size {
150            builder.header_table_size(size);
151        }
152        if config.enable_connect_protocol {
153            builder.enable_connect_protocol();
154        }
155        let handshake = builder.handshake(Compat::new(io));
156
157        let bdp = if config.adaptive_window {
158            Some(config.initial_stream_window_size)
159        } else {
160            None
161        };
162
163        let ping_config = ping::Config {
164            bdp_initial_window: bdp,
165            keep_alive_interval: config.keep_alive_interval,
166            keep_alive_timeout: config.keep_alive_timeout,
167            // If keep-alive is enabled for servers, always enabled while
168            // idle, so it can more aggressively close dead connections.
169            keep_alive_while_idle: true,
170        };
171
172        Server {
173            exec,
174            timer,
175            state: State::Handshaking {
176                ping_config,
177                hs: handshake,
178            },
179            service,
180            date_header: config.date_header,
181            close_pending: false,
182        }
183    }
184
185    pub(crate) fn graceful_shutdown(&mut self) {
186        trace!("graceful_shutdown");
187        match &mut self.state {
188            State::Handshaking { .. } => {
189                self.close_pending = true;
190            }
191            State::Serving(srv) => {
192                if srv.closing.is_none() {
193                    srv.conn.graceful_shutdown();
194                }
195            }
196        }
197    }
198}
```

--------------------------------

### GET without body length decodes to DecodedLength::ZERO

Source: https://docs.rs/hyper/latest/src/hyper/proto/h1/role.rs.html

Asserts that a GET request without Content-Length or Transfer-Encoding is decoded as a zero-length body. Part of the test_decoder_request coverage for missing length indicators.

```Rust
assert_eq!(
    parse(
        "\
         GET / HTTP/1.1\r\n\
         \r\n\
         "
    )
    .decode,
    DecodedLength::ZERO
);
```

--------------------------------

### Serve connection with hyper builder and hello handler

Source: https://docs.rs/hyper-util/latest/src/hyper_util/server/conn/auto/mod.rs.html?search=std%3A%3Avec

Shows how to serve an HTTP/1.1 or HTTP/2 connection with hyper's builder, choosing between plain, HTTP/2-only, and HTTP/2 with upgrades based on a boolean flag. The hello handler returns a static response body.

```rust
builder.serve_connection(stream, service_fn(hello)).await
} else if h2_only {
    builder = builder.http2_only();
    builder.serve_connection(stream, service_fn(hello)).await
} else {
    builder
        .http2()
        .max_header_list_size(4096)
        .serve_connection_with_upgrades(stream, service_fn(hello))
        .await
}
.unwrap();
```

```rust
async fn hello(_req: Request<body::Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
    Ok(Response::new(Full::new(Bytes::from(BODY))))
}
```

--------------------------------

### Lazy future implementation in Rust

Source: https://docs.rs/hyper-util/latest/src/hyper_util/common/lazy.rs.html?search=u32+-%3E+bool

Defines a `Lazy` future that defers creation of the inner future until first poll. Uses `pin_project_lite` for pin projection and implements the `Future` trait. The `Started` trait indicates whether the future has been started.

```rust
use pin_project_lite::pin_project;

use std::pin::Pin;
use std::task::{self, Poll};

pub(crate) trait Started: Future {
    fn started(&self) -> bool;
}

pub(crate) fn lazy<F, R>(func: F) -> Lazy<F, R>
where
    F: FnOnce() -> R,
    R: Future + Unpin,
{
    Lazy {
        inner: Inner::Init { func },
    }
}

// FIXME: allow() required due to `impl Trait` leaking types to this lint
pin_project! {
    #[allow(missing_debug_implementations)]
    pub(crate) struct Lazy<F, R> {
        #[pin]
        inner: Inner<F, R>,
    }
}

pin_project! {
    #[project = InnerProj]
    #[project_replace = InnerProjReplace]
    enum Inner<F, R> {
        Init { func: F },
        Fut { #[pin] fut: R },
        Empty,
    }
}

impl<F, R> Started for Lazy<F, R>
where
    F: FnOnce() -> R,
    R: Future,
{
    fn started(&self) -> bool {
        match self.inner {
            Inner::Init { .. } => false,
            Inner::Fut { .. } | Inner::Empty => true,
        }
    }
}

impl<F, R> Future for Lazy<F, R>
where
    F: FnOnce() -> R,
    R: Future,
{
    type Output = R::Output;

    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
        let mut this = self.project();

        if let InnerProj::Fut { fut } = this.inner.as_mut().project() {
            return fut.poll(cx);
        }

        match this.inner.as_mut().project_replace(Inner::Empty) {
            InnerProjReplace::Init { func } => {
                this.inner.set(Inner::Fut { fut: func() });
                if let InnerProj::Fut { fut } = this.inner.project() {
                    return fut.poll(cx);
                }
                unreachable!()
            }
            _ => unreachable!("lazy state wrong"),
        }
    }
}

```

--------------------------------

### Buf::get_i8

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 8-bit integer from the buffer.

```APIDOC
## Buf::get_i8

### Description
Gets a signed 8-bit integer from the buffer.

### Method
`fn get_i8(&mut self) -> i8`

### Parameters
None

### Returns
- `i8` - The signed 8-bit integer.
```

--------------------------------

### Helper: start_server spawns auto server with protocol options

Source: https://docs.rs/hyper-util/latest/src/hyper_util/server/conn/auto/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Binds a TCP listener and spawns a task that accepts connections and serves them using auto::Builder with optional http1_only or http2_only settings.

```rust
async fn start_server(h1_only: bool, h2_only: bool) -> SocketAddr {
    let addr: SocketAddr = ([127, 0, 0, 1], 0).into();
    let listener = TcpListener::bind(addr).await.unwrap();

    let local_addr = listener.local_addr().unwrap();

    tokio::spawn(async move {
        loop {
            let (stream, _) = listener.accept().await.unwrap();
            let stream = TokioIo::new(stream);
            tokio::task::spawn(async move {
                let mut builder = auto::Builder::new(TokioExecutor::new());
                if h1_only {
                    builder = builder.http1_only();
```

--------------------------------

### macOS system proxy setup with SCDynamicStore

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/proxy/matcher.rs.html

Reads macOS system proxy settings from the dynamic store and populates the builder's HTTP and HTTPS proxy fields only when they are empty. The helper parses the enable flag, host, and port keys, returning a formatted host:port string when both are present, otherwise the host alone or None.

```rust
let store = if let Some(store) = SCDynamicStoreBuilder::new("hyper-util").build() {
    store
} else {
    return;
};

let proxies_map = if let Some(proxies_map) = store.get_proxies() {
    proxies_map
} else {
    return;
};

if builder.http.is_empty() {
    let http_proxy_config = parse_setting_from_dynamic_store(
        &proxies_map,
        unsafe { kSCPropNetProxiesHTTPEnable },
        unsafe { kSCPropNetProxiesHTTPProxy },
        unsafe { kSCPropNetProxiesHTTPPort },
    );
    if let Some(http) = http_proxy_config {
        builder.http = http;
    }
}

if builder.https.is_empty() {
    let https_proxy_config = parse_setting_from_dynamic_store(
        &proxies_map,
        unsafe { kSCPropNetProxiesHTTPSEnable },
        unsafe { kSCPropNetProxiesHTTPSProxy },
        unsafe { kSCPropNetProxiesHTTPSPort },
    );

    if let Some(https) = https_proxy_config {
        builder.https = https;
    }
}
```

```rust
fn parse_setting_from_dynamic_store(
    proxies_map: &CFDictionary<CFString, CFType>,
    enabled_key: CFStringRef,
    host_key: CFStringRef,
    port_key: CFStringRef,
) -> Option<String> {
    let proxy_enabled = proxies_map
        .find(enabled_key)
        .and_then(|flag| flag.downcast::<CFNumber>())
        .and_then(|flag| flag.to_i32())
        .unwrap_or(0)
        == 1;

    if proxy_enabled {
        let proxy_host = proxies_map
            .find(host_key)
            .and_then(|host| host.downcast::<CFString>())
            .map(|host| host.to_string());
        let proxy_port = proxies_map
            .find(port_key)
            .and_then(|port| port.downcast::<CFNumber>())
            .and_then(|port| port.to_i32());

        return match (proxy_host, proxy_port) {
            (Some(proxy_host), Some(proxy_port)) => Some(format!("{proxy_host}:{proxy_port}")),
            (Some(proxy_host), None) => Some(proxy_host),
            (None, Some(_)) => None,
            (None, None) => None,
        };
    }

    None
}
```

--------------------------------

### on_upgrade method

Source: https://docs.rs/hyper/latest/src/hyper/proto/h1/conn.rs.html?search=std%3A%3Avec

Prepares the connection for a possible HTTP upgrade and returns the upgrade handle. Logs a trace message with the connection type's log target.

```rust
pub(super) fn on_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
    trace!("{}: prepare possible HTTP upgrade", T::LOG);
    self.state.prepare_upgrade()
}
```

--------------------------------

### Buf::get_i128_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 128-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_i128_ne

### Description
Gets a signed 128-bit integer from the buffer in native-endian byte order.

### Method
`fn get_i128_ne(&mut self) -> i128`

### Parameters
None

### Returns
- `i128` - The signed 128-bit integer.
```

--------------------------------

### Buf::get_i128_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 128-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_i128_le

### Description
Gets a signed 128-bit integer from the buffer in little-endian byte order.

### Method
`fn get_i128_le(&mut self) -> i128`

### Parameters
None

### Returns
- `i128` - The signed 128-bit integer.
```

--------------------------------

### Windows: Read System Proxy Settings from Registry

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/proxy/matcher.rs.html?search=std%3A%3Avec

Opens the Windows registry key for Internet Settings, checks ProxyEnable, and sets the builder's HTTP, HTTPS, and no-proxy values from ProxyServer and ProxyOverride.

```rust
pub(super) fn with_system(builder: &mut super::Builder) {
    let settings = if let Ok(settings) = windows_registry::CURRENT_USER
        .open("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings")
    {
        settings
    } else {
        return;
    };

    if settings.get_u32("ProxyEnable").unwrap_or(0) == 0 {
        return;
    }

    if let Ok(val) = settings.get_string("ProxyServer") {
        if builder.http.is_empty() {
            builder.http = val.clone();
        }
        if builder.https.is_empty() {
            builder.https = val;
        }
    }

    if builder.no.is_empty() {
        if let Ok(val) = settings.get_string("ProxyOverride") {
            builder.no = normalize_proxy_override(&val);
        }
    }
}
```

--------------------------------

### Buf::get_i128

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 128-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_i128

### Description
Gets a signed 128-bit integer from the buffer in big-endian byte order.

### Method
`fn get_i128(&mut self) -> i128`

### Parameters
None

### Returns
- `i128` - The signed 128-bit integer.
```

--------------------------------

### Serve connection with auto builder and hello handler

Source: https://docs.rs/hyper-util/latest/src/hyper_util/server/conn/auto/mod.rs.html?search=u32+-%3E+bool

Configures a hyper-util auto connection builder to serve a connection with optional HTTP/2-only mode and upgrades. The builder is conditionally set to HTTP/2-only if h2_only is true, otherwise it enables HTTP/2 with a max header list size of 4096 and serves with upgrades. The hello handler returns a response with a fixed body.

```rust
builder.serve_connection(stream, service_fn(hello)).await
} else if h2_only {
    builder = builder.http2_only();
    builder.serve_connection(stream, service_fn(hello)).await
} else {
    builder
        .http2()
        .max_header_list_size(4096)
        .serve_connection_with_upgrades(stream, service_fn(hello))
        .await
}
.unwrap();
});
}
});

local_addr
}

async fn hello(_req: Request<body::Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
    Ok(Response::new(Full::new(Bytes::from(BODY))))
}
}
```

--------------------------------

### Buf::get_u128_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 128-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_u128_ne

### Description
Gets an unsigned 128-bit integer from the buffer in native-endian byte order.

### Method
`fn get_u128_ne(&mut self) -> u128`

### Parameters
None

### Returns
- `u128` - The unsigned 128-bit integer.
```

--------------------------------

### Server builder configuration and handshake

Source: https://docs.rs/hyper/latest/src/hyper/proto/h2/server.rs.html?search=

Configures the HTTP/2 server builder with optional settings like max concurrent streams, header table size, and connect protocol, then performs the handshake. Sets up ping configuration with adaptive window and keep-alive settings.

```rust
            .max_local_error_reset_streams(config.max_local_error_reset_streams)
            .max_send_buffer_size(config.max_send_buffer_size);
        if let Some(max) = config.max_concurrent_streams {
            builder.max_concurrent_streams(max);
        }
        if let Some(max) = config.max_pending_accept_reset_streams {
            builder.max_pending_accept_reset_streams(max);
        }
        if let Some(size) = config.header_table_size {
            builder.header_table_size(size);
        }
        if config.enable_connect_protocol {
            builder.enable_connect_protocol();
        }
        let handshake = builder.handshake(Compat::new(io));

        let bdp = if config.adaptive_window {
            Some(config.initial_stream_window_size)
        } else {
            None
        };

        let ping_config = ping::Config {
            bdp_initial_window: bdp,
            keep_alive_interval: config.keep_alive_interval,
            keep_alive_timeout: config.keep_alive_timeout,
            // If keep-alive is enabled for servers, always enabled while
            // idle, so it can more aggressively close dead connections.
            keep_alive_while_idle: true,
        };

        Server {
            exec,
            timer,
            state: State::Handshaking {
                ping_config,
                hs: handshake,
            },
            service,
            date_header: config.date_header,
            close_pending: false,
        }
```

--------------------------------

### Buf::get_u128_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 128-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_u128_le

### Description
Gets an unsigned 128-bit integer from the buffer in little-endian byte order.

### Method
`fn get_u128_le(&mut self) -> u128`

### Parameters
None

### Returns
- `u128` - The unsigned 128-bit integer.
```

--------------------------------

### Buf::get_u128

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 128-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_u128

### Description
Gets an unsigned 128-bit integer from the buffer in big-endian byte order.

### Method
`fn get_u128(&mut self) -> u128`

### Parameters
None

### Returns
- `u128` - The unsigned 128-bit integer.
```

--------------------------------

### Prepare HTTP/1 connection upgrade

Source: https://docs.rs/hyper/latest/src/hyper/proto/h1/conn.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Prepares an upgrade by creating a pending upgrade channel, storing the sender in self.upgrade, and returning the receiver.

```rust
fn prepare_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
    let (tx, rx) = crate::upgrade::pending();
    self.upgrade = Some(tx);
    rx
}
```

--------------------------------

### Test sync_capture_connection: set proxy and assert metadata

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/capture.rs.html?search=u32+-%3E+bool

Creates a CaptureConnection, sets Connected with proxy(true), and asserts connection_metadata() returns a proxied connection. Also verifies the metadata can be queried multiple times.

```rust
#[tokio::test]
async fn sync_capture_connection() {
    let (tx, mut rx) = CaptureConnection::new();
    assert!(
        rx.connection_metadata().is_none(),
        "connection has not been set"
    );

    tx.set(&Connected::new().proxy(true));
    assert!(
        rx.connection_metadata()
            .as_ref()
            .expect("connected should be set")
            .is_proxied()
    );

    // ensure it can be called multiple times
    assert!(
        rx.connection_metadata()
            .as_ref()
            .expect("connected should be set")
            .is_proxied()
    );
}
```

--------------------------------

### Buf::get_i64_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 64-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_i64_ne

### Description
Gets a signed 64-bit integer from the buffer in native-endian byte order.

### Method
`fn get_i64_ne(&mut self) -> i64`

### Parameters
None

### Returns
- `i64` - The signed 64-bit integer.
```

--------------------------------

### Buf::get_i64_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 64-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_i64_le

### Description
Gets a signed 64-bit integer from the buffer in little-endian byte order.

### Method
`fn get_i64_le(&mut self) -> i64`

### Parameters
None

### Returns
- `i64` - The signed 64-bit integer.
```

--------------------------------

### ConnectingTcpRemote::connect with error handling

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/http.rs.html?search=std%3A%3Avec

Attempts to connect to each address in sequence, returning the first successful connection or the first error encountered.

```rust
impl ConnectingTcpRemote {
    async fn connect(&mut self, config: &Config) -> Result<TcpStream, ConnectError> {
        let mut err = None;
        for addr in &mut self.addrs {
            debug!("connecting to {}", addr);
            match connect(&addr, config, self.connect_timeout)?.await {
                Ok(tcp) => {
                    debug!("connected to {}", addr);
                    return Ok(tcp);
                }
                Err(mut e) => {
                    trace!("connect error for {}: {:?}", addr, e);
                    e.addr = Some(addr);
                    // only return the first error, we assume it's the most relevant
                    if err.is_none() {
                        err = Some(e);
                    }
                }
            }
        }

        match err {
            Some(e) => Err(e),
            None => Err(ConnectError::new(
                "tcp connect error",
                std::io::Error::new(std::io::ErrorKind::NotConnected, "Network unreachable"),
            )),
        }
    }
}
```

--------------------------------

### Connection readiness error handling and pool creation

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/client.rs.html?search=u32+-%3E+bool

Handles connection readiness failure by logging and returning an error wrapped in Error::tx. If the http1 feature is not enabled, panics. On success, creates a pooled client with the connection info and transaction.

```rust
trace!("connection readiness failed: {:?}", e);
// Return the error wrapped in Error::tx to propagate it.
return Err(crate::client::legacy::client::Error::tx(e));
```

```rust
#[cfg(not(feature = "http1"))] {
    panic!("http1 feature is not enabled");
}
```

```rust
Ok(pool.pooled(
    connecting,
    PoolClient {
        conn_info: connected,
        tx,
    },
))
```

--------------------------------

### Buf::get_i64

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 64-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_i64

### Description
Gets a signed 64-bit integer from the buffer in big-endian byte order.

### Method
`fn get_i64(&mut self) -> i64`

### Parameters
None

### Returns
- `i64` - The signed 64-bit integer.
```

--------------------------------

### SOCKS4 handshaking future setup

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/proxy/socks/v4/mod.rs.html?search=

Sets up the SOCKS4 handshaking future by stripping IPv6 brackets from the host, awaiting the connection, and executing the configuration. Used in the legacy client connect module.

```rust
let host = crate::client::strip_ipv6_brackets(host_from_uri).to_string();

let conn = connecting.await.map_err(SocksError::Inner)?;
config.execute(conn, host, port).await
};

Handshaking {
    fut: Box::pin(fut),
    _marker: Default::default(),
}
```

--------------------------------

### Buf::get_u64_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 64-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_u64_ne

### Description
Gets an unsigned 64-bit integer from the buffer in native-endian byte order.

### Method
`fn get_u64_ne(&mut self) -> u64`

### Parameters
None

### Returns
- `u64` - The unsigned 64-bit integer.
```

--------------------------------

### Helper: connect_h1 establishes HTTP/1 client connection

Source: https://docs.rs/hyper-util/latest/src/hyper_util/server/conn/auto/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Connects to the given address using HTTP/1 handshake and spawns the connection task. Returns the SendRequest handle.

```rust
async fn connect_h1<B>(addr: SocketAddr) -> client::conn::http1::SendRequest<B>
where
    B: Body + Send + 'static,
    B::Data: Send,
    B::Error: Into<Box<dyn StdError + Send + Sync>>,
{
    let stream = TokioIo::new(TcpStream::connect(addr).await.unwrap());
    let (sender, connection) = client::conn::http1::handshake(stream).await.unwrap();

    tokio::spawn(connection);

    sender
}
```

--------------------------------

### Buf::get_u64_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 64-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_u64_le

### Description
Gets an unsigned 64-bit integer from the buffer in little-endian byte order.

### Method
`fn get_u64_le(&mut self) -> u64`

### Parameters
None

### Returns
- `u64` - The unsigned 64-bit integer.
```

--------------------------------

### Buf::get_u64

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 64-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_u64

### Description
Gets an unsigned 64-bit integer from the buffer in big-endian byte order.

### Method
`fn get_u64(&mut self) -> u64`

### Parameters
None

### Returns
- `u64` - The unsigned 64-bit integer.
```

--------------------------------

### ConnectingTcpRemote::new with timeout division

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/http.rs.html?search=std%3A%3Avec

Creates a ConnectingTcpRemote, dividing the connect timeout by the number of addresses to allocate per-address time.

```rust
impl ConnectingTcpRemote {
    fn new(addrs: dns::SocketAddrs, connect_timeout: Option<Duration>) -> Self {
        let connect_timeout = connect_timeout.and_then(|t| t.checked_div(addrs.len() as u32));

        Self {
            addrs,
            connect_timeout,
        }
    }
}
```

--------------------------------

### Clone implementation for Client<C, B>

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/client.rs.html?search=u32+-%3E+bool

Clones the client by copying config, exec, and connector, and conditionally cloning h1_builder and h2_builder based on feature flags, and cloning the pool.

```rust
impl<C: Clone, B> Clone for Client<C, B> {
    fn clone(&self) -> Client<C, B> {
        Client {
            config: self.config,
            exec: self.exec.clone(),
            #[cfg(feature = "http1")]
            h1_builder: self.h1_builder.clone(),
            #[cfg(feature = "http2")]
            h2_builder: self.h2_builder.clone(),
            connector: self.connector.clone(),
            pool: self.pool.clone(),
        }
    }
}
```

--------------------------------

### Buf::get_i32_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 32-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_i32_ne

### Description
Gets a signed 32-bit integer from the buffer in native-endian byte order.

### Method
`fn get_i32_ne(&mut self) -> i32`

### Parameters
None

### Returns
- `i32` - The signed 32-bit integer.
```

--------------------------------

### Buf::get_i32_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 32-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_i32_le

### Description
Gets a signed 32-bit integer from the buffer in little-endian byte order.

### Method
`fn get_i32_le(&mut self) -> i32`

### Parameters
None

### Returns
- `i32` - The signed 32-bit integer.
```

--------------------------------

### Test async_capture_connection: await metadata after set

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/capture.rs.html?search=u32+-%3E+bool

Spawns a task that awaits wait_for_connection_metadata() and asserts the connection is proxied. Verifies the await can be repeated and that the task does not finish until tx.set() is called.

```rust
#[tokio::test]
async fn async_capture_connection() {
    let (tx, mut rx) = CaptureConnection::new();
    assert!(
        rx.connection_metadata().is_none(),
        "connection has not been set"
    );
    let test_task = tokio::spawn(async move {
        assert!(
            rx.wait_for_connection_metadata()
                .await
                .as_ref()
                .expect("connection should be set")
                .is_proxied()
        );
        // can be awaited multiple times
        assert!(
            rx.wait_for_connection_metadata().await.is_some(),
            "should be awaitable multiple times"
        );

        assert!(rx.connection_metadata().is_some());
    });
    // can't be finished, we haven't set the connection yet
    assert!(!test_task.is_finished());
    tx.set(&Connected::new().proxy(true));

    assert!(test_task.await.is_ok());
}
```

--------------------------------

### WeakOpt implementation

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/pool.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines WeakOpt, a wrapper around Option<Weak<T>>, with methods none, downgrade, and upgrade.

```rust
impl<T> WeakOpt<T> {
    fn none() -> Self {
        WeakOpt(None)
    }

    fn downgrade(arc: &Arc<T>) -> Self {
        WeakOpt(Some(Arc::downgrade(arc)))
    }

    fn upgrade(&self) -> Option<Arc<T>> {
        self.0.as_ref().and_then(Weak::upgrade)
    }
}
```

--------------------------------

### Buf::get_i32

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 32-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_i32

### Description
Gets a signed 32-bit integer from the buffer in big-endian byte order.

### Method
`fn get_i32(&mut self) -> i32`

### Parameters
None

### Returns
- `i32` - The signed 32-bit integer.
```

--------------------------------

### Buf::get_u32_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 32-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_u32_ne

### Description
Gets an unsigned 32-bit integer from the buffer in native-endian byte order.

### Method
`fn get_u32_ne(&mut self) -> u32`

### Parameters
None

### Returns
- `u32` - The unsigned 32-bit integer.
```

--------------------------------

### Singleton Service Implementation: poll_ready, call, send_result, store_waker, store_driver_waker, wake_driver

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/pool/singleton.rs.html?search=u32+-%3E+bool

Core implementation of the Singleton service. Handles polling readiness, driving the inner service, storing wakers for waiting calls, and waking the driver when the inner service is ready.

```rust
                    let err = box_error_into_shared(err.into());
                    self.future = None;
                    Poll::Ready(Err(err))
                }
            }
        }

        fn send_result(&mut self, result: Result<S, SharedError>)
        where
            S: Clone,
        {
            for waiter in std::mem::take(&mut self.waiters) {
                let _ = waiter.tx.send(result.clone());
            }
        }

        fn store_waker(&mut self, id: WaiterId, waker: &Waker) {
            if let Some(waiter) = self.waiters.iter_mut().find(|waiter| waiter.id == id) {
                if waiter
                    .waker
                    .as_ref()
                    .is_none_or(|current| !current.will_wake(waker))
                {
                    waiter.waker = Some(waker.clone());
                }
            }
        }

        fn store_driver_waker(&mut self, waker: &Waker) {
            if let Some(driver) = &mut self.driver {
                if driver
                    .waker
                    .as_ref()
                    .is_none_or(|current| !current.will_wake(waker))
                {
                    driver.waker = Some(waker.clone());
                }
            }
        }

        fn wake_driver(&mut self) {
            if let Some(driver) = &mut self.driver {
                if let Some(waker) = driver.waker.take() {
                    waker.wake();
                }
            }
        }
    }
```

--------------------------------

### Test module with test_makes_svc_when_empty

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/pool/cache.rs.html?search=

Starts the test module for the connection pool. It imports the necessary types and defines a tokio test that creates a mock service pair to verify behavior when the pool is empty. The test is incomplete in the source, showing only the beginning of the test function.

```rust
#[cfg(test)]
mod tests {
    use std::convert::Infallible;
    use std::sync::{
        Arc, Mutex,
        atomic::{AtomicUsize, Ordering},
    };
    use std::task::{self, Poll};

    use futures_util::future;
    use tower_service::Service;
    use tower_test::assert_request_eq;

    #[tokio::test]
    async fn test_makes_svc_when_empty() {
        let (mock, mut handle) = tower_test::mock::pair();
```

--------------------------------

### Buf::get_u32_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 32-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_u32_le

### Description
Gets an unsigned 32-bit integer from the buffer in little-endian byte order.

### Method
`fn get_u32_le(&mut self) -> u32`

### Parameters
None

### Returns
- `u32` - The unsigned 32-bit integer.
```

--------------------------------

### ClientTask helper methods

Source: https://docs.rs/hyper/latest/src/hyper/proto/h2/client.rs.html?search=u32+-%3E+bool

Provides methods to query extended connect protocol and current max send/recv streams.

```rust
impl<B, E, T> ClientTask<B, E, T>
where
    B: Body + 'static,
    E: Http2ClientConnExec<B, T> + Unpin,
    B::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
    T: Read + Write + Unpin,
{
    pub(crate) fn is_extended_connect_protocol_enabled(&self) -> bool {
        self.h2_tx.is_extended_connect_protocol_enabled()
    }
    pub(crate) fn current_max_send_streams(&self) -> usize {
        self.h2_tx.current_max_send_streams()
    }
    pub(crate) fn current_max_recv_streams(&self) -> usize {
        self.h2_tx.current_max_recv_streams()
    }
}
```

--------------------------------

### Buf::get_u32

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 32-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_u32

### Description
Gets an unsigned 32-bit integer from the buffer in big-endian byte order.

### Method
`fn get_u32(&mut self) -> u32`

### Parameters
None

### Returns
- `u32` - The unsigned 32-bit integer.
```

--------------------------------

### Buf::get_i16_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 16-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_i16_ne

### Description
Gets a signed 16-bit integer from the buffer in native-endian byte order.

### Method
`fn get_i16_ne(&mut self) -> i16`

### Parameters
None

### Returns
- `i16` - The signed 16-bit integer.
```

--------------------------------

### HTTP/1 connection state methods: close, keep-alive, idle, upgrade

Source: https://docs.rs/hyper/latest/src/hyper/proto/h1/conn.rs.html?search=u32+-%3E+bool

Methods on the HTTP/1 connection state machine that manage read/write closure, keep-alive status, idle transitions, and upgrade preparation. `try_keep_alive` closes the connection when both sides are not in KeepAlive state or when the keep-alive status is not Busy; `idle` resets reading/writing to Init and sets `notify_read` for client connections or when a header read timeout is configured. `prepare_upgrade` returns an `OnUpgrade` receiver for an HTTP upgrade.

```rust
fn close_read(&mut self) {
    trace!("State::close_read()");
    self.reading = Reading::Closed;
    self.keep_alive.disable();
}

fn close_write(&mut self) {
    trace!("State::close_write()");
    self.writing = Writing::Closed;
    self.keep_alive.disable();
}

fn wants_keep_alive(&self) -> bool {
    !matches!(self.keep_alive.status(), KA::Disabled)
}

fn try_keep_alive<T: Http1Transaction>(&mut self) {
    match (&self.reading, &self.writing) {
        (&Reading::KeepAlive, &Writing::KeepAlive) => {
            if let KA::Busy = self.keep_alive.status() {
                self.idle::<T>();
            } else {
                trace!(
                    "try_keep_alive({}): could keep-alive, but status = {:?}",
                    T::LOG,
                    self.keep_alive
                );
                self.close();
            }
        }
        (&Reading::Closed, &Writing::KeepAlive) | (&Reading::KeepAlive, &Writing::Closed) => {
            self.close();
        }
        _ => (),
    }
}

fn disable_keep_alive(&mut self) {
    self.keep_alive.disable();
}

fn busy(&mut self) {
    if let KA::Disabled = self.keep_alive.status() {
        return;
    }
    self.keep_alive.busy();
}

fn idle<T: Http1Transaction>(&mut self) {
    debug_assert!(!self.is_idle(), "State::idle() called while idle");

    self.method = None;
    self.keep_alive.idle();

    if !self.is_idle() {
        self.close();
        return;
    }

    self.reading = Reading::Init;
    self.writing = Writing::Init;

    // !T::should_read_first() means Client.
    //
    // If Client connection has just gone idle, the Dispatcher
    // should try the poll loop one more time, so as to poll the
    // pending requests stream.
    if !T::should_read_first() {
        self.notify_read = true;
    }

    #[cfg(feature = "server")]
    if self.h1_header_read_timeout.is_some() {
        // Next read will start and poll the header read timeout,
        // so we can close the connection if another header isn't
        // received in a timely manner.
        self.notify_read = true;
    }
}

fn is_idle(&self) -> bool {
    matches!(self.keep_alive.status(), KA::Idle)
}

fn is_read_closed(&self) -> bool {
    matches!(self.reading, Reading::Closed)
}

fn is_write_closed(&self) -> bool {
    matches!(self.writing, Writing::Closed)
}

fn prepare_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
    let (tx, rx) = crate::upgrade::pending();
    self.upgrade = Some(tx);
    rx
}
```

--------------------------------

### Buf::get_i16_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 16-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_i16_le

### Description
Gets a signed 16-bit integer from the buffer in little-endian byte order.

### Method
`fn get_i16_le(&mut self) -> i16`

### Parameters
None

### Returns
- `i16` - The signed 16-bit integer.
```

--------------------------------

### Test Name::from_str with a domain string

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/dns.rs.html?search=

Tests parsing a domain string into a Name using from_str, then verifies that as_str() and to_string() return the original domain. Expects the domain to be valid.

```rust
const DOMAIN: &str = "test.example.com";
let name = Name::from_str(DOMAIN).expect("Should be a valid domain");
assert_eq!(name.as_str(), DOMAIN);
assert_eq!(name.to_string(), DOMAIN);
```

--------------------------------

### Cache builder method

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/pool/cache.rs.html

Builds a Cache from a connector and events, initializing shared state with empty services, waiters, and reservations.

```rust
pub fn build<M, Dst>(self, connector: M) -> Cache<M, Dst, Ev>
    where
        M: Service<Dst>,
    {
        Cache {
            connector,
            events: self.events,
            ready: Ready::None,
            ready_waiter: None,
            shared: Arc::new(Mutex::new(Shared {
                services: Vec::new(),
                waiters: VecDeque::new(),
                reservations: Vec::new(),
                next_waiter: 0,
            })),
        }
    }
```

--------------------------------

### Buf::get_i16

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets a signed 16-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_i16

### Description
Gets a signed 16-bit integer from the buffer in big-endian byte order.

### Method
`fn get_i16(&mut self) -> i16`

### Parameters
None

### Returns
- `i16` - The signed 16-bit integer.
```

--------------------------------

### Buf::get_u16_ne

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 16-bit integer from the buffer in native-endian byte order.

```APIDOC
## Buf::get_u16_ne

### Description
Gets an unsigned 16-bit integer from the buffer in native-endian byte order.

### Method
`fn get_u16_ne(&mut self) -> u16`

### Parameters
None

### Returns
- `u16` - The unsigned 16-bit integer.
```

--------------------------------

### Test helper functions

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/pool.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides helper functions to create Connecting, KeyImpl, and Pool instances for tests.

```rust
fn c<T: Poolable, K: Key>(key: K) -> Connecting<T, K> {
    Connecting {
        key,
        pool: WeakOpt::none(),
    }
}

fn host_key(s: &str) -> KeyImpl {
    KeyImpl(http::uri::Scheme::HTTP, s.parse().expect("host key"))
}

fn pool_no_timer<T, K: Key>() -> Pool<T, K> {
    pool_max_idle_no_timer(usize::MAX)
}

fn pool_max_idle_no_timer<T, K: Key>(max_idle: usize) -> Pool<T, K> {
    let pool = Pool::new(
        super::Config {
            idle_timeout: Some(Duration::from_millis(100)),
            max_idle_per_host: max_idle,
        },
        TokioExecutor::new(),
        Option::<timer::Timer>::None,
    );
    pool.no_timer();
    pool
}
```

--------------------------------

### Buf::get_u16_le

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 16-bit integer from the buffer in little-endian byte order.

```APIDOC
## Buf::get_u16_le

### Description
Gets an unsigned 16-bit integer from the buffer in little-endian byte order.

### Method
`fn get_u16_le(&mut self) -> u16`

### Parameters
None

### Returns
- `u16` - The unsigned 16-bit integer.
```

--------------------------------

### Address Roundtrip Tests for IPv4, IPv6, and Domain

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/connect/proxy/socks/v5/messages.rs.html

Three test cases that verify address roundtrips for IPv4, IPv6, and domain addresses using the helper function.

```rust
#[test]
fn address_roundtrip_ipv4() {
    assert_address_roundtrips(Address::Socket(SocketAddr::new(
        Ipv4Addr::LOCALHOST.into(),
        8080,
    )));
}
```

```rust
#[test]
fn address_roundtrip_ipv6() {
    assert_address_roundtrips(Address::Socket(SocketAddr::new(
        Ipv6Addr::LOCALHOST.into(),
        8080,
    )));
}
```

```rust
#[test]
fn address_roundtrip_domain() {
    assert_address_roundtrips(Address::Domain("example.com".into(), 8080));
}
```

--------------------------------

### Buf::get_u16

Source: https://docs.rs/hyper/latest/hyper/body/trait.Buf.html?search=

Gets an unsigned 16-bit integer from the buffer in big-endian byte order.

```APIDOC
## Buf::get_u16

### Description
Gets an unsigned 16-bit integer from the buffer in big-endian byte order.

### Method
`fn get_u16(&mut self) -> u16`

### Parameters
None

### Returns
- `u16` - The unsigned 16-bit integer.
```

--------------------------------

### Service implementation for &Client<C, B>

Source: https://docs.rs/hyper-util/latest/src/hyper_util/client/legacy/client.rs.html?search=u32+-%3E+bool

Implements tower_service::Service for a reference to Client<C, B>, allowing the client to be used by reference. The call method delegates to self.request(req).

```rust
impl<C, B> tower_service::Service<Request<B>> for &'_ Client<C, B>
where
    C: Connect + Clone + Send + Sync + 'static,
    B: Body + Send + 'static + Unpin,
    B::Data: Send,
    B::Error: Into<Box<dyn StdError + Send + Sync>>,
{
    type Response = Response<hyper::body::Incoming>;
    type Error = Error;
    type Future = ResponseFuture;

    fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: Request<B>) -> Self::Future {
        self.request(req)
    }
}
```
Tokens:
Raw