cpp_stdlib_headers = Set(["algorithm", "fstream", "list", "regex", "typeindex", "array", "functional", "locale", "set", "typeinfo", "atomic", "future", "map", "sstream", "type_traits", "bitset", "initializer_list", "memory", "stack", "unordered_map", "chrono", "iomanip", "mutex", "stdexcept", "unordered_set", "codecvt", "ios", "new", "streambuf", "utility", "complex", "iosfwd", "numeric", "string", "valarray", "condition_variable", "iostream", "ostream", "strstream", "vector", "deque", "istream", "queue", "system_error", "exception", "iterator", "random", "thread", "forward_list", "limits", "ratio", "tuple", "cassert", "ciso646", "csetjmp", "cstdio", "ctime", "cctype", "climits", "csignal", "cstdlib", "cwchar", "cerrno", "clocale", "cstdarg", "cstring", "cwctype", "cfloat", "cmath", "cstddef"])

class HeaderType:

def findHeaderBlock(lines):

start = False

if name.startswith("Q"):

return HeaderType.QT

if name.startswith("Swiften"):

return HeaderType.SWIFTEN

---------------

- Fix UI layout issue for translations that require right-to-left (RTL) layout

- macOS releases are now code-signed with a key from Apple, so they can be run without Gatekeeper trust warnings

4.0-beta2 ( 2016-07-20 )

------------------------

#include <memory>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Serializer/PayloadSerializer.h>

#include <Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h>

#include <Swiften/Serializer/XMPPSerializer.h>

os << "Element(Unknown)";

return os;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <iosfwd>

namespace Swift {

class ClientError;

class Element;

std::ostream& operator<<(std::ostream& os, const Swift::ClientError& error);

std::ostream& operator<<(std::ostream& os, Swift::Element* ele);

4.0-beta1 ( 2016-07-15 )

------------------------

- Moved code-base to C++11

HTTPConnectProxy

};

}

/**

*

* Default: true

*/

/**

* Sets whether TLS encryption should be used.

*

* Default: UseTLSWhenAvailable

*/

/**

* Sets whether plaintext authentication is

*

* Default: false

*/

/**

* Use XEP-196 stream resumption when available.

*

* Default: false

*/

/**

* Forget the password once it's used.

*

* Default: false

*/

/**

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

* Default: true

*/

/**

* Use Single Sign On.

* Default: false

*/

/**

* The hostname to connect to.

* Leave this empty for standard XMPP connection, based on the JID domain.

*/

/**

* The port to connect to.

* Leave this to -1 to use the port discovered by SRV lookups, and 5222 as a

* fallback.

*/

/**

* The type of proxy to use for connecting to the XMPP

* server.

*/

/**

* Override the system-configured proxy hostname.

*/

/**

* Override the system-configured proxy port.

*/

/**

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

* Default: empty (no BOSH)

*/

/**

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

* proxy instead of directly.

* Default: empty (no proxy)

*/

/**

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

*/

/**

* This can be initialized with a custom HTTPTrafficFilter, which allows HTTP CONNECT

* Options passed to the TLS stack

*/

TLSOptions tlsOptions;

};

}

#include <Swiften/Client/ClientSession.h>

#include <boost/bind.hpp>

#include <boost/uuid/uuid.hpp>

#include <boost/uuid/uuid_io.hpp>

#include <boost/uuid/uuid_generators.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Elements/AuthChallenge.h>

#include <Swiften/Elements/AuthResponse.h>

#include <Swiften/Elements/CompressFailure.h>

#include <Swiften/Elements/CompressRequest.h>

#include <Swiften/Elements/EnableStreamManagement.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/ResourceBind.h>

#include <Swiften/SASL/EXTERNALClientAuthenticator.h>

#include <Swiften/SASL/SCRAMSHA1ClientAuthenticator.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/CertificateTrustChecker.h>

#include <Swiften/TLS/ServerIdentityVerifier.h>

const JID& jid,

std::shared_ptr<SessionStream> stream,

IDNConverter* idnConverter,

localJID(jid),

stream(stream),

idnConverter(idnConverter),

crypto(crypto),

allowPLAINOverNonTLS(false),

useStreamCompression(true),

useTLS(UseTLSWhenAvailable),

void ClientSession::start() {

stream->onStreamStartReceived.connect(boost::bind(&ClientSession::handleStreamStart, shared_from_this(), _1));

stream->onElementReceived.connect(boost::bind(&ClientSession::handleElement, shared_from_this(), _1));

stream->onClosed.connect(boost::bind(&ClientSession::handleStreamClosed, shared_from_this(), _1));

stream->onTLSEncrypted.connect(boost::bind(&ClientSession::handleTLSEncrypted, shared_from_this()));

sendStreamHeader();

}

}

void ClientSession::handleStreamStart(const ProtocolHeader&) {

}

