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>
 
  /* COM interfaces of freerdp/wts_services.h, the rdp_context slots only need their names */
  typedef struct IWTSWindowInfoService IWTSWindowInfoService;
  typedef struct IWTSBitmapRenderService IWTSBitmapRenderService;
  typedef struct IWTSPluginServiceProvider IWTSPluginServiceProvider;
 
#define MCS_BASE_CHANNEL_ID 1001
#define MCS_GLOBAL_CHANNEL_ID 1003
 
/* Flags used by certificate callbacks */
  typedef enum WINPR_C23_ENUM_TYPE(uint32_t)
  {
    VERIFY_CERT_FLAG_NONE = 0x00,
    VERIFY_CERT_FLAG_LEGACY = 0x02,
    VERIFY_CERT_FLAG_REDIRECT = 0x10,
    VERIFY_CERT_FLAG_GATEWAY = 0x20,
    VERIFY_CERT_FLAG_CHANGED = 0x40,
    VERIFY_CERT_FLAG_MISMATCH = 0x80,
    VERIFY_CERT_FLAG_MATCH_LEGACY_SHA1 = 0x100,
    VERIFY_CERT_FLAG_FP_IS_PEM = 0x200,
    VERIFY_CERT_FLAG_HTTP = 0x1000 
  } RDP_VERIFY_CERT_FLAG;
 
/* 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,
    AUTH_RDSTLS,
    AUTH_FIDO_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);
 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
  typedef BOOL (*pAuthenticate)(freerdp* instance, char** username, char** password,
                                char** domain);
#endif
 
  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 BOOL (*pGetCommonAccessToken)(rdpContext* context, AccessTokenType tokenType,
                                        char** token, size_t count, ...);
 
  typedef SSIZE_T (*pRetryDialog)(freerdp* instance, const char* what, size_t current,
                                  void* userarg);
 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
  WINPR_DEPRECATED_VAR("Use pVerifyCertificateEx",
                       typedef 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(WITHOUT_FREERDP_3x_DEPRECATED)
  WINPR_DEPRECATED_VAR("Use pVerifyChangedCertificateEx",
                       typedef 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 */
 
    /* Services for virtual channel plugins, with Microsoft's interfaces and behaviour (see
     * freerdp/wts_services.h): they let a channel, in tree or provided separately, take part in
     * the rendering (draw video frames in a mapped area, follow the window showing the
     * session). The two client services are created by the client (in ContextNew or before
     * connecting) holding one reference, and released and reset to nullptr by the client in
     * ContextFree; nullptr when the client has none. Channels don't read them directly but call
     * GetService() on the provider (freerdp_get_plugin_service_provider()), which gives each
     * its own instance where Microsoft's client does.
     * @since version 3.34.0 */
    ALIGN64 IWTSWindowInfoService* windowInfoService;         /* 46 set by the client */
    ALIGN64 IWTSBitmapRenderService* bitmapRenderService;     /* 47 set by the client */
    ALIGN64 IWTSPluginServiceProvider* pluginServiceProvider; /* 48 owned by the core */
    UINT64 paddingC[64 - 49];                                 /* 49 */
 
    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 information in it. Clients will typically make it
                 bigger, and use a context structure embedding the rdpContext, and adding
                 additional information after that.
              */
 
    WINPR_ATTR_NODISCARD ALIGN64 pContextNew
        ContextNew; 
    ALIGN64 pContextFree
        ContextFree;          
    UINT64 paddingC[47 - 35]; /* 35 */
 
    ALIGN64 UINT ConnectionCallbackState; /* 47 */
 
    WINPR_ATTR_NODISCARD ALIGN64 pConnectCallback
        PreConnect; 
    WINPR_ATTR_NODISCARD ALIGN64 pConnectCallback
        PostConnect; 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
    WINPR_DEPRECATED_VAR("[since 3.25.0] Use AuthenticateEx instead",
                         WINPR_ATTR_NODISCARD ALIGN64 pAuthenticate
                             Authenticate); 
    WINPR_DEPRECATED_VAR("Use VerifyCertificateEx or VerifyX509Certificate  instead",
                         WINPR_ATTR_NODISCARD ALIGN64 pVerifyCertificate
                             VerifyCertificate); 
    WINPR_DEPRECATED_VAR("Use VerifyChangedCertificateEx or VerifyX509Certificate  instead",
                         WINPR_ATTR_NODISCARD ALIGN64 pVerifyChangedCertificate
                             VerifyChangedCertificate); 
