2582N/A# This file adds the code to setup internal mutexes and callback function.
2582N/A# This change was implemented in-house. The issue was brought up to
2582N/A# the upstream engineers, but there was no commitment.
2582N/A #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
4006N/A static double SSLeay_MSVC5_hack = 0.0; /* and for VC1.5 */
4006N/A static STACK_OF(CRYPTO_dynlock) *dyn_locks = NULL;
2582N/A+static pthread_mutex_t *solaris_openssl_locks;
4006N/A static void (MS_FAR *locking_callback) (int mode, int type,
4006N/A const char *file, int line) = 0;
4006N/A static int (MS_FAR *add_lock_callback) (int *pointer, int amount,
4459N/A void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
4459N/A (const char *file, int line))
4459N/A- dynlock_create_callback = func;
4459N/A+ * we now setup our own dynamic locking callback, and disallow
4459N/A+ * setting of another locking callback.
4459N/A void CRYPTO_set_dynlock_lock_callback(void (*func) (int mode,
4459N/A- dynlock_lock_callback = func;
4459N/A+ * we now setup our own dynamic locking callback, and disallow
4459N/A+ * setting of another locking callback.
4459N/A void CRYPTO_set_dynlock_destroy_callback(void (*func)
4459N/A (struct CRYPTO_dynlock_value *l,
4459N/A const char *file, int line))
4459N/A- dynlock_destroy_callback = func;
4459N/A+ * we now setup our own dynamic locking callback, and disallow
4459N/A+ * setting of another locking callback.
4459N/A void (*CRYPTO_get_locking_callback(void)) (int mode, int type,
4006N/A return (add_lock_callback);
2582N/A+ * This is the locking callback function which all applications will be
2582N/A+ * using when CRYPTO_lock() is called.
2582N/A+static void solaris_locking_callback(int mode, int type, const char *file,
7161N/A+ (void) pthread_mutex_lock(&solaris_openssl_locks[type]);
7161N/A+ (void) pthread_mutex_unlock(&solaris_openssl_locks[type]);
4459N/A+ * Implement Solaris's own dynamic locking routines.
4459N/A+static struct CRYPTO_dynlock_value *
4459N/A+solaris_dynlock_create(const char *file, int line)
4459N/A+ dynlock = OPENSSL_malloc(sizeof(pthread_mutex_t));
4459N/A+ ret = pthread_mutex_init(dynlock, NULL);
4459N/A+ return ((struct CRYPTO_dynlock_value *)dynlock);
4459N/A+solaris_dynlock_lock(int mode, struct CRYPTO_dynlock_value *dynlock,
4459N/A+ const char *file, int line)
4459N/A+ ret = pthread_mutex_lock((pthread_mutex_t *)dynlock);
4459N/A+ ret = pthread_mutex_unlock((pthread_mutex_t *)dynlock);
4459N/A+solaris_dynlock_destroy(struct CRYPTO_dynlock_value *dynlock,
4459N/A+ const char *file, int line)
4459N/A+ ret = pthread_mutex_destroy((pthread_mutex_t *)dynlock);
7161N/A+static void solaris_fork_prep(void)
7161N/A+ for (i = 0; i < CRYPTO_NUM_LOCKS; i++) {
7161N/A+ (void) pthread_mutex_lock(&solaris_openssl_locks[i]);
7161N/A+static void solaris_fork_post(void)
7161N/A+ for (i = CRYPTO_NUM_LOCKS - 1; i >= 0; i--) {
7161N/A+ (void) pthread_mutex_unlock(&solaris_openssl_locks[i]);
7161N/A+ OPENSSL_assert(dynlock_create_callback == solaris_dynlock_create);
7161N/A+ OPENSSL_assert(dynlock_lock_callback == solaris_dynlock_lock);
7161N/A+ OPENSSL_assert(dynlock_destroy_callback == solaris_dynlock_destroy);
7161N/A+ OPENSSL_assert(locking_callback == solaris_locking_callback);
7161N/A+ * This is called by the _init() function to setup locks used by OpenSSL
7161N/A+ * and locking callback functions.
4459N/A+ /* setup the dynlock callback if not already */
4459N/A+ if (dynlock_create_callback == NULL) {
4459N/A+ dynlock_create_callback = solaris_dynlock_create;
4459N/A+ if (dynlock_lock_callback == NULL) {
4459N/A+ dynlock_lock_callback = solaris_dynlock_lock;
4459N/A+ if (dynlock_destroy_callback == NULL) {
4459N/A+ dynlock_destroy_callback = solaris_dynlock_destroy;
7161N/A+ if (locking_callback == NULL) {
7161N/A+ locking_callback = solaris_locking_callback;
7161N/A+ /* allocate and initialize locks needed by OpenSSL */
7161N/A+ OPENSSL_malloc(sizeof (pthread_mutex_t) * CRYPTO_NUM_LOCKS);
4459N/A+ if (solaris_openssl_locks == NULL) {
4459N/A+ "solaris_locking_setup: memory allocation failure.\n");
7161N/A+ for (i = 0; i < CRYPTO_NUM_LOCKS; i++) {
7161N/A+ (void) pthread_mutex_init(&solaris_openssl_locks[i], NULL);
7161N/A+ (void) pthread_atfork(solaris_fork_prep, solaris_fork_post, solaris_fork_post);
4006N/A void CRYPTO_set_locking_callback(void (*func) (int mode, int type,
4006N/A const char *file, int line))
4459N/A+ * we now setup our own locking callback and mutexes, and disallow
4459N/A+ * setting of another locking callback.
4006N/A void CRYPTO_set_add_lock_callback(int (*func) (int *num, int mount, int type,
4459N/A int CRYPTO_THREADID_set_callback(void (*func) (CRYPTO_THREADID *))
4459N/A+ * Use the backup method (the address of 'errno') to identify the
4459N/A+ * thread and disallow setting the threadid callback.
4459N/A void CRYPTO_set_id_callback(unsigned long (*func) (void))
4459N/A+ * Setting the id callback is disallowed.
4459N/A unsigned long CRYPTO_thread_id(void)
2582N/A void *OPENSSL_stderr(void);
2582N/A extern int OPENSSL_NONPIC_relocated;
2582N/A+void solaris_locking_setup();
7161N/A .size _sparcv9_vis1_instrument_bus2,.-_sparcv9_vis1_instrument_bus2
2582N/A .section ".init",#alloc,#execinstr
2582N/A+ call solaris_locking_setup
2582N/A .extern OPENSSL_cpuid_setup
2582N/A .hidden OPENSSL_cpuid_setup
2582N/A+.extern solaris_locking_setup
2582N/A+.hidden solaris_locking_setup
2582N/A+ call solaris_locking_setup
7161N/A &function_end_B("OPENSSL_ia32_rdseed");
2582N/A+&initseg("solaris_locking_setup");
2582N/A &initseg("OPENSSL_cpuid_setup");
7161N/A+&hidden("solaris_locking_setup");
7161N/A &hidden("OPENSSL_cpuid_setup");
7161N/A &hidden("OPENSSL_ia32cap_P");