diff options
Diffstat (limited to 'automation/inc/automation/simplecm.hxx')
-rw-r--r-- | automation/inc/automation/simplecm.hxx | 387 |
1 files changed, 387 insertions, 0 deletions
diff --git a/automation/inc/automation/simplecm.hxx b/automation/inc/automation/simplecm.hxx new file mode 100644 index 000000000000..dd522cb3beeb --- /dev/null +++ b/automation/inc/automation/simplecm.hxx @@ -0,0 +1,387 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +#ifndef _SIMPLECM_HXX +#define _SIMPLECM_HXX + +#include <tools/link.hxx> +#include <tools/string.hxx> +#include <tools/stream.hxx> +#include <osl/socket.hxx> +#include <tools/debug.hxx> +#include <tools/datetime.hxx> + +#include <automation/commdefines.hxx> + +// CM steht f�r CommunicationManager +#define CM_UNLIMITED_CONNECTIONS 0xffff + +typedef sal_uInt16 CM_NameType; +#define CM_DOTTED ( (CM_NameType) 01 ) +#define CM_FQDN ( (CM_NameType) 02 ) + +typedef sal_uInt16 CM_InfoType; +// nur eines dieser 3 defines darf verwendet werden +#define CM_NO_TEXT ( (CM_InfoType) 01 ) +#define CM_SHORT_TEXT ( (CM_InfoType) 02 ) +#define CM_VERBOSE_TEXT ( (CM_InfoType) 03 ) + +#define CM_OPEN ( (CM_InfoType) 0x0004 ) +#define CM_CLOSE ( (CM_InfoType) 0x0008 ) +#define CM_RECEIVE ( (CM_InfoType) 0x0010 ) +#define CM_SEND ( (CM_InfoType) 0x0020 ) +#define CM_ERROR ( (CM_InfoType) 0x0040 ) +#define CM_MISC ( (CM_InfoType) 0x0080 ) + +#define CM_USER_1 ( (CM_InfoType) 0x0100 ) +#define CM_USER_2 ( (CM_InfoType) 0x0200 ) +#define CM_USER_3 ( (CM_InfoType) 0x0400 ) +#define CM_USER_4 ( (CM_InfoType) 0x0800 ) + +#define CM_ALL ( CM_OPEN | CM_CLOSE | CM_RECEIVE | CM_SEND | CM_ERROR | CM_MISC ) +#define CM_NONE ( 0 ) + +#define CByteString( constAsciiStr ) ByteString( RTL_CONSTASCII_STRINGPARAM ( constAsciiStr ) ) + +#define INFO_MSG( Short, Long, Type, CLink ) \ +{ \ + if ( (Type & GetInfoType()) > 0 ) \ + { \ + switch ( GetInfoType() & 03 ) \ + { \ + case CM_NO_TEXT: \ + { \ + ByteString aByteString; \ + CallInfoMsg( InfoString( aByteString, Type, CLink ) ); \ + } \ + break; \ + case CM_SHORT_TEXT: \ + { \ + ByteString aByteString( Short ); \ + CallInfoMsg( InfoString( aByteString, Type, CLink ) ); \ + } \ + break; \ + case CM_VERBOSE_TEXT: \ + { \ + ByteString aByteString( Long ); \ + CallInfoMsg( InfoString( aByteString, Type, CLink ) ); \ + } \ + break; \ + default: \ + break; \ + } \ + } \ +}\ + +class CommunicationLink; + +SV_DECL_REF( CommunicationLink ) + +class InfoString : public ByteString +{ +public: + InfoString( ByteString &nMsg, CM_InfoType nIT, CommunicationLink *pCL = NULL ): ByteString( nMsg ), nInfoType( nIT ), pCommLink( pCL ) {;} + CM_InfoType GetInfoType(){ return nInfoType; } + CommunicationLinkRef GetCommunicationLink(){ return pCommLink; } +private: + CM_InfoType nInfoType; + CommunicationLinkRef pCommLink; +}; + +class PacketHandler; +class CommunicationManager; +class SingleCommunicationManager; +class MultiCommunicationManager; +class CommunicationManagerServerAcceptThread; +class CommunicationLink : public SvRefBase +{ +protected: + friend class CommunicationManager; + friend class SingleCommunicationManager; + friend class MultiCommunicationManager; + friend class CommunicationManagerServerAcceptThread; + // Darf nicht abger�umt werden zwischen Empfang des Streams und ende des Callbacks + +protected: // so da� nur �ber Ref gel�scht werden kann + virtual ~CommunicationLink(); + void InvalidateManager() { pMyManager = NULL; } + + PacketHandler* pPacketHandler; + +public: + CommunicationLink( CommunicationManager *pMan ); + + virtual sal_Bool StopCommunication()=0; + virtual sal_Bool IsCommunicationError()=0; + CommunicationManager* GetCommunicationManager(){ return pMyManager; } + +// Der Name oder die IP-Adresse oder sonstwas um den Communikationspartner zu identifizieren + virtual ByteString GetCommunicationPartner( CM_NameType eType )=0; + +// Der Name oder die IP-Adresse oder sonstwas um den Communikationspartner zu identifizieren + virtual ByteString GetMyName( CM_NameType eType )=0; + +// Liefert einen neuen Stream zum Versenden von Daten. + virtual SvStream* GetBestCommunicationStream()=0; + + /** will call virtual function DoTransferDataStream to do actual work + Purpos is to allow housekeeping + **/ + sal_Bool TransferDataStream( SvStream *pDataStream, CMProtocol nProtocol = CM_PROTOCOL_OLDSTYLE ); + + // Liefert die ID, die vom Sender angegeben wurde. + // Dadurch lassen sich virtuelle Kommunikationen �ber einen physikalischen Link realisiren. + // Da die Kommunikation zu �lteren Versionen kompatibel bleiben mu�, mu� der Empf�nger raten, + // die neue oder die alte verwendet wird, da sich der Kopf eines Auftrages dann �ndert. + sal_uInt16 GetProtocol(){ return nServiceProtocol; } + + // Der Stream wird hier �bergeben. Der Aufrufer ist f�r dessen L�schung zust�ndig + // Die Methode MUSS gerufen werden, da sonst keine weiteren Daten empfangen werden. + SvStream* GetServiceData(){ SvStream *pTemp = pServiceData; pServiceData = NULL; return pTemp; } + + /// Erm�glicht das Ausl�sen des n�chsten Callbacks. Wird auch Implizit gerufen. + void FinishCallback(){ bIsInsideCallback = sal_False; } + + /// Syncrones Empfangen der Daten. Nur f�r Kommandozeile, sonst leer implementiert + virtual sal_Bool ReceiveDataStream(){ return sal_False; } + + /// Statistics + DateTime GetStart() { return aStart; } + sal_uLong GetTotalBytes() { return nTotalBytes; } + DateTime GetLastAccess() { return aLastAccess; } + const ByteString& GetApplication() { return maApplication; } + virtual void SetApplication( const ByteString& aApp ); + +protected: + void CallInfoMsg( InfoString aMsg ); + CM_InfoType GetInfoType(); + CommunicationManager *pMyManager; +// Diese Methoden werden im Main Kontext gerufen und an den Manager weitergereicht. + virtual DECL_LINK( ConnectionClosed, void* = NULL ); + virtual DECL_LINK( DataReceived, void* = NULL ); + + virtual sal_Bool DoTransferDataStream( SvStream *pDataStream, CMProtocol nProtocol = CM_PROTOCOL_OLDSTYLE ); + + SvStream *pServiceData; + sal_uInt16 nServiceProtocol; + sal_uInt16 nServiceHeaderType; + + /// Verhindert das vorzeitige Ausl�sen des n�chsten Callbacks. + void StartCallback(){ bIsInsideCallback = sal_True; } + sal_Bool bIsInsideCallback; + + virtual sal_Bool SendHandshake( HandshakeType aHandshakeType, SvStream* pData = NULL)=0; + + virtual sal_Bool ShutdownCommunication() = 0; /// Really stop the Communication + + /// Statistics + DateTime aStart; + sal_uLong nTotalBytes; + DateTime aLastAccess; + +private: + ByteString maApplication; + +#if OSL_DEBUG_LEVEL > 1 +public: + // misc (debuging) purposes + sal_Bool bFlag; + sal_uLong nSomething; +#endif + +}; + +SV_IMPL_REF( CommunicationLink ); + +class CommonSocketFunctions; +class CommunicationManager +{ + friend class CommunicationLink; + friend class CommonSocketFunctions; +public: + CommunicationManager( sal_Bool bUseMultiChannel = sal_False ); + virtual ~CommunicationManager(); + + virtual sal_Bool StartCommunication()=0; + virtual sal_Bool StartCommunication( String aApp, String aParams ); + virtual sal_Bool StartCommunication( ByteString aHost, sal_uLong nPort ); + virtual sal_Bool StopCommunication()=0; // H�lt alle CommunicationLinks an + virtual sal_Bool IsCommunicationRunning() { return bIsCommunicationRunning; } +// virtual sal_Bool IsCommunicationError(); + +// Der Name oder die IP-Adresse oder sonstwas um den Communikationspartner zu identifizieren + virtual ByteString GetMyName( CM_NameType eType ); + + virtual sal_Bool IsLinkValid( CommunicationLink* pCL )=0; // Notwendig f�r call im Destruktor + + virtual sal_uInt16 GetCommunicationLinkCount()=0; + virtual CommunicationLinkRef GetCommunicationLink( sal_uInt16 nNr )=0; + + // Liefert den letzten neuen Link oder NULL wenn dieser schon wieder geschlossen ist. + CommunicationLinkRef GetLastNewLink() { return xLastNewLink; } + + void SetConnectionOpenedHdl( Link lConnectionOpened ){ mlConnectionOpened = lConnectionOpened; } + void SetConnectionClosedHdl( Link lConnectionClosed ){ mlConnectionClosed = lConnectionClosed; } + void SetDataReceivedHdl( Link lDataReceived ){ mlDataReceived = lDataReceived; } + void SetInfoMsgHdl( Link lInfoMsg ){ mlInfoMsg = lInfoMsg; } + + void SetInfoType( CM_InfoType nIT ){ nInfoType = nIT; } + CM_InfoType GetInfoType(){ return nInfoType; } + + sal_Bool IsMultiChannel(){ return bIsMultiChannel; } + void SetApplication( const ByteString& aApp, sal_Bool bRunningLinks = sal_False ); + const ByteString& GetApplication() { return maApplication; } + +protected: + // Diese Methoden werden innerhalb gerufen. Sie erledigen eventuelles Housekeeping + // und rufen dann die entsprechende Methode + virtual void CallConnectionOpened( CommunicationLink* pCL ); + virtual void CallConnectionClosed( CommunicationLink* pCL ); + void CallDataReceived( CommunicationLink* pCL ); + void CallInfoMsg( InfoString aMsg ); + + CM_InfoType nInfoType; + + // Diese Routinen rufen den Link oder sind �berladen + virtual void ConnectionOpened( CommunicationLink* pCL ){ mlConnectionOpened.Call( pCL ); } + virtual void ConnectionClosed( CommunicationLink* pCL ){ mlConnectionClosed.Call( pCL ); } + virtual void DataReceived( CommunicationLink* pCL ){ mlDataReceived.Call( pCL ); } + virtual void InfoMsg( InfoString aMsg ){ mlInfoMsg.Call( &aMsg ); } + + sal_Bool bIsCommunicationRunning; + + virtual void DestroyingLink( CommunicationLink *pCL )=0; // Link tr�gt sich im Destruktor aus + +private: + ByteString maApplication; + Link mlConnectionOpened; + Link mlConnectionClosed; + Link mlDataReceived; + Link mlInfoMsg; + CommunicationLinkRef xLastNewLink; + + sal_Bool bIsMultiChannel; +}; + +class SingleCommunicationManager : public CommunicationManager +{ +public: + SingleCommunicationManager( sal_Bool bUseMultiChannel = sal_False ); + virtual ~SingleCommunicationManager(); + virtual sal_Bool StopCommunication(); // H�lt alle CommunicationLinks an + virtual sal_Bool IsLinkValid( CommunicationLink* pCL ); + virtual sal_uInt16 GetCommunicationLinkCount(); + virtual CommunicationLinkRef GetCommunicationLink( sal_uInt16 nNr ); + +protected: + virtual void CallConnectionOpened( CommunicationLink* pCL ); + virtual void CallConnectionClosed( CommunicationLink* pCL ); + CommunicationLinkRef xActiveLink; + CommunicationLink *pInactiveLink; + virtual void DestroyingLink( CommunicationLink *pCL ); // Link tr�gt sich im Destruktor aus +}; + +class ICommunicationManagerClient +{ + friend class CommonSocketFunctions; +protected: + virtual sal_Bool RetryConnect() { return sal_False; } // Kann dann eventuell die Applikation starten +}; + +class TCPIO; +class SimpleCommunicationLinkViaSocket : public CommunicationLink +{ +public: + virtual sal_Bool IsCommunicationError(); + virtual sal_Bool StopCommunication(); + + virtual ByteString GetCommunicationPartner( CM_NameType eType ); + virtual ByteString GetMyName( CM_NameType eType ); + virtual SvStream* GetBestCommunicationStream(); + virtual void SetApplication( const ByteString& aApp ); + +private: + ByteString aCommunicationPartner; + ByteString aMyName; + + TCPIO* pTCPIO; + osl::StreamSocket* pStreamSocket; + +protected: + SimpleCommunicationLinkViaSocket( CommunicationManager *pMan, osl::StreamSocket* pSocket ); + virtual ~SimpleCommunicationLinkViaSocket(); + + osl::StreamSocket* GetStreamSocket() { return pStreamSocket; } + void SetStreamSocket( osl::StreamSocket* pSocket ); + + SvStream *pReceiveStream; + sal_Bool DoReceiveDataStream(); /// Recieve DataPacket from Socket + virtual sal_Bool SendHandshake( HandshakeType aHandshakeType, SvStream* pData = NULL); + bool IsReceiveReady(); + sal_Bool bIsRequestShutdownPending; + virtual void WaitForShutdown()=0; + void SetNewPacketAsCurrent(); +}; + +class SimpleCommunicationLinkViaSocketWithReceiveCallbacks : public SimpleCommunicationLinkViaSocket +{ +public: + SimpleCommunicationLinkViaSocketWithReceiveCallbacks( CommunicationManager *pMan, osl::StreamSocket* pSocket ); + ~SimpleCommunicationLinkViaSocketWithReceiveCallbacks(); + virtual sal_Bool ReceiveDataStream(); +protected: + virtual sal_Bool ShutdownCommunication(); /// Really stop the Communication + virtual void WaitForShutdown(); +}; + +class CommonSocketFunctions +{ +public: + sal_Bool DoStartCommunication( CommunicationManager *pCM, ICommunicationManagerClient *pCMC, ByteString aHost, sal_uLong nPort ); +protected: + virtual CommunicationLink *CreateCommunicationLink( CommunicationManager *pCM, osl::ConnectorSocket* pCS )=0; +}; + +class SingleCommunicationManagerClientViaSocket : public SingleCommunicationManager, public ICommunicationManagerClient, CommonSocketFunctions +{ +public: + using CommunicationManager::StartCommunication; + + SingleCommunicationManagerClientViaSocket( ByteString aHost, sal_uLong nPort, sal_Bool bUseMultiChannel = sal_False ); + SingleCommunicationManagerClientViaSocket( sal_Bool bUseMultiChannel = sal_False ); + virtual sal_Bool StartCommunication(){ return DoStartCommunication( this, (ICommunicationManagerClient*) this, aHostToTalk, nPortToTalk );} + virtual sal_Bool StartCommunication( ByteString aHost, sal_uLong nPort ){ return DoStartCommunication( this, (ICommunicationManagerClient*) this, aHost, nPort );} +private: + ByteString aHostToTalk; + sal_uLong nPortToTalk; +protected: + virtual CommunicationLink *CreateCommunicationLink( CommunicationManager *pCM, osl::ConnectorSocket* pCS ){ return new SimpleCommunicationLinkViaSocketWithReceiveCallbacks( pCM, pCS ); } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |