UseTLS useTLS;

/**

* Sets whether plaintext authentication is

* allowed over non-TLS-encrypted connections.

*

* Default: false

*/

bool allowPLAINWithoutTLS;

/**

* Use XEP-196 stream resumption when available.

*

* Default: false

*/

bool useStreamResumption;

/**

* Forget the password once it's used.

* This makes the Client useless after the first login attempt.

*

* FIXME: This is a temporary workaround.

*

* Default: false

*/

bool forgetPassword;

/**

* Use XEP-0198 acks in the stream when available.

* Default: true

*/

bool useAcks;

/**

* If non-empty, use BOSH instead of direct TCP, with the given URL.

* Default: empty (no BOSH)

*/

URL boshURL;

/**

* If non-empty, BOSH connections will try to connect over this HTTP CONNECT

* proxy instead of directly.

* Default: empty (no proxy)

*/

URL boshHTTPConnectProxyURL;

/**

* If this and matching Password are non-empty, BOSH connections over

* HTTP CONNECT proxies will use these credentials for proxy access.

* Default: empty (no authentication needed by the proxy)

*/

SafeString boshHTTPConnectProxyAuthID;

SafeString boshHTTPConnectProxyAuthPassword;

};

}

stanzaChannel_->onStanzaAcked.connect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

stanzaChannel_->onAvailableChanged.connect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

iqRouter_ = new IQRouter(stanzaChannel_);

iqRouter_->setJID(jid);

}

CoreClient::~CoreClient() {

forceReset();

delete iqRouter_;

stanzaChannel_->onAvailableChanged.disconnect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

stanzaChannel_->onMessageReceived.disconnect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.disconnect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

stanzaChannel_->onStanzaAcked.disconnect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

delete stanzaChannel_;

}

void CoreClient::connect(const ClientOptions& o) {

SWIFT_LOG(debug) << "Connecting" << std::endl;

options = o;

connect(jid_.getDomain());

}

void CoreClient::connect(const std::string& host) {

forceReset();

SWIFT_LOG(debug) << "Connecting to host " << host << std::endl;

disconnectRequested_ = false;

assert(!connector_);

assert(proxyConnectionFactories.empty());

if(networkFactories->getProxyProvider()->getSOCKS5Proxy().isValid()) {

proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getConnectionFactory(), networkFactories->getProxyProvider()->getSOCKS5Proxy()));

}

if(networkFactories->getProxyProvider()->getHTTPConnectProxy().isValid()) {

}

std::vector<ConnectionFactory*> connectionFactories(proxyConnectionFactories);

if (options.boshURL.empty()) {

connectionFactories.push_back(networkFactories->getConnectionFactory());

connector_ = boost::make_shared<ChainedConnector>(host, networkFactories->getDomainNameResolver(), connectionFactories, networkFactories->getTimerFactory());

connector_->onConnectFinished.connect(boost::bind(&CoreClient::handleConnectorFinished, this, _1));

connector_->setTimeoutMilliseconds(60*1000);

connector_->start();

}

else {

/* Autodiscovery of which proxy works is largely ok with a TCP session, because this is a one-off. With BOSH

* it would be quite painful given that potentially every stanza could be sent on a new connection.

*/

//sessionStream_ = boost::make_shared<BOSHSessionStream>(boost::make_shared<BOSHConnectionFactory>(options.boshURL, networkFactories->getConnectionFactory(), networkFactories->getXMLParserFactory(), networkFactories->getTLSContextFactory()), getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory(), networkFactories->getEventLoop(), host, options.boshHTTPConnectProxyURL, options.boshHTTPConnectProxyAuthID, options.boshHTTPConnectProxyAuthPassword);

sessionStream_ = boost::shared_ptr<BOSHSessionStream>(new BOSHSessionStream(

options.boshURL,

getPayloadParserFactories(),

getPayloadSerializers(),

networkFactories->getConnectionFactory(),

networkFactories->getXMLParserFactory(),

options.boshHTTPConnectProxyAuthPassword));

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

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

bindSessionToStream();

}

}

void CoreClient::bindSessionToStream() {

session_ = ClientSession::create(jid_, sessionStream_);

session_->setCertificateTrustChecker(certificateTrustChecker);

session_->setUseStreamCompression(options.useStreamCompression);

session_->setAllowPLAINOverNonTLS(options.allowPLAINWithoutTLS);

switch(options.useTLS) {

case ClientOptions::UseTLSWhenAvailable:

session_->setUseTLS(ClientSession::UseTLSWhenAvailable);

break;

case ClientOptions::NeverUseTLS:

session_->setUseTLS(ClientSession::NeverUseTLS);

break;

case ClientOptions::RequireTLS:

session_->setUseTLS(ClientSession::RequireTLS);

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