import sys, os

sys.path.append(Dir("BuildTools/SCons").abspath)

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

# Build variables

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

vars = Variables("config.py")

vars.Add('ccflags', "Extra C(++) compiler flags")

vars.Add('linkflags', "Extra linker flags")

vars.Add(EnumVariable("test", "Compile and run tests", "none", ["none", "all", "unit", "system"]))

vars.Add(BoolVariable("optimize", "Compile with optimizations turned on", "no"))

vars.Add(BoolVariable("debug", "Compile with debug information", "yes" if os.name != "nt" else "no"))

vars.Add(BoolVariable("warnings", "Compile with warnings turned on",

"yes" if os.name != "nt" else "no"))

if os.name != "nt" :

vars.Add(BoolVariable("coverage", "Compile with coverage information", "no"))

if os.name == "posix" :

vars.Add(BoolVariable("valgrind", "Run tests with valgrind", "no"))

if os.name == "mac" :

vars.Add(BoolVariable("universal", "Create universal binaries", "no"))

if os.name == "nt" :

vars.Add(PathVariable("vcredist", "MSVC redistributable dir", "", PathVariable.PathAccept))

if os.name == "nt" :

vars.Add(PackageVariable("bonjour", "Bonjour SDK location", "yes"))

vars.Add(PackageVariable("openssl", "OpenSSL location", "yes"))

vars.Add(PathVariable("qt", "Qt location", "", PathVariable.PathAccept))

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

# Set up default build & configure environment

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

env = Environment(CPPPATH = "#", ENV = {'PATH' : os.environ['PATH']}, variables = vars)

Help(vars.GenerateHelpText(env))

env.Alias("dist", ["."])

# Default custom tools

