QWebSocket::QWebSocket(const QString &origin,
QWebSocketProtocol::Version version,
QObject *parent) :
- QObject(parent),
- d_ptr(new QWebSocketPrivate(origin, version, this, this))
+ QObject(*(new QWebSocketPrivate(origin, version, this)), parent)
{
}
*/
QWebSocket::~QWebSocket()
{
- delete d_ptr;
}
/*!
*/
QWebSocket::QWebSocket(QTcpSocket *pTcpSocket,
QWebSocketProtocol::Version version, QObject *parent) :
- QObject(parent),
- d_ptr(new QWebSocketPrivate(pTcpSocket, version, this, this))
+ QObject(*(new QWebSocketPrivate(pTcpSocket, version, this)), parent)
{
}
private:
QWebSocket(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version,
QObject *parent = Q_NULLPTR);
- QWebSocketPrivate * const d_ptr;
};
QT_END_NAMESPACE
\internal
*/
QWebSocketPrivate::QWebSocketPrivate(const QString &origin, QWebSocketProtocol::Version version,
- QWebSocket *pWebSocket, QObject *parent) :
- QObject(parent),
+ QWebSocket *pWebSocket) :
+ QObjectPrivate(),
q_ptr(pWebSocket),
m_pSocket(),
m_errorString(QWebSocket::tr("Unknown error")),
\internal
*/
QWebSocketPrivate::QWebSocketPrivate(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version,
- QWebSocket *pWebSocket, QObject *parent) :
- QObject(parent),
+ QWebSocket *pWebSocket) :
+ QObjectPrivate(),
q_ptr(pWebSocket),
m_pSocket(pTcpSocket),
m_errorString(pTcpSocket->errorString()),
if (!m_pSocket)
return;
if (state() == QAbstractSocket::ConnectedState)
- close(QWebSocketProtocol::CloseCodeGoingAway, tr("Connection closed"));
+ close(QWebSocketProtocol::CloseCodeGoingAway, QWebSocket::tr("Connection closed"));
releaseConnections(m_pSocket.data());
}
#ifndef QT_NO_SSL
if (url.scheme() == QStringLiteral("wss")) {
if (!QSslSocket::supportsSsl()) {
- const QString message = tr("SSL Sockets are not supported on this platform.");
+ const QString message =
+ QWebSocket::tr("SSL Sockets are not supported on this platform.");
setErrorString(message);
Q_EMIT q->error(QAbstractSocket::UnsupportedSocketOperationError);
} else {
- QSslSocket *sslSocket = new QSslSocket(this);
+ QSslSocket *sslSocket = new QSslSocket(q);
m_pSocket.reset(sslSocket);
if (Q_LIKELY(m_pSocket)) {
m_pSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
m_pSocket->setPauseMode(m_pauseMode);
makeConnections(m_pSocket.data());
- connect(sslSocket, &QSslSocket::encryptedBytesWritten, q,
- &QWebSocket::bytesWritten);
+ QObject::connect(sslSocket, &QSslSocket::encryptedBytesWritten, q,
+ &QWebSocket::bytesWritten);
setSocketState(QAbstractSocket::ConnectingState);
sslSocket->setSslConfiguration(m_configuration.m_sslConfiguration);
#endif
sslSocket->connectToHostEncrypted(url.host(), url.port(443));
} else {
- const QString message = tr("Out of memory.");
+ const QString message = QWebSocket::tr("Out of memory.");
setErrorString(message);
Q_EMIT q->error(QAbstractSocket::SocketResourceError);
}
} else
#endif
if (url.scheme() == QStringLiteral("ws")) {
- m_pSocket.reset(new QTcpSocket(this));
+ m_pSocket.reset(new QTcpSocket(q));
if (Q_LIKELY(m_pSocket)) {
m_pSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
m_pSocket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
m_pSocket->setPauseMode(m_pauseMode);
makeConnections(m_pSocket.data());
- connect(m_pSocket.data(), &QAbstractSocket::bytesWritten, q,
- &QWebSocket::bytesWritten);
+ QObject::connect(m_pSocket.data(), &QAbstractSocket::bytesWritten, q,
+ &QWebSocket::bytesWritten);
setSocketState(QAbstractSocket::ConnectingState);
#ifndef QT_NO_NETWORKPROXY
m_pSocket->setProxy(m_configuration.m_proxy);
#endif
m_pSocket->connectToHost(url.host(), url.port(80));
} else {
- const QString message = tr("Out of memory.");
+ const QString message = QWebSocket::tr("Out of memory.");
setErrorString(message);
Q_EMIT q->error(QAbstractSocket::SocketResourceError);
}
} else {
- const QString message = tr("Unsupported websockets scheme: %1").arg(url.scheme());
+ const QString message =
+ QWebSocket::tr("Unsupported websockets scheme: %1").arg(url.scheme());
setErrorString(message);
Q_EMIT q->error(QAbstractSocket::UnsupportedSocketOperationError);
}
//pass through signals
typedef void (QAbstractSocket:: *ASErrorSignal)(QAbstractSocket::SocketError);
typedef void (QWebSocket:: *WSErrorSignal)(QAbstractSocket::SocketError);
- connect(pTcpSocket,
- static_cast<ASErrorSignal>(&QAbstractSocket::error),
- q, static_cast<WSErrorSignal>(&QWebSocket::error));
- connect(pTcpSocket, &QAbstractSocket::proxyAuthenticationRequired, q,
- &QWebSocket::proxyAuthenticationRequired);
- connect(pTcpSocket, &QAbstractSocket::readChannelFinished, q,
- &QWebSocket::readChannelFinished);
- connect(pTcpSocket, &QAbstractSocket::aboutToClose, q, &QWebSocket::aboutToClose);
+ QObject::connect(pTcpSocket,
+
static_cast<ASErrorSignal>(&QAbstractSocket::error),
+ q, static_cast<WSErrorSignal>(&QWebSocket::error));
+ QObject::connect(pTcpSocket, &QAbstractSocket::proxyAuthenticationRequired, q,
+ &QWebSocket::proxyAuthenticationRequired);
+ QObject::connect(pTcpSocket, &QAbstractSocket::readChannelFinished, q,
+ &QWebSocket::readChannelFinished);
+ QObject::connect(pTcpSocket, &QAbstractSocket::aboutToClose, q, &QWebSocket::aboutToClose);
//catch signals
- connect(pTcpSocket, &QAbstractSocket::stateChanged, this,
- &QWebSocketPrivate::processStateChanged);
+ QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::stateChanged, this,
+ &QWebSocketPrivate::processStateChanged);
//!!!important to use a QueuedConnection here;
//with QTcpSocket there is no problem, but with QSslSocket the processing hangs
- connect(pTcpSocket, &QAbstractSocket::readyRead, this,
- &QWebSocketPrivate::processData, Qt::QueuedConnection);
+ QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::readyRead, this,
+ &QWebSocketPrivate::processData, Qt::QueuedConnection);
}
- connect(&m_dataProcessor, &QWebSocketDataProcessor::textFrameReceived, q,
- &QWebSocket::textFrameReceived);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryFrameReceived, q,
- &QWebSocket::binaryFrameReceived);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryMessageReceived, q,
- &QWebSocket::binaryMessageReceived);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::textMessageReceived, q,
- &QWebSocket::textMessageReceived);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::errorEncountered, this,
- &QWebSocketPrivate::close);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::pingReceived, this,
- &QWebSocketPrivate::processPing);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::pongReceived, this,
- &QWebSocketPrivate::processPong);
- connect(&m_dataProcessor, &QWebSocketDataProcessor::closeReceived, this,
- &QWebSocketPrivate::processClose);
+ QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::textFrameReceived, q,
+ &QWebSocket::textFrameReceived);
+ QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryFrameReceived, q,
+ &QWebSocket::binaryFrameReceived);
+ QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryMessageReceived, q,
+ &QWebSocket::binaryMessageReceived);
+ QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::textMessageReceived, q,
+ &QWebSocket::textMessageReceived);
+ QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::errorEncountered, this,
+ &QWebSocketPrivate::close);
+ QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::pingReceived, this,
+ &QWebSocketPrivate::processPing);
+ QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::pongReceived, this,
+ &QWebSocketPrivate::processPong);
+ QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::closeReceived, this,
+ &QWebSocketPrivate::processClose);
}
/*!
void QWebSocketPrivate::releaseConnections(const QTcpSocket *pTcpSocket)
{
if (Q_LIKELY(pTcpSocket))
- disconnect(pTcpSocket);
- disconnect(&m_dataProcessor);
+ pTcpSocket->disconnect(pTcpSocket);
+ m_dataProcessor.disconnect(&m_dataProcessor);
}
/*!
payloadWritten += written;
} else {
m_pSocket->flush();
- setErrorString(tr("Error writing bytes to socket: %1.")
+ setErrorString(QWebSocket::tr("Error writing bytes to socket: %1.")
.arg(m_pSocket->errorString()));
Q_EMIT q->error(QAbstractSocket::NetworkError);
break;
bytesLeft -= size;
}
if (Q_UNLIKELY(payloadWritten != data.size())) {
- setErrorString(tr("Bytes written %1 != %2.").arg(payloadWritten).arg(data.size()));
+ setErrorString(QWebSocket::tr("Bytes written %1 != %2.")
+ .arg(payloadWritten).arg(data.size()));
Q_EMIT q->error(QAbstractSocket::NetworkError);
}
return payloadWritten;
}
}
if (Q_UNLIKELY(!ok)) {
- errorDescription = tr("Invalid statusline in response: %1.").arg(statusLine);
+ errorDescription = QWebSocket::tr("Invalid statusline in response: %1.").arg(statusLine);
} else {
QString headerLine = readLine(pSocket);
QMap<QString, QString> headers;
ok = (accept == acceptKey);
if (!ok)
errorDescription =
- tr("Accept-Key received from server %1 does not match the client key %2.")
+ QWebSocket::tr("Accept-Key received from server %1 does not match the client key %2.")
.arg(acceptKey).arg(accept);
} else {
errorDescription =
- tr("QWebSocketPrivate::processHandshake: Invalid statusline in response: %1.")
+ QWebSocket::tr("QWebSocketPrivate::processHandshake: Invalid statusline in response: %1.")
.arg(statusLine);
}
} else if (httpStatusCode == 400) {
//if needed to switch protocol version, then we are finished here
//because we cannot handle other protocols than the RFC one (v13)
errorDescription =
- tr("Handshake: Server requests a version that we don't support: %1.")
+ QWebSocket::tr("Handshake: Server requests a version that we don't support: %1.")
.arg(versions.join(QStringLiteral(", ")));
ok = false;
} else {
//we tried v13, but something different went wrong
errorDescription =
- tr("QWebSocketPrivate::processHandshake: Unknown error condition " \
- "encountered. Aborting connection.");
+ QWebSocket::tr("QWebSocketPrivate::processHandshake: Unknown error condition encountered. Aborting connection.");
ok = false;
}
}
} else {
errorDescription =
- tr("QWebSocketPrivate::processHandshake: Unhandled http status code: %1 (%2).")
- .arg(httpStatusCode).arg(httpStatusMessage);
+ QWebSocket::tr("QWebSocketPrivate::processHandshake: Unhandled http status code: %1 (%2).")
+ .arg(httpStatusCode).arg(httpStatusMessage);
ok = false;
}
#include <QtNetwork/QSslSocket>
#endif
#include <QtCore/QTime>
+#include <private/qobject_p.h>
#include "qwebsocketprotocol.h"
#include "qwebsocketdataprocessor_p.h"
QTcpSocket *m_pSocket;
};
-class QWebSocketPrivate : public QObject
+class QWebSocketPrivate : public QObjectPrivate
{
- Q_OBJECT
Q_DISABLE_COPY(QWebSocketPrivate)
- Q_DECLARE_PUBLIC(QWebSocket)
public:
+ Q_DECLARE_PUBLIC(QWebSocket)
explicit QWebSocketPrivate(const QString &origin,
QWebSocketProtocol::Version version,
- QWebSocket * const pWebSocket,
- QObject *parent = Q_NULLPTR);
+ QWebSocket * const pWebSocket);
virtual ~QWebSocketPrivate();
void init();
#ifndef QT_NO_SSL
void ignoreSslErrors(const QList<QSslError> &errors);
+ void ignoreSslErrors();
void setSslConfiguration(const QSslConfiguration &sslConfiguration);
QSslConfiguration sslConfiguration() const;
#endif
-public Q_SLOTS:
void close(QWebSocketProtocol::CloseCode closeCode, QString reason);
void open(const QUrl &url, bool mask);
void ping(const QByteArray &payload);
-#ifndef QT_NO_SSL
- void ignoreSslErrors();
-#endif
-
-private Q_SLOTS:
- void processData();
- void processPing(const QByteArray &data);
- void processPong(const QByteArray &data);
- void processClose(QWebSocketProtocol::CloseCode closeCode, QString closeReason);
- void processHandshake(QTcpSocket *pSocket);
- void processStateChanged(QAbstractSocket::SocketState socketState);
-
-private:
QWebSocket * const q_ptr;
+private:
QWebSocketPrivate(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version,
- QWebSocket *pWebSocket, QObject *parent = Q_NULLPTR);
+ QWebSocket *pWebSocket);
void setVersion(QWebSocketProtocol::Version version);
void setResourceName(const QString &resourceName);
void setRequestUrl(const QUrl &requestUrl);
void setSocketState(QAbstractSocket::SocketState state);
void setErrorString(const QString &errorString);
+ void processData();
+ void processPing(const QByteArray &data);
+ void processPong(const QByteArray &data);
+ void processClose(QWebSocketProtocol::CloseCode closeCode, QString closeReason);
+ void processHandshake(QTcpSocket *pSocket);
+ void processStateChanged(QAbstractSocket::SocketState socketState);
+
qint64 doWriteFrames(const QByteArray &data, bool isBinary) Q_REQUIRED_RESULT;
void makeConnections(const QTcpSocket *pTcpSocket);
*/
QWebSocketServer::QWebSocketServer(const QString &serverName, SslMode secureMode,
QObject *parent) :
- QObject(parent),
- d_ptr(new QWebSocketServerPrivate(serverName,
+ QObject(*(new QWebSocketServerPrivate(serverName,
#ifndef QT_NO_SSL
(secureMode == SecureMode) ?
QWebSocketServerPrivate::SecureMode :
#else
QWebSocketServerPrivate::NonSecureMode,
#endif
- this,
- this))
+ this)), parent)
{
#ifdef QT_NO_SSL
Q_UNUSED(secureMode)
*/
QWebSocketServer::~QWebSocketServer()
{
- delete d_ptr;
}
/*!
void sslErrors(const QList<QSslError> &errors);
#endif
void closed();
-
-private:
- QWebSocketServerPrivate * const d_ptr;
};
QT_END_NAMESPACE
*/
QWebSocketServerPrivate::QWebSocketServerPrivate(const QString &serverName,
QWebSocketServerPrivate::SslMode secureMode,
- QWebSocketServer * const pWebSocketServer,
- QObject *parent) :
- QObject(parent),
+ QWebSocketServer * const pWebSocketServer) :
+ QObjectPrivate(),
q_ptr(pWebSocketServer),
m_pTcpServer(Q_NULLPTR),
m_serverName(serverName),
{
Q_ASSERT(pWebSocketServer);
if (m_secureMode == NonSecureMode) {
- m_pTcpServer = new QTcpServer(this);
+ m_pTcpServer = new QTcpServer();
if (Q_LIKELY(m_pTcpServer))
- connect(m_pTcpServer, &QTcpServer::newConnection,
- this, &QWebSocketServerPrivate::onNewConnection);
+ QObjectPrivate::connect(m_pTcpServer, &QTcpServer::newConnection,
+ this, &QWebSocketServerPrivate::onNewConnection);
else
qFatal("Could not allocate memory for tcp server.");
} else {
#ifndef QT_NO_SSL
- QSslServer *pSslServer = new QSslServer(this);
+ QSslServer *pSslServer = new QSslServer();
m_pTcpServer = pSslServer;
if (Q_LIKELY(m_pTcpServer)) {
- connect(pSslServer, &QSslServer::newEncryptedConnection,
- this, &QWebSocketServerPrivate::onNewConnection);
- connect(pSslServer, &QSslServer::peerVerifyError,
- q_ptr, &QWebSocketServer::peerVerifyError);
- connect(pSslServer, &QSslServer::sslErrors,
- q_ptr, &QWebSocketServer::sslErrors);
+ QObjectPrivate::connect(pSslServer, &QSslServer::newEncryptedConnection,
+ this, &QWebSocketServerPrivate::onNewConnection);
+ QObject::connect(pSslServer, &QSslServer::peerVerifyError,
+ q_ptr, &QWebSocketServer::peerVerifyError);
+ QObject::connect(pSslServer, &QSslServer::sslErrors,
+ q_ptr, &QWebSocketServer::sslErrors);
}
#else
qFatal("SSL not supported on this platform.");
#endif
}
- connect(m_pTcpServer, &QTcpServer::acceptError, q_ptr, &QWebSocketServer::acceptError);
+ QObject::connect(m_pTcpServer, &QTcpServer::acceptError, q_ptr, &QWebSocketServer::acceptError);
}
/*!
m_pTcpServer->close();
while (!m_pendingConnections.isEmpty()) {
QWebSocket *pWebSocket = m_pendingConnections.dequeue();
- pWebSocket->close(QWebSocketProtocol::CloseCodeGoingAway, tr("Server closed."));
+ pWebSocket->close(QWebSocketProtocol::CloseCodeGoingAway,
+ QWebSocketServer::tr("Server closed."));
pWebSocket->deleteLater();
}
//emit signal via the event queue, so the server gets time
void QWebSocketServerPrivate::onNewConnection()
{
QTcpSocket *pTcpSocket = m_pTcpServer->nextPendingConnection();
- connect(pTcpSocket, &QTcpSocket::readyRead, this, &QWebSocketServerPrivate::handshakeReceived);
+ QObjectPrivate::connect(pTcpSocket, &QTcpSocket::readyRead,
+ this, &QWebSocketServerPrivate::handshakeReceived);
}
/*!
*/
void QWebSocketServerPrivate::onCloseConnection()
{
- QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
- if (Q_LIKELY(pTcpSocket))
- pTcpSocket->close();
+ if (Q_LIKELY(currentSender)) {
+ QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(currentSender->sender);
+ if (Q_LIKELY(pTcpSocket))
+ pTcpSocket->close();
+ }
}
/*!
*/
void QWebSocketServerPrivate::handshakeReceived()
{
+ if (Q_UNLIKELY(!currentSender)) {
+ qWarning() << QWebSocketServer::tr("Sender is NULL. This is a Qt bug.");
+ return;
+ }
+ QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(currentSender->sender);
+ if (Q_UNLIKELY(!pTcpSocket)) {
+ qWarning() << QWebSocketServer::tr("Sender is not a QTcpSocket. This is a Qt bug!!!");
+ return;
+ }
Q_Q(QWebSocketServer);
- QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
- if (Q_LIKELY(pTcpSocket)) {
- bool success = false;
- bool isSecure = false;
+ bool success = false;
+ bool isSecure = false;
- disconnect(pTcpSocket, &QTcpSocket::readyRead,
- this, &QWebSocketServerPrivate::handshakeReceived);
+ disconnect(pTcpSocket, &QTcpSocket::readyRead,
+ this, &QWebSocketServerPrivate::handshakeReceived);
- if (m_pendingConnections.length() >= maxPendingConnections()) {
- pTcpSocket->close();
- pTcpSocket->deleteLater();
- setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
- tr("Too many pending connections."));
- return;
- }
+ if (m_pendingConnections.length() >= maxPendingConnections()) {
+ pTcpSocket->close();
+ pTcpSocket->deleteLater();
+ qWarning() << QWebSocketServer::tr("Too many pending connections: " \
+ "New websocket connection not accepted.");
+ setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
+ QWebSocketServer::tr("Too many pending connections."));
+ return;
+ }
- QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure);
- QTextStream textStream(pTcpSocket);
- request.readHandshake(textStream);
-
- if (request.isValid()) {
- QWebSocketCorsAuthenticator corsAuthenticator(request.origin());
- Q_EMIT q->originAuthenticationRequired(&corsAuthenticator);
-
- QWebSocketHandshakeResponse response(request,
- m_serverName,
- corsAuthenticator.allowed(),
- supportedVersions(),
- supportedProtocols(),
- supportedExtensions());
-
- if (response.isValid()) {
- QTextStream httpStream(pTcpSocket);
- httpStream << response;
- httpStream.flush();
-
- if (response.canUpgrade()) {
- QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket,
- request,
- response);
- if (pWebSocket) {
- addPendingConnection(pWebSocket);
- Q_EMIT q->newConnection();
- success = true;
- } else {
- setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
- tr("Upgrading to websocket failed."));
- }
- }
- else {
- setError(response.error(), response.errorString());
+ QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure);
+ QTextStream textStream(pTcpSocket);
+ request.readHandshake(textStream);
+
+ if (request.isValid()) {
+ QWebSocketCorsAuthenticator corsAuthenticator(request.origin());
+ Q_EMIT q->originAuthenticationRequired(&corsAuthenticator);
+
+ QWebSocketHandshakeResponse response(request,
+ m_serverName,
+ corsAuthenticator.allowed(),
+ supportedVersions(),
+ supportedProtocols(),
+ supportedExtensions());
+
+ if (response.isValid()) {
+ QTextStream httpStream(pTcpSocket);
+ httpStream << response;
+ httpStream.flush();
+
+ if (response.canUpgrade()) {
+ QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket,
+ request,
+ response);
+ if (pWebSocket) {
+ addPendingConnection(pWebSocket);
+ Q_EMIT q->newConnection();
+ success = true;
+ } else {
+ setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
+ QWebSocketServer::tr("Upgrading to websocket failed."));
}
- } else {
- setError(QWebSocketProtocol::CloseCodeProtocolError, tr("Invalid response received."));
}
+ else {
+ setError(response.error(), response.errorString());
+ }
+ } else {
+ setError(QWebSocketProtocol::CloseCodeProtocolError,
+ QWebSocketServer::tr("Invalid response received."));
}
- if (!success) {
- qWarning() << tr("Closing socket because of invalid or unsupported request.");
- pTcpSocket->close();
- pTcpSocket->deleteLater();
- }
- } else {
- qWarning() <<
- tr("Sender socket is NULL. This should not happen, otherwise it is a Qt bug!!!");
+ }
+ if (!success) {
+ qWarning() << QWebSocketServer::tr("Closing socket because of invalid or unsupported request.");
+ pTcpSocket->close();
}
}
#include <QtCore/QQueue>
#include <QtCore/QString>
#include <QtNetwork/QHostAddress>
+#include <private/qobject_p.h>
#include "qwebsocket.h"
#ifndef QT_NO_SSL
class QTcpServer;
class QWebSocketServer;
-class QWebSocketServerPrivate : public QObject
+class QWebSocketServerPrivate : public QObjectPrivate
{
- Q_OBJECT
Q_DISABLE_COPY(QWebSocketServerPrivate)
- Q_DECLARE_PUBLIC(QWebSocketServer)
public:
+ Q_DECLARE_PUBLIC(QWebSocketServer)
enum SslMode
{
SecureMode = true,
};
explicit QWebSocketServerPrivate(const QString &serverName, SslMode secureMode,
- QWebSocketServer * const pWebSocketServer,
- QObject *parent = Q_NULLPTR);
+ QWebSocketServer * const pWebSocketServer);
virtual ~QWebSocketServerPrivate();
void close();
void setError(QWebSocketProtocol::CloseCode code, const QString &errorString);
-private Q_SLOTS:
- void onNewConnection();
- void onCloseConnection();
- void handshakeReceived();
-
-private:
QWebSocketServer * const q_ptr;
+private:
QTcpServer *m_pTcpServer;
QString m_serverName;
SslMode m_secureMode;
void addPendingConnection(QWebSocket *pWebSocket);
void setErrorFromSocketError(QAbstractSocket::SocketError error,
const QString &errorDescription);
+
+ void onNewConnection();
+ void onCloseConnection();
+ void handshakeReceived();
};
QT_END_NAMESPACE
load(qt_build_config)
TARGET = QtWebSockets
-QT = core network
+QT = core network core-private
TEMPLATE = lib
projects / contrib / qtwebsockets.git / commitdiff