quickfix_ruby 1.14.3

data/ext/quickfix/SocketAcceptor.cpp

@@ -0,0 +1,222 @@
+/****************************************************************************
+** 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 "SocketAcceptor.h"
+#include "Session.h"
+#include "Settings.h"
+#include "Utility.h"
+#include "Exceptions.h"
+
+namespace FIX
+{
+SocketAcceptor::SocketAcceptor( Application& application,
+                                MessageStoreFactory& factory,
+                                const SessionSettings& settings ) throw( ConfigError )
+: Acceptor( application, factory, settings ),
+  m_pServer( 0 ) {}
+
+SocketAcceptor::SocketAcceptor( Application& application,
+                                MessageStoreFactory& factory,
+                                const SessionSettings& settings,
+                                LogFactory& logFactory ) throw( 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& s )
+throw ( ConfigError )
+{
+  std::set<SessionID> sessions = s.getSessions();
+  std::set<SessionID>::iterator i;
+  for( i = sessions.begin(); i != sessions.end(); ++i )
+  {
+    const Dictionary& settings = s.get( *i );
+    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& s )
+throw ( RuntimeError )
+{
+  short port = 0;
+
+  try
+  {
+    m_pServer = new SocketServer( 1 );
+
+    std::set<SessionID> sessions = s.getSessions();
+    std::set<SessionID>::iterator i = sessions.begin();
+    for( ; i != sessions.end(); ++i )
+    {
+      const Dictionary& settings = s.get( *i );
+      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;
+
+      m_portToSessions[port].insert( *i );
+      m_pServer->add( port, reuseAddress, noDelay, sendBufSize, rcvBufSize );      
+    }    
+  }
+  catch( SocketException& e )
+  {
+    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( double timeout )
+{
+  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, timeout );
+  return true;
+}
+
+void SocketAcceptor::onStop()
+{
+}
+
+void SocketAcceptor::onConnect( SocketServer& server, int a, int s )
+{
+  if ( !socket_isValid( s ) ) return;
+  SocketConnections::iterator i = m_connections.find( s );
+  if ( i != m_connections.end() ) return;
+  int 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, int 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, int 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&, int 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();
+}
+}

data/ext/quickfix/SocketAcceptor.h

@@ -0,0 +1,75 @@
+/* -*- 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 "SocketServer.h"
+#include "SocketConnection.h"
+
+namespace FIX
+{
+/// Socket implementation of Acceptor.
+class SocketAcceptor : public Acceptor, SocketServer::Strategy
+{
+  friend class SocketConnection;
+public:
+  SocketAcceptor( Application&, MessageStoreFactory&,
+                  const SessionSettings& ) throw( ConfigError );
+  SocketAcceptor( Application&, MessageStoreFactory&,
+                  const SessionSettings&, LogFactory& ) throw( ConfigError );
+
+  virtual ~SocketAcceptor();
+
+private:
+  bool readSettings( const SessionSettings& );
+
+  typedef std::set < SessionID > Sessions;
+  typedef std::map < int, Sessions > PortToSessions;
+  typedef std::map < int, SocketConnection* > SocketConnections;
+
+  void onConfigure( const SessionSettings& ) throw ( ConfigError );
+  void onInitialize( const SessionSettings& ) throw ( RuntimeError );
+
+  void onStart();
+  bool onPoll( double timeout );
+  void onStop();
+
+  void onConnect( SocketServer&, int, int );
+  void onWrite( SocketServer&, int );
+  bool onData( SocketServer&, int );
+  void onDisconnect( SocketServer&, int );
+  void onError( SocketServer& );
+  void onTimeout( SocketServer& );
+
+  SocketServer* m_pServer;
+  PortToSessions m_portToSessions;
+  SocketConnections m_connections;
+};
+/*! @} */
+}
+
+#endif //FIX_SOCKETACCEPTOR_H

data/ext/quickfix/SocketConnection.cpp

