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