/*

* Copyright (c) 2007-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:  Login Request to the Network Server.

*

*/

#include "cossprotocolloginrequest.h"

#include <ximpprotocolconnectionhost.h>

#include "mossprotocolconnectionmanager.h"

#include "ossprotocolpluginlogger.h"

#include "cossprotocolconnection.h"

#include "cossprotocolconnectionmanager.h"

#include <stdlib.h>

#include "stringutils.h"

#include <string.h>

#include "msgliterals.h"

#include "msg_enums.h"

#include "xmppparameters.h"

#include "waittimer.h"

#include <e32math.h>

#include <ximperrors.hrh>

// ======== MEMBER FUNCTIONS ========

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

// COSSProtocolLoginRequest::COSSProtocolLoginRequest()

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

//

COSSProtocolLoginRequest::COSSProtocolLoginRequest (

    MOSSProtocolConnectionManager& aConnMan,

    TXIMPRequestId aRequestId ) :

		CActive ( CActive::EPriorityStandard  ),

		iRequestId ( aRequestId ),

		iConnMan ( aConnMan )

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::COSSProtocolLoginRequest Start" ) );

	CActiveScheduler::Add ( this );

	LOGGER ( TXT ( "COSSProtocolLoginRequest::COSSProtocolLoginRequest End" ) );

	}

// COSSProtocolLoginRequest::ConstructL()

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

//

void COSSProtocolLoginRequest::ConstructL()

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::COSSProtocolLoginRequest Start-End" ) );

	LOGGER ( TXT ( "COSSProtocolLoginRequest::COSSProtocolLoginRequest End" ) );

	}

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

// COSSProtocolLoginRequest::NewL()

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

//

COSSProtocolLoginRequest* COSSProtocolLoginRequest::NewL (

    MOSSProtocolConnectionManager& aConnMan,

    TXIMPRequestId aRequestId )

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::NewL Start" ) );

	COSSProtocolLoginRequest* self =

	    new ( ELeave ) COSSProtocolLoginRequest ( aConnMan, aRequestId );

	CleanupStack::PushL ( self );

	self->ConstructL();

	CleanupStack::Pop ( self );

	LOGGER ( TXT ( "COSSProtocolLoginRequest::NewL End" ) );

	return self;

	}

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

// COSSProtocolLoginRequest::NewLC()

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

//

COSSProtocolLoginRequest* COSSProtocolLoginRequest::NewLC (

    MOSSProtocolConnectionManager& aConnMan,

    TXIMPRequestId aRequestId )

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::NewLC Start" ) );

	COSSProtocolLoginRequest* self =

	    COSSProtocolLoginRequest::NewL ( aConnMan, aRequestId );

	CleanupStack::PushL ( self );

	LOGGER ( TXT ( "COSSProtocolLoginRequest::NewLC End" ) );

	return self;

	}

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

// COSSProtocolLoginRequest::~COSSProtocolLoginRequest()

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

//

COSSProtocolLoginRequest::~COSSProtocolLoginRequest()

	{

	LOGGER ( TXT ( "::~COSSProtocolLoginRequest Start-End" ) );

	Cancel();

	if( iUserName )

	    {

	    delete iUserName;

	    }

	LOGGER ( TXT ( "::~COSSProtocolLoginRequest End\n" ) );

	}

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

// COSSProtocolLoginRequest::DoCancel()

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

//

void COSSProtocolLoginRequest::DoCancel()

	{

	}

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

// COSSProtocolLoginRequest::RunL()

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

//

