ACE/tests/SOCK_SEQPACK_SCTP_Test.cpp

   1 //
   2 // *WARRANTY DISCLAIMER: LIMITATION OF LIABILITY. THE SOFTWARE AND
   3 // CONTENT ARE PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED
   4 // REPRESENTATIONS, GUARANTEES, OR WARRANTIES, INCLUDING BUT NOT LIMITED
   5 // TO SUCH REPRESENTATION, GUARANTEES OR WARRANTIES REGARDING THE
   6 // USABILITY, SUITABILITY, CONDITION, OPERATION OR ACCURACY THEREOF. *
   7 //
   8 // *ALL OTHER WARRANTIES AND CONDITIONS (EXPRESS, IMPLIED OR STATUTORY)
   9 // ARE HEREBY DISCLAIMED, SUCH WARRANTIES AND CONDITIONS INCLUDING
  10 // WITHOUT LIMITATION, ALL WARRANTIES AND CONDITIONS OF MERCHANTABILITY,
  11 // TITLE, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT,
  12 // COMPATIBILITY, AND SECURITY OR ACCURACY.*
  13 //
  14 // ============================================================================
  15 //
  16 // = LIBRARY
  17 //    tests
  18 //
  19 // = FILENAME
  20 //    SOCK_SEQPACK_SCTP_Test.cpp
  21 //
  22 // = DESCRIPTION
  23 //    Performs several tests on the ACE_SOCK_SEQPACK_Connector,
  24 //    ACE_SOCK_SEQPACK_Acceptor, and ACE_SOCK_SEQPACK_Association classes
  25 //    specifically for SCTP using the loopback interface.  Attempts to
  26 //    replicate behavior of SOCK_Test.cpp, but integrating IPv6 tests
  27 //    directly.
  28 //
  29 // = AUTHOR
  30 //    Dave Craig <dwc@qualcomm.com>
  31 //
  32
  33 #include "test_config.h"
  34 #include "ace/OS_NS_unistd.h"
  35 #include "ace/OS_NS_sys_select.h"
  36 #include "ace/OS_NS_sys_wait.h"
  37 #include "ace/SOCK_SEQPACK_Connector.h"
  38 #include "ace/SOCK_SEQPACK_Acceptor.h"
  39 #include "ace/Thread_Manager.h"
  40 #include "ace/Handle_Set.h"
  41
  42 #define TTCPPORT 5001
  43 #define BYTE_MESG 0xcd
  44
  45 struct tdesc {
  46   ACE_Thread_Semaphore *tsemap;
  47   bool ipv6_test;
  48 };
  49
  50 using tdesc_t = struct tdesc;
  51
  52 #ifdef ACE_WIN64
  53 // This arg is ignored on Windows and causes pointer truncation
  54 // warnings on 64-bit compiled.
  55 #define SELECT_WIDTH(x) 0
  56 #else
  57 #define SELECT_WIDTH(x) (x)
  58 #endif
  59
  60 ACE_THR_FUNC_RETURN
  61 Server (void *arg)
  62 {
  63   ACE_SOCK_SEQPACK_Acceptor *AcceptorSocket =
  64     reinterpret_cast<ACE_SOCK_SEQPACK_Acceptor *> (arg);
  65
  66   ACE_SOCK_SEQPACK_Association Stream;
  67
  68   ACE_Handle_Set handle_set;
  69
  70   const ACE_Time_Value def_timeout (ACE_DEFAULT_TIMEOUT);
  71
  72   ACE_Time_Value tv (def_timeout);
  73
  74   int select_width;
  75
  76   int result;
  77
  78   //
  79   // Make sure AcceptorSocket is in nonblocking mode so as not to
  80   // hang tests.
  81   //
  82   if (-1 == AcceptorSocket->enable (ACE_NONBLOCK))
  83     ACE_ERROR ((LM_ERROR,
  84                 ACE_TEXT ("(%P|%t) %p\n"),
  85                 ACE_TEXT ("AcceptorSocket.enable (ACE_NONBLOCK)")));
  86
  87   //
  88   // Set up select to wait for I/O events.
  89   //
  90   handle_set.reset ();
  91   handle_set.set_bit (AcceptorSocket->get_handle ());
  92
  93   select_width = SELECT_WIDTH(int (AcceptorSocket->get_handle ()) + 1);
  94
  95   result = ACE_OS::select(select_width,
  96                           handle_set,
  97                           0,
  98                           0,
  99                           &tv);
 100
 101   if (-1 == result)
 102     ACE_ERROR_RETURN ((LM_ERROR,
 103                        ACE_TEXT ("(%P|%t) %p\n"),
 104                        ACE_TEXT ("select")),
 105                       0);
 106   if (0 == result)
 107     ACE_ERROR_RETURN ((LM_ERROR,
 108                        ACE_TEXT("(%P|%t) select timed out, shutting down\n")),
 109                       0);
 110
 111   ACE_DEBUG ((LM_DEBUG,
 112               ACE_TEXT ("(%P|%t) waiting for client to connect\n")));
 113
 114   while (-1 != AcceptorSocket->accept (Stream)) {
 115     ACE_DEBUG ((LM_DEBUG,
 116                 ACE_TEXT ("(%P|%t) client connected\n")));
 117
 118     //
 119     // Enable non-blocking I/O.
 120     //
 121     if (Stream.enable (ACE_NONBLOCK))
 122       ACE_ERROR_RETURN ((LM_ERROR,
 123                          ACE_TEXT ("(%P|%t) %p\n"),
 124                          ACE_TEXT ("Stream.enable (ACE_NONBLOCK)")),
 125                         0);
 126
 127     unsigned char byte = BYTE_MESG;
 128
 129     if (-1 == Stream.send_n (&byte, 1))
 130       ACE_ERROR ((LM_ERROR,
 131                   ACE_TEXT ("(%P|%t) %p\n"),
 132                   ACE_TEXT ("Stream.send_n")));
 133
 134     ACE_DEBUG ((LM_DEBUG,
 135                 ACE_TEXT ("(%P|%t) byte sent\n")));
 136
 137     //
 138     // Abruptly terminate the association.
 139     //
 140     if (-1 == Stream.abort ())
 141       ACE_ERROR ((LM_ERROR,
 142                   ACE_TEXT ("(%P|%t) %p\n"),
 143                   ACE_TEXT ("Association.abort")));
 144
 145     //
 146     // Negative test: make sure that we cannot send on a closed association.
 147     //
 148     if (-1 != Stream.send_n (&byte, 1))
 149       //FUZZ: disable check_for_lack_ACE_OS
 150       ACE_ERROR ((LM_ERROR,
 151                   ACE_TEXT ("(%P|%t) Negative test fail: Association")
 152                   ACE_TEXT(".send_n succeeded after abort()\n")));
 153       //FUZZ: enable check_for_lack_ACE_OS
 154
 155   }
 156
 157   //
 158   // Close server socket.
 159   //
 160   if (-1 == AcceptorSocket->close ())
 161     ACE_ERROR ((LM_ERROR,
 162                 ACE_TEXT ("(%P|%t) %p\n"),
 163                 ACE_TEXT ("AcceptorSocket.close")));
 164
 165   return 0;
 166 }
 167
 168 ACE_THR_FUNC_RETURN
 169 Client(void *arg)
 170 {
 171   ACE_Multihomed_INET_Addr *ServerAddr =
 172     reinterpret_cast<ACE_Multihomed_INET_Addr *> (arg);
 173
 174   ACE_SOCK_SEQPACK_Connector Connector;
 175
 176   ACE_SOCK_SEQPACK_Association Stream;
 177
 178   ACE_Time_Value tv (ACE_DEFAULT_TIMEOUT);
 179
 180   char b;
 181   size_t bytes;
 182
 183   if (-1 == Connector.connect (Stream,
 184                                *ServerAddr,
 185                                &tv,
 186                                ACE_Addr::sap_any,
 187                                1))
 188   {
 189     ACE_ERROR_RETURN ((LM_ERROR,
 190                        ACE_TEXT ("(%P|%t) %p to %s:%d\n"),
 191                        ACE_TEXT ("Connector.connect"),
 192                        ServerAddr->get_host_name (),
 193                        ServerAddr->get_port_number ()),
 194                       0);
 195   }
 196
 197   if (-1 == Stream.disable (ACE_NONBLOCK))
 198   {
 199     ACE_ERROR ((LM_ERROR,
 200                 ACE_TEXT ("(%P|%t) %p\n"),
 201                 ACE_TEXT ("Association.disable (ACE_NONBLOCK)")));
 202   }
 203
 204
 205   if (-1 == Stream.recv_n (&b, 1, &tv, &bytes))
 206   {
 207     ACE_ERROR ((LM_ERROR,
 208                 ACE_TEXT ("(%P|%t) %p\n"),
 209                 ACE_TEXT ("Association.recv_n")));
 210   }
 211
 212   if (1 == bytes)
 213     ACE_DEBUG ((LM_DEBUG,
 214                 ACE_TEXT ("(%P|%t) Client received %B bytes\n"),
 215                 bytes));
 216   else
 217     ACE_ERROR ((LM_ERROR,
 218                 ACE_TEXT ("(%P|%t) Client received %B bytes; expected 1\n"),
 219                 bytes));
 220
 221   //
 222   // Give server a little time to abort the association.
 223   //
 224   ACE_OS::sleep(1);
 225
 226   // abort closes the connection, so the recv should either see a closed
 227   // socket or some failure other than a timeout.
 228   ssize_t cnt = Stream.recv_n (&b, 1, &tv, &bytes);
 229   if (cnt > 0 || (cnt == -1 && errno == ETIME))
 230     ACE_ERROR ((LM_ERROR,
 231                 ACE_TEXT ("(%P|%t) Negative test failed; Association")
 232                 ACE_TEXT (".recv_n returned %b (w/ %m) after abort\n"),
 233                 cnt));
 234
 235   return 0;
 236 }
 237
 238 //
 239 // Spawn server and client threads and then wait until they complete the
 240 // test.  There must be a timeout on the wait, so executable does not hang the
 241 // tests indefinitely.
 242 //
 243 int
 244 spawn_test(bool ipv6_test)
 245 {
 246   ACE_DEBUG ((LM_DEBUG,
 247               ACE_TEXT ("(%P|%t) spawn_test started ipv6 %d\n"),
 248               ipv6_test));
 249
 250   ACE_SOCK_SEQPACK_Acceptor AcceptorSocket;
 251
 252   const ACE_TCHAR *addrstr =
 253 #ifdef ACE_HAS_IPV6
 254     ipv6_test ? ACE_IPV6_LOCALHOST : ACE_LOCALHOST;
 255 #else
 256     ACE_LOCALHOST;
 257 #endif /* ACE_HAS_IPV6 */
 258   ACE_Multihomed_INET_Addr ServerAddr (TTCPPORT,
 259                                        addrstr
 260 #ifdef ACE_HAS_IPV6
 261                                        ,1,
 262                                        ipv6_test ? AF_INET6 : AF_INET
 263 #endif /* ACE_HAS_IPV6 */
 264                                        );
 265
 266   if (-1 == AcceptorSocket.open (ServerAddr, 1))
 267     {
 268       ACE_ERROR ((LM_ERROR,
 269                   ACE_TEXT ("(%P|%t) %p\n"),
 270                   ACE_TEXT ("AcceptorSocket.open")));
 271     }
 272
 273   if (-1 == AcceptorSocket.get_local_addr (ServerAddr))
 274     {
 275       ACE_ERROR ((LM_ERROR,
 276                   ACE_TEXT ("(%P|%t) %p\n"),
 277                   ACE_TEXT ("AcceptorSocket.get_local_addr")));
 278     }
 279
 280 #ifndef ACE_LACKS_FORK
 281   switch (ACE_OS::fork (ACE_TEXT ("child")))
 282   {
 283   case -1:
 284     ACE_ERROR ((LM_ERROR,
 285                 ACE_TEXT ("(%P|%t) %p"),
 286                 ACE_TEXT ("fork failed")));
 287     break;
 288   case 0:
 289     ACE_LOG_MSG->sync (ACE_TEXT ("SOCK_SEQPACK_SCTP_Test"));
 290     Client (&ServerAddr);
 291     ACE_OS::exit (0);
 292     break;
 293   default:
 294     Server (reinterpret_cast<void *> (&AcceptorSocket));
 295     ACE_OS::wait ();
 296     break;
 297   }
 298 #elif defined (ACE_HAS_THREADS)
 299   if (-1 == ACE_Thread_Manager::instance ()->spawn
 300       (Server,
 301        reinterpret_cast<void *> (&AcceptorSocket),
 302        THR_NEW_LWP | THR_DETACHED))
 303   {
 304     ACE_ERROR ((LM_ERROR,
 305                 ACE_TEXT ("(%P|%t) %p%a"),
 306                 ACE_TEXT ("thread create failed")));
 307   }
 308
 309   if (-1 == ACE_Thread_Manager::instance ()->spawn
 310       (Client,
 311        reinterpret_cast<void *> (&ServerAddr),
 312        THR_NEW_LWP | THR_DETACHED))
 313   {
 314     ACE_ERROR ((LM_ERROR,
 315                 ACE_TEXT ("(%P|%t) %p%a"),
 316                 ACE_TEXT ("thread create failed")));
 317   }
 318
 319   ACE_Thread_Manager::instance ()->wait ();
 320 #else /* ACE_LACKS_FORK && ! ACE_HAS_THREADS */
 321   ACE_ERROR ((LM_DEBUG,
 322               ACE_TEXT ("(%P|%t)\n"),
 323               ACE_TEXT ("only one thread may be run ")
 324               ACE_TEXT ("in a process on this platform\n")));
 325 #endif /* ACE_LACKS_FORK && ! ACE_HAS_THREADS */
 326
 327   return 0;
 328 }
 329
 330 int
 331 do_test()
 332 {
 333   spawn_test(false);
 334
 335 #ifdef ACE_HAS_IPV6
 336   spawn_test(true);
 337 #endif
 338
 339   return 0;
 340 }
 341
 342 int run_main (int, ACE_TCHAR *[])
 343 {
 344   ACE_START_TEST (ACE_TEXT ("SOCK_SEQPACK_SCTP_Test"));
 345
 346   //
 347   // Check whether host OS has SCTP support before starting this test.
 348   // If not, just pass because there is not a hope of testing
 349   // SOCK_SEQPACK.
 350   //
 351   int status = 0;
 352
 353 #ifdef ACE_HAS_SCTP
 354   status = do_test();
 355 #else /* ! ACE_HAS_SCTP */
 356   ACE_DEBUG ((LM_DEBUG,
 357               ACE_TEXT("SCTP not supported by ACE.\n")
 358               ACE_TEXT("This test will not do anything.\n")));
 359 #endif /* ! ACE_HAS_SCTP */
 360
 361   ACE_END_TEST;
 362
 363   return status;
 364 }
 365