if env.get("coverage", 0) :

assert(env["PLATFORM"] != "win32")

env.Append(CCFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

env.Append(LINKFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

if env["PLATFORM"] == "win32" :

env.Append(LIBS = ["user32", "crypt32", "dnsapi", "iphlpapi", "ws2_32", "wsock32", "Advapi32"])

env.Append(CCFLAGS = ["/EHsc", "/nologo"])

if int(env["MSVS_VERSION"].split(".")[0]) < 10 :

env["LINKCOM"] = [env["LINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1']

env["SHLINKCOM"] = [env["SHLINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2']

if env["PLATFORM"] == "darwin" and not env["target"] in ["iphone-device", "iphone-simulator", "xcode"] :

env.Append(FRAMEWORKS = ["IOKit", "AppKit", "SystemConfiguration", "Security", "SecurityInterface"])

# Testing

env["TEST_TYPE"] = env["test"]

/*

* 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 <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <string>

#include <Swiften/Session/Session.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class ProtocolHeader;

class Element;

class Stanza;

env.Install(os.path.join(env["SWIFT_INSTALLDIR"], "share", "swift", dir), resource)

if env["PLATFORM"] == "win32" :

if env["DIST"] :

commonResources[""] = commonResources.get("", []) + [

#os.path.join(env["OPENSSL_DIR"], "bin", "ssleay32.dll"),

#os.path.join(env["OPENSSL_DIR"], "bin", "libeay32.dll"),

"#/Swift/resources/images",

]

qtimageformats = ["gif", "ico", "jpeg", "mng", "svg", "tiff"]

qtlibs = ["QtCore4", "QtGui4", "QtNetwork4", "QtWebKit4", "QtXMLPatterns4", "phonon4"]

myenv.WindowsBundle("Swift",

resources = commonResources,

qtimageformats = qtimageformats,

qtlibs = qtlibs)

#myenv.Append(NSIS_OPTIONS = [

# "/DmsvccRedistributableDir=\"" + env["vcredist"] + "\"",

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <map>

#include <Swiften/JID/JID.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/Command.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <boost/signals/connection.hpp>

namespace Swift {

class IQRouter;

class MainWindow;

class UIEventStream;

public:

/**

* Availability of action.

*/

enum ActionState {

Absent /** Action isn't applicable to this command. */ = 0,

Present /** Action is applicable to this command */= 1,

Enabled /** Action is applicable and currently available */ = 2,

* 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 <boost/filesystem/path.hpp>

#include <string>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class JID;

public:

virtual ~AvatarStorage();

virtual bool hasAvatar(const std::string& hash) const = 0;

virtual void addAvatar(const std::string& hash, const ByteArray& avatar) = 0;

virtual ByteArray getAvatar(const std::string& hash) const = 0;

virtual boost::filesystem::path getAvatarPath(const std::string& hash) const = 0;

virtual void setAvatarForJID(const JID& jid, const std::string& hash) = 0;

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <string>

namespace Swift {

typedef std::vector<unsigned char> ByteArray;

inline ByteArray createByteArray(const unsigned char* c, size_t n) {

return ByteArray(c, c + n);

}

inline ByteArray createByteArray(const char* c, size_t n) {

return ByteArray(c, c + n);

}

static const T* vecptr(const std::vector<T, A>& v) {

return v.empty() ? NULL : &v[0];

}

template<typename T, typename A>

static T* vecptr(std::vector<T, A>& v) {

return v.empty() ? NULL : &v[0];

}

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

public:

virtual ~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 <string>

namespace Swift {

public:

IDGenerator();

std::string generateID();

};

}

* Copyright (c) 2010-2012 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <iostream>

namespace Swift {

namespace LogDetail {

// Only here to be able to statically check the correctness of the severity levers

namespace Severity {

enum {

debug, info, warning, 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 <boost/filesystem/path.hpp>

namespace Swift {

public:

static boost::filesystem::path getExecutablePath();

};

}

* Copyright (c) 2011 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <Swiften/Base/SafeAllocator.h>

#include <Swiften/Base/ByteArray.h>

#include <boost/smart_ptr/make_shared.hpp>

namespace Swift {

typedef std::vector<unsigned char, SafeAllocator<unsigned char> > SafeByteArray;

inline SafeByteArray createSafeByteArray(const ByteArray& a) {

return SafeByteArray(a.begin(), a.end());

}

inline SafeByteArray createSafeByteArray(const std::string& s) {

return SafeByteArray(s.begin(), s.end());

}

inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const std::string& s) {

return boost::make_shared<SafeByteArray>(s.begin(), s.end());

}

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

*/

#pragma once

#include <string>

#include <vector>

#include <sstream>

#define SWIFTEN_STRING_TO_CFSTRING(a) \

CFStringCreateWithBytes(NULL, reinterpret_cast<const UInt8*>(a.c_str()), a.size(), kCFStringEncodingUTF8, false)

namespace Swift {

namespace String {

inline bool beginsWith(const std::string& s, char c) {

return s.size() > 0 && s[0] == c;

}

inline bool endsWith(const std::string& s, char c) {

return s.size() > 0 && s[s.size()-1] == c;

}

};

public:

template <typename T> makeString& operator<<(T const& v) {

stream << v;

return *this;

}

operator std::string() const {

return stream.str();

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

}

* 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/Elements/Message.h>

#include <Swiften/Elements/ChatState.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class StanzaChannel;

class EntityCapsProvider;

public:

ChatStateNotifier(StanzaChannel* stanzaChannel, const JID& contact, EntityCapsProvider* entityCapsManager);

~ChatStateNotifier();

void setContact(const JID& contact);

void addChatStateRequest(Message::ref message);

void setUserIsTyping();

* 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/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/ChatState.h>

namespace Swift {

public:

ChatStateTracker();

void handleMessageReceived(boost::shared_ptr<Message> message);

void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

boost::signal<void (ChatState::ChatStateType)> onChatStateChange;

private:

void changeState(ChatState::ChatStateType state);

ChatState::ChatStateType currentState_;

};

/*

* 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/Client/CoreClient.h>

#include <Swiften/Base/SafeString.h>

namespace Swift {

class SoftwareVersionResponder;

class BlindCertificateTrustChecker;

class XMPPRoster;

class XMPPRosterImpl;

class MUCManager;

class XMPPRosterController;

class JingleSessionManager;

class FileTransferManager;

/**

* Provides the core functionality for writing XMPP client software.

*

* Besides connecting to an XMPP server, this class also provides interfaces for

* performing most tasks on the XMPP network.

*/

public:

/**

* Constructs a client for the given JID with the given password.

*

* \param storages The interfaces for storing cache information etc. If

* this is NULL,

* all data will be stored in memory (and be lost on shutdown)

*/

Client(const JID& jid, const SafeString& password, NetworkFactories* networkFactories, Storages* storages = NULL);

/*

* 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/Client/CoreClient.h>

#include <Swiften/Client/XMLBeautifier.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

ClientXMLTracer(CoreClient* client, bool bosh = false);

~ClientXMLTracer();

private:

void printData(char direction, const SafeByteArray& data);

void printLine(char c);

private:

XMLBeautifier *beautifier;

* Copyright (c) 2010-2012 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Entity/Entity.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Client/ClientOptions.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/CertificateWithKey.h>

namespace Swift {

class ChainedConnector;

* The central class for communicating with an XMPP server.

*

* This class is responsible for setting up the connection with the XMPP

* server, authenticating, and initializing the session.

*

* This class can be used directly in your application, although the Client

* subclass provides more functionality and interfaces, and is better suited

* for most needs.

*/

public:

/**

* Constructs a client for the given JID with the given password.

* The given eventLoop will be used to post events to.

*/

CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories);

~CoreClient();

/**

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#include <map>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/VCard.h>

namespace Swift {

class XMPPRoster;

class MUCRegistry;

class VCardManager;

public:

NickResolver(const JID& ownJID, XMPPRoster* xmppRoster, VCardManager* vcardManager, MUCRegistry* mucRegistry);

std::string jidToNick(const JID& jid);

boost::signal<void (const JID&, const std::string& /*previousNick*/)> onNickChanged;

private:

void handleVCardReceived(const JID& jid, VCard::ref vCard);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class VCardStorage;

class AvatarStorage;

class CapsStorage;

class RosterStorage;

/**

* An interface to hold storage classes for different

* controllers.

*/

public:

virtual ~Storages();

virtual VCardStorage* getVCardStorage() const = 0;

virtual AvatarStorage* getAvatarStorage() const = 0;

virtual CapsStorage* getCapsStorage() const = 0;

virtual RosterStorage* getRosterStorage() const = 0;

};

}

/*

* 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/Component/CoreComponent.h>

namespace Swift {

class SoftwareVersionResponder;

/**

* Provides the core functionality for writing XMPP component software.

*

* Besides connecting to an XMPP server, this class also provides interfaces for

* performing most component tasks on the XMPP network.

*/

public:

Component(EventLoop* eventLoop, NetworkFactories* networkFactories, const JID& jid, const std::string& secret);

~Component();

/**

* Sets the software version of the client.

*

* This will be used to respond to version queries from other entities.

*/

/*

* 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/Component/Component.h>

namespace Swift {

public:

ComponentXMLTracer(CoreComponent* component);

private:

static void printData(char direction, const SafeByteArray& data);

static void printLine(char c);

};

}

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Network/PlatformDomainNameResolver.h>

#include <Swiften/Component/ComponentConnector.h>

#include <Swiften/Component/ComponentSession.h>

#include <Swiften/Component/ComponentError.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/JID/JID.h>

* The central class for communicating with an XMPP server as a component.

*

* This class is responsible for setting up the connection with the XMPP

* server and authenticating the component.

*

* This class can be used directly in your application, although the Component

* subclass provides more functionality and interfaces, and is better suited

* for most needs.

*/

public:

CoreComponent(EventLoop* eventLoop, NetworkFactories* networkFactories, const JID& jid, const std::string& secret);

~CoreComponent();

void connect(const std::string& host, int port);

void disconnect();

void sendMessage(boost::shared_ptr<Message>);

void sendPresence(boost::shared_ptr<Presence>);

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/DiscoInfo.h>

namespace Swift {

public:

virtual ~CapsStorage();

virtual DiscoInfo::ref getDiscoInfo(const std::string&) const = 0;

virtual void setDiscoInfo(const std::string&, DiscoInfo::ref) = 0;

};

}

/*

* 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/Elements/CapsInfo.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Presence/PayloadAddingPresenceSender.h>

namespace Swift {

class IQRouter;

class DiscoInfoResponder;

class PayloadAddingPresenceSender;

class PresenceSender;

* Class responsible for managing outgoing disco information for a client.

*

* The manager will respond to disco#info requests, and add entity capabilities information

* to outgoing presence.

*

* To use this class, call setCapsNode() once with the caps URI of the client. After this,

* call setDiscoInfo() with the capabilities for the client. This can be

* called whenever the capabilities change.

*/

public:

/**

* Constructs the manager

*

* \param iqRouter the router on which requests will be answered

* \param presenceSender the presence sender to which all outgoing presence

* (with caps information) will be sent.

*/

ClientDiscoManager(IQRouter* iqRouter, PresenceSender* presenceSender);

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <set>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <string>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/DiscoItems.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Disco/GetDiscoInfoRequest.h>

#include <Swiften/Disco/GetDiscoItemsRequest.h>

namespace Swift {

class IQRouter;

/**

* Recursively walk service discovery trees to find all services offered.

* This stops on any disco item that's not reporting itself as a server.

*/

public:

DiscoServiceWalker(const JID& service, IQRouter* iqRouter, size_t maxSteps = 200);

/**

* Start the walk.

*

* Call this exactly once.

*/

void beginWalk();

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <string>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/Form.h>

namespace Swift {

/**

* disco#info from XEP-0030

*/

public:

typedef boost::shared_ptr<DiscoInfo> ref;

static const std::string ChatStatesFeature;

static const std::string SecurityLabelsFeature;

static const std::string SecurityLabelsCatalogFeature;

static const std::string JabberSearchFeature;

static const std::string CommandsFeature;

static const std::string MessageCorrectionFeature;

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

public:

virtual ~Element();

};

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <string>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/FormField.h>

#include <Swiften/JID/JID.h>

namespace Swift {

/**

* XEP-0004 Data form.

* For the relevant Fields, the parsers and serialisers protect the API user against

* the strange multi-value instead of newline thing by transforming them.

*/

public:

typedef boost::shared_ptr<Form> ref;

typedef std::vector<FormField::ref> FormItem;

enum Type { FormType, SubmitType, CancelType, ResultType };

public:

Form(Type type = FormType) : type_(type) {}

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

public:

typedef boost::shared_ptr<IQ> ref;

enum Type { Get, Set, Result, Error };

IQ(Type type = Get) : type_(type) { }

Type getType() const { return type_; }

void setType(Type type) { type_ = type; }

/*

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/optional.hpp>

#include <string>

#include <Swiften/JID/JID.h>

namespace Swift {

class Client;

public:

enum Role {Moderator, Participant, Visitor, NoRole};

enum Affiliation {Owner, Admin, Member, Outcast, NoAffiliation};

MUCOccupant(const std::string &nick, Role role, Affiliation affiliation);

MUCOccupant(const MUCOccupant& other);

~MUCOccupant();

std::string getNick() const;

* 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 <boost/shared_ptr.hpp>

namespace Swift {

public:

typedef boost::shared_ptr<Payload> ref;

public:

virtual ~Payload();

};

}

* 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 <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Elements/Stanza.h>

#include <Swiften/Elements/StatusShow.h>

namespace Swift {

public:

typedef boost::shared_ptr<Presence> ref;

enum Type { Available, Error, Probe, Subscribe, Subscribed, Unavailable, Unsubscribe, Unsubscribed };

Presence();

Presence(const std::string& status);

virtual ~Presence();

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

*/

#pragma once

#include <vector>

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/SecurityLabel.h>

namespace Swift {

public:

typedef boost::shared_ptr<SecurityLabelsCatalog> ref;

class Item {

public:

Item() : default_(false) {}

SecurityLabel::ref getLabel() const {

return label_;

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Payload.h>

namespace Swift {

public:

typedef boost::shared_ptr<SoftwareVersion> ref;

SoftwareVersion(

const std::string& name = "",

const std::string& version = "",

const std::string& os = "") :

name_(name), version_(version), os_(os) {}

#pragma once

#include <vector>

#include <string>

#include <boost/shared_ptr.hpp>

#include <boost/optional/optional_fwd.hpp>

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

#include <Swiften/Elements/Element.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class Payload;

public:

typedef boost::shared_ptr<Stanza> ref;

Stanza();

virtual ~Stanza();

template<typename T>

boost::shared_ptr<T> getPayload() const {

for (size_t i = 0; i < payloads_.size(); ++i) {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class PayloadParserFactory;

class PayloadSerializer;

class FullPayloadParserFactoryCollection;

class FullPayloadSerializerCollection;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

/**

* The base class for XMPP entities (Clients, Components).

*/

public:

Entity();

virtual ~Entity();

void addPayloadParserFactory(PayloadParserFactory* payloadParserFactory);

void removePayloadParserFactory(PayloadParserFactory* payloadParserFactory);

void addPayloadSerializer(PayloadSerializer* payloadSerializer);

void removePayloadSerializer(PayloadSerializer* payloadSerializer);

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/filesystem/path.hpp>

namespace Swift {

class Payload;

class PayloadSerializer;

class PayloadParser;

public:

PayloadPersister();

virtual ~PayloadPersister();

void savePayload(boost::shared_ptr<Payload>, const boost::filesystem::path&);

boost::shared_ptr<Payload> loadPayload(const boost::filesystem::path&);

protected:

* 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 <deque>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

public:

DummyEventLoop();

~DummyEventLoop();

void processEvents() {

while (!events_.empty()) {

handleEvent(events_[0]);

events_.pop_front();

}

*/

#pragma once

#include <boost/function.hpp>

#include <boost/thread/mutex.hpp>

#include <list>

#include <deque>

#include <Swiften/EventLoop/Event.h>

namespace Swift {

class EventOwner;

public:

EventLoop();

virtual ~EventLoop();

void postEvent(boost::function<void ()> event, boost::shared_ptr<EventOwner> owner = boost::shared_ptr<EventOwner>());

void removeEventsFromOwner(boost::shared_ptr<EventOwner> owner);

protected:

/**

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

public:

virtual ~EventOwner();

};

}

*/

#pragma once

#include <vector>

#include <boost/function.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/condition_variable.hpp>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

public:

SimpleEventLoop();

~SimpleEventLoop();

void run() {

doRun(false);

}

void runUntilEvents() {

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/filesystem/path.hpp>

#include <boost/filesystem/fstream.hpp>

#include <Swiften/FileTransfer/ReadBytestream.h>

namespace Swift {

public:

FileReadBytestream(const boost::filesystem::path& file);

~FileReadBytestream();

virtual boost::shared_ptr< std::vector<unsigned char> > read(size_t size);

virtual bool isFinished() const;

private:

boost::filesystem::path file;

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/filesystem/path.hpp>

#include <boost/filesystem/fstream.hpp>

#include <Swiften/FileTransfer/WriteBytestream.h>

namespace Swift {

public:

FileWriteBytestream(const boost::filesystem::path& file);

~FileWriteBytestream();

virtual void write(const std::vector<unsigned char>&);

void close();

private:

boost::filesystem::path file;

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

*/

#pragma once

#include <string>

//#include <iosfwd>

#include <iostream>

namespace Swift {

/**

* This represents the JID used in XMPP

* (RFC6120 - http://tools.ietf.org/html/rfc6120 ).

* For a description of format, see the RFC or page 14 of

* XMPP: The Definitive Guide (Saint-Andre et al.)

*

* Particularly - a Bare JID is a JID without a resource part.

*

* A JID can be invalid (when isValid() returns false). No member methods are

* guaranteed to work correctly if they do.

*/

public:

enum CompareType {

WithResource, WithoutResource

};

/**

* Create a JID from its String representation.

*

* e.g.

* 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 <boost/shared_ptr.hpp>

namespace Swift {

class DNSSDQuerier;

class EventLoop;

public:

PlatformDNSSDQuerierFactory(EventLoop* eventLoop);

boost::shared_ptr<DNSSDQuerier> createQuerier();

bool canCreate();

private:

EventLoop* eventLoop;

/*

* 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/JID/JID.h>

#include <string>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/Elements/MUCOwnerPayload.h>

#include <Swiften/Elements/MUCAdminPayload.h>

#include <Swiften/Elements/Form.h>

#include <boost/signals/connection.hpp>

#include <map>

namespace Swift {

class StanzaChannel;

class IQRouter;

class DirectedPresenceSender;

public:

typedef boost::shared_ptr<MUC> ref;

enum JoinResult { JoinSucceeded, JoinFailed };

enum LeavingType { LeavePart, LeaveKick, LeaveBan, LeaveDestroy, LeaveNotMember, Disconnect };

public:

MUC(StanzaChannel* stanzaChannel, IQRouter* iqRouter, DirectedPresenceSender* presenceSender, const JID &muc, MUCRegistry* mucRegistry);

#pragma once

#include <vector>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/optional.hpp>

#include <Swiften/MUC/MUCBookmark.h>

#include <Swiften/Elements/Storage.h>

#include <Swiften/Elements/ErrorPayload.h>

namespace Swift {

class IQRouter;

public:

MUCBookmarkManager(IQRouter* iqRouter);

void addBookmark(const MUCBookmark& bookmark);

void removeBookmark(const MUCBookmark& bookmark);

void replaceBookmark(const MUCBookmark& oldBookmark, const MUCBookmark& newBookmark);

const std::vector<MUCBookmark>& getBookmarks() const;

/*

* 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/MUC/MUC.h>

namespace Swift {

class IQRouter;

class StanzaChannel;

class DirectedPresenceSender;

class MUCRegistry;

public:

MUCManager(StanzaChannel* stanzaChannel, IQRouter* iqRouter, DirectedPresenceSender* presenceSender, MUCRegistry* mucRegistry);

MUC::ref createMUC(const JID&);

private:

StanzaChannel* stanzaChannel;

IQRouter* iqRouter;

DirectedPresenceSender* presenceSender;

* 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 <vector>

#include <Swiften/JID/JID.h>

namespace Swift {

class JID;

public:

~MUCRegistry();

bool isMUC(const JID& j) const;

void addMUC(const JID& j);

void removeMUC(const JID& j);

private:

std::vector<JID> mucs;

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <boost/asio/ip/tcp.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <boost/thread/mutex.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Base/SafeByteArray.h>

namespace boost {

class thread;

namespace system {

class error_code;

}

}

namespace Swift {

class EventLoop;

public:

typedef boost::shared_ptr<BoostConnection> ref;

~BoostConnection();

static ref create(boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

return ref(new BoostConnection(ioService, eventLoop));

}

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/asio/io_service.hpp>

#include <boost/asio/ip/tcp.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionServer.h>

#include <Swiften/EventLoop/EventOwner.h>

namespace Swift {

public:

typedef boost::shared_ptr<BoostConnectionServer> ref;

enum Error {

Conflict,

UnknownError

};

static ref create(int port, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

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

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <boost/thread/thread.hpp>

#include <boost/shared_ptr.hpp>

namespace Swift {

public:

BoostIOServiceThread();

~BoostIOServiceThread();

boost::shared_ptr<boost::asio::io_service> getIOService() const {

return ioService_;

}

private:

/*

* 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/Network/NetworkFactories.h>

#include <Swiften/Network/BoostIOServiceThread.h>

namespace Swift {

class EventLoop;

class NATTraverser;

class PlatformTLSFactories;

public:

BoostNetworkFactories(EventLoop* eventLoop);

~BoostNetworkFactories();

virtual TimerFactory* getTimerFactory() const {

return timerFactory;

}

virtual ConnectionFactory* getConnectionFactory() const {

/*

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

public:

virtual ~ConnectionServer();

virtual HostAddressPort getAddressPort() const = 0;

virtual void start() = 0;

virtual void stop() = 0;

/*

* 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 <boost/shared_ptr.hpp>

#include <string>

namespace Swift {

class DomainNameServiceQuery;

class DomainNameAddressQuery;

public:

virtual ~DomainNameResolver();

virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& name) = 0;

virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name) = 0;

};

}

* 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 <string>

#include <boost/asio/ip/address.hpp>

namespace Swift {

public:

HostAddress();

HostAddress(const std::string&);

HostAddress(const unsigned char* address, int length);

HostAddress(const boost::asio::ip::address& address);

std::string toString() const;

boost::asio::ip::address getRawAddress() const;

* 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 <boost/asio/ip/tcp.hpp>

#include <Swiften/Network/HostAddress.h>

namespace Swift {

public:

HostAddressPort(const HostAddress& address = HostAddress(), int port = -1);

HostAddressPort(const boost::asio::ip::tcp::endpoint& endpoint);

const HostAddress& getAddress() const {

return address_;

}

int getPort() const {

*/

#pragma once

#include <deque>

#include <boost/thread/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/condition_variable.hpp>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/PlatformDomainNameQuery.h>

#include <Swiften/Network/DomainNameServiceQuery.h>

#include <Swiften/Network/DomainNameAddressQuery.h>

namespace Swift {

class EventLoop;

public:

PlatformDomainNameResolver(EventLoop* eventLoop);

~PlatformDomainNameResolver();

virtual DomainNameServiceQuery::ref createServiceQuery(const std::string& name);

virtual DomainNameAddressQuery::ref createAddressQuery(const std::string& name);

private:

void run();

*/

#pragma once

#include <vector>

#include <string>

#include <map>

#include <boost/optional/optional_fwd.hpp>

#include <Swiften/Parser/Attribute.h>

namespace Swift {

public:

class Entry {

public:

Entry(const Attribute& attribute, const std::string& value) : attribute(attribute), value(value) {

}

const Attribute& getAttribute() const {

return attribute;

}

/*

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Elements/Payload.h>

namespace Swift {

/**

* A parser for XMPP stanza payloads.

*

* The parser is event driven: handleStartElement, handleEndElement, and handleCharacterData will be called

* when the parser detects start and end of XML elements, or character data.

* After the data for the given top-level element is processed, getPayload() will be called to retrieve the

* payload.

*/

public:

virtual ~PayloadParser();

/**

* Handle the start of an XML element.

*/

virtual void handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) = 0;

/**

/*

* 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/Parser/AttributeMap.h>

namespace Swift {

class PayloadParser;

/**

* A factory for PayloadParsers.

*/

public:

virtual ~PayloadParserFactory();

/**

* Checks whether this factory can parse the given top-level element in the given namespace (with the given attributes).

*/

virtual bool canParse(const std::string& element, const std::string& ns, const AttributeMap& attributes) const = 0;

/**

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <Swiften/Parser/AttributeMap.h>

namespace Swift {

class PayloadParserFactory;

public:

PayloadParserFactoryCollection();

void addFactory(PayloadParserFactory* factory);

void removeFactory(PayloadParserFactory* factory);

void setDefaultFactory(PayloadParserFactory* factory);

PayloadParserFactory* getPayloadParserFactory(const std::string& element, const std::string& ns, const AttributeMap& attributes);

/*

* 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/Elements/DiscoInfo.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

public:

DiscoInfoParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes);

virtual void handleEndElement(const std::string& element, const std::string&);

virtual void handleCharacterData(const std::string& data);

private:

enum Level {

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <vector>

#include <Swiften/Parser/PayloadParserFactoryCollection.h>

#include <Swiften/Parser/PayloadParserFactory.h>

namespace Swift {

public:

FullPayloadParserFactoryCollection();

~FullPayloadParserFactoryCollection();

private:

std::vector< boost::shared_ptr<PayloadParserFactory> > factories_;

PayloadParserFactory* defaultFactory_;

};

}

/*

* 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/Elements/RosterPayload.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SerializingParser;

public:

RosterParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes);

virtual void handleEndElement(const std::string& element, const std::string&);

virtual void handleCharacterData(const std::string& data);

private:

enum Level {

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swiften/Elements/VCard.h>

#include <Swiften/Parser/GenericPayloadParser.h>

namespace Swift {

class SerializingParser;

public:

VCardParser();

virtual void handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes);

virtual void handleEndElement(const std::string& element, const std::string&);

virtual void handleCharacterData(const std::string& data);

private:

std::string getElementHierarchy() const;

/*

* 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/Parser/XMLParserFactory.h>

namespace Swift {

public:

PlatformXMLParserFactory();

virtual XMLParser* createXMLParser(XMLParserClient*);

};

}

* 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 <string>

namespace Swift {

class XMLParserClient;

public:

XMLParser(XMLParserClient* client);

virtual ~XMLParser();

virtual bool parse(const std::string& data) = 0;

XMLParserClient* getClient() const {

return client_;

}

/*

* 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/AttributeMap.h>

namespace Swift {

public:

virtual ~XMLParserClient();

virtual void handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) = 0;

virtual void handleEndElement(const std::string& element, const std::string& ns) = 0;

virtual void handleCharacterData(const std::string& data) = 0;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class XMLParser;

class XMLParserClient;

public:

virtual ~XMLParserFactory();

virtual XMLParser* createXMLParser(XMLParserClient*) = 0;

};

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/noncopyable.hpp>

#include <Swiften/Parser/XMLParserClient.h>

#include <Swiften/Parser/AttributeMap.h>

namespace Swift {

class XMLParser;

class XMPPParserClient;

class XMLParserFactory;

class ElementParser;

class PayloadParserFactoryCollection;

public:

XMPPParser(

XMPPParserClient* parserClient,

PayloadParserFactoryCollection* payloadParserFactories,

XMLParserFactory* xmlParserFactory);

~XMPPParser();

bool parse(const std::string&);

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Elements/Element.h>

namespace Swift {

class ProtocolHeader;

public:

virtual ~XMPPParserClient();

virtual void handleStreamStart(const ProtocolHeader&) = 0;

virtual void handleElement(boost::shared_ptr<Element>) = 0;

virtual void handleStreamEnd() = 0;

};

}

*/

#pragma once

#include <map>

#include <string>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

public:

PresenceOracle(StanzaChannel* stanzaChannel);

~PresenceOracle();

Presence::ref getLastPresence(const JID&) const;

Presence::ref getHighestPriorityPresence(const JID& bareJID) const;

std::vector<Presence::ref> getAllPresence(const JID& bareJID) const;

public:

#pragma once

#include <map>

#include <string>

#include <Swiften/JID/JID.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/Presence.h>

namespace Swift {

class StanzaChannel;

public:

SubscriptionManager(StanzaChannel* stanzaChannel);

~SubscriptionManager();

void cancelSubscription(const JID& jid);

void confirmSubscription(const JID& jid);

void requestSubscription(const JID& jid);

/**

/*

* 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 <Swiften/Queries/Request.h>

namespace Swift {

/**

* GenericRequest is used for managing the sending of, and handling of replies to, iq stanzas that do not have their own Request types.

*

* To create an iq stanza, call a constructor with the type of the iq that needs to be sent (either Set or Get), addressing information (clients should use the constructor that doesn't specify a sender), the payload that should be sent in the iq, and the IQRouter for the connection, obtained through the Client or CoreClient object.

*

* Having created a GenericRequest, connect to the onResponse signal to be told when a response (either a result or an error) has been received by Swiften.

/*

* 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/Responder.h>

namespace Swift {

template<typename T>

public:

GetResponder(IQRouter* router) : Responder<T>(router) {}

private:

virtual bool handleSetRequest(const JID&, const JID&, const std::string&, boost::shared_ptr<T>) { return false; }

};

}

* 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 <boost/shared_ptr.hpp>

#include <Swiften/Elements/IQ.h>

namespace Swift {

class IQRouter;

public:

virtual ~IQHandler();

virtual bool handleIQ(boost::shared_ptr<IQ>) = 0;

};

}

* 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 <boost/shared_ptr.hpp>

#include <vector>

#include <string>

#include <Swiften/Elements/IQ.h>

namespace Swift {

class IQChannel;

class IQHandler;

public:

IQRouter(IQChannel* channel);

~IQRouter();

/**

* Sets the JID of this IQ router.

*

* This JID is used by requests to check whether incoming

* results are addressed correctly.

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <string>

#include <Swiften/Queries/IQHandler.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/JID/JID.h>

namespace Swift {

/**

* An IQ get/set request query.

*/

public:

void send();

const JID& getReceiver() const {

return receiver_;

}

protected:

/**

/*

* 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/GetResponder.h>

#include <Swiften/Elements/SoftwareVersion.h>

namespace Swift {

class IQRouter;

public:

SoftwareVersionResponder(IQRouter* router);

void setVersion(const std::string& client, const std::string& version, const std::string& os = "");

private:

virtual bool handleGetRequest(const JID& from, const JID& to, const std::string& id, boost::shared_ptr<SoftwareVersion> payload);

private:

* Copyright (c) 2011 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/RosterPayload.h>

namespace Swift {

public:

virtual ~RosterStorage();

virtual boost::shared_ptr<RosterPayload> getRoster() const = 0;

virtual void setRoster(boost::shared_ptr<RosterPayload>) = 0;

};

}

* Licensed under the GNU General Public License v3.

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

*/

// TODO: Get rid of this

//

#pragma once

#include <string>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

PLAINMessage(const std::string& authcid, const SafeByteArray& password, const std::string& authzid = "");

PLAINMessage(const SafeByteArray& value);

SafeByteArray getValue() const;

const std::string& getAuthenticationID() const {

return authcid;

}

Import("env")

################################################################################

# Flags

################################################################################

swiften_dep_modules = ["BOOST", "GCONF", "ICU", "LIBIDN", "ZLIB", "OPENSSL", "LIBXML", "EXPAT", "AVAHI", "LIBMINIUPNPC", "LIBNATPMP"]

if env["SCONS_STAGE"] == "flags" :

env["SWIFTEN_VERSION"] = Version.getBuildVersion(env.Dir("#").abspath, "swift")

version_match = re.match("(\d+)\.(\d+).*", env["SWIFTEN_VERSION"])

if version_match :

env["SWIFTEN_VERSION_MAJOR"] = int(version_match.group(1))

env["SWIFTEN_VERSION_MINOR"] = int(version_match.group(2))

else :

env["SWIFTEN_VERSION_MAJOR"] = 0

env["SWIFTEN_VERSION_MINOR"] = 0

env["SWIFTEN_VERSION_PATCH"] = 0

env["SWIFTEN_LIBRARY"] = "Swiften"

env["SWIFTEN_LIBRARY_FILE"] = "Swiften"

env["SWIFTEN_LIBRARY_ALIASES"] = []

if env["PLATFORM"] == "win32" :

elif env["PLATFORM"] == "darwin" :

env["SWIFTEN_LIBRARY_FILE"] = env.subst("Swiften.${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}")

env["SWIFTEN_LIBRARY_ALIASES"] = ["libSwiften.dylib", env.subst("libSwiften.${SWIFTEN_VERSION_MAJOR}.dylib")]

else :

env["SWIFTEN_LIBRARY_FILE"] = env.subst("libSwiften.so.${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}")

env["SWIFTEN_LIBRARY_ALIASES"] = ["libSwiften.so", env.subst("libSwiften.so.${SWIFTEN_VERSION_MAJOR}")]

swiften_env = env.Clone()

swiften_env["LIBPATH"] = [Dir(".")]

swiften_env["LIBS"] = [swiften_env["SWIFTEN_LIBRARY"]]

dep_env = env.Clone()

for module in swiften_dep_modules :

if env.get(module + "_BUNDLED", False) :

swiften_env.UseFlags(env.get(module + "_FLAGS", {}))

else :

dep_env.UseFlags(env.get(module + "_FLAGS", {}))

dep_env.UseFlags(dep_env["PLATFORM_FLAGS"])

if env.get("HAVE_SCHANNEL", 0) :

"FRAMEWORKS": e.get("FRAMEWORKS", []),

}

################################################################################

# Build

################################################################################

if env["SCONS_STAGE"] == "build" :

swiften_env = env.Clone()

for module in swiften_dep_modules :

swiften_env.UseFlags(swiften_env.get(module + "_FLAGS", {}))

swiften_env.UseFlags(swiften_env["PLATFORM_FLAGS"])

swiften_env.AddMethod(lambda e,s : e.SharedObject(s), "SwiftenObject")

swiften_env.AddMethod(lambda e,l,o : e.SharedLibrary(l,o), "SwiftenLibrary")

else :

swiften_env.AddMethod(lambda e,s : e.StaticObject(s), "SwiftenObject")

swiften_env.AddMethod(lambda e,l,o : e.StaticLibrary(l,o), "SwiftenLibrary")

Export("swiften_env")

# TODO: Move all this to a submodule SConscript

sources = [

if env["build_examples"] :

SConscript(dirs = [

"Config",

"Examples"

])

env.SConscript(test_only = True, dirs = [

"QA",

])

myenv = swiften_env.Clone()

if myenv["PLATFORM"] == "win32":

sources.append("StringCodecs/SHA1_Windows.cpp")

else:

sources.append("StringCodecs/SHA1.cpp")

if myenv["PLATFORM"] != "darwin" and myenv["PLATFORM"] != "win32" and myenv.get("HAVE_GCONF", 0) :

env.MergeFlags(env["GCONF_FLAGS"])

if myenv["PLATFORM"] == "posix" :

myenv.Append(LINKFLAGS = ["-Wl,-soname,libSwiften.so.$SWIFTEN_VERSION_MAJOR"])

myenv["SHLIBSUFFIX"] = ""

elif myenv["PLATFORM"] == "darwin" :

myenv.Append(LINKFLAGS = ["-Wl,-install_name,libSwiften.so.$SWIFTEN_VERSION_MAJOR", "-Wl,-compatibility_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}", "-Wl,-current_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}"])

swiften_lib = myenv.SwiftenLibrary(swiften_env["SWIFTEN_LIBRARY_FILE"], sources + swiften_env["SWIFTEN_OBJECTS"])

def symlink(env, target, source) :

if os.path.exists(str(target[0])) :

os.unlink(str(target[0]))

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <boost/shared_ptr.hpp>

namespace Swift {

class Payload;

public:

virtual ~PayloadSerializer();

virtual bool canSerialize(boost::shared_ptr<Payload>) const = 0;

virtual std::string serialize(boost::shared_ptr<Payload>) const = 0;

};

}

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <vector>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class PayloadSerializer;

public:

PayloadSerializerCollection();

void addSerializer(PayloadSerializer* factory);

void removeSerializer(PayloadSerializer* factory);

PayloadSerializer* getPayloadSerializer(boost::shared_ptr<Payload>) const;

private:

std::vector<PayloadSerializer*> serializers_;

/*

* 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/Elements/DiscoInfo.h>

namespace Swift {

public:

DiscoInfoSerializer();

virtual std::string serializePayload(boost::shared_ptr<DiscoInfo>) const;

};

}

/*

* 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/Elements/ErrorPayload.h>

namespace Swift {

class PayloadSerializerCollection;

public:

ErrorSerializer(PayloadSerializerCollection* serializers);

virtual std::string serializePayload(boost::shared_ptr<ErrorPayload> error) const;

private:

PayloadSerializerCollection* serializers;

};

}

* 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 <vector>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

namespace Swift {

public:

FullPayloadSerializerCollection();

~FullPayloadSerializerCollection();

private:

std::vector<PayloadSerializer*> serializers_;

};

}

/*

* 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/Elements/RosterPayload.h>

namespace Swift {

public:

RosterSerializer();

virtual std::string serializePayload(boost::shared_ptr<RosterPayload>) const;

};

}

* 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/Elements/VCard.h>

namespace Swift {

public:

VCardSerializer();

virtual std::string serializePayload(boost::shared_ptr<VCard>) const;

};

}

#pragma once

#include <boost/shared_ptr.hpp>

#include <vector>

#include <map>

#include <string>

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

namespace Swift {

public:

typedef boost::shared_ptr<XMLElement> ref;

XMLElement(const std::string& tag, const std::string& xmlns = "", const std::string& text = "");

void setAttribute(const std::string& attribute, const std::string& value);

void addNode(boost::shared_ptr<XMLNode> node);

virtual std::string 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 <string>

namespace Swift {

public:

virtual ~XMLNode();

virtual std::string serialize() = 0;

};

}

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/optional.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/Element.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/StreamStack/ConnectionLayer.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class ProtocolHeader;

class StreamStack;

class JID;

class Element;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class XMPPLayer;

class XMLParserFactory;

public:

enum SessionError {

ConnectionReadError,

ConnectionWriteError,

XMLError,

AuthenticationFailedError,

NoSupportedAuthMechanismsError,

UnexpectedElementError,

ResourceBindError,

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/noncopyable.hpp>

#include <Swiften/StreamStack/HighLayer.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Elements/Element.h>

#include <Swiften/Elements/StreamType.h>

#include <Swiften/Parser/XMPPParserClient.h>

namespace Swift {

class ProtocolHeader;

class XMPPParser;

class PayloadParserFactoryCollection;

class XMPPSerializer;

class PayloadSerializerCollection;

class XMLParserFactory;

class BOSHSessionStream;

friend class BOSHSessionStream;

public:

XMPPLayer(

PayloadParserFactoryCollection* payloadParserFactories,

PayloadSerializerCollection* payloadSerializers,

XMLParserFactory* xmlParserFactory,

StreamType streamType);

~XMPPLayer();

/*

* 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 <vector>

#include <string>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

static std::string encode(const ByteArray& s);

static SafeByteArray encode(const SafeByteArray& s);

static ByteArray decode(const std::string &s);

};

}

/*

* 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/ByteArray.h>

namespace Swift {

public:

static std::string hexify(unsigned char byte);

static std::string hexify(const ByteArray& data);

static ByteArray unhexify(const std::string& hexstring);

};

}

#pragma once

#ifdef SWIFTEN_PLATFORM_WIN32

#include "SHA1_Windows.h"

#else

#include <vector>

#include <boost/cstdint.hpp>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

SHA1();

SHA1& update(const std::vector<unsigned char>& data);

std::vector<unsigned char> getHash() const;

/**

* Equivalent of:

* SHA1().update(data),getHash(), but slightly more efficient and

#pragma once

#include <vector>

#include <Windows.h>

#define SECURITY_WIN32

#include <security.h>

#include <Wincrypt.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

public:

SHA1();

~SHA1();

SHA1& update(const std::vector<unsigned char>& data);

std::vector<unsigned char> getHash() const;

static ByteArray getHash(const ByteArray& data);

static ByteArray getHash(const SafeByteArray& data);

/*

* Copyright (c) 2012 Isode Limited, London, England.

* Licensed under the simplified BSD license.

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

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/Network/Timer.h>

#define SECURITY_WIN32

#include <Windows.h>

#include <WinCrypt.h>

#include <Winscard.h>

#define SMARTCARD_EJECTION_CHECK_FREQUENCY_MILLISECONDS 1000

namespace Swift {

class TimerFactory;

public:

CAPICertificate(const std::string& capiUri, TimerFactory* timerFactory);

virtual ~CAPICertificate();

virtual bool isNull() const;

const std::string& getCertStoreName() const;

/*

* 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 <boost/shared_ptr.hpp>

#include <string>

#include <vector>

namespace Swift {

/**

* A class to implement a check for certificate trust.

*/

public:

virtual ~CertificateTrustChecker();

/**

* This method is called to find out whether a certificate (chain) is

* trusted. This usually happens when a certificate's validation

* fails, to check whether to proceed with the connection or not.

*

* certificateChain contains the chain of certificates. The first certificate

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class TLSContextFactory;

class CertificateFactory;

public:

PlatformTLSFactories();

~PlatformTLSFactories();

TLSContextFactory* getTLSContextFactory() const;

CertificateFactory* getCertificateFactory() const;

private:

TLSContextFactory* contextFactory;

* 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 <set>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/VCard.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/VCards/SetVCardRequest.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class JID;

class VCardStorage;

class IQRouter;

public:

VCardManager(const JID& ownJID, IQRouter* iqRouter, VCardStorage* vcardStorage);

~VCardManager();

VCard::ref getVCard(const JID& jid) const;

VCard::ref getVCardAndRequestWhenNeeded(const JID& jid);

void requestVCard(const JID& jid);

void requestOwnVCard();

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Elements/VCard.h>

namespace Swift {

class JID;

public:

virtual ~VCardStorage();

virtual VCard::ref getVCard(const JID& jid) const = 0;

virtual void setVCard(const JID&, VCard::ref) = 0;

virtual std::string getPhotoHash(const JID&) const;

};

}