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

//.........这里部分代码省略.........    if (state_index > state_num)        state_index %= state_num;    /*     * state[st_idx], ..., state[(st_idx + num_ceil - 1) % st_num] are now     * ours (but other threads may use them too)     */    md_count[0] += 1;    /* before unlocking, we must clear 'crypto_lock_rand' */    crypto_lock_rand = 0;    ASYNC_unblock_pause();    CRYPTO_THREAD_unlock(rand_lock);    while (num > 0) {        /* num_ceil -= MD_DIGEST_LENGTH/2 */        j = (num >= MD_DIGEST_LENGTH / 2) ? MD_DIGEST_LENGTH / 2 : num;        num -= j;        if (!MD_Init(m))            goto err;#ifndef GETPID_IS_MEANINGLESS        if (curr_pid) {         /* just in the first iteration to save time */            if (!MD_Update(m, (unsigned char *)&curr_pid, sizeof curr_pid))                goto err;            curr_pid = 0;        }#endif        if (curr_time) {        /* just in the first iteration to save time */            if (!MD_Update(m, (unsigned char *)&curr_time, sizeof curr_time))                goto err;            if (!MD_Update(m, (unsigned char *)&tv, sizeof tv))                goto err;            curr_time = 0;            if (!rand_hw_seed(m))                goto err;        }        if (!MD_Update(m, local_md, MD_DIGEST_LENGTH))            goto err;        if (!MD_Update(m, (unsigned char *)&(md_c[0]), sizeof(md_c)))            goto err;        k = (st_idx + MD_DIGEST_LENGTH / 2) - st_num;        if (k > 0) {            if (!MD_Update(m, &(state[st_idx]), MD_DIGEST_LENGTH / 2 - k))                goto err;            if (!MD_Update(m, &(state[0]), k))                goto err;        } else if (!MD_Update(m, &(state[st_idx]), MD_DIGEST_LENGTH / 2))            goto err;        if (!MD_Final(m, local_md))            goto err;        for (i = 0; i < MD_DIGEST_LENGTH / 2; i++) {            /* may compete with other threads */            state[st_idx++] ^= local_md[i];            if (st_idx >= st_num)                st_idx = 0;            if (i < j)                *(buf++) = local_md[i + MD_DIGEST_LENGTH / 2];        }    }    if (!MD_Init(m)        || !MD_Update(m, (unsigned char *)&(md_c[0]), sizeof(md_c))        || !MD_Update(m, local_md, MD_DIGEST_LENGTH))        goto err;    CRYPTO_THREAD_write_lock(rand_lock);    /*     * Prevent deadlocks if we end up in an async engine     */    ASYNC_block_pause();    if (!MD_Update(m, md, MD_DIGEST_LENGTH) || !MD_Final(m, md)) {        CRYPTO_THREAD_unlock(rand_lock);        goto err;    }    ASYNC_unblock_pause();    CRYPTO_THREAD_unlock(rand_lock);    EVP_MD_CTX_free(m);    if (ok)        return (1);    else if (pseudo)        return 0;    else {        RANDerr(RAND_F_RAND_BYTES, RAND_R_PRNG_NOT_SEEDED);        ERR_add_error_data(1, "You need to read the OpenSSL FAQ, "                           "https://www.openssl.org/docs/faq.html");        return (0);    } err:    RANDerr(RAND_F_RAND_BYTES, ERR_R_EVP_LIB);    EVP_MD_CTX_free(m);    return 0; err_mem:    RANDerr(RAND_F_RAND_BYTES, ERR_R_MALLOC_FAILURE);    EVP_MD_CTX_free(m);    return 0;}

//.........这里部分代码省略.........		while (n > 0)			{#if MD_DIGEST_LENGTH > 20# error "Please adjust DUMMY_SEED."#endif#define DUMMY_SEED "...................." /* at least MD_DIGEST_LENGTH */			/* Note that the seed does not matter, it's just that			 * ssleay_rand_add expects to have something to hash. */			ssleay_rand_add(DUMMY_SEED, MD_DIGEST_LENGTH, 0.0);			n -= MD_DIGEST_LENGTH;			}		if (ok)			stirred_pool = 1;		}	st_idx=state_index;	st_num=state_num;	md_c[0] = md_count[0];	md_c[1] = md_count[1];	TINYCLR_SSL_MEMCPY(local_md, md, sizeof md);	state_index+=num_ceil;	if (state_index > state_num)		state_index %= state_num;	/* state[st_idx], ..., state[(st_idx + num_ceil - 1) % st_num]	 * are now ours (but other threads may use them too) */	md_count[0] += 1;	/* before unlocking, we must clear 'crypto_lock_rand' */	crypto_lock_rand = 0;	CRYPTO_w_unlock(CRYPTO_LOCK_RAND);	while (num > 0)		{		/* num_ceil -= MD_DIGEST_LENGTH/2 */		j=(num >= MD_DIGEST_LENGTH/2)?MD_DIGEST_LENGTH/2:num;		num-=j;		MD_Init(&m);#ifndef GETPID_IS_MEANINGLESS		if (curr_pid) /* just in the first iteration to save time */			{			MD_Update(&m,(unsigned char*)&curr_pid,sizeof curr_pid);			curr_pid = 0;			}#endif		MD_Update(&m,local_md,MD_DIGEST_LENGTH);		MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c));#ifndef PURIFY /* purify complains */		/* The following line uses the supplied buffer as a small		 * source of entropy: since this buffer is often uninitialised		 * it may cause programs such as purify or valgrind to		 * complain. So for those builds it is not used: the removal		 * of such a small source of entropy has negligible impact on		 * security.		 */		MD_Update(&m,buf,j);#endif		k=(st_idx+MD_DIGEST_LENGTH/2)-st_num;		if (k > 0)			{			MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2-k);			MD_Update(&m,&(state[0]),k);			}		else			MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2);		MD_Final(&m,local_md);		for (i=0; i<MD_DIGEST_LENGTH/2; i++)			{			state[st_idx++]^=local_md[i]; /* may compete with other threads */			if (st_idx >= st_num)				st_idx=0;			if (i < j)				*(buf++)=local_md[i+MD_DIGEST_LENGTH/2];			}		}	MD_Init(&m);	MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c));	MD_Update(&m,local_md,MD_DIGEST_LENGTH);	CRYPTO_w_lock(CRYPTO_LOCK_RAND);	MD_Update(&m,md,MD_DIGEST_LENGTH);	MD_Final(&m,md);	CRYPTO_w_unlock(CRYPTO_LOCK_RAND);	EVP_MD_CTX_cleanup(&m);	if (ok)		return(1);	else		{		RANDerr(RAND_F_SSLEAY_RAND_BYTES,RAND_R_PRNG_NOT_SEEDED);		ERR_add_error_data(1, "You need to read the OpenSSL FAQ, "			"http://www.openssl.org/support/faq.html");		return(0);		}	}

