ps5-remoteplay 0.1.0__py3-none-any.whl

ps5_remoteplay/__init__.py

@@ -0,0 +1,39 @@
+from .credentials import Credentials
+from .discovery import DeviceInfo, DeviceStatus, discover, get_device, wait_for_status
+from .errors import (
+    DeviceNotFound,
+    LoginFailed,
+    OAuthError,
+    PasscodeMismatch,
+    PasscodeRequired,
+    ProtocolError,
+    PS5Error,
+    RemotePlayHttpError,
+)
+from .oauth import account_id_from_redirect, login_url
+from .registration import register
+from .session import RemotePlaySession, standby
+from .wake import wake
+
+__all__ = [
+    "Credentials",
+    "DeviceInfo",
+    "DeviceNotFound",
+    "DeviceStatus",
+    "LoginFailed",
+    "OAuthError",
+    "PS5Error",
+    "PasscodeMismatch",
+    "PasscodeRequired",
+    "ProtocolError",
+    "RemotePlayHttpError",
+    "RemotePlaySession",
+    "account_id_from_redirect",
+    "discover",
+    "get_device",
+    "login_url",
+    "register",
+    "standby",
+    "wait_for_status",
+    "wake",
+]

ps5_remoteplay/__main__.py

@@ -0,0 +1,168 @@
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+import webbrowser
+from pathlib import Path
+
+import aiohttp
+
+from . import (
+    Credentials,
+    DeviceInfo,
+    DeviceNotFound,
+    DeviceStatus,
+    PS5Error,
+    account_id_from_redirect,
+    discover,
+    get_device,
+    login_url,
+    register,
+    standby,
+    wait_for_status,
+    wake,
+)
+
+EXIT_AWAKE = 0
+EXIT_STANDBY = 1
+EXIT_NOT_FOUND = 2
+EXIT_ERROR = 3
+
+DEFAULT_CREDENTIALS = Path.home() / ".config" / "ps5-remoteplay" / "credentials.json"
+
+
+def _load_store(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text())
+    except FileNotFoundError:
+        return {}
+
+
+def _save_store(path: Path, store: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as f:
+        json.dump(store, f, indent=2)
+
+
+def _credentials_for(args: argparse.Namespace, device: DeviceInfo) -> Credentials:
+    entry = _load_store(args.credentials).get(device.id)
+    if not entry:
+        raise PS5Error(f"No credentials for {device.name} ({device.id}) in {args.credentials}; run 'pair' first")
+    return Credentials.from_dict(entry)
+
+
+def _describe(device: DeviceInfo) -> str:
+    return f"{device.name} ({device.id}) at {device.host}: {device.status}"
+
+
+async def _status(args: argparse.Namespace) -> int:
+    if args.host:
+        device = await get_device(args.host, timeout=args.timeout)
+        print(_describe(device))
+        return EXIT_AWAKE if device.status == DeviceStatus.AWAKE else EXIT_STANDBY
+
+    devices = await discover(timeout=args.timeout)
+    for device in devices:
+        print(_describe(device))
+    return EXIT_AWAKE if devices else EXIT_NOT_FOUND
+
+
+async def _wake(args: argparse.Namespace) -> int:
+    device = await get_device(args.host)
+    if device.status == DeviceStatus.AWAKE:
+        print(f"{device.name} is already awake")
+        return EXIT_AWAKE
+
+    await wake(args.host, _credentials_for(args, device))
+    print(f"Sent WAKEUP to {device.name}")
+    if not args.no_wait:
+        await wait_for_status(args.host, DeviceStatus.AWAKE, timeout=args.timeout)
+        print(f"{device.name} is awake")
+    return EXIT_AWAKE
+
+
+async def _pair(args: argparse.Namespace) -> int:
+    device = await get_device(args.host)
+    if device.status != DeviceStatus.AWAKE:
+        raise PS5Error("The PS5 must be awake to pair; turn it on first")
+
+    url = login_url()
+    print("1. Sign in to PSN in your browser. When the page shows \"redirect\", copy the full URL from the address bar.")
+    print(f"   {url}")
+    if not args.no_browser:
+        webbrowser.open(url)
+    redirect = await asyncio.to_thread(input, "Redirect URL> ")
+    account_id = await account_id_from_redirect(redirect)
+
+    print("2. On the PS5, open Settings > System > Remote Play > Link Device.")
+    pin = await asyncio.to_thread(input, "PIN shown on the PS5> ")
+    credentials = await register(args.host, account_id, pin)
+
+    store = _load_store(args.credentials)
+    store[device.id] = credentials.to_dict()
+    _save_store(args.credentials, store)
+    print(f"Paired with {device.name}; credentials saved to {args.credentials}")
+    return EXIT_AWAKE
+
+
+async def _standby(args: argparse.Namespace) -> int:
+    device = await get_device(args.host)
+    changed = await standby(args.host, _credentials_for(args, device), passcode=args.passcode)
+    print(f"{device.name} {'is going into standby' if changed else 'is already in standby'}")
+    return EXIT_STANDBY
+
+
+def _parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--debug", action="store_true", help="log protocol details")
+    common.add_argument(
+        "--credentials", type=Path, default=DEFAULT_CREDENTIALS,
+        help=f"credentials file (default {DEFAULT_CREDENTIALS}); playactor's file also works",
+    )
+
+    parser = argparse.ArgumentParser(prog="ps5-remoteplay")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    status = commands.add_parser("status", parents=[common], help="show status; exit 0 awake, 1 standby, 2 not found")
+    status.add_argument("--host", help="console IP; omit to broadcast")
+    status.add_argument("--timeout", type=float, default=3.0)
+    status.set_defaults(handler=_status)
+
+    wake_cmd = commands.add_parser("wake", parents=[common], help="wake a paired console")
+    wake_cmd.add_argument("--host", required=True)
+    wake_cmd.add_argument("--no-wait", action="store_true")
+    wake_cmd.add_argument("--timeout", type=float, default=30.0)
+    wake_cmd.set_defaults(handler=_wake)
+
+    pair = commands.add_parser("pair", parents=[common], help="pair via PSN login and the Link Device PIN")
+    pair.add_argument("--host", required=True)
+    pair.add_argument("--no-browser", action="store_true")
+    pair.set_defaults(handler=_pair)
+
+    standby_cmd = commands.add_parser("standby", parents=[common], help="put a paired console into standby")
+    standby_cmd.add_argument("--host", required=True)
+    standby_cmd.add_argument("--passcode", help="4-digit PS5 user passcode, if set")
+    standby_cmd.set_defaults(handler=_standby)
+    return parser
+
+
+def main() -> None:
+    args = _parser().parse_args()
+    logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING)
+    try:
+        sys.exit(asyncio.run(args.handler(args)))
+    except DeviceNotFound as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(EXIT_NOT_FOUND)
+    except (PS5Error, ValueError, OSError, aiohttp.ClientError) as e:
+        print(f"Error: {e or type(e).__name__}", file=sys.stderr)
+        sys.exit(EXIT_ERROR)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

