*** empty log message ***

7 files changed, 256 insertions, 568 deletions

diff --git a/netsvcs/lib/Log_Message_Receiver.cpp b/netsvcs/lib/Log_Message_Receiver.cpp
index 03fccfea3b2..ff11b2277b3 100644
--- a/netsvcs/lib/Log_Message_Receiver.cpp
+++ b/netsvcs/lib/Log_Message_Receiver.cpp
@@ -1,20 +1,27 @@
+#if !defined (LOG_MESSAGE_RECEIVER_CPP)
+#define LOG_MESSAGE_RECEIVER_CPP
+
+#include "ace/Synch.h"
+#include "ace/Synch_T.h"
 #include "Log_Message_Receiver.h"
 
-// Type based log message receiver.
+// Type based log message receiver
 template<ACE_SYNCH_1> void
 Static_Log_Message_Receiver<ACE_SYNCH_2>::log_record (char const *hostname,
-                                                     ACE_Log_Record &record)
+						      ACE_Log_Record &record)
 {
 #if defined (ACE_HAS_THREADS)
-  static ACE_SYNCH_MUTEX_T lock;
-  ACE_Guard<ACE_SYNCH_MUTEX_T> guard (lock);
+    static ACE_SYNCH_MUTEX lock_;
+    ACE_Guard<ACE_SYNCH_MUTEX> guard (lock_);
 #endif /* ACE_HAS_THREADS */
    
-  record.print(hostname, 0, stderr);
-};
+  record.print (hostname, 0, stderr);
+}
 
-template<ACE_SYNCH_1>
+#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
+template<ACE_SYNCH_1> 
 ACE_SYNCH_MUTEX_T Log_Message_Receiver_Impl<ACE_SYNCH_2>::copy_lock_;
+#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
 
 template<ACE_SYNCH_1> inline 
 Log_Message_Receiver_Impl<ACE_SYNCH_2>::Log_Message_Receiver_Impl (void) 
@@ -22,7 +29,8 @@ Log_Message_Receiver_Impl<ACE_SYNCH_2>::Log_Message_Receiver_Impl (void)
 {
 }
 
-template<ACE_SYNCH_1> inline Log_Message_Receiver_Impl<ACE_SYNCH_2> *
+template<ACE_SYNCH_1> inline
+Log_Message_Receiver_Impl<ACE_SYNCH_2> *
 Log_Message_Receiver_Impl<ACE_SYNCH_2>::create (void)
 {
   return new Log_Message_Receiver_Impl<ACE_SYNCH_2>;
@@ -34,30 +42,45 @@ Log_Message_Receiver_Impl<ACE_SYNCH_2>::attach (Log_Message_Receiver_Impl<ACE_SY
 {
   assert(body != 0);
   
-  Guard guard(copy_lock_);
+#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
+  ACE_Guard<ACE_SYNCH_MUTEX> guard (copy_lock_);
+#else
+  ACE_Guard<ACE_SYNCH_MUTEX> guard (body->print_lock_);
+#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
   ++body->count_;
   return body;
 }
 
 template<ACE_SYNCH_1> inline void
-Log_Message_Receiver_Impl<ACE_SYNCH_2>::detach (Log_Message_Receiver_Impl<ACE_SYNCH_2> *body)
+Log_Message_Receiver_Impl<ACE_SYNCH_2>::detach(Log_Message_Receiver_Impl<ACE_SYNCH_2> *body)
 {
-  assert(body != 0);
+  assert (body != 0);
   
-  Guard guard(copy_lock_);
+#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
+  ACE_Guard<ACE_SYNCH_MUTEX> guard (copy_lock_);
   
   if (body->count_-- == 0)
     delete body;
+#else
+  bool result = false;
+  {
+    ACE_Guard<ACE_SYNCH_MUTEX> guard (body->print_lock_);
+    result = body->count_-- == 0;
+  }
+
+  if (result != false)
+    delete body;
+#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
 }
 
 // Type based log message receiver
 template<ACE_SYNCH_1> inline void
-Log_Message_Receiver_Impl<ACE_SYNCH_2>::log_record (char const *hostname, 
+Log_Message_Receiver_Impl<ACE_SYNCH_2>::log_record (char const *hostname,
 						    ACE_Log_Record &record)
 {
-  ACE_MT (Guard guard (print_lock_));
+  ACE_MT (ACE_Guard<ACE_SYNCH_MUTEX> guard (print_lock_));
   record.print (hostname, 0, stderr);
-};
+}
 
 template<ACE_SYNCH_1> inline 
 Log_Message_Receiver_Impl<ACE_SYNCH_2>::~Log_Message_Receiver_Impl (void)
@@ -66,23 +89,24 @@ Log_Message_Receiver_Impl<ACE_SYNCH_2>::~Log_Message_Receiver_Impl (void)
 }
 
 template<ACE_SYNCH_1>
-Log_Message_Receiver<ACE_SYNCH_2>::Log_Message_Receiver (void) 
+Log_Message_Receiver<ACE_SYNCH_2>::Log_Message_Receiver() 
   : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_2>::create ())
 {
   assert (receiver_impl_ != 0);  
 }
 
-template<ACE_SYNCH_1> 
-Log_Message_Receiver<ACE_SYNCH_2>::Log_Message_Receiver (const Log_Message_Receiver<ACE_SYNCH_2>& lhs) 
-  : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_2>::attach (lhs.receiver_impl_))
+template<ACE_SYNCH_1>
+Log_Message_Receiver<ACE_SYNCH_2>::Log_Message_Receiver 
+  (Log_Message_Receiver<ACE_SYNCH_2> const &rhs)
+    : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_2>::attach (rhs.receiver_impl_))
 {
   assert (receiver_impl_ != 0);  
 }
 
 // Type based log message receiver
 template<ACE_SYNCH_1> void
-Log_Message_Receiver<ACE_SYNCH_2>::log_record (char const *hostname,
-					       ACE_Log_Record &record)
+Log_Message_Receiver<ACE_SYNCH_2>::log_record(char const *hostname,
+                                              ACE_Log_Record &record)
 {
   assert (receiver_impl_ != 0);  
   receiver_impl_->log_record (hostname, record);
@@ -95,4 +119,4 @@ Log_Message_Receiver<ACE_SYNCH_2>::~Log_Message_Receiver (void)
   Log_Message_Receiver_Impl<ACE_SYNCH_2>::detach (receiver_impl_);
 }
 
