freerdp.h

 
#ifndef FREERDP_H
#define FREERDP_H
 
#include <winpr/stream.h>
#include <winpr/sspi.h>
 
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/error.h>
#include <freerdp/event.h>
 
#include <freerdp/settings.h>
 
#include <freerdp/gdi/gdi.h>
#include <freerdp/codecs.h>
#include <freerdp/metrics.h>
#include <freerdp/extension.h>
#include <freerdp/heartbeat.h>
#include <freerdp/message.h>
#include <freerdp/autodetect.h>
#include <freerdp/streamdump.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef struct rdp_rdp rdpRdp;
  typedef struct rdp_rail rdpRail;
  typedef struct rdp_cache rdpCache;
 
  typedef struct rdp_client_context rdpClientContext;
  typedef struct rdp_client_entry_points_v1 RDP_CLIENT_ENTRY_POINTS_V1;
  typedef RDP_CLIENT_ENTRY_POINTS_V1 RDP_CLIENT_ENTRY_POINTS;
 
#include <freerdp/utils/smartcardlogon.h>
#include <freerdp/update.h>
#include <freerdp/input.h>
#include <freerdp/graphics.h>
 
#define MCS_BASE_CHANNEL_ID 1001
#define MCS_GLOBAL_CHANNEL_ID 1003
 
/* Flags used by certificate callbacks */
#define VERIFY_CERT_FLAG_NONE 0x00
#define VERIFY_CERT_FLAG_LEGACY 0x02
#define VERIFY_CERT_FLAG_REDIRECT 0x10
#define VERIFY_CERT_FLAG_GATEWAY 0x20
#define VERIFY_CERT_FLAG_CHANGED 0x40
#define VERIFY_CERT_FLAG_MISMATCH 0x80
#define VERIFY_CERT_FLAG_MATCH_LEGACY_SHA1 0x100
#define VERIFY_CERT_FLAG_FP_IS_PEM 0x200
 
/* Message types used by gateway messaging callback */
#define GATEWAY_MESSAGE_CONSENT 1
#define GATEWAY_MESSAGE_SERVICE 2
 
  typedef enum
  {
    AUTH_NLA,
    AUTH_TLS,
    AUTH_RDP,
    GW_AUTH_HTTP,
    GW_AUTH_RDG,
    GW_AUTH_RPC,
    AUTH_SMARTCARD_PIN
  } rdp_auth_reason;
 
  typedef BOOL (*pContextNew)(freerdp* instance, rdpContext* context);
  typedef void (*pContextFree)(freerdp* instance, rdpContext* context);
 
  typedef BOOL (*pConnectCallback)(freerdp* instance);
  typedef void (*pPostDisconnect)(freerdp* instance);
 
  typedef BOOL (*pAuthenticate)(freerdp* instance, char** username, char** password,
                                char** domain);
 
  typedef BOOL (*pAuthenticateEx)(freerdp* instance, char** username, char** password,
                                  char** domain, rdp_auth_reason reason);
  typedef BOOL (*pChooseSmartcard)(freerdp* instance, SmartcardCertInfo** cert_list, DWORD count,
                                   DWORD* choice, BOOL gateway);
 
  typedef enum
  {
    ACCESS_TOKEN_TYPE_AAD, 
    ACCESS_TOKEN_TYPE_AVD  
  } AccessTokenType;
 
  typedef BOOL (*pGetAccessToken)(freerdp* instance, AccessTokenType tokenType, char** token,
                                  size_t count, ...);
 
  typedef SSIZE_T (*pRetryDialog)(freerdp* instance, const char* what, size_t current,
                                  void* userarg);
 
#if defined(WITH_FREERDP_DEPRECATED)
  typedef WINPR_DEPRECATED_VAR(
      "Use pVerifyCertificateEx",
      DWORD (*pVerifyCertificate)(freerdp* instance, const char* common_name, const char* subject,
                                  const char* issuer, const char* fingerprint,
                                  BOOL host_mismatch));
#endif
 
  typedef DWORD (*pVerifyCertificateEx)(freerdp* instance, const char* host, UINT16 port,
                                        const char* common_name, const char* subject,
                                        const char* issuer, const char* fingerprint, DWORD flags);
 
