change ports and add ssl configuration

data/config/guhd.conf

@@ -1,14 +1,20 @@
 [JSONRPC]
-port=1234
+port=2222
 interfaces="lo", "all"
 ip="IPv4", "IPv6"
 
-[Webserver]
+[WebServer]
-port=3000
+port=3333
 https=false
+publicFolder=/usr/share/guh-webinterface/public
+
+[WebSocketServer]
+port=4444
+https=false
+
+[SSL-Configuration]
 certificate=/etc/ssl/certs/guhd-certificate.crt
 certificate-key=/etc/ssl/private/guhd-certificate.key
-publicFolder=/usr/share/guh-webinterface/public
 
 [GPIO]
 rf433rx=27

server/jsonrpc/jsonrpcserver.cpp

@@ -51,10 +51,11 @@
 
 #include <QJsonDocument>
 #include <QStringList>
+#include <QSslConfiguration>
 
 namespace guhserver {
 
-JsonRPCServer::JsonRPCServer(QObject *parent):
+JsonRPCServer::JsonRPCServer(const QSslConfiguration &sslConfiguration, QObject *parent):
     JsonHandler(parent),
     #ifdef TESTING_ENABLED
     m_tcpServer(new MockTcpServer(this)),
@@ -62,7 +63,7 @@ JsonRPCServer::JsonRPCServer(QObject *parent):
     m_tcpServer(new TcpServer(this)),
     #endif
     #ifdef WEBSOCKET
-    m_websocketServer(new WebSocketServer(this)),
+    m_websocketServer(new WebSocketServer(sslConfiguration, this)),
     #endif
     m_notificationId(0)
 {

server/jsonrpc/jsonrpcserver.h

@@ -34,6 +34,7 @@
 #include <QString>
 
 class Device;
+class QSslConfiguration;
 
 namespace guhserver {
 #ifdef WEBSOCKET
@@ -50,7 +51,7 @@ class JsonRPCServer: public JsonHandler
 {
     Q_OBJECT
 public:
-    JsonRPCServer(QObject *parent = 0);
+    JsonRPCServer(const QSslConfiguration &sslConfiguration = QSslConfiguration(), QObject *parent = 0);
 
     // JsonHandler API implementation
     QString name() const;

server/rest/restserver.cpp

@@ -25,13 +25,14 @@
 #include "guhcore.h"
 
 #include <QJsonDocument>
+#include <QSslConfiguration>
 
 namespace guhserver {
 
-RestServer::RestServer(QObject *parent) :
+RestServer::RestServer(const QSslConfiguration &sslConfiguration, QObject *parent) :
     QObject(parent)
 {
-    m_webserver = new WebServer(this);
+    m_webserver = new WebServer(sslConfiguration, this);
     connect(m_webserver, &WebServer::clientConnected, this, &RestServer::clientConnected);
     connect(m_webserver, &WebServer::clientDisconnected, this, &RestServer::clientDisconnected);
     connect(m_webserver, &WebServer::httpRequestReady, this, &RestServer::processHttpRequest);

server/rest/restserver.h

@@ -34,6 +34,7 @@
 
 class HttpRequest;
 class HttpReply;
+class QSslConfiguration;
 
 namespace guhserver {
 
@@ -41,7 +42,7 @@ class RestServer : public QObject
 {
     Q_OBJECT
 public:
-    explicit RestServer(QObject *parent = 0);
+    explicit RestServer(const QSslConfiguration &sslConfiguration = QSslConfiguration(), QObject *parent = 0);
 
 
 private:

server/servermanager.cpp

@@ -21,16 +21,45 @@
 #include "servermanager.h"
 #include "guhsettings.h"
 
+#include <QSslCertificate>
+#include <QSslConfiguration>
+#include <QSslKey>
+
 namespace guhserver {
 
 ServerManager::ServerManager(QObject *parent) :
-    QObject(parent)
+    QObject(parent),
+    m_sslConfiguration(QSslConfiguration())
 {
+    // check SSL
+    if (!QSslSocket::supportsSsl()) {
+        qCWarning(dcConnection) << "SSL is not supported/installed on this platform.";
+    } else {
+        qCDebug(dcConnection) << "SSL library version:" << QSslSocket::sslLibraryVersionString();
+
+        // load SSL configuration settings
+        GuhSettings settings(GuhSettings::SettingsRoleGlobal);
+        qCDebug(dcConnection) << "Loading SSL-configuration from" << settings.fileName();
+
+        settings.beginGroup("SSL-Configuration");
+        QString certificateFileName = settings.value("certificate", QVariant("/etc/ssl/certs/guhd-certificate.crt")).toString();
+        QString keyFileName = settings.value("certificate-key", QVariant("/etc/ssl/private/guhd-certificate.key")).toString();
+        settings.endGroup();
+
+        if (!loadCertificate(keyFileName, certificateFileName)) {
+            qCWarning(dcConnection) << "SSL encryption disabled";
+        } else {
+            m_sslConfiguration.setProtocol(QSsl::TlsV1_2);
+            m_sslConfiguration.setPrivateKey(m_certificateKey);
+            m_sslConfiguration.setLocalCertificate(m_certificate);
+        }
+    }
+
     qCDebug(dcApplication) << "Starting JSON RPC Server";
-    m_jsonServer = new JsonRPCServer(this);
+    m_jsonServer = new JsonRPCServer(m_sslConfiguration, this);
 
     qCDebug(dcApplication) << "Starting REST Server";
-    m_restServer = new RestServer(this);
+    m_restServer = new RestServer(m_sslConfiguration, this);
 }
 
 JsonRPCServer *ServerManager::jsonServer() const
@@ -43,4 +72,27 @@ RestServer *ServerManager::restServer() const
     return m_restServer;
 }
 
+bool ServerManager::loadCertificate(const QString &certificateKeyFileName, const QString &certificateFileName)
+{
+    QFile certificateKeyFile(certificateKeyFileName);
+    if (!certificateKeyFile.open(QIODevice::ReadOnly)) {
+        qCWarning(dcWebServer) << "Could not open" << certificateKeyFile.fileName() << ":" << certificateKeyFile.errorString();
+        return false;
+    }
+    m_certificateKey = QSslKey(certificateKeyFile.readAll(), QSsl::Rsa);
+    qCDebug(dcWebServer) << "Loaded successfully private certificate key " << certificateKeyFileName;
+    certificateKeyFile.close();
+
+    QFile certificateFile(certificateFileName);
+    if (!certificateFile.open(QIODevice::ReadOnly)) {
+        qCWarning(dcWebServer) << "Could not open" << certificateFile.fileName() << ":" << certificateFile.errorString();
+        return false;
+    }
+    m_certificate = QSslCertificate(certificateFile.readAll());
+    qCDebug(dcWebServer) << "Loaded successfully certificate file " << certificateFileName;
+    certificateFile.close();
+
+    return true;
+}
+
 }

server/servermanager.h

@@ -27,6 +27,10 @@
 #include "jsonrpc/jsonrpcserver.h"
 #include "rest/restserver.h"
 
+class QSslConfiguration;
+class QSslCertificate;
+class QSslKey;
+
 namespace guhserver {
 
 class ServerManager : public QObject
@@ -42,6 +46,13 @@ private:
     JsonRPCServer *m_jsonServer;
     RestServer *m_restServer;
 
+    QSslConfiguration m_sslConfiguration;
+    QSslKey m_certificateKey;
+    QSslCertificate m_certificate;
+
+
+    bool loadCertificate(const QString &certificateKeyFileName, const QString &certificateFileName);
+
 };
 
 }

server/tcpserver.cpp

@@ -42,11 +42,12 @@ TcpServer::TcpServer(QObject *parent) :
 
     // load JSON-RPC server settings
     GuhSettings settings(GuhSettings::SettingsRoleGlobal);
-    qCDebug(dcTcpServer) << "Loading Tcp server settings from:" << settings.fileName();
+    qCDebug(dcTcpServer) << "Loading Tcp server settings from" << settings.fileName();
     settings.beginGroup("JSONRPC");
 
     // load port
-    m_port = settings.value("port", 1234).toUInt();
+    // 2222 Official free according to https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers
+    m_port = settings.value("port", 2222).toUInt();
 
     // load interfaces
     QStringList interfaceList = settings.value("interfaces", QStringList("all")).toStringList();

server/webserver.cpp

@@ -35,34 +35,32 @@
 
 namespace guhserver {
 
-WebServer::WebServer(QObject *parent) :
+WebServer::WebServer(const QSslConfiguration &sslConfiguration, QObject *parent) :
     QTcpServer(parent),
-    m_enabled(false),
+    m_sslConfiguration(sslConfiguration),
-    m_useSsl(false)
+    m_useSsl(false),
+    m_enabled(false)
 {
     // load webserver settings
     GuhSettings settings(GuhSettings::SettingsRoleGlobal);
-    qCDebug(dcWebSocketServer) << "Loading web socket server settings from:" << settings.fileName();
+    qCDebug(dcWebSocketServer) << "Loading web socket server settings from" << settings.fileName();
 
-    settings.beginGroup("WebSocketServer");
+    settings.beginGroup("WebServer");
-    m_port = settings.value("port", 3000).toInt();
+    // 3333 Official free according to https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers
+    m_port = settings.value("port", 3333).toInt();
     m_useSsl = settings.value("https", false).toBool();
-    QString certificateFileName = settings.value("certificate", QVariant("/etc/ssl/certs/guhd-certificate.crt")).toString();
+    m_webinterfaceDir = QDir(settings.value("publicFolder", "/usr/share/guh-webinterface/public/").toString());
-    QString keyFileName = settings.value("certificate-key", QVariant("/etc/ssl/private/guhd-certificate.key")).toString();
     settings.endGroup();
 
-    // check SSL
+    // check public directory
-    if (m_useSsl && !QSslSocket::supportsSsl()) {
+    qCDebug(dcWebServer) << "Publish webinterface folder" << m_webinterfaceDir.path();
-        qCWarning(dcWebServer) << "SSL is not supported/installed on this platform.";
+    if (!m_webinterfaceDir.exists())
-        m_useSsl = false;
+        qCWarning(dcWebServer) << "Web interface public folder" << m_webinterfaceDir.path() << "does not exist.";
-    }
 
-    if (m_useSsl && !loadCertificate(keyFileName, certificateFileName)) {
+
-        qCWarning(dcWebServer) << "SSL encryption disabled";
+    // check SSL
+    if (m_useSsl && m_sslConfiguration.isNull())
         m_useSsl = false;
-        return;
-    }
-    qCDebug(dcWebServer) << "Using SSL lib version:" << QSslSocket::sslLibraryVersionString();
 }
 
 WebServer::~WebServer()
@@ -74,7 +72,6 @@ void WebServer::sendHttpReply(HttpReply *reply)
 {
     QSslSocket *socket = 0;
     socket = m_clientList.value(reply->clientId());
-
     if (!socket) {
         qCDebug(dcWebServer) << "Invalid socket pointer! This should never happen!!!";
         return;
@@ -132,33 +129,6 @@ QString WebServer::fileName(const QString &query)
     return m_webinterfaceDir.path() + fileName;
 }
 
-bool WebServer::loadCertificate(const QString &keyFileName, const QString &certificateFileName)
-{
-    QByteArray certificateData;
-    QByteArray certificateKeyData;
-
-    QFile certificateKeyFile(keyFileName);
-    if (!certificateKeyFile.open(QIODevice::ReadOnly)) {
-        qCWarning(dcWebServer) << "Could not open" << certificateKeyFile.fileName() << ":" << certificateKeyFile.errorString();
-        return false;
-    }
-    certificateKeyData = certificateKeyFile.readAll();
-    certificateKeyFile.close();
-    qCDebug(dcWebServer) << "Loaded successfully private certificate key.";
-
-    QFile certificateFile(certificateFileName);
-    if (!certificateFile.open(QIODevice::ReadOnly)) {
-        qCWarning(dcWebServer) << "Could not open" << certificateFile.fileName() << ":" << certificateFile.errorString();
-        return false;
-    }
-    certificateData = certificateFile.readAll();
-    certificateFile.close();
-    qCDebug(dcWebServer) << "Loaded successfully certificate file.";
-
-    m_certificate = QSslCertificate(certificateData);
-    m_certificateKey = QSslKey(certificateKeyData, QSsl::Rsa);
-    return true;
-}
 
 void WebServer::writeData(QSslSocket *socket, const QByteArray &data)
 {
@@ -174,6 +144,7 @@ void WebServer::incomingConnection(qintptr socketDescriptor)
     QSslSocket *socket = new QSslSocket();
     if (!socket->setSocketDescriptor(socketDescriptor)) {
         qCWarning(dcConnection) << "Could not set socket descriptor. Rejecting connection.";
+        socket->close();
         delete socket;
         return;
     }
@@ -186,9 +157,7 @@ void WebServer::incomingConnection(qintptr socketDescriptor)
 
     if (m_useSsl) {
         // configure client connection
-        socket->setProtocol(QSsl::TlsV1_2);
+        socket->setSslConfiguration(m_sslConfiguration);
-        socket->setPrivateKey(m_certificateKey);
-        socket->setLocalCertificate(m_certificate);
         connect(socket, SIGNAL(encrypted()), this, SLOT(onEncrypted()));
         socket->startServerEncryption();
         // wait for encrypted connection before continue with this client

server/webserver.h

@@ -28,6 +28,7 @@
 #include <QDir>
 #include <QSslSocket>
 #include <QSslCertificate>
+#include <QSslConfiguration>
 #include <QSslKey>
 
 class HttpRequest;
@@ -42,7 +43,7 @@ class WebServer : public QTcpServer
 {
     Q_OBJECT
 public:
-    explicit WebServer(QObject *parent = 0);
+    explicit WebServer(const QSslConfiguration &sslConfiguration = QSslConfiguration(), QObject *parent = 0);
     ~WebServer();
 
     void sendHttpReply(HttpReply *reply);
@@ -51,18 +52,17 @@ private:
     QHash<QUuid, QSslSocket *> m_clientList;
     QHash<QSslSocket *, HttpRequest> m_incompleteRequests;
 
-    bool m_enabled;
+    QSslConfiguration m_sslConfiguration;
     bool m_useSsl;
+
+    bool m_enabled;
     qint16 m_port;
     QDir m_webinterfaceDir;
-    QSslCertificate m_certificate;
+
-    QSslKey m_certificateKey;
 
     bool verifyFile(QSslSocket *socket, const QString &fileName);
     QString fileName(const QString &query);
 
-    bool loadCertificate(const QString &keyFileName, const QString &certificateFileName);
-
     void writeData(QSslSocket *socket, const QByteArray &data);
 
 protected:

server/websocketserver.cpp

@@ -23,27 +23,30 @@
 #include "loggingcategories.h"
 
 #include <QJsonDocument>
+#include <QSslConfiguration>
 
 namespace guhserver {
 
-WebSocketServer::WebSocketServer(QObject *parent) :
+WebSocketServer::WebSocketServer(const QSslConfiguration &sslConfiguration, QObject *parent) :
     TransportInterface(parent),
-    m_server(0)
+    m_server(0),
+    m_sslConfiguration(sslConfiguration),
+    m_useSsl(false),
+    m_enabled(false)
 {
     // load webserver settings
     GuhSettings settings(GuhSettings::SettingsRoleGlobal);
-    qCDebug(dcWebServer) << "Loading webserver settings from:" << settings.fileName();
+    qCDebug(dcWebServer) << "Loading webserver settings from" << settings.fileName();
 
     settings.beginGroup("WebSocketServer");
-    m_port = settings.value("port", 3001).toInt();
+    // 4444 Official free according to https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers
+    m_port = settings.value("port", 4444).toInt();
     m_useSsl = settings.value("https", false).toBool();
     settings.endGroup();
 
     // check SSL
-    if (m_useSsl && !QSslSocket::supportsSsl()) {
+    if (m_useSsl && m_sslConfiguration.isNull())
-        qCWarning(dcWebServer) << "SSL is not supported/installed on this platform.";
         m_useSsl = false;
-    }
 }
 
 WebSocketServer::~WebSocketServer()
@@ -141,6 +144,7 @@ bool WebSocketServer::startServer()
 
     if (m_useSsl) {
         m_server = new QWebSocketServer("guh", QWebSocketServer::SecureMode, this);
+        m_server->setSslConfiguration(m_sslConfiguration);
     } else {
         m_server = new QWebSocketServer("guh", QWebSocketServer::NonSecureMode, this);
     }
@@ -157,8 +161,6 @@ bool WebSocketServer::startServer()
     } else {
         qCDebug(dcConnection) << "Started websocket server" << m_server->serverName() << QString("on wss://%1:%2").arg(m_server->serverAddress().toString()).arg(m_port);
     }
-    qCDebug(dcWebSocketServer) << "Supported protocol versions" << m_server->supportedVersions();
-
     return true;
 }
 

server/websocketserver.h

@@ -33,13 +33,15 @@
 // Note: WebSocket Protocol from the Internet Engineering Task Force (IETF) -> RFC6455 V13:
 //       http://tools.ietf.org/html/rfc6455
 
+class QSslConfiguration;
+
 namespace guhserver {
 
 class WebSocketServer : public TransportInterface
 {
     Q_OBJECT
 public:
-    explicit WebSocketServer(QObject *parent = 0);
+    explicit WebSocketServer(const QSslConfiguration &sslConfiguration = QSslConfiguration(), QObject *parent = 0);
     ~WebSocketServer();
 
     void sendData(const QUuid &clientId, const QVariantMap &data) override;
@@ -49,8 +51,10 @@ private:
     QWebSocketServer *m_server;
     QHash<QUuid, QWebSocket *> m_clientList;
 
-    bool m_enabled;
+    QSslConfiguration m_sslConfiguration;
     bool m_useSsl;
+
+    bool m_enabled;
     qint16 m_port;
 
 private slots:

tests/auto/auto.pro

@@ -14,6 +14,8 @@ SUBDIRS = versioning \
         restplugins \
         restvendors \
         restrules \
-        websocketserver \
 
+contains(DEFINES, WEBSOCKET){
+    SUBDIRS += websocketserver
+}
 

tests/auto/restdeviceclasses/testrestdeviceclasses.cpp

@@ -70,7 +70,7 @@ void TestRestDeviceClasses::getSupportedDevices()
 
     // Get all devices
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000/api/v1/deviceclasses"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/deviceclasses"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -88,7 +88,7 @@ void TestRestDeviceClasses::getSupportedDevices()
         QVariantMap deviceClassMap = deviceClass.toMap();
         QNetworkRequest request;
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1").arg(deviceClassMap.value("id").toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1").arg(deviceClassMap.value("id").toString())));
         clientSpy.clear();
         QNetworkReply *reply = nam->get(request);
         clientSpy.wait();
@@ -126,10 +126,10 @@ void TestRestDeviceClasses::getActionTypes()
 
     QNetworkRequest request;
     if (!actionTypeId.isNull()) {
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/actiontypes/%2").arg(deviceClassId.toString()).arg(actionTypeId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/actiontypes/%2").arg(deviceClassId.toString()).arg(actionTypeId.toString())));
     } else {
         // Get all actiontypes
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/actiontypes").arg(deviceClassId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/actiontypes").arg(deviceClassId.toString())));
     }
 
     QNetworkReply *reply = nam->get(request);
@@ -164,10 +164,10 @@ void TestRestDeviceClasses::getStateTypes()
 
     QNetworkRequest request;
     if (!stateTypeId.isNull()) {
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/statetypes/%2").arg(deviceClassId.toString()).arg(stateTypeId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/statetypes/%2").arg(deviceClassId.toString()).arg(stateTypeId.toString())));
     } else {
         // Get all actiontypes
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/statetypes").arg(deviceClassId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/statetypes").arg(deviceClassId.toString())));
     }
 
     QNetworkReply *reply = nam->get(request);