-
+#endif /* LOG_MESSAGE_RECEIVER_CPP */
diff --git a/netsvcs/lib/Log_Message_Receiver.h b/netsvcs/lib/Log_Message_Receiver.h
index 9c0a7d5f8f6..a4485f5dece 100644
--- a/netsvcs/lib/Log_Message_Receiver.h
+++ b/netsvcs/lib/Log_Message_Receiver.h
@@ -7,7 +7,7 @@
 //    ace
 // 
 // = FILENAME
-//    Server_Logging_Handler.h 
+//    Log_Message_Receiver
 //
 // = AUTHOR
 //    Per Andersson
@@ -17,45 +17,41 @@
 #if !defined (LOG_MESSAGE_RECEIVER_H)
 #define LOG_MESSAGE_RECEIVER_H
 
-#include "ace/Synch.h"
 #include "ace/Log_Record.h"
+#include "ace/Synch.h"
 
 // Type based log message receiver
 template<ACE_SYNCH_1> 
 class Static_Log_Message_Receiver
-// = TITLE
 {
 public:
-  static void log_record (char const *hostname,
+  static void log_record (char const *hostname, 
 			  ACE_Log_Record &record);
 };
 
-//Forward declaration.
-template<ACE_SYNCH_1> 
-class Log_Message_Receiver_Impl;
+//Forward declaration
+template<ACE_SYNCH_1> class Log_Message_Receiver_Impl;
 
-// Instance based log message receiver.
+// Instance based log message receiver
 template<ACE_SYNCH_1> 
 class Log_Message_Receiver
-// = TITLE
 {
 public:
   Log_Message_Receiver (void);
-  Log_Message_Receiver (const Log_Message_Receiver<ACE_SYNCH_2> &rhs);
+  Log_Message_Receiver(Log_Message_Receiver<ACE_SYNCH_2> const &rhs);
   ~Log_Message_Receiver (void);
   
-  void log_record (char const *hostname, 
+  void log_record (const char *hostname,
 		   ACE_Log_Record &record);
   
 private:
-  Log_Message_Receiver &operator= (const Log_Message_Receiver<ACE_SYNCH_2> &rhs);
+  void operator= (const Log_Message_Receiver<ACE_SYNCH_2> &rhs);
   
-  // = Attributes.
-  ACE_SYNCH_MUTEX_T lock_;
   Log_Message_Receiver_Impl<ACE_SYNCH_2> *receiver_impl_;
+  // Attributes.
 };
 
-template<ACE_SYNCH_1>
+template<ACE_SYNCH_1> 
 class Log_Message_Receiver_Impl
 {
   friend class ACE_Shutup_GPlusPlus;  // Turn off g++ warning
@@ -64,25 +60,31 @@ public:
   static Log_Message_Receiver_Impl *attach (Log_Message_Receiver_Impl<ACE_SYNCH_2> *body);
   static void detach (Log_Message_Receiver_Impl<ACE_SYNCH_2> *body);
   
-  void log_record (char const *hostname,
+  void log_record (const char *hostname,
 		   ACE_Log_Record &record);
 
 private:
   Log_Message_Receiver_Impl (void);
   ~Log_Message_Receiver_Impl (void);
   
-  // = Attributes.
-  int count_;
-  ACE_SYNCH_MUTEX_T print_lock_;
-  static ACE_SYNCH_MUTEX_T copy_lock_;
-  typedef ACE_Guard<ACE_SYNCH_MUTEX_T> Guard;
-
   // = Not implemeted
-  Log_Message_Receiver_Impl (const Log_Message_Receiver_Impl<ACE_SYNCH_2> &lhs);
-  Log_Message_Receiver_Impl &operator= (const Log_Message_Receiver_Impl<ACE_SYNCH_2> &lhs);
-};  
+  Log_Message_Receiver_Impl (const Log_Message_Receiver_Impl<ACE_SYNCH_2> &rhs);
+  void operator=(const Log_Message_Receiver_Impl<ACE_SYNCH_2> &rhs);
+    
+  int count_;
+  ACE_SYNCH_MUTEX print_lock_;
 
-#endif /* LOG_MESSAGE_RECEIVER_H */
+#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
+  static ACE_SYNCH_MUTEX_T copy_lock_;
+#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
+};
 
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "Log_Message_Receiver.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
 
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Log_Message_Receiver.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
 
+#endif /* LOG_MESSAGE_RECEIVER_H */
diff --git a/netsvcs/lib/Makefile b/netsvcs/lib/Makefile
index 16316bba46f..49fadb4a9f0 100644
--- a/netsvcs/lib/Makefile
+++ b/netsvcs/lib/Makefile
@@ -11,6 +11,8 @@ FILES	=  TS_Server_Handler \
 	   TS_Clerk_Handler \
 	   Client_Logging_Handler \
 	   Name_Handler \
+	   Server_Logging_Handler_T \
+	   Log_Message_Receiver \
 	   Server_Logging_Handler \
 	   Token_Handler \
 	   Logging_Strategy
diff --git a/netsvcs/lib/Server_Logging_Handler.cpp b/netsvcs/lib/Server_Logging_Handler.cpp
index 948a79d4040..06c997d709b 100644
--- a/netsvcs/lib/Server_Logging_Handler.cpp
+++ b/netsvcs/lib/Server_Logging_Handler.cpp
@@ -5,270 +5,9 @@
 #define ACE_SERVER_LOGGING_HANDLER_C
 
 #define ACE_BUILD_SVC_DLL
-#include "ace/Get_Opt.h"
+#include "ace/Synch.h"
 #include "Server_Logging_Handler.h"
 
-#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
-// Track number of requests.
-template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1>
-COUNTER ACE_Server_Logging_Handler<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2>::request_count_ = (COUNTER) 0;
-#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
-
-int
-ACE_Server_Logging_Acceptor::parse_args (int argc, char *argv[])
-{
-  ACE_TRACE ("ACE_Server_Logging_Acceptor::parse_args");
-
-  this->service_port_ = ACE_DEFAULT_SERVER_PORT;
-
-  ACE_LOG_MSG->open ("Logging Service");
-
-  ACE_Get_Opt get_opt (argc, argv, "p:", 0);
-
-  for (int c; (c = get_opt ()) != -1; )
-    {
-      switch (c)
-	{
-	case 'p':
-	  this->service_port_ = ACE_OS::atoi (get_opt.optarg);
-	  break;
-	default:
-	  ACE_ERROR_RETURN ((LM_ERROR, 
-			    "%n:\n[-p server-port]\n%a", 1),
-			   -1);
-	}
-    }
-
-  this->service_addr_.set (this->service_port_);
-  return 0;
-}
-
-int
-ACE_Server_Logging_Acceptor::init (int argc, 
-				   char *argv[])
-{
-  ACE_TRACE ("ACE_Server_Logging_Acceptor::init");
-
-  // Use the options hook to parse the command line arguments and set
-  // options.
-  this->parse_args (argc, argv);
-
-  // Set the acceptor endpoint into listen mode (use the Singleton
-  // global Reactor...).
-  if (this->open (this->service_addr_, 
-		  ACE_Service_Config::reactor (),
-		  0, 0, 0, 
-		  &this->scheduling_strategy_,
-		  "Logging Server", "ACE single-threaded logging service") == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%n: %p on port %d\n", 
-		       "acceptor::open failed", 
-		       this->service_addr_.get_port_number ()), -1);
-
-  // Ignore SIGPIPE so that each <SVC_HANDLER> can handle this on its
-  // own.
-  ACE_Sig_Action sig (ACE_SignalHandler (SIG_IGN), SIGPIPE);
-  ACE_UNUSED_ARG (sig);
-
-  ACE_INET_Addr server_addr;
-
-  // Figure out what port we're really bound to.
-  if (this->acceptor ().get_local_addr (server_addr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_local_addr"), -1);
-    
-  ACE_DEBUG ((LM_DEBUG, 
-	      "starting up Logging Server at port %d on handle %d\n", 
-	     server_addr.get_port_number (),
-	     this->acceptor ().get_handle ()));
-  return 0;
-}
-
-template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1>
-ACE_Server_Logging_Handler<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2>::ACE_Server_Logging_Handler 
-  (ACE_Thread_Manager *)
-{
-  this->host_name_[0] = '\0'; // Initialize to a known state.
-}
-
-template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1> int
-ACE_Server_Logging_Handler<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2>::handle_logging_record (void)
-{
-  ssize_t len;
-
-  // Perform two recv's to emulate record-oriented semantics.  Note
-  // that this code is not entirely portable since it relies on the
-  // fact that sizeof (ssize_t) is the same on both the sender and
-  // receiver side.  To correctly handle this is painful, and we leave
-  // it as an exercise for the reader ;-).
-
-  ssize_t n = this->peer ().recv (&len, sizeof len);
-
-  switch (n)
-    {
-    case -1:
-      ACE_ERROR_RETURN ((LM_ERROR, "%p at host %s\n",
-			"server logger", this->host_name_), -1);      
-      /* NOTREACHED */
-    case 0:
-      ACE_ERROR_RETURN ((LM_ERROR, "closing log daemon at host %s\n",
-			this->host_name_), -1);	
-      /* NOTREACHED */
-    case sizeof (ssize_t):
-      {
-	ACE_Log_Record lp;
-	
-#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
-	u_long count = ++this->request_count_;
-	ACE_DEBUG ((LM_DEBUG, "request count = %d\n", count));
-#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
-
-        len = ntohl (len);
-	n = this->peer ().recv_n ((void *) &lp, len);
-	if (n != len)
-	  ACE_ERROR_RETURN ((LM_ERROR, "len = %d, %p at host %s\n",
-			    n, "server logger", this->host_name_), -1);
-	/* NOTREACHED */
-	  
-	lp.decode ();
-
-	if (lp.length () == n)
-	  {
-	    // Serialize output, if necessary (i.e., if we are running
-	    // in separate threads).
-	    ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, *this->lock_, -1));
-
-	    lp.print (this->host_name_, 0, stderr);
-	  }
-	else
-	  ACE_ERROR ((LM_ERROR, "error, lp.length = %d, n = %d\n",
-		     lp.length (), n));
-	break;
-      }
-    default:
-      ACE_ERROR_RETURN ((LM_ERROR, "%p at host %s\n",
-			"server logger", this->host_name_), -1);
-      /* NOTREACHED */
-    }
-
-  return n;
-}
-
-// Hook called by Server_Logging_Acceptor when connection is
-// established.
-
-template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1> int
-ACE_Server_Logging_Handler<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2>::open (void *)
-{
-  // Register ourselves with the Reactor to enable subsequent
-  // dispatching.
-  if (ACE_Service_Config::reactor ()->register_handler 
-      (this, ACE_Event_Handler::READ_MASK) == -1)
-    return -1;
-
-  ACE_PEER_STREAM_ADDR client_addr;
-
-  // Determine the address of the client and display it.
-  if (this->peer ().get_remote_addr (client_addr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_remote_addr"), -1);
-
-  ACE_OS::strncpy (this->host_name_, client_addr.get_host_name (), MAXHOSTNAMELEN + 1);
-
-  ACE_DEBUG ((LM_DEBUG, "(%t) accepted connection from host %s on fd %d\n",
-	      client_addr.get_host_name (), this->peer ().get_handle ()));
-
-  // Shut off non-blocking IO if it was enabled...
-  if (this->peer ().disable (ACE_NONBLOCK) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "disable"), -1);
-
-  return 0;
-}
-
-// Callback routine for handling the reception of remote logging
-// transmissions.
-
-template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1> int
-ACE_Server_Logging_Handler<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2>::handle_input (ACE_HANDLE)
-{
-  int result = this->handle_logging_record ();
-  return result > 0 ? result : -1;
-}
-
-int 
-ACE_Thr_Server_Logging_Acceptor::make_svc_handler (ACE_Thr_Server_Logging_Handler *&handler)
-{
-  ACE_NEW_RETURN (handler, 
-		  ACE_Thr_Server_Logging_Handler (ACE_Service_Config::thr_mgr (),
-						  &this->lock_),
-		  -1);
-  return 0;
-}
-
-int
-ACE_Thr_Server_Logging_Acceptor::parse_args (int argc, char *argv[])
-{
-  ACE_TRACE ("ACE_Thr_Server_Logging_Acceptor::parse_args");
-
-  this->service_port_ = ACE_DEFAULT_SERVER_PORT;
-
-  ACE_LOG_MSG->open ("Logging Service");
-
-  ACE_Get_Opt get_opt (argc, argv, "p:", 0);
-
-  for (int c; (c = get_opt ()) != -1; )
-    {
-      switch (c)
-	{
-	case 'p':
-	  this->service_port_ = ACE_OS::atoi (get_opt.optarg);
-	  break;
-	default:
-	  ACE_ERROR_RETURN ((LM_ERROR, 
-			    "%n:\n[-p server-port]\n%a", 1),
-			   -1);
-	}
-    }
-
-  this->service_addr_.set (this->service_port_);
-  return 0;
-}
-
-int
-ACE_Thr_Server_Logging_Acceptor::init (int argc, 
-				       char *argv[])
-{
-  ACE_TRACE ("ACE_Thr_Server_Logging_Acceptor::init");
-
-  // Use the options hook to parse the command line arguments and set
-  // options.
-  this->parse_args (argc, argv);
-
-  // Set the acceptor endpoint into listen mode (use the Singleton
-  // global Reactor...).
-  if (this->open (this->service_addr_, ACE_Service_Config::reactor (),
-		  0, 0, 0, 
-		  &this->scheduling_strategy_,
-		  "Thr Logging Server", "ACE multi-threaded logging service") == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%n: %p on port %d\n", 
-		       "acceptor::open failed", 
-		       this->service_addr_.get_port_number ()), -1);
-
-  // Ignore SIGPIPE so that each <SVC_HANDLER> can handle this on its
-  // own.
-  ACE_Sig_Action sig (ACE_SignalHandler (SIG_IGN), SIGPIPE);
-  ACE_UNUSED_ARG (sig);
-
-  ACE_INET_Addr server_addr;
-
-  // Figure out what port we're really bound to.
-  if (this->acceptor ().get_local_addr (server_addr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_local_addr"), -1);
-    
-  ACE_DEBUG ((LM_DEBUG, 
-	      "starting up Threaded Logging Server at port %d on handle %d\n", 
-	     server_addr.get_port_number (),
-	     this->acceptor ().get_handle ()));
-  return 0;
-}
-
 // The following are "Factories" used by the ACE_Service_Config and
 // svc.conf file to dynamically initialize the state of the
 // single-threaded and multi-threaded logging server.
@@ -276,77 +15,85 @@ ACE_Thr_Server_Logging_Acceptor::init (int argc,
 ACE_SVC_FACTORY_DEFINE (ACE_Server_Logging_Acceptor)
 ACE_SVC_FACTORY_DEFINE (ACE_Thr_Server_Logging_Acceptor)
 
-// Override definition in the ACE_Svc_Handler class (spawn a new
-// thread if we're configured with ACE_HAS_THREADS!).
-
-int
-ACE_Thr_Server_Logging_Handler::open (void *)
-{
-  // Shut off non-blocking IO since now we can block in our own
-  // thread!
-  if (this->peer ().disable (ACE_NONBLOCK) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "disable"), -1);
+#if defined (ACE_TEMPLATES_REQUIRE_SPECIALIZATION) 
+template class Log_Message_Receiver_Impl<ACE_NULL_SYNCH>;
+template class Static_Log_Message_Receiver<ACE_NULL_SYNCH>;
+template class ACE_Acceptor<Null_Synch_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+template class ACE_Accept_Strategy<Null_Synch_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+template class ACE_Concurrency_Strategy<Null_Synch_Logging_Handler_Static_Receiver>;
+template class ACE_Creation_Strategy<Null_Synch_Logging_Handler_Static_Receiver>;
+template class ACE_Schedule_All_Reactive_Strategy<Null_Synch_Logging_Handler_Static_Receiver>;
+template class ACE_Scheduling_Strategy<Null_Synch_Logging_Handler_Static_Receiver>;
+template class ACE_Strategy_Acceptor<Null_Synch_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+template class ACE_Server_Logging_Acceptor_T<Null_Synch_Logging_Handler_Static_Receiver, 
+                                            Null_Synch_Static_Receiver, 
+                                            ACE_Schedule_All_Reactive_Strategy<Null_Synch_Logging_Handler_Static_Receiver> >;
+template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, Null_Synch_Static_Receiver>;
+template class ACE_Server_Logging_Handler<Null_Synch_Static_Receiver>;
+
+
+//#if defined (ACE_HAS_THREADS) 
+  template class Static_Log_Message_Receiver<ACE_LOGGER_SYNCH>;
+  template class Log_Message_Receiver<ACE_LOGGER_SYNCH>;
+  template class ACE_Acceptor<Synch_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Acceptor<Synch_Thr_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Acceptor<Synch_Logging_Handler_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Acceptor<Synch_Thr_Logging_Handler_Receiver, LOGGING_PEER_ACCEPTOR>;
+
+  template class ACE_Accept_Strategy<Synch_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Accept_Strategy<Synch_Thr_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Accept_Strategy<Synch_Logging_Handler_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Accept_Strategy<Synch_Thr_Logging_Handler_Receiver, LOGGING_PEER_ACCEPTOR>;
+
+  template class ACE_Concurrency_Strategy<Synch_Logging_Handler_Static_Receiver>;
+  template class ACE_Concurrency_Strategy<Synch_Thr_Logging_Handler_Static_Receiver>;
+  template class ACE_Concurrency_Strategy<Synch_Logging_Handler_Receiver>;
+  template class ACE_Concurrency_Strategy<Synch_Thr_Logging_Handler_Receiver>;
+
+  template class ACE_Creation_Strategy<Synch_Logging_Handler_Static_Receiver>;
+  template class ACE_Creation_Strategy<Synch_Thr_Logging_Handler_Static_Receiver>;
+  template class ACE_Creation_Strategy<Synch_Logging_Handler_Receiver>;
+  template class ACE_Creation_Strategy<Synch_Thr_Logging_Handler_Receiver>;
+
+  template class ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Static_Receiver>;
+  template class ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Receiver>;
+
+  template class ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Static_Receiver>;
+  template class ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Receiver>;
+
+  template class ACE_Scheduling_Strategy<Synch_Logging_Handler_Static_Receiver>;
+  template class ACE_Scheduling_Strategy<Synch_Logging_Handler_Receiver>;
+  template class ACE_Scheduling_Strategy<Synch_Thr_Logging_Handler_Static_Receiver>;
+  template class ACE_Scheduling_Strategy<Synch_Thr_Logging_Handler_Receiver>;
+
+  template class ACE_Strategy_Acceptor<Synch_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Strategy_Acceptor<Synch_Thr_Logging_Handler_Static_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Strategy_Acceptor<Synch_Logging_Handler_Receiver, LOGGING_PEER_ACCEPTOR>;
+  template class ACE_Strategy_Acceptor<Synch_Thr_Logging_Handler_Receiver, LOGGING_PEER_ACCEPTOR>;
+
+  template class ACE_Server_Logging_Acceptor_T<Synch_Logging_Handler_Static_Receiver, 
+                                              Synch_Static_Receiver, 
+                                              ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Static_Receiver> >;
+  template class ACE_Server_Logging_Acceptor_T<Synch_Thr_Logging_Handler_Static_Receiver, 
+                                              Synch_Static_Receiver, 
+                                              ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Static_Receiver> >;
+  template class ACE_Server_Logging_Acceptor_T<Synch_Logging_Handler_Receiver, 
+                                              Synch_Receiver, 
+                                              ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Receiver> >;
+  template class ACE_Server_Logging_Acceptor_T<Synch_Thr_Logging_Handler_Receiver, 
+                                              Synch_Receiver, 
+                                              ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Receiver> >;
+
+//  template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, Synch_Static_Receiver>;
+  template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_SYNCH, Synch_Static_Receiver>;
+  template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_SYNCH, Synch_Receiver>;
+//  template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_MT_SYNCH, Synch_Receiver>;
+
+  template class ACE_Server_Logging_Handler<Synch_Static_Receiver>;
+  template class ACE_Thr_Server_Logging_Handler<Synch_Static_Receiver>;
+  template class ACE_Server_Logging_Handler<Synch_Receiver>;
+  template class ACE_Thr_Server_Logging_Handler<Synch_Receiver>;
 
-  ACE_INET_Addr client_addr;
-
-  // Determine the address of the client and display it.
-  if (this->peer ().get_remote_addr (client_addr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "get_remote_addr"), -1);
-
-  ACE_OS::strncpy (this->host_name_, client_addr.get_host_name (), MAXHOSTNAMELEN + 1);
-
-  ACE_DEBUG ((LM_DEBUG, "(%t) accepted connection from host %s on fd %d\n",
-	      client_addr.get_host_name (), this->peer ().get_handle ()));
-
-  // Spawn a new thread of control to handle logging records with the
-  // client.  Note that this implicitly uses the
-  // ACE_Service_Config::thr_mgr () to control all the threads.
-  if (this->activate (THR_BOUND | THR_DETACHED) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);    
-  return 0;
-}
-
-ACE_Thr_Server_Logging_Handler::ACE_Thr_Server_Logging_Handler
-   (ACE_Thread_Manager *, 
-    ACE_SYNCH_MUTEX *lock)
-{
-  this->lock_ = lock;
-}
-
-// Process remote logging records. 
-
-int
-ACE_Thr_Server_Logging_Handler::svc (void)
-{
-  int result = 0;
-
-  // Loop until the client terminates the connection or an error occurs.
-
-  while ((result = this->handle_input ()) > 0)
-    continue;
-
-  return result;
-}
-
-#if defined (ACE_TEMPLATES_REQUIRE_SPECIALIZATION)
-template class ACE_Acceptor<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH>, LOGGING_PEER_ACCEPTOR>;
-template class ACE_Acceptor<ACE_Thr_Server_Logging_Handler, LOGGING_PEER_ACCEPTOR>;
-template class ACE_Accept_Strategy<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH>, LOGGING_PEER_ACCEPTOR>;
-template class ACE_Accept_Strategy<ACE_Thr_Server_Logging_Handler, LOGGING_PEER_ACCEPTOR>;
-template class ACE_Concurrency_Strategy<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH> >;
-template class ACE_Concurrency_Strategy<ACE_Thr_Server_Logging_Handler>;
-template class ACE_Creation_Strategy<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH> >;
-template class ACE_Creation_Strategy<ACE_Thr_Server_Logging_Handler>;
-template class ACE_Schedule_All_Reactive_Strategy<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH> >;
-template class ACE_Schedule_All_Threaded_Strategy<ACE_Thr_Server_Logging_Handler>;
-template class ACE_Scheduling_Strategy<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH> >;
-template class ACE_Scheduling_Strategy<ACE_Thr_Server_Logging_Handler>;
-template class ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH>;
-template class ACE_Strategy_Acceptor<ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH>, LOGGING_PEER_ACCEPTOR>;
-template class ACE_Strategy_Acceptor<ACE_Thr_Server_Logging_Handler, LOGGING_PEER_ACCEPTOR>;
-
-#if defined (ACE_HAS_THREADS) 
-  template class ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, ACE_Atomic_Op<ACE_Thread_Mutex, u_long>, ACE_MT_SYNCH>;
   template class ACE_Svc_Handler<LOGGING_PEER_STREAM, ACE_SYNCH>;
   #if defined (ACE_HAS_TLI)
     template class ACE_Svc_Handler<LOGGING_PEER_STREAM, ACE_NULL_SYNCH>;
@@ -356,11 +103,12 @@ template class ACE_Strategy_Acceptor<ACE_Thr_Server_Logging_Handler, LOGGING_PEE
     // That specialization is in TS_Server_Handler.cpp, so we don't need it
     // here.
   #endif /* ACE_HAS_TLI */
-#else
-  #if defined (ACE_HAS_TLI)
-    template class ACE_Svc_Handler<LOGGING_PEER_STREAM, ACE_SYNCH>;
-  #endif /* ACE_HAS_TLI */
-#endif /* ACE_HAS_THREADS */
+// #else
+// #if defined (ACE_HAS_TLI)
+// template class ACE_Svc_Handler<LOGGING_PEER_STREAM, ACE_SYNCH>;
+// #endif /* ACE_HAS_TLI */
+// #endif /* ACE_HAS_THREADS */
 #endif /* ACE_TEMPLATES_REQUIRE_SPECIALIZATION */
 
-#endif /* ACE_SERVER_LOGGING_HANDLER_C */
+#endif /* ACE_SERVER_LOGGING_HANDLERT_C */
+
diff --git a/netsvcs/lib/Server_Logging_Handler.h b/netsvcs/lib/Server_Logging_Handler.h
index 4f61190cdf8..91a473caf40 100644
--- a/netsvcs/lib/Server_Logging_Handler.h
+++ b/netsvcs/lib/Server_Logging_Handler.h
@@ -1,156 +1,58 @@
-/* -*- C++ -*- */
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    ace
-// 
-// = FILENAME
-//    Server_Logging_Handler.h 
-//
-// = AUTHOR
-//    Doug Schmidt 
-// 
-// ============================================================================
-
 #if !defined (ACE_SERVER_LOGGING_HANDLER_H)
 #define ACE_SERVER_LOGGING_HANDLER_H
 
-#include "ace/Synch.h"
-#include "ace/TLI_Acceptor.h"
-#include "ace/SOCK_Acceptor.h"
-#include "ace/Acceptor.h"
-
-template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1>
-class ACE_Server_Logging_Handler : public ACE_Svc_Handler<ACE_PEER_STREAM_2, ACE_SYNCH_2>
-{
-  // = TITLE
-  //    Product object created by an <ACE_Server_Logging_Acceptor>.  An
-  //    <ACE_Server_Logging_Handler> receives, frames, and processes logging
-  //    records.
-  // 
-  // = DESCRIPTION
-  //     Defines the classes that perform server logging daemon
-  //     functionality.
-public:
-  ACE_Server_Logging_Handler (ACE_Thread_Manager * = 0);
-  // Constructor.
-
-  virtual int open (void * = 0);
-  // Hook called by <Server_Logging_Acceptor> when connection is
-  // established.
-
-  virtual int handle_input (ACE_HANDLE = ACE_INVALID_HANDLE);
-  // Process remote logging records. 
-
-protected:
-  int handle_logging_record (void);
-  // Receive the logging record from a client.
-  
-#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
-  static COUNTER request_count_;
-  // Count the number of logging records that arrive.
-#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
-
-  char host_name_[MAXHOSTNAMELEN + 1];
-  // Name of the host we are connected to.
-
-  ACE_SYNCH_MUTEX_T *lock_;
-  // Reference to the lock used to serialize output.
-};
-
-#if !defined (ACE_HAS_TLI)
-#define LOGGING_PEER_ACCEPTOR ACE_SOCK_ACCEPTOR
-#define LOGGING_PEER_STREAM ACE_SOCK_STREAM
-#else /* use sockets */
-#define LOGGING_PEER_ACCEPTOR ACE_TLI_ACCEPTOR
-#define LOGGING_PEER_STREAM ACE_TLI_STREAM
-#endif /* ACE_HAS_TLI */
-
-typedef ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH>
-	SERVER_LOGGING_HANDLER;
+#include "Log_Message_Receiver.h"
+#include "Server_Logging_Handler_T.h"
 
-class ACE_Server_Logging_Acceptor : public ACE_Strategy_Acceptor<SERVER_LOGGING_HANDLER, LOGGING_PEER_ACCEPTOR>
-  // = TITLE
-  //     This class implements the ACE single-threaded logging service.
-  //
-  // = DESCRIPTION
-  //     This class contains the service-specific methods that can't
-  //     easily be factored into the <ACE_Strategy_Acceptor>.
-{
-public:
-  virtual int init (int argc, char *argv[]);
-  // Dynamic linking hook.
+// Type based log message receivers.
+typedef Static_Log_Message_Receiver<ACE_NULL_SYNCH> Null_Synch_Static_Receiver;
+typedef Static_Log_Message_Receiver<ACE_LOGGER_SYNCH> Synch_Static_Receiver;
 
-protected:
-  int parse_args (int argc, char *argv[]);
-  // Parse svc.conf arguments.
+typedef ACE_Server_Logging_Handler<Null_Synch_Static_Receiver> Null_Synch_Logging_Handler_Static_Receiver;
 
-private:
-  ACE_Schedule_All_Reactive_Strategy<SERVER_LOGGING_HANDLER> scheduling_strategy_;
-  // The scheduling strategy is designed for Reactive services.
-};
+typedef ACE_Server_Logging_Handler<Synch_Static_Receiver> Synch_Logging_Handler_Static_Receiver;
+typedef ACE_Thr_Server_Logging_Handler<Synch_Static_Receiver> Synch_Thr_Logging_Handler_Static_Receiver;
 
-#if !defined (ACE_HAS_THREADS) 
-typedef u_long COUNTER;
-#define ACE_LOGGER_SYNCH ACE_NULL_SYNCH 
-#else
-typedef ACE_Atomic_Op <ACE_Thread_Mutex, u_long> COUNTER;
-#define ACE_LOGGER_SYNCH ACE_MT_SYNCH 
-#endif /* ACE_HAS_THREADS */
+typedef ACE_Server_Logging_Acceptor_T<Null_Synch_Logging_Handler_Static_Receiver, 
+                                     Null_Synch_Static_Receiver, 
+                                     ACE_Schedule_All_Reactive_Strategy<Null_Synch_Logging_Handler_Static_Receiver> > 
+                  Null_Synch_Logging_Handler_Static_Receiver_Acceptor;                  
 
-class ACE_Svc_Export ACE_Thr_Server_Logging_Handler : public ACE_Server_Logging_Handler<LOGGING_PEER_STREAM, COUNTER, ACE_LOGGER_SYNCH> 
-  // = TITLE
-  //    Product object created by a <ACE_Thr_Server_Logging_Acceptor>.  An
-  //    <ACE_Thr_Server_Logging_Handler> receives, frames, and processes
-  //    logging records.
-  //
-  // = DESCRIPTION
-  //     Each client is handled in its own separate thread.
-{
-public:
-  ACE_Thr_Server_Logging_Handler (ACE_Thread_Manager * = 0,
-				  ACE_SYNCH_MUTEX * = 0);
+typedef ACE_Server_Logging_Acceptor_T<Synch_Logging_Handler_Static_Receiver, 
+                                     Synch_Static_Receiver, 
+                                     ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Static_Receiver> > 
+                  Synch_Logging_Handler_Static_Receiver_Acceptor;                  
 
-  virtual int open (void * = 0);
-  // Override activation definition in the ACE_Svc_Handler class (will
-  // spawn a new thread if we've got threads).
+typedef ACE_Server_Logging_Acceptor_T<Synch_Thr_Logging_Handler_Static_Receiver, 
+                                     Synch_Static_Receiver, 
+                                     ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Static_Receiver> > 
+                  Synch_Thr_Logging_Handler_Static_Receiver_Acceptor;                  
 
-  virtual int svc (void);
-  // Process remote logging records. 
-};
+// Instance based log message receivers 
+typedef Log_Message_Receiver<ACE_LOGGER_SYNCH> Synch_Receiver;
 
-class ACE_Thr_Server_Logging_Acceptor : public ACE_Strategy_Acceptor<ACE_Thr_Server_Logging_Handler, LOGGING_PEER_ACCEPTOR>
-  // = TITLE
-  //     This class implements the ACE multi-threaded logging service.
-  //
-  // = DESCRIPTION
-  //     This class contains the service-specific methods that can't
-  //     easily be factored into the <ACE_Strategy_Acceptor>.
-{
-public:
-  virtual int init (int argc, char *argv[]);
-  // Dynamic linking hook.
+typedef ACE_Server_Logging_Handler<Synch_Receiver> Synch_Logging_Handler_Receiver;
+typedef ACE_Thr_Server_Logging_Handler<Synch_Receiver> Synch_Thr_Logging_Handler_Receiver;
+                                 
+typedef ACE_Server_Logging_Acceptor_T<Synch_Logging_Handler_Receiver, 
+                                     Synch_Receiver, 
+                                     ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Receiver> > 
+                  Synch_Logging_Handler_Receiver_Acceptor;                  
 
-  int parse_args (int argc, char *argv[]);
-  // Parse svc.conf arguments.
+typedef ACE_Server_Logging_Acceptor_T<Synch_Thr_Logging_Handler_Receiver, 
+                                     Synch_Receiver,
+                                     ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Receiver> > 
+                  Synch_Thr_Logging_Handler_Receiver_Acceptor;                  
 
-  virtual int make_svc_handler (ACE_Thr_Server_Logging_Handler *&);
-  // Factory that creates a new <SERVER_LOGGING_HANDLER>.  We need to
-  // specialize this since the <lock_> held by this Acceptor must be
-  // passed into the <SERVER_LOGGING_HANDLER>.
+// Define external acceptors
+typedef  Null_Synch_Logging_Handler_Static_Receiver_Acceptor ACE_Server_Logging_Acceptor;
+typedef  Synch_Thr_Logging_Handler_Static_Receiver_Acceptor ACE_Thr_Server_Logging_Acceptor;
 
-private:
-  ACE_SYNCH_MUTEX lock_;
-  // Lock used to serialize output by the various
-  // <ACE_Server_Logging_Handler>'s.
+//typedef  Synch_Logging_Handler_Receiver_Acceptor ACE_Server_Logging_Acceptor;
+//typedef  Synch_Thr_Logging_Handler_Receiver_Acceptor ACE_Thr_Server_Logging_Acceptor;
 
-  ACE_Schedule_All_Threaded_Strategy<ACE_Thr_Server_Logging_Handler> scheduling_strategy_;
-  // The scheduling strategy is designed for multi-threaded services.
-};
 
 ACE_SVC_FACTORY_DECLARE (ACE_Server_Logging_Acceptor)
 ACE_SVC_FACTORY_DECLARE (ACE_Thr_Server_Logging_Acceptor)
 
-#endif /* ACE_SERVER_LOGGING_HANDLER_H */
+#endif
diff --git a/netsvcs/lib/Server_Logging_Handler_T.cpp b/netsvcs/lib/Server_Logging_Handler_T.cpp
index 5822720a6ae..7df7cd220b1 100644
--- a/netsvcs/lib/Server_Logging_Handler_T.cpp
+++ b/netsvcs/lib/Server_Logging_Handler_T.cpp
@@ -1,11 +1,13 @@
-// Server_Logging_Handler_T.cpp
+// $Id$
+// Server_Logging_Handler.cpp
 
-#if !defined (ACE_SERVER_LOGGING_HANDLER_T_C)
-#define ACE_SERVER_LOGGING_HANDLER_T_C
+#if !defined (ACE_SERVER_LOGGING_HANDLERT_C)
+#define ACE_SERVER_LOGGING_HANDLERT_C
 
 #define ACE_BUILD_SVC_DLL
 #include "ace/Get_Opt.h"
 #include "Server_Logging_Handler_T.h"
+#include <string.h>
 
 #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
 // Track number of requests.
@@ -16,8 +18,8 @@ COUNTER ACE_Server_Logging_Handler_T<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2, LM
 template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1, class LMR>
 ACE_Server_Logging_Handler_T<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2, LMR>::ACE_Server_Logging_Handler_T 
   (ACE_Thread_Manager *,
-  LMR const &receiver) :
-  receiver_ (receiver, ACE_CString (" ", 1))
+   LMR const& receiver) 
+    : receiver_ (receiver, ACE_CString (" ", 1))
 {
 }
 
@@ -111,6 +113,7 @@ ACE_Server_Logging_Handler_T<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2, LMR>::open
 
   ACE_DEBUG ((LM_DEBUG, "(%t) accepted connection from host %s on fd %d\n",
 	      client_addr.get_host_name (), this->peer ().get_handle ()));
+
   return 0;
 }
 
@@ -178,8 +181,8 @@ ACE_Server_Logging_Acceptor_T<SLH, LMR, SS>::parse_args (int argc, char *argv[])
 	  break;
 	default:
 	  ACE_ERROR_RETURN ((LM_ERROR, 
-			     "%n:\n[-p server-port]\n%a", 1),
-			    -1);
+			    "%n:\n[-p server-port]\n%a", 1),
+			   -1);
 	}
     }
 