#if defined(WITH_FREERDP_DEPRECATED)
  typedef WINPR_DEPRECATED_VAR(
      "Use pVerifyChangedCertificateEx",
      DWORD (*pVerifyChangedCertificate)(freerdp* instance, const char* common_name,
                                         const char* subject, const char* issuer,
                                         const char* new_fingerprint, const char* old_subject,
                                         const char* old_issuer, const char* old_fingerprint));
#endif
 
  typedef DWORD (*pVerifyChangedCertificateEx)(freerdp* instance, const char* host, UINT16 port,
                                               const char* common_name, const char* subject,
                                               const char* issuer, const char* new_fingerprint,
                                               const char* old_subject, const char* old_issuer,
                                               const char* old_fingerprint, DWORD flags);
 
  typedef int (*pVerifyX509Certificate)(freerdp* instance, const BYTE* data, size_t length,
                                        const char* hostname, UINT16 port, DWORD flags);
 
  typedef int (*pLogonErrorInfo)(freerdp* instance, UINT32 data, UINT32 type);
 
  typedef BOOL (*pSendChannelData)(freerdp* instance, UINT16 channelId, const BYTE* data,
                                   size_t size);
  typedef BOOL (*pSendChannelPacket)(freerdp* instance, UINT16 channelId, size_t totalSize,
                                     UINT32 flags, const BYTE* data, size_t chunkSize);
  typedef BOOL (*pReceiveChannelData)(freerdp* instance, UINT16 channelId, const BYTE* data,
                                      size_t size, UINT32 flags, size_t totalSize);
 
  /* type can be one of the GATEWAY_MESSAGE_ type defines */
  typedef BOOL (*pPresentGatewayMessage)(freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
                                         BOOL isConsentMandatory, size_t length,
                                         const WCHAR* message);
 
  struct rdp_context
  {
    ALIGN64 freerdp* instance;  
    ALIGN64 freerdp_peer* peer; 
    ALIGN64 BOOL ServerMode;    
    ALIGN64 UINT32 LastError; /* 3 */
 
    UINT64 paddingA[16 - 4]; /* 4 */
 
    ALIGN64 int argc;    
    ALIGN64 char** argv; 
    ALIGN64 wPubSub* pubSub; /* (offset 18) */
 
    ALIGN64 HANDLE channelErrorEvent; /* (offset 19)*/
    ALIGN64 UINT channelErrorNum;     /*(offset 20)*/
    ALIGN64 char* errorDescription;   /*(offset 21)*/
 
    UINT64 paddingB[32 - 22]; /* 22 */
 
    ALIGN64 rdpRdp*
        rdp;                           
    ALIGN64 rdpGdi* gdi;               
    ALIGN64 rdpRail* rail;             /* 34 */
    ALIGN64 rdpCache* cache;           /* 35 */
    ALIGN64 rdpChannels* channels;     /* 36 */
    ALIGN64 rdpGraphics* graphics;     /* 37 */
    ALIGN64 rdpInput* input;           /* 38 owned by rdpRdp */
    ALIGN64 rdpUpdate* update;         /* 39 owned by rdpRdp */
    ALIGN64 rdpSettings* settings;     /* 40 owned by rdpRdp */
    ALIGN64 rdpMetrics* metrics;       /* 41 */
    ALIGN64 rdpCodecs* codecs;         /* 42 */
    ALIGN64 rdpAutoDetect* autodetect; /* 43 owned by rdpRdp */
    UINT64 paddingC1[45 - 44];         /* 44 */
    ALIGN64 int disconnectUltimatum;   /* 45 */
    UINT64 paddingC[64 - 46];          /* 46 */
 
    ALIGN64 rdpStreamDumpContext* dump; /* 64 */
    ALIGN64 wLog* log;                  /* 65 */
 
    UINT64 paddingD[96 - 66];  /* 66 */
    UINT64 paddingE[128 - 96]; /* 96 */
  };
 
  enum Disconnect_Ultimatum
  {
    Disconnect_Ultimatum_domain_disconnected = 0,
    Disconnect_Ultimatum_provider_initiated = 1,
    Disconnect_Ultimatum_token_purged = 2,
    Disconnect_Ultimatum_user_requested = 3,
    Disconnect_Ultimatum_channel_purged = 4
  };
 
