socks5bytestreammanager.h

/*
  Copyright (c) 2007-2008 by Jakob Schroeter <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"

namespace gloox
{

  class SOCKS5BytestreamHandler;
  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*/                      
      };

      SOCKS5BytestreamManager( ClientBase *parent, SOCKS5BytestreamHandler* 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 = "" );

      bool dispose( SOCKS5Bytestream *s5b );

      void acceptSOCKS5Bytestream( const std::string& sid );

      void rejectSOCKS5Bytestream( const std::string& sid );

      void registerSOCKS5BytestreamHandler( SOCKS5BytestreamHandler *s5bh )
        { m_socks5BytestreamHandler = s5bh; }

      void removeSOCKS5BytestreamHandler()
        { m_socks5BytestreamHandler = 0; }

      void registerSOCKS5BytestreamServer( SOCKS5BytestreamServer* server ) { m_server = server; }

      void removeSOCKS5BytestreamServer() { m_server = 0; }

      // reimplemented from IqHandler
      virtual bool handleIq( Stanza *stanza );

      // reimplemented from IqHandler
      virtual bool handleIqID( Stanza *stanza, int context );

    private:
      void rejectSOCKS5Bytestream( const JID& from, const std::string& id, StanzaError reason );
      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;
        std::string id;
        StreamHostList sHosts;
        bool incoming;
      };
      typedef std::map<std::string, AsyncS5BItem> AsyncTrackMap;
      AsyncTrackMap m_asyncTrackMap;

      ClientBase *m_parent;
      SOCKS5BytestreamHandler* m_socks5BytestreamHandler;
      SOCKS5BytestreamServer* m_server;
      StreamHostList m_hosts;
      StringMap m_trackMap;

  };

}

#endif // SOCKS5BYTESTREAMMANAGER_H__