@@ -190,24 +193,27 @@ ACE_Server_Logging_Acceptor_T<SLH, LMR, SS>::parse_args (int argc, char *argv[])
 template<class SLH, class LMR, class SS> int
 ACE_Server_Logging_Acceptor_T<SLH, LMR, SS>::make_svc_handler (SLH *&handler)
 {
-  ACE_NEW_RETURN (handler, SLH (ACE_Service_Config::thr_mgr (), this->receiver()), -1);
+  ACE_NEW_RETURN (handler, 
+		  SLH (ACE_Service_Config::thr_mgr (), this->receiver()), 
+		  -1);
   return 0;
 }
 
 template<class LMR> 
-ACE_Server_Logging_Handler<LMR>::ACE_Server_Logging_Handler (ACE_Thread_Manager *tm,
-							     LMR const &receiver) 
-  : ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, LMR>(tm, receiver)
+ACE_Server_Logging_Handler<LMR>::ACE_Server_Logging_Handler (ACE_Thread_Manager * tm,
+							     LMR const& receiver) 
+  : ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, LMR>(tm,
+										   receiver)
 {
 }
 
 template<class LMR> 
-ACE_Server_Logging_Handler<LMR>::ACE_Server_Logging_Handler(ACE_Thread_Manager *tm)
-  : ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, LMR>(tm, LMR ())
+ACE_Server_Logging_Handler<LMR>::ACE_Server_Logging_Handler(ACE_Thread_Manager * tm) 
+  : ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, LMR>(tm, LMR())
 {
 }
 
