Revision control
Copy as Markdown
// Copyright (C) 2018 Witekio.
// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtTest>
#include <QCoreApplication>
#include <private/qcoapinternalreply_p.h>
#include <private/qcoapreply_p.h>
class tst_QCoapInternalReply : public QObject
{
Q_OBJECT
private Q_SLOTS:
void parseReplyPdu_data();
void parseReplyPdu();
void parseInvalidReplyPdu_data();
void parseInvalidReplyPdu();
void parseExtendedOption();
void parseEmptyBlockOption();
void nextBlockToSendWithEmptyBlock1();
void updateReply_data();
void updateReply();
};
void tst_QCoapInternalReply::parseReplyPdu_data()
{
QTest::addColumn<QtCoap::ResponseCode>("responseCode");
QTest::addColumn<QCoapMessage::Type>("type");
QTest::addColumn<quint16>("messageId");
QTest::addColumn<QByteArray>("token");
QTest::addColumn<quint8>("tokenLength");
QTest::addColumn<QList<QCoapOption::OptionName>>("optionsNames");
QTest::addColumn<QList<quint8>>("optionsLengths");
QTest::addColumn<QList<QByteArray>>("optionsValues");
QTest::addColumn<QString>("payload");
QTest::addColumn<QString>("pduHexa");
QList<QCoapOption::OptionName> optionsNamesReply({QCoapOption::ContentFormat,
QCoapOption::MaxAge});
QList<quint8> optionsLengthsReply({0, 1});
QList<QByteArray> optionsValuesReply({"", QByteArray::fromHex("1e")});
QList<QCoapOption::OptionName> bigOptionNameReply({QCoapOption::Size1});
QList<quint8> bigOptionLengthReply({26});
QList<QByteArray> bigOptionValueReply({QByteArray("abcdefghijklmnopqrstuvwxyz")});
QTest::newRow("reply_with_options_and_payload")
<< QtCoap::ResponseCode::Content
<< QCoapMessage::Type::NonConfirmable
<< quint16(64463)
<< QByteArray("4647f09b")
<< quint8(4)
<< optionsNamesReply
<< optionsLengthsReply
<< optionsValuesReply
<< "Type: 1 (NON)\nCode: 1 (GET)\nMID: 56400\nToken: 4647f09b"
<< "5445fbcf4647f09bc0211eff547970653a203120284e4f4e290a436f64653a20"
"312028474554290a4d49443a2035363430300a546f6b656e3a20343634376630"
"3962";
QTest::newRow("reply_with_payload")
<< QtCoap::ResponseCode::Content
<< QCoapMessage::Type::NonConfirmable
<< quint16(64463)
<< QByteArray("4647f09b")
<< quint8(4)
<< QList<QCoapOption::OptionName>()
<< QList<quint8>()
<< QList<QByteArray>()
<< "Type: 1 (NON)\nCode: 1 (GET)\nMID: 56400\nToken: 4647f09b"
<< "5445fbcf4647f09bff547970653a203120284e4f4e290a436f64653a20312028"
"474554290a4d49443a2035363430300a546f6b656e3a203436343766303962";
QTest::newRow("reply_with_options")
<< QtCoap::ResponseCode::Content
<< QCoapMessage::Type::NonConfirmable
<< quint16(64463)
<< QByteArray("4647f09b")
<< quint8(4)
<< optionsNamesReply
<< optionsLengthsReply
<< optionsValuesReply
<< ""
<< "5445fbcf4647f09bc0211e";
QTest::newRow("reply_only")
<< QtCoap::ResponseCode::Content
<< QCoapMessage::Type::NonConfirmable
<< quint16(64463)
<< QByteArray("4647f09b")
<< quint8(4)
<< QList<QCoapOption::OptionName>()
<< QList<quint8>()
<< QList<QByteArray>()
<< ""
<< "5445fbcf4647f09b";
QTest::newRow("reply_with_big_option")
<< QtCoap::ResponseCode::Content
<< QCoapMessage::Type::NonConfirmable
<< quint16(64463)
<< QByteArray("4647f09b")
<< quint8(4)
<< bigOptionNameReply
<< bigOptionLengthReply
<< bigOptionValueReply
<< ""
<< "5445fbcf4647f09bdd2f0d6162636465666768696a6b6c6d6e6f707172737475"
"767778797a";
}
void tst_QCoapInternalReply::parseReplyPdu()
{
QFETCH(QtCoap::ResponseCode, responseCode);
QFETCH(QCoapMessage::Type, type);
QFETCH(quint16, messageId);
QFETCH(QByteArray, token);
QFETCH(quint8, tokenLength);
QFETCH(QList<QCoapOption::OptionName>, optionsNames);
QFETCH(QList<quint8>, optionsLengths);
QFETCH(QList<QByteArray>, optionsValues);
QFETCH(QString, payload);
QFETCH(QString, pduHexa);
QScopedPointer<QCoapInternalReply>
reply(QCoapInternalReply::createFromFrame(QByteArray::fromHex(pduHexa.toUtf8())));
QCOMPARE(reply->message()->type(), type);
QCOMPARE(reply->message()->tokenLength(), tokenLength);
QCOMPARE(reply->responseCode(), responseCode);
QCOMPARE(reply->message()->messageId(), messageId);
QCOMPARE(reply->message()->token().toHex(), token);
QCOMPARE(reply->message()->optionCount(), optionsNames.size());
for (int i = 0; i < reply->message()->optionCount(); ++i) {
QCoapOption option = reply->message()->optionAt(i);
QCOMPARE(option.name(), optionsNames.at(i));
QCOMPARE(option.length(), optionsLengths.at(i));
QCOMPARE(option.opaqueValue(), optionsValues.at(i));
}
QCOMPARE(reply->message()->payload(), payload.toUtf8());
}
void tst_QCoapInternalReply::parseInvalidReplyPdu_data()
{
QTest::addColumn<QByteArray>("frame");
// A CoAP message is at least 4 bytes long (the fixed header). Frames shorter
// than that must be rejected before the header is dereferenced;
// createFromFrame() signals rejection by returning nullptr.
QTest::newRow("empty") << QByteArray();
QTest::newRow("one_byte") << QByteArray::fromHex("50");
QTest::newRow("two_bytes") << QByteArray::fromHex("5045");
QTest::newRow("three_bytes") << QByteArray::fromHex("5045fb");
// Option-parser cases: each frame has a valid 4-byte header (no token)
// followed by a single option byte whose encoding demands bytes that are
// not present. createFromFrame() must reject the frame rather than read
// past the buffer or deliver a silently truncated option.
// 0x09: option value length 9, but no value bytes follow it.
QTest::newRow("option_value_overruns_buffer") << QByteArray::fromHex("50450001" "09");
// 0xd0: delta nibble 13 promises one extended delta byte that is missing.
QTest::newRow("missing_option_delta_ext_byte") << QByteArray::fromHex("50450001" "d0");
// 0x0d: length nibble 13 promises one extended length byte that is missing.
QTest::newRow("missing_option_length_ext_byte") << QByteArray::fromHex("50450001" "0d");
// 0x0d + 0xff: extended length yields optionLength 268, far past the buffer.
QTest::newRow("extended_option_length_overruns") << QByteArray::fromHex("50450001" "0d" "ff");
// 0xe0 + 0xffff: extended delta 0xffff -> option number 65535 + 269 = 65804,
// which exceeds the 65535 maximum, so the frame is rejected.
QTest::newRow("option_number_exceeds_max") << QByteArray::fromHex("50450001" "e0" "ffff");
// Token-length cases.
// TKL 9 is reserved (RFC 7252 §3) and must be rejected even when the 9 token
// bytes are present, so this frame includes them.
QTest::newRow("reserved_token_length") << QByteArray::fromHex("59450001" "aabbccddeeff001122");
// TKL 4 is valid, but no token bytes follow the 4-byte header.
QTest::newRow("truncated_token") << QByteArray::fromHex("54450001");
// RFC 7959 §2.2: SZX value 7 (block size 2048) is reserved. Reject a block
// option whose last byte has SZX 7 (low 3 bits set). Value byte 0x07 encodes
// NUM=0, M=0, SZX=7. Option header 0xd1 = delta 13 (extended), length 1.
// Block2 (number 23): extended delta byte 0x0a -> 10 + 13 = 23.
QTest::newRow("reserved_block2_szx7") << QByteArray::fromHex("50450001" "d10a" "07");
// Block1 (number 27): extended delta byte 0x0e -> 14 + 13 = 27.
QTest::newRow("reserved_block1_szx7") << QByteArray::fromHex("50450001" "d10e" "07");
// RFC 7959 §2.2: a block option value is 0-3 bytes; a 4-byte value is rejected
// (it would overflow the 20-bit block number). Option header 0xd4 = delta 13
// (extended), length 4; 0x0a -> Block2 (23); last byte 0x04 has a valid SZX, so
// this exercises the length check rather than the SZX check.
QTest::newRow("oversized_block2_value") << QByteArray::fromHex("50450001" "d40a" "01020304");
}
void tst_QCoapInternalReply::parseInvalidReplyPdu()
{
QFETCH(QByteArray, frame);
QScopedPointer<QCoapInternalReply> reply(QCoapInternalReply::createFromFrame(frame));
QVERIFY2(reply.isNull(),
"createFromFrame() must reject a malformed frame by returning nullptr");
}
void tst_QCoapInternalReply::parseExtendedOption()
{
// RFC 7252 §3.1: a delta/length nibble of 14 is followed by a 16-bit
// unsigned integer in network byte order (the value minus 269). Build one
// option that uses the 16-bit form for BOTH its delta and its length, with
// distinct first/second bytes so the test also verifies the byte order:
// 0xee -> delta nibble 14, length nibble 14
// 0x01 0x02 -> extended delta = 0x0102 = 258 -> option number 258 + 269 = 527
// 0x00 0x03 -> extended length = 0x0003 = 3 -> value length 3 + 269 = 272
// 272 value bytes
// A decoder that read one byte instead of two, or used the wrong byte order,
// would compute different numbers and misalign the rest of the frame.
const QByteArray value(272, 'x');
const QByteArray frame = QByteArray::fromHex("50450001" "ee" "0102" "0003") + value;
QScopedPointer<QCoapInternalReply> reply(QCoapInternalReply::createFromFrame(frame));
QVERIFY(!reply.isNull());
QCOMPARE(reply->message()->optionCount(), 1);
const QCoapOption option = reply->message()->options().constFirst();
QCOMPARE(static_cast<int>(option.name()), 527);
QCOMPARE(option.opaqueValue(), value);
}
void tst_QCoapInternalReply::parseEmptyBlockOption()
{
// RFC 7959 §2.2: a zero-length Block option is valid and encodes
// NUM=0, M=0, SZX=0. Frame: 4-byte header (no token), then a Block2
// option (number 23) carrying an empty value.
// 0xd0 -> option delta nibble 13 (extended), length nibble 0
// 0x0a -> extended delta byte, giving option number 13 + 10 = 23 (Block2)
const QByteArray frame = QByteArray::fromHex("50450001" "d0" "0a");
QScopedPointer<QCoapInternalReply> reply(QCoapInternalReply::createFromFrame(frame));
QVERIFY(!reply.isNull());
QCOMPARE(reply->currentBlockNumber(), 0u);
QVERIFY(!reply->hasMoreBlocksToReceive());
QCOMPARE(reply->blockSize(), 16u);
}
void tst_QCoapInternalReply::nextBlockToSendWithEmptyBlock1()
{
// A zero-length Block1 option is valid (RFC 7959 §2.2), encoding M=0, so
// there is no next block to send. nextBlockToSend() must return -1 rather
// than read optionData[-1]. Frame: 4-byte header, then a Block1 option
// (number 27) with an empty value.
// 0xd0 -> option delta nibble 13 (extended), length nibble 0
// 0x0e -> extended delta byte, giving option number 13 + 14 = 27 (Block1)
const QByteArray frame = QByteArray::fromHex("50450001" "d0" "0e");
QScopedPointer<QCoapInternalReply> reply(QCoapInternalReply::createFromFrame(frame));
QVERIFY(!reply.isNull());
QCOMPARE(reply->nextBlockToSend(), -1);
}
void tst_QCoapInternalReply::updateReply_data()
{
QTest::addColumn<QByteArray>("data");
QTest::newRow("success") << QByteArray("Data for the updating test");
}
void tst_QCoapInternalReply::updateReply()
{
QFETCH(QByteArray, data);
QScopedPointer<QCoapReply> reply(QCoapReplyPrivate::createCoapReply(QCoapRequest()));
QCoapInternalReply internalReply;
internalReply.message()->setPayload(data);
QSignalSpy spyReplyFinished(reply.data(), &QCoapReply::finished);
QMetaObject::invokeMethod(reply.data(), "_q_setContent",
Q_ARG(QHostAddress, internalReply.senderAddress()),
Q_ARG(QCoapMessage, *internalReply.message()),
Q_ARG(QtCoap::ResponseCode, internalReply.responseCode()));
QMetaObject::invokeMethod(reply.data(), "_q_setFinished", Q_ARG(QtCoap::Error, QtCoap::Error::Ok));
QTRY_COMPARE_WITH_TIMEOUT(spyReplyFinished.size(), 1, 1000);
QCOMPARE(reply->readAll(), data);
}
QTEST_MAIN(tst_QCoapInternalReply)
#include "tst_qcoapinternalreply.moc"