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

static int dlfcn_load(DSO *dso)	{	void *ptr = NULL;	/* See applicable comments in dso_dl.c */	char *filename = DSO_convert_filename(dso, NULL);	int flags = DLOPEN_FLAG;	if(filename == NULL)		{		DSOerr(DSO_F_DLFCN_LOAD,DSO_R_NO_FILENAME);		goto err;		}#ifdef RTLD_GLOBAL	if (dso->flags & DSO_FLAG_GLOBAL_SYMBOLS)		flags |= RTLD_GLOBAL;#endif	ptr = dlopen(filename, flags);	if(ptr == NULL)		{		DSOerr(DSO_F_DLFCN_LOAD,DSO_R_LOAD_FAILED);		ERR_add_error_data(4, "filename(", filename, "): ", dlerror());		goto err;		}	if(!sk_void_push(dso->meth_data, (char *)ptr))		{		DSOerr(DSO_F_DLFCN_LOAD,DSO_R_STACK_ERROR);		goto err;		}	/* Success */	dso->loaded_filename = filename;	return(1);err:	/* Cleanup! */	if(filename != NULL)		OPENSSL_free(filename);	if(ptr != NULL)		dlclose(ptr);	return(0);}

static int dl_load(DSO *dso){    shl_t ptr = NULL;    /*     * We don't do any fancy retries or anything, just take the method's (or     * DSO's if it has the callback set) best translation of the     * platform-independant filename and try once with that.     */    char *filename = DSO_convert_filename(dso, NULL);    if (filename == NULL) {        DSOerr(DSO_F_DL_LOAD, DSO_R_NO_FILENAME);        goto err;    }    ptr = shl_load(filename, BIND_IMMEDIATE |                   (dso->flags & DSO_FLAG_NO_NAME_TRANSLATION ? 0 :                    DYNAMIC_PATH), 0L);    if (ptr == NULL) {        DSOerr(DSO_F_DL_LOAD, DSO_R_LOAD_FAILED);        ERR_add_error_data(4, "filename(", filename, "): ", strerror(errno));        goto err;    }    if (!sk_push(dso->meth_data, (char *)ptr)) {        DSOerr(DSO_F_DL_LOAD, DSO_R_STACK_ERROR);        goto err;    }    /*     * Success, stick the converted filename we've loaded under into the DSO     * (it also serves as the indicator that we are currently loaded).     */    dso->loaded_filename = filename;    return (1); err:    /* Cleanup! */    if (filename != NULL)        OPENSSL_free(filename);    if (ptr != NULL)        shl_unload(ptr);    return (0);}

int DSO_set_filename(DSO *dso, const char *filename){    char *copied;    if ((dso == NULL) || (filename == NULL)) {        DSOerr(DSO_F_DSO_SET_FILENAME, ERR_R_PASSED_NULL_PARAMETER);        return (0);    }    if (dso->loaded_filename) {        DSOerr(DSO_F_DSO_SET_FILENAME, DSO_R_DSO_ALREADY_LOADED);        return (0);    }    /* We'll duplicate filename */    copied = strdup(filename);    if (copied == NULL) {        DSOerr(DSO_F_DSO_SET_FILENAME, ERR_R_MALLOC_FAILURE);        return (0);    }    free(dso->filename);    dso->filename = copied;    return (1);}

static int win32_load(DSO *dso){    HINSTANCE h = NULL, *p = NULL;    /* See applicable comments from dso_dl.c */    char *filename = DSO_convert_filename(dso, NULL);    if (filename == NULL) {        DSOerr(DSO_F_WIN32_LOAD, DSO_R_NO_FILENAME);        goto err;    }    h = LoadLibraryA(filename);    if (h == NULL) {        DSOerr(DSO_F_WIN32_LOAD, DSO_R_LOAD_FAILED);        ERR_add_error_data(3, "filename(", filename, ")");        goto err;    }    p = (HINSTANCE *) OPENSSL_malloc(sizeof(HINSTANCE));    if (p == NULL) {        DSOerr(DSO_F_WIN32_LOAD, ERR_R_MALLOC_FAILURE);        goto err;    }    *p = h;    if (!sk_void_push(dso->meth_data, p)) {        DSOerr(DSO_F_WIN32_LOAD, DSO_R_STACK_ERROR);        goto err;    }    /* Success */    dso->loaded_filename = filename;    return (1); err:    /* Cleanup ! */    if (filename != NULL)        OPENSSL_free(filename);    if (p != NULL)        OPENSSL_free(p);    if (h != NULL)        FreeLibrary(h);    return (0);}

static intdlfcn_unload(DSO *dso){	void *ptr;	if (dso == NULL) {		DSOerr(DSO_F_DLFCN_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);		return (0);	}	if (sk_void_num(dso->meth_data) < 1)		return (1);	ptr = sk_void_pop(dso->meth_data);	if (ptr == NULL) {		DSOerr(DSO_F_DLFCN_UNLOAD, DSO_R_NULL_HANDLE);		/* Should push the value back onto the stack in		 * case of a retry. */		sk_void_push(dso->meth_data, ptr);		return (0);	}	/* For now I'm not aware of any errors associated with dlclose() */	dlclose(ptr);	return (1);}

void *DSO_bind_var(DSO *dso, const char *symname)	{	void *ret = NULL;	if((dso == NULL) || (symname == NULL))		{		DSOerr(DSO_F_DSO_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);		return(NULL);		}	if(dso->meth->dso_bind_var == NULL)		{		DSOerr(DSO_F_DSO_BIND_VAR,DSO_R_UNSUPPORTED);		return(NULL);		}	if((ret = dso->meth->dso_bind_var(dso, symname)) == NULL)		{		DSOerr(DSO_F_DSO_BIND_VAR,DSO_R_SYM_FAILURE);		return(NULL);		}	/* Success */	return(ret);	}

DSO_FUNC_TYPE DSO_bind_func(DSO *dso, const char *symname)	{	DSO_FUNC_TYPE ret = NULL;	if((dso == NULL) || (symname == NULL))		{		DSOerr(DSO_F_DSO_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);		return(NULL);		}	if(dso->meth->dso_bind_func == NULL)		{		DSOerr(DSO_F_DSO_BIND_FUNC,DSO_R_UNSUPPORTED);		return(NULL);		}	if((ret = dso->meth->dso_bind_func(dso, symname)) == NULL)		{		DSOerr(DSO_F_DSO_BIND_FUNC,DSO_R_SYM_FAILURE);		return(NULL);		}	/* Success */	return(ret);	}

int DSO_set_name_converter(DSO *dso, DSO_NAME_CONVERTER_FUNC cb,                           DSO_NAME_CONVERTER_FUNC *oldcb){    if (dso == NULL) {        DSOerr(DSO_F_DSO_SET_NAME_CONVERTER,               ERR_R_PASSED_NULL_PARAMETER);        return (0);    }    if (oldcb)        *oldcb = dso->name_converter;    dso->name_converter = cb;    return (1);}

static int dl_unload(DSO *dso){    shl_t ptr;    if (dso == NULL) {        DSOerr(DSO_F_DL_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);        return (0);    }    if (sk_num(dso->meth_data) < 1)        return (1);    /* Is this statement legal? */    ptr = (shl_t) sk_pop(dso->meth_data);    if (ptr == NULL) {        DSOerr(DSO_F_DL_UNLOAD, DSO_R_NULL_HANDLE);        /*         * Should push the value back onto the stack in case of a retry.         */        sk_push(dso->meth_data, (char *)ptr);        return (0);    }    shl_unload(ptr);    return (1);}

DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags){    DSO *ret;    int allocated = 0;    if (dso == NULL) {        ret = DSO_new_method(meth);        if (ret == NULL) {            DSOerr(DSO_F_DSO_LOAD, ERR_R_MALLOC_FAILURE);            goto err;        }        allocated = 1;        /* Pass the provided flags to the new DSO object */        if (DSO_ctrl(ret, DSO_CTRL_SET_FLAGS, flags, NULL) < 0) {            DSOerr(DSO_F_DSO_LOAD, DSO_R_CTRL_FAILED);            goto err;        }    } else        ret = dso;    /* Don't load if we're currently already loaded */    if (ret->filename != NULL) {        DSOerr(DSO_F_DSO_LOAD, DSO_R_DSO_ALREADY_LOADED);        goto err;    }    /*     * filename can only be NULL if we were passed a dso that already has one     * set.     */    if (filename != NULL)        if (!DSO_set_filename(ret, filename)) {            DSOerr(DSO_F_DSO_LOAD, DSO_R_SET_FILENAME_FAILED);            goto err;        }    filename = ret->filename;    if (filename == NULL) {        DSOerr(DSO_F_DSO_LOAD, DSO_R_NO_FILENAME);        goto err;    }    if (ret->meth->dso_load == NULL) {        DSOerr(DSO_F_DSO_LOAD, DSO_R_UNSUPPORTED);        goto err;    }    if (!ret->meth->dso_load(ret)) {        DSOerr(DSO_F_DSO_LOAD, DSO_R_LOAD_FAILED);        goto err;    }    /* Load succeeded */    return (ret); err:    if (allocated)        DSO_free(ret);    return (NULL);}