ps5_remoteplay/const.py

@@ -0,0 +1,14 @@
+DISCOVERY_PORT = 9302
+REMOTEPLAY_PORT = 9295
+DISCOVERY_VERSION = "00030010"
+RP_VERSION = "1.0"
+USER_AGENT = "remoteplay Windows"
+
+CLIENT_TYPE = "dabfa2ec873de5839bee8d3f4c0239c4282c07c25c6077a2931afcf0adc0d34f"
+
+# Values used by the official Remote Play Windows client
+OAUTH_CLIENT_ID = "ba495a24-818c-472b-b12d-ff231c1b5745"
+OAUTH_CLIENT_SECRET = "mvaiZkRsAsI1IBkY"
+OAUTH_REDIRECT_URI = "https://remoteplay.dl.playstation.net/remoteplay/redirect"
+OAUTH_AUTHORIZE_URL = "https://auth.api.sonyentertainmentnetwork.com/2.0/oauth/authorize"
+OAUTH_TOKEN_URL = "https://auth.api.sonyentertainmentnetwork.com/2.0/oauth/token"

ps5_remoteplay/credentials.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Credentials:
+    """Pairing result for one console.
+
+    `to_dict`/`from_dict` use playactor's credentials.json entry shape, so
+    entries can be moved between the two tools.
+    """
+
+    account_id: str
+    user_credential: str
+    registration: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def regist_key(self) -> str:
+        return self.registration["PS5-RegistKey"]
+
+    @property
+    def rp_key(self) -> bytes:
+        return bytes.fromhex(self.registration["RP-Key"])
+
+    def wake_fields(self) -> dict[str, str]:
+        return {
+            "app-type": "r",
+            "auth-type": "R",
+            "client-type": "vr",
+            "model": "w",
+            "user-credential": self.user_credential,
+        }
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **self.wake_fields(),
+            "accountId": self.account_id,
+            "registration": dict(self.registration),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Credentials":
+        registration = data.get("registration") or {}
+        if not registration.get("PS5-RegistKey") or not registration.get("RP-Key"):
+            raise ValueError("Credentials are missing PS5-RegistKey or RP-Key; pair again")
+        return cls(
+            account_id=data["accountId"],
+            user_credential=data["user-credential"],
+            registration=dict(registration),
+        )