void COSSProtocolLoginRequest::RunL()

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL Start" ) );

	message_hdr_resp* msg_struct = NULL;

	User::LeaveIfError ( iStatus.Int() );

    char* pResponse = NULL;  

	pResponse = iConnMan.DataHandler().ResponseL ( iSendId );

	msg_struct = ( message_hdr_resp* )pResponse ;

	if( !( msg_struct->response ) )

	{

		switch( msg_struct->error_type )

		{

		case ELOGIN_NETWORK_ERROR:

		    LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL ELOGIN_NETWORK_ERROR" ) );

		case ELOGIN_NONE_SPECIFIED:

		    //XImpfw is not giving any error code for canceling accespoint so we are using KErrDisconnected

		    //once error code is provided by ximpfw we can remove 

		    LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL ELOGIN_NONE_SPECIFIED" ) );

		    iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, KErrDisconnected );

		    break;

		case ELOGIN_AUTHENTICATION: //The username or password was invalid. 

		    LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL ELOGIN_AUTHENTICATION" ) );

			   iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, KXIMPErrServiceAuthenticationFailed );

		       break;

		default:  //for all other error codes like ssl related are mapped to general error ELOGIN_AUTHORIZATION

                LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL defualt" ) );

			   iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, KXIMPErrServiceGeneralError );

		       break;       

		}	

	}

	else

	    {

	    iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, KErrNone );

	    MPresenceBuddyInfo2* buddyPresInfo = MPresenceBuddyInfo2::NewLC();

	    MPresenceCacheWriter2* presenceCacheWriter = MPresenceCacheWriter2::CreateWriterL();

	    HBufC* userName = HBufC::NewLC( iUserName->Length() + iConnMan.ServiceName().Length() + KColon().Length() );     

	    TPtr namePtr( userName->Des() );

	    namePtr.Zero();

	    namePtr.Append(iConnMan.ServiceName()); // prepend service name

	    namePtr.Append(KColon);

	    namePtr.Append(iUserName->Des() );

	    buddyPresInfo->SetIdentityL(namePtr);

	    LOGGER ( TXT ( "COSSProtocolLoginRequest::owndata:%S " ), userName ); 

	    CleanupStack::PopAndDestroy();//userName      

	    _LIT(KAvailable,"available");//since not getting the own status from downlayer.here 

	    _LIT(KStatusTest,"Online");//is hardcoded once logged in is successfully

	    HBufC16 *message = KAvailable().AllocLC();      

	    buddyPresInfo->SetAvailabilityL( MPresenceBuddyInfo2::EAvailable,*message);                 

	    HBufC16 *statusmessage = KStatusTest().AllocLC();

	    buddyPresInfo->SetStatusMessageL(*statusmessage);

	    TInt cacheerror = presenceCacheWriter->WritePresenceL(buddyPresInfo);

	    User::LeaveIfError ( cacheerror);

	    CleanupStack::PopAndDestroy ( 3 ); //buddyPresInfo, message ,statusmessage

	    delete presenceCacheWriter ;

	    }

	free( pResponse );

	delete this;

	LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL End" ) );

	}

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

// COSSProtocolLoginRequest::RunError()

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

//

TInt COSSProtocolLoginRequest::RunError ( TInt  aError )

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::RunError Start" ) );

	iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, aError );

	delete this;

	LOGGER ( TXT ( "COSSProtocolLoginRequest::RunError End" ) );

	return KErrNone;

	}

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

// COSSProtocolLoginRequest::IssueLoginRequestL()

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

//

