connectiontls.h

/*
 * Copyright (c) 2007-2023 by Jakob Schröter <js@camaya.net>
 * This file is part of the gloox library. http://camaya.net/gloox
 *
 * This software is distributed under a license. The full license
 * agreement can be found in the file LICENSE in this distribution.
 * This software may not be copied, modified, sold or distributed
 * other than expressed in the named license agreement.
 *
 * This software is distributed without any warranty.
 */
 
#ifndef CONNECTIONTLS_H__
#define CONNECTIONTLS_H__
 
#include "gloox.h"
#include "logsink.h"
#include "connectionbase.h"
#include "tlsdefault.h"
#include "connectiondatahandler.h"
 
#include <string>
 
namespace gloox
{
 
  class GLOOX_API ConnectionTLS : public TLSHandler, public ConnectionBase, public ConnectionDataHandler
  {
    public:
      ConnectionTLS( ConnectionDataHandler* cdh, ConnectionBase* conn, const LogSink& log );
 
      ConnectionTLS( ConnectionBase* conn, const LogSink& log );
 
      virtual ~ConnectionTLS();
 
      void setCACerts( const StringList& cacerts )
      {
        m_cacerts = cacerts;
      }
 
      const CertInfo& fetchTLSInfo() const { return m_certInfo; }
 
      void setClientCert( const std::string& clientKey, const std::string& clientCerts )
      {
        m_clientKey = clientKey;
        m_clientCerts = clientCerts;
      }
 
      void setConnectionImpl( ConnectionBase* connection );
 
      void registerTLSHandler( TLSHandler* th ) { m_tlsHandler = th; }
 
      // reimplemented from ConnectionBase
      virtual ConnectionError connect();
 
      // reimplemented from ConnectionBase
      virtual ConnectionError recv( int timeout = -1 );
 
      // reimplemented from ConnectionBase
      virtual bool send( const std::string& data );
 
      // reimplemented from ConnectionBase
      virtual ConnectionError receive();
 
      // reimplemented from ConnectionBase
      virtual void disconnect();
 
      // reimplemented from ConnectionBase
      virtual void cleanup();
 
      // reimplemented from ConnectionBase
      virtual void getStatistics( long int& totalIn, long int& totalOut );
 
      // reimplemented from ConnectionDataHandler
      virtual void handleReceivedData( const ConnectionBase* connection, const std::string& data );
 
      // reimplemented from ConnectionDataHandler
      virtual void handleConnect( const ConnectionBase* connection );
 
      // reimplemented from ConnectionDataHandler
      virtual void handleDisconnect( const ConnectionBase* connection, ConnectionError reason );
 
      // reimplemented from ConnectionDataHandler
      virtual ConnectionBase* newInstance() const;
 
      // reimplemented from TLSHandler
      virtual void handleEncryptedData( const TLSBase*, const std::string& data );
 
      // reimplemented from TLSHandler
      virtual void handleDecryptedData( const TLSBase*, const std::string& data );
 
      // reimplemented from TLSHandler
      virtual void handleHandshakeResult( const TLSBase* base, bool success, CertInfo& certinfo );
 
    protected:
      virtual TLSBase* getTLSBase( TLSHandler* th, const std::string server )
      {
        return new TLSDefault( th, server, TLSDefault::VerifyingClient );
      }
 
      ConnectionBase* m_connection;
      TLSBase* m_tls;
      TLSHandler* m_tlsHandler;
      CertInfo m_certInfo;
      const LogSink& m_log;
      StringList m_cacerts;
      std::string m_clientCerts;
      std::string m_clientKey;
 
    private:
      ConnectionTLS& operator=( const ConnectionTLS& );
 
  };
 
}
 
#endif // CONNECTIONTLS_H__