ps5_remoteplay/crypto.py

@@ -0,0 +1,119 @@
+import hashlib
+import hmac
+import struct
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms
+
+try:
+    from cryptography.hazmat.decrepit.ciphers.modes import CFB
+except ImportError:
+    from cryptography.hazmat.primitives.ciphers.modes import CFB
+
+from .keys import AERO_KEYS, AUTH_NONCE_KEYS, AUTH_SEED_KEYS, INIT_KEYS
+
+NONCE_LENGTH = 16
+PREFACE_LENGTH = 480
+HEADER_LENGTH = 8
+
+_HMAC_KEY = bytes.fromhex("464687b349ca8ce859c5270f5d7a69d6")
+
+
+def generate_iv(nonce: bytes, counter: int) -> bytes:
+    message = nonce + struct.pack(">Q", counter)
+    return hmac.new(_HMAC_KEY, message, hashlib.sha256).digest()[:NONCE_LENGTH]
+
+
+def generate_seed(pin: int, offset: int) -> bytes:
+    seed = bytearray(INIT_KEYS[(i * 0x20 + offset) % len(INIT_KEYS)] for i in range(16))
+    for i, b in enumerate(struct.pack(">I", pin & 0xFFFFFFFF)):
+        seed[12 + i] ^= b
+    return bytes(seed)
+
+
+def generate_aeropause(nonce: bytes, preface: bytes) -> bytes:
+    offset = preface[0] >> 3
+    return bytes(
+        ((nonce[i] ^ AERO_KEYS[i * 0x20 + offset]) + 0xD3 + i) & 0xFF
+        for i in range(16)
+    )
+
+
+def transform_server_nonce(server_nonce: bytes) -> bytes:
+    offset = (server_nonce[0] >> 3) * 0x70
+    return bytes(
+        ((server_nonce[i] - 0x2D - i) ^ AUTH_NONCE_KEYS[offset + i]) & 0xFF
+        for i in range(16)
+    )
+
+
+def generate_auth_seed(auth_key: bytes, server_nonce: bytes) -> bytes:
+    offset = (server_nonce[7] >> 3) * 0x70
+    return bytes(
+        (((auth_key[i] + 0x18 + i) ^ server_nonce[i]) ^ AUTH_SEED_KEYS[offset + i]) & 0xFF
+        for i in range(16)
+    )
+
+
+def aes_cfb(key: bytes, iv: bytes, data: bytes, *, decrypt: bool = False) -> bytes:
+    cipher = Cipher(algorithms.AES(key), CFB(iv))
+    ctx = cipher.decryptor() if decrypt else cipher.encryptor()
+    return ctx.update(data) + ctx.finalize()
+
+
+class RegistrationCrypto:
+    def __init__(self, pin: str, nonce: bytes) -> None:
+        if not pin.isdigit():
+            raise ValueError("PIN must be numeric")
+        if len(nonce) != NONCE_LENGTH:
+            raise ValueError("nonce must be 16 bytes")
+
+        preface = bytearray(b"A" * PREFACE_LENGTH)
+        self._iv = generate_iv(nonce, 0)
+        self._key = generate_seed(int(pin), preface[0x18D] & 0x1F)
+
+        aeropause = generate_aeropause(nonce, preface)
+        preface[0xC7:0xCF] = aeropause[8:16]
+        preface[0x191:0x199] = aeropause[0:8]
+        self.preface = bytes(preface)
+
+    def encrypt_record(self, record: dict[str, str]) -> bytes:
+        text = "".join(f"{k}: {v}\r\n" for k, v in record.items())
+        return self.preface + aes_cfb(self._key, self._iv, text.encode())
+
+    def decrypt(self, data: bytes) -> bytes:
+        return aes_cfb(self._key, self._iv, data, decrypt=True)
+
+
+class SessionCipher:
+    """Per-message AES-CFB with independent encrypt/decrypt counters.
+
+    Header-only frames are sent in the clear and do not consume a counter.
+    """
+
+    def __init__(self, rp_key: bytes, server_nonce: bytes) -> None:
+        if len(rp_key) != NONCE_LENGTH or len(server_nonce) != NONCE_LENGTH:
+            raise ValueError("RP-Key and server nonce must be 16 bytes")
+        self._key = generate_auth_seed(rp_key, server_nonce)
+        self._nonce = transform_server_nonce(server_nonce)
+        self._encrypt_counter = 0
+        self._decrypt_counter = 0
+
+    def encrypt(self, data: bytes) -> bytes:
+        iv = generate_iv(self._nonce, self._encrypt_counter)
+        self._encrypt_counter += 1
+        return aes_cfb(self._key, iv, data)
+
+    def decrypt(self, data: bytes) -> bytes:
+        iv = generate_iv(self._nonce, self._decrypt_counter)
+        self._decrypt_counter += 1
+        return aes_cfb(self._key, iv, data, decrypt=True)
+
+    def encode_frame(self, frame: bytes) -> bytes:
+        if len(frame) == HEADER_LENGTH:
+            return frame
+        return frame[:HEADER_LENGTH] + self.encrypt(frame[HEADER_LENGTH:])
+
+    def decode_payload(self, payload: bytes) -> bytes:
+        if not payload:
+            return payload
+        return self.decrypt(payload)

