Initial commit

src/Listener.cpp

@@ -0,0 +1,72 @@
+#include "Listener.h"
+
+namespace uad
+{
+Listener::Listener(boost::asio::io_context& ioc,
+                        boost::asio::ip::tcp::endpoint endpoint,
+                        const std::shared_ptr<const std::string>& doc_root)
+  : ioc_(ioc), acceptor_(net::make_strand(ioc)), doc_root_(doc_root)
+{
+  beast::error_code ec;
+
+  acceptor_.open(endpoint.protocol(), ec);
+  if (ec)
+  {
+    uad::Fail(ec, "open");
+    return;
+  }
+
+  acceptor_.set_option(net::socket_base::reuse_address(true), ec);
+  if (ec)
+  {
+    uad::Fail(ec, "set_option");
+    return;
+  }
+
+  acceptor_.bind(endpoint, ec);
+  if (ec)
+  {
+    uad::Fail(ec, "bind");
+    return;
+  }
+
+  acceptor_.listen(
+    net::socket_base::max_listen_connections, ec);
+  if (ec)
+  {
+    uad::Fail(ec, "listen");
+    return;
+  }
+}
+
+void Listener::Run()
+{
+  DoAccept();
+}
+
+void Listener::DoAccept()
+{
+  acceptor_.async_accept(
+    net::make_strand(ioc_),
+    beast::bind_front_handler(
+      &Listener::OnAccept,
+      shared_from_this()));
+}
+
+void Listener::OnAccept(beast::error_code ec, tcp::socket socket)
+{
+  if (ec)
+  {
+    uad::Fail(ec, "accept");
+    return;
+  }
+  else
+  {
+    std::make_shared<uad::Session>(
+      std::move(socket),
+      doc_root_)->Run();
+  }
+
+  DoAccept();
+}
+}

src/Listener.h

@@ -0,0 +1,45 @@
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/config.hpp>
+#include <algorithm>
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "helpers.h"
+#include "Session.h"
+
+namespace uad
+{
+namespace beast = boost::beast;
+namespace http = beast::http;
+namespace net = boost::asio;
+using tcp = boost::asio::ip::tcp;
+
+class Listener : public std::enable_shared_from_this<Listener>
+{
+  net::io_context& ioc_;
+  tcp::acceptor acceptor_;
+  std::shared_ptr<std::string const> doc_root_;
+
+ public:
+  Listener(
+    net::io_context& ioc,
+    tcp::endpoint endpoint,
+    std::shared_ptr<std::string const> const& doc_root);
+
+  void Run();
+
+ private:
+  void DoAccept();
+
+  void OnAccept(beast::error_code ec, tcp::socket socket);
+};
+}

src/RequestHandlers/BasicRequestHandler.cpp

