connectionbosh.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 CONNECTIONBOSH_H__
#define CONNECTIONBOSH_H__
 
#include "gloox.h"
#include "connectionbase.h"
#include "logsink.h"
#include "taghandler.h"
#include "parser.h"
 
#include <string>
#include <list>
#include <ctime>
 
namespace gloox
{
 
  class GLOOX_API ConnectionBOSH : public ConnectionBase, ConnectionDataHandler, TagHandler
  {
    public:
      ConnectionBOSH( ConnectionBase* connection, const LogSink& logInstance, const std::string& boshHost,
                      const std::string& xmppServer, int xmppPort = 5222 );
 
      ConnectionBOSH( ConnectionDataHandler* cdh, ConnectionBase* connection,
                      const LogSink& logInstance, const std::string& boshHost,
                      const std::string& xmppServer, int xmppPort = 5222 );
 
      virtual ~ConnectionBOSH();
 
      enum ConnMode
      {
        ModeLegacyHTTP,             
        ModePersistentHTTP,         
        ModePipelining              
      };
 
      void setServer( const std::string& xmppHost, unsigned short xmppPort = 5222 )
        { m_server = xmppHost; m_port = xmppPort; }
 
      void setPath( const std::string& path ) { m_path = path; }
 
      void setMode( ConnMode mode ) { m_connMode = mode; }
 
      // 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 TagHandler
      virtual void handleTag( Tag* tag );
 
    private:
      ConnectionBOSH& operator=( const ConnectionBOSH& );
      void initInstance( ConnectionBase* connection, const std::string& xmppServer, const int xmppPort );
      bool sendRequest( const std::string& xml );
      bool sendXML();
      const std::string getHTTPField( const std::string& field );
      ConnectionBase* getConnection();
      ConnectionBase* activateConnection();
      void putConnection();
 
      //ConnectionBase *m_connection;
      const LogSink& m_logInstance;
 
      Parser m_parser;   // Used for parsing XML section of responses
      std::string m_boshHost;   // The hostname of the BOSH connection manager
      std::string m_boshedHost;   // The hostname of the BOSH connection manager + : + port
      std::string m_path;   // The path part of the URL that we need to request
 
      // BOSH parameters
      unsigned long m_rid;
      std::string m_sid;
 
      bool m_initialStreamSent;
      int m_openRequests;
      int m_maxOpenRequests;
      int m_wait;
      int m_hold;
 
      bool m_streamRestart;   // Set to true if we are waiting for an acknowledgement of a stream restart
 
      time_t m_lastRequestTime;
      unsigned long m_minTimePerRequest;
 
      std::string m_buffer;   // Buffer of received data
      std::string m_bufferHeader;   // HTTP header of data currently in buffer // FIXME doens't need to be member
      std::string::size_type m_bufferContentLength;   // Length of the data in the current response
 
      std::string m_sendBuffer;   // Data waiting to be sent
 
      typedef std::list<ConnectionBase*> ConnectionList;
      ConnectionList m_activeConnections;
      ConnectionList m_connectionPool;
      ConnMode m_connMode;
 
  };
 
}
 
#endif // CONNECTIONBOSH_H__