/gtk-adwaita/src/core/discovery.zig at f8d353fc96fb7d58c9f3af2e9f19467264863df8

// 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 sood = @import("sood");

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

const udp_send_tries = 4;
const udp_receive_window_ms = 1300;

pub const Server = extern struct {
    internal: *Internal,

    pub const Internal = struct {
        id: [:0]const u8,
        name: [:0]const u8,
        version: [:0]const u8,
        address: std.net.Address,

        ref_count: i64 = 1,
    };

    pub fn make(resp: *const sood.discovery.Response, addr: *const std.net.Address) !*Server {
        const allocator = std.heap.c_allocator;

        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 address = addr.*;
        address.setPort(resp.http_port);

        internal.* = .{
            .id = id,
            .name = name,
            .version = version,
            .address = address,
        };

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

        return self;
    }

    pub fn retain(ptr: ?*Server) callconv(.C) *Server {
        var self = ptr orelse @panic("Received null pointer on Server.retain");
        self.internal.ref_count += 1;
        return self;
    }

    pub fn release(ptr: ?*Server) callconv(.C) void {
        var self = ptr orelse @panic("Received null pointer on Server.release");

        self.internal.ref_count -= 1;

        if (self.internal.ref_count == 0) {
            std.log.debug("Releasing {*}...", .{self});
            const allocator = std.heap.c_allocator;

            allocator.free(self.internal.id);
            allocator.free(self.internal.name);
            allocator.free(self.internal.version);
            allocator.destroy(self.internal);
            allocator.destroy(self);
        } else if (self.internal.ref_count < 0) {
            std.log.warn("Over deref detected {*}, count={d}", .{ self, self.internal.ref_count });
        }
    }

    pub fn getId(ptr: ?*const Server) callconv(.C) [*:0]const u8 {
        const self = ptr orelse @panic("Received null pointer on Server.id");

        return self.internal.id.ptr;
    }

    pub fn getName(ptr: ?*const Server) callconv(.C) [*:0]const u8 {
        const self = ptr orelse @panic("Received null pointer on Server.name");

        return self.internal.name.ptr;
    }

    pub fn getVersion(ptr: ?*const Server) callconv(.C) [*:0]const u8 {
        const self = ptr orelse @panic("Received null pointer on Server.version");

        return self.internal.version.ptr;
    }

    pub fn getHttpPort(ptr: ?*const Server) callconv(.C) u16 {
        const self = ptr orelse @panic("Received null pointer on Server.httpPort");

        return self.internal.address.getPort();
    }
};

