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 this->destroy ();
00306
00307 return 0;
00308 }
00309
00310 template <PR_ST_1, ACE_SYNCH_DECL> int
00311 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout (const ACE_Time_Value &,
00312 const void *)
00313 {
00314 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
00315 return this->handle_close ();
00316 }
00317
00318 template <PR_ST_1, ACE_SYNCH_DECL> int
00319 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close (u_long)
00320 {
00321 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::close");
00322 return this->handle_close ();
00323 }
00324
00325 template <PR_ST_1, ACE_SYNCH_DECL> int
00326 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init (int ,
00327 ACE_TCHAR * [])
00328 {
00329 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::init");
00330 return -1;
00331 }
00332
00333 template <PR_ST_1, ACE_SYNCH_DECL> int
00334 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini (void)
00335 {
00336 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::fini");
00337 return -1;
00338 }
00339
00340 template <PR_ST_1, ACE_SYNCH_DECL> int
00341 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info (ACE_TCHAR **, size_t) const
00342 {
00343 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::info");
00344 return -1;
00345 }
00346
00347 template <PR_ST_1, ACE_SYNCH_DECL> int
00348 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::idle (u_long flags)
00349 {
00350 if (this->recycler ())
00351 return this->recycler ()->cache (this->recycling_act_);
00352 else
00353 return this->close (flags);
00354 }
00355
00356 template <PR_ST_1, ACE_SYNCH_DECL> int
00357 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (ACE_Recyclable_State new_state)
00358 {
00359 if (this->recycler ())
00360 return this->recycler ()->recycle_state (this->recycling_act_,
00361 new_state);
00362
00363 return 0;
00364 }
00365
00366 template <PR_ST_1, ACE_SYNCH_DECL> ACE_Recyclable_State
00367 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle_state (void) const
00368 {
00369 if (this->recycler ())
00370 return this->recycler ()->recycle_state (this->recycling_act_);
00371
00372 return ACE_RECYCLABLE_UNKNOWN;
00373 }
00374
00375 template <PR_ST_1, ACE_SYNCH_DECL> void
00376 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler (ACE_Connection_Recycling_Strategy *recycler,
00377 const void *recycling_act)
00378 {
00379 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
00380 this->recycler_ = recycler;
00381 this->recycling_act_ = recycling_act;
00382 }
00383
00384 template <PR_ST_1, ACE_SYNCH_DECL> ACE_Connection_Recycling_Strategy *
00385 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler (void) const
00386 {
00387 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycler");
00388 return this->recycler_;
00389 }
00390
00391 template <PR_ST_1, ACE_SYNCH_DECL> const void *
00392 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act (void) const
00393 {
00394 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycling_act");
00395 return this->recycling_act_;
00396 }
00397
00398 template <PR_ST_1, ACE_SYNCH_DECL> int
00399 ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle (void *)
00400 {
00401 ACE_TRACE ("ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::recycle");
00402
00403 return 0;
00404 }
00405
00406 template <PR_ST_1, ACE_SYNCH_DECL>
00407 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::~ACE_Buffered_Svc_Handler (void)
00408 {
00409 this->flush ();
00410 }
00411
00412 template <PR_ST_1, ACE_SYNCH_DECL>
00413 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler (ACE_Thread_Manager *tm,
00414 ACE_Message_Queue<ACE_SYNCH_USE> *mq,
00415 ACE_Reactor *reactor,
00416 size_t maximum_buffer_size,
00417 ACE_Time_Value *timeout)
00418 : ACE_Svc_Handler<PR_ST_2, ACE_SYNCH_USE> (tm, mq, reactor),
00419 maximum_buffer_size_ (maximum_buffer_size),
00420 current_buffer_size_ (0),
00421 timeoutp_ (timeout)
00422 {
00423 ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::ACE_Buffered_Svc_Handler");
00424
00425 if (this->timeoutp_ != 0)
00426 {
00427 this->interval_ = *timeout;
00428 this->next_timeout_ = ACE_OS::gettimeofday () + this->interval_;
00429 }
00430 }
00431
00432 template <PR_ST_1, ACE_SYNCH_DECL> int
00433 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::put (ACE_Message_Block *mb,
00434 ACE_Time_Value *tv)
00435 {
00436 ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);
00437
00438
00439 if (this->putq (mb, tv) == -1)
00440 return -1;
00441 else
00442 {
00443
00444 this->current_buffer_size_ += mb->total_size ();
00445
00446
00447
00448 if (this->current_buffer_size_ >= this->maximum_buffer_size_
00449 || (this->timeoutp_ != 0
00450 && this->next_timeout_ <= ACE_OS::gettimeofday ()))
00451 return this->flush_i ();
00452 else
00453 return 0;
00454 }
00455 }
00456
00457
00458
00459 template <PR_ST_1, ACE_SYNCH_DECL> int
00460 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush (void)
00461 {
00462 ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, m, this->msg_queue ()->lock (), -1);
00463
00464 return this->flush_i ();
00465 }
00466
00467 template <PR_ST_1, ACE_SYNCH_DECL> int
00468 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::flush_i (void)
00469 {
00470 ACE_Message_Queue_Iterator<ACE_SYNCH_USE> iterator (*this->msg_queue ());
00471 ACE_Message_Block *mblk = 0;
00472 ssize_t result = 0;
00473
00474
00475
00476 if (iterator.next (mblk) != 0)
00477 result = this->peer ().send_n (mblk);
00478
00479
00480 if (result != -1)
00481 this->msg_queue ()->flush_i ();
00482
00483 if (this->timeoutp_ != 0)
00484
00485 this->next_timeout_ += this->interval_;
00486
00487 this->current_buffer_size_ = 0;
00488
00489 return result;
00490 }
00491
00492 template <PR_ST_1, ACE_SYNCH_DECL> void
00493 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump (void) const
00494 {
00495 #if defined (ACE_HAS_DUMP)
00496 ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump");
00497
00498 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::dump ();
00499 ACE_DEBUG ((LM_DEBUG,
00500 "maximum_buffer_size_ = %d\n",
00501 this->maximum_buffer_size_));
00502 ACE_DEBUG ((LM_DEBUG,
00503 "current_buffer_size_ = %d\n",
00504 this->current_buffer_size_));
00505 if (this->timeoutp_ != 0)
00506 ACE_DEBUG ((LM_DEBUG,
00507 "next_timeout_.sec = %d, next_timeout_.usec = %d\n",
00508 this->next_timeout_.sec (),
00509 this->next_timeout_.usec ()));
00510 #endif
00511 }
00512
00513 template <PR_ST_1, ACE_SYNCH_DECL> int
00514 ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout (const ACE_Time_Value &,
00515 const void *)
00516 {
00517 ACE_TRACE ("ACE_Buffered_Svc_Handler<PR_ST_2, ACE_SYNCH_USE>::handle_timeout");
00518 return 0;
00519 }
00520
00521 ACE_END_VERSIONED_NAMESPACE_DECL
00522
00523 #undef PR_ST_1
00524 #undef PR_ST_2
00525 #endif