tiny.wayland.protocol.value

1pub const Decoder = struct {2    metadata: *const protocol.schema.Message,3    payload: []const u8,4    descriptors: []const sys.fd.Descriptor,5    byte_offset: usize = 0,6    descriptor_offset: usize = 0,78    pub fn init(9        metadata: *const protocol.schema.Message,10        payload: []const u8,11        descriptors: []const sys.fd.Descriptor,12    ) Error!Decoder {13        if (payload.len % 4 != 0) return error.InvalidAlignment;14        if (payload.len > value.maximum_payload_size) return error.MessageTooLarge;15        if (payload.len < metadata.minimum_payload_size) return error.PayloadTooSmall;16        if (descriptors.len != metadata.descriptor_count) return error.DescriptorCountMismatch;17        return .{18            .metadata = metadata,19            .payload = payload,20            .descriptors = descriptors,21        };22    }2324    pub fn signed(self: *Decoder) Error!i32 {25        const bytes = try self.word();26        return std.mem.readInt(i32, bytes, builtin.cpu.arch.endian());27    }2829    pub fn unsigned(self: *Decoder) Error!u32 {30        const bytes = try self.word();31        return std.mem.readInt(u32, bytes, builtin.cpu.arch.endian());32    }3334    pub fn fixed(self: *Decoder) Error!value.Fixed {35        return .fromRaw(try self.signed());36    }3738    pub fn string(self: *Decoder) Error![]const u8 {39        return (try self.optionalString()) orelse error.InvalidString;40    }4142    pub fn optionalString(self: *Decoder) Error!?[]const u8 {43        const length = try self.unsigned();44        if (length == 0) return null;45        const bytes = try self.delimited(length);46        if (bytes[bytes.len - 1] != 0) return error.InvalidString;47        const text = bytes[0 .. bytes.len - 1];48        if (std.mem.indexOfScalar(u8, text, 0) != null) return error.InvalidString;49        if (!std.unicode.utf8ValidateSlice(text)) return error.InvalidUtf8;50        return text;51    }5253    pub fn object(self: *Decoder) Error!value.ObjectId {54        return value.ObjectId.init(try self.unsigned()) catch return error.InvalidObject;55    }5657    pub fn optionalObject(self: *Decoder) Error!?value.ObjectId {58        const raw = try self.unsigned();59        return if (raw == 0) null else value.ObjectId.init(raw) catch return error.InvalidObject;60    }6162    pub fn newId(self: *Decoder) Error!value.NewId {63        return value.NewId.init(try self.unsigned()) catch return error.InvalidNewId;64    }6566    pub fn dynamicNewId(self: *Decoder) Error!value.DynamicNewId {67        const interface = try self.string();68        if (interface.len == 0) return error.InvalidInterface;69        const version = try self.unsigned();70        if (version == 0) return error.InvalidVersion;71        return .{72            .interface = interface,73            .version = version,74            .id = try self.newId(),75        };76    }7778    pub fn array(self: *Decoder) Error![]const u8 {79        return self.delimited(try self.unsigned());80    }8182    pub fn descriptor(self: *Decoder) Error!sys.fd.Descriptor {83        if (self.descriptor_offset == self.descriptors.len) return error.IncompletePayload;84        const item = self.descriptors[self.descriptor_offset];85        if (item < 0) return error.InvalidDescriptor;86        self.descriptor_offset += 1;87        return item;88    }8990    pub fn finish(self: *const Decoder) Error!void {91        if (self.byte_offset != self.payload.len) return error.TrailingPayload;92        if (self.descriptor_offset != self.descriptors.len) return error.TrailingDescriptors;93    }9495    fn word(self: *Decoder) Error!*const [4]u8 {96        if (self.payload.len - self.byte_offset < 4) return error.IncompletePayload;97        const bytes: *const [4]u8 = self.payload[self.byte_offset..][0..4];98        self.byte_offset += 4;99        return bytes;100    }101102    fn delimited(self: *Decoder, length: u32) Error![]const u8 {103        const rounded = std.math.add(usize, length, 3) catch return error.IncompletePayload;104        const padded_len = rounded & ~@as(usize, 3);105        if (padded_len > self.payload.len - self.byte_offset) return error.IncompletePayload;106        const bytes = self.payload[self.byte_offset..][0..length];107        self.byte_offset += padded_len;108        return bytes;109    }110};

