ACE/tests/Bug_2610_Regression_Test.cpp

   1 /**
   2  * @file Bug_2610_Regression_Test.cpp
   3  *
   4  * Reproduces the problems reported in bug 2610:
   5  *   http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=2610
   6  *
   7  * @author Milan Cvetkovic <milan.cvetkovic@mpathix.com>
   8  */
   9
  10 #include "test_config.h"
  11 #include "ace/INET_Addr.h"
  12 #include "ace/SOCK_Stream.h"
  13 #include "ace/SOCK_Acceptor.h"
  14 #include "ace/SOCK_Connector.h"
  15 #include "ace/Svc_Handler.h"
  16 #include "ace/Acceptor.h"
  17 #include "ace/Connector.h"
  18 #include "ace/Trace.h"
  19 #include "ace/Thread_Semaphore.h"
  20
  21 #if defined (ACE_HAS_THREADS)
  22
  23 # define TEST_TRACE(X) ACE_Trace ____ (ACE_TEXT (X), __LINE__, ACE_TEXT (__FILE__))
  24
  25 int g_svc_handlers_leaked = 0;
  26 // use semaphore for synchronization
  27 //
  28 ACE_Thread_Semaphore g_semaphore (0);
  29
  30 class My_Svc_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH>
  31 {
  32 public:
  33   typedef ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_NULL_SYNCH> super;
  34   My_Svc_Handler()
  35   {
  36     TEST_TRACE ("My_Svc_Handler:My_Svc_Handler");
  37     ++g_svc_handlers_leaked;
  38     reference_counting_policy().value(
  39       Reference_Counting_Policy::ENABLED);
  40   }
  41
  42   ~My_Svc_Handler()
  43   {
  44     TEST_TRACE ("My_Svc_Handler::~My_Svc_Handler");
  45     --g_svc_handlers_leaked;
  46   }
  47
  48   int handle_close (ACE_HANDLE /*fd*/, ACE_Reactor_Mask /*mask*/)
  49   {
  50     TEST_TRACE ("handle_close");
  51     g_semaphore.release();
  52     return 0;
  53   }
  54 };
  55
  56 bool g_acceptor_accept_fails;
  57
  58 class My_Acceptor : public ACE_Acceptor<My_Svc_Handler, ACE_SOCK_ACCEPTOR>
  59 {
  60 public:
  61   typedef ACE_Acceptor<My_Svc_Handler, ACE_SOCK_ACCEPTOR> super;
  62   My_Acceptor () : super (ACE_INET_Addr(9000)) {}
  63
  64 protected:
  65   int accept_svc_handler (My_Svc_Handler *svc_handler)
  66   {
  67     TEST_TRACE ("accept_svc_handler");
  68     int rv = super::accept_svc_handler(svc_handler);
  69     if (g_acceptor_accept_fails)
  70       {
  71         g_semaphore.release();
  72         return -1;
  73       }
  74     return rv;
  75   }
  76   int activate_svc_handler (My_Svc_Handler* /*svc_handler*/)
  77   {
  78     TEST_TRACE ("My_Acceptor::activate_svc_handler");
  79     g_semaphore.release();
  80     return -1;
  81   }
  82 };
  83
  84 class My_Connector : public ACE_Connector<My_Svc_Handler, ACE_SOCK_CONNECTOR>
  85 {
  86 public:
  87   typedef ACE_Connector<My_Svc_Handler, ACE_SOCK_CONNECTOR> super;
  88 protected:
  89   int activate_svc_handler (My_Svc_Handler* /*svc_handler*/)
  90   {
  91     TEST_TRACE ("My_Connector::activate_svc_handler");
  92     g_semaphore.release();
  93     return -1;
  94   }
  95 };
  96
  97 struct My_Task : public ACE_Task_Base
  98 {
  99    int svc()
 100    {
 101      TEST_TRACE ("My_Task::svc");
 102      ACE_Reactor::instance()->owner(ACE_OS::thr_self());
 103      int rv = ACE_Reactor::instance()->run_reactor_event_loop();
 104      if (rv < 0)
 105      {
 106        ACE_ERROR ((LM_ERROR,
 107                    ACE_TEXT ("%p\n"),
 108                    ACE_TEXT ("Cannot run reactor event loop")));
 109      }
 110      return 0;
 111    }
 112 };
 113
 114 // event handler used to signal when the reactor started
 115 struct Timer_Handler : public ACE_Event_Handler
 116 {
 117    int handle_timeout (const ACE_Time_Value&, const void*)
 118    {
 119      g_semaphore.release(); // signal reactor started
 120      return 0;
 121    }
 122 };
 123
 124 #endif
 125
 126 int
 127 run_main (int, ACE_TCHAR *[])
 128 {
 129   ACE_START_TEST (ACE_TEXT ("Bug_2610_Regression_Test"));
 130
 131 #if defined (ACE_HAS_THREADS)
 132
 133   My_Acceptor acceptor;
 134   Timer_Handler timer_handler;
 135   ACE_Reactor::instance()->schedule_timer(
 136     &timer_handler, 0, ACE_Time_Value(0));
 137
 138   My_Task task;
 139   int activated = task.activate();
 140   if (activated < 0)
 141     {
 142       ACE_ERROR_RETURN ((LM_ERROR,
 143                          ACE_TEXT ("%p\n"),
 144                          ACE_TEXT ("Could not activate task")),
 145                         -1);
 146     }
 147
 148   // Don't assume addr family of the listener - check and adapt when needed.
 149   ACE_INET_Addr listen_addr;
 150   acceptor.acceptor ().get_local_addr (listen_addr);
 151 #if defined (ACE_HAS_IPV6)
 152   const ACE_TCHAR *me =
 153     listen_addr.get_type () == PF_INET ? ACE_LOCALHOST : ACE_IPV6_LOCALHOST;
 154 #else
 155   const ACE_TCHAR *me = ACE_LOCALHOST;
 156 #endif /* ACE_HAS_IPV6 */
 157   ACE_INET_Addr a1 (listen_addr.get_port_number (),
 158                     me,
 159                     listen_addr.get_type ());
 160   ACE_SOCK_Connector c1;
 161   g_semaphore.acquire();// wait for reactor to start
 162
 163   {
 164     g_acceptor_accept_fails = true;
 165     ACE_SOCK_Stream s1;
 166     if (-1 == c1.connect (s1, a1))
 167       {
 168         ACE_ERROR_RETURN ((LM_ERROR,
 169                            ACE_TEXT ("%p\n"),
 170                            ACE_TEXT ("Could not connect")),
 171                           -1);
 172       }
 173     g_semaphore.acquire(); // wait for accept_svc_handler() to start
 174   }
 175   {
 176     g_acceptor_accept_fails = false;
 177     ACE_SOCK_Stream s1;
 178     if (-1 == c1.connect (s1, a1))
 179       {
 180         ACE_ERROR_RETURN ((LM_ERROR,
 181                            ACE_TEXT ("%p\n"),
 182                            ACE_TEXT ("Could not connect")),
 183                           -1);
 184       }
 185     g_semaphore.acquire(); // wait for activate_svc_handler to complete
 186   }
 187
 188   {
 189     My_Svc_Handler* handler=0;
 190     My_Connector connector;
 191     connector.connect (handler, a1);
 192     ACE_Event_Handler_var safe_handler (handler);
 193     g_semaphore.acquire(); // wait for connect to complete
 194   }
 195   ACE_Reactor::end_event_loop();
 196   task.wait();
 197
 198   if (g_svc_handlers_leaked != 0)
 199     {
 200       ACE_ERROR_RETURN ((LM_ERROR,
 201                          ACE_TEXT ("Svc_Handler leakage detected, ")
 202                          ACE_TEXT ("%d objects remain\n"),
 203                          g_svc_handlers_leaked),
 204                         1);
 205     }
 206 #else
 207   ACE_ERROR ((LM_INFO,
 208               ACE_TEXT ("threads not supported on this platform\n")));
 209 #endif
 210
 211   ACE_END_TEST;
 212
 213   return 0;
 214 }