*** empty log message ***

6 files changed, 291 insertions, 136 deletions

diff --git a/netsvcs/lib/Log_Message_Receiver.cpp b/netsvcs/lib/Log_Message_Receiver.cpp
index ff11b2277b3..45752d092e2 100644
--- a/netsvcs/lib/Log_Message_Receiver.cpp
+++ b/netsvcs/lib/Log_Message_Receiver.cpp
@@ -11,8 +11,8 @@ Static_Log_Message_Receiver<ACE_SYNCH_2>::log_record (char const *hostname,
 						      ACE_Log_Record &record)
 {
 #if defined (ACE_HAS_THREADS)
-    static ACE_SYNCH_MUTEX lock_;
-    ACE_Guard<ACE_SYNCH_MUTEX> guard (lock_);
+    static ACE_SYNCH_MUTEX_T lock_;
+    ACE_Guard<ACE_SYNCH_MUTEX_T> guard (lock_);
 #endif /* ACE_HAS_THREADS */
    
   record.print (hostname, 0, stderr);
@@ -21,6 +21,8 @@ Static_Log_Message_Receiver<ACE_SYNCH_2>::log_record (char const *hostname,
 #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_;
+#else
+static ACE_SYNCH_MUTEX global_copy_lock_;
 #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
 
 template<ACE_SYNCH_1> inline 
@@ -41,12 +43,15 @@ Log_Message_Receiver_Impl<ACE_SYNCH_2> *
 Log_Message_Receiver_Impl<ACE_SYNCH_2>::attach (Log_Message_Receiver_Impl<ACE_SYNCH_2> *body)
 {
   assert(body != 0);
-  
-#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 */
+
+#if defined (ACE_HAS_THREADS)  
+  #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
+  Guard guard (copy_lock_);
+  #else
+  // Use the "body"s print lock as copy lock.
+  ACE_Guard<ACE_SYNCH_MUTEX> guard (global_copy_lock_);  
+  #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
+#endif
   ++body->count_;
   return body;
 }
@@ -56,21 +61,16 @@ Log_Message_Receiver_Impl<ACE_SYNCH_2>::detach(Log_Message_Receiver_Impl<ACE_SYN
 {
   assert (body != 0);
   
-#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
-  ACE_Guard<ACE_SYNCH_MUTEX> guard (copy_lock_);
-  
+#if defined (ACE_HAS_THREADS)  
+  #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
+  Guard guard (copy_lock_);
+  #else
+  // Use the "body"s print lock as copy lock.
+  ACE_Guard<ACE_SYNCH_MUTEX> guard (global_copy_lock_);  
+  #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
+#endif
   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
@@ -78,7 +78,7 @@ template<ACE_SYNCH_1> inline void
 Log_Message_Receiver_Impl<ACE_SYNCH_2>::log_record (char const *hostname,
 						    ACE_Log_Record &record)
 {
-  ACE_MT (ACE_Guard<ACE_SYNCH_MUTEX> guard (print_lock_));
+  ACE_MT (Guard guard (print_lock_));
   record.print (hostname, 0, stderr);
 }
 
diff --git a/netsvcs/lib/Log_Message_Receiver.h b/netsvcs/lib/Log_Message_Receiver.h
index a4485f5dece..20ce767c276 100644
--- a/netsvcs/lib/Log_Message_Receiver.h
+++ b/netsvcs/lib/Log_Message_Receiver.h
@@ -20,48 +20,148 @@
 #include "ace/Log_Record.h"
 #include "ace/Synch.h"
 
+// ==========================================================================//
+//------------- General Requirements on a Log Message Receiver --------------//
+// ==========================================================================//
+//
+//  The requiremnts on a log manager receiver, T, are quite simple.
+//  1: There must exist one "log_record" member function with the following
+//     prototype:
+//        void log_record(char const* hostname,
+//                        ACE_Log_Record &record);
+//
+//  2: There must exist a public destructor.
+//  3: There must exist a public copy constructor.
+//  4: There must exist a default constructor. (for now)
+//
+//
+//  The semantics are also simple. A log message receiver should
+//  behave as an accessor object (smart pointer or envelope class). 
+//  It should be very cheap to copy and the should be no noticeable 
+//  difference when using either the new copy or the old log message 
+//  receiver.
+//
+//  Methods:
+//    void log_record(char const* hostname,
+//                    ACE_Log_Record& record)
+//  Description: 
+//    Processes the log record "record" from the host "hostname"
+//  Precondition: 
+//    hostname != 0;
+//  Requirements:
+//    Record must be a valid ACE_Log_Record.
+//
+// ==========================================================================//
+
+// ==========================================================================//
+// ------------ General Description of a Log Message Receiver -------------- //
+// ==========================================================================//
+//
+//  Log Message Receivers, LRMs, are processing log records. It is the
+//  LRM that writes a log message to stderr, stdout, a log file and maybee
+//  converts some of the log messages to notifications, warnings, alarms
+//  and forwards them to some operation and maintenance system (PATROL).
+//
+//  The client logging handler and server logging handler are responsible
+//  for forwarding, receiving, framing, processing log records. 
+//  That is a very usable service, but it should also be possible to change
+//  how log records are processed without having to rewrite code in 
+//  the server log handler. This code should instead be written as a  
+//  separate entity, a Log Message Receiver. 
+//
+//  A simple LMR should be very easy to write but it should also 
+//  be possible to write more complex LMRs, like one that creates
+//  a new log file each day or keeps a fixed size, round robin,
+//  log file. It should also be possible to have separate LMRs
+//  of the same type that uses differnt log files.
+//
+// ==========================================================================//
+
+
 // Type based log message receiver
 template<ACE_SYNCH_1> 
 class Static_Log_Message_Receiver
-{
+  // = TITLE
+  //  Static_Log_Message_Receiver is a simple log message receiver. It
+  //  has no instance data and only static member functions. Static/typed
+  //  based receivers are best when all LMR should do exactly the same thing.
+  //
+  // = DESCRIPTION
+  //  This class contains a static log_record member function that
+  //  prints the content of log_records on stderr.
 public:
-  static void log_record (char const *hostname, 
-			  ACE_Log_Record &record);
+  static void log_record(const char *hostname, 
+                         ACE_Log_Record &record);
+  // Prints the log_record to stderr using record.print (hostname, 0, stderr).
+  // Serializes the output by using a ACE_SYNCH_MUTEX.
 };
 
+// Instance based log message receiver
+
+// ------------------------ Log_Message_Receiver --------------------------- //
+//
+//  Log_Message_Receiver is little more complicated log message receiver.
+//  It is instance based and have a reference counted implementation.
+//  Log_Message_Receiver is the envelope class for Log_Message_Receiver_Impl.
+//  
+// ------------------------------------------------------------------------- //
+
+
 //Forward declaration
 template<ACE_SYNCH_1> class Log_Message_Receiver_Impl;
 
-// Instance based log message receiver
 template<ACE_SYNCH_1> 
 class Log_Message_Receiver
+  // = TITLE
+  //  Log_Message_Receiver is a little more complicated log message receiver.
+  //  It is instance based and have a reference counted implementation.
+  //  Log_Message_Receiver is the envelope class for Log_Message_Receiver_Impl.
+  //  The difference between Static_Log_Message_Receiver and 
+  //  Log_Message_Receiver is that is possible to have instance data
+  //  in Log_Message_Receiver. 
+  //
+  //  Comment:
+  //  The practical usage of this is limited with the current
+  //  ACE_Server_Logging_Acceptor_T design. Since ACE_Server_Logging_Acceptor_T
+  //  will create the Log_Message_Receiver using the default constructor.
+  //  The main reason for inclusion right now is to ensure that the
+  //  code in ACE_Server_Logging_Handler_T works both with type and instance
+  //  based LMRs.
+  //
+  //
+  // = DESCRIPTION
+  //  This class contains a log_record member function that
+  //  prints the content of log_records on stderr.
 {
 public:
   Log_Message_Receiver (void);
+  // Creates a new Log_Message_Receiver
   Log_Message_Receiver(Log_Message_Receiver<ACE_SYNCH_2> const &rhs);
   ~Log_Message_Receiver (void);
   
   void log_record (const char *hostname,
-		   ACE_Log_Record &record);
-  
+                   ACE_Log_Record &record);  
 private:
   void operator= (const Log_Message_Receiver<ACE_SYNCH_2> &rhs);
   
-  Log_Message_Receiver_Impl<ACE_SYNCH_2> *receiver_impl_;
   // Attributes.
+  Log_Message_Receiver_Impl<ACE_SYNCH_2> *receiver_impl_;
 };
 
+// Implementation with reference count.
+
 template<ACE_SYNCH_1> 
 class Log_Message_Receiver_Impl
 {
   friend class ACE_Shutup_GPlusPlus;  // Turn off g++ warning
 public:
+  // Methods for handling reference count and instance lifetime
   static Log_Message_Receiver_Impl *create (void);
   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 (const char *hostname,
-		   ACE_Log_Record &record);
+                   ACE_Log_Record &record);
 
 private:
   Log_Message_Receiver_Impl (void);
@@ -71,8 +171,10 @@ private:
   Log_Message_Receiver_Impl (const Log_Message_Receiver_Impl<ACE_SYNCH_2> &rhs);
   void operator=(const Log_Message_Receiver_Impl<ACE_SYNCH_2> &rhs);
     
+  typedef ACE_Guard<ACE_SYNCH_MUTEX_T> Guard;
+  // Attributes
   int count_;
-  ACE_SYNCH_MUTEX print_lock_;
+  ACE_SYNCH_MUTEX_T print_lock_;
 
 #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
   static ACE_SYNCH_MUTEX_T copy_lock_;
diff --git a/netsvcs/lib/Server_Logging_Handler.cpp b/netsvcs/lib/Server_Logging_Handler.cpp
index 06c997d709b..0fa8089a820 100644
--- a/netsvcs/lib/Server_Logging_Handler.cpp
+++ b/netsvcs/lib/Server_Logging_Handler.cpp
@@ -26,88 +26,87 @@ template class ACE_Schedule_All_Reactive_Strategy<Null_Synch_Logging_Handler_Sta
 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> >;
+                                             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>;
-
-  template class ACE_Svc_Handler<LOGGING_PEER_STREAM, ACE_SYNCH>;
+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, u_long, ACE_NULL_SYNCH, Synch_Receiver>;
+
+  #if defined (ACE_HAS_THREADS) 
+  template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_MT_SYNCH, Synch_Static_Receiver>;
+  template class ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_MT_SYNCH, Synch_Receiver>;
+  template class Log_Message_Receiver_Impl<ACE_MT_SYNCH>;
+  #endif /* ACE_HAS_THREADS */
+
+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>;
+
+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>;
-    // else LOGGING_PEER_STREAM is ACE_SOCK_STREAM,
-    // and the specialization would be
-    //   template class ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
-    // That specialization is in TS_Server_Handler.cpp, so we don't need it
-    // here.
+  template class ACE_Svc_Handler<LOGGING_PEER_STREAM, ACE_NULL_SYNCH>;
+  // else LOGGING_PEER_STREAM is ACE_SOCK_STREAM,
+  // and the specialization would be
+  //   template class ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
+  // 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 */
 #endif /* ACE_TEMPLATES_REQUIRE_SPECIALIZATION */
 
 #endif /* ACE_SERVER_LOGGING_HANDLERT_C */
diff --git a/netsvcs/lib/Server_Logging_Handler.h b/netsvcs/lib/Server_Logging_Handler.h
index 91a473caf40..4a787c5e2d4 100644
--- a/netsvcs/lib/Server_Logging_Handler.h
+++ b/netsvcs/lib/Server_Logging_Handler.h
@@ -1,53 +1,84 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+// 
+// = FILENAME
+//    Server_Logging_Handler.h 
+//
+// = AUTHOR
+//    Doug Schmidt and Per Andersson
+// 
+// ============================================================================
 #if !defined (ACE_SERVER_LOGGING_HANDLER_H)
 #define ACE_SERVER_LOGGING_HANDLER_H
 
 #include "Log_Message_Receiver.h"
 #include "Server_Logging_Handler_T.h"
 
-// Type based log message receivers.
+// typedefs for Logging Handlers & acceptors using a static
+// type based log message receivers.
+
+// Synched and NULL synched 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;
 
+// NULL synched logging handler
 typedef ACE_Server_Logging_Handler<Null_Synch_Static_Receiver> Null_Synch_Logging_Handler_Static_Receiver;
 
+// synched logging handlers
 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;
 
+// NULL synched logging acceptor
 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_Static_Receiver, 
+                                      ACE_Schedule_All_Reactive_Strategy<Null_Synch_Logging_Handler_Static_Receiver> > 
                   Null_Synch_Logging_Handler_Static_Receiver_Acceptor;                  
 
+// NULL synched logging acceptors
 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_Static_Receiver, 
+                                      ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Static_Receiver> > 
                   Synch_Logging_Handler_Static_Receiver_Acceptor;                  
 
 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_Static_Receiver, 
+                                      ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Static_Receiver> > 
                   Synch_Thr_Logging_Handler_Static_Receiver_Acceptor;                  
 
-// Instance based log message receivers 
+// typedefs for Logging Handlers & acceptors using a instance
+// based log message receivers.
+
+// Synched message receivers
 typedef Log_Message_Receiver<ACE_LOGGER_SYNCH> Synch_Receiver;
 
+// synched logging handlers
 typedef ACE_Server_Logging_Handler<Synch_Receiver> Synch_Logging_Handler_Receiver;
 typedef ACE_Thr_Server_Logging_Handler<Synch_Receiver> Synch_Thr_Logging_Handler_Receiver;
                                  
+// synched logging acceptors
 typedef ACE_Server_Logging_Acceptor_T<Synch_Logging_Handler_Receiver, 
-                                     Synch_Receiver, 
-                                     ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Receiver> > 
+                                      Synch_Receiver, 
+                                      ACE_Schedule_All_Reactive_Strategy<Synch_Logging_Handler_Receiver> > 
                   Synch_Logging_Handler_Receiver_Acceptor;                  
 
 typedef ACE_Server_Logging_Acceptor_T<Synch_Thr_Logging_Handler_Receiver, 
-                                     Synch_Receiver,
-                                     ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Receiver> > 
+                                      Synch_Receiver,
+                                      ACE_Schedule_All_Threaded_Strategy<Synch_Thr_Logging_Handler_Receiver> > 
                   Synch_Thr_Logging_Handler_Receiver_Acceptor;                  
 
+
 // Define external acceptors
+
+// acceptors that use static/type based log message receiver
 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;
 
+// acceptors that use instance based log message receiver
 //typedef  Synch_Logging_Handler_Receiver_Acceptor ACE_Server_Logging_Acceptor;
 //typedef  Synch_Thr_Logging_Handler_Receiver_Acceptor ACE_Thr_Server_Logging_Acceptor;
 
diff --git a/netsvcs/lib/Server_Logging_Handler_T.cpp b/netsvcs/lib/Server_Logging_Handler_T.cpp
index 7df7cd220b1..d330b0a8eac 100644
--- a/netsvcs/lib/Server_Logging_Handler_T.cpp
+++ b/netsvcs/lib/Server_Logging_Handler_T.cpp
@@ -19,7 +19,9 @@ 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))
+    : receiver_ (receiver, ACE_CString (" ", 1)) // Initialize the CString to something
+                                                 // that is not the empty string to avoid
+                                                 // problmes when calling fast_rep()
 {
 }
 
@@ -75,9 +77,11 @@ ACE_Server_Logging_Handler_T<ACE_PEER_STREAM_2, COUNTER, ACE_SYNCH_2, LMR>::hand
 	lp.decode ();
 
 	if (lp.length () == n)
-	  {
-      receiver().log_record(this->host_name(), lp);
-	  }
+  {
+    receiver().log_record(this->host_name(), lp);
+    // Send the log record to the log message receiver for
+    // processing.
+  }
 	else
 	  ACE_ERROR ((LM_ERROR, "error, lp.length = %d, n = %d\n",
 		     lp.length (), n));
diff --git a/netsvcs/lib/Server_Logging_Handler_T.h b/netsvcs/lib/Server_Logging_Handler_T.h
index 694804d0dae..6e2118bfd88 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.h 
+//    Server_Logging_Handler_T.h 
 //
 // = AUTHOR
 //    Doug Schmidt and Per Andersson
@@ -28,9 +28,10 @@ template <ACE_PEER_STREAM_1, class COUNTER, ACE_SYNCH_1, class LOG_MESSAGE_RECEI
 class ACE_Server_Logging_Handler_T : 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_T> receives, frames, and processes logging
-  //    records.
+  //    Product object created by an <ACE_Server_Logging_Acceptor_T>.  An
+  //    <ACE_Server_Logging_Handler_T> receives, and frames logging
+  //    records. The logging record is then processed by the 
+  //    <LOG_MESSAGE_RECEIVER>
   // 
   // = DESCRIPTION
   //     Defines the classes that perform server logging daemon
@@ -58,6 +59,9 @@ protected:
 #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
 
   Base_Optimizer<LOG_MESSAGE_RECEIVER, ACE_CString> receiver_;
+  // Packs a LOG_MESSAGE_RECEIVER and ACE_CString attribute
+  // together in a optimized fashion. The LOG_MESSAGE_RECEIVER class 
+  // is often a class with no instance data.
   
   const char *host_name (void) { return receiver_.m_.fast_rep (); }
   // Name of the host we are connected to.
@@ -77,7 +81,9 @@ protected:
 template<class SERVER_LOGGING_HANDLER, class LOG_MESSAGE_RECEIVER, class SCHEDULE_STRATEGY>
 class ACE_Server_Logging_Acceptor_T : public ACE_Strategy_Acceptor<SERVER_LOGGING_HANDLER, LOGGING_PEER_ACCEPTOR>
   // = TITLE
-  //     This class implements the ACE single-threaded logging service.
+  //     Factory that creates <SERVER_LOGGING_HANDLER>s scheduled with
+  //     <SCHEDULE_STRATEGY> and logging records proccessed by a
+  //     <LOG_MESSAGE_RECEIVER>
   //
   // = DESCRIPTION
   //     This class contains the service-specific methods that can't
@@ -95,10 +101,23 @@ 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>.
+  // passed into the <SERVER_LOGGING_HANDLER>. 
 
 private:
+  // At the moment each ACE_Server_Logging_Acceptor_T contains
+  // a <LOG_MESSAGE_RECEIVER> attribute that is passed to the
+  // <SERVER_LOGGING_HANDLER> at construction. A better idea might 
+  // be to have accessor class as template argument. The accessor
+  // should be a factory/strategy that hands the 
+  // ACE_Server_Logging_Acceptor_T instance references
+  // to a <LOG_MESSAGE_RECEIVER>. This makes it possible
+  // to change how <LOG_MESSAGE_RECEIVER> are created without chaning the
+  // ACE_Server_Logging_Acceptor_T code.
+  
   Base_Optimizer<LOG_MESSAGE_RECEIVER, SCHEDULE_STRATEGY> receiver_;
+  // Packs a LOG_MESSAGE_RECEIVER and ACE_CString attribute
+  // together in a optimized fashion. The LOG_MESSAGE_RECEIVER class 
+  // is often a class with no instance data.
   
   SCHEDULE_STRATEGY& scheduling_strategy (void){ return receiver_.m_; }
   // The scheduling strategy for the service.
@@ -111,12 +130,12 @@ template<class LOG_MESSAGE_RECEIVER>
 class ACE_Server_Logging_Handler : public ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, u_long, ACE_NULL_SYNCH, LOG_MESSAGE_RECEIVER> 
   // = TITLE
   //    Product object created by a 
-  //    <ACE_Server_Logging_Acceptor<ACE_Server_Logging_Handler> >.  An
-  //    <ACE_Server_Logging_Handler> receives, frames, and processes
-  //    logging records.
+  //    <ACE_Server_Logging_Acceptor_T<ACE_Server_Logging_Handler> >.  An
+  //    <ACE_Server_Logging_Handler> receives, frames. The logging record 
+  //    is then processed by the <LOG_MESSAGE_RECEIVER>
   //
   // = DESCRIPTION
-  //     Each client is handled in its own separate thread.
+  //     All clients are handled in the same thread.
 {
 public:
   ACE_Server_Logging_Handler (ACE_Thread_Manager * = 0);
@@ -138,9 +157,9 @@ template<class LOG_MESSAGE_RECEIVER>
 class ACE_Thr_Server_Logging_Handler : public ACE_Server_Logging_Handler_T<LOGGING_PEER_STREAM, ACE_LOGGER_COUNTER, ACE_LOGGER_SYNCH, LOG_MESSAGE_RECEIVER> 
   // = TITLE
   //    Product object created by a 
-  //    <ACE_Server_Logging_Acceptor<ACE_Thr_Server_Logging_Handler> >.  An
-  //    <ACE_Thr_Server_Logging_Handler> receives, frames, and processes
-  //    logging records.
+  //    <ACE_Server_Logging_Acceptor_T<ACE_Thr_Server_Logging_Handler> >.  An
+  //    <ACE_Thr_Server_Logging_Handler> receives, frames. The logging record is then processed by the 
+  //    <LOG_MESSAGE_RECEIVER>
   //
   // = DESCRIPTION
   //     Each client is handled in its own separate thread.