quickfix_ruby 1.14.3.1 → 1.15.1

data/ext/quickfix/HttpConnection.cpp

@@ -66,7 +66,7 @@ bool HttpConnection::read()
     if( result > 0 ) // Something to read
     {
       // We can read without blocking
-      ssize_t size = recv( m_socket, m_buffer, sizeof(m_buffer), 0 );
+      ssize_t size = socket_recv( m_socket, m_buffer, sizeof(m_buffer) );
       if ( size <= 0 ) { throw SocketRecvFailed( size ); }
       m_parser.addToStream( m_buffer, size );
     }

data/ext/quickfix/Initiator.cpp

@@ -231,7 +231,13 @@ void Initiator::stop( bool force )
 
   std::vector<Session*> enabledSessions;
 
-  SessionIDs connected = m_connected;
+  SessionIDs connected;
+
+  {
+    Locker l(m_mutex);
+    connected = m_connected;
+  }
+
   SessionIDs::iterator i = connected.begin();
   for ( ; i != connected.end(); ++i )
   {

data/ext/quickfix/Initiator.h

@@ -135,7 +135,9 @@ private:
   thread_id m_threadid;
   Application& m_application;
   MessageStoreFactory& m_messageStoreFactory;
+protected:
   SessionSettings m_settings;
+private:
   LogFactory* m_pLogFactory;
   Log* m_pLog;
   NullLog m_nullLog;

data/ext/quickfix/Log.h

@@ -115,14 +115,14 @@ public:
 class ScreenLog : public Log
 {
 public:
-  ScreenLog( bool incoming, bool outgoing, bool event ) 
+  ScreenLog( bool incoming, bool outgoing, bool event )
 : m_prefix( "GLOBAL" ),
-  m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ), m_millisecondsInTimeStamp( true ) {}
+  m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ) {}
 
   ScreenLog( const SessionID& sessionID,
              bool incoming, bool outgoing, bool event )
 : m_prefix( sessionID.toString() ),
-  m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ), m_millisecondsInTimeStamp( true ) {}
+  m_incoming( incoming ), m_outgoing( outgoing ), m_event( event ) {}
 
   void clear() {}
   void backup() {}
@@ -132,7 +132,7 @@ public:
     if ( !m_incoming ) return ;
     Locker l( s_mutex );
     m_time.setCurrent();
-    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, m_millisecondsInTimeStamp)
+    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, 9)
               << ", " << m_prefix
               << ", " << "incoming>" << std::endl
               << "  (" << value << ")" << std::endl;
@@ -143,7 +143,7 @@ public:
     if ( !m_outgoing ) return ;
     Locker l( s_mutex );
     m_time.setCurrent();
-    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, m_millisecondsInTimeStamp)
+    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, 9)
               << ", " << m_prefix
               << ", " << "outgoing>" << std::endl
               << "  (" << value << ")" << std::endl;
@@ -154,17 +154,12 @@ public:
     if ( !m_event ) return ;
     Locker l( s_mutex );
     m_time.setCurrent();
-    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, m_millisecondsInTimeStamp)
+    std::cout << "<" << UtcTimeStampConvertor::convert(m_time, 9)
               << ", " << m_prefix
               << ", " << "event>" << std::endl
               << "  (" << value << ")" << std::endl;
   }
 
-  bool getMillisecondsInTimeStamp() const
-  { return m_millisecondsInTimeStamp; }
-  void setMillisecondsInTimeStamp ( bool value )
-  { m_millisecondsInTimeStamp = value; }
-
 private:
   std::string m_prefix;
   UtcTimeStamp m_time;
@@ -172,7 +167,6 @@ private:
   bool m_outgoing;
   bool m_event;
   static Mutex s_mutex;
-  bool m_millisecondsInTimeStamp;
 };
 }
 

data/ext/quickfix/Message.cpp

