amps-python-client 5.3.4.2__zip → 5.3.4.4__zip

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.4}/src/cpp/src/amps_ssl.c

@@ -57,6 +57,7 @@
 /* function pointers for openssl functions */
 void              (*_amps_SSL_library_init)(void);
 void              (*_amps_SSL_load_error_strings)(void);
+void              (*_amps_ERR_free_strings)(void);
 unsigned long     (*_amps_ERR_get_error)(void);
 void              (*_amps_ERR_error_string_n)(unsigned long, char*, size_t);
 void              (*_amps_ERR_clear_error)(void);
@@ -87,8 +88,8 @@ char           _amps_ssl_initialization_error[ERROR_BUFFER_LENGTH];
 
 #ifdef _WIN32
 typedef int (*local_proc)(void);
-HMODULE _amps_ssl_libeay_handle;
-HMODULE _amps_ssl_ssleay_handle;
+HMODULE _amps_crypto_library_handle = 0;
+HMODULE _amps_ssl_library_handle = 0;
 #define AMPS_strcpy strcpy_s
 
 void _amps_get_last_error(char* buffer, size_t length)
@@ -113,35 +114,37 @@ void _amps_get_last_error(char* buffer, size_t length)
                    NULL);
   }
 }
-#define LOAD_AMPS_LIBEAY_FUNCTION(name)                                         \
-  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_ssl_libeay_handle,#name);   \
-  if(!_amps_##name)                                                             \
-  {                                                                             \
-    _amps_get_last_error(errorBuffer, ERROR_BUFFER_LENGTH);                   \
-    _AMPS_SNPRINTF(_amps_ssl_initialization_error,                            \
-                   ERROR_BUFFER_LENGTH,                                      \
-                   "Error locating SSL procedure %s: %s",                    \
-                   #name,                                                    \
-                   errorBuffer);                                             \
-    return -1;                                                                \
+#define LOAD_AMPS_LIBEAY_FUNCTION(name)                                            \
+  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_crypto_library_handle,#name);  \
+  if(!_amps_##name)                                                                \
+  {                                                                                \
+    _amps_get_last_error(errorBuffer, ERROR_BUFFER_LENGTH);                        \
+    _AMPS_SNPRINTF(_amps_ssl_initialization_error,                                 \
+                   ERROR_BUFFER_LENGTH,                                            \
+                   "Error locating CRYPTO procedure %s: %s",                       \
+                   #name,                                                          \
+                   errorBuffer);                                                   \
+    _amps_crypto_library_handle = 0;                                               \
+    return -1;                                                                     \
   }
-#define LOAD_AMPS_SSLEAY_FUNCTION(name)                                         \
-  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_ssl_ssleay_handle,#name);   \
-  if(!_amps_##name)                                                             \
-  {                                                                             \
-    _amps_get_last_error(errorBuffer, ERROR_BUFFER_LENGTH);                   \
-    _AMPS_SNPRINTF(_amps_ssl_initialization_error,                            \
-                   ERROR_BUFFER_LENGTH,                                       \
-                   "Error locating SSL procedure %s: %s",                     \
-                   #name,                                                     \
-                   errorBuffer);                                              \
-    return -1;                                                                \
+#define LOAD_AMPS_SSLEAY_FUNCTION(name)                                            \
+  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_ssl_library_handle,#name);     \
+  if(!_amps_##name)                                                                \
+  {                                                                                \
+    _amps_get_last_error(errorBuffer, ERROR_BUFFER_LENGTH);                        \
+    _AMPS_SNPRINTF(_amps_ssl_initialization_error,                                 \
+                   ERROR_BUFFER_LENGTH,                                            \
+                   "Error locating SSL procedure %s: %s",                          \
+                   #name,                                                          \
+                   errorBuffer);                                                   \
+    _amps_ssl_library_handle = 0;                                                  \
+    return -1;                                                                     \
   }
-#define LOAD_AMPS_LIBEAY_FUNCTION_OPTIONAL(name)                                \
-  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_ssl_libeay_handle,#name);
+#define LOAD_AMPS_LIBEAY_FUNCTION_OPTIONAL(name)                                   \
+  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_crypto_library_handle,#name);
 
-#define LOAD_AMPS_SSLEAY_FUNCTION_OPTIONAL(name)                                \
-  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_ssl_ssleay_handle,#name);
+#define LOAD_AMPS_SSLEAY_FUNCTION_OPTIONAL(name)                                   \
+  *((FARPROC*)&_amps_##name) = GetProcAddress(_amps_ssl_library_handle,#name);
 
 int _amps_ssl_load(const char* dllPath_)
 {
@@ -153,11 +156,10 @@ int _amps_ssl_load(const char* dllPath_)
     /* attempt to locate via GetModuleHandle since it
      *  may already be loaded
      */
-    _amps_ssl_ssleay_handle = (HMODULE) GetModuleHandle(dllPath_);
-    if (!_amps_ssl_ssleay_handle)
+    if (!GetModuleHandleExA(0, dllPath_, &_amps_ssl_library_handle))
     {
-      _amps_ssl_ssleay_handle = (HMODULE) LoadLibraryExA(dllPath_, NULL, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
-      if (!_amps_ssl_ssleay_handle)
+      _amps_ssl_library_handle = (HMODULE) LoadLibraryExA(dllPath_, NULL, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+      if (!_amps_ssl_library_handle)
       {
         _amps_get_last_error(errorBuffer, ERROR_BUFFER_LENGTH);
         _AMPS_SNPRINTF(_amps_ssl_initialization_error, ERROR_BUFFER_LENGTH,
@@ -174,27 +176,39 @@ int _amps_ssl_load(const char* dllPath_)
      *       specify a ssleay32.dll path or at least filename,
      *       we won't default to looking around ourselves.
      */
-    _amps_ssl_ssleay_handle = LoadLibrary("ssleay32.dll");
-    if (!_amps_ssl_ssleay_handle)
+    _amps_ssl_library_handle = LoadLibrary("libssl-3.dll");
+    if (!_amps_ssl_library_handle)
     {
-      _amps_ssl_ssleay_handle = LoadLibrary("libssl-1_1-x64.dll");
+      _amps_ssl_library_handle = LoadLibrary("libssl-1_1.dll");
     }
-    if (!_amps_ssl_ssleay_handle)
+    if (!_amps_ssl_library_handle)
     {
-      _amps_ssl_ssleay_handle = LoadLibrary("libssl-1_1-x86.dll");
+      _amps_ssl_library_handle = LoadLibrary("libssl-1_1-x64.dll");
     }
-#else
-    _amps_ssl_ssleay_handle = GetModuleHandle("ssleay32.dll");
-    if (!_amps_ssl_ssleay_handle)
+    if (!_amps_ssl_library_handle)
     {
-      _amps_ssl_ssleay_handle = GetModuleHandle("libssl-1_1-x64.dll");
+      _amps_ssl_library_handle = LoadLibrary("libssl-1_1-x86.dll");
     }
-    if (!_amps_ssl_ssleay_handle)
+    if (!_amps_ssl_library_handle)
+    {
+      _amps_ssl_library_handle = LoadLibrary("ssleay32.dll");
+    }
+#else
+    if (!GetModuleHandleExA(0, "libssl-3.dll", &_amps_ssl_library_handle))
     {
-      _amps_ssl_ssleay_handle = GetModuleHandle("libssl-1_1-x86.dll");
+      if (!GetModuleHandleExA(0, "libssl-1_1.dll", &_amps_ssl_library_handle))
+      {
+        if (!GetModuleHandleExA(0, "libssl-1_1-x64.dll", &_amps_ssl_library_handle))
+        {
+          if (!GetModuleHandleExA(0, "libssl-1_1-x86.dll", &_amps_ssl_library_handle))
+          {
+            GetModuleHandleExA(0, "ssleay32.dll", &_amps_ssl_library_handle);
+          }
+        }
+      }
     }
 #endif
-    if (!_amps_ssl_ssleay_handle)
+    if (!_amps_ssl_library_handle)
     {
       _AMPS_SNPRINTF(_amps_ssl_initialization_error, ERROR_BUFFER_LENGTH,
                      "AMPS ssl_init() must be called with the path to " \
@@ -204,28 +218,34 @@ int _amps_ssl_load(const char* dllPath_)
     }
   }
 
-  /* Should have been loaded by ssleay32.dll loading if necessary */
-  _amps_ssl_libeay_handle = GetModuleHandle("libeay32.dll");
-  if (!_amps_ssl_libeay_handle)
-  {
-    _amps_ssl_libeay_handle = GetModuleHandle("libcrypto-1_1-x64.dll");
-  }
-
-  if (!_amps_ssl_libeay_handle)
-  {
-    _amps_ssl_libeay_handle = GetModuleHandle("libcrypto-1_1-x86.dll");
-  }
-
-  if (!_amps_ssl_libeay_handle)
+  if (!_amps_crypto_library_handle)
   {
-    _AMPS_SNPRINTF(_amps_ssl_initialization_error, ERROR_BUFFER_LENGTH,
-                   "The OpenSSL modules libeay32.dll, libcrypto-1_1-x64.dll, libcrypto-1_1-x86.dll"
-                   " were not loaded.");
-    return -1;
+    /* Should have been loaded by ssleay32.dll loading if necessary */
+    if (!GetModuleHandleExA(0, "libcrypto-3.dll", &_amps_crypto_library_handle))
+    {
+      if (!GetModuleHandleExA(0, "libcrypto-1_1.dll", &_amps_crypto_library_handle))
+      {
+        if (!GetModuleHandleExA(0, "libcrypto-1_1-x64.dll", &_amps_crypto_library_handle))
+        {
+          if (!GetModuleHandleExA(0, "libcrypto-1_1-x86.dll", &_amps_crypto_library_handle))
+          {
+            if (!GetModuleHandleExA(0, "libeay32.dll", &_amps_crypto_library_handle))
+            {
+              _AMPS_SNPRINTF(_amps_ssl_initialization_error, ERROR_BUFFER_LENGTH,
+                             "The OpenSSL modules libeay32.dll, "
+                             "libcrypto-1_1.dll, libcrypto-1_1-x64.dll were "
+                             "libcrypto-1_1-x86.dll not loaded.");
+              return -1;
+            }
+          }
+        }
+      }
+    }
   }
 
   LOAD_AMPS_SSLEAY_FUNCTION_OPTIONAL(SSL_library_init);
   LOAD_AMPS_SSLEAY_FUNCTION_OPTIONAL(SSL_load_error_strings);
+  LOAD_AMPS_LIBEAY_FUNCTION_OPTIONAL(ERR_free_strings);
   LOAD_AMPS_LIBEAY_FUNCTION(ERR_get_error);
   LOAD_AMPS_LIBEAY_FUNCTION(ERR_error_string_n);
   LOAD_AMPS_LIBEAY_FUNCTION(ERR_clear_error);
@@ -254,25 +274,54 @@ int _amps_ssl_load(const char* dllPath_)
 #else
 
 void*          _amps_ssl_library_handle = 0;
+void*          _amps_crypto_library_handle = 0;
 
 #define AMPS_strcpy(x, y, z) strcpy(x, z)
-#define LOAD_AMPS_SSL_FUNCTION_OPTIONAL(name)           \
+#define LOAD_AMPS_SSL_FUNCTION_OPTIONAL(name)                \
   _amps_##name = dlsym(_amps_ssl_library_handle,#name);
 
-#define LOAD_AMPS_SSL_FUNCTION(name)                    \
-  _amps_##name = dlsym(_amps_ssl_library_handle,#name); \
-  if(!_amps_##name)                                     \
-  {                                                     \
-    _AMPS_SNPRINTF(_amps_ssl_initialization_error,    \
-                   ERROR_BUFFER_LENGTH,               \
-                   "Error loading SSL module: %s",    \
-                   dlerror());                        \
-    return -1;                                        \
+#define LOAD_AMPS_SSL_FUNCTION(name)                         \
+  _amps_##name = dlsym(_amps_ssl_library_handle,#name);      \
+  if(!_amps_##name)                                          \
+  {                                                          \
+    _AMPS_SNPRINTF(_amps_ssl_initialization_error,           \
+                   ERROR_BUFFER_LENGTH,                      \
+                   "Error loading SSL module: %s",           \
+                   dlerror());                               \
+    _amps_ssl_library_handle = 0;                            \
+    return -1;                                               \
+  }
+
+#define LOAD_AMPS_CRYPTO_FUNCTION_OPTIONAL(name)             \
+  _amps_##name = dlsym(_amps_ssl_library_handle,#name);      \
+  if (_amps_crypto_library_handle && !_amps_##name)          \
+  {                                                          \
+    _amps_##name = dlsym(_amps_crypto_library_handle,#name); \
+  }
+
+#define LOAD_AMPS_CRYPTO_FUNCTION(name)                      \
+  _amps_##name = dlsym(_amps_ssl_library_handle,#name);      \
+  if (_amps_crypto_library_handle && !_amps_##name)          \
+  {                                                          \
+    _amps_##name = dlsym(_amps_crypto_library_handle,#name); \
+  }                                                          \
+  if(!_amps_##name)                                          \
+  {                                                          \
+    _AMPS_SNPRINTF(_amps_ssl_initialization_error,           \
+                   ERROR_BUFFER_LENGTH,                      \
+                   "Error loading CRYPTO module: %s",        \
+                   dlerror());                               \
+    _amps_crypto_library_handle = 0;                         \
+    return -1;                                               \
   }
 
 int _amps_ssl_load(const char* dllPath_)
 {
   _amps_ssl_initialization_error[0] = '\0';
+  if (_amps_ssl_library_handle && _amps_crypto_library_handle)
+  {
+    return 0;
+  }
   if (dllPath_)
   {
     _amps_ssl_library_handle = dlopen(dllPath_, RTLD_LOCAL | RTLD_LAZY);
@@ -284,19 +333,56 @@ int _amps_ssl_load(const char* dllPath_)
                      dlerror());
       return -1;
     }
+    size_t dllPathLen = strlen(dllPath_);
+    const char* ssl = strstr(dllPath_, "ssl");
+    if (!ssl)
+    {
+      _amps_crypto_library_handle = AMPS_RTLD_DEFAULT;
+    }
+    else
+    {
+      const char* nextSsl = strstr(ssl+1, "ssl");
+      while (nextSsl)
+      {
+        ssl = nextSsl;
+        nextSsl = strstr(ssl+1, "ssl");
+      }
+      char* cryptoPath = (char*) malloc(dllPathLen + 4);
+      size_t offset = (size_t)(ssl - dllPath_);
+      memcpy(cryptoPath, dllPath_, offset);
+      memcpy(cryptoPath + offset, "crypto", 6);
+      memcpy(cryptoPath + offset + 6, ssl + 3, dllPathLen - offset - 3);
+      cryptoPath[dllPathLen + 3] = '\0';
+      _amps_crypto_library_handle = dlopen(cryptoPath, RTLD_LOCAL | RTLD_LAZY);
+      if (!_amps_crypto_library_handle)
+      {
+        // If it's a python module, use it for both
+        if (strstr(dllPath_, "python"))
+        {
+          _amps_crypto_library_handle = _amps_ssl_library_handle;
+        }
+        else
+        {
+          _amps_crypto_library_handle = AMPS_RTLD_DEFAULT;
+        }
+      }
+      free(cryptoPath);
+    }
   }
   else
   {
     _amps_ssl_library_handle = AMPS_RTLD_DEFAULT;
+    _amps_crypto_library_handle = AMPS_RTLD_DEFAULT;
   }
 
   LOAD_AMPS_SSL_FUNCTION_OPTIONAL(SSL_library_init);
   LOAD_AMPS_SSL_FUNCTION_OPTIONAL(SSL_load_error_strings);
-  LOAD_AMPS_SSL_FUNCTION(ERR_get_error);
-  LOAD_AMPS_SSL_FUNCTION(ERR_error_string_n);
-  LOAD_AMPS_SSL_FUNCTION(ERR_clear_error);
-  LOAD_AMPS_SSL_FUNCTION_OPTIONAL(CRYPTO_num_locks);
-  LOAD_AMPS_SSL_FUNCTION_OPTIONAL(CRYPTO_set_locking_callback);
+  LOAD_AMPS_SSL_FUNCTION_OPTIONAL(ERR_free_strings);
+  LOAD_AMPS_CRYPTO_FUNCTION(ERR_get_error);
+  LOAD_AMPS_CRYPTO_FUNCTION(ERR_error_string_n);
+  LOAD_AMPS_CRYPTO_FUNCTION(ERR_clear_error);
+  LOAD_AMPS_CRYPTO_FUNCTION_OPTIONAL(CRYPTO_num_locks);
+  LOAD_AMPS_CRYPTO_FUNCTION_OPTIONAL(CRYPTO_set_locking_callback);
   LOAD_AMPS_SSL_FUNCTION_OPTIONAL(SSLv23_client_method);
   LOAD_AMPS_SSL_FUNCTION_OPTIONAL(TLS_client_method);
   LOAD_AMPS_SSL_FUNCTION(SSL_CTX_new);
@@ -320,14 +406,18 @@ int _amps_ssl_load(const char* dllPath_)
 
 /****************** THREADING SUPPORT *********************/
 #ifdef _WIN32
-  CRITICAL_SECTION* _amps_ssl_mutexes;
+  CRITICAL_SECTION* _amps_ssl_mutexes = 0;
 #else
-  pthread_mutex_t*  _amps_ssl_mutexes;
+  pthread_mutex_t*  _amps_ssl_mutexes = 0;
 #endif
-size_t            _amps_ssl_mutex_count;
+size_t            _amps_ssl_mutex_count = 0;
 
 void amps_ssl_locking_callback(int mode_, int n_, const char* filename_, int line_)
 {
+  if (!_amps_ssl_mutexes)
+  {
+    return;
+  }
   if (mode_ & AMPS_CRYPTO_LOCK) /* CRYPTO_LOCK == 0x01 */
   {
 #ifdef _WIN32
@@ -416,6 +506,10 @@ AMPSDLL int amps_ssl_init(const char* dllPath_)
       return -1;
     }
     _amps_SSL_load_error_strings();
+    if (_amps_ERR_free_strings)
+    {
+      atexit(_amps_ERR_free_strings);
+    }
     _amps_SSL_library_init();
     amps_ssl_setup_threading_functions();
     sslMethod = _amps_SSLv23_client_method();
@@ -448,6 +542,25 @@ AMPSDLL int amps_ssl_init(const char* dllPath_)
   return 0;
 }
 
+AMPSDLL int amps_ssl_init_from_context(void* context_, const char* fileName_)
+{
+  if (_amps_ssl_load(NULL) != 0)
+  {
+    if (!fileName_ || _amps_ssl_load(fileName_))
+    {
+      return -1;
+    }
+  }
+  _amps_ssl_ctx = (_amps_SSL_CTX*)context_;
+
+#ifndef _WIN32
+  /* No SIGPIPE */
+  signal(SIGPIPE, SIG_IGN);
+#endif
+
+  return 0;
+}
+
 AMPSDLL const char* amps_ssl_get_error(void)
 {
   return _amps_ssl_initialization_error;
@@ -484,6 +597,20 @@ AMPSDLL int amps_ssl_load_verify_locations(const char* caFile_, const char* caPa
 
 AMPSDLL void amps_ssl_free(void)
 {
-  _amps_SSL_CTX_free(_amps_ssl_ctx);
+  if (_amps_ssl_ctx)
+  {
+    _amps_SSL_CTX_free(_amps_ssl_ctx);
+  }
   _amps_ssl_ctx = 0;
+  for (size_t i = 0; i < _amps_ssl_mutex_count; ++i)
+  {
+#ifdef _WIN32
+    DeleteCriticalSection(_amps_ssl_mutexes + i);
+#else
+    pthread_mutex_destroy(_amps_ssl_mutexes + i);
+#endif
+  }
+  free(_amps_ssl_mutexes);
+  _amps_ssl_mutexes = 0;
+  _amps_ssl_mutex_count = 0;
 }

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.4}/src/cpp/src/atfork.c

@@ -107,9 +107,37 @@ void __amps_atfork_mutex_init(void)
 #endif
 }
 
+void _amps_atfork_cleanup(void)
+{
+  if (!_amps_atfork_array)
+  {
+    return;
+  }
+  for (size_t h = 0; h < _amps_atfork_array_size; ++h)
+  {
+    struct _amps_atfork_entry* pEntry = &_amps_atfork_array[h];
+    if (!pEntry || !pEntry->capacity || !pEntry->buckets || !pEntry->callback)
+    {
+      continue;
+    }
+    for (size_t i = 0; i < pEntry->maxBucket; ++i)
+    {
+      struct _amps_atfork_bucket* pBucket = &pEntry->buckets[i];
+      free(pBucket->_array);
+    }
+    free(pEntry->buckets);
+  }
+  free(_amps_atfork_array);
+  _amps_atfork_array = 0;
+  _amps_atfork_array_size = 0;
+  _amps_atfork_array_capacity = 0;
+}
+
 void _amps_atfork_register(void)
 {
   pthread_atfork(__amps_prefork, __amps_postfork_parent, __amps_postfork_child);
+  // Needed if static items aren't destroyed
+  atexit(_amps_atfork_cleanup);
 }
 
 void _amps_atfork_init(void)
@@ -272,6 +300,7 @@ void amps_atfork_add(void* user_data_, _amps_atfork_callback_function callback_)
   if (!pEntry->callback)
   {
     pEntry->callback = callback_;
+    free(pEntry->buckets);
     pEntry->buckets = malloc((_AMPS_ATFORK_DEFAULT_RESIZE - 1) * sizeof(struct _amps_atfork_bucket));
     memset(pEntry->buckets, 0, (_AMPS_ATFORK_DEFAULT_RESIZE - 1) * sizeof(struct _amps_atfork_bucket));
     pEntry->capacity = _AMPS_ATFORK_DEFAULT_RESIZE - 1;
@@ -331,6 +360,10 @@ void amps_atfork_add(void* user_data_, _amps_atfork_callback_function callback_)
 
 void amps_atfork_remove(void* user_data_, _amps_atfork_callback_function callback_)
 {
+  if (!_amps_atfork_array || !_amps_atfork_array_size)
+  {
+    return;
+  }
   pthread_mutex_lock(&_amps_atfork_registry_mutex);
   pthread_cleanup_push(amps_cleanup_unlock_registry_mutex, NULL);