diff --git a/app/proxy.py b/app/proxy.py index a3f19dc..dbf493b 100644 --- a/app/proxy.py +++ b/app/proxy.py @@ -5,6 +5,7 @@ from urllib.parse import urlsplit MAX_HEADER_SIZE = 64 * 1024 +BODY_CHUNK = 64 * 1024 logger = logging.getLogger("uvicorn.error") @@ -12,16 +13,181 @@ class ProxyError(Exception): 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: 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 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) @@ -113,7 +279,6 @@ async def send_error(writer: asyncio.StreamWriter, status: int, reason: str, det await writer.drain() except (ConnectionError, OSError, RuntimeError): pass - pass async def handle_client( @@ -127,43 +292,84 @@ async def handle_client( port = None route_name = "UNKNOWN" try: - header = await read_headers(client_reader) - method, host, port, direct_header = request_target(header) - decision = route_for(host) - route_name = decision["route"] - use_upstream = route_name == "PROXY" - rule = decision.get("rule") - matched_by = f'rule {rule["domain"]}' if rule else "default" + # 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 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": - response = await read_headers(remote_reader) - 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) - if method == "CONNECT": - client_writer.write(b"HTTP/1.1 200 Connection Established\r\n\r\n") + 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: - remote_writer.write(direct_header) - await remote_writer.drain() - - await asyncio.gather( - relay(client_reader, remote_writer), - relay(remote_reader, client_writer), - ) + 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: diff --git a/tests/test_app.py b/tests/test_app.py index 7d704f6..7475535 100644 --- a/tests/test_app.py +++ b/tests/test_app.py @@ -102,3 +102,85 @@ def test_proxy_shutdown_closes_pending_clients(): await target_server.wait_closed() 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())