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

static long nullf_ctrl(BIO *b, int cmd, long num, void *ptr){    long ret;    if (b->next_bio == NULL)        return 0;    switch (cmd) {    case BIO_C_DO_STATE_MACHINE:        BIO_clear_retry_flags(b);        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        BIO_copy_next_retry(b);        break;    case BIO_CTRL_DUP:        ret = 0L;        break;    default:        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);    }    return ret;}

static int acpt_write (BIO * b, const char *in, int inl){    int ret;    BIO_ACCEPT *data;    BIO_clear_retry_flags (b);    data = (BIO_ACCEPT *) b->ptr;    while (b->next_bio == NULL)    {        ret = acpt_state (b, data);        if (ret <= 0)            return (ret);    }    ret = BIO_write (b->next_bio, in, inl);    BIO_copy_next_retry (b);    return (ret);}

static int acpt_read (BIO * b, char *out, int outl){    int ret = 0;    BIO_ACCEPT *data;    BIO_clear_retry_flags (b);    data = (BIO_ACCEPT *) b->ptr;    while (b->next_bio == NULL)    {        ret = acpt_state (b, data);        if (ret <= 0)            return (ret);    }    ret = BIO_read (b->next_bio, out, outl);    BIO_copy_next_retry (b);    return (ret);}

int proxy_read(BIO *b, char *buf, int sz){  int r;  struct proxy_ctx *ctx = (struct proxy_ctx *) b->ptr;  assert(buf);  if (!b->next_bio)    return 0;  if (!ctx->connected) {    assert(ctx->connect);    if (!ctx->connect(b))      return 0;  }  r = BIO_read(b->next_bio, buf, sz);  BIO_clear_retry_flags(b);  BIO_copy_next_retry(b);  return r;}

static int md_write(BIO *b, const char *in, int inl)	{	int ret=0;	EVP_MD_CTX *ctx;	if ((in == NULL) || (inl <= 0)) return(0);	ctx=b->ptr;	if ((ctx != NULL) && (b->next_bio != NULL))		ret=BIO_write(b->next_bio,in,inl);	if (b->init)		{		if (ret > 0)			{			EVP_DigestUpdate(ctx,(unsigned char *)in,				(unsigned int)ret);			}		}	BIO_clear_retry_flags(b);	BIO_copy_next_retry(b);	return(ret);	}

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 (nt->lwn > 0) {        num = nt->lwn;        nt->lwn = 0;    } else {        if (RAND_bytes(&n, 1) <= 0)            return -1;        num = (n & 7);    }    if (inl > num)        inl = num;    if (num == 0) {        ret = -1;        BIO_set_retry_write(b);    } else {        ret = BIO_write(b->next_bio, in, inl);        if (ret < 0) {            BIO_copy_next_retry(b);            nt->lwn = inl;        }    }    return (ret);}

