Use Boost.Beast to parse HTTP request

fuzz/CMakeLists.txt

@@ -38,8 +38,7 @@ if (ENABLE_FUZZING)
 	  "table_parameters"
 	  "tile_parameters"
 	  "trip_parameters"
-	  "url_parser"
-	  "request_parser")
+	  "url_parser")
 
   foreach (target ${ServerTargets})
 	  add_fuzz_target(${target})

include/server/connection.hpp

@@ -4,14 +4,15 @@
 #include "server/http/compression_type.hpp"
 #include "server/http/reply.hpp"
 #include "server/http/request.hpp"
-#include "server/request_parser.hpp"
-
 #include <boost/array.hpp>
 #include <boost/asio.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
 #include <boost/config.hpp>
 #include <boost/version.hpp>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 // workaround for incomplete std::shared_ptr compatibility in old boost versions
@@ -47,6 +48,7 @@ class Connection : public std::enable_shared_from_this<Connection>
     void start();
 
   private:
+    using RequestParser = boost::beast::http::request_parser<boost::beast::http::string_body>;
     void handle_read(const boost::system::error_code &e, std::size_t bytes_transferred);
 
     /// Handle completion of a write operation.
@@ -60,11 +62,13 @@ class Connection : public std::enable_shared_from_this<Connection>
     std::vector<char> compress_buffers(const std::vector<char> &uncompressed_data,
                                        const http::compression_type compression_type);
 
+    void fill_request(const RequestParser::value_type &httpMessage, http::request &request);
+
     boost::asio::strand<boost::asio::io_context::executor_type> strand;
     boost::asio::ip::tcp::socket TCP_socket;
     boost::asio::deadline_timer timer;
     RequestHandler &request_handler;
-    RequestParser request_parser;
+    std::optional<RequestParser> http_request_parser;
     boost::array<char, 8192> incoming_data_buffer;
     http::request current_request;
     http::reply current_reply;

src/server/connection.cpp

@@ -1,12 +1,10 @@
 #include "server/connection.hpp"
 #include "server/request_handler.hpp"
-#include "server/request_parser.hpp"
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/bind.hpp>
 #include <boost/iostreams/filter/gzip.hpp>
 #include <boost/iostreams/filtering_stream.hpp>
-
 #include <vector>
 
 namespace osrm
@@ -16,12 +14,32 @@ namespace server
 
 Connection::Connection(boost::asio::io_context &io_context, RequestHandler &handler)
     : strand(boost::asio::make_strand(io_context)), TCP_socket(strand), timer(strand),
-      request_handler(handler)
+      request_handler(handler), http_request_parser(std::make_optional<RequestParser>())
 {
 }
 
 boost::asio::ip::tcp::socket &Connection::socket() { return TCP_socket; }
 
+namespace
+{
+
+http::compression_type select_compression(const boost::beast::http::fields &fields)
+{
+    const auto header_value = fields[boost::beast::http::field::accept_encoding];
+    /* giving gzip precedence over deflate */
+    if (boost::icontains(header_value, "deflate"))
+    {
+        return http::deflate_rfc1951;
+    }
+    if (boost::icontains(header_value, "gzip"))
+    {
+        return http::gzip_rfc1952;
+    }
+    return http::no_compression;
+}
+
+} // namespace
+
 /// Start the first asynchronous operation for the connection.
 void Connection::start()
 {
@@ -60,20 +78,45 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
         timer.expires_from_now(boost::posix_time::seconds(0));
     }
 
+    boost::beast::error_code ec;
+    http_request_parser->put(boost::asio::buffer(incoming_data_buffer, bytes_transferred), ec);
     // no error detected, let's parse the request
     http::compression_type compression_type(http::no_compression);
-    RequestParser::RequestStatus result;
-    std::tie(result, compression_type) =
-        request_parser.parse(current_request,
-                             incoming_data_buffer.data(),
-                             incoming_data_buffer.data() + bytes_transferred);
-
-    // the request has been parsed
-    if (result == RequestParser::RequestStatus::valid)
+
+    if (ec)
+    {
+        if (ec == boost::beast::http::error::need_more)
+        {
+            // we don't have a result yet, so continue reading
+            TCP_socket.async_read_some(boost::asio::buffer(incoming_data_buffer),
+                                       boost::bind(&Connection::handle_read,
+                                                   this->shared_from_this(),
+                                                   boost::asio::placeholders::error,
+                                                   boost::asio::placeholders::bytes_transferred));
+        }
+        else
+        {
+            // request is not parseable
+            current_reply = http::reply::stock_reply(http::reply::bad_request);
+
+            boost::asio::async_write(TCP_socket,
+                                     current_reply.to_buffers(),
+                                     boost::bind(&Connection::handle_write,
+                                                 this->shared_from_this(),
+                                                 boost::asio::placeholders::error));
+        }
+    }
+    else
     {
+        // the request has been parsed
+        const auto &message = http_request_parser->get();
+        compression_type = select_compression(message);
+
+        fill_request(message, current_request);
 
         boost::system::error_code ec;
         current_request.endpoint = TCP_socket.remote_endpoint(ec).address();
+
         if (ec)
         {
             util::Log(logDEBUG) << "Socket remote endpoint error: " << ec.message();
@@ -127,25 +170,6 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
                                              this->shared_from_this(),
                                              boost::asio::placeholders::error));
     }
-    else if (result == RequestParser::RequestStatus::invalid)
-    { // request is not parseable
-        current_reply = http::reply::stock_reply(http::reply::bad_request);
-
-        boost::asio::async_write(TCP_socket,
-                                 current_reply.to_buffers(),
-                                 boost::bind(&Connection::handle_write,
-                                             this->shared_from_this(),
-                                             boost::asio::placeholders::error));
-    }
-    else
-    {
-        // we don't have a result yet, so continue reading
-        TCP_socket.async_read_some(boost::asio::buffer(incoming_data_buffer),
-                                   boost::bind(&Connection::handle_read,
-                                               this->shared_from_this(),
-                                               boost::asio::placeholders::error,
-                                               boost::asio::placeholders::bytes_transferred));
-    }
 }
 
 /// Handle completion of a write operation.
@@ -158,7 +182,7 @@ void Connection::handle_write(const boost::system::error_code &error)
             --processed_requests;
             current_request = http::request();
             current_reply = http::reply();
-            request_parser = RequestParser();
+            http_request_parser.emplace();
             incoming_data_buffer = boost::array<char, 8192>();
             output_buffer.clear();
             this->start();
@@ -220,5 +244,15 @@ std::vector<char> Connection::compress_buffers(const std::vector<char> &uncompre
 
     return compressed_data;
 }
+
+void Connection::fill_request(const RequestParser::value_type &http_message,
+                              http::request &current_request)
+{
+    current_request.uri = http_message.target().to_string();
+    current_request.agent = http_message[boost::beast::http::field::user_agent].to_string();
+    current_request.referrer = http_message[boost::beast::http::field::referer].to_string();
+    current_request.connection = http_message[boost::beast::http::field::connection].to_string();
+}
+
 } // namespace server
 } // namespace osrm