/src/core/discovery.zig at 52424bbaa849773c854f56835731bea534c1db1d

// 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

const std = @import("std");

const moo = @import("moo");
const sood = @import("sood");
const websocket = @import("websocket");

const Arc = @import("./Arc.zig");
const freelog = @import("./log.zig").freelog;
const RegistryService = @import("./services/registry.zig").RegistryService;

pub const Server = extern struct {
    const cname = "plac_discovery_server";
    const allocator = std.heap.c_allocator;

    internal: *Internal,
    id: [*:0]const u8,
    name: [*:0]const u8,
    version: [*:0]const u8,
    ip_addr: [*:0]const u8,
    http_port: u16,

    pub const Internal = struct {
        address: std.net.Address,
        arc: Arc = .{},
    };

    pub fn make(resp: *const sood.discovery.Response, addr: *const std.net.Address) !*Server {
        const self = try allocator.create(Server);
        errdefer allocator.destroy(self);

        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        const id = try allocator.dupeZ(u8, resp.unique_id);
        errdefer allocator.free(id);

        const name = try allocator.dupeZ(u8, resp.name);
        errdefer allocator.free(name);

        const version = try allocator.dupeZ(u8, resp.display_version);
        errdefer allocator.free(version);

        var ip_addr_buf = std.ArrayList(u8).init(allocator);
        defer ip_addr_buf.deinit();

        try std.fmt.format(ip_addr_buf.writer(), "{}", .{addr});
        if (std.mem.lastIndexOfScalar(u8, ip_addr_buf.items, ':')) |last_colon| {
            ip_addr_buf.shrinkAndFree(last_colon);
        }

        const ip_addr = try allocator.dupeZ(u8, ip_addr_buf.items);
        errdefer allocator.free(ip_addr);

        var address = addr.*;
        address.setPort(resp.http_port);

        internal.* = .{
            .address = address,
        };

        self.* = .{
            .internal = internal,
            .id = id.ptr,
            .name = name.ptr,
            .version = version.ptr,
            .ip_addr = ip_addr.ptr,
            .http_port = resp.http_port,
        };

        return self;
    }

    fn init(
        id: [*:0]const u8,
        name: [*:0]const u8,
        version: [*:0]const u8,
        ip_addr: [*:0]const u8,
        http_port: u16,
    ) !*Server {
        const self = try allocator.create(Server);
        errdefer allocator.destroy(self);

        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        const id_copy = try allocator.dupeZ(u8, std.mem.span(id));
        errdefer allocator.free(id_copy);

        const name_copy = try allocator.dupeZ(u8, std.mem.span(name));
        errdefer allocator.free(name_copy);

        const version_copy = try allocator.dupeZ(u8, std.mem.span(version));
        errdefer allocator.free(version_copy);

        const ip_addr_slice = std.mem.span(ip_addr);

        const ip_addr_copy = try allocator.dupeZ(u8, ip_addr_slice);
        errdefer allocator.free(ip_addr_copy);

        const colon = std.mem.indexOfScalar(u8, ip_addr_slice, ':') orelse {
            return error.UnexpectedIpFormat;
        };

        const internal_addr = try std.net.Address.parseIp4(ip_addr_slice[0..colon], http_port);

        internal.* = .{
            .address = internal_addr,
        };

        self.* = .{
            .internal = internal,
            .id = id_copy.ptr,
            .name = name_copy.ptr,
            .version = version_copy.ptr,
            .ip_addr = ip_addr_copy.ptr,
            .http_port = http_port,
        };

        return self;
    }

    pub fn new(
        id: [*:0]const u8,
        name: [*:0]const u8,
        version: [*:0]const u8,
        ip_addr: [*:0]const u8,
        http_port: u16,
    ) callconv(.C) ?*Server {
        return init(id, name, version, ip_addr, http_port) catch |err| {
            std.log.err("Unable to construct Discovery.Server: {s}", .{@errorName(err)});
            return null;
        };
    }

    pub fn retain(ptr: ?*Server) callconv(.C) *Server {
        var self = ptr orelse @panic(std.fmt.comptimePrint(
            "Received null pointer on {s}_{s}",
            .{ cname, @src().fn_name },
        ));
        self.internal.arc.ref();
        return self;
    }

    pub fn release(ptr: ?*Server) callconv(.C) void {
        var self = ptr orelse @panic(std.fmt.comptimePrint(
            "Received null pointer on {s}_{s}",
            .{ cname, @src().fn_name },
        ));

        if (self.internal.arc.unref()) {
            freelog(self);

            allocator.free(std.mem.span(self.id));
            allocator.free(std.mem.span(self.name));
            allocator.free(std.mem.span(self.version));
            allocator.free(std.mem.span(self.ip_addr));
            allocator.destroy(self.internal);
            allocator.destroy(self);
        }
    }

    pub fn export_capi() void {
        @export(&retain, .{ .name = std.fmt.comptimePrint("{s}_retain", .{cname}) });
        @export(&release, .{ .name = std.fmt.comptimePrint("{s}_release", .{cname}) });
        @export(&new, .{ .name = std.fmt.comptimePrint("{s}_new", .{cname}) });
    }
};

