SandboXP

1
// -------------------------------------------------
2
// ------------------ Marshall ---------------------
3
// -------------------------------------------------
4
// helper functions for virtio and 9p.
5

6
"use strict";
7

8
var marshall = {};
9

10

11
// Inserts data from an array to a byte aligned struct in memory
12
marshall.Marshall = function(typelist, input, struct, offset) {
13
    var item;
14
    var size = 0;
15
    for (var i=0; i < typelist.length; i++) {
16
        item = input[i];
17
        switch (typelist[i]) {
18
            case "w":
19
                struct[offset++] = item & 0xFF;
20
                struct[offset++] = (item >> 8) & 0xFF;
21
                struct[offset++] = (item >> 16) & 0xFF;
22
                struct[offset++] = (item >> 24) & 0xFF;
23
                size += 4;
24
                break;
25
            case "d": // double word
26
                struct[offset++] = item & 0xFF;
27
                struct[offset++] = (item >> 8) & 0xFF;
28
                struct[offset++] = (item >> 16) & 0xFF;
29
                struct[offset++] = (item >> 24) & 0xFF;
30
                struct[offset++] = 0x0;
31
                struct[offset++] = 0x0;
32
                struct[offset++] = 0x0;
33
                struct[offset++] = 0x0;
34
                size += 8;
35
                break;
36
            case "h":
37
                struct[offset++] = item & 0xFF;
38
                struct[offset++] = item >> 8;
39
                size += 2;
40
                break;
41
            case "b":
42
                struct[offset++] = item;
43
                size += 1;
44
                break;
45
            case "s":
46
                var lengthoffset = offset;
47
                var length = 0;
48
                struct[offset++] = 0; // set the length later
49
                struct[offset++] = 0;
50
                size += 2;
51
                for (var j of item) {
52
                    var utf8 = UnicodeToUTF8Stream(j.charCodeAt(0));
53
                    utf8.forEach( function(c) {
54
                        struct[offset++] = c;
55
                        size += 1;
56
                        length++;
57
                    });
58
                }
59
                struct[lengthoffset+0] = length & 0xFF;
60
                struct[lengthoffset+1] = (length >> 8) & 0xFF;
61
                break;
62
            case "Q":
63
                marshall.Marshall(["b", "w", "d"], [item.type, item.version, item.path], struct, offset);
64
                offset += 13;
65
                size += 13;
66
                break;
67
            default:
68
                message.Debug("Marshall: Unknown type=" + typelist[i]);
69
                break;
70
        }
71
    }
72
    return size;
73
};
74

75

76
// Extracts data from a byte aligned struct in memory to an array
77
marshall.Unmarshall = function(typelist, struct, state) {
78
    let offset = state.offset;
79
    var output = [];
80
    for (var i=0; i < typelist.length; i++) {
81
        switch (typelist[i]) {
82
            case "w":
83
                var val = struct[offset++];
84
                val += struct[offset++] << 8;
85
                val += struct[offset++] << 16;
86
                val += (struct[offset++] << 24) >>> 0;
87
                output.push(val);
88
                break;
89
            case "d":
90
                var val = struct[offset++];
91
                val += struct[offset++] << 8;
92
                val += struct[offset++] << 16;
93
                val += (struct[offset++] << 24) >>> 0;
94
                offset += 4;
95
                output.push(val);
96
                break;
97
            case "h":
98
                var val = struct[offset++];
99
                output.push(val + (struct[offset++] << 8));
100
                break;
101
            case "b":
102
                output.push(struct[offset++]);
103
                break;
104
            case "s":
105
                var len = struct[offset++];
106
                len += struct[offset++] << 8;
107
                var str = '';
108
                var utf8converter = new UTF8StreamToUnicode();
109
                for (var j=0; j < len; j++) {
110
                    var c = utf8converter.Put(struct[offset++]);
111
                    if (c == -1) continue;
112
                    str += String.fromCharCode(c);
113
                }
114
                output.push(str);
115
                break;
116
            case "Q":
117
                state.offset = offset;
118
                const qid = marshall.Unmarshall(["b", "w", "d"], struct, state);
119
                offset = state.offset;
120
                output.push({
121
                    type: qid[0],
122
                    version: qid[1],
123
                    path: qid[2],
124
                });
125
                break;
126
            default:
127
                message.Debug("Error in Unmarshall: Unknown type=" + typelist[i]);
128
                break;
129
        }
130
    }
131
    state.offset = offset;
132
    return output;
133
};
134