o3r.h

/*
 * Copyright 2021-present ifm electronic, gmbh
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef IFM3D_DEVICE_O3R_H
#define IFM3D_DEVICE_O3R_H
 
#include <ifm3d/common/features.h>
#include <ifm3d/device/device.h>
#include <sstream>
#ifdef BUILD_MODULE_CRYPTO
#  include <ifm3d/crypto/crypto.h>
#endif
#include <ifm3d/device/pcic_command.h>
#include <initializer_list>
#include <optional>
#include <variant>
#include <vector>
 
namespace ifm3d
{
  static const int NET_WAIT_O3R_SET =
    std::getenv("IFM3D_NET_WAIT_O3R_SET") == nullptr ?
      15000 :
      std::stoi(std::getenv("IFM3D_NET_WAIT_O3R_SET"));
 
  struct IFM3D_EXPORT RtspControlInfo
  {
    uint16_t tcp_port;
  };
 
  struct IFM3D_EXPORT RtspMediaEndpoint
  {
    std::string path;
  };
 
  struct IFM3D_EXPORT RtspInfo
  {
    RtspControlInfo control;
    std::vector<RtspMediaEndpoint> media_endpoints;
    std::vector<std::string> supported_transports;
  };
 
  struct IFM3D_EXPORT PortInfo
  {
    std::string port;
    uint16_t pcic_port;
    std::string type;
    std::optional<RtspInfo> rtsp;
  };
 
#ifdef BUILD_MODULE_CRYPTO
  class O3RSealedBox;
#endif
 
  class IFM3D_EXPORT O3R : public Device
  {
  public:
    using Ptr = std::shared_ptr<O3R>;
    O3R(const std::string& ip = ifm3d::DEFAULT_IP,
        std::uint16_t xmlrpc_port = ifm3d::DEFAULT_XMLRPC_PORT);
 
    ~O3R() override;
    O3R(O3R&&) = delete;
    O3R& operator=(O3R&&) = delete;
    O3R(O3R&) = delete;
    O3R& operator=(O3R&) = delete;
 
    virtual void FactoryReset(bool keep_network_settings);
 
    json GetSchema();
 
    json GetSchema(
      std::variant<std::monostate, std::string, std::vector<std::string>>
        pointers);
 
    json GetSchema(std::initializer_list<std::string> pointers);
 
    json Get(
      const std::vector<std::string>& path = std::vector<std::string>());
 
    json ResolveConfig(const json::json_pointer& ptr);
 
    void Set(const json& j);
 
    void Remove(const std::string& json_pointer);
 
    void Reset(const std::string& json_pointer);
 
    json GetInit();
 
    void SaveInit(const std::vector<std::string>& pointers = {});
 
    std::string GetInitStatus();
 
    void Lock(const std::string& password);
 
    void Unlock(const std::string& password);
 
    std::vector<PortInfo> Ports();
 
    PortInfo Port(const std::string& port);
 
    json GetDiagnostic();
 
    json GetDiagnosticFilterSchema();
 
    json GetDiagnosticFiltered(const json& filter);
 
    void Reboot(
      const BootMode& mode = ifm3d::Device::BootMode::PRODUCTIVE) override;
 
    void RebootToRecovery();
 
    DeviceFamily WhoAmI() override;
    ifm3d::Device::SWUVersion SwUpdateVersion() override;
 
    json ToJSON() override;
 
    void FromJSON(const json& j) override;
 
    void DownloadServiceReport(const std::string& out_file);
 
#ifdef BUILD_MODULE_CRYPTO
    std::shared_ptr<O3RSealedBox> SealedBox();
#endif
 
    struct SetTemporaryApplicationParameter : public PCICCommand
    {
      enum Parameter : uint16_t
      {
        ODS_OVERHANGING_LOAD = 2003,
        ODS_ZONE_SET = 2101,
        ODS_MAXIMUM_HEIGHT = 2102,
        ODS_MOTION_DATA = 2103,
        PDS_GET_PALLET = 2200,
        PDS_GET_ITEM = 2201,
        PDS_GET_RACK = 2202,
        PDS_VOL_CHECK = 2203,
      };
 
      Parameter parameter;
      std::vector<std::uint8_t> data;
 
      SetTemporaryApplicationParameter(
        Parameter param,
        std::vector<std::uint8_t> parameter_data)
        : parameter(param),
          data(std::move(parameter_data))
      {}
 
      std::vector<std::uint8_t>
      SerializeData() const override
      {
        std::vector<std::uint8_t> payload;
 
        // 'f' command prefix
        payload.push_back(static_cast<uint8_t>('f'));
 
        // parameter ID as 5-digit ASCII string padded with zeros
        std::ostringstream param;
        param << std::setw(5) << std::setfill('0')
              << static_cast<uint16_t>(parameter);
        const std::string paramStr = param.str(); // e.g., "02103"
        payload.insert(payload.end(), paramStr.begin(), paramStr.end());
 
        // reserved string "#00000" as bytes
        const std::string reserved = "#00000";
        payload.insert(payload.end(), reserved.begin(), reserved.end());
 
        // append user data bytes
        payload.insert(payload.end(), data.begin(), data.end());
 
        return payload;
      }
    };
 
  private:
    class Impl;
    std::shared_ptr<Impl> _impl;
 
#ifdef BUILD_MODULE_CRYPTO
    friend class O3RSealedBox;
#endif
  }; // end: class O3R
 
#ifdef BUILD_MODULE_CRYPTO
  class IFM3D_EXPORT O3RSealedBox
  {
  public:
    using Ptr = std::shared_ptr<O3RSealedBox>;
 
    O3RSealedBox(const O3RSealedBox&) = default;
    O3RSealedBox(O3RSealedBox&&) = delete;
    O3RSealedBox& operator=(const O3RSealedBox&) = default;
    O3RSealedBox& operator=(O3RSealedBox&&) = delete;
    O3RSealedBox(std::shared_ptr<O3R::Impl> p_impl);
    ~O3RSealedBox();
 
    void SetPassword(const std::string& new_password,
                     std::optional<std::string> old_password = std::nullopt);
 
    bool IsPasswordProtected();
 
    void RemovePassword(std::string password);
 
    void Set(const std::string& password, const json& configuration);
 
    std::vector<uint8_t> GetPublicKey();
 
  private:
    std::shared_ptr<O3R::Impl> _impl;
  };
#endif
}
 
#endif // IFM3D_DEVICE_O3R_H