@@ -202,10 +202,10 @@ void TestRestDeviceClasses::getEventTypes()
 
     QNetworkRequest request;
     if (!eventTypeId.isNull()) {
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/eventtypes/%2").arg(deviceClassId.toString()).arg(eventTypeId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/eventtypes/%2").arg(deviceClassId.toString()).arg(eventTypeId.toString())));
     } else {
         // Get all actiontypes
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/eventtypes").arg(deviceClassId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/eventtypes").arg(deviceClassId.toString())));
     }
 
     QNetworkReply *reply = nam->get(request);
@@ -249,7 +249,7 @@ void TestRestDeviceClasses::discoverDevices()
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
     // DISCOVER
-    QUrl url(QString("http://localhost:3000/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
+    QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
 
     if (!discoveryParams.isEmpty()) {
         QUrlQuery query;
@@ -277,7 +277,7 @@ void TestRestDeviceClasses::discoverDevices()
     QCOMPARE(foundDevices.count(), resultCount);
 
     // ADD the discovered device
-    request.setUrl(QUrl("http://localhost:3000/api/v1/devices"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/devices"));
     DeviceDescriptorId descriptorId = DeviceDescriptorId(foundDevices.first().toMap().value("id").toString());
     qDebug() << descriptorId;
     params.clear();
@@ -302,7 +302,7 @@ void TestRestDeviceClasses::discoverDevices()
 
     DeviceId deviceId = DeviceId(response.value("deviceId").toString());
 
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
     clientSpy.clear();
     reply = nam->deleteResource(request);
     clientSpy.wait();

tests/auto/restdevices/testrestdevices.cpp

@@ -73,7 +73,7 @@ void TestRestDevices::getConfiguredDevices()
     // Get all devices
     QNetworkRequest request;
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
-    request.setUrl(QUrl("http://localhost:3000/api/v1/devices"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/devices"));
     QNetworkReply *reply;
 
     reply = nam->get(request);
@@ -94,7 +94,7 @@ void TestRestDevices::getConfiguredDevices()
         QVariantMap deviceMap = device.toMap();
         QNetworkRequest request;
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceMap.value("id").toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceMap.value("id").toString())));
         clientSpy.clear();
         QNetworkReply *reply = nam->get(request);
         clientSpy.wait();
@@ -179,7 +179,7 @@ void TestRestDevices::addConfiguredDevice()
     // Get all devices
     QNetworkRequest request;
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-    request.setUrl(QUrl("http://localhost:3000/api/v1/devices"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/devices"));
 
     QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact);
     qDebug() << "sending" << payload;
@@ -204,7 +204,7 @@ void TestRestDevices::addConfiguredDevice()
 
         DeviceId deviceId = DeviceId(response.value("deviceId").toString());
 
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
         clientSpy.clear();
         reply = nam->deleteResource(request);
         clientSpy.wait();
@@ -256,7 +256,7 @@ void TestRestDevices::executeAction()
     QVariantMap payloadMap;
     payloadMap.insert("params", actionParams);
 
-    QNetworkRequest request(QUrl(QString("http://localhost:3000/api/v1/devices/%1/execute/%2").arg(deviceId.toString()).arg(actionTypeId.toString())));
+    QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices/%1/execute/%2").arg(deviceId.toString()).arg(actionTypeId.toString())));
     spy.clear();
     QNetworkReply *reply = nam.post(request, QJsonDocument::fromVariant(payloadMap).toJson(QJsonDocument::Compact));
     spy.wait();
@@ -320,10 +320,10 @@ void TestRestDevices::getStateValue()
     QNetworkRequest request;
 
     if (!stateTypeId.isNull()) {
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1/states/%2").arg(deviceId.toString()).arg(stateTypeId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1/states/%2").arg(deviceId.toString()).arg(stateTypeId.toString())));
     } else {
         // Get all states
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1/states").arg(deviceId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1/states").arg(deviceId.toString())));
     }
     qDebug() << request.url();
 
