@corewire/airplay 0.0.0 → 1.0.0-beta.1

package/dist/rtsp-BWFaYW5H.mjs

@@ -0,0 +1,374 @@
+import { ConnectionClosedError, ConnectionTimeoutError, InvalidResponseError, TimeoutError, reporter } from "@corewire/core";
+import { Plist } from "@corewire/core/encoding";
+import { Connection } from "@corewire/core/transport";
+
+//#region src/const.ts
+/** RTSP port of an AirPlay receiver when discovery did not say otherwise. */
+const DEFAULT_PORT = 7e3;
+/** Timeout in milliseconds for HTTP and RTSP requests during setup and control. */
+const HTTP_TIMEOUT = 6e3;
+/** Interval in milliseconds of the `/feedback` keepalive a receiver expects. */
+const FEEDBACK_INTERVAL = 2e3;
+/** Default bytes per sample per channel, for 16-bit PCM. */
+const AUDIO_BYTES_PER_CHANNEL = 2;
+/** Default number of audio channels, for stereo. */
+const AUDIO_CHANNELS = 2;
+/** Default sample rate in Hz, for CD quality. */
+const AUDIO_SAMPLE_RATE = 44100;
+
+//#endregion
+//#region src/rtsp/encoding.ts
+const MAX_HEADER_LENGTH = 64 * 1024;
+const MAX_BODY_LENGTH = 16 * 1024 * 1024;
+/** Serializes an RTSP or HTTP response, with `Content-Length` set from the body. */
+function buildResponse(options) {
+	const { status, statusText, headers: extraHeaders = {}, body, protocol = "RTSP/1.0" } = options;
+	const headers = {
+		...extraHeaders,
+		"Content-Length": body?.byteLength ?? 0
+	};
+	const headerLines = [
+		`${protocol} ${status} ${statusText}`,
+		...Object.entries(headers).map(([name, value]) => `${name}: ${value}`),
+		"",
+		""
+	].join("\r\n");
+	if (body && body.byteLength > 0) return Buffer.concat([Buffer.from(headerLines), body]);
+	return Buffer.from(headerLines);
+}
+/**
+* Parses an RTSP or HTTP request from the start of a buffer that fills as
+* TCP data arrives.
+*
+* @returns The request, or `null` while the headers or body are incomplete.
+* @throws Error if the request line is malformed.
+*/
+function parseRequest(buffer) {
+	const headerLength = buffer.indexOf("\r\n\r\n");
+	if (headerLength > MAX_HEADER_LENGTH || headerLength === -1 && buffer.length > MAX_HEADER_LENGTH) throw new Error("RTSP headers exceed maximum length");
+	if (headerLength === -1) return null;
+	const { headers, method, path } = parseRequestHeaders(buffer.subarray(0, headerLength));
+	const contentLength = parseContentLength(headers);
+	const requestLength = headerLength + 4 + contentLength;
+	if (buffer.byteLength < requestLength) return null;
+	return {
+		headers,
+		method,
+		path,
+		body: buffer.subarray(headerLength + 4, requestLength),
+		requestLength
+	};
+}
+/**
+* Parses an RTSP or HTTP response from the start of a buffer that fills as
+* TCP data arrives.
+*
+* @returns The response, or `null` while the headers or body are incomplete.
+* @throws Error if the status line is malformed.
+*/
+function parseResponse(buffer) {
+	const headerLength = buffer.indexOf("\r\n\r\n");
+	if (headerLength > MAX_HEADER_LENGTH || headerLength === -1 && buffer.length > MAX_HEADER_LENGTH) throw new Error("RTSP headers exceed maximum length");
+	if (headerLength === -1) return null;
+	const { headers, status, statusText } = parseResponseHeaders(buffer.subarray(0, headerLength));
+	const contentLength = parseContentLength(headers);
+	const responseLength = headerLength + 4 + contentLength;
+	if (buffer.byteLength < responseLength) return null;
+	const body = buffer.subarray(headerLength + 4, responseLength);
+	return {
+		response: new Response(status === 204 || status === 205 || status === 304 ? null : new Uint8Array(body), {
+			status,
+			statusText,
+			headers
+		}),
+		responseLength
+	};
+}
+/**
+* Parses header lines, without the request or status line. Names become
+* capitalized (`content-length` to `Content-Length`), so lookups ignore the
+* sender's casing. Lines without a colon are skipped.
+*/
+function parseHeaders(lines) {
+	const headers = {};
+	for (let i = 0; i < lines.length; i++) {
+		const colon = lines[i].indexOf(":");
+		if (colon <= 0) continue;
+		const rawName = lines[i].substring(0, colon).trim();
+		const name = rawName.toLowerCase() === "cseq" ? "CSeq" : rawName.toLowerCase().replace(/(^|-)(\w)/g, (_, prefix, char) => prefix + char.toUpperCase());
+		const value = lines[i].substring(colon + 1).trim();
+		if (name === "Content-Length" && headers[name] !== void 0 && headers[name] !== value) throw new Error("Conflicting Content-Length headers");
+		headers[name] = value;
+	}
+	return headers;
+}
+/**
+* Parses the header section of a request, with a first line such as
+* `METHOD /path RTSP/1.0` or `METHOD /path HTTP/1.1`.
+*
+* @param buffer - The header bytes, without the `\r\n\r\n` delimiter.
+* @throws Error if the request line does not match.
+*/
+function parseRequestHeaders(buffer) {
+	const lines = buffer.toString("utf8").split("\r\n");
+	const rawRequest = lines[0].match(/^(\S+)\s+(\S+)\s+(?:RTSP|HTTP)\/[\d.]+$/);
+	if (!rawRequest) throw new Error(`Invalid RTSP/HTTP request line: ${lines[0]}`);
+	const method = rawRequest[1];
+	const path = rawRequest[2];
+	return {
+		headers: parseHeaders(lines.slice(1)),
+		method,
+		path
+	};
+}
+/**
+* Parses the header section of a response, with a first line such as
+* `RTSP/1.0 200 OK` or `HTTP/1.1 200 OK`.
+*
+* @param buffer - The header bytes, without the `\r\n\r\n` delimiter.
+* @throws Error if the status line does not match.
+*/
+function parseResponseHeaders(buffer) {
+	const lines = buffer.toString("utf8").split("\r\n");
+	const rawStatus = lines[0].match(/(HTTP|RTSP)\/[\d.]+\s+(\d+)\s+(.+)/);
+	if (!rawStatus) throw new Error(`Invalid RTSP/HTTP response line: ${lines[0]}`);
+	const status = Number(rawStatus[2]);
+	const statusText = rawStatus[3];
+	return {
+		headers: parseHeaders(lines.slice(1)),
+		status,
+		statusText
+	};
+}
+function parseContentLength(headers) {
+	const value = headers["Content-Length"];
+	if (value === void 0) return 0;
+	const length = Number(value);
+	if (!/^\d+$/.test(value) || !Number.isSafeInteger(length) || length > MAX_BODY_LENGTH) throw new Error("Invalid or excessive Content-Length");
+	return length;
+}
+
+//#endregion
+//#region src/rtsp/client.ts
+/** Buffer size at which the buffers reset, against memory exhaustion. */
+const MAX_BUFFER_SIZE = 2 * 1024 * 1024;
+/**
+* RTSP over TCP with CSeq-based response tracking and binary-plist serialization of object bodies.
+* Keeps ciphertext and plaintext separate to handle partial TCP delivery.
+* Override {@link transformIncoming}, {@link transformOutgoing} and {@link getDefaultHeaders} for encryption and protocol headers.
+*/
+var RtspClient = class extends Connection {
+	/** Decrypted plaintext waiting to be parsed as responses. */
+	#buffer = Buffer.alloc(0);
+	/** Raw TCP data waiting for {@link transformIncoming}. */
+	#encryptedBuffer = Buffer.alloc(0);
+	#cseq = 0;
+	#requests = /* @__PURE__ */ new Map();
+	constructor(context, address, port) {
+		super(context, address, port);
+		this.on("closed", (reason, error) => this.#onClose(reason, error));
+		this.on("data", (data) => this.#onData(data));
+		this.on("error", (error) => this.#onError(error));
+	}
+	/**
+	* Headers on every request, after CSeq and before the headers of
+	* {@link ExchangeOptions.headers}. A subclass adds its session headers
+	* here, such as DACP-ID and Active-Remote.
+	*/
+	getDefaultHeaders() {
+		return {};
+	}
+	/**
+	* Decrypts incoming TCP data before parsing; a subclass overrides it.
+	*
+	* @returns The plaintext, with the consumed byte count when not all input
+	*          was used, or `false` until a complete encrypted block arrived.
+	*/
+	transformIncoming(data) {
+		return data;
+	}
+	/** Encrypts a formatted request before it goes to the socket; a subclass overrides it. */
+	transformOutgoing(data) {
+		return data;
+	}
+	/**
+	* Sends a request with CSeq tracking and a response timeout. Object bodies become binary plists.
+	*
+	* @throws TimeoutError if no response arrives in time.
+	* @throws InvalidResponseError for non-OK status unless `allowError` is set.
+	*/
+	async exchange(method, path, options = {}) {
+		const { contentType, headers: extraHeaders = {}, allowError = false, protocol = "RTSP/1.0", timeout = HTTP_TIMEOUT } = options;
+		let { body } = options;
+		const cseq = this.#cseq++;
+		const headers = {
+			"CSeq": cseq,
+			...this.getDefaultHeaders(),
+			...extraHeaders
+		};
+		let bodyBuffer;
+		if (body && typeof body === "object" && !Buffer.isBuffer(body)) {
+			bodyBuffer = Buffer.from(Plist.serialize(body));
+			headers["Content-Type"] = "application/x-apple-binary-plist";
+		} else if (body) {
+			bodyBuffer = typeof body === "string" ? Buffer.from(body) : body;
+			if (contentType) headers["Content-Type"] = contentType;
+		} else if (contentType) headers["Content-Type"] = contentType;
+		if (bodyBuffer) headers["Content-Length"] = bodyBuffer.length;
+		else headers["Content-Length"] = 0;
+		const headerLines = [
+			`${method} ${path} ${protocol}`,
+			...Object.entries(headers).map(([name, value]) => `${name}: ${value}`),
+			"",
+			""
+		].join("\r\n");
+		const raw = bodyBuffer ? Buffer.concat([Buffer.from(headerLines), bodyBuffer]) : Buffer.from(headerLines);
+		const data = this.transformOutgoing(Buffer.from(raw));
+		this.context.logger.net("[rtsp]", method, path, `cseq=${cseq}`);
+		if (reporter.tapsTraffic) this.context.logger.traffic("rtsp", "out", `${method} ${path} cseq=${cseq}`, {
+			headers,
+			body: decodeBody(String(headers["Content-Type"] ?? ""), bodyBuffer)
+		}, raw);
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#requests.delete(cseq);
+				reject(new TimeoutError(`No response to CSeq ${cseq} (${path})`));
+			}, timeout);
+			this.#requests.set(cseq, {
+				resolve: (response) => {
+					clearTimeout(timer);
+					if (!allowError && !response.ok) reject(new InvalidResponseError(`RTSP error: ${response.status} ${response.statusText}`));
+					else resolve(response);
+				},
+				reject: (error) => {
+					clearTimeout(timer);
+					reject(error);
+				}
+			});
+			try {
+				this.write(data);
+			} catch (err) {
+				clearTimeout(timer);
+				this.#requests.delete(cseq);
+				reject(err);
+			}
+		});
+	}
+	/**
+	* Resets both buffers and rejects every pending request: with a {@link ConnectionTimeoutError}
+	* after a timeout, with the error that broke the connection, or with a {@link ConnectionClosedError}.
+	*/
+	#onClose(reason, error) {
+		this.#buffer = Buffer.alloc(0);
+		this.#encryptedBuffer = Buffer.alloc(0);
+		for (const [cseq, { reject }] of this.#requests) {
+			reject(reason === "timeout" ? new ConnectionTimeoutError() : error ?? new ConnectionClosedError("Connection closed."));
+			this.#requests.delete(cseq);
+		}
+		this.context.logger.net("[rtsp]", "onRtspClose()", reason);
+	}
+	/**
+	* Collects TCP data in the encrypted buffer, decrypts it with
+	* {@link transformIncoming} into the plaintext buffer and matches each
+	* complete response to its request by CSeq. Past {@link MAX_BUFFER_SIZE},
+	* both buffers reset and every pending request is rejected.
+	*/
+	#onData(data) {
+		try {
+			this.#encryptedBuffer = Buffer.concat([this.#encryptedBuffer, data]);
+			if (this.#encryptedBuffer.byteLength > MAX_BUFFER_SIZE) {
+				this.context.logger.error("[rtsp]", `Buffer exceeded max size (${this.#encryptedBuffer.byteLength} bytes), resetting.`);
+				this.#encryptedBuffer = Buffer.alloc(0);
+				this.#buffer = Buffer.alloc(0);
+				const err = /* @__PURE__ */ new Error("Buffer overflow: exceeded maximum buffer size");
+				for (const [cseq, { reject }] of this.#requests) {
+					reject(err);
+					this.#requests.delete(cseq);
+				}
+				this.emit("error", err);
+				return;
+			}
+			const transformed = this.transformIncoming(this.#encryptedBuffer);
+			if (transformed === false) return;
+			const result = Buffer.isBuffer(transformed) ? {
+				data: transformed,
+				consumed: this.#encryptedBuffer.length
+			} : transformed;
+			this.#encryptedBuffer = Buffer.from(this.#encryptedBuffer.subarray(result.consumed));
+			this.#buffer = Buffer.concat([this.#buffer, result.data]);
+			while (this.#buffer.byteLength > 0) {
+				const result = parseResponse(this.#buffer);
+				if (result === null) return;
+				if (reporter.tapsTraffic) this.#tapResponse(result.response, this.#buffer.subarray(0, result.responseLength));
+				this.#buffer = this.#buffer.subarray(result.responseLength);
+				const cseqHeader = result.response.headers.get("CSeq");
+				const cseq = cseqHeader ? parseInt(cseqHeader, 10) : -1;
+				if (this.#requests.has(cseq)) {
+					const { resolve } = this.#requests.get(cseq);
+					this.#requests.delete(cseq);
+					resolve(result.response);
+				} else this.context.logger.warn("[rtsp]", `Unexpected response for CSeq ${cseq}`);
+			}
+		} catch (err) {
+			this.#encryptedBuffer = Buffer.alloc(0);
+			this.#buffer = Buffer.alloc(0);
+			this.context.logger.error("[rtsp]", "onRtspData()", err);
+			this.destroy(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	/**
+	* Reports a response to the traffic sink. The body is cut from the frame, because reading it
+	* off the `Response` would consume it before the caller gets to.
+	*
+	* @param bytes - The plaintext response as it was framed.
+	*/
+	#tapResponse(response, bytes) {
+		const frame = Buffer.from(bytes);
+		const headers = Object.fromEntries(response.headers.entries());
+		const bodyStart = frame.indexOf("\r\n\r\n") + 4;
+		const body = decodeBody(headers["content-type"] ?? "", frame.subarray(bodyStart));
+		this.context.logger.traffic("rtsp", "in", `${response.status} ${response.statusText} cseq=${headers["cseq"] ?? "?"}`, {
+			headers,
+			body
+		}, frame);
+	}
+	/** Rejects every pending request with the socket error. */
+	#onError(err) {
+		for (const [cseq, { reject }] of this.#requests) {
+			reject(err);
+			this.#requests.delete(cseq);
+		}
+		this.context.logger.error("[rtsp]", "onRtspError()", err);
+	}
+};
+/**
+* Turns a body into something readable for the traffic sink: a parsed plist, text, or nothing
+* when it is binary the sink already gets as bytes.
+*/
+function decodeBody(contentType, body) {
+	if (!body || body.byteLength === 0) return;
+	try {
+		if (contentType.includes("plist")) return decodeNestedPlist(Plist.parse(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)));
+		if (contentType.startsWith("text/") || contentType.includes("sdp") || contentType.includes("parameters")) return body.toString("utf8");
+	} catch {}
+}
+/** Decodes a binary plist in `params.data`, as AirPlay play queue commands carry one. */
+function decodeNestedPlist(value) {
+	const params = value?.params;
+	const data = params?.data;
+	if (!(data instanceof ArrayBuffer) || data.byteLength < 8 || Buffer.from(data, 0, 8).toString("latin1") !== "bplist00") return value;
+	try {
+		return {
+			...value,
+			params: {
+				...params,
+				data: Plist.parse(data)
+			}
+		};
+	} catch {
+		return value;
+	}
+}
+
+//#endregion
+export { AUDIO_BYTES_PER_CHANNEL as a, DEFAULT_PORT as c, parseResponse as i, FEEDBACK_INTERVAL as l, buildResponse as n, AUDIO_CHANNELS as o, parseRequest as r, AUDIO_SAMPLE_RATE as s, RtspClient as t, HTTP_TIMEOUT as u };

package/dist/rtsp.d.mts

@@ -0,0 +1,2 @@
+import { a as RtspRequest, c as parseRequest, i as Method, l as parseResponse, n as RtspClient, o as RtspResponse, r as BuildResponseOptions, s as buildResponse, t as ExchangeOptions } from "./index-BlcOBfSz.mjs";
+export { type BuildResponseOptions, type ExchangeOptions, type Method, RtspClient, type RtspRequest, type RtspResponse, buildResponse, parseRequest, parseResponse };

package/dist/rtsp.mjs

@@ -0,0 +1,3 @@
+import { i as parseResponse, n as buildResponse, r as parseRequest, t as RtspClient } from "./rtsp-BWFaYW5H.mjs";
+
+export { RtspClient, buildResponse, parseRequest, parseResponse };