tiny.stun.Builder

1pub const Builder = struct {2    storage: []u8,3    capacity: Capacity,4    transaction_id: TransactionId,5    index: usize = header_bytes,6    attribute_count: u14 = 0,7    state: BuilderState = .attributes,89    pub fn init(10        storage: []u8,11        limits: Limits,12        class: Class,13        method: Method,14        transaction_id: TransactionId,15    ) EncodeError!Builder {16        const capacity = try Capacity.derive(limits);17        if (storage.len < capacity.message_bytes) return error.StorageTooSmall;18        var builder = Builder{19            .storage = storage[0..capacity.message_bytes],20            .capacity = capacity,21            .transaction_id = transaction_id,22        };23        std.mem.writeInt(u16, builder.storage[0..2], encodeType(method, class), .big);24        std.mem.writeInt(u16, builder.storage[2..4], 0, .big);25        std.mem.writeInt(u32, builder.storage[4..8], magic_cookie, .big);26        @memcpy(builder.storage[8..20], &transaction_id);27        return builder;28    }2930    pub fn appendRaw(31        self: *Builder,32        type_code: u16,33        value: []const u8,34    ) EncodeError!void {35        const zeros = [_]u8{ 0, 0, 0 };36        const padding_len = attribute.paddingLength(value.len);37        try self.appendRawPadded(type_code, value, zeros[0..padding_len]);38    }3940    pub fn appendRawPadded(41        self: *Builder,42        type_code: u16,43        value: []const u8,44        padding: []const u8,45    ) EncodeError!void {46        if (self.state != .attributes) return error.InvalidBuilderState;47        if (isIntegrityOrFingerprint(type_code)) return error.UseFinishFunction;48        if (padding.len != attribute.paddingLength(value.len)) {49            return error.InvalidAttributePadding;50        }51        const region = try self.reserve(value.len, padding.len);52        std.mem.writeInt(u16, self.storage[region.start..][0..2], type_code, .big);53        std.mem.writeInt(u16, self.storage[region.start + 2 ..][0..2], @intCast(value.len), .big);54        @memcpy(self.storage[region.value_start..region.value_end], value);55        @memcpy(self.storage[region.value_end..region.end], padding);56        self.commit(region.end);57    }5859    pub fn appendDecoded(self: *Builder, value: attribute.Attribute) EncodeError!void {60        try self.appendRawPadded(value.type_code, value.raw_value, value.padding);61    }6263    pub fn appendUsername(self: *Builder, username: []const u8) EncodeError!void {64        _ = try integrity.shortTermKey(username);65        try self.appendRaw(@backingInt(attribute.Type.username), username);66    }6768    pub fn appendAddress(69        self: *Builder,70        attribute_type: attribute.Type,71        address: attribute.Address,72    ) EncodeError!void {73        const xor_cookie: ?u32 = switch (attribute_type) {74            .xor_mapped_address => magic_cookie,75            .mapped_address, .alternate_server, .response_origin, .other_address => null,76            else => return error.InvalidAttributeType,77        };78        var encoded: [20]u8 = undefined;79        const length = attribute.encodeAddress(80            &encoded,81            address,82            xor_cookie,83            self.transaction_id,84        );85        try self.appendRaw(@backingInt(attribute_type), encoded[0..length]);86    }8788    pub fn appendChangeRequest(89        self: *Builder,90        request: attribute.ChangeRequest,91    ) EncodeError!void {92        var encoded: [4]u8 = @splat(0);93        if (request.change_ip) encoded[3] |= 0x04;94        if (request.change_port) encoded[3] |= 0x02;95        try self.appendRaw(@backingInt(attribute.Type.change_request), &encoded);96    }9798    pub fn appendResponsePort(self: *Builder, port: u16) EncodeError!void {99        var encoded: [2]u8 = undefined;100        std.mem.writeInt(u16, &encoded, port, .big);101        try self.appendRaw(@backingInt(attribute.Type.response_port), &encoded);102    }103104    pub fn finishIntegrity(self: *Builder, key: []const u8) EncodeError!void {105        if (self.state != .attributes) return error.InvalidBuilderState;106        const region = try self.reserve(integrity.sha1_bytes, 0);107        writeAttributeHeader(108            self.storage,109            region.start,110            @backingInt(attribute.Type.message_integrity),111            integrity.sha1_bytes,112        );113        @memset(self.storage[region.value_start..region.value_end], 0);114        const adjusted_len: u16 = @intCast(region.end - header_bytes);115        var digest: [integrity.sha1_bytes]u8 = undefined;116        integrity.hmacSha1Adjusted(&digest, self.storage, region.start, adjusted_len, key);117        @memcpy(self.storage[region.value_start..region.value_end], &digest);118        self.state = .sha1;119        self.commit(region.end);120    }121122    pub fn finishIntegritySha256(self: *Builder, key: []const u8) EncodeError!void {123        if (self.state != .attributes and self.state != .sha1) {124            return error.InvalidBuilderState;125        }126        const region = try self.reserve(integrity.sha256_bytes, 0);127        writeAttributeHeader(128            self.storage,129            region.start,130            @backingInt(attribute.Type.message_integrity_sha256),131            integrity.sha256_bytes,132        );133        @memset(self.storage[region.value_start..region.value_end], 0);134        const adjusted_len: u16 = @intCast(region.end - header_bytes);135        var digest: [integrity.sha256_bytes]u8 = undefined;136        integrity.hmacSha256Adjusted(&digest, self.storage, region.start, adjusted_len, key);137        @memcpy(self.storage[region.value_start..region.value_end], &digest);138        self.state = .sha256;139        self.commit(region.end);140    }141142    pub fn finishFingerprint(self: *Builder) EncodeError!void {143        if (self.state == .fingerprint) return error.InvalidBuilderState;144        const region = try self.reserve(4, 0);145        writeAttributeHeader(146            self.storage,147            region.start,148            @backingInt(attribute.Type.fingerprint),149            4,150        );151        @memset(self.storage[region.value_start..region.value_end], 0);152        self.patchLength(region.end);153        const value = integrity.fingerprint(self.storage[0..region.start]);154        std.mem.writeInt(u32, self.storage[region.value_start..][0..4], value, .big);155        self.state = .fingerprint;156        self.commit(region.end);157    }158159    pub fn finish(self: *Builder) []const u8 {160        self.patchLength(self.index);161        return self.storage[0..self.index];162    }163164    fn reserve(self: *Builder, value_len: usize, padding_len: usize) EncodeError!BuilderRegion {165        if (self.attribute_count == self.capacity.attributes) {166            return error.AttributeLimitExceeded;167        }168        if (value_len > std.math.maxInt(u16)) return error.MessageTooLarge;169        const value_start = std.math.add(usize, self.index, 4) catch170            return error.CapacityOverflow;171        const value_end = std.math.add(usize, value_start, value_len) catch172            return error.CapacityOverflow;173        const end = std.math.add(usize, value_end, padding_len) catch174            return error.CapacityOverflow;175        if (end > self.capacity.message_bytes) return error.MessageTooLarge;176        if (end - header_bytes > max_payload_bytes) return error.MessageTooLarge;177        return .{178            .start = self.index,179            .value_start = value_start,180            .value_end = value_end,181            .end = end,182        };183    }184185    fn commit(self: *Builder, end: usize) void {186        std.debug.assert(end > self.index);187        std.debug.assert(end <= self.capacity.message_bytes);188        self.index = end;189        self.attribute_count += 1;190        self.patchLength(end);191    }192193    fn patchLength(self: *Builder, end: usize) void {194        std.debug.assert(end >= header_bytes);195        std.debug.assert(end - header_bytes <= max_payload_bytes);196        std.mem.writeInt(u16, self.storage[2..4], @intCast(end - header_bytes), .big);197    }198};

1pub const Builder = message_mod.Builder;