#include <Swiften/StringCodecs/Base64.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

#include <Swift/Controllers/Chat/ChatController.h>

#include <Swift/Controllers/Chat/ChatControllerBase.h>

#include <Swift/Controllers/Chat/ChatMessageParser.h>

#include <Swift/Controllers/Chat/MUCController.h>

#include <Swift/Controllers/Chat/MUCSearchController.h>

roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));

ftOverview_->onNewFileTransferController.disconnect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

delete joinMUCWindow_;

for (JIDChatControllerPair controllerPair : chatControllers_) {

delete controllerPair.second;

}

#include <boost/algorithm/string.hpp>

#include <Swift/Controllers/Intl.h>

#include <Swift/QtUI/QtSwiftUtil.h>

#include <Swiften/Base/Log.h>

namespace Swift {

}

}

/* Call Windows dialog to select a suitable certificate */

delete[] titleChars;

delete[] promptChars;

if (hstore) {

}

return result;

#include <QSplitter>

#include <Swiften/Whiteboard/WhiteboardSession.h>

#include <Swift/Controllers/Settings/SettingsProviderHierachy.h>

this->tabs = dynamic_cast<QtChatTabs*>(tabsBase);

}

XMLConsoleWidget* QtUIFactory::createXMLConsoleWidget() {

QtXMLConsoleWidget* widget = new QtXMLConsoleWidget();

tabsBase->addTab(widget);

Q_OBJECT

public:

QtUIFactory(SettingsProviderHierachy* settings, QtSettingsProvider* qtOnlySettings, QtChatTabsBase* tabs, QtSingleWindow* netbookSplitter, QtSystemTray* systemTray, QtChatWindowFactory* chatWindowFactory, TimerFactory* timerFactory, StatusCache* statusCache, AutoUpdater* autoUpdater, bool startMinimized, bool emoticonsExist, bool enableAdHocCommandOnJID);

virtual XMLConsoleWidget* createXMLConsoleWidget();

virtual HistoryWindow* createHistoryWindow(UIEventStream*);

virtual MainWindow* createMainWindow(UIEventStream* eventStream);

#include <Swiften/Base/Log.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/StringCodecs/Hexify.h>

// Size of the SHA1 hash

#define SHA1_HASH_LEN 20

}

CAPICertificate::~CAPICertificate() {

if (smartCardTimer_) {

smartCardTimer_->stop();

smartCardTimer_->onTick.disconnect(boost::bind(&CAPICertificate::handleSmartCardTimerTick, this));

}

if (certStoreHandle_) {

}

if (cardHandle_) {

return smartCardReaderName_;

}

if (!boost::iequals(certName.substr(0, 5), "sha1:")) {

// Find client certificate. Note that this sample just searches for a

}

valid_ = false;

/* Syntax: "certstore:" <cert_store> ":" <hash> ":" <hash_of_cert> */

/* Substring of subject: uses "storename" */

std::string capiIdentity = capiUri.substr(10);

std::string newCertStoreName;

if (pos == std::string::npos) {

/* Using the default certificate store */

certStore_ = newCertStoreName;

if (!certContext) {

return;

}

/* Now verify that we can have access to the corresponding private key */

DWORD len;

if (!CertGetCertificateContextProperty(certContext,

CERT_KEY_PROV_INFO_PROP_ID,

NULL,

&len)) {

return;

}

if (!pinfo) {

return;

}

return;

}

// Now verify if we have access to the private key

if (!CryptAcquireContextW(&hprov, pinfo->pwszContainerName, pinfo->pwszProvName, pinfo->dwProvType, 0)) {

return;

}

char smartCardReader[1024];

DWORD bufferLength = sizeof(smartCardReader);

if (!CryptGetProvParam(hprov, PP_SMARTCARD_READER, (BYTE *)&smartCardReader, &bufferLength, 0)) {

smartCardTimer_ = timerFactory_->createTimer(SMARTCARD_EJECTION_CHECK_FREQUENCY_MILLISECONDS);

}

else {

}

}

if (!CryptGetUserKey(hprov, pinfo->dwKeySpec, &key)) {

CryptReleaseContext(hprov, 0);

return;

}

CryptDestroyKey(key);

CryptReleaseContext(hprov, 0);

if (smartCardTimer_) {

smartCardTimer_->onTick.connect(boost::bind(&CAPICertificate::handleSmartCardTimerTick, this));

valid_ = true;

}

const char* pReader,

SCARDHANDLE hCardHandle, /* Can be 0 on the first call */

SCARDHANDLE* newCardHandle, /* The handle returned */

}

}

if (!smartCardReaderName_.empty()) {

DWORD dwState;

smartcard_check_status(scardContext_, smartCardReaderName_.c_str(), cardHandle_, &cardHandle_, &dwState);

break;

}

switch (dwState) {

case SCARD_ABSENT:

return false;

void CAPICertificate::handleSmartCardTimerTick() {

bool poll = checkIfSmartCardPresent();

if (lastPollingResult_ && !poll) {

onCertificateCardRemoved();

}

lastPollingResult_ = poll;

#include <WinHTTP.h> /* For SECURITY_FLAG_IGNORE_CERT_CN_INVALID */

#include <Swiften/TLS/CAPICertificate.h>

#include <Swiften/TLS/Schannel/SchannelCertificate.h>

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

SchannelContext::~SchannelContext() {

}

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

void SchannelContext::determineStreamSizes() {

}

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

SecBuffer inBuffers[2];

// Provide Schannel with the remote host's handshake data

inBuffers[0].BufferType = SECBUFFER_TOKEN;

inBuffers[1].pvBuffer = NULL;

// contexts. Additionally, a second SECBUFFER_TOKEN type buffer that contains a security token

// must also be supplied.

//

inBuffers[0].BufferType = SECBUFFER_DATA;

inBuffers[1].BufferType = SECBUFFER_EMPTY;

outBuffers[0].BufferType = SECBUFFER_STREAM_HEADER;

outBuffers[1].pvBuffer = &sendBuffer[0] + streamSizes_.cbHeader;

outBuffers[1].BufferType = SECBUFFER_DATA;

outBuffers[2].pvBuffer = &sendBuffer[0] + streamSizes_.cbHeader + bytesToSend;

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

if (status != SEC_E_OK) {

return certificateChain;

}

certificateChain.push_back(std::make_shared<SchannelCertificate>(pServerCert));

if (ret == SEC_E_OK) {

return createByteArray(((unsigned char*) bindings.Bindings) + bindings.Bindings->dwApplicationDataOffset + 11 /* tls-unique:*/, bindings.Bindings->cbApplicationDataLength - 11);

}

return ByteArray();

}