ps5_remoteplay/discovery.py

@@ -0,0 +1,144 @@
+import asyncio
+import logging
+from dataclasses import dataclass
+from enum import StrEnum
+
+from .const import DISCOVERY_PORT, DISCOVERY_VERSION
+from .errors import DeviceNotFound
+
+_LOGGER = logging.getLogger(__name__)
+
+_STATUS_CODE_STANDBY = "620"
+
+
+class DeviceStatus(StrEnum):
+    AWAKE = "AWAKE"
+    STANDBY = "STANDBY"
+
+
+@dataclass(frozen=True)
+class DeviceInfo:
+    host: str
+    id: str
+    name: str
+    type: str
+    status: DeviceStatus
+    system_version: str
+    host_request_port: int | None
+    data: dict[str, str]
+
+
+def format_message(message_type: str, data: dict[str, str] | None = None) -> bytes:
+    fields = "".join(f"{k}:{v}\n" for k, v in (data or {}).items())
+    return (
+        f"{message_type} * HTTP/1.1\n{fields}device-discovery-protocol-version:{DISCOVERY_VERSION}\n"
+    ).encode()
+
+
+def parse_message(raw: bytes) -> dict[str, str] | None:
+    """Parse a discovery datagram; returns None for anything that isn't a device reply."""
+    lines = raw.decode("utf-8", errors="replace").replace("\r", "").split("\n")
+    parts = lines[0].split(" ")
+    if not lines[0].startswith("HTTP") or len(parts) < 2:
+        return None
+
+    result = {"status_code": parts[1]}
+    for line in lines[1:]:
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        value = value.lstrip(" ")
+        if value:
+            result[key.lower()] = value
+    return result
+
+
+def _device_from(host: str, parsed: dict[str, str]) -> DeviceInfo | None:
+    device_id = parsed.get("host-id")
+    if not device_id:
+        return None
+    port = parsed.get("host-request-port", "")
+    return DeviceInfo(
+        host=host,
+        id=device_id,
+        name=parsed.get("host-name", ""),
+        type=parsed.get("host-type", ""),
+        status=DeviceStatus.STANDBY if parsed["status_code"] == _STATUS_CODE_STANDBY else DeviceStatus.AWAKE,
+        system_version=parsed.get("system-version", ""),
+        host_request_port=int(port) if port.isdigit() else None,
+        data=parsed,
+    )
+
+
+class _DiscoveryProtocol(asyncio.DatagramProtocol):
+    def __init__(self) -> None:
+        self.devices: asyncio.Queue[DeviceInfo] = asyncio.Queue()
+
+    def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
+        parsed = parse_message(data)
+        device = parsed and _device_from(addr[0], parsed)
+        if device:
+            _LOGGER.debug("Discovered %s at %s: %s", device.id, device.host, device.status)
+            self.devices.put_nowait(device)
+
+
+async def _search(
+    host: str | None, timeout: float, resend_interval: float, *, first_only: bool
+) -> list[DeviceInfo]:
+    loop = asyncio.get_running_loop()
+    transport, protocol = await loop.create_datagram_endpoint(
+        _DiscoveryProtocol,
+        local_addr=("0.0.0.0", 0),
+        allow_broadcast=host is None,
+    )
+    target = (host or "255.255.255.255", DISCOVERY_PORT)
+    message = format_message("SRCH")
+    found: dict[str, DeviceInfo] = {}
+    deadline = loop.time() + timeout
+    try:
+        while loop.time() < deadline:
+            transport.sendto(message, target)
+            resend_at = min(loop.time() + resend_interval, deadline)
+            while (wait := resend_at - loop.time()) > 0:
+                try:
+                    device = await asyncio.wait_for(protocol.devices.get(), wait)
+                except TimeoutError:
+                    break
+                if host and device.host != host:
+                    continue
+                found[device.id] = device
+                if first_only:
+                    return [device]
+    finally:
+        transport.close()
+    return list(found.values())
+
+
+async def discover(timeout: float = 5.0, resend_interval: float = 1.0) -> list[DeviceInfo]:
+    """Broadcast a search and return every PS5 that answered."""
+    return await _search(None, timeout, resend_interval, first_only=False)
+
+
+async def get_device(host: str, timeout: float = 3.0, resend_interval: float = 1.0) -> DeviceInfo:
+    """Query one console directly. Raises DeviceNotFound if it doesn't answer."""
+    devices = await _search(host, timeout, resend_interval, first_only=True)
+    if not devices:
+        raise DeviceNotFound(f"No PS5 answered at {host}")
+    return devices[0]
+
+
+async def wait_for_status(
+    host: str,
+    status: DeviceStatus,
+    timeout: float = 30.0,
+    poll_interval: float = 2.0,
+) -> DeviceInfo:
+    async with asyncio.timeout(timeout):
+        while True:
+            try:
+                device = await get_device(host, timeout=poll_interval)
+                if device.status == status:
+                    return device
+            except DeviceNotFound:
+                pass
+            await asyncio.sleep(poll_interval)

