diff --git a/packages/cli/src/commands/snapshot.ts b/packages/cli/src/commands/snapshot.ts index c493892a3e..7926767637 100644 --- a/packages/cli/src/commands/snapshot.ts +++ b/packages/cli/src/commands/snapshot.ts @@ -112,6 +112,7 @@ import { localVideos, probeHeldVideo, projectLocalFile, + projectVideoFile, type HeldVideoProbe, } from "./snapshotHeldVideos.js"; import type { Example } from "./_examples.js"; @@ -1015,12 +1016,12 @@ export async function captureSnapshots( const fps = compositionFps(html); const heldVideoIds = localVideoRenderIds(html); const heldProbes = new Map>(); - const heldHints = await heldVideoHints(projectDir, localVideos(html), heldProbes); const savedPaths: string[] = []; let pairSheetFailure: string | null = null; try { + const heldHints = await heldVideoHints(projectDir, localVideos(html), heldProbes); const { browser: chromeBrowser, page, @@ -1217,6 +1218,21 @@ export async function captureSnapshots( remoteCopies.set(href, copy); return copy; }; + const projectVideos = new Map>(); + const checkedProjectVideo = (src: string): ReturnType => { + const known = projectVideos.get(src); + if (known) return known; + const checked = projectVideoFile(projectDir, src).then((project) => { + if (project?.refused) { + const message = `${relative(projectDir, project.file)} is not media: a document, a pipe or device, or a playlist naming files outside its folder`; + warnings.push(message); + console.warn(` ${c.warn("⚠")} ${message}`); + } + return project; + }); + projectVideos.set(src, checked); + return checked; + }; const shouldUseVp9AlphaDecoder = (filePath: string): Promise => { if (!extractMediaMetadata) return Promise.resolve(false); const cached = alphaDecoderCache.get(filePath); @@ -1335,9 +1351,13 @@ export async function captureSnapshots( // since headless Chrome can't seek them and they would render blank. let ffmpegInput: string | null = null; let inputIsLocal = false; - const projectFile = projectLocalFile(projectDir, v.src); - if (projectFile) { - ffmpegInput = projectFile; + const project = await checkedProjectVideo(v.src); + if (project?.refused) { + unreadVideoFrames += 1; + return null; + } + if (project) { + ffmpegInput = project.file; inputIsLocal = true; } else { try { diff --git a/packages/cli/src/commands/snapshotHeldVideos.test.ts b/packages/cli/src/commands/snapshotHeldVideos.test.ts index 65be537a28..77c0b721b3 100644 --- a/packages/cli/src/commands/snapshotHeldVideos.test.ts +++ b/packages/cli/src/commands/snapshotHeldVideos.test.ts @@ -1,3 +1,4 @@ +import { execFileSync } from "node:child_process"; import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; @@ -12,6 +13,7 @@ import { localVideos, probeHeldVideo, projectLocalFile, + projectVideoFile, type HeldVideoProbe, } from "./snapshotHeldVideos.js"; @@ -140,3 +142,76 @@ describe("heldVideoHints", () => { ]); }); }); + +describe("projectVideoFile", () => { + const root = mkdtempSync(join(tmpdir(), "hf-held-playlist-")); + const dir = join(root, "project"); + mkdirSync(join(root, "outside")); + mkdirSync(dir); + writeFileSync(join(root, "outside", "secret.mp4"), "outside media"); + writeFileSync(join(dir, "clip.mp4"), Buffer.from([0, 0, 0, 0x20, 0x66, 0x74, 0x79, 0x70])); + const list = (entry: string) => + `#EXTM3U\n#EXT-X-TARGETDURATION:1\n#EXTINF:1,\n${entry}\n#EXT-X-ENDLIST\n`; + writeFileSync(join(dir, "escape.m3u8"), list("../outside/secret.mp4")); + writeFileSync(join(dir, "escape.mp4"), list(join(root, "outside", "secret.mp4"))); + writeFileSync(join(dir, "stream.m3u8"), list("seg0.ts")); + afterAll(() => rmSync(root, { recursive: true, force: true })); + beforeEach(() => { + run.mockReset(); + }); + + it.each([ + ["a playlist naming a file above the project", "escape.m3u8"], + ["a playlist behind a media extension", "escape.mp4"], + ])("refuses %s, and FFprobe never reads it", async (_label, src) => { + await expect(projectVideoFile(dir, src)).resolves.toEqual({ + file: join(dir, src), + refused: true, + }); + await expect(probeHeldVideo(join(dir, src), new Map(), "ffprobe")).resolves.toEqual({ + duration: 0, + width: 0, + height: 0, + }); + expect(run).not.toHaveBeenCalled(); + }); + + it.each([ + ["a media file", "clip.mp4"], + ["a playlist of segments beside it", "stream.m3u8"], + ])("keeps %s", async (_label, src) => { + await expect(projectVideoFile(dir, src)).resolves.toEqual({ + file: join(dir, src), + refused: false, + }); + }); + + it("gives null for a src outside the project", async () => { + await expect(projectVideoFile(dir, "../outside/secret.mp4")).resolves.toBeNull(); + }); +}); + +describe.skipIf(process.platform === "win32")( + "a project video that is a FIFO with no writer", + () => { + const dir = mkdtempSync(join(tmpdir(), "hf-held-fifo-")); + execFileSync("mkfifo", [join(dir, "pipe.mp4")]); + afterAll(() => rmSync(dir, { recursive: true, force: true })); + beforeEach(() => { + run.mockReset(); + }); + + it("is refused for frame extraction without waiting for a writer", async () => { + await expect(projectVideoFile(dir, "pipe.mp4")).resolves.toEqual({ + file: join(dir, "pipe.mp4"), + refused: true, + }); + }); + + it("gets no held-video hint, and FFprobe never reads it", async () => { + const videos = localVideos(''); + await expect(heldVideoHints(dir, videos, new Map(), "ffprobe")).resolves.toEqual([]); + expect(run).not.toHaveBeenCalled(); + }); + }, +); diff --git a/packages/cli/src/commands/snapshotHeldVideos.ts b/packages/cli/src/commands/snapshotHeldVideos.ts index a6041e825e..2007282363 100644 --- a/packages/cli/src/commands/snapshotHeldVideos.ts +++ b/packages/cli/src/commands/snapshotHeldVideos.ts @@ -2,7 +2,7 @@ import { existsSync } from "node:fs"; import { isAbsolute, relative, resolve } from "node:path"; import { parseHTML } from "linkedom"; import { MEDIA_RENDER_ID_ATTR } from "@hyperframes/core"; -import type { CaptureVideoMetadataHint } from "@hyperframes/engine"; +import { isNotMediaPayload, type CaptureVideoMetadataHint } from "@hyperframes/engine"; import { findFFprobe } from "../browser/ffmpeg.js"; import { runCancellableProcess } from "../utils/cancellableProcess.js"; @@ -36,8 +36,29 @@ export function projectLocalFile(projectDir: string, src: string): string | null } } +export async function projectVideoFile( + projectDir: string, + src: string, +): Promise<{ file: string; refused: boolean } | null> { + const file = projectLocalFile(projectDir, src); + return file ? { file, refused: !(await readableAsMediaWithinProbeLimit(file)) } : null; +} + const PROBE_TIMEOUT_MS = 30_000; +async function readableAsMediaWithinProbeLimit(path: string): Promise { + let timer: ReturnType | undefined; + const deadline = new Promise((done) => { + timer = setTimeout(() => done(false), PROBE_TIMEOUT_MS); + timer.unref?.(); + }); + try { + return await Promise.race([isNotMediaPayload(path).then((notMedia) => !notMedia), deadline]); + } finally { + clearTimeout(timer); + } +} + export interface HeldVideoProbe { duration: number; /** The size Chrome would lay the video out at: rotated footage swaps its coded width and height. */ @@ -84,7 +105,7 @@ export function probeHeldVideo( const known = cache.get(path); if (known) return known; const read = (async () => { - if (!ffprobe) return UNKNOWN_VIDEO; + if (!ffprobe || !(await readableAsMediaWithinProbeLimit(path))) return UNKNOWN_VIDEO; try { const { stdout } = await runCancellableProcess( ffprobe, diff --git a/packages/engine/src/utils/notMediaPayload.test.ts b/packages/engine/src/utils/notMediaPayload.test.ts index bc4dc3f36a..5342bdbb84 100644 --- a/packages/engine/src/utils/notMediaPayload.test.ts +++ b/packages/engine/src/utils/notMediaPayload.test.ts @@ -1,7 +1,9 @@ +import { execFileSync, spawnSync } from "node:child_process"; import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { describe, expect, it } from "vitest"; +import { getFfprobeBinary } from "./ffmpegBinaries.js"; import { assertMediaPayload, fingerprintElementId, @@ -17,6 +19,15 @@ function writeFixture(name: string, contents: string | Buffer): string { return filePath; } +function writeTree(files: Record): string { + const dir = mkdtempSync(join(tmpdir(), "hf-playlist-tree-")); + for (const [name, contents] of Object.entries(files)) { + mkdirSync(join(dir, name, ".."), { recursive: true }); + writeFileSync(join(dir, name), contents); + } + return join(dir, Object.keys(files)[0]!); +} + describe("isNotMediaPayload", () => { it.each([ ["doctype", "\n"], @@ -201,15 +212,6 @@ describe("playlistLeavesItsFolder", () => { expect(await isNotMediaPayload(file)).toBe(true); }); - function writeTree(files: Record): string { - const dir = mkdtempSync(join(tmpdir(), "hf-playlist-tree-")); - for (const [name, contents] of Object.entries(files)) { - mkdirSync(join(dir, name, ".."), { recursive: true }); - writeFileSync(join(dir, name), contents); - } - return join(dir, Object.keys(files)[0]!); - } - it("refuses a list whose nested list names a file outside the top folder", async () => { const master = writeTree({ "master.m3u8": "#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=1\nsub/inner.m3u8\n", @@ -252,3 +254,140 @@ describe("playlistLeavesItsFolder", () => { expect(await playlistLeavesItsFolder(writeFixture("clip.m3u8", contents))).toBe(false); }); }); + +describe("playlistLeavesItsFolder reads a list as ffprobe does", () => { + const FFPROBE_8 = /^ffprobe version n?8\./.test( + spawnSync(getFfprobeBinary(), ["-version"], { encoding: "utf-8" }).stdout ?? "", + ); + const head = "#EXTM3U\n#EXT-X-TARGETDURATION:1\n"; + const tail = "#EXTINF:1,\nseg.ts\n#EXT-X-ENDLIST\n"; + const outside = "../outside/secret.mp4"; + // Cut at ffmpeg's 4095-byte line limit this names the outside file; whole, it walks back in. + const cutLine = "./".repeat((4095 - outside.length) / 2) + outside + "/../../proj/seg.ts"; + // Each 0xFF is one byte to ffmpeg, so the cut lands after the outside name, not inside it. + const tagStart = Buffer.concat([ + Buffer.from('#EXT-X-MAP:X="'), + Buffer.alloc(40, 0xff), + Buffer.from('",URI="'), + ]); + const tagPad = 4095 - tagStart.length - outside.length; + const notUtf8Line = Buffer.concat([ + tagStart, + Buffer.from( + "./".repeat(Math.floor(tagPad / 2)) + + (tagPad % 2 ? "/" : "") + + outside + + '/../../proj/seg.ts"', + ), + ]); + + it.each([ + ["a segment after a bare carriage return", `${head}#EXTINF:1,\r${outside}\n#EXT-X-ENDLIST\n`], + ["a segment after a NUL", `${head}#EXTINF:1,\0${outside}\n#EXT-X-ENDLIST\n`], + ["an unquoted map URI", `${head}#EXT-X-MAP:URI=${outside}\n${tail}`], + ["a backslash-escaped map URI", `${head}#EXT-X-MAP:URI=".\\./outside/secret.mp4"\n${tail}`], + [ + "an unquoted rendition URI", + `#EXTM3U\n#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=a,NAME=a,URI=${outside}\n` + + '#EXT-X-STREAM-INF:BANDWIDTH=1,AUDIO="a"\nv.m3u8\n', + ], + [ + "a list behind an ID3 tag", + Buffer.concat([ + Buffer.from([0x49, 0x44, 0x33, 4, 0, 0, 0, 0, 0, 0]), + Buffer.from(`${head}#EXTINF:1,\n${outside}\n#EXT-X-ENDLIST\n`), + ]), + ], + ["a segment line longer than ffmpeg reads", `${head}#EXTINF:1,\n${cutLine}\n#EXT-X-ENDLIST\n`], + [ + "a long tag line with bytes that are not UTF-8", + Buffer.concat([ + Buffer.from(head), + notUtf8Line, + Buffer.from("\n#EXTINF:1,\nseg.ts\n#EXT-X-ENDLIST\n"), + ]), + ], + ])("refuses %s", async (_name, contents) => { + const root = mkdtempSync(join(tmpdir(), "hf-playlist-ffprobe-")); + mkdirSync(join(root, "proj")); + mkdirSync(join(root, "outside")); + writeFileSync(join(root, "outside", "secret.mp4"), "outside media"); + writeFileSync(join(root, "proj", "v.m3u8"), head + tail); + writeFileSync(join(root, "proj", "clip.m3u8"), contents); + + expect(await playlistLeavesItsFolder(join(root, "proj", "clip.m3u8"))).toBe(true); + if (!FFPROBE_8) return; + const probe = spawnSync( + getFfprobeBinary(), + ["-loglevel", "debug", "-show_format", "--", "clip.m3u8"], + { + cwd: join(root, "proj"), + encoding: "utf-8", + }, + ); + expect(probe.stderr).toMatch(/outside\/secret\.mp4' for reading/); + }); + + it("refuses a nested name it cannot read, and keeps one that does not exist", async () => { + const list = (entry: string) => `${head}#EXTINF:1,\n${entry}\n#EXT-X-ENDLIST\n`; + const unreadable = writeTree({ "clip.m3u8": list("sub"), "sub/seg.ts": "segment" }); + expect(await playlistLeavesItsFolder(unreadable)).toBe(true); + const missing = writeTree({ "clip.m3u8": list("gone.ts") }); + expect(await playlistLeavesItsFolder(missing)).toBe(false); + const tooLong = writeTree({ "clip.m3u8": list("a".repeat(5000)) }); + expect(await playlistLeavesItsFolder(tooLong)).toBe(false); + }); + + it.skipIf(process.platform !== "linux")( + "reads a nested list whose name is not UTF-8 by its bytes", + async () => { + const root = mkdtempSync(join(tmpdir(), "hf-playlist-bytes-")); + const name = Buffer.concat([Buffer.from("in"), Buffer.from([0xff]), Buffer.from(".m3u8")]); + writeFileSync(Buffer.from(`${root}/${name.toString("latin1")}`, "latin1"), list(outside)); + const top = Buffer.concat([ + Buffer.from("#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=1\n"), + name, + Buffer.from("\n"), + ]); + writeFileSync(join(root, "clip.m3u8"), top); + expect(await playlistLeavesItsFolder(join(root, "clip.m3u8"))).toBe(true); + + function list(entry: string): string { + return `${head}#EXTINF:1,\n${entry}\n#EXT-X-ENDLIST\n`; + } + }, + ); + + it("keeps a list with the same tags naming files beside it", async () => { + const list = `${head}#EXT-X-MAP:URI=init.mp4\r#EXT-X-KEY:METHOD=AES-128,URI="k\\ey.bin"\r${tail}`; + expect(await playlistLeavesItsFolder(writeFixture("clip.m3u8", list))).toBe(false); + }); + + it("refuses a file behind more ID3 tags than it skips", async () => { + const tag = Buffer.from([0x49, 0x44, 0x33, 4, 0, 0, 0, 0, 0, 0]); + const file = writeFixture( + "clip.m3u8", + Buffer.concat([...Array(17).fill(tag), Buffer.from(head)]), + ); + expect(await playlistLeavesItsFolder(file)).toBe(true); + }); +}); + +describe.skipIf(process.platform === "win32")("a FIFO with no writer", () => { + function fifoBeside(list?: string): string { + const dir = mkdtempSync(join(tmpdir(), "hf-playlist-fifo-")); + execFileSync("mkfifo", [join(dir, "pipe.mp4")]); + if (list === undefined) return join(dir, "pipe.mp4"); + writeFileSync(join(dir, "clip.m3u8"), list); + return join(dir, "clip.m3u8"); + } + + it("is refused as media without waiting for a writer", async () => { + expect(await isNotMediaPayload(fifoBeside())).toBe(true); + }); + + it("is refused when a list names it, without waiting for a writer", async () => { + const list = fifoBeside("#EXTM3U\n#EXT-X-TARGETDURATION:1\n#EXTINF:1,\npipe.mp4\n"); + expect(await playlistLeavesItsFolder(list)).toBe(true); + }); +}); diff --git a/packages/engine/src/utils/notMediaPayload.ts b/packages/engine/src/utils/notMediaPayload.ts index 6231ae9209..4e58fbb722 100644 --- a/packages/engine/src/utils/notMediaPayload.ts +++ b/packages/engine/src/utils/notMediaPayload.ts @@ -1,4 +1,5 @@ import { createHash } from "node:crypto"; +import { constants } from "node:fs"; import { open as openFile } from "node:fs/promises"; import { dirname, isAbsolute, relative, resolve } from "node:path"; @@ -84,20 +85,43 @@ function byteOrderMarkLength(head: Buffer): number { return 0; } -/** Read up to `bytes` (default {@link SNIFF_BYTES}) from the front of the file. */ -async function readHead(filePath: string, bytes = SNIFF_BYTES): Promise { - const fh = await openFile(filePath, "r"); +type FileHandle = Awaited>; + +async function readAt(fh: FileHandle, bytes: number, position: number): Promise { + const buf = Buffer.alloc(bytes); + let filled = 0; + // Looped because a single read can come back short on NFS/FUSE and on + // FIFOs, which would truncate the window mid-prefix. + while (filled < buf.length) { + const { bytesRead } = await fh.read(buf, filled, buf.length - filled, position + filled); + if (bytesRead === 0) break; + filled += bytesRead; + } + return buf.subarray(0, filled); +} + +const OPEN_WITHOUT_WAITING = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0); + +/** Opens without waiting on a FIFO or device, and gives null for one. A folder opens, and reading it fails as before. */ +async function openRegular(path: string | Buffer): Promise { + const fh = await openFile(path, OPEN_WITHOUT_WAITING); try { - const buf = Buffer.alloc(bytes); - let filled = 0; - // Looped because a single read can come back short on NFS/FUSE and on - // FIFOs, which would truncate the window mid-prefix. - while (filled < buf.length) { - const { bytesRead } = await fh.read(buf, filled, buf.length - filled, filled); - if (bytesRead === 0) break; - filled += bytesRead; - } - return buf.subarray(0, filled); + const stats = await fh.stat(); + if (stats.isFile() || stats.isDirectory()) return fh; + } catch (error) { + await fh.close().catch(() => {}); + throw error; + } + await fh.close().catch(() => {}); + return null; +} + +/** Read up to {@link SNIFF_BYTES} from the front of the file; null when it is not a regular file. */ +async function readHead(filePath: string): Promise { + const fh = await openRegular(filePath); + if (!fh) return null; + try { + return await readAt(fh, SNIFF_BYTES, 0); } finally { await fh.close().catch(() => {}); } @@ -133,9 +157,8 @@ function startsWithDocumentByte(head: Buffer): boolean { */ export async function isNotMediaPayload(filePath: string): Promise { try { - return ( - startsWithDocumentByte(await readHead(filePath)) || (await playlistLeavesItsFolder(filePath)) - ); + const head = await readHead(filePath); + return !head || startsWithDocumentByte(head) || (await playlistLeavesItsFolder(filePath)); } catch { return false; } @@ -160,15 +183,65 @@ const HTTP_URL = /^https?:\/\//i; const OTHER_SCHEME = /^[a-z][a-z0-9+.-]+:/i; const DRIVE_PATH = /^[a-z]:[\\/]/i; -function playlistEntries(text: string): string[] | undefined { - const body = text.replace(/^\uFEFF/, "").trimStart(); - if (body.startsWith("#EXTM3U")) { - return body.split(/\r?\n/).flatMap((raw) => { - const line = raw.trim(); - const uris = [...line.matchAll(/URI="([^"]*)"/gi)].map((match) => match[1]!); - return line && !line.startsWith("#") ? [line, ...uris] : uris; - }); +// ffmpeg reads a playlist line into a 4096-byte buffer and drops the rest of it. +const MAX_HLS_LINE_BYTES = 4095; +const ATTRIBUTE_GAP = /[\t\n\v\f\r ,]/; + +/** + * Every name an HLS list can open, read as ffmpeg's hls demuxer reads it and also as written. + * The text is latin1, one character per byte, so a line is cut where ffmpeg cuts it. + */ +function hlsEntries(body: string): string[] { + const names = new Set(); + for (const raw of body.replaceAll("\0", "\n").split(/[\r\n]/)) { + for (const whole of new Set([raw, raw.slice(0, MAX_HLS_LINE_BYTES)])) { + const line = whole.replace(/[\t\v\f ]+$/, ""); + const found = line.startsWith("#") ? attributeUris(line) : [line, line.trim()]; + for (const name of found) if (name) names.add(name); + } } + return [...names]; +} + +/** `URI=` values of a tag, split as ffmpeg's `ff_parse_key_value` splits them. */ +function attributeUris(line: string): string[] { + const uris: string[] = []; + let at = line.indexOf(":") + 1; + while (at > 0 && at < line.length) { + while (at < line.length && ATTRIBUTE_GAP.test(line[at]!)) at++; + const equals = line.indexOf("=", at); + if (equals < 0) break; + const [value, next] = attributeValue(line, equals + 1); + if (line.slice(at, equals).toUpperCase() === "URI") uris.push(value); + at = next; + } + return uris; +} + +/** A quoted value drops its quotes and the backslash before any character; a bare one ends at a space or comma. */ +function attributeValue(line: string, at: number): [string, number] { + if (line[at] !== '"') { + let end = at; + while (end < line.length && !ATTRIBUTE_GAP.test(line[end]!)) end++; + return [line.slice(at, end), end]; + } + let value = ""; + let index = at + 1; + for (; index < line.length && line[index] !== '"'; index++) { + if (line[index] === "\\") { + if (index + 1 >= line.length) break; + index++; + } + value += line[index]; + } + return [value, line[index] === '"' ? index + 1 : index]; +} + +const UTF8_BOM = "\xEF\xBB\xBF"; + +function playlistEntries(text: string): string[] | undefined { + const body = (text.startsWith(UTF8_BOM) ? text.slice(UTF8_BOM.length) : text).trimStart(); + if (body.startsWith("#EXTM3U")) return hlsEntries(body); if (/^ffconcat\s+version/i.test(body)) { return body.split(/\r?\n/).flatMap((raw) => { const match = /^\s*file\s+(.*)$/.exec(raw); @@ -183,7 +256,7 @@ function playlistEntries(text: string): string[] | undefined { function entryLeavesFolder(entry: string, base: string, folder: string): boolean { if (HTTP_URL.test(entry)) return false; if (OTHER_SCHEME.test(entry) && !DRIVE_PATH.test(entry)) return true; - return [entry, safeDecode(entry)].some((path) => { + return [entry, percentDecoded(entry)].some((path) => { if (isAbsolute(path) || DRIVE_PATH.test(path) || path.startsWith("\\")) return true; const inside = relative(folder, resolve(base, path)); return ( @@ -192,12 +265,20 @@ function entryLeavesFolder(entry: string, base: string, folder: string): boolean }); } -function safeDecode(value: string): string { - try { - return decodeURIComponent(value); - } catch { - return value; - } +/** `%XX` escapes decoded to the byte they name, kept as latin1 like every other name here. */ +function percentDecoded(value: string): string { + return value.replace(/%([0-9a-f]{2})/gi, (_escape, hex: string) => + String.fromCharCode(Number.parseInt(hex, 16)), + ); +} + +/** Paths are walked as latin1 strings, one character per byte, and opened by those bytes. */ +const asBytes = (path: string): string => Buffer.from(path).toString("latin1"); + +interface Walk { + folder: string; + seen: Set; + verdicts: Map; } /** @@ -208,54 +289,105 @@ export async function playlistLeavesItsFolder( filePath: string, placedAt = filePath, ): Promise { - const placed = resolve(placedAt); - return listLeaves(resolve(filePath), placed, dirname(placed), new Set(), 0); -} - -async function startsAsPlaylist(path: string): Promise { - const head = (await readHead(path)) - .toString("utf8") - .replace(/^\uFEFF/, "") - .trimStart(); - return head.startsWith("#EXTM3U") || /^ffconcat\s+version/i.test(head); -} - -/** Every list a list names is read too, against the top list's folder. */ -async function listLeaves( - readPath: string, - path: string, - folder: string, - seen: Set, - depth: number, -): Promise { + const placed = asBytes(resolve(placedAt)); + const walk: Walk = { folder: dirname(placed), seen: new Set(), verdicts: new Map() }; try { - if (!(await startsAsPlaylist(readPath))) return false; - if (depth >= MAX_PLAYLIST_DEPTH) return true; - if (seen.has(path)) return false; - seen.add(path); - const body = await readHead(readPath, MAX_PLAYLIST_BYTES + 1); - if (body.length > MAX_PLAYLIST_BYTES) return true; - for (const entry of playlistEntries(body.toString("utf8")) ?? []) { - if (await entryLeaves(entry, dirname(path), folder, seen, depth)) return true; - } - return false; + return await listLeaves(asBytes(resolve(filePath)), placed, walk, 0); } catch { return false; } } -async function entryLeaves( - entry: string, - base: string, - folder: string, - seen: Set, +const MAX_ID3_TAGS = 16; + +function isId3Header(head: Buffer): boolean { + return ( + head.length >= 10 && + head.toString("latin1", 0, 3) === "ID3" && + head[3] !== 0xff && + head[4] !== 0xff && + head.subarray(6, 10).every((byte) => byte < 0x80) + ); +} + +/** Where the text starts: ffmpeg skips leading ID3v2 tags before it probes or parses a file. -1 past {@link MAX_ID3_TAGS}. */ +async function textStart(fh: FileHandle, first: Buffer): Promise { + let offset = 0; + let head = first; + for (let tags = 0; tags <= MAX_ID3_TAGS; tags++) { + if (!isId3Header(head)) return offset; + const size = (head[6]! << 21) | (head[7]! << 14) | (head[8]! << 7) | head[9]!; + offset += 10 + size + (head[5]! & 0x10 ? 10 : 0); + head = await readAt(fh, 10, offset); + } + return -1; +} + +function startsAsPlaylist(head: Buffer): boolean { + const text = head + .toString("utf8") + .replace(/^\uFEFF/, "") + .trimStart(); + return text.startsWith("#EXTM3U") || /^ffconcat\s+version/i.test(text); +} + +/** The list's text as latin1, null when the file is not a list, true when it must be refused unread. One open. */ +async function readList(path: string): Promise { + const fh = await openRegular(Buffer.from(path, "latin1")); + if (!fh) return true; + try { + const first = await readAt(fh, SNIFF_BYTES, 0); + const start = await textStart(fh, first); + if (start < 0) return true; + if (!startsAsPlaylist(start === 0 ? first : await readAt(fh, SNIFF_BYTES, start))) return null; + const body = await readAt(fh, MAX_PLAYLIST_BYTES + 1, start); + return body.length > MAX_PLAYLIST_BYTES ? true : body.toString("latin1"); + } finally { + await fh.close().catch(() => {}); + } +} + +const isMissing = (error: unknown): boolean => + ["ENOENT", "ENOTDIR", "ENAMETOOLONG"].includes( + (error as NodeJS.ErrnoException | null)?.code ?? "", + ); + +/** Every list a list names is read too, against the top list's folder. A nested file that exists but cannot be read is refused. */ +async function listLeaves( + readPath: string, + path: string, + walk: Walk, depth: number, ): Promise { - if (entryLeavesFolder(entry, base, folder)) return true; + const text = await readList(readPath).catch((error: unknown) => + depth > 0 && !isMissing(error) ? true : null, + ); + if (text === null) return false; + if (text === true || depth >= MAX_PLAYLIST_DEPTH) return true; + if (walk.seen.has(path)) return false; + walk.seen.add(path); + for (const entry of playlistEntries(text) ?? []) { + if (await entryLeaves(entry, dirname(path), walk, depth)) return true; + } + return false; +} + +async function entryLeaves( + entry: string, + base: string, + walk: Walk, + depth: number, +): Promise { + if (entryLeavesFolder(entry, base, walk.folder)) return true; if (HTTP_URL.test(entry)) return false; - for (const local of new Set([entry, safeDecode(entry)])) { + for (const local of new Set([entry, percentDecoded(entry)])) { const nested = resolve(base, local); - if (await listLeaves(nested, nested, folder, seen, depth + 1)) return true; + let verdict = walk.verdicts.get(nested); + if (verdict === undefined) { + verdict = await listLeaves(nested, nested, walk, depth + 1); + walk.verdicts.set(nested, verdict); + } + if (verdict) return true; } return false; }