@@ -418,7 +418,7 @@ void TestRestDevices::editDevices()
     QNetworkAccessManager *nam = new QNetworkAccessManager();
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
-    QNetworkRequest request(QUrl(QString("http://localhost:3000/api/v1/devices")));
+    QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices")));
 
     QNetworkReply *reply = nam->post(request, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact));
     clientSpy.wait();
@@ -440,7 +440,7 @@ void TestRestDevices::editDevices()
     editParams.insert("deviceId", deviceId);
     editParams.insert("deviceParams", newDeviceParams);
 
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
     clientSpy.clear();
     reply = nam->put(request, QJsonDocument::fromVariant(editParams).toJson(QJsonDocument::Compact));
     clientSpy.wait();
@@ -452,7 +452,7 @@ void TestRestDevices::editDevices()
     // if the edit should have been successfull
     if (expectedStatusCode == 200) {
 
-        request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+        request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
         clientSpy.clear();
         reply = nam->get(request);
         clientSpy.wait();
@@ -468,7 +468,7 @@ void TestRestDevices::editDevices()
     }
 
     // delete it
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
     clientSpy.clear();
     reply = nam->deleteResource(request);
     clientSpy.wait();
@@ -508,7 +508,7 @@ void TestRestDevices::editByDiscovery()
     QNetworkAccessManager *nam = new QNetworkAccessManager(this);
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
-    QUrl url(QString("http://localhost:3000/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
+    QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
 
     if (!discoveryParams.isEmpty()) {
         QUrlQuery query;
@@ -534,7 +534,7 @@ void TestRestDevices::editByDiscovery()
     QCOMPARE(foundDevices.count(), resultCount);
 
     // add Discovered Device 1 port 55555
-    request.setUrl(QUrl("http://localhost:3000/api/v1/devices"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/devices"));
     DeviceDescriptorId descriptorId1;
     foreach (const QVariant &descriptor, foundDevices) {
         // find the device with port 55555
@@ -571,7 +571,7 @@ void TestRestDevices::editByDiscovery()
     params.insert("discoveryParams", discoveryParams);
 
     clientSpy.clear();
-    url = QUrl(QString("http://localhost:3000/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
+    url = QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
     QUrlQuery query2;
     query2.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact));
     url.setQuery(query2);
@@ -607,7 +607,7 @@ void TestRestDevices::editByDiscovery()
     params.insert("deviceId", deviceId.toString());
     params.insert("deviceDescriptorId", descriptorId2);
 
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
 
     clientSpy.clear();
     payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact);
@@ -675,7 +675,7 @@ void TestRestDevices::editByDiscovery()
 
 
     // remove added device
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/devices/%1").arg(deviceId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
     clientSpy.clear();
     reply = nam->deleteResource(request);
     clientSpy.wait();

tests/auto/restplugins/testrestplugins.cpp

@@ -57,7 +57,7 @@ void TestRestDeviceClasses::getPlugins()
 
     // Get all plugins
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000/api/v1/plugins"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/plugins"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -74,7 +74,7 @@ void TestRestDeviceClasses::getPlugins()
     // Get each of thouse devices individualy
     foreach (const QVariant &plugin, pluginList) {
         QVariantMap pluginMap = plugin.toMap();
-        QNetworkRequest request(QUrl(QString("http://localhost:3000/api/v1/plugins/%1").arg(pluginMap.value("id").toString())));
+        QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1").arg(pluginMap.value("id").toString())));
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
         clientSpy.clear();
         QNetworkReply *reply = nam->get(request);
@@ -95,7 +95,7 @@ void TestRestDeviceClasses::getPluginConfiguration()
 
     // Get all plugins
     QNetworkRequest request;
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/plugins/%1/configuration").arg(mockPluginId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(mockPluginId.toString())));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -157,7 +157,7 @@ void TestRestDeviceClasses::setPluginConfiguration()
 
     // Get plugin configuration
     QNetworkRequest request;
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -181,7 +181,7 @@ void TestRestDeviceClasses::setPluginConfiguration()
 
     // Set new configuration
     clientSpy.clear();
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
     reply = nam->put(request, QJsonDocument::fromVariant(newConfigurations).toJson(QJsonDocument::Compact));
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -194,7 +194,7 @@ void TestRestDeviceClasses::setPluginConfiguration()
 
     // check new configurations
     clientSpy.clear();
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
     reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -215,7 +215,7 @@ void TestRestDeviceClasses::setPluginConfiguration()
 
     // check new configurations after restart
     clientSpy.clear();
-    request.setUrl(QUrl(QString("http://localhost:3000/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
+    request.setUrl(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(pluginId.toString())));
     reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");

tests/auto/restrules/testrestrules.cpp

@@ -77,7 +77,7 @@ void TestRestRules::cleanupRules()
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
     // Get all rules
-    QNetworkRequest request = QNetworkRequest(QUrl("http://localhost:3000/api/v1/rules"));
+    QNetworkRequest request = QNetworkRequest(QUrl("http://localhost:3333/api/v1/rules"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -95,7 +95,7 @@ void TestRestRules::cleanupRules()
     foreach (const QVariant &rule, rulesList) {
         clientSpy.clear();
         QVariantMap ruleMap = rule.toMap();
-        QNetworkRequest request(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleMap.value("id").toString())));
+        QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleMap.value("id").toString())));
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
         reply = nam->deleteResource(request);
         clientSpy.wait();
@@ -331,7 +331,7 @@ void TestRestRules::addRemoveRules()
 
     // Get rules and verify there is no rule added
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000/api/v1/rules"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/rules"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -348,7 +348,7 @@ void TestRestRules::addRemoveRules()
 
     // ADD rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules")));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules")));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->post(request, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact));
     clientSpy.wait();
@@ -368,7 +368,7 @@ void TestRestRules::addRemoveRules()
 
     // GET rule details
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->get(request);
     clientSpy.wait();
@@ -382,7 +382,7 @@ void TestRestRules::addRemoveRules()
 
     // REMOVE rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->deleteResource(request);
     clientSpy.wait();
@@ -648,7 +648,7 @@ void TestRestRules::editRules()
 
     // Get rules and verify there is no rule added
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000/api/v1/rules"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/rules"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -665,7 +665,7 @@ void TestRestRules::editRules()
 
     // ADD rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules")));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules")));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->post(request, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact));
     clientSpy.wait();
@@ -707,7 +707,7 @@ void TestRestRules::editRules()
 
     // EDIT rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->put(request, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact));
     clientSpy.wait();
@@ -718,7 +718,7 @@ void TestRestRules::editRules()
     if (expectedStatusCode == 200) {
         // get edit rule and verify params
         clientSpy.clear();
-        request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules")));
+        request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules")));
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
         reply = nam->get(request);
         clientSpy.wait();
@@ -732,7 +732,7 @@ void TestRestRules::editRules()
 
     // REMOVE rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->deleteResource(request);
     clientSpy.wait();
@@ -744,7 +744,7 @@ void TestRestRules::editRules()
 
     // check if removed
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleId.toString())));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     reply = nam->get(request);
     clientSpy.wait();
@@ -778,7 +778,7 @@ void TestRestRules::enableDisableRule()
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
     // ADD rule
-    QNetworkRequest request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules")));
+    QNetworkRequest request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules")));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
     QNetworkReply *reply = nam->post(request, QJsonDocument::fromVariant(addRuleParams).toJson(QJsonDocument::Compact));
     clientSpy.wait();
@@ -797,7 +797,7 @@ void TestRestRules::enableDisableRule()
 
     // ENABLE rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1/enable").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1/enable").arg(ruleId.toString())));
     reply = nam->post(request, QByteArray());
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -821,7 +821,7 @@ void TestRestRules::enableDisableRule()
 
     // DISABLE the rule
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1/disable").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1/disable").arg(ruleId.toString())));
     reply = nam->post(request, QByteArray());
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -844,7 +844,7 @@ void TestRestRules::enableDisableRule()
 
     // ENABLE again
     clientSpy.clear();
-    request = QNetworkRequest(QUrl(QString("http://localhost:3000/api/v1/rules/%1/enable").arg(ruleId.toString())));
+    request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/rules/%1/enable").arg(ruleId.toString())));
     reply = nam->post(request, QByteArray());
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -872,7 +872,7 @@ void TestRestRules::getRules()
 
     // Get all rules
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000/api/v1/rules"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/rules"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -890,7 +890,7 @@ void TestRestRules::getRules()
     // Get each of thouse rules individualy
     foreach (const QVariant &rule, rulesList) {
         QVariantMap ruleMap = rule.toMap();
-        QNetworkRequest request(QUrl(QString("http://localhost:3000/api/v1/rules/%1").arg(ruleMap.value("id").toString())));
+        QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleMap.value("id").toString())));
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
         clientSpy.clear();
         QNetworkReply *reply = nam->get(request);

