Initial Import.

HttpServer/connection.h

@@ -0,0 +1,164 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+#ifndef HTTP_SERVER3_CONNECTION_HPP
+#define HTTP_CONNECTION_HPP
+
+#include <vector>
+
+#include <boost/asio.hpp>
+#include <boost/array.hpp>
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include "reply.h"
+#include "request.h"
+#include "request_handler.h"
+#include "request_parser.h"
+
+namespace http {
+
+
+/// Represents a single connection from a client.
+class connection
+: public boost::enable_shared_from_this<connection>,
+private boost::noncopyable
+{
+public:
+    /// Construct a connection with the given io_service.
+    explicit connection(boost::asio::io_service& io_service,
+            request_handler& handler);
+
+    /// Get the socket associated with the connection.
+    boost::asio::ip::tcp::socket& socket();
+
+    /// Start the first asynchronous operation for the connection.
+    void start();
+
+private:
+    /// Handle completion of a read operation.
+    void handle_read(const boost::system::error_code& e,
+            std::size_t bytes_transferred);
+
+    /// Handle completion of a write operation.
+    void handle_write(const boost::system::error_code& e);
+
+    /// Strand to ensure the connection's handlers are not called concurrently.
+    boost::asio::io_service::strand strand_;
+
+    /// Socket for the connection.
+    boost::asio::ip::tcp::socket socket_;
+
+    /// The handler used to process the incoming request.
+    request_handler& request_handler_;
+
+    /// Buffer for incoming data.
+    boost::array<char, 8192> buffer_;
+
+    /// The incoming request.
+    request request_;
+
+    /// The parser for the incoming request.
+    request_parser request_parser_;
+
+    /// The reply to be sent back to the client.
+    reply reply_;
+};
+
+typedef boost::shared_ptr<connection> connection_ptr;
+
+
+connection::connection(boost::asio::io_service& io_service,
+        request_handler& handler)
+: strand_(io_service),
+  socket_(io_service),
+  request_handler_(handler)
+{
+}
+
+boost::asio::ip::tcp::socket& connection::socket()
+{
+    return socket_;
+}
+
+void connection::start()
+{
+    socket_.async_read_some(boost::asio::buffer(buffer_),
+            strand_.wrap(
+                    boost::bind(&connection::handle_read, shared_from_this(),
+                            boost::asio::placeholders::error,
+                            boost::asio::placeholders::bytes_transferred)));
+}
+
+void connection::handle_read(const boost::system::error_code& e,
+        std::size_t bytes_transferred)
+{
+    if (!e)
+    {
+        boost::tribool result;
+        boost::tie(result, boost::tuples::ignore) = request_parser_.parse(
+                request_, buffer_.data(), buffer_.data() + bytes_transferred);
+
+        if (result)
+        {
+            request_handler_.handle_request(request_, reply_);
+            boost::asio::async_write(socket_, reply_.to_buffers(),
+                    strand_.wrap(
+                            boost::bind(&connection::handle_write, shared_from_this(),
+                                    boost::asio::placeholders::error)));
+        }
+        else if (!result)
+        {
+            reply_ = reply::stock_reply(reply::bad_request);
+            boost::asio::async_write(socket_, reply_.to_buffers(),
+                    strand_.wrap(
+                            boost::bind(&connection::handle_write, shared_from_this(),
+                                    boost::asio::placeholders::error)));
+        }
+        else
+        {
+            socket_.async_read_some(boost::asio::buffer(buffer_),
+                    strand_.wrap(
+                            boost::bind(&connection::handle_read, shared_from_this(),
+                                    boost::asio::placeholders::error,
+                                    boost::asio::placeholders::bytes_transferred)));
+        }
+    }
+}
+
+void connection::handle_write(const boost::system::error_code& e)
+{
+    if (!e)
+    {
+        // Initiate graceful connection closure.
+        boost::system::error_code ignored_ec;
+        socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
+    }
+
+    // No new asynchronous operations are started. This means that all shared_ptr
+    // references to the connection object will disappear and the object will be
+    // destroyed automatically after this handler returns. The connection class's
+    // destructor closes the socket.
+}
+
+} // namespace http
+
+#endif /* CONNECTION_HPP_ */

