Repo restructuring

90 files changed, 13969 insertions, 0 deletions

diff --git a/ACE/examples/Reactor/Dgram/.cvsignore b/ACE/examples/Reactor/Dgram/.cvsignore
new file mode 100644
index 00000000000..94126b14c4e
--- /dev/null
+++ b/ACE/examples/Reactor/Dgram/.cvsignore
@@ -0,0 +1,4 @@
+codgram
+codgram
+dgram
+dgram
diff --git a/ACE/examples/Reactor/Dgram/CODgram.cpp b/ACE/examples/Reactor/Dgram/CODgram.cpp
new file mode 100644
index 00000000000..f423c43fb8c
--- /dev/null
+++ b/ACE/examples/Reactor/Dgram/CODgram.cpp
@@ -0,0 +1,254 @@
+// $Id$
+
+// Exercise the <ACE_SOCK_CODgram> wrapper along with the
+// <ACE_Reactor>.  This test simply ping-pongs datagrams back and
+// forth between the peer1 and peer2 processes.  This test can
+// be run in two ways:
+//
+// 1. Stand-alone -- e.g.,
+//
+//    % ./CODgram
+//
+//    which will spawn a child process and run peer1 and peer2
+//    in different processes on the same machine.
+//
+// 2. Distributed -- e.g.,
+//
+//    # Peer1
+//    % ./CODgram 10002 tango.cs.wustl.edu 10003 peer1
+//
+//    # Peer1
+//    % ./CODgram 10003 tango.cs.wustl.edu 10002 peer2
+//
+//    which will run peer1 and peer2 in different processes
+//    on the same or different machines.  Note that you MUST
+//    give the name "peer1" as the final argument to one and
+//    only one of the programs so that the test will work properly.
+
+#include "ace/OS_main.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/Reactor.h"
+#include "ace/SOCK_CODgram.h"
+#include "ace/INET_Addr.h"
+#include "ace/Process.h"
+#include "ace/Log_Msg.h"
+
+ACE_RCSID(Dgram, CODgram, "$Id$")
+
+// Port used to receive for dgrams.
+static u_short port1;
+
+class Dgram_Endpoint : public ACE_Event_Handler
+{
+public:
+  Dgram_Endpoint (const ACE_INET_Addr &remote_addr,
+                  const ACE_INET_Addr &local_addr);
+
+  // = Hook methods inherited from the <ACE_Event_Handler>.
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE handle);
+  virtual int handle_timeout (const ACE_Time_Value & tv,
+                              const void *arg = 0);
+
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+
+  int send (const char *buf, size_t len);
+  // Send the <buf> to the peer.
+
+private:
+  ACE_SOCK_CODgram endpoint_;
+  // Wrapper for sending/receiving dgrams.
+};
+
+int
+Dgram_Endpoint::send (const char *buf, size_t len)
+{
+  return this->endpoint_.send (buf, len);
+}
+
+int
+Dgram_Endpoint::handle_close (ACE_HANDLE handle,
+                              ACE_Reactor_Mask)
+{
+  ACE_UNUSED_ARG (handle);
+
+  this->endpoint_.close ();
+  return 0;
+}
+
+Dgram_Endpoint::Dgram_Endpoint (const ACE_INET_Addr &remote_addr,
+                                const ACE_INET_Addr &local_addr)
+  : endpoint_ (remote_addr, local_addr)
+{
+}
+
+ACE_HANDLE
+Dgram_Endpoint::get_handle (void) const
+{
+  return this->endpoint_.get_handle ();
+}
+
+int
+Dgram_Endpoint::handle_input (ACE_HANDLE)
+{
+  char buf[BUFSIZ];
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) activity occurred on handle %d!\n",
+              this->endpoint_.get_handle ()));
+
+  ssize_t n = this->endpoint_.recv (buf, sizeof buf);
+
+  if (n == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "handle_input"));
+  else
+    ACE_DEBUG ((LM_DEBUG,
+                "(%P|%t) buf of size %d = %*s\n",
+                n, n, buf));
+  return 0;
+}
+
+int
+Dgram_Endpoint::handle_timeout (const ACE_Time_Value &,
+                                const void *)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) timed out for endpoint\n"));
+  return 0;
+}
+
+static int
+run_test (u_short localport,
+          const ACE_TCHAR *remotehost,
+          u_short remoteport,
+          const ACE_TCHAR *peer)
+{
+  ACE_INET_Addr remote_addr (remoteport,
+                             remotehost);
+  ACE_INET_Addr local_addr (localport);
+
+  Dgram_Endpoint endpoint (remote_addr, local_addr);
+
+  // Read data from other side.
+  if (ACE_Reactor::instance ()->register_handler
+      (&endpoint,
+       ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "ACE_Reactor::register_handler"),
+                      -1);
+  char buf[BUFSIZ];
+  ACE_OS::strcpy (buf,
+                  "Data to transmit");
+  size_t len = ACE_OS::strlen (buf);
+
+  // "peer1" is the "initiator."
+  if (ACE_OS::strncmp (peer, ACE_TEXT("peer1"), 5) == 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) sending data\n"));
+      for (size_t i = 0; i < 20; i++)
+        {
+          endpoint.send (buf, len);
+          ACE_DEBUG ((LM_DEBUG,
+                      "(%P|%t) .\n"));
+          ACE_OS::sleep (1);
+        }
+    }
+
+  for (int i = 0; i < 40; i++)
+    {
+      // Wait up to 10 seconds for data.
+      ACE_Time_Value tv (10, 0);
+
+      if (ACE_Reactor::instance ()->handle_events (tv) <= 0)
+        ACE_ERROR_RETURN ((LM_DEBUG,
+                           "(%P|%t) %p\n",
+                           "handle_events"),
+                          -1);
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) return from handle events\n"));
+
+      endpoint.send (buf, len);
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) .\n"));
+    }
+
+  if (ACE_Reactor::instance ()->remove_handler
+      (&endpoint,
+       ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "ACE_Reactor::remove_handler"),
+                      -1);
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) exiting\n"));
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  // Estabish call backs and socket names.
+
+  port1 = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_SERVER_PORT;
+  const ACE_TCHAR *remotehost = argc > 2 ? argv[2] : ACE_DEFAULT_SERVER_HOST;
+  const u_short port2 = argc > 3 ? ACE_OS::atoi (argv[3]) : port1 + 1;
+
+  // Providing the fourth command line argument indicates we don't
+  // want to spawn a new process.  On Win32, we use this to exec the
+  // new program.
+  if (argc > 4)
+    run_test (port1,
+              remotehost,
+              port2,
+              argv[4]);
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) local port = %d, remote host = %s, remote port = %d\n",
+                  port1,
+                  remotehost,
+                  port2));
+
+      ACE_Process_Options options;
+      options.command_line ("%s %d %s %d %c",
+                            argv[0],
+                            port1,
+                            remotehost,
+                            port2,
+                            'c');
+
+      // This has no effect on NT and will spawn a process that exec
+      // the above run_test function.
+      options.creation_flags (ACE_Process_Options::NO_EXEC);
+
+      ACE_Process new_process;
+
+      switch (new_process.spawn (options))
+        {
+        case -1:
+          return -1;
+
+        case 0:
+          run_test (port1,
+                    remotehost,
+                    port2,
+                    ACE_TEXT("peer1"));
+          break;
+
+        default:
+          run_test (port2,
+                    remotehost,
+                    port1,
+                    ACE_TEXT("peer2"));
+          new_process.wait ();
+          break;
+        }
+    }
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Dgram/Dgram.cpp b/ACE/examples/Reactor/Dgram/Dgram.cpp
new file mode 100644
index 00000000000..c4c21e84186
--- /dev/null
+++ b/ACE/examples/Reactor/Dgram/Dgram.cpp
@@ -0,0 +1,258 @@
+// $Id$
+
+// Exercise the <ACE_SOCK_Dgram> wrapper along with the <ACE_Reactor>.
+// This test simply ping-pongs datagrams back and forth between the
+// peer1 and peer2 processes.  This test can be run in two ways:
+//
+// 1. Stand-alone -- e.g.,
+//
+//    % ./Dgram
+//
+//    which will spawn a child process and run peer1 and peer2
+//    in different processes on the same machine.
+//
+// 2. Distributed -- e.g.,
+//
+//    # Peer1
+//    % ./Dgram 10002 tango.cs.wustl.edu 10003 peer1
+//
+//    # Peer1
+//    % ./Dgram 10003 tango.cs.wustl.edu 10002 peer2
+//
+//    which will run peer1 and peer2 in different processes
+//    on the same or different machines.  Note that you MUST
+//    give the name "peer1" as the final argument to one and
+//    only one of the programs so that the test will work properly.
+
+#include "ace/OS_main.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/Reactor.h"
+#include "ace/Process.h"
+#include "ace/SOCK_Dgram.h"
+#include "ace/INET_Addr.h"
+#include "ace/Log_Msg.h"
+
+ACE_RCSID(Dgram, Dgram, "$Id$")
+
+// Port used to receive for dgrams.
+static u_short port1;
+
+class Dgram_Endpoint : public ACE_Event_Handler
+{
+public:
+  Dgram_Endpoint (const ACE_INET_Addr &local_addr);
+
+  // = Hook methods inherited from the <ACE_Event_Handler>.
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE handle);
+  virtual int handle_timeout (const ACE_Time_Value & tv,
+                              const void *arg = 0);
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+
+  int send (const char *buf, size_t len, const ACE_INET_Addr &);
+  // Send the <buf> to the peer.
+
+private:
+  ACE_SOCK_Dgram endpoint_;
+  // Wrapper for sending/receiving dgrams.
+};
+
+int
+Dgram_Endpoint::send (const char *buf,
+                      size_t len,
+                      const ACE_INET_Addr &addr)
+{
+  return this->endpoint_.send (buf, len, addr);
+}
+
+Dgram_Endpoint::Dgram_Endpoint (const ACE_INET_Addr &local_addr)
+  : endpoint_ (local_addr)
+{
+}
+
+ACE_HANDLE
+Dgram_Endpoint::get_handle (void) const
+{
+  return this->endpoint_.get_handle ();
+}
+
+int
+Dgram_Endpoint::handle_close (ACE_HANDLE handle,
+                              ACE_Reactor_Mask)
+{
+  ACE_UNUSED_ARG (handle);
+
+  this->endpoint_.close ();
+  delete this;
+  return 0;
+}
+
+int
+Dgram_Endpoint::handle_input (ACE_HANDLE)
+{
+  char buf[BUFSIZ];
+  ACE_INET_Addr from_addr;
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) activity occurred on handle %d!\n",
+              this->endpoint_.get_handle ()));
+
+  ssize_t n = this->endpoint_.recv (buf,
+                                    sizeof buf,
+                                    from_addr);
+
+  if (n == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "handle_input"));
+  else
+    ACE_DEBUG ((LM_DEBUG,
+                "(%P|%t) buf of size %d = %*s\n",
+                n,
+                n,
+                buf));
+  return 0;
+}
+
+int
+Dgram_Endpoint::handle_timeout (const ACE_Time_Value &,
+                                const void *)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) timed out for endpoint\n"));
+  return 0;
+}
+
+static int
+run_test (u_short localport,
+          const ACE_TCHAR *remotehost,
+          u_short remoteport,
+          const ACE_TCHAR *peer)
+{
+  ACE_INET_Addr remote_addr (remoteport,
+                             remotehost);
+  ACE_INET_Addr local_addr (localport);
+
+  Dgram_Endpoint *endpoint;
+
+  ACE_NEW_RETURN (endpoint,
+                  Dgram_Endpoint (local_addr),
+                  -1);
+
+  // Read data from other side.
+  if (ACE_Reactor::instance ()->register_handler
+      (endpoint,
+       ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "ACE_Reactor::register_handler"),
+                      -1);
+
+  char buf[BUFSIZ];
+  ACE_OS::strcpy (buf, "Data to transmit");
+  size_t len = ACE_OS::strlen (buf);
+
+  if (ACE_OS::strncmp (peer, ACE_TEXT("peer1"), 5) == 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) sending data\n"));
+
+      for (size_t i = 0; i < 20; i++)
+        {
+          endpoint->send (buf, len, remote_addr);
+          ACE_DEBUG ((LM_DEBUG,
+                      "(%P|%t) .\n"));
+          ACE_OS::sleep (1);
+        }
+    }
+
+  for (int i = 0; i < 40; i++)
+    {
+      // Wait up to 10 seconds for data.
+      ACE_Time_Value tv (10, 0);
+
+      if (ACE_Reactor::instance ()->handle_events (tv) <= 0)
+        ACE_ERROR_RETURN ((LM_DEBUG,
+                           "(%P|%t) %p\n",
+                           "handle_events"),
+                          -1);
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) return from handle events\n"));
+
+      endpoint->send (buf, len, remote_addr);
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) .\n"));
+    }
+
+  if (ACE_Reactor::instance ()->remove_handler
+      (endpoint,
+       ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "ACE_Reactor::remove_handler"),
+                      -1);
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P|%t) exiting\n"));
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  // Estabish call backs and socket names.
+
+  port1 = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_SERVER_PORT;
+  const ACE_TCHAR *remotehost = argc > 2 ? argv[2] : ACE_DEFAULT_SERVER_HOST;
+  const u_short port2 = argc > 3 ? ACE_OS::atoi (argv[3]) : port1 + 1;
+
+  // Providing the fourth command line argument indicate we don't want
+  // to spawn a new process.  On Win32, we use this to exec the new
+  // program.
+  if (argc > 4)
+    run_test (port1, remotehost, port2, argv[4]);
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t) local port = %d, remote host = %s, remote port = %d\n",
+                  port1,
+                  remotehost,
+                  port2));
+
+      ACE_Process_Options options;
+      options.command_line ("%s %d %s %d %c",
+                            argv[0],
+                            port1,
+                            remotehost,
+                            port2,
+                            'c');
+
+      // This has no effect on NT and will spawn a process that exec
+      // the above run_test function.
+      options.creation_flags (ACE_Process_Options::NO_EXEC);
+
+      ACE_Process new_process;
+      switch (new_process.spawn (options))
+        {
+        case -1:
+          return -1;
+
+        case 0:
+          run_test (port1,
+                    remotehost,
+                    port2,
+                    ACE_TEXT("peer1"));
+          break;
+
+        default:
+          run_test (port2,
+                    remotehost,
+                    port1,
+                    ACE_TEXT("peer2"));
+          new_process.wait ();
+          break;
+        }
+    }
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Dgram/Makefile.am b/ACE/examples/Reactor/Dgram/Makefile.am
new file mode 100644
index 00000000000..797f4b3d75e
--- /dev/null
+++ b/ACE/examples/Reactor/Dgram/Makefile.am
@@ -0,0 +1,51 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+
+## Makefile.Reactor_Dgram.am
+noinst_PROGRAMS = dgram
+
+dgram_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+dgram_SOURCES = \
+  Dgram.cpp
+
+dgram_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Dgram_CO.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += codgram
+
+codgram_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+codgram_SOURCES = \
+  CODgram.cpp
+
+codgram_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/Dgram/Reactor_Dgram.mpc b/ACE/examples/Reactor/Dgram/Reactor_Dgram.mpc
new file mode 100644
index 00000000000..1040aedc184
--- /dev/null
+++ b/ACE/examples/Reactor/Dgram/Reactor_Dgram.mpc
@@ -0,0 +1,18 @@
+// -*- MPC -*-
+// $Id$
+
+project(*CO) : aceexe {
+  avoids += ace_for_tao
+  exename = codgram
+  Source_Files {
+    CODgram.cpp
+  }
+}
+
+project : aceexe {
+  exename = dgram
+  Source_Files {
+    Dgram.cpp
+  }
+}
+
diff --git a/ACE/examples/Reactor/FIFO/.cvsignore b/ACE/examples/Reactor/FIFO/.cvsignore
new file mode 100644
index 00000000000..955ffdc75d5
--- /dev/null
+++ b/ACE/examples/Reactor/FIFO/.cvsignore
@@ -0,0 +1,4 @@
+client
+client
+server
+server
diff --git a/ACE/examples/Reactor/FIFO/Makefile.am b/ACE/examples/Reactor/FIFO/Makefile.am
new file mode 100644
index 00000000000..5540e860968
--- /dev/null
+++ b/ACE/examples/Reactor/FIFO/Makefile.am
@@ -0,0 +1,56 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+noinst_PROGRAMS =
+
+## Makefile.Reactor_FIFO_Client.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += client
+
+client_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+client_SOURCES = \
+  client.cpp
+
+client_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Reactor_FIFO_Server.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += server
+
+server_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+server_SOURCES = \
+  server.cpp
+
+server_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/FIFO/Reactor_FIFO.mpc b/ACE/examples/Reactor/FIFO/Reactor_FIFO.mpc
new file mode 100644
index 00000000000..072ec5412b8
--- /dev/null
+++ b/ACE/examples/Reactor/FIFO/Reactor_FIFO.mpc
@@ -0,0 +1,18 @@
+// -*- MPC -*-
+// $Id$
+
+project(*client) : aceexe {
+  avoids += ace_for_tao
+  exename = client
+  Source_Files {
+   client.cpp
+  }
+}
+
+project(*server) : aceexe {
+  avoids += ace_for_tao
+  exename = server
+  Source_Files {
+   server.cpp
+  }
+}
diff --git a/ACE/examples/Reactor/FIFO/client.cpp b/ACE/examples/Reactor/FIFO/client.cpp
new file mode 100644
index 00000000000..daa8d3304ad
--- /dev/null
+++ b/ACE/examples/Reactor/FIFO/client.cpp
@@ -0,0 +1,23 @@
+// $Id$
+
+#include "ace/FIFO_Send_Msg.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_NS_stropts.h"
+
+ACE_RCSID(FIFO, client, "$Id$")
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  char buf[] = "hello world";
+  ACE_Str_Buf msg (buf, sizeof buf);
+
+  ACE_FIFO_Send_Msg fifo_sender (ACE_DEFAULT_RENDEZVOUS,
+				 O_WRONLY | O_CREAT,
+				 ACE_DEFAULT_FILE_PERMS);
+
+  if (fifo_sender.send (msg) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send error for fifo"), -1);
+  else
+    return 0;
+}
diff --git a/ACE/examples/Reactor/FIFO/server.cpp b/ACE/examples/Reactor/FIFO/server.cpp
new file mode 100644
index 00000000000..b6e91dd5046
--- /dev/null
+++ b/ACE/examples/Reactor/FIFO/server.cpp
@@ -0,0 +1,89 @@
+// $Id$
+
+#include "ace/Service_Config.h"
+#include "ace/Reactor.h"
+#include "ace/Event_Handler.h"
+#include "ace/FIFO_Recv_Msg.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_NS_stropts.h"
+
+ACE_RCSID(FIFO, server, "$Id$")
+
+class FIFO_Recv_Handler : public ACE_Event_Handler
+{
+public:
+  FIFO_Recv_Handler (void);
+  ~FIFO_Recv_Handler (void);
+
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE fd);
+
+private:
+  ACE_FIFO_Recv_Msg fifo_reader_;
+};
+
+FIFO_Recv_Handler::FIFO_Recv_Handler (void)
+{
+  ACE_OS::unlink (ACE_DEFAULT_RENDEZVOUS);
+
+  // Make sure to open the FIFO with the "persistent" flag enabled
+  // (which is the default).
+  if (this->fifo_reader_.open (ACE_DEFAULT_RENDEZVOUS) == -1)
+    ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("open")));
+
+  // Register with the Reactor.
+  if (ACE_Reactor::instance ()->register_handler
+      (this, ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("register_handler")));
+}
+
+ACE_HANDLE
+FIFO_Recv_Handler::get_handle (void) const
+{
+  return this->fifo_reader_.get_handle ();
+}
+
+FIFO_Recv_Handler::~FIFO_Recv_Handler (void)
+{
+  this->fifo_reader_.close ();
+  this->fifo_reader_.remove ();
+}
+
+int
+FIFO_Recv_Handler::handle_input (ACE_HANDLE)
+{
+  char buf[BUFSIZ];
+
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("handle_input\n")));
+
+  ACE_Str_Buf msg (buf, 0, sizeof buf);
+
+  ssize_t n = this->fifo_reader_.recv (msg);
+
+  if (n < 0)
+    ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("recv")), -1);
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("msg.len = %d, n = %d\n"), msg.len, n));
+
+      if (msg.len > 0)
+	{
+	  // Do some work in here...
+	  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("msg.buf = %C\n"), msg.buf));
+	}
+      return 0;
+    }
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *argv[])
+{
+  ACE_Service_Config daemon (argv[0]);
+
+  FIFO_Recv_Handler fr_handler;
+
+  ACE_Reactor::instance ()->run_reactor_event_loop ();
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Makefile.am b/ACE/examples/Reactor/Makefile.am
new file mode 100644
index 00000000000..24d9217302d
--- /dev/null
+++ b/ACE/examples/Reactor/Makefile.am
@@ -0,0 +1,20 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+SUBDIRS = \
+        Dgram \
+        FIFO \
+        Misc \
+        Multicast \
+        Ntalker \
+        Proactor \
+        TP_Reactor \
+        WFMO_Reactor
+
diff --git a/ACE/examples/Reactor/Misc/.cvsignore b/ACE/examples/Reactor/Misc/.cvsignore
new file mode 100644
index 00000000000..f7cc1865efa
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/.cvsignore
@@ -0,0 +1,16 @@
+demuxing
+demuxing
+early_timeouts
+early_timeouts
+notification
+notification
+pingpong
+pingpong
+reactors
+reactors
+signals_1
+signals_1
+signals_2
+signals_2
+timer_queue
+timer_queue
diff --git a/ACE/examples/Reactor/Misc/Makefile.am b/ACE/examples/Reactor/Misc/Makefile.am
new file mode 100644
index 00000000000..47111585f87
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/Makefile.am
@@ -0,0 +1,137 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+## Makefile.Reactor_Misc_Demuxing.am
+noinst_PROGRAMS = demuxing
+
+demuxing_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+demuxing_SOURCES = \
+  test_demuxing.cpp
+
+demuxing_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Early_Timeouts.am
+noinst_PROGRAMS += early_timeouts
+
+early_timeouts_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+early_timeouts_SOURCES = \
+  test_early_timeouts.cpp
+
+early_timeouts_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Event_Handler_t.am
+noinst_PROGRAMS += event_handler_t
+
+event_handler_t_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+event_handler_t_SOURCES = \
+  test_event_handler_t.cpp
+
+event_handler_t_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Notification.am
+noinst_PROGRAMS += notification
+
+notification_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+notification_SOURCES = \
+  notification.cpp
+
+notification_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Pingpong.am
+noinst_PROGRAMS += pingpong
+
+pingpong_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+pingpong_SOURCES = \
+  pingpong.cpp
+
+pingpong_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Reactors.am
+noinst_PROGRAMS += reactors
+
+reactors_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+reactors_SOURCES = \
+  test_reactors.cpp
+
+reactors_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Signals_1.am
+noinst_PROGRAMS += signals_1
+
+signals_1_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+signals_1_SOURCES = \
+  test_signals_1.cpp
+
+signals_1_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Signals_2.am
+noinst_PROGRAMS += signals_2
+
+signals_2_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+signals_2_SOURCES = \
+  test_signals_2.cpp
+
+signals_2_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Misc_Timer_Queue.am
+noinst_PROGRAMS += timer_queue
+
+timer_queue_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+timer_queue_SOURCES = \
+  test_timer_queue.cpp
+
+timer_queue_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/Misc/Reactor_Misc.mpc b/ACE/examples/Reactor/Misc/Reactor_Misc.mpc
new file mode 100644
index 00000000000..c056a909bd8
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/Reactor_Misc.mpc
@@ -0,0 +1,57 @@
+// -*- MPC -*-
+// $Id$
+
+project(*event_handler_t) : aceexe {
+  exename = event_handler_t
+  Source_Files {
+    test_event_handler_t.cpp
+  }
+}
+project(*demuxing) : aceexe {
+  exename = demuxing
+  Source_Files {
+    test_demuxing.cpp
+  }
+}
+project(*early_timeouts) : aceexe {
+  exename = early_timeouts
+  Source_Files {
+    test_early_timeouts.cpp
+  }
+}
+project(*notification) : aceexe {
+  exename = notification
+  Source_Files {
+    notification.cpp
+  }
+}
+project(*pingpong) : aceexe {
+  exename = pingpong
+  Source_Files {
+    pingpong.cpp
+  }
+}
+project(*reactors) : aceexe {
+  exename = reactors
+  Source_Files {
+    test_reactors.cpp
+  }
+}
+project(*signals_1) : aceexe {
+  exename = signals_1
+  Source_Files {
+    test_signals_1.cpp
+  }
+}
+project(*signals_2) : aceexe {
+  exename = signals_2
+  Source_Files {
+    test_signals_2.cpp
+  }
+}
+project(*timer_queue) : aceexe {
+  exename = timer_queue
+  Source_Files {
+    test_timer_queue.cpp
+  }
+}
diff --git a/ACE/examples/Reactor/Misc/notification.cpp b/ACE/examples/Reactor/Misc/notification.cpp
new file mode 100644
index 00000000000..a04663b28ad
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/notification.cpp
@@ -0,0 +1,385 @@
+// $Id$
+
+#include "ace/OS_NS_unistd.h"
+#include "ace/Service_Config.h"
+#include "ace/Reactor.h"
+#include "ace/Thread_Manager.h"
+#include "ace/Thread.h"
+#include "ace/Signal.h"
+
+ACE_RCSID(Misc, notification, "$Id$")
+
+#if defined (ACE_HAS_THREADS)
+#if defined (CHORUS)
+// Chorus does not have signal, so we'll stop after a number of rounds.
+#define MAX_ITERATIONS 3
+#else
+#define MAX_ITERATIONS 10000
+#endif /* CHORUS */
+
+class Thread_Handler : public ACE_Event_Handler
+{
+  // = TITLE
+  //   Illustrate how the ACE_Reactor's thread-safe event notification
+  //   mechanism works.
+  //
+  // = DESCRIPTION
+  //   Handle timeouts in the main thread via the ACE_Reactor and I/O
+  //   events in a separate thread.  Just before the separate I/O
+  //   thread exits it notifies the ACE_Reactor in the main thread
+  //   using the ACE_Reactor's notification mechanism.
+public:
+  Thread_Handler (long delay,
+                  long interval,
+                  size_t n_threads,
+                  size_t max_iterations);
+  // Constructor.
+
+  Thread_Handler (size_t id,
+                  size_t max_iterations);
+
+  ~Thread_Handler (void);
+  // Destructor.
+
+  virtual int handle_signal (int signum,
+                             siginfo_t * = 0,
+                             ucontext_t * = 0);
+  // Handle signals.
+
+  virtual int handle_exception (ACE_HANDLE);
+  // Print data from main thread.
+
+  virtual int handle_output (ACE_HANDLE);
+  // Print data from main thread.
+
+  virtual int handle_timeout (const ACE_Time_Value &,
+			      const void *);
+  // Handle timeout events in the main thread.
+
+  virtual int handle_input (ACE_HANDLE);
+  // General notification messages to the Reactor.
+
+  virtual int notify (ACE_Time_Value *tv = 0);
+  // Perform notifications.
+
+  virtual int svc (void);
+  // Handle I/O events in a separate threads.
+
+private:
+  static void *svc_run (void *);
+  // Glues C++ to C thread library functions.
+
+  size_t id_;
+  // ID passed in by Thread_Handler constructor.
+
+  size_t iterations_;
+
+  static sig_atomic_t shutdown_;
+  // Shutting down.
+
+  // = Timing variables.
+  // Delay factor for timer-driven I/O.
+  static ACE_Time_Value delay_;
+
+  // Interval factor for Event_Handler timer.
+  static ACE_Time_Value interval_;
+};
+
+// Shutdown flag.
+sig_atomic_t Thread_Handler::shutdown_ = 0;
+
+// Delay factor for timer-driven I/O.
+ACE_Time_Value Thread_Handler::delay_;
+
+// Interval factor for Event_Handler timer.
+ACE_Time_Value Thread_Handler::interval_;
+
+Thread_Handler::Thread_Handler (size_t id,
+                                size_t max_iterations)
+  : id_ (id),
+    iterations_ (max_iterations)
+{
+}
+
+Thread_Handler::~Thread_Handler (void)
+{
+  // Cleanup resources so that we don't crash and burn when shutdown.
+  ACE_Event_Handler::remove_stdin_handler (ACE_Reactor::instance (),
+                                           ACE_Thread_Manager::instance ());
+  ACE_Reactor::instance ()->cancel_timer (this);
+}
+
+Thread_Handler::Thread_Handler (
+        long delay,
+        long interval,
+				size_t n_threads,
+        size_t max_iterations)
+    : iterations_ (max_iterations)
+{
+  ACE_Sig_Set sig_set;
+
+  sig_set.sig_add (SIGQUIT);
+  sig_set.sig_add (SIGINT);
+
+  delay_.set (delay);
+  interval_.set (interval);
+  this->id_ = 0;
+
+  if (ACE_Event_Handler::register_stdin_handler (this,
+						 ACE_Reactor::instance (),
+						 ACE_Thread_Manager::instance ()) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "register_stdin_handler"));
+  else if (ACE_Reactor::instance ()->register_handler (sig_set,
+                                                       this) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "(%t) %p\n",
+                "register_handler"));
+  else if (ACE_Reactor::instance ()->schedule_timer
+           (this,
+            0,
+            Thread_Handler::delay_,
+            Thread_Handler::interval_) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "(%t) %p\n",
+                "schedule_timer"));
+
+  // Set up this thread's signal mask to block all the signal in the
+  // <sig_set>, which is inherited by the threads it spawns.
+  ACE_Sig_Guard guard (&sig_set);
+
+  // Create N new threads of control Thread_Handlers.
+
+  for (size_t i = 0; i < n_threads; i++)
+    {
+      Thread_Handler *th;
+
+      ACE_NEW (th,
+               Thread_Handler (i + 1,
+                               this->iterations_));
+
+      if (ACE_Thread::spawn (reinterpret_cast<ACE_THR_FUNC> (&Thread_Handler::svc_run),
+                             reinterpret_cast<void *> (th),
+                             THR_NEW_LWP | THR_DETACHED) != 0)
+        ACE_ERROR ((LM_ERROR,
+                    "%p\n",
+                    "ACE_Thread::spawn"));
+    }
+
+  // The destructor of <guard> unblocks the signal set so that only
+  // this thread receives them!
+}
+
+int
+Thread_Handler::notify (ACE_Time_Value *timeout)
+{
+  // Just do something to test the ACE_Reactor's multi-thread
+  // capabilities...
+
+  if (ACE_Reactor::instance ()->notify
+      (this,
+       ACE_Event_Handler::EXCEPT_MASK,
+       timeout) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "(%t) %p\n",
+		       "notification::notify:exception"),
+                      -1);
+  else if (ACE_Reactor::instance ()->notify
+	   (this,
+            ACE_Event_Handler::WRITE_MASK,
+            timeout) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "(%t) %p\n",
+		       "notification::notify:write"),
+                      -1);
+  return 0;
+}
+
+// Test stdin handling that uses <select> to demultiplex HANDLEs.
+// Input is only handled by the main thread.
+
+int
+Thread_Handler::handle_input (ACE_HANDLE handle)
+{
+  char buf[BUFSIZ];
+  ssize_t n = ACE_OS::read (handle, buf, sizeof buf);
+
+  if (n > 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "input to (%t) %*s",
+		  n,
+                  buf));
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "%d more input to kill\n",
+		  this->iterations_));
+
+      // Only wait up to 10 milliseconds to notify the Reactor.
+      ACE_Time_Value timeout (0,
+                              10 * 1000);
+
+      if (this->notify (&timeout) == -1)
+	ACE_ERROR ((LM_DEBUG,
+                    "(%t), %p\n",
+		    "notification::handle_input:notify"));
+      return 0;
+    }
+  else
+    return -1;
+}
+
+// Perform a task that will test the ACE_Reactor's multi-threading
+// capabilities in separate threads.
+
+int
+Thread_Handler::svc (void)
+{
+  ACE_Time_Value sleep_timeout (0,
+                                // Transform this into microseconds and divide by 2.
+                                (Thread_Handler::interval_.sec () * ACE_ONE_SECOND_IN_USECS) / 2);
+
+  for (int i = this->iterations_;
+       i > 0;
+       --i)
+    {
+      if (this->shutdown_ != 0)
+        break;
+
+      // Block for delay_.secs () / 2, then notify the Reactor.
+      ACE_OS::sleep (sleep_timeout);
+
+      // Wait up to 10 milliseconds to notify the Reactor.
+      ACE_Time_Value timeout (0,
+                              10 * 1000);
+      if (this->notify (&timeout) == -1)
+	ACE_ERROR ((LM_ERROR,
+                    "(%t) %p\n",
+                    "notify"));
+    }
+
+  ACE_Reactor::instance ()->remove_handler (this,
+                                            ALL_EVENTS_MASK);
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) exiting svc\n"));
+  return 0;
+}
+
+// Test signal handling.
+
+int
+Thread_Handler::handle_signal (int signum, siginfo_t *, ucontext_t *)
+{
+  // @@ Note that this code is not portable to all OS platforms since
+  // it uses print statements within signal handler context.
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) received signal %S\n",
+              signum));
+
+  switch (signum)
+    {
+    case SIGINT:
+    case SIGQUIT:
+      ACE_ERROR ((LM_ERROR,
+		  "(%t) ******************** shutting down %n on signal %S\n",
+		  signum));
+      this->shutdown_ = 1;
+      ACE_Reactor::end_event_loop();
+    }
+  return 0;
+}
+
+int
+Thread_Handler::handle_timeout (const ACE_Time_Value &time, const void *)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) received timeout at (%u, %u), iterations = %d\n",
+	      time.sec (),
+              time.usec (),
+              this->iterations_));
+
+  if (--this->iterations_ <= 0
+      || Thread_Handler::interval_.sec () == 0)
+    ACE_Reactor::end_event_loop ();
+
+  return 0;
+}
+
+// Called by the ACE_Reactor when it receives a notification.
+
+int
+Thread_Handler::handle_exception (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG,
+	      "(%t) exception to id %d, iteration = %d\n",
+	      this->id_,
+              this->iterations_));
+  return 0;
+}
+
+// Called by the ACE_Reactor when it receives a notification.
+
+int
+Thread_Handler::handle_output (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG,
+	      "(%t) output to id %d, iteration = %d\n",
+	      this->id_,
+              // This decrement must come last since
+              // <handle_exception> is called before <handle_output>!
+              this->iterations_--));
+  return 0;
+}
+
+// "Shim" function that integrates C thread API with C++.
+
+void *
+Thread_Handler::svc_run (void *eh)
+{
+  Thread_Handler *this_handler =
+    reinterpret_cast<Thread_Handler *> (eh);
+
+  if (this_handler->svc () == 0)
+    return 0;
+  else
+    return reinterpret_cast<void *> (-1);
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  ACE_LOG_MSG->open (argv[0]);
+
+  if (argc < 4)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("usage: %s delay interval n_threads [iterations]\n"),
+                  argv[0]));
+      ACE_OS::exit (1);
+    }
+
+  int delay = ACE_OS::atoi (argv[1]);
+  int interval = ACE_OS::atoi (argv[2]);
+  size_t n_threads = ACE_OS::atoi (argv[3]);
+  size_t max_iterations = argc > 4 ? ACE_OS::atoi (argv[4]) : MAX_ITERATIONS;
+
+  Thread_Handler thr_handler (delay,
+                              interval,
+                              n_threads,
+                              max_iterations);
+
+  ACE_Reactor::instance ()->run_reactor_event_loop ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("exiting from main\n")));
+  return 0;
+}
+#else
+int
+main (int, char *[])
+{
+  ACE_ERROR_RETURN ((LM_ERROR,
+		     "threads must be supported to run this application\n"), -1);
+}
+#endif /* ACE_HAS_THREADS */
diff --git a/ACE/examples/Reactor/Misc/pingpong.cpp b/ACE/examples/Reactor/Misc/pingpong.cpp
new file mode 100644
index 00000000000..f4a3bc0630e
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/pingpong.cpp
@@ -0,0 +1,302 @@
+// $Id$
+
+/* Simple program that illustrates many features of the ACE_Reactor:
+
+   1. I/O event demultiplexing
+   2. Signal-based demultiplexing
+   3. Timer-based demultiplexing
+
+   To test this program, compile it and then execute it as follows:
+
+   % ./pingpong hello
+
+   You should see lots of the following output:
+
+   writing <4> [7860]
+   writing <4> [7860]
+   writing <4> [7860]
+   writing <4> [7860]
+   reading <5> (7860) [1] = hello
+   writing <4> [7860]
+   writing <5> [7861]
+   reading <4> (7861) [2] = hello
+   reading <5> (7860) [2] = hello
+   writing <4> [7860]
+   writing <5> [7861]
+   reading <4> (7861) [3] = hello
+   reading <5> (7860) [3] = hello
+
+   After 10 seconds you'll see the following:
+
+   ./pingpong: shutting down tester (pid = 7861)
+   ./pingpong: shutting down tester (pid = 7860)
+
+   and the program will stop.  If you'd like to
+   stop it earlier, just hit the control-C sequence
+   and you'll see the same messages. */
+
+#include "ace/Reactor.h"
+#include "ace/Pipe.h"
+#include "ace/Log_Msg.h"
+#include "ace/ACE.h"
+#include "ace/Test_and_Set.h"
+#include "ace/OS_NS_string.h"
+#include "ace/Null_Mutex.h"
+#include "ace/OS_NS_unistd.h"
+#if defined (ACE_WIN32) || defined (CHORUS)
+#  include "ace/Barrier.h"
+#  include "ace/Thread.h"
+#endif
+
+ACE_RCSID(Misc, pingpong, "$Id$")
+
+class Ping_Pong : public ACE_Test_and_Set<ACE_Null_Mutex, sig_atomic_t>
+{
+public:
+  Ping_Pong (char b[], ACE_HANDLE f);
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE);
+  virtual int handle_output (ACE_HANDLE);
+  virtual int handle_timeout (const ACE_Time_Value &,
+                              const void *);
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+private:
+  char buf_[BUFSIZ];
+  // Buffer to send.
+
+  size_t buflen_;
+  // Length of the buffer to send.
+
+  int pid_;
+  // Process ID.
+
+  ACE_HANDLE handle_;
+  // Open handle.
+};
+
+Ping_Pong::Ping_Pong (char b[], ACE_HANDLE f)
+  : buflen_ (ACE_OS::strlen (b) + 1 + (2 * sizeof (int))),
+    pid_ (ACE_OS::getpid ()),
+    handle_ (f)
+{
+  *((int *) this->buf_) = (int) this->pid_;
+  *((int *) (this->buf_ + sizeof (int))) = 0;
+  ACE_OS::strcpy (this->buf_ + (2 * sizeof (int)), b);
+  this->buf_[this->buflen_ - 1] = '\n';
+  this->buf_[this->buflen_] = '\0';
+}
+
+ACE_HANDLE
+Ping_Pong::get_handle (void) const
+{
+  return this->handle_;
+}
+
+int
+Ping_Pong::handle_close (ACE_HANDLE,
+                         ACE_Reactor_Mask)
+{
+  delete this; // Cleanup when we're removed from the reactor.
+  return 0;
+}
+
+int
+Ping_Pong::handle_input (ACE_HANDLE)
+{
+#if defined (ACE_HAS_STREAM_PIPES)
+  // We can rely on record-oriented reads...
+
+  ssize_t n = ACE::recv (this->handle_, this->buf_, this->buflen_);
+
+  if (n != (ssize_t) this->buflen_)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ACE_TEXT ("(%P|%t) reading [%d] %p\n"),
+                       handle_,
+                       ACE_TEXT ("read")),
+                      -1);
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) reading <%d> (%d) [%d] = %C\n"),
+              this->handle_,
+              *(int *) this->buf_,
+              *(int *) (this->buf_ + sizeof (int)),
+              this->buf_ + (2 * sizeof (int))));
+#else
+  ssize_t n = ACE::recv (this->handle_,
+                         this->buf_,
+                         this->buflen_);
+  if (n == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ACE_TEXT ("[%d] %p\n"),
+                       handle_,
+                       ACE_TEXT ("read")),
+                      -1);
+  n -= (2 * sizeof (int));
+  char *buf = this->buf_ + (2 * sizeof (int));
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) reading <%d> = %*C\n"),
+              this->handle_,
+              n,
+              buf));
+#endif /* ACE_HAS_STREAM_PIPES */
+  return 0;
+}
+
+int
+Ping_Pong::handle_output (ACE_HANDLE)
+{
+#if defined (ACE_HAS_STREAM_PIPES)
+  // We can rely on record-oriented reads...
+
+  (*(int *) (this->buf_)) = this->pid_;
+  (*(int *) (this->buf_ + sizeof (int)))++;
+  if (ACE::send (this->handle_,
+                 this->buf_,
+                 this->buflen_) == -1)
+    return -1;
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("(%P|%t) writing <%d> [%d]\n"),
+                  this->handle_,
+                  this->pid_));
+      return 0;
+    }
+#else
+  if (ACE::send (this->handle_,
+                 this->buf_,
+                 this->buflen_) == -1)
+    return -1;
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("(%P|%t) writing <%d>\n"),
+                  this->handle_));
+      return 0;
+    }
+#endif /* ACE_HAS_STREAM_PIPES */
+}
+
+int
+Ping_Pong::handle_timeout (const ACE_Time_Value &,
+                           const void *)
+{
+  this->set (1);
+  return 0;
+}
+
+// Contains the string to "pingpong" back and forth...
+static ACE_TCHAR *string_name;
+
+// Wait for 10 seconds and then shut down.
+static const ACE_Time_Value SHUTDOWN_TIME (10);
+
+static void
+run_svc (ACE_HANDLE handle)
+{
+  Ping_Pong *callback = 0;
+  ACE_NEW (callback,
+           Ping_Pong (ACE_TEXT_ALWAYS_CHAR (string_name),
+                      handle));
+
+  ACE_Reactor reactor;
+
+  // Register the callback object for the various I/O, signal, and
+  // timer-based events.
+
+  if (reactor.register_handler (callback,
+                                ACE_Event_Handler::READ_MASK
+                                | ACE_Event_Handler::WRITE_MASK) == -1
+#if !defined (CHORUS)
+      || reactor.register_handler (SIGINT,
+                                   callback) == -1
+#endif /* CHORUS */
+      || reactor.schedule_timer (callback,
+                                 0,
+                                 SHUTDOWN_TIME) == -1)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("%p\n"),
+                  ACE_TEXT ("reactor")));
+      ACE_OS::exit (1);
+    }
+
+  // Main event loop (one per process).
+
+  while (callback->is_set () == 0)
+    if (reactor.handle_events () == -1)
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("%p\n"),
+                  ACE_TEXT ("handle_events")));
+}
+
+#if defined (ACE_WIN32) || defined (CHORUS)
+static ACE_Barrier barrier (3);
+
+static void *
+worker (void *arg)
+{
+  ACE_HANDLE handle = (ACE_HANDLE) arg;
+
+  run_svc (handle);
+
+  // Wait for the threads to exit.
+  barrier.wait ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) %n: shutting down tester\n")));
+  return 0;
+}
+#endif /* ACE_WIN32 */
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  if (argc != 2)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ACE_TEXT ("usage: pingpong <string>\n")),
+                       -1);
+
+  ACE_LOG_MSG->open (argv[0]);
+
+  string_name = argv[1];
+
+  ACE_HANDLE handles[2];
+
+  // Create a pipe and initialize the handles.
+  ACE_Pipe pipe (handles);
+
+#if defined (ACE_WIN32) || defined (CHORUS)
+  if (ACE_Thread::spawn (ACE_THR_FUNC (worker),
+                         (void *) handles[0],
+                         THR_DETACHED) == -1
+      || ACE_Thread::spawn (ACE_THR_FUNC (worker),
+                            (void *) handles[1],
+                            THR_DETACHED) == -1)
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("%p\n%a"),
+                  ACE_TEXT ("spawn"),
+                  1));
+  barrier.wait ();
+#else
+  pid_t pid = ACE_OS::fork (argv[0]);
+
+  if (pid == -1)
+    ACE_ERROR ((LM_ERROR,
+                ACE_TEXT ("%p\n%a"),
+                ACE_TEXT ("fork"),
+                1));
+  run_svc (handles[pid == 0]);
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) %n: shutting down tester\n")));
+#endif /* ACE_WIN32 */
+
+  if (pipe.close () == -1)
+    ACE_ERROR ((LM_ERROR,
+                ACE_TEXT ("%p\n"),
+                ACE_TEXT ("close")));
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Misc/test_demuxing.cpp b/ACE/examples/Reactor/Misc/test_demuxing.cpp
new file mode 100644
index 00000000000..6badd849757
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_demuxing.cpp
@@ -0,0 +1,384 @@
+// $Id$
+
+// Perform an extensive test of all the ACE_Reactor's event handler
+// dispatching mechanisms.  These mechanisms illustrate how I/O,
+// timeout, and signal events, as well as ACE_Message_Queues, can all
+// be handled within the same demultiplexing and dispatching
+// framework.  In addition, this example illustrates how to use the
+// ACE_Reactor for devices that perform I/O via signals (such as SVR4
+// message queues).
+
+#include "ace/ACE.h"
+#include "ace/Service_Config.h"
+#include "ace/Reactor.h"
+#include "ace/Task.h"
+#include "ace/Reactor_Notification_Strategy.h"
+#include "ace/Signal.h"
+#include "ace/OS_NS_fcntl.h"
+#include "ace/OS_NS_unistd.h"
+
+ACE_RCSID(Misc, test_demuxing, "$Id$")
+
+// Default is to have a 2 second timeout.
+static int timeout = 2;
+
+class Sig_Handler : public ACE_Event_Handler
+{
+  // = TITLE
+  //   This class illustrates how to handle signal-driven I/O using
+  //   the <ACE_Reactor> framework.  Note that signals may be caught
+  //   and processed without requiring the use of global signal
+  //   handler functions or global signal handler data.
+public:
+  Sig_Handler (void);
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE);
+  virtual int shutdown (ACE_HANDLE, ACE_Reactor_Mask);
+  virtual int handle_signal (int signum, siginfo_t * = 0,
+                             ucontext_t * = 0);
+
+private:
+  ACE_HANDLE handle_;
+};
+
+// A dummy_handle is required to reserve a slot in the ACE_Reactor's
+// descriptor table.
+
+Sig_Handler::Sig_Handler (void)
+{
+  // Assign the Sig_Handler a dummy I/O descriptor.  Note that even
+  // though we open this file "Write Only" we still need to use the
+  // ACE_Event_Handler::NULL_MASK when registering this with the
+  // ACE_Reactor (see below).
+  this->handle_ = ACE_OS::open (ACE_DEV_NULL, O_WRONLY);
+  ACE_ASSERT (this->handle_ != ACE_INVALID_HANDLE);
+
+  // Register signal handler object.  Note that NULL_MASK is used to
+  // keep the ACE_Reactor from calling us back on the "/dev/null"
+  // descriptor.  NULL_MASK just reserves a "slot" in the Reactor's
+  // internal demuxing table, but doesn't cause it to dispatch the
+  // event handler directly.  Instead, we use the signal handler to do
+  // this.
+  ACE_Reactor_Mask mask = ACE_Event_Handler::NULL_MASK;
+  if (ACE_Reactor::instance ()->register_handler
+      (this,
+       mask) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n%a",
+                "register_handler",
+                1));
+
+  // Create a sigset_t corresponding to the signals we want to catch.
+  ACE_Sig_Set sig_set;
+
+  sig_set.sig_add (SIGINT);
+  sig_set.sig_add (SIGQUIT);
+  sig_set.sig_add (SIGALRM);
+
+  // Register the signal handler object to catch the signals.
+  if (ACE_Reactor::instance ()->register_handler
+      (sig_set, this) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n%a",
+                "register_handler",
+                1));
+}
+
+// Called by the ACE_Reactor to extract the handle.
+
+ACE_HANDLE
+Sig_Handler::get_handle (void) const
+{
+  return this->handle_;
+}
+
+// In a real application, this method would be where the read on the
+// signal-driven I/O device would occur asynchronously.  For now we'll
+// just print a greeting to let you know that everything is working
+// properly!
+
+int
+Sig_Handler::handle_input (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) handling asynchonrous input...\n"));
+  return 0;
+}
+
+// In a real application, this method would do any cleanup activities
+// required when shutting down the I/O device.
+
+int
+Sig_Handler::shutdown (ACE_HANDLE, ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) closing down Sig_Handler...\n"));
+  return 0;
+}
+
+// This method handles all the signals that are being caught by this
+// object.  In our simple example, we are simply catching SIGALRM,
+// SIGINT, and SIGQUIT.  Anything else is logged and ignored.  Note
+// that the ACE_Reactor's signal handling mechanism eliminates the
+// need to use global signal handler functions and data.
+
+int
+Sig_Handler::handle_signal (int signum, siginfo_t *, ucontext_t *)
+{
+  switch (signum)
+    {
+#if !defined (ACE_WIN32)
+    case SIGALRM:
+      // Rearm the alarm.
+      ACE_OS::alarm (4);
+      break;
+#endif /* !ACE_WIN32 */
+    case SIGINT:
+      // Tell the ACE_Reactor to enable the ready bit for
+      // this->handle_.  The ACE_Reactor will subsequently call the
+      // <Sig_Handler::handle_input> method from within its event
+      // loop, i.e., the behavior triggered by the signal is handled
+      // in the main event loop, rather than in the signal handler.
+      return ACE_Reactor::instance ()->ready_ops
+        (this->handle_,
+         ACE_Event_Handler::READ_MASK,
+         ACE_Reactor::ADD_MASK);
+#if defined (ACE_WIN32)
+    case SIGTERM:
+#else
+    case SIGQUIT:
+#endif /* ACE_WIN32 */
+      ACE_Reactor::end_event_loop ();
+      break;
+    default:
+      ACE_ERROR_RETURN ((LM_ERROR, "invalid signal"), -1);
+      break;
+      /* NOTREACHED */
+    }
+  return 0;
+}
+
+class STDIN_Handler : public ACE_Event_Handler
+{
+  // = TITLE
+  //   This class illustrates that the ACE_Reactor can handle signals,
+  //   STDIO, and timeouts using the same mechanisms.
+public:
+  STDIN_Handler (void);
+  ~STDIN_Handler (void);
+  virtual int handle_input (ACE_HANDLE);
+  virtual int handle_timeout (const ACE_Time_Value &,
+                              const void *arg);
+};
+
+STDIN_Handler::STDIN_Handler (void)
+{
+  if (ACE_Event_Handler::register_stdin_handler (this,
+                                                 ACE_Reactor::instance (),
+                                                 ACE_Thread_Manager::instance ()) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "register_stdin_handler"));
+
+  // Register the <STDIN_Handler> to be dispatched once every
+  // <timeout> seconds starting in <timeout> seconds.  This example
+  // uses the "interval timer" feature of the <ACE_Reactor>'s timer
+  // queue.
+  else if (ACE_Reactor::instance ()->schedule_timer
+           (this,
+            0,
+            ACE_Time_Value (timeout),
+            ACE_Time_Value (timeout)) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n%a",
+                "schedule_timer",
+                1));
+}
+
+STDIN_Handler::~STDIN_Handler (void)
+{
+  if (ACE_Event_Handler::remove_stdin_handler (ACE_Reactor::instance (),
+                                               ACE_Thread_Manager::instance ()) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "remove_stdin_handler"));
+  else if (ACE_Reactor::instance ()->cancel_timer
+           (this) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n%a",
+                "cancel_timer",
+                1));
+}
+
+int
+STDIN_Handler::handle_timeout (const ACE_Time_Value &tv,
+                               const void *)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) timeout occurred at %d sec, %d usec\n",
+              tv.sec (),
+              tv.usec ()));
+  return 0;
+}
+
+// Read from input handle and write to stdout handle.
+
+int
+STDIN_Handler::handle_input (ACE_HANDLE handle)
+{
+  char buf[BUFSIZ];
+  ssize_t n = ACE_OS::read (handle, buf, sizeof buf);
+
+  switch (n)
+    {
+    case -1:
+      if (errno == EINTR)
+        return 0;
+        /* NOTREACHED */
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "%p\n",
+                    "read"));
+      /* FALLTHROUGH */
+    case 0:
+      ACE_Reactor::end_event_loop ();
+      break;
+    default:
+      {
+        ssize_t result = ACE::write_n (ACE_STDOUT, buf, n);
+
+        if (result != n)
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "%p\n",
+                             "write"),
+                            result == -1 && errno == EINTR ? 0 : -1);
+      }
+    }
+  return 0;
+}
+
+class Message_Handler : public ACE_Task <ACE_SYNCH>
+{
+public:
+  Message_Handler (void);
+
+  virtual int handle_input (ACE_HANDLE);
+  // Called back within the context of the <ACE_Reactor> Singleton to
+  // dequeue and process the message on the <ACE_Message_Queue>.
+
+  virtual int svc (void);
+  // Run the "event-loop" periodically putting messages to our
+  // internal <Message_Queue> that we inherit from <ACE_Task>.
+
+private:
+  ACE_Reactor_Notification_Strategy notification_strategy_;
+  // This strategy will notify the <ACE_Reactor> Singleton when a new
+  // message is enqueued.
+};
+
+Message_Handler::Message_Handler (void)
+  : notification_strategy_ (ACE_Reactor::instance (),
+                            this,
+                            ACE_Event_Handler::READ_MASK)
+{
+  // Set this to the Reactor notification strategy.
+  this->msg_queue ()->notification_strategy (&this->notification_strategy_);
+
+  if (this->activate ())
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "activate"));
+}
+
+int
+Message_Handler::svc (void)
+{
+  for (int i = 0;; i++)
+    {
+      ACE_Message_Block *mb;
+
+      ACE_NEW_RETURN (mb,
+                      ACE_Message_Block (1),
+                      0);
+
+      mb->msg_priority (i);
+      ACE_OS::sleep (1);
+
+      // Note that this putq() call with automagically invoke the
+      // notify() hook of our ACE_Reactor_Notification_Strategy,
+      // thereby informing the <ACE_Reactor> Singleton to call our
+      // <handle_input> method.
+      if (this->putq (mb) == -1)
+        {
+          if (errno == ESHUTDOWN)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "(%t) queue is deactivated"), 0);
+          else
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "(%t) %p\n",
+                               "putq"),
+                              -1);
+        }
+    }
+
+  ACE_NOTREACHED (return 0);
+}
+
+int
+Message_Handler::handle_input (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) Message_Handler::handle_input\n"));
+
+  ACE_Message_Block *mb;
+
+  if (this->getq (mb, (ACE_Time_Value *) &ACE_Time_Value::zero) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "(%t) %p\n",
+                "dequeue_head"));
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%t) priority = %d\n",
+                  mb->msg_priority ()));
+      mb->release ();
+    }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Service_Config daemon (argv [0]);
+
+  // Optionally start the alarm.
+  if (argc > 1)
+    {
+      ACE_OS::alarm (4);
+      timeout = ACE_OS::atoi (argv[1]);
+    }
+
+  // Signal handler.
+  Sig_Handler sh;
+
+  // Define an I/O handler object.
+  STDIN_Handler ioh;
+
+  // Define a message handler.
+  Message_Handler mh;
+
+  // Loop handling signals and I/O events until SIGQUIT occurs.
+
+  while (ACE_Reactor::instance ()->event_loop_done () == 0)
+    ACE_Reactor::instance ()->run_reactor_event_loop ();
+
+  // Deactivate the message queue.
+  mh.msg_queue ()->deactivate ();
+
+  // Wait for the thread to exit.
+  ACE_Thread_Manager::instance ()->wait ();
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%t) leaving main\n")));
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Misc/test_early_timeouts.cpp b/ACE/examples/Reactor/Misc/test_early_timeouts.cpp
new file mode 100644
index 00000000000..4c7193d9a67
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_early_timeouts.cpp
@@ -0,0 +1,114 @@
+// $Id$
+
+// ================================================================
+//
+// = LIBRARY
+//    examples/Reactor/Misc/
+//
+// = FILENAME
+//    test_early_timeouts.cpp
+//
+// = DESCRIPTION
+//    On some platforms, select() returns before the time value
+//    specified.  This tests counts the number of times this happens
+//    and the max early timeout.
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ================================================================
+
+#include "ace/Handle_Set.h"
+#include "ace/Pipe.h"
+#include "ace/Log_Msg.h"
+#include "ace/Time_Value.h"
+#include "ace/OS_NS_sys_time.h"
+#include "ace/OS_NS_sys_select.h"
+
+ACE_RCSID(Misc, test_early_timeouts, "$Id$")
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  // Mumber of seconds this test should run
+  int runtime_in_seconds = 10;
+
+  // Iterations
+  int iterations = runtime_in_seconds * 10;
+
+  // 100 millisecond timeout
+  ACE_Time_Value timeout (0, 100000);
+
+  // Time before starting select
+  ACE_Time_Value starting_time_of_day;
+
+  // Time before starting select
+  ACE_Time_Value ending_time_of_day;
+
+  // Number of times the timer expired early
+  int no_of_early_timers = 0;
+
+  // Maximum early timeout
+  ACE_Time_Value maximum_early_timeout;
+
+  //
+  // Dummy handle and handle set
+  // Note that some OS do not like "empty selects"
+  //
+
+  // Dummy handle set
+  ACE_Handle_Set dummy_handle_set;
+
+  // Dummy pipe
+  ACE_Pipe dummy_pipe;
+  int result = dummy_pipe.open ();
+  ACE_ASSERT (result == 0);
+  ACE_UNUSED_ARG (result); // To avoid compile warning with ACE_NDEBUG.
+
+  for (int i = 1; i <= iterations; i++)
+    {
+      // Add dummy handle to dummy set
+      dummy_handle_set.set_bit (dummy_pipe.read_handle ());
+
+      // Note the time before select
+      starting_time_of_day = ACE_OS::gettimeofday ();
+
+      // Wait for timeout
+      result = ACE_OS::select ((int) dummy_pipe.read_handle (), dummy_handle_set, 0, 0, &timeout);
+      ACE_ASSERT (result == 0);
+
+      // Note the time after select
+      ending_time_of_day = ACE_OS::gettimeofday ();
+
+      // Expected ending time
+      ACE_Time_Value expected_ending_time_of_day =
+        starting_time_of_day + timeout;
+
+      // If the timer expired early
+      if (ending_time_of_day < expected_ending_time_of_day)
+        {
+          // How early
+          ACE_Time_Value early_timeout = expected_ending_time_of_day - ending_time_of_day;
+
+          // Increment number of early timers
+          no_of_early_timers++;
+
+          // Check max early timeout
+          if (early_timeout > maximum_early_timeout)
+            {
+              maximum_early_timeout = early_timeout;
+            }
+        }
+    }
+
+  ACE_DEBUG ((LM_DEBUG,
+              "There were %d early timers out of %d calls to select() (%f%%)\n"
+              "The max early timeout was: %dsec %dusec\n",
+              no_of_early_timers,
+              iterations,
+              float (no_of_early_timers) / iterations * 100,
+              maximum_early_timeout.sec (),
+              maximum_early_timeout.usec ()));
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Misc/test_event_handler_t.cpp b/ACE/examples/Reactor/Misc/test_event_handler_t.cpp
new file mode 100644
index 00000000000..4261859784e
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_event_handler_t.cpp
@@ -0,0 +1,47 @@
+// $Id$
+
+#include "ace/Event_Handler_T.h"
+#include "ace/Log_Msg.h"
+
+ACE_RCSID(Misc, test_event_handler_t, "$Id$")
+
+#if defined (ACE_HAS_TEMPLATE_TYPEDEFS)
+
+class ACE_Test_Sig_Handler
+{
+public:
+  ACE_Test_Sig_Handler (void) {}
+  virtual ~ACE_Test_Sig_Handler (void) {}
+  virtual ACE_HANDLE get_handle (void) const { return 0; }
+  virtual void set_handle (ACE_HANDLE) {}
+  virtual int handle_async_io (ACE_HANDLE) { return 0; }
+  virtual int shutdown (ACE_HANDLE, ACE_Reactor_Mask) { return 0; }
+  virtual int signal_handler (int /* signum */,
+                              siginfo_t * = 0,
+                              ucontext_t * = 0)
+  {
+    return 0;
+  }
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  typedef ACE_Event_Handler_T<ACE_Test_Sig_Handler> EH_SH;
+
+  // Tie the ACE_Event_Handler_T together with the methods from ACE_Test_Sig_Handler.
+  EH_SH tied_sh (new ACE_Test_Sig_Handler, 1,
+                 &ACE_Test_Sig_Handler::get_handle,
+                 &ACE_Test_Sig_Handler::handle_async_io,
+                 &ACE_Test_Sig_Handler::shutdown,
+                 &ACE_Test_Sig_Handler::signal_handler);
+  return 0;
+}
+
+#else
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_ERROR_RETURN ((LM_ERROR, "your platform does not support template typedefs\n"), 1);
+}
+#endif /* ACE_HAS_TEMPLATE_TYPEDEFS */
diff --git a/ACE/examples/Reactor/Misc/test_reactors.cpp b/ACE/examples/Reactor/Misc/test_reactors.cpp
new file mode 100644
index 00000000000..a08580672e0
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_reactors.cpp
@@ -0,0 +1,195 @@
+// $Id$
+
+// Perform a torture test of multiple ACE_Reactors and ACE_Tasks in
+// the same process...  Thanks to Detlef Becker for contributing this.
+
+#include "ace/Reactor.h"
+#include "ace/Service_Config.h"
+#include "ace/Task.h"
+#include "ace/Atomic_Op.h"
+
+ACE_RCSID(Misc, test_reactors, "$Id$")
+
+#if defined (ACE_HAS_THREADS)
+
+#include "ace/Recursive_Thread_Mutex.h"
+
+static const int NUM_INVOCATIONS = 10;
+static const int MAX_TASKS = 20;
+
+class Test_Task : public ACE_Task<ACE_MT_SYNCH>
+{
+public:
+  Test_Task (void);
+  ~Test_Task (void);
+
+  virtual int open (void *args = 0);
+  virtual int close (u_long flags = 0);
+  virtual int svc (void);
+
+  virtual int handle_input (ACE_HANDLE handle);
+  virtual int handle_close (ACE_HANDLE fd,
+                            ACE_Reactor_Mask close_mask);
+
+private:
+  int handled_;
+
+  static int task_count_;
+};
+
+int Test_Task::task_count_ = 0;
+
+static ACE_Atomic_Op<ACE_Thread_Mutex, int> done_count = MAX_TASKS * 2;
+
+static ACE_Recursive_Thread_Mutex reclock_;
+
+Test_Task::Test_Task (void)
+  : handled_ (0)
+{
+  ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, reclock_);
+
+  Test_Task::task_count_++;
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) TT+ Test_Task::task_count_ = %d\n",
+              Test_Task::task_count_));
+}
+
+Test_Task::~Test_Task (void)
+{
+  ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, reclock_);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) TT- Test_Task::task_count_ = %d\n",
+              Test_Task::task_count_));
+}
+
+int
+Test_Task::open (void *args)
+{
+  this->reactor ((ACE_Reactor *) args);
+  return this->activate (THR_NEW_LWP);
+}
+
+int
+Test_Task::close (u_long)
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, reclock_, -1);
+
+  Test_Task::task_count_--;
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) close Test_Task::task_count_ = %d\n",
+              Test_Task::task_count_));
+  return 0;
+}
+
+int
+Test_Task::svc (void)
+{
+  for (int i = 0; i < NUM_INVOCATIONS; i++)
+    {
+      ACE_OS::thr_yield ();
+
+      // ACE_DEBUG ((LM_DEBUG, "(%t) calling notify %d\n", i));
+
+      if (this->reactor ()->notify (this, ACE_Event_Handler::READ_MASK) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "(%t) %p\n", "notify"), -1);
+
+      // ACE_DEBUG ((LM_DEBUG, "(%t) leaving notify %d\n", i));
+    }
+
+  return 0;
+}
+
+int
+Test_Task::handle_close (ACE_HANDLE,
+                         ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) handle_close\n"));
+  return 0;
+}
+
+int
+Test_Task::handle_input (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) handle_input\n"));
+
+  this->handled_++;
+
+  if (this->handled_ == NUM_INVOCATIONS)
+    {
+      done_count--;
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%t) handle_input, handled_ = %d, done_count = %d\n",
+                  this->handled_, done_count.value ()));
+    }
+
+  ACE_OS::thr_yield ();
+  return -1;
+}
+
+static void *
+worker (void *args)
+{
+  ACE_Reactor *reactor = (ACE_Reactor *) args;
+
+  reactor->owner (ACE_Thread::self ());
+
+  ACE_Time_Value timeout (4);
+
+  for (;;)
+    {
+      //ACE_DEBUG ((LM_DEBUG, "(%t) calling handle_events\n"));
+
+      switch (reactor->handle_events (timeout))
+        {
+        case -1:
+          ACE_ERROR_RETURN ((LM_ERROR, "(%t) %p\n", "reactor"), 0);
+          /* NOTREACHED */
+        case 0:
+          ACE_ERROR_RETURN ((LM_ERROR, "(%t) timeout\n"), 0);
+          /* NOTREACHED */
+        }
+
+      // ACE_DEBUG ((LM_DEBUG, "(%t) done with handle_events\n"));
+
+    }
+
+  ACE_NOTREACHED(return 0);
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_Reactor *react1 = ACE_Reactor::instance ();
+  ACE_Reactor *react2 = new ACE_Reactor ();
+  Test_Task tt1[MAX_TASKS];
+  Test_Task tt2[MAX_TASKS];
+
+  for (int i = 0; i < MAX_TASKS; i++)
+    {
+      tt1[i].open (react1);
+      tt2[i].open (react2);
+    }
+
+  if (ACE_Thread_Manager::instance ()->spawn
+      (ACE_THR_FUNC (worker), (void *) react1, THR_NEW_LWP) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);
+
+  else if (ACE_Thread_Manager::instance ()->spawn
+      (ACE_THR_FUNC (worker), (void *) react2, THR_NEW_LWP) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);
+
+  ACE_Thread_Manager::instance ()->wait ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) done\n"));
+
+  return 0;
+}
+
+#else
+int
+main (int, char *[])
+{
+  ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
+  return 0;
+}
+#endif /* ACE_HAS_THREADS */
diff --git a/ACE/examples/Reactor/Misc/test_signals_1.cpp b/ACE/examples/Reactor/Misc/test_signals_1.cpp
new file mode 100644
index 00000000000..b0410f572c1
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_signals_1.cpp
@@ -0,0 +1,114 @@
+// $Id$
+
+// This simple program illustrates the difference between handling
+// signals via the Reactor (which doesn't cause the event loop to
+// terminate) and signals that aren't handled via the Reactor (which
+// do).
+
+#include "ace/Service_Config.h"
+#include "ace/Reactor.h"
+#include "ace/Log_Msg.h"
+#include "ace/Signal.h"
+
+ACE_RCSID(Misc, test_signals_1, "$Id$")
+
+// Number of times to allow signal to execute until we quit.
+static size_t count = 10;
+
+static void
+my_signal_function (int sig)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "Executed non-ACE signal handler for signal %S\n",
+              sig));
+}
+
+class My_Handler : public ACE_Event_Handler
+{
+public:
+  virtual int handle_signal (int sig,
+			     siginfo_t *,
+			     ucontext_t *)
+  {
+    // @@ Note that this code is not portable to all OS platforms
+    // since it uses print statements within signal handler context.
+    ACE_DEBUG ((LM_DEBUG,
+                "Executed ACE signal handler for signal %S, count = %d\n",
+		sig,
+                count));
+    count--;
+
+    if (count == 0)
+      ACE_Reactor::end_event_loop ();
+
+    return 0;
+  }
+
+  virtual int handle_timeout (const ACE_Time_Value &,
+			      const void *arg)
+  {
+    ACE_DEBUG ((LM_DEBUG,
+                "%s\n",
+                (const char *) arg));
+    return 0;
+  }
+};
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  // First you need a handler for the timeout.
+  My_Handler my_handler;
+
+  // This is the timeout period in seconds.
+  ACE_Time_Value period (ACE_DEFAULT_TIMEOUT);
+
+  if (argc > 1)
+    period.set (ACE_OS::atoi (argv[1]), 0);
+
+  // Set up the periodic interval timer.
+  if (ACE_Reactor::instance ()->schedule_timer
+      (&my_handler,
+       "hello",
+       period,
+       period) == -1)
+    ACE_ERROR_RETURN ((LM_DEBUG,
+                       "%p\n",
+                       "schedule_timer"),
+                      -1);
+
+  // Set up an ACE signal handler.
+
+  if (ACE_Reactor::instance ()->register_handler
+      (SIGINT,
+       &my_handler) == -1)
+    ACE_ERROR_RETURN ((LM_DEBUG,
+                       "%p\n",
+                       "register_handler"),
+                      -1);
+
+  // Set up a non-ACE signal handler.  When this goes off, the Reactor
+  // should return from its <run_event_loop> method.
+  ACE_Sig_Action sig ((ACE_SignalHandler) my_signal_function,
+                      SIGQUIT);
+  ACE_UNUSED_ARG (sig);
+
+  ACE_DEBUG ((LM_DEBUG,
+	      "starting event loop that runs until you've typed ^C a total of 10 times or ^\\ once.\n"));
+
+  // This call executes the reactor events until we're finished.
+  int result = ACE_Reactor::run_event_loop ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              "result = %d\n",
+              result));
+
+  // Make sure to remove my_handler before exiting main() since
+  // otherwise weird things can happen...
+  if (ACE_Reactor::instance ()->cancel_timer (&my_handler) == -1)
+    ACE_ERROR_RETURN ((LM_DEBUG,
+                       "%p\n",
+                       "cancel_timer"),
+                      -1);
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Misc/test_signals_2.cpp b/ACE/examples/Reactor/Misc/test_signals_2.cpp
new file mode 100644
index 00000000000..466ab58482f
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_signals_2.cpp
@@ -0,0 +1,291 @@
+// $Id$
+
+// Test the ability of the Reactor/Signal_Handler to register multiple
+// handler per-signal.
+
+/* This test works as follows:
+
+	1. To test the "original" semantics of ACE (i.e., only one
+	   ACE_Event_Handler can be registered per signal), you don't
+	   need to do anything special.  Existing programs work the
+	   same since giving the Reactor's constructor a 0 value
+	   (which is the default argument, BTW) instructs it to behave
+	   as before.  When a 0 is given, the ACE_Reactor's
+	   constructor/open method creates an instance of
+	   ACE_Sig_Handler and assigns this to an internal pointer.
+	   This pointer is then used to dispatch all signal-related
+	   methods within the Reactor.  The default ACE_Sig_Handler
+	   only allows *one* ACE_Event_Handler to be registered
+	   per-signal.
+
+	   To run this version of the test do the following:
+
+	   % ./test-signal
+	   ./test_signals
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 0, 0) with count = 1
+	   waiting for SIGINT or SIGQUIT
+	   ^\
+	   signal Quit occurred in Sig_Handler_2 (fruity, 0, 0) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_2 (fruity, 0, 0)
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 0, 0) with count = 3
+	   waiting for SIGINT or SIGQUIT
+	   ^\Quit (core dumped)
+
+           Note that in this test only one handler (the last one --
+	   "Sig_Handler_2 (fruity)") is actually registered.  BTW, the
+	   core dump is the expected behavior since the default
+	   disposition is restored when there are no more handlers
+	   (see the code below).
+
+	2. To test the "multiple handlers per-signal semantics", you
+	   need to pass the constructor/open method of the ACE_Reactor
+	   a pointer to a an instance of ACE_Sig_Handlers (note the
+	   plural "s").  ACE_Sig_Handlers is a class that derives from
+	   ACE_Sig_Handler.  The difference between these two classes
+	   is that (1) ACE_Sig_Handlers::register_signal allows
+	   multiple ACE_Event_Handlers to be registered per-signal and
+	   (2) it enables SA_RESTART by default.  This class also
+	   implements Detlef Becker's algorithm for integrating ACE
+	   signal handling with 3rd party libraries.
+
+	   To run this version of the test do the following:
+
+	   % ./test_signals 1
+
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in external handler!
+	   signal Interrupt occurred in Sig_Handler_1 (howdy, 3, 1) with count = 1
+	   shutting down SIGINT in Sig_Handler_1 (howdy, 3, 1)
+	   signal Interrupt occurred in Sig_Handler_1 (doody, 5, 4) with count = 1
+	   shutting down SIGINT in Sig_Handler_1 (doody, 5, 4)
+	   signal Interrupt occurred in Sig_Handler_2 (tutty, 7, 6) with count = 1
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 9, 8) with count = 1
+	   waiting for SIGINT or SIGQUIT
+	   ^\
+	   signal Quit occurred in Sig_Handler_1 (howdy, 3, 1) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_1 (howdy, 3, 1)
+	   signal Quit occurred in Sig_Handler_1 (doody, 5, 4) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_1 (doody, 5, 4)
+	   signal Quit occurred in Sig_Handler_2 (tutty, 7, 6) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_2 (tutty, 7, 6)
+	   signal Quit occurred in Sig_Handler_2 (fruity, 9, 8) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_2 (fruity, 9, 8)
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in external handler!
+	   signal Interrupt occurred in Sig_Handler_2 (tutty, 7, 6) with count = 3
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 9, 8) with count = 3
+	   waiting for SIGINT or SIGQUIT
+	   ^\Quit (core dumped)
+
+           When this test begins all four handlers are registered and
+           dispatched when a SIGINT or SIGQUIT occurs.  After the
+           first SIGINT, the handle_signal method of the Sig_Handler_1
+           objects unregister themselves.  At that point there are 4
+           SIGQUIT handlers left, but only 2 of our SIGINT handlers
+           left (and the 1 external handler).  After the first
+           SIGQUIT, there are no SIGQUIT handlers left since they all
+           deregister themselves (which restores the "SIG_DFL"
+           disposition).  On the second SIGINT there are only 3
+           handlers left (2 of ours and 1 external).  Finally, on the
+           second SIGQUIT we exit and dump core since that's what
+           happens with the default disposition for SIGQUIT. */
+
+
+#include "ace/Reactor.h"
+#include "ace/WFMO_Reactor.h"
+#include "ace/Select_Reactor.h"
+#include "ace/Log_Msg.h"
+#include "ace/Signal.h"
+
+ACE_RCSID(Misc, test_signals_2, "$Id$")
+
+class Sig_Handler_1 : public ACE_Event_Handler
+{
+public:
+  Sig_Handler_1 (ACE_Reactor &reactor, const char *msg)
+    : msg_ (msg),
+      count_ (0),
+      reactor_ (reactor)
+  {
+    // Register the signal handlers.
+    this->quit_sigkey_ =
+      reactor.register_handler (SIGQUIT, this);
+    this->int_sigkey_ =
+      reactor.register_handler (SIGINT, this);
+
+    if (this->quit_sigkey_ == -1 || this->int_sigkey_ == -1)
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "register_handler"));
+  }
+
+  // @@ Note that this code is not portable to all OS platforms since
+  // it does print statements within the signal handler.
+  virtual int handle_signal (int signum,
+                             siginfo_t *,
+                             ucontext_t *)
+  {
+    this->count_++;
+    ACE_DEBUG ((LM_DEBUG,
+	       "\nsignal %S occurred in Sig_Handler_1 (%s, %d, %d) with count = %d",
+	       signum,
+                this->msg_,
+                this->int_sigkey_,
+                this->quit_sigkey_,
+                this->count_));
+
+    if (this->count_ != 1 && signum == SIGQUIT)
+      {
+	if (this->reactor_.remove_handler (SIGQUIT,
+                                           0,
+                                           0,
+					   this->quit_sigkey_) == -1)
+	  ACE_ERROR ((LM_ERROR,
+                      "\n%p",
+                      "remove_handler"));
+	else
+	  ACE_DEBUG ((LM_DEBUG,
+                      "\nshutting down SIGQUIT in Sig_Handler_1 (%s, %d, %d)",
+                      this->msg_,
+                      this->int_sigkey_,
+                      this->quit_sigkey_));
+      }
+    else if (this->count_ != 2 && signum == SIGINT)
+      {
+	if (this->reactor_.remove_handler (SIGINT,
+                                           0,
+                                           0,
+					   this->int_sigkey_) == -1)
+	  ACE_ERROR ((LM_ERROR,
+                      "\n%p",
+                      "remove_handler"));
+	else
+	  ACE_DEBUG ((LM_DEBUG,
+                      "\nshutting down SIGINT in Sig_Handler_1 (%s, %d, %d)",
+		     this->msg_,
+                      this->int_sigkey_,
+                      this->quit_sigkey_));
+      }
+    return 0;
+  }
+
+protected:
+  const char *msg_;
+  int count_;
+  int int_sigkey_;
+  int quit_sigkey_;
+  ACE_Reactor &reactor_;
+};
+
+class Sig_Handler_2 : public Sig_Handler_1
+{
+public:
+  Sig_Handler_2 (ACE_Reactor &reactor, const char *msg)
+    : Sig_Handler_1 (reactor, msg)
+  {
+  }
+
+  virtual int handle_signal (int signum,
+                             siginfo_t *,
+                             ucontext_t *)
+  {
+    this->count_++;
+    ACE_DEBUG ((LM_DEBUG,
+	       "\nsignal %S occurred in Sig_Handler_2 (%s, %d, %d) with count = %d",
+	       signum,
+                this->msg_,
+                this->int_sigkey_,
+                this->quit_sigkey_,
+                this->count_));
+    if (this->count_ != 0 && signum == SIGQUIT)
+      {
+	if (this->reactor_.remove_handler (SIGQUIT, 0, 0,
+					   this->quit_sigkey_) == -1)
+	  ACE_ERROR ((LM_ERROR,
+                      "\n%p",
+                      "remove_handler"));
+	else
+	  ACE_DEBUG ((LM_DEBUG,
+                      "\nshutting down SIGQUIT in Sig_Handler_2 (%s, %d, %d)",
+                      this->msg_,
+                      this->int_sigkey_,
+                      this->quit_sigkey_));
+      }
+    return 0;
+  }
+};
+
+static void
+external_handler (int signum)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "\nsignal %S occurred in external handler!",
+              signum));
+}
+
+#if !defined (HPUX)
+int
+ACE_TMAIN (int argc, ACE_TCHAR *[])
+{
+  // If argc > 1 then allow multiple handlers per-signal, else just
+  // allow 1 handler per-signal.
+  ACE_Sig_Handlers multi_handlers;
+
+#if defined (ACE_WIN32)
+  ACE_WFMO_Reactor reactor_impl (argc > 1
+                                 ? &multi_handlers
+                                 : (ACE_Sig_Handler *) 0);
+#else
+  ACE_Select_Reactor reactor_impl (argc > 1
+                                   ? &multi_handlers
+                                   : (ACE_Sig_Handler *) 0);
+#endif /* ACE_WIN32 */
+  ACE_Reactor reactor (&reactor_impl);
+
+  if (argc > 1)
+    {
+      // Register an "external" signal handler so that the
+      // ACE_Sig_Handlers code will have something to incorporate!
+
+      ACE_SignalHandler eh = (ACE_SignalHandler) external_handler;
+      ACE_Sig_Action sa (eh);
+
+      sa.register_action (SIGINT);
+    }
+
+  // Create a bevy of handlers.
+  Sig_Handler_1 h1 (reactor, "howdy");
+  Sig_Handler_1 h2 (reactor, "doody");
+  Sig_Handler_2 h3 (reactor, "tutty");
+  Sig_Handler_2 h4 (reactor, "fruity");
+
+  // Wait for user to type SIGINT and SIGQUIT.
+
+  for (;;)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "\nwaiting for SIGINT or SIGQUIT\n"));
+
+      if (reactor.handle_events () == -1)
+	ACE_ERROR ((LM_ERROR,
+                    "%p\n",
+                    "handle_events"));
+    }
+
+  ACE_NOTREACHED (return 0);
+}
+#else
+int
+main (int, char *[])
+{
+  ACE_ERROR_RETURN ((LM_ERROR,
+                     "The HP C++ compiler is too lame to support this feature\n"),
+                    -1);
+}
+#endif /* HPUX */
diff --git a/ACE/examples/Reactor/Misc/test_time_value.cpp b/ACE/examples/Reactor/Misc/test_time_value.cpp
new file mode 100644
index 00000000000..a1c1c874b78
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_time_value.cpp
@@ -0,0 +1,83 @@
+// $Id$
+
+// FUZZ: disable check_for_streams_include
+#include "ace/streams.h"
+
+#include "ace/Log_Msg.h"
+#include "ace/Time_Value.h"
+
+ACE_RCSID(Misc, test_time_value, "$Id$")
+
+inline int my_abs (int d) { return d > 0 ? d : -d; }
+
+ostream &
+operator<< (ostream &stream, const ACE_Time_Value &tv)
+{
+  if (tv.usec () < 0 || tv.sec () < 0)
+    stream << "-";
+
+  stream << my_abs (int (tv.sec ())) << "."
+//       << setw (6) << setfill ('0')
+         << my_abs (int (tv.usec ()));
+  return stream;
+}
+
+int
+main (int, char *[])
+{
+  ACE_Time_Value tv1;
+  ACE_Time_Value tv2 (2);
+  ACE_Time_Value tv3 (100);
+  ACE_Time_Value tv4 (1, 1000000);
+  ACE_Time_Value tv5 (2);
+  ACE_Time_Value tv6 (1, -1000000);
+
+  ACE_ASSERT (tv1 == ACE_Time_Value (0));
+  ACE_ASSERT (tv2 < tv3);
+  ACE_ASSERT (tv2 <= tv2);
+  ACE_ASSERT (tv2 >= tv4);
+  ACE_ASSERT (tv5 >= tv6);
+  ACE_ASSERT (tv2 == ACE_Time_Value (1, 1000000));
+  ACE_ASSERT (tv5 == tv4);
+  ACE_ASSERT (tv2 == tv4);
+  ACE_ASSERT (tv1 != tv2);
+  ACE_ASSERT (tv6 == tv1);
+
+# if defined (ACE_NDEBUG)
+  ACE_UNUSED_ARG (tv1);
+  ACE_UNUSED_ARG (tv2);
+  ACE_UNUSED_ARG (tv3);
+  ACE_UNUSED_ARG (tv4);
+  ACE_UNUSED_ARG (tv5);
+  ACE_UNUSED_ARG (tv6);
+# endif /* ACE_NDEBUG */
+
+  cout << "0,0 :\t\t"        << ACE_Time_Value (0,0) << endl;
+  cout << "-0,0 :\t\t"       << ACE_Time_Value (-0,0) << endl;
+  cout << "0,-0 :\t\t"       << ACE_Time_Value (0,-0) << endl;
+  cout << "-0,-0 :\t\t"      << ACE_Time_Value (-0,-0) << endl;
+  cout << endl;
+
+  cout << "0,1 :\t\t"        << ACE_Time_Value (0,1) << endl;
+  cout << "1,0 :\t\t"        << ACE_Time_Value (1,0) << endl;
+  cout << "-1,0 :\t\t"       << ACE_Time_Value (-1,0) << endl;
+  cout << "-1,-0 :\t\t"      << ACE_Time_Value (-1,-0) << endl;
+  cout << endl;
+
+  cout << "1,1 :\t\t"        << ACE_Time_Value (1,1) << endl;
+  cout << "-1,1 :\t\t"       << ACE_Time_Value (-1,1) << endl;
+  cout << "1,-1 :\t\t"       << ACE_Time_Value (1,-1) << endl;
+  cout << "-1,-1 :\t\t"      << ACE_Time_Value (-1,-1) << endl;
+  cout << endl;
+
+  cout << "1,-1111111 :\t"   << ACE_Time_Value (1,-1111111) << endl;
+  cout << "1,-100000 :\t"    << ACE_Time_Value (1,-100000) << endl;
+  cout << "1,-1000000 :\t"   << ACE_Time_Value (1,-1000000) << endl;
+  cout << "-1,1000000 :\t"   << ACE_Time_Value (-1,1000000) << endl;
+  cout << "5,-1000000 :\t"   << ACE_Time_Value (5,-1000000) << endl;
+  cout << "5,-1500000 :\t"   << ACE_Time_Value (5,-1500000) << endl;
+  cout << "2,-2500000 :\t"   << ACE_Time_Value (2,-2500000) << endl;
+  cout << "2,-4500000 :\t"   << ACE_Time_Value (2,-4500000) << endl;
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Misc/test_timer_queue.cpp b/ACE/examples/Reactor/Misc/test_timer_queue.cpp
new file mode 100644
index 00000000000..64138e13daf
--- /dev/null
+++ b/ACE/examples/Reactor/Misc/test_timer_queue.cpp
@@ -0,0 +1,115 @@
+// $Id$
+
+#include "ace/OS_NS_sys_time.h"
+#include "ace/Timer_Heap.h"
+#include "ace/Timer_List.h"
+#include "ace/Timer_Queue.h"
+#include "ace/Log_Msg.h"
+#include "ace/Recursive_Thread_Mutex.h"
+#include "ace/Null_Mutex.h"
+
+ACE_RCSID(Misc, test_timer_queue, "$Id$")
+
+class Example_Handler : public ACE_Event_Handler
+{
+public:
+  Example_Handler (void)
+    : count_ (1)
+  {}
+
+  virtual int handle_timeout (const ACE_Time_Value &, const void *arg)
+  {
+    int *times = (int *) arg;
+
+    ACE_DEBUG ((LM_DEBUG,
+                "yow, the time has come and gone %d times %d, Horatio!\n",
+                this->count_++,
+                *times));
+    delete times;
+    return 0;
+  }
+
+private:
+  int count_;
+};
+
+static void
+test_functionality (ACE_Timer_Queue *tq)
+{
+  Example_Handler eh;
+
+  ACE_ASSERT (tq->is_empty ());
+  ACE_ASSERT (ACE_Time_Value::zero == ACE_Time_Value (0));
+  const void *timer_act = 0;
+
+  ACE_NEW (timer_act, int (1));
+  long timer_id1 = tq->schedule (&eh, timer_act, ACE_OS::gettimeofday ());
+
+  // Use timer_id outside of an assert, so that we don't get compile
+  // warnings with ACE_NDEBUG about it being unused.
+  if (timer_id1 == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n", "schedule () failed"));
+  ACE_ASSERT (timer_id1 != -1);
+
+  ACE_NEW (timer_act, int (42));
+  long result = tq->schedule (&eh, timer_act, ACE_OS::gettimeofday ());
+  ACE_ASSERT (result != -1);
+  ACE_NEW (timer_act, int (42));
+  result = tq->schedule (&eh, timer_act, ACE_OS::gettimeofday ());
+  ACE_ASSERT (result != -1);
+
+  result = tq->cancel (timer_id1, &timer_act);
+  ACE_ASSERT (result == 1);
+  delete (int *) timer_act;
+  result = tq->is_empty ();
+  ACE_ASSERT (!result);
+
+  result = tq->expire ();
+  ACE_ASSERT (result == 2);
+
+  ACE_NEW (timer_act, int (4));
+  timer_id1 = tq->schedule (&eh, timer_act, ACE_OS::gettimeofday ());
+  ACE_ASSERT (timer_id1 != -1);
+  ACE_NEW (timer_act, int (5));
+  long timer_id2 = tq->schedule (&eh, timer_act, ACE_OS::gettimeofday ());
+  ACE_ASSERT (timer_id2 != -1);
+
+  result = tq->cancel (timer_id1, &timer_act);
+  ACE_ASSERT (result == 1);
+  delete (int *) timer_act;
+  result = tq->cancel (timer_id2, &timer_act);
+  ACE_ASSERT (result == 1);
+  delete (int *) timer_act;
+  result = tq->is_empty ();
+  ACE_ASSERT (result == 1);
+  result = tq->expire ();
+  ACE_ASSERT (result == 0);
+}
+
+struct Timer_Queues
+{
+  ACE_Timer_Queue *queue_;
+  // Pointer to the subclass of <ACE_Timer_Queue> that we're testing.
+
+  const char *name_;
+  // Name of the Queue that we're testing.
+};
+
+static Timer_Queues timer_queues[] =
+{
+  { new ACE_Timer_List, "ACE_Timer_List" },
+  { new ACE_Timer_Heap, "ACE_Timer_Heap" },
+  { 0, 0 },
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  for (int i = 0; timer_queues[i].name_ != 0; i++)
+    {
+      test_functionality (timer_queues[i].queue_);
+      delete timer_queues[i].queue_;
+    }
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Multicast/.cvsignore b/ACE/examples/Reactor/Multicast/.cvsignore
new file mode 100644
index 00000000000..955ffdc75d5
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/.cvsignore
@@ -0,0 +1,4 @@
+client
+client
+server
+server
diff --git a/ACE/examples/Reactor/Multicast/Log_Wrapper.cpp b/ACE/examples/Reactor/Multicast/Log_Wrapper.cpp
new file mode 100644
index 00000000000..055b57b9975
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/Log_Wrapper.cpp
@@ -0,0 +1,81 @@
+// $Id$
+
+// client.C
+
+#include "Log_Wrapper.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_NS_sys_utsname.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_netdb.h"
+
+ACE_RCSID(Multicast, Log_Wrapper, "$Id$")
+
+Log_Wrapper::Log_Wrapper (void)
+{
+  sequence_number_ = 0;
+  this->log_msg_.app_id = ACE_OS::getpid ();
+}
+
+Log_Wrapper::~Log_Wrapper (void)
+{
+}
+
+// Set the log_msg_ host address.
+
+int
+Log_Wrapper::open (const int port, const char *mcast_addr)
+{
+  struct hostent *host_info;
+  ACE_utsname host_data;
+
+  if (ACE_OS::uname (&host_data) < 0)
+    return -1;
+
+#if defined (ACE_LACKS_UTSNAME_T)
+  if ((host_info = ACE_OS::gethostbyname
+       (ACE_TEXT_ALWAYS_CHAR(host_data.nodename))) == NULL)
+#else
+  if ((host_info = ACE_OS::gethostbyname (host_data.nodename)) == NULL)
+#endif
+    return -1;
+  else
+    ACE_OS::memcpy ((char *) &this->log_msg_.host,
+                    (char *) host_info->h_addr,
+                    host_info->h_length);
+
+  // This starts out initialized to all zeros!
+  server_ = ACE_INET_Addr (port, mcast_addr);
+
+  if (logger_.subscribe (server_) == -1)
+      perror("can't subscribe to multicast group"), exit(1);
+
+  // success.
+  return 0;
+}
+
+// Send the message to a logger object.
+// This wrapper fills in all the log_record info for you.
+// uses iovector stuff to make contiguous header and message.
+
+int
+Log_Wrapper::log_message (Log_Priority type, char *message)
+{
+  sequence_number_++;
+
+  this->log_msg_.type = type;
+  this->log_msg_.time = time (0);
+  this->log_msg_.msg_length = ACE_OS::strlen(message)+1;
+  this->log_msg_.sequence_number = htonl(sequence_number_);
+
+  iovec iovp[2];
+  iovp[0].iov_base = reinterpret_cast<char*> (&log_msg_);
+  iovp[0].iov_len  = sizeof (log_msg_);
+  iovp[1].iov_base = message;
+  iovp[1].iov_len  = log_msg_.msg_length;
+
+  logger_.send (iovp, 2);
+
+  // success.
+  return 0;
+}
+
diff --git a/ACE/examples/Reactor/Multicast/Log_Wrapper.h b/ACE/examples/Reactor/Multicast/Log_Wrapper.h
new file mode 100644
index 00000000000..10458f706bc
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/Log_Wrapper.h
@@ -0,0 +1,68 @@
+/* -*- C++ -*- */
+// $Id$
+
+// log_wrapper.h
+
+#include "ace/Profile_Timer.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Dgram_Mcast.h"
+
+#ifndef _LOG_WRAPPER_H
+#define _LOG_WRAPPER_H
+
+class Log_Wrapper
+  // = TITLE
+  //      Provide a wrapper around sending log messages via IP
+  //      multicast.
+{
+public:
+  Log_Wrapper (void);
+  ~Log_Wrapper (void);
+
+  // = Types of logging messages.
+  enum Log_Priority
+  {
+    LM_MESSAGE,
+    LM_DEBUG,
+    LM_WARNING,
+    LM_ERROR,
+    LM_EMERG
+  };
+
+  int open (const int port, const char* mcast_addr);
+  // Subscribe to a given UDP multicast group
+
+  int log_message (Log_Priority type, char *message);
+  // send a string to the logger
+
+  // = Format of the logging record.
+  struct Log_Record
+  {
+    u_long sequence_number;
+    Log_Priority type;
+    long  host;
+    long  time;
+    long  app_id;
+    long  msg_length;
+  };
+
+private:
+  ACE_INET_Addr server_;
+  // Server address where records are logged.
+
+  u_long sequence_number_;
+  // Keep track of the sequence.
+
+  Log_Record log_msg_;
+  // One record used for many log messages.
+
+  ACE_SOCK_Dgram_Mcast logger_;
+  // A logger object.
+};
+
+#endif /* _LOG_WRAPPER_H */
diff --git a/ACE/examples/Reactor/Multicast/Makefile.am b/ACE/examples/Reactor/Multicast/Makefile.am
new file mode 100644
index 00000000000..60d65e7ebe8
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/Makefile.am
@@ -0,0 +1,50 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+## Makefile.Reactor_Multicast_Client.am
+noinst_PROGRAMS = client
+
+client_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+client_SOURCES = \
+  Log_Wrapper.cpp \
+  client.cpp \
+  Log_Wrapper.h
+
+client_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.Reactor_Multicast_Server.am
+noinst_PROGRAMS += server
+
+server_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+server_SOURCES = \
+  Log_Wrapper.cpp \
+  server.cpp \
+  Log_Wrapper.h
+
+server_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/Multicast/README b/ACE/examples/Reactor/Multicast/README
new file mode 100644
index 00000000000..85f64cc8120
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/README
@@ -0,0 +1,15 @@
+The following test illustrates the SOCK Mcast multicast wrappers in
+conjunction with the Reactor.  This test was written by Tim Harrison
+(harrison@cs.wustl.edu).
+
+To run the server type: 
+
+% server &
+
+It will wait for the first message sent to it and then read for 5 seconds. 
+
+To run the client type any of these:
+
+% client -m max_message_size -i iterations
+% client < <filename>
+% client
diff --git a/ACE/examples/Reactor/Multicast/Reactor_Multicast.mpc b/ACE/examples/Reactor/Multicast/Reactor_Multicast.mpc
new file mode 100644
index 00000000000..a15c53340e4
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/Reactor_Multicast.mpc
@@ -0,0 +1,17 @@
+// -*- MPC -*-
+// $Id$
+
+project(*client) : aceexe {
+  exename = client
+  Source_Files {
+    client.cpp
+    Log_Wrapper.cpp
+  }
+}
+project(*server) : aceexe {
+  exename = server
+  Source_Files {
+    server.cpp
+    Log_Wrapper.cpp
+  }
+}
diff --git a/ACE/examples/Reactor/Multicast/client.cpp b/ACE/examples/Reactor/Multicast/client.cpp
new file mode 100644
index 00000000000..25b18c2ae6c
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/client.cpp
@@ -0,0 +1,126 @@
+// $Id$
+
+// This program reads in messages from stdin and sends them to a
+// Log_Wrapper.
+
+#include "ace/OS_main.h"
+#include "ace/OS_NS_stdlib.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_Memory.h"
+#include "ace/Get_Opt.h"
+#include "ace/Log_Msg.h"
+#include "Log_Wrapper.h"
+
+ACE_RCSID(Multicast, client, "$Id$")
+
+// Multi-cast address.
+static const char *MCAST_ADDR = ACE_DEFAULT_MULTICAST_ADDR;
+
+// UDP port.
+static const int UDP_PORT = ACE_DEFAULT_MULTICAST_PORT;
+
+// Maximum message size.
+static int max_message_size = BUFSIZ;
+
+// Number of times to send message of max_message_size.
+static int iterations = 0;
+
+static void
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_LOG_MSG->open (argv[0]);
+
+  // Start at argv[1]
+  ACE_Get_Opt getopt (argc, argv, ACE_TEXT("m:ui:"), 1);
+
+  for (int c; (c = getopt ()) != -1; )
+    switch (c)
+      {
+      case 'm':
+        max_message_size = ACE_OS::atoi (getopt.opt_arg ()) * BUFSIZ;
+        break;
+      case 'i':
+        iterations = ACE_OS::atoi (getopt.opt_arg ());
+        break;
+      case 'u':
+        // usage fallthrough
+      default:
+        ACE_ERROR ((LM_ERROR,
+		    "%n: -m max_message_size (in k) -i iterations\n%a",
+		    1));
+        /* NOTREACHED */
+      }
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR **argv)
+{
+  int user_prompt;
+
+  parse_args (argc,argv);
+
+  ACE_DEBUG ((LM_DEBUG, "max buffer size = %d\n", max_message_size));
+
+  // Instantiate a log wrapper for logging
+  Log_Wrapper log;
+
+  // Make a connection to a logger.
+  if (log.open (UDP_PORT, MCAST_ADDR) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n" "open"), -1);
+
+  char *buf;
+  ACE_NEW_RETURN (buf, char[max_message_size], -1);
+
+  // If -i has been specified, send max_message_size messages
+  // iterations number of times.
+  if (iterations)
+    {
+      ACE_OS::memset (buf, 1, max_message_size);
+
+      while (iterations--)
+        if (log.log_message (Log_Wrapper::LM_DEBUG, buf) == -1)
+	  ACE_ERROR_RETURN ((LM_ERROR, "%p\n" "log"), -1);
+    }
+
+  // otherwise, a file has been redirected, or give prompts
+  else
+    {
+      // If a file has been redirected, don't activate user prompts.
+      if (ACE_OS::isatty (0))
+        user_prompt = 1;
+      else
+        user_prompt = 0;
+
+      // Continually read messages from stdin and log them.
+
+      for (int count = 1;;)
+        {
+          if (user_prompt)
+            ACE_DEBUG ((LM_DEBUG, "\nEnter message ('Q':quit):\n"));
+
+	  ssize_t nbytes = ACE_OS::read (ACE_STDIN, buf, max_message_size);
+
+          if (nbytes <= 0)
+            break; // End of file or error.
+          buf[nbytes - 1] = '\0';
+
+          // Quitting?
+          if (user_prompt)
+	    {
+	      if (buf[0] == 'Q' || buf[0] == 'q')
+		break;
+	    }
+	  else // Keep from overrunning the receiver.
+	    ACE_OS::sleep (1);
+
+          // Send the message to the logger.
+          if (log.log_message (Log_Wrapper::LM_DEBUG, buf) == -1)
+	    ACE_ERROR_RETURN ((LM_ERROR, "%p\n" "log_message"), -1);
+	  ACE_DEBUG ((LM_DEBUG, "finished sending message %d\n", count++));
+        }
+    }
+
+  ACE_DEBUG ((LM_DEBUG, "Client done.\n"));
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Multicast/server.cpp b/ACE/examples/Reactor/Multicast/server.cpp
new file mode 100644
index 00000000000..65e39b97d1a
--- /dev/null
+++ b/ACE/examples/Reactor/Multicast/server.cpp
@@ -0,0 +1,247 @@
+// $Id$
+
+// server.cpp (written by Tim Harrison)
+
+// Listens to multicast address for client log messages.  Prints
+// Mbits/sec received from client.
+
+#include "ace/OS_main.h"
+#include "ace/SOCK_Dgram.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Dgram_Mcast.h"
+#include "ace/Reactor.h"
+#include "ace/Log_Msg.h"
+#include "Log_Wrapper.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/os_include/os_netdb.h"
+
+ACE_RCSID(Multicast, server, "$Id$")
+
+#if defined (ACE_HAS_IP_MULTICAST)
+class Server_Events : public ACE_Event_Handler
+{
+public:
+  Server_Events (u_short port,
+                 const char *mcast_addr,
+                 long time_interval = 0);
+  ~Server_Events (void);
+
+  virtual int handle_input (ACE_HANDLE fd);
+  virtual int handle_timeout (const ACE_Time_Value &tv,
+                              const void *arg);
+
+  virtual ACE_HANDLE get_handle (void) const;
+
+  ACE_Time_Value *wait_time (void);
+
+private:
+  char *message_;
+  Log_Wrapper::Log_Record *log_record_;
+  char buf_[4 * BUFSIZ];
+  char hostname_[MAXHOSTNAMELEN];
+
+  int initialized_;
+  int count_;
+  long interval_;
+  // time interval to log messages
+
+  ACE_Time_Value *how_long_;
+  ACE_Reactor *reactor_;
+  ACE_SOCK_Dgram_Mcast mcast_dgram_;
+  ACE_INET_Addr remote_addr_;
+  ACE_INET_Addr mcast_addr_;
+
+  // = statistics on messages received
+  double total_bytes_received_;
+  int total_messages_received_;
+  int last_sequence_number_;
+};
+
+static const char MCAST_ADDR[] = ACE_DEFAULT_MULTICAST_ADDR;
+static const int UDP_PORT = ACE_DEFAULT_MULTICAST_PORT;
+static const int DURATION = 5;
+
+ACE_HANDLE
+Server_Events::get_handle (void) const
+{
+  return this->mcast_dgram_.get_handle ();
+}
+
+ACE_Time_Value *
+Server_Events::wait_time (void)
+{
+  return this->how_long_;
+}
+
+Server_Events::Server_Events (u_short port,
+                              const char *mcast_addr,
+                              long time_interval)
+  : initialized_ (0),
+    count_ (1),
+    interval_ (time_interval),
+    mcast_addr_ (port, mcast_addr),
+    total_bytes_received_ (0)
+{
+  // Use ACE_SOCK_Dgram_Mcast factory to subscribe to multicast group.
+
+  if (ACE_OS::hostname (this->hostname_,
+                        MAXHOSTNAMELEN) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "hostname"));
+
+  else if (this->mcast_dgram_.subscribe (this->mcast_addr_) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "subscribe"));
+  else
+    {
+      // Point to NULL so that we block in the beginning.
+      this->how_long_ = 0;
+
+      this->log_record_ = (Log_Wrapper::Log_Record *) &buf_;
+      this->message_ = &buf_[sizeof (Log_Wrapper::Log_Record)];
+    }
+}
+
+// A destructor that emacs refuses to color blue ;-)
+
+Server_Events::~Server_Events (void)
+{
+  this->mcast_dgram_.unsubscribe ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              "total bytes received = %d after %d second\n",
+              this->total_bytes_received_,
+              this->interval_));
+
+  ACE_DEBUG ((LM_DEBUG,
+              "Mbits/sec = %.2f\n",
+              (float) (total_bytes_received_ * 8 / (float) (1024*1024*interval_))));
+
+  ACE_DEBUG ((LM_DEBUG,
+              "last sequence number = %d\ntotal messages received = %d\ndiff = %d\n",
+              this->last_sequence_number_,
+              this->total_messages_received_,
+              this->last_sequence_number_ - total_messages_received_));
+}
+
+int
+Server_Events::handle_timeout (const ACE_Time_Value &,
+                               const void *arg)
+{
+  ACE_DEBUG ((LM_DEBUG, "\t%d timeout%s occurred for %s.\n",
+              this->count_,
+              this->count_ == 1 ? "" : "s",
+              (char *) arg));
+
+  // Don't let the timeouts continue if there's no activity since
+  // otherwise we use up a lot of CPU time unnecessarily.
+  if (this->count_ == 5)
+    {
+      reactor ()->cancel_timer (this);
+      this->initialized_ = 0;
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "\tcancelled timeout for %s to avoid busy waiting.\n",
+                  (char *) arg));
+    }
+
+  this->count_++;
+  return 0;
+}
+
+int
+Server_Events::handle_input (ACE_HANDLE)
+{
+  // Receive message from multicast group.
+  iovec iovp[2];
+  iovp[0].iov_base = buf_;
+  iovp[0].iov_len  = sizeof (log_record_);
+  iovp[1].iov_base = &buf_[sizeof (log_record_)];
+  iovp[1].iov_len  = 4 * BUFSIZ - sizeof (log_record_);
+
+  ssize_t retcode =
+    this->mcast_dgram_.recv (iovp,
+                             2,
+                             this->remote_addr_);
+  if (retcode != -1)
+    {
+      total_messages_received_++;
+      total_bytes_received_ += retcode;
+      last_sequence_number_ =
+        ntohl (log_record_->sequence_number);
+
+      for (char *message_end = this->message_ + ACE_OS::strlen (this->message_) - 1;
+           ACE_OS::strchr ("\r\n \t", *message_end) != 0;
+           )
+        {
+          *message_end-- = '\0';
+          if (message_end == this->message_)
+            break;
+        }
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "sequence number = %d\n",
+                  last_sequence_number_));
+      ACE_DEBUG ((LM_DEBUG,
+                  "message = '%s'\n",
+                  this->message_));
+
+      if (this->initialized_ == 0)
+        {
+          // Restart the timer since we've received events again.
+          if (reactor()->schedule_timer (this,
+                                         (void *) this->hostname_,
+                                         ACE_Time_Value::zero,
+                                         ACE_Time_Value (DURATION)) == -1)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "%p\n",
+                               "schedule_timer"),
+                              -1);
+          this->initialized_ = 1;
+        }
+
+      this->count_ = 1;
+      return 0;
+    }
+  else
+    return -1;
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  // Instantiate a server which will receive messages for DURATION
+  // seconds.
+  Server_Events server_events (UDP_PORT,
+                               MCAST_ADDR,
+                               DURATION);
+  // Instance of the ACE_Reactor.
+  ACE_Reactor reactor;
+
+  if (reactor.register_handler (&server_events,
+                                ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n%a",
+                "register_handler",
+                1));
+
+  ACE_DEBUG ((LM_DEBUG,
+              "starting up server\n"));
+
+  for (;;)
+    reactor.handle_events (server_events.wait_time ());
+
+  ACE_NOTREACHED (return 0;)
+}
+#else
+int
+main (int, char *argv[])
+{
+  ACE_ERROR_RETURN ((LM_ERROR,
+                     "error: %s must be run on a platform that support IP multicast\n",
+                     argv[0]), -1);
+}
+#endif /* ACE_HAS_IP_MULTICAST */
diff --git a/ACE/examples/Reactor/Ntalker/.cvsignore b/ACE/examples/Reactor/Ntalker/.cvsignore
new file mode 100644
index 00000000000..a9350d173bf
--- /dev/null
+++ b/ACE/examples/Reactor/Ntalker/.cvsignore
@@ -0,0 +1,2 @@
+ntalker
+ntalker
diff --git a/ACE/examples/Reactor/Ntalker/Makefile.am b/ACE/examples/Reactor/Ntalker/Makefile.am
new file mode 100644
index 00000000000..6efc3521a32
--- /dev/null
+++ b/ACE/examples/Reactor/Ntalker/Makefile.am
@@ -0,0 +1,33 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+## Makefile.Reactor_Ntalker.am
+noinst_PROGRAMS = ntalker
+
+ntalker_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+ntalker_SOURCES = \
+  ntalker.cpp
+
+ntalker_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/Ntalker/README b/ACE/examples/Reactor/Ntalker/README
new file mode 100644
index 00000000000..191cef9256f
--- /dev/null
+++ b/ACE/examples/Reactor/Ntalker/README
@@ -0,0 +1,17 @@
+This test program illustrates how the ACE datagram multicast feature
+works.  To run the test simply do the following on multiple machines:
+
+# Machine 1
+% ./ntalker
+
+# Machine 2
+% ./ntalker
+
+# Machine 3
+% ./ntalker
+
+Then, on one (or all) of the machines, type input into the keyboard.
+This input will be multicast to all the machines using IP multicast
+via the ACE_SOCK_Dgram_Mcast wrapper.
+
+When you want to shut down the sender, just type ^D.
diff --git a/ACE/examples/Reactor/Ntalker/Reactor_Ntalker.mpc b/ACE/examples/Reactor/Ntalker/Reactor_Ntalker.mpc
new file mode 100644
index 00000000000..ef2fb84d9a0
--- /dev/null
+++ b/ACE/examples/Reactor/Ntalker/Reactor_Ntalker.mpc
@@ -0,0 +1,6 @@
+// -*- MPC -*-
+// $Id$
+
+project : aceexe {
+  exename = ntalker
+}
diff --git a/ACE/examples/Reactor/Ntalker/ntalker.cpp b/ACE/examples/Reactor/Ntalker/ntalker.cpp
new file mode 100644
index 00000000000..80873ead1a9
--- /dev/null
+++ b/ACE/examples/Reactor/Ntalker/ntalker.cpp
@@ -0,0 +1,231 @@
+// $Id$
+
+// Listens to multicast address.  After first message received, will
+// listen for 5 more seconds.  Prints Mbits/sec received from client.
+
+#include "ace/OS_main.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Dgram_Mcast.h"
+#include "ace/Reactor.h"
+#include "ace/Get_Opt.h"
+#include "ace/Thread_Manager.h"
+#include "ace/Service_Config.h"
+
+ACE_RCSID(Ntalker, ntalker, "$Id$")
+
+#if defined (ACE_HAS_IP_MULTICAST)
+// Network interface to subscribe to.  This is hardware specific.  use
+// netstat(1M) to find whether your interface is le0 or ie0
+
+static const ACE_TCHAR *INTERFACE = 0;
+static const char *MCAST_ADDR = ACE_DEFAULT_MULTICAST_ADDR;
+static const u_short UDP_PORT = ACE_DEFAULT_MULTICAST_PORT;
+
+class Handler : public ACE_Event_Handler
+{
+  // = TITLE
+  //     Handle both multicast and stdin events.
+public:
+  // = Initialization and termination methods.
+  Handler (u_short udp_port,
+	   const char *ip_addr,
+      const ACE_TCHAR *a_interface,
+	   ACE_Reactor & );
+  // Constructor.
+
+  ~Handler (void);
+  // Destructor.
+
+  // Event demuxer hooks.
+  virtual int handle_input (ACE_HANDLE);
+  virtual int handle_close (ACE_HANDLE,
+                            ACE_Reactor_Mask);
+  virtual ACE_HANDLE get_handle (void) const;
+
+private:
+  ACE_SOCK_Dgram_Mcast mcast_;
+  // Multicast wrapper.
+};
+
+ACE_HANDLE
+Handler::get_handle (void) const
+{
+  return this->mcast_.get_handle ();
+}
+
+int
+Handler::handle_input (ACE_HANDLE h)
+{
+  char buf[BUFSIZ];
+
+  if (h == ACE_STDIN)
+    {
+      ssize_t result = ACE_OS::read (h, buf, BUFSIZ);
+
+      if (result > 0)
+	{
+	  if (this->mcast_.send (buf, result) != result)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "%p\n",
+                               "send error"),
+                              -1);
+	  return 0;
+	}
+      else if (result == -1)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "%p\n",
+                               "can't read from STDIN"),
+                              -1);
+      else // result == 0
+        {
+          ACE_Reactor::end_event_loop ();
+          return -1;
+        }
+    }
+  else
+    {
+      ACE_INET_Addr remote_addr;
+
+      // Receive message from multicast group.
+      ssize_t result = this->mcast_.recv (buf,
+                                          sizeof buf,
+                                          remote_addr);
+
+      if (result != -1)
+	{
+          ACE_DEBUG ((LM_DEBUG,
+                      "received datagram from host %s on port %d bytes = %d\n",
+                      remote_addr.get_host_name (),
+                      remote_addr.get_port_number (),
+                      result));
+	  ACE_OS::write (ACE_STDERR, buf, result);
+          ACE_DEBUG ((LM_DEBUG,
+                      "\n"));
+	  return 0;
+	}
+
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "something amiss"),
+                              -1);
+    }
+}
+
+int
+Handler::handle_close (ACE_HANDLE h, ACE_Reactor_Mask)
+{
+  if (h == ACE_STDIN)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "STDIN_Events handle removed from reactor.\n"));
+      if (ACE_Reactor::instance ()->remove_handler
+          (this, ACE_Event_Handler::READ_MASK) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "%p\n",
+                           "remove_handler"),
+                           -1);
+    }
+  else
+    ACE_DEBUG ((LM_DEBUG,
+                "Mcast_Events handle removed from reactor.\n"));
+  return 0;
+}
+
+Handler::~Handler (void)
+{
+  if (this->mcast_.unsubscribe () == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "unsubscribe fails"));
+}
+
+Handler::Handler (u_short udp_port,
+		  const char *ip_addr,
+        const ACE_TCHAR *a_interface,
+		  ACE_Reactor &reactor)
+{
+  // Create multicast address to listen on.
+
+  ACE_INET_Addr sockmc_addr (udp_port, ip_addr);
+
+  // subscribe to multicast group.
+
+  if (this->mcast_.subscribe (sockmc_addr, 1, a_interface) == -1)
+  {
+  	  ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "can't subscribe to multicast group"));
+  }
+  // Disable loopbacks.
+  // if (this->mcast_.set_option (IP_MULTICAST_LOOP, 0) == -1 )
+  //   ACE_OS::perror (" can't disable loopbacks " ), ACE_OS::exit (1);
+
+  // Register callbacks with the ACE_Reactor.
+  else if (reactor.register_handler (this->mcast_.get_handle (),
+                                     this,
+                                     ACE_Event_Handler::READ_MASK) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "can't register with Reactor\n"));
+  // Register the STDIN handler.
+  else if (ACE_Event_Handler::register_stdin_handler (this,
+                                        		ACE_Reactor::instance (),
+                                        		ACE_Thread_Manager::instance ()) == -1)
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "register_stdin_handler"));
+}
+
+static void
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("i:u"));
+
+  int c;
+
+  while ((c = get_opt ()) != -1)
+    switch (c)
+      {
+      case 'i':
+	INTERFACE = get_opt.opt_arg ();
+	break;
+      case 'u':
+	// Usage fallthrough.
+      default:
+        ACE_DEBUG ((LM_DEBUG,
+                    "%s -i interface\n",
+                    argv[0]));
+	ACE_OS::exit (1);
+      }
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  parse_args (argc, argv);
+
+  Handler handler (UDP_PORT,
+                   MCAST_ADDR,
+                   INTERFACE,
+                   *ACE_Reactor::instance ());
+
+  // Run the event loop.
+  ACE_Reactor::run_event_loop ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              "talker Done.\n"));
+  return 0;
+}
+
+#else
+int
+ACE_TMAIN (int, ACE_TCHAR *argv[])
+{
+  ACE_ERROR_RETURN ((LM_ERROR,
+                     "error: %s must be run on a platform that support IP multicast\n",
+                     argv[0]),
+                    0);
+}
+#endif /* ACE_HAS_IP_MULTICAST */
+
diff --git a/ACE/examples/Reactor/Proactor/.cvsignore b/ACE/examples/Reactor/Proactor/.cvsignore
new file mode 100644
index 00000000000..34179361b75
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/.cvsignore
@@ -0,0 +1,7 @@
+test_cancel
+test_end_event_loop
+test_multiple_loops
+test_post_completions
+test_proactor
+test_timeout
+test_udp_proactor
diff --git a/ACE/examples/Reactor/Proactor/Aio_Platform_Test_C.cpp b/ACE/examples/Reactor/Proactor/Aio_Platform_Test_C.cpp
new file mode 100644
index 00000000000..be720fdef40
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/Aio_Platform_Test_C.cpp
@@ -0,0 +1,137 @@
+// $Id$
+// ============================================================================
+//
+// = FILENAME
+//    aio_platform_test_c.cpp
+//
+// =  DESCRITPTION
+//     Testing the platform for POSIX Asynchronous I/O. This is the C
+//     version of the  $ACE_ROOT/tests/Aio_Platform_Test.cpp. Useful
+//     to send bug reports.
+//
+// = AUTHOR
+//    Programming for the Real World. Bill O. GallMeister.
+//    Modified by Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// =====================================================================
+
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+
+#include <limits.h>
+
+#include <aio.h>
+
+int do_sysconf (void);
+int have_asynchio (void);
+
+static int file_handle = -1;
+char mb1 [BUFSIZ + 1];
+char mb2 [BUFSIZ + 1];
+aiocb aiocb1, aiocb2;
+sigset_t completion_signal;
+
+// For testing the <aio> stuff.
+int test_aio_calls (void);
+int issue_aio_calls (void);
+int query_aio_completions (void);
+int setup_signal_delivery (void);
+int do_sysconf (void);
+int have_asynchio (void);
+  
+int
+do_sysconf (void)
+{
+  // Call sysconf to find out runtime values.
+  errno = 0;
+#if defined (_SC_LISTIO_AIO_MAX)
+  printf ("Runtime value of LISTIO_AIO_MAX is %d, errno = %d\n",
+          sysconf(_SC_LISTIO_AIO_MAX),
+          errno);
+#else
+  printf ("Runtime value of AIO_LISTIO_MAX is %d, errno = %d\n",
+          sysconf(_SC_AIO_LISTIO_MAX),
+          errno);
+#endif  
+  
+  errno = 0;
+  printf ("Runtime value of AIO_MAX is %d, errno = %d\n",
+          sysconf (_SC_AIO_MAX),
+          errno);
+
+  errno = 0;
+  printf ("Runtime value of _POSIX_ASYNCHRONOUS_IO is %d, errno = %d\n",
+          sysconf (_SC_ASYNCHRONOUS_IO),
+          errno);
+
+  errno = 0;
+  printf ("Runtime value of _POSIX_REALTIME_SIGNALS is %d, errno = %d\n",
+          sysconf (_SC_REALTIME_SIGNALS),
+          errno);
+
+  errno = 0;
+  printf ("Runtime value of RTSIG_MAX %d, Errno = %d\n",
+          sysconf (_SC_RTSIG_MAX), 
+          errno);
+  
+  errno = 0;
+  printf ("Runtime value of SIGQUEUE_MAX %d, Errno = %d\n",
+          sysconf (_SC_SIGQUEUE_MAX),
+          errno); 
+  return 0;
+}
+
+int
+have_asynchio (void)
+{
+#if defined (_POSIX_ASYNCHRONOUS_IO)
+  // POSIX Asynch IO is present in this system.
+#if defined (_POSIX_ASYNC_IO)
+  // If this is defined and it is not -1, POSIX_ASYNCH is supported
+  // everywhere in the system.
+#if _POSIX_ASYNC_IO == -1
+  printf ("_POSIX_ASYNC_IO = -1.. ASYNCH IO NOT supported at all\n");
+  return -1;
+#else /* Not _POSIX_ASYNC_IO == -1 */
+  printf ("_POSIX_ASYNC_IO = %d\n ASYNCH IO is supported FULLY\n",
+          _POSIX_ASYNC_IO);
+#endif /* _POSIX_ASYNC_IO == -1 */
+  
+#else  /* Not defined  _POSIX_ASYNC_IO */
+  printf ("_POSIX_ASYNC_IO is not defined.\n");
+  printf ("AIO might *not* be supported on some paths\n");
+#endif /* _POSIX_ASYNC_IO */
+  
+  // System defined POSIX Values.
+  printf ("System claims to have  POSIX_ASYNCHRONOUS_IO\n");
+
+  printf ("_POSIX_AIO_LISTIO_MAX = %d\n", _POSIX_AIO_LISTIO_MAX);
+  printf ("_POSIX_AIO_MAX = %d\n", _POSIX_AIO_MAX);
+
+  // Check and print the run time values.
+  do_sysconf ();
+  
+  return 0;
+  
+#else /* Not _POSIX_ASYNCHRONOUS_IO */
+  printf ("No support._POSIX_ASYNCHRONOUS_IO itself is not defined\n");
+  return -1;
+#endif /* _POSIX_ASYNCHRONOUS_IO */  
+}
+
+int
+main (int, char *[])
+{
+  if (have_asynchio () == 0)
+    printf ("Test successful\n");
+  else
+    printf ("Test not successful\n");
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Proactor/Makefile.am b/ACE/examples/Reactor/Proactor/Makefile.am
new file mode 100644
index 00000000000..7f1bc4b8a57
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/Makefile.am
@@ -0,0 +1,153 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+noinst_PROGRAMS =
+
+## Makefile.Proactor_Cancel.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_cancel
+
+test_cancel_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_cancel_SOURCES = \
+  test_cancel.cpp \
+  test_cancel.h
+
+test_cancel_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Proactor_End_Event_Loops.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_end_event_loop
+
+test_end_event_loop_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_end_event_loop_SOURCES = \
+  test_end_event_loop.cpp \
+  test_cancel.h \
+  test_proactor.h
+
+test_end_event_loop_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Proactor_Multiple_Loops.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_multiple_loops
+
+test_multiple_loops_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_multiple_loops_SOURCES = \
+  test_multiple_loops.cpp \
+  test_cancel.h \
+  test_proactor.h
+
+test_multiple_loops_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Proactor_Post_Completions.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_post_completions
+
+test_post_completions_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_post_completions_SOURCES = \
+  post_completions.cpp \
+  test_cancel.h \
+  test_proactor.h
+
+test_post_completions_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Proactor_Proactor.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_proactor
+
+test_proactor_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_proactor_SOURCES = \
+  test_proactor.cpp \
+  test_proactor.h
+
+test_proactor_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Proactor_Timeout.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_timeout
+
+test_timeout_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_timeout_SOURCES = \
+  test_timeout.cpp \
+  test_cancel.h \
+  test_proactor.h
+
+test_timeout_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Makefile.Proactor_Udp_Proactor.am
+
+if !BUILD_ACE_FOR_TAO
+noinst_PROGRAMS += test_udp_proactor
+
+test_udp_proactor_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+test_udp_proactor_SOURCES = \
+  test_udp_proactor.cpp \
+  test_cancel.h \
+  test_proactor.h
+
+test_udp_proactor_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_ACE_FOR_TAO
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/Proactor/Proactor.mpc b/ACE/examples/Reactor/Proactor/Proactor.mpc
new file mode 100644
index 00000000000..c2c52207ca1
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/Proactor.mpc
@@ -0,0 +1,59 @@
+// -*- MPC -*-
+// $Id$
+
+project(*cancel) : aceexe {
+  avoids += ace_for_tao
+  exename = test_cancel
+  Source_Files {
+    test_cancel.cpp
+  }
+}
+
+project(*end_event_loops) : aceexe {
+  avoids += ace_for_tao
+  exename = test_end_event_loop
+  Source_Files {
+    test_end_event_loop.cpp
+  }
+}
+
+project(*multiple_loops) : aceexe {
+  avoids += ace_for_tao
+  exename = test_multiple_loops
+  Source_Files {
+    test_multiple_loops.cpp
+  }
+}
+
+project(*post_completions) : aceexe {
+  avoids += ace_for_tao
+  exename = test_post_completions
+  Source_Files {
+    post_completions.cpp
+  }
+}
+
+project(*proactor) : aceexe {
+  avoids += ace_for_tao
+  exename = test_proactor
+  Source_Files {
+    test_proactor.cpp
+  }
+}
+
+project(*timeout) : aceexe {
+  avoids += ace_for_tao
+  exename = test_timeout
+  Source_Files {
+    test_timeout.cpp
+  }
+}
+
+project(*udp_proactor) : aceexe {
+  avoids += ace_for_tao
+  exename = test_udp_proactor
+  Source_Files {
+    test_udp_proactor.cpp
+  }
+}
+
diff --git a/ACE/examples/Reactor/Proactor/README b/ACE/examples/Reactor/Proactor/README
new file mode 100644
index 00000000000..29f2a0b1832
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/README
@@ -0,0 +1,75 @@
+$Id$
+
+This README file lists all the example applications for the Proactor framework. 
+
+Test/Example Applications for Proactor:
+=========================================
+
+The following tests are available.
+        
+o $ACE_ROOT/tests/Aio_Platform_Test.cpp : Tests basic limits
+        pertaining to the  POSIX features 
+
+o $ACE_ROOT/examples/Reactor/Proactor/test_aiocb.cpp    : 
+        This is a C++ program for testing the AIOCB (AIO Control
+        Blocks) based completion approach which uses <aio_suspend> for
+        completion querying. 
+
+o $ACE_ROOT/examples/Reactor/Proactor/test_aiosig.cpp   : This is a
+        C++ program for testing the Signal based completion approach
+        that uses <sigtimedwait> for completion querying. 
+
+o $ACE_ROOT/examples/Reactor/Proactor/test_aiocb_ace.cpp: Portable
+        version of test_aiocb.cpp. (Same as test_aiocb.cpp, but uses
+        ACE_DEBUGs instead of printf's and ACE_Message_Blocks instead
+        of char*'s. 
+
+o $ACE_ROOT/examples/Reactor/Proactor/test_aiosig_ace.cpp: Portable
+        version of test_aiosig.cpp. (Same as test_aiosig.cpp, but uses
+        ACE_DEBUGs instead of printf's and ACE_Message_Blocks instead
+        of char*'s. 
+
+o test_proactor.cpp (with ACE_POSIX_AIOCB_Proactor)     : Test for
+        ACE_Proactor which uses AIOCB (AIO Control Blocks) based
+        completions strategy Proactor. (#define
+        ACE_POSIX_AIOCB_PROACTOR in the config file, but this is the
+        default option)
+
+o test_proactor.cpp (with ACE_POSIX_SIG_Proactor)     : Test for
+        ACE_Proactor which uses real time signal based completion
+        strategy proactor. (#define ACE_POSIX_SIG_PROACTOR in the
+        config file)
+
+o test_multiple_loops.cpp       : This example application shows how
+        to write programs that combine the Proactor and Reactor event
+        loops. This is possible only on WIN32 platform.
+       
+o test_timeout.cpp      : Multithreaded application testing the Timers
+        mechanism of the Proactor.
+
+o test_timeout_st.cpp   : Single-threaded version of test_timeout.cpp.
+
+o post_completions.cpp  : Tests the completion posting mechanism of
+        the Proactor.  
+
+o test_end_event_loop.cpp : Tests the event loop mechanism of the
+        Proactor. 
+        
+o test_cancel.cpp         : Tests <cancel> interface of the
+        Asynch_Operation class.
+        
+Behavior of POSIX AIO of various platforms:
+==========================================
+
+Sun 5.6 :       POSIX4 Real-Time signals implementation is broken in
+                this platform. 
+                Only POSIX AIOCB Proactor works in this platform.
+                Therefore, it is not possible to use multiple threads
+                with in the framework.
+
+Sun 5.7 :       AIOCB and SIG Proactors work fine.
+
+LynxOS 3.0.0 :  <pthread_sigmask> is not available in this
+                platform. So, only AIOCB Proactor works here. 
+
+
diff --git a/ACE/examples/Reactor/Proactor/post_completions.cpp b/ACE/examples/Reactor/Proactor/post_completions.cpp
new file mode 100644
index 00000000000..e6545241953
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/post_completions.cpp
@@ -0,0 +1,306 @@
+// $Id$
+// ============================================================================
+//
+// = FILENAME
+//     post_completions.cpp
+//
+// = DESCRITPTION
+//     This program demonstrates how to post fake completions to The
+//     Proactor. It also shows the how to specify the particular
+//     real-time signals to post completions. The Real-time signal
+//     based completion strategy is implemented with
+//     ACE_POSIX_SIG_PROACTOR.
+//     (So, it can be used only if both ACE_HAS_AIO_CALLS and
+//     ACE_HAS_POSIX_REALTIME_SIGNALS are defined.)
+//     Since it is faking results, you have to pay by knowing and
+//     using platform-specific implementation objects for Asynchronous
+//     Result classes.
+//     This example shows using an arbitrary result class for faking
+//     completions. You can also use the predefined Result classes for
+//     faking. The factory methods in the Proactor class create the
+//     Result objects.
+//
+// = COMPILATION
+//     make
+//
+// = RUN
+//     ./post_completions
+//
+// = AUTHOR
+//     Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// =====================================================================
+
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_main.h"
+#include "ace/Proactor.h"
+#include "ace/Task.h"
+#include "ace/WIN32_Proactor.h"
+#include "ace/POSIX_Proactor.h"
+#include "ace/Atomic_Op.h"
+#include "ace/Thread_Mutex.h"
+
+// Keep track of how many completions are still expected.
+static ACE_Atomic_Op <ACE_SYNCH_MUTEX, size_t> Completions_To_Go;
+
+
+#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || \
+     defined (ACE_HAS_AIO_CALLS)
+// This only works on Win32 platforms and on Unix platforms supporting
+// POSIX aio calls.
+
+#if defined (ACE_HAS_AIO_CALLS)
+#define RESULT_CLASS ACE_POSIX_Asynch_Result
+#elif defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+#define RESULT_CLASS ACE_WIN32_Asynch_Result
+#endif /* ACE_HAS_AIO_CALLS */
+
+class My_Result : public RESULT_CLASS
+{
+  // = TITLE
+  //
+  //     Result Object that we will post to the Proactor.
+  //
+  // = DESCRIPTION
+  //
+
+public:
+  My_Result (ACE_Handler &handler,
+             const void *act,
+             int signal_number,
+             size_t sequence_number)
+    : RESULT_CLASS (handler.proxy (),
+                    act,
+                    ACE_INVALID_HANDLE,
+                    0, // Offset
+                    0, // OffsetHigh
+                    0, // Priority
+                    signal_number),
+      sequence_number_ (sequence_number)
+    {}
+  // Constructor.
+
+  virtual ~My_Result (void)
+    {}
+  // Destructor.
+
+  void complete (size_t,
+                 int success,
+                 const void *completion_key,
+                 u_long error)
+    // This is the method that will be called by the Proactor for
+    // dispatching the completion. This method generally calls one of
+    // the call back hood methods defined in the ACE_Handler
+    // class. But, we will just handle the completions here.
+    {
+      this->success_ = success;
+      this->completion_key_ = completion_key;
+      this->error_ = error;
+
+      size_t to_go = --Completions_To_Go;
+
+      // Print the completion details.
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%t) Completion sequence number %d, success : %d, error : %d, signal_number : %d, %u more to go\n",
+                  this->sequence_number_,
+                  this->success_,
+                  this->error_,
+                  this->signal_number (),
+                  to_go));
+
+      // Sleep for a while.
+      ACE_OS::sleep (4);
+    }
+
+private:
+  size_t sequence_number_;
+  // Sequence number for the result object.
+};
+
+class My_Handler : public  ACE_Handler
+{
+  // = TITLE
+  //
+  //     Handler class for faked completions.
+  //
+  // = DESCRIPTION
+  //
+
+public:
+  My_Handler (void) {}
+  // Constructor.
+
+  virtual ~My_Handler (void) {}
+  // Destructor.
+};
+
+class My_Task: public ACE_Task <ACE_NULL_SYNCH>
+{
+  // = TITLE
+  //
+  //     Contains thread functions which execute event loops. Each
+  //     thread waits for a different signal.
+  //
+public:
+  My_Task (void) {}
+  // Constructor.
+
+  virtual ~My_Task (void) {}
+  // Destructor.
+
+  int open (void *proactor)
+    {
+      // Store the proactor.
+      this->proactor_ = (ACE_Proactor *) proactor;
+
+      // Activate the Task.
+      this->activate (THR_NEW_LWP, 5);
+      return 0;
+    }
+
+  int svc (void)
+    {
+      // Handle events for 13 seconds.
+      ACE_Time_Value run_time (13);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t):Starting svc routine\n"));
+
+      if (this->proactor_->handle_events (run_time) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "(%t):%p.\n", "Worker::svc"), -1);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t) work complete\n"));
+
+      return 0;
+    }
+
+private:
+  ACE_Proactor *proactor_;
+  // Proactor for this task.
+};
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  ACE_UNUSED_ARG (argc);
+  ACE_UNUSED_ARG (argv);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P | %t):Test starts \n"));
+
+  // = Get two POSIX_SIG_Proactors, one with SIGRTMIN and one with
+  //   SIGRTMAX.
+
+  ACE_Proactor  proactor1;
+  // Proactor1. SIGRTMIN Proactor. (default).
+
+  // = Proactor2. SIGRTMAX Proactor.
+#if defined (ACE_HAS_AIO_CALLS) && defined (ACE_HAS_POSIX_REALTIME_SIGNALS)
+
+  ACE_DEBUG ((LM_DEBUG, "Using ACE_POSIX_SIG_Proactor\n"));
+
+  sigset_t signal_set;
+  // Signal set that we want to mask.
+
+  // Clear the signal set.
+  if (sigemptyset (&signal_set) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Error:%p\n",
+                       "sigemptyset failed"),
+                      1);
+
+  // Add the SIGRTMAX to the signal set.
+  if (sigaddset (&signal_set, ACE_SIGRTMAX) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Error:%p\n",
+                       "sigaddset failed"),
+                      1);
+
+  // Make the POSIX Proactor.
+  ACE_POSIX_SIG_Proactor posix_proactor (signal_set);
+  // Get the Proactor interface out of it.
+  ACE_Proactor proactor2 (&posix_proactor);
+#else /* ACE_HAS_AIO_CALLS && ACE_HAS_POSIX_REALTIME_SIGNALS */
+  ACE_Proactor proactor2;
+#endif /* ACE_HAS_AIO_CALLS && ACE_HAS_POSIX_REALTIME_SIGNALS */
+
+  // = Create Tasks. One pool of threads to handle completions on
+  //   SIGRTMIN and the other one to handle completions on SIGRTMAX.
+  My_Task task1, task2;
+  task1.open (&proactor1);
+  task2.open (&proactor2);
+
+  // Handler for completions.
+  My_Handler handler;
+
+  // = Create a few MyResult objects and post them to Proactor.
+  const size_t NrCompletions (10);
+  My_Result *result_objects [NrCompletions];
+  int signal_number = ACE_SIGRTMAX;
+  size_t ri = 0;
+
+  Completions_To_Go = NrCompletions;
+
+  // Creation.
+  for (ri = 0; ri < NrCompletions; ri++)
+    {
+      // Use RTMIN and RTMAX proactor alternatively, to post
+      // completions.
+      if (ri % 2)
+        signal_number = ACE_SIGRTMIN;
+      else
+        signal_number = ACE_SIGRTMAX;
+      // Create the result.
+      ACE_NEW_RETURN (result_objects [ri],
+                      My_Result (handler,
+                                 0,
+                                 signal_number,
+                                 ri),
+                      1);
+    }
+  ACE_OS::sleep(5);
+  // Post all the result objects.
+  ACE_Proactor *proactor;
+  for (ri = 0; ri < NrCompletions; ri++)
+    {
+      // Use RTMIN and RTMAX Proactor alternatively, to post
+      // completions.
+      if (ri % 2)
+        proactor = &proactor1;
+      else
+        proactor = &proactor2;
+      if (result_objects [ri]->post_completion (proactor->implementation ())
+          == -1)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Test failed\n"),
+                          1);
+    }
+
+  ACE_Thread_Manager::instance ()->wait ();
+
+  int status = 0;
+  size_t to_go = Completions_To_Go.value ();
+  if (size_t (0) != to_go)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "Fail! Expected all completions to finish but %u to go\n",
+                  to_go));
+      status = 1;
+    }
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P | %t):Test ends\n"));
+  return status;
+}
+
+#else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
+
+int
+main (int, char *[])
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "This example cannot work with AIOCB_Proactor.\n"));
+  return 1;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
+
diff --git a/ACE/examples/Reactor/Proactor/simple_test_proactor.cpp b/ACE/examples/Reactor/Proactor/simple_test_proactor.cpp
new file mode 100644
index 00000000000..1f4557d7df5
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/simple_test_proactor.cpp
@@ -0,0 +1,269 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    simple_test_proactor.cpp
+//
+// = DESCRIPTION
+//    Very simple version of test_proactor.cpp.
+//
+// = AUTHOR
+//    Alexander Babu Arulanthu (alex@cs.wustl.edu)
+//
+// ============================================================================
+
+#include "ace/Service_Config.h"
+#include "ace/Proactor.h"
+#include "ace/Asynch_IO.h"
+#include "ace/Asynch_IO_Impl.h"
+#include "ace/Message_Block.h"
+#include "ace/Get_Opt.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(Proactor, test_proactor, "simple_test_proactor.cpp,v 1.1 1999/05/18 22:15:30 alex Exp")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
+  // This only works on Win32 platforms and on Unix platforms supporting
+  // POSIX aio calls.
+
+static ACE_TCHAR *file = ACE_TEXT("simple_test_proactor.cpp");
+static ACE_TCHAR *dump_file = ACE_TEXT("simple_output");
+
+class Simple_Tester : public ACE_Handler
+{
+  // = TITLE
+  //
+  //     Simple_Tester
+  //
+  // = DESCRIPTION
+  //
+  //     The class will be created by main(). This class reads a block
+  // from the file and write that to the dump file.
+
+public:
+  Simple_Tester (void);
+  // Constructor.
+
+  ~Simple_Tester (void);
+
+  int open (void);
+  // Open the operations and initiate read from the file.
+
+protected:
+  // = These methods are called by the freamwork.
+
+  virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result);
+  // This is called when asynchronous reads from the socket complete.
+
+  virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result);
+  // This is called when asynchronous writes from the socket complete.
+
+private:
+  int initiate_read_file (void);
+
+  ACE_Asynch_Read_File rf_;
+  // rf (read file): for writing from the file.
+
+  ACE_Asynch_Write_File wf_;
+  // ws (write File): for writing to the file.
+
+  ACE_HANDLE input_file_;
+  // File to read from.
+
+  ACE_HANDLE dump_file_;
+  // File for dumping data.
+
+  // u_long file_offset_;
+  // Current file offset
+
+  // u_long file_size_;
+  // File size
+};
+
+
+Simple_Tester::Simple_Tester (void)
+  : input_file_ (ACE_INVALID_HANDLE),
+    dump_file_ (ACE_INVALID_HANDLE)
+{
+}
+
+Simple_Tester::~Simple_Tester (void)
+{
+  ACE_OS::close (this->input_file_);
+  ACE_OS::close (this->dump_file_);
+}
+
+
+int
+Simple_Tester::open (void)
+{
+  // Initialize stuff
+
+  // Open input file (in OVERLAPPED mode)
+  this->input_file_ = ACE_OS::open (file,
+                                    GENERIC_READ | FILE_FLAG_OVERLAPPED);
+  if (this->input_file_ == ACE_INVALID_HANDLE)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_OS::open"), -1);
+
+  // Open dump file (in OVERLAPPED mode)
+  this->dump_file_ = ACE_OS::open (dump_file,
+                                   O_CREAT | O_RDWR | O_TRUNC | FILE_FLAG_OVERLAPPED,
+                                   0644);
+  if (this->dump_file_ == ACE_INVALID_HANDLE)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_OS::open"), -1);
+
+  // Open ACE_Asynch_Read_File
+  if (this->rf_.open (*this, this->input_file_) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Read_File::open"), -1);
+
+  // Open ACE_Asynch_Write_File
+  if (this->wf_.open (*this, this->dump_file_) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Write_File::open"), -1);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "Simple_Tester::open: Files and Asynch Operations opened sucessfully\n"));
+
+
+  // Start an asynchronous read file
+  if (this->initiate_read_file () == -1)
+    return -1;
+
+  return 0;
+}
+
+
+int
+Simple_Tester::initiate_read_file (void)
+{
+  // Create Message_Block
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb, ACE_Message_Block (BUFSIZ + 1), -1);
+
+  // Inititiate an asynchronous read from the file
+  if (this->rf_.read (*mb,
+		      mb->size () - 1) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Read_File::read"), -1);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "Simple_Tester:initiate_read_file: Asynch Read File issued sucessfully\n"));
+
+  return 0;
+}
+
+void
+Simple_Tester::handle_read_file (const ACE_Asynch_Read_File::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG, "handle_read_file called\n"));
+
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  // Watch out if you need to enable this... the ACE_Log_Record::MAXLOGMSGLEN
+  // value controls to max length of a log record, and a large output
+  // buffer may smash it.
+#if 0
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n",
+              "message_block",
+              result.message_block ().rd_ptr ()));
+#endif /* 0 */
+
+  if (result.success ())
+    {
+      // Read successful: write this to the file.
+      if (this->wf_.write (result.message_block (),
+			   result.bytes_transferred ()) == -1)
+	{
+	  ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Asynch_Write_File::write"));
+	  return;
+	}
+    }
+}
+
+void
+Simple_Tester::handle_write_file (const ACE_Asynch_Write_File::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG, "handle_write_File called\n"));
+
+  // Reset pointers
+  result.message_block ().rd_ptr (result.message_block ().rd_ptr () - result.bytes_transferred ());
+
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  // Watch out if you need to enable this... the ACE_Log_Record::MAXLOGMSGLEN
+  // value controls to max length of a log record, and a large output
+  // buffer may smash it.
+#if 0
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n",
+              "message_block",
+              result.message_block ().rd_ptr ()));
+#endif  /* 0 */
+  ACE_Proactor::end_event_loop ();
+}
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("f:d:"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    switch (c)
+      {
+      case 'f':
+	file = get_opt.opt_arg ();
+	break;
+      case 'd':
+	dump_file = get_opt.opt_arg ();
+	break;
+      default:
+	ACE_ERROR ((LM_ERROR, "%p.\n",
+		    "usage :\n"
+                    "-d <dumpfile>\n"
+		    "-f <file>\n"));
+	return -1;
+      }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  if (parse_args (argc, argv) == -1)
+    return -1;
+
+  Simple_Tester Simple_Tester;
+
+  if (Simple_Tester.open () == -1)
+    return -1;
+
+  int success = 1;
+
+  // dispatch events
+  success = !(ACE_Proactor::run_event_loop () == -1);
+
+  return success ? 0 : 1;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
diff --git a/ACE/examples/Reactor/Proactor/test_aiocb.cpp b/ACE/examples/Reactor/Proactor/test_aiocb.cpp
new file mode 100644
index 00000000000..c9c0d280f1b
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_aiocb.cpp
@@ -0,0 +1,239 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    proactor
+//
+// = FILENAME
+//    test_aiocb.cpp
+//
+// = DESCRIPTION
+//    Checkout $ACE_ROOT/examples/Reactor/Proactor/test_aiocb_ace.cpp,
+//    which is the ACE'ified version of this program. 
+// 
+// = COMPILE and RUN
+//    % CC -g -o test_aiocb -lrt test_aiocb.cpp
+//    % ./test_aiocb
+// 
+// = AUTHOR
+//    Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// ============================================================================
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <iostream.h>
+
+#include <aio.h>
+
+class Test_Aio
+{
+public:
+  Test_Aio (void);
+  // Default constructor.
+
+  int init (void);
+  // Initting the output file and the buffer.
+
+  int do_aio (void);
+  // Doing the testing stuff.
+
+  ~Test_Aio (void);
+  // Destructor.
+private:
+  int out_fd_;
+  // Output file descriptor.
+
+  struct aiocb *aiocb_write_;
+  // For writing to the file.
+
+  struct aiocb *aiocb_read_;
+  // Reading stuff from the file.
+
+  char *buffer_write_;
+  // The buffer to be written to the out_fd.
+
+  char *buffer_read_;
+  // The buffer to be read back from the file.
+};
+
+Test_Aio::Test_Aio (void)
+  : aiocb_write_ (new struct aiocb),
+    aiocb_read_ (new struct aiocb),
+    buffer_write_ (0),
+    buffer_read_ (0)
+{
+}
+
+Test_Aio::~Test_Aio (void)
+{
+  delete aiocb_write_;
+  delete aiocb_read_;
+  delete buffer_write_;
+  delete buffer_read_;
+}
+
+// Init the output file and init the buffer.
+int
+Test_Aio::init (void)
+{
+  // Open the output file.
+  this->out_fd_ = open ("test_aio.log", O_RDWR | O_CREAT | O_TRUNC, 0666);
+  if (this->out_fd_ == 0)
+    {
+      cout << "Error : Opening file" << endl;
+      return -1;
+    }
+
+  // Init the buffers.
+  this->buffer_write_ = strdup ("Welcome to the world of AIO... AIO Rules !!!");
+  cout << "The buffer : " << this->buffer_write_ << endl;
+  this->buffer_read_ = new char [strlen (this->buffer_write_) + 1];
+  return 0;
+}
+
+// Set the necessary things for the AIO stuff.
+// Write the buffer asynchly.hmm Disable signals.
+// Go on aio_suspend. Wait for completion.
+// Print out the result.
+int
+Test_Aio::do_aio (void)
+{
+  // = Write to the file.
+
+  // Setup AIOCB.
+  this->aiocb_write_->aio_fildes = this->out_fd_;
+  this->aiocb_write_->aio_offset = 0;
+  this->aiocb_write_->aio_buf = this->buffer_write_;
+  this->aiocb_write_->aio_nbytes = strlen (this->buffer_write_);
+  this->aiocb_write_->aio_reqprio = 0;
+  this->aiocb_write_->aio_sigevent.sigev_notify = SIGEV_NONE;
+  //this->this->aiocb_.aio_sigevent.sigev_signo = SIGRTMAX;
+  this->aiocb_write_->aio_sigevent.sigev_value.sival_ptr =
+    (void *) this->aiocb_write_;
+
+  // Fire off the aio write.
+  if (aio_write (this->aiocb_write_) != 0)
+    {
+      perror ("aio_write");
+      return -1;
+    }
+
+  // = Read from that file.
+
+  // Setup AIOCB.
+  this->aiocb_read_->aio_fildes = this->out_fd_;
+  this->aiocb_read_->aio_offset = 0;
+  this->aiocb_read_->aio_buf = this->buffer_read_;
+  this->aiocb_read_->aio_nbytes = strlen (this->buffer_write_);
+  this->aiocb_read_->aio_reqprio = 0;
+  this->aiocb_read_->aio_sigevent.sigev_notify = SIGEV_NONE;
+  //this->this->aiocb_.aio_sigevent.sigev_signo = SIGRTMAX;
+  this->aiocb_read_->aio_sigevent.sigev_value.sival_ptr =
+    (void *) this->aiocb_read_;
+
+  // Fire off the aio write. If it doesnt get queued, carry on to get
+  // the completion for the first one.
+  if (aio_read (this->aiocb_read_) < 0)
+    perror ("aio_read");
+  
+  // Wait for the completion on aio_suspend.
+  struct aiocb *list_aiocb[2];
+  list_aiocb [0] = this->aiocb_write_;
+  list_aiocb [1] = this->aiocb_read_;
+
+  // Do suspend till all the aiocbs in the list are done.
+  int done = 0;
+  int return_val = 0;
+  while (!done)
+    {
+      return_val = aio_suspend (list_aiocb,
+                                2,
+                                0);
+      cerr << "Return value :" << return_val << endl;
+
+      // Analyze return and error values.
+      if (list_aiocb[0] != 0)
+        {
+          if (aio_error (list_aiocb [0]) != EINPROGRESS)
+            {
+              if (aio_return (list_aiocb [0]) == -1)
+                {
+                  perror ("aio_return");
+                  return -1;
+                }
+              else
+                {
+                  // Successful. Store the pointer somewhere and make the
+                  // entry NULL in the list.
+                  this->aiocb_write_ = list_aiocb [0];
+                  list_aiocb [0] = 0;
+                }
+            }
+          else
+            cout << "AIO write in progress" << endl;
+        }
+
+      if (list_aiocb[1] != 0)
+        {
+          if (aio_error (list_aiocb [1]) != EINPROGRESS)
+            {
+              int read_return = aio_return (list_aiocb[1]);
+              if (read_return == -1)
+                {
+                  perror ("aio_return");
+                  return -1;
+                }
+              else
+                {
+                  // Successful. Store the pointer somewhere and make the
+                  // entry NULL in the list.
+                  this->aiocb_read_ = list_aiocb [1];
+                  list_aiocb [1] = 0;
+                  this->buffer_read_[read_return] = '\0';
+                }
+            }
+          else
+            cout << "AIO read in progress" << endl;
+        }
+
+      // Is it done?
+      if ((list_aiocb [0] == 0) && (list_aiocb [1] == 0))
+        done = 1;
+    }
+
+  cout << "Both the AIO operations done." << endl;
+  cout << "The buffer is :" << this->buffer_read_ << endl;
+  
+  return 0;
+}
+
+int
+main (int argc, char **argv)
+{
+  Test_Aio test_aio;
+
+  if (test_aio.init () != 0)
+    {
+      printf ("AIOCB test failed:\n"
+              "ACE_POSIX_AIOCB_PROACTOR may not work in this platform\n");
+      return -1;
+    }
+  
+  if (test_aio.do_aio () != 0)
+    {
+      printf ("AIOCB test failed:\n"
+              "ACE_POSIX_AIOCB_PROACTOR may not work in this platform\n"); 
+      return -1;
+    }
+  printf ("AIOCB test successful:\n"
+          "ACE_POSIX_AIOCB_PROACTOR should work in this platform\n");
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Proactor/test_aiocb_ace.cpp b/ACE/examples/Reactor/Proactor/test_aiocb_ace.cpp
new file mode 100644
index 00000000000..17705de1f03
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_aiocb_ace.cpp
@@ -0,0 +1,259 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    proactor
+//
+// = FILENAME
+//    test_aiocb_ace.cpp
+//
+// = DESCRIPTION
+//    This program helps you to test the <aio_*> calls on a
+//    platform.
+//
+//    Before running this test, make sure the platform can 
+//    support POSIX <aio_> calls, using
+//    ACE_ROOT/tests/Aio_Platform_Test.
+// 
+//    This program tests the AIOCB (AIO Control Blocks) based
+//    completion approach which uses <aio_suspend> for completion
+//    querying. 
+// 
+//    If this test is successful, ACE_POSIX_AIOCB_PROACTOR
+//    can be used on this platform.
+// 
+// = COMPILE and RUN
+//    % make
+//    % ./test_aiocb_ace
+// 
+// = AUTHOR
+//    Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "ace/ACE.h"
+#include "ace/Log_Msg.h"
+#include "ace/os_include/os_aio.h"
+#include "ace/OS_NS_string.h"
+
+class Test_Aio
+{
+public:
+  Test_Aio (void);
+  // Default constructor.
+
+  int init (void);
+  // Initting the output file and the buffer.
+
+  int do_aio (void);
+  // Doing the testing stuff.
+
+  ~Test_Aio (void);
+  // Destructor.
+private:
+  int out_fd_;
+  // Output file descriptor.
+
+  struct aiocb *aiocb_write_;
+  // For writing to the file.
+
+  struct aiocb *aiocb_read_;
+  // Reading stuff from the file.
+
+  char *buffer_write_;
+  // The buffer to be written to the out_fd.
+
+  char *buffer_read_;
+  // The buffer to be read back from the file.
+};
+
+Test_Aio::Test_Aio (void)
+  : aiocb_write_ (0),
+    aiocb_read_ (0),
+    buffer_write_ (0),
+    buffer_read_ (0)
+{
+  ACE_NEW (this->aiocb_write_,
+           struct aiocb);
+  ACE_NEW (this->aiocb_read_,
+           struct aiocb);
+}
+
+Test_Aio::~Test_Aio (void)
+{
+  delete aiocb_write_;
+  delete aiocb_read_;
+  delete buffer_write_;
+  delete buffer_read_;
+}
+
+// Init the output file and init the buffer.
+int
+Test_Aio::init (void)
+{
+  // Open the output file.
+  this->out_fd_ = ACE_OS::open ("test_aio.log",
+                                O_RDWR | O_CREAT | O_TRUNC,
+                                0666); 
+  if (this->out_fd_ == 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Error: Opening file\n"),
+                      -1);
+
+  // Init the buffers.
+  this->buffer_write_ = ACE::strnew ("Welcome to the world of AIO... AIO Rules !!!");
+  ACE_DEBUG ((LM_DEBUG,
+              "The buffer : %s\n",
+              this->buffer_write_));
+  
+  // Allocate memory for the read buffer.
+  ACE_NEW_RETURN (this->buffer_read_,
+                  char [ACE_OS::strlen (this->buffer_write_)],
+                  -1);
+
+  return 0;
+}
+
+// Set the necessary things for the AIO stuff.
+// Write the buffer asynchly.hmm Disable signals.
+// Go on aio_suspend. Wait for completion.
+// Print out the result.
+int
+Test_Aio::do_aio (void)
+{
+  // = Write to the file.
+
+  // Setup AIOCB.
+  this->aiocb_write_->aio_fildes = this->out_fd_;
+  this->aiocb_write_->aio_offset = 0;
+  this->aiocb_write_->aio_buf = this->buffer_write_;
+  this->aiocb_write_->aio_nbytes = ACE_OS::strlen (this->buffer_write_);
+  this->aiocb_write_->aio_reqprio = 0;
+  this->aiocb_write_->aio_sigevent.sigev_notify = SIGEV_NONE;
+  //this->this->aiocb_.aio_sigevent.sigev_signo = SIGRTMAX;
+  this->aiocb_write_->aio_sigevent.sigev_value.sival_ptr =
+    (void *) this->aiocb_write_;
+  
+  // Fire off the aio write.
+  if (aio_write (this->aiocb_write_) != 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "aio_write"),
+                      -1);
+  
+  // = Read from that file.
+
+  // Setup AIOCB.
+  this->aiocb_read_->aio_fildes = this->out_fd_;
+  this->aiocb_read_->aio_offset = 0;
+  this->aiocb_read_->aio_buf = this->buffer_read_;
+  this->aiocb_read_->aio_nbytes = ACE_OS::strlen (this->buffer_write_);
+  this->aiocb_read_->aio_reqprio = 0;
+  this->aiocb_read_->aio_sigevent.sigev_notify = SIGEV_NONE;
+  //this->this->aiocb_.aio_sigevent.sigev_signo = SIGRTMAX;
+  this->aiocb_read_->aio_sigevent.sigev_value.sival_ptr =
+    (void *) this->aiocb_read_;
+
+  // Fire off the aio write. If it doesnt get queued, carry on to get
+  // the completion for the first one.
+  if (aio_read (this->aiocb_read_) < 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "aio_read"),
+                      -1);
+  
+  // Wait for the completion on aio_suspend.
+  struct aiocb *list_aiocb[2];
+  list_aiocb [0] = this->aiocb_write_;
+  list_aiocb [1] = this->aiocb_read_;
+
+  // Do suspend till all the aiocbs in the list are done.
+  int to_finish = 2;
+  int return_val = 0;
+  while (to_finish > 0)
+    {
+      return_val = aio_suspend (list_aiocb,
+                                to_finish,
+                                0);
+      ACE_DEBUG ((LM_DEBUG,
+                  "Result of <aio_suspend> : %d\n",
+                  return_val));
+
+      // Analyze return and error values.     
+      if (to_finish > 1)
+        {
+          if (aio_error (list_aiocb [1]) != EINPROGRESS)
+            {
+              if (aio_return (list_aiocb [1]) == -1)
+                ACE_ERROR_RETURN ((LM_ERROR,
+                                   "%p\n",
+                                   "aio_return, item 1"),
+                                  -1);
+              else
+                {
+                  // Successful. Remember we have one less thing to finish.
+                  --to_finish;
+                  list_aiocb [1] = 0;
+                }
+            }
+          else
+            ACE_DEBUG ((LM_DEBUG, 
+                        "aio_error says aio 1 is in progress\n"));
+        }
+
+      if (aio_error (list_aiocb [0]) != EINPROGRESS)
+        {
+          if (aio_return (list_aiocb [0]) == -1)
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               "%p\n",
+                               "aio_return, item 0"),
+                              -1);
+          else
+            {
+              // Successful. Store the pointer somewhere and bump the
+              // read entry up to the front, if it is still not done.
+              --to_finish;
+              list_aiocb [0] = this->aiocb_read_;
+            }
+        }
+      else
+        ACE_DEBUG ((LM_DEBUG, 
+                    "aio_error says aio 0 is in progress\n"));
+    }
+
+  ACE_DEBUG ((LM_DEBUG, 
+              "Both the AIO operations done.\n"
+              "The buffer is : %s\n",
+              this->buffer_read_));
+  
+  return 0;
+}
+
+int
+main (int argc, char **argv)
+{
+
+  ACE_UNUSED_ARG (argc);
+  ACE_UNUSED_ARG (argv);
+
+  Test_Aio test_aio;
+
+  if (test_aio.init () != 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "AIOCB test failed:\n"
+                       "ACE_POSIX_AIOCB_PROACTOR may not work in this platform\n"),
+                      -1);
+  
+  if (test_aio.do_aio () != 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "AIOCB test failed:\n"
+                       "ACE_POSIX_AIOCB_PROACTOR may not work in this platform\n"),
+                      -1);
+  
+  ACE_DEBUG ((LM_DEBUG,
+              "AIOCB test successful:\n"
+              "ACE_POSIX_AIOCB_PROACTOR should work in this platform\n"));
+  
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Proactor/test_aiosig.cpp b/ACE/examples/Reactor/Proactor/test_aiosig.cpp
new file mode 100644
index 00000000000..1746a10a49c
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_aiosig.cpp
@@ -0,0 +1,294 @@
+// $Id$
+// ============================================================================
+//
+// = FILENAME
+//     test_aiosig.cpp
+//
+// = DESCRITPTION
+//     Check out test_aiosig_ace.cpp, the ACE'ified version of this
+//     program. This program may not be uptodate.
+//
+// = COMPILATION
+//     CC -g -o test_aiosig -lrt test_aiosig.cpp   
+//
+// = RUN
+//     ./test_aiosig
+//
+// = AUTHOR
+//     Programming for the Real World. Bill O. GallMeister.
+//     Modified by Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// =====================================================================
+
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+
+#include <limits.h>
+
+#include <aio.h>
+
+int file_handle = -1;
+char mb1 [BUFSIZ + 1];
+char mb2 [BUFSIZ + 1];
+aiocb aiocb1, aiocb2;
+sigset_t completion_signal;
+
+// Function prototypes.
+int setup_signal_delivery (void);
+int issue_aio_calls (void);
+int query_aio_completions (void);
+int test_aio_calls (void);
+int setup_signal_handler (void);
+int setup_signal_handler (int signal_number);
+
+int 
+setup_signal_delivery (void)
+{
+  // Make the sigset_t consisting of the completion signal.
+  if (sigemptyset (&completion_signal) == -1)
+    {
+      perror ("Error:Couldnt init the RT completion signal set\n");
+      return -1;
+    }
+  
+  if (sigaddset (&completion_signal, SIGRTMIN) == -1)
+    {
+      perror ("Error:Couldnt init the RT completion signal set\n");
+      return -1;
+    }
+  
+  // Mask them.
+  if (pthread_sigmask (SIG_BLOCK, &completion_signal, 0) == -1)
+    {
+      perror ("Error:Couldnt maks the RT completion signals\n");
+      return -1;
+    }
+  
+  return setup_signal_handler (SIGRTMIN);
+}
+
+int
+issue_aio_calls (void)
+{
+  // Setup AIOCB.
+  aiocb1.aio_fildes = file_handle;
+  aiocb1.aio_offset = 0;
+  aiocb1.aio_buf = mb1;
+  aiocb1.aio_nbytes = BUFSIZ;
+  aiocb1.aio_reqprio = 0;
+  aiocb1.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+  aiocb1.aio_sigevent.sigev_signo = SIGRTMIN;
+  aiocb1.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb1; 
+  
+  // Fire off the aio write.
+  if (aio_read (&aiocb1) == -1)
+    {
+      // Queueing failed.
+      perror ("Error:Asynch_Read_Stream: aio_read queueing failed\n");
+      return -1;
+    }
+  
+  // Setup AIOCB.
+  aiocb2.aio_fildes = file_handle;
+  aiocb2.aio_offset = BUFSIZ + 1;
+  aiocb2.aio_buf = mb2;
+  aiocb2.aio_nbytes = BUFSIZ;
+  aiocb2.aio_reqprio = 0;
+  aiocb2.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+  aiocb2.aio_sigevent.sigev_signo = SIGRTMIN;
+  aiocb2.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb2; 
+  
+  // Fire off the aio write.
+  if (aio_read (&aiocb2) == -1)
+    {
+      // Queueing failed.
+      perror ("Error:Asynch_Read_Stream: aio_read queueing failed\n");
+      return -1;
+    }
+  return 0;
+}
+
+int
+query_aio_completions (void)
+{
+  int result = 0;
+  size_t number_of_compleions = 0;
+  for (number_of_compleions = 0;
+       number_of_compleions < 2;
+       number_of_compleions ++)
+    {
+      // Wait for <milli_seconds> amount of time.
+      // @@ Assigning <milli_seconds> to tv_sec.
+      timespec timeout;
+      timeout.tv_sec = INT_MAX;
+      timeout.tv_nsec = 0;
+  
+      // To get back the signal info.
+      siginfo_t sig_info;
+      
+      // Await the RT completion signal.
+      int sig_return = sigtimedwait (&completion_signal,
+                                     &sig_info,
+                                     &timeout);
+      
+      // Error case.
+      // If failure is coz of timeout, then return *0* but set
+      // errno appropriately. This is what the WinNT proactor
+      // does.
+      if (sig_return == -1)
+        {
+          perror ("Error:Error waiting for RT completion signals\n");
+          return -1;
+        }
+      
+      // RT completion signals returned.
+      if (sig_return != SIGRTMIN)
+        {
+          printf ("Unexpected signal (%d) has been received while waiting for RT Completion Signals\n",
+                  sig_return);
+          return -1;
+        }
+      
+      // @@ Debugging.
+      printf ("Sig number found in the sig_info block : %d\n",
+              sig_info.si_signo);
+  
+      // Is the signo returned consistent?
+      if (sig_info.si_signo != sig_return)
+        {
+          printf ("Inconsistent signal number (%d) in the signal info block\n",
+                  sig_info.si_signo);
+          return -1;
+        }
+  
+      // @@ Debugging.
+      printf ("Signal code for this signal delivery : %d\n",
+              sig_info.si_code);
+  
+      // Is the signal code an aio completion one?
+      if ((sig_info.si_code != SI_ASYNCIO) &&
+          (sig_info.si_code != SI_QUEUE))
+        {
+          printf ("Unexpected signal code (%d) returned on completion querying\n",
+                  sig_info.si_code);
+          return -1;
+        }
+  
+      // Retrive the aiocb.
+      aiocb* aiocb_ptr = (aiocb *) sig_info.si_value.sival_ptr;
+      
+      // Analyze error and return values. Return values are
+      // actually <errno>'s associated with the <aio_> call
+      // corresponding to aiocb_ptr.
+      int error_code = aio_error (aiocb_ptr);
+      if (error_code == -1)
+        {
+          perror ("Error:Invalid control block was sent to <aio_error> for compleion querying\n");
+          return -1;
+        }
+  
+      if (error_code != 0)
+        {
+          // Error occurred in the <aio_>call. Return the errno
+          // corresponding to that <aio_> call.
+          printf ("Error:An AIO call has failed:Error code = %d\n",
+                  error_code);
+          return -1;
+        }
+
+      // No error occured in the AIO operation.
+      int nbytes = aio_return (aiocb_ptr);
+      if (nbytes == -1)
+        {
+          perror ("Error:Invalid control block was send to <aio_return>\n");
+          return -1;
+        }
+      
+      if (number_of_compleions == 0)
+        // Print the buffer.
+        printf ("Number of bytes transferred : %d\n The buffer : %s \n",
+                nbytes,
+                mb1);
+      else
+        // Print the buffer.
+        printf ("Number of bytes transferred : %d\n The buffer : %s \n",
+                nbytes,
+                mb2);
+    }
+  return 0;
+}
+
+int
+test_aio_calls (void) 
+{
+  // Set up the input file.
+  // Open file (in SEQUENTIAL_SCAN mode)
+  file_handle = open ("test_aiosig.cpp", O_RDONLY);
+  
+  if (file_handle == -1)
+    {
+      perror ("Error:Opening the inputfile");
+      return -1;
+    }
+  
+  if (setup_signal_delivery () < 0)
+    return -1;
+  
+  if (issue_aio_calls () < 0)
+    return -1;
+  
+  if (query_aio_completions () < 0)
+    return -1;
+  
+  return 0;
+}
+
+int
+setup_signal_handler (int signal_number)
+{
+   // Setting up the handler(!) for these signals.
+  struct sigaction reaction;
+  sigemptyset (&reaction.sa_mask);   // Nothing else to mask.
+  reaction.sa_flags = SA_SIGINFO;    // Realtime flag.
+#if defined (SA_SIGACTION)
+  // Lynx says, it is better to set this bit to be portable.
+  reaction.sa_flags &= SA_SIGACTION;
+#endif /* SA_SIGACTION */      
+  reaction.sa_sigaction = null_handler;     // Null handler.
+  int sigaction_return = sigaction (SIGRTMIN,
+                                    &reaction,
+                                    0);
+  if (sigaction_return == -1)
+    {
+      perror ("Error:Proactor couldnt do sigaction for the RT SIGNAL");
+      return -1;
+    }
+  
+  return 0;
+}
+
+void
+null_handler (int         /* signal_number */,
+              siginfo_t * /* info */,
+              void *      /* context */)
+{
+}
+
+int
+main (int, char *[])
+{
+  if (test_aio_calls () == 0)
+    printf ("RT SIG test successful:\n"
+            "ACE_POSIX_SIG_PROACTOR should work in this platform\n");
+  else
+    printf ("RT SIG test failed:\n"
+            "ACE_POSIX_SIG_PROACTOR may not work in this platform\n");
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Proactor/test_aiosig_ace.cpp b/ACE/examples/Reactor/Proactor/test_aiosig_ace.cpp
new file mode 100644
index 00000000000..34c1b9b5ab2
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_aiosig_ace.cpp
@@ -0,0 +1,358 @@
+// $Id$
+
+// ============================================================================
+//
+// = FILENAME
+//     test_aiosig_sig.cpp
+//
+// = DESCRITPTION
+//     This program helps you to test the <aio_*> calls on a
+//     platform. 
+//     Before running this test, make sure the platform can
+//     support POSIX <aio_> calls, using ACE_ROOT/tests/Aio_Plaform_Test.cpp
+// 
+//     This  program tests the Signal based completion approach which 
+//     uses <sigtimedwait> for completion querying. 
+//     If this test is successful, ACE_POSIX_SIG_PROACTOR
+//     can be used on this platform.
+// 
+//     This program is a ACE version of the 
+//     $ACE_ROOT/examples/Reactor/Proactor/test_aiosig.cpp, with
+//     ACE_DEBUGs and Message_Blocks.
+//
+//     This test does the following:
+//     Issue two <aio_read>s.
+//     Assign SIGRTMIN as the notification signal.
+//     Mask these signals from delivery.
+//     Receive this signal by doing <sigtimedwait>.
+//     Wait for two completions (two signals)
+// 
+// = COMPILATION
+//     make 
+//
+// = RUN
+//     ./test_aiosig_ace
+//
+// = AUTHOR
+//     Programming for the Real World. Bill O. GallMeister.
+//     Modified by Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// =====================================================================
+
+#include "ace/Message_Block.h"
+#include "ace/Log_Msg.h"
+#include "ace/os_include/os_aio.h"
+#include "ace/OS_NS_signal.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_NS_fcntl.h"
+#include "ace/Asynch_IO.h" // for ACE_INFINITE
+
+static ACE_HANDLE file_handle = ACE_INVALID_HANDLE;
+static ACE_Message_Block mb1 (BUFSIZ + 1);
+static ACE_Message_Block mb2 (BUFSIZ + 1);
+static aiocb aiocb1;
+static aiocb aiocb2;
+static aiocb aiocb3;
+static sigset_t completion_signal;
+
+// Function prototypes.
+static int setup_signal_delivery (void);
+static int issue_aio_calls (void);
+static int query_aio_completions (void);
+static int test_aio_calls (void);
+static void null_handler (int signal_number, siginfo_t *info, void *context);
+static int setup_signal_handler (int signal_number);
+
+static int
+setup_signal_delivery (void)
+{
+  // = Mask all the signals.
+  
+  sigset_t full_set;
+  
+  // Get full set.
+  if (sigfillset (&full_set) != 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Error:(%P | %t):%p\n",
+                       "sigfillset failed"),
+                      -1);
+  
+  // Mask them.
+  if (ACE_OS::pthread_sigmask (SIG_SETMASK, &full_set, 0) != 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Error:(%P | %t):%p\n",
+                       "pthread_sigmask failed"),
+                      -1);
+  
+  // = Make a mask with SIGRTMIN only. We use only that signal to
+  //   issue <aio_>'s.
+  
+  if (sigemptyset (&completion_signal) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
+                       "Couldnt init the RT completion signal set"),
+                      -1);
+
+  if (sigaddset (&completion_signal,
+                 SIGRTMIN) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
+                       "Couldnt init the RT completion signal set"),
+                      -1);
+
+  // Set up signal handler for this signal.
+  return setup_signal_handler (SIGRTMIN);
+}
+
+static int
+setup_signal_handler (int signal_number)
+{
+  ACE_UNUSED_ARG (signal_number);
+
+  // Setting up the handler(!) for these signals.
+  struct sigaction reaction;
+  sigemptyset (&reaction.sa_mask);   // Nothing else to mask.
+  reaction.sa_flags = SA_SIGINFO;    // Realtime flag.
+#if defined (SA_SIGACTION)
+  // Lynx says, it is better to set this bit to be portable.
+  reaction.sa_flags &= SA_SIGACTION;
+#endif /* SA_SIGACTION */
+  reaction.sa_sigaction = null_handler; // Null handler.
+  int sigaction_return = sigaction (SIGRTMIN,
+                                    &reaction,
+                                    0);
+  if (sigaction_return == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
+                       "Proactor couldnt do sigaction for the RT SIGNAL"),
+                      -1);
+  return 0;
+}
+
+
+static int
+issue_aio_calls (void)
+{
+  // Setup AIOCB.
+  aiocb1.aio_fildes = file_handle;
+  aiocb1.aio_offset = 0;
+  aiocb1.aio_buf = mb1.wr_ptr ();
+  aiocb1.aio_nbytes = BUFSIZ;
+  aiocb1.aio_reqprio = 0;
+  aiocb1.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+  aiocb1.aio_sigevent.sigev_signo = SIGRTMIN;
+  aiocb1.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb1;
+
+  // Fire off the aio read.
+  if (aio_read (&aiocb1) == -1)
+    // Queueing failed.
+    ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
+                       "Asynch_Read_Stream: aio_read queueing failed"),
+                      -1);
+
+  // Setup AIOCB.
+  aiocb2.aio_fildes = file_handle;
+  aiocb2.aio_offset = BUFSIZ + 1;
+  aiocb2.aio_buf = mb2.wr_ptr ();
+  aiocb2.aio_nbytes = BUFSIZ;
+  aiocb2.aio_reqprio = 0;
+  aiocb2.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+  aiocb2.aio_sigevent.sigev_signo = SIGRTMIN;
+  aiocb2.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb2;
+
+  // Fire off the aio read.
+  if (aio_read (&aiocb2) == -1)
+    // Queueing failed.
+    ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
+                       "Asynch_Read_Stream: aio_read queueing failed"),
+                      -1);
+
+  // Setup sigval.
+  aiocb3.aio_fildes = ACE_INVALID_HANDLE;
+  aiocb3.aio_offset = 0;
+  aiocb3.aio_buf = 0;
+  aiocb3.aio_nbytes = 0;
+  aiocb3.aio_reqprio = 0;
+  aiocb3.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
+  aiocb3.aio_sigevent.sigev_signo = SIGRTMIN;
+  aiocb3.aio_sigevent.sigev_value.sival_ptr = (void *) &aiocb3;
+  sigval value;
+  value.sival_ptr = reinterpret_cast<void *> (&aiocb3);
+  // Queue this one for completion right now.
+  if (sigqueue (ACE_OS::getpid (), SIGRTMIN, value) == -1)
+    // Queueing failed.
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "Error: %p\n", "sigqueue"),
+                      -1);
+
+  return 0;
+}
+
+static int
+query_aio_completions (void)
+{
+  for (size_t number_of_compleions = 0;
+       number_of_compleions < 3;
+       number_of_compleions ++)
+    {
+      // Wait for <milli_seconds> amount of time.  @@ Assigning
+      // <milli_seconds> to tv_sec.
+      timespec timeout;
+      timeout.tv_sec = ACE_INFINITE;
+      timeout.tv_nsec = 0;
+      
+      // To get back the signal info.
+      siginfo_t sig_info;
+      
+      // Await the RT completion signal.
+      int sig_return = sigtimedwait (&completion_signal,
+                                     &sig_info,
+                                     &timeout);
+
+      // Error case.
+      // If failure is coz of timeout, then return *0* but set
+      // errno appropriately. This is what the WinNT proactor
+      // does.
+      if (sig_return == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
+                           "Error waiting for RT completion signals"),
+                          -1);
+
+      // RT completion signals returned.
+      if (sig_return != SIGRTMIN)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Unexpected signal (%d) has been received while waiting for RT Completion Signals\n",
+                           sig_return),
+                          -1);
+
+      // @@ Debugging.
+      ACE_DEBUG ((LM_DEBUG,
+                  "Sig number found in the sig_info block : %d\n",
+                  sig_info.si_signo));
+
+      // Is the signo returned consistent?
+      if (sig_info.si_signo != sig_return)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Inconsistent signal number (%d) in the signal info block\n",
+                           sig_info.si_signo),
+                          -1);
+
+      // @@ Debugging.
+      ACE_DEBUG ((LM_DEBUG,
+                  "Signal code for this signal delivery : %d\n",
+                  sig_info.si_code));
+
+      // Is the signal code an aio completion one?
+      if ((sig_info.si_code != SI_ASYNCIO) &&
+          (sig_info.si_code != SI_QUEUE))
+        ACE_ERROR_RETURN ((LM_DEBUG,
+                           "Unexpected signal code (%d) returned on completion querying\n",
+                           sig_info.si_code),
+                          -1);
+
+      // Retrive the aiocb.
+      aiocb* aiocb_ptr = (aiocb *) sig_info.si_value.sival_ptr;
+      if (aiocb_ptr == &aiocb3)
+        {
+          ACE_ASSERT (sig_info.si_code == SI_QUEUE);
+          ACE_DEBUG ((LM_DEBUG, "sigqueue caught... good\n"));
+        }
+      else
+        {
+          // Analyze error and return values. Return values are
+          // actually <errno>'s associated with the <aio_> call
+          // corresponding to aiocb_ptr.
+          int error_code = aio_error (aiocb_ptr);
+          if (error_code == -1)
+            ACE_ERROR_RETURN ((LM_ERROR, "%p\n",
+                               "Invalid control block was sent to <aio_error> for completion querying"),
+                              -1);
+
+          if (error_code != 0)
+            // Error occurred in the <aio_>call. Return the errno
+            // corresponding to that <aio_> call.
+            ACE_ERROR_RETURN ((LM_ERROR, "%p\n",
+                               "An AIO call has failed"),
+                              error_code);
+
+          // No error occured in the AIO operation.
+          int nbytes = aio_return (aiocb_ptr);
+          if (nbytes == -1)
+            ACE_ERROR_RETURN ((LM_ERROR, "%p\n",
+                               "Invalid control block was send to <aio_return>"),
+                              -1);
+          if (number_of_compleions == 0)
+            {
+              // Print the buffer.
+              ACE_DEBUG ((LM_DEBUG,
+                          "\n Number of bytes transferred : %d\n",
+                          nbytes));
+              // Note... the dumps of the buffers are disabled because they
+              // may easily overrun the ACE_Log_Msg output buffer. If you need
+              // to turn the on for some reason, be careful of this.
+#if 0
+              ACE_DEBUG ((LM_DEBUG, "The buffer : %s \n", mb1.rd_ptr ()));
+#endif /* 0 */
+            }
+          else
+            {
+              // Print the buffer.
+              ACE_DEBUG ((LM_DEBUG,
+                          "\n Number of bytes transferred : %d\n",
+                          nbytes));
+#if 0
+              ACE_DEBUG ((LM_DEBUG, "The buffer : %s \n", mb2.rd_ptr ()));
+#endif /* 0 */
+            }
+        }
+    }
+
+  return 0;
+}
+
+static int
+test_aio_calls (void)
+{
+  // Set up the input file.
+  // Open file (in SEQUENTIAL_SCAN mode)
+  file_handle = ACE_OS::open ("test_aiosig_ace.cpp",
+                              O_RDONLY);
+
+  if (file_handle == ACE_INVALID_HANDLE)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_OS::open"),
+                      -1);
+
+  if (setup_signal_delivery () == -1)
+    return -1;
+
+  if (issue_aio_calls () == -1)
+    return -1;
+
+  if (query_aio_completions () == -1)
+    return -1;
+
+  return 0;
+}
+
+static void
+null_handler (int signal_number,
+              siginfo_t */* info */,
+              void * /* context */)
+{
+  ACE_ERROR ((LM_ERROR,
+              "Error:%s:Signal number %d\n"
+              "Mask all the RT signals for this thread",
+              "ACE_POSIX_SIG_Proactor::null_handler called",
+              signal_number));
+}
+
+int
+main (int, char *[])
+{
+  if (test_aio_calls () == 0)
+    printf ("RT SIG test successful:\n"
+            "ACE_POSIX_SIG_PROACTOR should work in this platform\n");
+  else
+    printf ("RT SIG test failed:\n"
+            "ACE_POSIX_SIG_PROACTOR may not work in this platform\n");
+  return 0;
+}
diff --git a/ACE/examples/Reactor/Proactor/test_cancel.cpp b/ACE/examples/Reactor/Proactor/test_cancel.cpp
new file mode 100644
index 00000000000..c10f8e9be2c
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_cancel.cpp
@@ -0,0 +1,246 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_cancel.cpp
+//
+// = DESCRIPTION
+//    This program tests cancelling an Asynchronous Operation in the
+//    Proactor framework.
+//
+//    This tests accepts a connection and issues an Asynchronous Read
+//    Stream. It reads <read_size> (option -s) number of bytes and
+//    when this operation completes, it issues another Asynchronous
+//    Read Stream to <read_size> and immediately calls <cancel> to
+//    cancel the operation and so the program exits closing the
+//    connection.
+//
+//    Works fine on NT. On Solaris platforms, the asynch read is
+//    pending, but the cancel returns with the value <AIO_ALLDONE>
+//    indicating all the operations in that handle are done.
+//    But, LynxOS has a good <aio_cancel> implementation. It works
+//    fine.
+//
+// = RUN
+//   ./test_cancel -p <port_number>
+//   Then telnet to this port and send <read_size> bytes and your
+//   connection should get closed down.
+//
+// = AUTHOR
+//    Irfan Pyarali (irfan@cs.wustl.edu)
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+#include "ace/Service_Config.h"
+#include "ace/Proactor.h"
+#include "ace/Asynch_IO.h"
+#include "ace/Asynch_IO_Impl.h"
+#include "ace/Asynch_Acceptor.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Connector.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Message_Block.h"
+#include "ace/Get_Opt.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_NS_sys_socket.h"
+
+ACE_RCSID (Proactor, test_proactor, "$Id$")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
+  // This only works on Win32 platforms and on Unix platforms supporting
+  // POSIX aio calls.
+
+#include "test_cancel.h"
+
+static u_short port = ACE_DEFAULT_SERVER_PORT;
+static int done = 0;
+static int read_size = 2;
+
+
+Receiver::Receiver (void)
+  : mb_ (read_size + 1),
+    handle_ (ACE_INVALID_HANDLE)
+{
+}
+
+Receiver::~Receiver (void)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "Receiver: Closing down Remote connection:%d\n",
+              this->handle_));
+
+  ACE_OS::closesocket (this->handle_);
+}
+
+void
+Receiver::open (ACE_HANDLE handle,
+		ACE_Message_Block &)
+{
+  // New connection, initiate stuff
+
+  ACE_DEBUG ((LM_DEBUG, "%N:%l:Receiver::open called\n"));
+
+  // Cache the new connection
+  this->handle_ = handle;
+
+  // Initiate ACE_Asynch_Read_Stream
+  if (this->rs_.open (*this, this->handle_) == -1)
+    {
+      ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Asynch_Read_Stream::open"));
+      return;
+    }
+
+  // Try to read <n> bytes from the stream.
+
+  ACE_DEBUG ((LM_DEBUG,
+              "Receiver::open: Issuing Asynch Read of (%d) bytes from the stream\n",
+              read_size));
+
+  if (this->rs_.read (this->mb_,
+                      read_size) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "Receiver::open: Failed to issue the read"));
+}
+
+void
+Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG, "handle_read_stream called\n"));
+
+  // Reset pointers
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+
+  if (result.success () && !result.error ())
+    {
+      // Successful read: No error.
+
+      // Set the pointers back in the message block.
+      result.message_block ().wr_ptr (result.message_block ().rd_ptr ());
+
+      // Issue another read, but immediately cancel it.
+
+      // Issue the read.
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "Issuing Asynch Read of (%d) bytes from the stream\n",
+                  read_size));
+
+      if (this->rs_.read (this->mb_,
+                          read_size) == -1)
+        ACE_ERROR ((LM_ERROR,
+                    "%p\n",
+                    "Receiver::handle_read_stream: Failed to issue the read"));
+
+      // Cancel the read.
+
+      ACE_DEBUG ((LM_DEBUG,
+                  "Cacelling Asynch Read "));
+
+      int ret_val = this->rs_.cancel ();
+      if (ret_val == -1)
+        ACE_ERROR ((LM_ERROR,
+                    "%p\n",
+                    "Receiver::handle_read_stream: Failed to cancel the read"));
+
+      ACE_DEBUG ((LM_DEBUG, "Asynch IO : Cancel : Result = %d\n",
+                  ret_val));
+    }
+  else
+    {
+      done = 1;
+
+      ACE_DEBUG ((LM_DEBUG, "Receiver completed\n"));
+
+      // Print the error message if any.
+      if (result.error () != 0)
+        {
+          errno = result.error ();
+
+          ACE_ERROR ((LM_ERROR,
+                      "%p\n",
+                      "Asynch Read Stream Error: "));
+        }
+    }
+}
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("p:s:"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    switch (c)
+      {
+      case 'p':
+        port = ACE_OS::atoi (get_opt.opt_arg ());
+	break;
+      case 's':
+	read_size = ACE_OS::atoi (get_opt.opt_arg ());
+	break;
+      default:
+	ACE_ERROR ((LM_ERROR, "%p.\n",
+		    "usage :\n"
+		    "-p <port>\n"
+		    "-s <read_size>\n"));
+	return -1;
+      }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  if (parse_args (argc, argv) == -1)
+    return -1;
+
+  // Note: acceptor parameterized by the Receiver
+  ACE_Asynch_Acceptor<Receiver> acceptor;
+
+  // Listening passively.
+  if (acceptor.open (ACE_INET_Addr (port),
+                     read_size,
+                     1) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "ACE:acceptor::open failed\n"),
+                      1);
+
+  int success = 1;
+
+  while (success > 0  && !done)
+    // dispatch events
+    success = ACE_Proactor::instance ()->handle_events ();
+
+  return 0;
+}
+
+#else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "This example does not work on this platform.\n"));
+  return 1;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
diff --git a/ACE/examples/Reactor/Proactor/test_cancel.h b/ACE/examples/Reactor/Proactor/test_cancel.h
new file mode 100644
index 00000000000..45c4bfbc85b
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_cancel.h
@@ -0,0 +1,47 @@
+/*
+** $Id$
+*/
+
+#ifndef _TEST_CANCEL_H
+#define _TEST_CANCEL_H
+
+#include "ace/Asynch_IO.h"
+
+class Receiver : public ACE_Service_Handler
+{
+  // = TITLE
+  //
+  //     Receiver
+  //
+  // = DESCRIPTION
+  //
+  //     The class will be created by ACE_Asynch_Acceptor when new
+  //     connections arrive.  This class will then receive data from
+  //     the network connection and dump it to a file.
+
+public:
+  Receiver (void);
+  ~Receiver (void);
+
+  virtual void open (ACE_HANDLE handle,
+		     ACE_Message_Block &message_block);
+  // This is called after the new connection has been accepted.
+
+protected:
+  // These methods are called by the framework
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
+  // This is called when asynchronous read from the socket complete
+
+private:
+  ACE_Asynch_Read_Stream rs_;
+  // rs (read stream): for reading from a socket
+
+  ACE_Message_Block mb_;
+  // Message block to read from the stream.
+
+  ACE_HANDLE handle_;
+  // Handle for IO to remote peer
+};
+
+#endif /* _TEST_CANCEL_H */
diff --git a/ACE/examples/Reactor/Proactor/test_end_event_loop.cpp b/ACE/examples/Reactor/Proactor/test_end_event_loop.cpp
new file mode 100644
index 00000000000..096f77b089d
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_end_event_loop.cpp
@@ -0,0 +1,168 @@
+// $Id$
+// ============================================================================
+//
+// = FILENAME
+//     test_end_event_loop.cpp
+//
+// = DESCRITPTION
+//     This program tests the event loop mechanism of the
+//     Proactor. To end the event loop, threads that are blocked in
+//     waiting for completions are  woken up and the event loop comes
+//     to the end. This is tested in this program.
+//
+//     Threads are doing <run_event_loop> with/without time_out
+//     values and the main thread calls <end_event_loop>.
+//
+// = COMPILATION
+//     make
+//
+// = RUN
+//     ./test_end_event_loop
+//
+// = AUTHOR
+//     Alexander Babu Arulanthu <alex@cs.wustl.edu>
+//
+// =====================================================================
+
+#include "ace/OS_NS_unistd.h"
+#include "ace/Proactor.h"
+#include "ace/Task.h"
+#include "ace/WIN32_Proactor.h"
+#include "ace/POSIX_Proactor.h"
+#include "ace/OS_main.h"
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || \
+     (defined (ACE_HAS_AIO_CALLS)) && !defined (ACE_POSIX_AIOCB_PROACTOR))
+// This only works on Win32 platforms and on Unix platforms supporting
+// POSIX aio calls.
+
+class My_Task: public ACE_Task <ACE_NULL_SYNCH>
+{
+  // = TITLE
+  //
+  //     Contains thread functions which execute event loops. Each
+  //     thread waits for a different signal.
+  //
+public:
+  // Constructor.
+  My_Task (void)
+    : time_flag_ (0)
+    {}
+
+
+  virtual ~My_Task (void) {}
+  // Destructor.
+
+  // If time_flag is zero do the eventloop indefinitely, otherwise do
+  // it for finite amount of time (13secs!!!).
+  int open (void *timed_event_loop)
+    {
+      // Set the local variable.
+      if (timed_event_loop == 0)
+        this->time_flag_ = 0;
+      else
+        this->time_flag_ = 1;
+
+      // Spawn the threads.
+      if (this->activate (THR_NEW_LWP, 5) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "%N:%l:%p\n",
+                           "My_Task:open: <activate> failed"),
+                          -1);
+
+      return 0;
+    }
+
+  // Thread function.
+  int svc (void)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "(%P|%t):Starting svc routine\n"));
+
+      if (this->time_flag_)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "(%P|%t):Going to do *timed* <run_event_loop> \n"));
+
+          ACE_Time_Value run_time (13);
+
+          if (ACE_Proactor::instance ()->run_event_loop (run_time) == -1)
+            ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t):%p.\n",
+                               "<Proactor::run_event_loop> failed"),
+                              -1);
+        }
+      else
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "(%P|%t):Going to do *indefinite* <run_event_loop> \n"));
+
+          if (ACE_Proactor::instance ()->run_event_loop () == -1)
+            ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t):%p.\n",
+                               "<Proactor::run_event_loop> failed"),
+                              -1);
+        }
+      return 0;
+    };
+
+private:
+  int time_flag_;
+  // If zero, indefinite event loop, otherwise timed event loop.
+};
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv [])
+{
+  ACE_UNUSED_ARG (argc);
+  ACE_UNUSED_ARG (argv);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P | %t):Test starts \n"));
+
+  // Let us get the singleton proactor created here. This is very
+  // important. This will mask the signal used in the Proactor masked
+  // for the main thread (and all the threads).
+  ACE_Proactor *proactor = ACE_Proactor::instance ();
+  ACE_UNUSED_ARG (proactor);
+
+  My_Task task1, task2;
+
+  // Test the indefinite run event loop.
+  if (task1.open (0) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%N:%l:(%P | %t):Failed to <open> the task\n"),
+                      1);
+
+  // Test the indefinite run event loop. Just pass a non-zero.
+  if (task2.open ((void *)&task2) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%N:%l:(%P | %t):Failed to <open> the task\n"),
+                      1);
+
+  // Give a gap.
+  ACE_OS::sleep (3);
+
+  // End the event loop.
+  if (ACE_Proactor::instance ()->end_event_loop () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%N:%l:(%P | %t):Failed to <end_event_loop>\n"),
+                      1);
+
+  ACE_Thread_Manager::instance ()->wait ();
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%P | %t):Test ends\n"));
+  return 0;
+}
+
+#else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
+
+int
+main (int, char *[])
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "This example cannot work with AIOCB_Proactor.\n"));
+  return 1;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
+
diff --git a/ACE/examples/Reactor/Proactor/test_multiple_loops.cpp b/ACE/examples/Reactor/Proactor/test_multiple_loops.cpp
new file mode 100644
index 00000000000..ac4228ab641
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_multiple_loops.cpp
@@ -0,0 +1,140 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_multiple_loops.cpp
+//
+// = DESCRIPTION
+//
+//    This example application shows how to write programs that
+//    combine the Proactor and Reactor event loops. This is possible
+//    only on WIN32 platform.
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/Task.h"
+#include "ace/Proactor.h"
+#include "ace/WIN32_Proactor.h"
+#include "ace/Atomic_Op.h"
+#include "ace/OS_NS_unistd.h"
+
+ACE_RCSID(Proactor, test_multiple_loops, "$Id$")
+
+#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
+
+class Timeout_Handler : public ACE_Handler, public ACE_Event_Handler
+{
+  // = TITLE
+  //     Generic timeout handler.
+
+public:
+  Timeout_Handler (void)
+    {
+    }
+
+  // This is called by the Proactor. This is declared in ACE_Handler.
+  virtual void handle_time_out (const ACE_Time_Value &tv,
+                                const void *arg)
+    {
+      // Print out when timeouts occur.
+      ACE_DEBUG ((LM_DEBUG, "(%t) %d timeout occurred for %s @ %d.\n",
+		  ++count_,
+		  (char *) arg,
+		  tv.sec ()));
+
+      // Since there is only one thread that can do the timeouts in
+      // Reactor, lets keep the handle_timeout short for that
+      // thread.
+      if (ACE_OS::strcmp ((char *) arg, "Proactor") == 0)
+	// Sleep for a while
+	ACE_OS::sleep (1);
+    }
+
+  // This method is declared in ACE_Event_Handler.
+  virtual int handle_timeout (const ACE_Time_Value &tv,
+			      const void *arg)
+    {
+      this->handle_time_out (tv, arg);
+      return 0;
+    }
+
+private:
+  ACE_Atomic_Op <ACE_Thread_Mutex, int> count_;
+};
+
+class Worker : public ACE_Task <ACE_NULL_SYNCH>
+{
+public:
+
+  // Thread fuction.
+  int svc (void)
+    {
+      ACE_DEBUG ((LM_DEBUG, "(%t) Worker started\n"));
+
+      // Handle events for 13 seconds.
+      ACE_Time_Value run_time (13);
+
+      // Try to become the owner
+      ACE_Reactor::instance ()->owner (ACE_Thread::self ());
+
+      if (ACE_Reactor::run_event_loop (run_time) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "Worker::svc"), -1);
+      else
+        ACE_DEBUG ((LM_DEBUG, "(%t) work complete\n"));
+
+      return 0;
+    }
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Timeout_Handler handler;
+  ACE_WIN32_Proactor win32_proactor (0, 1);
+  ACE_Proactor proactor (&win32_proactor, 0, 0);
+
+  ACE_Reactor::instance ()->register_handler (proactor.implementation ());
+
+  // Register a 2 second timer.
+  ACE_Time_Value foo_tv (2);
+  if (proactor.schedule_timer (handler,
+			       (void *) "Proactor",
+			       ACE_Time_Value::zero,
+			       foo_tv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+  // Register a 3 second timer.
+  ACE_Time_Value bar_tv (3);
+  if (ACE_Reactor::instance ()->schedule_timer (&handler,
+						(void *) "Reactor",
+						ACE_Time_Value::zero,
+						bar_tv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+  Worker worker;
+
+  if (worker.activate (THR_NEW_LWP, 10) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "main"), -1);
+
+  ACE_Thread_Manager::instance ()->wait ();
+
+  // Remove from reactor
+  ACE_Reactor::instance ()->remove_handler (&proactor,
+                                            ACE_Event_Handler::DONT_CALL);
+
+  return 0;
+}
+#else
+int
+main (int, char *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE */
diff --git a/ACE/examples/Reactor/Proactor/test_proactor.cpp b/ACE/examples/Reactor/Proactor/test_proactor.cpp
new file mode 100644
index 00000000000..035a2facf6a
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_proactor.cpp
@@ -0,0 +1,679 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_proactor.cpp
+//
+// = DESCRIPTION
+//    This program illustrates how the <ACE_Proactor> can be used to
+//    implement an application that does various asynchronous
+//    operations.
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "ace/OS_NS_string.h"
+#include "ace/OS_main.h"
+#include "ace/Service_Config.h"
+#include "ace/Proactor.h"
+#include "ace/Asynch_IO.h"
+#include "ace/Asynch_IO_Impl.h"
+#include "ace/Asynch_Acceptor.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Connector.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Message_Block.h"
+#include "ace/Get_Opt.h"
+#include "ace/Log_Msg.h"
+#include "ace/OS_NS_sys_stat.h"
+#include "ace/OS_NS_sys_socket.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_NS_fcntl.h"
+
+ACE_RCSID(Proactor, test_proactor, "$Id$")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
+  // This only works on Win32 platforms and on Unix platforms supporting
+  // POSIX aio calls.
+
+#include "test_proactor.h"
+
+
+// Host that we're connecting to.
+static ACE_TCHAR *host = 0;
+
+// Port that we're receiving connections on.
+static u_short port = ACE_DEFAULT_SERVER_PORT;
+
+// File that we're sending.
+static const ACE_TCHAR *file = ACE_TEXT("test_proactor.cpp");
+
+// Name of the output file.
+static const ACE_TCHAR *dump_file = ACE_TEXT("output");
+
+// Keep track of when we're done.
+static int done = 0;
+
+// Size of each initial asynchronous <read> operation.
+static int initial_read_size = BUFSIZ;
+
+
+Receiver::Receiver (void)
+  : dump_file_ (ACE_INVALID_HANDLE),
+    handle_ (ACE_INVALID_HANDLE)
+{
+}
+
+Receiver::~Receiver (void)
+{
+  ACE_OS::close (this->dump_file_);
+  ACE_OS::closesocket (this->handle_);
+}
+
+void
+Receiver::open (ACE_HANDLE handle,
+                ACE_Message_Block &message_block)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "%N:%l:Receiver::open called\n"));
+
+  // New connection, so initiate stuff.
+
+  // Cache the new connection
+  this->handle_ = handle;
+
+  // File offset starts at zero
+  this->file_offset_ = 0;
+
+  // Open dump file (in OVERLAPPED mode)
+  this->dump_file_ = ACE_OS::open (dump_file,
+                                   O_CREAT | O_RDWR | O_TRUNC | \
+                                   FILE_FLAG_OVERLAPPED);
+  if (this->dump_file_ == ACE_INVALID_HANDLE)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_OS::open"));
+      return;
+    }
+
+  // Initiate <ACE_Asynch_Write_File>.
+  if (this->wf_.open (*this,
+                      this->dump_file_) == -1)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Write_File::open"));
+      return;
+    }
+
+  // Initiate <ACE_Asynch_Read_Stream>.
+  if (this->rs_.open (*this, this->handle_) == -1)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Read_Stream::open"));
+      return;
+    }
+
+  // Fake the result and make the <handle_read_stream> get
+  // called. But, not, if there is '0' is transferred.
+  if (message_block.length () != 0)
+    {
+      // Duplicate the message block so that we can keep it around.
+      ACE_Message_Block &duplicate =
+        *message_block.duplicate ();
+
+      // Fake the result so that we will get called back.
+      ACE_Asynch_Read_Stream_Result_Impl *fake_result =
+        ACE_Proactor::instance ()->create_asynch_read_stream_result (this->proxy (),
+                                                                     this->handle_,
+                                                                     duplicate,
+                                                                     initial_read_size,
+                                                                     0,
+                                                                     ACE_INVALID_HANDLE,
+                                                                     0,
+                                                                     0);
+
+      size_t bytes_transferred = message_block.length ();
+
+      // <complete> for Accept would have already moved the <wr_ptr>
+      // forward. Update it to the beginning position.
+      duplicate.wr_ptr (duplicate.wr_ptr () - bytes_transferred);
+
+      // This will call the callback.
+      fake_result->complete (message_block.length (),
+                             1,
+                             0);
+
+      // Zap the fake result.
+      delete fake_result;
+    }
+  else
+    // Otherwise, make sure we proceed. Initiate reading the socket
+    // stream.
+    if (this->initiate_read_stream () == -1)
+      return;
+}
+
+int
+Receiver::initiate_read_stream (void)
+{
+  // Create a new <Message_Block>.  Note that this message block will
+  // be used both to <read> data asynchronously from the socket and to
+  // <write> data asynchronously to the file.
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb,
+                  ACE_Message_Block (BUFSIZ + 1),
+                  -1);
+
+  // Inititiate read
+  if (this->rs_.read (*mb,
+                      mb->size () - 1) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Read_Stream::read"),
+                      -1);
+  return 0;
+}
+
+void
+Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_read_stream called\n"));
+
+  // Reset pointers.
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+#if 0
+  // This can overrun the ACE_Log_Msg buffer and do bad things.
+  // Re-enable it at your risk.
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+#endif /* 0 */
+
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      // Successful read: write the data to the file asynchronously.
+      // Note how we reuse the <ACE_Message_Block> for the writing.
+      // Therefore, we do not delete this buffer because it is handled
+      // in <handle_write_stream>.
+      if (this->wf_.write (result.message_block (),
+                           result.bytes_transferred (),
+                           this->file_offset_) == -1)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "%p\n",
+                      "ACE_Asynch_Write_File::write"));
+          return;
+        }
+
+      // Initiate new read from the stream.
+      if (this->initiate_read_stream () == -1)
+        return;
+    }
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "Receiver completed\n"));
+
+      // No need for this message block anymore.
+      result.message_block ().release ();
+
+      // Note that we are done with the test.
+      done = 1;
+
+      // We are done: commit suicide.
+      delete this;
+    }
+}
+
+void
+Receiver::handle_write_file (const ACE_Asynch_Write_File::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG, "handle_write_file called\n"));
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+
+  result.message_block ().release ();
+
+  if (result.success ())
+    // Write successful:  Increment file offset
+    this->file_offset_ += result.bytes_transferred ();
+
+  // This code is not robust enough to deal with short file writes
+  // (which hardly ever happen) ;-)
+  ACE_ASSERT (result.bytes_to_write () == result.bytes_transferred ());
+}
+
+class Sender : public ACE_Handler
+{
+  // = TITLE
+  //     The class will be created by <main>.  After connecting to the
+  //     host, this class will then read data from a file and send it
+  //     to the network connection.
+public:
+  Sender (void);
+  ~Sender (void);
+  int open (const ACE_TCHAR *host,
+            u_short port);
+  ACE_HANDLE handle (void) const;
+  void handle (ACE_HANDLE);
+
+protected:
+  // These methods are called by the freamwork
+
+  virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result);
+  // This is called when asynchronous transmit files complete
+  virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
+  // This is called when asynchronous writes from the socket complete
+  virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result);
+  // This is called when asynchronous reads from the socket complete
+
+private:
+  int transmit_file (void);
+  // Transmit the entire file in one fell swoop.
+
+  int initiate_read_file (void);
+  // Initiate an asynchronous file read.
+
+  ACE_SOCK_Stream stream_;
+  // Network I/O handle
+
+  ACE_Asynch_Write_Stream ws_;
+  // ws (write stream): for writing to the socket
+
+  ACE_Asynch_Read_File rf_;
+  // rf (read file): for writing from the file
+
+  ACE_Asynch_Transmit_File tf_;
+  // Transmit file.
+
+  ACE_HANDLE input_file_;
+  // File to read from
+
+  u_long file_offset_;
+  // Current file offset
+
+  u_long file_size_;
+  // File size
+
+  ACE_Message_Block welcome_message_;
+  // Welcome message
+
+  ACE_Asynch_Transmit_File::Header_And_Trailer header_and_trailer_;
+  // Header and trailer which goes with transmit_file
+
+  int stream_write_done_;
+  int transmit_file_done_;
+  // These flags help to determine when to close down the event loop
+};
+
+Sender::Sender (void)
+  : input_file_ (ACE_INVALID_HANDLE),
+    file_offset_ (0),
+    file_size_ (0),
+    stream_write_done_ (0),
+    transmit_file_done_ (0)
+{
+  // Moment of inspiration... :-)
+  static const char *data = "Welcome to Irfan World! Irfan RULES here !!\n";
+  this->welcome_message_.init (data,
+                               ACE_OS::strlen (data));
+  this->welcome_message_.wr_ptr (ACE_OS::strlen (data));
+}
+
+Sender::~Sender (void)
+{
+  this->stream_.close ();
+}
+
+ACE_HANDLE
+Sender::handle (void) const
+{
+  return this->stream_.get_handle ();
+}
+
+void
+Sender::handle (ACE_HANDLE handle)
+{
+  this->stream_.set_handle (handle);
+}
+
+int
+Sender::open (const ACE_TCHAR *host,
+               u_short port)
+{
+  // Initialize stuff
+
+  // Open input file (in OVERLAPPED mode)
+  this->input_file_ =
+    ACE_OS::open (file, GENERIC_READ | FILE_FLAG_OVERLAPPED);
+  if (this->input_file_ == ACE_INVALID_HANDLE)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_OS::open"), -1);
+
+  // Find file size
+  this->file_size_ =
+    ACE_OS::filesize (this->input_file_);
+
+  // Connect to remote host
+  ACE_INET_Addr address (port, host);
+  ACE_SOCK_Connector connector;
+  if (connector.connect (this->stream_,
+                         address) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_SOCK_Connector::connect"),
+                      -1);
+
+  // Open ACE_Asynch_Write_Stream
+  if (this->ws_.open (*this) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Write_Stream::open"),
+                      -1);
+
+  // Open ACE_Asynch_Read_File
+  if (this->rf_.open (*this, this->input_file_) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Read_File::open"),
+                      -1);
+
+  // Start an asynchronous transmit file
+  if (this->transmit_file () == -1)
+    return -1;
+
+  // Start an asynchronous read file
+  if (this->initiate_read_file () == -1)
+    return -1;
+
+  return 0;
+}
+
+int
+Sender::transmit_file (void)
+{
+  // Open file (in SEQUENTIAL_SCAN mode)
+  ACE_HANDLE file_handle =
+    ACE_OS::open (file, GENERIC_READ | FILE_FLAG_SEQUENTIAL_SCAN);
+  if (file_handle == ACE_INVALID_HANDLE)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_OS::open"),
+                      -1);
+
+  // Open ACE_Asynch_Transmit_File
+  if (this->tf_.open (*this) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Transmit_File::open"),
+                      -1);
+
+  // Header and trailer data for the file.
+  // @@ What happens if header and trailer are the same?
+  this->header_and_trailer_.header_and_trailer (&this->welcome_message_,
+                                                this->welcome_message_.length (),
+                                                &this->welcome_message_,
+                                                this->welcome_message_.length ());
+
+  // Send the entire file in one fell swoop!
+  if (this->tf_.transmit_file (file_handle,
+                               &this->header_and_trailer_) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Transmit_File::transmit_file"),
+                      -1);
+
+  return 0;
+}
+
+void
+Sender::handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_transmit_file called\n"));
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "socket", result.socket ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "file", result.file ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_per_send", result.bytes_per_send ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "flags", result.flags ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+
+  // Done with file
+  ACE_OS::close (result.file ());
+
+  this->transmit_file_done_ = 1;
+  if (this->stream_write_done_)
+    done = 1;
+}
+
+int
+Sender::initiate_read_file (void)
+{
+  // Create a new <Message_Block>.  Note that this message block will
+  // be used both to <read> data asynchronously from the file and to
+  // <write> data asynchronously to the socket.
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb,
+                  ACE_Message_Block (BUFSIZ + 1),
+                  -1);
+
+  // Inititiate an asynchronous read from the file
+  if (this->rf_.read (*mb,
+                      mb->size () - 1,
+                      this->file_offset_) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Read_File::read"),
+                      -1);
+  return 0;
+}
+
+void
+Sender::handle_read_file (const ACE_Asynch_Read_File::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_read_file called\n"));
+
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  //ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+
+  if (result.success ())
+    {
+      // Read successful: increment offset and write data to network.
+      // Note how we reuse the <ACE_Message_Block> for the writing.
+      // Therefore, we do not delete this buffer because it is handled
+      // in <handle_write_stream>.
+
+      this->file_offset_ += result.bytes_transferred ();
+      if (this->ws_.write (result.message_block (),
+                           result.bytes_transferred ()) == -1)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "%p\n",
+                      "ACE_Asynch_Write_Stream::write"));
+          return;
+        }
+
+      if (this->file_size_ > this->file_offset_)
+        {
+          // Start an asynchronous read file.
+          if (initiate_read_file () == -1)
+            return;
+        }
+    }
+}
+
+void
+Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_write_stream called\n"));
+
+  // Reset pointers.
+  result.message_block ().rd_ptr (result.message_block ().rd_ptr () - result.bytes_transferred ());
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+#if 0
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+#endif
+
+  if (result.success ())
+    {
+      // Partial write to socket
+      int unsent_data = result.bytes_to_write () - result.bytes_transferred ();
+      if (unsent_data != 0)
+        {
+          // Reset pointers
+          result.message_block ().rd_ptr (result.bytes_transferred ());
+
+          // Duplicate the message block and retry remaining data
+          if (this->ws_.write (*result.message_block ().duplicate (),
+                               unsent_data) == -1)
+            {
+              ACE_ERROR ((LM_ERROR,
+                          "%p\n",
+                          "ACE_Asynch_Write_Stream::write"));
+              return;
+            }
+        }
+      else if (!(this->file_size_ > this->file_offset_))
+        {
+          this->stream_write_done_ = 1;
+          if (this->transmit_file_done_)
+            done = 1;
+        }
+    }
+
+  // Release message block.
+  result.message_block ().release ();
+}
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("h:p:f:d:"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    switch (c)
+      {
+      case 'h':
+        host = get_opt.opt_arg ();
+        break;
+      case 'p':
+        port = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 'f':
+        file = get_opt.opt_arg ();
+        break;
+      case 'd':
+        dump_file = get_opt.opt_arg ();
+        break;
+      default:
+        ACE_ERROR ((LM_ERROR, "%p.\n",
+                    "usage :\n"
+                    "-h <host>\n"
+                    "-p <port>\n"
+                    "-f <file>\n"));
+        return -1;
+      }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  if (parse_args (argc, argv) == -1)
+    return -1;
+
+  Sender sender;
+
+  // Note: acceptor parameterized by the Receiver.
+  ACE_Asynch_Acceptor<Receiver> acceptor;
+
+  // If passive side
+  if (host == 0)
+   {
+     if (acceptor.open (ACE_INET_Addr (port),
+                        initial_read_size,
+                        1) == -1)
+       return -1;
+   }
+  // If active side
+  else if (sender.open (host, port) == -1)
+    return -1;
+
+  int success = 1;
+
+  while (success > 0  && !done)
+    // Dispatch events via Proactor singleton.
+    success = ACE_Proactor::instance ()->handle_events ();
+
+  return 0;
+}
+
+#else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "This example does not work on this platform.\n"));
+  return 1;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
diff --git a/ACE/examples/Reactor/Proactor/test_proactor.h b/ACE/examples/Reactor/Proactor/test_proactor.h
new file mode 100644
index 00000000000..482e176041e
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_proactor.h
@@ -0,0 +1,56 @@
+/*
+** $Id$
+*/
+
+#ifndef _TEST_PROACTOR_H
+#define _TEST_PROACTOR_H
+
+#include "ace/Asynch_IO.h"
+
+class Receiver : public ACE_Service_Handler
+{
+  // = TITLE
+  //     The class will be created by <ACE_Asynch_Acceptor> when new
+  //     connections arrive.  This class will then receive data from
+  //     the network connection and dump it to a file.
+public:
+  // = Initialization and termination.
+  Receiver (void);
+  ~Receiver (void);
+
+  virtual void open (ACE_HANDLE handle,
+                     ACE_Message_Block &message_block);
+  // This is called after the new connection has been accepted.
+
+protected:
+  // These methods are called by the framework
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
+  // This is called when asynchronous <read> operation from the socket
+  // complete.
+
+  virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result);
+  // This is called when an asynchronous <write> to the file
+  // completes.
+
+private:
+  int initiate_read_stream (void);
+  // Initiate an asynchronous <read> operation on the socket.
+
+  ACE_Asynch_Read_Stream rs_;
+  // rs (read stream): for reading from a socket.
+
+  ACE_HANDLE dump_file_;
+  // File for dumping data.
+
+  ACE_Asynch_Write_File wf_;
+  // wf (write file): for writing to a file.
+
+  u_long file_offset_;
+  // Offset for the file.
+
+  ACE_HANDLE handle_;
+  // Handle for IO to remote peer.
+};
+
+#endif /* _TEST_PROACTOR_H */
diff --git a/ACE/examples/Reactor/Proactor/test_proactor2.cpp b/ACE/examples/Reactor/Proactor/test_proactor2.cpp
new file mode 100644
index 00000000000..cd5cbf7092e
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_proactor2.cpp
@@ -0,0 +1,808 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_proactor2.cpp
+//
+// = DESCRIPTION
+//    Alexander Libman <Alibman@baltimore.com> modified
+//    <test_proactor> and made this test. Instead of writing received
+//    data to the file, the receiver sends them back to the
+//    sender,i.e. ACE_Asynch_Write_File wf_  has been changed to
+//    ACE_Asynch_Write_Stream wf_.
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu> and Alexander Libman
+//    <Alibman@baltimore.com>.
+// ============================================================================
+
+#include "ace/Signal.h"
+
+#include "ace/Service_Config.h"
+#include "ace/Proactor.h"
+#include "ace/Asynch_IO.h"
+#include "ace/Asynch_IO_Impl.h"
+#include "ace/Asynch_Acceptor.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Connector.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Message_Block.h"
+#include "ace/Get_Opt.h"
+
+// FUZZ: disable check_for_streams_include
+#include "ace/streams.h"
+
+#include "ace/Task.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(Proactor, test_proactor2, "test_proactor2.cpp,v 1.27 2000/03/07 17:15:56 schmidt Exp")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
+  // This only works on Win32 platforms and on Unix platforms supporting
+  // POSIX aio calls.
+
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+
+#include "ace/WIN32_Proactor.h"
+
+#elif defined (ACE_HAS_AIO_CALLS)
+
+#include "ace/POSIX_Proactor.h"
+
+#endif
+
+  //  Some debug helper functions
+  int DisableSignal ( int SigNum );
+int PrintSigMask ();
+
+#define  COUT(X)  cout << X ; cout.flush ();
+
+// Host that we're connecting to.
+static ACE_TCHAR *host = 0;
+
+// duplex mode: ==0 half-duplex
+//              !=0 full duplex
+static int duplex = 0 ;
+
+// number threads in the Proactor thread pool
+static int nThreads = 1;
+
+// Port that we're receiving connections on.
+static u_short port = ACE_DEFAULT_SERVER_PORT;
+
+// Size of each initial asynchronous <read> operation.
+static int initial_read_size = BUFSIZ;
+
+
+#define MyMutex ACE_Recursive_Thread_Mutex
+//#define MyMutex ACE_Thread_Mutex
+//#define MyMutex ACE_Null_Mutex
+
+//--------------------------------------------------------------------------
+// MyTask plays role for Proactor threads pool
+//--------------------------------------------------------------------------
+class MyTask: public ACE_Task<ACE_MT_SYNCH>
+{
+
+public:
+
+  int svc (void) ;
+};
+
+
+int MyTask::svc (void )
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) MyTask started\n"));
+
+  while ( ACE_Proactor::event_loop_done () == 0 )
+    {
+      ACE_Proactor::run_event_loop ();
+    }
+
+  ACE_DEBUG ((LM_DEBUG, "(%t) MyTask finished\n"));
+  return 0 ;
+}
+
+//-----------------------------------------------------------
+//  Receiver
+//-----------------------------------------------------------
+class Receiver : public ACE_Service_Handler
+{
+public:
+
+  Receiver (void);
+  ~Receiver (void);
+
+  virtual void open (ACE_HANDLE handle,
+                     ACE_Message_Block &message_block);
+  // This is called after the new connection has been accepted.
+
+protected:
+  // These methods are called by the framework
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result
+                                   &result);
+  // This is called when asynchronous <read> operation from the socket
+  // complete.
+
+  virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result
+                                    &result);
+  // This is called when an asynchronous <write> to the file
+  // completes.
+
+private:
+  int  initiate_read_stream  (void);
+  int  initiate_write_stream (ACE_Message_Block & mb, int nBytes );
+  bool check_destroy () ;
+
+  ACE_Asynch_Read_Stream rs_;
+  ACE_Asynch_Write_Stream ws_;
+  ACE_HANDLE handle_;
+  MyMutex m_Mtx ;
+  long    nIOCount ;
+  static long nSessions ;
+};
+
+
+long Receiver::nSessions = 0 ;
+
+Receiver::Receiver (void)
+  : handle_ (ACE_INVALID_HANDLE),
+    nIOCount ( 0 )
+{
+  ACE_Guard<MyMutex> locker (m_Mtx) ;
+  nSessions ++ ;
+  ACE_DEBUG ((LM_DEBUG, "Receiver Ctor nSessions=%d\n", nSessions ));
+}
+
+Receiver::~Receiver (void)
+{
+  ACE_Guard<MyMutex> locker (m_Mtx) ;
+  nSessions -- ;
+  ACE_OS::closesocket (this->handle_);
+  ACE_DEBUG ((LM_DEBUG, "~Receiver Dtor nSessions=%d\n", nSessions ));
+}
+
+//---------------------------------------------------------------------
+//  return true if we alive, false  we commited suicide
+//
+//---------------------------------------------------------------------
+bool Receiver::check_destroy ()
+{
+  {
+    ACE_Guard<MyMutex> locker (m_Mtx) ;
+
+    if ( nIOCount > 0 )
+      {
+        return true ;
+      }
+  }
+
+  delete this ;
+  return false ;
+}
+
+
+void Receiver::open (ACE_HANDLE handle,
+                     ACE_Message_Block &message_block)
+{
+  ACE_UNUSED_ARG (message_block);
+
+  ACE_DEBUG ((LM_DEBUG,
+              "%N:%l:Receiver::open called\n"));
+
+
+  this->handle_ = handle;
+
+  if (this->ws_.open (*this, this->handle_ ) == -1)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Write_Stream::open"));
+
+    }
+  else if (this->rs_.open (*this, this->handle_) == -1)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Read_Stream::open"));
+    }
+  else
+    {
+      initiate_read_stream ();
+    }
+
+
+  check_destroy ();
+}
+
+int Receiver::initiate_read_stream (void)
+{
+  ACE_Guard<MyMutex> locker (m_Mtx) ;
+
+  // Create a new <Message_Block>.  Note that this message block will
+  // be used both to <read> data asynchronously from the socket and to
+  // <write> data asynchronously to the file.
+  ACE_DEBUG ((LM_DEBUG,
+              "initiate_read_stream called\n"));
+
+
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb,
+                  ACE_Message_Block (BUFSIZ + 1),
+                  -1);
+
+  // Inititiate read
+  if (this->rs_.read (*mb, mb->size ()- 1) == -1)
+    {
+      mb->release () ;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "ACE_Asynch_Read_Stream::read"),
+                        -1);
+    }
+
+  nIOCount++ ;
+  return 0;
+}
+
+int Receiver::initiate_write_stream (ACE_Message_Block & mb, int nBytes )
+{
+  ACE_Guard<MyMutex> locker (m_Mtx) ;
+  if (this->ws_.write (mb , nBytes ) == -1)
+    {
+      mb.release ();
+      ACE_ERROR_RETURN((LM_ERROR,
+                        "%p\n",
+                        "ACE_Asynch_Write_File::write"),
+                       -1);
+    }
+
+  nIOCount++ ;
+  return 0;
+}
+
+void
+Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_read_stream called\n"));
+
+  // Reset pointers.
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] =
+    '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read
+              ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
+              result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
+              result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block",
+              result.message_block ().rd_ptr ()));
+
+  if ( result.success () && result.bytes_transferred () != 0)
+    {
+      // Successful read: write the data to the file asynchronously.
+      // Note how we reuse the <ACE_Message_Block> for the writing.
+      // Therefore, we do not delete this buffer because it is handled
+      // in <handle_write_stream>.
+
+      if(this->initiate_write_stream (result.message_block (),
+
+                                      result.bytes_transferred () ) == 0 )
+        {
+          if ( duplex != 0 )
+            {
+              // Initiate new read from the stream.
+              this->initiate_read_stream () ;
+            }
+        }
+    }
+  else
+    {
+      result.message_block ().release ();
+      ACE_DEBUG ((LM_DEBUG,  "Receiver completed\n"));
+    }
+
+  {
+    ACE_Guard<MyMutex> locker (m_Mtx) ;
+    nIOCount-- ;
+  }
+  check_destroy () ;
+}
+
+void
+Receiver::handle_write_stream (const ACE_Asynch_Write_Stream::Result
+                               &result)
+{
+  ACE_DEBUG ((LM_DEBUG, "handle_write_stream called\n"));
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write",
+              result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
+              result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
+              result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+
+  result.message_block ().release ();
+
+  if (result.success ())
+    {
+      // This code is not robust enough to deal with short file writes
+      // (which hardly ever happen) ;-)
+      //ACE_ASSERT (result.bytes_to_write () == result.bytes_transferred ());
+
+      if ( duplex == 0 )
+        {
+          initiate_read_stream () ;
+        }
+    }
+
+  {
+    ACE_Guard<MyMutex> locker (m_Mtx) ;
+    nIOCount-- ;
+  }
+  check_destroy () ;
+}
+
+//-------------------------------------------------------------------------
+// Sender:  sends indefinetely welcome message
+//  and  recieves it back
+//------------------------------------------------------------------------
+class Sender : public ACE_Handler
+{
+public:
+  Sender (void);
+  ~Sender (void);
+  int open (const ACE_TCHAR *host, u_short port);
+  void close ();
+  ACE_HANDLE handle (void) const;
+  void handle (ACE_HANDLE);
+
+protected:
+// These methods are called by the freamwork
+
+virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result
+&result);
+// This is called when asynchronous reads from the socket complete
+
+virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result
+&result);
+// This is called when asynchronous writes from the socket complete
+
+private:
+
+int initiate_read_stream (void);
+int initiate_write_stream (void);
+
+ACE_SOCK_Stream stream_;
+// Network I/O handle
+
+ACE_Asynch_Write_Stream ws_;
+// ws (write stream): for writing to the socket
+
+ACE_Asynch_Read_Stream rs_;
+// rs (read file): for reading from the socket
+
+ACE_Message_Block welcome_message_;
+// Welcome message
+
+MyMutex m_Mtx ;
+long    nIOCount ;
+};
+
+static char *data = "Welcome to Irfan World! Irfan RULES here !!\n";
+
+Sender::Sender (void)
+  :nIOCount ( 0 )
+{
+  // Moment of inspiration... :-)
+  this->welcome_message_.init (data, ACE_OS::strlen (data));
+}
+
+Sender::~Sender (void)
+{
+  close ();
+}
+
+void Sender::close ()
+{
+  this->stream_.close ();
+}
+
+ACE_HANDLE Sender::handle (void) const
+{
+  return this->stream_.get_handle ();
+}
+
+void Sender::handle (ACE_HANDLE handle)
+{
+  this->stream_.set_handle (handle);
+}
+
+int Sender::open (const ACE_TCHAR *host, u_short port)
+{
+  // Initialize stuff
+  // Connect to remote host
+  ACE_INET_Addr address (port, host);
+  ACE_SOCK_Connector connector;
+
+  if (connector.connect (this->stream_,
+                         address) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "ACE_SOCK_Connector::connect"),
+                        -1);
+    }
+
+  // Open ACE_Asynch_Write_Stream
+  if (this->ws_.open (*this) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Write_Stream::open"),
+                      -1);
+
+  // Open ACE_Asynch_Read_Stream
+  if (this->rs_.open (*this) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Read_File::open"),
+                      -1);
+
+  // Start an asynchronous transmit file
+  if ( this->initiate_write_stream () == -1)
+    return -1;
+
+  if ( duplex != 0 )
+    {
+      // Start an asynchronous read file
+      if (this->initiate_read_stream () == -1)
+        return -1;
+    }
+
+  return 0;
+}
+
+int Sender::initiate_write_stream (void)
+{
+  ACE_Guard<MyMutex> locker (m_Mtx) ;
+
+
+  welcome_message_.rd_ptr( welcome_message_.base ());
+  welcome_message_.wr_ptr( welcome_message_.base ());
+  welcome_message_.wr_ptr (ACE_OS::strlen (data));
+
+  if (this->ws_.write (welcome_message_,
+                       welcome_message_.length ()
+                       ) == -1)
+    {
+      ACE_ERROR_RETURN((LM_ERROR,
+                        "%p\n",
+                        "ACE_Asynch_Write_File::write"),
+                       -1);
+    }
+
+  nIOCount++ ;
+  return 0;
+}
+
+int Sender::initiate_read_stream (void)
+{
+  ACE_Guard<MyMutex> locker (m_Mtx) ;
+
+  // Create a new <Message_Block>.  Note that this message block will
+  // be used both to <read> data asynchronously from the socket and to
+  // <write> data asynchronously to the file.
+  ACE_DEBUG ((LM_DEBUG,
+              "initiate_read_stream called\n"));
+
+
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb,
+                  ACE_Message_Block (BUFSIZ + 1),
+                  -1);
+
+  // Inititiate read
+  if (this->rs_.read (*mb, mb->size ()- 1) == -1)
+    {
+      mb->release () ;
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "ACE_Asynch_Read_Stream::read"),
+                        -1);
+    }
+
+  nIOCount++ ;
+  return 0;
+}
+
+
+void Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result
+                                  &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_write_stream called\n"));
+
+  // Reset pointers.
+  result.message_block ().rd_ptr (result.message_block ().rd_ptr () -
+                                  result.bytes_transferred ());
+
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write",
+              result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
+              result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
+              result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block",
+              result.message_block ().rd_ptr ()));
+
+  // Simplify just for Test
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      if ( duplex != 0 )  // full duplex, continue write
+        {
+          initiate_write_stream () ;
+        }
+      else  // half-duplex   read reply, after read we will start
+        // write
+        {
+          initiate_read_stream () ;
+        }
+    }
+
+  {
+    ACE_Guard<MyMutex> locker (m_Mtx) ;
+    nIOCount-- ;
+  }
+}
+
+void
+Sender::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_read_stream called\n"));
+
+  // Reset pointers.
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] =
+    '\0';
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read
+              ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
+              result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
+              result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block",
+              result.message_block ().rd_ptr ()));
+
+  result.message_block().release ();
+
+  if ( result.success () && result.bytes_transferred () != 0)
+    {
+      // Successful read: write the data to the file asynchronously.
+      // Note how we reuse the <ACE_Message_Block> for the writing.
+      // Therefore, we do not delete this buffer because it is handled
+      // in <handle_write_stream>.
+
+      if ( duplex != 0 )  // full duplex, continue read
+        {
+          initiate_read_stream () ;
+        }
+      else  // half-duplex  writey, after write we will start read
+        {
+          initiate_write_stream () ;
+        }
+    }
+
+  {
+    ACE_Guard<MyMutex> locker (m_Mtx) ;
+    nIOCount-- ;
+  }
+}
+
+//--------------------------------------------------------------------------
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("n:p:d:h:"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    switch (c)
+      {
+      case 'h':
+        host = get_opt.opt_arg ();
+        break;
+      case 'n':
+        nThreads = ACE_OS::atoi (get_opt.opt_arg ()) ;
+        break;
+      case 'p':
+        port = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 'd':
+        duplex = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      default:
+        ACE_ERROR ((LM_ERROR, "%p.\n",
+                    "usage :\n"
+                    "-h <host> for Sender mode\n"
+                    "-d <duplex mode 1-on/0-off>\n"
+                    "-p <port to listen/connect>\n"
+                    "-n <number threads for Proactor pool>\n"));
+        return -1;
+      }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  ACE_UNUSED_ARG (initial_read_size);
+
+  if (parse_args (argc, argv) == -1)
+    return -1;
+
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+
+  ACE_WIN32_Proactor *      pImpl = new ACE_WIN32_Proactor;
+
+#elif defined (ACE_HAS_AIO_CALLS)
+
+  //  ACE_POSIX_AIOCB_Proactor *  pImpl = new ACE_POSIX_AIOCB_Proactor;
+  ACE_POSIX_SIG_Proactor *  pImpl = new ACE_POSIX_SIG_Proactor;
+#endif
+
+  ACE_Proactor Proactor ( pImpl ,1 );
+
+  ACE_Proactor::instance( & Proactor );
+
+
+  MyTask  Task1 ;
+
+  if (Task1.activate (THR_NEW_LWP, nThreads ) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "main"), -1);
+    }
+
+  Sender sender;
+  ACE_Asynch_Acceptor<Receiver> acceptor;
+
+  int Rc = -1 ;
+
+  if ( host == NULL ) // Acceptor
+    {
+      // Simplify , initial read with  zero size
+      Rc = acceptor.open (ACE_INET_Addr (port),0,1);
+
+    }
+  else
+    {
+      Rc = sender.open (host, port);
+    }
+
+  if ( Rc == 0 )
+    {
+      char c ;
+      cout << "Press any key to stop and exit=>\n" << flush ;
+      cin.clear ();
+      cin >> c ;
+    }
+
+  ACE_Proactor::end_event_loop () ;
+
+  if ( host != NULL ) // we are sender
+    {
+      sender.close () ; // disconnect to get reciever error !!!
+    }
+
+
+  ACE_Thread_Manager * pTM = ACE_Thread_Manager::instance();
+
+  pTM->wait_task ( & Task1 ) ;
+
+  ACE_Proactor::instance( ( ACE_Proactor* )NULL );
+
+  return 0;
+}
+//--------------------------------------------------------------------
+//
+//--------------------------------------------------------------------
+int DisableSignal ( int SigNum )
+{
+
+#ifndef ACE_WIN32
+  sigset_t signal_set;
+  if ( sigemptyset (&signal_set) == - 1 )
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "Error:(%P | %t):%p\n",
+                  "sigemptyset failed"));
+    }
+
+  sigaddset (&signal_set, SigNum);
+
+  //  Put the <signal_set>.
+  if (ACE_OS::pthread_sigmask (SIG_BLOCK, &signal_set, 0) != 0)
+    {
+      ACE_ERROR ((LM_ERROR,
+                  "Error:(%P | %t):%p\n",
+                  "pthread_sigmask failed"));
+    }
+#else
+  ACE_UNUSED_ARG(SigNum);
+#endif
+
+  return  1;
+}
+//--------------------------------------------------------------------
+// Get the <signal_set> back from the OS.
+//--------------------------------------------------------------------
+
+int PrintSigMask ()
+{
+#ifndef ACE_WIN32
+
+  sigset_t  mask ;
+  int member = 0;
+
+  COUT ( "\n=============Signal Mask==========" )
+
+    if (ACE_OS::pthread_sigmask (SIG_SETMASK, 0, & mask ) != 0)
+      {
+        ACE_ERROR ((LM_ERROR,
+                    "Error:(%P | %t):%p\n",
+                    "ACE_OS::pthread_sigmask failed"));
+      }
+    else  for (int i = 1 ; i < 1000; i++)
+      {
+        member = sigismember (&mask,i);
+
+        COUT ( "\nSig " )
+          COUT ( i )
+          COUT ( " is " )
+          COUT (member )
+
+          if (member == -1)
+            {
+              break ;
+            }
+      }
+#endif
+  return 0;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
diff --git a/ACE/examples/Reactor/Proactor/test_proactor3.cpp b/ACE/examples/Reactor/Proactor/test_proactor3.cpp
new file mode 100644
index 00000000000..c47468276c8
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_proactor3.cpp
@@ -0,0 +1,864 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_proactor3.cpp
+//
+// = DESCRIPTION
+//    This program illustrates how the <ACE_Proactor> can be used to
+//    implement an application that does various asynchronous
+//    operations.
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//    modified by  Alexander Libman <alibman@baltimore.com>
+//    from original test_proactor.cpp
+// ============================================================================
+
+#include "ace/Signal.h"
+
+#include "ace/Service_Config.h"
+#include "ace/Proactor.h"
+#include "ace/Asynch_IO.h"
+#include "ace/Asynch_IO_Impl.h"
+#include "ace/Asynch_Acceptor.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Connector.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Message_Block.h"
+#include "ace/Get_Opt.h"
+
+// FUZZ: disable check_for_streams_include
+#include "ace/streams.h"
+
+#include "ace/Task.h"
+
+ACE_RCSID(Proactor, test_proactor, "test_proactor.cpp,v 1.27 2000/03/07 17:15:56 schmidt Exp")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
+  // This only works on Win32 platforms and on Unix platforms
+  // supporting POSIX aio calls.
+
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+
+#	include "ace/WIN32_Proactor.h"
+
+#elif defined (ACE_HAS_AIO_CALLS)
+
+#	include "ace/POSIX_Proactor.h"
+#	include "ace/SUN_Proactor.h"
+
+#endif /* defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) */
+
+//  Some debug helper functions
+static int disable_signal (int sigmin, int sigmax);
+#if 0
+static int print_sigmask (void);
+#endif
+
+#define  COUT(X)  cout << X; cout.flush ();
+
+// Proactor Type (UNIX only, Win32 ignored) 0-default, 1 -AIOCB,
+// 2-SIG, 3-SUN
+static int proactor_type = 0;
+
+// POSIX : > 0 max number aio operations  proactor,
+static int max_aio_operations = 0;
+
+// Host that we're connecting to.
+static ACE_TCHAR *host = 0;
+
+// number of Senders instances
+static int senders = 1;
+static const int MaxSenders = 100;
+
+// duplex mode: ==0 half-duplex
+//              !=0 full duplex
+static int duplex = 0;
+
+// number threads in the Proactor thread pool
+static int threads = 1;
+
+// Port that we're receiving connections on.
+static u_short port = ACE_DEFAULT_SERVER_PORT;
+
+class MyTask: public ACE_Task<ACE_MT_SYNCH>
+{
+  // = TITLE
+  //   MyTask plays role for Proactor threads pool
+public:
+  MyTask (void) : threads_ (0), proactor_ (0) {}
+
+  int svc (void);
+  void waitready (void) { event_.wait (); }
+
+private:
+  ACE_Recursive_Thread_Mutex mutex_;
+  int threads_;
+  ACE_Proactor *proactor_;
+  ACE_Manual_Event event_;
+
+  void create_proactor (void);
+  void delete_proactor (void);
+};
+
+void
+MyTask::create_proactor (void)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+
+  if (threads_ == 0)
+    {
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+      ACE_WIN32_Proactor *proactor = new ACE_WIN32_Proactor;
+      ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=WIN32"));
+
+#elif defined (ACE_HAS_AIO_CALLS)
+
+      ACE_POSIX_Proactor *proactor = 0;
+
+      switch (proactor_type)
+        {
+        case 1:	proactor = new ACE_POSIX_AIOCB_Proactor (max_aio_operations);
+          ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=AIOCB\n"));
+          break;
+        case 2:	proactor = new ACE_POSIX_SIG_Proactor;
+          ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=SIG\n"));
+          break;
+#  if defined (sun)
+        case 3:	proactor = new ACE_SUN_Proactor (max_aio_operations);
+          ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=SUN\n"));
+          break;
+#  endif /* sun */
+        default:proactor = new ACE_POSIX_SIG_Proactor;
+          ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=SIG\n"));
+          break;
+        }
+#endif
+
+      proactor_ = new ACE_Proactor (proactor, 1);
+
+      ACE_Proactor::instance(proactor_);
+      event_.signal ();
+    }
+
+  threads_++;
+}
+
+void
+MyTask::delete_proactor (void)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+  if (--threads_ == 0)
+    {
+      ACE_DEBUG ((LM_DEBUG, "(%t) Delete Proactor\n"));
+      ACE_Proactor::instance ((ACE_Proactor *) 0);
+      delete proactor_;
+      proactor_ = 0;
+    }
+}
+
+int
+MyTask::svc (void)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) MyTask started\n"));
+
+  create_proactor ();
+  disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX);
+
+  while (ACE_Proactor::event_loop_done () == 0)
+    ACE_Proactor::run_event_loop ();
+
+  delete_proactor ();
+
+  ACE_DEBUG ((LM_DEBUG, "(%t) MyTask finished\n"));
+  return 0;
+}
+
+class Receiver : public ACE_Service_Handler
+{
+public:
+
+  Receiver (void);
+  ~Receiver (void);
+
+  virtual void open (ACE_HANDLE handle,
+		     ACE_Message_Block &message_block);
+  // This is called after the new connection has been accepted.
+
+  static long get_number_sessions (void) { return sessions_; }
+
+protected:
+  // These methods are called by the framework
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
+  // This is called when asynchronous <read> operation from the socket
+  // complete.
+
+  virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
+  // This is called when an asynchronous <write> to the file
+  // completes.
+
+private:
+  int  initiate_read_stream (void);
+  int  initiate_write_stream (ACE_Message_Block & mb, int nBytes);
+  int check_destroy (void);
+
+  ACE_Asynch_Read_Stream rs_;
+  ACE_Asynch_Write_Stream ws_;
+  ACE_HANDLE handle_;
+  ACE_Recursive_Thread_Mutex mutex_;
+  long io_count_;
+  static long sessions_;
+};
+
+long Receiver::sessions_ = 0;
+
+Receiver::Receiver (void)
+  : handle_ (ACE_INVALID_HANDLE),
+    io_count_ (0)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+  sessions_++;
+  ACE_DEBUG ((LM_DEBUG, "Receiver Ctor sessions_=%d\n", sessions_));
+}
+
+Receiver::~Receiver (void)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+  sessions_--;
+  ACE_OS::closesocket (this->handle_);
+  ACE_DEBUG ((LM_DEBUG, "~Receiver Dtor sessions_=%d\n", sessions_));
+}
+
+//  return true if we alive, false  we commited suicide
+int
+Receiver::check_destroy (void)
+{
+  {
+    ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+
+    if (io_count_ > 0)
+      return 1;
+  }
+
+  delete this;
+  return 0;
+}
+
+void
+Receiver::open (ACE_HANDLE handle,
+		ACE_Message_Block &)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "%N:%l:Receiver::open called\n"));
+
+  this->handle_ = handle;
+
+  if (this->ws_.open (*this, this->handle_) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "ACE_Asynch_Write_Stream::open"));
+  else if (this->rs_.open (*this, this->handle_) == -1)
+    ACE_ERROR ((LM_ERROR,
+                "%p\n",
+                "ACE_Asynch_Read_Stream::open"));
+  else
+    initiate_read_stream ();
+
+  check_destroy ();
+}
+
+int
+Receiver::initiate_read_stream (void)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb,
+                  ACE_Message_Block (BUFSIZ + 1),
+                  -1);
+
+  // Inititiate read
+  if (this->rs_.read (*mb, mb->size ()- 1) == -1)
+    {
+      mb->release ();
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "ACE_Asynch_Read_Stream::read"),
+                        -1);
+    }
+
+  io_count_++;
+  return 0;
+}
+
+int
+Receiver::initiate_write_stream (ACE_Message_Block &mb, int nbytes)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+  if (nbytes <= 0)
+    {
+      mb.release ();
+      ACE_ERROR_RETURN((LM_ERROR,
+                        "ACE_Asynch_Write_Stream::write nbytes <0 "),
+                       -1);
+    }
+
+  if (this->ws_.write (mb, nbytes) == -1)
+    {
+      mb.release ();
+      ACE_ERROR_RETURN((LM_ERROR,
+                        "%p\n",
+                        "ACE_Asynch_Write_Stream::write"),
+                       -1);
+    }
+
+  io_count_++;
+  return 0;
+}
+
+void
+Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  // Reset pointers.
+  result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+  if (result.bytes_transferred () == 0 || result.error () != 0)
+    {
+      ACE_DEBUG ((LM_DEBUG, "handle_read_stream called\n"));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+    }
+
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      // Successful read: write the data to the file asynchronously.
+      // Note how we reuse the <ACE_Message_Block> for the writing.
+      // Therefore, we do not delete this buffer because it is handled
+      // in <handle_write_stream>.
+
+      if(this->initiate_write_stream (result.message_block (),
+                                      result.bytes_transferred ()) == 0)
+        {
+          if (duplex != 0)
+            {
+              // Initiate new read from the stream.
+              this->initiate_read_stream ();
+            }
+        }
+    }
+  else
+    {
+      result.message_block ().release ();
+      ACE_DEBUG ((LM_DEBUG,  "Receiver completed\n"));
+    }
+
+  {
+    ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+    io_count_--;
+  }
+  check_destroy ();
+}
+
+void
+Receiver::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
+{
+  if (result.bytes_transferred () == 0 || result.error () != 0)
+    {
+      ACE_DEBUG ((LM_DEBUG, "handle_write_stream called\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+    }
+
+  result.message_block ().release ();
+
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      // This code is not robust enough to deal with short file writes
+      // (which hardly ever happen);-)
+      //	ACE_ASSERT (result.bytes_to_write () == result.bytes_transferred ());
+
+      if (duplex == 0)
+        initiate_read_stream ();
+    }
+
+  {
+    ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+    io_count_--;
+  }
+  check_destroy ();
+}
+
+class Sender : public ACE_Handler
+{
+  // = TITLE
+  //   Sends welcome messages receives them back.
+public:
+  Sender (void);
+  ~Sender (void);
+  int open (const ACE_TCHAR *host, u_short port);
+  void close (void);
+  ACE_HANDLE handle (void) const;
+
+protected:
+  // These methods are called by the freamwork
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
+  // This is called when asynchronous reads from the socket complete
+
+  virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
+  // This is called when asynchronous writes from the socket complete
+
+private:
+
+  int initiate_read_stream (void);
+  int initiate_write_stream (void);
+
+  ACE_SOCK_Stream stream_;
+  // Network I/O handle
+
+  ACE_Asynch_Write_Stream ws_;
+  // ws (write stream): for writing to the socket
+
+  ACE_Asynch_Read_Stream rs_;
+  // rs (read file): for reading from the socket
+
+  ACE_Message_Block welcome_message_;
+  // Welcome message
+
+  ACE_Recursive_Thread_Mutex mutex_;
+  long io_count_;
+};
+
+static char *data = "Welcome to Irfan World! Irfan RULES here !!\n";
+
+Sender::Sender (void)
+  : io_count_ (0)
+{
+  // Moment of inspiration... :-)
+  this->welcome_message_.init (data, ACE_OS::strlen (data));
+}
+
+Sender::~Sender (void)
+{
+  close ();
+}
+
+void Sender::close (void)
+{
+  this->stream_.close ();
+}
+
+ACE_HANDLE Sender::handle (void) const
+{
+  return this->stream_.get_handle ();
+}
+
+int Sender::open (const ACE_TCHAR *host, u_short port)
+{
+  // Initialize stuff
+  // Connect to remote host
+  ACE_INET_Addr address (port, host);
+  ACE_SOCK_Connector connector;
+
+  if (connector.connect (this->stream_,
+			 address) == -1)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "ACE_SOCK_Connector::connect"),
+                        -1);
+    }
+
+  // Open ACE_Asynch_Write_Stream
+  if (this->ws_.open (*this) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Write_Stream::open"),
+                      -1);
+
+  // Open ACE_Asynch_Read_Stream
+  if (this->rs_.open (*this) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Read_Stream::open"),
+                      -1);
+
+  // Start an asynchronous transmit file
+  if (this->initiate_write_stream () == -1)
+    return -1;
+
+  if (duplex != 0)
+    // Start an asynchronous read file
+    if (this->initiate_read_stream () == -1)
+      return -1;
+
+  return 0;
+}
+
+int
+Sender::initiate_write_stream (void)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+
+  welcome_message_.rd_ptr(welcome_message_.base ());
+  welcome_message_.wr_ptr(welcome_message_.base ());
+  welcome_message_.wr_ptr (ACE_OS::strlen (data));
+
+  if (this->ws_.write (welcome_message_,
+                       welcome_message_.length ()) == -1)
+    ACE_ERROR_RETURN((LM_ERROR,
+                      "%p\n",
+                      "ACE_Asynch_Write_Stream::write"),
+                     -1);
+  io_count_++;
+  return 0;
+}
+
+int
+Sender::initiate_read_stream (void)
+{
+  ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+
+  // Create a new <Message_Block>.  Note that this message block will
+  // be used both to <read> data asynchronously from the socket and to
+  // <write> data asynchronously to the file.
+  ACE_DEBUG ((LM_DEBUG,
+              "initiate_read_stream called\n"));
+
+  ACE_Message_Block *mb = 0;
+  ACE_NEW_RETURN (mb,
+                  ACE_Message_Block (BUFSIZ + 1),
+                  -1);
+
+  // Inititiate read
+  if (this->rs_.read (*mb, mb->size ()- 1) == -1)
+    {
+      mb->release ();
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         "%p\n",
+                         "ACE_Asynch_Read_Stream::read"),
+                        -1);
+    }
+
+  io_count_++;
+  return 0;
+}
+
+void
+Sender::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
+{
+  if (result.bytes_transferred () == 0 || result.error () != 0)
+    {
+      ACE_DEBUG ((LM_DEBUG, "handle_write_stream called\n"));
+
+      // Reset pointers.
+      result.message_block ().rd_ptr (result.message_block ().rd_ptr () - result.bytes_transferred ());
+
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+    }
+
+  // Simplify just for Test
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      if (duplex != 0)  // full duplex, continue write
+        initiate_write_stream ();
+      else  // half-duplex   read reply, after read we will start write
+        initiate_read_stream ();
+    }
+
+  {
+    ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+    io_count_--;
+  }
+}
+
+void
+Sender::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  if (result.bytes_transferred () == 0 || result.error () != 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "handle_read_stream called\n"));
+
+      // Reset pointers.
+      result.message_block ().rd_ptr ()[result.bytes_transferred ()] = '\0';
+
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long) result.completion_key ()));
+      ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", result.message_block ().rd_ptr ()));
+    }
+
+  result.message_block().release ();
+
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      // Successful read: write the data to the file asynchronously.
+      // Note how we reuse the <ACE_Message_Block> for the writing.
+      // Therefore, we do not delete this buffer because it is handled
+      // in <handle_write_stream>.
+
+      if (duplex != 0)  // full duplex, continue read
+        initiate_read_stream ();
+      else  // half-duplex  writey, after write we will start read
+        initiate_write_stream ();
+    }
+
+  {
+    ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
+    io_count_--;
+  }
+}
+
+static int
+set_proactor_type (const char *ptype)
+{
+  if (!ptype)
+    return false;
+
+  switch (toupper (*ptype))
+    {
+    case 'D' :  proactor_type = 0; return true;
+    case 'A' :  proactor_type = 1; return true;
+    case 'I' :  proactor_type = 2; return true;
+#if defined (sun)
+    case 'S' :  proactor_type = 3; return true;
+#endif /* sun */
+    }
+  return false;
+}
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("t:o:n:p:d:h:s:u"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    switch (c)
+      {
+      case 'd':		// duplex
+        duplex = ACE_OS::atoi (get_opt.opt_arg ());
+		break;
+      case 'h':		// host for sender
+        host = get_opt.opt_arg ();
+		break;
+      case 'p':		// port number
+        port = ACE_OS::atoi (get_opt.opt_arg ());
+		break;
+      case 'n':		// thread pool size
+        threads = ACE_OS::atoi (get_opt.opt_arg ());
+		break;
+      case 's':     // number of senders
+        senders = ACE_OS::atoi (get_opt.opt_arg ());
+	if (senders > MaxSenders)
+	  senders = MaxSenders;
+	break;
+      case 'o':     // max number of aio for proactor
+        max_aio_operations = ACE_OS::atoi (get_opt.opt_arg ());
+	break;
+      case 't':    //  Proactor Type
+	if (set_proactor_type (get_opt.opt_arg ()))
+          break;
+      case 'u':
+      default:
+	ACE_ERROR ((LM_ERROR, "%p.",
+		    "\nusage:"
+		    "\n-o <max number of started aio operations for Proactor>"
+                    "\n-t <Proactor type> UNIX-only, Win32-default always:"
+                    "\n    a AIOCB"
+                    "\n    i SIG"
+                    "\n    s SUN"
+                    "\n    d default"
+		    "\n-d <duplex mode 1-on/0-off>"
+		    "\n-h <host> for Sender mode"
+		    "\n-n <number threads for Proactor pool>"
+		    "\n-p <port to listen/connect>"
+		    "\n-s <number of sender's instances>"
+		    "\n-u show this message"
+		    "\n"));
+
+	return -1;
+      }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+#if defined (sun)
+  ACE_DEBUG ((LM_DEBUG, "\nSUN defined!\n"));
+#endif
+  if (parse_args (argc, argv) == -1)
+    return -1;
+
+  disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX);
+
+  MyTask task1;
+
+  if (task1.activate (THR_NEW_LWP, threads) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p.\n",
+                       "main"),
+                      -1);
+
+  // wait for creation of Proactor
+  task1.waitready ();
+
+  Sender * send_list[MaxSenders];
+
+  ACE_Asynch_Acceptor<Receiver> acceptor;
+
+  int rc = -1;
+  int i;
+  char c;
+
+  if (host == 0) // Acceptor
+    {
+      // Simplify, initial read with  zero size
+      if (acceptor.open (ACE_INET_Addr (port),0,1) == 0)
+        rc = 1;
+    }
+  else
+    {
+      for (i = 0; i < senders; ++i)
+        send_list[i] = new Sender;
+
+      for (i = 0; i < senders; ++i)
+        if (send_list[i]->open (host, port) == 0)
+          rc++;
+    }
+
+  if (rc > 0)
+    {
+      cout << "Press any key to stop=>" << flush;
+      cin.clear ();
+      cin >> c;
+    }
+
+  ACE_Proactor::end_event_loop ();
+
+  if (host != 0) // we are sender
+    {
+      for (i = 0; i < senders; ++i)
+        send_list[i]->close ();
+    }
+
+
+  ACE_Thread_Manager *tm =
+    ACE_Thread_Manager::instance();
+
+  tm->wait_task (&task1);
+
+  cout 	<< "\nNumber of Receivers objects="
+        << Receiver::get_number_sessions ()
+        << flush;
+
+  for (i = 0; i < senders; ++i)
+    {
+      delete (send_list[i]);
+      send_list[i] = 0;
+    }
+
+  return 0;
+}
+
+static int
+disable_signal (int sigmin, int sigmax)
+{
+#ifndef ACE_WIN32
+
+  sigset_t signal_set;
+  if (sigemptyset (&signal_set) == - 1)
+    ACE_ERROR ((LM_ERROR,
+                "Error:(%P | %t):%p\n",
+                "sigemptyset failed"));
+
+  for (int i = sigmin; i <= sigmax; i++)
+    sigaddset (&signal_set, i);
+
+  //  Put the <signal_set>.
+  if (ACE_OS::pthread_sigmask (SIG_BLOCK, &signal_set, 0) != 0)
+    ACE_ERROR ((LM_ERROR,
+                "Error:(%P | %t):%p\n",
+                "pthread_sigmask failed"));
+#endif /* ACE_WIN32 */
+
+  return 1;
+}
+
+// Get the <signal_set> back from the OS.
+
+#if 0
+static int
+print_sigmask (void)
+{
+#ifndef ACE_WIN32
+  sigset_t  mask;
+  int member = 0;
+
+  COUT ("\n=============Signal Mask==========")
+
+  if (ACE_OS::pthread_sigmask (SIG_SETMASK, 0, & mask) != 0)
+    ACE_ERROR ((LM_ERROR,
+                "Error:(%P | %t):%p\n",
+                "ACE_OS::pthread_sigmask failed"));
+  else
+    for (int i = 1; i < 1000; i++)
+      {
+        member = sigismember (&mask,i);
+
+        COUT ("\nSig ")
+        COUT (i)
+        COUT (" is ")
+        COUT (member)
+
+        if (member == -1)
+          break;
+    }
+
+#endif /* ACE_WIN32 */
+  return 0;
+}
+#endif /* 0 */
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
diff --git a/ACE/examples/Reactor/Proactor/test_timeout.cpp b/ACE/examples/Reactor/Proactor/test_timeout.cpp
new file mode 100644
index 00000000000..39351717db9
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_timeout.cpp
@@ -0,0 +1,130 @@
+// $Id: test_timeout.cpp
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_timeout.cpp
+//
+// = DESCRIPTION
+//
+//    This example application shows how to write event loops that
+//    handle events for some fixed amount of time. Note that any
+//    thread in the Proactor thread pool can call back the handler. On
+//    POSIX4 systems, this test works only with POSIX_SIG_Proactor,
+//    which can work with multiple threads.
+//
+// = AUTHOR
+//    Irfan Pyarali and Alexander Babu Arulanthu
+//
+// ============================================================================
+
+#include "ace/Proactor.h"
+#include "ace/Task.h"
+#include "ace/Atomic_Op.h"
+#include "ace/OS_NS_sys_time.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(Proactor, test_timeout, "$Id$")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || \
+     (defined (ACE_HAS_AIO_CALLS)) && !defined (ACE_POSIX_AIOCB_PROACTOR))
+  // This only works on Win32 platforms and on Unix platforms supporting
+  // POSIX aio calls.
+
+class Timeout_Handler : public ACE_Handler
+{
+  // = TITLE
+  //     Generic timeout handler.
+public:
+  Timeout_Handler (void)
+    : start_time_ (ACE_OS::gettimeofday ())
+    {
+    }
+
+  virtual void handle_time_out (const ACE_Time_Value &tv,
+				const void *arg)
+    {
+      // Print out when timeouts occur.
+      ACE_DEBUG ((LM_DEBUG, "(%t) %d timeout occurred for %s @ %d.\n",
+		  ++count_,
+		  (char *) arg,
+		  (tv - this->start_time_).sec ()));
+
+      // Sleep for a while
+      ACE_OS::sleep (4);
+    }
+
+private:
+  ACE_Atomic_Op <ACE_SYNCH_MUTEX, int> count_;
+  // Number of the timer event.
+
+  ACE_Time_Value start_time_;
+  // Starting time of the test.
+};
+
+class Worker : public ACE_Task <ACE_NULL_SYNCH>
+{
+public:
+  int svc (void)
+    {
+      // Handle events for 13 seconds.
+      ACE_Time_Value run_time (13);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t):Starting svc routine\n"));
+
+      if (ACE_Proactor::run_event_loop(run_time) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "(%t):%p.\n", "Worker::svc"), -1);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t) work complete\n"));
+
+      return 0;
+    }
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Timeout_Handler handler;
+
+  // Register a 2 second timer.
+  ACE_Time_Value foo_tv (2);
+  if (ACE_Proactor::instance ()->schedule_timer (handler,
+                                                 (void *) "Foo",
+                                                 ACE_Time_Value::zero,
+                                                 foo_tv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+  // Register a 3 second timer.
+  ACE_Time_Value bar_tv (3);
+  if (ACE_Proactor::instance ()->schedule_timer (handler,
+                                                 (void *) "Bar",
+                                                 ACE_Time_Value::zero,
+                                                 bar_tv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+  Worker worker;
+
+  if (worker.activate (THR_NEW_LWP, 10) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "main"), -1);
+
+  ACE_Thread_Manager::instance ()->wait ();
+
+  return 0;
+}
+
+#else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
+
+int
+main (int, char *[])
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "This example is multithreaded version of test_timeout_st.cpp\n"
+              "This doesnt work on this platform !!!\n"));
+  return 1;
+}
+
+#endif /*  ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS && !ACE_POSIX_AIOCB_PROACTOR*/
diff --git a/ACE/examples/Reactor/Proactor/test_timeout_st.cpp b/ACE/examples/Reactor/Proactor/test_timeout_st.cpp
new file mode 100644
index 00000000000..ae44c2ba1f4
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_timeout_st.cpp
@@ -0,0 +1,99 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_timeout_st.cpp
+//
+// = DESCRIPTION
+//
+//    This example application shows how to write event loops that
+//    handle events for some fixed amount of time. This is the single
+//    threaded version of the test_timeout.cpp application.
+//
+// = AUTHOR
+//    Irfan Pyarali and Alexander Babu Arulanthu
+//
+// ============================================================================
+
+#include "ace/Proactor.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(Proactor, test_timeout, "$Id$")
+
+#if ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
+// This only works on Win32 platforms and on Unix platforms supporting
+// POSIX aio calls.
+
+class Timeout_Handler : public ACE_Handler
+{
+  // = TITLE
+  //     Generic timeout handler.
+
+public:
+  Timeout_Handler (void)
+    : count_ (0),
+      start_time_ (ACE_OS::gettimeofday ())
+    {
+    }
+
+  virtual void handle_time_out (const ACE_Time_Value &tv,
+				const void *arg)
+    {
+      // Print out when timeouts occur.
+      ACE_DEBUG ((LM_DEBUG, "(%t) %d timeout occurred for %s @ %d.\n",
+		  ++count_,
+		  (char *) arg,
+		  (tv - this->start_time_).sec ()));
+    }
+
+private:
+  int count_;
+  // Sequence number for the timeouts.
+
+  ACE_Time_Value start_time_;
+  // Starting time of the test.
+};
+
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Timeout_Handler handler;
+
+  // Register a 2 second timer.
+  ACE_Time_Value foo_tv (2);
+  if (ACE_Proactor::instance ()->schedule_timer (handler,
+                                                 (void *) "Foo",
+                                                 ACE_Time_Value::zero,
+                                                 foo_tv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+  // Register a 3 second timer.
+  ACE_Time_Value bar_tv (3);
+  if (ACE_Proactor::instance ()->schedule_timer (handler,
+                                                 (void *) "Bar",
+                                                 ACE_Time_Value::zero,
+                                                 bar_tv) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+  // Handle events for 13 seconds.
+  ACE_Time_Value run_time (13);
+
+  ACE_DEBUG ((LM_DEBUG, "Starting event loop\n"));
+
+  // Run the event loop.
+  if (ACE_Proactor::run_event_loop(run_time) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "(%t):%p.\n", "Worker::svc"),
+                      1);
+
+  ACE_DEBUG ((LM_DEBUG, "Ending event loop\n"));
+
+  return 0;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
diff --git a/ACE/examples/Reactor/Proactor/test_udp_proactor.cpp b/ACE/examples/Reactor/Proactor/test_udp_proactor.cpp
new file mode 100644
index 00000000000..49d834a2884
--- /dev/null
+++ b/ACE/examples/Reactor/Proactor/test_udp_proactor.cpp
@@ -0,0 +1,432 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    test_udp_proactor.cpp
+//
+// = DESCRIPTION
+//    This program illustrates how the <ACE_Proactor> can be used to
+//    implement an application that does asynchronous operations using
+//    datagrams.
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu> and
+//    Roger Tragin <r.tragin@computer.org>
+//
+// ============================================================================
+
+#include "ace/OS_NS_string.h"
+#include "ace/OS_main.h"
+#include "ace/Proactor.h"
+#include "ace/Asynch_IO.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Dgram.h"
+#include "ace/Message_Block.h"
+#include "ace/Get_Opt.h"
+#include "ace/Log_Msg.h"
+
+ACE_RCSID(Proactor, test_udp_proactor, "test_proactor.cpp,v 1.29 2001/02/02 23:41:16 shuston Exp")
+
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) || defined (ACE_HAS_AIO_CALLS)
+  // This only works on Win32 platforms.
+
+// Host that we're connecting to.
+static ACE_TCHAR *host = 0;
+
+// Port that we're receiving connections on.
+static u_short port = ACE_DEFAULT_SERVER_PORT;
+
+// Keep track of when we're done.
+static int done = 0;
+
+class Receiver : public ACE_Service_Handler
+{
+  // = TITLE
+  //     This class will receive data from
+  //     the network connection and dump it to a file.
+public:
+  // = Initialization and termination.
+  Receiver (void);
+  ~Receiver (void);
+
+  int open_addr (const ACE_INET_Addr &localAddr);
+
+protected:
+  // These methods are called by the framework
+
+  /// This method will be called when an asynchronous read completes on
+  /// a UDP socket.
+  virtual void handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result);
+
+private:
+  ACE_SOCK_Dgram sock_dgram_;
+
+  ACE_Asynch_Read_Dgram rd_;
+  // rd (read dgram): for reading from a UDP socket.
+  const char* completion_key_;
+  const char* act_;
+};
+
+Receiver::Receiver (void)
+  : completion_key_ ("Receiver Completion Key"),
+    act_ ("Receiver ACT")
+{
+}
+
+Receiver::~Receiver (void)
+{
+  sock_dgram_.close ();
+}
+
+int
+Receiver::open_addr (const ACE_INET_Addr &localAddr)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "%N:%l:Receiver::open_addr called\n"));
+
+  // Create a local UDP socket to receive datagrams.
+  if (this->sock_dgram_.open (localAddr) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_SOCK_Dgram::open"), -1);
+
+  // Initialize the asynchronous read.
+  if (this->rd_.open (*this,
+                      this->sock_dgram_.get_handle (),
+                      this->completion_key_,
+                      ACE_Proactor::instance ()) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Read_Dgram::open"), -1);
+
+  // Create a buffer to read into.  We are using scatter/gather to
+  // read the message header and message body into 2 buffers
+
+  // create a message block to read the message header
+  ACE_Message_Block* msg = 0;
+  ACE_NEW_RETURN (msg, ACE_Message_Block (1024), -1);
+
+  // the next line sets the size of the header, even though we
+  // allocated a the message block of 1k, by setting the size to 20
+  // bytes then the first 20 bytes of the reveived datagram will be
+  // put into this message block.
+  msg->size (20); // size of header to read is 20 bytes
+
+  // create a message block to read the message body
+  ACE_Message_Block* body = 0;
+  ACE_NEW_RETURN (body, ACE_Message_Block (1024), -1);
+  // The message body will not exceed 1024 bytes, at least not in this test.
+
+  // set body as the cont of msg.  This associates the 2 message
+  // blocks so that a read will fill the first block (which is the
+  // header) up to size (), and use the cont () block for the rest of
+  // the data.  You can chain up to IOV_MAX message block using this
+  // method.
+  msg->cont (body);
+
+  // ok lets do the asynch read
+  size_t number_of_bytes_recvd = 0;
+
+  int res = rd_.recv (msg,
+                      number_of_bytes_recvd,
+                      0,
+                      PF_INET,
+                      this->act_);
+  switch (res)
+    {
+    case 0:
+      // this is a good error.  The proactor will call our handler when the
+      // read has completed.
+      break;
+    case 1:
+      // actually read something, we will handle it in the handler callback
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG,
+                  "%s = %d\n",
+                  "bytes recieved immediately",
+                  number_of_bytes_recvd));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      res = 0;
+      break;
+    case -1:
+      // Something else went wrong.
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Read_Dgram::recv"));
+      // the handler will not get called in this case so lets clean up our msg
+      msg->release ();
+      break;
+    default:
+      // Something undocumented really went wrong.
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Read_Dgram::recv"));
+      msg->release ();
+      break;
+    }
+
+  return res;
+}
+
+void
+Receiver::handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_read_dgram called\n"));
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_INET_Addr peerAddr;
+  result.remote_address (peerAddr);
+  ACE_DEBUG ((LM_DEBUG, "%s = %s:%d\n", "peer_address", peerAddr.get_host_addr (), peerAddr.get_port_number ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "flags", result.flags ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "act", result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "completion_key", result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+
+  if (result.success () && result.bytes_transferred () != 0)
+    {
+      // loop through our message block and print out the contents
+      for (const ACE_Message_Block* msg = result.message_block (); msg != 0; msg = msg->cont ())
+        { // use msg->length () to get the number of bytes written to the message
+          // block.
+          ACE_DEBUG ((LM_DEBUG, "Buf=[size=<%d>", msg->length ()));
+          for (u_long i = 0; i < msg->length (); ++i)
+            ACE_DEBUG ((LM_DEBUG,
+                        "%c", (msg->rd_ptr ())[i]));
+          ACE_DEBUG ((LM_DEBUG, "]\n"));
+        }
+    }
+
+  ACE_DEBUG ((LM_DEBUG,
+              "Receiver completed\n"));
+
+  // No need for this message block anymore.
+  result.message_block ()->release ();
+
+  // Note that we are done with the test.
+  done++;
+}
+
+class Sender : public ACE_Handler
+{
+  // = TITLE
+  //     The class will be created by <main>.
+public:
+  Sender (void);
+  ~Sender (void);
+  int open (const ACE_TCHAR *host, u_short port);
+
+protected:
+  // These methods are called by the freamwork
+
+  virtual void handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result);
+  // This is called when asynchronous writes from the dgram socket
+  // complete
+
+private:
+
+  ACE_SOCK_Dgram sock_dgram_;
+  // Network I/O handle
+
+  ACE_Asynch_Write_Dgram wd_;
+  // wd (write dgram): for writing to the socket
+
+  const char* completion_key_;
+  const char* act_;
+};
+
+Sender::Sender (void)
+  : completion_key_ ("Sender completion key"),
+    act_ ("Sender ACT")
+{
+}
+
+Sender::~Sender (void)
+{
+  this->sock_dgram_.close ();
+}
+
+int
+Sender::open (const ACE_TCHAR *host,
+              u_short port)
+{
+  // Initialize stuff
+
+  if (this->sock_dgram_.open (ACE_INET_Addr::sap_any) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_SOCK_Dgram::open"), -1);
+
+  // Initialize the asynchronous read.
+  if (this->wd_.open (*this,
+                      this->sock_dgram_.get_handle (),
+                      this->completion_key_,
+                      ACE_Proactor::instance ()) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p\n",
+                       "ACE_Asynch_Write_Dgram::open"), -1);
+
+  // We are using scatter/gather to send the message header and
+  // message body using 2 buffers
+
+  // create a message block for the message header
+  ACE_Message_Block* msg = 0;
+  ACE_NEW_RETURN (msg, ACE_Message_Block (100), -1);
+  const char raw_msg [] = "To be or not to be.";
+  // Copy buf into the Message_Block and update the wr_ptr ().
+  msg->copy (raw_msg, ACE_OS::strlen (raw_msg) + 1);
+
+  // create a message block for the message body
+  ACE_Message_Block* body = 0;
+  ACE_NEW_RETURN (body, ACE_Message_Block (100), -1);
+  ACE_OS::memset (body->wr_ptr (), 'X', 100);
+  body->wr_ptr (100); // always remember to update the wr_ptr ()
+
+  // set body as the cont of msg.  This associates the 2 message blocks so
+  // that a send will send the first block (which is the header) up to
+  // length (), and use the cont () to get the next block to send.  You can
+  // chain up to IOV_MAX message block using this method.
+  msg->cont (body);
+
+  // do the asynch send
+  size_t number_of_bytes_sent = 0;
+  ACE_INET_Addr serverAddr (port, host);
+  int res = this->wd_.send (msg, number_of_bytes_sent, 0, serverAddr, this->act_);
+
+  switch (res)
+    {
+    case 0:
+      // this is a good error.  The proactor will call our handler when the
+      // send has completed.
+      break;
+    case 1:
+      // actually sent something, we will handle it in the handler callback
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      ACE_DEBUG ((LM_DEBUG,
+                  "%s = %d\n",
+                  "bytes sent immediately",
+                  number_of_bytes_sent));
+      ACE_DEBUG ((LM_DEBUG, "********************\n"));
+      res = 0;
+      break;
+    case -1:
+      // Something else went wrong.
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Write_Dgram::recv"));
+      // the handler will not get called in this case so lets clean up our msg
+      msg->release ();
+      break;
+    default:
+      // Something undocumented really went wrong.
+      ACE_ERROR ((LM_ERROR,
+                  "%p\n",
+                  "ACE_Asynch_Write_Dgram::recv"));
+      msg->release ();
+      break;
+    }
+  return res;
+}
+
+void
+Sender::handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "handle_write_dgram called\n"));
+
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", result.bytes_to_write ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered", result.bytes_transferred ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "flags", result.flags ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "act", result.act ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "completion_key", result.completion_key ()));
+  ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
+  ACE_DEBUG ((LM_DEBUG, "********************\n"));
+
+
+  ACE_DEBUG ((LM_DEBUG,
+              "Sender completed\n"));
+
+  // No need for this message block anymore.
+  result.message_block ()->release ();
+
+  // Note that we are done with the test.
+  done++;
+}
+
+static int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("h:p:"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    switch (c)
+      {
+      case 'h':
+        host = get_opt.opt_arg ();
+        break;
+      case 'p':
+        port = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR, "%p.\n",
+                           "usage :\n"
+                           "-h <host>\n"), -1);
+      }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  if (parse_args (argc, argv) == -1)
+    return -1;
+
+  Sender sender;
+
+  Receiver receiver;
+
+  // If passive side
+  if (host == 0)
+    {
+      if (receiver.open_addr (ACE_INET_Addr (port)) == -1)
+        return -1;
+    }
+  // If active side
+  else if (sender.open (host, port) == -1)
+    return -1;
+
+  for (int success = 1;
+       success > 0  && !done;
+       )
+    // Dispatch events via Proactor singleton.
+    success = ACE_Proactor::instance ()->handle_events ();
+
+  return 0;
+}
+
+#else /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "This example does not work on this platform.\n"));
+  return 1;
+}
+
+#endif /* ACE_WIN32 && !ACE_HAS_WINCE || ACE_HAS_AIO_CALLS*/
+
diff --git a/ACE/examples/Reactor/README b/ACE/examples/Reactor/README
new file mode 100644
index 00000000000..fefaeeaf317
--- /dev/null
+++ b/ACE/examples/Reactor/README
@@ -0,0 +1,20 @@
+This directory contains subdirectories that test the ACE Reactor and Proactor
+
+	. Dgram
+		Tests the CODgram and Dgram classes with the Reactor.	
+	
+	. Misc
+		Various miscellaneous tests of Reactor functionality
+		(e.g., signals, timers, notification, etc.).
+
+	. Multicast
+		Tests out the ACE multicast capabilities in conjunction
+		with the Reactor.
+
+	. Ntalker
+		A program that implements a multicast "chat" program.
+
+
+	. Proactor
+		A program that illustrates the "Proactive" version of
+		the Reactor
diff --git a/ACE/examples/Reactor/TP_Reactor/AcceptHandler.cpp b/ACE/examples/Reactor/TP_Reactor/AcceptHandler.cpp
new file mode 100644
index 00000000000..7ae34d2b2b4
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/AcceptHandler.cpp
@@ -0,0 +1,106 @@
+/*
+ * $Id$
+ *
+ * ACE reactor demonstration
+ *
+ * Date: 26-Jan-2006
+ */
+
+#include <ace/Auto_Ptr.h>
+#include <ace/INET_Addr.h>
+
+#include "common.h"
+#include "AcceptHandler.h"
+#include "ReadHandler.h"
+
+AcceptHandler:: AcceptHandler(ACE_Reactor *reactor) :
+        ACE_Event_Handler(),
+        mReactor(reactor == 0 ? ACE_Reactor::instance() : reactor),
+        mAcceptor() {
+    ACE_TRACE("AcceptHandler:: AcceptHandler(ACE_Reactor *)");
+}
+
+AcceptHandler::~AcceptHandler() {
+    ACE_TRACE("AcceptHandler::~AcceptHandler()");
+}
+
+int AcceptHandler::open(void) {
+    ACE_TRACE("AcceptHandler::open(void)");
+
+    // create the local address used for the service (PORT is from common.h)
+    ACE_INET_Addr addr(PORT);
+
+    // open a port using the acceptor; reuse the address later
+    if (mAcceptor.open(addr, 1) == -1)
+      ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to open ")
+                        ACE_TEXT ("listening socket. (errno = %i: %m)\n"), errno), -1);
+
+    // register the handler with the reactor
+    if (mReactor->register_handler(this,
+            ACE_Event_Handler::ACCEPT_MASK) == -1) {
+      ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to register accept ")
+                 ACE_TEXT ("handler. (errno = %i: %m)\n"), errno));
+
+        // don't leave the acceptor open
+        if (mAcceptor.close() == -1)
+          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to close the socket ")
+                     ACE_TEXT ("after previous error. (errno = %i: %m)\n"),
+                        errno));
+        return -1;
+    }
+
+    return 0;
+}
+
+ACE_HANDLE AcceptHandler::get_handle(void) const {
+    ACE_TRACE("AcceptHandler::get_handle(void)");
+    return mAcceptor.get_handle();
+}
+
+int AcceptHandler::handle_input(ACE_HANDLE) {
+    ACE_TRACE("AcceptHandler::handle_input(ACE_HANDLE)");
+
+    ACE_INET_Addr clientAddr;
+
+    // create a new ReadHandler
+    ReadHandler *reader = 0;
+    ACE_NEW_NORETURN (reader, ReadHandler());
+    if (reader == 0)
+      ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to allocate ")
+                        ACE_TEXT ("reader. (errno = %i: %m)\n"), errno), -1);
+
+    // put reader in an auto pointer so we can use ACE_ERROR_RETURN safely
+    auto_ptr<ReadHandler> pReader(reader);
+
+    // accept the connection using the reader's stream
+    if (mAcceptor.accept(reader->getStream(), &clientAddr) == -1)
+      ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to accept ")
+                    ACE_TEXT ("client connection. (errno = %i: %m)\n"), errno), -1);
+
+    // register the reader with the reactor
+    if (mReactor->register_handler(reader,
+            ACE_Event_Handler::READ_MASK) == -1)
+      ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to register ")
+                        ACE_TEXT ("read handler. (errno = %i: %m)\n"), errno), -1);
+
+    // from now on the read handler takes care of itself
+    pReader.release();
+
+    return 0; // keep going
+}
+
+int AcceptHandler::handle_close(ACE_HANDLE, ACE_Reactor_Mask) {
+    ACE_TRACE("AcceptHandler::handle_close(ACE_HANDLE, ACE_Reactor_Mask)");
+
+    // close the listening socket
+    if (mAcceptor.close() == -1)
+      ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to close the ")
+                 ACE_TEXT ("socket. (errno = %i: %m)\n"), errno));
+
+    // no need to distinguish between error during close and normal close
+    // since ACE does not evaluate the return value of handle_close()
+
+    delete this;
+    return 0;
+}
+
diff --git a/ACE/examples/Reactor/TP_Reactor/AcceptHandler.h b/ACE/examples/Reactor/TP_Reactor/AcceptHandler.h
new file mode 100644
index 00000000000..036f7a36f5a
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/AcceptHandler.h
@@ -0,0 +1,75 @@
+/*
+ * ACE reactor demonstration
+ *
+ * $Id$
+ * Date: 26-Jan-2006
+ */
+
+#ifndef __ACCEPTHANDLER_H__
+#define __ACCEPTHANDLER_H__
+
+#include <ace/Event_Handler.h>
+#include <ace/Reactor.h>
+#include <ace/SOCK_Acceptor.h>
+
+/**
+ * This accept handler is based on the provided solution from the ACE course.
+ */
+class AcceptHandler : public ACE_Event_Handler {
+
+    private:
+
+        /**
+         * The reactor to which the accept handler belongs.
+         */
+        ACE_Reactor *mReactor;
+
+        /**
+         * The socket used for incoming conections.
+         */
+        ACE_SOCK_Acceptor mAcceptor;
+
+    public:
+
+        /**
+         * @param reactor The reactor which will use this accept handler.
+         */
+        AcceptHandler(ACE_Reactor *reactor = 0);
+
+        /**
+         * The destructor exists for tracing purposes.
+         */
+        virtual ~AcceptHandler();
+
+        /**
+         * Open the listening socket and register the handler with the reactor.
+         *
+         * @return 0 on success, -1 on failure
+         */
+        int open(void);
+
+        /**
+         * @name Overridden methods from the ACE_Event_Handler
+         */
+        // @{
+
+        /**
+         * Provides the handle of mAcceptor.
+         */
+        virtual ACE_HANDLE get_handle(void) const;
+
+        /**
+         * Create a read handler for the new connection and register that
+         * handler with the reactor.
+         */
+        virtual int handle_input(ACE_HANDLE = ACE_INVALID_HANDLE);
+
+        /**
+         * Close the listening socket.
+         */
+        virtual int handle_close(ACE_HANDLE, ACE_Reactor_Mask);
+        // @}
+};
+
+#endif /* __ACCEPTHANDLER_H__ */
+
diff --git a/ACE/examples/Reactor/TP_Reactor/Makefile.am b/ACE/examples/Reactor/TP_Reactor/Makefile.am
new file mode 100644
index 00000000000..5407cbb10e1
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/Makefile.am
@@ -0,0 +1,53 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+## Makefile.TP_Reactor_Client.am
+noinst_PROGRAMS = client
+
+client_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+client_SOURCES = \
+  client.cpp \
+  AcceptHandler.h \
+  ReadHandler.h \
+  common.h
+
+client_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Makefile.TP_Reactor_Server.am
+noinst_PROGRAMS += server
+
+server_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+server_SOURCES = \
+  AcceptHandler.cpp \
+  ReadHandler.cpp \
+  server.cpp \
+  AcceptHandler.h \
+  ReadHandler.h
+
+server_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/TP_Reactor/README b/ACE/examples/Reactor/TP_Reactor/README
new file mode 100644
index 00000000000..32fbc15aca9
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/README
@@ -0,0 +1,86 @@
+ACE reactor demonstration
+=========================
+
+Martin Kolleck
+Tino Riethmuller
+
+
+
+1. Introduction
+
+This program demonstrates what we think is a bug in the ACE library. The
+affected component is the ACE_TP_Reactor. According to the documentation, the
+reactor ensures that only one of the handle_*() methods of an event handler is
+called at a time. Tino found this to be not true and I wrote this example
+program showing the behavior. I do not exclude the possibility that we are
+using the ACE library in an unintended/wrong way. So comments on the code as
+well as any other remarks are welcome.
+
+
+
+2. The program
+
+The program consists of a client and a server. The general implementation is
+taken from the example solution to exercise 4c of the ACE course. The client
+will send a request to the server. This request is interpreted to be the size
+of the following data. The server allocates the memory required to hold the
+client's data and then sends a confirmation to the client, that it may
+proceed. The the client sends the large data chunk and the server again
+confirms it.
+
+The client runs in a loop which can be configured to run indefinitely or a
+previously set amount of times. The configuration i done from the command
+line. To invoke the client type:
+
+    $ ./client size [count]
+
+<size> sets the size (in MiB) of the buffer sent to the server. Depending on
+the systems, values between 60 and 100 have been used for testing. <count>
+determines how often the buffer is sent. If left out, the clients send the
+buffer until interrupted.
+
+The server is started without arguments. Both programs will print a dot for
+each successful connection. I found this an easy and unintrusive way of showing
+progress whithout flooding the console too fast. This also makes it easier to
+see when an error has occurred.
+
+
+
+3. Building the program
+
+This example was created on a Linux box. You will need the environment
+variable ACE_ROOT set up to the location where ACE is installed. It might be
+possible, that the path where the ACE libraries are found, needs to be adjusted
+in the Makefile.
+
+To compile simply type 'make' on the command prompt.
+
+    $ make
+
+This will create two executable files. One for the server and one for the
+client. (named respectively)
+
+
+
+4. Running the program
+
+The error seems to be of statistical nature. Occurring only under certain
+conditions (which I am not sure of, what they are). I successfully produced
+the error on the four machines given below (architecture, ACE and compiler
+version). I tested the program with localhost connections, as well as over
+a real network connection and could always reproduce the error.
+
+To detect the error I introduced a member variable to the read event handler.
+This counter is initialized to zero in the constructor. When handle_input() of
+the event handler is called, the counter is increased and decreased, when
+handle_input() returns. Before increasing the counter, It is compared to zero
+(which it should alway be, if only one invocation to handle_input() is made
+at a time) and an error message is printed if it is not zero.
+
+To test for the error, I ran one instance of the server program and TWO
+instances of the client program. The sizes of the buffers were between 60 and
+100 MiB and no count was given (running until stopped) The three Linux boxes
+showed the error within one minute of starting both clients. For the Windows
+box I decreased the buffer size to 15 and 20 MiB (Windows does not seem to have
+very performant localhost connectivity) and it took about half an
+hour until the error occurred the first time.
diff --git a/ACE/examples/Reactor/TP_Reactor/ReadHandler.cpp b/ACE/examples/Reactor/TP_Reactor/ReadHandler.cpp
new file mode 100644
index 00000000000..06c6c953046
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/ReadHandler.cpp
@@ -0,0 +1,151 @@
+/*
+ * ACE reactor demonstration
+ *
+ * $Id$
+ * Date: 26-Jan-2006
+ */
+
+#include <ace/streams.h>
+#include <ace/Time_Value.h>
+
+#include "common.h"
+#include "ReadHandler.h"
+
+/**
+ * This macro is used to increase the invocation counter by one when entering
+ * handle_input(). It also checks wether the counter is greater than zero
+ * indicating, that handle_input() has been called before.
+ */
+#define INVOCATION_ENTER() do { if (mInvocationCounter > 0) \
+        ACE_ERROR((LM_ERROR, ACE_TEXT("Multiple invocations detected.\n"))); \
+        mInvocationCounter++; } while (0)
+
+/**
+ * THis macro is the counter part to INVOCATION_ENTER(). It decreases the
+ * invocation counter and then returns the given value. This macro is
+ * here for convenience to decrease the invocation counter also when returning
+ * due to errors.
+ */
+#define INVOCATION_RETURN(retval) do { mInvocationCounter--; \
+                                    return retval; } while(0)
+
+ReadHandler::ReadHandler() : ACE_Event_Handler(), mStream(), mDataSize(0),
+        mData(0), mCallCounter(0), mInvocationCounter(0) {
+    ACE_TRACE(ACE_TEXT("ReadHandler::ReadHandler()"));
+}
+
+ReadHandler::~ReadHandler() {
+    ACE_TRACE(ACE_TEXT("ReadHandler::~ReadHandler()"));
+
+    if (mStream.close() == -1)
+      ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to close socket. ")
+                 ACE_TEXT ("(errno = %i: %m)\n"), errno));
+
+    delete[] mData;
+}
+
+ACE_SOCK_Stream &ReadHandler::getStream(void) {
+    ACE_TRACE(ACE_TEXT("ReadHandler::getStream(void)"));
+    return mStream;
+}
+
+ACE_HANDLE ReadHandler::get_handle(void) const {
+    ACE_TRACE(ACE_TEXT("ReadHandler::get_handle(void)"));
+    return mStream.get_handle();
+}
+
+int ReadHandler::handle_input(ACE_HANDLE) {
+    ACE_TRACE(ACE_TEXT("ReadHandler::handle_input(ACE_HANDLE)"));
+
+    INVOCATION_ENTER();
+
+    // the response sent to the client
+    char response = 0;
+
+    if (mCallCounter == 0) {
+
+        /*
+         * This is the first request from the client.
+         */
+
+        // increase the call counter so the next client request goes to else-if
+        mCallCounter++;
+
+        // get the desired size from the client
+        // Note: only use the sizeof and pointer to int on compatible
+        //       platforms (i.e. little-endian/big-endian, data type size)
+        if (mStream.recv_n(&mDataSize, sizeof(mDataSize),
+                &connTimeout) != sizeof(mDataSize)) {
+          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to receive ")
+                     ACE_TEXT ("request. (errno = %i: %m)\n"), errno));
+            INVOCATION_RETURN(-1);
+        }
+
+        // The verbose debug output is replaced with some unintrusive dots.
+        // This increases visibility of the desired effect.
+        // ACE_DEBUG((LM_DEBUG, ACE_TEXT("%@: Data size: %i\n"), this, mDataSize));
+        ACE_DEBUG((LM_DEBUG, ACE_TEXT(".")));
+
+        // check mDataSize for plausability then allocate memory
+        if (mDataSize > 0) {
+            mData = new (std::nothrow) char[mDataSize];
+            if (mData == 0)
+              ACE_DEBUG((LM_DEBUG, ACE_TEXT("%N:%l: Failed to allocate ")
+                         ACE_TEXT ("data buffer.\n")));
+            else
+                response = 'K';
+        }
+
+        // send the response to the client (which is still 0, if the
+        // allocation did not succeed)
+        if (mStream.send_n(&response, sizeof(response), &connTimeout) != 1) {
+          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to send ")
+                     ACE_TEXT ("response. (errno = %i: %m)\n"), errno));
+            INVOCATION_RETURN(-1);
+        }
+
+        if (response == 'K')
+            INVOCATION_RETURN(0); // get another request from the same client
+        else
+            INVOCATION_RETURN(-1); // the client will not send data if response != 'K'
+
+    } else if (mCallCounter == 1) {
+
+        /*
+         * This is the second request from the client.
+         */
+
+        // increase the call counter, this read handler should not be called
+        // again
+        mCallCounter++;
+
+        // receive the data from the client
+        if (mStream.recv_n(mData, mDataSize, &connTimeout) != mDataSize) {
+          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to receive data.")
+                     ACE_TEXT ("(errno = %i: %m)\n"), errno));
+            INVOCATION_RETURN(-1);
+        }
+
+        response = 'K';
+
+        if (mStream.send_n(&response, 1, &connTimeout) != 1) {
+          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to send ")
+                     ACE_TEXT ("confirmation. (errno = %i: %m)\n"), errno));
+            INVOCATION_RETURN(-1);
+        }
+
+        INVOCATION_RETURN(-1); // ask for removal, since client does not send any more data
+    }
+
+    // this is to find strange actions with the call counter
+    ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: We should not get here.")));
+    INVOCATION_RETURN(-1);
+}
+
+int ReadHandler::handle_close(ACE_HANDLE, ACE_Reactor_Mask) {
+  ACE_TRACE("ReadHandler::handle_close(ACE_HANDLE, ACE_Reactor_Mask)");
+
+    delete this;
+    return 0;
+}
+
diff --git a/ACE/examples/Reactor/TP_Reactor/ReadHandler.h b/ACE/examples/Reactor/TP_Reactor/ReadHandler.h
new file mode 100644
index 00000000000..41d58b6008a
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/ReadHandler.h
@@ -0,0 +1,92 @@
+/*
+ * ACE reactor demonstration
+ *
+ * $Id$
+ * Date: 26-Jan-2006
+ */
+
+#ifndef __READHANDLER_H__
+#define __READHANDLER_H__
+
+#include <ace/Event_Handler.h>
+#include <ace/SOCK_Stream.h>
+
+/**
+ * This read handler is created by the accept handler and handles all the data
+ * exchange between client and server. The client makes two requests to the
+ * server. The first asks the server to create a buffer which will hold the
+ * data sent in the second call.
+ */
+class ReadHandler : public ACE_Event_Handler {
+
+    private:
+
+        /**
+         * The stream socket used for data exchange.
+         */
+        ACE_SOCK_Stream mStream;
+
+        /**
+         * The size of the data array.
+         */
+        int mDataSize;
+
+        /**
+         * The array containing the client's data.
+         */
+        char *mData;
+
+        /**
+         * The call counter to distinguish between first and second call.
+         */
+        int mCallCounter;
+
+        /**
+         * Count the numer of invocations of handle_*(). According to the
+         * docs, there should be only one invocation at any given time.
+         */
+        int mInvocationCounter;
+
+    public:
+
+        /**
+         * Initialization.
+         */
+        ReadHandler(void);
+
+        /**
+         * Clean up data.
+         */
+        virtual ~ReadHandler();
+
+        /**
+         * Provide access to the internal stream socket.
+         */
+        ACE_SOCK_Stream &getStream(void);
+
+        /**
+         * @name Overridden methods from the ACE_Event_Handler
+         */
+        // @{
+
+        /**
+         * Provides the handle of mStream;
+         */
+        virtual ACE_HANDLE get_handle(void) const;
+
+        /**
+         * Handles the data excahnge between client and server. On the first
+         * invocation, mData is allocated to the requested size and on the
+         * second invocation, that buffer is filled with the client's data.
+         */
+        virtual int handle_input(ACE_HANDLE = ACE_INVALID_HANDLE);
+
+        /**
+         * Deletes this instance of the read handler.
+         */
+        virtual int handle_close(ACE_HANDLE, ACE_Reactor_Mask);
+        // @}
+};
+
+#endif /* __READHANDLER_H__ */
+
diff --git a/ACE/examples/Reactor/TP_Reactor/TP_Reactor.mpc b/ACE/examples/Reactor/TP_Reactor/TP_Reactor.mpc
new file mode 100644
index 00000000000..03d8de2e7aa
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/TP_Reactor.mpc
@@ -0,0 +1,18 @@
+// -*- MPC -*-
+// $Id$
+
+project (*client) : aceexe {
+  exename = client
+  Source_Files {
+    client.cpp
+  }
+}
+
+project (*server) : aceexe {
+  exename = server
+  Source_Files {
+    server.cpp
+    AcceptHandler.cpp
+    ReadHandler.cpp
+  }
+}
diff --git a/ACE/examples/Reactor/TP_Reactor/client.cpp b/ACE/examples/Reactor/TP_Reactor/client.cpp
new file mode 100644
index 00000000000..509f2e9c457
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/client.cpp
@@ -0,0 +1,141 @@
+/*
+ * ACE reactor demonstration
+ *
+ * $Id$
+ * Date: 26-Jan-2006
+ */
+
+#include <ace/Auto_Ptr.h>
+#include <ace/INET_Addr.h>
+#include <ace/Log_Msg.h>
+#include <ace/OS.h>
+#include <ace/SOCK_Acceptor.h>
+#include <ace/SOCK_Connector.h>
+#include <ace/SOCK_Stream.h>
+#include <ace/streams.h>
+
+#include "common.h"
+
+/**
+ * Print usage information for the client.
+ *
+ * @param arg The progams name (argv[0]).
+ */
+int printUsage(ACE_TCHAR *arg) {
+    cerr << "Usage: " << arg << " size [count]" << endl;
+    cerr << "\tSends <size> MiB to the server and optionally repeats that "
+         << "<count> times." << endl;
+    cerr << "\tAll arguments must be positive numbers. If no <count> is "
+         << "given, the\n\tclient runs until interrupted." << endl;
+    return -1;
+}
+
+int ACE_TMAIN(int argc, ACE_TCHAR **argv) {
+
+    // size and count for transmissions
+    int size = 0, count = -1;
+
+    // the server's answer is a single byte
+    char answer;
+
+    // parse the <size> argument
+    if ((argc < 2) || (((size = ACE_OS::strtol(argv[1], 0, 10)) < 1) ||
+            (errno == EINVAL)))
+        return printUsage(argv[0]);
+
+    // take size as the number of MiB and create appropriate buffer
+    size *= BASE;
+    char *someData = new (std::nothrow) char[size];
+
+    if (someData == 0)
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         ACE_TEXT ("%N:%l: Failed to allocate ")
+                         ACE_TEXT ("data buffer.\n")), -1);
+
+    // put someData in an auto_ptr so it gets deleted automatically
+    auto_ptr<char> pSomeData(someData);
+
+    // parse the <count> argument if available
+    if ((argc == 3) && (((count = ACE_OS::strtol(argv[2], 0, 10)) < 1) ||
+            (errno == EINVAL)))
+        return printUsage(argv[0]);
+
+    // the server listens on localhost on default port (from common.h)
+    ACE_INET_Addr serverAddr(PORT, "localhost");
+
+    ACE_SOCK_Stream stream;
+    ACE_SOCK_Connector connector;
+
+    // -1 is running indefinitely
+    while ((count == -1) || (count-- != 0)) {
+
+        // some output, that we know something is happening
+        //ACE_DEBUG((LM_DEBUG, ACE_TEXT("%N:%l: Passes left: %i\n"), count));
+        ACE_DEBUG((LM_DEBUG, ACE_TEXT(".")));
+
+        // connect to the server and get the stream
+        if (connector.connect(stream, serverAddr) == -1) {
+          ACE_ERROR((LM_ERROR,
+                     ACE_TEXT("%N:%l: Failed to connect to ")
+                     ACE_TEXT ("server. (errno = %i: %m)\n"), errno));
+            break;
+        }
+
+        try {
+
+            // send the request to the server (number of MiB in the next call)
+            // Note: only use the sizeof and pointer to int on compatible
+            //       platforms (i.e. little-endian/big-endian, data type size)
+            if (stream.send_n(&size, sizeof(size), &connTimeout) != sizeof(size)) {
+                ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to  send ")
+                           ACE_TEXT ("request. (errno = %i: %m)\n"), errno));
+                throw(1);
+            }
+
+            // receive the answer
+            if (stream.recv_n(&answer, sizeof(answer), &connTimeout) != 1) {
+              ACE_ERROR((LM_ERROR, ACE_TEXT("%N: %l: Failed to receive ")
+                         ACE_TEXT ("1st response. (errno = %i: %m)\n"), errno));
+                throw(1);
+            }
+
+            // server answer, 'K" indicates a positive answer
+            if (answer == 'K') {
+
+                // send a huge message to the server
+                if (stream.send_n(someData, size, &connTimeout) != size) {
+                  ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to send ")
+                             ACE_TEXT ("someData. (errno = %i: %m)\n"), errno));
+                    throw(1);
+                }
+
+                // get an answer
+                if (stream.recv_n(&answer, sizeof(answer), &connTimeout) != 1) {
+                  ACE_ERROR((LM_ERROR, ACE_TEXT("%N: %l: Failed to receive ")
+                             ACE_TEXT ("2nd response. (errno = %i: %m)\n"), errno));
+                    throw(1);
+                }
+
+                // check the answer
+                if (answer != 'K') {
+                    cout << "The server was unable to process the data."
+                         << endl;
+                }
+            }
+        } catch (...) {
+            // ok we know an error occurred, we need to close the socket.
+            // The we'll try again.
+        }
+
+        // close the current stream
+        if (stream.close() == -1) {
+          ACE_ERROR((LM_ERROR, ACE_TEXT("%N:%l: Failed to close ")
+                     ACE_TEXT ("socket. (errno = %i: %m)\n"), errno));
+            break;
+        }
+    } // while
+
+    cout << "Bye. Bye" << endl;
+    return 0;
+}
+
diff --git a/ACE/examples/Reactor/TP_Reactor/common.h b/ACE/examples/Reactor/TP_Reactor/common.h
new file mode 100644
index 00000000000..c9661027923
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/common.h
@@ -0,0 +1,29 @@
+/*
+ * ACE reactor demonstration
+ *
+ * $Id$
+ * Date: 26-Jan-2006
+ */
+
+#ifndef __COMMON_H__
+#define __COMMON_H__
+
+#include <ace/Time_Value.h>
+
+/**
+ * The port number used by client and server.
+ */
+static const int PORT = 4711;
+
+/**
+ * The base size. 0x100000 = 1 MiB
+ */
+static const int BASE = 0x100000;
+
+/**
+ * The timeout value for connections. (30 seconds)
+ */
+static const ACE_Time_Value connTimeout(30);
+
+#endif /* __COMMON_H__ */
+
diff --git a/ACE/examples/Reactor/TP_Reactor/run_test.pl b/ACE/examples/Reactor/TP_Reactor/run_test.pl
new file mode 100644
index 00000000000..ac07295a735
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/run_test.pl
@@ -0,0 +1,41 @@
+eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
+     & eval 'exec perl -S $0 $argv:q'
+     if 0;
+
+# $Id$
+# -*- perl -*-
+
+use lib '../../../bin';
+use PerlACE::Run_Test;
+
+$status = 0;
+
+$SV = new PerlACE::Process ("server", "");
+$CL1 = new PerlACE::Process ("client", "80 100");
+$CL2 = new PerlACE::Process ("client", "80 100");
+$SV->Spawn ();
+
+sleep (1);
+
+$client1 = $CL1->Spawn ();
+
+if ($client1 != 0) {
+    print STDERR "ERROR: client 1 returned $client1\n";
+    $status = 1;
+}
+
+$client2 = $CL2->Spawn ();
+
+if ($client2 != 0) {
+    print STDERR "ERROR: client 2 returned $client2\n";
+    $status = 1;
+}
+
+$server = $SV->WaitKill (1000);
+
+if ($server != 0) {
+    print STDERR "ERROR: server returned $server\n";
+    $status = 1;
+}
+
+exit $status;
diff --git a/ACE/examples/Reactor/TP_Reactor/server.cpp b/ACE/examples/Reactor/TP_Reactor/server.cpp
new file mode 100644
index 00000000000..0c147818424
--- /dev/null
+++ b/ACE/examples/Reactor/TP_Reactor/server.cpp
@@ -0,0 +1,66 @@
+/*
+ * ACE reactor demonstration
+ *
+ * $Id$
+ * Date: 26-Jan-2006
+ */
+
+#include <ace/Event_Handler.h>
+#include <ace/Log_Msg.h>
+#include <ace/OS.h>
+#include <ace/Reactor.h>
+#include <ace/Signal.h>
+#include <ace/streams.h>
+#include <ace/Thread_Manager.h>
+#include <ace/TP_Reactor.h>
+
+#include "AcceptHandler.h"
+
+/**
+ * This is the function run by all threads in the thread pool.
+ *
+ * @param arg is expected to be of type (ACE_Reactor *)
+ */
+ACE_THR_FUNC_RETURN threadFunc(void *arg) {
+    ACE_TRACE("threadFunc(void *)");
+
+    ACE_Reactor *reactor = (ACE_Reactor *) arg;
+    reactor->run_reactor_event_loop();
+
+    return 0;
+}
+
+/**
+ * The main function sets up the TP reactor. The code is basically taken from
+ * the solution to exercise 4c of the ACE course.
+ */
+int ACE_TMAIN(int, ACE_TCHAR **) {
+
+    // create a reactor from a TP reactor
+    ACE_TP_Reactor tpReactor;
+    ACE_Reactor reactor(&tpReactor);
+
+    // create a new accept handler using that reactor
+    AcceptHandler *acceptHandler = 0;
+    ACE_NEW_NORETURN (acceptHandler, AcceptHandler(&reactor));
+    if (acceptHandler == 0)
+      ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to allocate ")
+                        ACE_TEXT ("accept handler. (errno = %i: %m)\n"), errno), -1);
+
+    // open the accept handler
+    if (acceptHandler->open() == -1) {
+        delete acceptHandler;
+        ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("%N:%l: Failed to open accept ")
+                          ACE_TEXT ("handler. Exiting.\n")), -1);
+    }
+
+    // spawn some threads which run the reactor event loop(s)
+    ACE_Thread_Manager::instance()->spawn_n(9, threadFunc, &reactor);
+
+    // let the thread manager wait for all threads
+    ACE_Thread_Manager::instance()->wait();
+
+    ACE_DEBUG((LM_DEBUG, ACE_TEXT("Bye. Bye.\n")));
+    return 0;
+}
+
diff --git a/ACE/examples/Reactor/WFMO_Reactor/APC.cpp b/ACE/examples/Reactor/WFMO_Reactor/APC.cpp
new file mode 100644
index 00000000000..bf42fd1edfa
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/APC.cpp
@@ -0,0 +1,124 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    APC.cpp
+//
+// = DESCRIPTION
+//
+//    Tests the WFMO_Reactor's ability to handle regular APC
+//    notifications.
+//
+// = AUTHOR
+//
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/Auto_Event.h"
+
+ACE_RCSID(WFMO_Reactor, APC, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  int handle_signal (int signum,
+                     siginfo_t * = 0,
+                     ucontext_t * = 0);
+
+  int handle_timeout (const ACE_Time_Value &tv,
+                      const void *arg = 0);
+
+  ACE_Auto_Event handle_;
+  int iterations_;
+};
+
+static Event_Handler *global_event_handler;
+
+static void WINAPI
+apc_callback (DWORD)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) apc occured @ %T\n"));
+
+  global_event_handler->handle_.signal ();
+}
+
+void
+queue_apc (void)
+{
+  DWORD result = ::QueueUserAPC (reinterpret_cast<PAPCFUNC> (&apc_callback),
+                                                         // pointer to APC function
+                                 ::GetCurrentThread (),  // handle to the thread
+                                 0);                     // argument for the APC function
+  if (result == FALSE)
+    ACE_OS::exit (-1);
+}
+
+int
+Event_Handler::handle_signal (int,
+                              siginfo_t *,
+                              ucontext_t *)
+{
+  --this->iterations_;
+
+  if (this->iterations_ == 0)
+    {
+      ACE_Reactor::instance ()->remove_handler (this->handle_.handle (),
+                                                ACE_Event_Handler::DONT_CALL);
+      ACE_Reactor::end_event_loop ();
+    }
+
+  return 0;
+}
+
+int
+Event_Handler::handle_timeout (const ACE_Time_Value &,
+                               const void *)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) timeout occured @ %T\n"));
+  queue_apc ();
+  return 0;
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Event_Handler event_handler;
+  event_handler.iterations_ = 5;
+  global_event_handler = &event_handler;
+
+  int result = ACE_Reactor::instance ()->register_handler (&event_handler,
+                                                           event_handler.handle_.handle ());
+  ACE_ASSERT (result == 0);
+
+  ACE_Time_Value timeout (2);
+  result = ACE_Reactor::instance ()->schedule_timer (&event_handler,
+                                                     0,
+                                                     timeout,
+                                                     timeout);
+  ACE_ASSERT (result != -1);
+
+  ACE_Reactor::run_alertable_event_loop ();
+
+  ACE_Reactor::instance ()->cancel_timer(&event_handler);
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Abandoned.cpp b/ACE/examples/Reactor/WFMO_Reactor/Abandoned.cpp
new file mode 100644
index 00000000000..c860fc2810c
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Abandoned.cpp
@@ -0,0 +1,141 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Abandoned.cpp
+//
+// = DESCRIPTION
+//
+//    Tests the WFMO_Reactor's ability to handle abandoned mutexes.
+//
+// = AUTHOR
+//
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/Thread_Manager.h"
+#include "ace/Process_Mutex.h"
+#include "ace/Auto_Event.h"
+
+ACE_RCSID(WFMO_Reactor, Abandoned, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  int handle_signal (int signum,
+                     siginfo_t * = 0,
+                     ucontext_t * = 0);
+
+  int handle_timeout (const ACE_Time_Value &tv,
+                      const void *arg = 0);
+
+  ACE_Auto_Event handle_;
+  ACE_Process_Mutex *mutex_;
+  int iterations_;
+};
+
+static int abandon = 1;
+
+static ACE_THR_FUNC_RETURN
+worker (void *data)
+{
+  Event_Handler *handler = (Event_Handler *) data;
+
+  handler->handle_.signal ();
+  handler->mutex_->acquire ();
+
+  if (!abandon)
+    handler->mutex_->release ();
+
+  return 0;
+}
+
+int
+Event_Handler::handle_signal (int,
+                              siginfo_t *s,
+                              ucontext_t *)
+{
+  ACE_HANDLE handle = s->si_handle_;
+  if (handle == this->handle_.handle ())
+    ACE_Reactor::instance ()->register_handler (this,
+                                                this->mutex_->lock ().proc_mutex_);
+  else
+    {
+      ACE_Reactor::instance ()->remove_handler (this->mutex_->lock ().proc_mutex_,
+                                                ACE_Event_Handler::DONT_CALL);
+      delete this->mutex_;
+    }
+
+  return 0;
+}
+
+int
+Event_Handler::handle_timeout (const ACE_Time_Value &,
+                               const void *)
+{
+  --this->iterations_;
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) timeout occured @ %T, iterations left %d\n",
+              this->iterations_));
+
+  if (this->iterations_ == 0)
+    {
+      ACE_Reactor::instance ()->remove_handler (this->handle_.handle (),
+                                                ACE_Event_Handler::DONT_CALL);
+
+      ACE_Reactor::instance ()->cancel_timer (this);
+
+      ACE_Reactor::end_event_loop ();
+    }
+  else
+    {
+      ACE_NEW_RETURN (this->mutex_,
+                      ACE_Process_Mutex,
+                      -1);
+      int result = ACE_Thread_Manager::instance ()->spawn (&worker, this);
+      ACE_ASSERT (result != -1);
+      ACE_UNUSED_ARG (result);
+    }
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int , ACE_TCHAR *[])
+{
+  Event_Handler event_handler;
+
+  event_handler.iterations_ = 5;
+  int result = ACE_Reactor::instance ()->register_handler
+    (&event_handler,
+     event_handler.handle_.handle ());
+  ACE_ASSERT (result == 0);
+
+  ACE_Time_Value timeout (2);
+  result = ACE_Reactor::instance ()->schedule_timer (&event_handler,
+                                                     0,
+                                                     timeout,
+                                                     timeout);
+  ACE_ASSERT (result != -1);
+
+  ACE_Reactor::run_event_loop ();
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int , ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Console_Input.cpp b/ACE/examples/Reactor/WFMO_Reactor/Console_Input.cpp
new file mode 100644
index 00000000000..363a6a8ead8
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Console_Input.cpp
@@ -0,0 +1,87 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Console_Input.cpp
+//
+// = DESCRIPTION
+//
+//    This application tests the working of WFMO_Reactor when users
+//    are interested in console input.
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "ace/Reactor.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_NS_string.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(WFMO_Reactor, Console_Input, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  Event_Handler (ACE_Reactor &reactor);
+  int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+  int handle_close (ACE_HANDLE handle,
+                    ACE_Reactor_Mask close_mask);
+};
+
+Event_Handler::Event_Handler (ACE_Reactor &reactor)
+{
+  this->reactor (&reactor);
+
+  if (this->reactor ()->register_handler (this,
+                                          ACE_STDIN) != 0)
+    ACE_ERROR ((LM_ERROR,
+                "Registration with Reactor could not be done\n"));
+}
+
+int
+Event_Handler::handle_signal (int, siginfo_t *, ucontext_t *)
+{
+  ACE_TCHAR buffer[BUFSIZ];
+  int result = ACE_OS::read (ACE_STDIN, buffer, sizeof buffer);
+  buffer[result] = '\0';
+
+  if (result <= 0)
+    {
+      this->reactor ()->close ();
+      ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_OS::read"), -1);
+    }
+
+  if (ACE_OS::strcmp (ACE_TEXT("quit\r\n"), buffer) == 0)
+    this->reactor ()->close ();
+
+  ACE_DEBUG ((LM_DEBUG, "User input: %s", buffer));
+
+  return 0;
+}
+
+int
+Event_Handler::handle_close (ACE_HANDLE,
+                             ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "Event_Handler removed from Reactor\n"));
+  return 0;
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_Reactor reactor;
+  Event_Handler handler (reactor);
+
+  int result = 0;
+  while (result != -1)
+    result = reactor.handle_events ();
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Directory_Changes.cpp b/ACE/examples/Reactor/WFMO_Reactor/Directory_Changes.cpp
new file mode 100644
index 00000000000..7f5126c6cba
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Directory_Changes.cpp
@@ -0,0 +1,128 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Directory_Changes.cpp
+//
+// = DESCRIPTION
+//
+//    This application tests the working of WFMO_Reactor when users
+//    are interested in monitoring changes in the filesystem.
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/OS_NS_unistd.h"
+#include "ace/OS_NS_fcntl.h"
+
+ACE_RCSID(WFMO_Reactor, Directory_Changes, "$Id$")
+
+static int stop_test = 0;
+static const ACE_TCHAR *directory = ACE_TEXT (".");
+static const ACE_TCHAR *temp_file = ACE_TEXT ("foo");
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  Event_Handler (ACE_Reactor &reactor);
+  ~Event_Handler (void);
+  int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+  int handle_close (ACE_HANDLE handle,
+                    ACE_Reactor_Mask close_mask);
+
+private:
+  ACE_HANDLE handle_;
+};
+
+Event_Handler::Event_Handler (ACE_Reactor &reactor)
+  : handle_ (ACE_INVALID_HANDLE)
+{
+  this->reactor (&reactor);
+
+  int change_notification_flags = FILE_NOTIFY_CHANGE_FILE_NAME;
+
+  this->handle_ = ACE_TEXT_FindFirstChangeNotification (directory,  // pointer to name of directory to watch
+                                                        FALSE, // flag for monitoring directory or directory tree
+                                                        change_notification_flags // filter conditions to watch for
+                                                        );
+  if (this->handle_ == ACE_INVALID_HANDLE)
+    ACE_ERROR ((LM_ERROR, "FindFirstChangeNotification could not be setup\n"));
+
+  if (this->reactor ()->register_handler (this,
+                                          this->handle_) != 0)
+    ACE_ERROR ((LM_ERROR, "Registration with Reactor could not be done\n"));
+}
+
+Event_Handler::~Event_Handler (void)
+{
+}
+
+int
+Event_Handler::handle_signal (int, siginfo_t *, ucontext_t *)
+{
+  ::FindNextChangeNotification (this->handle_);
+  if (stop_test)
+    this->reactor ()->close ();
+  return 0;
+}
+
+int
+Event_Handler::handle_close (ACE_HANDLE,
+                             ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "Event_Handler removed from Reactor\n"));
+  ::FindCloseChangeNotification (this->handle_);
+  return 0;
+}
+
+void
+worker (void)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread creation\n"));
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread creating temporary file\n"));
+  ACE_HANDLE file = ACE_OS::open (temp_file, _O_CREAT | _O_EXCL);
+  if (file == ACE_INVALID_HANDLE)
+    ACE_ERROR ((LM_ERROR, "Error in creating %s: %p\n", temp_file, "ACE_OS::open"));
+  else
+    {
+      ACE_OS::close (file);
+      ACE_DEBUG ((LM_DEBUG, "(%t) Thread sleeping\n"));
+      ACE_OS::sleep (3);
+      ACE_DEBUG ((LM_DEBUG, "(%t) Thread removing temporary file\n"));
+      stop_test = 1;
+      ACE_OS::unlink (temp_file);
+    }
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_Reactor reactor;
+  Event_Handler handler (reactor);
+
+  int result = ACE_OS::thr_create ((ACE_THR_FUNC) worker, 0, 0, 0);
+  ACE_ASSERT (result == 0);
+
+  for (result = 0; result != -1; result = reactor.handle_events ())
+    continue;
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Exceptions.cpp b/ACE/examples/Reactor/WFMO_Reactor/Exceptions.cpp
new file mode 100644
index 00000000000..5bbf0b4e4f3
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Exceptions.cpp
@@ -0,0 +1,109 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Exceptions.cpp
+//
+// = DESCRIPTION
+//
+//    This test application tests the state of WFMO_Reactor when
+//    exceptions occurs when executing user callbacks.
+//
+//    The thread count in WFMO_Reactor is used to ensure that state of
+//    WFMO_Reactor is not fouled up when exceptions occur in user code.
+//    This example also shows how to write event loops that survive
+//    user exceptions
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/WFMO_Reactor.h"
+
+ACE_RCSID(WFMO_Reactor, Exceptions, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  Event_Handler (void)
+    : event_ (1)
+  {
+    ACE_DEBUG ((LM_DEBUG,
+                "Event_Handler created\n"));
+  }
+
+  ~Event_Handler (void)
+  {
+    ACE_DEBUG ((LM_DEBUG,
+                "Event_Handler destroyed\n"));
+  }
+
+  int handle_signal (int, siginfo_t * = 0, ucontext_t * = 0)
+  {
+    char *cause_exception = 0;
+    char a = *cause_exception;
+    ACE_UNUSED_ARG(a);
+    return 0;
+  }
+
+  ACE_HANDLE get_handle (void) const
+  {
+    return this->event_.handle ();
+  }
+private:
+  ACE_Manual_Event event_;
+};
+
+class ACE_WFMO_Reactor_Test
+{
+public:
+  static void doit (ACE_WFMO_Reactor &wfmo_reactor)
+  {
+    for (int i = 1; i <= 10; i++)
+      {
+        ACE_DEBUG ((LM_DEBUG,
+                    "Active threads in WFMO_Reactor (before handle_events) = %d\n",
+                    wfmo_reactor.active_threads_));
+        ACE_SEH_TRY
+          {
+            wfmo_reactor.handle_events ();
+          }
+        ACE_SEH_EXCEPT (EXCEPTION_EXECUTE_HANDLER)
+          {
+            ACE_DEBUG ((LM_DEBUG,
+                        "Exception occurred\n"));
+          }
+        ACE_DEBUG ((LM_DEBUG,
+                    "Active threads in WFMO_Reactor (after handle_events) = %d\n",
+                    wfmo_reactor.active_threads_));
+      }
+  }
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Event_Handler handler;
+  ACE_WFMO_Reactor wfmo_reactor;
+  wfmo_reactor.register_handler (&handler);
+
+  ACE_WFMO_Reactor_Test::doit (wfmo_reactor);
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Handle_Close.cpp b/ACE/examples/Reactor/WFMO_Reactor/Handle_Close.cpp
new file mode 100644
index 00000000000..9eb6d7c727a
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Handle_Close.cpp
@@ -0,0 +1,333 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Handle_Close.cpp
+//
+// = DESCRIPTION
+//
+//    This application tests whether handle_close gets called and if
+//    the correct masks are passed along.  The handler should get
+//    handle_close called for all three masks (READ, WRITE, and
+//    EXCEPT).
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/Get_Opt.h"
+#include "ace/Reactor.h"
+#include "ace/WFMO_Reactor.h"
+#include "ace/Select_Reactor.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Pipe.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(WFMO_Reactor, Handle_Close, "$Id: ")
+
+// Use the WFMO_Reactor
+static int opt_wfmo_reactor = 0;
+
+// Use the Select_Reactor
+static int opt_select_reactor = 0;
+
+// Make pipe readable in main()
+static int write_to_pipe_in_main = 0;
+
+// Cancel reads
+static int cancel_reads = 0;
+
+// Write some data to the pipe.  This will cause handle_input to get
+// called.
+void
+write_to_pipe (ACE_Pipe &pipe)
+{
+  char *data = "hello";
+  size_t len = ACE_OS::strlen (data);
+
+  ssize_t result = ACE::send (pipe.write_handle (),
+                              data,
+                              len);
+  ACE_ASSERT ((size_t)result == len);
+  ACE_UNUSED_ARG (result);
+}
+
+// Simple handler class
+class Handler : public ACE_Event_Handler
+{
+public:
+  Handler (ACE_Pipe &pipe)
+    : pipe_ (pipe)
+  {
+  }
+
+  ~Handler (void)
+  {
+    this->reactor (0);
+  }
+
+  ACE_HANDLE get_handle (void) const
+  {
+    return this->pipe_.read_handle ();
+  }
+
+  int handle_close (ACE_HANDLE handle,
+                    ACE_Reactor_Mask close_mask)
+  {
+    ACE_UNUSED_ARG (handle);
+    ACE_DEBUG ((LM_DEBUG,
+                "Handler::handle_close called with mask = %d\n",
+                close_mask));
+    return 0;
+  }
+
+  int handle_input (ACE_HANDLE handle)
+  {
+    ACE_UNUSED_ARG (handle);
+    ACE_DEBUG ((LM_DEBUG, "Handler::handle_input\n"));
+
+    // Remove for reading
+    return -1;
+  }
+
+  int handle_output (ACE_HANDLE handle)
+  {
+    ACE_UNUSED_ARG (handle);
+    ACE_DEBUG ((LM_DEBUG, "Handler::handle_output\n"));
+
+    // Optionally cancel reads
+    if (cancel_reads)
+      {
+        int result = this->reactor ()->cancel_wakeup (this,
+                                                      ACE_Event_Handler::READ_MASK);
+        ACE_ASSERT (result != -1);
+        ACE_UNUSED_ARG (result);
+      }
+
+    // Write to the pipe; this causes handle_input to get called.
+    if (!write_to_pipe_in_main)
+      write_to_pipe (this->pipe_);
+
+    // Remove for writing
+    return -1;
+  }
+
+protected:
+  ACE_Pipe &pipe_;
+};
+
+class Different_Handler : public ACE_Event_Handler
+{
+public:
+
+  Different_Handler (ACE_Pipe &pipe)
+    : pipe_ (pipe)
+  {
+  }
+
+  ~Different_Handler (void)
+  {
+    this->reactor (0);
+  }
+
+  ACE_HANDLE get_handle (void) const
+  {
+    return this->pipe_.read_handle ();
+  }
+
+  int handle_close (ACE_HANDLE handle,
+                    ACE_Reactor_Mask close_mask)
+  {
+    ACE_UNUSED_ARG (handle);
+    ACE_DEBUG ((LM_DEBUG,
+                "Different_Handler::handle_close called with mask = %d\n",
+                close_mask));
+    return 0;
+  }
+
+  int handle_input (ACE_HANDLE handle)
+  {
+    ACE_UNUSED_ARG (handle);
+    ACE_DEBUG ((LM_DEBUG, "Different_Handler::handle_input\n"));
+
+    // Remove for reading
+    int result = this->reactor ()->remove_handler (this,
+                                                   ACE_Event_Handler::READ_MASK);
+    ACE_ASSERT (result == 0);
+    ACE_UNUSED_ARG (result);
+
+    return 0;
+  }
+
+  int handle_output (ACE_HANDLE handle)
+  {
+    ACE_UNUSED_ARG (handle);
+    ACE_DEBUG ((LM_DEBUG, "Different_Handler::handle_output\n"));
+
+    // Add for reading
+    int result = this->reactor ()->mask_ops (this,
+                                             ACE_Event_Handler::READ_MASK,
+                                             ACE_Reactor::ADD_MASK);
+    ACE_ASSERT (result != -1);
+
+    ACE_Reactor_Mask old_masks =
+      ACE_Event_Handler::WRITE_MASK |
+      ACE_Event_Handler::EXCEPT_MASK;
+
+    ACE_ASSERT (old_masks ==
+                static_cast<ACE_Reactor_Mask> (result));
+    ACE_UNUSED_ARG (old_masks);
+
+    // Get new masks
+    result = this->reactor ()->mask_ops (this,
+                                         ACE_Event_Handler::NULL_MASK,
+                                         ACE_Reactor::GET_MASK);
+    ACE_ASSERT (result != -1);
+
+    ACE_Reactor_Mask current_masks =
+      ACE_Event_Handler::READ_MASK |
+      ACE_Event_Handler::WRITE_MASK |
+      ACE_Event_Handler::EXCEPT_MASK;
+
+    ACE_ASSERT (current_masks ==
+                static_cast<ACE_Reactor_Mask> (result));
+    ACE_UNUSED_ARG (current_masks);
+
+    // Remove for writing
+    ACE_Reactor_Mask mask = ACE_Event_Handler::WRITE_MASK | ACE_Event_Handler::DONT_CALL;
+    result = this->reactor ()->remove_handler (this,
+                                               mask);
+    ACE_ASSERT (result == 0);
+
+    // Write to the pipe; this causes handle_input to get called.
+    if (!write_to_pipe_in_main)
+      write_to_pipe (this->pipe_);
+
+    return 0;
+  }
+
+protected:
+  ACE_Pipe &pipe_;
+};
+
+
+//
+// Selection of which reactor should get created
+//
+ACE_Reactor *
+create_reactor (void)
+{
+  ACE_Reactor_Impl *impl = 0;
+
+  if (opt_wfmo_reactor)
+    {
+#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
+      ACE_NEW_RETURN (impl,
+                      ACE_WFMO_Reactor,
+                      0);
+#endif /* ACE_WIN32 */
+    }
+  else if (opt_select_reactor)
+    {
+      ACE_NEW_RETURN (impl,
+                      ACE_Select_Reactor,
+                      0);
+    }
+  else
+    {
+      ACE_Reactor *singleton_reactor =
+        ACE_Reactor::instance ();
+      ACE_Reactor::instance (0);
+      return singleton_reactor;
+    }
+
+  ACE_Reactor *reactor = 0;
+  ACE_NEW_RETURN (reactor,
+                  ACE_Reactor (impl,
+                               1),
+                  0);
+
+  return reactor;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  int result = 0;
+
+  // Parse args
+  ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("swmc"), 1);
+  for (int c; (c = getopt ()) != -1; )
+    switch (c)
+      {
+      case 's':
+        opt_select_reactor = 1;
+        break;
+      case 'w':
+        opt_wfmo_reactor = 1;
+        break;
+      case 'm':
+        write_to_pipe_in_main = 1;
+        break;
+      case 'c':
+        cancel_reads = 1;
+        break;
+      }
+
+  // Create pipes
+  ACE_Pipe pipe1, pipe2;
+
+  result = pipe1.open ();
+  ACE_ASSERT (result == 0);
+
+  result = pipe2.open ();
+  ACE_ASSERT (result == 0);
+
+  // Create handlers
+  Handler handler (pipe1);
+  Different_Handler different_handler (pipe2);
+
+  // Manage memory automagically.
+  auto_ptr<ACE_Reactor> reactor (create_reactor ());
+
+  // Register handlers
+  ACE_Reactor_Mask handler_mask =
+    ACE_Event_Handler::READ_MASK |
+    ACE_Event_Handler::WRITE_MASK |
+    ACE_Event_Handler::EXCEPT_MASK;
+
+  ACE_Reactor_Mask different_handler_mask =
+    ACE_Event_Handler::WRITE_MASK |
+    ACE_Event_Handler::EXCEPT_MASK;
+
+  result = reactor->register_handler (&handler,
+                                      handler_mask);
+  ACE_ASSERT (result == 0);
+
+  result = reactor->register_handler (&different_handler,
+                                      different_handler_mask);
+  ACE_ASSERT (result == 0);
+
+  // Write to the pipe; this causes handle_input to get called.
+  if (write_to_pipe_in_main)
+    {
+      write_to_pipe (pipe1);
+      write_to_pipe (pipe2);
+    }
+
+  // Note that handle_output will get called automatically since the
+  // pipe is writable!
+
+  // Run for three seconds
+  ACE_Time_Value time (3);
+  reactor->run_reactor_event_loop (time);
+
+  ACE_DEBUG ((LM_DEBUG, "\nClosing down the application\n\n"));
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Makefile.am b/ACE/examples/Reactor/WFMO_Reactor/Makefile.am
new file mode 100644
index 00000000000..cfa1c687b6c
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Makefile.am
@@ -0,0 +1,308 @@
+##  Process this file with automake to create Makefile.in
+##
+## $Id$
+##
+## This file was generated by MPC.  Any changes made directly to
+## this file will be lost the next time it is generated.
+##
+## MPC Command:
+## /acebuilds/ACE_wrappers-repository/bin/mwc.pl -include /acebuilds/MPC/config -include /acebuilds/MPC/templates -feature_file /acebuilds/ACE_wrappers-repository/local.features -noreldefs -type automake -exclude build,Kokyu
+
+ACE_BUILDDIR = $(top_builddir)
+ACE_ROOT = $(top_srcdir)
+
+noinst_PROGRAMS =
+
+## Makefile.WFMO_Reactor_APC.am
+
+if BUILD_WFMO
+if !BUILD_WINCE
+noinst_PROGRAMS += apc
+
+apc_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+apc_SOURCES = \
+  APC.cpp
+
+apc_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_WINCE
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Abandoned.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += abandoned
+
+abandoned_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+abandoned_SOURCES = \
+  Abandoned.cpp
+
+abandoned_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Console_Input.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += console_input
+
+console_input_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+console_input_SOURCES = \
+  Console_Input.cpp
+
+console_input_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Directory_Changes.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += directory_changes
+
+directory_changes_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+directory_changes_SOURCES = \
+  Directory_Changes.cpp
+
+directory_changes_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Exceptions.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += exceptions
+
+exceptions_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+exceptions_SOURCES = \
+  Exceptions.cpp
+
+exceptions_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Handle_Close.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += handle_close
+
+handle_close_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+handle_close_SOURCES = \
+  Handle_Close.cpp
+
+handle_close_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Multithreading.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += multithreading
+
+multithreading_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+multithreading_SOURCES = \
+  Multithreading.cpp
+
+multithreading_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Network_Events.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += network_events
+
+network_events_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+network_events_SOURCES = \
+  Network_Events.cpp
+
+network_events_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Prerun_State_Changes.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += prerun_state_changes
+
+prerun_state_changes_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+prerun_state_changes_SOURCES = \
+  Prerun_State_Changes.cpp
+
+prerun_state_changes_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Registration.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += registration
+
+registration_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+registration_SOURCES = \
+  Registration.cpp
+
+registration_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Registry_Changes.am
+
+if BUILD_WFMO
+if !BUILD_ACE_FOR_TAO
+if !BUILD_WINCE
+noinst_PROGRAMS += registry_changes
+
+registry_changes_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+registry_changes_SOURCES = \
+  Registry_Changes.cpp
+
+registry_changes_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_WINCE
+endif !BUILD_ACE_FOR_TAO
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Removals.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += removals
+
+removals_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+removals_SOURCES = \
+  Removals.cpp
+
+removals_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Suspended_Removals.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += suspended_removals
+
+suspended_removals_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+suspended_removals_SOURCES = \
+  Suspended_Removals.cpp
+
+suspended_removals_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Talker.am
+
+if BUILD_WFMO
+if !BUILD_ACE_FOR_TAO
+if !BUILD_WINCE
+noinst_PROGRAMS += talker
+
+talker_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+talker_SOURCES = \
+  Talker.cpp
+
+talker_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_WINCE
+endif !BUILD_ACE_FOR_TAO
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Timeouts.am
+
+if BUILD_WFMO
+noinst_PROGRAMS += timeouts
+
+timeouts_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+timeouts_SOURCES = \
+  Timeouts.cpp
+
+timeouts_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif BUILD_WFMO
+
+## Makefile.WFMO_Reactor_Window_Messages.am
+
+if BUILD_WFMO
+if !BUILD_ACE_FOR_TAO
+if !BUILD_WINCE
+noinst_PROGRAMS += window_messages
+
+window_messages_CPPFLAGS = \
+  -I$(ACE_ROOT) \
+  -I$(ACE_BUILDDIR)
+
+window_messages_SOURCES = \
+  Window_Messages.cpp
+
+window_messages_LDADD = \
+  $(ACE_BUILDDIR)/ace/libACE.la
+
+endif !BUILD_WINCE
+endif !BUILD_ACE_FOR_TAO
+endif BUILD_WFMO
+
+## Clean up template repositories, etc.
+clean-local:
+	-rm -f *~ *.bak *.rpo *.sym lib*.*_pure_* core core.*
+	-rm -f gcctemp.c gcctemp so_locations *.ics
+	-rm -rf cxx_repository ptrepository ti_files
+	-rm -rf templateregistry ir.out
+	-rm -rf ptrepository SunWS_cache Templates.DB
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Multithreading.cpp b/ACE/examples/Reactor/WFMO_Reactor/Multithreading.cpp
new file mode 100644
index 00000000000..0778f375251
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Multithreading.cpp
@@ -0,0 +1,262 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Multithreading.cpp
+//
+// = DESCRIPTION
+//
+//    This application tests multiple threads simultaneously calling
+//    Reactor::handle_events(). It also shows how different threads
+//    can update the state of Reactor by registering and removing
+//    Event_Handlers.
+//
+//    Note that this test will only work with WFMO_Reactor
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Task.h"
+#include "ace/Reactor.h"
+#include "ace/WFMO_Reactor.h"
+#include "ace/Get_Opt.h"
+#include "ace/OS_NS_time.h"
+
+ACE_RCSID(WFMO_Reactor, Multithreading, "$Id$")
+
+static int concurrent_threads = 1;
+static int number_of_handles = static_cast<int> (ACE_Reactor::instance ()->size ());
+static int number_of_handles_to_signal = 1;
+static int interval = 2;
+static int iterations = 10;
+
+// Explain usage and exit.
+static void
+print_usage_and_die (void)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              "usage: \n\t"
+              "[-t (# of threads - default 1)] \n\t"
+              "[-h (# of handlers) - default 62] \n\t"
+              "[-i (# time interval between signals) - default 2] \n\t"
+              "[-s (# of handles to signal) - default 1] \n\t"
+              "[-e (# of iterations) - default 10] \n\t"));
+  ACE_OS::exit (1);
+}
+
+// Parse the command-line arguments and set options.
+static void
+parse_args (int argc, ACE_TCHAR **argv)
+{
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("t:h:s:i:e:"));
+  int c;
+
+  while ((c = get_opt ()) != -1)
+    switch (c)
+      {
+      case 't':
+        concurrent_threads = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 'e':
+        iterations = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 'h':
+        number_of_handles = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 'i':
+        interval = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      case 's':
+        number_of_handles_to_signal = ACE_OS::atoi (get_opt.opt_arg ());
+        break;
+      default:
+        print_usage_and_die ();
+        break;
+      }
+}
+
+class Task_Handler : public ACE_Task<ACE_NULL_SYNCH>
+{
+public:
+  Task_Handler (size_t number_of_handles,
+                size_t concurrent_threads);
+  // Constructor.
+
+  ~Task_Handler (void);
+  // Destructor.
+
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+  // Called when object is removed from the ACE_Reactor
+
+  int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+  // Handle events being signaled by the main thread.
+
+  virtual int handle_timeout (const ACE_Time_Value &tv,
+                              const void *arg = 0);
+  // Called when timer expires.
+
+  int svc (void);
+  // Task event loop.
+
+  int signal (size_t index);
+  // Signal an event.
+
+private:
+  ACE_Auto_Event *events_;
+};
+
+// All threads do reactor->handle_events ()
+int
+Task_Handler::svc (void)
+{
+  // Try to become the owner
+  ACE_Reactor::instance ()->owner (ACE_Thread::self ());
+  // Run the event loop.
+  return ACE_Reactor::run_event_loop ();
+}
+
+Task_Handler::Task_Handler (size_t number_of_handles,
+                            size_t concurrent_threads)
+{
+  ACE_NEW (this->events_, ACE_Auto_Event [number_of_handles]);
+
+  for (size_t i = 0; i < number_of_handles; ++i)
+    if (ACE_Reactor::instance ()->register_handler (this,
+                                                    this->events_[i].handle ()) == -1)
+      ACE_ERROR ((LM_ERROR,
+                  "%p\t cannot register handle %d with Reactor\n",
+                  "Task_Handler::Task_Handler",
+                  i));
+
+  // Make us an active object.
+  if (this->activate (THR_NEW_LWP,
+                      static_cast<int> (concurrent_threads)) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\t cannot activate task\n",
+                "activate"));
+}
+
+Task_Handler::~Task_Handler (void)
+{
+  this->reactor (0);
+  delete [] this->events_;
+}
+
+
+int
+Task_Handler::handle_signal (int, siginfo_t *siginfo, ucontext_t *)
+{
+  // When signaled, print message, remove self, and add self
+  // This will force Reactor to update its internal handle tables
+
+  ACE_DEBUG ((LM_DEBUG,
+              "(%t) calls handle_signal for handle %d\n",
+              siginfo->si_handle_));
+
+  if (ACE_Reactor::instance ()->remove_handler (siginfo->si_handle_,
+                                                ACE_Event_Handler::DONT_CALL) == -1)
+    return -1;
+  // ACE_ERROR_RETURN ((LM_ERROR,
+  //                   "(%t) %p\tTask cannot be unregistered from Reactor: handle value = %d\n",
+  //                   "Task_Handler::handle_signal",
+  //                   siginfo->si_handle_), -1);
+
+  if (ACE_Reactor::instance ()->register_handler (this,
+                                                  siginfo->si_handle_) == -1)
+    return -1;
+  // ACE_ERROR_RETURN ((LM_ERROR,
+  //                   "(%t) %p\tTask cannot be registered with Reactor: handle value = %d\n",
+  //                   "Task_Handler::handle_signal",
+  //                   siginfo->si_handle_), -1);
+  return 0;
+}
+
+int
+Task_Handler::handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) handle_close() called: handle value = %d\n",
+              handle));
+  return 0;
+}
+
+int
+Task_Handler::handle_timeout (const ACE_Time_Value &,
+                              const void *arg)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) handle_timeout() called: iteration value = %d\n",
+              size_t (arg)));
+  return 0;
+}
+
+int
+Task_Handler::signal (size_t index)
+{
+  return this->events_[index].signal ();
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR **argv)
+{
+  parse_args (argc, argv);
+  Task_Handler task (number_of_handles,
+                     concurrent_threads);
+
+  ACE_OS::srand (ACE_OS::time (0L));
+
+  for (int i = 1; i <= iterations; i++)
+    {
+      // Sleep for a while
+      ACE_OS::sleep (interval);
+
+      // Randomly generate events
+      ACE_DEBUG ((LM_DEBUG, "********************************************************\n"));
+      ACE_DEBUG ((LM_DEBUG, "(%t -- main thread) signaling %d events : iteration = %d\n",
+                  number_of_handles_to_signal,
+                  i));
+      ACE_DEBUG ((LM_DEBUG, "********************************************************\n"));
+
+      // Setup a timer for the task
+      if (ACE_Reactor::instance ()->schedule_timer (&task,
+                                                    (void *)((size_t)i),
+                                                    ACE_Time_Value::zero) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "schedule_timer"), -1);
+
+      for (int i = 0; i < number_of_handles_to_signal; i++)
+        // Randomly select a handle to signal.
+        task.signal (ACE_OS::rand() % number_of_handles);
+    }
+
+  // Sleep for a while
+  ACE_OS::sleep (interval);
+
+  // End the Reactor event loop
+  ACE_Reactor::end_event_loop ();
+
+  // Wait for all threads to exit
+  ACE_Thread_Manager::instance ()->wait ();
+
+  // Close the Reactor singleton before exiting this function.
+  // If we wait for the Object Manager to do this, it will be too
+  // late since Task_Handler instance would have disappeared.
+  ACE_Reactor::close_singleton ();
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int, ACE_TCHAR **)
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Network_Events.cpp b/ACE/examples/Reactor/WFMO_Reactor/Network_Events.cpp
new file mode 100644
index 00000000000..9935679a60f
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Network_Events.cpp
@@ -0,0 +1,211 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Network_Events.cpp
+//
+// = DESCRIPTION
+//
+//    This application tests Reactor to make sure that it responds
+//    correctly to different kinds of network events.
+//
+//    The test starts off by creating a Network_Listener, that listens
+//    for connections at ACE_DEFAULT_SERVER_PORT. When a client
+//    connects, a Network_Handler is created. Network_Handler reads
+//    messages off the socket and prints them out. This is done until
+//    the remote side shuts down. Multiple clients can connect at the
+//    same time.
+//
+//    Events tested in this example includes ACCEPT, READ, and CLOSE masks.
+//
+//    To run this example, start an instance of this example and
+//    connect to it using telnet (to port
+//    ACE_DEFAULT_SERVER_PORT(20002)).
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/Reactor.h"
+#include "ace/WFMO_Reactor.h"
+#include "ace/INET_Addr.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(WFMO_Reactor, Network_Events, "$Id$")
+
+class Network_Handler : public ACE_Event_Handler
+{
+public:
+  Network_Handler (ACE_SOCK_Stream &s);
+  // Default constructor
+
+  virtual int handle_input (ACE_HANDLE handle);
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+  virtual ACE_HANDLE  get_handle (void) const;
+
+  ACE_SOCK_Stream stream_;
+
+};
+
+Network_Handler::Network_Handler (ACE_SOCK_Stream &s)
+  : stream_ (s)
+{
+  this->reactor (ACE_Reactor::instance ());
+
+  int result = this->reactor ()->register_handler (this, READ_MASK);
+  ACE_ASSERT (result == 0);
+  ACE_UNUSED_ARG (result);
+}
+
+ACE_HANDLE
+Network_Handler::get_handle (void) const
+{
+  return this->stream_.get_handle ();
+}
+
+int
+Network_Handler::handle_input (ACE_HANDLE handle)
+{
+  ACE_DEBUG ((LM_DEBUG, "Network_Handler::handle_input handle = %d\n", handle));
+
+  while (1)
+    {
+      char message[BUFSIZ];
+      int result = this->stream_.recv (message, sizeof message);
+      if (result > 0)
+        {
+          message[result] = 0;
+          ACE_DEBUG ((LM_DEBUG, "Remote message: %s\n", message));
+        }
+      else if (result == 0)
+        {
+          ACE_DEBUG ((LM_DEBUG, "Connection closed\n"));
+          return -1;
+        }
+      else if (errno == EWOULDBLOCK)
+        {
+          return 0;
+        }
+      else
+        {
+          ACE_DEBUG ((LM_DEBUG, "Problems in receiving data, result = %d", result));
+          return -1;
+        }
+    }
+}
+
+int
+Network_Handler::handle_close (ACE_HANDLE handle,
+                               ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "Network_Handler::handle_close handle = %d\n", handle));
+
+  this->stream_.close ();
+  delete this;
+
+  ACE_Reactor::end_event_loop ();
+
+  return 0;
+}
+
+class Network_Listener : public ACE_Event_Handler
+{
+public:
+  Network_Listener (void);
+  // Default constructor
+  ~Network_Listener (void);
+  // Default constructor
+
+  virtual int handle_input (ACE_HANDLE handle);
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+  ACE_HANDLE get_handle (void) const;
+
+  ACE_INET_Addr local_address_;
+  ACE_SOCK_Acceptor acceptor_;
+};
+
+Network_Listener::Network_Listener (void)
+  : local_address_ (ACE_DEFAULT_SERVER_PORT),
+    acceptor_ (local_address_, 1)
+{
+  this->reactor (ACE_Reactor::instance ());
+  int result = this->reactor ()->register_handler (this,
+                                                   ACE_Event_Handler::ACCEPT_MASK);
+  ACE_ASSERT (result == 0);
+  ACE_UNUSED_ARG (result);
+}
+
+Network_Listener::~Network_Listener (void)
+{
+}
+
+ACE_HANDLE
+Network_Listener::get_handle (void) const
+{
+  return this->acceptor_.get_handle ();
+}
+
+int
+Network_Listener::handle_input (ACE_HANDLE handle)
+{
+  ACE_DEBUG ((LM_DEBUG, "Network_Listener::handle_input handle = %d\n", handle));
+
+  ACE_INET_Addr remote_address;
+  ACE_SOCK_Stream stream;
+
+  // Try to find out if the implementation of the reactor that we are
+  // using requires us to reset the event association for the newly
+  // created handle. This is because the newly created handle will
+  // inherit the properties of the listen handle, including its event
+  // associations.
+  int reset_new_handle = this->reactor ()->uses_event_associations ();
+
+  int result = this->acceptor_.accept (stream, // stream
+                                       &remote_address, // remote address
+                                       0, // timeout
+                                       1, // restart
+                                       reset_new_handle);  // reset new handler
+  ACE_ASSERT (result == 0);
+  ACE_UNUSED_ARG (result);
+
+  ACE_DEBUG ((LM_DEBUG, "Remote connection from: "));
+  remote_address.dump ();
+
+  Network_Handler *handler;
+  ACE_NEW_RETURN (handler, Network_Handler (stream), -1);
+
+  return 0;
+}
+
+int
+Network_Listener::handle_close (ACE_HANDLE handle,
+                                ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "Network_Listener::handle_close handle = %d\n", handle));
+
+  this->acceptor_.close ();
+
+  delete this;
+
+  return 0;
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Network_Listener *listener = 0;
+  listener = new Network_Listener;
+
+  ACE_Reactor::run_event_loop ();
+
+  return 0;
+};
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Prerun_State_Changes.cpp b/ACE/examples/Reactor/WFMO_Reactor/Prerun_State_Changes.cpp
new file mode 100644
index 00000000000..e276fd7d3f8
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Prerun_State_Changes.cpp
@@ -0,0 +1,66 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Prerun_State_Changes.cpp
+//
+// = DESCRIPTION
+//
+//    Tests the Reactor's ability to handle state changes before
+//    getting a chance to run.
+//
+// = AUTHOR
+//
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/Reactor.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(WFMO_Reactor, Prerun_State_Changes, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+// = TITLE
+//    Generic Event Handler.
+//
+{
+public:
+  virtual int handle_close (ACE_HANDLE handle, ACE_Reactor_Mask mask)
+    {
+      ACE_UNUSED_ARG(mask);
+      ACE_DEBUG ((LM_DEBUG,
+                  "event handler %d closed.\n",
+                  (size_t) handle));
+      delete this;
+      return 0;
+    }
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_HANDLE handle = (ACE_HANDLE) ::socket (PF_INET, SOCK_STREAM, 0);
+
+  Event_Handler *event_handler = new Event_Handler;
+
+  int result = ACE_Reactor::instance ()->register_handler (handle,
+                                                           event_handler,
+                                                           ACE_Event_Handler::READ_MASK);
+  ACE_ASSERT (result == 0);
+
+  result = ACE_Reactor::instance ()->register_handler (handle,
+                                                       event_handler,
+                                                       ACE_Event_Handler::WRITE_MASK | ACE_Event_Handler::QOS_MASK);
+  ACE_ASSERT (result == 0);
+
+  result = ACE_Reactor::instance ()->remove_handler (handle,
+                                                     ACE_Event_Handler::READ_MASK | ACE_Event_Handler::DONT_CALL);
+  ACE_ASSERT (result == 0);
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Registration.cpp b/ACE/examples/Reactor/WFMO_Reactor/Registration.cpp
new file mode 100644
index 00000000000..a9429bdd433
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Registration.cpp
@@ -0,0 +1,169 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Registration.cpp
+//
+// = DESCRIPTION
+//
+//    This test application tests a wide range of registration,
+//    suspension, resumption, and removal of events from Reactor.
+//
+//    The application initially registers two events with Reactor. A
+//    auxiliary thread is created to do the signaling on the
+//    events. When the first event is signaled, the event is suspended
+//    from Reactor. The event is then signaled again, but is "lost"
+//    since the handler has been suspended. When the second event is
+//    signal, the first event is resumed and the second is
+//    suspended. When the first event is signaled again, both events
+//    are removed from Reactor.
+//
+//    This test shows off the following features of Reactor:
+//    - Registration
+//    - Suspension
+//    - Resumption
+//    - Removal (while active and while suspended)
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/Auto_Event.h"
+#include "ace/OS_NS_unistd.h"
+
+ACE_RCSID(WFMO_Reactor, Registration, "$Id$")
+
+// Globals for this test
+int stop_test = 0;
+ACE_Reactor reactor;
+
+
+class Simple_Handler : public ACE_Event_Handler
+{
+public:
+  Simple_Handler (void);
+  // Default constructor
+
+  virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+  virtual int handle_close (ACE_HANDLE handle,
+                            ACE_Reactor_Mask close_mask);
+
+  ACE_Auto_Event event1_;
+  ACE_Auto_Event event2_;
+  int handle_signal_count_;
+  int handle_close_count_;
+};
+
+Simple_Handler::Simple_Handler (void)
+  : handle_signal_count_ (0),
+    handle_close_count_ (0)
+{
+}
+
+int
+Simple_Handler::handle_signal (int, siginfo_t *s, ucontext_t *)
+{
+  ACE_HANDLE handle = s->si_handle_;
+  ACE_UNUSED_ARG (handle);
+
+  this->handle_signal_count_++;
+
+  if (this->handle_signal_count_ == 1)
+    this->reactor ()->suspend_handler (event1_.handle ());
+  else if (this->handle_signal_count_ == 2)
+    {
+      this->reactor ()->resume_handler (event1_.handle ());
+      this->reactor ()->suspend_handler (event2_.handle ());
+    }
+  else if (this->handle_signal_count_ == 3)
+    {
+      this->reactor ()->remove_handler (event1_.handle (),
+                                        ACE_Event_Handler::NULL_MASK);
+      this->reactor ()->remove_handler (event2_.handle (),
+                                        ACE_Event_Handler::NULL_MASK);
+    }
+  return 0;
+}
+
+int
+Simple_Handler::handle_close (ACE_HANDLE handle,
+                              ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "Simple_Handler::handle_close handle = %d\n", handle));
+  this->handle_close_count_++;
+
+  if (this->handle_close_count_ == 1)
+    stop_test = 0;
+  else if (this->handle_close_count_ == 2)
+    stop_test = 1;
+
+  return 0;
+}
+
+// Globals for this test
+Simple_Handler simple_handler;
+
+void
+worker (void)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread creation\n"));
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread sleeping\n"));
+  ACE_OS::sleep (1);
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread signaling %d\n", simple_handler.event1_.handle()));
+  simple_handler.event1_.signal ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread sleeping\n"));
+  ACE_OS::sleep (1);
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread signaling %d\n", simple_handler.event1_.handle()));
+  ACE_DEBUG ((LM_DEBUG, "Note: This signal should be \"lost\" because of the suspended handler\n"));
+  simple_handler.event1_.signal ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread sleeping\n"));
+  ACE_OS::sleep (1);
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread resetting %d\n", simple_handler.event1_.handle()));
+  simple_handler.event1_.reset ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread signaling %d\n", simple_handler.event2_.handle()));
+  simple_handler.event2_.signal ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread sleeping\n"));
+  ACE_OS::sleep (1);
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread signaling %d\n", simple_handler.event1_.handle()));
+  simple_handler.event1_.signal ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread death\n"));
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  int result = reactor.register_handler (&simple_handler,
+                                       simple_handler.event1_.handle ());
+  ACE_ASSERT (result == 0);
+
+  result = reactor.register_handler (&simple_handler,
+                                     simple_handler.event2_.handle ());
+  ACE_ASSERT (result == 0);
+
+  result = ACE_OS::thr_create ((ACE_THR_FUNC) worker, 0, 0, 0);
+  ACE_ASSERT (result == 0);
+
+  result = 0;
+  while (!stop_test && result != -1)
+    {
+      result = reactor.handle_events ();
+    }
+  return 0;
+};
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int, ACE_TCHAR **)
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Registry_Changes.cpp b/ACE/examples/Reactor/WFMO_Reactor/Registry_Changes.cpp
new file mode 100644
index 00000000000..be787293e65
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Registry_Changes.cpp
@@ -0,0 +1,146 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Registry_Changes.cpp
+//
+// = DESCRIPTION
+//
+//    This application tests the working of Reactor when users are
+//    interested in monitoring changes in the registry.
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/Registry.h"
+#include "ace/Auto_Event.h"
+#include "ace/OS_NS_unistd.h"
+
+ACE_RCSID(WFMO_Reactor, Registry_Changes, "$Id$")
+
+static int stop_test = 0;
+static HKEY context_to_monitor = HKEY_CURRENT_USER;
+static const ACE_TCHAR *temp_context_name = ACE_TEXT ("ACE temporary context");
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  Event_Handler (ACE_Reactor &reactor);
+  ~Event_Handler (void);
+  int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+  int handle_close (ACE_HANDLE handle,
+                    ACE_Reactor_Mask close_mask);
+  ACE_Registry::Naming_Context &context (void);
+
+private:
+  ACE_Auto_Event event_;
+  ACE_Registry::Naming_Context context_;
+};
+
+Event_Handler::Event_Handler (ACE_Reactor &reactor)
+  : context_ (context_to_monitor)
+{
+  this->reactor (&reactor);
+
+  if (::RegNotifyChangeKeyValue (this->context_.key (), // handle of key to watch
+                                 FALSE, // flag for subkey notification
+                                 REG_NOTIFY_CHANGE_NAME, // changes to be reported
+                                 this->event_.handle (), // handle of signaled event
+                                 TRUE // flag for asynchronous reporting
+                                 ) != ERROR_SUCCESS)
+    ACE_ERROR ((LM_ERROR, "RegNotifyChangeKeyValue could not be setup\n"));
+
+  if (this->reactor ()->register_handler (this,
+                                          this->event_.handle ()) != 0)
+    ACE_ERROR ((LM_ERROR, "Registration with Reactor could not be done\n"));
+}
+
+Event_Handler::~Event_Handler (void)
+{
+}
+
+int
+Event_Handler::handle_signal (int, siginfo_t *, ucontext_t *)
+{
+  if (stop_test)
+    this->reactor ()->close ();
+  else if (::RegNotifyChangeKeyValue (this->context_.key (), // handle of key to watch
+                                      FALSE, // flag for subkey notification
+                                      REG_NOTIFY_CHANGE_NAME, // changes to be reported
+                                      this->event_.handle (), // handle of signaled event
+                                      TRUE // flag for asynchronous reporting
+                                      ) != ERROR_SUCCESS)
+    ACE_ERROR ((LM_ERROR,
+                "RegNotifyChangeKeyValue could not be setup\n"));
+  return 0;
+}
+
+int
+Event_Handler::handle_close (ACE_HANDLE,
+                             ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "Event_Handler removed from Reactor\n"));
+  return 0;
+}
+
+ACE_Registry::Naming_Context &
+Event_Handler::context (void)
+{
+  return this->context_;
+}
+
+void
+worker (Event_Handler *event_handler)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread creation\n"));
+  ACE_DEBUG ((LM_DEBUG, "(%t) Thread creating temporary registry entry\n"));
+
+  ACE_Registry::Naming_Context temp_context;
+  int result = event_handler->context ().bind_new_context (temp_context_name,
+                                                           temp_context);
+
+  if (result == -1)
+    ACE_ERROR ((LM_ERROR, "Error in creating %s: %p\n", temp_context_name, "bind_new_context"));
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG, "(%t) Thread sleeping\n"));
+      ACE_OS::sleep (3);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t) Thread removing registry entry\n"));
+      stop_test = 1;
+      event_handler->context ().unbind_context (temp_context_name);
+    }
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  ACE_Reactor reactor;
+  Event_Handler handler (reactor);
+
+  int result = ACE_OS::thr_create ((ACE_THR_FUNC) worker, &handler, 0, 0);
+  ACE_ASSERT (result == 0);
+
+  for (result = 0; result != -1; result = reactor.handle_events ())
+    continue;
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int, ACE_TCHAR **)
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Removals.cpp b/ACE/examples/Reactor/WFMO_Reactor/Removals.cpp
new file mode 100644
index 00000000000..260b9e897ee
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Removals.cpp
@@ -0,0 +1,114 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Removals.cpp
+//
+// = DESCRIPTION
+//
+//    Tests the Reactor's ability to handle simultaneous events.  If
+//    you pass anything on the command-line, then each handler
+//    requests to be removed from the Reactor after each event.
+//
+// = AUTHOR
+//    Tim Harrison
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/Service_Config.h"
+#include "ace/Event.h"
+
+ACE_RCSID(WFMO_Reactor, Removals, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+// = TITLE
+//    Generic Event Handler.
+//
+// = DESCRIPTION
+//
+//    Creates event.  Registers with Reactor.  Signals event.  If
+//    created with -close_down- it returns -1 from handle signal.
+{
+public:
+  Event_Handler (int event_number,
+                 int close_down)
+    : event_number_ (event_number),
+    close_down_ (close_down)
+    {
+      if (ACE_Reactor::instance ()->register_handler (this,
+                                                      this->event_.handle ()) == -1)
+        ACE_ERROR ((LM_ERROR, "%p\tevent handler %d cannot be added to Reactor\n", "", event_number_));
+      this->event_.signal ();
+    }
+
+  virtual int handle_signal (int, siginfo_t *, ucontext_t *)
+    {
+      if (this->close_down_)
+        return -1;
+      else
+        return 0;
+    }
+
+  virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask)
+    {
+      ACE_DEBUG ((LM_DEBUG, "event handler %d closed.\n", event_number_));
+      delete this;
+      return 0;
+    }
+
+  virtual ACE_HANDLE get_handle (void) const
+    {
+      return event_.handle ();
+    }
+
+private:
+  int event_number_;
+  // Our event number.
+
+  int close_down_;
+  // Shall we close down or not.
+
+  ACE_Event event_;
+  // Signaled to shut down the handler.
+};
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *[])
+{
+  int close_down = argc > 1 ? 1 : 0;
+
+  for (size_t i = 1; i <= ACE_Reactor::instance ()->size (); i++)
+    new Event_Handler (static_cast<int> (i), close_down);
+
+  int result = 0;
+  ACE_Time_Value time (1);
+  while (1)
+    {
+      result = ACE_Reactor::instance ()->handle_events (time);
+      if (result == 0 && errno == ETIME)
+        {
+          ACE_DEBUG ((LM_DEBUG, "No more work left: timing out\n"));
+          break;
+        }
+      if (result == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "main"), -1);
+    }
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int , ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Suspended_Removals.cpp b/ACE/examples/Reactor/WFMO_Reactor/Suspended_Removals.cpp
new file mode 100644
index 00000000000..ead467146a5
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Suspended_Removals.cpp
@@ -0,0 +1,173 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Suspended_Removals.cpp
+//
+// = DESCRIPTION
+//
+//    Tests the Reactor's ability to handle removal of suspended
+//    handles.
+//
+// = AUTHOR
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/WFMO_Reactor.h"
+
+ACE_RCSID(WFMO_Reactor, Suspended_Removals, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+
+  ACE_HANDLE get_handle (void) const
+  {
+    return this->event_.handle ();
+  }
+
+  ACE_Event event_;
+};
+
+class ACE_WFMO_Reactor_Test
+{
+public:
+  static void check_for_valid_state (ACE_WFMO_Reactor &wfmo_reactor,
+                                     size_t handles_to_be_added,
+                                     size_t handles_to_be_suspended,
+                                     size_t handles_to_be_resumed,
+                                     size_t handles_to_be_deleted)
+  {
+    ACE_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_added_ == handles_to_be_added);
+    ACE_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_suspended_ == handles_to_be_suspended);
+    ACE_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_resumed_ == handles_to_be_resumed);
+    ACE_ASSERT (wfmo_reactor.handler_rep_.handles_to_be_deleted_ == handles_to_be_deleted);
+  }
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Event_Handler handler;
+  ACE_WFMO_Reactor reactor;
+  ACE_Reactor base_reactor (&reactor);
+  ACE_Time_Value time (1);
+
+  int result =
+    reactor.register_handler (&handler);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                1, 0, 0, 0);
+
+  result =
+    reactor.remove_handler (&handler,
+                            ACE_Event_Handler::DONT_CALL |
+                            ACE_Event_Handler::ALL_EVENTS_MASK);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                1, 0, 0, 1);
+
+  result = base_reactor.run_reactor_event_loop (time);
+  ACE_ASSERT (result != -1);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 0);
+
+  result =
+    reactor.register_handler (&handler);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                1, 0, 0, 0);
+
+  result = base_reactor.run_reactor_event_loop (time);
+  ACE_ASSERT (result != -1);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 0);
+
+  result =
+    reactor.suspend_handler (&handler);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 1, 0, 0);
+
+  result =
+    reactor.remove_handler (&handler,
+                            ACE_Event_Handler::DONT_CALL |
+                            ACE_Event_Handler::ALL_EVENTS_MASK);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 1);
+
+  result = base_reactor.run_reactor_event_loop (time);
+  ACE_ASSERT (result != -1);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 0);
+
+  result =
+    reactor.register_handler (&handler);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                1, 0, 0, 0);
+
+  result =
+    reactor.suspend_handler (&handler);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                1, 1, 0, 0);
+
+  result = base_reactor.run_reactor_event_loop (time);
+  ACE_ASSERT (result != -1);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 0);
+
+  result =
+    reactor.resume_handler (&handler);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 1, 0);
+
+  result =
+    reactor.remove_handler (&handler,
+                            ACE_Event_Handler::DONT_CALL |
+                            ACE_Event_Handler::ALL_EVENTS_MASK);
+  ACE_ASSERT (result == 0);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 1);
+
+  result = base_reactor.run_reactor_event_loop (time);
+  ACE_ASSERT (result != -1);
+
+  ACE_WFMO_Reactor_Test::check_for_valid_state (reactor,
+                                                0, 0, 0, 0);
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int , ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Talker.cpp b/ACE/examples/Reactor/WFMO_Reactor/Talker.cpp
new file mode 100644
index 00000000000..32438088614
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Talker.cpp
@@ -0,0 +1,594 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Talker.cpp
+//
+// = DESCRIPTION
+//
+//    This test application tests a wide range of events that can be
+//    demultiplexed using various ACE utilities.  Events used include
+//    ^C events, reading from STDIN, vanilla Win32 events, thread
+//    exits, Reactor notifications, proactive reads, and proactive
+//    writes.
+//
+//    The proactive I/O events are demultiplexed by the ACE_Proactor.
+//    The thread exits, notications, and vanilla Win32 events are
+//    demultiplexed by the ACE_Reactor.  To enable a single thread
+//    to run all these events, the Proactor is integrated with the
+//    Reactor.
+//
+//    The test application prototypes a simple talk program.  Two
+//    instances of the application connect.  Input from either console
+//    is displayed on the others console also.  Because of the evils
+//    of Win32 STDIN, a separate thread is used to read from STDIN.
+//    To test the Proactor and Reactor, I/O between the remote
+//    processes is performed proactively and interactions between the
+//    STDIN thread and the main thread are performed reactively.
+//
+//    The following description of the test application is in two
+//    parts.  The participants section explains the main components
+//    involved in the application.  The collaboration section
+//    describes how the partipants interact in response to the
+//    multiple event types which occur.
+//
+//    The Reactor test application has the following participants:
+//
+//    . Reactor -- The Reactor demultiplexes Win32 "waitable"
+//    events using WaitForMultipleObjects.
+//
+//    . Proactor -- The proactor initiates and demultiplexes
+//    overlapped I/O operations.  The Proactor registers with the
+//    Reactor so that a single-thread can demultiplex all
+//    application events.
+//
+//    . STDIN_Handler -- STDIN_Handler is an Active Object which reads
+//    from STDIN and forwards the input to the Peer_Handler.  This
+//    runs in a separate thread to make the test more interesting.
+//    However, STDIN is "waitable", so in general it can be waited on
+//    by the ACE Reactor, thanks MicroSlush!
+//
+//    . Peer_Handler -- The Peer_Handler connects to another instance
+//    of test_reactor.  It Proactively reads and writes data to the
+//    peer.  When the STDIN_Handler gives it messages, it fowards them
+//    to the remote peer.  When it receives messages from the remote
+//    peer, it prints the output to the console.
+//
+//    The collaborations of the participants are as follows:
+//
+//    . Initialization
+//
+//      Peer_Handler -- connects to the remote peer.  It then begins
+//      proactively reading from the remote connection.  Note that it
+//      will be notified by the Proactor when a read completes.  It
+//      also registers a notification strategy with message queue so
+//      that it is notified when the STDIN_Handler posts a message
+//      onto the queue.
+//
+//      STDIN_Handler -- STDIN_Handler registers a signal handler for
+//      SIGINT.  This just captures the exception so that the kernel
+//      doesn't kill our process; We want to exit gracefully.  It also
+//      creates an Exit_Hook object which registers the
+//      STDIN_Handler's thread handle with the Reactor.  The
+//      Exit_Hook will get called back when the STDIN_Handler thread
+//      exits.  After registering these, it blocks reading from STDIN.
+//
+//      Proactor -- is registered with the Reactor.
+//
+//      The main thread of control waits in the Reactor.
+//
+//    . STDIN events -- When the STDIN_Handler thread reads from
+//    STDIN, it puts the message on Peer_Handler's message queue.  It
+//    then returns to reading from STDIN.
+//
+//    . Message enqueue -- The Reactor thread wakes up and calls
+//    Peer_Handler::handle_output.  The Peer_Handler then tries to
+//    dequeue a message from its message queue.  If it can, the
+//    message is Proactively sent to the remote peer.  Note that the
+//    Peer_Handler will be notified with this operation is complete.
+//    The Peer_Handler then falls back into the Reactor event loop.
+//
+//    . Send complete event -- When a proactive send is complete, the
+//    Proactor is notified by the Reactor.  The Proactor, in turn,
+//    notifies the Peer_Handler.  The Peer_Handler then checks for
+//    more messages from the message queue.  If there are any, it
+//    tries to send them.  If there are not, it returns to the
+//    Reactor event loop.
+//
+//    . Read complete event -- When a proactive read is complete (the
+//    Peer_Handler initiated a proactive read when it connected to the
+//    remote peer), the Proactor is notified by the Reactor.  The
+//    Proactor, in turn notifies the Peer_Handler.  If the read was
+//    successful the Peer_Handler just displays the received msg to
+//    the console and reinvokes a proactive read from the network
+//    connection.  If the read failed (i.e. the remote peer exited),
+//    the Peer_Handler sets a flag to end the event loop and returns.
+//    This will cause the application to exit.
+//
+//    . ^C events -- When the user types ^C at the console, the
+//    STDIN_Handler's signal handler will be called.  It does nothing,
+//    but as a result of the signal, the STDIN_Handler thread will
+//    exit.
+//
+//    . STDIN_Handler thread exits -- The Exit_Hook will get called
+//    back from the Reactor.  Exit_Hook::handle_signal sets a flag
+//    to end the event loop and returns.  This will cause the
+//    application to exit.
+//
+//
+//    To run example, start an instance of the test with an optional
+//    local port argument (as the acceptor). Start the other instance
+//    with -h <hostname> and -p <server port>. Type in either the
+//    client or server windows and your message should show up in the
+//    other window.  Control C to exit.
+//
+// = AUTHOR
+//    Tim Harrison
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Reactor.h"
+#include "ace/Reactor_Notification_Strategy.h"
+#include "ace/WIN32_Proactor.h"
+#include "ace/Proactor.h"
+#include "ace/SOCK_Connector.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/Get_Opt.h"
+#include "ace/Service_Config.h"
+#include "ace/Task.h"
+#include "ace/OS_NS_unistd.h"
+
+ACE_RCSID(WFMO_Reactor, Talker, "$Id$")
+
+typedef ACE_Task<ACE_MT_SYNCH> MT_TASK;
+
+class Peer_Handler : public MT_TASK, public ACE_Handler
+// = TITLE
+//     Connect to a server.  Receive messages from STDIN_Handler
+//     and forward them to the server using proactive I/O.
+{
+public:
+  // = Initialization methods.
+  Peer_Handler (int argc, ACE_TCHAR *argv[]);
+  ~Peer_Handler (void);
+
+  int open (void * =0);
+  // This method creates the network connection to the remote peer.
+  // It does blocking connects and accepts depending on whether a
+  // hostname was specified from the command line.
+
+  virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
+  // This method will be called when an asynchronous read completes on a stream.
+  // The remote peer has sent us something.  If it succeeded, print
+  // out the message and reinitiate a read.  Otherwise, fail.  In both
+  // cases, delete the message sent.
+
+  virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
+  // This method will be called when an asynchronous write completes on a strea_m.
+  // One of our asynchronous writes to the remote peer has completed.
+  // Make sure it succeeded and then delete the message.
+
+  virtual ACE_HANDLE handle (void) const;
+  // Get the I/O handle used by this <handler>. This method will be
+  // called by the ACE_Asynch_* classes when an ACE_INVALID_HANDLE is
+  // passed to <open>.
+
+  void handle (ACE_HANDLE);
+  // Set the ACE_HANDLE value for this Handler.
+
+  virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask);
+  // We've been removed from the Reactor.
+
+  virtual int handle_output (ACE_HANDLE fd);
+  // Called when output events should start.  Note that this is
+  // automatically invoked by the
+  // <ACE_Reactor_Notificiation_Strategy>.
+
+private:
+  ACE_SOCK_Stream stream_;
+  // Socket that we have connected to the server.
+
+  ACE_Reactor_Notification_Strategy strategy_;
+  // The strategy object that the reactor uses to notify us when
+  // something is added to the queue.
+
+  // = Remote peer info.
+  ACE_TCHAR *host_;
+  // Name of remote host.
+
+  u_short port_;
+  // Port number for remote host.
+
+  ACE_Asynch_Read_Stream rd_stream_;
+  // Read stream
+
+  ACE_Asynch_Write_Stream wr_stream_;
+  // Write stream
+
+  ACE_Message_Block mb_;
+  // Message Block for reading from the network
+};
+
+class STDIN_Handler : public ACE_Task<ACE_NULL_SYNCH>
+// = TITLE
+//    Active Object.  Reads from STDIN and passes message blocks to
+//    the peer handler.
+{
+public:
+  STDIN_Handler (MT_TASK &ph);
+  // Initialization.
+
+  virtual int open (void * = 0);
+  // Activate object.
+
+  virtual int close (u_long = 0);
+  // Shut down.
+
+  int svc (void);
+  // Thread runs here as an active object.
+
+  int handle_close (ACE_HANDLE,
+                    ACE_Reactor_Mask);
+
+private:
+  static void handler (int signum);
+  // Handle a ^C.  (Do nothing, this just illustrates how we can catch
+  // signals along with the other things).
+
+  void register_thread_exit_hook (void);
+  // Helper function to register with the Reactor for thread exit.
+
+  virtual int handle_signal (int index, siginfo_t *, ucontext_t *);
+  // The STDIN thread has exited.  This means the user hit ^C.  We can
+  // end the event loop.
+
+  MT_TASK &ph_;
+  // Send all input to ph_.
+
+  ACE_HANDLE thr_handle_;
+  // Handle of our thread.
+};
+
+Peer_Handler::Peer_Handler (int argc, ACE_TCHAR *argv[])
+  : strategy_ (ACE_Reactor::instance (),
+               this,
+               ACE_Event_Handler::WRITE_MASK),
+    host_ (0),
+    port_ (ACE_DEFAULT_SERVER_PORT),
+    mb_ (BUFSIZ)
+{
+  // This code sets up the message to notify us when a new message is
+  // added to the queue.  Actually, the queue notifies Reactor which
+  // then notifies us.
+  this->msg_queue ()->notification_strategy (&this->strategy_);
+
+  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("h:p:"));
+  int c;
+
+  while ((c = get_opt ()) != EOF)
+    {
+      switch (c)
+        {
+        case 'h':
+          host_ = get_opt.opt_arg ();
+          break;
+        case 'p':
+          port_ = ACE_OS::atoi (get_opt.opt_arg ());
+          break;
+        }
+    }
+}
+
+Peer_Handler::~Peer_Handler (void)
+{
+}
+
+// This method creates the network connection to the remote peer.  It
+// does blocking connects and accepts depending on whether a hostname
+// was specified from the command line.
+
+int
+Peer_Handler::open (void *)
+{
+  if (host_ != 0) // Connector
+    {
+      ACE_INET_Addr addr (port_, host_);
+      ACE_SOCK_Connector connector;
+
+      // Establish connection with server.
+      if (connector.connect (stream_, addr) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "connect"), -1);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t) connected.\n"));
+    }
+  else // Acceptor
+    {
+      ACE_SOCK_Acceptor acceptor;
+      ACE_INET_Addr local_addr (port_);
+
+      if ((acceptor.open (local_addr) == -1) ||
+          (acceptor.accept (this->stream_) == -1))
+        ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "accept failed"), -1);
+
+      ACE_DEBUG ((LM_DEBUG, "(%t) accepted.\n"));
+    }
+
+  int result = this->rd_stream_.open (*this);
+  if (result != 0)
+    return result;
+
+  result = this->wr_stream_.open (*this);
+  if (result != 0)
+    return result;
+
+  result = this->rd_stream_.read (this->mb_,
+                                  this->mb_.size ());
+  return result;
+}
+
+// One of our asynchronous writes to the remote peer has completed.
+// Make sure it succeeded and then delete the message.
+
+void
+Peer_Handler::handle_write_stream (const ACE_Asynch_Write_Stream::Result &result)
+{
+  if (result.bytes_transferred () <= 0)
+    ACE_DEBUG ((LM_DEBUG, "(%t) %p bytes = %d\n", "Message failed",
+                result.bytes_transferred ()));
+
+  // This was allocated by the STDIN_Handler, queued, dequeued, passed
+  // to the proactor, and now passed back to us.
+  result.message_block ().release ();
+}
+
+// The remote peer has sent us something.  If it succeeded, print
+// out the message and reinitiate a read.  Otherwise, fail.  In both
+// cases, delete the message sent.
+
+
+void
+Peer_Handler::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
+{
+  if (result.bytes_transferred () > 0 &&
+      this->mb_.length () > 0)
+    {
+      this->mb_.rd_ptr ()[result.bytes_transferred ()] = '\0';
+      // Print out the message received from the server.
+      ACE_DEBUG ((LM_DEBUG, "%s", this->mb_.rd_ptr ()));
+    }
+  else
+    {
+      // If a read failed, we will assume it's because the remote peer
+      // went away.  We will end the event loop.  Since we're in the
+      // main thread, we don't need to do a notify.
+      ACE_Reactor::end_event_loop();
+      return;
+    }
+
+  // Reset pointers
+  this->mb_.wr_ptr (this->mb_.wr_ptr () - result.bytes_transferred ());
+
+  // Start off another read
+  if (this->rd_stream_.read (this->mb_,
+                             this->mb_.size ()) == -1)
+    ACE_ERROR ((LM_ERROR, "%p Read initiate.\n", "Peer_Handler"));
+}
+
+// This is so the Proactor can get our handle.
+ACE_HANDLE
+Peer_Handler::handle (void) const
+{
+  return this->stream_.get_handle ();
+}
+
+void
+Peer_Handler::handle (ACE_HANDLE handle)
+{
+  this->stream_.set_handle (handle);
+}
+
+// We've been removed from the Reactor.
+int
+Peer_Handler::handle_close (ACE_HANDLE, ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) Peer_Handler closing down\n"));
+  return 0;
+}
+
+// New stuff added to the message queue.  Try to dequeue a message.
+int
+Peer_Handler::handle_output (ACE_HANDLE)
+{
+  ACE_Message_Block *mb;
+
+  ACE_Time_Value tv (ACE_Time_Value::zero);
+
+  // Forward the message to the remote peer receiver.
+  if (this->getq (mb, &tv) != -1)
+    {
+      if (this->wr_stream_.write (*mb,
+                                  mb->length ()) == -1)
+        ACE_ERROR_RETURN ((LM_ERROR, "%p Write initiate.\n", "Peer_Handler"), -1);
+    }
+  return 0;
+}
+
+void
+STDIN_Handler::handler (int signum)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) signal = %S\n", signum));
+}
+
+STDIN_Handler::STDIN_Handler (MT_TASK &ph)
+  : ph_ (ph)
+{
+  // Register for ^C from the console.  We just need to catch the
+  // exception so that the kernel doesn't kill our process.
+  // Registering this signal handler just tells the kernel that we
+  // know what we're doing; to leave us alone.
+
+  ACE_OS::signal (SIGINT, (ACE_SignalHandler) STDIN_Handler::handler);
+};
+
+// Activate object.
+
+int
+STDIN_Handler::open (void *)
+{
+  if (this->activate (THR_NEW_LWP | THR_DETACHED) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);
+
+  return 0;
+}
+
+// Shut down.
+
+int
+STDIN_Handler::close (u_long)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) thread is exiting.\n"));
+  return 0;
+}
+
+// Thread runs here.
+
+int
+STDIN_Handler::svc (void)
+{
+  this->register_thread_exit_hook ();
+
+  for (;;)
+    {
+      ACE_Message_Block *mb = new ACE_Message_Block (BUFSIZ);
+
+      // Read from stdin into mb.
+      int read_result = ACE_OS::read (ACE_STDIN,
+                                      mb->rd_ptr (),
+                                      mb->size ());
+
+      // If read succeeds, put mb to peer handler, else end the loop.
+      if (read_result > 0)
+        {
+          mb->wr_ptr (read_result);
+          // Note that this call will first enqueue mb onto the peer
+          // handler's message queue, which will then turn around and
+          // notify the Reactor via the Notification_Strategy.  This
+          // will subsequently signal the Peer_Handler, which will
+          // react by calling back to its handle_output() method,
+          // which dequeues the message and sends it to the peer
+          // across the network.
+          this->ph_.putq (mb);
+        }
+      else
+        {
+          mb->release ();
+          break;
+        }
+    }
+
+  // handle_signal will get called on the main proactor thread since
+  // we just exited and the main thread is waiting on our thread exit.
+  return 0;
+}
+
+// Register an exit hook with the reactor.
+
+void
+STDIN_Handler::register_thread_exit_hook (void)
+{
+  // Get a real handle to our thread.
+  ACE_Thread_Manager::instance ()->thr_self (this->thr_handle_);
+
+  // Register ourselves to get called back when our thread exits.
+
+  if (ACE_Reactor::instance ()->
+      register_handler (this, this->thr_handle_) == -1)
+    ACE_ERROR ((LM_ERROR, "Exit_Hook Register failed.\n"));
+}
+
+// The STDIN thread has exited.  This means the user hit ^C.  We can
+// end the event loop and delete ourself.
+
+int
+STDIN_Handler::handle_signal (int, siginfo_t *si, ucontext_t *)
+{
+  if (si != 0)
+    {
+      ACE_ASSERT (this->thr_handle_ == si->si_handle_);
+      ACE_Reactor::end_event_loop ();
+    }
+  return 0;
+}
+
+int
+STDIN_Handler::handle_close (ACE_HANDLE,
+                             ACE_Reactor_Mask)
+{
+  delete this;
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  // Let the proactor know that it will be used with Reactor
+  // Create specific proactor
+  ACE_WIN32_Proactor win32_proactor (0, 1);
+  // Get the interface proactor
+  ACE_Proactor proactor (&win32_proactor);
+  // Put it as the instance.
+  ACE_Proactor::instance (&proactor);
+
+  // Open handler for remote peer communications this will run from
+  // the main thread.
+  Peer_Handler peer_handler (argc, argv);
+
+  if (peer_handler.open () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p open failed, errno = %d.\n",
+                       "peer_handler", errno), 0);
+
+  // Open active object for reading from stdin.
+  STDIN_Handler *stdin_handler =
+    new STDIN_Handler (peer_handler);
+
+  // Spawn thread.
+  if (stdin_handler->open () == -1)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       "%p open failed, errno = %d.\n",
+                       "stdin_handler", errno), 0);
+
+  // Register proactor with Reactor so that we can demultiplex
+  // "waitable" events and I/O operations from a single thread.
+  if (ACE_Reactor::instance ()->register_handler
+      (ACE_Proactor::instance ()->implementation ()) != 0)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p failed to register Proactor.\n",
+                       argv[0]), -1);
+
+  // Run main event demultiplexor.
+  ACE_Reactor::run_event_loop ();
+
+  // Remove proactor with Reactor.
+  if (ACE_Reactor::instance ()->remove_handler
+      (ACE_Proactor::instance ()->implementation (), ACE_Event_Handler::DONT_CALL) != 0)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p failed to register Proactor.\n",
+                       argv[0]), -1);
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int , ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Timeouts.cpp b/ACE/examples/Reactor/WFMO_Reactor/Timeouts.cpp
new file mode 100644
index 00000000000..8cc37a940bc
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Timeouts.cpp
@@ -0,0 +1,83 @@
+// $Id$
+//
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Timeouts.cpp
+//
+// = DESCRIPTION
+//
+//    This example application shows how to write Reactor event
+//    loops that handle events for some fixed amount of time.
+//
+//    Run this example (without arguments) to see the timers
+//    expire. The order should be:
+//
+//    foo, bar, foo, bar, foo, foo, bar, foo, bar, foo
+//
+// = AUTHOR
+//    Tim Harrison
+//    Irfan Pyarali
+//
+// ============================================================================
+
+#include "ace/Reactor.h"
+#include "ace/Service_Config.h"
+#include "ace/OS_main.h"
+
+ACE_RCSID(WFMO_Reactor, Timeouts, "$Id$")
+
+class Timeout_Handler : public ACE_Event_Handler
+// = TITLE
+//     Generic timeout handler.
+{
+public:
+  Timeout_Handler (void)
+    : count_ (0) {}
+
+  virtual int handle_timeout (const ACE_Time_Value &tv,
+                              const void *arg)
+    // Print out when timeouts occur.
+    {
+      ACE_UNUSED_ARG(tv);
+      ACE_DEBUG ((LM_DEBUG,
+                  "%d timeout occurred for %s.\n",
+                  ++count_,
+                  (char *) arg));
+      return 0;
+    }
+
+private:
+  int count_;
+};
+
+int
+ACE_TMAIN (int, ACE_TCHAR *[])
+{
+  Timeout_Handler handler;
+
+  // Register a 3 second timer.
+  ACE_Time_Value bar_tv (3);
+  ACE_Reactor::instance ()->schedule_timer (&handler,
+                                            (void *) "Bar",
+                                            bar_tv,
+                                            bar_tv);
+
+  // Register a 2 second timer.
+  ACE_Time_Value foo_tv (2);
+  ACE_Reactor::instance ()->schedule_timer (&handler,
+                                            (void *) "Foo",
+                                            foo_tv,
+                                            foo_tv);
+  // Handle events for 12 seconds.
+  ACE_Time_Value run_time (12);
+  if (ACE_Reactor::run_event_loop(run_time) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "main"), -1);
+
+  ACE_Reactor::instance ()->cancel_timer(&handler);
+
+  return 0;
+}
diff --git a/ACE/examples/Reactor/WFMO_Reactor/WFMO_Reactor.mpc b/ACE/examples/Reactor/WFMO_Reactor/WFMO_Reactor.mpc
new file mode 100644
index 00000000000..eec632ee696
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/WFMO_Reactor.mpc
@@ -0,0 +1,118 @@
+// -*- MPC -*-
+// $Id$
+
+project(*Abandoned): aceexe, wfmo {
+  exename = abandoned
+  Source_Files {
+    Abandoned.cpp
+  }
+}
+
+project(*APC): aceexe, wfmo {
+  avoids += wince
+  exename = apc
+  Source_Files {
+    APC.cpp
+  }
+}
+
+project(*Console_Input): aceexe, wfmo {
+  exename = console_input
+  Source_Files {
+    Console_Input.cpp
+  }
+}
+
+project(*Directory_Changes): aceexe, wfmo {
+  exename = directory_changes
+  Source_Files {
+    Directory_Changes.cpp
+  }
+}
+
+project(*Exceptions): aceexe, wfmo {
+  exename = exceptions
+  Source_Files {
+    Exceptions.cpp
+  }
+}
+
+project(*Handle_Close): aceexe, wfmo {
+  exename = handle_close
+  Source_Files {
+    Handle_Close.cpp
+  }
+}
+
+project(*Multithreading): aceexe, wfmo {
+  exename = multithreading
+  Source_Files {
+    Multithreading.cpp
+  }
+}
+
+project(*Network_Events): aceexe, wfmo {
+  exename = network_events
+  Source_Files {
+    Network_Events.cpp
+  }
+}
+
+project(*Prerun_State_Changes): aceexe, wfmo {
+  exename = prerun_state_changes
+  Source_Files {
+    Prerun_State_Changes.cpp
+  }
+}
+
+project(*Registration): aceexe, wfmo {
+  exename = registration
+  Source_Files {
+    Registration.cpp
+  }
+}
+
+project(*Registry_Changes): aceexe, wfmo {
+  avoids += ace_for_tao wince
+  exename = registry_changes
+  Source_Files {
+    Registry_Changes.cpp
+  }
+}
+
+project(*Removals): aceexe, wfmo {
+  exename = removals
+  Source_Files {
+    Removals.cpp
+  }
+}
+
+project(*Suspended_Removals): aceexe, wfmo {
+  exename = suspended_removals
+  Source_Files {
+    Suspended_Removals.cpp
+  }
+}
+
+project(*Talker): aceexe, wfmo {
+  avoids += ace_for_tao wince
+  exename = talker
+  Source_Files {
+    Talker.cpp
+  }
+}
+
+project(*Timeouts): aceexe, wfmo {
+  exename = timeouts
+  Source_Files {
+    Timeouts.cpp
+  }
+}
+
+project(*Window_Messages): aceexe, wfmo {
+  avoids += ace_for_tao wince
+  exename = window_messages
+  Source_Files {
+    Window_Messages.cpp
+  }
+}
diff --git a/ACE/examples/Reactor/WFMO_Reactor/Window_Messages.cpp b/ACE/examples/Reactor/WFMO_Reactor/Window_Messages.cpp
new file mode 100644
index 00000000000..f5a1994168c
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/Window_Messages.cpp
@@ -0,0 +1,100 @@
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    examples
+//
+// = FILENAME
+//    Window_Messages.cpp
+//
+// = DESCRIPTION
+//
+//    Tests the Msg_WFMO_Reactor's ability to handle regular events
+//    and window messages.
+//
+// = AUTHOR
+//
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ============================================================================
+
+#include "ace/OS_main.h"
+
+#if defined (ACE_WIN32)
+
+#include "ace/Msg_WFMO_Reactor.h"
+#include "ace/Reactor.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Auto_Event.h"
+
+ACE_RCSID(WFMO_Reactor, Window_Messages, "$Id$")
+
+class Event_Handler : public ACE_Event_Handler
+{
+public:
+  int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+
+  ACE_Auto_Event handle_;
+  int iterations_;
+};
+
+int
+Event_Handler::handle_signal (int, siginfo_t *, ucontext_t *)
+{
+  --this->iterations_;
+
+  if (this->iterations_ == 0)
+    ACE_Reactor::end_event_loop ();
+
+  return 0;
+}
+
+static Event_Handler *global_event_handler;
+
+void WINAPI
+timer_callback (HWND,
+                UINT,
+                UINT,
+                DWORD dwTime)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) timeout occured @ %u\n", dwTime));
+
+  global_event_handler->handle_.signal ();
+}
+
+int
+ACE_TMAIN (int, ACE_TCHAR*[])
+{
+  // Manage memory automagically.
+  ACE_Reactor_Impl *impl = new ACE_Msg_WFMO_Reactor;
+  auto_ptr<ACE_Reactor> reactor (new ACE_Reactor (impl, 1));
+  ACE_Reactor::instance (reactor.get ());
+
+  Event_Handler event_handler;
+  global_event_handler = &event_handler;
+
+  event_handler.iterations_ = 5;
+  int result = ACE_Reactor::instance ()->register_handler (&event_handler,
+                                                           event_handler.handle_.handle ());
+  ACE_ASSERT (result == 0);
+
+  ACE_Time_Value timeout (1);
+  result = ::SetTimer (NULL,                         // handle of window for timer messages
+                       0,                            // timer identifier
+                       timeout.msec (),              // time-out value
+                       (TIMERPROC) &timer_callback   // address of timer procedure
+                       );
+  ACE_ASSERT (result != 0);
+
+  ACE_Reactor::run_event_loop ();
+
+  return 0;
+}
+#else /* !ACE_WIN32 */
+int
+ACE_TMAIN (int , ACE_TCHAR *[])
+{
+  return 0;
+}
+#endif /* ACE_WIN32 */
diff --git a/ACE/examples/Reactor/WFMO_Reactor/run_test.pl b/ACE/examples/Reactor/WFMO_Reactor/run_test.pl
new file mode 100755
index 00000000000..cc445c64043
--- /dev/null
+++ b/ACE/examples/Reactor/WFMO_Reactor/run_test.pl
@@ -0,0 +1,68 @@
+eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
+    & eval 'exec perl -S $0 $argv:q'
+    if 0;
+
+# $Id$
+# -*- perl -*-
+
+use lib '../../../bin';
+use PerlACE::Run_Test;
+
+#
+# These tests only run on Win32
+#
+if ($^O ne "MSWin32") 
+{
+    exit;
+}
+
+$test_timeout = 60;
+
+@tests = 
+    (
+     "Abandoned",
+     "APC",
+#    "Console_Input",            # This test is interactive
+     "Directory_Changes",
+     "Exceptions",
+     "Handle_Close",
+     "Multithreading",
+#    "Network_Events",           # This test is interactive
+     "Prerun_State_Changes",
+     "Registration",
+     "Registry_Changes",
+     "Removals",
+     "Suspended_Removals",
+#    "Talker",                   # This test is interactive
+     "Timeouts",
+     "Window_Messages",
+     );
+
+for $test (@tests)
+{
+    print STDOUT "\n________________________________________\n";
+    print STDOUT "\nStarting test \"$test\"";
+    print STDOUT "\n________________________________________\n\n";
+    
+    $test_process = new PerlACE::Process ($test);
+
+    if (! -x $test_process->Executable ()) {
+        print STDERR "Error: " . $test_process->Executable () .
+                     " does not exist or is not runnable\n";
+    }
+    else
+    {
+       $test_process->Spawn ();
+       $test_result = $test_process->WaitKill ($test_timeout);
+        
+       if ($test_result != 0) 
+       {
+           print STDERR "\n________________________________________\n";
+           print STDERR "\nERROR: \"$test\" returned $test_result";
+           print STDERR "\n________________________________________\n";
+       }
+    }
+    print STDOUT "\n________________________________________\n";
+    print STDOUT "\n\"$test\" completed";
+    print STDOUT "\n________________________________________\n";
+}