1 /* crypto/cryptlib.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
59 #include <stdio.h>
60 #include <string.h>
61 #include "cryptlib.h"
62 #include <openssl/crypto.h>
63 #include <openssl/safestack.h>
64
65 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
66 static double SSLeay_MSVC5_hack=0.0; /* and for VC1.5 */
67 #endif
68
69 DECLARE_STACK_OF(CRYPTO_dynlock)
70 IMPLEMENT_STACK_OF(CRYPTO_dynlock)
71
72 /* real #defines in crypto.h, keep these upto date */
73 static const char* const lock_names[CRYPTO_NUM_LOCKS] =
74 {
75 "<<ERROR>>",
76 "err",
77 "ex_data",
78 "x509",
79 "x509_info",
80 "x509_pkey",
81 "x509_crl",
82 "x509_req",
83 "dsa",
84 "rsa",
85 "evp_pkey",
86 "x509_store",
87 "ssl_ctx",
88 "ssl_cert",
89 "ssl_session",
90 "ssl_sess_cert",
91 "ssl",
92 "ssl_method",
93 "rand",
94 "rand2",
95 "debug_malloc",
96 "BIO",
97 "gethostbyname",
98 "getservbyname",
99 "readdir",
100 "RSA_blinding",
101 "dh",
102 "debug_malloc2",
103 "dso",
104 "dynlock",
105 "engine",
106 "ui",
107 "hwcrhk", /* This is a HACK which will disappear in 0.9.8 */
108 "fips",
109 "fips2",
110 #if CRYPTO_NUM_LOCKS != 35
111 # error "Inconsistency between crypto.h and cryptlib.c"
112 #endif
113 };
114
115 /* This is for applications to allocate new type names in the non-dynamic
116 array of lock names. These are numbered with positive numbers. */
117 static STACK *app_locks=NULL;
118
119 /* For applications that want a more dynamic way of handling threads, the
120 following stack is used. These are externally numbered with negative
121 numbers. */
122 static STACK_OF(CRYPTO_dynlock) *dyn_locks=NULL;
123
124
125 static void (MS_FAR *locking_callback)(int mode,int type,
126 const char *file,int line)=NULL;
127 static int (MS_FAR *add_lock_callback)(int *pointer,int amount,
128 int type,const char *file,int line)=NULL;
129 static unsigned long (MS_FAR *id_callback)(void)=NULL;
130 static struct CRYPTO_dynlock_value *(MS_FAR *dynlock_create_callback)
131 (const char *file,int line)=NULL;
132 static void (MS_FAR *dynlock_lock_callback)(int mode,
133 struct CRYPTO_dynlock_value *l, const char *file,int line)=NULL;
134 static void (MS_FAR *dynlock_destroy_callback)(struct CRYPTO_dynlock_value *l,
135 const char *file,int line)=NULL;
136
CRYPTO_get_new_lockid(char * name)137 int CRYPTO_get_new_lockid(char *name)
138 {
139 char *str;
140 int i;
141
142 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
143 /* A hack to make Visual C++ 5.0 work correctly when linking as
144 * a DLL using /MT. Without this, the application cannot use
145 * and floating point printf's.
146 * It also seems to be needed for Visual C 1.5 (win16) */
147 SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
148 #endif
149
150 if ((app_locks == NULL) && ((app_locks=sk_new_null()) == NULL))
151 {
152 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
153 return(0);
154 }
155 if ((str=BUF_strdup(name)) == NULL)
156 {
157 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
158 return(0);
159 }
160 i=sk_push(app_locks,str);
161 if (!i)
162 OPENSSL_free(str);
163 else
164 i+=CRYPTO_NUM_LOCKS; /* gap of one :-) */
165 return(i);
166 }
167
CRYPTO_num_locks(void)168 int CRYPTO_num_locks(void)
169 {
170 return CRYPTO_NUM_LOCKS;
171 }
172
CRYPTO_get_new_dynlockid(void)173 int CRYPTO_get_new_dynlockid(void)
174 {
175 int i = 0;
176 CRYPTO_dynlock *pointer = NULL;
177
178 if (dynlock_create_callback == NULL)
179 {
180 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
181 return(0);
182 }
183 CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
184 if ((dyn_locks == NULL)
185 && ((dyn_locks=sk_CRYPTO_dynlock_new_null()) == NULL))
186 {
187 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
188 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
189 return(0);
190 }
191 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
192
193 pointer = (CRYPTO_dynlock *)OPENSSL_malloc(sizeof(CRYPTO_dynlock));
194 if (pointer == NULL)
195 {
196 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
197 return(0);
198 }
199 pointer->references = 1;
200 pointer->data = dynlock_create_callback(__FILE__,__LINE__);
201 if (pointer->data == NULL)
202 {
203 OPENSSL_free(pointer);
204 CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,ERR_R_MALLOC_FAILURE);
205 return(0);
206 }
207
208 CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
209 /* First, try to find an existing empty slot */
210 i=sk_CRYPTO_dynlock_find(dyn_locks,NULL);
211 /* If there was none, push, thereby creating a new one */
212 if (i == -1)
213 /* Since sk_push() returns the number of items on the
214 stack, not the location of the pushed item, we need
215 to transform the returned number into a position,
216 by decreasing it. */
217 i=sk_CRYPTO_dynlock_push(dyn_locks,pointer) - 1;
218 else
219 /* If we found a place with a NULL pointer, put our pointer
220 in it. */
221 sk_CRYPTO_dynlock_set(dyn_locks,i,pointer);
222 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
223
224 if (i == -1)
225 {
226 dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
227 OPENSSL_free(pointer);
228 }
229 else
230 i += 1; /* to avoid 0 */
231 return -i;
232 }
233
CRYPTO_destroy_dynlockid(int i)234 void CRYPTO_destroy_dynlockid(int i)
235 {
236 CRYPTO_dynlock *pointer = NULL;
237 if (i)
238 i = -i-1;
239 if (dynlock_destroy_callback == NULL)
240 return;
241
242 CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
243
244 if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks))
245 {
246 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
247 return;
248 }
249 pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
250 if (pointer != NULL)
251 {
252 --pointer->references;
253 #ifdef REF_CHECK
254 if (pointer->references < 0)
255 {
256 fprintf(stderr,"CRYPTO_destroy_dynlockid, bad reference count\n");
257 abort();
258 }
259 else
260 #endif
261 if (pointer->references <= 0)
262 {
263 sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
264 }
265 else
266 pointer = NULL;
267 }
268 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
269
270 if (pointer)
271 {
272 dynlock_destroy_callback(pointer->data,__FILE__,__LINE__);
273 OPENSSL_free(pointer);
274 }
275 }
276
CRYPTO_get_dynlock_value(int i)277 struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i)
278 {
279 CRYPTO_dynlock *pointer = NULL;
280 if (i)
281 i = -i-1;
282
283 CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
284
285 if (dyn_locks != NULL && i < sk_CRYPTO_dynlock_num(dyn_locks))
286 pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
287 if (pointer)
288 pointer->references++;
289
290 CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
291
292 if (pointer)
293 return pointer->data;
294 return NULL;
295 }
296
CRYPTO_get_dynlock_create_callback(void)297 struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))
298 (const char *file,int line)
299 {
300 return(dynlock_create_callback);
301 }
302
CRYPTO_get_dynlock_lock_callback(void)303 void (*CRYPTO_get_dynlock_lock_callback(void))(int mode,
304 struct CRYPTO_dynlock_value *l, const char *file,int line)
305 {
306 return(dynlock_lock_callback);
307 }
308
CRYPTO_get_dynlock_destroy_callback(void)309 void (*CRYPTO_get_dynlock_destroy_callback(void))
310 (struct CRYPTO_dynlock_value *l, const char *file,int line)
311 {
312 return(dynlock_destroy_callback);
313 }
314
CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value * (* func)(const char * file,int line))315 void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
316 (const char *file, int line))
317 {
318 dynlock_create_callback=func;
319 }
320
CRYPTO_set_dynlock_lock_callback(void (* func)(int mode,struct CRYPTO_dynlock_value * l,const char * file,int line))321 void CRYPTO_set_dynlock_lock_callback(void (*func)(int mode,
322 struct CRYPTO_dynlock_value *l, const char *file, int line))
323 {
324 dynlock_lock_callback=func;
325 }
326
CRYPTO_set_dynlock_destroy_callback(void (* func)(struct CRYPTO_dynlock_value * l,const char * file,int line))327 void CRYPTO_set_dynlock_destroy_callback(void (*func)
328 (struct CRYPTO_dynlock_value *l, const char *file, int line))
329 {
330 dynlock_destroy_callback=func;
331 }
332
333
CRYPTO_get_locking_callback(void)334 void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
335 int line)
336 {
337 return(locking_callback);
338 }
339
CRYPTO_get_add_lock_callback(void)340 int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
341 const char *file,int line)
342 {
343 return(add_lock_callback);
344 }
345
CRYPTO_set_locking_callback(void (* func)(int mode,int type,const char * file,int line))346 void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
347 const char *file,int line))
348 {
349 locking_callback=func;
350 }
351
CRYPTO_set_add_lock_callback(int (* func)(int * num,int mount,int type,const char * file,int line))352 void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
353 const char *file,int line))
354 {
355 add_lock_callback=func;
356 }
357
CRYPTO_get_id_callback(void)358 unsigned long (*CRYPTO_get_id_callback(void))(void)
359 {
360 return(id_callback);
361 }
362
CRYPTO_set_id_callback(unsigned long (* func)(void))363 void CRYPTO_set_id_callback(unsigned long (*func)(void))
364 {
365 id_callback=func;
366 }
367
CRYPTO_thread_id(void)368 unsigned long CRYPTO_thread_id(void)
369 {
370 unsigned long ret=0;
371
372 if (id_callback == NULL)
373 {
374 #ifdef OPENSSL_SYS_WIN16
375 ret=(unsigned long)GetCurrentTask();
376 #elif defined(OPENSSL_SYS_WIN32)
377 ret=(unsigned long)GetCurrentThreadId();
378 #elif defined(GETPID_IS_MEANINGLESS)
379 ret=1L;
380 #else
381 ret=(unsigned long)getpid();
382 #endif
383 }
384 else
385 ret=id_callback();
386 return(ret);
387 }
388
CRYPTO_lock(int mode,int type,const char * file,int line)389 void CRYPTO_lock(int mode, int type, const char *file, int line)
390 {
391 #ifdef LOCK_DEBUG
392 {
393 char *rw_text,*operation_text;
394
395 if (mode & CRYPTO_LOCK)
396 operation_text="lock ";
397 else if (mode & CRYPTO_UNLOCK)
398 operation_text="unlock";
399 else
400 operation_text="ERROR ";
401
402 if (mode & CRYPTO_READ)
403 rw_text="r";
404 else if (mode & CRYPTO_WRITE)
405 rw_text="w";
406 else
407 rw_text="ERROR";
408
409 fprintf(stderr,"lock:%08lx:(%s)%s %-18s %s:%d\n",
410 CRYPTO_thread_id(), rw_text, operation_text,
411 CRYPTO_get_lock_name(type), file, line);
412 }
413 #endif
414 if (type < 0)
415 {
416 if (dynlock_lock_callback != NULL)
417 {
418 struct CRYPTO_dynlock_value *pointer
419 = CRYPTO_get_dynlock_value(type);
420
421 OPENSSL_assert(pointer != NULL);
422
423 dynlock_lock_callback(mode, pointer, file, line);
424
425 CRYPTO_destroy_dynlockid(type);
426 }
427 }
428 else
429 if (locking_callback != NULL)
430 locking_callback(mode,type,file,line);
431 }
432
CRYPTO_add_lock(int * pointer,int amount,int type,const char * file,int line)433 int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
434 int line)
435 {
436 int ret = 0;
437
438 if (add_lock_callback != NULL)
439 {
440 #ifdef LOCK_DEBUG
441 int before= *pointer;
442 #endif
443
444 ret=add_lock_callback(pointer,amount,type,file,line);
445 #ifdef LOCK_DEBUG
446 fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
447 CRYPTO_thread_id(),
448 before,amount,ret,
449 CRYPTO_get_lock_name(type),
450 file,line);
451 #endif
452 }
453 else
454 {
455 CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,file,line);
456
457 ret= *pointer+amount;
458 #ifdef LOCK_DEBUG
459 fprintf(stderr,"ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\n",
460 CRYPTO_thread_id(),
461 *pointer,amount,ret,
462 CRYPTO_get_lock_name(type),
463 file,line);
464 #endif
465 *pointer=ret;
466 CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,file,line);
467 }
468 return(ret);
469 }
470
CRYPTO_get_lock_name(int type)471 const char *CRYPTO_get_lock_name(int type)
472 {
473 if (type < 0)
474 return("dynamic");
475 else if (type < CRYPTO_NUM_LOCKS)
476 return(lock_names[type]);
477 else if (type-CRYPTO_NUM_LOCKS > sk_num(app_locks))
478 return("ERROR");
479 else
480 return(sk_value(app_locks,type-CRYPTO_NUM_LOCKS));
481 }
482
483 int OPENSSL_NONPIC_relocated=0;
484
485 #if defined(_WIN32) && defined(_WINDLL)
486
487 /* All we really need to do is remove the 'error' state when a thread
488 * detaches */
489
DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved)490 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason,
491 LPVOID lpvReserved)
492 {
493 switch(fdwReason)
494 {
495 case DLL_PROCESS_ATTACH:
496 #if defined(_WIN32_WINNT)
497 {
498 IMAGE_DOS_HEADER *dos_header = (IMAGE_DOS_HEADER *)hinstDLL;
499 IMAGE_NT_HEADERS *nt_headers;
500
501 if (dos_header->e_magic==IMAGE_DOS_SIGNATURE)
502 {
503 nt_headers = (IMAGE_NT_HEADERS *)((char *)dos_header
504 + dos_header->e_lfanew);
505 if (nt_headers->Signature==IMAGE_NT_SIGNATURE &&
506 hinstDLL!=(HINSTANCE)(nt_headers->OptionalHeader.ImageBase))
507 OPENSSL_NONPIC_relocated=1;
508 }
509 }
510 #endif
511 break;
512 case DLL_THREAD_ATTACH:
513 break;
514 case DLL_THREAD_DETACH:
515 ERR_remove_state(0);
516 break;
517 case DLL_PROCESS_DETACH:
518 break;
519 }
520 return(TRUE);
521 }
522 #endif
523
524 #if defined(_WIN32)
525 #include <tchar.h>
526
527 #if defined(_WIN32_WINNT) && _WIN32_WINNT>=0x0333
IsService(void)528 static int IsService(void)
529 { HWINSTA h;
530 DWORD len;
531 WCHAR *name;
532
533 (void)GetDesktopWindow(); /* return value is ignored */
534
535 h = GetProcessWindowStation();
536 if (h==NULL) return -1;
537
538 if (GetUserObjectInformationW (h,UOI_NAME,NULL,0,&len) ||
539 GetLastError() != ERROR_INSUFFICIENT_BUFFER)
540 return -1;
541
542 if (len>512) return -1; /* paranoia */
543 len++,len&=~1; /* paranoia */
544 #ifdef _MSC_VER
545 name=(WCHAR *)_alloca(len+sizeof(WCHAR));
546 #else
547 name=(WCHAR *)alloca(len+sizeof(WCHAR));
548 #endif
549 if (!GetUserObjectInformationW (h,UOI_NAME,name,len,&len))
550 return -1;
551
552 len++,len&=~1; /* paranoia */
553 name[len/sizeof(WCHAR)]=L'\0'; /* paranoia */
554 #if 1
555 /* This doesn't cover "interactive" services [working with real
556 * WinSta0's] nor programs started non-interactively by Task
557 * Scheduler [those are working with SAWinSta]. */
558 if (wcsstr(name,L"Service-0x")) return 1;
559 #else
560 /* This covers all non-interactive programs such as services. */
561 if (!wcsstr(name,L"WinSta0")) return 1;
562 #endif
563 else return 0;
564 }
565 #endif
566
OPENSSL_showfatal(const char * fmta,...)567 void OPENSSL_showfatal (const char *fmta,...)
568 { va_list ap;
569 TCHAR buf[256];
570 const TCHAR *fmt;
571 HANDLE h;
572
573 if ((h=GetStdHandle(STD_ERROR_HANDLE)) != NULL &&
574 GetFileType(h)!=FILE_TYPE_UNKNOWN)
575 { /* must be console application */
576 va_start (ap,fmta);
577 vfprintf (stderr,fmta,ap);
578 va_end (ap);
579 return;
580 }
581
582 if (sizeof(TCHAR)==sizeof(char))
583 fmt=(const TCHAR *)fmta;
584 else do
585 { int keepgoing;
586 size_t len_0=strlen(fmta)+1,i;
587 WCHAR *fmtw;
588
589 #ifdef _MSC_VER
590 fmtw = (WCHAR *)_alloca (len_0*sizeof(WCHAR));
591 #else
592 fmtw = (WCHAR *)alloca (len_0*sizeof(WCHAR));
593 #endif
594 if (fmtw == NULL) { fmt=(const TCHAR *)L"no stack?"; break; }
595
596 #ifndef OPENSSL_NO_MULTIBYTE
597 if (!MultiByteToWideChar(CP_ACP,0,fmta,len_0,fmtw,len_0))
598 #endif
599 for (i=0;i<len_0;i++) fmtw[i]=(WCHAR)fmta[i];
600
601 for (i=0;i<len_0;i++)
602 { if (fmtw[i]==L'%') do
603 { keepgoing=0;
604 switch (fmtw[i+1])
605 { case L'0': case L'1': case L'2': case L'3': case L'4':
606 case L'5': case L'6': case L'7': case L'8': case L'9':
607 case L'.': case L'*':
608 case L'-': i++; keepgoing=1; break;
609 case L's': fmtw[i+1]=L'S'; break;
610 case L'S': fmtw[i+1]=L's'; break;
611 case L'c': fmtw[i+1]=L'C'; break;
612 case L'C': fmtw[i+1]=L'c'; break;
613 }
614 } while (keepgoing);
615 }
616 fmt = (const TCHAR *)fmtw;
617 } while (0);
618
619 va_start (ap,fmta);
620 _vsntprintf (buf,sizeof(buf)/sizeof(TCHAR)-1,fmt,ap);
621 buf [sizeof(buf)/sizeof(TCHAR)-1] = _T('\0');
622 va_end (ap);
623
624 #if defined(_WIN32_WINNT) && _WIN32_WINNT>=0x0333
625 /* this -------------v--- guards NT-specific calls */
626 if (GetVersion() < 0x80000000 && IsService())
627 { HANDLE h = RegisterEventSource(0,_T("OPENSSL"));
628 const TCHAR *pmsg=buf;
629 ReportEvent(h,EVENTLOG_ERROR_TYPE,0,0,0,1,0,&pmsg,0);
630 DeregisterEventSource(h);
631 }
632 else
633 #endif
634 { MSGBOXPARAMS m;
635
636 m.cbSize = sizeof(m);
637 m.hwndOwner = NULL;
638 m.lpszCaption = _T("OpenSSL: FATAL");
639 m.dwStyle = MB_OK;
640 m.hInstance = NULL;
641 m.lpszIcon = IDI_ERROR;
642 m.dwContextHelpId = 0;
643 m.lpfnMsgBoxCallback = NULL;
644 m.dwLanguageId = MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US);
645 m.lpszText = buf;
646
647 MessageBoxIndirect (&m);
648 }
649 }
650 #else
OPENSSL_showfatal(const char * fmta,...)651 void OPENSSL_showfatal (const char *fmta,...)
652 { va_list ap;
653
654 va_start (ap,fmta);
655 vfprintf (stderr,fmta,ap);
656 va_end (ap);
657 }
658 #endif
659
OpenSSLDie(const char * file,int line,const char * assertion)660 void OpenSSLDie(const char *file,int line,const char *assertion)
661 {
662 OPENSSL_showfatal(
663 "%s(%d): OpenSSL internal error, assertion failed: %s\n",
664 file,line,assertion);
665 abort();
666 }
667
OPENSSL_stderr(void)668 void *OPENSSL_stderr(void) { return stderr; }
669
670 #ifdef OPENSSL_FIPS
671
fips_w_lock(void)672 void fips_w_lock(void) { CRYPTO_w_lock(CRYPTO_LOCK_FIPS); }
fips_w_unlock(void)673 void fips_w_unlock(void) { CRYPTO_w_unlock(CRYPTO_LOCK_FIPS); }
fips_r_lock(void)674 void fips_r_lock(void) { CRYPTO_r_lock(CRYPTO_LOCK_FIPS); }
fips_r_unlock(void)675 void fips_r_unlock(void) { CRYPTO_r_unlock(CRYPTO_LOCK_FIPS); }
676
677 static int fips_started = 0;
678 static unsigned long fips_thread = 0;
679
fips_set_started(void)680 void fips_set_started(void)
681 {
682 fips_started = 1;
683 }
684
fips_is_started(void)685 int fips_is_started(void)
686 {
687 return fips_started;
688 }
689
fips_is_owning_thread(void)690 int fips_is_owning_thread(void)
691 {
692 int ret = 0;
693
694 if (fips_is_started())
695 {
696 CRYPTO_r_lock(CRYPTO_LOCK_FIPS2);
697 if (fips_thread != 0 && fips_thread == CRYPTO_thread_id())
698 ret = 1;
699 CRYPTO_r_unlock(CRYPTO_LOCK_FIPS2);
700 }
701 return ret;
702 }
703
fips_set_owning_thread(void)704 int fips_set_owning_thread(void)
705 {
706 int ret = 0;
707
708 if (fips_is_started())
709 {
710 CRYPTO_w_lock(CRYPTO_LOCK_FIPS2);
711 if (fips_thread == 0)
712 {
713 fips_thread = CRYPTO_thread_id();
714 ret = 1;
715 }
716 CRYPTO_w_unlock(CRYPTO_LOCK_FIPS2);
717 }
718 return ret;
719 }
720
fips_clear_owning_thread(void)721 int fips_clear_owning_thread(void)
722 {
723 int ret = 0;
724
725 if (fips_is_started())
726 {
727 CRYPTO_w_lock(CRYPTO_LOCK_FIPS2);
728 if (fips_thread == CRYPTO_thread_id())
729 {
730 fips_thread = 0;
731 ret = 1;
732 }
733 CRYPTO_w_unlock(CRYPTO_LOCK_FIPS2);
734 }
735 return ret;
736 }
737
fips_signature_witness(void)738 unsigned char *fips_signature_witness(void)
739 {
740 extern unsigned char FIPS_signature[];
741 return FIPS_signature;
742 }
743 #endif /* OPENSSL_FIPS */
744
745