diff -r 000000000000 -r 094583676ce7 IMPSengine/ImpsIpCirWatcher/ImpsTcpIpCirWatcher/inc/TcpCirWatcher.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/IMPSengine/ImpsIpCirWatcher/ImpsTcpIpCirWatcher/inc/TcpCirWatcher.h Thu Dec 17 08:41:52 2009 +0200 @@ -0,0 +1,295 @@ +/* +* Copyright (c) 2003 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: Tcp CirWatcher +* +* +*/ + + +#ifndef __TCPCIRWATCHER_H__ +#define __TCPCIRWATCHER_H__ + +// INCLUDES +#include +#include +#include +#include "ImpsIpCirWatcherAPI.h" +#include "TcpCirWatcherTimerCallback.h" + +//FORWARD DECLARATIONS +class CTcpCirWatcherTimer; +class TTcpWatcherParameters; +class MImpsConnectionManager; +class MImpsBearerObserverCallback; + +// CLASS DECLARATION +class CTcpCirWatcher : public CImpsTcpCirWatcher, + public MMsgBearerObsCallback, + public MTcpCirWatcherTimerCallback + + { + public: // Constructors and destructor + + /** + * Two-phased constructor. + * @param TTcpWatcherParameters Parameter wrapper object + * @return CTcpCirWatcher + */ + static CTcpCirWatcher* NewL( TTcpWatcherParameters* aParameters ); + + /** + * Destructor. + */ + virtual ~CTcpCirWatcher(); + + public: //New functions + + /** + * Start a TCP Watcher. This is an asynchronous request + * that completes as soon as the watcher receives a response + * to the HELO request. In such case the watcher completes the + * client's request and starts to ping the server in intervals + * defined in the constructor call (default) or by the dedicated + * method SetPingInterval(). The new value becomes effective + * as soon as the ping request following the change of the value + * has been issued. + * + * It should be noted that the call to this method means anything + * only when the watcher is at idle state. In other words, the + * watcher must be stopped before an attempt to start it again may + * take place. If, for instance, the client wishes to change the + * server to which the watcher is connected, it must first call + * StopTCPWatcher() method and only then initiate a new connection + * to a different server. + * + * NOTE: The contents of TDesC8& parameters are NOT copied. Thus the + * client must make sure that the data the descriptors point to + * exist at least as long as it takes the watcher to complete the + * client's request. + * + * @param aStatus Request status of the client + * @param aServerPort Port number of the server + * @param aServerAddress Address of the server + * @param aCSPSessionID ID of the client's CSP Session + */ + virtual void StartTCPWatcherL( TRequestStatus& aStatus, + const TUint aServerport, + const TDesC& aServerAddress, + const TDesC8& aCSPSessionID ); + + /** + * Stops a TCP Watcher. This is a synchronous request + * which cancels all socket reads and writes and, + * eventually, closes the outbound socket, too. + */ + virtual void StopTCPWatcher(); + + /** + * Returns the current state of the watcher. This method comes + * in handy for example in situations where a GPRS resume has + * just been occurred. In such case the client is able to ask + * whether or not the watcher has recovered from the event. + */ + virtual TUint WatcherStatus() const; + + /** + * Set the value of the PING timer. + */ + virtual void SetPingInterval( const TInt aPingInterval ); + +#ifdef _DEBUG + + /** + * A global logging function + */ + static void WriteToLog( TRefByValue aFmt, ... ); + +#endif + + private: + + /** + * C++ default constructor is public, because + * FinishConstuctL() takes care of memory reservations. + */ + CTcpCirWatcher( const TInt aPingInterval, + MImpsCirReceiver& aCirReceiver, + MMsgConnManager& aConnManager ); + + /** + * Connect a TCP Socket to the server + */ + void ConnectTCPSocketL(); + + /** + * Send the initial "Hello World!" message + */ + void SendHELOMessageL(); + + /** + * Receive data from the socket + */ + void ReceiveFromSocket(); + + /** + * Wait for response to the HELO request + * (=receive data from the socket) + */ + void WaitForHELOResponse(); + + /** + * Send a ping request + */ + void SendPingL(); + + /** + * Handle a timer event + */ + void HandleTimerEventL( const TUint aExpiredRequest ); + + /** + * Handle a succesful request completion + */ + void HandleRequestCompletionL(); + + /** + * Handle bearer suspension + */ + void HandleBearerSuspension(); + + /** + * Handle bearer activation + */ + void HandleBearerActivationL(); + + /** + * Handle an erroneous request completion + */ + void HandleErrorL( const TInt aError ); + + /** + * Determine the state of the socket + */ + void DetermineSocketStateL( const TInt aError ); + + /** + * Check the validity of the sender + */ + TBool CheckAddressValidity(); + + /** + * Send the received CIR message to client + */ + void ReportCirL(); + + /** + * Complete the request of the client application with an error + */ + void CompleteWithError( const TInt aError ); + + /** + * Reset the necessary member variables before connecting + */ + void Reset(); + + /** + * Save the necessary parameters before connecting + */ + void SetConnectionDetailsL( const TDesC& aServerAddress, + const TDesC8& aCSPSessionID, + const TUint aServerPort ); + + /** + * Wait for timer to expire + */ + void WaitForNextPing(); + + /** + * Handle a change in the status of the bearer. + */ + void HandleBearerEventL( TBool aIsAuthClose, TMsgBearerEvent aBearerEvent ); + + /** + * Return the name of the listener + */ +#ifdef _DEBUG + TPtrC8 Name() const; +#endif + + /** + * Delete the watcher's log file + */ + void DeleteLogFileL(); + + /** + * Symbian OS second-phase constructor. + */ + void ConstructL(); + + /** + * From CActive + */ + void RunL(); + + /** + * From CActive + */ + void DoCancel(); + + private: //Data + + enum TImpsCIRWatcherState + { + EImpsCIRWatcherIdle = KImpsCIRWatcherIdle, + EImpsCIRWatcherUnknown = KImpsCIRWatcherUnknown, + EImpsCIRWatcherAwaitingDNS = KImpsCIRWatcherAwaitingDNS, + EImpsCIRWatcherConnectingTCPSocket = KImpsCIRWatcherConnectingTCPSocket, + EImpsCIRWatcherSendingHELOMessage = KImpsCIRWatcherSendingHELOMessage, + EImpsCIRWatcherReceivingHELOResponse = KImpsCIRWatcherReceivingHELOResponse, + EImpsCIRWatcherReceivingFromSocket = KImpsCIRWatcherReceivingFromSocket, + EImpsCIRWatcherSendingPINGRequest = KImpsCIRWatcherSendingPINGRequest, + EImpsCIRWatcherWaitingPINGResponse = KImpsCIRWatcherWaitingPINGResponse, + EImpsCIRWatcherBearerSuspended = KImpsCIRWatcherBearerSuspended, + EImpsCIRWatcherStopping = KImpsCIRWatcherStopping + }; + + TUint iServerPort; + TUint iConnRetries; + TInt iPingRetries; + TInt iCompletionCode; + TBool iClientRequestPending; + RSocket iTCPCIRSocket; + TBuf8<512> iSocketReceiveBuffer; + TSockXfrLength iRecvLength; + HBufC8* iCSPSessionID; + HBufC8* iSocketSendBuffer; + HBufC* iAddressBuffer; + TInt iPingInterval; + TInetAddr iSocketAddress; + HBufC8* iPacket; + TRequestStatus* iClientStatus; + TNameEntry iHostAddressDnsEntry; + RHostResolver iHostResolver; + MImpsCirReceiver& iCirReceiver; + CTcpCirWatcherTimer* iWatcherTimer; + MMsgConnManager& iConnectionManager; + TImpsCIRWatcherState iWatcherStatus; + TImpsCIRWatcherState iLastGoodWatcherStatus; + RSocketServ iSocketSession; + RConnection iConnection; + }; + +#endif + +// End of File