quickfix_ruby 1.14.3

data/ext/quickfix/HttpConnection.h

@@ -0,0 +1,78 @@
+/* -*- 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_HTTPCONNECTION_H
+#define FIX_HTTPCONNECTION_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "HttpParser.h"
+#include <stdio.h>
+
+namespace FIX
+{
+class HttpMessage;
+
+/// Encapsulates a HTTP socket file descriptor
+class HttpConnection
+{
+public:
+  HttpConnection( int s );
+
+  int getSocket() const { return m_socket; }
+  bool read();
+
+private:
+  bool readMessage( std::string& msg ) throw( SocketRecvFailed );
+  void processStream();
+  void processRequest( const HttpMessage& );
+  void processRoot( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processResetSessions( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processRefreshSessions( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processEnableSessions( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processDisableSessions( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processSession( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processResetSession( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+  void processRefreshSession( const HttpMessage&, std::stringstream& h, std::stringstream& b );
+ 
+ void showToggle
+    ( std::stringstream& s, const std::string& name, bool value, const std::string& url );
+  void showRow
+    ( std::stringstream& s, const std::string& name, bool value, const std::string& url = "" );
+  void showRow
+    ( std::stringstream& s, const std::string& name, const std::string& value, const std::string& url = "" );
+  void showRow
+    ( std::stringstream& s, const std::string& name, int value, const std::string& url = "" );
+
+  bool send( const std::string& );
+  void disconnect( int error = 0 );
+
+  int m_socket;
+  char m_buffer[BUFSIZ];
+
+  HttpParser m_parser;
+  fd_set m_fds;
+};
+}
+
+#endif

data/ext/quickfix/HttpMessage.cpp

@@ -0,0 +1,149 @@
+/****************************************************************************
+** 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 "HttpMessage.h"
+#include "Utility.h"
+#include <sstream>
+#include <iomanip>
+
+namespace FIX
+{
+
+HttpMessage::HttpMessage() {}
+
+HttpMessage::HttpMessage( const std::string& string )
+throw( InvalidMessage )
+{
+  setString( string );
+}
+
+std::string HttpMessage::toString() const
+{
+  std::string str;
+  return toString( str );
+}
+
+std::string& HttpMessage::toString( std::string& str ) const
+{
+  str = m_root + getParameterString();
+  return str;
+}
+
+void HttpMessage::setString( const std::string& string )
+throw( InvalidMessage )
+{
+  clear();
+
+  std::string::size_type eolPos = string.find( "\r\n" );
+  if( eolPos == std::string::npos ) throw InvalidMessage();
+  std::string line = string.substr( 0, eolPos );
+  std::string::size_type getPos = line.find( "GET " );
+  if( getPos != 0 ) throw InvalidMessage();
+  std::string::size_type httpPos = line.rfind( "HTTP", std::string::npos );
+  if( httpPos == std::string::npos ) throw InvalidMessage();
+
+  m_root = line.substr( getPos + 4, httpPos - 5 );
+  std::string::size_type paramPos = m_root.find_first_of( '?' );
+  if( paramPos == std::string::npos ) return;
+  std::string parameters = m_root.substr( paramPos, m_root.size() - paramPos );
+  m_root = m_root.substr( 0, paramPos );
+  paramPos = 0;
+
+  while( paramPos != std::string::npos )
+  {
+    std::string::size_type sepPos = parameters.find_first_of( "=", paramPos );
+    if( sepPos == std::string::npos ) break;
+    std::string::size_type tempPos = paramPos;
+    paramPos = parameters.find_first_of( "&", paramPos + 1 );
+    std::string key = parameters.substr(tempPos + 1, sepPos - tempPos - 1);
+    std::string value = parameters.substr(sepPos + 1, paramPos - sepPos - 1);
+    m_parameters[key] = value;
+  }
+}
+
+std::string HttpMessage::createResponse( int error, const std::string& text )
+{
+  std::string errorString;
+  switch( error )
+  {
+  case 100: errorString = "Continue"; break;
+  case 101: errorString = "Switching Protocols"; break;
+  case 200: errorString = "OK"; break;
+  case 201: errorString = "Created"; break;
+  case 202: errorString = "Accepted"; break;
+  case 203: errorString = "Non-Authoritative Information"; break;
+  case 204: errorString = "No Content"; break;
+  case 205: errorString = "Reset Content"; break;
+  case 206: errorString = "Partial Content"; break;
+  case 300: errorString = "Multiple Choices"; break;
+  case 301: errorString = "Moved Permanently"; break;
+  case 302: errorString = "Found"; break;
+  case 303: errorString = "See Other"; break;
+  case 304: errorString = "Not Modified"; break;
+  case 305: errorString = "Use Proxy"; break;
+  case 307: errorString = "Temporary Redirect"; break;
+  case 400: errorString = "Bad Request"; break;
+  case 401: errorString = "Unauthorized"; break;
+  case 402: errorString = "Payment Required"; break;
+  case 403: errorString = "Forbidden"; break;
+  case 404: errorString = "Not Found"; break;
+  case 405: errorString = "Method Not Allowed"; break;
+  case 406: errorString = "Not Acceptable"; break;
+  case 407: errorString = "Proxy Authentication Required"; break;
+  case 408: errorString = "Request Timeout"; break;
+  case 409: errorString = "Conflict"; break;
+  case 410: errorString = "Gone"; break;
+  case 411: errorString = "Length Required"; break;
+  case 412: errorString = "Precondition Failed"; break;
+  case 413: errorString = "Request Entity Too Large"; break;
+  case 414: errorString = "Request-URI Too Large"; break;
+  case 415: errorString = "Unsupported Media Type"; break;
+  case 416: errorString = "Requested Range Not Satisfiable"; break;
+  case 417: errorString = "Expectation Failed"; break;
+  case 500: errorString = "Internal Server Error"; break;
+  case 501: errorString = "Not Implemented"; break;
+  case 502: errorString = "Bad Gateway"; break;
+  case 503: errorString = "Service Unavailable"; break;
+  case 504: errorString = "Gateway Timeout"; break;
+  case 505: errorString = "HTTP Version not supported"; break;
+  default: errorString = "Unknown";
+  }
+
+  std::stringstream response;
+  response << "HTTP/1.1 " << error << " " << errorString << "\r\n"
+           << "Server: QuickFIX" << "\r\n"
+           << "Content-Type: text/html; charset=iso-8859-1" << "\r\n\r\n"
+           << "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">";
+
+  if( error < 200 || error >= 300 )
+    response << "<HTML><HEAD><TITLE>" << error << " " << errorString << "</TITLE></HEAD><BODY>"
+             << "<H1>" << error << " " << errorString << "</H1>" << text << "</BODY></HTML>";
+  else
+    response << text;
+
+  return response.str();
+}
+
+}

data/ext/quickfix/HttpMessage.h

@@ -0,0 +1,133 @@
+/* -*- 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_HTTPMESSAGE
+#define FIX_HTTPMESSAGE
+
+#ifdef _MSC_VER
+#pragma warning( disable: 4786 )
+#endif
+
+#include "Exceptions.h"
+#include <map>
+
+namespace FIX
+{
+/**
+ * HTTP Message that implemented GET functionality
+ */
+class HttpMessage
+{
+public:
+  typedef std::map<std::string, std::string> Parameters;
+
+  HttpMessage();
+
+  /// Construct a message from a string
+  HttpMessage( const std::string& string )
+  throw( InvalidMessage );
+
+  HttpMessage( const HttpMessage& copy )
+  {
+    m_root = copy.m_root;
+    m_parameters = copy.m_parameters;
+  }
+
+public:
+  /// Get a string representation of the message
+  std::string toString() const;
+  /// Get a string representation without making a copy
+  std::string& toString( std::string& ) const;
+
+  void setString( const std::string& string )
+  throw( InvalidMessage );
+
+  void clear()
+  {
+#if defined(_MSC_VER) && _MSC_VER < 1300
+    m_root = "";
+#else
+    m_root.clear();
+#endif
+    m_parameters.clear();
+  }
+
+  const std::string& getRootString() const
+  { return m_root; }
+
+  const std::string getParameterString() const
+  {
+    std::string result;
+    Parameters::const_iterator i;
+    for( i = m_parameters.begin(); i != m_parameters.end(); ++i )
+    {
+      result += (i == m_parameters.begin()) ? "?" : "&";
+      result += i->first + "=" + i->second;
+    }
+    return result;
+  }
+
+  const Parameters& getParameters() const
+  { return m_parameters; }
+
+  bool hasParameter( const std::string& key ) const
+  {
+    Parameters::const_iterator find = m_parameters.find( key );
+    return find != m_parameters.end();
+  }
+
+  const std::string& getParameter( const std::string& key ) const
+  throw( std::logic_error )
+  {
+    Parameters::const_iterator find = m_parameters.find( key );
+    if( find == m_parameters.end() )
+      throw std::logic_error( "Parameter " + key + " not found" );
+    return find->second;
+  }
+
+  void addParameter( const std::string& key, const std::string& value )
+  {
+    m_parameters[key] = value;
+  }
+
+  void removeParameter( const std::string& key )
+  {
+    m_parameters.erase( key );
+  }  
+
+  static std::string createResponse( int error = 0, const std::string& text = "" );
+ 
+private:
+  std::string m_root;
+  Parameters m_parameters;
+};
+/*! @} */
+
+inline std::ostream& operator <<
+( std::ostream& stream, const HttpMessage& message )
+{
+  std::string str;
+  stream << message.toString( str );
+  return stream;
+}
+}
+
+#endif //FIX_HTTPMESSAGE

