Formatting

src/impl/httpproxytransport.cpp

@@ -18,11 +18,10 @@ namespace rtc::impl {
 using std::to_string;
 using std::chrono::system_clock;
 
-HttpProxyTransport::HttpProxyTransport(shared_ptr<TcpTransport> lower, std::string hostname, std::string service, state_callback stateCallback)
-    : Transport(lower, std::move(stateCallback))
-	, mHostname( std::move(hostname) )
-	, mService( std::move(service) )
-{
+HttpProxyTransport::HttpProxyTransport(shared_ptr<TcpTransport> lower, std::string hostname,
+                                       std::string service, state_callback stateCallback)
+    : Transport(lower, std::move(stateCallback)), mHostname(std::move(hostname)),
+      mService(std::move(service)) {
 	if (!lower->isActive())
 		throw std::logic_error("Http proxy creation failed, expects lower transport to be active");
 
@@ -38,9 +37,7 @@ void HttpProxyTransport::start() {
 	sendHttpRequest();
 }
 
-void HttpProxyTransport::stop() {
-	unregisterIncoming();
-}
+void HttpProxyTransport::stop() { unregisterIncoming(); }
 
 bool HttpProxyTransport::send(message_ptr message) {
 	std::lock_guard lock(mSendMutex);
@@ -70,15 +67,12 @@ void HttpProxyTransport::incoming(message_ptr message) {
 					changeState(State::Connected);
 					mBuffer.erase(mBuffer.begin(), mBuffer.begin() + len);
 
-					if( !mBuffer.empty() )
-					{
+					if (!mBuffer.empty()) {
 						recv(make_message(mBuffer));
 						mBuffer.clear();
 					}
 				}
-			}
-			else if (state() == State::Connected)
-			{
+			} else if (state() == State::Connected) {
 				recv(std::move(message));
 			}
 
@@ -106,18 +100,13 @@ bool HttpProxyTransport::sendHttpRequest() {
 	return outgoing(make_message(data, data + request.size()));
 }
 
-std::string HttpProxyTransport::generateHttpRequest()
-{
+std::string HttpProxyTransport::generateHttpRequest() {
 	std::string out =
-		"CONNECT " +
-		mHostname + ":" + mService +
-		" HTTP/1.1\r\nHost: " +
-		mHostname + "\r\n\r\n";
+	    "CONNECT " + mHostname + ":" + mService + " HTTP/1.1\r\nHost: " + mHostname + "\r\n\r\n";
 	return out;
 }
 
-size_t HttpProxyTransport::parseHttpResponse( std::byte* buffer, size_t size )
-{
+size_t HttpProxyTransport::parseHttpResponse(std::byte *buffer, size_t size) {
 	std::list<string> lines;
 	size_t length = utils::parseHttpLines(buffer, size, lines);
 	if (length == 0)

src/impl/httpproxytransport.hpp

@@ -19,10 +19,11 @@ namespace rtc::impl {
 
 class TcpTransport;
 
-class HttpProxyTransport final : public Transport, public std::enable_shared_from_this<HttpProxyTransport> {
+class HttpProxyTransport final : public Transport,
+                                 public std::enable_shared_from_this<HttpProxyTransport> {
 public:
 	HttpProxyTransport(shared_ptr<TcpTransport> lower, std::string hostname, std::string service,
-				state_callback stateCallback);
+	                   state_callback stateCallback);
 	~HttpProxyTransport();
 
 	void start() override;
@@ -35,7 +36,7 @@ private:
 	void incoming(message_ptr message) override;
 	bool sendHttpRequest();
 	std::string generateHttpRequest();
-	size_t parseHttpResponse( std::byte* buffer, size_t size );
+	size_t parseHttpResponse(std::byte *buffer, size_t size);
 
 	std::string mHostname;
 	std::string mService;

src/impl/tlstransport.cpp

@@ -7,8 +7,8 @@
  */
 
 #include "tlstransport.hpp"
-#include "tcptransport.hpp"
 #include "httpproxytransport.hpp"
+#include "tcptransport.hpp"
 #include "threadpool.hpp"
 
 #if RTC_ENABLE_WEBSOCKET
@@ -59,12 +59,13 @@ void TlsTransport::Cleanup() {
 	// Nothing to do
 }
 
-TlsTransport::TlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower, optional<string> host,
-                           certificate_ptr certificate, state_callback callback)
+TlsTransport::TlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower,
+                           optional<string> host, certificate_ptr certificate,
+                           state_callback callback)
     : Transport(std::visit([](auto l) { return std::static_pointer_cast<Transport>(l); }, lower),
-			    std::move(callback)), mHost(std::move(host))
-	, mIsClient(std::visit([](auto l) { return l->isActive(); }, lower))
-	, mIncomingQueue(RECV_QUEUE_LIMIT, message_size_func) {
+                std::move(callback)),
+      mHost(std::move(host)), mIsClient(std::visit([](auto l) { return l->isActive(); }, lower)),
+      mIncomingQueue(RECV_QUEUE_LIMIT, message_size_func) {
 
 	PLOG_DEBUG << "Initializing TLS transport (GnuTLS)";
 
@@ -311,12 +312,13 @@ void TlsTransport::Cleanup() {
 	// Nothing to do
 }
 
-TlsTransport::TlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower, optional<string> host,
-                           certificate_ptr certificate, state_callback callback)
+TlsTransport::TlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower,
+                           optional<string> host, certificate_ptr certificate,
+                           state_callback callback)
     : Transport(std::visit([](auto l) { return std::static_pointer_cast<Transport>(l); }, lower),
-				std::move(callback)), mHost(std::move(host))
-	, mIsClient(std::visit([](auto l) { return l->isActive(); }, lower))
-	, mIncomingQueue(RECV_QUEUE_LIMIT, message_size_func) {
+                std::move(callback)),
+      mHost(std::move(host)), mIsClient(std::visit([](auto l) { return l->isActive(); }, lower)),
+      mIncomingQueue(RECV_QUEUE_LIMIT, message_size_func) {
 
 	PLOG_DEBUG << "Initializing TLS transport (OpenSSL)";
 

src/impl/tlstransport.hpp

@@ -30,8 +30,8 @@ public:
 	static void Init();
 	static void Cleanup();
 
-	TlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower, optional<string> host, certificate_ptr certificate,
-	             state_callback callback);
+	TlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower,
+	             optional<string> host, certificate_ptr certificate, state_callback callback);
 	virtual ~TlsTransport();
 
 	void start() override;

src/impl/utils.cpp

@@ -153,8 +153,7 @@ std::multimap<string, string> parseHttpHeaders(const std::list<string> &lines) {
 		if (size_t pos = line.find_first_of(':'); pos != string::npos) {
 			string key = line.substr(0, pos);
 			string value = "";
-			if (size_t subPos = line.find_first_not_of(' ', pos + 1); subPos != string::npos )
-			{
+			if (size_t subPos = line.find_first_not_of(' ', pos + 1); subPos != string::npos) {
 				value = line.substr(subPos);
 			}
 			std::transform(key.begin(), key.end(), key.begin(),

src/impl/verifiedtlstransport.cpp

@@ -13,8 +13,9 @@
 
 namespace rtc::impl {
 
-VerifiedTlsTransport::VerifiedTlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower, string host,
-                                           certificate_ptr certificate, state_callback callback)
+VerifiedTlsTransport::VerifiedTlsTransport(
+    variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower, string host,
+    certificate_ptr certificate, state_callback callback)
     : TlsTransport(std::move(lower), std::move(host), std::move(certificate), std::move(callback)) {
 
 #if USE_GNUTLS

src/impl/verifiedtlstransport.hpp

@@ -17,8 +17,8 @@ namespace rtc::impl {
 
 class VerifiedTlsTransport final : public TlsTransport {
 public:
-	VerifiedTlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower, string host, certificate_ptr certificate,
-	                     state_callback callback);
+	VerifiedTlsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>> lower,
+	                     string host, certificate_ptr certificate, state_callback callback);
 	~VerifiedTlsTransport();
 };
 

src/impl/websocket.cpp

@@ -14,8 +14,8 @@
 #include "processor.hpp"
 #include "utils.hpp"
 
-#include "tcptransport.hpp"
 #include "httpproxytransport.hpp"
+#include "tcptransport.hpp"
 #include "tlstransport.hpp"
 #include "verifiedtlstransport.hpp"
 #include "wstransport.hpp"
@@ -99,17 +99,15 @@ void WebSocket::open(const string &url) {
 		path += "?" + query;
 
 	mHostname = hostname; // for TLS SNI and Proxy
-	mService = service; //For proxy
+	mService = service;   // For proxy
 	std::atomic_store(&mWsHandshake, std::make_shared<WsHandshake>(host, path, config.protocols));
 
 	changeState(State::Connecting);
 
-	if (config.proxyServer)
-	{
-		setTcpTransport(std::make_shared<TcpTransport>(config.proxyServer->hostname, std::to_string(config.proxyServer->port), nullptr));
-	}
-	else
-	{
+	if (config.proxyServer) {
+		setTcpTransport(std::make_shared<TcpTransport>(
+		    config.proxyServer->hostname, std::to_string(config.proxyServer->port), nullptr));
+	} else {
 		setTcpTransport(std::make_shared<TcpTransport>(hostname, service, nullptr));
 	}
 }
@@ -293,7 +291,8 @@ shared_ptr<HttpProxyTransport> WebSocket::initProxyTransport() {
 			}
 		};
 
-		auto transport = std::make_shared<HttpProxyTransport>( lower, mHostname.value(), mService.value(), stateChangeCallback );
+		auto transport = std::make_shared<HttpProxyTransport>(
+		    lower, mHostname.value(), mService.value(), stateChangeCallback);
 
 		return emplaceTransport(this, &mProxyTransport, std::move(transport));
 
@@ -379,15 +378,15 @@ shared_ptr<WsTransport> WebSocket::initWsTransport() {
 		if (auto transport = std::atomic_load(&mWsTransport))
 			return transport;
 
-		variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>, shared_ptr<TlsTransport>> lower;
+		variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>, shared_ptr<TlsTransport>>
+		    lower;
 		if (mIsSecure) {
 			auto transport = std::atomic_load(&mTlsTransport);
 			if (!transport)
 				throw std::logic_error("No underlying TLS transport for WebSocket transport");
 
 			lower = transport;
-		} 
-		else if (config.proxyServer) {
+		} else if (config.proxyServer) {
 			auto transport = std::atomic_load(&mProxyTransport);
 			if (!transport)
 				throw std::logic_error("No underlying proxy transport for WebSocket transport");

src/impl/websocket.hpp

@@ -13,11 +13,11 @@
 
 #include "channel.hpp"
 #include "common.hpp"
+#include "httpproxytransport.hpp"
 #include "init.hpp"
 #include "message.hpp"
 #include "queue.hpp"
 #include "tcptransport.hpp"
-#include "httpproxytransport.hpp"
 #include "tlstransport.hpp"
 #include "wstransport.hpp"
 
@@ -73,7 +73,7 @@ private:
 	bool mIsSecure;
 
 	optional<string> mHostname; // for TLS SNI and Proxy
-	optional<string> mService; // for Proxy
+	optional<string> mService;  // for Proxy
 
 	shared_ptr<TcpTransport> mTcpTransport;
 	shared_ptr<HttpProxyTransport> mProxyTransport;

src/impl/wstransport.cpp

@@ -43,9 +43,11 @@ using std::to_integer;
 using std::to_string;
 using std::chrono::system_clock;
 
-WsTransport::WsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>, shared_ptr<TlsTransport>> lower,
-                         shared_ptr<WsHandshake> handshake, int maxOutstandingPings,
-                         message_callback recvCallback, state_callback stateCallback)
+WsTransport::WsTransport(
+    variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>, shared_ptr<TlsTransport>>
+        lower,
+    shared_ptr<WsHandshake> handshake, int maxOutstandingPings, message_callback recvCallback,
+    state_callback stateCallback)
     : Transport(std::visit([](auto l) { return std::static_pointer_cast<Transport>(l); }, lower),
                 std::move(stateCallback)),
       mHandshake(std::move(handshake)),

src/impl/wstransport.hpp

@@ -25,9 +25,11 @@ class TlsTransport;
 
 class WsTransport final : public Transport, public std::enable_shared_from_this<WsTransport> {
 public:
-	WsTransport(variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>, shared_ptr<TlsTransport>> lower,
-	            shared_ptr<WsHandshake> handshake, int maxOutstandingPings,
-	            message_callback recvCallback, state_callback stateCallback);
+	WsTransport(
+	    variant<shared_ptr<TcpTransport>, shared_ptr<HttpProxyTransport>, shared_ptr<TlsTransport>>
+	        lower,
+	    shared_ptr<WsHandshake> handshake, int maxOutstandingPings, message_callback recvCallback,
+	    state_callback stateCallback);
 	~WsTransport();
 
 	void start() override;