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

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

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

# FIXME: We should find a decent solution for MSVS 10

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"] :

# Testing

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

if "check" in ARGUMENTS :

env["TEST_TYPE"] = "unit"

env["checker_report"] = ARGUMENTS.get("checker_report", False)

env["TEST"] = (env["TEST_TYPE"] != "none") or env.GetOption("clean")

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

env["TEST_RUNNER"] = "valgrind --suppressions=QA/valgrind.supp -q --leak-check=full --track-origins=yes "

#include <Swift/Controllers/ProfileController.h>

#include <Swift/Controllers/ContactEditController.h>

#include <Swift/Controllers/XMPPURIController.h>

#include "Swift/Controllers/AdHocManager.h"

#include <SwifTools/Idle/IdleDetector.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/Client/ClientXMLTracer.h>

#include <Swift/Controllers/SettingConstants.h>

namespace Swift {

static const std::string CLIENT_NAME = "Swift";

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

MainController::MainController(

EventLoop* eventLoop,

profileController_ = new ProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

srand(time(NULL));

int randomPort = 10000 + rand() % 10000;

client_->getFileTransferManager()->startListeningOnPort(randomPort);

ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());

fileTransferListController_->setFileTransferOverview(ftOverview_);

rosterController_ = new RosterController(jid_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), ftOverview_);

rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));

rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));

contactEditController_ = new ContactEditController(rosterController_, client_->getVCardManager(), uiFactory_, uiEventStream_);

chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_);

client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

chatsManager_->setAvatarManager(client_->getAvatarManager());

eventWindowController_ = new EventWindowController(eventController_, uiFactory_);

client_->requestRoster();

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(boundJID_.getDomain()), client_->getIQRouter());

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

client_->getVCardManager()->requestOwnVCard();

rosterController_->setEnabled(true);

profileController_->setAvailable(true);

contactEditController_->setAvailable(true);

/* Send presence later to catch all the incoming presences. */

sendPresence(statusTracker_->getNextPresence());

/* Enable chats last of all, so rejoining MUCs has the right sent presence */

chatsManager_->setOnline(true);

}

if (statusTracker_->goAutoUnAway()) {

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

sendPresence(statusTracker_->getNextPresence());

}

}

}

}

}

void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificatePath, CertificateWithKey::ref certificate, bool remember, bool loginAutomatically) {

jid_ = JID(username);

if (!jid_.isValid() || jid_.getNode().empty()) {

loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'alice@wonderland.lit'"));

loginWindow_->setIsLoggingIn(false);

} else {

loginWindow_->setMessage("");

loginWindow_->setIsLoggingIn(true);

profileSettings_ = new ProfileSettingsProvider(username, settings_);

void handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText);

void handleDisconnected(const boost::optional<ClientError>& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, ErrorPayload::ref);

void handleEventQueueLengthChange(int count);

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

void handleSettingChanged(const std::string& settingPath);

void handlePurgeSavedLoginRequest(const std::string& username);

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

void handleInputIdleChanged(bool);

void logout();

void signOut();

void setReconnectTimer();

void resetPendingReconnects();

void resetCurrentError();

void performLoginFromCachedCredentials();

void reconnectAfterError();

void setManagersOffline();

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

*/

#pragma once

#include <string>

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/StatusShow.h"

#include "Swiften/Elements/DiscoItems.h"

#include "Swiften/Base/boost_bsignals.h"

#include <boost/shared_ptr.hpp>

namespace Swift {

class Roster;

class MainWindow {

public:

MainWindow(bool candelete = true) : canDelete_(candelete) {}

virtual void setMyNick(const std::string& name) = 0;

virtual void setMyJID(const JID& jid) = 0;

virtual void setMyAvatarPath(const std::string& path) = 0;

virtual void setMyStatusText(const std::string& status) = 0;

virtual void setMyStatusType(StatusShow::Type type) = 0;

/** Must be able to cope with NULL to clear the roster */

virtual void setRosterModel(Roster* roster) = 0;

virtual void setConnecting() = 0;

virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) = 0;

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

private:

bool canDelete_;

};

}

