Client.h

Go to the documentation of this file.

/*
 * Deskflow -- mouse and keyboard sharing utility
 * SPDX-FileCopyrightText: (C) 2025 - 2026 Deskflow Developers
 * SPDX-FileCopyrightText: (C) 2012 - 2016, 2026 Synergy App Ltd
 * SPDX-FileCopyrightText: (C) 2002 Chris Schoeneman
 * SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
 */
 
#pragma once
 
#include "deskflow/IClient.h"
 
#include "base/Event.h"
#include "base/EventTypes.h"
#include "common/Enums.h"
#include "deskflow/IClipboard.h"
#include "net/NetworkAddress.h"
 
#include <climits>
#include <string>
 
class Event;
class EventQueueTimer;
namespace deskflow {
class Computer;
}
class ServerProxy;
class IDataSocket;
class ISocketFactory;
namespace deskflow {
class IStream;
}
class IEventQueue;
class Thread;
class TCPSocket;


class Client : public IClient
{
public:
  class DisconnectRequest : public EventData
  {
  public:
    enum class Kind
    {
      Disconnect,
      Refuse
    };
 
    DisconnectRequest(Kind kind, const char *message);
    DisconnectRequest(deskflow::core::ConnectionRefusal reason, const char *message);
 
    Kind kind() const
    {
      return m_kind;
    }
 
    deskflow::core::ConnectionRefusal refusalReason() const
    {
      return m_refusalReason;
    }
 
    const char *message() const
    {
      return m_message.empty() ? nullptr : m_message.c_str();
    }
 
  private:
    Kind m_kind = Kind::Disconnect;
    deskflow::core::ConnectionRefusal m_refusalReason = deskflow::core::ConnectionRefusal::ProtocolError;
    std::string m_message;
  };
 
  class FailInfo
  {
  public:
    explicit FailInfo(const char *what) : m_what(what)
    {
      // do nothing
    }
    bool m_retry = false;
    QString m_what;
  };
 
public:
  Client(
      IEventQueue *events, const std::string &name, const NetworkAddress &address, ISocketFactory *socketFactory,
      deskflow::Computer *computer
  );
  Client(Client const &) = delete;
  Client(Client &&) = delete;
  ~Client() override;
 
  Client &operator=(Client const &) = delete;
  Client &operator=(Client &&) = delete;




  void connect(size_t addressIndex = 0);
  void setServerAddress(const NetworkAddress &address);


  void disconnect(const char *msg);


  void refuseConnection(deskflow::core::ConnectionRefusal reason, const char *msg);


  virtual void handshakeComplete();




  bool isConnected() const;


  bool isConnecting() const;


  NetworkAddress getServerAddress() const;

  size_t getLastResolvedAddressesCount() const
  {
    return m_resolvedAddressesCount;
  }
  size_t getMaximumClipboardReceiveSizeBytes() const;

 
  // IComputer overrides
  void *getEventTarget() const final;
  bool getClipboard(ClipboardID id, IClipboard *) const override;
  void getShape(int32_t &x, int32_t &y, int32_t &width, int32_t &height) const override;
  void getCursorPos(int32_t &x, int32_t &y) const override;
 
  // IClient overrides
  void enter(int32_t xAbs, int32_t yAbs, uint32_t seqNum, KeyModifierMask mask, bool forScreensaver) override;
  bool leave() override;
  void setClipboard(ClipboardID, const IClipboard *) override;
  void grabClipboard(ClipboardID) override;
  void setClipboardDirty(ClipboardID, bool) override;
  void keyDown(KeyID, KeyModifierMask, KeyButton, const std::string &) override;
  void keyRepeat(KeyID, KeyModifierMask, int32_t count, KeyButton, const std::string &lang) override;
  void keyUp(KeyID, KeyModifierMask, KeyButton) override;
  void mouseDown(ButtonID) override;
  void mouseUp(ButtonID) override;
  void mouseMove(int32_t xAbs, int32_t yAbs) override;
  void mouseRelativeMove(int32_t xRel, int32_t yRel) override;
  void mouseWheel(int32_t xDelta, int32_t yDelta) override;
  void screensaver(bool activate) override;
  void resetOptions() override;
  void setOptions(const OptionsList &options) override;
  std::string getName() const override;
 
private:
  void saveRelativeRestorePosition();
  void sendClipboard(ClipboardID);
  void sendEvent(deskflow::EventTypes);
  void sendConnectionFailedEvent(const char *msg);
  void setupConnecting();
  void setupConnection();
  bool setupComputer(int16_t protocolMinor);
  void setupTimer();
  void cleanup();
  void cleanupConnecting();
  void cleanupConnection();
  void cleanupComputer();
  void cleanupTimer();
  void cleanupStream();
  void handleConnected();
  void handleConnectionFailed(const Event &event);
  void handleConnectTimeout();
  void handleOutputError();
  void handleDisconnected();
  void handleDisconnectRequested(const Event &event);
  void handleShapeChanged();
  void handleClipboardGrabbed(const Event &event);
  void handleHello();
  void handleSuspend();
  void handleResume();
  void sendClipboardThread(void *);
  void bindNetworkInterface(IDataSocket *socket) const;
 
private:
  std::string m_name;
  NetworkAddress m_serverAddress;
  ISocketFactory *m_socketFactory = nullptr;
  deskflow::Computer *m_computer = nullptr;
  deskflow::IStream *m_stream = nullptr;
  EventQueueTimer *m_timer = nullptr;
  ServerProxy *m_server = nullptr;
  bool m_ready = false;
  bool m_active = false;
  bool m_suspended = false;
  bool m_connectOnResume = false;
  bool m_ownClipboard[kClipboardEnd];
  bool m_sentClipboard[kClipboardEnd];
  IClipboard::Time m_timeClipboard[kClipboardEnd];
  std::string m_dataClipboard[kClipboardEnd];
  IEventQueue *m_events = nullptr;
  bool m_useSecureNetwork = false;
  bool m_enableClipboard = true;
  bool m_relativeMouseMoves = false;
  bool m_hasRelativeRestorePosition = false;
  int32_t m_relativeRestoreX = 0;
  int32_t m_relativeRestoreY = 0;
  size_t m_maximumClipboardSize = INT_MAX;
  size_t m_resolvedAddressesCount = 0;
};