ACE/ace/Svc_Handler.cpp

   1 #ifndef ACE_SVC_HANDLER_CPP
   2 #define ACE_SVC_HANDLER_CPP
   3
   4 #include "ace/Svc_Handler.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 # pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #include "ace/OS_NS_sys_time.h"
  11 #include "ace/Object_Manager.h"
  12 #include "ace/Connection_Recycling_Strategy.h"
  13
  14 #include "ace/Dynamic.h"
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 template <typename PEER_STREAM, typename SYNCH_TRAITS> void *
  19 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (size_t, void *p)
  20 {
  21   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (NOOP, 2 parameters)");
  22   return p;
  23 }
  24
  25 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
  26 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
  27 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (void *, void *)
  28 {
  29   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (NOOP, 2 parameters)");
  30   return;
  31 }
  32 #endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
  33
  34 template <typename PEER_STREAM, typename SYNCH_TRAITS> void *
  35 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (size_t n)
  36 {
  37   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new");
  38
  39   ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
  40
  41   if (dynamic_instance == 0)
  42     {
  43       // If this ACE_ASSERT fails, it may be due to running of out TSS
  44       // keys.  Try using ACE_HAS_TSS_EMULATION, or increasing
  45       // ACE_DEFAULT_THREAD_KEYS if already using TSS emulation.
  46       ACE_ASSERT (dynamic_instance != 0);
  47
  48       ACE_throw_bad_alloc;
  49     }
  50   else
  51     {
  52       // Allocate the memory and store it (usually in thread-specific
  53       // storage, depending on config flags).
  54       dynamic_instance->set ();
  55
  56       return ::new char[n];
  57     }
  58 }
  59
  60 #if defined (ACE_HAS_NEW_NOTHROW)
  61 template <typename PEER_STREAM, typename SYNCH_TRAITS> void *
  62 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new (size_t n,
  63                                                           const ACE_nothrow_t&) throw()
  64 {
  65   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator new(nothrow)");
  66
  67   ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
  68
  69   if (dynamic_instance == 0)
  70     {
  71       // If this ACE_ASSERT fails, it may be due to running of out TSS
  72       // keys.  Try using ACE_HAS_TSS_EMULATION, or increasing
  73       // ACE_DEFAULT_THREAD_KEYS if already using TSS emulation.
  74       ACE_ASSERT (dynamic_instance != 0);
  75
  76       return 0;
  77     }
  78   else
  79     {
  80       // Allocate the memory and store it (usually in thread-specific
  81       // storage, depending on config flags).
  82       dynamic_instance->set ();
  83
  84       return ::new(ACE_nothrow) char[n];
  85     }
  86 }
  87
  88 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
  89 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
  90 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (void *p,
  91                                          const ACE_nothrow_t&) throw()
  92 {
  93   ACE_TRACE("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete(nothrow)");
  94   ::delete [] static_cast <char *> (p);
  95 }
  96 #endif /* ACE_LACKS_PLACEMENT_OPERATOR_DELETE */
  97
  98 #endif /* ACE_HAS_NEW_NOTHROW */
  99
 100 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 101 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::destroy (void)
 102 {
 103   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::destroy");
 104
 105   // Only delete ourselves if we're not owned by a module and have
 106   // been allocated dynamically.
 107   if (this->mod_ == 0 && this->dynamic_ && this->closing_ == false)
 108     // Will call the destructor, which automatically calls <shutdown>.
 109     // Note that if we are *not* allocated dynamically then the
 110     // destructor will call <shutdown> automatically when it gets run
 111     // during cleanup.
 112     delete this;
 113 }
 114
 115 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 116 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete (void *obj)
 117 {
 118   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::operator delete");
 119   // You cannot delete a 'void*' (X3J16/95-0087 5.3.5.3), but we know
 120   // the pointer was created using new char[] (see operator new code),
 121   // so we use a cast:
 122   ::delete [] static_cast <char *> (obj);
 123 }
 124
 125 // Default constructor.
 126
 127 template <typename PEER_STREAM, typename SYNCH_TRAITS>
 128 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Svc_Handler (ACE_Thread_Manager *tm,
 129                                                           ACE_Message_Queue<SYNCH_TRAITS> *mq,
 130                                                           ACE_Reactor *reactor)
 131   : ACE_Task<SYNCH_TRAITS> (tm, mq),
 132     closing_ (false),
 133     recycler_ (0),
 134     recycling_act_ (0)
 135 {
 136   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Svc_Handler");
 137
 138   this->reactor (reactor);
 139
 140   // This clever idiom transparently checks if we were allocated
 141   // dynamically.  This information is used by the <destroy> method to
 142   // decide if we need to delete <this>...  The idiom is based on a
 143   // paper by Michael van Rooyen (mrooyen@cellnet.co.uk) that appeared
 144   // in the April '96 issue of the C++ Report.  We've spruced it up to
 145   // work correctly in multi-threaded programs by using our ACE_TSS
 146   // class.
 147   this->dynamic_ = ACE_Dynamic::instance ()->is_dynamic ();
 148
 149   if (this->dynamic_)
 150     // Make sure to reset the flag.
 151     ACE_Dynamic::instance ()->reset ();
 152 }
 153
 154 // Default behavior for a ACE_Svc_Handler object is to be registered
 155 // with the ACE_Reactor (thereby ensuring single threading).
 156
 157 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 158 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::open (void *)
 159 {
 160   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::open");
 161 #if defined (ACELIB_DEBUGGING)
 162   ACE_TCHAR buf[BUFSIZ];
 163   ACE_PEER_STREAM_ADDR client_addr;
 164
 165   if (this->peer_.get_remote_addr (client_addr) == -1)
 166     ACELIB_ERROR_RETURN ((LM_ERROR,
 167                        ACE_TEXT ("%p\n"),
 168                        ACE_TEXT ("get_remote_addr")),
 169                       -1);
 170   else if (client_addr.addr_to_string (buf, sizeof buf) == -1)
 171     ACELIB_ERROR_RETURN ((LM_ERROR,
 172                        ACE_TEXT ("%p\n"),
 173                        ACE_TEXT ("can't obtain peer's address")),
 174                       -1);
 175   ACELIB_DEBUG ((LM_DEBUG,
 176               ACE_TEXT ("connected to %s on fd %d\n"),
 177               buf,
 178               this->peer_.get_handle ()));
 179 #endif /* ACELIB_DEBUGGING */
 180   if (this->reactor ()
 181       && this->reactor ()->register_handler
 182       (this,
 183        ACE_Event_Handler::READ_MASK) == -1)
 184     ACELIB_ERROR_RETURN ((LM_ERROR,
 185                        ACE_TEXT ("%p\n"),
 186                        ACE_TEXT ("unable to register client handler")),
 187                       -1);
 188   return 0;
 189 }
 190
 191 // Perform termination activities.
 192
 193 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 194 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::shutdown (void)
 195 {
 196   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::shutdown");
 197
 198   // Deregister this handler with the ACE_Reactor.
 199   if (this->reactor ())
 200     {
 201       ACE_Reactor_Mask mask = ACE_Event_Handler::ALL_EVENTS_MASK |
 202         ACE_Event_Handler::DONT_CALL;
 203
 204       // Make sure there are no timers.
 205       this->reactor ()->cancel_timer (this);
 206
 207       if (this->peer ().get_handle () != ACE_INVALID_HANDLE)
 208         // Remove self from reactor.
 209         this->reactor ()->remove_handler (this, mask);
 210     }
 211
 212   // Remove self from the recycler.
 213   if (this->recycler ())
 214     this->recycler ()->purge (this->recycling_act_);
 215
 216   this->peer ().close ();
 217 }
 218
 219 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 220 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::cleanup_hint (void **act_holder)
 221 {
 222   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::cleanup_hint");
 223
 224   // Remove as hint.
 225   if (this->recycler ())
 226     this->recycler ()->cleanup_hint (this->recycling_act_,
 227                                      act_holder);
 228 }
 229
 230 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 231 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump (void) const
 232 {
 233 #if defined (ACE_HAS_DUMP)
 234   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump");
 235
 236   this->peer_.dump ();
 237   ACELIB_DEBUG ((LM_DEBUG,
 238               "dynamic_ = %d\n",
 239               this->dynamic_));
 240   ACELIB_DEBUG ((LM_DEBUG,
 241               "closing_ = %d\n",
 242               this->closing_));
 243   ACELIB_DEBUG ((LM_DEBUG,
 244               "recycler_ = %d\n",
 245               this->recycler_));
 246   ACELIB_DEBUG ((LM_DEBUG,
 247               "recycling_act_ = %d\n",
 248               this->recycling_act_));
 249 #endif /* ACE_HAS_DUMP */
 250 }
 251
 252 template <typename PEER_STREAM, typename SYNCH_TRAITS> PEER_STREAM &
 253 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::peer (void) const
 254 {
 255   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::peer");
 256   return (PEER_STREAM &) this->peer_;
 257 }
 258
 259 // Extract the underlying I/O descriptor.
 260
 261 template <typename PEER_STREAM, typename SYNCH_TRAITS> ACE_HANDLE
 262 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::get_handle (void) const
 263 {
 264   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::get_handle");
 265   return this->peer_.get_handle ();
 266 }
 267
 268 // Set the underlying I/O descriptor.
 269
 270 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 271 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::set_handle (ACE_HANDLE h)
 272 {
 273   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::set_handle");
 274   this->peer_.set_handle (h);
 275 }
 276
 277 template <typename PEER_STREAM, typename SYNCH_TRAITS>
 278 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::~ACE_Svc_Handler (void)
 279 {
 280   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::~ACE_Svc_Handler");
 281
 282   if (this->closing_ == false)
 283     {
 284       // We're closing down now, so make sure not to call ourselves
 285       // recursively via other calls to handle_close() (e.g., from the
 286       // Timer_Queue).
 287       this->closing_ = true;
 288
 289       this->shutdown ();
 290     }
 291 }
 292
 293 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 294 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_close (ACE_HANDLE,
 295                                                        ACE_Reactor_Mask)
 296 {
 297   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_close");
 298
 299   if (this->reference_counting_policy ().value () ==
 300       ACE_Event_Handler::Reference_Counting_Policy::DISABLED)
 301     {
 302       this->destroy ();
 303     }
 304
 305   return 0;
 306 }
 307
 308 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 309 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout (const ACE_Time_Value &,
 310                                                          const void *)
 311 {
 312   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout");
 313   return this->handle_close ();
 314 }
 315
 316 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 317 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::close (u_long)
 318 {
 319   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::close");
 320   return this->handle_close ();
 321 }
 322
 323 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 324 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::init (int /* argc */,
 325                                                ACE_TCHAR * /* argv */[])
 326 {
 327   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::init");
 328   return -1;
 329 }
 330
 331 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 332 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::fini (void)
 333 {
 334   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::fini");
 335   return -1;
 336 }
 337
 338 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 339 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::info (ACE_TCHAR **, size_t) const
 340 {
 341   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::info");
 342   return -1;
 343 }
 344
 345 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 346 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::idle (u_long flags)
 347 {
 348   if (this->recycler ())
 349     return this->recycler ()->cache (this->recycling_act_);
 350   else
 351     return this->close (flags);
 352 }
 353
 354 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 355 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle_state (ACE_Recyclable_State new_state)
 356 {
 357   if (this->recycler ())
 358     return this->recycler ()->recycle_state (this->recycling_act_,
 359                                              new_state);
 360
 361   return 0;
 362 }
 363
 364 template <typename PEER_STREAM, typename SYNCH_TRAITS> ACE_Recyclable_State
 365 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle_state (void) const
 366 {
 367   if (this->recycler ())
 368     return this->recycler ()->recycle_state (this->recycling_act_);
 369
 370   return ACE_RECYCLABLE_UNKNOWN;
 371 }
 372
 373 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 374 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler (ACE_Connection_Recycling_Strategy *recycler,
 375                                                    const void *recycling_act)
 376 {
 377   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler");
 378   this->recycler_ = recycler;
 379   this->recycling_act_ = recycling_act;
 380 }
 381
 382 template <typename PEER_STREAM, typename SYNCH_TRAITS> ACE_Connection_Recycling_Strategy *
 383 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler (void) const
 384 {
 385   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycler");
 386   return this->recycler_;
 387 }
 388
 389 template <typename PEER_STREAM, typename SYNCH_TRAITS> const void *
 390 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycling_act (void) const
 391 {
 392   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycling_act");
 393   return this->recycling_act_;
 394 }
 395
 396 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 397 ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle (void *)
 398 {
 399   ACE_TRACE ("ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::recycle");
 400   // By default, the object is ready and willing to be recycled.
 401   return 0;
 402 }
 403
 404 template <typename PEER_STREAM, typename SYNCH_TRAITS>
 405 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::~ACE_Buffered_Svc_Handler (void)
 406 {
 407   this->flush ();
 408 }
 409
 410 template <typename PEER_STREAM, typename SYNCH_TRAITS>
 411 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Buffered_Svc_Handler (ACE_Thread_Manager *tm,
 412                                                                             ACE_Message_Queue<SYNCH_TRAITS> *mq,
 413                                                                             ACE_Reactor *reactor,
 414                                                                             size_t maximum_buffer_size,
 415                                                                             ACE_Time_Value *timeout)
 416   : ACE_Svc_Handler<PEER_STREAM, SYNCH_TRAITS> (tm, mq, reactor),
 417     maximum_buffer_size_ (maximum_buffer_size),
 418     current_buffer_size_ (0),
 419     timeoutp_ (timeout)
 420 {
 421   ACE_TRACE ("ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::ACE_Buffered_Svc_Handler");
 422
 423   if (this->timeoutp_ != 0)
 424     {
 425       this->interval_ = *timeout;
 426       this->next_timeout_ = ACE_OS::gettimeofday () + this->interval_;
 427     }
 428 }
 429
 430 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 431 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::put (ACE_Message_Block *mb,
 432                                                           ACE_Time_Value *tv)
 433 {
 434   ACE_GUARD_RETURN (typename SYNCH_TRAITS::MUTEX, m, this->msg_queue ()->lock (), -1);
 435
 436   // Enqueue <mb> onto the message queue.
 437   if (this->putq (mb, tv) == -1)
 438     return -1;
 439   else
 440     {
 441       // Update the current number of bytes on the queue.
 442       this->current_buffer_size_ += mb->total_size ();
 443
 444       // Flush the buffer when the number of bytes exceeds the maximum
 445       // buffer size or when the timeout period has elapsed.
 446       if (this->current_buffer_size_ >= this->maximum_buffer_size_
 447           || (this->timeoutp_ != 0
 448               && this->next_timeout_ <= ACE_OS::gettimeofday ()))
 449         return this->flush_i ();
 450       else
 451         return 0;
 452     }
 453 }
 454
 455 // Flush the buffer.
 456
 457 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 458 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::flush (void)
 459 {
 460   ACE_GUARD_RETURN (typename SYNCH_TRAITS::MUTEX, m, this->msg_queue ()->lock (), -1);
 461
 462   return this->flush_i ();
 463 }
 464
 465 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 466 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::flush_i (void)
 467 {
 468   ACE_Message_Queue_Iterator<SYNCH_TRAITS> iterator (*this->msg_queue ());
 469   ACE_Message_Block *mblk = 0;
 470   ssize_t result = 0;
 471
 472   // Get the first <ACE_Message_Block> so that we can write everything
 473   // out via the <send_n>.
 474   if (iterator.next (mblk) != 0)
 475     result = this->peer ().send_n (mblk);
 476
 477   // This method assumes the caller holds the queue's lock!
 478   if (result != -1)
 479     this->msg_queue ()->flush_i ();
 480
 481   if (this->timeoutp_ != 0)
 482     // Update the next timeout period by adding the interval.
 483     this->next_timeout_ += this->interval_;
 484
 485   this->current_buffer_size_ = 0;
 486
 487   return result;
 488 }
 489
 490 template <typename PEER_STREAM, typename SYNCH_TRAITS> void
 491 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump (void) const
 492 {
 493 #if defined (ACE_HAS_DUMP)
 494   ACE_TRACE ("ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump");
 495
 496   ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::dump ();
 497   ACELIB_DEBUG ((LM_DEBUG,
 498               "maximum_buffer_size_ = %d\n",
 499               this->maximum_buffer_size_));
 500   ACELIB_DEBUG ((LM_DEBUG,
 501               "current_buffer_size_ = %d\n",
 502               this->current_buffer_size_));
 503   if (this->timeoutp_ != 0)
 504     ACELIB_DEBUG ((LM_DEBUG,
 505                 "next_timeout_.sec = %d, next_timeout_.usec = %d\n",
 506                 this->next_timeout_.sec (),
 507                 this->next_timeout_.usec ()));
 508 #endif /* ACE_HAS_DUMP */
 509 }
 510
 511 template <typename PEER_STREAM, typename SYNCH_TRAITS> int
 512 ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout (const ACE_Time_Value &,
 513                                                                      const void *)
 514 {
 515   ACE_TRACE ("ACE_Buffered_Svc_Handler<PEER_STREAM, SYNCH_TRAITS>::handle_timeout");
 516   return 0;
 517 }
 518
 519 ACE_END_VERSIONED_NAMESPACE_DECL
 520
 521 #endif /* ACE_SVC_HANDLER_CPP */