00001 #include "SSL_Asynch_Stream.h"
00002
00003 ACE_RCSID (ACE_SSL,
00004 SSL_Asynch_Stream,
00005 "$Id: SSL_Asynch_Stream.cpp 84181 2009-01-16 22:37:49Z shuston $")
00006
00007
00008 #if OPENSSL_VERSION_NUMBER > 0x0090581fL && ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
00009
00010 #if defined (ACE_WIN32)
00011 # include "ace/WIN32_Proactor.h"
00012 #else
00013 # include "ace/POSIX_Proactor.h"
00014 #endif
00015
00016 #include "ace/OS_NS_string.h"
00017 #include "ace/Proactor.h"
00018 #include "ace/Truncate.h"
00019
00020 #if !defined(__ACE_INLINE__)
00021 #include "SSL_Asynch_Stream.inl"
00022 #endif
00023
00024 #include <openssl/err.h>
00025
00026 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00027
00028 ACE_SSL_Asynch_Write_Stream_Result::ACE_SSL_Asynch_Write_Stream_Result
00029 (ACE_Handler & handler,
00030 ACE_HANDLE handle,
00031 ACE_Message_Block & message_block,
00032 size_t bytes_to_write,
00033 const void * act,
00034 ACE_HANDLE event,
00035 int priority,
00036 int signal_number
00037 )
00038 : AWS_RESULT (handler.proxy (),
00039 handle,
00040 message_block,
00041 bytes_to_write,
00042 act,
00043 event,
00044 priority,
00045 signal_number
00046 )
00047 {
00048 }
00049
00050 ACE_SSL_Asynch_Read_Stream_Result::ACE_SSL_Asynch_Read_Stream_Result
00051 (ACE_Handler & handler,
00052 ACE_HANDLE handle,
00053 ACE_Message_Block & message_block,
00054 size_t bytes_to_read,
00055 const void * act,
00056 ACE_HANDLE event,
00057 int priority,
00058 int signal_number
00059 )
00060 : ARS_RESULT (handler.proxy (),
00061 handle,
00062 message_block,
00063 bytes_to_read,
00064 act,
00065 event,
00066 priority,
00067 signal_number
00068 )
00069 {
00070 }
00071
00072 ACE_SSL_Asynch_Result::ACE_SSL_Asynch_Result (ACE_Handler & handler)
00073 : A_RESULT (handler.proxy (),
00074 0,
00075 ACE_INVALID_HANDLE,
00076 0,
00077 0,
00078 0,
00079 ACE_SIGRTMIN
00080 )
00081 {
00082 }
00083
00084 void
00085 ACE_SSL_Asynch_Result::complete (size_t ,
00086 int ,
00087 const void * ,
00088 u_long )
00089 {
00090 this->handler_proxy_->handler ()->handle_wakeup ();
00091 }
00092
00093
00094
00095
00096 ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream (
00097 ACE_SSL_Asynch_Stream::Stream_Type s_type,
00098 ACE_SSL_Context * context)
00099 : type_ (s_type),
00100 proactor_ (0),
00101 ext_handler_ (0),
00102 ext_read_result_ (0),
00103 ext_write_result_(0),
00104 flags_ (0),
00105 ssl_ (0),
00106 handshake_complete_(false),
00107 bio_ (0),
00108 bio_istream_ (),
00109 bio_inp_msg_ (),
00110 bio_inp_errno_(0),
00111 bio_inp_flag_ (0),
00112 bio_ostream_ (),
00113 bio_out_msg_ (),
00114 bio_out_errno_(0),
00115 bio_out_flag_ (0),
00116 mutex_ ()
00117 {
00118 ACE_TRACE ("ACE_SSL_Asynch_Stream::ACE_SSL_Asynch_Stream");
00119
00120
00121 ACE_SSL_Context * ctx =
00122 (context == 0 ? ACE_SSL_Context::instance () : context);
00123
00124 this->ssl_ = ::SSL_new (ctx->context ());
00125
00126 if (this->ssl_ == 0)
00127 ACE_ERROR
00128 ((LM_ERROR,
00129 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00130 ACE_TEXT ("- cannot allocate new SSL structure")
00131 ));
00132
00133 }
00134
00135 ACE_SSL_Asynch_Stream::~ACE_SSL_Asynch_Stream (void)
00136 {
00137 ACE_TRACE ("ACE_SSL_Asynch_Stream::~ACE_SSL_Asynch_Stream");
00138
00139
00140
00141
00142
00143 if (this->flags_ & SF_STREAM_OPEN)
00144 if ((this->flags_ & SF_DELETE_ENABLE) == 0)
00145 ACE_DEBUG ((LM_DEBUG,
00146 ACE_TEXT("ACE_SSL_Asynch_Stream::DTOR-")
00147 ACE_TEXT("possible access violation ")
00148 ACE_TEXT("if proactor still handles events\n")));
00149
00150 ::SSL_free (this->ssl_);
00151
00152
00153
00154
00155
00156
00157
00158 }
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169 int
00170 ACE_SSL_Asynch_Stream::close (void)
00171 {
00172 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1));
00173
00174 if ((flags_ & SF_STREAM_OPEN) == 0)
00175 flags_ |= SF_DELETE_ENABLE;
00176
00177 if (flags_ & SF_DELETE_ENABLE)
00178 return 0;
00179
00180 flags_ |= SF_REQ_SHUTDOWN;
00181
00182 this->do_SSL_state_machine ();
00183
00184 return -1;
00185 }
00186
00187
00188
00189
00190
00191 int
00192 ACE_SSL_Asynch_Stream::cancel (void)
00193 {
00194 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1));
00195
00196 if ((flags_ & SF_STREAM_OPEN) == 0)
00197 {
00198 return 1;
00199 }
00200
00201
00202 int rc_r_int = bio_istream_.cancel();
00203 int rc_w_int = bio_ostream_.cancel();
00204
00205
00206 int rc_r_ext = notify_read (0, ERR_CANCELED);
00207 int rc_w_ext = notify_write (0, ERR_CANCELED);
00208
00209 if ((rc_r_int < 0 || rc_w_int < 0)
00210 && (rc_r_ext < 0 || rc_w_ext < 0))
00211 {
00212 return -1;
00213 }
00214
00215 if (rc_r_int == 1 && rc_w_int == 1
00216 && rc_r_ext == 1 && rc_w_ext == 1)
00217 {
00218 return 1;
00219 }
00220
00221 if ((rc_r_int == 2 || rc_w_int == 2)
00222 && (rc_r_ext == 2 || rc_w_ext == 2))
00223 {
00224 return 2;
00225 }
00226
00227 return 0;
00228 }
00229
00230
00231
00232
00233
00234 int
00235 ACE_SSL_Asynch_Stream::open (ACE_Handler & handler,
00236 ACE_HANDLE handle,
00237 const void * completion_key,
00238 ACE_Proactor * proactor)
00239 {
00240 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1));
00241
00242 if (this->flags_ & SF_STREAM_OPEN)
00243 ACE_ERROR_RETURN
00244 ((LM_ERROR,
00245 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"),
00246 ACE_TEXT ("- already opened")),
00247 -1);
00248
00249 if (this->ssl_ == 0)
00250 ACE_ERROR_RETURN
00251 ((LM_ERROR,
00252 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"),
00253 ACE_TEXT ("- SSL structure is absent")),
00254 -1);
00255
00256 if (handle == ACE_INVALID_HANDLE)
00257 ACE_ERROR_RETURN
00258 ((LM_ERROR,
00259 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"),
00260 ACE_TEXT ("- invalid handle")),
00261 -1);
00262
00263
00264
00265 this->proactor_ = this->get_proactor (proactor, handler);
00266 this->ext_handler_ = & handler;
00267 this->handle (handle);
00268
00269
00270 if (this->bio_istream_.open (*this,
00271 handle,
00272 completion_key,
00273 this->proactor_) != 0)
00274 return -1;
00275
00276
00277 if (this->bio_ostream_.open (*this,
00278 handle,
00279 completion_key,
00280 this->proactor_) != 0)
00281 return -1;
00282
00283 this->bio_ = ACE_SSL_make_BIO (this);
00284
00285 if (this->bio_ == 0)
00286 ACE_ERROR_RETURN
00287 ((LM_ERROR,
00288 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"),
00289 ACE_TEXT ("- cannot allocate new BIO structure")),
00290 -1);
00291
00292 ::SSL_set_bio (this->ssl_ , this->bio_ , this->bio_);
00293
00294 switch (this->type_)
00295 {
00296 case ST_CLIENT:
00297 ::SSL_set_connect_state (this->ssl_);
00298 break;
00299
00300 case ST_SERVER:
00301 ::SSL_set_accept_state (this->ssl_);
00302 break;
00303
00304 default:
00305 ACE_ERROR_RETURN
00306 ((LM_ERROR,
00307 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream::open() %p\n"),
00308 ACE_TEXT ("- invalid stream type")),
00309 -1);
00310 }
00311
00312 this->flags_ |= SF_STREAM_OPEN;
00313
00314 this->do_SSL_state_machine ();
00315
00316 return 0;
00317 }
00318
00319
00320
00321
00322
00323
00324 int
00325 ACE_SSL_Asynch_Stream::read (ACE_Message_Block & message_block,
00326 size_t bytes_to_read,
00327 const void * act,
00328 int priority,
00329 int signal_number)
00330 {
00331 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1));
00332
00333 if ((this->flags_ & SF_STREAM_OPEN) == 0)
00334 return -1;
00335
00336 if (this->flags_ & SF_REQ_SHUTDOWN)
00337 return -1;
00338
00339
00340
00341
00342 if (this->ext_read_result_ != 0)
00343 return -1;
00344
00345
00346 ACE_NEW_RETURN (this->ext_read_result_,
00347 ACE_SSL_Asynch_Read_Stream_Result (
00348 *this->ext_handler_,
00349 this->handle (),
00350 message_block,
00351 bytes_to_read,
00352 act,
00353 this->proactor_->get_handle(),
00354 priority,
00355 signal_number),
00356 -1);
00357
00358 this->do_SSL_state_machine ();
00359
00360 return 0;
00361 }
00362
00363
00364
00365
00366
00367 int
00368 ACE_SSL_Asynch_Stream::write (ACE_Message_Block & message_block,
00369 size_t bytes_to_write,
00370 const void * act,
00371 int priority,
00372 int signal_number)
00373 {
00374 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1));
00375
00376 if ((this->flags_ & SF_STREAM_OPEN) == 0)
00377 return -1;
00378
00379 if (this->flags_ & SF_REQ_SHUTDOWN)
00380 return -1;
00381
00382
00383
00384
00385 if (this->ext_write_result_ != 0)
00386 return -1;
00387
00388
00389 ACE_NEW_RETURN (this->ext_write_result_,
00390 ACE_SSL_Asynch_Write_Stream_Result (
00391 *this->ext_handler_,
00392 this->handle (),
00393 message_block,
00394 bytes_to_write,
00395 act,
00396 this->proactor_->get_handle(),
00397 priority,
00398 signal_number),
00399 -1);
00400
00401 this->do_SSL_state_machine ();
00402
00403 return 0;
00404 }
00405
00406
00407
00408
00409 int
00410 ACE_SSL_Asynch_Stream::do_SSL_state_machine (void)
00411 {
00412
00413
00414
00415 int retval = this->do_SSL_handshake ();
00416
00417 if (retval == 0)
00418 return 0;
00419
00420 if (retval < 0)
00421 this->flags_ |= SF_REQ_SHUTDOWN;
00422
00423 this->do_SSL_read ();
00424 this->do_SSL_write ();
00425
00426 if ((this->flags_ & SF_REQ_SHUTDOWN) == 0)
00427 return 0;
00428
00429 this->do_SSL_shutdown ();
00430
00431 this->notify_close ();
00432
00433 return 0;
00434 }
00435
00436
00437
00438
00439
00440
00441
00442
00443 int
00444 ACE_SSL_Asynch_Stream::do_SSL_shutdown (void)
00445 {
00446 if (this->flags_ & SF_SHUTDOWN_DONE)
00447 return 1;
00448
00449 this->flags_ |= SF_REQ_SHUTDOWN;
00450
00451
00452
00453 this->notify_read (0, ERR_CANCELED);
00454 this->notify_write (0, ERR_CANCELED);
00455
00456 int retval = ::SSL_shutdown (this->ssl_);
00457
00458 int status = ::SSL_get_error (this->ssl_, retval);
00459
00460 switch (status)
00461 {
00462 case SSL_ERROR_NONE:
00463 case SSL_ERROR_ZERO_RETURN:
00464 case SSL_ERROR_SYSCALL:
00465 retval = 1;
00466 break;
00467
00468 case SSL_ERROR_WANT_READ:
00469 case SSL_ERROR_WANT_WRITE:
00470 case SSL_ERROR_WANT_CONNECT:
00471
00472 case SSL_ERROR_WANT_X509_LOOKUP:
00473 return 0;
00474
00475 default:
00476 this->print_error (status,
00477 ACE_TEXT ("Shutdown error"));
00478 retval = -1;
00479 break;
00480 }
00481
00482 this->flags_ |= SF_SHUTDOWN_DONE;
00483
00484 return retval;
00485 }
00486
00487
00488
00489
00490
00491
00492
00493
00494 int
00495 ACE_SSL_Asynch_Stream::do_SSL_handshake (void)
00496 {
00497 if (SSL_is_init_finished (this->ssl_))
00498 {
00499 if (!handshake_complete_)
00500 {
00501 handshake_complete_ = true;
00502
00503 if (!post_handshake_check ())
00504 {
00505 return -1;
00506 }
00507 }
00508 return 1;
00509 }
00510
00511 if (this->flags_ & SF_REQ_SHUTDOWN)
00512 return -1;
00513
00514 int retval = -1;
00515
00516 switch (this->type_)
00517 {
00518 case ST_CLIENT:
00519 retval = ::SSL_connect (this->ssl_);
00520 break;
00521
00522 case ST_SERVER:
00523 retval = ::SSL_accept (this->ssl_);
00524 break;
00525
00526 default:
00527 ACE_ERROR_RETURN
00528 ((LM_ERROR,
00529 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00530 ACE_TEXT ("- invalid stream type")),
00531 -1);
00532 }
00533
00534 int status = ::SSL_get_error (this->ssl_, retval);
00535
00536 switch (status)
00537 {
00538 case SSL_ERROR_NONE:
00539 break;
00540
00541 case SSL_ERROR_WANT_READ:
00542 case SSL_ERROR_WANT_WRITE:
00543 case SSL_ERROR_WANT_CONNECT:
00544
00545 case SSL_ERROR_WANT_X509_LOOKUP:
00546 return 0;
00547
00548 case SSL_ERROR_ZERO_RETURN:
00549 case SSL_ERROR_SYSCALL:
00550 default:
00551 this->print_error (status,
00552 ACE_TEXT ("Handshake error"));
00553 return -1;
00554 }
00555
00556 return 1;
00557 }
00558
00559
00560 bool
00561 ACE_SSL_Asynch_Stream::post_handshake_check (void)
00562 {
00563 return true;
00564 }
00565
00566
00567
00568
00569 int
00570 ACE_SSL_Asynch_Stream::do_SSL_read (void)
00571 {
00572 if (this->ext_read_result_ == 0)
00573 {
00574 return 0;
00575 }
00576
00577 if (this->flags_ & SF_REQ_SHUTDOWN)
00578 {
00579 this->notify_read (0, ERR_CANCELED);
00580 return -1;
00581 }
00582
00583 ACE_Message_Block & mb = this->ext_read_result_->message_block ();
00584 size_t bytes_req = this->ext_read_result_->bytes_to_read ();
00585
00586 ERR_clear_error ();
00587
00588 const int bytes_trn =
00589 ::SSL_read (this->ssl_,
00590 mb.wr_ptr (),
00591 ACE_Utils::truncate_cast<int> (bytes_req));
00592
00593 int const status = ::SSL_get_error (this->ssl_, bytes_trn);
00594
00595 switch (status)
00596 {
00597 case SSL_ERROR_NONE:
00598 this->notify_read (bytes_trn, 0);
00599 return 1;
00600
00601 case SSL_ERROR_WANT_READ:
00602 case SSL_ERROR_WANT_WRITE:
00603 return 0;
00604
00605 case SSL_ERROR_ZERO_RETURN:
00606 this->notify_read (0, 0);
00607 return 1;
00608
00609 case SSL_ERROR_SYSCALL:
00610 if (bytes_trn == 0)
00611 {
00612 this->notify_read (0, 0);
00613 return 1;
00614 }
00615
00616
00617 default:
00618 break;
00619 }
00620
00621 this->notify_read (0, EFAULT);
00622 this->print_error (status,
00623 ACE_TEXT ("SSL_read error"));
00624
00625 return -1;
00626 }
00627
00628
00629
00630
00631 int
00632 ACE_SSL_Asynch_Stream::do_SSL_write (void)
00633 {
00634 if (this->ext_write_result_ == 0)
00635 {
00636 return 0;
00637 }
00638
00639 if (this->flags_ & SF_REQ_SHUTDOWN)
00640 {
00641 this->notify_write (0, ERR_CANCELED);
00642 return -1;
00643 }
00644
00645 ACE_Message_Block & mb = this->ext_write_result_->message_block ();
00646 size_t bytes_req = this->ext_write_result_->bytes_to_write ();
00647
00648 ERR_clear_error ();
00649
00650 const int bytes_trn =
00651 ::SSL_write (this->ssl_,
00652 mb.rd_ptr (),
00653 ACE_Utils::truncate_cast<int> (bytes_req));
00654
00655 int const status = ::SSL_get_error (this->ssl_, bytes_trn);
00656
00657 switch (status)
00658 {
00659 case SSL_ERROR_NONE:
00660 this->notify_write (bytes_trn, 0);
00661 return 1;
00662
00663 case SSL_ERROR_WANT_READ:
00664 case SSL_ERROR_WANT_WRITE:
00665 return 0;
00666
00667 case SSL_ERROR_ZERO_RETURN:
00668 this->notify_write (bytes_trn, 0);
00669 return 1;
00670
00671 case SSL_ERROR_SYSCALL:
00672 default:
00673 break;
00674 }
00675
00676 this->notify_write(0, EFAULT);
00677 this->print_error (status,
00678 ACE_TEXT ("SSL_write error"));
00679
00680 return -1;
00681 }
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691 int
00692 ACE_SSL_Asynch_Stream::notify_close (void)
00693 {
00694 if (this->flags_ & SF_CLOSE_NTF_SENT)
00695 return 1;
00696
00697 if ((this->flags_ & SF_SHUTDOWN_DONE) == 0)
00698 return 2;
00699
00700 if (this->pending_BIO_count () != 0)
00701 return 2;
00702
00703
00704 ACE_SSL_Asynch_Result * close_result = 0;
00705
00706 ACE_NEW_RETURN (close_result,
00707 ACE_SSL_Asynch_Result (*this),
00708 2);
00709
00710
00711 int retval =
00712 close_result->post_completion (this->proactor_->implementation ());
00713
00714 if (retval == 0)
00715 {
00716 this->flags_ |= SF_CLOSE_NTF_SENT;
00717 return 0;
00718 }
00719
00720 delete close_result;
00721 return 2;
00722 }
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732 int
00733 ACE_SSL_Asynch_Stream::notify_read (int bytes_transferred,
00734 int error)
00735 {
00736 if (ext_read_result_ == 0)
00737 return 1;
00738
00739 this->ext_read_result_->set_bytes_transferred (bytes_transferred);
00740 this->ext_read_result_->set_error (error);
00741
00742 int retval =
00743 this->ext_read_result_->post_completion (proactor_->implementation ());
00744
00745 if (retval == 0)
00746 {
00747 this->ext_read_result_ = 0;
00748 return 0;
00749 }
00750
00751 return 2;
00752 }
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762 int
00763 ACE_SSL_Asynch_Stream::notify_write (int bytes_transferred,
00764 int error)
00765 {
00766 if (this->ext_write_result_ == 0)
00767 return 1;
00768
00769 this->ext_write_result_->set_bytes_transferred (bytes_transferred);
00770 this->ext_write_result_->set_error (error);
00771
00772 int retval =
00773 this->ext_write_result_->post_completion (
00774 this->proactor_->implementation ());
00775
00776 if (retval == 0)
00777 {
00778 this->ext_write_result_ = 0;
00779 return 0;
00780 }
00781
00782 return 2;
00783 }
00784
00785
00786
00787
00788 void
00789 ACE_SSL_Asynch_Stream::print_error (int err_ssl,
00790 const ACE_TCHAR * pText)
00791 {
00792 ACE_DEBUG ((LM_DEBUG,
00793 ACE_TEXT("SSL-error:%d %s\n"),
00794 err_ssl,
00795 pText));
00796
00797 #if OPENSSL_VERSION_NUMBER >= 0x0090601fL
00798
00799 unsigned long lerr = 0;
00800 char buf[1024];
00801
00802 while ((lerr = ERR_get_error()) != 0)
00803 {
00804 ERR_error_string_n (lerr, buf, sizeof buf);
00805
00806 ACE_DEBUG ((LM_DEBUG, "%C\n", buf));
00807 }
00808 #endif
00809 }
00810
00811
00812
00813
00814
00815
00816 int
00817 ACE_SSL_Asynch_Stream::ssl_bio_read (char * buf,
00818 size_t len,
00819 int & errval)
00820 {
00821
00822
00823
00824
00825 errval = 0;
00826
00827 size_t cur_len = this->bio_inp_msg_.length ();
00828
00829 if (cur_len > 0)
00830 {
00831 const char * rd_ptr = this->bio_inp_msg_.rd_ptr ();
00832
00833 if (cur_len > len)
00834 {
00835 cur_len = len;
00836 }
00837
00838 ACE_OS::memcpy (buf, rd_ptr, cur_len);
00839
00840 this->bio_inp_msg_.rd_ptr (cur_len);
00841
00842 return ACE_Utils::truncate_cast<int> (cur_len);
00843 }
00844
00845 if (this->bio_inp_errno_ != 0)
00846 {
00847 errval = this->bio_inp_errno_;
00848 return -1;
00849 }
00850
00851 if (this->bio_inp_flag_ & BF_EOS)
00852 {
00853 return 0;
00854 }
00855
00856 errval = EINPROGRESS;
00857
00858 if (this->bio_inp_flag_ & BF_AIO)
00859 {
00860 return -1;
00861 }
00862
00863 if (this->bio_inp_msg_.size (len) != 0)
00864 {
00865 ACE_ERROR
00866 ((LM_ERROR,
00867 ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00868 ACE_TEXT ("error in ACE_Message_Block::size() ")
00869 ));
00870
00871 errval = EINVAL;
00872 return -1;
00873 }
00874
00875 char * base = this->bio_inp_msg_.base ();
00876
00877 this->bio_inp_msg_.rd_ptr (base);
00878 this->bio_inp_msg_.wr_ptr (base);
00879
00880 if (this->bio_istream_.read (
00881 bio_inp_msg_,
00882 len,
00883 0,
00884 0,
00885 ACE_SIGRTMIN
00886 ) == -1)
00887 {
00888 ACE_ERROR
00889 ((LM_ERROR,
00890 ACE_TEXT ("%N:%l (%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00891 ACE_TEXT ("attempt read failed")
00892 ));
00893
00894 errval = EINVAL;
00895 return -1;
00896 }
00897
00898 this->bio_inp_flag_ |= BF_AIO;
00899
00900 return -1;
00901 }
00902
00903
00904 int
00905 ACE_SSL_Asynch_Stream::ssl_bio_write (const char * buf,
00906 size_t len,
00907 int & errval)
00908 {
00909
00910
00911
00912
00913 errval = 0;
00914
00915 if (this->bio_out_flag_ & BF_AIO)
00916 {
00917 errval = EINPROGRESS;
00918 return -1;
00919 }
00920
00921 if (this->bio_out_errno_ != 0)
00922 {
00923 errval = this->bio_out_errno_;
00924 return -1;
00925 }
00926
00927 if (this->bio_out_msg_.size (len) != 0)
00928 {
00929 ACE_ERROR
00930 ((LM_ERROR,
00931 ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00932 ACE_TEXT ("error in ACE_Message_Block::size() ")
00933 ));
00934
00935 errval = EINVAL;
00936 return -1;
00937 }
00938
00939 char * base = this->bio_out_msg_.base ();
00940
00941 this->bio_out_msg_.rd_ptr (base);
00942 this->bio_out_msg_.wr_ptr (base);
00943
00944 if (this->bio_out_msg_.copy (buf, len) == -1)
00945 {
00946 ACE_ERROR
00947 ((LM_ERROR,
00948 ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00949 ACE_TEXT ("error in ACE_Message_Block::copy() ")
00950 ));
00951
00952 errval = EINVAL;
00953 return -1;
00954 }
00955
00956
00957 if (this->bio_ostream_.write (
00958 this->bio_out_msg_,
00959 len,
00960 0,
00961 0,
00962 ACE_SIGRTMIN
00963 ) == -1)
00964 {
00965 ACE_ERROR
00966 ((LM_ERROR,
00967 ACE_TEXT ("%N:%l ((%P|%t) ACE_SSL_Asynch_Stream %p\n"),
00968 ACE_TEXT ("attempt write failed")
00969 ));
00970
00971 errval = EINVAL;
00972 return -1;
00973 }
00974
00975 this->bio_out_flag_ |= BF_AIO;
00976 errval = 0;
00977
00978 return ACE_Utils::truncate_cast<int> (len);
00979 }
00980
00981
00982
00983
00984
00985 void
00986 ACE_SSL_Asynch_Stream::handle_write_stream (
00987 const ACE_Asynch_Write_Stream::Result &result)
00988 {
00989 ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_));
00990
00991 this->bio_out_flag_ &= ~BF_AIO;
00992
00993 ACE_Message_Block & mb = result.message_block ();
00994
00995 size_t bytes_req = result.bytes_to_write ();
00996 size_t bytes_trn = result.bytes_transferred ();
00997 u_long errval = result.error ();
00998 size_t len = bytes_req - bytes_trn;
00999
01000 if (errval != 0)
01001 this->bio_out_errno_ = errval;
01002 else if (len > 0)
01003 {
01004 if (this->bio_ostream_.write (
01005 mb,
01006 len,
01007 0,
01008 0,
01009 ACE_SIGRTMIN
01010 ) == 0)
01011 {
01012 this->bio_out_flag_ |= BF_AIO;
01013 return;
01014 }
01015
01016 ACE_ERROR
01017 ((LM_ERROR,
01018 ACE_TEXT ("(%P|%t) ACE_SSL_Asynch_Stream %p\n"),
01019 ACE_TEXT ("attempt write failed")
01020 ));
01021
01022 this->bio_out_errno_ = EINVAL;
01023 }
01024
01025 this->do_SSL_state_machine ();
01026
01027 return;
01028 }
01029
01030 void
01031 ACE_SSL_Asynch_Stream::handle_read_stream (
01032 const ACE_Asynch_Read_Stream::Result &result)
01033 {
01034 ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_));
01035
01036 this->bio_inp_flag_ &= ~BF_AIO;
01037
01038 size_t bytes_trn = result.bytes_transferred ();
01039 u_long errval = result.error ();
01040
01041 if (errval != 0)
01042 this->bio_inp_errno_ = errval;
01043 else if (bytes_trn == 0)
01044 this->bio_inp_flag_ |= BF_EOS;
01045
01046 this->do_SSL_state_machine ();
01047
01048 return;
01049 }
01050
01051 void
01052 ACE_SSL_Asynch_Stream::handle_wakeup (void)
01053 {
01054 ACE_Handler * user_handler = 0;
01055
01056 {
01057 ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_));
01058
01059 this->flags_ |= SF_DELETE_ENABLE;
01060
01061 user_handler = this->ext_handler_;
01062 }
01063
01064 if (user_handler != 0)
01065 user_handler->handle_wakeup();
01066 }
01067
01068 int
01069 ACE_SSL_Asynch_Stream::pending_BIO_count (void)
01070 {
01071 int ret = 0;
01072
01073 if (this->bio_inp_flag_ & BF_AIO)
01074 ++ret;
01075
01076 if (this->bio_out_flag_ & BF_AIO)
01077 ++ret;
01078
01079 return ret;
01080 }
01081
01082 ACE_END_VERSIONED_NAMESPACE_DECL
01083
01084 #endif
01085