/*

* Copyright (c) 2005 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:  

*

*/

#include <badesca.h>

#include <sip.h>

#include <sipprofile.h>

#include <sipprofileregistry.h>

#include <siphttpdigest.h>

#include <sipservertransaction.h>

#include <siprequestelements.h>

#include <siptoheader.h>

#include <sipaddress.h>

#include <sipmessageelements.h>

#include <sipinvitedialogassoc.h>

#include <sipnotifydialogassoc.h>

#include <sipeventheader.h>

#include <sipexpiresheader.h>

#include <sipmanagedprofile.h>

#include "mcesipstatemachine.h"

#include "mcesipmanager.h"

#include "mceservercore.h"

#include "mcecssession.h"

#include "mcecssessionimplementation.h"

#include "mcesipsession.h"

#include "mcesipconnection.h"

#include "mcemediamanager.h"

#include "mcenatpluginmanager.h"

#include "mcenatsipsession.h"

#include "mceclientserver.h"

#include "mcesrvlogs.h"

#include "mceclient.pan"

#include "mcesipevent.h"

#include "mceclientresolver.h"

#include "mcetimermanager.h"

#include "cleanupresetanddestroy.h"

#define REJECT( transaction )\

        MCESRV_DEBUG("REJECTED");\

        MceSip::DiscardRequest( transaction );\

        return

#define REJECT_IF_ERROR( error, transaction )\

    if ( error != KErrNone )\

        {\

        REJECT( transaction );\

        }

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

// CMceSipManager::NewL

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

//

CMceSipManager* CMceSipManager::NewL (CMceServerCore& aServerCore )

	{

    CMceSipManager* self = CMceSipManager::NewLC( aServerCore );

    CleanupStack::Pop(self);

    return self;

	}

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

// CMceSipManager::NewLC

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

//

CMceSipManager* CMceSipManager::NewLC ( CMceServerCore& aServerCore )

	{

    CMceSipManager* self = new (ELeave) CMceSipManager(aServerCore);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

	}

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

// CMceSipManager::CMceSipManager

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

//

CMceSipManager::CMceSipManager (CMceServerCore& aServerCore)

: iServerCore (aServerCore),

  iNextDialogId( 0 )

	{

	}

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

// CMceSipManager::ConstructL

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

//

void CMceSipManager::ConstructL ()

	{

    MCESRV_DEBUG("CMceSipManager::ConstructL, Entry")

    User::LeaveIfError( iSocketServ.Connect() );	

	iSIP = CSIP::NewL( KServerUid3, *this );

	iProfileRegistry = CSIPProfileRegistry::NewL( *iSIP, *this );

	iMediaManager = CMceMediaManager::NewL( *this );

	iStateMachine = CMceSipStateMachine::NewL();

	iClientResolver = CMceClientResolver::NewL( *this );

	iOrphanSubSessions = CMceCsSessionImplementation::NewL( *this, NULL );

	iTimerManager = CMceTimerManager::NewL();

    MCESRV_DEBUG("CMceSipManager::ConstructL, Exit")

	}

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

// CMceSipManager::~CMceSipManager

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

//

CMceSipManager::~CMceSipManager()

	{

    MCESRV_DEBUG("CMceSipManager::~CMceSipManager, Entry")

    iSIPClientConnections.ResetAndDestroy();

    iSIPClientConnections.Close();

    iClients.Reset();

    iClients.Close();

    if ( iOrphanSubSessions )

        {

        iOrphanSubSessions->RemoveAllSubSessions( EFalse );    

        }

    delete iOrphanSubSessions;

    iProfiles.ResetAndDestroy();

    iProfiles.Close();

    delete iMediaManager;

    delete iStateMachine;

    delete iProfileRegistry;

	delete iClientResolver;

	delete iTimerManager;

    delete iSIP;

    iSocketServ.Close();

    MCESRV_DEBUG("CMceSipManager::~CMceSipManager, Exit")

	}

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

// CMceSipManager::NextDialogId

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

//

TUint32 CMceSipManager::NextDialogId()

    {

    iNextDialogId++;

    return iNextDialogId;

    }

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

// CMceSipManager::RegisterClientL

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

//

void CMceSipManager::RegisterClientL( CMceCsSession& aClientSession )

    {

    MCESRV_DEBUG("CMceSipManager::RegisterClientL, Entry")

    MCESRV_DEBUG_DVALUE("UID", aClientSession.Uid().iUid )

	iClientResolver->RegisterClientL( aClientSession.Uid() );

    iClients.AppendL( &aClientSession );

    MCESRV_DEBUG("CMceSipManager::RegisterClientL, Exit")

    }

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

// CMceSipManager::UnRegisterClient

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

//

