dep/ACE_wrappers/ace/Asynch_IO.cpp

   1 // $Id: Asynch_IO.cpp 82559 2008-08-07 20:23:07Z parsons $
   2
   3 #include "ace/Asynch_IO.h"
   4
   5 ACE_RCSID(ace, Asynch_IO, "$Id: Asynch_IO.cpp 82559 2008-08-07 20:23:07Z parsons $")
   6
   7 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
   8 // This only works on platforms with Asynchronous IO
   9
  10 #include "ace/Proactor.h"
  11 #include "ace/Message_Block.h"
  12 #include "ace/INET_Addr.h"
  13 #include "ace/Asynch_IO_Impl.h"
  14 #include "ace/os_include/os_errno.h"
  15 #include "ace/Truncate.h"
  16
  17 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 size_t
  20 ACE_Asynch_Result::bytes_transferred (void) const
  21 {
  22   return this->implementation ()->bytes_transferred ();
  23 }
  24
  25 const void *
  26 ACE_Asynch_Result::act (void) const
  27 {
  28   return this->implementation ()->act ();
  29 }
  30
  31 int
  32 ACE_Asynch_Result::success (void) const
  33 {
  34   return this->implementation ()->success ();
  35 }
  36
  37 const void *
  38 ACE_Asynch_Result::completion_key (void) const
  39 {
  40   return this->implementation ()->completion_key ();
  41 }
  42
  43 unsigned long
  44 ACE_Asynch_Result::error (void) const
  45 {
  46   return this->implementation ()->error ();
  47 }
  48
  49 ACE_HANDLE
  50 ACE_Asynch_Result::event (void) const
  51 {
  52   return this->implementation ()->event ();
  53 }
  54
  55 unsigned long
  56 ACE_Asynch_Result::offset (void) const
  57 {
  58   return this->implementation ()->offset ();
  59 }
  60
  61 unsigned long
  62 ACE_Asynch_Result::offset_high (void) const
  63 {
  64   return this->implementation ()->offset_high ();
  65 }
  66
  67 int
  68 ACE_Asynch_Result::priority (void) const
  69 {
  70   return this->implementation ()->priority ();
  71 }
  72
  73 int
  74 ACE_Asynch_Result::signal_number (void) const
  75 {
  76   return this->implementation ()->signal_number ();
  77 }
  78
  79 ACE_Asynch_Result::ACE_Asynch_Result (ACE_Asynch_Result_Impl *implementation)
  80   : implementation_ (implementation)
  81 {
  82 }
  83
  84 ACE_Asynch_Result::~ACE_Asynch_Result (void)
  85 {
  86   // Proactor deletes the implementation when the <complete> finishes.
  87 }
  88
  89 ACE_Asynch_Result_Impl *
  90 ACE_Asynch_Result::implementation (void) const
  91 {
  92   return this->implementation_;
  93 }
  94
  95 // *********************************************************************
  96
  97 int
  98 ACE_Asynch_Operation::open (ACE_Handler &handler,
  99                             ACE_HANDLE handle,
 100                             const void *completion_key,
 101                             ACE_Proactor *proactor)
 102 {
 103   return this->implementation ()->open (handler.proxy (),
 104                                         handle,
 105                                         completion_key,
 106                                         proactor);
 107 }
 108
 109 int
 110 ACE_Asynch_Operation::cancel (void)
 111 {
 112   if (0 == this->implementation ())
 113     {
 114       errno = EFAULT;
 115       return -1;
 116     }
 117   return this->implementation ()->cancel ();
 118 }
 119
 120 ACE_Proactor *
 121 ACE_Asynch_Operation::proactor (void) const
 122 {
 123   if (0 == this->implementation ())
 124     {
 125       errno = EFAULT;
 126       return 0;
 127     }
 128   return this->implementation ()->proactor ();
 129 }
 130
 131 ACE_Asynch_Operation::ACE_Asynch_Operation (void)
 132 {
 133 }
 134
 135 ACE_Asynch_Operation::~ACE_Asynch_Operation (void)
 136 {
 137 }
 138
 139 ACE_Proactor *
 140 ACE_Asynch_Operation::get_proactor (ACE_Proactor *user_proactor,
 141                                     ACE_Handler &handler) const
 142 {
 143   if (user_proactor == 0)
 144     {
 145       // Grab the singleton proactor if <handler->proactor> is zero
 146       user_proactor = handler.proactor ();
 147       if (user_proactor == 0)
 148         user_proactor = ACE_Proactor::instance ();
 149     }
 150
 151   return user_proactor;
 152 }
 153
 154 // ************************************************************
 155
 156 ACE_Asynch_Read_Stream::ACE_Asynch_Read_Stream (void)
 157   : implementation_ (0)
 158 {
 159 }
 160
 161 ACE_Asynch_Read_Stream::~ACE_Asynch_Read_Stream (void)
 162 {
 163   // Delete the implementation.
 164   delete this->implementation_;
 165   this->implementation_ = 0;
 166 }
 167
 168 int
 169 ACE_Asynch_Read_Stream::open (ACE_Handler &handler,
 170                               ACE_HANDLE handle,
 171                               const void *completion_key,
 172                               ACE_Proactor *proactor)
 173 {
 174   // Get a proactor for/from the user.
 175   proactor = this->get_proactor (proactor, handler);
 176
 177   // Now let us get the implementation initialized.
 178   if ((this->implementation_ = proactor->create_asynch_read_stream ()) == 0)
 179     return -1;
 180
 181   // Call the <open> method of the base class.
 182   return ACE_Asynch_Operation::open (handler,
 183                                      handle,
 184                                      completion_key,
 185                                      proactor);
 186 }
 187
 188 int
 189 ACE_Asynch_Read_Stream::read (ACE_Message_Block &message_block,
 190                               size_t bytes_to_read,
 191                               const void *act,
 192                               int priority,
 193                               int signal_number)
 194 {
 195   if (0 == this->implementation_)
 196     {
 197       errno = EFAULT;
 198       return -1;
 199     }
 200   return this->implementation_->read (message_block,
 201                                       bytes_to_read,
 202                                       act,
 203                                       priority,
 204                                       signal_number);
 205 }
 206
 207 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO)
 208 int
 209 ACE_Asynch_Read_Stream::readv (ACE_Message_Block &message_block,
 210                                size_t bytes_to_read,
 211                                const void *act,
 212                                int priority,
 213                                int signal_number)
 214 {
 215   if (0 == this->implementation_)
 216     {
 217       errno = EFAULT;
 218       return -1;
 219     }
 220   return this->implementation_->readv (message_block,
 221                                        bytes_to_read,
 222                                        act,
 223                                        priority,
 224                                        signal_number);
 225 }
 226 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO */
 227
 228 ACE_Asynch_Operation_Impl *
 229 ACE_Asynch_Read_Stream::implementation (void) const
 230 {
 231   return this->implementation_;
 232 }
 233
 234 // ************************************************************
 235
 236 size_t
 237 ACE_Asynch_Read_Stream::Result::bytes_to_read (void) const
 238 {
 239   return this->implementation ()->bytes_to_read ();
 240 }
 241
 242 ACE_Message_Block &
 243 ACE_Asynch_Read_Stream::Result::message_block (void) const
 244 {
 245   return this->implementation ()->message_block ();
 246 }
 247
 248 ACE_HANDLE
 249 ACE_Asynch_Read_Stream::Result::handle (void) const
 250 {
 251   return this->implementation ()->handle ();
 252 }
 253
 254 ACE_Asynch_Read_Stream::Result::Result (ACE_Asynch_Read_Stream_Result_Impl *implementation)
 255   : ACE_Asynch_Result (implementation),
 256     implementation_ (implementation)
 257 {
 258 }
 259
 260 ACE_Asynch_Read_Stream::Result::~Result (void)
 261 {
 262   // Proactor will delete the implementation after <complete> is
 263   // finished.
 264 }
 265
 266 ACE_Asynch_Read_Stream_Result_Impl *
 267 ACE_Asynch_Read_Stream::Result::implementation (void) const
 268 {
 269   return this->implementation_;
 270 }
 271
 272 // ***************************************************
 273
 274 ACE_Asynch_Write_Stream::ACE_Asynch_Write_Stream (void)
 275   : implementation_ (0)
 276 {
 277 }
 278
 279 ACE_Asynch_Write_Stream::~ACE_Asynch_Write_Stream (void)
 280 {
 281   // Delete the implementation.
 282   delete this->implementation_;
 283   this->implementation_ = 0;
 284 }
 285
 286 int
 287 ACE_Asynch_Write_Stream::open (ACE_Handler &handler,
 288                                ACE_HANDLE handle,
 289                                const void *completion_key,
 290                                ACE_Proactor *proactor)
 291 {
 292   // Get a proactor for/from the user.
 293   proactor = this->get_proactor (proactor, handler);
 294
 295   // Now let us get the implementation initialized.
 296   if ((this->implementation_ = proactor->create_asynch_write_stream ()) == 0)
 297     return -1;
 298
 299   // Call the <open> method of the base class.
 300   return ACE_Asynch_Operation::open (handler,
 301                                      handle,
 302                                      completion_key,
 303                                      proactor);
 304 }
 305
 306 int
 307 ACE_Asynch_Write_Stream::write (ACE_Message_Block &message_block,
 308                                 size_t bytes_to_write,
 309                                 const void *act,
 310                                 int priority,
 311                                 int signal_number)
 312 {
 313   if (0 == this->implementation_)
 314     {
 315       errno = EFAULT;
 316       return -1;
 317     }
 318   return this->implementation_->write (message_block,
 319                                        bytes_to_write,
 320                                        act,
 321                                        priority,
 322                                        signal_number);
 323 }
 324
 325 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO)
 326 int
 327 ACE_Asynch_Write_Stream::writev (ACE_Message_Block &message_block,
 328                                  size_t bytes_to_write,
 329                                  const void *act,
 330                                  int priority,
 331                                  int signal_number)
 332 {
 333   if (0 == this->implementation_)
 334     {
 335       errno = EFAULT;
 336       return -1;
 337     }
 338   return this->implementation_->writev (message_block,
 339                                         bytes_to_write,
 340                                         act,
 341                                         priority,
 342                                         signal_number);
 343 }
 344 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO */
 345
 346 ACE_Asynch_Operation_Impl *
 347 ACE_Asynch_Write_Stream::implementation (void) const
 348 {
 349   return this->implementation_;
 350 }
 351
 352 // ************************************************************
 353
 354 size_t
 355 ACE_Asynch_Write_Stream::Result::bytes_to_write (void) const
 356 {
 357   return this->implementation ()->bytes_to_write ();
 358 }
 359
 360 ACE_Message_Block &
 361 ACE_Asynch_Write_Stream::Result::message_block (void) const
 362 {
 363   return this->implementation ()->message_block ();
 364 }
 365
 366 ACE_HANDLE
 367 ACE_Asynch_Write_Stream::Result::handle (void) const
 368 {
 369   return this->implementation ()->handle ();
 370 }
 371
 372 ACE_Asynch_Write_Stream::Result::Result (ACE_Asynch_Write_Stream_Result_Impl *implementation)
 373   : ACE_Asynch_Result (implementation),
 374     implementation_ (implementation)
 375 {
 376 }
 377
 378 ACE_Asynch_Write_Stream::Result::~Result (void)
 379 {
 380   // Proactor will delte the implementation when the <complete> call
 381   // finishes.
 382 }
 383
 384 ACE_Asynch_Write_Stream_Result_Impl *
 385 ACE_Asynch_Write_Stream::Result::implementation (void) const
 386 {
 387   return this->implementation_;
 388 }
 389
 390 // ************************************************************
 391
 392 ACE_Asynch_Read_File::ACE_Asynch_Read_File (void)
 393   : implementation_ (0)
 394 {
 395 }
 396
 397 ACE_Asynch_Read_File::~ACE_Asynch_Read_File (void)
 398 {
 399   // Delete the implementation.
 400   delete this->implementation_;
 401   this->implementation_ = 0;
 402 }
 403
 404 int
 405 ACE_Asynch_Read_File::open (ACE_Handler &handler,
 406                             ACE_HANDLE handle,
 407                             const void *completion_key,
 408                             ACE_Proactor *proactor)
 409 {
 410   // Get a proactor for/from the user.
 411   proactor = this->get_proactor (proactor, handler);
 412
 413   // Now let us get the implementation initialized.
 414   if ((this->implementation_ = proactor->create_asynch_read_file ()) == 0)
 415     return -1;
 416
 417   // Call the <open> method of the base class.
 418   return ACE_Asynch_Operation::open (handler,
 419                                      handle,
 420                                      completion_key,
 421                                      proactor);
 422 }
 423
 424 int
 425 ACE_Asynch_Read_File::read (ACE_Message_Block &message_block,
 426                             size_t bytes_to_read,
 427                             unsigned long offset,
 428                             unsigned long offset_high,
 429                             const void *act,
 430                             int priority,
 431                             int signal_number)
 432 {
 433   if (0 == this->implementation_)
 434     {
 435       errno = EFAULT;
 436       return -1;
 437     }
 438   return this->implementation_->read (message_block,
 439                                       bytes_to_read,
 440                                       offset,
 441                                       offset_high,
 442                                       act,
 443                                       priority,
 444                                       signal_number);
 445 }
 446
 447 #if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
 448 int
 449 ACE_Asynch_Read_File::readv (ACE_Message_Block &message_block,
 450                              size_t bytes_to_read,
 451                              unsigned long offset,
 452                              unsigned long offset_high,
 453                              const void *act,
 454                              int priority,
 455                              int signal_number)
 456 {
 457   if (0 == this->implementation_)
 458     {
 459       errno = EFAULT;
 460       return -1;
 461     }
 462   return this->implementation_->readv (message_block,
 463                                        bytes_to_read,
 464                                        offset,
 465                                        offset_high,
 466                                        act,
 467                                        priority,
 468                                        signal_number);
 469 }
 470 #endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */
 471
 472 ACE_Asynch_Operation_Impl *
 473 ACE_Asynch_Read_File::implementation (void) const
 474 {
 475   return this->implementation_;
 476 }
 477
 478 // ************************************************************
 479
 480 ACE_Asynch_Read_File::Result::Result (ACE_Asynch_Read_File_Result_Impl *implementation)
 481   : ACE_Asynch_Read_Stream::Result (implementation),
 482     implementation_ (implementation)
 483 {
 484 }
 485
 486 ACE_Asynch_Read_File::Result::~Result (void)
 487 {
 488   // Proactor will delete the implementation when <complete> call
 489   // completes.
 490 }
 491
 492 ACE_Asynch_Read_File_Result_Impl *
 493 ACE_Asynch_Read_File::Result::implementation (void) const
 494 {
 495   return this->implementation_;
 496 }
 497
 498 // ************************************************************
 499
 500 ACE_Asynch_Write_File::ACE_Asynch_Write_File (void)
 501   : implementation_ (0)
 502 {
 503 }
 504
 505 ACE_Asynch_Write_File::~ACE_Asynch_Write_File (void)
 506 {
 507   // Delete the implementation.
 508   delete this->implementation_;
 509   this->implementation_ = 0;
 510 }
 511
 512 int
 513 ACE_Asynch_Write_File::open (ACE_Handler &handler,
 514                              ACE_HANDLE handle,
 515                              const void *completion_key,
 516                              ACE_Proactor *proactor)
 517 {
 518   // Get a proactor for/from the user.
 519   proactor = this->get_proactor (proactor, handler);
 520
 521   // Now let us get the implementation initialized.
 522   if ((this->implementation_ = proactor->create_asynch_write_file ()) == 0)
 523     return -1;
 524
 525   // Call the <open> method of the base class.
 526   return ACE_Asynch_Operation::open (handler,
 527                                      handle,
 528                                      completion_key,
 529                                      proactor);
 530 }
 531
 532 int
 533 ACE_Asynch_Write_File::write (ACE_Message_Block &message_block,
 534                               size_t bytes_to_write,
 535                               unsigned long offset,
 536                               unsigned long offset_high,
 537                               const void *act,
 538                               int priority,
 539                               int signal_number)
 540 {
 541   if (0 == this->implementation_)
 542     {
 543       errno = EFAULT;
 544       return -1;
 545     }
 546   return this->implementation_->write (message_block,
 547                                        bytes_to_write,
 548                                        offset,
 549                                        offset_high,
 550                                        act,
 551                                        priority,
 552                                        signal_number);
 553 }
 554
 555 #if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
 556 int
 557 ACE_Asynch_Write_File::writev (ACE_Message_Block &message_block,
 558                                size_t bytes_to_write,
 559                                unsigned long offset,
 560                                unsigned long offset_high,
 561                                const void *act,
 562                                int priority,
 563                                int signal_number)
 564 {
 565   if (0 == this->implementation_)
 566     {
 567       errno = EFAULT;
 568       return -1;
 569     }
 570   return this->implementation_->writev (message_block,
 571                                         bytes_to_write,
 572                                         offset,
 573                                         offset_high,
 574                                         act,
 575                                         priority,
 576                                         signal_number);
 577 }
 578 #endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */
 579
 580 ACE_Asynch_Operation_Impl *
 581 ACE_Asynch_Write_File::implementation (void) const
 582 {
 583   return this->implementation_;
 584 }
 585
 586 // ************************************************************
 587
 588 ACE_Asynch_Write_File::Result::Result (ACE_Asynch_Write_File_Result_Impl *implementation)
 589   : ACE_Asynch_Write_Stream::Result (implementation),
 590     implementation_ (implementation)
 591 {
 592 }
 593
 594 ACE_Asynch_Write_File::Result::~Result (void)
 595 {
 596   // Proactor will delete the implementation when the <complete> call
 597   // completes.
 598 }
 599
 600 ACE_Asynch_Write_File_Result_Impl *
 601 ACE_Asynch_Write_File::Result::implementation (void) const
 602 {
 603   return this->implementation_;
 604 }
 605
 606 // *********************************************************************
 607
 608 ACE_Asynch_Accept::ACE_Asynch_Accept (void)
 609   : implementation_ (0)
 610 {
 611 }
 612
 613 ACE_Asynch_Accept::~ACE_Asynch_Accept (void)
 614 {
 615   // Delete the implementation.
 616   delete this->implementation_;
 617   this->implementation_ = 0;
 618 }
 619
 620 int
 621 ACE_Asynch_Accept::open (ACE_Handler &handler,
 622                          ACE_HANDLE handle,
 623                          const void *completion_key,
 624                          ACE_Proactor *proactor)
 625 {
 626   // Get a proactor for/from the user.
 627   proactor = this->get_proactor (proactor, handler);
 628
 629   // Now let us get the implementation initialized.
 630   if ((this->implementation_ = proactor->create_asynch_accept ()) == 0)
 631     return -1;
 632
 633   // Call the <open> method of the base class.
 634   return ACE_Asynch_Operation::open (handler,
 635                                      handle,
 636                                      completion_key,
 637                                      proactor);
 638 }
 639
 640 int
 641 ACE_Asynch_Accept::accept (ACE_Message_Block &message_block,
 642                            size_t bytes_to_read,
 643                            ACE_HANDLE accept_handle,
 644                            const void *act,
 645                            int priority,
 646                            int signal_number,
 647                            int addr_family)
 648 {
 649   if (0 == this->implementation_)
 650     {
 651       errno = EFAULT;
 652       return -1;
 653     }
 654   return this->implementation_->accept (message_block,
 655                                         bytes_to_read,
 656                                         accept_handle,
 657                                         act,
 658                                         priority,
 659                                         signal_number,
 660                                         addr_family);
 661 }
 662
 663 ACE_Asynch_Operation_Impl *
 664 ACE_Asynch_Accept::implementation (void)  const
 665 {
 666   return this->implementation_;
 667 }
 668
 669 // ************************************************************
 670
 671 size_t
 672 ACE_Asynch_Accept::Result::bytes_to_read (void) const
 673 {
 674   return this->implementation ()->bytes_to_read ();
 675 }
 676
 677 ACE_Message_Block &
 678 ACE_Asynch_Accept::Result::message_block (void) const
 679 {
 680   return this->implementation ()->message_block ();
 681 }
 682
 683 ACE_HANDLE
 684 ACE_Asynch_Accept::Result::listen_handle (void) const
 685 {
 686   return this->implementation ()->listen_handle ();
 687 }
 688
 689 ACE_HANDLE
 690 ACE_Asynch_Accept::Result::accept_handle (void) const
 691 {
 692   return this->implementation ()->accept_handle ();
 693 }
 694
 695 ACE_Asynch_Accept::Result::Result (ACE_Asynch_Accept_Result_Impl *implementation)
 696   : ACE_Asynch_Result (implementation),
 697     implementation_ (implementation)
 698 {
 699 }
 700
 701 ACE_Asynch_Accept::Result::~Result (void)
 702 {
 703   // Proactor will delete the implementation when the <complete> call
 704   // completes.
 705 }
 706
 707 ACE_Asynch_Accept_Result_Impl *
 708 ACE_Asynch_Accept::Result::implementation (void) const
 709 {
 710   return this->implementation_;
 711 }
 712
 713
 714
 715 // *********************************************************************
 716
 717 ACE_Asynch_Connect::ACE_Asynch_Connect (void)
 718   : implementation_ (0)
 719 {
 720 }
 721
 722 ACE_Asynch_Connect::~ACE_Asynch_Connect (void)
 723 {
 724   // Delete the implementation.
 725   delete this->implementation_;
 726   this->implementation_ = 0;
 727 }
 728
 729 int
 730 ACE_Asynch_Connect::open (ACE_Handler &handler,
 731                           ACE_HANDLE handle,
 732                           const void *completion_key,
 733                           ACE_Proactor *proactor)
 734 {
 735   // Get a proactor for/from the user.
 736   proactor = this->get_proactor (proactor, handler);
 737
 738   // Now let us get the implementation initialized.
 739   if ((this->implementation_ = proactor->create_asynch_connect ()) == 0)
 740     return -1;
 741
 742   // Call the <open> method of the base class.
 743   return ACE_Asynch_Operation::open (handler,
 744                                      handle,
 745                                      completion_key,
 746                                      proactor);
 747 }
 748
 749 int
 750 ACE_Asynch_Connect::connect (ACE_HANDLE connect_handle,
 751                              const ACE_Addr & remote_sap,
 752                              const ACE_Addr & local_sap,
 753                              int  reuse_addr,
 754                              const void *act,
 755                              int priority,
 756                              int signal_number)
 757 {
 758   if (0 == this->implementation_)
 759     {
 760       errno = EFAULT;
 761       return -1;
 762     }
 763   return this->implementation_->connect (connect_handle,
 764                                          remote_sap,
 765                                          local_sap,
 766                                          reuse_addr,
 767                                          act,
 768                                          priority,
 769                                          signal_number);
 770 }
 771
 772 ACE_Asynch_Operation_Impl *
 773 ACE_Asynch_Connect::implementation (void)  const
 774 {
 775   return this->implementation_;
 776 }
 777
 778 // ************************************************************
 779
 780 ACE_Asynch_Connect::Result::Result (ACE_Asynch_Connect_Result_Impl *implementation)
 781   : ACE_Asynch_Result (implementation),
 782     implementation_ (implementation)
 783 {
 784 }
 785
 786 ACE_Asynch_Connect::Result::~Result (void)
 787 {
 788   // Proactor will delete the implementation when the <complete> call
 789   // completes.
 790 }
 791
 792 ACE_HANDLE
 793 ACE_Asynch_Connect::Result::connect_handle (void) const
 794 {
 795   return this->implementation ()->connect_handle ();
 796 }
 797
 798
 799 ACE_Asynch_Connect_Result_Impl *
 800 ACE_Asynch_Connect::Result::implementation (void) const
 801 {
 802   return this->implementation_;
 803 }
 804
 805 // ************************************************************
 806
 807 ACE_Asynch_Transmit_File::ACE_Asynch_Transmit_File (void)
 808   : implementation_ (0)
 809 {
 810 }
 811
 812 ACE_Asynch_Transmit_File::~ACE_Asynch_Transmit_File (void)
 813 {
 814   // Delete the implementation.
 815   delete this->implementation_;
 816   this->implementation_ = 0;
 817 }
 818
 819 int
 820 ACE_Asynch_Transmit_File::open (ACE_Handler &handler,
 821                                 ACE_HANDLE handle,
 822                                 const void *completion_key,
 823                                 ACE_Proactor *proactor)
 824 {
 825   // Get a proactor for/from the user.
 826   proactor = this->get_proactor (proactor, handler);
 827
 828   // Now let us get the implementation initialized.
 829   if ((this->implementation_ = proactor->create_asynch_transmit_file ()) == 0)
 830     return -1;
 831
 832   // Call the <open> method of the base class.
 833   return ACE_Asynch_Operation::open (handler,
 834                                      handle,
 835                                      completion_key,
 836                                      proactor);
 837 }
 838
 839 int
 840 ACE_Asynch_Transmit_File::transmit_file (ACE_HANDLE file,
 841                                          Header_And_Trailer *header_and_trailer,
 842                                          size_t bytes_to_write,
 843                                          unsigned long offset,
 844                                          unsigned long offset_high,
 845                                          size_t bytes_per_send,
 846                                          unsigned long flags,
 847                                          const void *act,
 848                                          int priority,
 849                                          int signal_number)
 850 {
 851   if (0 == this->implementation_)
 852     {
 853       errno = EFAULT;
 854       return -1;
 855     }
 856   return this->implementation_->transmit_file (file,
 857                                                header_and_trailer,
 858                                                bytes_to_write,
 859                                                offset,
 860                                                offset_high,
 861                                                bytes_per_send,
 862                                                flags,
 863                                                act,
 864                                                priority,
 865                                                signal_number);
 866 }
 867
 868 ACE_Asynch_Operation_Impl *
 869 ACE_Asynch_Transmit_File::implementation (void) const
 870 {
 871   return this->implementation_;
 872 }
 873
 874 // ****************************************************************************
 875
 876 ACE_HANDLE
 877 ACE_Asynch_Transmit_File::Result::socket (void) const
 878 {
 879   return this->implementation ()->socket ();
 880 }
 881
 882 ACE_HANDLE
 883 ACE_Asynch_Transmit_File::Result::file (void) const
 884 {
 885   return this->implementation ()->file ();
 886 }
 887
 888 ACE_Asynch_Transmit_File::Header_And_Trailer *
 889 ACE_Asynch_Transmit_File::Result::header_and_trailer (void) const
 890 {
 891   return this->implementation ()->header_and_trailer ();
 892 }
 893
 894 size_t
 895 ACE_Asynch_Transmit_File::Result::bytes_to_write (void) const
 896 {
 897   return this->implementation ()->bytes_to_write ();
 898 }
 899
 900 size_t
 901 ACE_Asynch_Transmit_File::Result::bytes_per_send (void) const
 902 {
 903   return this->implementation ()->bytes_per_send ();
 904 }
 905
 906 unsigned long
 907 ACE_Asynch_Transmit_File::Result::flags (void) const
 908 {
 909   return this->implementation ()->flags ();
 910 }
 911
 912 ACE_Asynch_Transmit_File::Result::Result (ACE_Asynch_Transmit_File_Result_Impl *implementation)
 913   : ACE_Asynch_Result (implementation),
 914     implementation_ (implementation)
 915 {
 916 }
 917
 918 ACE_Asynch_Transmit_File::Result::~Result (void)
 919 {
 920 }
 921
 922 ACE_Asynch_Transmit_File_Result_Impl *
 923 ACE_Asynch_Transmit_File::Result::implementation (void) const
 924 {
 925   return this->implementation_;
 926 }
 927
 928 // ************************************************************
 929
 930 ACE_Asynch_Transmit_File::Header_And_Trailer::Header_And_Trailer (ACE_Message_Block *header,
 931                                                                   size_t header_bytes,
 932                                                                   ACE_Message_Block *trailer,
 933                                                                   size_t trailer_bytes)
 934   : header_ (header),
 935     header_bytes_ (header_bytes),
 936     trailer_ (trailer),
 937     trailer_bytes_ (trailer_bytes)
 938 {
 939 }
 940
 941 ACE_Asynch_Transmit_File::Header_And_Trailer::~Header_And_Trailer (void)
 942 {
 943 }
 944
 945 void
 946 ACE_Asynch_Transmit_File::Header_And_Trailer::header_and_trailer (ACE_Message_Block *header,
 947                                                                   size_t header_bytes,
 948                                                                   ACE_Message_Block *trailer,
 949                                                                   size_t trailer_bytes)
 950 {
 951   this->header (header);
 952   this->header_bytes (header_bytes);
 953   this->trailer (trailer);
 954   this->trailer_bytes (trailer_bytes);
 955 }
 956
 957 ACE_Message_Block *
 958 ACE_Asynch_Transmit_File::Header_And_Trailer::header (void) const
 959 {
 960   return this->header_;
 961 }
 962
 963 void
 964 ACE_Asynch_Transmit_File::Header_And_Trailer::header (ACE_Message_Block *message_block)
 965 {
 966   this->header_ = message_block;
 967 }
 968
 969 size_t
 970 ACE_Asynch_Transmit_File::Header_And_Trailer::header_bytes (void) const
 971 {
 972   return this->header_bytes_;
 973 }
 974
 975 void
 976 ACE_Asynch_Transmit_File::Header_And_Trailer::header_bytes (size_t bytes)
 977 {
 978   this->header_bytes_ = bytes;
 979 }
 980
 981 ACE_Message_Block *
 982 ACE_Asynch_Transmit_File::Header_And_Trailer::trailer (void) const
 983 {
 984   return this->trailer_;
 985 }
 986
 987 void
 988 ACE_Asynch_Transmit_File::Header_And_Trailer::trailer (ACE_Message_Block *message_block)
 989 {
 990   this->trailer_ = message_block;
 991 }
 992
 993 size_t
 994 ACE_Asynch_Transmit_File::Header_And_Trailer::trailer_bytes (void) const
 995 {
 996   return this->trailer_bytes_;
 997 }
 998
 999 void
