jsonl_server.cpp

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
//
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#include "proto/main.pb.h"
#include "protocol/jsonl_server.h"
 
#include "net/ethernet.h"
#include "protocol/protocol.h"
#include "utils/logging.h"
 
void msg::ApplicationServer::begin() {
  server.begin(net::StartupConfig::get().jsonl_port);
}
 
void msg::ApplicationServer::_accept_clients() {
  net::EthernetClient client_socket = server.accept();
 
  if (!client_socket) return;
  auto remote_ip = client_socket.remoteIP();
 
  // note there is also net::EthernetClient::maxSockets(), which is dominated by basic system constraints.
  // This limit here is rather dominated by application level constraints and can probably be a counter
  // measure against ddos attacks.
  if (clients.size() == net::StartupConfig::get().max_connections) {
    LOG5("Cannot accept client from ", remote_ip, " because maximum number of connections (",
         net::StartupConfig::get().max_connections, ") already reached.");
    client_socket.stop();
    return;
  }
 
 
  // note that the following code copies "socket" object multiple times. When using pointers into
  // the struct, do not use the pointer to the wrong version.
  // TODO: Clean up code.
  auto socket = std::make_shared<net::EthernetClient>(std::move(client_socket));
 
  LOG4("Client ", static_cast<unsigned>(clients.size()), " connected from ", remote_ip);
  auto& client = clients.emplace_back(ApplicationClient{
    .socket = socket,
    .transport = transport::Transport(
        std::make_shared<transport::DelimitedInputStream<std::shared_ptr<Client>>>(socket),
        std::make_shared<transport::DelimitedMessageOutputStream<std::shared_ptr<Client>>>(socket),
        std::make_shared<transport::DelimitedMessageOutputStream<std::shared_ptr<Client>>>(socket),
        remote_ip
      ),
  });
 
  client.user_context.set_remote_identifier(net::auth::RemoteIdentifier{remote_ip});
}
 
void msg::ApplicationServer::_handle_clients() {
  // using iterator instead range-based loop because EthernetClient lacks == operator
  // so we use list::erase instead of list::remove.
  for (auto it = clients.begin(); it != clients.end(); ++it) {
    auto& client = *it;
    auto& socket = client.socket;
 
    if (socket->connected()) {
      if (socket->available() > 0) {
        Broker::get().process(client.transport);
        client.last_contact.reset();
      } else if (client.last_contact.expired(net::StartupConfig::get().connection_timeout_ms)) {
        LOG3("Client timed out after ",
             net::StartupConfig::get().connection_timeout_ms, " ms of idling");
        socket->stop();
      }
    } else {
      LOG3("Client  was ", client.user_context, ", disconnected");
      socket->stop(); // important, stop waits
      clients.erase(it);
      return; // iterator invalidated, better start loop() freshly.
    }
  }
}
 
 
void msg::ApplicationServer::loop() {
  _accept_clients();
  _handle_clients();
  delay(100);
}