/*

* Copyright (c) 2006-2009 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 FILES

#ifdef _DEBUG

#include <f32file.h>

#endif

#include <badesca.h>

// sip api

#include <sip.h>

#include <sipconnection.h>

#include <sipconnectionobserver.h>

#include <sipresponseelements.h>

#include <siprequestelements.h>

#include <sipclienttransaction.h>

#include <siprefresh.h>

#include <sipmessageelements.h>

#include <sipsubscribedialogassoc.h>

#include <sipregistrationcontext.h>

// sip codec api

#include <sipfromheader.h>

#include <siptoheader.h>

#include <sipexpiresheader.h>

#include <sipeventheader.h>

#include <sipcontenttypeheader.h>

#include <sipaddress.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

#include <sipextensionheader.h>

#include <sipsubscriptionstateheader.h>

#include <sipsupportedheader.h>

#include <sipacceptheader.h>

#include <cvimpstsettingsstore.h>

// own simple

#include "simplesipconnection.h"

#include "simplesipconnectionobserver.h"

#include "simplesipprofileobserver.h"

#include "simplerefreshtimer.h"

#include "msimpleenginerequest.h"

#include "simpleerrors.h"

#ifdef _DEBUG

#include "simpledebugutils.h"

#ifdef __LOCAL_MODE

// INTERNAL TEST SUITE

#include "simplelocalmodeutils.h"

#endif

#endif

_LIT8 ( KSimpleWINFO, "winfo");

_LIT8 ( KSimplePRESENCE_LOW, "presence");

_LIT8 ( KSimpleEventlist, "eventlist");

_LIT8 ( KSimpleId, "id");

_LIT8 ( KSimpleAnonymous, "\"Anonymous\" <sip:anonymous@anonymous.invalid>");

_LIT8 ( KSimpleDeactivated, "deactivated" );

_LIT8 ( KSimpleProbation, "probation" );

_LIT8 ( KSimpleRejected, "rejected" );

_LIT8 ( KSimpleTimeout, "timeout" );

_LIT8 ( KSimpleGiveup, "giveup" );

_LIT8 ( KSimpleNoresource, "Noresource" );

_LIT8 ( KSipPrefix, "sip:" );

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

//

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

// CSimpleSipConnection::CSimpleSipConnection

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

//

CSimpleSipConnection::CSimpleSipConnection()

: iSip(NULL), iSipConnection(NULL), iConnectionObserver(NULL),

  iSipState( ESimpleSipInactive ),

  iRequestList(CSimpleRequest::LinkOffset()),

  iCurrentNbrSubs( 0 )

    {

    }

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

// CSimpleSipConnection::~CSimpleSipConnection

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

//

EXPORT_C CSimpleSipConnection::~CSimpleSipConnection()

    {

#ifdef _DEBUG

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

    iFs.Close();

#endif

    delete iSipConnection;

    delete iProfileObserver;

    delete iConnectionObserver;

    delete iSip;

    DeleteRequests();

    DeleteRequests( CSimpleRequest::EReqReceiveIM );

    SIPStrings::Close();

    }

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

// CSimpleSipConnection::NewL

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

//

EXPORT_C CSimpleSipConnection* CSimpleSipConnection::NewL()

    {

    CSimpleSipConnection* self = new (ELeave) CSimpleSipConnection;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSimpleSipConnection::ConstructL

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

//

void CSimpleSipConnection::ConstructL()

    {

#ifdef _DEBUG

    TSimpleLogger::Log(

        _L("SipConnection: ConstructL 20-01-07 this=%d" ), (TInt)this );

#endif

    iConnectionObserver = CSimpleSipConnectionObserver::NewL( *this);

    SIPStrings::OpenL();

    // read static cenrep settings

    iSettings.ReadCentRepSettings();

#ifdef _DEBUG

    // read ini file for debug version settings

    (void)iFs.Connect();

    TRAP_IGNORE(iSettings.ReadIniFileL( iFs ));

#endif

    }

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

// CSimpleSipConnection::DispatchReqL

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

//

EXPORT_C void CSimpleSipConnection::DispatchReqL( MSimpleEngineRequest& aReq )

    {

    MSimpleEngineRequest::TSimpleRequest type = aReq.RequestType();

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnection: DispatchReqL type=%d this=%d" ),

        type, (TInt)this );

#endif

    switch ( type )

        {

        case MSimpleEngineRequest::ERegister:

            aReq.SetRefreshTime( 0 );

            RegisterL( aReq );

            break;

        case MSimpleEngineRequest::ESendIM:

            aReq.SetRefreshTime( 0 );

            SendInstantMessageL( aReq );

            break;

        case MSimpleEngineRequest::EReceiveIM:

            aReq.SetRefreshTime( 0 );

            RequestInstantMessageReceivingL( aReq );

            break;

        case MSimpleEngineRequest::EStartPublish:

            aReq.SetRefreshTime( iSettings.ExpiryPuhlish() );

            StartPublishL( aReq );

            break;

        case MSimpleEngineRequest::EPublishModify:

            ModifyPublishL( aReq );

            break;

        case MSimpleEngineRequest::ESubscribe:

            aReq.SetRefreshTime( iSettings.ExpiryWatcher() );

            SubscribeL( aReq);

            break;

        case MSimpleEngineRequest::ESubscribeStop:

            aReq.SetRefreshTime( 0 );

            StopSubscribeL( aReq );

            break;

        case MSimpleEngineRequest::ESubscribeGet:

            aReq.SetRefreshTime( 0 );

            SubscribeL( aReq );

            break;

        case MSimpleEngineRequest::ESubscribeWinfo:

            aReq.SetRefreshTime( iSettings.ExpiryWinfo() );

            SubscribeWinfoL( aReq );

            break;

        case MSimpleEngineRequest::ESubscribeLista:

            aReq.SetRefreshTime( iSettings.ExpiryWatcher() );

            SubscribeListL( aReq );

            break;

        case MSimpleEngineRequest::EStopPublish:

            aReq.SetRefreshTime( 0 );

            StopPublishL( aReq );

            break;

        case MSimpleEngineRequest::EListenEvents:

            aReq.SetRefreshTime( 0 );

            ListenStatusL( aReq );

            break;

        case MSimpleEngineRequest::EDestroy:

            DeleteRequest( aReq );

            break;

        case MSimpleEngineRequest::EDestroyStart:

            DeleteRequestStart( aReq );

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    }

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

// CSimpleSipConnection::SIPStatus

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

//

EXPORT_C TUint CSimpleSipConnection::SIPStatus( 

    TInt aOpId, TInt& aRetryAfter )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnection: SIPStatus this=%d" ), (TInt)this);

#endif

    TDblQueIter<CSimpleRequest> rIter( iRequestList );

    rIter.SetToFirst();

    aRetryAfter = 0;

    while ( rIter )

        {

        CSimpleRequest* req = rIter;

        rIter++; //lint !e1757

        MSimpleEngineRequest& mr = req->Request();

        if ( mr.OpId( ) == aOpId )

            {

            aRetryAfter = req->RetryAfter();

            return req->Status();

            }

        }

    return 0;

    }

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

// CSimpleSipConnection::SIPState

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

//

EXPORT_C TSimpleSipState CSimpleSipConnection::SIPState( )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnection: SIPState returns %d this=%d" ),

        iSipState, (TInt)this );

#endif

    return iSipState;

    }

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

// CSimpleSipConnection::CurrentSIPIdentityL

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

//

EXPORT_C TPtrC8 CSimpleSipConnection::CurrentSIPIdentityL()

    {

    return iProfileObserver->GiveUserAorL();

    }  

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

// CSimpleSipConnection::SipSubscriptionState

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

//

EXPORT_C MSimpleEngineRequest::TSimpleSipSubscriptionState CSimpleSipConnection::SipSubscriptionState( 

    MSimpleEngineRequest& aReq )

    {

    MSimpleEngineRequest::TSimpleSipSubscriptionState retVal = MSimpleEngineRequest::ESimpleStateNone;

    CSimpleRequest* r = GetCliRequest( aReq );             

    if ( r )

        {

        retVal = r->SipSubscriptionState();

        }

    else

        {        

        }

    return retVal;        

    }      

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

// CSimpleSipConnection::RegisterL

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

//

void CSimpleSipConnection::RegisterL( MSimpleEngineRequest& aReq )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnection: RegisterL" ));

#endif

    // Check if already registered

    switch ( iSipState )

        {

        case ESimpleSipInactive:

            {

            if ( !aReq.Aux() )

                {

                // Default profile used

                RegisterDefaultL( aReq );

                }

            else

                {

                RegisterAnyL( aReq );

                }

            }

            break;

        case ESimpleSipActive:

        case ESimpleSipSuspend:

            // The sip connection is already registered,

            // return the callback.

            aReq.Complete( KErrNone );

            break;

        case ESimpleSipIdle:

            {

            // already initiated, just wait

            // Save the request to wait a response

            CSimpleRequest* simpleR = CSimpleRequest::NewL(

                *this, aReq, CSimpleRequest::EReqRegister, aReq.RefreshTime());

            iRequestList.AddLast( *simpleR );

            }

            break;

        case ESimpleSipUnavailable:

        default:

            User::Leave( KErrNotFound );

            break;

        }; //lint !e960

    }

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

// CSimpleSipConnection::ListenStatusL

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

//

void CSimpleSipConnection::ListenStatusL( MSimpleEngineRequest& aReq )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(_L("SipConnection: ListenStatusL" ));

#endif

    // Save the request to wait a response

    CSimpleRequest* simpleR = CSimpleRequest::NewL(

        *this, aReq, CSimpleRequest::EReqListenEvents, aReq.RefreshTime() );

    iRequestList.AddLast( *simpleR );

    }

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

// CSimpleSipConnection::RequestInstantMessageReceivingL

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

//

void CSimpleSipConnection::RequestInstantMessageReceivingL(

    MSimpleEngineRequest& aReq )

    {

#ifdef _DEBUG

    TSimpleLogger::Log( _L(

        "CSimpleSipConnection::RequestInstantMessageReceivingL - Start" ) );

#endif

    // Create the request

    CSimpleRequest* request = CSimpleRequest::NewL( *this,

        aReq, CSimpleRequest::EReqReceiveIM, aReq.RefreshTime() );

    // Save the request into queue

    iRequestList.AddLast( *request );

#ifdef _DEBUG

    TSimpleLogger::Log( _L(

        "CSimpleSipConnection::RequestInstantMessageReceivingL - End" ) );

#endif

    }

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

// CSimpleSipConnection::SendInstantMessageL

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

//

void CSimpleSipConnection::SendInstantMessageL( MSimpleEngineRequest& aReq )

    {

#ifdef _DEBUG

    TSimpleLogger::Log(

        _L( "CSimpleSipConnection::SendInstantMessageL - Start" ) );

#endif

    // Create the request

    CSimpleRequest* request = CSimpleRequest::NewL( *this, aReq,

        CSimpleRequest::EReqSendIM, aReq.RefreshTime() );

    CleanupStack::PushL( request );  // CS: 1

    request->SetDataL( aReq.RequestData() );

    request->SetRequestContentTypeL( aReq.RequestContentType() );

    request->SetRefreshTime( aReq.RefreshTime() );

    if ( ESimpleSipActive == iSipState )

        {

        // Set request state

        request->SetReqState( CSimpleRequest::ESimpleRunningInit );

        const TDesC8& aContent = request->Data();

        if ( !iSipConnection || ESimpleSipActive != iSipState ||

            !iProfileObserver )

            {

            User::Leave( KErrNotReady );

            }

        MSIPRegistrationContext* regContext = iProfileObserver->

            ProfileContext();

        if ( !regContext )

            {

            User::Leave( KErrNotReady );

            }

        // Check CLIENT-OBJ-DATA-LIMIT

        TUint myLimit = iSettings.ObjLimit();

        if ( myLimit && ( TUint )aContent.Size() > myLimit )

           {

           // This is too big mesasge, an error is returned

           User::Leave( KSimpleErrSettingsLimit );

           }

        // Get request URI from a request

        TUriParser8 parser;

        HBufC8* temp = HBufC8::NewLC( KSipPrefix().Length() +

            aReq.Recipient().Length() ); // CS: 2

        temp->Des().Copy( KSipPrefix() );

        temp->Des().Append( aReq.Recipient() );

        User::LeaveIfError( parser.Parse( *temp ));

        CUri8* uri = CUri8::NewL( parser );

        // Start to fill header, Remote URI

        CSIPRequestElements* elems = CSIPRequestElements::NewL( uri );

        CleanupStack::PushL( elems );  // CS: 3

        TUriParser8 parser3;

        User::LeaveIfError( parser3.Parse( iProfileObserver->

            GiveUserAorL() ));

        uri = CUri8::NewL( parser3 );

        CSIPAddress* sipAddress = CSIPAddress::NewL( uri );

        // From Header

        CSIPFromHeader* fromH = CSIPFromHeader::NewL( sipAddress );

        elems->SetFromHeaderL( fromH ); // fromH, ownership given to elems

        uri = CUri8::NewL( parser );

        CSIPAddress* addr = CSIPAddress::NewL( uri );

        // To Header

        CSIPToHeader* toHeader = CSIPToHeader::NewL( addr );

        elems->SetToHeaderL( toHeader );

        CSIPMessageElements& mesElems = elems->MessageElements();

        // Add Expires Header

        if ( aReq.RefreshTime() )

            {

            RPointerArray<CSIPHeaderBase> headers;

            CleanupClosePushL( headers );  // CS: 4

            CSIPExpiresHeader* exprH = new (ELeave) CSIPExpiresHeader(

                aReq.RefreshTime() );

            CleanupStack::PushL( exprH );  // CS: 5

            User::LeaveIfError( headers.Append( exprH ) );

            CleanupStack::Pop( exprH ); // CS: 4

            mesElems.SetUserHeadersL( headers );

            // headers ownership given to mesElems

            CleanupStack::Pop( &headers ); // CS: 3

            }

        // Set content type and content

        HBufC8* buffer = aContent.AllocLC(); // CS: 4

        CSIPContentTypeHeader* contTypeH = CSIPContentTypeHeader::NewL(

            KSimpleMediaType, KSimpleMediaSubType );

        CleanupStack::Pop( buffer ); // CS: 3

        mesElems.SetContentL( buffer, contTypeH );

        // buffer ownership given to mesElems

        // contTypeH ownership given to mesElems

        // Set method

        elems->SetMethodL( SIPStrings::StringF( SipStrConsts::EMessage ) );

        CleanupStack::Pop( elems ); // CS: 2

        // Send the request transaction

        // elems, ownership given

        CSIPClientTransaction* sipTrans = iSipConnection->SendRequestL( elems,

            *regContext );

        // Save SIP client transaction

        request->SetTransaction( sipTrans );

        CleanupStack::PopAndDestroy( temp ); // CS: 1

        // Start refresh timer, it's used for garbage collection too.

        request->StartRefreshTimer();

        }

    else if ( iSipState == ESimpleSipSuspend )

        {

        request->SetReqState( CSimpleRequest::ESimplePendingInit );

        }

    else

        {

        User::Leave( KErrNotReady );

        }

    // Save the request into queue

    iRequestList.AddLast( *request );

    CleanupStack::Pop( request );  // CS: 0

    // Update SOURCE-THROTTLE-PUBLISH time

    if ( iSettings.Throttle() )

        {

        request->SetThrottleTime( iSettings.Throttle() );