client/drdynvc_main.h

 
#ifndef FREERDP_CHANNEL_DRDYNVC_CLIENT_MAIN_H
#define FREERDP_CHANNEL_DRDYNVC_CLIENT_MAIN_H
 
#include <freerdp/config.h>
 
#include <winpr/wlog.h>
#include <winpr/synch.h>
#include <freerdp/settings.h>
#include <winpr/collections.h>
 
#include <freerdp/api.h>
#include <freerdp/svc.h>
#include <freerdp/dvc.h>
#include <freerdp/addin.h>
#include <freerdp/channels/log.h>
#include <freerdp/client/drdynvc.h>
#include <freerdp/codec/zgfx.h>
#include <freerdp/freerdp.h>
 
typedef struct drdynvc_plugin drdynvcPlugin;
 
typedef struct
{
  IWTSVirtualChannelManager iface;
 
  drdynvcPlugin* drdynvc;
 
  wArrayList* plugin_names;
  wArrayList* plugins;
 
  wHashTable* listeners;
  wHashTable* channelsById;
  wStreamPool* pool;
} DVCMAN;
 
typedef struct
{
  IWTSListener iface;
 
  DVCMAN* dvcman;
  char* channel_name;
  UINT32 flags;
  IWTSListenerCallback* listener_callback;
} DVCMAN_LISTENER;
 
typedef struct
{
  IDRDYNVC_ENTRY_POINTS iface;
 
  DVCMAN* dvcman;
  const ADDIN_ARGV* args;
  rdpContext* context;
} DVCMAN_ENTRY_POINTS;
 
typedef enum
{
  DVC_CHANNEL_INIT,
  DVC_CHANNEL_RUNNING,
  DVC_CHANNEL_CLOSED
} DVC_CHANNEL_STATE;
 
typedef struct
{
  uint64_t bytesIn;
  uint64_t bytesOut;
  uint64_t fragmentsIn;
  uint64_t fragmentsOut;
  uint64_t packetsIn;
  uint64_t packetsOut;
} DVCMAN_CHANNEL_STATS;
 
typedef struct
{
  IWTSVirtualChannel iface;
 
  volatile LONG refCounter;
  DVC_CHANNEL_STATE state;
  DVCMAN* dvcman;
  void* pInterface;
  UINT32 channel_id;
  char* channel_name;
  IWTSVirtualChannelCallback* channel_callback;
 
  wStream* dvc_data;
  UINT32 dvc_data_length;
  ZGFX_CONTEXT* decompressor;
  CRITICAL_SECTION lock;
  DVCMAN_CHANNEL_STATS stats;
 
  /* TUNNELTYPE_ the channel's data is written on, 0 for the drdynvc static channel. Guarded by
   * lock: a writer holds it for a whole message, so Soft-Sync cannot move the channel between
   * two fragments, nor while a message is still on its way out over TCP. */
  UINT32 tunnelType;
#if defined(WITH_RDPEUDP)
  /* The channel carries a static virtual channel's traffic, see dvcman_static_bridge_new. Its
   * data is passed on in the chunks it came in: bridgeFragmented is set from a DATA_FIRST PDU
   * until bridgeReceived reaches its length (dvc_data_length). */
  BOOL staticBridge;
  BOOL bridgeFragmented;
  UINT32 bridgeReceived;
#endif
} DVCMAN_CHANNEL;
 
typedef enum
{
  DRDYNVC_STATE_INITIAL,
  DRDYNVC_STATE_CAPABILITIES,
  DRDYNVC_STATE_READY,
  DRDYNVC_STATE_OPENING_CHANNEL,
  DRDYNVC_STATE_SEND_RECEIVE,
  DRDYNVC_STATE_FINAL
} DRDYNVC_STATE;
 
struct drdynvc_plugin
{
  CHANNEL_DEF channelDef;
  CHANNEL_ENTRY_POINTS_FREERDP_EX channelEntryPoints;
 
  wLog* log;
  HANDLE thread;
  BOOL async;
  wStream* data_in;
  void* InitHandle;
  DWORD OpenHandle;
  wMessageQueue* queue;
 
  DRDYNVC_STATE state;
  DrdynvcClientContext* context;
 
  UINT16 version;
  int PriorityCharge0;
  int PriorityCharge1;
  int PriorityCharge2;
  int PriorityCharge3;
  rdpContext* rdpcontext;
 
  IWTSVirtualChannelManager* channel_mgr;
  BOOL firstFlagReceived;
  UINT32 totalLength;
 
  /* Soft-Sync ([MS-RDPEDYC] 3.1.5.3) */
  BOOL softSyncDone;
  wStream* pendingSoftSync;
  wStream** tunnelBacklog;
  UINT32* tunnelBacklogTypes;
  size_t tunnelBacklogCount;
  size_t tunnelBacklogCapacity;
};
 
#endif /* FREERDP_CHANNEL_DRDYNVC_CLIENT_MAIN_H */