ps5_remoteplay/errors.py

@@ -0,0 +1,48 @@
+class PS5Error(Exception):
+    pass
+
+
+class DeviceNotFound(PS5Error):
+    pass
+
+
+class OAuthError(PS5Error):
+    pass
+
+
+_REASONS = {
+    "80108b09": "Registration failed, probably invalid PIN",
+    "80108b02": "Invalid PSN ID",
+    "80108b10": "Remote is already in use",
+    "80108b15": "Remote Play on Console crashed",
+    "80108b11": "RP-Version mismatch",
+}
+
+
+class RemotePlayHttpError(PS5Error):
+    def __init__(self, status: int, reason_code: str | None = None) -> None:
+        self.status = status
+        self.reason_code = reason_code
+        self.reason = _REASONS.get((reason_code or "").lower())
+        message = f"Remote Play request failed with HTTP {status}"
+        if reason_code:
+            message += f": {self.reason or 'Other error'} ({reason_code})"
+        super().__init__(message)
+
+
+class ProtocolError(PS5Error):
+    pass
+
+
+class PasscodeRequired(PS5Error):
+    pass
+
+
+class PasscodeMismatch(PS5Error):
+    pass
+
+
+class LoginFailed(PS5Error):
+    def __init__(self, result: int) -> None:
+        self.result = result
+        super().__init__(f"Remote Play login failed with result {result}")

