include/freerdp/settings.h

 
#ifndef FREERDP_SETTINGS_H
#define FREERDP_SETTINGS_H
 
#include <winpr/timezone.h>
#include <winpr/wlog.h>
 
#include <freerdp/api.h>
#include <freerdp/config.h>
#include <freerdp/types.h>
#include <freerdp/redirection.h>
 
#if !defined(WITH_OPAQUE_SETTINGS)
#include <freerdp/settings_types_private.h>
#endif
 
#include <freerdp/settings_keys.h>
#include <freerdp/settings_types.h>
 
#include <freerdp/crypto/certificate.h>
#include <freerdp/crypto/privatekey.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef struct rdp_settings rdpSettings;
 
#define FREERDP_SETTINGS_SERVER_MODE 0x00000001
#define FREERDP_SETTINGS_REMOTE_MODE 0x00000002
 
  FREERDP_API void freerdp_settings_free(rdpSettings* settings);
 
  WINPR_ATTR_MALLOC(freerdp_settings_free, 1)
  FREERDP_API rdpSettings* freerdp_settings_new(DWORD flags);
 
  WINPR_ATTR_MALLOC(freerdp_settings_free, 1)
  FREERDP_API rdpSettings* freerdp_settings_clone(const rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_settings_copy(rdpSettings* dst, const rdpSettings* src);
 
  FREERDP_API BOOL freerdp_settings_copy_item(rdpSettings* dst, const rdpSettings* src,
                                              SSIZE_T id);
 
  FREERDP_API void freerdp_settings_dump(wLog* log, DWORD level, const rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_settings_print_diff(wLog* log, DWORD level, const rdpSettings* src,
                                               const rdpSettings* other);
 
  FREERDP_API void freerdp_addin_argv_free(ADDIN_ARGV* args);
 
  WINPR_ATTR_MALLOC(freerdp_addin_argv_free, 1)
  FREERDP_API ADDIN_ARGV* freerdp_addin_argv_new(size_t argc, const char* const argv[]);
 
  WINPR_ATTR_MALLOC(freerdp_addin_argv_free, 1)
  FREERDP_API ADDIN_ARGV* freerdp_addin_argv_clone(const ADDIN_ARGV* args);
 
  FREERDP_API BOOL freerdp_addin_argv_add_argument(ADDIN_ARGV* args, const char* argument);
  FREERDP_API BOOL freerdp_addin_argv_add_argument_ex(ADDIN_ARGV* args, const char* argument,
                                                      size_t len);
  FREERDP_API BOOL freerdp_addin_argv_del_argument(ADDIN_ARGV* args, const char* argument);
 
  FREERDP_API int freerdp_addin_set_argument(ADDIN_ARGV* args, const char* argument);
  FREERDP_API int freerdp_addin_replace_argument(ADDIN_ARGV* args, const char* previous,
                                                 const char* argument);
  FREERDP_API int freerdp_addin_set_argument_value(ADDIN_ARGV* args, const char* option,
                                                   const char* value);
  FREERDP_API int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, const char* previous,
                                                       const char* option, const char* value);
 
  FREERDP_API BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device);
 
  FREERDP_API BOOL freerdp_device_collection_del(rdpSettings* settings,
                                                 const RDPDR_DEVICE* device);
  FREERDP_API RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings,
                                                           const char* name);
  FREERDP_API RDPDR_DEVICE* freerdp_device_collection_find_type(rdpSettings* settings,
                                                                UINT32 type);
 
  FREERDP_API void freerdp_device_free(RDPDR_DEVICE* device);
 
  WINPR_ATTR_MALLOC(freerdp_device_free, 1)
  FREERDP_API RDPDR_DEVICE* freerdp_device_new(UINT32 Type, size_t count,
                                               const char* const args[]);
 
  WINPR_ATTR_MALLOC(freerdp_device_free, 1)
  FREERDP_API RDPDR_DEVICE* freerdp_device_clone(const RDPDR_DEVICE* device);
 
  FREERDP_API BOOL freerdp_device_equal(const RDPDR_DEVICE* one, const RDPDR_DEVICE* other);
 
  FREERDP_API void freerdp_device_collection_free(rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_static_channel_collection_add(rdpSettings* settings,
                                                         ADDIN_ARGV* channel);
  FREERDP_API BOOL freerdp_static_channel_collection_del(rdpSettings* settings, const char* name);
  FREERDP_API ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings,
                                                                 const char* name);
