socks5bytestreammanager.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 SOCKS5BYTESTREAMMANAGER_H__
#define SOCKS5BYTESTREAMMANAGER_H__
 
#include "iqhandler.h"
#include "jid.h"
#include "stanzaextension.h"
 
namespace gloox
{
 
  class BytestreamHandler;
  class SOCKS5BytestreamServer;
  class SOCKS5Bytestream;
  class ClientBase;
 
  struct StreamHost
  {
    JID jid;                    
    std::string host;           
    int port;                   
//         std::string zeroconf;       /**< A zeroconf identifier. */
  };
 
  typedef std::list<StreamHost> StreamHostList;
 
  class GLOOX_API SOCKS5BytestreamManager : public IqHandler
  {
 
    friend class SOCKS5Bytestream;
 
    public:
 
      enum S5BMode
      {
        S5BTCP,                     
        S5BUDP,                     
        S5BInvalid                  
      };
 
      SOCKS5BytestreamManager( ClientBase* parent, BytestreamHandler* s5bh );
 
      virtual ~SOCKS5BytestreamManager();
 
      void setStreamHosts( StreamHostList hosts ) { m_hosts = hosts; }
 
      void addStreamHost( const JID& jid, const std::string& host, int port );
 
      bool requestSOCKS5Bytestream( const JID& to, S5BMode mode, const std::string& sid = EmptyString,
                                    const JID& from = JID() );
 
      bool dispose( SOCKS5Bytestream* s5b );
 
      void acceptSOCKS5Bytestream( const std::string& sid );
 
      void rejectSOCKS5Bytestream( const std::string& sid, StanzaError reason = StanzaErrorNotAcceptable );
 
      void registerBytestreamHandler( BytestreamHandler* s5bh )
        { m_socks5BytestreamHandler = s5bh; }
 
      void removeBytestreamHandler()
        { m_socks5BytestreamHandler = 0; }
 
      void registerSOCKS5BytestreamServer( SOCKS5BytestreamServer* server ) { m_server = server; }
 
      void removeSOCKS5BytestreamServer() { m_server = 0; }
 
      // reimplemented from IqHandler.
      virtual bool handleIq( const IQ& iq );
 
      // reimplemented from IqHandler.
      virtual void handleIqID( const IQ& iq, int context );
 
    private:
#ifdef SOCKS5BYTESTREAMMANAGER_TEST
    public:
#endif
 
      class Query : public StanzaExtension
      {
        public:
          Query();
 
          Query( const std::string& sid, S5BMode mode,
                 const StreamHostList& hosts );
 
          Query( const JID& jid, const std::string& sid, bool activate );
 
          Query( const Tag* tag );
 
          virtual ~Query();
 
          const std::string& sid() const { return m_sid; }
 
          const JID& jid() const { return m_jid; }
 
          S5BMode mode() const { return m_mode; }
 
          const StreamHostList& hosts() const { return m_hosts; }
 
          // reimplemented from StanzaExtension
          virtual const std::string& filterString() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new Query( tag );
          }
 
          // reimplemented from StanzaExtension
          virtual Tag* tag() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const
          {
            return new Query( *this );
          }
 
        private:
          enum QueryType
          {
            TypeSH,
            TypeSHU,
            TypeA,
            TypeInvalid
          };
 
          std::string m_sid;
          JID m_jid;
          SOCKS5BytestreamManager::S5BMode m_mode;
          StreamHostList m_hosts;
          QueryType m_type;
 
      };
 
      SOCKS5BytestreamManager& operator=( const SOCKS5BytestreamManager&);
      void rejectSOCKS5Bytestream( const JID& from, const std::string& id, StanzaError reason = StanzaErrorNotAcceptable );
      bool haveStream( const JID& from );
      const StreamHost* findProxy( const JID& from, const std::string& hostjid, const std::string& sid );
 
      void acknowledgeStreamHost( bool success, const JID& jid, const std::string& sid );
 
      enum IBBActionType
      {
        S5BOpenStream,
        S5BCloseStream,
        S5BActivateStream
      };
 
      typedef std::map<std::string, SOCKS5Bytestream*> S5BMap;
      S5BMap m_s5bMap;
 
      struct AsyncS5BItem
      {
        JID from;
        JID to;
        std::string id;
        StreamHostList sHosts;
        bool incoming;
      };
      typedef std::map<std::string, AsyncS5BItem> AsyncTrackMap;
      AsyncTrackMap m_asyncTrackMap;
 
      ClientBase* m_parent;
      BytestreamHandler* m_socks5BytestreamHandler;
      SOCKS5BytestreamServer* m_server;
      StreamHostList m_hosts;
      StringMap m_trackMap;
 
  };
 
}
 
#endif // SOCKS5BYTESTREAMMANAGER_H__