amps-python-client 5.3.4.2__zip → 5.3.4.3__zip

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/command_docs.h

@@ -26,11 +26,9 @@
 
 #define COMMAND_SETTER_BOILERPLATE "\n\nNot all headers are processed by AMPS for all commands. See the AMPS Command Reference for which headers are used by AMPS for a specific command.\n\n:param value: The new value to set for the header.\n\n:returns: This command."
 
-// #define COMMAND_SETTER_BOILERPLATE "\nNot all headers are processed by AMPS for all commands. See the AMPS Command Reference\nfor which headers are used by AMPS for a specific command.\n\n:param value: The new value to set for the header.\n\n:returns: This command.\n";
 
-
-static const char* command_class_doc = R"docstring(
-AMPS.Command represents a single message (or *command*) sent to the
+static const char* command_class_doc = R"docstring(Command(command_name)
+``AMPS.Command`` represents a single message (or *command*) sent to the
 AMPS server. The class provides methods for headers that are used
 for commands to the server. Applications typically use this class
 to create outgoing requests to AMPS. The responses to requests,
@@ -49,6 +47,11 @@ Command, set options as described in the Command Cookbook in the
 Python Developer Guide or the AMPS Command Reference, and then use
 :func:`AMPS.Client.execute_async()` to process messages asynchronously,
 or :func:`AMPS.Client.execute()` to process messages synchronously.
+
+**Constructor Arguments:**
+
+:param command_name: The name of the command to send to the server. 
+                     For example, ``sow``, ``sow_and_subscribe`` or ``publish``.
 )docstring";
 
 
@@ -142,7 +145,7 @@ static const char* set_bookmark_doc = R"docstring(set_bookmark(value)
 Sets the value of the bookmark header. For a subscription, this identifies the point in the
 transaction log at which to begin the replay. For a ``sow_delete`` (queue acknowledgment), this
 indicates the message or messages to acknowledge. For a query on a SOW topic with
-History configured, this indicates the point at which to query the topic.
+``History`` configured, this indicates the point at which to query the topic.
 )docstring"
 COMMAND_SETTER_BOILERPLATE;
 
@@ -265,5 +268,7 @@ static const char* get_sequence_doc = R"docstring(get_sequence()
 Gets the sequence of self for ``publish``, ``delta_publish``, or ``sow_delete`` commands.
 This can be checked after calling ``execute`` or ``executeAsync`` to query the sequence
 number that was used, if any.
+
+:returns: The sequence number used in the last ``publish``, ``delta_publish``, or ``sow_delete`` command.
 )docstring";
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/BlockPublishStore.hpp

@@ -42,9 +42,6 @@
   #include <sys/timeb.h>
 #else
   #include <sys/time.h>
-  #if AMPS_SSE_42
-    #include <cpuid.h>
-  #endif
 #endif
 #include <iostream>
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/BlockStore.hpp

@@ -40,9 +40,6 @@
   #include <sys/timeb.h>
 #else
   #include <sys/time.h>
-  #if AMPS_SSE_42
-    #include <cpuid.h>
-  #endif
 #endif
 #include <iostream>
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/Field.hpp

@@ -163,7 +163,7 @@ namespace AMPS
       {
         return (!_data && !rhs_);
       }
-      return ::strncmp(_data, rhs_, _len) == 0 && rhs_[_len] == '\0';
+      return (_len == strlen(rhs_)) && (::strncmp(_data, rhs_, _len) == 0);
     }
 
     bool operator<(const Field& rhs) const;
@@ -189,7 +189,7 @@ namespace AMPS
     ///
     bool operator!=(const char* rhs_) const
     {
-      return strncmp(_data, rhs_, _len) != 0 || rhs_[_len] != '\0';
+      return (_len != strlen(rhs_)) || (::memcmp(_data, rhs_, _len) != 0);
     }
 
     ///
