initial/final commitHEADmaster

18 files changed, 2701 insertions, 0 deletions

diff --git a/vmime-master/src/vmime/security/sasl/SASLAuthenticator.hpp b/vmime-master/src/vmime/security/sasl/SASLAuthenticator.hpp
new file mode 100644
index 0000000..a75bfa0
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLAuthenticator.hpp
@@ -0,0 +1,96 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_SASLAUTHENTICATOR_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_SASLAUTHENTICATOR_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/types.hpp"
+
+#include "vmime/security/authenticator.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLMechanism;
+class SASLSession;
+
+
+/** SASL-aware authenticator.
+  *
+  * Usually, you should not inherit from this class, but instead from the
+  * more convenient defaultSASLAuthenticator class.
+  */
+class VMIME_EXPORT SASLAuthenticator : public authenticator {
+
+public:
+
+	/** This method is called to allow the client to choose the
+	  * authentication mechanisms that will be used. By default,
+	  * the most secure mechanisms are chosen.
+	  *
+	  * @param available available mechanisms
+	  * @param suggested suggested mechanism (or NULL if the system
+	  * could not suggest a mechanism)
+	  * @return ordered list of mechanism to use among the available
+	  * mechanisms (from the first to try to the last)
+	  */
+	virtual const std::vector <shared_ptr <SASLMechanism> > getAcceptableMechanisms(
+		const std::vector <shared_ptr <SASLMechanism> >& available,
+		const shared_ptr <SASLMechanism>& suggested
+	) const = 0;
+
+	/** Set the SASL session which is using this authenticator.
+	  *
+	  * @param sess SASL session
+	  */
+	virtual void setSASLSession(const shared_ptr <SASLSession>& sess) = 0;
+
+	/** Set the SASL mechanism which has been selected for the
+	  * SASL authentication process. This may be called several times
+	  * if the multiple mechanisms are tried by the service which
+	  * use this authentication.
+	  *
+	  * @param mech SASL mechanism
+	  */
+	virtual void setSASLMechanism(const shared_ptr <SASLMechanism>& mech) = 0;
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_SASLAUTHENTICATOR_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/SASLContext.cpp b/vmime-master/src/vmime/security/sasl/SASLContext.cpp
new file mode 100644
index 0000000..2174541
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLContext.cpp
@@ -0,0 +1,221 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include <sstream>
+
+#include <gsasl.h>
+
+#include "vmime/security/sasl/SASLContext.hpp"
+#include "vmime/security/sasl/SASLMechanism.hpp"
+
+#include "vmime/base.hpp"
+
+#include "vmime/utility/encoder/encoderFactory.hpp"
+
+#include "vmime/utility/stream.hpp"
+#include "vmime/utility/outputStreamStringAdapter.hpp"
+#include "vmime/utility/inputStreamStringAdapter.hpp"
+#include "vmime/utility/inputStreamByteBufferAdapter.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+SASLContext::SASLContext() {
+
+	if (gsasl_init(&m_gsaslContext) != GSASL_OK) {
+		throw std::bad_alloc();
+	}
+}
+
+
+SASLContext::~SASLContext() {
+
+	gsasl_done(m_gsaslContext);
+}
+
+
+// static
+shared_ptr <SASLContext> SASLContext::create() {
+
+	return shared_ptr <SASLContext>(new SASLContext());
+}
+
+
+shared_ptr <SASLSession> SASLContext::createSession(
+	const string& serviceName,
+	const shared_ptr <authenticator>& auth,
+	const shared_ptr <SASLMechanism>& mech
+) {
+
+	return SASLSession::create
+		(serviceName, dynamicCast <SASLContext>(shared_from_this()), auth, mech);
+}
+
+
+shared_ptr <SASLMechanism> SASLContext::createMechanism(const string& name) {
+
+	return SASLMechanismFactory::getInstance()->create(
+		dynamicCast <SASLContext>(shared_from_this()), name
+	);
+}
+
+
+shared_ptr <SASLMechanism> SASLContext::suggestMechanism(
+	const std::vector <shared_ptr <SASLMechanism> >& mechs
+) {
+
+	if (mechs.empty()) {
+		return null;
+	}
+
+	std::ostringstream oss;
+
+	for (unsigned int i = 0 ; i < mechs.size() ; ++i) {
+		oss << mechs[i]->getName() << " ";
+	}
+
+	const string mechList = oss.str();
+	const char* suggested = gsasl_client_suggest_mechanism(m_gsaslContext, mechList.c_str());
+
+	if (suggested) {
+
+		for (unsigned int i = 0 ; i < mechs.size() ; ++i) {
+
+			if (mechs[i]->getName() == suggested) {
+				return mechs[i];
+			}
+		}
+	}
+
+	return null;
+}
+
+
+void SASLContext::decodeB64(const string& input, byte_t** output, size_t* outputLen) {
+
+	string res;
+
+	utility::inputStreamStringAdapter is(input);
+	utility::outputStreamStringAdapter os(res);
+
+	shared_ptr <utility::encoder::encoder> dec =
+		utility::encoder::encoderFactory::getInstance()->create("base64");
+
+	dec->decode(is, os);
+
+	byte_t* out = new byte_t[res.length()];
+
+	std::copy(res.begin(), res.end(), out);
+
+	*output = out;
+	*outputLen = res.length();
+}
+
+
+const string SASLContext::encodeB64(const byte_t* input, const size_t inputLen) {
+
+	string res;
+
+	utility::inputStreamByteBufferAdapter is(input, inputLen);
+	utility::outputStreamStringAdapter os(res);
+
+	shared_ptr <utility::encoder::encoder> enc =
+		utility::encoder::encoderFactory::getInstance()->create("base64");
+
+	enc->encode(is, os);
+
+	return res;
+}
+
+
+const string SASLContext::getErrorMessage(const string& fname, const int code) {
+
+	string msg = fname + "() returned ";
+
+#define ERROR(x) \
+	case x: msg += #x; break;
+
+	switch (code)
+	{
+		ERROR(GSASL_NEEDS_MORE)
+		ERROR(GSASL_UNKNOWN_MECHANISM)
+		ERROR(GSASL_MECHANISM_CALLED_TOO_MANY_TIMES)
+		ERROR(GSASL_MALLOC_ERROR)
+		ERROR(GSASL_BASE64_ERROR)
+		ERROR(GSASL_CRYPTO_ERROR)
+		ERROR(GSASL_SASLPREP_ERROR)
+		ERROR(GSASL_MECHANISM_PARSE_ERROR)
+		ERROR(GSASL_AUTHENTICATION_ERROR)
+		ERROR(GSASL_INTEGRITY_ERROR)
+		ERROR(GSASL_NO_CLIENT_CODE)
+		ERROR(GSASL_NO_SERVER_CODE)
+		ERROR(GSASL_NO_CALLBACK)
+		ERROR(GSASL_NO_ANONYMOUS_TOKEN)
+		ERROR(GSASL_NO_AUTHID)
+		ERROR(GSASL_NO_AUTHZID)
+		ERROR(GSASL_NO_PASSWORD)
+		ERROR(GSASL_NO_PASSCODE)
+		ERROR(GSASL_NO_PIN)
+		ERROR(GSASL_NO_SERVICE)
+		ERROR(GSASL_NO_HOSTNAME)
+		ERROR(GSASL_GSSAPI_RELEASE_BUFFER_ERROR)
+		ERROR(GSASL_GSSAPI_IMPORT_NAME_ERROR)
+		ERROR(GSASL_GSSAPI_INIT_SEC_CONTEXT_ERROR)
+		ERROR(GSASL_GSSAPI_ACCEPT_SEC_CONTEXT_ERROR)
+		ERROR(GSASL_GSSAPI_UNWRAP_ERROR)
+		ERROR(GSASL_GSSAPI_WRAP_ERROR)
+		ERROR(GSASL_GSSAPI_ACQUIRE_CRED_ERROR)
+		ERROR(GSASL_GSSAPI_DISPLAY_NAME_ERROR)
+		ERROR(GSASL_GSSAPI_UNSUPPORTED_PROTECTION_ERROR)
+		ERROR(GSASL_KERBEROS_V5_INIT_ERROR)
+		ERROR(GSASL_KERBEROS_V5_INTERNAL_ERROR)
+		ERROR(GSASL_SECURID_SERVER_NEED_ADDITIONAL_PASSCODE)
+		ERROR(GSASL_SECURID_SERVER_NEED_NEW_PIN)
+
+		default:
+
+			msg += "unknown error";
+			break;
+	}
+
+#undef ERROR
+
+	return msg;
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/SASLContext.hpp b/vmime-master/src/vmime/security/sasl/SASLContext.hpp
new file mode 100644
index 0000000..93d80ff
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLContext.hpp
@@ -0,0 +1,136 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_SASLCONTEXT_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_SASLCONTEXT_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/types.hpp"
+
+#include "vmime/security/sasl/SASLSession.hpp"
+#include "vmime/security/sasl/SASLMechanismFactory.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+/** An SASL client context.
+  */
+class VMIME_EXPORT SASLContext : public object, public enable_shared_from_this <SASLContext> {
+
+	friend class SASLSession;
+	friend class builtinSASLMechanism;
+
+public:
+
+	~SASLContext();
+
+	/** Construct and initialize a new SASL context.
+	  *
+	  * @return pointer to a new SASL context
+	  */
+	static shared_ptr <SASLContext> create();
+
+	/** Create and initialize a new SASL session.
+	  *
+	  * @param serviceName name of the service which will use the session
+	  * @param auth authenticator object to use during the session
+	  * @param mech SASL mechanism
+	  * @return a new SASL session
+	  */
+	shared_ptr <SASLSession> createSession(
+		const string& serviceName,
+		const shared_ptr <authenticator>& auth,
+		const shared_ptr <SASLMechanism>& mech
+	);
+
+	/** Create an instance of an SASL mechanism.
+	  *
+	  * @param name mechanism name
+	  * @return a new instance of the specified SASL mechanism
+	  * @throw exceptions::no_such_mechanism if no mechanism is
+	  * registered for the specified name
+	  */
+	shared_ptr <SASLMechanism> createMechanism(const string& name);
+
+	/** Suggests an SASL mechanism among a set of mechanisms
+	  * supported by the server.
+	  *
+	  * @param mechs list of mechanisms
+	  * @return suggested mechanism (usually the safest mechanism
+	  * supported by both the client and the server)
+	  */
+	shared_ptr <SASLMechanism> suggestMechanism(
+		const std::vector <shared_ptr <SASLMechanism> >& mechs
+	);
+
+	/** Helper function for decoding Base64-encoded challenge.
+	  *
+	  * @param input input buffer
+	  * @param output output buffer
+	  * @param outputLen length of output buffer
+	  */
+	void decodeB64(const string& input, byte_t** output, size_t* outputLen);
+
+	/** Helper function for encoding challenge in Base64.
+	  *
+	  * @param input input buffer
+	  * @param inputLen length of input buffer
+	  * @return Base64-encoded challenge
+	  */
+	const string encodeB64(const byte_t* input, const size_t inputLen);
+
+private:
+
+	SASLContext();
+	SASLContext(SASLContext&);
+
+
+	static const string getErrorMessage(const string& fname, const int code);
+
+
+#ifdef GSASL_VERSION
+	Gsasl* m_gsaslContext;
+#else
+	void* m_gsaslContext;
+#endif // GSASL_VERSION
+
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_SASLCONTEXT_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/SASLMechanism.hpp b/vmime-master/src/vmime/security/sasl/SASLMechanism.hpp
new file mode 100644
index 0000000..a6e056d
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLMechanism.hpp
@@ -0,0 +1,153 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_SASLMECHANISM_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_SASLMECHANISM_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/types.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLSession;
+
+
+/** An SASL mechanism.
+  */
+class VMIME_EXPORT SASLMechanism : public object {
+
+public:
+
+	/** Return the name of this mechanism.
+	  *
+	  * @return mechanism name
+	  */
+	virtual const string getName() const = 0;
+
+	/** Perform one step of SASL authentication. Accept data from the
+	  * server (challenge), process it and return data to be returned
+	  * in response to the server.
+	  *
+	  * If the challenge is empty (challengeLen == 0), the initial
+	  * response is returned, if this mechanism has one.
+	  *
+	  * @param sess SASL session
+	  * @param challenge challenge sent from the server
+	  * @param challengeLen length of challenge
+	  * @param response response to send to the server (allocated by
+	  * this function, free with delete[])
+	  * @param responseLen length of response buffer
+	  * @return true if authentication terminated successfully, or
+	  * false if the authentication process should continue
+	  * @throw exceptions::sasl_exception if an error occurred during
+	  * authentication (in this case, the values in 'response' and
+	  * 'responseLen' are undetermined)
+	  */
+	virtual bool step(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* challenge,
+		const size_t challengeLen,
+		byte_t** response,
+		size_t* responseLen
+	) = 0;
+
+	/** Check whether authentication has completed. If false, more
+	  * calls to evaluateChallenge() are needed to complete the
+	  * authentication process).
+	  *
+	  * @return true if the authentication has finished, or false
+	  * otherwise
+	  */
+	virtual bool isComplete() const = 0;
+
+	/** Determine if this mechanism has an optional initial response.
+	  * If true, caller should call step() with an empty challenge to
+	  * get the initial response.
+	  *
+	  * @return true if this mechanism has an initial response, or
+	  * false otherwise
+	  */
+	virtual bool hasInitialResponse() const = 0;
+
+	/** Encode data according to negotiated SASL mechanism. This
+	  * might mean that data is integrity or privacy protected.
+	  *
+	  * @param sess SASL session
+	  * @param input input buffer
+	  * @param inputLen length of input buffer
+	  * @param output output buffer (allocated bu the function,
+	  * free with delete[])
+	  * @param outputLen length of output buffer
+	  * @throw exceptions::sasl_exception if an error occurred during
+	  * the encoding of data (in this case, the values in 'output' and
+	  * 'outputLen' are undetermined)
+	  */
+	virtual void encode(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* input,
+		const size_t inputLen,
+		byte_t** output,
+		size_t* outputLen
+	) = 0;
+
+	/** Decode data according to negotiated SASL mechanism. This
+	  * might mean that data is integrity or privacy protected.
+	  *
+	  * @param sess SASL session
+	  * @param input input buffer
+	  * @param inputLen length of input buffer
+	  * @param output output buffer (allocated bu the function,
+	  * free with delete[])
+	  * @param outputLen length of output buffer
+	  * @throw exceptions::sasl_exception if an error occurred during
+	  * the encoding of data (in this case, the values in 'output' and
+	  * 'outputLen' are undetermined)
+	  */
+	virtual void decode(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* input,
+		const size_t inputLen,
+		byte_t** output,
+		size_t* outputLen
+	) = 0;
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_SASLMECHANISM_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/SASLMechanismFactory.cpp b/vmime-master/src/vmime/security/sasl/SASLMechanismFactory.cpp
new file mode 100644
index 0000000..a2fbedb
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLMechanismFactory.cpp
@@ -0,0 +1,149 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include <stdexcept>
+#include <new>
+
+#include <gsasl.h>
+
+#include "vmime/security/sasl/SASLMechanismFactory.hpp"
+#include "vmime/security/sasl/builtinSASLMechanism.hpp"
+#include "vmime/security/sasl/SASLContext.hpp"
+
+#include "vmime/utility/stringUtils.hpp"
+
+#include "vmime/base.hpp"
+#include "vmime/exception.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+SASLMechanismFactory::SASLMechanismFactory() {
+
+	if (gsasl_init(&m_gsaslContext) != GSASL_OK) {
+		throw std::bad_alloc();
+	}
+}
+
+
+SASLMechanismFactory::~SASLMechanismFactory() {
+
+	gsasl_done(m_gsaslContext);
+}
+
+
+// static
+SASLMechanismFactory* SASLMechanismFactory::getInstance() {
+
+	static SASLMechanismFactory instance;
+	return &instance;
+}
+
+
+shared_ptr <SASLMechanism> SASLMechanismFactory::create(
+	const shared_ptr <SASLContext>& ctx,
+	const string& name_
+) {
+
+	const string name(utility::stringUtils::toUpper(name_));
+
+	// Check for registered mechanisms
+	MapType::iterator it = m_mechs.find(name);
+
+	if (it != m_mechs.end()) {
+		return (*it).second->create(ctx, name);
+	}
+
+	// Check for built-in mechanisms
+	if (isBuiltinMechanism(name)) {
+		return make_shared <builtinSASLMechanism>(ctx, name);
+	}
+
+	throw exceptions::no_such_mechanism(name);
+	return null;
+}
+
+
+const std::vector <string> SASLMechanismFactory::getSupportedMechanisms() const {
+
+	std::vector <string> list;
+
+	// Registered mechanisms
+	for (MapType::const_iterator it = m_mechs.begin() ;
+	     it != m_mechs.end() ; ++it) {
+
+		list.push_back((*it).first);
+	}
+
+	// Built-in mechanisms
+	char* out = 0;
+
+	if (gsasl_client_mechlist(m_gsaslContext, &out) == GSASL_OK) {
+
+		// 'out' contains SASL mechanism names, separated by spaces
+		for (char *start = out, *p = out ; ; ++p) {
+
+			if (*p == ' ' || !*p) {
+
+				list.push_back(string(start, p));
+				start = p + 1;
+
+				// End of string
+				if (!*p) break;
+			}
+		}
+
+		gsasl_free(out);
+	}
+
+	return list;
+}
+
+
+bool SASLMechanismFactory::isMechanismSupported(const string& name) const {
+
+	return isBuiltinMechanism(name) || m_mechs.find(name) != m_mechs.end();
+}
+
+
+bool SASLMechanismFactory::isBuiltinMechanism(const string& name) const {
+
+	return gsasl_client_support_p(m_gsaslContext, name.c_str()) != 0;
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/SASLMechanismFactory.hpp b/vmime-master/src/vmime/security/sasl/SASLMechanismFactory.hpp
new file mode 100644
index 0000000..af76c96
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLMechanismFactory.hpp
@@ -0,0 +1,155 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_SASLMECHANISMFACTORY_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_SASLMECHANISMFACTORY_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/types.hpp"
+#include "vmime/base.hpp"
+
+#include "vmime/security/sasl/SASLMechanism.hpp"
+
+#include <map>
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLContext;
+
+
+/** Constructs SASL mechanism objects.
+  */
+class VMIME_EXPORT SASLMechanismFactory : public object {
+
+private:
+
+	SASLMechanismFactory();
+	~SASLMechanismFactory();
+
+
+	struct registeredMechanism : public object {
+
+		virtual shared_ptr <SASLMechanism> create(
+			const shared_ptr <SASLContext>& ctx, const string& name
+		) = 0;
+	};
+
+	template <typename T>
+	struct registeredMechanismImpl : public registeredMechanism {
+
+		shared_ptr <SASLMechanism> create(
+			const shared_ptr <SASLContext>& ctx,
+			const string& name
+		) {
+
+			return vmime::make_shared <T>(ctx, name);
+		}
+	};
+
+	typedef std::map <string, shared_ptr <registeredMechanism> > MapType;
+	MapType m_mechs;
+
+public:
+
+	static SASLMechanismFactory* getInstance();
+
+	/** Register a mechanism into this factory, so that subsequent
+	  * calls to create return a valid object for this mechanism.
+	  *
+	  * @param name mechanism name
+	  */
+	template <typename MECH_CLASS>
+	void registerMechanism(const string& name) {
+
+		m_mechs.insert(
+			MapType::value_type(
+				name,
+				vmime::make_shared <registeredMechanismImpl <MECH_CLASS> >()
+			)
+		);
+	}
+
+	/** Create a mechanism object given its name.
+	  *
+	  * @param ctx SASL context
+	  * @param name mechanism name
+	  * @return a new mechanism object
+	  * @throw exceptions::no_such_mechanism if no mechanism is
+	  * registered for the specified name
+	  */
+	shared_ptr <SASLMechanism> create(const shared_ptr <SASLContext>& ctx, const string& name);
+
+	/** Return a list of supported mechanisms. This includes mechanisms
+	  * registered using registerMechanism() as well as the ones that
+	  * are built-in.
+	  *
+	  * @return list of supported mechanisms
+	  */
+	const std::vector <string> getSupportedMechanisms() const;
+
+	/** Test whether an authentication mechanism is supported.
+	  *
+	  * @param name mechanism name
+	  * @return true if the specified mechanism is supported,
+	  * false otherwise
+	  */
+	bool isMechanismSupported(const string& name) const;
+
+	/** Test whether an authentication mechanism is directly supported
+	  * by the underlying SASL library.
+	  *
+	  * @param name mechanism name
+	  * @return true if the specified mechanism is built-in,
+	  * or false otherwise
+	  */
+	bool isBuiltinMechanism(const string& name) const;
+
+private:
+
+#ifdef GSASL_VERSION
+	Gsasl* m_gsaslContext;
+#else
+	void* m_gsaslContext;
+#endif // GSASL_VERSION
+
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_SASLMECHANISMFACTORY_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/SASLSession.cpp b/vmime-master/src/vmime/security/sasl/SASLSession.cpp
new file mode 100644
index 0000000..7498b46
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLSession.cpp
@@ -0,0 +1,221 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include <sstream>
+
+#include <gsasl.h>
+
+#include "vmime/security/sasl/SASLSession.hpp"
+
+#include "vmime/security/sasl/SASLContext.hpp"
+#include "vmime/security/sasl/SASLSocket.hpp"
+#include "vmime/security/sasl/SASLAuthenticator.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+SASLSession::SASLSession(
+	const string& serviceName,
+	const shared_ptr <SASLContext>& ctx,
+	const shared_ptr <authenticator>& auth,
+	const shared_ptr <SASLMechanism>& mech
+)
+	: m_serviceName(serviceName),
+	  m_context(ctx),
+	  m_auth(auth),
+	  m_mech(mech),
+	  m_gsaslContext(0),
+	  m_gsaslSession(0) {
+
+	if (gsasl_init(&m_gsaslContext) != GSASL_OK) {
+		throw std::bad_alloc();
+	}
+
+	gsasl_client_start(m_gsaslContext, mech->getName().c_str(), &m_gsaslSession);
+
+	gsasl_callback_set(m_gsaslContext, gsaslCallback);
+	gsasl_callback_hook_set(m_gsaslContext, this);
+}
+
+
+SASLSession::~SASLSession() {
+
+	gsasl_finish(m_gsaslSession);
+	m_gsaslSession = NULL;
+
+	gsasl_done(m_gsaslContext);
+	m_gsaslContext = NULL;
+}
+
+
+// static
+shared_ptr <SASLSession> SASLSession::create(
+	const string& serviceName,
+	const shared_ptr <SASLContext>& ctx,
+	const shared_ptr <authenticator>& auth,
+	const shared_ptr <SASLMechanism>& mech
+) {
+
+	return shared_ptr <SASLSession>(new SASLSession(serviceName, ctx, auth, mech));
+}
+
+
+void SASLSession::init() {
+
+	shared_ptr <SASLAuthenticator> saslAuth = dynamicCast <SASLAuthenticator>(m_auth);
+
+	if (saslAuth) {
+		saslAuth->setSASLMechanism(m_mech);
+		saslAuth->setSASLSession(dynamicCast <SASLSession>(shared_from_this()));
+	}
+}
+
+
+shared_ptr <authenticator> SASLSession::getAuthenticator() {
+
+	return m_auth;
+}
+
+
+shared_ptr <SASLMechanism> SASLSession::getMechanism() {
+
+	return m_mech;
+}
+
+
+shared_ptr <SASLContext> SASLSession::getContext() {
+
+	return m_context;
+}
+
+
+bool SASLSession::evaluateChallenge(
+	const byte_t* challenge,
+	const size_t challengeLen,
+	byte_t** response,
+	size_t* responseLen
+) {
+
+	return m_mech->step(
+		dynamicCast <SASLSession>(shared_from_this()),
+		challenge, challengeLen, response, responseLen
+	);
+}
+
+
+shared_ptr <net::socket> SASLSession::getSecuredSocket(const shared_ptr <net::socket>& sok) {
+
+	return make_shared <SASLSocket>(dynamicCast <SASLSession>(shared_from_this()), sok);
+}
+
+
+const string SASLSession::getServiceName() const {
+
+	return m_serviceName;
+}
+
+
+// static
+int SASLSession::gsaslCallback(
+	Gsasl* ctx,
+	Gsasl_session* sctx,
+	Gsasl_property prop
+) {
+
+	SASLSession* sess = reinterpret_cast <SASLSession*>(gsasl_callback_hook_get(ctx));
+
+	if (!sess) {
+		return GSASL_AUTHENTICATION_ERROR;
+	}
+
+	shared_ptr <authenticator> auth = sess->getAuthenticator();
+
+	try {
+
+		string res;
+
+		switch (prop) {
+
+			case GSASL_AUTHID:
+
+				res = auth->getUsername();
+				break;
+
+			case GSASL_PASSWORD:
+
+				res = auth->getPassword();
+				break;
+
+			case GSASL_ANONYMOUS_TOKEN:
+
+				res = auth->getAnonymousToken();
+				break;
+
+			case GSASL_HOSTNAME:
+
+				res = auth->getHostname();
+				break;
+
+			case GSASL_SERVICE:
+
+				res = auth->getServiceName();
+				break;
+
+			case GSASL_AUTHZID:
+			case GSASL_GSSAPI_DISPLAY_NAME:
+			case GSASL_PASSCODE:
+			case GSASL_SUGGESTED_PIN:
+			case GSASL_PIN:
+			case GSASL_REALM:
+
+			default:
+
+				return GSASL_NO_CALLBACK;
+		}
+
+		gsasl_property_set(sctx, prop, res.c_str());
+
+		return GSASL_OK;
+
+	} catch (...) {
+
+		return GSASL_NO_CALLBACK;
+	}
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/SASLSession.hpp b/vmime-master/src/vmime/security/sasl/SASLSession.hpp
new file mode 100644
index 0000000..7fc7225
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLSession.hpp
@@ -0,0 +1,180 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_SASLSESSION_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_SASLSESSION_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/types.hpp"
+
+#include "vmime/net/socket.hpp"
+
+#include "vmime/security/sasl/SASLAuthenticator.hpp"
+#include "vmime/security/sasl/SASLMechanism.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLContext;
+
+
+/** An SASL client session.
+  */
+class VMIME_EXPORT SASLSession : public object, public enable_shared_from_this <SASLSession> {
+
+	friend class builtinSASLMechanism;
+	friend class SASLSocket;
+
+public:
+
+	~SASLSession();
+
+	/** Construct a new SASL session.
+	  *
+	  * @param serviceName name of the service using this session
+	  * @param ctx SASL context
+	  * @param auth authenticator to use for this session
+	  * @param mech SASL mechanism
+	  */
+	static shared_ptr <SASLSession> create(
+		const string& serviceName,
+		const shared_ptr <SASLContext>& ctx,
+		const shared_ptr <authenticator>& auth,
+		const shared_ptr <SASLMechanism>& mech
+	);
+
+	/** Initialize this SASL session. This must be called before
+	  * calling any other method on this object (except accessors).
+	  */
+	void init();
+
+	/** Return the authenticator used for this session. This is the
+	  * authenticator which has been previously set with a call to
+	  * setAuthenticator().
+	  *
+	  * @return authenticator object
+	  */
+	shared_ptr <authenticator> getAuthenticator();
+
+	/** Return the mechanism used for this session.
+	  *
+	  * @return SASL mechanism
+	  */
+	shared_ptr <SASLMechanism> getMechanism();
+
+	/** Return the SASL context.
+	  *
+	  * @return SASL context
+	  */
+	shared_ptr <SASLContext> getContext();
+
+	/** Perform one step of SASL authentication. Accept data from the
+	  * server (challenge), process it and return data to be returned
+	  * in response to the server.
+	  *
+	  * If the challenge is empty (challengeLen == 0), the initial
+	  * response is returned, if the mechanism has one.
+	  *
+	  * @param challenge challenge sent from the server
+	  * @param challengeLen length of challenge
+	  * @param response response to send to the server (allocated by
+	  * this function, free with delete[])
+	  * @param responseLen length of response buffer
+	  * @return true if authentication terminated successfully, or
+	  * false if the authentication process should continue
+	  * @throw exceptions::sasl_exception if an error occurred during
+	  * authentication (in this case, the values in 'response' and
+	  * 'responseLen' are undetermined)
+	  */
+	bool evaluateChallenge(
+		const byte_t* challenge,
+		const size_t challengeLen,
+		byte_t** response,
+		size_t* responseLen
+	);
+
+	/** Return a socket in which transmitted data is integrity
+	  * and/or privacy protected, depending on the QOP (Quality of
+	  * Protection) negotiated during the SASL authentication.
+	  *
+	  * @param sok socket to wrap
+	  * @return secured socket
+	  */
+	shared_ptr <net::socket> getSecuredSocket(const shared_ptr <net::socket>& sok);
+
+	/** Return the name of the service which is using this
+	  * SASL session (eg. "imap"). This value should be returned
+	  * by the authenticator when INFO_SERVICE is requested.
+	  *
+	  * @return service name
+	  */
+	const string getServiceName() const;
+
+private:
+
+	SASLSession(
+		const string& serviceName,
+		const shared_ptr <SASLContext>& ctx,
+		const shared_ptr <authenticator>& auth,
+		const shared_ptr <SASLMechanism>& mech
+	);
+
+
+	const string m_serviceName;
+
+	shared_ptr <SASLContext> m_context;
+	shared_ptr <authenticator> m_auth;
+	shared_ptr <SASLMechanism> m_mech;
+
+#ifdef GSASL_VERSION
+	Gsasl* m_gsaslContext;
+	Gsasl_session* m_gsaslSession;
+
+	static int gsaslCallback(Gsasl* ctx, Gsasl_session* sctx, Gsasl_property prop);
+#else
+	void* m_gsaslContext;
+	void* m_gsaslSession;
+
+	static int gsaslCallback(void* ctx, void* sctx, int prop);
+#endif // GSASL_VERSION
+
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_SASLSESSION_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/SASLSocket.cpp b/vmime-master/src/vmime/security/sasl/SASLSocket.cpp
new file mode 100644
index 0000000..0dbafd8
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLSocket.cpp
@@ -0,0 +1,273 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/SASLSocket.hpp"
+#include "vmime/security/sasl/SASLSession.hpp"
+
+#include "vmime/utility/stringUtils.hpp"
+
+#include "vmime/exception.hpp"
+
+#include <algorithm>
+#include <cstring>
+
+#include <gsasl.h>
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+
+SASLSocket::SASLSocket(
+	const shared_ptr <SASLSession>& sess,
+	const shared_ptr <net::socket>& wrapped
+)
+	: m_session(sess),
+	  m_wrapped(wrapped),
+	  m_pendingBuffer(0),
+	  m_pendingPos(0),
+	  m_pendingLen(0) {
+
+}
+
+
+SASLSocket::~SASLSocket() {
+
+	if (m_pendingBuffer) {
+		delete [] m_pendingBuffer;
+	}
+}
+
+
+void SASLSocket::connect(const string& address, const port_t port) {
+
+	m_wrapped->connect(address, port);
+}
+
+
+void SASLSocket::disconnect() {
+
+	m_wrapped->disconnect();
+}
+
+
+bool SASLSocket::isConnected() const {
+
+	return m_wrapped->isConnected();
+}
+
+
+size_t SASLSocket::getBlockSize() const {
+
+	return m_wrapped->getBlockSize();
+}
+
+
+const string SASLSocket::getPeerName() const {
+
+	return m_wrapped->getPeerName();
+}
+
+
+const string SASLSocket::getPeerAddress() const {
+
+	return m_wrapped->getPeerAddress();
+}
+
+
+shared_ptr <net::timeoutHandler> SASLSocket::getTimeoutHandler() {
+
+	return m_wrapped->getTimeoutHandler();
+}
+
+
+void SASLSocket::setTracer(const shared_ptr <net::tracer>& tracer) {
+
+	m_wrapped->setTracer(tracer);
+}
+
+
+shared_ptr <net::tracer> SASLSocket::getTracer() {
+
+	return m_wrapped->getTracer();
+}
+
+
+bool SASLSocket::waitForRead(const int msecs) {
+
+	return m_wrapped->waitForRead(msecs);
+}
+
+
+bool SASLSocket::waitForWrite(const int msecs) {
+
+	return m_wrapped->waitForWrite(msecs);
+}
+
+
+void SASLSocket::receive(string& buffer) {
+
+	const size_t n = receiveRaw(m_recvBuffer, sizeof(m_recvBuffer));
+
+	buffer = utility::stringUtils::makeStringFromBytes(m_recvBuffer, n);
+}
+
+
+size_t SASLSocket::receiveRaw(byte_t* buffer, const size_t count) {
+
+	if (m_pendingLen != 0) {
+
+		const size_t copyLen =
+			(count >= m_pendingLen ? m_pendingLen : count);
+
+		std::copy(
+			m_pendingBuffer + m_pendingPos,
+			m_pendingBuffer + m_pendingPos + copyLen,
+			buffer
+		);
+
+		m_pendingLen -= copyLen;
+		m_pendingPos += copyLen;
+
+		if (m_pendingLen == 0) {
+
+			delete [] m_pendingBuffer;
+
+			m_pendingBuffer = 0;
+			m_pendingPos = 0;
+			m_pendingLen = 0;
+		}
+
+		return copyLen;
+	}
+
+	const size_t n = m_wrapped->receiveRaw(buffer, count);
+
+	byte_t* output = 0;
+	size_t outputLen = 0;
+
+	m_session->getMechanism()->decode(m_session, buffer, n, &output, &outputLen);
+
+	// If we can not copy all decoded data into the output buffer, put
+	// remaining data into a pending buffer for next calls to receive()
+	if (outputLen > count) {
+
+		std::copy(output, output + count, buffer);
+
+		m_pendingBuffer = output;
+		m_pendingLen = outputLen;
+		m_pendingPos = count;
+
+		return count;
+
+	} else {
+
+		std::copy(output, output + outputLen, buffer);
+
+		delete [] output;
+
+		return outputLen;
+	}
+}
+
+
+void SASLSocket::send(const string& buffer) {
+
+	sendRaw(reinterpret_cast <const byte_t*>(buffer.data()), buffer.length());
+}
+
+
+void SASLSocket::send(const char* str) {
+
+	sendRaw(reinterpret_cast <const byte_t*>(str), strlen(str));
+}
+
+
+void SASLSocket::sendRaw(const byte_t* buffer, const size_t count) {
+
+	byte_t* output = 0;
+	size_t outputLen = 0;
+
+	m_session->getMechanism()->encode(
+		m_session, buffer, count, &output, &outputLen
+	);
+
+	try {
+
+		m_wrapped->sendRaw(output, outputLen);
+
+	} catch (...) {
+
+		delete [] output;
+		throw;
+	}
+
+	delete [] output;
+}
+
+
+size_t SASLSocket::sendRawNonBlocking(const byte_t* buffer, const size_t count) {
+
+	byte_t* output = 0;
+	size_t outputLen = 0;
+
+	m_session->getMechanism()->encode(m_session, buffer, count, &output, &outputLen);
+
+	size_t bytesSent = 0;
+
+	try {
+
+		bytesSent = m_wrapped->sendRawNonBlocking(output, outputLen);
+
+	} catch (...) {
+
+		delete [] output;
+		throw;
+	}
+
+	delete [] output;
+
+	return bytesSent;
+}
+
+
+unsigned int SASLSocket::getStatus() const {
+
+	return m_wrapped->getStatus();
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/SASLSocket.hpp b/vmime-master/src/vmime/security/sasl/SASLSocket.hpp
new file mode 100644
index 0000000..ac0e89e
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/SASLSocket.hpp
@@ -0,0 +1,108 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_SASLSOCKET_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_SASLSOCKET_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/types.hpp"
+
+#include "vmime/net/socket.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLSession;
+
+
+/** A socket which provides data integrity and/or privacy protection.
+  */
+class VMIME_EXPORT SASLSocket : public net::socket {
+
+public:
+
+	SASLSocket(
+		const shared_ptr <SASLSession>& sess,
+		const shared_ptr <net::socket>& wrapped
+	);
+
+	~SASLSocket();
+
+	void connect(const string& address, const port_t port);
+	void disconnect();
+
+	bool isConnected() const;
+
+	bool waitForRead(const int msecs = 30000);
+	bool waitForWrite(const int msecs = 30000);
+
+	void receive(string& buffer);
+	size_t receiveRaw(byte_t* buffer, const size_t count);
+
+	void send(const string& buffer);
+	void send(const char* str);
+	void sendRaw(const byte_t* buffer, const size_t count);
+	size_t sendRawNonBlocking(const byte_t* buffer, const size_t count);
+
+	size_t getBlockSize() const;
+
+	unsigned int getStatus() const;
+
+	const string getPeerName() const;
+	const string getPeerAddress() const;
+
+	shared_ptr <net::timeoutHandler> getTimeoutHandler();
+
+	void setTracer(const shared_ptr <net::tracer>& tracer);
+	shared_ptr <net::tracer> getTracer();
+
+private:
+
+	shared_ptr <SASLSession> m_session;
+	shared_ptr <net::socket> m_wrapped;
+
+	byte_t* m_pendingBuffer;
+	size_t m_pendingPos;
+	size_t m_pendingLen;
+
+	byte_t m_recvBuffer[65536];
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_SASLSOCKET_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/XOAuth2SASLAuthenticator.cpp b/vmime-master/src/vmime/security/sasl/XOAuth2SASLAuthenticator.cpp
new file mode 100644
index 0000000..ecc715a
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/XOAuth2SASLAuthenticator.cpp
@@ -0,0 +1,99 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/XOAuth2SASLAuthenticator.hpp"
+
+#include "vmime/security/sasl/SASLMechanism.hpp"
+#include "vmime/security/sasl/SASLSession.hpp"
+#include "vmime/security/sasl/SASLContext.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+XOAuth2SASLAuthenticator::XOAuth2SASLAuthenticator(const Mode mode)
+	: m_mode(mode) {
+
+}
+
+
+XOAuth2SASLAuthenticator::~XOAuth2SASLAuthenticator() {
+
+}
+
+
+const std::vector <shared_ptr <SASLMechanism> >
+	XOAuth2SASLAuthenticator::getAcceptableMechanisms(
+		const std::vector <shared_ptr <SASLMechanism> >& available,
+		const shared_ptr <SASLMechanism>& suggested
+	) const {
+
+	if (m_mode == MODE_EXCLUSIVE) {
+
+		std::vector <shared_ptr <SASLMechanism> > mechs;
+
+		for (size_t i = available.size() ; i != 0 ; --i) {
+
+			shared_ptr <SASLMechanism> mech = available[i - 1];
+
+			if ("XOAUTH2" == mech->getName()) {
+				// Only allow XOAuth2
+				mechs.push_back(mech);
+			}
+		}
+
+		return mechs;
+
+	} else {
+
+		shared_ptr <SASLMechanism> newSuggested(suggested);
+
+		for (size_t i = available.size() ; i != 0 ; --i) {
+
+			shared_ptr <SASLMechanism> mech = available[i - 1];
+
+			if ("XOAUTH2" == mech->getName()) {
+				// Suggest using XOAuth2
+				newSuggested = mech;
+			}
+		}
+
+		return defaultSASLAuthenticator::getAcceptableMechanisms(available, newSuggested);
+	}
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/XOAuth2SASLAuthenticator.hpp b/vmime-master/src/vmime/security/sasl/XOAuth2SASLAuthenticator.hpp
new file mode 100644
index 0000000..e4d3d83
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/XOAuth2SASLAuthenticator.hpp
@@ -0,0 +1,77 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_XOAUTH2SASLAUTHENTICATOR_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_XOAUTH2SASLAUTHENTICATOR_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/defaultSASLAuthenticator.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+/** An authenticator that is capable of providing information
+  * for XOAuth2 authentication mechanisms (username and access token).
+  * This authenticator force using the XOAUTH2 mechanism.
+  */
+class VMIME_EXPORT XOAuth2SASLAuthenticator : public defaultSASLAuthenticator {
+
+public:
+
+	enum Mode {
+		MODE_SUGGEST,    /**< Try XOAUTH2 before other mechanisms. */
+		MODE_EXCLUSIVE   /**< Use XOAUTH2 and nothing else. */
+	};
+
+
+	XOAuth2SASLAuthenticator(const Mode mode);
+	~XOAuth2SASLAuthenticator();
+
+	const std::vector <shared_ptr <SASLMechanism> > getAcceptableMechanisms(
+		const std::vector <shared_ptr <SASLMechanism> >& available,
+		const shared_ptr <SASLMechanism>& suggested
+	) const;
+
+private:
+
+	Mode m_mode;
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_XOAUTH2SASLAUTHENTICATOR_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/XOAuth2SASLMechanism.cpp b/vmime-master/src/vmime/security/sasl/XOAuth2SASLMechanism.cpp
new file mode 100644
index 0000000..e5ecd4b
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/XOAuth2SASLMechanism.cpp
@@ -0,0 +1,155 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/XOAuth2SASLMechanism.hpp"
+
+#include "vmime/security/sasl/SASLContext.hpp"
+#include "vmime/security/sasl/SASLSession.hpp"
+
+#include "vmime/exception.hpp"
+
+#include <sstream>
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+XOAuth2SASLMechanism::XOAuth2SASLMechanism(
+	const shared_ptr <SASLContext>& ctx,
+	const string& /* name */
+)
+	: m_context(ctx),
+	  m_complete(false) {
+
+}
+
+
+XOAuth2SASLMechanism::~XOAuth2SASLMechanism() {
+
+}
+
+
+const string XOAuth2SASLMechanism::getName() const {
+
+	return "XOAUTH2";
+}
+
+
+bool XOAuth2SASLMechanism::step(
+	const shared_ptr <SASLSession>& sess,
+	const byte_t* /* challenge */,
+	const size_t /* challengeLen */,
+	byte_t** response,
+	size_t* responseLen
+) {
+
+	// Build initial response
+	//
+	// The SASL XOAUTH2 initial client response has the following format:
+	//    base64("user=" {User} "^Aauth=Bearer " {Access Token} "^A^A")
+
+	const std::string user(sess->getAuthenticator()->getUsername());
+	const std::string accessToken(sess->getAuthenticator()->getAccessToken());
+
+	std::ostringstream initRespBytes;
+	initRespBytes.write("user=", 5);
+	initRespBytes.write(user.c_str(), user.length());
+	initRespBytes.write("\x01", 1);
+	initRespBytes.write("auth=Bearer ", 12);
+	initRespBytes.write(accessToken.c_str(), accessToken.length());
+	initRespBytes.write("\x01\x01", 2);
+
+	const std::string initResp = initRespBytes.str();
+
+	// Set initial response
+	byte_t* res = new byte_t[initResp.length()];
+	std::copy(initResp.c_str(), initResp.c_str() + initResp.length(), res);
+
+	*response = res;
+	*responseLen = initResp.length();
+	m_complete = true;
+
+	return true;
+}
+
+
+bool XOAuth2SASLMechanism::isComplete() const {
+
+	return m_complete;
+}
+
+
+bool XOAuth2SASLMechanism::hasInitialResponse() const {
+
+	return true;
+}
+
+
+void XOAuth2SASLMechanism::encode(
+	const shared_ptr <SASLSession>& /* sess */,
+	const byte_t* input,
+	const size_t inputLen,
+	byte_t** output,
+	size_t* outputLen
+) {
+
+	// No encoding performed, just copy input bytes
+	byte_t* res = new byte_t[inputLen];
+	std::copy(input, input + inputLen, res);
+
+	*outputLen = inputLen;
+	*output = res;
+}
+
+
+void XOAuth2SASLMechanism::decode(
+	const shared_ptr <SASLSession>& /* sess */,
+	const byte_t* input,
+	const size_t inputLen,
+	byte_t** output,
+	size_t* outputLen
+) {
+
+	// No decoding performed, just copy input bytes
+	byte_t* res = new byte_t[inputLen];
+	std::copy(input, input + inputLen, res);
+
+	*outputLen = inputLen;
+	*output = res;
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/XOAuth2SASLMechanism.hpp b/vmime-master/src/vmime/security/sasl/XOAuth2SASLMechanism.hpp
new file mode 100644
index 0000000..eacbb0a
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/XOAuth2SASLMechanism.hpp
@@ -0,0 +1,102 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_XOAUTH2SASLMECHANISM_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_XOAUTH2SASLMECHANISM_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/SASLMechanism.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLContext;
+
+
+/** SASL XOAUTH2 mechanism, used by GMail.
+  */
+class VMIME_EXPORT XOAuth2SASLMechanism : public SASLMechanism {
+
+public:
+
+	XOAuth2SASLMechanism(const shared_ptr <SASLContext>& ctx, const string& name);
+	~XOAuth2SASLMechanism();
+
+
+	const string getName() const;
+
+	bool step(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* challenge,
+		const size_t challengeLen,
+		byte_t** response,
+		size_t* responseLen
+	);
+
+	bool isComplete() const;
+
+	bool hasInitialResponse() const;
+
+	void encode(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* input,
+		const size_t inputLen,
+		byte_t** output,
+		size_t* outputLen
+	);
+
+	void decode(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* input,
+		const size_t inputLen,
+		byte_t** output,
+		size_t* outputLen
+	);
+
+private:
+
+	/** SASL context */
+	shared_ptr <SASLContext> m_context;
+
+	/** Authentication process status. */
+	bool m_complete;
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_XOAUTH2SASLMECHANISM_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/builtinSASLMechanism.cpp b/vmime-master/src/vmime/security/sasl/builtinSASLMechanism.cpp
new file mode 100644
index 0000000..846e2cc
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/builtinSASLMechanism.cpp
@@ -0,0 +1,221 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include <gsasl.h>
+
+#include "vmime/security/sasl/builtinSASLMechanism.hpp"
+
+#include "vmime/security/sasl/SASLContext.hpp"
+#include "vmime/security/sasl/SASLSession.hpp"
+
+#include "vmime/exception.hpp"
+
+#include <stdexcept>
+#include <new>
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+builtinSASLMechanism::builtinSASLMechanism(
+	const shared_ptr <SASLContext>& ctx,
+	const string& name
+)
+	: m_context(ctx),
+	  m_name(name),
+	  m_complete(false) {
+
+}
+
+
+builtinSASLMechanism::~builtinSASLMechanism() {
+
+}
+
+
+const string builtinSASLMechanism::getName() const {
+
+	return m_name;
+}
+
+
+bool builtinSASLMechanism::step(
+	const shared_ptr <SASLSession>& sess,
+	const byte_t* challenge,
+	const size_t challengeLen,
+	byte_t** response,
+	size_t* responseLen
+) {
+
+	char* output = 0;
+	size_t outputLen = 0;
+
+	const int result = gsasl_step(
+		sess->m_gsaslSession,
+		reinterpret_cast <const char*>(challenge), challengeLen,
+		&output, &outputLen
+	);
+
+	if (result == GSASL_OK || result == GSASL_NEEDS_MORE) {
+
+		byte_t* res = new byte_t[outputLen];
+
+		for (size_t i = 0 ; i < outputLen ; ++i) {
+			res[i] = output[i];
+		}
+
+		*response = res;
+		*responseLen = outputLen;
+
+		gsasl_free(output);
+
+	} else {
+
+		*response = 0;
+		*responseLen = 0;
+	}
+
+	if (result == GSASL_OK) {
+
+		// Authentication process completed
+		m_complete = true;
+		return true;
+
+	} else if (result == GSASL_NEEDS_MORE) {
+
+		// Continue authentication process
+		return false;
+
+	} else if (result == GSASL_MALLOC_ERROR) {
+
+		throw std::bad_alloc();
+
+	} else {
+
+		throw exceptions::sasl_exception(
+			"Error when processing challenge: "
+			+ SASLContext::getErrorMessage("gsasl_step", result)
+		);
+	}
+}
+
+
+bool builtinSASLMechanism::isComplete() const {
+
+	return m_complete;
+}
+
+
+bool builtinSASLMechanism::hasInitialResponse() const {
+
+	// It seems GNU SASL does not support initial response
+	return false;
+}
+
+
+void builtinSASLMechanism::encode(
+	const shared_ptr <SASLSession>& sess,
+	const byte_t* input,
+	const size_t inputLen,
+	byte_t** output,
+	size_t* outputLen
+) {
+
+	char* coutput = 0;
+	size_t coutputLen = 0;
+
+	if (gsasl_encode(sess->m_gsaslSession, reinterpret_cast <const char*>(input), inputLen,
+			&coutput, &coutputLen) != GSASL_OK) {
+
+		throw exceptions::sasl_exception("Encoding error.");
+	}
+
+	try {
+
+		byte_t* res = new byte_t[coutputLen];
+
+		std::copy(coutput, coutput + coutputLen, res);
+
+		*output = res;
+		*outputLen = static_cast <int>(coutputLen);
+
+	} catch (...) {
+
+		gsasl_free(coutput);
+		throw;
+	}
+
+	gsasl_free(coutput);
+}
+
+
+void builtinSASLMechanism::decode(
+	const shared_ptr <SASLSession>& sess,
+	const byte_t* input,
+	const size_t inputLen,
+	byte_t** output,
+	size_t* outputLen
+) {
+
+	char* coutput = 0;
+	size_t coutputLen = 0;
+
+	try {
+
+		if (gsasl_decode(sess->m_gsaslSession, reinterpret_cast <const char*>(input), inputLen,
+				&coutput, &coutputLen) != GSASL_OK) {
+
+			throw exceptions::sasl_exception("Decoding error.");
+		}
+
+		byte_t* res = new byte_t[coutputLen];
+
+		std::copy(coutput, coutput + coutputLen, res);
+
+		*output = res;
+		*outputLen = static_cast <int>(coutputLen);
+
+	} catch (...) {
+
+		gsasl_free(coutput);
+		throw;
+	}
+
+	gsasl_free(coutput);
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/builtinSASLMechanism.hpp b/vmime-master/src/vmime/security/sasl/builtinSASLMechanism.hpp
new file mode 100644
index 0000000..2e412d6
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/builtinSASLMechanism.hpp
@@ -0,0 +1,105 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_BUILTINSASLMECHANISM_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_BUILTINSASLMECHANISM_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/SASLMechanism.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+class SASLContext;
+
+
+/** A built-in authentication mechanism that relies on
+  * the GNU SASL library.
+  */
+class VMIME_EXPORT builtinSASLMechanism : public SASLMechanism {
+
+public:
+
+	builtinSASLMechanism(const shared_ptr <SASLContext>& ctx, const string& name);
+	~builtinSASLMechanism();
+
+
+	const string getName() const;
+
+	bool step(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* challenge,
+		const size_t challengeLen,
+		byte_t** response, size_t* responseLen
+	);
+
+	bool isComplete() const;
+
+	bool hasInitialResponse() const;
+
+	void encode(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* input,
+		const size_t inputLen,
+		byte_t** output,
+		size_t* outputLen
+	);
+
+	void decode(
+		const shared_ptr <SASLSession>& sess,
+		const byte_t* input,
+		const size_t inputLen,
+		byte_t** output,
+		size_t* outputLen
+	);
+
+private:
+
+	/** SASL context */
+	shared_ptr <SASLContext> m_context;
+
+	/** Mechanism name */
+	const string m_name;
+
+	/** Authentication process status. */
+	bool m_complete;
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_BUILTINSASLMECHANISM_HPP_INCLUDED
diff --git a/vmime-master/src/vmime/security/sasl/defaultSASLAuthenticator.cpp b/vmime-master/src/vmime/security/sasl/defaultSASLAuthenticator.cpp
new file mode 100644
index 0000000..ebd7e68
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/defaultSASLAuthenticator.cpp
@@ -0,0 +1,159 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/defaultSASLAuthenticator.hpp"
+
+#include "vmime/security/sasl/SASLMechanism.hpp"
+#include "vmime/security/sasl/SASLSession.hpp"
+#include "vmime/security/sasl/SASLContext.hpp"
+
+#include "vmime/net/service.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+defaultSASLAuthenticator::defaultSASLAuthenticator() {
+
+}
+
+
+defaultSASLAuthenticator::~defaultSASLAuthenticator() {
+
+}
+
+
+const std::vector <shared_ptr <SASLMechanism> > defaultSASLAuthenticator::getAcceptableMechanisms(
+	const std::vector <shared_ptr <SASLMechanism> >& available,
+	const shared_ptr <SASLMechanism>& suggested
+) const {
+
+	if (suggested) {
+
+		std::vector <shared_ptr <SASLMechanism> > res;
+
+		res.push_back(suggested);
+
+		for (unsigned int i = 0 ; i < available.size() ; ++i) {
+
+			if (available[i]->getName() != suggested->getName()) {
+				res.push_back(available[i]);
+			}
+		}
+
+		return res;
+
+	} else {
+
+		return available;
+	}
+}
+
+
+const string defaultSASLAuthenticator::getUsername() const {
+
+	return m_default.getUsername();
+}
+
+
+const string defaultSASLAuthenticator::getPassword() const {
+
+	return m_default.getPassword();
+}
+
+
+const string defaultSASLAuthenticator::getAccessToken() const {
+
+	return m_default.getAccessToken();
+}
+
+
+const string defaultSASLAuthenticator::getHostname() const {
+
+	return m_default.getHostname();
+}
+
+
+const string defaultSASLAuthenticator::getAnonymousToken() const {
+
+	return m_default.getAnonymousToken();
+}
+
+
+const string defaultSASLAuthenticator::getServiceName() const {
+
+	return m_saslSession.lock()->getServiceName();
+}
+
+
+void defaultSASLAuthenticator::setService(const shared_ptr <net::service>& serv) {
+
+	m_service = serv;
+	m_default.setService(serv);
+}
+
+
+weak_ptr <net::service> defaultSASLAuthenticator::getService() const {
+
+	return m_service;
+}
+
+
+void defaultSASLAuthenticator::setSASLSession(const shared_ptr <SASLSession>& sess) {
+
+	m_saslSession = sess;
+}
+
+
+shared_ptr <SASLSession> defaultSASLAuthenticator::getSASLSession() const {
+
+	return m_saslSession.lock();
+}
+
+
+void defaultSASLAuthenticator::setSASLMechanism(const shared_ptr <SASLMechanism>& mech) {
+
+	m_saslMech = mech;
+}
+
+
+shared_ptr <SASLMechanism> defaultSASLAuthenticator::getSASLMechanism() const {
+
+	return m_saslMech;
+}
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
diff --git a/vmime-master/src/vmime/security/sasl/defaultSASLAuthenticator.hpp b/vmime-master/src/vmime/security/sasl/defaultSASLAuthenticator.hpp
new file mode 100644
index 0000000..368e9ef
--- /dev/null
+++ b/vmime-master/src/vmime/security/sasl/defaultSASLAuthenticator.hpp
@@ -0,0 +1,91 @@
+//
+// VMime library (http://www.vmime.org)
+// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 3 of
+// the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Linking this library statically or dynamically with other modules is making
+// a combined work based on this library.  Thus, the terms and conditions of
+// the GNU General Public License cover the whole combination.
+//
+
+#ifndef VMIME_SECURITY_SASL_DEFAULTSASLAUTHENTICATOR_HPP_INCLUDED
+#define VMIME_SECURITY_SASL_DEFAULTSASLAUTHENTICATOR_HPP_INCLUDED
+
+
+#include "vmime/config.hpp"
+
+
+#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+
+#include "vmime/security/sasl/SASLAuthenticator.hpp"
+#include "vmime/security/defaultAuthenticator.hpp"
+
+
+namespace vmime {
+namespace security {
+namespace sasl {
+
+
+/** An authenticator that is capable of providing information
+  * for simple authentication mechanisms (username and password).
+  */
+class VMIME_EXPORT defaultSASLAuthenticator : public SASLAuthenticator {
+
+public:
+
+	defaultSASLAuthenticator();
+	~defaultSASLAuthenticator();
+
+	const std::vector <shared_ptr <SASLMechanism> > getAcceptableMechanisms(
+		const std::vector <shared_ptr <SASLMechanism> >& available,
+		const shared_ptr <SASLMechanism>& suggested
+	) const;
+
+	const string getUsername() const;
+	const string getPassword() const;
+	const string getHostname() const;
+	const string getAnonymousToken() const;
+	const string getServiceName() const;
+	const string getAccessToken() const;
+
+	void setService(const shared_ptr <net::service>& serv);
+	weak_ptr <net::service> getService() const;
+
+	void setSASLSession(const shared_ptr <SASLSession>& sess);
+	shared_ptr <SASLSession> getSASLSession() const;
+
+	void setSASLMechanism(const shared_ptr <SASLMechanism>& mech);
+	shared_ptr <SASLMechanism> getSASLMechanism() const;
+
+private:
+
+	defaultAuthenticator m_default;
+
+	weak_ptr <net::service> m_service;
+	weak_ptr <SASLSession> m_saslSession;
+	shared_ptr <SASLMechanism> m_saslMech;
+};
+
+
+} // sasl
+} // security
+} // vmime
+
+
+#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_SASL_SUPPORT
+
+#endif // VMIME_SECURITY_SASL_DEFAULTSASLAUTHENTICATOR_HPP_INCLUDED