websocket.cc

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#include "websocket.hh"
#include "platform.hh"
#include "strings.hh"
#include "formatter.hh"
#include "path.hh"
#include "blob.hh"
#include "utils.hh"
#include "regex.hh"
#include "randomhash.hh"
#include "internal.hh"
#include "main.hh"
#include <regex>
#include <fstream>
#include <map>
#include <vector>
 
// POSIX Network Headers
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>
 
#include <websocketpp/config/core.hpp>
#include <websocketpp/server.hpp>
 
#define IODEBUG(...)    while (0) { printerr (__VA_ARGS__); break; }
 
namespace Ase {
 
struct WebSocketServerImpl;
using WebSocketServerImplP = std::shared_ptr<WebSocketServerImpl>;
 
// Use core config with sync concurrency so send() is thread-safe
struct CustomServerConfig : public websocketpp::config::core {
  static const size_t connection_read_buffer_size = 16384;
};
 
using WppServer = websocketpp::server<CustomServerConfig>;
using WppConnectionP = WppServer::connection_ptr;
using WppConnection = WppConnectionP::element_type;
using WppHdl = websocketpp::connection_hdl;
 
static inline bool
operator!= (const WppHdl &a, const WppHdl &b)
{
  return a.owner_before (b) || b.owner_before (a);
}
static inline bool operator== (const WppHdl &a, const WppHdl &b) { return !(a != b); }
 
// State for main_loop integration
struct ClientState {
  int fd;
  WppConnectionP con;
  std::string out_buffer;
  std::string local_ip;
  int local_port = 0;
  std::string remote_ip;
  int remote_port = 0;
  Ase::LoopID source_id = Ase::LoopID::INVALID;
};
 
// == WebSocketServerImpl ==
struct WebSocketServerImpl : public WebSocketServer {
  using ConVec = std::vector<WebSocketConnectionP>;
  using RegexVector = std::vector<std::regex>;
  WppServer      wppserver_;
  String         server_url_, dir_, token_, see_other_;
  std::vector<std::pair<String,String>> aliases_;
  ConVec         opencons_;
  RegexVector    ignores_;
  MakeConnection make_con_;
  int            logflags_ = 0;
  int            listen_port_ = 0;
  std::map<int, ClientState> clients_;
  int                        listen_fd_ = -1;
  Ase::LoopID                listen_source_id_ = Ase::LoopID::INVALID;
 
  void update_client_sources();
  bool io_handler (PollFD &pfd);
 
