开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
cryptlib.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：21k
源码类别：

其他游戏

开发平台：

Visual C++

cryptlib.c：源码内容
  1. /* crypto/cryptlib.c */
  2. /* ====================================================================
  3.  * Copyright (c) 1998-2003 The OpenSSL Project.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer. 
  11.  *
  12.  * 2. Redistributions in binary form must reproduce the above copyright
  13.  *    notice, this list of conditions and the following disclaimer in
  14.  *    the documentation and/or other materials provided with the
  15.  *    distribution.
  16.  *
  17.  * 3. All advertising materials mentioning features or use of this
  18.  *    software must display the following acknowledgment:
  19.  *    "This product includes software developed by the OpenSSL Project
  20.  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  21.  *
  22.  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  23.  *    endorse or promote products derived from this software without
  24.  *    prior written permission. For written permission, please contact
  25.  *    openssl-core@openssl.org.
  26.  *
  27.  * 5. Products derived from this software may not be called "OpenSSL"
  28.  *    nor may "OpenSSL" appear in their names without prior written
  29.  *    permission of the OpenSSL Project.
  30.  *
  31.  * 6. Redistributions of any form whatsoever must retain the following
  32.  *    acknowledgment:
  33.  *    "This product includes software developed by the OpenSSL Project
  34.  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  35.  *
  36.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  37.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  39.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  40.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  42.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  44.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  45.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  47.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  48.  * ====================================================================
  49.  *
  50.  * This product includes cryptographic software written by Eric Young
  51.  * (eay@cryptsoft.com).  This product includes software written by Tim
  52.  * Hudson (tjh@cryptsoft.com).
  53.  *
  54.  */
  55. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  56.  * All rights reserved.
  57.  *
  58.  * This package is an SSL implementation written
  59.  * by Eric Young (eay@cryptsoft.com).
  60.  * The implementation was written so as to conform with Netscapes SSL.
  61.  * 
  62.  * This library is free for commercial and non-commercial use as long as
  63.  * the following conditions are aheared to.  The following conditions
  64.  * apply to all code found in this distribution, be it the RC4, RSA,
  65.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  66.  * included with this distribution is covered by the same copyright terms
  67.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  68.  * 
  69.  * Copyright remains Eric Young's, and as such any Copyright notices in
  70.  * the code are not to be removed.
  71.  * If this package is used in a product, Eric Young should be given attribution
  72.  * as the author of the parts of the library used.
  73.  * This can be in the form of a textual message at program startup or
  74.  * in documentation (online or textual) provided with the package.
  75.  * 
  76.  * Redistribution and use in source and binary forms, with or without
  77.  * modification, are permitted provided that the following conditions
  78.  * are met:
  79.  * 1. Redistributions of source code must retain the copyright
  80.  *    notice, this list of conditions and the following disclaimer.
  81.  * 2. Redistributions in binary form must reproduce the above copyright
  82.  *    notice, this list of conditions and the following disclaimer in the
  83.  *    documentation and/or other materials provided with the distribution.
  84.  * 3. All advertising materials mentioning features or use of this software
  85.  *    must display the following acknowledgement:
  86.  *    "This product includes cryptographic software written by
  87.  *     Eric Young (eay@cryptsoft.com)"
  88.  *    The word 'cryptographic' can be left out if the rouines from the library
  89.  *    being used are not cryptographic related :-).
  90.  * 4. If you include any Windows specific code (or a derivative thereof) from 
  91.  *    the apps directory (application code) you must include an acknowledgement:
  92.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  93.  * 
  94.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  95.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  96.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  97.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  98.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  99.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  100.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  101.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  102.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  103.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  104.  * SUCH DAMAGE.
  105.  * 
  106.  * The licence and distribution terms for any publically available version or
  107.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  108.  * copied and put under another distribution licence
  109.  * [including the GNU Public Licence.]
  110.  */
  111. /* ====================================================================
  112.  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  113.  * ECDH support in OpenSSL originally developed by 
  114.  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  115.  */
  117. #include "cryptlib.h"
  118. #include <openssl/safestack.h>
  120. #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
  121. static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
  122. #endif
  124. DECLARE_STACK_OF(CRYPTO_dynlock)
  125. IMPLEMENT_STACK_OF(CRYPTO_dynlock)
  127. /* real #defines in crypto.h, keep these upto date */
  128. static const char* lock_names[CRYPTO_NUM_LOCKS] =
  129. {
  130. "<<ERROR>>",
  131. "err",
  132. "ex_data",
  133. "x509",
  134. "x509_info",
  135. "x509_pkey",
  136. "x509_crl",
  137. "x509_req",
  138. "dsa",
  139. "rsa",
  140. "evp_pkey",
  141. "x509_store",
  142. "ssl_ctx",
  143. "ssl_cert",
  144. "ssl_session",
  145. "ssl_sess_cert",
  146. "ssl",
  147. "ssl_method",
  148. "rand",
  149. "rand2",
  150. "debug_malloc",
  151. "BIO",
  152. "gethostbyname",
  153. "getservbyname",
  154. "readdir",
  155. "RSA_blinding",
  156. "dh",
  157. "debug_malloc2",
  158. "dso",
  159. "dynlock",
  160. "engine",
  161. "ui",
  162. "ecdsa",
  163. "ec",
  164. "ecdh",
  165. "bn",
  166. "ec_pre_comp",
  167. "store",
  168. "comp",
  169. #if CRYPTO_NUM_LOCKS != 39
  170. # error "Inconsistency between crypto.h and cryptlib.c"
  171. #endif
  172. };
  174. /* This is for applications to allocate new type names in the non-dynamic
  175.    array of lock names.  These are numbered with positive numbers.  */
  176. static STACK *app_locks=NULL;
  178. /* For applications that want a more dynamic way of handling threads, the
  179.    following stack is used.  These are externally numbered with negative
  180.    numbers.  */
  181. static STACK_OF(CRYPTO_dynlock) *dyn_locks=NULL;
  184. static void (MS_FAR *locking_callback)(int mode,int type,
  185. const char *file,int line)=NULL;
  186. static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
  187. int type,const char *file,int line)=NULL;
  188. static unsigned long (MS_FAR *id_callback)(void)=NULL;
  189. static struct CRYPTO_dynlock_value *(MS_FAR *dynlock_create_callback)
  190. (const char *file,int line)=NULL;
  191. static void (MS_FAR *dynlock_lock_callback)(int mode,
  192. struct CRYPTO_dynlock_value *l, const char *file,int line)=NULL;
  193. static void (MS_FAR *dynlock_destroy_callback)(struct CRYPTO_dynlock_value *l,
  194. const char *file,int line)=NULL;
  196. int CRYPTO_get_new_lockid(char *name)
  197. {
  198. char *str;
  199. int i;
  201. #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
  202. /* A hack to make Visual C++ 5.0 work correctly when linking as
  203.  * a DLL using /MT. Without this, the application cannot use
  204.  * and floating point printf's.
  205.  * It also seems to be needed for Visual C 1.5 (win16) */
  206. SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
  207. #endif
  209. if ((app_locks == NULL) && ((app_locks=sk_new_null()) == NULL))
  210. {
  211. CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
  212. return(0);
  213. }
  214. if ((str=BUF_strdup(name)) == NULL)
  215. {
  216. CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
  217. return(0);
  218. }
  219. i=sk_push(app_locks,str);
  220. if (!i)
  221. OPENSSL_free(str);
  222. else
  223. i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
  224. return(i);
  225. }
  227. int CRYPTO_num_locks(void)
  228. {
  229. return CRYPTO_NUM_LOCKS;
  230. }
  232. int CRYPTO_get_new_dynlockid(void)
  233. {
  234. int i = 0;
  235. CRYPTO_dynlock *pointer = NULL;
  237. if (dynlock_create_callback == NULL)
  238. {
  239. CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
  240. return(0);
  241. }
  242. CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
  243. if ((dyn_locks == NULL)
  244. && ((dyn_locks=sk_CRYPTO_dynlock_new_null()) == NULL))
  245. {
  246. CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
  247. CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
  248. return(0);
  249. }
  250. CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
  252. pointer = (CRYPTO_dynlock *)OPENSSL_malloc(sizeof(CRYPTO_dynlock));
  253. if (pointer == NULL)
  254. {
  255. CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
  256. return(0);
  257. }
  258. pointer->references = 1;
  259. pointer->data = dynlock_create_callback(__FILE__,__LINE__);
  260. if (pointer->data == NULL)
  261. {
  262. OPENSSL_free(pointer);
  263. CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
  264. return(0);
  265. }
  267. CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
  268. /* First, try to find an existing empty slot */
  269. i=sk_CRYPTO_dynlock_find(dyn_locks,NULL);
  270. /* If there was none, push, thereby creating a new one */
  271. if (i == -1)
  272. /* Since sk_push() returns the number of items on the
  273.    stack, not the location of the pushed item, we need
  274.    to transform the returned number into a position,
  275.    by decreasing it.  */
  276. i=sk_CRYPTO_dynlock_push(dyn_locks,pointer) - 1;
  277. else
  278. /* If we found a place with a NULL pointer, put our pointer
  279.    in it.  */
  280. sk_CRYPTO_dynlock_set(dyn_locks,i,pointer);
  281. CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
  283. if (i == -1)
  284. {
  285. dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
  286. OPENSSL_free(pointer);
  287. }
  288. else
  289. i += 1; /* to avoid 0 */
  290. return -i;
  291. }
  293. void CRYPTO_destroy_dynlockid(int i)
  294. {
  295. CRYPTO_dynlock *pointer = NULL;
  296. if (i)
  297. i = -i-1;
  298. if (dynlock_destroy_callback == NULL)
  299. return;
  301. CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
  303. if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
  304. {
  305. CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
  306. return;
  307. }
  308. pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
  309. if (pointer != NULL)
  310. {
  311. --pointer->references;
  312. #ifdef REF_CHECK
  313. if (pointer->references < 0)
  314. {
  315. fprintf(stderr,"CRYPTO_destroy_dynlockid, bad reference countn");
  316. abort();
  317. }
  318. else
  319. #endif
  320. if (pointer->references <= 0)
  321. {
  322. sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
  323. }
  324. else
  325. pointer = NULL;
  326. }
  327. CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
  329. if (pointer)
  330. {
  331. dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
  332. OPENSSL_free(pointer);
  333. }
  334. }
  336. struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i)
  337. {
  338. CRYPTO_dynlock *pointer = NULL;
  339. if (i)
  340. i = -i-1;
  342. CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
  344. if (dyn_locks != NULL && i < sk_CRYPTO_dynlock_num(dyn_locks))
  345. pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
  346. if (pointer)
  347. pointer->references++;
  349. CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
  351. if (pointer)
  352. return pointer->data;
  353. return NULL;
  354. }
  356. struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))
  357. (const char *file,int line)
  358. {
  359. return(dynlock_create_callback);
  360. }
  362. void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,
  363. struct CRYPTO_dynlock_value *l, const char *file,int line)
  364. {
  365. return(dynlock_lock_callback);
  366. }
  368. void (*CRYPTO_get_dynlock_destroy_callback(void))
  369. (struct CRYPTO_dynlock_value *l, const char *file,int line)
  370. {
  371. return(dynlock_destroy_callback);
  372. }
  374. void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
  375. (const char *file, int line))
  376. {
  377. dynlock_create_callback=func;
  378. }
  380. void CRYPTO_set_dynlock_lock_callback(void (*func)(int mode,
  381. struct CRYPTO_dynlock_value *l, const char *file, int line))
  382. {
  383. dynlock_lock_callback=func;
  384. }
  386. void CRYPTO_set_dynlock_destroy_callback(void (*func)
  387. (struct CRYPTO_dynlock_value *l, const char *file, int line))
  388. {
  389. dynlock_destroy_callback=func;
  390. }
  393. void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
  394. int line)
  395. {
  396. return(locking_callback);
  397. }
  399. int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
  400.   const char *file,int line)
  401. {
  402. return(add_lock_callback);
  403. }
  405. void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
  406.       const char *file,int line))
  407. {
  408. locking_callback=func;
  409. }
  411. void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
  412.       const char *file,int line))
  413. {
  414. add_lock_callback=func;
  415. }
  417. unsigned long (*CRYPTO_get_id_callback(void))(void)
  418. {
  419. return(id_callback);
  420. }
  422. void CRYPTO_set_id_callback(unsigned long (*func)(void))
  423. {
  424. id_callback=func;
  425. }
  427. unsigned long CRYPTO_thread_id(void)
  428. {
  429. unsigned long ret=0;
  431. if (id_callback == NULL)
  432. {
  433. #ifdef OPENSSL_SYS_WIN16
  434. ret=(unsigned long)GetCurrentTask();
  435. #elif defined(OPENSSL_SYS_WIN32)
  436. ret=(unsigned long)GetCurrentThreadId();
  437. #elif defined(GETPID_IS_MEANINGLESS)
  438. ret=1L;
  439. #else
  440. ret=(unsigned long)getpid();
  441. #endif
  442. }
  443. else
  444. ret=id_callback();
  445. return(ret);
  446. }
  448. void CRYPTO_lock(int mode, int type, const char *file, int line)
  449. {
  450. #ifdef LOCK_DEBUG
  451. {
  452. char *rw_text,*operation_text;
  454. if (mode & CRYPTO_LOCK)
  455. operation_text="lock  ";
  456. else if (mode & CRYPTO_UNLOCK)
  457. operation_text="unlock";
  458. else
  459. operation_text="ERROR ";
  461. if (mode & CRYPTO_READ)
  462. rw_text="r";
  463. else if (mode & CRYPTO_WRITE)
  464. rw_text="w";
  465. else
  466. rw_text="ERROR";
  468. fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%dn",
  469. CRYPTO_thread_id(), rw_text, operation_text,
  470. CRYPTO_get_lock_name(type), file, line);
  471. }
  472. #endif
  473. if (type < 0)
  474. {
  475. if (dynlock_lock_callback != NULL)
  476. {
  477. struct CRYPTO_dynlock_value *pointer
  478. = CRYPTO_get_dynlock_value(type);
  480. OPENSSL_assert(pointer != NULL);
  482. dynlock_lock_callback(mode, pointer, file, line);
  484. CRYPTO_destroy_dynlockid(type);
  485. }
  486. }
  487. else
  488. if (locking_callback != NULL)
  489. locking_callback(mode,type,file,line);
  490. }
  492. int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
  493.      int line)
  494. {
  495. int ret = 0;
  497. if (add_lock_callback != NULL)
  498. {
  499. #ifdef LOCK_DEBUG
  500. int before= *pointer;
  501. #endif
  503. ret=add_lock_callback(pointer,amount,type,file,line);
  504. #ifdef LOCK_DEBUG
  505. fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%dn",
  506. CRYPTO_thread_id(),
  507. before,amount,ret,
  508. CRYPTO_get_lock_name(type),
  509. file,line);
  510. #endif
  511. }
  512. else
  513. {
  514. CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
  516. ret= *pointer+amount;
  517. #ifdef LOCK_DEBUG
  518. fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%dn",
  519. CRYPTO_thread_id(),
  520. *pointer,amount,ret,
  521. CRYPTO_get_lock_name(type),
  522. file,line);
  523. #endif
  524. *pointer=ret;
  525. CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
  526. }
  527. return(ret);
  528. }
  530. const char *CRYPTO_get_lock_name(int type)
  531. {
  532. if (type < 0)
  533. return("dynamic");
  534. else if (type < CRYPTO_NUM_LOCKS)
  535. return(lock_names[type]);
  536. else if (type-CRYPTO_NUM_LOCKS > sk_num(app_locks))
  537. return("ERROR");
  538. else
  539. return(sk_value(app_locks,type-CRYPTO_NUM_LOCKS));
  540. }
  542. #if defined(__i386)   || defined(__i386__)   || defined(_M_IX86) || 
  543. defined(__INTEL__) || 
  544. defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64)
  546. unsigned long  OPENSSL_ia32cap_P=0;
  547. unsigned long *OPENSSL_ia32cap_loc(void) { return &OPENSSL_ia32cap_P; }
  549. #if defined(OPENSSL_CPUID_OBJ) && !defined(OPENSSL_NO_ASM) && !defined(I386_ONLY)
  550. #define OPENSSL_CPUID_SETUP
  551. void OPENSSL_cpuid_setup(void)
  552. { static int trigger=0;
  553.   unsigned long OPENSSL_ia32_cpuid(void);
  554.   char *env;
  556.     if (trigger) return;
  558.     trigger=1;
  559.     if ((env=getenv("OPENSSL_ia32cap")))
  560. OPENSSL_ia32cap_P = strtoul(env,NULL,0)|(1<<10);
  561.     else
  562. OPENSSL_ia32cap_P = OPENSSL_ia32_cpuid()|(1<<10);
  563.     /*
  564.      * |(1<<10) sets a reserved bit to signal that variable
  565.      * was initialized already... This is to avoid interference
  566.      * with cpuid snippets in ELF .init segment.
  567.      */
  568. }
  569. #endif
  571. #else
  572. unsigned long *OPENSSL_ia32cap_loc(void) { return NULL; }
  573. #endif
  574. int OPENSSL_NONPIC_relocated = 0;
  575. #if !defined(OPENSSL_CPUID_SETUP)
  576. void OPENSSL_cpuid_setup(void) {}
  577. #endif
  579. #if (defined(_WIN32) || defined(__CYGWIN__)) && defined(_WINDLL)
  580. #ifdef __CYGWIN__
  581. /* pick DLL_[PROCESS|THREAD]_[ATTACH|DETACH] definitions */
  582. #include <windows.h>
  583. #endif
  585. /* All we really need to do is remove the 'error' state when a thread
  586.  * detaches */
  588. BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason,
  589.      LPVOID lpvReserved)
  590. {
  591. switch(fdwReason)
  592. {
  593. case DLL_PROCESS_ATTACH:
  594. OPENSSL_cpuid_setup();
  595. #if defined(_WIN32_WINNT)
  596. {
  597. IMAGE_DOS_HEADER *dos_header = (IMAGE_DOS_HEADER *)hinstDLL;
  598. IMAGE_NT_HEADERS *nt_headers;
  600. if (dos_header->e_magic==IMAGE_DOS_SIGNATURE)
  601. {
  602. nt_headers = (IMAGE_NT_HEADERS *)((char *)dos_header
  603. + dos_header->e_lfanew);
  604. if (nt_headers->Signature==IMAGE_NT_SIGNATURE &&
  605.     hinstDLL!=(HINSTANCE)(nt_headers->OptionalHeader.ImageBase))
  606. OPENSSL_NONPIC_relocated=1;
  607. }
  608. }
  609. #endif
  610. break;
  611. case DLL_THREAD_ATTACH:
  612. break;
  613. case DLL_THREAD_DETACH:
  614. ERR_remove_state(0);
  615. break;
  616. case DLL_PROCESS_DETACH:
  617. break;
  618. }
  619. return(TRUE);
  620. }
  621. #endif
  623. #if defined(_WIN32) && !defined(__CYGWIN__)
  624. #include <tchar.h>
  626. #if defined(_WIN32_WINNT) && _WIN32_WINNT>=0x0333
  627. int OPENSSL_isservice(void)
  628. { HWINSTA h;
  629.   DWORD len;
  630.   WCHAR *name;
  632.     (void)GetDesktopWindow(); /* return value is ignored */
  634.     h = GetProcessWindowStation();
  635.     if (h==NULL) return -1;
  637.     if (GetUserObjectInformationW (h,UOI_NAME,NULL,0,&len) ||
  638. GetLastError() != ERROR_INSUFFICIENT_BUFFER)
  639. return -1;
  641.     if (len>512) return -1; /* paranoia */
  642.     len++,len&=~1; /* paranoia */
  643. #ifdef _MSC_VER
  644.     name=(WCHAR *)_alloca(len+sizeof(WCHAR));
  645. #else
  646.     name=(WCHAR *)alloca(len+sizeof(WCHAR));
  647. #endif
  648.     if (!GetUserObjectInformationW (h,UOI_NAME,name,len,&len))
  649. return -1;
  651.     len++,len&=~1; /* paranoia */
  652.     name[len/sizeof(WCHAR)]=L''; /* paranoia */
  653. #if 1
  654.     /* This doesn't cover "interactive" services [working with real
  655.      * WinSta0's] nor programs started non-interactively by Task
  656.      * Scheduler [those are working with SAWinSta]. */
  657.     if (wcsstr(name,L"Service-0x")) return 1;
  658. #else
  659.     /* This covers all non-interactive programs such as services. */
  660.     if (!wcsstr(name,L"WinSta0")) return 1;
  661. #endif
  662.     else return 0;
  663. }
  664. #else
  665. int OPENSSL_isservice(void) { return 0; }
  666. #endif
  668. void OPENSSL_showfatal (const char *fmta,...)
  669. { va_list ap;
  670.   TCHAR buf[256];
  671.   const TCHAR *fmt;
  672. #ifdef STD_ERROR_HANDLE /* what a dirty trick! */
  673.   HANDLE h;
  675.     if ((h=GetStdHandle(STD_ERROR_HANDLE)) != NULL &&
  676. GetFileType(h)!=FILE_TYPE_UNKNOWN)
  677.     { /* must be console application */
  678. va_start (ap,fmta);
  679. vfprintf (stderr,fmta,ap);
  680. va_end (ap);
  681. return;
  682.     }
  683. #endif
  685.     if (sizeof(TCHAR)==sizeof(char))
  686. fmt=(const TCHAR *)fmta;
  687.     else do
  688.     { int    keepgoing;
  689.       size_t len_0=strlen(fmta)+1,i;
  690.       WCHAR *fmtw;
  692. #ifdef _MSC_VER
  693. fmtw = (WCHAR *)_alloca (len_0*sizeof(WCHAR));
  694. #else
  695. fmtw = (WCHAR *)alloca (len_0*sizeof(WCHAR));
  696. #endif
  697. if (fmtw == NULL) { fmt=(const TCHAR *)L"no stack?"; break; }
  699. #ifndef OPENSSL_NO_MULTIBYTE
  700. if (!MultiByteToWideChar(CP_ACP,0,fmta,len_0,fmtw,len_0))
  701. #endif
  702.     for (i=0;i<len_0;i++) fmtw[i]=(WCHAR)fmta[i];
  704. for (i=0;i<len_0;i++)
  705. {   if (fmtw[i]==L'%') do
  706.     { keepgoing=0;
  707. switch (fmtw[i+1])
  708. {   case L'0': case L'1': case L'2': case L'3': case L'4':
  709.     case L'5': case L'6': case L'7': case L'8': case L'9':
  710.     case L'.': case L'*':
  711.     case L'-': i++; keepgoing=1; break;
  712.     case L's': fmtw[i+1]=L'S';   break;
  713.     case L'S': fmtw[i+1]=L's';   break;
  714.     case L'c': fmtw[i+1]=L'C';   break;
  715.     case L'C': fmtw[i+1]=L'c';   break;
  716. }
  717.     } while (keepgoing);
  718. }
  719. fmt = (const TCHAR *)fmtw;
  720.     } while (0);
  722.     va_start (ap,fmta);
  723.     _vsntprintf (buf,sizeof(buf)/sizeof(TCHAR)-1,fmt,ap);
  724.     buf [sizeof(buf)/sizeof(TCHAR)-1] = _T('');
  725.     va_end (ap);
  727. #if defined(_WIN32_WINNT) && _WIN32_WINNT>=0x0333
  728.     /* this -------------v--- guards NT-specific calls */
  729.     if (GetVersion() < 0x80000000 && OPENSSL_isservice())
  730.     { HANDLE h = RegisterEventSource(0,_T("OPENSSL"));
  731. const TCHAR *pmsg=buf;
  732. ReportEvent(h,EVENTLOG_ERROR_TYPE,0,0,0,1,0,&pmsg,0);
  733. DeregisterEventSource(h);
  734.     }
  735.     else
  736. #endif
  737. MessageBox (NULL,buf,_T("OpenSSL: FATAL"),MB_OK|MB_ICONSTOP);
  738. }
  739. #else
  740. void OPENSSL_showfatal (const char *fmta,...)
  741. { va_list ap;
  743.     va_start (ap,fmta);
  744.     vfprintf (stderr,fmta,ap);
  745.     va_end (ap);
  746. }
  747. int OPENSSL_isservice (void) { return 0; }
  748. #endif
  750. void OpenSSLDie(const char *file,int line,const char *assertion)
  751. {
  752. OPENSSL_showfatal(
  753. "%s(%d): OpenSSL internal error, assertion failed: %sn",
  754. file,line,assertion);
  755. abort();
  756. }
  758. void *OPENSSL_stderr(void) { return stderr; }