proxy_context.h

 
#ifndef FREERDP_SERVER_PROXY_PFCONTEXT_H
#define FREERDP_SERVER_PROXY_PFCONTEXT_H
 
#include <freerdp/api.h>
#include <freerdp/types.h>
 
#include <freerdp/freerdp.h>
#include <freerdp/channels/wtsvc.h>
 
#include <freerdp/server/proxy/proxy_config.h>
#include <freerdp/server/proxy/proxy_types.h>
 
#define PROXY_SESSION_ID_LENGTH 32
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef struct proxy_data proxyData;
  typedef struct proxy_module proxyModule;
  typedef struct p_server_static_channel_context pServerStaticChannelContext;
 
  typedef struct s_InterceptContextMapEntry
  {
    void (*free)(struct s_InterceptContextMapEntry*);
  } InterceptContextMapEntry;
 
  /* All proxy interception channels derive from this base struct
   * and set their cleanup function accordingly. */
  FREERDP_API void intercept_context_entry_free(void* obj);
 
  typedef PfChannelResult (*proxyChannelDataFn)(proxyData* pdata,
                                                const pServerStaticChannelContext* channel,
                                                const BYTE* xdata, size_t xsize, UINT32 flags,
                                                size_t totalSizepServer);
  typedef void (*proxyChannelContextDtor)(void* context);
 
  struct p_server_static_channel_context
  {
    char* channel_name;
    UINT32 front_channel_id;
    UINT32 back_channel_id;
    pf_utils_channel_mode channelMode;
    WINPR_ATTR_NODISCARD proxyChannelDataFn onFrontData;
    WINPR_ATTR_NODISCARD proxyChannelDataFn onBackData;
    proxyChannelContextDtor contextDtor;
    void* context;
  };
 
  FREERDP_API void StaticChannelContext_free(pServerStaticChannelContext* ctx);
 
  typedef struct p_server_context pServerContext;
 
  WINPR_ATTR_MALLOC(StaticChannelContext_free, 1)
  WINPR_ATTR_NODISCARD
  pServerStaticChannelContext* StaticChannelContext_new(pServerContext* ps, const char* name,
                                                        UINT32 id);
 
  typedef struct p_client_context pClientContext;
 
  struct proxy_data
  {
    proxyModule* module;
    const proxyConfig* config;
 
    rdpContext* ps; /* actual type is pServerContext */
    rdpContext* pc; /* actual type is pClientContext */
 
    HANDLE abort_event;
    HANDLE client_thread;
    HANDLE gfx_server_ready;
 
    char session_id[PROXY_SESSION_ID_LENGTH + 1];
 
    /* used to external modules to store per-session info */
    wHashTable* modules_info;
    psPeerReceiveChannelData server_receive_channel_data_original;
  };
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL pf_context_copy_settings(rdpSettings* dst, const rdpSettings* src);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL pf_context_init_server_context(freerdp_peer* client);
 
  WINPR_ATTR_MALLOC(freerdp_client_context_free, 1)
  FREERDP_API pClientContext* pf_context_create_client_context(const rdpSettings* clientSettings);
 
  FREERDP_API void proxy_data_free(proxyData* pdata);
 
  WINPR_ATTR_MALLOC(proxy_data_free, 1)
  FREERDP_API proxyData* proxy_data_new(void);
  FREERDP_API void proxy_data_set_client_context(proxyData* pdata, pClientContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API pClientContext* proxy_data_get_client_context(proxyData* pdata);
 
  FREERDP_API void proxy_data_set_server_context(proxyData* pdata, pServerContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API pServerContext* proxy_data_get_server_context(proxyData* pdata);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL proxy_data_shall_disconnect(proxyData* pdata);
  FREERDP_API void proxy_data_abort_connect(proxyData* pdata);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREERDP_SERVER_PROXY_PFCONTEXT_H */