env.Tool("Test", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("WriteVal", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("BuildVersion", toolpath = ["#/BuildTools/SCons/Tools"])

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

env.Tool("Nib", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("AppBundle", toolpath = ["#/BuildTools/SCons/Tools"])

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

env.Tool("WindowsBundle", toolpath = ["#/BuildTools/SCons/Tools"])

# Default compiler flags

env["CCFLAGS"] = env.get("ccflags", [])

Export("env")

Export("conf_env")

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

# Extend the default build environment (not affecting the configure env)

#

# Keeping both environments separated mostly because of SCons Issue 2391,

# although it doesn't hurt to separate them (e.g. not have pretty printed

# strings in config.log)

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

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

# env["MSVC_BATCH"] = 1

# Pretty output

def colorize(command, target, color) :

colors = { "red": "31", "green": "32", "yellow": "33", "blue": "34" }

prefix = ""

suffix = ""

if sys.stdout.isatty() and env["PLATFORM"] != "win32":

prefix = "\033[0;" + colors[color] + ";140m"

suffix = "\033[0m"

return " " + prefix + command + suffix + " " + target

if int(ARGUMENTS.get("V", 0)) == 0:

env["CCCOMSTR"] = colorize("CC", "$TARGET", "green")

env["CXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

env["LINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

env["ARCOMSTR"] = colorize("AR", "$TARGET", "red")

env["RANLIBCOMSTR"] = colorize("RANLIB", "$TARGET", "red")

env["QT4_RCCCOMSTR"] = colorize("RCC", "$TARGET", "blue")

env["QT4_UICCOMSTR"] = colorize("UIC", "$TARGET", "blue")

env["QT4_MOCFROMHCOMSTR"] = colorize("MOC", "$TARGET", "blue")

env["QT4_MOCFROMCXXCOMSTR"] = colorize("MOC", "$TARGET", "blue")

env["GENCOMSTR"] = colorize("GEN", "$TARGET", "blue")

env["RCCOMSTR"] = colorize("RC", "$TARGET", "blue")

env["BUNDLECOMSTR"] = colorize("BUNDLE", "$TARGET", "blue")

env["NIBCOMSTR"] = colorize("NIB", "$TARGET", "blue")

env["NSISCOMSTR"] = colorize("NSIS", "$TARGET", "blue")

env["TESTCOMSTR"] = colorize("TEST", "$SOURCE", "yellow")

#Progress(colorize("DEP", "$TARGET", "red")

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

# Platform configuration

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

conf = Configure(conf_env)

if conf.CheckLib("z") :

env.Append(LIBS = "z")

env["ZLIB_FLAGS"] = ""

else :

SConscript("3rdParty/ZLib/SConscript")

if conf.CheckLib("dl") :

env.Append(LIBS = ["dl"])

if conf.CheckLib("c") :

env.Append(LIBS = ["c"])

if conf.CheckLib("resolv") :

env.Append(LIBS = ["resolv"])

# Expat

if conf.CheckCHeader("expat.h") and conf.CheckLib("expat") :

env["HAVE_EXPAT"] = 1

env["EXPAT_FLAGS"] = { "LIBS": ["expat"] }

conf.Finish()

# Xss

env["HAVE_XSS"] = 0

if env["PLATFORM"] != "win32" and env["PLATFORM"] != "darwin" :

xss_flags = {

"LIBPATH": ["/usr/X11R6/lib"],

"LIBS": ["X11", "Xss"]

}

xss_env = conf_env.Clone()

xss_env.MergeFlags(xss_flags)

conf = Configure(xss_env)

if conf.CheckFunc("XScreenSaverQueryExtension") :

env["HAVE_XSS"] = 1

env["XSS_FLAGS"] = xss_flags

conf.Finish()

# LibXML

conf = Configure(conf_env)

if conf.CheckCHeader("libxml/parser.h") and conf.CheckLib("xml2") :

env["HAVE_LIBXML"] = 1

env["LIBXML_FLAGS"] = { "LIBS": ["xml2"] }

conf.Finish()

if not env.get("HAVE_LIBXML", 0) :

libxml_env = conf_env.Clone()

#include "Swift/Controllers/MainController.h"

#include <boost/bind.hpp>

#include <boost/lexical_cast.hpp>

#include <boost/shared_ptr.hpp>

#include <stdlib.h>

#include "Swiften/Application/Application.h"

#include "Swiften/Application/ApplicationMessageDisplay.h"

#include "Swift/Controllers/ChatController.h"

#include "Swift/Controllers/ChatWindowFactory.h"

#include "Swift/Controllers/EventController.h"

#include "Swift/Controllers/UIInterfaces/LoginWindow.h"

#include "Swift/Controllers/UIInterfaces/LoginWindowFactory.h"

#include "Swift/Controllers/MainWindow.h"

#include "Swift/Controllers/MainWindowFactory.h"

#include "Swift/Controllers/MUCController.h"

#include "Swift/Controllers/NickResolver.h"

#include "Swift/Controllers/ProfileSettingsProvider.h"

#include "Swift/Controllers/RosterController.h"

#include "Swift/Controllers/SoundEventController.h"

#include "Swift/Controllers/SoundPlayer.h"

#include "Swift/Controllers/SystemTray.h"

#include "Swift/Controllers/SystemTrayController.h"

#include "Swift/Controllers/XMLConsoleController.h"

#include "Swift/Controllers/XMPPRosterController.h"

#include "Swift/Controllers/UIInterfaces/XMLConsoleWidgetFactory.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swiften/Base/foreach.h"

#include "Swiften/Base/String.h"

#include "Swiften/Client/Client.h"

#include "Swiften/Presence/PresenceSender.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Elements/VCardUpdate.h"

#include "Swiften/Queries/Responders/SoftwareVersionResponder.h"

#include "Swiften/Roster/TreeWidgetFactory.h"

#include "Swiften/Settings/SettingsProvider.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Queries/Responders/DiscoInfoResponder.h"

#include "Swiften/Disco/CapsInfoGenerator.h"

#include "Swiften/Queries/Requests/GetDiscoInfoRequest.h"

#include "Swiften/Queries/Requests/GetVCardRequest.h"

#include "Swiften/Avatars/AvatarFileStorage.h"

#include "Swiften/Avatars/AvatarManager.h"

#include "Swiften/StringCodecs/SHA1.h"

namespace {

void printIncomingData(const Swift::String& data) {

std::cout << "<- " << data << std::endl;

}

void printOutgoingData(const Swift::String& data) {

std::cout << "-> " << data << std::endl;

}

}

namespace Swift {

static const String CLIENT_NAME = "Swift";

static const String CLIENT_VERSION = "0.3";

static const String CLIENT_NODE = "http://swift.im";

typedef std::pair<JID, ChatController*> JIDChatControllerPair;

typedef std::pair<JID, MUCController*> JIDMUCControllerPair;

MainController::MainController(ChatWindowFactory* chatWindowFactory, MainWindowFactory *mainWindowFactory, LoginWindowFactory *loginWindowFactory, TreeWidgetFactory *treeWidgetFactory, SettingsProvider *settings, Application* application, SystemTray* systemTray, SoundPlayer* soundPlayer, XMLConsoleWidgetFactory* xmlConsoleWidgetFactory)

: timerFactory_(&boostIOServiceThread_.getIOService()), idleDetector_(&idleQuerier_, &timerFactory_, 100), client_(NULL), presenceSender_(NULL), chatWindowFactory_(chatWindowFactory), mainWindowFactory_(mainWindowFactory), loginWindowFactory_(loginWindowFactory), treeWidgetFactory_(treeWidgetFactory), settings_(settings), xmppRosterController_(NULL), rosterController_(NULL), loginWindow_(NULL), clientVersionResponder_(NULL), nickResolver_(NULL), discoResponder_(NULL) {

application_ = application;

presenceOracle_ = NULL;

avatarManager_ = NULL;

uiEventStream_ = new UIEventStream();

avatarStorage_ = new AvatarFileStorage(application_->getAvatarDir());

eventController_ = new EventController();

eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings->getBoolSetting("playSounds", true));

loginWindow_ = loginWindowFactory_->createLoginWindow(uiEventStream_);

foreach (String profile, settings->getAvailableProfiles()) {

ProfileSettingsProvider* profileSettings = new ProfileSettingsProvider(profile, settings);

loginWindow_->addAvailableAccount(profileSettings->getStringSetting("jid"), profileSettings->getStringSetting("pass"), profileSettings->getStringSetting("certificate"));

delete profileSettings;

}

loginWindow_->selectUser(settings_->getStringSetting("lastLoginJID"));

loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4));

loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));

idleDetector_.setIdleTimeSeconds(600);

idleDetector_.onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

xmlConsoleController_ = new XMLConsoleController(uiEventStream_, xmlConsoleWidgetFactory);

}

void MainController::handleJoinMUCRequest(const JID &muc, const String &nick) {

mucControllers_[muc] = new MUCController(jid_, muc, nick, client_, presenceSender_, client_, chatWindowFactory_, treeWidgetFactory_, presenceOracle_, avatarManager_);

mucControllers_[muc]->setAvailableServerFeatures(serverDiscoInfo_);

}

void MainController::handleIncomingMessage(boost::shared_ptr<Message> message) {

JID jid = message->getFrom();

boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

if (!event->isReadable()) {

return;

}

// Try to deliver it to a MUC

if (message->getType() == Message::Groupchat || message->getType() == Message::Error) {

std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());

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

i->second->handleIncomingMessage(event);

return;

}

else if (message->getType() == Message::Groupchat) {

//FIXME: Error handling - groupchat messages from an unknown muc.

return;

}

}