@@ -0,0 +1,114 @@
+#include "BasicRequestHandler.h"
+
+#include <iostream>
+#include <string_view>
+
+#include "../content_type.h"
+
+using namespace std;
+using namespace string_view_literals;
+
+namespace uad
+{
+namespace beast = boost::beast;
+namespace http = beast::http;
+namespace net = boost::asio;
+
+http::message_generator HandleRequest(
+  beast::string_view doc_root,
+  http::request<http::string_body>&& req)
+{
+  auto const bad_request =
+    [&req](beast::string_view why)
+    {
+      http::response<http::string_body> res {http::status::bad_request, req.version()};
+      res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
+      res.set(http::field::content_type, "text/html");
+      res.keep_alive(req.keep_alive());
+      res.body() = std::string(why);
+      res.prepare_payload();
+      return res;
+    };
+
+  auto const not_found =
+    [&req](beast::string_view target)
+    {
+      http::response<http::string_body> res {http::status::not_found, req.version()};
+      res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
+      res.set(http::field::content_type, "text/html");
+      res.keep_alive(req.keep_alive());
+      res.body() = "The resource '" + std::string(target) + "' was not found.";
+      res.prepare_payload();
+      return res;
+    };
+
+  auto const server_error =
+    [&req](beast::string_view what)
+    {
+      http::response<http::string_body> res {http::status::internal_server_error, req.version()};
+      res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
+      res.set(http::field::content_type, "text/html");
+      res.keep_alive(req.keep_alive());
+      res.body() = "An error occurred: '" + std::string(what) + "'";
+      res.prepare_payload();
+      return res;
+    };
+
+  if (req.target() == "/HelloWorld"sv)
+  {
+    http::response<http::string_body> res {};
+    res.body() = "{ \"Hello\": \"World\" }"sv;
+    res.content_length(res.body().size());
+    res.set(http::field::content_type, content_type::k_JSON);
+    res.prepare_payload();
+    res.keep_alive(req.keep_alive());
+
+    return res;
+  }
+
+  if (req.method() != http::verb::get &&
+    req.method() != http::verb::head)
+    return bad_request("Unknown HTTP-method");
+
+  if (req.target().empty() ||
+    req.target()[0] != '/' ||
+    req.target().find("..") != beast::string_view::npos)
+    return bad_request("Illegal request-target");
+
+  std::string path = PathCat(doc_root, req.target());
+  if (req.target().back() == '/')
+    path.append("index.html");
+
+  beast::error_code ec;
+  http::file_body::value_type body;
+  body.open(path.c_str(), beast::file_mode::scan, ec);
+
+  if (ec == beast::errc::no_such_file_or_directory)
+    return not_found(req.target());
+
+  if (ec)
+    return server_error(ec.message());
+
+  auto const size = body.size();
+
+  if (req.method() == http::verb::head)
+  {
+    http::response<http::empty_body> res {http::status::ok, req.version()};
+    res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
+    res.set(http::field::content_type, MimeType(path));
+    res.content_length(size);
+    res.keep_alive(req.keep_alive());
+    return res;
+  }
+
+  http::response<http::file_body> res {
+    std::piecewise_construct,
+    std::make_tuple(std::move(body)),
+    std::make_tuple(http::status::ok, req.version())};
+  res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
+  res.set(http::field::content_type, MimeType(path));
+  res.content_length(size);
+  res.keep_alive(req.keep_alive());
+  return res;
+}
+}

src/RequestHandlers/BasicRequestHandler.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/config.hpp>
+#include <algorithm>
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+#include <type_traits>
+
+#include "./../helpers.h"
+
+namespace uad
+{
+namespace beast = boost::beast;
+namespace http = beast::http;
+namespace net = boost::asio;
+
+http::message_generator HandleRequest(
+  beast::string_view doc_root,
+  http::request<http::string_body>&& req);
+}

src/Session.cpp

@@ -0,0 +1,81 @@
+#include "RequestHandlers/BasicRequestHandler.h"
+#include "Session.h"
+
+namespace uad
+{
+Session::Session(
+  tcp::socket&& socket,
+  std::shared_ptr<std::string const> const& doc_root)
+  : stream_(std::move(socket)), doc_root_(doc_root) {}
+
+void Session::Run()
+{
+  net::dispatch(stream_.get_executor(),
+                beast::bind_front_handler(
+                  &Session::DoRead,
+                  shared_from_this()));
+}
+
+void Session::DoRead()
+{
+  req_ = {};
+
+  stream_.expires_after(std::chrono::seconds(30));
+
+  http::async_read(stream_, buffer_, req_,
+                   beast::bind_front_handler(
+                     &Session::OnRead,
+                     shared_from_this()));
+}
+
+void Session::OnRead(
+  beast::error_code ec,
+  std::size_t bytes_transferred)
+{
+  boost::ignore_unused(bytes_transferred);
+
+  if (ec == http::error::end_of_stream)
+    return DoClose();
+
+  if (ec)
+    return Fail(ec, "read");
+
+  SendResponse(
+    HandleRequest(*doc_root_, std::move(req_)));
+}
+
+void Session::SendResponse(http::message_generator&& msg)
+{
+  bool keep_alive = msg.keep_alive();
+
+  beast::async_write(
+    stream_,
+    std::move(msg),
+    beast::bind_front_handler(
+      &Session::OnWrite, shared_from_this(), keep_alive));
+}
+
+void Session::OnWrite(
+  bool keep_alive,
+  beast::error_code ec,
+  std::size_t bytes_transferred)
+{
+  boost::ignore_unused(bytes_transferred);
+
+  if (ec)
+    return uad::Fail(ec, "write");
+
+  if (!keep_alive)
+  {
+    return DoClose();
+  }
+
+  DoRead();
+}
+
+void Session::DoClose()
+{
+  beast::error_code ec;
+  stream_.socket().shutdown(tcp::socket::shutdown_send, ec);
+}
+}