static char *vms_merger(DSO *dso, const char *filespec1,                        const char *filespec2){    int status;    int filespec1len, filespec2len;    struct FAB fab;    struct NAMX_STRUCT nam;    char esa[NAMX_MAXRSS + 1];    char *merged;/* Arrange 32-bit pointer to (copied) string storage, if needed. */# if __INITIAL_POINTER_SIZE == 64#  define FILESPEC1 filespec1_32p;#  define FILESPEC2 filespec2_32p;#  pragma pointer_size save#  pragma pointer_size 32    char *filespec1_32p;    char *filespec2_32p;#  pragma pointer_size restore    char filespec1_32[NAMX_MAXRSS + 1];    char filespec2_32[NAMX_MAXRSS + 1];# else                          /* __INITIAL_POINTER_SIZE == 64 */#  define FILESPEC1 ((char *) filespec1)#  define FILESPEC2 ((char *) filespec2)# endif                         /* __INITIAL_POINTER_SIZE == 64 [else] */    if (!filespec1)        filespec1 = "";    if (!filespec2)        filespec2 = "";    filespec1len = strlen(filespec1);    filespec2len = strlen(filespec2);# if __INITIAL_POINTER_SIZE == 64    /* Copy the file names to storage with a 32-bit pointer. */    filespec1_32p = filespec1_32;    filespec2_32p = filespec2_32;    strcpy(filespec1_32p, filespec1);    strcpy(filespec2_32p, filespec2);# endif                         /* __INITIAL_POINTER_SIZE == 64 [else] */    fab = cc$rms_fab;    nam = CC_RMS_NAMX;    FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNA = FILESPEC1;    FAB_OR_NAML(fab, nam).FAB_OR_NAML_FNS = filespec1len;    FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNA = FILESPEC2;    FAB_OR_NAML(fab, nam).FAB_OR_NAML_DNS = filespec2len;    NAMX_DNA_FNA_SET(fab)        nam.NAMX_ESA = esa;    nam.NAMX_ESS = NAMX_MAXRSS;    nam.NAMX_NOP = NAM$M_SYNCHK | NAM$M_PWD;    SET_NAMX_NO_SHORT_UPCASE(nam);    fab.FAB_NAMX = &nam;    status = sys$parse(&fab, 0, 0);    if (!$VMS_STATUS_SUCCESS(status)) {        unsigned short length;        char errstring[257];        struct dsc$descriptor_s errstring_dsc;        errstring_dsc.dsc$w_length = sizeof(errstring);        errstring_dsc.dsc$b_dtype = DSC$K_DTYPE_T;        errstring_dsc.dsc$b_class = DSC$K_CLASS_S;        errstring_dsc.dsc$a_pointer = errstring;        status = sys$getmsg(status, &length, &errstring_dsc, 1, 0);        if (!$VMS_STATUS_SUCCESS(status))            lib$signal(status); /* This is really bad.  Abort! */        else {            errstring[length] = '/0';            DSOerr(DSO_F_VMS_MERGER, DSO_R_FAILURE);            ERR_add_error_data(7,                               "filespec /"", filespec1, "/", ",                               "defaults /"", filespec2, "/": ", errstring);        }        return (NULL);    }    merged = OPENSSL_malloc(nam.NAMX_ESL + 1);    if (!merged)        goto malloc_err;    strncpy(merged, nam.NAMX_ESA, nam.NAMX_ESL);    merged[nam.NAMX_ESL] = '/0';    return (merged); malloc_err:    DSOerr(DSO_F_VMS_MERGER, ERR_R_MALLOC_FAILURE);}

//.........这里部分代码省略.........		/* Dangerous to set stdin/stdout to raw (unless redirected) */		else			{			if (fd == STDIN_FILENO || fd == STDOUT_FILENO)				{				if (isatty(fd) <= 0)					_setmode(fd,_O_BINARY);				}			else				_setmode(fd,_O_BINARY);			}#elif defined(OPENSSL_SYS_OS2)		int fd = fileno((FILE*)ptr);		if (num & BIO_FP_TEXT)			setmode(fd, O_TEXT);		else			setmode(fd, O_BINARY);#endif		}		break;	case BIO_C_SET_FILENAME:		file_free(b);		b->shutdown=(int)num&BIO_CLOSE;		if (num & BIO_FP_APPEND)			{			if (num & BIO_FP_READ)				BUF_strlcpy(p,"a+",sizeof p);			else	BUF_strlcpy(p,"a",sizeof p);			}		else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))			BUF_strlcpy(p,"r+",sizeof p);		else if (num & BIO_FP_WRITE)			BUF_strlcpy(p,"w",sizeof p);		else if (num & BIO_FP_READ)			BUF_strlcpy(p,"r",sizeof p);		else			{			BIOerr(BIO_F_FILE_CTRL,BIO_R_BAD_FOPEN_MODE);			ret=0;			break;			}#if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN)		if (!(num & BIO_FP_TEXT))			strcat(p,"b");		else			strcat(p,"t");#endif#if defined(OPENSSL_SYS_NETWARE)		if (!(num & BIO_FP_TEXT))			strcat(p,"b");		else			strcat(p,"t");#endif		fp=fopen(ptr,p);		if (fp == NULL)			{			SYSerr(SYS_F_FOPEN,get_last_sys_error());			ERR_add_error_data(5,"fopen('",ptr,"','",p,"')");			BIOerr(BIO_F_FILE_CTRL,ERR_R_SYS_LIB);			ret=0;			break;			}		b->ptr=fp;		b->init=1;		BIO_clear_flags(b,BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */		break;	case BIO_C_GET_FILE_PTR:		/* the ptr parameter is actually a FILE ** in this case. */		if (ptr != NULL)			{			fpp=(FILE **)ptr;			*fpp=(FILE *)b->ptr;			}		break;	case BIO_CTRL_GET_CLOSE:		ret=(long)b->shutdown;		break;	case BIO_CTRL_SET_CLOSE:		b->shutdown=(int)num;		break;	case BIO_CTRL_FLUSH:		if (b->flags&BIO_FLAGS_UPLINK)			UP_fflush(b->ptr);		else			fflush((FILE *)b->ptr);		break;	case BIO_CTRL_DUP:		ret=1;		break;	case BIO_CTRL_WPENDING:	case BIO_CTRL_PENDING:	case BIO_CTRL_PUSH:	case BIO_CTRL_POP:	default:		ret=0;		break;		}	return(ret);	}

int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,					int inform, unsigned long mask, 					long minsize, long maxsize){	int str_type;	int ret;	char free_out;	int outform, outlen = 0;	ASN1_STRING *dest;	unsigned char *p;	int nchar;	char strbuf[32];	int (*cpyfunc)(unsigned long,void *) = NULL;	if(len == -1) len = strlen((const char *)in);	if(!mask) mask = DIRSTRING_TYPE;	/* First do a string check and work out the number of characters */	switch(inform) {		case MBSTRING_BMP:		if(len & 1) {			ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,					 ASN1_R_INVALID_BMPSTRING_LENGTH);			return -1;		}		nchar = len >> 1;		break;		case MBSTRING_UNIV:		if(len & 3) {			ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,					 ASN1_R_INVALID_UNIVERSALSTRING_LENGTH);			return -1;		}		nchar = len >> 2;		break;		case MBSTRING_UTF8:		nchar = 0;		/* This counts the characters and does utf8 syntax checking */		ret = traverse_string(in, len, MBSTRING_UTF8, in_utf8, &nchar);		if(ret < 0) {			ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY,						 ASN1_R_INVALID_UTF8STRING);			return -1;		}		break;		case MBSTRING_ASC:		nchar = len;		break;		default:		ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_UNKNOWN_FORMAT);		return -1;	}	if((minsize > 0) && (nchar < minsize)) {		ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_SHORT);		BIO_snprintf(strbuf, sizeof strbuf, "%ld", minsize);		ERR_add_error_data(2, "minsize=", strbuf);		return -1;	}	if((maxsize > 0) && (nchar > maxsize)) {		ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_LONG);		BIO_snprintf(strbuf, sizeof strbuf, "%ld", maxsize);		ERR_add_error_data(2, "maxsize=", strbuf);		return -1;	}	/* Now work out minimal type (if any) */	if(traverse_string(in, len, inform, type_str, &mask) < 0) {		ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_ILLEGAL_CHARACTERS);		return -1;	}	/* Now work out output format and string type */	outform = MBSTRING_ASC;	if(mask & B_ASN1_PRINTABLESTRING) str_type = V_ASN1_PRINTABLESTRING;	else if(mask & B_ASN1_IA5STRING) str_type = V_ASN1_IA5STRING;	else if(mask & B_ASN1_T61STRING) str_type = V_ASN1_T61STRING;	else if(mask & B_ASN1_BMPSTRING) {		str_type = V_ASN1_BMPSTRING;		outform = MBSTRING_BMP;	} else if(mask & B_ASN1_UNIVERSALSTRING) {		str_type = V_ASN1_UNIVERSALSTRING;		outform = MBSTRING_UNIV;	} else {		str_type = V_ASN1_UTF8STRING;		outform = MBSTRING_UTF8;	}	if(!out) return str_type;	if(*out) {		free_out = 0;		dest = *out;		if(dest->data) {			dest->length = 0;			OPENSSL_free(dest->data);//.........这里部分代码省略.........

int UI_set_result(UI *ui, UI_STRING *uis, const char *result){    int l = strlen(result);    ui->flags &= ~UI_FLAG_REDOABLE;    if (!uis)        return -1;    switch (uis->type) {    case UIT_PROMPT:    case UIT_VERIFY:        {            char number1[DECIMAL_SIZE(uis->_.string_data.result_minsize) + 1];            char number2[DECIMAL_SIZE(uis->_.string_data.result_maxsize) + 1];            BIO_snprintf(number1, sizeof(number1), "%d",                         uis->_.string_data.result_minsize);            BIO_snprintf(number2, sizeof(number2), "%d",                         uis->_.string_data.result_maxsize);            if (l < uis->_.string_data.result_minsize) {                ui->flags |= UI_FLAG_REDOABLE;                UIerr(UI_F_UI_SET_RESULT, UI_R_RESULT_TOO_SMALL);                ERR_add_error_data(5, "You must type in ",                                   number1, " to ", number2, " characters");                return -1;            }            if (l > uis->_.string_data.result_maxsize) {                ui->flags |= UI_FLAG_REDOABLE;                UIerr(UI_F_UI_SET_RESULT, UI_R_RESULT_TOO_LARGE);                ERR_add_error_data(5, "You must type in ",                                   number1, " to ", number2, " characters");                return -1;            }        }        if (!uis->result_buf) {            UIerr(UI_F_UI_SET_RESULT, UI_R_NO_RESULT_BUFFER);            return -1;        }        BUF_strlcpy(uis->result_buf, result,                    uis->_.string_data.result_maxsize + 1);        break;    case UIT_BOOLEAN:        {            const char *p;            if (!uis->result_buf) {                UIerr(UI_F_UI_SET_RESULT, UI_R_NO_RESULT_BUFFER);                return -1;            }            uis->result_buf[0] = '/0';            for (p = result; *p; p++) {                if (strchr(uis->_.boolean_data.ok_chars, *p)) {                    uis->result_buf[0] = uis->_.boolean_data.ok_chars[0];                    break;                }                if (strchr(uis->_.boolean_data.cancel_chars, *p)) {                    uis->result_buf[0] = uis->_.boolean_data.cancel_chars[0];                    break;                }            }        }    default:        break;    }    return 0;}

ENGINE *ENGINE_by_id(const char *id)	{	ENGINE *iterator;	char *load_dir = NULL;	if(id == NULL)		{		ENGINEerr(ENGINE_F_ENGINE_BY_ID,			ERR_R_PASSED_NULL_PARAMETER);		return NULL;		}	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);	iterator = engine_list_head;	while(iterator && (strcmp(id, iterator->id) != 0))		iterator = iterator->next;	if(iterator)		{		/* We need to return a structural reference. If this is an		 * ENGINE type that returns copies, make a duplicate - otherwise		 * increment the existing ENGINE's reference count. */		if(iterator->flags & ENGINE_FLAGS_BY_ID_COPY)			{			ENGINE *cp = ENGINE_new();			if(!cp)				iterator = NULL;			else				{				engine_cpy(cp, iterator);				iterator = cp;				}			}		else			{			iterator->struct_ref++;			engine_ref_debug(iterator, 0, 1)			}		}	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);#if 0	if(iterator == NULL)		{		ENGINEerr(ENGINE_F_ENGINE_BY_ID,			ENGINE_R_NO_SUCH_ENGINE);		ERR_add_error_data(2, "id=", id);		}	return iterator;#else	/* EEK! Experimental code starts */	if(iterator) return iterator;	/* Prevent infinite recusrion if we're looking for the dynamic engine. */	if (strcmp(id, "dynamic"))		{#ifdef OPENSSL_SYS_VMS		if((load_dir = getenv("OPENSSL_ENGINES")) == 0) load_dir = "SSLROOT:[ENGINES]";#else		if((load_dir = getenv("OPENSSL_ENGINES")) == 0) load_dir = ENGINESDIR;#endif		iterator = ENGINE_by_id("dynamic");		if(!iterator || !ENGINE_ctrl_cmd_string(iterator, "ID", id, 0) ||				!ENGINE_ctrl_cmd_string(iterator, "DIR_LOAD", "2", 0) ||				!ENGINE_ctrl_cmd_string(iterator, "DIR_ADD",					load_dir, 0) ||				!ENGINE_ctrl_cmd_string(iterator, "LOAD", NULL, 0))				goto notfound;		return iterator;		}notfound:	ENGINE_free(iterator);	ENGINEerr(ENGINE_F_ENGINE_BY_ID,ENGINE_R_NO_SUCH_ENGINE);	ERR_add_error_data(2, "id=", id);	return NULL;	/* EEK! Experimental code ends */#endif	}

static int ssl_module_init(CONF_IMODULE *md, const CONF *cnf){    size_t i, j, cnt;    int rv = 0;    const char *ssl_conf_section;    STACK_OF(CONF_VALUE) *cmd_lists;    ssl_conf_section = CONF_imodule_get_value(md);    cmd_lists = NCONF_get_section(cnf, ssl_conf_section);    if (sk_CONF_VALUE_num(cmd_lists) <= 0) {        if (cmd_lists == NULL)            SSLerr(SSL_F_SSL_MODULE_INIT, SSL_R_SSL_SECTION_NOT_FOUND);        else            SSLerr(SSL_F_SSL_MODULE_INIT, SSL_R_SSL_SECTION_EMPTY);        ERR_add_error_data(2, "section=", ssl_conf_section);        goto err;    }    cnt = sk_CONF_VALUE_num(cmd_lists);    ssl_names = OPENSSL_zalloc(sizeof(*ssl_names) * cnt);    ssl_names_count = cnt;    for (i = 0; i < ssl_names_count; i++) {        struct ssl_conf_name *ssl_name = ssl_names + i;        CONF_VALUE *sect = sk_CONF_VALUE_value(cmd_lists, i);        STACK_OF(CONF_VALUE) *cmds = NCONF_get_section(cnf, sect->value);        if (sk_CONF_VALUE_num(cmds) <= 0) {            if (cmds == NULL)                SSLerr(SSL_F_SSL_MODULE_INIT, SSL_R_SSL_COMMAND_SECTION_NOT_FOUND);            else                SSLerr(SSL_F_SSL_MODULE_INIT, SSL_R_SSL_COMMAND_SECTION_EMPTY);            ERR_add_error_data(4, "name=", sect->name, ", value=", sect->value);            goto err;        }        ssl_name->name = BUF_strdup(sect->name);        if (ssl_name->name == NULL)            goto err;        cnt = sk_CONF_VALUE_num(cmds);        ssl_name->cmds = OPENSSL_zalloc(cnt * sizeof(struct ssl_conf_cmd));        if (ssl_name->cmds == NULL)            goto err;        ssl_name->cmd_count = cnt;        for (j = 0; j < cnt; j++) {            const char *name;            CONF_VALUE *cmd_conf = sk_CONF_VALUE_value(cmds, j);            struct ssl_conf_cmd *cmd = ssl_name->cmds + j;            /* Skip any initial dot in name */            name = strchr(cmd_conf->name, '.');            if (name != NULL)                name++;            else                name = cmd_conf->name;            cmd->cmd = BUF_strdup(name);            cmd->arg = BUF_strdup(cmd_conf->value);            if (cmd->cmd == NULL || cmd->arg == NULL)                goto err;        }    }    rv = 1;    err:    if (rv == 0)        ssl_module_free(md);    return rv;}

static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr){    long ret=1;    FILE *fp=(FILE *)b->ptr;    FILE **fpp;    char p[4];    switch (cmd)    {    case BIO_C_FILE_SEEK:    case BIO_CTRL_RESET:        ret=(long)fseek(fp,num,0);        break;    case BIO_CTRL_EOF:        ret=(long)feof(fp);        break;    case BIO_C_FILE_TELL:    case BIO_CTRL_INFO:        ret=ftell(fp);        break;    case BIO_C_SET_FILE_PTR:        file_free(b);        b->shutdown=(int)num&BIO_CLOSE;        b->ptr=(char *)ptr;        b->init=1;#if defined(OPENSSL_SYS_WINDOWS)        if (num & BIO_FP_TEXT)            _setmode(fileno((FILE *)ptr),_O_TEXT);        else            _setmode(fileno((FILE *)ptr),_O_BINARY);#elif defined(OPENSSL_SYS_MSDOS)        {            int fd = fileno((FILE*)ptr);            /* Set correct text/binary mode */            if (num & BIO_FP_TEXT)                _setmode(fd,_O_TEXT);            /* Dangerous to set stdin/stdout to raw (unless redirected) */            else            {                if (fd == STDIN_FILENO || fd == STDOUT_FILENO)                {                    if (isatty(fd) <= 0)                        _setmode(fd,_O_BINARY);                }                else                    _setmode(fd,_O_BINARY);            }        }#elif defined(OPENSSL_SYS_OS2)        if (num & BIO_FP_TEXT)            setmode(fileno((FILE *)ptr), O_TEXT);        else            setmode(fileno((FILE *)ptr), O_BINARY);#endif        break;    case BIO_C_SET_FILENAME:        file_free(b);        b->shutdown=(int)num&BIO_CLOSE;        if (num & BIO_FP_APPEND)        {            if (num & BIO_FP_READ)                BUF_strlcpy(p,"a+",sizeof p);            else	BUF_strlcpy(p,"a",sizeof p);        }        else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))            BUF_strlcpy(p,"r+",sizeof p);        else if (num & BIO_FP_WRITE)            BUF_strlcpy(p,"w",sizeof p);        else if (num & BIO_FP_READ)            BUF_strlcpy(p,"r",sizeof p);        else        {            BIOerr(BIO_F_FILE_CTRL,BIO_R_BAD_FOPEN_MODE);            ret=0;            break;        }#if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2)        if (!(num & BIO_FP_TEXT))            strcat(p,"b");        else            strcat(p,"t");#endif        fp=fopen(ptr,p);        if (fp == NULL)        {            SYSerr(SYS_F_FOPEN,get_last_sys_error());            ERR_add_error_data(5,"fopen('",ptr,"','",p,"')");            BIOerr(BIO_F_FILE_CTRL,ERR_R_SYS_LIB);            ret=0;            break;        }        b->ptr=(char *)fp;        b->init=1;        break;    case BIO_C_GET_FILE_PTR:        /* the ptr parameter is actually a FILE ** in this case. */        if (ptr != NULL)        {            fpp=(FILE **)ptr;            *fpp=(FILE *)b->ptr;//.........这里部分代码省略.........

static EVP_PKEY *capi_get_pkey(ENGINE *eng, CAPI_KEY *key)	{	unsigned char *pubkey = NULL;	DWORD len;	BLOBHEADER *bh;	RSA *rkey = NULL;	DSA *dkey = NULL;	EVP_PKEY *ret = NULL;	if (!CryptExportKey(key->key, 0, PUBLICKEYBLOB, 0, NULL, &len))		{		CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_PUBKEY_EXPORT_LENGTH_ERROR);		capi_addlasterror();		return NULL;		}	pubkey = OPENSSL_malloc(len);	if (!pubkey)		goto memerr;	if (!CryptExportKey(key->key, 0, PUBLICKEYBLOB, 0, pubkey, &len))		{		CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_PUBKEY_EXPORT_ERROR);		capi_addlasterror();		goto err;		}	bh = (BLOBHEADER *)pubkey;	if (bh->bType != PUBLICKEYBLOB)		{		CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_INVALID_PUBLIC_KEY_BLOB);		goto err;		}	if (bh->aiKeyAlg == CALG_RSA_SIGN || bh->aiKeyAlg == CALG_RSA_KEYX)		{		RSAPUBKEY *rp;		DWORD rsa_modlen;		unsigned char *rsa_modulus;		rp = (RSAPUBKEY *)(bh + 1);		if (rp->magic != 0x31415352)			{			char magstr[10];			BIO_snprintf(magstr, 10, "%lx", rp->magic);			CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_INVALID_RSA_PUBLIC_KEY_BLOB_MAGIC_NUMBER);			ERR_add_error_data(2, "magic=0x", magstr);			goto err;			}		rsa_modulus = (unsigned char *)(rp + 1);		rkey = RSA_new_method(eng);		if (!rkey)			goto memerr;		rkey->e = BN_new();		rkey->n = BN_new();		if (!rkey->e || !rkey->n)			goto memerr;		if (!BN_set_word(rkey->e, rp->pubexp))			goto memerr;		rsa_modlen = rp->bitlen / 8;		if (!lend_tobn(rkey->n, rsa_modulus, rsa_modlen))			goto memerr;		RSA_set_ex_data(rkey, rsa_capi_idx, key);		if (!(ret = EVP_PKEY_new()))			goto memerr;		EVP_PKEY_assign_RSA(ret, rkey);		rkey = NULL;		}	else if (bh->aiKeyAlg == CALG_DSS_SIGN)		{		DSSPUBKEY *dp;		DWORD dsa_plen;		unsigned char *btmp;		dp = (DSSPUBKEY *)(bh + 1);		if (dp->magic != 0x31535344)			{			char magstr[10];			BIO_snprintf(magstr, 10, "%lx", dp->magic);			CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_INVALID_DSA_PUBLIC_KEY_BLOB_MAGIC_NUMBER);			ERR_add_error_data(2, "magic=0x", magstr);			goto err;			}		dsa_plen = dp->bitlen / 8;		btmp = (unsigned char *)(dp + 1);		dkey = DSA_new_method(eng);		if (!dkey)			goto memerr;		dkey->p = BN_new();		dkey->q = BN_new();		dkey->g = BN_new();		dkey->pub_key = BN_new();		if (!dkey->p || !dkey->q || !dkey->g || !dkey->pub_key)			goto memerr;		if (!lend_tobn(dkey->p, btmp, dsa_plen))//.........这里部分代码省略.........