@@ -365,6 +365,10 @@ namespace AMPS
                               amps_uint64_t& sequenceNumber_)
     {
       publisherId_ = sequenceNumber_ = (amps_uint64_t)0;
+      if (field_.empty())
+      {
+        return;
+      }
       const char* data = field_.data();
       size_t len = field_.len();
       // Can't parse a timestamp

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/MMapStoreBuffer.hpp

@@ -79,8 +79,8 @@ namespace AMPS
 #else
       size_t fileSize = liFileSize.LowPart;
 #endif
-      _setSize( AMPS_MEMORYBUFFER_DEFAULT_LENGTH > fileSize ?
-                AMPS_MEMORYBUFFER_DEFAULT_LENGTH : fileSize);
+      _setSize(AMPS_MEMORYBUFFER_DEFAULT_LENGTH > fileSize
+               ? AMPS_MEMORYBUFFER_DEFAULT_LENGTH : fileSize);
 #else
     {
       _fd = ::open(fileName_.c_str(), O_CREAT | O_RDWR, (mode_t)0644);
@@ -92,9 +92,10 @@ namespace AMPS
         os << "Failed to stat file " << fileName_ << " for MMapStoreBuffer";
         error(os.str());
       }
-      _bufferLen = (size_t)statBuf.st_size;
-      _setSize(statBuf.st_size > (ssize_t)AMPS_MEMORYBUFFER_DEFAULT_LENGTH
-               ? (size_t)statBuf.st_size : AMPS_MEMORYBUFFER_DEFAULT_LENGTH);
+      bool recovery = statBuf.st_size >= (ssize_t)AMPS_MEMORYBUFFER_DEFAULT_LENGTH;
+      _setSize(recovery ? (size_t)statBuf.st_size
+                        : AMPS_MEMORYBUFFER_DEFAULT_LENGTH,
+               recovery);
 #endif
     }
 
@@ -127,7 +128,7 @@ namespace AMPS
 
     void sync()
     {
-      if (_buffer != NULL)
+      if (_buffer != NULL && _bufferLen)
       {
 #ifdef _WIN32
         if (!FlushViewOfFile(_buffer, _bufferPos))
@@ -148,7 +149,7 @@ namespace AMPS
       _setSize(newSize_);
     }
 
-    void _setSize(size_t newSize_)
+    void _setSize(size_t newSize_, bool recovery_ = false)
     {
       if (_bufferLen > 0)
       {
@@ -202,13 +203,16 @@ namespace AMPS
              << " requested new size: " << newSize_;
           error(os.str());
         }
-        if (::write(_fd, "", 1) == -1)
+        if (!recovery_)
         {
-          std::ostringstream os;
-          os << "Failed to grow buffer; buffer: " << (size_t)_buffer << " length: "
-             << _bufferLen << " pos: " << _bufferPos << " requested new size: "
-             << newSize_;
-          error(os.str());
+          if (::write(_fd, "", 1) == -1)
+          {
+            std::ostringstream os;
+            os << "Failed to grow buffer; buffer: " << (size_t)_buffer << " length: "
+               << _bufferLen << " pos: " << _bufferPos << " requested new size: "
+               << newSize_;
+            error(os.str());
+          }
         }
       }
 
@@ -236,7 +240,10 @@ namespace AMPS
         _bufferLen = 0;
         error(os.str());
       }
-      _buffer = (char*)result;
+      else
+      {
+        _buffer = (char*)result;
+      }
 #endif
       if (_buffer)
       {

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/MemoryStoreBuffer.hpp

@@ -230,7 +230,10 @@ namespace AMPS
 
   protected:
     enum CtorFlag { EMPTY };
-    MemoryStoreBuffer(CtorFlag) : _buffer(0), _bufferLen(0), _bufferPos(0)
+    MemoryStoreBuffer(CtorFlag)
+    : _buffer(nullptr)
+    , _bufferLen(0)
+    , _bufferPos(0)
     {}
 
     char*  _buffer;

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/Message.hpp

@@ -1811,6 +1811,14 @@ namespace AMPS
   inline bool
   AMPS::Field::operator<(const AMPS::Field& rhs) const
   {
+    if (!data())
+    {
+      return rhs.data() != NULL;
+    }
+    if (!rhs.data())
+    {
+      return false;
+    }
     return std::lexicographical_compare(data(), data() + len(), rhs.data(), rhs.data() + rhs.len());
   }
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/ServerChooser.hpp

@@ -51,6 +51,8 @@ namespace AMPS
 
     ServerChooser(ServerChooserImpl* body_) : _body(body_) {}
 
+    ~ServerChooser() {}
+
     bool isValid()
     {
       return _body.isValid();
@@ -127,16 +129,25 @@ namespace AMPS
       _body.get().remove(uri_);
     }
 
-    ~ServerChooser() {}
+    ServerChooser(const ServerChooser& rhs) : _body(rhs._body)
+    {
+    }
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || _MSC_VER >= 1600
+    ServerChooser(ServerChooser&& rhs) : _body(rhs._body)
+    {
+    }
 
+    ServerChooser& operator=(ServerChooser&& rhs)
+    {
+      _body = rhs._body;
+      return *this;
+    }
+#endif // defined(__GXX_EXPERIMENTAL_CXX0X__) || _MSC_VER >= 1600
     ServerChooser& operator=(const ServerChooser& rhs)
     {
       _body = rhs._body;
       return *this;
     }
-
-    ServerChooser(const ServerChooser& rhs) : _body(rhs._body) {}
-
   };
 
 } //namespace AMPS

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/amps.h

