broker.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************
 * This file is a part of RDMnet. For more information, go to:
 * https://github.com/ETCLabs/RDMnet
 *****************************************************************************/
 
 
#ifndef RDMNET_CPP_BROKER_H_
#define RDMNET_CPP_BROKER_H_
 
#include <cstdint>
#include <cstring>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "etcpal/common.h"
#include "etcpal/cpp/error.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/log.h"
#include "etcpal/cpp/uuid.h"
#include "rdm/cpp/uid.h"
#include "rdmnet/common.h"
#include "rdmnet/defs.h"
 
class BrokerCore;
 
namespace rdmnet
{
 
struct DnsTxtRecordItem
{
  std::string          key;    
  std::vector<uint8_t> value;  
 
  DnsTxtRecordItem() = default;
  DnsTxtRecordItem(const char* new_key, const char* new_value);
  DnsTxtRecordItem(const char* new_key, const uint8_t* new_value, size_t new_value_len);
  DnsTxtRecordItem(const std::string& new_key, const std::string& new_value);
  DnsTxtRecordItem(const std::string& new_key, const uint8_t* new_value, size_t new_value_len);
  DnsTxtRecordItem(const std::string& new_key, const std::vector<uint8_t>& new_value);
};
 
inline DnsTxtRecordItem::DnsTxtRecordItem(const char* new_key, const char* new_value)
{
  if (new_key)
    key = std::string(new_key);
 
  if (new_value)
    value = std::vector<uint8_t>(new_value, &new_value[std::strlen(new_value)]);
}
 
inline DnsTxtRecordItem::DnsTxtRecordItem(const char* new_key, const uint8_t* new_value, size_t new_value_len)
{
  if (new_key)
    key = std::string(new_key);
 
  if (new_value)
    value = std::vector<uint8_t>(new_value, new_value + new_value_len);
}
 
inline DnsTxtRecordItem::DnsTxtRecordItem(const std::string& new_key, const std::string& new_value)
    : key(new_key), value(new_value.begin(), new_value.end())
{
}
 
inline DnsTxtRecordItem::DnsTxtRecordItem(const std::string& new_key, const uint8_t* new_value, size_t new_value_len)
    : key(new_key)
{
  if (new_value)
    value = std::vector<uint8_t>(new_value, new_value + new_value_len);
}
 
inline DnsTxtRecordItem::DnsTxtRecordItem(const std::string& new_key, const std::vector<uint8_t>& new_value)
    : key(new_key), value(new_value)
{
}
 
class Broker
{
public:
  struct DnsAttributes
  {
    std::string service_instance_name;
 
    std::string manufacturer{"Generic Manufacturer"};
    std::string model{"Generic RDMnet Broker"};
 
    std::vector<DnsTxtRecordItem> additional_txt_record_items;
  };
 
  struct Limits
  {
    unsigned int connections{0};
    unsigned int controllers{0};
    unsigned int controller_messages{500};
    unsigned int devices{0};
    unsigned int device_messages{500};
    unsigned int reject_connections{1000};
  };
 
  struct Settings
  {
    etcpal::Uuid  cid;     
    rdm::Uid      uid;     
    DnsAttributes dns;     
    Limits        limits;  
 
    std::string scope{E133_DEFAULT_SCOPE};
    // bool allow_rdm_scope_change{false};  // (TODO: Not yet implemented)
    // bool allow_rdm_disable{false};  // (TODO: Not yet implemented)
 
    uint16_t listen_port{0};
 
    std::vector<std::string> listen_interfaces;
 
    Settings() = default;
    Settings(const etcpal::Uuid& cid_in, const rdm::Uid& static_uid_in);
    Settings(const etcpal::Uuid& cid_in, uint16_t rdm_manu_id_in);
 
    void SetDefaultServiceInstanceName();
 
    bool IsValid() const;
  };
 
  class NotifyHandler
  {
  public:
    virtual ~NotifyHandler() = default;
 
    virtual void HandleScopeChanged(const std::string& new_scope) { ETCPAL_UNUSED_ARG(new_scope); }
  };
 
  Broker();
  virtual ~Broker();
 
  Broker(const Broker& other) = delete;
  Broker& operator=(const Broker& other) = delete;
  Broker(Broker&& other) = default;
  Broker& operator=(Broker&& other) = default;
 
  etcpal::Error Startup(const Settings& settings, etcpal::Logger* logger = nullptr, NotifyHandler* notify = nullptr);
  void          Shutdown(rdmnet_disconnect_reason_t disconnect_reason = kRdmnetDisconnectShutdown);
  etcpal::Error ChangeScope(const std::string& new_scope, rdmnet_disconnect_reason_t disconnect_reason);
 
  const Settings& settings() const;
 
private:
  std::unique_ptr<BrokerCore> core_;
};
 
inline void Broker::Settings::SetDefaultServiceInstanceName()
{
  dns.service_instance_name = "RDMnet Broker Instance " + cid.ToString();
}
 
inline Broker::Settings::Settings(const etcpal::Uuid& cid_in, const rdm::Uid& static_uid_in)
    : cid(cid_in), uid(static_uid_in)
{
  SetDefaultServiceInstanceName();
}
 
inline Broker::Settings::Settings(const etcpal::Uuid& cid_in, uint16_t rdm_manu_id_in)
    : cid(cid_in), uid(rdm::Uid::DynamicUidRequest(rdm_manu_id_in))
{
  SetDefaultServiceInstanceName();
}
 
inline bool Broker::Settings::IsValid() const
{
  // clang-format off
  return (
          !cid.IsNull() &&
          (!scope.empty() && scope.length() < (E133_SCOPE_STRING_PADDED_LENGTH - 1)) &&
          (!dns.manufacturer.empty() && dns.manufacturer.length() < (E133_MANUFACTURER_STRING_PADDED_LENGTH - 1)) &&
          (!dns.model.empty() && dns.model.length() < (E133_MODEL_STRING_PADDED_LENGTH - 1)) &&
          (!dns.service_instance_name.empty() && dns.service_instance_name.length() < (E133_SERVICE_NAME_STRING_PADDED_LENGTH - 1)) &&
          (listen_port == 0 || listen_port >= 1024) &&
          (uid.manufacturer_id() != 0) &&
          (uid.IsStatic() || uid.IsDynamicUidRequest())
         );
  // clang-format on
}
 
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_BROKER_H_