static long dl_ctrl(DSO *dso, int cmd, long larg, void *parg)	{	if(dso == NULL)		{		DSOerr(DSO_F_DL_CTRL,ERR_R_PASSED_NULL_PARAMETER);		return(-1);		}	switch(cmd)		{	case DSO_CTRL_GET_FLAGS:		return dso->flags;	case DSO_CTRL_SET_FLAGS:		dso->flags = larg;		return(0);	case DSO_CTRL_OR_FLAGS:		dso->flags |= larg;		return(0);	default:		break;		}	DSOerr(DSO_F_DL_CTRL,DSO_R_UNKNOWN_COMMAND);	return(-1);	}

int DSO_up_ref(DSO *dso){    int i;    if (dso == NULL) {        DSOerr(DSO_F_DSO_UP_REF, ERR_R_PASSED_NULL_PARAMETER);        return 0;    }    if (CRYPTO_atomic_add(&dso->references, 1, &i, dso->lock) <= 0)        return 0;    return ((i > 1) ? 1 : 0);}

static char *dlfcn_name_converter(DSO *dso, const char *filename)	{	char *translated;	int len, rsize, transform;	len = strlen(filename);	rsize = len + 1;	transform = (strstr(filename, "/") == NULL);	if(transform)		{#ifndef SYMBIAN				/* We will convert this to "%s.so" or "lib%s.so" */		rsize += 3;	/* The length of ".so" */		if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)			rsize += 3; /* The length of "lib" */#else	/* We will convert this to "%s.dll" or "lib%s.dll" */		rsize += 4;	/* The length of ".dll" */		if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)			rsize += 3; /* The length of "lib" */#endif					}	translated = OPENSSL_malloc(rsize);	if(translated == NULL)		{		DSOerr(DSO_F_DLFCN_NAME_CONVERTER,				DSO_R_NAME_TRANSLATION_FAILED);		return(NULL);		}	if(transform)		{#ifndef SYMBIAN				if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)			sprintf(translated, "lib%s.so", filename);		else			sprintf(translated, "%s.so", filename);#else		if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)			sprintf(translated, "lib%s.dll", filename);		else			sprintf(translated, "%s.dll", filename);#endif						}	else		sprintf(translated, "%s", filename);	return(translated);	}

int DSO_free(DSO *dso){    int i;    if (dso == NULL)        return (1);    i = CRYPTO_add(&dso->references, -1, CRYPTO_LOCK_DSO);#ifdef REF_PRINT    REF_PRINT("DSO", dso);#endif    if (i > 0)        return (1);#ifdef REF_CHECK    if (i < 0) {        fprintf(stderr, "DSO_free, bad reference count/n");        abort();    }#endif    if ((dso->meth->dso_unload != NULL) && !dso->meth->dso_unload(dso)) {        DSOerr(DSO_F_DSO_FREE, DSO_R_UNLOAD_FAILED);        return (0);    }    if ((dso->meth->finish != NULL) && !dso->meth->finish(dso)) {        DSOerr(DSO_F_DSO_FREE, DSO_R_FINISH_FAILED);        return (0);    }    sk_void_free(dso->meth_data);    OPENSSL_free(dso->filename);    OPENSSL_free(dso->loaded_filename);    OPENSSL_free(dso);    return (1);}

DSO *DSO_new_method(DSO_METHOD *meth)	{	DSO *ret;	if(default_DSO_meth == NULL)		/* We default to DSO_METH_openssl() which in turn defaults		 * to stealing the "best available" method. Will fallback		 * to DSO_METH_null() in the worst case. */		default_DSO_meth = DSO_METHOD_openssl();	ret = (DSO *)OPENSSL_malloc(sizeof(DSO));	if(ret == NULL)		{		DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);		return(NULL);		}	memset(ret, 0, sizeof(DSO));	ret->meth_data = sk_void_new_null();	if(ret->meth_data == NULL)		{		/* sk_new doesn't generate any errors so we do */		DSOerr(DSO_F_DSO_NEW_METHOD,ERR_R_MALLOC_FAILURE);		OPENSSL_free(ret);		return(NULL);		}	if(meth == NULL)		ret->meth = default_DSO_meth;	else		ret->meth = meth;	ret->references = 1;	if((ret->meth->init != NULL) && !ret->meth->init(ret))		{		OPENSSL_free(ret);		ret=NULL;		}	return(ret);	}

int DSO_up_ref(DSO *dso){    int i;    if (dso == NULL) {        DSOerr(DSO_F_DSO_UP_REF, ERR_R_PASSED_NULL_PARAMETER);        return 0;    }    if (CRYPTO_UP_REF(&dso->references, &i, dso->lock) <= 0)        return 0;    REF_PRINT_COUNT("DSO", r);    REF_ASSERT_ISNT(i < 2);    return ((i > 1) ? 1 : 0);}

char *DSO_merge(DSO *dso, const char *filespec1, const char *filespec2){    char *result = NULL;    if (dso == NULL || filespec1 == NULL) {        DSOerr(DSO_F_DSO_MERGE, ERR_R_PASSED_NULL_PARAMETER);        return (NULL);    }    if ((dso->flags & DSO_FLAG_NO_NAME_TRANSLATION) == 0) {        if (dso->merger != NULL)            result = dso->merger(dso, filespec1, filespec2);        else if (dso->meth->dso_merger != NULL)            result = dso->meth->dso_merger(dso, filespec1, filespec2);    }    return (result);}

static char *dlfcn_name_converter(DSO *dso, const char *filename){	char *translated;	int ret;	if (strchr(filename, '/') == NULL) {		/* Bare name, so convert to "%s.so" or "lib%s.so" */		if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)			ret = asprintf(&translated, "lib%s" DSO_ext, filename);		else			ret = asprintf(&translated, "%s" DSO_ext, filename);		if (ret == -1)			translated = NULL;	} else {		/* Full path, so just duplicate it */		translated = strdup(filename);	}	if (translated == NULL)		DSOerr(DSO_F_DLFCN_NAME_CONVERTER,		    DSO_R_NAME_TRANSLATION_FAILED);	return (translated);}

static char *dlfcn_merger(DSO *dso, const char *filespec1,	const char *filespec2)	{	char *merged;	size_t len;	if(!filespec1 && !filespec2)		{		DSOerr(DSO_F_DLFCN_MERGER,				ERR_R_PASSED_NULL_PARAMETER);		return(NULL);		}	/* If the first file specification is a rooted path, it rules.	   same goes if the second file specification is missing. */	if (!filespec2 || (filespec1 != NULL && filespec1[0] == '/'))		{		len = strlen(filespec1) + 1;		merged = OPENSSL_malloc(len);		if(!merged)			{			DSOerr(DSO_F_DLFCN_MERGER, ERR_R_MALLOC_FAILURE);			return(NULL);			}		strlcpy(merged, filespec1, len);		}	/* If the first file specification is missing, the second one rules. */	else if (!filespec1)		{		len = strlen(filespec2) + 1;		merged = OPENSSL_malloc(strlen(filespec2) + 1);		if(!merged)			{			DSOerr(DSO_F_DLFCN_MERGER,				ERR_R_MALLOC_FAILURE);			return(NULL);			}		strlcpy(merged, filespec2, len);		}	else		/* This part isn't as trivial as it looks.  It assumes that		   the second file specification really is a directory, and		   makes no checks whatsoever.  Therefore, the result becomes		   the concatenation of filespec2 followed by a slash followed		   by filespec1. */		{		int spec2len, len;		spec2len = strlen(filespec2);		len = spec2len + (filespec1 ? strlen(filespec1) : 0);		if(filespec2 && filespec2[spec2len - 1] == '/')			{			spec2len--;			len--;			}		merged = OPENSSL_malloc(len + 2);		if(!merged)			{			DSOerr(DSO_F_DLFCN_MERGER,				ERR_R_MALLOC_FAILURE);			return(NULL);			}		strlcpy(merged, filespec2, len + 2);		merged[spec2len] = '/';		strlcpy(&merged[spec2len + 1], filespec1, len + 1 - spec2len);		}	return(merged);	}

static void *win32_globallookup(const char *name)	{	HMODULE dll;	HANDLE hModuleSnap = INVALID_HANDLE_VALUE;	MODULEENTRY32 me32;	CREATETOOLHELP32SNAPSHOT create_snap;	CLOSETOOLHELP32SNAPSHOT  close_snap;	MODULE32 module_first, module_next;	FARPROC ret=NULL;	dll = LoadLibrary(TEXT(DLLNAME));	if (dll == NULL)		{		DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);		return NULL;		}	create_snap = (CREATETOOLHELP32SNAPSHOT)		GetProcAddress(dll,"CreateToolhelp32Snapshot");	if (create_snap == NULL)		{		FreeLibrary(dll);		DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);		return NULL;		}	/* We take the rest for granted... */#ifdef _WIN32_WCE	close_snap = (CLOSETOOLHELP32SNAPSHOT)		GetProcAddress(dll,"CloseToolhelp32Snapshot");#else	close_snap = (CLOSETOOLHELP32SNAPSHOT)CloseHandle;#endif	module_first = (MODULE32)GetProcAddress(dll,"Module32First");	module_next  = (MODULE32)GetProcAddress(dll,"Module32Next");	hModuleSnap = (*create_snap)(TH32CS_SNAPMODULE,0);	if( hModuleSnap == INVALID_HANDLE_VALUE )		{		FreeLibrary(dll);		DSOerr(DSO_F_WIN32_GLOBALLOOKUP,DSO_R_UNSUPPORTED);		return NULL;		}	me32.dwSize = sizeof(me32);	if (!(*module_first)(hModuleSnap,&me32))		{		(*close_snap)(hModuleSnap);		FreeLibrary(dll);		return NULL;		}	do	{		if ((ret = GetProcAddress(me32.hModule,name)))			{			(*close_snap)(hModuleSnap);			FreeLibrary(dll);			return ret;			}		} while((*module_next)(hModuleSnap,&me32));	(*close_snap)(hModuleSnap); 	FreeLibrary(dll);	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;}