void ClientSession::handleElement(std::shared_ptr<ToplevelElement> element) {

if (stanzaAckResponder_) {

stanzaAckResponder_->handleStanzaReceived();

}

onStanzaReceived(stanza);

}

else if (std::shared_ptr<IQ> iq = std::dynamic_pointer_cast<IQ>(element)) {

std::shared_ptr<ResourceBind> resourceBind(iq->getPayload<ResourceBind>());

if (iq->getType() == IQ::Error && iq->getID() == "session-bind") {

finishSession(Error::ResourceBindError);

finishSession(Error::UnexpectedElementError);

}

}

if (iq->getType() == IQ::Result) {

needSessionStart = false;

continueSessionInitialization();

else if (StreamError::ref streamError = std::dynamic_pointer_cast<StreamError>(element)) {

finishSession(Error::StreamError);

}

std::shared_ptr<Stanza> stanza = std::dynamic_pointer_cast<Stanza>(element);

if (stanza) {

if (stanzaAckResponder_) {

}

}

else if (StreamFeatures* streamFeatures = dynamic_cast<StreamFeatures*>(element.get())) {

if (streamFeatures->hasStartTLS() && stream->supportsTLSEncryption() && useTLS != NeverUseTLS) {

stream->writeElement(std::make_shared<StartTLSRequest>());

}

else if (useTLS == RequireTLS && !stream->isTLSEncrypted()) {

finishSession(Error::NoSupportedAuthMechanismsError);

}

else if (useStreamCompression && stream->supportsZLibCompression() && streamFeatures->hasCompressionMethod("zlib")) {

stream->writeElement(std::make_shared<CompressRequest>("zlib"));

}

else if (streamFeatures->hasAuthenticationMechanisms()) {

authenticator = gssapiAuthenticator;

if (!gssapiAuthenticator->isError()) {

stream->writeElement(std::make_shared<AuthRequest>(authenticator->getName(), authenticator->getResponse()));

}

else {

if (stream->hasTLSCertificate()) {

if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {

authenticator = new EXTERNALClientAuthenticator();

stream->writeElement(std::make_shared<AuthRequest>("EXTERNAL", createSafeByteArray("")));

}

else {

}

else if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {

authenticator = new EXTERNALClientAuthenticator();

stream->writeElement(std::make_shared<AuthRequest>("EXTERNAL", createSafeByteArray("")));

}

else if (streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1") || streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1-PLUS")) {

scramAuthenticator->setTLSChannelBindingData(finishMessage);

}

authenticator = scramAuthenticator;

onNeedCredentials();

}

else if ((stream->isTLSEncrypted() || allowPLAINOverNonTLS) && streamFeatures->hasAuthenticationMechanism("PLAIN")) {

authenticator = new PLAINClientAuthenticator();

onNeedCredentials();

}

else if (streamFeatures->hasAuthenticationMechanism("DIGEST-MD5") && crypto->isMD5AllowedForCrypto()) {

s << boost::uuids::random_generator()();

// FIXME: Host should probably be the actual host

authenticator = new DIGESTMD5ClientAuthenticator(localJID.getDomain(), s.str(), crypto);

onNeedCredentials();

}

else {

}

}

else if (std::dynamic_pointer_cast<Compressed>(element)) {

stream->addZLibCompression();

stream->resetXMPPParser();

sendStreamHeader();

continueSessionInitialization();

}

else if (AuthChallenge* challenge = dynamic_cast<AuthChallenge*>(element.get())) {

assert(authenticator);

if (authenticator->setChallenge(challenge->getValue())) {

stream->writeElement(std::make_shared<AuthResponse>(authenticator->getResponse()));

}

}

else if (AuthSuccess* authSuccess = dynamic_cast<AuthSuccess*>(element.get())) {

assert(authenticator);

if (!authenticator->setChallenge(authSuccess->getValue())) {

finishSession(Error::ServerVerificationFailedError);

}

else {

delete authenticator;

authenticator = nullptr;

stream->resetXMPPParser();

finishSession(Error::AuthenticationFailedError);

}

else if (dynamic_cast<TLSProceed*>(element.get())) {

stream->addTLSEncryption();

}

else if (dynamic_cast<StartTLSFailure*>(element.get())) {

}

else {

// FIXME Not correct?

onInitialized();

}

}

void ClientSession::continueSessionInitialization() {

if (needResourceBind) {

std::shared_ptr<ResourceBind> resourceBind(std::make_shared<ResourceBind>());

if (!localJID.getResource().empty()) {

resourceBind->setResource(localJID.getResource());

sendStanza(IQ::createRequest(IQ::Set, JID(), "session-bind", resourceBind));

}

else if (needAcking) {

stream->writeElement(std::make_shared<EnableStreamManagement>());

}

else if (needSessionStart) {

sendStanza(IQ::createRequest(IQ::Set, JID(), "session-start", std::make_shared<StartSession>()));

}

else {

onInitialized();

}

}

}

void ClientSession::sendCredentials(const SafeByteArray& password) {

assert(authenticator);

authenticator->setCredentials(localJID.getNode(), password);

stream->writeElement(std::make_shared<AuthRequest>(authenticator->getName(), authenticator->getResponse()));

}

void ClientSession::handleTLSEncrypted() {

std::vector<Certificate::ref> certificateChain = stream->getPeerCertificateChain();

std::shared_ptr<CertificateVerificationError> verificationError = stream->getPeerCertificateVerificationError();

}

}

void ClientSession::continueAfterTLSEncrypted() {

stream->resetXMPPParser();

sendStreamHeader();

}

void ClientSession::handleStreamClosed(std::shared_ptr<Swift::Error> streamError) {

State previousState = state;

if (stanzaAckRequester_) {

stanzaAckRequester_->onRequestAck.disconnect(boost::bind(&ClientSession::requestAck, shared_from_this()));

}

stream->setWhitespacePingEnabled(false);

stream->onStreamStartReceived.disconnect(boost::bind(&ClientSession::handleStreamStart, shared_from_this(), _1));

stream->onElementReceived.disconnect(boost::bind(&ClientSession::handleElement, shared_from_this(), _1));

stream->onClosed.disconnect(boost::bind(&ClientSession::handleStreamClosed, shared_from_this(), _1));

stream->onTLSEncrypted.disconnect(boost::bind(&ClientSession::handleTLSEncrypted, shared_from_this()));

onFinished(error_);

}

else {

}

}

