tiny.quic.frame

1pub const Ack = struct {2    largest: u62,3    delay: u62,4    first_range: u62,5    range_count: u8,6    ranges: []const u8,7    ecn: ?Ecn,89    pub fn iterator(self: Ack) AckIterator {10        return .{11            .input = quic.cursor.Read.init(self.ranges),12            .remaining = self.range_count,13        };14    }15};

1pub const AckIterator = struct {2    input: quic.cursor.Read,3    remaining: u8,45    pub fn next(self: *AckIterator) quic.varint.DecodeError!?AckRange {6        if (self.remaining == 0) return null;7        self.remaining -= 1;8        return .{9            .gap = (try quic.varint.read(&self.input)).value,10            .length = (try quic.varint.read(&self.input)).value,11        };12    }1314    pub fn exhausted(self: *const AckIterator) bool {15        return self.remaining == 0 and self.input.remaining() == 0;16    }17};

1pub const AckRange = struct {2    gap: u62,3    length: u62,4};

1pub const ConnectionClose = struct {2    application: bool,3    error_code: u62,4    frame_type: ?u62,5    reason: []const u8,6};

1pub const Crypto = struct {2    offset: u62,3    data: []const u8,4};

1pub const Datagram = struct {2    length_present: bool,3    data: []const u8,4};

1pub const Ecn = struct {2    ect0: u62,3    ect1: u62,4    ce: u62,5};

1pub const Frame = union(enum) {2    padding: void,3    ping: void,4    ack: Ack,5    reset_stream: ResetStream,6    stop_sending: StopSending,7    crypto: Crypto,8    new_token: []const u8,9    stream: Stream,10    max_data: u62,11    max_stream_data: StreamData,12    max_streams: StreamLimit,13    data_blocked: u62,14    stream_data_blocked: StreamData,15    streams_blocked: StreamLimit,16    new_connection_id: NewConnectionId,17    retire_connection_id: u62,18    path_challenge: [8]u8,19    path_response: [8]u8,20    connection_close: ConnectionClose,21    handshake_done: void,22    datagram: Datagram,23};

1pub const NewConnectionId = struct {2    sequence: u62,3    retire_prior_to: u62,4    connection_id: quic.packet.ConnectionId,5    reset_token: [16]u8,6};

1pub const ResetStream = struct {2    stream_id: u62,3    error_code: u62,4    final_size: u62,5};

1pub const StopSending = struct {2    stream_id: u62,3    error_code: u62,4};

1pub const Stream = struct {2    stream_id: u62,3    offset: u62,4    offset_present: bool,5    length_present: bool,6    fin: bool,7    data: []const u8,8};

1pub const StreamData = struct {2    stream_id: u62,3    maximum: u62,4};

1pub const StreamLimit = struct {2    unidirectional: bool,3    maximum: u62,4};

1pub const DecodeError = cursor.ReadError || varint.DecodeError || DecodeSpecific;

1pub const EncodeError = cursor.WriteError || varint.EncodeError || EncodeSpecific;

1pub fn decode(input: *cursor.Read) DecodeError!model.Frame {2    const frame_type = try readType(input);3    if (frame_type >= 0x08 and frame_type <= 0x0f) {4        return decodeStream(input, frame_type);5    }6    return switch (frame_type) {7        0x00 => .{ .padding = {} },8        0x01 => .{ .ping = {} },9        0x02 => decodeAck(input, false),10        0x03 => decodeAck(input, true),11        0x04 => .{ .reset_stream = .{12            .stream_id = (try varint.read(input)).value,13            .error_code = (try varint.read(input)).value,14            .final_size = (try varint.read(input)).value,15        } },16        0x05 => .{ .stop_sending = .{17            .stream_id = (try varint.read(input)).value,18            .error_code = (try varint.read(input)).value,19        } },20        0x06 => decodeCrypto(input),21        0x07 => decodeToken(input),22        0x10 => .{ .max_data = (try varint.read(input)).value },23        0x11 => .{ .max_stream_data = try decodeStreamData(input) },24        0x12, 0x13 => .{ .max_streams = try decodeStreamLimit(input, frame_type) },25        0x14 => .{ .data_blocked = (try varint.read(input)).value },26        0x15 => .{ .stream_data_blocked = try decodeStreamData(input) },27        0x16, 0x17 => .{ .streams_blocked = try decodeStreamLimit(input, frame_type) },28        0x18 => decodeNewConnectionId(input),29        0x19 => .{ .retire_connection_id = (try varint.read(input)).value },30        0x1a => .{ .path_challenge = try readEight(input) },31        0x1b => .{ .path_response = try readEight(input) },32        0x1c => decodeConnectionClose(input, false),33        0x1d => decodeConnectionClose(input, true),34        0x1e => .{ .handshake_done = {} },35        0x30 => decodeDatagram(input, false),36        0x31 => decodeDatagram(input, true),37        else => error.InvalidFrameType,38    };39}