virtual ~MockMainWindow() {};

virtual void setRosterModel(Roster* roster) {this->roster = roster;};

virtual void setMyNick(const std::string& /*name*/) {};;

virtual void setMyJID(const JID& /*jid*/) {};;

virtual void setMyAvatarPath(const std::string& /*path*/) {};

virtual void setMyStatusText(const std::string& /*status*/) {};

virtual void setMyStatusType(StatusShow::Type /*type*/) {};

virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {};

virtual void setConnecting() {};

Roster* roster;

};

}

#include <Roster/QtRosterWidget.h>

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

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

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

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

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

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

#include <Swift/QtUI/QtUISettingConstants.h>

#include <Swift/Controllers/SettingConstants.h>

namespace Swift {

QtMainWindow::QtMainWindow(SettingsProvider* settings, UIEventStream* uiEventStream, QtLoginWindow::QtMenus loginMenus) : QWidget(), MainWindow(false), loginMenus_(loginMenus) {

uiEventStream_ = uiEventStream;

settings_ = settings;

setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

QBoxLayout *mainLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);

mainLayout->setContentsMargins(0,0,0,0);

mainLayout->setSpacing(0);

meView_ = new QtRosterHeader(settings, this);

mainLayout->addWidget(meView_);

connect(meView_, SIGNAL(onChangeStatusRequest(StatusShow::Type, const QString&)), this, SLOT(handleStatusChanged(StatusShow::Type, const QString&)));

connect(meView_, SIGNAL(onEditProfileRequest()), this, SLOT(handleEditProfileRequest()));

tabs_ = new QtTabWidget(this);

#if QT_VERSION >= 0x040500

tabs_->setDocumentMode(true);

#endif

tabs_->setTabPosition(QTabWidget::South);

mainLayout->addWidget(tabs_);

contactsTabWidget_ = new QWidget(this);

contactsTabWidget_->setContentsMargins(0, 0, 0, 0);

void QtMainWindow::handleTabChanged(int index) {

settings_->storeSetting(QtUISettingConstants::CURRENT_ROSTER_TAB, index);

}

void QtMainWindow::handleToggleRequestDeliveryReceipts(bool enabled) {

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

}

QtEventWindow* QtMainWindow::getEventWindow() {

return eventWindow_;

}

QtChatListWindow* QtMainWindow::getChatListWindow() {

return chatListWindow_;

}

void QtMainWindow::setRosterModel(Roster* roster) {

void QtMainWindow::setMyStatusType(StatusShow::Type type) {

meView_->setStatusType(type);

}

void QtMainWindow::setConnecting() {

meView_->setConnecting();

}

void QtMainWindow::handleAdHocActionTriggered(bool /*checked*/) {

QAction* action = qobject_cast<QAction*>(sender());

assert(action);

DiscoItems::Item command = serverAdHocCommands_[serverAdHocCommandActions_.indexOf(action)];

uiEventStream_->send(boost::shared_ptr<UIEvent>(new RequestAdHocUIEvent(command)));

}

void QtMainWindow::setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands) {

serverAdHocCommands_ = commands;

QtMainWindow(SettingsProvider*, UIEventStream* eventStream, QtLoginWindow::QtMenus loginMenus);

virtual ~QtMainWindow();

std::vector<QMenu*> getMenus() {return menus_;}

void setMyNick(const std::string& name);

void setMyJID(const JID& jid);

void setMyAvatarPath(const std::string& path);

void setMyStatusText(const std::string& status);

void setMyStatusType(StatusShow::Type type);

void setConnecting();

QtEventWindow* getEventWindow();

QtChatListWindow* getChatListWindow();

void setRosterModel(Roster* roster);

void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& commands);

private slots:

void handleStatusChanged(StatusShow::Type showType, const QString &statusMessage);

void handleSettingChanged(const std::string& settingPath);

void handleShowOfflineToggled(bool);

void handleJoinMUCAction();

void handleEditProfileAction();

void handleAddUserActionTriggered(bool checked);

void handleChatUserActionTriggered(bool checked);

void handleAdHocActionTriggered(bool checked);

void handleEventCountUpdated(int count);

void handleChatCountUpdated(int count);

void handleEditProfileRequest();

void handleTabChanged(int index);

void handleToggleRequestDeliveryReceipts(bool enabled);

private:

SettingsProvider* settings_;

QtLoginWindow::QtMenus loginMenus_;

std::vector<QMenu*> menus_;

QtRosterWidget* treeWidget_;

QtRosterHeader* meView_;

QAction* addUserAction_;

QAction* editUserAction_;

avatarLabel_->setScaledContents(false);

topLayout->addWidget(avatarLabel_);

connect(avatarLabel_, SIGNAL(clicked()), this, SIGNAL(onEditProfileRequest()));

QVBoxLayout* rightLayout = new QVBoxLayout();

rightLayout->setSpacing(4);

rightLayout->setContentsMargins(4,0,0,0);

topLayout->addLayout(rightLayout);

nameWidget_ = new QtNameWidget(settings, this);

connect(nameWidget_, SIGNAL(onChangeNickRequest()), this, SIGNAL(onEditProfileRequest()));

statusWidget_ = new QtStatusWidget(this);

connect(statusWidget_, SIGNAL(onChangeStatusRequest(StatusShow::Type, const QString&)), this, SLOT(handleChangeStatusRequest(StatusShow::Type, const QString&)));

rightLayout->addWidget(statusWidget_);

show();

}

