quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/SharedArray.h

@@ -0,0 +1,274 @@
+/* -*- 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 SHARED_ARRAY
+#define SHARED_ARRAY
+
+#include "config-all.h"
+
+#include <atomic>
+#include <cstdlib>
+#include <cstring>
+#include <new>
+
+namespace FIX {
+/// Shared array with atomic reference count
+#ifndef NO_UNALIGNED_ACCESS
+template <typename T> class shared_array {
+  enum {
+    data_offset = (sizeof(std::atomic<long>) / sizeof(T) + 1)
+  };
+
+public:
+  shared_array()
+      : m_size(0),
+        m_buffer(0) {}
+
+  shared_array(const shared_array &rhs)
+      : m_size(rhs.m_size),
+        m_buffer(rhs.m_buffer) {
+    rhs.attach();
+  }
+
+  shared_array(shared_array &&rhs)
+      : m_size(rhs.m_size),
+        m_buffer(rhs.m_buffer) {
+    rhs.m_size = 0;
+    rhs.m_buffer = 0;
+  }
+
+  ~shared_array() { release(); }
+
+  shared_array &operator=(shared_array &&rhs) noexcept {
+    if (&rhs == this) {
+      return *this;
+    }
+
+    release();
+
+    m_size = rhs.m_size;
+    m_buffer = rhs.m_buffer;
+
+    rhs.m_size = 0;
+    rhs.m_buffer = 0;
+
+    return *this;
+  }
+
+  shared_array &operator=(const shared_array &rhs) {
+    if (&rhs == this) {
+      return *this;
+    }
+
+    rhs.attach();
+    release();
+
+    m_size = rhs.m_size;
+    m_buffer = rhs.m_buffer;
+
+    return *this;
+  }
+
+  std::size_t size() const { return m_size; }
+
+  bool empty() const { return m_buffer == 0; }
+
+  operator T *() const { return &m_buffer[data_offset]; }
+
+  // optimized function to allocate storage for buffer and counter object at once
+  static shared_array create(const std::size_t nSize) {
+    if (nSize == 0) {
+      return shared_array();
+    }
+
+    // verify the needed buffer size to allocate counter object and nSize elements
+    const std::size_t sizeToAllocate = data_offset + nSize;
+
+    // allocate and zero-fill the buffer
+    T *storage = new T[sizeToAllocate];
+    memset(reinterpret_cast<void *>(storage), 0, sizeToAllocate * sizeof(T));
+
+    // create the counter object at the end of the storage
+    // with initial reference count set to 1
+    new (storage) std::atomic<long>(1);
+
+    return shared_array(storage, nSize);
+  }
+
+private:
+  shared_array(T *buff, std::size_t nSize)
+      : m_size(nSize),
+        m_buffer(buff) {}
+
+  std::atomic<long> *get_counter() const { return reinterpret_cast<std::atomic<long> *>(m_buffer); }
+
+  void increment_reference_count() const {
+    std::atomic<long> *counter = get_counter();
+    ++(*counter);
+  }
+
+  long decrement_reference_count() const {
+    std::atomic<long> *counter = get_counter();
+    return --(*counter);
+  }
+
+  void attach() const {
+    if (!empty()) {
+      increment_reference_count();
+    }
+  }
+
+  void release() {
+    if (empty()) {
+      return;
+    }
+
+    // free object if reference count has decreased to zero
+    if (decrement_reference_count() == 0) {
+      T *tmpBuff = m_buffer;
+      std::atomic<long> *tmpCounter = get_counter();
+
+      m_buffer = 0;
+      m_size = 0;
+
+      // explicitly call destructor for the counter object
+      tmpCounter->~atomic<long>();
+
+      delete[] tmpBuff;
+    }
+  }
+
+  std::size_t m_size;
+  T *m_buffer;
+};
+#else
+template <typename T> class shared_array {
+public:
+  shared_array()
+      : m_size(0),
+        m_buffer(0),
+        m_pCtr(0) {}
+
+  shared_array(const shared_array &rhs)
+      : m_size(rhs.m_size),
+        m_buffer(rhs.m_buffer),
+        m_pCtr(rhs.m_pCtr) {
+    rhs.attach();
+  }
+
+  ~shared_array() { release(); }
+
+  shared_array &operator=(const shared_array &rhs) {
+    if (&rhs == this) {
+      return *this;
+    }
+
+    rhs.attach();
+    release();
+
+    m_size = rhs.m_size;
+    m_buffer = rhs.m_buffer;
+    m_pCtr = rhs.m_pCtr;
+
+    return *this;
+  }
+
+  std::size_t size() const { return m_size; }
+
+  bool empty() const { return m_buffer == 0; }
+
+  operator T *() const { return m_buffer; }
+
+  // optimized function to allocate storage for buffer and counter object at once
+  static shared_array create(const std::size_t nSize) {
+    if (nSize <= 0) {
+      return shared_array();
+    }
+
+    // verify the needed buffer size to allocate counter object and nSize elements
+    const std::size_t sizeToAllocate = (nSize * sizeof(T)) + sizeof(std::atomic<long>) + 15;
+
+    // allocate and zero-fill the buffer
+    void *buf = std::malloc(sizeToAllocate);
+    memset(buf, 0, sizeToAllocate);
+
+    // create the counter object at the end of the storage
+    // with initial reference count set to 1
+    /* round up to multiple of alignment : add (alignment - 1) and then round down by masking */
+    void *ptr = (void *)(((uintptr_t)(buf) + nSize * sizeof(T) + 15) & ~(uintptr_t)0x0F);
+    new (ptr) std::atomic<long>(1);
+
+    T *storage = reinterpret_cast<T *>(buf);
+    return shared_array(storage, nSize, ptr);
+  }
+
+private:
+  shared_array(T *buff, std::size_t nSize, void *pCtr)
+      : m_size(nSize),
+        m_buffer(buff),
+        m_pCtr(pCtr) {}
+
+  std::atomic<long> *get_counter() const { return reinterpret_cast<std::atomic<long> *>(m_pCtr); }
+
+  void increment_reference_count() const {
+    std::atomic<long> *counter = get_counter();
+    ++(*counter);
+  }
+
+  long decrement_reference_count() const {
+    std::atomic<long> *counter = get_counter();
+    return --(*counter);
+  }
+
+  void attach() const {
+    if (!empty()) {
+      increment_reference_count();
+    }
+  }
+
+  void release() {
+    if (empty()) {
+      return;
+    }
+
+    // free object if reference count has decreased to zero
+    if (decrement_reference_count() == 0) {
+      T *tmpBuff = m_buffer;
+      std::atomic<long> *tmpCounter = get_counter();
+
+      m_buffer = 0;
+      m_size = 0;
+
+      // explicitly call destructor for the counter object
+      tmpCounter->~atomic<long>();
+
+      std::free(tmpBuff);
+    }
+  }
+
+  std::size_t m_size;
+  T *m_buffer;
+  void *m_pCtr;
+};
+#endif
+} // namespace FIX
+
+#endif

