/src/Plac/ServerScanner.vala at 417fbfc723dce4d626c7b3bba87aac86a05a7e17

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

namespace Plac {
	public class ServerScanner : Object {
		/**
		 * Found a server.
		 *
		 * ServerScanner emits this signal everytime server returned discovery response:
		 * if a server A returned a response at t1 then returned again at t2, ServerScanner
		 * emits this signal twice (t1 and t2.)
		 */
		public signal void found(Server server);

		/**
		 * Scan has been aborted due to a socket error.
		 */
		public signal void scan_failed(GLib.Error error);

		private GLib.Cancellable? cancellable = null;

		public int64 read_timeout_us = 1000 * 1000 * 2;

		public ServerScanner() {
			Object();
		}

		public void start() {
			GLib.log("Plac", LEVEL_DEBUG, "Starting server scanner...");

			cancellable = new GLib.Cancellable();

			new GLib.Thread<void>("plac-server-scanner", () => {
				try {
					var socket = new GLib.Socket(IPV4, DATAGRAM, UDP);

					socket.set_timeout(3);

					// These connection address is hard-coded in Roon Node.js SDK.
					var inet_addr = new GLib.InetAddress.from_bytes({ 239, 255, 90, 90 }, IPV4);
					var sock_addr = new GLib.InetSocketAddress(inet_addr, 9003);

					while (true) {
						try {
							socket.send_to(sock_addr, (uint8[]) Sood.discovery_query, cancellable);

							GLib.log("Plac", LEVEL_DEBUG, "Sent discovery query");
						} catch (GLib.Error error) {
							if (error is GLib.IOError.CANCELLED) {
								return;
							}

							GLib.log("Plac", LEVEL_CRITICAL, "Failed to send discovery query: %s", error.message);

							var e = error.copy();
							GLib.Idle.add(() => {
								scan_failed(e);
								return false;
							});
							cancellable = null;
							return;
						}

						while (true) {
							try {
								GLib.SocketAddress addr;
								var bytes = socket.receive_bytes_from(out addr, 512, read_timeout_us, cancellable);

								if (!(addr is GLib.InetSocketAddress)) {
									GLib.log("Plac", LEVEL_WARNING, "Received discovery response from non-IP socket");
									continue;
								}

								Sood.Message resp;
								try {
									resp = new Sood.Message.from_bytes(bytes);
								} catch (Sood.ParseError error) {
									GLib.log("Plac", LEVEL_WARNING, "Received malformed discovery response: %s", error.message);
									continue;
								}

								if (resp.properties["unique_id"] == null) {
									GLib.log("Plac", LEVEL_WARNING, "Discovery response does not contain unique_id property");
									continue;
								}

								if (resp.properties["display_version"] == null) {
									GLib.log("Plac", LEVEL_WARNING, "Discovery response does not contain display_version property");
									continue;
								}

								if (resp.properties["name"] == null) {
									GLib.log("Plac", LEVEL_WARNING, "Discovery response does not contain name property");
									continue;
								}

								if (resp.properties["http_port"] == null) {
									GLib.log("Plac", LEVEL_WARNING, "Discovery response does not contain http_port property");
									continue;
								}

								var http_port = resp.properties["http_port"].to_int();
								if (http_port < 0 || http_port > uint16.MAX) {
									GLib.log("Plac", LEVEL_WARNING, "Discovery response contains http_port value outside of 16bit uint");
									continue;
								}

								var server = new Server(
									(GLib.InetSocketAddress) addr,
									resp.properties["unique_id"],
									resp.properties["display_version"],
									resp.properties["name"],
									(uint16) http_port
								);

								GLib.Idle.add(() => {
									found(server);
									return false;
								});
							} catch (GLib.Error error) {
								if (error is GLib.IOError.TIMED_OUT) {
									break;
								}

								if (error is GLib.IOError.CANCELLED) {
									return;
								}

								GLib.log("Plac", LEVEL_CRITICAL, "Failed to read discovery response: %s", error.message);
								cancellable = null;

								var e = error.copy();
								GLib.Idle.add(() => {
									scan_failed(e);
									return false;
								});
								return;
							}
						}
					}
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_CRITICAL, "Discovery aborted due to an error: %s", error.message);

					var e = error.copy();
					GLib.Idle.add(() => {
						scan_failed(e);
						return false;
					});
				}

				cancellable = null;
			});
		}

		public void stop() {
			GLib.log("Plac", LEVEL_DEBUG, "Stopping server scanner...");
			cancellable.cancel();
		}
	}
}