Config.h

Go to the documentation of this file.

/*
 * Deskflow -- mouse and keyboard sharing utility
 * SPDX-FileCopyrightText: (C) 2026 Deskflow Developers
 * SPDX-FileCopyrightText: (C) 2012 - 2016 Synergy App Ltd
 * SPDX-FileCopyrightText: (C) 2002 Chris Schoeneman
 * SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
 */
 
#pragma once
 
#include "base/BaseException.h"
#include "base/String.h"
#include "deskflow/IPlatformComputer.h"
#include "deskflow/OptionTypes.h"
#include "net/NetworkAddress.h"
#include "server/InputFilter.h"
 
#include <iosfwd>
#include <map>
#include <set>
 
namespace deskflow::server {
class Config;
class ConfigReadContext;
} // namespace deskflow::server
 
class IEventQueue;
 
namespace std {
template <> struct iterator_traits<deskflow::server::Config>
{
  using value_type = std::string;
  using difference_type = ptrdiff_t;
  using iterator_category = bidirectional_iterator_tag;
  using pointer = std::string *;
  using reference = std::string &;
};
} // namespace std
 
namespace deskflow::server {


class Config
{
public:
  using ScreenOptions = std::map<OptionID, OptionValue>;
  using Interval = std::pair<float, float>;
 
  class CellEdge
  {
  public:
    CellEdge(Direction side, float position);
    CellEdge(Direction side, const Interval &);
    CellEdge(const std::string &name, Direction side, const Interval &);
    ~CellEdge() = default;
 
    Interval getInterval() const;
    void setName(const std::string_view &newName);
    std::string getName() const;
    Direction getSide() const;
    bool overlaps(const CellEdge &) const;
    bool isInside(float x) const;
 
    // transform position to [0,1]
    float transform(float x) const;
 
    // transform [0,1] to position
    float inverseTransform(float x) const;
 
    // compares side and start of interval
    bool operator<(const CellEdge &) const;
 
    // compares side and interval
    bool operator==(const CellEdge &) const;
 
  private:
    void init(const std::string_view &name, Direction side, const Interval &);
 
  private:
    std::string m_name;
    Direction m_side;
    Interval m_interval;
  };
 
private:
  class Name
  {
  public:
    Name(Config *, const std::string &name);
 
    bool operator==(const std::string &name) const;
 
  private:
    Config *m_config;
    std::string m_name;
  };
 
  class Cell
  {
  private:
    using EdgeLinks = std::map<CellEdge, CellEdge>;
 
  public:
    using const_iterator = EdgeLinks::const_iterator;
 
    bool add(const CellEdge &src, const CellEdge &dst);
    void remove(Direction side);
    void remove(Direction side, float position);
    void remove(const Name &destinationName);
    void rename(const Name &oldName, const std::string &newName);
 
    bool hasEdge(const CellEdge &) const;
    bool overlaps(const CellEdge &) const;
 
    bool getLink(Direction side, float position, const CellEdge *&src, const CellEdge *&dst) const;
 
    bool operator==(const Cell &) const;
 
    const_iterator begin() const;
    const_iterator end() const;
 
  private:
    EdgeLinks m_neighbors;
 
  public:
    ScreenOptions m_options;
  };
  using CellMap = std::map<std::string, Cell, deskflow::string::CaselessCmp>;
  using NameMap = std::map<std::string, std::string, deskflow::string::CaselessCmp>;
 
public:
  using link_const_iterator = Cell::const_iterator;
  using internal_const_iterator = CellMap::const_iterator;
  using all_const_iterator = NameMap::const_iterator;
  class const_iterator : public std::iterator_traits<Config>
  {
  public:
    explicit const_iterator() = default;
    explicit const_iterator(const internal_const_iterator &i) : m_i(i)
    {
      // do nothing
    }
    const_iterator(const const_iterator &src) = default;
    ~const_iterator() = default;
 
    const_iterator &operator=(const const_iterator &i)
    {
      m_i = i.m_i;
      return *this;
    }
    std::string operator*() const
    {
      return m_i->first;
    }
    const std::string *operator->() const
    {
      return &(m_i->first);
    }
    const_iterator &operator++()
    {
      ++m_i;
      return *this;
    }
    const_iterator operator++(int)
    {
      return const_iterator(m_i++);
    }
    const_iterator &operator--()
    {
      --m_i;
      return *this;
    }
    const_iterator operator--(int)
    {
      return const_iterator(m_i--);
    }
    bool operator==(const const_iterator &i) const
    {
      return (m_i == i.m_i);
    }
 
