quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/Session.h

@@ -0,0 +1,343 @@
+/* -*- 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 "Application.h"
+#include "DataDictionaryProvider.h"
+#include "Fields.h"
+#include "Log.h"
+#include "Mutex.h"
+#include "Responder.h"
+#include "SessionID.h"
+#include "SessionState.h"
+#include "TimeRange.h"
+
+#include <functional>
+#include <map>
+#include <queue>
+#include <utility>
+
+namespace FIX {
+/// Maintains the state and implements the logic of a %FIX %session.
+class Session {
+public:
+  Session(
+      std::function<UtcTimeStamp()> timestamper,
+      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() EXCEPT(IOException) {
+    generateLogout();
+    disconnect();
+    m_state.reset(m_timestamper());
+  }
+  void refresh() EXCEPT(IOException) { m_state.refresh(); }
+  void setNextSenderMsgSeqNum(SEQNUM num) EXCEPT(IOException) { m_state.setNextSenderMsgSeqNum(num); }
+  void setNextTargetMsgSeqNum(SEQNUM num) EXCEPT(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 = "") EXCEPT(SessionNotFound);
+  static bool sendToTarget(Message &message, const SessionID &sessionID) EXCEPT(SessionNotFound);
+  static bool sendToTarget(
+      Message &,
+      const SenderCompID &senderCompID,
+      const TargetCompID &targetCompID,
+      const std::string &qualifier = "") EXCEPT(SessionNotFound);
+  static bool sendToTarget(
+      Message &message,
+      const std::string &senderCompID,
+      const std::string &targetCompID,
+      const std::string &qualifier = "") EXCEPT(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 &now) { return m_sessionTime.isInRange(now); }
+  bool isLogonTime(const UtcTimeStamp &now) { return m_logonTime.isInRange(now); }
+  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_timestampPrecision == 3); }
+  void setMillisecondsInTimeStamp(bool 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;
+  }
+  int getSupportedTimestampPrecision() {
+    return supportsSubSecondTimestamps(m_sessionID.getBeginString()) ? m_timestampPrecision : 0;
+  }
+  static bool supportsSubSecondTimestamps(const std::string &beginString) {
+    if (beginString == BeginString_FIXT11) {
+      return true;
+    } else {
+      return beginString >= BeginString_FIX42;
+    }
+  }
+
+  bool getPersistMessages() { return m_persistMessages; }
+  void setPersistMessages(bool value) { m_persistMessages = value; }
+
+  bool getValidateLengthAndChecksum() { return m_validateLengthAndChecksum; }
+  void setValidateLengthAndChecksum(bool value) { m_validateLengthAndChecksum = value; }
+
+  bool getSendNextExpectedMsgSeqNum() { return m_sendNextExpectedMsgSeqNum; }
+  void setSendNextExpectedMsgSeqNum(bool value) { m_sendNextExpectedMsgSeqNum = value; }
+
+  bool getIsNonStopSession() const { return m_isNonStopSession; }
+  void setIsNonStopSession(bool value) { m_isNonStopSession = value; }
+
+  const std::set<std::string> &getAllowedRemoteAddresses() const { return m_allowedRemoteAddresses; }
+  void setAllowedRemoteAddresses(const std::set<std::string> &value) { m_allowedRemoteAddresses = value; }
+  bool inAllowedRemoteAddresses(const std::string &value) const {
+    return (m_allowedRemoteAddresses.cend() != m_allowedRemoteAddresses.find(value));
+  }
+
+  void setResponder(Responder *pR) {
+    if (m_refreshOnLogon) {
+      refresh();
+    }
+    if (!checkSessionTime(m_timestamper())) {
+      reset();
+    }
+    m_pResponder = pR;
+  }
+
+  bool send(Message &);
+  void next(const UtcTimeStamp &now);
+  void next(const std::string &, const UtcTimeStamp &now, bool queued = false);
+  void next(const Message &, const UtcTimeStamp &now, bool queued = false);
+  void disconnect();
+
+  SEQNUM getExpectedSenderNum() { return m_state.getNextSenderMsgSeqNum(); }
+  SEQNUM 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 &, SEQNUM msgSeqNum = 0);
+  bool resend(Message &message);
+  void persist(const Message &, const std::string &) EXCEPT(IOException);
+
+  void insertSendingTime(Header &);
+  void insertOrigSendingTime(Header &, const UtcTimeStamp &now);
+  void fill(Header &);
+
+  bool isGoodTime(const SendingTime &sendingTime) {
+    if (!m_checkLatency) {
+      return true;
+    }
+    return labs(m_timestamper() - sendingTime) <= m_maxLatency;
+  }
+  bool checkSessionTime(const UtcTimeStamp &now) {
+    if (getIsNonStopSession()) {
+      return true;
+    }
+    UtcTimeStamp creationTime = m_state.getCreationTime();
+    return m_sessionTime.isInSameRange(now, 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 &now);
+  bool nextQueued(SEQNUM num, const UtcTimeStamp &now);
+
+  void nextLogon(const Message &, const UtcTimeStamp &now);
+  void nextHeartbeat(const Message &, const UtcTimeStamp &now);
+  void nextTestRequest(const Message &, const UtcTimeStamp &now);
+  void nextLogout(const Message &, const UtcTimeStamp &now);
+  void nextReject(const Message &, const UtcTimeStamp &now);
+  void nextSequenceReset(const Message &, const UtcTimeStamp &now);
+  void nextResendRequest(const Message &, const UtcTimeStamp &now);
+
+  void generateLogon();
+  void generateLogon(const Message &);
+  void generateResendRequest(const BeginString &, const MsgSeqNum &);
+  void generateSequenceReset(SEQNUM, SEQNUM);
+  void generateRetransmits(SEQNUM beginSeqNo, SEQNUM endSeqNo);
+  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 &text);
+  void generateBusinessReject(const Message &, int err, int field = 0);
+  void generateLogout(const std::string &text = "");
+
+  void populateRejectReason(Message &, int field, const std::string &text);
+  void populateRejectReason(Message &, const std::string &text);
+
+  bool verify(const Message &msg, bool checkTooHigh = true, bool checkTooLow = true);
+
+  Message newMessage(const MsgType &msgType) const;
+
+  std::function<UtcTimeStamp()> m_timestamper;
+  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;
+  int m_timestampPrecision;
+  bool m_persistMessages;
+  bool m_validateLengthAndChecksum;
+  bool m_sendNextExpectedMsgSeqNum;
+  bool m_isNonStopSession;
+  std::set<std::string> m_allowedRemoteAddresses;
+
+  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;
+};
+} // namespace FIX
+
+#endif // FIX_SESSION_H

data/ext/quickfix/SessionFactory.cpp

@@ -0,0 +1,314 @@
+/****************************************************************************
+** 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 "DataDictionaryProvider.h"
+#include "Session.h"
+#include "SessionFactory.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "Values.h"
+
+#include <memory>
+
+namespace FIX {
+SessionFactory::~SessionFactory() {}
+
+Session *SessionFactory::create(const SessionID &sessionID, const Dictionary &settings) EXCEPT(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);
+  }
+
+  bool isNonStopSession = false;
+  if (settings.has(NON_STOP_SESSION)) {
+    isNonStopSession = settings.getBool(NON_STOP_SESSION);
+  }
+
+  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(0, 0, 0);
+  UtcTimeOnly endTime = UtcTimeOnly(0, 0, 0);
+  try {
+    startTime = UtcTimeOnlyConvertor::convert(settings.getString(START_TIME));
+    endTime = UtcTimeOnlyConvertor::convert(settings.getString(END_TIME));
+  } catch (ConfigError &e) {
+    if (!isNonStopSession) {
+      throw e;
+    }
+  } 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");
+  }
+
+  if (isNonStopSession
+      && (startDay >= 0 || endDay >= 0 || startTime != UtcTimeOnly(0, 0, 0) || endTime != UtcTimeOnly(0, 0, 0))) {
+    throw ConfigError("NonStopSession used with StartTime/EndTime/StartDay/EndDay");
+  }
+
+  HeartBtInt heartBtInt(0);
+  if (connectionType == "initiator") {
+    heartBtInt = HeartBtInt(settings.getInt(HEARTBTINT));
+    if (heartBtInt <= 0) {
+      throw ConfigError("Heartbeat must be greater than zero");
+    }
+  }
+
+  std::unique_ptr<Session> pSession;
+  pSession.reset(new Session(
+      []() { return UtcTimeStamp::now(); },
+      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));
+  }
+  if (settings.has(SEND_NEXT_EXPECTED_MSG_SEQ_NUM)) {
+    pSession->setSendNextExpectedMsgSeqNum(settings.getBool(SEND_NEXT_EXPECTED_MSG_SEQ_NUM));
+  }
+  if (isNonStopSession) {
+    pSession->setIsNonStopSession(isNonStopSession);
+  }
+  if (settings.has(ALLOWED_REMOTE_ADDRESSES)) {
+    pSession->setAllowedRemoteAddresses(string_split(settings.getString(ALLOWED_REMOTE_ADDRESSES), ','));
+  }
+
+  return pSession.release();
+}
+
+void SessionFactory::destroy(Session *pSession) { delete pSession; }
+
+std::shared_ptr<DataDictionary> SessionFactory::createDataDictionary(
+    const SessionID &sessionID,
+    const Dictionary &settings,
+    const std::string &settingsKey) EXCEPT(ConfigError) {
+  std::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 {
+    bool preserveMsgFldsOrder = false;
+    if (settings.has(PRESERVE_MESSAGE_FIELDS_ORDER)) {
+      preserveMsgFldsOrder = settings.getBool(PRESERVE_MESSAGE_FIELDS_ORDER);
+    }
+    pDD = std::shared_ptr<DataDictionary>(new DataDictionary(path, preserveMsgFldsOrder));
+    m_dictionaries[path] = pDD;
+  }
+
+  std::shared_ptr<DataDictionary> pCopyOfDD = std::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));
+  }
+  if (settings.has(ALLOW_UNKNOWN_MSG_FIELDS)) {
+    pCopyOfDD->allowUnknownMsgFields(settings.getBool(ALLOW_UNKNOWN_MSG_FIELDS));
+  }
+
+  return pCopyOfDD;
+}
+
+void SessionFactory::processFixtDataDictionaries(
+    const SessionID &sessionID,
+    const Dictionary &settings,
+    DataDictionaryProvider &provider) EXCEPT(ConfigError) {
+  std::shared_ptr<DataDictionary> pDataDictionary
+      = createDataDictionary(sessionID, settings, TRANSPORT_DATA_DICTIONARY);
+  provider.addTransportDataDictionary(sessionID.getBeginString(), pDataDictionary);
+
+  for (const Dictionary::value_type &data : settings) {
+    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) EXCEPT(ConfigError) {
+  std::shared_ptr<DataDictionary> pDataDictionary = createDataDictionary(sessionID, settings, DATA_DICTIONARY);
+  provider.addTransportDataDictionary(sessionID.getBeginString(), pDataDictionary);
+  provider.addApplicationDataDictionary(Message::toApplVerID(sessionID.getBeginString()), pDataDictionary);
+}
+} // namespace FIX