quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/NullStore.cpp

@@ -0,0 +1,40 @@
+/****************************************************************************
+** 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 "NullStore.h"
+
+namespace FIX {
+
+MessageStore *NullStoreFactory::create(const UtcTimeStamp &now, const SessionID &) { return new NullStore(now); }
+
+void NullStoreFactory::destroy(MessageStore *pStore) { delete pStore; }
+
+bool NullStore::set(SEQNUM msgSeqNum, const std::string &msg) EXCEPT(IOException) { return true; }
+
+void NullStore::get(SEQNUM begin, SEQNUM end, std::vector<std::string> &messages) const EXCEPT(IOException) {
+  messages.clear();
+}
+
+} // namespace FIX

data/ext/quickfix/NullStore.h

@@ -0,0 +1,89 @@
+/* -*- 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_NULLSTORE_H
+#define FIX_NULLSTORE_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "MessageStore.h"
+#include "SessionSettings.h"
+#include <string>
+
+namespace FIX {
+class Session;
+
+/**
+ * Null implementation of MessageStore.
+ *
+ * Will not actually store messages.  Useful for admin-only or market
+ * data-only applications.
+ */
+class NullStoreFactory : public MessageStoreFactory {
+public:
+  MessageStore *create(const UtcTimeStamp &, const SessionID &);
+  void destroy(MessageStore *);
+};
+/*! @} */
+
+/**
+ * Null implementation of MessageStore.
+ *
+ * Will not actually store messages.  Useful for admin-only or market
+ * data-only applications.
+ */
+class NullStore : public MessageStore {
+public:
+  NullStore(const UtcTimeStamp &now)
+      : m_nextSenderMsgSeqNum(1),
+        m_nextTargetMsgSeqNum(1),
+        m_creationTime(now) {}
+
+  bool set(SEQNUM, const std::string &) EXCEPT(IOException);
+  void get(SEQNUM, SEQNUM, std::vector<std::string> &) const EXCEPT(IOException);
+
+  SEQNUM getNextSenderMsgSeqNum() const EXCEPT(IOException) { return m_nextSenderMsgSeqNum; }
+  SEQNUM getNextTargetMsgSeqNum() const EXCEPT(IOException) { return m_nextTargetMsgSeqNum; }
+  void setNextSenderMsgSeqNum(SEQNUM value) EXCEPT(IOException) { m_nextSenderMsgSeqNum = value; }
+  void setNextTargetMsgSeqNum(SEQNUM value) EXCEPT(IOException) { m_nextTargetMsgSeqNum = value; }
+  void incrNextSenderMsgSeqNum() EXCEPT(IOException) { ++m_nextSenderMsgSeqNum; }
+  void incrNextTargetMsgSeqNum() EXCEPT(IOException) { ++m_nextTargetMsgSeqNum; }
+
+  void setCreationTime(const UtcTimeStamp &creationTime) EXCEPT(IOException) { m_creationTime = creationTime; }
+  UtcTimeStamp getCreationTime() const EXCEPT(IOException) { return m_creationTime; }
+
+  void reset(const UtcTimeStamp &now) EXCEPT(IOException) {
+    m_nextSenderMsgSeqNum = 1;
+    m_nextTargetMsgSeqNum = 1;
+    m_creationTime = now;
+  }
+  void refresh() EXCEPT(IOException) {}
+
+private:
+  SEQNUM m_nextSenderMsgSeqNum;
+  SEQNUM m_nextTargetMsgSeqNum;
+  UtcTimeStamp m_creationTime;
+};
+} // namespace FIX
+
+#endif // FIX_NULLSTORE_H

data/ext/quickfix/OdbcConnection.h