void ClientSession::finish() {

}

void ClientSession::finishSession(Error::Type error) {

}

void ClientSession::finishSession(std::shared_ptr<Swift::Error> error) {

if (!error_) {

error_ = error;

}

delete authenticator;

authenticator = nullptr;

}

}

void ClientSession::requestAck() {

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Session/SessionStream.h>

namespace Swift {

class CertificateTrustChecker;

class CryptoProvider;

class SWIFTEN_API ClientSession : public std::enable_shared_from_this<ClientSession> {

public:

Initial,

WaitingForStreamStart,

Negotiating,

SessionStartError,

TLSClientCertificateError,

TLSError,

} type;

std::shared_ptr<boost::system::error_code> errorCode;

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

~ClientSession();

}

State getState() const {

useAcks = b;

}

bool getStreamManagementEnabled() const {

// Explicitly convert to bool. In C++11, it would be cleaner to

// compare to nullptr.

void finish();

bool isFinished() const {

}

void sendCredentials(const SafeByteArray& password);

authenticationPort = i;

}

public:

boost::signals2::signal<void ()> onNeedCredentials;

boost::signals2::signal<void ()> onInitialized;

const JID& jid,

std::shared_ptr<SessionStream>,

IDNConverter* idnConverter,

void finishSession(Error::Type error);

void finishSession(std::shared_ptr<Swift::Error> error);

void handleElement(std::shared_ptr<ToplevelElement>);

void handleStreamStart(const ProtocolHeader&);

void handleStreamClosed(std::shared_ptr<Swift::Error>);

void handleTLSEncrypted();

void ack(unsigned int handledStanzasCount);

void continueAfterTLSEncrypted();

void checkTrustOrFinish(const std::vector<Certificate::ref>& certificateChain, std::shared_ptr<CertificateVerificationError> error);

private:

JID localJID;

State state;

std::shared_ptr<SessionStream> stream;

bool allowPLAINOverNonTLS;

bool useStreamCompression;

UseTLS useTLS;

virtual std::vector<Certificate::ref> getPeerCertificateChain() const;

bool isAvailable() const {

}

private:

}

void CoreClient::bindSessionToStream() {

session_->setCertificateTrustChecker(certificateTrustChecker);

session_->setUseStreamCompression(options.useStreamCompression);

session_->setAllowPLAINOverNonTLS(options.allowPLAINWithoutTLS);

session_->setSingleSignOn(options.singleSignOn);

session_->setAuthenticationPort(options.manualPort);

switch(options.useTLS) {

case ClientOptions::UseTLSWhenAvailable:

session_->setUseTLS(ClientSession::UseTLSWhenAvailable);

case ClientSession::Error::StreamError:

clientError = ClientError(ClientError::StreamError);

break;

}

clientError.setErrorCode(actualError->errorCode);

}

#include <boost/bind.hpp>

#include <boost/optional.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/TLSProceed.h>

#include <Swiften/IDN/IDNConverter.h>

#include <Swiften/IDN/PlatformIDNConverter.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/BlindCertificateTrustChecker.h>

#include <Swiften/TLS/SimpleCertificate.h>