//if not a mucroom

eventController_->handleIncomingEvent(event);

getChatController(jid)->handleIncomingMessage(event);

}

void MainController::handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, const boost::optional<ErrorPayload>& error) {

if (!error) {

serverDiscoInfo_ = info;

foreach (JIDChatControllerPair pair, chatControllers_) {

pair.second->setAvailableServerFeatures(info);

}

foreach (JIDMUCControllerPair pair, mucControllers_) {

pair.second->setAvailableServerFeatures(info);

}

}

}

bool MainController::isMUC(const JID& jid) const {

return mucControllers_.find(jid.toBare()) != mucControllers_.end();

}

void MainController::handleOwnVCardReceived(boost::shared_ptr<VCard> vCard, const boost::optional<ErrorPayload>& error) {

if (!error && !vCard->getPhoto().isEmpty()) {

if (lastSentPresence_) {

sendPresence(lastSentPresence_);

}

avatarManager_->setAvatar(jid_, vCard->getPhoto());

}

}

}

Import("env")

env["SWIFT_CONTROLLERS_FLAGS"] = {

"LIBPATH": [Dir(".")],

"LIBS": ["SwiftControllers"]

}

myenv = env.Clone()

myenv.MergeFlags(env["BOOST_FLAGS"])

myenv.StaticLibrary("SwiftControllers", [

"ChatController.cpp",

"ChatControllerBase.cpp",

"MainController.cpp",

"NickResolver.cpp",

"RosterController.cpp",

"XMPPRosterController.cpp",

"MUCController.cpp",

"EventController.cpp",

"SoundEventController.cpp",

"SystemTrayController.cpp",

"XMLConsoleController.cpp",

])

