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

static int bio_zlib_new(BIO *bi){    BIO_ZLIB_CTX *ctx;# ifdef ZLIB_SHARED    (void)COMP_zlib();    if (!zlib_loaded) {        COMPerr(COMP_F_BIO_ZLIB_NEW, COMP_R_ZLIB_NOT_SUPPORTED);        return 0;    }# endif    ctx = OPENSSL_zalloc(sizeof(*ctx));    if (ctx == NULL) {        COMPerr(COMP_F_BIO_ZLIB_NEW, ERR_R_MALLOC_FAILURE);        return 0;    }    ctx->ibufsize = ZLIB_DEFAULT_BUFSIZE;    ctx->obufsize = ZLIB_DEFAULT_BUFSIZE;    ctx->zin.zalloc = Z_NULL;    ctx->zin.zfree = Z_NULL;    ctx->zout.zalloc = Z_NULL;    ctx->zout.zfree = Z_NULL;    ctx->comp_level = Z_DEFAULT_COMPRESSION;    BIO_set_init(bi, 1);    BIO_set_data(bi, ctx);    return 1;}

static int bio_create(BIO *b){	BIO_set_init(b, 1);	BIO_set_data(b, NULL);	return 1;}

/** create a new BIO. * (internal openssl use via the tls_mbuf method) * @return 1 on success, 0 on error. */static int tls_bio_mbuf_new(BIO* b){	struct tls_bio_mbuf_data* d;	TLS_BIO_DBG("tls_bio_mbuf_new called (%p)/n", b);#if OPENSSL_VERSION_NUMBER < 0x010100000L	b->init = 0; /* not initialized yet */	b->num = 0;	b->ptr = 0;	b->flags = 0;	d = OPENSSL_malloc(sizeof(*d));	if (unlikely(d == 0))		return 0;	d->rd = 0;	d->wr = 0;	b->ptr = d;#else	BIO_set_init(b, 0);	BIO_set_data(b, NULL);	d = OPENSSL_zalloc(sizeof(*d));	if (unlikely(d == 0))		return 0;	BIO_set_data(b, d);#endif	return 1;}

int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,                   const unsigned char *i, int e){    BIO_ENC_CTX *ctx;    long (*callback) (struct bio_st *, int, const char *, int, long, long);    ctx = BIO_get_data(b);    if (ctx == NULL)        return 0;    callback = BIO_get_callback(b);    if ((callback != NULL) &&            (callback(b, BIO_CB_CTRL, (const char *)c, BIO_CTRL_SET, e,                      0L) <= 0))        return 0;    BIO_set_init(b, 1);    if (!EVP_CipherInit_ex(ctx->cipher, c, NULL, k, i, e))        return 0;    if (callback != NULL)        return callback(b, BIO_CB_CTRL, (const char *)c, BIO_CTRL_SET, e, 1L);    return 1;}

static inttlso_bio_create( BIO *b ) {	BIO_set_init( b, 1 );	BIO_set_data( b, NULL );	BIO_clear_flags( b, ~0 );	return 1;}

static BIO *dill_tls_new_cbio(void *mem) {    BIO *bio = BIO_new(dill_tls_cbio);    if(dill_slow(!bio)) {errno = EFAULT; return NULL;}    BIO_set_data(bio, mem);    BIO_set_init(bio, 1);    return bio;}

/* Called to initialize a new BIO */static intbio_bufferevent_new(BIO *b){	BIO_set_init(b, 0);	BIO_set_data(b, NULL); /* We'll be putting the bufferevent in this field.*/	return 1;}

static int transport_bio_simple_uninit(BIO* bio){	WINPR_BIO_SIMPLE_SOCKET* ptr = (WINPR_BIO_SIMPLE_SOCKET*) BIO_get_data(bio);	if (BIO_get_shutdown(bio))	{		if (BIO_get_init(bio))		{			_shutdown(ptr->socket, SD_BOTH);			closesocket(ptr->socket);			ptr->socket = 0;		}	}	if (ptr->hEvent)	{		CloseHandle(ptr->hEvent);		ptr->hEvent = NULL;	}	BIO_set_init(bio, 0);	BIO_set_flags(bio, 0);	return 1;}

static int bio_rdp_tls_free(BIO* bio){	BIO_RDP_TLS* tls;	if (!bio)		return 0;	tls = (BIO_RDP_TLS*) BIO_get_data(bio);	if (!tls)		return 0;	if (BIO_get_shutdown(bio))	{		if (BIO_get_init(bio) && tls->ssl)		{			SSL_shutdown(tls->ssl);			SSL_free(tls->ssl);		}		BIO_set_init(bio, 0);		BIO_set_flags(bio, 0);	}	DeleteCriticalSection(&tls->lock);	free(tls);	return 1;}

static int tap_free(BIO *b){    if (b == NULL)        return 0;    BIO_set_data(b, NULL);    BIO_set_init(b, 0);    return 1;}

static int mempacket_test_free(BIO *bio){    MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);    sk_MEMPACKET_pop_free(ctx->pkts, mempacket_free);    OPENSSL_free(ctx);    BIO_set_data(bio, NULL);    BIO_set_init(bio, 0);    return 1;}