@@ -0,0 +1,238 @@
+/****************************************************************************
+** 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 "SocketConnection.h"
+#include "SocketAcceptor.h"
+#include "SocketConnector.h"
+#include "SocketInitiator.h"
+#include "Session.h"
+#include "Utility.h"
+
+namespace FIX
+{
+SocketConnection::SocketConnection( int s, Sessions sessions,
+                                    SocketMonitor* pMonitor )
+: m_socket( s ), m_sendLength( 0 ),
+  m_sessions(sessions), m_pSession( 0 ), m_pMonitor( pMonitor )
+{
+  FD_ZERO( &m_fds );
+  FD_SET( m_socket, &m_fds );
+}
+
+SocketConnection::SocketConnection( SocketInitiator& i,
+                                    const SessionID& sessionID, int s,
+                                    SocketMonitor* pMonitor )
+: m_socket( s ), m_sendLength( 0 ),
+  m_pSession( i.getSession( sessionID, *this ) ),
+  m_pMonitor( pMonitor ) 
+{
+  FD_ZERO( &m_fds );
+  FD_SET( m_socket, &m_fds );
+  m_sessions.insert( sessionID );
+}
+
+SocketConnection::~SocketConnection()
+{
+  if ( m_pSession )
+    Session::unregisterSession( m_pSession->getSessionID() );
+}
+
+bool SocketConnection::send( const std::string& msg )
+{
+  Locker l( m_mutex );
+
+  m_sendQueue.push_back( msg );
+  processQueue();
+  signal();
+  return true;
+}
+
+bool SocketConnection::processQueue()
+{
+  Locker l( m_mutex );
+
+  if( !m_sendQueue.size() ) return true;
+
+  struct timeval timeout = { 0, 0 };
+  fd_set writeset = m_fds;
+  if( select( 1 + m_socket, 0, &writeset, 0, &timeout ) <= 0 )
+    return false;
+    
+  const std::string& msg = m_sendQueue.front();
+
+  size_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& a, SocketServer& s )
+{
+  std::string msg;
+  try
+  {
+    if ( !m_pSession )
+    {
+      struct timeval timeout = { 1, 0 };
+      fd_set readset = m_fds;
+
+      while( !readMessage( msg ) )
+      {
+        int result = select( 1 + m_socket, &readset, 0, 0, &timeout );
+        if( result > 0 )
+          readFromSocket();
+        else if( result == 0 )
+          return false;
+        else if( result < 0 )
+          return false;
+      }
+
+      m_pSession = Session::lookupSession( msg, true );
+      if( !isValidSession() )
+      {
+        m_pSession = 0;
+        if( a.getLog() )
+        {
+          a.getLog()->onEvent( "Session not found for incoming message: " + msg );
+          a.getLog()->onIncoming( msg );
+        }
+      }
+      if( m_pSession )
+        m_pSession = a.getSession( msg, *this );
+      if( m_pSession )
+        m_pSession->next( msg, UtcTimeStamp() );
+      if( !m_pSession )
+      {
+        s.getMonitor().drop( m_socket );
+        return false;
+      }
+
+      Session::registerSession( m_pSession->getSessionID() );
+      return true;
+    }
+    else
+    {
+      readFromSocket();
+      readMessages( s.getMonitor() );
+      return true;
+    }
+  }
+  catch ( SocketRecvFailed& e )
+  {
+    if( m_pSession )
+      m_pSession->getLog()->onEvent( e.what() );
+    s.getMonitor().drop( m_socket );
+  }
+  catch ( InvalidMessage& )
+  {
+    s.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()
+throw( SocketRecvFailed )
+{
+  ssize_t size = recv( m_socket, m_buffer, sizeof(m_buffer), 0 );
+  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& s )
+{
+  if( !m_pSession ) return;
+
+  std::string msg;
+  while( readMessage( msg ) )
+  {
+    try
+    {
+      m_pSession->next( msg, UtcTimeStamp() );
+    }
+    catch ( InvalidMessage& )
+    {
+      if( !m_pSession->isLoggedOn() )
+        s.drop( m_socket );
+    }
+  }
+}
+
+void SocketConnection::onTimeout()
+{
+  if ( m_pSession ) m_pSession->next();
+}
+} // namespace FIX

data/ext/quickfix/SocketConnection.h

@@ -0,0 +1,103 @@
+/* -*- 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 "Parser.h"
+#include "Responder.h"
+#include "SessionID.h"
+#include "SocketMonitor.h"
+#include "Utility.h"
+#include "Mutex.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( int s, Sessions sessions, SocketMonitor* pMonitor );
+  SocketConnection( SocketInitiator&, const SessionID&, int, SocketMonitor* );
+  virtual ~SocketConnection();
+
+  int 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() throw( SocketRecvFailed );
+  bool readMessage( std::string& msg );
+  void readMessages( SocketMonitor& s );
+  bool send( const std::string& );
+  void disconnect();
+
+  int m_socket;
+  char m_buffer[BUFSIZ];
+
+  Parser m_parser;
+  Queue m_sendQueue;
+  unsigned m_sendLength;
+  Sessions m_sessions;
+  Session* m_pSession;
+  SocketMonitor* m_pMonitor;
+  Mutex m_mutex;
+  fd_set m_fds;
+};
+}
+
+#endif //FIX_SOCKETCONNECTION_H