env.Append(UNITTEST_SOURCES = [

File("UnitTest/NickResolverTest.cpp"),

File("UnitTest/RosterControllerTest.cpp"),

File("UnitTest/XMPPRosterControllerTest.cpp")

])

#pragma once

namespace Swift {

class XMLConsoleWidget {

public:

virtual void show() = 0;

};

}

#include "Swiften/Avatars/AvatarManager.h"

#include <boost/bind.hpp>

#include "Swiften/Client/StanzaChannel.h"

#include "Swiften/Elements/VCardUpdate.h"

#include "Swiften/Queries/Requests/GetVCardRequest.h"

#include "Swiften/StringCodecs/SHA1.h"

#include "Swiften/Avatars/AvatarStorage.h"

#include "Swiften/MUC/MUCRegistry.h"

namespace Swift {

AvatarManager::AvatarManager(StanzaChannel* stanzaChannel, IQRouter* iqRouter, AvatarStorage* avatarStorage, MUCRegistry* mucRegistry) : stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), avatarStorage_(avatarStorage), mucRegistry_(mucRegistry) {

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

}

void AvatarManager::handlePresenceReceived(boost::shared_ptr<Presence> presence) {

boost::shared_ptr<VCardUpdate> update = presence->getPayload<VCardUpdate>();

if (!update) {

return;

}

JID from = getAvatarJID(presence->getFrom());

String& hash = avatarHashes_[from];

if (hash != update->getPhotoHash()) {

String newHash = update->getPhotoHash();

if (avatarStorage_->hasAvatar(newHash)) {

setAvatarHash(from, newHash);

}

else {

boost::shared_ptr<GetVCardRequest> request(new GetVCardRequest(from, iqRouter_));

request->onResponse.connect(boost::bind(&AvatarManager::handleVCardReceived, this, from, newHash, _1, _2));

request->send();

}

}

}

void AvatarManager::handleVCardReceived(const JID& from, const String& promisedHash, boost::shared_ptr<VCard> vCard, const boost::optional<ErrorPayload>& error) {

if (error) {

// FIXME: What to do here?

std::cerr << "Warning: " << from << ": Could not get vCard" << std::endl;

return;

}

if (promisedHash != realHash) {

std::cerr << "Warning: " << from << ": Got different vCard photo hash (" << promisedHash << " != " << realHash << ")" << std::endl;

}

avatarStorage_->addAvatar(realHash, vCard->getPhoto());

setAvatarHash(from, realHash);

}

void AvatarManager::setAvatar(const JID& jid, const ByteArray& avatar) {

avatarStorage_->addAvatar(hash, avatar);

setAvatarHash(getAvatarJID(jid), hash);

}

void AvatarManager::setAvatarHash(const JID& from, const String& hash) {

avatarHashes_[from] = hash;

onAvatarChanged(from, hash);

}

String AvatarManager::getAvatarHash(const JID& jid) const {

std::map<JID, String>::const_iterator i = avatarHashes_.find(getAvatarJID(jid));

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

return i->second;

}

else {

return "";

}

}

boost::filesystem::path AvatarManager::getAvatarPath(const JID& jid) const {

String hash = getAvatarHash(jid);

if (!hash.isEmpty()) {

return avatarStorage_->getAvatarPath(hash);

}

return boost::filesystem::path();

}

JID AvatarManager::getAvatarJID(const JID& jid) const {

JID bareFrom = jid.toBare();

return (mucRegistry_->isMUC(bareFrom) ? jid : bareFrom);

}

}

#include "Swiften/Disco/CapsInfoGenerator.h"

#include <algorithm>

#include "Swiften/Base/foreach.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/StringCodecs/SHA1.h"

#include "Swiften/StringCodecs/Base64.h"

namespace Swift {

CapsInfoGenerator::CapsInfoGenerator(const String& node) : node_(node) {

}

CapsInfo CapsInfoGenerator::generateCapsInfo(const DiscoInfo& discoInfo) const {

String serializedCaps;

std::vector<DiscoInfo::Identity> identities(discoInfo.getIdentities());

std::sort(identities.begin(), identities.end());

foreach (const DiscoInfo::Identity& identity, identities) {

serializedCaps += identity.getCategory() + "/" + identity.getType() + "/" + identity.getLanguage() + "/" + identity.getName() + "<";

}

std::vector<String> features(discoInfo.getFeatures());

std::sort(features.begin(), features.end());

foreach (const String& feature, features) {

serializedCaps += feature + "<";

}

return CapsInfo(node_, version, "sha-1");

}

}

