116 lines
3.6 KiB
C#
116 lines
3.6 KiB
C#
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
|
|
namespace WirelessTextSyncer.Windows.Services;
|
|
|
|
public sealed class DiscoveryResponderService : IDisposable
|
|
{
|
|
public const int DiscoveryPort = 8182;
|
|
public const string DiscoveryRequestType = "wirelessTextSyncer.discovery";
|
|
public const string ServiceResponseType = "wirelessTextSyncer.service";
|
|
|
|
private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
|
|
private readonly Func<string> hostProvider;
|
|
private readonly Func<int> portProvider;
|
|
private readonly string deviceName;
|
|
private readonly CancellationTokenSource cancellation = new();
|
|
private UdpClient? udpClient;
|
|
private Task? listenTask;
|
|
|
|
public DiscoveryResponderService(Func<string> hostProvider, Func<int> portProvider, string? deviceName = null)
|
|
{
|
|
this.hostProvider = hostProvider;
|
|
this.portProvider = portProvider;
|
|
this.deviceName = string.IsNullOrWhiteSpace(deviceName) ? Environment.MachineName : deviceName;
|
|
}
|
|
|
|
public void Start()
|
|
{
|
|
if (udpClient is not null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
udpClient = new UdpClient(AddressFamily.InterNetwork);
|
|
udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
|
|
udpClient.EnableBroadcast = true;
|
|
udpClient.Client.Bind(new IPEndPoint(IPAddress.Any, DiscoveryPort));
|
|
listenTask = Task.Run(ListenAsync);
|
|
AppLogger.Info($"Discovery responder listening on UDP {DiscoveryPort}.");
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
cancellation.Cancel();
|
|
udpClient?.Dispose();
|
|
|
|
try
|
|
{
|
|
listenTask?.Wait(TimeSpan.FromSeconds(1));
|
|
}
|
|
catch (AggregateException)
|
|
{
|
|
}
|
|
|
|
cancellation.Dispose();
|
|
}
|
|
|
|
public string BuildResponseJson()
|
|
{
|
|
return JsonSerializer.Serialize(
|
|
new DiscoveryResponse(ServiceResponseType, 1, deviceName, hostProvider(), portProvider()),
|
|
JsonOptions);
|
|
}
|
|
|
|
private async Task ListenAsync()
|
|
{
|
|
var token = cancellation.Token;
|
|
while (!token.IsCancellationRequested && udpClient is not null)
|
|
{
|
|
try
|
|
{
|
|
var result = await udpClient.ReceiveAsync(token);
|
|
if (!IsDiscoveryRequest(result.Buffer))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var responseBytes = Encoding.UTF8.GetBytes(BuildResponseJson());
|
|
await udpClient.SendAsync(responseBytes, result.RemoteEndPoint, token);
|
|
AppLogger.Info($"Answered discovery request from {result.RemoteEndPoint}.");
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
break;
|
|
}
|
|
catch (ObjectDisposedException)
|
|
{
|
|
break;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
AppLogger.Error("Discovery responder failed to process a packet.", exception);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool IsDiscoveryRequest(byte[] bytes)
|
|
{
|
|
try
|
|
{
|
|
var request = JsonSerializer.Deserialize<DiscoveryRequest>(bytes, JsonOptions);
|
|
return request?.Type == DiscoveryRequestType && request.Version == 1;
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private sealed record DiscoveryRequest(string Type, int Version);
|
|
|
|
private sealed record DiscoveryResponse(string Type, int Version, string Name, string Host, int Port);
|
|
}
|