[client/idd] network: add clipboard and bulk transfer

client/transports/Network/CMakeLists.txt

@@ -7,6 +7,7 @@ endif()
 
 set(TRANSPORT_NETWORK_SOURCES
   audio.c
+  clipboard.c
   connection.c
   control.c
   cursor.c

client/transports/Network/clipboard.h

@@ -0,0 +1,48 @@
+/**
+ * Looking Glass
+ * Copyright © 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#pragma once
+
+#include "connection.h"
+
+#include "interface/clipboard.h"
+
+#include <LGProtocol/NetworkProtocol.h>
+
+#include <stdbool.h>
+
+typedef struct NetworkClipboard NetworkClipboard;
+
+bool networkClipboardCreate(NetworkClipboard ** clipboard,
+    NetworkConnection * connection);
+void networkClipboardDestroy(NetworkClipboard ** clipboard);
+
+void networkClipboardConnectionState(NetworkClipboard * clipboard,
+    bool connected);
+void networkClipboardConnect(NetworkClipboard * clipboard);
+void networkClipboardDisconnect(NetworkClipboard * clipboard);
+void networkClipboardProcess(NetworkClipboard * clipboard);
+void networkClipboardSendReady(NetworkClipboard * clipboard,
+    LGNetService service, NetworkPacketDelivery delivery);
+
+bool networkClipboardPacket(NetworkClipboard * clipboard,
+    const LGNetPacketView * packet, NetworkPacketDelivery delivery);
+
+const LG_ClipboardOps * networkClipboardGetOps(void);

client/transports/Network/connection.h

@@ -31,6 +31,14 @@
 
 typedef struct NetworkConnection NetworkConnection;
 
+typedef enum NetworkPacketDelivery
+{
+  NETWORK_PACKET_DELIVERY_RELIABLE,
+  NETWORK_PACKET_DELIVERY_DATAGRAM,
+  NETWORK_PACKET_DELIVERY_BULK,
+}
+NetworkPacketDelivery;
+
 typedef void (*NetworkTrustDecisionFn)(void * opaque, bool trusted);
 typedef bool (*NetworkTrustPromptFn)(void * opaque, const char * endpoint,
     const char * fingerprint, NetworkTrustDecisionFn decision,
@@ -38,11 +46,11 @@ typedef bool (*NetworkTrustPromptFn)(void * opaque, const char * endpoint,
 typedef void (*NetworkTrustCancelFn)(void * opaque);
 /* The packet view and payload are borrowed for the duration of the callback. */
 typedef void (*NetworkPacketFn)(void * opaque,
-    const LGNetPacketView * packet, bool datagram);
+    const LGNetPacketView * packet, NetworkPacketDelivery delivery);
 typedef void (*NetworkConnectionStateFn)(void * opaque, bool connected,
     LG_TransportStatus reason);
 typedef void (*NetworkSendReadyFn)(void * opaque, LGNetService service,
-    bool datagram);
+    NetworkPacketDelivery delivery);
 
 typedef struct NetworkConnectionParams
 {
@@ -85,3 +93,7 @@ LG_TransportStatus networkConnectionSendDatagram(
     uint16_t messageType, uint16_t serviceVersion,
     LGNetEnvelopeFlags flags, uint64_t componentEpoch, uint64_t requestID,
     const void * payload, uint32_t payloadLength, bool discardIfBlocked);
+LG_TransportStatus networkConnectionSendBulk(NetworkConnection * connection,
+    LGNetService service, uint16_t messageType, uint16_t serviceVersion,
+    LGNetEnvelopeFlags flags, uint64_t componentEpoch, uint64_t requestID,
+    const void * payload, uint32_t payloadLength);

client/transports/Network/network.c

@@ -20,6 +20,7 @@
 
 #include "network.h"
 #include "audio.h"
+#include "clipboard.h"
 #include "connection.h"
 #include "control.h"
 #include "cursor.h"
@@ -43,13 +44,18 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define NETWORK_ADDRESS_MAX        255U
-#define NETWORK_ENDPOINT_TEXT_SIZE (NETWORK_ADDRESS_MAX + 9U)
-#define NETWORK_MAX_PAYLOAD        \
+#define NETWORK_ADDRESS_MAX           255U
+#define NETWORK_ENDPOINT_TEXT_SIZE    (NETWORK_ADDRESS_MAX + 9U)
+#define NETWORK_MAX_PAYLOAD           \
   (LG_NET_CURSOR_SHAPE_HEADER_WIRE_SIZE + LG_NET_CURSOR_MAX_SHAPE_LENGTH)
-#define NETWORK_MAX_DATAGRAM       1136U
-#define NETWORK_AUDIO_MAX_PAYLOAD  \
+#define NETWORK_MAX_DATAGRAM          1136U
+#define NETWORK_AUDIO_MAX_PAYLOAD     \
   (LG_NET_AUDIO_DATA_HEADER_WIRE_SIZE + 65536U)
+#define NETWORK_TRANSFER_CHUNK        (256U * 1024U)
+#define NETWORK_CLIPBOARD_MAX_PAYLOAD \
+  (LG_NET_CLIPBOARD_CHUNK_HEADER_WIRE_SIZE + NETWORK_TRANSFER_CHUNK)
+#define NETWORK_FILE_MAX_PAYLOAD      \
+  (LG_NET_FILE_CHUNK_HEADER_WIRE_SIZE + NETWORK_TRANSFER_CHUNK)
 
 static const LGNetCapability NETWORK_CAPABILITIES[] =
 {
@@ -101,6 +107,30 @@ static const LGNetCapability NETWORK_CAPABILITIES[] =
     .maxBidirectionalStreams  = 0,
     .maxUnidirectionalStreams = 0,
   },
+  {
+    .service                  = LG_NET_SERVICE_CLIPBOARD,
+    .versionMin               = LG_NET_CLIPBOARD_VERSION_MIN,
+    .versionMax               = LG_NET_CLIPBOARD_VERSION_CURRENT,
+    .flags                    = LG_NET_CAPABILITY_RELIABLE |
+      LG_NET_CAPABILITY_BULK,
+    .features                 = 0,
+    .maxPayloadLength         = NETWORK_CLIPBOARD_MAX_PAYLOAD,
+    .maxDatagramPayload       = 0,
+    .maxBidirectionalStreams  = 0,
+    .maxUnidirectionalStreams = 1,
+  },
+  {
+    .service                  = LG_NET_SERVICE_FILE,
+    .versionMin               = LG_NET_FILE_VERSION_MIN,
+    .versionMax               = LG_NET_FILE_VERSION_CURRENT,
+    .flags                    = LG_NET_CAPABILITY_RELIABLE |
+      LG_NET_CAPABILITY_BULK,
+    .features                 = 0,
+    .maxPayloadLength         = NETWORK_FILE_MAX_PAYLOAD,
+    .maxDatagramPayload       = 0,
+    .maxBidirectionalStreams  = 0,
+    .maxUnidirectionalStreams = 1,
+  },
   {
     .service                  = LG_NET_SERVICE_CONTROL,
     .versionMin               = LG_NET_CONTROL_VERSION_MIN,
@@ -125,6 +155,7 @@ struct LG_Transport
 {
   NetworkConnection * connection;
   NetworkAudio      * audio;
+  NetworkClipboard  * clipboard;
   NetworkControl    * control;
   NetworkCursor     * cursor;
   NetworkInput      * input;
@@ -341,6 +372,7 @@ static void networkConnectionState(void * opaque, bool connected,
 
   networkInputConnectionState(this->input, connected);
   networkAudioConnectionState(this->audio, connected);
+  networkClipboardConnectionState(this->clipboard, connected);
   networkControlConnectionState(this->control, connected);
   networkRecoveryConnectionState(this->recovery, connected);
   const bool cursorAvailable =
@@ -359,28 +391,39 @@ static void networkConnectionState(void * opaque, bool connected,
 }
 
 static void networkPacket(void * opaque, const LGNetPacketView * packet,
-    bool datagram)
+    NetworkPacketDelivery delivery)
 {
-  LG_Transport * this = opaque;
-  bool valid;
+  LG_Transport * this     = opaque;
+  const bool     datagram =
+    delivery == NETWORK_PACKET_DELIVERY_DATAGRAM;
+  bool           valid;
   switch (packet->envelope.service)
   {
     case LG_NET_SERVICE_RECOVERY:
-      valid = networkRecoveryPacket(this->recovery, packet, datagram);
+      valid = delivery != NETWORK_PACKET_DELIVERY_BULK &&
+        networkRecoveryPacket(this->recovery, packet, datagram);
       break;
     case LG_NET_SERVICE_CURSOR:
-      valid = networkCursorPacket(this->cursor, packet, datagram);
+      valid = delivery != NETWORK_PACKET_DELIVERY_BULK &&
+        networkCursorPacket(this->cursor, packet, datagram);
       break;
     case LG_NET_SERVICE_INPUT:
-      valid = networkInputPacket(this->input, packet, datagram);
+      valid = delivery != NETWORK_PACKET_DELIVERY_BULK &&
+        networkInputPacket(this->input, packet, datagram);
       break;
     case LG_NET_SERVICE_AUDIO:
-      valid = datagram ?
-        networkAudioDatagram(this->audio, packet) :
-        networkAudioPacket(this->audio, packet);
+      valid = delivery != NETWORK_PACKET_DELIVERY_BULK &&
+        (datagram ? networkAudioDatagram(this->audio, packet) :
+          networkAudioPacket(this->audio, packet));
+      break;
+    case LG_NET_SERVICE_CLIPBOARD:
+    case LG_NET_SERVICE_FILE:
+      valid = delivery != NETWORK_PACKET_DELIVERY_DATAGRAM &&
+        networkClipboardPacket(this->clipboard, packet, delivery);
       break;
     case LG_NET_SERVICE_CONTROL:
-      valid = networkControlPacket(this->control, packet, datagram);
+      valid = delivery != NETWORK_PACKET_DELIVERY_BULK &&
+        networkControlPacket(this->control, packet, datagram);
       break;
     default:
       valid = false;
@@ -397,11 +440,17 @@ static void networkPacket(void * opaque, const LGNetPacketView * packet,
 }
 
 static void networkSendReady(void * opaque, LGNetService service,
-    bool datagram)
+    NetworkPacketDelivery delivery)
 {
-  LG_Transport * this = opaque;
-  if (service == LG_NET_SERVICE_AUDIO)
+  LG_Transport * this     = opaque;
+  const bool     datagram =
+    delivery == NETWORK_PACKET_DELIVERY_DATAGRAM;
+  if (service == LG_NET_SERVICE_AUDIO &&
+      delivery != NETWORK_PACKET_DELIVERY_BULK)
     networkAudioSendReady(this->audio, datagram);
+  if ((service == LG_NET_SERVICE_CLIPBOARD ||
+      service == LG_NET_SERVICE_FILE) && !datagram)
+    networkClipboardSendReady(this->clipboard, service, delivery);
   lgSignalEvent(this->frameEvent);
 }
 
@@ -463,6 +512,7 @@ static bool networkCreate(LG_Transport ** result)
   if (!networkConnectionCreate(&this->connection, &params))
     goto fail;
   if (!networkAudioCreate(&this->audio, this->connection) ||
+      !networkClipboardCreate(&this->clipboard, this->connection) ||
       !networkControlCreate(&this->control, this->connection) ||
       !networkCursorCreate(&this->cursor, this->connection) ||
       !networkInputCreate(&this->input, this->connection) ||
@@ -477,6 +527,7 @@ fail:
   networkInputDestroy(&this->input);
   networkCursorDestroy(&this->cursor);
   networkControlDestroy(&this->control);
+  networkClipboardDestroy(&this->clipboard);
   networkAudioDestroy(&this->audio);
   networkConnectionDestroy(&this->connection);
   if (this->frameEvent)
@@ -512,6 +563,7 @@ static void networkDestroy(LG_Transport ** transport)
   networkInputDestroy(&this->input);
   networkCursorDestroy(&this->cursor);
   networkControlDestroy(&this->control);
+  networkClipboardDestroy(&this->clipboard);
   networkAudioDestroy(&this->audio);
   networkConnectionDestroy(&this->connection);
   lgFreeEvent(this->frameEvent);
@@ -542,6 +594,7 @@ static void networkDisconnect(LG_Transport * this)
 {
   networkInputConnectionState(this->input, false);
   networkAudioConnectionState(this->audio, false);
+  networkClipboardConnectionState(this->clipboard, false);
   networkControlConnectionState(this->control, false);
   networkRecoveryConnectionState(this->recovery, false);
   networkCursorConnectionState(this->cursor, false);
@@ -728,9 +781,14 @@ static const LG_AudioOps * networkGetAudioOps(LG_Transport * this,
 static const LG_ClipboardOps * networkGetClipboardOps(LG_Transport * this,
     void ** opaque)
 {
-  (void)this;
   *opaque = NULL;
-  return NULL;
+  if (!networkConnectionServiceAvailable(this->connection,
+        LG_NET_SERVICE_CLIPBOARD, LG_NET_CAPABILITY_RELIABLE) ||
+      !networkConnectionServiceAvailable(this->connection,
+        LG_NET_SERVICE_FILE, LG_NET_CAPABILITY_RELIABLE))
+    return NULL;
+  *opaque = this->clipboard;
+  return networkClipboardGetOps();
 }
 
 static LG_TransportStatus networkSendControl(LG_Transport * this,

idd/LGIdd/LGIdd.vcxproj

@@ -89,6 +89,7 @@
     <ClCompile Include="transport\lgmp\CLGMPInputTransport.cpp" />
     <ClCompile Include="transport\lgmp\CLGMPTransport.cpp" />
     <ClCompile Include="transport\network\CNetworkAudio.cpp" />
+    <ClCompile Include="transport\network\CNetworkClipboard.cpp" />
     <ClCompile Include="transport\network\CNetworkServer.cpp" />
     <ClCompile Include="transport\network\CNetworkSession.cpp" />
     <ClCompile Include="transport\network\CNetworkTransport.cpp" />
@@ -175,6 +176,7 @@
     <ClInclude Include="transport\lgmp\CLGMPInputTransport.h" />
     <ClInclude Include="transport\lgmp\CLGMPTransport.h" />
     <ClInclude Include="transport\network\CNetworkAudio.h" />
+    <ClInclude Include="transport\network\CNetworkClipboard.h" />
     <ClInclude Include="transport\network\CNetworkServer.h" />
     <ClInclude Include="transport\network\CNetworkSession.h" />
     <ClInclude Include="transport\network\CNetworkTransport.h" />

idd/LGIdd/LGIdd.vcxproj.filters

@@ -289,6 +289,9 @@
     <ClInclude Include="transport\network\CNetworkAudio.h">
       <Filter>Transport\Network</Filter>
     </ClInclude>
+    <ClInclude Include="transport\network\CNetworkClipboard.h">
+      <Filter>Transport\Network</Filter>
+    </ClInclude>
     <ClInclude Include="transport\network\CNetworkServer.h">
       <Filter>Transport\Network</Filter>
     </ClInclude>
@@ -483,6 +486,9 @@
     <ClCompile Include="transport\network\CNetworkAudio.cpp">
       <Filter>Transport\Network</Filter>
     </ClCompile>
+    <ClCompile Include="transport\network\CNetworkClipboard.cpp">
+      <Filter>Transport\Network</Filter>
+    </ClCompile>
     <ClCompile Include="transport\network\CNetworkServer.cpp">
       <Filter>Transport\Network</Filter>
     </ClCompile>

idd/LGIdd/transport/network/CNetworkClipboard.h

@@ -0,0 +1,105 @@
+/**
+ * Looking Glass
+ * Copyright © 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#pragma once
+
+#include "transport/IClipboardSource.h"
+
+#include <LGProtocol/NetworkProtocol.h>
+
+#include <memory>
+#include <stdint.h>
+
+struct NetworkClipboardPeer
+{
+  uint32_t client     = 0;
+  uint32_t generation = 0;
+};
+
+struct NetworkClipboardPeerInfo
+{
+  uint16_t             clipboardVersion         = 0;
+  uint16_t             fileVersion              = 0;
+  LGNetCapabilityFlags clipboardFlags           = 0;
+  LGNetCapabilityFlags fileFlags                = 0;
+  uint32_t             clipboardReliablePayload = 0;
+  uint32_t             clipboardBulkPayload     = 0;
+  uint32_t             fileReliablePayload      = 0;
+  uint32_t             fileBulkPayload          = 0;
+};
+
+enum class NetworkClipboardSendResult
+{
+  ACCEPTED,
+  BLOCKED,
+  FAILED,
+};
+
+enum class NetworkClipboardPacketResult
+{
+  HANDLED,
+  IGNORED,
+  INVALID,
+};
+
+class INetworkClipboardSender
+{
+public:
+  virtual ~INetworkClipboardSender() = default;
+
+  virtual bool ClipboardPeerInfo(
+    const NetworkClipboardPeer& peer, NetworkClipboardPeerInfo& info) = 0;
+  virtual NetworkClipboardSendResult SendClipboard(
+    const NetworkClipboardPeer& peer, bool bulk, LGNetService service,
+    uint16_t messageType, LGNetEnvelopeFlags flags, uint64_t componentEpoch,
+    uint64_t requestID, const void * payload, uint32_t payloadLength) = 0;
+};
+
+class CNetworkClipboard final : public IClipboardSource
+{
+private:
+  struct Impl;
+  std::unique_ptr<Impl> m_impl;
+
+public:
+  CNetworkClipboard();
+  ~CNetworkClipboard() override;
+
+  CNetworkClipboard(const CNetworkClipboard&)            = delete;
+  CNetworkClipboard& operator=(const CNetworkClipboard&) = delete;
+
+  bool AttachSender(INetworkClipboardSender& sender);
+  void DetachSender();
+
+  bool PeerConnected(const NetworkClipboardPeer& peer);
+  void PeerDisconnected(const NetworkClipboardPeer& peer);
+  NetworkClipboardPacketResult HandlePacket(
+    const NetworkClipboardPeer& peer, const LGNetPacketView& packet, bool bulk);
+  void Process(uint64_t nowMs);
+  void SendReady(
+    const NetworkClipboardPeer& peer, LGNetService service, bool bulk);
+
+  bool Start(IClipboardTarget& target) override;
+  void Stop() override;
+  void ClipboardState(bool available, uint32_t generation) override;
+  ClipboardChannelResult SendClipboard(
+    const KVMFRClipboardMessage& record, const uint8_t * data) override;
+  void ClipboardReset(uint32_t generation, uint32_t reason) override;
+};

idd/LGIdd/transport/network/CNetworkServer.h

@@ -21,13 +21,16 @@
 #pragma once
 
 #include "transport/network/CNetworkAudio.h"
+#include "transport/network/CNetworkClipboard.h"
 
 #include <memory>
 
 class CNetworkTransport;
 struct NetworkSettings;
 
-class CNetworkServer final : public INetworkAudioSender
+class CNetworkServer final :
+  public INetworkAudioSender,
+  public INetworkClipboardSender
 {
 private:
   struct Impl;
@@ -35,7 +38,7 @@ private:
 
 public:
   CNetworkServer(CNetworkTransport& transport, CNetworkAudio& audio,
-    const NetworkSettings& settings);
+    CNetworkClipboard& clipboard, const NetworkSettings& settings);
   ~CNetworkServer();
 
   CNetworkServer(const CNetworkServer&) = delete;
@@ -52,4 +55,12 @@ public:
     uint16_t messageType, LGNetEnvelopeFlags flags,
     uint64_t componentEpoch, uint64_t requestID,
     const void * payload, uint32_t payloadLength) override;
+
+  bool ClipboardPeerInfo(const NetworkClipboardPeer& peer,
+    NetworkClipboardPeerInfo& info) override;
+  NetworkClipboardSendResult SendClipboard(
+    const NetworkClipboardPeer& peer, bool bulk, LGNetService service,
+    uint16_t messageType, LGNetEnvelopeFlags flags,
+    uint64_t componentEpoch, uint64_t requestID,
+    const void * payload, uint32_t payloadLength) override;
 };

idd/LGIdd/transport/network/CNetworkTransport.cpp

@@ -76,7 +76,8 @@ bool CNetworkTransport::Initialize()
 
   try
   {
-    m_server.reset(new CNetworkServer(*this, m_audio, m_settings));
+    m_server.reset(
+      new CNetworkServer(*this, m_audio, m_clipboard, m_settings));
   }
   catch (...)
   {
@@ -89,6 +90,13 @@ bool CNetworkTransport::Initialize()
     m_server.reset();
     return false;
   }
+  if (!m_clipboard.AttachSender(*m_server))
+  {
+    DEBUG_ERROR("Failed to attach the network clipboard sender");
+    m_audio.DetachSender();
+    m_server.reset();
+    return false;
+  }
 
   m_state = State::INITIALIZED;
   if (m_config.services & TRANSPORT_SERVICE_FRAME)
@@ -163,6 +171,7 @@ void CNetworkTransport::Stop()
 
   if (server)
     server->Stop();
+  m_clipboard.DetachSender();
   m_audio.DetachSender();
 
   std::vector<SessionPtr> sessions;
@@ -175,6 +184,7 @@ void CNetworkTransport::Stop()
 
   m_input.Stop();
   m_audio.Stop();
+  m_clipboard.Stop();
   m_control.SetControlEvents(nullptr, {});
   m_events.Reset();
 }
@@ -204,13 +214,13 @@ const FrameProfile * CNetworkTransport::Profiles(unsigned& count) const
 
 CfgResult CNetworkTransport::Probe(const FrameCfg& cfg) const
 {
-  UNREFERENCED_PARAMETER(cfg);
+  (void)cfg;
   return CfgResult::REJECTED;
 }
 
 CfgResult CNetworkTransport::Prepare(const FrameCfg& cfg)
 {
-  UNREFERENCED_PARAMETER(cfg);
+  (void)cfg;
   return CfgResult::REJECTED;
 }
 
@@ -237,6 +247,12 @@ IAudioSource * CNetworkTransport::Audio()
   return (m_config.services & TRANSPORT_SERVICE_AUDIO) ? &m_audio : nullptr;
 }
 
+IClipboardSource * CNetworkTransport::Clipboard()
+{
+  return (m_config.services & TRANSPORT_SERVICE_CLIPBOARD) ?
+    &m_clipboard : nullptr;
+}
+
 IControlSink * CNetworkTransport::Control()
 {
   return (m_config.services & TRANSPORT_SERVICE_CONTROL) ?

idd/LGIdd/transport/network/CNetworkTransport.h

@@ -23,6 +23,7 @@
 #include "CSRWLock.h"
 #include "transport/ITransport.h"
 #include "transport/network/CNetworkAudio.h"
+#include "transport/network/CNetworkClipboard.h"
 #include "transport/network/CNetworkSession.h"
 #include "transport/network/NetworkSettings.h"
 
@@ -51,6 +52,7 @@ private:
   TransportInstance               m_config;
   NetworkSettings                 m_settings;
   CNetworkAudio                   m_audio;
+  CNetworkClipboard               m_clipboard;
   std::unique_ptr<CNetworkServer> m_server;
 
   mutable CSRWLock  m_lifecycleLock;
@@ -92,6 +94,7 @@ public:
   std::shared_ptr<const FrameCaps> GetFrameCaps() const override;
   DirectFrameBufferMemory GetDirectMemory() const override;
   IAudioSource * Audio() override;
+  IClipboardSource * Clipboard() override;
   IControlSink * Control() override;
   IInputSource * Input() override;