quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/SessionFactory.h

@@ -0,0 +1,84 @@
+/* -*- 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 "Dictionary.h"
+#include "Exceptions.h"
+#include "Log.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) EXCEPT(ConfigError);
+  void destroy(Session *pSession);
+
+private:
+  typedef std::map<std::string, std::shared_ptr<DataDictionary>> Dictionaries;
+
+  std::shared_ptr<DataDictionary> createDataDictionary(
+      const SessionID &sessionID,
+      const Dictionary &settings,
+      const std::string &settingsKey) EXCEPT(ConfigError);
+
+  void processFixtDataDictionaries(
+      const SessionID &sessionID,
+      const Dictionary &settings,
+      DataDictionaryProvider &provider) EXCEPT(ConfigError);
+
+  void processFixDataDictionary(
+      const SessionID &sessionID,
+      const Dictionary &settings,
+      DataDictionaryProvider &provider) EXCEPT(ConfigError);
+
+  std::string toApplVerID(const std::string &value);
+
+  Application &m_application;
+  MessageStoreFactory &m_messageStoreFactory;
+  LogFactory *m_pLogFactory;
+  Dictionaries m_dictionaries;
+};
+} // namespace FIX
+
+#endif

data/ext/quickfix/SessionID.h

@@ -0,0 +1,136 @@
+/* -*- 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_SESSIONID_H
+#define FIX_SESSIONID_H
+
+#include "Fields.h"
+
+namespace FIX {
+/// Unique session id consists of BeginString, SenderCompID and TargetCompID.
+class SessionID {
+public:
+  SessionID() { toString(m_frozenString); }
+
+  SessionID(
+      const std::string &beginString,
+      const std::string &senderCompID,
+      const std::string &targetCompID,
+      const std::string &sessionQualifier = "")
+      : m_beginString(BeginString(beginString)),
+        m_senderCompID(SenderCompID(senderCompID)),
+        m_targetCompID(TargetCompID(targetCompID)),
+        m_sessionQualifier(sessionQualifier),
+        m_isFIXT(false) {
+    toString(m_frozenString);
+    if (beginString.substr(0, 4) == "FIXT") {
+      m_isFIXT = true;
+    }
+  }
+
+  const BeginString &getBeginString() const { return m_beginString; }
+  const SenderCompID &getSenderCompID() const { return m_senderCompID; }
+  const TargetCompID &getTargetCompID() const { return m_targetCompID; }
+  const std::string &getSessionQualifier() const { return m_sessionQualifier; }
+  const bool isFIXT() const { return m_isFIXT; }
+
+  /// Get a string representation of the SessionID
+  std::string toString() const { return m_frozenString; }
+
+  // Return a reference for a high-performance scenario
+  const std::string &toStringFrozen() const { return m_frozenString; }
+
+  /// Build from string representation of SessionID
+  void fromString(const std::string &str) {
+    std::string::size_type first = str.find_first_of(':');
+    std::string::size_type second = str.find("->");
+    std::string::size_type third = str.find_last_of(':');
+    if (first == std::string::npos) {
+      return;
+    }
+    if (second == std::string::npos) {
+      return;
+    }
+    m_beginString = str.substr(0, first);
+    m_senderCompID = str.substr(first + 1, second - first - 1);
+    if (first == third) {
+      m_targetCompID = str.substr(second + 2);
+      m_sessionQualifier = "";
+    } else {
+      m_targetCompID = str.substr(second + 2, third - second - 2);
+      m_sessionQualifier = str.substr(third + 1);
+    }
+    toString(m_frozenString);
+  }
+
+  /// Get a string representation without making a copy
+  std::string &toString(std::string &str) const {
+    str = getBeginString().getValue() + ":" + getSenderCompID().getValue() + "->" + getTargetCompID().getValue();
+    if (m_sessionQualifier.size()) {
+      str += ":" + m_sessionQualifier;
+    }
+    return str;
+  }
+
+  friend bool operator<(const SessionID &, const SessionID &);
+  friend bool operator==(const SessionID &, const SessionID &);
+  friend bool operator!=(const SessionID &, const SessionID &);
+  friend std::ostream &operator<<(std::ostream &, const SessionID &);
+  friend std::istream &operator>>(std::istream &, SessionID &);
+
+  SessionID operator~() const {
+    return SessionID(m_beginString, SenderCompID(m_targetCompID), TargetCompID(m_senderCompID), m_sessionQualifier);
+  }
+
+private:
+  BeginString m_beginString;
+  SenderCompID m_senderCompID;
+  TargetCompID m_targetCompID;
+  std::string m_sessionQualifier;
+  bool m_isFIXT;
+  std::string m_frozenString;
+};
+/*! @} */
+
+inline bool operator<(const SessionID &lhs, const SessionID &rhs) {
+  return lhs.toStringFrozen() < rhs.toStringFrozen();
+}
+
+inline bool operator==(const SessionID &lhs, const SessionID &rhs) {
+  return lhs.toStringFrozen() == rhs.toStringFrozen();
+}
+
+inline bool operator!=(const SessionID &lhs, const SessionID &rhs) { return !(lhs == rhs); }
+
+inline std::ostream &operator<<(std::ostream &stream, const SessionID &sessionID) {
+  stream << sessionID.toStringFrozen();
+  return stream;
+}
+
+inline std::istream &operator>>(std::istream &stream, SessionID &sessionID) {
+  std::string str;
+  stream >> str;
+  sessionID.fromString(str);
+  return stream;
+}
+
+} // namespace FIX
+#endif // FIX_SESSIONID_H

