private async Task HandleIncoming()
        {
            while (!_cts.IsCancellationRequested)
            {
                try
                {
                    UdpReceiveResult data;
                    try
                    {
                        data = await _socket.ReceiveAsync();

                        _logger.LogDebug("Received DTLS Packet from {EndPoint}", data.RemoteEndPoint);
                    }
                    catch (ObjectDisposedException)
                    {
                        // Happens when the Connection is being closed
                        continue;
                    }
                    catch (SocketException sockEx)
                    {
                        // Some clients send an ICMP Port Unreachable when they receive data after they stopped listening.
                        // If we knew from which client it came we could get rid of the connection, but we can't, so we just ignore the exception.
                        if (sockEx.SocketErrorCode == SocketError.ConnectionReset)
                        {
                            _logger.LogInformation("Connection Closed by remote host");
                            continue;
                        }
                        _logger.LogError("SocketException with SocketErrorCode {SocketErrorCode}", sockEx.SocketErrorCode);
                        throw;
                    }

                    // if there is an existing session, we pass the datagram to the session.
                    if (_sessions.TryGetValue(data.RemoteEndPoint, out CoapDtlsServerClientEndPoint session))
                    {
                        session.EnqueueDatagram(data.Buffer);
                        continue;
                    }

                    // if there isn't an existing session for this remote endpoint, we start a new one and pass the first datagram to the session
                    var transport = new QueueDatagramTransport(NetworkMtu, bytes => _sendQueue.Add(new UdpSendPacket(bytes, data.RemoteEndPoint)));
                    session = new CoapDtlsServerClientEndPoint(data.RemoteEndPoint, transport, DateTime.UtcNow);
                    session.EnqueueDatagram(data.Buffer);

                    _sessions.TryAdd(data.RemoteEndPoint, session);
                    try
                    {
                        _logger.LogInformation("New connection from {EndPoint}; Active Sessions: {ActiveSessions}", data.RemoteEndPoint, _sessions.Count);

#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                        Task.Factory.StartNew(() => HandleSession(session), TaskCreationOptions.LongRunning);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "Exception while starting session handler!");
                        _sessions.TryRemove(session.EndPoint, out _);
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error while handling incoming datagrams");
                }
            }
        }
        private async Task HandleSession(CoapDtlsServerClientEndPoint session)
        {
            var state = new Dictionary <string, object>
            {
                { "RemoteEndPoint", session?.EndPoint }
            };

            using (_logger.BeginScope(state))
            {
                try
                {
                    _logger.LogDebug("Trying to accept TLS connection from {EndPoint}", session.EndPoint);

                    var server = _tlsServerFactory.Create();

                    session.Accept(_serverProtocol, server);

                    if (session.ConnectionInfo != null)
                    {
                        _logger.LogInformation("New TLS connection from {EndPoint}, Server Info: {ServerInfo}", session.EndPoint, session.ConnectionInfo);
                    }
                    else
                    {
                        _logger.LogInformation("New TLS connection from {EndPoint}", session.EndPoint);
                    }

                    var connectionInfo = new CoapDtlsConnectionInformation
                    {
                        LocalEndpoint  = _endPoint,
                        RemoteEndpoint = session,
                        TlsServer      = server
                    };

                    while (!session.IsClosed && !_cts.IsCancellationRequested)
                    {
                        var packet = await session.ReceiveAsync(_cts.Token);

                        _logger.LogDebug("Handling CoAP Packet from {EndPoint}", session.EndPoint);
                        await _coapHandler.ProcessRequestAsync(connectionInfo, packet.Payload);

                        _logger.LogDebug("CoAP request from {EndPoint} handled!", session.EndPoint);
                    }
                }
                catch (OperationCanceledException)
                {
                }
                catch (DtlsConnectionClosedException)
                {
                }
                catch (TlsFatalAlert tlsAlert)
                {
                    if (!(tlsAlert.InnerException is DtlsConnectionClosedException) && tlsAlert.AlertDescription != AlertDescription.user_canceled)
                    {
                        _logger.LogWarning(tlsAlert, "TLS Error");
                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error while handling session");
                }
                finally
                {
                    _logger.LogInformation("Connection from {EndPoint} closed", session.EndPoint);
                    _sessions.TryRemove(session.EndPoint, out _);
                }
            }
        }