HttpServer/header.h

@@ -0,0 +1,37 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+#ifndef HTTP_HEADER_HPP
+#define HTTP_HEADER_HPP
+
+#include <string>
+
+namespace http {
+
+
+struct header
+{
+  std::string name;
+  std::string value;
+};
+
+}
+
+#endif

HttpServer/reply.h

@@ -0,0 +1,312 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+
+#ifndef HTTP_SERVER3_REPLY_HPP
+#define HTTP_SERVER3_REPLY_HPP
+
+#include <string>
+#include <vector>
+#include <boost/asio.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include "header.h"
+
+namespace http {
+
+/// A reply to be sent to a client.
+struct reply
+{
+  /// The status of the reply.
+  enum status_type
+  {
+    ok = 200,
+    created = 201,
+    accepted = 202,
+    no_content = 204,
+    multiple_choices = 300,
+    moved_permanently = 301,
+    moved_temporarily = 302,
+    not_modified = 304,
+    bad_request = 400,
+    unauthorized = 401,
+    forbidden = 403,
+    not_found = 404,
+    internal_server_error = 500,
+    not_implemented = 501,
+    bad_gateway = 502,
+    service_unavailable = 503
+  } status;
+
+  /// The headers to be included in the reply.
+  std::vector<header> headers;
+
+  /// The content to be sent in the reply.
+  std::string content;
+
+  /// Convert the reply into a vector of buffers. The buffers do not own the
+  /// underlying memory blocks, therefore the reply object must remain valid and
+  /// not be changed until the write operation has completed.
+  std::vector<boost::asio::const_buffer> to_buffers();
+
+  /// Get a stock reply.
+  static reply stock_reply(status_type status);
+};
+
+namespace status_strings {
+
+const std::string ok =
+  "HTTP/1.0 200 OK\r\n";
+const std::string created =
+  "HTTP/1.0 201 Created\r\n";
+const std::string accepted =
+  "HTTP/1.0 202 Accepted\r\n";
+const std::string no_content =
+  "HTTP/1.0 204 No Content\r\n";
+const std::string multiple_choices =
+  "HTTP/1.0 300 Multiple Choices\r\n";
+const std::string moved_permanently =
+  "HTTP/1.0 301 Moved Permanently\r\n";
+const std::string moved_temporarily =
+  "HTTP/1.0 302 Moved Temporarily\r\n";
+const std::string not_modified =
+  "HTTP/1.0 304 Not Modified\r\n";
+const std::string bad_request =
+  "HTTP/1.0 400 Bad Request\r\n";
+const std::string unauthorized =
+  "HTTP/1.0 401 Unauthorized\r\n";
+const std::string forbidden =
+  "HTTP/1.0 403 Forbidden\r\n";
+const std::string not_found =
+  "HTTP/1.0 404 Not Found\r\n";
+const std::string internal_server_error =
+  "HTTP/1.0 500 Internal Server Error\r\n";
+const std::string not_implemented =
+  "HTTP/1.0 501 Not Implemented\r\n";
+const std::string bad_gateway =
+  "HTTP/1.0 502 Bad Gateway\r\n";
+const std::string service_unavailable =
+  "HTTP/1.0 503 Service Unavailable\r\n";
+
+boost::asio::const_buffer to_buffer(reply::status_type status)
+{
+  switch (status)
+  {
+  case reply::ok:
+    return boost::asio::buffer(ok);
+  case reply::created:
+    return boost::asio::buffer(created);
+  case reply::accepted:
+    return boost::asio::buffer(accepted);
+  case reply::no_content:
+    return boost::asio::buffer(no_content);
+  case reply::multiple_choices:
+    return boost::asio::buffer(multiple_choices);
+  case reply::moved_permanently:
+    return boost::asio::buffer(moved_permanently);
+  case reply::moved_temporarily:
+    return boost::asio::buffer(moved_temporarily);
+  case reply::not_modified:
+    return boost::asio::buffer(not_modified);
+  case reply::bad_request:
+    return boost::asio::buffer(bad_request);
+  case reply::unauthorized:
+    return boost::asio::buffer(unauthorized);
+  case reply::forbidden:
+    return boost::asio::buffer(forbidden);
+  case reply::not_found:
+    return boost::asio::buffer(not_found);
+  case reply::internal_server_error:
+    return boost::asio::buffer(internal_server_error);
+  case reply::not_implemented:
+    return boost::asio::buffer(not_implemented);
+  case reply::bad_gateway:
+    return boost::asio::buffer(bad_gateway);
+  case reply::service_unavailable:
+    return boost::asio::buffer(service_unavailable);
+  default:
+    return boost::asio::buffer(internal_server_error);
+  }
+}
+
+} // namespace status_strings
+
+namespace misc_strings {
+
+const char name_value_separator[] = { ':', ' ' };
+const char crlf[] = { '\r', '\n' };
+
+} // namespace misc_strings
+
+std::vector<boost::asio::const_buffer> reply::to_buffers()
+{
+  std::vector<boost::asio::const_buffer> buffers;
+  buffers.push_back(status_strings::to_buffer(status));
+  for (std::size_t i = 0; i < headers.size(); ++i)
+  {
+    header& h = headers[i];
+    buffers.push_back(boost::asio::buffer(h.name));
+    buffers.push_back(boost::asio::buffer(misc_strings::name_value_separator));
+    buffers.push_back(boost::asio::buffer(h.value));
+    buffers.push_back(boost::asio::buffer(misc_strings::crlf));
+  }
+  buffers.push_back(boost::asio::buffer(misc_strings::crlf));
+  buffers.push_back(boost::asio::buffer(content));
+  return buffers;
+}
+
+namespace stock_replies {
+
+const char ok[] = "";
+const char created[] =
+  "<html>"
+  "<head><title>Created</title></head>"
+  "<body><h1>201 Created</h1></body>"
+  "</html>";
+const char accepted[] =
+  "<html>"
+  "<head><title>Accepted</title></head>"
+  "<body><h1>202 Accepted</h1></body>"
+  "</html>";
+const char no_content[] =
+  "<html>"
+  "<head><title>No Content</title></head>"
+  "<body><h1>204 Content</h1></body>"
+  "</html>";
+const char multiple_choices[] =
+  "<html>"
+  "<head><title>Multiple Choices</title></head>"
+  "<body><h1>300 Multiple Choices</h1></body>"
+  "</html>";
+const char moved_permanently[] =
+  "<html>"
+  "<head><title>Moved Permanently</title></head>"
+  "<body><h1>301 Moved Permanently</h1></body>"
+  "</html>";
+const char moved_temporarily[] =
+  "<html>"
+  "<head><title>Moved Temporarily</title></head>"
+  "<body><h1>302 Moved Temporarily</h1></body>"
+  "</html>";
+const char not_modified[] =
+  "<html>"
+  "<head><title>Not Modified</title></head>"
+  "<body><h1>304 Not Modified</h1></body>"
+  "</html>";
+const char bad_request[] =
+  "<html>"
+  "<head><title>Bad Request</title></head>"
+  "<body><h1>400 Bad Request</h1></body>"
+  "</html>";
+const char unauthorized[] =
+  "<html>"
+  "<head><title>Unauthorized</title></head>"
+  "<body><h1>401 Unauthorized</h1></body>"
+  "</html>";
+const char forbidden[] =
+  "<html>"
+  "<head><title>Forbidden</title></head>"
+  "<body><h1>403 Forbidden</h1></body>"
+  "</html>";
+const char not_found[] =
+  "<html>"
+  "<head><title>Not Found</title></head>"
+  "<body><h1>404 Not Found</h1></body>"
+  "</html>";
+const char internal_server_error[] =
+  "<html>"
+  "<head><title>Internal Server Error</title></head>"
+  "<body><h1>500 Internal Server Error</h1></body>"
+  "</html>";
+const char not_implemented[] =
+  "<html>"
+  "<head><title>Not Implemented</title></head>"
+  "<body><h1>501 Not Implemented</h1></body>"
+  "</html>";
+const char bad_gateway[] =
+  "<html>"
+  "<head><title>Bad Gateway</title></head>"
+  "<body><h1>502 Bad Gateway</h1></body>"
+  "</html>";
+const char service_unavailable[] =
+  "<html>"
+  "<head><title>Service Unavailable</title></head>"
+  "<body><h1>503 Service Unavailable</h1></body>"
+  "</html>";
+
+std::string to_string(reply::status_type status)
+{
+  switch (status)
+  {
+  case reply::ok:
+    return ok;
+  case reply::created:
+    return created;
+  case reply::accepted:
+    return accepted;
+  case reply::no_content:
+    return no_content;
+  case reply::multiple_choices:
+    return multiple_choices;
+  case reply::moved_permanently:
+    return moved_permanently;
+  case reply::moved_temporarily:
+    return moved_temporarily;
+  case reply::not_modified:
+    return not_modified;
+  case reply::bad_request:
+    return bad_request;
+  case reply::unauthorized:
+    return unauthorized;
+  case reply::forbidden:
+    return forbidden;
+  case reply::not_found:
+    return not_found;
+  case reply::internal_server_error:
+    return internal_server_error;
+  case reply::not_implemented:
+    return not_implemented;
+  case reply::bad_gateway:
+    return bad_gateway;
+  case reply::service_unavailable:
+    return service_unavailable;
+  default:
+    return internal_server_error;
+  }
+}
+
+} // namespace stock_replies
+
+reply reply::stock_reply(reply::status_type status)
+{
+  reply rep;
+  rep.status = status;
+  rep.content = stock_replies::to_string(status);
+  rep.headers.resize(2);
+  rep.headers[0].name = "Content-Length";
+  rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
+  rep.headers[1].name = "Content-Type";
+  rep.headers[1].value = "text/html";
+  return rep;
+}
+
+} // namespace http
+
+#endif // HTTP_SERVER3_REPLY_HPP

