protocol.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/transport.h>
#include <net/auth.h>
#include <net/settings.h>
#include <protocol/protocol.h>
#include <protocol/protocol_oob.h>
#include <protocol/registry.h>
#include <run/run_manager.h>
#include <utils/StringPrint.h>
#include <utils/logging.h>
#include <utils/serial_lines.h>
 
#include <algorithm>
#include <cctype>
#include <cstring>
#include <locale>
#include <utils/streaming_json.h>
 
void trim(char *str) {
  unsigned int start = 0, end = strlen(str) - 1;
 
  // Remove leading whitespace
  while (isspace(str[start])) {
    start++;
  }
 
  // Remove trailing whitespace
  while (end > start && isspace(str[end])) {
    end--;
  }
 
  // If the string was trimmed, adjust the null terminator
  if (start > 0 || end < (strlen(str) - 1)) {
    memmove(str, str + start, end - start + 1);
    str[end - start + 1] = '\0';
  }
}
 
void msg::Broker::handleMessage(transport::Transport &transport, pb_Envelope &in_envelope) {
  auto msg_stream = transport.ctrl_output();
 
  if (in_envelope.which_kind != pb_Envelope_message_v1_tag) {
    msg_stream->report_error("handler only supports v1 messages!");
    return;
  }
 
  int envelope_kind = in_envelope.which_kind;
  int message_kind;
  if (envelope_kind == pb_Envelope_generic_tag) {
    message_kind = in_envelope.kind.generic.which_kind;
  }else if (envelope_kind == pb_Envelope_message_v1_tag) {
    message_kind = in_envelope.kind.message_v1.which_kind;
  }else {
    msg_stream->report_error("Unknown envelope kind.");
    return;
  }
 
  // Select message handler
  auto msg_handler = msg::handlers::Registry::get().lookup(envelope_kind, message_kind);
  if (!msg_handler) {
    msg_stream->report_error("Error unknown handler for message type.");
    return;
  }
  //auto requiredClearance = msg::handlers::Registry::get().requiredClearance(msg_type);
  if (msg_handler->handle(transport, in_envelope))
    return;
 
  msg_stream->report_error("Error while handling streaming message.");
  LOG_ALWAYS("Error while handling message.");
}
 
utils::SerialLineReader serial_line_reader;
 
bool msg::Broker::process(transport::Transport &transport) {
  pb_Envelope envelope;
  auto result = transport.ctrl_input()->read(envelope);
  if (result.is_ok()) {
    handleMessage(transport, envelope);
    pb_release(pb_Envelope_fields, &envelope);
    return true;
  }
 
  transport.ctrl_output()->report_error(result.err_value());
  LOG_ALWAYS(result.err_value().c_str());
  LOG_ALWAYS("Malformed input. Expecting protobuf.");
  return false;
}