00001
00002
00003 #ifndef ACE_SELECT_REACTOR_T_CPP
00004 #define ACE_SELECT_REACTOR_T_CPP
00005
00006 #include "ace/Select_Reactor_T.h"
00007
00008 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00009 # pragma once
00010 #endif
00011
00012 #include "ace/ACE.h"
00013 #include "ace/Guard_T.h"
00014 #include "ace/Log_Msg.h"
00015 #include "ace/Signal.h"
00016 #include "ace/Sig_Handler.h"
00017 #include "ace/Thread.h"
00018 #include "ace/Timer_Heap.h"
00019 #include "ace/OS_NS_errno.h"
00020 #include "ace/OS_NS_sys_select.h"
00021 #include "ace/OS_NS_sys_stat.h"
00022
00023
00024 #include "ace/Recursive_Thread_Mutex.h"
00025
00026
00027
00028
00029
00030
00031 #if !defined (__ACE_INLINE__)
00032 #include "ace/Select_Reactor_T.inl"
00033 #endif
00034
00035 ACE_RCSID (ace,
00036 Select_Reactor_T,
00037 "$Id: Select_Reactor_T.cpp 85505 2009-06-04 10:14:56Z johnnyw $")
00038
00039 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00040
00041 ACE_ALLOC_HOOK_DEFINE(ACE_Select_Reactor_T)
00042
00043 template <class ACE_SELECT_REACTOR_TOKEN> int
00044 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::any_ready
00045 (ACE_Select_Reactor_Handle_Set &wait_set)
00046 {
00047 ACE_TRACE ("ACE_Select_Reactor_T::any_ready");
00048
00049 if (this->mask_signals_)
00050 {
00051 #if !defined (ACE_WIN32)
00052
00053 ACE_Sig_Guard sb;
00054 #endif
00055
00056 return this->any_ready_i (wait_set);
00057 }
00058 return this->any_ready_i (wait_set);
00059 }
00060
00061 template <class ACE_SELECT_REACTOR_TOKEN> int
00062 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::any_ready_i
00063 (ACE_Select_Reactor_Handle_Set &wait_set)
00064 {
00065 ACE_TRACE ("ACE_Select_Reactor_T::any_ready_i");
00066
00067 int const number_ready = this->ready_set_.rd_mask_.num_set ()
00068 + this->ready_set_.wr_mask_.num_set ()
00069 + this->ready_set_.ex_mask_.num_set ();
00070
00071
00072
00073
00074
00075 if (number_ready > 0 && &wait_set != &(this->ready_set_))
00076 {
00077 wait_set.rd_mask_ = this->ready_set_.rd_mask_;
00078 wait_set.wr_mask_ = this->ready_set_.wr_mask_;
00079 wait_set.ex_mask_ = this->ready_set_.ex_mask_;
00080
00081 this->ready_set_.rd_mask_.reset ();
00082 this->ready_set_.wr_mask_.reset ();
00083 this->ready_set_.ex_mask_.reset ();
00084 }
00085
00086 return number_ready;
00087 }
00088
00089 template <class ACE_SELECT_REACTOR_TOKEN> int
00090 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handler_i (int signum,
00091 ACE_Event_Handler **eh)
00092 {
00093 ACE_TRACE ("ACE_Select_Reactor_T::handler_i");
00094 ACE_Event_Handler *handler = this->signal_handler_->handler (signum);
00095
00096 if (handler == 0)
00097 return -1;
00098 else if (eh != 0)
00099 *eh = handler;
00100 return 0;
00101 }
00102
00103 template <class ACE_SELECT_REACTOR_TOKEN> bool
00104 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::initialized (void)
00105 {
00106 ACE_TRACE ("ACE_Select_Reactor_T::initialized");
00107 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, false));
00108 return this->initialized_;
00109 }
00110
00111
00112 template <class ACE_SELECT_REACTOR_TOKEN> int
00113 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::owner (ACE_thread_t tid,
00114 ACE_thread_t *o_id)
00115 {
00116 ACE_TRACE ("ACE_Select_Reactor_T::owner");
00117 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00118
00119 if (o_id)
00120 {
00121 *o_id = this->owner_;
00122 }
00123
00124 this->owner_ = tid;
00125
00126 return 0;
00127 }
00128
00129 template <class ACE_SELECT_REACTOR_TOKEN> int
00130 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::owner (ACE_thread_t *t_id)
00131 {
00132 ACE_TRACE ("ACE_Select_Reactor_T::owner");
00133 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00134 *t_id = this->owner_;
00135 return 0;
00136 }
00137
00138 template <class ACE_SELECT_REACTOR_TOKEN> bool
00139 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::restart (void)
00140 {
00141 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, false));
00142 return this->restart_;
00143 }
00144
00145 template <class ACE_SELECT_REACTOR_TOKEN> bool
00146 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::restart (bool r)
00147 {
00148 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, false));
00149 bool const current_value = this->restart_;
00150 this->restart_ = r;
00151 return current_value;
00152 }
00153
00154 template <class ACE_SELECT_REACTOR_TOKEN> void
00155 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::requeue_position (int rp)
00156 {
00157 ACE_TRACE ("ACE_Select_Reactor_T::requeue_position");
00158 ACE_MT (ACE_GUARD (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_));
00159 #if defined (ACE_WIN32)
00160 ACE_UNUSED_ARG (rp);
00161
00162 this->requeue_position_ = 0;
00163 #else
00164 this->requeue_position_ = rp;
00165 #endif
00166 }
00167
00168 template <class ACE_SELECT_REACTOR_TOKEN> int
00169 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::requeue_position (void)
00170 {
00171 ACE_TRACE ("ACE_Select_Reactor_T::requeue_position");
00172 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00173 return this->requeue_position_;
00174 }
00175
00176 template <class ACE_SELECT_REACTOR_TOKEN> void
00177 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::max_notify_iterations (int iterations)
00178 {
00179 ACE_TRACE ("ACE_Select_Reactor_T::max_notify_iterations");
00180 ACE_MT (ACE_GUARD (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_));
00181
00182 this->notify_handler_->max_notify_iterations (iterations);
00183 }
00184
00185 template <class ACE_SELECT_REACTOR_TOKEN> int
00186 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::max_notify_iterations (void)
00187 {
00188 ACE_TRACE ("ACE_Select_Reactor_T::max_notify_iterations");
00189 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00190 return this->notify_handler_->max_notify_iterations ();
00191 }
00192
00193
00194 template <class ACE_SELECT_REACTOR_TOKEN> void
00195 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::renew (void)
00196 {
00197 ACE_TRACE ("ACE_Select_Reactor_T::renew");
00198 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00199 if (this->supress_notify_renew () == 0)
00200 this->token_.renew (this->requeue_position_);
00201 #endif
00202 }
00203
00204 template <class ACE_SELECT_REACTOR_TOKEN> int
00205 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::notify (ACE_Event_Handler *eh,
00206 ACE_Reactor_Mask mask,
00207 ACE_Time_Value *timeout)
00208 {
00209 ACE_TRACE ("ACE_Select_Reactor_T::notify");
00210
00211
00212
00213
00214 ssize_t n = -1;
00215 if (this->notify_handler_)
00216 {
00217 n = this->notify_handler_->notify (eh, mask, timeout);
00218 }
00219 return n == -1 ? -1 : 0;
00220 }
00221
00222 template <class ACE_SELECT_REACTOR_TOKEN> int
00223 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::resume_handler (ACE_HANDLE handle)
00224 {
00225 ACE_TRACE ("ACE_Select_Reactor_T::resume_handler");
00226 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00227 return this->resume_i (handle);
00228 }
00229
00230 template <class ACE_SELECT_REACTOR_TOKEN> int
00231 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::suspend_handler (ACE_HANDLE handle)
00232 {
00233 ACE_TRACE ("ACE_Select_Reactor_T::suspend_handler");
00234 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00235 return this->suspend_i (handle);
00236 }
00237
00238 template <class ACE_SELECT_REACTOR_TOKEN> int
00239 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::suspend_handlers (void)
00240 {
00241 ACE_TRACE ("ACE_Select_Reactor_T::suspend_handlers");
00242 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00243
00244 ACE_Event_Handler *eh = 0;
00245
00246 for (ACE_Select_Reactor_Handler_Repository_Iterator iter (&this->handler_rep_);
00247 iter.next (eh) != 0;
00248 iter.advance ())
00249 {
00250 this->suspend_i (eh->get_handle ());
00251 }
00252
00253 return 0;
00254 }
00255
00256 template <class ACE_SELECT_REACTOR_TOKEN> int
00257 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::resume_handlers (void)
00258 {
00259 ACE_TRACE ("ACE_Select_Reactor_T::resume_handlers");
00260 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00261
00262 ACE_Event_Handler *eh = 0;
00263
00264 for (ACE_Select_Reactor_Handler_Repository_Iterator iter (&this->handler_rep_);
00265 iter.next (eh) != 0;
00266 iter.advance ())
00267 {
00268 this->resume_i (eh->get_handle ());
00269 }
00270
00271 return 0;
00272 }
00273
00274 template <class ACE_SELECT_REACTOR_TOKEN> int
00275 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler
00276 (ACE_Event_Handler *handler,
00277 ACE_Reactor_Mask mask)
00278 {
00279 ACE_TRACE ("ACE_Select_Reactor_T::register_handler");
00280 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00281 return this->register_handler_i (handler->get_handle (), handler, mask);
00282 }
00283
00284 template <class ACE_SELECT_REACTOR_TOKEN> int
00285 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler
00286 (ACE_HANDLE handle,
00287 ACE_Event_Handler *handler,
00288 ACE_Reactor_Mask mask)
00289 {
00290 ACE_TRACE ("ACE_Select_Reactor_T::register_handler");
00291 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00292 return this->register_handler_i (handle, handler, mask);
00293 }
00294
00295 template <class ACE_SELECT_REACTOR_TOKEN> int
00296 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler
00297 (const ACE_Handle_Set &handles,
00298 ACE_Event_Handler *handler,
00299 ACE_Reactor_Mask mask)
00300 {
00301 ACE_TRACE ("ACE_Select_Reactor_T::register_handler");
00302 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00303 return this->register_handler_i (handles, handler, mask);
00304 }
00305
00306 template <class ACE_SELECT_REACTOR_TOKEN> ACE_Event_Handler *
00307 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::find_handler
00308 (ACE_HANDLE handle)
00309 {
00310 ACE_TRACE ("ACE_Select_Reactor_T::find_handler");
00311 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, 0));
00312 return this->find_handler_i (handle);
00313 }
00314
00315 template <class ACE_SELECT_REACTOR_TOKEN> int
00316 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handler
00317 (ACE_HANDLE handle,
00318 ACE_Reactor_Mask mask,
00319 ACE_Event_Handler **handler)
00320 {
00321 ACE_TRACE ("ACE_Select_Reactor_T::handler");
00322 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00323 return this->handler_i (handle, mask, handler);
00324 }
00325
00326 template <class ACE_SELECT_REACTOR_TOKEN> int
00327 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler
00328 (const ACE_Handle_Set &handles,
00329 ACE_Reactor_Mask mask)
00330 {
00331 ACE_TRACE ("ACE_Select_Reactor_T::remove_handler");
00332 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00333 return this->remove_handler_i (handles, mask);
00334 }
00335
00336 template <class ACE_SELECT_REACTOR_TOKEN> int
00337 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler
00338 (ACE_Event_Handler *handler,
00339 ACE_Reactor_Mask mask)
00340 {
00341 ACE_TRACE ("ACE_Select_Reactor_T::remove_handler");
00342 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00343 return this->remove_handler_i (handler->get_handle (), mask);
00344 }
00345
00346 template <class ACE_SELECT_REACTOR_TOKEN> int
00347 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler
00348 (ACE_HANDLE handle,
00349 ACE_Reactor_Mask mask)
00350 {
00351 ACE_TRACE ("ACE_Select_Reactor_T::remove_handler");
00352 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00353 return this->remove_handler_i (handle, mask);
00354 }
00355
00356
00357
00358 template <class ACE_SELECT_REACTOR_TOKEN> int
00359 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::ready_ops
00360 (ACE_HANDLE handle,
00361 ACE_Reactor_Mask mask,
00362 int ops)
00363 {
00364 ACE_TRACE ("ACE_Select_Reactor_T::ready_ops");
00365 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00366 return this->bit_ops (handle,
00367 mask,
00368 this->ready_set_,
00369 ops);
00370 }
00371
00372 template <class ACE_SELECT_REACTOR_TOKEN> int
00373 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::open
00374 (size_t size,
00375 bool restart,
00376 ACE_Sig_Handler *sh,
00377 ACE_Timer_Queue *tq,
00378 int disable_notify_pipe,
00379 ACE_Reactor_Notify *notify)
00380 {
00381 ACE_TRACE ("ACE_Select_Reactor_T::open");
00382 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00383
00384
00385 if (this->initialized_)
00386 return -1;
00387
00388 this->owner_ = ACE_Thread::self ();
00389 this->restart_ = restart;
00390 this->signal_handler_ = sh;
00391 this->timer_queue_ = tq;
00392 this->notify_handler_ = notify;
00393
00394 int result = 0;
00395
00396
00397 if (this->signal_handler_ == 0)
00398 {
00399 ACE_NEW_RETURN (this->signal_handler_,
00400 ACE_Sig_Handler,
00401 -1);
00402
00403 this->delete_signal_handler_ = true;
00404 }
00405
00406
00407 if (result != -1 && this->timer_queue_ == 0)
00408 {
00409 ACE_NEW_RETURN (this->timer_queue_,
00410 ACE_Timer_Heap,
00411 -1);
00412
00413 this->delete_timer_queue_ = true;
00414 }
00415
00416
00417 if (result != -1 && this->notify_handler_ == 0)
00418 {
00419 ACE_NEW_RETURN (this->notify_handler_,
00420 ACE_Select_Reactor_Notify,
00421 -1);
00422
00423 this->delete_notify_handler_ = true;
00424 }
00425
00426 if (result != -1 && this->handler_rep_.open (size) == -1)
00427 result = -1;
00428 else if (this->notify_handler_->open (this,
00429 0,
00430 disable_notify_pipe) == -1)
00431 {
00432 ACE_ERROR ((LM_ERROR,
00433 ACE_TEXT ("%p\n"),
00434 ACE_TEXT ("notification pipe open failed")));
00435 result = -1;
00436 }
00437
00438 if (result != -1)
00439
00440 this->initialized_ = true;
00441 else
00442
00443 this->close ();
00444
00445 return result;
00446 }
00447
00448 template <class ACE_SELECT_REACTOR_TOKEN> int
00449 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::set_sig_handler
00450 (ACE_Sig_Handler *signal_handler)
00451 {
00452 delete this->signal_handler_;
00453 this->signal_handler_ = signal_handler;
00454 this->delete_signal_handler_ = false;
00455 return 0;
00456 }
00457
00458 template <class ACE_SELECT_REACTOR_TOKEN> ACE_Timer_Queue *
00459 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::timer_queue (void) const
00460 {
00461 return this->timer_queue_;
00462 }
00463
00464 template <class ACE_SELECT_REACTOR_TOKEN> int
00465 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::timer_queue
00466 (ACE_Timer_Queue *tq)
00467 {
00468 delete this->timer_queue_;
00469 this->timer_queue_ = tq;
00470 this->delete_timer_queue_ = false;
00471 return 0;
00472 }
00473
00474 template <class ACE_SELECT_REACTOR_TOKEN>
00475 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::ACE_Select_Reactor_T
00476 (ACE_Sig_Handler *sh,
00477 ACE_Timer_Queue *tq,
00478 int disable_notify_pipe,
00479 ACE_Reactor_Notify *notify,
00480 bool mask_signals,
00481 int s_queue)
00482 : ACE_Select_Reactor_Impl (mask_signals)
00483 , token_ (s_queue)
00484 , lock_adapter_ (token_)
00485 , deactivated_ (0)
00486 {
00487 ACE_TRACE ("ACE_Select_Reactor_T::ACE_Select_Reactor_T");
00488
00489 this->token_.reactor (*this);
00490
00491 if (this->open (ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::DEFAULT_SIZE,
00492 0,
00493 sh,
00494 tq,
00495 disable_notify_pipe,
00496 notify) == -1)
00497 {
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509 if (this->open (ACE::max_handles (),
00510 0,
00511 sh,
00512 tq,
00513 disable_notify_pipe,
00514 notify) == -1)
00515 ACE_ERROR ((LM_ERROR,
00516 ACE_TEXT ("%p\n"),
00517 ACE_TEXT ("ACE_Select_Reactor_T::open ")
00518 ACE_TEXT ("failed inside ")
00519 ACE_TEXT ("ACE_Select_Reactor_T::CTOR")));
00520 }
00521 }
00522
00523
00524
00525 template <class ACE_SELECT_REACTOR_TOKEN>
00526 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::ACE_Select_Reactor_T
00527 (size_t size,
00528 bool restart,
00529 ACE_Sig_Handler *sh,
00530 ACE_Timer_Queue *tq,
00531 int disable_notify_pipe,
00532 ACE_Reactor_Notify *notify,
00533 bool mask_signals,
00534 int s_queue)
00535 : ACE_Select_Reactor_Impl (mask_signals)
00536 , token_ (s_queue)
00537 , lock_adapter_ (token_)
00538 , deactivated_ (0)
00539 {
00540 ACE_TRACE ("ACE_Select_Reactor_T::ACE_Select_Reactor_T");
00541
00542 this->token_.reactor (*this);
00543 if (this->open (size,
00544 restart,
00545 sh,
00546 tq,
00547 disable_notify_pipe,
00548 notify) == -1)
00549 ACE_ERROR ((LM_ERROR,
00550 ACE_TEXT ("%p\n"),
00551 ACE_TEXT ("ACE_Select_Reactor_T::open ")
00552 ACE_TEXT ("failed inside ACE_Select_Reactor_T::CTOR")));
00553 }
00554
00555
00556
00557
00558
00559 template <class ACE_SELECT_REACTOR_TOKEN> int
00560 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::close (void)
00561 {
00562 ACE_TRACE ("ACE_Select_Reactor_T::close");
00563 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00564
00565 if (this->delete_signal_handler_)
00566 {
00567 delete this->signal_handler_;
00568 this->signal_handler_ = 0;
00569 this->delete_signal_handler_ = false;
00570 }
00571
00572 this->handler_rep_.close ();
00573
00574 if (this->delete_timer_queue_)
00575 {
00576 delete this->timer_queue_;
00577 this->timer_queue_ = 0;
00578 this->delete_timer_queue_ = false;
00579 }
00580
00581 if (this->notify_handler_ != 0)
00582 this->notify_handler_->close ();
00583
00584 if (this->delete_notify_handler_)
00585 {
00586 delete this->notify_handler_;
00587 this->notify_handler_ = 0;
00588 this->delete_notify_handler_ = false;
00589 }
00590
00591 this->initialized_ = false;
00592
00593 return 0;
00594 }
00595
00596 template <class ACE_SELECT_REACTOR_TOKEN> int
00597 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::current_info
00598 (ACE_HANDLE, size_t &)
00599 {
00600 return -1;
00601 }
00602
00603 template <class ACE_SELECT_REACTOR_TOKEN>
00604 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::~ACE_Select_Reactor_T (void)
00605 {
00606 ACE_TRACE ("ACE_Select_Reactor_T::~ACE_Select_Reactor_T");
00607 this->close ();
00608 }
00609
00610 template <class ACE_SELECT_REACTOR_TOKEN> int
00611 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler_i
00612 (const ACE_Handle_Set &handles,
00613 ACE_Reactor_Mask mask)
00614 {
00615 ACE_TRACE ("ACE_Select_Reactor_T::remove_handler_i");
00616 ACE_HANDLE h;
00617
00618 ACE_Handle_Set_Iterator handle_iter (handles);
00619
00620 while ((h = handle_iter ()) != ACE_INVALID_HANDLE)
00621 if (this->remove_handler_i (h, mask) == -1)
00622 return -1;
00623
00624 return 0;
00625 }
00626
00627 template <class ACE_SELECT_REACTOR_TOKEN> int
00628 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler_i
00629 (const ACE_Handle_Set &handles,
00630 ACE_Event_Handler *handler,
00631 ACE_Reactor_Mask mask)
00632 {
00633 ACE_TRACE ("ACE_Select_Reactor_T::register_handler_i");
00634 ACE_HANDLE h;
00635
00636 ACE_Handle_Set_Iterator handle_iter (handles);
00637 while ((h = handle_iter ()) != ACE_INVALID_HANDLE)
00638 if (this->register_handler_i (h, handler, mask) == -1)
00639 return -1;
00640
00641 return 0;
00642 }
00643
00644 template <class ACE_SELECT_REACTOR_TOKEN> int
00645 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler
00646 (const ACE_Sig_Set &sigset,
00647 ACE_Event_Handler *new_sh,
00648 ACE_Sig_Action *new_disp)
00649 {
00650 ACE_TRACE ("ACE_Select_Reactor_T::register_handler");
00651
00652 int result = 0;
00653
00654 #if (ACE_NSIG > 0)
00655 for (int s = 1; s < ACE_NSIG; ++s)
00656 if ((sigset.is_member (s) == 1)
00657 && this->signal_handler_->register_handler (s,
00658 new_sh,
00659 new_disp) == -1)
00660 result = -1;
00661 #else
00662 ACE_UNUSED_ARG (sigset);
00663 ACE_UNUSED_ARG (new_sh);
00664 ACE_UNUSED_ARG (new_disp);
00665 #endif
00666 return result;
00667 }
00668
00669 template <class ACE_SELECT_REACTOR_TOKEN> int
00670 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler
00671 (const ACE_Sig_Set &sigset)
00672 {
00673 ACE_TRACE ("ACE_Select_Reactor_T::remove_handler");
00674 int result = 0;
00675
00676 #if (ACE_NSIG > 0)
00677 for (int s = 1; s < ACE_NSIG; ++s)
00678 if ((sigset.is_member (s) == 1)
00679 && this->signal_handler_->remove_handler (s) == -1)
00680 result = -1;
00681 #else
00682 ACE_UNUSED_ARG (sigset);
00683 #endif
00684
00685 return result;
00686 }
00687
00688 template <class ACE_SELECT_REACTOR_TOKEN> int
00689 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::cancel_timer (ACE_Event_Handler *handler,
00690 int dont_call_handle_close)
00691 {
00692 ACE_TRACE ("ACE_Select_Reactor_T::cancel_timer");
00693 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00694
00695 if (this->timer_queue_ != 0)
00696 return this->timer_queue_->cancel (handler, dont_call_handle_close);
00697 else
00698 return 0;
00699 }
00700
00701 template <class ACE_SELECT_REACTOR_TOKEN> int
00702 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::cancel_timer (long timer_id,
00703 const void **arg,
00704 int dont_call_handle_close)
00705 {
00706 ACE_TRACE ("ACE_Select_Reactor_T::cancel_timer");
00707 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00708
00709 if (this->timer_queue_ != 0)
00710 return this->timer_queue_->cancel (timer_id,
00711 arg,
00712 dont_call_handle_close);
00713 else
00714 return 0;
00715 }
00716
00717 template <class ACE_SELECT_REACTOR_TOKEN> long
00718 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::schedule_timer
00719 (ACE_Event_Handler *handler,
00720 const void *arg,
00721 const ACE_Time_Value &delay_time,
00722 const ACE_Time_Value &interval)
00723 {
00724 ACE_TRACE ("ACE_Select_Reactor_T::schedule_timer");
00725 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00726
00727 if (0 != this->timer_queue_)
00728 return this->timer_queue_->schedule
00729 (handler,
00730 arg,
00731 timer_queue_->gettimeofday () + delay_time,
00732 interval);
00733
00734 errno = ESHUTDOWN;
00735 return -1;
00736 }
00737
00738 template <class ACE_SELECT_REACTOR_TOKEN> int
00739 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::reset_timer_interval
00740 (long timer_id,
00741 const ACE_Time_Value &interval)
00742 {
00743 ACE_TRACE ("ACE_Select_Reactor_T::reset_timer_interval");
00744 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00745
00746 if (0 != this->timer_queue_)
00747 {
00748 return this->timer_queue_->reset_interval (timer_id, interval);
00749 }
00750
00751 errno = ESHUTDOWN;
00752 return -1;
00753 }
00754
00755
00756
00757
00758 template <class ACE_SELECT_REACTOR_TOKEN> int
00759 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handle_events
00760 (ACE_Time_Value &max_wait_time)
00761 {
00762 ACE_TRACE ("ACE_Select_Reactor_T::handle_events");
00763
00764 return this->handle_events (&max_wait_time);
00765 }
00766
00767 template <class ACE_SELECT_REACTOR_TOKEN> int
00768 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handle_error (void)
00769 {
00770 ACE_TRACE ("ACE_Select_Reactor_T::handle_error");
00771 #if defined (linux) && defined (ERESTARTNOHAND)
00772 int const error = errno;
00773 if (error == EINTR || error == ERESTARTNOHAND)
00774 return this->restart_;
00775 #else
00776 if (errno == EINTR)
00777 return this->restart_;
00778 #endif
00779 #if defined (__MVS__) || defined (ACE_WIN32) || defined (ACE_VXWORKS)
00780
00781
00782
00783
00784 else
00785 return this->check_handles ();
00786 #else
00787 else if (errno == EBADF)
00788 return this->check_handles ();
00789 else
00790 return -1;
00791 #endif
00792 }
00793
00794 template <class ACE_SELECT_REACTOR_TOKEN> void
00795 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::notify_handle
00796 (ACE_HANDLE handle,
00797 ACE_Reactor_Mask mask,
00798 ACE_Handle_Set &ready_mask,
00799 ACE_Event_Handler *event_handler,
00800 ACE_EH_PTMF ptmf)
00801 {
00802 ACE_TRACE ("ACE_Select_Reactor_T::notify_handle");
00803
00804 if (event_handler == 0)
00805 return;
00806
00807 bool const reference_counting_required =
00808 event_handler->reference_counting_policy ().value () ==
00809 ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
00810
00811
00812 if (reference_counting_required)
00813 {
00814 event_handler->add_reference ();
00815 }
00816
00817 int const status = (event_handler->*ptmf) (handle);
00818
00819 if (status < 0)
00820 this->remove_handler_i (handle, mask);
00821 else if (status > 0)
00822 ready_mask.set_bit (handle);
00823
00824
00825 if (reference_counting_required)
00826 event_handler->remove_reference ();
00827 }
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841 template <class ACE_SELECT_REACTOR_TOKEN> int
00842 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::mask_ops
00843 (ACE_HANDLE handle,
00844 ACE_Reactor_Mask mask,
00845 int ops)
00846 {
00847 ACE_TRACE ("ACE_Select_Reactor_T::mask_ops");
00848 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1));
00849
00850
00851
00852
00853 if (this->is_suspended_i (handle))
00854 return this->bit_ops (handle, mask, this->suspend_set_, ops);
00855 else
00856 return this->bit_ops (handle, mask, this->wait_set_, ops);
00857 }
00858
00859 template <class ACE_SELECT_REACTOR_TOKEN> ACE_Event_Handler *
00860 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::find_handler_i
00861 (ACE_HANDLE handle)
00862 {
00863 ACE_TRACE ("ACE_Select_Reactor_T::find_handler_i");
00864
00865 ACE_Event_Handler *event_handler = this->handler_rep_.find (handle);
00866
00867 if (event_handler)
00868 {
00869 event_handler->add_reference ();
00870 }
00871
00872 return event_handler;
00873 }
00874
00875
00876
00877 template <class ACE_SELECT_REACTOR_TOKEN> int
00878 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handler_i
00879 (ACE_HANDLE handle,
00880 ACE_Reactor_Mask mask,
00881 ACE_Event_Handler **eh)
00882 {
00883 ACE_TRACE ("ACE_Select_Reactor_T::handler_i");
00884 ACE_Event_Handler *event_handler = this->handler_rep_.find (handle);
00885
00886 if (event_handler == 0)
00887 return -1;
00888 else
00889 {
00890 if ((ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK)
00891 || ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK))
00892 && this->wait_set_.rd_mask_.is_set (handle) == 0)
00893 return -1;
00894 if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK)
00895 && this->wait_set_.wr_mask_.is_set (handle) == 0)
00896 return -1;
00897 if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)
00898 && this->wait_set_.ex_mask_.is_set (handle) == 0)
00899 return -1;
00900 }
00901
00902 if (eh != 0)
00903 {
00904 *eh = event_handler;
00905 event_handler->add_reference ();
00906 }
00907
00908 return 0;
00909 }
00910
00911
00912
00913 template <class ACE_SELECT_REACTOR_TOKEN> int
00914 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::resume_i (ACE_HANDLE handle)
00915 {
00916 ACE_TRACE ("ACE_Select_Reactor_T::resume_i");
00917 if (this->handler_rep_.find (handle) == 0)
00918 return -1;
00919
00920 if (this->suspend_set_.rd_mask_.is_set (handle))
00921 {
00922 this->wait_set_.rd_mask_.set_bit (handle);
00923 this->suspend_set_.rd_mask_.clr_bit (handle);
00924 }
00925 if (this->suspend_set_.wr_mask_.is_set (handle))
00926 {
00927 this->wait_set_.wr_mask_.set_bit (handle);
00928 this->suspend_set_.wr_mask_.clr_bit (handle);
00929 }
00930 if (this->suspend_set_.ex_mask_.is_set (handle))
00931 {
00932 this->wait_set_.ex_mask_.set_bit (handle);
00933 this->suspend_set_.ex_mask_.clr_bit (handle);
00934 }
00935 return 0;
00936 }
00937
00938
00939
00940 template <class ACE_SELECT_REACTOR_TOKEN> int
00941 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::suspend_i (ACE_HANDLE handle)
00942 {
00943 ACE_TRACE ("ACE_Select_Reactor_T::suspend_i");
00944 if (this->handler_rep_.find (handle) == 0)
00945 return -1;
00946
00947 if (this->wait_set_.rd_mask_.is_set (handle))
00948 {
00949 this->suspend_set_.rd_mask_.set_bit (handle);
00950 this->wait_set_.rd_mask_.clr_bit (handle);
00951 }
00952 if (this->wait_set_.wr_mask_.is_set (handle))
00953 {
00954 this->suspend_set_.wr_mask_.set_bit (handle);
00955 this->wait_set_.wr_mask_.clr_bit (handle);
00956 }
00957 if (this->wait_set_.ex_mask_.is_set (handle))
00958 {
00959 this->suspend_set_.ex_mask_.set_bit (handle);
00960 this->wait_set_.ex_mask_.clr_bit (handle);
00961 }
00962
00963
00964
00965
00966 this->clear_dispatch_mask (handle, ACE_Event_Handler::RWE_MASK);
00967 return 0;
00968 }
00969
00970
00971
00972 template <class ACE_SELECT_REACTOR_TOKEN> int
00973 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::is_suspended_i (ACE_HANDLE handle)
00974 {
00975 ACE_TRACE ("ACE_Select_Reactor_T::is_suspended_i");
00976 if (this->handler_rep_.find (handle) == 0)
00977 return 0;
00978
00979 return this->suspend_set_.rd_mask_.is_set (handle) ||
00980 this->suspend_set_.wr_mask_.is_set (handle) ||
00981 this->suspend_set_.ex_mask_.is_set (handle);
00982
00983 }
00984
00985
00986
00987 template <class ACE_SELECT_REACTOR_TOKEN> int
00988 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::register_handler_i
00989 (ACE_HANDLE handle,
00990 ACE_Event_Handler *event_handler,
00991 ACE_Reactor_Mask mask)
00992 {
00993 ACE_TRACE ("ACE_Select_Reactor_T::register_handler_i");
00994
00995
00996
00997 return this->handler_rep_.bind (handle, event_handler, mask);
00998 }
00999
01000 template <class ACE_SELECT_REACTOR_TOKEN> int
01001 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::remove_handler_i
01002 (ACE_HANDLE handle,
01003 ACE_Reactor_Mask mask)
01004 {
01005 ACE_TRACE ("ACE_Select_Reactor_T::remove_handler_i");
01006
01007
01008 return this->handler_rep_.unbind (handle, mask);
01009 }
01010
01011 template <class ACE_SELECT_REACTOR_TOKEN> int
01012 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::work_pending
01013 (const ACE_Time_Value &max_wait_time)
01014 {
01015 ACE_TRACE ("ACE_Select_Reactor_T::work_pending");
01016
01017 ACE_Time_Value mwt (max_wait_time);
01018 ACE_MT (ACE_Countdown_Time countdown (&mwt));
01019
01020 ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN,
01021 ace_mon,
01022 this->token_,
01023 -1));
01024
01025 if (this->deactivated_)
01026 return 0;
01027
01028
01029 ACE_MT (countdown.update ());
01030
01031 ACE_Time_Value timer_buf (0);
01032 ACE_Time_Value *this_timeout =
01033 this->timer_queue_->calculate_timeout (&mwt, &timer_buf);
01034
01035
01036 bool const timers_pending =
01037 (this_timeout != 0 && *this_timeout != mwt ? true : false);
01038
01039 #ifdef ACE_WIN32
01040
01041
01042 int const width = 0;
01043 #else
01044 int const width = this->handler_rep_.max_handlep1 ();
01045 #endif
01046
01047 ACE_Select_Reactor_Handle_Set fd_set;
01048 fd_set.rd_mask_ = this->wait_set_.rd_mask_;
01049 fd_set.wr_mask_ = this->wait_set_.wr_mask_;
01050 fd_set.ex_mask_ = this->wait_set_.ex_mask_;
01051
01052 int const nfds = ACE_OS::select (width,
01053 fd_set.rd_mask_,
01054 fd_set.wr_mask_,
01055 fd_set.ex_mask_,
01056 this_timeout);
01057
01058
01059
01060 return (nfds == 0 && timers_pending ? 1 : nfds);
01061 }
01062
01063
01064
01065 template <class ACE_SELECT_REACTOR_TOKEN> int
01066 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::wait_for_multiple_events
01067 (ACE_Select_Reactor_Handle_Set &dispatch_set,
01068 ACE_Time_Value *max_wait_time)
01069 {
01070 ACE_TRACE ("ACE_Select_Reactor_T::wait_for_multiple_events");
01071 ACE_Time_Value timer_buf (0);
01072 ACE_Time_Value *this_timeout = 0;
01073
01074 int number_of_active_handles = this->any_ready (dispatch_set);
01075
01076
01077
01078
01079 if (number_of_active_handles == 0)
01080 {
01081 do
01082 {
01083 if (this->timer_queue_ == 0)
01084 return 0;
01085
01086 this_timeout =
01087 this->timer_queue_->calculate_timeout (max_wait_time,
01088 &timer_buf);
01089 #ifdef ACE_WIN32
01090
01091
01092 int const width = 0;
01093 #else
01094 int const width = this->handler_rep_.max_handlep1 ();
01095 #endif
01096
01097 dispatch_set.rd_mask_ = this->wait_set_.rd_mask_;
01098 dispatch_set.wr_mask_ = this->wait_set_.wr_mask_;
01099 dispatch_set.ex_mask_ = this->wait_set_.ex_mask_;
01100 number_of_active_handles = ACE_OS::select (width,
01101 dispatch_set.rd_mask_,
01102 dispatch_set.wr_mask_,
01103 dispatch_set.ex_mask_,
01104 this_timeout);
01105 }
01106 while (number_of_active_handles == -1 && this->handle_error () > 0);
01107
01108 if (number_of_active_handles > 0)
01109 {
01110 #if !defined (ACE_WIN32)
01111
01112 dispatch_set.rd_mask_.sync (this->handler_rep_.max_handlep1 ());
01113 dispatch_set.wr_mask_.sync (this->handler_rep_.max_handlep1 ());
01114 dispatch_set.ex_mask_.sync (this->handler_rep_.max_handlep1 ());
01115 #endif
01116 }
01117 else if (number_of_active_handles == -1)
01118 {
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130 dispatch_set.rd_mask_.reset ();
01131 dispatch_set.wr_mask_.reset ();
01132 dispatch_set.ex_mask_.reset ();
01133 }
01134 }
01135
01136
01137 return number_of_active_handles;
01138 }
01139
01140 template <class ACE_SELECT_REACTOR_TOKEN> int
01141 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::dispatch_timer_handlers
01142 (int &number_of_handlers_dispatched)
01143 {
01144 number_of_handlers_dispatched += this->timer_queue_->expire ();
01145
01146 return 0;
01147 }
01148
01149 template <class ACE_SELECT_REACTOR_TOKEN> int
01150 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::dispatch_notification_handlers
01151 (ACE_Select_Reactor_Handle_Set &dispatch_set,
01152 int &number_of_active_handles,
01153 int &number_of_handlers_dispatched)
01154 {
01155
01156
01157
01158
01159
01160
01161 int const n =
01162 this->notify_handler_->dispatch_notifications (number_of_active_handles,
01163 dispatch_set.rd_mask_);
01164
01165 if (n == -1)
01166 return -1;
01167 else
01168 {
01169 number_of_handlers_dispatched += n;
01170 number_of_active_handles -= n;
01171 }
01172
01173
01174
01175
01176
01177
01178
01179 return 0;
01180 }
01181
01182 template <class ACE_SELECT_REACTOR_TOKEN> int
01183 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::dispatch_io_set
01184 (int number_of_active_handles,
01185 int &number_of_handlers_dispatched,
01186 int mask,
01187 ACE_Handle_Set &dispatch_mask,
01188 ACE_Handle_Set &ready_mask,
01189 ACE_EH_PTMF callback)
01190 {
01191 ACE_TRACE ("ACE_Select_Reactor_T::dispatch_io_set");
01192 ACE_HANDLE handle;
01193
01194 ACE_Handle_Set_Iterator handle_iter (dispatch_mask);
01195
01196 while ((handle = handle_iter ()) != ACE_INVALID_HANDLE &&
01197 number_of_handlers_dispatched < number_of_active_handles)
01198 {
01199 ++number_of_handlers_dispatched;
01200
01201 this->notify_handle (handle,
01202 mask,
01203 ready_mask,
01204 this->handler_rep_.find (handle),
01205 callback);
01206
01207
01208
01209
01210 this->clear_dispatch_mask (handle, mask);
01211
01212 if (this->state_changed_)
01213 {
01214
01215 handle_iter.reset_state ();
01216 this->state_changed_ = false;
01217 }
01218 }
01219
01220 return 0;
01221 }
01222
01223 template <class ACE_SELECT_REACTOR_TOKEN> int
01224 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::dispatch_io_handlers
01225 (ACE_Select_Reactor_Handle_Set &dispatch_set,
01226 int &number_of_active_handles,
01227 int &number_of_handlers_dispatched)
01228 {
01229 ACE_TRACE ("ACE_Select_Reactor_T::dispatch_io_handlers");
01230
01231
01232
01233
01234
01235 if (this->dispatch_io_set (number_of_active_handles,
01236 number_of_handlers_dispatched,
01237 ACE_Event_Handler::WRITE_MASK,
01238 dispatch_set.wr_mask_,
01239 this->ready_set_.wr_mask_,
01240 &ACE_Event_Handler::handle_output) == -1)
01241 {
01242 number_of_active_handles -= number_of_handlers_dispatched;
01243 return -1;
01244 }
01245
01246
01247 if (this->dispatch_io_set (number_of_active_handles,
01248 number_of_handlers_dispatched,
01249 ACE_Event_Handler::EXCEPT_MASK,
01250 dispatch_set.ex_mask_,
01251 this->ready_set_.ex_mask_,
01252 &ACE_Event_Handler::handle_exception) == -1)
01253 {
01254 number_of_active_handles -= number_of_handlers_dispatched;
01255 return -1;
01256 }
01257
01258
01259 if (this->dispatch_io_set (number_of_active_handles,
01260 number_of_handlers_dispatched,
01261 ACE_Event_Handler::READ_MASK,
01262 dispatch_set.rd_mask_,
01263 this->ready_set_.rd_mask_,
01264 &ACE_Event_Handler::handle_input) == -1)
01265 {
01266 number_of_active_handles -= number_of_handlers_dispatched;
01267 return -1;
01268 }
01269
01270 number_of_active_handles -= number_of_handlers_dispatched;
01271 return 0;
01272 }
01273
01274 template <class ACE_SELECT_REACTOR_TOKEN> int
01275 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::dispatch
01276 (int active_handle_count,
01277 ACE_Select_Reactor_Handle_Set &dispatch_set)
01278 {
01279 ACE_TRACE ("ACE_Select_Reactor_T::dispatch");
01280
01281 int io_handlers_dispatched = 0;
01282 int other_handlers_dispatched = 0;
01283 int signal_occurred = 0;
01284
01285
01286
01287
01288
01289 do
01290 {
01291
01292
01293
01294
01295
01296 int initial_handle_count = active_handle_count;
01297
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310 this->state_changed_ = false;
01311
01312
01313
01314
01315 if (active_handle_count == -1)
01316 {
01317
01318 if (ACE_Sig_Handler::sig_pending () != 0)
01319 {
01320 ACE_Sig_Handler::sig_pending (0);
01321
01322
01323
01324
01325 active_handle_count = this->any_ready (dispatch_set);
01326
01327
01328
01329
01330 signal_occurred = 1;
01331 }
01332 else
01333 return -1;
01334 }
01335
01336
01337
01338
01339 else if (this->dispatch_timer_handlers (other_handlers_dispatched) == -1)
01340
01341 break;
01342
01343
01344
01345 else if (active_handle_count == 0)
01346 return io_handlers_dispatched
01347 + other_handlers_dispatched
01348 + signal_occurred;
01349
01350
01351
01352
01353
01354 else if (this->dispatch_notification_handlers
01355 (dispatch_set,
01356 active_handle_count,
01357 other_handlers_dispatched) == -1)
01358
01359
01360 break;
01361
01362
01363 else if (this->dispatch_io_handlers
01364 (dispatch_set,
01365 active_handle_count,
01366 io_handlers_dispatched) == -1)
01367
01368 break;
01369
01370
01371
01372 if (initial_handle_count == active_handle_count
01373 || this->state_changed_)
01374 {
01375 active_handle_count = this->any_ready (dispatch_set);
01376 }
01377 }
01378 while (active_handle_count > 0);
01379
01380 return io_handlers_dispatched + other_handlers_dispatched + signal_occurred;
01381 }
01382
01383 template <class ACE_SELECT_REACTOR_TOKEN> int
01384 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::release_token (void)
01385 {
01386 #if defined (ACE_WIN32)
01387 this->token_.release ();
01388 return (int) EXCEPTION_CONTINUE_SEARCH;
01389 #else
01390 return 0;
01391 #endif
01392 }
01393
01394 template <class ACE_SELECT_REACTOR_TOKEN> int
01395 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handle_events
01396 (ACE_Time_Value *max_wait_time)
01397 {
01398 ACE_TRACE ("ACE_Select_Reactor_T::handle_events");
01399
01400 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
01401
01402
01403
01404
01405 ACE_Countdown_Time countdown (max_wait_time);
01406
01407 ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1);
01408
01409 if (ACE_OS::thr_equal (ACE_Thread::self (),
01410 this->owner_) == 0 || this->deactivated_)
01411 return -1;
01412
01413
01414 countdown.update ();
01415 #else
01416 if (this->deactivated_)
01417 return -1;
01418 #endif
01419
01420 return this->handle_events_i (max_wait_time);
01421 }
01422
01423 template <class ACE_SELECT_REACTOR_TOKEN> int
01424 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::handle_events_i
01425 (ACE_Time_Value *max_wait_time)
01426 {
01427 int result = -1;
01428
01429 ACE_SEH_TRY
01430 {
01431
01432
01433
01434
01435 this->dispatch_set_.rd_mask_.reset ();
01436 this->dispatch_set_.wr_mask_.reset ();
01437 this->dispatch_set_.ex_mask_.reset ();
01438
01439 int number_of_active_handles =
01440 this->wait_for_multiple_events (this->dispatch_set_,
01441 max_wait_time);
01442
01443 result =
01444 this->dispatch (number_of_active_handles,
01445 this->dispatch_set_);
01446 }
01447 ACE_SEH_EXCEPT (this->release_token ())
01448 {
01449
01450
01451
01452 }
01453
01454 return result;
01455 }
01456
01457 template <class ACE_SELECT_REACTOR_TOKEN> int
01458 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::check_handles (void)
01459 {
01460 ACE_TRACE ("ACE_Select_Reactor_T::check_handles");
01461
01462 #if defined (ACE_WIN32) || defined (__MVS__) || defined (ACE_VXWORKS)
01463 ACE_Time_Value time_poll = ACE_Time_Value::zero;
01464 ACE_Handle_Set rd_mask;
01465 #endif
01466
01467 int result = 0;
01468
01469
01470
01471
01472
01473
01474
01475
01476 ACE_HANDLE h;
01477 ACE_Handle_Set check_set (this->wait_set_.rd_mask_);
01478 ACE_Handle_Set_Iterator wr_iter (this->wait_set_.wr_mask_);
01479 while ((h = wr_iter ()) != ACE_INVALID_HANDLE)
01480 check_set.set_bit (h);
01481 ACE_Handle_Set_Iterator ex_iter (this->wait_set_.ex_mask_);
01482 while ((h = ex_iter ()) != ACE_INVALID_HANDLE)
01483 check_set.set_bit (h);
01484
01485 ACE_Handle_Set_Iterator check_iter (check_set);
01486 while ((h = check_iter ()) != ACE_INVALID_HANDLE)
01487 {
01488
01489 #if defined (ACE_WIN32) || defined (__MVS__) || defined (ACE_VXWORKS)
01490
01491
01492
01493
01494
01495
01496
01497 rd_mask.set_bit (h);
01498
01499 # if defined (ACE_WIN32)
01500
01501
01502 int select_width = 0;
01503 # else
01504 int select_width = int (h) + 1;
01505 # endif
01506
01507 if (ACE_OS::select (select_width,
01508 rd_mask, 0, 0,
01509 &time_poll) < 0)
01510 {
01511 result = 1;
01512 this->remove_handler_i (h, ACE_Event_Handler::ALL_EVENTS_MASK);
01513 }
01514 rd_mask.clr_bit (h);
01515 #else
01516 struct stat temp;
01517
01518 if (ACE_OS::fstat (h, &temp) == -1)
01519 {
01520 result = 1;
01521 this->remove_handler_i (h, ACE_Event_Handler::ALL_EVENTS_MASK);
01522 }
01523 #endif
01524 }
01525
01526 return result;
01527 }
01528
01529 template <class ACE_SELECT_REACTOR_TOKEN> void
01530 ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::dump (void) const
01531 {
01532 #if defined (ACE_HAS_DUMP)
01533 ACE_TRACE ("ACE_Select_Reactor_T::dump");
01534
01535 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
01536
01537 this->timer_queue_->dump ();
01538 this->handler_rep_.dump ();
01539 this->signal_handler_->dump ();
01540 ACE_DEBUG ((LM_DEBUG,
01541 ACE_TEXT ("delete_signal_handler_ = %d\n"),
01542 this->delete_signal_handler_));
01543
01544 ACE_HANDLE h;
01545
01546 for (ACE_Handle_Set_Iterator handle_iter_wr (this->wait_set_.wr_mask_);
01547 (h = handle_iter_wr ()) != ACE_INVALID_HANDLE;)
01548 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("write_handle = %d\n"), h));
01549
01550 for (ACE_Handle_Set_Iterator handle_iter_rd (this->wait_set_.rd_mask_);
01551 (h = handle_iter_rd ()) != ACE_INVALID_HANDLE;)
01552 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("read_handle = %d\n"), h));
01553
01554 for (ACE_Handle_Set_Iterator handle_iter_ex (this->wait_set_.ex_mask_);
01555 (h = handle_iter_ex ()) != ACE_INVALID_HANDLE;)
01556 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("except_handle = %d\n"), h));
01557
01558 for (ACE_Handle_Set_Iterator handle_iter_wr_ready (this->ready_set_.wr_mask_);
01559 (h = handle_iter_wr_ready ()) != ACE_INVALID_HANDLE;)
01560 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("write_handle_ready = %d\n"), h));
01561
01562 for (ACE_Handle_Set_Iterator handle_iter_rd_ready (this->ready_set_.rd_mask_);
01563 (h = handle_iter_rd_ready ()) != ACE_INVALID_HANDLE;)
01564 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("read_handle_ready = %d\n"), h));
01565
01566 for (ACE_Handle_Set_Iterator handle_iter_ex_ready (this->ready_set_.ex_mask_);
01567 (h = handle_iter_ex_ready ()) != ACE_INVALID_HANDLE;)
01568 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("except_handle_ready = %d\n"), h));
01569
01570 for (ACE_Handle_Set_Iterator handle_iter_su_ready (this->suspend_set_.wr_mask_);
01571 (h = handle_iter_su_ready ()) != ACE_INVALID_HANDLE;)
01572 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("write_handle_suspend = %d\n"), h));
01573
01574 for (ACE_Handle_Set_Iterator handle_iter_su_ready (this->suspend_set_.rd_mask_);
01575 (h = handle_iter_su_ready ()) != ACE_INVALID_HANDLE;)
01576 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("read_handle_suspend = %d\n"), h));
01577
01578 for (ACE_Handle_Set_Iterator handle_iter_su_ready (this->suspend_set_.ex_mask_);
01579 (h = handle_iter_su_ready ()) != ACE_INVALID_HANDLE;)
01580 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("except_handle_suspend = %d\n"), h));
01581
01582 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("restart_ = %d\n"), this->restart_));
01583 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("requeue_position_ = %d\n"), this->requeue_position_));
01584 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("initialized_ = %d\n"), this->initialized_));
01585 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("owner_ = %d\n"), this->owner_));
01586
01587 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
01588 this->notify_handler_->dump ();
01589 this->token_.dump ();
01590 #endif
01591
01592 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
01593 #endif
01594 }
01595
01596 ACE_END_VERSIONED_NAMESPACE_DECL
01597
01598 #endif