if-proxy/app/proxy.py
boyko_vn 98cb79b3fe fix(proxy): route every request on a keep-alive connection
The proxy read only the first request per client connection and then
tunneled all subsequent bytes to that first request's upstream. Browsers
reuse HTTP/1.1 connections to the proxy across hosts, so any later
request was forwarded raw to the first upstream server, which answered
with its default vhost — pages showed wrong content (e.g. a Caddy
listing from another host under http://192.168.0.1/) until refresh.

Plain HTTP now runs a keep-alive loop with a routing decision, fresh
upstream connection and correct response framing (Content-Length,
chunked, 1xx, HEAD, 204/304, EOF) per request. CONNECT is unchanged.
2026-11-05 11:35:01 +03:00

446 lines
16 KiB
Python

import asyncio
import logging
from collections.abc import Callable
from urllib.parse import urlsplit
MAX_HEADER_SIZE = 64 * 1024
BODY_CHUNK = 64 * 1024
logger = logging.getLogger("uvicorn.error")
class ProxyError(Exception):
pass
async def read_headers(reader: asyncio.StreamReader) -> bytes | None:
"""Read one HTTP head (request/status line + headers).
Returns None on clean EOF before any byte (idle keep-alive connection
closed by the peer). Raises ProxyError on malformed or oversized heads.
"""
try:
data = await reader.readuntil(b"\r\n\r\n")
except asyncio.IncompleteReadError as exc:
if not exc.partial:
return None
raise ProxyError("invalid or incomplete HTTP headers") from exc
except asyncio.LimitOverrunError as exc:
raise ProxyError("invalid or incomplete HTTP headers") from exc
if len(data) > MAX_HEADER_SIZE:
raise ProxyError("HTTP headers are too large")
return data
def parse_head(head: bytes) -> tuple[bytes, list[tuple[bytes, bytes]]]:
lines = head.split(b"\r\n")
headers = []
for line in lines[1:]:
if not line:
continue
name, sep, value = line.partition(b":")
if sep:
headers.append((name.strip().lower(), value.strip()))
return lines[0], headers
def head_value(headers: list[tuple[bytes, bytes]], name: bytes) -> bytes | None:
values = [v for k, v in headers if k == name]
if not values:
return None
return b", ".join(values)
def http_version(start_line: bytes) -> bytes:
parts = start_line.split(b" ", 2)
return parts[2].upper() if len(parts) > 2 else b"HTTP/1.1"
def wants_keep_alive(version: bytes, headers: list[tuple[bytes, bytes]]) -> bool:
tokens = [t.strip().lower() for t in (head_value(headers, b"connection") or b"").split(b",") if t.strip()]
if version == b"HTTP/1.0":
return b"keep-alive" in tokens
return b"close" not in tokens
def filter_head(head: bytes, drop: set[bytes], set_headers: dict[bytes, bytes]) -> bytes:
lines = head.split(b"\r\n")
dropped = set(drop) | set(set_headers)
kept = [lines[0]]
for line in lines[1:]:
if not line:
continue
if line.split(b":", 1)[0].strip().lower() in dropped:
continue
kept.append(line)
for name, value in set_headers.items():
kept.append(name + b": " + value)
return b"\r\n".join(kept) + b"\r\n\r\n"
def body_length(headers: list[tuple[bytes, bytes]]) -> int | None:
raw = head_value(headers, b"content-length")
if raw is None:
return None
try:
return int(raw.split(b",")[-1].strip())
except ValueError as exc:
raise ProxyError("invalid Content-Length") from exc
async def copy_exact(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, length: int):
remaining = length
while remaining > 0:
data = await reader.read(min(BODY_CHUNK, remaining))
if not data:
raise ConnectionError("peer closed mid-body")
writer.write(data)
remaining -= len(data)
await writer.drain()
async def copy_chunked(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
while True:
size_line = await reader.readline()
if not size_line:
raise ConnectionError("unexpected EOF in chunked body")
writer.write(size_line)
try:
size = int(size_line.split(b";", 1)[0].strip(), 16)
except ValueError as exc:
raise ProxyError("invalid chunk size") from exc
if size == 0:
while True:
trailer = await reader.readline()
writer.write(trailer)
if trailer in (b"\r\n", b"\n", b""):
break
await writer.drain()
return
writer.write(await reader.readexactly(size + 2))
await writer.drain()
async def copy_request_body(
client_reader: asyncio.StreamReader,
remote_writer: asyncio.StreamWriter,
req_headers: list[tuple[bytes, bytes]],
):
if b"chunked" in (head_value(req_headers, b"transfer-encoding") or b"").lower():
await copy_chunked(client_reader, remote_writer)
return
length = body_length(req_headers)
if length:
await copy_exact(client_reader, remote_writer, length)
async def forward_response(
remote_reader: asyncio.StreamReader,
client_writer: asyncio.StreamWriter,
method: str,
client_keep: bool,
) -> bool:
"""Forward exactly one upstream response to the client.
Returns whether the client connection may be reused for another request.
"""
while True:
head = await read_headers(remote_reader)
if head is None:
raise ConnectionError("upstream closed without a response")
start, headers = parse_head(head)
parts = start.split(b" ", 2)
code = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 0
keep = client_keep and wants_keep_alive(http_version(start), headers)
if code == 101:
client_writer.write(head)
await client_writer.drain()
await relay(remote_reader, client_writer)
return False
informational = 100 <= code < 200
client_writer.write(
filter_head(
head,
drop=set(),
set_headers={b"connection": b"keep-alive" if keep and not informational else b"close"},
)
)
if informational:
await client_writer.drain()
continue
if method == "HEAD" or code in (204, 304):
await client_writer.drain()
return keep
if b"chunked" in (head_value(headers, b"transfer-encoding") or b"").lower():
await copy_chunked(remote_reader, client_writer)
return keep
length = body_length(headers)
if length is not None:
await copy_exact(remote_reader, client_writer, length)
return keep
# Body is delimited by the upstream closing the connection.
while data := await remote_reader.read(BODY_CHUNK):
client_writer.write(data)
await client_writer.drain()
return False
def request_target(header: bytes) -> tuple[str, str, int, bytes]:
try:
first, rest = header.split(b"\r\n", 1)
method_raw, target_raw, version = first.split(b" ", 2)
method = method_raw.decode("ascii").upper()
target = target_raw.decode("ascii")
except (ValueError, UnicodeDecodeError) as exc:
raise ProxyError("invalid HTTP request line") from exc
if method == "CONNECT":
host, port = split_authority(target, 443)
return method, host, port, header
parsed = urlsplit(target)
if parsed.scheme not in ("http", "https") or not parsed.hostname:
host_header = next(
(line[5:].strip().decode("ascii") for line in rest.split(b"\r\n") if line.lower().startswith(b"host:")),
None,
)
if not host_header:
raise ProxyError("absolute URL or Host header is required")
host, port = split_authority(host_header, 80)
return method, host, port, header
host = parsed.hostname
port = parsed.port or (443 if parsed.scheme == "https" else 80)
path = parsed.path or "/"
if parsed.query:
path += "?" + parsed.query
direct_header = b" ".join((method_raw, path.encode("ascii"), version)) + b"\r\n" + rest
return method, host, port, direct_header
def split_authority(value: str, default_port: int) -> tuple[str, int]:
try:
parsed = urlsplit("//" + value)
host = parsed.hostname
port = parsed.port or default_port
except ValueError as exc:
raise ProxyError("invalid target address") from exc
if not host or not 1 <= port <= 65535:
raise ProxyError("invalid target address")
return host.lower().rstrip("."), port
async def relay(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
try:
while data := await reader.read(64 * 1024):
writer.write(data)
await writer.drain()
except (ConnectionError, OSError, RuntimeError, asyncio.CancelledError):
pass
finally:
if writer.can_write_eof():
try:
writer.write_eof()
except (ConnectionError, OSError, RuntimeError):
pass
async def close_writer(writer: asyncio.StreamWriter):
try:
if not writer.is_closing():
writer.close()
await asyncio.wait_for(writer.wait_closed(), timeout=1)
except (ConnectionError, OSError, RuntimeError, asyncio.TimeoutError):
try:
writer.transport.abort()
except (OSError, RuntimeError):
pass
except asyncio.CancelledError:
try:
writer.transport.abort()
except (OSError, RuntimeError):
pass
raise
async def send_error(writer: asyncio.StreamWriter, status: int, reason: str, detail: str = ""):
if writer.is_closing():
return
body = detail.encode("utf-8")
response = (
f"HTTP/1.1 {status} {reason}\r\nConnection: close\r\n"
f"Content-Type: text/plain; charset=utf-8\r\nContent-Length: {len(body)}\r\n\r\n"
).encode("ascii") + body
try:
writer.write(response)
await writer.drain()
except (ConnectionError, OSError, RuntimeError):
pass
async def handle_client(
client_reader: asyncio.StreamReader,
client_writer: asyncio.StreamWriter,
route_for: Callable[[str], dict],
settings: Callable[[], dict],
):
remote_writer = None
method = host = None
port = None
route_name = "UNKNOWN"
try:
# Plain HTTP runs in a keep-alive loop with a routing decision per
# request: browsers reuse one proxy connection for many hosts, so the
# first request's route must never govern later requests.
while True:
header = await read_headers(client_reader)
if header is None:
return
method, host, port, direct_header = request_target(header)
start, req_headers = parse_head(header)
client_keep = wants_keep_alive(http_version(start), req_headers)
decision = route_for(host)
route_name = decision["route"]
rule = decision.get("rule")
matched_by = f'rule {rule["domain"]}' if rule else "default"
if method == "CONNECT":
if route_name == "PROXY":
config = settings()
logger.info(
"Routing %s %s:%s -> PROXY %s:%s (%s)",
method, host, port, config["proxy_host"], config["proxy_port"], matched_by,
)
remote_reader, remote_writer = await asyncio.open_connection(
config["proxy_host"], config["proxy_port"], limit=MAX_HEADER_SIZE + 1
)
remote_writer.write(header)
await remote_writer.drain()
response = await read_headers(remote_reader)
if response is None:
raise ConnectionError("upstream closed during CONNECT")
client_writer.write(response)
await client_writer.drain()
if not response.split(b" ", 2)[1].startswith(b"2"):
return
else:
logger.info("Routing %s %s:%s -> DIRECT (%s)", method, host, port, matched_by)
remote_reader, remote_writer = await asyncio.open_connection(host, port)
client_writer.write(b"HTTP/1.1 200 Connection Established\r\n\r\n")
await client_writer.drain()
await asyncio.gather(
relay(client_reader, remote_writer),
relay(remote_reader, client_writer),
)
return
outgoing = header if route_name == "PROXY" else direct_header
expect = head_value(req_headers, b"expect")
if expect and b"100-continue" in expect.lower():
outgoing = filter_head(outgoing, drop={b"expect"}, set_headers={})
client_writer.write(b"HTTP/1.1 100 Continue\r\n\r\n")
await client_writer.drain()
config = settings() if route_name == "PROXY" else None
if route_name == "PROXY":
logger.info(
"Routing %s %s:%s -> PROXY %s:%s (%s)",
method, host, port, config["proxy_host"], config["proxy_port"], matched_by,
)
connect_to = (config["proxy_host"], config["proxy_port"])
else:
logger.info("Routing %s %s:%s -> DIRECT (%s)", method, host, port, matched_by)
connect_to = (host, port)
remote_reader, remote_writer = await asyncio.open_connection(*connect_to, limit=MAX_HEADER_SIZE + 1)
try:
remote_writer.write(outgoing)
await copy_request_body(client_reader, remote_writer, req_headers)
try:
keep = await forward_response(remote_reader, client_writer, method, client_keep)
except (ConnectionError, OSError, RuntimeError, ProxyError) as exc:
# Response bytes may already be on the wire; only a clean
# close is safe there.
logger.warning("Response from %s:%s failed mid-transfer: %s", host, port, exc)
return
finally:
await close_writer(remote_writer)
remote_writer = None
if not keep:
return
except ProxyError as exc:
await send_error(client_writer, 400, "Bad Request", str(exc))
except (ConnectionError, OSError, RuntimeError) as exc:
target = f"{host}:{port}" if host and port else "unparsed request"
logger.warning("Routing %s %s via %s failed: %s", method or "request", target, route_name, exc)
await send_error(client_writer, 502, "Bad Gateway")
finally:
if remote_writer is not None:
await close_writer(remote_writer)
await close_writer(client_writer)
class ManagedProxyServer:
def __init__(self):
self.server: asyncio.Server | None = None
self.client_tasks: set[asyncio.Task] = set()
self.client_writers: set[asyncio.StreamWriter] = set()
@property
def sockets(self):
return self.server.sockets if self.server else ()
def handle(self, reader, writer, route_for, settings):
self.client_writers.add(writer)
async def run():
try:
await handle_client(reader, writer, route_for, settings)
finally:
self.client_writers.discard(writer)
task = asyncio.create_task(run())
self.client_tasks.add(task)
def finished(done):
self.client_tasks.discard(done)
if not done.cancelled():
done.exception() # Retrieve unexpected exceptions so asyncio does not emit noisy warnings.
task.add_done_callback(finished)
def close(self):
if self.server:
self.server.close()
async def wait_closed(self):
for writer in tuple(self.client_writers):
writer.close()
tasks = tuple(self.client_tasks)
for task in tasks:
task.cancel()
if tasks:
await asyncio.gather(*tasks, return_exceptions=True)
if self.server:
await self.server.wait_closed()
async def __aenter__(self):
return self
async def __aexit__(self, exc_type, exc, traceback):
self.close()
await self.wait_closed()
async def start_proxy(host, port, route_for, settings):
managed = ManagedProxyServer()
managed.server = await asyncio.start_server(
lambda reader, writer: managed.handle(reader, writer, route_for, settings),
host,
port,
limit=MAX_HEADER_SIZE + 1,
)
return managed