CPPUNIT_TEST(testStreamManagement_Failed);

CPPUNIT_TEST(testUnexpectedChallenge);

CPPUNIT_TEST(testFinishAcksStanzas);

/*

CPPUNIT_TEST(testResourceBind);

CPPUNIT_TEST(testResourceBind_ChangeResource);

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

idnConverter = std::shared_ptr<IDNConverter>(PlatformIDNConverter::create());

server = std::make_shared<MockSessionStream>();

sessionFinishedReceived = false;

needCredentials = false;

session->start();

server->breakConnection();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendStreamStart();

server->sendStreamError();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendTLSFailure();

CPPUNIT_ASSERT(!server->tlsEncrypted);

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendTLSProceed();

server->breakTLS();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendTLSProceed();

CPPUNIT_ASSERT(server->tlsEncrypted);

server->onTLSEncrypted();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

CPPUNIT_ASSERT_EQUAL(CertificateVerificationError::InvalidServerIdentity, std::dynamic_pointer_cast<CertificateVerificationError>(sessionFinishedError)->getType());

}

server->sendStreamStart();

server->sendEmptyStreamFeatures();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendStreamStart();

server->sendStreamFeaturesWithPLAINAuthentication();

CPPUNIT_ASSERT(needCredentials);

session->sendCredentials(createSafeByteArray("mypass"));

server->receiveAuthRequest("PLAIN");

server->sendAuthSuccess();

server->sendStreamStart();

server->sendStreamFeaturesWithPLAINAuthentication();

CPPUNIT_ASSERT(needCredentials);

session->sendCredentials(createSafeByteArray("mypass"));

server->receiveAuthRequest("PLAIN");

server->sendAuthFailure();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendStreamStart();

server->sendStreamFeaturesWithPLAINAuthentication();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->receiveStreamStart();

server->sendStreamStart();

server->sendStreamFeaturesWithMultipleAuthentication();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendStreamStart();

server->sendStreamFeaturesWithUnknownAuthentication();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

server->sendChallenge();

server->sendChallenge();

CPPUNIT_ASSERT(sessionFinishedReceived);

CPPUNIT_ASSERT(sessionFinishedError);

}

CPPUNIT_ASSERT(session->getStreamManagementEnabled());

// TODO: Test if the requesters & responders do their work

session->finish();

}

server->sendStreamManagementFailed();

CPPUNIT_ASSERT(!session->getStreamManagementEnabled());

session->finish();

}

server->receiveAck(3);

}

private:

std::shared_ptr<ClientSession> createSession() {

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

session->onNeedCredentials.connect(boost::bind(&ClientSessionTest::handleSessionNeedCredentials, this));

session->setAllowPLAINOverNonTLS(true);

std::shared_ptr<Error> sessionFinishedError;

BlindCertificateTrustChecker* blindCertificateTrustChecker;

std::shared_ptr<CryptoProvider> crypto;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ClientSessionTest);

tlsOptions_(tlsOptions) {

xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, xmlParserFactory, streamType);

xmppLayer->onStreamStart.connect(boost::bind(&BasicSessionStream::handleStreamStartReceived, this, _1));

xmppLayer->onElement.connect(boost::bind(&BasicSessionStream::handleElementReceived, this, _1));

xmppLayer->onError.connect(boost::bind(&BasicSessionStream::handleXMPPError, this));

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

delete connectionLayer;

xmppLayer->onStreamStart.disconnect(boost::bind(&BasicSessionStream::handleStreamStartReceived, this, _1));

xmppLayer->onElement.disconnect(boost::bind(&BasicSessionStream::handleElementReceived, this, _1));

xmppLayer->onError.disconnect(boost::bind(&BasicSessionStream::handleXMPPError, this));

xmppLayer->onDataRead.disconnect(boost::bind(&BasicSessionStream::handleDataRead, this, _1));

onStreamStartReceived(header);

}

void BasicSessionStream::handleElementReceived(std::shared_ptr<ToplevelElement> element) {

onElementReceived(element);

}

void handleTLSConnected();

void handleTLSError(std::shared_ptr<TLSError>);

void handleStreamStartReceived(const ProtocolHeader&);

void handleElementReceived(std::shared_ptr<ToplevelElement>);

void handleDataRead(const SafeByteArray& data);

void handleDataWritten(const SafeByteArray& data);

virtual ByteArray getTLSFinishMessage() const = 0;

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

boost::signals2::signal<void (std::shared_ptr<ToplevelElement>)> onElementReceived;

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

boost::signals2::signal<void ()> onTLSEncrypted;

}

void XMPPLayer::handleStreamEnd() {

}

void XMPPLayer::resetParser() {

public:

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

boost::signals2::signal<void (std::shared_ptr<ToplevelElement>)> onElement;

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

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