@@ -0,0 +1,241 @@
+/* -*- 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 HAVE_ODBC
+#error OdbcConnection.h included, but HAVE_ODBC not defined
+#endif
+
+#ifdef HAVE_ODBC
+#ifndef FIX_ODBCCONNECTION_H
+#define FIX_ODBCCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#pragma comment(lib, "Odbc32")
+#endif
+
+#include "DatabaseConnectionID.h"
+#include "DatabaseConnectionPool.h"
+#include "Exceptions.h"
+#include "Mutex.h"
+#include "Utility.h"
+#include <sql.h>
+#include <sqlext.h>
+#include <sqltypes.h>
+#include <sstream>
+
+namespace FIX {
+
+inline std::string odbcError(SQLSMALLINT statementType, SQLHANDLE handle) {
+  SQLCHAR state[6];
+  SQLINTEGER error;
+  SQLCHAR text[SQL_MAX_MESSAGE_LENGTH];
+  SQLSMALLINT textLength;
+  RETCODE result = SQLGetDiagRec(statementType, handle, 1, state, &error, text, sizeof(text), &textLength);
+  if (result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO) {
+    return std::string((char *)text);
+  }
+  return "";
+}
+
+inline bool odbcSuccess(RETCODE result) { return result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO; }
+
+class OdbcQuery {
+public:
+  OdbcQuery(const std::string &query)
+      : m_statement(0),
+        m_result(0),
+        m_query(query) {}
+
+  ~OdbcQuery() { close(); }
+
+  void close() {
+    if (m_statement) {
+      SQLFreeHandle(SQL_HANDLE_STMT, m_statement);
+      m_statement = 0;
+      m_result = 0;
+    }
+  }
+
+  bool execute(HDBC connection) {
+    if (m_statement) {
+      SQLFreeHandle(SQL_HANDLE_STMT, m_statement);
+    }
+    SQLAllocHandle(SQL_HANDLE_STMT, connection, &m_statement);
+    m_result = SQLExecDirect(m_statement, (SQLCHAR *)m_query.c_str(), (SQLINTEGER)m_query.size());
+    if (success() || m_result == SQL_NO_DATA) {
+      return true;
+    }
+    m_reason = odbcError(SQL_HANDLE_STMT, m_statement);
+    SQLFreeHandle(SQL_HANDLE_STMT, m_statement);
+    m_statement = 0;
+    return success();
+  }
+
+  bool success() { return odbcSuccess(m_result); }
+
+  /*int rows()
+  {
+    return (int)mysql_num_rows( m_result );
+  }*/
+
+  const std::string &reason() { return m_reason; }
+
+  bool fetch() { return odbcSuccess(SQLFetch(m_statement)); }
+
+  /*char* getValue( int row, int column )
+  {
+    if( m_rows.empty() )
+    {
+      MYSQL_ROW row = 0;
+      while( row = mysql_fetch_row( m_result ) )
+        m_rows.push_back(row);
+    }
+    return m_rows[row][column];
+  }*/
+
+  HSTMT statement() { return m_statement; }
+
+  void throwException() EXCEPT(IOException) {
+    if (!success()) {
+      throw IOException("Query failed [" + m_query + "] " + reason());
+    }
+  }
+
+private:
+  HSTMT m_statement;
+  RETCODE m_result;
+  std::string m_query;
+  std::string m_reason;
+};
+
+class OdbcConnection {
+public:
+  OdbcConnection(const DatabaseConnectionID &id)
+      : m_environment(0),
+        m_connection(0),
+        m_connectionID(id) {
+    connect();
+  }
+
+  OdbcConnection(const std::string &user, const std::string &password, const std::string &connectionString)
+      : m_environment(0),
+        m_connection(0),
+        m_connectionID("", user, password, connectionString, 0) {
+    connect();
+  }
+
+  ~OdbcConnection() {
+    if (m_connection) {
+      SQLDisconnect(m_connection);
+      SQLFreeHandle(SQL_HANDLE_DBC, m_connection);
+      SQLFreeHandle(SQL_HANDLE_ENV, m_environment);
+    }
+  }
+
+  const DatabaseConnectionID &connectionID() { return m_connectionID; }
+
+  bool connected() {
+    Locker locker(m_mutex);
+    return m_connected;
+  }
+
+  bool reconnect() {
+    Locker locker(m_mutex);
+    SQLDisconnect(m_connection);
+    SQLFreeHandle(SQL_HANDLE_DBC, m_connection);
+    m_connection = 0;
+    connect();
+    return true;
+  }
+
+  bool execute(OdbcQuery &pQuery) {
+    Locker locker(m_mutex);
+    if (!pQuery.execute(m_connection)) {
+      reconnect();
+      return pQuery.execute(m_connection);
+    }
+    return true;
+  }
+
+private:
+  void connect() {
+    m_connected = false;
+
+    RETCODE result;
+    if (!m_environment) {
+      result = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_environment);
+      if (!odbcSuccess(result)) {
+        throw ConfigError("Unable to allocate ODBC environment");
+      }
+
+      result = SQLSetEnvAttr(m_environment, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0);
+      if (!odbcSuccess(result)) {
+        throw ConfigError("Unable to find ODBC version 3.0");
+      }
+    }
+
+    result = SQLAllocHandle(SQL_HANDLE_DBC, m_environment, &m_connection);
+    if (!odbcSuccess(result)) {
+      throw ConfigError("Unable to allocate ODBC connection");
+    }
+
+    std::stringstream connectionStream;
+    std::string connectionString = m_connectionID.getHost();
+    if (m_connectionID.getHost().find("UID=") == std::string::npos) {
+      connectionStream << "UID=" << m_connectionID.getUser() << ";";
+    }
+    if (m_connectionID.getHost().find("PWD=") == std::string::npos) {
+      connectionStream << "PWD=" << m_connectionID.getPassword() << ";";
+    }
+    connectionStream << m_connectionID.getHost();
+    connectionString = connectionStream.str();
+
+    SQLCHAR connectionStringOut[255];
+
+    result = SQLDriverConnect(
+        m_connection,
+        NULL,
+        (SQLCHAR *)connectionString.c_str(),
+        SQL_NTS,
+        connectionStringOut,
+        255,
+        0,
+        SQL_DRIVER_NOPROMPT);
+
+    if (!odbcSuccess(result)) {
+      std::string error = odbcError(SQL_HANDLE_DBC, m_connection);
+      throw ConfigError(error);
+    }
+
+    m_connected = true;
+  }
+
+  HENV m_environment;
+  HDBC m_connection;
+  bool m_connected;
+  DatabaseConnectionID m_connectionID;
+  Mutex m_mutex;
+};
+} // namespace FIX
+
+#endif
+#endif

