00001
00002
00003
00004
00005 #include "ace/OS_NS_errno.h"
00006 #include "ace/Truncate.h"
00007
00008 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00009
00010 ACE_INLINE void
00011 ACE_SSL_SOCK_Stream::set_handle (ACE_HANDLE fd)
00012 {
00013 if (this->ssl_ == 0 || fd == ACE_INVALID_HANDLE)
00014 {
00015 this->ACE_SSL_SOCK::set_handle (ACE_INVALID_HANDLE);
00016 return;
00017 }
00018 else
00019 {
00020 (void) ::SSL_set_fd (this->ssl_, (int) fd);
00021 this->ACE_SSL_SOCK::set_handle (fd);
00022 this->stream_.set_handle (fd);
00023 }
00024 }
00025
00026 ACE_INLINE ssize_t
00027 ACE_SSL_SOCK_Stream::send_i (const void *buf,
00028 size_t n,
00029 int flags) const
00030 {
00031 ACE_TRACE ("ACE_SSL_SOCK_Stream::send_i");
00032
00033
00034
00035
00036 if (flags != 0)
00037 {
00038 ACE_NOTSUP_RETURN (-1);
00039 }
00040
00041 int const bytes_sent = ::SSL_write (this->ssl_,
00042 static_cast<const char *> (buf),
00043 ACE_Utils::truncate_cast<int> (n));
00044
00045 switch (::SSL_get_error (this->ssl_, bytes_sent))
00046 {
00047 case SSL_ERROR_NONE:
00048 return bytes_sent;
00049
00050 case SSL_ERROR_WANT_READ:
00051 case SSL_ERROR_WANT_WRITE:
00052 errno = EWOULDBLOCK;
00053
00054 return -1;
00055
00056 case SSL_ERROR_ZERO_RETURN:
00057
00058
00059 (void) ::SSL_shutdown (this->ssl_);
00060
00061 return bytes_sent;
00062
00063 case SSL_ERROR_SYSCALL:
00064 if (bytes_sent == 0)
00065
00066
00067 return 0;
00068
00069
00070
00071
00072
00073 ACE_OS::set_errno_to_last_error ();
00074
00075 break;
00076
00077 default:
00078
00079
00080 errno = 0;
00081
00082 ACE_SSL_Context::report_error ();
00083
00084 break;
00085 }
00086
00087 return -1;
00088 }
00089
00090 ACE_INLINE ssize_t
00091 ACE_SSL_SOCK_Stream::send (const void *buf,
00092 size_t n,
00093 int flags) const
00094 {
00095 return this->send_i (buf, n, flags);
00096 }
00097
00098 ACE_INLINE ssize_t
00099 ACE_SSL_SOCK_Stream::recv_i (void *buf,
00100 size_t n,
00101 int flags,
00102 const ACE_Time_Value *timeout) const
00103 {
00104 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv_i");
00105
00106
00107
00108 int bytes_read = 0;
00109 ACE_HANDLE const handle = this->get_handle ();
00110
00111
00112 int val = 0;
00113
00114 if (timeout != 0)
00115 ACE::record_and_set_non_blocking_mode (handle,
00116 val);
00117
00118
00119
00120
00121
00122 if (timeout != 0
00123 && !::SSL_pending (this->ssl_))
00124 {
00125 if (ACE::enter_recv_timedwait (handle,
00126 timeout,
00127 val) == -1)
00128 return -1;
00129 }
00130
00131 if (flags)
00132 {
00133 if (ACE_BIT_ENABLED (flags, MSG_PEEK))
00134 {
00135 bytes_read = ::SSL_peek (this->ssl_,
00136 static_cast<char *> (buf),
00137 ACE_Utils::truncate_cast<int> (n));
00138 }
00139 else
00140 {
00141 ACE_NOTSUP_RETURN (-1);
00142 }
00143 }
00144 else
00145 {
00146 bytes_read = ::SSL_read (this->ssl_,
00147 static_cast<char *> (buf),
00148 ACE_Utils::truncate_cast<int> (n));
00149 }
00150
00151 int const status = ::SSL_get_error (this->ssl_, bytes_read);
00152 switch (status)
00153 {
00154 case SSL_ERROR_NONE:
00155 if (timeout != 0)
00156 ACE::restore_non_blocking_mode (handle, val);
00157
00158 return bytes_read;
00159
00160 case SSL_ERROR_WANT_READ:
00161 case SSL_ERROR_WANT_WRITE:
00162 errno = EWOULDBLOCK;
00163
00164 return -1;
00165
00166 case SSL_ERROR_ZERO_RETURN:
00167 if (timeout != 0)
00168 ACE::restore_non_blocking_mode (handle, val);
00169
00170
00171
00172 (void) ::SSL_shutdown (this->ssl_);
00173
00174 return bytes_read;
00175
00176 case SSL_ERROR_SYSCALL:
00177 if (bytes_read == 0)
00178
00179
00180 return 0;
00181
00182
00183
00184
00185
00186 ACE_OS::set_errno_to_last_error ();
00187
00188 break;
00189
00190 default:
00191
00192
00193 errno = 0;
00194
00195 ACE_SSL_Context::report_error ();
00196
00197 break;
00198 }
00199
00200 return -1;
00201 }
00202
00203 ACE_INLINE ssize_t
00204 ACE_SSL_SOCK_Stream::recv (void *buf,
00205 size_t n,
00206 int flags) const
00207 {
00208 return this->recv_i (buf, n, flags, 0);
00209 }
00210
00211 ACE_INLINE ssize_t
00212 ACE_SSL_SOCK_Stream::send (const void *buf,
00213 size_t n) const
00214 {
00215 ACE_TRACE ("ACE_SSL_SOCK_Stream::send");
00216
00217 return this->send_i (buf, n, 0);
00218 }
00219
00220 ACE_INLINE ssize_t
00221 ACE_SSL_SOCK_Stream::recv (void *buf,
00222 size_t n) const
00223 {
00224 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv");
00225
00226 return this->recv_i (buf, n, 0, 0);
00227 }
00228
00229 ACE_INLINE ssize_t
00230 ACE_SSL_SOCK_Stream::send (const void *buf,
00231 size_t len,
00232 const ACE_Time_Value *timeout) const
00233 {
00234 ACE_TRACE ("ACE_SSL_SOCK_Stream::send");
00235 return this->send (buf, len, 0, timeout);
00236 }
00237
00238 ACE_INLINE ssize_t
00239 ACE_SSL_SOCK_Stream::recv (void *buf,
00240 size_t n,
00241 const ACE_Time_Value *timeout) const
00242 {
00243 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv");
00244 return this->recv (buf, n, 0, timeout);
00245 }
00246
00247 ACE_INLINE ssize_t
00248 ACE_SSL_SOCK_Stream::recv_n (void *buf, int buf_size) const
00249 {
00250 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv_n");
00251 return this->recv_n (buf, buf_size, 0);
00252 }
00253
00254 ACE_INLINE ssize_t
00255 ACE_SSL_SOCK_Stream::recv_n (void *buf,
00256 size_t len,
00257 const ACE_Time_Value *timeout,
00258 size_t *bytes_transferred) const
00259 {
00260 ACE_TRACE ("ACE_SSL_SOCK_Stream::recv_n");
00261 return this->recv_n (buf, len, 0, timeout, bytes_transferred);
00262 }
00263
00264 ACE_INLINE ssize_t
00265 ACE_SSL_SOCK_Stream::send_n (const void *buf, int len) const
00266 {
00267 ACE_TRACE ("ACE_SSL_SOCK_Stream::send_n");
00268 return this->send_n (buf, len, 0);
00269 }
00270
00271 ACE_INLINE ssize_t
00272 ACE_SSL_SOCK_Stream::send_n (const void *buf,
00273 size_t len,
00274 const ACE_Time_Value *timeout,
00275 size_t *bytes_transferred) const
00276 {
00277 ACE_TRACE ("ACE_SSL_SOCK_Stream::send_n");
00278 return this->send_n (buf, len, 0, timeout, bytes_transferred);
00279 }
00280
00281 ACE_INLINE int
00282 ACE_SSL_SOCK_Stream::close_reader (void)
00283 {
00284 ACE_TRACE ("ACE_SSL_SOCK_Stream::close_reader");
00285 return this->stream_.close_reader ();
00286 }
00287
00288 ACE_INLINE int
00289 ACE_SSL_SOCK_Stream::close_writer (void)
00290 {
00291 ACE_TRACE ("ACE_SSL_SOCK_Stream::close_writer");
00292 return this->stream_.close_writer ();
00293 }
00294
00295 ACE_INLINE int
00296 ACE_SSL_SOCK_Stream::close (void)
00297 {
00298 ACE_TRACE ("ACE_SSL_SOCK_Stream::close");
00299
00300 if (this->ssl_ == 0 || this->get_handle () == ACE_INVALID_HANDLE)
00301 return 0;
00302
00303
00304
00305 int const status = ::SSL_shutdown (this->ssl_);
00306
00307 switch (::SSL_get_error (this->ssl_, status))
00308 {
00309 case SSL_ERROR_NONE:
00310 case SSL_ERROR_SYSCALL:
00311
00312
00313
00314
00315
00316 (void) ::SSL_clear (this->ssl_);
00317 this->set_handle (ACE_INVALID_HANDLE);
00318 return this->stream_.close ();
00319
00320 case SSL_ERROR_WANT_READ:
00321 case SSL_ERROR_WANT_WRITE:
00322 errno = EWOULDBLOCK;
00323 break;
00324
00325 default:
00326 ACE_SSL_Context::report_error ();
00327
00328 ACE_Errno_Guard error (errno);
00329 (void) this->stream_.close ();
00330
00331 return -1;
00332 }
00333
00334 return -1;
00335 }
00336
00337 ACE_INLINE ACE_SOCK_Stream &
00338 ACE_SSL_SOCK_Stream::peer (void)
00339 {
00340 ACE_TRACE ("ACE_SSL_SOCK_Stream::peer");
00341 return this->stream_;
00342 }
00343
00344 ACE_INLINE SSL *
00345 ACE_SSL_SOCK_Stream::ssl (void) const
00346 {
00347 return this->ssl_;
00348 }
00349
00350 ACE_END_VERSIONED_NAMESPACE_DECL