ACE/ace/WIN32_Proactor.cpp

   1 //
   2
   3 #include "ace/WIN32_Proactor.h"
   4
   5 #if defined (ACE_WIN32) && defined (ACE_HAS_WIN32_OVERLAPPED_IO)
   6 // WIN implemenatation of the Proactor.
   7
   8 #include "ace/Log_Category.h"
   9 #include "ace/Object_Manager.h"
  10 #include "ace/OS_NS_errno.h"
  11 #include "ace/OS_NS_unistd.h"
  12
  13 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  14
  15 /**
  16  * @class ACE_WIN32_Wakeup_Completion
  17  *
  18  * This is result object is used by the <end_event_loop> of the
  19  * ACE_Proactor interface to wake up all the threads blocking
  20  * for completions.
  21  */
  22 class ACE_WIN32_Wakeup_Completion : public ACE_WIN32_Asynch_Result
  23 {
  24
  25 public:
  26   /// Constructor.
  27   ACE_WIN32_Wakeup_Completion (ACE_Handler::Proxy_Ptr &handler_proxy,
  28                                const void *act = 0,
  29                                ACE_HANDLE event = ACE_INVALID_HANDLE,
  30                                int priority = 0,
  31                                int signal_number = ACE_SIGRTMIN);
  32
  33   /// Destructor.
  34   virtual ~ACE_WIN32_Wakeup_Completion (void);
  35
  36   /// This method calls the <handler>'s <handle_wakeup> method.
  37   virtual void complete (size_t bytes_transferred = 0,
  38                          int success = 1,
  39                          const void *completion_key = 0,
  40                          u_long error = 0);
  41 };
  42
  43 ACE_WIN32_Proactor::ACE_WIN32_Proactor (size_t number_of_threads,
  44                                         bool used_with_reactor_event_loop)
  45   : completion_port_ (0),
  46     // This *MUST* be 0, *NOT* ACE_INVALID_HANDLE !!!
  47     number_of_threads_ (static_cast<DWORD> (number_of_threads)),
  48     used_with_reactor_event_loop_ (used_with_reactor_event_loop)
  49 {
  50   // Create the completion port.
  51   this->completion_port_ = ::CreateIoCompletionPort (INVALID_HANDLE_VALUE,
  52                                                      0,
  53                                                      0,
  54                                                      this->number_of_threads_);
  55   if (this->completion_port_ == 0)
  56     ACELIB_ERROR ((LM_ERROR,
  57                 ACE_TEXT ("%p\n"),
  58                 ACE_TEXT ("CreateIoCompletionPort")));
  59
  60   this->get_asynch_pseudo_task ().start ();
  61 }
  62
  63 ACE_WIN32_Proactor::~ACE_WIN32_Proactor (void)
  64 {
  65   this->get_asynch_pseudo_task ().stop ();
  66
  67   this->close ();
  68 }
  69
  70 ACE_Asynch_Pseudo_Task &
  71 ACE_WIN32_Proactor::get_asynch_pseudo_task ()
  72 {
  73   return this->pseudo_task_;
  74 }
  75
  76 int
  77 ACE_WIN32_Proactor::close (void)
  78 {
  79   // Close the completion port
  80   if (this->completion_port_ != 0)
  81     {
  82       // To avoid memory leaks we should delete all results from queue.
  83
  84       for (;;)
  85         {
  86           ACE_OVERLAPPED *overlapped = 0;
  87           u_long bytes_transferred = 0;
  88           ULONG_PTR completion_key = 0;
  89
  90           // Get the next asynchronous operation that completes
  91           BOOL res = ::GetQueuedCompletionStatus
  92             (this->completion_port_,
  93              &bytes_transferred,
  94              &completion_key,
  95              &overlapped,
  96              0);  // poll
  97
  98           if (overlapped == 0 || res == FALSE)
  99             break;
 100
 101           ACE_WIN32_Asynch_Result *asynch_result =
 102             (ACE_WIN32_Asynch_Result *) overlapped;
 103
 104           delete asynch_result;
 105         }
 106
 107       int result = ACE_OS::close (this->completion_port_);
 108       this->completion_port_ = 0;
 109       return result;
 110     }
 111
 112   return 0;
 113 }
 114
 115 int
 116 ACE_WIN32_Proactor::register_handle (ACE_HANDLE handle,
 117                                      const void *completion_key)
 118 {
 119   ULONG_PTR comp_key (reinterpret_cast<ULONG_PTR> (completion_key));
 120
 121   // No locking is needed here as no state changes.
 122   ACE_HANDLE cp = ::CreateIoCompletionPort (handle,
 123                                             this->completion_port_,
 124                                             comp_key,
 125                                             this->number_of_threads_);
 126   if (cp == 0)
 127     {
 128       ACE_OS::set_errno_to_last_error ();
 129       // If errno == ERROR_INVALID_PARAMETER, then this handle was
 130       // already registered.
 131       if (errno != ERROR_INVALID_PARAMETER)
 132         {
 133           if (ACE::debug ())
 134             {
 135               ACELIB_DEBUG ((LM_ERROR,
 136                           ACE_TEXT ("%p\n"),
 137                           ACE_TEXT ("CreateIoCompletionPort")));
 138             }
 139           return -1;
 140         }
 141     }
 142   return 0;
 143 }
 144
 145 ACE_Asynch_Read_Stream_Impl *
 146 ACE_WIN32_Proactor::create_asynch_read_stream (void)
 147 {
 148   ACE_Asynch_Read_Stream_Impl *implementation = 0;
 149   ACE_NEW_RETURN (implementation,
 150                   ACE_WIN32_Asynch_Read_Stream (this),
 151                   0);
 152   return implementation;
 153 }
 154
 155 ACE_Asynch_Write_Stream_Impl *
 156 ACE_WIN32_Proactor::create_asynch_write_stream (void)
 157 {
 158   ACE_Asynch_Write_Stream_Impl *implementation = 0;
 159   ACE_NEW_RETURN (implementation,
 160                   ACE_WIN32_Asynch_Write_Stream (this),
 161                   0);
 162   return implementation;
 163 }
 164
 165 ACE_Asynch_Read_Dgram_Impl *
 166 ACE_WIN32_Proactor::create_asynch_read_dgram (void)
 167 {
 168   ACE_Asynch_Read_Dgram_Impl *implementation = 0;
 169   ACE_NEW_RETURN (implementation,
 170                   ACE_WIN32_Asynch_Read_Dgram (this),
 171                   0);
 172   return implementation;
 173 }
 174
 175 ACE_Asynch_Write_Dgram_Impl *
 176 ACE_WIN32_Proactor::create_asynch_write_dgram (void)
 177 {
 178   ACE_Asynch_Write_Dgram_Impl *implementation = 0;
 179   ACE_NEW_RETURN (implementation,
 180                   ACE_WIN32_Asynch_Write_Dgram (this),
 181                   0);
 182   return implementation;
 183 }
 184
 185 ACE_Asynch_Read_File_Impl *
 186 ACE_WIN32_Proactor::create_asynch_read_file (void)
 187 {
 188   ACE_Asynch_Read_File_Impl *implementation = 0;
 189   ACE_NEW_RETURN (implementation,
 190                   ACE_WIN32_Asynch_Read_File (this),
 191                   0);
 192   return  implementation;
 193 }
 194
 195 ACE_Asynch_Write_File_Impl *
 196 ACE_WIN32_Proactor::create_asynch_write_file (void)
 197 {
 198   ACE_Asynch_Write_File_Impl *implementation = 0;
 199   ACE_NEW_RETURN (implementation,
 200                   ACE_WIN32_Asynch_Write_File (this),
 201                   0);
 202   return  implementation;
 203 }
 204
 205 ACE_Asynch_Accept_Impl *
 206 ACE_WIN32_Proactor::create_asynch_accept (void)
 207 {
 208   ACE_Asynch_Accept_Impl *implementation = 0;
 209   ACE_NEW_RETURN (implementation,
 210                   ACE_WIN32_Asynch_Accept (this),
 211                   0);
 212   return implementation;
 213 }
 214
 215 ACE_Asynch_Connect_Impl *
 216 ACE_WIN32_Proactor::create_asynch_connect (void)
 217 {
 218   ACE_Asynch_Connect_Impl *implementation = 0;
 219   ACE_NEW_RETURN (implementation,
 220                   ACE_WIN32_Asynch_Connect (this),
 221                   0);
 222   return implementation;
 223 }
 224
 225 ACE_Asynch_Transmit_File_Impl *
 226 ACE_WIN32_Proactor::create_asynch_transmit_file (void)
 227 {
 228   ACE_Asynch_Transmit_File_Impl *implementation = 0;
 229   ACE_NEW_RETURN (implementation,
 230                   ACE_WIN32_Asynch_Transmit_File (this),
 231                   0);
 232   return  implementation;
 233 }
 234
 235 ACE_Asynch_Read_Stream_Result_Impl *
 236 ACE_WIN32_Proactor::create_asynch_read_stream_result
 237   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 238    ACE_HANDLE handle,
 239    ACE_Message_Block &message_block,
 240    size_t bytes_to_read,
 241    const void* act,
 242    ACE_HANDLE event,
 243    int priority,
 244    int signal_number)
 245 {
 246   ACE_Asynch_Read_Stream_Result_Impl *implementation = 0;
 247   ACE_NEW_RETURN (implementation,
 248                   ACE_WIN32_Asynch_Read_Stream_Result (handler_proxy,
 249                                                        handle,
 250                                                        message_block,
 251                                                        bytes_to_read,
 252                                                        act,
 253                                                        event,
 254                                                        priority,
 255                                                        signal_number),
 256                   0);
 257   return implementation;
 258 }
 259
 260 ACE_Asynch_Write_Stream_Result_Impl *
 261 ACE_WIN32_Proactor::create_asynch_write_stream_result
 262   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 263    ACE_HANDLE handle,
 264    ACE_Message_Block &message_block,
 265    size_t bytes_to_write,
 266    const void* act,
 267    ACE_HANDLE event,
 268    int priority,
 269    int signal_number)
 270 {
 271   ACE_Asynch_Write_Stream_Result_Impl *implementation = 0;
 272   ACE_NEW_RETURN (implementation,
 273                   ACE_WIN32_Asynch_Write_Stream_Result (handler_proxy,
 274                                                         handle,
 275                                                         message_block,
 276                                                         bytes_to_write,
 277                                                         act,
 278                                                         event,
 279                                                         priority,
 280                                                         signal_number),
 281                   0);
 282   return implementation;
 283 }
 284
 285 ACE_Asynch_Read_File_Result_Impl *
 286 ACE_WIN32_Proactor::create_asynch_read_file_result
 287   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 288    ACE_HANDLE handle,
 289    ACE_Message_Block &message_block,
 290    size_t bytes_to_read,
 291    const void* act,
 292    u_long offset,
 293    u_long offset_high,
 294    ACE_HANDLE event,
 295    int priority,
 296    int signal_number)
 297 {
 298   ACE_Asynch_Read_File_Result_Impl *implementation = 0;
 299   ACE_NEW_RETURN (implementation,
 300                   ACE_WIN32_Asynch_Read_File_Result (handler_proxy,
 301                                                      handle,
 302                                                      message_block,
 303                                                      bytes_to_read,
 304                                                      act,
 305                                                      offset,
 306                                                      offset_high,
 307                                                      event,
 308                                                      priority,
 309                                                      signal_number),
 310                   0);
 311   return implementation;
 312 }
 313
 314 ACE_Asynch_Write_File_Result_Impl *
 315 ACE_WIN32_Proactor::create_asynch_write_file_result
 316  (const ACE_Handler::Proxy_Ptr &handler_proxy,
 317   ACE_HANDLE handle,
 318   ACE_Message_Block &message_block,
 319   size_t bytes_to_write,
 320   const void* act,
 321   u_long offset,
 322   u_long offset_high,
 323   ACE_HANDLE event,
 324   int priority,
 325   int signal_number)
 326 {
 327   ACE_Asynch_Write_File_Result_Impl *implementation = 0;
 328   ACE_NEW_RETURN (implementation,
 329                   ACE_WIN32_Asynch_Write_File_Result (handler_proxy,
 330                                                       handle,
 331                                                       message_block,
 332                                                       bytes_to_write,
 333                                                       act,
 334                                                       offset,
 335                                                       offset_high,
 336                                                       event,
 337                                                       priority,
 338                                                       signal_number),
 339                   0);
 340   return implementation;
 341 }
 342
 343 ACE_Asynch_Read_Dgram_Result_Impl *
 344 ACE_WIN32_Proactor::create_asynch_read_dgram_result
 345   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 346    ACE_HANDLE handle,
 347    ACE_Message_Block *message_block,
 348    size_t bytes_to_read,
 349    int flags,
 350    int protocol_family,
 351    const void* act,
 352    ACE_HANDLE event,
 353    int priority,
 354    int signal_number)
 355 {
 356   ACE_Asynch_Read_Dgram_Result_Impl *implementation = 0;
 357   ACE_NEW_RETURN (implementation,
 358                   ACE_WIN32_Asynch_Read_Dgram_Result (handler_proxy,
 359                                                       handle,
 360                                                       message_block,
 361                                                       bytes_to_read,
 362                                                       flags,
 363                                                       protocol_family,
 364                                                       act,
 365                                                       event,
 366                                                       priority,
 367                                                       signal_number),
 368                   0);
 369   return implementation;
 370 }
 371
 372 ACE_Asynch_Write_Dgram_Result_Impl *
 373 ACE_WIN32_Proactor::create_asynch_write_dgram_result
 374   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 375    ACE_HANDLE handle,
 376    ACE_Message_Block *message_block,
 377    size_t bytes_to_read,
 378    int flags,
 379    const void* act,
 380    ACE_HANDLE event,
 381    int priority,
 382    int signal_number)
 383 {
 384   ACE_Asynch_Write_Dgram_Result_Impl *implementation = 0;
 385   ACE_NEW_RETURN (implementation,
 386                   ACE_WIN32_Asynch_Write_Dgram_Result(handler_proxy,
 387                                                       handle,
 388                                                       message_block,
 389                                                       bytes_to_read,
 390                                                       flags,
 391                                                       act,
 392                                                       event,
 393                                                       priority,
 394                                                       signal_number),
 395                  0);
 396   return implementation;
 397 }
 398
 399 ACE_Asynch_Accept_Result_Impl *
 400 ACE_WIN32_Proactor::create_asynch_accept_result
 401   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 402    ACE_HANDLE listen_handle,
 403    ACE_HANDLE accept_handle,
 404    ACE_Message_Block &message_block,
 405    size_t bytes_to_read,
 406    const void* act,
 407    ACE_HANDLE event,
 408    int priority,
 409    int signal_number)
 410 {
 411   ACE_Asynch_Accept_Result_Impl *implementation = 0;
 412   ACE_NEW_RETURN (implementation,
 413                   ACE_WIN32_Asynch_Accept_Result (handler_proxy,
 414                                                   listen_handle,
 415                                                   accept_handle,
 416                                                   message_block,
 417                                                   bytes_to_read,
 418                                                   act,
 419                                                   event,
 420                                                   priority,
 421                                                   signal_number),
 422                   0);
 423   return implementation;
 424 }
 425
 426 ACE_Asynch_Connect_Result_Impl *
 427 ACE_WIN32_Proactor::create_asynch_connect_result
 428   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 429    ACE_HANDLE connect_handle,
 430    const void *act,
 431    ACE_HANDLE event,
 432    int priority,
 433    int signal_number)
 434 {
 435   ACE_Asynch_Connect_Result_Impl *implementation = 0;
 436   ACE_NEW_RETURN (implementation,
 437                   ACE_WIN32_Asynch_Connect_Result (handler_proxy,
 438                                                    connect_handle,
 439                                                    act,
 440                                                    event,
 441                                                    priority,
 442                                                    signal_number),
 443                   0);
 444   return implementation;
 445 }
 446
 447 ACE_Asynch_Transmit_File_Result_Impl *
 448 ACE_WIN32_Proactor::create_asynch_transmit_file_result
 449   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 450    ACE_HANDLE socket,
 451    ACE_HANDLE file,
 452    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
 453    size_t bytes_to_write,
 454    u_long offset,
 455    u_long offset_high,
 456    size_t bytes_per_send,
 457    u_long flags,
 458    const void *act,
 459    ACE_HANDLE event,
 460    int priority,
 461    int signal_number)
 462 {
 463   ACE_Asynch_Transmit_File_Result_Impl *implementation = 0;
 464   ACE_NEW_RETURN (implementation,
 465                   ACE_WIN32_Asynch_Transmit_File_Result (handler_proxy,
 466                                                          socket,
 467                                                          file,
 468                                                          header_and_trailer,
 469                                                          bytes_to_write,
 470                                                          offset,
 471                                                          offset_high,
 472                                                          bytes_per_send,
 473                                                          flags,
 474                                                          act,
 475                                                          event,
 476                                                          priority,
 477                                                          signal_number),
 478                   0);
 479   return implementation;
 480 }
 481
 482 ACE_Asynch_Result_Impl *
 483 ACE_WIN32_Proactor::create_asynch_timer (const ACE_Handler::Proxy_Ptr &handler_proxy,
 484                                          const void *act,
 485                                          const ACE_Time_Value &tv,
 486                                          ACE_HANDLE event,
 487                                          int priority,
 488                                          int signal_number)
 489 {
 490   ACE_Asynch_Result_Impl *implementation = 0;
 491   ACE_NEW_RETURN (implementation,
 492                   ACE_WIN32_Asynch_Timer (handler_proxy,
 493                                           act,
 494                                           tv,
 495                                           event,
 496                                           priority,
 497                                           signal_number),
 498                   0);
 499   return implementation;
 500 }
 501
 502 int
 503 ACE_WIN32_Proactor::handle_signal (int, siginfo_t *, ucontext_t *)
 504 {
 505   // Perform a non-blocking "poll" for all the I/O events that have
 506   // completed in the I/O completion queue.
 507
 508   int result = 0;
 509
 510   for (ACE_Time_Value timeout (0, 0);
 511        ;
 512       )
 513     {
 514       result = this->handle_events (timeout);
 515
 516       if (result != 1)
 517         break;
 518     }
 519
 520   // If our handle_events failed, we'll report a failure to the
 521   // Reactor.
 522   return result == -1 ? -1 : 0;
 523 }
 524
 525 int
 526 ACE_WIN32_Proactor::handle_close (ACE_HANDLE handle,
 527                                   ACE_Reactor_Mask close_mask)
 528 {
 529   ACE_UNUSED_ARG (close_mask);
 530   ACE_UNUSED_ARG (handle);
 531
 532   return this->close ();
 533 }
 534
 535 ACE_HANDLE
 536 ACE_WIN32_Proactor::get_handle (void) const
 537 {
 538   if (this->used_with_reactor_event_loop_)
 539     return this->event_.handle ();
 540   else
 541     return 0;
 542 }
 543
 544 int
 545 ACE_WIN32_Proactor::handle_events (ACE_Time_Value &wait_time)
 546 {
 547   // Decrement <wait_time> with the amount of time spent in the method
 548   ACE_Countdown_Time countdown (&wait_time);
 549   return this->handle_events (wait_time.msec ());
 550 }
 551
 552 int
 553 ACE_WIN32_Proactor::handle_events (void)
 554 {
 555   return this->handle_events (ACE_INFINITE);
 556 }
 557
 558 int
 559 ACE_WIN32_Proactor::handle_events (unsigned long milli_seconds)
 560 {
 561   ACE_OVERLAPPED *overlapped = 0;
 562   u_long bytes_transferred = 0;
 563   ULONG_PTR completion_key = 0;
 564
 565   // Get the next asynchronous operation that completes
 566   BOOL result = ::GetQueuedCompletionStatus (this->completion_port_,
 567                                              &bytes_transferred,
 568                                              &completion_key,
 569                                              &overlapped,
 570                                              milli_seconds);
 571   if (result == FALSE && overlapped == 0)
 572     {
 573       ACE_OS::set_errno_to_last_error ();
 574
 575       switch (errno)
 576         {
 577         case WAIT_TIMEOUT:
 578           errno = ETIME;
 579           return 0;
 580
 581         case ERROR_SUCCESS:
 582           // Calling GetQueuedCompletionStatus with timeout value 0
 583           // returns FALSE with extended errno "ERROR_SUCCESS" errno =
 584           // ETIME; ?? I don't know if this has to be done !!
 585           return 0;
 586
 587         default:
 588           if (ACE::debug ())
 589             ACELIB_DEBUG ((LM_ERROR,
 590                         ACE_TEXT ("%p\n"),
 591                         ACE_TEXT ("GetQueuedCompletionStatus")));
 592           return -1;
 593         }
 594     }
 595   else if (overlapped != 0)
 596     {
 597       // Narrow the result.
 598       ACE_WIN32_Asynch_Result *asynch_result = (ACE_WIN32_Asynch_Result *) overlapped;
 599
 600       // If errors happen, grab the error.
 601       if (result == FALSE)
 602         ACE_OS::set_errno_to_last_error ();
 603       else
 604         errno = 0;
 605
 606       u_long result_err = asynch_result->error ();
 607
 608       // if "result_err" is 0 than
 609       //     It is normal OS/WIN32 AIO completion.
 610       //     We have cleared asynch_result->error_
 611       //     during shared_read/shared_write.
 612       //     The real error code is already stored in "errno",
 613       //     so copy "errno" value to the "result_err"
 614       //     and pass this "result_err" code
 615       //     to the application_specific_code ()
 616       // else
 617       //    "result_err" non zero
 618       //     it means we have "post_completed" result
 619       //     so pass this "result_err" code
 620       //     to the application_specific_code ()
 621
 622       if (result_err == 0)
 623         result_err = errno ;
 624
 625       this->application_specific_code (asynch_result,
 626                                        static_cast<size_t> (bytes_transferred),
 627                                        (void *) completion_key,
 628                                        result_err);
 629     }
 630   return 1;
 631 }
 632
 633 void
 634 ACE_WIN32_Proactor::application_specific_code (ACE_WIN32_Asynch_Result *asynch_result,
 635                                                size_t bytes_transferred,
 636                                                const void *completion_key,
 637                                                u_long error)
 638 {
 639   ACE_SEH_TRY
 640     {
 641       // Call completion hook
 642       asynch_result->complete (bytes_transferred,
 643                                error ? 0 : 1,
 644                                (void *) completion_key,
 645                                error);
 646     }
 647   ACE_SEH_FINALLY
 648     {
 649       // This is crucial to prevent memory leaks
 650       delete asynch_result;
 651     }
 652 }
 653
 654 int
 655 ACE_WIN32_Proactor::post_completion (ACE_WIN32_Asynch_Result *result)
 656 {
 657   // Grab the event associated with the Proactor
 658   HANDLE handle = this->get_handle ();
 659
 660   // pass
 661   //   bytes_transferred
 662   //   completion_key
 663   // to the ::PostQueuedCompletionStatus()
 664   //   error will be extracted later in handle_events()
 665
 666   DWORD bytes_transferred = 0;
 667   const void * completion_key = 0 ;
 668
 669   if (result != 0)
 670     {
 671       // This cast is ok since the original API calls restricted the transfer
 672       // counts to DWORD range.
 673       bytes_transferred = static_cast<DWORD> (result->bytes_transferred ());
 674       completion_key = result->completion_key();
 675     }
 676
 677   ULONG_PTR comp_key (reinterpret_cast<ULONG_PTR> (completion_key));
 678
 679   // Post a completion
 680   if (::PostQueuedCompletionStatus (this->completion_port_, // completion port
 681                                     bytes_transferred,      // xfer count
 682                                     comp_key,               // completion key
 683                                     result                  // overlapped
 684                                    ) == FALSE)
 685     {
 686       delete result;
 687
 688       if (ACE::debug ())
 689         {
 690           ACELIB_DEBUG ((LM_ERROR,
 691                       ACE_TEXT ("%p\n"),
 692                       ACE_TEXT ("PostQueuedCompletionStatus failed")));
 693         }
 694       return -1;
 695     }
 696
 697   // If Proactor event is valid, signal it
 698   if (handle != ACE_INVALID_HANDLE
 699       && handle != 0)
 700     ACE_OS::event_signal (&handle);
 701
 702   return 0;
 703 }
 704
 705 int
 706 ACE_WIN32_Proactor::post_wakeup_completions (int how_many)
 707 {
 708   ACE_WIN32_Wakeup_Completion *wakeup_completion = 0;
 709
 710   for (ssize_t ci = 0; ci < how_many; ci++)
 711     {
 712       ACE_NEW_RETURN
 713         (wakeup_completion,
 714          ACE_WIN32_Wakeup_Completion (this->wakeup_handler_.proxy ()),
 715          -1);
 716
 717       if (wakeup_completion->post_completion (this) == -1)
 718         return -1;
 719     }
 720
 721   return 0;
 722 }
 723
 724 int
 725 ACE_WIN32_Proactor::wake_up_dispatch_threads (void)
 726 {
 727   return 0;
 728 }
 729
 730 int
 731 ACE_WIN32_Proactor::close_dispatch_threads (int)
 732 {
 733   return 0;
 734 }
 735
 736 size_t
 737 ACE_WIN32_Proactor::number_of_threads (void) const
 738 {
 739   return static_cast<size_t> (this->number_of_threads_);
 740 }
 741
 742 void
 743 ACE_WIN32_Proactor::number_of_threads (size_t threads)
 744 {
 745   this->number_of_threads_ = static_cast<DWORD> (threads);
 746 }
 747
 748 ACE_WIN32_Asynch_Timer::ACE_WIN32_Asynch_Timer
 749   (const ACE_Handler::Proxy_Ptr &handler_proxy,
 750    const void *act,
 751    const ACE_Time_Value &tv,
 752    ACE_HANDLE event,
 753    int priority,
 754    int signal_number)
 755   : ACE_Asynch_Result_Impl (),
 756     ACE_WIN32_Asynch_Result (handler_proxy, act, event, 0, 0, priority,
 757                              signal_number),
 758     time_ (tv)
 759 {
 760 }
 761
 762 void
 763 ACE_WIN32_Asynch_Timer::complete (size_t,
 764                                   int,
 765                                   const void *,
 766                                   u_long)
 767 {
 768   ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
 769   if (handler != 0)
 770     handler->handle_time_out (this->time_, this->act ());
 771 }
 772
 773 ACE_WIN32_Wakeup_Completion::ACE_WIN32_Wakeup_Completion
 774   (ACE_Handler::Proxy_Ptr &handler_proxy,
 775    const void *act,
 776    ACE_HANDLE event,
 777    int priority,
 778    int signal_number)
 779   : ACE_Asynch_Result_Impl (),
 780     ACE_WIN32_Asynch_Result
 781      (handler_proxy, act, event, 0, 0, priority, signal_number)
 782 {
 783 }
 784
 785 ACE_WIN32_Wakeup_Completion::~ACE_WIN32_Wakeup_Completion (void)
 786 {
 787 }
 788
 789 void
 790 ACE_WIN32_Wakeup_Completion::complete (size_t       /* bytes_transferred */,
 791                                        int          /* success */,
 792                                        const void * /* completion_key */,
 793                                        u_long       /*  error */)
 794 {
 795   ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
 796   if (handler != 0)
 797     handler->handle_wakeup ();
 798 }
 799
 800 ACE_END_VERSIONED_NAMESPACE_DECL
 801
 802 #endif /* ACE_WIN32 */