187d2adbcSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
387d2adbcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
487d2adbcSAndrew Rist * or more contributor license agreements. See the NOTICE file
587d2adbcSAndrew Rist * distributed with this work for additional information
687d2adbcSAndrew Rist * regarding copyright ownership. The ASF licenses this file
787d2adbcSAndrew Rist * to you under the Apache License, Version 2.0 (the
887d2adbcSAndrew Rist * "License"); you may not use this file except in compliance
987d2adbcSAndrew Rist * with the License. You may obtain a copy of the License at
1087d2adbcSAndrew Rist *
1187d2adbcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1287d2adbcSAndrew Rist *
1387d2adbcSAndrew Rist * Unless required by applicable law or agreed to in writing,
1487d2adbcSAndrew Rist * software distributed under the License is distributed on an
1587d2adbcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1687d2adbcSAndrew Rist * KIND, either express or implied. See the License for the
1787d2adbcSAndrew Rist * specific language governing permissions and limitations
1887d2adbcSAndrew Rist * under the License.
1987d2adbcSAndrew Rist *
2087d2adbcSAndrew Rist *************************************************************/
2187d2adbcSAndrew Rist
2287d2adbcSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sal.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir /** test coder preface:
28cdf0e10cSrcweir 1. the BSD socket function will meet "unresolved external symbol error" on Windows platform
29cdf0e10cSrcweir if you are not including ws2_32.lib in makefile.mk, the including format will be like this:
30cdf0e10cSrcweir
31cdf0e10cSrcweir .IF "$(GUI)" == "WNT"
32cdf0e10cSrcweir SHL1STDLIBS += $(SOLARLIBDIR)$/cppunit.lib
33cdf0e10cSrcweir SHL1STDLIBS += ws2_32.lib
34cdf0e10cSrcweir .ENDIF
35cdf0e10cSrcweir
36cdf0e10cSrcweir likewise on Solaris platform.
37cdf0e10cSrcweir .IF "$(GUI)" == "UNX"
38cdf0e10cSrcweir SHL1STDLIBS+=$(SOLARLIBDIR)$/libcppunit$(DLLPOSTFIX).a
39cdf0e10cSrcweir SHL1STDLIBS += -lsocket -ldl -lnsl
40cdf0e10cSrcweir .ENDIF
41cdf0e10cSrcweir
42cdf0e10cSrcweir 2. since the Socket implementation of osl is only IPv4 oriented, our test are mainly focus on IPv4
43cdf0e10cSrcweir category.
44cdf0e10cSrcweir
45cdf0e10cSrcweir 3. some fragment of Socket source implementation are lack of comment so it is hard for testers
46cdf0e10cSrcweir guess what the exact functionality or usage of a member. Hope the Socket section's comment
47cdf0e10cSrcweir will be added.
48cdf0e10cSrcweir
49cdf0e10cSrcweir 4. following functions are declared but not implemented:
50cdf0e10cSrcweir inline sal_Bool SAL_CALL operator== (const SocketAddr & Addr) const;
51cdf0e10cSrcweir */
52cdf0e10cSrcweir
53cdf0e10cSrcweir //------------------------------------------------------------------------
54cdf0e10cSrcweir // include files
55cdf0e10cSrcweir //------------------------------------------------------------------------
56cdf0e10cSrcweir
57cdf0e10cSrcweir
58cdf0e10cSrcweir //#include "osl_Socket_Const.h"
59cdf0e10cSrcweir #include "sockethelper.hxx"
60cdf0e10cSrcweir #include <osl/conditn.hxx>
61*63d99982SDamjan Jovanovic #include <osl/signal.h>
62*63d99982SDamjan Jovanovic #include "gtest/gtest.h"
63cdf0e10cSrcweir
64cdf0e10cSrcweir using namespace osl;
65cdf0e10cSrcweir using namespace rtl;
66cdf0e10cSrcweir
67cdf0e10cSrcweir #define IP_PORT_MYPORT9 8897
68cdf0e10cSrcweir #define IP_PORT_MYPORT10 18900
69cdf0e10cSrcweir
70cdf0e10cSrcweir const char * pTestString1 = "test socket";
71cdf0e10cSrcweir const char * pTestString2 = " Passed#OK";
72cdf0e10cSrcweir
73cdf0e10cSrcweir //------------------------------------------------------------------------
74cdf0e10cSrcweir // helper functions
75cdf0e10cSrcweir //------------------------------------------------------------------------
76cdf0e10cSrcweir
77cdf0e10cSrcweir // just used to test socket::close() when accepting
78cdf0e10cSrcweir class AcceptorThread : public Thread
79cdf0e10cSrcweir {
80cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
81cdf0e10cSrcweir ::rtl::OUString aHostIP;
82cdf0e10cSrcweir sal_Bool bOK;
83cdf0e10cSrcweir protected:
run()84cdf0e10cSrcweir void SAL_CALL run( )
85cdf0e10cSrcweir {
86cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( aHostIP, IP_PORT_MYPORT9 );
87cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
88cdf0e10cSrcweir
89cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //integer not sal_Bool : sal_True);
90cdf0e10cSrcweir sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
91cdf0e10cSrcweir if ( sal_True != bOK1 )
92cdf0e10cSrcweir {
93*63d99982SDamjan Jovanovic printf("# AcceptorSocket bind address failed.\n" ) ;
94cdf0e10cSrcweir return;
95cdf0e10cSrcweir }
96cdf0e10cSrcweir sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
97cdf0e10cSrcweir if ( sal_True != bOK2 )
98cdf0e10cSrcweir {
99*63d99982SDamjan Jovanovic printf("# AcceptorSocket listen address failed.\n" ) ;
100cdf0e10cSrcweir return;
101cdf0e10cSrcweir }
102cdf0e10cSrcweir
103cdf0e10cSrcweir asAcceptorSocket.enableNonBlockingMode( sal_False );
104cdf0e10cSrcweir
105cdf0e10cSrcweir oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
106cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
107cdf0e10cSrcweir {
108cdf0e10cSrcweir bOK = sal_True;
109*63d99982SDamjan Jovanovic printf("AcceptorThread: acceptConnection failed! \n");
110cdf0e10cSrcweir }
111cdf0e10cSrcweir }
112cdf0e10cSrcweir public:
AcceptorThread(::osl::AcceptorSocket & asSocket,::rtl::OUString const & aBindIP)113cdf0e10cSrcweir AcceptorThread(::osl::AcceptorSocket & asSocket, ::rtl::OUString const& aBindIP )
114cdf0e10cSrcweir : asAcceptorSocket( asSocket ), aHostIP( aBindIP )
115cdf0e10cSrcweir {
116cdf0e10cSrcweir bOK = sal_False;
117cdf0e10cSrcweir }
118cdf0e10cSrcweir
isOK()119cdf0e10cSrcweir sal_Bool isOK() { return bOK; }
120cdf0e10cSrcweir
~AcceptorThread()121cdf0e10cSrcweir ~AcceptorThread( )
122cdf0e10cSrcweir {
123cdf0e10cSrcweir if ( isRunning( ) )
124cdf0e10cSrcweir {
125cdf0e10cSrcweir asAcceptorSocket.shutdown();
126*63d99982SDamjan Jovanovic printf("# error: Acceptor thread not terminated.\n" );
127cdf0e10cSrcweir }
128cdf0e10cSrcweir }
129cdf0e10cSrcweir };
130cdf0e10cSrcweir
131cdf0e10cSrcweir /** Server Socket Thread, served as a temp little server to communicate with client.
132cdf0e10cSrcweir */
133cdf0e10cSrcweir class ServerSocketThread : public Thread
134cdf0e10cSrcweir {
135cdf0e10cSrcweir osl::Condition &m_aCondition;
136cdf0e10cSrcweir protected:
137cdf0e10cSrcweir oslThreadIdentifier m_id;
138cdf0e10cSrcweir
run()139cdf0e10cSrcweir void SAL_CALL run( )
140cdf0e10cSrcweir {
141cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
142cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 );
143cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
144cdf0e10cSrcweir
145cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
146cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //integer not sal_Bool : sal_True);
147cdf0e10cSrcweir while ( schedule( ) == sal_True )
148cdf0e10cSrcweir {
149cdf0e10cSrcweir sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
150cdf0e10cSrcweir if ( sal_True != bOK1 )
151cdf0e10cSrcweir {
152*63d99982SDamjan Jovanovic printf("# ServerSocketThread: AcceptorSocket bind address failed.\n" ) ;
153cdf0e10cSrcweir break;
154cdf0e10cSrcweir }
155cdf0e10cSrcweir sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
156cdf0e10cSrcweir if ( sal_True != bOK2 )
157cdf0e10cSrcweir {
158*63d99982SDamjan Jovanovic printf("# ServerSocketThread: AcceptorSocket listen address failed.\n" ) ;
159cdf0e10cSrcweir break;
160cdf0e10cSrcweir }
161cdf0e10cSrcweir
162cdf0e10cSrcweir asAcceptorSocket.enableNonBlockingMode( sal_False );
163cdf0e10cSrcweir m_aCondition.set();
164cdf0e10cSrcweir
165cdf0e10cSrcweir oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
166cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
167cdf0e10cSrcweir {
168*63d99982SDamjan Jovanovic printf("ServerSocketThread: acceptConnection failed! \n");
169cdf0e10cSrcweir break;
170cdf0e10cSrcweir }
171cdf0e10cSrcweir sal_Int32 nReadNumber1 = ssStreamConnection.recv( pReadBuffer, 11 );
172cdf0e10cSrcweir sal_Int32 nReadNumber2 = ssStreamConnection.recv( pReadBuffer + nReadNumber1, 11 );
173cdf0e10cSrcweir pReadBuffer[nReadNumber1 + nReadNumber2] = '\0';
174*63d99982SDamjan Jovanovic //printf("# read buffer content: %s\n", pReadBuffer );
175cdf0e10cSrcweir break;
176cdf0e10cSrcweir }
177cdf0e10cSrcweir ssStreamConnection.close();
178cdf0e10cSrcweir asAcceptorSocket.close();
179cdf0e10cSrcweir
180cdf0e10cSrcweir }
181cdf0e10cSrcweir
onTerminated()182cdf0e10cSrcweir void SAL_CALL onTerminated( )
183cdf0e10cSrcweir {
184*63d99982SDamjan Jovanovic //printf("# normally terminate this server thread %d!\n", m_id );
185cdf0e10cSrcweir }
186cdf0e10cSrcweir
187cdf0e10cSrcweir public:
188cdf0e10cSrcweir // public to check if data transmition is OK
189cdf0e10cSrcweir sal_Char pReadBuffer[30];
ServerSocketThread(osl::Condition & _aCond)190cdf0e10cSrcweir ServerSocketThread( osl::Condition &_aCond ):m_aCondition(_aCond)
191cdf0e10cSrcweir {
192cdf0e10cSrcweir m_aCondition.reset();
193*63d99982SDamjan Jovanovic printf("#init ServerSocketThread\n");
194cdf0e10cSrcweir m_id = getIdentifier( );
195*63d99982SDamjan Jovanovic //printf("# successfully creat this ServerSocketThread %d!\n", m_id );
196cdf0e10cSrcweir }
197cdf0e10cSrcweir
~ServerSocketThread()198cdf0e10cSrcweir ~ServerSocketThread( )
199cdf0e10cSrcweir {
200cdf0e10cSrcweir if ( isRunning( ) )
201*63d99982SDamjan Jovanovic printf("# error: ServerSocketThread has not terminated.\n" );
202cdf0e10cSrcweir }
203cdf0e10cSrcweir };
204cdf0e10cSrcweir
205cdf0e10cSrcweir /** Client Socket Thread, served as a temp little client to communicate with server.
206cdf0e10cSrcweir */
207cdf0e10cSrcweir class ClientSocketThread : public Thread
208cdf0e10cSrcweir {
209cdf0e10cSrcweir protected:
210cdf0e10cSrcweir osl::Condition &m_aCondition;
211cdf0e10cSrcweir oslThreadIdentifier m_id;
212cdf0e10cSrcweir ::osl::SocketAddr m_saTargetSocketAddr;
213cdf0e10cSrcweir ::osl::ConnectorSocket m_csConnectorSocket;
214cdf0e10cSrcweir
run()215cdf0e10cSrcweir void SAL_CALL run( )
216cdf0e10cSrcweir {
217cdf0e10cSrcweir TimeValue *pTimeout;
218cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
219cdf0e10cSrcweir pTimeout->Seconds = 5;
220cdf0e10cSrcweir pTimeout->Nanosec = 0;
221cdf0e10cSrcweir
222cdf0e10cSrcweir /// if the thread should terminate, schedule return false
223cdf0e10cSrcweir //while ( schedule( ) == sal_True )
224cdf0e10cSrcweir //{
225cdf0e10cSrcweir if ( osl::Condition::result_ok != m_aCondition.wait( pTimeout ) )
226cdf0e10cSrcweir {
227cdf0e10cSrcweir free( pTimeout );
228cdf0e10cSrcweir return;
229cdf0e10cSrcweir }
230cdf0e10cSrcweir
231cdf0e10cSrcweir if ( osl_Socket_Ok == m_csConnectorSocket.connect( m_saTargetSocketAddr, pTimeout ))
232cdf0e10cSrcweir {
233cdf0e10cSrcweir m_csConnectorSocket.send( pTestString1, 11 ); // "test socket"
234cdf0e10cSrcweir m_csConnectorSocket.send( pTestString2, 10);
235cdf0e10cSrcweir }
236cdf0e10cSrcweir else
237*63d99982SDamjan Jovanovic printf("# ClientSocketThread: connect failed! \n");
238cdf0e10cSrcweir // terminate();
239cdf0e10cSrcweir //}
240cdf0e10cSrcweir m_csConnectorSocket.close();
241cdf0e10cSrcweir free( pTimeout );
242cdf0e10cSrcweir }
243cdf0e10cSrcweir
onTerminated()244cdf0e10cSrcweir void SAL_CALL onTerminated( )
245cdf0e10cSrcweir {
246*63d99982SDamjan Jovanovic //printf("# normally terminate this thread %d!\n", m_id );
247cdf0e10cSrcweir }
248cdf0e10cSrcweir
249cdf0e10cSrcweir public:
ClientSocketThread(osl::Condition & _aCond)250cdf0e10cSrcweir ClientSocketThread( osl::Condition &_aCond ):
251cdf0e10cSrcweir m_aCondition(_aCond),
252cdf0e10cSrcweir m_saTargetSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 ),
253cdf0e10cSrcweir m_csConnectorSocket( )
254cdf0e10cSrcweir {
255cdf0e10cSrcweir m_id = getIdentifier( );
256*63d99982SDamjan Jovanovic //printf("# successfully creat this client thread %d!\n", m_id );
257cdf0e10cSrcweir }
258cdf0e10cSrcweir
~ClientSocketThread()259cdf0e10cSrcweir ~ClientSocketThread( )
260cdf0e10cSrcweir {
261cdf0e10cSrcweir if ( isRunning( ) )
262*63d99982SDamjan Jovanovic printf("# error: client thread not terminated.\n" );
263cdf0e10cSrcweir }
264cdf0e10cSrcweir
265cdf0e10cSrcweir };
266cdf0e10cSrcweir
267cdf0e10cSrcweir // -----------------------------------------------------------------------------
268cdf0e10cSrcweir // Helper functions, to create buffers, check buffers
269cdf0e10cSrcweir class ValueCheckProvider
270cdf0e10cSrcweir {
271cdf0e10cSrcweir bool m_bFoundFailure;
272cdf0e10cSrcweir char *m_pBuffer;
273cdf0e10cSrcweir sal_Int32 m_nBufferSize;
274cdf0e10cSrcweir
275cdf0e10cSrcweir public:
ValueCheckProvider()276cdf0e10cSrcweir ValueCheckProvider()
277cdf0e10cSrcweir :m_bFoundFailure(false),
278cdf0e10cSrcweir m_pBuffer(NULL),
279cdf0e10cSrcweir m_nBufferSize(0)
280cdf0e10cSrcweir {
281cdf0e10cSrcweir }
282cdf0e10cSrcweir
isFailure()283cdf0e10cSrcweir bool isFailure() {return m_bFoundFailure;}
284cdf0e10cSrcweir
getBuffer()285cdf0e10cSrcweir const char* getBuffer() {return m_pBuffer;}
getWriteBuffer()286cdf0e10cSrcweir char* getWriteBuffer() {return m_pBuffer;}
287cdf0e10cSrcweir
getBufferSize()288cdf0e10cSrcweir sal_Int32 getBufferSize() {return m_nBufferSize;}
289cdf0e10cSrcweir
checkValues(sal_Int32 _nLength,int _nValue)290cdf0e10cSrcweir bool checkValues(sal_Int32 _nLength, int _nValue)
291cdf0e10cSrcweir {
292cdf0e10cSrcweir m_bFoundFailure = false;
293cdf0e10cSrcweir for(sal_Int32 i=0;i<_nLength;i++)
294cdf0e10cSrcweir {
295cdf0e10cSrcweir if (m_pBuffer[i] != _nValue)
296cdf0e10cSrcweir {
297cdf0e10cSrcweir m_bFoundFailure = true;
298cdf0e10cSrcweir }
299cdf0e10cSrcweir }
300cdf0e10cSrcweir return m_bFoundFailure;
301cdf0e10cSrcweir }
302cdf0e10cSrcweir
createBuffer(sal_Int32 _nLength,int _nValue)303cdf0e10cSrcweir void createBuffer(sal_Int32 _nLength, int _nValue)
304cdf0e10cSrcweir {
305cdf0e10cSrcweir m_nBufferSize = _nLength;
306cdf0e10cSrcweir m_pBuffer = (char*) malloc(m_nBufferSize);
307cdf0e10cSrcweir if (m_pBuffer)
308cdf0e10cSrcweir {
309cdf0e10cSrcweir memset(m_pBuffer, _nValue, m_nBufferSize);
310cdf0e10cSrcweir }
311cdf0e10cSrcweir }
312cdf0e10cSrcweir
freeBuffer()313cdf0e10cSrcweir void freeBuffer()
314cdf0e10cSrcweir {
315cdf0e10cSrcweir if (m_pBuffer) free(m_pBuffer);
316cdf0e10cSrcweir }
317cdf0e10cSrcweir
318cdf0e10cSrcweir };
319cdf0e10cSrcweir
320cdf0e10cSrcweir // -----------------------------------------------------------------------------
321cdf0e10cSrcweir /** Client Socket Thread, served as a temp little client to communicate with server.
322cdf0e10cSrcweir */
323cdf0e10cSrcweir
324cdf0e10cSrcweir class ReadSocketThread : public Thread
325cdf0e10cSrcweir {
326cdf0e10cSrcweir ValueCheckProvider m_aValues;
327cdf0e10cSrcweir int m_nValue;
328cdf0e10cSrcweir osl::Condition &m_aCondition;
329cdf0e10cSrcweir
330cdf0e10cSrcweir protected:
331cdf0e10cSrcweir oslThreadIdentifier m_id;
332cdf0e10cSrcweir
run()333cdf0e10cSrcweir void SAL_CALL run( )
334cdf0e10cSrcweir {
335cdf0e10cSrcweir ::osl::SocketAddr m_aTargetSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT10 );
336cdf0e10cSrcweir ::osl::ConnectorSocket m_aConnectorSocket;
337cdf0e10cSrcweir
338cdf0e10cSrcweir if (! m_aTargetSocketAddr.is())
339cdf0e10cSrcweir {
340*63d99982SDamjan Jovanovic printf("# SocketAddr was NOT created successfully!\n");
341cdf0e10cSrcweir }
342cdf0e10cSrcweir else
343cdf0e10cSrcweir {
344*63d99982SDamjan Jovanovic printf("start ReadSocketThread\n");
345cdf0e10cSrcweir
346cdf0e10cSrcweir TimeValue *pTimeout;
347cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
348cdf0e10cSrcweir pTimeout->Seconds = 5;
349cdf0e10cSrcweir pTimeout->Nanosec = 0;
350cdf0e10cSrcweir
351cdf0e10cSrcweir m_aCondition.wait();
352cdf0e10cSrcweir
353*63d99982SDamjan Jovanovic printf("connect()\n");
354cdf0e10cSrcweir
355cdf0e10cSrcweir oslSocketResult eResult = m_aConnectorSocket.connect( m_aTargetSocketAddr, pTimeout );
356cdf0e10cSrcweir if ( osl_Socket_Ok == eResult )
357cdf0e10cSrcweir {
358cdf0e10cSrcweir sal_Int32 nReadCount = m_aConnectorSocket.read( m_aValues.getWriteBuffer(), m_aValues.getBufferSize() );
359cdf0e10cSrcweir m_aValues.checkValues(nReadCount, m_nValue);
360cdf0e10cSrcweir }
361cdf0e10cSrcweir else
362cdf0e10cSrcweir {
363*63d99982SDamjan Jovanovic printf("# ReadSocketThread: connect failed! \n");
364cdf0e10cSrcweir printSocketResult(eResult);
365cdf0e10cSrcweir }
366cdf0e10cSrcweir
367cdf0e10cSrcweir //remove this line for deadlock on solaris( margritte.germany )
368cdf0e10cSrcweir m_aConnectorSocket.close();
369cdf0e10cSrcweir free( pTimeout );
370cdf0e10cSrcweir }
371cdf0e10cSrcweir }
372cdf0e10cSrcweir
onTerminated()373cdf0e10cSrcweir void SAL_CALL onTerminated( )
374cdf0e10cSrcweir {
375*63d99982SDamjan Jovanovic //printf("# normally terminate this thread %d!\n", m_id );
376cdf0e10cSrcweir }
377cdf0e10cSrcweir
378cdf0e10cSrcweir public:
getCount()379cdf0e10cSrcweir sal_Int32 getCount() {return m_aValues.getBufferSize();}
isOk()380cdf0e10cSrcweir bool isOk() {return m_aValues.isFailure() == true ? false : true;}
381cdf0e10cSrcweir
ReadSocketThread(sal_Int32 _nBufferSize,int _nValue,osl::Condition & _aCond)382cdf0e10cSrcweir ReadSocketThread(sal_Int32 _nBufferSize, int _nValue, osl::Condition &_aCond )
383cdf0e10cSrcweir : m_nValue( _nValue ),
384cdf0e10cSrcweir m_aCondition(_aCond)
385cdf0e10cSrcweir {
386*63d99982SDamjan Jovanovic printf("#init ReadSocketThread\n");
387cdf0e10cSrcweir m_id = getIdentifier( );
388cdf0e10cSrcweir
389*63d99982SDamjan Jovanovic //printf("# successfully creat this client thread %d!\n", m_id );
390cdf0e10cSrcweir m_aValues.createBuffer(_nBufferSize, 0);
391cdf0e10cSrcweir }
392cdf0e10cSrcweir
~ReadSocketThread()393cdf0e10cSrcweir ~ReadSocketThread( )
394cdf0e10cSrcweir {
395cdf0e10cSrcweir if ( isRunning( ) )
396*63d99982SDamjan Jovanovic printf("# error: client thread not terminated.\n" );
397cdf0e10cSrcweir m_aValues.freeBuffer();
398cdf0e10cSrcweir }
399cdf0e10cSrcweir
400cdf0e10cSrcweir };
401cdf0e10cSrcweir
402cdf0e10cSrcweir /** Server Socket Thread, write a file which is large
403cdf0e10cSrcweir */
404cdf0e10cSrcweir class WriteSocketThread : public Thread
405cdf0e10cSrcweir {
406cdf0e10cSrcweir ValueCheckProvider m_aValues;
407cdf0e10cSrcweir osl::Condition &m_aCondition;
408cdf0e10cSrcweir
409cdf0e10cSrcweir protected:
410cdf0e10cSrcweir oslThreadIdentifier m_id;
411cdf0e10cSrcweir
run()412cdf0e10cSrcweir void SAL_CALL run( )
413cdf0e10cSrcweir {
414*63d99982SDamjan Jovanovic printf("start WriteSocketThread\n");
415cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
416cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT10 );
417cdf0e10cSrcweir if (! saLocalSocketAddr.is())
418cdf0e10cSrcweir {
419*63d99982SDamjan Jovanovic printf("LocalSocketAddr was NOT created successfully!\n");
420cdf0e10cSrcweir }
421cdf0e10cSrcweir
422cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
423cdf0e10cSrcweir
424cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
425cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
426cdf0e10cSrcweir
427cdf0e10cSrcweir /// if the thread should terminate, schedule return false
428cdf0e10cSrcweir // while ( schedule( ) == sal_True )
429cdf0e10cSrcweir // {
430*63d99982SDamjan Jovanovic printf("bind()\n");
431cdf0e10cSrcweir sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
432cdf0e10cSrcweir if ( sal_True != bOK1 )
433cdf0e10cSrcweir {
434*63d99982SDamjan Jovanovic printf("# WriteSocketThread: AcceptorSocket bind address failed. \n" ) ;
435cdf0e10cSrcweir }
436cdf0e10cSrcweir else
437cdf0e10cSrcweir {
438*63d99982SDamjan Jovanovic printf("listen()\n");
439cdf0e10cSrcweir sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
440cdf0e10cSrcweir if ( sal_True != bOK2 )
441cdf0e10cSrcweir {
442*63d99982SDamjan Jovanovic printf("# WriteSocketThread: AcceptorSocket listen address failed. \n" ) ;
443cdf0e10cSrcweir }
444cdf0e10cSrcweir else
445cdf0e10cSrcweir {
446cdf0e10cSrcweir
447cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
448cdf0e10cSrcweir asAcceptorSocket.enableNonBlockingMode( sal_False);
449*63d99982SDamjan Jovanovic printf("acceptConnection()\n");
450cdf0e10cSrcweir m_aCondition.set();
451cdf0e10cSrcweir
452cdf0e10cSrcweir oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
453cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
454cdf0e10cSrcweir {
455*63d99982SDamjan Jovanovic printf("WriteSocketThread: acceptConnection failed! \n");
456cdf0e10cSrcweir }
457cdf0e10cSrcweir else
458cdf0e10cSrcweir {
459cdf0e10cSrcweir
460cdf0e10cSrcweir // LLA: removed, due to the fact, this is to error prone
461cdf0e10cSrcweir // LLA: char * pSrcRoot = getenv("SOURCE_ROOT");
462cdf0e10cSrcweir // LLA: // LLA: This is absolute wrong!
463cdf0e10cSrcweir // LLA: // strcat( pSrcRoot, "/sal/inc/osl/file.hxx");
464cdf0e10cSrcweir // LLA: rtl::OString sSrcRoot(pSrcRoot);
465cdf0e10cSrcweir // LLA: sSrcRoot += "/sal/inc/osl/file.hxx";
466cdf0e10cSrcweir // LLA:
467cdf0e10cSrcweir // LLA: ::rtl::OUString sFilePath = ::rtl::OUString::createFromAscii( sSrcRoot.getStr() );
468cdf0e10cSrcweir // LLA: #ifdef WNT
469cdf0e10cSrcweir // LLA: while (sFilePath.lastIndexOf('/') != -1)
470cdf0e10cSrcweir // LLA: sFilePath = sFilePath.replace('/',(sal_Unicode)'\\');
471cdf0e10cSrcweir // LLA: #endif
472cdf0e10cSrcweir // LLA: FILE *stream;
473cdf0e10cSrcweir // LLA: sal_uInt64 nCount_read;
474cdf0e10cSrcweir // LLA: sal_Char buffer_read[FILE_READ];
475cdf0e10cSrcweir // LLA:
476cdf0e10cSrcweir // LLA: if( (stream = fopen( oustring2char( sFilePath ), "r+t" )) != NULL )
477cdf0e10cSrcweir // LLA: {
478cdf0e10cSrcweir // LLA: /* Attempt to read in 25 characters */
479cdf0e10cSrcweir // LLA: nCount_read = fread( buffer_read, sizeof( char ), FILE_READ, stream );
480cdf0e10cSrcweir // LLA: fclose( stream );
481cdf0e10cSrcweir // LLA: }
482cdf0e10cSrcweir // LLA: else
483*63d99982SDamjan Jovanovic // LLA: printf("# File $SRC_ROOT/sal/inc/osl/file.hxx could not be opened\n" );
484cdf0e10cSrcweir
485*63d99982SDamjan Jovanovic printf("write()\n");
486cdf0e10cSrcweir
487cdf0e10cSrcweir ssStreamConnection.write( m_aValues.getBuffer(), m_aValues.getBufferSize() );
488*63d99982SDamjan Jovanovic printf("done written.\n");
489cdf0e10cSrcweir }
490cdf0e10cSrcweir }
491cdf0e10cSrcweir }
492cdf0e10cSrcweir ssStreamConnection.close();
493cdf0e10cSrcweir asAcceptorSocket.close();
494cdf0e10cSrcweir }
495cdf0e10cSrcweir
onTerminated()496cdf0e10cSrcweir void SAL_CALL onTerminated( )
497cdf0e10cSrcweir {
498*63d99982SDamjan Jovanovic //printf("# normally terminate this server thread %d!\n", m_id );
499cdf0e10cSrcweir }
500cdf0e10cSrcweir
501cdf0e10cSrcweir public:
502cdf0e10cSrcweir // public to check if data transmition is OK
WriteSocketThread(sal_Int32 _nBufferSize,int _nValue,osl::Condition & _aCond)503cdf0e10cSrcweir WriteSocketThread(sal_Int32 _nBufferSize, int _nValue, osl::Condition &_aCond )
504cdf0e10cSrcweir : m_aCondition(_aCond)
505cdf0e10cSrcweir {
506cdf0e10cSrcweir m_aCondition.reset();
507cdf0e10cSrcweir
508*63d99982SDamjan Jovanovic printf("#init WriteSocketThread\n");
509cdf0e10cSrcweir m_id = getIdentifier( );
510*63d99982SDamjan Jovanovic //printf("# successfully creat this server thread %d!\n", m_id );
511cdf0e10cSrcweir
512cdf0e10cSrcweir m_aValues.createBuffer(_nBufferSize, _nValue);
513cdf0e10cSrcweir }
514cdf0e10cSrcweir
~WriteSocketThread()515cdf0e10cSrcweir ~WriteSocketThread( )
516cdf0e10cSrcweir {
517cdf0e10cSrcweir if ( isRunning( ) )
518*63d99982SDamjan Jovanovic printf("# error: server thread not terminated.\n" );
519cdf0e10cSrcweir m_aValues.freeBuffer();
520cdf0e10cSrcweir }
521cdf0e10cSrcweir };
522cdf0e10cSrcweir
523cdf0e10cSrcweir // -----------------------------------------------------------------------------
524cdf0e10cSrcweir
525cdf0e10cSrcweir namespace osl_StreamSocket
526cdf0e10cSrcweir {
527cdf0e10cSrcweir
528cdf0e10cSrcweir /** testing the methods:
529cdf0e10cSrcweir inline StreamSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
530cdf0e10cSrcweir oslProtocol Protocol = osl_Socket_ProtocolIp,
531cdf0e10cSrcweir oslSocketType Type = osl_Socket_TypeStream);
532cdf0e10cSrcweir
533cdf0e10cSrcweir inline StreamSocket( const StreamSocket & );
534cdf0e10cSrcweir
535cdf0e10cSrcweir inline StreamSocket( oslSocket Socket , __sal_NoAcquire noacquire );
536cdf0e10cSrcweir
537cdf0e10cSrcweir inline StreamSocket( oslSocket Socket );
538cdf0e10cSrcweir */
539cdf0e10cSrcweir
540*63d99982SDamjan Jovanovic class ctors : public ::testing::Test
541cdf0e10cSrcweir {
542cdf0e10cSrcweir public:
543cdf0e10cSrcweir oslSocket sHandle;
544cdf0e10cSrcweir // initialization
SetUp()545*63d99982SDamjan Jovanovic void SetUp( )
546cdf0e10cSrcweir {
547cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
548cdf0e10cSrcweir }
549cdf0e10cSrcweir
TearDown()550*63d99982SDamjan Jovanovic void TearDown( )
551cdf0e10cSrcweir {
552cdf0e10cSrcweir sHandle = NULL;
553cdf0e10cSrcweir }
554*63d99982SDamjan Jovanovic }; // class ctors
555cdf0e10cSrcweir
TEST_F(ctors,ctors_none)556*63d99982SDamjan Jovanovic TEST_F(ctors, ctors_none)
557*63d99982SDamjan Jovanovic {
558*63d99982SDamjan Jovanovic /// Socket constructor.
559*63d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
560cdf0e10cSrcweir
561*63d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == ssSocket.getType( )) << "test for ctors_none constructor function: check if the stream socket was created successfully.";
562*63d99982SDamjan Jovanovic }
563cdf0e10cSrcweir
TEST_F(ctors,ctors_acquire)564*63d99982SDamjan Jovanovic TEST_F(ctors, ctors_acquire)
565*63d99982SDamjan Jovanovic {
566*63d99982SDamjan Jovanovic /// Socket constructor.
567*63d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( sHandle );
568cdf0e10cSrcweir
569*63d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == ssSocket.getType( )) << "test for ctors_acquire constructor function: check if the socket was created successfully";
570*63d99982SDamjan Jovanovic }
571cdf0e10cSrcweir
TEST_F(ctors,ctors_no_acquire)572*63d99982SDamjan Jovanovic TEST_F(ctors, ctors_no_acquire)
573*63d99982SDamjan Jovanovic {
574*63d99982SDamjan Jovanovic /// Socket constructor.
575*63d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( sHandle, SAL_NO_ACQUIRE );
576cdf0e10cSrcweir
577*63d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == ssSocket.getType( )) << " test for ctors_no_acquire constructor function: check if the socket was created successfully";
578*63d99982SDamjan Jovanovic }
579cdf0e10cSrcweir
TEST_F(ctors,ctors_copy_ctor)580*63d99982SDamjan Jovanovic TEST_F(ctors, ctors_copy_ctor)
581*63d99982SDamjan Jovanovic {
582*63d99982SDamjan Jovanovic /// Socket constructor.
583*63d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
584*63d99982SDamjan Jovanovic /// Socket copy constructor.
585*63d99982SDamjan Jovanovic ::osl::StreamSocket copySocket( ssSocket );
586cdf0e10cSrcweir
587*63d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == copySocket.getType( )) << " test for ctors_copy_ctor constructor function: create new Socket instance using copy constructor";
588*63d99982SDamjan Jovanovic }
589cdf0e10cSrcweir
590*63d99982SDamjan Jovanovic class send_recv: public ::testing::Test
591cdf0e10cSrcweir {
592cdf0e10cSrcweir public:
593cdf0e10cSrcweir // initialization
SetUp()594*63d99982SDamjan Jovanovic void SetUp( )
595cdf0e10cSrcweir {
596cdf0e10cSrcweir }
597cdf0e10cSrcweir
TearDown()598*63d99982SDamjan Jovanovic void TearDown( )
599cdf0e10cSrcweir {
600cdf0e10cSrcweir
601cdf0e10cSrcweir }
602cdf0e10cSrcweir
603cdf0e10cSrcweir // LLA: This is a helper function, which create 2 threads, a server and a client.
604cdf0e10cSrcweir // the server writes the buffersize to the client.
605cdf0e10cSrcweir
write_read(sal_Int32 _nBufferSize,int _nValue)606cdf0e10cSrcweir void write_read(sal_Int32 _nBufferSize, int _nValue)
607cdf0e10cSrcweir {
608cdf0e10cSrcweir //client sent two strings, and server received, check the order and value
609cdf0e10cSrcweir osl::Condition aCondition;
610cdf0e10cSrcweir WriteSocketThread myServerThread(_nBufferSize, _nValue, aCondition);
611cdf0e10cSrcweir ReadSocketThread myClientThread(_nBufferSize, _nValue, aCondition);
612cdf0e10cSrcweir myServerThread.create( );
613cdf0e10cSrcweir // thread_sleep( 1 );
614cdf0e10cSrcweir myClientThread.create( );
615cdf0e10cSrcweir
616cdf0e10cSrcweir //wait until the thread terminate
617cdf0e10cSrcweir myClientThread.join( );
618cdf0e10cSrcweir myServerThread.join( );
619cdf0e10cSrcweir
620cdf0e10cSrcweir //Maximum Packet Size is ( ARPANET, MILNET = 1007 Ethernet (10Mb) = 1500
621cdf0e10cSrcweir // Proteon PRONET = 2046), so here test read 4000 bytes
622cdf0e10cSrcweir sal_Int32 nLength = myClientThread.getCount();
623cdf0e10cSrcweir bool bIsOk = myClientThread.isOk(); // check if the values are right.
624cdf0e10cSrcweir
625*63d99982SDamjan Jovanovic printf("Length:=%d\n", nLength);
626*63d99982SDamjan Jovanovic printf(" bIsOk:=%d\n", bIsOk);
627cdf0e10cSrcweir
628*63d99982SDamjan Jovanovic ASSERT_TRUE(nLength == _nBufferSize && bIsOk == true) << " test for write/read values with two threads: send data from server, check readed data in client.";
629cdf0e10cSrcweir }
630*63d99982SDamjan Jovanovic }; // class send_recv
631cdf0e10cSrcweir
TEST_F(send_recv,send_recv1)632*63d99982SDamjan Jovanovic TEST_F(send_recv, send_recv1)
633*63d99982SDamjan Jovanovic {
634*63d99982SDamjan Jovanovic osl::Condition aCondition;
635*63d99982SDamjan Jovanovic //client sent two strings, and server received, check the order and value
636*63d99982SDamjan Jovanovic ServerSocketThread myServerThread( aCondition );
637*63d99982SDamjan Jovanovic ClientSocketThread myClientThread( aCondition );
638*63d99982SDamjan Jovanovic myServerThread.create( );
639*63d99982SDamjan Jovanovic myClientThread.create( );
640*63d99982SDamjan Jovanovic
641*63d99982SDamjan Jovanovic //wait until the thread terminate
642*63d99982SDamjan Jovanovic myClientThread.join( );
643*63d99982SDamjan Jovanovic myServerThread.join( );
644*63d99982SDamjan Jovanovic sal_Char myStr[30] = "";
645*63d99982SDamjan Jovanovic strcat( myStr, pTestString1 );
646*63d99982SDamjan Jovanovic strcat( myStr, pTestString2 );
647*63d99982SDamjan Jovanovic sal_Int32 nRes = strcmp( myServerThread.pReadBuffer, myStr );
648*63d99982SDamjan Jovanovic ASSERT_TRUE(nRes == 0) << " test for send/recv with two threads: launch Server/Client threads, send data from client, check received data in Server thread.";
649*63d99982SDamjan Jovanovic }
650cdf0e10cSrcweir
651*63d99982SDamjan Jovanovic // error when recv
TEST_F(send_recv,send_recv2)652*63d99982SDamjan Jovanovic TEST_F(send_recv, send_recv2)
653*63d99982SDamjan Jovanovic {
654*63d99982SDamjan Jovanovic ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
655*63d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 );
656*63d99982SDamjan Jovanovic ::osl::StreamSocket ssStreamConnection;
657*63d99982SDamjan Jovanovic sal_Char pReadBuffer[30] = "";
658*63d99982SDamjan Jovanovic
659*63d99982SDamjan Jovanovic osl::Condition aCondition;
660*63d99982SDamjan Jovanovic aCondition.reset();
661*63d99982SDamjan Jovanovic ClientSocketThread myClientThread( aCondition );
662*63d99982SDamjan Jovanovic myClientThread.create( );
663*63d99982SDamjan Jovanovic
664*63d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
665*63d99982SDamjan Jovanovic
666*63d99982SDamjan Jovanovic asAcceptorSocket.bind( saLocalSocketAddr );
667*63d99982SDamjan Jovanovic asAcceptorSocket.listen( 1 );
668*63d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
669*63d99982SDamjan Jovanovic aCondition.set();
670*63d99982SDamjan Jovanovic
671*63d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection( ssStreamConnection );
672*63d99982SDamjan Jovanovic sal_Int32 nReadNumber = ssStreamConnection.recv( pReadBuffer, 11 );
673*63d99982SDamjan Jovanovic
674*63d99982SDamjan Jovanovic myClientThread.join( ) ;
675*63d99982SDamjan Jovanovic ssStreamConnection.close();
676*63d99982SDamjan Jovanovic asAcceptorSocket.close();
677*63d99982SDamjan Jovanovic ASSERT_TRUE(nReadNumber == -1) << " test for send/recv, recv error!";
678*63d99982SDamjan Jovanovic }
679*63d99982SDamjan Jovanovic
680*63d99982SDamjan Jovanovic // Tests with different values and sizes
TEST_F(send_recv,write_read_001)681*63d99982SDamjan Jovanovic TEST_F(send_recv, write_read_001)
682*63d99982SDamjan Jovanovic {
683*63d99982SDamjan Jovanovic write_read(50, 10);
684*63d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_002)685*63d99982SDamjan Jovanovic TEST_F(send_recv, write_read_002)
686*63d99982SDamjan Jovanovic {
687*63d99982SDamjan Jovanovic write_read(1024, 20);
688*63d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_003)689*63d99982SDamjan Jovanovic TEST_F(send_recv, write_read_003)
690*63d99982SDamjan Jovanovic {
691*63d99982SDamjan Jovanovic write_read(4000, 1);
692*63d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_004)693*63d99982SDamjan Jovanovic TEST_F(send_recv, write_read_004)
694*63d99982SDamjan Jovanovic {
695*63d99982SDamjan Jovanovic write_read(8192, 3);
696*63d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_005)697*63d99982SDamjan Jovanovic TEST_F(send_recv, write_read_005)
698*63d99982SDamjan Jovanovic {
699*63d99982SDamjan Jovanovic write_read(32768, 3);
700*63d99982SDamjan Jovanovic }
701cdf0e10cSrcweir
702cdf0e10cSrcweir // -----------------------------------------------------------------------------
703cdf0e10cSrcweir
704cdf0e10cSrcweir class SendClientThread : public Thread
705cdf0e10cSrcweir {
706cdf0e10cSrcweir protected:
707cdf0e10cSrcweir ::osl::SocketAddr m_saTargetSocketAddr;
708cdf0e10cSrcweir ::osl::ConnectorSocket m_csConnectorSocket;
run()709cdf0e10cSrcweir void SAL_CALL run( )
710cdf0e10cSrcweir {
711cdf0e10cSrcweir TimeValue *pTimeout;
712cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
713cdf0e10cSrcweir pTimeout->Seconds = 5;
714cdf0e10cSrcweir pTimeout->Nanosec = 0;
715cdf0e10cSrcweir
716cdf0e10cSrcweir if ( osl_Socket_Ok == m_csConnectorSocket.connect( m_saTargetSocketAddr, pTimeout ))
717cdf0e10cSrcweir {
718cdf0e10cSrcweir sal_Int32 nWrite1 = m_csConnectorSocket.write( pTestString1, 11 ); // "test socket"
719cdf0e10cSrcweir
720cdf0e10cSrcweir sal_Int32 nWrite2 = m_csConnectorSocket.write( pTestString2, strlen( pTestString2 ) + 1 );
721cdf0e10cSrcweir thread_sleep( 2 );
722cdf0e10cSrcweir m_csConnectorSocket.write( pTestString2, strlen( pTestString2 ) + 1 );
723*63d99982SDamjan Jovanovic printf("nWrite1 is %d, nWrite2 is %d\n", nWrite1, nWrite2 );
724cdf0e10cSrcweir //thread_sleep( 1 );
725cdf0e10cSrcweir }
726cdf0e10cSrcweir else
727*63d99982SDamjan Jovanovic printf("# SendClientThread: connect failed! \n");
728cdf0e10cSrcweir
729cdf0e10cSrcweir m_csConnectorSocket.close();
730cdf0e10cSrcweir free( pTimeout );
731cdf0e10cSrcweir }
732cdf0e10cSrcweir public:
SendClientThread()733cdf0e10cSrcweir SendClientThread( ):
734cdf0e10cSrcweir m_saTargetSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 ),
735cdf0e10cSrcweir m_csConnectorSocket( )
736cdf0e10cSrcweir {
737*63d99982SDamjan Jovanovic //printf("# successfully creat this SendClientThread %d!\n", m_id );
738cdf0e10cSrcweir }
739cdf0e10cSrcweir
~SendClientThread()740cdf0e10cSrcweir ~SendClientThread( )
741cdf0e10cSrcweir {
742cdf0e10cSrcweir if ( isRunning( ) )
743*63d99982SDamjan Jovanovic printf("# error: SendClientThread has not terminated.\n" );
744cdf0e10cSrcweir }
745cdf0e10cSrcweir
746cdf0e10cSrcweir };
747cdf0e10cSrcweir
748*63d99982SDamjan Jovanovic class shutdown: public ::testing::Test
749cdf0e10cSrcweir {
750cdf0e10cSrcweir public:
751cdf0e10cSrcweir // initialization
SetUp()752*63d99982SDamjan Jovanovic void SetUp( )
753cdf0e10cSrcweir {
754cdf0e10cSrcweir }
755cdf0e10cSrcweir
TearDown()756*63d99982SDamjan Jovanovic void TearDown( )
757cdf0e10cSrcweir {
758cdf0e10cSrcweir
759cdf0e10cSrcweir }
760*63d99982SDamjan Jovanovic }; // class shutdown
761cdf0e10cSrcweir
762*63d99982SDamjan Jovanovic // similar to close_002
TEST_F(shutdown,shutdown_001)763*63d99982SDamjan Jovanovic TEST_F(shutdown, shutdown_001)
764*63d99982SDamjan Jovanovic {
765cdf0e10cSrcweir #if defined(LINUX)
766*63d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
767*63d99982SDamjan Jovanovic AcceptorThread myAcceptorThread( asSocket, rtl::OUString::createFromAscii("127.0.0.1") );
768*63d99982SDamjan Jovanovic myAcceptorThread.create();
769cdf0e10cSrcweir
770*63d99982SDamjan Jovanovic thread_sleep( 1 );
771cdf0e10cSrcweir
772*63d99982SDamjan Jovanovic //when accepting, shutdown the socket, the thread will not block for accepting
773*63d99982SDamjan Jovanovic asSocket.shutdown();
774*63d99982SDamjan Jovanovic myAcceptorThread.join();
775cdf0e10cSrcweir
776*63d99982SDamjan Jovanovic ASSERT_TRUE(myAcceptorThread.isOK( ) == sal_True) << "test for close when is accepting: the socket will quit accepting status.";
777cdf0e10cSrcweir #endif
778*63d99982SDamjan Jovanovic }
779cdf0e10cSrcweir
TEST_F(shutdown,shutdown_002)780*63d99982SDamjan Jovanovic TEST_F(shutdown, shutdown_002)
781*63d99982SDamjan Jovanovic {
782*63d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
783*63d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9);
784*63d99982SDamjan Jovanovic asSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
785*63d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.bind( saLocalSocketAddr ) == sal_True) << "shutdown_002: bind fail";
786*63d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.listen( 1 ) == sal_True) << "shutdown_002: listen fail";
787*63d99982SDamjan Jovanovic sal_Char pReadBuffer[40];
788cdf0e10cSrcweir // osl::Condition aCondition;
789*63d99982SDamjan Jovanovic SendClientThread mySendThread;
790*63d99982SDamjan Jovanovic mySendThread.create();
791*63d99982SDamjan Jovanovic
792*63d99982SDamjan Jovanovic asSocket.enableNonBlockingMode( sal_False );
793*63d99982SDamjan Jovanovic ::osl::StreamSocket ssConnectionSocket;
794*63d99982SDamjan Jovanovic oslSocketResult eResult = asSocket.acceptConnection( ssConnectionSocket );
795*63d99982SDamjan Jovanovic ASSERT_TRUE(eResult == osl_Socket_Ok) << "shutdown_002: acceptConnection fail";
796*63d99982SDamjan Jovanovic
797*63d99982SDamjan Jovanovic /* set socket option SO_LINGER 0, so close immediately */
798*63d99982SDamjan Jovanovic linger aLingerSet;
799*63d99982SDamjan Jovanovic sal_Int32 nBufferLen = sizeof( struct linger );
800*63d99982SDamjan Jovanovic aLingerSet.l_onoff = 0;
801*63d99982SDamjan Jovanovic aLingerSet.l_linger = 0;
802*63d99982SDamjan Jovanovic
803*63d99982SDamjan Jovanovic ssConnectionSocket.setOption( osl_Socket_OptionLinger, &aLingerSet, nBufferLen );
804*63d99982SDamjan Jovanovic thread_sleep( 1 );
805*63d99982SDamjan Jovanovic //sal_uInt32 nRecv1 = 0;
806*63d99982SDamjan Jovanovic sal_Int32 nRead1 = ssConnectionSocket.read( pReadBuffer, 11 );
807*63d99982SDamjan Jovanovic
808*63d99982SDamjan Jovanovic //shutdown read after client the first send complete
809*63d99982SDamjan Jovanovic ssConnectionSocket.shutdown( osl_Socket_DirRead );
810*63d99982SDamjan Jovanovic
811*63d99982SDamjan Jovanovic sal_Int32 nRead2 = ssConnectionSocket.read( pReadBuffer + nRead1, 12 );
812*63d99982SDamjan Jovanovic sal_Int32 nRead3 = ssConnectionSocket.read( pReadBuffer + nRead1 + nRead2, 12 );
813*63d99982SDamjan Jovanovic printf("after read 2, nRead1 is %d, nRead2 is %d, nRead3 is %d \n", nRead1, nRead2, nRead3 );
814*63d99982SDamjan Jovanovic mySendThread.join();
815*63d99982SDamjan Jovanovic
816*63d99982SDamjan Jovanovic ssConnectionSocket.close();
817*63d99982SDamjan Jovanovic asSocket.close();
818*63d99982SDamjan Jovanovic
819*63d99982SDamjan Jovanovic /* on Linux, if send is before shutdown(DirRead), can read, nRecv2 still > 0,
820*63d99982SDamjan Jovanovic http://dbforums.com/arch/186/2002/12/586417
821*63d99982SDamjan Jovanovic While on Solaris, after shutdown(DirRead), all read will return 0
822*63d99982SDamjan Jovanovic */
823cdf0e10cSrcweir #ifdef LINUX
824*63d99982SDamjan Jovanovic ASSERT_TRUE(nRead1 > 0 && nRead3 == 0) << "test for shutdown read direction: the socket can not read(recv).";
825cdf0e10cSrcweir #else
826*63d99982SDamjan Jovanovic ASSERT_TRUE(nRead1 > 0 && nRead2 == 0 && nRead3 == 0) << "test for shutdown read direction: the socket can not read(recv).";
827cdf0e10cSrcweir #endif
828cdf0e10cSrcweir
829*63d99982SDamjan Jovanovic }
830cdf0e10cSrcweir
TEST_F(shutdown,shutdown_003)831*63d99982SDamjan Jovanovic TEST_F(shutdown, shutdown_003)
832*63d99982SDamjan Jovanovic {
833*63d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
834*63d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9);
835*63d99982SDamjan Jovanovic asSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
836*63d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.bind( saLocalSocketAddr ) == sal_True) << "shutdown_002: bind fail";
837*63d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.listen( 1 ) == sal_True) << "shutdown_002: listen fail";
838*63d99982SDamjan Jovanovic sal_Char pReadBuffer[40];
839*63d99982SDamjan Jovanovic osl::Condition aCondition;
840*63d99982SDamjan Jovanovic SendClientThread mySendThread;
841*63d99982SDamjan Jovanovic mySendThread.create();
842*63d99982SDamjan Jovanovic
843*63d99982SDamjan Jovanovic asSocket.enableNonBlockingMode( sal_False );
844*63d99982SDamjan Jovanovic ::osl::StreamSocket ssConnectionSocket;
845*63d99982SDamjan Jovanovic oslSocketResult eResult = asSocket.acceptConnection( ssConnectionSocket );
846*63d99982SDamjan Jovanovic ASSERT_TRUE(eResult == osl_Socket_Ok) << "shutdown_002: acceptConnection fail";
847*63d99982SDamjan Jovanovic
848*63d99982SDamjan Jovanovic thread_sleep( 1 );
849*63d99982SDamjan Jovanovic //shutdown write after client the first send complete
850*63d99982SDamjan Jovanovic ssConnectionSocket.shutdown( osl_Socket_DirWrite );
851*63d99982SDamjan Jovanovic
852*63d99982SDamjan Jovanovic // recv should not shutdown
853*63d99982SDamjan Jovanovic sal_Int32 nRead1 = ssConnectionSocket.read( pReadBuffer, 11 );
854*63d99982SDamjan Jovanovic
855*63d99982SDamjan Jovanovic sal_Int32 nWrite = ssConnectionSocket.write( pReadBuffer, 11 );
856*63d99982SDamjan Jovanovic // still can read
857*63d99982SDamjan Jovanovic sal_Int32 nRead3 = ssConnectionSocket.read( pReadBuffer + nRead1 , 12 );
858*63d99982SDamjan Jovanovic printf("after read 2, nRead1 is %d, nWrite is %d, nRead3 is %d\n", nRead1, nWrite, nRead3 );
859*63d99982SDamjan Jovanovic mySendThread.join();
860*63d99982SDamjan Jovanovic ssConnectionSocket.close();
861*63d99982SDamjan Jovanovic asSocket.close();
862*63d99982SDamjan Jovanovic
863*63d99982SDamjan Jovanovic ASSERT_TRUE(nRead1 > 0 && nWrite == 0 && nRead3 > 0) << "test for shutdown read direction: the socket can not send(write).";
864cdf0e10cSrcweir
865*63d99982SDamjan Jovanovic }
866cdf0e10cSrcweir
867*63d99982SDamjan Jovanovic class isExceptionPending: public ::testing::Test
868cdf0e10cSrcweir {
869cdf0e10cSrcweir public:
870*63d99982SDamjan Jovanovic }; // class isExceptionPending
871cdf0e10cSrcweir
872*63d99982SDamjan Jovanovic /**tester's comments: lack of a case that return sal_True, do not know when it will return sal_True*/
TEST_F(isExceptionPending,isExPending_001)873*63d99982SDamjan Jovanovic TEST_F(isExceptionPending, isExPending_001)
874*63d99982SDamjan Jovanovic {
875*63d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
876*63d99982SDamjan Jovanovic TimeValue *pTimeout;
877*63d99982SDamjan Jovanovic pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
878*63d99982SDamjan Jovanovic pTimeout->Seconds = 3;
879*63d99982SDamjan Jovanovic pTimeout->Nanosec = 0;
880*63d99982SDamjan Jovanovic sal_Bool bOk = asSocket.isExceptionPending( pTimeout );
881*63d99982SDamjan Jovanovic free( pTimeout );
882cdf0e10cSrcweir
883*63d99982SDamjan Jovanovic ASSERT_TRUE(bOk == sal_False) << "test for isExceptionPending.";
884*63d99982SDamjan Jovanovic }
885cdf0e10cSrcweir
886cdf0e10cSrcweir // -----------------------------------------------------------------------------
887cdf0e10cSrcweir /** Server Socket Thread, write a file which is large
888cdf0e10cSrcweir */
889cdf0e10cSrcweir // LLA: class WriteSocketThread : public Thread
890cdf0e10cSrcweir // LLA: {
891cdf0e10cSrcweir // LLA: ValueCheckProvider m_aValues;
892cdf0e10cSrcweir // LLA:
893cdf0e10cSrcweir // LLA: protected:
894cdf0e10cSrcweir // LLA: oslThreadIdentifier m_id;
895cdf0e10cSrcweir // LLA:
896cdf0e10cSrcweir // LLA: void SAL_CALL run( )
897cdf0e10cSrcweir // LLA: {
898cdf0e10cSrcweir // LLA: ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
899cdf0e10cSrcweir // LLA: ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("10.16.66.252"), 8888 );
900cdf0e10cSrcweir // LLA: ::osl::StreamSocket ssStreamConnection;
901cdf0e10cSrcweir // LLA:
902cdf0e10cSrcweir // LLA: //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
903cdf0e10cSrcweir // LLA: asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
904cdf0e10cSrcweir // LLA:
905cdf0e10cSrcweir // LLA: /// if the thread should terminate, schedule return false
906cdf0e10cSrcweir // LLA: while ( schedule( ) == sal_True )
907cdf0e10cSrcweir // LLA: {
908cdf0e10cSrcweir // LLA: sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
909cdf0e10cSrcweir // LLA: if ( sal_True != bOK1 )
910cdf0e10cSrcweir // LLA: {
911*63d99982SDamjan Jovanovic // LLA: printf("# WriteSocketThread: AcceptorSocket bind address failed. \n" ) ;
912cdf0e10cSrcweir // LLA: break;
913cdf0e10cSrcweir // LLA: }
914cdf0e10cSrcweir // LLA: sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
915cdf0e10cSrcweir // LLA: if ( sal_True != bOK2 )
916cdf0e10cSrcweir // LLA: {
917*63d99982SDamjan Jovanovic // LLA: printf("# WriteSocketThread: AcceptorSocket listen address failed. \n" ) ;
918cdf0e10cSrcweir // LLA: break;
919cdf0e10cSrcweir // LLA: }
920cdf0e10cSrcweir // LLA: // blocking mode, if read/recv failed, block until success
921cdf0e10cSrcweir // LLA: asAcceptorSocket.enableNonBlockingMode( sal_False);
922cdf0e10cSrcweir // LLA:
923cdf0e10cSrcweir // LLA: oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
924cdf0e10cSrcweir // LLA: if (eResult != osl_Socket_Ok )
925cdf0e10cSrcweir // LLA: {
926*63d99982SDamjan Jovanovic // LLA: printf("WriteSocketThread: acceptConnection failed! \n");
927cdf0e10cSrcweir // LLA: break;
928cdf0e10cSrcweir // LLA: }
929cdf0e10cSrcweir // LLA:
930cdf0e10cSrcweir // LLA:
931cdf0e10cSrcweir // LLA: sal_Int32 nReadNumber1 = ssStreamConnection.write( m_aValues.getBuffer(), m_aValues.getBufferSize() );
932cdf0e10cSrcweir // LLA: break;
933cdf0e10cSrcweir // LLA: }
934cdf0e10cSrcweir // LLA: ssStreamConnection.close();
935cdf0e10cSrcweir // LLA: asAcceptorSocket.close();
936cdf0e10cSrcweir // LLA: }
937cdf0e10cSrcweir // LLA: }
938cdf0e10cSrcweir // -----------------------------------------------------------------------------
939cdf0e10cSrcweir // -----------------------------------------------------------------------------
940cdf0e10cSrcweir /** Client Socket Thread, served as a temp little client to communicate with server.
941cdf0e10cSrcweir */
942cdf0e10cSrcweir
943cdf0e10cSrcweir #define IP_PORT_TEST 8900
944cdf0e10cSrcweir
945cdf0e10cSrcweir class ReadSocket2Thread : public Thread
946cdf0e10cSrcweir {
947cdf0e10cSrcweir osl::Condition &m_aCondition;
948cdf0e10cSrcweir char* m_pBuffer;
949cdf0e10cSrcweir sal_Int32 m_nBufferSize;
950cdf0e10cSrcweir sal_Int32 m_nReadCount;
951cdf0e10cSrcweir rtl::OString m_sAddr;
952cdf0e10cSrcweir
953cdf0e10cSrcweir bool m_bOk;
954cdf0e10cSrcweir
setFailed()955cdf0e10cSrcweir void setFailed()
956cdf0e10cSrcweir {
957cdf0e10cSrcweir m_bOk = false;
958cdf0e10cSrcweir }
959cdf0e10cSrcweir
960cdf0e10cSrcweir protected:
961cdf0e10cSrcweir oslThreadIdentifier m_id;
962cdf0e10cSrcweir
read()963cdf0e10cSrcweir void read()
964cdf0e10cSrcweir {
965cdf0e10cSrcweir if (m_sAddr.getLength() == 0)
966cdf0e10cSrcweir {
967cdf0e10cSrcweir setFailed();
968cdf0e10cSrcweir return;
969cdf0e10cSrcweir }
970cdf0e10cSrcweir
971cdf0e10cSrcweir // 10.16.66.252
972cdf0e10cSrcweir ::osl::SocketAddr aSocketAddr( rtl::OUString::createFromAscii(m_sAddr.getStr()), IP_PORT_TEST );
973cdf0e10cSrcweir ::osl::ConnectorSocket aSocket; // ( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
974cdf0e10cSrcweir
975cdf0e10cSrcweir aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;
976cdf0e10cSrcweir
977cdf0e10cSrcweir m_aCondition.wait();
978*63d99982SDamjan Jovanovic printf("wait done\n");
979cdf0e10cSrcweir
980cdf0e10cSrcweir TimeValue *pTimeout;
981cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
982cdf0e10cSrcweir pTimeout->Seconds = 20;
983cdf0e10cSrcweir pTimeout->Nanosec = 0;
984cdf0e10cSrcweir
985cdf0e10cSrcweir
986cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
987*63d99982SDamjan Jovanovic printf("enableNonBlockingMode(false)\n");
988cdf0e10cSrcweir aSocket.enableNonBlockingMode( sal_False );
989cdf0e10cSrcweir
990cdf0e10cSrcweir
991*63d99982SDamjan Jovanovic printf("connect()\n");
992cdf0e10cSrcweir oslSocketResult eResult = aSocket.connect( aSocketAddr, pTimeout );
993cdf0e10cSrcweir if ( osl_Socket_Ok == eResult)
994cdf0e10cSrcweir {
995cdf0e10cSrcweir if (m_pBuffer)
996cdf0e10cSrcweir {
997*63d99982SDamjan Jovanovic printf("read()\n");
998cdf0e10cSrcweir m_nReadCount = aSocket.read( m_pBuffer, m_nBufferSize );
999*63d99982SDamjan Jovanovic printf("%d bytes received.\n", m_nReadCount);
1000cdf0e10cSrcweir }
1001cdf0e10cSrcweir }
1002cdf0e10cSrcweir else
1003cdf0e10cSrcweir {
1004*63d99982SDamjan Jovanovic printf("# ReadSocket2Thread: connect failed! \n");
1005cdf0e10cSrcweir printSocketResult(eResult);
1006cdf0e10cSrcweir setFailed();
1007cdf0e10cSrcweir }
1008cdf0e10cSrcweir
1009cdf0e10cSrcweir //remove this line for deadlock on solaris( margritte.germany )
1010cdf0e10cSrcweir aSocket.close();
1011cdf0e10cSrcweir free( pTimeout );
1012cdf0e10cSrcweir }
1013cdf0e10cSrcweir
run()1014cdf0e10cSrcweir void SAL_CALL run( )
1015cdf0e10cSrcweir {
1016cdf0e10cSrcweir read();
1017cdf0e10cSrcweir }
1018cdf0e10cSrcweir
onTerminated()1019cdf0e10cSrcweir void SAL_CALL onTerminated( )
1020cdf0e10cSrcweir {
1021*63d99982SDamjan Jovanovic //printf("# normally terminate this thread %d!\n", m_id );
1022cdf0e10cSrcweir }
1023cdf0e10cSrcweir
1024cdf0e10cSrcweir public:
getCount()1025cdf0e10cSrcweir sal_Int32 getCount() {return m_nReadCount;}
isOk()1026cdf0e10cSrcweir bool isOk() {return m_nReadCount == 0 ? false : true;}
getFailed()1027cdf0e10cSrcweir bool getFailed() {return m_bOk == false ? true : false;}
1028cdf0e10cSrcweir
ReadSocket2Thread(osl::Condition & _aCondition)1029cdf0e10cSrcweir ReadSocket2Thread(osl::Condition &_aCondition)
1030cdf0e10cSrcweir :m_aCondition(_aCondition),
1031cdf0e10cSrcweir m_nReadCount(0),
1032cdf0e10cSrcweir m_bOk( true )
1033cdf0e10cSrcweir {
1034cdf0e10cSrcweir m_aCondition.reset();
1035cdf0e10cSrcweir m_pBuffer = (char*) malloc(1024);
1036cdf0e10cSrcweir if (m_pBuffer)
1037cdf0e10cSrcweir {
1038cdf0e10cSrcweir m_nBufferSize = 1024;
1039cdf0e10cSrcweir }
1040cdf0e10cSrcweir
1041cdf0e10cSrcweir m_id = getIdentifier( );
1042*63d99982SDamjan Jovanovic //printf("# successfully creat this client thread %d!\n", m_id );
1043cdf0e10cSrcweir }
1044cdf0e10cSrcweir
setAddr(rtl::OString const & _sAddr)1045cdf0e10cSrcweir void setAddr(rtl::OString const& _sAddr)
1046cdf0e10cSrcweir {
1047cdf0e10cSrcweir m_sAddr = _sAddr;
1048cdf0e10cSrcweir }
1049cdf0e10cSrcweir
~ReadSocket2Thread()1050cdf0e10cSrcweir ~ReadSocket2Thread( )
1051cdf0e10cSrcweir {
1052cdf0e10cSrcweir if ( isRunning( ) )
1053*63d99982SDamjan Jovanovic printf("# error: client thread not terminated.\n" );
1054cdf0e10cSrcweir free(m_pBuffer);
1055cdf0e10cSrcweir }
1056cdf0e10cSrcweir
1057cdf0e10cSrcweir };
1058cdf0e10cSrcweir
1059cdf0e10cSrcweir // -----------------------------------------------------------------------------
1060cdf0e10cSrcweir
1061*63d99982SDamjan Jovanovic class justtest : public ::testing::Test
1062cdf0e10cSrcweir {
1063*63d99982SDamjan Jovanovic protected:
send_Acceptor(rtl::OString const & _sAddr,osl::Condition &)1064cdf0e10cSrcweir void send_Acceptor(rtl::OString const& _sAddr, osl::Condition &)
1065cdf0e10cSrcweir {
1066cdf0e10cSrcweir ::osl::AcceptorSocket aSocket; // ( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
1067cdf0e10cSrcweir ::osl::SocketAddr aSocketAddr;
1068cdf0e10cSrcweir
1069cdf0e10cSrcweir if (! aSocketAddr.setPort(IP_PORT_TEST))
1070cdf0e10cSrcweir {
1071*63d99982SDamjan Jovanovic printf("# can't set port\n" );
1072cdf0e10cSrcweir }
1073cdf0e10cSrcweir
1074cdf0e10cSrcweir if (! aSocketAddr.setHostname(rtl::OUString::createFromAscii(_sAddr.getStr())))
1075cdf0e10cSrcweir {
1076*63d99982SDamjan Jovanovic printf("# can't set hostname/ip\n" );
1077cdf0e10cSrcweir }
1078cdf0e10cSrcweir
1079cdf0e10cSrcweir rtl::OUString aHostname = aSocketAddr.getHostname();
1080cdf0e10cSrcweir aSocketAddr.getPort();
1081cdf0e10cSrcweir
1082cdf0e10cSrcweir
1083cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
1084cdf0e10cSrcweir aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
1085cdf0e10cSrcweir
1086cdf0e10cSrcweir /// if the thread should terminate, schedule return false
1087cdf0e10cSrcweir // while ( schedule( ) == sal_True )
1088cdf0e10cSrcweir // {
1089cdf0e10cSrcweir if (! aSocket.bind( aSocketAddr ))
1090cdf0e10cSrcweir {
1091*63d99982SDamjan Jovanovic printf("# can't bind.\n" );
1092cdf0e10cSrcweir }
1093cdf0e10cSrcweir if (! aSocket.listen( ))
1094cdf0e10cSrcweir {
1095*63d99982SDamjan Jovanovic printf("# can't listen. \n" );
1096cdf0e10cSrcweir }
1097cdf0e10cSrcweir
1098cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
1099cdf0e10cSrcweir aSocket.enableNonBlockingMode( sal_False);
1100cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
1101cdf0e10cSrcweir
1102cdf0e10cSrcweir oslSocketResult eResult = aSocket.acceptConnection( ssStreamConnection );
1103cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
1104cdf0e10cSrcweir {
1105*63d99982SDamjan Jovanovic printf("WriteSocketThread: acceptConnection failed! \n");
1106cdf0e10cSrcweir // break;
1107cdf0e10cSrcweir }
1108cdf0e10cSrcweir char const * pBuffer = "Test String\n";
1109cdf0e10cSrcweir sal_Int32 nBufferSize = strlen(pBuffer);
1110cdf0e10cSrcweir ssStreamConnection.write( pBuffer, nBufferSize );
1111cdf0e10cSrcweir // break;
1112cdf0e10cSrcweir // }
1113cdf0e10cSrcweir
1114cdf0e10cSrcweir // ssStreamConnection.close();
1115cdf0e10cSrcweir aSocket.close();
1116cdf0e10cSrcweir }
1117cdf0e10cSrcweir
1118cdf0e10cSrcweir // -----------------------------------------------------------------------------
1119cdf0e10cSrcweir
send_Connector(rtl::OString const & _sAddr,osl::Condition &)1120cdf0e10cSrcweir void send_Connector(rtl::OString const& _sAddr, osl::Condition &/*_aCondition*/ )
1121cdf0e10cSrcweir {
1122cdf0e10cSrcweir ::osl::ConnectorSocket aSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
1123cdf0e10cSrcweir ::osl::SocketAddr aSocketAddr( rtl::OUString::createFromAscii(_sAddr.getStr()), IP_PORT_TEST );
1124cdf0e10cSrcweir
1125cdf0e10cSrcweir if (! aSocketAddr.is())
1126cdf0e10cSrcweir {
1127*63d99982SDamjan Jovanovic printf("is failed.\n");
1128cdf0e10cSrcweir return;
1129cdf0e10cSrcweir }
1130cdf0e10cSrcweir
1131cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
1132cdf0e10cSrcweir aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;
1133cdf0e10cSrcweir
1134cdf0e10cSrcweir oslSocketResult aResult = aSocket.connect( aSocketAddr );
1135cdf0e10cSrcweir if ( aResult != osl_Socket_Ok )
1136cdf0e10cSrcweir {
1137*63d99982SDamjan Jovanovic printf("# send_Connector: connect failed. \n" );
1138cdf0e10cSrcweir }
1139cdf0e10cSrcweir else
1140cdf0e10cSrcweir {
1141cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
1142cdf0e10cSrcweir // aSocket.enableNonBlockingMode( sal_False );
1143cdf0e10cSrcweir
1144cdf0e10cSrcweir // _aCondition.set();
1145cdf0e10cSrcweir
1146cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection(aSocket);
1147cdf0e10cSrcweir
1148cdf0e10cSrcweir char const * pBuffer = "GET / HTTP/1.0\015\012\015\012";
1149cdf0e10cSrcweir sal_Int32 nBufferSize = strlen(pBuffer);
1150cdf0e10cSrcweir ssStreamConnection.write( pBuffer, nBufferSize );
1151cdf0e10cSrcweir
1152cdf0e10cSrcweir char *pBufferPeek = (char*) malloc(1024);
1153cdf0e10cSrcweir sal_Int32 nReadNumber = ssStreamConnection.recv( pBufferPeek, 1024, osl_Socket_MsgPeek);
1154cdf0e10cSrcweir free(pBufferPeek);
1155cdf0e10cSrcweir
1156cdf0e10cSrcweir char *pBuffer2 = (char*) malloc(nReadNumber + 1);
1157cdf0e10cSrcweir sal_Int32 nReadNumberReal = ssStreamConnection.read( pBuffer2, nReadNumber );
1158cdf0e10cSrcweir pBuffer2[nReadNumberReal] = '\0';
1159cdf0e10cSrcweir
1160*63d99982SDamjan Jovanovic printf("received: %s\n", pBuffer2);
1161cdf0e10cSrcweir
1162cdf0e10cSrcweir // char * pBuffer3 = "quit\n";
1163cdf0e10cSrcweir // nBufferSize = strlen(pBuffer3);
1164cdf0e10cSrcweir // nWriteNumber = ssStreamConnection.write( pBuffer3, nBufferSize );
1165cdf0e10cSrcweir
1166cdf0e10cSrcweir rtl::OUString suError = ssStreamConnection.getErrorAsString();
1167cdf0e10cSrcweir free(pBuffer2);
1168cdf0e10cSrcweir // ssStreamConnection.close();
1169cdf0e10cSrcweir
1170cdf0e10cSrcweir // ssStreamConnection.close();
1171cdf0e10cSrcweir }
1172cdf0e10cSrcweir aSocket.shutdown(osl_Socket_DirReadWrite);
1173cdf0e10cSrcweir aSocket.close();
1174cdf0e10cSrcweir }
1175cdf0e10cSrcweir
1176cdf0e10cSrcweir
1177cdf0e10cSrcweir public:
1178cdf0e10cSrcweir // LLA: orig void send_recv()
1179cdf0e10cSrcweir // LLA: orig {
1180cdf0e10cSrcweir // LLA: orig if ( ifAvailable(rtl::OUString::createFromAscii("margritte.germany")) == sal_True )
1181*63d99982SDamjan Jovanovic // LLA: orig printf("margritte is alive ! \n");
1182cdf0e10cSrcweir // LLA: orig if ( ifAvailable(rtl::OUString::createFromAscii("10.16.66.252")) == sal_False )
1183cdf0e10cSrcweir // LLA: orig {
1184*63d99982SDamjan Jovanovic // LLA: orig printf("ip 10.16.66.252 is not alive! \n");
1185cdf0e10cSrcweir // LLA: orig return;
1186cdf0e10cSrcweir // LLA: orig }
1187cdf0e10cSrcweir // LLA: orig ReadSocket2Thread myReadThread;
1188cdf0e10cSrcweir // LLA: orig myReadThread.create();
1189cdf0e10cSrcweir // LLA: orig
1190cdf0e10cSrcweir // LLA: orig thread_sleep( 2 );
1191cdf0e10cSrcweir // LLA: orig // send_Acceptor();
1192cdf0e10cSrcweir // LLA: orig send_Connector();
1193cdf0e10cSrcweir // LLA: orig
1194cdf0e10cSrcweir // LLA: orig myReadThread.join();
1195cdf0e10cSrcweir // LLA: orig
1196cdf0e10cSrcweir // LLA: orig // statistics
1197cdf0e10cSrcweir // LLA: orig sal_uInt32 nLength = myReadThread.getCount();
1198cdf0e10cSrcweir // LLA: orig bool bIsOk = myReadThread.isOk(); // check if the values are right.
1199cdf0e10cSrcweir // LLA: orig
1200*63d99982SDamjan Jovanovic // LLA: orig printf("Length:=%d\n", nLength);
1201*63d99982SDamjan Jovanovic // LLA: orig printf(" bIsOk:=%d\n", bIsOk);
1202cdf0e10cSrcweir // LLA: orig }
1203cdf0e10cSrcweir
1204cdf0e10cSrcweir // -----------------------------------------------------------------------------
1205cdf0e10cSrcweir
1206cdf0e10cSrcweir // LLA: send_Connector_2_margritte works, it send strings to echo server on margritte
1207cdf0e10cSrcweir // but can not receive anything
1208cdf0e10cSrcweir
send_Connector_2_margritte(rtl::OString const & _sAddr)1209cdf0e10cSrcweir void send_Connector_2_margritte(rtl::OString const& _sAddr)
1210cdf0e10cSrcweir {
1211cdf0e10cSrcweir ::osl::ConnectorSocket aSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
1212cdf0e10cSrcweir ::osl::SocketAddr aSocketAddr( rtl::OUString::createFromAscii(_sAddr.getStr()), IP_PORT_TEST );
1213cdf0e10cSrcweir
1214cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
1215cdf0e10cSrcweir aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;
1216cdf0e10cSrcweir
1217cdf0e10cSrcweir oslSocketResult aResult = aSocket.connect( aSocketAddr );
1218cdf0e10cSrcweir if ( aResult != osl_Socket_Ok )
1219cdf0e10cSrcweir {
1220*63d99982SDamjan Jovanovic printf("# connect failed. \n" );
1221cdf0e10cSrcweir }
1222cdf0e10cSrcweir else
1223cdf0e10cSrcweir {
1224cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
1225cdf0e10cSrcweir aSocket.enableNonBlockingMode( sal_False );
1226cdf0e10cSrcweir
1227cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection(aSocket);
1228cdf0e10cSrcweir
1229cdf0e10cSrcweir char const * pBuffer = "Test String\n";
1230cdf0e10cSrcweir sal_Int32 nBufferSize = strlen(pBuffer);
1231cdf0e10cSrcweir sal_Int32 nWriteNumber = ssStreamConnection.write( pBuffer, nBufferSize );
1232cdf0e10cSrcweir
1233cdf0e10cSrcweir // char * pBuffer2 = " ";
1234cdf0e10cSrcweir // sal_Int32 nReadNumber = ssStreamConnection.read( pBuffer2, strlen(pBuffer2) );
1235cdf0e10cSrcweir
1236cdf0e10cSrcweir char const * pBuffer3 = "quit\n";
1237cdf0e10cSrcweir nBufferSize = strlen(pBuffer3);
1238cdf0e10cSrcweir nWriteNumber = ssStreamConnection.write( pBuffer3, nBufferSize );
1239cdf0e10cSrcweir
1240cdf0e10cSrcweir ssStreamConnection.close();
1241cdf0e10cSrcweir }
1242cdf0e10cSrcweir aSocket.close();
1243cdf0e10cSrcweir }
1244cdf0e10cSrcweir
send_recv_2_margritte()1245cdf0e10cSrcweir void send_recv_2_margritte()
1246cdf0e10cSrcweir {
1247cdf0e10cSrcweir rtl::OString sAddr;
1248cdf0e10cSrcweir sAddr = "margritte.germany.sun.com";
1249cdf0e10cSrcweir if ( ifAvailable(rtl::OUString::createFromAscii(sAddr.getStr())) == sal_True )
1250cdf0e10cSrcweir {
1251*63d99982SDamjan Jovanovic printf("found %s!\n", sAddr.getStr());
1252cdf0e10cSrcweir }
1253cdf0e10cSrcweir send_Connector_2_margritte(sAddr);
1254cdf0e10cSrcweir }
1255cdf0e10cSrcweir
1256cdf0e10cSrcweir // -----------------------------------------------------------------------------
1257cdf0e10cSrcweir
1258cdf0e10cSrcweir
1259*63d99982SDamjan Jovanovic
1260*63d99982SDamjan Jovanovic void getPage(rtl::OString const& _sAddr);
1261*63d99982SDamjan Jovanovic }; // class isExceptionPending
1262*63d99982SDamjan Jovanovic
TEST_F(justtest,send_recv)1263*63d99982SDamjan Jovanovic TEST_F(justtest, send_recv)
1264*63d99982SDamjan Jovanovic {
1265*63d99982SDamjan Jovanovic rtl::OString sAddr;
1266*63d99982SDamjan Jovanovic // if ( ifAvailable(rtl::OUString::createFromAscii("margritte.germany")) == sal_True )
1267*63d99982SDamjan Jovanovic // {
1268*63d99982SDamjan Jovanovic // printf("margritte is alive ! \n");
1269*63d99982SDamjan Jovanovic // sAddr = "margritte.germany";
1270*63d99982SDamjan Jovanovic // }
1271*63d99982SDamjan Jovanovic
1272*63d99982SDamjan Jovanovic sAddr = "margritte.germany.sun.com";
1273*63d99982SDamjan Jovanovic if ( ifAvailable(rtl::OUString::createFromAscii(sAddr.getStr())) == sal_True )
1274*63d99982SDamjan Jovanovic {
1275*63d99982SDamjan Jovanovic printf("found %s!\n", sAddr.getStr());
1276*63d99982SDamjan Jovanovic }
1277cdf0e10cSrcweir // else
1278cdf0e10cSrcweir // {
1279cdf0e10cSrcweir // if ( ifAvailable(rtl::OUString::createFromAscii("192.168.7.2")) == sal_True )
1280cdf0e10cSrcweir // {
1281cdf0e10cSrcweir // sAddr = "192.168.7.2";
1282*63d99982SDamjan Jovanovic // printf("moon found ! \n");
1283cdf0e10cSrcweir // }
1284cdf0e10cSrcweir // else
1285cdf0e10cSrcweir // {
1286cdf0e10cSrcweir // if ( ifAvailable(rtl::OUString::createFromAscii("moon.linux.bogus")) == sal_True )
1287cdf0e10cSrcweir // {
1288cdf0e10cSrcweir // sAddr = "moon.linux.bogus";
1289*63d99982SDamjan Jovanovic // printf("moon found ! \n");
1290cdf0e10cSrcweir // }
1291cdf0e10cSrcweir // else
1292cdf0e10cSrcweir // {
1293cdf0e10cSrcweir // if ( ifAvailable(rtl::OUString::createFromAscii("moon")) == sal_True )
1294cdf0e10cSrcweir // {
1295cdf0e10cSrcweir // sAddr = "moon";
1296*63d99982SDamjan Jovanovic // printf("moon found ! \n");
1297cdf0e10cSrcweir // }
1298cdf0e10cSrcweir // }
1299cdf0e10cSrcweir // }
1300cdf0e10cSrcweir // }
1301cdf0e10cSrcweir
1302*63d99982SDamjan Jovanovic // if ( ifAvailable(rtl::OUString::createFromAscii("10.16.64.196")) == sal_False )
1303*63d99982SDamjan Jovanovic // {
1304*63d99982SDamjan Jovanovic // printf("ip 10.16.64.196 is not alive! \n");
1305*63d99982SDamjan Jovanovic // return;
1306*63d99982SDamjan Jovanovic // }
1307cdf0e10cSrcweir
1308*63d99982SDamjan Jovanovic osl::Condition aCondition;
1309*63d99982SDamjan Jovanovic ReadSocket2Thread myReadThread(aCondition);
1310*63d99982SDamjan Jovanovic myReadThread.setAddr(sAddr);
1311cdf0e10cSrcweir // myReadThread.create();
1312cdf0e10cSrcweir
1313*63d99982SDamjan Jovanovic thread_sleep( 2 );
1314*63d99982SDamjan Jovanovic if (! myReadThread.getFailed())
1315*63d99982SDamjan Jovanovic {
1316*63d99982SDamjan Jovanovic // send_Acceptor(sAddr, aCondition);
1317*63d99982SDamjan Jovanovic send_Connector(sAddr, aCondition);
1318cdf0e10cSrcweir
1319*63d99982SDamjan Jovanovic thread_sleep( 2 );
1320*63d99982SDamjan Jovanovic if (myReadThread.isRunning())
1321cdf0e10cSrcweir {
1322*63d99982SDamjan Jovanovic myReadThread.join();
1323cdf0e10cSrcweir }
1324*63d99982SDamjan Jovanovic // termAndJoinThread(&myReadThread);
1325cdf0e10cSrcweir
1326*63d99982SDamjan Jovanovic // statistics
1327*63d99982SDamjan Jovanovic sal_uInt32 nLength = myReadThread.getCount();
1328*63d99982SDamjan Jovanovic bool bIsOk = myReadThread.isOk(); // check if the values are right.
1329cdf0e10cSrcweir
1330*63d99982SDamjan Jovanovic printf("Length:=%d\n", nLength);
1331*63d99982SDamjan Jovanovic printf(" bIsOk:=%d\n", bIsOk);
1332*63d99982SDamjan Jovanovic }
1333*63d99982SDamjan Jovanovic else
1334cdf0e10cSrcweir {
1335*63d99982SDamjan Jovanovic printf("ERROR: No echo Server on %s found.\n", sAddr.getStr());
1336cdf0e10cSrcweir }
1337*63d99982SDamjan Jovanovic }
1338cdf0e10cSrcweir
TEST_F(justtest,test_getPage)1339*63d99982SDamjan Jovanovic TEST_F(justtest, test_getPage)
1340*63d99982SDamjan Jovanovic {
1341*63d99982SDamjan Jovanovic // rtl::OString sPage("lla-1.germany.sun.com");
1342*63d99982SDamjan Jovanovic // getPage(sPage);
1343*63d99982SDamjan Jovanovic
1344*63d99982SDamjan Jovanovic rtl::OString sPage("lla-1");
1345*63d99982SDamjan Jovanovic getPage(sPage);
1346*63d99982SDamjan Jovanovic }
1347cdf0e10cSrcweir
1348cdf0e10cSrcweir
getPage(rtl::OString const & _sAddr)1349cdf0e10cSrcweir void justtest::getPage(rtl::OString const& _sAddr)
1350cdf0e10cSrcweir {
1351cdf0e10cSrcweir rtl::OUString suAddr = rtl::OUString::createFromAscii(_sAddr.getStr());
1352cdf0e10cSrcweir ::osl::ConnectorSocket aSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
1353cdf0e10cSrcweir ::osl::SocketAddr aSocketAddr( suAddr, 80 );
1354cdf0e10cSrcweir
1355cdf0e10cSrcweir {
1356cdf0e10cSrcweir // some checks
1357cdf0e10cSrcweir aSocketAddr.getPort();
1358cdf0e10cSrcweir oslSocketResult aResult;
1359cdf0e10cSrcweir rtl::ByteSequence aSeq = aSocketAddr.getAddr(&aResult);
1360cdf0e10cSrcweir if (aResult != osl_Socket_Ok)
1361cdf0e10cSrcweir {
1362*63d99982SDamjan Jovanovic printf("problem with getAddr: ");
1363cdf0e10cSrcweir printSocketResult(aResult);
1364cdf0e10cSrcweir }
1365cdf0e10cSrcweir
1366cdf0e10cSrcweir rtl::OUString sStr = aSocketAddr.getHostname(&aResult);
1367cdf0e10cSrcweir if (aResult != osl_Socket_Ok)
1368cdf0e10cSrcweir {
1369*63d99982SDamjan Jovanovic printf("problem with hostname: ");
1370cdf0e10cSrcweir printSocketResult(aResult);
1371cdf0e10cSrcweir }
1372cdf0e10cSrcweir }
1373cdf0e10cSrcweir
1374cdf0e10cSrcweir oslSocketResult aResult;
1375cdf0e10cSrcweir
1376cdf0e10cSrcweir // SocketAddr::resolveHostname(suAddr, aSocketAddr);
1377cdf0e10cSrcweir // if (! aSocketAddr.is())
1378cdf0e10cSrcweir // {
1379*63d99982SDamjan Jovanovic // printf("Can't resolve Hostname.\n");
1380cdf0e10cSrcweir // return;
1381cdf0e10cSrcweir // }
1382cdf0e10cSrcweir // rtl::OUString sStr = aSocketAddr.getHostname(&aResult);
1383cdf0e10cSrcweir // if (aResult != osl_Socket_Ok)
1384cdf0e10cSrcweir // {
1385*63d99982SDamjan Jovanovic // printf("problem with hostname: ");
1386cdf0e10cSrcweir // printSocketResult(aResult);
1387cdf0e10cSrcweir //
1388cdf0e10cSrcweir // }
1389cdf0e10cSrcweir
1390cdf0e10cSrcweir if (! aSocketAddr.is())
1391cdf0e10cSrcweir {
1392*63d99982SDamjan Jovanovic printf("SocketAddr::is() failed.\n");
1393cdf0e10cSrcweir return;
1394cdf0e10cSrcweir }
1395cdf0e10cSrcweir
1396cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
1397cdf0e10cSrcweir aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;
1398cdf0e10cSrcweir
1399cdf0e10cSrcweir aResult = aSocket.connect( aSocketAddr );
1400cdf0e10cSrcweir if ( aResult != osl_Socket_Ok )
1401cdf0e10cSrcweir {
1402*63d99982SDamjan Jovanovic printf("# send_Connector: connect failed. \n" );
1403cdf0e10cSrcweir }
1404cdf0e10cSrcweir else
1405cdf0e10cSrcweir {
1406cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
1407cdf0e10cSrcweir // aSocket.enableNonBlockingMode( sal_False );
1408cdf0e10cSrcweir
1409cdf0e10cSrcweir // _aCondition.set();
1410cdf0e10cSrcweir
1411cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection(aSocket);
1412cdf0e10cSrcweir
1413cdf0e10cSrcweir char const * pBuffer = "GET / HTTP/1.0\015\012\015\012";
1414cdf0e10cSrcweir sal_Int32 nBufferSize = strlen(pBuffer);
1415cdf0e10cSrcweir ssStreamConnection.write( pBuffer, nBufferSize );
1416cdf0e10cSrcweir
1417cdf0e10cSrcweir
1418cdf0e10cSrcweir char *pBufferPeek = (char*) malloc(1024);
1419cdf0e10cSrcweir sal_Int32 nReadNumber = 1;
1420cdf0e10cSrcweir while ( nReadNumber != 0)
1421cdf0e10cSrcweir {
1422cdf0e10cSrcweir nReadNumber = ssStreamConnection.recv( pBufferPeek, 1024, osl_Socket_MsgPeek);
1423cdf0e10cSrcweir if (nReadNumber > 0)
1424cdf0e10cSrcweir {
1425cdf0e10cSrcweir char *pBuffer2 = (char*) malloc(nReadNumber + 1);
1426cdf0e10cSrcweir sal_Int32 nReadNumberReal = ssStreamConnection.read( pBuffer2, nReadNumber );
1427cdf0e10cSrcweir pBuffer2[nReadNumberReal] = '\0';
1428*63d99982SDamjan Jovanovic printf("%s", pBuffer2);
1429cdf0e10cSrcweir free(pBuffer2);
1430cdf0e10cSrcweir }
1431cdf0e10cSrcweir }
1432cdf0e10cSrcweir free(pBufferPeek);
1433cdf0e10cSrcweir
1434cdf0e10cSrcweir // char * pBuffer3 = "quit\n";
1435cdf0e10cSrcweir // nBufferSize = strlen(pBuffer3);
1436cdf0e10cSrcweir // nWriteNumber = ssStreamConnection.write( pBuffer3, nBufferSize );
1437cdf0e10cSrcweir
1438cdf0e10cSrcweir rtl::OUString suError = ssStreamConnection.getErrorAsString();
1439cdf0e10cSrcweir }
1440cdf0e10cSrcweir aSocket.shutdown(osl_Socket_DirReadWrite);
1441cdf0e10cSrcweir aSocket.close();
1442cdf0e10cSrcweir }
1443cdf0e10cSrcweir
1444cdf0e10cSrcweir
1445cdf0e10cSrcweir } // namespace osl_StreamSocket
1446cdf0e10cSrcweir
signalHandler(void * pData,oslSignalInfo * pInfo)1447*63d99982SDamjan Jovanovic static oslSignalAction SAL_CALL signalHandler(void* pData, oslSignalInfo* pInfo)
1448*63d99982SDamjan Jovanovic {
1449*63d99982SDamjan Jovanovic return osl_Signal_ActCallNextHdl;
1450*63d99982SDamjan Jovanovic }
1451cdf0e10cSrcweir
main(int argc,char ** argv)1452*63d99982SDamjan Jovanovic int main(int argc, char **argv)
1453*63d99982SDamjan Jovanovic {
1454*63d99982SDamjan Jovanovic osl_addSignalHandler(signalHandler, NULL);
1455*63d99982SDamjan Jovanovic ::testing::InitGoogleTest(&argc, argv);
1456*63d99982SDamjan Jovanovic return RUN_ALL_TESTS();
1457*63d99982SDamjan Jovanovic }
1458