/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Limber/Server/ServerFromClientSession.h"

#include <boost/bind.hpp>

#include "Swiften/Elements/ProtocolHeader.h"

#include "Limber/Server/UserRegistry.h"

#include "Swiften/Network/Connection.h"

#include "Swiften/StreamStack/XMPPLayer.h"

#include "Swiften/Elements/StreamFeatures.h"

#include "Swiften/Elements/ResourceBind.h"

#include "Swiften/Elements/StartSession.h"

void ServerFromClientSession::handleElement(boost::shared_ptr<Element> element) {

if (isInitialized()) {

onElementReceived(element);

}

else {

if (AuthRequest* authRequest = dynamic_cast<AuthRequest*>(element.get())) {

if (authRequest->getMechanism() == "PLAIN" || (allowSASLEXTERNAL && authRequest->getMechanism() == "EXTERNAL")) {

if (authRequest->getMechanism() == "EXTERNAL") {

authenticated_ = true;

getXMPPLayer()->resetParser();

}

else {

PLAINMessage plainMessage(authRequest->getMessage() ? *authRequest->getMessage() : createSafeByteArray(""));

if (userRegistry_->isValidUserPassword(JID(plainMessage.getAuthenticationID(), getLocalJID().getDomain()), plainMessage.getPassword())) {

user_ = plainMessage.getAuthenticationID();

authenticated_ = true;

getXMPPLayer()->resetParser();

}

else {

getXMPPLayer()->writeElement(boost::shared_ptr<AuthFailure>(new AuthFailure));

finishSession(AuthenticationFailedError);

}

}

return;

}

stanza->setFrom(session->getRemoteJID());

if (!stanza->getTo().isValid()) {

stanza->setTo(JID(session->getLocalJID()));

}

if (!stanza->getTo().isValid() || stanza->getTo() == session->getLocalJID() || stanza->getTo() == session->getRemoteJID().toBare()) {

if (boost::shared_ptr<IQ> iq = boost::dynamic_pointer_cast<IQ>(stanza)) {

if (iq->getPayload<RosterPayload>()) {

}

if (iq->getPayload<VCard>()) {

if (iq->getType() == IQ::Get) {

boost::shared_ptr<VCard> vcard(new VCard());

vcard->setNickname(iq->getFrom().getNode());

session->sendElement(IQ::createResult(iq->getFrom(), iq->getID(), vcard));

}

else {

session->sendElement(IQ::createError(iq->getFrom(), iq->getID(), ErrorPayload::Forbidden, ErrorPayload::Cancel));

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Slimber/FileVCardCollection.h"

#include <boost/filesystem/fstream.hpp>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/Serializer/PayloadSerializers/VCardSerializer.h>

#include <Swiften/Parser/PayloadParsers/UnitTest/PayloadParserTester.h>

#include <Swiften/Parser/PayloadParsers/VCardParser.h>

namespace Swift {

ByteArray data;

readByteArrayFromFile(data, boost::filesystem::path(vcardsPath / std::string("vcard.xml")).string());

VCardParser parser;

PayloadParserTester tester(&parser);

tester.parse(byteArrayToString(data));

return boost::dynamic_pointer_cast<VCard>(parser.getPayload());

}

else {

}

}

void FileVCardCollection::setOwnVCard(boost::shared_ptr<VCard> v) {

boost::filesystem::ofstream file(vcardsPath / std::string("vcard.xml"));

file << VCardSerializer().serializePayload(v);

file.close();

}

connectors.erase(std::remove(connectors.begin(), connectors.end(), connector), connectors.end());

}

void Server::registerLinkLocalSession(boost::shared_ptr<Session> session) {

session->onSessionFinished.connect(

boost::bind(&Server::handleLinkLocalSessionFinished, this, session));

session->onElementReceived.connect(

boost::bind(&Server::handleLinkLocalElementReceived, this, _1, session));

linkLocalSessions.push_back(session);

session->startSession();

}

boost::shared_ptr<Session> Server::getLinkLocalSessionForJID(const JID& jid) {

foreach(const boost::shared_ptr<Session> session, linkLocalSessions) {

if (session->getRemoteJID() == jid) {

return session;

}

}

CPPUNIT_TEST(testGetRoster_InfoWithFirstAndLastName);

CPPUNIT_TEST(testGetRoster_NoInfo);

CPPUNIT_TEST(testGetServiceForJID);

CPPUNIT_TEST(testGetServiceForJID_NoMatch);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

eventLoop = new DummyEventLoop();

browser = new LinkLocalServiceBrowser(querier);

browser->start();

}

void tearDown() {

browser->stop();

delete browser;

delete eventLoop;

}

/*

* Copyright (c) 2010-2012 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Swift/Controllers/Chat/ChatController.h"

#include <boost/bind.hpp>

#include <stdio.h>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Avatars/AvatarManager.h>

#include <Swiften/Chat/ChatStateNotifier.h>

#include <Swiften/Chat/ChatStateTracker.h>

#include <Swiften/Client/StanzaChannel.h>

me = true;

}

} else if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {

me = true;

}

if (!me) {

return;

}

if (!newPresence) {

newPresence->setType(Presence::Unavailable);

}

lastShownStatus_ = newPresence->getShow();

chatStateTracker_->handlePresenceChange(newPresence);

chatStateNotifier_->setContactIsOnline(newPresence->getType() == Presence::Available);

std::string newStatusChangeString = getStatusChangeString(newPresence);

if (newStatusChangeString != lastStatusChangeString_) {

if (lastWasPresence_) {

*/

#include "Swift/Controllers/Chat/ChatControllerBase.h"

#include <sstream>

#include <map>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/algorithm/string.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swiften/Base/format.h>

#include <Swiften/Base/String.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

if (labelsEnabled_) {

SecurityLabelsCatalog::Item labelItem = chatWindow_->getSelectedSecurityLabel();

if (labelItem.getLabel()) {

message->addPayload(labelItem.getLabel());

}

}

preSendMessageRequest(message);

if (useDelayForLatency_) {

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

}

if (isCorrectionMessage) {

message->addPayload(boost::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

}

message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

stanzaChannel_->sendMessage(message);

postSendMessage(message->getBody(), boost::dynamic_pointer_cast<Stanza>(message));

onActivity(message->getBody());

}

* Copyright (c) 2010-2011 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Swift/Controllers/Chat/ChatsManager.h"

#include <boost/bind.hpp>

#include <boost/algorithm/string.hpp>

#include <Swiften/Base/foreach.h>

#include <Swift/Controllers/Chat/ChatController.h>

#include <Swift/Controllers/Chat/ChatControllerBase.h>

#include <Swift/Controllers/Chat/MUCSearchController.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

#include <Swift/Controllers/Chat/MUCController.h>

#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

settings_(settings) {

timerFactory_ = timerFactory;

eventController_ = eventController;

stanzaChannel_ = stanzaChannel;

iqRouter_ = iqRouter;

chatWindowFactory_ = chatWindowFactory;

nickResolver_ = nickResolver;

presenceOracle_ = presenceOracle;

avatarManager_ = NULL;

presenceSender_ = presenceSender;

uiEventStream_ = uiEventStream;

mucBookmarkManager_ = NULL;

profileSettings_ = profileSettings;

presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));

uiEventConnection_ = uiEventStream_->onUIEvent.connect(boost::bind(&ChatsManager::handleUIEvent, this, _1));

chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);

chatListWindow_->onMUCBookmarkActivated.connect(boost::bind(&ChatsManager::handleMUCBookmarkActivated, this, _1));

iqRouter_ = new IQRouter(iqChannel_);

capsProvider_ = new DummyCapsProvider();

eventController_ = new EventController();

chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, NULL, mucRegistry_);

presenceOracle_ = new PresenceOracle(stanzaChannel_);

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

uiEventStream_ = new UIEventStream();

entityCapsManager_ = new EntityCapsManager(capsProvider_, stanzaChannel_);

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

profileSettings_ = new ProfileSettingsProvider("a", settings_);

}

/**

* Test that MUC PMs get opened in the right windows

*/

void testThreeMUCWindows() {

JID muc("testling@test.com");

ChatWindow* mucWindow = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc, uiEventStream_).Return(mucWindow);

std::string messageJIDString1("testling@test.com/1");

ChatWindow* window1 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID(messageJIDString1), uiEventStream_).Return(window1);

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(JID(messageJIDString1))));

std::string messageJIDString2("testling@test.com/2");

ChatWindow* window2 = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swift/Controllers/Chat/UserSearchController.h>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swift/Controllers/ContactEditController.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIEvents/RequestChatWithUserDialogUIEvent.h>