int capi_rsa_sign(int dtype, const unsigned char *m, unsigned int m_len,             unsigned char *sigret, unsigned int *siglen, const RSA *rsa)	{	ALG_ID alg;	HCRYPTHASH hash;	DWORD slen;	unsigned int i;	int ret = -1;	CAPI_KEY *capi_key;	CAPI_CTX *ctx;	ctx = ENGINE_get_ex_data(rsa->engine, capi_idx);	CAPI_trace(ctx, "Called CAPI_rsa_sign()/n");	capi_key = RSA_get_ex_data(rsa, rsa_capi_idx);	if (!capi_key)		{		CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_CANT_GET_KEY);		return -1;		}/* Convert the signature type to a CryptoAPI algorithm ID */	switch(dtype)		{	case NID_sha1:		alg = CALG_SHA1;		break;	case NID_md5:		alg = CALG_MD5;		break;	case NID_md5_sha1:		alg = CALG_SSL3_SHAMD5;		break;	default:		{		char algstr[10];		BIO_snprintf(algstr, 10, "%lx", dtype);		CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_UNSUPPORTED_ALGORITHM_NID);		ERR_add_error_data(2, "NID=0x", algstr);		return -1;		}	}/* Create the hash object */	if(!CryptCreateHash(capi_key->hprov, alg, 0, 0, &hash))		{		CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_CANT_CREATE_HASH_OBJECT);		capi_addlasterror();		return -1;		}/* Set the hash value to the value passed */	if(!CryptSetHashParam(hash, HP_HASHVAL, (unsigned char *)m, 0))		{		CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_CANT_SET_HASH_VALUE);		capi_addlasterror();		goto err;		}/* Finally sign it */	slen = RSA_size(rsa);	if(!CryptSignHashA(hash, capi_key->keyspec, NULL, 0, sigret, &slen))		{		CAPIerr(CAPI_F_CAPI_RSA_SIGN, CAPI_R_ERROR_SIGNING_HASH);		capi_addlasterror();		goto err;		}	else		{		ret = 1;		/* Inplace byte reversal of signature */		for(i = 0; i < slen / 2; i++)			{			unsigned char c;			c = sigret[i];			sigret[i] = sigret[slen - i - 1];			sigret[slen - i - 1] = c;			}		*siglen = slen;		}	/* Now cleanup */err:	CryptDestroyHash(hash);	return ret;	}

