/*

* Copyright (c) 2008 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 "wsovioauthclient.h"

#include <s32mem.h>

#include <f32file.h>

#include <s32file.h>

#include <SenXmlUtils.h>

#include "sencryptoutils.h"

#include "wsoviservicesession.h"

#include "SenXmlUtils.h"

#include "msencoreservicemanager.h"

#include "sendebug.h"

#include "senlogger.h"

#include "MSenServiceDescription.h"

#include "SenServiceConnection.h"

#include "seninternalserviceconsumer.h"

#include <SenCredential.h>

#include "wsoviplugin.h"

#include "SenHttpTransportProperties.h"

#include "senwspattern.h"

#include "wsovicons.h"

#include "wsovitokencreationresponse.h"

#include "sencryptoutils.h"

#include "wsoviutils.h"

namespace 

    {

    _LIT8(KRemoteConsumer,       "RemoteConsumer");

    }

using namespace OAuth;

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

// Creates and returns a new instace of this class.

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

//

CWSOviOAuthClient* CWSOviOAuthClient::NewL(

                                                        CSIF& aSIF)

    {

    CWSOviOAuthClient* pNew = NewLC(aSIF);

    CleanupStack::Pop(pNew);

    return pNew;

    }

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

// Creates and returns a new instace of this class and leaves the object on the cleanup stack

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

//

CWSOviOAuthClient* CWSOviOAuthClient::NewLC(

                                                        CSIF& aSIF)

    {

    CWSOviOAuthClient* pNew =

        new (ELeave) CWSOviOAuthClient(

                    aSIF,

                    MSenServiceDescription::EOviOAuthClient);

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL();

    return pNew;

    }

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

// Constructor

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

//

CWSOviOAuthClient::CWSOviOAuthClient(

                                                CSIF& aSIF,

                                                TDescriptionClassType aType)

    : CSenInternalServiceConsumer(aType, aSIF)

    {

    }

void CWSOviOAuthClient::BaseConstructL()

    {

    CSenInternalServiceConsumer::ConstructL();

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSOviOAuthClient::ConstructL()")));

    }

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

// Destructor

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

//

CWSOviOAuthClient::~CWSOviOAuthClient()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::~CWSOviTrustClient");

    delete iAuthSession;

    delete iBody;

    }

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

// The most siginificant method of this class. Make validation of session, 

//    credentails obtained if needed.

//    Sequential logic, synchronized, 

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

//

TInt CWSOviOAuthClient::ValidateL( CWSOviServiceSession& aSession,

                                    HBufC8*& aErrorMessage,

                                    TBool aOnlySharing )

    {

//    iAuthSession->CompleteServerMessagesOnOffL(ETrue);

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::ValidateL(..)");

    TInt retVal(KErrNone);            // for returning error codes

    iWSOviServiceSession = &aSession;            // save session

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

//0  token sharing, only if scope of token is not applied

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

    TBool sharingSucceed = EFalse;

    RPointerArray<CSenWSDescription> oviSDs;

    CleanupClosePushL(oviSDs);

    CSenWSPattern* pattern = CSenWSPattern::NewLC();

    //select * from session_of_SD where session is (ovi framework, and has same provideId && No scope of token)

    pattern->SetFrameworkIdL(KDefaultOviFrameworkID);

    pattern->AsElement().AddElementL(KSenIdpProviderIdLocalname).SetContentL(iIdentityProvider->ProviderID());

    //if (iWSOviServiceSession->ScopeToken() == EFalse) then pattern->SetScopeToken(EFalse) 

    CWSOviServiceSession* oviSession = NULL;

    TRAP(retVal, retVal = Framework().Manager().ServiceDescriptionsL(oviSDs, *pattern));

    if(!retVal)

        {

        TInt count = oviSDs.Count();

        for(TInt i = 0; i < oviSDs.Count(); i++)

            {

            //all sessions, to eliminate client, just for case we check type

            TDescriptionClassType dt = oviSDs[i]->DescriptionClassType();

            if (dt == MSenServiceDescription::EOviServiceSession)

                {

                oviSession = (CWSOviServiceSession*)oviSDs[i];

                //dont share to itself

                if (oviSession != iWSOviServiceSession)

                    {

                    TRAPD(err, retVal = oviSession->ShareTokenWithL(

                            iWSOviServiceSession));

                    if ((retVal == KErrNone) && (err == KErrNone))

                        {

                        sharingSucceed = ETrue;

                        break;

                        }    

                    }

                }

            }

        if ( !sharingSucceed )

            {

            // Did not find valid token      (<=> sharingSucceed     == EFalse)

            // 

            // Try to search valid toeken directly from CredentialManager

            // (This is needed especially in case when token is imported

            //  through Public API

            //  => There is not yet Session which holds imported token)

            if ( iWSOviServiceSession->TryToSearchValidCredentialL() == KErrNone )	//codescannerwarnings

                {

                iWSOviServiceSession->SetStatusL();

                iWSOviServiceSession->AddSecurityTokenToContextL();

                sharingSucceed = ETrue;

                }

            }

        }

    CleanupStack::PopAndDestroy(2, &oviSDs);

    if (sharingSucceed)

        {

        iWSOviServiceSession->SetTrustAnchorL(iIdentityProvider->ProviderID());

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::ValidateL(..) - sharing succed, we don't need more validation");

        return KErrNone;

        }

    if (aOnlySharing)

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarTrustClient::ValidateL(..) - only sharing was allowed so NO continuation");

        return KErrNone;

        }

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

//1 Init session

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

    if (!iAuthSession)// if AuthenticationClient has NOT been registered earlier

        {

        iAuthSession = CWSOviServiceSession::NewL(Framework());

        iAuthSession->InitializeFromL(*this);

        iAuthSession->SetEndPointL(iIdentityProvider->Endpoint());

        iAuthSession->SetContractL(KWSOviAuthenticationServiceContract);

        iAuthSession->AddConsumerL(*this);

        }

    CSenXmlReader* reader = Framework().Manager().XMLReader();

    CWSOviSessionContext* NAUTHSsnContext = iAuthSession->SessionContext();

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

//2.preparing context    

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

    TInt retryCounter(0);

    TBool retry(ETrue);

    TBool authenticationInfoPromptedFromUser(EFalse);

    TPckgBuf<TSenAuthentication> authInfo;

    HBufC8* response = NULL;

    MSenRemoteServiceConsumer* pConsumer = NULL;

    while ( retry ) // Authentication loop starts

        {

        retry = EFalse;

        //building body

        const TDesC8* version  = iHndCtx->GetDesC8L(HandlerContextKey::KVersion);

        TTime time;

        time.UniversalTime();

        TPtrC8 userName(KNullDesC8);

        TPtrC8 password(KNullDesC8);

        if ( authenticationInfoPromptedFromUser )

            {

            userName.Set(authInfo().iUsername);

            password.Set(authInfo().iPassword);

            }

        else

            {

            userName.Set(iIdentityProvider->UserName());

            password.Set(iIdentityProvider->Password());

            }

        HBufC8* created(NULL);

        const TInt* diffHandlerContext = iHndCtx->GetIntL(HandlerContextKey::KDiff);

        if( diffHandlerContext && *diffHandlerContext > 0 )

            {

            TTimeIntervalMinutes minutes(*diffHandlerContext);

            TTime diff = time - minutes;

            time -= TTimeIntervalMicroSeconds(diff.Int64());

            created = SenCryptoUtils::GetTimestampL(time);

            }

        else

            {

            created = SenCryptoUtils::GetTimestampL();

            }

        CleanupStack::PushL(created);

        CreateBodyL(*version,

                    userName,

                    password,

					*created);

        CleanupStack::PopAndDestroy(created);

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

        //_____________________________________SYNC Sending____________________________________________

        CSenHttpTransportProperties* transProp = CSenHttpTransportProperties::NewLC();

        // IAP dialog used to appear though IAP id is provided as a part of Service Description

        // Get the IAP setting and accordingly set the transport properties

    	TUint32 id = 0;

    	TInt getIapRetCode = IapId(id);

    	// Check whether IAP ID is pre-defined, and copy it only if such property value is found

    	//if ( getIapRetCode == KErrNone && id < 4294967295) // unsigned 4294967295 == -1 signed

    	if ( getIapRetCode == KErrNone && id < (TUint32)KErrNotFound) // unsigned 4294967295 == -1 signed

    	    {

    	    transProp->SetIapIdL(id); 

    	    }

    	// ETMI-6WAGDB end

    	//limit http timeout, 

    	//  if NAUTH hangs and can not send any response, then we block every async client method.

    	//  Possibel revalidation during sendL can take too long time therefore we create new limit

    	transProp->SetMaxTimeToLiveL(WSOviSession::KMaxHttpTimeOut);

		transProp->SetBoolPropertyL(OAuth::KNeedSecurity(), EFalse);

		transProp->SetEndpointResourceL(WSOviSession::KTokenEndpointSuffix());

//    	transProp->SetContentTypeL(KFormUrlEncoded());

//set consumer keys for proper DB		

		HBufC8* providerTP(NULL); 

		iIdentityProvider->TransportPropertiesL(providerTP);

		if (providerTP)

		    {

        	CleanupStack::PushL(providerTP);

        	CSenHttpTransportProperties* httpProviderTP = CSenHttpTransportProperties::NewLC(*providerTP, *reader);

        	if (httpProviderTP)

        		{

        		TPtrC8 content(KNullDesC8);

        		httpProviderTP->PropertyL(KNCIMConsumerKeyId , content);

        		if (content.Length())

        			{

        			transProp->SetPropertyL(KNCIMConsumerKeyId, content);

        			}

        		httpProviderTP->PropertyL(KNCIMConsumerSecret , content);

        		if (content.Length())

        			{

        			transProp->SetPropertyL(KNCIMConsumerSecret, content);

        			}

        		httpProviderTP->PropertyL(KNCIMConsumerServiceId , content);

        		if (content.Length())

        			{

        			transProp->SetPropertyL(KNCIMConsumerServiceId, content);

        			}

        		/*TUint32 id = 0;

                if (! httpProviderTP->SnapIdL(id))

                      {

                      transProp->SetSnapIdL(id);

                      }*/

                CleanupStack::PopAndDestroy(httpProviderTP);

        		}

            CleanupStack::PopAndDestroy(providerTP);

		    }

		// setting SNAP/IAP 

            if(!iAuthSession->IapId(id) )

                {

                transProp->SetIapIdL(id);

                transProp->SetSnapIdL(0);

                }

            else if(!iAuthSession->SnapId(id) )

                {

                transProp->SetSnapIdL(id);

                transProp->SetIapIdL(0);

                }

        HBufC8* transPropAsXml = transProp->AsUtf8LC();

