quickfix_ruby_ud 2.0.7-aarch64-linux

data/ext/quickfix/SocketConnection.cpp

@@ -0,0 +1,256 @@
+/****************************************************************************
+** 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 "SocketAcceptor.h"
+#include "SocketConnection.h"
+#include "SocketConnector.h"
+#include "SocketInitiator.h"
+#include "Utility.h"
+
+namespace FIX {
+SocketConnection::SocketConnection(socket_handle s, Sessions sessions, SocketMonitor *pMonitor)
+    : m_socket(s),
+      m_sendLength(0),
+      m_sessions(sessions),
+      m_pSession(0),
+      m_pMonitor(pMonitor) {
+#ifdef _MSC_VER
+  FD_ZERO(&m_fds);
+  FD_SET(m_socket, &m_fds);
+#endif
+}
+
+SocketConnection::SocketConnection(
+    SocketInitiator &i,
+    const SessionID &sessionID,
+    socket_handle s,
+    SocketMonitor *pMonitor)
+    : m_socket(s),
+      m_sendLength(0),
+      m_pSession(i.getSession(sessionID, *this)),
+      m_pMonitor(pMonitor) {
+#ifdef _MSC_VER
+  FD_ZERO(&m_fds);
+  FD_SET(m_socket, &m_fds);
+#endif
+  m_sessions.insert(sessionID);
+}
+
+SocketConnection::~SocketConnection() {
+  if (m_pSession) {
+    Session::unregisterSession(m_pSession->getSessionID());
+  }
+}
+
+bool SocketConnection::send(const std::string &message) {
+  Locker l(m_mutex);
+
+  m_sendQueue.push_back(message);
+  processQueue();
+  signal();
+  return true;
+}
+
+bool SocketConnection::processQueue() {
+  Locker l(m_mutex);
+
+  if (!m_sendQueue.size()) {
+    return true;
+  }
+
+#ifdef _MSC_VER
+  struct timeval timeout = {0, 0};
+  fd_set writeset = m_fds;
+  if (select(0, 0, &writeset, 0, &timeout) <= 0) {
+    return false;
+  }
+#else
+  struct pollfd pfd = {m_socket, POLLOUT, 0};
+  if (poll(&pfd, 1, 0) <= 0) {
+    return false;
+  }
+#endif
+
+  const std::string &msg = m_sendQueue.front();
+
+  ssize_t result = socket_send(m_socket, msg.c_str() + m_sendLength, msg.length() - m_sendLength);
+
+  if (result > 0) {
+    m_sendLength += result;
+  }
+
+  if (m_sendLength == msg.length()) {
+    m_sendLength = 0;
+    m_sendQueue.pop_front();
+  }
+
+  return !m_sendQueue.size();
+}
+
+void SocketConnection::disconnect() {
+  if (m_pMonitor) {
+    m_pMonitor->drop(m_socket);
+  }
+}
+
+bool SocketConnection::read(SocketConnector &s) {
+  if (!m_pSession) {
+    return false;
+  }
+
+  try {
+    readFromSocket();
+    readMessages(s.getMonitor());
+  } catch (SocketRecvFailed &e) {
+    m_pSession->getLog()->onEvent(e.what());
+    return false;
+  }
+  return true;
+}
+
+bool SocketConnection::read(SocketAcceptor &acceptor, SocketServer &server) {
+  std::string message;
+  try {
+    if (!m_pSession) {
+#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
+
+      while (!readMessage(message)) {
+#if _MSC_VER
+        int result = select(0, &readset, 0, 0, &timeout);
+#else
+        int result = poll(&pfd, 1, timeout);
+#endif
+        if (result > 0) {
+          readFromSocket();
+        } else if (result == 0) {
+          return false;
+        } else if (result < 0) {
+          return false;
+        }
+      }
+
+      m_pSession = Session::lookupSession(message, true);
+      if (!isValidSession()) {
+        m_pSession = 0;
+        if (acceptor.getLog()) {
+          acceptor.getLog()->onEvent("Session not found for incoming message: " + message);
+          acceptor.getLog()->onIncoming(message);
+        }
+      }
+      if (m_pSession) {
+        m_pSession = acceptor.getSession(message, *this);
+      }
+      if (m_pSession) {
+        m_pSession->next(message, UtcTimeStamp::now());
+      }
+      if (!m_pSession) {
+        server.getMonitor().drop(m_socket);
+        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);
+      }
+
+      Session::registerSession(m_pSession->getSessionID());
+      return true;
+    } else {
+      readFromSocket();
+      readMessages(server.getMonitor());
+      return true;
+    }
+  } catch (SocketRecvFailed &e) {
+    if (m_pSession) {
+      m_pSession->getLog()->onEvent(e.what());
+    }
+    server.getMonitor().drop(m_socket);
+  } catch (InvalidMessage &) {
+    server.getMonitor().drop(m_socket);
+  }
+  return false;
+}
+
+bool SocketConnection::isValidSession() {
+  if (m_pSession == 0) {
+    return false;
+  }
+  SessionID sessionID = m_pSession->getSessionID();
+  if (Session::isSessionRegistered(sessionID)) {
+    return false;
+  }
+  return !(m_sessions.find(sessionID) == m_sessions.end());
+}
+
+void SocketConnection::readFromSocket() EXCEPT(SocketRecvFailed) {
+  ssize_t size = socket_recv(m_socket, m_buffer, sizeof(m_buffer));
+  if (size <= 0) {
+    throw SocketRecvFailed(size);
+  }
+  m_parser.addToStream(m_buffer, size);
+}
+
+bool SocketConnection::readMessage(std::string &msg) {
+  try {
+    return m_parser.readFixMessage(msg);
+  } catch (MessageParseError &) {}
+  return true;
+}
+
+void SocketConnection::readMessages(SocketMonitor &socketMonitor) {
+  if (!m_pSession) {
+    return;
+  }
+
+  std::string message;
+  while (readMessage(message)) {
+    try {
+      m_pSession->next(message, UtcTimeStamp::now());
+    } catch (InvalidMessage &) {
+      if (!m_pSession->isLoggedOn()) {
+        socketMonitor.drop(m_socket);
+      }
+    }
+  }
+}
+
+void SocketConnection::onTimeout() {
+  if (m_pSession) {
+    m_pSession->next(UtcTimeStamp::now());
+  }
+}
+} // namespace FIX

data/ext/quickfix/SocketConnection.h

@@ -0,0 +1,102 @@
+/* -*- 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_SOCKETCONNECTION_H
+#define FIX_SOCKETCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Mutex.h"
+#include "Parser.h"
+#include "Responder.h"
+#include "SessionID.h"
+#include "SocketMonitor.h"
+#include "Utility.h"
+#include <set>
+
+namespace FIX {
+class SocketAcceptor;
+class SocketServer;
+class SocketConnector;
+class SocketInitiator;
+class Session;
+
+/// Encapsulates a socket file descriptor (single-threaded).
+class SocketConnection : Responder {
+public:
+  typedef std::set<SessionID> Sessions;
+
+  SocketConnection(socket_handle s, Sessions sessions, SocketMonitor *pMonitor);
+  SocketConnection(SocketInitiator &, const SessionID &, socket_handle, SocketMonitor *);
+  virtual ~SocketConnection();
+
+  socket_handle getSocket() const { return m_socket; }
+  Session *getSession() const { return m_pSession; }
+
+  bool read(SocketConnector &s);
+  bool read(SocketAcceptor &, SocketServer &);
+  bool processQueue();
+
+  void signal() {
+    Locker l(m_mutex);
+    if (m_sendQueue.size() == 1) {
+      m_pMonitor->signal(m_socket);
+    }
+  }
+
+  void unsignal() {
+    Locker l(m_mutex);
+    if (m_sendQueue.size() == 0) {
+      m_pMonitor->unsignal(m_socket);
+    }
+  }
+
+  void onTimeout();
+
+private:
+  typedef std::deque<std::string, ALLOCATOR<std::string>> Queue;
+
+  bool isValidSession();
+  void readFromSocket() EXCEPT(SocketRecvFailed);
+  bool readMessage(std::string &msg);
+  void readMessages(SocketMonitor &s);
+  bool send(const std::string &);
+  void disconnect();
+
+  socket_handle m_socket;
+  char m_buffer[BUFSIZ];
+
+  Parser m_parser;
+  Queue m_sendQueue;
+  ssize_t m_sendLength;
+  Sessions m_sessions;
+  Session *m_pSession;
+  SocketMonitor *m_pMonitor;
+  Mutex m_mutex;
+#ifdef _MSC_VER
+  fd_set m_fds;
+#endif
+};
+} // namespace FIX
+
+#endif // FIX_SOCKETCONNECTION_H

data/ext/quickfix/SocketConnector.cpp

@@ -0,0 +1,112 @@
+/****************************************************************************
+** 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 "SocketConnector.h"
+#include "Utility.h"
+#ifndef _MSC_VER
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+#include <iostream>
+
+namespace FIX {
+/// Handles events from SocketMonitor for client connections.
+class ConnectorWrapper : public SocketMonitor::Strategy {
+public:
+  ConnectorWrapper(SocketConnector &connector, SocketConnector::Strategy &strategy)
+      : m_connector(connector),
+        m_strategy(strategy) {}
+
+private:
+  virtual void onConnect(SocketMonitor &, socket_handle socket) override { m_strategy.onConnect(m_connector, socket); }
+
+  virtual void onWrite(SocketMonitor &, socket_handle socket) override { m_strategy.onWrite(m_connector, socket); }
+
+  virtual void onEvent(SocketMonitor &, socket_handle socket) override {
+    if (!m_strategy.onData(m_connector, socket)) {
+      m_strategy.onDisconnect(m_connector, socket);
+    }
+  }
+
+  virtual void onError(SocketMonitor &, socket_handle socket) override { m_strategy.onDisconnect(m_connector, socket); }
+
+  virtual void onError(SocketMonitor &) override { m_strategy.onError(m_connector); }
+
+  virtual void onTimeout(SocketMonitor &) override { m_strategy.onTimeout(m_connector); };
+
+  SocketConnector &m_connector;
+  SocketConnector::Strategy &m_strategy;
+};
+
+SocketConnector::SocketConnector(int timeout)
+    : m_monitor(timeout) {}
+
+socket_handle SocketConnector::connect(
+    const std::string &address,
+    int port,
+    bool noDelay,
+    int sendBufSize,
+    int rcvBufSize,
+    const std::string &sourceAddress,
+    int sourcePort) {
+  socket_handle socket = socket_createConnector();
+
+  if (socket != 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);
+    }
+    if (!sourceAddress.empty() || sourcePort) {
+      socket_bind(socket, sourceAddress.c_str(), sourcePort);
+    }
+    m_monitor.addConnect(socket);
+    socket_connect(socket, address.c_str(), port);
+  }
+  return socket;
+}
+
+socket_handle SocketConnector::connect(
+    const std::string &address,
+    int port,
+    bool noDelay,
+    int sendBufSize,
+    int rcvBufSize,
+    Strategy &strategy) {
+  socket_handle socket = connect(address, port, noDelay, sendBufSize, rcvBufSize, "", 0);
+  return socket;
+}
+
+void SocketConnector::block(Strategy &strategy, bool poll, double timeout) {
+  ConnectorWrapper wrapper(*this, strategy);
+  m_monitor.block(wrapper, poll, timeout);
+}
+} // namespace FIX

data/ext/quickfix/SocketConnector.h

@@ -0,0 +1,76 @@
+/* -*- 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_SOCKETCONNECTOR_H
+#define FIX_SOCKETCONNECTOR_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "SocketMonitor.h"
+#include "Utility.h"
+#include <string>
+
+namespace FIX {
+/// Connects sockets to remote ports and addresses.
+class SocketConnector {
+public:
+  class Strategy;
+
+  SocketConnector(int timeout = 0);
+
+  socket_handle connect(
+      const std::string &address,
+      int port,
+      bool noDelay,
+      int sendBufSize,
+      int rcvBufSize,
+      const std::string &sourceAddress = "",
+      int sourcePort = 0);
+  socket_handle connect(
+      const std::string &address,
+      int port,
+      bool noDelay,
+      int sendBufSize,
+      int rcvBufSize,
+      Strategy &);
+  void block(Strategy &strategy, bool poll = 0, double timeout = 0.0);
+  SocketMonitor &getMonitor() { return m_monitor; }
+
+private:
+  SocketMonitor m_monitor;
+
+public:
+  class Strategy {
+  public:
+    virtual ~Strategy() {}
+    virtual void onConnect(SocketConnector &, socket_handle socket) = 0;
+    virtual void onWrite(SocketConnector &, socket_handle socket) = 0;
+    virtual bool onData(SocketConnector &, socket_handle socket) = 0;
+    virtual void onDisconnect(SocketConnector &, socket_handle socket) = 0;
+    virtual void onError(SocketConnector &) = 0;
+    virtual void onTimeout(SocketConnector &) {};
+  };
+};
+} // namespace FIX
+
+#endif // FIX_SOCKETCONNECTOR_H