quickfix_ruby 1.14.3

data/ext/quickfix/Session.h

@@ -0,0 +1,335 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_SESSION_H
+#define FIX_SESSION_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "SessionState.h"
+#include "TimeRange.h"
+#include "SessionID.h"
+#include "Responder.h"
+#include "Fields.h"
+#include "DataDictionaryProvider.h"
+#include "Application.h"
+#include "Mutex.h"
+#include "Log.h"
+#include <utility>
+#include <map>
+#include <queue>
+
+namespace FIX
+{
+/// Maintains the state and implements the logic of a %FIX %session.
+class Session
+{
+public:
+  Session( Application&, MessageStoreFactory&,
+           const SessionID&,
+           const DataDictionaryProvider&,
+           const TimeRange&,
+           int heartBtInt, LogFactory* pLogFactory );
+  virtual ~Session();
+
+  void logon() 
+  { m_state.enabled( true ); m_state.logoutReason( "" ); }
+  void logout( const std::string& reason = "" ) 
+  { m_state.enabled( false ); m_state.logoutReason( reason ); }
+  bool isEnabled() 
+  { return m_state.enabled(); }
+
+  bool sentLogon() { return m_state.sentLogon(); }
+  bool sentLogout() { return m_state.sentLogout(); }
+  bool receivedLogon() { return m_state.receivedLogon(); }
+  bool isLoggedOn() { return receivedLogon() && sentLogon(); }
+  void reset() throw( IOException ) 
+  { generateLogout(); disconnect(); m_state.reset(); }
+  void refresh() throw( IOException )
+  { m_state.refresh(); }
+  void setNextSenderMsgSeqNum( int num ) throw( IOException )
+  { m_state.setNextSenderMsgSeqNum( num ); }
+  void setNextTargetMsgSeqNum( int num ) throw( IOException )
+  { m_state.setNextTargetMsgSeqNum( num ); }
+
+  const SessionID& getSessionID() const
+  { return m_sessionID; }
+  void setDataDictionaryProvider( const DataDictionaryProvider& dataDictionaryProvider )
+  { m_dataDictionaryProvider = dataDictionaryProvider; }
+  const DataDictionaryProvider& getDataDictionaryProvider() const
+  { return m_dataDictionaryProvider; }
+
+  static bool sendToTarget( Message& message,
+                            const std::string& qualifier = "" )
+  throw( SessionNotFound );
+  static bool sendToTarget( Message& message, const SessionID& sessionID )
+  throw( SessionNotFound );
+  static bool sendToTarget( Message&,
+                            const SenderCompID& senderCompID,
+                            const TargetCompID& targetCompID,
+                            const std::string& qualifier = "" )
+  throw( SessionNotFound );
+  static bool sendToTarget( Message& message,
+                            const std::string& senderCompID,
+                            const std::string& targetCompID,
+                            const std::string& qualifier = "" )
+  throw( SessionNotFound );
+
+  static std::set<SessionID> getSessions();
+  static bool doesSessionExist( const SessionID& );
+  static Session* lookupSession( const SessionID& );
+  static Session* lookupSession( const std::string&, bool reverse = false );
+  static bool isSessionRegistered( const SessionID& );
+  static Session* registerSession( const SessionID& );
+  static void unregisterSession( const SessionID& );
+
+  static size_t numSessions();
+
+  bool isSessionTime(const UtcTimeStamp& time)
+    { return m_sessionTime.isInRange(time); }
+  bool isLogonTime(const UtcTimeStamp& time)
+    { return m_logonTime.isInRange(time); }
+  bool isInitiator()
+    { return m_state.initiate(); }
+  bool isAcceptor()
+    { return !m_state.initiate(); }
+
+  const TimeRange& getLogonTime()
+    { return m_logonTime; }
+  void setLogonTime( const TimeRange& value )
+    { m_logonTime = value; }
+
+  const std::string& getSenderDefaultApplVerID()
+    { return m_senderDefaultApplVerID; }
+  void setSenderDefaultApplVerID( const std::string& senderDefaultApplVerID )
+    { m_senderDefaultApplVerID = senderDefaultApplVerID; }
+
+  const std::string& getTargetDefaultApplVerID()
+    { return m_targetDefaultApplVerID; }
+  void setTargetDefaultApplVerID( const std::string& targetDefaultApplVerID )
+    { m_targetDefaultApplVerID = targetDefaultApplVerID; }
+
+  bool getSendRedundantResendRequests()
+    { return m_sendRedundantResendRequests; }
+  void setSendRedundantResendRequests ( bool value )
+    { m_sendRedundantResendRequests = value; } 
+
+  bool getCheckCompId()
+    { return m_checkCompId; }
+  void setCheckCompId ( bool value )
+    { m_checkCompId = value; }
+
+  bool getCheckLatency()
+    { return m_checkLatency; }
+  void setCheckLatency ( bool value )
+    { m_checkLatency = value; }
+
+  int getMaxLatency()
+    { return m_maxLatency; }
+  void setMaxLatency ( int value )
+    { m_maxLatency = value; }
+
+  int getLogonTimeout()
+    { return m_state.logonTimeout(); }
+  void setLogonTimeout ( int value )
+    { m_state.logonTimeout( value ); }
+
+  int getLogoutTimeout()
+    { return m_state.logoutTimeout(); }
+  void setLogoutTimeout ( int value )
+    { m_state.logoutTimeout( value ); }
+
+  bool getResetOnLogon()
+    { return m_resetOnLogon; }
+  void setResetOnLogon ( bool value )
+    { m_resetOnLogon = value; }
+
+  bool getResetOnLogout()
+    { return m_resetOnLogout; }
+  void setResetOnLogout ( bool value )
+    { m_resetOnLogout = value; }
+
+  bool getResetOnDisconnect()
+    { return m_resetOnDisconnect; }
+  void setResetOnDisconnect( bool value )
+    { m_resetOnDisconnect = value; }
+
+  bool getRefreshOnLogon()
+    { return m_refreshOnLogon; }
+  void setRefreshOnLogon( bool value )
+    { m_refreshOnLogon = value; } 
+
+  bool getMillisecondsInTimeStamp()
+    { return m_millisecondsInTimeStamp; }
+  void setMillisecondsInTimeStamp ( bool value )
+    { m_millisecondsInTimeStamp = value; }
+
+  bool getPersistMessages()
+    { return m_persistMessages; }
+  void setPersistMessages ( bool value )
+    { m_persistMessages = value; }
+
+  bool getValidateLengthAndChecksum()
+    { return m_validateLengthAndChecksum; }
+  void setValidateLengthAndChecksum ( bool value )
+    { m_validateLengthAndChecksum = value; }
+
+  void setResponder( Responder* pR )
+  {
+    if( !checkSessionTime(UtcTimeStamp()) )
+      reset();
+    m_pResponder = pR;
+  }
+
+  bool send( Message& );
+  void next();
+  void next( const UtcTimeStamp& timeStamp );
+  void next( const std::string&, const UtcTimeStamp& timeStamp, bool queued = false );
+  void next( const Message&, const UtcTimeStamp& timeStamp, bool queued = false );
+  void disconnect();
+
+  int getExpectedSenderNum() { return m_state.getNextSenderMsgSeqNum(); }
+  int getExpectedTargetNum() { return m_state.getNextTargetMsgSeqNum(); }
+
+  Log* getLog() { return &m_state; }
+  const MessageStore* getStore() { return &m_state; }
+
+private:
+  typedef std::map < SessionID, Session* > Sessions;
+  typedef std::set < SessionID > SessionIDs;
+
+  static bool addSession( Session& );
+  static void removeSession( Session& );
+
+  bool send( const std::string& );
+  bool sendRaw( Message&, int msgSeqNum = 0 );
+  bool resend( Message& message );
+  void persist( const Message&, const std::string& ) throw ( IOException );
+
+  void insertSendingTime( Header& );
+  void insertOrigSendingTime( Header&,
+                              const UtcTimeStamp& when = UtcTimeStamp () );
+  void fill( Header& );
+
+  bool isGoodTime( const SendingTime& sendingTime )
+  {
+    if ( !m_checkLatency ) return true;
+    UtcTimeStamp now;
+    return labs( now - sendingTime ) <= m_maxLatency;
+  }
+  bool checkSessionTime( const UtcTimeStamp& timeStamp )
+  {
+    UtcTimeStamp creationTime = m_state.getCreationTime();
+    return m_sessionTime.isInSameRange( timeStamp, creationTime );
+  }
+  bool isTargetTooHigh( const MsgSeqNum& msgSeqNum )
+  { return msgSeqNum > ( m_state.getNextTargetMsgSeqNum() ); }
+  bool isTargetTooLow( const MsgSeqNum& msgSeqNum )
+  { return msgSeqNum < ( m_state.getNextTargetMsgSeqNum() ); }
+  bool isCorrectCompID( const SenderCompID& senderCompID,
+                        const TargetCompID& targetCompID )
+  {
+    if( !m_checkCompId ) return true;
+
+    return
+      m_sessionID.getSenderCompID().getValue() == targetCompID.getValue()
+      && m_sessionID.getTargetCompID().getValue() == senderCompID.getValue();
+  }
+  bool shouldSendReset();
+
+  bool validLogonState( const MsgType& msgType );
+  void fromCallback( const MsgType& msgType, const Message& msg,
+                     const SessionID& sessionID );
+
+  void doBadTime( const Message& msg );
+  void doBadCompID( const Message& msg );
+  bool doPossDup( const Message& msg );
+  bool doTargetTooLow( const Message& msg );
+  void doTargetTooHigh( const Message& msg );
+  void nextQueued( const UtcTimeStamp& timeStamp );
+  bool nextQueued( int num, const UtcTimeStamp& timeStamp );
+
+  void nextLogon( const Message&, const UtcTimeStamp& timeStamp );
+  void nextHeartbeat( const Message&, const UtcTimeStamp& timeStamp );
+  void nextTestRequest( const Message&, const UtcTimeStamp& timeStamp );
+  void nextLogout( const Message&, const UtcTimeStamp& timeStamp );
+  void nextReject( const Message&, const UtcTimeStamp& timeStamp );
+  void nextSequenceReset( const Message&, const UtcTimeStamp& timeStamp );
+  void nextResendRequest( const Message&, const UtcTimeStamp& timeStamp );
+
+  void generateLogon();
+  void generateLogon( const Message& );
+  void generateResendRequest( const BeginString&, const MsgSeqNum& );
+  void generateSequenceReset( int, int );
+  void generateHeartbeat();
+  void generateHeartbeat( const Message& );
+  void generateTestRequest( const std::string& );
+  void generateReject( const Message&, int err, int field = 0 );
+  void generateReject( const Message&, const std::string& );
+  void generateBusinessReject( const Message&, int err, int field = 0 );
+  void generateLogout( const std::string& text = "" );
+
+  void populateRejectReason( Message&, int field, const std::string& );
+  void populateRejectReason( Message&, const std::string& );
+
+  bool verify( const Message& msg,
+               bool checkTooHigh = true, bool checkTooLow = true );
+
+  bool set( int s, const Message& m );
+  bool get( int s, Message& m ) const;
+
+  Application& m_application;
+  SessionID m_sessionID;
+  TimeRange m_sessionTime;
+  TimeRange m_logonTime;
+
+  std::string m_senderDefaultApplVerID;
+  std::string m_targetDefaultApplVerID;
+  bool m_sendRedundantResendRequests;
+  bool m_checkCompId;
+  bool m_checkLatency;
+  int m_maxLatency;
+  bool m_resetOnLogon;
+  bool m_resetOnLogout;
+  bool m_resetOnDisconnect;
+  bool m_refreshOnLogon;
+  bool m_millisecondsInTimeStamp;
+  bool m_persistMessages;
+  bool m_validateLengthAndChecksum;
+
+  SessionState m_state;
+  DataDictionaryProvider m_dataDictionaryProvider;
+  MessageStoreFactory& m_messageStoreFactory;
+  LogFactory* m_pLogFactory;
+  Responder* m_pResponder;
+  Mutex m_mutex;
+
+  static Sessions s_sessions;
+  static SessionIDs s_sessionIDs;
+  static Sessions s_registered;
+  static Mutex s_mutex;
+
+};
+}
+
+#endif //FIX_SESSION_H

