quickfix_ruby 1.14.3.1 → 1.15.1

data/ext/quickfix/Session.h

@@ -180,9 +180,22 @@ public:
     { m_refreshOnLogon = value; } 
 
   bool getMillisecondsInTimeStamp()
-    { return m_millisecondsInTimeStamp; }
+    { return (m_timestampPrecision == 3); }
   void setMillisecondsInTimeStamp ( bool value )
-    { m_millisecondsInTimeStamp = value; }
+    { if (value)
+        m_timestampPrecision = 3;
+      else
+        m_timestampPrecision = 0;
+    }
+  int getTimestampPrecision()
+    { return m_timestampPrecision; }
+  void setTimestampPrecision(int precision)
+    {
+      if (precision < 0 || precision > 9)
+        return;
+
+      m_timestampPrecision = precision;
+    }
 
   bool getPersistMessages()
     { return m_persistMessages; }
@@ -298,6 +311,8 @@ private:
   bool set( int s, const Message& m );
   bool get( int s, Message& m ) const;
 
+  Message * newMessage(const std::string & msgType) const;
+
   Application& m_application;
   SessionID m_sessionID;
   TimeRange m_sessionTime;
@@ -313,7 +328,7 @@ private:
   bool m_resetOnLogout;
   bool m_resetOnDisconnect;
   bool m_refreshOnLogon;
-  bool m_millisecondsInTimeStamp;
+  int m_timestampPrecision;
   bool m_persistMessages;
   bool m_validateLengthAndChecksum;
 
@@ -328,7 +343,6 @@ private:
   static SessionIDs s_sessionIDs;
   static Sessions s_registered;
   static Mutex s_mutex;
-
 };
 }
 

data/ext/quickfix/SessionFactory.cpp

@@ -120,7 +120,7 @@ Session* SessionFactory::create( const SessionID& sessionID,
     if ( heartBtInt <= 0 ) throw ConfigError( "Heartbeat must be greater than zero" );
   }
 
-  std::auto_ptr<Session> pSession;
+  SmartPtr<Session> pSession;
   pSession.reset( new Session( m_application, m_messageStoreFactory,
     sessionID, dataDictionaryProvider, sessionTimeRange,
     heartBtInt, m_pLogFactory ) );
