tiny.quic.packet

1pub const Common = struct {2    first: u8,3    version: u32,4    destination: ConnectionId,5    source: ConnectionId,6};

1/// A 20-byte array with the count of bytes in use holds the identifier a packet header carries, the2/// connection ID. A caller reads one out of a decoded header, or builds one to encode, and passes3/// it by value. RFC 9000 section 17.2 bounds a version 1 connection ID at 20 bytes, so the array4/// holds every legal value and the value copies without touching an allocator. Building one from a5/// longer slice gives `ConnectionIdTooLong`. The bytes past the length are zero, and `slice`6/// returns the bytes in use.7pub const ConnectionId = struct {8    bytes: ConnectionIdBytes,9    length: u5,1011    pub fn init(input: []const u8) error{ConnectionIdTooLong}!ConnectionId {12        if (input.len > connection_id_bytes_max) return error.ConnectionIdTooLong;13        var result = ConnectionId{14            .bytes = @splat(0),15            .length = @intCast(input.len),16        };17        @memcpy(result.bytes[0..input.len], input);18        return result;19    }2021    pub fn slice(self: *const ConnectionId) []const u8 {22        std.debug.assert(self.length <= connection_id_bytes_max);23        return self.bytes[0..self.length];24    }25};

1pub const Initial = struct {2    common: Common,3    token: []const u8,4    length: u62,5    packet_number_offset: usize,6};

1pub const Long = union(enum) {2    initial: Initial,3    zero_rtt: Protected,4    handshake: Protected,5    retry: Retry,6    version_negotiation: VersionNegotiation,78    pub fn packetNumberOffset(self: Long) ?usize {9        return switch (self) {10            .initial => |value| value.packet_number_offset,11            .zero_rtt, .handshake => |value| value.packet_number_offset,12            .retry, .version_negotiation => null,13        };14    }15};

1pub const Protected = struct {2    common: Common,3    length: u62,4    packet_number_offset: usize,5};

1pub const Retry = struct {2    common: Common,3    token: []const u8,4    integrity_tag: [16]u8,5};

1pub const Short = struct {2    first: u8,3    destination: ConnectionId,4    packet_number_offset: usize,5};

1pub const VersionIterator = struct {2    bytes: []const u8,3    index: usize,45    pub fn next(self: *VersionIterator) ?u32 {6        std.debug.assert(self.index <= self.bytes.len);7        if (self.index == self.bytes.len) return null;8        std.debug.assert(self.bytes.len - self.index >= 4);9        const value = std.mem.readInt(u32, self.bytes[self.index..][0..4], .big);10        self.index += 4;11        return value;12    }13};

1pub const VersionNegotiation = struct {2    common: Common,3    versions: []const u8,45    pub fn iterator(self: VersionNegotiation) VersionIterator {6        return .{ .bytes = self.versions, .index = 0 };7    }8};

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

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

1pub fn decodeLong(bytes: []const u8) DecodeError!model.Long {2    var input = cursor.Read.init(bytes);3    const first = try input.byte();4    if (first & 0x80 == 0) return error.InvalidHeader;5    const version = try input.int(u32);6    const common = try readCommon(&input, first, version);7    if (version == 0) return decodeVersionNegotiation(&input, common);8    if (version != 1) return error.UnsupportedVersion;9    if (first & 0x40 == 0) return error.InvalidHeader;10    return switch ((first >> 4) & 0x03) {11        0 => decodeInitial(&input, common),12        1 => .{ .zero_rtt = try decodeProtected(&input, common) },13        2 => .{ .handshake = try decodeProtected(&input, common) },14        3 => decodeRetry(&input, common),15        else => unreachable,16    };17}

1pub fn decodeShort(bytes: []const u8, destination_length: u5) DecodeError!model.Short {2    if (destination_length > model.connection_id_bytes_max) {3        return error.ConnectionIdTooLong;4    }5    var input = cursor.Read.init(bytes);6    const first = try input.byte();7    if (first & 0x80 != 0) return error.InvalidHeader;8    if (first & 0x40 == 0) return error.InvalidHeader;9    const destination = model.ConnectionId.init(try input.take(destination_length)) catch10        return error.ConnectionIdTooLong;11    return .{12        .first = first,13        .destination = destination,14        .packet_number_offset = input.index,15    };16}

1pub fn encodeLong(value: model.Long, output: *cursor.Write) EncodeError!void {2    switch (value) {3        .version_negotiation => |packet| {4            if (packet.common.version != 0) return error.InvalidHeader;5            if (packet.versions.len == 0) return error.InvalidVersionList;6            if (packet.versions.len % 4 != 0) return error.InvalidVersionList;7            try writeCommon(packet.common, output);8            try output.put(packet.versions);9        },10        .initial => |packet| {11            try validateVersionOne(packet.common, 0);12            if (packet.length == 0) return error.InvalidLength;13            try writeCommon(packet.common, output);14            _ = try varint.write(@intCast(packet.token.len), output);15            try output.put(packet.token);16            _ = try varint.write(packet.length, output);17        },18        .zero_rtt => |packet| try writeProtected(packet, 1, output),19        .handshake => |packet| try writeProtected(packet, 2, output),20        .retry => |packet| {21            try validateVersionOne(packet.common, 3);22            if (packet.token.len == 0) return error.InvalidRetry;23            try writeCommon(packet.common, output);24            try output.put(packet.token);25            try output.put(&packet.integrity_tag);26        },27    }28}

1pub fn encodeShort(value: model.Short, output: *cursor.Write) EncodeError!void {2    if (value.first & 0x80 != 0) return error.InvalidHeader;3    if (value.first & 0x40 == 0) return error.InvalidHeader;4    try output.byte(value.first);5    try output.put(value.destination.slice());6}

1pub fn packetNumberLength(first: u8) u3 {2    return @as(u3, @intCast(first & 0x03)) + 1;3}

1pub const connection_id_bytes_max: u5 = 20;

1const header = @import("header.zig");2const model = @import("model.zig");3const number = @import("number.zig");45pub const connection_id_bytes_max = model.connection_id_bytes_max;6pub const ConnectionId = model.ConnectionId;7pub const Common = model.Common;8pub const Initial = model.Initial;9pub const Protected = model.Protected;10pub const Retry = model.Retry;11pub const VersionNegotiation = model.VersionNegotiation;12pub const VersionIterator = model.VersionIterator;13pub const Long = model.Long;14pub const Short = model.Short;1516pub const Number = struct {17    pub const Truncated: type = number.Truncated;18    pub const truncate = number.truncate;19    pub const expand = number.expand;20};2122pub const DecodeError = header.DecodeError;23pub const EncodeError = header.EncodeError;24pub const decodeLong = header.decodeLong;25pub const encodeLong = header.encodeLong;26pub const decodeShort = header.decodeShort;27pub const encodeShort = header.encodeShort;28pub const packetNumberLength = header.packetNumberLength;

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