void QtRosterHeader::handleChangeStatusRequest(StatusShow::Type type, const QString& text) {

emit onChangeStatusRequest(type, text);

}

void QtRosterHeader::setStatusText(const QString& statusMessage) {

statusWidget_->setStatusText(statusMessage);

void QtRosterHeader::setStatusType(StatusShow::Type type) {

statusWidget_->setStatusType(type);

}

void QtRosterHeader::setConnecting() {

statusWidget_->setConnecting();

}

void QtRosterHeader::setAvatar(const QString& path) {

QString scaledAvatarPath = QtScaledAvatarCache(avatarSize_).getScaledAvatarPath(path);

QPixmap avatar;

if (QFileInfo(scaledAvatarPath).exists()) {

avatar.load(scaledAvatarPath);

}

else {

avatar = QPixmap(":/icons/avatar.png").scaled(avatarSize_, avatarSize_, Qt::KeepAspectRatio, Qt::SmoothTransformation);

}

*/

#pragma once

#include <QWidget>

#include <QLabel>

#include <QPixmap>

#include <QSize>

#include <QToolBar>

#include <string>

#include "Swiften/Elements/StatusShow.h"

#include "QtTextEdit.h"

class QHBoxLayout;

namespace Swift {

QtRosterHeader(SettingsProvider* settings, QWidget* parent = NULL);

void setAvatar(const QString& path);

void setJID(const QString& jid);

void setNick(const QString& nick);

void setStatusText(const QString& statusMessage);

void setStatusType(StatusShow::Type type);

void setConnecting();

signals:

void onChangeStatusRequest(StatusShow::Type showType, const QString &statusMessage);

void onEditProfileRequest();

private slots:

void handleChangeStatusRequest(StatusShow::Type type, const QString &statusMessage);

private:

QString name_;

QtClickableLabel* avatarLabel_;

QtNameWidget* nameWidget_;

QtTextEdit* statusEdit_;

QToolBar* toolBar_;

QtStatusWidget* statusWidget_;

static const int avatarSize_;

};

}

myenv["SWIFT_VERSION_MAJOR"] = int(version_match.group(1)) if version_match else 0

myenv["SWIFT_VERSION_MINOR"] = int(version_match.group(2)) if version_match else 0

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

res = myenv.RES("#/Swift/resources/Windows/Swift.rc")

# For some reason, SCons isn't picking up the dependency correctly

# Adding it explicitly until i figure out why

myenv.Depends(res, "../Controllers/BuildVersion.h")

sources += [

"CAPICertificateSelector.cpp",

"WindowsNotifier.cpp",

"#/Swift/resources/Windows/Swift.res"

]

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

sources += [

"FreeDesktopNotifier.cpp",

"QtDBUSURIHandler.cpp",

]

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

sources += ["CocoaApplicationActivateHelper.mm"]

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

swiftProgram = myenv.Program("Swift", sources)

else :

swiftProgram = myenv.Program("swift", sources)

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

openURIProgram = myenv.Program("swift-open-uri", "swift-open-uri.cpp")

else :

bool getStreamManagementEnabled() const {

return stanzaAckRequester_;

}

bool getRosterVersioningSupported() const {

return rosterVersioningSupported;

}

const JID& getLocalJID() const {

return localJID;

}

void start();

void finish();

bool isFinished() const {

return getState() == Finished;

bool ClientSessionStanzaChannel::getStreamManagementEnabled() const {

if (session) {

return session->getStreamManagementEnabled();

}

return false;

}

void ClientSessionStanzaChannel::handleStanzaAcked(boost::shared_ptr<Stanza> stanza) {

onStanzaAcked(stanza);

}

void ClientSessionStanzaChannel::handleSessionInitialized() {

onAvailableChanged(true);

}

*/

class ClientSessionStanzaChannel : public StanzaChannel {

public:

void setSession(boost::shared_ptr<ClientSession> session);

void sendIQ(boost::shared_ptr<IQ> iq);

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

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

bool getStreamManagementEnabled() const;

bool isAvailable() const {

return session && session->getState() == ClientSession::Initialized;

}

private:

std::string getNewIQID();

void send(boost::shared_ptr<Stanza> stanza);

void handleSessionFinished(boost::shared_ptr<Error> error);

bool CoreClient::isAvailable() const {

return stanzaChannel_->isAvailable();

}

bool CoreClient::getStreamManagementEnabled() const {

return stanzaChannel_->getStreamManagementEnabled();

}

StanzaChannel* CoreClient::getStanzaChannel() const {

return stanzaChannel_;

}

const JID& CoreClient::getJID() const {

if (session_) {

return session_->getLocalJID();

}

else {

* Checks whether stream management is enabled.

*

* If stream management is enabled, onStanzaAcked will be

* emitted when a stanza is received by the server.

*

* \see onStanzaAcked

*/

bool getStreamManagementEnabled() const;

StanzaChannel* getStanzaChannel() const;

/**

* Sets the certificate trust checker.

*

* This checker will be called when the server sends a

* TLS certificate that does not validate. If the trust checker

* says the certificate is trusted, then connecting will proceed;

* if not, the connection will end with an error.

}

template<typename T> boost::shared_ptr<T> getStanzaAtIndex(size_t index) {

if (sentStanzas.size() <= index) {

return boost::shared_ptr<T>();

}

return boost::dynamic_pointer_cast<T>(sentStanzas[index]);

}

std::vector<boost::shared_ptr<Stanza> > sentStanzas;

bool available_;

};

}

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Queries/IQChannel.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/Elements/Presence.h>

namespace Swift {

class StanzaChannel : public IQChannel {

public:

virtual void sendMessage(boost::shared_ptr<Message>) = 0;

virtual void sendPresence(boost::shared_ptr<Presence>) = 0;

virtual bool isAvailable() const = 0;

virtual bool getStreamManagementEnabled() const = 0;

boost::signal<void (bool /* isAvailable */)> onAvailableChanged;

boost::signal<void (boost::shared_ptr<Message>)> onMessageReceived;

boost::signal<void (boost::shared_ptr<Presence>) > onPresenceReceived;

boost::signal<void (boost::shared_ptr<Stanza>)> onStanzaAcked;

};

}

virtual ByteArray getTLSFinishMessage() const {

return ByteArray();

}

virtual Certificate::ref getPeerCertificate() const {

return Certificate::ref(new SimpleCertificate());

}

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const {

return boost::shared_ptr<CertificateVerificationError>();

}

virtual bool supportsZLibCompression() {

return true;

}

virtual void addZLibCompression() {

void sendIQ(boost::shared_ptr<IQ> iq);

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

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

bool getStreamManagementEnabled() const {

return false;

}

bool isAvailable() const {

return session && session->getState() == ComponentSession::Initialized;

}

private:

std::string getNewIQID();

void send(boost::shared_ptr<Stanza> stanza);

void handleSessionFinished(boost::shared_ptr<Error> error);

void handleStanza(boost::shared_ptr<Stanza> stanza);

virtual ByteArray getTLSFinishMessage() const {

return ByteArray();

}

virtual Certificate::ref getPeerCertificate() const {

return Certificate::ref();

}

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const {

return boost::shared_ptr<CertificateVerificationError>();

}

virtual bool supportsZLibCompression() {

return true;

}

virtual void addZLibCompression() {

bool BOSHSessionStream::isTLSEncrypted() {

return false;

}

Certificate::ref BOSHSessionStream::getPeerCertificate() const {

return Certificate::ref();

}

boost::shared_ptr<CertificateVerificationError> BOSHSessionStream::getPeerCertificateVerificationError() const {

return boost::shared_ptr<CertificateVerificationError>();

}

ByteArray BOSHSessionStream::getTLSFinishMessage() const {

return ByteArray();

}

bool BOSHSessionStream::supportsZLibCompression() {

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

virtual bool supportsZLibCompression();

virtual void addZLibCompression();

virtual bool supportsTLSEncryption();

virtual void addTLSEncryption();

virtual bool isTLSEncrypted();

virtual Certificate::ref getPeerCertificate() const;

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

virtual ByteArray getTLSFinishMessage() const;

virtual void setWhitespacePingEnabled(bool);

virtual void resetXMPPParser();

private:

void handleXMPPError();

bool BasicSessionStream::isTLSEncrypted() {

return tlsLayer;

}

Certificate::ref BasicSessionStream::getPeerCertificate() const {

return tlsLayer->getPeerCertificate();

}

boost::shared_ptr<CertificateVerificationError> BasicSessionStream::getPeerCertificateVerificationError() const {

return tlsLayer->getPeerCertificateVerificationError();

}

ByteArray BasicSessionStream::getTLSFinishMessage() const {

return tlsLayer->getContext()->getFinishMessage();

}

bool BasicSessionStream::supportsZLibCompression() {

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

virtual bool supportsZLibCompression();

virtual void addZLibCompression();

virtual bool supportsTLSEncryption();

virtual void addTLSEncryption();

virtual bool isTLSEncrypted();

virtual Certificate::ref getPeerCertificate() const;

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

virtual ByteArray getTLSFinishMessage() const;

virtual void setWhitespacePingEnabled(bool);

virtual void resetXMPPParser();

private:

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

void setTLSCertificate(CertificateWithKey::ref cert) {

certificate = cert;

}

virtual bool hasTLSCertificate() {

return certificate && !certificate->isNull();

}

virtual Certificate::ref getPeerCertificate() const = 0;

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const = 0;

virtual ByteArray getTLSFinishMessage() const = 0;

boost::signal<void (const ProtocolHeader&)> onStreamStartReceived;

boost::signal<void (boost::shared_ptr<Element>)> onElementReceived;

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

boost::signal<void ()> onTLSEncrypted;

boost::signal<void (const SafeByteArray&)> onDataRead;

bool TLSLayer::setClientCertificate(CertificateWithKey::ref certificate) {

return context->setClientCertificate(certificate);

}

Certificate::ref TLSLayer::getPeerCertificate() const {

return context->getPeerCertificate();

}

boost::shared_ptr<CertificateVerificationError> TLSLayer::getPeerCertificateVerificationError() const {

return context->getPeerCertificateVerificationError();

}

}

class TLSLayer : public StreamLayer {

public:

TLSLayer(TLSContextFactory*);

~TLSLayer();

void connect();

bool setClientCertificate(CertificateWithKey::ref cert);

Certificate::ref getPeerCertificate() const;

boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

void writeData(const SafeByteArray& data);

void handleDataRead(const SafeByteArray& data);

TLSContext* getContext() const {

return context;

}

void freeX509Stack(STACK_OF(X509)* stack) {

sk_X509_free(stack);

}

OpenSSLContext::OpenSSLContext() : state_(Start), context_(0), handle_(0), readBIO_(0), writeBIO_(0) {

ensureLibraryInitialized();

context_ = SSL_CTX_new(TLSv1_client_method());

// Load system certs

#if defined(SWIFTEN_PLATFORM_WINDOWS)

X509_STORE* store = SSL_CTX_get_cert_store(context_);

HCERTSTORE systemStore = CertOpenSystemStore(0, "ROOT");

if (systemStore) {

PCCERT_CONTEXT certContext = NULL;

while (true) {

certContext = CertFindCertificateInStore(systemStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, CERT_FIND_ANY, NULL, certContext);

if (!certContext) {

boost::shared_ptr<X509> x509Cert(SSL_get_peer_certificate(handle_), X509_free);

if (x509Cert) {

return boost::make_shared<OpenSSLCertificate>(x509Cert);

}

else {

return Certificate::ref();

}

}

boost::shared_ptr<CertificateVerificationError> OpenSSLContext::getPeerCertificateVerificationError() const {

int verifyResult = SSL_get_verify_result(handle_);

if (verifyResult != X509_V_OK) {

return boost::make_shared<CertificateVerificationError>(getVerificationErrorTypeForResult(verifyResult));

}

else {

return boost::shared_ptr<CertificateVerificationError>();

}

}

~OpenSSLContext();

void connect();

bool setClientCertificate(CertificateWithKey::ref cert);

void handleDataFromNetwork(const SafeByteArray&);

void handleDataFromApplication(const SafeByteArray&);

Certificate::ref getPeerCertificate() const;

boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

virtual ByteArray getFinishMessage() const;

private:

static void ensureLibraryInitialized();

static CertificateVerificationError::Type getVerificationErrorTypeForResult(int);

Certificate::ref SchannelContext::getPeerCertificate() const {

ScopedCertContext pServerCert;

SECURITY_STATUS status = QueryContextAttributes(m_ctxtHandle, SECPKG_ATTR_REMOTE_CERT_CONTEXT, pServerCert.Reset());

return status == SEC_E_OK ? boost::make_shared<SchannelCertificate>(pServerCert) : SchannelCertificate::ref();

}

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

CertificateVerificationError::ref SchannelContext::getPeerCertificateVerificationError() const {

return m_verificationError ? boost::make_shared<CertificateVerificationError>(*m_verificationError) : CertificateVerificationError::ref();

}

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

ByteArray SchannelContext::getFinishMessage() const {

SecPkgContext_Bindings bindings;

int ret = QueryContextAttributes(m_ctxtHandle, SECPKG_ATTR_UNIQUE_BINDINGS, &bindings);

// TLSContext

//

virtual void connect();

virtual bool setClientCertificate(CertificateWithKey::ref cert);

virtual void handleDataFromNetwork(const SafeByteArray& data);

virtual void handleDataFromApplication(const SafeByteArray& data);

virtual Certificate::ref getPeerCertificate() const;

virtual CertificateVerificationError::ref getPeerCertificateVerificationError() const;

virtual ByteArray getFinishMessage() const;

virtual void setCheckCertificateRevocation(bool b);

private:

void determineStreamSizes();

void continueHandshake(const SafeByteArray& data);

virtual void connect() = 0;

virtual bool setClientCertificate(CertificateWithKey::ref cert) = 0;

virtual void handleDataFromNetwork(const SafeByteArray&) = 0;

virtual void handleDataFromApplication(const SafeByteArray&) = 0;

virtual Certificate::ref getPeerCertificate() const = 0;

virtual CertificateVerificationError::ref getPeerCertificateVerificationError() const = 0;

virtual ByteArray getFinishMessage() const = 0;

public:

boost::signal<void (const SafeByteArray&)> onDataForNetwork;

boost::signal<void (const SafeByteArray&)> onDataForApplication;

boost::signal<void (boost::shared_ptr<TLSError>)> onError;

boost::signal<void ()> onConnected;