dso_dl.c
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:10k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /* dso_dl.c -*- mode:C; c-file-style: "eay" -*- */
  2. /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
  3.  * project 2000.
  4.  */
  5. /* ====================================================================
  6.  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer. 
  14.  *
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in
  17.  *    the documentation and/or other materials provided with the
  18.  *    distribution.
  19.  *
  20.  * 3. All advertising materials mentioning features or use of this
  21.  *    software must display the following acknowledgment:
  22.  *    "This product includes software developed by the OpenSSL Project
  23.  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24.  *
  25.  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26.  *    endorse or promote products derived from this software without
  27.  *    prior written permission. For written permission, please contact
  28.  *    licensing@OpenSSL.org.
  29.  *
  30.  * 5. Products derived from this software may not be called "OpenSSL"
  31.  *    nor may "OpenSSL" appear in their names without prior written
  32.  *    permission of the OpenSSL Project.
  33.  *
  34.  * 6. Redistributions of any form whatsoever must retain the following
  35.  *    acknowledgment:
  36.  *    "This product includes software developed by the OpenSSL Project
  37.  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38.  *
  39.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51.  * ====================================================================
  52.  *
  53.  * This product includes cryptographic software written by Eric Young
  54.  * (eay@cryptsoft.com).  This product includes software written by Tim
  55.  * Hudson (tjh@cryptsoft.com).
  56.  *
  57.  */
  58. #include <stdio.h>
  59. #include "cryptlib.h"
  60. #include <openssl/dso.h>
  61. #ifndef DSO_DL
  62. DSO_METHOD *DSO_METHOD_dl(void)
  63.        {
  64.        return NULL;
  65.        }
  66. #else
  67. #include <dl.h>
  68. /* Part of the hack in "dl_load" ... */
  69. #define DSO_MAX_TRANSLATED_SIZE 256
  70. static int dl_load(DSO *dso);
  71. static int dl_unload(DSO *dso);
  72. static void *dl_bind_var(DSO *dso, const char *symname);
  73. static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname);
  74. #if 0
  75. static int dl_unbind_var(DSO *dso, char *symname, void *symptr);
  76. static int dl_unbind_func(DSO *dso, char *symname, DSO_FUNC_TYPE symptr);
  77. static int dl_init(DSO *dso);
  78. static int dl_finish(DSO *dso);
  79. static int dl_ctrl(DSO *dso, int cmd, long larg, void *parg);
  80. #endif
  81. static char *dl_name_converter(DSO *dso, const char *filename);
  82. static char *dl_merger(DSO *dso, const char *filespec1, const char *filespec2);
  83. static DSO_METHOD dso_meth_dl = {
  84. "OpenSSL 'dl' shared library method",
  85. dl_load,
  86. dl_unload,
  87. dl_bind_var,
  88. dl_bind_func,
  89. /* For now, "unbind" doesn't exist */
  90. #if 0
  91. NULL, /* unbind_var */
  92. NULL, /* unbind_func */
  93. #endif
  94. NULL, /* ctrl */
  95. dl_name_converter,
  96. dl_merger,
  97. NULL, /* init */
  98. NULL  /* finish */
  99. };
  100. DSO_METHOD *DSO_METHOD_dl(void)
  101. {
  102. return(&dso_meth_dl);
  103. }
  104. /* For this DSO_METHOD, our meth_data STACK will contain;
  105.  * (i) the handle (shl_t) returned from shl_load().
  106.  * NB: I checked on HPUX11 and shl_t is itself a pointer
  107.  * type so the cast is safe.
  108.  */
  109. static int dl_load(DSO *dso)
  110. {
  111. shl_t ptr = NULL;
  112. /* We don't do any fancy retries or anything, just take the method's
  113.  * (or DSO's if it has the callback set) best translation of the
  114.  * platform-independant filename and try once with that. */
  115. char *filename= DSO_convert_filename(dso, NULL);
  116. if(filename == NULL)
  117. {
  118. DSOerr(DSO_F_DL_LOAD,DSO_R_NO_FILENAME);
  119. goto err;
  120. }
  121. ptr = shl_load(filename, BIND_IMMEDIATE |
  122. (dso->flags&DSO_FLAG_NO_NAME_TRANSLATION?0:DYNAMIC_PATH), 0L);
  123. if(ptr == NULL)
  124. {
  125. DSOerr(DSO_F_DL_LOAD,DSO_R_LOAD_FAILED);
  126. ERR_add_error_data(4, "filename(", filename, "): ",
  127. strerror(errno));
  128. goto err;
  129. }
  130. if(!sk_push(dso->meth_data, (char *)ptr))
  131. {
  132. DSOerr(DSO_F_DL_LOAD,DSO_R_STACK_ERROR);
  133. goto err;
  134. }
  135. /* Success, stick the converted filename we've loaded under into the DSO
  136.  * (it also serves as the indicator that we are currently loaded). */
  137. dso->loaded_filename = filename;
  138. return(1);
  139. err:
  140. /* Cleanup! */
  141. if(filename != NULL)
  142. OPENSSL_free(filename);
  143. if(ptr != NULL)
  144. shl_unload(ptr);
  145. return(0);
  146. }
  147. static int dl_unload(DSO *dso)
  148. {
  149. shl_t ptr;
  150. if(dso == NULL)
  151. {
  152. DSOerr(DSO_F_DL_UNLOAD,ERR_R_PASSED_NULL_PARAMETER);
  153. return(0);
  154. }
  155. if(sk_num(dso->meth_data) < 1)
  156. return(1);
  157. /* Is this statement legal? */
  158. ptr = (shl_t)sk_pop(dso->meth_data);
  159. if(ptr == NULL)
  160. {
  161. DSOerr(DSO_F_DL_UNLOAD,DSO_R_NULL_HANDLE);
  162. /* Should push the value back onto the stack in
  163.  * case of a retry. */
  164. sk_push(dso->meth_data, (char *)ptr);
  165. return(0);
  166. }
  167. shl_unload(ptr);
  168. return(1);
  169. }
  170. static void *dl_bind_var(DSO *dso, const char *symname)
  171. {
  172. shl_t ptr;
  173. void *sym;
  174. if((dso == NULL) || (symname == NULL))
  175. {
  176. DSOerr(DSO_F_DL_BIND_VAR,ERR_R_PASSED_NULL_PARAMETER);
  177. return(NULL);
  178. }
  179. if(sk_num(dso->meth_data) < 1)
  180. {
  181. DSOerr(DSO_F_DL_BIND_VAR,DSO_R_STACK_ERROR);
  182. return(NULL);
  183. }
  184. ptr = (shl_t)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
  185. if(ptr == NULL)
  186. {
  187. DSOerr(DSO_F_DL_BIND_VAR,DSO_R_NULL_HANDLE);
  188. return(NULL);
  189. }
  190. if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0)
  191. {
  192. DSOerr(DSO_F_DL_BIND_VAR,DSO_R_SYM_FAILURE);
  193. ERR_add_error_data(4, "symname(", symname, "): ",
  194. strerror(errno));
  195. return(NULL);
  196. }
  197. return(sym);
  198. }
  199. static DSO_FUNC_TYPE dl_bind_func(DSO *dso, const char *symname)
  200. {
  201. shl_t ptr;
  202. void *sym;
  203. if((dso == NULL) || (symname == NULL))
  204. {
  205. DSOerr(DSO_F_DL_BIND_FUNC,ERR_R_PASSED_NULL_PARAMETER);
  206. return(NULL);
  207. }
  208. if(sk_num(dso->meth_data) < 1)
  209. {
  210. DSOerr(DSO_F_DL_BIND_FUNC,DSO_R_STACK_ERROR);
  211. return(NULL);
  212. }
  213. ptr = (shl_t)sk_value(dso->meth_data, sk_num(dso->meth_data) - 1);
  214. if(ptr == NULL)
  215. {
  216. DSOerr(DSO_F_DL_BIND_FUNC,DSO_R_NULL_HANDLE);
  217. return(NULL);
  218. }
  219. if (shl_findsym(&ptr, symname, TYPE_UNDEFINED, &sym) < 0)
  220. {
  221. DSOerr(DSO_F_DL_BIND_FUNC,DSO_R_SYM_FAILURE);
  222. ERR_add_error_data(4, "symname(", symname, "): ",
  223. strerror(errno));
  224. return(NULL);
  225. }
  226. return((DSO_FUNC_TYPE)sym);
  227. }
  228. static char *dl_merger(DSO *dso, const char *filespec1, const char *filespec2)
  229. {
  230. char *merged;
  231. if(!filespec1 && !filespec2)
  232. {
  233. DSOerr(DSO_F_DL_MERGER,
  234. ERR_R_PASSED_NULL_PARAMETER);
  235. return(NULL);
  236. }
  237. /* If the first file specification is a rooted path, it rules.
  238.    same goes if the second file specification is missing. */
  239. if (!filespec2 || filespec1[0] == '/')
  240. {
  241. merged = OPENSSL_malloc(strlen(filespec1) + 1);
  242. if(!merged)
  243. {
  244. DSOerr(DSO_F_DL_MERGER,
  245. ERR_R_MALLOC_FAILURE);
  246. return(NULL);
  247. }
  248. strcpy(merged, filespec1);
  249. }
  250. /* If the first file specification is missing, the second one rules. */
  251. else if (!filespec1)
  252. {
  253. merged = OPENSSL_malloc(strlen(filespec2) + 1);
  254. if(!merged)
  255. {
  256. DSOerr(DSO_F_DL_MERGER,
  257. ERR_R_MALLOC_FAILURE);
  258. return(NULL);
  259. }
  260. strcpy(merged, filespec2);
  261. }
  262. else
  263. /* This part isn't as trivial as it looks.  It assumes that
  264.    the second file specification really is a directory, and
  265.    makes no checks whatsoever.  Therefore, the result becomes
  266.    the concatenation of filespec2 followed by a slash followed
  267.    by filespec1. */
  268. {
  269. int spec2len, len;
  270. spec2len = (filespec2 ? strlen(filespec2) : 0);
  271. len = spec2len + (filespec1 ? strlen(filespec1) : 0);
  272. if(filespec2 && filespec2[spec2len - 1] == '/')
  273. {
  274. spec2len--;
  275. len--;
  276. }
  277. merged = OPENSSL_malloc(len + 2);
  278. if(!merged)
  279. {
  280. DSOerr(DSO_F_DL_MERGER,
  281. ERR_R_MALLOC_FAILURE);
  282. return(NULL);
  283. }
  284. strcpy(merged, filespec2);
  285. merged[spec2len] = '/';
  286. strcpy(&merged[spec2len + 1], filespec1);
  287. }
  288. return(merged);
  289. }
  290. /* This function is identical to the one in dso_dlfcn.c, but as it is highly
  291.  * unlikely that both the "dl" *and* "dlfcn" variants are being compiled at the
  292.  * same time, there's no great duplicating the code. Figuring out an elegant 
  293.  * way to share one copy of the code would be more difficult and would not
  294.  * leave the implementations independant. */
  295. #if defined(__hpux)
  296. static const char extension[] = ".sl";
  297. #else
  298. static const char extension[] = ".so";
  299. #endif
  300. static char *dl_name_converter(DSO *dso, const char *filename)
  301. {
  302. char *translated;
  303. int len, rsize, transform;
  304. len = strlen(filename);
  305. rsize = len + 1;
  306. transform = (strstr(filename, "/") == NULL);
  307. {
  308. /* We will convert this to "%s.s?" or "lib%s.s?" */
  309. rsize += strlen(extension);/* The length of ".s?" */
  310. if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
  311. rsize += 3; /* The length of "lib" */
  312. }
  313. translated = OPENSSL_malloc(rsize);
  314. if(translated == NULL)
  315. {
  316. DSOerr(DSO_F_DL_NAME_CONVERTER,
  317. DSO_R_NAME_TRANSLATION_FAILED); 
  318. return(NULL);   
  319. }
  320. if(transform)
  321. {
  322. if ((DSO_flags(dso) & DSO_FLAG_NAME_TRANSLATION_EXT_ONLY) == 0)
  323. sprintf(translated, "lib%s%s", filename, extension);
  324. else
  325. sprintf(translated, "%s%s", filename, extension);
  326. }
  327. else
  328. sprintf(translated, "%s", filename);
  329. return(translated);
  330. }
  331. #endif /* DSO_DL */