&& identity.getType() == "user")) {

//isUserDirectory = true;

}

}

std::vector<std::string> features = info->getFeatures();

supports55 = std::find(features.begin(), features.end(), DiscoInfo::JabberSearchFeature) != features.end();

if (/*isUserDirectory && */supports55) { //FIXME: once M-Link correctly advertises directoryness.

/* Abort further searches.*/

endDiscoWalker();

searchRequest->onResponse.connect(boost::bind(&UserSearchController::handleFormResponse, this, _1, _2));

searchRequest->send();

}

}

void UserSearchController::handleFormResponse(boost::shared_ptr<SearchPayload> fields, ErrorPayload::ref error) {

if (error || !fields) {

window_->setServerSupportsSearch(false);

return;

void MainController::sendPresence(boost::shared_ptr<Presence> presence) {

rosterController_->getWindow()->setMyStatusType(presence->getShow());

rosterController_->getWindow()->setMyStatusText(presence->getStatus());

systemTrayController_->setMyStatusType(presence->getShow());

notifier_->setTemporarilyDisabled(presence->getShow() == StatusShow::DND);

// Add information and send

if (!vCardPhotoHash_.empty()) {

}

client_->getPresenceSender()->sendPresence(presence);

if (presence->getType() == Presence::Unavailable) {

logout();

}

}

void MainController::handleInputIdleChanged(bool idle) {

if (!statusTracker_) {

if (!offlineRequested_) {

setReconnectTimer();

}

if (lastDisconnectError_) {

message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % boost::lexical_cast<std::string>(timeBeforeNextReconnect_));

lastDisconnectError_->conclude();

} else {

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%.")) % jid_.getDomain() % message);

}

eventController_->handleIncomingEvent(lastDisconnectError_);

}

}

}

else if (!rosterController_) { //hasn't been logged in yet

loginWindow_->setIsLoggingIn(false);

}

}

sendPresence(statusTracker_->getNextPresence());

}

}

}

void MainController::handleNotificationClicked(const JID& jid) {

assert(chatsManager_);

if (clientInitialized_) {

if (client_->getMUCRegistry()->isMUC(jid)) {

}

else {

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestChatUIEvent(jid)));

}

}

}

void MainController::handleQuitRequest() {

if (client_ && client_->isActive()) {

boost::shared_ptr<Presence> presence(new Presence());

presence->setShow(StatusShow::DND);

presence->setFrom(jid4a);

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

presence->setFrom(jid4b);

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

presence->setFrom(jid4c);

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

presence->setFrom(jid4b);

presence->setShow(StatusShow::Online);

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

std::vector<RosterItem*> children = static_cast<GroupRosterItem*>(roster_->getRoot()->getDisplayedChildren()[0])->getDisplayedChildren();

CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(children.size()));

/* Check order */

CPPUNIT_ASSERT_EQUAL(std::string("Ernie"), children[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Bert"), children[1]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Bird"), children[2]->getDisplayName());

presence->setFrom(jid4c);

presence->setType(Presence::Unavailable);

roster_->removeContact(jid4c);

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

}

void testReSortLikeMUC() {

JID jid4a("a@b/c");

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "Swift/Controllers/StatusTracker.h"

namespace Swift {

StatusTracker::StatusTracker() {

isAutoAway_ = false;

}

boost::shared_ptr<Presence> StatusTracker::getNextPresence() {

boost::shared_ptr<Presence> presence;

if (isAutoAway_) {

presence->setShow(StatusShow::Away);

presence->setStatus(queuedPresence_->getStatus());

} else {

presence = queuedPresence_;

}

return presence;

}

void StatusTracker::setRequestedPresence(boost::shared_ptr<Presence> presence) {

isAutoAway_ = false;

queuedPresence_ = presence;

// if (presence->getType() == Presence::Unavailable) {

// }

}

bool StatusTracker::goAutoAway() {

if (queuedPresence_->getShow() != StatusShow::Online) {

return false;

}

isAutoAway_ = true;

return true;

Swift::QtEventWindow* viewer = new Swift::QtEventWindow(&eventStream);

viewer->show();

boost::shared_ptr<Swift::Message> message1(new Swift::Message());

message1->setBody("Oooh, shiny");

boost::shared_ptr<Swift::MessageEvent> event1(new Swift::MessageEvent(message1));

viewer->addEvent(boost::dynamic_pointer_cast<Swift::StanzaEvent>(event1), true);

for (int i = 0; i < 100; i++) {

viewer->addEvent(boost::dynamic_pointer_cast<Swift::StanzaEvent>(event1), false);

}

return app.exec();

}

}

else {

aboutDialog_->show();

aboutDialog_->raise();

aboutDialog_->activateWindow();

}

}

void QtLoginWindow::handleShowXMLConsole() {

}

void QtLoginWindow::handleShowFileTransferOverview() {

uiEventStream_->send(boost::make_shared<RequestFileTransferListUIEvent>());

}

void QtLoginWindow::handleToggleSounds(bool enabled) {

settings_->storeSetting(SettingConstants::PLAY_SOUNDS, enabled);

}

boost::shared_ptr<VCardUpdateAvatarManager> createManager() {

boost::shared_ptr<VCardUpdateAvatarManager> result(new VCardUpdateAvatarManager(vcardManager, stanzaChannel, avatarStorage, mucRegistry));

result->onAvatarChanged.connect(boost::bind(&VCardUpdateAvatarManagerTest::handleAvatarChanged, this, _1));

return result;

}

boost::shared_ptr<Presence> createPresenceWithPhotoHash(const JID& jid, const std::string& hash) {

boost::shared_ptr<Presence> presence(new Presence());

presence->setFrom(jid);

return presence;

}

IQ::ref createVCardResult(const ByteArray& avatar) {

VCard::ref vcard(new VCard());

if (!avatar.empty()) {

vcard->setPhoto(avatar);

}

return IQ::createResult(JID("baz@fum.com"), stanzaChannel->sentStanzas[0]->getTo(), stanzaChannel->sentStanzas[0]->getID(), vcard);

CPPUNIT_TEST(testSessionStart_AfterResourceBind);

CPPUNIT_TEST(testWhitespacePing);

CPPUNIT_TEST(testReceiveElementAfterSessionStarted);

CPPUNIT_TEST(testSendElement);

*/

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

sessionFinishedReceived = false;

needCredentials = false;

blindCertificateTrustChecker = new BlindCertificateTrustChecker();

}

void tearDown() {

delete blindCertificateTrustChecker;

}

virtual void setWhitespacePingEnabled(bool enabled) {

whitespacePingEnabled = enabled;

}

virtual void resetXMPPParser() {

resetCount++;

}

void breakConnection() {

}

void breakTLS() {

}

void sendStreamStart() {

ProtocolHeader header;

header.setTo("foo.com");

return onStreamStartReceived(header);

}

streamFeatures->setHasStartTLS();

onElementReceived(streamFeatures);

}

void sendStreamError() {

onElementReceived(boost::make_shared<StreamError>());

}

void sendTLSProceed() {

}

void sendTLSFailure() {

}

void sendStreamFeaturesWithMultipleAuthentication() {

boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

streamFeatures->addAuthenticationMechanism("PLAIN");

streamFeatures->addAuthenticationMechanism("DIGEST-MD5");

streamFeatures->addAuthenticationMechanism("SCRAM-SHA1");

onElementReceived(streamFeatures);

}

streamFeatures->setHasStreamManagement();

onElementReceived(streamFeatures);

}

void sendEmptyStreamFeatures() {

onElementReceived(boost::make_shared<StreamFeatures>());

}

void sendAuthSuccess() {

}

void sendAuthFailure() {

}

void sendStreamManagementEnabled() {

}

void sendStreamManagementFailed() {

}

void sendBindResult() {

boost::shared_ptr<ResourceBind> resourceBind(new ResourceBind());

resourceBind->setJID(JID("foo@bar.com/bla"));

boost::shared_ptr<IQ> iq = IQ::createResult(JID("foo@bar.com"), bindID, resourceBind);

onElementReceived(iq);

}

void testReceiveElementAfterSessionStarted() {

boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

getMockServer()->expectStreamStart();

getMockServer()->sendStreamStart();

getMockServer()->sendStreamFeatures();

session->startSession();

processEvents();

getMockServer()->expectMessage();

}

