*** empty log message ***

4 files changed, 172 insertions, 179 deletions

diff --git a/netsvcs/lib/Client_Logging_Handler.cpp b/netsvcs/lib/Client_Logging_Handler.cpp
index e180fd4b165..768792cd92d 100644
--- a/netsvcs/lib/Client_Logging_Handler.cpp
+++ b/netsvcs/lib/Client_Logging_Handler.cpp
@@ -4,51 +4,22 @@
 
 #define ACE_BUILD_SVC_DLL
 #include "ace/Get_Opt.h"
+#include "ace/Acceptor.h"
+#include "ace/SOCK_Connector.h"
+#include "ace/SOCK_Acceptor.h"
+#include "ace/SPIPE_Acceptor.h"
 #include "Client_Logging_Handler.h"
 
-#if defined (ACE_LACKS_FIFO)
-#define DEFAULT_RENDEZVOUS "10012"
-#else
-#define DEFAULT_RENDEZVOUS ACE_DEFAULT_RENDEZVOUS
-#endif /* ACE_LACKS_FIFO */
-
-ACE_Client_Logging_Handler::ACE_Client_Logging_Handler (const char rendezvous[])
-  : logging_output_ (ACE_STDOUT)
+ACE_Client_Logging_Handler::ACE_Client_Logging_Handler (ACE_HANDLE output_handle)
+  : logging_output_ (output_handle)
 {
-#if defined (ACE_LACKS_FIFO)
-  if (this->acceptor_.open (ACE_INET_Addr (DEFAULT_RENDEZVOUS)) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "open"));
-  // Register passive-mode socket to receive connections from clients.
-  else if (ACE_Reactor::instance ()->register_handler
-	   (this->acceptor_.get_handle (),
-	    this,
-	    ACE_Event_Handler::ACCEPT_MASK) == -1)
-    ACE_ERROR ((LM_ERROR, "%n: %p\n", "register_handler"));
-  ACE_DEBUG ((LM_DEBUG,
-	      "opened acceptor socket at %s on handle %d\n",
-	      rendezvous,
-	      this->acceptor_.get_handle ()));
-#else
-  if (ACE_OS::unlink (rendezvous) == -1 && errno == EACCES)
-    ACE_ERROR ((LM_ERROR, "%p\n", "unlink"));
-
-  else if (this->msg_queue_.open (rendezvous) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n", "open"));
-
-  // Register message FIFO to receive input from clients.  Note that
-  // we need to put the EXCEPT_MASK here to deal with SVR4 MSG_BAND
-  // data correctly...
-  else if (ACE_Reactor::instance ()->register_handler
-	   (this->msg_queue_.get_handle (),
-	    this,
-	    ACE_Event_Handler::READ_MASK | ACE_Event_Handler::EXCEPT_MASK) == -1)
+  // Register ourselves to receive SIGPIPE so we can attempt
+  // reconnections.
+#if !defined (ACE_LACKS_UNIX_SIGNALS)
+  if (ACE_Reactor::instance ()->register_handler (SIGPIPE, this) == -1)
     ACE_ERROR ((LM_ERROR, "%n: %p\n",
-		"register_handler"));
-  ACE_DEBUG ((LM_DEBUG,
-	      "opened fifo at %s on handle %d\n",
-	     rendezvous,
-	     this->msg_queue_.get_handle ()));
-#endif /* ACE_LACKS_FIFO */
+		"register_handler (SIGPIPE)"));
+#endif /* !ACE_LACKS_UNIX_SIGNALS */
 }
 
 // This is called when a <send> to the logging server fails...
@@ -56,34 +27,36 @@ ACE_Client_Logging_Handler::ACE_Client_Logging_Handler (const char rendezvous[])
 int
 ACE_Client_Logging_Handler::handle_signal (int, siginfo_t *, ucontext_t *)
 {
-  ACE_TRACE ("ACE_Client_Logging_Connector::handle_signal");
+  ACE_TRACE ("ACE_Client_Logging_Acceptor::handle_signal");
   return -1;
 }
 
