*/
QWebSocketPrivate::~QWebSocketPrivate()
{
- if (!m_pSocket) {
+ if (!m_pSocket)
return;
- }
- if (state() == QAbstractSocket::ConnectedState) {
+ if (state() == QAbstractSocket::ConnectedState)
close(QWebSocketProtocol::CC_GOING_AWAY, tr("Connection closed"));
- }
releaseConnections(m_pSocket.data());
}
*/
void QWebSocketPrivate::abort()
{
- if (m_pSocket) {
+ if (m_pSocket)
m_pSocket->abort();
- }
}
/*!
QAbstractSocket::SocketError QWebSocketPrivate::error() const
{
QAbstractSocket::SocketError err = QAbstractSocket::OperationError;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
err = m_pSocket->error();
- }
return err;
}
QString QWebSocketPrivate::errorString() const
{
QString errMsg;
- if (!m_errorString.isEmpty()) {
+ if (!m_errorString.isEmpty())
errMsg = m_errorString;
- } else if (m_pSocket) {
+ else if (m_pSocket)
errMsg = m_pSocket->errorString();
- }
return errMsg;
}
bool QWebSocketPrivate::flush()
{
bool result = true;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
result = m_pSocket->flush();
- }
return result;
}
m_configuration.m_ignoreSslErrors = true;
if (Q_LIKELY(m_pSocket)) {
QSslSocket *pSslSocket = qobject_cast<QSslSocket *>(m_pSocket.data());
- if (Q_LIKELY(pSslSocket)) {
+ if (Q_LIKELY(pSslSocket))
pSslSocket->ignoreSslErrors();
- }
}
}
*/
void QWebSocketPrivate::close(QWebSocketProtocol::CloseCode closeCode, QString reason)
{
- if (Q_UNLIKELY(!m_pSocket)) {
+ if (Q_UNLIKELY(!m_pSocket))
return;
- }
if (!m_isClosingHandshakeSent) {
Q_Q(QWebSocket);
quint32 maskingKey = 0;
- if (m_mustMask) {
+ 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()) {
+ if (!reason.isEmpty())
payload.append(reason.toUtf8());
- }
- if (m_mustMask) {
+ 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);
}
resourceName.append(url.query());
}
- if (resourceName.isEmpty()) {
+ if (resourceName.isEmpty())
resourceName = QStringLiteral("/");
- }
setResourceName(resourceName);
enableMasking(mask);
setSocketState(QAbstractSocket::ConnectingState);
sslSocket->setSslConfiguration(m_configuration.m_sslConfiguration);
- if (Q_UNLIKELY(m_configuration.m_ignoreSslErrors)) {
+ if (Q_UNLIKELY(m_configuration.m_ignoreSslErrors))
sslSocket->ignoreSslErrors();
- } else {
+ else
sslSocket->ignoreSslErrors(m_configuration.m_ignoredSslErrors);
- }
#ifndef QT_NO_NETWORKPROXY
sslSocket->setProxy(m_configuration.m_proxy);
#endif
*/
void QWebSocketPrivate::ping(QByteArray payload)
{
- if (payload.length() > 125) {
+ if (payload.length() > 125)
payload.truncate(125);
- }
m_pingTimer.restart();
QByteArray pingFrame = getFrameHeader(QWebSocketProtocol::OC_PING, payload.size(), 0 /*do not mask*/, true);
pingFrame.append(payload);
*/
void QWebSocketPrivate::setVersion(QWebSocketProtocol::Version version)
{
- if (m_version != version) {
+ if (m_version != version)
m_version = version;
- }
}
/*!
*/
void QWebSocketPrivate::setResourceName(const QString &resourceName)
{
- if (m_resourceName != resourceName) {
+ if (m_resourceName != resourceName)
m_resourceName = resourceName;
- }
}
/*!
*/
void QWebSocketPrivate::setRequestUrl(const QUrl &requestUrl)
{
- if (m_requestUrl != requestUrl) {
+ if (m_requestUrl != requestUrl)
m_requestUrl = requestUrl;
- }
}
/*!
*/
void QWebSocketPrivate::setOrigin(const QString &origin)
{
- if (m_origin != origin) {
+ if (m_origin != origin)
m_origin = origin;
- }
}
/*!
*/
void QWebSocketPrivate::setProtocol(const QString &protocol)
{
- if (m_protocol != protocol) {
+ if (m_protocol != protocol)
m_protocol = protocol;
- }
}
/*!
*/
void QWebSocketPrivate::setExtension(const QString &extension)
{
- if (m_extension != extension) {
+ if (m_extension != extension)
m_extension = extension;
- }
}
/*!
*/
void QWebSocketPrivate::enableMasking(bool enable)
{
- if (m_mustMask != enable) {
+ if (m_mustMask != enable)
m_mustMask = enable;
- }
}
/*!
*/
void QWebSocketPrivate::releaseConnections(const QTcpSocket *pTcpSocket)
{
- if (Q_LIKELY(pTcpSocket)) {
+ if (Q_LIKELY(pTcpSocket))
disconnect(pTcpSocket);
- }
disconnect(&m_dataProcessor);
}
header.append(static_cast<char>(byte));
byte = 0x00;
- if (maskingKey != 0) {
+ if (maskingKey != 0)
byte |= 0x80;
- }
if (payloadLength <= 125) {
byte |= static_cast<quint8>(payloadLength);
header.append(static_cast<char>(byte));
qint64 QWebSocketPrivate::doWriteFrames(const QByteArray &data, bool isBinary)
{
qint64 payloadWritten = 0;
- if (Q_UNLIKELY(!m_pSocket)) {
+ if (Q_UNLIKELY(!m_pSocket))
return payloadWritten;
- }
+
Q_Q(QWebSocket);
const QWebSocketProtocol::OpCode firstOpCode = isBinary ?
QWebSocketProtocol::OC_BINARY : QWebSocketProtocol::OC_TEXT;
tmpData.detach();
char *payload = tmpData.data();
quint64 sizeLeft = quint64(data.size()) % FRAME_SIZE_IN_BYTES;
- if (Q_LIKELY(sizeLeft)) {
+ if (Q_LIKELY(sizeLeft))
++numFrames;
- }
+
//catch the case where the payload is zero bytes;
//in this case, we still need to send a frame
- if (Q_UNLIKELY(numFrames == 0)) {
+ if (Q_UNLIKELY(numFrames == 0))
numFrames = 1;
- }
quint64 currentPosition = 0;
qint64 bytesWritten = 0;
quint64 bytesLeft = data.size();
for (int i = 0; i < numFrames; ++i) {
quint32 maskingKey = 0;
- if (m_mustMask) {
+ if (m_mustMask)
maskingKey = generateMaskingKey();
- }
const bool isLastFrame = (i == (numFrames - 1));
const bool isFirstFrame = (i == 0);
//write payload
if (Q_LIKELY(size > 0)) {
char *currentData = payload + currentPosition;
- if (m_mustMask) {
+ if (m_mustMask)
QWebSocketProtocol::mask(currentData, size, maskingKey);
- }
qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
if (Q_LIKELY(written > 0)) {
bytesWritten += written;
qint64 written = 0;
if (Q_LIKELY(m_pSocket)) {
QList<QByteArray>::const_iterator it;
- for (it = frames.cbegin(); it < frames.cend(); ++it) {
+ for (it = frames.cbegin(); it < frames.cend(); ++it)
written += writeFrame(*it);
- }
}
return written;
}
qint64 QWebSocketPrivate::writeFrame(const QByteArray &frame)
{
qint64 written = 0;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
written = m_pSocket->write(frame);
- }
return written;
}
void QWebSocketPrivate::processHandshake(QTcpSocket *pSocket)
{
Q_Q(QWebSocket);
- if (!pSocket) {
+ if (Q_UNLIKELY(!pSocket))
return;
- }
bool ok = false;
QString errorDescription;
if (ok) {
const QString accept = calculateAcceptKey(m_key);
ok = (accept == acceptKey);
- if (!ok) {
+ if (!ok)
errorDescription = 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.").arg(statusLine);
}
Q_ASSERT(m_pSocket);
Q_Q(QWebSocket);
QAbstractSocket::SocketState webSocketState = this->state();
- switch (socketState)
- {
+ switch (socketState) {
case QAbstractSocket::ConnectedState:
- {
if (webSocketState == QAbstractSocket::ConnectingState) {
m_key = generateKey();
const QString handshake = createHandShakeRequest(m_resourceName, m_requestUrl.host() % QStringLiteral(":") % QString::number(m_requestUrl.port(80)), origin(), QStringLiteral(""), QStringLiteral(""), m_key);
m_pSocket->write(handshake.toLatin1());
}
break;
- }
+
case QAbstractSocket::ClosingState:
- {
- if (webSocketState == QAbstractSocket::ConnectedState) {
+ if (webSocketState == QAbstractSocket::ConnectedState)
setSocketState(QAbstractSocket::ClosingState);
- }
break;
- }
+
case QAbstractSocket::UnconnectedState:
- {
if (webSocketState != QAbstractSocket::UnconnectedState) {
setSocketState(QAbstractSocket::UnconnectedState);
Q_EMIT q->disconnected();
}
break;
- }
+
case QAbstractSocket::HostLookupState:
case QAbstractSocket::ConnectingState:
case QAbstractSocket::BoundState:
case QAbstractSocket::ListeningState:
- {
//do nothing
//to make C++ compiler happy;
break;
- }
default:
- {
break;
}
- }
}
//order of events:
{
Q_ASSERT(m_pSocket);
while (m_pSocket->bytesAvailable()) {
- if (state() == QAbstractSocket::ConnectingState) {
+ if (state() == QAbstractSocket::ConnectingState)
processHandshake(m_pSocket.data());
- } else {
+ else
m_dataProcessor.process(m_pSocket.data());
- }
}
}
{
Q_ASSERT(m_pSocket);
quint32 maskingKey = 0;
- if (m_mustMask) {
+ if (m_mustMask)
maskingKey = generateMaskingKey();
- }
m_pSocket->write(getFrameHeader(QWebSocketProtocol::OC_PONG, data.size(), maskingKey, true));
if (data.size() > 0) {
- if (m_mustMask) {
+ if (m_mustMask)
QWebSocketProtocol::mask(&data, maskingKey);
- }
m_pSocket->write(data);
}
}
QStringLiteral("Upgrade: websocket") <<
QStringLiteral("Connection: Upgrade") <<
QStringLiteral("Sec-WebSocket-Key: ") % QString::fromLatin1(key);
- if (!origin.isEmpty()) {
+ if (!origin.isEmpty())
handshakeRequest << QStringLiteral("Origin: ") % origin;
- }
handshakeRequest << QStringLiteral("Sec-WebSocket-Version: ") % QString::number(QWebSocketProtocol::currentVersion());
- if (extensions.length() > 0) {
+ if (extensions.length() > 0)
handshakeRequest << QStringLiteral("Sec-WebSocket-Extensions: ") % extensions;
- }
- if (protocols.length() > 0) {
+ if (protocols.length() > 0)
handshakeRequest << QStringLiteral("Sec-WebSocket-Protocol: ") % protocols;
- }
handshakeRequest << QStringLiteral("\r\n");
return handshakeRequest.join(QStringLiteral("\r\n"));
bool QWebSocketPrivate::waitForConnected(int msecs)
{
bool result = false;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
result = m_pSocket->waitForConnected(msecs);
- }
return result;
}
bool QWebSocketPrivate::waitForDisconnected(int msecs)
{
bool result = false;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
result = m_pSocket->waitForDisconnected(msecs);
- }
return result;
}
*/
void QWebSocketPrivate::setErrorString(const QString &errorString)
{
- if (m_errorString != errorString) {
+ if (m_errorString != errorString)
m_errorString = errorString;
- }
}
/*!
QHostAddress QWebSocketPrivate::localAddress() const
{
QHostAddress address;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
address = m_pSocket->localAddress();
- }
return address;
}
quint16 QWebSocketPrivate::localPort() const
{
quint16 port = 0;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
port = m_pSocket->localPort();
- }
return port;
}
QAbstractSocket::PauseModes QWebSocketPrivate::pauseMode() const
{
QAbstractSocket::PauseModes mode = QAbstractSocket::PauseNever;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
mode = m_pSocket->pauseMode();
- }
return mode;
}
QHostAddress QWebSocketPrivate::peerAddress() const
{
QHostAddress address;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
address = m_pSocket->peerAddress();
- }
return address;
}
QString QWebSocketPrivate::peerName() const
{
QString name;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
name = m_pSocket->peerName();
- }
return name;
}
quint16 QWebSocketPrivate::peerPort() const
{
quint16 port = 0;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
port = m_pSocket->peerPort();
- }
return port;
}
*/
void QWebSocketPrivate::setProxy(const QNetworkProxy &networkProxy)
{
- if (networkProxy != networkProxy) {
+ if (networkProxy != networkProxy)
m_configuration.m_proxy = networkProxy;
- }
}
#endif //QT_NO_NETWORKPROXY
qint64 QWebSocketPrivate::readBufferSize() const
{
qint64 size = 0;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
size = m_pSocket->readBufferSize();
- }
return size;
}
*/
void QWebSocketPrivate::resume()
{
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
m_pSocket->resume();
- }
}
/*!
*/
void QWebSocketPrivate::setPauseMode(QAbstractSocket::PauseModes pauseMode)
{
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
m_pSocket->setPauseMode(pauseMode);
- }
}
/*!
*/
void QWebSocketPrivate::setReadBufferSize(qint64 size)
{
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
m_pSocket->setReadBufferSize(size);
- }
}
/*!
*/
void QWebSocketPrivate::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
{
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
m_pSocket->setSocketOption(option, value);
- }
}
/*!
QVariant QWebSocketPrivate::socketOption(QAbstractSocket::SocketOption option)
{
QVariant val;
- if (Q_LIKELY(m_pSocket)) {
+ if (Q_LIKELY(m_pSocket))
val = m_pSocket->socketOption(option);
- }
return val;
}
*/
void QWebSocketCorsAuthenticator::swap(QWebSocketCorsAuthenticator &other)
{
- if (&other != this) {
+ if (&other != this)
qSwap(d_ptr, other.d_ptr);
- }
}
/*!
}
if (frame.isFinalFrame()) {
- if (m_opCode == QWebSocketProtocol::OC_TEXT) {
+ if (m_opCode == QWebSocketProtocol::OC_TEXT)
Q_EMIT textMessageReceived(m_textMessage);
- } else {
+ else
Q_EMIT binaryMessageReceived(m_binaryMessage);
- }
clear();
isDone = true;
}
}
}
if (!m_pConverterState)
- {
m_pConverterState = new QTextCodec::ConverterState(QTextCodec::ConvertInvalidToNull | QTextCodec::IgnoreHeader);
- }
}
/*!
bool QWebSocketDataProcessor::processControlFrame(const QWebSocketFrame &frame)
{
bool mustStopProcessing = true; //control frames never expect additional frames to be processed
- switch (frame.opCode())
+ switch (frame.opCode()) {
+ case QWebSocketProtocol::OC_PING:
+ Q_EMIT pingReceived(frame.payload());
+ break;
+
+ case QWebSocketProtocol::OC_PONG:
+ Q_EMIT pongReceived(frame.payload());
+ break;
+
+ case QWebSocketProtocol::OC_CLOSE:
{
- case QWebSocketProtocol::OC_PING:
- {
- Q_EMIT pingReceived(frame.payload());
- break;
- }
- case QWebSocketProtocol::OC_PONG:
- {
- Q_EMIT pongReceived(frame.payload());
- break;
- }
- case QWebSocketProtocol::OC_CLOSE:
- {
- quint16 closeCode = QWebSocketProtocol::CC_NORMAL;
- QString closeReason;
- QByteArray payload = frame.payload();
- if (Q_UNLIKELY(payload.size() == 1)) {
- //size is either 0 (no close code and no reason) or >= 2 (at least a close code of 2 bytes)
+ quint16 closeCode = QWebSocketProtocol::CC_NORMAL;
+ QString closeReason;
+ QByteArray payload = frame.payload();
+ if (Q_UNLIKELY(payload.size() == 1)) {
+ //size is either 0 (no close code and no reason) or >= 2 (at least a close code of 2 bytes)
+ closeCode = QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ closeReason = tr("Payload of close frame is too small.");
+ } else if (Q_LIKELY(payload.size() > 1)) {
+ //close frame can have a close code and reason
+ closeCode = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(payload.constData()));
+ if (Q_UNLIKELY(!QWebSocketProtocol::isCloseCodeValid(closeCode))) {
closeCode = QWebSocketProtocol::CC_PROTOCOL_ERROR;
- closeReason = tr("Payload of close frame is too small.");
- } else if (Q_LIKELY(payload.size() > 1)) {
- //close frame can have a close code and reason
- closeCode = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(payload.constData()));
- if (Q_UNLIKELY(!QWebSocketProtocol::isCloseCodeValid(closeCode))) {
- closeCode = QWebSocketProtocol::CC_PROTOCOL_ERROR;
- closeReason = tr("Invalid close code %1 detected.").arg(closeCode);
- } else {
- if (payload.size() > 2) {
- QTextCodec *tc = QTextCodec::codecForName("UTF-8");
- QTextCodec::ConverterState state(QTextCodec::ConvertInvalidToNull);
- closeReason = tc->toUnicode(payload.constData() + 2, payload.size() - 2, &state);
- const bool failed = (state.invalidChars != 0) || (state.remainingChars != 0);
- if (Q_UNLIKELY(failed)) {
- closeCode = QWebSocketProtocol::CC_WRONG_DATATYPE;
- closeReason = tr("Invalid UTF-8 code encountered.");
- }
+ closeReason = tr("Invalid close code %1 detected.").arg(closeCode);
+ } else {
+ if (payload.size() > 2) {
+ QTextCodec *tc = QTextCodec::codecForName(QByteArrayLiteral("UTF-8"));
+ QTextCodec::ConverterState state(QTextCodec::ConvertInvalidToNull);
+ closeReason = tc->toUnicode(payload.constData() + 2, payload.size() - 2, &state);
+ const bool failed = (state.invalidChars != 0) || (state.remainingChars != 0);
+ if (Q_UNLIKELY(failed)) {
+ closeCode = QWebSocketProtocol::CC_WRONG_DATATYPE;
+ closeReason = tr("Invalid UTF-8 code encountered.");
}
}
}
- Q_EMIT closeReceived(static_cast<QWebSocketProtocol::CloseCode>(closeCode), closeReason);
- break;
- }
- case QWebSocketProtocol::OC_CONTINUE:
- case QWebSocketProtocol::OC_BINARY:
- case QWebSocketProtocol::OC_TEXT:
- case QWebSocketProtocol::OC_RESERVED_3:
- case QWebSocketProtocol::OC_RESERVED_4:
- case QWebSocketProtocol::OC_RESERVED_5:
- case QWebSocketProtocol::OC_RESERVED_6:
- case QWebSocketProtocol::OC_RESERVED_7:
- case QWebSocketProtocol::OC_RESERVED_C:
- case QWebSocketProtocol::OC_RESERVED_B:
- case QWebSocketProtocol::OC_RESERVED_D:
- case QWebSocketProtocol::OC_RESERVED_E:
- case QWebSocketProtocol::OC_RESERVED_F:
- {
- //do nothing
- //case added to make C++ compiler happy
- break;
- }
- default:
- {
- Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR, tr("Invalid opcode detected: %1").arg(int(frame.opCode())));
- //Do nothing
- break;
}
+ Q_EMIT closeReceived(static_cast<QWebSocketProtocol::CloseCode>(closeCode), closeReason);
+ break;
+ }
+
+ case QWebSocketProtocol::OC_CONTINUE:
+ case QWebSocketProtocol::OC_BINARY:
+ case QWebSocketProtocol::OC_TEXT:
+ case QWebSocketProtocol::OC_RESERVED_3:
+ case QWebSocketProtocol::OC_RESERVED_4:
+ case QWebSocketProtocol::OC_RESERVED_5:
+ case QWebSocketProtocol::OC_RESERVED_6:
+ case QWebSocketProtocol::OC_RESERVED_7:
+ case QWebSocketProtocol::OC_RESERVED_C:
+ case QWebSocketProtocol::OC_RESERVED_B:
+ case QWebSocketProtocol::OC_RESERVED_D:
+ case QWebSocketProtocol::OC_RESERVED_E:
+ case QWebSocketProtocol::OC_RESERVED_F:
+ //do nothing
+ //case statements added to make C++ compiler happy
+ break;
+
+ default:
+ Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR, tr("Invalid opcode detected: %1").arg(int(frame.opCode())));
+ //do nothing
+ break;
}
return mustStopProcessing;
}
while (!isDone)
{
- switch (processingState)
- {
- case PS_WAIT_FOR_MORE_DATA:
- {
- //TODO: waitForReadyRead should really be changed
- //now, when a websocket is used in a GUI thread
- //the GUI will hang for at most 5 seconds
- //maybe, a QStateMachine should be used
- bool ok = pIoDevice->waitForReadyRead(5000);
- if (!ok) {
- frame.setError(QWebSocketProtocol::CC_GOING_AWAY, QObject::tr("Timeout when reading data from socket."));
- processingState = PS_DISPATCH_RESULT;
- } else {
- processingState = returnState;
- }
- break;
+ switch (processingState) {
+ case PS_WAIT_FOR_MORE_DATA:
+ //TODO: waitForReadyRead should really be changed
+ //now, when a websocket is used in a GUI thread
+ //the GUI will hang for at most 5 seconds
+ //maybe, a QStateMachine should be used
+ if (!pIoDevice->waitForReadyRead(5000)) {
+ frame.setError(QWebSocketProtocol::CC_GOING_AWAY, QObject::tr("Timeout when reading data from socket."));
+ processingState = PS_DISPATCH_RESULT;
+ } else {
+ processingState = returnState;
}
- case PS_READ_HEADER:
- {
- if (Q_LIKELY(pIoDevice->bytesAvailable() >= 2)) {
- //FIN, RSV1-3, Opcode
- char header[2] = {0};
- bytesRead = pIoDevice->read(header, 2);
- frame.m_isFinalFrame = (header[0] & 0x80) != 0;
- frame.m_rsv1 = (header[0] & 0x40);
- frame.m_rsv2 = (header[0] & 0x20);
- frame.m_rsv3 = (header[0] & 0x10);
- frame.m_opCode = static_cast<QWebSocketProtocol::OpCode>(header[0] & 0x0F);
-
- //Mask, PayloadLength
- hasMask = (header[1] & 0x80) != 0;
- frame.m_length = (header[1] & 0x7F);
-
- switch (frame.m_length)
+ break;
+
+ case PS_READ_HEADER:
+ if (Q_LIKELY(pIoDevice->bytesAvailable() >= 2)) {
+ //FIN, RSV1-3, Opcode
+ char header[2] = {0};
+ bytesRead = pIoDevice->read(header, 2);
+ frame.m_isFinalFrame = (header[0] & 0x80) != 0;
+ frame.m_rsv1 = (header[0] & 0x40);
+ frame.m_rsv2 = (header[0] & 0x20);
+ frame.m_rsv3 = (header[0] & 0x10);
+ frame.m_opCode = static_cast<QWebSocketProtocol::OpCode>(header[0] & 0x0F);
+
+ //Mask, PayloadLength
+ hasMask = (header[1] & 0x80) != 0;
+ frame.m_length = (header[1] & 0x7F);
+
+ switch (frame.m_length)
+ {
+ case 126:
{
- case 126:
- {
- processingState = PS_READ_PAYLOAD_LENGTH;
- break;
- }
- case 127:
- {
- processingState = PS_READ_BIG_PAYLOAD_LENGTH;
- break;
- }
- default:
- {
- payloadLength = frame.m_length;
- processingState = hasMask ? PS_READ_MASK : PS_READ_PAYLOAD;
- break;
- }
+ processingState = PS_READ_PAYLOAD_LENGTH;
+ break;
}
- if (!frame.checkValidity()) {
- processingState = PS_DISPATCH_RESULT;
+ case 127:
+ {
+ processingState = PS_READ_BIG_PAYLOAD_LENGTH;
+ break;
}
- } else {
- WAIT_FOR_MORE_DATA(2);
- }
- break;
- }
-
- case PS_READ_PAYLOAD_LENGTH:
- {
- if (Q_LIKELY(pIoDevice->bytesAvailable() >= 2)) {
- uchar length[2] = {0};
- bytesRead = pIoDevice->read(reinterpret_cast<char *>(length), 2);
- if (Q_UNLIKELY(bytesRead == -1)) {
- frame.setError(QWebSocketProtocol::CC_GOING_AWAY, QObject::tr("Error occurred while reading from the network: %1").arg(pIoDevice->errorString()));
- processingState = PS_DISPATCH_RESULT;
- } else {
- payloadLength = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(length));
- if (Q_UNLIKELY(payloadLength < 126)) {
- //see http://tools.ietf.org/html/rfc6455#page-28 paragraph 5.2
- //"in all cases, the minimal number of bytes MUST be used to encode
- //the length, for example, the length of a 124-byte-long string
- //can't be encoded as the sequence 126, 0, 124"
- frame.setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Lengths smaller than 126 must be expressed as one byte."));
- processingState = PS_DISPATCH_RESULT;
- } else {
- processingState = hasMask ? PS_READ_MASK : PS_READ_PAYLOAD;
- }
+ default:
+ {
+ payloadLength = frame.m_length;
+ processingState = hasMask ? PS_READ_MASK : PS_READ_PAYLOAD;
+ break;
}
- } else {
- WAIT_FOR_MORE_DATA(2);
}
- break;
+ if (!frame.checkValidity())
+ processingState = PS_DISPATCH_RESULT;
+ } else {
+ WAIT_FOR_MORE_DATA(2);
}
-
- case PS_READ_BIG_PAYLOAD_LENGTH:
- {
- if (Q_LIKELY(pIoDevice->bytesAvailable() >= 8)) {
- uchar length[8] = {0};
- bytesRead = pIoDevice->read(reinterpret_cast<char *>(length), 8);
- if (Q_UNLIKELY(bytesRead < 8)) {
- frame.setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION, QObject::tr("Something went wrong during reading from the network."));
+ break;
+
+ case PS_READ_PAYLOAD_LENGTH:
+ if (Q_LIKELY(pIoDevice->bytesAvailable() >= 2)) {
+ uchar length[2] = {0};
+ bytesRead = pIoDevice->read(reinterpret_cast<char *>(length), 2);
+ if (Q_UNLIKELY(bytesRead == -1)) {
+ frame.setError(QWebSocketProtocol::CC_GOING_AWAY, QObject::tr("Error occurred while reading from the network: %1").arg(pIoDevice->errorString()));
+ processingState = PS_DISPATCH_RESULT;
+ } else {
+ payloadLength = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(length));
+ if (Q_UNLIKELY(payloadLength < 126)) {
+ //see http://tools.ietf.org/html/rfc6455#page-28 paragraph 5.2
+ //"in all cases, the minimal number of bytes MUST be used to encode
+ //the length, for example, the length of a 124-byte-long string
+ //can't be encoded as the sequence 126, 0, 124"
+ frame.setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Lengths smaller than 126 must be expressed as one byte."));
processingState = PS_DISPATCH_RESULT;
} else {
- //Most significant bit must be set to 0 as per http://tools.ietf.org/html/rfc6455#section-5.2
- payloadLength = qFromBigEndian<quint64>(length);
- if (Q_UNLIKELY(payloadLength & (quint64(1) << 63))) {
- frame.setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Highest bit of payload length is not 0."));
- processingState = PS_DISPATCH_RESULT;
- } else if (Q_UNLIKELY(payloadLength <= 0xFFFFu)) {
- //see http://tools.ietf.org/html/rfc6455#page-28 paragraph 5.2
- //"in all cases, the minimal number of bytes MUST be used to encode
- //the length, for example, the length of a 124-byte-long string
- //can't be encoded as the sequence 126, 0, 124"
- frame.setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Lengths smaller than 65536 (2^16) must be expressed as 2 bytes."));
- processingState = PS_DISPATCH_RESULT;
- } else {
- processingState = hasMask ? PS_READ_MASK : PS_READ_PAYLOAD;
- }
+ processingState = hasMask ? PS_READ_MASK : PS_READ_PAYLOAD;
}
- } else {
- WAIT_FOR_MORE_DATA(8);
}
-
- break;
+ } else {
+ WAIT_FOR_MORE_DATA(2);
}
-
- case PS_READ_MASK:
- {
- if (Q_LIKELY(pIoDevice->bytesAvailable() >= 4)) {
- bytesRead = pIoDevice->read(reinterpret_cast<char *>(&frame.m_mask), sizeof(frame.m_mask));
- if (bytesRead == -1) {
- frame.setError(QWebSocketProtocol::CC_GOING_AWAY, QObject::tr("Error while reading from the network: %1.").arg(pIoDevice->errorString()));
+ break;
+
+ case PS_READ_BIG_PAYLOAD_LENGTH:
+ if (Q_LIKELY(pIoDevice->bytesAvailable() >= 8)) {
+ uchar length[8] = {0};
+ bytesRead = pIoDevice->read(reinterpret_cast<char *>(length), 8);
+ if (Q_UNLIKELY(bytesRead < 8)) {
+ frame.setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION, QObject::tr("Something went wrong during reading from the network."));
+ processingState = PS_DISPATCH_RESULT;
+ } else {
+ //Most significant bit must be set to 0 as per http://tools.ietf.org/html/rfc6455#section-5.2
+ payloadLength = qFromBigEndian<quint64>(length);
+ if (Q_UNLIKELY(payloadLength & (quint64(1) << 63))) {
+ frame.setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Highest bit of payload length is not 0."));
+ processingState = PS_DISPATCH_RESULT;
+ } else if (Q_UNLIKELY(payloadLength <= 0xFFFFu)) {
+ //see http://tools.ietf.org/html/rfc6455#page-28 paragraph 5.2
+ //"in all cases, the minimal number of bytes MUST be used to encode
+ //the length, for example, the length of a 124-byte-long string
+ //can't be encoded as the sequence 126, 0, 124"
+ frame.setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Lengths smaller than 65536 (2^16) must be expressed as 2 bytes."));
processingState = PS_DISPATCH_RESULT;
} else {
- frame.m_mask = qFromBigEndian(frame.m_mask);
- processingState = PS_READ_PAYLOAD;
+ processingState = hasMask ? PS_READ_MASK : PS_READ_PAYLOAD;
}
- } else {
- WAIT_FOR_MORE_DATA(4);
}
- break;
+ } else {
+ WAIT_FOR_MORE_DATA(8);
}
- case PS_READ_PAYLOAD:
- {
- if (!payloadLength) {
- processingState = PS_DISPATCH_RESULT;
- } else if (Q_UNLIKELY(payloadLength > MAX_FRAME_SIZE_IN_BYTES)) {
- frame.setError(QWebSocketProtocol::CC_TOO_MUCH_DATA, QObject::tr("Maximum framesize exceeded."));
+ break;
+
+ case PS_READ_MASK:
+ if (Q_LIKELY(pIoDevice->bytesAvailable() >= 4)) {
+ bytesRead = pIoDevice->read(reinterpret_cast<char *>(&frame.m_mask), sizeof(frame.m_mask));
+ if (bytesRead == -1) {
+ frame.setError(QWebSocketProtocol::CC_GOING_AWAY, QObject::tr("Error while reading from the network: %1.").arg(pIoDevice->errorString()));
processingState = PS_DISPATCH_RESULT;
} else {
- quint64 bytesAvailable = quint64(pIoDevice->bytesAvailable());
- if (bytesAvailable >= payloadLength) {
- frame.m_payload = pIoDevice->read(payloadLength);
- //payloadLength can be safely cast to an integer, as the MAX_FRAME_SIZE_IN_BYTES = MAX_INT
- if (Q_UNLIKELY(frame.m_payload.length() != int(payloadLength))) {
- //some error occurred; refer to the Qt documentation of QIODevice::read()
- frame.setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION, QObject::tr("Some serious error occurred while reading from the network."));
- processingState = PS_DISPATCH_RESULT;
- } else {
- if (hasMask) {
- QWebSocketProtocol::mask(&frame.m_payload, frame.m_mask);
- }
- processingState = PS_DISPATCH_RESULT;
- }
+ frame.m_mask = qFromBigEndian(frame.m_mask);
+ processingState = PS_READ_PAYLOAD;
+ }
+ } else {
+ WAIT_FOR_MORE_DATA(4);
+ }
+ break;
+
+ case PS_READ_PAYLOAD:
+ if (!payloadLength) {
+ processingState = PS_DISPATCH_RESULT;
+ } else if (Q_UNLIKELY(payloadLength > MAX_FRAME_SIZE_IN_BYTES)) {
+ frame.setError(QWebSocketProtocol::CC_TOO_MUCH_DATA, QObject::tr("Maximum framesize exceeded."));
+ processingState = PS_DISPATCH_RESULT;
+ } else {
+ quint64 bytesAvailable = quint64(pIoDevice->bytesAvailable());
+ if (bytesAvailable >= payloadLength) {
+ frame.m_payload = pIoDevice->read(payloadLength);
+ //payloadLength can be safely cast to an integer, as the MAX_FRAME_SIZE_IN_BYTES = MAX_INT
+ if (Q_UNLIKELY(frame.m_payload.length() != int(payloadLength))) {
+ //some error occurred; refer to the Qt documentation of QIODevice::read()
+ frame.setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION, QObject::tr("Some serious error occurred while reading from the network."));
+ processingState = PS_DISPATCH_RESULT;
} else {
- WAIT_FOR_MORE_DATA(payloadLength); //if payload is too big, then this will timeout
+ if (hasMask)
+ QWebSocketProtocol::mask(&frame.m_payload, frame.m_mask);
+ processingState = PS_DISPATCH_RESULT;
}
+ } else {
+ WAIT_FOR_MORE_DATA(payloadLength); //if payload is too big, then this will timeout
}
- break;
- }
-
- case PS_DISPATCH_RESULT:
- {
- processingState = PS_READ_HEADER;
- isDone = true;
- break;
- }
-
- default:
- {
- //should not come here
- qWarning() << "DataProcessor::process: Found invalid state. This should not happen!";
- frame.clear();
- isDone = true;
- break;
}
+ break;
+
+ case PS_DISPATCH_RESULT:
+ processingState = PS_READ_HEADER;
+ isDone = true;
+ break;
+
+ default:
+ //should not come here
+ qWarning() << "DataProcessor::process: Found invalid state. This should not happen!";
+ frame.clear();
+ isDone = true;
+ break;
} //end switch
}
*/
bool QWebSocketFrame::checkValidity()
{
- if (isValid()) {
+ if (isValid())
return true;
- }
if (Q_UNLIKELY(m_rsv1 || m_rsv2 || m_rsv3)) {
setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Rsv field is non-zero"));
} else if (Q_UNLIKELY(QWebSocketProtocol::isOpCodeReserved(m_opCode))) {
{
m_isValid = false;
clear();
- if (Q_UNLIKELY(textStream.status() != QTextStream::Ok)) {
+ if (Q_UNLIKELY(textStream.status() != QTextStream::Ok))
return textStream;
- }
const QString requestLine = textStream.readLine();
const QStringList tokens = requestLine.split(' ', QString::SkipEmptyParts);
if (Q_UNLIKELY(tokens.length() < 3)) {
const QString host = m_headers.value(QStringLiteral("Host"), QStringLiteral(""));
m_requestUrl = QUrl::fromEncoded(resourceName.toLatin1());
- if (m_requestUrl.isRelative()) {
+ if (m_requestUrl.isRelative())
m_requestUrl.setHost(host);
- }
if (m_requestUrl.scheme().isEmpty()) {
const QString scheme = isSecure() ? QStringLiteral("wss") : QStringLiteral("ws");
m_requestUrl.setScheme(scheme);
const QString connection = m_headers.value(QStringLiteral("Connection"), QStringLiteral(""));
const QStringList connectionLine = connection.split(QStringLiteral(","), QString::SkipEmptyParts);
QStringList connectionValues;
- for (QStringList::const_iterator c = connectionLine.begin(); c != connectionLine.end(); ++c) {
+ for (QStringList::const_iterator c = connectionLine.begin(); c != connectionLine.end(); ++c)
connectionValues << (*c).trimmed();
- }
//optional headers
m_origin = m_headers.value(QStringLiteral("Sec-WebSocket-Origin"), QStringLiteral(""));
const QStringList protocolLines = m_headers.values(QStringLiteral("Sec-WebSocket-Protocol"));
for (QStringList::const_iterator pl = protocolLines.begin(); pl != protocolLines.end(); ++pl) {
QStringList protocols = (*pl).split(QStringLiteral(","), QString::SkipEmptyParts);
- for (QStringList::const_iterator p = protocols.begin(); p != protocols.end(); ++p) {
+ for (QStringList::const_iterator p = protocols.begin(); p != protocols.end(); ++p)
m_protocols << (*p).trimmed();
- }
}
const QStringList extensionLines = m_headers.values(QStringLiteral("Sec-WebSocket-Extensions"));
for (QStringList::const_iterator el = extensionLines.begin(); el != extensionLines.end(); ++el) {
QStringList extensions = (*el).split(QStringLiteral(","), QString::SkipEmptyParts);
- for (QStringList::const_iterator e = extensions.begin(); e != extensions.end(); ++e) {
+ for (QStringList::const_iterator e = extensions.begin(); e != extensions.end(); ++e)
m_extensions << (*e).trimmed();
- }
}
//TODO: authentication field
(!conversionOk || (httpVersion < 1.1f)) ||
(upgrade.toLower() != QStringLiteral("websocket")) ||
(!connectionValues.contains(QStringLiteral("upgrade"), Qt::CaseInsensitive)));
- if (Q_UNLIKELY(!m_isValid)) {
+ if (Q_UNLIKELY(!m_isValid))
clear();
- }
return textStream;
}
response << QStringLiteral("Sec-WebSocket-Extensions: ") % m_acceptedExtension;
}
QString origin = request.origin().trimmed();
- if (origin.isEmpty()) {
+ if (origin.isEmpty())
origin = QStringLiteral("*");
- }
response << QStringLiteral("Server: ") % serverName <<
QStringLiteral("Access-Control-Allow-Credentials: false") << //do not allow credentialed request (containing cookies)
QStringLiteral("Access-Control-Allow-Methods: GET") << //only GET is allowed during handshaking
if (Q_UNLIKELY(!m_canUpgrade)) {
response << QStringLiteral("HTTP/1.1 400 Bad Request");
QStringList versions;
- Q_FOREACH (QWebSocketProtocol::Version version, supportedVersions) {
+ Q_FOREACH (QWebSocketProtocol::Version version, supportedVersions)
versions << QString::number(static_cast<int>(version));
- }
response << QStringLiteral("Sec-WebSocket-Version: ") % versions.join(QStringLiteral(", "));
}
}
*/
QTextStream &QWebSocketHandshakeResponse::writeToStream(QTextStream &textStream) const
{
- if (Q_LIKELY(!m_response.isEmpty())) {
+ if (Q_LIKELY(!m_response.isEmpty()))
textStream << m_response.toLatin1().constData();
- } else {
+ else
textStream.setStatus(QTextStream::WriteFailed);
- }
return textStream;
}
const int ver = versionString.toInt(&ok);
QSet<Version> supportedVersions;
supportedVersions << V_0 << V_4 << V_5 << V_6 << V_7 << V_8 << V_13;
- if (Q_LIKELY(ok)) {
- if (supportedVersions.contains(static_cast<Version>(ver))) {
- version = static_cast<Version>(ver);
- }
- }
+ if (Q_LIKELY(ok) && (supportedVersions.contains(static_cast<Version>(ver))))
+ version = static_cast<Version>(ver);
return version;
}
quint8((maskingKey & 0x000000FFu))
};
int i = 0;
- while (size-- > 0) {
+ while (size-- > 0)
*payload++ ^= mask[i++ % 4];
- }
}
} //end namespace WebSocketProtocol
Q_ASSERT(pWebSocketServer);
if (m_secureMode == NON_SECURE_MODE) {
m_pTcpServer = new QTcpServer(this);
- if (Q_LIKELY(m_pTcpServer)) {
+ if (Q_LIKELY(m_pTcpServer))
connect(m_pTcpServer, SIGNAL(newConnection()), this, SLOT(onNewConnection()));
- } else {
+ else
qFatal("Could not allocate memory for tcp server.");
- }
} else {
#ifndef QT_NO_SSL
QSslServer *pSslServer = new QSslServer(this);
*/
QString QWebSocketServerPrivate::errorString() const
{
- if (m_errorString.isEmpty()) {
+ if (m_errorString.isEmpty())
return m_pTcpServer->errorString();
- } else {
+ else
return m_errorString;
- }
}
/*!
*/
void QWebSocketServerPrivate::addPendingConnection(QWebSocket *pWebSocket)
{
- if (m_pendingConnections.size() < maxPendingConnections()) {
+ if (m_pendingConnections.size() < maxPendingConnections())
m_pendingConnections.enqueue(pWebSocket);
- }
}
/*!
QWebSocket *QWebSocketServerPrivate::nextPendingConnection()
{
QWebSocket *pWebSocket = Q_NULLPTR;
- if (Q_LIKELY(!m_pendingConnections.isEmpty())) {
+ if (Q_LIKELY(!m_pendingConnections.isEmpty()))
pWebSocket = m_pendingConnections.dequeue();
- }
return pWebSocket;
}
*/
void QWebSocketServerPrivate::setServerName(const QString &serverName)
{
- if (m_serverName != serverName) {
+ if (m_serverName != serverName)
m_serverName = serverName;
- }
}
/*!
#ifndef QT_NO_SSL
void QWebSocketServerPrivate::setSslConfiguration(const QSslConfiguration &sslConfiguration)
{
- if (m_secureMode == SECURE_MODE) {
+ if (m_secureMode == SECURE_MODE)
qobject_cast<QSslServer *>(m_pTcpServer)->setSslConfiguration(sslConfiguration);
- } else {
+ else
qWarning() << tr("Cannot set SSL configuration for non-secure server.");
- }
}
QSslConfiguration QWebSocketServerPrivate::sslConfiguration() const
{
- if (m_secureMode == SECURE_MODE) {
+ if (m_secureMode == SECURE_MODE)
return qobject_cast<QSslServer *>(m_pTcpServer)->sslConfiguration();
- } else {
+ else
return QSslConfiguration::defaultConfiguration();
- }
}
#endif
void QWebSocketServerPrivate::onCloseConnection()
{
QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
- if (Q_LIKELY(pTcpSocket)) {
+ if (Q_LIKELY(pTcpSocket))
pTcpSocket->close();
- }
}
/*!
projects / contrib / qtwebsockets.git / commitdiff