c2s.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 C2S_H__
#define C2S_H__

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

#include <gloox/connectionhandler.h>
#include <gloox/gloox.h>
#include <gloox/mutex.h>

#include <string>
#include <list>

namespace gloox
{
  class ConnectionBase;
  class ConnectionTCPServer;
  class JID;
}

namespace glooxd
{

  class ConfigManager;
  class Router;
  class StreamBase;
  class SM;

  class GLOOXD_API C2S : public gloox::ConnectionHandler, ComponentBase
  {

    friend class StreamBase;

    public:
      C2S( Router& router, ConfigManager& cm, const gloox::LogSink& logInstance,
           SM& sm, bool threading = false,
           const gloox::JID& name = gloox::JID( "c2s." + GLOOXD_DOMAIN )
         );

      virtual ~C2S();

      void run();

      void registerStreamFeature( StreamFeature* feature )
      {
        m_features.push_back( feature );
      }

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

      void setSupportRecipientUnavailable( bool value )
      {
        m_supportRecipientUnavailable = value;
      }

      bool supportRecipientUnavailable() const
      {
        return m_supportRecipientUnavailable;
      }

      // reimplemented from gloox::ConnectionHandler
      virtual void handleIncomingConnection( gloox::ConnectionBase* server,
                                             gloox::ConnectionBase* connection );

      // reimplemented from TagHandler
      virtual void handleIncomingTag( gloox::Tag* tag );

      // reimplemented from TagHandler
      virtual void handleOutgoingTag( gloox::Tag* tag );

      // reimplemented from ConfigHandler
      virtual bool handleC2SInterfaceAdded( const std::string& interface,
                                            int port );

      // reimplemented from ConfigHandler
      virtual bool handleC2SInterfaceRemoved( const std::string& interface,
                                              int port );
      // reimplemented from ConfigHandler
      virtual void handleDomainAdded( const std::string& domain );

      // reimplemented from ConfigHandler
      virtual void handleDomainRemoved( const std::string& domain );

      // reimplemented from ConfigHandler
      virtual void handleShutdown();

    private:
      void disconnect( StreamBase* client );

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

      gloox::ConnectionError receive();

      void handleTag( gloox::Tag* tag );

      typedef std::list<gloox::ConnectionTCPServer*> ServerList;
      typedef std::list<StreamBase*> StreamBaseList;

      ServerList m_servers;
      StreamBaseList m_clients;
      StreamBaseList m_obsoleteClients;
      FeatureList m_features;

      gloox::util::Mutex m_clientMutex;
      gloox::util::Mutex m_obsoleteClientMutex;
      gloox::util::Mutex m_serverMutex;

      SM& m_sm;

      gloox::TagList m_queue;
      glooxd::util::Semaphore m_queueSemaphore;
      gloox::util::Mutex m_queueMutex;

      volatile bool m_threading;
      bool m_strictXMPP;
      bool m_running;
      bool m_supportRecipientUnavailable;

  };
}

#endif // C2S_H__