// Copyright (c) 2000-2009 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 <e32std.h>

#include "Dummywapstd.h"

#include "DummyWapClient.h"

#include "dummywapstack.h"

/** Bound Connectionless Push

*/

EXPORT_C CWapBoundCLPushService* CWapBoundCLPushService::NewL()

	{

	CWapBoundCLPushService* me = new (ELeave) CWapBoundCLPushService();

	return me;

	}

EXPORT_C CWapBoundCLPushService::~CWapBoundCLPushService()

	{

	if(iSessHandle&&iClConnHandle)

		{

		iSessHandle->Close();

		}

	STATIC_CAST(CDummyWapStack* , Dll::Tls())->CloseSession(iSessHandle);

	delete iClConnHandle;

 	}

TInt CWapBoundCLPushService::Connect(Wap::TBearer /*aBearer*/, Wap::TPort aPort, TBool /*aSecure*/)

	{

	TInt err = KErrNone;

	if (!iSessHandle)

		{

		TRAP(err, iSessHandle=  STATIC_CAST(CDummyWapStack* , Dll::Tls())->NewSessionL());

		}

	if (!iSessHandle)

		return KErrServerTerminated;

	TRAP(err,iClConnHandle =iSessHandle->NewWSPCLConnL(aPort));

	if(err)

		return err;

	return KErrNone; 

	}

/**

 * Return the "dummy" wap session associated with this client session

 */

CDummyWapSession* CWapBoundCLPushService::DummyWapSession()

	{

	return iSessHandle;

	}

TInt CWapBoundCLPushService::AwaitPush(TDes8& aPushHeaders, TDes8& aPushBody, TPckgBuf<TUint8>& aPushIdPckg, TRequestStatus& aReqStatus)

	{

	TPushID pushID;

	pushID() = aPushIdPckg();

	TRAPD(err,iClConnHandle->UnitWaitPushL(aPushBody,aPushHeaders,pushID, aReqStatus));

	return err;

	}

void CWapBoundCLPushService::CancelAwaitPush()

	{

	iClConnHandle->CancelUnitWaitPush();

	}

TInt CWapBoundCLPushService::GetServerAddressL(HBufC8*& aRemoteHost) 

	{

	__ASSERT_ALWAYS(aRemoteHost==NULL, User::Invariant());

	if((iClConnHandle->GetServerAddr()).Compare(_L8("")) == 0)

		{

		_LIT8(KRemoteAddress, "www.zappow.com");

		aRemoteHost = KRemoteAddress().AllocL();

		}

	else

		{

		aRemoteHost = iClConnHandle->GetServerAddr().AllocL();	

		}	

	return KErrNone;

	}

EXPORT_C CWapBoundCLPushService::CWapBoundCLPushService() 

	{

	}

/**

 * Constructor

 */

EXPORT_C RWAPServ::RWAPServ()

	{

	}

/**

 * Creates a session with the dummy wap stack

 * Get the pointer to the stack from TLS

 * @param TInt aDefaultMessageSlots Ignored in the dummy stack

 */

EXPORT_C TInt RWAPServ::Connect(TInt /*aDefaultMessageSlots*/)

	{

	TRAPD(err, iSessHandle=  STATIC_CAST(CDummyWapStack* , Dll::Tls())->NewSessionL());

	if (err)

		return err;

	if (!iSessHandle)

		return KErrServerTerminated;

	return KErrNone; 

	}

/**

 * Closes a previously created WAP session

 */

EXPORT_C void RWAPServ::Close()

	{

	STATIC_CAST(CDummyWapStack* , Dll::Tls())->CloseSession(iSessHandle);

	}

/**

 * Return the "dummy" wap session associated with this client session

 */

CDummyWapSession* RWAPServ::DummyWapSession()

	{

	return iSessHandle;

	}

/**

 * Closes an open connection

 */

EXPORT_C TInt RWAPConn::Close()

	{

	if (iDummyConn)

		iDummyConn->Close();

	return KErrNone;

	}

/**

 * Return the RWTLS object on which the WTLS functions are available

 */

EXPORT_C RWTLS RWAPConn::Wtls()

	{

	RWTLS wtls; 

	wtls.iDummyWTLS = iDummyConn->WtlsL();

	return wtls;

	}

/**

 * Set suggested security parameters before (re)negotiating with the server. 

 * These return ETrue on success otherwise EFalse.

 */

EXPORT_C TInt RWTLS::SetKeyExchangeSuite(TKeyExchangeSuite aSuite,TIdType aIdType,const TDesC8& aKeyId)

	{

	iDummyWTLS->SetKeyExchangeSuite(aSuite,aIdType,aKeyId);

	return ETrue;

	}

/**

 * Set suggested security parameters before (re)negotiating with the server. 

 * These return ETrue on success otherwise EFalse.

 */

EXPORT_C TInt RWTLS::SetCipherSuites(const CipherSuiteArray& aCipherSuites)

	{

	iDummyWTLS->SetCipherSuites(aCipherSuites);

	return ETrue;

	}

/**

 * Set suggested security parameters before (re)negotiating with the server. 

 * These return ETrue on success otherwise EFalse.

 */

EXPORT_C TInt RWTLS::SetSequenceNumberMode(TSequenceNumberMode aMode)

	{

	iDummyWTLS->SetSequenceNumberMode(aMode);

	return ETrue;

	}

/**

 * Set suggested security parameters before (re)negotiating with the server. 

 * These return ETrue on success otherwise EFalse.

 */

EXPORT_C TInt RWTLS::SetKeyRefreshRate(TUint8 aRate)

	{

	iDummyWTLS->SetKeyRefreshRate(aRate);

	return ETrue;

	}

/**

 * Set suggested security parameters before (re)negotiating with the server. 

 * These return ETrue on success otherwise EFalse.

 */

EXPORT_C TInt RWTLS::SetSharedSecret(const TDesC8& aSharedSecret)

	{

	iDummyWTLS->SetSharedSecret(aSharedSecret);

	return ETrue;

	}

/**

 * Set suggested security parameters before (re)negotiating with the server. 

 * These return ETrue on success otherwise EFalse.

 */

EXPORT_C TInt RWTLS::SetRecordLengthUsage(TBool aUsage)

	{

	iDummyWTLS->SetRecordLengthUsage(aUsage);

	return ETrue;

	}

/** 

 * Make the handshake with the server to agree on the security parameters.

 * The connection must be Opened (in secure mode) before this. 

 * Optionally the parameter setters may precede this call. 

 * If called more than once a renegotiation is done with possibly 

 * new parameters.

 * aTwoPhaseHandshake may be set to ETrue to return half way through to check

 * the server certificate. CancelConnect() or ConnectPhaseTwo() should succeed

 * this call if two phase connect is used.

 */

EXPORT_C void RWTLS::Connect(TRequestStatus& aStatus, TBool aTwoPhaseHandshake)

	{

	// assert that the connection has been opened

	iDummyWTLS->Connect(aStatus,aTwoPhaseHandshake);

	}

/**

 * Cancels the secure handshake. May be called after the first phase.

 */

EXPORT_C void RWTLS::CancelConnect()

	{

	iDummyWTLS->CancelConnect();

	}

/**

 * Continue the secure handshake after the first phase has completed.

 */

EXPORT_C TInt RWTLS::ConnectPhaseTwo(TRequestStatus& aStatus)

	{

	iDummyWTLS->ConnectPhaseTwo(aStatus);

	return KErrNone;

	}

/** 

 * Cancel second phase connection

 */

EXPORT_C void RWTLS::CancelConnectPhaseTwo()

	{

	iDummyWTLS->CancelConnectPhaseTwo();

	}

/**

 * Use the getters to see which values where agreed upon.

 */

EXPORT_C TInt RWTLS::GetCipherSuite(TCipherSuite& aCipherSuite) const

	{

	iDummyWTLS->GetCipherSuite(aCipherSuite);

	return KErrNone;

	}