  void   setup        ();
  WebSocketConnectionP make_connection (WppHdl hdl);
  WebSocketConnection* force_con (WppHdl);
  friend class WebSocketServer;
public:
  int            listen_port () const override   { return listen_port_; }
  String         url      () const override      { return server_url_; }
  WppConnectionP wppconp  (WppHdl hdl)
  {
    websocketpp::lib::error_code ec;
    return wppserver_.get_con_from_hdl (hdl, ec); // nullptr if (ec)
  }
  void
  http_dir (const String &path) override
  {
    assert_return (listen_fd_ < 0);
    dir_ = Path::normalize (path);
    aliases_.clear();
    ignores_.clear();
 
    // compile .aseignore
    String cxxline;
    std::ifstream aseignore;
    aseignore.open (Path::join (dir_, ".aseignore"));
    while (!aseignore.fail() && std::getline (aseignore, cxxline))
      if (!cxxline.empty())
        ignores_.push_back (std::regex (cxxline));
  }
  void
  http_alias (const String &webdir, const String &path) override
  {
    assert_return (!dir_.empty());
    String aliaspath = Path::normalize (Path::abspath (path, dir_));
    aliases_.push_back (std::make_pair (webdir, aliaspath));
    // sort by URL length, longest URLs come first
    std::stable_sort (aliases_.begin(), aliases_.end(), [] (const auto &a, const auto &b) {
      return a.first.size() > b.first.size();
    });
  }
  String
  map_url (const String &urlpath) override
  {
    if (dir_.empty())
      return "";
 
    // decode URL, also uncovers '.' and '/'
    String absurl = string_url_decode (urlpath);
 
    // normalize '.' and '..' dirs
    absurl = Path::simplify_abspath (absurl);
 
    // ignore urls
    for (const auto &ignorepat : ignores_)
      if (std::regex_search (absurl, ignorepat))
        return "";
 
    // map URL to sorted aliases, prefers longest match
    for (const auto &pair : aliases_)
      if (absurl == pair.first)
        return pair.second;
      else if (absurl.size() > pair.first.size() &&
               absurl[pair.first.size()] == '/' &&
               strncmp (absurl.c_str(), pair.first.c_str(), pair.first.size()) == 0)
        return Path::join (pair.second, absurl.c_str() + pair.first.size());
 
    // fallback to root
    return Path::join (dir_, absurl);
  }
  void
  listen (const SocketInfo &sinfo, const UnlistenCB &ulcb) override
  {
    assert_return (listen_fd_ < 0);
    listen_fd_ = sinfo.fd;
    listen_port_ = sinfo.port;
    if (::listen (listen_fd_, 128) < 0)
      fatal_error ("failed to listen on %s:%d, fd=%d: %s", sinfo.host, sinfo.port, listen_fd_, strerror (errno));
    fcntl (listen_fd_, F_SETFL, O_NONBLOCK);
    String fullurl = string_format ("http://%s:%d/", sinfo.host.empty() ? "127.0.0.1" : sinfo.host, listen_port_);
    server_url_ = fullurl;
    setup();
    // Register listen fd with main_loop
    listen_source_id_ = main_loop->exec_io_handler ([this] (PollFD &pfd) {
      // Handle new connections
      if (pfd.revents & PollFD::IN) {
        sockaddr_in client_addr;
        socklen_t client_len = sizeof (client_addr);
        int client_fd = accept (listen_fd_, (sockaddr*) &client_addr, &client_len);
        if (client_fd >= 0) {
          fcntl (client_fd, F_SETFL, O_NONBLOCK);
          sockaddr_in local_addr;
          socklen_t local_len = sizeof (local_addr);
          getsockname (client_fd, (sockaddr*) &local_addr, &local_len);
          WppConnectionP con = wppserver_.get_connection();
          ClientState cs;
          cs.fd = client_fd;
          cs.con = con;
          char ip_str[INET_ADDRSTRLEN];
          inet_ntop (AF_INET, &(local_addr.sin_addr), ip_str, INET_ADDRSTRLEN);
          cs.local_ip = ip_str;
          cs.local_port = ntohs (local_addr.sin_port);
          inet_ntop (AF_INET, &(client_addr.sin_addr), ip_str, INET_ADDRSTRLEN);
          cs.remote_ip = ip_str;
          cs.remote_port = ntohs (client_addr.sin_port);
          // Wire up the iostream transport's write handler
          con->set_write_handler ([this, client_fd] (WppHdl hdl, char const *data, size_t len)
          {
            auto it = clients_.find (client_fd);
            if (it != clients_.end()) {
              it->second.out_buffer.append (data, len);
              main_loop->wakeup();
            }
            IODEBUG ("%s:%u:%s: fd=%d write_handler: len=%d\n", __FILE__, __LINE__, __func__, it != clients_.end() ? it->first : -1, len);
            return websocketpp::lib::error_code();
          });
          clients_[client_fd] = cs;
          IODEBUG ("%s:%u:%s: accept(%d)\n", __FILE__, __LINE__, __func__, client_fd);
          con->start();
          // Update client sources to include the new connection
          update_client_sources();
        }
      }
      return true; // keep handler active
    }, listen_fd_, "r", LoopPriority::NORMAL);
  }
  void
  see_other (const String &uri) override
  {
    // TODO: not thread-safe
    see_other_ = uri;
  }
  void
  shutdown () override
  {
    // Cancel loop sources
    reset();
    main_loop->cancel (&listen_source_id_);
    ::close (listen_fd_);
    listen_fd_ = -1;
  }
  void ws_opened (WebSocketConnectionP);
  void ws_closed (WebSocketConnectionP);
  void reset         () override;
  WebSocketServerImpl (const MakeConnection &make_con, int logflags, const std::string &token) :
    token_ (token), make_con_ (make_con), logflags_ (logflags)
  {}
};
 
void
WebSocketServerImpl::setup ()
{
  wppserver_.set_user_agent (user_agent());
  wppserver_.set_validate_handler ([this] (WppHdl hdl)
  {
    WebSocketConnectionP conp = make_connection (hdl);
    WppConnectionP cp = this->wppconp (hdl);
    return_unless (conp && cp, false);
    const bool is_authenticated = conp->authenticated (token_);
    if (is_authenticated) {
      const int index = conp->validate();
      if (index >= 0) {
        const std::vector<std::string> &subprotocols = cp->get_requested_subprotocols();
        if (size_t (index) < subprotocols.size())
          {
            cp->select_subprotocol (subprotocols[index]);
            return true;
          }
        else if (subprotocols.size() == 0 && index == 0)
          return true;
      }
    }
    cp->set_status (websocketpp::http::status_code::forbidden);
    conp->log_status (cp->get_response_code());
    return false;
  });
  wppserver_.set_http_handler ([this] (WppHdl hdl)
  {
    WebSocketConnectionP conp = make_connection (hdl);
    if (conp)
      conp->http_request();
  });
  wppserver_.clear_access_channels (websocketpp::log::alevel::all);
  wppserver_.clear_error_channels (websocketpp::log::elevel::all);
}
 
bool
WebSocketServerImpl::io_handler (PollFD &pfd)
{
  const int fd = pfd.fd;
  IODEBUG ("%s:%u:%s: io-ready(%d): r=%d w=%d other=0x%x\n", __FILE__, __LINE__, __func__, fd,
           pfd.revents & PollFD::IN, pfd.revents & PollFD::OUT,
           pfd.revents & ~(PollFD::IN | PollFD::OUT));
  auto it = clients_.find (fd);
  if (it == clients_.end())
    return false; // client gone
  const WppConnectionP con = it->second.con; // owning copy, reentrant close may erase the client
  if (it->second.out_buffer.size()) {
    auto &client = it->second;
    ssize_t n = ::send (fd, client.out_buffer.data(), client.out_buffer.size(), 0);
    IODEBUG ("%s:%u:%s: send(%d,%d)\n", __FILE__, __LINE__, __func__, fd, n);
    if (n > 0)
      client.out_buffer.erase (0, n);
    else if (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
      con->fatal_error();
      it = clients_.find (fd);
      return_unless (it != clients_.end(), false);
    }
  }
  if ((pfd.revents & PollFD::IN) &&
      con->get_state() != websocketpp::session::state::closed) {
    char buf[8192];
    ssize_t n = ::recv (fd, buf, sizeof (buf), 0);
    IODEBUG ("%s:%u:%s: recv(%d)=%d\n", __FILE__, __LINE__, __func__, fd, n);
    if (n > 0) {
      try {
        con->read_all (buf, n);
      } catch (...) {
        con->fatal_error();  // websocketpp error
      }
    }
    else if (n == 0)
      con->eof();
    else if (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK)
      con->fatal_error();    // read EIO
    it = clients_.find (fd);
    return_unless (it != clients_.end(), false);
  }
  if (pfd.revents & (PollFD::ERR | PollFD::HUP | PollFD::NVAL)) { // 0x8 0x10 0x20
    con->fatal_error();    // fd EIO
    it = clients_.find (fd);
    return_unless (it != clients_.end(), false);
  }
  if (con->get_state() == websocketpp::session::state::closed)
    IODEBUG ("%s:%u:%s: closed fd=%d ob=%d io_errors=0x%x\n", __FILE__, __LINE__, __func__, fd, it->second.out_buffer.size(), pfd.revents & (PollFD::ERR | PollFD::HUP | PollFD::NVAL));
  if (it->second.out_buffer.size())
    pfd.events |= PollFD::OUT;
  else
    pfd.events &= ~PollFD::OUT;
  const bool closed = it->second.out_buffer.empty() && con->get_state() == websocketpp::session::state::closed;
  return !closed; // keep handler if not closed
}
 
// Update client sources when clients connect/disconnect
void
WebSocketServerImpl::update_client_sources()
{
  // Register missing client fds
  for (auto &[fd, client] : clients_)
    if (client.source_id == Ase::LoopID::INVALID)
      client.source_id = main_loop->exec_io_handler ([this] (PollFD &pfd)
      {
        return this->io_handler (pfd);
      }, fd, "r", LoopPriority::NORMAL);
}
 
// == WebSocketConnection ==
struct WebSocketConnection::Internals {
  WebSocketServerImplP server;
  WppServer           &wppserver;
  WppHdl               hdl;
  String               nickname_;
  bool                 opened = false;
  WppConnectionP       wppconp()        { return server->wppconp (hdl); }
  friend struct WebSocketServerImpl;
};
 
void
WebSocketConnection::log_status (int intstatus, const String &filepath)
{
  const auto status = websocketpp::http::status_code::value (intstatus);
  WppConnectionP cp = internals_.wppconp();
  if (!cp || !(logflags_ & 16))
    return;
  using namespace AnsiColors;
  const bool rejected = (status >= 400 && status <= 499) || status == 303;
  const String C1 = rejected ? color (FG_RED) : "";
  const String C0 = rejected ? color (RESET) : "";
  String resource = cp->get_resource();
  resource = Re::sub ("\\btoken=[^;?]+", "token=<………>", resource);
  log (string_format ("%s%d %s %s%s%s",
                      C1, status,
                      cp->get_request().get_method(), resource, C0,
                      filepath.empty() ? "" : " [" + filepath + "]"));
}
 
WebSocketConnection::WebSocketConnection (Internals &internals, int logflags) :
  internals_ (*new (internals_mem_) Internals (internals)), logflags_ (logflags)
{
  static_assert (sizeof (Internals) <= sizeof (internals_mem_));
  assert_return (internals_.server != nullptr);
}
 
WebSocketConnection::~WebSocketConnection()
{
  internals_.~Internals();
}
 
bool
WebSocketConnection::is_open () const
{
  return internals_.opened;
}
 
bool
WebSocketConnection::send_text (const String &message)
{
  assert_return (!message.empty(), false);
  WppConnectionP cp = internals_.wppconp();
  return_unless (cp, false);
  websocketpp::lib::error_code ec;
  // Find client fd for debug logging
  int fd = -1;
  for (const auto &[f, client] : internals_.server->clients_)
    if (client.con == cp)
      { fd = f; break; }
  IODEBUG ("%s:%u:%s: fd=%d message=%d\n", __FILE__, __LINE__, __func__, fd, message.size());
  internals_.wppserver.send (internals_.hdl, message, websocketpp::frame::opcode::text, ec);
  if (ec)
    {
      if (logflags_ > 0)
        log (string_format ("Error: %s: %s", __func__, ec.message()));
      websocketpp::lib::error_code ec2;
      cp->close (websocketpp::close::status::going_away, "", ec2);
      return false;
    }
  return true;
}
 
bool
WebSocketConnection::send_binary (const String &blob)
{
  WppConnectionP cp = internals_.wppconp();
  return_unless (cp, false);
  websocketpp::lib::error_code ec;
  internals_.wppserver.send (internals_.hdl, blob, websocketpp::frame::opcode::binary, ec);
  if (ec)
    {
      if (logflags_ > 0)
        log (string_format ("Error: %s: %s", __func__, ec.message()));
      websocketpp::lib::error_code ec2;
      cp->close (websocketpp::close::status::going_away, "", ec2);
      return false;   // invalid connection or send failed
    }
  if (ASE_UNLIKELY (logflags_ & 256))
    {
      String hex;
      for (size_t i = 0; i < blob.size(); i++)
        {
          if (i && 0 == i % 16)
            hex += "\n ";
          else if (0 == i % 8)
            hex += " ";
          hex += string_format (" %02x", blob[i]);
        }
      log (string_format ("⇜ Blob: len=%d hash=%016x\n%s", blob.size(), fnv1a_consthash64 (blob.data(), blob.size()), hex));
    }
  return true; // connection alive and message queued
}
 
WebSocketConnection::Info
WebSocketConnection::get_info ()
{
  WppConnectionP cp = internals_.wppconp();
  const websocketpp::http::parser::request &rq = cp->get_request();
  auto headers = std::make_shared<websocketpp::http::parser::header_list> (rq.get_headers());
  Info info;
  info.header = [headers] (const String &header) {
    const auto it = headers->find (header);
    return it == headers->end() ? "" : it->second;
  };
  if (0)
    for (auto it : *headers)
      IODEBUG ("%s: %s\n", it.first, it.second);
 
  // Lookup IP/Port from our manual ClientState map
  for (const auto &[fd, client] : internals_.server->clients_)
    if (client.con == cp) {
      info.local = client.local_ip;
      info.lport = client.local_port;
      info.remote = client.remote_ip;
      info.rport = client.remote_port;
      break;
    }
  info.subs = cp->get_requested_subprotocols();
  return info;
}
 
String
WebSocketConnection::nickname ()
{
  if (internals_.nickname_.empty())
    {
      Info info = get_info();
      const String ua = info.header ("User-Agent");
      String s = info.local + ":" + string_from_int (info.lport) + "\n" +
                 info.remote + ":" + string_from_int (info.rport * 0) + "\n" +
                 ua + "\n" +
                 info.header ("Accept-Encoding") + "\n" +
                 info.header ("Accept-Language") + "\n" +
                 info.header ("sec-ch-ua") + "\n" +
                 info.header ("sec-ch-ua-mobile") + "\n" +
                 info.header ("sec-gpc") + "\n";
      String hh;
      uint64_t hash = string_hash64 (s);
      if      (Re::search (R"(\bFirefox/)", ua) >= 0)
        hh = "FF";
      else if (Re::search (R"(\bElectron/)", ua) >= 0)
        hh = "El";
      else if (Re::search (R"(\bChrome-Lighthouse\b)", ua) >= 0)
        hh = "Lh";
      else if (Re::search (R"(\bChrome/)", ua) >= 0)
        hh = "CR";
      else if (Re::search (R"(\bSafari/)", ua) >= 0)
        hh = "Sa";
      else if (Re::search (R"(\bWget/)", ua) >= 0)
        hh = "Wg";
      else if (Re::search (R"(\bw3m/)", ua) >= 0)
        hh = "W3";
      else if (Re::search (R"(\bLynx/)", ua) >= 0)
        hh = "Ly";
      else if (Re::search (R"(\bPython-urllib/)", ua) >= 0)
        hh = "Py";
      else
        hh = "NA";
      internals_.nickname_ = string_format ("%s-%08x:%x", hh, uint32_t (hash ^ (hash >> 32)), info.rport);
    }
  return internals_.nickname_;
}
 
int  WebSocketConnection::validate ()                           { return -1; }
void WebSocketConnection::failed ()                             { /*if (logflags_ & 2) log (__func__);*/ }
void WebSocketConnection::opened ()                             { if (logflags_ & 4) log (__func__); }
void WebSocketConnection::message (const String &message)       { if (logflags_ & 8) log (__func__); }
void WebSocketConnection::closed ()                             { if (logflags_ & 4) log (__func__); }
void WebSocketConnection::log (const String &message)           { printerr ("%s\n", message);}
 
bool
WebSocketConnection::authenticated (const String &token)
{
  WppConnectionP cp = internals_.wppconp();
  if (!cp)
    return false;
  if (token.empty())
    return true;
  const String cookie_header = cp->get_request().get_header ("Cookie");
  const String cookie_token = Re::grep ("\\bsession_auth=([^;?]+)", cookie_header, 1);
  return cookie_token == token;
}
 
enum CacheType {
  CACHE_NEVER,
  CACHE_AUTO,
  CACHE_BRIEFLY,
  CACHE_FOREVER,
};
 
void
WebSocketConnection::http_request ()
{
  if (internals_.server->dir_.empty())
    return;
  WppConnectionP cp = internals_.wppconp();
  const auto &parts = string_split (cp->get_resource(), "?");
  const String query = cp->get_uri()->get_query();
  String filepath;
 
  // Helpers
  auto set_response = [] (WppConnectionP cp, websocketpp::http::status_code::value status, const String &title, const String &msg)
  {
    const String body =
      string_format ("<!DOCTYPE html>\n"
                     "<html><head><title>%u %s</title></head>\n<body>\n"
                     "<h1>%s</h1>\n\n"
                     "%s\n"
                     "<hr><address>%s</address>\n"
                     "<hr></body></html>\n", status, title, title,
                     msg.size() ? "<p>" + msg + "</p>" : "",
                     WebSocketServer::user_agent());
    cp->set_body (body);
    cp->replace_header ("Content-Type", "text/html; charset=utf-8");
    cp->set_status (status);
  };
 
  // GET ~auth
  if (cp->get_request().get_method() == "GET" && parts[0] == "/~auth" &&
      (authenticated (internals_.server->token_) ||
       Re::search ("\\btoken=" + internals_.server->token_ + "\\b", query) >= 0)) {
    const std::string target = string_format ("http://localhost:%u/", cp->get_port());
    cp->replace_header ("Set-Cookie", "session_auth=" + internals_.server->token_ + "; Path=/; HttpOnly");
    cp->replace_header ("Location", target);
    set_response (cp, websocketpp::http::status_code::found, // 302 Found
                  "Found", "Redirecting to: <tt>" + target + "</tt>");
    log_status (cp->get_response_code());
    return;
  }
 
  // Validate Cookie session_auth
  if (!authenticated (internals_.server->token_)) {
    const std::string see_other = internals_.server->see_other_;
    if (see_other.empty())
      set_response (cp, websocketpp::http::status_code::method_not_allowed, // 405 Method Not Allowed
                    "Method Not Allowed", "Authentication required.");
    else {
      if (string_startswith (see_other, "http"))
        cp->replace_header ("Location", see_other);
      set_response (cp, websocketpp::http::status_code::see_other, // 303 See Other
                    "See Other", "<a href=\"" + see_other + "\">" + see_other + "</a>");
    }
    log_status (cp->get_response_code());
    return;
  }
 
  // find file for URL
  filepath = internals_.server->map_url (parts[0]);
 
  // map directories to index.html
  if (!filepath.empty() && Path::check (filepath, "dx"))
    filepath = Path::join (filepath, "index.html");
 
  // GET
  if (cp->get_request().get_method() == "GET") {
    // serve existing files
    const String accept_encoding = cp->get_request().get_header ("Accept-Encoding");
    const bool canzip = nullptr != string_find_word (accept_encoding.c_str(), "gzip");
    bool fp = false, fz = false;
    if (!filepath.empty() && ((fp = Path::check (filepath, "fr")) || (fz = canzip && Path::check (filepath + ".gz", "fr"))))
      {
        const char *ext = strrchr (filepath.c_str(), '.');
        const String mimetype = WebSocketServer::mime_type (ext ? ext + 1 : "", true);
        cp->append_header ("Content-Type", mimetype);
        // Use CACHE_FOREVER for text/css to reduce FOUC (flashing of unstyled content)
        // with shadowRoot stylesheet links in Chrome-115. CACHE_AUTO worsens FOUC.
        const CacheType caching = mimetype == "text/css" ? CACHE_FOREVER : CACHE_AUTO;
        switch (caching) {
        case CACHE_NEVER:         // response must not be stored in cache
          cp->append_header ("Cache-Control", "no-store");
          break;
        case CACHE_AUTO:          // force response revalidation if content stored in cache
          cp->append_header ("Cache-Control", "no-cache"); // max-age=0, must-revalidate
          break;
        case CACHE_BRIEFLY:       // needs validation support: https://developer.mozilla.org/en-US/docs/Web/HTTP/Conditional_requests
          cp->append_header ("Cache-Control", "max-age=7, stale-while-revalidate=31536000");
          break;
        case CACHE_FOREVER:       // keep content forever in cache
          cp->append_header ("Cache-Control", "max-age=31536000, public, immutable");
          break;
        }
        if (fz) {
          filepath = filepath + ".gz";
          cp->append_header ("Content-Encoding", "gzip");
        }
        Blob blob = Blob::from_file (filepath);
        cp->set_body (blob.string());
        cp->set_status (websocketpp::http::status_code::ok); // 200 OK
      }
    else // 404
      set_response (cp, websocketpp::http::status_code::not_found, // 404 Not Found
                    "Not Found",
                    "The requested URL was not found: <br /> <tt>" + cp->get_uri()->str() + "</tt>");
  }
  else // 405
    set_response (cp, websocketpp::http::status_code::method_not_allowed, // 405 Method Not Allowed
                  "Method Not Allowed", "");
 
  log_status (cp->get_response_code());
}
 
// == WebSocketServerImpl ==
WebSocketConnectionP
WebSocketServerImpl::make_connection (WppHdl hdl)
{
  WppConnectionP cp = wppconp (hdl);
  assert_return (cp, nullptr);
  WebSocketConnection::Internals internals {
    std::dynamic_pointer_cast<WebSocketServerImpl> (shared_from_this()),
    wppserver_, hdl,
  };
  WebSocketConnectionP conp = make_con_ (internals, logflags_);
  // capturing conp in handler contexts keeps it alive long enough for calls
  cp->set_http_handler ([conp] (WppHdl hdl) {
    WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
    assert_return (hdl == internals_.hdl);
    conp->http_request();
  });
  // cp->set_validate_handler (...); - too late, validate_handler calls make_connection()
  cp->set_fail_handler ([conp] (WppHdl hdl) {
    WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
    assert_return (hdl == internals_.hdl);
    conp->failed();
  });
  cp->set_open_handler  ([conp] (WppHdl hdl) {
    WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
    assert_return (hdl == internals_.hdl);
    internals_.server->ws_opened (conp);
  });
  cp->set_message_handler ([conp] (WppHdl hdl, WppServer::message_ptr msg) {
    WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
    assert_return (hdl == internals_.hdl);
    conp->message (msg->get_payload());
  });
  cp->set_close_handler ([conp] (WppHdl hdl) {
    WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
    assert_return (hdl == internals_.hdl);
    internals_.server->ws_closed (conp);
  });
  return conp;
}
 
void
WebSocketServerImpl::ws_opened (WebSocketConnectionP conp)
{
  WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
  internals_.opened = true;
  opencons_.push_back (conp);
  // Update client sources to include the new connection
  update_client_sources();
  conp->opened ();
}
 
void
WebSocketServerImpl::ws_closed (WebSocketConnectionP conp)
{
  WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
  WppConnectionP wppconp = internals_.wppconp();
  if (internals_.opened) {
    internals_.opened = false;
    auto it = std::find (opencons_.begin(), opencons_.end(), conp);
    if (it != opencons_.end())
      opencons_.erase (it);
    // Find and remove the client from clients_
    for (auto client_it = clients_.begin(); client_it != clients_.end(); ) {
      if (client_it->second.con == wppconp) {
        auto &[fd, client] = *client_it;
        ::close (fd);
        main_loop->cancel (&client.source_id);
        IODEBUG ("%s:%u:%s: closed fd=%d ob=%d\n", __FILE__, __LINE__, __func__, fd, client.out_buffer.size());
        client_it = clients_.erase (client_it);
      } else
        ++client_it;
    }
    conp->closed();
  }
}
 
void
WebSocketServerImpl::reset()
{
  // stop open connections
  for (ssize_t i = ssize_t (opencons_.size()) - 1; i >= 0; i--)
    {
      WebSocketConnectionP conp = opencons_[i];
      WebSocketConnection::Internals &internals_ = WebSocketServer::internals (*conp);
      WppConnectionP cp = internals_.wppconp();
      websocketpp::lib::error_code ec;
      cp->close (websocketpp::close::status::going_away, "", ec); // omit_handshake
    }
 
  // cancel client sources and close raw sockets
  for (auto &[fd, client] : clients_) {
    ::close (fd);
    main_loop->cancel (&client.source_id);
    IODEBUG ("%s:%u:%s: closed fd=%d ob=%d\n", __FILE__, __LINE__, __func__, fd, client.out_buffer.size());
  }
  clients_.clear();
}
 
// == WebSocketServer ==
WebSocketServer::~WebSocketServer()
{}
 
WebSocketServer::SocketInfo
WebSocketServer::bind_port (const String &host, int port)
{
  SocketInfo sinfo { -1, host, port };
  sinfo.fd = socket (AF_INET, SOCK_STREAM, 0);
  if (sinfo.fd < 0)
    fatal_error ("failed to create socket for: %s:%d: %s", host, port, strerror (errno));
  sockaddr_in addr{};
  int opt = 1;
  if (port > 0) {
    setsockopt (sinfo.fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));
    addr.sin_port = htons (port);
  }
  addr.sin_family = AF_INET;
  if (host == "0.0.0.0")
    addr.sin_addr.s_addr = htonl (INADDR_ANY);
  else
    {
      addr.sin_addr.s_addr = inet_addr (host.c_str());
      if (addr.sin_addr.s_addr == INADDR_NONE)
        addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
    }
  if (bind (sinfo.fd, (sockaddr*) &addr, sizeof (addr)) < 0)
    fatal_error ("failed to bind to %s:%d, fd=%d: %s", host, port, sinfo.fd, strerror (errno));
  socklen_t len = sizeof (addr);
  if (getsockname (sinfo.fd, (sockaddr*) &addr, &len) == 0)
    sinfo.port = ntohs (addr.sin_port);
  return sinfo;
}
 
