/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Client/BlockListImpl.h>

#include <algorithm>

using namespace Swift;

BlockListImpl::BlockListImpl() : state(Init) {

}

void BlockListImpl::setItems(const std::vector<JID>& newItems) {

// JIDs which are in the current list but not in the new list, are removed.

if (std::find(newItems.begin(), newItems.end(), jid) == newItems.end()) {

onItemRemoved(jid);

}

}

// JIDs which are in the new list but not in the current list, are added.

if (std::find(items.begin(), items.end(), jid) == items.end()) {

onItemAdded(jid);

}

}

items = newItems;

}

void BlockListImpl::addItem(const JID& item) {

if (std::find(items.begin(), items.end(), item) == items.end()) {

items.push_back(item);

onItemAdded(item);

}

}

void BlockListImpl::removeItem(const JID& item) {

size_t oldSize = items.size();

items.erase(std::remove(items.begin(), items.end(), item), items.end());

if (items.size() != oldSize) {

onItemRemoved(item);

}

}

void BlockListImpl::setState(State state) {

if (this->state != state) {

this->state = state;

onStateChanged();

}

}

void BlockListImpl::addItems(const std::vector<JID>& items) {

addItem(item);

}

}

void BlockListImpl::removeItems(const std::vector<JID>& items) {

std::vector<JID> itemsToRemove = items;

removeItem(item);

}

}

void BlockListImpl::removeAllItems() {

removeItems(items);

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Client/CoreClient.h>

#include <memory>

#include <boost/bind.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Client/ClientSession.h>

#include <Swiften/Client/ClientSessionStanzaChannel.h>

#include <Swiften/Network/ChainedConnector.h>

#include <Swiften/Network/DomainNameResolveError.h>

#include <Swiften/Network/HTTPConnectProxiedConnectionFactory.h>

#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/Network/ProxyProvider.h>

#include <Swiften/Network/SOCKS5ProxiedConnectionFactory.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Session/BOSHSessionStream.h>

#include <Swiften/Session/BasicSessionStream.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/TLS/PKCS12Certificate.h>

#include <Swiften/TLS/TLSError.h>

namespace Swift {

CoreClient::CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories) : jid_(jid), password_(password), networkFactories(networkFactories), disconnectRequested_(false), certificateTrustChecker(nullptr) {

stanzaChannel_ = new ClientSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.connect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

stanzaChannel_->onStanzaAcked.connect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

stanzaChannel_->onAvailableChanged.connect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

iqRouter_ = new IQRouter(stanzaChannel_);

iqRouter_->setJID(jid);

}

CoreClient::~CoreClient() {

forceReset();

}

bool CoreClient::getStreamManagementEnabled() const {

return stanzaChannel_->getStreamManagementEnabled();

}

bool CoreClient::isStreamEncrypted() const {

return sessionStream_->isTLSEncrypted();

}

StanzaChannel* CoreClient::getStanzaChannel() const {

return stanzaChannel_;

}

const JID& CoreClient::getJID() const {

if (session_) {

return session_->getLocalJID();

}

else {

return jid_;

}

}

void CoreClient::purgePassword() {

safeClear(password_);

}

void CoreClient::resetConnector() {

connector_->onConnectFinished.disconnect(boost::bind(&CoreClient::handleConnectorFinished, this, _1, _2));

connector_.reset();

delete f;

}

proxyConnectionFactories.clear();

}

void CoreClient::resetSession() {

session_->onFinished.disconnect(boost::bind(&CoreClient::handleSessionFinished, this, _1));

session_->onNeedCredentials.disconnect(boost::bind(&CoreClient::handleNeedCredentials, this));

sessionStream_->onDataRead.disconnect(boost::bind(&CoreClient::handleDataRead, this, _1));

sessionStream_->onDataWritten.disconnect(boost::bind(&CoreClient::handleDataWritten, this, _1));

if (connection_) {

connection_->disconnect();

}

else if (std::dynamic_pointer_cast<BOSHSessionStream>(sessionStream_)) {

sessionStream_->close();

}

sessionStream_.reset();

connection_.reset();

}

void CoreClient::forceReset() {

if (connector_) {

SWIFT_LOG(warning) << "Client not disconnected properly: Connector still active" << std::endl;

resetConnector();

}

if (sessionStream_ || connection_) {

SWIFT_LOG(warning) << "Client not disconnected properly: Session still active" << std::endl;

resetSession();

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <algorithm>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Queries/IQRouter.h>

using namespace Swift;

class ClientBlockListManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ClientBlockListManagerTest);

CPPUNIT_TEST(testFetchBlockList);

CPPUNIT_TEST(testBlockCommand);

CPPUNIT_TEST(testUnblockCommand);

CPPUNIT_TEST(testUnblockAllCommand);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

ownJID_ = JID("kev@wonderland.lit");

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

iqRouter_->setJID(ownJID_);

clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

}