#include "Swiften/SASL/SCRAMSHA1ClientAuthenticator.h"

#include <cassert>

#include <map>

#include <boost/lexical_cast.hpp>

#include "Swiften/StringCodecs/SHA1.h"

#include "Swiften/StringCodecs/Base64.h"

#include "Swiften/StringCodecs/HMACSHA1.h"

#include "Swiften/StringCodecs/PBKDF2.h"

#include "Swiften/StringPrep/StringPrep.h"

namespace Swift {

static String escape(const String& s) {

String result;

for (size_t i = 0; i < s.getUTF8Size(); ++i) {

if (s[i] == ',') {

result += "=2C";

}

else if (s[i] == '=') {

result += "=3D";

}

else {

result += s[i];

}

}

return result;

}

SCRAMSHA1ClientAuthenticator::SCRAMSHA1ClientAuthenticator(const String& nonce) : ClientAuthenticator("SCRAM-SHA-1"), step(Initial), clientnonce(nonce) {

}

ByteArray SCRAMSHA1ClientAuthenticator::getResponse() const {

if (step == Initial) {

return getGS2Header() + getInitialBareClientMessage();

}

else {

ByteArray clientKey = HMACSHA1::getResult(saltedPassword, "Client Key");

ByteArray clientSignature = HMACSHA1::getResult(storedKey, authMessage);

ByteArray clientProof = clientKey;

for (unsigned int i = 0; i < clientProof.getSize(); ++i) {

clientProof[i] ^= clientSignature[i];

}

ByteArray result = ByteArray("c=") + Base64::encode(getGS2Header()) + ",r=" + clientnonce + serverNonce + ",p=" + Base64::encode(clientProof);

return result;

}

}

bool SCRAMSHA1ClientAuthenticator::setChallenge(const ByteArray& challenge) {

if (step == Initial) {

initialServerMessage = challenge;

std::map<char, String> keys = parseMap(String(initialServerMessage.getData(), initialServerMessage.getSize()));

// Extract the salt

ByteArray salt = Base64::decode(keys['s']);

// Extract the server nonce

String clientServerNonce = keys['r'];

if (clientServerNonce.getUTF8Size() <= clientnonce.getUTF8Size()) {

return false;

}

String receivedClientNonce = clientServerNonce.getSubstring(0, clientnonce.getUTF8Size());

if (receivedClientNonce != clientnonce) {

return false;

}

serverNonce = clientServerNonce.getSubstring(clientnonce.getUTF8Size(), clientServerNonce.npos());

// Extract the number of iterations

int iterations = 0;

try {

iterations = boost::lexical_cast<int>(keys['i'].getUTF8String());

}

catch (const boost::bad_lexical_cast&) {

return false;

}

if (iterations <= 0) {

return false;

}

// Compute all the values needed for the server signature

saltedPassword = PBKDF2::encode(StringPrep::getPrepared(getPassword(), StringPrep::SASLPrep), salt, iterations);

authMessage = getInitialBareClientMessage() + "," + initialServerMessage + "," + "c=" + Base64::encode(getGS2Header()) + ",r=" + clientnonce + serverNonce;

ByteArray serverKey = HMACSHA1::getResult(saltedPassword, "Server Key");

serverSignature = HMACSHA1::getResult(serverKey, authMessage);

"Queries/IQHandler.cpp",

"Queries/IQRouter.cpp",

"Queries/Request.cpp",

"Queries/Responders/DiscoInfoResponder.cpp",

"Queries/Responders/SoftwareVersionResponder.cpp",

"Roster/ContactRosterItem.cpp",

"Roster/Roster.cpp",

"Roster/XMPPRoster.cpp",

"Serializer/AuthRequestSerializer.cpp",

"Serializer/AuthSuccessSerializer.cpp",

"Serializer/AuthChallengeSerializer.cpp",

"Serializer/AuthResponseSerializer.cpp",

"Serializer/CompressRequestSerializer.cpp",

"Serializer/ElementSerializer.cpp",

"Serializer/MessageSerializer.cpp",

"Serializer/PayloadSerializer.cpp",

"Serializer/PayloadSerializerCollection.cpp",

"Serializer/PayloadSerializers/CapsInfoSerializer.cpp",

"Serializer/PayloadSerializers/DiscoInfoSerializer.cpp",

"Serializer/PayloadSerializers/ErrorSerializer.cpp",

"Serializer/PayloadSerializers/FullPayloadSerializerCollection.cpp",

"Serializer/PayloadSerializers/MUCPayloadSerializer.cpp",

"Serializer/PayloadSerializers/ResourceBindSerializer.cpp",

"Serializer/PayloadSerializers/RosterSerializer.cpp",

"Serializer/PayloadSerializers/SecurityLabelSerializer.cpp",

"Serializer/PayloadSerializers/SecurityLabelsCatalogSerializer.cpp",

"Serializer/PayloadSerializers/SoftwareVersionSerializer.cpp",

"Serializer/PayloadSerializers/VCardSerializer.cpp",

"Serializer/PayloadSerializers/VCardUpdateSerializer.cpp",

"Serializer/PayloadSerializers/StorageSerializer.cpp",

"Serializer/PayloadSerializers/PrivateStorageSerializer.cpp",

"Serializer/PresenceSerializer.cpp",

"Serializer/StanzaSerializer.cpp",

"Serializer/StreamFeaturesSerializer.cpp",

"Serializer/XML/XMLElement.cpp",

"Serializer/XML/XMLNode.cpp",

"Serializer/XMPPSerializer.cpp",

"Server/ServerFromClientSession.cpp",

"Server/ServerSession.cpp",

"Server/ServerStanzaRouter.cpp",

"Server/SimpleUserRegistry.cpp",

"Server/UserRegistry.cpp",

"Session/Session.cpp",

"Session/SessionStream.cpp",

"Session/BasicSessionStream.cpp",

"StringCodecs/Base64.cpp",

"StringCodecs/SHA1.cpp",

"StringCodecs/HMACSHA1.cpp",

"StringCodecs/PBKDF2.cpp",

]

# "Notifier/GrowlNotifier.cpp",

if myenv.get("HAVE_OPENSSL", 0) :

sources += ["TLS/OpenSSL/OpenSSLContext.cpp"]

SConscript(dirs = [

"Base",

"StringPrep",

"SASL",

"Application",

"EventLoop",

"Parser",

"JID",

"Network",

"History",

"StreamStack",

"LinkLocal",

"QA",

])

myenv.StaticLibrary("Swiften", sources + swiften_env["SWIFTEN_OBJECTS"])

env.Append(UNITTEST_SOURCES = [

File("Application/UnitTest/ApplicationTest.cpp"),

File("Base/UnitTest/IDGeneratorTest.cpp"),

File("Base/UnitTest/StringTest.cpp"),

File("Base/UnitTest/ByteArrayTest.cpp"),

File("Client/UnitTest/ClientSessionTest.cpp"),

File("Compress/UnitTest/ZLibCompressorTest.cpp"),

File("Compress/UnitTest/ZLibDecompressorTest.cpp"),

File("Disco/UnitTest/CapsInfoGeneratorTest.cpp"),

File("Elements/UnitTest/IQTest.cpp"),

File("Elements/UnitTest/StanzaTest.cpp"),

File("Elements/UnitTest/StanzasTest.cpp"),

File("EventLoop/UnitTest/EventLoopTest.cpp"),

File("EventLoop/UnitTest/SimpleEventLoopTest.cpp"),

File("History/UnitTest/SQLiteHistoryManagerTest.cpp"),

File("JID/UnitTest/JIDTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalConnectorTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalServiceBrowserTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp"),

File("LinkLocal/UnitTest/LinkLocalServiceTest.cpp"),

File("Network/UnitTest/HostAddressTest.cpp"),

File("Network/UnitTest/ConnectorTest.cpp"),

File("Parser/PayloadParsers/UnitTest/BodyParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/DiscoInfoParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/ErrorParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/StorageParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/PrivateStorageParserTest.cpp"),

File("Parser/PayloadParsers/UnitTest/VCardUpdateParserTest.cpp"),

File("Parser/UnitTest/AttributeMapTest.cpp"),

File("Parser/UnitTest/IQParserTest.cpp"),

File("Parser/UnitTest/MessageParserTest.cpp"),

File("Parser/UnitTest/PayloadParserFactoryCollectionTest.cpp"),

File("Parser/UnitTest/PresenceParserTest.cpp"),

File("Parser/UnitTest/SerializingParserTest.cpp"),

File("Parser/UnitTest/StanzaParserTest.cpp"),

File("Parser/UnitTest/StreamFeaturesParserTest.cpp"),

File("Parser/UnitTest/XMLParserTest.cpp"),

File("Parser/UnitTest/XMPPParserTest.cpp"),

File("Presence/UnitTest/PresenceOracleTest.cpp"),

File("Presence/UnitTest/PresenceSenderTest.cpp"),

File("Queries/Requests/UnitTest/GetPrivateStorageRequestTest.cpp"),

File("Queries/Responders/UnitTest/DiscoInfoResponderTest.cpp"),

File("Queries/UnitTest/IQRouterTest.cpp"),

File("Queries/UnitTest/RequestTest.cpp"),

File("Queries/UnitTest/ResponderTest.cpp"),

File("Roster/UnitTest/OfflineRosterFilterTest.cpp"),

File("Roster/UnitTest/RosterTest.cpp"),

File("Roster/UnitTest/XMPPRosterTest.cpp"),

File("SASL/UnitTest/PLAINMessageTest.cpp"),

File("SASL/UnitTest/PLAINClientAuthenticatorTest.cpp"),

File("SASL/UnitTest/SCRAMSHA1ClientAuthenticatorTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/PayloadsSerializer.cpp"),

File("Serializer/PayloadSerializers/UnitTest/CapsInfoSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/DiscoInfoSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/ErrorSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/PrioritySerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/ResourceBindSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/RosterSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/SecurityLabelSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/SecurityLabelsCatalogSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/SoftwareVersionSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StatusSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StatusShowSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/VCardUpdateSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/StorageSerializerTest.cpp"),

File("Serializer/PayloadSerializers/UnitTest/PrivateStorageSerializerTest.cpp"),

File("Serializer/UnitTest/StreamFeaturesSerializerTest.cpp"),

File("Serializer/XML/UnitTest/XMLElementTest.cpp"),

File("Server/UnitTest/ServerStanzaRouterTest.cpp"),

File("StreamStack/UnitTest/StreamStackTest.cpp"),

File("StreamStack/UnitTest/XMPPLayerTest.cpp"),

File("StringCodecs/UnitTest/Base64Test.cpp"),

File("StringCodecs/UnitTest/SHA1Test.cpp"),

File("StringCodecs/UnitTest/HMACSHA1Test.cpp"),

File("StringCodecs/UnitTest/PBKDF2Test.cpp"),

])

#include <vector>

#include "Swiften/Base/String.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

public:

static String encode(const ByteArray& s);

static ByteArray decode(const String &s);

};

}