1pub const Error = error{2    DescriptorCountMismatch,3    IncompletePayload,4    InvalidAlignment,5    InvalidDescriptor,6    InvalidInterface,7    InvalidNewId,8    InvalidObject,9    InvalidString,10    InvalidUtf8,11    InvalidVersion,12    MessageTooLarge,13    PayloadTooSmall,14    TrailingDescriptors,15    TrailingPayload,16};

1pub const Capacity = struct {2    payload_byte_count: usize,3    descriptor_count: usize,4    descriptor_bytes: usize,5    total_requested_bytes: usize,67    pub fn derive(limits: Limits) CapacityError!Capacity {8        if (limits.payload_byte_count > value.maximum_payload_size) {9            return error.PayloadStorageTooLarge;10        }11        if (limits.descriptor_count > sys.ancillary.maximum_descriptors) {12            return error.DescriptorStorageTooLarge;13        }14        const descriptor_bytes = std.math.mul(15            usize,16            limits.descriptor_count,17            @sizeOf(sys.fd.Descriptor),18        ) catch return error.CapacityOverflow;19        const total_requested_bytes = std.math.add(20            usize,21            limits.payload_byte_count,22            descriptor_bytes,23        ) catch return error.CapacityOverflow;24        return .{25            .payload_byte_count = limits.payload_byte_count,26            .descriptor_count = limits.descriptor_count,27            .descriptor_bytes = descriptor_bytes,28            .total_requested_bytes = total_requested_bytes,29        };30    }31};

1pub const CapacityError = error{2    PayloadStorageTooLarge,3    DescriptorStorageTooLarge,4    CapacityOverflow,5};