void testSendElement() {

boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

session->onElementReceived.connect(boost::bind(&ClientSessionTest::addReceivedElement, this, _1));

getMockServer()->expectStreamStart();

getMockServer()->sendStreamStart();

getMockServer()->sendStreamFeatures();

getMockServer()->sendMessage();

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Component/ComponentSession.h>

#include <boost/bind.hpp>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Elements/ComponentHandshake.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/Component/ComponentHandshakeGenerator.h>

namespace Swift {

ComponentSession::ComponentSession(const JID& jid, const std::string& secret, boost::shared_ptr<SessionStream> stream) : jid(jid), secret(secret), stream(stream), state(Initial) {

onFinished(streamError);

}

}

void ComponentSession::finish() {

finishSession(boost::shared_ptr<Error>());

}

void ComponentSession::finishSession(Error::Type error) {

}

void ComponentSession::finishSession(boost::shared_ptr<Swift::Error> finishError) {

state = Finishing;

error = finishError;

assert(stream->isOpen());

stream->writeFooter();

stream->close();

}

class ComponentSessionTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ComponentSessionTest);

CPPUNIT_TEST(testStart);

CPPUNIT_TEST(testStart_Error);

CPPUNIT_TEST(testStart_Unauthorized);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

sessionFinishedReceived = false;

}

void testStart() {

boost::shared_ptr<ComponentSession> session(createSession());

session->start();

server->receiveStreamStart();

server->sendStreamStart();

server->receiveHandshake();

virtual void setWhitespacePingEnabled(bool enabled) {

whitespacePingEnabled = enabled;

}

virtual void resetXMPPParser() {

resetCount++;

}

void breakConnection() {

}

void sendStreamStart() {

ProtocolHeader header;

header.setFrom("service.foo.com");

return onStreamStartReceived(header);

}

void sendHandshakeResponse() {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Disco/DiscoInfoResponder.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Elements/DiscoInfo.h>

namespace Swift {

DiscoInfoResponder::DiscoInfoResponder(IQRouter* router) : GetResponder<DiscoInfo>(router) {

}

void DiscoInfoResponder::setDiscoInfo(const std::string& node, const DiscoInfo& info) {

DiscoInfo newInfo(info);

newInfo.setNode(node);

nodeInfo_[node] = newInfo;

}

bool DiscoInfoResponder::handleGetRequest(const JID& from, const JID&, const std::string& id, boost::shared_ptr<DiscoInfo> info) {

if (info->getNode().empty()) {

}

else {

std::map<std::string,DiscoInfo>::const_iterator i = nodeInfo_.find(info->getNode());

if (i != nodeInfo_.end()) {

}

else {

sendError(from, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);

}

}

return true;

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Elements/DiscoInfo.h>

namespace Swift {

class GetDiscoInfoRequest : public GenericRequest<DiscoInfo> {

public:

typedef boost::shared_ptr<GetDiscoInfoRequest> ref;

static ref create(const JID& jid, IQRouter* router) {

return ref(new GetDiscoInfoRequest(jid, router));

}

static ref create(const JID& jid, const std::string& node, IQRouter* router) {

return ref(new GetDiscoInfoRequest(jid, node, router));

}

private:

GetDiscoInfoRequest(const JID& jid, IQRouter* router) :

}

GetDiscoInfoRequest(const JID& jid, const std::string& node, IQRouter* router) :

getPayloadGeneric()->setNode(node);

}

};

}

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Elements/DiscoItems.h>

namespace Swift {

class GetDiscoItemsRequest : public GenericRequest<DiscoItems> {

public:

typedef boost::shared_ptr<GetDiscoItemsRequest> ref;

static ref create(const JID& jid, IQRouter* router) {

return ref(new GetDiscoItemsRequest(jid, router));

}

static ref create(const JID& jid, const std::string& node, IQRouter* router) {

return ref(new GetDiscoItemsRequest(jid, node, router));

}

private:

GetDiscoItemsRequest(const JID& jid, IQRouter* router) :

}

GetDiscoItemsRequest(const JID& jid, const std::string& node, IQRouter* router) :

getPayloadGeneric()->setNode(node);

}

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Disco/JIDDiscoInfoResponder.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Elements/DiscoInfo.h>

namespace Swift {

JIDDiscoInfoResponder::JIDDiscoInfoResponder(IQRouter* router) : GetResponder<DiscoInfo>(router) {

}

DiscoInfo newInfo(discoInfo);

newInfo.setNode(node);

i->second.nodeDiscoInfo[node] = newInfo;

}

bool JIDDiscoInfoResponder::handleGetRequest(const JID& from, const JID& to, const std::string& id, boost::shared_ptr<DiscoInfo> discoInfo) {

JIDDiscoInfoMap::const_iterator i = info.find(to);

if (i != info.end()) {

if (discoInfo->getNode().empty()) {

}

else {

std::map<std::string,DiscoInfo>::const_iterator j = i->second.nodeDiscoInfo.find(discoInfo->getNode());

if (j != i->second.nodeDiscoInfo.end()) {

}

else {

sendError(from, to, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);

}

}

}

else {

sendError(from, to, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);

}

CPPUNIT_TEST(testReconnectResetsRequests);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

stanzaChannel = new DummyStanzaChannel();

iqRouter = new IQRouter(stanzaChannel);

storage = new CapsMemoryStorage();

user1 = JID("user1@bar.com/bla");

discoInfo1->addFeature("http://swift.im/feature1");

user2 = JID("user2@foo.com/baz");

discoInfo2->addFeature("http://swift.im/feature2");

user3 = JID("user3@foo.com/baz");

}

void tearDown() {

delete storage;

delete iqRouter;

delete stanzaChannel;

}

void testReceiveNewHashRequestsDisco() {

CPPUNIT_TEST(testHashAvailable);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

stanzaChannel = new DummyStanzaChannel();

capsProvider = new DummyCapsProvider();

user1 = JID("user1@bar.com/bla");

discoInfo1->addFeature("http://swift.im/feature1");

user2 = JID("user2@foo.com/baz");

discoInfo2->addFeature("http://swift.im/feature2");

user3 = JID("user3@foo.com/baz");

}

void tearDown() {

delete capsProvider;

delete stanzaChannel;

}

void testReceiveKnownHash() {

boost::shared_ptr<EntityCapsManager> testling = createManager();

(*alive_) = false;

}

private:

bool* alive_;

};

void testConstructor_Copy() {

Message m;

Message copy(m);

CPPUNIT_ASSERT(copy.getPayload<MyPayload1>());

CPPUNIT_ASSERT(copy.getPayload<MyPayload2>());

}

void testDestructor() {

bool payloadAlive = true;

{

Message m;

}

CPPUNIT_ASSERT(!payloadAlive);

}

void testDestructor_Copy() {

bool payloadAlive = true;

Message* m1 = new Message();

Message* m2 = new Message(*m1);

delete m1;

CPPUNIT_ASSERT(payloadAlive);

delete m2;

CPPUNIT_ASSERT(!payloadAlive);

}

void testGetPayload() {

Message m;

boost::shared_ptr<MyPayload2> p(m.getPayload<MyPayload2>());

CPPUNIT_ASSERT(p);

}

void testGetPayload_NoSuchPayload() {

Message m;

boost::shared_ptr<MyPayload2> p(m.getPayload<MyPayload2>());

CPPUNIT_ASSERT(!p);

}

void testGetPayloads() {

Message m;

boost::shared_ptr<MyPayload2> payload1(new MyPayload2());

boost::shared_ptr<MyPayload2> payload2(new MyPayload2());

m.addPayload(payload1);

m.addPayload(payload2);

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(2), m.getPayloads<MyPayload2>().size());

CPPUNIT_ASSERT_EQUAL(payload1, m.getPayloads<MyPayload2>()[0]);

CPPUNIT_ASSERT_EQUAL(payload2, m.getPayloads<MyPayload2>()[1]);

}

void testUpdatePayload_ExistingPayload() {

Message m;

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), m.getPayloads().size());

boost::shared_ptr<MyPayload2> p(m.getPayload<MyPayload2>());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), p->text_);

}

void testUpdatePayload_NewPayload() {

Message m;

CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(3), m.getPayloads().size());

boost::shared_ptr<MyPayload2> p(m.getPayload<MyPayload2>());

CPPUNIT_ASSERT_EQUAL(std::string("bar"), p->text_);

}

void testGetPayloadOfSameType() {

Message m;

CPPUNIT_ASSERT(payload);

CPPUNIT_ASSERT_EQUAL(std::string("foo"), payload->text_);

}

void testGetPayloadOfSameType_NoSuchPayload() {

Message m;

}

void testGetTimestamp() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestamp();

CPPUNIT_ASSERT(timestamp);

