/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

boost::optional<std::string> newHash = getCombinedAvatarAndCache(jid);

if (newHash != oldHash) {

onAvatarChanged(jid);

}

}

boost::optional<std::string> CombinedAvatarProvider::getCombinedAvatarAndCache(const JID& jid) const {

boost::optional<std::string> hash;

for (size_t i = 0; i < providers.size() && !hash; ++i) {

hash = providers[i]->getAvatarHash(jid);

}

if (hash) {

avatars[jid] = *hash;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

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

if (update->getPhotoHash().size() != 40) {

return;

}

if (getAvatarHash(from) == update->getPhotoHash()) {

return;

}

if (avatarStorage_->hasAvatar(update->getPhotoHash())) {

setAvatarHash(from, update->getPhotoHash());

}

void VCardUpdateAvatarManager::handleVCardChanged(const JID& from, VCard::ref vCard) {

if (!vCard) {

return;

}

}

void VCardUpdateAvatarManager::setAvatarHash(const JID& from, const std::string& hash) {

avatarHashes_[from] = hash;

onAvatarChanged(from);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

localString = boost::posix_time::to_simple_string(boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local(time));

}

catch(std::out_of_range& exception) {

}

return localString;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

if (logCallback) {

logCallback(severity_, std::move(file_), line_, std::move(function_), stream.str());

}

else {

}

#endif

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

authenticationPort(-1) {

#ifdef SWIFTEN_PLATFORM_WIN32

if (WindowsRegistry::isFIPSEnabled()) {

}

#endif

}

finishSession(std::shared_ptr<Error>());

}

else {

}

}

error_ = error;

}

else {

}

assert(stream->isOpen());

if (stanzaAckResponder_) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void ClientSessionStanzaChannel::send(std::shared_ptr<Stanza> stanza) {

if (!isAvailable()) {

return;

}

session->sendStanza(stanza);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

HostAddressPort systemHTTPConnectProxy = networkFactories->getProxyProvider()->getHTTPConnectProxy();

switch (o.proxyType) {

case ClientOptions::NoProxy:

break;

case ClientOptions::SystemConfiguredProxy:

if (systemSOCKS5Proxy.isValid()) {

proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), systemSOCKS5Proxy.getAddress().toString(), systemSOCKS5Proxy.getPort()));

}

if (systemHTTPConnectProxy.isValid()) {

proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), systemHTTPConnectProxy.getAddress().toString(), systemHTTPConnectProxy.getPort()));

}

break;

case ClientOptions::SOCKS5Proxy: {

std::string proxyHostname = o.manualProxyHostname.empty() ? systemSOCKS5Proxy.getAddress().toString() : o.manualProxyHostname;

auto proxyPort = systemSOCKS5Proxy.getPort();

if (o.manualProxyPort != -1) {

proxyPort = boost::numeric_cast<unsigned short>(o.manualProxyPort);

}

catch (const boost::numeric::bad_numeric_cast& e) {

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

return;

}

}

proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), proxyHostname, proxyPort));

useDirectConnection = false;

break;

}

case ClientOptions::HTTPConnectProxy: {

std::string proxyHostname = o.manualProxyHostname.empty() ? systemHTTPConnectProxy.getAddress().toString() : o.manualProxyHostname;

unsigned short proxyPort = systemHTTPConnectProxy.getPort();

if (o.manualProxyPort != -1) {

proxyPort = boost::numeric_cast<unsigned short>(o.manualProxyPort);

}

catch (const boost::numeric::bad_numeric_cast& e) {

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

return;

}

}

proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), proxyHostname, proxyPort, o.httpTrafficFilter));

useDirectConnection = false;

break;

port = boost::numeric_cast<unsigned short>(o.manualPort);

}

catch (const boost::numeric::bad_numeric_cast& e) {

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

return;

}

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

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

if (certificate_ && !certificate_->isNull()) {

sessionStream_->setTLSCertificate(certificate_);

}

boshSessionStream_->open();

void CoreClient::sendData(const std::string& data) {

if (!sessionStream_) {

return;

}

sessionStream_->writeData(data);

void CoreClient::forceReset() {

if (connector_) {

resetConnector();

}

if (sessionStream_ || connection_) {

resetSession();

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void ComponentSessionStanzaChannel::send(std::shared_ptr<Stanza> stanza) {

if (!isAvailable()) {

return;

}

session->sendStanza(stanza);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

CoreComponent::~CoreComponent() {

if (session_ || connection_) {

}

delete iqRouter_;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

requestedDiscoInfos.erase(hash);

if (error || !discoInfo || CapsInfoGenerator("", crypto).generateCapsInfo(*discoInfo.get()).getVersion() != hash) {

if (warnOnInvalidHash && !error && discoInfo) {

}

failingCaps.insert(std::make_pair(from, hash));

std::map<std::string, std::set< std::pair<JID, std::string> > >::iterator i = fallbacks.find(hash);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void DiscoServiceWalker::beginWalk() {

assert(!active_);

assert(servicesBeingSearched_.empty());

active_ = true;

void DiscoServiceWalker::endWalk() {

if (active_) {

for (auto&& request : pendingDiscoInfoRequests_) {

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoInfoResponse, this, _1, _2, request));

}

}

void DiscoServiceWalker::walkNode(const JID& jid) {

servicesBeingSearched_.insert(jid);

searchedServices_.insert(jid);

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(jid, iqRouter_);

return;

}

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoInfoResponse, this, _1, _2, request));

pendingDiscoInfoRequests_.erase(request);

return;

}

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoItemsResponse, this, _1, _2, request));

pendingDiscoItemsRequests_.erase(request);

if (error) {

* but I've never seen one in the wild, and it's an easy fix for not looping.

*/

if (std::find(searchedServices_.begin(), searchedServices_.end(), item.getJID()) == searchedServices_.end()) { /* Don't recurse infinitely */

walkNode(item.getJID());

}

}

}

void DiscoServiceWalker::handleDiscoError(const JID& jid, ErrorPayload::ref /*error*/) {

markNodeCompleted(jid);

}

void DiscoServiceWalker::markNodeCompleted(const JID& jid) {

servicesBeingSearched_.erase(jid);

/* All results are in */

if (servicesBeingSearched_.empty()) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

file.close();

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

}

}

catch (const boost::filesystem::filesystem_error& e) {

}

return std::shared_ptr<Payload>();

}

DummyEventLoop::~DummyEventLoop() {

if (hasEvents()) {

}

}

event.callback();

}

catch (const std::exception& e) {

}

catch (...) {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

incomingFileTransfers.push_back(transfer);

std::shared_ptr<FileWriteBytestream> out = std::make_shared<FileWriteBytestream>("out");

transfer->onFinished.connect(boost::bind(&FileReceiver::handleFileTransferFinished, this, _1, out));

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void DefaultFileTransferTransporter::startActivatingProxy(const JID& proxyServiceJID) {

// activate proxy

S5BProxyRequest::ref proxyRequest = std::make_shared<S5BProxyRequest>();

proxyRequest->setSID(s5bSessionID);

proxyRequest->setActivate(role == Initiator ? responder : initiator);

transportSession = std::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(proxySession, stream);

}

else {

}

}

