EchoServer::EchoServer(quint16 port, QObject *parent) :
QObject(parent),
m_pWebSocketServer(new QWebSocketServer(QStringLiteral("Echo Server"),
- QWebSocketServer::NON_SECURE_MODE, this)),
+ QWebSocketServer::SecureModeNonSecure, this)),
m_clients()
{
if (m_pWebSocketServer->listen(QHostAddress::Any, port)) {
m_pWebSocketServer(Q_NULLPTR),
m_clients()
{
- m_pWebSocketServer = new QWebSocketServer("Chat Server", QWebSocketServer::NON_SECURE_MODE, this);
+ m_pWebSocketServer = new QWebSocketServer("Chat Server", QWebSocketServer::SecureModeNonSecure, this);
if (m_pWebSocketServer->listen(QHostAddress::Any, port))
{
qDebug() << "Chat Server listening on port" << port;
m_pWebSocketServer(Q_NULLPTR),
m_clients()
{
- m_pWebSocketServer = new QWebSocketServer("SSL Echo Server", QWebSocketServer::SECURE_MODE, this);
+ m_pWebSocketServer = new QWebSocketServer("SSL Echo Server", QWebSocketServer::SecureModeSecure, this);
QSslConfiguration sslConfiguration;
QFile certFile(QStringLiteral("./localhost.cert"));
QFile keyFile(QStringLiteral("./localhost.key"));
public:
explicit QWebSocket(const QString &origin = QString(),
- QWebSocketProtocol::Version version = QWebSocketProtocol::V_LATEST,
+ QWebSocketProtocol::Version version = QWebSocketProtocol::VersionLatest,
QObject *parent = Q_NULLPTR);
virtual ~QWebSocket();
#endif
public Q_SLOTS:
- void close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CC_NORMAL,
+ void close(QWebSocketProtocol::CloseCode closeCode = QWebSocketProtocol::CloseCodeNormal,
const QString &reason = QString());
void open(const QUrl &url, bool mask = true);
void ping(const QByteArray &payload = QByteArray());
m_mustMask(true),
m_isClosingHandshakeSent(false),
m_isClosingHandshakeReceived(false),
- m_closeCode(QWebSocketProtocol::CC_NORMAL),
+ m_closeCode(QWebSocketProtocol::CloseCodeNormal),
m_closeReason(),
m_pingTimer(),
m_dataProcessor(),
m_mustMask(true),
m_isClosingHandshakeSent(false),
m_isClosingHandshakeReceived(false),
- m_closeCode(QWebSocketProtocol::CC_NORMAL),
+ m_closeCode(QWebSocketProtocol::CloseCodeNormal),
m_closeReason(),
m_pingTimer(),
m_dataProcessor(),
if (!m_pSocket)
return;
if (state() == QAbstractSocket::ConnectedState)
- close(QWebSocketProtocol::CC_GOING_AWAY, tr("Connection closed"));
+ close(QWebSocketProtocol::CloseCodeGoingAway, tr("Connection closed"));
releaseConnections(m_pSocket.data());
}
maskingKey = generateMaskingKey();
QWebSocketProtocol::mask(payload.data(), payload.size(), maskingKey);
}
- QByteArray frame = getFrameHeader(QWebSocketProtocol::OC_CLOSE,
+ QByteArray frame = getFrameHeader(QWebSocketProtocol::OpCodeClose,
payload.size(), maskingKey, true);
frame.append(payload);
m_pSocket->write(frame);
{
QByteArray payloadTruncated = payload.left(125);
m_pingTimer.restart();
- QByteArray pingFrame = getFrameHeader(QWebSocketProtocol::OC_PING, payloadTruncated.size(),
+ QByteArray pingFrame = getFrameHeader(QWebSocketProtocol::OpCodePing, payloadTruncated.size(),
0 /*do not mask*/, true);
pingFrame.append(payloadTruncated);
qint64 ret = writeFrame(pingFrame);
Q_Q(QWebSocket);
const QWebSocketProtocol::OpCode firstOpCode = isBinary ?
- QWebSocketProtocol::OC_BINARY : QWebSocketProtocol::OC_TEXT;
+ QWebSocketProtocol::OpCodeBinary : QWebSocketProtocol::OpCodeText;
int numFrames = data.size() / FRAME_SIZE_IN_BYTES;
QByteArray tmpData(data);
const quint64 size = qMin(bytesLeft, FRAME_SIZE_IN_BYTES);
const QWebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode
- : QWebSocketProtocol::OC_CONTINUE;
+ : QWebSocketProtocol::OpCodeContinue;
//write header
bytesWritten += m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
quint32 maskingKey = 0;
if (m_mustMask)
maskingKey = generateMaskingKey();
- m_pSocket->write(getFrameHeader(QWebSocketProtocol::OC_PONG, data.size(), maskingKey, true));
+ m_pSocket->write(getFrameHeader(QWebSocketProtocol::OpCodePong, data.size(), maskingKey, true));
if (data.size() > 0) {
QByteArray maskedData = data;
if (m_mustMask)
m_processingState(PS_READ_HEADER),
m_isFinalFrame(false),
m_isFragmented(false),
- m_opCode(QWebSocketProtocol::OC_CLOSE),
+ m_opCode(QWebSocketProtocol::OpCodeClose),
m_isControlFrame(false),
m_hasMask(false),
m_mask(0),
//we have a dataframe; opcode can be OC_CONTINUE, OC_TEXT or OC_BINARY
if (Q_UNLIKELY(!m_isFragmented && frame.isContinuationFrame())) {
clear();
- Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR,
+ Q_EMIT errorEncountered(QWebSocketProtocol::CloseCodeProtocolError,
tr("Received Continuation frame, while there is " \
"nothing to continue."));
return;
if (Q_UNLIKELY(m_isFragmented && frame.isDataFrame() &&
!frame.isContinuationFrame())) {
clear();
- Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR,
+ Q_EMIT errorEncountered(QWebSocketProtocol::CloseCodeProtocolError,
tr("All data frames after the initial data frame " \
"must have opcode 0 (continuation)."));
return;
m_opCode = frame.opCode();
m_isFragmented = !frame.isFinalFrame();
}
- quint64 messageLength = (quint64)(m_opCode == QWebSocketProtocol::OC_TEXT)
+ quint64 messageLength = (quint64)(m_opCode == QWebSocketProtocol::OpCodeText)
? m_textMessage.length()
: m_binaryMessage.length();
if (Q_UNLIKELY((messageLength + quint64(frame.payload().length())) >
MAX_MESSAGE_SIZE_IN_BYTES)) {
clear();
- Q_EMIT errorEncountered(QWebSocketProtocol::CC_TOO_MUCH_DATA,
+ Q_EMIT errorEncountered(QWebSocketProtocol::CloseCodeTooMuchData,
tr("Received message is too big."));
return;
}
- if (m_opCode == QWebSocketProtocol::OC_TEXT) {
+ if (m_opCode == QWebSocketProtocol::OpCodeText) {
QString frameTxt = m_pTextCodec->toUnicode(frame.payload().constData(),
frame.payload().size(),
m_pConverterState);
|| (frame.isFinalFrame() && (m_pConverterState->remainingChars != 0));
if (Q_UNLIKELY(failed)) {
clear();
- Q_EMIT errorEncountered(QWebSocketProtocol::CC_WRONG_DATATYPE,
+ Q_EMIT errorEncountered(QWebSocketProtocol::CloseCodeWrongDatatype,
tr("Invalid UTF-8 code encountered."));
return;
} else {
}
if (frame.isFinalFrame()) {
- if (m_opCode == QWebSocketProtocol::OC_TEXT)
+ if (m_opCode == QWebSocketProtocol::OpCodeText)
Q_EMIT textMessageReceived(m_textMessage);
else
Q_EMIT binaryMessageReceived(m_binaryMessage);
m_processingState = PS_READ_HEADER;
m_isFinalFrame = false;
m_isFragmented = false;
- m_opCode = QWebSocketProtocol::OC_CLOSE;
+ m_opCode = QWebSocketProtocol::OpCodeClose;
m_hasMask = false;
m_mask = 0;
m_binaryMessage.clear();
{
bool mustStopProcessing = true; //control frames never expect additional frames to be processed
switch (frame.opCode()) {
- case QWebSocketProtocol::OC_PING:
+ case QWebSocketProtocol::OpCodePing:
Q_EMIT pingReceived(frame.payload());
break;
- case QWebSocketProtocol::OC_PONG:
+ case QWebSocketProtocol::OpCodePong:
Q_EMIT pongReceived(frame.payload());
break;
- case QWebSocketProtocol::OC_CLOSE:
+ case QWebSocketProtocol::OpCodeClose:
{
- quint16 closeCode = QWebSocketProtocol::CC_NORMAL;
+ quint16 closeCode = QWebSocketProtocol::CloseCodeNormal;
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;
+ closeCode = QWebSocketProtocol::CloseCodeProtocolError;
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;
+ closeCode = QWebSocketProtocol::CloseCodeProtocolError;
closeReason = tr("Invalid close code %1 detected.").arg(closeCode);
} else {
if (payload.size() > 2) {
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;
+ closeCode = QWebSocketProtocol::CloseCodeWrongDatatype;
closeReason = tr("Invalid UTF-8 code encountered.");
}
}
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:
+ case QWebSocketProtocol::OpCodeContinue:
+ case QWebSocketProtocol::OpCodeBinary:
+ case QWebSocketProtocol::OpCodeText:
+ case QWebSocketProtocol::OpCodeReserved3:
+ case QWebSocketProtocol::OpCodeReserved4:
+ case QWebSocketProtocol::OpCodeReserved5:
+ case QWebSocketProtocol::OpCodeReserved6:
+ case QWebSocketProtocol::OpCodeReserved7:
+ case QWebSocketProtocol::OpCodeReservedC:
+ case QWebSocketProtocol::OpCodeReservedB:
+ case QWebSocketProtocol::OpCodeReservedD:
+ case QWebSocketProtocol::OpCodeReservedE:
+ case QWebSocketProtocol::OpCodeReservedF:
//do nothing
//case statements added to make C++ compiler happy
break;
default:
- Q_EMIT errorEncountered(QWebSocketProtocol::CC_PROTOCOL_ERROR,
+ Q_EMIT errorEncountered(QWebSocketProtocol::CloseCodeProtocolError,
tr("Invalid opcode detected: %1").arg(int(frame.opCode())));
//do nothing
break;
\internal
*/
QWebSocketFrame::QWebSocketFrame() :
- m_closeCode(QWebSocketProtocol::CC_NORMAL),
+ m_closeCode(QWebSocketProtocol::CloseCodeNormal),
m_closeReason(),
m_isFinalFrame(true),
m_mask(0),
m_rsv1(0),
m_rsv2(0),
m_rsv3(0),
- m_opCode(QWebSocketProtocol::OC_RESERVED_C),
+ m_opCode(QWebSocketProtocol::OpCodeReservedC),
m_length(0),
m_payload(),
m_isValid(false)
*/
bool QWebSocketFrame::isContinuationFrame() const
{
- return isDataFrame() && (m_opCode == QWebSocketProtocol::OC_CONTINUE);
+ return isDataFrame() && (m_opCode == QWebSocketProtocol::OpCodeContinue);
}
/*!
*/
void QWebSocketFrame::clear()
{
- m_closeCode = QWebSocketProtocol::CC_NORMAL;
+ m_closeCode = QWebSocketProtocol::CloseCodeNormal;
m_closeReason.clear();
m_isFinalFrame = true;
m_mask = 0;
m_rsv1 = 0;
m_rsv2 = 0;
m_rsv3 = 0;
- m_opCode = QWebSocketProtocol::OC_RESERVED_C;
+ m_opCode = QWebSocketProtocol::OpCodeReservedC;
m_length = 0;
m_payload.clear();
m_isValid = false;
//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,
+ frame.setError(QWebSocketProtocol::CloseCodeGoingAway,
QObject::tr("Timeout when reading data from socket."));
processingState = PS_DISPATCH_RESULT;
} else {
uchar length[2] = {0};
bytesRead = pIoDevice->read(reinterpret_cast<char *>(length), 2);
if (Q_UNLIKELY(bytesRead == -1)) {
- frame.setError(QWebSocketProtocol::CC_GOING_AWAY,
+ frame.setError(QWebSocketProtocol::CloseCodeGoingAway,
QObject::tr("Error occurred while reading from the network: %1")
.arg(pIoDevice->errorString()));
processingState = PS_DISPATCH_RESULT;
//"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,
+ frame.setError(QWebSocketProtocol::CloseCodeProtocolError,
QObject::tr("Lengths smaller than 126 " \
"must be expressed as one byte."));
processingState = PS_DISPATCH_RESULT;
uchar length[8] = {0};
bytesRead = pIoDevice->read(reinterpret_cast<char *>(length), 8);
if (Q_UNLIKELY(bytesRead < 8)) {
- frame.setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION,
+ frame.setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
QObject::tr("Something went wrong during "\
"reading from the network."));
processingState = PS_DISPATCH_RESULT;
//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,
+ frame.setError(QWebSocketProtocol::CloseCodeProtocolError,
QObject::tr("Highest bit of payload length is not 0."));
processingState = PS_DISPATCH_RESULT;
} else if (Q_UNLIKELY(payloadLength <= 0xFFFFu)) {
//"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,
+ frame.setError(QWebSocketProtocol::CloseCodeProtocolError,
QObject::tr("Lengths smaller than 65536 (2^16) " \
"must be expressed as 2 bytes."));
processingState = PS_DISPATCH_RESULT;
bytesRead = pIoDevice->read(reinterpret_cast<char *>(&frame.m_mask),
sizeof(frame.m_mask));
if (bytesRead == -1) {
- frame.setError(QWebSocketProtocol::CC_GOING_AWAY,
+ frame.setError(QWebSocketProtocol::CloseCodeGoingAway,
QObject::tr("Error while reading from the network: %1.")
.arg(pIoDevice->errorString()));
processingState = PS_DISPATCH_RESULT;
if (!payloadLength) {
processingState = PS_DISPATCH_RESULT;
} else if (Q_UNLIKELY(payloadLength > MAX_FRAME_SIZE_IN_BYTES)) {
- frame.setError(QWebSocketProtocol::CC_TOO_MUCH_DATA,
+ frame.setError(QWebSocketProtocol::CloseCodeTooMuchData,
QObject::tr("Maximum framesize exceeded."));
processingState = PS_DISPATCH_RESULT;
} else {
//because 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,
+ frame.setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
QObject::tr("Some serious error occurred " \
"while reading from the network."));
processingState = PS_DISPATCH_RESULT;
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"));
+ setError(QWebSocketProtocol::CloseCodeProtocolError, QObject::tr("Rsv field is non-zero"));
} else if (Q_UNLIKELY(QWebSocketProtocol::isOpCodeReserved(m_opCode))) {
- setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, QObject::tr("Used reserved opcode"));
+ setError(QWebSocketProtocol::CloseCodeProtocolError, QObject::tr("Used reserved opcode"));
} else if (isControlFrame()) {
if (Q_UNLIKELY(m_length > 125)) {
- setError(QWebSocketProtocol::CC_PROTOCOL_ERROR,
+ setError(QWebSocketProtocol::CloseCodeProtocolError,
QObject::tr("Controle frame is larger than 125 bytes"));
} else if (Q_UNLIKELY(!m_isFinalFrame)) {
- setError(QWebSocketProtocol::CC_PROTOCOL_ERROR,
+ setError(QWebSocketProtocol::CloseCodeProtocolError,
QObject::tr("Controle frames cannot be fragmented"));
} else {
m_isValid = true;
m_response(),
m_acceptedProtocol(),
m_acceptedExtension(),
- m_acceptedVersion(QWebSocketProtocol::V_Unknow),
- m_error(QWebSocketProtocol::CC_NORMAL),
+ m_acceptedVersion(QWebSocketProtocol::VersionUnknown),
+ m_error(QWebSocketProtocol::CloseCodeNormal),
m_errorString()
{
m_response = getHandshakeResponse(request, serverName,
if (!isOriginAllowed) {
if (!m_canUpgrade) {
- m_error = QWebSocketProtocol::CC_POLICY_VIOLATED;
+ m_error = QWebSocketProtocol::CloseCodePolicyViolated;
m_errorString = tr("Access forbidden.");
response << QStringLiteral("HTTP/1.1 403 Access Forbidden");
}
std::greater<QWebSocketProtocol::Version>()); //sort in descending order
if (Q_UNLIKELY(matchingVersions.isEmpty())) {
- m_error = QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ m_error = QWebSocketProtocol::CloseCodeProtocolError;
m_errorString = tr("Unsupported version requested.");
m_canUpgrade = false;
} else {
m_canUpgrade = true;
}
} else {
- m_error = QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ m_error = QWebSocketProtocol::CloseCodeProtocolError;
m_errorString = tr("Bad handshake request received.");
m_canUpgrade = false;
}
The close codes supported by WebSockets V13
- \value CC_NORMAL Normal closure
- \value CC_GOING_AWAY Going away
- \value CC_PROTOCOL_ERROR Protocol error
- \value CC_DATATYPE_NOT_SUPPORTED Unsupported data
- \value CC_RESERVED_1004 Reserved
- \value CC_MISSING_STATUS_CODE No status received
- \value CC_ABNORMAL_DISCONNECTION Abnormal closure
- \value CC_WRONG_DATATYPE Invalid frame payload data
- \value CC_POLICY_VIOLATED Policy violation
- \value CC_TOO_MUCH_DATA Message too big
- \value CC_MISSING_EXTENSION Mandatory extension missing
- \value CC_BAD_OPERATION Internal server error
- \value CC_TLS_HANDSHAKE_FAILED TLS handshake failed
+ \value CloseCodeNormal Normal closure
+ \value CloseCodeGoingAway Going away
+ \value CloseCodeProtocolError Protocol error
+ \value CloseCodeDatatypeNotSupported Unsupported data
+ \value CloseCodeReserved1004 Reserved
+ \value CloseCodeMissingStatusCode No status received
+ \value CloseCodeAbnormalDisconnection Abnormal closure
+ \value CloseCodeWrongDatatype Invalid frame payload data
+ \value CloseCodePolicyViolated Policy violation
+ \value CloseCodeTooMuchData Message too big
+ \value CloseCodeMissingExtension Mandatory extension missing
+ \value CloseCodeBadOperation Internal server error
+ \value CloseCodeHandshakeFailed TLS handshake failed
\sa QWebSocket::close()
*/
For an overview of the differences between the different protocols, see
<http://code.google.com/p/pywebsocket/wiki/WebSocketProtocolSpec>
- \value V_Unknow
- \value V_0 hixie76: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 &
- hybi-00: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00.
- Works with key1, key2 and a key in the payload.
- Attribute: Sec-WebSocket-Draft value 0.
- \value V_4 hybi-04: http://tools.ietf.org/id/draft-ietf-hybi-thewebsocketprotocol-04.txt.
- Changed handshake: key1, key2, key3
- ==> Sec-WebSocket-Key, Sec-WebSocket-Nonce, Sec-WebSocket-Accept
- Sec-WebSocket-Draft renamed to Sec-WebSocket-Version
- Sec-WebSocket-Version = 4
- \value V_5 hybi-05: http://tools.ietf.org/id/draft-ietf-hybi-thewebsocketprotocol-05.txt.
- Sec-WebSocket-Version = 5
- Removed Sec-WebSocket-Nonce
- Added Sec-WebSocket-Accept
- \value V_6 Sec-WebSocket-Version = 6.
- \value V_7 hybi-07: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07.
- Sec-WebSocket-Version = 7
- \value V_8 hybi-8, hybi-9, hybi-10, hybi-11 and hybi-12.
- Status codes 1005 and 1006 are added and all codes are now unsigned
- Internal error results in 1006
- \value V_13 hybi-13, hybi14, hybi-15, hybi-16, hybi-17 and RFC 6455.
- Sec-WebSocket-Version = 13
- Status code 1004 is now reserved
- Added 1008, 1009 and 1010
- Must support TLS
- Clarify multiple version support
- \value V_LATEST Refers to the latest know version to QWebSockets.
+ \value VersionUnknow Unknown or unspecified version.
+ \value Version0 hixie76:
+ http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 &
+ hybi-00:
+ http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00.
+ Works with key1, key2 and a key in the payload.
+ Attribute: Sec-WebSocket-Draft value 0.
+ \value Version4 hybi-04:
+ http://tools.ietf.org/id/draft-ietf-hybi-thewebsocketprotocol-04.txt.
+ Changed handshake: key1, key2, key3
+ ==> Sec-WebSocket-Key, Sec-WebSocket-Nonce, Sec-WebSocket-Accept
+ Sec-WebSocket-Draft renamed to Sec-WebSocket-Version
+ Sec-WebSocket-Version = 4.
+ \value Version5 hybi-05:
+ http://tools.ietf.org/id/draft-ietf-hybi-thewebsocketprotocol-05.txt.
+ Sec-WebSocket-Version = 5
+ Removed Sec-WebSocket-Nonce
+ Added Sec-WebSocket-Accept.
+ \value Version6 Sec-WebSocket-Version = 6.
+ \value Version7 hybi-07:
+ http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07.
+ Sec-WebSocket-Version = 7.
+ \value Version8 hybi-8, hybi-9, hybi-10, hybi-11 and hybi-12.
+ Status codes 1005 and 1006 are added and all codes are now unsigned
+ Internal error results in 1006.
+ \value Version13 hybi-13, hybi14, hybi-15, hybi-16, hybi-17 and RFC 6455.
+ Sec-WebSocket-Version = 13
+ Status code 1004 is now reserved
+ Added 1008, 1009 and 1010
+ Must support TLS
+ Clarify multiple version suppor.t
+ \value VersionLatest Refers to the latest known version to QtWebSockets.
*/
/*!
The frame opcodes as defined by the WebSockets standard
- \value OC_CONTINUE Continuation frame
- \value OC_TEXT Text frame
- \value OC_BINARY Binary frame
- \value OC_RESERVED_3 Reserved
- \value OC_RESERVED_4 Reserved
- \value OC_RESERVED_5 Reserved
- \value OC_RESERVED_6 Reserved
- \value OC_RESERVED_7 Reserved
- \value OC_CLOSE Close frame
- \value OC_PING Ping frame
- \value OC_PONG Pong frame
- \value OC_RESERVED_B Reserved
- \value OC_RESERVED_C Reserved
- \value OC_RESERVED_D Reserved
- \value OC_RESERVED_E Reserved
- \value OC_RESERVED_F Reserved
+ \value OpCodeContinue Continuation frame
+ \value OpCodeText Text frame
+ \value OpCodeBinary Binary frame
+ \value OpCodeReserved3 Reserved
+ \value OpCodeReserved4 Reserved
+ \value OpCodeReserved5 Reserved
+ \value OpCodeReserved6 Reserved
+ \value OpCodeReserved7 Reserved
+ \value OpCodeClose Close frame
+ \value OpCodePing Ping frame
+ \value OpCodePong Pong frame
+ \value OpCodeReservedB Reserved
+ \value OpCodeReservedC Reserved
+ \value OpCodeReservedD Reserved
+ \value OpCodeReservedE Reserved
+ \value OpCodeReservedF Reserved
\internal
*/
QWebSocketProtocol::Version QWebSocketProtocol::versionFromString(const QString &versionString)
{
bool ok = false;
- Version version = V_Unknow;
+ Version version = VersionUnknown;
const int ver = versionString.toInt(&ok);
QSet<Version> supportedVersions;
- supportedVersions << V_0 << V_4 << V_5 << V_6 << V_7 << V_8 << V_13;
+ supportedVersions << Version0 << Version4 << Version5 << Version6 << Version7 << Version8
+ << Version13;
if (Q_LIKELY(ok) && (supportedVersions.contains(static_cast<Version>(ver))))
version = static_cast<Version>(ver);
return version;
{
enum Version
{
- V_Unknow = -1,
- V_0 = 0,
+ VersionUnknown = -1,
+ Version0 = 0,
//hybi-01, hybi-02 and hybi-03 not supported
- V_4 = 4,
- V_5 = 5,
- V_6 = 6,
- V_7 = 7,
- V_8 = 8,
- V_13 = 13,
- V_LATEST = V_13
+ Version4 = 4,
+ Version5 = 5,
+ Version6 = 6,
+ Version7 = 7,
+ Version8 = 8,
+ Version13 = 13,
+ VersionLatest = Version13
};
Version versionFromString(const QString &versionString);
enum CloseCode
{
- CC_NORMAL = 1000,
- CC_GOING_AWAY = 1001,
- CC_PROTOCOL_ERROR = 1002,
- CC_DATATYPE_NOT_SUPPORTED = 1003,
- CC_RESERVED_1004 = 1004,
- CC_MISSING_STATUS_CODE = 1005,
- CC_ABNORMAL_DISCONNECTION = 1006,
- CC_WRONG_DATATYPE = 1007,
- CC_POLICY_VIOLATED = 1008,
- CC_TOO_MUCH_DATA = 1009,
- CC_MISSING_EXTENSION = 1010,
- CC_BAD_OPERATION = 1011,
- CC_TLS_HANDSHAKE_FAILED = 1015
+ CloseCodeNormal = 1000,
+ CloseCodeGoingAway = 1001,
+ CloseCodeProtocolError = 1002,
+ CloseCodeDatatypeNotSupported = 1003,
+ CloseCodeReserved1004 = 1004,
+ CloseCodeMissingStatusCode = 1005,
+ CloseCodeAbnormalDisconnection = 1006,
+ CloseCodeWrongDatatype = 1007,
+ CloseCodePolicyViolated = 1008,
+ CloseCodeTooMuchData = 1009,
+ CloseCodeMissingExtension = 1010,
+ CloseCodeBadOperation = 1011,
+ CloseCodeTlsHandshakeFailed = 1015
};
-inline Version currentVersion() { return V_LATEST; }
+inline Version currentVersion() { return VersionLatest; }
} //end namespace QWebSocketProtocol
{
enum OpCode
{
- OC_CONTINUE = 0x0,
- OC_TEXT = 0x1,
- OC_BINARY = 0x2,
- OC_RESERVED_3 = 0x3,
- OC_RESERVED_4 = 0x4,
- OC_RESERVED_5 = 0x5,
- OC_RESERVED_6 = 0x6,
- OC_RESERVED_7 = 0x7,
- OC_CLOSE = 0x8,
- OC_PING = 0x9,
- OC_PONG = 0xA,
- OC_RESERVED_B = 0xB,
- OC_RESERVED_C = 0xC,
- OC_RESERVED_D = 0xD,
- OC_RESERVED_E = 0xE,
- OC_RESERVED_F = 0xF
+ OpCodeContinue = 0x0,
+ OpCodeText = 0x1,
+ OpCodeBinary = 0x2,
+ OpCodeReserved3 = 0x3,
+ OpCodeReserved4 = 0x4,
+ OpCodeReserved5 = 0x5,
+ OpCodeReserved6 = 0x6,
+ OpCodeReserved7 = 0x7,
+ OpCodeClose = 0x8,
+ OpCodePing = 0x9,
+ OpCodePong = 0xA,
+ OpCodeReservedB = 0xB,
+ OpCodeReservedC = 0xC,
+ OpCodeReservedD = 0xD,
+ OpCodeReservedE = 0xE,
+ OpCodeReservedF = 0xF
};
inline bool isOpCodeReserved(OpCode code)
{
- return ((code > OC_BINARY) && (code < OC_CLOSE)) || (code > OC_PONG);
+ return ((code > OpCodeBinary) && (code < OpCodeClose)) || (code > OpCodePong);
}
inline bool isCloseCodeValid(int closeCode)
{
return (closeCode > 999) && (closeCode < 5000) &&
- (closeCode != CC_RESERVED_1004) && //see RFC6455 7.4.1
- (closeCode != CC_MISSING_STATUS_CODE) &&
- (closeCode != CC_ABNORMAL_DISCONNECTION) &&
+ (closeCode != CloseCodeReserved1004) && //see RFC6455 7.4.1
+ (closeCode != CloseCodeMissingStatusCode) &&
+ (closeCode != CloseCodeAbnormalDisconnection) &&
((closeCode >= 3000) || (closeCode < 1012));
}
/*!
\enum QWebSocketServer::SecureMode
- Indicates whether the server operates over wss (SECURE_MODE) or ws (NON_SECURE_MODE)
+ Indicates whether the server operates over wss (SecureModeSecure) or ws (SecureModeNonSecure)
- \value SECURE_MODE The server operates in secure mode (over wss)
- \value NON_SECURE_MODE The server operates in non-secure mode (over ws)
+ \value SecureModeSecure The server operates in secure mode (over wss)
+ \value SecureModeNonSecure The server operates in non-secure mode (over ws)
*/
#include "qwebsocketprotocol.h"
QObject(parent),
d_ptr(new QWebSocketServerPrivate(serverName,
#ifndef QT_NO_SSL
- (secureMode == SECURE_MODE) ?
- QWebSocketServerPrivate::SECURE_MODE :
- QWebSocketServerPrivate::NON_SECURE_MODE,
+ (secureMode == SecureModeSecure) ?
+ QWebSocketServerPrivate::SecureModeSecure :
+ QWebSocketServerPrivate::SecureModeNonSecure,
#else
- QWebSocketServerPrivate::NON_SECURE_MODE,
+ QWebSocketServerPrivate::SecureModeNonSecure,
#endif
this,
this))
/*!
Sets the SSL configuration for the websocket server to \a sslConfiguration.
This method has no effect if QWebSocketServer runs in non-secure mode
- (QWebSocketServer::NON_SECURE_MODE).
+ (QWebSocketServer::SecureModeNonSecure).
\sa sslConfiguration(), SecureMode
*/
{
#ifndef QT_NO_SSL
Q_D(const QWebSocketServer);
- return (d->secureMode() == QWebSocketServerPrivate::SECURE_MODE) ?
- QWebSocketServer::SECURE_MODE : QWebSocketServer::NON_SECURE_MODE;
+ return (d->secureMode() == QWebSocketServerPrivate::SecureModeSecure) ?
+ QWebSocketServer::SecureModeSecure : QWebSocketServer::SecureModeNonSecure;
#else
- return QWebSocketServer::NON_SECURE_MODE;
+ return QWebSocketServer::SecureModeNonSecure;
#endif
}
public:
enum SecureMode {
#ifndef QT_NO_SSL
- SECURE_MODE,
+ SecureModeSecure,
#endif
- NON_SECURE_MODE
+ SecureModeNonSecure
};
explicit QWebSocketServer(const QString &serverName, SecureMode secureMode,
m_serverName(serverName),
m_secureMode(secureMode),
m_pendingConnections(),
- m_error(QWebSocketProtocol::CC_NORMAL),
+ m_error(QWebSocketProtocol::CloseCodeNormal),
m_errorString()
{
Q_ASSERT(pWebSocketServer);
- if (m_secureMode == NON_SECURE_MODE) {
+ if (m_secureMode == SecureModeSecure) {
m_pTcpServer = new QTcpServer(this);
if (Q_LIKELY(m_pTcpServer))
connect(m_pTcpServer, &QTcpServer::newConnection,
m_pTcpServer->close();
while (!m_pendingConnections.isEmpty()) {
QWebSocket *pWebSocket = m_pendingConnections.dequeue();
- pWebSocket->close(QWebSocketProtocol::CC_GOING_AWAY, tr("Server closed."));
+ pWebSocket->close(QWebSocketProtocol::CloseCodeGoingAway, tr("Server closed."));
pWebSocket->deleteLater();
}
//emit signal via the event queue, so the server gets time
#ifndef QT_NO_SSL
void QWebSocketServerPrivate::setSslConfiguration(const QSslConfiguration &sslConfiguration)
{
- if (m_secureMode == SECURE_MODE)
+ if (m_secureMode == SecureModeSecure)
qobject_cast<QSslServer *>(m_pTcpServer)->setSslConfiguration(sslConfiguration);
else
qWarning() << tr("Cannot set SSL configuration for non-secure server.");
QSslConfiguration QWebSocketServerPrivate::sslConfiguration() const
{
- if (m_secureMode == SECURE_MODE)
+ if (m_secureMode == SecureModeSecure)
return qobject_cast<QSslServer *>(m_pTcpServer)->sslConfiguration();
else
return QSslConfiguration::defaultConfiguration();
pTcpSocket->close();
qWarning() <<
tr("Too many pending connections: new websocket connection not accepted.");
- setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION,
+ setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
tr("Too many pending connections."));
return;
}
Q_EMIT q->newConnection();
success = true;
} else {
- setError(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION,
+ setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
tr("Upgrading to websocket failed."));
}
}
setError(response.error(), response.errorString());
}
} else {
- setError(QWebSocketProtocol::CC_PROTOCOL_ERROR, tr("Invalid response received."));
+ setError(QWebSocketProtocol::CloseCodeProtocolError, tr("Invalid response received."));
}
}
if (!success) {
public:
enum SecureMode
{
- SECURE_MODE = true,
- NON_SECURE_MODE
+ SecureModeSecure = true,
+ SecureModeNonSecure
};
explicit QWebSocketServerPrivate(const QString &serverName, SecureMode secureMode,
QWebSocketDataProcessor dataProcessor;
QFETCH(QByteArray, payload);
- data.append((char)(FIN | QWebSocketProtocol::OC_BINARY));
+ data.append((char)(FIN | QWebSocketProtocol::OpCodeBinary));
if (payload.length() < 126)
{
QFETCH(QByteArray, payload);
QFETCH(int, size);
- data.append((char)(FIN | QWebSocketProtocol::OC_TEXT));
+ data.append((char)(FIN | QWebSocketProtocol::OpCodeText));
if (payload.length() < 126)
{
QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
- data.append((char)(FIN | QWebSocketProtocol::OC_PING));
+ data.append((char)(FIN | QWebSocketProtocol::OpCodePing));
data.append(QChar::fromLatin1(0));
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
data.clear();
pingReceivedSpy.clear();
pongReceivedSpy.clear();
- data.append((char)(FIN | QWebSocketProtocol::OC_PONG));
+ data.append((char)(FIN | QWebSocketProtocol::OpCodePong));
data.append(QChar::fromLatin1(0));
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
for (int i = 0; i < 124; ++i)
{
QTest::newRow(QStringLiteral("Close frame with %1 ASCII characters").arg(i).toLatin1().constData())
- << QString(i, 'a') << QWebSocketProtocol::CC_NORMAL;
+ << QString(i, 'a') << QWebSocketProtocol::CloseCodeNormal;
}
for (int i = 0; i < 126; ++i)
{
QTest::newRow(QStringLiteral("Text frame with containing ASCII character '0x%1'")
.arg(QByteArray(1, char(i)).toHex().constData()).toLatin1().constData())
- << QString(1, char(i)) << QWebSocketProtocol::CC_NORMAL;
+ << QString(1, char(i)) << QWebSocketProtocol::CloseCodeNormal;
}
- QTest::newRow("Close frame with close code NORMAL") << QString(1, 'a') << QWebSocketProtocol::CC_NORMAL;
- QTest::newRow("Close frame with close code BAD OPERATION") << QString(1, 'a') << QWebSocketProtocol::CC_BAD_OPERATION;
- QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED") << QString(1, 'a') << QWebSocketProtocol::CC_DATATYPE_NOT_SUPPORTED;
- QTest::newRow("Close frame with close code GOING AWAY") << QString(1, 'a') << QWebSocketProtocol::CC_GOING_AWAY;
- QTest::newRow("Close frame with close code MISSING EXTENSION") << QString(1, 'a') << QWebSocketProtocol::CC_MISSING_EXTENSION;
- QTest::newRow("Close frame with close code POLICY VIOLATED") << QString(1, 'a') << QWebSocketProtocol::CC_POLICY_VIOLATED;
- QTest::newRow("Close frame with close code PROTOCOL ERROR") << QString(1, 'a') << QWebSocketProtocol::CC_PROTOCOL_ERROR;
- QTest::newRow("Close frame with close code TOO MUCH DATA") << QString(1, 'a') << QWebSocketProtocol::CC_TOO_MUCH_DATA;
- QTest::newRow("Close frame with close code WRONG DATATYPE") << QString(1, 'a') << QWebSocketProtocol::CC_WRONG_DATATYPE;
- QTest::newRow("Close frame with close code 3000") << QString(1, 'a') << QWebSocketProtocol::CloseCode(3000);
- QTest::newRow("Close frame with close code 3999") << QString(1, 'a') << QWebSocketProtocol::CloseCode(3999);
- QTest::newRow("Close frame with close code 4000") << QString(1, 'a') << QWebSocketProtocol::CloseCode(4000);
- QTest::newRow("Close frame with close code 4999") << QString(1, 'a') << QWebSocketProtocol::CloseCode(4999);
+ QTest::newRow("Close frame with close code NORMAL")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeNormal;
+ QTest::newRow("Close frame with close code BAD OPERATION")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeBadOperation;
+ QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeDatatypeNotSupported;
+ QTest::newRow("Close frame with close code GOING AWAY")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeGoingAway;
+ QTest::newRow("Close frame with close code MISSING EXTENSION")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeMissingExtension;
+ QTest::newRow("Close frame with close code POLICY VIOLATED")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodePolicyViolated;
+ QTest::newRow("Close frame with close code PROTOCOL ERROR")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeProtocolError;
+ QTest::newRow("Close frame with close code TOO MUCH DATA")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeTooMuchData;
+ QTest::newRow("Close frame with close code WRONG DATATYPE")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCodeWrongDatatype;
+ QTest::newRow("Close frame with close code 3000")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCode(3000);
+ QTest::newRow("Close frame with close code 3999")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCode(3999);
+ QTest::newRow("Close frame with close code 4000")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCode(4000);
+ QTest::newRow("Close frame with close code 4999")
+ << QString(1, 'a') << QWebSocketProtocol::CloseCode(4999);
//close frames with no close reason
- QTest::newRow("Close frame with close code NORMAL and no reason") << QString() << QWebSocketProtocol::CC_NORMAL;
- QTest::newRow("Close frame with close code BAD OPERATION and no reason") << QString() << QWebSocketProtocol::CC_BAD_OPERATION;
- QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED and no reason") << QString() << QWebSocketProtocol::CC_DATATYPE_NOT_SUPPORTED;
- QTest::newRow("Close frame with close code GOING AWAY and no reason") << QString() << QWebSocketProtocol::CC_GOING_AWAY;
- QTest::newRow("Close frame with close code MISSING EXTENSION and no reason") << QString() << QWebSocketProtocol::CC_MISSING_EXTENSION;
- QTest::newRow("Close frame with close code POLICY VIOLATED and no reason") << QString() << QWebSocketProtocol::CC_POLICY_VIOLATED;
- QTest::newRow("Close frame with close code PROTOCOL ERROR and no reason") << QString() << QWebSocketProtocol::CC_PROTOCOL_ERROR;
- QTest::newRow("Close frame with close code TOO MUCH DATA and no reason") << QString() << QWebSocketProtocol::CC_TOO_MUCH_DATA;
- QTest::newRow("Close frame with close code WRONG DATATYPE and no reason") << QString() << QWebSocketProtocol::CC_WRONG_DATATYPE;
- QTest::newRow("Close frame with close code 3000 and no reason") << QString() << QWebSocketProtocol::CloseCode(3000);
- QTest::newRow("Close frame with close code 3999 and no reason") << QString() << QWebSocketProtocol::CloseCode(3999);
- QTest::newRow("Close frame with close code 4000 and no reason") << QString() << QWebSocketProtocol::CloseCode(4000);
- QTest::newRow("Close frame with close code 4999 and no reason") << QString() << QWebSocketProtocol::CloseCode(4999);
-
- QTest::newRow("Close frame with no close code and no reason") << QString() << QWebSocketProtocol::CloseCode(0);
+ QTest::newRow("Close frame with close code NORMAL and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeNormal;
+ QTest::newRow("Close frame with close code BAD OPERATION and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeBadOperation;
+ QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeDatatypeNotSupported;
+ QTest::newRow("Close frame with close code GOING AWAY and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeGoingAway;
+ QTest::newRow("Close frame with close code MISSING EXTENSION and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeMissingExtension;
+ QTest::newRow("Close frame with close code POLICY VIOLATED and no reason")
+ << QString() << QWebSocketProtocol::CloseCodePolicyViolated;
+ QTest::newRow("Close frame with close code PROTOCOL ERROR and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeProtocolError;
+ QTest::newRow("Close frame with close code TOO MUCH DATA and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeTooMuchData;
+ QTest::newRow("Close frame with close code WRONG DATATYPE and no reason")
+ << QString() << QWebSocketProtocol::CloseCodeWrongDatatype;
+ QTest::newRow("Close frame with close code 3000 and no reason")
+ << QString() << QWebSocketProtocol::CloseCode(3000);
+ QTest::newRow("Close frame with close code 3999 and no reason")
+ << QString() << QWebSocketProtocol::CloseCode(3999);
+ QTest::newRow("Close frame with close code 4000 and no reason")
+ << QString() << QWebSocketProtocol::CloseCode(4000);
+ QTest::newRow("Close frame with close code 4999 and no reason")
+ << QString() << QWebSocketProtocol::CloseCode(4999);
+
+ QTest::newRow("Close frame with no close code and no reason")
+ << QString() << QWebSocketProtocol::CloseCode(0);
}
void tst_DataProcessor::goodOpcodes_data()
{
QTest::addColumn<QWebSocketProtocol::OpCode>("opCode");
- QTest::newRow("Frame with PING opcode") << QWebSocketProtocol::OC_PING;
- QTest::newRow("Frame with PONG opcode") << QWebSocketProtocol::OC_PONG;
- QTest::newRow("Frame with TEXT opcode") << QWebSocketProtocol::OC_TEXT;
- QTest::newRow("Frame with BINARY opcode") << QWebSocketProtocol::OC_BINARY;
- QTest::newRow("Frame with CLOSE opcode") << QWebSocketProtocol::OC_CLOSE;
+ QTest::newRow("Frame with PING opcode") << QWebSocketProtocol::OpCodePing;
+ QTest::newRow("Frame with PONG opcode") << QWebSocketProtocol::OpCodePong;
+ QTest::newRow("Frame with TEXT opcode") << QWebSocketProtocol::OpCodeText;
+ QTest::newRow("Frame with BINARY opcode") << QWebSocketProtocol::OpCodeBinary;
+ QTest::newRow("Frame with CLOSE opcode") << QWebSocketProtocol::OpCodeClose;
}
void tst_DataProcessor::goodOpcodes()
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
- QSignalSpy errorReceivedSpy(&dataProcessor, SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
- QSignalSpy closeReceivedSpy(&dataProcessor, SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
- QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
- QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
- QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
- QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
- QSignalSpy binaryFrameReceivedSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
- QSignalSpy binaryMessageReceivedSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
+ QSignalSpy errorReceivedSpy(&dataProcessor,
+ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
+ QSignalSpy closeReceivedSpy(&dataProcessor,
+ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
+ QSignalSpy pingReceivedSpy(&dataProcessor,
+ SIGNAL(pingReceived(QByteArray)));
+ QSignalSpy pongReceivedSpy(&dataProcessor,
+ SIGNAL(pongReceived(QByteArray)));
+ QSignalSpy textFrameReceivedSpy(&dataProcessor,
+ SIGNAL(textFrameReceived(QString,bool)));
+ QSignalSpy textMessageReceivedSpy(&dataProcessor,
+ SIGNAL(textMessageReceived(QString)));
+ QSignalSpy binaryFrameReceivedSpy(&dataProcessor,
+ SIGNAL(binaryFrameReceived(QByteArray,bool)));
+ QSignalSpy binaryMessageReceivedSpy(&dataProcessor,
+ SIGNAL(binaryMessageReceived(QByteArray)));
dataProcessor.process(&buffer);
QCOMPARE(errorReceivedSpy.count(), 0);
- QCOMPARE(pingReceivedSpy.count(), opCode == QWebSocketProtocol::OC_PING ? 1 : 0);
- QCOMPARE(pongReceivedSpy.count(), opCode == QWebSocketProtocol::OC_PONG ? 1 : 0);
- QCOMPARE(closeReceivedSpy.count(), opCode == QWebSocketProtocol::OC_CLOSE ? 1 : 0);
- QCOMPARE(textFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OC_TEXT ? 1 : 0);
- QCOMPARE(textMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OC_TEXT ? 1 : 0);
- QCOMPARE(binaryFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OC_BINARY ? 1 : 0);
- QCOMPARE(binaryMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OC_BINARY ? 1 : 0);
+ QCOMPARE(pingReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodePing ? 1 : 0);
+ QCOMPARE(pongReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodePong ? 1 : 0);
+ QCOMPARE(closeReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeClose ? 1 : 0);
+ QCOMPARE(textFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
+ QCOMPARE(textMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
+ QCOMPARE(binaryFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
+ QCOMPARE(binaryMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
buffer.close();
}
quint16 swapped = qToBigEndian<quint16>(closeCode);
const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
- data.append((char)(FIN | QWebSocketProtocol::OC_CLOSE));
+ data.append((char)(FIN | QWebSocketProtocol::OpCodeClose));
if (swapped != 0)
{
data.append(char(payload.length() + 2)).append(wireRepresentation, 2).append(payload);
else
{
data.append(QChar::fromLatin1(0)); //payload length 0;
- //dataprocessor emits a CC_NORMAL close code when none is present
- closeCode = QWebSocketProtocol::CC_NORMAL;
+ //dataprocessor emits a CloseCodeNormal close code when none is present
+ closeCode = QWebSocketProtocol::CloseCodeNormal;
}
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
QWebSocketDataProcessor dataProcessor;
QByteArray firstFrame;
- firstFrame.append(quint8(QWebSocketProtocol::OC_TEXT)).append(char(1)).append(QByteArray(1, 'a'));
+ firstFrame.append(quint8(QWebSocketProtocol::OpCodeText)).append(char(1))
+ .append(QByteArray(1, 'a'));
- //with nothing in the buffer, the dataProcessor should time out and the error should be CC_GOING_AWAY
+ //with nothing in the buffer, the dataProcessor should time out and the error should be CloseCodeGoingAway
//meaning the socket will be closed
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
QCOMPARE(binaryFrameSpy.count(), 0);
QList<QVariant> arguments = errorSpy.takeFirst();
- QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+ QWebSocketProtocol::CloseCodeGoingAway);
errorSpy.clear();
closeSpy.clear();
pingMessageSpy.clear();
buffer.close();
data.clear();
- //only one byte; this is far too little; should get a time out as well and the error should be CC_GOING_AWAY
+ //only one byte; this is far too little;
+ //should get a time out as well and the error should be CloseCodeGoingAway
//meaning the socket will be closed
data.append(quint8('1')); //put 1 byte in the buffer; this is too little
buffer.setData(data);
QCOMPARE(binaryFrameSpy.count(), 0);
arguments = errorSpy.takeFirst();
- QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+ QWebSocketProtocol::CloseCodeGoingAway);
buffer.close();
errorSpy.clear();
closeSpy.clear();
{
//text frame with final bit not set
- data.append((char)(QWebSocketProtocol::OC_TEXT)).append(char(0x0));
+ data.append((char)(QWebSocketProtocol::OpCodeText)).append(char(0x0));
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
buffer.close();
data.clear();
- //with nothing in the buffer, the dataProcessor should time out and the error should be CC_GOING_AWAY
+ //with nothing in the buffer,
+ //the dataProcessor should time out and the error should be CloseCodeGoingAway
//meaning the socket will be closed
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
- QSignalSpy errorSpy(&dataProcessor, SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
+ QSignalSpy errorSpy(&dataProcessor,
+ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
dataProcessor.process(&buffer);
QCOMPARE(errorSpy.count(), 1);
QCOMPARE(binaryFrameSpy.count(), 0);
QList<QVariant> arguments = errorSpy.takeFirst();
- QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+ QWebSocketProtocol::CloseCodeGoingAway);
errorSpy.clear();
closeSpy.clear();
pingMessageSpy.clear();
data.clear();
//text frame with final bit not set
- data.append((char)(QWebSocketProtocol::OC_TEXT)).append(char(0x0));
+ data.append((char)(QWebSocketProtocol::OpCodeText)).append(char(0x0));
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
dataProcessor.process(&buffer);
textFrameSpy.clear();
binaryFrameSpy.clear();
- //only 1 byte follows in continuation frame; should time out with close code CC_GOING_AWAY
+ //only 1 byte follows in continuation frame;
+ //should time out with close code CloseCodeGoingAway
data.append('a');
buffer.setData(data);
buffer.open(QIODevice::ReadOnly);
QCOMPARE(textFrameSpy.count(), 0);
QCOMPARE(binaryFrameSpy.count(), 0);
arguments = errorSpy.takeFirst();
- QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), QWebSocketProtocol::CC_GOING_AWAY);
+ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
+ QWebSocketProtocol::CloseCodeGoingAway);
buffer.close();
}
}
swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
QTest::newRow("Text frame with payload size > INT_MAX")
- << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+ << quint8(FIN | QWebSocketProtocol::OpCodeText)
<< quint8(127)
<< QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
<< false
- << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+ << QWebSocketProtocol::CloseCodeTooMuchData;
swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
QTest::newRow("Binary frame with payload size > INT_MAX")
- << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
<< quint8(127)
<< QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
<< false
- << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+ << QWebSocketProtocol::CloseCodeTooMuchData;
swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
QTest::newRow("Continuation frame with payload size > INT_MAX")
- << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
<< quint8(127)
<< QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
<< true
- << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+ << QWebSocketProtocol::CloseCodeTooMuchData;
}
void tst_DataProcessor::frameTooBig()
invalidField("RSV1, RSV2 and RSV3 set", RSV1 | RSV2 | RSV3);
//invalid opcodes
- invalidField("Invalid OpCode 3", QWebSocketProtocol::OC_RESERVED_3);
- invalidField("Invalid OpCode 4", QWebSocketProtocol::OC_RESERVED_4);
- invalidField("Invalid OpCode 5", QWebSocketProtocol::OC_RESERVED_5);
- invalidField("Invalid OpCode 6", QWebSocketProtocol::OC_RESERVED_6);
- invalidField("Invalid OpCode 7", QWebSocketProtocol::OC_RESERVED_7);
- invalidField("Invalid OpCode B", QWebSocketProtocol::OC_RESERVED_B);
- invalidField("Invalid OpCode C", QWebSocketProtocol::OC_RESERVED_C);
- invalidField("Invalid OpCode D", QWebSocketProtocol::OC_RESERVED_D);
- invalidField("Invalid OpCode E", QWebSocketProtocol::OC_RESERVED_E);
- invalidField("Invalid OpCode F", QWebSocketProtocol::OC_RESERVED_F);
+ invalidField("Invalid OpCode 3", QWebSocketProtocol::OpCodeReserved3);
+ invalidField("Invalid OpCode 4", QWebSocketProtocol::OpCodeReserved4);
+ invalidField("Invalid OpCode 5", QWebSocketProtocol::OpCodeReserved5);
+ invalidField("Invalid OpCode 6", QWebSocketProtocol::OpCodeReserved6);
+ invalidField("Invalid OpCode 7", QWebSocketProtocol::OpCodeReserved7);
+ invalidField("Invalid OpCode B", QWebSocketProtocol::OpCodeReservedB);
+ invalidField("Invalid OpCode C", QWebSocketProtocol::OpCodeReservedC);
+ invalidField("Invalid OpCode D", QWebSocketProtocol::OpCodeReservedD);
+ invalidField("Invalid OpCode E", QWebSocketProtocol::OpCodeReservedE);
+ invalidField("Invalid OpCode F", QWebSocketProtocol::OpCodeReservedF);
}
void tst_DataProcessor::invalidHeader()
QTest::newRow("Close control frame with payload size 126")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(126)
<< QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Ping control frame with payload size 126")
- << quint8(FIN | QWebSocketProtocol::OC_PING)
+ << quint8(FIN | QWebSocketProtocol::OpCodePing)
<< quint8(126)
<< QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Close control frame with payload size 126")
- << quint8(FIN | QWebSocketProtocol::OC_PONG)
+ << quint8(FIN | QWebSocketProtocol::OpCodePong)
<< quint8(126)
<< QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Non-final close control frame (fragmented)")
- << quint8(QWebSocketProtocol::OC_CLOSE)
+ << quint8(QWebSocketProtocol::OpCodeClose)
<< quint8(32)
<< QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Non-final ping control frame (fragmented)")
- << quint8(QWebSocketProtocol::OC_PING)
+ << quint8(QWebSocketProtocol::OpCodePing)
<< quint8(32) << QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Non-final pong control frame (fragmented)")
- << quint8(QWebSocketProtocol::OC_PONG)
+ << quint8(QWebSocketProtocol::OpCodePong)
<< quint8(32)
<< QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
void tst_DataProcessor::invalidControlFrame()
QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
QTest::newRow("Close control frame with payload size 1")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(1)
<< QByteArray(1, 'a')
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
- quint16 swapped = qToBigEndian<quint16>(QWebSocketProtocol::CC_ABNORMAL_DISCONNECTION);
+ << QWebSocketProtocol::CloseCodeProtocolError;
+ quint16 swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeAbnormalDisconnection);
const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
//Not allowed per RFC 6455 (see para 7.4.1)
QTest::newRow("Close control frame close code ABNORMAL DISCONNECTION")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
- swapped = qToBigEndian<quint16>(QWebSocketProtocol::CC_MISSING_STATUS_CODE);
+ << QWebSocketProtocol::CloseCodeProtocolError;
+ swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeMissingStatusCode);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
//Not allowed per RFC 6455 (see para 7.4.1)
QTest::newRow("Close control frame close code MISSING STATUS CODE")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(1004);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 1004")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
- swapped = qToBigEndian<quint16>(QWebSocketProtocol::CC_TLS_HANDSHAKE_FAILED);
+ << QWebSocketProtocol::CloseCodeProtocolError;
+ swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeTlsHandshakeFailed);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
//Not allowed per RFC 6455 (see para 7.4.1)
QTest::newRow("Close control frame close code TLS HANDSHAKE FAILED")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(0);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 0")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(999);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 999")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(1012);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 1012")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(1013);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 1013")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(1014);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 1014")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(1100);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 1100")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(2000);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 2000")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(2999);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 2999")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(5000);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 5000")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
swapped = qToBigEndian<quint16>(65535u);
wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
QTest::newRow("Close control frame close code 65535")
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(2)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
void tst_DataProcessor::invalidCloseFrame()
QTest::addColumn<bool>("isContinuationFrame");
QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
- incompleteFrame(QWebSocketProtocol::OC_TEXT, 125, 0);
- incompleteFrame(QWebSocketProtocol::OC_TEXT, 64, 32);
- incompleteFrame(QWebSocketProtocol::OC_TEXT, 256, 32);
- incompleteFrame(QWebSocketProtocol::OC_TEXT, 128000, 32);
- incompleteFrame(QWebSocketProtocol::OC_BINARY, 125, 0);
- incompleteFrame(QWebSocketProtocol::OC_BINARY, 64, 32);
- incompleteFrame(QWebSocketProtocol::OC_BINARY, 256, 32);
- incompleteFrame(QWebSocketProtocol::OC_BINARY, 128000, 32);
- incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 125, 0);
- incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 64, 32);
- incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 256, 32);
- incompleteFrame(QWebSocketProtocol::OC_CONTINUE, 128000, 32);
-
- incompleteFrame(QWebSocketProtocol::OC_CLOSE, 64, 32);
- incompleteFrame(QWebSocketProtocol::OC_PING, 64, 32);
- incompleteFrame(QWebSocketProtocol::OC_PONG, 64, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeText, 125, 0);
+ incompleteFrame(QWebSocketProtocol::OpCodeText, 64, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeText, 256, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeText, 128000, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 125, 0);
+ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 64, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 256, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 128000, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 125, 0);
+ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 64, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 256, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 128000, 32);
+
+ incompleteFrame(QWebSocketProtocol::OpCodeClose, 64, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodePing, 64, 32);
+ incompleteFrame(QWebSocketProtocol::OpCodePong, 64, 32);
}
void tst_DataProcessor::incompletePayload()
if (isContinuationFrame)
{
- data.append(quint8(QWebSocketProtocol::OC_TEXT)).append(char(1)).append(QByteArray(1, 'a'));
+ data.append(quint8(QWebSocketProtocol::OpCodeText)).append(char(1)).append(QByteArray(1, 'a'));
}
data.append(firstByte).append(secondByte);
data.append(payload);
QString frameType;
switch (opCode)
{
- case QWebSocketProtocol::OC_BINARY:
+ case QWebSocketProtocol::OpCodeBinary:
{
frameType = QStringLiteral("Binary");
break;
}
- case QWebSocketProtocol::OC_TEXT:
+ case QWebSocketProtocol::OpCodeText:
{
frameType = QStringLiteral("Text");
break;
}
- case QWebSocketProtocol::OC_PING:
+ case QWebSocketProtocol::OpCodePing:
{
frameType = QStringLiteral("Ping");
break;
}
- case QWebSocketProtocol::OC_PONG:
+ case QWebSocketProtocol::OpCodePong:
{
frameType = QStringLiteral("Pong");
break;
}
- case QWebSocketProtocol::OC_CLOSE:
+ case QWebSocketProtocol::OpCodeClose:
{
frameType = QStringLiteral("Close");
break;
}
- case QWebSocketProtocol::OC_CONTINUE:
+ case QWebSocketProtocol::OpCodeContinue:
{
frameType = QStringLiteral("Continuation");
break;
}
- case QWebSocketProtocol::OC_RESERVED_3:
+ case QWebSocketProtocol::OpCodeReserved3:
{
frameType = QStringLiteral("Reserved3");
break;
}
- case QWebSocketProtocol::OC_RESERVED_4:
+ case QWebSocketProtocol::OpCodeReserved4:
{
frameType = QStringLiteral("Reserved5");
break;
}
- case QWebSocketProtocol::OC_RESERVED_5:
+ case QWebSocketProtocol::OpCodeReserved5:
{
frameType = QStringLiteral("Reserved5");
break;
}
- case QWebSocketProtocol::OC_RESERVED_6:
+ case QWebSocketProtocol::OpCodeReserved6:
{
frameType = QStringLiteral("Reserved6");
break;
}
- case QWebSocketProtocol::OC_RESERVED_7:
+ case QWebSocketProtocol::OpCodeReserved7:
{
frameType = QStringLiteral("Reserved7");
break;
}
- case QWebSocketProtocol::OC_RESERVED_B:
+ case QWebSocketProtocol::OpCodeReservedB:
{
frameType = QStringLiteral("ReservedB");
break;
}
- case QWebSocketProtocol::OC_RESERVED_C:
+ case QWebSocketProtocol::OpCodeReservedC:
{
frameType = QStringLiteral("ReservedC");
break;
}
- case QWebSocketProtocol::OC_RESERVED_D:
+ case QWebSocketProtocol::OpCodeReservedD:
{
frameType = QStringLiteral("ReservedD");
break;
}
- case QWebSocketProtocol::OC_RESERVED_E:
+ case QWebSocketProtocol::OpCodeReservedE:
{
frameType = QStringLiteral("ReservedE");
break;
}
- case QWebSocketProtocol::OC_RESERVED_F:
+ case QWebSocketProtocol::OpCodeReservedF:
{
frameType = QStringLiteral("ReservedF");
break;
const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped16));
QTest::newRow(QStringLiteral("Text frame with payload size %1, represented in 2 bytes")
.arg(sizeInBytes).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+ << quint8(FIN | QWebSocketProtocol::OpCodeText)
<< quint8(126)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow(QStringLiteral("Binary frame with payload size %1, represented in 2 bytes")
.arg(sizeInBytes).toLatin1().constBegin())
- << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
<< quint8(126)
<< QByteArray(wireRepresentation, 2)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow(QStringLiteral("Continuation frame with payload size %1, represented in 2 bytes")
.arg(sizeInBytes).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
<< quint8(126)
<< QByteArray(wireRepresentation, 2)
<< true
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
void tst_DataProcessor::minimumSize64Bit(quint64 sizeInBytes)
QTest::newRow(QStringLiteral("Text frame with payload size %1, represented in 8 bytes")
.arg(sizeInBytes).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+ << quint8(FIN | QWebSocketProtocol::OpCodeText)
<< quint8(127)
<< QByteArray(wireRepresentation, 8)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow(QStringLiteral("Binary frame with payload size %1, represented in 8 bytes")
.arg(sizeInBytes).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
<< quint8(127)
<< QByteArray(wireRepresentation, 8)
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow(QStringLiteral("Continuation frame with payload size %1, represented in 8 bytes")
.arg(sizeInBytes).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
<< quint8(127)
<< QByteArray(wireRepresentation, 8)
<< true
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequence, bool isCloseFrame)
if (isCloseFrame)
{
- quint16 closeCode = qToBigEndian<quint16>(QWebSocketProtocol::CC_NORMAL);
+ quint16 closeCode = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeNormal);
const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&closeCode));
QTest::newRow(QStringLiteral("Close frame with invalid UTF8-sequence: %1")
.arg(dataTag).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_CLOSE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
<< quint8(payload.length() + 2)
<< QByteArray(wireRepresentation, 2).append(payload)
<< false
- << QWebSocketProtocol::CC_WRONG_DATATYPE;
+ << QWebSocketProtocol::CloseCodeWrongDatatype;
}
else
{
QTest::newRow(QStringLiteral("Text frame with invalid UTF8-sequence: %1")
.arg(dataTag).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+ << quint8(FIN | QWebSocketProtocol::OpCodeText)
<< quint8(payload.length())
<< payload
<< false
- << QWebSocketProtocol::CC_WRONG_DATATYPE;
+ << QWebSocketProtocol::CloseCodeWrongDatatype;
QTest::newRow(QStringLiteral("Continuation text frame with invalid UTF8-sequence: %1")
.arg(dataTag).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
<< quint8(payload.length())
<< payload
<< true
- << QWebSocketProtocol::CC_WRONG_DATATYPE;
+ << QWebSocketProtocol::CloseCodeWrongDatatype;
}
}
<< quint8(0x00)
<< QByteArray()
<< false
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow(QString::fromLatin1(dataTag).append(" with continuation frame").toLatin1().constData())
<< quint8(FIN | invalidFieldValue)
<< quint8(0x00)
<< QByteArray()
<< true
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
void tst_DataProcessor::incompleteFrame(quint8 controlCode, quint64 indicatedSize, quint64 actualPayloadSize)
<< quint8(FIN | controlCode)
<< quint8(indicatedSize)
<< firstFrame.append(QByteArray(actualPayloadSize, 'a'))
- << (controlCode == QWebSocketProtocol::OC_CONTINUE)
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << (controlCode == QWebSocketProtocol::OpCodeContinue)
+ << QWebSocketProtocol::CloseCodeGoingAway;
}
else if (indicatedSize <= 0xFFFFu)
{
<< quint8(FIN | controlCode)
<< quint8(126)
<< firstFrame.append(QByteArray(wireRepresentation, 2).append(QByteArray(actualPayloadSize, 'a')))
- << (controlCode == QWebSocketProtocol::OC_CONTINUE)
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << (controlCode == QWebSocketProtocol::OpCodeContinue)
+ << QWebSocketProtocol::CloseCodeGoingAway;
}
else
{
<< quint8(FIN | controlCode)
<< quint8(127)
<< firstFrame.append(QByteArray(wireRepresentation, 8).append(QByteArray(actualPayloadSize, 'a')))
- << (controlCode == QWebSocketProtocol::OC_CONTINUE)
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << (controlCode == QWebSocketProtocol::OpCodeContinue)
+ << QWebSocketProtocol::CloseCodeGoingAway;
}
}
QTest::newRow(QStringLiteral("Text frame with payload containing the non-control character sequence 0x%1")
.arg(QString::fromLocal8Bit(sequence)).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+ << quint8(FIN | QWebSocketProtocol::OpCodeText)
<< quint8(utf8Sequence.size())
<< utf8Sequence
<< false;
QTest::newRow(QStringLiteral("Continuation frame with payload containing the non-control character sequence 0x%1")
.arg(QString::fromLocal8Bit(sequence)).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
<< quint8(utf8Sequence.size())
<< utf8Sequence
<< true;
{
QTest::newRow(QStringLiteral("Text frame with payload size %1, with %2 bytes following.")
.arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_TEXT)
+ << quint8(FIN | QWebSocketProtocol::OpCodeText)
<< quint8(payloadCode)
<< QByteArray(numBytesFollowing, quint8(1))
<< false
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << QWebSocketProtocol::CloseCodeGoingAway;
QTest::newRow(QStringLiteral("Binary frame with payload size %1, with %2 bytes following.")
.arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_BINARY)
+ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
<< quint8(payloadCode)
<< QByteArray(numBytesFollowing, quint8(1))
<< false
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << QWebSocketProtocol::CloseCodeGoingAway;
QTest::newRow(QStringLiteral("Continuation frame with payload size %1, with %2 bytes following.")
.arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
- << quint8(FIN | QWebSocketProtocol::OC_CONTINUE)
+ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
<< quint8(payloadCode)
<< QByteArray(numBytesFollowing, quint8(1))
<< true
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << QWebSocketProtocol::CloseCodeGoingAway;
}
QTEST_MAIN(tst_DataProcessor)
QCOMPARE(request.host(), QStringLiteral("foo.com"));
QCOMPARE(request.resourceName().length(), 5);
QCOMPARE(request.versions().length(), 1);
- QCOMPARE(request.versions().at(0), QWebSocketProtocol::V_13);
+ QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
}
void tst_HandshakeRequest::tst_multipleVersions()
QCOMPARE(request.resourceName().length(), 5);
QCOMPARE(request.versions().length(), 6);
//should be 13 since the list is ordered in decreasing order
- QCOMPARE(request.versions().at(0), QWebSocketProtocol::V_13);
+ QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
}
QTEST_MAIN(tst_HandshakeRequest)
FrameHelper::FrameHelper() :
m_rsv1(0), m_rsv2(0), m_rsv3(0),
- m_mask(0), m_opCode(QWebSocketProtocol::OC_RESERVED_3),
+ m_mask(0), m_opCode(QWebSocketProtocol::OpCodeReserved3),
m_payload(), m_isFinalFrame(false)
{}
frameHelper.setRsv3(0);
frameHelper.setFinalFrame(true);
frameHelper.setMask(1234u);
- frameHelper.setOpCode(QWebSocketProtocol::OC_BINARY);
+ frameHelper.setOpCode(QWebSocketProtocol::OpCodeBinary);
frameHelper.setPayload(QByteArray("12345"));
QByteArray payload = frameHelper.wireRepresentation();
QTest::newRow("Non masked final text frame with small payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
<< false << true << false;
QTest::newRow("Non masked final binary frame with small payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_BINARY
+ << 0U << QWebSocketProtocol::OpCodeBinary
<< true << QByteArrayLiteral("\x00\x01\x02\x03\x04")
<< false << true << false;
QTest::newRow("Non masked final text frame with no payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QByteArray()
<< false << true << false;
QTest::newRow("Non masked final binary frame with no payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_BINARY
+ << 0U << QWebSocketProtocol::OpCodeBinary
<< true << QByteArray()
<< false << true << false;
QTest::newRow("Non masked final close frame with small payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_CLOSE
+ << 0U << QWebSocketProtocol::OpCodeClose
<< true << QStringLiteral("Hello world!").toUtf8()
<< true << false << false;
QTest::newRow("Non masked final close frame with no payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_CLOSE
+ << 0U << QWebSocketProtocol::OpCodeClose
<< true << QByteArray()
<< true << false << false;
QTest::newRow("Non masked final ping frame with small payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_PING
+ << 0U << QWebSocketProtocol::OpCodePing
<< true << QStringLiteral("Hello world!").toUtf8()
<< true << false << false;
QTest::newRow("Non masked final pong frame with no payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_PONG
+ << 0U << QWebSocketProtocol::OpCodePong
<< true << QByteArray()
<< true << false << false;
QTest::newRow("Non masked final continuation frame with small payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_CONTINUE
+ << 0U << QWebSocketProtocol::OpCodeContinue
<< true << QStringLiteral("Hello world!").toUtf8()
<< false << true << true;
QTest::newRow("Non masked non-final continuation frame with small payload")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_CONTINUE
+ << 0U << QWebSocketProtocol::OpCodeContinue
<< false << QStringLiteral("Hello world!").toUtf8()
<< false << true << true;
}
QTest::newRow("RSV1 != 0")
<< 1 << 0 << 0
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("RSV2 != 0")
<< 0 << 1 << 0
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("RSV3 != 0")
<< 0 << 0 << 1
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("RSV1 != 0 and RSV2 != 0")
<< 1 << 1 << 0
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("RSV1 != 0 and RSV3 != 0")
<< 1 << 0 << 1
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("RSV2 != 0 and RSV3 != 0")
<< 0 << 1 << 1
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode 3")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_3
+ << 0U << QWebSocketProtocol::OpCodeReserved3
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode 4")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_4
+ << 0U << QWebSocketProtocol::OpCodeReserved4
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode 5")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_5
+ << 0U << QWebSocketProtocol::OpCodeReserved5
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode 6")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_6
+ << 0U << QWebSocketProtocol::OpCodeReserved6
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode 7")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_7
+ << 0U << QWebSocketProtocol::OpCodeReserved7
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode B")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_B
+ << 0U << QWebSocketProtocol::OpCodeReservedB
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode C")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_C
+ << 0U << QWebSocketProtocol::OpCodeReservedC
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode D")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_D
+ << 0U << QWebSocketProtocol::OpCodeReservedD
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode E")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_E
+ << 0U << QWebSocketProtocol::OpCodeReservedE
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Reserved OpCode F")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_RESERVED_F
+ << 0U << QWebSocketProtocol::OpCodeReservedF
<< true << QStringLiteral("Hello world!").toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Close Frame with payload > 125 bytes")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_CLOSE
+ << 0U << QWebSocketProtocol::OpCodeClose
<< true << QString(126, 'a').toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Non-final Close Frame")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_CLOSE
+ << 0U << QWebSocketProtocol::OpCodeClose
<< false << QString(126, 'a').toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Ping Frame with payload > 125 bytes")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_PING
+ << 0U << QWebSocketProtocol::OpCodePing
<< true << QString(126, 'a').toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Non-final Ping Frame")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_PING
+ << 0U << QWebSocketProtocol::OpCodePing
<< false << QString(126, 'a').toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Pong Frame with payload > 125 bytes")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_PONG
+ << 0U << QWebSocketProtocol::OpCodePong
<< true << QString(126, 'a').toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
QTest::newRow("Non-final Pong Frame")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_PONG
+ << 0U << QWebSocketProtocol::OpCodePong
<< false << QString(126, 'a').toUtf8()
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
void tst_WebSocketFrame::tst_invalidFrames()
*
QTest::newRow("Frame Too Big")
<< 0 << 0 << 0
- << 0U << QWebSocketProtocol::OC_TEXT
+ << 0U << QWebSocketProtocol::OpCodeText
<< true << QString(MAX_FRAME_SIZE_IN_BYTES + 1, 'a').toUtf8()
- << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+ << QWebSocketProtocol::CloseCodeTooMuchData;
*/
void tst_WebSocketFrame::tst_malformedFrames_data()
QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedError");
//too little data
- QTest::newRow("No data") << QByteArray() << QWebSocketProtocol::CC_GOING_AWAY;
+ QTest::newRow("No data") << QByteArray() << QWebSocketProtocol::CloseCodeGoingAway;
FrameHelper helper;
helper.setRsv1(0);
helper.setRsv2(0);
helper.setRsv3(0);
helper.setMask(0U);
- helper.setOpCode(QWebSocketProtocol::OC_TEXT);
+ helper.setOpCode(QWebSocketProtocol::OpCodeText);
helper.setFinalFrame(true);
helper.setPayload(QString(10, 'a').toUtf8());
QByteArray wireRep = helper.wireRepresentation();
{
QTest::newRow(QStringLiteral("Header too small - %1 byte(s)").arg(i).toLatin1().constData())
<< wireRep.left(i)
- << QWebSocketProtocol::CC_GOING_AWAY;
+ << QWebSocketProtocol::CloseCodeGoingAway;
}
//too much data
{
qToBigEndian<quint64>(payloadSize, swapped);
QTest::newRow("Frame too big")
<< wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
- << QWebSocketProtocol::CC_TOO_MUCH_DATA;
+ << QWebSocketProtocol::CloseCodeTooMuchData;
}
//invalid size field
{
qToBigEndian<quint64>(payloadSize, swapped);
QTest::newRow("Highest bit of payload length is set")
<< wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
payloadSize = 256;
qToBigEndian<quint64>(payloadSize, swapped);
QTest::newRow("Overlong 64-bit size field; should be 16-bit")
<< wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
//overlong size field
{
qToBigEndian<quint16>(payloadSize, swapped);
QTest::newRow("Overlong 16-bit size field")
<< wireRep.left(1).append(largepayloadIndicator).append(reinterpret_cast<char *>(swapped), 2)
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
{
const char bigpayloadIndicator = char(127);
qToBigEndian<quint64>(payloadSize, swapped);
QTest::newRow("Overlong 64-bit size field; should be 7-bit")
<< wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
payloadSize = 256;
qToBigEndian<quint64>(payloadSize, swapped);
QTest::newRow("Overlong 64-bit size field; should be 16-bit")
<< wireRep.left(1).append(bigpayloadIndicator).append(reinterpret_cast<char *>(swapped), 8)
- << QWebSocketProtocol::CC_PROTOCOL_ERROR;
+ << QWebSocketProtocol::CloseCodeProtocolError;
}
}
QTest::addColumn<QWebSocketProtocol::OpCode>("opCode");
QTest::addColumn<bool>("isReserved");
- QTest::newRow("OC_BINARY") << QWebSocketProtocol::OC_BINARY << false;
- QTest::newRow("OC_CLOSE") << QWebSocketProtocol::OC_CLOSE << false;
- QTest::newRow("OC_CONTINUE") << QWebSocketProtocol::OC_CONTINUE << false;
- QTest::newRow("OC_PING") << QWebSocketProtocol::OC_PING << false;
- QTest::newRow("OC_PONG") << QWebSocketProtocol::OC_PONG << false;
- QTest::newRow("OC_RESERVED3") << QWebSocketProtocol::OC_RESERVED_3 << true;
- QTest::newRow("OC_RESERVED4") << QWebSocketProtocol::OC_RESERVED_4 << true;
- QTest::newRow("OC_RESERVED5") << QWebSocketProtocol::OC_RESERVED_5 << true;
- QTest::newRow("OC_RESERVED6") << QWebSocketProtocol::OC_RESERVED_6 << true;
- QTest::newRow("OC_RESERVED7") << QWebSocketProtocol::OC_RESERVED_7 << true;
- QTest::newRow("OC_RESERVEDB") << QWebSocketProtocol::OC_RESERVED_B << true;
- QTest::newRow("OC_RESERVEDC") << QWebSocketProtocol::OC_RESERVED_C << true;
- QTest::newRow("OC_RESERVEDD") << QWebSocketProtocol::OC_RESERVED_D << true;
- QTest::newRow("OC_RESERVEDE") << QWebSocketProtocol::OC_RESERVED_E << true;
- QTest::newRow("OC_RESERVEDF") << QWebSocketProtocol::OC_RESERVED_F << true;
- QTest::newRow("OC_TEXT") << QWebSocketProtocol::OC_TEXT << false;
+ QTest::newRow("OpCodeBinary") << QWebSocketProtocol::OpCodeBinary << false;
+ QTest::newRow("OpCodeClose") << QWebSocketProtocol::OpCodeClose << false;
+ QTest::newRow("OpCodeContinue") << QWebSocketProtocol::OpCodeContinue << false;
+ QTest::newRow("OpCodePing") << QWebSocketProtocol::OpCodePing << false;
+ QTest::newRow("OpCodePong") << QWebSocketProtocol::OpCodePong << false;
+ QTest::newRow("OpCodeReserved3") << QWebSocketProtocol::OpCodeReserved3 << true;
+ QTest::newRow("OpCodeReserved4") << QWebSocketProtocol::OpCodeReserved4 << true;
+ QTest::newRow("OpCodeReserved5") << QWebSocketProtocol::OpCodeReserved5 << true;
+ QTest::newRow("OpCodeReserved6") << QWebSocketProtocol::OpCodeReserved6 << true;
+ QTest::newRow("OpCodeReserved7") << QWebSocketProtocol::OpCodeReserved7 << true;
+ QTest::newRow("OpCodeReserved8") << QWebSocketProtocol::OpCodeReservedB << true;
+ QTest::newRow("OpCodeReservedC") << QWebSocketProtocol::OpCodeReservedC << true;
+ QTest::newRow("OpCodeReservedD") << QWebSocketProtocol::OpCodeReservedD << true;
+ QTest::newRow("OpCodeReservedE") << QWebSocketProtocol::OpCodeReservedE << true;
+ QTest::newRow("OpCodeReservedF") << QWebSocketProtocol::OpCodeReservedF << true;
+ QTest::newRow("OpCodeText") << QWebSocketProtocol::OpCodeText << false;
}
void tst_WebSocketProtocol::tst_opCodes()
projects / contrib / qtwebsockets.git / commitdiff