streambase.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 "authenticationhandler.h"
#include "c2s.h"
#include "configmanager.h"
#include "streambase.h"
#include "streamfeature.h"

#include <gloox/adhoc.h>
#include <gloox/base64.h>
#include <gloox/connectionbase.h>
#include <gloox/connectiontls.h>
#include <gloox/dataform.h>
#include <gloox/dataformfield.h>
#include <gloox/iq.h>
#include <gloox/jid.h>
#include <gloox/logsink.h>
#include <gloox/sha.h>
#include <gloox/tlsbase.h>
#include <gloox/util.h>

#include <cstdio>
#include <ctime>
#include <stdio.h>

namespace glooxd
{

  static const char* streamErrorValues[] = {
    "bad-format",
    "bad-namespace-prefix",
    "conflict",
    "connection-timeout",
    "host-gone",
    "host-unknown",
    "improper-addressing",
    "internal-server-error",
    "invalid-from",
    "invalid-id",
    "invalid-namespace",
    "invalid-xml",
    "not-authorized",
    "policy-violation",
    "remote-connection-failed",
    "resource-constraint",
    "restricted-xml",
    "see-other-host",
    "system-shutdown",
    "undefined-condition",
    "unsupported-encoding",
    "unsupported-stanza-type",
    "unsupported-version",
    "xml-not-well-formed"
  };

  static inline const std::string streamErrorValue( gloox::StreamError se )
  {
    return gloox::util::lookup( se, streamErrorValues );
  }

