router.cpp

/*
  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.
*/


#include "configmanager.h"
#include "c2s.h"
#include "glooxd.h"
#include "router.h"

#include <gloox/error.h>
#include <gloox/gloox.h>
#include <gloox/iq.h>
#include <gloox/logsink.h>
#include <gloox/message.h>
#include <gloox/presence.h>
#include <gloox/taghandler.h>
#include <gloox/util.h>

#include <cstdio>

namespace glooxd
{

  Router::Router( ConfigManager& cm, const gloox::LogSink& logInstance, bool threading )
    : m_cm( cm ), m_logInstance( logInstance ), m_threading( threading )
  {
    m_cm.registerConfigHandler( this );
  }

  Router::~Router()
  {
    gloox::util::clearList( m_queue );
  }

  void Router::run()
  {
    if( !m_threading && !m_queue.size() )
      return;

    do
    {
      m_queueSemaphore.wait();
      gloox::Tag* t = m_queue.front();
      m_queueMutex.lock();
      m_queue.pop_front();
      m_queueMutex.unlock();
      handleTag( t );
    } while( m_threading );
  }

  void Router::handleShutdown()
  {
    m_threading = false;
    m_queueMutex.lock();
    m_queue.push_back( 0 );
    m_queueMutex.unlock();
  }

  void Router::registerDomain( TagHandler* th, const std::string& domain, bool node )
  {
    if( node )
    {
      m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaRouter ),
                         "Registered target for " + domain + ", for user traffic" );
      gloox::util::MutexGuard mg(m_userRoutingMutex );
      m_userRouting.insert( std::make_pair( domain, th ) );
    }
    else
    {
      m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaRouter ),
                         "Registered target for " + domain + ", for domain traffic" );
      gloox::util::MutexGuard mg(m_domainRoutingMutex );
      m_domainRouting.insert( std::make_pair( domain, th ) );
    }
  }

  bool Router::isLocal( const std::string& /*domain*/ )
  {
    // FIXME check with DomainManager!
    return true;
  }

  void Router::removeDomain( TagHandler* /*th*/, const std::string& domain, bool node )
  {
    if( node )
    {
      gloox::util::MutexGuard mg(m_userRoutingMutex );
      RoutingTable::iterator it = m_userRouting.find( domain );
      if( it !=m_userRouting.end() )
      {
        m_userRouting.erase( it );
        m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaRouter ),
                           "Removed target for " + domain + ", for user traffic" );
      }
    }
    else
    {
      gloox::util::MutexGuard mg(m_domainRoutingMutex );
      RoutingTable::iterator it = m_domainRouting.find( domain );
      if( it != m_domainRouting.end() )
      {
        m_domainRouting.erase( it );
        m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaRouter ),
                           "Removed target for " + domain + ", for domain traffic" );
      }
    }
  }

  void Router::handleIncomingTag( gloox::Tag* tag )
  {
    if( !tag )
      return;

    m_queueMutex.lock();
    m_queue.push_back( tag );
    m_queueMutex.unlock();
    m_queueSemaphore.post();
  }

  void Router::handleTag( gloox::Tag* tag )
  {
    if( !tag )
      return;

#ifdef DEBUG
    printf( "!!!!!Router::handleTag(): %s\n", tag->xml().c_str() );
#endif
    const gloox::JID to( tag->findAttribute( "to" ) );

    if( !to )
      routeBySender( tag );
    else if( isLocal( to.server() ) )
      routeByReceipient( tag );
    else
    {
      gloox::Tag* t = returnError( tag, gloox::StanzaErrorRemoteServerNotFound );
      handleIncomingTag( t );
      delete tag;
    }
  }

  void Router::routeBySender( gloox::Tag* tag )
  {
    if( !tag )
      return;
#ifdef DEBUG
    printf( "!!!!!Router::routeBySender(): %s\n", tag->xml().c_str() );
#endif

    const gloox::JID from( tag->findAttribute( "from" ) );

    gloox::util::MutexGuard mg( m_domainRoutingMutex );
    RoutingTable::const_iterator it = m_domainRouting.find( from.server() );
    if( it == m_domainRouting.end() )
    {
      delete tag;
      return;
    }

#ifdef DEBUG
    printf( "!!!!!found domain destination by 'from'\n" );
#endif
    (*it).second->handleIncomingTag( tag );
  }

  void Router::routeByReceipient( gloox::Tag* tag )
  {
    if( !tag )
      return;

#ifdef DEBUG
    printf( "!!!!!Router::routeByReceipient(): %s\n", tag->xml().c_str() );
#endif
    const gloox::JID to( tag->findAttribute( "to" ) );
//     const std::string& name = tag->name();

    if( to.username().empty() || to.resource().empty() )
    {
      gloox::util::MutexGuard mg( m_domainRoutingMutex );
      RoutingTable::const_iterator it = m_domainRouting.find( to.server() );
      if( it != m_domainRouting.end() )
      {
#ifdef DEBUG
        printf( "!!!!!found domain destination by 'to'\n" );
#endif
        (*it).second->handleIncomingTag( tag );
        return;
      }
    }
    else
    {
      gloox::util::MutexGuard mg( m_userRoutingMutex );
      RoutingTable::const_iterator it = m_userRouting.find( to.server() );
      if( it != m_userRouting.end() )
      {
#ifdef DEBUG
        printf( "!!!!!found user destination by 'to'\n" );
#endif
        (*it).second->handleOutgoingTag( tag );
        return;
      }
    }

    gloox::Tag* t = returnError( tag, gloox::StanzaErrorRemoteServerNotFound );
    handleIncomingTag( t );
    delete tag;
  }

}