#include "Swiften/StringCodecs/HMACSHA1.h"

#include <cassert>

#include "Swiften/StringCodecs/SHA1.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

static const unsigned int B = 64;

ByteArray HMACSHA1::getResult(const ByteArray& key, const ByteArray& data) {

assert(key.getSize() <= B);

// Create the padded key

ByteArray paddedKey(key);

paddedKey.resize(B);

for (unsigned int i = key.getSize(); i < paddedKey.getSize(); ++i) {

paddedKey[i] = 0x0;

}

// Create the first value

ByteArray x(paddedKey);

for (unsigned int i = 0; i < x.getSize(); ++i) {

x[i] ^= 0x36;

}

x += data;

// Create the second value

ByteArray y(paddedKey);

for (unsigned int i = 0; i < y.getSize(); ++i) {

y[i] ^= 0x5c;

}

}

}

#include "Swiften/Base/Platform.h"

#pragma GCC diagnostic ignored "-Wold-style-cast"

/*

SHA-1 in C

By Steve Reid <steve@edmweb.com>

100% Public Domain

Test Vectors (from FIPS PUB 180-1)

"abc"

A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D

"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"

84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1

A million repetitions of "a"

34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F

*/

/* #define LITTLE_ENDIAN * This should be #define'd if true. */

/* #define SHA1HANDSOFF * Copies data before messing with it. */

