/*

* 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 "senservicemanagerimpl.h"

#include <SenIdentityProvider.h>

#include <SenXmlUtils.h>

#include <SenServiceConnection.h>  // WSF error codes

#include "senservicemanagerdefines.h" // IPC enumerations

#include "sendebug.h" // filelogging MACROs

#include "senlogger.h"

#include "senguidgen.h"

#include "senchunk.h"

#include <SenCredential2.h>

#include "senxmldebug.h"

namespace

    {

    const TInt KMaxChunkNumDecimals = 64;

    _LIT8(KIdentityProviderName, "IdentityProvider");

    }

CSenServiceManagerImpl* CSenServiceManagerImpl::NewL()

    {

    CSenServiceManagerImpl* pNew = NewLC();

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceManagerImpl* CSenServiceManagerImpl::NewLC()

    {

    CSenServiceManagerImpl* pNew = new (ELeave) CSenServiceManagerImpl(NULL);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenServiceManagerImpl* CSenServiceManagerImpl::NewL(MSenAuthenticationProvider& aAuthProvider)

    {

    CSenServiceManagerImpl* pNew = NewLC(aAuthProvider);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceManagerImpl* CSenServiceManagerImpl::NewLC(MSenAuthenticationProvider& aAuthProvider)

    {

    CSenServiceManagerImpl* pNew = new (ELeave) CSenServiceManagerImpl(&aAuthProvider);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

void CSenServiceManagerImpl::ConstructL()

    {

    TInt connAttemp = 0;

    TInt connErr = KErrGeneral;

    ipGenerator = CSenGuidGen::NewL();

    ipChunkName = HBufC::NewL(KSenUuidMaxLength+KMaxChunkNumDecimals);

    TLSLOG_OPEN(KSenServiceManagerLogChannel, KSenServiceManagerLogLevel, KSenServiceManagerLogDir, KSenServiceManagerLogFile);

    connErr = iConnection.Connect();

    while ( (connErr == KErrServerBusy || connErr == KErrServerTerminated) 

                     & connAttemp < KSenMaxClientConnectionOpeningAttempts )

        {

        User::After(1000000); // wait for a second if server has been shut down

        connErr = iConnection.Connect();

        connAttemp++;

        }

    if ( connErr != KErrNone )

        {

        User::Leave( connErr );

        }

    iConnectionID = iConnection.ConnectionID();

    iConnection.SetChannel(KSenServiceManagerLogChannelBase+iConnectionID);   

    //iTlsLogChannel = KSenServiceManagerLogChannelBase + iConnectionID;

#ifdef _SENDEBUG

    RThread thread;

    RProcess process;

    TFileName logFile;

    logFile.Append( KSenServiceManagerLogFile().Left(KSenServiceManagerLogFile().Length()-4) ); // exclude ".log" file extension

    logFile.AppendNum( iConnectionID );

    logFile.Append( KSenUnderline );

    logFile.Append( process.Name().Left(32));

    logFile.Append( KSenUnderline );

    logFile.Append( thread.Name().Left(20));

    logFile.Append( KSenServiceManagerLogFile().Right(4) ); // postfix with ".log" file extension

    // Open connection to the file logger server

    TLSLOG_OPEN(KSenServiceManagerLogChannelBase+iConnectionID, KSenServiceManagerLogLevel, KSenServiceManagerLogDir, logFile);

    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManager::ConstructL - Log file opened");

    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("- Connection ID: (%d)"), iConnectionID));

    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"- Service Manager client ready.");

#endif

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

    }

CSenServiceManagerImpl::CSenServiceManagerImpl(MSenAuthenticationProvider* apAuthProvider)

:   iConnection(),//&iLog),

    iReader(NULL),

    iInBuffer(NULL,0),

    iOutBuffer(NULL,0),

    iInitialized(EFalse),

    ipGenerator(NULL),

    ipChunkName(NULL),

    iChunkNameNumber(0),

    ipAuthProvider(apAuthProvider),

    iConnectionID(KErrNotReady) //,

//    iTlsLogChannel(KSenServiceManagerLogChannelBase)

    {

    CActiveScheduler::Add(this);

    }

CSenServiceManagerImpl::~CSenServiceManagerImpl()

    {

    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManagerImpl::~CSenServiceManagerImpl");

    Cancel(); // Causes call to DoCancel()

    iConnection.Close();

    delete iReader;

    delete iOutBuf;

    delete ipGenerator;

    delete ipChunkName;

    // Close the log file and the connection to the server.

    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("Log file closed.")));

    TLSLOG_CLOSE (KSenServiceManagerLogChannelBase+iConnectionID);

    TLSLOG_CLOSE (KSenServiceManagerLogChannel);

    }

void CSenServiceManagerImpl::RunL()

    {

    }

void CSenServiceManagerImpl::DoCancel()

    {

    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceManagerImpl::DoCancel")));

    }

TInt CSenServiceManagerImpl::Identifier()

    {

    return iConnectionID;    

    }

/*

RFileLogger* CSenServiceManagerImpl::Log() const

    {

    return (RFileLogger*) &iLog;

    }

*/