WebSocketServerP
WebSocketServer::create (const MakeConnection &make, int logflags, const std::string &session_token)
{
  return std::make_shared<WebSocketServerImpl> (make, logflags, session_token);
}
 
String
WebSocketServer::user_agent ()
{
  return String ("AnklangSynthEngine/") + ase_version();
}
 
bool
WebSocketServer::utf8_validate (const std::string &utf8string)
{
  return !!websocketpp::utf8_validator::validate (utf8string);
}
 
#include "mime-types.hh"        // static const char mime_types[];
 
String
WebSocketServer::mime_type (const String &ext, bool utf8)
{
  using MimeMap = std::unordered_map<String, String>;
  static MimeMap mime_map = [] ()
  {
    MimeMap mime_map;
    // mime_types, list of "mime/type ext ext2\n" lines
    for (const String &line : string_split (mime_types, "\n"))
      {
        const StringS w = string_split (line, " ");
        for (size_t i = 1; i < w.size(); i++)
          if (!w[i].empty())
            {
              if (mime_map.end() != mime_map.find (w[i]))
                warning ("mime-types.hh: duplicate extension: %s", w[i]);
              mime_map[w[i]] = w[0];
            }
      }
    return mime_map;
  } ();
  auto it = mime_map.find (ext);
  String mimetype = it != mime_map.end() ? it->second : "application/octet-stream";
  if (utf8)
    {
      if (mimetype == "text/html" || mimetype == "text/markdown" || mimetype == "text/plain")
        mimetype += "; charset=utf-8";
    }
  return mimetype;
}
 
} // Ase