#include <boost/cstdint.hpp>

#include <stdio.h>

#include <string.h>

typedef struct {

boost::uint32_t state[5];

boost::uint32_t count[2];

boost::uint8_t buffer[64];

} SHA1_CTX;

void SHA1Transform(boost::uint32_t state[5], boost::uint8_t buffer[64]);

void SHA1Init(SHA1_CTX* context);

void SHA1Update(SHA1_CTX* context, boost::uint8_t* data, unsigned int len);

void SHA1Final(boost::uint8_t digest[20], SHA1_CTX* context);

#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))

/* blk0() and blk() perform the initial expand. */

/* I got the idea of expanding during the round function from SSLeay */

#ifdef SWIFTEN_LITTLE_ENDIAN

#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \

|(rol(block->l[i],8)&0x00FF00FF))

#else

#define blk0(i) block->l[i]

#endif

#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \

^block->l[(i+2)&15]^block->l[i&15],1))

SHA1Transform(context->state, context->buffer);

for ( ; i + 63 < len; i += 64) {

SHA1Transform(context->state, &data[i]);

}

j = 0;

}

else i = 0;

memcpy(&context->buffer[j], &data[i], len - i);

}

/* Add padding and return the message digest. */

void SHA1Final(boost::uint8_t digest[20], SHA1_CTX* context)

