Add tooling TCP/IP support to enable diagnostics on IOS/Android runtime platforms.

src/Microsoft.Diagnostics.NETCore.Client/DiagnosticsIpc/IpcAdvertise.cs

@@ -37,6 +37,8 @@ private IpcAdvertise(byte[] magic, Guid cookie, UInt64 pid, UInt16 future)
             RuntimeInstanceCookie = cookie;
         }
 
+        public static int V1SizeInBytes { get; } = IpcAdvertiseV1SizeInBytes;
+
         public static async Task<IpcAdvertise> ParseAsync(Stream stream, CancellationToken token)
         {
             byte[] buffer = new byte[IpcAdvertiseV1SizeInBytes];
@@ -78,6 +80,28 @@ public static async Task<IpcAdvertise> ParseAsync(Stream stream, CancellationTok
             return new IpcAdvertise(magic, cookie, pid, future);
         }
 
+        public static async Task SerializeAsync(Stream stream, Guid runtimeInstanceCookie, ulong processId, CancellationToken token)
+        {
+            int index = 0;
+            byte[] buffer = new byte[IpcAdvertiseV1SizeInBytes];
+
+            Array.Copy(Magic_V1, buffer, Magic_V1.Length);
+            index += Magic_V1.Length;
+
+            byte[] cookieBuffer = runtimeInstanceCookie.ToByteArray();
+            Array.Copy(cookieBuffer, 0, buffer, index, cookieBuffer.Length);
+            index += cookieBuffer.Length;
+
+            Array.Copy(BitConverter.GetBytes(processId), 0, buffer, index, sizeof(ulong));
+            index += sizeof(ulong);
+
+            short future = 0;
+            Array.Copy(BitConverter.GetBytes(future), 0, buffer, index, sizeof(short));
+            index += sizeof(short);
+
+            await stream.WriteAsync(buffer, 0, index).ConfigureAwait(false);
+        }
+
         public override string ToString()
         {
             return $"{{ Magic={Magic}; ClrInstanceId={RuntimeInstanceCookie}; ProcessId={ProcessId}; Future={Future} }}";

src/Microsoft.Diagnostics.NETCore.Client/DiagnosticsIpc/IpcServerTransport.cs

@@ -17,15 +17,22 @@ internal abstract class IpcServerTransport : IDisposable
         private IIpcServerTransportCallbackInternal _callback;
         private bool _disposed;
 
-        public static IpcServerTransport Create(string transportPath, int maxConnections)
+        public static IpcServerTransport Create(string address, int maxConnections, bool enableTcpIpProtocol)
         {
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            if (!enableTcpIpProtocol || !IpcTcpSocketTransport.TryParseIPAddress(address))
             {
-                return new WindowsPipeServerTransport(transportPath, maxConnections);
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    return new IpcWindowsNamedPipeServerTransport(address, maxConnections);
+                }
+                else
+                {
+                    return new IpcUnixDomainSocketServerTransport(address, maxConnections);
+                }
             }
             else
             {
-                return new UnixDomainSocketServerTransport(transportPath, maxConnections);
+                return new IpcTcpSocketServerTransport(address, maxConnections);
             }
         }
 
@@ -45,18 +52,10 @@ protected virtual void Dispose(bool disposing)
 
         public abstract Task<Stream> AcceptAsync(CancellationToken token);
 
-        public static int MaxAllowedConnections
-        {
+        public static int MaxAllowedConnections {
             get
             {
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    return NamedPipeServerStream.MaxAllowedServerInstances;
-                }
-                else
-                {
-                    return (int)SocketOptionName.MaxConnections;
-                }
+                return -1;
             }
         }
 
@@ -79,7 +78,7 @@ protected void OnCreateNewServer()
         }
     }
 
-    internal sealed class WindowsPipeServerTransport : IpcServerTransport
+    internal sealed class IpcWindowsNamedPipeServerTransport : IpcServerTransport
     {
         private const string PipePrefix = @"\\.\pipe\";
 
@@ -89,11 +88,11 @@ internal sealed class WindowsPipeServerTransport : IpcServerTransport
         private readonly string _pipeName;
         private readonly int _maxInstances;
 
-        public WindowsPipeServerTransport(string pipeName, int maxInstances)
+        public IpcWindowsNamedPipeServerTransport(string pipeName, int maxInstances)
         {
-            _maxInstances = maxInstances;
+            _maxInstances = maxInstances != MaxAllowedConnections ? maxInstances : NamedPipeServerStream.MaxAllowedServerInstances;
             _pipeName = pipeName.StartsWith(PipePrefix) ? pipeName.Substring(PipePrefix.Length) : pipeName;
-            CreateNewPipeServer();
+            _stream = CreateNewNamedPipeServer(_pipeName, _maxInstances);
         }
 
         protected override void Dispose(bool disposing)
@@ -113,50 +112,56 @@ public override async Task<Stream> AcceptAsync(CancellationToken token)
             VerifyNotDisposed();
 
             using var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, _cancellation.Token);