transportSession = std::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(proxySession, stream);

}

else {

}

}

std::string result;

if (role == Initiator) {

result = getInitiatorCandidateSOCKS5DstAddr();

}

else {

result = getResponderCandidateSOCKS5DstAddr();

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void FailingTransportSession::start() {

onFinished(FileTransferError(FileTransferError::PeerError));

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

}

else {

}

return outgoingFTManager->createOutgoingFileTransfer(iqRouter->getJID(), receipient, bytestream, fileInfo, options);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void IncomingJingleFileTransfer::accept(

std::shared_ptr<WriteBytestream> stream,

const FileTransferOptions& options) {

assert(!this->stream);

this->stream = stream;

JingleS5BTransportPayload::ref s5bTransport = initialContent->getTransport<JingleS5BTransportPayload>();

JingleIBBTransportPayload::ref ibbTransport = initialContent->getTransport<JingleIBBTransportPayload>();

if (s5bTransport) {

setTransporter(transporterFactory->createResponderTransporter(

getInitiator(), getResponder(), s5bTransport->getSessionID(), options));

transporter->addRemoteCandidates(s5bTransport->getCandidates(), s5bTransport->getDstAddr());

transporter->startGeneratingLocalCandidates();

}

else if (ibbTransport && options.isInBandAllowed()) {

setTransporter(transporterFactory->createResponderTransporter(

getInitiator(), getResponder(), ibbTransport->getSessionID(), options));

}

void IncomingJingleFileTransfer::cancel() {

terminate(state == Initial ? JinglePayload::Reason::Decline : JinglePayload::Reason::Cancel);

}

const std::string& s5bSessionID,

const std::vector<JingleS5BTransportPayload::Candidate>& candidates,

const std::string& dstAddr) {

fillCandidateMap(localCandidates, candidates);

void IncomingJingleFileTransfer::handleSessionInfoReceived(JinglePayload::ref jinglePayload) {

JingleFileTransferHash::ref transferHash = jinglePayload->getPayload<JingleFileTransferHash>();

if (transferHash) {

waitOnHashTimer->stop();

if (transferHash->getFileInfo().getHashes().find("sha-1") != transferHash->getFileInfo().getHashes().end()) {

hashes["sha-1"] = transferHash->getFileInfo().getHash("sha-1").get();

}

}

else {

}

}

void IncomingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {

if (state == Finished) {

return;

}

terminate(JinglePayload::Reason::Success);

}

else {

terminate(JinglePayload::Reason::MediaError);

}

}

void IncomingJingleFileTransfer::checkIfAllDataReceived() {

if (receivedBytes == getFileSizeInBytes()) {

bool hashInfoAvailable = false;

for (const auto& hashElement : hashes) {

hashInfoAvailable |= !hashElement.second.empty();

}

if (!hashInfoAvailable) {

setState(WaitingForHash);

waitOnHashTimer->start();

}

}

}

else if (receivedBytes > getFileSizeInBytes()) {

terminate(JinglePayload::Reason::MediaError);

}

}

void IncomingJingleFileTransfer::handleTransportReplaceReceived(

const JingleContentID& content, JingleTransportPayload::ref transport) {

if (state != WaitingForFallbackOrTerminate) {

return;

}

JingleIBBTransportPayload::ref ibbTransport;

if (options.isInBandAllowed() && (ibbTransport = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport))) {

startTransferring(transporter->createIBBReceiveSession(

ibbTransport->getSessionID(),

session->sendTransportAccept(content, ibbTransport);

}

else {

session->sendTransportReject(content, transport);

}

}

bool IncomingJingleFileTransfer::verifyData() {

if (hashes.empty()) {

return true;

}

if (hashes.find("sha-1") != hashes.end()) {

return hashes["sha-1"] == hashCalculator->getSHA1Hash();

}

else if (hashes.find("md5") != hashes.end()) {

return hashes["md5"] == hashCalculator->getMD5Hash();

}

else {

return true;

}

}

void IncomingJingleFileTransfer::handleWaitOnHashTimerTicked() {

waitOnHashTimer->stop();

terminate(JinglePayload::Reason::Success);

}

}

void IncomingJingleFileTransfer::setState(State state) {

this->state = state;

onStateChanged(FileTransfer::State(getExternalState(state)));

}