data/ext/quickfix/SessionFactory.cpp

@@ -0,0 +1,274 @@
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifdef _MSC_VER
+#include "stdafx.h"
+#else
+#include "config.h"
+#endif
+
+#include "Utility.h"
+#include "Values.h"
+#include "DataDictionaryProvider.h"
+#include "SessionFactory.h"
+#include "SessionSettings.h"
+#include "Session.h"
+
+#include <memory>
+
+namespace FIX
+{
+SessionFactory::~SessionFactory()
+{
+}
+
+Session* SessionFactory::create( const SessionID& sessionID,
+                                 const Dictionary& settings ) throw( ConfigError )
+{
+  std::string connectionType = settings.getString( CONNECTION_TYPE );
+  if ( connectionType != "acceptor" && connectionType != "initiator" )
+    throw ConfigError( "Invalid ConnectionType" );
+
+  if( connectionType == "acceptor" && settings.has(SESSION_QUALIFIER) )
+    throw ConfigError( "SessionQualifier cannot be used with acceptor." );
+
+  bool useDataDictionary = true;
+  if ( settings.has( USE_DATA_DICTIONARY ) )
+    useDataDictionary = settings.getBool( USE_DATA_DICTIONARY );
+
+  std::string defaultApplVerID;
+  if( sessionID.isFIXT() )
+  {
+    if( !settings.has(DEFAULT_APPLVERID) )
+    {
+      throw ConfigError("ApplVerID is required for FIXT transport");
+    }
+    defaultApplVerID = Message::toApplVerID( settings.getString(DEFAULT_APPLVERID) );
+  }
+
+  DataDictionaryProvider dataDictionaryProvider;
+  if( useDataDictionary )
+  {
+    if( sessionID.isFIXT() )
+    {
+      processFixtDataDictionaries(sessionID, settings, dataDictionaryProvider);
+    }
+    else
+    {
+      processFixDataDictionary(sessionID, settings, dataDictionaryProvider);
+    }
+  }
+
+  bool useLocalTime = false;
+  if( settings.has(USE_LOCAL_TIME) )
+    useLocalTime = settings.getBool( USE_LOCAL_TIME );
+
+  int startDay = -1;
+  int endDay = -1;
+  try
+  {
+    startDay = settings.getDay( START_DAY );
+    endDay = settings.getDay( END_DAY );
+  }
+  catch( ConfigError & ) {}
+  catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
+
+  UtcTimeOnly startTime;
+  UtcTimeOnly endTime;
+  try
+  {
+    startTime = UtcTimeOnlyConvertor::convert
+                ( settings.getString( START_TIME ) );
+    endTime = UtcTimeOnlyConvertor::convert
+              ( settings.getString( END_TIME ) );
+  }
+  catch ( FieldConvertError & e ) { throw ConfigError( e.what() ); }
+
+  TimeRange utcSessionTime
+    ( startTime, endTime, startDay, endDay );
+  TimeRange localSessionTime
+    ( LocalTimeOnly(startTime.getHour(), startTime.getMinute(), startTime.getSecond()),
+      LocalTimeOnly(endTime.getHour(), endTime.getMinute(), endTime.getSecond()),
+      startDay, endDay );
+  TimeRange sessionTimeRange = useLocalTime ? localSessionTime : utcSessionTime;
+
+  if( startDay >= 0 && endDay < 0 )
+    throw ConfigError( "StartDay used without EndDay" );
+  if( endDay >= 0 && startDay < 0 )
+    throw ConfigError( "EndDay used without StartDay" );
+
+  HeartBtInt heartBtInt( 0 );
+  if ( connectionType == "initiator" )
+  {
+    heartBtInt = HeartBtInt( settings.getInt( HEARTBTINT ) );
+    if ( heartBtInt <= 0 ) throw ConfigError( "Heartbeat must be greater than zero" );
+  }
+
+  std::auto_ptr<Session> pSession;
+  pSession.reset( new Session( m_application, m_messageStoreFactory,
+    sessionID, dataDictionaryProvider, sessionTimeRange,
+    heartBtInt, m_pLogFactory ) );
+
+  pSession->setSenderDefaultApplVerID(defaultApplVerID);
+
+  int logonDay = startDay;
+  int logoutDay = endDay;
+  try
+  {
+    logonDay = settings.getDay( LOGON_DAY );
+    logoutDay = settings.getDay( LOGOUT_DAY );
+  }
+  catch( ConfigError & ) {}
+  catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
+
+  UtcTimeOnly logonTime( startTime );
+  UtcTimeOnly logoutTime( endTime );
+  try
+  {
+    logonTime = UtcTimeOnlyConvertor::convert
+                ( settings.getString( LOGON_TIME ) );
+  }
+  catch( ConfigError & ) {}
+  catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
+  try
+  {
+    logoutTime = UtcTimeOnlyConvertor::convert
+              ( settings.getString( LOGOUT_TIME ) );
+  }
+  catch( ConfigError & ) {}
+  catch( FieldConvertError & e ) { throw ConfigError( e.what() ); }
+
+  TimeRange utcLogonTime
+    ( logonTime, logoutTime, logonDay, logoutDay );
+  TimeRange localLogonTime
+    ( LocalTimeOnly(logonTime.getHour(), logonTime.getMinute(), logonTime.getSecond()),
+      LocalTimeOnly(logoutTime.getHour(), logoutTime.getMinute(), logoutTime.getSecond()),
+      logonDay, logoutDay );
+  TimeRange logonTimeRange = useLocalTime ? localLogonTime : utcLogonTime;
+
+  if( !sessionTimeRange.isInRange(logonTime, logonDay) )
+    throw ConfigError( "LogonTime must be between StartTime and EndTime" );
+  if( !sessionTimeRange.isInRange(logoutTime, logoutDay) )
+    throw ConfigError( "LogoutTime must be between StartTime and EndTime" );
+  pSession->setLogonTime( logonTimeRange );
+
+  if ( settings.has( SEND_REDUNDANT_RESENDREQUESTS ) )
+    pSession->setSendRedundantResendRequests( settings.getBool( SEND_REDUNDANT_RESENDREQUESTS ) );
+  if ( settings.has( CHECK_COMPID ) )
+    pSession->setCheckCompId( settings.getBool( CHECK_COMPID ) );
+  if ( settings.has( CHECK_LATENCY ) )
+    pSession->setCheckLatency( settings.getBool( CHECK_LATENCY ) );
+  if ( settings.has( MAX_LATENCY ) )
+    pSession->setMaxLatency( settings.getInt( MAX_LATENCY ) );
+  if ( settings.has( LOGON_TIMEOUT ) )
+    pSession->setLogonTimeout( settings.getInt( LOGON_TIMEOUT ) );
+  if ( settings.has( LOGOUT_TIMEOUT ) )
+    pSession->setLogoutTimeout( settings.getInt( LOGOUT_TIMEOUT ) );
+  if ( settings.has( RESET_ON_LOGON ) )
+    pSession->setResetOnLogon( settings.getBool( RESET_ON_LOGON ) );
+  if ( settings.has( RESET_ON_LOGOUT ) )
+    pSession->setResetOnLogout( settings.getBool( RESET_ON_LOGOUT ) );
+  if ( settings.has( RESET_ON_DISCONNECT ) )
+    pSession->setResetOnDisconnect( settings.getBool( RESET_ON_DISCONNECT ) );
+  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 ) );
+  if ( settings.has( PERSIST_MESSAGES ) )
+    pSession->setPersistMessages( settings.getBool( PERSIST_MESSAGES ) );
+  if ( settings.has( VALIDATE_LENGTH_AND_CHECKSUM ) )
+    pSession->setValidateLengthAndChecksum( settings.getBool( VALIDATE_LENGTH_AND_CHECKSUM ) );
+   
+  return pSession.release();
+}
+
+void SessionFactory::destroy( Session* pSession )
+{
+  delete pSession;
+}
+
+ptr::shared_ptr<DataDictionary> SessionFactory::createDataDictionary(const SessionID& sessionID, 
+                                                                     const Dictionary& settings, 
+                                                                     const std::string& settingsKey) throw(ConfigError)
+{
+  ptr::shared_ptr<DataDictionary> pDD;
+  std::string path = settings.getString( settingsKey );
+  Dictionaries::iterator i = m_dictionaries.find( path );
+  if ( i != m_dictionaries.end() )
+  {
+    pDD = i->second;
+  }
+  else
+  {
+    pDD = ptr::shared_ptr<DataDictionary>(new DataDictionary( path ));
+    m_dictionaries[ path ] = pDD;
+  }
+
+  ptr::shared_ptr<DataDictionary> pCopyOfDD = ptr::shared_ptr<DataDictionary>(new DataDictionary(*pDD));
+
+  if( settings.has( VALIDATE_FIELDS_OUT_OF_ORDER ) )
+    pCopyOfDD->checkFieldsOutOfOrder( settings.getBool( VALIDATE_FIELDS_OUT_OF_ORDER ) );
+  if( settings.has( VALIDATE_FIELDS_HAVE_VALUES ) )
+    pCopyOfDD->checkFieldsHaveValues( settings.getBool( VALIDATE_FIELDS_HAVE_VALUES ) );
+  if( settings.has( VALIDATE_USER_DEFINED_FIELDS ) )
+    pCopyOfDD->checkUserDefinedFields( settings.getBool( VALIDATE_USER_DEFINED_FIELDS ) );
+
+  return pCopyOfDD;
+}
+
+void SessionFactory::processFixtDataDictionaries(const SessionID& sessionID, 
+                                                 const Dictionary& settings, 
+                                                 DataDictionaryProvider& provider) throw(ConfigError)
+{
+  ptr::shared_ptr<DataDictionary> pDataDictionary = createDataDictionary(sessionID, settings, TRANSPORT_DATA_DICTIONARY);
+  provider.addTransportDataDictionary(sessionID.getBeginString(), pDataDictionary);
+  
+  for(Dictionary::const_iterator data = settings.begin(); data != settings.end(); ++data)
+  {
+    const std::string& key = data->first;
+    const std::string frontKey = key.substr(0, strlen(APP_DATA_DICTIONARY));
+    if( frontKey == string_toUpper(APP_DATA_DICTIONARY) )
+    {
+      if( key == string_toUpper(APP_DATA_DICTIONARY) )
+      {
+        provider.addApplicationDataDictionary(Message::toApplVerID(settings.getString(DEFAULT_APPLVERID)),
+            createDataDictionary(sessionID, settings, APP_DATA_DICTIONARY));
+      }
+      else
+      {
+        std::string::size_type offset = key.find('.');
+        if( offset == std::string::npos )
+          throw ConfigError(std::string("Malformed ") + APP_DATA_DICTIONARY + ": " + key);
+        std::string beginStringQualifier = key.substr(offset+1);
+        provider.addApplicationDataDictionary(Message::toApplVerID(beginStringQualifier), 
+            createDataDictionary(sessionID, settings, key));
+      }
+    }
+  }
+}
+
+void SessionFactory::processFixDataDictionary(const SessionID& sessionID, 
+                                              const Dictionary& settings, 
+                                              DataDictionaryProvider& provider) throw(ConfigError)
+{
+  ptr::shared_ptr<DataDictionary> pDataDictionary = createDataDictionary(sessionID, settings, DATA_DICTIONARY);
+  provider.addTransportDataDictionary(sessionID.getBeginString(), pDataDictionary);
+  provider.addApplicationDataDictionary(Message::toApplVerID(sessionID.getBeginString()), pDataDictionary);
+}
+}