-template<class LMR> int
+template<class LMR>  int
 ACE_Server_Logging_Handler<LMR>::open (void *)
 {
   // call base class open_common
@@ -216,27 +222,26 @@ ACE_Server_Logging_Handler<LMR>::open (void *)
 
   // Register ourselves with the Reactor to enable subsequent
   // dispatching.
-  else if (ACE_Service_Config::reactor ()->register_handler 
+  if (ACE_Service_Config::reactor ()->register_handler 
       (this, ACE_Event_Handler::READ_MASK) == -1)
     return -1;
-  else
-    return 0;
+  return 0;
 }
 
 template<class LMR> 
-ACE_Thr_Server_Logging_Handler<LMR>::ACE_Thr_Server_Logging_Handler (ACE_Thread_Manager *tm,
-								    LMR const &receiver) 
+ACE_Thr_Server_Logging_Handler<LMR>::ACE_Thr_Server_Logging_Handler (ACE_Thread_Manager *tm, LMR const &receiver)
   : ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_LOGGER_SYNCH, LMR>(tm, receiver)
 {
 }
 
-template<class LMR> 
-ACE_Thr_Server_Logging_Handler<LMR>::ACE_Thr_Server_Logging_Handler(ACE_Thread_Manager *tm) 
+template<class LMR>
+ACE_Thr_Server_Logging_Handler<LMR>::ACE_Thr_Server_Logging_Handler (ACE_Thread_Manager *tm)
   : ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_LOGGER_SYNCH, LMR>(tm, LMR ())
 {
 }
 
-template<class LMR> int
+template<class LMR> 
+int
 ACE_Thr_Server_Logging_Handler<LMR>::open (void *)
 {
   // call base class open_common
@@ -246,10 +251,9 @@ ACE_Thr_Server_Logging_Handler<LMR>::open (void *)
   // Spawn a new thread of control to handle logging records with the
   // client.  Note that this implicitly uses the
   // ACE_Service_Config::thr_mgr () to control all the threads.
-  else if (this->activate (THR_BOUND | THR_DETACHED) == -1)
+  if (this->activate (THR_BOUND | THR_DETACHED) == -1)
     ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);    
-  else
-    return 0;
+  return 0;
 }
 
 // Process remote logging records. 
