Implemented DTLS timeout handling

src/dtlstransport.cpp

@@ -67,6 +67,7 @@ DtlsTransport::DtlsTransport(shared_ptr<IceTransport> lower, shared_ptr<Certific
 	    gnutls_credentials_set(mSession, GNUTLS_CRD_CERTIFICATE, mCertificate->credentials()));
 
 	gnutls_dtls_set_timeouts(mSession, 400, 60000);
+	gnutls_handshake_set_timeout(mSession, 60000);
 
 	gnutls_session_set_ptr(mSession, this);
 	gnutls_transport_set_ptr(mSession, this);
@@ -200,7 +201,12 @@ ssize_t DtlsTransport::ReadCallback(gnutls_transport_ptr_t ptr, void *data, size
 }
 
 int DtlsTransport::TimeoutCallback(gnutls_transport_ptr_t ptr, unsigned int ms) {
-	return 1; // So ReadCallback is called
+	DtlsTransport *t = static_cast<DtlsTransport *>(ptr);
+	if (ms != GNUTLS_INDEFINITE_TIMEOUT)
+		t->mIncomingQueue.wait(std::chrono::milliseconds(ms));
+	else
+		t->mIncomingQueue.wait();
+	return !t->mIncomingQueue.empty() ? 1 : 0;
 }
 
 } // namespace rtc

src/queue.hpp

@@ -22,6 +22,7 @@
 #include "include.hpp"
 
 #include <atomic>
+#include <chrono>
 #include <condition_variable>
 #include <mutex>
 #include <optional>
@@ -35,10 +36,11 @@ public:
 	~Queue();
 
 	void stop();
+	bool empty() const;
 	void push(const T &element);
 	std::optional<T> pop();
-
-	bool empty() const;
+	void wait();
+	void wait(const std::chrono::milliseconds &duration);
 
 private:
 	std::queue<T> mQueue;
@@ -58,6 +60,11 @@ template <typename T> void Queue<T>::stop() {
 	mCondition.notify_all();
 }
 
+template <typename T> bool Queue<T>::empty() const {
+	std::lock_guard<std::mutex> lock(mMutex);
+	return mQueue.empty();
+}
+
 template <typename T> void Queue<T>::push(const T &element) {
 	std::lock_guard<std::mutex> lock(mMutex);
 	if (mStopping)
@@ -79,9 +86,16 @@ template <typename T> std::optional<T> Queue<T>::pop() {
 	return element;
 }
 
-template <typename T> bool Queue<T>::empty() const {
-	std::lock_guard<std::mutex> lock(mMutex);
-	return mQueue.empty();
+template <typename T> void Queue<T>::wait() {
+	std::unique_lock<std::mutex> lock(mMutex);
+	if (mQueue.empty() && !mStopping)
+		mCondition.wait(lock);
+}
+
+template <typename T> void Queue<T>::wait(const std::chrono::milliseconds &duration) {
+	std::unique_lock<std::mutex> lock(mMutex);
+	if (mQueue.empty() && !mStopping)
+		mCondition.wait_for(lock, duration);
 }
 
 } // namespace rtc