tests/auto/restvendors/testrestvendors.cpp

@@ -52,7 +52,7 @@ void TestRestVendors::getVendors()
 
     // Get all vendors
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000/api/v1/vendors"));
+    request.setUrl(QUrl("http://localhost:3333/api/v1/vendors"));
     QNetworkReply *reply = nam->get(request);
     clientSpy.wait();
     QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
@@ -71,7 +71,7 @@ void TestRestVendors::getVendors()
     // Get each of thouse vendors individualy
     foreach (const QVariant &vendor, vendorList) {
         QVariantMap vendorMap = vendor.toMap();
-        QNetworkRequest request(QUrl(QString("http://localhost:3000/api/v1/vendors/%1").arg(vendorMap.value("id").toString())));
+        QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/vendors/%1").arg(vendorMap.value("id").toString())));
         request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
         clientSpy.clear();
         QNetworkReply *reply = nam->get(request);

tests/auto/webserver/testwebserver.cpp

@@ -63,7 +63,7 @@ private:
 void TestWebserver::httpVersion()
 {
     QTcpSocket *socket = new QTcpSocket(this);
-    socket->connectToHost(QHostAddress("127.0.0.1"), 3000);
+    socket->connectToHost(QHostAddress("127.0.0.1"), 3333);
     bool connected = socket->waitForConnected(1000);
     QVERIFY2(connected, "could not connect to webserver.");
 
@@ -100,7 +100,7 @@ void TestWebserver::multiPackageMessage()
 {
 
     QTcpSocket *socket = new QTcpSocket(this);
-    socket->connectToHost(QHostAddress("127.0.0.1"), 3000);
+    socket->connectToHost(QHostAddress("127.0.0.1"), 3333);
     bool connected = socket->waitForConnected(1000);
     QVERIFY2(connected, "could not connect to webserver.");
 
@@ -173,7 +173,7 @@ void TestWebserver::checkAllowedMethodCall()
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000"));
+    request.setUrl(QUrl("http://localhost:3333"));
     QNetworkReply *reply = 0;
 
     if (method == "GET") {
@@ -242,7 +242,7 @@ void TestWebserver::badRequests()
     QFETCH(int, expectedStatusCode);
 
     QTcpSocket *socket = new QTcpSocket(this);
-    socket->connectToHost(QHostAddress("127.0.0.1"), 3000);
+    socket->connectToHost(QHostAddress("127.0.0.1"), 3333);
     bool connected = socket->waitForConnected(1000);
     QVERIFY2(connected, "could not connect to webserver.");
 
@@ -291,7 +291,7 @@ void TestWebserver::getFiles()
     QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
 
     QNetworkRequest request;
-    request.setUrl(QUrl("http://localhost:3000" + query));
+    request.setUrl(QUrl("http://localhost:3333" + query));
     QNetworkReply *reply = nam->get(request);
 
     clientSpy.wait();

tests/auto/websocketserver/testwebsocketserver.cpp

@@ -54,7 +54,7 @@ void TestWebSocketServer::testHandshake()
 {
     QWebSocket *socket = new QWebSocket("guh tests", QWebSocketProtocol::Version13);
     QSignalSpy spy(socket, SIGNAL(textMessageReceived(QString)));
-    socket->open(QUrl(QStringLiteral("ws://localhost:3001")));
+    socket->open(QUrl(QStringLiteral("ws://localhost:4444")));
     spy.wait();
     QVERIFY2(spy.count() > 0, "Did not get the handshake message upon connect.");
     QJsonDocument jsonDoc = QJsonDocument::fromJson(spy.first().first().toByteArray());
@@ -73,7 +73,7 @@ void TestWebSocketServer::pingTest()
 {
     QWebSocket *socket = new QWebSocket("guh tests", QWebSocketProtocol::Version13);
     QSignalSpy spyConnection(socket, SIGNAL(connected()));
-    socket->open(QUrl(QStringLiteral("ws://localhost:3001")));
+    socket->open(QUrl(QStringLiteral("ws://localhost:4444")));
     spyConnection.wait();
     QVERIFY2(spyConnection.count() > 0, "not connected");
 

tests/auto/websocketserver/websocketserver.pro

@@ -1,9 +1,8 @@
 include(../../../guh.pri)
 include(../autotests.pri)
 
-TARGET = websocketserver
+QT += websockets
+
+TARGET = websocketserver
+SOURCES += testwebsocketserver.cpp
 
-contains(DEFINES, WEBSOCKET){
-    QT += websockets
-    SOURCES += testwebsocketserver.cpp
-}