data/ext/quickfix/SessionFactory.h

@@ -0,0 +1,86 @@
+/* -*- C++ -*- */
+
+/****************************************************************************
+** Copyright (c) 2001-2014
+**
+** This file is part of the QuickFIX FIX Engine
+**
+** This file may be distributed under the terms of the quickfixengine.org
+** license as defined by quickfixengine.org and appearing in the file
+** LICENSE included in the packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.quickfixengine.org/LICENSE for licensing information.
+**
+** Contact ask@quickfixengine.org if any conditions of this licensing are
+** not clear to you.
+**
+****************************************************************************/
+
+#ifndef FIX_SESSIONFACTORY_H
+#define FIX_SESSIONFACTORY_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Log.h"
+#include "Exceptions.h"
+#include "Dictionary.h"
+
+namespace FIX
+{
+class SessionID;
+class Session;
+class Application;
+class MessageStoreFactory;
+class DataDictionaryProvider;
+
+/** Responsible for creating Session objects.  This factory will use
+ *  QuickFIX SessionID, Dictionary settings, MessageStoreFactory, and
+ *  optional LogFactory to create all the required sessions for an
+ *  Application.
+ */
+class SessionFactory
+{
+public:
+  SessionFactory( Application& application,
+                  MessageStoreFactory& messageStoreFactory,
+                  LogFactory* pLogFactory )
+: m_application( application ),
+  m_messageStoreFactory( messageStoreFactory ),
+  m_pLogFactory( pLogFactory ) {}
+
+  ~SessionFactory();
+
+  Session* create( const SessionID& sessionID,
+                   const Dictionary& settings ) throw( ConfigError );
+  void destroy( Session* pSession );
+
+private:
+  typedef std::map < std::string, ptr::shared_ptr<DataDictionary> > Dictionaries;
+
+  ptr::shared_ptr<DataDictionary> createDataDictionary(const SessionID& sessionID, 
+                                                       const Dictionary& settings, 
+                                                       const std::string& settingsKey) throw(ConfigError);
+
+  void processFixtDataDictionaries(const SessionID& sessionID, 
+                                   const Dictionary& settings, 
+                                   DataDictionaryProvider& provider) throw(ConfigError);
+
+  void processFixDataDictionary(const SessionID& sessionID, 
+                                const Dictionary& settings, 
+                                DataDictionaryProvider& provider) throw(ConfigError);
+
+  std::string toApplVerID(const std::string& value);
+
+  Application& m_application;
+  MessageStoreFactory& m_messageStoreFactory;
+  LogFactory* m_pLogFactory;
+  Dictionaries m_dictionaries;
+};
+}
+
+#endif