quickfix_ruby 1.14.3

data/ext/quickfix/SocketMonitor.cpp

@@ -0,0 +1,335 @@
+/****************************************************************************
+** 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 "SocketMonitor.h"
+#include "Utility.h"
+#include <exception>
+#include <set>
+#include <algorithm>
+#include <iostream>
+
+namespace FIX
+{
+SocketMonitor::SocketMonitor( int timeout )
+: m_timeout( timeout )
+{
+  socket_init();
+
+  std::pair<int, int> 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( int 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( int 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( int 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( int 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 = (timeout * 1000000);
+  }
+  else
+  {
+    m_timeval.tv_sec = 0;
+    m_timeval.tv_usec = ( ( 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( int socket )
+{
+  socket_send( m_signal, (char*)&socket, sizeof(socket) );
+}
+
+void SocketMonitor::unsignal( int 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 )
+{
+#ifdef _MSC_VER
+  for ( unsigned i = 0; i < readSet.fd_count; ++i )
+  {
+    int s = readSet.fd_array[ i ];
+    if( s == m_interrupt )
+    {
+      int socket = 0;
+      recv( s, (char*)&socket, sizeof(socket), 0 );
+      addWrite( socket );
+    }
+    else
+    {
+      strategy.onEvent( *this, s );
+    }
+  }
+#else
+    Sockets::iterator i;
+    Sockets sockets = m_readSockets;
+    for ( i = sockets.begin(); i != sockets.end(); ++i )
+    {
+      int s = *i;
+      if ( !FD_ISSET( *i, &readSet ) )
+        continue;
+      if( s == m_interrupt )
+      {
+        int socket = 0;
+        recv( s, (char*)&socket, sizeof(socket), 0 );
+        addWrite( socket );
+      }
+      else
+      {
+        strategy.onEvent( *this, s );
+      }
+    }
+#endif
+}
+
+void SocketMonitor::processWriteSet( Strategy& strategy, fd_set& writeSet )
+{
+#ifdef _MSC_VER
+  for ( unsigned i = 0; i < writeSet.fd_count; ++i )
+  {
+    int 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 );
+    }
+  }
+#else
+  Sockets::iterator i;
+  Sockets sockets = m_connectSockets;
+  for( i = sockets.begin(); i != sockets.end(); ++i )
+  {
+    int s = *i;
+    if ( !FD_ISSET( *i, &writeSet ) )
+      continue;
+    m_connectSockets.erase( s );
+    m_readSockets.insert( s );
+    strategy.onConnect( *this, s );
+  }
+
+  sockets = m_writeSockets;
+  for( i = sockets.begin(); i != sockets.end(); ++i )
+  {
+    int s = *i;
+    if ( !FD_ISSET( *i, &writeSet ) )
+      continue;
+    strategy.onWrite( *this, s );
+  }
+#endif
+}
+
+void SocketMonitor::processExceptSet( Strategy& strategy, fd_set& exceptSet )
+{
+#ifdef _MSC_VER
+  for ( unsigned i = 0; i < exceptSet.fd_count; ++i )
+  {
+    int s = exceptSet.fd_array[ i ];
+    strategy.onError( *this, s );
+  }
+#else
+    Sockets::iterator i;
+    Sockets sockets = m_connectSockets;
+    for ( i = sockets.begin(); i != sockets.end(); ++i )
+    {
+      int s = *i;
+      if ( !FD_ISSET( *i, &exceptSet ) )
+        continue;
+      strategy.onError( *this, s );
+    }
+#endif
+}
+
+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 );
+  }
+}
+}

data/ext/quickfix/SocketMonitor.h

@@ -0,0 +1,111 @@
+/* -*- 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_H
+#define FIX_SOCKETMONITOR_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#ifdef _MSC_VER
+#include <Winsock2.h>
+typedef int socklen_t;
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#include <set>
+#include <queue>
+#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( int socket );
+  bool addRead( int socket );
+  bool addWrite( int socket );
+  bool drop( int socket );
+  void signal( int socket );
+  void unsignal( int socket );
+  void block( Strategy& strategy, bool poll = 0, double timeout = 0.0 );
+
+  size_t numSockets() 
+  { return m_readSockets.size() - 1; }
+
+private:
+  typedef std::set < int > Sockets;
+  typedef std::queue < int > 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
+
+  int m_signal;
+  int m_interrupt;
+  Sockets m_connectSockets;
+  Sockets m_readSockets;
+  Sockets m_writeSockets;
+  Queue m_dropped;
+
+public:
+  class Strategy
+  {
+  public:
+    virtual ~Strategy()
+    {}
+    virtual void onConnect( SocketMonitor&, int socket ) = 0;
+    virtual void onEvent( SocketMonitor&, int socket ) = 0;
+    virtual void onWrite( SocketMonitor&, int socket ) = 0;
+    virtual void onError( SocketMonitor&, int socket ) = 0;
+    virtual void onError( SocketMonitor& ) = 0;
+    virtual void onTimeout( SocketMonitor& )
+  {}}
+  ;
+};
+}
+
+#endif //FIX_SOCKETMONITOR_H

data/ext/quickfix/SocketServer.cpp

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

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 "SocketMonitor.h"
+#include "Exceptions.h"
+#include <map>
+#include <set>
+#include <queue>
+
+namespace FIX
+{
+/// Information about listening socket
+struct SocketInfo
+{
+  SocketInfo()
+  : m_socket( -1 ), m_port( 0 ), m_noDelay( false ),
+    m_sendBufSize( 0 ), m_rcvBufSize( 0 ) {}
+  
+  SocketInfo( int socket, short port, bool noDelay, int sendBufSize, int rcvBufSize )
+  : m_socket( socket ), m_port( port ), m_noDelay( noDelay ), 
+    m_sendBufSize( sendBufSize ), m_rcvBufSize( rcvBufSize ) {}
+
+  int 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 );
+
+  int add( int port, bool reuse = false, bool noDelay = false, 
+           int sendBufSize = 0, int rcvBufSize = 0 ) throw( SocketException& );
+  int accept( int 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( int socket );
+  int portToSocket( int port );
+
+private:
+  typedef std::map<int, 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&, int acceptSocket, int socket ) = 0;
+    virtual void onWrite( SocketServer&, int socket ) = 0;
+    virtual bool onData( SocketServer&, int socket ) = 0;
+    virtual void onDisconnect( SocketServer&, int socket ) = 0;
+    virtual void onError( SocketServer& ) = 0;
+    virtual void onTimeout( SocketServer& ) {};
+  };
+};
+}
+
+#endif //FIX_SOCKETSERVER_H