quickfix_ruby_ud 2.0.7-x86_64-linux

data/ext/quickfix/HttpConnection.h

@@ -0,0 +1,74 @@
+/* -*- 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(socket_handle s);
+
+  socket_handle getSocket() const { return m_socket; }
+  bool read();
+
+private:
+  bool readMessage(std::string &msg) EXCEPT(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);
+
+  socket_handle m_socket;
+  char m_buffer[BUFSIZ];
+
+  HttpParser m_parser;
+#if _MSC_VER
+  fd_set m_fds;
+#endif
+};
+} // namespace FIX
+
+#endif

data/ext/quickfix/HttpMessage.cpp

@@ -0,0 +1,229 @@
+/****************************************************************************
+** 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 <iomanip>
+#include <sstream>
+
+namespace FIX {
+
+HttpMessage::HttpMessage() {}
+
+HttpMessage::HttpMessage(const std::string &string) EXCEPT(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) EXCEPT(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();
+}
+
+} // namespace FIX

data/ext/quickfix/HttpMessage.h

@@ -0,0 +1,112 @@
+/* -*- 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) EXCEPT(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) EXCEPT(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;
+    for (Parameters::const_iterator 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 EXCEPT(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;
+}
+} // namespace FIX
+
+#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) EXCEPT(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;
+}
+} // namespace FIX

data/ext/quickfix/HttpParser.h

@@ -0,0 +1,49 @@
+/* -*- 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) EXCEPT(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;
+};
+} // namespace FIX
+#endif // FIX_HTTPPARSER_H

data/ext/quickfix/HttpServer.cpp

@@ -0,0 +1,152 @@
+/****************************************************************************
+** 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 "HttpConnection.h"
+#include "HttpServer.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) EXCEPT(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) EXCEPT(ConfigError)
+    : m_pServer(0),
+      m_settings(settings),
+      m_threadid(0),
+      m_port(0),
+      m_stop(false) {}
+
+void HttpServer::onConfigure(const SessionSettings &s) EXCEPT(ConfigError) {
+  m_port = s.get().getInt(HTTP_ACCEPT_PORT);
+}
+
+void HttpServer::onInitialize(const SessionSettings &s) EXCEPT(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() EXCEPT(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, socket_handle a, socket_handle s) {
+  if (!socket_isValid(s)) {
+    return;
+  }
+  HttpConnection connection(s);
+  while (connection.read()) {}
+  m_pServer->getMonitor().drop(s);
+}
+
+void HttpServer::onWrite(SocketServer &server, socket_handle s) {}
+
+bool HttpServer::onData(SocketServer &server, socket_handle s) { return true; }
+
+void HttpServer::onDisconnect(SocketServer &, socket_handle 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;
+}
+
+} // namespace FIX