@@ -30,14 +30,31 @@
 
 namespace FIX
 {
-std::auto_ptr<DataDictionary> Message::s_dataDictionary;
+
+int const headerOrder[] =
+{
+  FIELD::BeginString,
+  FIELD::BodyLength,
+  FIELD::MsgType
+};
+
+SmartPtr<DataDictionary> Message::s_dataDictionary;
 
 Message::Message()
-: m_validStructure( true ) {}
+: m_validStructure( true )
+, m_tag( 0 )
+{
+  
+}
+
+Message::Message(const message_order &hdrOrder, const message_order &trlOrder, const message_order& order)
+: FieldMap(order), m_header(hdrOrder),
+  m_trailer(trlOrder), m_validStructure( true ) {}
 
 Message::Message( const std::string& string, bool validate )
 throw( InvalidMessage )
 : m_validStructure( true )
+, m_tag( 0 )
 {
   setString( string, validate );
 }
@@ -47,6 +64,7 @@ Message::Message( const std::string& string,
                   bool validate )
 throw( InvalidMessage )
 : m_validStructure( true )
+, m_tag( 0 )
 {
   setString( string, validate, &dataDictionary, &dataDictionary );
 }
@@ -57,6 +75,34 @@ Message::Message( const std::string& string,
                   bool validate )
 throw( InvalidMessage )
 : m_validStructure( true )
+, m_tag( 0 )
+{
+    setString( string, validate, &sessionDataDictionary, &applicationDataDictionary );
+}
+
+Message::Message( const message_order &hdrOrder,
+                  const message_order &trlOrder,
+                  const message_order& order,
+                  const std::string& string,
+                  const DataDictionary& dataDictionary,
+                  bool validate )
+throw( InvalidMessage )
+: FieldMap(order), m_header(hdrOrder),
+  m_trailer(trlOrder), m_validStructure( true )
+{
+  setString( string, validate, &dataDictionary, &dataDictionary );
+}
+
+Message::Message( const message_order &hdrOrder,
+                  const message_order &trlOrder,
+                  const message_order& order,
+                  const std::string& string,
+                  const DataDictionary& sessionDataDictionary,
+                  const DataDictionary& applicationDataDictionary,
+                  bool validate )
+throw( InvalidMessage )
+: FieldMap(order), m_header(hdrOrder),
+  m_trailer(trlOrder), m_validStructure( true )
 {
   setStringHeader( string );
   if( isAdmin() )
@@ -65,13 +111,36 @@ throw( InvalidMessage )
     setString( string, validate, &sessionDataDictionary, &applicationDataDictionary );
 }
 
+Message::Message( const BeginString& beginString, const MsgType& msgType )
+: m_validStructure(true)
+, m_tag( 0 )
+{
+  m_header.setField(beginString);
+  m_header.setField(msgType);
+}
+
+Message::Message(const Message& copy)
+: FieldMap(copy)
+, m_header(copy.m_header)
+, m_trailer(copy.m_trailer)
+, m_validStructure(copy.m_validStructure)
+, m_tag(copy.m_tag)
+#ifdef HAVE_EMX
+, m_subMsgType(copy.m_subMsgType)
+#endif
+{
+
+}
+
+Message::~Message()
+{
+}
+
 bool Message::InitializeXML( const std::string& url )
 {
   try
   {
-    std::auto_ptr<DataDictionary> p =
-      std::auto_ptr<DataDictionary>(new DataDictionary(url));
-    s_dataDictionary = p;
+    s_dataDictionary.reset(new DataDictionary(url));
     return true;
   }
   catch( ConfigError& )
@@ -85,9 +154,9 @@ void Message::reverseRoute( const Header& header )
   SenderCompID senderCompID;
   TargetCompID targetCompID;
 
-  m_header.removeField( beginString.getField() );
-  m_header.removeField( senderCompID.getField() );
-  m_header.removeField( targetCompID.getField() );
+  m_header.removeField( beginString.getTag() );
+  m_header.removeField( senderCompID.getTag() );
+  m_header.removeField( targetCompID.getTag() );
 
   if( header.getFieldIfSet( beginString ) )
   {
@@ -97,8 +166,8 @@ void Message::reverseRoute( const Header& header )
     OnBehalfOfLocationID onBehalfOfLocationID;
     DeliverToLocationID deliverToLocationID;
 
-    m_header.removeField( onBehalfOfLocationID.getField() );
-    m_header.removeField( deliverToLocationID.getField() );
+    m_header.removeField( onBehalfOfLocationID.getTag() );
+    m_header.removeField( deliverToLocationID.getTag() );
 
     if( beginString >= BeginString_FIX41 )
     {
@@ -134,10 +203,10 @@ void Message::reverseRoute( const Header& header )
   DeliverToCompID deliverToCompID;
   DeliverToSubID deliverToSubID;
 
-  m_header.removeField( onBehalfOfCompID.getField() );
-  m_header.removeField( onBehalfOfSubID.getField() );
-  m_header.removeField( deliverToCompID.getField() );
-  m_header.removeField( deliverToSubID.getField() );
+  m_header.removeField( onBehalfOfCompID.getTag() );
+  m_header.removeField( onBehalfOfSubID.getTag() );
+  m_header.removeField( deliverToCompID.getTag() );
+  m_header.removeField( deliverToSubID.getTag() );
 
   if( header.getFieldIfSet( onBehalfOfCompID ) )
   {
@@ -169,7 +238,8 @@ std::string Message::toString( int beginStringField,
                                int checkSumField ) const
 {
   std::string str;
-  return toString( str, beginStringField, bodyLengthField, checkSumField );
+  toString( str, beginStringField, bodyLengthField, checkSumField );
+  return str;
 }
 
 std::string& Message::toString( std::string& str, 
@@ -200,7 +270,8 @@ std::string& Message::toString( std::string& str,
 std::string Message::toXML() const
 {
   std::string str;
-  return toXML( str );
+  toXML( str );
+  return str;
 }
 
 std::string& Message::toXML( std::string& str ) const
@@ -224,12 +295,12 @@ std::string& Message::toXML( std::string& str ) const
 std::string Message::toXMLFields(const FieldMap& fields, int space) const
 {
   std::stringstream stream;
-  FieldMap::iterator i;
+  FieldMap::const_iterator i;
   std::string name;
   for(i = fields.begin(); i != fields.end(); ++i)
   {
-    int field = i->first;
-    std::string value = i->second.getString();
+    int field = i->getTag();
+    std::string value = i->getString();
 
     stream << std::setw(space) << " " << "<field ";
     if(s_dataDictionary.get() && s_dataDictionary->getFieldName(field, name))
@@ -247,7 +318,7 @@ std::string Message::toXMLFields(const FieldMap& fields, int space) const
     stream << "</field>" << std::endl;
   }
 
-  FieldMap::g_iterator j;
+  FieldMap::g_const_iterator j;
   for(j = fields.g_begin(); j != fields.g_end(); ++j)
   {
     std::vector<FieldMap*>::const_iterator k;
@@ -272,35 +343,50 @@ throw( InvalidMessage )
 
   std::string::size_type pos = 0;
   int count = 0;
-  std::string msg;
 
-  static int const headerOrder[] =
-  {
-    FIELD::BeginString,
-    FIELD::BodyLength,
-    FIELD::MsgType
-  };
+  FIX::MsgType msg;
 
   field_type type = header;
 
   while ( pos < string.size() )
   {
     FieldBase field = extractField( string, pos, pSessionDataDictionary, pApplicationDataDictionary );
-    if ( count < 3 && headerOrder[ count++ ] != field.getField() )
+    if ( count < 3 && headerOrder[ count++ ] != field.getTag() )
       if ( doValidation ) throw InvalidMessage("Header fields out of order");
 
     if ( isHeaderField( field, pSessionDataDictionary ) )
     {
       if ( type != header )
       {
-        if(m_field == 0) m_field = field.getField();
+        if(m_tag == 0) m_tag = field.getTag();
         m_validStructure = false;
       }
 
-      if ( field.getField() == FIELD::MsgType )
-        msg = field.getString();
+      if ( field.getTag() == FIELD::MsgType )
+      {
+        msg.setString( field.getString() );
+        if ( isAdminMsgType( msg ) )
+        {
+          pApplicationDataDictionary = pSessionDataDictionary;
+#ifdef HAVE_EMX
+          m_subMsgType.assign(msg);
+        }
+        else
+        {
+          std::string::size_type equalSign = string.find("\0019426=", pos);
+          if (equalSign == std::string::npos)
+            throw InvalidMessage("EMX message type (9426) not found");
+
+          equalSign += 6;
+          std::string::size_type soh = string.find_first_of('\001', equalSign);
+          if (soh == std::string::npos)
+            throw InvalidMessage("EMX message type (9426) soh char not found");
+          m_subMsgType.assign(string.substr(equalSign, soh - equalSign ));
+#endif
+        }
+      }
 
-      m_header.setField( field, false );
+      m_header.appendField( field );
 
       if ( pSessionDataDictionary )
         setGroup( "_header_", field, string, pos, getHeader(), *pSessionDataDictionary );
@@ -308,7 +394,7 @@ throw( InvalidMessage )
     else if ( isTrailerField( field, pSessionDataDictionary ) )
     {
       type = trailer;
-      m_trailer.setField( field, false );
+      m_trailer.appendField( field );
 
       if ( pSessionDataDictionary )
         setGroup( "_trailer_", field, string, pos, getTrailer(), *pSessionDataDictionary );
@@ -317,18 +403,27 @@ throw( InvalidMessage )
     {
       if ( type == trailer )
       {
-        if(m_field == 0) m_field = field.getField();
+        if(m_tag == 0) m_tag = field.getTag();
         m_validStructure = false;
       }
 
       type = body;
-      setField( field, false );
+      appendField( field );
 
       if ( pApplicationDataDictionary )
+#ifdef HAVE_EMX
+        setGroup(m_subMsgType, field, string, pos, *this, *pApplicationDataDictionary);
+#else
         setGroup( msg, field, string, pos, *this, *pApplicationDataDictionary );
+#endif
     }
   }
 
+  // sort fields
+  m_header.sortFields();
+  sortFields();
+  m_trailer.sortFields();
+
   if ( doValidation )
     validate();
 }
@@ -338,11 +433,11 @@ void Message::setGroup( const std::string& msg, const FieldBase& field,
                         std::string::size_type& pos, FieldMap& map,
                         const DataDictionary& dataDictionary )
 {
-  int group = field.getField();
+  int group = field.getTag();
   int delim;
   const DataDictionary* pDD = 0;
   if ( !dataDictionary.getGroup( msg, group, delim, pDD ) ) return ;
-  std::auto_ptr<Group> pGroup;
+  SmartPtr<Group> pGroup;
 
   while ( pos < string.size() )
   {
@@ -351,17 +446,17 @@ void Message::setGroup( const std::string& msg, const FieldBase& field,
        
     // Start a new group because...
     if (// found delimiter
-    (field.getField() == delim) ||
+    (field.getTag() == delim) ||
     // no delimiter, but field belongs to group OR field already processed
-    (pDD->isField( field.getField() ) && (pGroup.get() == 0 || pGroup->isSetField( field.getField() )) ))
+    (pDD->isField( field.getTag() ) && (pGroup.get() == 0 || pGroup->isSetField( field.getTag() )) ))
     {
       if ( pGroup.get() )
       {
         map.addGroupPtr( group, pGroup.release(), false );
       }
-      pGroup.reset( new Group( field.getField(), delim, pDD->getOrderedFields() ) );
+      pGroup.reset( new Group( field.getTag(), delim, pDD->getOrderedFields() ) );
     }
-    else if ( !pDD->isField( field.getField() ) )
+    else if ( !pDD->isField( field.getTag() ) )
     {
       if ( pGroup.get() )
       {
@@ -372,7 +467,7 @@ void Message::setGroup( const std::string& msg, const FieldBase& field,
     }
 
     if ( !pGroup.get() ) return ;
-    pGroup->setField( field, false );
+    pGroup->addField( field );
     setGroup( msg, field, string, pos, *pGroup, *pDD );
   }
 }
@@ -387,13 +482,15 @@ bool Message::setStringHeader( const std::string& string )
   while ( pos < string.size() )
   {
     FieldBase field = extractField( string, pos );
-    if ( count < 3 && headerOrder[ count++ ] != field.getField() )
+    if ( count < 3 && headerOrder[ count++ ] != field.getTag() )
       return false;
 
     if ( isHeaderField( field ) )
-      m_header.setField( field, false );
+      m_header.appendField( field );
     else break;
   }
+
+  m_header.sortFields();
   return true;
 }
 
@@ -439,8 +536,14 @@ bool Message::isHeaderField( int field )
 bool Message::isHeaderField( const FieldBase& field,
                              const DataDictionary* pD )
 {
-  if ( isHeaderField( field.getField() ) ) return true;
-  if ( pD ) return pD->isHeaderField( field.getField() );
+  return isHeaderField( field.getTag(), pD );
+}
+
+bool Message::isHeaderField( int field, 
+                             const DataDictionary * pD )
+{
+  if ( isHeaderField( field ) ) return true;
+  if ( pD ) return pD->isHeaderField( field );
   return false;
 }
 
@@ -460,8 +563,13 @@ bool Message::isTrailerField( int field )
 bool Message::isTrailerField( const FieldBase& field,
                               const DataDictionary* pD )
 {
-  if ( isTrailerField( field.getField() ) ) return true;
-  if ( pD ) return pD->isTrailerField( field.getField() );
+  return isTrailerField( field.getTag(), pD );
+}
+
+bool Message::isTrailerField( int field, const DataDictionary * pD )
+{
+  if ( isTrailerField( field ) ) return true;
+  if ( pD ) return pD->isTrailerField( field );
   return false;
 }
 
@@ -486,7 +594,7 @@ void Message::setSessionID( const SessionID& sessionID )
   getHeader().setField( sessionID.getTargetCompID() );
 }
 
-void Message::validate()
+void Message::validate() const
 {
   try
   {
@@ -530,7 +638,7 @@ void Message::validate()
 
 FIX::FieldBase Message::extractField( const std::string& string, std::string::size_type& pos, 
                                       const DataDictionary* pSessionDD /*= 0*/, const DataDictionary* pAppDD /*= 0*/, 
-                                      const Group* pGroup /*= 0*/ )
+                                      const Group* pGroup /*= 0*/ ) const
 {
   std::string::const_iterator const tagStart = string.begin() + pos;
   std::string::const_iterator const strEnd = string.end();
@@ -540,7 +648,8 @@ FIX::FieldBase Message::extractField( const std::string& string, std::string::si
     throw InvalidMessage("Equal sign not found in field");
 
   int field = 0;
-  IntConvertor::convert( tagStart, equalSign, field );
+  if( !IntConvertor::convert( tagStart, equalSign, field ) )
+    throw InvalidMessage( std::string("Field tag is invalid: ") + std::string( tagStart, equalSign ));
 
   std::string::const_iterator const valueStart = equalSign + 1;
 
@@ -555,20 +664,39 @@ FIX::FieldBase Message::extractField( const std::string& string, std::string::si
     // Special case for Signature which violates above assumption.
     if ( field == FIELD::Signature ) lenField = FIELD::SignatureLength;
 
-    if ( pGroup && pGroup->isSetField( lenField ) )
+    // identify part of the message that should contain length field
+    const FieldMap * location = pGroup;
+    if ( !location )
+    {
+      if ( isHeaderField( lenField, pSessionDD ) )
+        location = &m_header;
+      else if ( isTrailerField( lenField, pSessionDD ) )
+        location = &m_trailer;
+      else
+        location = this;
+    }
+
+    try
+    {
+      const FieldBase& fieldLength = location->reverse_find( lenField );
+      soh = valueStart + IntConvertor::convert( fieldLength.getString() );
+    }
+    catch( FieldNotFound& )
     {
-      const std::string& fieldLength = pGroup->getField( lenField );
-      soh = valueStart + atol( fieldLength.c_str() );
+      throw InvalidMessage( std::string( "Data length field " ) + IntConvertor::convert( lenField ) + std::string( " was not found for data field " ) + IntConvertor::convert( field ) );
     }
-    else if ( isSetField( lenField ) )
+    catch( FieldConvertError& e )
     {
-      const std::string& fieldLength = getField( lenField );
-      soh = valueStart + atol( fieldLength.c_str() );
+      throw InvalidMessage( std::string( "Unable to determine SOH for data field " ) + IntConvertor::convert( field ) + std::string( ": " ) + e.what() );
     }
   }
 
   std::string::const_iterator const tagEnd = soh + 1;
+#if defined(__SUNPRO_CC)
+  std::distance( string.begin(), tagEnd, pos );
+#else
   pos = std::distance( string.begin(), tagEnd );
+#endif
 
   return FieldBase (
     field,
@@ -577,4 +705,5 @@ FIX::FieldBase Message::extractField( const std::string& string, std::string::si
     tagStart, 
     tagEnd );
 }
+
 }