- The first part

- Added CodeDocs config file for customization
- Fixing LGTM alerts
- LGTM bug fixed again
- added token option to hyperion-remote
- fix DBManager::getDB()
- next bugfix
- correct broken signal from SettingManager to Hyperion
- Token list is created after the schema is fetched

Signed-off-by: Paulchen-Panther <Paulchen-Panter@protonmail.com>

libsrc/webserver/CgiHandler.cpp

@@ -55,7 +55,6 @@ void CgiHandler::cmd_cfg_jsonserver()
 	if ( _args.at(0) == "cfg_jsonserver" )
 	{
 		quint16 jsonPort = 19444;
-
 		// send result as reply
 		_reply->addHeader ("Content-Type", "text/plain" );
 		_reply->appendRawData (QByteArrayLiteral(":") % QString::number(jsonPort).toUtf8() );

libsrc/webserver/QtHttpClientWrapper.cpp

@@ -4,8 +4,8 @@
 #include "QtHttpReply.h"
 #include "QtHttpServer.h"
 #include "QtHttpHeader.h"
+#include "WebSocketClient.h"
 #include "WebJsonRpc.h"
-#include "webserver/WebSocketClient.h"
 
 #include <QCryptographicHash>
 #include <QTcpSocket>
@@ -16,15 +16,16 @@
 
 const QByteArray & QtHttpClientWrapper::CRLF = QByteArrayLiteral ("\r\n");
 
-QtHttpClientWrapper::QtHttpClientWrapper (QTcpSocket * sock, QtHttpServer * parent)
-    : QObject          (parent)
-    , m_guid           ("")
-    , m_parsingStatus  (AwaitingRequest)
-    , m_sockClient     (sock)
-    , m_currentRequest (Q_NULLPTR)
-    , m_serverHandle   (parent)
-    , m_websocketClient(nullptr)
-    , m_webJsonRpc     (nullptr)
+QtHttpClientWrapper::QtHttpClientWrapper (QTcpSocket * sock, const bool& localConnection, QtHttpServer * parent)
+	: QObject          (parent)
+	, m_guid           ("")
+	, m_parsingStatus  (AwaitingRequest)
+	, m_sockClient     (sock)
+	, m_currentRequest (Q_NULLPTR)
+	, m_serverHandle   (parent)
+	, m_localConnection(localConnection)
+	, m_websocketClient(nullptr)
+	, m_webJsonRpc     (nullptr)
 {
     connect (m_sockClient, &QTcpSocket::readyRead, this, &QtHttpClientWrapper::onClientDataReceived);
 }
@@ -120,7 +121,7 @@ void QtHttpClientWrapper::onClientDataReceived (void) {
 						{
 							// disconnect this slot from socket for further requests
 							disconnect(m_sockClient, &QTcpSocket::readyRead, this, &QtHttpClientWrapper::onClientDataReceived);
-							m_websocketClient = new WebSocketClient(m_currentRequest->getHeader(QtHttpHeader::SecWebSocketKey), m_sockClient, this);
+							m_websocketClient = new WebSocketClient(m_currentRequest, m_sockClient, m_localConnection, this);
 						}
 						break;
 					}
@@ -149,7 +150,7 @@ void QtHttpClientWrapper::onClientDataReceived (void) {
 						{
 							if(m_webJsonRpc == Q_NULLPTR)
 							{
-								m_webJsonRpc = new WebJsonRpc(m_currentRequest, m_serverHandle, this);
+								m_webJsonRpc = new WebJsonRpc(m_currentRequest, m_serverHandle, m_localConnection, this);
 							}
 							m_webJsonRpc->handleMessage(m_currentRequest);
 							break;

libsrc/webserver/QtHttpClientWrapper.h

@@ -13,43 +13,44 @@ class WebSocketClient;
 class WebJsonRpc;
 
 class QtHttpClientWrapper : public QObject {
-    Q_OBJECT
+	Q_OBJECT
 
 public:
-    explicit QtHttpClientWrapper (QTcpSocket * sock, QtHttpServer * parent);
+	explicit QtHttpClientWrapper (QTcpSocket * sock, const bool& localConnection, QtHttpServer * parent);
 
-    static const char SPACE = ' ';
-    static const char COLON = ':';
-    static const QByteArray & CRLF;
+	static const char SPACE = ' ';
+	static const char COLON = ':';
+	static const QByteArray & CRLF;
 
-    enum ParsingStatus {
-        ParsingError    = -1,
-        AwaitingRequest =  0,
-        AwaitingHeaders =  1,
-        AwaitingContent =  2,
-        RequestParsed   =  3
-    };
+	enum ParsingStatus {
+		ParsingError    = -1,
+		AwaitingRequest =  0,
+		AwaitingHeaders =  1,
+		AwaitingContent =  2,
+		RequestParsed   =  3
+	};
 
-    QString getGuid (void);
+	QString getGuid (void);
 	/// @brief Wrapper for sendReplyToClient(), handles m_parsingStatus and signal connect
 	void sendToClientWithReply (QtHttpReply * reply);
 
 private slots:
-    void onClientDataReceived (void);
+	void onClientDataReceived (void);
 
 protected:
-    ParsingStatus sendReplyToClient (QtHttpReply * reply);
+	ParsingStatus sendReplyToClient (QtHttpReply * reply);
 
 protected slots:
-    void onReplySendHeadersRequested (void);
-    void onReplySendDataRequested    (void);
+	void onReplySendHeadersRequested (void);
+	void onReplySendDataRequested    (void);
 
 private:
-    QString           m_guid;
-    ParsingStatus     m_parsingStatus;
-    QTcpSocket    *   m_sockClient;
-    QtHttpRequest *   m_currentRequest;
-    QtHttpServer  *   m_serverHandle;
+	QString           m_guid;
+	ParsingStatus     m_parsingStatus;
+	QTcpSocket    *   m_sockClient;
+	QtHttpRequest *   m_currentRequest;
+	QtHttpServer  *   m_serverHandle;
+	const bool        m_localConnection;
 	WebSocketClient * m_websocketClient;
 	WebJsonRpc *      m_webJsonRpc;
 };

libsrc/webserver/QtHttpServer.cpp

@@ -1,3 +1,4 @@
+
 #include "QtHttpServer.h"
 #include "QtHttpRequest.h"
 #include "QtHttpReply.h"
@@ -5,158 +6,147 @@
 
 #include <QUrlQuery>
 
+#include <utils/NetOrigin.h>
+
 const QString & QtHttpServer::HTTP_VERSION = QStringLiteral ("HTTP/1.1");
 
 QtHttpServerWrapper::QtHttpServerWrapper (QObject * parent)
-	: QTcpServer (parent)
-	, m_useSsl (false)
-{
-}
+    : QTcpServer (parent)
+    , m_useSsl   (false)
+{ }
 
-QtHttpServerWrapper::~QtHttpServerWrapper (void)
-{
-}
+QtHttpServerWrapper::~QtHttpServerWrapper (void) { }
 
 void QtHttpServerWrapper::setUseSecure (const bool ssl) {
-	m_useSsl = ssl;
+    m_useSsl = ssl;
 }
 
-void QtHttpServerWrapper::incomingConnection (qintptr handle)
-{
-	QTcpSocket * sock = (m_useSsl
-		? new QSslSocket (this)
-		: new QTcpSocket (this));
-	(sock->setSocketDescriptor (handle))
-		? addPendingConnection (sock)
-		: delete sock;
+void QtHttpServerWrapper::incomingConnection (qintptr handle) {
+    QTcpSocket * sock = (m_useSsl
+                         ? new QSslSocket (this)
+                         : new QTcpSocket (this));
+    if (sock->setSocketDescriptor (handle)) {
+        addPendingConnection (sock);
+    }
+    else {
+        delete sock;
+    }
 }
 
 QtHttpServer::QtHttpServer (QObject * parent)
-	: QObject (parent)
-	, m_useSsl (false)
-	, m_serverName (QStringLiteral ("The Qt5 HTTP Server"))
+    : QObject      (parent)
+    , m_useSsl     (false)
+    , m_serverName (QStringLiteral ("The Qt5 HTTP Server"))
+	, m_netOrigin  (NetOrigin::getInstance())
 {
-	m_sockServer = new QtHttpServerWrapper (this);
-	connect (m_sockServer, &QtHttpServerWrapper::newConnection, this, &QtHttpServer::onClientConnected);
+    m_sockServer = new QtHttpServerWrapper (this);
+    connect (m_sockServer, &QtHttpServerWrapper::newConnection, this, &QtHttpServer::onClientConnected);
 }
 
-const QString & QtHttpServer::getServerName (void) const
-{
-	return m_serverName;
+const QString & QtHttpServer::getServerName (void) const {
+    return m_serverName;
 }
 
-quint16 QtHttpServer::getServerPort (void) const
-{
-	return m_sockServer->serverPort ();
+quint16 QtHttpServer::getServerPort (void) const {
+    return m_sockServer->serverPort ();
 }
 
-QString QtHttpServer::getErrorString (void) const
-{
-	return m_sockServer->errorString ();
+QString QtHttpServer::getErrorString (void) const {
+    return m_sockServer->errorString ();
 }
 
-void QtHttpServer::start (quint16 port)
-{
+void QtHttpServer::start (quint16 port) {
 	if(!m_sockServer->isListening())
-		(m_sockServer->listen (QHostAddress::Any, port))
-		? emit started (m_sockServer->serverPort ())
-		: emit error (m_sockServer->errorString ());
+	{
+		if (m_sockServer->listen (QHostAddress::Any, port)) {
+			emit started (m_sockServer->serverPort ());
+		}
+		else {
+			emit error (m_sockServer->errorString ());
+		}
+	}
 }
 
-void QtHttpServer::stop (void)
-{
-	if (m_sockServer->isListening ())
-	{
-		m_sockServer->close ();
-
+void QtHttpServer::stop (void) {
+    if (m_sockServer->isListening ()) {
+        m_sockServer->close ();
 		// disconnect clients
 		const QList<QTcpSocket*> socks = m_socksClientsHash.keys();
 		for(auto sock : socks)
 		{
 			sock->close();
 		}
-
-		emit stopped ();
-	}
+        emit stopped ();
+    }
 }
 
-void QtHttpServer::setServerName (const QString & serverName)
-{
-	m_serverName = serverName;
+void QtHttpServer::setServerName (const QString & serverName) {
+    m_serverName = serverName;
 }
 
-void QtHttpServer::setUseSecure (const bool ssl)
-{
-	m_useSsl = ssl;
-	m_sockServer->setUseSecure (m_useSsl);
+void QtHttpServer::setUseSecure (const bool ssl) {
+    m_useSsl = ssl;
+    m_sockServer->setUseSecure (m_useSsl);
 }
 
-void QtHttpServer::setPrivateKey (const QSslKey & key)
-{
-	m_sslKey = key;
+void QtHttpServer::setPrivateKey (const QSslKey & key) {
+    m_sslKey = key;
 }
 
-void QtHttpServer::setCertificates (const QList<QSslCertificate> & certs)
-{
-	m_sslCerts = certs;
+void QtHttpServer::setCertificates (const QList<QSslCertificate> & certs) {
+    m_sslCerts = certs;
 }
 
-void QtHttpServer::onClientConnected (void)
-{
-	while (m_sockServer->hasPendingConnections ())
-	{
-		if (QTcpSocket * sock = m_sockServer->nextPendingConnection ())
-		{
-			connect (sock, &QTcpSocket::disconnected, this, &QtHttpServer::onClientDisconnected);
-			if (m_useSsl)
+void QtHttpServer::onClientConnected (void) {
+    while (m_sockServer->hasPendingConnections ()) {
+        if (QTcpSocket * sock = m_sockServer->nextPendingConnection ()) {
+			if(m_netOrigin->accessAllowed(sock->peerAddress(), sock->localAddress()))
 			{
-				if (QSslSocket * ssl = qobject_cast<QSslSocket *> (sock))
-				{
-					connect (ssl, SslErrorSignal (&QSslSocket::sslErrors), this, &QtHttpServer::onClientSslErrors);
-					connect (ssl, &QSslSocket::encrypted, this, &QtHttpServer::onClientSslEncrypted);
-					connect (ssl, &QSslSocket::peerVerifyError, this, &QtHttpServer::onClientSslPeerVerifyError);
-					connect (ssl, &QSslSocket::modeChanged, this, &QtHttpServer::onClientSslModeChanged);
-					ssl->setLocalCertificateChain (m_sslCerts);
-					ssl->setPrivateKey (m_sslKey);
-					ssl->setPeerVerifyMode (QSslSocket::AutoVerifyPeer);
-					ssl->startServerEncryption ();
-				}
+	            connect (sock, &QTcpSocket::disconnected, this, &QtHttpServer::onClientDisconnected);
+	            if (m_useSsl) {
+	                if (QSslSocket * ssl = qobject_cast<QSslSocket *> (sock)) {
+	                    connect (ssl, SslErrorSignal (&QSslSocket::sslErrors), this, &QtHttpServer::onClientSslErrors);
+	                    connect (ssl, &QSslSocket::encrypted,                  this, &QtHttpServer::onClientSslEncrypted);
+	                    connect (ssl, &QSslSocket::peerVerifyError,            this, &QtHttpServer::onClientSslPeerVerifyError);
+	                    connect (ssl, &QSslSocket::modeChanged,                this, &QtHttpServer::onClientSslModeChanged);
+	                    ssl->setLocalCertificateChain (m_sslCerts);
+	                    ssl->setPrivateKey (m_sslKey);
+	                    ssl->setPeerVerifyMode (QSslSocket::AutoVerifyPeer);
+	                    ssl->startServerEncryption ();
+	                }
+	            }
+	            QtHttpClientWrapper * wrapper = new QtHttpClientWrapper (sock, m_netOrigin->isLocalAddress(sock->peerAddress(), sock->localAddress()), this);
+	            m_socksClientsHash.insert (sock, wrapper);
+	            emit clientConnected (wrapper->getGuid ());
 			}
-			QtHttpClientWrapper * wrapper = new QtHttpClientWrapper (sock, this);
-			m_socksClientsHash.insert (sock, wrapper);
-			emit clientConnected (wrapper->getGuid ());
-		}
-	}
+			else
+			{
+				sock->close();
+			}
+        }
+    }
 }
 
-void QtHttpServer::onClientSslEncrypted (void)
-{
+void QtHttpServer::onClientSslEncrypted (void) { }
+
+void QtHttpServer::onClientSslPeerVerifyError (const QSslError & err) {
+    Q_UNUSED (err)
 }
 
-void QtHttpServer::onClientSslPeerVerifyError (const QSslError & err)
-{
-	Q_UNUSED (err)
+void QtHttpServer::onClientSslErrors (const QList<QSslError> & errors) {
+    Q_UNUSED (errors)
 }
 
-void QtHttpServer::onClientSslErrors (const QList<QSslError> & errors)
-{
-	Q_UNUSED (errors)
+void QtHttpServer::onClientSslModeChanged (QSslSocket::SslMode mode) {
+    Q_UNUSED (mode)
 }
 
-void QtHttpServer::onClientSslModeChanged (QSslSocket::SslMode mode)
-{
-	Q_UNUSED (mode)
-}
-
-void QtHttpServer::onClientDisconnected (void)
-{
-	if (QTcpSocket * sockClient = qobject_cast<QTcpSocket *> (sender ()))
-	{
-		if (QtHttpClientWrapper * wrapper = m_socksClientsHash.value (sockClient, Q_NULLPTR))
-		{
-			emit clientDisconnected (wrapper->getGuid ());
-			wrapper->deleteLater ();
-			m_socksClientsHash.remove (sockClient);
-		}
-	}
+void QtHttpServer::onClientDisconnected (void) {
+    if (QTcpSocket * sockClient = qobject_cast<QTcpSocket *> (sender ())) {
+        if (QtHttpClientWrapper * wrapper = m_socksClientsHash.value (sockClient, Q_NULLPTR)) {
+            emit clientDisconnected (wrapper->getGuid ());
+            wrapper->deleteLater ();
+            m_socksClientsHash.remove (sockClient);
+        }
+    }
 }

libsrc/webserver/QtHttpServer.h

@@ -17,72 +17,72 @@ class QTcpServer;
 class QtHttpRequest;
 class QtHttpReply;
 class QtHttpClientWrapper;
+class NetOrigin;
 
 class QtHttpServerWrapper : public QTcpServer {
-	Q_OBJECT
+    Q_OBJECT
 
 public:
-	explicit QtHttpServerWrapper (QObject * parent = Q_NULLPTR);
-	virtual ~QtHttpServerWrapper (void);
+    explicit QtHttpServerWrapper (QObject * parent = Q_NULLPTR);
+    virtual ~QtHttpServerWrapper (void);
 
-	void setUseSecure (const bool ssl = true);
+    void setUseSecure (const bool ssl = true);
 
 protected:
-	void incomingConnection (qintptr handle) Q_DECL_OVERRIDE;
+    void incomingConnection (qintptr handle) Q_DECL_OVERRIDE;
 
 private:
-	bool m_useSsl;
+    bool m_useSsl;
 };
 
 class QtHttpServer : public QObject {
-	Q_OBJECT
+    Q_OBJECT
 
 public:
-	explicit QtHttpServer (QObject * parent = Q_NULLPTR);
+    explicit QtHttpServer (QObject * parent = Q_NULLPTR);
 
-	static const QString & HTTP_VERSION;
+    static const QString & HTTP_VERSION;
 
-	typedef void (QSslSocket::* SslErrorSignal) (const QList<QSslError> &);
+    typedef void (QSslSocket::* SslErrorSignal) (const QList<QSslError> &);
 
-	const QString & getServerName (void) const;
+    const QString & getServerName (void) const;
 
-	quint16 getServerPort    (void) const;
-	QString getErrorString   (void) const;
-
-	bool isListening(void) { return m_sockServer->isListening(); };
+    quint16 getServerPort    (void) const;
+    QString getErrorString   (void) const;
+	const bool isListening() { return m_sockServer->isListening(); };
 
 public slots:
-	void start           (quint16 port = 0);
-	void stop            (void);
-	void setServerName   (const QString & serverName);
-	void setUseSecure    (const bool ssl = true);
-	void setPrivateKey   (const QSslKey & key);
-	void setCertificates (const QList<QSslCertificate> & certs);
+    void start           (quint16 port = 0);
+    void stop            (void);
+    void setServerName   (const QString & serverName);
+    void setUseSecure    (const bool ssl = true);
+    void setPrivateKey   (const QSslKey & key);
+    void setCertificates (const QList<QSslCertificate> & certs);
 
 signals:
-	void started            (quint16 port);
-	void stopped            (void);
-	void error              (const QString & msg);
-	void clientConnected    (const QString & guid);
-	void clientDisconnected (const QString & guid);
-	void requestNeedsReply  (QtHttpRequest * request, QtHttpReply * reply);
+    void started            (quint16 port);
+    void stopped            (void);
+    void error              (const QString & msg);
+    void clientConnected    (const QString & guid);
+    void clientDisconnected (const QString & guid);
+    void requestNeedsReply  (QtHttpRequest * request, QtHttpReply * reply);
 
 private slots:
-	void onClientConnected          (void);
-	void onClientDisconnected       (void);
-	void onClientSslEncrypted       (void);
-	void onClientSslPeerVerifyError (const QSslError & err);
-	void onClientSslErrors          (const QList<QSslError> & errors);
-	void onClientSslModeChanged     (QSslSocket::SslMode mode);
+    void onClientConnected          (void);
+    void onClientDisconnected       (void);
+    void onClientSslEncrypted       (void);
+    void onClientSslPeerVerifyError (const QSslError & err);
+    void onClientSslErrors          (const QList<QSslError> & errors);
+    void onClientSslModeChanged     (QSslSocket::SslMode mode);
 
 private:
-	bool                                       m_useSsl;
-	QSslKey                                    m_sslKey;
-	QList<QSslCertificate>                     m_sslCerts;
-	QString                                    m_serverName;
-	QtHttpServerWrapper *                      m_sockServer;
-	QHash<QTcpSocket *, QtHttpClientWrapper *> m_socksClientsHash;
+    bool                                       m_useSsl;
+    QSslKey                                    m_sslKey;
+    QList<QSslCertificate>                     m_sslCerts;
+    QString                                    m_serverName;
+	NetOrigin*                                 m_netOrigin;
+    QtHttpServerWrapper *                      m_sockServer;
+    QHash<QTcpSocket *, QtHttpClientWrapper *> m_socksClientsHash;
 };
 
 #endif // QTHTTPSERVER_H
-

libsrc/webserver/StaticFileServing.cpp

@@ -23,7 +23,7 @@ StaticFileServing::StaticFileServing (QObject * parent)
 
 StaticFileServing::~StaticFileServing ()
 {
-	delete _mimeDb;
+
 }
 
 void StaticFileServing::setBaseUrl(const QString& url)

libsrc/webserver/WebJsonRpc.cpp

@@ -6,22 +6,23 @@
 
 #include <api/JsonAPI.h>
 
-WebJsonRpc::WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, QtHttpClientWrapper* parent)
+WebJsonRpc::WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, const bool& localConnection, QtHttpClientWrapper* parent)
 	: QObject(parent)
 	, _server(server)
 	, _wrapper(parent)
 	, _log(Logger::getInstance("HTTPJSONRPC"))
 {
 	const QString client = request->getClientInfo().clientAddress.toString();
-	_jsonAPI = new JsonAPI(client, _log, this, true);
+	_jsonAPI = new JsonAPI(client, _log, localConnection, this, true);
 	connect(_jsonAPI, &JsonAPI::callbackMessage, this, &WebJsonRpc::handleCallback);
 }
 
 void WebJsonRpc::handleMessage(QtHttpRequest* request)
 {
+	QByteArray header = request->getHeader("Authorization");
 	QByteArray data = request->getRawData();
 	_unlocked = true;
-	_jsonAPI->handleMessage(data);
+	_jsonAPI->handleMessage(data,header);
 }
 
 void WebJsonRpc::handleCallback(QJsonObject obj)

libsrc/webserver/WebJsonRpc.h

@@ -1,9 +1,7 @@
 #pragma once
 
-// utils includes
 #include <utils/Logger.h>
 
-// qt includes
 #include <QJsonObject>
 
 class QtHttpServer;
@@ -14,7 +12,7 @@ class JsonAPI;
 class WebJsonRpc : public QObject {
 	Q_OBJECT
 public:
-	WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, QtHttpClientWrapper* parent);
+	WebJsonRpc(QtHttpRequest* request, QtHttpServer* server, const bool& localConnection, QtHttpClientWrapper* parent);
 
 	void handleMessage(QtHttpRequest* request);
 

libsrc/webserver/WebServer.cpp

@@ -13,11 +13,12 @@
 
 
 WebServer::WebServer(const QJsonDocument& config, QObject * parent)
-	: QObject(parent)
+	:  QObject(parent)
 	, _config(config)
 	, _log(Logger::getInstance("WEBSERVER"))
 	, _server()
 {
+
 }
 
 WebServer::~WebServer()

libsrc/webserver/WebSocketClient.cpp

@@ -1,39 +1,37 @@
-#include "webserver/WebSocketClient.h"
+#include "WebSocketClient.h"
+#include "QtHttpRequest.h"
+#include "QtHttpHeader.h"
 
-// hyperion includes
 #include <hyperion/Hyperion.h>
-
-// JsonAPI includes
 #include <api/JsonAPI.h>
 
-// qt includes
 #include <QTcpSocket>
 #include <QtEndian>
 #include <QCryptographicHash>
 #include <QJsonObject>
-#include <QHostAddress>
 
-
-WebSocketClient::WebSocketClient(QByteArray socketKey, QTcpSocket* sock, QObject* parent)
+WebSocketClient::WebSocketClient(QtHttpRequest* request, QTcpSocket* sock, const bool& localConnection, QObject* parent)
 	: QObject(parent)
 	, _socket(sock)
-	, _secWebSocketKey(socketKey)
 	, _log(Logger::getInstance("WEBSOCKET"))
+//	, _hyperion(Hyperion::getInstance())
 {
 	// connect socket; disconnect handled from QtHttpServer
 	connect(_socket, &QTcpSocket::readyRead , this, &WebSocketClient::handleWebSocketFrame);
 
-	const QString client = sock->peerAddress().toString();
+	// QtHttpRequest contains all headers for handshake
+	QByteArray secWebSocketKey = request->getHeader(QtHttpHeader::SecWebSocketKey);
+	const QString client = request->getClientInfo().clientAddress.toString();
 
 	// Json processor
-	_jsonAPI = new JsonAPI(client, _log, this);
+	_jsonAPI = new JsonAPI(client, _log, localConnection, this);
 	connect(_jsonAPI, &JsonAPI::callbackMessage, this, &WebSocketClient::sendMessage);
 
 	Debug(_log, "New connection from %s", QSTRING_CSTR(client));
 
 	// do handshake
-	_secWebSocketKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-	QByteArray hash = QCryptographicHash::hash(_secWebSocketKey, QCryptographicHash::Sha1).toBase64();
+	secWebSocketKey += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+	QByteArray hash = QCryptographicHash::hash(secWebSocketKey, QCryptographicHash::Sha1).toBase64();
 
 	QString data
 		= QString("HTTP/1.1 101 Switching Protocols\r\n")
@@ -113,14 +111,14 @@ void WebSocketClient::handleWebSocketFrame(void)
 			if (_wsh.fin)
 			{
 				_onContinuation = false;
-//				if (_wsh.opCode == OPCODE::TEXT)
-//				{
+				if (_wsh.opCode == OPCODE::TEXT)
+				{
 					_jsonAPI->handleMessage(QString(_wsReceiveBuffer));
-//				}
-//				else
-//				{
-//					handleBinaryMessage(_wsReceiveBuffer);
-//				}
+				}
+				else
+				{
+					handleBinaryMessage(_wsReceiveBuffer);
+				}
 				_wsReceiveBuffer.clear();
 			}
 		}
@@ -223,7 +221,6 @@ void WebSocketClient::sendClose(int status, QString reason)
 	_socket->close();
 }
 
-/*
 void WebSocketClient::handleBinaryMessage(QByteArray &data)
 {
 	//uint8_t  priority   = data.at(0);
@@ -242,10 +239,9 @@ void WebSocketClient::handleBinaryMessage(QByteArray &data)
 	image.resize(width, height);
 
 	memcpy(image.memptr(), data.data()+4, imgSize);
-	_hyperion->registerInput();
-	_hyperion->setInputImage(priority, image, duration_s*1000);
+	//_hyperion->registerInput();
+	//_hyperion->setInputImage(priority, image, duration_s*1000);
 }
-*/
 
 qint64 WebSocketClient::sendMessage(QJsonObject obj)
 {

libsrc/webserver/WebSocketClient.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <utils/Logger.h>
+#include "WebSocketUtils.h"
+
+class QTcpSocket;
+
+class QtHttpRequest;
+class Hyperion;
+class JsonAPI;
+
+class WebSocketClient : public QObject {
+	Q_OBJECT
+public:
+	WebSocketClient(QtHttpRequest* request, QTcpSocket* sock, const bool& localConnection, QObject* parent);
+
+	struct WebSocketHeader
+	{
+		bool          fin;
+		quint8 opCode;
+		bool          masked;
+		quint64       payloadLength;
+		char          key[4];
+	};
+
+private:
+	QTcpSocket* _socket;
+	Logger* _log;
+	Hyperion* _hyperion;
+	JsonAPI* _jsonAPI;
+
+	void getWsFrameHeader(WebSocketHeader* header);
+	void sendClose(int status, QString reason = "");
+	void handleBinaryMessage(QByteArray &data);
+	qint64 sendMessage_Raw(const char* data, quint64 size);
+	qint64 sendMessage_Raw(QByteArray &data);
+	QByteArray makeFrameHeader(quint8 opCode, quint64 payloadLength, bool lastFrame);
+
+	/// The buffer used for reading data from the socket
+	QByteArray _receiveBuffer;
+
+	/// buffer for websockets multi frame receive
+	QByteArray _wsReceiveBuffer;
+	quint8 _maskKey[4];
+
+	bool _onContinuation = false;
+
+	// true when data is missing for parsing
+	bool _notEnoughData = false;
+
+	// websocket header store
+	WebSocketHeader _wsh;
+
+	// masks for fields in the basic header
+	static uint8_t const BHB0_OPCODE = 0x0F;
+	static uint8_t const BHB0_RSV3   = 0x10;
+	static uint8_t const BHB0_RSV2   = 0x20;
+	static uint8_t const BHB0_RSV1   = 0x40;
+	static uint8_t const BHB0_FIN    = 0x80;
+
+	static uint8_t const BHB1_PAYLOAD = 0x7F;
+	static uint8_t const BHB1_MASK    = 0x80;
+
+	static uint8_t const payload_size_code_16bit = 0x7E; // 126
+	static uint8_t const payload_size_code_64bit = 0x7F; // 127
+
+	static const quint64 FRAME_SIZE_IN_BYTES = 512 * 512 * 2;  //maximum size of a frame when sending a message
+
+private slots:
+	void handleWebSocketFrame(void);
+	qint64 sendMessage(QJsonObject obj);
+};

libsrc/webserver/WebSocketUtils.h

@@ -0,0 +1,68 @@
+#pragma once
+
+/// Constants and utility functions related to WebSocket opcodes
+/**
+ * WebSocket Opcodes are 4 bits. See RFC6455 section 5.2.
+ */
+namespace OPCODE {
+	enum value {
+		CONTINUATION = 0x0,
+		TEXT = 0x1,
+		BINARY = 0x2,
+		RSV3 = 0x3,
+		RSV4 = 0x4,
+		RSV5 = 0x5,
+		RSV6 = 0x6,
+		RSV7 = 0x7,
+		CLOSE = 0x8,
+		PING = 0x9,
+		PONG = 0xA,
+		CONTROL_RSVB = 0xB,
+		CONTROL_RSVC = 0xC,
+		CONTROL_RSVD = 0xD,
+		CONTROL_RSVE = 0xE,
+		CONTROL_RSVF = 0xF
+	};
+
+	/// Check if an opcode is reserved
+	/**
+	 * @param v The opcode to test.
+	 * @return Whether or not the opcode is reserved.
+	 */
+	inline bool reserved(value v) {
+		return (v >= RSV3 && v <= RSV7) || (v >= CONTROL_RSVB && v <= CONTROL_RSVF);
+	}
+
+	/// Check if an opcode is invalid
+	/**
+	 * Invalid opcodes are negative or require greater than 4 bits to store.
+	 *
+	 * @param v The opcode to test.
+	 * @return Whether or not the opcode is invalid.
+	 */
+	inline bool invalid(value v) {
+		return (v > 0xF || v < 0);
+	}
+
+	/// Check if an opcode is for a control frame
+	/**
+	 * @param v The opcode to test.
+	 * @return Whether or not the opcode is a control opcode.
+	*/
+	inline bool is_control(value v) {
+		return v >= 0x8;
+	}
+}
+
+namespace CLOSECODE {
+	enum value {
+		NORMAL    = 1000,
+		AWAY      = 1001,
+		TERM      = 1002,
+		INV_TYPE  = 1003,
+		INV_DATA  = 1007,
+		VIOLATION = 1008,
+		BIG_MSG   = 1009,
+		UNEXPECTED= 1011
+	};
+}