00001
00002
00003 #ifndef ACE_CONNECTOR_CPP
00004 #define ACE_CONNECTOR_CPP
00005
00006 #include "ace/Connector.h"
00007 #include "ace/ACE.h"
00008 #include "ace/OS_NS_stdio.h"
00009 #include "ace/OS_NS_string.h"
00010 #include "ace/os_include/os_fcntl.h"
00011
00012 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00013 # pragma once
00014 #endif
00015
00016 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00017
00018 ACE_ALLOC_HOOK_DEFINE(ACE_Connector)
00019
00020 template <class SVC_HANDLER>
00021 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::ACE_NonBlocking_Connect_Handler
00022 (ACE_Connector_Base<SVC_HANDLER> &connector,
00023 SVC_HANDLER *sh,
00024 long id)
00025 : connector_ (connector)
00026 , svc_handler_ (sh)
00027 , cleanup_svc_handler_ (0)
00028 , timer_id_ (id)
00029 {
00030 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::ACE_NonBlocking_Connect_Handler");
00031
00032 this->reference_counting_policy ().value
00033 (ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
00034
00035 if (this->svc_handler_ != 0 &&
00036 this->svc_handler_->reference_counting_policy ().value () ==
00037 ACE_Event_Handler::Reference_Counting_Policy::ENABLED)
00038 {
00039
00040
00041
00042 this->cleanup_svc_handler_ = sh;
00043 this->cleanup_svc_handler_->add_reference ();
00044 }
00045 }
00046
00047 template <class SVC_HANDLER>
00048 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::~ACE_NonBlocking_Connect_Handler (void)
00049 {
00050 if (this->cleanup_svc_handler_)
00051 {
00052 this->cleanup_svc_handler_->remove_reference ();
00053 }
00054 }
00055
00056 template <class SVC_HANDLER> SVC_HANDLER *
00057 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::svc_handler (void)
00058 {
00059 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::svc_handler");
00060 return this->svc_handler_;
00061 }
00062
00063 template <class SVC_HANDLER> long
00064 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id (void)
00065 {
00066 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id");
00067 return this->timer_id_;
00068 }
00069
00070 template <class SVC_HANDLER> void
00071 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id (long id)
00072 {
00073 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::timer_id");
00074 this->timer_id_ = id;
00075 }
00076
00077 template <class SVC_HANDLER> void
00078 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::dump (void) const
00079 {
00080 #if defined (ACE_HAS_DUMP)
00081 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::dump");
00082
00083 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00084 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("svc_handler_ = %x"), this->svc_handler_));
00085 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\ntimer_id_ = %d"), this->timer_id_));
00086 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00087 #endif
00088 }
00089
00090 template <class SVC_HANDLER> bool
00091 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::close (SVC_HANDLER *&sh)
00092 {
00093
00094 if (!this->svc_handler_)
00095 return false;
00096
00097 {
00098
00099 ACE_GUARD_RETURN (ACE_Lock,
00100 ace_mon,
00101 this->reactor ()->lock (),
00102 0);
00103
00104
00105 if (!this->svc_handler_)
00106 return false;
00107
00108
00109 sh = this->svc_handler_;
00110 ACE_HANDLE h = sh->get_handle ();
00111 this->svc_handler_ = 0;
00112
00113
00114
00115 this->connector_.non_blocking_handles ().remove (h);
00116
00117
00118 if (this->reactor ()->cancel_timer (this->timer_id (),
00119 0,
00120 0) == -1)
00121 return false;
00122
00123
00124 if (this->reactor ()->remove_handler (
00125 h,
00126 ACE_Event_Handler::ALL_EVENTS_MASK) == -1)
00127 return false;
00128 }
00129
00130 return true;
00131 }
00132
00133
00134 template <class SVC_HANDLER> int
00135 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_timeout
00136 (const ACE_Time_Value &tv,
00137 const void *arg)
00138 {
00139
00140 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_timeout");
00141
00142 SVC_HANDLER *svc_handler = 0;
00143 int const retval = this->close (svc_handler) ? 0 : -1;
00144
00145
00146
00147
00148
00149 if (svc_handler != 0 && svc_handler->handle_timeout (tv, arg) == -1)
00150 svc_handler->handle_close (svc_handler->get_handle (),
00151 ACE_Event_Handler::TIMER_MASK);
00152
00153 return retval;
00154 }
00155
00156
00157 template <class SVC_HANDLER> int
00158 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_input (ACE_HANDLE)
00159 {
00160
00161
00162 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_input");
00163
00164 SVC_HANDLER *svc_handler = 0;
00165 int const retval = this->close (svc_handler) ? 0 : -1;
00166
00167
00168 if (svc_handler != 0)
00169 {
00170 svc_handler->close (NORMAL_CLOSE_OPERATION);
00171 }
00172
00173 return retval;
00174 }
00175
00176 template <class SVC_HANDLER> int
00177 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_output (ACE_HANDLE handle)
00178 {
00179
00180 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_output");
00181
00182
00183 ACE_Connector_Base<SVC_HANDLER> &connector = this->connector_;
00184 SVC_HANDLER *svc_handler = 0;
00185 int const retval = this->close (svc_handler) ? 0 : -1;
00186
00187 if (svc_handler != 0)
00188 {
00189 connector.initialize_svc_handler (handle, svc_handler);
00190 }
00191
00192 return retval;
00193 }
00194
00195 template <class SVC_HANDLER> int
00196 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_exception (ACE_HANDLE h)
00197 {
00198
00199
00200 ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::handle_exception");
00201 return this->handle_output (h);
00202 }
00203
00204 template <class SVC_HANDLER> int
00205 ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::resume_handler (void)
00206 {
00207 return ACE_Event_Handler::ACE_EVENT_HANDLER_NOT_RESUMED;
00208 }
00209
00210 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
00211 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump (void) const
00212 {
00213 #if defined (ACE_HAS_DUMP)
00214 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump");
00215
00216 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00217 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nflags_ = %d"), this->flags_));
00218 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00219 #endif
00220 }
00221
00222 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00223 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
00224 {
00225 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler");
00226
00227 if (sh == 0)
00228 ACE_NEW_RETURN (sh,
00229 SVC_HANDLER,
00230 -1);
00231
00232
00233
00234 sh->reactor (this->reactor ());
00235 return 0;
00236 }
00237
00238 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00239 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler (SVC_HANDLER *svc_handler)
00240 {
00241 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler");
00242
00243 int error = 0;
00244
00245
00246
00247 if (ACE_BIT_ENABLED (this->flags_, ACE_NONBLOCK) != 0)
00248 {
00249 if (svc_handler->peer ().enable (ACE_NONBLOCK) == -1)
00250 error = 1;
00251 }
00252
00253 else if (svc_handler->peer ().disable (ACE_NONBLOCK) == -1)
00254 error = 1;
00255
00256
00257 if (error || svc_handler->open ((void *) this) == -1)
00258 {
00259
00260
00261
00262
00263 svc_handler->close (NORMAL_CLOSE_OPERATION);
00264 return -1;
00265 }
00266 else
00267 return 0;
00268 }
00269
00270 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_PEER_CONNECTOR &
00271 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector (void) const
00272 {
00273 return const_cast<ACE_PEER_CONNECTOR &> (this->connector_);
00274 }
00275
00276 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00277 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
00278 (SVC_HANDLER *&svc_handler,
00279 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00280 ACE_Time_Value *timeout,
00281 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00282 int reuse_addr,
00283 int flags,
00284 int perms)
00285 {
00286 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler");
00287
00288 return this->connector_.connect (svc_handler->peer (),
00289 remote_addr,
00290 timeout,
00291 local_addr,
00292 reuse_addr,
00293 flags,
00294 perms);
00295 }
00296
00297 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00298 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
00299 (SVC_HANDLER *&svc_handler,
00300 SVC_HANDLER *&sh_copy,
00301 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00302 ACE_Time_Value *timeout,
00303 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00304 int reuse_addr,
00305 int flags,
00306 int perms)
00307 {
00308 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler");
00309
00310 sh_copy = svc_handler;
00311 return this->connector_.connect (svc_handler->peer (),
00312 remote_addr,
00313 timeout,
00314 local_addr,
00315 reuse_addr,
00316 flags,
00317 perms);
00318 }
00319
00320 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00321 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open (ACE_Reactor *r, int flags)
00322 {
00323 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open");
00324 this->reactor (r);
00325 this->flags_ = flags;
00326 return 0;
00327 }
00328
00329 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
00330 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connector (ACE_Reactor *r,
00331 int flags)
00332 {
00333 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connector");
00334 (void) this->open (r, flags);
00335 }
00336
00337 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00338 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect
00339 (SVC_HANDLER *&sh,
00340 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00341 const ACE_Synch_Options &synch_options,
00342 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00343 int reuse_addr,
00344 int flags,
00345 int perms)
00346 {
00347
00348 return this->connect_i (sh,
00349 0,
00350 remote_addr,
00351 synch_options,
00352 local_addr,
00353 reuse_addr,
00354 flags,
00355 perms);
00356 }
00357
00358 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00359 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect
00360 (SVC_HANDLER *&sh,
00361 SVC_HANDLER *&sh_copy,
00362 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00363 const ACE_Synch_Options &synch_options,
00364 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00365 int reuse_addr,
00366 int flags,
00367 int perms)
00368 {
00369
00370 return this->connect_i (sh,
00371 &sh_copy,
00372 remote_addr,
00373 synch_options,
00374 local_addr,
00375 reuse_addr,
00376 flags,
00377 perms);
00378 }
00379
00380 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00381 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_i
00382 (SVC_HANDLER *&sh,
00383 SVC_HANDLER **sh_copy,
00384 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00385 const ACE_Synch_Options &synch_options,
00386 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00387 int reuse_addr,
00388 int flags,
00389 int perms)
00390 {
00391 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_i");
00392
00393
00394
00395
00396 if (this->make_svc_handler (sh) == -1)
00397 return -1;
00398
00399 ACE_Time_Value *timeout = 0;
00400 int const use_reactor = synch_options[ACE_Synch_Options::USE_REACTOR];
00401
00402 if (use_reactor)
00403 timeout = const_cast<ACE_Time_Value *> (&ACE_Time_Value::zero);
00404 else
00405 timeout = const_cast<ACE_Time_Value *> (synch_options.time_value ());
00406
00407 int result;
00408 if (sh_copy == 0)
00409 result = this->connect_svc_handler (sh,
00410 remote_addr,
00411 timeout,
00412 local_addr,
00413 reuse_addr,
00414 flags,
00415 perms);
00416 else
00417 result = this->connect_svc_handler (sh,
00418 *sh_copy,
00419 remote_addr,
00420 timeout,
00421 local_addr,
00422 reuse_addr,
00423 flags,
00424 perms);
00425
00426
00427 if (result != -1)
00428 return this->activate_svc_handler (sh);
00429
00430
00431 if (use_reactor && ACE_OS::last_error () == EWOULDBLOCK)
00432 {
00433
00434
00435
00436
00437
00438 int result;
00439
00440 if (sh_copy == 0)
00441 result = this->nonblocking_connect (sh, synch_options);
00442 else
00443 result = this->nonblocking_connect (*sh_copy, synch_options);
00444
00445
00446
00447
00448
00449 if (result == 0)
00450 errno = EWOULDBLOCK;
00451 }
00452 else
00453 {
00454
00455 ACE_Errno_Guard error (errno);
00456
00457
00458 if (sh_copy == 0)
00459 {
00460 if (sh)
00461 sh->close (CLOSE_DURING_NEW_CONNECTION);
00462 }
00463 else if (*sh_copy)
00464 (*sh_copy)->close (CLOSE_DURING_NEW_CONNECTION);
00465 }
00466
00467 return -1;
00468 }
00469
00470 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00471 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_n
00472 (size_t n,
00473 SVC_HANDLER *sh[],
00474 ACE_PEER_CONNECTOR_ADDR remote_addrs[],
00475 ACE_TCHAR *failed_svc_handlers,
00476 const ACE_Synch_Options &synch_options)
00477 {
00478 int result = 0;
00479
00480 for (size_t i = 0; i < n; i++)
00481 {
00482 if (this->connect (sh[i], remote_addrs[i], synch_options) == -1
00483 && !(synch_options[ACE_Synch_Options::USE_REACTOR]
00484 && errno == EWOULDBLOCK))
00485 {
00486 result = -1;
00487 if (failed_svc_handlers != 0)
00488
00489 failed_svc_handlers[i] = 1;
00490 }
00491 else if (failed_svc_handlers != 0)
00492
00493 failed_svc_handlers[i] = 0;
00494 }
00495
00496 return result;
00497 }
00498
00499
00500 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00501 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::cancel (SVC_HANDLER *sh)
00502 {
00503 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::cancel");
00504
00505 ACE_Event_Handler *handler =
00506 this->reactor ()->find_handler (sh->get_handle ());
00507
00508 if (handler == 0)
00509 return -1;
00510
00511
00512 ACE_Event_Handler_var safe_handler (handler);
00513
00514 NBCH *nbch =
00515 dynamic_cast<NBCH *> (handler);
00516
00517 if (nbch == 0)
00518 return -1;
00519
00520 SVC_HANDLER *tmp_sh = 0;
00521
00522 if (nbch->close (tmp_sh) == false)
00523 return -1;
00524
00525 return 0;
00526 }
00527
00528 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00529 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::nonblocking_connect
00530 (SVC_HANDLER *sh,
00531 const ACE_Synch_Options &synch_options)
00532 {
00533 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::nonblocking_connect");
00534
00535
00536 if (this->reactor () == 0)
00537 return -1;
00538
00539
00540
00541
00542 ACE_HANDLE handle = sh->get_handle ();
00543 long timer_id = -1;
00544 ACE_Time_Value *tv = 0;
00545 NBCH *nbch = 0;
00546
00547 ACE_NEW_RETURN (nbch,
00548 NBCH (*this,
00549 sh,
00550 -1),
00551 -1);
00552
00553 ACE_Event_Handler_var safe_nbch (nbch);
00554
00555
00556 ACE_GUARD_RETURN (ACE_Lock, ace_mon, this->reactor ()->lock (), -1);
00557
00558
00559 ACE_Reactor_Mask mask = ACE_Event_Handler::CONNECT_MASK;
00560 if (this->reactor ()->register_handler (handle,
00561 nbch,
00562 mask) == -1)
00563 goto reactor_registration_failure;
00564
00565
00566 this->non_blocking_handles ().insert (handle);
00567
00568
00569
00570 tv = const_cast<ACE_Time_Value *> (synch_options.time_value ());
00571 if (tv != 0)
00572 {
00573 timer_id =
00574 this->reactor ()->schedule_timer (nbch,
00575 synch_options.arg (),
00576 *tv);
00577 if (timer_id == -1)
00578 goto timer_registration_failure;
00579
00580
00581 nbch->timer_id (timer_id);
00582 }
00583
00584 return 0;
00585
00586
00587
00588 timer_registration_failure:
00589
00590
00591 this->reactor ()->remove_handler (handle, mask);
00592
00593
00594 this->non_blocking_handles ().remove (handle);
00595
00596
00597
00598 reactor_registration_failure:
00599
00600
00601 sh->close (CLOSE_DURING_NEW_CONNECTION);
00602
00603 return -1;
00604 }
00605
00606 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
00607 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connector (void)
00608 {
00609 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connector");
00610
00611 this->close ();
00612 }
00613
00614 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
00615 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::initialize_svc_handler
00616 (ACE_HANDLE handle,
00617 SVC_HANDLER *svc_handler)
00618 {
00619
00620
00621 bool reset_new_handle =
00622 this->reactor ()->uses_event_associations ();
00623
00624 if (reset_new_handle)
00625 this->connector_.reset_new_handle (handle);
00626
00627
00628 svc_handler->set_handle (handle);
00629
00630 ACE_PEER_CONNECTOR_ADDR raddr;
00631
00632
00633 if (svc_handler->peer ().get_remote_addr (raddr) != -1)
00634 this->activate_svc_handler (svc_handler);
00635 else
00636 {
00637 #if defined (ACE_WIN32)
00638
00639
00640
00641 ACE_Time_Value tv (0, ACE_NON_BLOCKING_BUG_DELAY);
00642 ACE_OS::sleep (tv);
00643 if (svc_handler->peer ().get_remote_addr (raddr) != -1)
00644 this->activate_svc_handler (svc_handler);
00645 else
00646 #endif
00647 svc_handler->close (NORMAL_CLOSE_OPERATION);
00648 }
00649 }
00650
00651 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
00652 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::reactor (ACE_Reactor *reactor)
00653 {
00654 this->reactor_ = reactor;
00655 }
00656
00657 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Reactor *
00658 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::reactor (void) const
00659 {
00660 return this->reactor_;
00661 }
00662
00663 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Unbounded_Set<ACE_HANDLE> &
00664 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::non_blocking_handles (void)
00665 {
00666 return this->non_blocking_handles_;
00667 }
00668
00669 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00670 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::close (void)
00671 {
00672
00673 if (this->non_blocking_handles ().size () == 0)
00674 return 0;
00675
00676
00677 ACE_GUARD_RETURN (ACE_Lock, ace_mon, this->reactor ()->lock (), -1);
00678
00679
00680
00681
00682 ACE_HANDLE *handle = 0;
00683 while (1)
00684 {
00685 ACE_Unbounded_Set_Iterator<ACE_HANDLE>
00686 iterator (this->non_blocking_handles ());
00687 if (!iterator.next (handle))
00688 break;
00689
00690 ACE_Event_Handler *handler =
00691 this->reactor ()->find_handler (*handle);
00692 if (handler == 0)
00693 {
00694 ACE_ERROR ((LM_ERROR,
00695 ACE_TEXT ("%t: Connector::close h %d, no handler\n"),
00696 *handle));
00697
00698 this->non_blocking_handles ().remove (*handle);
00699 continue;
00700 }
00701
00702
00703 ACE_Event_Handler_var safe_handler (handler);
00704 NBCH *nbch = dynamic_cast<NBCH *> (handler);
00705 if (nbch == 0)
00706 {
00707 ACE_ERROR ((LM_ERROR,
00708 ACE_TEXT ("%t: Connector::close h %d handler %@ ")
00709 ACE_TEXT ("not a legit handler\n"),
00710 *handle,
00711 handler));
00712
00713 this->non_blocking_handles ().remove (*handle);
00714 continue;
00715 }
00716 SVC_HANDLER *svc_handler = nbch->svc_handler ();
00717
00718
00719 this->cancel (svc_handler);
00720
00721
00722 svc_handler->close (NORMAL_CLOSE_OPERATION);
00723 }
00724
00725 return 0;
00726 }
00727
00728 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00729 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::fini (void)
00730 {
00731 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::fini");
00732
00733 return this->close ();
00734 }
00735
00736
00737
00738 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00739 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::init (int, ACE_TCHAR *[])
00740 {
00741 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::init");
00742 return -1;
00743 }
00744
00745 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00746 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::suspend (void)
00747 {
00748 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::suspend");
00749 return -1;
00750 }
00751
00752 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00753 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::resume (void)
00754 {
00755 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::resume");
00756 return -1;
00757 }
00758
00759 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00760 ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::info (ACE_TCHAR **strp, size_t length) const
00761 {
00762 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::info");
00763 ACE_TCHAR buf[BUFSIZ];
00764
00765 ACE_OS::sprintf (buf,
00766 ACE_TEXT ("%s\t %s"),
00767 ACE_TEXT ("ACE_Connector"),
00768 ACE_TEXT ("# connector factory\n"));
00769
00770 if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
00771 return -1;
00772 else
00773 ACE_OS::strsncpy (*strp, buf, length);
00774 return static_cast<int> (ACE_OS::strlen (buf));
00775 }
00776
00777 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00778 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open (ACE_Reactor *r,
00779 int flags)
00780 {
00781 ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open");
00782 return this->open (r, 0, 0, 0, flags);
00783 }
00784
00785 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00786 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open
00787 (ACE_Reactor *r,
00788 ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
00789 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *conn_s,
00790 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
00791 int flags)
00792 {
00793 ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::open");
00794
00795 this->reactor (r);
00796
00797
00798
00799 ACE_UNUSED_ARG (flags);
00800
00801
00802
00803
00804 if (this->creation_strategy_ != 0 &&
00805 this->delete_creation_strategy_ &&
00806 cre_s != 0)
00807 {
00808 delete this->creation_strategy_;
00809 this->creation_strategy_ = 0;
00810 this->delete_creation_strategy_ = false;
00811 }
00812
00813 if (cre_s != 0)
00814 this->creation_strategy_ = cre_s;
00815 else if (this->creation_strategy_ == 0)
00816 {
00817 ACE_NEW_RETURN (this->creation_strategy_,
00818 CREATION_STRATEGY,
00819 -1);
00820 this->delete_creation_strategy_ = true;
00821 }
00822
00823
00824
00825
00826 if (this->connect_strategy_ != 0 &&
00827 this->delete_connect_strategy_ &&
00828 conn_s != 0)
00829 {
00830 delete this->connect_strategy_;
00831 this->connect_strategy_ = 0;
00832 this->delete_connect_strategy_ = false;
00833 }
00834
00835 if (conn_s != 0)
00836 this->connect_strategy_ = conn_s;
00837 else if (this->connect_strategy_ == 0)
00838 {
00839 ACE_NEW_RETURN (this->connect_strategy_,
00840 CONNECT_STRATEGY,
00841 -1);
00842 this->delete_connect_strategy_ = true;
00843 }
00844
00845
00846
00847 if (this->concurrency_strategy_ != 0 &&
00848 this->delete_concurrency_strategy_ &&
00849 con_s != 0)
00850 {
00851 delete this->concurrency_strategy_;
00852 this->concurrency_strategy_ = 0;
00853 this->delete_concurrency_strategy_ = false;
00854 }
00855
00856 if (con_s != 0)
00857 this->concurrency_strategy_ = con_s;
00858 else if (this->concurrency_strategy_ == 0)
00859 {
00860 ACE_NEW_RETURN (this->concurrency_strategy_,
00861 CONCURRENCY_STRATEGY,
00862 -1);
00863 this->delete_concurrency_strategy_ = true;
00864 }
00865
00866 return 0;
00867 }
00868
00869 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
00870 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Strategy_Connector
00871 (ACE_Reactor *reactor,
00872 ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
00873 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *conn_s,
00874 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
00875 int flags)
00876 : creation_strategy_ (0),
00877 delete_creation_strategy_ (false),
00878 connect_strategy_ (0),
00879 delete_connect_strategy_ (false),
00880 concurrency_strategy_ (0),
00881 delete_concurrency_strategy_ (false)
00882 {
00883 ACE_TRACE ("ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Strategy_Connector");
00884
00885 if (this->open (reactor, cre_s, conn_s, con_s, flags) == -1)
00886 ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_Strategy_Connector::ACE_Strategy_Connector")));
00887 }
00888
00889 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
00890 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Strategy_Connector (void)
00891 {
00892 ACE_TRACE ("ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Strategy_Connector");
00893
00894
00895 this->close ();
00896 }
00897
00898 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00899 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::close (void)
00900 {
00901 if (this->delete_creation_strategy_)
00902 delete this->creation_strategy_;
00903 this->delete_creation_strategy_ = false;
00904 this->creation_strategy_ = 0;
00905
00906 if (this->delete_connect_strategy_)
00907 delete this->connect_strategy_;
00908 this->delete_connect_strategy_ = false;
00909 this->connect_strategy_ = 0;
00910
00911 if (this->delete_concurrency_strategy_)
00912 delete this->concurrency_strategy_;
00913 this->delete_concurrency_strategy_ = false;
00914 this->concurrency_strategy_ = 0;
00915
00916 return SUPER::close ();
00917 }
00918
00919 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00920 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
00921 {
00922 return this->creation_strategy_->make_svc_handler (sh);
00923 }
00924
00925 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00926 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
00927 (SVC_HANDLER *&sh,
00928 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00929 ACE_Time_Value *timeout,
00930 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00931 int reuse_addr,
00932 int flags,
00933 int perms)
00934 {
00935 return this->connect_strategy_->connect_svc_handler (sh,
00936 remote_addr,
00937 timeout,
00938 local_addr,
00939 reuse_addr,
00940 flags,
00941 perms);
00942 }
00943
00944 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00945 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
00946 (SVC_HANDLER *&sh,
00947 SVC_HANDLER *&sh_copy,
00948 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00949 ACE_Time_Value *timeout,
00950 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00951 int reuse_addr,
00952 int flags,
00953 int perms)
00954 {
00955 return this->connect_strategy_->connect_svc_handler (sh,
00956 sh_copy,
00957 remote_addr,
00958 timeout,
00959 local_addr,
00960 reuse_addr,
00961 flags,
00962 perms);
00963 }
00964
00965 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00966 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::activate_svc_handler (SVC_HANDLER *svc_handler)
00967 {
00968 return this->concurrency_strategy_->activate_svc_handler (svc_handler, this);
00969 }
00970
00971 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Creation_Strategy<SVC_HANDLER> *
00972 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::creation_strategy (void) const
00973 {
00974 return this->creation_strategy_;
00975 }
00976
00977 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> *
00978 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_strategy (void) const
00979 {
00980 return this->connect_strategy_;
00981 }
00982
00983 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_Concurrency_Strategy<SVC_HANDLER> *
00984 ACE_Strategy_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::concurrency_strategy (void) const
00985 {
00986 return this->concurrency_strategy_;
00987 }
00988
00989 ACE_END_VERSIONED_NAMESPACE_DECL
00990
00991 #endif