Added basic end2end tests

lib/ShortDev.Microsoft.ConnectedDevices/EndpointInfo.cs

@@ -23,13 +23,13 @@ public IPEndPoint ToIPEndPoint()
     }
 
     public static EndpointInfo FromTcp(IPEndPoint endpoint)
-        => FromTcp(endpoint.Address);
+        => FromTcp(endpoint.Address, endpoint.Port);
 
-    public static EndpointInfo FromTcp(IPAddress address)
-    => FromTcp(address.ToString());
+    public static EndpointInfo FromTcp(IPAddress address, int port = Constants.TcpPort)
+    => FromTcp(address.ToString(), port);
 
-    public static EndpointInfo FromTcp(string address)
-        => new(CdpTransportType.Tcp, address, Constants.TcpPort.ToString());
+    public static EndpointInfo FromTcp(string address, int port = Constants.TcpPort)
+        => new(CdpTransportType.Tcp, address, port.ToString());
 
     public static EndpointInfo FromRfcommDevice(PhysicalAddress macAddress)
         => new(CdpTransportType.Rfcomm, macAddress.ToStringFormatted(), Constants.RfcommServiceId);

lib/ShortDev.Microsoft.ConnectedDevices/Session/Upgrade/HostUpgradeHandler.cs

@@ -95,8 +95,9 @@ void HandleUpgradeRequest(CdpSocket socket, ref EndianReader reader)
             Type = MessageType.Connect
         };
 
-        var localIp = _session.Platform.TryGetTransport<NetworkTransport>()?.Handler.TryGetLocalIp();
-        if (localIp == null)
+        var networkTransport = _session.Platform.TryGetTransport<NetworkTransport>();
+        var localIp = networkTransport?.Handler.TryGetLocalIp();
+        if (networkTransport == null || localIp == null)
         {
             EndianWriter writer = new(Endianness.BigEndian);
             new ConnectionHeader()
@@ -126,7 +127,7 @@ void HandleUpgradeRequest(CdpSocket socket, ref EndianReader reader)
             {
                 Endpoints =
                 [
-                    EndpointInfo.FromTcp(localIp)
+                    EndpointInfo.FromTcp(localIp, networkTransport.TcpPort)
                 ],
                 MetaData =
                 [

lib/ShortDev.Microsoft.ConnectedDevices/Transports/Network/NetworkTransport.cs

@@ -6,25 +6,32 @@
 
 namespace ShortDev.Microsoft.ConnectedDevices.Transports.Network;
 
-public sealed class NetworkTransport(INetworkHandler handler) : ICdpTransport, ICdpDiscoverableTransport
+public sealed class NetworkTransport(
+    INetworkHandler handler,
+    int tcpPort = Constants.TcpPort, int udpPort = Constants.UdpPort
+) : ICdpTransport, ICdpDiscoverableTransport
 {
-    readonly TcpListener _listener = new(IPAddress.Any, Constants.TcpPort);
+    public int TcpPort { get; } = tcpPort;
+    public int UdpPort { get; } = udpPort;
+
+    TcpListener? _listener;
     public INetworkHandler Handler { get; } = handler;
 
     public CdpTransportType TransportType { get; } = CdpTransportType.Tcp;
     public EndpointInfo GetEndpoint()
-        => new(TransportType, Handler.GetLocalIp().ToString(), Constants.TcpPort.ToString(CultureInfo.InvariantCulture));
+        => new(TransportType, Handler.GetLocalIp().ToString(), TcpPort.ToString(CultureInfo.InvariantCulture));
 
     public event DeviceConnectedEventHandler? DeviceConnected;
     public async Task Listen(CancellationToken cancellationToken)
     {
-        _listener.Start();
+        var listener = _listener ??= new(IPAddress.Any, TcpPort);
+        listener.Start();
 
         try
         {
             while (!cancellationToken.IsCancellationRequested)
             {
-                var client = await _listener.AcceptTcpClientAsync(cancellationToken).ConfigureAwait(false);
+                var client = await listener.AcceptTcpClientAsync(cancellationToken).ConfigureAwait(false);
 
                 if (client.Client.RemoteEndPoint is not IPEndPoint endPoint)
                     return;
@@ -39,7 +46,7 @@ public async Task Listen(CancellationToken cancellationToken)
                     Endpoint = new EndpointInfo(
                         TransportType,
                         endPoint.Address.ToString(),
-                        Constants.TcpPort.ToString(CultureInfo.InvariantCulture)
+                        TcpPort.ToString(CultureInfo.InvariantCulture)
                     )
                 });
             }
@@ -65,10 +72,26 @@ public async Task<CdpSocket> ConnectAsync(EndpointInfo endpoint)
 
     #region Discovery (Udp)
 
-    readonly UdpClient _udpclient = new(Constants.UdpPort)
+    readonly UdpClient _udpclient = CreateUdpClient(udpPort);
+
+    static UdpClient CreateUdpClient(int port)
     {
-        EnableBroadcast = true
-    };
+        UdpClient client = new()
+        {
+            EnableBroadcast = true
+        };
+
+        if (OperatingSystem.IsWindows())
+        {
+            const int SIO_UDP_CONNRESET = -1744830452;
+            client.Client.IOControl(SIO_UDP_CONNRESET, [0, 0, 0, 0], null);
+        }
+
+        client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+        client.Client.Bind(new IPEndPoint(IPAddress.Any, port));
+
+        return client;
+    }
 
     public async Task Advertise(LocalDeviceInfo deviceInfo, CancellationToken cancellationToken)
     {
@@ -194,7 +217,7 @@ void SendPresenceRequest()
             Type = DiscoveryType.PresenceRequest
         }.Write(payloadWriter);
 
-        new UdpFragmentSender(_udpclient, new IPEndPoint(IPAddress.Broadcast, Constants.UdpPort))
+        new UdpFragmentSender(_udpclient, new IPEndPoint(IPAddress.Broadcast, UdpPort))
             .SendMessage(header, payloadWriter.Buffer.AsSpan());
     }
 
@@ -212,7 +235,7 @@ void SendPresenceResponse(IPAddress device, PresenceResponse response)
         }.Write(payloadWriter);
         response.Write(payloadWriter);
 
-        new UdpFragmentSender(_udpclient, new IPEndPoint(device, Constants.UdpPort))
+        new UdpFragmentSender(_udpclient, new IPEndPoint(device, UdpPort))
             .SendMessage(header, payloadWriter.Buffer.AsSpan());
     }
 
