#include <Swift/QtUI/QtUISettingConstants.h>

#include <Swiften/Base/Platform.h>

#include <Swiften/Base/Paths.h>

#include <QtAboutWidget.h>

#include <QtSwiftUtil.h>

#include <QtMainWindow.h>

#include <QtUtilities.h>

namespace Swift{

QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings) : QMainWindow(), settings_(settings) {

uiEventStream_ = uiEventStream;

setWindowTitle("Swift");

#ifndef Q_WS_MAC

setWindowIcon(QIcon(":/logo-icon-16.png"));

#endif

}

}

void QtLoginWindow::setLoginAutomatically(bool loginAutomatically) {

loginAutomatically_->setChecked(loginAutomatically);

}

void QtLoginWindow::handleCertficateChecked(bool checked) {

if (checked) {

}

else {

certificateFile_ = "";

}

}

void QtLoginWindow::handleAbout() {

if (!aboutDialog_) {

aboutDialog_ = new QtAboutWidget();

qt4modules += ["QtDBus"]

myenv.EnableQt4Modules(qt4modules, debug = False)

myenv.Append(CPPPATH = ["."])

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

#myenv["LINKFLAGS"] = ["/SUBSYSTEM:CONSOLE"]

myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])

myenv.Append(LIBS = "qtmain")

myenv.WriteVal("DefaultTheme.qrc", myenv.Value(generateDefaultTheme(myenv.Dir("#/Swift/resources/themes/Default"))))

sources = [

"main.cpp",

"QtAboutWidget.cpp",

"QtAvatarWidget.cpp",

"QtUIFactory.cpp",

"QtChatWindowFactory.cpp",

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

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 += [

"WindowsNotifier.cpp",

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

]

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

sources += [

"FreeDesktopNotifier.cpp",

"QtDBUSURIHandler.cpp",

]

break;

}

session_->setUseAcks(options.useAcks);

stanzaChannel_->setSession(session_);

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

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

session_->start();

}

/**

* Only called for TCP sessions. BOSH is handled inside the BOSHSessionStream.

*/

void CoreClient::handleConnectorFinished(boost::shared_ptr<Connection> connection) {

resetConnector();

if (!connection) {

if (options.forgetPassword) {

purgePassword();

}

onDisconnected(disconnectRequested_ ? boost::optional<ClientError>() : boost::optional<ClientError>(ClientError::ConnectionError));

}

else {

assert(!connection_);

connection_ = connection;

assert(!sessionStream_);

sessionStream_ = boost::make_shared<BasicSessionStream>(ClientStreamType, connection_, getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory());

if (!certificate_.empty()) {

}

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

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

bindSessionToStream();

}

}

void CoreClient::disconnect() {

NetworkFactories* getNetworkFactories() const {

return networkFactories;

}

/**

* Called before onConnected signal is emmitted.

*/

virtual void handleConnected() {};

private:

void handleConnectorFinished(boost::shared_ptr<Connection>);

void handleStanzaChannelAvailableChanged(bool available);

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

void handleNeedCredentials();

void handleDataRead(const SafeByteArray&);

void handleDataWritten(const SafeByteArray&);

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

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

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Session/SessionStream.h>

namespace Swift {

SessionStream::~SessionStream() {

}

};

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Elements/Element.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class SessionStream {

public:

class Error : public Swift::Error {

public:

enum Type {

ConnectionReadError,

ConnectionWriteError

};

Error(Type type) : type(type) {}

Type type;

};

virtual ~SessionStream();

virtual void close() = 0;

virtual bool isOpen() = 0;

virtual void writeHeader(const ProtocolHeader& header) = 0;

virtual void writeFooter() = 0;

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

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

virtual void addZLibCompression() = 0;

virtual bool supportsTLSEncryption() = 0;

virtual void addTLSEncryption() = 0;

virtual bool isTLSEncrypted() = 0;

virtual void setWhitespacePingEnabled(bool enabled) = 0;

virtual void resetXMPPParser() = 0;

certificate = cert;

}

virtual bool hasTLSCertificate() {

}

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;

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

protected:

return certificate;

}

private:

};

}

void TLSLayer::writeData(const SafeByteArray& data) {

context->handleDataFromApplication(data);

}

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

context->handleDataFromNetwork(data);

}

return context->setClientCertificate(certificate);

}

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

return context->getPeerCertificate();

}

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

return context->getPeerCertificateVerificationError();

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/StreamStack/StreamLayer.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class TLSContext;

class TLSContextFactory;

class TLSLayer : public StreamLayer {

public:

TLSLayer(TLSContextFactory*);

~TLSLayer();

void connect();

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;

#include <openssl/pkcs12.h>

#include <boost/smart_ptr/make_shared.hpp>

#if defined(SWIFTEN_PLATFORM_MACOSX) && OPENSSL_VERSION_NUMBER < 0x00908000

#include <Security/Security.h>

#endif

#include <Swiften/TLS/OpenSSL/OpenSSLContext.h>

#include <Swiften/TLS/OpenSSL/OpenSSLCertificate.h>

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

namespace Swift {

static const int MAX_FINISHED_SIZE = 4096;

static const int SSL_READ_BUFFERSIZE = 8192;

void freeX509Stack(STACK_OF(X509)* stack) {

data.resize(SSL_READ_BUFFERSIZE);

ret = SSL_read(handle_, vecptr(data), data.size());

}

if (ret < 0 && SSL_get_error(handle_, ret) != SSL_ERROR_WANT_READ) {

state_ = Error;

onError();

}

}

return false;

}

