include/freerdp/client.h

 
#ifndef FREERDP_CLIENT_H
#define FREERDP_CLIENT_H
 
#include <winpr/cmdline.h>
#include <freerdp/client/cmdline.h>
 
#include <freerdp/config.h>
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/event.h>
#include <freerdp/freerdp.h>
 
#if defined(CHANNEL_AINPUT_CLIENT)
#include <freerdp/client/ainput.h>
#endif
 
#if defined(CHANNEL_RDPEI_CLIENT)
#include <freerdp/client/rdpei.h>
#endif
 
#if defined(CHANNEL_ENCOMSP_CLIENT)
#include <freerdp/client/encomsp.h>
#endif
 
typedef struct MIBClientWrapper MIBClientWrapper;
typedef struct AadAuthHelper AadAuthHelper;
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef BOOL (*pRdpGlobalInit)(void);
  typedef void (*pRdpGlobalUninit)(void);
 
  typedef BOOL (*pRdpClientNew)(freerdp* instance, rdpContext* context);
  typedef void (*pRdpClientFree)(freerdp* instance, rdpContext* context);
 
  typedef int (*pRdpClientStart)(rdpContext* context);
  typedef int (*pRdpClientStop)(rdpContext* context);
 
  struct rdp_client_entry_points_v1
  {
    DWORD Size;
    DWORD Version;
 
    rdpSettings* settings;
 
    WINPR_ATTR_NODISCARD pRdpGlobalInit GlobalInit;
    pRdpGlobalUninit GlobalUninit;
 
    DWORD ContextSize;
    WINPR_ATTR_NODISCARD pRdpClientNew ClientNew;
    pRdpClientFree ClientFree;
 
    WINPR_ATTR_NODISCARD pRdpClientStart ClientStart;
    pRdpClientStop ClientStop;
  };
 
#define RDP_CLIENT_INTERFACE_VERSION 1
#define RDP_CLIENT_ENTRY_POINT_NAME "RdpClientEntry"
 
  typedef int (*pRdpClientEntry)(RDP_CLIENT_ENTRY_POINTS* pEntryPoints);
 
  /* Common Client Interface */
#define FREERDP_MAX_TOUCH_CONTACTS 10
 
  typedef struct
  {
    ALIGN64 INT32 id;
    ALIGN64 UINT32 count;
    ALIGN64 INT32 x;
    ALIGN64 INT32 y;
    ALIGN64 UINT32 flags;
    ALIGN64 UINT32 pressure;
  } FreeRDP_TouchContact;
 
