void TestPackets::testStreamFeatures()
{
const QByteArray xml("<stream:features/>");
QXmppStreamFeatures features;
parsePacket(features, xml);
QCOMPARE(features.bindMode(), QXmppStreamFeatures::Disabled);
QCOMPARE(features.sessionMode(), QXmppStreamFeatures::Disabled);
QCOMPARE(features.nonSaslAuthMode(), QXmppStreamFeatures::Disabled);
QCOMPARE(features.tlsMode(), QXmppStreamFeatures::Disabled);
QCOMPARE(features.authMechanisms(), QList<QXmppConfiguration::SASLAuthMechanism>());
QCOMPARE(features.compressionMethods(), QList<QXmppConfiguration::CompressionMethod>());
serializePacket(features, xml);
const QByteArray xml2("<stream:features>"
"<bind xmlns=\"urn:ietf:params:xml:ns:xmpp-bind\"/>"
"<session xmlns=\"urn:ietf:params:xml:ns:xmpp-session\"/>"
"<auth xmlns=\"http://jabber.org/features/iq-auth\"/>"
"<starttls xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>"
"<compression xmlns=\"http://jabber.org/features/compress\"><method>zlib</method></compression>"
"<mechanisms xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"><mechanism>PLAIN</mechanism></mechanisms>"
"</stream:features>");
QXmppStreamFeatures features2;
parsePacket(features2, xml2);
QCOMPARE(features2.bindMode(), QXmppStreamFeatures::Enabled);
QCOMPARE(features2.sessionMode(), QXmppStreamFeatures::Enabled);
QCOMPARE(features2.nonSaslAuthMode(), QXmppStreamFeatures::Enabled);
QCOMPARE(features2.tlsMode(), QXmppStreamFeatures::Enabled);
QCOMPARE(features2.authMechanisms(), QList<QXmppConfiguration::SASLAuthMechanism>() << QXmppConfiguration::SASLPlain);
QCOMPARE(features2.compressionMethods(), QList<QXmppConfiguration::CompressionMethod>() << QXmppConfiguration::ZlibCompression);
serializePacket(features2, xml2);
}
/// Blocks until either the stream encounters a pause mark or the sourceSocket errors.
/// This function is intended to be run after the 'q' command is sent, throwing away superfluous packets.
/// It will time out after 5 seconds, disconnecting the sourceSocket.
void DTSC::Stream::waitForPause(Socket::Connection & sourceSocket) {
bool wasBlocking = sourceSocket.isBlocking();
sourceSocket.setBlocking(false);
//cancel the attempt after 5000 milliseconds
long long int start = Util::getMS();
while (lastType() != DTSC::PAUSEMARK && sourceSocket.connected() && Util::getMS() - start < 5000) {
//we have data? parse it
if (sourceSocket.Received().size()) {
//return value is ignored because we're not interested.
parsePacket(sourceSocket.Received());
}
//still no pause mark? check for more data
if (lastType() != DTSC::PAUSEMARK) {
if (sourceSocket.spool()) {
//more received? attempt to read
//return value is ignored because we're not interested in data packets, just metadata.
parsePacket(sourceSocket.Received());
} else {
//nothing extra to receive? wait a bit and retry
Util::sleep(10);
}
}
}
sourceSocket.setBlocking(wasBlocking);
//if the timeout has passed, close the socket
if (Util::getMS() - start >= 5000) {
sourceSocket.close();
//and optionally print a debug message that this happened
DEBUG_MSG(DLVL_DEVEL, "Timing out while waiting for pause break");
}
}
void tst_QXmppMessage::testMessageReceipt()
{
const QByteArray xml(
"<message id=\"richard2-4.1.247\" to=\"[email protected]/throne\" from=\"[email protected]/westminster\" type=\"normal\">"
"<body>My lord, dispatch; read o'er these articles.</body>"
"<request xmlns=\"urn:xmpp:receipts\"/>"
"</message>");
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.id(), QString("richard2-4.1.247"));
QCOMPARE(message.to(), QString("[email protected]/throne"));
QCOMPARE(message.from(), QString("[email protected]/westminster"));
QVERIFY(message.extendedAddresses().isEmpty());
QCOMPARE(message.type(), QXmppMessage::Normal);
QCOMPARE(message.body(), QString("My lord, dispatch; read o'er these articles."));
QCOMPARE(message.isAttentionRequested(), false);
QCOMPARE(message.isReceiptRequested(), true);
QCOMPARE(message.receiptId(), QString());
serializePacket(message, xml);
const QByteArray receiptXml(
"<message id=\"bi29sg183b4v\" to=\"[email protected]/westminster\" from=\"[email protected]/throne\" type=\"normal\">"
"<received xmlns=\"urn:xmpp:receipts\" id=\"richard2-4.1.247\"/>"
"</message>");
QXmppMessage receipt;
parsePacket(receipt, receiptXml);
QCOMPARE(receipt.id(), QString("bi29sg183b4v"));
QCOMPARE(receipt.to(), QString("[email protected]/westminster"));
QCOMPARE(receipt.from(), QString("[email protected]/throne"));
QVERIFY(receipt.extendedAddresses().isEmpty());
QCOMPARE(receipt.type(), QXmppMessage::Normal);
QCOMPARE(receipt.body(), QString());
QCOMPARE(receipt.isAttentionRequested(), false);
QCOMPARE(receipt.isReceiptRequested(), false);
QCOMPARE(receipt.receiptId(), QString("richard2-4.1.247"));
serializePacket(receipt, receiptXml);
const QByteArray oldXml(
"<message id=\"richard2-4.1.247\" to=\"[email protected]/westminster\" from=\"[email protected]/throne\" type=\"normal\">"
"<received xmlns=\"urn:xmpp:receipts\"/>"
"</message>");
QXmppMessage old;
parsePacket(old, oldXml);
QCOMPARE(old.id(), QString("richard2-4.1.247"));
QCOMPARE(old.to(), QString("[email protected]/westminster"));
QCOMPARE(old.from(), QString("[email protected]/throne"));
QVERIFY(old.extendedAddresses().isEmpty());
QCOMPARE(old.type(), QXmppMessage::Normal);
QCOMPARE(old.body(), QString());
QCOMPARE(old.isAttentionRequested(), false);
QCOMPARE(old.isReceiptRequested(), false);
QCOMPARE(old.receiptId(), QString("richard2-4.1.247"));
}
void tst_QXmppSasl::testSuccess()
{
const QByteArray xml = "<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>";
QXmppSaslSuccess stanza;
parsePacket(stanza, xml);
serializePacket(stanza, xml);
}
void tst_QXmppSasl::testFailure()
{
// no condition
const QByteArray xml = "<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>";
QXmppSaslFailure failure;
parsePacket(failure, xml);
QCOMPARE(failure.condition(), QString());
serializePacket(failure, xml);
// not authorized
const QByteArray xml2 = "<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"><not-authorized/></failure>";
QXmppSaslFailure failure2;
parsePacket(failure2, xml2);
QCOMPARE(failure2.condition(), QLatin1String("not-authorized"));
serializePacket(failure2, xml2);
}
void tst_QXmppMessage::testBasic()
{
QFETCH(QByteArray, xml);
QFETCH(int, type);
QFETCH(QString, body);
QFETCH(QString, subject);
QFETCH(QString, thread);
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.to(), QString("[email protected]/QXmpp"));
QCOMPARE(message.from(), QString("[email protected]/QXmpp"));
QVERIFY(message.extendedAddresses().isEmpty());
QCOMPARE(int(message.type()), type);
QCOMPARE(message.body(), body);
QCOMPARE(message.subject(), subject);
QCOMPARE(message.thread(), thread);
QCOMPARE(message.state(), QXmppMessage::None);
QCOMPARE(message.isAttentionRequested(), false);
QCOMPARE(message.isReceiptRequested(), false);
QCOMPARE(message.hasForwarded(), false);
QCOMPARE(message.receiptId(), QString());
QCOMPARE(message.xhtml(), QString());
serializePacket(message, xml);
}
void tst_QXmppMessage::testReplaceWithEmptyMessage()
{
const QByteArray replaceXml(
"<message to='[email protected]/balcony' id='good1'>"
"<body/>"
"<replace id='bad1' xmlns='urn:xmpp:message-correct:0'/>"
"</message>");
QXmppMessage replaceMessage;
parsePacket(replaceMessage, replaceXml);
QCOMPARE(replaceMessage.isReplace(), true);
QCOMPARE(replaceMessage.replaceId(), QString("bad1"));
QCOMPARE(replaceMessage.body(), QString(""));
const QByteArray replaceSerialisation(
"<message id=\"good1\" to=\"[email protected]/balcony\" type=\"chat\">"
"<body/>"
"<replace id=\"bad1\" xmlns=\"urn:xmpp:message-correct:0\"/>"
"</message>");
QXmppMessage serialisationMessage;
serialisationMessage.setTo("[email protected]/balcony");
serialisationMessage.setId("good1");
serialisationMessage.setBody("");
serialisationMessage.setReplace("bad1");
serializePacket(serialisationMessage, replaceSerialisation);
}
void tst_QXmppMessage::testProcessingHints()
{
const QByteArray xml("<message "
"to=\"[email protected]/laptop\" "
"from=\"[email protected]/laptop\" "
"type=\"chat\">"
"<body>V unir avtug'f pybnx gb uvqr zr sebz gurve fvtug</body>"
"<no-copy xmlns=\"urn:xmpp:hints\"/>"
"<no-store xmlns=\"urn:xmpp:hints\"/>"
"<allow-permanent-storage xmlns=\"urn:xmpp:hints\"/>"
"</message>");
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.hasHint(QXmppMessage::NoCopies), true);
QCOMPARE(message.hasHint(QXmppMessage::NoStorage), true);
QCOMPARE(message.hasHint(QXmppMessage::AllowPermantStorage), true);
QXmppMessage message2;
message2.setType(QXmppMessage::Chat);
message2.setFrom(QString("[email protected]/laptop"));
message2.setTo(QString("[email protected]/laptop"));
message2.setBody(QString("V unir avtug'f pybnx gb uvqr zr sebz gurve fvtug"));
message2.addHint(QXmppMessage::NoCopies);
message2.addHint(QXmppMessage::NoStorage);
message2.addHint(QXmppMessage::AllowPermantStorage);
serializePacket(message2, xml);
}
void tst_QXmppMessage::testForwarding()
{
const QByteArray xml("<message type=\"normal\">"
"<body>hi!</body>"
"<forwarded xmlns=\"urn:xmpp:forward:0\">"
"<delay xmlns=\"urn:xmpp:delay\" stamp=\"2010-06-29T08:23:06Z\"/>"
"<message xmlns=\"jabber:client\" "
"type=\"chat\" "
"from=\"[email protected]/QXmpp\" "
"to=\"[email protected]/QXmpp\">"
"<body>ABC</body>"
"</message>"
"</forwarded>"
"</message>");
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.hasForwarded(), true);
QXmppMessage fwd = message.forwarded();
QCOMPARE(fwd.stamp(), QDateTime(QDate(2010, 06, 29), QTime(8, 23, 6), Qt::UTC));
QCOMPARE(fwd.body(), QString("ABC"));
QCOMPARE(fwd.to(), QString("[email protected]/QXmpp"));
QCOMPARE(fwd.from(), QString("[email protected]/QXmpp"));
}
void tst_QXmppJingleIq::testCandidate()
{
const QByteArray xml(
"<candidate component=\"1\""
" foundation=\"1\""
" generation=\"0\""
" id=\"el0747fg11\""
" ip=\"10.0.1.1\""
" network=\"1\""
" port=\"8998\""
" priority=\"2130706431\""
" protocol=\"udp\""
" type=\"host\"/>");
QXmppJingleCandidate candidate;
parsePacket(candidate, xml);
QCOMPARE(candidate.foundation(), QLatin1String("1"));
QCOMPARE(candidate.generation(), 0);
QCOMPARE(candidate.id(), QLatin1String("el0747fg11"));
QCOMPARE(candidate.host(), QHostAddress("10.0.1.1"));
QCOMPARE(candidate.network(), 1);
QCOMPARE(candidate.port(), quint16(8998));
QCOMPARE(candidate.priority(), 2130706431);
QCOMPARE(candidate.protocol(), QLatin1String("udp"));
QCOMPARE(candidate.type(), QXmppJingleCandidate::HostType);
serializePacket(candidate, xml);
};
void tst_QXmppRegisterIq::testResult()
{
const QByteArray xml(
"<iq id=\"reg1\" type=\"result\">"
"<query xmlns=\"jabber:iq:register\">"
"<instructions>Choose a username and password for use with this service. Please also provide your email address.</instructions>"
"<username/>"
"<password/>"
"<email/>"
"</query>"
"</iq>");
QXmppRegisterIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.id(), QLatin1String("reg1"));
QCOMPARE(iq.to(), QString());
QCOMPARE(iq.from(), QString());
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.instructions(), QLatin1String("Choose a username and password for use with this service. Please also provide your email address."));
QVERIFY(!iq.username().isNull());
QVERIFY(iq.username().isEmpty());
QVERIFY(!iq.password().isNull());
QVERIFY(iq.password().isEmpty());
QVERIFY(!iq.email().isNull());
QVERIFY(iq.email().isEmpty());
QVERIFY(iq.form().isNull());
serializePacket(iq, xml);
}
void sJarvisNode::parseBuffer(QString& buf)
{
//qDebug() << "BufferStart:" << buf;
//qDebug() << "-PacketSeparators:" << P_PACKETSTART << P_PACKETSEPARATOR << P_PACKETTERMINATOR;
if(buf.length() == 0) return;
int s_index = buf.indexOf(P_PACKETSTART);
int e_index = buf.indexOf(P_PACKETTERMINATOR);
//saneado del buffer
//qDebug() << "indexs:" << s_index << "indexe" << e_index;
if(s_index < 0)
{// si no hay inicio de paquete lo que hay en el buffer tiene que ser basura.
//qDebug() << "Limpiando Buffer";
buf.clear();
return;
}
//extraccion de comandos
while ((s_index >= 0) && (e_index >= 0)) //Si hay inicio y fin de paquete se extrae el comando.
{// lo que haya en el buffer hasta el inicio de paquete se descarta(basura)
QString packet = buf.mid(s_index+1,e_index-s_index-1);
parsePacket(packet);
buf = buf.mid(e_index+1);
s_index = buf.indexOf(P_PACKETSTART);
e_index = buf.indexOf(P_PACKETTERMINATOR);
}
//qDebug() << "Buffer:End" << m_rxBuffer;
}
void TestDiagnostics::testPacket()
{
const QByteArray xml(
"<iq type=\"result\">"
"<query xmlns=\"http://wifirst.net/protocol/diagnostics\">"
"<software type=\"os\" name=\"Windows\" version=\"XP\"/>"
"<interface name=\"en1\">"
"<address broadcast=\"\" ip=\"FE80:0:0:0:226:8FF:FEE1:A96B\" netmask=\"FFFF:FFFF:FFFF:FFFF:0:0:0:0\"/>"
"<address broadcast=\"192.168.99.255\" ip=\"192.168.99.179\" netmask=\"255.255.255.0\"/>"
"<wireless standards=\"ABGN\">"
"<network current=\"1\" cinr=\"-91\" rssi=\"-59\" ssid=\"Maki\"/>"
"<network cinr=\"-92\" rssi=\"-45\" ssid=\"freephonie\"/>"
"</wireless>"
"</interface>"
"<lookup hostName=\"www.google.fr\">"
"<address>2A00:1450:4007:800:0:0:0:68</address>"
"<address>66.249.92.104</address>"
"</lookup>"
"<ping hostAddress=\"192.168.99.1\" minimumTime=\"1.657\" maximumTime=\"44.275\" averageTime=\"20.258\" sentPackets=\"3\" receivedPackets=\"3\"/>"
"<traceroute hostAddress=\"213.91.4.201\">"
"<ping hostAddress=\"192.168.99.1\" minimumTime=\"1.719\" maximumTime=\"4.778\" averageTime=\"3.596\" sentPackets=\"3\" receivedPackets=\"3\"/>"
"</traceroute>"
"</query>"
"</iq>");
DiagnosticsIq iq;
parsePacket(iq, xml);
serializePacket(iq, xml);
}
void TestJingle::testSession()
{
const QByteArray xml(
"<iq"
" id=\"zid615d9\""
" to=\"[email protected]/balcony\""
" from=\"[email protected]/orchard\""
" type=\"set\">"
"<jingle xmlns=\"urn:xmpp:jingle:1\""
" action=\"session-initiate\""
" initiator=\"[email protected]/orchard\""
" sid=\"a73sjjvkla37jfea\">"
"<content creator=\"initiator\" name=\"this-is-a-stub\">"
"<description xmlns=\"urn:xmpp:jingle:apps:stub:0\"/>"
"<transport xmlns=\"urn:xmpp:jingle:transports:stub:0\"/>"
"</content>"
"</jingle>"
"</iq>");
QXmppJingleIq session;
parsePacket(session, xml);
QCOMPARE(session.action(), QXmppJingleIq::SessionInitiate);
QCOMPARE(session.initiator(), QLatin1String("[email protected]/orchard"));
QCOMPARE(session.sid(), QLatin1String("a73sjjvkla37jfea"));
QCOMPARE(session.content().creator(), QLatin1String("initiator"));
QCOMPARE(session.content().name(), QLatin1String("this-is-a-stub"));
QCOMPARE(session.reason().text(), QString());
QCOMPARE(session.reason().type(), QXmppJingleIq::Reason::None);
serializePacket(session, xml);
}
void TestPackets::testPresenceWithCapability()
{
const QByteArray xml(
"<presence to=\"[email protected]/QXmpp\" from=\"[email protected]/QXmpp\">"
"<show>away</show>"
"<status>In a meeting</status>"
"<priority>5</priority>"
"<x xmlns=\"vcard-temp:x:update\">"
"<photo>73b908bc</photo>"
"</x>"
"<c xmlns=\"http://jabber.org/protocol/caps\" hash=\"sha-1\" node=\"http://code.google.com/p/qxmpp\" ver=\"QgayPKawpkPSDYmwT/WM94uAlu0=\"/>"
"</presence>");
QXmppPresence presence;
parsePacket(presence, xml);
QCOMPARE(presence.to(), QString("[email protected]/QXmpp"));
QCOMPARE(presence.from(), QString("[email protected]/QXmpp"));
QCOMPARE(presence.status().type(), QXmppPresence::Status::Away);
QCOMPARE(presence.status().statusText(), QString("In a meeting"));
QCOMPARE(presence.status().priority(), 5);
QCOMPARE(presence.photoHash(), QByteArray::fromHex("73b908bc"));
QCOMPARE(presence.vCardUpdateType(), QXmppPresence::VCardUpdateValidPhoto);
QCOMPARE(presence.capabilityHash(), QString("sha-1"));
QCOMPARE(presence.capabilityNode(), QString("http://code.google.com/p/qxmpp"));
QCOMPARE(presence.capabilityVer(), QByteArray::fromBase64("QgayPKawpkPSDYmwT/WM94uAlu0="));
serializePacket(presence, xml);
}
void TestPubSub::testPublish()
{
const QByteArray xml(
"<iq"
" id=\"items1\""
" to=\"pubsub.shakespeare.lit\""
" from=\"[email protected]/barracks\""
" type=\"result\">"
"<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
"<publish node=\"storage:bookmarks\">"
"<item id=\"current\">"
"<storage xmlns=\"storage:bookmarks\">"
"<conference"
" autojoin=\"true\""
" jid=\"[email protected]\""
" name=\"The Play's the Thing\">"
"<nick>JC</nick>"
"</conference>"
"</storage>"
"</item>"
"</publish>"
"</pubsub>"
"</iq>");
QXmppPubSubIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.id(), QLatin1String("items1"));
QCOMPARE(iq.to(), QLatin1String("pubsub.shakespeare.lit"));
QCOMPARE(iq.from(), QLatin1String("[email protected]/barracks"));
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.queryType(), QXmppPubSubIq::PublishQuery);
QCOMPARE(iq.queryJid(), QString());
QCOMPARE(iq.queryNode(), QLatin1String("storage:bookmarks"));
serializePacket(iq, xml);
}
void TestPackets::testArchiveChat()
{
const QByteArray xml(
"<iq id=\"chat_1\" type=\"result\">"
"<chat xmlns=\"urn:xmpp:archive\""
" with=\"[email protected]\""
" start=\"1469-07-21T02:56:15Z\""
" subject=\"She speaks!\""
" version=\"4\""
">"
"<from secs=\"0\"><body>Art thou not Romeo, and a Montague?</body></from>"
"<to secs=\"11\"><body>Neither, fair saint, if either thee dislike.</body></to>"
"</chat>"
"</iq>");
QXmppArchiveChatIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.id(), QLatin1String("chat_1"));
QCOMPARE(iq.chat().with(), QLatin1String("*****@*****.**"));
QCOMPARE(iq.chat().messages().size(), 2);
QCOMPARE(iq.chat().messages()[0].isReceived(), true);
QCOMPARE(iq.chat().messages()[0].body(), QLatin1String("Art thou not Romeo, and a Montague?"));
QCOMPARE(iq.chat().messages()[0].date(), QDateTime(QDate(1469, 7, 21), QTime(2, 56, 15), Qt::UTC));
QCOMPARE(iq.chat().messages()[1].isReceived(), false);
QCOMPARE(iq.chat().messages()[1].date(), QDateTime(QDate(1469, 7, 21), QTime(2, 56, 26), Qt::UTC));
QCOMPARE(iq.chat().messages()[1].body(), QLatin1String("Neither, fair saint, if either thee dislike."));
serializePacket(iq, xml);
}
void TestPubSub::testSubscription()
{
const QByteArray xml(
"<iq"
" id=\"sub1\""
" to=\"[email protected]/barracks\""
" from=\"pubsub.shakespeare.lit\""
" type=\"result\">"
"<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
"<subscription jid=\"[email protected]\""
" node=\"princely_musings\""
" subid=\"ba49252aaa4f5d320c24d3766f0bdcade78c78d3\""
" subscription=\"subscribed\"/>"
"</pubsub>"
"</iq>");
QXmppPubSubIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.id(), QLatin1String("sub1"));
QCOMPARE(iq.to(), QLatin1String("[email protected]/barracks"));
QCOMPARE(iq.from(), QLatin1String("pubsub.shakespeare.lit"));
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.queryType(), QXmppPubSubIq::SubscriptionQuery);
QCOMPARE(iq.queryJid(), QLatin1String("*****@*****.**"));
QCOMPARE(iq.queryNode(), QLatin1String("princely_musings"));
QCOMPARE(iq.subscriptionId(), QLatin1String("ba49252aaa4f5d320c24d3766f0bdcade78c78d3"));
serializePacket(iq, xml);
}
void TestXmlRpc::testResponse()
{
const QByteArray xml(
"<iq"
" id=\"rpc1\""
" to=\"[email protected]/jrpc-client\""
" from=\"[email protected]/jrpc-server\""
" type=\"result\">"
"<query xmlns=\"jabber:iq:rpc\">"
"<methodResponse>"
"<params>"
"<param>"
"<value><string>Colorado</string></value>"
"</param>"
"</params>"
"</methodResponse>"
"</query>"
"</iq>");
QXmppRpcResponseIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.faultCode(), 0);
QCOMPARE(iq.faultString(), QString());
QCOMPARE(iq.values(), QVariantList() << QString("Colorado"));
serializePacket(iq, xml);
}
void TestXmlRpc::testResponseFault()
{
const QByteArray xml(
"<iq"
" id=\"rpc1\""
" to=\"[email protected]/jrpc-client\""
" from=\"[email protected]/jrpc-server\""
" type=\"result\">"
"<query xmlns=\"jabber:iq:rpc\">"
"<methodResponse>"
"<fault>"
"<value>"
"<struct>"
"<member>"
"<name>faultCode</name>"
"<value><i4>404</i4></value>"
"</member>"
"<member>"
"<name>faultString</name>"
"<value><string>Not found</string></value>"
"</member>"
"</struct>"
"</value>"
"</fault>"
"</methodResponse>"
"</query>"
"</iq>");
QXmppRpcResponseIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.faultCode(), 404);
QCOMPARE(iq.faultString(), QLatin1String("Not found"));
QCOMPARE(iq.values(), QVariantList());
serializePacket(iq, xml);
}
void TestXmlRpc::testInvoke()
{
const QByteArray xml(
"<iq"
" id=\"rpc1\""
" to=\"[email protected]/jrpc-server\""
" from=\"[email protected]/jrpc-client\""
" type=\"set\">"
"<query xmlns=\"jabber:iq:rpc\">"
"<methodCall>"
"<methodName>examples.getStateName</methodName>"
"<params>"
"<param>"
"<value><i4>6</i4></value>"
"</param>"
"</params>"
"</methodCall>"
"</query>"
"</iq>");
QXmppRpcInvokeIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.method(), QLatin1String("examples.getStateName"));
QCOMPARE(iq.arguments(), QVariantList() << int(6));
serializePacket(iq, xml);
}
void EvaAgentDownloader::processTransferInfo( EvaFTAgentTransferReply * packet )
{
printf("EvaAgentDownloader::processTransferInfo\n");
if(!parsePacket(packet)){
m_State = EError;
delete packet;
return;
}
m_StartSequence = packet->getSequence();
m_IsSendingStart = true;
m_File->setCheckValues( packet->getFileNameMd5(), packet->getFileMd5());
TQTextCodec *codec = TQTextCodec::codecForName("GB18030");
m_FileName = codec->toUnicode(packet->getFileName().c_str());
m_FileSize = packet->getFileSize();
printf("EvaAgentDownloader:: -------------------- got info - file: %s, size: %d\n",
packet->getFileName().c_str(), m_FileSize);
m_StartTime = TQDateTime::currentDateTime();
if(!(m_File->setFileInfo(m_FileName, m_FileSize))){
m_State = EError;
delete packet;
return;
};
if(m_File->loadInfoFile() && m_TransferType == TQQ_TRANSFER_FILE){
notifyNormalStatus(ESResume);
m_State = ENone;
delete packet;
return;
}
notifyTransferStatus();
m_State = EInfoReady;
delete packet;
}
void tst_QXmppVCardIq::testAddress()
{
QFETCH(QByteArray, xml);
QFETCH(int, type);
QFETCH(QString, country);
QFETCH(QString, locality);
QFETCH(QString, postcode);
QFETCH(QString, region);
QFETCH(QString, street);
QFETCH(bool, equalsEmpty);
QXmppVCardAddress address;
parsePacket(address, xml);
QCOMPARE(int(address.type()), type);
QCOMPARE(address.country(), country);
QCOMPARE(address.locality(), locality);
QCOMPARE(address.postcode(), postcode);
QCOMPARE(address.region(), region);
QCOMPARE(address.street(), street);
serializePacket(address, xml);
QXmppVCardAddress addressCopy = address;
QVERIFY2(addressCopy == address, "QXmppVCardAddres::operator==() fails");
QVERIFY2(!(addressCopy != address), "QXmppVCardAddres::operator!=() fails");
QXmppVCardAddress emptyAddress;
QCOMPARE(emptyAddress == address, equalsEmpty);
QCOMPARE(emptyAddress != address, !equalsEmpty);
}
void TestJingle::testTerminate()
{
const QByteArray xml(
"<iq"
" id=\"le71fa63\""
" to=\"[email protected]/orchard\""
" from=\"[email protected]/balcony\""
" type=\"set\">"
"<jingle xmlns=\"urn:xmpp:jingle:1\""
" action=\"session-terminate\""
" sid=\"a73sjjvkla37jfea\">"
"<reason>"
"<success/>"
"</reason>"
"</jingle>"
"</iq>");
QXmppJingleIq session;
parsePacket(session, xml);
QCOMPARE(session.action(), QXmppJingleIq::SessionTerminate);
QCOMPARE(session.initiator(), QString());
QCOMPARE(session.sid(), QLatin1String("a73sjjvkla37jfea"));
QCOMPARE(session.reason().text(), QString());
QCOMPARE(session.reason().type(), QXmppJingleIq::Reason::Success);
serializePacket(session, xml);
}
CCarProtocol::CCarProtocol(alt_u8 *pPacket, int iLength)
{
m_bValid = false;
m_bThereIsMore = false;
parsePacket(pPacket, iLength);
}
void TestPackets::testNonSaslAuth()
{
// Client Requests Authentication Fields from Server
const QByteArray xml1(
"<iq id=\"auth1\" to=\"shakespeare.lit\" type=\"get\">"
"<query xmlns=\"jabber:iq:auth\"/>"
"</iq>");
QXmppNonSASLAuthIq iq1;
parsePacket(iq1, xml1);
serializePacket(iq1, xml1);
// Client Provides Required Information (Plaintext)
const QByteArray xml3(
"<iq id=\"auth2\" type=\"set\">"
"<query xmlns=\"jabber:iq:auth\">"
"<username>bill</username>"
"<password>Calli0pe</password>"
"<resource>globe</resource>"
"</query>"
"</iq>");
QXmppNonSASLAuthIq iq3;
parsePacket(iq3, xml3);
QCOMPARE(iq3.username(), QLatin1String("bill"));
QCOMPARE(iq3.digest(), QByteArray());
QCOMPARE(iq3.password(), QLatin1String("Calli0pe"));
QCOMPARE(iq3.resource(), QLatin1String("globe"));
serializePacket(iq3, xml3);
// Client Provides Required Information (Plaintext)
const QByteArray xml4(
"<iq id=\"auth2\" type=\"set\">"
"<query xmlns=\"jabber:iq:auth\">"
"<username>bill</username>"
"<digest>48fc78be9ec8f86d8ce1c39c320c97c21d62334d</digest>"
"<resource>globe</resource>"
"</query>"
"</iq>");
QXmppNonSASLAuthIq iq4;
parsePacket(iq4, xml4);
QCOMPARE(iq4.username(), QLatin1String("bill"));
QCOMPARE(iq4.digest(), QByteArray("\x48\xfc\x78\xbe\x9e\xc8\xf8\x6d\x8c\xe1\xc3\x9c\x32\x0c\x97\xc2\x1d\x62\x33\x4d"));
QCOMPARE(iq4.password(), QString());
QCOMPARE(iq4.resource(), QLatin1String("globe"));
serializePacket(iq4, xml4);
}
void UDPThread::run() {
fd_set readfds;
ssize_t receivedBytes;
uint8_t buffer[RECEIVE_BUFFER_SIZE];
struct sockaddr_in clientAddr;
socklen_t clientAddrLen = sizeof(struct sockaddr_in);
/* Set interval to m_timeout */
m_transmitTimer.adjust(m_timeout, m_timeout);
m_blockTimer.adjust(SELECT_TIMEOUT, SELECT_TIMEOUT);
linfo << "UDPThread up and running" << std::endl;
while (m_started) {
/* Prepare readfds */
FD_ZERO(&readfds);
FD_SET(m_socket, &readfds);
FD_SET(m_transmitTimer.getFd(), &readfds);
FD_SET(m_blockTimer.getFd(), &readfds);
int ret = select(std::max({m_socket, m_transmitTimer.getFd(), m_blockTimer.getFd()})+1,
&readfds, NULL, NULL, NULL);
if (ret < 0) {
lerror << "select error" << std::endl;
break;
}
if (FD_ISSET(m_transmitTimer.getFd(), &readfds)) {
if (m_transmitTimer.read() > 0) {
if (m_frameBuffer->getFrameBufferSize())
prepareBuffer();
else {
m_transmitTimer.disable();
}
}
}
if (FD_ISSET(m_blockTimer.getFd(), &readfds)) {
m_blockTimer.read();
}
if (FD_ISSET(m_socket, &readfds)) {
/* Clear buffer */
memset(buffer, 0, RECEIVE_BUFFER_SIZE);
receivedBytes = recvfrom(m_socket, buffer, RECEIVE_BUFFER_SIZE,
0, (struct sockaddr *) &clientAddr, &clientAddrLen);
if (receivedBytes < 0) {
lerror << "recvfrom error." << std::endl;
continue;
} else if (receivedBytes > 0) {
parsePacket(buffer, receivedBytes, clientAddr);
}
}
}
if (m_debugOptions.buffer) {
m_frameBuffer->debug();
}
linfo << "Shutting down. UDP Transmission Summary: TX: " << m_txCount << " RX: " << m_rxCount << std::endl;
shutdown(m_socket, SHUT_RDWR);
close(m_socket);
}
void tst_QXmppMessage::testDelay()
{
QFETCH(QByteArray, xml);
QFETCH(QDateTime, stamp);
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.stamp(), stamp);
serializePacket(message, xml);
}
void tst_QXmppMessage::testState()
{
QFETCH(QByteArray, xml);
QFETCH(int, state);
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(int(message.state()), state);
serializePacket(message, xml);
}
void TestJingle::testPayloadType()
{
const QByteArray xml("<payload-type id=\"103\" name=\"L16\" channels=\"2\" clockrate=\"16000\"/>");
QXmppJinglePayloadType payload;
parsePacket(payload, xml);
QCOMPARE(payload.id(), static_cast<unsigned char>(103));
QCOMPARE(payload.name(), QLatin1String("L16"));
QCOMPARE(payload.channels(), static_cast<unsigned char>(2));
QCOMPARE(payload.clockrate(), 16000u);
serializePacket(payload, xml);
}