@@ -228,7 +251,7 @@ public void Dispose()
         DeviceDiscovered = null;
         DiscoveryMessageReceived = null;
 
-        _listener.Dispose();
+        _listener?.Dispose();
         _udpclient.Dispose();
     }
 }

tests/ShortDev.Microsoft.ConnectedDevices.Test/E2E/BluetoothHandler.cs

@@ -0,0 +1,84 @@
+using ShortDev.Microsoft.ConnectedDevices.Transports;
+using ShortDev.Microsoft.ConnectedDevices.Transports.Bluetooth;
+using System.IO.Pipes;
+using System.Net.NetworkInformation;
+
+namespace ShortDev.Microsoft.ConnectedDevices.Test.E2E;
+
+internal sealed class BluetoothHandler(DeviceContainer container, DeviceContainer.Device device) : IBluetoothHandler
+{
+    public PhysicalAddress MacAddress => PhysicalAddress.Parse(device.Address);
+
+    public Task<CdpSocket> ConnectRfcommAsync(EndpointInfo endpoint, RfcommOptions options, CancellationToken cancellationToken = default)
+    {
+        var device = container.FindDevice(endpoint.Address)
+            ?? throw new KeyNotFoundException("Could not find device");
+
+        return Task.FromResult(
+            device.ConnectFrom(new(CdpTransportType.Rfcomm, device.Address, options.ServiceId ?? ""))
+        );
+    }
+
+    public async Task ListenRfcommAsync(RfcommOptions options, CancellationToken cancellationToken = default)
+    {
+        device.ConnectionRequest += OnNewConnection;
+
+        await cancellationToken.AwaitCancellation();
+
+        device.ConnectionRequest -= OnNewConnection;
+
+        void OnNewConnection(EndpointInfo client, ref (Stream Input, Stream Output)? clientStream)
+        {
+            AnonymousPipeServerStream serverInputStream = new(PipeDirection.In);
+            AnonymousPipeServerStream serverOutputStream = new(PipeDirection.Out);
+
+            // Accept connection
+            clientStream = (
+                new AnonymousPipeClientStream(PipeDirection.In, serverOutputStream.GetClientHandleAsString()),
+                new AnonymousPipeClientStream(PipeDirection.Out, serverInputStream.GetClientHandleAsString())
+            );
+
+            options.SocketConnected?.Invoke(new CdpSocket()
+            {
+                InputStream = serverInputStream,
+                OutputStream = serverOutputStream,
+                Endpoint = client,
+                Close = () =>
+                {
+                    serverInputStream.Dispose();
+                    serverOutputStream.Dispose();
+                }
+            });
+        }
+    }
+
+    public async Task AdvertiseBLeBeaconAsync(AdvertiseOptions options, CancellationToken cancellationToken = default)
+    {
+        var data = options.BeaconData.ToArray();
+        container.Advertise(device, (uint)options.ManufacturerId, data);
+
+        await cancellationToken.AwaitCancellation();
+
+        container.TryRemove(device);
+    }
+
+    public async Task ScanBLeAsync(ScanOptions scanOptions, CancellationToken cancellationToken = default)
+    {
+        container.FoundDevice += OnNewDevice;
+
+        await cancellationToken.AwaitCancellation();
+
+        container.FoundDevice -= OnNewDevice;
+
+        void OnNewDevice(DeviceContainer.Device device, DeviceContainer.Adverstisement ad)
+        {
+            if (ad.Manufacturer != Constants.BLeBeaconManufacturerId)
+                return;
+
+            if (!BLeBeacon.TryParse(ad.Data.ToArray(), out var beaconData))
+                return;
+
+            scanOptions.OnDeviceDiscovered?.Invoke(beaconData);
+        }
+    }
+}