long proxy_ctrl(BIO *b, int cmd, long num, void *ptr){  long ret;  struct proxy_ctx *ctx;  if (!b->next_bio)    return 0;  ctx = (struct proxy_ctx *) b->ptr;  assert(ctx);  switch (cmd) {  case BIO_C_DO_STATE_MACHINE:    BIO_clear_retry_flags(b);    ret = BIO_ctrl(b->next_bio, cmd, num, ptr);    BIO_copy_next_retry(b);    break;  case BIO_CTRL_DUP:    ret = 0;    break;  default:    ret = BIO_ctrl(b->next_bio, cmd, num, ptr);  }  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 intbuffer_read(BIO *b, char *out, int outl){	int i, num = 0;	BIO_F_BUFFER_CTX *ctx;	if (out == NULL)		return (0);	ctx = (BIO_F_BUFFER_CTX *)b->ptr;	if ((ctx == NULL) || (b->next_bio == NULL))		return (0);	num = 0;	BIO_clear_retry_flags(b);start:	i = ctx->ibuf_len;	/* If there is stuff left over, grab it */	if (i != 0) {		if (i > outl)			i = outl;		memcpy(out, &(ctx->ibuf[ctx->ibuf_off]), i);		ctx->ibuf_off += i;		ctx->ibuf_len -= i;		num += i;		if (outl == i)			return (num);		outl -= i;		out += i;	}	/* We may have done a partial read. try to do more.	 * We have nothing in the buffer.	 * If we get an error and have read some data, just return it	 * and let them retry to get the error again.	 * copy direct to parent address space */	if (outl > ctx->ibuf_size) {		for (;;) {			i = BIO_read(b->next_bio, out, outl);			if (i <= 0) {				BIO_copy_next_retry(b);				if (i < 0)					return ((num > 0) ? num : i);				if (i == 0)					return (num);			}			num += i;			if (outl == i)				return (num);			out += i;			outl -= i;		}	}	/* else */	/* we are going to be doing some buffering */	i = BIO_read(b->next_bio, ctx->ibuf, ctx->ibuf_size);	if (i <= 0) {		BIO_copy_next_retry(b);		if (i < 0)			return ((num > 0) ? num : i);		if (i == 0)			return (num);	}	ctx->ibuf_off = 0;	ctx->ibuf_len = i;	/* Lets re-read using ourselves :-) */	goto start;}

static int crlfbuffer_read(BIO *b, char *out, int outl)	{	int ret=0;	BIO_CRLFBUFFER_CTX *ctx; 	if (out == NULL) return(0);	if (b->next_bio == NULL) return(0);	ctx=(BIO_CRLFBUFFER_CTX *)b->ptr;		// First copy what's in the current buffer	int i = ctx->ibuf_len;	if (i != 0)	{		if (i > outl)			i = outl;		memcpy(out, &(ctx->ibuf[ctx->ibuf_off]), i);		ctx->ibuf_off += i;		ctx->ibuf_len -= i;		ret += i;		outl -= i;		out += i;	}	// Now read any remaining direct from source	if (outl > 0)		ret += BIO_read(b->next_bio,out,outl);	BIO_clear_retry_flags(b);	BIO_copy_next_retry(b);	if (ret > 0)	{		BIO_CRLFBUFFER_CTX *new_ctx = (BIO_CRLFBUFFER_CTX *)b->ptr;		char *p = out;		char *q = out;		int qlen = 0;		int plen = ret;		while(plen > 0)		{			if (*p == '/r')			{				p++;				plen--;				*q++ = '/n';				qlen++;				new_ctx->got_cr = true;			}			else if (*p == '/n')			{				p++;				plen--;				if (!new_ctx->got_cr)				{					*q++ = '/n';					qlen++;				}				new_ctx->got_cr = false;			}			else			{				*q++ = *p++;				plen--;				qlen++;				new_ctx->got_cr = false;			}		}		*q++ = 0;		ret = qlen;	}	return(ret);	}

static int asn1_bio_write(BIO *b, const char *in, int inl){    BIO_ASN1_BUF_CTX *ctx;    int wrmax, wrlen, ret;    unsigned char *p;    if (!in || (inl < 0) || (b->next_bio == NULL))        return 0;    ctx = (BIO_ASN1_BUF_CTX *)b->ptr;    if (ctx == NULL)        return 0;    wrlen = 0;    ret = -1;    for (;;) {        switch (ctx->state) {            /* Setup prefix data, call it */        case ASN1_STATE_START:            if (!asn1_bio_setup_ex(b, ctx, ctx->prefix,                                   ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER))                return 0;            break;            /* Copy any pre data first */        case ASN1_STATE_PRE_COPY:            ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free,                                    ASN1_STATE_HEADER);            if (ret <= 0)                goto done;            break;        case ASN1_STATE_HEADER:            ctx->buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl;            OPENSSL_assert(ctx->buflen <= ctx->bufsize);            p = ctx->buf;            ASN1_put_object(&p, 0, inl, ctx->asn1_tag, ctx->asn1_class);            ctx->copylen = inl;            ctx->state = ASN1_STATE_HEADER_COPY;            break;        case ASN1_STATE_HEADER_COPY:            ret = BIO_write(b->next_bio, ctx->buf + ctx->bufpos, ctx->buflen);            if (ret <= 0)                goto done;            ctx->buflen -= ret;            if (ctx->buflen)                ctx->bufpos += ret;            else {                ctx->bufpos = 0;                ctx->state = ASN1_STATE_DATA_COPY;            }            break;        case ASN1_STATE_DATA_COPY:            if (inl > ctx->copylen)                wrmax = ctx->copylen;            else                wrmax = inl;            ret = BIO_write(b->next_bio, in, wrmax);            if (ret <= 0)                break;            wrlen += ret;            ctx->copylen -= ret;            in += ret;            inl -= ret;            if (ctx->copylen == 0)                ctx->state = ASN1_STATE_HEADER;            if (inl == 0)                goto done;            break;        default:            BIO_clear_retry_flags(b);            return 0;        }    } done:    BIO_clear_retry_flags(b);    BIO_copy_next_retry(b);    return (wrlen > 0) ? wrlen : ret;}

static long bio_zlib_ctrl(BIO *b, int cmd, long num, void *ptr){    BIO_ZLIB_CTX *ctx;    int ret, *ip;    int ibs, obs;    if (!b->next_bio)        return 0;    ctx = (BIO_ZLIB_CTX *) b->ptr;    switch (cmd) {    case BIO_CTRL_RESET:        ctx->ocount = 0;        ctx->odone = 0;        ret = 1;        break;    case BIO_CTRL_FLUSH:        ret = bio_zlib_flush(b);        if (ret > 0)            ret = BIO_flush(b->next_bio);        break;    case BIO_C_SET_BUFF_SIZE:        ibs = -1;        obs = -1;        if (ptr != NULL) {            ip = ptr;            if (*ip == 0)                ibs = (int)num;            else                obs = (int)num;        } else {            ibs = (int)num;            obs = ibs;        }        if (ibs != -1) {            OPENSSL_free(ctx->ibuf);            ctx->ibuf = NULL;            ctx->ibufsize = ibs;        }        if (obs != -1) {            OPENSSL_free(ctx->obuf);            ctx->obuf = NULL;            ctx->obufsize = obs;        }        ret = 1;        break;    case BIO_C_DO_STATE_MACHINE:        BIO_clear_retry_flags(b);        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        BIO_copy_next_retry(b);        break;    default:        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        break;    }    return ret;}

static int bio_zlib_write(BIO *b, const char *in, int inl){    BIO_ZLIB_CTX *ctx;    int ret;    z_stream *zout;    if (!in || !inl)        return 0;    ctx = (BIO_ZLIB_CTX *) b->ptr;    if (ctx->odone)        return 0;    zout = &ctx->zout;    BIO_clear_retry_flags(b);    if (!ctx->obuf) {        ctx->obuf = OPENSSL_malloc(ctx->obufsize);        /* Need error here */        if (!ctx->obuf) {            COMPerr(COMP_F_BIO_ZLIB_WRITE, ERR_R_MALLOC_FAILURE);            return 0;        }        ctx->optr = ctx->obuf;        ctx->ocount = 0;        deflateInit(zout, ctx->comp_level);        zout->next_out = ctx->obuf;        zout->avail_out = ctx->obufsize;    }    /* Obtain input data directly from supplied buffer */    zout->next_in = (void *)in;    zout->avail_in = inl;    for (;;) {        /* If data in output buffer write it first */        while (ctx->ocount) {            ret = BIO_write(b->next_bio, ctx->optr, ctx->ocount);            if (ret <= 0) {                /* Total data written */                int tot = inl - zout->avail_in;                BIO_copy_next_retry(b);                if (ret < 0)                    return (tot > 0) ? tot : ret;                return tot;            }            ctx->optr += ret;            ctx->ocount -= ret;        }        /* Have we consumed all supplied data? */        if (!zout->avail_in)            return inl;        /* Compress some more */        /* Reset buffer */        ctx->optr = ctx->obuf;        zout->next_out = ctx->obuf;        zout->avail_out = ctx->obufsize;        /* Compress some more */        ret = deflate(zout, 0);        if (ret != Z_OK) {            COMPerr(COMP_F_BIO_ZLIB_WRITE, COMP_R_ZLIB_DEFLATE_ERROR);            ERR_add_error_data(2, "zlib error:", zError(ret));            return 0;        }        ctx->ocount = ctx->obufsize - zout->avail_out;    }}

static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)	{	SSL **sslp,*ssl;	BIO_SSL *bs;	BIO *dbio,*bio;	long ret=1;	bs=(BIO_SSL *)b->ptr;	ssl=bs->ssl;	if ((ssl == NULL)  && (cmd != BIO_C_SET_SSL))		return(0);	switch (cmd)		{	case BIO_CTRL_RESET:		SSL_shutdown(ssl);		if (ssl->handshake_func == ssl->method->ssl_connect)			SSL_set_connect_state(ssl);		else if (ssl->handshake_func == ssl->method->ssl_accept)			SSL_set_accept_state(ssl);		SSL_clear(ssl);		if (b->next_bio != NULL)			ret=BIO_ctrl(b->next_bio,cmd,num,ptr);		else if (ssl->rbio != NULL)			ret=BIO_ctrl(ssl->rbio,cmd,num,ptr);		else			ret=1;		break;	case BIO_CTRL_INFO:		ret=0;		break;	case BIO_C_SSL_MODE:		if (num) /* client mode */			SSL_set_connect_state(ssl);		else			SSL_set_accept_state(ssl);		break;	case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT:		ret=bs->renegotiate_timeout;		if (num < 60) num=5;		bs->renegotiate_timeout=(unsigned long)num;		bs->last_time=(unsigned long)time(NULL);		break;	case BIO_C_SET_SSL_RENEGOTIATE_BYTES:		ret=bs->renegotiate_count;		if ((long)num >=512)			bs->renegotiate_count=(unsigned long)num;		break;	case BIO_C_GET_SSL_NUM_RENEGOTIATES:		ret=bs->num_renegotiates;		break;	case BIO_C_SET_SSL:		if (ssl != NULL)			{			ssl_free(b);			if (!ssl_new(b))				return 0;			}		b->shutdown=(int)num;		ssl=(SSL *)ptr;		((BIO_SSL *)b->ptr)->ssl=ssl;		bio=SSL_get_rbio(ssl);		if (bio != NULL)			{			if (b->next_bio != NULL)				BIO_push(bio,b->next_bio);			b->next_bio=bio;			CRYPTO_add(&bio->references,1,CRYPTO_LOCK_BIO);			}		b->init=1;		break;	case BIO_C_GET_SSL:		if (ptr != NULL)			{			sslp=(SSL **)ptr;			*sslp=ssl;			}		else			ret=0;		break;	case BIO_CTRL_GET_CLOSE:		ret=b->shutdown;		break;	case BIO_CTRL_SET_CLOSE:		b->shutdown=(int)num;		break;	case BIO_CTRL_WPENDING:		ret=BIO_ctrl(ssl->wbio,cmd,num,ptr);		break;	case BIO_CTRL_PENDING:		ret=SSL_pending(ssl);		if (ret == 0)			ret=BIO_pending(ssl->rbio);		break;	case BIO_CTRL_FLUSH:		BIO_clear_retry_flags(b);		ret=BIO_ctrl(ssl->wbio,cmd,num,ptr);		BIO_copy_next_retry(b);//.........这里部分代码省略.........

static int ok_write(BIO *b, const char *in, int inl){    int ret = 0, n, i;    BIO_OK_CTX *ctx;    if (inl <= 0)        return inl;    ctx = (BIO_OK_CTX *)b->ptr;    ret = inl;    if ((ctx == NULL) || (b->next_bio == NULL) || (b->init == 0))        return (0);    if (ctx->sigio && !sig_out(b))        return 0;    do {        BIO_clear_retry_flags(b);        n = ctx->buf_len - ctx->buf_off;        while (ctx->blockout && n > 0) {            i = BIO_write(b->next_bio, &(ctx->buf[ctx->buf_off]), n);            if (i <= 0) {                BIO_copy_next_retry(b);                if (!BIO_should_retry(b))                    ctx->cont = 0;                return (i);            }            ctx->buf_off += i;            n -= i;        }        /* at this point all pending data has been written */        ctx->blockout = 0;        if (ctx->buf_len == ctx->buf_off) {            ctx->buf_len = OK_BLOCK_BLOCK;            ctx->buf_off = 0;        }        if ((in == NULL) || (inl <= 0))            return (0);        n = (inl + ctx->buf_len > OK_BLOCK_SIZE + OK_BLOCK_BLOCK) ?            (int)(OK_BLOCK_SIZE + OK_BLOCK_BLOCK - ctx->buf_len) : inl;        memcpy((unsigned char *)(&(ctx->buf[ctx->buf_len])),               (unsigned char *)in, n);        ctx->buf_len += n;        inl -= n;        in += n;        if (ctx->buf_len >= OK_BLOCK_SIZE + OK_BLOCK_BLOCK) {            if (!block_out(b)) {                BIO_clear_retry_flags(b);                return 0;            }        }    } while (inl > 0);    BIO_clear_retry_flags(b);    BIO_copy_next_retry(b);    return (ret);}

static long enc_ctrl(BIO *b, int cmd, long num, void *ptr){    BIO *dbio;    BIO_ENC_CTX *ctx,*dctx;    long ret=1;    int i;    EVP_CIPHER_CTX **c_ctx;    ctx=(BIO_ENC_CTX *)b->ptr;    switch (cmd)    {    case BIO_CTRL_RESET:        ctx->ok=1;        ctx->finished=0;        EVP_CipherInit_ex(&(ctx->cipher),NULL,NULL,NULL,NULL,                          ctx->cipher.encrypt);        ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        break;    case BIO_CTRL_EOF:	/* More to read */        if (ctx->cont <= 0)            ret=1;        else            ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        break;    case BIO_CTRL_WPENDING:        ret=ctx->buf_len-ctx->buf_off;        if (ret <= 0)            ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        break;    case BIO_CTRL_PENDING: /* More to read in buffer */        ret=ctx->buf_len-ctx->buf_off;        if (ret <= 0)            ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        break;    case BIO_CTRL_FLUSH:        /* do a final write */again:        while (ctx->buf_len != ctx->buf_off)        {            i=enc_write(b,NULL,0);            if (i < 0)                return i;        }        if (!ctx->finished)        {            ctx->finished=1;            ctx->buf_off=0;            ret=EVP_CipherFinal_ex(&(ctx->cipher),                                   (unsigned char *)ctx->buf,                                   &(ctx->buf_len));            ctx->ok=(int)ret;            if (ret <= 0) break;            /* push out the bytes */            goto again;        }        /* Finally flush the underlying BIO */        ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        break;    case BIO_C_GET_CIPHER_STATUS:        ret=(long)ctx->ok;        break;    case BIO_C_DO_STATE_MACHINE:        BIO_clear_retry_flags(b);        ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        BIO_copy_next_retry(b);        break;    case BIO_C_GET_CIPHER_CTX:        c_ctx=(EVP_CIPHER_CTX **)ptr;        (*c_ctx)= &(ctx->cipher);        b->init=1;        break;    case BIO_CTRL_DUP:        dbio=(BIO *)ptr;        dctx=(BIO_ENC_CTX *)dbio->ptr;        EVP_CIPHER_CTX_init(&dctx->cipher);        ret = EVP_CIPHER_CTX_copy(&dctx->cipher,&ctx->cipher);        if (ret)            dbio->init=1;        break;    default:        ret=BIO_ctrl(b->next_bio,cmd,num,ptr);        break;    }    return(ret);}

static long bio_rdp_tls_ctrl(BIO* bio, int cmd, long num, void* ptr){	BIO* ssl_rbio;	BIO* ssl_wbio;	BIO* next_bio;	int status = -1;	BIO_RDP_TLS* tls = (BIO_RDP_TLS*) BIO_get_data(bio);	if (!tls)		return 0;	if (!tls->ssl && (cmd != BIO_C_SET_SSL))		return 0;	next_bio = BIO_next(bio);	ssl_rbio = tls->ssl ? SSL_get_rbio(tls->ssl) : NULL;	ssl_wbio = tls->ssl ? SSL_get_wbio(tls->ssl) : NULL;	switch (cmd)	{		case BIO_CTRL_RESET:			SSL_shutdown(tls->ssl);			if (SSL_in_connect_init(tls->ssl))				SSL_set_connect_state(tls->ssl);			else if (SSL_in_accept_init(tls->ssl))				SSL_set_accept_state(tls->ssl);			SSL_clear(tls->ssl);			if (next_bio)				status = BIO_ctrl(next_bio, cmd, num, ptr);			else if (ssl_rbio)				status = BIO_ctrl(ssl_rbio, cmd, num, ptr);			else				status = 1;			break;		case BIO_C_GET_FD:			status = BIO_ctrl(ssl_rbio, cmd, num, ptr);			break;		case BIO_CTRL_INFO:			status = 0;			break;		case BIO_CTRL_SET_CALLBACK:			status = 0;			break;		case BIO_CTRL_GET_CALLBACK:			*((ULONG_PTR*) ptr) = (ULONG_PTR) SSL_get_info_callback(tls->ssl);			status = 1;			break;		case BIO_C_SSL_MODE:			if (num)				SSL_set_connect_state(tls->ssl);			else				SSL_set_accept_state(tls->ssl);			status = 1;			break;		case BIO_CTRL_GET_CLOSE:			status = BIO_get_shutdown(bio);			break;		case BIO_CTRL_SET_CLOSE:			BIO_set_shutdown(bio, (int) num);			status = 1;			break;		case BIO_CTRL_WPENDING:			status = BIO_ctrl(ssl_wbio, cmd, num, ptr);			break;		case BIO_CTRL_PENDING:			status = SSL_pending(tls->ssl);			if (status == 0)				status = BIO_pending(ssl_rbio);			break;		case BIO_CTRL_FLUSH:			BIO_clear_retry_flags(bio);			status = BIO_ctrl(ssl_wbio, cmd, num, ptr);			BIO_copy_next_retry(bio);			status = 1;			break;		case BIO_CTRL_PUSH:			if (next_bio && (next_bio != ssl_rbio))			{#if OPENSSL_VERSION_NUMBER < 0x10100000L				SSL_set_bio(tls->ssl, next_bio, next_bio);				CRYPTO_add(&(bio->next_bio->references), 1, CRYPTO_LOCK_BIO);//.........这里部分代码省略.........

static long md_ctrl(BIO *b, int cmd, long num, void *ptr){    EVP_MD_CTX *ctx, *dctx, **pctx;    const EVP_MD **ppmd;    EVP_MD *md;    long ret = 1;    BIO *dbio, *next;    ctx = BIO_get_data(b);    next = BIO_next(b);    switch (cmd) {    case BIO_CTRL_RESET:        if (BIO_get_init(b))            ret = EVP_DigestInit_ex(ctx, ctx->digest, NULL);        else            ret = 0;        if (ret > 0)            ret = BIO_ctrl(next, cmd, num, ptr);        break;    case BIO_C_GET_MD:        if (BIO_get_init(b)) {            ppmd = ptr;            *ppmd = ctx->digest;        } else            ret = 0;        break;    case BIO_C_GET_MD_CTX:        pctx = ptr;        *pctx = ctx;        BIO_set_init(b, 1);        break;    case BIO_C_SET_MD_CTX:        if (BIO_get_init(b))            BIO_set_data(b, ptr);        else            ret = 0;        break;    case BIO_C_DO_STATE_MACHINE:        BIO_clear_retry_flags(b);        ret = BIO_ctrl(next, cmd, num, ptr);        BIO_copy_next_retry(b);        break;    case BIO_C_SET_MD:        md = ptr;        ret = EVP_DigestInit_ex(ctx, md, NULL);        if (ret > 0)            BIO_set_init(b, 1);        break;    case BIO_CTRL_DUP:        dbio = ptr;        dctx = BIO_get_data(dbio);        if (!EVP_MD_CTX_copy_ex(dctx, ctx))            return 0;        BIO_set_init(b, 1);        break;    default:        ret = BIO_ctrl(next, cmd, num, ptr);        break;    }    return ret;}

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 ok_write(BIO *b, const char *in, int inl){    int ret = 0, n, i;    BIO_OK_CTX *ctx;    BIO *next;    if (inl <= 0)        return inl;    ctx = BIO_get_data(b);    next = BIO_next(b);    ret = inl;    if ((ctx == NULL) || (next == NULL) || (BIO_get_init(b) == 0))        return 0;    if (ctx->sigio && !sig_out(b))        return 0;    do {        BIO_clear_retry_flags(b);        n = ctx->buf_len - ctx->buf_off;        while (ctx->blockout && n > 0) {            i = BIO_write(next, &(ctx->buf[ctx->buf_off]), n);            if (i <= 0) {                BIO_copy_next_retry(b);                if (!BIO_should_retry(b))                    ctx->cont = 0;                return i;            }            ctx->buf_off += i;            n -= i;        }        /* at this point all pending data has been written */        ctx->blockout = 0;        if (ctx->buf_len == ctx->buf_off) {            ctx->buf_len = OK_BLOCK_BLOCK;            ctx->buf_off = 0;        }        if ((in == NULL) || (inl <= 0))            return 0;        n = (inl + ctx->buf_len > OK_BLOCK_SIZE + OK_BLOCK_BLOCK) ?            (int)(OK_BLOCK_SIZE + OK_BLOCK_BLOCK - ctx->buf_len) : inl;        memcpy(&ctx->buf[ctx->buf_len], in, n);        ctx->buf_len += n;        inl -= n;        in += n;        if (ctx->buf_len >= OK_BLOCK_SIZE + OK_BLOCK_BLOCK) {            if (!block_out(b)) {                BIO_clear_retry_flags(b);                return 0;            }        }    } while (inl > 0);    BIO_clear_retry_flags(b);    BIO_copy_next_retry(b);    return ret;}

static int enc_read(BIO *b, char *out, int outl){    int ret=0,i;    BIO_ENC_CTX *ctx;    if (out == NULL) return(0);    ctx=(BIO_ENC_CTX *)b->ptr;    if ((ctx == NULL) || (b->next_bio == NULL)) return(0);    /* First check if there are bytes decoded/encoded */    if (ctx->buf_len > 0)    {        i=ctx->buf_len-ctx->buf_off;        if (i > outl) i=outl;        TINYCLR_SSL_MEMCPY(out,&(ctx->buf[ctx->buf_off]),i);        ret=i;        out+=i;        outl-=i;        ctx->buf_off+=i;        if (ctx->buf_len == ctx->buf_off)        {            ctx->buf_len=0;            ctx->buf_off=0;        }    }    /* At this point, we have room of outl bytes and an empty     * buffer, so we should read in some more. */    while (outl > 0)    {        if (ctx->cont <= 0) break;        /* read in at IV offset, read the EVP_Cipher         * documentation about why */        i=BIO_read(b->next_bio,&(ctx->buf[BUF_OFFSET]),ENC_BLOCK_SIZE);        if (i <= 0)        {            /* Should be continue next time we are called? */            if (!BIO_should_retry(b->next_bio))            {                ctx->cont=i;                i=EVP_CipherFinal_ex(&(ctx->cipher),                                     (unsigned char *)ctx->buf,                                     &(ctx->buf_len));                ctx->ok=i;                ctx->buf_off=0;            }            else            {                ret=(ret == 0)?i:ret;                break;            }        }        else        {            EVP_CipherUpdate(&(ctx->cipher),                             (unsigned char *)ctx->buf,&ctx->buf_len,                             (unsigned char *)&(ctx->buf[BUF_OFFSET]),i);            ctx->cont=1;            /* Note: it is possible for EVP_CipherUpdate to             * decrypt zero bytes because this is or looks like             * the final block: if this happens we should retry             * and either read more data or decrypt the final             * block             */            if(ctx->buf_len == 0) continue;        }        if (ctx->buf_len <= outl)            i=ctx->buf_len;        else            i=outl;        if (i <= 0) break;        TINYCLR_SSL_MEMCPY(out,ctx->buf,i);        ret+=i;        ctx->buf_off=i;        outl-=i;        out+=i;    }    BIO_clear_retry_flags(b);    BIO_copy_next_retry(b);    return((ret == 0)?ctx->cont:ret);}

static intbuffer_write(BIO *b, const char *in, int inl){	int i, num = 0;	BIO_F_BUFFER_CTX *ctx;	if ((in == NULL) || (inl <= 0))		return (0);	ctx = (BIO_F_BUFFER_CTX *)b->ptr;	if ((ctx == NULL) || (b->next_bio == NULL))		return (0);	BIO_clear_retry_flags(b);start:	i = ctx->obuf_size - (ctx->obuf_len + ctx->obuf_off);	/* add to buffer and return */	if (i >= inl) {		memcpy(&(ctx->obuf[ctx->obuf_off + ctx->obuf_len]), in, inl);		ctx->obuf_len += inl;		return (num + inl);	}	/* else */	/* stuff already in buffer, so add to it first, then flush */	if (ctx->obuf_len != 0) {		if (i > 0) /* lets fill it up if we can */		{			memcpy(&(ctx->obuf[ctx->obuf_off + ctx->obuf_len]), in, i);			in += i;			inl -= i;			num += i;			ctx->obuf_len += i;		}		/* we now have a full buffer needing flushing */		for (;;) {			i = BIO_write(b->next_bio, &(ctx->obuf[ctx->obuf_off]),			    ctx->obuf_len);			if (i <= 0) {				BIO_copy_next_retry(b);				if (i < 0)					return ((num > 0) ? num : i);				if (i == 0)					return (num);			}			ctx->obuf_off += i;			ctx->obuf_len -= i;			if (ctx->obuf_len == 0)				break;		}	}	/* we only get here if the buffer has been flushed and we	 * still have stuff to write */	ctx->obuf_off = 0;	/* we now have inl bytes to write */	while (inl >= ctx->obuf_size) {		i = BIO_write(b->next_bio, in, inl);		if (i <= 0) {			BIO_copy_next_retry(b);			if (i < 0)				return ((num > 0) ? num : i);			if (i == 0)				return (num);		}		num += i;		in += i;		inl -= i;		if (inl == 0)			return (num);	}	/* copy the rest into the buffer since we have only a small	 * amount left */	goto start;}

static int ok_read(BIO *b, char *out, int outl){    int ret = 0, i, n;    BIO_OK_CTX *ctx;    if (out == NULL)        return (0);    ctx = (BIO_OK_CTX *)b->ptr;    if ((ctx == NULL) || (b->next_bio == NULL) || (b->init == 0))        return (0);    while (outl > 0) {        /* copy clean bytes to output buffer */        if (ctx->blockout) {            i = ctx->buf_len - ctx->buf_off;            if (i > outl)                i = outl;            memcpy(out, &(ctx->buf[ctx->buf_off]), i);            ret += i;            out += i;            outl -= i;            ctx->buf_off += i;            /* all clean bytes are out */            if (ctx->buf_len == ctx->buf_off) {                ctx->buf_off = 0;                /*                 * copy start of the next block into proper place                 */                if (ctx->buf_len_save - ctx->buf_off_save > 0) {                    ctx->buf_len = ctx->buf_len_save - ctx->buf_off_save;                    memmove(ctx->buf, &(ctx->buf[ctx->buf_off_save]),                            ctx->buf_len);                } else {                    ctx->buf_len = 0;                }                ctx->blockout = 0;            }        }        /* output buffer full -- cancel */        if (outl == 0)            break;        /* no clean bytes in buffer -- fill it */        n = IOBS - ctx->buf_len;        i = BIO_read(b->next_bio, &(ctx->buf[ctx->buf_len]), n);        if (i <= 0)            break;              /* nothing new */        ctx->buf_len += i;        /* no signature yet -- check if we got one */        if (ctx->sigio == 1) {            if (!sig_in(b)) {                BIO_clear_retry_flags(b);                return 0;            }        }        /* signature ok -- check if we got block */        if (ctx->sigio == 0) {            if (!block_in(b)) {                BIO_clear_retry_flags(b);                return 0;            }        }        /* invalid block -- cancel */        if (ctx->cont <= 0)            break;    }    BIO_clear_retry_flags(b);    BIO_copy_next_retry(b);    return (ret);}

//.........这里部分代码省略.........		ret = 1;		break;	case BIO_C_SET_BUFF_SIZE:		if (ptr != NULL) {			ip = (int *)ptr;			if (*ip == 0) {				ibs = (int)num;				obs = ctx->obuf_size;			}			else /* if (*ip == 1) */			{				ibs = ctx->ibuf_size;				obs = (int)num;			}		} else {			ibs = (int)num;			obs = (int)num;		}		p1 = ctx->ibuf;		p2 = ctx->obuf;		if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size)) {			p1 = malloc(num);			if (p1 == NULL)				goto malloc_error;		}		if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) {			p2 = malloc(num);			if (p2 == NULL) {				if (p1 != ctx->ibuf)					free(p1);				goto malloc_error;			}		}		if (ctx->ibuf != p1) {			free(ctx->ibuf);			ctx->ibuf = p1;			ctx->ibuf_off = 0;			ctx->ibuf_len = 0;			ctx->ibuf_size = ibs;		}		if (ctx->obuf != p2) {			free(ctx->obuf);			ctx->obuf = p2;			ctx->obuf_off = 0;			ctx->obuf_len = 0;			ctx->obuf_size = obs;		}		break;	case BIO_C_DO_STATE_MACHINE:		if (b->next_bio == NULL)			return (0);		BIO_clear_retry_flags(b);		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		BIO_copy_next_retry(b);		break;	case BIO_CTRL_FLUSH:		if (b->next_bio == NULL)			return (0);		if (ctx->obuf_len <= 0) {			ret = BIO_ctrl(b->next_bio, cmd, num, ptr);			break;		}		for (;;) {			BIO_clear_retry_flags(b);			if (ctx->obuf_len > 0) {				r = BIO_write(b->next_bio,				    &(ctx->obuf[ctx->obuf_off]),				    ctx->obuf_len);				BIO_copy_next_retry(b);				if (r <= 0)					return ((long)r);				ctx->obuf_off += r;				ctx->obuf_len -= r;			} else {				ctx->obuf_len = 0;				ctx->obuf_off = 0;				break;			}		}		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		break;	case BIO_CTRL_DUP:		dbio = (BIO *)ptr;		if (!BIO_set_read_buffer_size(dbio, ctx->ibuf_size) ||		    !BIO_set_write_buffer_size(dbio, ctx->obuf_size))			ret = 0;		break;	default:		if (b->next_bio == NULL)			return (0);		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		break;	}	return (ret);malloc_error:	BIOerror(ERR_R_MALLOC_FAILURE);	return (0);}

static long ok_ctrl(BIO *b, int cmd, long num, void *ptr){    BIO_OK_CTX *ctx;    EVP_MD *md;    const EVP_MD **ppmd;    long ret = 1;    int i;    ctx = b->ptr;    switch (cmd) {    case BIO_CTRL_RESET:        ctx->buf_len = 0;        ctx->buf_off = 0;        ctx->buf_len_save = 0;        ctx->buf_off_save = 0;        ctx->cont = 1;        ctx->finished = 0;        ctx->blockout = 0;        ctx->sigio = 1;        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        break;    case BIO_CTRL_EOF:         /* More to read */        if (ctx->cont <= 0)            ret = 1;        else            ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        break;    case BIO_CTRL_PENDING:     /* More to read in buffer */    case BIO_CTRL_WPENDING:    /* More to read in buffer */        ret = ctx->blockout ? ctx->buf_len - ctx->buf_off : 0;        if (ret <= 0)            ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        break;    case BIO_CTRL_FLUSH:        /* do a final write */        if (ctx->blockout == 0)            if (!block_out(b))                return 0;        while (ctx->blockout) {            i = ok_write(b, NULL, 0);            if (i < 0) {                ret = i;                break;            }        }        ctx->finished = 1;        ctx->buf_off = ctx->buf_len = 0;        ctx->cont = (int)ret;        /* Finally flush the underlying BIO */        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        break;    case BIO_C_DO_STATE_MACHINE:        BIO_clear_retry_flags(b);        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        BIO_copy_next_retry(b);        break;    case BIO_CTRL_INFO:        ret = (long)ctx->cont;        break;    case BIO_C_SET_MD:        md = ptr;        if (!EVP_DigestInit_ex(&ctx->md, md, NULL))            return 0;        b->init = 1;        break;    case BIO_C_GET_MD:        if (b->init) {            ppmd = ptr;            *ppmd = ctx->md.digest;        } else            ret = 0;        break;    default:        ret = BIO_ctrl(b->next_bio, cmd, num, ptr);        break;    }    return (ret);}

static intlinebuffer_write(BIO *b, const char *in, int inl){	int i, num = 0, foundnl;	BIO_LINEBUFFER_CTX *ctx;	if ((in == NULL) || (inl <= 0))		return (0);	ctx = (BIO_LINEBUFFER_CTX *)b->ptr;	if ((ctx == NULL) || (b->next_bio == NULL))		return (0);	BIO_clear_retry_flags(b);	do {		const char *p;		for (p = in; p < in + inl && *p != '/n'; p++)			;		if (*p == '/n') {			p++;			foundnl = 1;		} else			foundnl = 0;		/* If a NL was found and we already have text in the save		   buffer, concatenate them and write */		while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len) &&		    ctx->obuf_len > 0) {			int orig_olen = ctx->obuf_len;			i = ctx->obuf_size - ctx->obuf_len;			if (p - in > 0) {				if (i >= p - in) {					memcpy(&(ctx->obuf[ctx->obuf_len]),					    in, p - in);					ctx->obuf_len += p - in;					inl -= p - in;					num += p - in;					in = p;				} else {					memcpy(&(ctx->obuf[ctx->obuf_len]),					    in, i);					ctx->obuf_len += i;					inl -= i;					in += i;					num += i;				}			}#if 0			BIO_write(b->next_bio, "<*<", 3);#endif			i = BIO_write(b->next_bio, ctx->obuf, ctx->obuf_len);			if (i <= 0) {				ctx->obuf_len = orig_olen;				BIO_copy_next_retry(b);#if 0				BIO_write(b->next_bio, ">*>", 3);#endif				if (i < 0)					return ((num > 0) ? num : i);				if (i == 0)					return (num);			}#if 0			BIO_write(b->next_bio, ">*>", 3);#endif			if (i < ctx->obuf_len)				memmove(ctx->obuf, ctx->obuf + i,				    ctx->obuf_len - i);			ctx->obuf_len -= i;		}		/* Now that the save buffer is emptied, let's write the input		   buffer if a NL was found and there is anything to write. */		if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) {#if 0			BIO_write(b->next_bio, "<*<", 3);#endif			i = BIO_write(b->next_bio, in, p - in);			if (i <= 0) {				BIO_copy_next_retry(b);#if 0				BIO_write(b->next_bio, ">*>", 3);#endif				if (i < 0)					return ((num > 0) ? num : i);				if (i == 0)					return (num);			}#if 0			BIO_write(b->next_bio, ">*>", 3);#endif			num += i;			in += i;			inl -= i;		}	} while (foundnl && inl > 0);	/* We've written as much as we can.  The rest of the input buffer, if//.........这里部分代码省略.........

static longlinebuffer_ctrl(BIO *b, int cmd, long num, void *ptr){	BIO *dbio;	BIO_LINEBUFFER_CTX *ctx;	long ret = 1;	char *p;	int r;	int obs;	ctx = (BIO_LINEBUFFER_CTX *)b->ptr;	switch (cmd) {	case BIO_CTRL_RESET:		ctx->obuf_len = 0;		if (b->next_bio == NULL)			return (0);		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		break;	case BIO_CTRL_INFO:		ret = (long)ctx->obuf_len;		break;	case BIO_CTRL_WPENDING:		ret = (long)ctx->obuf_len;		if (ret == 0) {			if (b->next_bio == NULL)				return (0);			ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		}		break;	case BIO_C_SET_BUFF_SIZE:		obs = (int)num;		p = ctx->obuf;		if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) {			p = (char *)OPENSSL_malloc((int)num);			if (p == NULL)				goto malloc_error;		}		if (ctx->obuf != p) {			if (ctx->obuf_len > obs) {				ctx->obuf_len = obs;			}			memcpy(p, ctx->obuf, ctx->obuf_len);			OPENSSL_free(ctx->obuf);			ctx->obuf = p;			ctx->obuf_size = obs;		}		break;	case BIO_C_DO_STATE_MACHINE:		if (b->next_bio == NULL)			return (0);		BIO_clear_retry_flags(b);		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		BIO_copy_next_retry(b);		break;	case BIO_CTRL_FLUSH:		if (b->next_bio == NULL)			return (0);		if (ctx->obuf_len <= 0) {			ret = BIO_ctrl(b->next_bio, cmd, num, ptr);			break;		}		for (;;) {			BIO_clear_retry_flags(b);			if (ctx->obuf_len > 0) {				r = BIO_write(b->next_bio,				    ctx->obuf, ctx->obuf_len);#if 0				fprintf(stderr, "FLUSH %3d -> %3d/n", ctx->obuf_len, r);#endif				BIO_copy_next_retry(b);				if (r <= 0)					return ((long)r);				if (r < ctx->obuf_len)					memmove(ctx->obuf, ctx->obuf + r,					    ctx->obuf_len - r);				ctx->obuf_len -= r;			} else {				ctx->obuf_len = 0;				ret = 1;				break;			}		}		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		break;	case BIO_CTRL_DUP:		dbio = (BIO *)ptr;		if (!BIO_set_write_buffer_size(dbio, ctx->obuf_size))			ret = 0;		break;	default:		if (b->next_bio == NULL)			return (0);		ret = BIO_ctrl(b->next_bio, cmd, num, ptr);		break;	}	return (ret);malloc_error://.........这里部分代码省略.........