@@ -41,6 +41,18 @@
 #include <stdio.h>
 #include "amps/amps_generated.h"
 
+#ifdef AMPS_CPP_COUNT_THREADS
+#ifdef __cplusplus
+extern "C" {
+#endif
+  size_t amps_get_thread_create_count(void);
+  size_t amps_get_thread_join_count(void);
+  size_t amps_get_thread_detach_count(void);
+#ifdef __cplusplus
+}
+#endif
+#endif
+
 //Avoid compiler warnings on win
 #ifdef INVALID_SOCKET
   #define AMPS_INVALID_SOCKET INVALID_SOCKET

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/amps_impl.h

@@ -204,5 +204,17 @@ AMPSDLL void amps_atfork_init(void);
 AMPSDLL void amps_atfork_add(void*, _amps_atfork_callback_function);
 AMPSDLL void amps_atfork_remove(void*, _amps_atfork_callback_function);
 
+#ifdef AMPS_CPP_COUNT_THREADS
+#if __STDC_VERSION__ >= 201100
+  extern _Atomic size_t amps_thread_create_count;
+  extern _Atomic size_t amps_thread_join_count;
+  extern _Atomic size_t amps_thread_detach_count;
+#else
+  extern volatile size_t amps_thread_create_count;
+  extern volatile size_t amps_thread_join_count;
+  extern volatile size_t amps_thread_detach_count;
+#endif
+#endif
+
 
 #endif

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/ampscrc.hpp

@@ -48,9 +48,7 @@ namespace AMPS
       __cpuid(cpuinfo, 1);
       return (cpuinfo[2] & (1 << 20)) != 0;
 #else
-      unsigned int eax, ebx, ecx = 0, edx;
-      __get_cpuid(1, &eax, &ebx, &ecx, &edx);
-      return ecx & (1 << 20);
+      return true;
 #endif
 #else
       return false;
@@ -87,7 +85,7 @@ namespace AMPS
       }
 
       // process 64 bytes at a time
-      unsigned int middleLen = (len_ - beginLen) & ~0x3Fl;
+      unsigned int middleLen = (unsigned int)((len_ - beginLen) & ~0x3Fl);
 
       unsigned int i = 0;
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/ampsplusplus.hpp

@@ -1724,6 +1724,7 @@ namespace AMPS
       unsigned connectionVersion;
       AckResponseImpl() :
         RefBody(),
+        username(), password(), reason(), status(), bookmark(), options(),
         sequenceNo((amps_uint64_t)0),
         serverVersion(),
         responded(false),
@@ -4407,9 +4408,7 @@ namespace AMPS
       unsigned requestedAcks = message.getAckTypeEnum();
       bool isPublishStore = _publishStore.isValid() && command_.needsSequenceNumber();
       Message::Command::Type commandType = message.getCommandEnum();
-      if (commandType == Message::Command::SOWAndSubscribe
-          || commandType == Message::Command::SOWAndDeltaSubscribe
-          || commandType == Message::Command::StopTimer)
+      if (commandType == Message::Command::StopTimer)
       {
         systemAddedAcks |= Message::AckType::Completed;
       }
@@ -4458,9 +4457,9 @@ namespace AMPS
         _registerHandler(command_, cid, handler_,
                          requestedAcks, systemAddedAcks, commandType);
       }