CPPUNIT_ASSERT_EQUAL(std::string("1970-Jan-01 00:00:01"), boost::posix_time::to_simple_string(*timestamp));

}

void testGetTimestamp_TimestampWithFrom() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestamp();

CPPUNIT_ASSERT(timestamp);

CPPUNIT_ASSERT_EQUAL(std::string("1970-Jan-01 00:00:01"), boost::posix_time::to_simple_string(*timestamp));

}

void testGetTimestamp_NoDelay() {

Message m;

CPPUNIT_ASSERT(!m.getTimestamp());

}

void testGetTimestampFrom() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestampFrom(JID("foo2@bar.com"));

CPPUNIT_ASSERT(timestamp);

CPPUNIT_ASSERT_EQUAL(std::string("1970-Jan-01 00:00:02"), boost::posix_time::to_simple_string(*timestamp));

}

void testGetTimestampFrom_Fallsback() {

Message m;

boost::optional<boost::posix_time::ptime> timestamp = m.getTimestampFrom(JID("foo2@bar.com"));

CPPUNIT_ASSERT(timestamp);

CPPUNIT_ASSERT_EQUAL(std::string("1970-Jan-01 00:00:01"), boost::posix_time::to_simple_string(*timestamp));

}

};

CPPUNIT_TEST_SUITE_REGISTRATION(StanzaTest);

// gather file information

/*StreamInitiationFileInfo fileInfo;

fileInfo.setName(file.filename());

fileInfo.setSize(boost::filesystem::file_size(file));

fileInfo.setDescription("Some file!");

fileInfo.setDate(boost::posix_time::from_time_t(boost::filesystem::last_write_time(file)));*/

//fileInfo.setHash(Hexify::hexify(MD5::getHash(fileData)));

/*

transfer->onFinished.connect(boost::bind(&FileSender::handleFileTransferFinished, this, _1));

transfer->start();

*/

}

void handleCapsChanged(JID jid) {

if (jid.toBare() == recipient) {

// create ReadBytestream from file

boost::shared_ptr<FileReadBytestream> fileStream = boost::make_shared<FileReadBytestream>(file);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/FileTransfer/OutgoingSIFileTransfer.h>

#include <boost/bind.hpp>

#include <Swiften/FileTransfer/StreamInitiationRequest.h>

#include <Swiften/FileTransfer/BytestreamsRequest.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServer.h>

#include <Swiften/FileTransfer/IBBSendSession.h>

namespace Swift {

OutgoingSIFileTransfer::OutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::string& description, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer) : id(id), from(from), to(to), name(name), size(size), description(description), bytestream(bytestream), iqRouter(iqRouter), socksServer(socksServer) {

Bytestreams::ref bytestreams(new Bytestreams());

bytestreams->setStreamID(id);

HostAddressPort addressPort = socksServer->getAddressPort();

bytestreams->addStreamHost(Bytestreams::StreamHost(addressPort.getAddress().toString(), from, addressPort.getPort()));

BytestreamsRequest::ref request = BytestreamsRequest::create(to, bytestreams, iqRouter);

request->onResponse.connect(boost::bind(&OutgoingSIFileTransfer::handleBytestreamsRequestResponse, this, _1, _2));

request->send();

}

else if (response->getRequestedMethod() == "http://jabber.org/protocol/ibb") {

ibbSession->onFinished.connect(boost::bind(&OutgoingSIFileTransfer::handleIBBSessionFinished, this, _1));

ibbSession->start();

}

}

}

void OutgoingSIFileTransfer::handleBytestreamsRequestResponse(Bytestreams::ref, ErrorPayload::ref error) {

if (error) {

finish(FileTransferError());

CPPUNIT_TEST(testDataStreamResumeBeforePauseDoesNotSendData);

CPPUNIT_TEST(testDataStreamResumeAfterResumeDoesNotSendData);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

stanzaChannel = new DummyStanzaChannel();

iqRouter = new IQRouter(stanzaChannel);

finished = false;

}

void tearDown() {

delete iqRouter;

delete stanzaChannel;

}

void testStart() {

SOCKS5BytestreamClientSessionTest() : destinationAddressPort(HostAddressPort(HostAddress("127.0.0.1"), 8888)),

destination(SOCKS5BytestreamRegistry::getHostname("foo", JID("requester@example.com/test"), JID("target@example.com/test"))), eventLoop(NULL), timerFactory(NULL) { }

void setUp() {

randomGen.seed(time(NULL));

eventLoop = new DummyEventLoop();

timerFactory = new DummyTimerFactory();

connection = boost::make_shared<MockeryConnection>(failingPorts, true, eventLoop);

//connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));

// connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSessionTest::handleDataRead, this, _1));

}

void tearDown() {

//connection.reset();

delete timerFactory;

delete eventLoop;

}

CPPUNIT_TEST(testReceiveData);

CPPUNIT_TEST(testReceiveData_Chunked);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

receivedDataChunks = 0;

eventLoop = new DummyEventLoop();

bytestreams = new SOCKS5BytestreamRegistry();

connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));

}

void tearDown() {

connection.reset();

delete bytestreams;

delete eventLoop;

}

void testAuthenticate() {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/LinkLocal/IncomingLinkLocalSession.h>

#include <boost/bind.hpp>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/StreamStack/StreamStack.h>

#include <Swiften/StreamStack/ConnectionLayer.h>

#include <Swiften/StreamStack/XMPPLayer.h>

#include <Swiften/Elements/StreamFeatures.h>

#include <Swiften/Elements/IQ.h>

finishSession();

return;

}

ProtocolHeader header;

header.setFrom(getLocalJID());

getXMPPLayer()->writeHeader(header);

if (incomingHeader.getVersion() == "1.0") {

}

else {

setInitialized();

}

}

void IncomingLinkLocalSession::handleElement(boost::shared_ptr<Element> element) {

boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);

// If we get our first stanza before streamfeatures, our session is implicitly

CPPUNIT_TEST(testConnect_UnableToResolve);

CPPUNIT_TEST(testConnect_UnableToConnect);

CPPUNIT_TEST(testCancel_DuringResolve);

CPPUNIT_TEST(testCancel_DuringConnect);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

eventLoop = new DummyEventLoop();

connectFinished = false;

}

void tearDown() {

querier->clearAllQueriesEverRun();

delete eventLoop;

}

void testConnect() {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/bind.hpp>

#include <map>

#include <Swiften/LinkLocal/LinkLocalServiceBrowser.h>

#include <Swiften/LinkLocal/LinkLocalService.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDServiceID.h>

#include <Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h>

#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h>

#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

CPPUNIT_TEST(testRegisterService);

CPPUNIT_TEST(testRegisterService_Error);

CPPUNIT_TEST(testRegisterService_Reregister);

CPPUNIT_TEST(testUpdateService);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

eventLoop = new DummyEventLoop();

aliceServiceID = new DNSSDServiceID("alice", "wonderland.lit");

aliceServiceInfo = new DNSSDResolveServiceQuery::Result("_presence._tcp.wonderland.lit", "xmpp.wonderland.lit", 1234, LinkLocalServiceInfo().toTXTRecord());

testServiceID = new DNSSDServiceID("foo", "bar.local");

testServiceInfo = new DNSSDResolveServiceQuery::Result("_presence._tcp.bar.local", "xmpp.bar.local", 1234, LinkLocalServiceInfo().toTXTRecord());

testServiceInfo2 = new DNSSDResolveServiceQuery::Result("_presence.tcp.bar.local", "xmpp.foo.local", 2345, LinkLocalServiceInfo().toTXTRecord());

errorStopReceived = false;

normalStopReceived = false;

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include "MUCBookmarkManager.h"

#include <boost/bind.hpp>

#include <iostream>

#include <Swiften/Base/foreach.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetPrivateStorageRequest.h>

#include <Swiften/Queries/Requests/SetPrivateStorageRequest.h>

namespace Swift {

onBookmarkRemoved(bookmark);

break;

}

}

flush();

}