1pub fn encode(value: model.Frame, output: *cursor.Write) EncodeError!void {2    switch (value) {3        .padding => try output.byte(0x00),4        .ping => try output.byte(0x01),5        .ack => |frame| try encodeAck(frame, output),6        .reset_stream => |frame| {7            try output.byte(0x04);8            _ = try varint.write(frame.stream_id, output);9            _ = try varint.write(frame.error_code, output);10            _ = try varint.write(frame.final_size, output);11        },12        .stop_sending => |frame| {13            try output.byte(0x05);14            _ = try varint.write(frame.stream_id, output);15            _ = try varint.write(frame.error_code, output);16        },17        .crypto => |frame| {18            if (!rangeFits(frame.offset, frame.data.len)) return error.InvalidLength;19            try output.byte(0x06);20            _ = try varint.write(frame.offset, output);21            _ = try varint.write(try sliceLength(frame.data.len), output);22            try output.put(frame.data);23        },24        .new_token => |token| {25            if (token.len == 0) return error.EmptyToken;26            try output.byte(0x07);27            _ = try varint.write(try sliceLength(token.len), output);28            try output.put(token);29        },30        .stream => |frame| try encodeStream(frame, output),31        .max_data => |maximum| try encodeOne(0x10, maximum, output),32        .max_stream_data => |frame| try encodeStreamData(0x11, frame, output),33        .max_streams => |frame| try encodeStreamLimit(0x12, frame, output),34        .data_blocked => |maximum| try encodeOne(0x14, maximum, output),35        .stream_data_blocked => |frame| try encodeStreamData(0x15, frame, output),36        .streams_blocked => |frame| try encodeStreamLimit(0x16, frame, output),37        .new_connection_id => |frame| try encodeNewConnectionId(frame, output),38        .retire_connection_id => |sequence| try encodeOne(0x19, sequence, output),39        .path_challenge => |data| try encodeEight(0x1a, data, output),40        .path_response => |data| try encodeEight(0x1b, data, output),41        .connection_close => |frame| try encodeConnectionClose(frame, output),42        .handshake_done => try output.byte(0x1e),43        .datagram => |frame| {44            try output.byte(if (frame.length_present) 0x31 else 0x30);45            if (frame.length_present) {46                _ = try varint.write(try sliceLength(frame.data.len), output);47            }48            try output.put(frame.data);49        },50    }51}

1pub const ack_ranges_max: u8 = 64;

1const codec = @import("codec.zig");2const model = @import("model.zig");34pub const ack_ranges_max = model.ack_ranges_max;5pub const Ecn = model.Ecn;6pub const AckRange = model.AckRange;7pub const AckIterator = model.AckIterator;8pub const Ack = model.Ack;9pub const ResetStream = model.ResetStream;10pub const StopSending = model.StopSending;11pub const Crypto = model.Crypto;12pub const Stream = model.Stream;13pub const StreamData = model.StreamData;14pub const StreamLimit = model.StreamLimit;15pub const NewConnectionId = model.NewConnectionId;16pub const ConnectionClose = model.ConnectionClose;17pub const Datagram = model.Datagram;18pub const Frame = model.Frame;19pub const DecodeError = codec.DecodeError;20pub const EncodeError = codec.EncodeError;21pub const decode = codec.decode;22pub const encode = codec.encode;

1pub const frame = @import("frame/root.zig");