*/
QWebSocketPrivate::~QWebSocketPrivate()
{
- if (state() == QAbstractSocket::ConnectedState)
+ if (m_pSocket)
{
- close(QWebSocketProtocol::CC_GOING_AWAY, tr("Connection closed"));
+ if (state() == QAbstractSocket::ConnectedState)
+ {
+ close(QWebSocketProtocol::CC_GOING_AWAY, tr("Connection closed"));
+ }
+ releaseConnections(m_pSocket);
+ m_pSocket->deleteLater();
+ m_pSocket = Q_NULLPTR;
}
- releaseConnections(m_pSocket);
- m_pSocket->deleteLater();
- m_pSocket = Q_NULLPTR;
}
/*!
*/
void QWebSocketPrivate::abort()
{
- m_pSocket->abort();
+ if (m_pSocket)
+ {
+ m_pSocket->abort();
+ }
}
/*!
*/
QAbstractSocket::SocketError QWebSocketPrivate::error() const
{
- return m_pSocket->error();
+ QAbstracktSocket::SocketError err = QAbstractSocket::OperationError;
+ if (m_pSocket)
+ {
+ err = m_pSocket->error();
+ }
+ return err;
}
/*!
*/
QString QWebSocketPrivate::errorString() const
{
+ QString errMsg;
if (!m_errorString.isEmpty())
{
- return m_errorString;
+ errMsg = m_errorString;
}
- else
+ else if (m_pSocket)
{
- return m_pSocket->errorString();
+ errMsg = m_pSocket->errorString();
}
+ return errMsg;
}
/*!
*/
bool QWebSocketPrivate::flush()
{
- return m_pSocket->flush();
+ bool result = true;
+ if (m_pSocket)
+ {
+ result = m_pSocket->flush();
+ }
+ return result;
}
/*!
*/
void QWebSocketPrivate::close(QWebSocketProtocol::CloseCode closeCode, QString reason)
{
- Q_Q(QWebSocket);
- if (!m_isClosingHandshakeSent)
+ if (m_pSocket)
{
- quint32 maskingKey = 0;
- if (m_mustMask)
+ if (!m_isClosingHandshakeSent)
{
- maskingKey = generateMaskingKey();
- }
- const quint16 code = qToBigEndian<quint16>(closeCode);
- QByteArray payload;
- payload.append(static_cast<const char *>(static_cast<const void *>(&code)), 2);
- if (!reason.isEmpty())
- {
- payload.append(reason.toUtf8());
- }
- if (m_mustMask)
- {
- QWebSocketProtocol::mask(payload.data(), payload.size(), maskingKey);
- }
- QByteArray frame = getFrameHeader(QWebSocketProtocol::OC_CLOSE, payload.size(), maskingKey, true);
- frame.append(payload);
- m_pSocket->write(frame);
- m_pSocket->flush();
+ Q_Q(QWebSocket);
+ quint32 maskingKey = 0;
+ if (m_mustMask)
+ {
+ maskingKey = generateMaskingKey();
+ }
+ const quint16 code = qToBigEndian<quint16>(closeCode);
+ QByteArray payload;
+ payload.append(static_cast<const char *>(static_cast<const void *>(&code)), 2);
+ if (!reason.isEmpty())
+ {
+ payload.append(reason.toUtf8());
+ }
+ if (m_mustMask)
+ {
+ QWebSocketProtocol::mask(payload.data(), payload.size(), maskingKey);
+ }
+ QByteArray frame = getFrameHeader(QWebSocketProtocol::OC_CLOSE, payload.size(), maskingKey, true);
+ frame.append(payload);
+ m_pSocket->write(frame);
+ m_pSocket->flush();
- m_isClosingHandshakeSent = true;
+ m_isClosingHandshakeSent = true;
- Q_EMIT q->aboutToClose();
+ Q_EMIT q->aboutToClose();
+ }
+ m_pSocket->close();
}
- m_pSocket->close();
}
/*!
*/
void QWebSocketPrivate::open(const QUrl &url, bool mask)
{
- Q_Q(QWebSocket);
+ if (!m_pSocket)
+ {
+ Q_Q(QWebSocket);
- m_dataProcessor.clear();
- m_isClosingHandshakeReceived = false;
- m_isClosingHandshakeSent = false;
+ m_dataProcessor.clear();
+ m_isClosingHandshakeReceived = false;
+ m_isClosingHandshakeSent = false;
- setRequestUrl(url);
- QString resourceName = url.path();
- if (!url.query().isEmpty())
- {
- if (!resourceName.endsWith(QChar::fromLatin1('?')))
+ setRequestUrl(url);
+ QString resourceName = url.path();
+ if (!url.query().isEmpty())
{
- resourceName.append(QChar::fromLatin1('?'));
+ if (!resourceName.endsWith(QChar::fromLatin1('?')))
+ {
+ resourceName.append(QChar::fromLatin1('?'));
+ }
+ resourceName.append(url.query());
}
- resourceName.append(url.query());
- }
- if (resourceName.isEmpty())
- {
- resourceName = QStringLiteral("/");
- }
- setResourceName(resourceName);
- enableMasking(mask);
-
-#ifndef QT_NO_SSL
- if (url.scheme() == QStringLiteral("wss"))
- {
- if (!QSslSocket::supportsSsl())
+ if (resourceName.isEmpty())
{
- const QString message = tr("SSL Sockets are not supported on this platform.");
- qWarning() << message;
- setErrorString(message);
- emit q->error(QAbstractSocket::UnsupportedSocketOperationError);
+ resourceName = QStringLiteral("/");
}
- else
- {
- QSslSocket *sslSocket = new QSslSocket(this);
- m_pSocket = sslSocket;
+ setResourceName(resourceName);
+ enableMasking(mask);
- makeConnections(m_pSocket);
- connect(sslSocket, SIGNAL(encryptedBytesWritten(qint64)), q, SIGNAL(bytesWritten(qint64)));
- setSocketState(QAbstractSocket::ConnectingState);
-
- sslSocket->setSslConfiguration(m_sslConfiguration);
- if (m_ignoreSslErrors)
+ #ifndef QT_NO_SSL
+ if (url.scheme() == QStringLiteral("wss"))
+ {
+ if (!QSslSocket::supportsSsl())
{
- sslSocket->ignoreSslErrors();
+ const QString message = tr("SSL Sockets are not supported on this platform.");
+ qWarning() << message;
+ setErrorString(message);
+ emit q->error(QAbstractSocket::UnsupportedSocketOperationError);
}
else
{
- sslSocket->ignoreSslErrors(m_ignoredSslErrors);
+ QSslSocket *sslSocket = new QSslSocket(this);
+ m_pSocket = sslSocket;
+
+ makeConnections(m_pSocket);
+ connect(sslSocket, SIGNAL(encryptedBytesWritten(qint64)), q, SIGNAL(bytesWritten(qint64)));
+ setSocketState(QAbstractSocket::ConnectingState);
+
+ sslSocket->setSslConfiguration(m_sslConfiguration);
+ if (m_ignoreSslErrors)
+ {
+ sslSocket->ignoreSslErrors();
+ }
+ else
+ {
+ sslSocket->ignoreSslErrors(m_ignoredSslErrors);
+ }
+ sslSocket->connectToHostEncrypted(url.host(), url.port(443));
}
- sslSocket->connectToHostEncrypted(url.host(), url.port(443));
}
- }
- else
-#endif
- if (url.scheme() == QStringLiteral("ws"))
- {
- m_pSocket = new QTcpSocket(this);
+ else
+ #endif
+ if (url.scheme() == QStringLiteral("ws"))
+ {
+ m_pSocket = new QTcpSocket(this);
- makeConnections(m_pSocket);
- connect(m_pSocket, SIGNAL(bytesWritten(qint64)), q, SIGNAL(bytesWritten(qint64)));
- setSocketState(QAbstractSocket::ConnectingState);
- m_pSocket->connectToHost(url.host(), url.port(80));
- }
- else
- {
- const QString message = tr("Unsupported websockets scheme: %1").arg(url.scheme());
- qWarning() << message;
- setErrorString(message);
- emit q->error(QAbstractSocket::UnsupportedSocketOperationError);
+ makeConnections(m_pSocket);
+ connect(m_pSocket, SIGNAL(bytesWritten(qint64)), q, SIGNAL(bytesWritten(qint64)));
+ setSocketState(QAbstractSocket::ConnectingState);
+ m_pSocket->connectToHost(url.host(), url.port(80));
+ }
+ else
+ {
+ const QString message = tr("Unsupported websockets scheme: %1").arg(url.scheme());
+ qWarning() << message;
+ setErrorString(message);
+ emit q->error(QAbstractSocket::UnsupportedSocketOperationError);
+ }
}
}
*/
void QWebSocketPrivate::makeConnections(const QTcpSocket *pTcpSocket)
{
+ Q_ASSERT(pTcpSocket);
Q_Q(QWebSocket);
//pass through signals
*/
qint64 QWebSocketPrivate::doWriteFrames(const QByteArray &data, bool isBinary)
{
- Q_Q(QWebSocket);
- const QWebSocketProtocol::OpCode firstOpCode = isBinary ? QWebSocketProtocol::OC_BINARY : QWebSocketProtocol::OC_TEXT;
-
- int numFrames = data.size() / FRAME_SIZE_IN_BYTES;
- QByteArray tmpData(data);
- tmpData.detach();
- char *payload = tmpData.data();
- quint64 sizeLeft = static_cast<quint64>(data.size()) % FRAME_SIZE_IN_BYTES;
- if (sizeLeft)
- {
- ++numFrames;
- }
- if (numFrames == 0) //catch the case where the payload is zero bytes; in that case, we still need to send a frame
- {
- numFrames = 1;
- }
- quint64 currentPosition = 0;
- qint64 bytesWritten = 0;
qint64 payloadWritten = 0;
- quint64 bytesLeft = data.size();
-
- for (int i = 0; i < numFrames; ++i)
+ if (m_pSocket)
{
- quint32 maskingKey = 0;
- if (m_mustMask)
+ Q_Q(QWebSocket);
+ const QWebSocketProtocol::OpCode firstOpCode = isBinary ? QWebSocketProtocol::OC_BINARY : QWebSocketProtocol::OC_TEXT;
+
+ int numFrames = data.size() / FRAME_SIZE_IN_BYTES;
+ QByteArray tmpData(data);
+ tmpData.detach();
+ char *payload = tmpData.data();
+ quint64 sizeLeft = static_cast<quint64>(data.size()) % FRAME_SIZE_IN_BYTES;
+ if (sizeLeft)
{
- maskingKey = generateMaskingKey();
+ ++numFrames;
}
+ if (numFrames == 0) //catch the case where the payload is zero bytes; in that case, we still need to send a frame
+ {
+ numFrames = 1;
+ }
+ quint64 currentPosition = 0;
+ qint64 bytesWritten = 0;
+ quint64 bytesLeft = data.size();
- const bool isLastFrame = (i == (numFrames - 1));
- const bool isFirstFrame = (i == 0);
-
- const quint64 size = qMin(bytesLeft, FRAME_SIZE_IN_BYTES);
- const QWebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode : QWebSocketProtocol::OC_CONTINUE;
-
- //write header
- bytesWritten += m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
-
- //write payload
- if (size > 0)
+ for (int i = 0; i < numFrames; ++i)
{
- char *currentData = payload + currentPosition;
+ quint32 maskingKey = 0;
if (m_mustMask)
{
- QWebSocketProtocol::mask(currentData, size, maskingKey);
- }
- qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
- if (written > 0)
- {
- bytesWritten += written;
- payloadWritten += written;
+ maskingKey = generateMaskingKey();
}
- else
+
+ const bool isLastFrame = (i == (numFrames - 1));
+ const bool isFirstFrame = (i == 0);
+
+ const quint64 size = qMin(bytesLeft, FRAME_SIZE_IN_BYTES);
+ const QWebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode : QWebSocketProtocol::OC_CONTINUE;
+
+ //write header
+ bytesWritten += m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
+
+ //write payload
+ if (size > 0)
{
- setErrorString(tr("Error writing bytes to socket: %1.").arg(m_pSocket->errorString()));
- qDebug() << errorString();
- m_pSocket->flush();
- Q_EMIT q->error(QAbstractSocket::NetworkError);
- break;
+ char *currentData = payload + currentPosition;
+ if (m_mustMask)
+ {
+ QWebSocketProtocol::mask(currentData, size, maskingKey);
+ }
+ qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
+ if (written > 0)
+ {
+ bytesWritten += written;
+ payloadWritten += written;
+ }
+ else
+ {
+ setErrorString(tr("Error writing bytes to socket: %1.").arg(m_pSocket->errorString()));
+ qDebug() << errorString();
+ m_pSocket->flush();
+ Q_EMIT q->error(QAbstractSocket::NetworkError);
+ break;
+ }
}
+ currentPosition += size;
+ bytesLeft -= size;
+ }
+ if (payloadWritten != data.size())
+ {
+ setErrorString(tr("Bytes written %1 != %2.").arg(payloadWritten).arg(data.size()));
+ qDebug() << errorString();
+ Q_EMIT q->error(QAbstractSocket::NetworkError);
}
- currentPosition += size;
- bytesLeft -= size;
- }
- if (payloadWritten != data.size())
- {
- setErrorString(tr("Bytes written %1 != %2.").arg(payloadWritten).arg(data.size()));
- qDebug() << errorString();
- Q_EMIT q->error(QAbstractSocket::NetworkError);
}
return payloadWritten;
}
*/
qint64 QWebSocketPrivate::writeFrame(const QByteArray &frame)
{
- return m_pSocket->write(frame);
+ qint64 written = 0;
+ if (m_pSocket)
+ {
+ written = m_pSocket->write(frame);
+ }
+ return written;
}
/*!
*/
QString readLine(QTcpSocket *pSocket)
{
+ Q_ASSERT(pSocket);
QString line;
char c;
while (pSocket->getChar(&c))
*/
void QWebSocketPrivate::processStateChanged(QAbstractSocket::SocketState socketState)
{
+ Q_ASSERT(m_pSocket);
Q_Q(QWebSocket);
QAbstractSocket::SocketState webSocketState = this->state();
switch (socketState)
*/
void QWebSocketPrivate::processData()
{
+ Q_ASSERT(m_pSocket);
while (m_pSocket->bytesAvailable())
{
if (state() == QAbstractSocket::ConnectingState)
*/
void QWebSocketPrivate::processPing(QByteArray data)
{
+ Q_ASSERT(m_pSocket);
quint32 maskingKey = 0;
if (m_mustMask)
{
*/
bool QWebSocketPrivate::waitForConnected(int msecs)
{
- return m_pSocket->waitForConnected(msecs);
+ bool result = false;
+ if (m_pSocket)
+ {
+ result = m_pSocket->waitForConnected(msecs);
+ }
+ return result;
}
/*!
*/
bool QWebSocketPrivate::waitForDisconnected(int msecs)
{
- return m_pSocket->waitForDisconnected(msecs);
+ bool result = false;
+ if (m_pSocket)
+ {
+ result = m_pSocket->waitForDisconnected(msecs);
+ }
+ return result;
}
/*!
*/
QHostAddress QWebSocketPrivate::localAddress() const
{
- return m_pSocket->localAddress();
+ QHostAddress address;
+ if (m_pSocket)
+ {
+ address = m_pSocket->localAddress();
+ }
+ return address;
}
/*!
*/
quint16 QWebSocketPrivate::localPort() const
{
- return m_pSocket->localPort();
+ quint16 port = 0;
+ if (m_pSocket)
+ {
+ port = m_pSocket->localPort();
+ }
+ return port;
}
/*!
*/
QAbstractSocket::PauseModes QWebSocketPrivate::pauseMode() const
{
- return m_pSocket->pauseMode();
+ QAbstractSocket::PauseModes mode = QAbstractSocket::PauseNever;
+ if (m_pSocket)
+ {
+ mode = m_pSocket->pauseMode();
+ }
+ return mode;
}
/*!
*/
QHostAddress QWebSocketPrivate::peerAddress() const
{
- return m_pSocket->peerAddress();
+ QHostAddress address;
+ if (m_pSocket)
+ {
+ address = m_pSocket->peerAddress();
+ }
+ return address;
}
/*!
*/
QString QWebSocketPrivate::peerName() const
{
- return m_pSocket->peerName();
+ QString name;
+ if (m_pSocket)
+ {
+ name = m_pSocket->peerName();
+ }
+ return name;
}
/*!
*/
quint16 QWebSocketPrivate::peerPort() const
{
- return m_pSocket->peerPort();
+ quint16 port = 0;
+ if (m_pSocket)
+ {
+ port = m_pSocket->peerPort();
+ }
+ return port;
}
/*!
*/
QNetworkProxy QWebSocketPrivate::proxy() const
{
- return m_pSocket->proxy();
+ QNetworkProxy proxy;
+ if (m_pSocket)
+ {
+ proxy = m_pSocket->proxy();
+ }
+ return proxy;
}
/*!
*/
qint64 QWebSocketPrivate::readBufferSize() const
{
- return m_pSocket->readBufferSize();
+ qint64 size = 0;
+ if (m_pSocket)
+ {
+ size = m_pSocket->readBufferSize();
+ }
+ return size;
}
/*!
*/
void QWebSocketPrivate::resume()
{
- m_pSocket->resume();
+ if (m_pSocket)
+ {
+ m_pSocket->resume();
+ }
}
/*!
*/
void QWebSocketPrivate::setPauseMode(QAbstractSocket::PauseModes pauseMode)
{
- m_pSocket->setPauseMode(pauseMode);
+ if (m_pSocket)
+ {
+ m_pSocket->setPauseMode(pauseMode);
+ }
}
/*!
*/
void QWebSocketPrivate::setProxy(const QNetworkProxy &networkProxy)
{
- m_pSocket->setProxy(networkProxy);
+ if (m_pSocket)
+ {
+ m_pSocket->setProxy(networkProxy);
+ }
}
/*!
*/
void QWebSocketPrivate::setReadBufferSize(qint64 size)
{
- m_pSocket->setReadBufferSize(size);
+ if (m_pSocket)
+ {
+ m_pSocket->setReadBufferSize(size);
+ }
}
/*!
*/
void QWebSocketPrivate::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
{
- m_pSocket->setSocketOption(option, value);
+ if (m_pSocket)
+ {
+ m_pSocket->setSocketOption(option, value);
+ }
}
/*!
*/
QVariant QWebSocketPrivate::socketOption(QAbstractSocket::SocketOption option)
{
- return m_pSocket->socketOption(option);
+ QVariant val;
+ if (m_pSocket)
+ {
+ val = m_pSocket->socketOption(option);
+ }
+ return val;
}
/*!
*/
bool QWebSocketPrivate::isValid() const
{
- return m_pSocket->isValid();
+ return (m_pSocket && m_pSocket->isValid());
}
QT_END_NAMESPACE
projects / contrib / qtwebsockets.git / commitdiff