sm.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 "glooxd.h"
#include "plugin.h"
#include "rosterprovider.h"
#include "sm.h"

#include <gloox/adhoc.h>
#include <gloox/dataform.h>
#include <gloox/dataformfield.h>
#include <gloox/error.h>
#include <gloox/iq.h>
#include <gloox/jid.h>
#include <gloox/logsink.h>
#include <gloox/mutexguard.h>
#include <gloox/sha.h>
#include <gloox/util.h>

#include <cstdio>
#include <ctime>

namespace glooxd
{

  SM::SM( Router& _router, ConfigManager& cm, const gloox::LogSink& _logInstance,
          RosterProvider* rp, bool threading,
          const gloox::JID& _name )
    : ComponentBase( _router, cm, _name, _logInstance ), m_rosterProvider( rp ),
      m_threading( threading )
  {
  }

  SM::~SM()
  {
    gloox::util::clearList( m_plugins );
    gloox::util::clearList( m_queue );
    SessionList::iterator it = m_sessions.begin();
    for( ; it != m_sessions.end(); ++it )
    {
      delete (*it).second.presence;
      (*it).second.presence = 0;
    }
  }

  void SM::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 );
  }

  bool SM::createSession( gloox::JID& jid, const std::string& id )
  {
    if( jid.username().empty() || jid.server().empty() )
    {
      m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaSM ),
                         "Cannot create session for " + jid.full()
                         + ". Need a username and server." );
      return false;
    }

    if( jid.resource().empty() )
    {
      gloox::SHA sha;
      sha.feed( id );
      sha.feed( jid.full() );
      sha.feed( gloox::util::int2string( time( 0 ) ) );
      jid.setResource( sha.hex() );
    }

    m_sessionMutex.lock();
    SessionList::iterator it = m_sessions.find( jid.full() );
    if( it != m_sessions.end() )
    {
      const std::string tid = (*it).second.id;
      m_sessionMutex.unlock();
      m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaSM ),
                         "Session for " + jid.full() + " already " "exists. Replacing by new session." );
      gloox::Tag* d = new gloox::Tag( "disconnect" );
      d->setXmlns( XMLNS_GLOOXD );
      gloox::Tag* c = new gloox::Tag( d, "conflict" );
      c->setXmlns( gloox::XMLNS_XMPP_STREAM );
      gloox::Tag* t = new gloox::Tag( c, "text", "conflicting resource connected." );
      t->setXmlns( gloox::XMLNS_XMPP_STREAM );
      t->addAttribute( "xml:lang", "en" );
      gloox::JID j( jid );
      j.setResource( tid  );
      d->addAttribute( "to", j.full() );
      m_router.handleIncomingTag( d );
      m_sessionMutex.lock();
    }

    Session s;
    s.id = id;
    s.presence = 0;
    m_sessions.insert( std::make_pair( jid.full(), s ) );
    m_sessionMutex.unlock();
    m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaSM ),
                       "Created session for " + jid.full()
                       + ", id: " + id );
    return true;
  }

  const SM::SessionList SM::findSessions( const gloox::JID& jid )
  {
    SessionList sl;
    m_sessionMutex.lock();
    SessionList::iterator it = m_sessions.begin();
    for( ; it != m_sessions.end(); ++it )
    {
      gloox::JID j( (*it).first );
      if( j.bare() == jid.bare() )
        sl.insert( std::make_pair( (*it).first, (*it).second ) );
    }
    m_sessionMutex.unlock();

    return sl;
  }

  bool SM::removeSession( const std::string& jid )
  {
#ifdef DEBUG
    printf( "--------------------removing sessions for client instance %s\n", jid.c_str() );
#endif
    gloox::util::MutexGuard mg( m_sessionMutex );
    SessionList::iterator it = m_sessions.find( jid );
    if( it != m_sessions.end() )
    {
      delete (*it).second.presence;
      m_sessions.erase( it );
      return true;
    }

    return false;
  }

  void SM::dispatchPresence( const gloox::Tag* pres )
  {
    if( !m_rosterProvider || !pres )
      return;

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

#ifdef DEBUG
    printf( "dispatching presence for %s\n", from.full().c_str() );
#endif

    bool first = false;
    SessionList::iterator itsl = m_sessions.find( from.full() );
    if( itsl != m_sessions.end() )
    {
      first = !( (*itsl).second.presence );
    }

    const Roster& rm = m_rosterProvider->getRoster( from.bare() );
    Roster::const_iterator it = rm.begin();
    for( ; it != rm.end(); ++it )
    {
#ifdef DEBUG
      printf( "looking for sessions for %s ...", (*it).first.c_str() );
#endif
      const SessionList cl = findSessions( (*it).first );
      if( cl.size() )
      {
#ifdef DEBUG
        printf( " found %d\n", cl.size() );
#endif
        SessionList::const_iterator its = cl.begin();
        for( ; its != cl.end(); ++its )
        {
          gloox::Tag* p = 0;
          if( (*it).second == gloox::S10nBoth
              || (*it).second == gloox::S10nFrom )
          { // send own presence to contact
            p = pres->clone();
#ifdef DEBUG
            printf( "in for: stamping 'to': %s\n", (*its).first.c_str() );
#endif
            p->addAttribute( "to", (*its).first );
            m_router.handleIncomingTag( p );
          }
          if( first && (*its).second.presence
              && ( (*it).second == gloox::S10nBoth
                    || (*it).second == gloox::S10nTo ) )
          { // send contact presence to self, if not already known
            p = (*its).second.presence->clone();
#ifdef DEBUG
            printf( "in for/if: stamping 'to': %s\n", from.full().c_str() );
#endif
            p->addAttribute( "to", from.full() );
            m_router.handleIncomingTag( p );
          }
        }
      }
#ifdef DEBUG
      else
        printf( " none found\n" );
#endif
    }

    if( itsl != m_sessions.end() )
    {
      delete (*itsl).second.presence;
      (*itsl).second.presence = pres->clone();
    }
  }

  bool SM::dispatchMessage( const gloox::Tag* msg )
  {
    if( !msg )
      return false;

    gloox::JID jid( msg->findAttribute( "to" ) );
    const SessionList sl = findSessions( jid );
    SessionList::const_iterator it = sl.begin();
    for( ; it != sl.end(); ++it )
    {
      gloox::Tag* m = msg->clone();
      m->addAttribute( "to", (*it).first );
      m_router.handleIncomingTag( m );
    }

    if( !sl.size() )
      return false;

    return true;
  }

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

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

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

    m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaSM ),
                       tag->xml() );

    bool handled = false;
    PluginList::const_iterator it = m_plugins.begin();
    for( ; it != m_plugins.end(); ++it )
    {
      const std::string& xpath = (*it)->filterString();
      const gloox::Tag* x = tag->findTag( xpath );
      if( x && (*it)->handleTag( x ) )
      {
        handled = true;
        break;
      }
    }

    if( !handled )
    {
#ifdef DEBUG
      printf( "!_____________!!!!!!!!!!!!______returningError for id: %s\n", tag->findAttribute( "id" ).c_str() );
#endif
      gloox::Tag* t = returnError( tag );
      m_router.handleIncomingTag( t );
    }

    delete tag;
  }

  void SM::handleDomainAdded( const std::string& domain )
  {
    if( domain.empty() )
      return;

    m_router.registerDomain( this, domain, false );
  }

  void SM::handleDomainRemoved( const std::string& domain )
  {
    if( domain.empty() )
      return;

    m_router.removeDomain( this, domain, false );
  }

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

}