void COSSProtocolLoginRequest::IssueLoginRequestL()

	{

	LOGGER ( TXT ( "COSSProtocolLoginRequest::IssueLoginRequestL Start" ) );

	char *smsg = NULL;

	char *tmpmsg = NULL;

	message_hdr_req msgHdr = {0,};

	int userLen = 0;

	int totalLen = 0;

	int err = 0;

	smsg = ( char* ) User::AllocLC(MAX_MSG_SIZE);

	tmpmsg = ( char* ) User::AllocLC(MAX_MSG_SIZE);

	HBufC* buffer = HBufC::NewLC ( MAX_MSG_SIZE );

	TPtr bufferPtr ( buffer->Des() );

	bufferPtr.Zero();

	memset ( smsg, '\0', MAX_MSG_SIZE );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	msgHdr.message_type = ELogin_Request;

	iConnMan.DataHandler().IncreaseOpId();

	TInt Opid = iConnMan.DataHandler().GetOpId();

	msgHdr.request_id = Opid;

	memcpy ( smsg, &msgHdr, sizeof ( message_hdr_req ) );

	totalLen += sizeof ( message_hdr_req );

	bufferPtr.Zero();

	if ( iConnMan.UserName().Length() == 0 && iConnMan.Password().Length() == 0 ) //if username and pwd are not passed from client.read default settings

		{

		bufferPtr.Append ( iConnMan.XmppParams().UserName() );

		iUserName = bufferPtr.AllocL();

		LOGGER ( TXT ( "COSSProtocolLoginRequest::UserName:%S " ), & ( iConnMan.XmppParams().UserName() ) );

		memset ( tmpmsg, '\0', MAX_MSG_SIZE );

		err = tbufC16tochar ( bufferPtr, tmpmsg );

		if( -1 == err)

		{

		iConnMan.HandleToHost().HandleRequestCompleted ( iRequestId, err );

		}

		userLen = strlen ( tmpmsg ) + 1; //for '\0'

		memcpy ( smsg + totalLen, tmpmsg, userLen );

		totalLen += userLen;

		bufferPtr.Zero();

		bufferPtr.Append ( iConnMan.XmppParams().Passwd() );

		memset ( tmpmsg, '\0', MAX_MSG_SIZE );

		err = tbufC16tochar ( bufferPtr, tmpmsg );

		userLen = strlen ( tmpmsg ) + 1; //for '\0'

		memcpy ( smsg + totalLen, tmpmsg, userLen );

		totalLen += userLen;

		}

	else

		{

		iUserName =  iConnMan.UserName().AllocL();

		bufferPtr.Append ( iConnMan.UserName() );

		LOGGER ( TXT ( "COSSProtocolLoginRequest::UserName:%S " ), & ( iConnMan.UserName() ) );

		memset ( tmpmsg, '\0', MAX_MSG_SIZE );

		err = tbufC16tochar ( bufferPtr, tmpmsg );

		userLen = strlen ( tmpmsg ) + 1; //for '\0'

		memcpy ( smsg + totalLen, tmpmsg, userLen );

		totalLen += userLen;

		bufferPtr.Zero();

		bufferPtr.Append ( iConnMan.Password() );

		memset ( tmpmsg, '\0', MAX_MSG_SIZE );

		err = tbufC16tochar ( bufferPtr, tmpmsg );

		userLen = strlen ( tmpmsg ) + 1; //for '\0'

		memcpy ( smsg + totalLen, tmpmsg, userLen );

		totalLen += userLen;

		}

	bufferPtr.Zero();

	bufferPtr.Append ( iConnMan.XmppParams().ServerAddress() );

	LOGGER ( TXT ( "COSSProtocolLoginRequest::RunL:ServerAddress:%S " ), & ( iConnMan.XmppParams().ServerAddress() ) );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//resource

	bufferPtr.Zero();

    bufferPtr.Append ( 	GenResourceId(iConnMan.XmppParams().Resource()) );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//ssl

	bufferPtr.Zero();

	bufferPtr.AppendNum ( iConnMan.XmppParams().Ssl() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//ServerPort

	bufferPtr.Zero();

	bufferPtr.AppendNum ( iConnMan.XmppParams().ServerPort() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//IapId

	bufferPtr.Zero();

	bufferPtr.AppendNum ( iConnMan.XmppParams().IapId() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//connmgr_bus

	bufferPtr.Zero();

	bufferPtr.Append ( iConnMan.XmppParams().ConnMgrBus() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//connmgr_path

	bufferPtr.Zero();

	bufferPtr.Append ( iConnMan.XmppParams().ConnMgrPath() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//protocol

	bufferPtr.Zero();

	bufferPtr.Append ( iConnMan.XmppParams().Protocol() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

#ifdef __WINSCW__

	//ProxyServer

	bufferPtr.Zero();

	bufferPtr.Append ( iConnMan.XmppParams().ProxyServer() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

	//ProxyPort

	bufferPtr.Zero();

	bufferPtr.AppendNum ( iConnMan.XmppParams().ProxyPort() );

	memset ( tmpmsg, '\0', MAX_MSG_SIZE );

	err = tbufC16tochar ( bufferPtr, tmpmsg );

	userLen = strlen ( tmpmsg ) + 1; //for '\0'

	memcpy ( smsg + totalLen, tmpmsg, userLen );

	totalLen += userLen;

#endif

	iSendId = iConnMan.DataHandler().SendDataL ( iStatus, smsg, totalLen );

	// signal the scheduler

	SetActive();

	CleanupStack::PopAndDestroy (buffer);

	CleanupStack::PopAndDestroy (tmpmsg);

	CleanupStack::PopAndDestroy (smsg);

	LOGGER ( TXT ( "COSSProtocolConnection::OpenSessionL() End" ) );

	}

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

// COSSProtocolLoginRequest::GenResourceId()

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

//

TPtrC COSSProtocolLoginRequest::GenResourceId( const TDesC& aResourceId )

    {

    	TBuf<KImpsMaxResourceIdLen> tempRId = aResourceId;

        //initialise client id

	    iResourceId.SetLength(0);

	    //generate Resourse here

	    iResourceId.Append(tempRId);

	    TTime time;

		time.HomeTime();

		TInt64 seed = time.Int64();

	    TInt i = Math::Rand( seed );

		iResourceId.AppendFormat( _L("%d"), i);

		return iResourceId;

     }  

// End of file