TPtrC CSenServiceManagerImpl::NextChunkNameL()	//Codescannerwarnings

    {

    if(ipChunkName)

        {

        iChunkNameNumber++;

        TPtr chunkname = ipChunkName->Des();

        chunkname.Zero();

        HBufC* pRandomGuid = ipGenerator->GetRandomGuidLC();

        TPtr idBuffer = pRandomGuid->Des();

        if(idBuffer.Length()>KSenUuidPrefixLength)

            {

            chunkname.Append(idBuffer.Right(idBuffer.Length()-KSenUuidPrefixLength));

            }

        CleanupStack::PopAndDestroy(); // pRandomGuid

        chunkname.AppendNum(iChunkNameNumber);

        // Remove dashes

         _LIT(KDash, "-");

        TInt pos = chunkname.Find(KDash);

        while (pos != KErrNotFound)

            {

            chunkname.Replace(pos, KDash().Length(), KNullDesC);

            pos = chunkname.Find(KDash);

            }

        TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KNormalLogLevel , _L("CSenServiceManagerImpl::NextChunkNameL(): %S"), &chunkname));

        return chunkname;

        }

    else

        {

        return KNullDesC();

        }  

    }

// Parameter aUri is contract of the service

TInt CSenServiceManagerImpl::ServiceDescriptionsL(const TDesC8& aUri, 

                                                  RServiceDescriptionArray& aList)

    {

    TInt retVal(KErrNone);

    TPtrC8 descriptions;

    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings

    //pSenChunk->SetLogger(Log());

    retVal = pSenChunk->CreateChunk();

    if (retVal == KErrNone)

        {

        retVal = pSenChunk->DescToChunk(aUri);

        if (retVal == KErrNone)

            {

            retVal = iConnection.ServiceDescriptionsByUriL(*pSenChunk);

            if (retVal == KErrNone)

                {

                retVal = pSenChunk->DescFromChunk(descriptions);

                if(retVal == KErrNone)

                    {

                    retVal = ExtractServiceDescriptionsL(descriptions, aList);

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy(pSenChunk); // Close chunk

    return retVal;

    }

TInt CSenServiceManagerImpl::ServiceDescriptionsL(MSenServiceDescription& aSD,

                                                  RServiceDescriptionArray& aList)

    {

    TInt retVal(KErrNone);

    HBufC8* pPattern = aSD.AsXmlL();

    CleanupStack::PushL(pPattern);

    TPtrC8 descriptions;

    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings

    //pSenChunk->SetLogger(Log());

    retVal = pSenChunk->CreateChunk();

    if (retVal == KErrNone)

        {

        retVal = pSenChunk->DescToChunk(*pPattern);

        if (retVal == KErrNone)

            {

            retVal = iConnection.ServiceDescriptionsByPatternL(*pSenChunk);

            if(retVal == KErrNone)

                {

                retVal = pSenChunk->DescFromChunk(descriptions);

                if(retVal == KErrNone)

                    {

                    retVal = ExtractServiceDescriptionsL(descriptions, aList);

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy(pSenChunk); // Close chunk

    // In any case, destroy the pattern as XML buffer:

    CleanupStack::PopAndDestroy(); // pPattern

    return retVal;

    }

TInt CSenServiceManagerImpl::RegisterServiceDescriptionL(MSenServiceDescription& aSD)

    {

    // do not register if both endpoint and contract are 

    // missing

    if(aSD.Endpoint().Length()==0 && aSD.Contract().Length()==0)

        {

        return KErrSenNoContractNoEndPoint;

        }

    else 

        {

        _LIT8(KProviderID,"ProviderID");

        HBufC8* pAsXml = NULL;

        if ( aSD.DescriptionClassType() ==

                MSenServiceDescription::EIdentityProvider )

            {

            TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("RegisterServiceDescriptionL with EIdentityProvider ")));

            CSenIdentityProvider* pIdP = (CSenIdentityProvider*)&aSD;

            CSenXmlServiceDescription* pSD = CSenXmlServiceDescription::NewLC(

                    pIdP->Endpoint(),

                    pIdP->Contract()  );

            pSD->SetFrameworkIdL( pIdP->FrameworkId() );

            pSD->AsElement().AddElementL(KProviderID).SetContentL(

                                                            pIdP->ProviderID() );	//CodeScannerWarnings

            pAsXml = pSD->AsXmlL(); // leaves if no memory available

            CleanupStack::PopAndDestroy(); // pSD

            }

        else    // ServiceDescription

            {

            pAsXml = aSD.AsXmlL(); // leaves if no memory available

            }

        CleanupStack::PushL(pAsXml); // must be the first line after if-clause

        TPtr8 ptr = pAsXml->Des();

        // now register the XML string (descriptor) to WSF Symbian server:

        TInt retVal(iConnection.RegisterServiceDescription(ptr));

        CleanupStack::PopAndDestroy(); // pAsXml

        return retVal;

        }

    }

TInt CSenServiceManagerImpl::UnregisterServiceDescriptionL(

                                                MSenServiceDescription& aSD)

    {

    // do not unregister if both endpoint and contract are 

    // missing

    if(aSD.Endpoint().Length()==0 && aSD.Contract().Length()==0)

        {

        return KErrSenNoContractNoEndPoint;

        }

    else 

        {

        HBufC8* pAsXml = NULL;

        if ( aSD.DescriptionClassType() ==

            MSenServiceDescription::EIdentityProvider )

            {

            TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("UnregisterServiceDescriptionL with EIdentityProvider ")));

            CSenIdentityProvider* pIdP = (CSenIdentityProvider*)&aSD;

            CSenXmlServiceDescription* pSD = 

                CSenXmlServiceDescription::NewLC(pIdP->Endpoint(),

                                                 pIdP->Contract());

            pSD->SetFrameworkIdL( pIdP->FrameworkId() );

            if(pIdP->ProviderID().Length()>0)

                {

		        _LIT8(KProviderID,"ProviderID");

                CSenElement& providerIdElement = 

                    pSD->AsElement().AddElementL(KProviderID);	//CodeScannerWarnings

                providerIdElement.SetContentL(pIdP->ProviderID());

                }

            pAsXml = pSD->AsXmlL(); // leaves if no memory available

            CleanupStack::PopAndDestroy(); // pSD

            }

        else    // ServiceDescription

            {

            pAsXml = aSD.AsXmlL(); // leaves if no memory available

            }

        CleanupStack::PushL(pAsXml); // must be the first line after if-clause

        TPtr8 ptr = pAsXml->Des();

        TInt retVal(iConnection.UnregisterServiceDescription(ptr));

        CleanupStack::PopAndDestroy(); // pAsXml

        return retVal;

        }

    }

// comment: remote developer interface to identity manager

TInt CSenServiceManagerImpl::RegisterIdentityProviderL(

                                            CSenIdentityProvider& aProvider)

    {

    HBufC8* provider = aProvider.AsXmlL();

    TPtr8 ptr = provider->Des();

    TInt retVal = iConnection.RegisterIdentityProvider(ptr);

    delete provider;

    return retVal;

    }

TInt CSenServiceManagerImpl::UnregisterIdentityProviderL(

                                            CSenIdentityProvider& aProvider)

    {

    HBufC8* provider = aProvider.AsXmlL();

    TPtr8 ptr = provider->Des();

    TInt retVal(iConnection.UnregisterIdentityProvider(ptr));

    delete provider;

    return retVal;

    }

TInt CSenServiceManagerImpl::AssociateServiceL(const TDesC8& aServiceID,

                                               const TDesC8& aProviderID)

    {

    if (aServiceID.Length() <= 0 || aProviderID.Length() <= 0)

        {

        return KErrArgument;

        }

    TInt retVal( iConnection.AssociateService(  (TDesC8&)aServiceID,

                                                (TDesC8&)aProviderID) );

    return retVal;

    }

TInt CSenServiceManagerImpl::DissociateServiceL(const TDesC8& aServiceID,

                                                const TDesC8& aProviderID)

    {

    if (aServiceID.Length() <= 0 || aProviderID.Length() <= 0)

        {

        return KErrArgument;

        }

    TInt retVal( iConnection.DissociateService( (TDesC8&)aServiceID,

                                                (TDesC8&)aProviderID) );

    return retVal;

    }

TInt CSenServiceManagerImpl::InstallFrameworkL(const TDesC8& aFrameworkId)

    {

    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceManager::InstallFrameworkL")));

    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(aFrameworkId));

    if (aFrameworkId.Length() <= 0)

        {

        return KErrArgument;

        }

    TInt retVal( iConnection.InstallFramework((TDesC8&)aFrameworkId) );

    return retVal;

    }

TInt CSenServiceManagerImpl::ExtractServiceDescriptionsL(TPtrC8& aSDs, 

                                                          RServiceDescriptionArray& aList)

    {

    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManagerImpl::ExtractServiceDescriptionsL");

    TInt retVal(KErrNotFound);

    if (aSDs.Length() > 0)

        {

        TPtrC8 single;

        TPtrC8 rest;

        _LIT8(KTab, "\t");

        TBool loop(ETrue);

        TInt pos(-1);

        CSenXmlServiceDescription* desc = NULL;

        rest.Set(aSDs);

        while (loop)

            {

            pos = rest.Find(KTab());

            if (pos > 0)

                {

                desc = CSenXmlServiceDescription::NewLC();

                iReader->SetContentHandler(*desc);

                desc->SetReader(*iReader);

                single.Set(rest.Left(pos));

                TInt leaveCode(KErrNone);

                TRAP(leaveCode, desc->ParseL(single));

                if(leaveCode!=KErrNone)

                    {

                    TInt count(aList.Count());

                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("-desc->ParseL(#%d): parsing failed: %d"), count+1, leaveCode));

                    CleanupStack::PopAndDestroy(); // desc

                    if(count == 0)

                        {

                        retVal = KErrNotFound; // could not parse single service description

                        }

                    break;

                    }

                rest.Set(rest.Mid(pos+1));  // Check

                retVal = aList.Append(desc);

                if(retVal == KErrNone)

                    {

                    CleanupStack::Pop(); // desc

                    }

                else

                    {

                    CleanupStack::PopAndDestroy();

                    }

                desc = NULL;

                }

            else

                {

                desc = CSenXmlServiceDescription::NewLC();

                iReader->SetContentHandler(*desc);

                desc->SetReader(*iReader);

                TInt leaveCode(KErrNone);

                TRAP(leaveCode, desc->ParseL(rest));

                if(leaveCode!=KErrNone)

                    {

                    TInt count(aList.Count());

                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("-desc->ParseL(#%d): parsing failed: %d"), count+1, leaveCode));

                    CleanupStack::PopAndDestroy(); // desc

                    if(count == 0)

                        {

                        retVal = KErrNotFound; // could not parse single service description

                        }

                    break;

                    }

                retVal = aList.Append(desc);

                if(retVal == KErrNone)

                    {

                    CleanupStack::Pop(); // desc

                    }

                else

                    {

                    CleanupStack::PopAndDestroy();

                    }

                desc = NULL;

                break;

                }

            if (rest.Length() == 0 )

                {

                break;

                }