自学教程：C++ BIO_set_retry_write函数代码示例

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 inttlso_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;}

intACE_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 intdgram_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 intbio_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 intmy_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 intbio_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 intmy_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 intmy_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;}