static char *win32_merger(DSO *dso, const char *filespec1,                          const char *filespec2){    char *merged = NULL;    struct file_st *filespec1_split = NULL;    struct file_st *filespec2_split = NULL;    if (!filespec1 && !filespec2) {        DSOerr(DSO_F_WIN32_MERGER, ERR_R_PASSED_NULL_PARAMETER);        return (NULL);    }    if (!filespec2) {        merged = OPENSSL_malloc(strlen(filespec1) + 1);        if (!merged) {            DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);            return (NULL);        }        strcpy(merged, filespec1);    } else if (!filespec1) {        merged = OPENSSL_malloc(strlen(filespec2) + 1);        if (!merged) {            DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);            return (NULL);        }        strcpy(merged, filespec2);    } else {        filespec1_split = win32_splitter(dso, filespec1, 0);        if (!filespec1_split) {            DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);            return (NULL);        }        filespec2_split = win32_splitter(dso, filespec2, 1);        if (!filespec2_split) {            DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);            OPENSSL_free(filespec1_split);            return (NULL);        }        /* Fill in into filespec1_split */        if (!filespec1_split->node && !filespec1_split->device) {            filespec1_split->node = filespec2_split->node;            filespec1_split->nodelen = filespec2_split->nodelen;            filespec1_split->device = filespec2_split->device;            filespec1_split->devicelen = filespec2_split->devicelen;        }        if (!filespec1_split->dir) {            filespec1_split->dir = filespec2_split->dir;            filespec1_split->dirlen = filespec2_split->dirlen;        } else if (filespec1_split->dir[0] != '//'                   && filespec1_split->dir[0] != '/') {            filespec1_split->predir = filespec2_split->dir;            filespec1_split->predirlen = filespec2_split->dirlen;        }        if (!filespec1_split->file) {            filespec1_split->file = filespec2_split->file;            filespec1_split->filelen = filespec2_split->filelen;        }        merged = win32_joiner(dso, filespec1_split);    }    OPENSSL_free(filespec1_split);    OPENSSL_free(filespec2_split);    return (merged);}

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

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);}