HttpServer/request.h

@@ -0,0 +1,42 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, others 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+#ifndef HTTP_REQUEST_HPP
+#define HTTP_REQUEST_HPP
+
+#include <string>
+#include <vector>
+#include "header.h"
+
+namespace http {
+
+/// A request received from a client.
+struct request
+{
+  std::string method;
+  std::string uri;
+  int http_version_major;
+  int http_version_minor;
+  std::vector<header> headers;
+};
+
+}
+
+#endif // HTTP_REQUEST_HPP

HttpServer/request_handler.h

@@ -0,0 +1,170 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+#ifndef HTTP_ROUTER_REQUEST_HANDLER_HPP
+#define HTTP_ROUTER_REQUEST_HANDLER_HPP
+
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <boost/lexical_cast.hpp>
+#include <boost/noncopyable.hpp>
+
+#include "reply.h"
+#include "request.h"
+
+#include "../typedefs.h"
+
+namespace http {
+
+struct reply;
+struct request;
+
+/// The common handler for all incoming requests.
+class request_handler : private boost::noncopyable
+{
+public:
+    /// Construct with a directory containing files to be served.
+    explicit request_handler(SearchEngine<EdgeData> * s) : sEngine(s){}
+
+    /// Handle a request and produce a reply.
+    void handle_request(const request& req, reply& rep){
+        try {
+            std::string request(req.uri);
+            std::string command;
+            std::size_t first_amp_pos = request.find_first_of("&");
+            command = request.substr(1,first_amp_pos-1);
+//            cout << "command: " << command << endl;
+            if(command == "locate")
+            {
+                std::size_t last_amp_pos = request.find_last_of("&");
+                int lat = static_cast<int>(100000*atof(request.substr(first_amp_pos+1, request.length()-last_amp_pos-1).c_str()));
+                int lon = static_cast<int>(100000*atof(request.substr(last_amp_pos+1).c_str()));
+                NodeCoords<NodeID> * data = new NodeCoords<NodeID>();
+                NodeID start = sEngine->findNearestNodeForLatLon(lat, lon, data);
+
+                rep.status = reply::ok;
+                rep.content.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+                rep.content.append("<kml xmlns=\"http://www.opengis.net/kml/2.2\">");
+                rep.content.append("<Placemark>");
+
+                std::stringstream out1;
+                out1 << setprecision(10);
+                out1 << "<name>Nearest Place in map to " << lat/100000. << "," << lon/10000. << ": node with id " << start << "</name>";
+                rep.content.append(out1.str());
+                rep.content.append("<Point>");
+
+                std::stringstream out2;
+                out2 << setprecision(10);
+                out2 << "<coordinates>" << data->lat / 100000. << "," << data->lon / 100000.  << "</coordinates>";
+                rep.content.append(out2.str());
+                rep.content.append("</Point>");
+                rep.content.append("</Placemark>");
+                rep.content.append("</kml>");
+
+                rep.headers.resize(3);
+                rep.headers[0].name = "Content-Length";
+                rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
+                rep.headers[1].name = "Content-Type";
+                rep.headers[1].value = "application/vnd.google-earth.kml+xml";
+                rep.headers[2].name = "Content-Disposition";
+                rep.headers[2].value = "attachment; filename=\"placemark.kml\"";
+                delete data;
+                return;
+            }
+            if(command == "route")
+            {
+                //http://localhost:5000/route&45.1427&12.14144&54.8733&8.59438
+                std::size_t second_amp_pos = request.find_first_of("&", first_amp_pos+1);
+                std::size_t third_amp_pos = request.find_first_of("&", second_amp_pos+1);
+                std::size_t fourth_amp_pos = request.find_last_of("&");
+
+                int lat1 = static_cast<int>(100000*atof(request.substr(first_amp_pos+1, request.length()-second_amp_pos-1).c_str()));
+                int lon1 = static_cast<int>(100000*atof(request.substr(second_amp_pos+1, request.length()-third_amp_pos-1).c_str()));
+                int lat2 = static_cast<int>(100000*atof(request.substr(third_amp_pos+1, request.length()-fourth_amp_pos-1).c_str()));
+                int lon2 = static_cast<int>(100000*atof(request.substr(fourth_amp_pos+1).c_str()));
+
+                NodeCoords<NodeID> * startData = new NodeCoords<NodeID>();
+                NodeCoords<NodeID> * targetData = new NodeCoords<NodeID>();
+                vector<NodeID> * path = new vector<NodeID>();
+                NodeID start = sEngine->findNearestNodeForLatLon(lat1, lon1, startData);
+                NodeID target = sEngine->findNearestNodeForLatLon(lat2, lon2, targetData);
+                unsigned int distance = sEngine->ComputeRoute(start, target, path);
+
+                rep.status = reply::ok;
+                rep.content.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+                rep.content.append("<kml xmlns=\"http://www.opengis.net/kml/2.2\">");
+                rep.content.append("<Document>");
+                rep.content.append("<Placemark>");
+                rep.content.append("<name>OSM Routing Engine (c) Dennis Luxen and others </name>");
+                std::stringstream out1;
+                out1 << std::setprecision(10);
+                out1 << "<description>Route from " << lat1/100000. << "," << lon1/100000. << " to " << lat2/100000. << "," << lon2/100000. << "</description>" << " ";
+                rep.content.append(out1.str());
+                rep.content.append("<LineString>");
+                rep.content.append("<extrude>1</extrude>");
+                rep.content.append("<tessellate>1</tessellate>");
+                rep.content.append("<altitudeMode>absolute</altitudeMode>");
+                rep.content.append("<coordinates>\n");
+                if(distance != std::numeric_limits<unsigned int>::max())
+                {   //A route has been found
+                    for(vector<NodeID>::iterator it = path->begin(); it != path->end(); it++)
+                    {
+                        NodeInfo info = sEngine-> getNodeInfo(*it);
+                        stringstream nodeout;
+                        nodeout << std::setprecision(10);
+                        nodeout << info.lon/100000. << "," << info.lat/100000. << " " << endl;
+                        rep.content.append(nodeout.str());
+                    }
+                }
+                rep.content.append("</coordinates>");
+                rep.content.append("</LineString>");
+                rep.content.append("</Placemark>");
+                rep.content.append("</Document>");
+                rep.content.append("</kml>");
+
+                rep.headers.resize(3);
+                rep.headers[0].name = "Content-Length";
+                rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
+                rep.headers[1].name = "Content-Type";
+                rep.headers[1].value = "application/vnd.google-earth.kml+xml";
+                rep.headers[2].name = "Content-Disposition";
+                rep.headers[2].value = "attachment; filename=\"route.kml\"";
+                return;
+            }
+            rep = reply::stock_reply(reply::not_found);
+            return;
+        } catch(std::exception& e)
+        {
+            //TODO: log exception somewhere
+            rep = reply::stock_reply(reply::internal_server_error);
+            return;
+        }
+    };
+
+private:
+    //SearchEngine object that is queried
+    SearchEngine<EdgeData> * sEngine;
+};
+
+} // namespace ROUTER
+
+#endif // HTTP_ROUTER_REQUEST_HANDLER_HPP