#if defined(WITH_FREERDP_DEPRECATED)
  WINPR_DEPRECATED(FREERDP_API ADDIN_ARGV* freerdp_static_channel_clone(ADDIN_ARGV* channel));
#endif
 
  FREERDP_API void freerdp_static_channel_collection_free(rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings,
                                                          ADDIN_ARGV* channel);
  FREERDP_API BOOL freerdp_dynamic_channel_collection_del(rdpSettings* settings,
                                                          const char* name);
  FREERDP_API ADDIN_ARGV* freerdp_dynamic_channel_collection_find(const rdpSettings* settings,
                                                                  const char* name);
 
#if defined(WITH_FREERDP_DEPRECATED)
  WINPR_DEPRECATED(FREERDP_API ADDIN_ARGV* freerdp_dynamic_channel_clone(ADDIN_ARGV* channel));
#endif
 
  FREERDP_API void freerdp_dynamic_channel_collection_free(rdpSettings* settings);
  FREERDP_API void freerdp_capability_buffer_free(rdpSettings* settings);
  FREERDP_API BOOL freerdp_capability_buffer_copy(rdpSettings* settings, const rdpSettings* src);
 
  FREERDP_API void freerdp_server_license_issuers_free(rdpSettings* settings);
  FREERDP_API BOOL freerdp_server_license_issuers_copy(rdpSettings* settings, char** addresses,
                                                       UINT32 count);
 
  FREERDP_API void freerdp_target_net_addresses_free(rdpSettings* settings);
  FREERDP_API BOOL freerdp_target_net_addresses_copy(rdpSettings* settings, char** addresses,
                                                     UINT32 count);
 
  FREERDP_API void freerdp_performance_flags_make(rdpSettings* settings);
  FREERDP_API void freerdp_performance_flags_split(rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_set_gateway_usage_method(rdpSettings* settings,
                                                    UINT32 GatewayUsageMethod);
  FREERDP_API void freerdp_update_gateway_usage_method(rdpSettings* settings,
                                                       UINT32 GatewayEnabled,
                                                       UINT32 GatewayBypassLocal);
 
  /* DEPRECATED:
   * the functions freerdp_get_param_* and freerdp_set_param_* are deprecated.
   * use freerdp_settings_get_* and freerdp_settings_set_* as a replacement!
   */
#if defined(WITH_FREERDP_DEPRECATED)
  WINPR_DEPRECATED_VAR("Use freerdp_settings_get_bool instead",
                       FREERDP_API BOOL freerdp_get_param_bool(const rdpSettings* settings,
                                                               int id));
  WINPR_DEPRECATED_VAR("Use freerdp_settings_set_bool instead",
                       FREERDP_API int freerdp_set_param_bool(rdpSettings* settings, int id,
                                                              BOOL param));
 
  WINPR_DEPRECATED_VAR("Use freerdp_settings_get_int[16|32] instead",
                       FREERDP_API int freerdp_get_param_int(const rdpSettings* settings,
                                                             int id));
  WINPR_DEPRECATED_VAR("Use freerdp_settings_set_int[16|32] instead",
                       FREERDP_API int freerdp_set_param_int(rdpSettings* settings, int id,
                                                             int param));
 
  WINPR_DEPRECATED_VAR("Use freerdp_settings_set_uint32 instead",
                       FREERDP_API UINT32 freerdp_get_param_uint32(const rdpSettings* settings,
                                                                   int id));
  WINPR_DEPRECATED_VAR("Use freerdp_settings_set_uint32 instead",
                       FREERDP_API int freerdp_set_param_uint32(rdpSettings* settings, int id,
                                                                UINT32 param));
 
  WINPR_DEPRECATED_VAR("Use freerdp_settings_get_uint64 instead",
                       FREERDP_API UINT64 freerdp_get_param_uint64(const rdpSettings* settings,
                                                                   int id));
  WINPR_DEPRECATED_VAR("Use freerdp_settings_set_uint64 instead",
                       FREERDP_API int freerdp_set_param_uint64(rdpSettings* settings, int id,
                                                                UINT64 param));
 
  WINPR_DEPRECATED_VAR("Use freerdp_settings_get_string instead",
                       FREERDP_API char* freerdp_get_param_string(const rdpSettings* settings,
                                                                  int id));
  WINPR_DEPRECATED_VAR("Use freerdp_settings_set_string instead",
                       FREERDP_API int freerdp_set_param_string(rdpSettings* settings, int id,
                                                                const char* param));
#endif
 
  FREERDP_API BOOL freerdp_settings_are_valid(const rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings* settings,
                                             FreeRDP_Settings_Keys_Bool id);
 
  FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings* settings, FreeRDP_Settings_Keys_Bool id,
                                             BOOL param);
 
  FREERDP_API INT16 freerdp_settings_get_int16(const rdpSettings* settings,
                                               FreeRDP_Settings_Keys_Int16 id);
 
  FREERDP_API BOOL freerdp_settings_set_int16(rdpSettings* settings,
                                              FreeRDP_Settings_Keys_Int16 id, INT16 param);
 
  FREERDP_API UINT16 freerdp_settings_get_uint16(const rdpSettings* settings,
                                                 FreeRDP_Settings_Keys_UInt16 id);
 
  FREERDP_API BOOL freerdp_settings_set_uint16(rdpSettings* settings,
                                               FreeRDP_Settings_Keys_UInt16 id, UINT16 param);
 
  FREERDP_API INT32 freerdp_settings_get_int32(const rdpSettings* settings,
                                               FreeRDP_Settings_Keys_Int32 id);
 
  FREERDP_API BOOL freerdp_settings_set_int32(rdpSettings* settings,
                                              FreeRDP_Settings_Keys_Int32 id, INT32 param);
 
  FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings* settings,
                                                 FreeRDP_Settings_Keys_UInt32 id);
 
  FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings* settings,
                                               FreeRDP_Settings_Keys_UInt32 id, UINT32 param);
 
  FREERDP_API INT64 freerdp_settings_get_int64(const rdpSettings* settings,
                                               FreeRDP_Settings_Keys_Int64 id);
 
  FREERDP_API BOOL freerdp_settings_set_int64(rdpSettings* settings,
                                              FreeRDP_Settings_Keys_Int64 id, INT64 param);
 
  FREERDP_API UINT64 freerdp_settings_get_uint64(const rdpSettings* settings,
                                                 FreeRDP_Settings_Keys_UInt64 id);
 
  FREERDP_API BOOL freerdp_settings_set_uint64(rdpSettings* settings,
                                               FreeRDP_Settings_Keys_UInt64 id, UINT64 param);
 
  FREERDP_API const char* freerdp_settings_get_string(const rdpSettings* settings,
                                                      FreeRDP_Settings_Keys_String id);
 
  FREERDP_API char* freerdp_settings_get_string_writable(rdpSettings* settings,
                                                         FreeRDP_Settings_Keys_String id);
 
  FREERDP_API BOOL freerdp_settings_set_string_len(rdpSettings* settings,
                                                   FreeRDP_Settings_Keys_String id,
                                                   const char* param, size_t len);
 
  FREERDP_API BOOL freerdp_settings_set_string(rdpSettings* settings,
                                               FreeRDP_Settings_Keys_String id,
                                               const char* param);
 
  FREERDP_API BOOL freerdp_settings_append_string(rdpSettings* settings,
                                                  FreeRDP_Settings_Keys_String id,
                                                  const char* separator, const char* param);
 
  FREERDP_API BOOL freerdp_settings_set_string_from_utf16(rdpSettings* settings,
                                                          FreeRDP_Settings_Keys_String id,
                                                          const WCHAR* param);
 
  FREERDP_API BOOL freerdp_settings_set_string_from_utf16N(rdpSettings* settings,
                                                           FreeRDP_Settings_Keys_String id,
                                                           const WCHAR* param, size_t length);
  FREERDP_API WCHAR* freerdp_settings_get_string_as_utf16(const rdpSettings* settings,
                                                          FreeRDP_Settings_Keys_String id,
                                                          size_t* pCharLen);
 
  FREERDP_API const void* freerdp_settings_get_pointer(const rdpSettings* settings,
                                                       FreeRDP_Settings_Keys_Pointer id);
 
  FREERDP_API void* freerdp_settings_get_pointer_writable(rdpSettings* settings,
                                                          FreeRDP_Settings_Keys_Pointer id);
 
  FREERDP_API BOOL freerdp_settings_set_pointer(rdpSettings* settings,
                                                FreeRDP_Settings_Keys_Pointer id,
                                                const void* data);
 
  FREERDP_API BOOL freerdp_settings_set_pointer_len(rdpSettings* settings,
                                                    FreeRDP_Settings_Keys_Pointer id,
                                                    const void* data, size_t len);
 
  FREERDP_API const void* freerdp_settings_get_pointer_array(const rdpSettings* settings,
                                                             FreeRDP_Settings_Keys_Pointer id,
                                                             size_t offset);
  FREERDP_API void* freerdp_settings_get_pointer_array_writable(const rdpSettings* settings,
                                                                FreeRDP_Settings_Keys_Pointer id,
                                                                size_t offset);
  FREERDP_API BOOL freerdp_settings_set_pointer_array(rdpSettings* settings,
                                                      FreeRDP_Settings_Keys_Pointer id,
                                                      size_t offset, const void* data);
 
  FREERDP_API BOOL freerdp_settings_set_value_for_name(rdpSettings* settings, const char* name,
                                                       const char* value);
 
  FREERDP_API SSIZE_T freerdp_settings_get_key_for_name(const char* value);
 
  FREERDP_API SSIZE_T freerdp_settings_get_type_for_name(const char* value);
 
  FREERDP_API SSIZE_T freerdp_settings_get_type_for_key(SSIZE_T key);
 
  FREERDP_API const char* freerdp_settings_get_type_name_for_key(SSIZE_T key);
 
  FREERDP_API const char* freerdp_settings_get_type_name_for_type(SSIZE_T type);
 
  FREERDP_API const char* freerdp_settings_get_name_for_key(SSIZE_T key);
 
  FREERDP_API UINT32 freerdp_settings_get_codecs_flags(const rdpSettings* settings);
 
  FREERDP_API BOOL freerdp_settings_update_from_caps(rdpSettings* settings, const BYTE* capsFlags,
                                                     const BYTE** capsData,
                                                     const UINT32* capsSizes, UINT32 capsCount,
                                                     BOOL serverReceivedCaps);
 
  FREERDP_API const char* freerdp_settings_get_server_name(const rdpSettings* settings);
 
  FREERDP_API const char* freerdp_rail_support_flags_to_string(UINT32 flags, char* buffer,
                                                               size_t length);
 
  FREERDP_API const char* freerdp_rdp_version_string(UINT32 version);
 
  FREERDP_API const char* freerdp_rdpdr_dtyp_string(UINT32 type);
 
  FREERDP_API const char* freerdp_encryption_level_string(UINT32 EncryptionLevel);
  FREERDP_API const char* freerdp_encryption_methods_string(UINT32 EncryptionLevel, char* buffer,
                                                            size_t size);
 
  FREERDP_API const char* freerdp_supported_color_depths_string(UINT16 mask, char* buffer,
                                                                size_t size);
 
  WINPR_ATTR_MALLOC(free, 1)
  FREERDP_API char* freerdp_settings_get_config_path(void);
 
  FREERDP_API BOOL freerdp_settings_set_monitor_def_array_sorted(rdpSettings* settings,
                                                                 const rdpMonitor* monitors,
                                                                 size_t count);
 
#ifdef __cplusplus
}
#endif
 
#endif /* FREERDP_SETTINGS_H */