boring-http 1.0.0__py3-none-any.whl

boring_http/hpack_tables.py

@@ -0,0 +1,326 @@
+# generated from the text of RFC 7541 appendices A and B, so regenerate rather than edit
+from typing import Final
+
+STATIC_TABLE: Final[tuple[tuple[bytes, bytes], ...]] = (
+    (b":authority", b""),
+    (b":method", b"GET"),
+    (b":method", b"POST"),
+    (b":path", b"/"),
+    (b":path", b"/index.html"),
+    (b":scheme", b"http"),
+    (b":scheme", b"https"),
+    (b":status", b"200"),
+    (b":status", b"204"),
+    (b":status", b"206"),
+    (b":status", b"304"),
+    (b":status", b"400"),
+    (b":status", b"404"),
+    (b":status", b"500"),
+    (b"accept-charset", b""),
+    (b"accept-encoding", b"gzip, deflate"),
+    (b"accept-language", b""),
+    (b"accept-ranges", b""),
+    (b"accept", b""),
+    (b"access-control-allow-origin", b""),
+    (b"age", b""),
+    (b"allow", b""),
+    (b"authorization", b""),
+    (b"cache-control", b""),
+    (b"content-disposition", b""),
+    (b"content-encoding", b""),
+    (b"content-language", b""),
+    (b"content-length", b""),
+    (b"content-location", b""),
+    (b"content-range", b""),
+    (b"content-type", b""),
+    (b"cookie", b""),
+    (b"date", b""),
+    (b"etag", b""),
+    (b"expect", b""),
+    (b"expires", b""),
+    (b"from", b""),
+    (b"host", b""),
+    (b"if-match", b""),
+    (b"if-modified-since", b""),
+    (b"if-none-match", b""),
+    (b"if-range", b""),
+    (b"if-unmodified-since", b""),
+    (b"last-modified", b""),
+    (b"link", b""),
+    (b"location", b""),
+    (b"max-forwards", b""),
+    (b"proxy-authenticate", b""),
+    (b"proxy-authorization", b""),
+    (b"range", b""),
+    (b"referer", b""),
+    (b"refresh", b""),
+    (b"retry-after", b""),
+    (b"server", b""),
+    (b"set-cookie", b""),
+    (b"strict-transport-security", b""),
+    (b"transfer-encoding", b""),
+    (b"user-agent", b""),
+    (b"vary", b""),
+    (b"via", b""),
+    (b"www-authenticate", b""),
+)
+
+HUFFMAN_CODES: Final[tuple[tuple[int, int], ...]] = (
+    (0x1FF8, 13),
+    (0x7FFFD8, 23),
+    (0xFFFFFE2, 28),
+    (0xFFFFFE3, 28),
+    (0xFFFFFE4, 28),
+    (0xFFFFFE5, 28),
+    (0xFFFFFE6, 28),
+    (0xFFFFFE7, 28),
+    (0xFFFFFE8, 28),
+    (0xFFFFEA, 24),
+    (0x3FFFFFFC, 30),
+    (0xFFFFFE9, 28),
+    (0xFFFFFEA, 28),
+    (0x3FFFFFFD, 30),
+    (0xFFFFFEB, 28),
+    (0xFFFFFEC, 28),
+    (0xFFFFFED, 28),
+    (0xFFFFFEE, 28),
+    (0xFFFFFEF, 28),
+    (0xFFFFFF0, 28),
+    (0xFFFFFF1, 28),
+    (0xFFFFFF2, 28),
+    (0x3FFFFFFE, 30),
+    (0xFFFFFF3, 28),
+    (0xFFFFFF4, 28),
+    (0xFFFFFF5, 28),
+    (0xFFFFFF6, 28),
+    (0xFFFFFF7, 28),
+    (0xFFFFFF8, 28),
+    (0xFFFFFF9, 28),
+    (0xFFFFFFA, 28),
+    (0xFFFFFFB, 28),
+    (0x14, 6),
+    (0x3F8, 10),
+    (0x3F9, 10),
+    (0xFFA, 12),
+    (0x1FF9, 13),
+    (0x15, 6),
+    (0xF8, 8),
+    (0x7FA, 11),
+    (0x3FA, 10),
+    (0x3FB, 10),
+    (0xF9, 8),
+    (0x7FB, 11),
+    (0xFA, 8),
+    (0x16, 6),
+    (0x17, 6),
+    (0x18, 6),
+    (0x0, 5),
+    (0x1, 5),
+    (0x2, 5),
+    (0x19, 6),
+    (0x1A, 6),
+    (0x1B, 6),
+    (0x1C, 6),
+    (0x1D, 6),
+    (0x1E, 6),
+    (0x1F, 6),
+    (0x5C, 7),
+    (0xFB, 8),
+    (0x7FFC, 15),
+    (0x20, 6),
+    (0xFFB, 12),
+    (0x3FC, 10),
+    (0x1FFA, 13),
+    (0x21, 6),
+    (0x5D, 7),
+    (0x5E, 7),
+    (0x5F, 7),
+    (0x60, 7),
+    (0x61, 7),
+    (0x62, 7),
+    (0x63, 7),
+    (0x64, 7),
+    (0x65, 7),
+    (0x66, 7),
+    (0x67, 7),
+    (0x68, 7),
+    (0x69, 7),
+    (0x6A, 7),
+    (0x6B, 7),
+    (0x6C, 7),
+    (0x6D, 7),
+    (0x6E, 7),
+    (0x6F, 7),
+    (0x70, 7),
+    (0x71, 7),
+    (0x72, 7),
+    (0xFC, 8),
+    (0x73, 7),
+    (0xFD, 8),
+    (0x1FFB, 13),
+    (0x7FFF0, 19),
+    (0x1FFC, 13),
+    (0x3FFC, 14),
+    (0x22, 6),
+    (0x7FFD, 15),
+    (0x3, 5),
+    (0x23, 6),
+    (0x4, 5),
+    (0x24, 6),
+    (0x5, 5),
+    (0x25, 6),
+    (0x26, 6),
+    (0x27, 6),
+    (0x6, 5),
+    (0x74, 7),
+    (0x75, 7),
+    (0x28, 6),
+    (0x29, 6),
+    (0x2A, 6),
+    (0x7, 5),
+    (0x2B, 6),
+    (0x76, 7),
+    (0x2C, 6),
+    (0x8, 5),
+    (0x9, 5),
+    (0x2D, 6),
+    (0x77, 7),
+    (0x78, 7),
+    (0x79, 7),
+    (0x7A, 7),
+    (0x7B, 7),
+    (0x7FFE, 15),
+    (0x7FC, 11),
+    (0x3FFD, 14),
+    (0x1FFD, 13),
+    (0xFFFFFFC, 28),
+    (0xFFFE6, 20),
+    (0x3FFFD2, 22),
+    (0xFFFE7, 20),
+    (0xFFFE8, 20),
+    (0x3FFFD3, 22),
+    (0x3FFFD4, 22),
+    (0x3FFFD5, 22),
+    (0x7FFFD9, 23),
+    (0x3FFFD6, 22),
+    (0x7FFFDA, 23),
+    (0x7FFFDB, 23),
+    (0x7FFFDC, 23),
+    (0x7FFFDD, 23),
+    (0x7FFFDE, 23),
+    (0xFFFFEB, 24),
+    (0x7FFFDF, 23),
+    (0xFFFFEC, 24),
+    (0xFFFFED, 24),
+    (0x3FFFD7, 22),
+    (0x7FFFE0, 23),
+    (0xFFFFEE, 24),
+    (0x7FFFE1, 23),
+    (0x7FFFE2, 23),
+    (0x7FFFE3, 23),
+    (0x7FFFE4, 23),
+    (0x1FFFDC, 21),
+    (0x3FFFD8, 22),
+    (0x7FFFE5, 23),
+    (0x3FFFD9, 22),
+    (0x7FFFE6, 23),
+    (0x7FFFE7, 23),
+    (0xFFFFEF, 24),
+    (0x3FFFDA, 22),
+    (0x1FFFDD, 21),
+    (0xFFFE9, 20),
+    (0x3FFFDB, 22),
+    (0x3FFFDC, 22),
+    (0x7FFFE8, 23),
+    (0x7FFFE9, 23),
+    (0x1FFFDE, 21),
+    (0x7FFFEA, 23),
+    (0x3FFFDD, 22),
+    (0x3FFFDE, 22),
+    (0xFFFFF0, 24),
+    (0x1FFFDF, 21),
+    (0x3FFFDF, 22),
+    (0x7FFFEB, 23),
+    (0x7FFFEC, 23),
+    (0x1FFFE0, 21),
+    (0x1FFFE1, 21),
+    (0x3FFFE0, 22),
+    (0x1FFFE2, 21),
+    (0x7FFFED, 23),
+    (0x3FFFE1, 22),
+    (0x7FFFEE, 23),
+    (0x7FFFEF, 23),
+    (0xFFFEA, 20),
+    (0x3FFFE2, 22),
+    (0x3FFFE3, 22),
+    (0x3FFFE4, 22),
+    (0x7FFFF0, 23),
+    (0x3FFFE5, 22),
+    (0x3FFFE6, 22),
+    (0x7FFFF1, 23),
+    (0x3FFFFE0, 26),
+    (0x3FFFFE1, 26),
+    (0xFFFEB, 20),
+    (0x7FFF1, 19),
+    (0x3FFFE7, 22),
+    (0x7FFFF2, 23),
+    (0x3FFFE8, 22),
+    (0x1FFFFEC, 25),
+    (0x3FFFFE2, 26),
+    (0x3FFFFE3, 26),
+    (0x3FFFFE4, 26),
+    (0x7FFFFDE, 27),
+    (0x7FFFFDF, 27),
+    (0x3FFFFE5, 26),
+    (0xFFFFF1, 24),
+    (0x1FFFFED, 25),
+    (0x7FFF2, 19),
+    (0x1FFFE3, 21),
+    (0x3FFFFE6, 26),
+    (0x7FFFFE0, 27),
+    (0x7FFFFE1, 27),
+    (0x3FFFFE7, 26),
+    (0x7FFFFE2, 27),
+    (0xFFFFF2, 24),
+    (0x1FFFE4, 21),
+    (0x1FFFE5, 21),
+    (0x3FFFFE8, 26),
+    (0x3FFFFE9, 26),
+    (0xFFFFFFD, 28),
+    (0x7FFFFE3, 27),
+    (0x7FFFFE4, 27),
+    (0x7FFFFE5, 27),
+    (0xFFFEC, 20),
+    (0xFFFFF3, 24),
+    (0xFFFED, 20),
+    (0x1FFFE6, 21),
+    (0x3FFFE9, 22),
+    (0x1FFFE7, 21),
+    (0x1FFFE8, 21),
+    (0x7FFFF3, 23),
+    (0x3FFFEA, 22),
+    (0x3FFFEB, 22),
+    (0x1FFFFEE, 25),
+    (0x1FFFFEF, 25),
+    (0xFFFFF4, 24),
+    (0xFFFFF5, 24),
+    (0x3FFFFEA, 26),
+    (0x7FFFF4, 23),
+    (0x3FFFFEB, 26),
+    (0x7FFFFE6, 27),
+    (0x3FFFFEC, 26),
+    (0x3FFFFED, 26),
+    (0x7FFFFE7, 27),
+    (0x7FFFFE8, 27),
+    (0x7FFFFE9, 27),
+    (0x7FFFFEA, 27),
+    (0x7FFFFEB, 27),
+    (0xFFFFFFE, 28),
+    (0x7FFFFEC, 27),
+    (0x7FFFFED, 27),
+    (0x7FFFFEE, 27),
+    (0x7FFFFEF, 27),
+    (0x7FFFFF0, 27),
+    (0x3FFFFEE, 26),
+    (0x3FFFFFFF, 30),
+)

