tiny.http.Frame

1pub const Frame = struct {2    fin: bool,3    opcode: Opcode,4    mask: ?[4]u8,5    payload: []const u8,67    pub fn parse(data: []u8, maximum_payload_bytes: usize) FrameError!FrameParseResult {8        if (data.len < 2) return FrameError.IncompleteFrame;9        if ((data[0] & 0x70) != 0) return FrameError.InvalidFrame;1011        const fin = (data[0] & 0x80) != 0;12        const opcode = try Opcode.fromWire(data[0] & 0x0F);1314        const masked = (data[1] & 0x80) != 0;15        const len7 = data[1] & 0x7F;1617        var header_len: usize = 2;18        var payload_len: usize = undefined;1920        if (len7 < 126) {21            payload_len = len7;22        } else if (len7 == 126) {23            if (data.len < 4) return FrameError.IncompleteFrame;24            payload_len = std.mem.readInt(u16, data[2..4], .big);25            if (payload_len < 126) return FrameError.InvalidFrame;26            header_len = 4;27        } else {28            if (data.len < 10) return FrameError.IncompleteFrame;29            const len64 = std.mem.readInt(u64, data[2..10], .big);30            if (len64 < 65536) return FrameError.InvalidFrame;31            if (@as(u128, len64) > maximum_protocol_payload_bytes) {32                return FrameError.InvalidFrame;33            }34            if (@as(u128, len64) > @as(u128, std.math.maxInt(usize))) {35                return FrameError.PayloadTooLarge;36            }37            payload_len = @intCast(len64);38            header_len = 10;39        }4041        try validateFrameHeader(fin, opcode, payload_len);42        if (payload_len > maximum_payload_bytes) return FrameError.PayloadTooLarge;4344        const mask_key_offset = header_len;45        if (masked) {46            header_len += 4;47        }4849        const total_len = std.math.add(usize, header_len, payload_len) catch {50            return FrameError.PayloadTooLarge;51        };52        if (data.len < total_len) return FrameError.IncompleteFrame;5354        const mask: ?[4]u8 = if (masked)55            data[mask_key_offset..][0..4].*56        else57            null;5859        const payload = data[header_len..total_len];60        if (mask) |m| {61            maskPayload(payload, payload, m);62        }6364        return .{65            .frame = .{66                .fin = fin,67                .opcode = opcode,68                .mask = mask,69                .payload = payload,70            },71            .consumed = total_len,72        };73    }7475    pub fn serializedLength(76        self: *const Frame,77        maximum_payload_bytes: usize,78    ) FrameError!usize {79        const header_bytes = try self.headerLength(maximum_payload_bytes);80        return std.math.add(usize, header_bytes, self.payload.len) catch {81            return FrameError.PayloadTooLarge;82        };83    }8485    pub fn serializeInto(86        self: *const Frame,87        output: []u8,88        maximum_payload_bytes: usize,89    ) FrameError![]u8 {90        const total_bytes = try self.serializedLength(maximum_payload_bytes);91        if (output.len < total_bytes) return FrameError.OutputTooSmall;92        const target = output[0..total_bytes];93        const header = try self.writeHeader(target, maximum_payload_bytes);94        const payload = target[header.len..];95        if (self.mask) |mask| {96            maskPayload(self.payload, payload, mask);97        } else {98            @memcpy(payload, self.payload);99        }100        return target;101    }102103    pub fn serializeHeaderInto(104        self: *const Frame,105        output: []u8,106        maximum_payload_bytes: usize,107    ) FrameError![]u8 {108        return try self.writeHeader(109            output,110            maximum_payload_bytes,111        );112    }113114    pub fn parseServer(data: []u8, maximum_payload_bytes: usize) FrameError!FrameParseResult {115        if (data.len < 2) return FrameError.IncompleteFrame;116        if ((data[1] & 0x80) == 0) return FrameError.MaskRequired;117118        return parse(data, maximum_payload_bytes);119    }120121    fn headerLength(self: *const Frame, maximum_payload_bytes: usize) FrameError!usize {122        const payload_bytes = self.payload.len;123        try validateFrameHeader(self.fin, self.opcode, payload_bytes);124        if (payload_bytes > maximum_payload_bytes) return FrameError.PayloadTooLarge;125        if (@as(u128, payload_bytes) > maximum_protocol_payload_bytes) {126            return FrameError.PayloadTooLarge;127        }128        const length_bytes: usize = if (payload_bytes < 126)129            0130        else if (payload_bytes <= std.math.maxInt(u16))131            2132        else133            8;134        return 2 + length_bytes + @as(usize, if (self.mask == null) 0 else 4);135    }136137    fn writeHeader(138        self: *const Frame,139        output: []u8,140        maximum_payload_bytes: usize,141    ) FrameError![]u8 {142        const header_bytes = try self.headerLength(maximum_payload_bytes);143        if (output.len < header_bytes) return FrameError.OutputTooSmall;144        const target = output[0..header_bytes];145        target[0] = @as(u8, if (self.fin) 0x80 else 0) | @backingInt(self.opcode);146147        const mask_bit: u8 = if (self.mask == null) 0 else 0x80;148        var index: usize = 1;149        if (self.payload.len < 126) {150            target[index] = mask_bit | @as(u8, @intCast(self.payload.len));151            index += 1;152        } else if (self.payload.len <= std.math.maxInt(u16)) {153            target[index] = mask_bit | 126;154            index += 1;155            std.mem.writeInt(u16, target[index..][0..2], @intCast(self.payload.len), .big);156            index += 2;157        } else {158            target[index] = mask_bit | 127;159            index += 1;160            std.mem.writeInt(u64, target[index..][0..8], @intCast(self.payload.len), .big);161            index += 8;162        }163        if (self.mask) |mask| {164            @memcpy(target[index..][0..mask.len], &mask);165            index += mask.len;166        }167        std.debug.assert(index == target.len);168        return target;169    }170};

1pub const Frame = websocket.Frame;