/src/c.zig at 70e48bbdedf00fe070bb0fa04950c6b0e7149420

// Copyright 2025 Shota FUJI
//
// Licensed under the Zero-Clause BSD License or the Apache License, Version 2.0, at your option.
// You may not use, copy, modify, or distribute this file except according to those terms. You can
// find a copy of the Zero-Clause BSD License at LICENSES/0BSD.txt, and a copy of the Apache License,
// Version 2.0 at LICENSES/Apache-2.0.txt. You may also obtain a copy of the Apache License, Version
// 2.0 at <https://www.apache.org/licenses/LICENSE-2.0>
//
// SPDX-License-Identifier: 0BSD OR Apache-2.0
//
// ===
//
// C API.
//
// Throughout this module, I use `u8` for `char` counterpart. Even though they are not completely
// same type, this is suffice in my usecase. I'm not going to support ancient computers or DSP or
// whatever. I hate C.
//
// In order to make comparison easier, structs, enums and functions use same symbols defined in
// the header file. They should appear in the same order as possible. If you modified definitions
// in this file, update `c.h` too.

const std = @import("std");

const sood = @import("lib.zig");
const property = @import("Message/property.zig");
const constants = @import("constants.zig");

const sood_message_kind = enum(c_int) {
    SOOD_MESSAGE_UNKNOWN = 0,
    SOOD_MESSAGE_QUERY = 1,
    SOOD_MESSAGE_RESPONSE = 2,
};

const sood_message = extern struct {
    raw_ptr: [*]const u8,
    raw_len: usize,
    sood_message_kind: sood_message_kind,
};

const sood_parse_result = enum(c_int) {
    SOOD_PARSE_OK = 0,
    SOOD_PARSE_ERROR_HEADER_SIZE_MISMATCH = 1,
    SOOD_PARSE_ERROR_INVALID_SIGNATURE = 2,
};

export fn sood_parse(dst: *sood_message, ptr: [*]const u8, len: usize) sood_parse_result {
    const bytes = ptr[0..len];

    const message = sood.Message.parse(bytes) catch |err| return switch (err) {
        sood.Message.HeaderParseError.InvalidHeaderSize => .SOOD_PARSE_ERROR_HEADER_SIZE_MISMATCH,
        sood.Message.HeaderParseError.InvalidSignature => .SOOD_PARSE_ERROR_INVALID_SIGNATURE,
    };

    dst.raw_ptr = ptr;
    dst.raw_len = len;
    dst.sood_message_kind = switch (message.kind) {
        .unknown => .SOOD_MESSAGE_UNKNOWN,
        .query => .SOOD_MESSAGE_QUERY,
        .response => .SOOD_MESSAGE_RESPONSE,
    };

    return .SOOD_PARSE_OK;
}

const sood_message_property = extern struct {
    key_ptr: [*]const u8,
    key_len: usize,
    value_ptr: [*]const u8,
    value_len: usize,
};

const sood_message_read_property_result = enum(c_int) {
    SOOD_READ_PROPERTY_OK = 0,
    SOOD_READ_PROPERTY_DONE = 1,
    SOOD_READ_PROPERTY_ERROR_EMPTY_KEY = 2,
    SOOD_READ_PROPERTY_ERROR_KEY_SIZE_MISMATCH = 3,
    SOOD_READ_PROPERTY_ERROR_NON_UTF8_KEY = 4,
    SOOD_READ_PROPERTY_ERROR_VALUE_SIZE_CORRUPTED = 5,
    SOOD_READ_PROPERTY_ERROR_VALUE_SIZE_MISMATCH = 6,
    SOOD_READ_PROPERTY_ERROR_NON_UTF8_VALUE = 7,
};

const sood_message_iter = extern struct {
    msg: *const sood_message,
    i: usize,
};

export fn sood_message_iterator(dst: *sood_message_iter, msg: *const sood_message) void {
    dst.msg = msg;
    dst.i = constants.header_byte_size;
}