//        HBufC8* bodyEncodedUrl = CWSOviUtils::FormEncodeCharsLC(*pBody);

//        _LIT8(KXmlContent, "XMLContent=");

//        HBufC8* allBody = HBufC8::NewL(KXmlContent().Length()+bodyEncodedUrl->Length());

//        allBody->Des().Append(KXmlContent());

//        allBody->Des().Append(*bodyEncodedUrl);

//        CleanupStack::PushL(allBody);

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

//3.submitting

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

        retVal = iAuthSession->SubmitL(*iBody, *transPropAsXml, *this, response);

        aSession.SetTransportL(ipTransport);//ownership moved

        ipTransport = NULL;

        if (!response)

            {

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::ValidateL - Response is empty - 1");

            CleanupStack::PopAndDestroy(transPropAsXml);

            CleanupStack::PopAndDestroy(transProp);

            return retVal;

            }

        const TInt* diffContext = iHndCtx->GetIntL(HandlerContextKey::KDiff);

        if (diffContext && *diffContext > 0)

            {

            delete response;

            response = NULL;

            TTime time;

            time.UniversalTime();

            TTimeIntervalMinutes minutes(*diffContext);

            TTime diff = time-minutes;

            time -= TTimeIntervalMicroSeconds(diff.Int64());

            HBufC8* created = SenCryptoUtils::GetTimestampL(time);

            CleanupStack::PushL(created);

            CreateBodyL(*version,

                        userName,

                        password,

                        *created);

            CleanupStack::PopAndDestroy(created);

            retVal = iAuthSession->SubmitL(*iBody, *transPropAsXml, *this, response);

            aSession.SetTransportL(ipTransport);//ownership moved

            ipTransport = NULL;

            }

        CleanupStack::PopAndDestroy(transPropAsXml);

        CleanupStack::PopAndDestroy(transProp);

        CleanupStack::PushL(response);

        if ( retVal )

            {

            CWSOviSessionContext* pSessionContext = iWSOviServiceSession->SessionContext();

            TAny* ptr = pSessionContext->GetAnyL(KRemoteConsumer());	//codescannerwarnings

            if ( ptr )

                {

                pConsumer = REINTERPRET_CAST(MSenRemoteServiceConsumer*, ptr);

                }

            else

                {

                pConsumer = iWSOviServiceSession->Consumer();

                }

            if ( pConsumer && !pConsumer->HasAuthenticationCallback() &&

                 retryCounter < 3 )

                {

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::ValidateL - Consumer does not have AuthenticationCallback");

                if ( pValue && *pValue != _L8("false") )

                // attribute has to exist, otherwise logic defaults to: DO NOT PROMPT

                // even when attribute does NOT exist, or when it does and has any other value but "false", default to: PROMPT

                    {

                    const TBool* renewingPtr = NAUTHSsnContext->GetIntL(WSOviContextKeys::KReAuthNeeded);

					if ( renewingPtr && *renewingPtr )

                     	{

                     	}

                    }

                else

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel," => prompt is not used.");

                    }

                }

            if ( pConsumer && pConsumer->HasAuthenticationCallback() &&

                             retryCounter < 3 )

            	{

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSOviOAuthClient::ValidateL - Consumer has AuthenticationCallback");

                const TDesC8* pValue = iIdentityProvider->AsElement().AttrValue( KSenAttrPromptUserInfo );

                if ( !pValue || *pValue != _L8("false") )

                    {

                    const TBool* renewingPtr = NAUTHSsnContext->GetIntL(WSOviContextKeys::KReAuthNeeded);

                    if ( renewingPtr && *renewingPtr )

                        {

                        retVal = KErrSenFailedAuthentication;

                        }

                    }

                else

                    {

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSOviOAuthClient::ValidateL - UserInfoPrompt = false");

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel," => AuthenticationCallback is not used.");

                    }

            	}

            }

        if ( retry )

            {

            CleanupStack::PopAndDestroy(response);

            }

        }  // Authentication loop ends

    HBufC8* ttlCreated = SenCryptoUtils::GetTimestampL();

    CleanupStack::PushL(ttlCreated);

    User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTokenCreationTime,*ttlCreated));

    CleanupStack::PopAndDestroy(ttlCreated);

    if (retVal != KErrNone)

        {

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("CWSOviOAuthClient::ValidateL - error when submit to NAUTH %d"), retVal));

        iWSOviServiceSession->SessionContext()->Remove(WSOviContextKeys::KTokenCreationTime);

        if (response)

            {

            aErrorMessage = response;

            }

        CleanupStack::Pop(response);

        return retVal;

        }

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::ValidateL - response from NAUTH is a valid SOAP");

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