+// This function is called every time a client connects to us.
+
 int
 ACE_Client_Logging_Handler::open (void *)
 {
-  ACE_INET_Addr server_addr;
-
-  this->logging_output_ = this->peer ().get_handle ();
-
-  // Register ourselves to receive SIGPIPE so we can attempt
-  // reconnections.
-#if !defined (ACE_LACKS_FIFO)
-  if (ACE_Reactor::instance ()->register_handler (SIGPIPE, this) == -1)
+  LOGGING_ADDR server_addr;
+
+  // Register ourselves to receive <handle_input> callbacks when
+  // clients send us logging records.  Note that since we're really a
+  // Singleton, this->peer() will change after each connect, so we
+  // need to grab the value now.
+  if (ACE_Reactor::instance ()->register_handler 
+      (this->peer ().get_handle (), 
+       this,
+       ACE_Event_Handler::READ_MASK
+       | ACE_Event_Handler::EXCEPT_MASK) == -1)
     ACE_ERROR_RETURN ((LM_ERROR, "%n: %p\n",
-		       "register_handler (SIGPIPE)"), -1);
-#endif /* !ACE_LACKS_FIFO */
-
+		       "register_handler)"), -1);
+  
   // Figure out what remote port we're really bound to.
   if (this->peer ().get_remote_addr (server_addr) == -1)
     ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_remote_addr"), -1);
 
   ACE_DEBUG ((LM_DEBUG,
-	      "starting up Client Logging Daemon, "
-	      "connected to port %d on handle %d\n",
-	     server_addr.get_port_number (),
-	     this->peer ().get_handle ()));
+	      "connected to client on handle %u\n",
+	      this->peer ().get_handle ()));
   return 0;
 }
 
@@ -91,13 +64,9 @@ ACE_Client_Logging_Handler::open (void *)
 ACE_Client_Logging_Handler::get_handle (void) const
 {
   ACE_TRACE ("ACE_Client_Logging_Handler::get_handle");
-#if defined (ACE_LACKS_FIFO)
   ACE_ERROR_RETURN ((LM_ERROR,
 		     "get_handle() shouldn't be called\n"),
 		     ACE_INVALID_HANDLE);
-#else
-  return this->msg_queue_.get_handle ();
-#endif /* ACE_LACKS_FIFO */
 }
 
 // Receive a logging record from an application.
@@ -107,36 +76,39 @@ ACE_Client_Logging_Handler::handle_input (ACE_HANDLE handle)
 {
   ACE_DEBUG ((LM_DEBUG, "in handle_input, handle = %u\n", handle));
 
-  if (handle == this->peer ().get_handle ())
+  if (handle == this->logging_output_)
     // We're getting a message from the logging server!
     ACE_ERROR_RETURN ((LM_ERROR, "received data from server!\n"), -1);
-#if defined (ACE_LACKS_FIFO)
-  else if (handle == this->acceptor_.get_handle ())
-    {
-      ACE_SOCK_Stream client_stream;
-
-      if (this->acceptor_.accept (client_stream) == -1)
-	ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "accept"), -1);
-
-      // Register message socket to receive input from clients.
-      else if (ACE_Reactor::instance ()->register_handler
-	       (client_stream.get_handle (),
-		this,
-		ACE_Event_Handler::READ_MASK) == -1)
-	ACE_ERROR_RETURN ((LM_ERROR, "%n: %p\n",
-			   "register_handler"), -1);
-      return 0;
-    }
-#endif /* ACE_LACKS_FIFO */  
 
+  ACE_Log_Record log_record;
+#if defined (ACE_HAS_STREAM_PIPES)
   // We're getting a logging message from a local application.
 
-  ACE_Log_Record log_record;
   ACE_Str_Buf msg ((void *) &log_record,
 		   0,
 		   sizeof log_record);
 
-#if defined (ACE_LACKS_FIFO)
+  ACE_SPIPE_Stream spipe;
+  spipe.set_handle (handle);
+  int flags = 0;
+
+  int result = spipe.recv ((ACE_Str_Buf *) 0, &msg, &flags);
+
+  // We've got a framed IPC mechanism, so we can just to a recv().
+  if (result < 0 || msg.len == 0)
+    {
+      if (ACE_Reactor::instance ()->remove_handler
+	  (handle,
+	   ACE_Event_Handler::READ_MASK
+	   | ACE_Event_Handler::EXCEPT_MASK
+	   | ACE_Event_Handler::DONT_CALL) == -1)
+	ACE_ERROR_RETURN ((LM_ERROR, "%n: %p\n",
+			   "remove_handler"), -1);
+      spipe.close ();
+      ACE_DEBUG ((LM_DEBUG, "client closing down\n"));
+      return 0;
+    }
+#else
   long length;
 
   // We need to use the ol' two-read trick here since TCP sockets
@@ -154,9 +126,10 @@ ACE_Client_Logging_Handler::handle_input (ACE_HANDLE handle)
       if (ACE_Reactor::instance ()->remove_handler
 	  (handle,
 	   ACE_Event_Handler::READ_MASK
+	   | ACE_Event_Handler::EXCEPT_MASK
 	   | ACE_Event_Handler::DONT_CALL) == -1)
 	ACE_ERROR_RETURN ((LM_ERROR, "%n: %p\n",
-			   "remove_handler"), -1);
+			   "remove_handler"), 0);
       ACE_OS::closesocket (handle);
       ACE_DEBUG ((LM_DEBUG, "client closing down\n"));
       return 0;
@@ -167,16 +140,9 @@ ACE_Client_Logging_Handler::handle_input (ACE_HANDLE handle)
       if (ACE_OS::recv (handle,
 			(char *) &log_record,
 			(int) length) != length)
-	ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "recv"), -1);
+	ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "recv"), 0);
     }
-#else
-  // We've got a framed IPC mechanism, so we can just to a recv().
-  if (this->msg_queue_.recv (msg) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-		       "%p\n",
-		       "ACE_FIFO_Recv_Msg::recv"),
-		      0);
-#endif /* ACE_LACKS_FIFO */
+#endif /* ACE_HAS_STREAM_PIPES */
 
   // Forward the logging record to the server.
   if (this->send (log_record) == -1)
@@ -202,24 +168,6 @@ ACE_Client_Logging_Handler::close (u_long)
 {
   ACE_DEBUG ((LM_DEBUG, "shutting down!!!\n"));
 
-#if defined (ACE_LACKS_FIFO)
-  if (ACE_Reactor::instance ()->remove_handler
-      (this->acceptor_.get_handle (),
-       ACE_Event_Handler::ACCEPT_MASK
-       | ACE_Event_Handler::DONT_CALL) == -1)
-    ACE_ERROR ((LM_ERROR, "%n: %p\n",
-		"remove_handler"));
-#else
-  if (ACE_Reactor::instance ()->remove_handler
-      (this->msg_queue_.get_handle (),
-       ACE_Event_Handler::READ_MASK 
-       | ACE_Event_Handler::EXCEPT_MASK 
-       | ACE_Event_Handler::DONT_CALL) == -1)
-    ACE_ERROR ((LM_ERROR, "%n: %p\n",
-		"remove_handler"));
-#endif /* ACE_LACKS_FIFO */
-
-  this->msg_queue_.close ();
   this->destroy ();
   return 0;
 }