  StreamBase::StreamBase( C2S& parent, ConfigManager& cm, gloox::ConnectionBase* conn,
                  const gloox::LogSink& log )
    : m_parent( parent ), m_cm( cm ),
      m_connection( conn ), m_logInstance( log ),
      m_parser( this, false ), m_exclusiveHandler( 0 ),
      m_threading( false ), m_fakePresence( true ), m_strictXMPP( true )
  {
    if( m_connection )
    {
      gloox::SHA sha;
      sha.feed( m_connection->server() );
      sha.feed( gloox::util::int2string( m_connection->port() ) );
      sha.feed( gloox::util::int2string( time( 0 ) ) );
      m_id = sha.hex();
      m_state = ( StateTransportConnected | StateReset );
      m_connection->registerConnectionDataHandler( this );
      m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaStreamBase ),
                         "Assigning ID: " + m_id );
    }
    else
      m_state = StateDisconnected;
  }

  StreamBase::~StreamBase()
  {
    printf( "in ~StreamBase\n" );
    delete m_connection;
    gloox::util::clearList( m_features );
    gloox::util::clearList( m_incomingQueue );
    gloox::util::clearList( m_outgoingQueue );
    printf( "leaving ~StreamBase\n" );
  }

  void StreamBase::run()
  {
    if( !m_threading && !m_incomingQueue.size()
          && !m_outgoingQueue.size() )
      return;

    do
    {
      m_queueSemaphore.wait();
      if( m_incomingQueue.size() )
      {
        gloox::Tag* t = m_incomingQueue.front();
        m_incomingQueueMutex.lock();
        m_incomingQueue.pop_front();
        m_incomingQueueMutex.unlock();
        handleTag( t );
      }
      else if( m_outgoingQueue.size() )
      {
        gloox::Tag* t = m_outgoingQueue.front();
        m_outgoingQueueMutex.lock();
        m_outgoingQueue.pop_front();
        m_outgoingQueueMutex.unlock();
        send( t );
      }
    } while( m_threading );
  }

  gloox::ConnectionError StreamBase::recv( int timeout )
  {
    if( m_connection )
      return m_connection->recv( timeout );
    else
      return gloox::ConnNotConnected;
  }

  void StreamBase::disconnect( gloox::ConnectionError e,
                           gloox::StreamError se,
                           const std::string& text )
  {
    if( m_fakePresence && !m_self.resource().empty() )
    {
      gloox::Tag* b = new gloox::Tag( "presence" );
      b->addAttribute( "type", "unavailable" );
      stampTag( b );
    }

    if( se != gloox::StreamErrorUndefined )
    {
      gloox::Tag* st = 0;
      if( m_state == ( StateTransportConnected | StateReset ) )
      {
        st = new gloox::Tag( "stream" );
        st->setPrefix( "stream" );
        st->setXmlns( gloox::XMLNS_STREAM, "stream" );
        st->addAttribute( "version", "1.0" );
      }
      gloox::Tag* s = new gloox::Tag( st, "error" );
      s->setPrefix( "stream" );
      gloox::Tag* err = new gloox::Tag( s, streamErrorValue( se ) );
      err->setXmlns( gloox::XMLNS_XMPP_STREAM );
      if( !text.empty() )
      {
        gloox::Tag* txt = new gloox::Tag( err, "text", text );
        txt->setXmlns( gloox::XMLNS_XMPP_STREAM );
      }
      if( st )
        send( st );
      else
      {
        send( s );
        send( "</stream:stream>" );
      }
    }

#ifdef DEBUG
    printf( "disconnecting with reason %d\n", e );
#endif
    int oldState = m_state;

    m_state = StateDisconnected;

    if( m_connection )
      m_connection->disconnect();

    m_parent.disconnect( this );

    if( ( oldState & StateReallyDone ) == StateReallyDone )
      m_cm.handleClientDisconnected( m_self, e, se );
  }

  void StreamBase::handleReceivedData( const gloox::ConnectionBase* /*conn*/, const std::string& data )
  {
    if( m_state == StateDisconnected )
      return;

    std::string copy = data;
    int i = 0;
    if( ( i = m_parser.feed( copy ) ) >= 0 )
    {
      m_logInstance.warn( static_cast<gloox::LogArea>( LogAreaStreamBase ),
                          "parse error (at pos "
                            + gloox::util::int2string( i )
                            + "): " + copy.c_str() );
      disconnect( gloox::ConnParseError, gloox::StreamErrorXmlNotWellFormed, "syntax error" );
    }
  }

  void StreamBase::send( gloox::Tag* tag )
  {
    if( !tag )
      return;

    send( tag->xml() );
    delete tag;
  }

  void StreamBase::send( const gloox::IQ& iq )
  {
    send( iq.tag() );
  }

  void StreamBase::send( const std::string& xml )
  {
    if( m_state == StateDisconnected || !m_connection )
      return;

    m_logInstance.dbg( gloox::LogAreaXmlOutgoing, xml );
    m_connection->send( xml );
  }

  void StreamBase::finishStreamFeature( StreamState state,
                                    gloox::ConnectionBase* conn )
  {
    m_state |= state;

    m_exclusiveHandler = 0;
    if( conn )
      m_connection = conn;
  }

  const gloox::JID StreamBase::name() const
  {
    gloox::JID j = m_parent.name().bare();
    j.setResource( m_id );
    return j;
  }

  void StreamBase::handleConnect( const gloox::ConnectionBase* /*conn*/ )
  {
#ifdef DEBUG
    printf( "should not happen\n" );
#endif
  }

  void StreamBase::handleDisconnect( const gloox::ConnectionBase* /*conn*/, gloox::ConnectionError /*reason*/ )
  {
#ifdef DEBUG
    printf( "detected disconnect\n" );
#endif
    disconnect( gloox::ConnUserDisconnected );
  }

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

    if( tag->name() == "disconnect" && tag->xmlns() == XMLNS_GLOOXD )
    {
      disconnect( gloox::ConnStreamError,
        static_cast<gloox::StreamError>( strtol( tag->cdata().c_str(), 0, 10 ) ) );
      delete tag;
      return;
    }
    m_incomingQueueMutex.lock();
    m_incomingQueue.push_back( tag );
    m_incomingQueueMutex.unlock();
    m_queueSemaphore.post();
  }

  void StreamBase::handleOutgoingTag( gloox::Tag* tag )
  {
    if( !tag )
      return;

    m_outgoingQueueMutex.lock();
    m_outgoingQueue.push_back( tag );
    m_outgoingQueueMutex.unlock();
    m_queueSemaphore.post();
  }

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

    if( m_state == StateDisconnected )
    {
      delete tag;
      return;
    }

    m_logInstance.dbg( gloox::LogAreaXmlIncoming, tag->xml() );

    if( ( m_state & StateReallyDone ) == StateReallyDone ) // shortcut
    {
      stampTag( tag );
      return;
    }

    if( m_exclusiveHandler )
    {
      m_exclusiveHandler->handleTag( tag );
      delete tag;
      return;
    }

    const std::string tname = tag->name(); // no reference!

    if( tname == "stream" && tag->xmlns() == gloox::XMLNS_STREAM )
    {
#ifdef DEBUG
      printf( "greeting\n" );
#endif
      handleStreamGreeting( tag );
      delete tag;
      return;
    }
    else if( ( m_state & StateReallyDone ) != StateReallyDone )
    {
      FeatureList::const_iterator it = m_features.begin();
      for( ; it != m_features.end(); ++it )
      {
        if( tag->findTag( (*it)->filterString() ) )
        {
          m_exclusiveHandler = (*it);
          (*it)->handleTag( tag );
          delete tag;
          return;
        }
      }

      if( ( m_state & StateDone ) == StateDone )
      {
        m_cm.handleClientConnected( m_self, m_connection->localInterface(), m_connection->localPort(),
                                    m_connection->server(), m_connection->port() );
        m_state |= StateReallyDone;
        gloox::util::clearList( m_features ); // not needed anymore
      }
      else
      {
        disconnect( gloox::ConnStreamError, gloox::StreamErrorNotAuthorized );
        delete tag;
        return;
      }
    }

    const std::string type = tag->findAttribute( gloox::TYPE ); // no reference!

    stampTag( tag );

    if( tname == "presence" && type == "unavailable" )
    {
      m_fakePresence = false;
      disconnect( gloox::ConnUserDisconnected );
    }
  }

  void StreamBase::handleStreamGreeting( const gloox::Tag* tag )
  {
    if( !tag )
      return;

    const std::string& to = tag->findAttribute( "to" );

    if( ( m_state & StateReset ) != StateReset )
    {
      disconnect( gloox::ConnStreamError, gloox::StreamErrorPolicyViolation );
      return;
    }

    if ( !tag->hasAttribute( "version", "1.0" ) )
    {
      if( m_strictXMPP )
      {
        m_logInstance.err( static_cast<gloox::LogArea>( LogAreaStreamBase ),
                           "StrictXMPP: Stream " + m_id + " does not send 'version' attribute."
                           " Disconnecting. See C2S::setStrictXMPP()." );
        disconnect( gloox::ConnStreamError, gloox::StreamErrorUnsupportedVersion,
                    "This server mandates XMPP version 1.0 which your client does not seem to support." );
        return;
      }
      else
      {
        m_logInstance.dbg( static_cast<gloox::LogArea>( LogAreaStreamBase ),
                           "StrictXMPP: Stream " + m_id + " does not send 'version' attribute."
                           " Ignoring. See C2S::setStrictXMPP()." );
      }
    }

    if( m_state == ( StateTransportConnected | StateReset ) )
    {
      if( !m_cm.checkDomain( to, m_connection->localInterface(),
                             m_connection->localPort() ) )
      {
        disconnect( gloox::ConnStreamError, gloox::StreamErrorHostUnknown );
        return;
      }
    }
    else if( m_self.server() != to )
    {
      disconnect( gloox::ConnStreamError, gloox::StreamErrorHostUnknown );
      return;
    }

    m_self.setServer( to );

    m_state &= ~StateReset;

    std::string reply = "<stream:stream xmlns:stream='";
    reply += gloox::XMLNS_STREAM;
    reply += "' xmlns='";
    reply += gloox::XMLNS_CLIENT;
    reply += "' from='";
    reply += to;
    reply += "' version='1.0' id='glooxd001'>";
    send( reply );

    gloox::Tag* f = new gloox::Tag( "features" );
    f->setPrefix( "stream" );
    f->setXmlns( gloox::XMLNS_STREAM, "stream" );

    FeatureList::const_iterator it = m_features.begin();
    for( ; it != m_features.end(); ++it )
      f->addChild( (*it)->tag( m_state, to ) );

    send( f );
  }

  void StreamBase::stampTag( gloox::Tag* tag )
  {
    if( !tag )
      return;

    if( !tag->hasAttribute( "from" )
         || tag->findAttribute( "from") != m_self.full() )
      tag->addAttribute( "from", m_self.full() );

    routeTag( tag );
  }

  void StreamBase::routeTag( gloox::Tag* tag )
  {
    if( !tag )
      return;

    m_parent.handleIncomingTag( tag );
  }

}