static void capi_adderror(DWORD err)	{	char errstr[10];	BIO_snprintf(errstr, 10, "%lX", err);	ERR_add_error_data(2, "Error code= 0x", errstr);	}

/*- * BIO_lookup - look up the node and service you want to connect to. * @node: the node you want to connect to. * @service: the service you want to connect to. * @lookup_type: declare intent with the result, client or server. * @family: the address family you want to use.  Use AF_UNSPEC for any, or *  AF_INET, AF_INET6 or AF_UNIX. * @socktype: The socket type you want to use.  Can be SOCK_STREAM, SOCK_DGRAM *  or 0 for all. * @res: Storage place for the resulting list of returned addresses * * This will do a lookup of the node and service that you want to connect to. * It returns a linked list of different addresses you can try to connect to. * * When no longer needed you should call BIO_ADDRINFO_free() to free the result. * * The return value is 1 on success or 0 in case of error. */int BIO_lookup(const char *host, const char *service,               enum BIO_lookup_type lookup_type,               int family, int socktype, BIO_ADDRINFO **res){    int ret = 0;                 /* Assume failure */    switch(family) {    case AF_INET:#ifdef AF_INET6    case AF_INET6:#endif#ifdef AF_UNIX    case AF_UNIX:#endif#ifdef AF_UNSPEC    case AF_UNSPEC:#endif        break;    default:        BIOerr(BIO_F_BIO_LOOKUP, BIO_R_UNSUPPORTED_PROTOCOL_FAMILY);        return 0;    }#ifdef AF_UNIX    if (family == AF_UNIX) {        if (addrinfo_wrap(family, socktype, host, strlen(host), 0, res))            return 1;        else            BIOerr(BIO_F_BIO_LOOKUP, ERR_R_MALLOC_FAILURE);        return 0;    }#endif    if (BIO_sock_init() != 1)        return 0;    if (1) {        int gai_ret = 0;#ifdef AI_PASSIVE        struct addrinfo hints;        memset(&hints, 0, sizeof hints);        hints.ai_family = family;        hints.ai_socktype = socktype;        if (lookup_type == BIO_LOOKUP_SERVER)            hints.ai_flags |= AI_PASSIVE;        /* Note that |res| SHOULD be a 'struct addrinfo **' thanks to         * macro magic in bio_lcl.h         */        switch ((gai_ret = getaddrinfo(host, service, &hints, res))) {# ifdef EAI_SYSTEM        case EAI_SYSTEM:            SYSerr(SYS_F_GETADDRINFO, get_last_socket_error());            BIOerr(BIO_F_BIO_LOOKUP, ERR_R_SYS_LIB);            break;# endif        case 0:            ret = 1;             /* Success */            break;        default:            BIOerr(BIO_F_BIO_LOOKUP, ERR_R_SYS_LIB);            ERR_add_error_data(1, gai_strerror(gai_ret));            break;        }    } else {#endif        const struct hostent *he;/* * Because struct hostent is defined for 32-bit pointers only with * VMS C, we need to make sure that '&he_fallback_address' and * '&he_fallback_addresses' are 32-bit pointers */#if defined(OPENSSL_SYS_VMS) && defined(__DECC)# pragma pointer_size save# pragma pointer_size 32#endif        /* Windows doesn't seem to have in_addr_t */#ifdef OPENSSL_SYS_WINDOWS        static uint32_t he_fallback_address;        static const char *he_fallback_addresses[] =//.........这里部分代码省略.........

/*- * addr_strings - helper function to get host and service names * @ap: the BIO_ADDR that has the input info * @numeric: 0 if actual names should be returned, 1 if the numeric * representation should be returned. * @hostname: a pointer to a pointer to a memory area to store the * host name or numeric representation.  Unused if NULL. * @service: a pointer to a pointer to a memory area to store the * service name or numeric representation.  Unused if NULL. * * The return value is 0 on failure, with the error code in the error * stack, and 1 on success. */static int addr_strings(const BIO_ADDR *ap, int numeric,                        char **hostname, char **service){    if (BIO_sock_init() != 1)        return 0;    if (1) {#ifdef AI_PASSIVE        int ret = 0;        char host[NI_MAXHOST] = "", serv[NI_MAXSERV] = "";        int flags = 0;        if (numeric)            flags |= NI_NUMERICHOST | NI_NUMERICSERV;        if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap),                               BIO_ADDR_sockaddr_size(ap),                               host, sizeof(host), serv, sizeof(serv),                               flags)) != 0) {# ifdef EAI_SYSTEM            if (ret == EAI_SYSTEM) {                SYSerr(SYS_F_GETNAMEINFO, get_last_socket_error());                BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);            } else# endif            {                BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB);                ERR_add_error_data(1, gai_strerror(ret));            }            return 0;        }        /* VMS getnameinfo() has a bug, it doesn't fill in serv, which         * leaves it with whatever garbage that happens to be there.         * However, we initialise serv with the empty string (serv[0]         * is therefore NUL), so it gets real easy to detect when things         * didn't go the way one might expect.         */        if (serv[0] == '/0') {            BIO_snprintf(serv, sizeof(serv), "%d",                         ntohs(BIO_ADDR_rawport(ap)));        }        if (hostname != NULL)            *hostname = OPENSSL_strdup(host);        if (service != NULL)            *service = OPENSSL_strdup(serv);    } else {#endif        if (hostname != NULL)            *hostname = OPENSSL_strdup(inet_ntoa(ap->s_in.sin_addr));        if (service != NULL) {            char serv[6];        /* port is 16 bits => max 5 decimal digits */            BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->s_in.sin_port));            *service = OPENSSL_strdup(serv);        }    }    if ((hostname != NULL && *hostname == NULL)            || (service != NULL && *service == NULL)) {        if (hostname != NULL) {            OPENSSL_free(*hostname);            *hostname = NULL;        }        if (service != NULL) {            OPENSSL_free(*service);            *service = NULL;        }        BIOerr(BIO_F_ADDR_STRINGS, ERR_R_MALLOC_FAILURE);        return 0;    }    return 1;}

//.........这里部分代码省略.........            /* now check if it's a missing record */            if (alert_descr == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) {                unsigned short seq;                unsigned int frag_off;                unsigned char *p = &(s->rlayer.d->alert_fragment[2]);                n2s(p, seq);                n2l3(p, frag_off);                dtls1_retransmit_message(s,                                         dtls1_get_queue_priority                                         (frag->msg_header.seq, 0), frag_off,                                         &found);                if (!found && SSL_in_init(s)) {                    /*                     * fprintf( stderr,"in init = %d/n", SSL_in_init(s));                     */                    /*                     * requested a message not yet sent, send an alert                     * ourselves                     */                    ssl3_send_alert(s, SSL3_AL_WARNING,                                    DTLS1_AD_MISSING_HANDSHAKE_MESSAGE);                }            }#endif        } else if (alert_level == SSL3_AL_FATAL) {            char tmp[16];            s->rwstate = SSL_NOTHING;            s->s3->fatal_alert = alert_descr;            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);            BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);            ERR_add_error_data(2, "SSL alert number ", tmp);            s->shutdown |= SSL_RECEIVED_SHUTDOWN;            SSL_CTX_remove_session(s->session_ctx, s->session);            return (0);        } else {            al = SSL_AD_ILLEGAL_PARAMETER;            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE);            goto f_err;        }        goto start;    }    if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a                                            * shutdown */        s->rwstate = SSL_NOTHING;        SSL3_RECORD_set_length(rr, 0);        return (0);    }    if (SSL3_RECORD_get_type(rr) == SSL3_RT_CHANGE_CIPHER_SPEC) {        /*         * We can't process a CCS now, because previous handshake messages         * are still missing, so just drop it.         */        SSL3_RECORD_set_length(rr, 0);        goto start;    }    /*     * Unexpected handshake message (Client Hello, or protocol violation)     */    if ((s->rlayer.d->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) &&

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)				{//.........这里部分代码省略.........

//.........这里部分代码省略.........                    ss = p;                    goto again;                }                CONFerr(CONF_F_DEF_LOAD_BIO,                        CONF_R_MISSING_CLOSE_SQUARE_BRACKET);                goto err;            }            *end = '/0';            if (!str_copy(conf, NULL, &section, start))                goto err;            if ((sv = _CONF_get_section(conf, section)) == NULL)                sv = _CONF_new_section(conf, section);            if (sv == NULL) {                CONFerr(CONF_F_DEF_LOAD_BIO,                        CONF_R_UNABLE_TO_CREATE_NEW_SECTION);                goto err;            }            continue;        } else {            pname = s;            psection = NULL;            end = eat_alpha_numeric(conf, s);            if ((end[0] == ':') && (end[1] == ':')) {                *end = '/0';                end += 2;                psection = pname;                pname = end;                end = eat_alpha_numeric(conf, end);            }            p = eat_ws(conf, end);            if (*p != '=') {                CONFerr(CONF_F_DEF_LOAD_BIO, CONF_R_MISSING_EQUAL_SIGN);                goto err;            }            *end = '/0';            p++;            start = eat_ws(conf, p);            while (!IS_EOF(conf, *p))                p++;            p--;            while ((p != start) && (IS_WS(conf, *p)))                p--;            p++;            *p = '/0';            if ((v = OPENSSL_malloc(sizeof(*v))) == NULL) {                CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);                goto err;            }            if (psection == NULL)                psection = section;            v->name = OPENSSL_malloc(strlen(pname) + 1);            v->value = NULL;            if (v->name == NULL) {                CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);                goto err;            }            OPENSSL_strlcpy(v->name, pname, strlen(pname) + 1);            if (!str_copy(conf, psection, &(v->value), start))                goto err;            if (strcmp(psection, section) != 0) {                if ((tv = _CONF_get_section(conf, psection))                    == NULL)                    tv = _CONF_new_section(conf, psection);                if (tv == NULL) {                    CONFerr(CONF_F_DEF_LOAD_BIO,                            CONF_R_UNABLE_TO_CREATE_NEW_SECTION);                    goto err;                }            } else                tv = sv;            if (_CONF_add_string(conf, tv, v) == 0) {                CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);                goto err;            }            v = NULL;        }    }    BUF_MEM_free(buff);    OPENSSL_free(section);    return (1); err:    BUF_MEM_free(buff);    OPENSSL_free(section);    if (line != NULL)        *line = eline;    BIO_snprintf(btmp, sizeof(btmp), "%ld", eline);    ERR_add_error_data(2, "line ", btmp);    if (h != conf->data) {        CONF_free(conf->data);        conf->data = NULL;    }    if (v != NULL) {        OPENSSL_free(v->name);        OPENSSL_free(v->value);        OPENSSL_free(v);    }    return (0);}

void vms_bind_sym(DSO *dso, const char *symname, void **sym)	{	DSO_VMS_INTERNAL *ptr;	int status;#if 0	int flags = (1<<4); /* LIB$M_FIS_MIXEDCASE, but this symbol isn't                               defined in VMS older than 7.0 or so */#else	int flags = 0;#endif	struct dsc$descriptor_s symname_dsc;	*sym = NULL;	symname_dsc.dsc$w_length = strlen(symname);	symname_dsc.dsc$b_dtype = DSC$K_DTYPE_T;	symname_dsc.dsc$b_class = DSC$K_CLASS_S;	symname_dsc.dsc$a_pointer = (char *)symname; /* The cast is needed */	if((dso == NULL) || (symname == NULL))		{		DSOerr(DSO_F_VMS_BIND_SYM,ERR_R_PASSED_NULL_PARAMETER);		return;		}	if(sk_num(dso->meth_data) < 1)		{		DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_STACK_ERROR);		return;		}	ptr = (DSO_VMS_INTERNAL *)sk_value(dso->meth_data,		sk_num(dso->meth_data) - 1);	if(ptr == NULL)		{		DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_NULL_HANDLE);		return;		}	if(dso->flags & DSO_FLAG_UPCASE_SYMBOL) flags = 0;	status = do_find_symbol(ptr, &symname_dsc, sym, flags);	if(!$VMS_STATUS_SUCCESS(status))		{		unsigned short length;		char errstring[257];		struct dsc$descriptor_s errstring_dsc;		errstring_dsc.dsc$w_length = sizeof(errstring);		errstring_dsc.dsc$b_dtype = DSC$K_DTYPE_T;		errstring_dsc.dsc$b_class = DSC$K_CLASS_S;		errstring_dsc.dsc$a_pointer = errstring;		*sym = NULL;		status = sys$getmsg(status, &length, &errstring_dsc, 1, 0);		if (!$VMS_STATUS_SUCCESS(status))			lib$signal(status); /* This is really bad.  Abort!  */		else			{			errstring[length] = '/0';			DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_SYM_FAILURE);			if (ptr->imagename_dsc.dsc$w_length)				ERR_add_error_data(9,					"Symbol ", symname,					" in ", ptr->filename,					" (", ptr->imagename, ")",					": ", errstring);			else				ERR_add_error_data(6,					"Symbol ", symname,					" in ", ptr->filename,					": ", errstring);			}		return;		}	return;	}

//.........这里部分代码省略.........			plen = param->value.sequence->length;			if (!(eckey = d2i_ECParameters(NULL, &cp, plen)))			{				EVPerr(EVP_F_EVP_PKCS82PKEY,					EVP_R_DECODE_ERROR);				goto ecerr;			}		}		else		{			EC_GROUP *group;			cp = p = param->value.object->data;			plen = param->value.object->length;			/* type == V_ASN1_OBJECT => the parameters are given			 * by an asn1 OID			 */			if ((eckey = EC_KEY_new()) == NULL)			{				EVPerr(EVP_F_EVP_PKCS82PKEY,					ERR_R_MALLOC_FAILURE);				goto ecerr;			}			group = EC_GROUP_new_by_curve_name(OBJ_obj2nid(a->parameter->value.object));			if (group == NULL)				goto ecerr;			EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);			if (EC_KEY_set_group(eckey, group) == 0)				goto ecerr;			EC_GROUP_free(group);		}		/* We have parameters now set private key */		if (!d2i_ECPrivateKey(&eckey, &p_tmp, pkeylen))		{			EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);			goto ecerr;		}		/* calculate public key (if necessary) */		if (EC_KEY_get0_public_key(eckey) == NULL)		{			const BIGNUM *priv_key;			const EC_GROUP *group;			EC_POINT *pub_key;			/* the public key was not included in the SEC1 private			 * key => calculate the public key */			group   = EC_KEY_get0_group(eckey);			pub_key = EC_POINT_new(group);			if (pub_key == NULL)			{				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);				goto ecerr;			}			if (!EC_POINT_copy(pub_key, EC_GROUP_get0_generator(group)))			{				EC_POINT_free(pub_key);				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);				goto ecerr;			}			priv_key = EC_KEY_get0_private_key(eckey);			if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))			{				EC_POINT_free(pub_key);				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);				goto ecerr;			}			if (EC_KEY_set_public_key(eckey, pub_key) == 0)			{				EC_POINT_free(pub_key);				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);				goto ecerr;			}			EC_POINT_free(pub_key);		}		EVP_PKEY_assign_EC_KEY(pkey, eckey);		if (ctx)			BN_CTX_free(ctx);		break;ecerr:		if (ctx)			BN_CTX_free(ctx);		if (eckey)			EC_KEY_free(eckey);		if (pkey)			EVP_PKEY_free(pkey);		return NULL;#endif		default:		EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);		if (!a->algorithm) BUF_strlcpy (obj_tmp, "NULL", sizeof obj_tmp);		else i2t_ASN1_OBJECT(obj_tmp, 80, a->algorithm);		ERR_add_error_data(2, "TYPE=", obj_tmp);		EVP_PKEY_free (pkey);		return NULL;	}	return pkey;}

static char *vms_merger(DSO *dso, const char *filespec1, const char *filespec2)	{	int status;	int filespec1len, filespec2len;	struct FAB fab;#ifdef NAML$C_MAXRSS	struct NAML nam;	char esa[NAML$C_MAXRSS];#else	struct NAM nam;	char esa[NAM$C_MAXRSS];#endif	char *merged;	if (!filespec1) filespec1 = "";	if (!filespec2) filespec2 = "";	filespec1len = strlen(filespec1);	filespec2len = strlen(filespec2);	fab = cc$rms_fab;#ifdef NAML$C_MAXRSS	nam = cc$rms_naml;#else	nam = cc$rms_nam;#endif	fab.fab$l_fna = (char *)filespec1;	fab.fab$b_fns = filespec1len;	fab.fab$l_dna = (char *)filespec2;	fab.fab$b_dns = filespec2len;#ifdef NAML$C_MAXRSS	if (filespec1len > NAM$C_MAXRSS)		{		fab.fab$l_fna = 0;		fab.fab$b_fns = 0;		nam.naml$l_long_filename = (char *)filespec1;		nam.naml$l_long_filename_size = filespec1len;		}	if (filespec2len > NAM$C_MAXRSS)		{		fab.fab$l_dna = 0;		fab.fab$b_dns = 0;		nam.naml$l_long_defname = (char *)filespec2;		nam.naml$l_long_defname_size = filespec2len;		}	nam.naml$l_esa = esa;	nam.naml$b_ess = NAM$C_MAXRSS;	nam.naml$l_long_expand = esa;	nam.naml$l_long_expand_alloc = sizeof(esa);	nam.naml$b_nop = NAM$M_SYNCHK | NAM$M_PWD;	nam.naml$v_no_short_upcase = 1;	fab.fab$l_naml = &nam;#else	nam.nam$l_esa = esa;	nam.nam$b_ess = NAM$C_MAXRSS;	nam.nam$b_nop = NAM$M_SYNCHK | NAM$M_PWD;	fab.fab$l_nam = &nam;#endif	status = sys$parse(&fab, 0, 0);	if(!$VMS_STATUS_SUCCESS(status))		{		unsigned short length;		char errstring[257];		struct dsc$descriptor_s errstring_dsc;		errstring_dsc.dsc$w_length = sizeof(errstring);		errstring_dsc.dsc$b_dtype = DSC$K_DTYPE_T;		errstring_dsc.dsc$b_class = DSC$K_CLASS_S;		errstring_dsc.dsc$a_pointer = errstring;		status = sys$getmsg(status, &length, &errstring_dsc, 1, 0);		if (!$VMS_STATUS_SUCCESS(status))			lib$signal(status); /* This is really bad.  Abort!  */		else			{			errstring[length] = '/0';			DSOerr(DSO_F_VMS_MERGER,DSO_R_FAILURE);			ERR_add_error_data(7,					   "filespec /"", filespec1, "/", ",					   "defaults /"", filespec2, "/": ",					   errstring);			}		return(NULL);		}#ifdef NAML$C_MAXRSS	if (nam.naml$l_long_expand_size)		{		merged = OPENSSL_malloc(nam.naml$l_long_expand_size + 1);		if(!merged)			goto malloc_err;		strncpy(merged, nam.naml$l_long_expand,			nam.naml$l_long_expand_size);		merged[nam.naml$l_long_expand_size] = '/0';		}	else		{//.........这里部分代码省略.........

int BIO_get_accept_socket(char *host, int bind_mode)	{	int ret=0;	struct sockaddr_in server,client;	int s=INVALID_SOCKET,cs;	unsigned char ip[4];	unsigned short port;	char *str=NULL,*e;	const char *h,*p;	unsigned long l;	int err_num;	if (BIO_sock_init() != 1) return(INVALID_SOCKET);	if ((str=BUF_strdup(host)) == NULL) return(INVALID_SOCKET);	h=p=NULL;	h=str;	for (e=str; *e; e++)		{		if (*e == ':')			{			p= &(e[1]);			*e='/0';			}		else if (*e == '/')			{			*e='/0';			break;			}		}	if (p == NULL)		{		p=h;		h="*";		}	if (!BIO_get_port(p,&port)) goto err;	memset((char *)&server,0,sizeof(server));	server.sin_family=AF_INET;	server.sin_port=htons(port);	if (strcmp(h,"*") == 0)		server.sin_addr.s_addr=INADDR_ANY;	else		{                if (!BIO_get_host_ip(h,&(ip[0]))) goto err;		l=(unsigned long)			((unsigned long)ip[0]<<24L)|			((unsigned long)ip[1]<<16L)|			((unsigned long)ip[2]<< 8L)|			((unsigned long)ip[3]);		server.sin_addr.s_addr=htonl(l);		}again:	s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);	if (s == INVALID_SOCKET)		{		SYSerr(SYS_F_SOCKET,get_last_socket_error());		ERR_add_error_data(3,"port='",host,"'");		BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET);		goto err;		}#ifdef SO_REUSEADDR	if (bind_mode == BIO_BIND_REUSEADDR)		{		int i=1;		ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i));		bind_mode=BIO_BIND_NORMAL;		}#endif	if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)		{#ifdef SO_REUSEADDR		err_num=get_last_socket_error();		if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&			(err_num == EADDRINUSE))			{			memcpy((char *)&client,(char *)&server,sizeof(server));			if (strcmp(h,"*") == 0)				client.sin_addr.s_addr=htonl(0x7F000001);			cs=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);			if (cs != INVALID_SOCKET)				{				int ii;				ii=connect(cs,(struct sockaddr *)&client,					sizeof(client));				closesocket(cs);				if (ii == INVALID_SOCKET)					{					bind_mode=BIO_BIND_REUSEADDR;					closesocket(s);					goto again;					}				/* else error *///.........这里部分代码省略.........

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);		TINYCLR_SSL_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 parse_http_line1(char *line)	{	int retcode;	char *p, *q, *r;	/* Skip to first white space (passed protocol info) */	for(p = line; *p && !isspace((unsigned char)*p); p++)		continue;	if(!*p)		{		OCSPerr(OCSP_F_PARSE_HTTP_LINE1,					OCSP_R_SERVER_RESPONSE_PARSE_ERROR);		return 0;		}	/* Skip past white space to start of response code */	while(*p && isspace((unsigned char)*p))		p++;	if(!*p)		{		OCSPerr(OCSP_F_PARSE_HTTP_LINE1,					OCSP_R_SERVER_RESPONSE_PARSE_ERROR);		return 0;		}	/* Find end of response code: first whitespace after start of code */	for(q = p; *q && !isspace((unsigned char)*q); q++)		continue;	if(!*q)		{		OCSPerr(OCSP_F_PARSE_HTTP_LINE1,					OCSP_R_SERVER_RESPONSE_PARSE_ERROR);		return 0;		}	/* Set end of response code and start of message */ 	*q++ = 0;	/* Attempt to parse numeric code */	retcode = strtoul(p, &r, 10);	if(*r)		return 0;	/* Skip over any leading white space in message */	while(*q && isspace((unsigned char)*q))		q++;	if(*q)		{		/* Finally zap any trailing white space in message (include		 * CRLF) */		/* We know q has a non white space character so this is OK */		for(r = q + strlen(q) - 1; isspace((unsigned char)*r); r--)			*r = 0;		}	if(retcode != 200)		{		OCSPerr(OCSP_F_PARSE_HTTP_LINE1, OCSP_R_SERVER_RESPONSE_ERROR);		if(!*q)			ERR_add_error_data(2, "Code=", p);		else			ERR_add_error_data(4, "Code=", p, ",Reason=", q);		return 0;		}	return 1;	}

static int asn1_cb(const char *elem, int len, void *bitstr)	{	tag_exp_arg *arg = bitstr;	int i;	int utype;	int vlen = 0;	const char *p, *vstart = NULL;	int tmp_tag, tmp_class;	if (elem == NULL)		return 0;	for(i = 0, p = elem; i < len; p++, i++)		{		/* Look for the ':' in name value pairs */		if (*p == ':')			{			vstart = p + 1;			vlen = len - (vstart - elem);			len = p - elem;			break;			}		}	utype = asn1_str2tag(elem, len);	if (utype == -1)		{		OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNKNOWN_TAG);		ERR_add_error_data(2, "tag=", elem);		return -1;		}	/* If this is not a modifier mark end of string and exit */	if (!(utype & ASN1_GEN_FLAG))		{		arg->utype = utype;		arg->str = vstart;		/* If no value and not end of string, error */		if (!vstart && elem[len])			{			OPENSSL_PUT_ERROR(ASN1, ASN1_R_MISSING_VALUE);			return -1;			}		return 0;		}	switch(utype)		{		case ASN1_GEN_FLAG_IMP:		/* Check for illegal multiple IMPLICIT tagging */		if (arg->imp_tag != -1)			{			OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_NESTED_TAGGING);			return -1;			}		if (!parse_tagging(vstart, vlen, &arg->imp_tag, &arg->imp_class))			return -1;		break;		case ASN1_GEN_FLAG_EXP:		if (!parse_tagging(vstart, vlen, &tmp_tag, &tmp_class))			return -1;		if (!append_exp(arg, tmp_tag, tmp_class, 1, 0, 0))			return -1;		break;		case ASN1_GEN_FLAG_SEQWRAP:		if (!append_exp(arg, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, 1, 0, 1))			return -1;		break;		case ASN1_GEN_FLAG_SETWRAP:		if (!append_exp(arg, V_ASN1_SET, V_ASN1_UNIVERSAL, 1, 0, 1))			return -1;		break;		case ASN1_GEN_FLAG_BITWRAP:		if (!append_exp(arg, V_ASN1_BIT_STRING, V_ASN1_UNIVERSAL, 0, 1, 1))			return -1;		break;		case ASN1_GEN_FLAG_OCTWRAP:		if (!append_exp(arg, V_ASN1_OCTET_STRING, V_ASN1_UNIVERSAL, 0, 0, 1))			return -1;		break;		case ASN1_GEN_FLAG_FORMAT:		if (!vstart)			{			OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNKNOWN_FORMAT);			return -1;			}		if (!strncmp(vstart, "ASCII", 5))			arg->format = ASN1_GEN_FORMAT_ASCII;		else if (!strncmp(vstart, "UTF8", 4))			arg->format = ASN1_GEN_FORMAT_UTF8;//.........这里部分代码省略.........

//.........这里部分代码省略.........		}	for (i = 0; i < sk_CONF_VALUE_num(ecmds); i++)		{		ecmd = sk_CONF_VALUE_value(ecmds, i);		ctrlname = skip_dot(ecmd->name);		ctrlvalue = ecmd->value;#ifdef ENGINE_CONF_DEBUG	fprintf(stderr, "ENGINE conf: doing ctrl(%s,%s)/n", ctrlname, ctrlvalue);#endif		/* First handle some special pseudo ctrls */		/* Override engine name to use */		if (!op_strcmp(ctrlname, "engine_id"))			name = ctrlvalue;		else if (!strcmp(ctrlname, "soft_load"))			soft = 1;		/* Load a dynamic ENGINE */		else if (!op_strcmp(ctrlname, "dynamic_path"))			{			e = ENGINE_by_id("dynamic");			if (!e)				goto err;			if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", ctrlvalue, 0))				goto err;			if (!ENGINE_ctrl_cmd_string(e, "LIST_ADD", "2", 0))				goto err;			if (!ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0))				goto err;			}		/* ... add other pseudos here ... */		else			{			/* At this point we need an ENGINE structural reference			 * if we don't already have one.			 */			if (!e)				{				e = ENGINE_by_id(name);				if (!e && soft)					{					ERR_clear_error();					return 1;					}				if (!e)					goto err;				}			/* Allow "EMPTY" to mean no value: this allows a valid			 * "value" to be passed to ctrls of type NO_INPUT		 	 */			if (!op_strcmp(ctrlvalue, "EMPTY"))				ctrlvalue = NULL;			if (!op_strcmp(ctrlname, "init"))				{				if (!NCONF_get_number_e(cnf, value, "init", &do_init))					goto err;				if (do_init == 1)					{					if (!int_engine_init(e))						goto err;					}				else if (do_init != 0)					{					ENGINEerr(ENGINE_F_INT_ENGINE_CONFIGURE, ENGINE_R_INVALID_INIT_VALUE);					goto err;					}				}			else if (!op_strcmp(ctrlname, "default_algorithms"))				{				if (!ENGINE_set_default_string(e, ctrlvalue))					goto err;				}			else if (!ENGINE_ctrl_cmd_string(e,					ctrlname, ctrlvalue, 0))				goto err;			}		}	if (e && (do_init == -1) && !int_engine_init(e))		{		ecmd = NULL;		goto err;		}	ret = 1;	err:	if (ret != 1)		{		ENGINEerr(ENGINE_F_INT_ENGINE_CONFIGURE, ENGINE_R_ENGINE_CONFIGURATION_ERROR);		if (ecmd)			ERR_add_error_data(6, "section=", ecmd->section, 						", name=", ecmd->name,						", value=", ecmd->value);		}	if (e)		ENGINE_free(e);	return ret;	}

//.........这里部分代码省略.........		case V_ASN1_T61STRING:		case V_ASN1_UTF8STRING:		case V_ASN1_VISIBLESTRING:		case V_ASN1_UNIVERSALSTRING:		case V_ASN1_GENERALSTRING:		case V_ASN1_NUMERICSTRING:		if (format == ASN1_GEN_FORMAT_ASCII)			format = MBSTRING_ASC;		else if (format == ASN1_GEN_FORMAT_UTF8)			format = MBSTRING_UTF8;		else			{			OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_FORMAT);			goto bad_form;			}		if (ASN1_mbstring_copy(&atmp->value.asn1_string, (unsigned char *)str,						-1, format, ASN1_tag2bit(utype)) <= 0)			{			OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);			goto bad_str;			}				break;		case V_ASN1_BIT_STRING:		case V_ASN1_OCTET_STRING:		if (!(atmp->value.asn1_string = ASN1_STRING_new()))			{			OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);			goto bad_form;			}		if (format == ASN1_GEN_FORMAT_HEX)			{			if (!(rdata = string_to_hex((char *)str, &rdlen)))				{				OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_HEX);				goto bad_str;				}			atmp->value.asn1_string->data = rdata;			atmp->value.asn1_string->length = rdlen;			atmp->value.asn1_string->type = utype;			}		else if (format == ASN1_GEN_FORMAT_ASCII)			ASN1_STRING_set(atmp->value.asn1_string, str, -1);		else if ((format == ASN1_GEN_FORMAT_BITLIST) && (utype == V_ASN1_BIT_STRING))			{			if (!CONF_parse_list(str, ',', 1, bitstr_cb, atmp->value.bit_string))				{				OPENSSL_PUT_ERROR(ASN1, ASN1_R_LIST_ERROR);				goto bad_str;				}			no_unused = 0;						}		else 			{			OPENSSL_PUT_ERROR(ASN1, ASN1_R_ILLEGAL_BITSTRING_FORMAT);			goto bad_form;			}		if ((utype == V_ASN1_BIT_STRING) && no_unused)			{			atmp->value.asn1_string->flags				&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07);        		atmp->value.asn1_string->flags				|= ASN1_STRING_FLAG_BITS_LEFT;			}		break;		default:		OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNSUPPORTED_TYPE);		goto bad_str;		break;		}	atmp->type = utype;	return atmp;	bad_str:	ERR_add_error_data(2, "string=", str);	bad_form:	ASN1_TYPE_free(atmp);	return NULL;	}

void vms_bind_sym(DSO *dso, const char *symname, void **sym){    DSO_VMS_INTERNAL *ptr;    int status;# if 0    int flags = (1 << 4);       /* LIB$M_FIS_MIXEDCASE, but this symbol isn't                                 * defined in VMS older than 7.0 or so */# else    int flags = 0;# endif    struct dsc$descriptor_s symname_dsc;/* Arrange 32-bit pointer to (copied) string storage, if needed. */# if __INITIAL_POINTER_SIZE == 64#  define SYMNAME symname_32p#  pragma pointer_size save#  pragma pointer_size 32    char *symname_32p;#  pragma pointer_size restore    char symname_32[NAMX_MAXRSS + 1];# else                          /* __INITIAL_POINTER_SIZE == 64 */#  define SYMNAME ((char *) symname)# endif                         /* __INITIAL_POINTER_SIZE == 64 [else] */    *sym = NULL;    if ((dso == NULL) || (symname == NULL)) {        DSOerr(DSO_F_VMS_BIND_SYM, ERR_R_PASSED_NULL_PARAMETER);        return;    }# if __INITIAL_POINTER_SIZE == 64    /* Copy the symbol name to storage with a 32-bit pointer. */    symname_32p = symname_32;    strcpy(symname_32p, symname);# endif                         /* __INITIAL_POINTER_SIZE == 64 [else] */    symname_dsc.dsc$w_length = strlen(SYMNAME);    symname_dsc.dsc$b_dtype = DSC$K_DTYPE_T;    symname_dsc.dsc$b_class = DSC$K_CLASS_S;    symname_dsc.dsc$a_pointer = SYMNAME;    if (sk_void_num(dso->meth_data) < 1) {        DSOerr(DSO_F_VMS_BIND_SYM, DSO_R_STACK_ERROR);        return;    }    ptr = (DSO_VMS_INTERNAL *)sk_void_value(dso->meth_data,                                            sk_void_num(dso->meth_data) - 1);    if (ptr == NULL) {        DSOerr(DSO_F_VMS_BIND_SYM, DSO_R_NULL_HANDLE);        return;    }    if (dso->flags & DSO_FLAG_UPCASE_SYMBOL)        flags = 0;    status = do_find_symbol(ptr, &symname_dsc, sym, flags);    if (!$VMS_STATUS_SUCCESS(status)) {        unsigned short length;        char errstring[257];        struct dsc$descriptor_s errstring_dsc;        errstring_dsc.dsc$w_length = sizeof(errstring);        errstring_dsc.dsc$b_dtype = DSC$K_DTYPE_T;        errstring_dsc.dsc$b_class = DSC$K_CLASS_S;        errstring_dsc.dsc$a_pointer = errstring;        *sym = NULL;        status = sys$getmsg(status, &length, &errstring_dsc, 1, 0);        if (!$VMS_STATUS_SUCCESS(status))            lib$signal(status); /* This is really bad.  Abort! */        else {            errstring[length] = '/0';            DSOerr(DSO_F_VMS_BIND_SYM, DSO_R_SYM_FAILURE);            if (ptr->imagename_dsc.dsc$w_length)                ERR_add_error_data(9,                                   "Symbol ", symname,                                   " in ", ptr->filename,                                   " (", ptr->imagename, ")",                                   ": ", errstring);            else                ERR_add_error_data(6,                                   "Symbol ", symname,                                   " in ", ptr->filename, ": ", errstring);        }        return;    }    return;}

//.........这里部分代码省略.........					ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,							ASN1_R_UNEXPECTED_EOC);					goto err;					}				len -= p - q;				seq_eoc = 0;				q = p;				break;				}			/* This determines the OPTIONAL flag value. The field			 * cannot be omitted if it is the last of a SEQUENCE			 * and there is still data to be read. This isn't			 * strictly necessary but it increases efficiency in			 * some cases.			 */			if (i == (it->tcount - 1))				isopt = 0;			else isopt = (char)(seqtt->flags & ASN1_TFLG_OPTIONAL);			/* attempt to read in field, allowing each to be			 * OPTIONAL */			ret = asn1_template_ex_d2i(pseqval, &p, len,							seqtt, isopt, ctx);			if (!ret)				{				errtt = seqtt;				goto err;				}			else if (ret == -1)				{				/* OPTIONAL component absent.				 * Free and zero the field.				 */				ASN1_template_free(pseqval, seqtt);				continue;				}			/* Update length */			len -= p - q;			}		/* Check for EOC if expecting one */		if (seq_eoc && !asn1_check_eoc(&p, len))			{			ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_MISSING_EOC);			goto err;			}		/* Check all data read */		if (!seq_nolen && len)			{			ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,					ASN1_R_SEQUENCE_LENGTH_MISMATCH);			goto err;			}		/* If we get here we've got no more data in the SEQUENCE,		 * however we may not have read all fields so check all		 * remaining are OPTIONAL and clear any that are.		 */		for (; i < it->tcount; tt++, i++)			{			const ASN1_TEMPLATE *seqtt;			seqtt = asn1_do_adb(pval, tt, 1);			if (!seqtt)				goto err;			if (seqtt->flags & ASN1_TFLG_OPTIONAL)				{				ASN1_VALUE **pseqval;				pseqval = asn1_get_field_ptr(pval, seqtt);				ASN1_template_free(pseqval, seqtt);				}			else				{				errtt = seqtt;				ASN1err(ASN1_F_ASN1_ITEM_EX_D2I,							ASN1_R_FIELD_MISSING);				goto err;				}			}		/* Save encoding */		if (!asn1_enc_save(pval, *in, p - *in, it))			goto auxerr;		*in = p;		if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it))				goto auxerr;		return 1;		default:		return 0;		}	auxerr:	ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_AUX_ERROR);	err:	ASN1_item_ex_free(pval, it);	if (errtt)		ERR_add_error_data(4, "Field=", errtt->field_name,					", Type=", it->sname);	else		ERR_add_error_data(2, "Type=", it->sname);	return 0;	}

//.........这里部分代码省略.........		/* Restore encrypt field: it is zeroed by cleanup */		ctx->encrypt = enc;#ifndef OPENSSL_NO_ENGINE		if (!do_evp_enc_engine(ctx, &cipher, impl))			return 0;#endif		ctx->cipher=cipher;		if (ctx->cipher->ctx_size)			{			ctx->cipher_data=OPENSSL_malloc(ctx->cipher->ctx_size);			if (!ctx->cipher_data)				{				EVPerr(EVP_F_EVP_CIPHERINIT_EX, ERR_R_MALLOC_FAILURE);				return 0;				}			}		else			{			ctx->cipher_data = NULL;			}		ctx->key_len = cipher->key_len;		ctx->flags = 0;		if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT)			{			if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL))				{				EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_INITIALIZATION_ERROR);				return 0;				}			}		}	else if(!ctx->cipher)		{		EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_NO_CIPHER_SET);		return 0;		}#ifndef OPENSSL_NO_ENGINEskip_to_init:#endif	/* we assume block size is a power of 2 in *cryptUpdate */	OPENSSL_assert(ctx->cipher->block_size == 1	    || ctx->cipher->block_size == 8	    || ctx->cipher->block_size == 16);	if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {		switch(EVP_CIPHER_CTX_mode(ctx)) {			case EVP_CIPH_STREAM_CIPHER:			case EVP_CIPH_ECB_MODE:			break;			case EVP_CIPH_CFB_MODE:			case EVP_CIPH_OFB_MODE:			ctx->num = 0;			case EVP_CIPH_CBC_MODE:			OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <=					(int)sizeof(ctx->iv));			if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));			memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));			break;			default:			return 0;			break;		}	}#ifdef OPENSSL_FIPS	/* After 'key' is set no further parameters changes are permissible.	 * So only check for non FIPS enabling at this point.	 */	if (key && FIPS_mode())		{		if (!(ctx->cipher->flags & EVP_CIPH_FLAG_FIPS)			& !(ctx->flags & EVP_CIPH_FLAG_NON_FIPS_ALLOW))			{			EVPerr(EVP_F_EVP_CIPHERINIT_EX, EVP_R_DISABLED_FOR_FIPS);#if 0			ERR_add_error_data(2, "cipher=",						EVP_CIPHER_name(ctx->cipher));#endif			ctx->cipher = &bad_cipher;			return 0;			}		}#endif	if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {		if(!ctx->cipher->init(ctx,key,iv,enc)) return 0;	}	ctx->buf_len=0;	ctx->final_used=0;	ctx->block_mask=ctx->cipher->block_size-1;	return 1;	}

static int cswift_dsa_verify(const unsigned char *dgst, int dgst_len,				DSA_SIG *sig, DSA *dsa)	{	SW_CONTEXT_HANDLE hac;	SW_PARAM sw_param;	SW_STATUS sw_status;	SW_LARGENUMBER arg[2], res;	unsigned long sig_result;	BN_CTX *ctx;	BIGNUM *dsa_p = NULL;	BIGNUM *dsa_q = NULL;	BIGNUM *dsa_g = NULL;	BIGNUM *dsa_key = NULL;	BIGNUM *argument = NULL;	int to_return = -1;	int acquired = 0;	if((ctx = BN_CTX_new()) == NULL)		goto err;	if(!get_context(&hac))		{		CSWIFTerr(CSWIFT_F_CSWIFT_DSA_VERIFY,CSWIFT_R_UNIT_FAILURE);		goto err;		}	acquired = 1;	/* Prepare the params */	BN_CTX_start(ctx);	dsa_p = BN_CTX_get(ctx);	dsa_q = BN_CTX_get(ctx);	dsa_g = BN_CTX_get(ctx);	dsa_key = BN_CTX_get(ctx);	argument = BN_CTX_get(ctx);	if(!argument)		{		CSWIFTerr(CSWIFT_F_CSWIFT_DSA_VERIFY,CSWIFT_R_BN_CTX_FULL);		goto err;		}	if(!bn_wexpand(dsa_p, dsa->p->top) ||			!bn_wexpand(dsa_q, dsa->q->top) ||			!bn_wexpand(dsa_g, dsa->g->top) ||			!bn_wexpand(dsa_key, dsa->pub_key->top) ||			!bn_wexpand(argument, 40))		{		CSWIFTerr(CSWIFT_F_CSWIFT_DSA_VERIFY,CSWIFT_R_BN_EXPAND_FAIL);		goto err;		}	sw_param.type = SW_ALG_DSA;	sw_param.up.dsa.p.nbytes = BN_bn2bin(dsa->p,				(unsigned char *)dsa_p->d);	sw_param.up.dsa.p.value = (unsigned char *)dsa_p->d;	sw_param.up.dsa.q.nbytes = BN_bn2bin(dsa->q,				(unsigned char *)dsa_q->d);	sw_param.up.dsa.q.value = (unsigned char *)dsa_q->d;	sw_param.up.dsa.g.nbytes = BN_bn2bin(dsa->g,				(unsigned char *)dsa_g->d);	sw_param.up.dsa.g.value = (unsigned char *)dsa_g->d;	sw_param.up.dsa.key.nbytes = BN_bn2bin(dsa->pub_key,				(unsigned char *)dsa_key->d);	sw_param.up.dsa.key.value = (unsigned char *)dsa_key->d;	/* Attach the key params */	sw_status = p_CSwift_AttachKeyParam(hac, &sw_param);	switch(sw_status)		{	case SW_OK:		break;	case SW_ERR_INPUT_SIZE:		CSWIFTerr(CSWIFT_F_CSWIFT_DSA_VERIFY,CSWIFT_R_BAD_KEY_SIZE);		goto err;	default:		{		char tmpbuf[DECIMAL_SIZE(sw_status)+1];		CSWIFTerr(CSWIFT_F_CSWIFT_DSA_VERIFY,CSWIFT_R_REQUEST_FAILED);		sprintf(tmpbuf, "%ld", sw_status);		ERR_add_error_data(2, "CryptoSwift error number is ",tmpbuf);		}		goto err;		}	/* Prepare the argument and response */	arg[0].nbytes = dgst_len;	arg[0].value = (unsigned char *)dgst;	arg[1].nbytes = 40;	arg[1].value = (unsigned char *)argument->d;	memset(arg[1].value, 0, 40);	BN_bn2bin(sig->r, arg[1].value + 20 - BN_num_bytes(sig->r));	BN_bn2bin(sig->s, arg[1].value + 40 - BN_num_bytes(sig->s));	res.nbytes = 4; /* unsigned long */	res.value = (unsigned char *)(&sig_result);	/* Perform the operation */	sw_status = p_CSwift_SimpleRequest(hac, SW_CMD_DSS_VERIFY, arg, 2,		&res, 1);	if(sw_status != SW_OK)		{		char tmpbuf[DECIMAL_SIZE(sw_status)+1];		CSWIFTerr(CSWIFT_F_CSWIFT_DSA_VERIFY,CSWIFT_R_REQUEST_FAILED);		sprintf(tmpbuf, "%ld", sw_status);		ERR_add_error_data(2, "CryptoSwift error number is ",tmpbuf);		goto err;		}	/* Convert the response */	to_return = ((sig_result == 0) ? 0 : 1);//.........这里部分代码省略.........