ps5_remoteplay/http.py

@@ -0,0 +1,102 @@
+"""Minimal HTTP/1.1 over asyncio streams.
+
+The Remote Play ctrl request hands its TCP connection over to the binary
+frame protocol, so the response must be read without consuming anything past
+the headers. A general-purpose client can't guarantee that.
+"""
+
+import asyncio
+from dataclasses import dataclass
+
+from .const import REMOTEPLAY_PORT, USER_AGENT
+from .errors import ProtocolError, RemotePlayHttpError
+
+_MAX_HEADER_BYTES = 64 * 1024
+
+
+@dataclass
+class Response:
+    status: int
+    reason: str
+    headers: dict[str, str]
+    body: bytes
+
+
+def build_request(
+    method: str,
+    host: str,
+    port: int,
+    path: str,
+    headers: dict[str, str],
+    body: bytes = b"",
+) -> bytes:
+    # Content-Length: 0 is required even on GETs; the console returns 403 without it
+    lines = [
+        f"{method} {path} HTTP/1.1",
+        f"Host: {host}:{port}",
+        f"User-Agent: {USER_AGENT}",
+        *(f"{k}: {v}" for k, v in headers.items()),
+        f"Content-Length: {len(body)}",
+    ]
+    return ("\r\n".join(lines) + "\r\n\r\n").encode() + body
+
+
+async def read_response(reader: asyncio.StreamReader, *, read_body: bool = True) -> Response:
+    try:
+        head = await reader.readuntil(b"\r\n\r\n")
+    except asyncio.IncompleteReadError as e:
+        raise ProtocolError("Connection closed before HTTP response headers") from e
+    except asyncio.LimitOverrunError as e:
+        raise ProtocolError("HTTP response headers too large") from e
+
+    if len(head) > _MAX_HEADER_BYTES:
+        raise ProtocolError("HTTP response headers too large")
+
+    status_line, *header_lines = head.decode("latin-1").split("\r\n")
+    parts = status_line.split(" ", 2)
+    if len(parts) < 2 or not parts[0].startswith("HTTP/") or not parts[1].isdigit():
+        raise ProtocolError(f"Invalid HTTP status line: {status_line!r}")
+
+    headers: dict[str, str] = {}
+    for line in header_lines:
+        if ":" in line:
+            key, value = line.split(":", 1)
+            headers[key.strip().lower()] = value.strip()
+
+    body = b""
+    if read_body:
+        if "chunked" in headers.get("transfer-encoding", "").lower():
+            raise ProtocolError("Chunked HTTP responses are not supported")
+        if "content-length" in headers:
+            body = await reader.readexactly(int(headers["content-length"]))
+        else:
+            body = await reader.read()
+
+    return Response(int(parts[1]), parts[2] if len(parts) > 2 else "", headers, body)
+
+
+def raise_for_status(response: Response) -> None:
+    if response.status >= 300:
+        raise RemotePlayHttpError(response.status, response.headers.get("rp-application-reason"))
+
+
+async def request(
+    host: str,
+    method: str,
+    path: str,
+    headers: dict[str, str],
+    body: bytes = b"",
+    *,
+    port: int = REMOTEPLAY_PORT,
+    timeout: float = 15.0,
+) -> Response:
+    async with asyncio.timeout(timeout):
+        reader, writer = await asyncio.open_connection(host, port)
+        try:
+            writer.write(build_request(method, host, port, path, headers, body))
+            await writer.drain()
+            response = await read_response(reader)
+        finally:
+            writer.close()
+    raise_for_status(response)
+    return response