/core/src/mod.zig at a079c8cd65b50ee763d22540b26c6c645555af01

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

//! This is an entrypoint of Zig module.

const std = @import("std");
const sood = @import("sood");

/// Data required to connect to a Roon Server
pub const Server = struct {
    ip_addr: std.net.Address,
    unique_id: []const u8,
    name: []const u8,
    version: []const u8,

    pub fn clone(self: Server, allocator: std.mem.Allocator) std.mem.Allocator.Error!Server {
        return Server{
            .ip_addr = self.ip_addr,
            .unique_id = try allocator.dupe(u8, self.unique_id),
            .name = try allocator.dupe(u8, self.name),
            .version = try allocator.dupe(u8, self.version),
        };
    }

    pub fn deinit(self: Server, allocator: std.mem.Allocator) void {
        allocator.free(self.unique_id);
        allocator.free(self.name);
        allocator.free(self.version);
    }

    pub fn jsonStringify(self: *const Server, jws: anytype) !void {
        try jws.beginObject();

        try jws.objectField("unique_id");
        try jws.write(self.unique_id);

        try jws.objectField("name");
        try jws.write(self.name);

        try jws.objectField("version");
        try jws.write(self.version);

        try jws.objectField("address");
        try jws.print("\"{}\"", .{self.ip_addr});

        try jws.endObject();
    }
};

pub const ServerScanner = struct {
    allocator: std.mem.Allocator,
    sockfd: std.posix.socket_t,

    servers: std.StringHashMap(Server),

    const dst = std.net.Address.initIp4(
        sood.discovery.multicast_ipv4_address,
        sood.discovery.udp_port,
    );

    pub const InitError = std.mem.Allocator.Error || std.posix.SocketError || std.posix.SetSockOptError;

    /// Caller must call `deinit()` after use.
    pub fn init(allocator: std.mem.Allocator) InitError!ServerScanner {
        const sockfd = try std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, 0);
        errdefer std.posix.close(sockfd);

        try std.posix.setsockopt(
            sockfd,
            std.posix.SOL.SOCKET,
            std.posix.SO.REUSEADDR,
            &std.mem.toBytes(@as(c_int, 1)),
        );

        const servers = std.StringHashMap(Server).init(allocator);

        return ServerScanner{
            .allocator = allocator,
            .sockfd = sockfd,
            .servers = servers,
        };
    }

    pub const ScanError = error{
        IllegalReceiveWindow,
    } || std.mem.Allocator.Error || std.posix.SetSockOptError || std.posix.SendToError || std.posix.RecvFromError;

    pub const ScanOptions = struct {
        receive_window_ms: u32 = 1_000,
    };

    pub fn scan(self: *ServerScanner, opts: ScanOptions) ScanError!void {
        const sec = std.math.divFloor(u32, opts.receive_window_ms, 1_000) catch {
            return ScanError.IllegalReceiveWindow;
        };
        const usec = 1_000 * (std.math.rem(u32, opts.receive_window_ms, 1_000) catch {
            return ScanError.IllegalReceiveWindow;
        });

        const timeout = std.posix.timeval{ .sec = sec, .usec = usec };
        try std.posix.setsockopt(
            self.sockfd,
            std.posix.SOL.SOCKET,
            std.posix.SO.RCVTIMEO,
            &std.mem.toBytes(timeout),
        );

        _ = try std.posix.sendto(
            self.sockfd,
            sood.discovery.Query.prebuilt,
            0,
            &dst.any,
            dst.getOsSockLen(),
        );

        // Discovery response from servers usually fits under 300 bytes.
        // Extra bytes for safety.
        var received: [512]u8 = undefined;
        var src: std.net.Address = undefined;
        var src_len: std.posix.socklen_t = dst.getOsSockLen();
        while (true) {
            if (std.posix.recvfrom(self.sockfd, &received, 0, &src.any, &src_len)) |received_size| {
                const response = sood.discovery.Response.parse(received[0..received_size]) catch {
                    // Non-SOOD message. Unlikely but technically possible.
                    continue;
                };

                const stale = self.servers.get(response.unique_id);
                defer if (stale) |server| {
                    server.deinit(self.allocator);
                };

                var ip_addr = src;
                ip_addr.setPort(response.http_port);

                const new = Server{
                    .unique_id = response.unique_id,
                    .version = response.display_version,
                    .name = response.name,
                    .ip_addr = ip_addr,
                };

                // Server's fields point to `received` buffer, which invalidates every UDP receive.
                // We have to copy the slices.
                const entry = try new.clone(self.allocator);
                errdefer entry.deinit(self.allocator);

                try self.servers.put(response.unique_id, entry);
            } else |err| switch (err) {
                std.posix.RecvFromError.WouldBlock => return,
                std.posix.RecvFromError.MessageTooBig => continue,
                else => return err,
            }
        }
    }

    pub fn deinit(self: *ServerScanner) void {
        var iter = self.servers.iterator();
        while (iter.next()) |server| {
            server.value_ptr.deinit(self.allocator);
        }

        self.servers.deinit();
        std.posix.close(self.sockfd);
        self.* = undefined;
    }
};