void CMceSipManager::UnRegisterClient( CMceCsSession& aClientSession )

    {

    MCESRV_DEBUG("CMceSipManager::UnRegisterClient, Entry")

	iClientResolver->DeregisterClient( aClientSession.Uid() );

    TInt index = iClients.Find( &aClientSession );

    if ( index >= KErrNone )

        {

        iClients.Remove( index );

        }

    else

        {

        MCESRV_DEBUG("UnRegisterClient: CLIENT NOT FOUND")

        }

    MCESRV_DEBUG("CMceSipManager::UnRegisterClient, Exit")

    }

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

// CMceSipManager::MediaManager

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

//

CMceMediaManager& CMceSipManager::MediaManager()

    {

    return *iMediaManager;

    }

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

// CMceSipManager::TimerManager

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

//

CMceTimerManager& CMceSipManager::TimerManager()

    {

    return *iTimerManager;

    }

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

// CMceSipManager::MediaManager

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

//

CSIP& CMceSipManager::SIPClient()

    {

    return *iSIP;

    }

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

// CMceSipManager::ProfileL

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

//

CSIPProfile& CMceSipManager::ProfileL( TUint32 aProfileId )

    {

    CSIPProfile* profile = NULL;

    TInt status = KErrNotFound;

    TInt index = FindProfileById( iProfiles, aProfileId );

    if ( index != KErrNotFound )

        {

        profile = iProfiles[ index ];

        }

    else

        {

        RPointerArray<CSIPProfile> profiles;

        iProfileRegistry->ProfilesL( profiles );

        index = FindProfileById( profiles, aProfileId );

        if ( index != KErrNotFound )

            {

            profile = profiles[ index ];

            status = iProfiles.Append( profile );

            if ( status != KErrNone )

                {

                profile = NULL;

                }

            else

                {

                profiles.Remove( index );

                }

            }

        profiles.ResetAndDestroy();

        profiles.Close();

        }

    if (!profile )

        {

        User::Leave( status );

        }

    return *profile;

    }

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

// CMceSipManager::ProfileL

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

//

CSIPProfile& CMceSipManager::ProfileL( TUint32 /*aIapId*/, 

                                       const CUri8& aRequestUri )

    {

    CSIPProfile* profile = NULL;

    TInt status = KErrNotFound;

    // Try to find in existing profiles 

    // Try matching with request URI

    TInt index = FindProfileByRequestUriL( iProfiles, aRequestUri );

    if ( index != KErrNotFound )

        {

        // found in existing profiles

        profile = iProfiles[ index ];

        }

    else

        {

        // Get all profiles

        RPointerArray<CSIPProfile> profiles;

        MceCleanupResetAndDestroyPushL( profiles );

        iProfileRegistry->ProfilesL( profiles );

        // Try matching with request URI

        index = FindProfileByRequestUriL( profiles, aRequestUri );

        if ( index != KErrNotFound )

            {

            profile = profiles[ index ];

            status = iProfiles.Append( profile );

            if ( status != KErrNone )

                {

                profile = NULL;

                }

            else

                {

                profiles.Remove( index );

                }

            }

        CleanupStack::PopAndDestroy( &profiles );

        }

    if (!profile )

        {

        User::Leave( status );

        }

    return *profile;

    }

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

// CMceSipManager::Cleanup

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

//

void CMceSipManager::Cleanup()

    {

    MCESRV_DEBUG("CMceSipManager::Cleanup, Entry")

    for ( int i = 0; i < iOrphanSubSessions->SubSessions().Count(); i++ )

        {

        CMceCsSubSession* session = iOrphanSubSessions->SubSessions()[i];

        if ( session->CanDispose() ||

             session->Terminate() )

            {

            MCESRV_DEBUG_DVALUE("Cleanup: orphan removed. ID", 

                MCE_SESSION_ID( session ) )

            iOrphanSubSessions->SubSessions().Remove( i );

            delete session;

            i--;

            }

        }

    // If number of orphan subsessions and number of CMceCsSession 

    // object's count are 0, stop MCE server after time out.

    iServerCore.InactiveServerCleanup();

    MCESRV_DEBUG("CMceSipManager::Cleanup, Exit")

    }

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

// CMceSipManager::ConnectionL

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

//