src/Session.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/strand.hpp>
+#include <memory>
+#include <string>
+
+#include "helpers.h"
+
+namespace uad
+{
+namespace beast = boost::beast;
+namespace http = beast::http;
+using tcp = boost::asio::ip::tcp;
+namespace net = boost::asio;
+
+class Session : public std::enable_shared_from_this<Session>
+{
+  beast::tcp_stream stream_;
+  beast::flat_buffer buffer_;
+  std::shared_ptr<std::string const> doc_root_;
+  http::request<http::string_body> req_;
+
+ public:
+  Session(
+    tcp::socket&& socket,
+    std::shared_ptr<std::string const> const& doc_root);
+
+  void Run();
+
+  void DoRead();
+
+  void OnRead(
+    beast::error_code ec,
+    std::size_t bytes_transferred);
+
+  void SendResponse(http::message_generator&& msg);
+
+  void OnWrite(
+    bool keep_alive,
+    beast::error_code ec,
+    std::size_t bytes_transferred);
+
+  void DoClose();
+};
+}

src/content_type.h

@@ -0,0 +1,27 @@
+#include <string_view>
+
+namespace uad
+{
+using namespace std::string_view_literals;
+
+struct content_type
+{
+  content_type() = delete;
+  constexpr inline static std::string_view k_TextHtml = "text/html"sv;
+  constexpr inline static std::string_view k_TextCsv = "text/csv"sv;
+  constexpr inline static std::string_view k_TextPlain = "text/plain"sv;
+  constexpr inline static std::string_view k_JSON = "application/json"sv;
+  constexpr inline static std::string_view k_Audio = "audio/mpeg"sv;
+  constexpr inline static std::string_view k_AudioExample = "audio/example"sv;
+  constexpr inline static std::string_view k_FontWoff = "font/woff"sv;
+  constexpr inline static std::string_view k_FontTtf = "font/ttf"sv;
+  constexpr inline static std::string_view k_FontOtf = "font/otf"sv;
+  constexpr inline static std::string_view k_ImagePng = "image/png"sv;
+  constexpr inline static std::string_view k_ImageJpeg = "image/jpeg"sv;
+  constexpr inline static std::string_view k_ImageGif = "image/gif"sv;
+  constexpr inline static std::string_view k_Model = "model/vrml"sv;
+  constexpr inline static std::string_view k_VideoMp4 = "video/mp4"sv;
+  constexpr inline static std::string_view k_VideoWebm = "video/webm"sv;
+  constexpr inline static std::string_view k_Binary = "application/octet-stream"sv;
+};
+}

src/helper.cpp

