@aptre/v86 0.5.0

package/lib/marshall.ts

@@ -0,0 +1,168 @@
+// -------------------------------------------------
+// ------------------ Marshall ---------------------
+// -------------------------------------------------
+// helper functions for virtio and 9p.
+
+import { dbg_log } from './../src/log.js'
+
+const textde = new TextDecoder()
+const texten = new TextEncoder()
+
+// QID structure used in the 9P protocol.
+export interface QID {
+    type: number
+    version: number
+    path: number
+}
+
+// Tracks the current read offset during unmarshalling.
+export interface MarshallState {
+    offset: number
+}
+
+// Type codes used by Marshall/Unmarshall:
+// 'w' = word (4 bytes), 'd' = double word (8 bytes, only low 32 bits written),
+// 'h' = half word (2 bytes), 'b' = byte, 's' = length-prefixed string, 'Q' = QID (13 bytes).
+export type MarshallTypeCode = 'w' | 'd' | 'h' | 'b' | 's' | 'Q'
+
+type MarshallInput = any
+
+// Inserts data from an array to a byte aligned struct in memory
+export function Marshall(
+    typelist: MarshallTypeCode[],
+    input: MarshallInput[],
+    struct: Uint8Array,
+    offset: number,
+): number {
+    let item: MarshallInput
+    let size = 0
+    for (let i = 0; i < typelist.length; i++) {
+        item = input[i]
+        switch (typelist[i]) {
+            case 'w':
+                struct[offset++] = item & 0xff
+                struct[offset++] = (item >> 8) & 0xff
+                struct[offset++] = (item >> 16) & 0xff
+                struct[offset++] = (item >> 24) & 0xff
+                size += 4
+                break
+            case 'd': // double word
+                struct[offset++] = item & 0xff
+                struct[offset++] = (item >> 8) & 0xff
+                struct[offset++] = (item >> 16) & 0xff
+                struct[offset++] = (item >> 24) & 0xff
+                struct[offset++] = 0x0
+                struct[offset++] = 0x0
+                struct[offset++] = 0x0
+                struct[offset++] = 0x0
+                size += 8
+                break
+            case 'h':
+                struct[offset++] = item & 0xff
+                struct[offset++] = item >> 8
+                size += 2
+                break
+            case 'b':
+                struct[offset++] = item
+                size += 1
+                break
+            case 's': {
+                const lengthoffset = offset
+                let length = 0
+                struct[offset++] = 0 // set the length later
+                struct[offset++] = 0
+                size += 2
+
+                const stringBytes = texten.encode(item)
+                size += stringBytes.byteLength
+                length += stringBytes.byteLength
+                struct.set(stringBytes, offset)
+                offset += stringBytes.byteLength
+
+                struct[lengthoffset + 0] = length & 0xff
+                struct[lengthoffset + 1] = (length >> 8) & 0xff
+                break
+            }
+            case 'Q':
+                Marshall(
+                    ['b', 'w', 'd'],
+                    [item.type, item.version, item.path],
+                    struct,
+                    offset,
+                )
+                offset += 13
+                size += 13
+                break
+            default:
+                dbg_log('Marshall: Unknown type=' + typelist[i])
+                break
+        }
+    }
+    return size
+}
+
+// Extracts data from a byte aligned struct in memory to an array
+
+export function Unmarshall(
+    typelist: MarshallTypeCode[],
+    struct: Uint8Array,
+    state: MarshallState,
+): any[] {
+    let offset = state.offset
+
+    const output: any[] = []
+    for (let i = 0; i < typelist.length; i++) {
+        switch (typelist[i]) {
+            case 'w': {
+                let val = struct[offset++]
+                val += struct[offset++] << 8
+                val += struct[offset++] << 16
+                val += (struct[offset++] << 24) >>> 0
+                output.push(val)
+                break
+            }
+            case 'd': {
+                let val = struct[offset++]
+                val += struct[offset++] << 8
+                val += struct[offset++] << 16
+                val += (struct[offset++] << 24) >>> 0
+                offset += 4
+                output.push(val)
+                break
+            }
+            case 'h': {
+                const val = struct[offset++]
+                output.push(val + (struct[offset++] << 8))
+                break
+            }
+            case 'b':
+                output.push(struct[offset++])
+                break
+            case 's': {
+                let len = struct[offset++]
+                len += struct[offset++] << 8
+
+                const stringBytes = struct.slice(offset, offset + len)
+                offset += len
+                output.push(textde.decode(stringBytes))
+                break
+            }
+            case 'Q': {
+                state.offset = offset
+                const qid = Unmarshall(['b', 'w', 'd'], struct, state)
+                offset = state.offset
+                output.push({
+                    type: qid[0],
+                    version: qid[1],
+                    path: qid[2],
+                })
+                break
+            }
+            default:
+                dbg_log('Error in Unmarshall: Unknown type=' + typelist[i])
+                break
+        }
+    }
+    state.offset = offset
+    return output
+}