+int CRYPTO_num_locks(void)
+{
+ return CRYPTO_NUM_LOCKS;
+}
+
+int CRYPTO_get_new_dynlockid(void)
+{
+ int i = 0;
+ CRYPTO_dynlock *pointer = NULL;
+
+ if (dynlock_create_callback == NULL) {
+ CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID,
+ CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK);
+ return (0);
+ }
+ CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
+ if ((dyn_locks == NULL)
+ && ((dyn_locks = sk_CRYPTO_dynlock_new_null()) == NULL)) {
+ CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
+ CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID, ERR_R_MALLOC_FAILURE);
+ return (0);
+ }
+ CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
+
+ pointer = (CRYPTO_dynlock *) OPENSSL_malloc(sizeof(CRYPTO_dynlock));
+ if (pointer == NULL) {
+ CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID, ERR_R_MALLOC_FAILURE);
+ return (0);
+ }
+ pointer->references = 1;
+ pointer->data = dynlock_create_callback(__FILE__, __LINE__);
+ if (pointer->data == NULL) {
+ OPENSSL_free(pointer);
+ CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID, ERR_R_MALLOC_FAILURE);
+ return (0);
+ }
+
+ CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
+ /* First, try to find an existing empty slot */
+ i = sk_CRYPTO_dynlock_find(dyn_locks, NULL);
+ /* If there was none, push, thereby creating a new one */
+ if (i == -1)
+ /*
+ * Since sk_push() returns the number of items on the stack, not the
+ * location of the pushed item, we need to transform the returned
+ * number into a position, by decreasing it.
+ */
+ i = sk_CRYPTO_dynlock_push(dyn_locks, pointer) - 1;
+ else
+ /*
+ * If we found a place with a NULL pointer, put our pointer in it.
+ */
+ (void)sk_CRYPTO_dynlock_set(dyn_locks, i, pointer);
+ CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
+
+ if (i == -1) {
+ dynlock_destroy_callback(pointer->data, __FILE__, __LINE__);
+ OPENSSL_free(pointer);
+ } else
+ i += 1; /* to avoid 0 */
+ return -i;
+}
+
+void CRYPTO_destroy_dynlockid(int i)
+{
+ CRYPTO_dynlock *pointer = NULL;
+ if (i)
+ i = -i - 1;
+ if (dynlock_destroy_callback == NULL)
+ return;
+
+ CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
+
+ if (dyn_locks == NULL || i >= sk_CRYPTO_dynlock_num(dyn_locks)) {
+ CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
+ return;
+ }
+ pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
+ if (pointer != NULL) {
+ --pointer->references;
+#ifdef REF_CHECK
+ if (pointer->references < 0) {
+ fprintf(stderr,
+ "CRYPTO_destroy_dynlockid, bad reference count\n");
+ abort();
+ } else
+#endif
+ if (pointer->references <= 0) {
+ (void)sk_CRYPTO_dynlock_set(dyn_locks, i, NULL);
+ } else
+ pointer = NULL;
+ }
+ CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
+
+ if (pointer) {
+ dynlock_destroy_callback(pointer->data, __FILE__, __LINE__);
+ OPENSSL_free(pointer);
+ }
+}
+
+struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i)
+{
+ CRYPTO_dynlock *pointer = NULL;
+ if (i)
+ i = -i - 1;
+
+ CRYPTO_w_lock(CRYPTO_LOCK_DYNLOCK);
+
+ if (dyn_locks != NULL && i < sk_CRYPTO_dynlock_num(dyn_locks))
+ pointer = sk_CRYPTO_dynlock_value(dyn_locks, i);
+ if (pointer)
+ pointer->references++;
+
+ CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
+
+ if (pointer)
+ return pointer->data;
+ return NULL;
+}
+
+struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))
+ (const char *file, int line) {
+ return (dynlock_create_callback);
+}
+
+void (*CRYPTO_get_dynlock_lock_callback(void)) (int mode,
+ struct CRYPTO_dynlock_value
+ *l, const char *file,
+ int line) {
+ return (dynlock_lock_callback);
+}
+
+void (*CRYPTO_get_dynlock_destroy_callback(void))
+ (struct CRYPTO_dynlock_value *l, const char *file, int line) {
+ return (dynlock_destroy_callback);
+}
+
+void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*func)
+ (const char *file, int line))
+{
+ dynlock_create_callback = func;
+}
+
+void CRYPTO_set_dynlock_lock_callback(void (*func) (int mode,
+ struct
+ CRYPTO_dynlock_value *l,
+ const char *file,
+ int line))
+{
+ dynlock_lock_callback = func;
+}
+
+void CRYPTO_set_dynlock_destroy_callback(void (*func)
+ (struct CRYPTO_dynlock_value *l,
+ const char *file, int line))
+{
+ dynlock_destroy_callback = func;
+}
+
+void (*CRYPTO_get_locking_callback(void)) (int mode, int type,
+ const char *file, int line) {
+ return (locking_callback);
+}
+
+int (*CRYPTO_get_add_lock_callback(void)) (int *num, int mount, int type,
+ const char *file, int line) {
+ return (add_lock_callback);
+}
+
+void CRYPTO_set_locking_callback(void (*func) (int mode, int type,
+ const char *file, int line))
+{
+ /*
+ * Calling this here ensures initialisation before any threads are
+ * started.
+ */
+ OPENSSL_init();
+ locking_callback = func;
+}
+
+void CRYPTO_set_add_lock_callback(int (*func) (int *num, int mount, int type,
+ const char *file, int line))
+{
+ add_lock_callback = func;
+}
+
+/*
+ * the memset() here and in set_pointer() seem overkill, but for the sake of
+ * CRYPTO_THREADID_cmp() this avoids any platform silliness that might cause
+ * two "equal" THREADID structs to not be memcmp()-identical.
+ */
+void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val)
+{
+ memset(id, 0, sizeof(*id));
+ id->val = val;
+}
+
+static const unsigned char hash_coeffs[] = { 3, 5, 7, 11, 13, 17, 19, 23 };
+
+void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr)
+{
+ unsigned char *dest = (void *)&id->val;
+ unsigned int accum = 0;
+ unsigned char dnum = sizeof(id->val);
+
+ memset(id, 0, sizeof(*id));
+ id->ptr = ptr;
+ if (sizeof(id->val) >= sizeof(id->ptr)) {
+ /*
+ * 'ptr' can be embedded in 'val' without loss of uniqueness
+ */
+ id->val = (unsigned long)id->ptr;
+ return;
+ }
+ /*
+ * hash ptr ==> val. Each byte of 'val' gets the mod-256 total of a
+ * linear function over the bytes in 'ptr', the co-efficients of which
+ * are a sequence of low-primes (hash_coeffs is an 8-element cycle) - the
+ * starting prime for the sequence varies for each byte of 'val' (unique
+ * polynomials unless pointers are >64-bit). For added spice, the totals
+ * accumulate rather than restarting from zero, and the index of the
+ * 'val' byte is added each time (position dependence). If I was a
+ * black-belt, I'd scan big-endian pointers in reverse to give low-order
+ * bits more play, but this isn't crypto and I'd prefer nobody mistake it
+ * as such. Plus I'm lazy.
+ */
+ while (dnum--) {
+ const unsigned char *src = (void *)&id->ptr;
+ unsigned char snum = sizeof(id->ptr);
+ while (snum--)
+ accum += *(src++) * hash_coeffs[(snum + dnum) & 7];
+ accum += dnum;
+ *(dest++) = accum & 255;
+ }
+}
+
+#ifdef OPENSSL_FIPS
+extern int FIPS_crypto_threadid_set_callback(void (*func) (CRYPTO_THREADID *));
+#endif
+
+int CRYPTO_THREADID_set_callback(void (*func) (CRYPTO_THREADID *))
+{
+ if (threadid_callback)
+ return 0;
+ threadid_callback = func;
+#ifdef OPENSSL_FIPS
+ FIPS_crypto_threadid_set_callback(func);
+#endif
+ return 1;
+}
+
+void (*CRYPTO_THREADID_get_callback(void)) (CRYPTO_THREADID *) {
+ return threadid_callback;
+}
+
+void CRYPTO_THREADID_current(CRYPTO_THREADID *id)
+{
+ if (threadid_callback) {
+ threadid_callback(id);
+ return;
+ }
+#ifndef OPENSSL_NO_DEPRECATED
+ /* If the deprecated callback was set, fall back to that */
+ if (id_callback) {
+ CRYPTO_THREADID_set_numeric(id, id_callback());
+ return;
+ }
+#endif
+ /* Else pick a backup */
+#ifdef OPENSSL_SYS_WIN16
+ CRYPTO_THREADID_set_numeric(id, (unsigned long)GetCurrentTask());
+#elif defined(OPENSSL_SYS_WIN32)
+ CRYPTO_THREADID_set_numeric(id, (unsigned long)GetCurrentThreadId());
+#elif defined(OPENSSL_SYS_BEOS)
+ CRYPTO_THREADID_set_numeric(id, (unsigned long)find_thread(NULL));