data/ext/quickfix/SocketAcceptor.cpp

@@ -0,0 +1,216 @@
+/****************************************************************************
+** 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 "Exceptions.h"
+#include "Session.h"
+#include "Settings.h"
+#include "SocketAcceptor.h"
+#include "Utility.h"
+
+namespace FIX {
+SocketAcceptor::SocketAcceptor(Application &application, MessageStoreFactory &factory, const SessionSettings &settings)
+    EXCEPT(ConfigError)
+    : Acceptor(application, factory, settings),
+      m_pServer(0) {}
+
+SocketAcceptor::SocketAcceptor(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings,
+    LogFactory &logFactory) EXCEPT(ConfigError)
+    : Acceptor(application, factory, settings, logFactory),
+      m_pServer(0) {}
+
+SocketAcceptor::~SocketAcceptor() {
+  SocketConnections::iterator iter;
+  for (iter = m_connections.begin(); iter != m_connections.end(); ++iter) {
+    delete iter->second;
+  }
+}
+
+void SocketAcceptor::onConfigure(const SessionSettings &sessionSettings) EXCEPT(ConfigError) {
+  for (const SessionID &sessionID : sessionSettings.getSessions()) {
+    const Dictionary &settings = sessionSettings.get(sessionID);
+    settings.getInt(SOCKET_ACCEPT_PORT);
+    if (settings.has(SOCKET_REUSE_ADDRESS)) {
+      settings.getBool(SOCKET_REUSE_ADDRESS);
+    }
+    if (settings.has(SOCKET_NODELAY)) {
+      settings.getBool(SOCKET_NODELAY);
+    }
+  }
+}
+
+void SocketAcceptor::onInitialize(const SessionSettings &sessionSettings) EXCEPT(RuntimeError) {
+  uint16_t port = 0;
+
+  try {
+    m_pServer = new SocketServer(1);
+
+    for (const SessionID &sessionID : sessionSettings.getSessions()) {
+      const Dictionary &settings = sessionSettings.get(sessionID);
+      port = (short)settings.getInt(SOCKET_ACCEPT_PORT);
+
+      const bool reuseAddress = settings.has(SOCKET_REUSE_ADDRESS) ? settings.getBool(SOCKET_REUSE_ADDRESS) : true;
+
+      const bool noDelay = settings.has(SOCKET_NODELAY) ? settings.getBool(SOCKET_NODELAY) : false;
+
+      const int sendBufSize = settings.has(SOCKET_SEND_BUFFER_SIZE) ? settings.getInt(SOCKET_SEND_BUFFER_SIZE) : 0;
+
+      const int rcvBufSize = settings.has(SOCKET_RECEIVE_BUFFER_SIZE) ? settings.getInt(SOCKET_RECEIVE_BUFFER_SIZE) : 0;
+
+      socket_handle acceptSocket = m_pServer->add(port, reuseAddress, noDelay, sendBufSize, rcvBufSize);
+      m_portToSessions[socket_hostport(acceptSocket)].insert(sessionID);
+      m_sessionToPort[sessionID] = socket_hostport(acceptSocket);
+    }
+  } catch (SocketException &e) {
+    delete m_pServer;
+    m_pServer = 0;
+    throw RuntimeError(
+        "Unable to create, bind, or listen to port " + IntConvertor::convert((unsigned short)port) + " (" + e.what()
+        + ")");
+  }
+}
+
+void SocketAcceptor::onStart() {
+  while (!isStopped() && m_pServer && m_pServer->block(*this)) {}
+
+  if (!m_pServer) {
+    return;
+  }
+
+  time_t start = 0;
+  time_t now = 0;
+
+  ::time(&start);
+  while (isLoggedOn()) {
+    m_pServer->block(*this);
+    if (::time(&now) - 5 >= start) {
+      break;
+    }
+  }
+
+  m_pServer->close();
+  delete m_pServer;
+  m_pServer = 0;
+}
+
+bool SocketAcceptor::onPoll() {
+  if (!m_pServer) {
+    return false;
+  }
+
+  time_t start = 0;
+  time_t now = 0;
+
+  if (isStopped()) {
+    if (start == 0) {
+      ::time(&start);
+    }
+    if (!isLoggedOn()) {
+      start = 0;
+      return false;
+    }
+    if (::time(&now) - 5 >= start) {
+      start = 0;
+      return false;
+    }
+  }
+
+  m_pServer->block(*this, true);
+  return true;
+}
+
+void SocketAcceptor::onStop() {
+  if (m_pServer) {
+    m_pServer->close();
+  }
+}
+
+void SocketAcceptor::onConnect(SocketServer &server, socket_handle a, socket_handle s) {
+  if (!socket_isValid(s)) {
+    return;
+  }
+  SocketConnections::iterator i = m_connections.find(s);
+  if (i != m_connections.end()) {
+    return;
+  }
+  uint16_t port = server.socketToPort(a);
+  Sessions sessions = m_portToSessions[port];
+  m_connections[s] = new SocketConnection(s, sessions, &server.getMonitor());
+
+  std::stringstream stream;
+  stream << "Accepted connection from " << socket_peername(s) << " on port " << port;
+
+  if (getLog()) {
+    getLog()->onEvent(stream.str());
+  }
+}
+
+void SocketAcceptor::onWrite(SocketServer &server, socket_handle s) {
+  SocketConnections::iterator i = m_connections.find(s);
+  if (i == m_connections.end()) {
+    return;
+  }
+  SocketConnection *pSocketConnection = i->second;
+  if (pSocketConnection->processQueue()) {
+    pSocketConnection->unsignal();
+  }
+}
+
+bool SocketAcceptor::onData(SocketServer &server, socket_handle s) {
+  SocketConnections::iterator i = m_connections.find(s);
+  if (i == m_connections.end()) {
+    return false;
+  }
+  SocketConnection *pSocketConnection = i->second;
+  return pSocketConnection->read(*this, server);
+}
+
+void SocketAcceptor::onDisconnect(SocketServer &, socket_handle s) {
+  SocketConnections::iterator i = m_connections.find(s);
+  if (i == m_connections.end()) {
+    return;
+  }
+  SocketConnection *pSocketConnection = i->second;
+
+  Session *pSession = pSocketConnection->getSession();
+  if (pSession) {
+    pSession->disconnect();
+  }
+
+  delete pSocketConnection;
+  m_connections.erase(s);
+}
+
+void SocketAcceptor::onError(SocketServer &) {}
+
+void SocketAcceptor::onTimeout(SocketServer &) {
+  SocketConnections::iterator i;
+  for (i = m_connections.begin(); i != m_connections.end(); ++i) {
+    i->second->onTimeout();
+  }
+}
+} // namespace FIX

data/ext/quickfix/SocketAcceptor.h

@@ -0,0 +1,77 @@
+/* -*- 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_SOCKETACCEPTOR_H
+#define FIX_SOCKETACCEPTOR_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Acceptor.h"
+#include "SocketConnection.h"
+#include "SocketServer.h"
+
+namespace FIX {
+/// Socket implementation of Acceptor.
+class SocketAcceptor : public Acceptor, SocketServer::Strategy {
+  friend class SocketConnection;
+
+public:
+  typedef std::map<SessionID, uint16_t> SessionToPort;
+
+  SocketAcceptor(Application &, MessageStoreFactory &, const SessionSettings &) EXCEPT(ConfigError);
+  SocketAcceptor(Application &, MessageStoreFactory &, const SessionSettings &, LogFactory &) EXCEPT(ConfigError);
+
+  virtual ~SocketAcceptor();
+
+  const SessionToPort &sessionToPort() { return m_sessionToPort; }
+
+private:
+  bool readSettings(const SessionSettings &);
+
+  typedef std::set<SessionID> Sessions;
+  typedef std::map<uint16_t, Sessions> PortToSessions;
+  typedef std::map<socket_handle, SocketConnection *> SocketConnections;
+
+  void onConfigure(const SessionSettings &) EXCEPT(ConfigError);
+  void onInitialize(const SessionSettings &) EXCEPT(RuntimeError);
+
+  void onStart();
+  bool onPoll();
+  void onStop();
+
+  void onConnect(SocketServer &, socket_handle, socket_handle);
+  void onWrite(SocketServer &, socket_handle);
+  bool onData(SocketServer &, socket_handle);
+  void onDisconnect(SocketServer &, socket_handle);
+  void onError(SocketServer &);
+  void onTimeout(SocketServer &);
+
+  SocketServer *m_pServer;
+  PortToSessions m_portToSessions;
+  SessionToPort m_sessionToPort;
+  SocketConnections m_connections;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_SOCKETACCEPTOR_H