//4 building response    

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

    CWSOviTokenCreationResponse* responseFragment = CWSOviTokenCreationResponse::NewLC();

    responseFragment->SetReader(*Framework().Manager().XMLReader());

    responseFragment->BuildFrom(*response);

    TPtrC8 ttl = responseFragment->TTL();

    TBool ttlInfinitive = EFalse;

//        _LIT8(KTempTTL,"1000");

    if (ttl.Length())

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,ttl);

        User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTTL,ttl));

        }

    else

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSOviOAuthClient::ValidateL - ttl is missing");

        const TInt KMaxTTLLength = 20;

        TBuf8<KMaxTTLLength> ttlMaxInt;

        ttlMaxInt.AppendNum(KMaxTInt);

        User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTTL,ttlMaxInt));

        ttlInfinitive = ETrue;

        }

    TPtrC8 tokenSecret = responseFragment->TokenSecret();

    if (tokenSecret.Length())

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,tokenSecret);

        User::LeaveIfError(iWSOviServiceSession->SessionContext()->Update(WSOviContextKeys::KTokenSecret,tokenSecret));

        }

    TPtrC8 token = responseFragment->Token();

    if (!token.Length())

        {

        iWSOviServiceSession->SessionContext()->Remove(WSOviContextKeys::KTokenCreationTime);

        retVal = KErrNotFound;

        }

    else

    	{    

        TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,token);

	    if (!iWSOviServiceSession->ExistConsumerL())

	        {