  private:
    internal_const_iterator m_i;
  };
 
  explicit Config(IEventQueue *events);
  virtual ~Config() = default;




  bool addComputer(const std::string &name);


  bool addAlias(const std::string &canonical, const std::string &alias);


  bool connect(
      const std::string &srcName, Direction srcSide, float srcStart, float srcEnd, const std::string &dstName,
      float dstStart, float dstEnd
  );


  bool disconnect(const std::string &srcName, Direction srcSide);


  bool disconnect(const std::string &srcName, Direction srcSide, float position);


  void setDeskflowAddress(const NetworkAddress &);


  bool addOption(const std::string &name, OptionID option, OptionValue value);


  virtual InputFilter *getInputFilter();




  bool isValidComputerName(const std::string &name) const;

  const_iterator begin() const;
  const_iterator end() const;

  all_const_iterator beginAll() const;
  all_const_iterator endAll() const;


  virtual bool isComputer(const std::string &name) const;


  bool isCanonicalName(const std::string &name) const;


  std::string getCanonicalName(const std::string &name) const;


  std::string getNeighbor(const std::string &, Direction, float position, float *positionOut) const;


  bool hasNeighbor(const std::string &, Direction) const;


  bool hasNeighbor(const std::string &, Direction, float start, float end) const;

  link_const_iterator beginNeighbor(const std::string &) const;
  link_const_iterator endNeighbor(const std::string &) const;

  const NetworkAddress &getDeskflowAddress() const;


  const ScreenOptions *getOptions(const std::string &name) const;


  bool hasLockToComputerAction() const;

  bool operator==(const Config &) const;


  void read(ConfigReadContext &context);


  friend std::istream &operator>>(std::istream &, Config &);


  friend std::ostream &operator<<(std::ostream &, const Config &);


  static const char *dirName(Direction);


  static std::string formatInterval(const Interval &);
 
private:
  void readSection(ConfigReadContext &);
  void readSectionOptions(ConfigReadContext &);
  void readSectionScreens(ConfigReadContext &);
  void readSectionLinks(ConfigReadContext &);
  void readSectionAliases(ConfigReadContext &);
 
  InputFilter::Condition *
  parseCondition(const ConfigReadContext &, const std::string &condition, const std::vector<std::string> &args);
  void parseAction(
      ConfigReadContext &, const std::string &action, const std::vector<std::string> &args, InputFilter::Rule &,
      bool activate
  );
 
  void parseComputers(const ConfigReadContext &, const std::string_view &, std::set<std::string> &computers) const;
 
private:
  CellMap m_map;
  NameMap m_nameToCanonicalName;
  NetworkAddress m_deskflowAddress;
  ScreenOptions m_globalOptions;
  InputFilter m_inputFilter;
  bool m_hasLockToComputerAction = false;
  IEventQueue *m_events;
};


class ConfigReadContext
{
public:
  using ArgList = std::vector<std::string>;
 
  explicit ConfigReadContext(std::istream &, int32_t firstLine = 1);
  ~ConfigReadContext() = default;
 
  bool readLine(std::string &);
  uint32_t getLineNumber() const;
 
  bool operator!() const;
 
  Config::Interval parseInterval(const ArgList &args) const;
  void parseNameWithArgs(
      const std::string &type, const std::string &line, const std::string &delim, std::string::size_type &index,
      std::string &name, ArgList &args
  ) const;
  IPlatformComputer::KeyInfo *parseKeystroke(const std::string &keystroke) const;
  IPlatformComputer::KeyInfo *
  parseKeystroke(const std::string &keystroke, const std::set<std::string> &computers) const;
  IPlatformComputer::ButtonInfo parseMouse(const std::string &mouse) const;
  KeyModifierMask parseModifier(const std::string &modifiers) const;
  std::istream &getStream() const
  {
    return m_stream;
  };
 
private:
  // not implemented
  ConfigReadContext &operator=(const ConfigReadContext &);
 
  static std::string concatArgs(const ArgList &args);
 
private:
  std::istream &m_stream;
  int32_t m_line;
};


class ServerConfigReadException : public BaseException
{
public:
  ServerConfigReadException(const ConfigReadContext &context, const std::string &);
  ServerConfigReadException(const ConfigReadContext &context, const char *errorFmt, const std::string &arg);
  ~ServerConfigReadException() throw() override = default;
 
protected:
  // BaseException overrides
  QString getWhat() const throw() override;
 
private:
  std::string m_error;
};
 
} // namespace deskflow::server