240 lines
8.0 KiB
Python
240 lines
8.0 KiB
Python
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
|