@@ -259,13 +263,11 @@ ACE_Thr_Server_Logging_Handler<LMR>::svc (void)
 {
   int result = 0;
 
-  // Loop until the client terminates the connection or an error
-  // occurs.
+  // Loop until the client terminates the connection or an error occurs.
 
   while ((result = this->handle_input ()) > 0)
     continue;
 
   return result;
 }
-#endif /* ACE_SERVER_LOGGING_HANDLER_T_C */
-
+#endif /* ACE_SERVER_LOGGING_HANDLER_TT_C */
diff --git a/netsvcs/lib/Server_Logging_Handler_T.h b/netsvcs/lib/Server_Logging_Handler_T.h
index 6a31212fe21..694804d0dae 100644
--- a/netsvcs/lib/Server_Logging_Handler_T.h
+++ b/netsvcs/lib/Server_Logging_Handler_T.h
@@ -7,7 +7,7 @@
 //    ace
 // 
 // = FILENAME
-//    Server_Logging_Handler_T.h 
+//    Server_Logging_Handler.h 
 //
 // = AUTHOR
 //    Doug Schmidt and Per Andersson
@@ -37,7 +37,7 @@ class ACE_Server_Logging_Handler_T : public ACE_Svc_Handler<ACE_PEER_STREAM_2, A
   //     functionality.
 public:  
   ACE_Server_Logging_Handler_T (ACE_Thread_Manager *,
-                               LOG_MESSAGE_RECEIVER const& receiver );
+				const LOG_MESSAGE_RECEIVER &receiver );
   // Constructor.
 
 