static int md_free(BIO *a){    if (a == NULL)        return 0;    EVP_MD_CTX_free(BIO_get_data(a));    BIO_set_data(a, NULL);    BIO_set_init(a, 0);    return 1;}

static intbio_method_new (BIO * bio){  GST_LOG_OBJECT (NULL, "BIO: new");  BIO_set_shutdown (bio, 0);  BIO_set_init (bio, 1);  return 1;}

static inttlso_bio_destroy( BIO *b ){	if ( b == NULL ) return 0;	BIO_set_data( b, NULL );		/* sb_tls_remove() will free it */	BIO_set_init( b, 0 );	BIO_clear_flags( b, ~0 );	return 1;}

intmongoc_stream_tls_openssl_bio_create (BIO *b){   BSON_ASSERT (b);   BIO_set_init (b, 1);   BIO_set_data (b, NULL);   BIO_set_flags (b, 0);   return 1;}

static int url_bio_create(BIO *b){#if OPENSSL_VERSION_NUMBER >= 0x1010000fL    BIO_set_init(b, 1);    BIO_set_data(b, NULL);    BIO_set_flags(b, 0);#else    b->init = 1;    b->ptr = NULL;    b->flags = 0;#endif    return 1;}

static int md_new(BIO *bi){    EVP_MD_CTX *ctx;    ctx = EVP_MD_CTX_new();    if (ctx == NULL)        return 0;    BIO_set_init(bi, 1);    BIO_set_data(bi, ctx);    return 1;}

/* Create a new BIO to wrap communication around a bufferevent.  If close_flag * is true, the bufferevent will be freed when the BIO is closed. */static BIO *BIO_new_bufferevent(struct bufferevent *bufferevent, int close_flag){	BIO *result;	if (!bufferevent)		return NULL;	if (!(result = BIO_new(BIO_s_bufferevent())))		return NULL;	BIO_set_init(result, 1);	BIO_set_data(result, bufferevent);	BIO_set_shutdown(result, close_flag ? 1 : 0);	return result;}

static int mempacket_test_new(BIO *bio){    MEMPACKET_TEST_CTX *ctx;    if (!TEST_ptr(ctx = OPENSSL_zalloc(sizeof(*ctx))))        return 0;    if (!TEST_ptr(ctx->pkts = sk_MEMPACKET_new_null())) {        OPENSSL_free(ctx);        return 0;    }    BIO_set_init(bio, 1);    BIO_set_data(bio, ctx);    return 1;}

static int ssl_new(BIO *bi){    BIO_SSL *bs = OPENSSL_zalloc(sizeof(*bs));    if (bs == NULL) {        BIOerr(BIO_F_SSL_NEW, ERR_R_MALLOC_FAILURE);        return 0;    }    BIO_set_init(bi, 0);    BIO_set_data(bi, bs);    /* Clear all flags */    BIO_clear_flags(bi, ~0);    return 1;}

static int asn1_bio_new(BIO *b){    BIO_ASN1_BUF_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));    if (ctx == NULL)        return 0;    if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {        OPENSSL_free(ctx);        return 0;    }    BIO_set_data(b, ctx);    BIO_set_init(b, 1);    return 1;}

