configmanager.h

/*
  Copyright (c) 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 CONFIGMANAGER_H__
#define CONFIGMANAGER_H__

#include "macros.h"

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

#include <list>

namespace gloox
{
  class LogSink;
}

namespace glooxd
{

  class ConfigHandler;
  class ServerEventHandler;

  class GLOOXD_API ConfigManager
  {
    public:
      ConfigManager( const gloox::LogSink& _logInstance );

      virtual ~ConfigManager();

      void registerConfigHandler( ConfigHandler* ch );

      void registerServerEventHandler( ServerEventHandler* seh );

      void bindDomain( const std::string& domain, const std::string& interface = gloox::EmptyString,
                      unsigned short port = 5222 );

      void unbindDomain( const std::string& domain, const std::string& interface = gloox::EmptyString,
                       unsigned short port = 5222 );

      bool addC2SInterface( const std::string& interface = gloox::EmptyString,
                            unsigned short port = 5222 );

      bool removeC2SInterface( const std::string& interface = gloox::EmptyString,
                               unsigned short port = 5222 );

      void rebind();

      void shutdown();

      virtual bool checkDomain( const std::string& domain, const std::string& ip,
                                int port );

      virtual void handleC2SListening( bool yes );

      virtual void handleS2SListening( bool yes );

      virtual void handleClientConnected( const gloox::JID jid, const std::string localIP, int localPort,
                                          const std::string remoteIP, int remotePort );

      virtual void handleClientDisconnected( const gloox::JID jid, gloox::ConnectionError e,
                                             gloox::StreamError se );

    private:
      struct Interface
      {

        public:
          Interface( const std::string& iface = gloox::EmptyString, int p = 5222 )
            : m_interface( iface ), m_port( p )
          {}

          ~Interface() {}

          const std::string& interface() const { return m_interface; }

          int port() const { return m_port; }

          bool hasDomain( const std::string& domain );

          void removeDomain( const std::string& domain )
          {
            m_domains.remove( domain );
          }

          void addDomain( const std::string& domain )
          {
            m_domains.push_back( domain );
          }

        private:
          std::string m_interface;
          int m_port;

          gloox::StringList m_domains;

      };

      bool findInterface( const std::string& interface, unsigned short port );

      typedef std::list<ConfigHandler*> ConfigHandlerList;
      typedef std::list<Interface*> InterfaceList;
      typedef std::list<ServerEventHandler*> ServerEventHandlerList;

      ConfigHandlerList m_configHandlers;
      InterfaceList m_c2sInterfaces;
      ServerEventHandlerList m_eventHandlers;

      gloox::util::Mutex m_c2sInterfacesMutex;
      gloox::util::Mutex m_configHandlersMutex;
      gloox::util::Mutex m_eventHandlersMutex;

      const gloox::LogSink& m_logInstance;

  };

}

#endif // CONFIGMANAGER_H__