{

boost::uint32_t i, j;

boost::uint8_t finalcount[8];

for (i = 0; i < 8; i++) {

finalcount[i] = (boost::uint8_t) ((context->count[(i >= 4 ? 0 : 1)]

>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */

}

SHA1Update(context, (boost::uint8_t *)("\200"), 1);

while ((context->count[0] & 504) != 448) {

SHA1Update(context, (boost::uint8_t *)("\0"), 1);

}

SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */

for (i = 0; i < 20; i++) {

digest[i] = (boost::uint8_t)

((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);

}

/* Wipe variables */

i = j = 0;

memset(context->buffer, 0, 64);

memset(context->state, 0, 20);

memset(context->count, 0, 8);

memset(&finalcount, 0, 8);

#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */

SHA1Transform(context->state, context->buffer);

#endif

}

// -----------------------------------------------------------------------------

#include "Swiften/StringCodecs/SHA1.h"

namespace Swift {

ByteArray inputCopy(input);

ByteArray digest;

digest.resize(20);

SHA1_CTX context;

SHA1Init(&context);

SHA1Update(&context, (boost::uint8_t*) inputCopy.getData(), inputCopy.getSize());

SHA1Final((boost::uint8_t*) digest.getData(), &context);

return digest;

}

}

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class SHA1 {

public:

}

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "Swiften/StringCodecs/Base64.h"

using namespace Swift;

CPPUNIT_TEST_SUITE(Base64Test);

CPPUNIT_TEST(testEncode);

CPPUNIT_TEST(testEncode_NonAscii);

CPPUNIT_TEST(testEncode_NoData);

CPPUNIT_TEST(testDecode);

CPPUNIT_TEST(testDecode_NoData);

CPPUNIT_TEST_SUITE_END();

public:

void testEncode() {

String result(Base64::encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"));

CPPUNIT_ASSERT_EQUAL(String("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejEyMzQ1Njc4OTA="), result);

}

void testEncode_NonAscii() {

String result(Base64::encode(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed")));

CPPUNIT_ASSERT_EQUAL(String("QgayPKawpkPSDYmwT/WM94uAlu0="), result);

}

void testEncode_NoData() {

String result(Base64::encode(ByteArray()));

CPPUNIT_ASSERT_EQUAL(String(""), result);

}

void testDecode() {

ByteArray result(Base64::decode("QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejEyMzQ1Njc4OTA="));

CPPUNIT_ASSERT_EQUAL(ByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"), result);

}

void testDecode_NoData() {

ByteArray result(Base64::decode(""));

CPPUNIT_ASSERT_EQUAL(ByteArray(), result);

}

};

CPPUNIT_TEST_SUITE_REGISTRATION(Base64Test);

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include "Swiften/StringCodecs/SHA1.h"

using namespace Swift;

CPPUNIT_TEST_SUITE(SHA1Test);

CPPUNIT_TEST_SUITE_END();

public:

CPPUNIT_ASSERT_EQUAL(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);

}

ByteArray input("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<");

CPPUNIT_ASSERT_EQUAL(ByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), result);

}

}

};

CPPUNIT_TEST_SUITE_REGISTRATION(SHA1Test);