/*

* 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 <f32file.h>

#include <s32file.h>

#include <s32strm.h>

#include <e32std.h>

#include <sysutil.h>

#include <eikenv.h>

#include <s32mem.h>

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

#include <MSenServiceDescription.h>

#include "senwsdescription.h"

#include <SenXmlUtils.h>          // static attribute value getter

#include <SenXmlReader.h>

#include "senprovider.h"

#include "senxmldao.h"

#include "msencoreservicemanager.h"

#include "senservicemanagerdefines.h" // KMaxTicks (1209600000)

                                      // 1 tick = 1 millisec

                                      // 86400 sec = 1 day

                                      // 86400*1000 millisec = 1 day

                                      // 86400*14*1000 = 1209600000 millisec = 2 weeks

#include "senlogger.h"

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

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

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

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

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

#include "senprovider.h"

#include "senlogger.h" 

// CONSTANTS

namespace

    {

    const TInt KFlatBufSize = 128;

#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )

     _LIT(KSenXMLDAOFile,        "C:\\system\\data\\sensessions.xml");

     // since CoreSM & XMLDAO are singleton, single temp file is ok:

     _LIT(KSenXMLDAOTempFile,    "C:\\system\\data\\sensessions.temp.xml");

#else

    _LIT(KSenXMLDAOFile,        "sensessions.xml");

    // since CoreSM & XMLDAO are singleton, single temp file is ok:

    _LIT(KSenXMLDAOTempFile,    "sensessions.temp.xml");

#endif   

    //_LIT(KSenXmlDaoPanic, "SenXmlDao");

    _LIT8(KDefaultFrameworkCue1,

                "com.nokia.Sen.idwsf.IdentityBasedWebServicesFramework");

    _LIT8(KDefaultFrameworkCue2,

                "com.nokia.Sen.wsi.WSIBasicFramework");

    _LIT8(KDefaultFrameworkCue3,

                "com.nokia.Sen.rest.RestServiceFramework");

    _LIT8(KDefaultFrameworkCue4,

                "com.nokia.ws.wsstar.WSStarFramework");

    _LIT8(KDefaultFrameworkCue5,

                "com.nokia.ws.atompub.AtomPubFramework");

    _LIT8(KDefaultFrameworkCue6,

                "com.nokia.ws.ovi.OviFramework");

    _LIT8(KEqual, "=");

    _LIT8(KQuote, "\"");

    _LIT8(KCloseTag, ">");

    _LIT8(KEmptySpace, " ");

    _LIT8(KServiceDescription, "ServiceDescription");

    _LIT8(KFramework, "Framework");

    _LIT8(KClass, "class");

    _LIT8(KProxyHost, "proxyHost");

    _LIT8(KProxyPort, "proxyPort");

    _LIT8(KLocalName, "SenConfiguration");

    _LIT8(KTransport,   "Transport");

    _LIT8(KEndTag, "</SenConfiguration>");

    _LIT8(KStartTag,

            "<SenConfiguration xmlns=\"urn:com.nokia.Sen.config.1.0\">");

    _LIT8(KStartTagEndless,

            "<SenConfiguration xmlns=\"urn:com.nokia.Sen.config.1.0\"");

    _LIT8(KNamespaceName, "urn:com.nokia.Sen.config.1.0");

    _LIT8(KSpace, " ");

    _LIT8(KTouch, "touch");

    // Transport plug-in spesific constants:

    _LIT8(KLocalTransportScheme,                "local");

    _LIT8(KDefaultLocalTransportPluginCue,      "com.nokia.wsf.transport.plugin.local");

    _LIT8(KTcpTransportScheme,                   "tcp");

    _LIT8(KDefaultVirtualTcpTransportPluginCue,  "com.nokia.wsf.transport.plugin.virtualtcp");

    }

CSenXMLDAO* CSenXMLDAO::NewL(MSenCoreServiceManager& aManager)

    {

    CSenXMLDAO* pNew = CSenXMLDAO::NewLC(aManager);

    CleanupStack::Pop();

    return pNew;

    }

CSenXMLDAO* CSenXMLDAO::NewLC(MSenCoreServiceManager& aManager)

    {

    CSenXMLDAO* pNew = new (ELeave) CSenXMLDAO(aManager);

    CleanupStack::PushL(pNew);

    // SenConfiguration xmlns="urn:com.nokia.Sen.config.1.0">

    pNew->ConstructL();

    return pNew;

    }

CSenXMLDAO::CSenXMLDAO(MSenCoreServiceManager& aManager)

    :iManager(aManager),

    iReadingConfig(ESenIdle),

    iErrorState(KErrNone),

    iFileName(KSenXMLDAOFile),

    iSessions(2),

    iFrameworks(2),                     

    iServiceDescription(NULL),

    iFrameworkConfigParser(NULL),

    iDefaultFrameworkCheckedToExist(EFalse),

    iProxyHost(NULL),

    iProxyPort(0),

    iTransportMap(ETrue, ETrue),

    iDefaultTransportMapChecked(EFalse),

    iSharableProviders(2),              

    iUnsharableProviders(ETrue, ETrue) 

    {

    }

void CSenXMLDAO::ConstructL()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO ConstructL()")));

    BaseConstructL(KNamespaceName(), KLocalName());

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO Base done")));

    SetReader(*iManager.XMLReader());

    //Data caging 2 implementation

#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )

    TBuf<KMaxPath> privatePath;

    RFs fss;

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

        CleanupClosePushL(fss);

    fss.CreatePrivatePath(EDriveC);

    fss.PrivatePath(privatePath);

    iFileName.Insert(0,privatePath);

    CleanupStack::PopAndDestroy(1);

#endif

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO ConstructL() done")));

    iCriticalSection.CreateLocal();

    }

CSenXMLDAO::~CSenXMLDAO()

    {

    // Save the XML

    CSenXMLDAO::Save();

    if(iServiceDescription)

        {

        TInt index = iSessions.Find(iServiceDescription);

        if(index==KErrNotFound)

            {

            // would otherwise NOT be taken care by:

            //             iSessions.ResetAndDestroy()

            delete iServiceDescription;

            }

        }

    iSessions.ResetAndDestroy();

    if(iFrameworkConfigParser)

        {

        CSIF* pSIF = (CSIF*) iFrameworkConfigParser;

        TInt index = iFrameworks.Find(pSIF);

        if(index==KErrNotFound)

            {

            // otherwise deleted in ResetAndDestroy() below

            delete iFrameworkConfigParser;

            }

        }

    iFrameworks.ResetAndDestroy();

    if ( iProxyHost )

        {

        delete iProxyHost;

        iProxyHost = NULL;

        }

    iTransportMap.Reset();

    iSharableProviders.ResetAndDestroy();

    iUnsharableProviders.Reset(); // destroys any unloaded / unreleased providers..

    iCriticalSection.Close();

    if( ipTransportDelegate )

        {

        ipTransportDelegate->ExtractElement();

        }

    delete ipTransportDelegate;    

    }

CSenXmlReader* CSenXMLDAO::XMLReader()

    {

    return iManager.XMLReader();

    }

void CSenXMLDAO::Load()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO::Load()")));

    TInt leaveCode(KErrNone);

    TRAP(leaveCode, ReadL());

#ifdef _SENDEBUG

    if(leaveCode!=KErrNone)

        {

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("CSenXMLDAO::Load() - ReadL() leaved: %d"), leaveCode));

        }

#else

    leaveCode = 0; 

#endif

    // Default frameworks are checked (and loaded)after all the frameworks have

    // been parsed in the MIDDLE of PARSING, to PREVENT possibility of orphan

    // SD, if no ID-WSF plug-in was found, for example because ECOM cue

    // (default_data) was wrong. MOVED the installation of default

    // frameworks to be in StartElementL() instead(!)

    // Handle the case where no frameworks or service descriptions were found 

    // from sensessions.xml

    if(!iDefaultFrameworkCheckedToExist)

        {

        TInt retVal = CheckDefaultFrameworks();

        retVal = 0; // not used currently

        iDefaultFrameworkCheckedToExist=ETrue;

        }

    if(!iDefaultTransportMapChecked)

        {

        TInt retCode = CheckDefaultTransports();

        iDefaultTransportMapChecked=ETrue;

        retCode=0; // not used currently

        }

    iReadingConfig = ESenIdle;

    // This way the sensessions.xml -file is validated,

    // and expired sessions will be deleted, etc..

    TInt saveRetVal = Save();

    saveRetVal = 0; // not used currently

    }

TInt CSenXMLDAO::Save()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO::SaveSessions()")));

    TInt notifyLeaveCode(KErrNone);

    TRAP(notifyLeaveCode, NotifyFrameworksL(KNullDesC8, KSenEventSessionsDbWriteBegin, NULL));

    TInt leaveCode(KErrNone);

    TRAP(leaveCode, WriteL());

    TRAP(notifyLeaveCode, NotifyFrameworksL(KNullDesC8, KSenEventSessionsDbWriteComplete, NULL));

    iManager.SaveCredentialDB();

    notifyLeaveCode = 0; // not used

    return leaveCode;

    }

MSIF* CSenXMLDAO::Framework(const TDesC8& aFrameworkId)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenXMLDAO::Framework");

    CSIF* pFramework = NULL;

    TInt count(iFrameworks.Count());

    for (TInt i=0; i<count; i++)

        {

        if(iFrameworks[i])

            {

            const TDesC8& frameworkId = iFrameworks[i]->Id();

            if(frameworkId == aFrameworkId)

                {

                pFramework = iFrameworks[i];

                break;

                }

            }

        }

    if(pFramework)  TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"  framework found:");//LOG_WRITE_L("  framework found:");

    else TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"  could not find:");        //   LOG_WRITE_L("  could not find:");

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(aFrameworkId));

    return pFramework;

    }

MSIF* CSenXMLDAO::DefaultFrameworkL(const TDesC8& aFrameworkID, 

                                    const TDesC8& aCue)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO::DefaultFramework()")));

    MSIF* pFramework = Framework(aFrameworkID);

    if(!pFramework)

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO::DefaultFramework() is not installed:")));

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(aFrameworkID));

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(aCue));

        TRAPD(leaveCode, iManager.InstallFrameworkL(aCue));

        if(leaveCode==KErrNone)

            {

            pFramework = Framework(aFrameworkID);

            if(pFramework)

                {

                TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(_L("CSenXMLDAO::DefaultFramework() - now installed.")));

                }

            }

#ifdef _SENDEBUG

        else

            {

            // install framework failed!

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO::DefaultFramework() - install failed:")));

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"FATAL!");

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(aCue));

            }

#endif //_SENDEBUG

        }

#ifdef _SENDEBUG

    else

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(_L("CSenXMLDAO::DefaultFramework() - was already installed:")));

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(aFrameworkID));

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(aCue));

        }

#endif //_SENDEBUG

    return pFramework;

    }

RFileLogger* CSenXMLDAO::Log() const

    {

    return iManager.Log();

    }

TInt CSenXMLDAO::SizeOfSessionsXmlInBytesL()

    {

    TInt size(0);

    TInt count = iSessions.Count();

    CBufFlat* pBuf = NULL;

    for(TInt i = 0; i < count; i++)

        {

        pBuf = CBufFlat::NewL(KFlatBufSize);

        CleanupStack::PushL(pBuf);

        RBufWriteStream bufWs(*pBuf);

        CleanupClosePushL(bufWs);

#ifdef _SENDEBUG

        TPtrC8 e = iSessions[i]->Endpoint();

        TPtrC8 c = iSessions[i]->Contract();

        TPtrC8 fid = iSessions[i]->FrameworkId();

        TInt leaveCode(KErrNone);

        TRAP( leaveCode, iSessions[i]->WriteAsXMLToL(bufWs); )

        if( leaveCode )

            {

            TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("FATAL: CSenXMLDAO::SizeOfSessionsXmlInBytesL leaved:   %d"), leaveCode));

            TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel, _L8("     : endpoint: '%S', contract: '%S', frameworkID: '%S'"), &e, &c, &fid));

            }

        User::LeaveIfError(leaveCode);

#else // release builds

        iSessions[i]->WriteAsXMLToL(bufWs);

#endif // _SENDEBUG        

        TPtr8 p8 = pBuf->Ptr(0);

        size += p8.Length();

        CleanupStack::PopAndDestroy(2); // bufWs (close), pBuf

        pBuf = NULL;

        }

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("CSenXMLDAO::SizeOfSessionsXmlInBytesL:   %d"), size));

    return size;

    }

TInt CSenXMLDAO::SizeOfFrameworksXmlInBytesL()

    {

    TInt size(0);

    HBufC8* pTemp = NULL;

    TInt frameworks = iFrameworks.Count();

    for (TInt j = 0; j < frameworks; j++)

        {

        pTemp = iFrameworks[j]->AsXmlL();

        if(pTemp)

            {

            CleanupStack::PushL(pTemp);

            size += pTemp->Length();

            CleanupStack::PopAndDestroy(); // pTemp

            pTemp = NULL;

            }

        }

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("CSenXMLDAO::SizeOfFrameworksXmlInBytesL: %d"), size));

    return size;

    }

void CSenXMLDAO::WriteL()

    {

    if (iReadingConfig != ESenIdle)

        {

        iReadingConfig = ESenSaveNeeded;

        return;

        }

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CSenXMLDAO::WriteL()")));

    CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

    CleanupStack::PushL(pBuf);

    RBufWriteStream bufWs(*pBuf);

    CleanupClosePushL(bufWs);

    if ( !iProxyHost )

        {

        bufWs.WriteL(KStartTag);

        }

    else

        {

        bufWs.WriteL( KStartTagEndless );

        bufWs.WriteL( KEmptySpace );

        bufWs.WriteL( KProxyHost );

        bufWs.WriteL( KEqual );

        bufWs.WriteL( KQuote );

        bufWs.WriteL(*iProxyHost);

        bufWs.WriteL( KQuote );

        bufWs.WriteL( KEmptySpace );

        bufWs.WriteL( KProxyPort );

        bufWs.WriteL( KEqual );

        bufWs.WriteL( KQuote );

        HBufC8* pPort = HBufC8::NewLC(5);

        TPtr8 pPtrPort = pPort->Des();

        pPtrPort.AppendNum( iProxyPort );

        bufWs.WriteL( *pPort );

        CleanupStack::PopAndDestroy( pPort );

        bufWs.WriteL( KQuote );

        bufWs.WriteL( KCloseTag );

        }

    // Now ensure that we have enough disk space for

    // new configuration file!

    TInt configFileSize(0);

    TPtr8 p8 = pBuf->Ptr(0);

    // calculate and add required space for sessions as XML (in bytes)

    configFileSize += SizeOfSessionsXmlInBytesL(); 

    // calculate and add required space for frameworks as XML (in bytes)

    configFileSize += SizeOfFrameworksXmlInBytesL(); 

    // add size of root element start tag (in bytes)

    configFileSize += p8.Length();

    // add size of root element close tag (in bytes)

    configFileSize += KEndTag().Length();

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("CSenXMLDAO::WriteL() - Base config size: %d bytes"), p8.Length()));

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("CSenXMLDAO::WriteL() - Config file size: %d bytes"),  configFileSize));

    // Now use SysUtils to ensure that we have room for temp file(!)

    RFs fss;

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

    CleanupClosePushL(fss);

    // Create and open write stream to temp file

    TFileName tempFile(KSenXMLDAOTempFile);

    // this will create the file or replace and zero-length any existing file

    // and might free some space, if write failed last time..

    RFileWriteStream tempFileWriteStream;

    CleanupClosePushL(tempFileWriteStream);

    tempFileWriteStream.Replace(fss, tempFile, EFileWrite);