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

static int mem_read(BIO *b, char *out, int outl){    int ret = -1;    BUF_MEM *bm;    bm = (BUF_MEM *)b->ptr;    BIO_clear_retry_flags(b);    ret = (outl >= 0 && (size_t)outl > bm->length) ? (int)bm->length : outl;    if ((out != NULL) && (ret > 0)) {        memcpy(out, bm->data, ret);        bm->length -= ret;        if (b->flags & BIO_FLAGS_MEM_RDONLY)            bm->data += ret;        else {            memmove(&(bm->data[0]), &(bm->data[ret]), bm->length);        }    } else if (bm->length == 0) {        ret = b->num;        if (ret != 0)            BIO_set_retry_read(b);    }    return (ret);}

static int conn_read(BIO *bio, char *out, int out_len) {  int ret = 0;  BIO_CONNECT *data;  data = (BIO_CONNECT *)bio->ptr;  if (data->state != BIO_CONN_S_OK) {    ret = conn_state(bio, data);    if (ret <= 0) {      return ret;    }  }  bio_clear_socket_error();  ret = recv(bio->num, out, out_len, 0);  BIO_clear_retry_flags(bio);  if (ret <= 0) {    if (bio_fd_should_retry(ret)) {      BIO_set_retry_read(bio);    }  }  return ret;}

static int dgram_read(BIO *b, char *out, int outl)	{	int ret=0;	bio_dgram_data *data = (bio_dgram_data *)b->ptr;	struct sockaddr peer;	int peerlen = sizeof(peer);	if (out != NULL)		{		clear_socket_error();		memset(&peer, 0x00, peerlen);		/* Last arg in recvfrom is signed on some platforms and		 * unsigned on others. It is of type socklen_t on some		 * but this is not universal. Cast to (void *) to avoid		 * compiler warnings.		 */		dgram_adjust_rcv_timeout(b);		ret=recvfrom(b->num,out,outl,0,&peer,(void *)&peerlen);		if ( ! data->connected  && ret >= 0)			BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &peer);		BIO_clear_retry_flags(b);		if (ret < 0)			{			if (BIO_dgram_should_retry(ret))				{				BIO_set_retry_read(b);				data->_errno = get_last_socket_error();				}			}		dgram_reset_rcv_timeout(b);		}	return(ret);	}