1pub const Encoder = struct {2    session_allocator: std.mem.Allocator,3    bytes: []u8,4    descriptors: []sys.fd.Descriptor,5    byte_count: usize = 0,6    descriptor_count: usize = 0,7    payload_capacity_rejection_count: u64 = 0,8    descriptor_capacity_rejection_count: u64 = 0,910    pub fn init(11        session_allocator: std.mem.Allocator,12        capacity: Capacity,13    ) std.mem.Allocator.Error!Encoder {14        const bytes = try session_allocator.alloc(u8, capacity.payload_byte_count);15        errdefer if (bytes.len != 0) session_allocator.free(bytes);16        return .{17            .session_allocator = session_allocator,18            .bytes = bytes,19            .descriptors = try session_allocator.alloc(20                sys.fd.Descriptor,21                capacity.descriptor_count,22            ),23        };24    }2526    pub fn deinit(self: *Encoder) void {27        self.assertValid();28        if (self.bytes.len != 0) self.session_allocator.free(self.bytes);29        if (self.descriptors.len != 0) self.session_allocator.free(self.descriptors);30        self.* = undefined;31    }3233    pub fn reset(self: *Encoder) void {34        self.assertValid();35        self.byte_count = 0;36        self.descriptor_count = 0;37    }3839    pub fn signed(self: *Encoder, item: i32) Error!void {40        var bytes: [4]u8 = undefined;41        std.mem.writeInt(i32, &bytes, item, builtin.cpu.arch.endian());42        try self.appendBytes(&bytes);43    }4445    pub fn unsigned(self: *Encoder, item: u32) Error!void {46        var bytes: [4]u8 = undefined;47        std.mem.writeInt(u32, &bytes, item, builtin.cpu.arch.endian());48        try self.appendBytes(&bytes);49    }5051    pub fn fixed(self: *Encoder, item: value.Fixed) Error!void {52        try self.signed(item.raw);53    }5455    pub fn string(self: *Encoder, text: []const u8) Error!void {56        try validateString(text);57        try self.lengthDelimited(text, true);58    }5960    pub fn optionalString(self: *Encoder, text: ?[]const u8) Error!void {61        if (text) |present| return self.string(present);62        try self.unsigned(0);63    }6465    pub fn object(self: *Encoder, id: value.ObjectId) Error!void {66        try self.unsigned(id.raw);67    }6869    pub fn optionalObject(self: *Encoder, id: ?value.ObjectId) Error!void {70        try self.unsigned(if (id) |present| present.raw else 0);71    }7273    pub fn newId(self: *Encoder, id: value.NewId) Error!void {74        try self.unsigned(id.raw);75    }7677    pub fn dynamicNewId(78        self: *Encoder,79        interface: []const u8,80        version: u32,81        id: value.NewId,82    ) Error!void {83        if (interface.len == 0) return error.InvalidInterface;84        if (version == 0) return error.InvalidVersion;85        const byte_mark = self.byte_count;86        errdefer self.byte_count = byte_mark;87        try self.string(interface);88        try self.unsigned(version);89        try self.newId(id);90    }9192    pub fn array(self: *Encoder, bytes: []const u8) Error!void {93        try self.lengthDelimited(bytes, false);94    }9596    pub fn descriptorBorrowed(self: *Encoder, descriptor: sys.fd.Descriptor) Error!void {97        self.assertValid();98        if (descriptor < 0) return error.InvalidDescriptor;99        if (self.descriptor_count == sys.ancillary.maximum_descriptors) {100            return error.TooManyDescriptors;101        }102        if (self.descriptor_count == self.descriptors.len) {103            self.descriptor_capacity_rejection_count +|= 1;104            return error.DescriptorCapacityExceeded;105        }106        self.descriptors[self.descriptor_count] = descriptor;107        self.descriptor_count += 1;108    }109110    pub fn finish(111        self: *const Encoder,112        metadata: *const @import("../root.zig").schema.Message,113    ) Error!value.Encoded {114        self.assertValid();115        if (self.byte_count < metadata.minimum_payload_size) return error.PayloadTooSmall;116        if (self.byte_count % 4 != 0) unreachable;117        if (self.descriptor_count != metadata.descriptor_count) {118            return error.DescriptorCountMismatch;119        }120        return .{121            .metadata = metadata,122            .payload = self.bytes[0..self.byte_count],123            .descriptors = self.descriptors[0..self.descriptor_count],124        };125    }126127    pub fn status(self: *const Encoder) Status {128        self.assertValid();129        return .{130            .payload_capacity_rejection_count = self.payload_capacity_rejection_count,131            .descriptor_capacity_rejection_count = self.descriptor_capacity_rejection_count,132        };133    }134135    fn appendBytes(self: *Encoder, bytes: []const u8) Error!void {136        try self.ensurePayloadCapacity(bytes.len);137        @memcpy(self.bytes[self.byte_count..][0..bytes.len], bytes);138        self.byte_count += bytes.len;139    }140141    fn lengthDelimited(self: *Encoder, bytes: []const u8, terminal_zero: bool) Error!void {142        const logical_len = std.math.add(usize, bytes.len, @intFromBool(terminal_zero)) catch {143            return error.MessageTooLarge;144        };145        if (logical_len > std.math.maxInt(u32)) return error.MessageTooLarge;146        const rounded_len = std.math.add(usize, logical_len, 3) catch return error.MessageTooLarge;147        const padded_len = rounded_len & ~@as(usize, 3);148        const encoded_len = std.math.add(usize, 4, padded_len) catch return error.MessageTooLarge;149        try self.ensurePayloadCapacity(encoded_len);150151        var length_bytes: [4]u8 = undefined;152        std.mem.writeInt(u32, &length_bytes, @intCast(logical_len), builtin.cpu.arch.endian());153        @memcpy(self.bytes[self.byte_count..][0..length_bytes.len], &length_bytes);154        self.byte_count += length_bytes.len;155        @memcpy(self.bytes[self.byte_count..][0..bytes.len], bytes);156        self.byte_count += bytes.len;157        if (terminal_zero) {158            self.bytes[self.byte_count] = 0;159            self.byte_count += 1;160        }161        const padding = padded_len - logical_len;162        @memset(self.bytes[self.byte_count..][0..padding], 0);163        self.byte_count += padding;164    }165166    fn ensurePayloadCapacity(self: *Encoder, additional: usize) Error!void {167        self.assertValid();168        const total = std.math.add(usize, self.byte_count, additional) catch {169            return error.MessageTooLarge;170        };171        if (total > value.maximum_payload_size) return error.MessageTooLarge;172        if (total > self.bytes.len) {173            self.payload_capacity_rejection_count +|= 1;174            return error.PayloadCapacityExceeded;175        }176    }177178    fn assertValid(self: *const Encoder) void {179        std.debug.assert(self.byte_count <= self.bytes.len);180        std.debug.assert(self.descriptor_count <= self.descriptors.len);181    }182};