#include <freerdp/client.h>
 
  struct rdp_freerdp
  {
    ALIGN64
    rdpContext* context; 
    ALIGN64 RDP_CLIENT_ENTRY_POINTS* pClientEntryPoints;
 
    UINT64 paddingA[16 - 2]; /* 2 */
 
#if defined(WITH_FREERDP_DEPRECATED)
    WINPR_DEPRECATED_VAR("use rdpContext::input instead", ALIGN64 rdpInput* input;) /* (offset
                            16) Input handle for the connection. Will be initialized by a call
                            to freerdp_context_new() owned by rdpRdp */
    WINPR_DEPRECATED_VAR("use rdpContext::update instead",
                         ALIGN64 rdpUpdate* update;) /* (offset 17)
                          Update display parameters. Used to register display events callbacks
and settings.    Will be initialized by a call to freerdp_context_new()    owned by rdpRdp */
    WINPR_DEPRECATED_VAR("use rdpContext::settings instead",
                         ALIGN64 rdpSettings* settings;) 
    WINPR_DEPRECATED_VAR("use rdpContext::autodetect instead",
                         ALIGN64 rdpAutoDetect* autodetect;) /* (offset 19)
                                    Auto-Detect handle for the connection.
                                    Will be initialized by a call to freerdp_context_new()
owned by rdpRdp */
#else
  UINT64 paddingX[4];
#endif
    ALIGN64 rdpHeartbeat* heartbeat; /* (offset 21) owned by rdpRdp*/
 
    UINT64 paddingB[32 - 21]; /* 21 */
 
    ALIGN64 size_t
        ContextSize; /* (offset 32)
                 Specifies the size of the 'context' field. freerdp_context_new() will use this
                 size to allocate the context buffer. freerdp_new() sets it to
                 sizeof(rdpContext). If modifying it, there should always be a minimum of
                 sizeof(rdpContext), as the freerdp library will assume it can use the 'context'
                 field to set the required informations in it. Clients will typically make it
                 bigger, and use a context structure embedding the rdpContext, and adding
                 additional information after that.
              */
 
    ALIGN64 pContextNew
        ContextNew; 
    ALIGN64 pContextFree
        ContextFree;          
    UINT64 paddingC[47 - 35]; /* 35 */
 
    ALIGN64 UINT ConnectionCallbackState; /* 47 */
 
    ALIGN64 pConnectCallback
        PreConnect; 
    ALIGN64 pConnectCallback
        PostConnect; 
    ALIGN64 pAuthenticate Authenticate; 
#if defined(WITH_FREERDP_DEPRECATED)
    WINPR_DEPRECATED_VAR("Use VerifyCertificateEx or VerifyX509Certificate  instead",
                         ALIGN64 pVerifyCertificate VerifyCertificate;) 
    WINPR_DEPRECATED_VAR("Use VerifyChangedCertificateEx or VerifyX509Certificate  instead",
                         ALIGN64 pVerifyChangedCertificate
                             VerifyChangedCertificate;) 
#else
  ALIGN64 UINT64 reserved[2];
#endif
    ALIGN64 pVerifyX509Certificate
        VerifyX509Certificate; 
    ALIGN64 pLogonErrorInfo
        LogonErrorInfo; 
    ALIGN64 pPostDisconnect
        PostDisconnect; 
    ALIGN64 pAuthenticate GatewayAuthenticate; 
    ALIGN64 pPresentGatewayMessage PresentGatewayMessage; 
    ALIGN64 pConnectCallback Redirect; 
    ALIGN64 pConnectCallback
        LoadChannels; 
    ALIGN64 pPostDisconnect
        PostFinalDisconnect;  
    UINT64 paddingD[64 - 61]; /* 61 */
 
    ALIGN64 pSendChannelData
        SendChannelData; /* (offset 64)
                    Callback for sending data to a channel.
                    By default, it is set by freerdp_new() to freerdp_send_channel_data(), which
                    eventually calls freerdp_channel_send() */
    ALIGN64 pReceiveChannelData
        ReceiveChannelData; /* (offset 65)
                       Callback for receiving data from a channel.
                       This is called by freerdp_channel_process() (if not NULL).
                       Clients will typically use a function that calls freerdp_channels_data()
                       to perform the needed tasks. */
 
    ALIGN64 pVerifyCertificateEx
        VerifyCertificateEx; 
    ALIGN64 pVerifyChangedCertificateEx
        VerifyChangedCertificateEx; 
    ALIGN64 pSendChannelPacket
        SendChannelPacket;                  /* (offset 68)
                                             * Callback for sending RAW data to a channel. In contrast to
                                             * SendChannelData data fragmentation    is up to the user and this
                                             * function sends data as is with the provided flags.
                                             */
    ALIGN64 pAuthenticateEx AuthenticateEx; 
    ALIGN64 pChooseSmartcard
        ChooseSmartcard;                    /* (offset 70)
                                          Callback for choosing a smartcard for logon.
                                          Used when multiple smartcards are available. Returns an index into a list
                                          of SmartcardCertInfo pointers */
    ALIGN64 pGetAccessToken GetAccessToken; /* (offset 71)
                                                Callback for obtaining an access token
                                                for \b AccessTokenType authentication */
    ALIGN64 pRetryDialog RetryDialog; /* (offset 72) Callback for displaying a dialog in case of
                                         something needs a retry */
    UINT64 paddingE[80 - 73];         /* 73 */
  };
 
  struct rdp_channel_handles
  {
    wListDictionary* init;
    wListDictionary* open;
  };
  typedef struct rdp_channel_handles rdpChannelHandles;
 
  FREERDP_API void freerdp_context_free(freerdp* instance);
 
  FREERDP_API BOOL freerdp_context_new(freerdp* instance);
  FREERDP_API BOOL freerdp_context_new_ex(freerdp* instance, rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_context_reset(freerdp* instance);
 
  FREERDP_API BOOL freerdp_connect(freerdp* instance);
 
  WINPR_DEPRECATED_VAR("use freerdp_abort_connect_context instead",
                       FREERDP_API BOOL freerdp_abort_connect(freerdp* instance));
 
  FREERDP_API BOOL freerdp_abort_connect_context(rdpContext* context);
  FREERDP_API HANDLE freerdp_abort_event(rdpContext* context);
 
  WINPR_DEPRECATED_VAR("use freerdp_shall_disconnect_context instead",
                       FREERDP_API BOOL freerdp_shall_disconnect(freerdp* instance));
 
  FREERDP_API BOOL freerdp_shall_disconnect_context(const rdpContext* context);
  FREERDP_API BOOL freerdp_disconnect(freerdp* instance);
 
  WINPR_DEPRECATED_VAR("use freerdp_disconnect_before_reconnect_context instead",
                       FREERDP_API BOOL freerdp_disconnect_before_reconnect(freerdp* instance));
  FREERDP_API BOOL freerdp_disconnect_before_reconnect_context(rdpContext* context);
 
  FREERDP_API BOOL freerdp_reconnect(freerdp* instance);
 
  FREERDP_API UINT freerdp_channels_attach(freerdp* instance);
  FREERDP_API UINT freerdp_channels_detach(freerdp* instance);
 
#if defined(WITH_FREERDP_DEPRECATED)
  FREERDP_API WINPR_DEPRECATED_VAR("Use freerdp_get_event_handles",
                                   BOOL freerdp_get_fds(freerdp* instance, void** rfds,
                                                        int* rcount, void** wfds, int* wcount));
#endif
 
  FREERDP_API BOOL freerdp_check_fds(freerdp* instance);
 
  FREERDP_API DWORD freerdp_get_event_handles(rdpContext* context, HANDLE* events, DWORD count);
  FREERDP_API BOOL freerdp_check_event_handles(rdpContext* context);
 
  FREERDP_API wMessageQueue* freerdp_get_message_queue(freerdp* instance, DWORD id);
  FREERDP_API HANDLE freerdp_get_message_queue_event_handle(freerdp* instance, DWORD id);
  FREERDP_API int freerdp_message_queue_process_message(freerdp* instance, DWORD id,
                                                        wMessage* message);
  FREERDP_API int freerdp_message_queue_process_pending_messages(freerdp* instance, DWORD id);
 
  FREERDP_API UINT32 freerdp_error_info(freerdp* instance);
  FREERDP_API void freerdp_set_error_info(rdpRdp* rdp, UINT32 error);
  FREERDP_API BOOL freerdp_send_error_info(rdpRdp* rdp);
  FREERDP_API BOOL freerdp_get_stats(rdpRdp* rdp, UINT64* inBytes, UINT64* outBytes,
                                     UINT64* inPackets, UINT64* outPackets);
 
  FREERDP_API void freerdp_get_version(int* major, int* minor, int* revision);
  FREERDP_API const char* freerdp_get_version_string(void);
  FREERDP_API const char* freerdp_get_build_revision(void);
  FREERDP_API const char* freerdp_get_build_config(void);
 
  FREERDP_API void freerdp_free(freerdp* instance);
 
  WINPR_ATTR_MALLOC(freerdp_free, 1)
  FREERDP_API freerdp* freerdp_new(void);
 
  FREERDP_API BOOL freerdp_focus_required(freerdp* instance);
  FREERDP_API void freerdp_set_focus(freerdp* instance);
 
  FREERDP_API int freerdp_get_disconnect_ultimatum(rdpContext* context);
 
  FREERDP_API UINT32 freerdp_get_last_error(rdpContext* context);
  FREERDP_API const char* freerdp_get_last_error_name(UINT32 error);
  FREERDP_API const char* freerdp_get_last_error_string(UINT32 error);
  FREERDP_API const char* freerdp_get_last_error_category(UINT32 error);
 
#define freerdp_set_last_error(context, lastError) \
  freerdp_set_last_error_ex((context), (lastError), __func__, __FILE__, __LINE__)
 
#define freerdp_set_last_error_if_not(context, lastError)             \
  do                                                                \
  {                                                                 \
    if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS) \
      freerdp_set_last_error_log(context, lastError);           \
  } while (0)
 
