00001 #ifndef ACE_ACCEPTOR_CPP
00002 #define ACE_ACCEPTOR_CPP
00003
00004 #include "ace/ACE.h"
00005
00006 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00007 # pragma once
00008 #endif
00009
00010 #include "ace/Acceptor.h"
00011 #include "ace/Handle_Set.h"
00012 #include "ace/Svc_Handler.h"
00013 #include "ace/WFMO_Reactor.h"
00014 #include "ace/OS_NS_stdio.h"
00015 #include "ace/OS_NS_string.h"
00016 #include "ace/OS_NS_sys_select.h"
00017
00018 ACE_RCSID (ace,
00019 Acceptor,
00020 "$Id: Acceptor.cpp 84935 2009-03-22 19:21:58Z schmidt $")
00021
00022 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00023
00024 ACE_ALLOC_HOOK_DEFINE(ACE_Acceptor)
00025
00026 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
00027 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
00028 {
00029 #if defined (ACE_HAS_DUMP)
00030 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
00031
00032 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00033 this->peer_acceptor_.dump ();
00034 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00035 #endif
00036 }
00037
00038 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00039 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR & () const
00040 {
00041 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
00042 return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
00043 }
00044
00045 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
00046 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
00047 {
00048 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
00049 return const_cast<ACE_PEER_ACCEPTOR &> (this->peer_acceptor_);
00050 }
00051
00052
00053
00054 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
00055 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
00056 {
00057 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
00058 return this->peer_acceptor_.get_handle ();
00059 }
00060
00061
00062
00063
00064
00065
00066 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00067 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
00068 (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
00069 ACE_Reactor *reactor,
00070 int flags,
00071 int use_select,
00072 int reuse_addr)
00073 {
00074 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
00075 this->flags_ = flags;
00076 this->use_select_ = use_select;
00077 this->reuse_addr_ = reuse_addr;
00078 this->peer_acceptor_addr_ = local_addr;
00079
00080
00081
00082 if (reactor == 0)
00083 {
00084 errno = EINVAL;
00085 return -1;
00086 }
00087
00088 if (this->peer_acceptor_.open (local_addr, reuse_addr) == -1)
00089 return -1;
00090
00091
00092
00093
00094
00095
00096
00097 (void) this->peer_acceptor_.enable (ACE_NONBLOCK);
00098
00099 int const result = reactor->register_handler (this,
00100 ACE_Event_Handler::ACCEPT_MASK);
00101 if (result != -1)
00102 this->reactor (reactor);
00103 else
00104 this->peer_acceptor_.close ();
00105
00106 return result;
00107 }
00108
00109
00110
00111 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00112 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor (ACE_Reactor *reactor,
00113 int use_select)
00114 :flags_ (0),
00115 use_select_ (use_select),
00116 reuse_addr_ (1)
00117 {
00118 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor");
00119
00120 this->reactor (reactor);
00121 }
00122
00123 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00124 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor
00125 (const ACE_PEER_ACCEPTOR_ADDR &addr,
00126 ACE_Reactor *reactor,
00127 int flags,
00128 int use_select,
00129 int reuse_addr)
00130 {
00131 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Acceptor");
00132
00133 if (this->open (addr,
00134 reactor,
00135 flags,
00136 use_select,
00137 reuse_addr) == -1)
00138 ACE_ERROR ((LM_ERROR,
00139 ACE_TEXT ("%p\n"),
00140 ACE_TEXT ("ACE_Acceptor::ACE_Acceptor")));
00141 }
00142
00143 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00144 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Acceptor (void)
00145 {
00146 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Acceptor");
00147 this->handle_close ();
00148 }
00149
00150 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00151 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini (void)
00152 {
00153 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
00154 return ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close ();
00155 }
00156
00157
00158
00159 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00160 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init (int, ACE_TCHAR *[])
00161 {
00162 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init");
00163 return -1;
00164 }
00165
00166 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00167 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
00168 size_t length) const
00169 {
00170 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info");
00171 ACE_TCHAR buf[BUFSIZ];
00172 ACE_TCHAR addr_str[BUFSIZ];
00173 ACE_PEER_ACCEPTOR_ADDR addr;
00174
00175 if (this->acceptor ().get_local_addr (addr) == -1)
00176 return -1;
00177 else if (addr.addr_to_string (addr_str, sizeof addr_str) == -1)
00178 return -1;
00179
00180 ACE_OS::sprintf (buf,
00181 ACE_TEXT ("%s\t %s %s"),
00182 ACE_TEXT ("ACE_Acceptor"),
00183 addr_str,
00184 ACE_TEXT ("# acceptor factory\n"));
00185
00186 if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
00187 return -1;
00188 else
00189 ACE_OS::strsncpy (*strp, buf, length);
00190 return static_cast<int> (ACE_OS::strlen (buf));
00191 }
00192
00193 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00194 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend (void)
00195 {
00196 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");
00197 return this->reactor ()->suspend_handler (this);
00198 }
00199
00200 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00201 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume (void)
00202 {
00203 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");
00204 return this->reactor ()->resume_handler (this);
00205 }
00206
00207
00208
00209
00210 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00211 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close (void)
00212 {
00213 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close");
00214 return this->handle_close ();
00215 }
00216
00217 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00218 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_accept_error (void)
00219 {
00220 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_accept_error");
00221 return 0;
00222 }
00223
00224 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00225 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
00226 ACE_Reactor_Mask)
00227 {
00228 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
00229
00230 if (this->reactor () != 0)
00231 {
00232 ACE_HANDLE handle = this->get_handle ();
00233
00234 this->reactor ()->remove_handler
00235 (handle,
00236
00237
00238 ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL);
00239
00240
00241 if (this->peer_acceptor_.close () == -1)
00242 ACE_ERROR ((LM_ERROR,
00243 ACE_TEXT ("close\n")));
00244
00245
00246 this->reactor (0);
00247 }
00248 return 0;
00249 }
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00260 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
00261 {
00262 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler");
00263
00264 if (sh == 0)
00265 ACE_NEW_RETURN (sh,
00266 SVC_HANDLER,
00267 -1);
00268
00269
00270
00271 sh->reactor (this->reactor ());
00272 return 0;
00273 }
00274
00275
00276
00277
00278
00279 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00280 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
00281 (SVC_HANDLER *svc_handler)
00282 {
00283 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler");
00284
00285
00286
00287
00288
00289
00290
00291 ACE_Reactor *reactor = this->reactor ();
00292 bool reset_new_handle;
00293
00294 if (reactor)
00295 reset_new_handle = reactor->uses_event_associations ();
00296 else
00297 {
00298
00299 errno = EINVAL;
00300 return -1;
00301 }
00302
00303 if (this->acceptor ().accept (svc_handler->peer (),
00304 0,
00305 0,
00306 true,
00307 reset_new_handle
00308 ) == -1)
00309 {
00310
00311
00312 ACE_Errno_Guard error(errno);
00313
00314
00315 svc_handler->close (CLOSE_DURING_NEW_CONNECTION);
00316
00317 return -1;
00318 }
00319 else
00320 return 0;
00321 }
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00332 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
00333 (SVC_HANDLER *svc_handler)
00334 {
00335 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
00336
00337 int result = 0;
00338
00339
00340
00341 if (ACE_BIT_ENABLED (this->flags_,
00342 ACE_NONBLOCK))
00343 {
00344 if (svc_handler->peer ().enable (ACE_NONBLOCK) == -1)
00345 result = -1;
00346 }
00347
00348 else if (svc_handler->peer ().disable (ACE_NONBLOCK) == -1)
00349 result = -1;
00350
00351 if (result == 0 && svc_handler->open ((void *) this) == -1)
00352 result = -1;
00353
00354 if (result == -1)
00355
00356
00357 svc_handler->close (NORMAL_CLOSE_OPERATION);
00358
00359 return result;
00360 }
00361
00362
00363
00364
00365
00366 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00367 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE listener)
00368 {
00369 ACE_TRACE ("ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input");
00370 ACE_Handle_Set conn_handle;
00371
00372
00373 ACE_Time_Value timeout;
00374 # if defined (ACE_WIN32)
00375
00376
00377 int select_width = 0;
00378 # else
00379 int select_width = int (listener) + 1;
00380 # endif
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396 do
00397 {
00398
00399
00400
00401 SVC_HANDLER *svc_handler = 0;
00402
00403 if (this->make_svc_handler (svc_handler) == -1)
00404 {
00405 if (ACE::debug ())
00406 ACE_DEBUG ((LM_DEBUG,
00407 ACE_TEXT ("%p\n"),
00408 ACE_TEXT ("make_svc_handler")));
00409 return 0;
00410 }
00411
00412 else if (this->accept_svc_handler (svc_handler) == -1)
00413 {
00414
00415
00416 if (ACE::debug ())
00417 ACE_DEBUG ((LM_DEBUG,
00418 ACE_TEXT ("%p\n"),
00419 ACE_TEXT ("accept_svc_handler")));
00420 return this->handle_accept_error ();
00421 }
00422
00423
00424
00425
00426 else if (this->activate_svc_handler (svc_handler) == -1)
00427 {
00428
00429
00430
00431 if (ACE::debug ())
00432 ACE_DEBUG ((LM_DEBUG,
00433 ACE_TEXT ("%p\n"),
00434 ACE_TEXT ("activate_svc_handler")));
00435 return 0;
00436 }
00437
00438 conn_handle.set_bit (listener);
00439 }
00440
00441
00442
00443 while (this->use_select_
00444 && ACE_OS::select (select_width,
00445 conn_handle,
00446 0,
00447 0,
00448 &timeout) == 1);
00449 return 0;
00450 }
00451
00452 ACE_ALLOC_HOOK_DEFINE(ACE_Strategy_Acceptor)
00453
00454 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00455 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend (void)
00456 {
00457 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");
00458
00459
00460 if (this->scheduling_strategy_->suspend () == -1)
00461 return -1;
00462 else
00463 return ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend ();
00464 }
00465
00466 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00467 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume (void)
00468 {
00469 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");
00470
00471
00472 if (ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume () == -1)
00473 return -1;
00474 else
00475 return this->scheduling_strategy_->resume ();
00476 }
00477
00478 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
00479 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
00480 {
00481 #if defined (ACE_HAS_DUMP)
00482 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
00483
00484 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00485 ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump ();
00486 this->creation_strategy_->dump ();
00487 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_creation_strategy_ = %d"), delete_creation_strategy_));
00488 this->accept_strategy_->dump ();
00489 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_accept_strategy_ = %d"), delete_accept_strategy_));
00490 this->concurrency_strategy_->dump ();
00491 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_concurrency_strategy_ = %d"), delete_concurrency_strategy_));
00492 this->scheduling_strategy_->dump ();
00493 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_scheduling_strategy_ = %d"), delete_scheduling_strategy_));
00494 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nservice_name_ = %s"),
00495 this->service_name_ == 0 ? ACE_TEXT ("<unknown>") : this->service_name_));
00496 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nservice_description_ = %s"),
00497 this->service_description_ == 0 ? ACE_TEXT ("<unknown>") : this->service_description_));
00498 this->service_addr_.dump ();
00499 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00500 #endif
00501 }
00502
00503 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
00504 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
00505 {
00506 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
00507 return this->accept_strategy_->acceptor ();
00508 }
00509
00510 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00511 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR & () const
00512 {
00513 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
00514 return this->accept_strategy_->acceptor ();
00515 }
00516
00517
00518
00519 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
00520 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
00521 {
00522 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
00523 return this->accept_strategy_->get_handle ();
00524 }
00525
00526
00527
00528
00529
00530 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00531 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
00532 (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
00533 ACE_Reactor *reactor,
00534 int ,
00535 int use_select,
00536 int reuse_addr)
00537 {
00538 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
00539 return this->open
00540 (local_addr, reactor, 0, 0, 0, 0, 0, 0, use_select, reuse_addr);
00541 }
00542
00543
00544 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00545 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
00546 (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
00547 ACE_Reactor *reactor,
00548 ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
00549 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> *acc_s,
00550 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
00551 ACE_Scheduling_Strategy<SVC_HANDLER> *sch_s,
00552 const ACE_TCHAR *service_name,
00553 const ACE_TCHAR *service_description,
00554 int use_select,
00555 int reuse_addr)
00556 {
00557 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
00558
00559 if (this->service_name_ == 0 && service_name != 0)
00560 ACE_ALLOCATOR_RETURN (this->service_name_,
00561 ACE_OS::strdup (service_name),
00562 -1);
00563 if (this->service_description_ == 0 && service_description != 0)
00564 ACE_ALLOCATOR_RETURN (this->service_description_,
00565 ACE_OS::strdup (service_description),
00566 -1);
00567 this->reactor (reactor);
00568
00569
00570 if (reactor == 0)
00571 {
00572 errno = EINVAL;
00573 return -1;
00574 }
00575
00576
00577
00578 if (cre_s == 0)
00579 {
00580 ACE_NEW_RETURN (cre_s,
00581 CREATION_STRATEGY,
00582 -1);
00583 this->delete_creation_strategy_ = true;
00584 }
00585 this->creation_strategy_ = cre_s;
00586
00587
00588
00589 if (acc_s == 0)
00590 {
00591 ACE_NEW_RETURN (acc_s,
00592 ACCEPT_STRATEGY (this->reactor ()),
00593 -1);
00594 this->delete_accept_strategy_ = true;
00595 }
00596 this->accept_strategy_ = acc_s;
00597
00598 if (this->accept_strategy_->open (local_addr, reuse_addr) == -1)
00599 return -1;
00600
00601
00602
00603
00604
00605
00606
00607 if (this->accept_strategy_->acceptor ().enable (ACE_NONBLOCK) != 0)
00608 return -1;
00609
00610
00611
00612 if (con_s == 0)
00613 {
00614 ACE_NEW_RETURN (con_s,
00615 CONCURRENCY_STRATEGY,
00616 -1);
00617 this->delete_concurrency_strategy_ = true;
00618 }
00619 this->concurrency_strategy_ = con_s;
00620
00621
00622
00623 if (sch_s == 0)
00624 {
00625 ACE_NEW_RETURN (sch_s,
00626 SCHEDULING_STRATEGY,
00627 -1);
00628 this->delete_scheduling_strategy_ = true;
00629 }
00630 this->scheduling_strategy_ = sch_s;
00631
00632 this->use_select_ = use_select;
00633
00634 return this->reactor ()->register_handler
00635 (this,
00636 ACE_Event_Handler::ACCEPT_MASK);
00637 }
00638
00639
00640
00641 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00642 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
00643 (const ACE_TCHAR service_name[],
00644 const ACE_TCHAR service_description[],
00645 int use_select,
00646 int reuse_addr)
00647 : creation_strategy_ (0),
00648 delete_creation_strategy_ (false),
00649 accept_strategy_ (0),
00650 delete_accept_strategy_ (false),
00651 concurrency_strategy_ (0),
00652 delete_concurrency_strategy_ (false),
00653 scheduling_strategy_ (0),
00654 delete_scheduling_strategy_ (false),
00655 service_name_ (0),
00656 service_description_ (0)
00657 {
00658 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor");
00659
00660 if (service_name != 0)
00661 ACE_ALLOCATOR (this->service_name_,
00662 ACE_OS::strdup (service_name));
00663 if (service_description != 0)
00664 ACE_ALLOCATOR (this->service_description_,
00665 ACE_OS::strdup (service_description));
00666 this->use_select_ = use_select;
00667 this->reuse_addr_ = reuse_addr;
00668 }
00669
00670 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00671 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor
00672 (const ACE_PEER_ACCEPTOR_ADDR &addr,
00673 ACE_Reactor *reactor,
00674 ACE_Creation_Strategy<SVC_HANDLER> *cre_s,
00675 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> *acc_s,
00676 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
00677 ACE_Scheduling_Strategy<SVC_HANDLER> *sch_s,
00678 const ACE_TCHAR service_name[],
00679 const ACE_TCHAR service_description[],
00680 int use_select,
00681 int reuse_addr)
00682 : creation_strategy_ (0),
00683 delete_creation_strategy_ (false),
00684 accept_strategy_ (0),
00685 delete_accept_strategy_ (false),
00686 concurrency_strategy_ (0),
00687 delete_concurrency_strategy_ (false),
00688 scheduling_strategy_ (0),
00689 delete_scheduling_strategy_ (false),
00690 service_name_ (0),
00691 service_description_ (0)
00692 {
00693 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Strategy_Acceptor");
00694
00695 if (this->open (addr,
00696 reactor,
00697 cre_s,
00698 acc_s,
00699 con_s,
00700 sch_s,
00701 service_name,
00702 service_description,
00703 use_select,
00704 reuse_addr) == -1)
00705 ACE_ERROR ((LM_ERROR,
00706 ACE_TEXT ("%p\n"),
00707 ACE_TEXT ("ACE_Strategy_Acceptor::ACE_Strategy_Acceptor")));
00708 }
00709
00710
00711
00712
00713 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00714 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
00715 ACE_Reactor_Mask)
00716 {
00717 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
00718
00719 if (this->reactor () != 0)
00720 {
00721 ACE_HANDLE handle = this->get_handle ();
00722
00723 if (this->delete_creation_strategy_)
00724 delete this->creation_strategy_;
00725 this->delete_creation_strategy_ = false;
00726 this->creation_strategy_ = 0;
00727
00728 if (this->delete_accept_strategy_)
00729 delete this->accept_strategy_;
00730 this->delete_accept_strategy_ = false;
00731 this->accept_strategy_ = 0;
00732
00733 if (this->delete_concurrency_strategy_)
00734 delete this->concurrency_strategy_;
00735 this->delete_concurrency_strategy_ = false;
00736 this->concurrency_strategy_ = 0;
00737
00738 if (this->delete_scheduling_strategy_)
00739 delete this->scheduling_strategy_;
00740 this->delete_scheduling_strategy_ = false;
00741 this->scheduling_strategy_ = 0;
00742
00743
00744
00745
00746 this->reactor ()->remove_handler
00747 (handle,
00748 ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL);
00749
00750
00751
00752 this->reactor (0);
00753 }
00754 return 0;
00755 }
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00766 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler (SVC_HANDLER *&sh)
00767 {
00768 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::make_svc_handler");
00769 return this->creation_strategy_->make_svc_handler (sh);
00770 }
00771
00772
00773
00774
00775
00776 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00777 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
00778 (SVC_HANDLER *svc_handler)
00779 {
00780 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler");
00781 return this->accept_strategy_->accept_svc_handler (svc_handler);
00782 }
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00793 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
00794 (SVC_HANDLER *svc_handler)
00795 {
00796 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
00797 return this->concurrency_strategy_->activate_svc_handler
00798 (svc_handler,
00799 (void *) this);
00800 }
00801
00802 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00803 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Strategy_Acceptor (void)
00804 {
00805 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Strategy_Acceptor");
00806 ACE_OS::free ((void *) this->service_name_);
00807 ACE_OS::free ((void *) this->service_description_);
00808 this->handle_close ();
00809 }
00810
00811
00812
00813 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00814 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_signal (int, siginfo_t *, ucontext_t *)
00815 {
00816 ACE_Reactor::instance()->end_reactor_event_loop ();
00817 return 0;
00818 }
00819
00820 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00821 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
00822 size_t length) const
00823 {
00824 ACE_TRACE ("ACE_Strategy_Acceptor::info");
00825
00826 ACE_TCHAR buf[BUFSIZ];
00827 ACE_TCHAR service_addr_str[BUFSIZ];
00828 ACE_PEER_ACCEPTOR_ADDR addr;
00829
00830 if (this->acceptor ().get_local_addr (addr) == -1)
00831 return -1;
00832 else if (addr.addr_to_string (service_addr_str,
00833 sizeof service_addr_str) == -1)
00834 return -1;
00835
00836
00837 ACE_OS::sprintf (buf,
00838 ACE_TEXT ("%s\t %s #%s\n"),
00839 this->service_name_ == 0
00840 ? ACE_TEXT ("<unknown>")
00841 : this->service_name_,
00842 service_addr_str,
00843 this->service_description_ == 0
00844 ? ACE_TEXT ("<unknown>")
00845 : this->service_description_);
00846
00847 if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
00848 return -1;
00849 else
00850 ACE_OS::strsncpy (*strp, buf, length);
00851 return static_cast<int> (ACE_OS::strlen (buf));
00852 }
00853
00854 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00855 ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini (void)
00856 {
00857 ACE_TRACE ("ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
00858 return this->ACE_Strategy_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close ();
00859 }
00860
00861 ACE_ALLOC_HOOK_DEFINE(ACE_Oneshot_Acceptor)
00862
00863 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
00864 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
00865 {
00866 #if defined (ACE_HAS_DUMP)
00867 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
00868
00869 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00870 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsvc_handler_ = %x"), this->svc_handler_));
00871 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nrestart_ = %d"), this->restart_));
00872 this->peer_acceptor_.dump ();
00873 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_concurrency_strategy_ = %d"),
00874 delete_concurrency_strategy_));
00875 this->concurrency_strategy_->dump ();
00876 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00877 #endif
00878 }
00879
00880 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00881 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
00882 (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
00883 ACE_Reactor *reactor,
00884 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s)
00885 {
00886 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open");
00887 this->reactor (reactor);
00888
00889
00890
00891 if (con_s == 0)
00892 {
00893 ACE_NEW_RETURN (con_s,
00894 ACE_Concurrency_Strategy<SVC_HANDLER>,
00895 -1);
00896 this->delete_concurrency_strategy_ = true;
00897 }
00898 this->concurrency_strategy_ = con_s;
00899
00900
00901 return this->peer_acceptor_.open (local_addr, 1);
00902 }
00903
00904 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00905 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor (void)
00906 : delete_concurrency_strategy_ (false)
00907 {
00908 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor");
00909 this->reactor (0);
00910 }
00911
00912 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00913 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor
00914 (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
00915 ACE_Reactor *reactor,
00916 ACE_Concurrency_Strategy<SVC_HANDLER> *cs)
00917 : delete_concurrency_strategy_ (false)
00918 {
00919 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor");
00920 if (this->open (local_addr, reactor, cs) == -1)
00921 ACE_ERROR ((LM_ERROR,
00922 ACE_TEXT ("%p\n"),
00923 ACE_TEXT ("ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor")));
00924 }
00925
00926 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00927 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Oneshot_Acceptor (void)
00928 {
00929 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Oneshot_Acceptor");
00930 this->handle_close ();
00931 }
00932
00933 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00934 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close (void)
00935 {
00936 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::close");
00937 return this->handle_close ();
00938 }
00939
00940 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00941 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close (ACE_HANDLE,
00942 ACE_Reactor_Mask)
00943 {
00944 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_close");
00945
00946
00947 if (this->delete_concurrency_strategy_)
00948 {
00949 delete this->concurrency_strategy_;
00950 this->delete_concurrency_strategy_ = false;
00951 this->concurrency_strategy_ = 0;
00952 }
00953
00954
00955
00956 if (this->reactor ())
00957 this->reactor ()->remove_handler
00958 (this,
00959 ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL);
00960
00961 if (this->peer_acceptor_.close () == -1)
00962 ACE_ERROR ((LM_ERROR,
00963 ACE_TEXT ("close\n")));
00964 return 0;
00965 }
00966
00967 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00968 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_timeout
00969 (const ACE_Time_Value &tv,
00970 const void *arg)
00971 {
00972 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_timeout");
00973 errno = ETIME;
00974
00975 if (this->svc_handler_->handle_timeout (tv, arg) == -1)
00976 this->svc_handler_->handle_close (this->svc_handler_->get_handle (),
00977 ACE_Event_Handler::TIMER_MASK);
00978
00979
00980
00981 if (this->reactor ())
00982 this->reactor ()->remove_handler (this,
00983 ACE_Event_Handler::ACCEPT_MASK);
00984 return 0;
00985 }
00986
00987 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00988 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::cancel (void)
00989 {
00990 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::cancel");
00991 return this->reactor () && this->reactor ()->cancel_timer (this);
00992 }
00993
00994 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00995 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::register_handler
00996 (SVC_HANDLER *svc_handler,
00997 const ACE_Synch_Options &synch_options,
00998 bool restart)
00999 {
01000 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::register_handler");
01001
01002 if (this->reactor () == 0)
01003 {
01004 errno = EINVAL;
01005 return -1;
01006 }
01007 else
01008 {
01009 this->svc_handler_ = svc_handler;
01010 this->restart_ = restart;
01011 ACE_Time_Value *tv = (ACE_Time_Value *) synch_options.time_value ();
01012
01013 if (tv != 0
01014 && this->reactor ()->schedule_timer (this,
01015 synch_options.arg (),
01016 *tv) == 0)
01017 return -1;
01018 else
01019 return this->reactor ()->register_handler
01020 (this,
01021 ACE_Event_Handler::ACCEPT_MASK);
01022 }
01023 }
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01034 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler
01035 (SVC_HANDLER *svc_handler)
01036 {
01037 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::activate_svc_handler");
01038 return this->concurrency_strategy_->activate_svc_handler
01039 (svc_handler,
01040 (void *) this);
01041 }
01042
01043
01044
01045
01046 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01047 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::shared_accept
01048 (SVC_HANDLER *svc_handler,
01049 ACE_PEER_ACCEPTOR_ADDR *remote_addr,
01050 ACE_Time_Value *timeout,
01051 bool restart,
01052 bool reset_new_handle)
01053 {
01054 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::shared_accept");
01055 if (svc_handler == 0)
01056 return -1;
01057
01058
01059 else if (this->peer_acceptor_.accept (svc_handler->peer (),
01060 remote_addr,
01061 timeout,
01062 restart,
01063 reset_new_handle
01064 ) == -1)
01065 {
01066
01067 if (!(errno == EWOULDBLOCK || errno == ETIME))
01068
01069 svc_handler->close (CLOSE_DURING_NEW_CONNECTION);
01070 return -1;
01071 }
01072
01073
01074
01075 else
01076 return this->activate_svc_handler (svc_handler);
01077 }
01078
01079
01080
01081
01082
01083 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01084 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept
01085 (SVC_HANDLER *svc_handler,
01086 ACE_PEER_ACCEPTOR_ADDR *remote_addr,
01087 const ACE_Synch_Options &synch_options,
01088 bool restart,
01089 bool reset_new_handle)
01090 {
01091 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept");
01092
01093
01094
01095
01096
01097
01098
01099 ACE_Time_Value *timeout;
01100 int use_reactor = synch_options[ACE_Synch_Options::USE_REACTOR];
01101
01102 if (use_reactor)
01103 timeout = (ACE_Time_Value *) &ACE_Time_Value::zero;
01104 else
01105 timeout = (ACE_Time_Value *) synch_options.time_value ();
01106
01107 if (this->shared_accept (svc_handler,
01108 remote_addr,
01109 timeout,
01110 restart,
01111 reset_new_handle
01112 ) == -1)
01113 {
01114 if (use_reactor && errno == EWOULDBLOCK)
01115
01116
01117 this->register_handler (svc_handler,
01118 synch_options,
01119 restart);
01120 return -1;
01121 }
01122 return 0;
01123 }
01124
01125
01126
01127
01128 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01129 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input (ACE_HANDLE)
01130 {
01131 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::handle_input");
01132 int result = 0;
01133
01134
01135 this->cancel ();
01136
01137
01138
01139
01140
01141
01142 bool const reset_new_handle = this->reactor ()->uses_event_associations ();
01143
01144
01145
01146
01147
01148 if (this->reactor ())
01149 this->reactor ()->remove_handler
01150 (this,
01151 ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL);
01152
01153 if (this->shared_accept (this->svc_handler_,
01154 0,
01155 0,
01156 this->restart_,
01157 reset_new_handle
01158 ) == -1)
01159 result = -1;
01160
01161 return result;
01162 }
01163
01164
01165
01166 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01167 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init (int, ACE_TCHAR *[])
01168 {
01169 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::init");
01170 return -1;
01171 }
01172
01173 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01174 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini (void)
01175 {
01176 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::fini");
01177 return this->handle_close ();
01178 }
01179
01180 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01181 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info (ACE_TCHAR **strp,
01182 size_t length) const
01183 {
01184 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::info");
01185 ACE_TCHAR buf[BUFSIZ];
01186 ACE_TCHAR addr_str[BUFSIZ];
01187 ACE_PEER_ACCEPTOR_ADDR addr;
01188
01189 if (this->peer_acceptor_.get_local_addr (addr) == -1)
01190 return -1;
01191 else if (addr.addr_to_string (addr_str, sizeof addr_str) == -1)
01192 return -1;
01193
01194 ACE_OS::sprintf (buf,
01195 ACE_TEXT ("%s\t %s %s"),
01196 ACE_TEXT ("ACE_Oneshot_Acceptor"),
01197 addr_str,
01198 ACE_TEXT ("#oneshot acceptor factory\n"));
01199
01200 if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
01201 return -1;
01202 else
01203 ACE_OS::strsncpy (*strp, buf, length);
01204 return static_cast<int> (ACE_OS::strlen (buf));
01205 }
01206
01207 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01208 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend (void)
01209 {
01210 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::suspend");
01211 return this->reactor () && this->reactor ()->suspend_handler (this);
01212 }
01213
01214 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
01215 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume (void)
01216 {
01217 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::resume");
01218 return this->reactor () && this->reactor ()->resume_handler (this);
01219 }
01220
01221
01222
01223 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
01224 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
01225 {
01226 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
01227 return this->peer_acceptor_.get_handle ();
01228 }
01229
01230 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
01231 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
01232 {
01233 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
01234 return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
01235 }
01236
01237 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
01238 ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR & () const
01239 {
01240 ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::operator ACE_PEER_ACCEPTOR &");
01241 return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
01242 }
01243
01244 ACE_END_VERSIONED_NAMESPACE_DECL
01245
01246 #endif