pub const ScanResult = extern struct {
    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 {
        servers: []*Server = &.{},

        ref_count: i64 = 1,
    };

    pub fn make() !*ScanResult {
        const allocator = std.heap.c_allocator;

        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 setServers(self: *ScanResult, input: *const std.StringHashMap(*Server)) !void {
        const allocator = std.heap.c_allocator;

        const servers = try allocator.alloc(*Server, input.count());

        var i: usize = 0;
        var iter = input.valueIterator();
        while (iter.next()) |server| {
            std.log.debug("Found server ({s})", .{server.*.getName()});
            servers[i] = server.*;
            i += 1;
        }

        self.internal.servers = servers;
        self.servers_ptr = servers.ptr;
        self.servers_len = servers.len;
    }

    pub fn retain(ptr: ?*ScanResult) callconv(.C) *ScanResult {
        var self = ptr orelse @panic("Received null pointer on ScanResult.retain");
        self.internal.ref_count += 1;
        return self;
    }

    pub fn release(ptr: ?*ScanResult) callconv(.C) void {
        var self = ptr orelse @panic("Received null pointer on ScanResult.release");

        self.internal.ref_count -= 1;

        if (self.internal.ref_count == 0) {
            std.log.debug("Releasing {*}...", .{self});
            const allocator = std.heap.c_allocator;

            for (self.internal.servers) |server| {
                server.release();
            }
            allocator.free(self.internal.servers);
            allocator.destroy(self.internal);
            allocator.destroy(self);
        } else if (self.internal.ref_count < 0) {
            std.log.warn("Over deref detected {*}, count={d}", .{ self, self.internal.ref_count });
        }
    }
};

pub fn scan() callconv(.C) ?*ScanResult {
    const result = ScanResult.make() catch {
        return null;
    };

    var arena = std.heap.ArenaAllocator.init(std.heap.c_allocator);
    defer arena.deinit();

    scanInternal(arena.allocator(), result) catch |err| {
        result.code = switch (err) {
            error.OutOfMemory => .out_of_memory,
            ScanError.NetworkUnavailable => .network_unavailable,
            ScanError.SocketPermissionDenied => .socket_permission_denied,
            ScanError.SocketError => .socket_error,
        };
    };

    return result;
}

const ScanError = error{
    NetworkUnavailable,
    SocketPermissionDenied,
    SocketError,
} || std.mem.Allocator.Error;

fn scanInternal(allocator: std.mem.Allocator, result: *ScanResult) !void {
    const sockfd = try createSocket();
    defer std.posix.close(sockfd);

    var servers = std.StringHashMap(*Server).init(allocator);
    errdefer servers.deinit();

    for (0..udp_send_tries) |_| {
        try sendDiscoveryQuery(sockfd);

        while (true) {
            std.log.debug("Waiting for UDP message...", .{});

            // 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 = udp_dst.getOsSockLen();

            const size = std.posix.recvfrom(
                sockfd,
                &received,
                0,
                &src.any,
                &src_len,
            ) catch |err| switch (err) {
                std.posix.RecvFromError.WouldBlock => {
                    std.log.debug("UDP read timeout.", .{});
                    break;
                },
                std.posix.RecvFromError.MessageTooBig => {
                    std.log.warn("Unable to read UDP message (message too big)", .{});
                    continue;
                },
                else => return ScanError.SocketError,
            };

            std.log.debug("Got UDP message.", .{});

            const response = sood.discovery.Response.parse(received[0..size]) catch |err| {
                std.log.warn(
                    "Unable to parse received UDP message as SOOD message: {s}",
                    .{@errorName(err)},
                );
                // Non-SOOD message. Unlikely but technically possible.
                continue;
            };

            const stale = servers.getPtr(response.unique_id);
            defer if (stale) |server| {
                server.*.release();
            };

            var server = try Server.make(&response, &src);
            errdefer server.release();
            try servers.put(server.internal.id, server);
        }
    }

    try result.setServers(&servers);
    result.code = .ok;
}

fn createSocket() !std.posix.socket_t {
    std.log.debug("Opening UDP socket...", .{});
    const sockfd = std.posix.socket(std.posix.AF.INET, std.posix.SOCK.DGRAM, 0) catch |err| {
        return switch (err) {
            std.posix.SocketError.PermissionDenied => ScanError.SocketPermissionDenied,
            std.posix.SocketError.SystemResources => ScanError.OutOfMemory,
            else => ScanError.SocketError,
        };
    };
    errdefer std.posix.close(sockfd);

    std.posix.setsockopt(
        sockfd,
        std.posix.SOL.SOCKET,
        std.posix.SO.REUSEADDR,
        &std.mem.toBytes(@as(c_int, 1)),
    ) catch |err| return switch (err) {
        std.posix.SetSockOptError.PermissionDenied => ScanError.SocketPermissionDenied,
        std.posix.SetSockOptError.SystemResources => ScanError.OutOfMemory,
        else => ScanError.SocketError,
    };

    const sec = comptime std.math.divFloor(u32, udp_receive_window_ms, 1_000) catch |err| {
        @compileError(
            std.fmt.comptimePrint(
                "Cannot divide udp_receive_window_ms ({d}) by 1,000: {s}",
                .{ udp_receive_window_ms, @errorName(err) },
            ),
        );
    };
    const usec = comptime usec: {
        break :usec @min(
            std.math.maxInt(i32),
            1_000 * (std.math.rem(u32, udp_receive_window_ms, 1_000) catch |err| {
                @compileError(
                    std.fmt.comptimePrint(
                        "Cannot get reminder of udp_receive_window_ms ({d}): {s}",
                        .{ udp_receive_window_ms, @errorName(err) },
                    ),
                );
            }),
        );
    };

    std.log.debug("Setting UDP read timeout to {d}ms ({d}sec, {d}usec)", .{
        udp_receive_window_ms,
        sec,
        usec,
    });

    const timeout = std.posix.timeval{ .sec = sec, .usec = usec };
    std.posix.setsockopt(
        sockfd,
        std.posix.SOL.SOCKET,
        std.posix.SO.RCVTIMEO,
        &std.mem.toBytes(timeout),
    ) catch |err| return switch (err) {
        std.posix.SetSockOptError.PermissionDenied => ScanError.SocketPermissionDenied,
        std.posix.SetSockOptError.SystemResources => ScanError.OutOfMemory,
        else => ScanError.SocketError,
    };

    return sockfd;
}

fn sendDiscoveryQuery(sockfd: std.posix.socket_t) !void {
    std.log.debug("Sending server discovery message to {}", .{udp_dst});

    _ = std.posix.sendto(
        sockfd,
        sood.discovery.Query.prebuilt,
        0,
        &udp_dst.any,
        udp_dst.getOsSockLen(),
    ) catch |err| {
        std.log.err("Failed to send discovery message: {s}", .{@errorName(err)});
        return switch (err) {
            std.posix.SendToError.NetworkSubsystemFailed,
            std.posix.SendToError.NetworkUnreachable,
            => ScanError.NetworkUnavailable,
            else => ScanError.SocketError,
        };
    };
}