transport_io.h

 
#ifndef FREERDP_TRANSPORT_IO_H
#define FREERDP_TRANSPORT_IO_H
 
#include <winpr/stream.h>
 
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/settings.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef int (*pTransportLayerRead)(void* userContext, void* data, int bytes);
 
  typedef int (*pTransportLayerWrite)(void* userContext, const void* data, int bytes);
  typedef BOOL (*pTransportLayerFkt)(void* userContext);
  typedef BOOL (*pTransportLayerWait)(void* userContext, BOOL waitWrite, DWORD timeout);
  typedef HANDLE (*pTransportLayerGetEvent)(void* userContext);
 
  typedef struct
  {
    ALIGN64 void* userContext;
    WINPR_ATTR_NODISCARD ALIGN64 pTransportLayerRead Read;
    WINPR_ATTR_NODISCARD ALIGN64 pTransportLayerWrite Write;
    ALIGN64 pTransportLayerFkt Close;
    WINPR_ATTR_NODISCARD ALIGN64 pTransportLayerWait Wait;
    WINPR_ATTR_NODISCARD ALIGN64 pTransportLayerGetEvent GetEvent;
    UINT64 reserved[64 - 6]; /* Reserve some space for ABI compatibility */
  } rdpTransportLayer;
 
  typedef int (*pTCPConnect)(rdpContext* context, rdpSettings* settings, const char* hostname,
                             int port, DWORD timeout);
  typedef BOOL (*pTransportFkt)(rdpTransport* transport);
  typedef BOOL (*pTransportAttach)(rdpTransport* transport, int sockfd);
  typedef int (*pTransportRWFkt)(rdpTransport* transport, wStream* s);
  typedef SSIZE_T (*pTransportRead)(rdpTransport* transport, BYTE* data, size_t bytes);
  typedef BOOL (*pTransportGetPublicKey)(rdpTransport* transport, const BYTE** data,
                                         DWORD* length);
  typedef BOOL (*pTransportSetBlockingMode)(rdpTransport* transport, BOOL blocking);
  typedef rdpTransportLayer* (*pTransportConnectLayer)(rdpTransport* transport,
                                                       const char* hostname, int port,
                                                       DWORD timeout);
 
  typedef BOOL (*pTransportAttachLayer)(rdpTransport* transport, rdpTransportLayer* layer);
 
  struct rdp_transport_io
  {
    WINPR_ATTR_NODISCARD pTCPConnect TCPConnect;
    WINPR_ATTR_NODISCARD pTransportFkt TLSConnect;
    WINPR_ATTR_NODISCARD pTransportFkt TLSAccept;
    WINPR_ATTR_NODISCARD pTransportAttach TransportAttach;
    WINPR_ATTR_NODISCARD pTransportFkt TransportDisconnect;
    WINPR_ATTR_NODISCARD pTransportRWFkt ReadPdu;  /* Reads a whole PDU from the transport */
    WINPR_ATTR_NODISCARD pTransportRWFkt WritePdu; /* Writes a whole PDU to the transport */
    WINPR_ATTR_NODISCARD pTransportRead ReadBytes; /* Reads up to a requested amount of bytes */
    WINPR_ATTR_NODISCARD pTransportGetPublicKey GetPublicKey;       
    WINPR_ATTR_NODISCARD pTransportSetBlockingMode SetBlockingMode; 
    WINPR_ATTR_NODISCARD pTransportConnectLayer ConnectLayer;       
    WINPR_ATTR_NODISCARD pTransportAttachLayer AttachLayer;         
    UINT64 reserved[64 - 12];                  /* Reserve some space for ABI compatibility */
  };
  typedef struct rdp_transport_io rdpTransportIo;
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_io_callback_set_event(rdpContext* context, BOOL set);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const rdpTransportIo* freerdp_get_io_callbacks(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_set_io_callbacks(rdpContext* context,
                                            const rdpTransportIo* io_callbacks);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_set_io_callback_context(rdpContext* context, void* usercontext);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API void* freerdp_get_io_callback_context(rdpContext* context);
 
  /* PDU parser.
   * incomplete: FALSE if the whole PDU is available, TRUE otherwise
   * Return: 0  -> PDU header incomplete
   *         >0 -> PDU header complete, length of PDU.
   *         <0 -> Abort, an error occurred
   */
  WINPR_ATTR_NODISCARD
  FREERDP_API SSIZE_T transport_parse_pdu(rdpTransport* transport, wStream* s, BOOL* incomplete);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API rdpContext* transport_get_context(rdpTransport* transport);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API rdpTransport* freerdp_get_transport(rdpContext* context);
 
  FREERDP_API void transport_layer_free(rdpTransportLayer* layer);
 
  WINPR_ATTR_MALLOC(transport_layer_free, 1)
  WINPR_ATTR_NODISCARD
  FREERDP_API rdpTransportLayer* transport_layer_new(rdpTransport* transport, size_t contextSize);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREERDP_TRANSPORT_IO_H */