CMceSipConnection& CMceSipManager::ConnectionL( CSIPProfile& aProfile )

    {

	MCESRV_DEBUG("CMceSipManager::ConnectionL, Entry")

	TUint32 iapId = 0;

	aProfile.GetParameter( KSIPAccessPointId, iapId );

    CMceSipConnection* connection = NULL;

    TInt index = 0;

    while ( !connection && index < iSIPClientConnections.Count() )

        {

        if ( iSIPClientConnections[ index ]->AccessPointId() == iapId )

            {

            connection = iSIPClientConnections[ index ];

            }

        index++;            

        }

    if (!connection )

        {

        MCESRV_DEBUG("CMceSipManager::ConnectionL, no connection created")

        MCESRV_DEBUG("CMceSipManager::ConnectionL, Create MceSipConnection")

		connection = 

		    CMceSipConnection::NewLC( *this, aProfile, *iProfileRegistry );

        iSIPClientConnections.AppendL( connection );

        CleanupStack::Pop( connection );

        }

    if ( !iProfileRegistry->IsEnabled( aProfile ) )

    	{

    	iProfileRegistry->EnableL( aProfile, *connection );

        }

    __ASSERT_ALWAYS( aProfile.IsContextActive(), 

                     User::Leave( KErrCouldNotConnect ) ); 

    MCESRV_DEBUG("CMceSipManager::ConnectionL, Exit")

    return *connection;

    }

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

// CMceSipManager::ConnectionL

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

//

CMceSipConnection& CMceSipManager::ConnectionL( TUint32 aIAPId )

    {

    CMceSipConnection* connection = NULL;

    TInt index = 0;

    while ( !connection && index < iSIPClientConnections.Count() )

        {

        if ( iSIPClientConnections[ index ]->AccessPointId() == aIAPId )

            {

            connection = iSIPClientConnections[ index ];

            }

        index++;            

        }

    if ( !connection )

        {

        connection = CMceSipConnection::NewLC( *this, aIAPId );

        iSIPClientConnections.AppendL( connection );

        CleanupStack::Pop( connection );

        }

    return *connection;

    }

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

// CMceSipManager::CreateSubSessionL

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

//

CMceCsSubSession* CMceSipManager::CreateSubSessionL( CMceCsSession& aSession,

                                                     TMceIds& aIds,

                                                     CDesC8Array& aParams )

    {

    MCESRV_DEBUG("CMceSipManager::CreateSubSessionL( by client ), Entry")

    Cleanup();

    TUint32 profileId = aIds.iProfileID;

    TMceCsSessionType sessionType = (TMceCsSessionType)aIds.iManagerType;

    TMceDialogType dialogType = (TMceDialogType)aIds.iDialogType;

    TUint32 dialogId = aIds.iDialogID;

    CMceSipConnection* connection = NULL;

    if ( profileId )

	    {

	    CSIPProfile& profile = ProfileL( profileId );

	    connection = &ConnectionL( profile );   	

	    }

	else

		{

		TInt32 iapId = 0;

		TLex8 accessPoint( aParams.MdcaPoint( KMceArrayIndexIAPId ) );

		accessPoint.Val( iapId );

	    connection = &ConnectionL( iapId );		

		}

    __ASSERT_ALWAYS( connection, User::Leave( KErrCouldNotConnect ) );    	

    CMceCsSubSession* subSession = NULL;

    aIds.iSpare1 = ( connection->State() == CSIPConnection::EActive );

    switch ( sessionType )

        {

        case KMceCSSIPSession:

            {

            if ( iMediaManager->NatPluginManager().NatEnabledL() )

                {

                if( profileId )

                	{

                	MCESRV_DEBUG("CMceSipManager::CreateSubSessionL, NAT SIP session with profile")

                	subSession = CMceNatSipSession::NewLC( aSession,

                                                       *connection,

                                                       *iStateMachine,

                                                       ProfileL( profileId ),

                                                       &aParams );

                	}

                else

                	{

                	MCESRV_DEBUG("CMceSipManager::CreateSubSessionL, NAT SIP session without profile")

                	subSession = CMceNatSipSession::NewLC( aSession,

                                                       *connection,

                                                       *iStateMachine,

                                                       &aParams );

                	}

                }

            else

                {

                if( profileId )

                	{

                    MCESRV_DEBUG("CMceSipManager::CreateSubSessionL, SIP session with profile")

                    subSession = CMceSipSession::NewLC( aSession,

                                                    *connection,

                                                    *iStateMachine,

                                                    ProfileL( profileId ) );

                	}

                else

                	{

                	MCESRV_DEBUG("CMceSipManager::CreateSubSessionL, SIP session without profile")

                	subSession = CMceSipSession::NewLC( aSession,

                                                       *connection,

                                                       *iStateMachine );

                	}

                }

            break;

            }

        case KMceCSSIPEvent:

            {

            MCESRV_DEBUG("CreateSubSessionL: creating SIP event")

            subSession = CMceSipEvent::NewLC( aSession, 

            								  *connection, 

            								  ProfileL( profileId ) );

            break;

            }

        default:

            {

            MCESRV_DEBUG("CreateSubSessionL: NOT SUPPORTED")

            User::Leave( KErrNotSupported );