HttpServer/request_parser.h

@@ -0,0 +1,420 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+
+#ifndef HTTP_REQUEST_PARSER_HPP
+#define HTTP_REQUEST_PARSER_HPP
+
+#include <boost/logic/tribool.hpp>
+#include <boost/tuple/tuple.hpp>
+
+namespace http {
+
+struct request;
+
+/// Parser for incoming requests.
+class request_parser
+{
+public:
+  /// Construct ready to parse the request method.
+  request_parser();
+
+  /// Reset to initial parser state.
+  void reset();
+
+  /// Parse some data. The tribool return value is true when a complete request
+  /// has been parsed, false if the data is invalid, indeterminate when more
+  /// data is required. The InputIterator return value indicates how much of the
+  /// input has been consumed.
+  template <typename InputIterator>
+  boost::tuple<boost::tribool, InputIterator> parse(request& req,
+      InputIterator begin, InputIterator end)
+  {
+    while (begin != end)
+    {
+      boost::tribool result = consume(req, *begin++);
+      if (result || !result)
+        return boost::make_tuple(result, begin);
+    }
+    boost::tribool result = boost::indeterminate;
+    return boost::make_tuple(result, begin);
+  }
+
+private:
+  /// Handle the next character of input.
+  boost::tribool consume(request& req, char input);
+
+  /// Check if a byte is an HTTP character.
+  static bool is_char(int c);
+
+  /// Check if a byte is an HTTP control character.
+  static bool is_ctl(int c);
+
+  /// Check if a byte is defined as an HTTP tspecial character.
+  static bool is_tspecial(int c);
+
+  /// Check if a byte is a digit.
+  static bool is_digit(int c);
+
+  /// The current state of the parser.
+  enum state
+  {
+    method_start,
+    method,
+    uri_start,
+    uri,
+    http_version_h,
+    http_version_t_1,
+    http_version_t_2,
+    http_version_p,
+    http_version_slash,
+    http_version_major_start,
+    http_version_major,
+    http_version_minor_start,
+    http_version_minor,
+    expecting_newline_1,
+    header_line_start,
+    header_lws,
+    header_name,
+    space_before_header_value,
+    header_value,
+    expecting_newline_2,
+    expecting_newline_3
+  } state_;
+};
+
+
+} // namespace http
+
+#include "request.h"
+
+namespace http {
+
+request_parser::request_parser()
+  : state_(method_start)
+{
+}
+
+void request_parser::reset()
+{
+  state_ = method_start;
+}
+
+boost::tribool request_parser::consume(request& req, char input)
+{
+  switch (state_)
+  {
+  case method_start:
+    if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      state_ = method;
+      req.method.push_back(input);
+      return boost::indeterminate;
+    }
+  case method:
+    if (input == ' ')
+    {
+      state_ = uri;
+      return boost::indeterminate;
+    }
+    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.method.push_back(input);
+      return boost::indeterminate;
+    }
+  case uri_start:
+    if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      state_ = uri;
+      req.uri.push_back(input);
+      return boost::indeterminate;
+    }
+  case uri:
+    if (input == ' ')
+    {
+      state_ = http_version_h;
+      return boost::indeterminate;
+    }
+    else if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.uri.push_back(input);
+      return boost::indeterminate;
+    }
+  case http_version_h:
+    if (input == 'H')
+    {
+      state_ = http_version_t_1;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_t_1:
+    if (input == 'T')
+    {
+      state_ = http_version_t_2;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_t_2:
+    if (input == 'T')
+    {
+      state_ = http_version_p;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_p:
+    if (input == 'P')
+    {
+      state_ = http_version_slash;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_slash:
+    if (input == '/')
+    {
+      req.http_version_major = 0;
+      req.http_version_minor = 0;
+      state_ = http_version_major_start;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_major_start:
+    if (is_digit(input))
+    {
+      req.http_version_major = req.http_version_major * 10 + input - '0';
+      state_ = http_version_major;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_major:
+    if (input == '.')
+    {
+      state_ = http_version_minor_start;
+      return boost::indeterminate;
+    }
+    else if (is_digit(input))
+    {
+      req.http_version_major = req.http_version_major * 10 + input - '0';
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_minor_start:
+    if (is_digit(input))
+    {
+      req.http_version_minor = req.http_version_minor * 10 + input - '0';
+      state_ = http_version_minor;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_minor:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_1;
+      return boost::indeterminate;
+    }
+    else if (is_digit(input))
+    {
+      req.http_version_minor = req.http_version_minor * 10 + input - '0';
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case expecting_newline_1:
+    if (input == '\n')
+    {
+      state_ = header_line_start;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case header_line_start:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_3;
+      return boost::indeterminate;
+    }
+    else if (!req.headers.empty() && (input == ' ' || input == '\t'))
+    {
+      state_ = header_lws;
+      return boost::indeterminate;
+    }
+    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.headers.push_back(header());
+      req.headers.back().name.push_back(input);
+      state_ = header_name;
+      return boost::indeterminate;
+    }
+  case header_lws:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_2;
+      return boost::indeterminate;
+    }
+    else if (input == ' ' || input == '\t')
+    {
+      return boost::indeterminate;
+    }
+    else if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      state_ = header_value;
+      req.headers.back().value.push_back(input);
+      return boost::indeterminate;
+    }
+  case header_name:
+    if (input == ':')
+    {
+      state_ = space_before_header_value;
+      return boost::indeterminate;
+    }
+    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.headers.back().name.push_back(input);
+      return boost::indeterminate;
+    }
+  case space_before_header_value:
+    if (input == ' ')
+    {
+      state_ = header_value;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case header_value:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_2;
+      return boost::indeterminate;
+    }
+    else if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.headers.back().value.push_back(input);
+      return boost::indeterminate;
+    }
+  case expecting_newline_2:
+    if (input == '\n')
+    {
+      state_ = header_line_start;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case expecting_newline_3:
+    return (input == '\n');
+  default:
+    return false;
+  }
+}
+
+bool request_parser::is_char(int c)
+{
+  return c >= 0 && c <= 127;
+}
+
+bool request_parser::is_ctl(int c)
+{
+  return (c >= 0 && c <= 31) || (c == 127);
+}
+
+bool request_parser::is_tspecial(int c)
+{
+  switch (c)
+  {
+  case '(': case ')': case '<': case '>': case '@':
+  case ',': case ';': case ':': case '\\': case '"':
+  case '/': case '[': case ']': case '?': case '=':
+  case '{': case '}': case ' ': case '\t':
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool request_parser::is_digit(int c)
+{
+  return c >= '0' && c <= '9';
+}
+
+} // namespace http
+
+#endif // HTTP_SERVER3_REQUEST_PARSER_HPP

HttpServer/server.h

@@ -0,0 +1,124 @@
+/*
+    open source routing machine
+    Copyright (C) Dennis Luxen, 2010
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU AFFERO General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+or see http://www.gnu.org/licenses/agpl.txt.
+*/
+
+#ifndef HTTP_ROUTER_SERVER_HPP
+#define HTTP_ROUTER_SERVER_HPP
+
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <climits>
+#include <string>
+#include <vector>
+
+#include "../typedefs.h"
+
+#include "connection.h"
+#include "request_handler.h"
+
+namespace http {
+
+/// The top-level class of the HTTP server.
+class server: private boost::noncopyable
+{
+public:
+    /// Construct the server to listen on the specified TCP address and port, and
+    /// serve up files from the given directory.
+    explicit server(const std::string& address, const std::string& port, std::size_t thread_pool_size, SearchEngine<EdgeData, NodeInformationHelpDesk> * s)
+    : thread_pool_size_(thread_pool_size),
+      acceptor_(io_service_),
+      new_connection_(new connection(io_service_, request_handler_)),
+      request_handler_(s),
+      sEngine(s)
+    {
+        // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
+        boost::asio::ip::tcp::resolver resolver(io_service_);
+        boost::asio::ip::tcp::resolver::query query(address, port);
+        boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
+
+        acceptor_.open(endpoint.protocol());
+        acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+        acceptor_.bind(endpoint);
+        acceptor_.listen();
+        acceptor_.async_accept(new_connection_->socket(), boost::bind(&server::handle_accept, this, boost::asio::placeholders::error));
+    }
+
+    /// Run the server's io_service loop.
+    void run()
+    {
+        // Create a pool of threads to run all of the io_services.
+        std::vector<boost::shared_ptr<boost::thread> > threads;
+        for (std::size_t i = 0; i < thread_pool_size_; ++i)
+        {
+            boost::shared_ptr<boost::thread> thread(new boost::thread(
+                    boost::bind(&boost::asio::io_service::run, &io_service_)));
+            threads.push_back(thread);
+        }
+
+        // Wait for all threads in the pool to exit.
+        for (std::size_t i = 0; i < threads.size(); ++i)
+            threads[i]->join();
+    }
+
+    /// Stop the server.
+    void stop()
+    {
+        io_service_.stop();
+    }
+
+private:
+    /// Handle completion of an asynchronous accept operation.
+    void handle_accept(const boost::system::error_code& e)
+    {
+        if (!e)
+        {
+            new_connection_->start();
+            new_connection_.reset(new connection(io_service_, request_handler_));
+            acceptor_.async_accept(new_connection_->socket(),
+                    boost::bind(&server::handle_accept, this,
+                            boost::asio::placeholders::error));
+        }
+    }
+
+    /// The number of threads that will call io_service::run().
+    std::size_t thread_pool_size_;
+
+    /// The io_service used to perform asynchronous operations.
+    boost::asio::io_service io_service_;
+
+    /// Acceptor used to listen for incoming connections.
+    boost::asio::ip::tcp::acceptor acceptor_;
+
+    /// The next connection to be accepted.
+    connection_ptr new_connection_;
+
+    /// The handler for all incoming requests.
+    request_handler request_handler_;
+
+    /// The object to query the Routing Engine
+    SearchEngine<EdgeData> * sEngine;
+
+};
+
+}   // namespace http
+
+#endif // HTTP_ROUTER_SERVER_HPP