streambase.h

/*
  Copyright (c) 2008-2009 by Jakob Schroeter <js@camaya.net>
  This file is part of the glooxd library. http://camaya.net/glooxd

  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 STREAMBASE_H__
#define STREAMBASE_H__

#include "glooxd.h"
#include "semafore.h"

#include <gloox/connectiondatahandler.h>
#include <gloox/jid.h>
#include <gloox/gloox.h>
#include <gloox/mutex.h>
#include <gloox/parser.h>
#include <gloox/taghandler.h>

namespace gloox
{
  class ConnectionBase;
  class IQ;
  class LogSink;
  class TLSBase;
}

namespace glooxd
{

  class AuthenticationHandler;
  class C2S;
  class ConfigManager;

  class GLOOXD_API StreamBase : public gloox::ConnectionDataHandler, gloox::TagHandler
  {
    public:
      StreamBase( C2S& parent, ConfigManager& cm, gloox::ConnectionBase* connection,
              const gloox::LogSink& logInstance );

      virtual ~StreamBase();

      void run();

      void setFeatures( const FeatureList& features ) { m_features = features; }

      gloox::ConnectionError recv( int timeout = -1 );

      void send( gloox::Tag* tag );

      void send( const std::string& xml );

      void send( const gloox::IQ& iq );

      void disconnect( gloox::ConnectionError e,
                       gloox::StreamError se = gloox::StreamErrorUndefined,
                       const std::string& text = gloox::EmptyString );

      gloox::ConnectionBase* connection() { return m_connection; }

      const gloox::LogSink& logInstance() { return m_logInstance; }

      const gloox::JID& jid() const { return m_self; }

      void setServer( const std::string& server )
      {
        m_self.setServer( server );
      }

      void setUsername( const std::string& username )
      {
        m_self.setUsername( username );
      }

      void setResource( const std::string& resource )
      {
        m_self.setResource( resource );
      }

      void setStrictXMPP( bool enable ) { m_strictXMPP = enable; }

      void finishStreamFeature( StreamState state,
                                gloox::ConnectionBase* conn = 0 );

      void routeTag( gloox::Tag* tag );


      const gloox::JID name() const;

      const std::string& id() const { return m_id; }

      void handleIncomingTag( gloox::Tag* tag );

      void handleOutgoingTag( gloox::Tag* tag );


      // re-implemented from gloox::ConnectionDataHandler
      virtual void handleReceivedData( const gloox::ConnectionBase* connection,
                                       const std::string& data );

      // re-implemented from gloox::ConnectionDataHandler
      virtual void handleConnect( const gloox::ConnectionBase* connection );

      // re-implemented from gloox::ConnectionDataHandler
      virtual void handleDisconnect( const gloox::ConnectionBase* connection,
                                     gloox::ConnectionError reason );

      // re-implemented from gloox::TagHandler
      virtual void handleTag( gloox::Tag* tag );

    protected:
      void sendStreamFeatures( const std::string& domain );
      void handleStreamGreeting( const gloox::Tag* tag );
      bool handlesDomain( const std::string& domain );
      void stampTag( gloox::Tag* tag );

      C2S& m_parent;
      ConfigManager& m_cm;

      gloox::ConnectionBase* m_connection;
      const gloox::LogSink& m_logInstance;
      gloox::Parser m_parser;

      FeatureList m_features;

      StreamFeature* m_exclusiveHandler;
      gloox::StringList m_domains;

      std::string m_id;

      int m_state;

      gloox::JID m_self;

      gloox::TagList m_incomingQueue;
      gloox::TagList m_outgoingQueue;
      gloox::util::Mutex m_incomingQueueMutex;
      gloox::util::Mutex m_outgoingQueueMutex;
      glooxd::util::Semaphore m_queueSemaphore;

      volatile bool m_threading;
      bool m_fakePresence;
      bool m_strictXMPP;
//       bool m_cancel;

  };

}

#endif // STREAMBASE_H__