00001
00002
00003 #include "ace/Handle_Set.h"
00004 #include "ace/Log_Msg.h"
00005 #include "ace/Countdown_Time.h"
00006 #include "ace/OS_NS_string.h"
00007 #include "ace/OS_NS_sys_select.h"
00008 #include "ace/OS_Memory.h"
00009
00010 #include <openssl/err.h>
00011
00012 #include "SSL_SOCK_Stream.h"
00013
00014 #if !defined (__ACE_INLINE__)
00015 #include "SSL_SOCK_Stream.inl"
00016 #endif
00017
00018 ACE_RCSID (ACE_SSL,
00019 SSL_SOCK_Stream,
00020 "$Id: SSL_SOCK_Stream.cpp 82577 2008-08-09 17:43:11Z mitza $")
00021
00022 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00023
00024 ACE_ALLOC_HOOK_DEFINE(ACE_SSL_SOCK_Stream)
00025
00026 ACE_SSL_SOCK_Stream::ACE_SSL_SOCK_Stream (ACE_SSL_Context *context)
00027 : ssl_ (0),
00028 stream_ ()
00029 {
00030 ACE_TRACE ("ACE_SSL_SOCK_Stream::ACE_SSL_SOCK_Stream");
00031
00032 ACE_SSL_Context * ctx =
00033 (context == 0 ? ACE_SSL_Context::instance () : context);
00034
00035 this->ssl_ = ::SSL_new (ctx->context ());
00036
00037 if (this->ssl_ == 0)
00038 {
00039 ACE_ERROR ((LM_ERROR,
00040 "(%P|%t) ACE_SSL_SOCK_Stream "
00041 "- cannot allocate new SSL structure %p\n",
00042 ACE_TEXT ("")));
00043 }
00044 }
00045
00046 ACE_SSL_SOCK_Stream::~ACE_SSL_SOCK_Stream (void)
00047 {
00048 ACE_TRACE ("ACE_SSL_SOCK_Stream::~ACE_SSL_SOCK_Stream");
00049
00050 ::SSL_free (this->ssl_);
00051
00052
00053
00054
00055
00056 }
00057
00058 ssize_t
00059 ACE_SSL_SOCK_Stream::sendv (const iovec iov[],
00060 size_t n,
00061 const ACE_Time_Value *max_wait_time) const
00062 {
00063 ACE_TRACE ("ACE_SSL_SOCK_Stream::sendv");
00064
00065
00066
00067
00068
00069
00070 ssize_t bytes_sent = 0;
00071
00072 ACE_Time_Value t;
00073 ACE_Time_Value *timeout = const_cast<ACE_Time_Value *> (max_wait_time);
00074
00075 if (max_wait_time != 0)
00076 {
00077
00078
00079 t = *max_wait_time;
00080 timeout = &t;
00081 }
00082
00083
00084 ACE_Countdown_Time countdown (timeout);
00085
00086 for (size_t i = 0; i < n; ++i)
00087 {
00088 ssize_t const result = this->send (iov[i].iov_base,
00089 iov[i].iov_len,
00090 timeout);
00091
00092 if (result == -1)
00093 {
00094
00095
00096
00097
00098 if (bytes_sent > 0)
00099 break;
00100 else
00101 return -1;
00102 }
00103 else
00104 {
00105 bytes_sent += result;
00106
00107
00108
00109
00110
00111
00112 if (static_cast<size_t> (result) < static_cast<size_t> (iov[i].iov_len))
00113 break;
00114 }
00115
00116 (void) countdown.update ();
00117 }
00118
00119 return bytes_sent;
00120 }
00121
00122 ssize_t
00123 ACE_SSL_SOCK_Stream::recvv (iovec *io_vec,
00124 const ACE_Time_Value *timeout) const
00125 {
00126 ACE_TRACE ("ACE_SSL_SOCK_Stream::recvv");
00127
00128
00129 #if defined (FIONREAD)
00130 ACE_Handle_Set handle_set;
00131 handle_set.reset ();
00132 handle_set.set_bit (this->get_handle ());
00133
00134 io_vec->iov_base = 0;
00135
00136
00137 switch (
00138 ACE_OS::select (int (this->get_handle ()) + 1,
00139 handle_set,
00140 0,
00141 0,
00142 timeout))
00143 {
00144 case -1:
00145 return -1;
00146
00147 case 0:
00148 errno = ETIME;
00149 return -1;
00150
00151 default:
00152
00153 break;
00154 }
00155
00156 int inlen;
00157
00158 if (ACE_OS::ioctl (this->get_handle (),
00159 FIONREAD,
00160 &inlen) == -1)
00161 return -1;
00162 else if (inlen > 0)
00163 {
00164 ACE_NEW_RETURN (io_vec->iov_base,
00165 char[inlen],
00166 -1);
00167 io_vec->iov_len = this->recv (io_vec->iov_base,
00168 inlen);
00169 return io_vec->iov_len;
00170 }
00171 else
00172 return 0;
00173 #else
00174 ACE_UNUSED_ARG (io_vec);
00175 ACE_UNUSED_ARG (timeout);
00176 ACE_NOTSUP_RETURN (-1);
00177 #endif
00178 }
00179
00180 ssize_t
00181 ACE_SSL_SOCK_Stream::send (const void *buf,
00182 size_t len,
00183 int flags,
00184 const ACE_Time_Value *timeout) const
00185 {
00186 ACE_TRACE ("ACE_SSL_SOCK_Stream::send");
00187
00188
00189
00190 if (timeout == 0 || ::SSL_pending (this->ssl_))
00191 return this->send (buf, len, flags);
00192
00193 int val = 0;
00194 if (ACE::enter_send_timedwait (this->get_handle (),
00195 timeout,
00196 val) == -1)
00197 return -1;
00198
00199 ssize_t const bytes_transferred = this->send (buf, len, flags);
00200
00201 ACE::restore_non_blocking_mode (this->get_handle (), val);
00202
00203 return bytes_transferred;
00204 }
00205
00206 ssize_t
00207 ACE_SSL_SOCK_Stream::recv (void *buf,
00208 size_t n,
00209 int flags,
00210 const ACE_Time_Value *timeout) const
00211 {
00212 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv");
00213
00214 return this->recv_i (buf, n, flags, timeout);
00215 }
00216
00217
00218 ssize_t
00219 ACE_SSL_SOCK_Stream::send (size_t n, ...) const
00220 {
00221 ACE_TRACE ("ACE_SSL_SOCK_Stream::send");
00222
00223 size_t const total_tuples = n / 2;
00224
00225 va_list argp;
00226 va_start (argp, n);
00227
00228 ssize_t bytes_sent = 0;
00229
00230
00231
00232
00233
00234
00235 for (size_t i = 0; i < total_tuples; ++i)
00236 {
00237 ssize_t const data_len = va_arg (argp, ssize_t);
00238 ssize_t const result = this->send (va_arg (argp, char *), data_len);
00239
00240 if (result == -1)
00241 {
00242
00243
00244
00245
00246
00247 if (bytes_sent > 0)
00248 break;
00249 else
00250 {
00251 va_end (argp);
00252 return -1;
00253 }
00254 }
00255 else
00256 {
00257 bytes_sent += result;
00258
00259
00260
00261
00262
00263
00264 if (result < data_len)
00265 break;
00266
00267 }
00268 }
00269
00270 va_end (argp);
00271
00272 return bytes_sent;
00273 }
00274
00275 ssize_t
00276 ACE_SSL_SOCK_Stream::recv (size_t n, ...) const
00277 {
00278 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv");
00279
00280 size_t const total_tuples = n / 2;
00281
00282 va_list argp;
00283 va_start (argp, n);
00284
00285 ssize_t bytes_recv = 0;
00286
00287 for (size_t i = 0; i < total_tuples; ++i)
00288 {
00289 ssize_t const data_len = va_arg (argp, ssize_t);
00290 ssize_t const result = this->recv (va_arg (argp, char *), data_len);
00291
00292 if (result == -1)
00293 {
00294
00295
00296
00297
00298
00299 if (bytes_recv > 0)
00300 {
00301 break;
00302 }
00303 else
00304 {
00305 va_end (argp);
00306 return -1;
00307 }
00308 }
00309 else
00310 {
00311 bytes_recv += result;
00312
00313
00314
00315
00316
00317
00318 if (result < data_len)
00319 {
00320 break;
00321 }
00322 }
00323 }
00324
00325 va_end (argp);
00326
00327 return bytes_recv;
00328 }
00329
00330 ssize_t
00331 ACE_SSL_SOCK_Stream::send_n (const void *buf,
00332 size_t len,
00333 int flags,
00334 const ACE_Time_Value *timeout,
00335 size_t *bt) const
00336 {
00337 ACE_TRACE ("ACE_SSL_SOCK_Stream::send_n");
00338
00339
00340 if (flags != 0)
00341 {
00342 ACE_NOTSUP_RETURN (-1);
00343 }
00344
00345
00346
00347 size_t temp = 0;
00348 size_t &bytes_transferred = ((bt == 0) ? temp : *bt);
00349
00350
00351 ssize_t n = 0;
00352
00353 for (bytes_transferred = 0;
00354 bytes_transferred < len;
00355 bytes_transferred += n)
00356 {
00357 n = this->send ((const char*) buf + bytes_transferred,
00358 len - bytes_transferred,
00359 flags,
00360 timeout);
00361
00362 if (n < 0)
00363 {
00364 if (errno == EWOULDBLOCK)
00365 {
00366
00367 n = 0;
00368 continue;
00369 }
00370 else
00371 {
00372 return -1;
00373 }
00374 }
00375 else if (n == 0)
00376 {
00377 break;
00378 }
00379 }
00380
00381 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
00382 }
00383
00384 ssize_t
00385 ACE_SSL_SOCK_Stream::recv_n (void *buf,
00386 size_t len,
00387 int flags,
00388 const ACE_Time_Value *timeout,
00389 size_t *bt) const
00390 {
00391 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv_n");
00392
00393 if (flags != 0)
00394 {
00395 if ((flags | MSG_PEEK) != MSG_PEEK)
00396 {
00397 ACE_NOTSUP_RETURN (-1);
00398 }
00399 }
00400
00401 size_t temp = 0;
00402 size_t &bytes_transferred = ((bt == 0) ? temp : *bt);
00403
00404 ssize_t n = 0;
00405
00406 for (bytes_transferred = 0;
00407 bytes_transferred < len;
00408 bytes_transferred += n)
00409 {
00410 n = this->recv ((char*) buf + bytes_transferred,
00411 len - bytes_transferred,
00412 flags,
00413 timeout);
00414
00415 if (n < 0)
00416 {
00417 if (errno == EWOULDBLOCK)
00418 {
00419
00420 n = 0;
00421 continue;
00422 }
00423 else
00424 {
00425 return -1;
00426 }
00427 }
00428 else if (n == 0)
00429 {
00430 break;
00431 }
00432 }
00433
00434 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
00435 }
00436
00437 ssize_t
00438 ACE_SSL_SOCK_Stream::recv_n (void *buf, int len, int flags) const
00439 {
00440 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv_n");
00441
00442 if (flags != 0)
00443 {
00444 if ((flags | MSG_PEEK) != MSG_PEEK)
00445 {
00446 ACE_NOTSUP_RETURN (-1);
00447 }
00448 }
00449
00450 ssize_t bytes_transferred = 0;
00451 ssize_t n = 0;
00452
00453 for (bytes_transferred = 0;
00454 bytes_transferred < len;
00455 bytes_transferred += n)
00456 {
00457 n = this->recv ((char*) buf + bytes_transferred,
00458 len - bytes_transferred,
00459 flags);
00460
00461 if (n < 0)
00462 {
00463 if (errno == EWOULDBLOCK)
00464 {
00465
00466 n = 0;
00467 continue;
00468 }
00469 else
00470 {
00471 return -1;
00472 }
00473 }
00474 else if (n == 0)
00475 {
00476 break;
00477 }
00478 }
00479
00480 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
00481 }
00482
00483 ssize_t
00484 ACE_SSL_SOCK_Stream::send_n (const void *buf, int len, int flags) const
00485 {
00486 ACE_TRACE ("ACE_SSL_SOCK_Stream::send_n");
00487
00488
00489 if (flags != 0)
00490 {
00491 ACE_NOTSUP_RETURN (-1);
00492 }
00493
00494
00495 size_t bytes_transferred = 0;
00496 ssize_t n = 0;
00497
00498 for (bytes_transferred = 0;
00499 bytes_transferred < (size_t) len;
00500 bytes_transferred += n)
00501 {
00502 n = this->send ((const char*) buf + bytes_transferred,
00503 len - bytes_transferred,
00504 flags);
00505
00506 if (n < 0)
00507 {
00508 if (errno == EWOULDBLOCK)
00509 {
00510
00511 n = 0;
00512 continue;
00513 }
00514 else
00515 {
00516 return -1;
00517 }
00518 }
00519 else if (n == 0)
00520 {
00521 break;
00522 }
00523 }
00524
00525 return ACE_Utils::truncate_cast<ssize_t> (bytes_transferred);
00526 }
00527
00528 ssize_t
00529 ACE_SSL_SOCK_Stream::sendv_n (const iovec iov[], size_t iovcnt) const
00530 {
00531 ACE_TRACE ("ACE_SSL_SOCK_Stream::sendv_n");
00532
00533 ssize_t bytes_sent = 0;
00534
00535 for (size_t i = 0; i < iovcnt; ++i)
00536 {
00537 ssize_t result = this->send_n (iov[i].iov_base,
00538 iov[i].iov_len);
00539
00540
00541 if (result == -1)
00542 {
00543
00544
00545
00546
00547
00548 if (bytes_sent > 0)
00549 {
00550 break;
00551 }
00552 else
00553 {
00554 return -1;
00555 }
00556 }
00557 else
00558 {
00559 bytes_sent += result;
00560 }
00561 }
00562
00563 return bytes_sent;
00564 }
00565
00566 ssize_t
00567 ACE_SSL_SOCK_Stream::recvv_n (iovec iov[], size_t iovcnt) const
00568 {
00569 ACE_TRACE ("ACE_SSL_SOCK_Stream::recvv_n");
00570
00571 ssize_t bytes_read = 0;
00572
00573 for (size_t i = 0; i < iovcnt; ++i)
00574 {
00575 ssize_t const result = this->recv_n (iov[i].iov_base,
00576 iov[i].iov_len);
00577
00578 if (result == -1)
00579 {
00580
00581
00582
00583
00584
00585 if (bytes_read > 0)
00586 {
00587 break;
00588 }
00589 else
00590 {
00591 return -1;
00592 }
00593 }
00594 else
00595 {
00596 bytes_read += result;
00597 }
00598 }
00599
00600 return bytes_read;
00601 }
00602
00603 int
00604 ACE_SSL_SOCK_Stream::get_remote_addr (ACE_Addr &addr) const
00605 {
00606
00607
00608
00609
00610
00611
00612
00613 if (SSL_is_init_finished (this->ssl_))
00614 {
00615 return this->ACE_SSL_SOCK::get_remote_addr (addr);
00616 }
00617
00618 if (this->get_handle () == ACE_INVALID_HANDLE)
00619 {
00620 errno = EBADF;
00621 }
00622 else
00623 {
00624 errno = ENOTCONN;
00625 }
00626
00627 return -1;
00628 }
00629
00630 ACE_END_VERSIONED_NAMESPACE_DECL