@@ -237,7 +185,7 @@ int
 ACE_Client_Logging_Handler::send (ACE_Log_Record &log_record)
 {
   if (this->logging_output_ == ACE_STDOUT)
-	log_record.print ("<localhost>", 0, stderr);
+    log_record.print ("<localhost>", 0, stderr);
   else
     {
       long len = log_record.length ();
@@ -245,10 +193,14 @@ ACE_Client_Logging_Handler::send (ACE_Log_Record &log_record)
 
       log_record.encode ();
 
-      if (this->peer ().send (4, &encoded_len, sizeof encoded_len,
-			      (char *) &log_record, len) == -1)
-	// Switch over to logging to stdout for now.  In the long run,
-	// we'll need to queue up the message, try to reestablish a
+      if (ACE::send (this->logging_output_,
+		     4,
+		     &encoded_len,
+		     sizeof encoded_len,
+		     (char *) &log_record,
+		     len) == -1)
+	// Switch over to logging to stdout for now.  Eventually,
+	// we'll try to queue up the message, try to reestablish a
 	// connection, and then send the queued data once we've
 	// reconnect to the logging server.
 	this->logging_output_ = ACE_STDOUT;
@@ -257,15 +209,20 @@ ACE_Client_Logging_Handler::send (ACE_Log_Record &log_record)
   return 0;
 }
 
-class ACE_Client_Logging_Connector : public ACE_Connector<ACE_Client_Logging_Handler, ACE_SOCK_CONNECTOR>
+class ACE_Client_Logging_Acceptor : public ACE_Acceptor<ACE_Client_Logging_Handler, LOGGING_ACCEPTOR>
   // = TITLE
   //     This factory creates connections with the
   //     <Server_Logging_Acceptor>. 
   //
   // = DESCRIPTION
   //     This class contains the service-specific methods that can't
-  //     easily be factored into the <ACE_Connector>.
+  //     easily be factored into the <ACE_Acceptor>.
 {
+public:
+  // = Initialization method.
+  ACE_Client_Logging_Acceptor (void);
+  // Default constructor.
+
 protected:
   // = Dynamic linking hooks.
   virtual int init (int argc, char *argv[]);
@@ -277,6 +234,9 @@ protected:
   virtual int info (char **strp, size_t length) const;
   // Called to determine info about the service.
 
+  virtual int make_svc_handler (ACE_Client_Logging_Handler *&sh);
+  // Factory that always returns the <handler_>.
+
   // = Scheduling hooks.
   virtual int suspend (void);
   virtual int resume (void);
@@ -297,22 +257,30 @@ private:
 
   const char *rendezvous_key_;
   // Communication endpoint where the client logging daemon will
-  // listen for application logging records.
+  // listen for connections from clients.
 
   ACE_Client_Logging_Handler *handler_;
   // Pointer to the handler that does the work.
 };
 
 int
-ACE_Client_Logging_Connector::fini (void)
+ACE_Client_Logging_Acceptor::fini (void)
 {
   if (this->handler_ != 0)
     this->handler_->close (0);
   return 0;
 }
 
+int 
+ACE_Client_Logging_Acceptor::make_svc_handler (ACE_Client_Logging_Handler *&sh)
+{
+  // Always return a pointer to the Singleton handler.
+  sh = this->handler_;
+  return 0;
+}
+
 int
-ACE_Client_Logging_Connector::info (char **strp, size_t length) const
+ACE_Client_Logging_Acceptor::info (char **strp, size_t length) const
 {
   char buf[BUFSIZ];
 
@@ -327,38 +295,65 @@ ACE_Client_Logging_Connector::info (char **strp, size_t length) const
   return ACE_OS::strlen (buf);
 }
 
+ACE_Client_Logging_Acceptor::ACE_Client_Logging_Acceptor (void)
+  : server_host_ (ACE_DEFAULT_SERVER_HOST),
+    server_port_ (ACE_DEFAULT_LOGGING_SERVER_PORT),
+    rendezvous_key_ (DEFAULT_RENDEZVOUS),
+    handler_ (0)
+{
+}
+
 int
-ACE_Client_Logging_Connector::init (int argc, char *argv[])
+ACE_Client_Logging_Acceptor::init (int argc, char *argv[])
 {
+  // We'll log *our* error and debug messages to stderr!
   ACE_LOG_MSG->open ("Client Logging Service");
 
   // Use the options hook to parse the command line arguments and set
   // options.
   this->parse_args (argc, argv);
 
-  ACE_NEW_RETURN (this->handler_,
-		  ACE_Client_Logging_Handler (this->rendezvous_key_),
-		  -1);
+  // Initialize the acceptor endpoint.
+  if (this->open (LOGGING_ADDR (this->rendezvous_key_)) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", this->rendezvous_key_), -1);
 
   // Establish connection with the server.
-  if (this->connect (this->handler_,
-		     this->server_addr_,
-		     ACE_Synch_Options::synch) == -1)
+  ACE_SOCK_Connector con;
+  ACE_SOCK_Stream stream;
+
+  if (con.connect (stream, this->server_addr_) == -1)
     {
       ACE_ERROR ((LM_ERROR, "%p, using stdout\n",
 		  "can't connect to logging server"));
-      this->handler_ = 0;
+      // If we can't connect to the server then we'll send the logging
+      // messages to stdout.
+      stream.set_handle (ACE_STDOUT);
+    }
+  else
+    {
+      ACE_INET_Addr server_addr;
+
+      // Figure out what remote port we're really bound to.
+      if (stream.get_remote_addr (server_addr) == -1)
+	ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_remote_addr"), -1);
+
+      ACE_DEBUG ((LM_DEBUG,
+		  "starting up Client Logging Daemon, "
+		  "connected to port %d on handle %u\n",
+		  server_addr.get_port_number (),
+		  stream.get_handle ()));
     }
+
+  // Create the Singleton <Client_Logging_Handler>.
+  ACE_NEW_RETURN (this->handler_,
+		  ACE_Client_Logging_Handler (stream.get_handle ()),
+		  -1);
   return 0;
 }
 
 int
-ACE_Client_Logging_Connector::parse_args (int argc, char *argv[])
+ACE_Client_Logging_Acceptor::parse_args (int argc, char *argv[])
 {
-  this->rendezvous_key_ = DEFAULT_RENDEZVOUS;
-  this->server_port_ = ACE_DEFAULT_LOGGING_SERVER_PORT;
-  this->server_host_ = ACE_DEFAULT_SERVER_HOST;
-
   ACE_Get_Opt get_opt (argc, argv, "h:k:p:", 0);
 
   for (int c; (c = get_opt ()) != -1; )
@@ -389,14 +384,14 @@ ACE_Client_Logging_Connector::parse_args (int argc, char *argv[])
 }
 
 int
-ACE_Client_Logging_Connector::suspend (void)
+ACE_Client_Logging_Acceptor::suspend (void)
 {
   // To be done...
   return 0;
 }
 
 int
-ACE_Client_Logging_Connector::resume (void)
+ACE_Client_Logging_Acceptor::resume (void)
 {
   // To be done...
   return 0;
@@ -406,19 +401,11 @@ ACE_Client_Logging_Connector::resume (void)
 // svc.conf file to dynamically initialize the state of the
 // single-threaded logging server.
 
-ACE_SVC_FACTORY_DEFINE (ACE_Client_Logging_Connector)
+ACE_SVC_FACTORY_DEFINE (ACE_Client_Logging_Acceptor)
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Connector<ACE_Client_Logging_Handler, ACE_SOCK_CONNECTOR>;
-template class ACE_Svc_Tuple<ACE_Client_Logging_Handler>;
-template class ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<ACE_Client_Logging_Handler> *>;
-template class ACE_Map_Iterator<ACE_HANDLE, ACE_Svc_Tuple<ACE_Client_Logging_Handler> *, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<ACE_Client_Logging_Handler> *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Acceptor<ACE_Client_Logging_Handler, LOGGING_ACCEPTOR>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Connector<ACE_Client_Logging_Handler, ACE_SOCK_CONNECTOR>
-#pragma instantiate ACE_Svc_Tuple<ACE_Client_Logging_Handler>
-#pragma instantiate ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<ACE_Client_Logging_Handler> *>
-#pragma instantiate ACE_Map_Iterator<ACE_HANDLE, ACE_Svc_Tuple<ACE_Client_Logging_Handler> *, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<ACE_Client_Logging_Handler> *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Acceptor<ACE_Client_Logging_Handler, LOGGING_ACCEPTOR>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
diff --git a/netsvcs/lib/Client_Logging_Handler.h b/netsvcs/lib/Client_Logging_Handler.h
index 7de14e72783..443f389bdc3 100644
--- a/netsvcs/lib/Client_Logging_Handler.h
+++ b/netsvcs/lib/Client_Logging_Handler.h
@@ -17,52 +17,66 @@
 #if !defined (ACE_CLIENT_LOGGER_H)
 #define ACE_CLIENT_LOGGER_H
 
-#include "ace/Connector.h"
-#include "ace/SOCK_Acceptor.h"
-#include "ace/SOCK_Connector.h"
-#include "ace/FIFO_Recv_Msg.h"
-
-class ACE_Svc_Export ACE_Client_Logging_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
+#include "ace/SPIPE_Stream.h"
+#include "ace/SOCK_Stream.h"
+#include "ace/Svc_Handler.h"
+#include "ace/Synch.h"
+
+#if defined (ACE_HAS_STREAM_PIPES)
+#define DEFAULT_RENDEZVOUS ACE_DEFAULT_RENDEZVOUS
+#define LOGGING_STREAM ACE_SPIPE_STREAM
+#define LOGGING_ACCEPTOR ACE_SPIPE_ACCEPTOR
+#define LOGGING_ADDR ACE_SPIPE_Addr
+#else
+#define DEFAULT_RENDEZVOUS "10012"
+#define LOGGING_STREAM ACE_SOCK_STREAM
+#define LOGGING_ACCEPTOR ACE_SOCK_ACCEPTOR
+#define LOGGING_ADDR ACE_INET_Addr
+#endif /* ACE_HAS_STREAM_PIPES */
+
+class ACE_Svc_Export ACE_Client_Logging_Handler : public ACE_Svc_Handler<LOGGING_STREAM, ACE_NULL_SYNCH>
   // = TITLE
   //    This client logging daemon is a mediator that receives logging
   //    records from local applications processes and forwards them to
   //    the server logging daemon running on another host. 
   //
   // = DESCRIPTION
-  //     The default implementation uses an <ACE_FIFO_Recv_Msg> data
-  //     member to receive the logging message from the application
-  //     and an <ACE_SOCK_Stream> to forward the logging message to
-  //     the server.  However, on platforms that don't support FIFOs
-  //     (e.g., Win32) we use sockets instead of FIFOs.
+  //     The default implementation uses an <ACE_SPIPE_Stream> to
+  //     receive the logging message from the application and an
+  //     <ACE_SOCK_Stream> to forward the logging message to the
+  //     server.  However, on platforms that don't support
+  //     <ACE_SPIPEs> (e.g., Win32) we use sockets instead.
 {
-friend class ACE_Client_Logging_Connector;
 public:
   // = Initialization and termination.
 
-  ACE_Client_Logging_Handler (const char rendezvous[] = 0);
-  // Default constructor, which initializes the server endpoint.
+  ACE_Client_Logging_Handler (ACE_HANDLE handle = ACE_STDOUT);
+  // Default constructor.  <handle> is where the output is sent.
 
   virtual int open (void * = 0);
   // Activate this instance of the <ACE_Client_Logging_Handler>
-  // (called by the <ACE_Client_Logging_Connector>).
+  // (called by the <ACE_Client_Logging_Acceptor>).
 
   virtual ACE_HANDLE get_handle (void) const;
-  // Return the handle of the message_fifo_;
+  // Return the handle of the <ACE_SPIPE_Stream>;
 
   virtual int close (u_long);
-  // Called when object is removed from the ACE_Reactor.
+  // Called when object is removed from the <ACE_Reactor>.
 
-protected:
-  virtual int handle_signal (int signum, siginfo_t *, ucontext_t *);
+private:
+  virtual int handle_signal (int signum,
+			     siginfo_t *,
+			     ucontext_t *);
   // Handle SIGPIPE.
 
   virtual int handle_input (ACE_HANDLE);
   // Receive logging records from applications.
 
   virtual int handle_exception (ACE_HANDLE);
-  // Receive logging records from applications.  This is necessary to handle
-  // madness with UNIX select, which can't deal with MSG_BAND data easily due
-  // to its overly simple interface...  This just calls <handle_input>.
+  // Receive logging records from applications.  This is necessary to
+  // handle madness with UNIX select, which can't deal with MSG_BAND
+  // data easily due to its overly simple interface...  This just
+  // calls <handle_input>.
 
   virtual int handle_output (ACE_HANDLE);
   // Called back when it's ok to send.
@@ -70,19 +84,11 @@ protected:
   int send (ACE_Log_Record &log_record);
   // Send the <log_record> to the logging server.
 
-  ACE_FIFO_Recv_Msg msg_queue_;
-  // Message queue we use to receive logging records from clients.
-
   ACE_HANDLE logging_output_;
   // This is either a SOCKET (if we're connected to a logging server)
   // or ACE_STDOUT.
-
-#if defined (ACE_LACKS_FIFO)  
-  ACE_SOCK_Acceptor acceptor_;
-  // Acceptor used for platforms that don't support FIFOs
-#endif /* ACE_LACKS_FIFO */
 };
 
-ACE_SVC_FACTORY_DECLARE (ACE_Client_Logging_Connector)
+ACE_SVC_FACTORY_DECLARE (ACE_Client_Logging_Acceptor)
 
 #endif /* ACE_CLIENT_LOGGER_H */
diff --git a/netsvcs/servers/main.cpp b/netsvcs/servers/main.cpp
index 4c5c4d5de72..3d6d3bb977e 100644
--- a/netsvcs/servers/main.cpp
+++ b/netsvcs/servers/main.cpp
@@ -87,7 +87,7 @@ main (int argc, char *argv[])
 #endif
 	  l_argv[0] = "-p " ACE_DEFAULT_LOGGING_SERVER_PORT_STR;
 	  l_argv[1] = "-hflamenco.cs.wustl.edu";
-	  ACE_Service_Object_Ptr sp_6 = ACE_SVC_INVOKE (ACE_Client_Logging_Connector);
+	  ACE_Service_Object_Ptr sp_6 = ACE_SVC_INVOKE (ACE_Client_Logging_Acceptor);
 
 	  if (sp_6->init (2, l_argv) == -1)
 	    ACE_ERROR ((LM_ERROR, "%p\n%a", "Logging Client", 1));
diff --git a/netsvcs/servers/svc.conf b/netsvcs/servers/svc.conf
index e85cadf3138..78b59eab3a9 100644
--- a/netsvcs/servers/svc.conf
+++ b/netsvcs/servers/svc.conf
@@ -13,5 +13,5 @@ dynamic Name_Server Service_Object * ../lib/netsvcs:_make_ACE_Name_Acceptor() "-
 dynamic Token_Service Service_Object * ../lib/netsvcs:_make_ACE_Token_Acceptor() "-p 20202"
 dynamic Server_Logging_Service Service_Object * ../lib/netsvcs:_make_ACE_Server_Logging_Acceptor() active "-p 20009"
 dynamic Thr_Server_Logging_Service Service_Object * ../lib/netsvcs:_make_ACE_Thr_Server_Logging_Acceptor() active "-p 20020"
-dynamic Client_Logging_Service Service_Object * ../lib/netsvcs:_make_ACE_Client_Logging_Connector() active "-p 20009"
+dynamic Client_Logging_Service Service_Object * ../lib/netsvcs:_make_ACE_Client_Logging_Acceptor() active "-p 20009"