@@ -189,7 +189,9 @@ Session* SessionFactory::create( const SessionID& sessionID,
   if ( settings.has( REFRESH_ON_LOGON ) )
     pSession->setRefreshOnLogon( settings.getBool( REFRESH_ON_LOGON ) );
   if ( settings.has( MILLISECONDS_IN_TIMESTAMP ) )
-    pSession->setMillisecondsInTimeStamp( settings.getBool( MILLISECONDS_IN_TIMESTAMP ) );
+    pSession->setTimestampPrecision(3);
+  if ( settings.has( TIMESTAMP_PRECISION ) )
+    pSession->setTimestampPrecision(settings.getInt( TIMESTAMP_PRECISION ) );
   if ( settings.has( PERSIST_MESSAGES ) )
     pSession->setPersistMessages( settings.getBool( PERSIST_MESSAGES ) );
   if ( settings.has( VALIDATE_LENGTH_AND_CHECKSUM ) )
@@ -216,7 +218,10 @@ ptr::shared_ptr<DataDictionary> SessionFactory::createDataDictionary(const Sessi
   }
   else
   {
-    pDD = ptr::shared_ptr<DataDictionary>(new DataDictionary( path ));
+    bool preserveMsgFldsOrder = false;
+    if( settings.has( PRESERVE_MESSAGE_FIELDS_ORDER ) )
+      preserveMsgFldsOrder = settings.getBool( PRESERVE_MESSAGE_FIELDS_ORDER );
+    pDD = ptr::shared_ptr<DataDictionary>(new DataDictionary( path, preserveMsgFldsOrder ));
     m_dictionaries[ path ] = pDD;
   }
 
@@ -228,6 +233,8 @@ ptr::shared_ptr<DataDictionary> SessionFactory::createDataDictionary(const Sessi
     pCopyOfDD->checkFieldsHaveValues( settings.getBool( VALIDATE_FIELDS_HAVE_VALUES ) );
   if( settings.has( VALIDATE_USER_DEFINED_FIELDS ) )
     pCopyOfDD->checkUserDefinedFields( settings.getBool( VALIDATE_USER_DEFINED_FIELDS ) );
+  if( settings.has( ALLOW_UNKNOWN_MSG_FIELDS ) )
+    pCopyOfDD->allowUnknownMsgFields( settings.getBool( ALLOW_UNKNOWN_MSG_FIELDS ) );
 
   return pCopyOfDD;
 }

data/ext/quickfix/SessionSettings.cpp

@@ -30,14 +30,16 @@
 
 namespace FIX
 {
-SessionSettings::SessionSettings( std::istream& stream )
+SessionSettings::SessionSettings( std::istream& stream, bool resolveEnvVars )
 throw( ConfigError )
+: m_resolveEnvVars( resolveEnvVars )
 {
   stream >> *this;
 }
 
-SessionSettings::SessionSettings( const std::string& file )
+SessionSettings::SessionSettings( const std::string& file, bool resolveEnvVars )
 throw( ConfigError )
+: m_resolveEnvVars( resolveEnvVars )
 {
   std::ifstream fstream( file.c_str() );
   if ( !fstream.is_open() )
@@ -48,7 +50,7 @@ throw( ConfigError )
 std::istream& operator>>( std::istream& stream, SessionSettings& s )
 throw( ConfigError )
 {
-  Settings settings;
+  Settings settings(s.m_resolveEnvVars);
   stream >> settings;
 
   Settings::Sections section;

data/ext/quickfix/SessionSettings.h

@@ -63,14 +63,18 @@ const char SOCKET_ACCEPT_PORT[] = "SocketAcceptPort";
 const char SOCKET_REUSE_ADDRESS[] = "SocketReuseAddress";
 const char SOCKET_CONNECT_HOST[] = "SocketConnectHost";
 const char SOCKET_CONNECT_PORT[] = "SocketConnectPort";
+const char SOCKET_CONNECT_SOURCE_HOST[] = "SocketConnectSourceHost";
+const char SOCKET_CONNECT_SOURCE_PORT[] = "SocketConnectSourcePort";
 const char SOCKET_NODELAY[] = "SocketNodelay";
-const char SOCKET_SEND_BUFFER_SIZE[] = "SendBufferSize";
-const char SOCKET_RECEIVE_BUFFER_SIZE[] = "ReceiveBufferSize";
+const char SOCKET_SEND_BUFFER_SIZE[] = "SocketSendBufferSize";
+const char SOCKET_RECEIVE_BUFFER_SIZE[] = "SocketReceiveBufferSize";
 const char RECONNECT_INTERVAL[] = "ReconnectInterval";
 const char VALIDATE_LENGTH_AND_CHECKSUM[] = "ValidateLengthAndChecksum";
 const char VALIDATE_FIELDS_OUT_OF_ORDER[] = "ValidateFieldsOutOfOrder";
 const char VALIDATE_FIELDS_HAVE_VALUES[] = "ValidateFieldsHaveValues";
 const char VALIDATE_USER_DEFINED_FIELDS[] = "ValidateUserDefinedFields";
+const char ALLOW_UNKNOWN_MSG_FIELDS[] = "AllowUnknownMsgFields";
+const char PRESERVE_MESSAGE_FIELDS_ORDER[] = "PreserveMessageFieldsOrder";
 const char LOGON_TIMEOUT[] = "LogonTimeout";
 const char LOGOUT_TIMEOUT[] = "LogoutTimeout";
 const char FILE_STORE_PATH[] = "FileStorePath";
@@ -123,16 +127,102 @@ const char RESET_ON_LOGOUT[] = "ResetOnLogout";
 const char RESET_ON_DISCONNECT[] = "ResetOnDisconnect";
 const char REFRESH_ON_LOGON[] = "RefreshOnLogon";
 const char MILLISECONDS_IN_TIMESTAMP[] = "MillisecondsInTimeStamp";
+const char TIMESTAMP_PRECISION[] = "TimestampPrecision";
 const char HTTP_ACCEPT_PORT[] = "HttpAcceptPort";
 const char PERSIST_MESSAGES[] = "PersistMessages";
+const char SERVER_CERT_FILE[] = "ServerCertificateFile";
+const char SERVER_CERT_KEY_FILE[] = "ServerCertificateKeyFile";
+const char CLIENT_CERT_FILE[] = "ClientCertificateFile";
+const char CLIENT_CERT_KEY_FILE[] = "ClientCertificateKeyFile";
+const char CERT_AUTH_FILE[] = "CertificationAuthoritiesFile";
+const char CERT_AUTH_DIR[] = "CertificationAuthoritiesDirectory";
+const char CRL_FILE[] = "CertificateRevocationListFile";
+const char CRL_DIR[] = "CertificateRevocationListDirectory";
+const char VERIFY_LEVEL[] = "CertificateVerifyLevel";
+/*
+# This directive can be used to control the SSL protocol flavors the application
+# should use when establishing its environment.
+#
+# The available (case-insensitive) protocols are:
+#
+# SSLv2
+#
+#  This is the Secure Sockets Layer (SSL) protocol, version 2.0. It is the
+#  original SSL protocol as designed by Netscape Corporation.
+#
+# SSLv3
+#
+#  This is the Secure Sockets Layer (SSL) protocol, version 3.0. It is the
+#  successor to SSLv2 and the currently (as of February 1999) de-facto
+#  standardized SSL protocol from Netscape Corporation. It's supported by
+#  almost all popular browsers.
+#
+# TLSv1
+#
+#  This is the Transport Layer Security (TLS) protocol, version 1.0.
+#
+# TLSv1_1
+#
+#  This is the Transport Layer Security (TLS) protocol, version 1.1.
+#
+# TLSv1_2
+#
+#  This is the Transport Layer Security (TLS) protocol, version 1.2.
+#
+# all
+#
+#  This is a shortcut for `+SSLv2 +SSLv3 +TLSv1 +TLSv1_1 +TLSv1_2' and a convenient way for
+#  enabling all protocols except one when used in combination with the minus
+#  sign on a protocol as the example above shows.
+#
+# Example:
+#
+#  enable all but not SSLv2
+#  SSL_PROTOCOL = all -SSLv2
+#
+# `all -SSLv2` is the default value when the parameter is not specified.
+
+*/
+const char SSL_PROTOCOL[] = "SSLProtocol";
+/*
+# This complex directive uses a colon-separated cipher-spec string consisting
+# of OpenSSL cipher specifications to configure the Cipher Suite the client is
+# permitted to negotiate in the SSL handshake phase. Notice that this directive
+# can be used both in per-server and per-directory context. In per-server
+# context it applies to the standard SSL handshake when a connection is
+# established. In per-directory context it forces a SSL renegotation with the
+# reconfigured Cipher Suite after the HTTP request was read but before the HTTP
+# response is sent.
+#
+# An SSL cipher specification in cipher-spec is composed of 4 major attributes
+# plus a few extra minor ones:
+#
+# Key Exchange Algorithm:
+#  RSA or Diffie-Hellman variants.
+#
+# Authentication Algorithm:
+#  RSA, Diffie-Hellman, DSS or none.
+#
+# Cipher/Encryption Algorithm:
+#  DES, Triple-DES, RC4, RC2, IDEA or none.
+#
+# MAC Digest Algorithm:
+#  MD5, SHA or SHA1.
+#
+# For more details refer to mod_ssl documentation.
+#
+# Example: RC4+RSA:+HIGH:
+*/
+const char SSL_CIPHER_SUITE[] = "SSLCipherSuite";
+
 
 /// Container for setting dictionaries mapped to sessions.
 class SessionSettings
 {
 public:
-  SessionSettings() {}
-  SessionSettings( std::istream& stream ) throw( ConfigError );
-  SessionSettings( const std::string& file ) throw( ConfigError );
+  SessionSettings() { m_resolveEnvVars = false; }
+  SessionSettings( std::istream& stream, bool resolveEnvVars = false ) throw( ConfigError );
+  SessionSettings( const std::string& file, bool resolveEnvVars = false ) throw( ConfigError );
 
   /// Check if session setings are present
   const bool has( const SessionID& ) const;
@@ -158,7 +248,9 @@ private:
 
   Dictionaries m_settings;
   Dictionary m_defaults;
+  bool m_resolveEnvVars;  // while reading, replace $var, $(var) and ${var} by environment variable var
 
+  friend std::istream& operator>>( std::istream&, SessionSettings& ) throw( ConfigError );
   friend std::ostream& operator<<( std::ostream&, const SessionSettings& );
 };
 /*! @} */

data/ext/quickfix/Settings.cpp

@@ -23,6 +23,7 @@
 #include "config.h"
 #endif
 
+#include <cstring>
 #include "Settings.h"
 
 namespace FIX
@@ -61,13 +62,82 @@ std::pair<std::string, std::string> splitKeyValue( const std::string& line )
   return std::pair<std::string, std::string>( key, value );
 }
 
+std::string resolveEnvVars(const std::string& str)
+{
+  std::string resultStr;
+  size_t      actPos = 0;
+  size_t      sourceLen = str.length();
+
+  while (actPos < sourceLen)
+  {
+    char c = str[actPos++];
+    if (actPos < sourceLen)
+    {
+      // escape character
+      if (c == '\\')
+      {
+        c = str[actPos++];
+        switch (c)
+        {
+          case 't' : resultStr.append(1, '\t'); break;
+          case 'r' : resultStr.append(1, '\r'); break;
+          case 'n' : resultStr.append(1, '\n'); break;
+          default :
+            resultStr.append(1, c);
+            break;
+        }
+        continue;
+      }
+
+      // variable substitution
+      if (c == '$')
+      {
+        bool inBraces = false;
+        c = str[actPos++];
+        if ((c == '(') || (c == '{'))
+        {
+          c = str[actPos++];
+          inBraces = true;
+        }
+
+        // actPos now points at start of var name
+        if (actPos >= sourceLen)
+          break;
+        std::string varName;
+        while (  (actPos <= sourceLen) )
+        {
+          varName.append(1, c);  // this must be done before overwriting c
+          c = str[actPos++];
+          if (std::strchr(" /:;,.=\"'?#+*()[]{}$&%\t\n", c))
+            break;
+        }
+        if (inBraces && (actPos <= sourceLen) && ((c == ')') || (c == '}')))
+          ;
+        else
+          --actPos;
+        // varName contains the name of the variable,
+        // actPos points to first char _after_ variable
+        const char *varValue = 0;
+        if (!varName.empty() && (0 != (varValue = getenv(varName.c_str()))))
+          resultStr.append(varValue);
+        continue;
+      }
+    }
+
+    // nothing special, just copy
+    resultStr.append(1, c);
+  }
+
+  return resultStr;
+}
+
 std::istream& operator>>( std::istream& stream, Settings& s )
 {
   char buffer[1024];
   std::string line;
   Settings::Sections::iterator section = s.m_sections.end();;
 
-  while( stream.getline(buffer, 1024) )
+  while( stream.getline(buffer, sizeof(buffer)) )
   {
     line = string_strip( buffer );
     if( isComment(line) )
@@ -83,7 +153,7 @@ std::istream& operator>>( std::istream& stream, Settings& s )
       std::pair<std::string, std::string> keyValue = splitKeyValue( line );
       if( section == s.m_sections.end() )
         continue;
-      (*section).setString( keyValue.first, keyValue.second );
+      (*section).setString( keyValue.first, s.m_resolveEnvVars ? resolveEnvVars(keyValue.second) : keyValue.second );
     }
   }
   return stream;

data/ext/quickfix/Settings.h

@@ -38,6 +38,8 @@ namespace FIX
 class Settings
 {
 public:
+  Settings( bool resolveEnvVars = false ) : m_resolveEnvVars(resolveEnvVars) {}
+
   typedef std::vector < Dictionary > Sections;
 
   Sections get( const std::string& name ) const;
@@ -45,6 +47,7 @@ public:
   friend std::istream& operator>>( std::istream&, Settings& );
 private:
   Sections m_sections;
+  bool m_resolveEnvVars;
 };
 
 std::istream& operator>>( std::istream&, Settings& );

data/ext/quickfix/SharedArray.h

@@ -22,14 +22,21 @@
 #ifndef SHARED_ARRAY
 #define SHARED_ARRAY
 
+#include "config-all.h"
 #include "AtomicCount.h"
 
 namespace FIX
 {
   /// Shared array with atomic reference count
+#ifndef NO_UNALIGNED_ACCESS
   template<typename T>
   class shared_array
   {
+    enum
+    {
+      data_offset = ( sizeof(atomic_count) / sizeof(T) + 1 )
+    };
+
   public:
     shared_array()
     : m_size(0)
@@ -67,16 +74,16 @@ namespace FIX
     { return m_buffer == 0; }
 
     operator T* () const
-    { return m_buffer; }
+    { return &m_buffer[data_offset]; }
 
     //optimized function to allocate storage for buffer and counter object at once
     static shared_array create(const std::size_t nSize)
     {
-      if(nSize <= 0)
+      if(nSize == 0)
         return shared_array();
 
       //verify the needed buffer size to allocate counter object and nSize elements
-      const std::size_t sizeToAllocate = nSize + ( sizeof(atomic_count) / sizeof(T) + 1 );
+      const std::size_t sizeToAllocate = data_offset + nSize;
 
       //allocate and zero-fill the buffer
       T* storage = new T[ sizeToAllocate ];
@@ -84,7 +91,7 @@ namespace FIX
 
       // create the counter object at the end of the storage
       // with initial reference count set to 1
-      new (&storage[nSize]) atomic_count( 1 );
+      new (storage) atomic_count( 1 );
 
       return shared_array(storage, nSize);
     }
@@ -100,7 +107,7 @@ namespace FIX
 
     atomic_count* get_counter() const
     {
-      return reinterpret_cast<atomic_count*>( &m_buffer[ size() ] );
+      return reinterpret_cast<atomic_count*>( m_buffer );
     }
 
     void increment_reference_count() const
@@ -109,7 +116,7 @@ namespace FIX
       ++(*counter);
     }
 
-    long decrement_reference_count() 
+    long decrement_reference_count() const
     {
       atomic_count* counter = get_counter();
       return --(*counter);
@@ -145,6 +152,133 @@ namespace FIX
     std::size_t m_size;
     T * m_buffer;
   };
+#else
+  template<typename T>
+  class shared_array
+  {
+  public:
+    shared_array()
+    : m_size(0)
+    , m_buffer(0)
+    , m_pCtr(0)
+    {}
+
+    shared_array(const shared_array& rhs)
+    : m_size(rhs.m_size)
+    , m_buffer(rhs.m_buffer)
+    {
+      rhs.attach();
+    }
+
+    ~shared_array()
+    { release(); }
+
+    shared_array& operator=(const shared_array& rhs)
+    {
+      if( &rhs == this )
+        return *this;
+
+      rhs.attach();
+      release();
+
+      m_size = rhs.m_size;
+      m_buffer = rhs.m_buffer;
+      m_pCtr = rhs.m_pCtr;
+
+      return *this;
+    }
+
+    std::size_t size() const
+    { return m_size; }
+
+    bool empty() const
+    { return m_buffer == 0; }
+
+    operator T* () const
+    { return m_buffer; }
+
+    //optimized function to allocate storage for buffer and counter object at once
+    static shared_array create(const std::size_t nSize)
+    {
+      if(nSize <= 0)
+        return shared_array();
+
+      //verify the needed buffer size to allocate counter object and nSize elements
+      const std::size_t sizeToAllocate = (nSize * sizeof(T)) + sizeof(atomic_count) + 15;
+
+      //allocate and zero-fill the buffer
+      void * buf = std::malloc(sizeToAllocate);
+      memset(buf, 0, sizeToAllocate);
+
+      // create the counter object at the end of the storage
+      // with initial reference count set to 1
+      /* round up to multiple of alignment : add (alignment - 1) and then round down by masking */
+      void *ptr = (void *) (((uintptr_t)(buf) + nSize * sizeof(T) + 15) & ~ (uintptr_t)0x0F);
+      new (ptr) atomic_count( 1 );
+
+      T* storage = reinterpret_cast<T*>(buf);
+      return shared_array(storage, nSize, ptr);
+    }
+
+  private:
+
+    shared_array( T * buff, std::size_t nSize, void * pCtr )
+    : m_size(nSize)
+    , m_buffer(buff)
+    , m_pCtr(pCtr)
+    {
+
+    }
+
+    atomic_count* get_counter() const
+    {
+      return reinterpret_cast<atomic_count*>( m_pCtr );
+    }
+
+    void increment_reference_count() const
+    {
+      atomic_count* counter = get_counter();
+      ++(*counter);
+    }
+
+    long decrement_reference_count() const
+    {
+      atomic_count* counter = get_counter();
+      return --(*counter);
+    }
+
+    void attach() const
+    {
+      if( !empty() )
+        increment_reference_count();
+    }
+
+    void release()
+    {
+      if( empty() )
+        return;
+
+      //free object if reference count has decreased to zero
+      if( decrement_reference_count() == 0)
+      {
+        T * tmpBuff = m_buffer;
+        atomic_count* tmpCounter = get_counter();
+
+        m_buffer = 0;
+        m_size = 0;
+
+        //explicitly call destructor for the counter object
+        tmpCounter->~atomic_count();
+
+        std::free(tmpBuff);
+      }
+    }
+
+    std::size_t m_size;
+    T * m_buffer;
+    void  * m_pCtr;
+  };
+#endif
 }
 
 #endif