00001
00002
00003 #include "ace/WIN32_Asynch_IO.h"
00004
00005 ACE_RCSID (ace,
00006 Win32_Asynch_IO,
00007 "$Id: WIN32_Asynch_IO.cpp 89454 2010-03-11 09:35:25Z johnnyw $")
00008
00009 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) && \
00010 (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 == 1))
00011
00012 #include "ace/WIN32_Proactor.h"
00013 #include "ace/Proactor.h"
00014 #include "ace/Message_Block.h"
00015 #include "ace/Service_Config.h"
00016 #include "ace/INET_Addr.h"
00017 #include "ace/Task_T.h"
00018 #include "ace/OS_NS_errno.h"
00019 #include "ace/OS_NS_unistd.h"
00020 #include "ace/OS_NS_sys_socket.h"
00021
00022 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00023
00024 size_t
00025 ACE_WIN32_Asynch_Result::bytes_transferred (void) const
00026 {
00027 return this->bytes_transferred_;
00028 }
00029
00030 const void *
00031 ACE_WIN32_Asynch_Result::act (void) const
00032 {
00033 return this->act_;
00034 }
00035
00036 int
00037 ACE_WIN32_Asynch_Result::success (void) const
00038 {
00039 return this->success_;
00040 }
00041
00042 const void *
00043 ACE_WIN32_Asynch_Result::completion_key (void) const
00044 {
00045 return this->completion_key_;
00046 }
00047
00048 u_long
00049 ACE_WIN32_Asynch_Result::error (void) const
00050 {
00051 return this->error_;
00052 }
00053
00054 ACE_HANDLE
00055 ACE_WIN32_Asynch_Result::event (void) const
00056 {
00057 return this->hEvent;
00058 }
00059
00060 u_long
00061 ACE_WIN32_Asynch_Result::offset (void) const
00062 {
00063 return this->Offset;
00064 }
00065
00066 u_long
00067 ACE_WIN32_Asynch_Result::offset_high (void) const
00068 {
00069 return this->OffsetHigh;
00070 }
00071
00072 int
00073 ACE_WIN32_Asynch_Result::priority (void) const
00074 {
00075 ACE_NOTSUP_RETURN (0);
00076 }
00077
00078 int
00079 ACE_WIN32_Asynch_Result::signal_number (void) const
00080 {
00081 ACE_NOTSUP_RETURN (0);
00082 }
00083
00084 int
00085 ACE_WIN32_Asynch_Result::post_completion (ACE_Proactor_Impl *proactor)
00086 {
00087
00088 ACE_WIN32_Proactor *win32_proactor = dynamic_cast<ACE_WIN32_Proactor *> (proactor);
00089
00090 if (win32_proactor == 0)
00091 ACE_ERROR_RETURN ((LM_ERROR,
00092 ACE_TEXT ("Dynamic cast to WIN32 Proactor failed\n")),
00093 -1);
00094
00095
00096 return win32_proactor->post_completion (this);
00097 }
00098
00099 void
00100 ACE_WIN32_Asynch_Result::set_bytes_transferred (size_t nbytes)
00101 {
00102 this->bytes_transferred_ = nbytes;
00103 }
00104
00105 void
00106 ACE_WIN32_Asynch_Result::set_error (u_long errcode)
00107 {
00108 this->error_ = errcode;
00109 }
00110
00111 ACE_WIN32_Asynch_Result::~ACE_WIN32_Asynch_Result (void)
00112 {
00113 }
00114
00115 ACE_WIN32_Asynch_Result::ACE_WIN32_Asynch_Result
00116 (const ACE_Handler::Proxy_Ptr &handler_proxy,
00117 const void* act,
00118 ACE_HANDLE event,
00119 u_long offset,
00120 u_long offset_high,
00121 int priority,
00122 int signal_number)
00123 : ACE_Asynch_Result_Impl (),
00124 OVERLAPPED (),
00125 handler_proxy_ (handler_proxy),
00126 act_ (act),
00127 bytes_transferred_ (0),
00128 success_ (0),
00129 completion_key_ (0),
00130 error_ (0)
00131 {
00132
00133 this->Internal = 0;
00134 this->InternalHigh = 0;
00135 this->Offset = offset;
00136 this->OffsetHigh = offset_high;
00137 this->hEvent = event;
00138
00139 ACE_UNUSED_ARG (priority);
00140 ACE_UNUSED_ARG (signal_number);
00141 }
00142
00143 int
00144 ACE_WIN32_Asynch_Operation::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
00145 ACE_HANDLE handle,
00146 const void *completion_key,
00147 ACE_Proactor *proactor)
00148 {
00149 this->proactor_ = proactor;
00150 this->handler_proxy_ = handler_proxy;
00151 this->handle_ = handle;
00152
00153
00154 if (this->handle_ == ACE_INVALID_HANDLE)
00155 {
00156 ACE_Handler *handler = handler_proxy.get ()->handler ();
00157 if (handler != 0)
00158 this->handle_ = handler->handle ();
00159 }
00160 if (this->handle_ == ACE_INVALID_HANDLE)
00161 return -1;
00162
00163 if (this->proactor_!= 0)
00164
00165 this->win32_proactor_ =
00166 dynamic_cast <ACE_WIN32_Proactor *>(this->proactor_->implementation ());
00167
00168
00169 return this->win32_proactor_->register_handle (this->handle_,
00170 completion_key);
00171 }
00172
00173 int
00174 ACE_WIN32_Asynch_Operation::cancel (void)
00175 {
00176 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO)
00177
00178
00179
00180
00181
00182
00183 int const result = (int) ::CancelIo (this->handle_);
00184
00185 if (result == 0)
00186
00187 return 2;
00188
00189
00190 return 0;
00191
00192 #else
00193 ACE_NOTSUP_RETURN (-1);
00194 #endif
00195 }
00196
00197 ACE_Proactor *
00198 ACE_WIN32_Asynch_Operation::proactor (void) const
00199 {
00200 return this->proactor_;
00201 }
00202
00203 ACE_WIN32_Asynch_Operation::ACE_WIN32_Asynch_Operation (ACE_WIN32_Proactor *win32_proactor)
00204 : ACE_Asynch_Operation_Impl (),
00205 win32_proactor_ (win32_proactor),
00206 proactor_ (0),
00207 handle_ (ACE_INVALID_HANDLE)
00208 {
00209 }
00210
00211 ACE_WIN32_Asynch_Operation::~ACE_WIN32_Asynch_Operation (void)
00212 {
00213 }
00214
00215
00216
00217 size_t
00218 ACE_WIN32_Asynch_Read_Stream_Result::bytes_to_read (void) const
00219 {
00220 return this->bytes_to_read_;
00221 }
00222
00223 ACE_Message_Block &
00224 ACE_WIN32_Asynch_Read_Stream_Result::message_block (void) const
00225 {
00226 return this->message_block_;
00227 }
00228
00229 ACE_HANDLE
00230 ACE_WIN32_Asynch_Read_Stream_Result::handle (void) const
00231 {
00232 return this->handle_;
00233 }
00234
00235 ACE_WIN32_Asynch_Read_Stream_Result::ACE_WIN32_Asynch_Read_Stream_Result (
00236 const ACE_Handler::Proxy_Ptr &handler_proxy,
00237 ACE_HANDLE handle,
00238 ACE_Message_Block &message_block,
00239 size_t bytes_to_read,
00240 const void* act,
00241 ACE_HANDLE event,
00242 int priority,
00243 int signal_number,
00244 int scatter_enabled)
00245 : ACE_Asynch_Result_Impl (),
00246 ACE_Asynch_Read_Stream_Result_Impl (),
00247 ACE_WIN32_Asynch_Result (handler_proxy,
00248 act,
00249 event,
00250 0,
00251 0,
00252 priority,
00253 signal_number),
00254 bytes_to_read_ (bytes_to_read),
00255 message_block_ (message_block),
00256 handle_ (handle),
00257 scatter_enabled_ (scatter_enabled)
00258 {
00259 }
00260
00261 void
00262 ACE_WIN32_Asynch_Read_Stream_Result::complete (size_t bytes_transferred,
00263 int success,
00264 const void *completion_key,
00265 u_long error)
00266 {
00267
00268 this->bytes_transferred_ = bytes_transferred;
00269 this->success_ = success;
00270 this->completion_key_ = completion_key;
00271 this->error_ = error;
00272
00273
00274 if (!this->scatter_enabled ())
00275 this->message_block_.wr_ptr (bytes_transferred);
00276 else
00277 {
00278 for (ACE_Message_Block* mb = &this->message_block_;
00279 (mb != 0) && (bytes_transferred > 0);
00280 mb = mb->cont ())
00281 {
00282 size_t len_part = mb->space ();
00283
00284 if (len_part > bytes_transferred)
00285 len_part = bytes_transferred;
00286
00287 mb->wr_ptr (len_part);
00288
00289 bytes_transferred -= len_part;
00290 }
00291 }
00292
00293
00294 ACE_Asynch_Read_Stream::Result result (this);
00295
00296
00297 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
00298 if (handler != 0)
00299 handler->handle_read_stream (result);
00300 }
00301
00302 ACE_WIN32_Asynch_Read_Stream_Result::~ACE_WIN32_Asynch_Read_Stream_Result (void)
00303 {
00304 }
00305
00306
00307
00308
00309 size_t
00310 ACE_WIN32_Asynch_Read_Stream_Result::bytes_transferred (void) const
00311 {
00312 return ACE_WIN32_Asynch_Result::bytes_transferred ();
00313 }
00314
00315 const void *
00316 ACE_WIN32_Asynch_Read_Stream_Result::act (void) const
00317 {
00318 return ACE_WIN32_Asynch_Result::act ();
00319 }
00320
00321 int
00322 ACE_WIN32_Asynch_Read_Stream_Result::success (void) const
00323 {
00324 return ACE_WIN32_Asynch_Result::success ();
00325 }
00326
00327 const void *
00328 ACE_WIN32_Asynch_Read_Stream_Result::completion_key (void) const
00329 {
00330 return ACE_WIN32_Asynch_Result::completion_key ();
00331 }
00332
00333 u_long
00334 ACE_WIN32_Asynch_Read_Stream_Result::error (void) const
00335 {
00336 return ACE_WIN32_Asynch_Result::error ();
00337 }
00338
00339 ACE_HANDLE
00340 ACE_WIN32_Asynch_Read_Stream_Result::event (void) const
00341 {
00342 return ACE_WIN32_Asynch_Result::event ();
00343 }
00344
00345 u_long
00346 ACE_WIN32_Asynch_Read_Stream_Result::offset (void) const
00347 {
00348 return ACE_WIN32_Asynch_Result::offset ();
00349 }
00350
00351 u_long
00352 ACE_WIN32_Asynch_Read_Stream_Result::offset_high (void) const
00353 {
00354 return ACE_WIN32_Asynch_Result::offset_high ();
00355 }
00356
00357 int
00358 ACE_WIN32_Asynch_Read_Stream_Result::priority (void) const
00359 {
00360 return ACE_WIN32_Asynch_Result::priority ();
00361 }
00362
00363 int
00364 ACE_WIN32_Asynch_Read_Stream_Result::signal_number (void) const
00365 {
00366 return ACE_WIN32_Asynch_Result::signal_number ();
00367 }
00368
00369 int
00370 ACE_WIN32_Asynch_Read_Stream_Result::post_completion (ACE_Proactor_Impl *proactor)
00371 {
00372 return ACE_WIN32_Asynch_Result::post_completion (proactor);
00373 }
00374
00375 int
00376 ACE_WIN32_Asynch_Read_Stream_Result::scatter_enabled (void) const
00377 {
00378 return this->scatter_enabled_;
00379 }
00380
00381 ACE_WIN32_Asynch_Read_Stream::ACE_WIN32_Asynch_Read_Stream (ACE_WIN32_Proactor *win32_proactor)
00382 : ACE_Asynch_Operation_Impl (),
00383 ACE_Asynch_Read_Stream_Impl (),
00384 ACE_WIN32_Asynch_Operation (win32_proactor)
00385 {
00386 }
00387
00388 int
00389 ACE_WIN32_Asynch_Read_Stream::read (ACE_Message_Block &message_block,
00390 size_t bytes_to_read,
00391 const void *act,
00392 int priority,
00393 int signal_number)
00394 {
00395 size_t space = message_block.space ();
00396 if (bytes_to_read > space)
00397 bytes_to_read = space;
00398
00399 if (bytes_to_read == 0)
00400 {
00401 errno = ENOSPC;
00402 return -1;
00403 }
00404
00405
00406 ACE_WIN32_Asynch_Read_Stream_Result *result = 0;
00407 ACE_NEW_RETURN (result,
00408 ACE_WIN32_Asynch_Read_Stream_Result (this->handler_proxy_,
00409 this->handle_,
00410 message_block,
00411 bytes_to_read,
00412 act,
00413 this->win32_proactor_->get_handle (),
00414 priority,
00415 signal_number),
00416 -1);
00417
00418
00419 int const return_val = this->shared_read (result);
00420
00421
00422 if (return_val == -1)
00423 delete result;
00424
00425 return return_val;
00426 }
00427
00428 int
00429 ACE_WIN32_Asynch_Read_Stream::readv (ACE_Message_Block &message_block,
00430 size_t bytes_to_read,
00431 const void *act,
00432 int priority,
00433 int signal_number)
00434 {
00435 #if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
00436 iovec iov[ACE_IOV_MAX];
00437 int iovcnt = 0;
00438
00439
00440
00441
00442 for (const ACE_Message_Block* msg = &message_block;
00443 msg != 0 && bytes_to_read > 0 && iovcnt < ACE_IOV_MAX;
00444 msg = msg->cont () , ++iovcnt )
00445 {
00446 size_t msg_space = msg->space ();
00447
00448
00449
00450
00451
00452
00453
00454
00455 if (msg_space > bytes_to_read)
00456 msg_space = bytes_to_read;
00457 bytes_to_read -= msg_space;
00458
00459
00460 size_t wr_ptr_offset = 0;
00461
00462 while (msg_space > 0 && iovcnt < ACE_IOV_MAX)
00463 {
00464 u_long this_chunk_length;
00465 if (msg_space > ULONG_MAX)
00466 this_chunk_length = ULONG_MAX;
00467 else
00468 this_chunk_length = static_cast<u_long> (msg_space);
00469
00470 iov[iovcnt].iov_base = msg->wr_ptr () + wr_ptr_offset;
00471 iov[iovcnt].iov_len = this_chunk_length;
00472 msg_space -= this_chunk_length;
00473 wr_ptr_offset += this_chunk_length;
00474
00475
00476 if (msg_space > 0)
00477 ++iovcnt;
00478 }
00479 if (msg_space > 0)
00480 {
00481 errno = ERANGE;
00482 return -1;
00483 }
00484 }
00485
00486
00487 bytes_to_read = 0;
00488
00489 for (int i = 0; i < iovcnt ; ++i)
00490 bytes_to_read += iov[i].iov_len;
00491
00492 if (bytes_to_read == 0)
00493 ACE_ERROR_RETURN ((LM_ERROR,
00494 ACE_TEXT ("ACE_WIN32_Asynch_Read_Stream::readv:")
00495 ACE_TEXT ("Attempt to read 0 bytes\n")),
00496 -1);
00497
00498
00499 ACE_WIN32_Asynch_Read_Stream_Result *result = 0;
00500 ACE_NEW_RETURN (result,
00501 ACE_WIN32_Asynch_Read_Stream_Result (this->handler_proxy_,
00502 this->handle_,
00503 message_block,
00504 bytes_to_read,
00505 act,
00506 this->win32_proactor_->get_handle (),
00507 priority,
00508 signal_number,
00509 1),
00510 -1);
00511
00512
00513
00514 result->set_error (0);
00515
00516 DWORD bytes_recvd = 0;
00517 u_long flags = 0;
00518
00519 int initiate_result = ::WSARecv (reinterpret_cast<SOCKET> (result->handle ()),
00520 reinterpret_cast<WSABUF *> (iov),
00521 iovcnt,
00522 &bytes_recvd,
00523 &flags,
00524 result,
00525 0);
00526
00527 if (0 == initiate_result)
00528
00529 return 1;
00530
00531 ACE_ASSERT (initiate_result == SOCKET_ERROR);
00532
00533
00534 ACE_OS::set_errno_to_last_error ();
00535 switch (errno)
00536 {
00537 case ERROR_IO_PENDING:
00538
00539
00540 initiate_result = 0;
00541 break;
00542
00543 default:
00544
00545
00546
00547 if (ACE::debug ())
00548 {
00549 ACE_DEBUG ((LM_ERROR,
00550 ACE_TEXT ("%p\n"),
00551 ACE_TEXT ("WSARecv")));
00552 }
00553
00554 delete result;
00555 initiate_result = -1;
00556 break;
00557 }
00558
00559 return initiate_result;
00560 #else
00561 ACE_UNUSED_ARG (message_block);
00562 ACE_UNUSED_ARG (bytes_to_read);
00563 ACE_UNUSED_ARG (act);
00564 ACE_UNUSED_ARG (priority);
00565 ACE_UNUSED_ARG (signal_number);
00566 ACE_NOTSUP_RETURN (-1);
00567 #endif
00568 }
00569
00570 ACE_WIN32_Asynch_Read_Stream::~ACE_WIN32_Asynch_Read_Stream (void)
00571 {
00572 }
00573
00574 int
00575 ACE_WIN32_Asynch_Read_Stream::shared_read (ACE_WIN32_Asynch_Read_Stream_Result *result)
00576 {
00577
00578 if (result->bytes_to_read () > MAXDWORD)
00579 {
00580 errno = ERANGE;
00581 return -1;
00582 }
00583 DWORD bytes_to_read = static_cast<DWORD> (result->bytes_to_read ());
00584 u_long bytes_read;
00585
00586 result->set_error (0);
00587
00588
00589 int initiate_result = ::ReadFile (result->handle (),
00590 result->message_block ().wr_ptr (),
00591 bytes_to_read,
00592 &bytes_read,
00593 result);
00594 if (initiate_result == 1)
00595
00596 return 0;
00597
00598
00599 ACE_OS::set_errno_to_last_error ();
00600 switch (errno)
00601 {
00602 case ERROR_IO_PENDING:
00603
00604 case ERROR_MORE_DATA:
00605
00606
00607 return 0;
00608
00609 default:
00610
00611
00612
00613 if (ACE::debug ())
00614 {
00615 ACE_DEBUG ((LM_ERROR,
00616 ACE_TEXT ("%p\n"),
00617 ACE_TEXT ("ReadFile")));
00618 }
00619
00620 return -1;
00621 }
00622 }
00623
00624
00625
00626
00627
00628 int
00629 ACE_WIN32_Asynch_Read_Stream::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
00630 ACE_HANDLE handle,
00631 const void *completion_key,
00632 ACE_Proactor *proactor)
00633 {
00634 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
00635 handle,
00636 completion_key,
00637 proactor);
00638 }
00639
00640 int
00641 ACE_WIN32_Asynch_Read_Stream::cancel (void)
00642 {
00643 return ACE_WIN32_Asynch_Operation::cancel ();
00644 }
00645
00646 ACE_Proactor *
00647 ACE_WIN32_Asynch_Read_Stream::proactor (void) const
00648 {
00649 return ACE_WIN32_Asynch_Operation::proactor ();
00650 }
00651
00652 size_t
00653 ACE_WIN32_Asynch_Write_Stream_Result::bytes_to_write (void) const
00654 {
00655 return this->bytes_to_write_;
00656 }
00657
00658 ACE_Message_Block &
00659 ACE_WIN32_Asynch_Write_Stream_Result::message_block (void) const
00660 {
00661 return this->message_block_;
00662 }
00663
00664 ACE_HANDLE
00665 ACE_WIN32_Asynch_Write_Stream_Result::handle (void) const
00666 {
00667 return this->handle_;
00668 }
00669
00670 ACE_WIN32_Asynch_Write_Stream_Result::ACE_WIN32_Asynch_Write_Stream_Result (
00671 const ACE_Handler::Proxy_Ptr &handler_proxy,
00672 ACE_HANDLE handle,
00673 ACE_Message_Block &message_block,
00674 size_t bytes_to_write,
00675 const void* act,
00676 ACE_HANDLE event,
00677 int priority,
00678 int signal_number,
00679 int gather_enabled)
00680 : ACE_Asynch_Result_Impl (),
00681 ACE_Asynch_Write_Stream_Result_Impl (),
00682 ACE_WIN32_Asynch_Result
00683 (handler_proxy, act, event, 0, 0, priority, signal_number),
00684 bytes_to_write_ (bytes_to_write),
00685 message_block_ (message_block),
00686 handle_ (handle),
00687 gather_enabled_ (gather_enabled)
00688 {
00689 }
00690
00691 void
00692 ACE_WIN32_Asynch_Write_Stream_Result::complete (size_t bytes_transferred,
00693 int success,
00694 const void *completion_key,
00695 u_long error)
00696 {
00697
00698 this->bytes_transferred_ = bytes_transferred;
00699 this->success_ = success;
00700 this->completion_key_ = completion_key;
00701 this->error_ = error;
00702
00703
00704 if (!this->gather_enabled ())
00705 this->message_block_.rd_ptr (bytes_transferred);
00706 else
00707 {
00708 for (ACE_Message_Block* mb = &this->message_block_;
00709 (mb != 0) && (bytes_transferred > 0);
00710 mb = mb->cont ())
00711 {
00712 size_t len_part = mb->length ();
00713
00714 if ( len_part > bytes_transferred)
00715 len_part = bytes_transferred;
00716
00717 mb->rd_ptr (len_part);
00718
00719 bytes_transferred -= len_part;
00720 }
00721 }
00722
00723
00724 ACE_Asynch_Write_Stream::Result result (this);
00725
00726
00727 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
00728 if (handler != 0)
00729 handler->handle_write_stream (result);
00730 }
00731
00732 ACE_WIN32_Asynch_Write_Stream_Result::~ACE_WIN32_Asynch_Write_Stream_Result (void)
00733 {
00734 }
00735
00736
00737
00738
00739 size_t
00740 ACE_WIN32_Asynch_Write_Stream_Result::bytes_transferred (void) const
00741 {
00742 return ACE_WIN32_Asynch_Result::bytes_transferred ();
00743 }
00744
00745 const void *
00746 ACE_WIN32_Asynch_Write_Stream_Result::act (void) const
00747 {
00748 return ACE_WIN32_Asynch_Result::act ();
00749 }
00750
00751 int
00752 ACE_WIN32_Asynch_Write_Stream_Result::success (void) const
00753 {
00754 return ACE_WIN32_Asynch_Result::success ();
00755 }
00756
00757 const void *
00758 ACE_WIN32_Asynch_Write_Stream_Result::completion_key (void) const
00759 {
00760 return ACE_WIN32_Asynch_Result::completion_key ();
00761 }
00762
00763 u_long
00764 ACE_WIN32_Asynch_Write_Stream_Result::error (void) const
00765 {
00766 return ACE_WIN32_Asynch_Result::error ();
00767 }
00768
00769 ACE_HANDLE
00770 ACE_WIN32_Asynch_Write_Stream_Result::event (void) const
00771 {
00772 return ACE_WIN32_Asynch_Result::event ();
00773 }
00774
00775 u_long
00776 ACE_WIN32_Asynch_Write_Stream_Result::offset (void) const
00777 {
00778 return ACE_WIN32_Asynch_Result::offset ();
00779 }
00780
00781 u_long
00782 ACE_WIN32_Asynch_Write_Stream_Result::offset_high (void) const
00783 {
00784 return ACE_WIN32_Asynch_Result::offset_high ();
00785 }
00786
00787 int
00788 ACE_WIN32_Asynch_Write_Stream_Result::priority (void) const
00789 {
00790 return ACE_WIN32_Asynch_Result::priority ();
00791 }
00792
00793 int
00794 ACE_WIN32_Asynch_Write_Stream_Result::signal_number (void) const
00795 {
00796 return ACE_WIN32_Asynch_Result::signal_number ();
00797 }
00798
00799 int
00800 ACE_WIN32_Asynch_Write_Stream_Result::post_completion (ACE_Proactor_Impl *proactor)
00801 {
00802 return ACE_WIN32_Asynch_Result::post_completion (proactor);
00803 }
00804
00805 int
00806 ACE_WIN32_Asynch_Write_Stream_Result::gather_enabled (void) const
00807 {
00808 return this->gather_enabled_;
00809 }
00810
00811 ACE_WIN32_Asynch_Write_Stream::ACE_WIN32_Asynch_Write_Stream (ACE_WIN32_Proactor *win32_proactor)
00812 : ACE_Asynch_Operation_Impl (),
00813 ACE_Asynch_Write_Stream_Impl (),
00814 ACE_WIN32_Asynch_Operation (win32_proactor)
00815 {
00816 }
00817
00818 int
00819 ACE_WIN32_Asynch_Write_Stream::write (ACE_Message_Block &message_block,
00820 size_t bytes_to_write,
00821 const void *act,
00822 int priority,
00823 int signal_number)
00824 {
00825 size_t len = message_block.length();
00826
00827 if (bytes_to_write > len)
00828 bytes_to_write = len ;
00829
00830 if (bytes_to_write == 0)
00831 ACE_ERROR_RETURN
00832 ((LM_ERROR,
00833 ACE_TEXT ("ACE_WIN32_Asynch_Write_Stream::write:")
00834 ACE_TEXT ("Attempt to write 0 bytes\n")),
00835 -1);
00836
00837 ACE_WIN32_Asynch_Write_Stream_Result *result = 0;
00838 ACE_NEW_RETURN (result,
00839 ACE_WIN32_Asynch_Write_Stream_Result (this->handler_proxy_,
00840 this->handle_,
00841 message_block,
00842 bytes_to_write,
00843 act,
00844 this->win32_proactor_->get_handle (),
00845 priority,
00846 signal_number),
00847 -1);
00848
00849
00850 int const return_val = this->shared_write (result);
00851
00852
00853 if (return_val == -1)
00854 {
00855 delete result;
00856 }
00857
00858 return return_val;
00859 }
00860
00861 int
00862 ACE_WIN32_Asynch_Write_Stream::writev (ACE_Message_Block &message_block,
00863 size_t bytes_to_write,
00864 const void *act,
00865 int priority,
00866 int signal_number)
00867 {
00868 #if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
00869 iovec iov[ACE_IOV_MAX];
00870 int iovcnt = 0;
00871
00872
00873
00874
00875 for (const ACE_Message_Block* msg = &message_block;
00876 msg != 0 && bytes_to_write > 0 && iovcnt < ACE_IOV_MAX;
00877 msg = msg->cont ())
00878 {
00879 size_t msg_len = msg->length ();
00880
00881
00882 if (msg_len == 0)
00883 continue;
00884 if (msg_len > bytes_to_write)
00885 msg_len = bytes_to_write;
00886 bytes_to_write -= msg_len;
00887
00888
00889 size_t rd_ptr_offset = 0;
00890
00891 while (msg_len > 0 && iovcnt < ACE_IOV_MAX)
00892 {
00893 u_long this_chunk_length;
00894 if (msg_len > ULONG_MAX)
00895 this_chunk_length = ULONG_MAX;
00896 else
00897 this_chunk_length = static_cast<u_long> (msg_len);
00898
00899 iov[iovcnt].iov_base = msg->rd_ptr () + rd_ptr_offset;
00900 iov[iovcnt].iov_len = this_chunk_length;
00901 msg_len -= this_chunk_length;
00902 rd_ptr_offset += this_chunk_length;
00903
00904
00905 if (msg_len > 0)
00906 iovcnt++;
00907 }
00908 if (msg_len > 0)
00909 {
00910 errno = ERANGE;
00911 return -1;
00912 }
00913 ++iovcnt;
00914 }
00915
00916
00917 bytes_to_write = 0;
00918
00919 for ( int i=0; i < iovcnt ; ++i )
00920 bytes_to_write += iov[i].iov_len;
00921
00922 if ( bytes_to_write == 0 )
00923 ACE_ERROR_RETURN ((LM_ERROR,
00924 ACE_TEXT ("ACE_WIN32_Asynch_Write_Stream::writev:")
00925 ACE_TEXT ("Attempt to write 0 bytes\n")),
00926 -1);
00927
00928
00929 ACE_WIN32_Asynch_Write_Stream_Result *result = 0;
00930 ACE_NEW_RETURN (result,
00931 ACE_WIN32_Asynch_Write_Stream_Result (this->handler_proxy_,
00932 this->handle_,
00933 message_block,
00934 bytes_to_write,
00935 act,
00936 this->win32_proactor_->get_handle (),
00937 priority,
00938 signal_number,
00939 1),
00940 -1);
00941
00942
00943
00944 u_long bytes_sent = 0;
00945
00946 int initiate_result = ::WSASend (reinterpret_cast<SOCKET> (result->handle ()),
00947 reinterpret_cast<WSABUF *> (iov),
00948 iovcnt,
00949 &bytes_sent,
00950 0,
00951 result,
00952 0);
00953
00954 if (0 == initiate_result)
00955
00956 return 1;
00957
00958 ACE_ASSERT (initiate_result == SOCKET_ERROR);
00959
00960
00961 ACE_OS::set_errno_to_last_error ();
00962 switch (errno)
00963 {
00964 case ERROR_IO_PENDING:
00965
00966
00967 initiate_result = 0;
00968 break;
00969
00970 default:
00971
00972
00973
00974 if (ACE::debug ())
00975 {
00976 ACE_DEBUG ((LM_ERROR,
00977 ACE_TEXT ("%p\n"),
00978 ACE_TEXT ("WSASend")));
00979 }
00980
00981 delete result;
00982 initiate_result = -1;
00983 break;
00984 }
00985
00986 return initiate_result;
00987 #else
00988 ACE_UNUSED_ARG (message_block);
00989 ACE_UNUSED_ARG (bytes_to_write);
00990 ACE_UNUSED_ARG (act);
00991 ACE_UNUSED_ARG (priority);
00992 ACE_UNUSED_ARG (signal_number);
00993 ACE_NOTSUP_RETURN (-1);
00994 #endif
00995 }
00996
00997 ACE_WIN32_Asynch_Write_Stream::~ACE_WIN32_Asynch_Write_Stream (void)
00998 {
00999 }
01000
01001 int
01002 ACE_WIN32_Asynch_Write_Stream::shared_write (ACE_WIN32_Asynch_Write_Stream_Result *result)
01003 {
01004 u_long bytes_written;
01005 if (result->bytes_to_write () > MAXDWORD)
01006 {
01007 errno = ERANGE;
01008 return -1;
01009 }
01010 DWORD bytes_to_write = static_cast<DWORD> (result->bytes_to_write ());
01011
01012 result->set_error (0);
01013
01014
01015
01016 int initiate_result = 0;
01017 #if (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
01018 WSABUF iov;
01019 iov.buf = result->message_block ().rd_ptr ();
01020 iov.len = bytes_to_write;
01021 initiate_result = ::WSASend (reinterpret_cast<SOCKET> (result->handle ()),
01022 &iov,
01023 1,
01024 &bytes_written,
01025 0,
01026 result,
01027 0);
01028 if (initiate_result == 0)
01029 {
01030
01031 return 0;
01032 }
01033 #else
01034 initiate_result = ::WriteFile (result->handle (),
01035 result->message_block ().rd_ptr (),
01036 bytes_to_write,
01037 &bytes_written,
01038 result);
01039 if (initiate_result == 1)
01040
01041 return 0;
01042 #endif
01043
01044
01045 ACE_OS::set_errno_to_last_error ();
01046 switch (errno)
01047 {
01048 case ERROR_IO_PENDING:
01049
01050
01051 return 0;
01052
01053 default:
01054
01055
01056
01057 if (ACE::debug ())
01058 ACE_DEBUG ((LM_ERROR,
01059 ACE_TEXT ("%p\n"),
01060 ACE_TEXT ("Initiating write")));
01061 return -1;
01062 }
01063 }
01064
01065
01066
01067
01068
01069 int
01070 ACE_WIN32_Asynch_Write_Stream::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
01071 ACE_HANDLE handle,
01072 const void *completion_key,
01073 ACE_Proactor *proactor)
01074 {
01075 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
01076 handle,
01077 completion_key,
01078 proactor);
01079 }
01080
01081 int
01082 ACE_WIN32_Asynch_Write_Stream::cancel (void)
01083 {
01084 return ACE_WIN32_Asynch_Operation::cancel ();
01085 }
01086
01087 ACE_Proactor *
01088 ACE_WIN32_Asynch_Write_Stream::proactor (void) const
01089 {
01090 return ACE_WIN32_Asynch_Operation::proactor ();
01091 }
01092
01093 ACE_WIN32_Asynch_Read_File_Result::ACE_WIN32_Asynch_Read_File_Result (
01094 const ACE_Handler::Proxy_Ptr &handler_proxy,
01095 ACE_HANDLE handle,
01096 ACE_Message_Block &message_block,
01097 size_t bytes_to_read,
01098 const void* act,
01099 u_long offset,
01100 u_long offset_high,
01101 ACE_HANDLE event,
01102 int priority,
01103 int signal_number,
01104 int scatter_enabled)
01105 : ACE_Asynch_Result_Impl (),
01106 ACE_Asynch_Read_Stream_Result_Impl (),
01107 ACE_Asynch_Read_File_Result_Impl (),
01108 ACE_WIN32_Asynch_Read_Stream_Result (handler_proxy,
01109 handle,
01110 message_block,
01111 bytes_to_read,
01112 act,
01113 event,
01114 priority,
01115 signal_number,
01116 scatter_enabled)
01117 {
01118 this->Offset = offset;
01119 this->OffsetHigh = offset_high;
01120 }
01121
01122 void
01123 ACE_WIN32_Asynch_Read_File_Result::complete (size_t bytes_transferred,
01124 int success,
01125 const void *completion_key,
01126 u_long error)
01127 {
01128
01129 this->bytes_transferred_ = bytes_transferred;
01130 this->success_ = success;
01131 this->completion_key_ = completion_key;
01132 this->error_ = error;
01133
01134
01135 if (!this->scatter_enabled ())
01136 this->message_block_.wr_ptr (bytes_transferred);
01137 else
01138 {
01139 static const size_t page_size = ACE_OS::getpagesize();
01140
01141 for (ACE_Message_Block* mb = &this->message_block_;
01142 (mb != 0) && (bytes_transferred > 0);
01143 mb = mb->cont ())
01144 {
01145
01146
01147
01148
01149 size_t len_part = page_size ;
01150
01151 if ( len_part > bytes_transferred)
01152 len_part = bytes_transferred;
01153
01154 mb->wr_ptr (len_part);
01155
01156 bytes_transferred -= len_part;
01157 }
01158 }
01159
01160
01161 ACE_Asynch_Read_File::Result result (this);
01162
01163
01164 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
01165 if (handler != 0)
01166 handler->handle_read_file (result);
01167 }
01168
01169 ACE_WIN32_Asynch_Read_File_Result::~ACE_WIN32_Asynch_Read_File_Result (void)
01170 {
01171 }
01172
01173
01174
01175
01176 size_t
01177 ACE_WIN32_Asynch_Read_File_Result::bytes_transferred (void) const
01178 {
01179 return ACE_WIN32_Asynch_Result::bytes_transferred ();
01180 }
01181
01182 const void *
01183 ACE_WIN32_Asynch_Read_File_Result::act (void) const
01184 {
01185 return ACE_WIN32_Asynch_Result::act ();
01186 }
01187
01188 int
01189 ACE_WIN32_Asynch_Read_File_Result::success (void) const
01190 {
01191 return ACE_WIN32_Asynch_Result::success ();
01192 }
01193
01194 const void *
01195 ACE_WIN32_Asynch_Read_File_Result::completion_key (void) const
01196 {
01197 return ACE_WIN32_Asynch_Result::completion_key ();
01198 }
01199
01200 u_long
01201 ACE_WIN32_Asynch_Read_File_Result::error (void) const
01202 {
01203 return ACE_WIN32_Asynch_Result::error ();
01204 }
01205
01206 ACE_HANDLE
01207 ACE_WIN32_Asynch_Read_File_Result::event (void) const
01208 {
01209 return ACE_WIN32_Asynch_Result::event ();
01210 }
01211
01212 u_long
01213 ACE_WIN32_Asynch_Read_File_Result::offset (void) const
01214 {
01215 return ACE_WIN32_Asynch_Result::offset ();
01216 }
01217
01218 u_long
01219 ACE_WIN32_Asynch_Read_File_Result::offset_high (void) const
01220 {
01221 return ACE_WIN32_Asynch_Result::offset_high ();
01222 }
01223
01224 int
01225 ACE_WIN32_Asynch_Read_File_Result::priority (void) const
01226 {
01227 return ACE_WIN32_Asynch_Result::priority ();
01228 }
01229
01230 int
01231 ACE_WIN32_Asynch_Read_File_Result::signal_number (void) const
01232 {
01233 return ACE_WIN32_Asynch_Result::signal_number ();
01234 }
01235
01236
01237
01238
01239
01240
01241 size_t
01242 ACE_WIN32_Asynch_Read_File_Result::bytes_to_read (void) const
01243 {
01244 return ACE_WIN32_Asynch_Read_Stream_Result::bytes_to_read ();
01245 }
01246
01247 ACE_Message_Block &
01248 ACE_WIN32_Asynch_Read_File_Result::message_block (void) const
01249 {
01250 return ACE_WIN32_Asynch_Read_Stream_Result::message_block ();
01251 }
01252
01253 ACE_HANDLE
01254 ACE_WIN32_Asynch_Read_File_Result::handle (void) const
01255 {
01256 return ACE_WIN32_Asynch_Read_Stream_Result::handle ();
01257 }
01258
01259 int
01260 ACE_WIN32_Asynch_Read_File_Result::post_completion (ACE_Proactor_Impl *proactor)
01261 {
01262 return ACE_WIN32_Asynch_Result::post_completion (proactor);
01263 }
01264
01265
01266
01267 ACE_WIN32_Asynch_Read_File::ACE_WIN32_Asynch_Read_File (ACE_WIN32_Proactor *win32_proactor)
01268 : ACE_Asynch_Operation_Impl (),
01269 ACE_Asynch_Read_Stream_Impl (),
01270 ACE_Asynch_Read_File_Impl (),
01271 ACE_WIN32_Asynch_Read_Stream (win32_proactor)
01272 {
01273 }
01274
01275 int
01276 ACE_WIN32_Asynch_Read_File::read (ACE_Message_Block &message_block,
01277 size_t bytes_to_read,
01278 u_long offset,
01279 u_long offset_high,
01280 const void *act,
01281 int priority,
01282 int signal_number)
01283 {
01284 size_t space = message_block.space ();
01285 if ( bytes_to_read > space )
01286 bytes_to_read = space;
01287
01288 if ( bytes_to_read == 0 )
01289 ACE_ERROR_RETURN
01290 ((LM_ERROR,
01291 ACE_TEXT ("ACE_WIN32_Asynch_Read_File::read:")
01292 ACE_TEXT ("Attempt to read 0 bytes or no space in the message block\n")),
01293 -1);
01294
01295
01296 ACE_WIN32_Asynch_Read_File_Result *result = 0;
01297 ACE_NEW_RETURN (result,
01298 ACE_WIN32_Asynch_Read_File_Result (this->handler_proxy_,
01299 this->handle_,
01300 message_block,
01301 bytes_to_read,
01302 act,
01303 offset,
01304 offset_high,
01305 this->win32_proactor_->get_handle (),
01306 priority,
01307 signal_number),
01308 -1);
01309
01310
01311 int return_val = this->shared_read (result);
01312
01313
01314 if (return_val == -1)
01315 delete result;
01316
01317 return return_val;
01318 }
01319
01320 int
01321 ACE_WIN32_Asynch_Read_File::readv (ACE_Message_Block &message_block,
01322 size_t bytes_to_read,
01323 u_long offset,
01324 u_long offset_high,
01325 const void *act,
01326 int priority,
01327 int signal_number)
01328 {
01329 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO)
01330 static const size_t page_size = ACE_OS::getpagesize();
01331
01332 FILE_SEGMENT_ELEMENT buffer_pointers[ACE_IOV_MAX + 1];
01333 int buffer_pointers_count = 0;
01334
01335
01336
01337
01338
01339
01340
01341 size_t total_space = 0;
01342
01343 for (const ACE_Message_Block* msg = &message_block;
01344 msg != 0 && buffer_pointers_count < ACE_IOV_MAX && total_space < bytes_to_read;
01345 msg = msg->cont(), ++buffer_pointers_count )
01346 {
01347 size_t msg_space = msg->space ();
01348
01349 if (msg_space < page_size)
01350 ACE_ERROR_RETURN ((LM_ERROR,
01351 ACE_TEXT ("ACE_WIN32_Asynch_Read_File::readv:")
01352 ACE_TEXT ("Invalid message block size\n")),
01353 -1);
01354
01355 buffer_pointers[buffer_pointers_count].Buffer = msg->wr_ptr ();
01356 total_space += page_size;
01357 }
01358
01359
01360 if (bytes_to_read > total_space)
01361 bytes_to_read = total_space;
01362
01363
01364 if (bytes_to_read > MAXDWORD)
01365 {
01366 errno = ERANGE;
01367 return -1;
01368 }
01369 DWORD dword_bytes_to_read = static_cast<DWORD> (bytes_to_read);
01370
01371
01372 buffer_pointers[buffer_pointers_count].Buffer = 0;
01373
01374 ACE_WIN32_Asynch_Read_File_Result *result = 0;
01375 ACE_NEW_RETURN (result,
01376 ACE_WIN32_Asynch_Read_File_Result (this->handler_proxy_,
01377 this->handle_,
01378 message_block,
01379 bytes_to_read,
01380 act,
01381 offset,
01382 offset_high,
01383 this->win32_proactor_->get_handle (),
01384 priority,
01385 signal_number,
01386 1),
01387 -1);
01388
01389
01390 result->set_error (0);
01391
01392 int initiate_result = ::ReadFileScatter (result->handle (),
01393 buffer_pointers,
01394 dword_bytes_to_read,
01395 0,
01396 result);
01397
01398 if (0 != initiate_result)
01399
01400 return 1;
01401
01402
01403 ACE_OS::set_errno_to_last_error ();
01404 switch (errno)
01405 {
01406 case ERROR_IO_PENDING:
01407
01408
01409 initiate_result = 0;
01410 break;
01411
01412 default:
01413
01414
01415
01416 if (ACE::debug ())
01417 {
01418 ACE_DEBUG ((LM_ERROR,
01419 ACE_TEXT ("%p\n"),
01420 ACE_TEXT ("ReadFileScatter")));
01421 }
01422
01423 delete result;
01424 initiate_result = -1;
01425 break;
01426 }
01427
01428 return initiate_result;
01429 #else
01430 ACE_NOTSUP_RETURN (-1);
01431 #endif
01432 }
01433
01434
01435 ACE_WIN32_Asynch_Read_File::~ACE_WIN32_Asynch_Read_File (void)
01436 {
01437 }
01438
01439 int
01440 ACE_WIN32_Asynch_Read_File::read (ACE_Message_Block &message_block,
01441 size_t bytes_to_read,
01442 const void *act,
01443 int priority,
01444 int signal_number)
01445 {
01446 return ACE_WIN32_Asynch_Read_Stream::read (message_block,
01447 bytes_to_read,
01448 act,
01449 priority,
01450 signal_number);
01451 }
01452
01453 int
01454 ACE_WIN32_Asynch_Read_File::readv (ACE_Message_Block &message_block,
01455 size_t bytes_to_read,
01456 const void *act,
01457 int priority,
01458 int signal_number)
01459 {
01460 return ACE_WIN32_Asynch_Read_Stream::readv (message_block,
01461 bytes_to_read,
01462 act,
01463 priority,
01464 signal_number);
01465 }
01466
01467
01468
01469
01470
01471 int
01472 ACE_WIN32_Asynch_Read_File::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
01473 ACE_HANDLE handle,
01474 const void *completion_key,
01475 ACE_Proactor *proactor)
01476 {
01477 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
01478 handle,
01479 completion_key,
01480 proactor);
01481 }
01482
01483 int
01484 ACE_WIN32_Asynch_Read_File::cancel (void)
01485 {
01486 return ACE_WIN32_Asynch_Operation::cancel ();
01487 }
01488
01489 ACE_Proactor *
01490 ACE_WIN32_Asynch_Read_File::proactor (void) const
01491 {
01492 return ACE_WIN32_Asynch_Operation::proactor ();
01493 }
01494
01495 ACE_WIN32_Asynch_Write_File_Result::ACE_WIN32_Asynch_Write_File_Result (
01496 const ACE_Handler::Proxy_Ptr &handler_proxy,
01497 ACE_HANDLE handle,
01498 ACE_Message_Block &message_block,
01499 size_t bytes_to_write,
01500 const void* act,
01501 u_long offset,
01502 u_long offset_high,
01503 ACE_HANDLE event,
01504 int priority,
01505 int signal_number,
01506 int gather_enabled)
01507 : ACE_Asynch_Result_Impl (),
01508 ACE_Asynch_Write_Stream_Result_Impl (),
01509 ACE_Asynch_Write_File_Result_Impl (),
01510 ACE_WIN32_Asynch_Write_Stream_Result (handler_proxy,
01511 handle,
01512 message_block,
01513 bytes_to_write,
01514 act,
01515 event,
01516 priority,
01517 signal_number,
01518 gather_enabled)
01519 {
01520 this->Offset = offset;
01521 this->OffsetHigh = offset_high;
01522 }
01523
01524 void
01525 ACE_WIN32_Asynch_Write_File_Result::complete (size_t bytes_transferred,
01526 int success,
01527 const void *completion_key,
01528 u_long error)
01529 {
01530
01531 this->bytes_transferred_ = bytes_transferred;
01532 this->success_ = success;
01533 this->completion_key_ = completion_key;
01534 this->error_ = error;
01535
01536
01537 if (!this->gather_enabled ())
01538 this->message_block_.rd_ptr (bytes_transferred);
01539 else
01540 {
01541 static const size_t page_size = ACE_OS::getpagesize();
01542
01543 for (ACE_Message_Block* mb = &this->message_block_;
01544 (mb != 0) && (bytes_transferred > 0);
01545 mb = mb->cont ())
01546 {
01547
01548
01549
01550
01551 size_t len_part = page_size;
01552
01553 if ( len_part > bytes_transferred)
01554 len_part = bytes_transferred;
01555
01556 mb->rd_ptr (len_part);
01557
01558 bytes_transferred -= len_part;
01559 }
01560
01561 }
01562
01563
01564 ACE_Asynch_Write_File::Result result (this);
01565
01566
01567 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
01568 if (handler != 0)
01569 handler->handle_write_file (result);
01570 }
01571
01572 ACE_WIN32_Asynch_Write_File_Result::~ACE_WIN32_Asynch_Write_File_Result (void)
01573 {
01574 }
01575
01576
01577
01578
01579 size_t
01580 ACE_WIN32_Asynch_Write_File_Result::bytes_transferred (void) const
01581 {
01582 return ACE_WIN32_Asynch_Result::bytes_transferred ();
01583 }
01584
01585 const void *
01586 ACE_WIN32_Asynch_Write_File_Result::act (void) const
01587 {
01588 return ACE_WIN32_Asynch_Result::act ();
01589 }
01590
01591 int
01592 ACE_WIN32_Asynch_Write_File_Result::success (void) const
01593 {
01594 return ACE_WIN32_Asynch_Result::success ();
01595 }
01596
01597 const void *
01598 ACE_WIN32_Asynch_Write_File_Result::completion_key (void) const
01599 {
01600 return ACE_WIN32_Asynch_Result::completion_key ();
01601 }
01602
01603 u_long
01604 ACE_WIN32_Asynch_Write_File_Result::error (void) const
01605 {
01606 return ACE_WIN32_Asynch_Result::error ();
01607 }
01608
01609 ACE_HANDLE
01610 ACE_WIN32_Asynch_Write_File_Result::event (void) const
01611 {
01612 return ACE_WIN32_Asynch_Result::event ();
01613 }
01614
01615 u_long
01616 ACE_WIN32_Asynch_Write_File_Result::offset (void) const
01617 {
01618 return ACE_WIN32_Asynch_Result::offset ();
01619 }
01620
01621 u_long
01622 ACE_WIN32_Asynch_Write_File_Result::offset_high (void) const
01623 {
01624 return ACE_WIN32_Asynch_Result::offset_high ();
01625 }
01626
01627 int
01628 ACE_WIN32_Asynch_Write_File_Result::priority (void) const
01629 {
01630 return ACE_WIN32_Asynch_Result::priority ();
01631 }
01632
01633 int
01634 ACE_WIN32_Asynch_Write_File_Result::signal_number (void) const
01635 {
01636 return ACE_WIN32_Asynch_Result::signal_number ();
01637 }
01638
01639
01640
01641
01642
01643
01644 size_t
01645 ACE_WIN32_Asynch_Write_File_Result::bytes_to_write (void) const
01646 {
01647 return ACE_WIN32_Asynch_Write_Stream_Result::bytes_to_write ();
01648 }
01649
01650 ACE_Message_Block &
01651 ACE_WIN32_Asynch_Write_File_Result::message_block (void) const
01652 {
01653 return ACE_WIN32_Asynch_Write_Stream_Result::message_block ();
01654 }
01655
01656 ACE_HANDLE
01657 ACE_WIN32_Asynch_Write_File_Result::handle (void) const
01658 {
01659 return ACE_WIN32_Asynch_Write_Stream_Result::handle ();
01660 }
01661
01662 int
01663 ACE_WIN32_Asynch_Write_File_Result::post_completion (ACE_Proactor_Impl *proactor)
01664 {
01665 return ACE_WIN32_Asynch_Result::post_completion (proactor);
01666 }
01667
01668 ACE_WIN32_Asynch_Write_File::ACE_WIN32_Asynch_Write_File (ACE_WIN32_Proactor *win32_proactor)
01669 : ACE_Asynch_Operation_Impl (),
01670 ACE_Asynch_Write_Stream_Impl (),
01671 ACE_Asynch_Write_File_Impl (),
01672 ACE_WIN32_Asynch_Write_Stream (win32_proactor)
01673 {
01674 }
01675
01676 int
01677 ACE_WIN32_Asynch_Write_File::write (ACE_Message_Block &message_block,
01678 size_t bytes_to_write,
01679 u_long offset,
01680 u_long offset_high,
01681 const void *act,
01682 int priority,
01683 int signal_number)
01684 {
01685 size_t len = message_block.length ();
01686 if ( bytes_to_write > len )
01687 bytes_to_write = len;
01688
01689 if ( bytes_to_write == 0 )
01690 ACE_ERROR_RETURN
01691 ((LM_ERROR,
01692 ACE_TEXT ("ACE_WIN32_Asynch_Write_File::write:")
01693 ACE_TEXT ("Attempt to read 0 bytes\n")),
01694 -1);
01695
01696 ACE_WIN32_Asynch_Write_File_Result *result = 0;
01697 ACE_NEW_RETURN (result,
01698 ACE_WIN32_Asynch_Write_File_Result (this->handler_proxy_,
01699 this->handle_,
01700 message_block,
01701 bytes_to_write,
01702 act,
01703 offset,
01704 offset_high,
01705 this->win32_proactor_->get_handle (),
01706 priority,
01707 signal_number),
01708 -1);
01709
01710
01711 int return_val = this->shared_write (result);
01712
01713
01714 if (return_val == -1)
01715 delete result;
01716
01717 return return_val;
01718 }
01719
01720 int
01721 ACE_WIN32_Asynch_Write_File::writev (ACE_Message_Block &message_block,
01722 size_t bytes_to_write,
01723 u_long offset,
01724 u_long offset_high,
01725 const void *act,
01726 int priority,
01727 int signal_number)
01728 {
01729 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO)
01730 static const size_t page_size = ACE_OS::getpagesize();
01731
01732 FILE_SEGMENT_ELEMENT buffer_pointers[ACE_IOV_MAX + 1];
01733 int buffer_pointers_count = 0;
01734
01735
01736
01737
01738
01739
01740
01741 size_t total_len = 0;
01742
01743 for (const ACE_Message_Block* msg = &message_block;
01744 msg != 0 && buffer_pointers_count < ACE_IOV_MAX && total_len < bytes_to_write;
01745 msg = msg->cont (), ++buffer_pointers_count )
01746 {
01747 size_t msg_len = msg->length ();
01748
01749
01750
01751
01752
01753 if (msg_len < page_size &&
01754 (msg->size () - (msg->rd_ptr () - msg->base ()) < page_size ||
01755 bytes_to_write - total_len > page_size ))
01756 ACE_ERROR_RETURN ((LM_ERROR,
01757 ACE_TEXT ("ACE_WIN32_Asynch_Write_File::writev:")
01758 ACE_TEXT ("Invalid message block length\n")),
01759 -1);
01760
01761 buffer_pointers[buffer_pointers_count].Buffer = msg->rd_ptr ();
01762 total_len += page_size;
01763 }
01764
01765
01766 if (bytes_to_write > total_len)
01767 bytes_to_write = total_len;
01768
01769 if (bytes_to_write > MAXDWORD)
01770 {
01771 errno = ERANGE;
01772 return -1;
01773 }
01774 DWORD dword_bytes_to_write = static_cast<DWORD> (bytes_to_write);
01775
01776
01777 buffer_pointers[buffer_pointers_count].Buffer = 0;
01778
01779 ACE_WIN32_Asynch_Write_File_Result *result = 0;
01780 ACE_NEW_RETURN (result,
01781 ACE_WIN32_Asynch_Write_File_Result (this->handler_proxy_,
01782 this->handle_,
01783 message_block,
01784 bytes_to_write,
01785 act,
01786 offset,
01787 offset_high,
01788 this->win32_proactor_->get_handle (),
01789 priority,
01790 signal_number,
01791 1),
01792 -1);
01793
01794 result->set_error(0);
01795
01796
01797 int initiate_result = ::WriteFileGather (result->handle (),
01798 buffer_pointers,
01799 dword_bytes_to_write,
01800 0,
01801 result);
01802
01803 if (0 != initiate_result)
01804
01805 return 1;
01806
01807
01808 ACE_OS::set_errno_to_last_error ();
01809 switch (errno)
01810 {
01811 case ERROR_IO_PENDING:
01812
01813
01814 initiate_result = 0;
01815 break;
01816
01817 default:
01818
01819
01820
01821 if (ACE::debug ())
01822 {
01823 ACE_DEBUG ((LM_ERROR,
01824 ACE_TEXT ("%p\n"),
01825 ACE_TEXT ("WriteFileGather")));
01826 }
01827
01828 delete result;
01829 initiate_result = -1;
01830 break;
01831 }
01832
01833 return initiate_result;
01834 #else
01835
01836 ACE_NOTSUP_RETURN (-1);
01837
01838 #endif
01839 }
01840
01841
01842 ACE_WIN32_Asynch_Write_File::~ACE_WIN32_Asynch_Write_File (void)
01843 {
01844 }
01845
01846 int
01847 ACE_WIN32_Asynch_Write_File::write (ACE_Message_Block &message_block,
01848 size_t bytes_to_write,
01849 const void *act,
01850 int priority,
01851 int signal_number)
01852 {
01853 return ACE_WIN32_Asynch_Write_Stream::write (message_block,
01854 bytes_to_write,
01855 act,
01856 priority,
01857 signal_number);
01858 }
01859
01860 int
01861 ACE_WIN32_Asynch_Write_File::writev (ACE_Message_Block &message_block,
01862 size_t bytes_to_write,
01863 const void *act,
01864 int priority,
01865 int signal_number)
01866 {
01867 return ACE_WIN32_Asynch_Write_Stream::writev (message_block,
01868 bytes_to_write,
01869 act,
01870 priority,
01871 signal_number);
01872 }
01873
01874
01875
01876
01877
01878 int
01879 ACE_WIN32_Asynch_Write_File::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
01880 ACE_HANDLE handle,
01881 const void *completion_key,
01882 ACE_Proactor *proactor)
01883 {
01884 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
01885 handle,
01886 completion_key,
01887 proactor);
01888 }
01889
01890 int
01891 ACE_WIN32_Asynch_Write_File::cancel (void)
01892 {
01893 return ACE_WIN32_Asynch_Operation::cancel ();
01894 }
01895
01896 ACE_Proactor *
01897 ACE_WIN32_Asynch_Write_File::proactor (void) const
01898 {
01899 return ACE_WIN32_Asynch_Operation::proactor ();
01900 }
01901
01902 size_t
01903 ACE_WIN32_Asynch_Accept_Result::bytes_to_read (void) const
01904 {
01905 return this->bytes_to_read_;
01906 }
01907
01908 ACE_Message_Block &
01909 ACE_WIN32_Asynch_Accept_Result::message_block (void) const
01910 {
01911 return this->message_block_;
01912 }
01913
01914 ACE_HANDLE
01915 ACE_WIN32_Asynch_Accept_Result::listen_handle (void) const
01916 {
01917 return this->listen_handle_;
01918 }
01919
01920 ACE_HANDLE
01921 ACE_WIN32_Asynch_Accept_Result::accept_handle (void) const
01922 {
01923 return this->accept_handle_;
01924 }
01925
01926 ACE_WIN32_Asynch_Accept_Result::ACE_WIN32_Asynch_Accept_Result (
01927 const ACE_Handler::Proxy_Ptr &handler_proxy,
01928 ACE_HANDLE listen_handle,
01929 ACE_HANDLE accept_handle,
01930 ACE_Message_Block &message_block,
01931 size_t bytes_to_read,
01932 const void* act,
01933 ACE_HANDLE event,
01934 int priority,
01935 int signal_number)
01936 : ACE_Asynch_Result_Impl (),
01937 ACE_Asynch_Accept_Result_Impl (),
01938 ACE_WIN32_Asynch_Result (handler_proxy,
01939 act,
01940 event,
01941 0,
01942 0,
01943 priority,
01944 signal_number),
01945 bytes_to_read_ (bytes_to_read),
01946 message_block_ (message_block),
01947 listen_handle_ (listen_handle),
01948 accept_handle_ (accept_handle)
01949 {
01950 }
01951
01952 void
01953 ACE_WIN32_Asynch_Accept_Result::complete (size_t bytes_transferred,
01954 int success,
01955 const void *completion_key,
01956 u_long error)
01957 {
01958
01959 this->bytes_transferred_ = bytes_transferred;
01960 this->success_ = success;
01961 this->completion_key_ = completion_key;
01962 this->error_ = error;
01963
01964
01965 this->message_block_.wr_ptr (bytes_transferred);
01966
01967 if (!success && this->accept_handle_ != ACE_INVALID_HANDLE)
01968 {
01969 ACE_OS::closesocket (this->accept_handle_);
01970 this->accept_handle_ = ACE_INVALID_HANDLE;
01971 }
01972
01973
01974 ACE_Asynch_Accept::Result result (this);
01975
01976
01977 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
01978 if (handler != 0)
01979 handler->handle_accept (result);
01980 }
01981
01982 ACE_WIN32_Asynch_Accept_Result::~ACE_WIN32_Asynch_Accept_Result (void)
01983 {
01984 }
01985
01986
01987
01988
01989 size_t
01990 ACE_WIN32_Asynch_Accept_Result::bytes_transferred (void) const
01991 {
01992 return ACE_WIN32_Asynch_Result::bytes_transferred ();
01993 }
01994
01995 const void *
01996 ACE_WIN32_Asynch_Accept_Result::act (void) const
01997 {
01998 return ACE_WIN32_Asynch_Result::act ();
01999 }
02000
02001 int
02002 ACE_WIN32_Asynch_Accept_Result::success (void) const
02003 {
02004 return ACE_WIN32_Asynch_Result::success ();
02005 }
02006
02007 const void *
02008 ACE_WIN32_Asynch_Accept_Result::completion_key (void) const
02009 {
02010 return ACE_WIN32_Asynch_Result::completion_key ();
02011 }
02012
02013 u_long
02014 ACE_WIN32_Asynch_Accept_Result::error (void) const
02015 {
02016 return ACE_WIN32_Asynch_Result::error ();
02017 }
02018
02019 ACE_HANDLE
02020 ACE_WIN32_Asynch_Accept_Result::event (void) const
02021 {
02022 return ACE_WIN32_Asynch_Result::event ();
02023 }
02024
02025 u_long
02026 ACE_WIN32_Asynch_Accept_Result::offset (void) const
02027 {
02028 return ACE_WIN32_Asynch_Result::offset ();
02029 }
02030
02031 u_long
02032 ACE_WIN32_Asynch_Accept_Result::offset_high (void) const
02033 {
02034 return ACE_WIN32_Asynch_Result::offset_high ();
02035 }
02036
02037 int
02038 ACE_WIN32_Asynch_Accept_Result::priority (void) const
02039 {
02040 return ACE_WIN32_Asynch_Result::priority ();
02041 }
02042
02043 int
02044 ACE_WIN32_Asynch_Accept_Result::signal_number (void) const
02045 {
02046 return ACE_WIN32_Asynch_Result::signal_number ();
02047 }
02048
02049 int
02050 ACE_WIN32_Asynch_Accept_Result::post_completion (ACE_Proactor_Impl *proactor)
02051 {
02052 return ACE_WIN32_Asynch_Result::post_completion (proactor);
02053 }
02054
02055 ACE_WIN32_Asynch_Accept::ACE_WIN32_Asynch_Accept (ACE_WIN32_Proactor *win32_proactor)
02056 : ACE_Asynch_Operation_Impl (),
02057 ACE_Asynch_Accept_Impl (),
02058 ACE_WIN32_Asynch_Operation (win32_proactor)
02059 {
02060 }
02061
02062 int
02063 ACE_WIN32_Asynch_Accept::accept (ACE_Message_Block &message_block,
02064 size_t bytes_to_read,
02065 ACE_HANDLE accept_handle,
02066 const void *act,
02067 int priority,
02068 int signal_number,
02069 int addr_family)
02070 {
02071 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
02072
02073
02074 size_t address_size =
02075 #if defined (ACE_HAS_IPV6)
02076 addr_family == AF_INET ? sizeof (sockaddr_in) : sizeof (sockaddr_in6);
02077 #else
02078 sizeof (sockaddr_in);
02079 #endif
02080 address_size += 16;
02081 size_t available_space = message_block.space ();
02082 size_t space_needed = bytes_to_read + 2 * address_size;
02083 if (available_space < space_needed)
02084 ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Buffer too small\n")), -1);
02085
02086
02087
02088
02089 if (bytes_to_read > MAXDWORD)
02090 {
02091 errno = ERANGE;
02092 return -1;
02093 }
02094 DWORD dword_bytes_to_read = static_cast<DWORD> (bytes_to_read);
02095
02096 int close_accept_handle = 0;
02097
02098 if (accept_handle == ACE_INVALID_HANDLE)
02099 {
02100 accept_handle = ACE_OS::socket (addr_family,
02101 SOCK_STREAM,
02102 0);
02103 if (accept_handle == ACE_INVALID_HANDLE)
02104 {
02105 if (ACE::debug ())
02106 {
02107 ACE_DEBUG ((LM_ERROR,
02108 ACE_TEXT ("%p\n"),
02109 ACE_TEXT ("ACE_OS::socket")));
02110 }
02111 return -1;
02112 }
02113 else
02114
02115 close_accept_handle = 1;
02116 }
02117
02118
02119 ACE_WIN32_Asynch_Accept_Result *result = 0;
02120 ACE_NEW_RETURN (result,
02121 ACE_WIN32_Asynch_Accept_Result (this->handler_proxy_,
02122 this->handle_,
02123 accept_handle,
02124 message_block,
02125 bytes_to_read,
02126 act,
02127 this->win32_proactor_->get_handle (),
02128 priority,
02129 signal_number),
02130 -1);
02131
02132 u_long bytes_read;
02133
02134
02135 int initiate_result = ::AcceptEx ((SOCKET) result->listen_handle (),
02136 (SOCKET) result->accept_handle (),
02137 result->message_block ().wr_ptr (),
02138 dword_bytes_to_read,
02139 static_cast<DWORD> (address_size),
02140 static_cast<DWORD> (address_size),
02141 &bytes_read,
02142 result);
02143 if (initiate_result == 1)
02144
02145 return 1;
02146
02147
02148 ACE_OS::set_errno_to_last_error ();
02149 switch (errno)
02150 {
02151 case ERROR_IO_PENDING:
02152
02153
02154 return 0;
02155
02156 default:
02157
02158
02159
02160 if (close_accept_handle == 1)
02161
02162 ACE_OS::closesocket (accept_handle);
02163
02164
02165 delete result;
02166
02167 if (ACE::debug ())
02168 {
02169 ACE_DEBUG ((LM_ERROR,
02170 ACE_TEXT ("%p\n"),
02171 ACE_TEXT ("AcceptEx")));
02172 }
02173 return -1;
02174 }
02175 #else
02176 ACE_UNUSED_ARG (message_block);
02177 ACE_UNUSED_ARG (bytes_to_read);
02178 ACE_UNUSED_ARG (accept_handle);
02179 ACE_UNUSED_ARG (act);
02180 ACE_UNUSED_ARG (priority);
02181 ACE_UNUSED_ARG (signal_number);
02182 ACE_UNUSED_ARG (addr_family);
02183 ACE_NOTSUP_RETURN (-1);
02184 #endif
02185 }
02186
02187 ACE_WIN32_Asynch_Accept::~ACE_WIN32_Asynch_Accept (void)
02188 {
02189 }
02190
02191
02192
02193
02194
02195 int
02196 ACE_WIN32_Asynch_Accept::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
02197 ACE_HANDLE handle,
02198 const void *completion_key,
02199 ACE_Proactor *proactor)
02200 {
02201 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
02202 handle,
02203 completion_key,
02204 proactor);
02205 }
02206
02207 int
02208 ACE_WIN32_Asynch_Accept::cancel (void)
02209 {
02210 return ACE_WIN32_Asynch_Operation::cancel ();
02211 }
02212
02213 ACE_Proactor *
02214 ACE_WIN32_Asynch_Accept::proactor (void) const
02215 {
02216 return ACE_WIN32_Asynch_Operation::proactor ();
02217 }
02218
02219
02220
02221 ACE_HANDLE
02222 ACE_WIN32_Asynch_Connect_Result::connect_handle (void) const
02223 {
02224 return this->connect_handle_;
02225 }
02226
02227 void ACE_WIN32_Asynch_Connect_Result::connect_handle ( ACE_HANDLE handle )
02228 {
02229 this->connect_handle_ = handle;
02230 }
02231
02232
02233 ACE_WIN32_Asynch_Connect_Result::ACE_WIN32_Asynch_Connect_Result
02234 (const ACE_Handler::Proxy_Ptr &handler_proxy,
02235 ACE_HANDLE connect_handle,
02236 const void* act,
02237 ACE_HANDLE event,
02238 int priority,
02239 int signal_number)
02240 : ACE_Asynch_Result_Impl (),
02241 ACE_Asynch_Connect_Result_Impl (),
02242 ACE_WIN32_Asynch_Result
02243 (handler_proxy, act, event, 0, 0, priority, signal_number),
02244 connect_handle_ (connect_handle)
02245 {
02246 ;
02247 }
02248
02249 void
02250 ACE_WIN32_Asynch_Connect_Result::complete (size_t bytes_transferred,
02251 int success,
02252 const void *completion_key,
02253 u_long error)
02254 {
02255
02256 this->bytes_transferred_ = bytes_transferred;
02257 this->success_ = success;
02258 this->completion_key_ = completion_key;
02259 this->error_ = error;
02260
02261
02262 ACE_Asynch_Connect::Result result (this);
02263
02264
02265 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
02266 if (handler != 0)
02267 handler->handle_connect (result);
02268 }
02269
02270 ACE_WIN32_Asynch_Connect_Result::~ACE_WIN32_Asynch_Connect_Result (void)
02271 {
02272 }
02273
02274
02275
02276
02277 size_t
02278 ACE_WIN32_Asynch_Connect_Result::bytes_transferred (void) const
02279 {
02280 return ACE_WIN32_Asynch_Result::bytes_transferred ();
02281 }
02282
02283 const void *
02284 ACE_WIN32_Asynch_Connect_Result::act (void) const
02285 {
02286 return ACE_WIN32_Asynch_Result::act ();
02287 }
02288
02289 int
02290 ACE_WIN32_Asynch_Connect_Result::success (void) const
02291 {
02292 return ACE_WIN32_Asynch_Result::success ();
02293 }
02294
02295 const void *
02296 ACE_WIN32_Asynch_Connect_Result::completion_key (void) const
02297 {
02298 return ACE_WIN32_Asynch_Result::completion_key ();
02299 }
02300
02301 u_long
02302 ACE_WIN32_Asynch_Connect_Result::error (void) const
02303 {
02304 return ACE_WIN32_Asynch_Result::error ();
02305 }
02306
02307 ACE_HANDLE
02308 ACE_WIN32_Asynch_Connect_Result::event (void) const
02309 {
02310 return ACE_WIN32_Asynch_Result::event ();
02311 }
02312
02313 u_long
02314 ACE_WIN32_Asynch_Connect_Result::offset (void) const
02315 {
02316 return ACE_WIN32_Asynch_Result::offset ();
02317 }
02318
02319 u_long
02320 ACE_WIN32_Asynch_Connect_Result::offset_high (void) const
02321 {
02322 return ACE_WIN32_Asynch_Result::offset_high ();
02323 }
02324
02325 int
02326 ACE_WIN32_Asynch_Connect_Result::priority (void) const
02327 {
02328 return ACE_WIN32_Asynch_Result::priority ();
02329 }
02330
02331 int
02332 ACE_WIN32_Asynch_Connect_Result::signal_number (void) const
02333 {
02334 return ACE_WIN32_Asynch_Result::signal_number ();
02335 }
02336
02337 int
02338 ACE_WIN32_Asynch_Connect_Result::post_completion (ACE_Proactor_Impl *proactor)
02339 {
02340 return ACE_WIN32_Asynch_Result::post_completion (proactor);
02341 }
02342
02343
02344
02345 ACE_WIN32_Asynch_Connect::ACE_WIN32_Asynch_Connect (ACE_WIN32_Proactor * win32_proactor)
02346 : ACE_Asynch_Operation_Impl (),
02347 ACE_Asynch_Connect_Impl (),
02348 ACE_WIN32_Asynch_Operation (win32_proactor),
02349 flg_open_ (false)
02350 {
02351 }
02352
02353 ACE_WIN32_Asynch_Connect::~ACE_WIN32_Asynch_Connect (void)
02354 {
02355 this->close ();
02356 this->reactor (0);
02357 }
02358
02359 ACE_Proactor *
02360 ACE_WIN32_Asynch_Connect::proactor (void) const
02361 {
02362 return ACE_WIN32_Asynch_Operation::proactor ();
02363 }
02364
02365 ACE_HANDLE
02366 ACE_WIN32_Asynch_Connect::get_handle (void) const
02367 {
02368
02369 ACE_ASSERT (0);
02370 return ACE_INVALID_HANDLE;
02371 }
02372
02373 void
02374 ACE_WIN32_Asynch_Connect::set_handle (ACE_HANDLE)
02375 {
02376 ACE_ASSERT (0) ;
02377 }
02378
02379 int
02380 ACE_WIN32_Asynch_Connect::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
02381 ACE_HANDLE,
02382 const void *completion_key,
02383 ACE_Proactor *proactor)
02384 {
02385 ACE_TRACE ("ACE_WIN32_Asynch_Connect::open");
02386
02387
02388
02389 if (this->flg_open_)
02390 ACE_ERROR_RETURN ((LM_ERROR,
02391 ACE_TEXT ("%N:%l:ACE_WIN32_Asynch_Connect::open:")
02392 ACE_TEXT ("connector already open\n")),
02393 -1);
02394
02395
02396 ACE_WIN32_Asynch_Operation::open (handler_proxy,
02397 ACE_INVALID_HANDLE,
02398 completion_key,
02399 proactor);
02400
02401
02402
02403
02404
02405 this->flg_open_ = true;
02406
02407 return 0;
02408 }
02409
02410 int
02411 ACE_WIN32_Asynch_Connect::connect (ACE_HANDLE connect_handle,
02412 const ACE_Addr & remote_sap,
02413 const ACE_Addr & local_sap,
02414 int reuse_addr,
02415 const void *act,
02416 int priority,
02417 int signal_number)
02418 {
02419 ACE_TRACE ("ACE_WIN32_Asynch_Connect::connect");
02420
02421 if (!this->flg_open_)
02422 ACE_ERROR_RETURN ((LM_ERROR,
02423 ACE_TEXT ("%N:%l:ACE_WIN32_Asynch_Connect::connect")
02424 ACE_TEXT ("connector was not opened before\n")),
02425 -1);
02426
02427
02428
02429 ACE_WIN32_Asynch_Connect_Result *result = 0;
02430 ACE_NEW_RETURN (result,
02431 ACE_WIN32_Asynch_Connect_Result (this->handler_proxy_,
02432 connect_handle,
02433 act,
02434 this->win32_proactor_->get_handle (),
02435 priority,
02436 signal_number),
02437 -1);
02438
02439 int rc = connect_i (result,
02440 remote_sap,
02441 local_sap,
02442 reuse_addr);
02443
02444
02445 connect_handle = result->connect_handle ();
02446
02447 if (rc != 0)
02448 return post_result (result, true);
02449
02450
02451 {
02452 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1));
02453
02454 if (this->result_map_.bind (connect_handle, result) == -1)
02455 {
02456 ACE_ERROR ((LM_ERROR,
02457 ACE_TEXT ("ACE_WIN32_Asynch_Connect::connect: %p\n"),
02458 ACE_TEXT ("bind")));
02459 result->set_error (EFAULT);
02460 return post_result (result, true);
02461 }
02462 }
02463
02464 ACE_Asynch_Pseudo_Task & task =
02465 this->win32_proactor_->get_asynch_pseudo_task ();
02466
02467 if (-1 == task.register_io_handler (connect_handle,
02468 this,
02469 ACE_Event_Handler::CONNECT_MASK,
02470 0))
02471 {
02472 result = 0;
02473 {
02474 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1));
02475 this->result_map_.unbind (connect_handle, result);
02476 }
02477 if (result != 0)
02478 {
02479 result->set_error (EFAULT);
02480 this->post_result (result, true);
02481 }
02482 }
02483
02484 return 0;
02485 }
02486
02487 int ACE_WIN32_Asynch_Connect::post_result (ACE_WIN32_Asynch_Connect_Result * result,
02488 bool post_enable)
02489 {
02490 ACE_HANDLE handle = result->connect_handle ();
02491 if (this->flg_open_ && post_enable)
02492 {
02493
02494
02495
02496 if (this->win32_proactor_ ->post_completion (result) == 0)
02497 return 0;
02498
02499 ACE_ERROR ((LM_ERROR,
02500 ACE_TEXT ("Error:(%P | %t):%p\n"),
02501 ACE_TEXT ("ACE_WIN32_Asynch_Connect::post_result: ")
02502 ACE_TEXT (" <post_completion> failed")));
02503 }
02504 else
02505 {
02506
02507 delete result;
02508 }
02509
02510 if (handle != ACE_INVALID_HANDLE)
02511 ACE_OS::closesocket (handle);
02512
02513 return -1;
02514 }
02515
02516
02517
02518
02519
02520
02521
02522 int
02523 ACE_WIN32_Asynch_Connect::connect_i (ACE_WIN32_Asynch_Connect_Result *result,
02524 const ACE_Addr & remote_sap,
02525 const ACE_Addr & local_sap,
02526 int reuse_addr)
02527 {
02528 result->set_bytes_transferred (0);
02529
02530 ACE_HANDLE handle = result->connect_handle ();
02531 if (handle == ACE_INVALID_HANDLE)
02532 {
02533 int protocol_family = remote_sap.get_type ();
02534 handle = ACE_OS::socket (protocol_family,
02535 SOCK_STREAM,
02536 0);
02537
02538
02539 result->connect_handle (handle);
02540 if (handle == ACE_INVALID_HANDLE)
02541 {
02542 result->set_error (errno);
02543 ACE_ERROR_RETURN
02544 ((LM_ERROR,
02545 ACE_TEXT ("ACE_WIN32_Asynch_Connect::connect_i: %p\n"),
02546 ACE_TEXT ("socket")),
02547 -1);
02548 }
02549
02550
02551 int one = 1;
02552 if (protocol_family != PF_UNIX &&
02553 reuse_addr != 0 &&
02554 ACE_OS::setsockopt (handle,
02555 SOL_SOCKET,
02556 SO_REUSEADDR,
02557 (const char*) &one,
02558 sizeof one) == -1)
02559 {
02560 result->set_error (errno);
02561 ACE_ERROR_RETURN
02562 ((LM_ERROR,
02563 ACE_TEXT ("ACE_WIN32_Asynch_Connect::connect_i: %p\n"),
02564 ACE_TEXT ("setsockopt")),
02565 -1);
02566 }
02567 }
02568
02569 if (local_sap != ACE_Addr::sap_any)
02570 {
02571 sockaddr * laddr = reinterpret_cast<sockaddr *> (local_sap.get_addr ());
02572 int size = local_sap.get_size ();
02573 if (ACE_OS::bind (handle, laddr, size) == -1)
02574 {
02575 result->set_error (errno);
02576 ACE_ERROR_RETURN
02577 ((LM_ERROR,
02578 ACE_TEXT ("ACE_WIN32_Asynch_Connect::connect_i: %p\n"),
02579 ACE_TEXT ("bind")),
02580 -1);
02581 }
02582 }
02583
02584
02585 if (ACE::set_flags (handle, ACE_NONBLOCK) != 0)
02586 {
02587 result->set_error (errno);
02588 ACE_ERROR_RETURN
02589 ((LM_ERROR,
02590 ACE_TEXT ("ACE_WIN32_Asynch_Connect::connect_i: %p\n"),
02591 ACE_TEXT ("set_flags")),
02592 -1);
02593 }
02594
02595 for (;;)
02596 {
02597 int rc = ACE_OS::connect
02598 (handle,
02599 reinterpret_cast<sockaddr *> (remote_sap.get_addr ()),
02600 remote_sap.get_size ());
02601
02602 if (rc < 0)
02603 {
02604 if (errno == EWOULDBLOCK || errno == EINPROGRESS)
02605 return 0;
02606
02607 if (errno == EINTR)
02608 continue;
02609
02610 result->set_error (errno);
02611 }
02612 return 1 ;
02613 }
02614 }
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626
02627
02628
02629 int
02630 ACE_WIN32_Asynch_Connect::cancel_uncompleted (bool flg_notify,
02631 ACE_Handle_Set &set)
02632 {
02633 ACE_TRACE ("ACE_WIN32_Asynch_Connect::cancel_uncompleted");
02634
02635 int retval = 0;
02636
02637 MAP_MANAGER::ITERATOR iter (result_map_);
02638 MAP_MANAGER::ENTRY * me = 0;
02639
02640 set.reset ();
02641
02642 for (; iter.next (me) != 0; retval++, iter.advance ())
02643 {
02644 ACE_HANDLE handle = me->ext_id_;
02645 ACE_WIN32_Asynch_Connect_Result* result = me->int_id_ ;
02646
02647 set.set_bit (handle);
02648
02649 result->set_bytes_transferred (0);
02650 result->set_error (ERROR_OPERATION_ABORTED);
02651 this->post_result (result, flg_notify);
02652 }
02653
02654 result_map_.unbind_all ();
02655
02656 return retval;
02657 }
02658
02659 int
02660 ACE_WIN32_Asynch_Connect::cancel (void)
02661 {
02662 ACE_TRACE ("ACE_WIN32_Asynch_Connect::cancel");
02663
02664 int rc = -1 ;
02665
02666 ACE_Handle_Set set;
02667 int num_cancelled = 0;
02668 {
02669 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1));
02670
02671 num_cancelled = cancel_uncompleted (flg_open_, set);
02672 }
02673 if (num_cancelled == 0)
02674 rc = 1;
02675 else if (num_cancelled > 0)
02676 rc = 0;
02677
02678 if (!this->flg_open_)
02679 return rc;
02680
02681 ACE_Asynch_Pseudo_Task & task =
02682 this->win32_proactor_->get_asynch_pseudo_task ();
02683
02684 task.remove_io_handler (set);
02685 return rc;
02686 }
02687
02688 int
02689 ACE_WIN32_Asynch_Connect::close (void)
02690 {
02691 ACE_TRACE ("ACE_WIN32_Asynch_Connect::close");
02692
02693 ACE_Handle_Set set;
02694 int num_cancelled = 0;
02695 {
02696 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1));
02697
02698 num_cancelled = cancel_uncompleted (flg_open_, set);
02699 }
02700 if (num_cancelled == 0 || this->flg_open_ == 0)
02701 {
02702 this->flg_open_ = false;
02703 return 0;
02704 }
02705
02706 ACE_Asynch_Pseudo_Task & task =
02707 this->win32_proactor_->get_asynch_pseudo_task ();
02708
02709 task.remove_io_handler (set);
02710 return 0;
02711 }
02712
02713 int
02714 ACE_WIN32_Asynch_Connect::handle_exception (ACE_HANDLE fd)
02715 {
02716 ACE_TRACE ("ACE_WIN32_Asynch_Connect::handle_exception");
02717 return handle_output (fd);
02718 }
02719
02720 int
02721 ACE_WIN32_Asynch_Connect::handle_input (ACE_HANDLE fd)
02722 {
02723 ACE_TRACE ("ACE_WIN32_Asynch_Connect::handle_input");
02724 return handle_output (fd);
02725 }
02726
02727 int
02728 ACE_WIN32_Asynch_Connect::handle_output (ACE_HANDLE fd)
02729 {
02730 ACE_TRACE ("ACE_WIN32_Asynch_Connect::handle_output");
02731
02732 ACE_WIN32_Asynch_Connect_Result* result = 0;
02733
02734 {
02735 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, 0));
02736 if (this->result_map_.unbind (fd, result) != 0)
02737 return -1;
02738 }
02739
02740 int sockerror = 0 ;
02741 int lsockerror = sizeof sockerror;
02742
02743 ACE_OS::getsockopt (fd,
02744 SOL_SOCKET,
02745 SO_ERROR,
02746 (char*) & sockerror,
02747 & lsockerror);
02748
02749
02750
02751
02752
02753
02754 this->win32_proactor_->get_asynch_pseudo_task().remove_io_handler (fd);
02755
02756 result->set_bytes_transferred (0);
02757 result->set_error (sockerror);
02758 this->post_result (result, this->flg_open_);
02759 return 0;
02760 }
02761
02762
02763 int
02764 ACE_WIN32_Asynch_Connect::handle_close (ACE_HANDLE fd, ACE_Reactor_Mask)
02765 {
02766 ACE_TRACE ("ACE_WIN32_Asynch_Connect::handle_close");
02767
02768 ACE_Asynch_Pseudo_Task & task =
02769 this->win32_proactor_->get_asynch_pseudo_task ();
02770 task.remove_io_handler (fd);
02771
02772 ACE_WIN32_Asynch_Connect_Result* result = 0;
02773
02774 {
02775 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, 0));
02776 if (this->result_map_.unbind (fd, result) != 0)
02777 return -1;
02778 }
02779
02780 result->set_bytes_transferred (0);
02781 result->set_error (ERROR_OPERATION_ABORTED);
02782 this->post_result (result, this->flg_open_);
02783
02784 return 0;
02785 }
02786
02787
02788
02789 ACE_HANDLE
02790 ACE_WIN32_Asynch_Transmit_File_Result::socket (void) const
02791 {
02792 return this->socket_;
02793 }
02794
02795 ACE_HANDLE
02796 ACE_WIN32_Asynch_Transmit_File_Result::file (void) const
02797 {
02798 return this->file_;
02799 }
02800
02801 ACE_Asynch_Transmit_File::Header_And_Trailer *
02802 ACE_WIN32_Asynch_Transmit_File_Result::header_and_trailer (void) const
02803 {
02804 return this->header_and_trailer_;
02805 }
02806
02807 size_t
02808 ACE_WIN32_Asynch_Transmit_File_Result::bytes_to_write (void) const
02809 {
02810 return this->bytes_to_write_;
02811 }
02812
02813 size_t
02814 ACE_WIN32_Asynch_Transmit_File_Result::bytes_per_send (void) const
02815 {
02816 return this->bytes_per_send_;
02817 }
02818
02819 u_long
02820 ACE_WIN32_Asynch_Transmit_File_Result::flags (void) const
02821 {
02822 return this->flags_;
02823 }
02824
02825 ACE_WIN32_Asynch_Transmit_File_Result::ACE_WIN32_Asynch_Transmit_File_Result (
02826 const ACE_Handler::Proxy_Ptr &handler_proxy,
02827 ACE_HANDLE socket,
02828 ACE_HANDLE file,
02829 ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
02830 size_t bytes_to_write,
02831 u_long offset,
02832 u_long offset_high,
02833 size_t bytes_per_send,
02834 u_long flags,
02835 const void *act,
02836 ACE_HANDLE event,
02837 int priority,
02838 int signal_number)
02839 : ACE_Asynch_Result_Impl (),
02840 ACE_Asynch_Transmit_File_Result_Impl (),
02841 ACE_WIN32_Asynch_Result (handler_proxy,
02842 act,
02843 event,
02844 offset,
02845 offset_high,
02846 priority,
02847 signal_number),
02848 socket_ (socket),
02849 file_ (file),
02850 header_and_trailer_ (header_and_trailer),
02851 bytes_to_write_ (bytes_to_write),
02852 bytes_per_send_ (bytes_per_send),
02853 flags_ (flags)
02854 {
02855 }
02856
02857 void
02858 ACE_WIN32_Asynch_Transmit_File_Result::complete (size_t bytes_transferred,
02859 int success,
02860 const void *completion_key,
02861 u_long error)
02862 {
02863
02864 this->bytes_transferred_ = bytes_transferred;
02865 this->success_ = success;
02866 this->completion_key_ = completion_key;
02867 this->error_ = error;
02868
02869
02870
02871
02872
02873
02874
02875
02876
02877
02878
02879
02880
02881
02882
02883
02884
02885
02886 ACE_Asynch_Transmit_File::Result result (this);
02887
02888
02889 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
02890 if (handler != 0)
02891 handler->handle_transmit_file (result);
02892 }
02893
02894 ACE_WIN32_Asynch_Transmit_File_Result::~ACE_WIN32_Asynch_Transmit_File_Result (void)
02895 {
02896 }
02897
02898
02899
02900
02901 size_t
02902 ACE_WIN32_Asynch_Transmit_File_Result::bytes_transferred (void) const
02903 {
02904 return ACE_WIN32_Asynch_Result::bytes_transferred ();
02905 }
02906
02907 const void *
02908 ACE_WIN32_Asynch_Transmit_File_Result::act (void) const
02909 {
02910 return ACE_WIN32_Asynch_Result::act ();
02911 }
02912
02913 int
02914 ACE_WIN32_Asynch_Transmit_File_Result::success (void) const
02915 {
02916 return ACE_WIN32_Asynch_Result::success ();
02917 }
02918
02919 const void *
02920 ACE_WIN32_Asynch_Transmit_File_Result::completion_key (void) const
02921 {
02922 return ACE_WIN32_Asynch_Result::completion_key ();
02923 }
02924
02925 u_long
02926 ACE_WIN32_Asynch_Transmit_File_Result::error (void) const
02927 {
02928 return ACE_WIN32_Asynch_Result::error ();
02929 }
02930
02931 ACE_HANDLE
02932 ACE_WIN32_Asynch_Transmit_File_Result::event (void) const
02933 {
02934 return ACE_WIN32_Asynch_Result::event ();
02935 }
02936
02937 u_long
02938 ACE_WIN32_Asynch_Transmit_File_Result::offset (void) const
02939 {
02940 return ACE_WIN32_Asynch_Result::offset ();
02941 }
02942
02943 u_long
02944 ACE_WIN32_Asynch_Transmit_File_Result::offset_high (void) const
02945 {
02946 return ACE_WIN32_Asynch_Result::offset_high ();
02947 }
02948
02949 int
02950 ACE_WIN32_Asynch_Transmit_File_Result::priority (void) const
02951 {
02952 return ACE_WIN32_Asynch_Result::priority ();
02953 }
02954
02955 int
02956 ACE_WIN32_Asynch_Transmit_File_Result::signal_number (void) const
02957 {
02958 return ACE_WIN32_Asynch_Result::signal_number ();
02959 }
02960
02961 int
02962 ACE_WIN32_Asynch_Transmit_File_Result::post_completion (ACE_Proactor_Impl *proactor)
02963 {
02964 return ACE_WIN32_Asynch_Result::post_completion (proactor);
02965 }
02966
02967 ACE_WIN32_Asynch_Transmit_File::ACE_WIN32_Asynch_Transmit_File (ACE_WIN32_Proactor *win32_proactor)
02968 : ACE_Asynch_Operation_Impl (),
02969 ACE_Asynch_Transmit_File_Impl (),
02970 ACE_WIN32_Asynch_Operation (win32_proactor)
02971 {
02972 }
02973
02974 int
02975 ACE_WIN32_Asynch_Transmit_File::transmit_file (ACE_HANDLE file,
02976 ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
02977 size_t bytes_to_write,
02978 u_long offset,
02979 u_long offset_high,
02980 size_t bytes_per_send,
02981 u_long flags,
02982 const void *act,
02983 int priority,
02984 int signal_number)
02985 {
02986 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
02987
02988
02989 if (bytes_to_write > MAXDWORD || bytes_per_send > MAXDWORD)
02990 {
02991 errno = ERANGE;
02992 return -1;
02993 }
02994 DWORD dword_bytes_to_write = static_cast<DWORD> (bytes_to_write);
02995 DWORD dword_bytes_per_send = static_cast<DWORD> (bytes_per_send);
02996
02997 ACE_WIN32_Asynch_Transmit_File_Result *result = 0;
02998 ACE_NEW_RETURN (result,
02999 ACE_WIN32_Asynch_Transmit_File_Result (this->handler_proxy_,
03000 this->handle_,
03001 file,
03002 header_and_trailer,
03003 bytes_to_write,
03004 offset,
03005 offset_high,
03006 bytes_per_send,
03007 flags,
03008 act,
03009 this->win32_proactor_->get_handle (),
03010 priority,
03011 signal_number),
03012 -1);
03013
03014 ACE_LPTRANSMIT_FILE_BUFFERS transmit_buffers = 0;
03015 if (result->header_and_trailer () != 0)
03016 transmit_buffers = result->header_and_trailer ()->transmit_buffers ();
03017
03018
03019 int initiate_result = ::TransmitFile ((SOCKET) result->socket (),
03020 result->file (),
03021 dword_bytes_to_write,
03022 dword_bytes_per_send,
03023 result,
03024 transmit_buffers,
03025 result->flags ());
03026 if (initiate_result == 1)
03027
03028 return 1;
03029
03030
03031 ACE_OS::set_errno_to_last_error ();
03032 switch (errno)
03033 {
03034 case ERROR_IO_PENDING:
03035
03036
03037 return 0;
03038
03039 default:
03040
03041
03042
03043
03044 delete result;
03045
03046 if (ACE::debug ())
03047 {
03048 ACE_DEBUG ((LM_ERROR,
03049 ACE_TEXT ("%p\n"),
03050 ACE_TEXT ("TransmitFile")));
03051 }
03052 return -1;
03053 }
03054 #else
03055 ACE_UNUSED_ARG (file);
03056 ACE_UNUSED_ARG (header_and_trailer);
03057 ACE_UNUSED_ARG (bytes_to_write);
03058 ACE_UNUSED_ARG (offset);
03059 ACE_UNUSED_ARG (offset_high);
03060 ACE_UNUSED_ARG (bytes_per_send);
03061 ACE_UNUSED_ARG (flags);
03062 ACE_UNUSED_ARG (act);
03063 ACE_UNUSED_ARG (priority);
03064 ACE_UNUSED_ARG (signal_number);
03065 ACE_NOTSUP_RETURN (-1);
03066 #endif
03067 }
03068
03069 ACE_WIN32_Asynch_Transmit_File::~ACE_WIN32_Asynch_Transmit_File (void)
03070 {
03071 }
03072
03073
03074
03075
03076
03077 int
03078 ACE_WIN32_Asynch_Transmit_File::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
03079 ACE_HANDLE handle,
03080 const void *completion_key,
03081 ACE_Proactor *proactor)
03082 {
03083 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
03084 handle,
03085 completion_key,
03086 proactor);
03087 }
03088
03089 int
03090 ACE_WIN32_Asynch_Transmit_File::cancel (void)
03091 {
03092 return ACE_WIN32_Asynch_Operation::cancel ();
03093 }
03094
03095 ACE_Proactor *
03096 ACE_WIN32_Asynch_Transmit_File::proactor (void) const
03097 {
03098 return ACE_WIN32_Asynch_Operation::proactor ();
03099 }
03100
03101 size_t
03102 ACE_WIN32_Asynch_Read_Dgram_Result::bytes_to_read (void) const
03103 {
03104 return this->bytes_to_read_;
03105 }
03106
03107 ACE_Message_Block*
03108 ACE_WIN32_Asynch_Read_Dgram_Result::message_block (void) const
03109 {
03110 return this->message_block_;
03111 }
03112
03113
03114 int
03115 ACE_WIN32_Asynch_Read_Dgram_Result::remote_address (ACE_Addr& addr) const
03116 {
03117 int retVal = -1;
03118
03119
03120 if (addr.get_type () == this->remote_address_->get_type ())
03121 {
03122 addr.set_addr (this->remote_address_->get_addr (),
03123 this->remote_address_->get_size ());
03124 retVal = 0;
03125 }
03126
03127 return retVal;
03128 }
03129
03130 sockaddr *
03131 ACE_WIN32_Asynch_Read_Dgram_Result::saddr () const
03132 {
03133 return (sockaddr *) this->remote_address_->get_addr ();
03134 }
03135
03136
03137 int
03138 ACE_WIN32_Asynch_Read_Dgram_Result::flags (void) const
03139 {
03140 return this->flags_;
03141 }
03142
03143 ACE_HANDLE
03144 ACE_WIN32_Asynch_Read_Dgram_Result::handle (void) const
03145 {
03146 return this->handle_;
03147 }
03148
03149 size_t
03150 ACE_WIN32_Asynch_Read_Dgram_Result::bytes_transferred (void) const
03151 {
03152 return ACE_WIN32_Asynch_Result::bytes_transferred ();
03153 }
03154
03155 const void *
03156 ACE_WIN32_Asynch_Read_Dgram_Result::act (void) const
03157 {
03158 return ACE_WIN32_Asynch_Result::act ();
03159 }
03160
03161 int
03162 ACE_WIN32_Asynch_Read_Dgram_Result::success (void) const
03163 {
03164 return ACE_WIN32_Asynch_Result::success ();
03165 }
03166
03167 const void *
03168 ACE_WIN32_Asynch_Read_Dgram_Result::completion_key (void) const
03169 {
03170 return ACE_WIN32_Asynch_Result::completion_key ();
03171 }
03172
03173 u_long
03174 ACE_WIN32_Asynch_Read_Dgram_Result::error (void) const
03175 {
03176 return ACE_WIN32_Asynch_Result::error ();
03177 }
03178
03179 ACE_HANDLE
03180 ACE_WIN32_Asynch_Read_Dgram_Result::event (void) const
03181 {
03182 return ACE_WIN32_Asynch_Result::event ();
03183 }
03184
03185 u_long
03186 ACE_WIN32_Asynch_Read_Dgram_Result::offset (void) const
03187 {
03188 return ACE_WIN32_Asynch_Result::offset ();
03189 }
03190
03191 u_long
03192 ACE_WIN32_Asynch_Read_Dgram_Result::offset_high (void) const
03193 {
03194 return ACE_WIN32_Asynch_Result::offset_high ();
03195 }
03196
03197 int
03198 ACE_WIN32_Asynch_Read_Dgram_Result::priority (void) const
03199 {
03200 return ACE_WIN32_Asynch_Result::priority ();
03201 }
03202
03203 int
03204 ACE_WIN32_Asynch_Read_Dgram_Result::signal_number (void) const
03205 {
03206 return ACE_WIN32_Asynch_Result::signal_number ();
03207 }
03208
03209 int
03210 ACE_WIN32_Asynch_Read_Dgram_Result::post_completion (ACE_Proactor_Impl *proactor)
03211 {
03212 return ACE_WIN32_Asynch_Result::post_completion (proactor);
03213 }
03214
03215 ACE_WIN32_Asynch_Read_Dgram_Result::ACE_WIN32_Asynch_Read_Dgram_Result (
03216 const ACE_Handler::Proxy_Ptr &handler_proxy,
03217 ACE_HANDLE handle,
03218 ACE_Message_Block *message_block,
03219 size_t bytes_to_read,
03220 int flags,
03221 int protocol_family,
03222 const void* act,
03223 ACE_HANDLE event,
03224 int priority,
03225 int signal_number)
03226 : ACE_Asynch_Result_Impl (),
03227 ACE_Asynch_Read_Dgram_Result_Impl(),
03228 ACE_WIN32_Asynch_Result (handler_proxy, act, event, 0, 0, priority, signal_number),
03229 bytes_to_read_ (bytes_to_read),
03230 message_block_ (message_block),
03231 remote_address_ (0),
03232 addr_len_ (0),
03233 flags_ (flags),
03234 handle_ (handle)
03235 {
03236 ACE_ASSERT (protocol_family == PF_INET);
03237
03238 ACE_NEW (remote_address_, ACE_INET_Addr);
03239 addr_len_ = remote_address_->get_size ();
03240
03241 ACE_UNUSED_ARG (protocol_family);
03242 }
03243
03244 void
03245 ACE_WIN32_Asynch_Read_Dgram_Result::complete (size_t bytes_transferred,
03246 int success,
03247 const void *completion_key,
03248 u_long error)
03249 {
03250
03251 this->bytes_transferred_ = bytes_transferred;
03252 this->success_ = success;
03253 this->completion_key_ = completion_key;
03254 this->error_ = error;
03255
03256
03257 for (ACE_Message_Block* mb = this->message_block_;
03258 (mb != 0) && (bytes_transferred > 0);
03259 mb = mb->cont ())
03260 {
03261 size_t len_part = mb->space ();
03262
03263 if ( len_part > bytes_transferred)
03264 len_part = bytes_transferred;
03265
03266 mb->wr_ptr (len_part);
03267
03268 bytes_transferred -= len_part;
03269 }
03270
03271
03272 this->remote_address_->set_size (this->addr_len_);
03273
03274
03275 ACE_Asynch_Read_Dgram::Result result (this);
03276
03277
03278 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
03279 if (handler != 0)
03280 handler->handle_read_dgram (result);
03281 }
03282
03283 ACE_WIN32_Asynch_Read_Dgram_Result::~ACE_WIN32_Asynch_Read_Dgram_Result (void)
03284 {
03285 delete this->remote_address_;
03286 }
03287
03288
03289
03290 ACE_WIN32_Asynch_Read_Dgram::~ACE_WIN32_Asynch_Read_Dgram (void)
03291 {
03292 }
03293
03294 ssize_t
03295 ACE_WIN32_Asynch_Read_Dgram::recv (ACE_Message_Block *message_block,
03296 size_t & number_of_bytes_recvd,
03297 int flags,
03298 int protocol_family,
03299 const void *act,
03300 int priority,
03301 int signal_number)
03302 {
03303 number_of_bytes_recvd = 0;
03304
03305 size_t bytes_to_read = 0;
03306
03307 iovec iov[ACE_IOV_MAX];
03308 int iovcnt = 0;
03309
03310 for (const ACE_Message_Block* msg = message_block;
03311 msg != 0 && iovcnt < ACE_IOV_MAX;
03312 msg = msg->cont () , ++iovcnt )
03313 {
03314 size_t msg_space = msg->space ();
03315
03316
03317
03318
03319
03320
03321
03322
03323 bytes_to_read += msg_space;
03324
03325
03326 size_t wr_ptr_offset = 0;
03327
03328 while (msg_space > 0 && iovcnt < ACE_IOV_MAX)
03329 {
03330 u_long this_chunk_length;
03331 if (msg_space > ULONG_MAX)
03332 this_chunk_length = ULONG_MAX;
03333 else
03334 this_chunk_length = static_cast<u_long> (msg_space);
03335
03336 iov[iovcnt].iov_base = msg->wr_ptr () + wr_ptr_offset;
03337 iov[iovcnt].iov_len = this_chunk_length;
03338 msg_space -= this_chunk_length;
03339 wr_ptr_offset += this_chunk_length;
03340
03341
03342 if (msg_space > 0)
03343 iovcnt++;
03344 }
03345 if (msg_space > 0)
03346 {
03347 errno = ERANGE;
03348 return -1;
03349 }
03350 }
03351
03352 if (bytes_to_read == 0)
03353 ACE_ERROR_RETURN ((LM_ERROR,
03354 ACE_TEXT ("ACE_WIN32_Asynch_Read_Dgram::recv:")
03355 ACE_TEXT ("Attempt to read 0 bytes\n")),
03356 -1);
03357
03358
03359 ACE_WIN32_Asynch_Read_Dgram_Result *result = 0;
03360 ACE_NEW_RETURN (result,
03361 ACE_WIN32_Asynch_Read_Dgram_Result (this->handler_proxy_,
03362 this->handle_,
03363 message_block,
03364 bytes_to_read,
03365 flags,
03366 protocol_family,
03367 act,
03368 this->win32_proactor_->get_handle (),
03369 priority,
03370 signal_number),
03371 -1);
03372
03373
03374 ssize_t initiate_result = ACE_OS::recvfrom (result->handle (),
03375 iov,
03376 iovcnt,
03377 number_of_bytes_recvd,
03378 result->flags_,
03379 result->saddr (),
03380 &(result->addr_len_),
03381 result,
03382 0);
03383 if (initiate_result == SOCKET_ERROR)
03384 {
03385
03386 ACE_OS::set_errno_to_last_error ();
03387 switch (errno)
03388 {
03389 case ERROR_IO_PENDING:
03390
03391
03392 initiate_result = 0;
03393 break;
03394
03395 default:
03396
03397
03398
03399 if (ACE::debug ())
03400 {
03401 ACE_DEBUG ((LM_ERROR,
03402 ACE_TEXT ("%p\n"),
03403 ACE_TEXT ("WSARecvFrom")));
03404 }
03405
03406 delete result;
03407 initiate_result = -1;
03408 break;
03409 }
03410
03411 }
03412 else
03413 {
03414
03415
03416
03417
03418
03419
03420 initiate_result = 1;
03421 }
03422
03423 return initiate_result;
03424 }
03425
03426 int
03427 ACE_WIN32_Asynch_Read_Dgram::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
03428 ACE_HANDLE handle,
03429 const void *completion_key,
03430 ACE_Proactor *proactor)
03431 {
03432 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
03433 handle,
03434 completion_key,
03435 proactor);
03436 }
03437
03438 int
03439 ACE_WIN32_Asynch_Read_Dgram::cancel (void)
03440 {
03441 return ACE_WIN32_Asynch_Operation::cancel ();
03442 }
03443
03444 ACE_Proactor *
03445 ACE_WIN32_Asynch_Read_Dgram::proactor (void) const
03446 {
03447 return ACE_WIN32_Asynch_Operation::proactor ();
03448 }
03449
03450 ACE_WIN32_Asynch_Read_Dgram::ACE_WIN32_Asynch_Read_Dgram (ACE_WIN32_Proactor *win32_proactor)
03451 : ACE_Asynch_Operation_Impl (),
03452 ACE_Asynch_Read_Dgram_Impl (),
03453 ACE_WIN32_Asynch_Operation (win32_proactor)
03454 {
03455 }
03456
03457
03458
03459 size_t
03460 ACE_WIN32_Asynch_Write_Dgram_Result::bytes_to_write (void) const
03461 {
03462 return this->bytes_to_write_;
03463 }
03464
03465 ACE_Message_Block*
03466 ACE_WIN32_Asynch_Write_Dgram_Result::message_block () const
03467 {
03468 return this->message_block_;
03469 }
03470
03471 int
03472 ACE_WIN32_Asynch_Write_Dgram_Result::flags (void) const
03473 {
03474 return this->flags_;
03475 }
03476
03477 ACE_HANDLE
03478 ACE_WIN32_Asynch_Write_Dgram_Result::handle (void) const
03479 {
03480 return this->handle_;
03481 }
03482
03483 size_t
03484 ACE_WIN32_Asynch_Write_Dgram_Result::bytes_transferred (void) const
03485 {
03486 return ACE_WIN32_Asynch_Result::bytes_transferred ();
03487 }
03488
03489 const void *
03490 ACE_WIN32_Asynch_Write_Dgram_Result::act (void) const
03491 {
03492 return ACE_WIN32_Asynch_Result::act ();
03493 }
03494
03495 int
03496 ACE_WIN32_Asynch_Write_Dgram_Result::success (void) const
03497 {
03498 return ACE_WIN32_Asynch_Result::success ();
03499 }
03500
03501 const void *
03502 ACE_WIN32_Asynch_Write_Dgram_Result::completion_key (void) const
03503 {
03504 return ACE_WIN32_Asynch_Result::completion_key ();
03505 }
03506
03507 u_long
03508 ACE_WIN32_Asynch_Write_Dgram_Result::error (void) const
03509 {
03510 return ACE_WIN32_Asynch_Result::error ();
03511 }
03512
03513 ACE_HANDLE
03514 ACE_WIN32_Asynch_Write_Dgram_Result::event (void) const
03515 {
03516 return ACE_WIN32_Asynch_Result::event ();
03517 }
03518
03519 u_long
03520 ACE_WIN32_Asynch_Write_Dgram_Result::offset (void) const
03521 {
03522 return ACE_WIN32_Asynch_Result::offset ();
03523 }
03524
03525 u_long
03526 ACE_WIN32_Asynch_Write_Dgram_Result::offset_high (void) const
03527 {
03528 return ACE_WIN32_Asynch_Result::offset_high ();
03529 }
03530
03531 int
03532 ACE_WIN32_Asynch_Write_Dgram_Result::priority (void) const
03533 {
03534 return ACE_WIN32_Asynch_Result::priority ();
03535 }
03536
03537 int
03538 ACE_WIN32_Asynch_Write_Dgram_Result::signal_number (void) const
03539 {
03540 return ACE_WIN32_Asynch_Result::signal_number ();
03541 }
03542
03543 int
03544 ACE_WIN32_Asynch_Write_Dgram_Result::post_completion (ACE_Proactor_Impl *proactor)
03545 {
03546 return ACE_WIN32_Asynch_Result::post_completion (proactor);
03547 }
03548
03549 ACE_WIN32_Asynch_Write_Dgram_Result::ACE_WIN32_Asynch_Write_Dgram_Result (
03550 const ACE_Handler::Proxy_Ptr &handler_proxy,
03551 ACE_HANDLE handle,
03552 ACE_Message_Block *message_block,
03553 size_t bytes_to_write,
03554 int flags,
03555 const void* act,
03556 ACE_HANDLE event,
03557 int priority,
03558 int signal_number)
03559 : ACE_Asynch_Result_Impl (),
03560 ACE_Asynch_Write_Dgram_Result_Impl(),
03561 ACE_WIN32_Asynch_Result (handler_proxy,
03562 act,
03563 event,
03564 0,
03565 0,
03566 priority,
03567 signal_number),
03568 bytes_to_write_ (bytes_to_write),
03569 message_block_ (message_block),
03570 flags_ (flags),
03571 handle_ (handle)
03572 {
03573 }
03574
03575 void
03576 ACE_WIN32_Asynch_Write_Dgram_Result::complete (size_t bytes_transferred,
03577 int success,
03578 const void *completion_key,
03579 u_long error)
03580 {
03581
03582 this->bytes_transferred_ = bytes_transferred;
03583 this->success_ = success;
03584 this->completion_key_ = completion_key;
03585 this->error_ = error;
03586
03587
03588 for (ACE_Message_Block* mb = this->message_block_;
03589 (mb != 0) && (bytes_transferred > 0);
03590 mb = mb->cont ())
03591 {
03592 size_t len_part = mb->length ();
03593
03594 if ( len_part > bytes_transferred)
03595 len_part = bytes_transferred;
03596
03597 mb->rd_ptr (len_part);
03598
03599 bytes_transferred -= len_part;
03600 }
03601
03602
03603 ACE_Asynch_Write_Dgram::Result result (this);
03604
03605
03606 ACE_Handler *handler = this->handler_proxy_.get ()->handler ();
03607 if (handler != 0)
03608 handler->handle_write_dgram (result);
03609 }
03610
03611 ACE_WIN32_Asynch_Write_Dgram_Result::~ACE_WIN32_Asynch_Write_Dgram_Result (void)
03612 {
03613 }
03614
03615
03616
03617
03618 ACE_WIN32_Asynch_Write_Dgram::~ACE_WIN32_Asynch_Write_Dgram (void)
03619 {
03620 }
03621
03622 ssize_t
03623 ACE_WIN32_Asynch_Write_Dgram::send (ACE_Message_Block *message_block,
03624 size_t &number_of_bytes_sent,
03625 int flags,
03626 const ACE_Addr &addr,
03627 const void *act,
03628 int priority,
03629 int signal_number)
03630 {
03631 number_of_bytes_sent = 0;
03632
03633 size_t bytes_to_write = 0;
03634
03635 iovec iov[ACE_IOV_MAX];
03636 int iovcnt = 0;
03637
03638 for (const ACE_Message_Block* msg = message_block;
03639 msg != 0 && iovcnt < ACE_IOV_MAX;
03640 msg = msg->cont () , ++iovcnt )
03641 {
03642 size_t msg_len = msg->length ();
03643
03644 bytes_to_write += msg_len;
03645
03646
03647 size_t rd_ptr_offset = 0;
03648
03649 do
03650 {
03651 if (msg_len >= 0 && iovcnt < ACE_IOV_MAX)
03652 {
03653 u_long this_chunk_length;
03654 if (msg_len > ULONG_MAX)
03655 this_chunk_length = ULONG_MAX;
03656 else
03657 this_chunk_length = static_cast<u_long> (msg_len);
03658
03659
03660 iov[iovcnt].iov_base = msg->rd_ptr () + rd_ptr_offset;
03661 iov[iovcnt].iov_len = this_chunk_length;
03662 msg_len -= this_chunk_length;
03663 rd_ptr_offset += this_chunk_length;
03664
03665
03666 if (msg_len > 0)
03667 iovcnt++;
03668 }
03669 }
03670 while (msg_len > 0 && iovcnt < ACE_IOV_MAX);
03671
03672 if (msg_len > 0)
03673 {
03674 errno = ERANGE;
03675 return -1;
03676 }
03677 }
03678
03679
03680 ACE_WIN32_Asynch_Write_Dgram_Result *result = 0;
03681 ACE_NEW_RETURN (result,
03682 ACE_WIN32_Asynch_Write_Dgram_Result (this->handler_proxy_,
03683 this->handle_,
03684 message_block,
03685 bytes_to_write,
03686 flags,
03687 act,
03688 this->win32_proactor_->get_handle (),
03689 priority,
03690 signal_number),
03691 -1);
03692
03693
03694
03695 ssize_t initiate_result = ACE_OS::sendto (result->handle (),
03696 iov,
03697 iovcnt,
03698 number_of_bytes_sent,
03699 result->flags_,
03700 (sockaddr *) addr.get_addr (),
03701 addr.get_size(),
03702 result,
03703 0);
03704
03705
03706 if (initiate_result == SOCKET_ERROR)
03707 {
03708
03709 ACE_OS::set_errno_to_last_error ();
03710 switch (errno)
03711 {
03712 case ERROR_IO_PENDING:
03713
03714
03715 initiate_result = 0;
03716 break;
03717
03718 default:
03719
03720
03721
03722 if (ACE::debug ())
03723 {
03724 ACE_DEBUG ((LM_ERROR,
03725 ACE_TEXT ("%p\n"),
03726 ACE_TEXT ("WSASendTo")));
03727 }
03728
03729 delete result;
03730 initiate_result = -1;
03731 break;
03732 }
03733
03734 }
03735 else
03736 {
03737
03738
03739
03740
03741
03742
03743 initiate_result = 1;
03744 }
03745
03746 return initiate_result;
03747 }
03748
03749 int
03750 ACE_WIN32_Asynch_Write_Dgram::open (const ACE_Handler::Proxy_Ptr &handler_proxy,
03751 ACE_HANDLE handle,
03752 const void *completion_key,
03753 ACE_Proactor *proactor)
03754 {
03755 return ACE_WIN32_Asynch_Operation::open (handler_proxy,
03756 handle,
03757 completion_key,
03758 proactor);
03759 }
03760
03761 int
03762 ACE_WIN32_Asynch_Write_Dgram::cancel (void)
03763 {
03764 return ACE_WIN32_Asynch_Operation::cancel ();
03765 }
03766
03767 ACE_Proactor *
03768 ACE_WIN32_Asynch_Write_Dgram::proactor (void) const
03769 {
03770 return ACE_WIN32_Asynch_Operation::proactor ();
03771 }
03772
03773 ACE_WIN32_Asynch_Write_Dgram::ACE_WIN32_Asynch_Write_Dgram (ACE_WIN32_Proactor *win32_proactor)
03774 : ACE_Asynch_Operation_Impl (),
03775 ACE_Asynch_Write_Dgram_Impl (),
03776 ACE_WIN32_Asynch_Operation (win32_proactor)
03777 {
03778 }
03779
03780 ACE_END_VERSIONED_NAMESPACE_DECL
03781
03782 #endif