/**

 * Use the getters to see which values where agreed upon.

 */

EXPORT_C TInt RWTLS::GetSequenceNumberMode(TSequenceNumberMode& aMode) const

	{

	iDummyWTLS->GetSequenceNumberMode(aMode);

	return KErrNone;

	}

/**

 * Use the getters to see which values where agreed upon.

 */

EXPORT_C TInt RWTLS::GetKeyRefreshRate(TUint8& aRate) const

	{

	iDummyWTLS->GetKeyRefreshRate(aRate);

	return KErrNone;

	}

/**

 * Use the getters to see which values where agreed upon.

 */

EXPORT_C RCertificate RWTLS::ServerCert()

	{

	RCertificate certificate = RCertificate();

	return certificate;

	}

/** 

 * Load a new certificate from persistent storage. Identified by subject.

 * NB: Not currently supported - returns KErrNotSupported

 */

EXPORT_C TInt RCertificate::Load(const TDesC8& /*aSubject*/)

	{

	return KErrNotSupported;

	}

/**

 * Load a new certificate from persistent storage. Identified by id.

 * NB: Not currently supported - returns KErrNotSupported

 */

EXPORT_C TInt RCertificate::LoadById(const TCertId& /*aId*/)

	{

	return KErrNotSupported;

	}

/** Delete certificate identified by subject from the certificate store */

EXPORT_C TInt RCertificate::Delete(const TDesC8& /*aSubject*/)

	{

	return KErrNotSupported;

	}

/** Save this cert to persistent storage */

EXPORT_C TInt RCertificate::Save(const TCertificate& /*aCertificate*/, TDes8& /*aSubject*/)

	{

	return KErrNotSupported;

	}

/**

 * Find subject of first cert in persistent storage. Use aId to find next.

 * NB: Not currently supported - returns KErrNotSupported

 */

EXPORT_C TInt RCertificate::FindFirst(TDes8& /*aSubject*/, TCertId& /*aId*/) const

	{

	return KErrNotSupported;

	}

/**

 * Find subject of next cert

 * NB: Not currently supported - returns KErrNotSupported

 */

EXPORT_C TInt RCertificate::FindNext(TDes8& /*aSubject*/, TCertId& /*aId*/) const

	{

	return KErrNotSupported;

	}

/**

 * Get the details of the server certificate of this secure connection OR the 

 * certificate explicitly loaded from persistent storage.

 */

EXPORT_C TInt RCertificate::Info(TInfo& /*aInfo*/) const

	{

	return KErrNotSupported;

	}

/**

 *  Creates a Push Connectionless type connection

 *  @param aServ Reference to RWAPServ object that Created the WAP Sesssion

 */

EXPORT_C TInt RWSPCLConn::Open(RWAPServ& aServer, TPort aLocalPort)

	{	

	TRAPD(err,iClConnHandle =aServer.DummyWapSession()->NewWSPCLConnL(aLocalPort));

	if(err)

		return err;

	iDummyConn=iClConnHandle;

	return KErrNone; 

	}

/**

 *  Creates a Push Connectionless type connection

 *  @param aServ Reference to RWAPServ object that Created the WAP Sesssion

 *  @param aRemotePort Port Number the Server is going to send on

 *  @param aLocalPort Local Port, if set to 0 it's allocated automatically

 *  @param aBearer enum, can be EIP, ESMS, EMSM7, EALL

 *  @param aSecureConn ETrue WTLS will be used, EFalse, it wont

 */

EXPORT_C TInt RWSPCLConn::Open(RWAPServ& aServer,

						const TDesC8& /*aRemoteHost*/,

						TPort /*aRemotePort*/,

						TPort aLocalPort,

						Wap::TBearer /*aBearer*/,

						TBool /*aSecureConn*/)

	{	

	TRAPD(err,iClConnHandle =aServer.DummyWapSession()->NewWSPCLConnL(aLocalPort));

	if(err)

		return err;

	iDummyConn=iClConnHandle;

	return KErrNone; 

	}