#else
      ALIGN64 UINT64 reserved50[3];
#endif
    WINPR_ATTR_NODISCARD ALIGN64 pVerifyX509Certificate
        VerifyX509Certificate; 
    WINPR_ATTR_NODISCARD ALIGN64 pLogonErrorInfo
        LogonErrorInfo; 
    ALIGN64 pPostDisconnect
        PostDisconnect; 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
    WINPR_DEPRECATED_VAR("[since 3.25.0] Use AuthenticateEx instead",
                         WINPR_ATTR_NODISCARD ALIGN64 pAuthenticate
                             GatewayAuthenticate); 
#else
      ALIGN64 UINT64 reserved56[1];
#endif
    WINPR_ATTR_NODISCARD ALIGN64 pPresentGatewayMessage PresentGatewayMessage; 
    WINPR_ATTR_NODISCARD ALIGN64 pConnectCallback Redirect; 
    WINPR_ATTR_NODISCARD ALIGN64 pConnectCallback
        LoadChannels; 
    ALIGN64 pPostDisconnect
        PostFinalDisconnect;  
    UINT64 paddingD[64 - 61]; /* 61 */
 
    WINPR_ATTR_NODISCARD 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() */
    WINPR_ATTR_NODISCARD ALIGN64 pReceiveChannelData
        ReceiveChannelData; /* (offset 65)
                       Callback for receiving data from a channel.
                       This is called by freerdp_channel_process() (if not nullptr).
                       Clients will typically use a function that calls freerdp_channels_data()
                       to perform the needed tasks. */
 
    WINPR_ATTR_NODISCARD ALIGN64 pVerifyCertificateEx
        VerifyCertificateEx; 
    WINPR_ATTR_NODISCARD ALIGN64 pVerifyChangedCertificateEx
        VerifyChangedCertificateEx; 
    WINPR_ATTR_NODISCARD 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.
                                                                  */
    WINPR_ATTR_NODISCARD ALIGN64 pAuthenticateEx AuthenticateEx; 
    WINPR_ATTR_NODISCARD 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  */
    WINPR_ATTR_NODISCARD ALIGN64 pGetAccessToken GetAccessToken; /* (offset 71)
                                                Callback for obtaining an access token
                                                for \b AccessTokenType authentication */
    WINPR_ATTR_NODISCARD 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);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_context_new(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_context_new_ex(freerdp* instance, rdpSettings* settings);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_context_reset(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_connect(freerdp* instance);
 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
  WINPR_DEPRECATED_VAR("use freerdp_abort_connect_context instead",
                       FREERDP_API BOOL freerdp_abort_connect(freerdp* instance));
#endif
 
  FREERDP_API BOOL freerdp_abort_connect_context(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API HANDLE freerdp_abort_event(rdpContext* context);
 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
  WINPR_DEPRECATED_VAR("use freerdp_shall_disconnect_context instead",
                       WINPR_ATTR_NODISCARD FREERDP_API BOOL
                           freerdp_shall_disconnect(const freerdp* instance));
#endif
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_shall_disconnect_context(const rdpContext* context);
 
  FREERDP_API BOOL freerdp_disconnect(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_disconnect_reason_string(int reason);
 
#if !defined(WITHOUT_FREERDP_3x_DEPRECATED)
  WINPR_DEPRECATED_VAR("use freerdp_disconnect_before_reconnect_context instead",
                       WINPR_ATTR_NODISCARD FREERDP_API BOOL
                           freerdp_disconnect_before_reconnect(freerdp* instance));
#endif
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_disconnect_before_reconnect_context(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_reconnect(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API UINT freerdp_channels_attach(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API UINT freerdp_channels_detach(freerdp* instance);
 
#if defined(WITH_FREERDP_DEPRECATED)
  WINPR_DEPRECATED_VAR("Use freerdp_get_event_handles",
                       WINPR_ATTR_NODISCARD FREERDP_API BOOL
                           freerdp_get_fds(freerdp* instance, void** rfds, int* rcount,
                                           void** wfds, int* wcount));
#endif
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_check_fds(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API DWORD freerdp_get_event_handles(rdpContext* context, HANDLE* events, DWORD count);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_check_event_handles(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API wMessageQueue* freerdp_get_message_queue(freerdp* instance, DWORD id);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API HANDLE freerdp_get_message_queue_event_handle(freerdp* instance, DWORD id);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_message_queue_process_message(freerdp* instance, DWORD id,
                                                        wMessage* message);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_message_queue_process_pending_messages(freerdp* instance, DWORD id);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API UINT32 freerdp_error_info(const freerdp* instance);
 
  FREERDP_API void freerdp_set_error_info(rdpRdp* rdp, UINT32 error);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_send_error_info(rdpRdp* rdp);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_get_stats(const rdpRdp* rdp, UINT64* inBytes, UINT64* outBytes,
                                     UINT64* inPackets, UINT64* outPackets);
 
  FREERDP_API void freerdp_get_version(int* major, int* minor, int* revision);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_version_string(void);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_build_revision(void);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_build_config(void);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_enable_translation(const char* locale, const char* searchPath);
 
  FREERDP_API void freerdp_free(freerdp* instance);
 
  WINPR_ATTR_MALLOC(freerdp_free, 1)
  WINPR_ATTR_NODISCARD
  FREERDP_API freerdp* freerdp_new(void);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_focus_required(freerdp* instance);
  FREERDP_API void freerdp_set_focus(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_get_disconnect_ultimatum(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API IWTSPluginServiceProvider*
  freerdp_get_plugin_service_provider(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API UINT32 freerdp_get_last_error(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_last_error_name(UINT32 code);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_last_error_string(UINT32 code);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_last_error_category(UINT32 code);
 
#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);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_logon_error_info_type(UINT32 type);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_logon_error_info_type_ex(UINT32 type, char* buffer,
                                                               size_t size);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_logon_error_info_data(UINT32 data);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_get_logon_error_info_data_ex(UINT32 data, char* buffer,
                                                               size_t size);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API ULONG freerdp_get_transport_sent(const rdpContext* context, BOOL resetCount);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_nla_impersonate(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_nla_revert_to_self(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API UINT32 freerdp_get_nla_sspi_error(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_nla_encrypt(rdpContext* context, const SecBuffer* inBuffer,
                                       SecBuffer* outBuffer);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_nla_decrypt(rdpContext* context, const SecBuffer* inBuffer,
                                       SecBuffer* outBuffer);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API SECURITY_STATUS freerdp_nla_QueryContextAttributes(rdpContext* context,
                                                                 DWORD ulAttr, PVOID pBuffer);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API SECURITY_STATUS freerdp_nla_FreeContextBuffer(rdpContext* context, PVOID pBuffer);
 
  FREERDP_API void clearChannelError(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API HANDLE getChannelErrorEventHandle(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API UINT getChannelError(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* getChannelErrorDescription(const rdpContext* context);
 
  FREERDP_API void setChannelError(rdpContext* context, UINT errorNum, const char* format, ...);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL checkChannelErrorEvent(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_nego_get_routing_token(const rdpContext* context,
                                                         DWORD* length);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API CONNECTION_STATE freerdp_get_state(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API const char* freerdp_state_string(CONNECTION_STATE state);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_is_active_state(const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_channels_from_mcs(rdpSettings* settings, const rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_is_valid_mcs_create_request(const BYTE* data, size_t size);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_is_valid_mcs_create_response(const BYTE* data, size_t size);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_persist_credentials(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_set_common_access_token(rdpContext* context,
                                                   pGetCommonAccessToken GetCommonAccessToken);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API pGetCommonAccessToken freerdp_get_common_access_token(const rdpContext* context);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREERDP_H */