/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    sip connection

*

*/

#include <sipconnectionobserver.h>

#include <sipmessageelements.h>

#include <sipresponseelements.h>

#include <sipregistrationbinding.h>

#include <sipconnection.h>

#include <siprefresh.h>

#include <sipdialog.h>

#include <sipdialogassocbase.h>

#include <sipsubscribedialogassoc.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

#include <sipclienttransaction.h>

#include <sipservertransaction.h>

#include <siprequestelements.h>

#include <sipretryafterheader.h>

#include <sipextensionheader.h>

#include <sipcontenttypeheader.h>

#include <siperr.h>

#include <sipaddress.h>

#include <sipfromheader.h>

#include "simplecommon.h"

#include "simplesipconnectionobserver.h"

#include "simplesipconncallback.h"

#include "simplerequest.h"

#include "simpleerrors.h"

#ifdef _DEBUG

#include "simpledebugutils.h"

#endif

// SIP response Call/Transaction does not exists

const TUint  KSimple481 = 481;

_LIT8 ( KSimpleBoundary, "boundary" );

_LIT8 ( KSimpleStart, "start");

_LIT8 ( KAt, "@" );

#ifdef _DEBUG

#include "simpledebugutils.h"

#ifdef __LOCAL_MODE

//  INTERNAL TEST SUITE

#include "simplelocalmodeutils.h"

#endif