1000 ACE_Asynch_Transmit_File::Header_And_Trailer::trailer_bytes (size_t bytes)
1001 {
1002   this->trailer_bytes_ = bytes;
1003 }
1004
1005 ACE_LPTRANSMIT_FILE_BUFFERS
1006 ACE_Asynch_Transmit_File::Header_And_Trailer::transmit_buffers (void)
1007 {
1008   // If both are zero, return zero
1009   if (this->header_ == 0 && this->trailer_ == 0)
1010     {
1011       return 0;
1012     }
1013   else
1014     {
1015       // Something is valid
1016
1017       // If header is valid, set the fields
1018       if (this->header_ != 0)
1019         {
1020           this->transmit_buffers_.Head = this->header_->rd_ptr ();
1021 #if defined (ACE_WIN64) || defined (ACE_WIN32)
1022           this->transmit_buffers_.HeadLength =
1023             ACE_Utils::truncate_cast<DWORD> (this->header_bytes_);
1024 #else
1025           this->transmit_buffers_.HeadLength = this->header_bytes_;
1026 #endif /* ACE_WIN64 || ACE_WIN32 */
1027         }
1028       else
1029         {
1030           this->transmit_buffers_.Head = 0;
1031           this->transmit_buffers_.HeadLength = 0;
1032         }
1033
1034       // If trailer is valid, set the fields
1035       if (this->trailer_ != 0)
1036         {
1037           this->transmit_buffers_.Tail = this->trailer_->rd_ptr ();
1038 #if defined(ACE_WIN64) || defined (ACE_WIN32)
1039           this->transmit_buffers_.TailLength =
1040             ACE_Utils::truncate_cast<DWORD> (this->trailer_bytes_);
1041 #else
1042           this->transmit_buffers_.TailLength = this->trailer_bytes_;
1043 #endif /* ACE_WIN64 || ACE_WIN32 */
1044         }
1045       else
1046         {
1047           this->transmit_buffers_.Tail = 0;
1048           this->transmit_buffers_.TailLength = 0;
1049         }
1050
1051       // Return the transmit buffers
1052       return &this->transmit_buffers_;
1053     }
1054 }
1055
1056 // *********************************************************************
1057
1058 ACE_Handler::ACE_Handler (void)
1059   : proactor_ (0), handle_ (ACE_INVALID_HANDLE)
1060 {
1061   ACE_Handler::Proxy *p;
1062   ACE_NEW (p, ACE_Handler::Proxy (this));
1063   this->proxy_.reset (p);
1064 }
1065
1066 ACE_Handler::ACE_Handler (ACE_Proactor *d)
1067   : proactor_ (d), handle_ (ACE_INVALID_HANDLE)
1068 {
1069   ACE_Handler::Proxy *p;
1070   ACE_NEW (p, ACE_Handler::Proxy (this));
1071   this->proxy_.reset (p);
1072 }
1073
1074 ACE_Handler::~ACE_Handler (void)
1075 {
1076   ACE_Handler::Proxy *p = this->proxy_.get ();
1077   if (p)
1078     p->reset ();
1079 }
1080
1081 void
1082 ACE_Handler::handle_read_stream (const ACE_Asynch_Read_Stream::Result & /* result */)
1083 {
1084 }
1085
1086 void
1087 ACE_Handler::handle_write_stream (const ACE_Asynch_Write_Stream::Result & /* result */)
1088 {
1089 }
1090
1091 void
1092 ACE_Handler::handle_write_dgram (const ACE_Asynch_Write_Dgram::Result & /* result */)
1093 {
1094 }
1095
1096 void
1097 ACE_Handler::handle_read_dgram (const ACE_Asynch_Read_Dgram::Result & /* result */)
1098 {
1099 }
1100
1101 void
1102 ACE_Handler::handle_accept (const ACE_Asynch_Accept::Result & /* result */)
1103 {
1104 }
1105
1106 void
1107 ACE_Handler::handle_connect (const ACE_Asynch_Connect::Result & /* result */)
1108 {
1109 }
1110
1111 void
1112 ACE_Handler::handle_transmit_file (const ACE_Asynch_Transmit_File::Result & /* result */)
1113 {
1114 }
1115
1116 void
1117 ACE_Handler::handle_read_file (const ACE_Asynch_Read_File::Result & /* result */)
1118 {
1119 }
1120
1121 void
1122 ACE_Handler::handle_write_file (const ACE_Asynch_Write_File::Result & /* result */)
1123 {
1124 }
1125
1126 void
1127 ACE_Handler::handle_time_out (const ACE_Time_Value & /* tv */,
1128                               const void *           /* act */)
1129 {
1130 }
1131
1132 void
1133 ACE_Handler::handle_wakeup (void)
1134 {
1135 }
1136
1137 ACE_Proactor *
1138 ACE_Handler::proactor (void)
1139 {
1140   return this->proactor_;
1141 }
1142
1143 void
1144 ACE_Handler::proactor (ACE_Proactor *p)
1145 {
1146   this->proactor_ = p;
1147 }
1148
1149 ACE_HANDLE
1150 ACE_Handler::handle (void) const
1151 {
1152   return this->handle_;
1153 }
1154
1155 void
1156 ACE_Handler::handle (ACE_HANDLE h)
1157 {
1158   this->handle_ = h;
1159 }
1160
1161 ACE_Refcounted_Auto_Ptr<ACE_Handler::Proxy, ACE_SYNCH_MUTEX> &
1162 ACE_Handler::proxy (void)
1163 {
1164   return this->proxy_;
1165 }
1166
1167 // ************************************************************
1168
1169 ACE_Service_Handler::ACE_Service_Handler (void)
1170 {
1171 }
1172
1173 ACE_Service_Handler::~ACE_Service_Handler (void)
1174 {
1175 }
1176
1177 void
1178 ACE_Service_Handler::addresses (const ACE_INET_Addr & /* remote_address */,
1179                                 const ACE_INET_Addr & /* local_address */ )
1180 {
1181 }
1182
1183 void
1184 ACE_Service_Handler::act (const void *)
1185 {
1186 }
1187
1188 void
1189 ACE_Service_Handler::open (ACE_HANDLE,
1190                            ACE_Message_Block &)
1191 {
1192 }
1193
1194
1195 // ************************************************************
1196
1197 ACE_Asynch_Read_Dgram::ACE_Asynch_Read_Dgram (void)
1198   : implementation_ (0)
1199 {
1200 }
1201
1202 ACE_Asynch_Read_Dgram::~ACE_Asynch_Read_Dgram (void)
1203 {
1204   // Delete the implementation.
1205   delete this->implementation_;
1206   this->implementation_ = 0;
1207 }
1208
1209 int
1210 ACE_Asynch_Read_Dgram::open (ACE_Handler &handler,
1211                              ACE_HANDLE handle,
1212                              const void *completion_key,
1213                              ACE_Proactor *proactor)
1214 {
1215   // Get a proactor for/from the user.
1216   proactor = this->get_proactor (proactor, handler);
1217
1218   // Now let us get the implementation initialized.
1219   if ((this->implementation_ = proactor->create_asynch_read_dgram ()) == 0)
1220     return -1;
1221
1222   // Call the <open> method of the base class.
1223   return ACE_Asynch_Operation::open (handler,
1224                                      handle,
1225                                      completion_key,
1226                                      proactor);
1227 }
1228
1229 ssize_t
1230 ACE_Asynch_Read_Dgram::recv (ACE_Message_Block *message_block,
1231                              size_t &number_of_bytes_recvd,
1232                              int flags,
1233                              int protocol_family,
1234                              const void *act,
1235                              int priority,
1236                              int signal_number)
1237 {
1238   if (0 == this->implementation_)
1239     {
1240       errno = EFAULT;
1241       return -1;
1242     }
1243   return this->implementation_->recv (message_block,
1244                                       number_of_bytes_recvd,
1245                                       flags,
1246                                       protocol_family,
1247                                       act,
1248                                       priority,
1249                                       signal_number);
1250 }
1251
1252 ACE_Asynch_Operation_Impl *
1253 ACE_Asynch_Read_Dgram::implementation (void) const
1254 {
1255   return this->implementation_;
1256 }
1257
1258 // ************************************************************
1259
1260 int
1261 ACE_Asynch_Read_Dgram::Result::remote_address (ACE_Addr& addr) const
1262 {
1263   return this->implementation ()->remote_address (addr);
1264 }
1265
1266 ACE_Message_Block*
1267 ACE_Asynch_Read_Dgram::Result::message_block (void) const
1268 {
1269   return this->implementation ()->message_block ();
1270 }
1271
1272 int
1273 ACE_Asynch_Read_Dgram::Result::flags (void) const
1274 {
1275   return this->implementation ()->flags ();
1276 }
1277
1278 size_t
1279 ACE_Asynch_Read_Dgram::Result::bytes_to_read (void) const
1280 {
1281   return this->implementation ()->bytes_to_read ();
1282 }
1283
1284 ACE_HANDLE
1285 ACE_Asynch_Read_Dgram::Result::handle (void) const
1286 {
1287   return this->implementation ()->handle();
1288 }
1289
1290 ACE_Asynch_Read_Dgram::Result::Result (ACE_Asynch_Read_Dgram_Result_Impl *implementation)
1291 : ACE_Asynch_Result (implementation),
1292   implementation_ (implementation)
1293 {
1294 }
1295
1296 ACE_Asynch_Read_Dgram::Result::~Result (void)
1297 {
1298 }
1299
1300 ACE_Asynch_Read_Dgram_Result_Impl *
1301 ACE_Asynch_Read_Dgram::Result::implementation (void) const
1302 {
1303   return this->implementation_;
1304 }
1305
1306 // ************************************************************
1307
1308
1309 ACE_Asynch_Write_Dgram::ACE_Asynch_Write_Dgram (void)
1310   : implementation_ (0)
1311 {
1312 }
1313
1314 ACE_Asynch_Write_Dgram::~ACE_Asynch_Write_Dgram (void)
1315 {
1316   // Delete the implementation.
1317   delete this->implementation_;
1318   this->implementation_ = 0;
1319 }
1320
1321 int
1322 ACE_Asynch_Write_Dgram::open (ACE_Handler &handler,
1323                               ACE_HANDLE handle,
1324                               const void *completion_key,
1325                               ACE_Proactor *proactor)
1326 {
1327   // Get a proactor for/from the user.
1328   proactor = this->get_proactor (proactor, handler);
1329
1330   // Now let us get the implementation initialized.
1331   if ((this->implementation_ = proactor->create_asynch_write_dgram ()) == 0)
1332     return -1;
1333
1334   // Call the <open> method of the base class.
1335   return ACE_Asynch_Operation::open (handler,
1336                                      handle,
1337                                      completion_key,
1338                                      proactor);
1339 }
1340
1341 ssize_t
1342 ACE_Asynch_Write_Dgram::send (ACE_Message_Block *message_block,
1343                               size_t &number_of_bytes_sent,
1344                               int flags,
1345                               const ACE_Addr& remote_addr,
1346                               const void *act,
1347                               int priority,
1348                               int signal_number)
1349 {
1350   if (0 == this->implementation_)
1351     {
1352       errno = EFAULT;
1353       return -1;
1354     }
1355   return this->implementation_->send (message_block,
1356                                       number_of_bytes_sent,
1357                                       flags,
1358                                       remote_addr,
1359                                       act,
1360                                       priority,
1361                                       signal_number);
1362 }
1363
1364 ACE_Asynch_Operation_Impl *
1365 ACE_Asynch_Write_Dgram::implementation (void) const
1366 {
1367   return this->implementation_;
1368 }
1369
1370 // ************************************************************
1371
1372 size_t
1373 ACE_Asynch_Write_Dgram::Result::bytes_to_write (void) const
1374 {
1375   return this->implementation ()->bytes_to_write ();
1376 }
1377
1378 ACE_Message_Block*
1379 ACE_Asynch_Write_Dgram::Result::message_block () const
1380 {
1381   return this->implementation ()->message_block ();
1382 }
1383
1384 int
1385 ACE_Asynch_Write_Dgram::Result::flags (void) const
1386 {
1387   return this->implementation ()->flags ();
1388 }
1389
1390 ACE_HANDLE
1391 ACE_Asynch_Write_Dgram::Result::handle (void) const
1392 {
1393   return this->implementation ()->handle ();
1394 }
1395
1396 ACE_Asynch_Write_Dgram_Result_Impl *
1397 ACE_Asynch_Write_Dgram::Result::implementation (void) const
1398 {
1399   return this->implementation_;
1400 }
1401
1402 ACE_Asynch_Write_Dgram::Result::Result (ACE_Asynch_Write_Dgram_Result_Impl *implementation)
1403 : ACE_Asynch_Result (implementation),
1404   implementation_ (implementation)
1405 {
1406 }
1407
1408 ACE_Asynch_Write_Dgram::Result::~Result (void)
1409 {
1410 }
1411
1412 ACE_END_VERSIONED_NAMESPACE_DECL
1413
1414 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */