diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/wappushfw/tpush/DummyStack/Dummywapclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/wappushfw/tpush/DummyStack/Dummywapclient.cpp Wed Nov 03 22:41:46 2010 +0530 @@ -0,0 +1,722 @@ +// 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 +#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& 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); + } + +/** + * Aborts a method invoke or push transaction + * State of the transaction can be EInit or ERequesting + */ +EXPORT_C TInt RWSPCOTrans::Abort(TAbortReason aReason) + { + // if the handle to the server's transaction is NULL then + // return RWSPCOConn::EInvalidTransaction; + if (!iCoTransHandle) + return RWSPCOConn::EInvalidTransaction; + // + // assert that the state of the transaction is EInit or ERequesting + return iCoTransHandle->Abort(aReason); + } + +/** + * Releases a transaction + * Must be called after use. Causes the resources reserved by the transaction + * to be released. Function succeeds only if the state of the transaction is + * EInit, EAborted or EDone. If the transaction is in any other state the + * transaction should be aborted first. + */ +EXPORT_C TInt RWSPCOTrans::Release() + { + // if the handle to the server's transaction is NULL then + // return RWSPCOConn::EInvalidTransaction; + if (!iCoTransHandle) + return RWSPCOConn::EInvalidTransaction; + // + // assert that the transaction state is EInit, EAborted or EDone + + return iCoTransHandle->Release(); + } + +EXPORT_C TInt RWSPCOTrans::Id(TTransID& aId) + { + // if the handle to the server's transaction is NULL then + // return RWSPCOConn::EInvalidTransaction; + if (!iCoTransHandle) + return RWSPCOConn::EInvalidTransaction; + // else return handle + return iCoTransHandle->Id(aId); + } + + + + +// +// -- connection-orientated connection -- +// + + +/** + * Fully defined open + * + */ +EXPORT_C TInt RWSPCOConn::Open(RWAPServ& aServer, const TDesC8& /*aRemoteHost*/, TPort /*aRemotePort*/, TPort /*aLocalPort*/, + TBearer /*aBearer*/, TBool /*aSecureConn*/) + { + TRAPD(err,iCoConnHandle=aServer.DummyWapSession()->NewWSPCOConnL()); + if(err) + return err; + iDummyConn=iCoConnHandle; + return KErrNone; + } + +/** + * Close CO connection + */ +EXPORT_C TInt RWSPCOConn::Close() + { + iDummyConn->Close(); + return KErrNone; + } + +/** + * Establishes a WSP session with the server + * Session creation status is retrieved by calls to GetEvent + * @param aClientHeaders Session headers communicated to the server during + * session establishment + * @param aCap Proposed capabilities + */ +EXPORT_C TInt RWSPCOConn::Connect(const TDesC8& aClientHeaders, class CCapCodec* aCap) + { + return iCoConnHandle->Connect(aClientHeaders,aCap); + } + +/** + * Disconnects the session and aborts all pending transactions + */ +EXPORT_C TInt RWSPCOConn::Disconnect() + { + return iCoConnHandle->Disconnect(); + } + +/** + * Suspends a session. No incoming or outgoing activity is allowed within the + * session. All pending transactions of the session are aborted, events + * corresponding to aborted transactions are NOT delivered via WSP_GetEvent() + */ +EXPORT_C TInt RWSPCOConn::Suspend() + { + return KErrNotSupported; + } + +/** + * Resumes a suspended session + */ +EXPORT_C TInt RWSPCOConn::Resume(RWSPCOConn& /*aBlankConn*/, const TDesC8& /*aHeaders*/) + { + return KErrNotSupported; + } + +/** + * Returns the state of the session + */ +EXPORT_C TInt RWSPCOConn::GetSessionState(TSessionState& aState) const + { + return iCoConnHandle->GetSessionState(aState); + } + +/** + * Retrieves data associated with a session + * If the allocated buffer is too small,the function will return EMoreData and + * the remaining data can be read with successive calls. + * @param aData The user allocated buffer to be filled with the requested data + * @param aType The type of the requested data. + */ +EXPORT_C TInt RWSPCOConn::GetSessionData(TDes8& /*aData*/, TSessionDataType /*aType*/) const + { + return KErrNone; + } + +/** + * Create a transaction + * Creates and invokes a methodInvoke in the context of the session + * @param aMethod HTTP method. May be either of EGet, EOptions, EHead, EDelete, + * ETrace, EPost or EPut + * @param aURI Uniform Resource Identifier. Must not be empty + * @param aHeaders Request headers. Content type must be the first header field + * if aBody is given. Can be empty + * @param aBody Data associated with the invoke. Semantically equivalent to + * HTTP entity body. If aMethod doesn't require a body. then + * this must be empty + * @param aTrans The created transaction + */ +EXPORT_C TInt RWSPCOConn::CreateTransaction(TMethod /*aMethod*/, const TDesC& /*aURI*/, const TDesC8& /*aHeaders*/, const TDesC8& /*aBody*/, RWSPCOTrans& /*aTrans*/) + { + // assert that aURI isn't empty + // assert if aMethod doesn't require a body - no body is provided + + return KErrNotSupported; + } + +/** + * Gets next session or transaction event on this session + * @param aEvent The event. Use the function operator to get the value of the event + * @param aTrans The transaction, if aEvent is a transaction event + * @param aStatus Indicates completion of this asynchronous request + */ +EXPORT_C void RWSPCOConn::GetEvent(TEvent& aEvent, RWSPCOTrans& aTrans, TRequestStatus& aStatus) const + { + iCoConnHandle->GetEvent(aEvent,aTrans,aStatus); + } + +/** + * Cancel the asynchronous GetEvent operation + */ +EXPORT_C void RWSPCOConn::CancelGetEvent() + { + iCoConnHandle->CancelGetEvent(); + } + +/** + * Gets next session or transaction event on this session (synchronous version) + * This isn't implemented in the dummy stack + * @param aEvent The event. Use the function operator to get the value of the event + * @param aTrans The transaction, if aEvent is a transaction event + */ +EXPORT_C TInt RWSPCOConn::GetEvent(TEvent& /*aEvent*/, RWSPCOTrans& /*aTrans*/) const + { + return KErrNotSupported; + } + +/** + * Return the number of events pending for the session + * @param aNrOfEvents The number of events pending + */ +EXPORT_C TInt RWSPCOConn::GetNrOfEvents(TUint& aNrOfEvents) const + { + return iCoConnHandle->GetNrOfEvents(aNrOfEvents); + } +