quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/ThreadedSocketAcceptor.cpp

@@ -0,0 +1,242 @@
+/****************************************************************************
+** 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 "Settings.h"
+#include "ThreadedSocketAcceptor.h"
+#include "Utility.h"
+
+namespace FIX {
+ThreadedSocketAcceptor::ThreadedSocketAcceptor(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings) EXCEPT(ConfigError)
+    : Acceptor(application, factory, settings) {
+  socket_init();
+}
+
+ThreadedSocketAcceptor::ThreadedSocketAcceptor(
+    Application &application,
+    MessageStoreFactory &factory,
+    const SessionSettings &settings,
+    LogFactory &logFactory) EXCEPT(ConfigError)
+    : Acceptor(application, factory, settings, logFactory) {
+  socket_init();
+}
+
+ThreadedSocketAcceptor::~ThreadedSocketAcceptor() { socket_term(); }
+
+void ThreadedSocketAcceptor::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 ThreadedSocketAcceptor::onInitialize(const SessionSettings &sessionSettings) EXCEPT(RuntimeError) {
+  short port = 0;
+  std::set<int> ports;
+
+  for (const SessionID &sessionID : sessionSettings.getSessions()) {
+    const Dictionary &settings = sessionSettings.get(sessionID);
+    port = (short)settings.getInt(SOCKET_ACCEPT_PORT);
+
+    m_portToSessions[port].insert(sessionID);
+
+    if (ports.find(port) != ports.end()) {
+      continue;
+    }
+    ports.insert(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 socket = socket_createAcceptor(port, reuseAddress);
+    if (socket == INVALID_SOCKET_HANDLE) {
+      SocketException e;
+      socket_close(socket);
+      throw RuntimeError(
+          "Unable to create, bind, or listen to port " + IntConvertor::convert((unsigned short)port) + " (" + e.what()
+          + ")");
+    }
+    if (noDelay) {
+      socket_setsockopt(socket, TCP_NODELAY);
+    }
+    if (sendBufSize) {
+      socket_setsockopt(socket, SO_SNDBUF, sendBufSize);
+    }
+    if (rcvBufSize) {
+      socket_setsockopt(socket, SO_RCVBUF, rcvBufSize);
+    }
+
+    m_socketToPort[socket] = port;
+    m_sockets.insert(socket);
+  }
+}
+
+void ThreadedSocketAcceptor::onStart() {
+  for (const Sockets::value_type &socket : m_sockets) {
+    Locker l(m_mutex);
+    int port = m_socketToPort[socket];
+    AcceptorThreadInfo *info = new AcceptorThreadInfo(this, socket, port);
+    thread_id thread;
+    thread_spawn(&socketAcceptorThread, info, thread);
+    addThread(socket, thread);
+  }
+}
+
+bool ThreadedSocketAcceptor::onPoll() { return false; }
+
+void ThreadedSocketAcceptor::onStop() {
+  SocketToThread threads;
+  SocketToThread::iterator i;
+
+  {
+    Locker l(m_mutex);
+
+    time_t start = 0;
+    time_t now = 0;
+
+    ::time(&start);
+    while (isLoggedOn()) {
+      if (::time(&now) - 5 >= start) {
+        break;
+      }
+    }
+
+    threads = m_threads;
+    m_threads.clear();
+  }
+
+  for (i = threads.begin(); i != threads.end(); ++i) {
+    socket_close(i->first);
+  }
+  for (i = threads.begin(); i != threads.end(); ++i) {
+    thread_join(i->second);
+  }
+}
+
+void ThreadedSocketAcceptor::addThread(socket_handle s, thread_id t) {
+  Locker l(m_mutex);
+
+  m_threads[s] = t;
+}
+
+void ThreadedSocketAcceptor::removeThread(socket_handle s) {
+  Locker l(m_mutex);
+  SocketToThread::iterator i = m_threads.find(s);
+  if (i != m_threads.end()) {
+    thread_detach(i->second);
+    m_threads.erase(i);
+  }
+}
+
+THREAD_PROC ThreadedSocketAcceptor::socketAcceptorThread(void *p) {
+  AcceptorThreadInfo *info = reinterpret_cast<AcceptorThreadInfo *>(p);
+
+  ThreadedSocketAcceptor *pAcceptor = info->m_pAcceptor;
+  socket_handle s = info->m_socket;
+  int port = info->m_port;
+  delete info;
+
+  int noDelay = 0;
+  int sendBufSize = 0;
+  int rcvBufSize = 0;
+  socket_getsockopt(s, TCP_NODELAY, noDelay);
+  socket_getsockopt(s, SO_SNDBUF, sendBufSize);
+  socket_getsockopt(s, SO_RCVBUF, rcvBufSize);
+
+  socket_handle socket = 0;
+  while ((!pAcceptor->isStopped() && (socket = socket_accept(s)) != INVALID_SOCKET_HANDLE)) {
+    if (noDelay) {
+      socket_setsockopt(socket, TCP_NODELAY);
+    }
+    if (sendBufSize) {
+      socket_setsockopt(socket, SO_SNDBUF, sendBufSize);
+    }
+    if (rcvBufSize) {
+      socket_setsockopt(socket, SO_RCVBUF, rcvBufSize);
+    }
+
+    Sessions sessions = pAcceptor->m_portToSessions[port];
+
+    ThreadedSocketConnection *pConnection = new ThreadedSocketConnection(socket, sessions, pAcceptor->getLog());
+
+    ConnectionThreadInfo *info = new ConnectionThreadInfo(pAcceptor, pConnection);
+
+    {
+      Locker l(pAcceptor->m_mutex);
+
+      std::stringstream stream;
+      stream << "Accepted connection from " << socket_peername(socket) << " on port " << port;
+
+      if (pAcceptor->getLog()) {
+        pAcceptor->getLog()->onEvent(stream.str());
+      }
+
+      thread_id thread;
+      if (!thread_spawn(&socketConnectionThread, info, thread)) {
+        delete info;
+        delete pConnection;
+      } else {
+        pAcceptor->addThread(socket, thread);
+      }
+    }
+  }
+
+  if (!pAcceptor->isStopped()) {
+    pAcceptor->removeThread(s);
+  }
+
+  return 0;
+}
+
+THREAD_PROC ThreadedSocketAcceptor::socketConnectionThread(void *p) {
+  ConnectionThreadInfo *info = reinterpret_cast<ConnectionThreadInfo *>(p);
+
+  ThreadedSocketAcceptor *pAcceptor = info->m_pAcceptor;
+  ThreadedSocketConnection *pConnection = info->m_pConnection;
+  delete info;
+
+  socket_handle socket = pConnection->getSocket();
+
+  while (pConnection->read()) {}
+  delete pConnection;
+  if (!pAcceptor->isStopped()) {
+    pAcceptor->removeThread(socket);
+  }
+  return 0;
+}
+} // namespace FIX

data/ext/quickfix/ThreadedSocketAcceptor.h

@@ -0,0 +1,95 @@
+/* -*- 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_THREADEDSOCKETACCEPTOR_H
+#define FIX_THREADEDSOCKETACCEPTOR_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Acceptor.h"
+#include "Mutex.h"
+#include "ThreadedSocketConnection.h"
+
+namespace FIX {
+/// Threaded Socket implementation of Acceptor.
+class ThreadedSocketAcceptor : public Acceptor {
+  friend class SocketConnection;
+
+public:
+  ThreadedSocketAcceptor(Application &, MessageStoreFactory &, const SessionSettings &) EXCEPT(ConfigError);
+  ThreadedSocketAcceptor(Application &, MessageStoreFactory &, const SessionSettings &, LogFactory &)
+      EXCEPT(ConfigError);
+
+  virtual ~ThreadedSocketAcceptor();
+
+private:
+  struct AcceptorThreadInfo {
+    AcceptorThreadInfo(ThreadedSocketAcceptor *pAcceptor, socket_handle socket, int port)
+        : m_pAcceptor(pAcceptor),
+          m_socket(socket),
+          m_port(port) {}
+
+    ThreadedSocketAcceptor *m_pAcceptor;
+    socket_handle m_socket;
+    int m_port;
+  };
+
+  struct ConnectionThreadInfo {
+    ConnectionThreadInfo(ThreadedSocketAcceptor *pAcceptor, ThreadedSocketConnection *pConnection)
+        : m_pAcceptor(pAcceptor),
+          m_pConnection(pConnection) {}
+
+    ThreadedSocketAcceptor *m_pAcceptor;
+    ThreadedSocketConnection *m_pConnection;
+  };
+
+  bool readSettings(const SessionSettings &);
+
+  typedef std::set<socket_handle> Sockets;
+  typedef std::set<SessionID> Sessions;
+  typedef std::map<int, Sessions> PortToSessions;
+  typedef std::map<socket_handle, int> SocketToPort;
+  typedef std::map<socket_handle, thread_id> SocketToThread;
+
+  void onConfigure(const SessionSettings &) EXCEPT(ConfigError);
+  void onInitialize(const SessionSettings &) EXCEPT(RuntimeError);
+
+  void onStart();
+  bool onPoll();
+  void onStop();
+
+  void addThread(socket_handle s, thread_id t);
+  void removeThread(socket_handle s);
+  static THREAD_PROC socketAcceptorThread(void *p);
+  static THREAD_PROC socketConnectionThread(void *p);
+
+  Sockets m_sockets;
+  PortToSessions m_portToSessions;
+  SocketToPort m_socketToPort;
+  SocketToThread m_threads;
+  Mutex m_mutex;
+};
+/*! @} */
+} // namespace FIX
+
+#endif // FIX_THREADEDSOCKETACCEPTOR_H