export fn sood_message_iter_next(
    iter: *sood_message_iter,
    dst: *sood_message_property,
) sood_message_read_property_result {
    const bytes = iter.msg.raw_ptr[iter.i..iter.msg.raw_len];
    if (bytes.len == 0) {
        return .SOOD_READ_PROPERTY_DONE;
    }

    var p: sood.Message.Property = undefined;

    iter.i += property.parseInto(bytes, &p) catch |err| return switch (err) {
        sood.Message.PropertyParseError.EmptyKey => .SOOD_READ_PROPERTY_ERROR_EMPTY_KEY,
        sood.Message.PropertyParseError.IncompleteKey => .SOOD_READ_PROPERTY_ERROR_KEY_SIZE_MISMATCH,
        sood.Message.PropertyParseError.NonUTF8Key => .SOOD_READ_PROPERTY_ERROR_NON_UTF8_KEY,
        sood.Message.PropertyParseError.InvalidValueSizeField => .SOOD_READ_PROPERTY_ERROR_VALUE_SIZE_CORRUPTED,
        sood.Message.PropertyParseError.NonUTF8Value => .SOOD_READ_PROPERTY_ERROR_NON_UTF8_VALUE,
        sood.Message.PropertyParseError.IncompleteValue => .SOOD_READ_PROPERTY_ERROR_VALUE_SIZE_MISMATCH,
    };

    dst.key_ptr = p.key.ptr;
    dst.key_len = p.key.len;
    dst.value_ptr = p.value.ptr;
    dst.value_len = p.value.len;

    return .SOOD_READ_PROPERTY_OK;
}

export const SOOD_DISCOVERY_QUERY_PREBUILT = constants.prebuilt_query.*;
export const SOOD_DISCOVERY_MULTICAST_IPV4_ADDRESS_BE = std.mem.readInt(u32, &sood.discovery.multicast_ipv4_address, .big);
export const SOOD_DISCOVERY_MULTICAST_IPV4_ADDRESS = sood.discovery.multicast_ipv4_address;
export const SOOD_DISCOVERY_SERVER_UDP_PORT: u16 = sood.discovery.udp_port;

test "sood_prebuilt_discovery_query size matches" {
    const testing = @import("std").testing;

    try testing.expectEqual(
        // This MUST be the same value as one in `c.h`.
        61,
        constants.prebuilt_query.len,
    );
}

const sood_discovery_response_parse_result = enum(c_int) {
    SOOD_DISCOVERY_RESPONSE_PARSE_OK = 0,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_HEADER_SIZE_MISMATCH = 1,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_INVALID_SIGNATURE = 2,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_EMPTY_KEY = 3,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_KEY_SIZE_MISMATCH = 4,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_NON_UTF8_KEY = 5,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_VALUE_SIZE_CORRUPTED = 6,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_VALUE_SIZE_MISMATCH = 7,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_NON_UTF8_VALUE = 8,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_UNEXPECTED_KIND = 9,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_MISSING_PROPERTY = 10,
    SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_UNEXPECTED_VALUE = 11,
};

const sood_discovery_response = extern struct {
    http_port: u16,
    name_ptr: [*]const u8,
    name_len: usize,
    display_version_ptr: [*]const u8,
    display_version_len: usize,
    unique_id_ptr: [*]const u8,
    unique_id_len: usize,
};

export fn sood_discovery_response_parse(
    dst: *sood_discovery_response,
    message_ptr: [*]const u8,
    message_len: usize,
) sood_discovery_response_parse_result {
    const ParseError = sood.discovery.Response.ParseError;

    const resp = sood.discovery.Response.parse(message_ptr[0..message_len]) catch |err| return switch (err) {
        ParseError.InvalidHeaderSize => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_HEADER_SIZE_MISMATCH,
        ParseError.InvalidSignature => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_INVALID_SIGNATURE,
        ParseError.EmptyKey => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_EMPTY_KEY,
        ParseError.IncompleteKey => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_KEY_SIZE_MISMATCH,
        ParseError.NonUTF8Key => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_NON_UTF8_KEY,
        ParseError.InvalidValueSizeField => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_VALUE_SIZE_CORRUPTED,
        ParseError.IncompleteValue => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_VALUE_SIZE_MISMATCH,
        ParseError.NonUTF8Value => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_NON_UTF8_VALUE,
        ParseError.NonResponseKindMessage => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_UNEXPECTED_KIND,
        ParseError.MissingRequiredProperty => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_MISSING_PROPERTY,
        ParseError.UnexpectedPropertyValue => .SOOD_DISCOVERY_RESPONSE_PARSE_ERROR_UNEXPECTED_VALUE,
    };

    dst.http_port = resp.http_port;
    dst.name_ptr = resp.name.ptr;
    dst.name_len = resp.name.len;
    dst.display_version_ptr = resp.display_version.ptr;
    dst.display_version_len = resp.display_version.len;
    dst.unique_id_ptr = resp.unique_id.ptr;
    dst.unique_id_len = resp.unique_id.len;

    return .SOOD_DISCOVERY_RESPONSE_PARSE_OK;
}