static int nbiof_read (BIO * b, char *out, int outl){    int ret = 0;#if 1    int num;    unsigned char n;#endif    if (out == NULL)        return (0);    if (b->next_bio == NULL)        return (0);    BIO_clear_retry_flags (b);#if 1    RAND_pseudo_bytes (&n, 1);    num = (n & 0x07);    if (outl > num)        outl = num;    if (num == 0)    {        ret = -1;        BIO_set_retry_read (b);    }    else#endif    {        ret = BIO_read (b->next_bio, out, outl);        if (ret < 0)            BIO_copy_next_retry (b);    }    return (ret);}

static int rdg_bio_read(BIO* bio, char* buf, int size){	int status;	rdpRdg* rdg = (rdpRdg*) BIO_get_data(bio);	status = rdg_read_data_packet(rdg, (BYTE*) buf, size);	if (status < 0)	{		BIO_clear_retry_flags(bio);		return -1;	}	else if (status == 0)	{		BIO_set_retry_read(bio);		WSASetLastError(WSAEWOULDBLOCK);		return -1;	}	else	{		BIO_set_flags(bio, BIO_FLAGS_READ);	}	return status;}

/* Called to extract data from the BIO. */static intbio_bufferevent_read(BIO *b, char *out, int outlen){	int r = 0;	struct evbuffer *input;	BIO_clear_retry_flags(b);	if (!out)		return 0;	if (!BIO_get_data(b))		return -1;	input = bufferevent_get_input(BIO_get_data(b));	if (evbuffer_get_length(input) == 0) {		/* If there's no data to read, say so. */		BIO_set_retry_read(b);		return -1;	} else {		r = evbuffer_remove(input, out, outlen);	}	return r;}

inline int memq_read (BIO *b, char *out, int size){	MemQ *bmq = (MemQ*)b->ptr;	int ret = -1;	BIO_clear_retry_flags (b);	if (!bmq->empty())	{		try {			ret = (int)bmq->read((unsigned char *)out, (size_t)size);		}		catch (...)		{			BIOerr(BIO_F_MEM_READ, BIO_R_INVALID_ARGUMENT);			return -1;		}	}	else	{		ret = b->num;		if (ret != 0)			BIO_set_retry_read (b);	}	return ret;}

/* Returns the amount read. */static int bio_apr_socket_read(BIO *bio, char *in, int inlen){    apr_size_t len = inlen;    serv_ctx_t *serv_ctx = bio->ptr;    apr_status_t status;    BIO_clear_retry_flags(bio);    status = apr_socket_recv(serv_ctx->client_sock, in, &len);    serv_ctx->bio_read_status = status;    serf__log_skt(TEST_VERBOSE, __FILE__, serv_ctx->client_sock,                  "Read %d bytes from socket with status %d./n", len, status);    if (status == APR_EAGAIN) {        BIO_set_retry_read(bio);        if (len == 0)            return -1;    }    if (SERF_BUCKET_READ_ERROR(status))        return -1;    return len;}

static int tou_socket_read(BIO *b, char *out, int outl)	{	int ret=0;#ifdef DEBUG_TOU_BIO	fprintf(stderr, "tou_socket_read(%p,%p,%d)/n",b,out,outl);#endif	if (out != NULL)		{		clear_tou_socket_error(b->num);		/* call tou library */		ret=tou_read(b->num,out,outl);		BIO_clear_retry_flags(b);		if (ret <= 0)			{			if (BIO_tou_socket_should_retry(b->num, ret))				BIO_set_retry_read(b);			}		}#ifdef DEBUG_TOU_BIO	fprintf(stderr, "tou_socket_read() = %d/n", ret);#endif	return(ret);	}

void BIO_set_retry_read_shim(BIO *b) {    BIO_set_retry_read(b);}

//.........这里部分代码省略.........        if (s->info_callback != NULL)            cb = s->info_callback;        else if (s->ctx->info_callback != NULL)            cb = s->ctx->info_callback;        if (cb != NULL) {            j = (alert_level << 8) | alert_descr;            cb(s, SSL_CB_READ_ALERT, j);        }        if (alert_level == SSL3_AL_WARNING) {            s->s3.warn_alert = alert_descr;            SSL3_RECORD_set_read(rr);            s->rlayer.alert_count++;            if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {                SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,                         SSL_R_TOO_MANY_WARN_ALERTS);                return -1;            }            if (alert_descr == SSL_AD_CLOSE_NOTIFY) {#ifndef OPENSSL_NO_SCTP                /*                 * With SCTP and streams the socket may deliver app data                 * after a close_notify alert. We have to check this first so                 * that nothing gets discarded.                 */                if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&                    BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {                    s->d1->shutdown_received = 1;                    s->rwstate = SSL_READING;                    BIO_clear_retry_flags(SSL_get_rbio(s));                    BIO_set_retry_read(SSL_get_rbio(s));                    return -1;                }#endif                s->shutdown |= SSL_RECEIVED_SHUTDOWN;                return 0;            }        } else if (alert_level == SSL3_AL_FATAL) {            char tmp[16];            s->rwstate = SSL_NOTHING;            s->s3.fatal_alert = alert_descr;            SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_DTLS1_READ_BYTES,                     SSL_AD_REASON_OFFSET + alert_descr);            BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);            ERR_add_error_data(2, "SSL alert number ", tmp);            s->shutdown |= SSL_RECEIVED_SHUTDOWN;            SSL3_RECORD_set_read(rr);            SSL_CTX_remove_session(s->session_ctx, s->session);            return 0;        } else {            SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_DTLS1_READ_BYTES,                     SSL_R_UNKNOWN_ALERT_TYPE);            return -1;        }        goto start;    }    if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a                                            * shutdown */        s->rwstate = SSL_NOTHING;        SSL3_RECORD_set_length(rr, 0);

static int bio_read(BIO *bio, char *buf, int size_) {  size_t size = size_;  size_t rest;  struct bio_bio_st *b, *peer_b;  BIO_clear_retry_flags(bio);  if (!bio->init) {    return 0;  }  b = bio->ptr;  assert(b != NULL);  assert(b->peer != NULL);  peer_b = b->peer->ptr;  assert(peer_b != NULL);  assert(peer_b->buf != NULL);  peer_b->request = 0; /* will be set in "retry_read" situation */  if (buf == NULL || size == 0 || peer_b->zero_copy_read_lock) {    return 0;  }  if (peer_b->len == 0) {    if (peer_b->closed) {      return 0; /* writer has closed, and no data is left */    } else {      BIO_set_retry_read(bio); /* buffer is empty */      if (size <= peer_b->size) {        peer_b->request = size;      } else {        /* don't ask for more than the peer can         * deliver in one write */        peer_b->request = peer_b->size;      }      return -1;    }  }  /* we can read */  if (peer_b->len < size) {    size = peer_b->len;  }  /* now read "size" bytes */  rest = size;  assert(rest > 0);  /* one or two iterations */  do {    size_t chunk;    assert(rest <= peer_b->len);    if (peer_b->offset + rest <= peer_b->size) {      chunk = rest;    } else {      /* wrap around ring buffer */      chunk = peer_b->size - peer_b->offset;    }    assert(peer_b->offset + chunk <= peer_b->size);    memcpy(buf, peer_b->buf + peer_b->offset, chunk);    peer_b->len -= chunk;    /* If zero_copy_write_lock == 1 we must advance the offset even if buffer     * becomes empty, to make sure write_offset = (offset + len) % size     * does not change. */    if (peer_b->len || peer_b->zero_copy_write_lock) {      peer_b->offset += chunk;      assert(peer_b->offset <= peer_b->size);      if (peer_b->offset == peer_b->size) {        peer_b->offset = 0;      }      buf += chunk;    } else {      /* buffer now empty, no need to advance "buf" */      assert(chunk == rest);      peer_b->offset = 0;    }    rest -= chunk;  } while (rest);  return size;}

int bio_ber_get_header(BIO *bio, BIO_BER_CTX *ctx)	{	char buf[64];	int i,j,n;	int ret;	unsigned char *p;	unsigned long length	int tag;	int class;	long max;	BIO_clear_retry_flags(b);	/* Pack the buffer down if there is a hole at the front */	if (ctx->buf_off != 0)		{		p=ctx->buf;		j=ctx->buf_off;		n=ctx->buf_len-j;		for (i=0; i<n; i++)			{			p[0]=p[j];			p++;			}		ctx->buf_len-j;		ctx->buf_off=0;		}	/* If there is more room, read some more data */	i=BER_BUF_SIZE-ctx->buf_len;	if (i)		{		i=BIO_read(bio->next_bio,&(ctx->buf[ctx->buf_len]),i);		if (i <= 0)			{			BIO_copy_next_retry(b);			return(i);			}		else			ctx->buf_len+=i;		}	max=ctx->buf_len;	p=ctx->buf;	ret=ASN1_get_object(&p,&length,&tag,&class,max);	if (ret & 0x80)		{		if ((ctx->buf_len < BER_BUF_SIZE) &&			(ERR_GET_REASON(ERR_peek_error()) == ASN1_R_TOO_LONG))			{			ERR_clear_error(); /* clear the error */			BIO_set_retry_read(b);			}		return(-1);		}	/* We have no error, we have a header, so make use of it */	if ((ctx->tag  >= 0) && (ctx->tag != tag))		{		BIOerr(BIO_F_BIO_BER_GET_HEADER,BIO_R_TAG_MISMATCH);		sprintf(buf,"tag=%d, got %d",ctx->tag,tag);		ERR_add_error_data(1,buf);		return(-1);		}	if (ret & 0x01)	if (ret & V_ASN1_CONSTRUCTED)	}

static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes){    int ret = 1;    BIO_SSL *sb;    SSL *ssl;    int retry_reason = 0;    int r = 0;    if (buf == NULL)        return 0;    sb = BIO_get_data(b);    ssl = sb->ssl;    BIO_clear_retry_flags(b);    ret = ssl_read_internal(ssl, buf, size, readbytes);    switch (SSL_get_error(ssl, ret)) {    case SSL_ERROR_NONE:        if (sb->renegotiate_count > 0) {            sb->byte_count += *readbytes;            if (sb->byte_count > sb->renegotiate_count) {                sb->byte_count = 0;                sb->num_renegotiates++;                SSL_renegotiate(ssl);                r = 1;            }        }        if ((sb->renegotiate_timeout > 0) && (!r)) {            unsigned long tm;            tm = (unsigned long)time(NULL);            if (tm > sb->last_time + sb->renegotiate_timeout) {                sb->last_time = tm;                sb->num_renegotiates++;                SSL_renegotiate(ssl);            }        }        break;    case SSL_ERROR_WANT_READ:        BIO_set_retry_read(b);        break;    case SSL_ERROR_WANT_WRITE:        BIO_set_retry_write(b);        break;    case SSL_ERROR_WANT_X509_LOOKUP:        BIO_set_retry_special(b);        retry_reason = BIO_RR_SSL_X509_LOOKUP;        break;    case SSL_ERROR_WANT_ACCEPT:        BIO_set_retry_special(b);        retry_reason = BIO_RR_ACCEPT;        break;    case SSL_ERROR_WANT_CONNECT:        BIO_set_retry_special(b);        retry_reason = BIO_RR_CONNECT;        break;    case SSL_ERROR_SYSCALL:    case SSL_ERROR_SSL:    case SSL_ERROR_ZERO_RETURN:    default:        break;    }    BIO_set_retry_reason(b, retry_reason);    return ret;}

static int bio_read(BIO *bio, char *buf, int size_)	{	size_t size = size_;	size_t rest;	struct bio_bio_st *b, *peer_b;	BIO_clear_retry_flags(bio);	if (!bio->init)		return 0;	b = bio->ptr;	assert(b != NULL);	assert(b->peer != NULL);	peer_b = b->peer->ptr;	assert(peer_b != NULL);	assert(peer_b->buf != NULL);	peer_b->request = 0; /* will be set in "retry_read" situation */	if (buf == NULL || size == 0)		return 0;	if (peer_b->len == 0)		{		if (peer_b->closed)			return 0; /* writer has closed, and no data is left */		else			{			BIO_set_retry_read(bio); /* buffer is empty */			if (size <= peer_b->size)				peer_b->request = size;			else				/* don't ask for more than the peer can				 * deliver in one write */				peer_b->request = peer_b->size;			return -1;			}		}	/* we can read */	if (peer_b->len < size)		size = peer_b->len;	/* now read "size" bytes */	rest = size;	assert(rest > 0);	do /* one or two iterations */		{		size_t chunk;		assert(rest <= peer_b->len);		if (peer_b->offset + rest <= peer_b->size)			chunk = rest;		else			/* wrap around ring buffer */			chunk = peer_b->size - peer_b->offset;		assert(peer_b->offset + chunk <= peer_b->size);		memcpy(buf, peer_b->buf + peer_b->offset, chunk);		peer_b->len -= chunk;		if (peer_b->len)			{			peer_b->offset += chunk;			assert(peer_b->offset <= peer_b->size);			if (peer_b->offset == peer_b->size)				peer_b->offset = 0;			buf += chunk;			}		else			{			/* buffer now empty, no need to advance "buf" */			assert(chunk == rest);			peer_b->offset = 0;			}		rest -= chunk;		}	while (rest);	return size;	}

//.........这里部分代码省略.........					OPENSSL_assert(i >= 0);#endif					}#ifdef SCTP_AUTHENTICATION_EVENT				if (snp->sn_header.sn_type == SCTP_AUTHENTICATION_EVENT)					dgram_sctp_handle_auth_free_key_event(b, snp);#endif				if (data->handle_notifications != NULL)					data->handle_notifications(b, data->notification_context, (void*) out);				memset(out, 0, outl);				}			else				ret += n;			}		while ((msg.msg_flags & MSG_NOTIFICATION) && (msg.msg_flags & MSG_EOR) && (ret < outl));		if (ret > 0 && !(msg.msg_flags & MSG_EOR))			{			/* Partial message read, this should never happen! */			/* The buffer was too small, this means the peer sent			 * a message that was larger than allowed. */			if (ret == outl)				return -1;			/* Test if socket buffer can handle max record			 * size (2^14 + 2048 + 13)			 */			optlen = (socklen_t) sizeof(int);			ret = getsockopt(b->num, SOL_SOCKET, SO_RCVBUF, &optval, &optlen);			OPENSSL_assert(ret >= 0);			OPENSSL_assert(optval >= 18445);			/* Test if SCTP doesn't partially deliver below			 * max record size (2^14 + 2048 + 13)			 */			optlen = (socklen_t) sizeof(int);			ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT,			                 &optval, &optlen);			OPENSSL_assert(ret >= 0);			OPENSSL_assert(optval >= 18445);			/* Partially delivered notification??? Probably a bug.... */			OPENSSL_assert(!(msg.msg_flags & MSG_NOTIFICATION));			/* Everything seems ok till now, so it's most likely			 * a message dropped by PR-SCTP.			 */			memset(out, 0, outl);			BIO_set_retry_read(b);			return -1;			}		BIO_clear_retry_flags(b);		if (ret < 0)			{			if (BIO_dgram_should_retry(ret))				{				BIO_set_retry_read(b);				data->_errno = get_last_socket_error();				}			}		/* Test if peer uses SCTP-AUTH before continuing */		if (!data->peer_auth_tested)			{			int ii, auth_data = 0, auth_forward = 0;			unsigned char *p;			struct sctp_authchunks *authchunks;			optlen = (socklen_t)(sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));			authchunks = OPENSSL_malloc(optlen);			memset(authchunks, 0, sizeof(optlen));			ii = getsockopt(b->num, IPPROTO_SCTP, SCTP_PEER_AUTH_CHUNKS, authchunks, &optlen);			OPENSSL_assert(ii >= 0);			for (p = (unsigned char*) authchunks + sizeof(sctp_assoc_t);				 p < (unsigned char*) authchunks + optlen;				 p += sizeof(uint8_t))				{				if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) auth_data = 1;				if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) auth_forward = 1;				}			OPENSSL_free(authchunks);			if (!auth_data || !auth_forward)				{				BIOerr(BIO_F_DGRAM_SCTP_READ,BIO_R_CONNECT_ERROR);				return -1;				}			data->peer_auth_tested = 1;			}		}	return(ret);	}

//.........这里部分代码省略.........				s->d1->listen = 0;				/* Set expected sequence numbers				 * to continue the handshake.				 */				s->d1->handshake_read_seq = 2;				s->d1->handshake_write_seq = 1;				s->d1->next_handshake_write_seq = 1;				goto end;			}			break;		case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:		case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:			ret = dtls1_send_hello_verify_request(s);			if (ret <= 0)				goto end;			s->state = SSL3_ST_SW_FLUSH;			s->s3->tmp.next_state = SSL3_ST_SR_CLNT_HELLO_A;			/* HelloVerifyRequest resets Finished MAC */			if (s->version != DTLS1_BAD_VER)				ssl3_init_finished_mac(s);			break;#ifndef OPENSSL_NO_SCTP		case DTLS1_SCTP_ST_SR_READ_SOCK:			if (BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {				s->s3->in_read_app_data = 2;				s->rwstate = SSL_READING;				BIO_clear_retry_flags(SSL_get_rbio(s));				BIO_set_retry_read(SSL_get_rbio(s));				ret = -1;				goto end;			}			s->state = SSL3_ST_SR_FINISHED_A;			break;		case DTLS1_SCTP_ST_SW_WRITE_SOCK:			ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(s));			if (ret < 0)				goto end;			if (ret == 0) {				if (s->d1->next_state != SSL_ST_OK) {					s->s3->in_read_app_data = 2;					s->rwstate = SSL_READING;					BIO_clear_retry_flags(SSL_get_rbio(s));					BIO_set_retry_read(SSL_get_rbio(s));					ret = -1;					goto end;				}			}			s->state = s->d1->next_state;			break;#endif		case SSL3_ST_SW_SRVR_HELLO_A:		case SSL3_ST_SW_SRVR_HELLO_B:			s->renegotiate = 2;			dtls1_start_timer(s);			ret = dtls1_send_server_hello(s);

static int bio_read(BIO *bio, char *buf, int size_) {  size_t size = size_;  size_t rest;  struct bio_bio_st *b, *peer_b;  BIO_clear_retry_flags(bio);  if (!bio->init) {    return 0;  }  b = bio->ptr;  assert(b != NULL);  assert(b->peer != NULL);  peer_b = b->peer->ptr;  assert(peer_b != NULL);  assert(peer_b->buf != NULL);  peer_b->request = 0;  // will be set in "retry_read" situation  if (buf == NULL || size == 0) {    return 0;  }  if (peer_b->len == 0) {    if (peer_b->closed) {      return 0;  // writer has closed, and no data is left    } else {      BIO_set_retry_read(bio);  // buffer is empty      if (size <= peer_b->size) {        peer_b->request = size;      } else {        // don't ask for more than the peer can        // deliver in one write        peer_b->request = peer_b->size;      }      return -1;    }  }  // we can read  if (peer_b->len < size) {    size = peer_b->len;  }  // now read "size" bytes  rest = size;  assert(rest > 0);  // one or two iterations  do {    size_t chunk;    assert(rest <= peer_b->len);    if (peer_b->offset + rest <= peer_b->size) {      chunk = rest;    } else {      // wrap around ring buffer      chunk = peer_b->size - peer_b->offset;    }    assert(peer_b->offset + chunk <= peer_b->size);    OPENSSL_memcpy(buf, peer_b->buf + peer_b->offset, chunk);    peer_b->len -= chunk;    if (peer_b->len) {      peer_b->offset += chunk;      assert(peer_b->offset <= peer_b->size);      if (peer_b->offset == peer_b->size) {        peer_b->offset = 0;      }      buf += chunk;    } else {      // buffer now empty, no need to advance "buf"      assert(chunk == rest);      peer_b->offset = 0;    }    rest -= chunk;  } while (rest);  return size;}

static int ssl_read(BIO *b, char *out, int outl)	{	int ret=1;	BIO_SSL *sb;	SSL *ssl;	int retry_reason=0;	int r=0;	if (out == NULL) return(0);	sb=(BIO_SSL *)b->ptr;	ssl=sb->ssl;	BIO_clear_retry_flags(b);#if 0	if (!SSL_is_init_finished(ssl))		{/*		ret=SSL_do_handshake(ssl); */		if (ret > 0)			{			outflags=(BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY);			ret= -1;			goto end;			}		}#endif/*	if (ret > 0) */	ret=SSL_read(ssl,out,outl);	switch (SSL_get_error(ssl,ret))		{	case SSL_ERROR_NONE:		if (ret <= 0) break;		if (sb->renegotiate_count > 0)			{			sb->byte_count+=ret;			if (sb->byte_count > sb->renegotiate_count)				{				sb->byte_count=0;				sb->num_renegotiates++;				SSL_renegotiate(ssl);				r=1;				}			}		if ((sb->renegotiate_timeout > 0) && (!r))			{			unsigned long tm;			tm=(unsigned long)time(NULL);			if (tm > sb->last_time+sb->renegotiate_timeout)				{				sb->last_time=tm;				sb->num_renegotiates++;				SSL_renegotiate(ssl);				}			}		break;	case SSL_ERROR_WANT_READ:		BIO_set_retry_read(b);		break;	case SSL_ERROR_WANT_WRITE:		BIO_set_retry_write(b);		break;	case SSL_ERROR_WANT_X509_LOOKUP:		BIO_set_retry_special(b);		retry_reason=BIO_RR_SSL_X509_LOOKUP;		break;	case SSL_ERROR_WANT_ACCEPT:		BIO_set_retry_special(b);		retry_reason=BIO_RR_ACCEPT;		break;	case SSL_ERROR_WANT_CONNECT:		BIO_set_retry_special(b);		retry_reason=BIO_RR_CONNECT;		break;	case SSL_ERROR_SYSCALL:	case SSL_ERROR_SSL:	case SSL_ERROR_ZERO_RETURN:	default:		break;		}	b->retry_reason=retry_reason;	return(ret);	}

static int ssl_write(BIO *b, const char *out, int outl)	{	int ret,r=0;	int retry_reason=0;	SSL *ssl;	BIO_SSL *bs;	if (out == NULL) return(0);	bs=(BIO_SSL *)b->ptr;	ssl=bs->ssl;	BIO_clear_retry_flags(b);/*	ret=SSL_do_handshake(ssl);	if (ret > 0) */	ret=SSL_write(ssl,out,outl);	switch (SSL_get_error(ssl,ret))		{	case SSL_ERROR_NONE:		if (ret <= 0) break;		if (bs->renegotiate_count > 0)			{			bs->byte_count+=ret;			if (bs->byte_count > bs->renegotiate_count)				{				bs->byte_count=0;				bs->num_renegotiates++;				SSL_renegotiate(ssl);				r=1;				}			}		if ((bs->renegotiate_timeout > 0) && (!r))			{			unsigned long tm;			tm=(unsigned long)time(NULL);			if (tm > bs->last_time+bs->renegotiate_timeout)				{				bs->last_time=tm;				bs->num_renegotiates++;				SSL_renegotiate(ssl);				}			}		break;	case SSL_ERROR_WANT_WRITE:		BIO_set_retry_write(b);		break;	case SSL_ERROR_WANT_READ:		BIO_set_retry_read(b);		break;	case SSL_ERROR_WANT_X509_LOOKUP:		BIO_set_retry_special(b);		retry_reason=BIO_RR_SSL_X509_LOOKUP;		break;	case SSL_ERROR_WANT_CONNECT:		BIO_set_retry_special(b);		retry_reason=BIO_RR_CONNECT;	case SSL_ERROR_SYSCALL:	case SSL_ERROR_SSL:	default:		break;		}	b->retry_reason=retry_reason;	return(ret);	}

static int mempacket_test_read(BIO *bio, char *out, int outl){    MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);    MEMPACKET *thispkt;    unsigned char *rec;    int rem;    unsigned int seq, offset, len, epoch;    BIO_clear_retry_flags(bio);    thispkt = sk_MEMPACKET_value(ctx->pkts, 0);    if (thispkt == NULL || thispkt->num != ctx->currpkt) {        /* Probably run out of data */        BIO_set_retry_read(bio);        return -1;    }    (void)sk_MEMPACKET_shift(ctx->pkts);    ctx->currpkt++;    if (outl > thispkt->len)        outl = thispkt->len;    if (thispkt->type != INJECT_PACKET_IGNORE_REC_SEQ            && (ctx->injected || ctx->droprec >= 0)) {        /*         * Overwrite the record sequence number. We strictly number them in         * the order received. Since we are actually a reliable transport         * we know that there won't be any re-ordering. We overwrite to deal         * with any packets that have been injected         */        for (rem = thispkt->len, rec = thispkt->data; rem > 0; rem -= len) {            if (rem < DTLS1_RT_HEADER_LENGTH)                return -1;            epoch = (rec[EPOCH_HI] << 8) | rec[EPOCH_LO];            if (epoch != ctx->epoch) {                ctx->epoch = epoch;                ctx->currrec = 0;            }            seq = ctx->currrec;            offset = 0;            do {                rec[RECORD_SEQUENCE - offset] = seq & 0xFF;                seq >>= 8;                offset++;            } while (seq > 0);            len = ((rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO])                  + DTLS1_RT_HEADER_LENGTH;            if (rem < (int)len)                return -1;            if (ctx->droprec == (int)ctx->currrec && ctx->dropepoch == epoch) {                if (rem > (int)len)                    memmove(rec, rec + len, rem - len);                outl -= len;                ctx->droprec = -1;                if (outl == 0)                    BIO_set_retry_read(bio);            } else {                rec += len;            }            ctx->currrec++;        }    }    memcpy(out, thispkt->data, outl);    mempacket_free(thispkt);    return outl;}

//.........这里部分代码省略.........				if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))					{					ret= -1;					goto end;					}				s->init_buf=buf;				buf=NULL;				}			if (!ssl3_setup_buffers(s)) { ret= -1; goto end; }			/* setup buffing BIO */			if (!ssl_init_wbio_buffer(s,0)) { ret= -1; goto end; }			/* don't push the buffering BIO quite yet */			s->state=SSL3_ST_CW_CLNT_HELLO_A;			s->ctx->stats.sess_connect++;			s->init_num=0;			/* mark client_random uninitialized */			memset(s->s3->client_random,0,sizeof(s->s3->client_random));			s->d1->send_cookie = 0;			s->hit = 0;			break;#ifndef OPENSSL_NO_SCTP		case DTLS1_SCTP_ST_CR_READ_SOCK:			if (BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)))			{				s->s3->in_read_app_data=2;				s->rwstate=SSL_READING;				BIO_clear_retry_flags(SSL_get_rbio(s));				BIO_set_retry_read(SSL_get_rbio(s));				ret = -1;				goto end;			}			s->state=s->s3->tmp.next_state;			break;		case DTLS1_SCTP_ST_CW_WRITE_SOCK:			/* read app data until dry event */			ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(s));			if (ret < 0) goto end;			if (ret == 0)			{				s->s3->in_read_app_data=2;				s->rwstate=SSL_READING;				BIO_clear_retry_flags(SSL_get_rbio(s));				BIO_set_retry_read(SSL_get_rbio(s));				ret = -1;				goto end;			}			s->state=s->d1->next_state;			break;#endif		case SSL3_ST_CW_CLNT_HELLO_A:		case SSL3_ST_CW_CLNT_HELLO_B:			s->shutdown=0;

//.........这里部分代码省略.........     * If we get here, then type != rr->type; if we have a handshake message,     * then it was unexpected (Hello Request or Client Hello).     */    /*     * In case of record types for which we have 'fragment' storage, fill     * that so that we can process the data at a fixed place.     */    {        unsigned int k, dest_maxlen = 0;        unsigned char *dest = NULL;        unsigned int *dest_len = NULL;        if (SSL3_RECORD_get_type(rr) == SSL3_RT_HANDSHAKE) {            dest_maxlen = sizeof s->rlayer.d->handshake_fragment;            dest = s->rlayer.d->handshake_fragment;            dest_len = &s->rlayer.d->handshake_fragment_len;        } else if (SSL3_RECORD_get_type(rr) == SSL3_RT_ALERT) {            dest_maxlen = sizeof(s->rlayer.d->alert_fragment);            dest = s->rlayer.d->alert_fragment;            dest_len = &s->rlayer.d->alert_fragment_len;        }#ifndef OPENSSL_NO_HEARTBEATS        else if (SSL3_RECORD_get_type(rr) == DTLS1_RT_HEARTBEAT) {            /* We allow a 0 return */            if (dtls1_process_heartbeat(s, SSL3_RECORD_get_data(rr),                                        SSL3_RECORD_get_length(rr)) < 0) {                return -1;            }            /* Exit and notify application to read again */            SSL3_RECORD_set_length(rr, 0);            s->rwstate = SSL_READING;            BIO_clear_retry_flags(SSL_get_rbio(s));            BIO_set_retry_read(SSL_get_rbio(s));            return (-1);        }#endif        /* else it's a CCS message, or application data or wrong */        else if (SSL3_RECORD_get_type(rr) != SSL3_RT_CHANGE_CIPHER_SPEC) {            /*             * Application data while renegotiating is allowed. Try again             * reading.             */            if (SSL3_RECORD_get_type(rr) == SSL3_RT_APPLICATION_DATA) {                BIO *bio;                s->s3->in_read_app_data = 2;                bio = SSL_get_rbio(s);                s->rwstate = SSL_READING;                BIO_clear_retry_flags(bio);                BIO_set_retry_read(bio);                return (-1);            }            /* Not certain if this is the right error handling */            al = SSL_AD_UNEXPECTED_MESSAGE;            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD);            goto f_err;        }        if (dest_maxlen > 0) {            /*             * XDTLS: In a pathological case, the Client Hello may be             * fragmented--don't always expect dest_maxlen bytes             */            if (SSL3_RECORD_get_length(rr) < dest_maxlen) {#ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE

//.........这里部分代码省略.........				s->d1->listen = 0;				/* Set expected sequence numbers				 * to continue the handshake.				 */				s->d1->handshake_read_seq = 2;				s->d1->handshake_write_seq = 1;				s->d1->next_handshake_write_seq = 1;				goto end;				}						break;					case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:		case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:			ret = dtls1_send_hello_verify_request(s);			if ( ret <= 0) goto end;			s->state=SSL3_ST_SW_FLUSH;			s->s3->tmp.next_state=SSL3_ST_SR_CLNT_HELLO_A;			/* HelloVerifyRequest resets Finished MAC */			if (s->version != DTLS1_BAD_VER)				ssl3_init_finished_mac(s);			break;			#ifndef OPENSSL_NO_SCTP		case DTLS1_SCTP_ST_SR_READ_SOCK:						if (BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)))						{				s->s3->in_read_app_data=2;				s->rwstate=SSL_READING;				BIO_clear_retry_flags(SSL_get_rbio(s));				BIO_set_retry_read(SSL_get_rbio(s));				ret = -1;				goto end;				}						s->state=SSL3_ST_SR_FINISHED_A;			break;					case DTLS1_SCTP_ST_SW_WRITE_SOCK:			ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(s));			if (ret < 0) goto end;						if (ret == 0)				{				if (s->d1->next_state != SSL_ST_OK)					{					s->s3->in_read_app_data=2;					s->rwstate=SSL_READING;					BIO_clear_retry_flags(SSL_get_rbio(s));					BIO_set_retry_read(SSL_get_rbio(s));					ret = -1;					goto end;					}				}			s->state=s->d1->next_state;			break;#endif		case SSL3_ST_SW_SRVR_HELLO_A:		case SSL3_ST_SW_SRVR_HELLO_B:			s->renegotiate = 2;			dtls1_start_timer(s);

static int ssl_write(BIO *b, const char *buf, size_t size, size_t *written){    int ret, r = 0;    int retry_reason = 0;    SSL *ssl;    BIO_SSL *bs;    if (buf == NULL)        return 0;    bs = BIO_get_data(b);    ssl = bs->ssl;    BIO_clear_retry_flags(b);    ret = ssl_write_internal(ssl, buf, size, written);    switch (SSL_get_error(ssl, ret)) {    case SSL_ERROR_NONE:        if (bs->renegotiate_count > 0) {            bs->byte_count += *written;            if (bs->byte_count > bs->renegotiate_count) {                bs->byte_count = 0;                bs->num_renegotiates++;                SSL_renegotiate(ssl);                r = 1;            }        }        if ((bs->renegotiate_timeout > 0) && (!r)) {            unsigned long tm;            tm = (unsigned long)time(NULL);            if (tm > bs->last_time + bs->renegotiate_timeout) {                bs->last_time = tm;                bs->num_renegotiates++;                SSL_renegotiate(ssl);            }        }        break;    case SSL_ERROR_WANT_WRITE:        BIO_set_retry_write(b);        break;    case SSL_ERROR_WANT_READ:        BIO_set_retry_read(b);        break;    case SSL_ERROR_WANT_X509_LOOKUP:        BIO_set_retry_special(b);        retry_reason = BIO_RR_SSL_X509_LOOKUP;        break;    case SSL_ERROR_WANT_CONNECT:        BIO_set_retry_special(b);        retry_reason = BIO_RR_CONNECT;    case SSL_ERROR_SYSCALL:    case SSL_ERROR_SSL:    default:        break;    }    BIO_set_retry_reason(b, retry_reason);    return ret;}