new brightness handling (#430)

* clean color adjustment

* now a prio duration of "0" means infinity

* implement dynamic 'just in time' initialization

* implement new brightness handling

* cahnge access level

* i18n fix

* - cleanup brightness stuff
- update webserver, now with initial ssl support

* - backlightThreshold is now 0-100 instead 0-1
- better performance for brightness - use piecewise linear instead of sqrt

libsrc/webconfig/QtHttpServer.cpp

@@ -4,18 +4,41 @@
 #include "QtHttpReply.h"
 #include "QtHttpClientWrapper.h"
 
-#include <QTcpServer>
-#include <QTcpSocket>
-#include <QHostAddress>
+#include <QDebug>
+#include <QUrlQuery>
 
 const QString & QtHttpServer::HTTP_VERSION = QStringLiteral ("HTTP/1.1");
 
+QtHttpServerWrapper::QtHttpServerWrapper (QObject * parent)
+    : QTcpServer (parent)
+    , m_useSsl   (false)
+{ }
+
+QtHttpServerWrapper::~QtHttpServerWrapper (void) { }
+
+void QtHttpServerWrapper::setUseSecure (const bool ssl) {
+    m_useSsl = ssl;
+}
+
+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"))
 {
-    m_sockServer = new QTcpServer (this);
-    connect (m_sockServer, &QTcpServer::newConnection, this, &QtHttpServer::onClientConnected);
+    m_sockServer = new QtHttpServerWrapper (this);
+    connect (m_sockServer, &QtHttpServerWrapper::newConnection, this, &QtHttpServer::onClientConnected);
 }
 
 const QString & QtHttpServer::getServerName (void) const {
@@ -50,21 +73,59 @@ 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::setPrivateKey (const QSslKey & key) {
+    m_sslKey = key;
+}
+
+void QtHttpServer::setCertificates (const QList<QSslCertificate> & certs) {
+    m_sslCerts = certs;
+}
+
 void QtHttpServer::onClientConnected (void) {
     while (m_sockServer->hasPendingConnections ()) {
-        QTcpSocket * sockClient = m_sockServer->nextPendingConnection ();
-        QtHttpClientWrapper * wrapper = new QtHttpClientWrapper (sockClient, this);
-        connect (sockClient, &QTcpSocket::disconnected, this, &QtHttpServer::onClientDisconnected);
-        m_socksClientsHash.insert (sockClient, wrapper);
-        emit clientConnected (wrapper->getGuid ());
+        if (QTcpSocket * sock = m_sockServer->nextPendingConnection ()) {
+            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, this);
+            m_socksClientsHash.insert (sock, wrapper);
+            emit clientConnected (wrapper->getGuid ());
+        }
     }
 }
 
+void QtHttpServer::onClientSslEncrypted (void) { }
+
+void QtHttpServer::onClientSslPeerVerifyError (const QSslError & err) {
+    Q_UNUSED (err)
+}
+
+void QtHttpServer::onClientSslErrors (const QList<QSslError> & errors) {
+    Q_UNUSED (errors)
+}
+
+void QtHttpServer::onClientSslModeChanged (QSslSocket::SslMode mode) {
+    Q_UNUSED (mode)
+}
+
 void QtHttpServer::onClientDisconnected (void) {
-    QTcpSocket * sockClient = qobject_cast<QTcpSocket *> (sender ());
-    if (sockClient) {
-        QtHttpClientWrapper * wrapper = m_socksClientsHash.value (sockClient, Q_NULLPTR);
-        if (wrapper) {
+    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/webconfig/QtHttpServer.h

@@ -4,6 +4,12 @@
 #include <QObject>
 #include <QString>
 #include <QHash>
+#include <QTcpServer>
+#include <QTcpSocket>
+#include <QSslCertificate>
+#include <QSslKey>
+#include <QSslSocket>
+#include <QHostAddress>
 
 class QTcpSocket;
 class QTcpServer;
@@ -12,6 +18,22 @@ class QtHttpRequest;
 class QtHttpReply;
 class QtHttpClientWrapper;
 
+class QtHttpServerWrapper : public QTcpServer {
+    Q_OBJECT
+
+public:
+    explicit QtHttpServerWrapper (QObject * parent = Q_NULLPTR);
+    virtual ~QtHttpServerWrapper (void);
+
+    void setUseSecure (const bool ssl = true);
+
+protected:
+    void incomingConnection (qintptr handle) Q_DECL_OVERRIDE;
+
+private:
+    bool m_useSsl;
+};
+
 class QtHttpServer : public QObject {
     Q_OBJECT
 
@@ -19,14 +41,21 @@ public:
     explicit QtHttpServer (QObject * parent = Q_NULLPTR);
 
     static const QString & HTTP_VERSION;
+
+    typedef void (QSslSocket::* SslErrorSignal) (const QList<QSslError> &);
+
     const QString & getServerName (void) const;
-    quint16 getServerPort (void) const;
+
+    quint16 getServerPort  (void) const;
     QString getErrorString (void) const;
 
 public slots:
-    void start         (quint16 port = 0);
-    void stop          (void);
-    void setServerName (const QString & serverName);
+    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);
@@ -37,13 +66,21 @@ signals:
     void requestNeedsReply  (QtHttpRequest * request, QtHttpReply * reply);
 
 private slots:
-    void onClientConnected    (void);
-    void onClientDisconnected (void);
+    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;
-    QTcpServer *                               m_sockServer;
+    QtHttpServerWrapper *                      m_sockServer;
     QHash<QTcpSocket *, QtHttpClientWrapper *> m_socksClientsHash;
 };
 
 #endif // QTHTTPSERVER_H
+