[studio] tweaks for old unity multipart handling unquoted boundaries

apps/studio/src/multipart.ts

@@ -0,0 +1,130 @@
+/**
+ * A multipart/form-data parser that tolerates what the Studio editor actually sends.
+ *
+ * The editor writes `Content-Disposition: form-data; name=roomId; filename=a.assetbundle`
+ * with the parameter values UNQUOTED. RFC 7578 wants quotes, and the runtime's own
+ * parser (`Request.formData()`, and so Hono's `parseBody`) throws
+ * "Content-Disposition header in FormData part is missing a name" on the first such
+ * part. Caught and defaulted, that read as an empty form and the upload was refused
+ * with "No such room." Every field is parsed here instead, quoted or bare.
+ */
+
+export type FormFields = Record<string, string | File>
+
+const CRLF = new Uint8Array([13, 10])
+const HEADER_END = new Uint8Array([13, 10, 13, 10])
+const DASHES = new Uint8Array([45, 45])
+
+function indexOf(haystack: Uint8Array, needle: Uint8Array, from: number): number {
+	const first = needle[0]
+	const last = haystack.length - needle.length
+	outer: for (let i = from; i <= last; i++) {
+		if (haystack[i] !== first) continue
+		for (let j = 1; j < needle.length; j++) {
+			if (haystack[i + j] !== needle[j]) continue outer
+		}
+		return i
+	}
+	return -1
+}
+
+function startsWith(bytes: Uint8Array, prefix: Uint8Array, at: number): boolean {
+	if (at + prefix.length > bytes.length) return false
+	for (let i = 0; i < prefix.length; i++) if (bytes[at + i] !== prefix[i]) return false
+	return true
+}
+
+function boundaryOf(contentType: string | null): string | null {
+	const match = contentType?.match(/multipart\/form-data\s*;.*?boundary=(?:"([^"]+)"|([^;\s]+))/i)
+	return match ? (match[1] ?? match[2] ?? null) : null
+}
+
+/**
+ * `; name=value`, `; name="value"`, with `\"` escapes inside quotes. A bare value runs
+ * to the next `;`, which is how the editor's unquoted filenames end.
+ */
+function dispositionParams(header: string): Map<string, string> {
+	const params = new Map<string, string>()
+	const re = /;\s*([^=;\s]+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^;]*))/g
+	for (const m of header.matchAll(re)) {
+		const key = m[1].toLowerCase()
+		const value = m[2] != null ? m[2].replace(/\\(.)/g, '$1') : (m[3] ?? '').trim()
+		params.set(key, value)
+	}
+	return params
+}
+
+/** RFC 5987 `utf-8''percent%20encoded`; a value that fails to decode is left as is. */
+function extendedValue(raw: string): string {
+	const m = raw.match(/^(?:utf-8|utf8)'[^']*'(.*)$/i)
+	if (!m) return raw
+	try {
+		return decodeURIComponent(m[1])
+	} catch {
+		return m[1]
+	}
+}
+
+function headerValue(headers: string, name: string): string | null {
+	const re = new RegExp(`^${name}\\s*:\\s*(.*)$`, 'im')
+	const m = headers.match(re)
+	return m ? m[1].trim() : null
+}
+
+function parseParts(bytes: Uint8Array, boundary: string): FormFields {
+	const fields: FormFields = {}
+	const delimiter = new TextEncoder().encode(`--${boundary}`)
+	const decoder = new TextDecoder()
+
+	// The first delimiter has no CRLF before it; every later one is `CRLF--boundary`.
+	let pos = indexOf(bytes, delimiter, 0)
+	if (pos !== 0 && !(pos > 0 && startsWith(bytes, CRLF, pos - 2))) return fields
+	pos += delimiter.length
+
+	while (pos < bytes.length) {
+		if (startsWith(bytes, DASHES, pos)) break
+		// Skip transport padding up to the CRLF that ends the delimiter line.
+		const lineEnd = indexOf(bytes, CRLF, pos)
+		if (lineEnd < 0) break
+		const headersStart = lineEnd + 2
+		const headersEnd = indexOf(bytes, HEADER_END, headersStart)
+		if (headersEnd < 0) break
+		const contentStart = headersEnd + 4
+		// Content runs to the CRLF that precedes the next delimiter.
+		let next = indexOf(bytes, delimiter, contentStart)
+		while (next >= 0 && !startsWith(bytes, CRLF, next - 2)) {
+			next = indexOf(bytes, delimiter, next + delimiter.length)
+		}
+		if (next < 0) break
+		const content = bytes.subarray(contentStart, next - 2)
+		pos = next + delimiter.length
+
+		const headers = decoder.decode(bytes.subarray(headersStart, headersEnd))
+		const disposition = headerValue(headers, 'content-disposition')
+		if (disposition == null) continue
+		const params = dispositionParams(disposition)
+		const name = params.get('name')
+		if (name == null || name === '') continue
+		const filenameExt = params.get('filename*')
+		const filename = filenameExt != null ? extendedValue(filenameExt) : params.get('filename')
+		if (filename != null) {
+			const type = headerValue(headers, 'content-type') ?? 'application/octet-stream'
+			fields[name] = new File([content.slice()], filename, { type })
+		} else {
+			fields[name] = decoder.decode(content)
+		}
+	}
+	return fields
+}
+
+/**
+ * Parse the request body as multipart/form-data. Text parts are strings, parts with a
+ * filename are Files. A later part with the same name replaces an earlier one. A
+ * request that is not multipart, or has no boundary, parses as no fields.
+ */
+export async function parseMultipart(req: Request): Promise<FormFields> {
+	const boundary = boundaryOf(req.headers.get('content-type'))
+	if (boundary == null) return {}
+	const bytes = new Uint8Array(await req.arrayBuffer())
+	return parseParts(bytes, boundary)
+}