void MUCBookmarkManager::flush() {

if (!storage) {

}

// Update the storage element

storage->clearRooms();

foreach(const MUCBookmark& bookmark, bookmarks_) {

storage->addRoom(bookmark.toStorage());

}

// Send an iq to save the storage element

SetPrivateStorageRequest<Storage>::ref request = SetPrivateStorageRequest<Storage>::create(storage, iqRouter_);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Parser/PayloadParsers/SecurityLabelsCatalogParser.h>

#include <Swiften/Parser/PayloadParsers/SecurityLabelParserFactory.h>

#include <Swiften/Parser/PayloadParsers/SecurityLabelParser.h>

namespace Swift {

SecurityLabelsCatalogParser::SecurityLabelsCatalogParser() : level_(TopLevel), labelParser_(0) {

labelParserFactory_ = new SecurityLabelParserFactory();

}

void SecurityLabelsCatalogParser::handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) {

++level_;

if (level_ == PayloadLevel) {

getPayloadInternal()->setTo(JID(attributes.getAttribute("to")));

getPayloadInternal()->setName(attributes.getAttribute("name"));

getPayloadInternal()->setDescription(attributes.getAttribute("desc"));

}

else if (level_ == ItemLevel && element == "item" && ns == "urn:xmpp:sec-label:catalog:2") {

currentItem_->setSelector(attributes.getAttribute("selector"));

currentItem_->setIsDefault(attributes.getBoolAttribute("default", false));

}

else if (level_ == LabelLevel) {

assert(!labelParser_);

if (labelParserFactory_->canParse(element, ns, attributes)) {

labelParser_ = dynamic_cast<SecurityLabelParser*>(labelParserFactory_->createPayloadParser());

assert(labelParser_);

}

public:

MyStanza() {}

};

class MyStanzaParser : public StanzaParser

{

public:

MyStanzaParser(PayloadParserFactoryCollection* collection) : StanzaParser(collection)

{

}

virtual boost::shared_ptr<Element> getElement() const {

return stanza_;

}

private:

boost::shared_ptr<MyStanza> stanza_;

};

CPPUNIT_TEST(testAddDirectedPresenceReceiver_WithoutSendingPresence);

CPPUNIT_TEST(testAddDirectedPresenceReceiver_AfterSendingDirectedPresence);

CPPUNIT_TEST(testRemoveDirectedPresenceReceiver);

CPPUNIT_TEST(testRemoveDirectedPresenceReceiver_WithoutSendingPresence);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

channel = new DummyStanzaChannel();

testPresence->setStatus("Foo");

secondTestPresence->setStatus("Bar");

stanzaChannelPresenceSender = new StanzaChannelPresenceSender(channel);

}

void tearDown() {

delete stanzaChannelPresenceSender;

delete channel;

}

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Queries/Request.h>

#include <Swiften/Elements/PrivateStorage.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

template<typename PAYLOAD_TYPE>

class GetPrivateStorageRequest : public Request {

public:

typedef boost::shared_ptr<GetPrivateStorageRequest<PAYLOAD_TYPE> > ref;

static ref create(IQRouter* router) {

return ref(new GetPrivateStorageRequest(router));

}

private:

}

virtual void handleResponse(boost::shared_ptr<Payload> payload, ErrorPayload::ref error) {

boost::shared_ptr<PrivateStorage> storage = boost::dynamic_pointer_cast<PrivateStorage>(payload);

if (storage) {

onResponse(boost::dynamic_pointer_cast<PAYLOAD_TYPE>(storage->getPayload()), error);

}

else {

onResponse(boost::shared_ptr<PAYLOAD_TYPE>(), error);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Queries/GenericRequest.h>

#include <Swiften/Elements/SecurityLabelsCatalog.h>

namespace Swift {

class GetSecurityLabelsCatalogRequest : public GenericRequest<SecurityLabelsCatalog> {

public:

typedef boost::shared_ptr<GetSecurityLabelsCatalogRequest> ref;

static ref create(const JID& recipient, IQRouter* router) {

return ref(new GetSecurityLabelsCatalogRequest(recipient, router));

}

private:

GetSecurityLabelsCatalogRequest(

const JID& recipient,

IQRouter* router) :

GenericRequest<SecurityLabelsCatalog>(

}

};

}

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Queries/Request.h>

#include <Swiften/Elements/PrivateStorage.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

template<typename PAYLOAD_TYPE>

class SetPrivateStorageRequest : public Request {

public:

typedef boost::shared_ptr<SetPrivateStorageRequest<PAYLOAD_TYPE> > ref;

static ref create(boost::shared_ptr<PAYLOAD_TYPE> payload, IQRouter* router) {

return ref(new SetPrivateStorageRequest<PAYLOAD_TYPE>(payload, router));

}

private:

}

virtual void handleResponse(boost::shared_ptr<Payload>, ErrorPayload::ref error) {

onResponse(error);

}

public:

boost::signal<void (ErrorPayload::ref)> onResponse;

};

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Queries/Responders/SoftwareVersionResponder.h>

#include <Swiften/Queries/IQRouter.h>

namespace Swift {

SoftwareVersionResponder::SoftwareVersionResponder(IQRouter* router) : GetResponder<SoftwareVersion>(router) {

}

void SoftwareVersionResponder::setVersion(const std::string& client, const std::string& version, const std::string& os) {

this->client = client;

this->version = version;

this->os = os;

}

bool SoftwareVersionResponder::handleGetRequest(const JID& from, const JID&, const std::string& id, boost::shared_ptr<SoftwareVersion>) {

return true;

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/shared_ptr.hpp>

#include <boost/bind.hpp>

#include <Swiften/Queries/IQHandler.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/DummyIQChannel.h>

using namespace Swift;

class IQRouterTest : public CppUnit::TestFixture {

delete channel_;

}

void testRemoveHandler() {

IQRouter testling(channel_);

DummyIQHandler handler1(true, &testling);

DummyIQHandler handler2(true, &testling);

testling.removeHandler(&handler1);

CPPUNIT_ASSERT_EQUAL(0, handler1.called);

CPPUNIT_ASSERT_EQUAL(1, handler2.called);

}

void testRemoveHandler_AfterHandleIQ() {

IQRouter testling(channel_);

DummyIQHandler handler2(true, &testling);

DummyIQHandler handler1(true, &testling);

testling.removeHandler(&handler1);

CPPUNIT_ASSERT_EQUAL(1, handler1.called);

CPPUNIT_ASSERT_EQUAL(1, handler2.called);

}

void testHandleIQ_SuccesfulHandlerFirst() {

IQRouter testling(channel_);

DummyIQHandler handler2(false, &testling);

DummyIQHandler handler1(true, &testling);

CPPUNIT_ASSERT_EQUAL(1, handler1.called);

CPPUNIT_ASSERT_EQUAL(0, handler2.called);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_SuccesfulHandlerLast() {

IQRouter testling(channel_);

DummyIQHandler handler2(true, &testling);

DummyIQHandler handler1(false, &testling);

CPPUNIT_ASSERT_EQUAL(1, handler1.called);

CPPUNIT_ASSERT_EQUAL(1, handler2.called);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_NoSuccesfulHandler() {

IQRouter testling(channel_);

DummyIQHandler handler(false, &testling);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

CPPUNIT_ASSERT(channel_->iqs_[0]->getPayload<ErrorPayload>());

}

void testHandleIQ_HandlerRemovedDuringHandle() {

IQRouter testling(channel_);

DummyIQHandler handler2(true, &testling);

RemovingIQHandler handler1(&testling);

CPPUNIT_ASSERT_EQUAL(1, handler1.called);

CPPUNIT_ASSERT_EQUAL(2, handler2.called);

}

void testSendIQ_WithFrom() {

IQRouter testling(channel_);

testling.setFrom(JID("foo@bar.com/baz"));

CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com/baz"), channel_->iqs_[0]->getFrom());

}

void testSendIQ_WithoutFrom() {

IQRouter testling(channel_);

CPPUNIT_ASSERT_EQUAL(JID(), channel_->iqs_[0]->getFrom());

}

void testHandleIQ_WithFrom() {

IQRouter testling(channel_);

testling.setFrom(JID("foo@bar.com/baz"));

DummyIQHandler handler(false, &testling);

CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com/baz"), channel_->iqs_[0]->getFrom());

}

private:

struct DummyIQHandler : public IQHandler {

DummyIQHandler(bool handle, IQRouter* router) : handle(handle), router(router), called(0) {

router->addHandler(this);

}

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_Error() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

boost::shared_ptr<IQ> error = createError(JID("foo@bar.com/baz"),"test-id");

error->addPayload(errorPayload);

channel_->onIQReceived(error);

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

CPPUNIT_ASSERT_EQUAL(ErrorPayload::InternalServerError, receivedErrors[0].getCondition());

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/shared_ptr.hpp>

#include <boost/bind.hpp>

#include <Swiften/Queries/Responder.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Elements/SoftwareVersion.h>

using namespace Swift;

CPPUNIT_TEST(testHandleIQ_Error);

CPPUNIT_TEST(testHandleIQ_Result);

CPPUNIT_TEST(testHandleIQ_NoPayload);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

channel_ = new DummyIQChannel();

router_ = new IQRouter(channel_);

}

void tearDown() {

delete router_;

delete channel_;

}

void testConstructor() {

MyResponder testling(router_);

CPPUNIT_ASSERT(!dynamic_cast<IQHandler*>(&testling)->handleIQ(createRequest(IQ::Result)));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling.getPayloads_.size()));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling.setPayloads_.size()));

}

void testHandleIQ_NoPayload() {

MyResponder testling(router_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling.getPayloads_.size()));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling.setPayloads_.size()));

}

