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.
This commit is contained in:
parent
1f380e3d27
commit
98cb79b3fe
278
app/proxy.py
278
app/proxy.py
@ -5,6 +5,7 @@ from urllib.parse import urlsplit
|
|||||||
|
|
||||||
|
|
||||||
MAX_HEADER_SIZE = 64 * 1024
|
MAX_HEADER_SIZE = 64 * 1024
|
||||||
|
BODY_CHUNK = 64 * 1024
|
||||||
logger = logging.getLogger("uvicorn.error")
|
logger = logging.getLogger("uvicorn.error")
|
||||||
|
|
||||||
|
|
||||||
@ -12,16 +13,181 @@ class ProxyError(Exception):
|
|||||||
pass
|
pass
|
||||||
|
|
||||||
|
|
||||||
async def read_headers(reader: asyncio.StreamReader) -> bytes:
|
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:
|
try:
|
||||||
data = await reader.readuntil(b"\r\n\r\n")
|
data = await reader.readuntil(b"\r\n\r\n")
|
||||||
except (asyncio.IncompleteReadError, asyncio.LimitOverrunError) as exc:
|
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
|
raise ProxyError("invalid or incomplete HTTP headers") from exc
|
||||||
if len(data) > MAX_HEADER_SIZE:
|
if len(data) > MAX_HEADER_SIZE:
|
||||||
raise ProxyError("HTTP headers are too large")
|
raise ProxyError("HTTP headers are too large")
|
||||||
return data
|
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]:
|
def request_target(header: bytes) -> tuple[str, str, int, bytes]:
|
||||||
try:
|
try:
|
||||||
first, rest = header.split(b"\r\n", 1)
|
first, rest = header.split(b"\r\n", 1)
|
||||||
@ -113,7 +279,6 @@ async def send_error(writer: asyncio.StreamWriter, status: int, reason: str, det
|
|||||||
await writer.drain()
|
await writer.drain()
|
||||||
except (ConnectionError, OSError, RuntimeError):
|
except (ConnectionError, OSError, RuntimeError):
|
||||||
pass
|
pass
|
||||||
pass
|
|
||||||
|
|
||||||
|
|
||||||
async def handle_client(
|
async def handle_client(
|
||||||
@ -127,43 +292,84 @@ async def handle_client(
|
|||||||
port = None
|
port = None
|
||||||
route_name = "UNKNOWN"
|
route_name = "UNKNOWN"
|
||||||
try:
|
try:
|
||||||
header = await read_headers(client_reader)
|
# Plain HTTP runs in a keep-alive loop with a routing decision per
|
||||||
method, host, port, direct_header = request_target(header)
|
# request: browsers reuse one proxy connection for many hosts, so the
|
||||||
decision = route_for(host)
|
# first request's route must never govern later requests.
|
||||||
route_name = decision["route"]
|
while True:
|
||||||
use_upstream = route_name == "PROXY"
|
header = await read_headers(client_reader)
|
||||||
rule = decision.get("rule")
|
if header is None:
|
||||||
matched_by = f'rule {rule["domain"]}' if rule else "default"
|
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 use_upstream:
|
|
||||||
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"])
|
|
||||||
remote_writer.write(header)
|
|
||||||
await remote_writer.drain()
|
|
||||||
if method == "CONNECT":
|
if method == "CONNECT":
|
||||||
response = await read_headers(remote_reader)
|
if route_name == "PROXY":
|
||||||
client_writer.write(response)
|
config = settings()
|
||||||
await client_writer.drain()
|
logger.info(
|
||||||
if not response.split(b" ", 2)[1].startswith(b"2"):
|
"Routing %s %s:%s -> PROXY %s:%s (%s)",
|
||||||
return
|
method, host, port, config["proxy_host"], config["proxy_port"], matched_by,
|
||||||
else:
|
)
|
||||||
logger.info("Routing %s %s:%s -> DIRECT (%s)", method, host, port, matched_by)
|
remote_reader, remote_writer = await asyncio.open_connection(
|
||||||
remote_reader, remote_writer = await asyncio.open_connection(host, port)
|
config["proxy_host"], config["proxy_port"], limit=MAX_HEADER_SIZE + 1
|
||||||
if method == "CONNECT":
|
)
|
||||||
client_writer.write(b"HTTP/1.1 200 Connection Established\r\n\r\n")
|
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()
|
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:
|
else:
|
||||||
remote_writer.write(direct_header)
|
logger.info("Routing %s %s:%s -> DIRECT (%s)", method, host, port, matched_by)
|
||||||
await remote_writer.drain()
|
connect_to = (host, port)
|
||||||
|
remote_reader, remote_writer = await asyncio.open_connection(*connect_to, limit=MAX_HEADER_SIZE + 1)
|
||||||
await asyncio.gather(
|
try:
|
||||||
relay(client_reader, remote_writer),
|
remote_writer.write(outgoing)
|
||||||
relay(remote_reader, client_writer),
|
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:
|
except ProxyError as exc:
|
||||||
await send_error(client_writer, 400, "Bad Request", str(exc))
|
await send_error(client_writer, 400, "Bad Request", str(exc))
|
||||||
except (ConnectionError, OSError, RuntimeError) as exc:
|
except (ConnectionError, OSError, RuntimeError) as exc:
|
||||||
|
|||||||
@ -102,3 +102,85 @@ def test_proxy_shutdown_closes_pending_clients():
|
|||||||
await target_server.wait_closed()
|
await target_server.wait_closed()
|
||||||
|
|
||||||
asyncio.run(scenario())
|
asyncio.run(scenario())
|
||||||
|
|
||||||
|
|
||||||
|
def test_keep_alive_connection_routes_every_request():
|
||||||
|
async def scenario():
|
||||||
|
seen_a, seen_b = [], []
|
||||||
|
|
||||||
|
async def target_a(reader, writer):
|
||||||
|
while head := await read_head(reader):
|
||||||
|
seen_a.append(head.split(b"\r\n", 1)[0])
|
||||||
|
length = content_length(head)
|
||||||
|
body = await reader.readexactly(length) if length else b""
|
||||||
|
writer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nfromA" if not body else
|
||||||
|
b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\npostA")
|
||||||
|
await writer.drain()
|
||||||
|
|
||||||
|
async def target_b(reader, writer):
|
||||||
|
while head := await read_head(reader):
|
||||||
|
seen_b.append(head.split(b"\r\n", 1)[0])
|
||||||
|
length = content_length(head)
|
||||||
|
body = await reader.readexactly(length) if length else b""
|
||||||
|
writer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nfromB" if not body else
|
||||||
|
b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\npostB")
|
||||||
|
await writer.drain()
|
||||||
|
|
||||||
|
async def read_head(reader):
|
||||||
|
try:
|
||||||
|
return await reader.readuntil(b"\r\n\r\n")
|
||||||
|
except asyncio.IncompleteReadError:
|
||||||
|
return None
|
||||||
|
|
||||||
|
def content_length(head):
|
||||||
|
for line in head.split(b"\r\n"):
|
||||||
|
if line.lower().startswith(b"content-length:"):
|
||||||
|
return int(line.split(b":", 1)[1].strip())
|
||||||
|
return 0
|
||||||
|
|
||||||
|
server_a = await asyncio.start_server(target_a, '127.0.0.1', 0)
|
||||||
|
server_b = await asyncio.start_server(target_b, '127.0.0.1', 0)
|
||||||
|
port_a = server_a.sockets[0].getsockname()[1]
|
||||||
|
port_b = server_b.sockets[0].getsockname()[1]
|
||||||
|
proxy_server = await start_proxy(
|
||||||
|
'127.0.0.1', 0,
|
||||||
|
lambda host: {'route': 'DIRECT'},
|
||||||
|
lambda: {'proxy_host': '127.0.0.1', 'proxy_port': 1},
|
||||||
|
)
|
||||||
|
proxy_port = proxy_server.sockets[0].getsockname()[1]
|
||||||
|
try:
|
||||||
|
reader, writer = await asyncio.open_connection('127.0.0.1', proxy_port)
|
||||||
|
|
||||||
|
async def request(raw):
|
||||||
|
writer.write(raw)
|
||||||
|
await writer.drain()
|
||||||
|
head = await reader.readuntil(b'\r\n\r\n')
|
||||||
|
length = content_length(head)
|
||||||
|
return head, await reader.readexactly(length) if length else b''
|
||||||
|
|
||||||
|
_, body = await request(f'GET http://127.0.0.1:{port_a}/first HTTP/1.1\r\nHost: 127.0.0.1:{port_a}\r\n\r\n'.encode())
|
||||||
|
assert body == b'fromA'
|
||||||
|
# Второй запрос по ТОМУ ЖЕ соединению — на другой хост (регрессия:
|
||||||
|
# раньше он улетал в апстрим первого запроса).
|
||||||
|
_, body = await request(f'GET http://127.0.0.1:{port_b}/second HTTP/1.1\r\nHost: 127.0.0.1:{port_b}\r\n\r\n'.encode())
|
||||||
|
assert body == b'fromB'
|
||||||
|
# Третий — POST с телом, снова первый хост.
|
||||||
|
_, body = await request(
|
||||||
|
f'POST http://127.0.0.1:{port_a}/third HTTP/1.1\r\nHost: 127.0.0.1:{port_a}\r\nContent-Length: 4\r\n\r\nDATA'.encode()
|
||||||
|
)
|
||||||
|
assert body == b'postA'
|
||||||
|
|
||||||
|
writer.close()
|
||||||
|
await writer.wait_closed()
|
||||||
|
await asyncio.sleep(0.1)
|
||||||
|
assert seen_a == [b'GET /first HTTP/1.1', b'POST /third HTTP/1.1']
|
||||||
|
assert seen_b == [b'GET /second HTTP/1.1']
|
||||||
|
finally:
|
||||||
|
proxy_server.close()
|
||||||
|
server_a.close()
|
||||||
|
server_b.close()
|
||||||
|
await proxy_server.wait_closed()
|
||||||
|
await server_a.wait_closed()
|
||||||
|
await server_b.wait_closed()
|
||||||
|
|
||||||
|
asyncio.run(scenario())
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user