#define FREERDP_MAX_PEN_DEVICES 10
 
  typedef struct pen_device
  {
    ALIGN64 INT32 deviceid;
    ALIGN64 UINT32 flags;
    ALIGN64 double max_pressure;
    ALIGN64 BOOL hovering;
    ALIGN64 BOOL pressed;
    ALIGN64 INT32 last_x;
    ALIGN64 INT32 last_y;
  } FreeRDP_PenDevice;
 
  typedef struct rdp_client_oauth2 rdpClientOAuth2;
 
  struct rdp_client_context
  {
    rdpContext context;
    ALIGN64 HANDLE thread; 
#if defined(CHANNEL_AINPUT_CLIENT)
    ALIGN64 AInputClientContext* ainput; 
#else
  UINT64 reserved1;
#endif
 
#if defined(CHANNEL_RDPEI_CLIENT)
    ALIGN64 RdpeiClientContext* rdpei; 
#else
  UINT64 reserved2;
#endif
 
    ALIGN64 INT32 lastX;        
    ALIGN64 INT32 lastY;        
    ALIGN64 BOOL mouse_grabbed; 
#if defined(CHANNEL_ENCOMSP_CLIENT)
    ALIGN64 EncomspClientContext* encomsp; 
    ALIGN64 BOOL controlToggle;            
#else
      UINT64 reserved3[2];
#endif
    ALIGN64 FreeRDP_TouchContact contacts[FREERDP_MAX_TOUCH_CONTACTS]; 
    ALIGN64 FreeRDP_PenDevice pens[FREERDP_MAX_PEN_DEVICES];           
    ALIGN64 MIBClientWrapper* mibClientWrapper; 
    ALIGN64 BOOL pressed_buttons[5];            
    ALIGN64 rdpClientOAuth2* oauth2;            
    ALIGN64 AadAuthHelper* aadHelper;           
    ALIGN64 pConnectCallback PreConnect;        
    ALIGN64 pConnectCallback PostConnect;       
    ALIGN64 pPostDisconnect PostDisconnect;     
    ALIGN64 pPostDisconnect PostFinalDisconnect; 
    ALIGN64 HANDLE pipethread;                   
    UINT64 reserved[129 - 23];                   
  };
 
  typedef BOOL (*window_events_fkt_t)(freerdp* instance);
 
  /* Common client functions */
 
  FREERDP_API void freerdp_client_context_free(rdpContext* context);
 
  WINPR_ATTR_MALLOC(freerdp_client_context_free, 1)
  FREERDP_API rdpContext* freerdp_client_context_new(const RDP_CLIENT_ENTRY_POINTS* pEntryPoints);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_start(rdpContext* context);
 
  FREERDP_API int freerdp_client_stop(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_client_enable_translation(const char* locale, const char* searchPath);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API freerdp* freerdp_client_get_instance(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API HANDLE freerdp_client_get_thread(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_settings_parse_command_line(rdpSettings* settings, int argc,
                                                             char** argv, BOOL allowUnknown);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_settings_parse_command_line_ex(
      rdpSettings* settings, int argc, char** argv, BOOL allowUnknown,
      COMMAND_LINE_ARGUMENT_A* args, size_t count,
      freerdp_command_line_handle_option_t handle_option, void* handle_userdata);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_settings_parse_connection_file(rdpSettings* settings,
                                                                const char* filename);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_settings_parse_connection_file_buffer(rdpSettings* settings,
                                                                       const BYTE* buffer,
                                                                       size_t size);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_settings_write_connection_file(const rdpSettings* settings,
                                                                const char* filename,
                                                                BOOL unicode);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_settings_parse_assistance_file(rdpSettings* settings, int argc,
                                                                char* argv[]);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_cli_authenticate_ex(freerdp* instance, char** username, char** password,
                                              char** domain, rdp_auth_reason reason);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_cli_choose_smartcard(freerdp* instance, SmartcardCertInfo** cert_list,
                                               DWORD count, DWORD* choice, BOOL gateway);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int client_cli_logon_error_info(freerdp* instance, UINT32 data, UINT32 type);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_failsafe_get_access_token(freerdp* instance, AccessTokenType tokenType,
                                                    char** token, size_t count, ...);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_helper_get_access_token(freerdp* instance, AccessTokenType tokenType,
                                                  char** token, size_t count, ...);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_cli_get_access_token(freerdp* instance, AccessTokenType tokenType,
                                               char** token, size_t count, ...);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_common_get_access_token(freerdp* instance, const char* request,
                                                  char** token);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API SSIZE_T client_common_retry_dialog(freerdp* instance, const char* what,
                                                 size_t current, void* userarg);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_common_save_session_info(rdpContext* context, UINT32 type,
                                                   const void* data);
 
  FREERDP_API void
  freerdp_client_OnChannelConnectedEventHandler(void* context,
                                                const ChannelConnectedEventArgs* e);
  FREERDP_API void
  freerdp_client_OnChannelDisconnectedEventHandler(void* context,
                                                   const ChannelDisconnectedEventArgs* e);
 
#if defined(WITH_FREERDP_DEPRECATED)
  WINPR_DEPRECATED_VAR("Use client_cli_authenticate_ex",
                       WINPR_ATTR_NODISCARD FREERDP_API BOOL client_cli_authenticate(
                           freerdp* instance, char** username, char** password, char** domain));
  WINPR_DEPRECATED_VAR("Use client_cli_authenticate_ex",
                       WINPR_ATTR_NODISCARD FREERDP_API BOOL client_cli_gw_authenticate(
                           freerdp* instance, char** username, char** password, char** domain));
 
  WINPR_DEPRECATED_VAR("Use client_cli_verify_certificate_ex",
                       WINPR_ATTR_NODISCARD FREERDP_API DWORD client_cli_verify_certificate(
                           freerdp* instance, const char* common_name, const char* subject,
                           const char* issuer, const char* fingerprint, BOOL host_mismatch));
#endif
 
  WINPR_ATTR_NODISCARD
  FREERDP_API DWORD client_cli_verify_certificate_ex(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)
  WINPR_DEPRECATED_VAR(
      "Use client_cli_verify_changed_certificate_ex",
      WINPR_ATTR_NODISCARD FREERDP_API DWORD client_cli_verify_changed_certificate(
          freerdp* instance, const char* common_name, const char* subject, const char* issuer,
          const char* fingerprint, const char* old_subject, const char* old_issuer,
          const char* old_fingerprint));
#endif
 
  WINPR_ATTR_NODISCARD
  FREERDP_API DWORD client_cli_verify_changed_certificate_ex(
      freerdp* instance, const char* host, UINT16 port, const char* common_name,
      const char* subject, const char* issuer, const char* fingerprint, const char* old_subject,
      const char* old_issuer, const char* old_fingerprint, DWORD flags);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_cli_present_gateway_message(freerdp* instance, UINT32 type,
                                                      BOOL isDisplayMandatory,
                                                      BOOL isConsentMandatory, size_t length,
                                                      const WCHAR* message);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_auto_reconnect(freerdp* instance);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL client_auto_reconnect_ex(freerdp* instance, window_events_fkt_t window_events);
 
  typedef enum
  {
    FREERDP_TOUCH_DOWN = 0x01,
    FREERDP_TOUCH_UP = 0x02,
    FREERDP_TOUCH_MOTION = 0x04,
    FREERDP_TOUCH_CANCEL = 0x08, 
    FREERDP_TOUCH_HAS_PRESSURE = 0x100
  } FreeRDPTouchEventType;
 
  FREERDP_API BOOL freerdp_client_handle_touch(rdpClientContext* cctx, UINT32 flags, INT32 finger,
                                               UINT32 pressure, INT32 x, INT32 y);
 
  typedef enum
  {
    FREERDP_PEN_REGISTER = 0x01,
    FREERDP_PEN_ERASER_PRESSED = 0x02,
    FREERDP_PEN_PRESS = 0x04,
    FREERDP_PEN_MOTION = 0x08,
    FREERDP_PEN_RELEASE = 0x10,
    FREERDP_PEN_BARREL_PRESSED = 0x20,
    FREERDP_PEN_HAS_PRESSURE = 0x40,
    FREERDP_PEN_HAS_ROTATION = 0x80,
    FREERDP_PEN_HAS_TILTX = 0x100,
    FREERDP_PEN_HAS_TILTY = 0x200,
    FREERDP_PEN_IS_INVERTED = 0x400
  } FreeRDPPenEventType;
 
  FREERDP_API BOOL freerdp_client_handle_pen(rdpClientContext* cctx, UINT32 flags, INT32 deviceid,
                                             ...);
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_client_is_pen(rdpClientContext* cctx, INT32 deviceid);
 
  FREERDP_API BOOL freerdp_client_pen_cancel_all(rdpClientContext* cctx);
 
  FREERDP_API BOOL freerdp_client_send_wheel_event(rdpClientContext* cctx, UINT16 mflags);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_client_use_relative_mouse_events(rdpClientContext* cctx);
 
  FREERDP_API BOOL freerdp_client_send_button_event(rdpClientContext* cctx, BOOL relative,
                                                    UINT16 mflags, INT32 x, INT32 y);
 
  FREERDP_API BOOL freerdp_client_send_extended_button_event(rdpClientContext* cctx,
                                                             BOOL relative, UINT16 mflags,
                                                             INT32 x, INT32 y);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API int freerdp_client_common_stop(rdpContext* context);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_client_load_channels(freerdp* instance);
 
#if defined(CHANNEL_ENCOMSP_CLIENT)
  FREERDP_API BOOL freerdp_client_encomsp_toggle_control(EncomspClientContext* encomsp);
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_client_encomsp_set_control(EncomspClientContext* encomsp,
                                                      BOOL control);
#endif
 
  typedef enum
  {
    FREERDP_CLIENT_AAD_AUTH_REQUEST,
    FREERDP_CLIENT_AAD_TOKEN_REQUEST,
    FREERDP_CLIENT_AAD_AVD_AUTH_REQUEST,
    FREERDP_CLIENT_AAD_AVD_TOKEN_REQUEST,
  } freerdp_client_aad_type;
 
  WINPR_ATTR_MALLOC(winpr_zfree, 1)
  FREERDP_API char* freerdp_client_get_aad_url(rdpClientContext* cctx,
                                               freerdp_client_aad_type type, ...);
 
  WINPR_ATTR_MALLOC(winpr_zfree, 1)
  FREERDP_API char* freerdp_client_extract_aad_code(rdpClientContext* cctx, const char* data,
                                                    size_t length);
 
  typedef enum WINPR_C23_ENUM_TYPE(uint32_t)
  {
    FREERDP_CLIENT_KBD_MOD_NONE = 0x00,
    FREERDP_CLIENT_KBD_MOD_LSHIFT = 0x01,
    FREERDP_CLIENT_KBD_MOD_RSHIFT = 0x02,
    FREERDP_CLIENT_KBD_MOD_LMENU = 0x04,
    FREERDP_CLIENT_KBD_MOD_RMENU = 0x08,
    FREERDP_CLIENT_KBD_MOD_LCONTROL = 0x10,
    FREERDP_CLIENT_KBD_MOD_RCONTROL = 0x20,
    FREERDP_CLIENT_KBD_MOD_LWIN = 0x40,
    FREERDP_CLIENT_KBD_MOD_RWIN = 0x80
  } FREERDP_CLIENT_KBD_MOD;
 
  WINPR_ATTR_NODISCARD
  FREERDP_API BOOL freerdp_client_send_key_as_unicode(rdpClientContext* cctx, UINT16 flags,
                                                      const char* str, UINT32 scancode,
                                                      FREERDP_CLIENT_KBD_MOD modmask);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREERDP_CLIENT_H */