import asyncio import logging from collections.abc import Callable from urllib.parse import urlsplit MAX_HEADER_SIZE = 64 * 1024 logger = logging.getLogger("uvicorn.error") class ProxyError(Exception): pass async def read_headers(reader: asyncio.StreamReader) -> bytes: try: data = await reader.readuntil(b"\r\n\r\n") except (asyncio.IncompleteReadError, 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 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 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: 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" 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") await client_writer.drain() else: remote_writer.write(direct_header) await remote_writer.drain() await asyncio.gather( relay(client_reader, remote_writer), relay(remote_reader, client_writer), ) 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