static int
bio_dsk_bwrite (BIO *bio, const char *out, int length)
{
DskSslStream *stream = DSK_SSL_STREAM (bio->ptr);
DskError *error = NULL;
unsigned n_written;
BIO_clear_retry_flags (bio);
switch (dsk_octet_sink_write (stream->underlying_sink,
length, out, &n_written,
&error))
{
case DSK_IO_RESULT_SUCCESS:
return n_written;
case DSK_IO_RESULT_EOF:
return 0;
case DSK_IO_RESULT_AGAIN:
BIO_set_retry_write (bio);
return -1;
case DSK_IO_RESULT_ERROR:
dsk_octet_stream_set_error (DSK_OCTET_STREAM (stream), error);
dsk_error_unref (error);
break;
}
errno = EINVAL; /* ugh! */
return -1;
}
static int tou_socket_write(BIO *b, const char *in, int inl)
{
int ret;
#ifdef DEBUG_TOU_BIO
fprintf(stderr, "tou_socket_write(%p,%p,%d)\n",b,in,inl);
#endif
clear_tou_socket_error(b->num);
/* call tou library */
ret=tou_write(b->num,in,inl);
BIO_clear_retry_flags(b);
if (ret <= 0)
{
if (BIO_tou_socket_should_retry(b->num,ret))
{
BIO_set_retry_write(b);
#ifdef DEBUG_TOU_BIO
fprintf(stderr, "tou_socket_write() setting retry flag\n");
#endif
}
}
#ifdef DEBUG_TOU_BIO
fprintf(stderr, "tou_socket_write() = %d\n", ret);
#endif
return(ret);
}
static int dgram_write(BIO *b, const char *in, int inl)
{
int ret;
bio_dgram_data *data = (bio_dgram_data *)b->ptr;
clear_socket_error();
if ( data->connected )
ret=writesocket(b->num,in,inl);
else
#if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
ret=sendto(b->num, (char *)in, inl, 0, &data->peer, sizeof(data->peer));
#else
ret=sendto(b->num, in, inl, 0, &data->peer, sizeof(data->peer));
#endif
BIO_clear_retry_flags(b);
if (ret <= 0)
{
if (BIO_sock_should_retry(ret))
{
BIO_set_retry_write(b);
data->_errno = get_last_socket_error();
#if 0 /* higher layers are responsible for querying MTU, if necessary */
if ( data->_errno == EMSGSIZE)
/* retrieve the new MTU */
BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
#endif
}
}
return(ret);
}
static int
tlso_bio_write( BIO *b, const char *buf, int len )
{
struct tls_data *p;
int ret;
if ( buf == NULL || len <= 0 ) return 0;
p = (struct tls_data *)b->ptr;
if ( p == NULL || p->sbiod == NULL ) {
return 0;
}
ret = LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len );
BIO_clear_retry_flags( b );
if ( ret < 0 ) {
int err = sock_errno();
if ( err == EAGAIN || err == EWOULDBLOCK ) {
BIO_set_retry_write( b );
}
}
return ret;
}
static int memory_write(BIO *b, const char *in, int inl)
{
int ret = -1;
char strBuffer[MAX_UDP_PACKET_SIZE];
BIO_memory_data* pData = (BIO_memory_data*)b->ptr;
//
strBuffer[0] = (char)(CW_PROTOCOL_VERSION << 4) | (char)(CW_PACKET_CRYPT);
strBuffer[1] = strBuffer[2] = strBuffer[3] = 0;
//
memcpy(&strBuffer[4], in, inl);
//
errno = 0;
ret = sendto(pData->sock, strBuffer, inl + 4, 0, (struct sockaddr*)&pData->sendAddress, sizeof(struct sockaddr_storage));
//BIO_clear_retry_flags(b);
if (ret <= 0)
{
if (errno == EINTR)
BIO_set_retry_write(b);
}
else
{
ret -= 4;
}
return ret;
}
static int
_mongoc_stream_tls_bio_write (BIO *b,
const char *buf,
int len)
{
mongoc_stream_tls_t *tls;
mongoc_iovec_t iov;
int ret;
BSON_ASSERT (b);
BSON_ASSERT (buf);
if (!(tls = b->ptr)) {
return -1;
}
iov.iov_base = (void *)buf;
iov.iov_len = len;
errno = 0;
ret = (int)mongoc_stream_writev (tls->base_stream, &iov, 1,
tls->timeout_msec);
BIO_clear_retry_flags (b);
if ((ret < 0) && MONGOC_ERRNO_IS_AGAIN (errno)) {
BIO_set_retry_write (b);
}
return ret;
}
int
ACE_ASYNCH_BIO_WRITE_NAME (BIO * pBIO, const char * buf, int len)
{
BIO_clear_retry_flags (pBIO);
ACE_SSL_Asynch_Stream * p_stream =
static_cast<ACE_SSL_Asynch_Stream *> (pBIO->ptr);
if (pBIO->init == 0 || p_stream == 0 || buf == 0 || len <= 0)
return -1;
BIO_clear_retry_flags (pBIO);
int errval = 0;
int retval =
ACE_SSL_Asynch_Stream_Accessor::write (p_stream,
buf,
len,
errval);
if (retval >= 0)
return retval;
if (errval == EINPROGRESS)
BIO_set_retry_write (pBIO);
return -1;
}
static int ssl_write(BIO *bio, const char *out, int outl) {
SSL *ssl = bio->ptr;
if (ssl == NULL) {
return 0;
}
BIO_clear_retry_flags(bio);
const int ret = SSL_write(ssl, out, outl);
switch (SSL_get_error(ssl, ret)) {
case SSL_ERROR_WANT_WRITE:
BIO_set_retry_write(bio);
break;
case SSL_ERROR_WANT_READ:
BIO_set_retry_read(bio);
break;
case SSL_ERROR_WANT_CONNECT:
BIO_set_retry_special(bio);
bio->retry_reason = BIO_RR_CONNECT;
break;
case SSL_ERROR_NONE:
case SSL_ERROR_SYSCALL:
case SSL_ERROR_SSL:
default:
break;
}
return ret;
}
static int
dgram_write(BIO *b, const char *in, int inl)
{
int ret;
bio_dgram_data *data = (bio_dgram_data *)b->ptr;
errno = 0;
if (data->connected)
ret = write(b->num, in, inl);
else {
int peerlen = sizeof(data->peer);
if (data->peer.sa.sa_family == AF_INET)
peerlen = sizeof(data->peer.sa_in);
else if (data->peer.sa.sa_family == AF_INET6)
peerlen = sizeof(data->peer.sa_in6);
ret = sendto(b->num, in, inl, 0, &data->peer.sa, peerlen);
}
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (BIO_dgram_should_retry(ret)) {
BIO_set_retry_write(b);
data->_errno = errno;
/*
* higher layers are responsible for querying MTU,
* if necessary
*/
}
}
return (ret);
}
/* Called to write data info the BIO */
static int
bio_bufferevent_write(BIO *b, const char *in, int inlen)
{
struct bufferevent *bufev = BIO_get_data(b);
struct evbuffer *output;
size_t outlen;
BIO_clear_retry_flags(b);
if (!BIO_get_data(b))
return -1;
output = bufferevent_get_output(bufev);
outlen = evbuffer_get_length(output);
/* Copy only as much data onto the output buffer as can fit under the
* high-water mark. */
if (bufev->wm_write.high && bufev->wm_write.high <= (outlen+inlen)) {
if (bufev->wm_write.high <= outlen) {
/* If no data can fit, we'll need to retry later. */
BIO_set_retry_write(b);
return -1;
}
inlen = bufev->wm_write.high - outlen;
}
EVUTIL_ASSERT(inlen > 0);
evbuffer_add(output, in, inlen);
return inlen;
}
/** write to a mbuf.
* (internal openssl use via the tls_mbuf method)
* @return bytes written on success (0<= ret <=src_len), -1 on error or buffer
* full (in this case sets should_retry_write).
*/
static int tls_bio_mbuf_write(BIO* b, const char* src, int src_len)
{
struct tls_bio_mbuf_data* d;
struct tls_mbuf* wr;
int ret;
ret = 0;
#if OPENSSL_VERSION_NUMBER < 0x010100000L
d = b->ptr;
#else
d = BIO_get_data(b);
#endif
BIO_clear_retry_flags(b);
if (unlikely(d == 0 || d->wr->buf == 0)) {
if (d == 0)
BUG("tls_BIO_mbuf %p: write called with null b->ptr\n", b);
else {
/* this form of calling write with a null buffer is used
as a shortcut when no data is available =>
simulate EAGAIN/WANT_WRITE */
TLS_BIO_DBG("write (%p, %p, %d) called with null buffer"
" => simulating WANT_WRITE\n", b, src, src_len);
BIO_set_retry_write(b);
}
return -1;
}
wr = d->wr;
if (unlikely(wr->size == wr->used && src_len)) {
/* mimic non-blocking socket behaviour */
TLS_BIO_DBG("write (%p, %p, %d) called with full wr buffer (%d)"
" => simulating WANT_WRITE\n", b, src, src_len, wr->used);
BIO_set_retry_write(b);
return -1;
}
ret = MIN_int(wr->size - wr->used, src_len);
memcpy(wr->buf + wr->used, src, ret);
wr->used += ret;
/* if (unlikely(ret < src_len))
BIO_set_retry_write();
*/
TLS_BIO_DBG("write called (%p, %p, %d) => %d\n", b, src, src_len, ret);
return ret;
}
static int fd_write(BIO *b, const char *in, int inl) {
int ret = write(b->num, in, inl);
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (bio_fd_should_retry(ret)) {
BIO_set_retry_write(b);
}
}
return ret;
}
int _goconn_bio_write (BIO *bio, const char *buf, int len) {
struct goconn_bio_write_return ret;
ret = goconn_bio_write(bio, (char *) buf, len);
BIO_clear_retry_flags(bio);
if (ret.r0 == -1 && ret.r1 == EAGAIN) {
BIO_set_retry_write(bio);
}
return ret.r0;
}
static int fd_write(BIO *b, const char *in, int inl)
{
int ret;
clear_sys_error();
ret = UP_write(b->num, in, inl);
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (BIO_fd_should_retry(ret))
BIO_set_retry_write(b);
}
return (ret);
}
static int sock_write(BIO *b, const char *in, int inl) {
int ret;
bio_clear_socket_error();
ret = send(b->num, in, inl, 0);
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (bio_fd_should_retry(ret)) {
BIO_set_retry_write(b);
}
}
return ret;
}
static int sock_write(BIO *b, const char *in, int inl)
{
int ret;
clear_socket_error();
ret = writesocket(b->num, in, inl);
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (BIO_sock_should_retry(ret))
BIO_set_retry_write(b);
}
return ret;
}
static int url_bio_bwrite(BIO *b, const char *buf, int len)
{
URLContext *h = GET_BIO_DATA(b);
int ret = ffurl_write(h, buf, len);
if (ret >= 0)
return ret;
BIO_clear_retry_flags(b);
if (ret == AVERROR(EAGAIN))
BIO_set_retry_write(b);
if (ret == AVERROR_EXIT)
return 0;
return -1;
}
static int sock_write(BIO *b, const char *in, int inl)
{
int ret;
clear_socket_error();
ret=ssl_sendmsg((struct socket*)b->num,in,inl);
BIO_clear_retry_flags(b);
if (ret <= 0)
{
if (BIO_sock_should_retry(ret))
BIO_set_retry_write(b);
}
return(ret);
}
static int bio_bufq_write(BIO *h, const char *buf, int size)
{
uint64_t n;
ph_bufq_t *q = h->ptr;
BIO_clear_retry_flags(h);
if (ph_bufq_append(q, buf, size, &n) != PH_OK) {
BIO_set_retry_write(h);
errno = EAGAIN;
return -1;
}
return (int)n;
}
static int nbiof_write (BIO * b, const char *in, int inl)
{
NBIO_TEST *nt;
int ret = 0;
int num;
unsigned char n;
if ((in == NULL) || (inl <= 0))
return (0);
if (b->next_bio == NULL)
return (0);
nt = (NBIO_TEST *) b->ptr;
BIO_clear_retry_flags (b);
#if 1
if (nt->lwn > 0)
{
num = nt->lwn;
nt->lwn = 0;
}
else
{
RAND_pseudo_bytes (&n, 1);
num = (n & 7);
}
if (inl > num)
inl = num;
if (num == 0)
{
ret = -1;
BIO_set_retry_write (b);
}
else
#endif
{
ret = BIO_write (b->next_bio, in, inl);
if (ret < 0)
{
BIO_copy_next_retry (b);
nt->lwn = inl;
}
}
return (ret);
}
static int
my_sock_write(BIO *h, const char *buf, int size)
{
int res = 0;
res = send(h->num, buf, size, 0);
if (res <= 0)
{
if (errno == EINTR)
{
BIO_set_retry_write(h);
}
}
return res;
}
/* non-copying interface: provide pointer to region to write to
* bio_nwrite0: check how much space is available
* bio_nwrite: also increase length
* (example usage: bio_nwrite0(), write to buffer, bio_nwrite()
* or just bio_nwrite(), write to buffer)
*/
static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf)
{
struct bio_bio_st *b;
size_t num;
size_t write_offset;
BIO_clear_retry_flags(bio);
if (!bio->init)
return 0;
b = bio->ptr;
assert(b != NULL);
assert(b->peer != NULL);
assert(b->buf != NULL);
b->request = 0;
if (b->closed)
{
BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE);
return -1;
}
assert(b->len <= b->size);
if (b->len == b->size)
{
BIO_set_retry_write(bio);
return -1;
}
num = b->size - b->len;
write_offset = b->offset + b->len;
if (write_offset >= b->size)
write_offset -= b->size;
if (write_offset + num > b->size)
/* no ring buffer wrap-around for non-copying interface
* (to fulfil the promise by BIO_ctrl_get_write_guarantee,
* BIO_nwrite may have to be called twice) */
num = b->size - write_offset;
if (buf != NULL)
*buf = b->buf + write_offset;
assert(write_offset + num <= b->size);
return num;
}
static int
bio_cb_read(BIO *bio, char *buf, int size)
{
struct tls *ctx = bio->ptr;
int rv;
BIO_clear_retry_flags(bio);
rv = (ctx->read_cb)(ctx, buf, size, ctx->cb_arg);
if (rv == TLS_WANT_POLLIN) {
BIO_set_retry_read(bio);
rv = -1;
} else if (rv == TLS_WANT_POLLOUT) {
BIO_set_retry_write(bio);
rv = -1;
}
return (rv);
}
static int sock_write(BIO *b, const char *in, int inl) {
int ret;
bio_clear_socket_error();
#if defined(OPENSSL_WINDOWS)
ret = send(b->num, in, inl, 0);
#else
ret = write(b->num, in, inl);
#endif
BIO_clear_retry_flags(b);
if (ret <= 0) {
if (bio_fd_should_retry(ret)) {
BIO_set_retry_write(b);
}
}
return ret;
}
static int transport_bio_tsg_write(BIO* bio, const char* buf, int num)
{
int status;
rdpTsg* tsg;
tsg = (rdpTsg*) bio->ptr;
status = tsg_write(tsg, (BYTE*) buf, num);
BIO_clear_retry_flags(bio);
if (status <= 0)
{
BIO_set_retry_write(bio);
}
return num;
}
static int
my_sock_write(BIO *h, const char *buf, int size)
{
int res = 0;
res = secure_raw_write(((Port *) BIO_get_data(h)), buf, size);
BIO_clear_retry_flags(h);
if (res <= 0)
{
/* If we were interrupted, tell caller to retry */
if (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
{
BIO_set_retry_write(h);
}
}
return res;
}
static int amqp_openssl_bio_write(BIO* b, const char *in, int inl) {
int flags = 0;
int fd;
int res;
#ifdef MSG_NOSIGNAL
flags |= MSG_NOSIGNAL;
#endif
BIO_get_fd(b, &fd);
res = send(fd, in, inl, flags);
BIO_clear_retry_flags(b);
if (res <= 0 && amqp_openssl_bio_should_retry(res)) {
BIO_set_retry_write(b);
}
return res;
}
static int dgram_write(BIO *b, const char *in, int inl)
{
int ret;
bio_dgram_data *data = (bio_dgram_data *)b->ptr;
clear_socket_error();
if ( data->connected )
ret=writesocket(b->num,in,inl);
else
{
int peerlen = sizeof(data->peer);
if (data->peer.sa.sa_family == AF_INET)
peerlen = sizeof(data->peer.sa_in);
#if OPENSSL_USE_IVP6
else if (data->peer.sa.sa_family == AF_INET6)
peerlen = sizeof(data->peer.sa_in6);
#endif
#if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
ret=TINYCLR_SSL_SENDTO(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen);
#else
ret=TINYCLR_SSL_SENDTO(b->num, in, inl, 0, &data->peer.sa, peerlen);
#endif
}
BIO_clear_retry_flags(b);
if (ret <= 0)
{
if (BIO_dgram_should_retry(ret))
{
BIO_set_retry_write(b);
data->_errno = get_last_socket_error();
#if 0 /* higher layers are responsible for querying MTU, if necessary */
if ( data->_errno == EMSGSIZE)
/* retrieve the new MTU */
BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
#endif
}
}
return(ret);
}
static int
my_sock_write(BIO *h, const char *buf, int size)
{
int res = 0;
prepare_for_client_write();
res = send(h->num, buf, size, 0);
if (res <= 0)
{
if (errno == EINTR)
{
BIO_set_retry_write(h);
}
}
client_write_ended();
return res;
}
static int bio_stm_write(BIO *h, const char *buf, int size)
{
uint64_t nwrote;
ph_stream_t *stm = h->ptr;
if (buf == NULL || size == 0 || stm == NULL) {
return 0;
}
BIO_clear_retry_flags(h);
if (ph_stm_write(stm, buf, size, &nwrote)) {
return (int)nwrote;
}
if (should_retry(stm)) {
BIO_set_retry_write(h);
}
return -1;
}