private:

boost::shared_ptr<IQ> createRequest(IQ::Type type) {

boost::shared_ptr<IQ> iq(new IQ(type));

iq->addPayload(payload_);

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/CommandSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

namespace Swift {

std::string executeAction = actionToString(command->getExecuteAction());

if (!executeAction.empty()) {

actions += " execute='" + executeAction + "'";

}

actions += ">";

foreach (Command::Action action, command->getAvailableActions()) {

actions += "<" + actionToString(action) + "/>";

}

actions += "</actions>";

}

foreach (Command::Note note, command->getNotes()) {

boost::shared_ptr<XMLElement> noteElement(new XMLElement("note"));

std::string type;

switch (note.type) {

case Command::Note::Info: type = "info"; break;

case Command::Note::Warn: type = "warn"; break;

case Command::Note::Error: type = "error"; break;

}

if (!type.empty()) {

noteElement->setAttribute("type", type);

}

commandElement.addNode(noteElement);

}

Form::ref form = command->getForm();

if (form) {

}

return commandElement.serialize();

}

std::string CommandSerializer::actionToString(Command::Action action) const {

std::string string;

switch (action) {

case Command::Cancel: string = "cancel"; break;

case Command::Execute: string = "execute"; break;

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/DiscoInfoSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

namespace Swift {

DiscoInfoSerializer::DiscoInfoSerializer() : GenericPayloadSerializer<DiscoInfo>() {

identityElement->setAttribute("type", identity.getType());

queryElement.addNode(identityElement);

}

foreach(const std::string& feature, discoInfo->getFeatures()) {

boost::shared_ptr<XMLElement> featureElement(new XMLElement("feature"));

featureElement->setAttribute("var", feature);

queryElement.addNode(featureElement);

}

foreach(const Form::ref extension, discoInfo->getExtensions()) {

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

#include <boost/shared_ptr.hpp>

#include <iostream>

#include <string>

#include <Swiften/Base/String.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

boost::shared_ptr<XMLElement> FormSerializer::fieldToXML(boost::shared_ptr<FormField> field, bool withTypeAttribute) const {

boost::shared_ptr<XMLElement> fieldElement(new XMLElement("field"));

if (!field->getName().empty()) {

fieldElement->setAttribute("var", field->getName());

}

if (!field->getLabel().empty()) {

fieldElement->setAttribute("label", field->getLabel());

}

if (field->getRequired()) {

}

if (!field->getDescription().empty()) {

boost::shared_ptr<XMLElement> descriptionElement(new XMLElement("desc"));

fieldElement->addNode(descriptionElement);

}

// Set the value and type

std::string fieldType;

if (boost::dynamic_pointer_cast<BooleanFormField>(field)) {

fieldType = "boolean";

boost::shared_ptr<XMLElement> valueElement(new XMLElement("value"));

valueElement->addNode(XMLTextNode::create(boost::dynamic_pointer_cast<BooleanFormField>(field)->getValue() ? "1" : "0"));

return fieldElement;

}

void FormSerializer::multiLineify(const std::string& text, const std::string& elementName, boost::shared_ptr<XMLElement> element) const {

std::string unRdText(text);

erase(unRdText, '\r');

std::vector<std::string> lines = String::split(unRdText, '\n');

foreach (std::string line, lines) {

boost::shared_ptr<XMLElement> lineElement(new XMLElement(elementName));

element->addNode(lineElement);

}

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/IBBSerializer.h>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/StringCodecs/Base64.h>

namespace Swift {

std::string IBBSerializer::serializePayload(boost::shared_ptr<IBB> ibb) const {

switch(ibb->getAction()) {

case IBB::Data: {

XMLElement ibbElement("data", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

if (ibb->getSequenceNumber() >= 0) {

ibbElement.setAttribute("seq", boost::lexical_cast<std::string>(ibb->getSequenceNumber()));

}

return ibbElement.serialize();

}

case IBB::Open: {

XMLElement ibbElement("open", "http://jabber.org/protocol/ibb");

ibbElement.setAttribute("sid", ibb->getStreamID());

switch (ibb->getStanzaType()) {

case IBB::IQStanza: ibbElement.setAttribute("stanza", "iq"); break;

case IBB::MessageStanza: ibbElement.setAttribute("stanza", "message"); break;

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/InBandRegistrationPayloadSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

namespace Swift {

InBandRegistrationPayloadSerializer::InBandRegistrationPayloadSerializer() {

if (registration->getText()) {

registerElement.addNode(XMLElement::ref(new XMLElement("text", "", *registration->getText())));

}

if (registration->getKey()) {

registerElement.addNode(XMLElement::ref(new XMLElement("key", "", *registration->getKey())));

}

if (Form::ref form = registration->getForm()) {

}

return registerElement.serialize();

}

}

jinglePayload.setAttribute("action", actionToString(payload->getAction()));

jinglePayload.setAttribute("initiator", payload->getInitiator());

jinglePayload.setAttribute("sid", payload->getSessionID());

std::vector<boost::shared_ptr<Payload> > payloads = payload->getPayloads();

if (!payloads.empty()) {

foreach(boost::shared_ptr<Payload> subPayload, payloads) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(subPayload);

if (serializer) {

}

}

}

if (payload->getReason().is_initialized()) {

boost::shared_ptr<XMLElement> reason = boost::make_shared<XMLElement>("reason");

reason->addNode(boost::make_shared<XMLElement>(reasonTypeToString(payload->getReason()->type)));

if (!payload->getReason()->text.empty()) {

reason->addNode(boost::make_shared<XMLElement>("desc", "", payload->getReason()->text));

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/MUCOwnerPayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

namespace Swift {

MUCOwnerPayloadSerializer::MUCOwnerPayloadSerializer(PayloadSerializerCollection* serializers) : GenericPayloadSerializer<MUCOwnerPayload>(), serializers(serializers) {

}

std::string MUCOwnerPayloadSerializer::serializePayload(boost::shared_ptr<MUCOwnerPayload> mucOwner) const {

XMLElement mucElement("query", "http://jabber.org/protocol/muc#owner");

boost::shared_ptr<Payload> payload = mucOwner->getPayload();

if (payload) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(payload);

if (serializer) {

}

}

return mucElement.serialize();

}

}

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/MUCUserPayloadSerializer.h>

#include <sstream>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/MUCItemSerializer.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

namespace Swift {

reasonElement->addNode(boost::make_shared<XMLTextNode>(invite.reason));

}

mucElement.addNode(inviteElement);

}

boost::shared_ptr<Payload> childPayload = payload->getPayload();

if (childPayload) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(childPayload);

if (serializer) {

}

}

return mucElement.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/NicknameSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

NicknameSerializer::NicknameSerializer() : GenericPayloadSerializer<Nickname>() {

}

std::string NicknameSerializer::serializePayload(boost::shared_ptr<Nickname> nick) const {

XMLElement nickElement("nick", "http://jabber.org/protocol/nick");

return nickElement.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/PrivateStorageSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

namespace Swift {

PrivateStorageSerializer::PrivateStorageSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {

}

std::string PrivateStorageSerializer::serializePayload(boost::shared_ptr<PrivateStorage> storage) const {

XMLElement storageElement("query", "jabber:iq:private");

boost::shared_ptr<Payload> payload = storage->getPayload();

if (payload) {

PayloadSerializer* serializer = serializers->getPayloadSerializer(payload);

if (serializer) {

}

}

return storageElement.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/ResourceBindSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

ResourceBindSerializer::ResourceBindSerializer() : GenericPayloadSerializer<ResourceBind>() {

}

std::string ResourceBindSerializer::serializePayload(boost::shared_ptr<ResourceBind> resourceBind) const {

XMLElement bindElement("bind", "urn:ietf:params:xml:ns:xmpp-bind");

if (resourceBind->getJID().isValid()) {

boost::shared_ptr<XMLElement> jidNode(new XMLElement("jid"));

bindElement.addNode(jidNode);

}

else if (!resourceBind->getResource().empty()) {

boost::shared_ptr<XMLElement> resourceNode(new XMLElement("resource"));

bindElement.addNode(resourceNode);

}

return bindElement.serialize();

}

}

/*

* Copyright (c) 2011 Jan Kaluza

* Licensed under the Simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/RosterItemExchangeSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

RosterItemExchangeSerializer::RosterItemExchangeSerializer() : GenericPayloadSerializer<RosterItemExchangePayload>() {

switch (item.getAction()) {

case RosterItemExchangePayload::Item::Add: itemElement->setAttribute("action", "add"); break;

case RosterItemExchangePayload::Item::Modify: itemElement->setAttribute("action", "modify"); break;

case RosterItemExchangePayload::Item::Delete: itemElement->setAttribute("action", "delete"); break;

}

foreach(const std::string& group, item.getGroups()) {

boost::shared_ptr<XMLElement> groupElement(new XMLElement("group"));

itemElement->addNode(groupElement);

}

queryElement.addNode(itemElement);

}

return queryElement.serialize();

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/RosterSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

RosterSerializer::RosterSerializer() : GenericPayloadSerializer<RosterPayload>() {

case RosterItemPayload::None: itemElement->setAttribute("subscription", "none"); break;

}

if (item.getSubscriptionRequested()) {

itemElement->setAttribute("ask", "subscribe");

}

foreach(const std::string& group, item.getGroups()) {

boost::shared_ptr<XMLElement> groupElement(new XMLElement("group"));

itemElement->addNode(groupElement);

}

if (!item.getUnknownContent().empty()) {

}

queryElement.addNode(itemElement);

}

return queryElement.serialize();

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/SearchPayloadSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

namespace Swift {

SearchPayloadSerializer::SearchPayloadSerializer() {

itemElement->addNode(XMLElement::ref(new XMLElement("first", "", item.first)));

itemElement->addNode(XMLElement::ref(new XMLElement("last", "", item.last)));

itemElement->addNode(XMLElement::ref(new XMLElement("nick", "", item.nick)));

itemElement->addNode(XMLElement::ref(new XMLElement("email", "", item.email)));

searchElement.addNode(itemElement);

}

if (Form::ref form = searchPayload->getForm()) {

}

return searchElement.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/SecurityLabelSerializer.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLElement.h>

namespace Swift {

SecurityLabelSerializer::SecurityLabelSerializer() : GenericPayloadSerializer<SecurityLabel>() {

XMLElement element("securitylabel", "urn:xmpp:sec-label:0");

if (!label->getDisplayMarking().empty()) {

boost::shared_ptr<XMLElement> displayMarking(new XMLElement("displaymarking"));

if (!label->getForegroundColor().empty()) {

displayMarking->setAttribute("fgcolor", label->getForegroundColor());

}

if (!label->getBackgroundColor().empty()) {

displayMarking->setAttribute("bgcolor", label->getBackgroundColor());

}

element.addNode(displayMarking);

}

boost::shared_ptr<XMLElement> labelElement(new XMLElement("label"));

element.addNode(labelElement);

foreach(const std::string& equivalentLabel, label->getEquivalentLabels()) {

boost::shared_ptr<XMLElement> equivalentLabelElement(new XMLElement("equivalentlabel"));

element.addNode(equivalentLabelElement);

}

return element.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/SecurityLabelsCatalogSerializer.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/SecurityLabelSerializer.h>

namespace Swift {

SecurityLabelsCatalogSerializer::SecurityLabelsCatalogSerializer() : GenericPayloadSerializer<SecurityLabelsCatalog>() {

}

foreach (const SecurityLabelsCatalog::Item& item, catalog->getItems()) {

boost::shared_ptr<XMLElement> itemElement(new XMLElement("item"));

itemElement->setAttribute("selector", item.getSelector());

if (item.getIsDefault()) {

itemElement->setAttribute("default", "true");

}

if (item.getLabel()) {

std::string serializedLabel = SecurityLabelSerializer().serialize(item.getLabel());

}

element.addNode(itemElement);

}

return element.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Serializer/GenericPayloadSerializer.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Elements/Status.h>

namespace Swift {

class StatusSerializer : public GenericPayloadSerializer<Status> {

public:

StatusSerializer() : GenericPayloadSerializer<Status>() {}

virtual std::string serializePayload(boost::shared_ptr<Status> status) const {

XMLElement element("status");

return element.serialize();

}

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/StorageSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

StorageSerializer::StorageSerializer() : GenericPayloadSerializer<Storage>() {

}

XMLElement storageElement("storage", "storage:bookmarks");

foreach(const Storage::Room& room, storage->getRooms()) {

boost::shared_ptr<XMLElement> conferenceElement(new XMLElement("conference"));

conferenceElement->setAttribute("name", room.name);

conferenceElement->setAttribute("jid", room.jid);

conferenceElement->setAttribute("autojoin", room.autoJoin ? "1" : "0");

if (!room.nick.empty()) {

boost::shared_ptr<XMLElement> nickElement(new XMLElement("nick"));

conferenceElement->addNode(nickElement);

}

if (room.password) {

boost::shared_ptr<XMLElement> passwordElement(new XMLElement("password"));

conferenceElement->addNode(passwordElement);

}

storageElement.addNode(conferenceElement);

}

foreach(const Storage::URL& url, storage->getURLs()) {

boost::shared_ptr<XMLElement> urlElement(new XMLElement("url"));

urlElement->setAttribute("name", url.name);

urlElement->setAttribute("url", url.url);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/StreamInitiationSerializer.h>

#include <boost/shared_ptr.hpp>

#include <boost/lexical_cast.hpp>

#include <Swiften/Base/foreach.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/Serializer/PayloadSerializers/FormSerializer.h>

if (streamInitiation->getFileInfo()) {

StreamInitiationFileInfo file = *streamInitiation->getFileInfo();

boost::shared_ptr<XMLElement> fileElement(new XMLElement("file", "http://jabber.org/protocol/si/profile/file-transfer"));

fileElement->setAttribute("name", file.getName());

if (file.getSize() != 0) {

fileElement->setAttribute("size", boost::lexical_cast<std::string>(file.getSize()));

}

if (!file.getDescription().empty()) {

boost::shared_ptr<XMLElement> descElement(new XMLElement("desc"));

fileElement->addNode(descElement);

}

siElement.addNode(fileElement);

}

boost::shared_ptr<XMLElement> featureElement(new XMLElement("feature", FEATURE_NEG_NS));

if (streamInitiation->getProvidedMethods().size() > 0) {

Form::ref form(new Form(Form::FormType));

ListSingleFormField::ref field = ListSingleFormField::create();

field->setName("stream-method");

foreach(const std::string& method, streamInitiation->getProvidedMethods()) {

field->addOption(FormField::Option("", method));

}

form->addField(field);

}

else if (!streamInitiation->getRequestedMethod().empty()) {

Form::ref form(new Form(Form::SubmitType));

ListSingleFormField::ref field = ListSingleFormField::create(streamInitiation->getRequestedMethod());

field->setName("stream-method");

form->addField(field);

}

siElement.addNode(featureElement);

return siElement.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/VCardSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

#include <Swiften/Serializer/XML/XMLRawTextNode.h>

#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/Base/foreach.h>

namespace Swift {

VCardSerializer::VCardSerializer() : GenericPayloadSerializer<VCard>() {

}

std::string VCardSerializer::serializePayload(boost::shared_ptr<VCard> vcard) const {

XMLElement queryElement("vCard", "vcard-temp");

if (!vcard->getVersion().empty()) {

boost::shared_ptr<XMLElement> versionElement(new XMLElement("VERSION"));

queryElement.addNode(versionElement);

}

if (!vcard->getFullName().empty()) {

boost::shared_ptr<XMLElement> fullNameElement(new XMLElement("FN"));

queryElement.addNode(fullNameElement);

}

if (!vcard->getGivenName().empty() || !vcard->getFamilyName().empty() || !vcard->getMiddleName().empty() || !vcard->getPrefix().empty() || !vcard->getSuffix().empty()) {

boost::shared_ptr<XMLElement> nameElement(new XMLElement("N"));

if (!vcard->getFamilyName().empty()) {

boost::shared_ptr<XMLElement> familyNameElement(new XMLElement("FAMILY"));

nameElement->addNode(familyNameElement);

}

if (!vcard->getGivenName().empty()) {

boost::shared_ptr<XMLElement> givenNameElement(new XMLElement("GIVEN"));

nameElement->addNode(givenNameElement);

}

if (!vcard->getMiddleName().empty()) {

boost::shared_ptr<XMLElement> middleNameElement(new XMLElement("MIDDLE"));

nameElement->addNode(middleNameElement);

}

if (!vcard->getPrefix().empty()) {

boost::shared_ptr<XMLElement> prefixElement(new XMLElement("PREFIX"));

nameElement->addNode(prefixElement);

}

if (!vcard->getSuffix().empty()) {

boost::shared_ptr<XMLElement> suffixElement(new XMLElement("SUFFIX"));

nameElement->addNode(suffixElement);

}

queryElement.addNode(nameElement);

}

foreach(const VCard::EMailAddress& emailAddress, vcard->getEMailAddresses()) {

boost::shared_ptr<XMLElement> emailElement(new XMLElement("EMAIL"));

boost::shared_ptr<XMLElement> userIDElement(new XMLElement("USERID"));

emailElement->addNode(userIDElement);

if (emailAddress.isHome) {

}

if (emailAddress.isWork) {

}

if (emailAddress.isInternet) {

}

if (emailAddress.isPreferred) {

}

if (emailAddress.isX400) {

}

queryElement.addNode(emailElement);

}

if (!vcard->getNickname().empty()) {

boost::shared_ptr<XMLElement> nickElement(new XMLElement("NICKNAME"));

queryElement.addNode(nickElement);

}

if (!vcard->getPhoto().empty() || !vcard->getPhotoType().empty()) {

XMLElement::ref photoElement(new XMLElement("PHOTO"));

if (!vcard->getPhotoType().empty()) {

XMLElement::ref typeElement(new XMLElement("TYPE"));

typeElement->addNode(XMLTextNode::ref(new XMLTextNode(vcard->getPhotoType())));

photoElement->addNode(typeElement);

}

if (!vcard->getPhoto().empty()) {

XMLElement::ref binvalElement(new XMLElement("BINVAL"));

binvalElement->addNode(XMLTextNode::ref(new XMLTextNode(Base64::encode(vcard->getPhoto()))));

photoElement->addNode(binvalElement);

}

queryElement.addNode(photoElement);

}

if (!vcard->getUnknownContent().empty()) {

}

return queryElement.serialize();

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Serializer/PayloadSerializers/VCardUpdateSerializer.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

namespace Swift {

VCardUpdateSerializer::VCardUpdateSerializer() : GenericPayloadSerializer<VCardUpdate>() {

}

std::string VCardUpdateSerializer::serializePayload(boost::shared_ptr<VCardUpdate> vcardUpdate) const {

XMLElement updateElement("x", "vcard-temp:x:update");

boost::shared_ptr<XMLElement> photoElement(new XMLElement("photo"));

updateElement.addNode(photoElement);

return updateElement.serialize();

}

}

StreamFeaturesSerializer::StreamFeaturesSerializer() {

}

SafeByteArray StreamFeaturesSerializer::serialize(boost::shared_ptr<Element> element) const {

boost::shared_ptr<StreamFeatures> streamFeatures(boost::dynamic_pointer_cast<StreamFeatures>(element));

XMLElement streamFeaturesElement("stream:features");

if (streamFeatures->hasStartTLS()) {

}

if (!streamFeatures->getCompressionMethods().empty()) {

boost::shared_ptr<XMLElement> compressionElement(new XMLElement("compression", "http://jabber.org/features/compress"));

foreach(const std::string& method, streamFeatures->getCompressionMethods()) {

boost::shared_ptr<XMLElement> methodElement(new XMLElement("method"));

compressionElement->addNode(methodElement);

}

streamFeaturesElement.addNode(compressionElement);

}

if (!streamFeatures->getAuthenticationMechanisms().empty()) {

boost::shared_ptr<XMLElement> mechanismsElement(new XMLElement("mechanisms", "urn:ietf:params:xml:ns:xmpp-sasl"));

foreach(const std::string& mechanism, streamFeatures->getAuthenticationMechanisms()) {

boost::shared_ptr<XMLElement> mechanismElement(new XMLElement("mechanism"));

mechanismsElement->addNode(mechanismElement);

}

streamFeaturesElement.addNode(mechanismsElement);

}

if (streamFeatures->hasResourceBind()) {

}

if (streamFeatures->hasSession()) {

}

if (streamFeatures->hasStreamManagement()) {

}

if (streamFeatures->hasRosterVersioning()) {

streamFeaturesElement.addNode(boost::make_shared<XMLElement>("ver", "urn:xmpp:features:rosterver"));

}

return createSafeByteArray(streamFeaturesElement.serialize());

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Serializer/XML/XMLElement.h>

#include <Swiften/Serializer/XML/XMLTextNode.h>

using namespace Swift;

class XMLElementTest : public CppUnit::TestFixture

{

CPPUNIT_TEST_SUITE(XMLElementTest);

CPPUNIT_TEST(testSerialize);

CPPUNIT_TEST_SUITE_END();

public:

XMLElementTest() {}

void testSerialize() {

XMLElement testling("foo", "http://example.com");

testling.setAttribute("myatt", "myval");

boost::shared_ptr<XMLElement> barElement(new XMLElement("bar"));

testling.addNode(barElement);

boost::shared_ptr<XMLElement> bazElement(new XMLElement("baz"));

testling.addNode(bazElement);

std::string result = testling.serialize();

std::string expectedResult =

"<foo myatt=\"myval\" xmlns=\"http://example.com\">"

"<bar>Blo</bar>"

"<baz>Bli&amp;&lt;/stream&gt;</baz>"

"</foo>";

onStreamStartReceived(header);

}

void BOSHSessionStream::handleElementReceived(boost::shared_ptr<Element> element) {

onElementReceived(element);

}

void BOSHSessionStream::handleXMPPError() {

available = false;

}

void BOSHSessionStream::handlePoolSessionStarted() {

fakeStreamHeaderReceipt();

}

void BOSHSessionStream::handlePoolSessionTerminated(BOSHError::ref error) {

eventLoop->postEvent(boost::bind(&BOSHSessionStream::fakeStreamFooterReceipt, this, error), shared_from_this());

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Session/BasicSessionStream.h>

#include <boost/bind.hpp>

#include <Swiften/StreamStack/XMPPLayer.h>

#include <Swiften/StreamStack/StreamStack.h>

#include <Swiften/StreamStack/ConnectionLayer.h>

#include <Swiften/StreamStack/WhitespacePingLayer.h>

#include <Swiften/StreamStack/CompressionLayer.h>

#include <Swiften/StreamStack/TLSLayer.h>

#include <Swiften/TLS/TLSContextFactory.h>

#include <Swiften/TLS/TLSContext.h>

bool BasicSessionStream::supportsTLSEncryption() {

return tlsContextFactory && tlsContextFactory->canCreate();

}

void BasicSessionStream::addTLSEncryption() {

assert(available);

tlsLayer = new TLSLayer(tlsContextFactory);

if (hasTLSCertificate() && !tlsLayer->setClientCertificate(getTLSCertificate())) {

}

else {

streamStack->addLayer(tlsLayer);

tlsLayer->onError.connect(boost::bind(&BasicSessionStream::handleTLSError, this));

tlsLayer->onConnected.connect(boost::bind(&BasicSessionStream::handleTLSConnected, this));

tlsLayer->connect();

}

}

onStreamStartReceived(header);

}

void BasicSessionStream::handleElementReceived(boost::shared_ptr<Element> element) {

onElementReceived(element);

}

void BasicSessionStream::handleXMPPError() {

available = false;

}

void BasicSessionStream::handleTLSConnected() {

onTLSEncrypted();

}

void BasicSessionStream::handleTLSError() {

available = false;

}

void BasicSessionStream::handleConnectionFinished(const boost::optional<Connection::Error>& error) {

available = false;

if (error == Connection::ReadError) {

}

else if (error) {

}

else {

onClosed(boost::shared_ptr<Error>());

}

}

void BasicSessionStream::handleDataRead(const SafeByteArray& data) {

onDataRead(data);

}

void testWriteHeader() {

ProtocolHeader header;

header.setTo("example.com");

testling_->writeHeader(header);

CPPUNIT_ASSERT_EQUAL(std::string("<?xml version=\"1.0\"?><stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"example.com\" version=\"1.0\">"), lowLayer_->writtenData);

}

void testWriteElement() {

CPPUNIT_ASSERT_EQUAL(std::string("<presence/>"), lowLayer_->writtenData);

}

void testWriteFooter() {

testling_->writeFooter();

CPPUNIT_ASSERT_EQUAL(std::string("</stream:stream>"), lowLayer_->writtenData);

}