1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120
121. 121
122. 122
123. 123
124. 124
125. 125
126. 126
127. 127
128. 128
129. 129
130. 130
131. 131
132. 132

// 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 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.Header.ParseError.InvalidHeaderSize => .SOOD_PARSE_ERROR_HEADER_SIZE_MISMATCH,
        sood.Message.Header.ParseError.InvalidSignature => .SOOD_PARSE_ERROR_INVALID_SIGNATURE,
    };

    dst.raw_ptr = ptr;
    dst.raw_len = len;
    dst.sood_message_kind = switch (message.header.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 = sood.Message.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 += sood.Message.readProperty(bytes, &p) catch |err| return switch (err) {
        sood.Message.ReadPropertyError.EmptyKey => .SOOD_READ_PROPERTY_ERROR_EMPTY_KEY,
        sood.Message.ReadPropertyError.IncompleteKey => .SOOD_READ_PROPERTY_ERROR_KEY_SIZE_MISMATCH,
        sood.Message.ReadPropertyError.NonUTF8Key => .SOOD_READ_PROPERTY_ERROR_NON_UTF8_KEY,
        sood.Message.ReadPropertyError.InvalidValueSizeField => .SOOD_READ_PROPERTY_ERROR_VALUE_SIZE_CORRUPTED,
        sood.Message.ReadPropertyError.NonUTF8Value => .SOOD_READ_PROPERTY_ERROR_NON_UTF8_VALUE,
        sood.Message.ReadPropertyError.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 = sood.discovery.Query.prebuilt.*;
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,
        sood_discovery_query_prebuilt.len,
    );
}