#endif

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::CSimpleSipConnectionObserver

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CSimpleSipConnectionObserver::CSimpleSipConnectionObserver(

    MSimpleSipConnCallback& aCallback )

    : iCallback( aCallback )

    {

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::~CSimpleSipConnectionObserver

// -----------------------------------------------------------------------------

//

CSimpleSipConnectionObserver::~CSimpleSipConnectionObserver()

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: DESTRUCTOR this=%d"), (TInt)this);

#ifdef __LOCAL_MODE

    /**

     * INTERNAL TEST SUITE

     */

    delete iLocalModeUtils;

#endif        

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::NewL

// -----------------------------------------------------------------------------

//

CSimpleSipConnectionObserver* CSimpleSipConnectionObserver::NewL(

    MSimpleSipConnCallback& aCallback )

    {

    CSimpleSipConnectionObserver* self = new (ELeave) CSimpleSipConnectionObserver( aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: NewL this=%d"), (TInt)self);

#endif

    return self;

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ConstructL

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ConstructL()

    {

#ifdef _DEBUG

#ifdef __LOCAL_MODE

    /**

     * INTERNAL TEST SUITE

     */

    iLocalModeUtils = CSimpleLocalModeUtils::NewL( );

    iLocalModeUtils->SubscribeNetworkStateL( this );

#endif

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ConnectionStateChanged

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ConnectionStateChanged(

    CSIPConnection::TState aState )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ConnectionStateChanged state=%d sip=%d"), aState );

#endif  

    ConnectionStateChanged2( aState, KErrNone );

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ProfileStateChanged

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ProfileStateChanged(

    CSIPConnection::TState aState, TInt aSipError )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ProfileStateChanged state=%d sip=%d"), aState );

#endif

      ConnectionStateChanged2( aState, aSipError );      

    }     

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ProfileUpdated

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ProfileUpdated()

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ProfileUpdated"));

#endif

    iCallback.ConnectionChanged();

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ConnectionStateChanged2

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ConnectionStateChanged2(

    CSIPConnection::TState aState, TInt aSipError )

    {

    TInt retErr = aSipError ? ConvertSipCode( aSipError, EFalse, EFalse ) : KErrNone;

    switch ( aState )

      {

      // Here is a logic, how to tell active state upward after waiting both

      // connection and profile to be ok.

      case CSIPConnection::EInit:

          iCallback.ConnectionStateChange( ESimpleSipIdle, retErr );

          break;

      case CSIPConnection::EActive:                      

         iCallback.ConnectionStateChange( ESimpleSipActive, retErr );

          break;

      case CSIPConnection::ESuspended:

          iCallback.ConnectionStateChange( ESimpleSipSuspend, retErr);

          break;

      case CSIPConnection::EInactive:

          iCallback.ConnectionStateChange( ESimpleSipInactive, retErr );

          break;

      case CSIPConnection::EUnavailable:

          iCallback.ConnectionStateChange( ESimpleSipUnavailable, retErr );

          break;

      default:

          break;

      }; 

    }    

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::IncomingResponse

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::IncomingResponse (

    CSIPClientTransaction& /*aTransaction*/,

    CSIPRegistrationBinding& /*aRegistration*/)

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: IncomingResponse" ));

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ErrorOccured

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ErrorOccured (

    TInt aError,

    CSIPClientTransaction& /*aTransaction*/,

    CSIPRegistrationBinding& /*aRegistration*/)

    {

    iError = aError;

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ErrorOccured 1 err=%d"), aError );

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ErrorOccured

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ErrorOccured (

    TInt aError,

    CSIPRegistrationBinding& /*aRegistration*/)

    {

    iError = aError;

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ErrorOccured 2 err=%d" ), aError);

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ErrorOccured

// This is mainly for Publish errors, no dialog.

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ErrorOccured (

    TInt aError,

    CSIPTransactionBase& aTransaction )

    {

    iError = aError;

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ErrorOccured 3 err=%d" ), aError);

#endif

    if ( aTransaction.IsSIPClientTransaction() )

        {

        CSIPTransactionBase::TState sipState = CSIPTransactionBase::ETrying;

        TRAP_IGNORE( sipState = aTransaction.StateL() );

        CSimpleRequest* r = iCallback.GetRequest(

            STATIC_CAST( CSIPClientTransaction&, aTransaction) );

        if ( r && sipState == CSIPTransactionBase::ETerminated )

            {

            TInt retCode = aError == KErrSIPForbidden ? KErrAccessDenied : KErrCommsBreak;

            r->SetStatus( 0 );

            // update response method

            r->Request().SetResponseMethod( MSimpleEngineRequest::EUnknownResponse );

            r->Complete( retCode );

            }

        else

            {

            // nothing to do

            }

        }

    else

        {

        // nothing to do

        }

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ErrorOccured

// Dialog refresh has failed, a transaction has been deleted.

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ErrorOccured (

    TInt aError,

    CSIPDialogAssocBase& aDialogAssoc )

    {

    // This is called when SUBSCRIBE refresh fails with

    // an error response from a remote server.

    iError = aError;

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ErrorOccured 4 err=%d" ), aError );

#endif

    TInt retCode = aError == KErrSIPForbidden ? KErrAccessDenied : KErrCommsBreak;

    TUint status(0);

    TUint myRefresh(0);

    CSIPSubscribeDialogAssoc& myDialogA = STATIC_CAST( CSIPSubscribeDialogAssoc&, aDialogAssoc );

    const CSIPDialog& myDialog = myDialogA.Dialog();

    CSimpleRequest* r = iCallback.GetdDialogRequest( myDialog );

    if ( !r )

        {

        // request not found

        return;

        }

    if ( aError == KErrSIPTerminatedWithResponse )

        {

        // It's subscription's response with data

        const CSIPRefresh* refresh = myDialogA.SIPRefresh();

        if ( refresh  )

            {

            // This instance is not the initial transaction but

            // the refresh transaction instance.

            // Ownership is not transferred. May be NULL.

            const CSIPClientTransaction* trans = refresh->SIPTransaction();

            if ( trans )

                {

                // ownership isn't transferred.

                // Elems must exist with KErrSIPTerminatedWithResponse

                const CSIPResponseElements* elems = trans->ResponseElements();

               // Get retry-after header value

                myRefresh = GetRetryAfter( elems );

                // Get SIP Status

                status = elems->StatusCode();

                if ( status >= KSimpleOK )

                    {

                    retCode = ConvertSipCode( status, myRefresh ? ETrue: EFalse, EFalse );

                    }

                }

            }

        }

    // Update the request entity and complete it.

    r->SetRetryAfter( myRefresh );

    r->SetStatus( status );

    r->Request().SetResponseMethod( MSimpleEngineRequest::EUnknownResponse );

    r->Complete( retCode );

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ErrorOccured

// Sending of either request or response failed, dialog specific.

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ErrorOccured (

    TInt aError,

    CSIPTransactionBase& aTransaction,

    CSIPDialogAssocBase& /*aDialogAssoc*/)

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ErrorOccured 5 err=%d" ), aError);

#endif

    TInt retCode = aError == KErrSIPForbidden ? KErrAccessDenied : KErrCommsBreak;

    TUint status = 0;

    if ( aTransaction.IsSIPClientTransaction() )

        {

        // This is an initial SUBSCRIBE transaction that has failed.

        CSimpleRequest* r2 = iCallback.GetRequest(

            STATIC_CAST( CSIPClientTransaction&, aTransaction )); 

        if ( !r2 )

            {

            // request not found

            return;

            }                               

        // This instance is the initial transaction.

        CSIPClientTransaction& trans = STATIC_CAST( CSIPClientTransaction&, aTransaction );

        // ownership isn't transferred.

        const CSIPResponseElements* elems = trans.ResponseElements();

        if ( elems )

            {

            status = elems->StatusCode();

            }

        // convert SIP status code

        if ( status >= KSimpleOK )

            {

            retCode = ConvertSipCode( status, EFalse, EFalse );

            }

        r2->SetStatus( status );

        // update response method

        r2->Request().SetResponseMethod( MSimpleEngineRequest::EUnknownResponse );

        r2->Complete( retCode );

        }

    else

        {

        // Server transactions are not handled.

        // An error in responding to NOTIFY request comes here.

        }

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::ErrorOccured

// This is not really needed because of engine does not use standalone CSIPRefesh

// requests.

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::ErrorOccured (

    TInt /*aError*/,

    CSIPRefresh& /*aRefresh*/)

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: ErrorOccured 6" ));

#endif

    }

// -----------------------------------------------------------------------------

// A SIP request outside a dialog has been received from the network.

// CSimpleSipConnectionObserver::IncomingRequest

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::IncomingRequest(

    CSIPServerTransaction* aTransaction )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(

        _L("CSimpleSipConnectionObserver::IncomingRequest" ) );

#endif

    TRAP_IGNORE( DoIncomingRequestL( aTransaction ) );

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::IncomingRequest

// Dialog specific request from server..

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::IncomingRequest (

    CSIPServerTransaction* aTransaction,

    CSIPDialog& aDialog )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: IncomingRequest (dialog)" ));

#endif

    TRAP_IGNORE( DoIncomingRequestL( aTransaction, aDialog ) );

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::IncomingResponse

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::IncomingResponse(

    CSIPClientTransaction& aTransaction)

    {

#ifdef _DEBUG

    TInt status = aTransaction.ResponseElements()->StatusCode();

    TSimpleLogger::Log(_L("SipConnectionObserver: IncomingResponse status=%d" ), status);

#endif

    DoIncomingResponse( aTransaction );

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::IncomingResponse

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::IncomingResponse(

    CSIPClientTransaction& aTransaction,

    CSIPDialogAssocBase& aDialogAssoc)

    {

#ifdef _DEBUG

    TInt status( KErrNone );

    status = aTransaction.ResponseElements()->StatusCode();

    TSimpleLogger::Log(_L("SipConnectionObserver: IncomingResponse (dialog) status=%d"), status);

#endif

    DoIncomingResponse( aTransaction, aDialogAssoc );

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::IncomingResponse

// Invite not supported by SIMPLE

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::IncomingResponse (

    CSIPClientTransaction& /*aTransaction*/,

    CSIPInviteDialogAssoc* /*aDialogAssoc*/)

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: IncomingResponse (invite)" ));

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::InviteCompleted

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::InviteCompleted (

    CSIPClientTransaction& /*aTransaction*/)

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: InviteCompleted" ));

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::InviteCanceled

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::InviteCanceled (

    CSIPServerTransaction& /*aTransaction*/)

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnectionObserver: InviteCanceled" ));

#endif

    }

// -----------------------------------------------------------------------------

// CSimpleSipConnectionObserver::DoHandleSrvrReqContentL

// -----------------------------------------------------------------------------

//

void CSimpleSipConnectionObserver::DoHandleSrvrReqContentL(

    const CSIPMessageElements& aElems,

    MSimpleEngineRequest& aR )

    {

    RStringF boundary = SIPStrings::Pool().OpenFStringL( KSimpleBoundary );

    CleanupClosePushL( boundary );

    RStringF start = SIPStrings::Pool().OpenFStringL( KSimpleStart );