jni/commoncpp2-1.8.1-android/src/ssl.cpp - jami-client-android - Gitiles

 // Copyright (C) 1999-2005 Open Source Telecom Corporation.
 // Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
 //
 // 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 //
 // As a special exception, you may use this file as part of a free software
 // library without restriction.  Specifically, if other files instantiate
 // templates or use macros or inline functions from this file, or you compile
 // this file and link it with other files to produce an executable, this
 // file does not by itself cause the resulting executable to be covered by
 // the GNU General Public License.  This exception does not however
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 //
 // This exception applies only to the code released under the name GNU
 // Common C++.  If you copy code from other releases into a copy of GNU
 // Common C++, as the General Public License permits, the exception does
 // not apply to the code that you add in this way.  To avoid misleading
 // anyone as to the status of such modified files, you must delete
 // this exception notice from them.
 //
 // If you write modifications of your own for GNU Common C++, it is your choice
 // whether to permit this exception to apply to your modifications.
 // If you do not wish that, delete this exception notice.
 //

 #include <cc++/config.h>
 #ifdef  CCXX_WITHOUT_EXTRAS
 #include <cc++/export.h>
 #endif
 #include <cc++/thread.h>
 #include <cc++/exception.h>
 #ifndef CCXX_WITHOUT_EXTRAS
 #include <cc++/export.h>
 #endif

 #ifdef  CCXX_SSL

 #include <cc++/ssl.h>
 #include <cerrno>
 #include <cstdlib>
 #include <cstdarg>
 #include <cstdio>

 #ifdef  CCXX_GNUTLS
 #include <gcrypt.h>
 #endif

 #ifdef  WIN32
 #include <io.h>
 #define socket_errno    WSAGetLastError()
 #else
 #define socket_errno    errno
 #endif

 #ifdef  CCXX_NAMESPACES
 namespace ost {
 using namespace std;
 #endif

 #ifdef  CCXX_GNUTLS

 #ifndef WIN32
 static int _gcry_mutex_init(Mutex **priv)
 {
     Mutex *m = new Mutex();

     *priv = m;
     return 0;
 }

 static int _gcry_mutex_destroy(Mutex **priv)
 {
     delete *priv;
     return 0;
 }

 static int _gcry_mutex_lock(Mutex **priv)
 {
     (*priv)->enter();
     return 0;
 }

 static int _gcry_mutex_unlock(Mutex **priv)
 {
     (*priv)->leave();
     return 0;
 }

 extern "C" {
     static int _wrap_mutex_init(void **priv)
     {
         return _gcry_mutex_init((Mutex **)(priv));
     }

     static int _wrap_mutex_destroy(void **priv)
     {
         return _gcry_mutex_destroy((Mutex **)(priv));
     }

     static int _wrap_mutex_lock(void **priv)
     {
         return _gcry_mutex_lock((Mutex **)(priv));
     }

     static int _wrap_mutex_unlock(void **priv)
     {
         return _gcry_mutex_unlock((Mutex **)(priv));
     }

     static struct gcry_thread_cbs _gcry_threads =
     {
         GCRY_THREAD_OPTION_PTHREAD, NULL,
         _wrap_mutex_init, _wrap_mutex_destroy,
         _wrap_mutex_lock, _wrap_mutex_unlock
     };

 };

 #endif

 static class _ssl_global {
 public:
     _ssl_global() {
 #ifndef WIN32
         gcry_control(GCRYCTL_SET_THREAD_CBS, &_gcry_threads);
 #endif
         gnutls_global_init();
     }

     ~_ssl_global() {
         gnutls_global_deinit();
     }

 } _ssl_global;
 #endif

 #ifdef  CCXX_OPENSSL
 static  Mutex *ssl_mutex = NULL;

 extern "C" {
     static void ssl_lock(int mode, int n, const char *file, int line)
     {
         if(mode && CRYPTO_LOCK)
             ssl_mutex[n].enter();
         else
             ssl_mutex[n].leave();
     }

     static unsigned long ssl_thread(void)
     {
     #ifdef  WIN32
         return GetCurrentThreadId();
     #else
         return (unsigned long)pthread_self();
     #endif
     }
 } // extern "C"

 static class _ssl_global {
 public:
     _ssl_global() {
         if(ssl_mutex)
             return;

         if(CRYPTO_get_id_callback() != NULL)
             return;

         ssl_mutex = new Mutex[CRYPTO_num_locks()];
         CRYPTO_set_id_callback(ssl_thread);
         CRYPTO_set_locking_callback(ssl_lock);
     }

     ~_ssl_global() {
         if(!ssl_mutex)
             return;
         CRYPTO_set_id_callback(NULL);
         CRYPTO_set_locking_callback(NULL);
         delete[] ssl_mutex;
         ssl_mutex = NULL;
     }
 } _ssl_global;
 #endif


 SSLStream::SSLStream(Family f, bool tf, timeout_t to) :
 TCPStream(f, tf, to)
 {
     ssl = NULL;
 }

 SSLStream::SSLStream(const IPV4Host &h, tpport_t p, unsigned mss, bool tf, timeout_t to) :
 TCPStream(h, p, mss, tf, to)
 {
     ssl = NULL;
 }

 #ifdef  CCXX_IPV6
 SSLStream::SSLStream(const IPV6Host &h, tpport_t p, unsigned mss, bool tf, timeout_t to) :
 TCPStream(h, p, mss, tf, to)
 {
     ssl = NULL;
 }
 #endif

 SSLStream::SSLStream(const char *name, Family f, unsigned mss, bool tf, timeout_t to) :
 TCPStream(name, f, mss, tf, to)
 {
     ssl = NULL;
 }

 ssize_t SSLStream::readLine(char *str, size_t request, timeout_t timeout)
 {
     ssize_t nstat;
     unsigned count = 0;

     if(!ssl)
         return Socket::readLine(str, request, timeout);

     while(count < request) {
         if(timeout && !isPending(pendingInput, timeout)) {
             error(errTimeout, "Read timeout", 0);
             return -1;
         }

 #ifdef  CCXX_GNUTLS
         nstat = gnutls_record_recv(ssl->session, str + count, 1);
 #else
         nstat = SSL_read(ssl, str + count, 1);
 #endif
         if(nstat <= 0) {
             error(errInput, "Could not read from socket", socket_errno);
             return -1;
         }

         if(str[count] == '\n') {
             if(count > 0 && str[count - 1] == '\r')
                 --count;
             break;
         }

         ++count;
     }
     str[count] = 0;
     return count;
 }

 ssize_t SSLStream::writeData(void *source, size_t size, timeout_t timeout)
 {
     ssize_t nstat, count = 0;
     if(size < 1)
         return 0;

     const char *slide = (const char *)source;

     while(size) {
         if(timeout && !isPending(pendingOutput, timeout)) {
             error(errOutput);
             return -1;
         }

 #ifdef  CCXX_GNUTLS
         nstat = gnutls_record_send(ssl->session, slide, size);
 #else
         nstat = SSL_write(ssl, slide, size);
 #endif
         if(nstat <= 0) {
             error(errOutput);
             return -1;
         }
         count += nstat;
         size -= nstat;
         slide += nstat;
     }
     return count;
 }

 ssize_t SSLStream::readData(void *target, size_t size, char separator, timeout_t timeout)
 {
     char *str = (char *)target;
     ssize_t nstat;
     unsigned count = 0;
     if(!ssl)
         return Socket::readData(target, size, separator, timeout);

     if(separator == 0x0d || separator == 0x0a)
         return readLine((char *)target, size, timeout);

     if(separator) {
         while(count < size) {
             if(timeout && !isPending(pendingInput, timeout)) {
                 error(errTimeout, "Read timeout", 0);
                 return -1;
             }

 #ifdef  CCXX_GNUTLS
             nstat = gnutls_record_recv(ssl->session, str + count, 1);
 #else
             nstat = SSL_read(ssl, str + count, 1);
 #endif
             if(nstat <= 0) {
                 error(errInput, "Could not read from socket", socket_errno);
                 return -1;
             }
             if(str[count] == separator)
                 break;
             ++count;
         }
         if(str[count] == separator)
             str[count] = 0;
         return count;
     }

     if(timeout && !isPending(pendingInput, timeout)) {
         error(errTimeout);
         return -1;
     }

 #ifdef  CCXX_GNUTLS
     nstat = gnutls_record_recv(ssl->session, target, size);
 #else
     nstat = SSL_read(ssl, target, size);
 #endif

     if(nstat < 0) {
         error(errInput);
         return -1;
     }
     return nstat;
 }

 #ifdef  CCXX_GNUTLS
 bool SSLStream::getSession(void)
 {
         const int cert_priority[3] =
         {GNUTLS_CRT_X509, GNUTLS_CRT_OPENPGP, 0};

     if(ssl)
         return true;

     if(so == INVALID_SOCKET)
         return false;

     ssl = new SSL;
     if(gnutls_init(&ssl->session, GNUTLS_CLIENT)) {
         delete ssl;
         ssl = NULL;
         return false;
     }

     gnutls_set_default_priority(ssl->session);
     gnutls_certificate_allocate_credentials(&ssl->xcred);
     gnutls_certificate_type_set_priority(ssl->session, cert_priority);
     gnutls_credentials_set(ssl->session, GNUTLS_CRD_CERTIFICATE, ssl->xcred);
     gnutls_transport_set_ptr(ssl->session, (gnutls_transport_ptr)so);
     if(gnutls_handshake(ssl->session)) {
         gnutls_deinit(ssl->session);
         gnutls_certificate_free_credentials(ssl->xcred);
         delete ssl;
         ssl = NULL;
         return false;
     }
     return true;
 }
 #else
 bool SSLStream::getSession(void)
 {
     SSL_CTX *ctx;
     int err;

     if(ssl)
         return true;

     if(so == INVALID_SOCKET)
         return false;

     ctx = SSL_CTX_new(SSLv3_client_method());
     if(!ctx) {
         SSL_CTX_free(ctx);
         return false;
     }

     ssl = SSL_new(ctx);
     if(!ssl) {
         SSL_CTX_free(ctx);
         return false;
     }

     SSL_set_fd(ssl, so);
     SSL_set_connect_state(ssl);
     err = SSL_connect(ssl);

     if(err < 0)
         SSL_shutdown(ssl);

     if(err <= 0) {
         SSL_free(ssl);
         SSL_CTX_free(ctx);
         ssl = NULL;
         return false;
     }
     return true;
 }
 #endif

 #ifdef  CCXX_GNUTLS
 void SSLStream::endStream(void)
 {
     if(ssl && so != INVALID_SOCKET)
         gnutls_bye(ssl->session, GNUTLS_SHUT_WR);
     TCPStream::endStream();
     if(ssl) {
         gnutls_deinit(ssl->session);
         gnutls_certificate_free_credentials(ssl->xcred);
         delete ssl;
         ssl = NULL;
     }
 }

 void SSLStream::disconnect(void)
 {
     if(ssl && so != INVALID_SOCKET)
         gnutls_bye(ssl->session, GNUTLS_SHUT_WR);

     if(so != INVALID_SOCKET)
         TCPStream::disconnect();
     if(ssl) {
         gnutls_deinit(ssl->session);
         gnutls_certificate_free_credentials(ssl->xcred);
         delete ssl;
         ssl = NULL;
     }
 }
 #else
 void SSLStream::disconnect(void)
 {
     if(ssl) {
         if(so != INVALID_SOCKET)
             SSL_shutdown(ssl);
         SSL_free(ssl);
         ssl = NULL;
     }
     TCPStream::disconnect();
 }

 void SSLStream::endStream(void)
 {
     if(ssl) {
         if(so != INVALID_SOCKET)
             SSL_shutdown(ssl);
         SSL_free(ssl);
         ssl = NULL;
     }
     TCPStream::endStream();
 }
 #endif

 SSLStream::~SSLStream()
 {
 #ifdef  CCXX_EXCEPTIONS
     try { endStream(); }
     catch( ...) { if ( ! std::uncaught_exception()) throw;};
 #else
     endStream();
 #endif
 }

 #ifdef  CCXX_NAMESPACES
 }
 #endif

 #endif
	// Copyright (C) 1999-2005 Open Source Telecom Corporation.
	// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
	//
	// 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	//
	// As a special exception, you may use this file as part of a free software
	// library without restriction. Specifically, if other files instantiate
	// templates or use macros or inline functions from this file, or you compile
	// this file and link it with other files to produce an executable, this
	// file does not by itself cause the resulting executable to be covered by
	// the GNU General Public License. This exception does not however
	// invalidate any other reasons why the executable file might be covered by
	// the GNU General Public License.
	//
	// This exception applies only to the code released under the name GNU
	// Common C++. If you copy code from other releases into a copy of GNU
	// Common C++, as the General Public License permits, the exception does
	// not apply to the code that you add in this way. To avoid misleading
	// anyone as to the status of such modified files, you must delete
	// this exception notice from them.
	//
	// If you write modifications of your own for GNU Common C++, it is your choice
	// whether to permit this exception to apply to your modifications.
	// If you do not wish that, delete this exception notice.
	//

	#include <cc++/config.h>
	#ifdef CCXX_WITHOUT_EXTRAS
	#include <cc++/export.h>
	#endif
	#include <cc++/thread.h>
	#include <cc++/exception.h>
	#ifndef CCXX_WITHOUT_EXTRAS
	#include <cc++/export.h>
	#endif

	#ifdef CCXX_SSL

	#include <cc++/ssl.h>
	#include <cerrno>
	#include <cstdlib>
	#include <cstdarg>
	#include <cstdio>

	#ifdef CCXX_GNUTLS
	#include <gcrypt.h>
	#endif

	#ifdef WIN32
	#include <io.h>
	#define socket_errno WSAGetLastError()
	#else
	#define socket_errno errno
	#endif

	#ifdef CCXX_NAMESPACES
	namespace ost {
	using namespace std;
	#endif

	#ifdef CCXX_GNUTLS

	#ifndef WIN32
	static int _gcry_mutex_init(Mutex **priv)
	{
	Mutex *m = new Mutex();

	*priv = m;
	return 0;
	}

	static int _gcry_mutex_destroy(Mutex **priv)
	{
	delete *priv;
	return 0;
	}

	static int _gcry_mutex_lock(Mutex **priv)
	{
	(*priv)->enter();
	return 0;
	}

	static int _gcry_mutex_unlock(Mutex **priv)
	{
	(*priv)->leave();
	return 0;
	}

	extern "C" {
	static int _wrap_mutex_init(void **priv)
	{
	return _gcry_mutex_init((Mutex **)(priv));
	}

	static int _wrap_mutex_destroy(void **priv)
	{
	return _gcry_mutex_destroy((Mutex **)(priv));
	}

	static int _wrap_mutex_lock(void **priv)
	{
	return _gcry_mutex_lock((Mutex **)(priv));
	}

	static int _wrap_mutex_unlock(void **priv)
	{
	return _gcry_mutex_unlock((Mutex **)(priv));
	}

	static struct gcry_thread_cbs _gcry_threads =
	{
	GCRY_THREAD_OPTION_PTHREAD, NULL,
	_wrap_mutex_init, _wrap_mutex_destroy,
	_wrap_mutex_lock, _wrap_mutex_unlock
	};

	};

	#endif

	static class _ssl_global {
	public:
	_ssl_global() {
	#ifndef WIN32
	gcry_control(GCRYCTL_SET_THREAD_CBS, &_gcry_threads);
	#endif
	gnutls_global_init();
	}

	~_ssl_global() {
	gnutls_global_deinit();
	}

	} _ssl_global;
	#endif

	#ifdef CCXX_OPENSSL
	static Mutex *ssl_mutex = NULL;

	extern "C" {
	static void ssl_lock(int mode, int n, const char *file, int line)
	{
	if(mode && CRYPTO_LOCK)
	ssl_mutex[n].enter();
	else
	ssl_mutex[n].leave();
	}

	static unsigned long ssl_thread(void)
	{
	#ifdef WIN32
	return GetCurrentThreadId();
	#else
	return (unsigned long)pthread_self();
	#endif
	}
	} // extern "C"

	static class _ssl_global {
	public:
	_ssl_global() {
	if(ssl_mutex)
	return;

	if(CRYPTO_get_id_callback() != NULL)
	return;

	ssl_mutex = new Mutex[CRYPTO_num_locks()];
	CRYPTO_set_id_callback(ssl_thread);
	CRYPTO_set_locking_callback(ssl_lock);
	}

	~_ssl_global() {
	if(!ssl_mutex)
	return;
	CRYPTO_set_id_callback(NULL);
	CRYPTO_set_locking_callback(NULL);
	delete[] ssl_mutex;
	ssl_mutex = NULL;
	}
	} _ssl_global;
	#endif


	SSLStream::SSLStream(Family f, bool tf, timeout_t to) :
	TCPStream(f, tf, to)
	{
	ssl = NULL;
	}

	SSLStream::SSLStream(const IPV4Host &h, tpport_t p, unsigned mss, bool tf, timeout_t to) :
	TCPStream(h, p, mss, tf, to)
	{
	ssl = NULL;
	}

	#ifdef CCXX_IPV6
	SSLStream::SSLStream(const IPV6Host &h, tpport_t p, unsigned mss, bool tf, timeout_t to) :
	TCPStream(h, p, mss, tf, to)
	{
	ssl = NULL;
	}
	#endif

	SSLStream::SSLStream(const char *name, Family f, unsigned mss, bool tf, timeout_t to) :
	TCPStream(name, f, mss, tf, to)
	{
	ssl = NULL;
	}

	ssize_t SSLStream::readLine(char *str, size_t request, timeout_t timeout)
	{
	ssize_t nstat;
	unsigned count = 0;

	if(!ssl)
	return Socket::readLine(str, request, timeout);

	while(count < request) {
	if(timeout && !isPending(pendingInput, timeout)) {
	error(errTimeout, "Read timeout", 0);
	return -1;
	}

	#ifdef CCXX_GNUTLS
	nstat = gnutls_record_recv(ssl->session, str + count, 1);
	#else
	nstat = SSL_read(ssl, str + count, 1);
	#endif
	if(nstat <= 0) {
	error(errInput, "Could not read from socket", socket_errno);
	return -1;
	}

	if(str[count] == '\n') {
	if(count > 0 && str[count - 1] == '\r')
	--count;
	break;
	}

	++count;
	}
	str[count] = 0;
	return count;
	}

	ssize_t SSLStream::writeData(void *source, size_t size, timeout_t timeout)
	{
	ssize_t nstat, count = 0;
	if(size < 1)
	return 0;

	const char slide = (const char )source;

	while(size) {
	if(timeout && !isPending(pendingOutput, timeout)) {
	error(errOutput);
	return -1;
	}

	#ifdef CCXX_GNUTLS
	nstat = gnutls_record_send(ssl->session, slide, size);
	#else
	nstat = SSL_write(ssl, slide, size);
	#endif
	if(nstat <= 0) {
	error(errOutput);
	return -1;
	}
	count += nstat;
	size -= nstat;
	slide += nstat;
	}
	return count;
	}

	ssize_t SSLStream::readData(void *target, size_t size, char separator, timeout_t timeout)
	{
	char str = (char )target;
	ssize_t nstat;
	unsigned count = 0;
	if(!ssl)
	return Socket::readData(target, size, separator, timeout);

	if(separator == 0x0d \|\| separator == 0x0a)
	return readLine((char *)target, size, timeout);

	if(separator) {
	while(count < size) {
	if(timeout && !isPending(pendingInput, timeout)) {
	error(errTimeout, "Read timeout", 0);
	return -1;
	}

	#ifdef CCXX_GNUTLS
	nstat = gnutls_record_recv(ssl->session, str + count, 1);
	#else
	nstat = SSL_read(ssl, str + count, 1);
	#endif
	if(nstat <= 0) {
	error(errInput, "Could not read from socket", socket_errno);
	return -1;
	}
	if(str[count] == separator)
	break;
	++count;
	}
	if(str[count] == separator)
	str[count] = 0;
	return count;
	}

	if(timeout && !isPending(pendingInput, timeout)) {
	error(errTimeout);
	return -1;
	}

	#ifdef CCXX_GNUTLS
	nstat = gnutls_record_recv(ssl->session, target, size);
	#else
	nstat = SSL_read(ssl, target, size);
	#endif

	if(nstat < 0) {
	error(errInput);
	return -1;
	}
	return nstat;
	}

	#ifdef CCXX_GNUTLS
	bool SSLStream::getSession(void)
	{
	const int cert_priority[3] =
	{GNUTLS_CRT_X509, GNUTLS_CRT_OPENPGP, 0};

	if(ssl)
	return true;

	if(so == INVALID_SOCKET)
	return false;

	ssl = new SSL;
	if(gnutls_init(&ssl->session, GNUTLS_CLIENT)) {
	delete ssl;
	ssl = NULL;
	return false;
	}

	gnutls_set_default_priority(ssl->session);
	gnutls_certificate_allocate_credentials(&ssl->xcred);
	gnutls_certificate_type_set_priority(ssl->session, cert_priority);
	gnutls_credentials_set(ssl->session, GNUTLS_CRD_CERTIFICATE, ssl->xcred);
	gnutls_transport_set_ptr(ssl->session, (gnutls_transport_ptr)so);
	if(gnutls_handshake(ssl->session)) {
	gnutls_deinit(ssl->session);
	gnutls_certificate_free_credentials(ssl->xcred);
	delete ssl;
	ssl = NULL;
	return false;
	}
	return true;
	}
	#else
	bool SSLStream::getSession(void)
	{
	SSL_CTX *ctx;
	int err;

	if(ssl)
	return true;

	if(so == INVALID_SOCKET)
	return false;

	ctx = SSL_CTX_new(SSLv3_client_method());
	if(!ctx) {
	SSL_CTX_free(ctx);
	return false;
	}

	ssl = SSL_new(ctx);
	if(!ssl) {
	SSL_CTX_free(ctx);
	return false;
	}

	SSL_set_fd(ssl, so);
	SSL_set_connect_state(ssl);
	err = SSL_connect(ssl);

	if(err < 0)
	SSL_shutdown(ssl);

	if(err <= 0) {
	SSL_free(ssl);
	SSL_CTX_free(ctx);
	ssl = NULL;
	return false;
	}
	return true;
	}
	#endif

	#ifdef CCXX_GNUTLS
	void SSLStream::endStream(void)
	{
	if(ssl && so != INVALID_SOCKET)
	gnutls_bye(ssl->session, GNUTLS_SHUT_WR);
	TCPStream::endStream();
	if(ssl) {
	gnutls_deinit(ssl->session);
	gnutls_certificate_free_credentials(ssl->xcred);
	delete ssl;
	ssl = NULL;
	}
	}

	void SSLStream::disconnect(void)
	{
	if(ssl && so != INVALID_SOCKET)
	gnutls_bye(ssl->session, GNUTLS_SHUT_WR);

	if(so != INVALID_SOCKET)
	TCPStream::disconnect();
	if(ssl) {
	gnutls_deinit(ssl->session);
	gnutls_certificate_free_credentials(ssl->xcred);
	delete ssl;
	ssl = NULL;
	}
	}
	#else
	void SSLStream::disconnect(void)
	{
	if(ssl) {
	if(so != INVALID_SOCKET)
	SSL_shutdown(ssl);
	SSL_free(ssl);
	ssl = NULL;
	}
	TCPStream::disconnect();
	}

	void SSLStream::endStream(void)
	{
	if(ssl) {
	if(so != INVALID_SOCKET)
	SSL_shutdown(ssl);
	SSL_free(ssl);
	ssl = NULL;
	}
	TCPStream::endStream();
	}
	#endif

	SSLStream::~SSLStream()
	{
	#ifdef CCXX_EXCEPTIONS
	try { endStream(); }
	catch( ...) { if ( ! std::uncaught_exception()) throw;};
	#else
	endStream();
	#endif
	}

	#ifdef CCXX_NAMESPACES
	}
	#endif

	#endif