data/ext/quickfix/OdbcLog.cpp

@@ -0,0 +1,230 @@
+/****************************************************************************
+** 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
+
+#ifdef HAVE_ODBC
+
+#include "OdbcLog.h"
+#include "SessionID.h"
+#include "SessionSettings.h"
+#include "Utility.h"
+#include "strptime.h"
+#include <fstream>
+
+namespace FIX {
+
+const std::string OdbcLogFactory::DEFAULT_USER = "sa";
+const std::string OdbcLogFactory::DEFAULT_PASSWORD = "";
+const std::string OdbcLogFactory::DEFAULT_CONNECTION_STRING = "DATABASE=quickfix;DRIVER={SQL Server};SERVER=(local);";
+
+OdbcLog::OdbcLog(
+    const SessionID &s,
+    const std::string &user,
+    const std::string &password,
+    const std::string &connectionString) {
+  init();
+  m_pSessionID = new SessionID(s);
+  m_pConnection = new OdbcConnection(user, password, connectionString);
+}
+
+OdbcLog::OdbcLog(const std::string &user, const std::string &password, const std::string &connectionString)
+    : m_pSessionID(0) {
+  init();
+  m_pConnection = new OdbcConnection(user, password, connectionString);
+}
+
+void OdbcLog::init() {
+  setIncomingTable("messages_log");
+  setOutgoingTable("messages_log");
+  setEventTable("event_log");
+}
+
+OdbcLog::~OdbcLog() {
+  delete m_pSessionID;
+  delete m_pConnection;
+}
+
+OdbcLogFactory::OdbcLogFactory(
+    const std::string &user,
+    const std::string &password,
+    const std::string &connectionString)
+    : m_user(user),
+      m_password(password),
+      m_connectionString(connectionString),
+      m_useSettings(false) {}
+
+OdbcLogFactory::OdbcLogFactory()
+    : m_user(DEFAULT_USER),
+      m_password(DEFAULT_PASSWORD),
+      m_connectionString(DEFAULT_CONNECTION_STRING),
+      m_useSettings(false) {}
+
+OdbcLogFactory::~OdbcLogFactory() {}
+
+Log *OdbcLogFactory::create() {
+  std::string database;
+  std::string user;
+  std::string connectionString;
+
+  init(m_settings.get(), database, user, connectionString);
+  OdbcLog *result = new OdbcLog(database, user, connectionString);
+  initLog(m_settings.get(), *result);
+  return result;
+}
+
+Log *OdbcLogFactory::create(const SessionID &s) {
+  std::string database;
+  std::string user;
+  std::string connectionString;
+
+  Dictionary settings;
+  if (m_settings.has(s)) {
+    settings = m_settings.get(s);
+  }
+
+  init(settings, database, user, connectionString);
+  OdbcLog *result = new OdbcLog(s, database, user, connectionString);
+  initLog(settings, *result);
+  return result;
+}
+
+void OdbcLogFactory::init(
+    const Dictionary &settings,
+    std::string &user,
+    std::string &password,
+    std::string &connectionString) {
+  user = DEFAULT_USER;
+  password = DEFAULT_PASSWORD;
+  connectionString = DEFAULT_CONNECTION_STRING;
+
+  if (m_useSettings) {
+    try {
+      user = settings.getString(ODBC_LOG_USER);
+    } catch (ConfigError &) {}
+
+    try {
+      password = settings.getString(ODBC_LOG_PASSWORD);
+    } catch (ConfigError &) {}
+
+    try {
+      connectionString = settings.getString(ODBC_LOG_CONNECTION_STRING);
+    } catch (ConfigError &) {}
+  } else {
+    user = m_user;
+    password = m_password;
+    connectionString = m_connectionString;
+  }
+}
+
+void OdbcLogFactory::initLog(const Dictionary &settings, OdbcLog &log) {
+  try {
+    log.setIncomingTable(settings.getString(ODBC_LOG_INCOMING_TABLE));
+  } catch (ConfigError &) {}
+
+  try {
+    log.setOutgoingTable(settings.getString(ODBC_LOG_OUTGOING_TABLE));
+  } catch (ConfigError &) {}
+
+  try {
+    log.setEventTable(settings.getString(ODBC_LOG_EVENT_TABLE));
+  } catch (ConfigError &) {}
+}
+
+void OdbcLogFactory::destroy(Log *pLog) { delete pLog; }
+
+void OdbcLog::clear() {
+  std::stringstream whereClause;
+
+  whereClause << "WHERE ";
+
+  if (m_pSessionID) {
+    whereClause << "BeginString = '" << m_pSessionID->getBeginString().getValue() << "' "
+                << "AND SenderCompID = '" << m_pSessionID->getSenderCompID().getValue() << "' "
+                << "AND TargetCompID = '" << m_pSessionID->getTargetCompID().getValue() << "' ";
+
+    if (m_pSessionID->getSessionQualifier().size()) {
+      whereClause << "AND SessionQualifier = '" << m_pSessionID->getSessionQualifier() << "'";
+    }
+  } else {
+    whereClause << "BeginString = NULL AND SenderCompID = NULL && TargetCompID = NULL";
+  }
+
+  std::stringstream incomingQuery;
+  std::stringstream outgoingQuery;
+  std::stringstream eventQuery;
+
+  incomingQuery << "DELETE FROM " << m_incomingTable << " " << whereClause.str();
+  outgoingQuery << "DELETE FROM " << m_outgoingTable << " " << whereClause.str();
+  eventQuery << "DELETE FROM " << m_eventTable << " " << whereClause.str();
+
+  OdbcQuery incoming(incomingQuery.str());
+  OdbcQuery outgoing(outgoingQuery.str());
+  OdbcQuery event(eventQuery.str());
+  m_pConnection->execute(incoming);
+  m_pConnection->execute(outgoing);
+  m_pConnection->execute(event);
+}
+
+void OdbcLog::backup() {}
+
+void OdbcLog::insert(const std::string &table, const std::string value) {
+  UtcTimeStamp time = UtcTimeStamp::now();
+  int year, month, day, hour, minute, second, millis;
+  time.getYMD(year, month, day);
+  time.getHMS(hour, minute, second, millis);
+
+  char sqlTime[100];
+  STRING_SPRINTF(sqlTime, "%d-%02d-%02d %02d:%02d:%02d.%003d", year, month, day, hour, minute, second, millis);
+
+  std::string valueCopy = value;
+  string_replace("'", "''", valueCopy);
+
+  std::stringstream queryString;
+  queryString << "INSERT INTO " << table << " "
+              << "(time, beginstring, sendercompid, targetcompid, session_qualifier, text) "
+              << "VALUES ("
+              << "{ts '" << sqlTime << "'},";
+
+  if (m_pSessionID) {
+    queryString << "'" << m_pSessionID->getBeginString().getValue() << "',"
+                << "'" << m_pSessionID->getSenderCompID().getValue() << "',"
+                << "'" << m_pSessionID->getTargetCompID().getValue() << "',";
+    if (m_pSessionID->getSessionQualifier() == "") {
+      queryString << "NULL" << ",";
+    } else {
+      queryString << "'" << m_pSessionID->getSessionQualifier() << "',";
+    }
+  } else {
+    queryString << "NULL, NULL, NULL, NULL, ";
+  }
+
+  queryString << "'" << valueCopy << "')";
+
+  OdbcQuery query(queryString.str());
+  m_pConnection->execute(query);
+}
+
+} // namespace FIX
+
+#endif

data/ext/quickfix/OdbcLog.h

@@ -0,0 +1,109 @@
+/* -*- 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 HAVE_ODBC
+#error OdbcLog.h included, but HAVE_ODBC not defined
+#endif
+
+#ifdef HAVE_ODBC
+#ifndef FIX_ODBCLOG_H
+#define FIX_ODBCLOG_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Log.h"
+#include "OdbcConnection.h"
+#include "SessionSettings.h"
+#include <fstream>
+#include <string>
+
+namespace FIX {
+/// ODBC based implementation of Log.
+class OdbcLog : public Log {
+public:
+  OdbcLog(
+      const SessionID &s,
+      const std::string &user,
+      const std::string &password,
+      const std::string &connectionString);
+  OdbcLog(const std::string &user, const std::string &password, const std::string &connectionString);
+
+  ~OdbcLog();
+
+  void clear();
+  void backup();
+  void setIncomingTable(const std::string &incomingTable) { m_incomingTable = incomingTable; }
+  void setOutgoingTable(const std::string &outgoingTable) { m_outgoingTable = outgoingTable; }
+  void setEventTable(const std::string &eventTable) { m_eventTable = eventTable; }
+
+  void onIncoming(const std::string &value) { insert(m_incomingTable, value); }
+  void onOutgoing(const std::string &value) { insert(m_outgoingTable, value); }
+  void onEvent(const std::string &value) { insert(m_eventTable, value); }
+
+private:
+  void init();
+  void insert(const std::string &table, const std::string value);
+
+  std::string m_incomingTable;
+  std::string m_outgoingTable;
+  std::string m_eventTable;
+  OdbcConnection *m_pConnection;
+  SessionID *m_pSessionID;
+};
+
+/// Creates a ODBC based implementation of Log.
+class OdbcLogFactory : public LogFactory {
+public:
+  static const std::string DEFAULT_USER;
+  static const std::string DEFAULT_PASSWORD;
+  static const std::string DEFAULT_CONNECTION_STRING;
+
+  OdbcLogFactory(const SessionSettings &settings)
+      : m_settings(settings),
+        m_useSettings(true) {}
+
+  OdbcLogFactory(const std::string &user, const std::string &password, const std::string &connectionString);
+
+  OdbcLogFactory();
+
+  ~OdbcLogFactory();
+
+  Log *create();
+  Log *create(const SessionID &);
+  void destroy(Log *);
+
+private:
+  void init(const Dictionary &settings, std::string &user, std::string &password, std::string &connectionString);
+
+  void initLog(const Dictionary &settings, OdbcLog &log);
+
+  SessionSettings m_settings;
+  std::string m_user;
+  std::string m_password;
+  std::string m_connectionString;
+  bool m_useSettings;
+};
+} // namespace FIX
+
+#endif
+#endif