data/ext/quickfix/HttpParser.cpp

@@ -0,0 +1,49 @@
+/****************************************************************************
+** 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 "HttpParser.h"
+#include "Utility.h"
+#include <algorithm>
+
+namespace FIX
+{
+bool HttpParser::readHttpMessage( std::string& str )
+throw( MessageParseError )
+{
+  std::string::size_type pos = 0;
+
+  if( m_buffer.length() < 4 ) 
+    return false;
+  pos = m_buffer.find( "\r\n\r\n" );
+  if( m_buffer.length() > 2048 )
+    throw MessageParseError();
+  if( pos == std::string::npos ) 
+    return false;
+  str.assign( m_buffer, 0, pos + 4 );
+  m_buffer.erase( 0, pos + 4 );
+
+  return true;
+}
+}

data/ext/quickfix/HttpParser.h

@@ -0,0 +1,54 @@
+/* -*- 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_HTTPPARSER_H
+#define FIX_HTTPPARSER_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "Exceptions.h"
+#include <iostream>
+#include <string>
+
+namespace FIX
+{
+/// Parses HTTP messages off an input stream.
+class HttpParser
+{
+public:
+  HttpParser() {}
+  ~HttpParser() {}
+
+  bool readHttpMessage( std::string& str )
+  throw ( MessageParseError );
+
+  void addToStream( const char* str, size_t len )
+  { m_buffer.append( str, len ); }
+  void addToStream( const std::string& str )
+  { m_buffer.append( str ); }
+
+private:
+  std::string m_buffer;
+};
+}
+#endif //FIX_HTTPPARSER_H

data/ext/quickfix/HttpServer.cpp

@@ -0,0 +1,169 @@
+/****************************************************************************
+** 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 "HttpServer.h"
+#include "HttpConnection.h"
+#include "Settings.h"
+#include "Utility.h"
+
+namespace FIX
+{
+Mutex HttpServer::s_mutex;
+int HttpServer::s_count = 0;
+HttpServer* HttpServer::s_pServer = 0;
+
+void HttpServer::startGlobal( const SessionSettings& s ) 
+throw ( ConfigError, RuntimeError )
+{
+  Locker l( s_mutex );
+
+  if( !s.get().has(HTTP_ACCEPT_PORT) )
+    return;
+
+  s_count += 1;
+  if( !s_pServer )
+  {
+    s_pServer = new HttpServer( s );
+    s_pServer->start();
+  }
+}
+
+void HttpServer::stopGlobal()
+{
+  Locker l( s_mutex );
+
+  s_count -= 1;
+  if( !s_count && s_pServer )
+  {
+    s_pServer->stop();
+    delete s_pServer;
+    s_pServer = 0;
+  }  
+}
+
+HttpServer::HttpServer( const SessionSettings& settings ) throw( ConfigError )
+: m_pServer( 0 ), m_settings( settings ), m_threadid( 0 ), m_port( 0 ), m_stop( false ) {}
+
+void HttpServer::onConfigure( const SessionSettings& s )
+throw ( ConfigError )
+{  
+  m_port = s.get().getInt( HTTP_ACCEPT_PORT );
+}
+
+void HttpServer::onInitialize( const SessionSettings& s )
+throw ( RuntimeError )
+{
+  try
+  {
+    m_pServer = new SocketServer( 1 );
+    m_pServer->add( m_port, true, false, 0, 0 );
+  }
+  catch( std::exception& )
+  {
+    throw RuntimeError( "Unable to create, bind, or listen to port " + IntConvertor::convert( (unsigned short)m_port ) );
+  }
+}
+
+void HttpServer::start() throw ( ConfigError, RuntimeError )
+{
+  m_stop = false;
+  onConfigure( m_settings );
+  onInitialize( m_settings );
+
+  if( !thread_spawn( &startThread, this, m_threadid ) )
+    throw RuntimeError("Unable to spawn thread");
+}
+
+void HttpServer::stop()
+{
+  if( m_stop ) return;
+  m_stop = true;
+  onStop();
+
+  if( m_threadid )
+    thread_join( m_threadid );
+  m_threadid = 0;
+}
+
+void HttpServer::onStart()
+{
+  while ( !m_stop && m_pServer && m_pServer->block( *this ) ) {}
+
+  if( !m_pServer )
+    return;
+
+  m_pServer->close();
+  delete m_pServer;
+  m_pServer = 0;
+}
+
+bool HttpServer::onPoll()
+{
+  if( !m_pServer || m_stop )
+    return false;
+
+  m_pServer->block( *this, true );
+  return true;
+}
+
+void HttpServer::onStop() 
+{
+}
+
+void HttpServer::onConnect( SocketServer& server, int a, int s )
+{
+  if ( !socket_isValid( s ) ) return;
+  HttpConnection connection( s );
+  while( connection.read() ) {}
+  m_pServer->getMonitor().drop( s );
+}
+
+void HttpServer::onWrite( SocketServer& server, int s ) 
+{
+}
+
+bool HttpServer::onData( SocketServer& server, int s )
+{
+  return true;
+}
+
+void HttpServer::onDisconnect( SocketServer&, int s ) 
+{
+}
+
+void HttpServer::onError( SocketServer& ) {}
+
+void HttpServer::onTimeout( SocketServer& )
+{
+}
+
+THREAD_PROC HttpServer::startThread( void* p )
+{
+  HttpServer * pServer = static_cast < HttpServer* > ( p );
+  pServer->onStart();
+  return 0;
+}
+
+}

data/ext/quickfix/HttpServer.h

@@ -0,0 +1,78 @@
+/* -*- 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_HTTPSERVER_H
+#define FIX_HTTPSERVER_H
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4503 4355 4786 4290 )
+#endif
+
+#include "SocketServer.h"
+#include "SessionSettings.h"
+#include "Exceptions.h"
+#include "Mutex.h"
+
+namespace FIX
+{
+/// Basic HTTP Server
+class HttpServer : public SocketServer::Strategy
+{
+public:
+  HttpServer( const SessionSettings& ) throw( ConfigError );
+
+  static void startGlobal( const SessionSettings& ) throw ( ConfigError, RuntimeError );
+  static void stopGlobal();
+
+  void start() throw ( ConfigError, RuntimeError );
+  void stop();
+
+private:
+  void onConfigure( const SessionSettings& ) throw ( ConfigError );
+  void onInitialize( const SessionSettings& ) throw ( RuntimeError );
+
+  void onStart();
+  bool onPoll();
+  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& );
+
+  static THREAD_PROC startThread( void* p );
+
+  SocketServer* m_pServer;
+  SessionSettings m_settings;
+  thread_id m_threadid;
+  int m_port;
+  bool m_stop;
+
+  static Mutex s_mutex;
+  static int s_count;
+  static HttpServer* s_pServer;
+};
+/*! @} */
+}
+
+#endif //FIX_HTTPSERVER_H