boring_http/http1.py

@@ -0,0 +1,259 @@
+from collections.abc import AsyncGenerator, Callable
+from typing import Final, final
+
+from ssl2 import AsyncTransport
+
+from boring_http.errors import ProtocolError, RemoteDisconnected
+from boring_http.message import Headers, HTTPVersion, Request, Response
+from boring_http.timing import Deadline
+
+READ_SIZE: Final = 65536
+HEAD_LIMIT: Final = 65536
+LINE_LIMIT: Final = 8192
+
+
+@final
+class Http1Connection:
+    def __init__(
+        self,
+        transport: AsyncTransport,
+        *,
+        leftover: bytes = b"",
+        absolute_form: bool = False,
+        proxy_authorization: str | None = None,
+    ) -> None:
+        self._transport = transport
+        self._buffer = bytearray(leftover)
+        self._absolute_form = absolute_form
+        self._proxy_authorization = proxy_authorization
+        self._keep_alive = True
+        self.idle = True
+        self.closed = False
+        self.reused = False
+        self.released: Callable[[], None] = self._nothing
+
+    @property
+    def available(self) -> bool:
+        return self.idle and not self.closed
+
+    @property
+    def shared(self) -> bool:
+        return False
+
+    def take(self) -> None:
+        self.idle = False
+
+    async def send(
+        self, request: Request, deadline: Deadline, *, decode: bool
+    ) -> Response:
+        self.idle = False
+        headers = request.wire_headers(HTTPVersion.HTTP_1)
+        if (
+            self._proxy_authorization is not None
+            and "proxy-authorization" not in headers
+        ):
+            headers.add("Proxy-Authorization", self._proxy_authorization)
+        target = (
+            request.url.origin + request.url.target
+            if self._absolute_form
+            else request.url.target
+        )
+        lines = [
+            f"{request.method} {target} HTTP/1.1",
+            *(f"{name}: {value}" for name, value in headers),
+        ]
+        try:
+            async with deadline.phase("write"):
+                await self._transport.write("\r\n".join(lines).encode() + b"\r\n\r\n")
+                if request.body is not None:
+                    await self._write_body(
+                        request,
+                        headers.get("transfer-encoding", "").lower() == "chunked",
+                    )
+            status, reason, response_headers, old = await self._read_head(deadline)
+        except BaseException:
+            await self.close()
+            raise
+        tokens = {
+            token.strip().lower()
+            for token in (
+                headers.get("connection", "")
+                + ","
+                + response_headers.get("connection", "")
+            ).split(",")
+        }
+        self._keep_alive = "close" not in tokens and (not old or "keep-alive" in tokens)
+        chunked, length = self._framing(request.method, status, response_headers)
+        trailers = Headers()
+        body = self._body(chunked, length, trailers, deadline)
+        return Response(
+            status=status,
+            reason=reason,
+            version=HTTPVersion.HTTP_1,
+            headers=response_headers,
+            request=request,
+            raw=body,
+            trailers=trailers,
+            decode=decode,
+        )
+
+    def detach(self) -> tuple[AsyncTransport, bytes]:
+        self.closed = True
+        self.released()
+        return self._transport, bytes(self._buffer)
+
+    async def close(self) -> None:
+        if not self.closed:
+            self.closed = True
+            await self._transport.close()
+            self.released()
+
+    async def _write_body(self, request: Request, chunked: bool) -> None:
+        if request.body is None:
+            return
+        async for chunk in request.body.chunks():
+            if chunked:
+                await self._transport.write(
+                    f"{len(chunk):x}\r\n".encode() + chunk + b"\r\n"
+                )
+            else:
+                await self._transport.write(chunk)
+        if chunked:
+            await self._transport.write(b"0\r\n\r\n")
+
+    async def _read_head(self, deadline: Deadline) -> tuple[int, str, Headers, bool]:
+        while True:
+            head = (await self._read_until(b"\r\n\r\n", HEAD_LIMIT, deadline)).decode(
+                "latin-1"
+            )
+            status_line, *lines = head.split("\r\n")
+            version, _, rest = status_line.partition(" ")
+            code, _, reason = rest.partition(" ")
+            if (
+                version not in ("HTTP/1.1", "HTTP/1.0")
+                or len(code) != 3
+                or not (code.isascii() and code.isdigit())
+            ):
+                raise ProtocolError(f"malformed status line {status_line!r}")
+            headers = Headers()
+            for line in lines:
+                name, separator, value = line.partition(":")
+                if not separator or line[:1] in (" ", "\t"):
+                    raise ProtocolError(f"malformed header line {line!r}")
+                try:
+                    headers.add(name.strip(), value)
+                except ValueError as error:
+                    raise ProtocolError(str(error)) from None
+            status = int(code)
+            if 100 <= status < 200 and status != 101:
+                continue
+            return status, reason, headers, version == "HTTP/1.0"
+
+    @staticmethod
+    def _framing(method: str, status: int, headers: Headers) -> tuple[bool, int | None]:
+        if method == "HEAD" or status in (101, 204, 304):
+            return False, 0
+        encoding = headers.get("transfer-encoding")
+        if encoding is not None:
+            return encoding.split(",")[-1].strip().lower() == "chunked", None
+        length = headers.get("content-length")
+        if length is None:
+            return False, None
+        # str.isdigit accepts superscripts and other Unicode digits that int rejects
+        if not (length.isascii() and length.isdigit()):
+            raise ProtocolError(f"malformed Content-Length {length!r}")
+        return False, int(length)
+
+    async def _body(
+        self, chunked: bool, length: int | None, trailers: Headers, deadline: Deadline
+    ) -> AsyncGenerator[bytes]:
+        try:
+            if chunked:
+                async for chunk in self._chunked(trailers, deadline):
+                    yield chunk
+            elif length is None:
+                self._keep_alive = False
+                while piece := await self._read_some(READ_SIZE, deadline):
+                    yield piece
+            else:
+                async for piece in self._exactly(length, deadline):
+                    yield piece
+        except BaseException:
+            await self.close()
+            raise
+        if self._keep_alive:
+            self.idle = True
+            self.released()
+        else:
+            await self.close()
+
+    async def _chunked(
+        self, trailers: Headers, deadline: Deadline
+    ) -> AsyncGenerator[bytes]:
+        while True:
+            line = await self._read_line(deadline)
+            try:
+                size = int(line.split(b";", 1)[0].strip(), 16)
+            except ValueError:
+                raise ProtocolError(f"malformed chunk size {line!r}") from None
+            if size == 0:
+                break
+            async for piece in self._exactly(size, deadline):
+                yield piece
+            if await self._read_line(deadline):
+                raise ProtocolError("chunk data not followed by CRLF")
+        while line := await self._read_line(deadline):
+            name, separator, value = line.decode("latin-1").partition(":")
+            if not separator:
+                raise ProtocolError(f"malformed trailer line {line!r}")
+            try:
+                trailers.add(name.strip(), value)
+            except ValueError as error:
+                raise ProtocolError(str(error)) from None
+
+    async def _exactly(self, length: int, deadline: Deadline) -> AsyncGenerator[bytes]:
+        remaining = length
+        while remaining:
+            piece = await self._read_some(remaining, deadline)
+            if not piece:
+                raise ProtocolError(
+                    f"the connection closed with {remaining} body bytes missing"
+                )
+            remaining -= len(piece)
+            yield piece
+
+    async def _read_some(self, limit: int, deadline: Deadline) -> bytes:
+        if not self._buffer:
+            async with deadline.phase("read"):
+                return await self._transport.read(min(limit, READ_SIZE))
+        piece = bytes(self._buffer[:limit])
+        del self._buffer[:limit]
+        return piece
+
+    async def _read_until(
+        self, terminator: bytes, limit: int, deadline: Deadline
+    ) -> bytes:
+        while (end := self._buffer.find(terminator)) < 0:
+            if len(self._buffer) > limit:
+                raise ProtocolError(f"the response head exceeds {limit} bytes")
+            async with deadline.phase("read"):
+                piece = await self._transport.read(READ_SIZE)
+            if not piece:
+                if self._buffer:
+                    raise ProtocolError(
+                        "the connection closed in the middle of the response head"
+                    )
+                raise RemoteDisconnected(
+                    "the server closed the connection before responding"
+                )
+            self._buffer += piece
+        head = bytes(self._buffer[:end])
+        del self._buffer[: end + len(terminator)]
+        return head
+
+    async def _read_line(self, deadline: Deadline) -> bytes:
+        return await self._read_until(b"\r\n", LINE_LIMIT, deadline)
+
+    @staticmethod
+    def _nothing() -> None:
+        pass