data/ext/quickfix/ThreadedSocketConnection.cpp

@@ -0,0 +1,227 @@
+/****************************************************************************
+** 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"
+#include <poll.h>
+#endif
+
+#include "Session.h"
+#include "ThreadedSocketAcceptor.h"
+#include "ThreadedSocketConnection.h"
+#include "ThreadedSocketInitiator.h"
+#include "Utility.h"
+
+namespace FIX {
+ThreadedSocketConnection::ThreadedSocketConnection(socket_handle s, Sessions sessions, Log *pLog)
+    : m_socket(s),
+      m_pLog(pLog),
+      m_sessions(sessions),
+      m_pSession(0),
+      m_disconnect(false) {
+#if _MSC_VER
+  FD_ZERO(&m_fds);
+  FD_SET(m_socket, &m_fds);
+#endif
+}
+
+ThreadedSocketConnection::ThreadedSocketConnection(
+    const SessionID &sessionID,
+    socket_handle s,
+    const std::string &address,
+    short port,
+    Log *pLog,
+    const std::string &sourceAddress,
+    short sourcePort)
+    : m_socket(s),
+      m_address(address),
+      m_port(port),
+      m_sourceAddress(sourceAddress),
+      m_sourcePort(sourcePort),
+      m_pLog(pLog),
+      m_pSession(Session::lookupSession(sessionID)),
+      m_disconnect(false) {
+#if _MSC_VER
+  FD_ZERO(&m_fds);
+  FD_SET(m_socket, &m_fds);
+#endif
+  if (m_pSession) {
+    m_pSession->setResponder(this);
+  }
+}
+
+ThreadedSocketConnection::~ThreadedSocketConnection() {
+  if (m_pSession) {
+    m_pSession->setResponder(0);
+    Session::unregisterSession(m_pSession->getSessionID());
+  }
+}
+
+bool ThreadedSocketConnection::send(const std::string &msg) {
+  ssize_t totalSent = 0;
+  while (totalSent < (int)msg.length()) {
+    ssize_t sent = socket_send(m_socket, msg.c_str() + totalSent, msg.length());
+    if (sent < 0) {
+      return false;
+    }
+    totalSent += sent;
+  }
+
+  return true;
+}
+
+bool ThreadedSocketConnection::connect() {
+  // do the bind in the thread as name resolution may block
+  if (!m_sourceAddress.empty() || m_sourcePort) {
+    socket_bind(m_socket, m_sourceAddress.c_str(), m_sourcePort);
+  }
+
+  return socket_connect(getSocket(), m_address.c_str(), m_port) >= 0;
+}
+
+void ThreadedSocketConnection::disconnect() {
+  m_disconnect = true;
+  socket_close(m_socket);
+}
+
+bool ThreadedSocketConnection::read() {
+#if _MSC_VER
+  struct timeval timeout = {1, 0};
+  fd_set readset = m_fds;
+#else
+  int timeout = 1000; // 1000ms = 1 second
+  struct pollfd pfd = {m_socket, POLLIN | POLLPRI, 0};
+#endif
+
+  try {
+    // Wait for input (1 second timeout)
+#if _MSC_VER
+    int result = select(0, &readset, 0, 0, &timeout);
+#else
+    int result = poll(&pfd, 1, timeout);
+#endif
+
+    if (result > 0) // Something to read
+    {
+      // We can read without blocking
+      ssize_t size = socket_recv(m_socket, m_buffer, sizeof(m_buffer));
+      if (size <= 0) {
+        throw SocketRecvFailed(size);
+      }
+      m_parser.addToStream(m_buffer, size);
+    } else if (result == 0 && m_pSession) // Timeout
+    {
+      m_pSession->next(UtcTimeStamp::now());
+    } else if (result < 0) // Error
+    {
+      throw SocketRecvFailed(result);
+    }
+
+    processStream();
+    return true;
+  } catch (SocketRecvFailed &e) {
+    if (m_disconnect) {
+      return false;
+    }
+
+    if (m_pSession) {
+      m_pSession->getLog()->onEvent(e.what());
+      m_pSession->disconnect();
+    } else {
+      disconnect();
+    }
+
+    return false;
+  }
+}
+
+bool ThreadedSocketConnection::readMessage(std::string &msg) EXCEPT(SocketRecvFailed) {
+  try {
+    return m_parser.readFixMessage(msg);
+  } catch (MessageParseError &) {}
+  return true;
+}
+
+void ThreadedSocketConnection::processStream() {
+  std::string msg;
+  while (readMessage(msg)) {
+    if (!m_pSession) {
+      if (!setSession(msg)) {
+        disconnect();
+        continue;
+      }
+    }
+    try {
+      m_pSession->next(msg, UtcTimeStamp::now());
+    } catch (InvalidMessage &) {
+      if (!m_pSession->isLoggedOn()) {
+        disconnect();
+        return;
+      }
+    }
+  }
+}
+
+bool ThreadedSocketConnection::setSession(const std::string &msg) {
+  m_pSession = Session::lookupSession(msg, true);
+  if (!m_pSession) {
+    if (m_pLog) {
+      m_pLog->onEvent("Session not found for incoming message: " + msg);
+      m_pLog->onIncoming(msg);
+    }
+    return false;
+  }
+
+  SessionID sessionID = m_pSession->getSessionID();
+  m_pSession = 0;
+
+  // see if the session frees up within 5 seconds
+  for (int i = 1; i <= 5; i++) {
+    if (!Session::isSessionRegistered(sessionID)) {
+      m_pSession = Session::registerSession(sessionID);
+    }
+    if (m_pSession) {
+      break;
+    }
+    process_sleep(1);
+  }
+
+  if (!m_pSession) {
+    return false;
+  }
+  if (m_sessions.find(m_pSession->getSessionID()) == m_sessions.end()) {
+    return false;
+  }
+
+  if (m_pSession->isAcceptor()) {
+    std::string remote_address = socket_peername(m_socket);
+    if (!m_pSession->getAllowedRemoteAddresses().empty() && !m_pSession->inAllowedRemoteAddresses(remote_address)) {
+      m_pSession->getLog()->onEvent("Deny connections to the acceptor from " + remote_address);
+      return false;
+    }
+    m_pSession->getLog()->onEvent("Allows connections to the acceptor from " + remote_address);
+  }
+
+  m_pSession->setResponder(this);
+  return true;
+}
+
+} // namespace FIX

data/ext/quickfix/ThreadedSocketConnection.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_THREADEDSOCKETCONNECTION_H
+#define FIX_THREADEDSOCKETCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Parser.h"
+#include "Responder.h"
+#include "SessionID.h"
+#include <map>
+#include <set>
+
+namespace FIX {
+class ThreadedSocketAcceptor;
+class ThreadedSocketInitiator;
+class Session;
+class Application;
+class Log;
+
+/// Encapsulates a socket file descriptor (multi-threaded).
+class ThreadedSocketConnection : Responder {
+public:
+  typedef std::set<SessionID> Sessions;
+
+  ThreadedSocketConnection(socket_handle s, Sessions sessions, Log *pLog);
+  ThreadedSocketConnection(
+      const SessionID &,
+      socket_handle s,
+      const std::string &address,
+      short port,
+      Log *pLog,
+      const std::string &sourceAddress = "",
+      short sourcePort = 0);
+  virtual ~ThreadedSocketConnection();
+
+  Session *getSession() const { return m_pSession; }
+  socket_handle getSocket() const { return m_socket; }
+  bool connect();
+  void disconnect();
+  bool read();
+
+private:
+  bool readMessage(std::string &msg) EXCEPT(SocketRecvFailed);
+  void processStream();
+  bool send(const std::string &);
+  bool setSession(const std::string &msg);
+
+  socket_handle m_socket;
+  char m_buffer[BUFSIZ];
+
+  std::string m_address;
+  int m_port;
+  std::string m_sourceAddress;
+  int m_sourcePort;
+
+  Log *m_pLog;
+  Parser m_parser;
+  Sessions m_sessions;
+  Session *m_pSession;
+  bool m_disconnect;
+#if _MSC_VER
+  fd_set m_fds;
+#endif
+};
+} // namespace FIX
+
+#endif // FIX_THREADEDSOCKETCONNECTION_H