@@ -49,8 +49,8 @@ protected:
   // Receive the logging record from a client.
 
   int open_common (void);
-  // Common parts of open function, sets hostname and diables NONBLOCK
-  // in peer called from derived classes open method.
+  // Common parts of open function, sets hostname and diables NONBLOCK in peer
+  // called from derived classes open method.
   
 #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
   static COUNTER request_count_;
@@ -59,11 +59,11 @@ protected:
 
   Base_Optimizer<LOG_MESSAGE_RECEIVER, ACE_CString> receiver_;
   
-  const char *host_name (void) {return receiver_.m_.fast_rep ();}
+  const char *host_name (void) { return receiver_.m_.fast_rep (); }
   // Name of the host we are connected to.
   
-  LOG_MESSAGE_RECEIVER &receiver (void) { return receiver_; }
-  // The receiver of log records.
+  LOG_MESSAGE_RECEIVER &receiver (void){ return receiver_; }
+  // The receiver of log records
 };
 
 #if !defined (ACE_HAS_TLI)
@@ -84,7 +84,7 @@ class ACE_Server_Logging_Acceptor_T : public ACE_Strategy_Acceptor<SERVER_LOGGIN
   //     easily be factored into the <ACE_Strategy_Acceptor>.
 {
 public:
-  ACE_Server_Logging_Acceptor_T (void);
+  ACE_Server_Logging_Acceptor_T (void); 
   virtual int init (int argc, char *argv[]);
   // Dynamic linking hook.
 
@@ -94,17 +94,17 @@ protected:
   
   virtual int make_svc_handler (SERVER_LOGGING_HANDLER *&);
   // Factory that creates a new <SERVER_LOGGING_HANDLER>.  We need to
-  // specialize this since the <LOG_MESSAGE_RECEIVER> held by this
-  // Acceptor must be passed into the <SERVER_LOGGING_HANDLER>.
+  // specialize this since the <LOG_MESSAGE_RECEIVER> held by this Acceptor must be
+  // passed into the <SERVER_LOGGING_HANDLER>.
 
 private:
   Base_Optimizer<LOG_MESSAGE_RECEIVER, SCHEDULE_STRATEGY> receiver_;
   
-  SCHEDULE_STRATEGY &scheduling_strategy (void) { return receiver_.m_; }
+  SCHEDULE_STRATEGY& scheduling_strategy (void){ return receiver_.m_; }
   // The scheduling strategy for the service.
   
   LOG_MESSAGE_RECEIVER &receiver (void) { return receiver_; }
-  // The receiver of log records.
+  // The receiver of log records
 };
 
 template<class LOG_MESSAGE_RECEIVER> 
@@ -121,8 +121,9 @@ class ACE_Server_Logging_Handler : public ACE_Server_Logging_Handler_T<LOGGING_P
 public:
   ACE_Server_Logging_Handler (ACE_Thread_Manager * = 0);
   ACE_Server_Logging_Handler (ACE_Thread_Manager *,
-                              LOG_MESSAGE_RECEIVER const &receiver);
-  virtual int open (void * = 0);
+			      const LOG_MESSAGE_RECEIVER &receiver);
+                                  
+  virtual int open (void* = 0);
 };
 
 #if !defined (ACE_HAS_THREADS) 
@@ -147,10 +148,17 @@ class ACE_Thr_Server_Logging_Handler : public ACE_Server_Logging_Handler_T<LOGGI
 public:
   ACE_Thr_Server_Logging_Handler (ACE_Thread_Manager * = 0);
   ACE_Thr_Server_Logging_Handler (ACE_Thread_Manager *,
-                                  LOG_MESSAGE_RECEIVER const &receiver);
+				  const LOG_MESSAGE_RECEIVER &receiver);
   virtual int open (void * = 0);
   virtual int svc (void);
 };
 
-#endif /* ACE_SERVER_LOGGING_HANDLER_T_H */
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "Server_Logging_Handler_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
 
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("Server_Logging_Handler_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#endif /* ACE_SERVER_LOGGING_HANDLER_T_H */