00001
00002
00003 #include "SSL_Asynch_BIO.h"
00004
00005 #if OPENSSL_VERSION_NUMBER > 0x0090581fL && ((defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)))
00006
00007 #include "SSL_Asynch_Stream.h"
00008 #include "ace/OS_NS_string.h"
00009 #include "ace/Truncate.h"
00010
00011 ACE_RCSID (ACE_SSL,
00012 SSL_Asynch_BIO,
00013 "$Id: SSL_Asynch_BIO.cpp 82574 2008-08-08 19:35:06Z parsons $")
00014
00015 #if (defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1)
00016 # define ACE_ASYNCH_BIO_WRITE_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_write)
00017 # define ACE_ASYNCH_BIO_READ_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_read)
00018 # define ACE_ASYNCH_BIO_PUTS_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_puts)
00019 # define ACE_ASYNCH_BIO_CTRL_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_ctrl)
00020 # define ACE_ASYNCH_BIO_NEW_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_new)
00021 # define ACE_ASYNCH_BIO_FREE_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ACE_Asynch_BIO_free)
00022 #else
00023 # define ACE_ASYNCH_BIO_WRITE_NAME ACE_Asynch_BIO_write
00024 # define ACE_ASYNCH_BIO_READ_NAME ACE_Asynch_BIO_read
00025 # define ACE_ASYNCH_BIO_PUTS_NAME ACE_Asynch_BIO_puts
00026 # define ACE_ASYNCH_BIO_CTRL_NAME ACE_Asynch_BIO_ctrl
00027 # define ACE_ASYNCH_BIO_NEW_NAME ACE_Asynch_BIO_new
00028 # define ACE_ASYNCH_BIO_FREE_NAME ACE_Asynch_BIO_free
00029 #endif
00030
00031
00032
00033
00034
00035
00036 extern "C"
00037 {
00038 int ACE_ASYNCH_BIO_WRITE_NAME (BIO *pBIO, const char *buf, int len);
00039 int ACE_ASYNCH_BIO_READ_NAME (BIO *pBIO, char *buf, int len);
00040 int ACE_ASYNCH_BIO_PUTS_NAME (BIO *pBIO, const char *str);
00041 long ACE_ASYNCH_BIO_CTRL_NAME (BIO *pBIO, int cmd, long arg1, void *arg2);
00042 int ACE_ASYNCH_BIO_NEW_NAME (BIO *pBIO);
00043 int ACE_ASYNCH_BIO_FREE_NAME (BIO *pBIO);
00044 }
00045
00046
00047 #define BIO_TYPE_ACE ( 21 | BIO_TYPE_SOURCE_SINK )
00048
00049 static BIO_METHOD methods_ACE =
00050 {
00051 BIO_TYPE_ACE,
00052 "ACE_Asynch_BIO",
00053 ACE_ASYNCH_BIO_WRITE_NAME,
00054 ACE_ASYNCH_BIO_READ_NAME,
00055 ACE_ASYNCH_BIO_PUTS_NAME,
00056 0,
00057 ACE_ASYNCH_BIO_CTRL_NAME,
00058 ACE_ASYNCH_BIO_NEW_NAME,
00059 ACE_ASYNCH_BIO_FREE_NAME,
00060 0
00061 };
00062
00063 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00064
00065 BIO *
00066 ACE_SSL_make_BIO (void * ssl_asynch_stream)
00067 {
00068 BIO * const pBIO = BIO_new (&methods_ACE);
00069
00070 if (pBIO)
00071 BIO_ctrl (pBIO,
00072 BIO_C_SET_FILE_PTR,
00073 0,
00074 ssl_asynch_stream);
00075
00076 return pBIO;
00077 }
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091 struct ACE_SSL_Asynch_Stream_Accessor
00092 {
00093 static int read (ACE_SSL_Asynch_Stream * stream,
00094 char * buf,
00095 size_t len,
00096 int & errval)
00097 {
00098 return stream->ssl_bio_read (buf, len, errval);
00099 }
00100
00101 static int write (ACE_SSL_Asynch_Stream * stream,
00102 const char * buf,
00103 size_t len,
00104 int & errval)
00105 {
00106 return stream->ssl_bio_write (buf, len, errval);
00107 }
00108 };
00109
00110 ACE_END_VERSIONED_NAMESPACE_DECL
00111
00112 int
00113 ACE_ASYNCH_BIO_NEW_NAME (BIO * pBIO)
00114 {
00115 pBIO->init = 0;
00116 pBIO->num = 0;
00117 pBIO->ptr = 0;
00118 pBIO->flags = 0;
00119
00120 return 1;
00121 }
00122
00123 int
00124 ACE_ASYNCH_BIO_FREE_NAME (BIO * pBIO)
00125 {
00126 if (pBIO && pBIO->shutdown)
00127 {
00128 pBIO->ptr = 0;
00129 pBIO->init = 0;
00130 pBIO->num = 0;
00131 pBIO->flags = 0;
00132
00133 return 1;
00134 }
00135
00136 return 0;
00137 }
00138
00139 int
00140 ACE_ASYNCH_BIO_READ_NAME (BIO * pBIO, char * buf, int len)
00141 {
00142 BIO_clear_retry_flags (pBIO);
00143
00144 ACE_SSL_Asynch_Stream * const p_stream =
00145 static_cast<ACE_SSL_Asynch_Stream *> (pBIO->ptr);
00146
00147 if (pBIO->init == 0 || p_stream == 0 || buf == 0 || len <= 0)
00148 return -1;
00149
00150 BIO_clear_retry_flags (pBIO);
00151
00152 int errval = 0;
00153
00154 int retval =
00155 ACE_SSL_Asynch_Stream_Accessor::read (p_stream,
00156 buf,
00157 len,
00158 errval);
00159
00160 if (retval >= 0)
00161 return retval;
00162
00163 if (errval == EINPROGRESS)
00164 BIO_set_retry_read (pBIO);
00165
00166 return -1;
00167 }
00168
00169 int
00170 ACE_ASYNCH_BIO_WRITE_NAME (BIO * pBIO, const char * buf, int len)
00171 {
00172 BIO_clear_retry_flags (pBIO);
00173
00174 ACE_SSL_Asynch_Stream * p_stream =
00175 static_cast<ACE_SSL_Asynch_Stream *> (pBIO->ptr);
00176
00177 if (pBIO->init == 0 || p_stream == 0 || buf == 0 || len <= 0)
00178 return -1;
00179
00180 BIO_clear_retry_flags (pBIO);
00181
00182 int errval = 0;
00183
00184 int retval =
00185 ACE_SSL_Asynch_Stream_Accessor::write (p_stream,
00186 buf,
00187 len,
00188 errval);
00189
00190 if (retval >= 0)
00191 return retval;
00192
00193 if (errval == EINPROGRESS)
00194 BIO_set_retry_write (pBIO);
00195
00196 return -1;
00197 }
00198
00199 long
00200 ACE_ASYNCH_BIO_CTRL_NAME (BIO * pBIO, int cmd, long num, void *ptr)
00201 {
00202 long ret = 1;
00203
00204 switch (cmd)
00205 {
00206 case BIO_C_SET_FILE_PTR:
00207 pBIO->shutdown = static_cast<int> (num);
00208 pBIO->ptr = ptr;
00209 pBIO->init = 1;
00210 break;
00211
00212 case BIO_CTRL_INFO:
00213 ret = 0;
00214 break;
00215
00216 case BIO_CTRL_GET_CLOSE:
00217 ret = pBIO->shutdown;
00218 break;
00219
00220 case BIO_CTRL_SET_CLOSE:
00221 pBIO->shutdown = static_cast<int> (num);
00222 break;
00223
00224 case BIO_CTRL_PENDING:
00225 case BIO_CTRL_WPENDING:
00226 ret = 0;
00227 break;
00228
00229 case BIO_CTRL_DUP:
00230 case BIO_CTRL_FLUSH:
00231 ret = 1;
00232 break;
00233
00234 default:
00235 ret = 0;
00236 break;
00237 }
00238
00239 return ret;
00240 }
00241
00242 int
00243 ACE_ASYNCH_BIO_PUTS_NAME (BIO *pBIO, const char *str)
00244 {
00245 size_t const n = ACE_OS::strlen (str);
00246
00247 return ACE_ASYNCH_BIO_WRITE_NAME (pBIO,
00248 str,
00249 ACE_Utils::truncate_cast<int> (n));
00250 }
00251
00252 #endif
00253