-
-            NamedPipeServerStream connectedStream;
             try
             {
+                // Connect client to named pipe server stream.
                 await _stream.WaitForConnectionAsync(linkedSource.Token).ConfigureAwait(false);
 
-                connectedStream = _stream;
+                // Transfer ownership of connected named pipe.
+                var connectedStream = _stream;
+
+                // Setup new named pipe server stream used in upcomming accept calls.
+                _stream = CreateNewNamedPipeServer(_pipeName, _maxInstances);
+
+                return connectedStream;
             }
-            finally
+            catch (Exception)
             {
-                if (!_cancellation.IsCancellationRequested)
+                // Keep named pipe server stream when getting any kind of cancel request.
+                // Cancel happens when complete transport is about to disposed or caller
+                // cancels out specific accept call, no need to recycle named pipe server stream.
+                // In all other exception scenarios named pipe server stream will be re-created.
+                if (!linkedSource.IsCancellationRequested)
                 {
-                    CreateNewPipeServer();
+                    _stream.Dispose();
+                    _stream = CreateNewNamedPipeServer(_pipeName, _maxInstances);
                 }
+                throw;
             }
-            return connectedStream;
         }
 
-        private void CreateNewPipeServer()
+        private NamedPipeServerStream CreateNewNamedPipeServer(string pipeName, int maxInstances)
         {
-            _stream = new NamedPipeServerStream(
-                _pipeName,
-                PipeDirection.InOut,
-                _maxInstances,
-                PipeTransmissionMode.Byte,
-                PipeOptions.Asynchronous);
+            var stream = new NamedPipeServerStream(pipeName, PipeDirection.InOut, maxInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
             OnCreateNewServer();
+            return stream;
         }
     }
 
-    internal sealed class UnixDomainSocketServerTransport : IpcServerTransport
+    internal abstract class IpcSocketServerTransport : IpcServerTransport
     {
         private readonly CancellationTokenSource _cancellation = new CancellationTokenSource();
         private readonly int _backlog;
-        private readonly string _path;
+        private readonly string _address;
 
-        private UnixDomainSocket _socket;
+        private IpcSocketTransport _socket;
 
-        public UnixDomainSocketServerTransport(string path, int backlog)
+        public IpcSocketServerTransport(string address, int backlog)
         {
             _backlog = backlog;
-            _path = path;
+            _address = address;
 
-            CreateNewSocketServer();
+            _socket = CreateNewSocketServer(_address, _backlog);
         }
 
         protected override void Dispose(bool disposing)
@@ -187,28 +192,83 @@ public override async Task<Stream> AcceptAsync(CancellationToken token)
             using var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, _cancellation.Token);
             try
             {
-                Socket socket = await _socket.AcceptAsync(linkedSource.Token).ConfigureAwait(false);
+                // Accept next client socket.
+                var socket = await _socket.AcceptAsync(linkedSource.Token).ConfigureAwait(false);
+
+                // Configure client socket based on transport type.
+                OnAccept(socket);
 
                 return new ExposedSocketNetworkStream(socket, ownsSocket: true);
             }
             catch (Exception)
             {
-                // Recreate socket if transport is not disposed.
-                if (!_cancellation.IsCancellationRequested)
+                // Keep server socket when getting any kind of cancel request.
+                // Cancel happens when complete transport is about to disposed or caller
+                // cancels out specific accept call, no need to recycle server socket.
+                // In all other exception scenarios server socket will be re-created.
+                if (!linkedSource.IsCancellationRequested)
                 {
-                    CreateNewSocketServer();
+                    _socket = CreateNewSocketServer(_address, _backlog);
                 }
                 throw;
             }
         }
 