// Create a PKCS12 structure

BIO* bio = BIO_new(BIO_s_mem());

boost::shared_ptr<PKCS12> pkcs12(d2i_PKCS12_bio(bio, NULL), PKCS12_free);

BIO_free(bio);

if (!pkcs12) {

return false;

}

// Parse PKCS12

X509 *certPtr = 0;

EVP_PKEY* privateKeyPtr = 0;

STACK_OF(X509)* caCertsPtr = 0;

if (result != 1) {

return false;

}

boost::shared_ptr<X509> cert(certPtr, X509_free);

boost::shared_ptr<EVP_PKEY> privateKey(privateKeyPtr, EVP_PKEY_free);

boost::shared_ptr<STACK_OF(X509)> caCerts(caCertsPtr, freeX509Stack);

// Use the key & certificates

if (SSL_CTX_use_certificate(context_, cert.get()) != 1) {

#include <openssl/ssl.h>

#include <Swiften/Base/boost_bsignals.h>

#include <boost/noncopyable.hpp>

#include <Swiften/TLS/TLSContext.h>

#include <Swiften/Base/ByteArray.h>

namespace Swift {

class OpenSSLContext : public TLSContext, boost::noncopyable {

public:

OpenSSLContext();

~OpenSSLContext();

void connect();

void handleDataFromNetwork(const SafeByteArray&);

void handleDataFromApplication(const SafeByteArray&);

Certificate::ref getPeerCertificate() const;

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

virtual ByteArray getFinishMessage() 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/Base/SafeByteArray.h>

namespace Swift {

public:

PKCS12Certificate() {}

PKCS12Certificate(const std::string& filename, const SafeByteArray& password) : password_(password) {

readByteArrayFromFile(data_, filename);

}

return data_.empty();

}

return data_;

}

void setData(const ByteArray& data) {

data_ = data;

}

return password_;

}

private:

ByteArray data_;

SafeByteArray password_;

};

}

namespace Swift {

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

SchannelContext::SchannelContext()

: m_state(Start)

, m_secContext(0)

, m_verificationError(CertificateVerificationError::UnknownError)

{

m_ctxtFlags = ISC_REQ_ALLOCATE_MEMORY |

ISC_REQ_CONFIDENTIALITY |

ISC_REQ_EXTENDED_ERROR |

ISC_REQ_INTEGRITY |

ISC_REQ_REPLAY_DETECT |

ISC_REQ_SEQUENCE_DETECT |

ISC_REQ_USE_SUPPLIED_CREDS |

ISC_REQ_STREAM;

ZeroMemory(&m_streamSizes, sizeof(m_streamSizes));

}

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

void SchannelContext::determineStreamSizes()

{

QueryContextAttributes(m_ctxtHandle, SECPKG_ATTR_STREAM_SIZES, &m_streamSizes);

}

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

void SchannelContext::connect()

{

m_state = Connecting;

// We use an empty list for client certificates

PCCERT_CONTEXT clientCerts[1] = {0};

SCHANNEL_CRED sc = {0};

sc.dwVersion = SCHANNEL_CRED_VERSION;

sc.grbitEnabledProtocols = SP_PROT_SSL3_CLIENT | SP_PROT_TLS1_CLIENT | SP_PROT_TLS1_1_CLIENT | SP_PROT_TLS1_2_CLIENT;

// Swiften performs the server name check for us

sc.dwFlags |= SCH_CRED_NO_SERVERNAME_CHECK;

SECURITY_STATUS status = AcquireCredentialsHandle(

NULL,

UNISP_NAME,

SECPKG_CRED_OUTBOUND,

NULL,

&sc,

NULL,

NULL,

m_credHandle.Reset(),

NULL);

if (status != SEC_E_OK)

{

// We failed to obtain the credentials handle

indicateError();

return;

}

SecBuffer outBuffers[2];

sendDataOnNetwork(&sendBuffer[0], outBuffers[0].cbBuffer + outBuffers[1].cbBuffer + outBuffers[2].cbBuffer);

bytesSent += bytesToSend;

} while (bytesSent < data.size());

}

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

{

return false;

}

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

Certificate::ref SchannelContext::getPeerCertificate() const

{

SchannelCertificate::ref pCertificate;

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

*/

#pragma once

#include "Swiften/Base/boost_bsignals.h"

#include "Swiften/TLS/TLSContext.h"

#include "Swiften/TLS/Schannel/SchannelUtil.h"

#include "Swiften/Base/ByteArray.h"

#define SECURITY_WIN32

#include <Windows.h>

#include <Schannel.h>

#include <security.h>

#include <schnlsp.h>

#include <boost/noncopyable.hpp>

namespace Swift

{

class SchannelContext : public TLSContext, boost::noncopyable

{

public:

typedef boost::shared_ptr<SchannelContext> sp_t;

public:

//

// TLSContext

//

virtual void connect();

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;

CertificateVerificationError m_verificationError;

ULONG m_secContext;

ScopedCredHandle m_credHandle;

ScopedCtxtHandle m_ctxtHandle;

DWORD m_ctxtFlags;

SecPkgContext_StreamSizes m_streamSizes;

std::vector<char> m_receivedData;

};

}

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class TLSContext {

public:

virtual ~TLSContext();

virtual void connect() = 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;