data/ext/quickfix/SessionSettings.cpp

@@ -0,0 +1,165 @@
+/****************************************************************************
+** 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 "SessionSettings.h"
+#include "Settings.h"
+#include "Values.h"
+#include <fstream>
+
+namespace FIX {
+SessionSettings::SessionSettings(std::istream &stream, bool resolveEnvVars) EXCEPT(ConfigError)
+    : m_resolveEnvVars(resolveEnvVars) {
+  stream >> *this;
+}
+
+SessionSettings::SessionSettings(const std::string &file, bool resolveEnvVars) EXCEPT(ConfigError)
+    : m_resolveEnvVars(resolveEnvVars) {
+  std::ifstream fstream(file.c_str());
+  if (!fstream.is_open()) {
+    throw ConfigError(("File " + file + " not found").c_str());
+  }
+  fstream >> *this;
+}
+
+std::istream &operator>>(std::istream &stream, SessionSettings &s) EXCEPT(ConfigError) {
+  Settings settings(s.m_resolveEnvVars);
+  stream >> settings;
+
+  Settings::Sections section;
+
+  section = settings.get("DEFAULT");
+  Dictionary def;
+  if (section.size()) {
+    def = section[0];
+  }
+  s.set(def);
+
+  section = settings.get("SESSION");
+  Settings::Sections::size_type session;
+  Dictionary dict;
+
+  for (session = 0; session < section.size(); ++session) {
+    dict = section[session];
+    dict.merge(def);
+
+    BeginString beginString(dict.getString(BEGINSTRING));
+    SenderCompID senderCompID(dict.getString(SENDERCOMPID));
+    TargetCompID targetCompID(dict.getString(TARGETCOMPID));
+
+    std::string sessionQualifier;
+    if (dict.has(SESSION_QUALIFIER)) {
+      sessionQualifier = dict.getString(SESSION_QUALIFIER);
+    }
+    SessionID sessionID(beginString, senderCompID, targetCompID, sessionQualifier);
+    s.set(sessionID, dict);
+  }
+  return stream;
+}
+
+std::ostream &operator<<(std::ostream &stream, const SessionSettings &sessionSettings) {
+  const Dictionary &defaults = sessionSettings.get();
+  if (defaults.size()) {
+    stream << "[DEFAULT]" << std::endl;
+    for (const Dictionary::value_type &defaultParam : defaults) {
+      stream << defaultParam.first << "=" << defaultParam.second << std::endl;
+    }
+    stream << std::endl;
+  }
+
+  for (const SessionID &sessionID : sessionSettings.getSessions()) {
+    stream << "[SESSION]" << std::endl;
+    const Dictionary &section = sessionSettings.get(sessionID);
+    if (!section.size()) {
+      continue;
+    }
+
+    for (const Dictionary::value_type &sectionParam : section) {
+      if (defaults.has(sectionParam.first) && defaults.getString(sectionParam.first) == sectionParam.second) {
+        continue;
+      }
+      stream << sectionParam.first << "=" << sectionParam.second << std::endl;
+    }
+    stream << std::endl;
+  }
+
+  return stream;
+}
+
+const bool SessionSettings::has(const SessionID &sessionID) const {
+  return m_settings.find(sessionID) != m_settings.end();
+}
+
+const Dictionary &SessionSettings::get(const SessionID &sessionID) const EXCEPT(ConfigError) {
+  Dictionaries::const_iterator i;
+  i = m_settings.find(sessionID);
+  if (i == m_settings.end()) {
+    throw ConfigError("Session not found");
+  }
+  return i->second;
+}
+
+void SessionSettings::set(const SessionID &sessionID, Dictionary settings) EXCEPT(ConfigError) {
+  if (has(sessionID)) {
+    throw ConfigError("Duplicate Session " + sessionID.toString());
+  }
+
+  settings.setString(BEGINSTRING, sessionID.getBeginString());
+  settings.setString(SENDERCOMPID, sessionID.getSenderCompID());
+  settings.setString(TARGETCOMPID, sessionID.getTargetCompID());
+
+  settings.merge(m_defaults);
+  validate(settings);
+  m_settings[sessionID] = settings;
+}
+
+void SessionSettings::set(const Dictionary &defaults) EXCEPT(ConfigError) {
+  m_defaults = defaults;
+  for (Dictionaries::value_type &setting : m_settings) {
+    setting.second.merge(defaults);
+  }
+}
+
+std::set<SessionID> SessionSettings::getSessions() const {
+  std::set<SessionID> result;
+  for (const Dictionaries::value_type &setting : m_settings) {
+    result.insert(setting.first);
+  }
+  return result;
+}
+
+void SessionSettings::validate(const Dictionary &dictionary) const EXCEPT(ConfigError) {
+  std::string beginString = dictionary.getString(BEGINSTRING);
+  if (beginString != BeginString_FIX40 && beginString != BeginString_FIX41 && beginString != BeginString_FIX42
+      && beginString != BeginString_FIX43 && beginString != BeginString_FIX44 && beginString != BeginString_FIXT11) {
+    throw ConfigError(std::string(BEGINSTRING) + " must be FIX.4.0 to FIX.4.4 or FIXT.1.1");
+  }
+
+  std::string connectionType = dictionary.getString(CONNECTION_TYPE);
+  if (connectionType != "initiator" && connectionType != "acceptor") {
+    throw ConfigError(std::string(CONNECTION_TYPE) + " must be 'initiator' or 'acceptor'");
+  }
+}
+
+} // namespace FIX

data/ext/quickfix/SessionSettings.h

@@ -0,0 +1,283 @@
+/* -*- 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_SESSIONSETTINGS_H
+#define FIX_SESSIONSETTINGS_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Dictionary.h"
+#include "Exceptions.h"
+#include "SessionID.h"
+#include <map>
+#include <set>
+
+namespace FIX {
+const char BEGINSTRING[] = "BeginString";
+const char SENDERCOMPID[] = "SenderCompID";
+const char TARGETCOMPID[] = "TargetCompID";
+const char SESSION_QUALIFIER[] = "SessionQualifier";
+const char DEFAULT_APPLVERID[] = "DefaultApplVerID";
+const char CONNECTION_TYPE[] = "ConnectionType";
+const char USE_DATA_DICTIONARY[] = "UseDataDictionary";
+const char SEND_RESETSEQNUMFLAG[] = "SendResetSeqNumFlag";
+const char SEND_REDUNDANT_RESENDREQUESTS[] = "SendRedundantResendRequests";
+const char SEND_NEXT_EXPECTED_MSG_SEQ_NUM[] = "SendNextExpectedMsgSeqNum";
+const char DATA_DICTIONARY[] = "DataDictionary";
+const char TRANSPORT_DATA_DICTIONARY[] = "TransportDataDictionary";
+const char APP_DATA_DICTIONARY[] = "AppDataDictionary";
+const char USE_LOCAL_TIME[] = "UseLocalTime";
+const char START_TIME[] = "StartTime";
+const char END_TIME[] = "EndTime";
+const char START_DAY[] = "StartDay";
+const char END_DAY[] = "EndDay";
+const char NON_STOP_SESSION[] = "NonStopSession";
+const char LOGON_TIME[] = "LogonTime";
+const char LOGOUT_TIME[] = "LogoutTime";
+const char LOGON_DAY[] = "LogonDay";
+const char LOGOUT_DAY[] = "LogoutDay";
+const char CHECK_COMPID[] = "CheckCompID";
+const char CHECK_LATENCY[] = "CheckLatency";
+const char MAX_LATENCY[] = "MaxLatency";
+const char HEARTBTINT[] = "HeartBtInt";
+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[] = "SocketSendBufferSize";
+const char SOCKET_RECEIVE_BUFFER_SIZE[] = "SocketReceiveBufferSize";
+const char HOST_SELECTION_POLICY[] = "HostSelectionPolicy";
+const char HOST_SELECTION_POLICY_PRIORITY_START_OVER_INTERVAL[] = "HostSelectionPolicyPriorityStartOverInterval";
+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";
+const char MYSQL_STORE_USECONNECTIONPOOL[] = "MySQLStoreUseConnectionPool";
+const char MYSQL_STORE_DATABASE[] = "MySQLStoreDatabase";
+const char MYSQL_STORE_USER[] = "MySQLStoreUser";
+const char MYSQL_STORE_PASSWORD[] = "MySQLStorePassword";
+const char MYSQL_STORE_HOST[] = "MySQLStoreHost";
+const char MYSQL_STORE_PORT[] = "MySQLStorePort";
+const char POSTGRESQL_STORE_USECONNECTIONPOOL[] = "PostgreSQLStoreUseConnectionPool";
+const char POSTGRESQL_STORE_DATABASE[] = "PostgreSQLStoreDatabase";
+const char POSTGRESQL_STORE_USER[] = "PostgreSQLStoreUser";
+const char POSTGRESQL_STORE_PASSWORD[] = "PostgreSQLStorePassword";
+const char POSTGRESQL_STORE_HOST[] = "PostgreSQLStoreHost";
+const char POSTGRESQL_STORE_PORT[] = "PostgreSQLStorePort";
+const char ODBC_STORE_USER[] = "OdbcStoreUser";
+const char ODBC_STORE_PASSWORD[] = "OdbcStorePassword";
+const char ODBC_STORE_CONNECTION_STRING[] = "OdbcStoreConnectionString";
+const char FILE_LOG_PATH[] = "FileLogPath";
+const char FILE_LOG_BACKUP_PATH[] = "FileLogBackupPath";
+const char SCREEN_LOG_SHOW_INCOMING[] = "ScreenLogShowIncoming";
+const char SCREEN_LOG_SHOW_OUTGOING[] = "ScreenLogShowOutgoing";
+const char SCREEN_LOG_SHOW_EVENTS[] = "ScreenLogShowEvents";
+const char MYSQL_LOG_USECONNECTIONPOOL[] = "MySQLLogUseConnectionPool";
+const char MYSQL_LOG_DATABASE[] = "MySQLLogDatabase";
+const char MYSQL_LOG_USER[] = "MySQLLogUser";
+const char MYSQL_LOG_PASSWORD[] = "MySQLLogPassword";
+const char MYSQL_LOG_HOST[] = "MySQLLogHost";
+const char MYSQL_LOG_PORT[] = "MySQLLogPort";
+const char MYSQL_LOG_INCOMING_TABLE[] = "MySQLLogIncomingTable";
+const char MYSQL_LOG_OUTGOING_TABLE[] = "MySQLLogOutgoingTable";
+const char MYSQL_LOG_EVENT_TABLE[] = "MySQLLogEventTable";
+const char POSTGRESQL_LOG_USECONNECTIONPOOL[] = "PostgreSQLLogUseConnectionPool";
+const char POSTGRESQL_LOG_DATABASE[] = "PostgreSQLLogDatabase";
+const char POSTGRESQL_LOG_USER[] = "PostgreSQLLogUser";
+const char POSTGRESQL_LOG_PASSWORD[] = "PostgreSQLLogPassword";
+const char POSTGRESQL_LOG_HOST[] = "PostgreSQLLogHost";
+const char POSTGRESQL_LOG_PORT[] = "PostgreSQLLogPort";
+const char POSTGRESQL_LOG_INCOMING_TABLE[] = "PostgreSQLLogIncomingTable";
+const char POSTGRESQL_LOG_OUTGOING_TABLE[] = "PostgreSQLLogOutgoingTable";
+const char POSTGRESQL_LOG_EVENT_TABLE[] = "PostgreSQLLogEventTable";
+const char ODBC_LOG_USER[] = "OdbcLogUser";
+const char ODBC_LOG_PASSWORD[] = "OdbcLogPassword";
+const char ODBC_LOG_CONNECTION_STRING[] = "OdbcLogConnectionString";
+const char ODBC_LOG_INCOMING_TABLE[] = "OdbcLogIncomingTable";
+const char ODBC_LOG_OUTGOING_TABLE[] = "OdbcLogOutgoingTable";
+const char ODBC_LOG_EVENT_TABLE[] = "OdbcLogEventTable";
+const char RESET_ON_LOGON[] = "ResetOnLogon";
+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_CERTIFICATE_FILE[] = "ServerCertificateFile";
+const char SERVER_CERTIFICATE_KEY_FILE[] = "ServerCertificateKeyFile";
+const char CLIENT_CERTIFICATE_FILE[] = "ClientCertificateFile";
+const char CLIENT_CERTIFICATE_KEY_FILE[] = "ClientCertificateKeyFile";
+const char CERTIFICATE_AUTHORITIES_FILE[] = "CertificationAuthoritiesFile";
+const char CERTIFICATE_AUTHORITIES_DIRECTORY[] = "CertificationAuthoritiesDirectory";
+const char CERTIFICATE_REVOCATION_LIST_FILE[] = "CertificateRevocationListFile";
+const char CERTIFICATE_REVOCATION_LIST_DIRECTORY[] = "CertificateRevocationListDirectory";
+const char CERTIFICATE_VERIFY_LEVEL[] = "CertificateVerifyLevel";
+const char ALLOWED_REMOTE_ADDRESSES[] = "AllowedRemoteAddresses";
+/*
+# 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";
+/*
+# DISCLAIMER: This setting only work for TLSv1.2 and below
+# see: https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_cipher_list.html
+#
+# 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";
+/*
+# DISCLAIMER: This setting only work for TLSv1.3 and upper
+# see: https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_set_ciphersuites.html
+#
+# This is a simple colon (":") separated list of TLSv1.3 ciphersuite names in
+# order of preference. Valid TLSv1.3 ciphersuite names are:
+#   TLS_AES_128_GCM_SHA256
+#   TLS_AES_256_GCM_SHA384
+#   TLS_CHACHA20_POLY1305_SHA256
+#   TLS_AES_128_CCM_SHA256
+#   TLS_AES_128_CCM_8_SHA256
+#
+# An empty list is permissible. The default value for the this setting is:
+# "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256"
+*/
+const char TLS_CIPHER_SUITES[] = "TLSCipherSuites";
+
+/// Container for setting dictionaries mapped to sessions.
+class SessionSettings {
+public:
+  SessionSettings() { m_resolveEnvVars = false; }
+  SessionSettings(std::istream &stream, bool resolveEnvVars = false) EXCEPT(ConfigError);
+  SessionSettings(const std::string &file, bool resolveEnvVars = false) EXCEPT(ConfigError);
+
+  /// Check if session setings are present
+  const bool has(const SessionID &) const;
+
+  /// Get a dictionary for a session.
+  const Dictionary &get(const SessionID &) const EXCEPT(ConfigError);
+  /// Set a dictionary for a session
+  void set(const SessionID &, Dictionary) EXCEPT(ConfigError);
+
+  /// Get global default settings
+  const Dictionary &get() const { return m_defaults; }
+  /// Set global default settings
+  void set(const Dictionary &defaults) EXCEPT(ConfigError);
+
+  /// Number of session settings
+  size_t size() const { return m_settings.size(); }
+
+  typedef std::map<SessionID, Dictionary> Dictionaries;
+  std::set<SessionID> getSessions() const;
+
+private:
+  void validate(const Dictionary &) const EXCEPT(ConfigError);
+
+  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 &) EXCEPT(ConfigError);
+  friend std::ostream &operator<<(std::ostream &, const SessionSettings &);
+};
+/*! @} */
+
+std::istream &operator>>(std::istream &, SessionSettings &) EXCEPT(ConfigError);
+std::ostream &operator<<(std::ostream &, const SessionSettings &);
+} // namespace FIX
+
+#endif // FIX_SESSIONSETTINGS_H