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