quickfix_ruby_ud 2.0.7

data/ext/quickfix/SocketMonitor_WIN32.cpp

@@ -0,0 +1,248 @@
+/****************************************************************************
+** 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"
+
+#include "SocketMonitor.h"
+#include "Utility.h"
+#include <algorithm>
+#include <exception>
+#include <iostream>
+#include <set>
+
+namespace FIX {
+SocketMonitor::SocketMonitor(int timeout)
+    : m_timeout(timeout) {
+  socket_init();
+
+  std::pair<socket_handle, socket_handle> sockets = socket_createpair();
+  m_signal = sockets.first;
+  m_interrupt = sockets.second;
+  socket_setnonblock(m_signal);
+  socket_setnonblock(m_interrupt);
+  m_readSockets.insert(m_interrupt);
+
+  m_timeval.tv_sec = 0;
+  m_timeval.tv_usec = 0;
+#ifndef SELECT_DECREMENTS_TIME
+  m_ticks = clock();
+#endif
+}
+
+SocketMonitor::~SocketMonitor() {
+  Sockets::iterator i;
+  for (i = m_readSockets.begin(); i != m_readSockets.end(); ++i) {
+    socket_close(*i);
+  }
+
+  socket_close(m_signal);
+  socket_term();
+}
+
+bool SocketMonitor::addConnect(socket_handle s) {
+  socket_setnonblock(s);
+  Sockets::iterator i = m_connectSockets.find(s);
+  if (i != m_connectSockets.end()) {
+    return false;
+  }
+
+  m_connectSockets.insert(s);
+  return true;
+}
+
+bool SocketMonitor::addRead(socket_handle s) {
+  socket_setnonblock(s);
+  Sockets::iterator i = m_readSockets.find(s);
+  if (i != m_readSockets.end()) {
+    return false;
+  }
+
+  m_readSockets.insert(s);
+  return true;
+}
+
+bool SocketMonitor::addWrite(socket_handle s) {
+  if (m_readSockets.find(s) == m_readSockets.end()) {
+    return false;
+  }
+
+  socket_setnonblock(s);
+  Sockets::iterator i = m_writeSockets.find(s);
+  if (i != m_writeSockets.end()) {
+    return false;
+  }
+
+  m_writeSockets.insert(s);
+  return true;
+}
+
+bool SocketMonitor::drop(socket_handle s) {
+  Sockets::iterator i = m_readSockets.find(s);
+  Sockets::iterator j = m_writeSockets.find(s);
+  Sockets::iterator k = m_connectSockets.find(s);
+
+  if (i != m_readSockets.end() || j != m_writeSockets.end() || k != m_connectSockets.end()) {
+    socket_close(s);
+    m_readSockets.erase(s);
+    m_writeSockets.erase(s);
+    m_connectSockets.erase(s);
+    m_dropped.push(s);
+    return true;
+  }
+  return false;
+}
+
+inline timeval *SocketMonitor::getTimeval(bool poll, double timeout) {
+  if (poll) {
+    m_timeval.tv_sec = 0;
+    m_timeval.tv_usec = 0;
+    return &m_timeval;
+  }
+
+  timeout = m_timeout;
+
+  if (!timeout) {
+    return 0;
+  }
+#ifdef SELECT_MODIFIES_TIMEVAL
+  if (!m_timeval.tv_sec && !m_timeval.tv_usec && timeout) {
+    m_timeval.tv_sec = timeout;
+  }
+  return &m_timeval;
+#else
+  double elapsed = (double)(clock() - m_ticks) / (double)CLOCKS_PER_SEC;
+  if (elapsed >= timeout || elapsed == 0.0) {
+    m_ticks = clock();
+    m_timeval.tv_sec = 0;
+    m_timeval.tv_usec = (long)(timeout * 1000000);
+  } else {
+    m_timeval.tv_sec = 0;
+    m_timeval.tv_usec = (long)((timeout - elapsed) * 1000000);
+  }
+  return &m_timeval;
+#endif
+}
+
+bool SocketMonitor::sleepIfEmpty(bool poll) {
+  if (poll) {
+    return false;
+  }
+
+  if (m_readSockets.empty() && m_writeSockets.empty() && m_connectSockets.empty()) {
+    process_sleep(m_timeout);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void SocketMonitor::signal(socket_handle socket) { socket_send(m_signal, (char *)&socket, sizeof(socket)); }
+
+void SocketMonitor::unsignal(socket_handle s) {
+  Sockets::iterator i = m_writeSockets.find(s);
+  if (i == m_writeSockets.end()) {
+    return;
+  }
+
+  m_writeSockets.erase(s);
+}
+
+void SocketMonitor::block(Strategy &strategy, bool poll, double timeout) {
+  while (m_dropped.size()) {
+    strategy.onError(*this, m_dropped.front());
+    m_dropped.pop();
+    if (m_dropped.size() == 0) {
+      return;
+    }
+  }
+
+  fd_set readSet;
+  FD_ZERO(&readSet);
+  buildSet(m_readSockets, readSet);
+  fd_set writeSet;
+  FD_ZERO(&writeSet);
+  buildSet(m_connectSockets, writeSet);
+  buildSet(m_writeSockets, writeSet);
+  fd_set exceptSet;
+  FD_ZERO(&exceptSet);
+  buildSet(m_connectSockets, exceptSet);
+
+  if (sleepIfEmpty(poll)) {
+    strategy.onTimeout(*this);
+    return;
+  }
+
+  int result = select(FD_SETSIZE, &readSet, &writeSet, &exceptSet, getTimeval(poll, timeout));
+
+  if (result == 0) {
+    strategy.onTimeout(*this);
+    return;
+  } else if (result > 0) {
+    processExceptSet(strategy, exceptSet);
+    processWriteSet(strategy, writeSet);
+    processReadSet(strategy, readSet);
+  } else {
+    strategy.onError(*this);
+  }
+}
+
+void SocketMonitor::processReadSet(Strategy &strategy, fd_set &readSet) {
+  for (unsigned i = 0; i < readSet.fd_count; ++i) {
+    socket_handle s = readSet.fd_array[i];
+    if (s == m_interrupt) {
+      socket_handle socket = 0;
+      socket_recv(s, (char *)&socket, sizeof(socket));
+      addWrite(socket);
+    } else {
+      strategy.onEvent(*this, s);
+    }
+  }
+}
+
+void SocketMonitor::processWriteSet(Strategy &strategy, fd_set &writeSet) {
+  for (unsigned i = 0; i < writeSet.fd_count; ++i) {
+    socket_handle s = writeSet.fd_array[i];
+    if (m_connectSockets.find(s) != m_connectSockets.end()) {
+      m_connectSockets.erase(s);
+      m_readSockets.insert(s);
+      strategy.onConnect(*this, s);
+    } else {
+      strategy.onWrite(*this, s);
+    }
+  }
+}
+
+void SocketMonitor::processExceptSet(Strategy &strategy, fd_set &exceptSet) {
+  for (unsigned i = 0; i < exceptSet.fd_count; ++i) {
+    socket_handle s = exceptSet.fd_array[i];
+    strategy.onError(*this, s);
+  }
+}
+
+void SocketMonitor::buildSet(const Sockets &sockets, fd_set &watchSet) {
+  Sockets::const_iterator iter;
+  for (iter = sockets.begin(); iter != sockets.end(); ++iter) {
+    FD_SET(*iter, &watchSet);
+  }
+}
+} // namespace FIX
+
+#endif

data/ext/quickfix/SocketMonitor_WIN32.h

@@ -0,0 +1,99 @@
+/* -*- 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_SOCKETMONITOR_WIND32_H
+#define FIX_SOCKETMONITOR_WIND32_H
+
+#ifdef _MSC_VER
+
+#include "Utility.h"
+
+#include <Winsock2.h>
+typedef int socklen_t;
+
+#include <queue>
+#include <set>
+#include <time.h>
+
+namespace FIX {
+/// Monitors events on a collection of sockets.
+class SocketMonitor {
+public:
+  class Strategy;
+
+  SocketMonitor(int timeout = 0);
+  virtual ~SocketMonitor();
+
+  bool addConnect(socket_handle socket);
+  bool addRead(socket_handle socket);
+  bool addWrite(socket_handle socket);
+  bool drop(socket_handle socket);
+  void signal(socket_handle socket);
+  void unsignal(socket_handle socket);
+  void block(Strategy &strategy, bool poll = 0, double timeout = 0.0);
+
+  size_t numSockets() { return m_readSockets.size() - 1; }
+
+private:
+  typedef std::set<socket_handle> Sockets;
+  typedef std::queue<socket_handle> Queue;
+
+  void setsockopt();
+  bool bind();
+  bool listen();
+  void buildSet(const Sockets &, fd_set &);
+  inline timeval *getTimeval(bool poll, double timeout);
+  inline bool sleepIfEmpty(bool poll);
+
+  void processReadSet(Strategy &, fd_set &);
+  void processWriteSet(Strategy &, fd_set &);
+  void processExceptSet(Strategy &, fd_set &);
+
+  int m_timeout;
+  timeval m_timeval;
+#ifndef SELECT_DECREMENTS_TIME
+  clock_t m_ticks;
+#endif
+
+  socket_handle m_signal;
+  socket_handle m_interrupt;
+  Sockets m_connectSockets;
+  Sockets m_readSockets;
+  Sockets m_writeSockets;
+  Queue m_dropped;
+
+public:
+  class Strategy {
+  public:
+    virtual ~Strategy() {}
+    virtual void onConnect(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onEvent(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onWrite(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onError(SocketMonitor &, socket_handle socket) = 0;
+    virtual void onError(SocketMonitor &) = 0;
+    virtual void onTimeout(SocketMonitor &) {}
+  };
+};
+} // namespace FIX
+
+#endif //_MSC_VER
+
+#endif // FIX_SOCKETMONITOR_WIN32_H

data/ext/quickfix/SocketServer.cpp

@@ -0,0 +1,163 @@
+/****************************************************************************
+** 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 "SocketServer.h"
+#include "Utility.h"
+#ifndef _MSC_VER
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+#include <exception>
+
+namespace FIX {
+/// Handles events from SocketMonitor for server connections.
+class ServerWrapper : public SocketMonitor::Strategy {
+public:
+  ServerWrapper(std::set<socket_handle> sockets, SocketServer &server, SocketServer::Strategy &strategy)
+      : m_sockets(sockets),
+        m_server(server),
+        m_strategy(strategy) {}
+
+private:
+  void onConnect(SocketMonitor &, socket_handle socket) {}
+
+  void onEvent(SocketMonitor &monitor, socket_handle socket) {
+    if (m_sockets.find(socket) != m_sockets.end()) {
+      m_strategy.onConnect(m_server, socket, m_server.accept(socket));
+    } else {
+      if (!m_strategy.onData(m_server, socket)) {
+        onError(monitor, socket);
+      }
+    }
+  }
+
+  void onWrite(SocketMonitor &, socket_handle socket) { m_strategy.onWrite(m_server, socket); }
+
+  void onError(SocketMonitor &monitor, socket_handle socket) {
+    m_strategy.onDisconnect(m_server, socket);
+    monitor.drop(socket);
+  }
+
+  void onError(SocketMonitor &) { m_strategy.onError(m_server); }
+
+  void onTimeout(SocketMonitor &) { m_strategy.onTimeout(m_server); };
+
+  typedef std::set<socket_handle> Sockets;
+
+  Sockets m_sockets;
+  SocketServer &m_server;
+  SocketServer::Strategy &m_strategy;
+};
+
+SocketServer::SocketServer(int timeout)
+    : m_monitor(timeout) {}
+
+socket_handle SocketServer::add(int port, bool reuse, bool noDelay, int sendBufSize, int rcvBufSize)
+    EXCEPT(SocketException &) {
+  if (m_portToInfo.find(port) != m_portToInfo.end()) {
+    return m_portToInfo[port].m_socket;
+  }
+
+  socket_handle socket = socket_createAcceptor(port, reuse);
+  if (socket == INVALID_SOCKET_HANDLE) {
+    throw SocketException();
+  }
+  if (noDelay) {
+    socket_setsockopt(socket, TCP_NODELAY);
+  }
+  if (sendBufSize) {
+    socket_setsockopt(socket, SO_SNDBUF, sendBufSize);
+  }
+  if (rcvBufSize) {
+    socket_setsockopt(socket, SO_RCVBUF, rcvBufSize);
+  }
+  m_monitor.addRead(socket);
+
+  SocketInfo info(socket, port, noDelay, sendBufSize, rcvBufSize);
+  m_socketToInfo[socket] = info;
+  m_portToInfo[port] = info;
+  return socket;
+}
+
+socket_handle SocketServer::accept(socket_handle socket) {
+  SocketInfo info = m_socketToInfo[socket];
+
+  socket_handle result = socket_accept(socket);
+  if (info.m_noDelay) {
+    socket_setsockopt(result, TCP_NODELAY);
+  }
+  if (info.m_sendBufSize) {
+    socket_setsockopt(result, SO_SNDBUF, info.m_sendBufSize);
+  }
+  if (info.m_rcvBufSize) {
+    socket_setsockopt(result, SO_RCVBUF, info.m_rcvBufSize);
+  }
+  if (result != INVALID_SOCKET_HANDLE) {
+    m_monitor.addConnect(result);
+  }
+  return result;
+}
+
+void SocketServer::close() {
+  for (const SocketToInfo::value_type &socketWithInfo : m_socketToInfo) {
+    socket_handle socket = socketWithInfo.first;
+    socket_close(socket);
+    socket_invalidate(socket);
+  }
+}
+
+bool SocketServer::block(Strategy &strategy, bool poll, double timeout) {
+  std::set<socket_handle> sockets;
+  for (const SocketToInfo::value_type &socketWithInfo : m_socketToInfo) {
+    if (!socket_isValid(socketWithInfo.first)) {
+      return false;
+    }
+    sockets.insert(socketWithInfo.first);
+  }
+
+  ServerWrapper wrapper(sockets, *this, strategy);
+  m_monitor.block(wrapper, poll, timeout);
+  return true;
+}
+
+int SocketServer::socketToPort(socket_handle socket) {
+  SocketToInfo::iterator find = m_socketToInfo.find(socket);
+  if (find == m_socketToInfo.end()) {
+    return 0;
+  }
+  return find->second.m_port;
+}
+
+socket_handle SocketServer::portToSocket(int port) {
+  PortToInfo::iterator find = m_portToInfo.find(port);
+  if (find == m_portToInfo.end()) {
+    return 0;
+  }
+  return find->second.m_socket;
+}
+} // namespace FIX

data/ext/quickfix/SocketServer.h

@@ -0,0 +1,100 @@
+/* -*- 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_SOCKETSERVER_H
+#define FIX_SOCKETSERVER_H
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4503 4355 4786 4290)
+#endif
+
+#include "Exceptions.h"
+#include "SocketMonitor.h"
+#include <map>
+#include <queue>
+#include <set>
+
+namespace FIX {
+/// Information about listening socket
+struct SocketInfo {
+  SocketInfo()
+      : m_socket(INVALID_SOCKET_HANDLE),
+        m_port(0),
+        m_noDelay(false),
+        m_sendBufSize(0),
+        m_rcvBufSize(0) {}
+
+  SocketInfo(socket_handle socket, short port, bool noDelay, int sendBufSize, int rcvBufSize)
+      : m_socket(socket),
+        m_port(port),
+        m_noDelay(noDelay),
+        m_sendBufSize(sendBufSize),
+        m_rcvBufSize(rcvBufSize) {}
+
+  socket_handle m_socket;
+  short m_port;
+  bool m_noDelay;
+  int m_sendBufSize;
+  int m_rcvBufSize;
+};
+
+/// Listens for and accepts incoming socket connections on a port.
+class SocketServer {
+public:
+  class Strategy;
+
+  SocketServer(int timeout = 0);
+
+  socket_handle add(int port, bool reuse = false, bool noDelay = false, int sendBufSize = 0, int rcvBufSize = 0)
+      EXCEPT(SocketException &);
+  socket_handle accept(socket_handle socket);
+  void close();
+  bool block(Strategy &strategy, bool poll = 0, double timeout = 0.0);
+
+  size_t numConnections() { return m_monitor.numSockets() - 1; }
+  SocketMonitor &getMonitor() { return m_monitor; }
+
+  int socketToPort(socket_handle socket);
+  socket_handle portToSocket(int port);
+
+private:
+  typedef std::map<socket_handle, SocketInfo> SocketToInfo;
+  typedef std::map<int, SocketInfo> PortToInfo;
+
+  SocketToInfo m_socketToInfo;
+  PortToInfo m_portToInfo;
+  SocketMonitor m_monitor;
+
+public:
+  class Strategy {
+  public:
+    virtual ~Strategy() {}
+    virtual void onConnect(SocketServer &, socket_handle acceptSocket, socket_handle socket) = 0;
+    virtual void onWrite(SocketServer &, socket_handle socket) = 0;
+    virtual bool onData(SocketServer &, socket_handle socket) = 0;
+    virtual void onDisconnect(SocketServer &, socket_handle socket) = 0;
+    virtual void onError(SocketServer &) = 0;
+    virtual void onTimeout(SocketServer &) {};
+  };
+};
+} // namespace FIX
+
+#endif // FIX_SOCKETSERVER_H