static int win32_pathbyaddr(void *addr, char *path, int sz){    HMODULE dll;    HANDLE hModuleSnap = INVALID_HANDLE_VALUE;    MODULEENTRY32 me32;    CREATETOOLHELP32SNAPSHOT create_snap;    CLOSETOOLHELP32SNAPSHOT close_snap;    MODULE32 module_first, module_next;    if (addr == NULL) {        union {            int (*f) (void *, char *, int);            void *p;        } t = {            win32_pathbyaddr        };        addr = t.p;    }    dll = LoadLibrary(TEXT(DLLNAME));    if (dll == NULL) {        DSOerr(DSO_F_WIN32_PATHBYADDR, DSO_R_UNSUPPORTED);        return -1;    }    create_snap = (CREATETOOLHELP32SNAPSHOT)        GetProcAddress(dll, "CreateToolhelp32Snapshot");    if (create_snap == NULL) {        FreeLibrary(dll);        DSOerr(DSO_F_WIN32_PATHBYADDR, DSO_R_UNSUPPORTED);        return -1;    }    /* We take the rest for granted... */# ifdef _WIN32_WCE    close_snap = (CLOSETOOLHELP32SNAPSHOT)        GetProcAddress(dll, "CloseToolhelp32Snapshot");# else    close_snap = (CLOSETOOLHELP32SNAPSHOT) CloseHandle;# endif    module_first = (MODULE32) GetProcAddress(dll, "Module32First");    module_next = (MODULE32) GetProcAddress(dll, "Module32Next");    hModuleSnap = (*create_snap) (TH32CS_SNAPMODULE, 0);    if (hModuleSnap == INVALID_HANDLE_VALUE) {        FreeLibrary(dll);        DSOerr(DSO_F_WIN32_PATHBYADDR, DSO_R_UNSUPPORTED);        return -1;    }    me32.dwSize = sizeof(me32);    if (!(*module_first) (hModuleSnap, &me32)) {        (*close_snap) (hModuleSnap);        FreeLibrary(dll);        DSOerr(DSO_F_WIN32_PATHBYADDR, DSO_R_FAILURE);        return -1;    }    do {        if ((BYTE *) addr >= me32.modBaseAddr &&            (BYTE *) addr < me32.modBaseAddr + me32.modBaseSize) {            (*close_snap) (hModuleSnap);            FreeLibrary(dll);# ifdef _WIN32_WCE#  if _WIN32_WCE >= 101            return WideCharToMultiByte(CP_ACP, 0, me32.szExePath, -1,                                       path, sz, NULL, NULL);#  else            {                int i, len = (int)wcslen(me32.szExePath);                if (sz <= 0)                    return len + 1;                if (len >= sz)                    len = sz - 1;                for (i = 0; i < len; i++)                    path[i] = (char)me32.szExePath[i];                path[len++] = 0;                return len;            }#  endif# else            {                int len = (int)strlen(me32.szExePath);                if (sz <= 0)                    return len + 1;                if (len >= sz)                    len = sz - 1;                memcpy(path, me32.szExePath, len);                path[len++] = 0;                return len;            }# endif        }    } while ((*module_next) (hModuleSnap, &me32));    (*close_snap) (hModuleSnap);    FreeLibrary(dll);    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;	}

static int vms_load(DSO *dso){    void *ptr = NULL;    /* See applicable comments in dso_dl.c */    char *filename = DSO_convert_filename(dso, NULL);/* Ensure 32-bit pointer for "p", and appropriate malloc() function. */# if __INITIAL_POINTER_SIZE == 64#  define DSO_MALLOC _malloc32#  pragma pointer_size save#  pragma pointer_size 32# else                          /* __INITIAL_POINTER_SIZE == 64 */#  define DSO_MALLOC OPENSSL_malloc# endif                         /* __INITIAL_POINTER_SIZE == 64 [else] */    DSO_VMS_INTERNAL *p = NULL;# if __INITIAL_POINTER_SIZE == 64#  pragma pointer_size restore# endif                         /* __INITIAL_POINTER_SIZE == 64 */    const char *sp1, *sp2;      /* Search result */    const char *ext = NULL;	/* possible extension to add */    if (filename == NULL) {        DSOerr(DSO_F_VMS_LOAD, DSO_R_NO_FILENAME);        goto err;    }    /*-     * A file specification may look like this:     *     *      node::dev:[dir-spec]name.type;ver     *     * or (for compatibility with TOPS-20):     *     *      node::dev:<dir-spec>name.type;ver     *     * and the dir-spec uses '.' as separator.  Also, a dir-spec     * may consist of several parts, with mixed use of [] and <>:     *     *      [dir1.]<dir2>     *     * We need to split the file specification into the name and     * the rest (both before and after the name itself).     */    /*     * Start with trying to find the end of a dir-spec, and save the position     * of the byte after in sp1     */    sp1 = strrchr(filename, ']');    sp2 = strrchr(filename, '>');    if (sp1 == NULL)        sp1 = sp2;    if (sp2 != NULL && sp2 > sp1)        sp1 = sp2;    if (sp1 == NULL)        sp1 = strrchr(filename, ':');    if (sp1 == NULL)        sp1 = filename;    else        sp1++;                  /* The byte after the found character */    /* Now, let's see if there's a type, and save the position in sp2 */    sp2 = strchr(sp1, '.');    /*     * If there is a period and the next character is a semi-colon,     * we need to add an extension     */    if (sp2 != NULL && sp2[1] == ';')        ext = ".EXE";    /*     * If we found it, that's where we'll cut.  Otherwise, look for a version     * number and save the position in sp2     */    if (sp2 == NULL) {        sp2 = strchr(sp1, ';');        ext = ".EXE";    }    /*     * If there was still nothing to find, set sp2 to point at the end of the     * string     */    if (sp2 == NULL)        sp2 = sp1 + strlen(sp1);    /* Check that we won't get buffer overflows */    if (sp2 - sp1 > FILENAME_MAX        || (sp1 - filename) + strlen(sp2) > FILENAME_MAX) {        DSOerr(DSO_F_VMS_LOAD, DSO_R_FILENAME_TOO_BIG);        goto err;    }    p = DSO_MALLOC(sizeof(DSO_VMS_INTERNAL));    if (p == NULL) {        DSOerr(DSO_F_VMS_LOAD, ERR_R_MALLOC_FAILURE);        goto err;    }    strncpy(p->filename, sp1, sp2 - sp1);    p->filename[sp2 - sp1] = '/0';//.........这里部分代码省略.........