Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 771 insertions, 0 deletions

diff --git a/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/NullLogger.cs b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/NullLogger.cs
new file mode 100644
index 000000000..1f1f542d5
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/NullLogger.cs
@@ -0,0 +1,56 @@
+// Licensed to the Apache Software Foundation(ASF) under one
+// or more contributor license agreements.See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.The ASF licenses this file
+// to you 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.
+
+using Microsoft.Extensions.Logging;
+using System;
+
+
+namespace Thrift.Transport.Server
+{
+    // sometimes we just don't want to log anything
+    internal class NullLogger<T> : IDisposable, ILogger, ILogger<T>
+    {
+        internal class NullScope : IDisposable
+        {
+            public void Dispose()
+            {
+                // nothing to do
+            }
+        }
+
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            return new NullScope();
+        }
+
+        public void Dispose()
+        {
+            // nothing to do
+        }
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            return false;  // no
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            // do nothing
+        }
+    }
+}
+
diff --git a/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/THttpServerTransport.cs b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/THttpServerTransport.cs
new file mode 100644
index 000000000..056300cfe
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/THttpServerTransport.cs
@@ -0,0 +1,118 @@
+// Licensed to the Apache Software Foundation(ASF) under one
+// or more contributor license agreements.See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.The ASF licenses this file
+// to you 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.
+
+using System;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Thrift.Processor;
+using Thrift.Protocol;
+using Thrift.Transport.Client;
+
+namespace Thrift.Transport.Server
+{
+    // ReSharper disable once InconsistentNaming
+    public class THttpServerTransport
+    {
+        protected const string ContentType = "application/x-thrift";
+        private readonly ILogger _logger;
+        private readonly RequestDelegate _next;
+        protected Encoding Encoding = Encoding.UTF8;
+
+        protected TProtocolFactory InputProtocolFactory;
+        protected TProtocolFactory OutputProtocolFactory;
+
+        protected TTransportFactory InputTransportFactory;
+        protected TTransportFactory OutputTransportFactory;
+
+        protected ITAsyncProcessor Processor;
+
+        public THttpServerTransport(ITAsyncProcessor processor, RequestDelegate next = null, ILoggerFactory loggerFactory = null)
+            : this(processor, new TBinaryProtocol.Factory(), null, next, loggerFactory)
+        {
+        }
+
+        public THttpServerTransport(
+            ITAsyncProcessor processor, 
+            TProtocolFactory protocolFactory, 
+            TTransportFactory transFactory = null, 
+            RequestDelegate next = null,
+            ILoggerFactory loggerFactory = null)
+            : this(processor, protocolFactory, protocolFactory, transFactory, transFactory, next, loggerFactory)
+        {
+        }
+
+        public THttpServerTransport(
+            ITAsyncProcessor processor, 
+            TProtocolFactory inputProtocolFactory,
+            TProtocolFactory outputProtocolFactory,
+            TTransportFactory inputTransFactory = null,
+            TTransportFactory outputTransFactory = null,
+            RequestDelegate next = null, 
+            ILoggerFactory loggerFactory = null)
+        {
+            // loggerFactory == null is not illegal anymore
+
+            Processor = processor ?? throw new ArgumentNullException(nameof(processor));
+            InputProtocolFactory = inputProtocolFactory ?? throw new ArgumentNullException(nameof(inputProtocolFactory));
+            OutputProtocolFactory = outputProtocolFactory ?? throw new ArgumentNullException(nameof(outputProtocolFactory));
+
+            InputTransportFactory = inputTransFactory;
+            OutputTransportFactory = outputTransFactory;
+
+            _next = next;
+            _logger = (loggerFactory != null) ? loggerFactory.CreateLogger<THttpServerTransport>() : new NullLogger<THttpServerTransport>();
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            context.Response.ContentType = ContentType;
+            await ProcessRequestAsync(context, context.RequestAborted); //TODO: check for correct logic
+        }
+
+        public async Task ProcessRequestAsync(HttpContext context, CancellationToken cancellationToken)
+        {
+            var transport = new TStreamTransport(context.Request.Body, context.Response.Body);
+
+            try
+            {
+                var intrans = (InputTransportFactory != null) ? InputTransportFactory.GetTransport(transport) : transport;
+                var outtrans = (OutputTransportFactory != null) ? OutputTransportFactory.GetTransport(transport) : transport;
+
+                var input = InputProtocolFactory.GetProtocol(intrans);
+                var output = OutputProtocolFactory.GetProtocol(outtrans);
+
+                while (await Processor.ProcessAsync(input, output, cancellationToken))
+                {
+                    if (!context.Response.HasStarted)  // oneway method called
+                        await context.Response.Body.FlushAsync(cancellationToken);
+                }
+            }
+            catch (TTransportException)
+            {
+                if (!context.Response.HasStarted)  // if something goes bust, let the client know
+                    context.Response.StatusCode = 500;
+            }
+            finally
+            {
+                transport.Close();
+            }
+        }
+    }
+}
diff --git a/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TNamedPipeServerTransport.cs b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TNamedPipeServerTransport.cs
new file mode 100644
index 000000000..77b825143
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TNamedPipeServerTransport.cs
@@ -0,0 +1,308 @@
+// Licensed to the Apache Software Foundation(ASF) under one
+// or more contributor license agreements.See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.The ASF licenses this file
+// to you 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.
+
+using Microsoft.Win32.SafeHandles;
+using System;
+using System.IO.Pipes;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using System.ComponentModel;
+using System.Security.AccessControl;
+using System.Security.Principal;
+
+namespace Thrift.Transport.Server
+{
+    // ReSharper disable once InconsistentNaming
+    public class TNamedPipeServerTransport : TServerTransport
+    {
+        /// <summary>
+        ///     This is the address of the Pipe on the localhost.
+        /// </summary>
+        private readonly string _pipeAddress;
+        private bool _asyncMode = true;
+        private volatile bool _isPending = true;
+        private NamedPipeServerStream _stream = null;
+
+        public TNamedPipeServerTransport(string pipeAddress)
+        {
+            _pipeAddress = pipeAddress;
+        }
+
+        public override void Listen()
+        {
+            // nothing to do here
+        }
+
+        public override void Close()
+        {
+            if (_stream != null)
+            {
+                try
+                {
+                    if (_stream.IsConnected)
+                        _stream.Disconnect();
+                    _stream.Dispose();
+                }
+                finally
+                {
+                    _stream = null;
+                    _isPending = false;
+                }
+            }
+        }
+
+        public override bool IsClientPending()
+        {
+            return _isPending;
+        }
+
+        private void EnsurePipeInstance()
+        {
+            if (_stream == null)
+            {
+                const PipeDirection direction = PipeDirection.InOut;
+                const int maxconn = NamedPipeServerStream.MaxAllowedServerInstances;
+                const PipeTransmissionMode mode = PipeTransmissionMode.Byte;
+                const int inbuf = 4096;
+                const int outbuf = 4096;
+                var options = _asyncMode ? PipeOptions.Asynchronous : PipeOptions.None;
+
+
+                // TODO: "CreatePipeNative" ist only a workaround, and there are have basically two possible outcomes:
+                // - once NamedPipeServerStream() gets a CTOR that supports pipesec, remove CreatePipeNative()
+                // - if 31190 gets resolved before, use _stream.SetAccessControl(pipesec) instead of CreatePipeNative()
+                // EITHER WAY,
+                // - if CreatePipeNative() finally gets removed, also remove "allow unsafe code" from the project settings
+
+                try
+                {
+                    var handle = CreatePipeNative(_pipeAddress, inbuf, outbuf);
+                    if( (handle != null) && (!handle.IsInvalid))
+                        _stream = new NamedPipeServerStream(PipeDirection.InOut, _asyncMode, false, handle);
+                    else
+                        _stream = new NamedPipeServerStream(_pipeAddress, direction, maxconn, mode, options, inbuf, outbuf/*, pipesec*/);
+                }
+                catch (NotImplementedException) // Mono still does not support async, fallback to sync
+                {
+                    if (_asyncMode)
+                    {
+                        options &= (~PipeOptions.Asynchronous);
+                        _stream = new NamedPipeServerStream(_pipeAddress, direction, maxconn, mode, options, inbuf, outbuf);
+                        _asyncMode = false;
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+        }
+
+
+        #region CreatePipeNative workaround
+
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal class SECURITY_ATTRIBUTES
+        {
+            internal int nLength = 0;
+            internal IntPtr lpSecurityDescriptor = IntPtr.Zero;
+            internal int bInheritHandle = 0;
+        }
+
+
+        private const string Kernel32 = "kernel32.dll";
+
+        [DllImport(Kernel32, SetLastError = true)]
+        internal static extern IntPtr CreateNamedPipe(
+            string lpName, uint dwOpenMode, uint dwPipeMode,
+            uint nMaxInstances, uint nOutBufferSize, uint nInBufferSize, uint nDefaultTimeOut,
+            SECURITY_ATTRIBUTES pipeSecurityDescriptor
+            );
+
+
+
+        // Workaround: create the pipe via API call
+        // we have to do it this way, since NamedPipeServerStream() for netstd still lacks a few CTORs
+        // and _stream.SetAccessControl(pipesec); only keeps throwing ACCESS_DENIED errors at us
+        // References:
+        // - https://github.com/dotnet/corefx/issues/30170 (closed, continued in 31190)
+        // - https://github.com/dotnet/corefx/issues/31190 System.IO.Pipes.AccessControl package does not work
+        // - https://github.com/dotnet/corefx/issues/24040 NamedPipeServerStream: Provide support for WRITE_DAC
+        // - https://github.com/dotnet/corefx/issues/34400 Have a mechanism for lower privileged user to connect to a privileged user's pipe
+        private SafePipeHandle CreatePipeNative(string name, int inbuf, int outbuf)
+        {
+            if (Environment.OSVersion.Platform != PlatformID.Win32NT)
+                return null; // Windows only
+
+            var pinningHandle = new GCHandle();
+            try
+            {
+                // owner gets full access, everyone else read/write
+                var pipesec = new PipeSecurity();
+                using (var currentIdentity = WindowsIdentity.GetCurrent())
+                {
+                    var sidOwner = currentIdentity.Owner;
+                    var sidWorld = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
+
+                    pipesec.SetOwner(sidOwner);
+                    pipesec.AddAccessRule(new PipeAccessRule(sidOwner, PipeAccessRights.FullControl, AccessControlType.Allow));
+                    pipesec.AddAccessRule(new PipeAccessRule(sidWorld, PipeAccessRights.ReadWrite, AccessControlType.Allow));
+                }
+
+                // create a security descriptor and assign it to the security attribs
+                var secAttrs = new SECURITY_ATTRIBUTES();
+                byte[] sdBytes = pipesec.GetSecurityDescriptorBinaryForm();
+                pinningHandle = GCHandle.Alloc(sdBytes, GCHandleType.Pinned);
+                unsafe {
+                    fixed (byte* pSD = sdBytes) {
+                        secAttrs.lpSecurityDescriptor = (IntPtr)pSD;
+                    }
+                }
+
+                // a bunch of constants we will need shortly
+                const int PIPE_ACCESS_DUPLEX = 0x00000003;
+                const int FILE_FLAG_OVERLAPPED = 0x40000000;
+                const int WRITE_DAC = 0x00040000;
+                const int PIPE_TYPE_BYTE = 0x00000000;
+                const int PIPE_READMODE_BYTE = 0x00000000;
+                const int PIPE_UNLIMITED_INSTANCES = 255;
+
+                // create the pipe via API call
+                var rawHandle = CreateNamedPipe(
+                    @"\\.\pipe\" + name,
+                    PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | WRITE_DAC,
+                    PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
+                    PIPE_UNLIMITED_INSTANCES, (uint)inbuf, (uint)outbuf,
+                    5 * 1000,
+                    secAttrs
+                    );
+
+                // make a SafePipeHandle() from it
+                var handle = new SafePipeHandle(rawHandle, true);
+                if (handle.IsInvalid)
+                    throw new Win32Exception(Marshal.GetLastWin32Error());
+
+                // return it (to be packaged)
+                return handle;
+            }
+            finally
+            {
+                if (pinningHandle.IsAllocated)
+                    pinningHandle.Free();
+            }
+        }
+
+        #endregion
+
+        protected override async ValueTask<TTransport> AcceptImplementationAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                EnsurePipeInstance();
+
+                await _stream.WaitForConnectionAsync(cancellationToken);
+
+                var trans = new ServerTransport(_stream);
+                _stream = null; // pass ownership to ServerTransport
+
+                //_isPending = false;
+
+                return trans;
+            }
+            catch (TTransportException)
+            {
+                Close();
+                throw;
+            }
+            catch (Exception e)
+            {
+                Close();
+                throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message);
+            }
+        }
+
+        private class ServerTransport : TTransport
+        {
+            private readonly NamedPipeServerStream PipeStream;
+
+            public ServerTransport(NamedPipeServerStream stream)
+            {
+                PipeStream = stream;
+            }
+
+            public override bool IsOpen => PipeStream != null && PipeStream.IsConnected;
+
+            public override async Task OpenAsync(CancellationToken cancellationToken)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    await Task.FromCanceled(cancellationToken);
+                }
+            }
+
+            public override void Close()
+            {
+                PipeStream?.Dispose();
+            }
+
+            public override async ValueTask<int> ReadAsync(byte[] buffer, int offset, int length, CancellationToken cancellationToken)
+            {
+                if (PipeStream == null)
+                {
+                    throw new TTransportException(TTransportException.ExceptionType.NotOpen);
+                }
+
+                return await PipeStream.ReadAsync(buffer, offset, length, cancellationToken);
+            }
+
+            public override async Task WriteAsync(byte[] buffer, int offset, int length, CancellationToken cancellationToken)
+            {
+                if (PipeStream == null)
+                {
+                    throw new TTransportException(TTransportException.ExceptionType.NotOpen);
+                }
+
+                // if necessary, send the data in chunks
+                // there's a system limit around 0x10000 bytes that we hit otherwise
+                // MSDN: "Pipe write operations across a network are limited to 65,535 bytes per write. For more information regarding pipes, see the Remarks section."
+                var nBytes = Math.Min(15 * 4096, length); // 16 would exceed the limit
+                while (nBytes > 0)
+                {
+                    await PipeStream.WriteAsync(buffer, offset, nBytes, cancellationToken);
+                    offset += nBytes;
+                    length -= nBytes;
+                    nBytes = Math.Min(nBytes, length);
+                }
+            }
+
+            public override async Task FlushAsync(CancellationToken cancellationToken)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    await Task.FromCanceled(cancellationToken);
+                }
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                PipeStream?.Dispose();
+            }
+        }
+    }
+}
diff --git a/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TServerSocketTransport.cs b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TServerSocketTransport.cs
new file mode 100644
index 000000000..86d82e3fc
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TServerSocketTransport.cs
@@ -0,0 +1,139 @@
+// Licensed to the Apache Software Foundation(ASF) under one
+// or more contributor license agreements.See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.The ASF licenses this file
+// to you 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.
+
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift.Transport.Client;
+
+namespace Thrift.Transport.Server
+{
+
+    // ReSharper disable once InconsistentNaming
+    public class TServerSocketTransport : TServerTransport
+    {
+        private readonly int _clientTimeout;
+        private TcpListener _server;
+
+        public TServerSocketTransport(TcpListener listener, int clientTimeout = 0)
+        {
+            _server = listener;
+            _clientTimeout = clientTimeout;
+        }
+
+        public TServerSocketTransport(int port, int clientTimeout = 0)
+            : this(null, clientTimeout)
+        {
+            try
+            {
+                // Make server socket
+                _server = new TcpListener(IPAddress.Any, port);
+                _server.Server.NoDelay = true;
+            }
+            catch (Exception)
+            {
+                _server = null;
+                throw new TTransportException("Could not create ServerSocket on port " + port + ".");
+            }
+        }
+
+        public override void Listen()
+        {
+            // Make sure not to block on accept
+            if (_server != null)
+            {
+                try
+                {
+                    _server.Start();
+                }
+                catch (SocketException sx)
+                {
+                    throw new TTransportException("Could not accept on listening socket: " + sx.Message);
+                }
+            }
+        }
+
+        public override bool IsClientPending()
+        {
+            return _server.Pending();
+        }
+
+        protected override async ValueTask<TTransport> AcceptImplementationAsync(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return await Task.FromCanceled<TTransport>(cancellationToken);
+            }
+
+            if (_server == null)
+            {
+                throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket.");
+            }
+
+            try
+            {
+                TTransport tSocketTransport = null;
+                var tcpClient = await _server.AcceptTcpClientAsync();
+
+                try
+                {
+                    tSocketTransport = new TSocketTransport(tcpClient)
+                    {
+                        Timeout = _clientTimeout
+                    };
+
+                    return tSocketTransport;
+                }
+                catch (Exception)
+                {
+                    if (tSocketTransport != null)
+                    {
+                        tSocketTransport.Dispose();
+                    }
+                    else //  Otherwise, clean it up ourselves.
+                    {
+                        ((IDisposable) tcpClient).Dispose();
+                    }
+
+                    throw;
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new TTransportException(ex.ToString());
+            }
+        }
+
+        public override void Close()
+        {
+            if (_server != null)
+            {
+                try
+                {
+                    _server.Stop();
+                }
+                catch (Exception ex)
+                {
+                    throw new TTransportException("WARNING: Could not close server socket: " + ex);
+                }
+                _server = null;
+            }
+        }
+    }
+}
diff --git a/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TTlsServerSocketTransport.cs b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TTlsServerSocketTransport.cs
new file mode 100644
index 000000000..128680599
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/netstd/Thrift/Transport/Server/TTlsServerSocketTransport.cs
@@ -0,0 +1,150 @@
+// Licensed to the Apache Software Foundation(ASF) under one
+// or more contributor license agreements.See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.The ASF licenses this file
+// to you 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.
+
+using System;
+using System.Net;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using Thrift.Transport.Client;
+
+namespace Thrift.Transport.Server
+{
+    // ReSharper disable once InconsistentNaming
+    public class TTlsServerSocketTransport : TServerTransport
+    {
+        private readonly RemoteCertificateValidationCallback _clientCertValidator;
+        private readonly int _clientTimeout = 0;
+        private readonly LocalCertificateSelectionCallback _localCertificateSelectionCallback;
+        private readonly X509Certificate2 _serverCertificate;
+        private readonly SslProtocols _sslProtocols;
+        private TcpListener _server;
+               
+        public TTlsServerSocketTransport(
+            TcpListener listener,
+            X509Certificate2 certificate,
+            RemoteCertificateValidationCallback clientCertValidator = null,
+            LocalCertificateSelectionCallback localCertificateSelectionCallback = null,
+            SslProtocols sslProtocols = SslProtocols.Tls12)
+        {
+            if (!certificate.HasPrivateKey)
+            {
+                throw new TTransportException(TTransportException.ExceptionType.Unknown,
+                    "Your server-certificate needs to have a private key");
+            }
+
+            _serverCertificate = certificate;
+            _clientCertValidator = clientCertValidator;
+            _localCertificateSelectionCallback = localCertificateSelectionCallback;
+            _sslProtocols = sslProtocols;
+            _server = listener;
+        }
+
+        public TTlsServerSocketTransport(
+            int port,
+            X509Certificate2 certificate,
+            RemoteCertificateValidationCallback clientCertValidator = null,
+            LocalCertificateSelectionCallback localCertificateSelectionCallback = null,
+            SslProtocols sslProtocols = SslProtocols.Tls12)
+            : this(null, certificate, clientCertValidator, localCertificateSelectionCallback)
+        {
+            try
+            {
+                // Create server socket
+                _server = new TcpListener(IPAddress.Any, port);
+                _server.Server.NoDelay = true;
+            }
+            catch (Exception)
+            {
+                _server = null;
+                throw new TTransportException($"Could not create ServerSocket on port {port}.");
+            }
+        }
+
+        public override void Listen()
+        {
+            // Make sure accept is not blocking
+            if (_server != null)
+            {
+                try
+                {
+                    _server.Start();
+                }
+                catch (SocketException sx)
+                {
+                    throw new TTransportException($"Could not accept on listening socket: {sx.Message}");
+                }
+            }
+        }
+
+        public override bool IsClientPending()
+        {
+            return _server.Pending();
+        }
+
+        protected override async ValueTask<TTransport> AcceptImplementationAsync(CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return await Task.FromCanceled<TTransport>(cancellationToken);
+            }
+
+            if (_server == null)
+            {
+                throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket.");
+            }
+
+            try
+            {
+                var client = await _server.AcceptTcpClientAsync();
+                client.SendTimeout = client.ReceiveTimeout = _clientTimeout;
+
+                //wrap the client in an SSL Socket passing in the SSL cert
+                var tTlsSocket = new TTlsSocketTransport(client, _serverCertificate, true, _clientCertValidator,
+                    _localCertificateSelectionCallback, _sslProtocols);
+
+                await tTlsSocket.SetupTlsAsync();
+                
+                return tTlsSocket;
+            }
+            catch (Exception ex)
+            {
+                throw new TTransportException(ex.ToString());
+            }
+        }
+
+        public override void Close()
+        {
+            if (_server != null)
+            {
+                try
+                {
+                    _server.Stop();
+                }
+                catch (Exception ex)
+                {
+                    throw new TTransportException($"WARNING: Could not close server socket: {ex}");
+                }
+
+                _server = null;
+            }
+        }
+    }
+}