void IncomingJingleFileTransfer::setFinishedState(

FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {

this->state = Finished;

onStateChanged(type);

onFinished(error);

transportSession->stop();

transportSession.reset();

break;

}

if (state != Initial) {

removeTransporter();

}

void IncomingJingleFileTransfer::startTransferViaRemoteCandidate() {

if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

setState(WaitingForPeerProxyActivate);

}

void IncomingJingleFileTransfer::startTransferViaLocalCandidate() {

if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

setState(WaitingForLocalProxyActivate);

}

void IncomingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {

this->transportSession = transportSession;

transferFinishedConnection = transportSession->onFinished.connect(

}

void IncomingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {

if (state != Finished) {

session->sendTerminate(reason);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void JingleFileTransfer::handleRemoteTransportCandidateSelectFinished(

const std::string& s5bSessionID, const boost::optional<JingleS5BTransportPayload::Candidate>& candidate) {

ourCandidateChoice = candidate;

ourCandidateSelectFinished = true;

// decide on candidates according to http://xmpp.org/extensions/xep-0260.html#complete

void JingleFileTransfer::decideOnCandidates() {

if (!ourCandidateSelectFinished || !theirCandidateSelectFinished) {

return;

}

if (!ourCandidateChoice && !theirCandidateChoice) {

fallback();

}

else if (ourCandidateChoice && !theirCandidateChoice) {

startTransferViaRemoteCandidate();

}

else if (theirCandidateChoice && !ourCandidateChoice) {

startTransferViaLocalCandidate();

}

else {

SWIFT_LOG(debug) << "Choosing between candidates "

<< ourCandidateChoice->cid << "(" << ourCandidateChoice->priority << ")" << " and "

if (ourCandidateChoice->priority > theirCandidateChoice->priority) {

startTransferViaRemoteCandidate();

}

else if (ourCandidateChoice->priority < theirCandidateChoice->priority) {

startTransferViaLocalCandidate();

}

else {

if (hasPriorityOnCandidateTie()) {

startTransferViaRemoteCandidate();

}

else {

startTransferViaLocalCandidate();

}

}

void JingleFileTransfer::handleProxyActivateFinished(

const std::string& s5bSessionID, ErrorPayload::ref error) {

if (error) {

JingleS5BTransportPayload::ref proxyError = std::make_shared<JingleS5BTransportPayload>();

proxyError->setSessionID(s5bSessionID);

proxyError->setProxyError(true);

void JingleFileTransfer::handleTransportInfoReceived(

const JingleContentID& /* contentID */, JingleTransportPayload::ref transport) {

if (JingleS5BTransportPayload::ref s5bPayload = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transport)) {

if (s5bPayload->hasCandidateError() || !s5bPayload->getCandidateUsed().empty()) {

theirCandidateSelectFinished = true;

if (!s5bPayload->hasCandidateError()) {

auto theirCandidate = localCandidates.find(s5bPayload->getCandidateUsed());

if (theirCandidate == localCandidates.end()) {

terminate(JinglePayload::Reason::GeneralError);

return;

}

decideOnCandidates();

}

else if (!s5bPayload->getActivated().empty()) {

if (ourCandidateChoice->cid == s5bPayload->getActivated()) {

startTransferring(createRemoteCandidateSession());

}

else {

terminate(JinglePayload::Reason::GeneralError);

}

}

else if (s5bPayload->hasProxyError()) {

fallback();

}

else {

}

}

else {

}

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

LocalJingleTransportCandidateGenerator::~LocalJingleTransportCandidateGenerator() {

}

void LocalJingleTransportCandidateGenerator::start() {

}

}

else {

if (s5bServerResourceUser_) {

s5bServerResourceUser_->onSuccessfulInitialized.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleS5BServerInitialized, this, _1));

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void OutgoingJingleFileTransfer::start() {

if (state != Initial) {

return;

}

}

void OutgoingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {

if (state != Initial && state != GeneratingInitialLocalCandidates && state != Finished) {

session->sendTerminate(reason);

const JingleContentID&,

JingleDescription::ref,

JingleTransportPayload::ref transportPayload) {

if (JingleS5BTransportPayload::ref s5bPayload = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload)) {

transporter->addRemoteCandidates(s5bPayload->getCandidates(), s5bPayload->getDstAddr());

startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));

}

else {

fallback();

}

}

void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {

stopAll();

if (state == WaitForTermination) {

}

void OutgoingJingleFileTransfer::handleTransportAcceptReceived(const JingleContentID&, JingleTransportPayload::ref transport) {

if (JingleIBBTransportPayload::ref ibbPayload = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport)) {

startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));

}

else {

terminate(JinglePayload::Reason::FailedTransport);

}

}

void OutgoingJingleFileTransfer::handleTransportRejectReceived(const JingleContentID &, std::shared_ptr<JingleTransportPayload>) {

terminate(JinglePayload::Reason::UnsupportedTransports);

}

void OutgoingJingleFileTransfer::sendSessionInfoHash() {

JingleFileTransferHash::ref hashElement = std::make_shared<JingleFileTransferHash>();

hashElement->getFileInfo().addHash(HashElement("sha-1", hashCalculator->getSHA1Hash()));

void OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated(

const std::string& s5bSessionID, const std::vector<JingleS5BTransportPayload::Candidate>& candidates, const std::string& dstAddr) {

fillCandidateMap(localCandidates, candidates);

JingleTransportPayload::ref transport;

if (candidates.empty()) {

JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();

ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);

ibbTransport->setSessionID(idGenerator->generateID());

s5bTransport->setDstAddr(dstAddr);

for (auto&& candidate : candidates) {

s5bTransport->addCandidate(candidate);

}

transport = s5bTransport;

}

void OutgoingJingleFileTransfer::fallback() {

if (options.isInBandAllowed()) {

JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();

ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);

ibbTransport->setSessionID(idGenerator->generateID());

session->sendTransportReplace(contentID, ibbTransport);

}

else {

terminate(JinglePayload::Reason::ConnectivityError);

}

}

void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {

if (error) {

terminate(JinglePayload::Reason::ConnectivityError);

}

void OutgoingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {

this->transportSession = transportSession;

processedBytesConnection = transportSession->onBytesSent.connect(

void OutgoingJingleFileTransfer::setInternalState(State state) {

this->state = state;

setState(FileTransfer::State(getExternalState(state)));

}

void OutgoingJingleFileTransfer::setFinishedState(

FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {

this->state = Finished;

onStateChanged(type);

onFinished(error);

}

void OutgoingJingleFileTransfer::stopAll() {

switch (state) {

case GeneratingInitialLocalCandidates: transporter->stopGeneratingLocalCandidates(); break;

case WaitingForAccept: break;

case TryingCandidates: transporter->stopTryingRemoteCandidates(); break;

break;

case WaitForTermination:

break;

}

if (state != Initial) {

removeTransporter();

}

void OutgoingJingleFileTransfer::startTransferViaRemoteCandidate() {

if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

setInternalState(WaitingForPeerProxyActivate);

}

void OutgoingJingleFileTransfer::startTransferViaLocalCandidate() {

if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

setInternalState(WaitingForLocalProxyActivate);

void OutgoingJingleFileTransfer::handleWaitForRemoteTerminationTimeout() {

assert(state == WaitForTermination);

waitForRemoteTermination->stop();

terminate(JinglePayload::Reason::MediaError);

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void RemoteJingleTransportCandidateSelector::tryNextCandidate() {

if (candidates.empty()) {

onCandidateSelectFinished(

boost::optional<JingleS5BTransportPayload::Candidate>(), std::shared_ptr<SOCKS5BytestreamClientSession>());

}

else {

lastCandidate = candidates.top();

candidates.pop();

if ((lastCandidate.type == JingleS5BTransportPayload::Candidate::DirectType && options.isDirectAllowed()) ||

(lastCandidate.type == JingleS5BTransportPayload::Candidate::AssistedType && options.isAssistedAllowed()) ||

(lastCandidate.type == JingleS5BTransportPayload::Candidate::ProxyType && options.isProxiedAllowed())) {

s5bSession->start();

}

else {

tryNextCandidate();

}

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void SOCKS5BytestreamClientSession::start() {

assert(state == Initial);

weFailedTimeout->start();

connectFinishedConnection = connection->onConnectFinished.connect(

boost::bind(&SOCKS5BytestreamClientSession::handleConnectFinished, this, _1));

}

void SOCKS5BytestreamClientSession::stop() {

if (state < Ready) {

weFailedTimeout->stop();

}

}

void SOCKS5BytestreamClientSession::process() {

ByteArray bndAddress;

switch(state) {

case Initial:

}

unprocessedData.clear();

state = Ready;

// issue ready signal so the bytestream can be used for reading or writing

weFailedTimeout->stop();

onSessionReady(false);

break;

case Ready:

break;

case Reading:

case Writing:

case Finished:

unprocessedData.clear();

//assert(false);

}

}

void SOCKS5BytestreamClientSession::authenticate() {

SafeByteArray header = createSafeByteArray("\x05\x01\x00\x03", 4);

SafeByteArray message = header;

append(message, createSafeByteArray(boost::numeric_cast<char>(destination.size())));

writeBytestream->write(unprocessedData);

unprocessedData.clear();

} else {

}

}

boost::bind(&SOCKS5BytestreamClientSession::sendData, this));

sendData();

} else {

}

}

}

void SOCKS5BytestreamClientSession::finish(bool error) {

if (state < Ready) {

weFailedTimeout->stop();

}

void SOCKS5BytestreamClientSession::handleConnectFinished(bool error) {

connectFinishedConnection.disconnect();

if (error) {

finish(true);

} else {

disconnectedConnection = connection->onDisconnected.connect(

boost::bind(&SOCKS5BytestreamClientSession::handleDisconnected, this, _1));

dataReadConnection = connection->onDataRead.connect(

}

void SOCKS5BytestreamClientSession::handleDataRead(std::shared_ptr<SafeByteArray> data) {

if (state != Reading) {

append(unprocessedData, *data);

process();

}

void SOCKS5BytestreamClientSession::handleDisconnected(const boost::optional<Connection::Error>& error) {

if (error) {

finish(true);

}

}

void SOCKS5BytestreamClientSession::handleWeFailedTimeout() {

finish(true);

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void SOCKS5BytestreamProxiesManager::addS5BProxy(S5BProxyRequest::ref proxy) {

if (proxy) {

if (!localS5BProxies_) {

localS5BProxies_ = std::vector<S5BProxyRequest::ref>();

}

}

void SOCKS5BytestreamProxiesManager::connectToProxies(const std::string& sessionID) {

ProxyJIDClientSessionVector clientSessions;

if (localS5BProxies_) {

if (proxyHostAddress) {

std::shared_ptr<Connection> conn = connectionFactory_->createConnection();

HostAddressPort addressPort = HostAddressPort(proxyHostAddress.get(), proxy->getStreamHost().get().port);

std::shared_ptr<SOCKS5BytestreamClientSession> session = std::make_shared<SOCKS5BytestreamClientSession>(conn, addressPort, sessionID, timerFactory_);

JID proxyJid = proxy->getStreamHost().get().jid;

clientSessions.push_back(std::pair<JID, std::shared_ptr<SOCKS5BytestreamClientSession> >(proxyJid, session));

i->second->stop();

}

}

proxySessions_.erase(sessionID);

}

else {

if (addresses.empty()) {

}

else {

// generate proxy per returned address

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

requester->onResponse.disconnect(boost::bind(&SOCKS5BytestreamProxyFinder::handleProxyResponse, this, requester, _1, _2));

pendingRequests.erase(requester);

if (error) {

} else {

if (request) {

proxyHosts.push_back(request);

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

SOCKS5BytestreamServerManager::~SOCKS5BytestreamServerManager() {

if (portMapping && !unforwardPortRequest) {

unforwardPortRequest = natTraverser->createRemovePortForwardingRequest(portMapping.get().getLocalPort(), portMapping.get().getPublicPort());

unforwardPortRequest->start();

}

assert(!connectionServer);

unsigned short port;

for (port = LISTEN_PORTS_BEGIN; port < LISTEN_PORTS_END; ++port) {

connectionServer = connectionServerFactory->createConnectionServer(HostAddress::fromString("::").get(), port);

boost::optional<ConnectionServer::Error> error = connectionServer->tryStart();

if (!error) {

break;

}

else if (*error != ConnectionServer::Conflict) {

onInitialized(false);

return;

}

connectionServer.reset();

}

if (!connectionServer) {

onInitialized(false);

return;

}

connectionServerPort = port;

// Start bytestream server. Should actually happen before the connectionserver is started

void SOCKS5BytestreamServerManager::handleGetPublicIPResult(boost::optional<HostAddress> address) {

if (address) {

}

else {

}

publicAddress = address;

void SOCKS5BytestreamServerManager::handleForwardPortResult(boost::optional<NATPortMapping> mapping) {

if (mapping) {

}

else {

}

portMapping = mapping;

portMapping.reset();

}

else {

}

attemptedPortMapping_ = false;

unforwardPortRequest.reset();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

SOCKS5BytestreamServerSession::~SOCKS5BytestreamServerSession() {

if (state != Finished && state != Initial) {

finish();

}

}

void SOCKS5BytestreamServerSession::start() {

dataReadConnection = connection->onDataRead.connect(

boost::bind(&SOCKS5BytestreamServerSession::handleDataRead, this, _1));

state = WaitingForAuthentication;

}

void SOCKS5BytestreamServerSession::startSending(std::shared_ptr<ReadBytestream> stream) {

readBytestream = stream;

state = WritingData;

}

void SOCKS5BytestreamServerSession::startReceiving(std::shared_ptr<WriteBytestream> stream) {

writeBytestream = stream;

state = ReadingData;

}

void SOCKS5BytestreamServerSession::handleDisconnected(const boost::optional<Connection::Error>& error) {

finish(error ? boost::optional<FileTransferError>(FileTransferError::PeerError) : boost::optional<FileTransferError>());

}

if (i == 2 + authCount) {

// Authentication message is complete

if (i != unprocessedData.size()) {

}

unprocessedData.clear();

connection->write(createSafeByteArray("\x05\x00", 2));

i += 2;

if (i <= unprocessedData.size()) {

if (i != unprocessedData.size()) {

}

unprocessedData.clear();

streamID = byteArrayToString(requestID);

result.push_back(boost::numeric_cast<unsigned char>(requestID.size()));

}

catch (const boost::numeric::bad_numeric_cast& e) {

finish();

return;

}

append(result, concat(requestID, createByteArray("\x00\x00", 2)));

if (!hasBytestream) {

connection->write(result);

finish(boost::optional<FileTransferError>(FileTransferError::PeerError));

}

else {

connection->write(result);

state = ReadyForTransfer;

}

}

void SOCKS5BytestreamServerSession::finish(const boost::optional<FileTransferError>& error) {

if (state == Finished) {

return;

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

std::shared_ptr<SafeByteArray> dataToSend;

//ByteArray failingData = Hexify::unhexify("8417947d1d305c72c11520ea7d2c6e787396705e72c312c6ccc3f66613d7cae1b91b7ab48e8b59a17d559c15fb51");

//append(dataToSend, failingData);

do {

ByteArray rndArray = generateRandomByteArray(correctData->size());

dataToSend = createSafeByteArrayRef(vecptr(rndArray), rndArray.size());

void handleConnectionDataWritten(const SafeByteArray& data) {

append(unprocessedInput, data);

}

void handleSessionReady(bool error) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

using namespace Swift;

void AbstractJingleSessionListener::handleSessionAcceptReceived(const JingleContentID&, std::shared_ptr<JingleDescription>, std::shared_ptr<JingleTransportPayload>) {

}

void AbstractJingleSessionListener::handleSessionInfoReceived(std::shared_ptr<JinglePayload>) {

}

void AbstractJingleSessionListener::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason>) {

}

void AbstractJingleSessionListener::handleTransportAcceptReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>) {

}

void AbstractJingleSessionListener::handleTransportInfoReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>) {

}

void AbstractJingleSessionListener::handleTransportRejectReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>) {

}

void AbstractJingleSessionListener::handleTransportReplaceReceived(const JingleContentID&, std::shared_ptr<JingleTransportPayload>) {

}

void AbstractJingleSessionListener::handleTransportInfoAcknowledged(const std::string&) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

JingleSessionImpl::ref session = std::make_shared<JingleSessionImpl>(payload->getInitiator(), from, payload->getSessionID(), router);

sessionManager->handleIncomingSession(from, to, session, payload->getContents());

} else {

}

}

}

else {

JingleSessionImpl::ref session;

if (payload->getInitiator().isValid()) {

session = sessionManager->getSession(payload->getInitiator(), payload->getSessionID());

} else {

session = sessionManager->getSession(from, payload->getSessionID());

}

if (session) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

JingleSessionImpl::JingleSessionImpl(const JID& initiator, const JID& peerJID, const std::string& id, IQRouter* router) : JingleSession(initiator, id), iqRouter(router), peerJID(peerJID) {

}

void JingleSessionImpl::handleIncomingAction(JinglePayload::ref action) {

JingleContentPayload::ref content = action->getPayload<JingleContentPayload>();

if (!content) {

return;

}

JingleContentID contentID(content->getName(), content->getCreator());

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void JingleSessionManager::registerOutgoingSession(const JID& initiator, JingleSessionImpl::ref session) {

sessions.insert(std::make_pair(JIDSession(initiator, session->getID()), session));

}

void JingleSessionManager::handleIncomingSession(const JID& initiator, const JID& recipient, JingleSessionImpl::ref session, const std::vector<JingleContentPayload::ref>& contents) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

namespace Swift {

AvahiResolveHostnameQuery::AvahiResolveHostnameQuery(const std::string& hostname, int, std::shared_ptr<AvahiQuerier> querier, EventLoop* eventLoop) : AvahiQuery(querier, eventLoop), hostname(hostname) {

}

void AvahiResolveHostnameQuery::run() {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

recordSize = boost::numeric_cast<unsigned short>(txtRecord.size());

}

catch (const boost::numeric::bad_numeric_cast&) {

return;

}

DNSServiceErrorType result = DNSServiceRegister(

recordSize, vecptr(txtRecord),

&BonjourRegisterQuery::handleServiceRegisteredStatic, this);

if (result != kDNSServiceErr_NoError) {

sdRef = nullptr;

}

}

DNSServiceUpdateRecord(sdRef, nullptr, 0, boost::numeric_cast<unsigned short>(txtRecord.size()), vecptr(txtRecord), 0);

}

catch (const boost::numeric::bad_numeric_cast&) {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

return result;

}

catch (const std::exception& e) {

return boost::none;

}

}

}

void BOSHConnection::handleTLSConnected() {

onConnectFinished(false);

}

void BOSHConnection::handleTLSApplicationDataRead(const SafeByteArray& data) {

handleDataRead(std::make_shared<SafeByteArray>(data));

}

void BOSHConnection::handleTLSNetowrkDataWriteRequest(const SafeByteArray& data) {

connection_->write(data);

}

void BOSHConnection::handleRawDataRead(std::shared_ptr<SafeByteArray> data) {

tlsLayer_->handleDataRead(*data.get());

}

void BOSHConnection::handleTLSError(std::shared_ptr<TLSError> error) {

}

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

bool BOSHConnection::setClientCertificate(CertificateWithKey::ref cert) {

if (tlsLayer_) {

return tlsLayer_->setClientCertificate(cert);

}

else {

writeData(safeHeader);

pending_ = true;

}

void BOSHConnection::handleConnectFinished(Connection::ref connection) {

SafeByteArray safeHeader = createSafeByteArray(header.str());

onBOSHDataWritten(safeHeader);

writeData(safeHeader);

}

void BOSHConnection::handleDataRead(std::shared_ptr<SafeByteArray> data) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

if (boshURL.getScheme() == "https") {

bool success = connection->setClientCertificate(clientCertificate);

}

connection->connect();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void BoostConnection::handleConnectFinished(const boost::system::error_code& error) {

if (!error) {

eventLoop->postEvent(boost::bind(boost::ref(onConnectFinished), false), shared_from_this());

doRead();

}

void BoostConnection::handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred) {

if (!error) {

readBuffer_->resize(bytesTransferred);

eventLoop->postEvent(boost::bind(boost::ref(onDataRead), readBuffer_), shared_from_this());

}

void BoostConnection::handleDataWritten(const boost::system::error_code& error) {

if (!error) {

eventLoop->postEvent(boost::ref(onDataWritten), shared_from_this());

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

if (endpoint.protocol() == boost::asio::ip::tcp::v6()) {

boost::system::error_code ec;

acceptor_->set_option(boost::asio::ip::v6_only(false), ec);

}

acceptNextConnection();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void ChainedConnector::start() {

connectionFactoryQueue = std::deque<ConnectionFactory*>(connectionFactories.begin(), connectionFactories.end());

tryNextConnectionFactory();

void ChainedConnector::tryNextConnectionFactory() {

assert(!currentConnector);

if (connectionFactoryQueue.empty()) {

finish(std::shared_ptr<Connection>(), lastError);

}

else {

ConnectionFactory* connectionFactory = connectionFactoryQueue.front();

connectionFactoryQueue.pop_front();

currentConnector = Connector::create(hostname, port, serviceLookupPrefix, resolver, connectionFactory, timerFactory);

currentConnector->setTimeoutMilliseconds(timeoutMilliseconds);

}

void ChainedConnector::handleConnectorFinished(std::shared_ptr<Connection> connection, std::shared_ptr<Error> error) {

currentConnector->onConnectFinished.disconnect(boost::bind(&ChainedConnector::handleConnectorFinished, this, _1, _2));

lastError = error;

currentConnector.reset();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void Connector::start() {

assert(!currentConnection);

assert(!serviceQuery);

assert(!timer);

}

void Connector::handleServiceQueryResult(const std::vector<DomainNameServiceQuery::Result>& result) {

serviceQueryResults = std::deque<DomainNameServiceQuery::Result>(result.begin(), result.end());

serviceQuery.reset();

if (!serviceQueryResults.empty()) {

void Connector::tryNextServiceOrFallback() {

if (queriedAllServices) {

finish(std::shared_ptr<Connection>());

}

else if (serviceQueryResults.empty()) {

// Fall back on simple address resolving

queriedAllServices = true;

queryAddress(hostname);

}

else {

queryAddress(serviceQueryResults.front().hostname);

}

}

void Connector::handleAddressQueryResult(const std::vector<HostAddress>& addresses, boost::optional<DomainNameResolveError> error) {

addressQuery.reset();

if (error || addresses.empty()) {

if (!serviceQueryResults.empty()) {

void Connector::tryNextAddress() {

if (addressQueryResults.empty()) {

// Done trying all addresses. Move on to the next host.

if (!serviceQueryResults.empty()) {

serviceQueryResults.pop_front();

tryNextServiceOrFallback();

}

else {

HostAddress address = addressQueryResults.front();

addressQueryResults.pop_front();

void Connector::tryConnect(const HostAddressPort& target) {

assert(!currentConnection);

currentConnection = connectionFactory->createConnection();

currentConnection->onConnectFinished.connect(boost::bind(&Connector::handleConnectionConnectFinished, shared_from_this(), _1));

currentConnection->connect(target);

}

void Connector::handleConnectionConnectFinished(bool error) {

if (timer) {

timer->stop();

timer.reset();

}

void Connector::handleTimeout() {

handleConnectionConnectFinished(true);

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

EnvironmentProxyProvider::EnvironmentProxyProvider() {

socksProxy = getFromEnv("all_proxy", "socks");

httpProxy = getFromEnv("http_proxy", "http");

}

HostAddressPort EnvironmentProxyProvider::getHTTPConnectProxy() const {

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

socksProxy = getFromGConf("/system/proxy/socks_host", "/system/proxy/socks_port");

httpProxy = getFromGConf("/system/http_proxy/host", "/system/http_proxy/port");

}

HostAddressPort GConfProxyProvider::getHTTPConnectProxy() const {

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

nextHTTPRequestHeaders_.clear();

}

append(data, createSafeByteArray("\r\n"));

write(data);

}

void HTTPConnectProxiedConnection::handleProxyInitializeData(std::shared_ptr<SafeByteArray> data) {

std::string dataString = byteArrayToString(ByteArray(data->begin(), data->end()));

httpResponseBuffer_.append(dataString);

std::string statusLine;

if (tmp.size() > 1) {

try {

int status = boost::lexical_cast<int>(tmp[1]);

if (status / 100 == 2) { // all 2XX states are OK

setProxyInitializeFinished(true);

}

else {

setProxyInitializeFinished(false);

}

}

catch (boost::bad_lexical_cast&) {

setProxyInitializeFinished(false);

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

addressString = address_.to_string(errorCode);

if (errorCode) {

}

return addressString;

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

boost::optional<HostAddress> NATPMPInterface::getPublicIP() {

if (sendpublicaddressrequest(&p->natpmp) < 0) {

return boost::optional<HostAddress>();

}

return boost::optional<HostAddress>(HostAddress(reinterpret_cast<const unsigned char*>(&(response.pnu.publicaddress.addr)), 4));

}

else {

return boost::optional<HostAddress>();

}

}

mapping.getLocalPort(),

mapping.getPublicPort(),

mapping.getLeaseInSeconds()) < 0) {

return boost::optional<NATPortMapping>();

}

return result;

}

else {

return boost::optional<NATPortMapping>();

}

}

bool NATPMPInterface::removePortForward(const NATPortMapping& mapping) {

if (sendnewportmappingrequest(&p->natpmp, mapping.getProtocol() == NATPortMapping::TCP ? NATPMP_PROTOCOL_TCP : NATPMP_PROTOCOL_UDP, mapping.getLocalPort(), 0, 0) < 0) {

return false;

}

return true;

}

else {

return false;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

return;

}

std::vector<DomainNameServiceQuery::Result> records;

response.resize(NS_PACKETSZ);

int responseLength = res_query(const_cast<char*>(service.c_str()), ns_c_in, ns_t_srv, reinterpret_cast<u_char*>(vecptr(response)), response.size());

if (responseLength == -1) {

emitError();

return;

}

miniUPnPInterface = new MiniUPnPInterface();

miniUPnPSupported = miniUPnPInterface->isAvailable();

}

if (miniUPnPSupported) {

return miniUPnPInterface;

}

natPMPInterface = new NATPMPInterface();

natPMPSupported = natPMPInterface->isAvailable();

}

if (natPMPSupported) {

return natPMPInterface;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

connection_->onDisconnected.disconnect(boost::bind(&ProxiedConnection::handleDisconnected, shared_from_this(), _1));

}

if (connected_) {

}

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

assert(rawAddress.is_v4() || rawAddress.is_v6());

if (proxyState_ == ProxyAuthenticating) {

unsigned char choosenMethod = static_cast<unsigned char> ((*data)[1]);

if ((*data)[0] == 0x05 && choosenMethod != 0xFF) {

switch(choosenMethod) { // use the correct Method

return;

}

catch(...) {

}

write(socksConnect);

break;

setProxyInitializeFinished(false);

}

else if (proxyState_ == ProxyConnecting) {

/*

data.at(1) can be one of the following:

0x09 bis 0xFF unassigned

*/

if ((*data)[0] == 0x05 && (*data)[1] == 0x0) {

setProxyInitializeFinished(true);

}

else {

setProxyInitializeFinished(false);

}

}

1 /* CLASS IN (internet) */,

helper, UnboundDomainNameResolver::unbound_callback_wrapper, NULL);

if(retval != 0) {

delete helper;

}

}

std::vector<DomainNameServiceQuery::Result> serviceRecords;

if(err != 0) {

} else {

if(result->havedata) {

ldns_pkt* replyPacket = 0;

serviceRecord.hostname = std::string(reinterpret_cast<char*>(ldns_buffer_at(buffer, 0)));

serviceRecords.push_back(serviceRecord);

}

}

if (replyPacket) ldns_pkt_free(replyPacket);

1 /* CLASS IN (internet) */,

helper, UnboundDomainNameResolver::unbound_callback_wrapper, NULL);

if(retval != 0) {

delete helper;

}

}

void handleResult(int err, struct ub_result* result) {

std::vector<HostAddress> addresses;

boost::optional<DomainNameResolveError> error;

if(err != 0) {

error = DomainNameResolveError();

} else {

if(result->havedata) {

char address[100];

const char* addressStr = 0;

if ((addressStr = inet_ntop(AF_INET, result->data[i], address, 100))) {

addresses.push_back(HostAddress(std::string(addressStr)));

} else if ((addressStr = inet_ntop(AF_INET6, result->data[i], address, 100))) {

addresses.push_back(HostAddress(std::string(addressStr)));

} else {

error = DomainNameResolveError();

}

}

UnboundDomainNameResolver::UnboundDomainNameResolver(IDNConverter* idnConverter, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : idnConverter(idnConverter), ioService(ioService), ubDescriptior(*ioService), eventLoop(eventLoop) {

ubContext = ub_ctx_create();

if(!ubContext) {

}

eventOwner = std::make_shared<EventOwner>();

/* read /etc/resolv.conf for DNS proxy settings (from DHCP) */

if( (ret=ub_ctx_resolvconf(ubContext, const_cast<char*>("/etc/resolv.conf"))) != 0) {

}

/* read /etc/hosts for locally supplied host addresses */

if( (ret=ub_ctx_hosts(ubContext, const_cast<char*>("/etc/hosts"))) != 0) {

}

ubDescriptior.assign(ub_fd(ubContext));

if (ub_poll(ubContext)) {

int ret = ub_process(ubContext);

if(ret != 0) {

}

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

virtual std::vector<std::pair<std::string, std::string> > filterHTTPResponseHeader(const std::string& /* statusLine */, const std::vector<std::pair<std::string, std::string> >& response) {

filterResponses.push_back(response);

return filterResponseReturn;

}

std::shared_ptr<Connection> createConnection() {

std::shared_ptr<MockConnection> connection = std::make_shared<MockConnection>(failingPorts, eventLoop);

connections.push_back(connection);

return connection;

}

for(auto&& proxy : proxies) {

if(proxy.find('=') != std::string::npos) {

protocolAndProxy = String::getSplittedAtFirst(proxy, '=');

if(protocolAndProxy.first.compare("socks") == 0) {

socksProxy = getAsHostAddressPort(protocolAndProxy.second);

}

ret = HostAddressPort(HostAddress::fromString(tmp.first).get(), port);

}

catch(...) {

}

return ret;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

getStanzaGeneric()->setType(IQ::Error);

}

else {

getStanzaGeneric()->setType(IQ::Get);

}

}

AttributeMap attributeValues;

if (nbDefaulted != 0) {

// Just because i don't understand what this means yet :-)

}

for (int i = 0; i < nbAttributes*5; i += 5) {

std::string attributeName = asString(attributes[i]);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

getStanzaGeneric()->setType(Presence::Error);

}

else {

getStanzaGeneric()->setType(Presence::Available);

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

xmppRoster_->addContact(item.getJID(), item.getName(), item.getGroups(), item.getSubscription());

}

else {

}

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#define ASSIGN_ERROR(status, errorCode) \

{ \

errorCode = std::make_shared<boost::system::error_code>(status, boost::system::system_category()); \

}

#define ASSIGN_SEC_ERROR(status, errorCode) \

{ \

if (status == SEC_E_OK) \

{ \

} \

else { \

ASSIGN_ERROR(status, errorCode); \

std::size_t position;

userName = convertWStringToString(std::wstring(vecptr(value), length));

position = userName.find("\\");

clientName = userName.substr(position + 1);

serverName = userName.substr(0, position);

break;

}

}

if ((status == SEC_E_OK) || (status == SEC_I_COMPLETE_AND_CONTINUE) || (status == SEC_I_COMPLETE_NEEDED) || (status == SEC_I_CONTINUE_NEEDED)) {

outputToken = createSafeByteArray (static_cast<unsigned char *>(outputTokenBuffer.pvBuffer), outputTokenBuffer.cbBuffer);

freeContextBuffer(outputTokenBuffer.pvBuffer);

return std::shared_ptr<boost::system::error_code>(); /* success */

messageBuffer[1].cbBuffer = 0;

messageBuffer[1].pvBuffer = NULL;

status = DecryptMessage(

contextHandle,

ASSIGN_SEC_ERROR(status, errorCode);

if (status == SEC_E_OK) {

if (qualityOfProtection == SECQOP_WRAP_NO_ENCRYPT) {

}

else {

}

decrypted = createSafeByteArray (static_cast<unsigned char *>(messageBuffer[1].pvBuffer), messageBuffer[1].cbBuffer);

}

messageBuffer[2].cbBuffer = sizes.cbBlockSize;

messageBuffer[2].pvBuffer = vecptr(blockSize);

status = EncryptMessage(

contextHandle,

if (status == SEC_E_OK) {

unsigned char* pointer;

output.resize(messageBuffer[0].cbBuffer + messageBuffer[1].cbBuffer + messageBuffer[2].cbBuffer);

pointer = vecptr(output);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

boost::optional<SafeByteArray> WindowsGSSAPIClientAuthenticator::getResponse() const {

return response_;

}

}

else if (step_ == SecurityLayerNegotiation) {

if (!challengeData) {

error_ = true;

return false;

}

}

if (challenge.size() != 4) {

error_ = true;

return false;

}

unsigned char serverSecurityLayer = challengePointer[0];

if (serverSecurityLayer == 0) {

serverSecurityLayer = SECURITY_LAYER_NONE;

}

else if (serverSecurityLayer == SECURITY_LAYER_NONE) {

}

else {

}

unsigned int serverMaximumBuffer = (challengePointer[1] << 16) |

(challengePointer[3] << 0);

if ((serverSecurityLayer == SECURITY_LAYER_NONE) && (serverMaximumBuffer != 0)) {

error_ = true;

return false;

}

}

if (contextSupported & ISC_REQ_MUTUAL_AUTH == 0) {

error_ = true;

return;

}

}

userName_ = names.sUserName;

std::size_t position = userName_.find("\\");

clientName_ = userName_.substr(position + 1);

serverName_ = userName_.substr(0, position);

freeContextBuffer(names.sUserName);

step_ = SecurityLayerNegotiation;

firstCall = false;

}

return str;

}

DWORD status;

#ifdef UNICODE

#else

#endif

/* Call the Unicode function because that is recommended:

https://msdn.microsoft.com/en-us/library/windows/desktop/ff381407%28v=vs.85%29.aspx */

if (status != ERROR_SUCCESS) {

boost::system::error_code errorCode(status, boost::system::system_category());

}

return status;

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

case JinglePayload::TransportReplace:

return "transport-replace";

case JinglePayload::UnknownAction:

return "";

}

assert(false);

std::string JinglePayloadSerializer::reasonTypeToString(JinglePayload::Reason::Type type) const {

switch(type) {

case JinglePayload::Reason::UnknownType:

return "";

case JinglePayload::Reason::AlternativeSession:

return "alternative-session";

/*

* All rights reserved.

* See the COPYING file for more information.

*/

element.addNode(std::make_shared<XMLRawTextNode>(serializer->serialize(payload)));

}

else {

}

}

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

case WhiteboardPayload::SessionTerminate:

return "session-terminate";

case WhiteboardPayload::UnknownType:

return "";

}

assert(false);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

serializedPayloads += serializer->serialize(payload);

}

else {

}

}

serializedPayloads = String::sanitizeXMPPString(serializedPayloads);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

return (*i)->serialize(element);

}

else {

return createSafeByteArray("");

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

unsigned int i = lastHandledStanzasCount;

while (i != handledStanzasCount) {

if (unackedStanzas.empty()) {

break;

}

std::shared_ptr<Stanza> ackedStanza = unackedStanzas.front();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

WhitespacePingLayer::~WhitespacePingLayer() {

if (isActive) {

timer->stop();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#define DEBUG_SCARD_STATUS(function, status) \

{ \

std::shared_ptr<boost::system::error_code> errorCode = std::make_shared<boost::system::error_code>(status, boost::system::system_category()); \

}

namespace Swift {

}

CAPICertificate::~CAPICertificate() {

if (smartCardTimer_) {

smartCardTimer_->stop();

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

if (certStoreHandle_) {

if (CertCloseStore(certStoreHandle_, 0) == FALSE) {

}

}

CERT_KEY_PROV_INFO_PROP_ID,

NULL,

&len)) {

return;

}

switch (dwState) {

case SCARD_ABSENT:

break;

case SCARD_PRESENT:

break;

case SCARD_SWALLOWED:

break;

case SCARD_POWERED:

break;

case SCARD_NEGOTIABLE:

break;

case SCARD_SPECIFIC:

break;

default:

break;

}

void CAPICertificate::handleSmartCardTimerTick() {

bool poll = checkIfSmartCardPresent();

if (lastPollingResult_ && !poll) {

onCertificateCardRemoved();

}

lastPollingResult_ = poll;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#endif

cert = std::shared_ptr<X509>(d2i_X509(nullptr, &p, der.size()), X509_free);

if (!cert) {

}

parse();

}

if (cb != nullptr) {

ret = cb(static_cast<const OpenSSLContext*>(context));

} else {

ret = 0;

}

SSL* ssl = static_cast<SSL*>(X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx()));

SSL_CTX* sslctx = ssl ? SSL_get_SSL_CTX(ssl) : nullptr;

if (!sslctx) {

return preverifyOk;

}

if (SSL_CTX_get_verify_mode(sslctx) == SSL_VERIFY_NONE) {

// No verification requested

return 1;

}

}

SWIFT_LOG(debug) << "verifyCallback: verification error " <<

X509_verify_cert_error_string(err) << " depth: " <<

} else {

SWIFT_LOG(debug) << "verifyCallback: SSL depth: " << depth << " Subject: " <<

}

// Always return "OK", as check on verification status

// will be performed once TLS handshake has completed,

if (options.cipherSuites) {

std::string cipherSuites = *(options.cipherSuites);

if (SSL_CTX_set_cipher_list(context_.get(), cipherSuites.c_str()) != 1 ) {

return false;

}

}

if (SSL_CTX_set_session_id_context(context_.get(),

reinterpret_cast<const unsigned char *>(contextId.c_str()),

contextId.length()) != 1) {

return false;

}

}

if (options.sessionCacheTimeout) {

int scto = *options.sessionCacheTimeout;

if (scto <= 0) {

return false;

}

(void)SSL_CTX_set_timeout(context_.get(), scto);

if (SSL_CTX_get_timeout(context_.get()) != scto) {

return false;

}

}

if (options.verifyDepth) {

int depth = *options.verifyDepth;

if (depth <= 0) {

return false;

}

bool OpenSSLContext::setCertificateChain(const std::vector<std::shared_ptr<Certificate>>& certificateChain) {

if (certificateChain.size() == 0) {

return false;

}

}

if (SSL_CTX_add_extra_chain_cert(context_.get(), openSSLCert->getInternalX509().get()) != 1) {

return false;

}

// Have to manually increment reference count as SSL_CTX_add_extra_chain_cert does not do so

void OpenSSLContextFactory::setCheckCertificateRevocation(bool check) {

if (check) {

assert(false);

}

}

void OpenSSLContextFactory::setDisconnectOnCardRemoval(bool check) {

if (check) {

}

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

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

SchannelContext::~SchannelContext() {

if (myCertStore_) {

if (CertCloseStore(myCertStore_, 0) == FALSE) {

}

}

}

void SchannelContext::determineStreamSizes() {

if (QueryContextAttributes(contextHandle_, SECPKG_ATTR_STREAM_SIZES, &streamSizes_) != SEC_E_OK) {

}

}

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));

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

}

else {

}

return ByteArray();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

break;

case errSecAuthFailed:

// Password did not work for decoding the certificate.

break;

case errSecDecode:

// Other decoding error.

break;

default:

}

if (securityError != errSecSuccess) {

// set IO callbacks

error = SSLSetIOFuncs(sslContext_.get(), &SecureTransportContext::SSLSocketReadCallback, &SecureTransportContext::SSLSocketWriteCallback);

if (error != noErr) {

sslContext_.reset();

}

error = SSLSetConnection(sslContext_.get(), this);

if (error != noErr) {

sslContext_.reset();

}

error = SSLSetSessionOption(sslContext_.get(), kSSLSessionOptionBreakOnServerAuth, true);

if (error != noErr) {

sslContext_.reset();

}

}

}

void SecureTransportContext::setState(State newState) {

state_ = newState;

}

void SecureTransportContext::connect() {

if (clientCertificate_) {

CFArrayRef certs = CreateClientCertificateChainAsCFArrayRef(clientCertificate_);

if (certs) {

std::shared_ptr<CFArray> certRefs(certs, CFRelease);

OSStatus result = SSLSetCertificate(sslContext_.get(), certRefs.get());

if (result != noErr) {

}

}

}

}

void SecureTransportContext::processHandshake() {

OSStatus error = SSLHandshake(sslContext_.get());

if (error == errSSLWouldBlock) {

setState(Handshake);

}

else if (error == noErr) {

setState(HandshakeDone);

onConnected();

}

else if (error == errSSLPeerAuthCompleted) {

setState(Handshake);

verifyServerCertificate();

}

else {

fatalError(nativeToTLSError(error), std::make_shared<CertificateVerificationError>());

}

}

OSStatus cssmResult = 0;

switch(trustResult) {

case kSecTrustResultUnspecified:

break;

case kSecTrustResultProceed:

break;

case kSecTrustResultRecoverableTrustFailure:

error = SecTrustGetCssmResultCode(trust, &cssmResult);

if (error == errSecSuccess) {

verificationError_ = CSSMErrorToVerificationError(cssmResult);

}

void SecureTransportContext::handleDataFromNetwork(const SafeByteArray& data) {

append(readingBuffer_, data);

break;

}

else {

fatalError(std::make_shared<TLSError>(), std::make_shared<CertificateVerificationError>());

return;

}

}

break;

case Error:

break;

}

}

OSStatus error = SSLWrite(sslContext_.get(), data.data(), data.size(), &processedBytes);

switch(error) {

case errSSLWouldBlock:

return;

case errSSLClosedGraceful:

case noErr:

return;

default:

fatalError(std::make_shared<TLSError>(), std::shared_ptr<CertificateVerificationError>());

}

}

}

}

else {

}

}

}

ByteArray SecureTransportContext::getFinishMessage() const {

return ByteArray();

}

std::shared_ptr<CertificateVerificationError> error;

switch(resultCode) {

case CSSMERR_TP_NOT_TRUSTED:

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::Untrusted);

break;

case CSSMERR_TP_CERT_NOT_VALID_YET:

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::NotYetValid);

break;

case CSSMERR_TP_CERT_EXPIRED:

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::Expired);

break;

case CSSMERR_TP_CERT_REVOKED:

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::Revoked);

break;

case CSSMERR_TP_VERIFY_ACTION_FAILED:

break;

case CSSMERR_APPLETP_INCOMPLETE_REVOCATION_CHECK:

if (checkCertificateRevocation_) {

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::RevocationCheckFailed);

}

break;

case CSSMERR_APPLETP_OCSP_UNAVAILABLE:

if (checkCertificateRevocation_) {

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::RevocationCheckFailed);

}

break;

case CSSMERR_APPLETP_SSL_BAD_EXT_KEY_USE:

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::InvalidPurpose);

break;

default:

error = std::make_shared<CertificateVerificationError>(CertificateVerificationError::UnknownError);

break;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void SecureTransportContextFactory::setDisconnectOnCardRemoval(bool b) {

disconnectOnCardRemoval_ = b;

if (disconnectOnCardRemoval_) {

}

}