tests/ShortDev.Microsoft.ConnectedDevices.Test/E2E/DeviceContainer.cs

@@ -0,0 +1,57 @@
+using ShortDev.Microsoft.ConnectedDevices.Transports;
+using System.Collections.Concurrent;
+
+namespace ShortDev.Microsoft.ConnectedDevices.Test.E2E;
+
+internal sealed class DeviceContainer
+{
+    readonly ConcurrentDictionary<Device, List<Adverstisement>> _registry = [];
+    sealed record Entry(Device Device, List<Adverstisement> Adverstisements);
+
+    public Device? FindDevice(string address)
+        => _registry.FirstOrDefault(x => x.Key.Address == address).Key;
+
+    public void Advertise(Device device, uint manufacturer, ReadOnlyMemory<byte> data)
+    {
+        var list = _registry.GetOrAdd(device, static key => []);
+        lock (list)
+        {
+            list.Add(new(manufacturer, data));
+        }
+        FoundDevice?.Invoke(device, new(manufacturer, data));
+    }
+
+    public bool TryRemove(Device device)
+        => _registry.Remove(device, out _);
+
+    public event Action<Device, Adverstisement>? FoundDevice;
+
+    public sealed record Adverstisement(uint Manufacturer, ReadOnlyMemory<byte> Data);
+    public sealed record Device(CdpTransportType TransportType, string Address)
+    {
+        public CdpSocket ConnectFrom(EndpointInfo client)
+        {
+            (Stream Input, Stream Output)? stream = null;
+            ConnectionRequest?.Invoke(client, ref stream);
+
+            if (stream is null)
+                throw new InvalidOperationException("Server did not accept");
+
+            return new CdpSocket()
+            {
+                InputStream = stream.Value.Input,
+                OutputStream = stream.Value.Output,
+                Endpoint = new(TransportType, Address, "Some Service Id"),
+                Close = () =>
+                {
+                    stream.Value.Input.Dispose();
+                    stream.Value.Output.Dispose();
+                }
+            };
+        }
+
+        public event ConnectionRequestHandler? ConnectionRequest;
+
+        public delegate void ConnectionRequestHandler(EndpointInfo client, ref (Stream Input, Stream Output)? stream);
+    }
+}