-        private void CreateNewSocketServer()
+        internal abstract bool OnAccept(Socket socket);
+
+        internal abstract IpcSocketTransport CreateNewSocketServer(string address, int backlog);
+    }
+
+    internal sealed class IpcTcpSocketServerTransport : IpcSocketServerTransport
+{
+        public IpcTcpSocketServerTransport(string address, int backlog)
+            : base (address, backlog != MaxAllowedConnections ? backlog : 100)
+        {
+        }
+
+        internal override bool OnAccept(Socket socket)
+        {
+            socket.NoDelay = true;
+            return true;
+        }
+
+        internal override IpcSocketTransport CreateNewSocketServer(string address, int backlog)
+        {
+            string hostAddress;
+            int hostPort;
+
+            if (!IpcTcpSocketTransport.TryParseIPAddress(address, out hostAddress, out hostPort))
+                throw new ArgumentException(string.Format("Could not parse {0} into host, port", address));
+
+            var socket = IpcTcpSocketTransport.Create(hostAddress, hostPort);
+            socket.Bind();
+            socket.Listen(backlog);
+            socket.LingerState.Enabled = false;
+            OnCreateNewServer();
+            return socket;
+        }
+    }
+
+    internal sealed class IpcUnixDomainSocketServerTransport : IpcSocketServerTransport
+    {
+        public IpcUnixDomainSocketServerTransport(string path, int backlog)
+            : base (path, backlog != MaxAllowedConnections ? backlog : (int)SocketOptionName.MaxConnections)
+        {
+        }
+
+        internal override bool OnAccept(Socket socket)
+        {
+            return true;
+        }
+
+        internal override IpcSocketTransport CreateNewSocketServer(string address, int backlog)
         {
-            _socket = new UnixDomainSocket();
-            _socket.Bind(_path);
-            _socket.Listen(_backlog);
-            _socket.LingerState.Enabled = false;
+            var socket = IpcUnixDomainSocketTransport.Create(address);
+            socket.Bind();
+            socket.Listen(backlog);
+            socket.LingerState.Enabled = false;
             OnCreateNewServer();
+            return socket;
         }
     }
 

src/Microsoft.Diagnostics.NETCore.Client/DiagnosticsIpc/UnixDomainSocket.cs → src/Microsoft.Diagnostics.NETCore.Client/DiagnosticsIpc/IpcSocketTransport.cs

@@ -4,22 +4,21 @@
 
 using System;
 using System.Diagnostics;
-using System.IO;
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.Diagnostics.NETCore.Client
 {
-    internal sealed class UnixDomainSocket : Socket
+    internal class IpcSocketTransport : Socket
     {
-        private bool _ownsSocketFile;
-        private string _path;
+        EndPoint _address;
 
-        public UnixDomainSocket() :
-            base(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified)
+        public IpcSocketTransport(EndPoint address, SocketType type, ProtocolType protocol)
+            : base(address.AddressFamily, type, protocol)
         {
+            _address = address;
         }
 
         public async Task<Socket> AcceptAsync(CancellationToken token)
@@ -44,24 +43,18 @@ public async Task<Socket> AcceptAsync(CancellationToken token)
             }
         }
 
-        public void Bind(string path)
+        public virtual void Bind()
         {
-            Bind(CreateUnixDomainSocketEndPoint(path));
-
-            _ownsSocketFile = true;
-            _path = path;
+            Bind(_address);
         }
 
-        public void Connect(string path, TimeSpan timeout)
+        public virtual void Connect(TimeSpan timeout)
         {
-            IAsyncResult result = BeginConnect(CreateUnixDomainSocketEndPoint(path), null, null);
+            IAsyncResult result = BeginConnect(_address, null, null);
 
             if (result.AsyncWaitHandle.WaitOne(timeout))
             {
                 EndConnect(result);
-
-                _ownsSocketFile = false;
-                _path = path;
             }
             else
             {
@@ -70,15 +63,15 @@ public void Connect(string path, TimeSpan timeout)
             }
         }
 
-        public async Task ConnectAsync(string path, CancellationToken token)
+        public async Task ConnectAsync(CancellationToken token)
         {
             using (token.Register(() => Close(0)))
             {
                 try
                 {
                     Func<AsyncCallback, object, IAsyncResult> beginConnect = (callback, state) =>
                     {
-                        return BeginConnect(CreateUnixDomainSocketEndPoint(path), callback, state);
+                        return BeginConnect(_address, callback, state);
                     };
                     await Task.Factory.FromAsync(beginConnect, EndConnect, this).ConfigureAwait(false);
                 }
@@ -93,33 +86,5 @@ public async Task ConnectAsync(string path, CancellationToken token)
             }
         }
 
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                if (_ownsSocketFile && !string.IsNullOrEmpty(_path) && File.Exists(_path))
-                {
-                    File.Delete(_path);
-                }
-            }
-            base.Dispose(disposing);
-        }
-
-        private static EndPoint CreateUnixDomainSocketEndPoint(string path)
-        {
-#if NETCOREAPP
-            return new UnixDomainSocketEndPoint(path);
-#elif NETSTANDARD2_0
-            // UnixDomainSocketEndPoint is not part of .NET Standard 2.0
-            var type = typeof(Socket).Assembly.GetType("System.Net.Sockets.UnixDomainSocketEndPoint")
-                        ?? Type.GetType("System.Net.Sockets.UnixDomainSocketEndPoint, System.Core");
-            if (type == null)
-            {
-                throw new PlatformNotSupportedException("Current process is not running a compatible .NET runtime.");
-            }
-            var ctor = type.GetConstructor(new[] { typeof(string) });
-            return (EndPoint)ctor.Invoke(new object[] { path });
-#endif
-        }
     }
 }