-      bool useSyncSend = cid.len() > 0 && command_.hasProcessedAck();
       if (isPublishStore)
       {
+        bool useSyncSend = cid.len() > 0 && command_.hasProcessedAck();
         amps_uint64_t haSequenceNumber = (amps_uint64_t)0;
         message.setAckTypeEnum(requestedAcks | systemAddedAcks);
         {
@@ -4516,15 +4515,8 @@ namespace AMPS
           message.setAckTypeEnum(requestedAcks | systemAddedAcks);
           try
           {
-            if (useSyncSend)
-            {
-              syncAckProcessing((long)command_.getTimeout(), message,
-                                isHASubscribe_);
-            }
-            else
-            {
-              _send(message);
-            }
+            syncAckProcessing((long)command_.getTimeout(), message,
+                              isHASubscribe_);
           }
           catch (const DisconnectedException&)
           {
@@ -4570,6 +4562,9 @@ namespace AMPS
         }
         else
         {
+          // SOW, Flush, etc. should always be sync. Publish/delete may not be.
+          bool useSyncSend = commandType & ~Message::Command::NoDataCommands
+                             || (cid.len() > 0 && command_.hasProcessedAck());
           message.setAckTypeEnum(requestedAcks | systemAddedAcks);
           try
           {
@@ -8500,10 +8495,11 @@ namespace AMPS
         {
           _state = Closed;
         }
-        else if (current_.getCommandEnum() == Message::Command::Publish &&
-                 _client.isValid() && _client.getAutoAck() &&
-                 !current_.getLeasePeriod().empty() &&
-                 !current_.getBookmark().empty())
+        else if (current_.isValid()
+                 && current_.getCommandEnum() == Message::Command::Publish
+                 && _client.isValid() && _client.getAutoAck()
+                 && !current_.getLeasePeriod().empty()
+                 && !current_.getBookmark().empty())
         {
           _previousTopic = current_.getTopic().deepCopy();
           _previousBookmark = current_.getBookmark().deepCopy();

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/ampsver.h

@@ -32,10 +32,10 @@
 
 
 /// The current version of the AMPS client.
-#define AMPS_CLIENT_VERSION "5.3.4.2"
+#define AMPS_CLIENT_VERSION "5.3.4.3"
 
 /// The current version of the AMPS client with the language appended.
-#define AMPS_CLIENT_VERSION_WITH_LANGUAGE "5.3.4.2.3304e34.540236:python"
+#define AMPS_CLIENT_VERSION_WITH_LANGUAGE "5.3.4.3.1c0da8e.656215:python"
 
 #endif
 

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/src/cpp/include/amps/util.hpp

@@ -587,7 +587,7 @@ namespace AMPS
       rhs._isRef = false;
     }
 
-    const BorrowRefHandle& operator=(BorrowRefHandle&& rhs)
+    BorrowRefHandle& operator=(BorrowRefHandle&& rhs)
     {
       if (this == &rhs)
       {
@@ -605,7 +605,7 @@ namespace AMPS
     }
 #endif // defined(__GXX_EXPERIMENTAL_CXX0X__) || _MSC_VER >= 1600
 
-    const BorrowRefHandle& operator=(const BorrowRefHandle& rhs)
+    BorrowRefHandle& operator=(const BorrowRefHandle& rhs)
     {
       if (this == &rhs)
       {
@@ -1600,7 +1600,7 @@ namespace AMPS
       return convertVersionToNumber(_versionString.data(), _versionString.length());
     }
 
-    const VersionInfo& operator=(const VersionInfo& info_)
+    VersionInfo& operator=(const VersionInfo& info_)
     {
       _versionString = info_._versionString;
       _versionNum = info_._versionNum;
@@ -1655,7 +1655,7 @@ namespace AMPS
       const int MAXDIGITS[] = { 4, 4, 5, 5 };
 
       amps_uint64_t versionNum = 0;
-      if (version_.length() == 0 || !isdigit(version_[0]))
+      if (version_.empty() || !isdigit(version_[0]))
       {
         // Start with non-numeric is a special build
         return AMPS_DEFAULT_SERVER_VERSION;

{amps-python-client-5.3.4.2 → amps-python-client-5.3.4.3}/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_ssl_libeay_handle = 0;
+HMODULE _amps_ssl_ssleay_handle = 0;
 #define AMPS_strcpy strcpy_s
 
 void _amps_get_last_error(char* buffer, size_t length)
@@ -226,6 +227,7 @@ int _amps_ssl_load(const char* dllPath_)
 
   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,6 +256,7 @@ 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)           \
@@ -270,6 +273,28 @@ void*          _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());                               \
+    return -1;                                               \
+  }
+
 int _amps_ssl_load(const char* dllPath_)
 {
   _amps_ssl_initialization_error[0] = '\0';
@@ -284,19 +309,48 @@ 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);
+      free(cryptoPath);
+      if (!_amps_crypto_library_handle)
+      {
+        _amps_crypto_library_handle = AMPS_RTLD_DEFAULT;
+      }
+    }
   }
   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 +374,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 +474,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();
@@ -484,6 +546,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.3}/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);