void testFetchBlockList() {

std::vector<JID> blockJids;

blockJids.push_back(JID("romeo@montague.net"));

blockJids.push_back(JID("iago@shakespeare.lit"));

helperInitialBlockListFetch(blockJids);

std::shared_ptr<UnblockPayload> pushPayload = std::make_shared<UnblockPayload>();

IQ::ref unblockPush = IQ::createRequest(IQ::Set, ownJID_, "push1", pushPayload);

stanzaChannel_->sendIQ(unblockPush);

stanzaChannel_->onIQReceived(unblockPush);

CPPUNIT_ASSERT_EQUAL(true, clientBlockListManager_->getBlockList()->getItems().empty());

}

void tearDown() {

delete clientBlockListManager_;

delete iqRouter_;

delete stanzaChannel_;

}

private:

void helperInitialBlockListFetch(const std::vector<JID>& blockedJids) {

std::shared_ptr<BlockList> blockList = clientBlockListManager_->requestBlockList();

CPPUNIT_ASSERT(blockList);

// check for IQ request

IQ::ref request = stanzaChannel_->getStanzaAtIndex<IQ>(0);

CPPUNIT_ASSERT(request.get() != nullptr);

std::shared_ptr<BlockListPayload> requestPayload = request->getPayload<BlockListPayload>();

CPPUNIT_ASSERT(requestPayload.get() != nullptr);

CPPUNIT_ASSERT_EQUAL(BlockList::Requesting, blockList->getState());

CPPUNIT_ASSERT_EQUAL(BlockList::Requesting, clientBlockListManager_->getBlockList()->getState());

// build IQ response

std::shared_ptr<BlockListPayload> responsePayload = std::make_shared<BlockListPayload>();

responsePayload->addItem(jid);

}

IQ::ref response = IQ::createResult(ownJID_, JID(), request->getID(), responsePayload);

stanzaChannel_->sendIQ(response);

stanzaChannel_->onIQReceived(response);

CPPUNIT_ASSERT_EQUAL(BlockList::Available, clientBlockListManager_->getBlockList()->getState());

CPPUNIT_ASSERT(responsePayload->getItems() == clientBlockListManager_->getBlockList()->getItems());

}

private:

JID ownJID_;

IQRouter* iqRouter_;

DummyStanzaChannel* stanzaChannel_;

ClientBlockListManager* clientBlockListManager_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ClientBlockListManagerTest);

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* Copyright (c) 2014-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Client/XMLBeautifier.h>

#include <sstream>

#include <stack>

#include <Swiften/Base/Log.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

namespace Swift {

XMLBeautifier::XMLBeautifier(bool indention, bool coloring) : doIndention(indention), doColoring(coloring), intLevel(0), parser(nullptr), lastWasStepDown(false) {

factory = new PlatformXMLParserFactory();

}

XMLBeautifier::~XMLBeautifier() {

delete factory;

}

std::string XMLBeautifier::beautify(const std::string &text) {

parser = factory->createXMLParser(this);

intLevel = 0;

buffer.str(std::string());

parser->parse(text);

delete parser;

return buffer.str();

}

void XMLBeautifier::indent() {

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

buffer << " ";

}

}

// all bold but reset

// static const char colorBlue[] = "\x1b[01;34m";

static const char colorCyan[] = "\x1b[01;36m";

}

std::string XMLBeautifier::styleAttribute(const std::string& text) const {

std::string result;

result += colorGreen;

result += text;

result += colorReset;

return result;

}

std::string XMLBeautifier::styleValue(const std::string& text) const {

std::string result;

result += colorCyan;

result += text;

result += colorReset;

return result;

}

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

if (doIndention) {

if (intLevel) buffer << std::endl;

}

indent();

buffer << "<" << (doColoring ? styleTag(element) : element);

if (!ns.empty() && (!parentNSs.empty() && parentNSs.top() != ns)) {

buffer << " ";

buffer << (doColoring ? styleAttribute("xmlns") : "xmlns");

buffer << "=";

buffer << "\"" << (doColoring ? styleNamespace(ns) : ns) << "\"";

}

if (!attributes.getEntries().empty()) {

buffer << " ";

buffer << (doColoring ? styleAttribute(entry.getAttribute().getName()) : entry.getAttribute().getName());

buffer << "=";

buffer << "\"" << (doColoring ? styleValue(entry.getValue()) : entry.getValue()) << "\"";

}

}

buffer << ">";

++intLevel;

lastWasStepDown = false;

parentNSs.push(ns);

}

void XMLBeautifier::handleEndElement(const std::string& element, const std::string& /* ns */) {

--intLevel;

parentNSs.pop();

if (/*hadCDATA.top() ||*/ lastWasStepDown) {

if (doIndention) {

buffer << std::endl;

}

indent();

}

buffer << "</" << (doColoring ? styleTag(element) : element) << ">";

lastWasStepDown = true;

}

void XMLBeautifier::handleCharacterData(const std::string& data) {

buffer << data;

lastWasStepDown = false;

}