1*cdf0e10cSrcweir /************************************************************************* 2*cdf0e10cSrcweir * 3*cdf0e10cSrcweir * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4*cdf0e10cSrcweir * 5*cdf0e10cSrcweir * Copyright 2000, 2010 Oracle and/or its affiliates. 6*cdf0e10cSrcweir * 7*cdf0e10cSrcweir * OpenOffice.org - a multi-platform office productivity suite 8*cdf0e10cSrcweir * 9*cdf0e10cSrcweir * This file is part of OpenOffice.org. 10*cdf0e10cSrcweir * 11*cdf0e10cSrcweir * OpenOffice.org is free software: you can redistribute it and/or modify 12*cdf0e10cSrcweir * it under the terms of the GNU Lesser General Public License version 3 13*cdf0e10cSrcweir * only, as published by the Free Software Foundation. 14*cdf0e10cSrcweir * 15*cdf0e10cSrcweir * OpenOffice.org is distributed in the hope that it will be useful, 16*cdf0e10cSrcweir * but WITHOUT ANY WARRANTY; without even the implied warranty of 17*cdf0e10cSrcweir * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18*cdf0e10cSrcweir * GNU Lesser General Public License version 3 for more details 19*cdf0e10cSrcweir * (a copy is included in the LICENSE file that accompanied this code). 20*cdf0e10cSrcweir * 21*cdf0e10cSrcweir * You should have received a copy of the GNU Lesser General Public License 22*cdf0e10cSrcweir * version 3 along with OpenOffice.org. If not, see 23*cdf0e10cSrcweir * <http://www.openoffice.org/license.html> 24*cdf0e10cSrcweir * for a copy of the LGPLv3 License. 25*cdf0e10cSrcweir * 26*cdf0e10cSrcweir ************************************************************************/ 27*cdf0e10cSrcweir 28*cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 29*cdf0e10cSrcweir #include "precompiled_automation.hxx" 30*cdf0e10cSrcweir 31*cdf0e10cSrcweir /************************************************************************* 32*cdf0e10cSrcweir * 33*cdf0e10cSrcweir * ATTENTION 34*cdf0e10cSrcweir * This file is intended to work inside and outside the StarOffice environment. 35*cdf0e10cSrcweir * Only adaption of file commtypes.hxx should be necessary. Else it is a bug! 36*cdf0e10cSrcweir * 37*cdf0e10cSrcweir ************************************************************************/ 38*cdf0e10cSrcweir 39*cdf0e10cSrcweir #include "packethandler.hxx" 40*cdf0e10cSrcweir #include <automation/commtypes.hxx> 41*cdf0e10cSrcweir #include <automation/commdefines.hxx> 42*cdf0e10cSrcweir #include "communiio.hxx" 43*cdf0e10cSrcweir 44*cdf0e10cSrcweir /** 45*cdf0e10cSrcweir Forces switch to multichannel headers even for old communication Method 46*cdf0e10cSrcweir **/ 47*cdf0e10cSrcweir #define FORCE_MULTI_CHANNEL_HEADERS 48*cdf0e10cSrcweir 49*cdf0e10cSrcweir 50*cdf0e10cSrcweir PacketHandler::PacketHandler( ITransmiter* pTransmitter_, IReceiver* pReceiver_, comm_BOOL bMC ) 51*cdf0e10cSrcweir : pTransmitter( pTransmitter_ ) 52*cdf0e10cSrcweir , pReceiver( pReceiver_ ) 53*cdf0e10cSrcweir , bMultiChannel( bMC ) 54*cdf0e10cSrcweir { 55*cdf0e10cSrcweir } 56*cdf0e10cSrcweir 57*cdf0e10cSrcweir unsigned char PacketHandler::CalcCheckByte( comm_UINT32 nBytes ) 58*cdf0e10cSrcweir { 59*cdf0e10cSrcweir comm_UINT16 nRes = 0; 60*cdf0e10cSrcweir nRes += HIBYTE( HIWORD( nBytes ) ) ^ 0xf0; 61*cdf0e10cSrcweir nRes += LOBYTE( HIWORD( nBytes ) ) ^ 0x0f; 62*cdf0e10cSrcweir nRes += HIBYTE( LOWORD( nBytes ) ) ^ 0xf0; 63*cdf0e10cSrcweir nRes += LOBYTE( LOWORD( nBytes ) ) ^ 0x0f; 64*cdf0e10cSrcweir 65*cdf0e10cSrcweir nRes ^= HIBYTE( nRes ); 66*cdf0e10cSrcweir 67*cdf0e10cSrcweir return LOBYTE( nRes ); 68*cdf0e10cSrcweir } 69*cdf0e10cSrcweir 70*cdf0e10cSrcweir 71*cdf0e10cSrcweir #define READ_SOCKET( pBuffer, nLength )\ 72*cdf0e10cSrcweir if ( !bWasError )\ 73*cdf0e10cSrcweir {\ 74*cdf0e10cSrcweir bWasError |= pReceiver->ReceiveBytes( pBuffer, nLength ) != C_ERROR_NONE;\ 75*cdf0e10cSrcweir } 76*cdf0e10cSrcweir 77*cdf0e10cSrcweir #define READ_SOCKET_LEN( pBuffer, nLength, nTotal )\ 78*cdf0e10cSrcweir READ_SOCKET( pBuffer, nLength );\ 79*cdf0e10cSrcweir if ( !bWasError )\ 80*cdf0e10cSrcweir {nTotal += nLength;} 81*cdf0e10cSrcweir 82*cdf0e10cSrcweir comm_BOOL PacketHandler::ReceiveData( void* &pData, comm_UINT32 &nLen ) 83*cdf0e10cSrcweir { 84*cdf0e10cSrcweir DBG_ASSERT( !pData, "pData should be NULL -> memory leak" ); 85*cdf0e10cSrcweir 86*cdf0e10cSrcweir nLen = 0; 87*cdf0e10cSrcweir pData = NULL; 88*cdf0e10cSrcweir comm_BOOL bWasError = sal_False; 89*cdf0e10cSrcweir comm_BOOL bForceMultiChannelThisPacket = sal_False; 90*cdf0e10cSrcweir if ( pReceiver ) 91*cdf0e10cSrcweir { 92*cdf0e10cSrcweir comm_UINT32 nBytes = 0; 93*cdf0e10cSrcweir nReceiveProtocol = CM_PROTOCOL_OLDSTYLE; 94*cdf0e10cSrcweir nReceiveHeaderType = CH_NoHeader; 95*cdf0e10cSrcweir 96*cdf0e10cSrcweir READ_SOCKET( &nBytes, sizeof(nBytes) ) 97*cdf0e10cSrcweir if ( bWasError ) 98*cdf0e10cSrcweir return sal_False; 99*cdf0e10cSrcweir 100*cdf0e10cSrcweir if ( 0xFFFFFFFF == nBytes ) // Expliziter Request f�r dieses Datenpaket auf MultiChannel umzuschalten 101*cdf0e10cSrcweir { 102*cdf0e10cSrcweir READ_SOCKET( &nBytes, sizeof(nBytes) ) 103*cdf0e10cSrcweir if ( bWasError ) 104*cdf0e10cSrcweir return sal_False; 105*cdf0e10cSrcweir bForceMultiChannelThisPacket = sal_True; 106*cdf0e10cSrcweir } 107*cdf0e10cSrcweir 108*cdf0e10cSrcweir nBytes = NETDWORD( nBytes ); 109*cdf0e10cSrcweir 110*cdf0e10cSrcweir if ( bMultiChannel || bForceMultiChannelThisPacket ) 111*cdf0e10cSrcweir { 112*cdf0e10cSrcweir comm_ULONG nReadSoFar = 0; 113*cdf0e10cSrcweir comm_ULONG nHeaderReadSoFar = 0; 114*cdf0e10cSrcweir 115*cdf0e10cSrcweir // Pr�fbyte f�r L�ngenangabe 116*cdf0e10cSrcweir unsigned char nLenCheck = 0; 117*cdf0e10cSrcweir READ_SOCKET_LEN( &nLenCheck, 1, nReadSoFar ); 118*cdf0e10cSrcweir // Stimmt das Pr�fbyte? 119*cdf0e10cSrcweir bWasError |= nLenCheck != CalcCheckByte( nBytes ); 120*cdf0e10cSrcweir 121*cdf0e10cSrcweir 122*cdf0e10cSrcweir comm_UINT16 nHeaderBytes; 123*cdf0e10cSrcweir READ_SOCKET_LEN( &nHeaderBytes, 2, nReadSoFar ); 124*cdf0e10cSrcweir nHeaderBytes = NETWORD( nHeaderBytes ); 125*cdf0e10cSrcweir // reicht der Header �ber das Ende hinaus? 126*cdf0e10cSrcweir bWasError |= !(nBytes >= nReadSoFar + nHeaderBytes); 127*cdf0e10cSrcweir 128*cdf0e10cSrcweir READ_SOCKET_LEN( &nReceiveHeaderType, 2, nHeaderReadSoFar ); 129*cdf0e10cSrcweir nReceiveHeaderType = NETWORD( nReceiveHeaderType ); 130*cdf0e10cSrcweir 131*cdf0e10cSrcweir switch ( nReceiveHeaderType ) 132*cdf0e10cSrcweir { 133*cdf0e10cSrcweir case CH_SimpleMultiChannel: 134*cdf0e10cSrcweir { 135*cdf0e10cSrcweir READ_SOCKET_LEN( &nReceiveProtocol, 2, nHeaderReadSoFar ); 136*cdf0e10cSrcweir nReceiveProtocol = NETWORD( nReceiveProtocol ); 137*cdf0e10cSrcweir } 138*cdf0e10cSrcweir break; 139*cdf0e10cSrcweir case CH_Handshake: 140*cdf0e10cSrcweir { 141*cdf0e10cSrcweir } 142*cdf0e10cSrcweir break; 143*cdf0e10cSrcweir default: 144*cdf0e10cSrcweir { 145*cdf0e10cSrcweir DBG_ERROR("Unbekannter Headertyp in der Kommunikation"); 146*cdf0e10cSrcweir bWasError = sal_True; 147*cdf0e10cSrcweir } 148*cdf0e10cSrcweir 149*cdf0e10cSrcweir } 150*cdf0e10cSrcweir 151*cdf0e10cSrcweir if ( bWasError ) 152*cdf0e10cSrcweir return sal_False; 153*cdf0e10cSrcweir 154*cdf0e10cSrcweir /// L�ngen anpassen und ggf restheader �berlesen. 155*cdf0e10cSrcweir while ( nHeaderBytes > nHeaderReadSoFar ) 156*cdf0e10cSrcweir { 157*cdf0e10cSrcweir unsigned char nDummy; 158*cdf0e10cSrcweir READ_SOCKET_LEN( &nDummy, 1, nHeaderReadSoFar ); 159*cdf0e10cSrcweir } 160*cdf0e10cSrcweir 161*cdf0e10cSrcweir nReadSoFar += nHeaderReadSoFar; 162*cdf0e10cSrcweir nBytes -= nReadSoFar; 163*cdf0e10cSrcweir 164*cdf0e10cSrcweir } 165*cdf0e10cSrcweir 166*cdf0e10cSrcweir /* @@@ Notes @@@ 167*cdf0e10cSrcweir * 168*cdf0e10cSrcweir * 1) a 'void*' allocated via 'new char[]' is always deallocated 169*cdf0e10cSrcweir * via plain 'delete()', not via array 'delete[]()'; it's just 170*cdf0e10cSrcweir * raw memory. 171*cdf0e10cSrcweir * 172*cdf0e10cSrcweir * 2) as the caller of this routine later-on changes ownership 173*cdf0e10cSrcweir * of 'pData' via 'SvMemoryStream::SetBuffer()' (in 'simplecm.cxx', 174*cdf0e10cSrcweir * 'SimpleCommunicationLinkViaSocket::DoReceiveDataStream()'), 175*cdf0e10cSrcweir * the allocator used here for 'void* pData' must match the 176*cdf0e10cSrcweir * deallocator used in 'SvMemoryStream::FreeMemory()', i.e. 177*cdf0e10cSrcweir * '::operator delete()'. 178*cdf0e10cSrcweir */ 179*cdf0e10cSrcweir pData = ::operator new(nBytes); 180*cdf0e10cSrcweir READ_SOCKET( pData, nBytes ) 181*cdf0e10cSrcweir if ( bWasError ) 182*cdf0e10cSrcweir { 183*cdf0e10cSrcweir ::operator delete(pData), pData = 0; 184*cdf0e10cSrcweir return sal_False; 185*cdf0e10cSrcweir } 186*cdf0e10cSrcweir nLen = nBytes; 187*cdf0e10cSrcweir } 188*cdf0e10cSrcweir else 189*cdf0e10cSrcweir bWasError = sal_True; 190*cdf0e10cSrcweir 191*cdf0e10cSrcweir return !bWasError; 192*cdf0e10cSrcweir } 193*cdf0e10cSrcweir 194*cdf0e10cSrcweir /*#define WRITE_SOCKET( pBuffer, nLength )\ 195*cdf0e10cSrcweir if ( !bWasError )\ 196*cdf0e10cSrcweir bWasError |= !pStreamSocket || (pStreamSocket->write( pBuffer, nLength ) != nLength)*/ 197*cdf0e10cSrcweir 198*cdf0e10cSrcweir #define WRITE_SOCKET( pBuffer, nLength )\ 199*cdf0e10cSrcweir if ( !bWasError )\ 200*cdf0e10cSrcweir {bWasError |= pTransmitter->TransferBytes( pBuffer, nLength ) != C_ERROR_NONE;} 201*cdf0e10cSrcweir 202*cdf0e10cSrcweir 203*cdf0e10cSrcweir 204*cdf0e10cSrcweir comm_BOOL PacketHandler::TransferData( const void* pData, comm_UINT32 nLen, CMProtocol nProtocol ) 205*cdf0e10cSrcweir { 206*cdf0e10cSrcweir comm_UINT32 nBuffer = nLen; 207*cdf0e10cSrcweir comm_BOOL bWasError = sal_False; 208*cdf0e10cSrcweir 209*cdf0e10cSrcweir #ifndef FORCE_MULTI_CHANNEL_HEADERS 210*cdf0e10cSrcweir if ( bMultiChannel ) 211*cdf0e10cSrcweir #endif 212*cdf0e10cSrcweir nBuffer += 1+2+2+2; // f�r einen CH_SimpleMultiChannel 213*cdf0e10cSrcweir 214*cdf0e10cSrcweir #ifdef FORCE_MULTI_CHANNEL_HEADERS 215*cdf0e10cSrcweir if ( !bMultiChannel ) 216*cdf0e10cSrcweir { 217*cdf0e10cSrcweir comm_UINT32 n32; 218*cdf0e10cSrcweir n32 = 0xffffffff; // Umschalten auf MultiChannel 219*cdf0e10cSrcweir n32 = NETDWORD( n32 ); 220*cdf0e10cSrcweir WRITE_SOCKET( &n32, 4 ); 221*cdf0e10cSrcweir } 222*cdf0e10cSrcweir #endif 223*cdf0e10cSrcweir 224*cdf0e10cSrcweir 225*cdf0e10cSrcweir comm_UINT32 nNetworkBuffer = NETDWORD( nBuffer ); 226*cdf0e10cSrcweir WRITE_SOCKET( &nNetworkBuffer, sizeof(nNetworkBuffer) ); 227*cdf0e10cSrcweir 228*cdf0e10cSrcweir 229*cdf0e10cSrcweir #ifndef FORCE_MULTI_CHANNEL_HEADERS 230*cdf0e10cSrcweir if ( bMultiChannel ) 231*cdf0e10cSrcweir #endif 232*cdf0e10cSrcweir { 233*cdf0e10cSrcweir comm_UINT16 n16; 234*cdf0e10cSrcweir unsigned char c; 235*cdf0e10cSrcweir 236*cdf0e10cSrcweir c = CalcCheckByte( nBuffer ); 237*cdf0e10cSrcweir WRITE_SOCKET( &c, 1 ); 238*cdf0e10cSrcweir 239*cdf0e10cSrcweir n16 = 4; // L�nge des Headers f�r einen CH_SimpleMultiChannel 240*cdf0e10cSrcweir n16 = NETWORD( n16 ); 241*cdf0e10cSrcweir WRITE_SOCKET( &n16, 2 ); 242*cdf0e10cSrcweir 243*cdf0e10cSrcweir n16 = CH_SimpleMultiChannel; // Typ des Headers 244*cdf0e10cSrcweir n16 = NETWORD( n16 ); 245*cdf0e10cSrcweir WRITE_SOCKET( &n16, 2 ); 246*cdf0e10cSrcweir 247*cdf0e10cSrcweir nProtocol = NETWORD( nProtocol ); 248*cdf0e10cSrcweir WRITE_SOCKET( &nProtocol, 2 ); 249*cdf0e10cSrcweir } 250*cdf0e10cSrcweir 251*cdf0e10cSrcweir WRITE_SOCKET( pData, nLen ); 252*cdf0e10cSrcweir return !bWasError; 253*cdf0e10cSrcweir } 254*cdf0e10cSrcweir 255*cdf0e10cSrcweir comm_BOOL PacketHandler::SendHandshake( HandshakeType aHandshakeType, const void* pData, comm_UINT32 nLen ) 256*cdf0e10cSrcweir { 257*cdf0e10cSrcweir comm_BOOL bWasError = sal_False; 258*cdf0e10cSrcweir 259*cdf0e10cSrcweir comm_UINT32 nBuffer = 0; 260*cdf0e10cSrcweir 261*cdf0e10cSrcweir // if ( pMyManager->IsMultiChannel() ) Wir senden immer FFFFFFFF vorweg -> immer MultiChannel (Oder GPF bei �lteren) 262*cdf0e10cSrcweir nBuffer += 1+2+2; // f�r einen CH_Handshake 263*cdf0e10cSrcweir 264*cdf0e10cSrcweir nBuffer += 2; // f�r den Typ des Handshakes 265*cdf0e10cSrcweir 266*cdf0e10cSrcweir switch ( aHandshakeType ) 267*cdf0e10cSrcweir { 268*cdf0e10cSrcweir case CH_REQUEST_HandshakeAlive: 269*cdf0e10cSrcweir nBuffer += 0; // Keine extra Daten 270*cdf0e10cSrcweir break; 271*cdf0e10cSrcweir case CH_RESPONSE_HandshakeAlive: 272*cdf0e10cSrcweir nBuffer += 0; // Keine extra Daten 273*cdf0e10cSrcweir break; 274*cdf0e10cSrcweir case CH_REQUEST_ShutdownLink: 275*cdf0e10cSrcweir nBuffer += 0; // Keine extra Daten 276*cdf0e10cSrcweir break; 277*cdf0e10cSrcweir case CH_ShutdownLink: 278*cdf0e10cSrcweir nBuffer += 0; // Keine extra Daten 279*cdf0e10cSrcweir break; 280*cdf0e10cSrcweir case CH_SUPPORT_OPTIONS: 281*cdf0e10cSrcweir nBuffer += 2 ; // one word extradata for options 282*cdf0e10cSrcweir break; 283*cdf0e10cSrcweir case CH_SetApplication: 284*cdf0e10cSrcweir nBuffer += 0 ; // one word extradata for options 285*cdf0e10cSrcweir break; 286*cdf0e10cSrcweir default: 287*cdf0e10cSrcweir DBG_ERROR("Unknown HandshakeType"); 288*cdf0e10cSrcweir } 289*cdf0e10cSrcweir 290*cdf0e10cSrcweir if ( pData ) 291*cdf0e10cSrcweir nBuffer += nLen; // Extra data in Buffer 292*cdf0e10cSrcweir 293*cdf0e10cSrcweir comm_UINT32 n32; 294*cdf0e10cSrcweir n32 = 0xffffffff; // Umschalten auf MultiChannel 295*cdf0e10cSrcweir n32 = NETDWORD( n32 ); 296*cdf0e10cSrcweir WRITE_SOCKET( &n32, 4 ); 297*cdf0e10cSrcweir 298*cdf0e10cSrcweir comm_UINT32 nNetworkBuffer = NETDWORD( nBuffer ); 299*cdf0e10cSrcweir WRITE_SOCKET( &nNetworkBuffer, sizeof(nNetworkBuffer) ); 300*cdf0e10cSrcweir 301*cdf0e10cSrcweir 302*cdf0e10cSrcweir comm_UINT16 n16; 303*cdf0e10cSrcweir unsigned char c; 304*cdf0e10cSrcweir 305*cdf0e10cSrcweir c = CalcCheckByte( nBuffer ); 306*cdf0e10cSrcweir WRITE_SOCKET( &c, 1 ); 307*cdf0e10cSrcweir 308*cdf0e10cSrcweir n16 = 2; // L�nge des Headers f�r einen CH_Handshake 309*cdf0e10cSrcweir n16 = NETWORD( n16 ); 310*cdf0e10cSrcweir WRITE_SOCKET( &n16, 2 ); 311*cdf0e10cSrcweir 312*cdf0e10cSrcweir n16 = CH_Handshake; // Typ des Headers 313*cdf0e10cSrcweir n16 = NETWORD( n16 ); 314*cdf0e10cSrcweir WRITE_SOCKET( &n16, 2 ); 315*cdf0e10cSrcweir 316*cdf0e10cSrcweir n16 = aHandshakeType; // Typ des Handshakes 317*cdf0e10cSrcweir n16 = NETWORD( n16 ); 318*cdf0e10cSrcweir WRITE_SOCKET( &n16, 2 ); 319*cdf0e10cSrcweir 320*cdf0e10cSrcweir 321*cdf0e10cSrcweir switch ( aHandshakeType ) 322*cdf0e10cSrcweir { 323*cdf0e10cSrcweir case CH_SUPPORT_OPTIONS: 324*cdf0e10cSrcweir n16 = OPT_USE_SHUTDOWN_PROTOCOL; 325*cdf0e10cSrcweir n16 = NETWORD( n16 ); 326*cdf0e10cSrcweir WRITE_SOCKET( &n16, 2 ); 327*cdf0e10cSrcweir break; 328*cdf0e10cSrcweir } 329*cdf0e10cSrcweir 330*cdf0e10cSrcweir if ( pData ) 331*cdf0e10cSrcweir WRITE_SOCKET( pData, nLen ); 332*cdf0e10cSrcweir 333*cdf0e10cSrcweir return !bWasError; 334*cdf0e10cSrcweir } 335