/*

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

#include <mmtsy_names.h>

#include <SenServiceConnection.h>   // error codes and framework ids

#include <SenHostletConnection.h>   // error codes for hostlet connections

#include <MSenServiceDescription.h>

#include <MSenConsumerPolicy.h>

#include <SenXmlUtils.h>

#include "senwsdescription.h"

#include "senwspattern.h"

#include <MSenServicePolicy.h>

#include "sencoreservicemanager.h"

#include "senservicemanagerdefines.h"

#include "senclientsession.h"

#include "senxmldao.h"

#include "sencoreshutdowntimer.h"

#include "senserviceinvocationframework.h"  // internal Framework\inc

#include "senservicesession.h"              // internal Framework\inc

#include "sendebug.h"                       // internal Utils\inc

#include "senlogger.h"                      // internal Utils\inc

#include "senguidgen.h"                     // internal Utils\inc

#include "senmultiuseridentitymanager.h"         // internal IdentityManager\inc

#include "sencredentialmanager.h"           // internal CredentialManager\inc

#include "seninternalcredential.h"

// To be kept ONLY UNTIL there are real ECOM transport plug-ins available:

#include "SenHttpTransportProperties.h"

#include "sentransportcontext.h"

#include "sentransport.h"

#include "senservercontext.h"

#include <RSenDocument.h>

#include "senxmldebug.h"

namespace

    {

    const TInt KBase64DecodeMultiplier  = 1;

    const TInt KBase64EncodeMultiplier  = 2;

// Deleted to fix for compiler warning  #177-D

    _LIT(KSOAServerName,"SOAServer");

    const TInt KFlatBufSize            = 64;

    }

CSenCoreServiceManager* CSenCoreServiceManager::NewL()

    {

    CSenCoreServiceManager* pNew = CSenCoreServiceManager::NewLC();

    CleanupStack::Pop();

    return pNew;

    }

CSenCoreServiceManager* CSenCoreServiceManager::NewLC()

    {

    CSenCoreServiceManager* pNew =

        new (ELeave) CSenCoreServiceManager(EPriorityNormal);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenCoreServiceManager::CSenCoreServiceManager(TInt aPriority)

#ifndef RD_SEN_SC_MSG_DISPATCHER_ENABLED // == FALSE, DISPATCHER IS DISABLED   

#ifdef EKA2

:   CPolicyServer(aPriority, coreServiceManagerPolicy, EUnsharableSessions),

  #else

:   CServer2(aPriority, EUnsharableSessions), //IPC V2

  #endif //EKA2

#else // RD_SEN_SC_MSG_DISPATCHER_ENABLED == TRUE, DISPATCHER IS ENABLED

  #ifdef EKA2

:   CPolicyServer(aPriority, coreServiceManagerPolicy, ESharableSessions),

  #else

:   CServer2(aPriority, ESharableSessions), //IPC V2

  #endif //EKA2

#endif //RD_SEN_SC_MSG_DISPATCHER_ENABLED

    iDAO(NULL),

    iIdentityManager(NULL),

    //iTransport(NULL),

    iGuidGenerator(NULL),

    iReader(NULL),

    iNextTransactionId(0)

//    ipActiveHostletEndpoints(NULL)

    {

    }

void CSenCoreServiceManager::ConstructL()

    {

    iShutdownTimer = CSenCoreShutdownTimer::NewL();

    // Start by creating a GUID generator

    iGuidGenerator = CSenGuidGen::NewL();

#ifdef _SENDEBUG

    // Open connection to the file logger server

    // Create a logger

    TLSLOG_OPEN_TO_MODE( KSenCoreServiceManagerLogChannelBase, KSenCoreServiceManagerLogLevel, KSenCoreServiceManagerLogDir, KSenCoreServiceManagerLogFile, EFileLoggingModeAppend );

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenCoreServiceManager::ConstructL - Log file opened [2008-11-12], WSF version 1.9 - build 48");

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("- Core instance (memory address): 0x%X"), this));

//    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,"Zapping filelogged messages (.xml)");

    TLSLOG_OPEN(KSenFaultsLogChannel, KSenFaultsLogLevel, KSenFaults, KSenFaultsLog);

    TLSLOG_OPEN(KSenUtilsLogChannel, KSenUtilsLogLevel, KSenUtils, KSenUtilsLog);

    // zap logged messages (.xml)

//    RFs fss;

//    User::LeaveIfError(fss.Connect() == NULL);

//    CleanupClosePushL(fss);

//

//    fss.Delete(_L("c:\\logs\\WsLog\\AS_init_req.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\AS_init_rsp.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\AS_req.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\AS_rsp.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\DS_lookup_req.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\DS_lookup_rsp.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\service_body_req.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\service_body_rsp.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\service_env_req.xml"));

//    fss.Delete(_L("c:\\logs\\WsLog\\service_env_rsp.xml"));

//    CleanupStack::PopAndDestroy(); // fss.Close()

#endif // _SENDEBUG

#ifdef _RD_SEN_ENABLE_CREDLOG    

    CREDLOG_OPEN();

    CREDLOG_L(KSenCredsLogLevelMin,    "Creds.log level 1: MIN enabled.");

    CREDLOG_L(KSenCredsLogLevelNormal, "Creds.log level 2: NORMAL enabled.");

    CREDLOG_L(KSenCredsLogLevelMax,    "Creds.log level 3: MAX enabled.");

    _LIT8(KTestingCredsLogLine, "[min]: Logging level verification complete.");

    CREDLOG(KSenCredsLogLevelMin, KTestingCredsLogLine);

    _LIT8(KTestingCredsLongLogLine, "[normal] ------------------------------------------------------------------------------"); // could be more that 120 chars or so..

    CREDLOG_ALL(KSenCredsLogLevelNormal, KTestingCredsLongLogLine);

    _LIT8(KTestingCredsLogLineFormat, "[max] - Logging channel is: %d");

    CREDLOG_FORMAT((KSenCredsLogChannel, KSenCredsLogLevelMax, KTestingCredsLogLineFormat, KSenCredsLogChannel)); // on format lines you need to give channel (at the moment)

#endif // _RD_SEN_ENABLE_CREDLOG    

    // Create THE common XML reader inside Serene

    iReader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser

    iIdentityManager = CSenMultiUserIdentityManager::NewL(*this);

    iCredentialManager = CSenCredentialManager::NewL(*this);

    iDAO = CSenXMLDAO::NewL(*(MSenCoreServiceManager*)this);

	CREDLOG_L(KSenCredsLogLevelMin,    "GetImsiImeiL Started");    	

    // Load the sessions from XML-file

    GetImsiImeiL();

	CREDLOG_L(KSenCredsLogLevelMin,    "GetImsiImeiL Completed");    

    iDAO->Load();

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"SenCoreServiceManager starting!");

    // Create server context for SEN.EXE (could be done in thread function as well)

    ipServerContext = CSenServerContext::NewL(*this);

    StartL(KSenServiceManager);

    NotifyFrameworksL(KSenEventWsfReady);

    }

CSenCoreServiceManager::~CSenCoreServiceManager()

    {

    // Delete member variables

    CSenCoreServiceManager::SetShowPasswordDialog(EFalse);

    delete ipServerContext;

    delete iDAO;

    delete iCredentialManager;

    if(iIdentityManager != NULL) // Fix for codescanner warning

    {

    iIdentityManager->WriteDatabase();

    }

    delete iIdentityManager;

    delete iGuidGenerator;

    delete iShutdownTimer;

    delete iReader;

    delete ipVtcpTransport;

//    delete ipVtcpEndpoint;

//    if(ipActiveHostletEndpoints)

//        {

//        ipActiveHostletEndpoints->ResetAndDestroy();

//        delete ipActiveHostletEndpoints;

//        }

#ifdef _SENDEBUG

    TLSLOG_CLOSE(KSenFaultsLogChannel);

    TLSLOG_CLOSE(KSenUtilsLogChannel);

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Log file closed.");

    TLSLOG_CLOSE(KSenCoreServiceManagerLogChannelBase);

#endif // _SENDEBUG

    CREDLOG_CLOSE();

    iStringPool.Close();

//    iLog.Close();

    }

//////////////////////////////////////////////////////////////////////////

// from MSenIdentityManager

MSenIdentity& CSenCoreServiceManager::IdentityL()

    {

    return iIdentityManager->IdentityL();

    }

TInt CSenCoreServiceManager::UserNameL(HBufC8*& aUserName)

    {

    return iIdentityManager->UserNameL(aUserName);

    }

CSenIdentityProvider* CSenCoreServiceManager::IdentityProviderL(

                                                        const TDesC8& aURI )

    {

    if(iIdentityManager)

        return iIdentityManager->IdentityProviderL(aURI);

    else

        return NULL;

    }

CSenIdentityProvider* CSenCoreServiceManager::IdentityProviderL(

                                                const CDesC8Array& aIdpList,

                                                TBool aStrict)

    {

    if(iIdentityManager)

        return iIdentityManager->IdentityProviderL(aIdpList,aStrict);

    else

        return NULL;

    }

CSenIdentityProvider* CSenCoreServiceManager::IdentityProviderL(

                                MSenServiceDescription& aServiceDescription )

    {

    if(iIdentityManager)

        return iIdentityManager->IdentityProviderL(aServiceDescription);

    else

        return NULL;

    }

CSenIdentityProvider* CSenCoreServiceManager::IdentityProviderL(

                                            MSenServiceDescription& aService,

                                            const CDesC8Array& aIdpList,

                                            TBool aStrict)

    {

    if(iIdentityManager)

        return iIdentityManager->IdentityProviderL(aService, aIdpList, aStrict);

    else

        return NULL;

    }

const RPointerArray<CSenIdentityProvider>& CSenCoreServiceManager::IdentityProvidersL()

    {

    if(!iIdentityManager) User::Leave(KErrNotFound);

    return iIdentityManager->IdentityProvidersL();

    }

CSenIdentityProvider* CSenCoreServiceManager::IdentityProviderL()

    {

    if(iIdentityManager)

        return iIdentityManager->IdentityProviderL();

    else

        return NULL;

    }

TInt CSenCoreServiceManager::RegisterIdentityProviderL(

                                                CSenIdentityProvider* aIdp)

    {

    return iIdentityManager->RegisterIdentityProviderL(aIdp);

    }

TInt CSenCoreServiceManager::UnregisterIdentityProviderL(

                                                CSenIdentityProvider& aIdp)

    {

    return iIdentityManager->UnregisterIdentityProviderL(aIdp);

    }

TBool CSenCoreServiceManager::AssociateServiceL(const TDesC8& aServiceID,

                                                const TDesC8& aProviderID )

    {

    return iIdentityManager->AssociateServiceL(aServiceID, aProviderID);

    }

TBool CSenCoreServiceManager::DissociateServiceL(const TDesC8& aServiceID,

                                                 const TDesC8& aProviderID )

    {

    return iIdentityManager->DissociateServiceL(aServiceID, aProviderID);

    }

TInt CSenCoreServiceManager::IdentitiesL( CDesC8Array& aIdentitiesList )

    {

    return iIdentityManager->IdentitiesL( aIdentitiesList );

    }

TInt CSenCoreServiceManager::AuthenticationForL(CSenIdentityProvider& aAccount, TPckgBuf<TSenAuthentication>& aResponse)

    {

    return iIdentityManager->AuthenticationForL( aAccount, aResponse );

    }

//////////////////////////////////////////////////////////////////////////

// getter

MSIF* CSenCoreServiceManager::Framework(const TDesC8& aFrameworkID)

    {

    return(iDAO->Framework(aFrameworkID));

    }

TInt CSenCoreServiceManager::InitServiceConnectionL(MSenRemoteServiceConsumer& aConsumer,

                                                    CSenWSDescription& aPattern,

                                                    HBufC8*& aErrorMsg)

    {

    CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL");

    TInt retVal(KErrNotFound);

//    CSenWSDescription* pSD = iDAO->FindMatchingServiceDescription(aPattern);

    TInt bestScore;

    CSenWSDescription* pSD = 

        iDAO->FindMatchingSDAndBestScoreL(aPattern, bestScore);	//CodeScannerWarnings

    if(!pSD) // service NOT found

        {

         CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

         CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ," - No matching service description in XML database.");

        // request frameworks to search for a matching service

        // as soon as a matching service is found retry the primary search

        TInt additions = iDAO->AddServiceDescriptionToFrameworksL( aPattern, aConsumer, aErrorMsg );

        CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

        TInt error(KErrNone);

        if( additions < 0 )

            {

            error = additions;

            additions = 0;

            }

        CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8(" - Just added %d service description(s)."), additions));

        if ( error )

            {

            retVal = error;

            CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"/ / / / / / / / / / / / / / /");

            CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8(" - Error occurred: (%d)."), error));

            if( aErrorMsg )

                {

                CSLOG_ALL(aConsumer.ConnectionId(),KMinLogLevel ,*aErrorMsg);

                }

             CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"/ / / / / / / / / / / / / / /");

            }

        if( additions > 0 ) // at least one SD was added, and no error occurred

            {

			/* We should now try the primary search again.

			 * Note that we try to pick a service that matches 

			 * at least as well as the best we had earlier

			 * but at least the contract or endpoint should

			 * match.

			 */ 

            pSD = iDAO->FindScoreMatchingServiceDescriptionL(aPattern, bestScore+1);	//CodeScannerWarnings

//            pSD = iDAO->FindMatchingServiceDescription(aPattern);

            }

        }

    if(pSD) // Service was found

        {

        // Update ProviderPolicy information

        pSD->RebuildFrom(aPattern);

        // Update ServicePolicy information

        MSenServicePolicy* servicePolicy = pSD->ServicePolicy();

        if(servicePolicy)

            {

            MSenServicePolicy* givenServicePolicy = aPattern.ServicePolicy();

            if(givenServicePolicy)

                servicePolicy->RebuildServicePolicyFrom(*givenServicePolicy);

            }

#ifdef _SENDEBUG

        TPtrC8 endpoint = pSD->Endpoint();

        if(endpoint.Length()>0)

            {

            CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

           CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8("- Matching service found, endpoint: %S"), &endpoint));

            }

        else

            {

            CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

            CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Matching service found; it has no endpoint.");

            }

#endif // _SENDEBUG

        TPtrC8 patternFrameworkID = pSD->FrameworkId();

        if(patternFrameworkID != KNullDesC8)

            {

            MSIF* pFramework = NULL;

            pFramework = iDAO->Framework( patternFrameworkID );

            if(pFramework)

                {

                CSenServiceSession* pSession = NULL;

                TInt err = pFramework->CreateServiceSessionL(*pSD,

                                                            aPattern,

                                                            pSession,

                                                            aConsumer,

                                                            aErrorMsg);

                CleanupStack::PushL(pSession);

                if( err != KErrNone )

                    {

                    CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

                    CSLOG_FORMAT((aConsumer.ConnectionId(), KMinLogLevel , _L8(" - CreateServiceSessionL failed, error: %d"), err));

                    if ( pSession && pSession != pSD )

                        {

                        // Since session creation failed, delete the returned orphan

                        // object. This should never occur; it is badly against the

                        // "framework design paradigms"):

                        CleanupStack::PopAndDestroy( pSession );

                        }

                    else

                        {

                        // NULL was returned

                        CleanupStack::Pop( pSession );

                        }

                    return err;

                    }

                else

                    {

                    // Create service session OK

                    // Note: isReady in Symbian c == isValid in Java

                    if( pSession && pSession->IsReadyL() )

                        {

                        // bind consumer to the new session:

                        pSession->AddConsumerL(aConsumer);

                        aConsumer.SetSessionL(*pSession);

                        UpdateTouchL(pSession);

                        CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

                        CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ," - CreateServiceSessionL OK!");

                        CleanupStack::Pop(); // pSession

                        return KErrNone;

                        }

                    else

                        {

                        CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"CSenCoreServiceManager::InitServiceConnectionL:");

                        CSLOG_L(aConsumer.ConnectionId(), KMinLogLevel ,"- Removing service description");

                        if(pSession)

                            {

                            iDAO->Remove(*pSession);

                            }

                        else

                            {

                            iDAO->Remove(*pSD);

                            }

                        CleanupStack::Pop(pSession);

                        return KErrNotReady;

                        }

                    }

                }

            }

        }

    // else { // service was not found }

    return retVal;

    }

TInt CSenCoreServiceManager::ServiceDescriptionsL( RWSDescriptionArray& aMatches, const TDesC8& aContract )

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenCoreServiceManager::ServiceDescriptionsL(<contract>)");

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8(" - Collecting existing service descriptions with contract: %S"), &aContract));

    return iDAO->FindAllMatchingServiceDescriptions(aMatches, aContract);

    }

TInt CSenCoreServiceManager::ServiceDescriptionsL(RWSDescriptionArray& aMatches, MSenServiceDescription& aPattern)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenCoreServiceManager::ServiceDescriptionsL(<pattern>)");

    return iDAO->FindAllMatchingServiceDescriptions(aMatches, aPattern);

    }

// Note that this method *always* takes the ownership of the SD

TInt CSenCoreServiceManager::RegisterServiceDescriptionL( CSenWSDescription* apServiceDescription )

    {

    if(!apServiceDescription)

        {