static int ok_free(BIO *a){    BIO_OK_CTX *ctx;    if (a == NULL)        return 0;    ctx = BIO_get_data(a);    EVP_MD_CTX_free(ctx->md);    OPENSSL_clear_free(ctx, sizeof(BIO_OK_CTX));    BIO_set_data(a, NULL);    BIO_set_init(a, 0);    return 1;}

static int b64_free(BIO *a){    BIO_B64_CTX *ctx;    if (a == NULL)        return 0;    ctx = BIO_get_data(a);    if (ctx == NULL)        return 0;    EVP_ENCODE_CTX_free(ctx->base64);    OPENSSL_free(ctx);    BIO_set_data(a, NULL);    BIO_set_init(a, 0);    return 1;}

static int transport_bio_buffered_new(BIO* bio){	WINPR_BIO_BUFFERED_SOCKET* ptr;	BIO_set_init(bio, 1);	BIO_set_flags(bio, BIO_FLAGS_SHOULD_RETRY);	ptr = (WINPR_BIO_BUFFERED_SOCKET*) calloc(1, sizeof(WINPR_BIO_BUFFERED_SOCKET));	if (!ptr)		return -1;	BIO_set_data(bio, (void*) ptr);	if (!ringbuffer_init(&ptr->xmitBuffer, 0x10000))		return -1;	return 1;}

static int enc_free(BIO *a){    BIO_ENC_CTX *b;    if (a == NULL)        return 0;    b = BIO_get_data(a);    if (b == NULL)        return 0;    EVP_CIPHER_CTX_free(b->cipher);    OPENSSL_clear_free(b, sizeof(BIO_ENC_CTX));    BIO_set_data(a, NULL);    BIO_set_init(a, 0);    return 1;}

static int asn1_bio_free(BIO *b){    BIO_ASN1_BUF_CTX *ctx;    if (b == NULL)        return 0;    ctx = BIO_get_data(b);    if (ctx == NULL)        return 0;    OPENSSL_free(ctx->buf);    OPENSSL_free(ctx);    BIO_set_data(b, NULL);    BIO_set_init(b, 0);    return 1;}

static int ssl_free(BIO *a){    BIO_SSL *bs;    if (a == NULL)        return 0;    bs = BIO_get_data(a);    if (bs->ssl != NULL)        SSL_shutdown(bs->ssl);    if (BIO_get_shutdown(a)) {        if (BIO_get_init(a))            SSL_free(bs->ssl);        /* Clear all flags */        BIO_clear_flags(a, ~0);        BIO_set_init(a, 0);    }    OPENSSL_free(bs);    return 1;}

static int ok_new(BIO *bi){    BIO_OK_CTX *ctx;    ctx = OPENSSL_zalloc(sizeof(*ctx));    if (ctx == NULL)        return 0;    ctx->cont = 1;    ctx->sigio = 1;    ctx->md = EVP_MD_CTX_new();    if (ctx->md == NULL) {        OPENSSL_free(ctx);        return 0;    }    BIO_set_init(bi, 0);    BIO_set_data(bi, ctx);    return 1;}

static int enc_new(BIO *bi){    BIO_ENC_CTX *ctx;    ctx = OPENSSL_zalloc(sizeof(*ctx));    if (ctx == NULL)        return 0;    ctx->cipher = EVP_CIPHER_CTX_new();    if (ctx->cipher == NULL) {        OPENSSL_free(ctx);        return 0;    }    ctx->cont = 1;    ctx->ok = 1;    BIO_set_data(bi, ctx);    BIO_set_init(bi, 1);    return 1;}

intmongoc_stream_tls_openssl_bio_destroy (BIO *b){   mongoc_stream_tls_t *tls;   BSON_ASSERT (b);   tls = (mongoc_stream_tls_t *) BIO_get_data (b);   if (!tls) {      return -1;   }   BIO_set_data (b, NULL);   BIO_set_init (b, 0);   BIO_set_flags (b, 0);   ((mongoc_stream_tls_openssl_t *) tls->ctx)->bio = NULL;   return 1;}