pub const ScanResult = extern struct {
    const cname = "plac_discovery_scan_result";
    const allocator = std.heap.c_allocator;

    internal: *Internal,

    servers_ptr: [*]*Server,
    servers_len: usize,
    code: Code = .unknown,

    pub const Code = enum(c_int) {
        ok = 0,
        unknown = 1,
        network_unavailable = 2,
        socket_permission_denied = 3,
        socket_error = 4,
        out_of_memory = 5,
    };

    pub const Internal = struct {
        arc: Arc = .{},
    };

    pub fn make() !*ScanResult {
        const self = try allocator.create(ScanResult);
        errdefer allocator.destroy(self);

        const internal = try allocator.create(Internal);
        errdefer allocator.destroy(internal);

        const servers: []*Server = &.{};

        internal.* = .{};

        self.* = .{
            .internal = internal,
            .servers_ptr = servers.ptr,
            .servers_len = servers.len,
        };

        return self;
    }

    pub fn initFindResult(self: *ScanResult, found: *Server) std.mem.Allocator.Error!void {
        const servers = try allocator.alloc(*Server, 1);
        errdefer allocator.free(servers);

        servers[0] = found.retain();

        self.servers_ptr = servers.ptr;
        self.servers_len = 1;
        self.code = .ok;
    }

    pub fn retain(ptr: ?*ScanResult) callconv(.C) *ScanResult {
        var self = ptr orelse @panic(std.fmt.comptimePrint(
            "Received null pointer on {s}_{s}",
            .{ cname, @src().fn_name },
        ));
        self.internal.arc.ref();
        return self;
    }

    pub fn release(ptr: ?*ScanResult) callconv(.C) void {
        var self = ptr orelse @panic(std.fmt.comptimePrint(
            "Received null pointer on {s}_{s}",
            .{ cname, @src().fn_name },
        ));

        if (self.internal.arc.unref()) {
            freelog(self);

            const servers = self.servers_ptr[0..self.servers_len];
            for (servers) |server| {
                server.release();
            }
            allocator.free(servers);
            allocator.destroy(self.internal);
            allocator.destroy(self);
        }
    }

    pub fn export_capi() void {
        @export(&retain, .{ .name = std.fmt.comptimePrint("{s}_retain", .{cname}) });
        @export(&release, .{ .name = std.fmt.comptimePrint("{s}_release", .{cname}) });
    }
};

pub fn resolve(server_id: [*:0]const u8, ip_addr: [*:0]const u8, http_port: u16) callconv(.C) ?*ScanResult {
    var arena = std.heap.ArenaAllocator.init(std.heap.c_allocator);
    defer arena.deinit();

    const result = ScanResult.make() catch {
        return null;
    };

    const id = std.mem.span(server_id);
    const addr = std.mem.span(ip_addr);

    resolveInternal(arena.allocator(), id, addr, http_port, result) catch |err| {
        result.code = switch (err) {
            error.OutOfMemory => .out_of_memory,
            else => .unknown,
        };
    };

    return result.retain();
}

fn resolveInternal(
    allocator: std.mem.Allocator,
    server_id: []const u8,
    ip_addr: []const u8,
    http_port: u16,
    result: *ScanResult,
) !void {
    std.log.debug("Establishing WebSocket connection to {s}:{d}...", .{
        ip_addr, http_port,
    });

    var ws = try websocket.Client.init(allocator, .{
        .host = ip_addr,
        .port = http_port,
        .max_size = std.math.maxInt(u32),
    });
    defer ws.deinit();

    std.log.debug("Performing WebSocket handshake...", .{});
    ws.handshake("/api", .{ .timeout_ms = 1_000 }) catch |err| {
        std.log.warn("Failed to perform WebSocket handshake, fallback to scan: {s}", .{@errorName(err)});
        result.code = .ok;
        return;
    };

    std.log.debug("Requesting server info...", .{});

    {
        const req = try RegistryService.Info.request(allocator, 0);
        defer allocator.free(req);
        try ws.writeBin(req);
    }

    const msg = (try ws.read()) orelse {
        return error.ConnectionClosed;
    };
    defer ws.done(msg);

    _, const header_ctx = try moo.Metadata.parse(msg.data);
    const resp = try RegistryService.Info.response(allocator, header_ctx, msg.data);
    defer resp.deinit();

    if (!std.mem.eql(u8, server_id, resp.value.core_id)) {
        std.log.info(
            "Found Roon Server on saved IP address, got different server instance, fallback to scan: saved ID={s}, found ID={s}",
            .{
                server_id,
                resp.value.core_id,
            },
        );
        result.code = .ok;
        return;
    }

    const addr = try std.net.Address.parseIp4(ip_addr, http_port);

    const sood_resp = sood.discovery.Response{
        .display_version = resp.value.display_version,
        .name = resp.value.display_name,
        .unique_id = server_id,
        .http_port = http_port,
    };

    var server = try Server.make(&sood_resp, &addr);
    errdefer server.release();

    try result.initFindResult(server);
    return;
}

pub fn export_capi() void {
    Server.export_capi();
    ScanResult.export_capi();

    @export(&resolve, .{ .name = "plac_discovery_resolve" });
}