@@ -0,0 +1,67 @@
+#include "helpers.h"
+
+namespace uad
+{
+beast::string_view MimeType(beast::string_view path)
+{
+  using beast::iequals;
+  auto const ext = [&path]
+  {
+    auto const pos = path.rfind(".");
+    if (pos == beast::string_view::npos)
+      return beast::string_view {};
+    return path.substr(pos);
+  }();
+  if (iequals(ext, ".htm")) return "text/html";
+  if (iequals(ext, ".html")) return "text/html";
+  if (iequals(ext, ".php")) return "text/html";
+  if (iequals(ext, ".css")) return "text/css";
+  if (iequals(ext, ".txt")) return "text/plain";
+  if (iequals(ext, ".js")) return "application/javascript";
+  if (iequals(ext, ".json")) return "application/json";
+  if (iequals(ext, ".xml")) return "application/xml";
+  if (iequals(ext, ".swf")) return "application/x-shockwave-flash";
+  if (iequals(ext, ".flv")) return "video/x-flv";
+  if (iequals(ext, ".png")) return "image/png";
+  if (iequals(ext, ".jpe")) return "image/jpeg";
+  if (iequals(ext, ".jpeg")) return "image/jpeg";
+  if (iequals(ext, ".jpg")) return "image/jpeg";
+  if (iequals(ext, ".gif")) return "image/gif";
+  if (iequals(ext, ".bmp")) return "image/bmp";
+  if (iequals(ext, ".ico")) return "image/vnd.microsoft.icon";
+  if (iequals(ext, ".tiff")) return "image/tiff";
+  if (iequals(ext, ".tif")) return "image/tiff";
+  if (iequals(ext, ".svg")) return "image/svg+xml";
+  if (iequals(ext, ".svgz")) return "image/svg+xml";
+  return "application/text";
+}
+
+std::string PathCat(
+  beast::string_view base,
+  beast::string_view path)
+{
+  if (base.empty())
+    return std::string(path);
+  std::string result(base);
+#ifdef BOOST_MSVC
+  char constexpr path_separator = '\\';
+  if (result.back() == path_separator)
+    result.resize(result.size() - 1);
+  result.append(path.data(), path.size());
+  for (auto& c: result)
+    if (c == '/')
+      c = path_separator;
+#else
+  char constexpr path_separator = '/';
+    if(result.back() == path_separator)
+      result.resize(result.size() - 1);
+    result.append(path.data(), path.size());
+#endif
+  return result;
+}
+
+void Fail(beast::error_code ec, char const* what)
+{
+  std::cerr << what << ": " << ec.message() << "\n";
+}
+}

src/helpers.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/config.hpp>
+#include <algorithm>
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace uad
+{
+namespace beast = boost::beast;
+namespace http = beast::http;
+namespace net = boost::asio;
+
+beast::string_view MimeType(beast::string_view path);
+
+std::string PathCat(beast::string_view base, beast::string_view path);
+
+void Fail(beast::error_code ec, char const* what);
+}

src/main.cpp

@@ -0,0 +1,55 @@
+#include "sdk.h"
+
+#include <boost/beast/core.hpp>
+#include <boost/asio/strand.hpp>
+#include <algorithm>
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "RequestHandlers/BasicRequestHandler.h"
+#include "Listener.h"
+
+namespace beast = boost::beast;
+namespace http = beast::http;
+namespace net = boost::asio;
+using tcp = boost::asio::ip::tcp;
+using namespace uad;
+
+int main(int argc, char* argv[])
+{
+  if (argc != 5)
+  {
+    std::cerr <<
+              "Usage: http-server-async <address> <port> <doc_root> <threads>\n" <<
+              "Example:\n" <<
+              "    http-server-async 0.0.0.0 8080 . 1\n";
+    return EXIT_FAILURE;
+  }
+  auto const address = net::ip::make_address(argv[1]);
+  auto const port = static_cast<unsigned short>(std::atoi(argv[2]));
+  auto const doc_root = std::make_shared<std::string>(argv[3]);
+  auto const threads = std::max<int>(1, std::atoi(argv[4]));
+
+  net::io_context ioc {threads};
+
+  std::make_shared<Listener>(
+    ioc,
+    tcp::endpoint {address, port},
+    doc_root)->Run();
+
+  std::vector<std::thread> v;
+  v.reserve(threads - 1);
+  for (auto i = threads - 1; i > 0; --i)
+    v.emplace_back(
+      [&ioc]
+      {
+        ioc.run();
+      });
+  ioc.run();
+
+  return EXIT_SUCCESS;
+}

src/sdk.h

@@ -0,0 +1,4 @@
+#pragma once
+#ifdef WIN32
+#include <sdkddkver.h>
+#endif