ksmith/orbithub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Milestone 5: deliver embedded RDP sessions and lifecycle hardening

Browse Source
This commit is contained in:
Keith Smith
2026-03-03 18:59:26 -07:00
parent 230a401386
commit 36006bd4aa
2941 changed files with 724359 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
third_party/FreeRDP/include/freerdp/client/ainput.h vendored Normal file
View File

@@ -0,0 +1,48 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Display Update Virtual Channel Extension
*
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_AINPUT_CLIENT_AINPUT_H
#define FREERDP_CHANNEL_AINPUT_CLIENT_AINPUT_H
#include <winpr/assert.h>
#include <freerdp/channels/ainput.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef UINT (*pcAInputSendInputEvent)(AInputClientContext* context, UINT64 flags, INT32 x,
INT32 y);
struct ainput_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcAInputSendInputEvent AInputSendInputEvent;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_AINPUT_CLIENT_AINPUT_H */

76
third_party/FreeRDP/include/freerdp/client/audin.h vendored Normal file
View File

@@ -0,0 +1,76 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Audio Input Redirection Virtual Channel
*
* Copyright 2010-2011 Vic Lee
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_AUDIN_CLIENT_AUDIN_H
#define FREERDP_CHANNEL_AUDIN_CLIENT_AUDIN_H
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/channels/audin.h>
#include <freerdp/codec/audio.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Subsystem Interface
*/
typedef UINT (*AudinReceive)(const AUDIO_FORMAT* format, const BYTE* data, size_t size,
void* userData);
typedef struct s_IAudinDevice IAudinDevice;
struct s_IAudinDevice
{
WINPR_ATTR_NODISCARD UINT (*Open)(IAudinDevice* devplugin, AudinReceive receive,
void* userData);
WINPR_ATTR_NODISCARD BOOL (*FormatSupported)(IAudinDevice* devplugin,
const AUDIO_FORMAT* format);
WINPR_ATTR_NODISCARD UINT (*SetFormat)(IAudinDevice* devplugin, const AUDIO_FORMAT* format,
UINT32 FramesPerPacket);
WINPR_ATTR_NODISCARD UINT (*Close)(IAudinDevice* devplugin);
WINPR_ATTR_NODISCARD UINT (*Free)(IAudinDevice* devplugin);
};
#define AUDIN_DEVICE_EXPORT_FUNC_NAME "freerdp_audin_client_subsystem_entry"
typedef UINT (*PREGISTERAUDINDEVICE)(IWTSPlugin* plugin, IAudinDevice* device);
typedef struct
{
IWTSPlugin* plugin;
WINPR_ATTR_NODISCARD PREGISTERAUDINDEVICE pRegisterAudinDevice;
const ADDIN_ARGV* args;
rdpContext* rdpcontext;
} FREERDP_AUDIN_DEVICE_ENTRY_POINTS;
typedef FREERDP_AUDIN_DEVICE_ENTRY_POINTS* PFREERDP_AUDIN_DEVICE_ENTRY_POINTS;
typedef UINT(VCAPITYPE* PFREERDP_AUDIN_DEVICE_ENTRY)(
PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_AUDIN_CLIENT_AUDIN_H */

101
third_party/FreeRDP/include/freerdp/client/channels.h vendored Normal file
View File

@@ -0,0 +1,101 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Client Channels
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNELS_CLIENT_H
#define FREERDP_CHANNELS_CLIENT_H
#include <freerdp/api.h>
#include <freerdp/dvc.h>
#include <freerdp/config.h>
#include <freerdp/addin.h>
#include <freerdp/channels/channels.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct
{
IWTSVirtualChannelCallback iface;
IWTSPlugin* plugin;
IWTSVirtualChannelManager* channel_mgr;
IWTSVirtualChannel* channel;
} GENERIC_CHANNEL_CALLBACK;
typedef struct
{
IWTSListenerCallback iface;
IWTSPlugin* plugin;
IWTSVirtualChannelManager* channel_mgr;
IWTSVirtualChannel* channel;
GENERIC_CHANNEL_CALLBACK* channel_callback;
} GENERIC_LISTENER_CALLBACK;
typedef struct GENERIC_DYNVC_PLUGIN GENERIC_DYNVC_PLUGIN;
typedef UINT (*DYNVC_PLUGIN_INIT_FN)(GENERIC_DYNVC_PLUGIN* plugin, rdpContext* context,
rdpSettings* settings);
typedef void (*DYNVC_PLUGIN_TERMINATE_FN)(GENERIC_DYNVC_PLUGIN* plugin);
struct GENERIC_DYNVC_PLUGIN
{
IWTSPlugin iface;
GENERIC_LISTENER_CALLBACK* listener_callback;
IWTSListener* listener;
BOOL attached;
BOOL initialized;
wLog* log;
char* dynvc_name;
size_t channelCallbackSize;
const IWTSVirtualChannelCallback* channel_callbacks;
DYNVC_PLUGIN_TERMINATE_FN terminatePluginFn;
};
#if defined(WITH_CHANNELS)
WINPR_ATTR_NODISCARD
FREERDP_API void* freerdp_channels_client_find_static_entry(const char* name,
const char* identifier);
WINPR_ATTR_NODISCARD
FREERDP_API PVIRTUALCHANNELENTRY freerdp_channels_load_static_addin_entry(LPCSTR pszName,
LPCSTR pszSubsystem,
LPCSTR pszType,
DWORD dwFlags);
WINPR_ATTR_NODISCARD
FREERDP_API FREERDP_ADDIN** freerdp_channels_list_addins(LPCSTR pszName, LPCSTR pszSubsystem,
LPCSTR pszType, DWORD dwFlags);
FREERDP_API void freerdp_channels_addin_list_free(FREERDP_ADDIN** ppAddins);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_initialize_generic_dynvc_plugin(GENERIC_DYNVC_PLUGIN* plugin);
WINPR_ATTR_NODISCARD
FREERDP_API UINT freerdp_generic_DVCPluginEntry(
IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* logTag, const char* name,
size_t pluginSize, size_t channelCallbackSize,
const IWTSVirtualChannelCallback* channel_callbacks, DYNVC_PLUGIN_INIT_FN initPluginFn,
DYNVC_PLUGIN_TERMINATE_FN terminatePluginFn);
#endif
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNELS_CLIENT_H */

118
third_party/FreeRDP/include/freerdp/client/client_cliprdr_file.h vendored Normal file
View File

@@ -0,0 +1,118 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* X11 Clipboard Redirection
*
* Copyright 2010-2011 Vic Lee
* Copyright 2023 Armin Novak <armin.novak@thincst.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CLIENT_X11_CLIPRDR_FILE_H
#define FREERDP_CLIENT_X11_CLIPRDR_FILE_H
#include <winpr/clipboard.h>
#include <freerdp/client/cliprdr.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct cliprdr_file_context CliprdrFileContext;
FREERDP_API void cliprdr_file_context_free(CliprdrFileContext* file);
WINPR_ATTR_MALLOC(cliprdr_file_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_API CliprdrFileContext* cliprdr_file_context_new(void* context);
/**! \brief returns if the implementation supports pasting files in a client file browser.
*
* \param file the file context to query
*
* \return \b TRUE if files can be pasted locally, \b FALSE if not (e.g. no FUSE, ...)
*/
WINPR_ATTR_NODISCARD
FREERDP_API BOOL cliprdr_file_context_has_local_support(CliprdrFileContext* file);
/**! \brief sets state of local file paste support
*
* \param file the file context to update
* \param available \b TRUE if the client supports pasting files to local file browsers, \b
* FALSE otherwise
*
* \return \b TRUE for success, \b FALSE otherwise
*/
WINPR_ATTR_NODISCARD
FREERDP_API BOOL cliprdr_file_context_set_locally_available(CliprdrFileContext* file,
BOOL available);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL cliprdr_file_context_remote_set_flags(CliprdrFileContext* file, UINT32 flags);
WINPR_ATTR_NODISCARD
FREERDP_API UINT32 cliprdr_file_context_remote_get_flags(CliprdrFileContext* file);
WINPR_ATTR_NODISCARD
FREERDP_API UINT32 cliprdr_file_context_current_flags(CliprdrFileContext* file);
WINPR_ATTR_NODISCARD
FREERDP_API void* cliprdr_file_context_get_context(CliprdrFileContext* file);
FREERDP_API BOOL cliprdr_file_context_init(CliprdrFileContext* file,
CliprdrClientContext* cliprdr);
FREERDP_API BOOL cliprdr_file_context_uninit(CliprdrFileContext* file,
CliprdrClientContext* cliprdr);
FREERDP_API BOOL cliprdr_file_context_clear(CliprdrFileContext* file);
WINPR_ATTR_NODISCARD
FREERDP_API UINT
cliprdr_file_context_notify_new_server_format_list(CliprdrFileContext* file_context);
WINPR_ATTR_NODISCARD
FREERDP_API UINT
cliprdr_file_context_notify_new_client_format_list(CliprdrFileContext* file_context);
/** \brief updates the files the client announces to the server
*
* \param file the file context to update
* \param data the file list
* \param size the length of the file list
*
* \return \b TRUE for success, \b FALSE otherwise
*/
FREERDP_API BOOL cliprdr_file_context_update_client_data(CliprdrFileContext* file,
const char* data, size_t size);
/** \brief updates the files the server announces to the client
*
* \param file the file context to update
* \param clip the clipboard instance to use
* \param data the file list [MS-RDPECLIP] 2.2.5.2.3 Packed File List (CLIPRDR_FILELIST)
* \param size the length of the file list
*
* \return \b TRUE for success, \b FALSE otherwise
*/
WINPR_ATTR_NODISCARD
FREERDP_API BOOL cliprdr_file_context_update_server_data(CliprdrFileContext* file,
wClipboard* clip, const void* data,
size_t size);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CLIENT_X11_CLIPRDR_FILE_H */

201
third_party/FreeRDP/include/freerdp/client/cliprdr.h vendored Normal file
View File

@@ -0,0 +1,201 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Clipboard Virtual Channel Extension
*
* Copyright 2011 Vic Lee
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_CLIPRDR_CLIENT_CLIPRDR_H
#define FREERDP_CHANNEL_CLIPRDR_CLIENT_CLIPRDR_H
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/message.h>
#include <freerdp/channels/cliprdr.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct s_cliprdr_client_context CliprdrClientContext;
typedef UINT (*pcCliprdrServerCapabilities)(CliprdrClientContext* context,
const CLIPRDR_CAPABILITIES* capabilities);
typedef UINT (*pcCliprdrClientCapabilities)(CliprdrClientContext* context,
const CLIPRDR_CAPABILITIES* capabilities);
typedef UINT (*pcCliprdrMonitorReady)(CliprdrClientContext* context,
const CLIPRDR_MONITOR_READY* monitorReady);
typedef UINT (*pcCliprdrTempDirectory)(CliprdrClientContext* context,
const CLIPRDR_TEMP_DIRECTORY* tempDirectory);
typedef UINT (*pcCliprdrClientFormatList)(CliprdrClientContext* context,
const CLIPRDR_FORMAT_LIST* formatList);
typedef UINT (*pcCliprdrServerFormatList)(CliprdrClientContext* context,
const CLIPRDR_FORMAT_LIST* formatList);
typedef UINT (*pcCliprdrClientFormatListResponse)(
CliprdrClientContext* context, const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse);
typedef UINT (*pcCliprdrServerFormatListResponse)(
CliprdrClientContext* context, const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse);
typedef UINT (*pcCliprdrClientLockClipboardData)(
CliprdrClientContext* context, const CLIPRDR_LOCK_CLIPBOARD_DATA* lockClipboardData);
typedef UINT (*pcCliprdrServerLockClipboardData)(
CliprdrClientContext* context, const CLIPRDR_LOCK_CLIPBOARD_DATA* lockClipboardData);
typedef UINT (*pcCliprdrClientUnlockClipboardData)(
CliprdrClientContext* context, const CLIPRDR_UNLOCK_CLIPBOARD_DATA* unlockClipboardData);
typedef UINT (*pcCliprdrServerUnlockClipboardData)(
CliprdrClientContext* context, const CLIPRDR_UNLOCK_CLIPBOARD_DATA* unlockClipboardData);
typedef UINT (*pcCliprdrClientFormatDataRequest)(
CliprdrClientContext* context, const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest);
typedef UINT (*pcCliprdrServerFormatDataRequest)(
CliprdrClientContext* context, const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest);
typedef UINT (*pcCliprdrClientFormatDataResponse)(
CliprdrClientContext* context, const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse);
typedef UINT (*pcCliprdrServerFormatDataResponse)(
CliprdrClientContext* context, const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse);
typedef UINT (*pcCliprdrClientFileContentsRequest)(
CliprdrClientContext* context, const CLIPRDR_FILE_CONTENTS_REQUEST* fileContentsRequest);
typedef UINT (*pcCliprdrServerFileContentsRequest)(
CliprdrClientContext* context, const CLIPRDR_FILE_CONTENTS_REQUEST* fileContentsRequest);
typedef UINT (*pcCliprdrClientFileContentsResponse)(
CliprdrClientContext* context, const CLIPRDR_FILE_CONTENTS_RESPONSE* fileContentsResponse);
typedef UINT (*pcCliprdrServerFileContentsResponse)(
CliprdrClientContext* context, const CLIPRDR_FILE_CONTENTS_RESPONSE* fileContentsResponse);
struct s_cliprdr_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcCliprdrServerCapabilities ServerCapabilities;
WINPR_ATTR_NODISCARD pcCliprdrClientCapabilities ClientCapabilities;
WINPR_ATTR_NODISCARD pcCliprdrMonitorReady MonitorReady;
WINPR_ATTR_NODISCARD pcCliprdrTempDirectory TempDirectory;
WINPR_ATTR_NODISCARD pcCliprdrClientFormatList ClientFormatList;
WINPR_ATTR_NODISCARD pcCliprdrServerFormatList ServerFormatList;
WINPR_ATTR_NODISCARD pcCliprdrClientFormatListResponse ClientFormatListResponse;
WINPR_ATTR_NODISCARD pcCliprdrServerFormatListResponse ServerFormatListResponse;
WINPR_ATTR_NODISCARD pcCliprdrClientLockClipboardData ClientLockClipboardData;
WINPR_ATTR_NODISCARD pcCliprdrServerLockClipboardData ServerLockClipboardData;
WINPR_ATTR_NODISCARD pcCliprdrClientUnlockClipboardData ClientUnlockClipboardData;
WINPR_ATTR_NODISCARD pcCliprdrServerUnlockClipboardData ServerUnlockClipboardData;
WINPR_ATTR_NODISCARD pcCliprdrClientFormatDataRequest ClientFormatDataRequest;
WINPR_ATTR_NODISCARD pcCliprdrServerFormatDataRequest ServerFormatDataRequest;
WINPR_ATTR_NODISCARD pcCliprdrClientFormatDataResponse ClientFormatDataResponse;
WINPR_ATTR_NODISCARD pcCliprdrServerFormatDataResponse ServerFormatDataResponse;
WINPR_ATTR_NODISCARD pcCliprdrClientFileContentsRequest ClientFileContentsRequest;
WINPR_ATTR_NODISCARD pcCliprdrServerFileContentsRequest ServerFileContentsRequest;
WINPR_ATTR_NODISCARD pcCliprdrClientFileContentsResponse ClientFileContentsResponse;
WINPR_ATTR_NODISCARD pcCliprdrServerFileContentsResponse ServerFileContentsResponse;
UINT32 lastRequestedFormatId;
rdpContext* rdpcontext;
};
typedef struct
{
UINT32 id;
char* name;
int length;
} CLIPRDR_FORMAT_NAME;
/**
* Clipboard Events
*/
typedef struct
{
wMessage event;
UINT32 capabilities;
} RDP_CB_CLIP_CAPS;
typedef struct
{
wMessage event;
UINT32 capabilities;
} RDP_CB_MONITOR_READY_EVENT;
typedef struct
{
wMessage event;
UINT32* formats;
UINT16 num_formats;
BYTE* raw_format_data;
UINT32 raw_format_data_size;
BOOL raw_format_unicode;
} RDP_CB_FORMAT_LIST_EVENT;
typedef struct
{
wMessage event;
UINT32 format;
} RDP_CB_DATA_REQUEST_EVENT;
typedef struct
{
wMessage event;
BYTE* data;
UINT32 size;
} RDP_CB_DATA_RESPONSE_EVENT;
typedef struct
{
wMessage event;
UINT32 streamId;
UINT32 lindex;
UINT32 dwFlags;
UINT32 nPositionLow;
UINT32 nPositionHigh;
UINT32 cbRequested;
UINT32 clipDataId;
} RDP_CB_FILECONTENTS_REQUEST_EVENT;
typedef struct
{
wMessage event;
BYTE* data;
UINT32 size;
UINT32 streamId;
} RDP_CB_FILECONTENTS_RESPONSE_EVENT;
typedef struct
{
wMessage event;
UINT32 clipDataId;
} RDP_CB_LOCK_CLIPDATA_EVENT;
typedef struct
{
wMessage event;
UINT32 clipDataId;
} RDP_CB_UNLOCK_CLIPDATA_EVENT;
typedef struct
{
wMessage event;
char dirname[520];
} RDP_CB_TEMPDIR_EVENT;
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_CLIPRDR_CLIENT_CLIPRDR_H */

177
third_party/FreeRDP/include/freerdp/client/cmdline.h vendored Normal file
View File

@@ -0,0 +1,177 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* FreeRDP Client Command-Line Interface
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CLIENT_CMDLINE_H
#define FREERDP_CLIENT_CMDLINE_H
#include <winpr/cmdline.h>
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/settings.h>
#ifdef __cplusplus
extern "C"
{
#endif
/** @brief Callback function type definition for command line handling
*
* @param arg A pointer to the argument to handle
* @param custom A pointer to user defined data
*
* @return \b 0 for success or a \b COMMAND_LINE_ERROR code
*
* @since version 3.12.0
*/
typedef int (*freerdp_command_line_handle_option_t)(const COMMAND_LINE_ARGUMENT_A* arg,
void* custom);
/** \brief parses command line arguments to appropriate settings values.
*
* \param settings The settings instance to store the parsed values to
* \param argc the number of argv values
* \param argv an array of strings (char pointer)
* \param allowUnknown Allow unknown command line arguments or \b FALSE if not.
*
* \return \b 0 in case of success, a negative number in case of failure.
*/
WINPR_ATTR_NODISCARD
FREERDP_API int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
int argc, char** argv,
BOOL allowUnknown);
/** \brief parses command line arguments to appropriate settings values. Additionally allows
* supplying custom command line arguments and a handler function.
*
* \param settings The settings instance to store the parsed values to
* \param argc the number of argv values
* \param argv an array of strings (char pointer)
* \param allowUnknown Allow unknown command line arguments or \b FALSE if not.
* \param args Pointer to the custom arguments
* \param count The number of custom arguments
* \param handle_option the handler function for custom arguments.
* \param handle_userdata custom data supplied to \b handle_option as context
*
* \since version 3.0.0
*
* \return \b 0 in case of success, a negative number in case of failure.
*/
WINPR_ATTR_NODISCARD
FREERDP_API int freerdp_client_settings_parse_command_line_arguments_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_command_line_status_print(rdpSettings* settings,
int status, int argc,
char** argv);
WINPR_ATTR_NODISCARD
FREERDP_API int
freerdp_client_settings_command_line_status_print_ex(rdpSettings* settings, int status,
int argc, char** argv,
const COMMAND_LINE_ARGUMENT_A* custom);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_load_addins(rdpChannels* channels, rdpSettings* settings);
/** Print a command line warning about the component being unmaintained.
*
* \since version 3.0.0
*/
FREERDP_API void freerdp_client_warn_unmaintained(int argc, char* argv[]);
/** Print a command line warning about the component being experimental.
*
* \since version 3.0.0
*/
FREERDP_API void freerdp_client_warn_experimental(int argc, char* argv[]);
/** Print a command line warning about the component being deprecated.
*
* \since version 3.0.0
*/
FREERDP_API void freerdp_client_warn_deprecated(int argc, char* argv[]);
FREERDP_API BOOL freerdp_client_print_version(void);
/** @brief prints the version of the client including the binary name extracted from \b argv
*
* @param argc the number of command line arguments, must be >= 0
* @param argv the array of command line argument strings
*
* @return \b TRUE for success
*
* @since version 3.10.0
*/
FREERDP_API BOOL freerdp_client_print_version_ex(int argc, char** argv);
FREERDP_API BOOL freerdp_client_print_buildconfig(void);
/** @brief prints the buidconfiguration of the client including the binary name extracted from
* \b argv
*
* @param argc the number of command line arguments, must be >= 0
* @param argv the array of command line argument strings
*
* @return \b TRUE for success
*
* @since version 3.10.0
*/
FREERDP_API BOOL freerdp_client_print_buildconfig_ex(int argc, char** argv);
FREERDP_API BOOL freerdp_client_print_command_line_help(int argc, char** argv);
FREERDP_API BOOL freerdp_client_print_command_line_help_ex(
int argc, char** argv, const COMMAND_LINE_ARGUMENT_A* custom);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_parse_username(const char* username, char** user, char** domain);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_parse_hostname(const char* hostname, char** host, int* port);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_set_connection_type(rdpSettings* settings, UINT32 type);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_add_device_channel(rdpSettings* settings, size_t count,
const char* const* params);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_add_static_channel(rdpSettings* settings, size_t count,
const char* const* params);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_del_static_channel(rdpSettings* settings, const char* name);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_add_dynamic_channel(rdpSettings* settings, size_t count,
const char* const* params);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_del_dynamic_channel(rdpSettings* settings, const char* name);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CLIENT_CMDLINE_H */

52
third_party/FreeRDP/include/freerdp/client/disp.h vendored Normal file
View File

@@ -0,0 +1,52 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Display Update Virtual Channel Extension
*
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_DISP_CLIENT_DISP_H
#define FREERDP_CHANNEL_DISP_CLIENT_DISP_H
#include <freerdp/channels/disp.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct s_disp_client_context DispClientContext;
typedef UINT (*pcDispCaps)(DispClientContext* context, UINT32 MaxNumMonitors,
UINT32 MaxMonitorAreaFactorA, UINT32 MaxMonitorAreaFactorB);
typedef UINT (*pcDispSendMonitorLayout)(DispClientContext* context, UINT32 NumMonitors,
DISPLAY_CONTROL_MONITOR_LAYOUT* Monitors);
struct s_disp_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcDispCaps DisplayControlCaps;
WINPR_ATTR_NODISCARD pcDispSendMonitorLayout SendMonitorLayout;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_DISP_CLIENT_DISP_H */

64
third_party/FreeRDP/include/freerdp/client/drdynvc.h vendored Normal file
View File

@@ -0,0 +1,64 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Dynamic Virtual Channel Extension
*
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_DRDYNVC_CLIENT_DRDYNVC_H
#define FREERDP_CHANNEL_DRDYNVC_CLIENT_DRDYNVC_H
#include <winpr/wtypes.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct s_drdynvc_client_context DrdynvcClientContext;
typedef int (*pcDrdynvcGetVersion)(DrdynvcClientContext* context);
typedef UINT (*pcDrdynvcOnChannelConnected)(DrdynvcClientContext* context, const char* name,
void* pInterface);
typedef UINT (*pcDrdynvcOnChannelDisconnected)(DrdynvcClientContext* context, const char* name,
void* pInterface);
typedef UINT (*pcDrdynvcOnChannelAttached)(DrdynvcClientContext* context, const char* name,
void* pInterface);
typedef UINT (*pcDrdynvcOnChannelDetached)(DrdynvcClientContext* context, const char* name,
void* pInterface);
struct s_drdynvc_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcDrdynvcGetVersion GetVersion;
WINPR_ATTR_NODISCARD pcDrdynvcOnChannelConnected OnChannelConnected;
WINPR_ATTR_NODISCARD pcDrdynvcOnChannelDisconnected OnChannelDisconnected;
WINPR_ATTR_NODISCARD pcDrdynvcOnChannelAttached OnChannelAttached;
WINPR_ATTR_NODISCARD pcDrdynvcOnChannelDetached OnChannelDetached;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_DRDYNVC_CLIENT_DRDYNVC_H */

88
third_party/FreeRDP/include/freerdp/client/encomsp.h vendored Normal file
View File

@@ -0,0 +1,88 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Multiparty Virtual Channel
*
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_ENCOMSP_CLIENT_ENCOMSP_H
#define FREERDP_CHANNEL_ENCOMSP_CLIENT_ENCOMSP_H
#include <freerdp/channels/encomsp.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct s_encomsp_client_context EncomspClientContext;
typedef UINT (*pcEncomspFilterUpdated)(EncomspClientContext* context,
const ENCOMSP_FILTER_UPDATED_PDU* filterUpdated);
typedef UINT (*pcEncomspApplicationCreated)(
EncomspClientContext* context, const ENCOMSP_APPLICATION_CREATED_PDU* applicationCreated);
typedef UINT (*pcEncomspApplicationRemoved)(
EncomspClientContext* context, const ENCOMSP_APPLICATION_REMOVED_PDU* applicationRemoved);
typedef UINT (*pcEncomspWindowCreated)(EncomspClientContext* context,
const ENCOMSP_WINDOW_CREATED_PDU* windowCreated);
typedef UINT (*pcEncomspWindowRemoved)(EncomspClientContext* context,
const ENCOMSP_WINDOW_REMOVED_PDU* windowRemoved);
typedef UINT (*pcEncomspShowWindow)(EncomspClientContext* context,
const ENCOMSP_SHOW_WINDOW_PDU* showWindow);
typedef UINT (*pcEncomspParticipantCreated)(
EncomspClientContext* context, const ENCOMSP_PARTICIPANT_CREATED_PDU* participantCreated);
typedef UINT (*pcEncomspParticipantRemoved)(
EncomspClientContext* context, const ENCOMSP_PARTICIPANT_REMOVED_PDU* participantRemoved);
typedef UINT (*pcEncomspChangeParticipantControlLevel)(
EncomspClientContext* context,
const ENCOMSP_CHANGE_PARTICIPANT_CONTROL_LEVEL_PDU* changeParticipantControlLevel);
typedef UINT (*pcEncomspGraphicsStreamPaused)(
EncomspClientContext* context,
const ENCOMSP_GRAPHICS_STREAM_PAUSED_PDU* graphicsStreamPaused);
typedef UINT (*pcEncomspGraphicsStreamResumed)(
EncomspClientContext* context,
const ENCOMSP_GRAPHICS_STREAM_RESUMED_PDU* graphicsStreamResumed);
struct s_encomsp_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcEncomspFilterUpdated FilterUpdated;
WINPR_ATTR_NODISCARD pcEncomspApplicationCreated ApplicationCreated;
WINPR_ATTR_NODISCARD pcEncomspApplicationRemoved ApplicationRemoved;
WINPR_ATTR_NODISCARD pcEncomspWindowCreated WindowCreated;
WINPR_ATTR_NODISCARD pcEncomspWindowRemoved WindowRemoved;
WINPR_ATTR_NODISCARD pcEncomspShowWindow ShowWindow;
WINPR_ATTR_NODISCARD pcEncomspParticipantCreated ParticipantCreated;
WINPR_ATTR_NODISCARD pcEncomspParticipantRemoved ParticipantRemoved;
WINPR_ATTR_NODISCARD pcEncomspChangeParticipantControlLevel ChangeParticipantControlLevel;
WINPR_ATTR_NODISCARD pcEncomspGraphicsStreamPaused GraphicsStreamPaused;
WINPR_ATTR_NODISCARD pcEncomspGraphicsStreamResumed GraphicsStreamResumed;
UINT32 participantId;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_ENCOMSP_CLIENT_ENCOMSP_H */

124
third_party/FreeRDP/include/freerdp/client/file.h vendored Normal file
View File

@@ -0,0 +1,124 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* .rdp file
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CLIENT_RDP_FILE_H
#define FREERDP_CLIENT_RDP_FILE_H
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/settings.h>
/* Ignore invalid integer values */
#define RDP_FILE_FLAG_PARSE_INT_RELAXED 1
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct rdp_file rdpFile;
typedef BOOL (*rdp_file_fkt_parse)(void* context, const char* key, char type,
const char* value);
/* When using freerdp_client_parse_rdp_file_ex or freerdp_client_parse_rdp_file_buffer_ex
* set the context for the callback with this function. */
FREERDP_API void freerdp_client_rdp_file_set_callback_context(rdpFile* file, void* context);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_parse_rdp_file(rdpFile* file, const char* name);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_parse_rdp_file_ex(rdpFile* file, const char* name,
rdp_file_fkt_parse parse);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_parse_rdp_file_buffer(rdpFile* file, const BYTE* buffer,
size_t size);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_parse_rdp_file_buffer_ex(rdpFile* file, const BYTE* buffer,
size_t size, rdp_file_fkt_parse parse);
/** @brief Populate \b settings from RDP \b file. Do only notify about inconsistencies and not
* correct them.
*
* @param file A pointer to the RDP file to use
* @param settings A pointer to the settings to update
*
* @return \b TRUE for success, \b FALSE otherwise
* @version since 3.17.0
*/
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_populate_settings_from_rdp_file_unchecked(
const rdpFile* file, rdpSettings* settings);
/** @brief Populate \b settings from RDP \b file. Do correct inconsistencies detected.
*
* @param file A pointer to the RDP file to use
* @param settings A pointer to the settings to update
*
* @return \b TRUE for success, \b FALSE otherwise
*/
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_populate_settings_from_rdp_file(const rdpFile* file,
rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_populate_rdp_file_from_settings(rdpFile* file,
const rdpSettings* settings);
WINPR_ATTR_NODISCARD
FREERDP_API BOOL freerdp_client_write_rdp_file(const rdpFile* file, const char* name,
BOOL unicode);
WINPR_ATTR_NODISCARD
FREERDP_API size_t freerdp_client_write_rdp_file_buffer(const rdpFile* file, char* buffer,
size_t size);
WINPR_ATTR_NODISCARD
FREERDP_API int freerdp_client_rdp_file_set_string_option(rdpFile* file, const char* name,
const char* value);
WINPR_ATTR_NODISCARD
FREERDP_API const char* freerdp_client_rdp_file_get_string_option(const rdpFile* file,
const char* name);
WINPR_ATTR_NODISCARD
FREERDP_API int freerdp_client_rdp_file_set_integer_option(rdpFile* file, const char* name,
int value);
WINPR_ATTR_NODISCARD
FREERDP_API int freerdp_client_rdp_file_get_integer_option(const rdpFile* file,
const char* name);
FREERDP_API void freerdp_client_rdp_file_free(rdpFile* file);
WINPR_ATTR_MALLOC(freerdp_client_rdp_file_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_API rdpFile* freerdp_client_rdp_file_new(void);
WINPR_ATTR_MALLOC(freerdp_client_rdp_file_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_API rdpFile* freerdp_client_rdp_file_new_ex(DWORD flags);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CLIENT_RDP_FILE_H */

76
third_party/FreeRDP/include/freerdp/client/geometry.h vendored Normal file
View File

@@ -0,0 +1,76 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Geometry tracking Virtual Channel Extension
*
* Copyright 2017 David Fort <contact@hardening-consulting.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNELS_CLIENT_GEOMETRY_H
#define FREERDP_CHANNELS_CLIENT_GEOMETRY_H
#include <winpr/collections.h>
#include <freerdp/api.h>
#include <freerdp/channels/geometry.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct s_geometry_client_context GeometryClientContext;
typedef struct S_MAPPED_GEOMETRY MAPPED_GEOMETRY;
typedef BOOL (*pcMappedGeometryAdded)(GeometryClientContext* context,
MAPPED_GEOMETRY* geometry);
typedef BOOL (*pcMappedGeometryUpdate)(MAPPED_GEOMETRY* geometry);
typedef BOOL (*pcMappedGeometryClear)(MAPPED_GEOMETRY* geometry);
/** @brief a geometry record tracked by the geometry channel */
struct S_MAPPED_GEOMETRY
{
volatile LONG refCounter;
UINT64 mappingId;
UINT64 topLevelId;
INT32 left, top, right, bottom;
INT32 topLevelLeft, topLevelTop, topLevelRight, topLevelBottom;
FREERDP_RGNDATA geometry;
void* custom;
WINPR_ATTR_NODISCARD pcMappedGeometryUpdate MappedGeometryUpdate;
WINPR_ATTR_NODISCARD pcMappedGeometryClear MappedGeometryClear;
};
/** @brief the geometry context for client channel */
struct s_geometry_client_context
{
wHashTable* geometries;
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcMappedGeometryAdded MappedGeometryAdded;
UINT32 remoteVersion;
};
FREERDP_API void mappedGeometryRef(MAPPED_GEOMETRY* g);
FREERDP_API void mappedGeometryUnref(MAPPED_GEOMETRY* g);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNELS_CLIENT_GEOMETRY_H */

107
third_party/FreeRDP/include/freerdp/client/location.h vendored Normal file
View File

@@ -0,0 +1,107 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Location Virtual Channel Extension
*
* Copyright 2024 Armin Novak <anovak@thincast.com>
* Copyright 2024 Thincast Technologies GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_LOCATION_CLIENT_LOCATION_H
#define FREERDP_CHANNEL_LOCATION_CLIENT_LOCATION_H
#include <freerdp/channels/location.h>
/** @file
* @since version 3.4.0
*/
#ifdef __cplusplus
extern "C"
{
#endif
/** @since version 3.4.0 */
typedef struct s_location_client_context LocationClientContext;
/** @since version 3.4.0 */
typedef UINT (*pcLocationStart)(LocationClientContext* context, UINT32 version, UINT32 flags);
/** @since version 3.4.0 */
typedef UINT (*pcLocationStop)(LocationClientContext* context);
/** @since version 3.4.0 */
typedef UINT (*pcLocationSend)(LocationClientContext* context, LOCATION_PDUTYPE type,
size_t count, ...);
/** @since version 3.4.0 */
struct s_location_client_context
{
void* handle;
void* custom;
/**! \brief initialize location services on client
*
* \param context The client context to operate on
* \param version The location channel version (determines which features are available.
* \param flags The location channel flags.
*
* \return \b CHANNEL_RC_OK for success, an appropriate error otherwise.
*/
WINPR_ATTR_NODISCARD pcLocationStart LocationStart;
/**! \brief stop location services on client
*
* \param context The client context to operate on
*
* \return \b CHANNEL_RC_OK for success, an appropriate error otherwise.
*/
WINPR_ATTR_NODISCARD pcLocationStop LocationStop;
/**! \brief Send a location update.
*
* This function sends location updates to a server.
* The following parameter formats are supported:
*
* \param type one of the following:
* PDUTYPE_BASE_LOCATION3D : count = 3 | 7
* latitude : double, required
* longitude : double, required
* altitude : INT32, required
* speed : double, optional
* heading : double, optional
* horizontalAccuracy : double, optional
* source : int, optional
* PDUTYPE_LOCATION2D_DELTA : count = 2 | 4
* latitudeDelta : double, required
* longitudeDelta : double, required
* speedDelta : double, optional
* headingDelta : double, optional
* PDUTYPE_LOCATION3D_DELTA : count = 3 | 5
* latitudeDelta : double, required
* longitudeDelta : double, required
* altitudeDelta : INT32, optional
* speedDelta : double, optional
* headingDelta : double, optional
* \param count the number of variable arguments following
*
* return \b CHANNEL_RC_OK for success, an appropriate error otherwise.
*/
WINPR_ATTR_NODISCARD pcLocationSend LocationSend;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_LOCATION_CLIENT_LOCATION_H */

89
third_party/FreeRDP/include/freerdp/client/printer.h vendored Normal file
View File

@@ -0,0 +1,89 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Print Virtual Channel
*
* Copyright 2010-2011 Vic Lee
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
* Copyright 2016 Armin Novak <armin.novak@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_PRINTER_CLIENT_PRINTER_H
#define FREERDP_CHANNEL_PRINTER_CLIENT_PRINTER_H
#include <freerdp/channels/rdpdr.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct rdp_printer_driver rdpPrinterDriver;
typedef struct rdp_printer rdpPrinter;
typedef struct rdp_print_job rdpPrintJob;
typedef void (*pcReferencePrinterDriver)(rdpPrinterDriver* driver);
typedef rdpPrinter** (*pcEnumPrinters)(rdpPrinterDriver* driver);
typedef void (*pcReleaseEnumPrinters)(rdpPrinter** printers);
typedef rdpPrinter* (*pcGetPrinter)(rdpPrinterDriver* driver, const char* name,
const char* driverName, BOOL isDefault);
typedef void (*pcReferencePrinter)(rdpPrinter* printer);
struct rdp_printer_driver
{
WINPR_ATTR_NODISCARD pcEnumPrinters EnumPrinters;
pcReleaseEnumPrinters ReleaseEnumPrinters;
WINPR_ATTR_NODISCARD pcGetPrinter GetPrinter;
pcReferencePrinterDriver AddRef;
pcReferencePrinterDriver ReleaseRef;
};
typedef rdpPrintJob* (*pcCreatePrintJob)(rdpPrinter* printer, UINT32 id);
typedef rdpPrintJob* (*pcFindPrintJob)(rdpPrinter* printer, UINT32 id);
struct rdp_printer
{
size_t id;
char* name;
char* driver;
BOOL is_default;
size_t references;
rdpPrinterDriver* backend;
WINPR_ATTR_NODISCARD pcCreatePrintJob CreatePrintJob;
WINPR_ATTR_NODISCARD pcFindPrintJob FindPrintJob;
pcReferencePrinter AddRef;
pcReferencePrinter ReleaseRef;
};
typedef UINT (*pcWritePrintJob)(rdpPrintJob* printjob, const BYTE* data, size_t size);
typedef void (*pcClosePrintJob)(rdpPrintJob* printjob);
struct rdp_print_job
{
UINT32 id;
rdpPrinter* printer;
WINPR_ATTR_NODISCARD pcWritePrintJob Write;
pcClosePrintJob Close;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_PRINTER_CLIENT_PRINTER_H */

144
third_party/FreeRDP/include/freerdp/client/rail.h vendored Normal file
View File

@@ -0,0 +1,144 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Remote Applications Integrated Locally (RAIL)
*
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_RAIL_CLIENT_RAIL_H
#define FREERDP_CHANNEL_RAIL_CLIENT_RAIL_H
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/rail.h>
#include <freerdp/message.h>
#include <freerdp/channels/rail.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct s_rail_client_context RailClientContext;
typedef UINT (*pcRailOnOpen)(RailClientContext* context, BOOL* sendHandshake);
typedef UINT (*pcRailClientExecute)(RailClientContext* context, const RAIL_EXEC_ORDER* exec);
typedef UINT (*pcRailClientActivate)(RailClientContext* context,
const RAIL_ACTIVATE_ORDER* activate);
typedef UINT (*pcRailClientSystemParam)(RailClientContext* context,
const RAIL_SYSPARAM_ORDER* sysparam);
typedef UINT (*pcRailServerSystemParam)(RailClientContext* context,
const RAIL_SYSPARAM_ORDER* sysparam);
typedef UINT (*pcRailClientSystemCommand)(RailClientContext* context,
const RAIL_SYSCOMMAND_ORDER* syscommand);
typedef UINT (*pcRailClientHandshake)(RailClientContext* context,
const RAIL_HANDSHAKE_ORDER* handshake);
typedef UINT (*pcRailServerHandshake)(RailClientContext* context,
const RAIL_HANDSHAKE_ORDER* handshake);
typedef UINT (*pcRailServerHandshakeEx)(RailClientContext* context,
const RAIL_HANDSHAKE_EX_ORDER* handshakeEx);
typedef UINT (*pcRailClientNotifyEvent)(RailClientContext* context,
const RAIL_NOTIFY_EVENT_ORDER* notifyEvent);
typedef UINT (*pcRailClientWindowMove)(RailClientContext* context,
const RAIL_WINDOW_MOVE_ORDER* windowMove);
typedef UINT (*pcRailServerLocalMoveSize)(RailClientContext* context,
const RAIL_LOCALMOVESIZE_ORDER* localMoveSize);
typedef UINT (*pcRailServerMinMaxInfo)(RailClientContext* context,
const RAIL_MINMAXINFO_ORDER* minMaxInfo);
typedef UINT (*pcRailClientInformation)(RailClientContext* context,
const RAIL_CLIENT_STATUS_ORDER* clientStatus);
typedef UINT (*pcRailClientSystemMenu)(RailClientContext* context,
const RAIL_SYSMENU_ORDER* sysmenu);
typedef UINT (*pcRailServerTaskBarInfo)(RailClientContext* context,
const RAIL_TASKBAR_INFO_ORDER* taskBarInfo);
typedef UINT (*pcRailClientLanguageBarInfo)(RailClientContext* context,
const RAIL_LANGBAR_INFO_ORDER* langBarInfo);
typedef UINT (*pcRailServerLanguageBarInfo)(RailClientContext* context,
const RAIL_LANGBAR_INFO_ORDER* langBarInfo);
typedef UINT (*pcRailClientLanguageIMEInfo)(RailClientContext* context,
const RAIL_LANGUAGEIME_INFO_ORDER* langImeInfo);
typedef UINT (*pcRailServerExecuteResult)(RailClientContext* context,
const RAIL_EXEC_RESULT_ORDER* execResult);
typedef UINT (*pcRailClientGetAppIdRequest)(RailClientContext* context,
const RAIL_GET_APPID_REQ_ORDER* getAppIdReq);
typedef UINT (*pcRailServerGetAppIdResponse)(RailClientContext* context,
const RAIL_GET_APPID_RESP_ORDER* getAppIdResp);
typedef UINT (*pcRailServerZOrderSync)(RailClientContext* context,
const RAIL_ZORDER_SYNC* zorder);
typedef UINT (*pcRailServerCloak)(RailClientContext* context, const RAIL_CLOAK* cloak);
typedef UINT (*pcRailClientCloak)(RailClientContext* context, const RAIL_CLOAK* cloak);
typedef UINT (*pcRailServerPowerDisplayRequest)(RailClientContext* context,
const RAIL_POWER_DISPLAY_REQUEST* power);
typedef UINT (*pcRailClientSnapArrange)(RailClientContext* context,
const RAIL_SNAP_ARRANGE* snap);
typedef UINT (*pcRailServerGetAppidResponseExtended)(RailClientContext* context,
const RAIL_GET_APPID_RESP_EX* id);
typedef UINT (*pcRailClientCompartmentInfo)(RailClientContext* context,
const RAIL_COMPARTMENT_INFO_ORDER* compartmentInfo);
typedef UINT (*pcRailClientTextScale)(RailClientContext* context, UINT32 TextScale);
typedef UINT (*pcRailClientCaretBlinkRate)(RailClientContext* context, UINT32 CaretBlinkRate);
struct s_rail_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcRailClientExecute ClientExecute;
WINPR_ATTR_NODISCARD pcRailClientActivate ClientActivate;
WINPR_ATTR_NODISCARD pcRailClientSystemParam ClientSystemParam;
WINPR_ATTR_NODISCARD pcRailServerSystemParam ServerSystemParam;
WINPR_ATTR_NODISCARD pcRailClientSystemCommand ClientSystemCommand;
WINPR_ATTR_NODISCARD pcRailClientHandshake ClientHandshake;
WINPR_ATTR_NODISCARD pcRailServerHandshake ServerHandshake;
WINPR_ATTR_NODISCARD pcRailServerHandshakeEx ServerHandshakeEx;
WINPR_ATTR_NODISCARD pcRailClientNotifyEvent ClientNotifyEvent;
WINPR_ATTR_NODISCARD pcRailClientWindowMove ClientWindowMove;
WINPR_ATTR_NODISCARD pcRailServerLocalMoveSize ServerLocalMoveSize;
WINPR_ATTR_NODISCARD pcRailServerMinMaxInfo ServerMinMaxInfo;
WINPR_ATTR_NODISCARD pcRailClientInformation ClientInformation;
WINPR_ATTR_NODISCARD pcRailClientSystemMenu ClientSystemMenu;
WINPR_ATTR_NODISCARD pcRailServerTaskBarInfo ServerTaskBarInfo;
WINPR_ATTR_NODISCARD pcRailClientLanguageBarInfo ClientLanguageBarInfo;
WINPR_ATTR_NODISCARD pcRailServerLanguageBarInfo ServerLanguageBarInfo;
WINPR_ATTR_NODISCARD pcRailClientLanguageIMEInfo ClientLanguageIMEInfo;
WINPR_ATTR_NODISCARD pcRailServerExecuteResult ServerExecuteResult;
WINPR_ATTR_NODISCARD pcRailClientGetAppIdRequest ClientGetAppIdRequest;
WINPR_ATTR_NODISCARD pcRailServerGetAppIdResponse ServerGetAppIdResponse;
WINPR_ATTR_NODISCARD pcRailServerZOrderSync ServerZOrderSync;
WINPR_ATTR_NODISCARD pcRailClientCloak ClientCloak;
WINPR_ATTR_NODISCARD pcRailServerCloak ServerCloak;
WINPR_ATTR_NODISCARD pcRailServerPowerDisplayRequest ServerPowerDisplayRequest;
WINPR_ATTR_NODISCARD pcRailClientSnapArrange ClientSnapArrange;
WINPR_ATTR_NODISCARD pcRailServerGetAppidResponseExtended ServerGetAppidResponseExtended;
WINPR_ATTR_NODISCARD pcRailClientCompartmentInfo ClientCompartmentInfo;
WINPR_ATTR_NODISCARD pcRailOnOpen OnOpen;
WINPR_ATTR_NODISCARD pcRailClientTextScale ClientTextScale;
WINPR_ATTR_NODISCARD pcRailClientCaretBlinkRate ClientCaretBlinkRate;
};
WINPR_ATTR_NODISCARD
FREERDP_API UINT client_rail_server_start_cmd(RailClientContext* context);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_RAIL_CLIENT_RAIL_H */

98
third_party/FreeRDP/include/freerdp/client/rdpdr.h vendored Normal file
View File

@@ -0,0 +1,98 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Device Redirection Virtual Channel Extension
*
* Copyright 2025 Armin Novak <anovak@thincast.com>
* Copyright 2025 Thincast Technologies GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_RDPDR_CLIENT_H
#define FREERDP_CHANNEL_RDPDR_CLIENT_H
#include <freerdp/channels/rdpdr.h>
#ifdef __cplusplus
extern "C"
{
#endif
/** @enum RdpdrHotplugEventType
* @brief Hotplug event types.
*
* @since version 3.16.0
*/
typedef enum
{
RDPDR_HOTPLUG_FIRST_CHECK,
RDPDR_HOTPLUG_CHECK_FOR_CHANGES
} RdpdrHotplugEventType;
typedef struct s_rdpdr_client_context RdpdrClientContext;
/** @brief register a new device and announce it to remote
*
* @param context The \ref RdpdrClientContext to operate on.
* @param device A pointer to a \ref RDPDR_DEVICE struct to register. Contents is copied.
* @param pid A pointer to a variable that will be set to a unique identifier for that device.
*
* @return \ref CHANNEL_RC_OK for success or an appropriate error code otherwise.
*
* @since version 3.16.0
*/
typedef UINT (*pcRdpdrRegisterDevice)(RdpdrClientContext* context, const RDPDR_DEVICE* device,
uint32_t* pid);
/** @brief unregister a new device and announce it to remote
*
* @param context The \ref RdpdrClientContext to operate on.
* @param count The number of uintptr_t id unique identifiers for a device (see \ref
* pcRdpdrRegisterDevice) following
*
* @return \ref CHANNEL_RC_OK for success or an appropriate error code otherwise.
* @since version 3.16.0
*/
typedef UINT (*pcRdpdrUnregisterDevice)(RdpdrClientContext* context, size_t count,
const uint32_t ids[]);
/** @brief Check for device changes and announce it to remote
*
* @param context The \ref RdpdrClientContext to operate on.
* @param type The event type.
*
* @return \ref CHANNEL_RC_OK for success or an appropriate error code otherwise.
* @since version 3.16.0
*/
typedef UINT (*pcRdpdrHotplugDevice)(RdpdrClientContext* context, RdpdrHotplugEventType type);
/** @struct s_rdpdr_client_context
* @brief rdpdr channel client context
*
* @since version 3.16.0
*/
struct s_rdpdr_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcRdpdrRegisterDevice RdpdrRegisterDevice;
WINPR_ATTR_NODISCARD pcRdpdrUnregisterDevice RdpdrUnregisterDevice;
WINPR_ATTR_NODISCARD pcRdpdrHotplugDevice RdpdrHotplugDevice;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_RDPDR_CLIENT_H */

110
third_party/FreeRDP/include/freerdp/client/rdpei.h vendored Normal file
View File

@@ -0,0 +1,110 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Dynamic Virtual Channel Extension
*
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_RDPEI_CLIENT_RDPEI_H
#define FREERDP_CHANNEL_RDPEI_CLIENT_RDPEI_H
#include <freerdp/channels/rdpei.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct s_rdpei_client_context RdpeiClientContext;
typedef UINT32 (*pcRdpeiGetVersion)(RdpeiClientContext* context);
typedef UINT32 (*pcRdpeiGetFeatures)(RdpeiClientContext* context);
typedef UINT (*pcRdpeiAddContact)(RdpeiClientContext* context,
const RDPINPUT_CONTACT_DATA* contact);
typedef UINT (*pcRdpeiTouchEvent)(RdpeiClientContext* context, INT32 externalId, INT32 x,
INT32 y, INT32* contactId);
typedef UINT (*pcRdpeiTouchRawEvent)(RdpeiClientContext* context, INT32 externalId, INT32 x,
INT32 y, INT32* contactId, UINT32 contactFlags,
UINT32 fieldFlags, ...);
typedef UINT (*pcRdpeiTouchRawEventVA)(RdpeiClientContext* context, INT32 externalId, INT32 x,
INT32 y, INT32* contactId, UINT32 contactFlags,
UINT32 fieldFlags, va_list args);
typedef UINT (*pcRdpeiAddPen)(RdpeiClientContext* context, INT32 externalId,
const RDPINPUT_PEN_CONTACT* contact);
typedef UINT (*pcRdpeiPen)(RdpeiClientContext* context, INT32 externalId, UINT32 fieldFlags,
INT32 x, INT32 y, ...);
typedef UINT (*pcRdpeiPenRawEvent)(RdpeiClientContext* context, INT32 externalId,
UINT32 contactFlags, UINT32 fieldFlags, INT32 x, INT32 y,
...);
typedef UINT (*pcRdpeiPenRawEventVA)(RdpeiClientContext* context, INT32 externalId,
UINT32 contactFlags, UINT32 fieldFlags, INT32 x, INT32 y,
va_list args);
typedef UINT (*pcRdpeiSuspendTouch)(RdpeiClientContext* context);
typedef UINT (*pcRdpeiResumeTouch)(RdpeiClientContext* context);
struct s_rdpei_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcRdpeiGetVersion GetVersion;
WINPR_ATTR_NODISCARD pcRdpeiGetFeatures GetFeatures;
WINPR_ATTR_NODISCARD pcRdpeiAddContact AddContact;
WINPR_ATTR_NODISCARD pcRdpeiTouchEvent TouchBegin;
WINPR_ATTR_NODISCARD pcRdpeiTouchEvent TouchUpdate;
WINPR_ATTR_NODISCARD pcRdpeiTouchEvent TouchEnd;
WINPR_ATTR_NODISCARD pcRdpeiAddPen AddPen;
WINPR_ATTR_NODISCARD pcRdpeiPen PenBegin;
WINPR_ATTR_NODISCARD pcRdpeiPen PenUpdate;
WINPR_ATTR_NODISCARD pcRdpeiPen PenEnd;
WINPR_ATTR_NODISCARD pcRdpeiPen PenHoverBegin;
WINPR_ATTR_NODISCARD pcRdpeiPen PenHoverUpdate;
WINPR_ATTR_NODISCARD pcRdpeiPen PenHoverCancel;
WINPR_ATTR_NODISCARD pcRdpeiSuspendTouch SuspendTouch;
WINPR_ATTR_NODISCARD pcRdpeiResumeTouch ResumeTouch;
WINPR_ATTR_NODISCARD pcRdpeiTouchEvent TouchCancel;
WINPR_ATTR_NODISCARD pcRdpeiTouchRawEvent TouchRawEvent;
WINPR_ATTR_NODISCARD pcRdpeiTouchRawEventVA TouchRawEventVA;
WINPR_ATTR_NODISCARD pcRdpeiPen PenCancel;
WINPR_ATTR_NODISCARD pcRdpeiPenRawEvent PenRawEvent;
WINPR_ATTR_NODISCARD pcRdpeiPenRawEventVA PenRawEventVA;
UINT32 clientFeaturesMask;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_RDPEI_CLIENT_RDPEI_H */

190
third_party/FreeRDP/include/freerdp/client/rdpgfx.h vendored Normal file
View File

@@ -0,0 +1,190 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Graphics Pipeline Extension
*
* Copyright 2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_RDPGFX_CLIENT_RDPGFX_H
#define FREERDP_CHANNEL_RDPGFX_CLIENT_RDPGFX_H
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/codecs.h>
#include <freerdp/channels/rdpgfx.h>
#include <freerdp/utils/profiler.h>
#include <freerdp/cache/persistent.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct gdi_gfx_surface gdiGfxSurface;
typedef struct s_rdpgfx_client_context RdpgfxClientContext;
typedef UINT (*pcRdpgfxResetGraphics)(RdpgfxClientContext* context,
const RDPGFX_RESET_GRAPHICS_PDU* resetGraphics);
typedef UINT (*pcRdpgfxStartFrame)(RdpgfxClientContext* context,
const RDPGFX_START_FRAME_PDU* startFrame);
typedef UINT (*pcRdpgfxEndFrame)(RdpgfxClientContext* context,
const RDPGFX_END_FRAME_PDU* endFrame);
typedef UINT (*pcRdpgfxSurfaceCommand)(RdpgfxClientContext* context,
const RDPGFX_SURFACE_COMMAND* cmd);
typedef UINT (*pcRdpgfxDeleteEncodingContext)(
RdpgfxClientContext* context,
const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext);
typedef UINT (*pcRdpgfxCreateSurface)(RdpgfxClientContext* context,
const RDPGFX_CREATE_SURFACE_PDU* createSurface);
typedef UINT (*pcRdpgfxDeleteSurface)(RdpgfxClientContext* context,
const RDPGFX_DELETE_SURFACE_PDU* deleteSurface);
typedef UINT (*pcRdpgfxSolidFill)(RdpgfxClientContext* context,
const RDPGFX_SOLID_FILL_PDU* solidFill);
typedef UINT (*pcRdpgfxSurfaceToSurface)(RdpgfxClientContext* context,
const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface);
typedef UINT (*pcRdpgfxSurfaceToCache)(RdpgfxClientContext* context,
const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache);
typedef UINT (*pcRdpgfxCacheToSurface)(RdpgfxClientContext* context,
const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface);
typedef UINT (*pcRdpgfxCacheImportOffer)(RdpgfxClientContext* context,
const RDPGFX_CACHE_IMPORT_OFFER_PDU* cacheImportOffer);
typedef UINT (*pcRdpgfxCacheImportReply)(RdpgfxClientContext* context,
const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply);
typedef UINT (*pcRdpgfxEvictCacheEntry)(RdpgfxClientContext* context,
const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry);
typedef UINT (*pcRdpgfxImportCacheEntry)(RdpgfxClientContext* context, UINT16 cacheSlot,
const PERSISTENT_CACHE_ENTRY* importCacheEntry);
typedef UINT (*pcRdpgfxExportCacheEntry)(RdpgfxClientContext* context, UINT16 cacheSlot,
PERSISTENT_CACHE_ENTRY* importCacheEntry);
typedef UINT (*pcRdpgfxMapSurfaceToOutput)(
RdpgfxClientContext* context, const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput);
typedef UINT (*pcRdpgfxMapSurfaceToScaledOutput)(
RdpgfxClientContext* context,
const RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU* surfaceToOutput);
typedef UINT (*pcRdpgfxMapSurfaceToWindow)(
RdpgfxClientContext* context, const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow);
typedef UINT (*pcRdpgfxMapSurfaceToScaledWindow)(
RdpgfxClientContext* context,
const RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU* surfaceToWindow);
typedef UINT (*pcRdpgfxSetSurfaceData)(RdpgfxClientContext* context, UINT16 surfaceId,
void* pData);
typedef void* (*pcRdpgfxGetSurfaceData)(RdpgfxClientContext* context, UINT16 surfaceId);
typedef UINT (*pcRdpgfxGetSurfaceIds)(RdpgfxClientContext* context, UINT16** ppSurfaceIds,
UINT16* count);
typedef UINT (*pcRdpgfxSetCacheSlotData)(RdpgfxClientContext* context, UINT16 cacheSlot,
void* pData);
typedef void* (*pcRdpgfxGetCacheSlotData)(RdpgfxClientContext* context, UINT16 cacheSlot);
typedef UINT (*pcRdpgfxUpdateSurfaces)(RdpgfxClientContext* context);
typedef UINT (*pcRdpgfxUpdateWindowFromSurface)(RdpgfxClientContext* context,
gdiGfxSurface* surface);
typedef UINT (*pcRdpgfxUpdateSurfaceArea)(RdpgfxClientContext* context, UINT16 surfaceId,
UINT32 nrRects, const RECTANGLE_16* rects);
typedef UINT (*pcRdpgfxOnOpen)(RdpgfxClientContext* context, BOOL* do_caps_advertise,
BOOL* do_frame_acks);
typedef UINT (*pcRdpgfxOnClose)(RdpgfxClientContext* context);
typedef UINT (*pcRdpgfxCapsAdvertise)(RdpgfxClientContext* context,
const RDPGFX_CAPS_ADVERTISE_PDU* capsAdvertise);
typedef UINT (*pcRdpgfxCapsConfirm)(RdpgfxClientContext* context,
const RDPGFX_CAPS_CONFIRM_PDU* capsConfirm);
typedef UINT (*pcRdpgfxFrameAcknowledge)(RdpgfxClientContext* context,
const RDPGFX_FRAME_ACKNOWLEDGE_PDU* frameAcknowledge);
typedef UINT (*pcRdpgfxQoeFrameAcknowledge)(
RdpgfxClientContext* context, const RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU* qoeFrameAcknowledge);
typedef UINT (*pcRdpgfxMapWindowForSurface)(RdpgfxClientContext* context, UINT16 surfaceID,
UINT64 windowID);
typedef UINT (*pcRdpgfxUnmapWindowForSurface)(RdpgfxClientContext* context, UINT64 windowID);
struct s_rdpgfx_client_context
{
void* handle;
void* custom;
/* Implementations require locking */
WINPR_ATTR_NODISCARD pcRdpgfxResetGraphics ResetGraphics;
WINPR_ATTR_NODISCARD pcRdpgfxStartFrame StartFrame;
WINPR_ATTR_NODISCARD pcRdpgfxEndFrame EndFrame;
WINPR_ATTR_NODISCARD pcRdpgfxSurfaceCommand SurfaceCommand;
WINPR_ATTR_NODISCARD pcRdpgfxDeleteEncodingContext DeleteEncodingContext;
WINPR_ATTR_NODISCARD pcRdpgfxCreateSurface CreateSurface;
WINPR_ATTR_NODISCARD pcRdpgfxDeleteSurface DeleteSurface;
WINPR_ATTR_NODISCARD pcRdpgfxSolidFill SolidFill;
WINPR_ATTR_NODISCARD pcRdpgfxSurfaceToSurface SurfaceToSurface;
WINPR_ATTR_NODISCARD pcRdpgfxSurfaceToCache SurfaceToCache;
WINPR_ATTR_NODISCARD pcRdpgfxCacheToSurface CacheToSurface;
WINPR_ATTR_NODISCARD pcRdpgfxCacheImportOffer CacheImportOffer;
WINPR_ATTR_NODISCARD pcRdpgfxCacheImportReply CacheImportReply;
WINPR_ATTR_NODISCARD pcRdpgfxImportCacheEntry ImportCacheEntry;
WINPR_ATTR_NODISCARD pcRdpgfxExportCacheEntry ExportCacheEntry;
WINPR_ATTR_NODISCARD pcRdpgfxEvictCacheEntry EvictCacheEntry;
WINPR_ATTR_NODISCARD pcRdpgfxMapSurfaceToOutput MapSurfaceToOutput;
WINPR_ATTR_NODISCARD pcRdpgfxMapSurfaceToScaledOutput MapSurfaceToScaledOutput;
WINPR_ATTR_NODISCARD pcRdpgfxMapSurfaceToWindow MapSurfaceToWindow;
WINPR_ATTR_NODISCARD pcRdpgfxMapSurfaceToScaledWindow MapSurfaceToScaledWindow;
WINPR_ATTR_NODISCARD pcRdpgfxGetSurfaceIds GetSurfaceIds;
WINPR_ATTR_NODISCARD pcRdpgfxSetSurfaceData SetSurfaceData;
WINPR_ATTR_NODISCARD pcRdpgfxGetSurfaceData GetSurfaceData;
WINPR_ATTR_NODISCARD pcRdpgfxSetCacheSlotData SetCacheSlotData;
WINPR_ATTR_NODISCARD pcRdpgfxGetCacheSlotData GetCacheSlotData;
/* Proxy callbacks */
WINPR_ATTR_NODISCARD pcRdpgfxOnOpen OnOpen;
WINPR_ATTR_NODISCARD pcRdpgfxOnClose OnClose;
WINPR_ATTR_NODISCARD pcRdpgfxCapsAdvertise CapsAdvertise;
WINPR_ATTR_NODISCARD pcRdpgfxCapsConfirm CapsConfirm;
WINPR_ATTR_NODISCARD pcRdpgfxFrameAcknowledge FrameAcknowledge;
WINPR_ATTR_NODISCARD pcRdpgfxQoeFrameAcknowledge QoeFrameAcknowledge;
/* No locking required */
WINPR_ATTR_NODISCARD pcRdpgfxUpdateSurfaces UpdateSurfaces;
WINPR_ATTR_NODISCARD pcRdpgfxUpdateSurfaceArea UpdateSurfaceArea;
WINPR_ATTR_NODISCARD pcRdpgfxUpdateWindowFromSurface UpdateWindowFromSurface;
/* These callbacks allow creating/destroying a window directly
* mapped to a surface.
* NOTE: The surface is already locked.
*/
WINPR_ATTR_NODISCARD pcRdpgfxMapWindowForSurface MapWindowForSurface;
WINPR_ATTR_NODISCARD pcRdpgfxUnmapWindowForSurface UnmapWindowForSurface;
CRITICAL_SECTION mux;
rdpCodecs* codecs;
PROFILER_DEFINE(SurfaceProfiler)
};
FREERDP_API void rdpgfx_client_context_free(RdpgfxClientContext* context);
WINPR_ATTR_MALLOC(rdpgfx_client_context_free, 1)
WINPR_ATTR_NODISCARD
FREERDP_API RdpgfxClientContext* rdpgfx_client_context_new(rdpContext* context);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_RDPGFX_CLIENT_RDPGFX_H */

92
third_party/FreeRDP/include/freerdp/client/rdpsnd.h vendored Normal file
View File

@@ -0,0 +1,92 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Audio Output Virtual Channel
*
* Copyright 2010-2011 Vic Lee
* Copyright 2012-2013 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_RDPSND_CLIENT_RDPSND_H
#define FREERDP_CHANNEL_RDPSND_CLIENT_RDPSND_H
#include <freerdp/channels/rdpsnd.h>
#include <freerdp/settings.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Subsystem Interface
*/
typedef struct rdpsnd_plugin rdpsndPlugin;
typedef struct rdpsnd_device_plugin rdpsndDevicePlugin;
typedef BOOL (*pcFormatSupported)(rdpsndDevicePlugin* device, const AUDIO_FORMAT* format);
typedef BOOL (*pcOpen)(rdpsndDevicePlugin* device, const AUDIO_FORMAT* format, UINT32 latency);
typedef UINT32 (*pcGetVolume)(rdpsndDevicePlugin* device);
typedef BOOL (*pcSetVolume)(rdpsndDevicePlugin* device, UINT32 value);
typedef UINT (*pcPlay)(rdpsndDevicePlugin* device, const BYTE* data, size_t size);
typedef UINT (*pcPlayEx)(rdpsndDevicePlugin* device, const AUDIO_FORMAT* format,
const BYTE* data, size_t size);
typedef void (*pcStart)(rdpsndDevicePlugin* device);
typedef void (*pcClose)(rdpsndDevicePlugin* device);
typedef void (*pcFree)(rdpsndDevicePlugin* device);
typedef BOOL (*pcDefaultFormat)(rdpsndDevicePlugin* device, const AUDIO_FORMAT* desired,
AUDIO_FORMAT* defaultFormat);
typedef UINT (*pcServerFormatAnnounce)(rdpsndDevicePlugin* device, const AUDIO_FORMAT* formats,
size_t count);
struct rdpsnd_device_plugin
{
rdpsndPlugin* rdpsnd;
WINPR_ATTR_NODISCARD pcFormatSupported FormatSupported;
WINPR_ATTR_NODISCARD pcOpen Open;
WINPR_ATTR_NODISCARD pcGetVolume GetVolume;
WINPR_ATTR_NODISCARD pcSetVolume SetVolume;
WINPR_ATTR_NODISCARD pcPlay Play;
pcStart Start; /* Deprecated, unused. */
pcClose Close;
pcFree Free;
WINPR_ATTR_NODISCARD pcDefaultFormat DefaultFormat;
WINPR_ATTR_NODISCARD pcServerFormatAnnounce ServerFormatAnnounce;
WINPR_ATTR_NODISCARD pcPlayEx PlayEx;
};
#define RDPSND_DEVICE_EXPORT_FUNC_NAME "freerdp_rdpsnd_client_subsystem_entry"
typedef void (*PREGISTERRDPSNDDEVICE)(rdpsndPlugin* rdpsnd, rdpsndDevicePlugin* device);
typedef struct
{
rdpsndPlugin* rdpsnd;
PREGISTERRDPSNDDEVICE pRegisterRdpsndDevice;
const ADDIN_ARGV* args;
} FREERDP_RDPSND_DEVICE_ENTRY_POINTS;
typedef FREERDP_RDPSND_DEVICE_ENTRY_POINTS* PFREERDP_RDPSND_DEVICE_ENTRY_POINTS;
typedef UINT(VCAPITYPE* PFREERDP_RDPSND_DEVICE_ENTRY)(
PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints);
WINPR_ATTR_NODISCARD
FREERDP_API rdpContext* freerdp_rdpsnd_get_context(rdpsndPlugin* plugin);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_RDPSND_CLIENT_RDPSND_H */

44
third_party/FreeRDP/include/freerdp/client/remdesk.h vendored Normal file
View File

@@ -0,0 +1,44 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Remote Assistance Virtual Channel
*
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_REMDESK_CLIENT_REMDESK_H
#define FREERDP_CHANNEL_REMDESK_CLIENT_REMDESK_H
#include <freerdp/channels/remdesk.h>
#ifdef __cplusplus
extern "C"
{
#endif
/**
* Client Interface
*/
typedef struct
{
void* handle;
void* custom;
} RemdeskClientContext;
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_REMDESK_CLIENT_REMDESK_H */

95
third_party/FreeRDP/include/freerdp/client/sshagent.h vendored Normal file
View File

@@ -0,0 +1,95 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* SSH Agent Virtual Channel Extension
*
* Copyright 2017 Ben Cohen
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNEL_CLIENT_SSHAGENT_H
#define FREERDP_CHANNEL_CLIENT_SSHAGENT_H
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/message.h>
#include <freerdp/channels/cliprdr.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct
{
int ProtocolVersion;
int MaxConnections;
} SSHAgentClientContext;
/*
* The channel is defined by the sshagent channel in xrdp as follows.
*
* Server to client commands
* -------------------------
*
* Capabilities (at start of channel stream):
*
* INT32 SA_TAG_CAPABILITY
* INT32 SSHAGENT_CHAN_PROT_VERSION := 1
* INT32 SSHAGENT_MAX_CONNECTIONS
*
* Open connection:
*
* INT32 SA_TAG_OPEN
* INT32 Connection id (0, ..., SSHAGENT_MAX_CONNECTIONS - 1)
*
* Send data:
*
* INT32 SA_TAG_WRITE
* INT32 Connection id (0, ..., SSHAGENT_MAX_CONNECTIONS - 1)
* INT32 Data length
* DATA ...
*
* Close connection:
*
* INT32 SA_TAG_CLOSE
* INT32 Connection id (0, ..., SSHAGENT_MAX_CONNECTIONS - 1)
*
* Client to server commands
* -------------------------
*
* Capabilities (in reply to server capabilities):
*
* INT32 SA_TAG_CAPABILITY
* INT32 SSHAGENT_CHAN_PROT_VERSION := 1
* INT32 SSHAGENT_MAX_CONNECTIONS
*
* Send data:
*
* INT32 SA_TAG_WRITE
* INT32 Connection id (0, ..., SSHAGENT_MAX_CONNECTIONS - 1)
* INT32 Data length
* DATA ...
*
* Close connection (abnormal):
*
* INT32 SA_TAG_CLOSE
* INT32 Connection id (0, ..., SSHAGENT_MAX_CONNECTIONS - 1)
*/
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_CLIENT_SSHAGENT_H */

79
third_party/FreeRDP/include/freerdp/client/tsmf.h vendored Normal file
View File

@@ -0,0 +1,79 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Multimedia Redirection Virtual Channel Types
*
* Copyright 2011 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* DEPRECATION WARNING:
*
* This channel is unmaintained and not used since windows 7.
* Only compile and use it if absolutely necessary, otherwise
* deactivate it or use the newer [MS-RDPEVOR] video redirection.
*/
#ifndef FREERDP_CHANNEL_TSMF_CLIENT_TSMF_H
#define FREERDP_CHANNEL_TSMF_CLIENT_TSMF_H
#include <freerdp/codec/region.h>
#include <freerdp/channels/tsmf.h>
/* RDP_VIDEO_FRAME_EVENT.frame_pixfmt */
/* http://www.fourcc.org/yuv.php */
#define RDP_PIXFMT_I420 0x30323449
#define RDP_PIXFMT_YV12 0x32315659
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct
{
BYTE* frameData;
UINT32 frameSize;
UINT32 framePixFmt;
INT16 frameWidth;
INT16 frameHeight;
INT16 x;
INT16 y;
INT16 width;
INT16 height;
UINT16 numVisibleRects;
RECTANGLE_16* visibleRects;
} TSMF_VIDEO_FRAME_EVENT;
/**
* Client Interface
*/
typedef struct s_tsmf_client_context TsmfClientContext;
typedef int (*pcTsmfFrameEvent)(TsmfClientContext* context, TSMF_VIDEO_FRAME_EVENT* event);
struct s_tsmf_client_context
{
void* handle;
void* custom;
WINPR_ATTR_NODISCARD pcTsmfFrameEvent FrameEvent;
};
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNEL_TSMF_CLIENT_TSMF_H */

37
third_party/FreeRDP/include/freerdp/client/utils/smartcard_cli.h vendored Normal file
View File

@@ -0,0 +1,37 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Smartcard client functions
*
* Copyright 2021 David Fort <contact@hardening-consulting.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UTILS_SMARTCARD_CLI_H__
#define UTILS_SMARTCARD_CLI_H__
#include <freerdp/api.h>
#include <freerdp/settings.h>
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
FREERDP_API BOOL freerdp_smartcard_list(const rdpSettings* settings);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* UTILS_SMARTCARD_CLI_H__ */

75
third_party/FreeRDP/include/freerdp/client/video.h vendored Normal file
View File

@@ -0,0 +1,75 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Video Optimized Remoting Virtual Channel Extension
*
* Copyright 2017 David Fort <contact@hardening-consulting.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_CHANNELS_CLIENT_VIDEO_H
#define FREERDP_CHANNELS_CLIENT_VIDEO_H
#include <freerdp/client/geometry.h>
#include <freerdp/channels/video.h>
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct s_VideoClientContext VideoClientContext;
typedef struct s_VideoClientContextPriv VideoClientContextPriv;
/** @brief an implementation of surface used by the video channel */
typedef struct
{
UINT32 x, y, w, h;
UINT32 alignedWidth, alignedHeight;
BYTE* data;
DWORD format;
UINT32 scanline;
} VideoSurface;
typedef void (*pcVideoTimer)(VideoClientContext* video, UINT64 now);
typedef void (*pcVideoSetGeometry)(VideoClientContext* video, GeometryClientContext* geometry);
typedef VideoSurface* (*pcVideoCreateSurface)(VideoClientContext* video, UINT32 x, UINT32 y,
UINT32 width, UINT32 height);
typedef BOOL (*pcVideoShowSurface)(VideoClientContext* video, const VideoSurface* surface,
UINT32 destinationWidth, UINT32 destinationHeight);
typedef BOOL (*pcVideoDeleteSurface)(VideoClientContext* video, VideoSurface* surface);
/** @brief context for the video (MS-RDPEVOR) channel */
struct s_VideoClientContext
{
void* handle;
void* custom;
VideoClientContextPriv* priv;
pcVideoSetGeometry setGeometry;
pcVideoTimer timer;
WINPR_ATTR_NODISCARD pcVideoCreateSurface createSurface;
WINPR_ATTR_NODISCARD pcVideoShowSurface showSurface;
pcVideoDeleteSurface deleteSurface;
};
WINPR_ATTR_NODISCARD
FREERDP_API VideoSurface* VideoClient_CreateCommonContext(size_t size, UINT32 x, UINT32 y,
UINT32 w, UINT32 h);
FREERDP_API void VideoClient_DestroyCommonContext(VideoSurface* surface);
#ifdef __cplusplus
}
#endif
#endif /* FREERDP_CHANNELS_CLIENT_VIDEO_H */