Feat/native http client

[casibbald]

No description provided.

[gemini-code-assist]

Code Review

This pull request introduces a native HTTP/1.1 client module to may_minihttp under the client feature flag, providing a drop-in replacement for the abandoned may_http crate. It also updates the server-side response to support owned headers (ResponseHeader) without memory leaks, and adds a comprehensive suite of integration and performance tests. The review feedback highlights several critical issues in the new client implementation: an unsafe cast in the response decoder that violates Rust's aliasing rules and causes undefined behavior, an inefficient buffering strategy in BufferIo for large writes, a potential protocol violation where duplicate Host headers can be written, and a blocking risk in BodyWriter when dropping a writer with a large remaining size.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

This unsafe cast violates Rust's aliasing rules and introduces Undefined Behavior (UB). buf is mutably borrowed, but r.parse(buf) immutably borrows it through headers. Mutating buf via buf.split_to while those immutable references are still active is UB. We can achieve the exact same zero-allocation behavior safely by temporarily splitting the entire buffer into a local BytesMut, parsing it, and then using unsplit to restore the remaining body bytes back to buf.

    let mut r = httparse::Response::new(&mut headers);
    let mut temp = buf.split_to(buf.len());
    let status = r.parse(&temp).map_err(|e| {
        let msg = format!("failed to parse http Response: {:?}", e);
        io::Error::other(msg)
    })?;

    let bytes = match status {
        httparse::Status::Complete(amt) => {
            let bytes = temp.split_to(amt).freeze();
            buf.unsplit(temp);
            bytes
        }
        httparse::Status::Partial => {
            buf.unsplit(temp);
            return Ok(None);
        }
    };

[gemini-code-assist]

When writing a buffer that is larger than the total capacity of writer_buf, copying it in small chunks through writer_buf is highly inefficient. It forces multiple small writes and flushes. Instead, we should flush any currently buffered data and write the large buffer directly to the underlying stream self.inner, matching the optimization used in std::io::BufWriter.

impl<T: Write> Write for BufferIo<T> {
    #[inline]
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        use std::ptr;
        let buf_len = self.writer_buf.0.len();
        if buf.len() >= buf_len {
            self.flush()?;
            return self.inner.write(buf);
        }

        if buf_len == self.writer_buf.1 {
            self.flush()?;
        }

        let remain = buf_len - self.writer_buf.1;
        let len = cmp::min(remain, buf.len());
        let dst = self.writer_buf.0.as_mut_ptr();
        unsafe {
            let dst = dst.add(self.writer_buf.1);
            ptr::copy_nonoverlapping(buf.as_ptr(), dst, len);
        }
        self.writer_buf.1 += len;
        Ok(len)
    }

[gemini-code-assist]

If the user manually sets a Host header in self.headers(), and self.uri().host() is also Some, this will write duplicate Host headers, which violates the HTTP/1.1 protocol. We should only write the URI host if the Host header is not already present in self.headers(). Additionally, note that if a relative URI is used, no Host header will be written at all, which will cause standard HTTP/1.1 servers to reject the request with 400 Bad Request.

        if !self.headers().contains_key(http::header::HOST) {
            if let Some(host) = self.uri().host() {
                write!(writer, "Host: {host}\r\n")?;
            }
        }

[gemini-code-assist]

If remain is extremely large (e.g., gigabytes), this loop will write gigabytes of zeros to the socket, blocking the coroutine/thread for an excessively long time and consuming 100% CPU/bandwidth. Consider limiting the maximum padding size to a reasonable threshold (e.g., 64KB) or avoiding padding entirely if remain is too large, as a mismatched Content-Length already indicates a protocol error.

Suggested change

	SizedWriter(ref w, remain) => {
	let mut w = w.borrow_mut();
	if remain > 0 {
	// write enough data when drop — stack buffer chunks, no heap alloc (JSF 206)
	let zero = [0u8; 256];
	let mut left = remain;
	while left > 0 {
	let amt = left.min(zero.len());
	w.write_all(&zero[..amt]).ok();
	left -= amt;
	}
	}
	w.flush().ok();
	}
	SizedWriter(ref w, remain) => {
	let mut w = w.borrow_mut();
	if remain > 0 && remain <= 65536 {
	// write enough data when drop — stack buffer chunks, no heap alloc (JSF 206)
	let zero = [0u8; 256];
	let mut left = remain;
	while left > 0 {
	let amt = left.min(zero.len());
	w.write_all(&zero[..amt]).ok();
	left -= amt;
	}
	}
	w.flush().ok();
	}