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