rdpemt.h

 
#ifndef FREERDP_LIB_CORE_RDPEMT_H
#define FREERDP_LIB_CORE_RDPEMT_H
 
#include <winpr/wtypes.h>
#include <winpr/winsock.h>
#include <winpr/wlog.h>
#include <winpr/stream.h>
#include <winpr/collections.h>
 
#include <freerdp/config.h>
#include <freerdp/api.h>
 
typedef struct rdp_emt rdpEmt;
 
typedef enum
{
  RDPEMT_EVENT_READY,             
  RDPEMT_EVENT_FAILED,            
  RDPEMT_EVENT_DATA,              
  RDPEMT_EVENT_AUTODETECT_REQUEST 
} RDPEMT_EVENT;
 
typedef void (*rdpEmtEventFn)(void* custom, rdpEmt* emt, RDPEMT_EVENT event, const BYTE* data,
                              size_t length);
 
typedef BOOL (*rdpEmtReceiverFn)(void* custom, wStream* s);
 
#if defined(WITH_RDPEUDP)
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdpemt_is_supported(void);
 
FREERDP_LOCAL void rdpemt_free(rdpEmt* emt);
 
WINPR_ATTR_MALLOC(rdpemt_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_LOCAL rdpEmt* rdpemt_new(wLog* log, UINT32 requestId, const BYTE* cookie,
                                 const char* hostname, const BYTE* publicKey,
                                 size_t publicKeyLength, rdpEmtEventFn callback, void* custom);
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdpemt_start(rdpEmt* emt, const struct sockaddr* addr, size_t addrlen);
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdpemt_send_data(rdpEmt* emt, const BYTE* data, size_t length);
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdpemt_send_subheader(rdpEmt* emt, const BYTE* subHeader, size_t length);
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT32 rdpemt_get_request_id(const rdpEmt* emt);
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL BOOL rdpemt_set_receiver(rdpEmt* emt, rdpEmtReceiverFn receiver, void* custom,
                                       wQueue* pending);
 
FREERDP_LOCAL void rdpemt_clear_receiver(rdpEmt* emt);
 
WINPR_ATTR_NODISCARD
FREERDP_LOCAL UINT32 rdpemt_take_direct_bytes(rdpEmt* emt);
 
#else
 
/* Built without UDP multitransport: requests are declined and no tunnel ever exists. */
WINPR_ATTR_NODISCARD
static inline BOOL rdpemt_is_supported(void)
{
  return FALSE;
}
 
static inline void rdpemt_free(WINPR_ATTR_UNUSED rdpEmt* emt)
{
}
 
WINPR_ATTR_NODISCARD
static inline rdpEmt*
rdpemt_new(WINPR_ATTR_UNUSED wLog* log, WINPR_ATTR_UNUSED UINT32 requestId,
           WINPR_ATTR_UNUSED const BYTE* cookie, WINPR_ATTR_UNUSED const char* hostname,
           WINPR_ATTR_UNUSED const BYTE* publicKey, WINPR_ATTR_UNUSED size_t publicKeyLength,
           WINPR_ATTR_UNUSED rdpEmtEventFn callback, WINPR_ATTR_UNUSED void* custom)
{
  return nullptr;
}
 
WINPR_ATTR_NODISCARD
static inline BOOL rdpemt_start(WINPR_ATTR_UNUSED rdpEmt* emt,
                                WINPR_ATTR_UNUSED const struct sockaddr* addr,
                                WINPR_ATTR_UNUSED size_t addrlen)
{
  return FALSE;
}
 
WINPR_ATTR_NODISCARD
static inline BOOL rdpemt_send_data(WINPR_ATTR_UNUSED rdpEmt* emt,
                                    WINPR_ATTR_UNUSED const BYTE* data,
                                    WINPR_ATTR_UNUSED size_t length)
{
  return FALSE;
}
 
WINPR_ATTR_NODISCARD
static inline BOOL rdpemt_send_subheader(WINPR_ATTR_UNUSED rdpEmt* emt,
                                         WINPR_ATTR_UNUSED const BYTE* subHeader,
                                         WINPR_ATTR_UNUSED size_t length)
{
  return FALSE;
}
 
WINPR_ATTR_NODISCARD
static inline UINT32 rdpemt_get_request_id(WINPR_ATTR_UNUSED const rdpEmt* emt)
{
  return 0;
}
 
WINPR_ATTR_NODISCARD
static inline BOOL rdpemt_set_receiver(WINPR_ATTR_UNUSED rdpEmt* emt,
                                       WINPR_ATTR_UNUSED rdpEmtReceiverFn receiver,
                                       WINPR_ATTR_UNUSED void* custom,
                                       WINPR_ATTR_UNUSED wQueue* pending)
{
  return FALSE;
}
 
static inline void rdpemt_clear_receiver(WINPR_ATTR_UNUSED rdpEmt* emt)
{
}
 
#endif
 
#endif /* FREERDP_LIB_CORE_RDPEMT_H */