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

其他游戏

开发平台:

Visual C++

  1. /* conf_api.c */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3.  * All rights reserved.
  4.  *
  5.  * This package is an SSL implementation written
  6.  * by Eric Young (eay@cryptsoft.com).
  7.  * The implementation was written so as to conform with Netscapes SSL.
  8.  * 
  9.  * This library is free for commercial and non-commercial use as long as
  10.  * the following conditions are aheared to.  The following conditions
  11.  * apply to all code found in this distribution, be it the RC4, RSA,
  12.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13.  * included with this distribution is covered by the same copyright terms
  14.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15.  * 
  16.  * Copyright remains Eric Young's, and as such any Copyright notices in
  17.  * the code are not to be removed.
  18.  * If this package is used in a product, Eric Young should be given attribution
  19.  * as the author of the parts of the library used.
  20.  * This can be in the form of a textual message at program startup or
  21.  * in documentation (online or textual) provided with the package.
  22.  * 
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    "This product includes cryptographic software written by
  34.  *     Eric Young (eay@cryptsoft.com)"
  35.  *    The word 'cryptographic' can be left out if the rouines from the library
  36.  *    being used are not cryptographic related :-).
  37.  * 4. If you include any Windows specific code (or a derivative thereof) from 
  38.  *    the apps directory (application code) you must include an acknowledgement:
  39.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40.  * 
  41.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51.  * SUCH DAMAGE.
  52.  * 
  53.  * The licence and distribution terms for any publically available version or
  54.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55.  * copied and put under another distribution licence
  56.  * [including the GNU Public Licence.]
  57.  */
  58. /* Part of the code in here was originally in conf.c, which is now removed */
  59. #ifndef CONF_DEBUG
  60. # undef NDEBUG /* avoid conflicting definitions */
  61. # define NDEBUG
  62. #endif
  63. #include <assert.h>
  64. #include <string.h>
  65. #include <openssl/conf.h>
  66. #include <openssl/conf_api.h>
  67. #include "e_os.h"
  68. static void value_free_hash(CONF_VALUE *a, LHASH *conf);
  69. static void value_free_stack(CONF_VALUE *a,LHASH *conf);
  70. static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_hash, CONF_VALUE *, LHASH *)
  71. static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_stack, CONF_VALUE *, LHASH *)
  72. /* We don't use function pointer casting or wrapper functions - but cast each
  73.  * callback parameter inside the callback functions. */
  74. /* static unsigned long hash(CONF_VALUE *v); */
  75. static unsigned long hash(const void *v_void);
  76. /* static int cmp_conf(CONF_VALUE *a,CONF_VALUE *b); */
  77. static int cmp_conf(const void *a_void,const void *b_void);
  78. /* Up until OpenSSL 0.9.5a, this was get_section */
  79. CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section)
  80. {
  81. CONF_VALUE *v,vv;
  82. if ((conf == NULL) || (section == NULL)) return(NULL);
  83. vv.name=NULL;
  84. vv.section=(char *)section;
  85. v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
  86. return(v);
  87. }
  88. /* Up until OpenSSL 0.9.5a, this was CONF_get_section */
  89. STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
  90.        const char *section)
  91. {
  92. CONF_VALUE *v;
  93. v=_CONF_get_section(conf,section);
  94. if (v != NULL)
  95. return((STACK_OF(CONF_VALUE) *)v->value);
  96. else
  97. return(NULL);
  98. }
  99. int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value)
  100. {
  101. CONF_VALUE *v = NULL;
  102. STACK_OF(CONF_VALUE) *ts;
  103. ts = (STACK_OF(CONF_VALUE) *)section->value;
  104. value->section=section->section;
  105. if (!sk_CONF_VALUE_push(ts,value))
  106. {
  107. return 0;
  108. }
  109. v = (CONF_VALUE *)lh_insert(conf->data, value);
  110. if (v != NULL)
  111. {
  112. sk_CONF_VALUE_delete_ptr(ts,v);
  113. OPENSSL_free(v->name);
  114. OPENSSL_free(v->value);
  115. OPENSSL_free(v);
  116. }
  117. return 1;
  118. }
  119. char *_CONF_get_string(const CONF *conf, const char *section, const char *name)
  120. {
  121. CONF_VALUE *v,vv;
  122. char *p;
  123. if (name == NULL) return(NULL);
  124. if (conf != NULL)
  125. {
  126. if (section != NULL)
  127. {
  128. vv.name=(char *)name;
  129. vv.section=(char *)section;
  130. v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
  131. if (v != NULL) return(v->value);
  132. if (strcmp(section,"ENV") == 0)
  133. {
  134. p=Getenv(name);
  135. if (p != NULL) return(p);
  136. }
  137. }
  138. vv.section="default";
  139. vv.name=(char *)name;
  140. v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
  141. if (v != NULL)
  142. return(v->value);
  143. else
  144. return(NULL);
  145. }
  146. else
  147. return(Getenv(name));
  148. }
  149. #if 0 /* There's no way to provide error checking with this function, so
  150.  force implementors of the higher levels to get a string and read
  151.  the number themselves. */
  152. long _CONF_get_number(CONF *conf, char *section, char *name)
  153. {
  154. char *str;
  155. long ret=0;
  156. str=_CONF_get_string(conf,section,name);
  157. if (str == NULL) return(0);
  158. for (;;)
  159. {
  160. if (conf->meth->is_number(conf, *str))
  161. ret=ret*10+conf->meth->to_int(conf, *str);
  162. else
  163. return(ret);
  164. str++;
  165. }
  166. }
  167. #endif
  168. int _CONF_new_data(CONF *conf)
  169. {
  170. if (conf == NULL)
  171. {
  172. return 0;
  173. }
  174. if (conf->data == NULL)
  175. if ((conf->data = lh_new(hash, cmp_conf)) == NULL)
  176. {
  177. return 0;
  178. }
  179. return 1;
  180. }
  181. void _CONF_free_data(CONF *conf)
  182. {
  183. if (conf == NULL || conf->data == NULL) return;
  184. conf->data->down_load=0; /* evil thing to make sure the 'OPENSSL_free()'
  185.   * works as expected */
  186. lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(value_free_hash),
  187. conf->data);
  188. /* We now have only 'section' entries in the hash table.
  189.  * Due to problems with */
  190. lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(value_free_stack),
  191. conf->data);
  192. lh_free(conf->data);
  193. }
  194. static void value_free_hash(CONF_VALUE *a, LHASH *conf)
  195. {
  196. if (a->name != NULL)
  197. {
  198. a=(CONF_VALUE *)lh_delete(conf,a);
  199. }
  200. }
  201. static void value_free_stack(CONF_VALUE *a, LHASH *conf)
  202. {
  203. CONF_VALUE *vv;
  204. STACK *sk;
  205. int i;
  206. if (a->name != NULL) return;
  207. sk=(STACK *)a->value;
  208. for (i=sk_num(sk)-1; i>=0; i--)
  209. {
  210. vv=(CONF_VALUE *)sk_value(sk,i);
  211. OPENSSL_free(vv->value);
  212. OPENSSL_free(vv->name);
  213. OPENSSL_free(vv);
  214. }
  215. if (sk != NULL) sk_free(sk);
  216. OPENSSL_free(a->section);
  217. OPENSSL_free(a);
  218. }
  219. /* static unsigned long hash(CONF_VALUE *v) */
  220. static unsigned long hash(const void *v_void)
  221. {
  222. CONF_VALUE *v = (CONF_VALUE *)v_void;
  223. return((lh_strhash(v->section)<<2)^lh_strhash(v->name));
  224. }
  225. /* static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b) */
  226. static int cmp_conf(const void *a_void,const  void *b_void)
  227. {
  228. int i;
  229. CONF_VALUE *a = (CONF_VALUE *)a_void;
  230. CONF_VALUE *b = (CONF_VALUE *)b_void;
  231. if (a->section != b->section)
  232. {
  233. i=strcmp(a->section,b->section);
  234. if (i) return(i);
  235. }
  236. if ((a->name != NULL) && (b->name != NULL))
  237. {
  238. i=strcmp(a->name,b->name);
  239. return(i);
  240. }
  241. else if (a->name == b->name)
  242. return(0);
  243. else
  244. return((a->name == NULL)?-1:1);
  245. }
  246. /* Up until OpenSSL 0.9.5a, this was new_section */
  247. CONF_VALUE *_CONF_new_section(CONF *conf, const char *section)
  248. {
  249. STACK *sk=NULL;
  250. int ok=0,i;
  251. CONF_VALUE *v=NULL,*vv;
  252. if ((sk=sk_new_null()) == NULL)
  253. goto err;
  254. if ((v=(CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE))) == NULL)
  255. goto err;
  256. i=strlen(section)+1;
  257. if ((v->section=(char *)OPENSSL_malloc(i)) == NULL)
  258. goto err;
  259. memcpy(v->section,section,i);
  260. v->name=NULL;
  261. v->value=(char *)sk;
  262. vv=(CONF_VALUE *)lh_insert(conf->data,v);
  263. assert(vv == NULL);
  264. ok=1;
  265. err:
  266. if (!ok)
  267. {
  268. if (sk != NULL) sk_free(sk);
  269. if (v != NULL) OPENSSL_free(v);
  270. v=NULL;
  271. }
  272. return(v);
  273. }
  274. IMPLEMENT_STACK_OF(CONF_VALUE)