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