00001
00002
00003 #ifndef ACE_SVC_HANDLER_CPP
00004 #define ACE_SVC_HANDLER_CPP
00005
00006 #include "ace/Svc_Handler.h"
00007
00008 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00009 # pragma once
00010 #endif
00011
00012 #include "ace/OS_NS_sys_time.h"
00013 #include "ace/Object_Manager.h"
00014 #include "ace/Connection_Recycling_Strategy.h"
00015
00016 #include "ace/Dynamic.h"
00017
00018 #define PR_ST_1 ACE_PEER_STREAM_1
00019 #define PR_ST_2 ACE_PEER_STREAM_2
00020
00021 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00022
00023 template <PR_ST_1, ACE_SYNCH_DECL> void *
00024 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t, void *p)
00025 {
00026 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (NOOP, 2 parameters)");
00027 return p;
00028 }
00029
00030 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
00031 template <PR_ST_1, ACE_SYNCH_DECL> void
00032 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *, void *)
00033 {
00034 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (NOOP, 2 parameters)");
00035 return;
00036 }
00037 #endif
00038
00039 template <PR_ST_1, ACE_SYNCH_DECL> void *
00040 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t n)
00041 {
00042 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new");
00043
00044 ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
00045
00046 if (dynamic_instance == 0)
00047 {
00048
00049
00050
00051 ACE_ASSERT (dynamic_instance != 0);
00052
00053 ACE_throw_bad_alloc;
00054 }
00055 else
00056 {
00057
00058
00059 dynamic_instance->set ();
00060
00061 return ::new char[n];
00062 }
00063 }
00064
00065 #if defined (ACE_HAS_NEW_NOTHROW)
00066 template <PR_ST_1, ACE_SYNCH_DECL> void *
00067 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new (size_t n,
00068 const ACE_nothrow_t&) throw()
00069 {
00070 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator new(nothrow)");
00071
00072 ACE_Dynamic *const dynamic_instance = ACE_Dynamic::instance ();
00073
00074 if (dynamic_instance == 0)
00075 {
00076
00077
00078
00079 ACE_ASSERT (dynamic_instance != 0);
00080
00081 return 0;
00082 }
00083 else
00084 {
00085
00086
00087 dynamic_instance->set ();
00088
00089 return ::new(ACE_nothrow) char[n];
00090 }
00091 }
00092
00093 #if !defined (ACE_LACKS_PLACEMENT_OPERATOR_DELETE)
00094 template <PR_ST_1, ACE_SYNCH_DECL> void
00095 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *p,
00096 const ACE_nothrow_t&) throw()
00097 {
00098 ACE_TRACE
00099 ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete(nothrow)");
00100 ::delete [] static_cast <char *> (p);
00101 }
00102 #endif
00103
00104 #endif
00105
00106 template <PR_ST_1, ACE_SYNCH_DECL> void
00107 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy (void)
00108 {
00109 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::destroy");
00110
00111
00112
00113 if (this->mod_ == 0 && this->dynamic_ && this->closing_ == false)
00114
00115
00116
00117
00118 delete this;
00119 }
00120
00121 template <PR_ST_1, ACE_SYNCH_DECL> void
00122 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete (void *obj)
00123 {
00124 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::operator delete");
00125
00126
00127
00128 ::delete [] static_cast <char *> (obj);
00129 }
00130
00131
00132
00133 template <PR_ST_1, ACE_SYNCH_DECL>
00134 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler (ACE_Thread_Manager *tm,
00135 ACE_Message_Queue<ACE_SYNCH_USE> *mq,
00136 ACE_Reactor *reactor)
00137 : ACE_Task<ACE_SYNCH_USE> (tm, mq),
00138 closing_ (false),
00139 recycler_ (0),
00140 recycling_act_ (0)
00141 {
00142 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Svc_Handler");
00143
00144 this->reactor (reactor);
00145
00146
00147
00148
00149
00150
00151
00152
00153 this->dynamic_ = ACE_Dynamic::instance ()->is_dynamic ();
00154
00155 if (this->dynamic_)
00156
00157 ACE_Dynamic::instance ()->reset ();
00158 }
00159
00160
00161
00162
00163 template <PR_ST_1, ACE_SYNCH_DECL> int
00164 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open (void *)
00165 {
00166 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::open");
00167 #if defined (ACE_DEBUGGING)
00168 ACE_TCHAR buf[BUFSIZ];
00169 ACE_PEER_STREAM_ADDR client_addr;
00170
00171 if (this->peer_.get_remote_addr (client_addr) == -1)
00172 ACE_ERROR_RETURN ((LM_ERROR,
00173 ACE_TEXT ("%p\n"),
00174 ACE_TEXT ("get_remote_addr")),
00175 -1);
00176 else if (client_addr.addr_to_string (buf, sizeof buf) == -1)
00177 ACE_ERROR_RETURN ((LM_ERROR,
00178 ACE_TEXT ("%p\n"),
00179 ACE_TEXT ("can't obtain peer's address")),
00180 -1);
00181 ACE_DEBUG ((LM_DEBUG,
00182 ACE_TEXT ("connected to %s on fd %d\n"),
00183 buf,
00184 this->peer_.get_handle ()));
00185 #endif
00186 if (this->reactor ()
00187 && this->reactor ()->register_handler
00188 (this,
00189 ACE_Event_Handler::READ_MASK) == -1)
00190 ACE_ERROR_RETURN ((LM_ERROR,
00191 ACE_TEXT ("%p\n"),
00192 ACE_TEXT ("unable to register client handler")),
00193 -1);
00194 return 0;
00195 }
00196
00197
00198
00199 template <PR_ST_1, ACE_SYNCH_DECL> void
00200 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown (void)
00201 {
00202 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::shutdown");
00203
00204
00205 if (this->reactor ())
00206 {
00207 ACE_Reactor_Mask mask = ACE_Event_Handler::ALL_EVENTS_MASK |
00208 ACE_Event_Handler::DONT_CALL;
00209
00210
00211 this->reactor ()->cancel_timer (this);
00212
00213 if (this->peer ().get_handle () != ACE_INVALID_HANDLE)
00214
00215 this->reactor ()->remove_handler (this, mask);
00216 }
00217
00218
00219 if (this->recycler ())
00220 this->recycler ()->purge (this->recycling_act_);
00221
00222 this->peer ().close ();
00223 }
00224
00225 template <PR_ST_1, ACE_SYNCH_DECL> void
00226 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint (void **act_holder)
00227 {
00228 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::cleanup_hint");
00229
00230
00231 if (this->recycler ())
00232 this->recycler ()->cleanup_hint (this->recycling_act_,
00233 act_holder);
00234 }
00235
00236 template <PR_ST_1, ACE_SYNCH_DECL> void
00237 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
00238 {
00239 #if defined (ACE_HAS_DUMP)
00240 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump");
00241
00242 this->peer_.dump ();
00243 ACE_DEBUG ((LM_DEBUG,
00244 "dynamic_ = %d\n",
00245 this->dynamic_));
00246 ACE_DEBUG ((LM_DEBUG,
00247 "closing_ = %d\n",
00248 this->closing_));
00249 ACE_DEBUG ((LM_DEBUG,
00250 "recycler_ = %d\n",
00251 this->recycler_));
00252 ACE_DEBUG ((LM_DEBUG,
00253 "recycling_act_ = %d\n",
00254 this->recycling_act_));
00255 #endif
00256 }
00257
00258 template <PR_ST_1, ACE_SYNCH_DECL> ACE_PEER_STREAM &
00259 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::peer (void) const
00260 {
00261 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::peer");
00262 return (ACE_PEER_STREAM &) this->peer_;
00263 }
00264
00265
00266
00267 template <PR_ST_1, ACE_SYNCH_DECL> ACE_HANDLE
00268 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::get_handle (void) const
00269 {
00270 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::get_handle");
00271 return this->peer_.get_handle ();
00272 }
00273
00274
00275
00276 template <PR_ST_1, ACE_SYNCH_DECL> void
00277 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::set_handle (ACE_HANDLE h)
00278 {
00279 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::set_handle");
00280 this->peer_.set_handle (h);
00281 }
00282
00283 template <PR_ST_1, ACE_SYNCH_DECL>
00284 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler (void)
00285 {
00286 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Svc_Handler");
00287
00288 if (this->closing_ == false)
00289 {
00290
00291
00292
00293 this->closing_ = true;
00294
00295 this->shutdown ();
00296 }
00297 }
00298
00299 template <PR_ST_1, ACE_SYNCH_DECL> int
00300 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close (ACE_HANDLE,
00301 ACE_Reactor_Mask)
00302 {
00303 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_close");
00304
00305 if (this->reference_counting_policy ().value () ==
00306 ACE_Event_Handler::Reference_Counting_Policy::DISABLED)
00307 {
00308 this->destroy ();
00309 }
00310
00311 return 0;
00312 }
00313
00314 template <PR_ST_1, ACE_SYNCH_DECL> int
00315 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout (const ACE_Time_Value &,
00316 const void *)
00317 {
00318 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
00319 return this->handle_close ();
00320 }
00321
00322 template <PR_ST_1, ACE_SYNCH_DECL> int
00323 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close (u_long)
00324 {
00325 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close");
00326 return this->handle_close ();
00327 }
00328
00329 template <PR_ST_1, ACE_SYNCH_DECL> int
00330 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init (int ,
00331 ACE_TCHAR * [])
00332 {
00333 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init");
00334 return -1;
00335 }
00336
00337 template <PR_ST_1, ACE_SYNCH_DECL> int
00338 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini (void)
00339 {
00340 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini");
00341 return -1;
00342 }
00343
00344 template <PR_ST_1, ACE_SYNCH_DECL> int
00345 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info (ACE_TCHAR **, size_t) const
00346 {
00347 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info");
00348 return -1;
00349 }
00350
00351 template <PR_ST_1, ACE_SYNCH_DECL> int
00352 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::idle (u_long flags)
00353 {
00354 if (this->recycler ())
00355 return this->recycler ()->cache (this->recycling_act_);
00356 else
00357 return this->close (flags);
00358 }
00359
00360 template <PR_ST_1, ACE_SYNCH_DECL> int
00361 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (ACE_Recyclable_State new_state)
00362 {
00363 if (this->recycler ())
00364 return this->recycler ()->recycle_state (this->recycling_act_,
00365 new_state);
00366
00367 return 0;
00368 }
00369
00370 template <PR_ST_1, ACE_SYNCH_DECL> ACE_Recyclable_State
00371 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (void) const
00372 {
00373 if (this->recycler ())
00374 return this->recycler ()->recycle_state (this->recycling_act_);
00375
00376 return ACE_RECYCLABLE_UNKNOWN;
00377 }
00378
00379 template <PR_ST_1, ACE_SYNCH_DECL> void
00380 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler (ACE_Connection_Recycling_Strategy *recycler,
00381 const void *recycling_act)
00382 {
00383 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
00384 this->recycler_ = recycler;
00385 this->recycling_act_ = recycling_act;
00386 }
00387
00388 template <PR_ST_1, ACE_SYNCH_DECL> ACE_Connection_Recycling_Strategy *
00389 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler (void) const
00390 {
00391 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
00392 return this->recycler_;
00393 }
00394
00395 template <PR_ST_1, ACE_SYNCH_DECL> const void *
00396 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act (void) const
00397 {
00398 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act");
00399 return this->recycling_act_;
00400 }
00401
00402 template <PR_ST_1, ACE_SYNCH_DECL> int
00403 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle (void *)
00404 {
00405 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle");
00406
00407 return 0;
00408 }
00409
00410 template <PR_ST_1, ACE_SYNCH_DECL>
00411 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Buffered_Svc_Handler (void)
00412 {
00413 this->flush ();
00414 }
00415
00416 template <PR_ST_1, ACE_SYNCH_DECL>
00417 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler (ACE_Thread_Manager *tm,
00418 ACE_Message_Queue<ACE_SYNCH_USE> *mq,
00419 ACE_Reactor *reactor,
00420 size_t maximum_buffer_size,
00421 ACE_Time_Value *timeout)
00422 : ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE> (tm, mq, reactor),
00423 maximum_buffer_size_ (maximum_buffer_size),
00424 current_buffer_size_ (0),
00425 timeoutp_ (timeout)
00426 {
00427 ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler");
00428
00429 if (this->timeoutp_ != 0)
00430 {
00431 this->interval_ = *timeout;
00432 this->next_timeout_ = ACE_OS::gettimeofday () + this->interval_;
00433 }
00434 }
00435
00436 template <PR_ST_1, ACE_SYNCH_DECL> int
00437 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
00438 ACE_Time_Value *tv)
00439 {
00440 ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);
00441
00442
00443 if (this->putq (mb, tv) == -1)
00444 return -1;
00445 else
00446 {
00447
00448 this->current_buffer_size_ += mb->total_size ();
00449
00450
00451
00452 if (this->current_buffer_size_ >= this->maximum_buffer_size_
00453 || (this->timeoutp_ != 0
00454 && this->next_timeout_ <= ACE_OS::gettimeofday ()))
00455 return this->flush_i ();
00456 else
00457 return 0;
00458 }
00459 }
00460
00461
00462
00463 template <PR_ST_1, ACE_SYNCH_DECL> int
00464 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush (void)
00465 {
00466 ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);
00467
00468 return this->flush_i ();
00469 }
00470
00471 template <PR_ST_1, ACE_SYNCH_DECL> int
00472 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush_i (void)
00473 {
00474 ACE_Message_Queue_Iterator<ACE_SYNCH_USE> iterator (*this->msg_queue ());
00475 ACE_Message_Block *mblk = 0;
00476 ssize_t result = 0;
00477
00478
00479
00480 if (iterator.next (mblk) != 0)
00481 result = this->peer ().send_n (mblk);
00482
00483
00484 if (result != -1)
00485 this->msg_queue ()->flush_i ();
00486
00487 if (this->timeoutp_ != 0)
00488
00489 this->next_timeout_ += this->interval_;
00490
00491 this->current_buffer_size_ = 0;
00492
00493 return result;
00494 }
00495
00496 template <PR_ST_1, ACE_SYNCH_DECL> void
00497 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
00498 {
00499 #if defined (ACE_HAS_DUMP)
00500 ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump");
00501
00502 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump ();
00503 ACE_DEBUG ((LM_DEBUG,
00504 "maximum_buffer_size_ = %d\n",
00505 this->maximum_buffer_size_));
00506 ACE_DEBUG ((LM_DEBUG,
00507 "current_buffer_size_ = %d\n",
00508 this->current_buffer_size_));
00509 if (this->timeoutp_ != 0)
00510 ACE_DEBUG ((LM_DEBUG,
00511 "next_timeout_.sec = %d, next_timeout_.usec = %d\n",
00512 this->next_timeout_.sec (),
00513 this->next_timeout_.usec ()));
00514 #endif
00515 }
00516
00517 template <PR_ST_1, ACE_SYNCH_DECL> int
00518 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout (const ACE_Time_Value &,
00519 const void *)
00520 {
00521 ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
00522 return 0;
00523 }
00524
00525 ACE_END_VERSIONED_NAMESPACE_DECL
00526
00527 #undef PR_ST_1
00528 #undef PR_ST_2
00529 #endif