1pub const Limits = struct {2    payload_byte_count: usize = value.maximum_payload_size,3    descriptor_count: usize = sys.ancillary.maximum_descriptors,4};

1pub const Status = struct {2    payload_capacity_rejection_count: u64 = 0,3    descriptor_capacity_rejection_count: u64 = 0,4};

1pub const StorageError = error{2    PayloadCapacityExceeded,3    DescriptorCapacityExceeded,4};

1pub const DynamicNewId = struct {2    interface: []const u8,3    version: u32,4    id: NewId,5};

1pub const Encoded = struct {2    metadata: *const protocol.schema.Message,3    payload: []const u8,4    descriptors: []const sys.fd.Descriptor,56    pub fn opcode(self: Encoded) u16 {7        return self.metadata.opcode;8    }9};

1pub const Fixed = struct {2    raw: i32,34    pub fn fromRaw(raw: i32) Fixed {5        return .{ .raw = raw };6    }78    pub fn fromInt(value: i32) error{Overflow}!Fixed {9        return .{ .raw = std.math.mul(i32, value, 256) catch return error.Overflow };10    }1112    pub fn toF64(self: Fixed) f64 {13        return @as(f64, @floatFromInt(self.raw)) / 256.0;14    }15};

1pub const NewId = struct {2    raw: u32,34    pub fn init(raw: u32) error{InvalidNewId}!NewId {5        if (raw == 0) return error.InvalidNewId;6        return .{ .raw = raw };7    }8};

1pub const ObjectId = struct {2    raw: u32,34    pub fn init(raw: u32) error{InvalidObject}!ObjectId {5        if (raw == 0) return error.InvalidObject;6        return .{ .raw = raw };7    }8};

1pub const Error = StorageError || ProtocolError;

1pub const default_capacity = Capacity.derive(.{}) catch unreachable;

1pub const maximum_payload_size = (std.math.maxInt(u16) & ~@as(u16, 3)) - 8;

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

1const decode = @import("decode.zig");2const encode = @import("encode.zig");3const types = @import("types.zig");45pub const validate = @import("validate.zig");67pub const Decoder = decode.Decoder;8pub const DecodeError = decode.Error;9pub const Encoder = encode.Encoder;10pub const EncoderError = encode.Error;11pub const EncoderLimits = encode.Limits;12pub const EncoderCapacity = encode.Capacity;13pub const EncoderCapacityError = encode.CapacityError;14pub const EncoderStorageError = encode.StorageError;15pub const EncoderStatus = encode.Status;16pub const default_encoder_capacity = encode.default_capacity;17pub const DynamicNewId = types.DynamicNewId;18pub const Encoded = types.Encoded;19pub const Fixed = types.Fixed;20pub const NewId = types.NewId;21pub const ObjectId = types.ObjectId;22pub const maximum_payload_size = types.maximum_payload_size;