sal/qa/osl/socket/osl_StreamSocket.cxx

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