/**

 *  Wait for push from the server. Assumes a bound RWSPCLConn object.

 */

EXPORT_C TInt RWSPCLConn::AwaitPush(TDes8& aPushHeaders, TDes8& aPushBody, TUint& aPushId, TRequestStatus& aReqStatus)

	{

	TRAPD(err,iClConnHandle->UnitWaitPushL(aPushBody,aPushHeaders,(TPushID&)aPushId, aReqStatus));

	return err;

	}

/**

 *  Wait for push from the server. Assumes a bound RWSPCLConn object.

 */

EXPORT_C void RWSPCLConn::UnitWaitPush(TDes8& aBody,TDes8& aHeaders,TPushID& aID,TRequestStatus& aStatus)

	{

	TRAPD(err,iClConnHandle->UnitWaitPushL(aBody,aHeaders,aID, aStatus));

	if(err)

		User::Panic(_L("RWSPCLConn::UnitWaitPush() --NewWSPCLConnL --"),err);

	}

/**

 *  Cancel the asynchronous UnitWaitPush operation.

 */

EXPORT_C void RWSPCLConn::CancelAwaitPush()

	{

	iClConnHandle->CancelUnitWaitPush();

	}

	/**

 *  Cancel the asynchronous UnitWaitPush operation.

 */

EXPORT_C void RWSPCLConn::CancelUnitWaitPush()

	{

	iClConnHandle->CancelUnitWaitPush();

	}

/**

 *  The synchronous version

 */

EXPORT_C TInt RWSPCLConn::UnitWaitPush(TDes8& aBody,TDes8& aHeaders,TPushID& aID)

	{

	TRAPD(err,iClConnHandle->UnitWaitPushL(aBody, aHeaders, aID));

	if(err)

		return err;

	return KErrNone;

	}

//

// -- connection-orientated transaction --

//

/**

 * Constructor for connection-orientated transaction

 */

EXPORT_C RWSPCOTrans::RWSPCOTrans() : iCoTransHandle(0)

	{

	}

/**

 * Destructor for connection-orientated transaction

 */

EXPORT_C RWSPCOTrans::~RWSPCOTrans()

	{

	}

/**

 * Acknowledges a transaction. 

 * This must be used to accept a confirmed push from the server. 

 *

 */

EXPORT_C TInt RWSPCOTrans::Acknowledge(const TDesC8& aAckHeaders)

	{

	// if the handle to the server's transaction is NULL then

	// return RWSPCOConn::EInvalidTransaction;

	if (!iCoTransHandle)

		return RWSPCOConn::EInvalidTransaction;

	return iCoTransHandle->Acknowledge(aAckHeaders); 

	}

/**

 * Get the data for this transaction

 * If the allocated buffer is too small the function will return EMoreData and

 * the remaining data can be read with successive calls

 * 

 * @param aBuffer The user allocated buffer to be filled with the requested data (output)

 * @param aDataType The type of data to be returned (input)

 */

EXPORT_C TInt RWSPCOTrans::GetData(TDes8& aBuffer, TDataType aDataType, TInt* aSizeLeft) const

	{

	// if the handle to the server's transaction is NULL then

	// return RWSPCOConn::EInvalidTransaction;

	if (!iCoTransHandle)

		return RWSPCOConn::EInvalidTransaction;

	return iCoTransHandle->GetData(aBuffer,aDataType,aSizeLeft);

	};

/**

 * Retrieve the state the transaction is in

 * Can be one of EInit, ERequesting, EReplying, EDone, EAborted, EPushing

 */

EXPORT_C TInt RWSPCOTrans::GetState(TState& aState) const

	{

	// if the handle to the server's transaction is NULL then

	// return RWSPCOConn::EInvalidTransaction;

	if (!iCoTransHandle)

		return RWSPCOConn::EInvalidTransaction;

	return iCoTransHandle->GetState(aState);

	}