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

static int conn_state(BIO *bio, BIO_CONNECT *c) {  int ret = -1, i;  char *p, *q;  int (*cb)(const BIO *, int, int) = NULL;  if (c->info_callback != NULL) {    cb = c->info_callback;  }  for (;;) {    switch (c->state) {      case BIO_CONN_S_BEFORE:        p = c->param_hostname;        if (p == NULL) {          OPENSSL_PUT_ERROR(BIO, conn_state, BIO_R_NO_HOSTNAME_SPECIFIED);          goto exit_loop;        }        for (; *p != 0; p++) {          if (*p == ':' || *p == '/') {            break;          }        }        i = *p;        if (i == ':' || i == '/') {          *(p++) = 0;          if (i == ':') {            for (q = p; *q; q++) {              if (*q == '/') {                *q = 0;                break;              }            }            if (c->param_port != NULL) {              OPENSSL_free(c->param_port);            }            c->param_port = BUF_strdup(p);          }        }        if (c->param_port == NULL) {          OPENSSL_PUT_ERROR(BIO, conn_state, BIO_R_NO_PORT_SPECIFIED);          ERR_add_error_data(2, "host=", c->param_hostname);          goto exit_loop;        }        if (!bio_ip_and_port_to_socket_and_addr(                &bio->num, &c->them, &c->them_length, c->param_hostname,                c->param_port)) {          OPENSSL_PUT_ERROR(BIO, conn_state, BIO_R_UNABLE_TO_CREATE_SOCKET);          ERR_add_error_data(4, "host=", c->param_hostname, ":", c->param_port);          goto exit_loop;        }        memset(c->ip, 0, 4);        maybe_copy_ipv4_address(c->ip, &c->them);        if (c->nbio) {          if (!bio_socket_nbio(bio->num, 1)) {            OPENSSL_PUT_ERROR(BIO, conn_state, BIO_R_ERROR_SETTING_NBIO);            ERR_add_error_data(4, "host=", c->param_hostname, ":",                               c->param_port);            goto exit_loop;          }        }        i = 1;        ret = setsockopt(bio->num, SOL_SOCKET, SO_KEEPALIVE, (char *)&i,                         sizeof(i));        if (ret < 0) {          OPENSSL_PUT_SYSTEM_ERROR(setsockopt);          OPENSSL_PUT_ERROR(BIO, conn_state, BIO_R_KEEPALIVE);          ERR_add_error_data(4, "host=", c->param_hostname, ":", c->param_port);          goto exit_loop;        }        BIO_clear_retry_flags(bio);        ret = connect(bio->num, (struct sockaddr*) &c->them, c->them_length);        if (ret < 0) {          if (bio_fd_should_retry(ret)) {            BIO_set_flags(bio, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY));            c->state = BIO_CONN_S_BLOCKED_CONNECT;            bio->retry_reason = BIO_RR_CONNECT;          } else {            OPENSSL_PUT_SYSTEM_ERROR(connect);            OPENSSL_PUT_ERROR(BIO, conn_state, BIO_R_CONNECT_ERROR);            ERR_add_error_data(4, "host=", c->param_hostname, ":",                               c->param_port);          }          goto exit_loop;        } else {          c->state = BIO_CONN_S_OK;        }        break;      case BIO_CONN_S_BLOCKED_CONNECT:        i = bio_sock_error(bio->num);        if (i) {          if (bio_fd_should_retry(ret)) {            BIO_set_flags(bio, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY));//.........这里部分代码省略.........

int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **p, unsigned char *d, int n, int *al)	{	unsigned short length;	unsigned short type;	unsigned short size;	unsigned char *data = *p;	int tlsext_servername = 0;	int renegotiate_seen = 0;	if (data >= (d+n-2))		goto ri_check;	n2s(data,length);	if (data+length != d+n)		{		*al = SSL_AD_DECODE_ERROR;		return 0;		}	while(data <= (d+n-4))		{		n2s(data,type);		n2s(data,size);		if (data+size > (d+n))	   		goto ri_check;		if (s->tlsext_debug_cb)			s->tlsext_debug_cb(s, 1, type, data, size,						s->tlsext_debug_arg);		if (type == TLSEXT_TYPE_server_name)			{			if (s->tlsext_hostname == NULL || size > 0)				{				*al = TLS1_AD_UNRECOGNIZED_NAME;				return 0;				}			tlsext_servername = 1;   			}		else if (type == TLSEXT_TYPE_session_ticket)			{			if ((SSL_get_options(s) & SSL_OP_NO_TICKET)				|| (size > 0))				{				*al = TLS1_AD_UNSUPPORTED_EXTENSION;				return 0;				}			s->tlsext_ticket_expected = 1;			}		else if (type == TLSEXT_TYPE_status_request &&		         s->version != DTLS1_VERSION)			{			/* MUST be empty and only sent if we've requested			 * a status request message.			 */ 			if ((s->tlsext_status_type == -1) || (size > 0))				{				*al = TLS1_AD_UNSUPPORTED_EXTENSION;				return 0;				}			/* Set flag to expect CertificateStatus message */			s->tlsext_status_expected = 1;			}		else if (type == TLSEXT_TYPE_renegotiate)			{			if(!ssl_parse_serverhello_renegotiate_ext(s, data, size, al))				return 0;			renegotiate_seen = 1;			}		data+=size;				}	if (data != d+n)		{		*al = SSL_AD_DECODE_ERROR;		return 0;		}	if (!s->hit && tlsext_servername == 1)		{ 		if (s->tlsext_hostname)			{			if (s->session->tlsext_hostname == NULL)				{				s->session->tlsext_hostname = BUF_strdup(s->tlsext_hostname);					if (!s->session->tlsext_hostname)					{					*al = SSL_AD_UNRECOGNIZED_NAME;					return 0;					}				}			else 				{				*al = SSL_AD_DECODE_ERROR;				return 0;				}			}		}//.........这里部分代码省略.........

static long set_HWCRHK_LIBNAME(const char *name)	{	free_HWCRHK_LIBNAME();	return (((HWCRHK_LIBNAME = BUF_strdup(name)) != NULL) ? 1 : 0);	}

EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,                                        const char *pem_str, const char *info){    EVP_PKEY_ASN1_METHOD *ameth;    ameth = OPENSSL_malloc(sizeof(EVP_PKEY_ASN1_METHOD));    if (!ameth)        return NULL;    memset(ameth, 0, sizeof(EVP_PKEY_ASN1_METHOD));    ameth->pkey_id = id;    ameth->pkey_base_id = id;    ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC;    if (info) {        ameth->info = BUF_strdup(info);        if (!ameth->info)            goto err;    } else        ameth->info = NULL;    if (pem_str) {        ameth->pem_str = BUF_strdup(pem_str);        if (!ameth->pem_str)            goto err;    } else        ameth->pem_str = NULL;    ameth->pub_decode = 0;    ameth->pub_encode = 0;    ameth->pub_cmp = 0;    ameth->pub_print = 0;    ameth->priv_decode = 0;    ameth->priv_encode = 0;    ameth->priv_print = 0;    ameth->old_priv_encode = 0;    ameth->old_priv_decode = 0;    ameth->item_verify = 0;    ameth->item_sign = 0;    ameth->pkey_size = 0;    ameth->pkey_bits = 0;    ameth->param_decode = 0;    ameth->param_encode = 0;    ameth->param_missing = 0;    ameth->param_copy = 0;    ameth->param_cmp = 0;    ameth->param_print = 0;    ameth->pkey_free = 0;    ameth->pkey_ctrl = 0;    return ameth; err:    EVP_PKEY_asn1_free(ameth);    return NULL;}

static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {  int *ip;  long ret = 1;  BIO_CONNECT *data;  data = (BIO_CONNECT *)bio->ptr;  switch (cmd) {    case BIO_CTRL_RESET:      ret = 0;      data->state = BIO_CONN_S_BEFORE;      conn_close_socket(bio);      bio->flags = 0;      break;    case BIO_C_DO_STATE_MACHINE:      // use this one to start the connection      if (data->state != BIO_CONN_S_OK) {        ret = (long)conn_state(bio, data);      } else {        ret = 1;      }      break;    case BIO_C_SET_CONNECT:      if (ptr != NULL) {        bio->init = 1;        if (num == 0) {          OPENSSL_free(data->param_hostname);          data->param_hostname = BUF_strdup(ptr);          if (data->param_hostname == NULL) {            ret = 0;          }        } else if (num == 1) {          OPENSSL_free(data->param_port);          data->param_port = BUF_strdup(ptr);          if (data->param_port == NULL) {            ret = 0;          }        } else {          ret = 0;        }      }      break;    case BIO_C_SET_NBIO:      data->nbio = (int)num;      break;    case BIO_C_GET_FD:      if (bio->init) {        ip = (int *)ptr;        if (ip != NULL) {          *ip = bio->num;        }        ret = bio->num;      } else {        ret = -1;      }      break;    case BIO_CTRL_GET_CLOSE:      ret = bio->shutdown;      break;    case BIO_CTRL_SET_CLOSE:      bio->shutdown = (int)num;      break;    case BIO_CTRL_PENDING:    case BIO_CTRL_WPENDING:      ret = 0;      break;    case BIO_CTRL_FLUSH:      break;    case BIO_CTRL_GET_CALLBACK: {      int (**fptr)(const BIO *bio, int state, int xret);      fptr = (int (**)(const BIO *bio, int state, int xret))ptr;      *fptr = data->info_callback;    } break;    default:      ret = 0;      break;  }  return ret;}

int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **p, unsigned char *d, int n, int *al)	{	unsigned short type;	unsigned short size;	unsigned short len;  	unsigned char *data = *p;	int tlsext_servername = 0;	if (data >= (d+n-2))		return 1;	n2s(data,len);	while(data <= (d+n-4))		{		n2s(data,type);		n2s(data,size);		if (data+size > (d+n))	   		return 1;		if (s->tlsext_debug_cb)			s->tlsext_debug_cb(s, 1, type, data, size,						s->tlsext_debug_arg);		if (type == TLSEXT_TYPE_server_name)			{			if (s->tlsext_hostname == NULL || size > 0)				{				*al = TLS1_AD_UNRECOGNIZED_NAME;				return 0;				}			tlsext_servername = 1;   			}		else if (type == TLSEXT_TYPE_session_ticket)			{			if ((SSL_get_options(s) & SSL_OP_NO_TICKET)				|| (size > 0))				{				*al = TLS1_AD_UNSUPPORTED_EXTENSION;				return 0;				}			s->tlsext_ticket_expected = 1;			}		data+=size;				}	if (data != d+n)		{		*al = SSL_AD_DECODE_ERROR;		return 0;		}	if (!s->hit && tlsext_servername == 1)		{ 		if (s->tlsext_hostname)			{			if (s->session->tlsext_hostname == NULL)				{				s->session->tlsext_hostname = BUF_strdup(s->tlsext_hostname);					if (!s->session->tlsext_hostname)					{					*al = SSL_AD_UNRECOGNIZED_NAME;					return 0;					}				}			else 				{				*al = SSL_AD_DECODE_ERROR;				return 0;				}			}		}	*p = data;	return 1;	}

static long set_ATALLA_LIBNAME(const char *name)	{	free_ATALLA_LIBNAME();	return (((ATALLA_LIBNAME = BUF_strdup(name)) != NULL) ? 1 : 0);	}

static int conn_state(BIO *b, BIO_CONNECT *c)	{	int ret= -1,i;	unsigned long l;	char *p,*q;	int (*cb)()=NULL;	if (c->info_callback != NULL)		cb=c->info_callback;	for (;;)		{		switch (c->state)			{		case BIO_CONN_S_BEFORE:			p=c->param_hostname;			if (p == NULL)				{				BIOerr(BIO_F_CONN_STATE,BIO_R_NO_HOSTNAME_SPECIFIED);				goto exit_loop;				}			for ( ; *p != '/0'; p++)				{				if ((*p == ':') || (*p == '/')) break;				}			i= *p;			if ((i == ':') || (i == '/'))				{				*(p++)='/0';				if (i == ':')					{					for (q=p; *q; q++)						if (*q == '/')							{							*q='/0';							break;							}					if (c->param_port != NULL)						OPENSSL_free(c->param_port);					c->param_port=BUF_strdup(p);					}				}			if (c->param_port == NULL)				{				BIOerr(BIO_F_CONN_STATE,BIO_R_NO_PORT_SPECIFIED);				ERR_add_error_data(2,"host=",c->param_hostname);				goto exit_loop;				}			c->state=BIO_CONN_S_GET_IP;			break;		case BIO_CONN_S_GET_IP:			if (BIO_get_host_ip(c->param_hostname,&(c->ip[0])) <= 0)				goto exit_loop;			c->state=BIO_CONN_S_GET_PORT;			break;		case BIO_CONN_S_GET_PORT:			if (c->param_port == NULL)				{				/* abort(); */				goto exit_loop;				}			else if (BIO_get_port(c->param_port,&c->port) <= 0)				goto exit_loop;			c->state=BIO_CONN_S_CREATE_SOCKET;			break;		case BIO_CONN_S_CREATE_SOCKET:			/* now setup address */			memset((char *)&c->them,0,sizeof(c->them));			c->them.sin_family=AF_INET;			c->them.sin_port=htons((unsigned short)c->port);			l=(unsigned long)				((unsigned long)c->ip[0]<<24L)|				((unsigned long)c->ip[1]<<16L)|				((unsigned long)c->ip[2]<< 8L)|				((unsigned long)c->ip[3]);			c->them.sin_addr.s_addr=htonl(l);			c->state=BIO_CONN_S_CREATE_SOCKET;			ret=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);			if (ret == INVALID_SOCKET)				{				SYSerr(SYS_F_SOCKET,get_last_socket_error());				ERR_add_error_data(4,"host=",c->param_hostname,					":",c->param_port);				BIOerr(BIO_F_CONN_STATE,BIO_R_UNABLE_TO_CREATE_SOCKET);				goto exit_loop;				}			b->num=ret;			c->state=BIO_CONN_S_NBIO;			break;		case BIO_CONN_S_NBIO:			if (c->nbio)				{//.........这里部分代码省略.........

//.........这里部分代码省略.........                if (kparam->idx == i) {                    tflags |= CMS_KEY_PARAM;                    break;                }            }            ri = CMS_add1_recipient_cert(cms, x, tflags);            if (!ri)                goto end;            if (kparam) {                EVP_PKEY_CTX *pctx;                pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);                if (!cms_set_pkey_param(pctx, kparam->param))                    goto end;            }            if (CMS_RecipientInfo_type(ri) == CMS_RECIPINFO_AGREE                && wrap_cipher) {                EVP_CIPHER_CTX *wctx;                wctx = CMS_RecipientInfo_kari_get0_ctx(ri);                EVP_EncryptInit_ex(wctx, wrap_cipher, NULL, NULL, NULL);            }        }        if (secret_key) {            if (!CMS_add0_recipient_key(cms, NID_undef,                                        secret_key, secret_keylen,                                        secret_keyid, secret_keyidlen,                                        NULL, NULL, NULL))                goto end;            /* NULL these because call absorbs them */            secret_key = NULL;            secret_keyid = NULL;        }        if (pwri_pass) {            pwri_tmp = (unsigned char *)BUF_strdup((char *)pwri_pass);            if (!pwri_tmp)                goto end;            if (!CMS_add0_recipient_password(cms,                                             -1, NID_undef, NID_undef,                                             pwri_tmp, -1, NULL))                goto end;            pwri_tmp = NULL;        }        if (!(flags & CMS_STREAM)) {            if (!CMS_final(cms, in, NULL, flags))                goto end;        }    } else if (operation == SMIME_ENCRYPTED_ENCRYPT) {        cms = CMS_EncryptedData_encrypt(in, cipher,                                        secret_key, secret_keylen, flags);    } else if (operation == SMIME_SIGN_RECEIPT) {        CMS_ContentInfo *srcms = NULL;        STACK_OF(CMS_SignerInfo) *sis;        CMS_SignerInfo *si;        sis = CMS_get0_SignerInfos(cms);        if (!sis)            goto end;        si = sk_CMS_SignerInfo_value(sis, 0);        srcms = CMS_sign_receipt(si, signer, key, other, flags);        if (!srcms)            goto end;        CMS_ContentInfo_free(cms);        cms = srcms;    } else if (operation & SMIME_SIGNERS) {        int i;        /*

//.........这里部分代码省略.........            X509_up_ref(rpk->x509);        }        if (cpk->privatekey != NULL) {            rpk->privatekey = cpk->privatekey;            CRYPTO_add(&cpk->privatekey->references, 1, CRYPTO_LOCK_EVP_PKEY);        }        if (cpk->chain) {            rpk->chain = X509_chain_up_ref(cpk->chain);            if (!rpk->chain) {                SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);                goto err;            }        }        if (cert->pkeys[i].serverinfo != NULL) {            /* Just copy everything. */            ret->pkeys[i].serverinfo =                OPENSSL_malloc(cert->pkeys[i].serverinfo_length);            if (ret->pkeys[i].serverinfo == NULL) {                SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);                goto err;            }            ret->pkeys[i].serverinfo_length =                cert->pkeys[i].serverinfo_length;            memcpy(ret->pkeys[i].serverinfo,                   cert->pkeys[i].serverinfo,                   cert->pkeys[i].serverinfo_length);        }    }    ret->references = 1;    /* Configured sigalgs copied across */    if (cert->conf_sigalgs) {        ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen);        if (!ret->conf_sigalgs)            goto err;        memcpy(ret->conf_sigalgs, cert->conf_sigalgs, cert->conf_sigalgslen);        ret->conf_sigalgslen = cert->conf_sigalgslen;    } else        ret->conf_sigalgs = NULL;    if (cert->client_sigalgs) {        ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen);        if (!ret->client_sigalgs)            goto err;        memcpy(ret->client_sigalgs, cert->client_sigalgs,               cert->client_sigalgslen);        ret->client_sigalgslen = cert->client_sigalgslen;    } else        ret->client_sigalgs = NULL;    /* Shared sigalgs also NULL */    ret->shared_sigalgs = NULL;    /* Copy any custom client certificate types */    if (cert->ctypes) {        ret->ctypes = OPENSSL_malloc(cert->ctype_num);        if (!ret->ctypes)            goto err;        memcpy(ret->ctypes, cert->ctypes, cert->ctype_num);        ret->ctype_num = cert->ctype_num;    }    ret->cert_flags = cert->cert_flags;    ret->cert_cb = cert->cert_cb;    ret->cert_cb_arg = cert->cert_cb_arg;    if (cert->verify_store) {        CRYPTO_add(&cert->verify_store->references, 1,                   CRYPTO_LOCK_X509_STORE);        ret->verify_store = cert->verify_store;    }    if (cert->chain_store) {        CRYPTO_add(&cert->chain_store->references, 1, CRYPTO_LOCK_X509_STORE);        ret->chain_store = cert->chain_store;    }    ret->sec_cb = cert->sec_cb;    ret->sec_level = cert->sec_level;    ret->sec_ex = cert->sec_ex;    if (!custom_exts_copy(&ret->cli_ext, &cert->cli_ext))        goto err;    if (!custom_exts_copy(&ret->srv_ext, &cert->srv_ext))        goto err;    if (cert->psk_identity_hint) {        ret->psk_identity_hint = BUF_strdup(cert->psk_identity_hint);        if (ret->psk_identity_hint == NULL)            goto err;    }    return (ret); err:    ssl_cert_free(ret);    return NULL;}

static int/*bool*/nss_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()) {    int ret = 0;    NSS_CTX *ctx;    CALL_TRACE("nss_ctrl() cmd=%d/n", cmd);/* Put commands that do not require initialisation here*/    switch (cmd) {#ifdef CMD_SO_PATH    case CMD_SO_PATH: {        /* not implemented */;        goto done;        } break;#endif    }/* Put commands that require initialisation here */    if (nss_eng_ctx_index < 0) {        NSSerr(NSS_F_CTRL, NSS_R_ENGINE_NOT_INITIALIZED);        return(ret);    }    ctx = ENGINE_get_ex_data(e, nss_eng_ctx_index);    switch (cmd) {    case E_NSS_CMD_CONFIG_DIR: {        ret = nss_cmd_nss_config_dir(ctx, (char*) p);        } break;    case E_NSS_CMD_DEBUG_LEVEL: {        if (0 <= i && i <= NSS_LOGLEVEL_LAST) {            ctx->debug_level = (int) i;            ret = 1;        }        } break;    case E_NSS_CMD_ERROR_FILE: {        if (ctx->error_file != NULL)            OPENSSL_free((void*)ctx->error_file);        ctx->error_file = BUF_strdup(p);        ret = 1;        } break;    case E_NSS_CMD_LIST_CERTS: {        ret = nss_cmd_list_cert(ctx, i);        } break;    case E_NSS_CMD_PRINT_CERT: {        ret = nss_cmd_print_cert(ctx, (char*) p);        } break;    case E_NSS_CMD_LOAD_CERT: {        ret = nss_cmd_load_cert(ctx, p);        } break;    case E_NSS_CMD_EVP_CERT: {        ret = nss_cmd_evp_cert(ctx, p);        } break;    default: {        nss_trace(ctx, "nss_ctrl() <UNKNOWN=%d>/n", cmd);        goto done;        } break;    }done:    return(ret);}

static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {  int *ip;  const char **pptr;  long ret = 1;  BIO_CONNECT *data;  data = (BIO_CONNECT *)bio->ptr;  switch (cmd) {    case BIO_CTRL_RESET:      ret = 0;      data->state = BIO_CONN_S_BEFORE;      conn_close_socket(bio);      bio->flags = 0;      break;    case BIO_C_DO_STATE_MACHINE:      /* use this one to start the connection */      if (data->state != BIO_CONN_S_OK)        ret = (long)conn_state(bio, data);      else        ret = 1;      break;    case BIO_C_GET_CONNECT:      /* TODO(fork): can this be removed? (Or maybe this whole file). */      if (ptr != NULL) {        pptr = (const char **)ptr;        if (num == 0) {          *pptr = data->param_hostname;        } else if (num == 1) {          *pptr = data->param_port;        } else if (num == 2) {          *pptr = (char *) &data->ip[0];        } else if (num == 3) {          *((int *)ptr) = data->port;        }        if (!bio->init) {          *pptr = "not initialized";        }        ret = 1;      }      break;    case BIO_C_SET_CONNECT:      if (ptr != NULL) {        bio->init = 1;        if (num == 0) {          if (data->param_hostname != NULL) {            OPENSSL_free(data->param_hostname);          }          data->param_hostname = BUF_strdup(ptr);        } else if (num == 1) {          if (data->param_port != NULL) {            OPENSSL_free(data->param_port);          }          data->param_port = BUF_strdup(ptr);        } else {          ret = 0;        }      }      break;    case BIO_C_SET_NBIO:      data->nbio = (int)num;      break;    case BIO_C_GET_FD:      if (bio->init) {        ip = (int *)ptr;        if (ip != NULL) {          *ip = bio->num;        }        ret = 1;      } else {        ret = 0;      }      break;    case BIO_CTRL_GET_CLOSE:      ret = bio->shutdown;      break;    case BIO_CTRL_SET_CLOSE:      bio->shutdown = (int)num;      break;    case BIO_CTRL_PENDING:    case BIO_CTRL_WPENDING:      ret = 0;      break;    case BIO_CTRL_FLUSH:      break;    case BIO_CTRL_SET_CALLBACK: {#if 0 /* FIXME: Should this be used?  -- Richard Levitte */		OPENSSL_PUT_ERROR(BIO, XXX, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);		ret = -1;#else      ret = 0;#endif    } break;    case BIO_CTRL_GET_CALLBACK: {      int (**fptr)(const BIO *bio, int state, int xret);      fptr = (int (**)(const BIO *bio, int state, int xret))ptr;      *fptr = data->info_callback;    } break;    default:      ret = 0;//.........这里部分代码省略.........

int SSL_SRP_CTX_init(struct ssl_st *s)	{	SSL_CTX *ctx;	if ((s == NULL) || ((ctx = s->ctx) == NULL))		return 0;	s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg;	/* set client Hello login callback */	s->srp_ctx.TLS_ext_srp_username_callback = ctx->srp_ctx.TLS_ext_srp_username_callback;	/* set SRP N/g param callback for verification */	s->srp_ctx.SRP_verify_param_callback = ctx->srp_ctx.SRP_verify_param_callback;	/* set SRP client passwd callback */	s->srp_ctx.SRP_give_srp_client_pwd_callback = ctx->srp_ctx.SRP_give_srp_client_pwd_callback;	s->srp_ctx.N = NULL;	s->srp_ctx.g = NULL;	s->srp_ctx.s = NULL;	s->srp_ctx.B = NULL;	s->srp_ctx.A = NULL;	s->srp_ctx.a = NULL;	s->srp_ctx.b = NULL;	s->srp_ctx.v = NULL;	s->srp_ctx.login = NULL;	s->srp_ctx.info = ctx->srp_ctx.info;	s->srp_ctx.strength = ctx->srp_ctx.strength;	if (((ctx->srp_ctx.N != NULL) &&		 ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) ||		((ctx->srp_ctx.g != NULL) &&		 ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) ||		((ctx->srp_ctx.s != NULL) &&		 ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) ||		((ctx->srp_ctx.B != NULL) &&		 ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) ||		((ctx->srp_ctx.A != NULL) &&		 ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) ||		((ctx->srp_ctx.a != NULL) &&		 ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) ||		((ctx->srp_ctx.v != NULL) &&		 ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) ||		((ctx->srp_ctx.b != NULL) &&		 ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL)))		{		SSLerr(SSL_F_SSL_SRP_CTX_INIT,ERR_R_BN_LIB);		goto err;		}	if ((ctx->srp_ctx.login != NULL) && 		((s->srp_ctx.login = BUF_strdup(ctx->srp_ctx.login)) == NULL))		{		SSLerr(SSL_F_SSL_SRP_CTX_INIT,ERR_R_INTERNAL_ERROR);		goto err;		}	s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask;	return (1);err:	OPENSSL_free(s->srp_ctx.login);	BN_free(s->srp_ctx.N);	BN_free(s->srp_ctx.g);	BN_free(s->srp_ctx.s);	BN_free(s->srp_ctx.B);	BN_free(s->srp_ctx.A);	BN_free(s->srp_ctx.a);	BN_free(s->srp_ctx.b);	BN_free(s->srp_ctx.v);	return (0);	}

static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)	{	BIO *dbio;	int *ip;	const char **pptr;	long ret=1;	BIO_CONNECT *data;	data=(BIO_CONNECT *)b->ptr;	switch (cmd)		{	case BIO_CTRL_RESET:		ret=0;		data->state=BIO_CONN_S_BEFORE;		conn_close_socket(b);		b->flags=0;		break;	case BIO_C_DO_STATE_MACHINE:		/* use this one to start the connection */		if (!data->state != BIO_CONN_S_OK)			ret=(long)conn_state(b,data);		else			ret=1;		break;	case BIO_C_GET_CONNECT:		if (ptr != NULL)			{			pptr=(const char **)ptr;			if (num == 0)				{				*pptr=data->param_hostname;				}			else if (num == 1)				{				*pptr=data->param_port;				}			else if (num == 2)				{				*pptr= (char *)&(data->ip[0]);				}			else if (num == 3)				{				*((int *)ptr)=data->port;				}			if ((!b->init) || (ptr == NULL))				*pptr="not initialized";			ret=1;			}		break;	case BIO_C_SET_CONNECT:		if (ptr != NULL)			{			b->init=1;			if (num == 0)				{				if (data->param_hostname != NULL)					OPENSSL_free(data->param_hostname);				data->param_hostname=BUF_strdup(ptr);				}			else if (num == 1)				{				if (data->param_port != NULL)					OPENSSL_free(data->param_port);				data->param_port=BUF_strdup(ptr);				}			else if (num == 2)				{				char buf[16];				unsigned char *p = ptr;				BIO_snprintf(buf,sizeof buf,"%d.%d.%d.%d",					     p[0],p[1],p[2],p[3]);				if (data->param_hostname != NULL)					OPENSSL_free(data->param_hostname);				data->param_hostname=BUF_strdup(buf);				memcpy(&(data->ip[0]),ptr,4);				}			else if (num == 3)				{				char buf[DECIMAL_SIZE(int)+1];				BIO_snprintf(buf,sizeof buf,"%d",*(int *)ptr);				if (data->param_port != NULL)					OPENSSL_free(data->param_port);				data->param_port=BUF_strdup(buf);				data->port= *(int *)ptr;				}			}		break;	case BIO_C_SET_NBIO:		data->nbio=(int)num;		break;	case BIO_C_GET_FD:		if (b->init)			{			ip=(int *)ptr;			if (ip != NULL)				*ip=b->num;//.........这里部分代码省略.........

static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)){    dynamic_data_ctx *ctx = dynamic_get_data_ctx(e);    int initialised;    if (!ctx) {        ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ENGINE_R_NOT_LOADED);        return 0;    }    initialised = ((ctx->dynamic_dso == NULL) ? 0 : 1);    /* All our control commands require the ENGINE to be uninitialised */    if (initialised) {        ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ENGINE_R_ALREADY_LOADED);        return 0;    }    switch (cmd) {    case DYNAMIC_CMD_SO_PATH:        /* a NULL 'p' or a string of zero-length is the same thing */        if (p && (strlen((const char *)p) < 1))            p = NULL;        OPENSSL_free(ctx->DYNAMIC_LIBNAME);        if (p)            ctx->DYNAMIC_LIBNAME = BUF_strdup(p);        else            ctx->DYNAMIC_LIBNAME = NULL;        return (ctx->DYNAMIC_LIBNAME ? 1 : 0);    case DYNAMIC_CMD_NO_VCHECK:        ctx->no_vcheck = ((i == 0) ? 0 : 1);        return 1;    case DYNAMIC_CMD_ID:        /* a NULL 'p' or a string of zero-length is the same thing */        if (p && (strlen((const char *)p) < 1))            p = NULL;        OPENSSL_free(ctx->engine_id);        if (p)            ctx->engine_id = BUF_strdup(p);        else            ctx->engine_id = NULL;        return (ctx->engine_id ? 1 : 0);    case DYNAMIC_CMD_LIST_ADD:        if ((i < 0) || (i > 2)) {            ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ENGINE_R_INVALID_ARGUMENT);            return 0;        }        ctx->list_add_value = (int)i;        return 1;    case DYNAMIC_CMD_LOAD:        return dynamic_load(e, ctx);    case DYNAMIC_CMD_DIR_LOAD:        if ((i < 0) || (i > 2)) {            ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ENGINE_R_INVALID_ARGUMENT);            return 0;        }        ctx->dir_load = (int)i;        return 1;    case DYNAMIC_CMD_DIR_ADD:        /* a NULL 'p' or a string of zero-length is the same thing */        if (!p || (strlen((const char *)p) < 1)) {            ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ENGINE_R_INVALID_ARGUMENT);            return 0;        }        {            char *tmp_str = BUF_strdup(p);            if (!tmp_str) {                ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ERR_R_MALLOC_FAILURE);                return 0;            }            sk_OPENSSL_STRING_insert(ctx->dirs, tmp_str, -1);        }        return 1;    default:        break;    }    ENGINEerr(ENGINE_F_DYNAMIC_CTRL, ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED);    return 0;}

int ssl_get_new_session(SSL *s, int session) {  /* This gets used by clients and servers. */  unsigned int tmp;  SSL_SESSION *ss = NULL;  GEN_SESSION_CB cb = def_generate_session_id;  if (s->mode & SSL_MODE_NO_SESSION_CREATION) {    OPENSSL_PUT_ERROR(SSL, ssl_get_new_session,                      SSL_R_SESSION_MAY_NOT_BE_CREATED);    return 0;  }  ss = SSL_SESSION_new();  if (ss == NULL) {    return 0;  }  /* If the context has a default timeout, use it over the default. */  if (s->initial_ctx->session_timeout != 0) {    ss->timeout = s->initial_ctx->session_timeout;  }  if (s->session != NULL) {    SSL_SESSION_free(s->session);    s->session = NULL;  }  if (session) {    if (s->version == SSL3_VERSION || s->version == TLS1_VERSION ||        s->version == TLS1_1_VERSION || s->version == TLS1_2_VERSION ||        s->version == DTLS1_VERSION || s->version == DTLS1_2_VERSION) {      ss->ssl_version = s->version;      ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;    } else {      OPENSSL_PUT_ERROR(SSL, ssl_get_new_session,                        SSL_R_UNSUPPORTED_SSL_VERSION);      SSL_SESSION_free(ss);      return 0;    }    /* If RFC4507 ticket use empty session ID */    if (s->tlsext_ticket_expected) {      ss->session_id_length = 0;      goto sess_id_done;    }    /* Choose which callback will set the session ID */    CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);    if (s->generate_session_id) {      cb = s->generate_session_id;    } else if (s->initial_ctx->generate_session_id) {      cb = s->initial_ctx->generate_session_id;    }    CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);    /* Choose a session ID */    tmp = ss->session_id_length;    if (!cb(s, ss->session_id, &tmp)) {      /* The callback failed */      OPENSSL_PUT_ERROR(SSL, ssl_get_new_session,                        SSL_R_SSL_SESSION_ID_CALLBACK_FAILED);      SSL_SESSION_free(ss);      return 0;    }    /* Don't allow the callback to set the session length to zero. nor set it     * higher than it was. */    if (!tmp || tmp > ss->session_id_length) {      /* The callback set an illegal length */      OPENSSL_PUT_ERROR(SSL, ssl_get_new_session,                        SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH);      SSL_SESSION_free(ss);      return 0;    }    ss->session_id_length = tmp;    /* Finally, check for a conflict */    if (SSL_has_matching_session_id(s, ss->session_id, ss->session_id_length)) {      OPENSSL_PUT_ERROR(SSL, ssl_get_new_session,                        SSL_R_SSL_SESSION_ID_CONFLICT);      SSL_SESSION_free(ss);      return 0;    }  sess_id_done:    if (s->tlsext_hostname) {      ss->tlsext_hostname = BUF_strdup(s->tlsext_hostname);      if (ss->tlsext_hostname == NULL) {        OPENSSL_PUT_ERROR(SSL, ssl_get_new_session, ERR_R_INTERNAL_ERROR);        SSL_SESSION_free(ss);        return 0;      }    }  } else {    ss->session_id_length = 0;  }  if (s->sid_ctx_length > sizeof(ss->sid_ctx)) {    OPENSSL_PUT_ERROR(SSL, ssl_get_new_session, ERR_R_INTERNAL_ERROR);//.........这里部分代码省略.........

int X509_PURPOSE_add(int id, int trust, int flags,			int (*ck)(const X509_PURPOSE *, const X509 *, int),					char *name, char *sname, void *arg){	int idx;	X509_PURPOSE *ptmp;	char *name_dup, *sname_dup;	/* This is set according to what we change: application can't set it */	flags &= ~X509_PURPOSE_DYNAMIC;	/* This will always be set for application modified trust entries */	flags |= X509_PURPOSE_DYNAMIC_NAME;	/* Get existing entry if any */	idx = X509_PURPOSE_get_by_id(id);	/* Need a new entry */	if(idx == -1) {		if(!(ptmp = OPENSSL_malloc(sizeof(X509_PURPOSE)))) {			OPENSSL_PUT_ERROR(X509V3, X509_PURPOSE_add, ERR_R_MALLOC_FAILURE);			return 0;		}		ptmp->flags = X509_PURPOSE_DYNAMIC;	} else ptmp = X509_PURPOSE_get0(idx);	/* Duplicate the supplied names. */	name_dup = BUF_strdup(name);	sname_dup = BUF_strdup(sname);	if (name_dup == NULL || sname_dup == NULL) {		OPENSSL_PUT_ERROR(X509V3, X509_PURPOSE_add, ERR_R_MALLOC_FAILURE);		if (name_dup != NULL)			OPENSSL_free(name_dup);		if (sname_dup != NULL)			OPENSSL_free(sname_dup);		if (idx == -1)			OPENSSL_free(ptmp);		return 0;	}	/* OPENSSL_free existing name if dynamic */	if(ptmp->flags & X509_PURPOSE_DYNAMIC_NAME) {		OPENSSL_free(ptmp->name);		OPENSSL_free(ptmp->sname);	}	/* dup supplied name */	ptmp->name = name_dup;	ptmp->sname = sname_dup;	/* Keep the dynamic flag of existing entry */	ptmp->flags &= X509_PURPOSE_DYNAMIC;	/* Set all other flags */	ptmp->flags |= flags;	ptmp->purpose = id;	ptmp->trust = trust;	ptmp->check_purpose = ck;	ptmp->usr_data = arg;	/* If its a new entry manage the dynamic table */	if(idx == -1) {		if(!xptable && !(xptable = sk_X509_PURPOSE_new(xp_cmp))) {			OPENSSL_PUT_ERROR(X509V3, X509_PURPOSE_add, ERR_R_MALLOC_FAILURE);			xptable_free(ptmp);			return 0;		}		if (!sk_X509_PURPOSE_push(xptable, ptmp)) {			OPENSSL_PUT_ERROR(X509V3, X509_PURPOSE_add, ERR_R_MALLOC_FAILURE);			xptable_free(ptmp);			return 0;		}	}	return 1;}

//.........这里部分代码省略.........                list_user = 0;            }            else if (userindex < 0)            {                BIO_printf(bio_err, "user /"%s/" does not exist, ignored. t/n",                           user);                errors++;            }        }        else if (add_user)        {            if (userindex >= 0)            {                /* reactivation of a new user */                char **row = sk_OPENSSL_PSTRING_value(db->db->data, userindex);                BIO_printf(bio_err, "user /"%s/" reactivated./n", user);                row[DB_srptype][0] = 'V';                doupdatedb = 1;            }            else            {                char *row[DB_NUMBER] ;                char *gNid;                row[DB_srpverifier] = NULL;                row[DB_srpsalt] = NULL;                row[DB_srpinfo] = NULL;                if (!(gNid = srp_create_user(user,&(row[DB_srpverifier]), &(row[DB_srpsalt]),gNrow?gNrow[DB_srpsalt]:gN,gNrow?gNrow[DB_srpverifier]:NULL, passout, bio_err,verbose)))                {                    BIO_printf(bio_err, "Cannot create srp verifier for user /"%s/", operation abandoned ./n", user);                    errors++;                    goto err;                }                row[DB_srpid] = BUF_strdup(user);                row[DB_srptype] = BUF_strdup("v");                row[DB_srpgN] = BUF_strdup(gNid);                if (!row[DB_srpid] || !row[DB_srpgN] || !row[DB_srptype] || !row[DB_srpverifier] || !row[DB_srpsalt] ||                        (userinfo && (!(row[DB_srpinfo] = BUF_strdup(userinfo)))) ||                        !update_index(db, bio_err, row))                {                    if (row[DB_srpid]) OPENSSL_free(row[DB_srpid]);                    if (row[DB_srpgN]) OPENSSL_free(row[DB_srpgN]);                    if (row[DB_srpinfo]) OPENSSL_free(row[DB_srpinfo]);                    if (row[DB_srptype]) OPENSSL_free(row[DB_srptype]);                    if (row[DB_srpverifier]) OPENSSL_free(row[DB_srpverifier]);                    if (row[DB_srpsalt]) OPENSSL_free(row[DB_srpsalt]);                    goto err;                }                doupdatedb = 1;            }        }        else if (modify_user)        {            if (userindex < 0)            {                BIO_printf(bio_err,"user /"%s/" does not exist, operation ignored./n",user);                errors++;            }            else            {                char **row = sk_OPENSSL_PSTRING_value(db->db->data, userindex);                char type = row[DB_srptype][0];                if (type == 'v')                {

static long set_CSWIFT_LIBNAME(const char *name)	{	free_CSWIFT_LIBNAME();	return (((CSWIFT_LIBNAME = BUF_strdup(name)) != NULL) ? 1 : 0);	}

//.........这里部分代码省略.........  }  /* if search type is rev, check if cert was revoked between start and end date */  if (strcmp(search, "rev") == 0) {    /* ---------------------------------------------------------- *     * Parse the CGI start date string into the start_tm struct   *     * ---------------------------------------------------------- */    memset (&start_tm, '/0', sizeof(start_tm));    strptime(rev_startstr, "%d.%m.%Y %R", &start_tm);    /* ---------------------------------------------------------- *     * Parse the CGI end date string into the end_tm struct       *     * ---------------------------------------------------------- */    memset (&end_tm, '/0', sizeof(end_tm));    strptime(rev_endstr, "%d.%m.%Y %R", &end_tm);    /* ---------------------------------------------------------- *     * Get all revoked certificates from revocation DB index.txt  *     * ---------------------------------------------------------- */    CA_DB *db = NULL;    DB_ATTR db_attr;    if((db = load_index(INDEXFILE, &db_attr)) == NULL)      int_error("Error cannot load CRL certificate database file");    /* ---------------------------------------------------------- *     * Get the certs serial number, convert it into a hex string  *     * -----------------------------------------------------------*/    BIGNUM *bn = NULL;    bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(cert), NULL);    if (!bn)     int_error("Cannot extract serial number from cert into BIGNUM");    char *serialstr = BN_bn2hex(bn);    /* ---------------------------------------------------------- *     * Check if the cert is revoked, looking up its serial in DB  *     * -----------------------------------------------------------*/    char *const *pp;    int i;    for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {      pp = sk_OPENSSL_PSTRING_value(db->db->data, i);      if ( (strcmp(pp[DB_serial], serialstr) == 0)           && (pp[DB_type][0] == DB_TYPE_REV) )  {        /* ---------------------------------------------------------- *         * Revoked, get the certs revocation date from the database   *         * -----------------------------------------------------------*/        char *p = strchr(pp[DB_rev_date], ',');        if (p) *p = '/0'; // if revocation reason is given, terminate before         char *revokedstr = BUF_strdup(pp[DB_rev_date]);        revocation_date = ASN1_UTCTIME_new();        ASN1_UTCTIME_set_string(revocation_date, revokedstr);        //int_error(revokedstr); /* debug correct time parsing */        /* copy the certificate revocation date into a string */        membio = BIO_new(BIO_s_mem());        ASN1_TIME_print(membio, revocation_date);        BIO_gets(membio, membio_buf, sizeof(membio_buf));        BIO_free(membio);        //int_error(membio_buf);        /* parse the revocation date string into a time struct */        memset (&revoked_tm, '/0', sizeof(revoked_tm));        strptime(membio_buf, "%h %d %T %Y %z", &revoked_tm);        //int_error(asctime(&revoked_tm)); /* debug correct time parsing */        /* ---------------------------------------------------------- *         * Check if revocation date >= start date and <= end date     *         * -----------------------------------------------------------*/        if ( difftime(mktime(&start_tm), mktime(&revoked_tm)) <=0 &&             difftime(mktime(&end_tm), mktime(&revoked_tm)) >= 0 ) return 1;      }    }    BN_free(bn);  }  /* if search type is ser, check if serial is between start and end serial */  if (strcmp(search, "ser") == 0) {    /* convert the serial strings to BIGNUM */    BN_dec2bn(&startserialbn, startserstr);    BN_dec2bn(&endserialbn, endserstr);    /* get the certificates serial number and convert it to BIGNUM */    if ((certserial = X509_get_serialNumber(cert)) == NULL)       int_error("Error: Getting certificate serial number in ASN1 format.");    if ((certserialbn = ASN1_INTEGER_to_BN(certserial, NULL)) == NULL)       int_error("Error: converting certserial number from ASN1 to BIGNUM.");    /* debugging output to see values of BIGNUM */    //membio = BIO_new(BIO_s_mem());    //BN_print(membio, endserialbn);    //BIO_gets(membio, membio_buf, sizeof(membio_buf));    //BIO_free(membio);    //int_error(membio_buf);    /* check if certserial >= startserial and <= endserial */    if ( BN_cmp(startserialbn, certserialbn) <= 0 &&         BN_cmp(endserialbn, certserialbn) >= 0 ) return 1;  }  return 0;}

int OCSP_parse_url(const char *url, char **phost, char **pport, char **ppath, int *pssl)	{	char *p, *buf;	char *host, *port;	*phost = NULL;	*pport = NULL;	*ppath = NULL;	/* dup the buffer since we are going to mess with it */	buf = BUF_strdup(url);	if (!buf) goto mem_err;	/* Check for initial colon */	p = strchr(buf, ':');	if (!p) goto parse_err;	*(p++) = '/0';	if (!strcmp(buf, "http"))		{		*pssl = 0;		port = "80";		}	else if (!strcmp(buf, "https"))		{		*pssl = 1;		port = "443";		}	else		goto parse_err;	/* Check for double slash */	if ((p[0] != '/') || (p[1] != '/'))		goto parse_err;	p += 2;	host = p;	/* Check for trailing part of path */	p = strchr(p, '/');	if (!p) 		*ppath = BUF_strdup("/");	else		{		*ppath = BUF_strdup(p);		/* Set start of path to 0 so hostname is valid */		*p = '/0';		}	if (!*ppath) goto mem_err;	/* Look for optional ':' for port number */	if ((p = strchr(host, ':')))		{		*p = 0;		port = p + 1;		}	else		{		/* Not found: set default port */		if (*pssl) port = "443";		else port = "80";		}	*pport = BUF_strdup(port);	if (!*pport) goto mem_err;	*phost = BUF_strdup(host);	if (!*phost) goto mem_err;	OPENSSL_free(buf);	return 1;	mem_err:	OCSPerr(OCSP_F_OCSP_PARSE_URL, ERR_R_MALLOC_FAILURE);	goto err;	parse_err:	OCSPerr(OCSP_F_OCSP_PARSE_URL, OCSP_R_ERROR_PARSING_URL);	err:	if (buf) OPENSSL_free(buf);	if (*ppath) OPENSSL_free(*ppath);	if (*pport) OPENSSL_free(*pport);	if (*phost) OPENSSL_free(*phost);	return 0;	}

//.........这里部分代码省略.........                if (kparam->idx == i) {                    tflags |= CMS_KEY_PARAM;                    break;                }            }            ri = CMS_add1_recipient_cert(cms, x, tflags);            if (!ri)                goto end;            if (kparam) {                EVP_PKEY_CTX *pctx;                pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);                if (!cms_set_pkey_param(pctx, kparam->param))                    goto end;            }            if (CMS_RecipientInfo_type(ri) == CMS_RECIPINFO_AGREE                && wrap_cipher) {                EVP_CIPHER_CTX *wctx;                wctx = CMS_RecipientInfo_kari_get0_ctx(ri);                EVP_EncryptInit_ex(wctx, wrap_cipher, NULL, NULL, NULL);            }        }        if (secret_key) {            if (!CMS_add0_recipient_key(cms, NID_undef,                                        secret_key, secret_keylen,                                        secret_keyid, secret_keyidlen,                                        NULL, NULL, NULL))                goto end;            /* NULL these because call absorbs them */            secret_key = NULL;            secret_keyid = NULL;        }        if (pwri_pass) {            pwri_tmp = (unsigned char *)BUF_strdup((char *)pwri_pass);            if (!pwri_tmp)                goto end;            if (!CMS_add0_recipient_password(cms,                                             -1, NID_undef, NID_undef,                                             pwri_tmp, -1, NULL))                goto end;            pwri_tmp = NULL;        }        if (!(flags & CMS_STREAM)) {            if (!CMS_final(cms, in, NULL, flags))                goto end;        }    } else if (operation == SMIME_ENCRYPTED_ENCRYPT) {        cms = CMS_EncryptedData_encrypt(in, cipher,                                        secret_key, secret_keylen, flags);    } else if (operation == SMIME_SIGN_RECEIPT) {        CMS_ContentInfo *srcms = NULL;        STACK_OF(CMS_SignerInfo) *sis;        CMS_SignerInfo *si;        sis = CMS_get0_SignerInfos(cms);        if (!sis)            goto end;        si = sk_CMS_SignerInfo_value(sis, 0);        srcms = CMS_sign_receipt(si, signer, key, other, flags);        if (!srcms)            goto end;        CMS_ContentInfo_free(cms);        cms = srcms;    } else if (operation & SMIME_SIGNERS) {        int i;        /*

static long set_CCA4758_LIB_NAME(const char *name)	{	free_CCA4758_LIB_NAME();	return (((CCA4758_LIB_NAME = BUF_strdup(name)) != NULL) ? 1 : 0);	}

SSL_SESSION *SSL_SESSION_dup(SSL_SESSION *session, int dup_flags) {  SSL_SESSION *new_session = ssl_session_new(session->x509_method);  if (new_session == NULL) {    goto err;  }  new_session->is_server = session->is_server;  new_session->ssl_version = session->ssl_version;  new_session->sid_ctx_length = session->sid_ctx_length;  OPENSSL_memcpy(new_session->sid_ctx, session->sid_ctx, session->sid_ctx_length);  /* Copy the key material. */  new_session->master_key_length = session->master_key_length;  OPENSSL_memcpy(new_session->master_key, session->master_key,         session->master_key_length);  new_session->cipher = session->cipher;  /* Copy authentication state. */  if (session->psk_identity != NULL) {    new_session->psk_identity = BUF_strdup(session->psk_identity);    if (new_session->psk_identity == NULL) {      goto err;    }  }  if (session->certs != NULL) {    new_session->certs = sk_CRYPTO_BUFFER_new_null();    if (new_session->certs == NULL) {      goto err;    }    for (size_t i = 0; i < sk_CRYPTO_BUFFER_num(session->certs); i++) {      CRYPTO_BUFFER *buffer = sk_CRYPTO_BUFFER_value(session->certs, i);      if (!sk_CRYPTO_BUFFER_push(new_session->certs, buffer)) {        goto err;      }      CRYPTO_BUFFER_up_ref(buffer);    }  }  if (!session->x509_method->session_dup(new_session, session)) {    goto err;  }  new_session->verify_result = session->verify_result;  new_session->ocsp_response_length = session->ocsp_response_length;  if (session->ocsp_response != NULL) {    new_session->ocsp_response = BUF_memdup(session->ocsp_response,                                            session->ocsp_response_length);    if (new_session->ocsp_response == NULL) {      goto err;    }  }  new_session->tlsext_signed_cert_timestamp_list_length =      session->tlsext_signed_cert_timestamp_list_length;  if (session->tlsext_signed_cert_timestamp_list != NULL) {    new_session->tlsext_signed_cert_timestamp_list =        BUF_memdup(session->tlsext_signed_cert_timestamp_list,                   session->tlsext_signed_cert_timestamp_list_length);    if (new_session->tlsext_signed_cert_timestamp_list == NULL) {      goto err;    }  }  OPENSSL_memcpy(new_session->peer_sha256, session->peer_sha256,                 SHA256_DIGEST_LENGTH);  new_session->peer_sha256_valid = session->peer_sha256_valid;  if (session->tlsext_hostname != NULL) {    new_session->tlsext_hostname = BUF_strdup(session->tlsext_hostname);    if (new_session->tlsext_hostname == NULL) {      goto err;    }  }  new_session->peer_signature_algorithm = session->peer_signature_algorithm;  new_session->timeout = session->timeout;  new_session->auth_timeout = session->auth_timeout;  new_session->time = session->time;  /* Copy non-authentication connection properties. */  if (dup_flags & SSL_SESSION_INCLUDE_NONAUTH) {    new_session->session_id_length = session->session_id_length;    OPENSSL_memcpy(new_session->session_id, session->session_id,                   session->session_id_length);    new_session->group_id = session->group_id;    OPENSSL_memcpy(new_session->original_handshake_hash,                   session->original_handshake_hash,                   session->original_handshake_hash_len);    new_session->original_handshake_hash_len =        session->original_handshake_hash_len;    new_session->tlsext_tick_lifetime_hint = session->tlsext_tick_lifetime_hint;    new_session->ticket_age_add = session->ticket_age_add;    new_session->ticket_max_early_data = session->ticket_max_early_data;    new_session->extended_master_secret = session->extended_master_secret;    if (session->early_alpn != NULL) {//.........这里部分代码省略.........

static int capi_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void))	{	int ret = 1;	CAPI_CTX *ctx;	BIO *out;	if (capi_idx == -1)		{		CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_ENGINE_NOT_INITIALIZED);		return 0;		}	ctx = ENGINE_get_ex_data(e, capi_idx);	out = BIO_new_fp(stdout, BIO_NOCLOSE);	switch (cmd)		{		case CAPI_CMD_LIST_CSPS:		ret = capi_list_providers(ctx, out);		break;		case CAPI_CMD_LIST_CERTS:		ret = capi_list_certs(ctx, out, NULL);		break;		case CAPI_CMD_LOOKUP_CERT:		ret = capi_list_certs(ctx, out, p);		break;		case CAPI_CMD_LIST_CONTAINERS:		ret = capi_list_containers(ctx, out);		break;		case CAPI_CMD_STORE_NAME:		if (ctx->storename)			OPENSSL_free(ctx->storename);		ctx->storename = BUF_strdup(p);		CAPI_trace(ctx, "Setting store name to %s/n", p);		break;		case CAPI_CMD_STORE_FLAGS:		if (i & 1)			{			ctx->store_flags |= CERT_SYSTEM_STORE_LOCAL_MACHINE;			ctx->store_flags &= ~CERT_SYSTEM_STORE_CURRENT_USER;			}		else			{			ctx->store_flags |= CERT_SYSTEM_STORE_CURRENT_USER;			ctx->store_flags &= ~CERT_SYSTEM_STORE_LOCAL_MACHINE;			}		CAPI_trace(ctx, "Setting flags to %d/n", i);		break;		case CAPI_CMD_DEBUG_LEVEL:		ctx->debug_level = (int)i;		CAPI_trace(ctx, "Setting debug level to %d/n", ctx->debug_level);		break;		case CAPI_CMD_DEBUG_FILE:		ctx->debug_file = BUF_strdup(p);		CAPI_trace(ctx, "Setting debug file to %s/n", ctx->debug_file);		break;		case CAPI_CMD_KEYTYPE:		ctx->keytype = i;		CAPI_trace(ctx, "Setting key type to %d/n", ctx->keytype);		break;		case CAPI_CMD_SET_CSP_IDX:		ret = capi_ctx_set_provname_idx(ctx, i);		break;		case CAPI_CMD_LIST_OPTIONS:		ctx->dump_flags = i;		break;		case CAPI_CMD_LOOKUP_METHOD:		if (i < 1 || i > 3)			{			CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_INVALID_LOOKUP_METHOD);			return 0;			}		ctx->lookup_method = i;		break;		case CAPI_CMD_SET_CSP_NAME:		ret = capi_ctx_set_provname(ctx, p, ctx->csptype, 1);		break;		case CAPI_CMD_SET_CSP_TYPE:		ctx->csptype = i;		break;		default:		CAPIerr(CAPI_F_CAPI_CTRL, CAPI_R_UNKNOWN_COMMAND);		ret = 0;	}	BIO_free(out);	return ret;	}

//.........这里部分代码省略.........		{		printf("Remove *should* have failed but didn't!/n");		goto end;		}	else		printf("Remove that should fail did./n");	ERR_clear_error();	if(!ENGINE_remove(new_h3))		{		printf("Remove failed!/n");		goto end;		}	display_engine_list();	if(!ENGINE_remove(new_h4))		{		printf("Remove failed!/n");		goto end;		}	display_engine_list();	/* Depending on whether there's any hardware support compiled	 * in, this remove may be destined to fail. */	ptr = ENGINE_get_first();	if(ptr)		if(!ENGINE_remove(ptr))			printf("Remove failed!i - probably no hardware "				"support present./n");	if (ptr)		ENGINE_free(ptr);	display_engine_list();	if(!ENGINE_add(new_h1) || !ENGINE_remove(new_h1))		{		printf("Couldn't add and remove to an empty list!/n");		goto end;		}	else		printf("Successfully added and removed to an empty list!/n");	printf("About to beef up the engine-type list/n");	for(loop = 0; loop < 512; loop++)		{		sprintf(buf, "id%i", loop);		id = BUF_strdup(buf);		sprintf(buf, "Fake engine type %i", loop);		name = BUF_strdup(buf);		if(((block[loop] = ENGINE_new()) == NULL) ||				!ENGINE_set_id(block[loop], id) ||				!ENGINE_set_name(block[loop], name))			{			printf("Couldn't create block of ENGINE structures./n"				"I'll probably also core-dump now, damn./n");			goto end;			}		}	for(loop = 0; loop < 512; loop++)		{		if(!ENGINE_add(block[loop]))			{			printf("/nAdding stopped at %i, (%s,%s)/n",				loop, ENGINE_get_id(block[loop]),				ENGINE_get_name(block[loop]));			goto cleanup_loop;			}		else			printf("."); fflush(stdout);		}cleanup_loop:	printf("/nAbout to empty the engine-type list/n");	while((ptr = ENGINE_get_first()) != NULL)		{		if(!ENGINE_remove(ptr))			{			printf("/nRemove failed!/n");			goto end;			}		ENGINE_free(ptr);		printf("."); fflush(stdout);		}	for(loop = 0; loop < 512; loop++)		{		OPENSSL_free((void *)ENGINE_get_id(block[loop]));		OPENSSL_free((void *)ENGINE_get_name(block[loop]));		}	printf("/nTests completed happily/n");	to_return = 0;end:	if(to_return)		ERR_print_errors_fp(stderr);	if(new_h1) ENGINE_free(new_h1);	if(new_h2) ENGINE_free(new_h2);	if(new_h3) ENGINE_free(new_h3);	if(new_h4) ENGINE_free(new_h4);	for(loop = 0; loop < 512; loop++)		if(block[loop])			ENGINE_free(block[loop]);	ENGINE_cleanup();	CRYPTO_cleanup_all_ex_data();	ERR_free_strings();	ERR_remove_thread_state(NULL);	CRYPTO_mem_leaks_fp(stderr);	return to_return;	}

static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)	{	BIO *dbio;	int *ip;	long ret=1;	BIO_ACCEPT *data;	char **pp;	data=(BIO_ACCEPT *)b->ptr;	switch (cmd)		{	case BIO_CTRL_RESET:		ret=0;		data->state=ACPT_S_BEFORE;		acpt_close_socket(b);		b->flags=0;		break;	case BIO_C_DO_STATE_MACHINE:		/* use this one to start the connection */		ret=(long)acpt_state(b,data);		break;	case BIO_C_SET_ACCEPT:		if (ptr != NULL)			{			if (num == 0)				{				b->init=1;				if (data->param_addr != NULL)					OPENSSL_free(data->param_addr);				data->param_addr=BUF_strdup(ptr);				}			else if (num == 1)				{				data->accept_nbio=(ptr != NULL);				}			else if (num == 2)				{				if (data->bio_chain != NULL)					BIO_free(data->bio_chain);				data->bio_chain=(BIO *)ptr;				}			}		break;	case BIO_C_SET_NBIO:		data->nbio=(int)num;		break;	case BIO_C_SET_FD:		b->init=1;		b->num= *((int *)ptr);		data->accept_sock=b->num;		data->state=ACPT_S_GET_ACCEPT_SOCKET;		b->shutdown=(int)num;		b->init=1;		break;	case BIO_C_GET_FD:		if (b->init)			{			ip=(int *)ptr;			if (ip != NULL)				*ip=data->accept_sock;			ret=data->accept_sock;			}		else			ret= -1;		break;	case BIO_C_GET_ACCEPT:		if (b->init)			{			if (ptr != NULL)				{				pp=(char **)ptr;				*pp=data->param_addr;				}			else				ret= -1;			}		else			ret= -1;		break;	case BIO_CTRL_GET_CLOSE:		ret=b->shutdown;		break;	case BIO_CTRL_SET_CLOSE:		b->shutdown=(int)num;		break;	case BIO_CTRL_PENDING:	case BIO_CTRL_WPENDING:		ret=0;		break;	case BIO_CTRL_FLUSH:		break;	case BIO_C_SET_BIND_MODE:		data->bind_mode=(int)num;		break;	case BIO_C_GET_BIND_MODE:		ret=(long)data->bind_mode;		break;	case BIO_CTRL_DUP:		dbio=(BIO *)ptr;//.........这里部分代码省略.........

//.........这里部分代码省略.........            } else if (userindex < 0) {                BIO_printf(bio_err,                           "user /"%s/" does not exist, ignored. t/n", user);                errors++;            }        } else if (mode == OPT_ADD) {            if (userindex >= 0) {                /* reactivation of a new user */                char **row =                    sk_OPENSSL_PSTRING_value(db->db->data, userindex);                BIO_printf(bio_err, "user /"%s/" reactivated./n", user);                row[DB_srptype][0] = 'V';                doupdatedb = 1;            } else {                char *row[DB_NUMBER];                char *gNid;                row[DB_srpverifier] = NULL;                row[DB_srpsalt] = NULL;                row[DB_srpinfo] = NULL;                if (!                    (gNid =                     srp_create_user(user, &(row[DB_srpverifier]),                                     &(row[DB_srpsalt]),                                     gNrow ? gNrow[DB_srpsalt] : gN,                                     gNrow ? gNrow[DB_srpverifier] : NULL,                                     passout, verbose))) {                    BIO_printf(bio_err,                               "Cannot create srp verifier for user /"%s/", operation abandoned ./n",                               user);                    errors++;                    goto end;                }                row[DB_srpid] = BUF_strdup(user);                row[DB_srptype] = BUF_strdup("v");                row[DB_srpgN] = BUF_strdup(gNid);                if ((row[DB_srpid] == NULL)                    || (row[DB_srpgN] == NULL)                    || (row[DB_srptype] == NULL)                    || (row[DB_srpverifier] == NULL)                    || (row[DB_srpsalt] == NULL)                    || (userinfo                        && ((row[DB_srpinfo] = BUF_strdup(userinfo)) == NULL))                    || !update_index(db, row)) {                    OPENSSL_free(row[DB_srpid]);                    OPENSSL_free(row[DB_srpgN]);                    OPENSSL_free(row[DB_srpinfo]);                    OPENSSL_free(row[DB_srptype]);                    OPENSSL_free(row[DB_srpverifier]);                    OPENSSL_free(row[DB_srpsalt]);                    goto end;                }                doupdatedb = 1;            }        } else if (mode == OPT_MODIFY) {            if (userindex < 0) {                BIO_printf(bio_err,                           "user /"%s/" does not exist, operation ignored./n",                           user);                errors++;            } else {                char **row =                    sk_OPENSSL_PSTRING_value(db->db->data, userindex);                char type = row[DB_srptype][0];