#define freerdp_set_last_error_log(context, lastError) \
  freerdp_set_last_error_ex((context), (lastError), __func__, __FILE__, __LINE__)
  FREERDP_API void freerdp_set_last_error_ex(rdpContext* context, UINT32 lastError,
                                             const char* fkt, const char* file, int line);
 
  FREERDP_API const char* freerdp_get_logon_error_info_type(UINT32 type);
  FREERDP_API const char* freerdp_get_logon_error_info_type_ex(UINT32 type, char* buffer,
                                                               size_t size);
 
  FREERDP_API const char* freerdp_get_logon_error_info_data(UINT32 data);
  FREERDP_API const char* freerdp_get_logon_error_info_data_ex(UINT32 data, char* buffer,
                                                               size_t size);
 
  FREERDP_API ULONG freerdp_get_transport_sent(rdpContext* context, BOOL resetCount);
 
  FREERDP_API BOOL freerdp_nla_impersonate(rdpContext* context);
  FREERDP_API BOOL freerdp_nla_revert_to_self(rdpContext* context);
 
  FREERDP_API UINT32 freerdp_get_nla_sspi_error(rdpContext* context);
 
  FREERDP_API BOOL freerdp_nla_encrypt(rdpContext* context, const SecBuffer* inBuffer,
                                       SecBuffer* outBuffer);
 
  FREERDP_API BOOL freerdp_nla_decrypt(rdpContext* context, const SecBuffer* inBuffer,
                                       SecBuffer* outBuffer);
 
  FREERDP_API SECURITY_STATUS freerdp_nla_QueryContextAttributes(rdpContext* context,
                                                                 DWORD ulAttr, PVOID pBuffer);
 
  FREERDP_API void clearChannelError(rdpContext* context);
  FREERDP_API HANDLE getChannelErrorEventHandle(rdpContext* context);
  FREERDP_API UINT getChannelError(rdpContext* context);
  FREERDP_API const char* getChannelErrorDescription(rdpContext* context);
  FREERDP_API void setChannelError(rdpContext* context, UINT errorNum, const char* format, ...);
  FREERDP_API BOOL checkChannelErrorEvent(rdpContext* context);
 
  FREERDP_API const char* freerdp_nego_get_routing_token(rdpContext* context, DWORD* length);
 
  FREERDP_API CONNECTION_STATE freerdp_get_state(const rdpContext* context);
 
  FREERDP_API const char* freerdp_state_string(CONNECTION_STATE state);
 
  FREERDP_API BOOL freerdp_is_active_state(const rdpContext* context);
 
  FREERDP_API BOOL freerdp_channels_from_mcs(rdpSettings* settings, const rdpContext* context);
 
  FREERDP_API BOOL freerdp_is_valid_mcs_create_request(const BYTE* data, size_t size);
  FREERDP_API BOOL freerdp_is_valid_mcs_create_response(const BYTE* data, size_t size);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREERDP_H */