github/FreeRDP
7
0
Fork 0
mirror of https://github.com/FreeRDP/FreeRDP.git synced 2025-06-03 00:00:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added const to function arguments

Browse Source
This commit is contained in:
akallabeth 2020-11-18 07:51:45 +01:00 committed by akallabeth
parent d6db010fc4
commit e2fd9db0b5
45 changed files with 403 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
channels/audin/client/alsa/audin_alsa.c
View File

@ -350,7 +350,7 @@ static UINT audin_alsa_close(IAudinDevice* device)
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT audin_alsa_parse_addin_args(AudinALSADevice* device, ADDIN_ARGV* args)
static UINT audin_alsa_parse_addin_args(AudinALSADevice* device, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -403,7 +403,7 @@ static UINT audin_alsa_parse_addin_args(AudinALSADevice* device, ADDIN_ARGV* arg
*/
UINT freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
AudinALSADevice* alsa;
UINT error;
alsa = (AudinALSADevice*)calloc(1, sizeof(AudinALSADevice));

8
channels/audin/client/audin_main.c
View File

@ -107,7 +107,7 @@ struct _AUDIN_PLUGIN
BOOL initialized;
};
static BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, ADDIN_ARGV* args);
static BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, const ADDIN_ARGV* args);
static UINT audin_channel_write_and_free(AUDIN_CHANNEL_CALLBACK* callback, wStream* out,
BOOL freeStream)
@ -799,7 +799,7 @@ static UINT audin_register_device_plugin(IWTSPlugin* pPlugin, IAudinDevice* devi
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT audin_load_device_plugin(AUDIN_PLUGIN* audin, char* name, ADDIN_ARGV* args)
static UINT audin_load_device_plugin(AUDIN_PLUGIN* audin, const char* name, const ADDIN_ARGV* args)
{
PFREERDP_AUDIN_DEVICE_ENTRY entry;
FREERDP_AUDIN_DEVICE_ENTRY_POINTS entryPoints;
@ -868,7 +868,7 @@ static UINT audin_set_device_name(AUDIN_PLUGIN* audin, const char* device_name)
return CHANNEL_RC_OK;
}
BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, ADDIN_ARGV* args)
BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -973,7 +973,7 @@ UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
char* device;
};
UINT error = CHANNEL_RC_INITIALIZATION_ERROR;
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
AUDIN_PLUGIN* audin;
struct SubsystemEntry entries[] =
{

4
channels/audin/client/mac/audin_mac.m
View File

@ -319,7 +319,7 @@ static UINT audin_mac_free(IAudinDevice *device)
return CHANNEL_RC_OK;
}
static UINT audin_mac_parse_addin_args(AudinMacDevice *device, ADDIN_ARGV *args)
static UINT audin_mac_parse_addin_args(AudinMacDevice *device, const ADDIN_ARGV *args)
{
DWORD errCode;
char errString[1024];
@ -386,7 +386,7 @@ UINT freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEn
{
DWORD errCode;
char errString[1024];
ADDIN_ARGV *args;
const ADDIN_ARGV *args;
AudinMacDevice *mac;
UINT error;
mac = (AudinMacDevice *)calloc(1, sizeof(AudinMacDevice));

6
channels/audin/client/opensles/audin_opensl_es.c
View File

@ -215,7 +215,7 @@ static UINT audin_opensles_open(IAudinDevice* device, AudinReceive receive, void
opensles->user_data = user_data;
return CHANNEL_RC_OK;
error_out:
audin_opensles_close(opensles);
audin_opensles_close(device);
return ERROR_INTERNAL_ERROR;
}
@ -244,7 +244,7 @@ UINT audin_opensles_close(IAudinDevice* device)
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT audin_opensles_parse_addin_args(AudinOpenSLESDevice* device, ADDIN_ARGV* args)
static UINT audin_opensles_parse_addin_args(AudinOpenSLESDevice* device, const ADDIN_ARGV* args)
{
UINT status;
DWORD flags;
@ -301,7 +301,7 @@ static UINT audin_opensles_parse_addin_args(AudinOpenSLESDevice* device, ADDIN_A
*/
UINT freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
AudinOpenSLESDevice* opensles;
UINT error;
opensles = (AudinOpenSLESDevice*)calloc(1, sizeof(AudinOpenSLESDevice));

4
channels/audin/client/oss/audin_oss.c
View File

@ -380,7 +380,7 @@ static UINT audin_oss_free(IAudinDevice* device)
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT audin_oss_parse_addin_args(AudinOSSDevice* device, ADDIN_ARGV* args)
static UINT audin_oss_parse_addin_args(AudinOSSDevice* device, const ADDIN_ARGV* args)
{
int status;
char *str_num, *eptr;
@ -453,7 +453,7 @@ static UINT audin_oss_parse_addin_args(AudinOSSDevice* device, ADDIN_ARGV* args)
*/
UINT freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
AudinOSSDevice* oss;
UINT error;
oss = (AudinOSSDevice*)calloc(1, sizeof(AudinOSSDevice));

4
channels/audin/client/pulse/audin_pulse.c
View File

@ -462,7 +462,7 @@ static UINT audin_pulse_open(IAudinDevice* device, AudinReceive receive, void* u
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT audin_pulse_parse_addin_args(AudinPulseDevice* device, ADDIN_ARGV* args)
static UINT audin_pulse_parse_addin_args(AudinPulseDevice* device, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -516,7 +516,7 @@ static UINT audin_pulse_parse_addin_args(AudinPulseDevice* device, ADDIN_ARGV* a
*/
UINT freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
AudinPulseDevice* pulse;
UINT error;
pulse = (AudinPulseDevice*)calloc(1, sizeof(AudinPulseDevice));

7
channels/drdynvc/client/drdynvc_main.c
View File

@ -167,7 +167,7 @@ static IWTSPlugin* dvcman_get_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const
return plugin;
}
static ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
static const ADDIN_ARGV* dvcman_get_plugin_data(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
{
return ((DVCMAN_ENTRY_POINTS*)pEntryPoints)->args;
}
@ -280,7 +280,7 @@ fail:
* @return 0 on success, otherwise a Win32 error code
*/
static UINT dvcman_load_addin(drdynvcPlugin* drdynvc, IWTSVirtualChannelManager* pChannelMgr,
ADDIN_ARGV* args, rdpSettings* settings)
const ADDIN_ARGV* args, rdpSettings* settings)
{
DVCMAN_ENTRY_POINTS entryPoints;
PDVC_PLUGIN_ENTRY pDVCPluginEntry = NULL;
@ -1485,7 +1485,6 @@ static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVO
UINT error;
UINT32 status;
UINT32 index;
ADDIN_ARGV* args;
rdpSettings* settings;
WINPR_UNUSED(pData);
@ -1509,7 +1508,7 @@ static UINT drdynvc_virtual_channel_event_connected(drdynvcPlugin* drdynvc, LPVO
for (index = 0; index < settings->DynamicChannelCount; index++)
{
args = settings->DynamicChannelArray[index];
const ADDIN_ARGV* args = settings->DynamicChannelArray[index];
error = dvcman_load_addin(drdynvc, drdynvc->channel_mgr, args, settings);
if (CHANNEL_RC_OK != error)

2
channels/drdynvc/client/drdynvc_main.h
View File

@ -68,7 +68,7 @@ struct _DVCMAN_ENTRY_POINTS
IDRDYNVC_ENTRY_POINTS iface;
DVCMAN* dvcman;
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
rdpSettings* settings;
};
typedef struct _DVCMAN_ENTRY_POINTS DVCMAN_ENTRY_POINTS;

3
channels/printer/client/printer_main.c
View File

@ -78,7 +78,8 @@ static const char* filemap[] = { "PortDosName", "PnPName", "DriverName",
static char* get_printer_config_path(const rdpSettings* settings, const WCHAR* name, size_t length)
{
char* dir = GetCombinedPath(settings->ConfigPath, "printers");
const char* path = settings->ConfigPath;
char* dir = GetCombinedPath(path, "printers");
char* bname = crypto_base64_encode((const BYTE*)name, (int)length);
char* config = GetCombinedPath(dir, bname);

73
channels/rdp2tcp/client/rdp2tcp_main.c
View File

@ -44,6 +44,7 @@ typedef struct
void* initHandle;
CHANNEL_ENTRY_POINTS_FREERDP_EX channelEntryPoints;
char buffer[16 * 1024];
char* commandline;
} Plugin;
static int init_external_addin(Plugin* plugin)
@ -84,17 +85,18 @@ static int init_external_addin(Plugin* plugin)
}
// Execute plugin
if (!CreateProcess(NULL,
plugin->channelEntryPoints.pExtendedData, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
0, // creation flags
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&procInfo // receives PROCESS_INFORMATION
))
plugin->commandline = _strdup(plugin->channelEntryPoints.pExtendedData);
if (!CreateProcessA(NULL,
plugin->commandline, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
TRUE, // handles are inherited
0, // creation flags
NULL, // use parent's environment
NULL, // use parent's current directory
&siStartInfo, // STARTUPINFO pointer
&procInfo // receives PROCESS_INFORMATION
))
{
WLog_ERR(TAG, "fork for addin");
return -1;
@ -243,6 +245,33 @@ static void VCAPITYPE VirtualChannelOpenEventEx(LPVOID lpUserParam, DWORD openHa
}
}
static void channel_terminated(Plugin* plugin)
{
if (debug)
puts("rdp2tcp terminated");
if (!plugin)
return;
if (plugin->copyThread)
TerminateThread(plugin->copyThread, 0);
if (plugin->writeComplete)
CloseHandle(plugin->writeComplete);
CloseHandle(plugin->hStdInputWrite);
CloseHandle(plugin->hStdOutputRead);
TerminateProcess(plugin->hProcess, 0);
CloseHandle(plugin->hProcess);
free(plugin->commandline);
free(plugin);
}
static void channel_initialized(Plugin* plugin)
{
plugin->writeComplete = CreateEvent(NULL, TRUE, FALSE, NULL);
plugin->copyThread = CreateThread(NULL, 0, copyThread, plugin, 0, NULL);
}
static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInitHandle, UINT event,
LPVOID pData, UINT dataLength)
{
@ -250,13 +279,14 @@ static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInit
switch (event)
{
case CHANNEL_EVENT_INITIALIZED:
channel_initialized(plugin);
break;
case CHANNEL_EVENT_CONNECTED:
if (debug)
puts("rdp2tcp connected");
plugin->writeComplete = CreateEvent(NULL, TRUE, FALSE, NULL);
plugin->copyThread = CreateThread(NULL, 0, copyThread, plugin, 0, NULL);
if (plugin->channelEntryPoints.pVirtualChannelOpenEx(
pInitHandle, &plugin->openHandle, RDP2TCP_CHAN_NAME,
VirtualChannelOpenEventEx) != CHANNEL_RC_OK)
@ -271,20 +301,7 @@ static VOID VCAPITYPE VirtualChannelInitEventEx(LPVOID lpUserParam, LPVOID pInit
break;
case CHANNEL_EVENT_TERMINATED:
if (debug)
puts("rdp2tcp terminated");
if (plugin->copyThread)
{
TerminateThread(plugin->copyThread, 0);
CloseHandle(plugin->writeComplete);
}
CloseHandle(plugin->hStdInputWrite);
CloseHandle(plugin->hStdOutputRead);
TerminateProcess(plugin->hProcess, 0);
CloseHandle(plugin->hProcess);
free(plugin);
channel_terminated(plugin);
break;
}
}

6
channels/rdpsnd/client/alsa/rdpsnd_alsa.c
View File

@ -472,7 +472,7 @@ static UINT rdpsnd_alsa_play(rdpsndDevicePlugin* device, const BYTE* data, size_
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpsnd_alsa_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV* args)
static UINT rdpsnd_alsa_parse_addin_args(rdpsndDevicePlugin* device, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -525,7 +525,7 @@ static UINT rdpsnd_alsa_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV*
*/
UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
rdpsndAlsaPlugin* alsa;
UINT error;
alsa = (rdpsndAlsaPlugin*)calloc(1, sizeof(rdpsndAlsaPlugin));
@ -547,7 +547,7 @@ UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS p
if (args->argc > 1)
{
if ((error = rdpsnd_alsa_parse_addin_args((rdpsndDevicePlugin*)alsa, args)))
if ((error = rdpsnd_alsa_parse_addin_args(&alsa->device, args)))
{
WLog_ERR(TAG, "rdpsnd_alsa_parse_addin_args failed with error %" PRIu32 "", error);
goto error_parse_args;

4
channels/rdpsnd/client/fake/rdpsnd_fake.c
View File

@ -80,7 +80,7 @@ static UINT rdpsnd_fake_play(rdpsndDevicePlugin* device, const BYTE* data, size_
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpsnd_fake_parse_addin_args(rdpsndFakePlugin* fake, ADDIN_ARGV* args)
static UINT rdpsnd_fake_parse_addin_args(rdpsndFakePlugin* fake, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -120,7 +120,7 @@ static UINT rdpsnd_fake_parse_addin_args(rdpsndFakePlugin* fake, ADDIN_ARGV* arg
*/
UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
rdpsndFakePlugin* fake;
UINT ret = CHANNEL_RC_OK;
fake = (rdpsndFakePlugin*)calloc(1, sizeof(rdpsndFakePlugin));

13
channels/rdpsnd/client/oss/rdpsnd_oss.c
View File

@ -386,7 +386,7 @@ static UINT rdpsnd_oss_play(rdpsndDevicePlugin* device, const BYTE* data, size_t
return 10; /* TODO: Get real latency in [ms] */
}
static int rdpsnd_oss_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV* args)
static int rdpsnd_oss_parse_addin_args(rdpsndDevicePlugin* device, const ADDIN_ARGV* args)
{
int status;
char *str_num, *eptr;
@ -455,9 +455,8 @@ static int rdpsnd_oss_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV* a
*/
UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
rdpsndOssPlugin* oss;
oss = (rdpsndOssPlugin*)calloc(1, sizeof(rdpsndOssPlugin));
const ADDIN_ARGV* args;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)calloc(1, sizeof(rdpsndOssPlugin));
if (!oss)
return CHANNEL_RC_NO_MEMORY;
@ -473,7 +472,11 @@ UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS p
oss->mixer_handle = -1;
oss->dev_unit = -1;
args = pEntryPoints->args;
rdpsnd_oss_parse_addin_args((rdpsndDevicePlugin*)oss, args);
if (rdpsnd_oss_parse_addin_args(&oss->device, args) < 0)
{
free(oss);
return ERROR_INVALID_PARAMETER;
}
pEntryPoints->pRegisterRdpsndDevice(pEntryPoints->rdpsnd, (rdpsndDevicePlugin*)oss);
return CHANNEL_RC_OK;
}

2
channels/rdpsnd/client/proxy/rdpsnd_proxy.c
View File

@ -115,7 +115,7 @@ static UINT rdpsnd_proxy_play(rdpsndDevicePlugin* device, const BYTE* data, size
*/
UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
rdpsndProxyPlugin* proxy;
pClientContext* pc;
proxy = (rdpsndProxyPlugin*)calloc(1, sizeof(rdpsndProxyPlugin));

6
channels/rdpsnd/client/pulse/rdpsnd_pulse.c
View File

@ -535,7 +535,7 @@ static UINT rdpsnd_pulse_play(rdpsndDevicePlugin* device, const BYTE* data, size
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpsnd_pulse_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV* args)
static UINT rdpsnd_pulse_parse_addin_args(rdpsndDevicePlugin* device, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -585,7 +585,7 @@ static UINT rdpsnd_pulse_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV
*/
UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
rdpsndPulsePlugin* pulse;
UINT ret;
pulse = (rdpsndPulsePlugin*)calloc(1, sizeof(rdpsndPulsePlugin));
@ -605,7 +605,7 @@ UINT freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS p
if (args->argc > 1)
{
ret = rdpsnd_pulse_parse_addin_args((rdpsndDevicePlugin*)pulse, args);
ret = rdpsnd_pulse_parse_addin_args(&pulse->device, args);
if (ret != CHANNEL_RC_OK)
{

12
channels/rdpsnd/client/rdpsnd_main.c
View File

@ -796,7 +796,8 @@ static void rdpsnd_register_device_plugin(rdpsndPlugin* rdpsnd, rdpsndDevicePlug
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpsnd_load_device_plugin(rdpsndPlugin* rdpsnd, const char* name, ADDIN_ARGV* args)
static UINT rdpsnd_load_device_plugin(rdpsndPlugin* rdpsnd, const char* name,
const ADDIN_ARGV* args)
{
PFREERDP_RDPSND_DEVICE_ENTRY entry;
FREERDP_RDPSND_DEVICE_ENTRY_POINTS entryPoints;
@ -841,7 +842,7 @@ static BOOL rdpsnd_set_device_name(rdpsndPlugin* rdpsnd, const char* device_name
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpsnd_process_addin_args(rdpsndPlugin* rdpsnd, ADDIN_ARGV* args)
static UINT rdpsnd_process_addin_args(rdpsndPlugin* rdpsnd, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -990,10 +991,10 @@ static UINT rdpsnd_process_connect(rdpsndPlugin* rdpsnd)
#endif
{ "fake", "" }
};
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
UINT status = ERROR_INTERNAL_ERROR;
rdpsnd->latency = 0;
args = (ADDIN_ARGV*)rdpsnd->channelEntryPoints.pExtendedData;
args = (const ADDIN_ARGV*)rdpsnd->channelEntryPoints.pExtendedData;
if (args)
{
@ -1640,7 +1641,8 @@ UINT rdpsnd_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
goto fail;
rdpsnd->log = WLog_Get("com.freerdp.channels.rdpsnd.client");
rdpsnd->channelEntryPoints.pExtendedData = pEntryPoints->GetPluginData(pEntryPoints);
/* user data pointer is not const, cast to avoid warning. */
rdpsnd->channelEntryPoints.pExtendedData = (void*)pEntryPoints->GetPluginData(pEntryPoints);
error = pEntryPoints->RegisterPlugin(pEntryPoints, "rdpsnd", &rdpsnd->iface);
}

2
channels/remdesk/client/remdesk_main.c
View File

@ -334,7 +334,7 @@ static UINT remdesk_send_ctl_authenticate_pdu(remdeskPlugin* remdesk)
WCHAR* expertBlobW = NULL;
int cbRaConnectionStringW = 0;
WCHAR* raConnectionStringW = NULL;
REMDESK_CTL_AUTHENTICATE_PDU pdu;
REMDESK_CTL_AUTHENTICATE_PDU pdu = { 0 };
if ((error = remdesk_generate_expert_blob(remdesk)))
{

5
channels/tsmf/client/tsmf_main.c
View File

@ -497,7 +497,7 @@ static UINT tsmf_plugin_terminated(IWTSPlugin* pPlugin)
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT tsmf_process_addin_args(IWTSPlugin* pPlugin, ADDIN_ARGV* args)
static UINT tsmf_process_addin_args(IWTSPlugin* pPlugin, const ADDIN_ARGV* args)
{
int status;
DWORD flags;
@ -611,8 +611,7 @@ UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
if (status == CHANNEL_RC_OK)
{
status =
tsmf_process_addin_args((IWTSPlugin*)tsmf, pEntryPoints->GetPluginData(pEntryPoints));
status = tsmf_process_addin_args(&tsmf->iface, pEntryPoints->GetPluginData(pEntryPoints));
}
return status;

2
channels/urbdrc/client/libusb/libusb_udevice.c
View File

@ -1562,7 +1562,7 @@ static int udev_get_hub_handle(URBDRC_PLUGIN* urbdrc, libusb_context* ctx, UDEVI
error = 0;
WLog_Print(urbdrc->log, WLOG_DEBUG, " Port: %d", pdev->port_number);
/* gen device path */
sprintf(pdev->path, "%" PRIu16 "-%" PRIu16 "", bus_number, pdev->port_number);
sprintf(pdev->path, "%" PRIu16 "-%d", bus_number, pdev->port_number);
WLog_Print(urbdrc->log, WLOG_DEBUG, " DevPath: %s", pdev->path);
break;

6
channels/urbdrc/client/libusb/libusb_udevman.c
View File

@ -685,7 +685,7 @@ static BOOL urbdrc_udevman_register_devices(UDEVMAN* udevman, const char* device
':', '#'))
{
WLog_ERR(TAG, "Invalid device argument: \"%s\"", devices);
return COMMAND_LINE_ERROR_UNEXPECTED_VALUE;
return FALSE;
}
if (add_by_addr)
@ -714,7 +714,7 @@ static BOOL urbdrc_udevman_register_devices(UDEVMAN* udevman, const char* device
return CHANNEL_RC_OK;
}
static UINT urbdrc_udevman_parse_addin_args(UDEVMAN* udevman, ADDIN_ARGV* args)
static UINT urbdrc_udevman_parse_addin_args(UDEVMAN* udevman, const ADDIN_ARGV* args)
{
int status;
LPSTR devices = NULL;
@ -907,7 +907,7 @@ UINT freerdp_urbdrc_client_subsystem_entry(PFREERDP_URBDRC_SERVICE_ENTRY_POINTS
UINT rc;
UINT status;
UDEVMAN* udevman;
ADDIN_ARGV* args = pEntryPoints->args;
const ADDIN_ARGV* args = pEntryPoints->args;
udevman = (PUDEVMAN)calloc(1, sizeof(UDEVMAN));
if (!udevman)

4
channels/urbdrc/client/urbdrc_main.c
View File

@ -762,7 +762,7 @@ static BOOL urbdrc_register_udevman_addin(IWTSPlugin* pPlugin, IUDEVMAN* udevman
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT urbdrc_load_udevman_addin(IWTSPlugin* pPlugin, LPCSTR name, ADDIN_ARGV* args)
static UINT urbdrc_load_udevman_addin(IWTSPlugin* pPlugin, LPCSTR name, const ADDIN_ARGV* args)
{
URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*)pPlugin;
PFREERDP_URBDRC_DEVICE_ENTRY entry;
@ -949,7 +949,7 @@ BOOL del_device(IUDEVMAN* idevman, UINT32 flags, BYTE busnum, BYTE devnum, UINT1
UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
{
UINT status = 0;
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
URBDRC_PLUGIN* urbdrc;
urbdrc = (URBDRC_PLUGIN*)pEntryPoints->GetPlugin(pEntryPoints, URBDRC_CHANNEL_NAME);
args = pEntryPoints->GetPluginData(pEntryPoints);

2
channels/urbdrc/client/urbdrc_main.h
View File

@ -93,7 +93,7 @@ struct _FREERDP_URBDRC_SERVICE_ENTRY_POINTS
{
IWTSPlugin* plugin;
PREGISTERURBDRCSERVICE pRegisterUDEVMAN;
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
};
typedef struct _FREERDP_URBDRC_SERVICE_ENTRY_POINTS FREERDP_URBDRC_SERVICE_ENTRY_POINTS;
typedef FREERDP_URBDRC_SERVICE_ENTRY_POINTS* PFREERDP_URBDRC_SERVICE_ENTRY_POINTS;

2
include/freerdp/client/audin.h
View File

@ -51,7 +51,7 @@ struct _FREERDP_AUDIN_DEVICE_ENTRY_POINTS
{
IWTSPlugin* plugin;
PREGISTERAUDINDEVICE pRegisterAudinDevice;
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
rdpContext* rdpcontext;
};
typedef struct _FREERDP_AUDIN_DEVICE_ENTRY_POINTS FREERDP_AUDIN_DEVICE_ENTRY_POINTS;

2
include/freerdp/client/rdpsnd.h
View File

@ -66,7 +66,7 @@ struct _FREERDP_RDPSND_DEVICE_ENTRY_POINTS
{
rdpsndPlugin* rdpsnd;
PREGISTERRDPSNDDEVICE pRegisterRdpsndDevice;
ADDIN_ARGV* args;
const ADDIN_ARGV* args;
};
typedef struct _FREERDP_RDPSND_DEVICE_ENTRY_POINTS FREERDP_RDPSND_DEVICE_ENTRY_POINTS;
typedef FREERDP_RDPSND_DEVICE_ENTRY_POINTS* PFREERDP_RDPSND_DEVICE_ENTRY_POINTS;

28
include/freerdp/crypto/per.h
View File

@ -30,27 +30,29 @@ extern "C"
#endif
FREERDP_API BOOL per_read_length(wStream* s, UINT16* length);
FREERDP_API void per_write_length(wStream* s, int length);
FREERDP_API BOOL per_write_length(wStream* s, UINT16 length);
FREERDP_API BOOL per_read_choice(wStream* s, BYTE* choice);
FREERDP_API void per_write_choice(wStream* s, BYTE choice);
FREERDP_API BOOL per_write_choice(wStream* s, BYTE choice);
FREERDP_API BOOL per_read_selection(wStream* s, BYTE* selection);
FREERDP_API void per_write_selection(wStream* s, BYTE selection);
FREERDP_API BOOL per_write_selection(wStream* s, BYTE selection);
FREERDP_API BOOL per_read_number_of_sets(wStream* s, BYTE* number);
FREERDP_API void per_write_number_of_sets(wStream* s, BYTE number);
FREERDP_API BOOL per_read_padding(wStream* s, int length);
FREERDP_API void per_write_padding(wStream* s, int length);
FREERDP_API BOOL per_write_number_of_sets(wStream* s, BYTE number);
FREERDP_API BOOL per_read_padding(wStream* s, UINT16 length);
FREERDP_API BOOL per_write_padding(wStream* s, UINT16 length);
FREERDP_API BOOL per_read_integer(wStream* s, UINT32* integer);
FREERDP_API BOOL per_read_integer16(wStream* s, UINT16* integer, UINT16 min);
FREERDP_API void per_write_integer(wStream* s, UINT32 integer);
FREERDP_API void per_write_integer16(wStream* s, UINT16 integer, UINT16 min);
FREERDP_API BOOL per_write_integer(wStream* s, UINT32 integer);
FREERDP_API BOOL per_write_integer16(wStream* s, UINT16 integer, UINT16 min);
FREERDP_API BOOL per_read_enumerated(wStream* s, BYTE* enumerated, BYTE count);
FREERDP_API void per_write_enumerated(wStream* s, BYTE enumerated, BYTE count);
FREERDP_API void per_write_object_identifier(wStream* s, BYTE oid[6]);
FREERDP_API BOOL per_write_enumerated(wStream* s, BYTE enumerated, BYTE count);
FREERDP_API BOOL per_write_object_identifier(wStream* s, const BYTE oid[6]);
FREERDP_API BOOL per_read_object_identifier(wStream* s, BYTE oid[6]);
FREERDP_API BOOL per_read_octet_string(wStream* s, BYTE* oct_str, int length, int min);
FREERDP_API void per_write_octet_string(wStream* s, BYTE* oct_str, int length, int min);
FREERDP_API BOOL per_read_octet_string(wStream* s, BYTE* oct_str, UINT16 length, UINT16 min);
FREERDP_API BOOL per_write_octet_string(wStream* s, const BYTE* oct_str, UINT16 length,
UINT16 min);
FREERDP_API BOOL per_read_numeric_string(wStream* s, int min);
FREERDP_API void per_write_numeric_string(wStream* s, BYTE* num_str, int length, int min);
FREERDP_API BOOL per_write_numeric_string(wStream* s, const BYTE* num_str, UINT16 length,
UINT16 min);
#ifdef __cplusplus
}

2
include/freerdp/crypto/tls.h
View File

@ -77,7 +77,7 @@ struct rdp_tls
SecPkgContext_Bindings* Bindings;
rdpCertificateStore* certificate_store;
BIO* underlying;
char* hostname;
const char* hostname;
int port;
int alertLevel;
int alertDescription;

2
include/freerdp/dvc.h
View File

@ -145,7 +145,7 @@ struct _IDRDYNVC_ENTRY_POINTS
UINT(*RegisterPlugin)
(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name, IWTSPlugin* pPlugin);
IWTSPlugin* (*GetPlugin)(IDRDYNVC_ENTRY_POINTS* pEntryPoints, const char* name);
ADDIN_ARGV* (*GetPluginData)(IDRDYNVC_ENTRY_POINTS* pEntryPoints);
const ADDIN_ARGV* (*GetPluginData)(IDRDYNVC_ENTRY_POINTS* pEntryPoints);
void* (*GetRdpSettings)(IDRDYNVC_ENTRY_POINTS* pEntryPoints);
};

2
include/freerdp/utils/pcap.h
View File

@ -77,7 +77,7 @@ extern "C"
{
#endif
FREERDP_API rdpPcap* pcap_open(char* name, BOOL write);
FREERDP_API rdpPcap* pcap_open(const char* name, BOOL write);
FREERDP_API void pcap_close(rdpPcap* pcap);
FREERDP_API BOOL pcap_add_record(rdpPcap* pcap, const void* data, UINT32 length);

17
libfreerdp/core/certificate.c
View File

@ -661,7 +661,7 @@ static BOOL certificate_read_server_x509_certificate_chain(rdpCertificate* certi
* @param length certificate length
*/
BOOL certificate_read_server_certificate(rdpCertificate* certificate, BYTE* server_cert,
BOOL certificate_read_server_certificate(rdpCertificate* certificate, const BYTE* server_cert,
size_t length)
{
BOOL ret;
@ -671,7 +671,7 @@ BOOL certificate_read_server_certificate(rdpCertificate* certificate, BYTE* serv
if (length < 4) /* NULL certificate is not an error see #1795 */
return TRUE;
s = Stream_New(server_cert, length);
s = Stream_New((BYTE*)server_cert, length);
if (!s)
{
@ -859,9 +859,7 @@ rdpRsaKey* key_clone(const rdpRsaKey* key)
return _key;
out_fail:
free(_key->Modulus);
free(_key->PrivateExponent);
free(_key);
key_free(_key);
return NULL;
}
@ -947,14 +945,7 @@ rdpCertificate* certificate_clone(rdpCertificate* certificate)
return _certificate;
out_fail:
if (_certificate->x509_cert_chain)
{
free(_certificate->x509_cert_chain->array);
free(_certificate->x509_cert_chain);
}
free(_certificate->cert_info.Modulus);
free(_certificate);
certificate_free(_certificate);
return NULL;
}

2
libfreerdp/core/certificate.h
View File

@ -46,7 +46,7 @@
#define BB_RSA_SIGNATURE_BLOB 8
FREERDP_LOCAL BOOL certificate_read_server_certificate(rdpCertificate* certificate,
BYTE* server_cert, size_t length);
const BYTE* server_cert, size_t length);
FREERDP_LOCAL rdpCertificate* certificate_clone(rdpCertificate* certificate);

26
libfreerdp/core/client.c
View File

@ -293,7 +293,7 @@ UINT freerdp_channels_attach(freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
char* hostname;
const char* hostname;
size_t hostnameLength;
rdpChannels* channels;
CHANNEL_CLIENT_DATA* pChannelClientData;
@ -310,14 +310,14 @@ UINT freerdp_channels_attach(freerdp* instance)
if (pChannelClientData->pChannelInitEventProc)
{
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
CHANNEL_EVENT_ATTACHED, hostname,
CHANNEL_EVENT_ATTACHED, (LPVOID)hostname,
(UINT)hostnameLength);
}
else if (pChannelClientData->pChannelInitEventProcEx)
{
pChannelClientData->pChannelInitEventProcEx(
pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
CHANNEL_EVENT_ATTACHED, hostname, (UINT)hostnameLength);
CHANNEL_EVENT_ATTACHED, (LPVOID)hostname, (UINT)hostnameLength);
}
if (getChannelError(instance->context) != CHANNEL_RC_OK)
@ -338,7 +338,7 @@ UINT freerdp_channels_detach(freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
char* hostname;
const char* hostname;
size_t hostnameLength;
rdpChannels* channels;
CHANNEL_CLIENT_DATA* pChannelClientData;
@ -355,14 +355,14 @@ UINT freerdp_channels_detach(freerdp* instance)
if (pChannelClientData->pChannelInitEventProc)
{
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
CHANNEL_EVENT_DETACHED, hostname,
CHANNEL_EVENT_DETACHED, (LPVOID)hostname,
(UINT)hostnameLength);
}
else if (pChannelClientData->pChannelInitEventProcEx)
{
pChannelClientData->pChannelInitEventProcEx(
pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
CHANNEL_EVENT_DETACHED, hostname, (UINT)hostnameLength);
CHANNEL_EVENT_DETACHED, (LPVOID)hostname, (UINT)hostnameLength);
}
if (getChannelError(instance->context) != CHANNEL_RC_OK)
@ -388,7 +388,7 @@ UINT freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
char* hostname;
const char* hostname;
size_t hostnameLength;
CHANNEL_CLIENT_DATA* pChannelClientData;
channels->connected = TRUE;
@ -404,14 +404,14 @@ UINT freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
if (pChannelClientData->pChannelInitEventProc)
{
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
CHANNEL_EVENT_CONNECTED, hostname,
CHANNEL_EVENT_CONNECTED, (LPVOID)hostname,
(UINT)hostnameLength);
}
else if (pChannelClientData->pChannelInitEventProcEx)
{
pChannelClientData->pChannelInitEventProcEx(
pChannelClientData->lpUserParam, pChannelClientData->pInitHandle,
CHANNEL_EVENT_CONNECTED, hostname, (UINT)hostnameLength);
CHANNEL_EVENT_CONNECTED, (LPVOID)hostname, (UINT)hostnameLength);
}
if (getChannelError(instance->context) != CHANNEL_RC_OK)
@ -772,9 +772,7 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelInitEx(
INT channelCount, ULONG versionRequested, PCHANNEL_INIT_EVENT_EX_FN pChannelInitEventProcEx)
{
INT index;
CHANNEL_DEF* channel;
rdpSettings* settings;
PCHANNEL_DEF pChannelDef;
CHANNEL_INIT_DATA* pChannelInitData;
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_CLIENT_DATA* pChannelClientData;
@ -808,7 +806,7 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelInitEx(
for (index = 0; index < channelCount; index++)
{
pChannelDef = &pChannel[index];
const PCHANNEL_DEF pChannelDef = &pChannel[index];
if (freerdp_channels_find_channel_open_data_by_name(channels, pChannelDef->name) != 0)
{
@ -825,7 +823,7 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelInitEx(
for (index = 0; index < channelCount; index++)
{
pChannelDef = &pChannel[index];
const PCHANNEL_DEF pChannelDef = &pChannel[index];
pChannelOpenData = &channels->openDataList[channels->openDataCount];
pChannelOpenData->OpenHandle = InterlockedIncrement(&g_OpenHandleSeq);
pChannelOpenData->channels = channels;
@ -838,7 +836,7 @@ static UINT VCAPITYPE FreeRDP_VirtualChannelInitEx(
if (settings->ChannelCount < CHANNEL_MAX_COUNT)
{
channel = &settings->ChannelDefArray[settings->ChannelCount];
CHANNEL_DEF* channel = &settings->ChannelDefArray[settings->ChannelCount];
strncpy(channel->name, pChannelDef->name, 7);
channel->options = pChannelDef->options;
settings->ChannelCount++;

231
libfreerdp/core/gcc.c
View File

@ -38,33 +38,33 @@ static BOOL gcc_read_client_core_data(wStream* s, rdpMcs* mcs, UINT16 blockLengt
static BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, int length);
static BOOL gcc_read_server_data_blocks(wStream* s, rdpMcs* mcs, int length);
static BOOL gcc_read_user_data_header(wStream* s, UINT16* type, UINT16* length);
static void gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length);
static BOOL gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length);
static void gcc_write_client_core_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_core_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_core_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_core_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_client_security_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);
static void gcc_write_client_security_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_security_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_server_security_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_security_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_read_client_network_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);
static void gcc_write_client_network_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_network_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_network_data(wStream* s, rdpMcs* mcs);
static void gcc_write_client_cluster_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_network_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_write_client_cluster_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_client_monitor_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);
static BOOL gcc_write_client_monitor_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_monitor_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_client_monitor_extended_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);
static BOOL gcc_write_client_monitor_extended_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_monitor_extended_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_client_message_channel_data(wStream* s, rdpMcs* mcs, UINT16 blockLength);
static void gcc_write_client_message_channel_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_message_channel_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_message_channel_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_message_channel_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_client_multitransport_channel_data(wStream* s, rdpMcs* mcs,
UINT16 blockLength);
static void gcc_write_client_multitransport_channel_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_client_multitransport_channel_data(wStream* s, const rdpMcs* mcs);
static BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs);
static void gcc_write_server_multitransport_channel_data(wStream* s, rdpMcs* mcs);
static BOOL gcc_write_server_multitransport_channel_data(wStream* s, const rdpMcs* mcs);
static DWORD rdp_version_common(DWORD serverVersion, DWORD clientVersion)
{
@ -267,29 +267,39 @@ BOOL gcc_read_conference_create_request(wStream* s, rdpMcs* mcs)
* @param user_data client data blocks
*/
void gcc_write_conference_create_request(wStream* s, wStream* userData)
BOOL gcc_write_conference_create_request(wStream* s, wStream* userData)
{
/* ConnectData */
per_write_choice(s, 0); /* From Key select object (0) of type OBJECT_IDENTIFIER */
per_write_object_identifier(s, t124_02_98_oid); /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */
if (!per_write_choice(s, 0)) /* From Key select object (0) of type OBJECT_IDENTIFIER */
return FALSE;
if (!per_write_object_identifier(s, t124_02_98_oid)) /* ITU-T T.124 (02/98) OBJECT_IDENTIFIER */
return FALSE;
/* ConnectData::connectPDU (OCTET_STRING) */
per_write_length(s, Stream_GetPosition(userData) + 14); /* connectPDU length */
if (!per_write_length(s, Stream_GetPosition(userData) + 14)) /* connectPDU length */
return FALSE;
/* ConnectGCCPDU */
per_write_choice(s, 0); /* From ConnectGCCPDU select conferenceCreateRequest (0) of type
if (!per_write_choice(s, 0)) /* From ConnectGCCPDU select conferenceCreateRequest (0) of type
ConferenceCreateRequest */
per_write_selection(s, 0x08); /* select optional userData from ConferenceCreateRequest */
return FALSE;
if (!per_write_selection(s, 0x08)) /* select optional userData from ConferenceCreateRequest */
return FALSE;
/* ConferenceCreateRequest::conferenceName */
per_write_numeric_string(s, (BYTE*)"1", 1, 1); /* ConferenceName::numeric */
per_write_padding(s, 1); /* padding */
if (!per_write_numeric_string(s, (BYTE*)"1", 1, 1)) /* ConferenceName::numeric */
return FALSE;
if (!per_write_padding(s, 1)) /* padding */
return FALSE;
/* UserData (SET OF SEQUENCE) */
per_write_number_of_sets(s, 1); /* one set of UserData */
per_write_choice(s, 0xC0); /* UserData::value present + select h221NonStandard (1) */
if (!per_write_number_of_sets(s, 1)) /* one set of UserData */
return FALSE;
if (!per_write_choice(s, 0xC0)) /* UserData::value present + select h221NonStandard (1) */
return FALSE;
/* h221NonStandard */
per_write_octet_string(s, h221_cs_key, 4,
4); /* h221NonStandard, client-to-server H.221 key, "Duca" */
if (!per_write_octet_string(s, h221_cs_key, 4,
4)) /* h221NonStandard, client-to-server H.221 key, "Duca" */
return FALSE;
/* userData::value (OCTET_STRING) */
per_write_octet_string(s, Stream_Buffer(userData), Stream_GetPosition(userData),
0); /* array of client data blocks */
return per_write_octet_string(s, Stream_Buffer(userData), Stream_GetPosition(userData),
0); /* array of client data blocks */
}
BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs)
@ -351,32 +361,42 @@ BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs)
return TRUE;
}
void gcc_write_conference_create_response(wStream* s, wStream* userData)
BOOL gcc_write_conference_create_response(wStream* s, wStream* userData)
{
/* ConnectData */
per_write_choice(s, 0);
per_write_object_identifier(s, t124_02_98_oid);
if (!per_write_choice(s, 0))
return FALSE;
if (!per_write_object_identifier(s, t124_02_98_oid))
return FALSE;
/* ConnectData::connectPDU (OCTET_STRING) */
/* This length MUST be ignored by the client according to [MS-RDPBCGR] */
per_write_length(s, 0x2A);
if (!per_write_length(s, 0x2A))
return FALSE;
/* ConnectGCCPDU */
per_write_choice(s, 0x14);
if (!per_write_choice(s, 0x14))
return FALSE;
/* ConferenceCreateResponse::nodeID (UserID) */
per_write_integer16(s, 0x79F3, 1001);
if (!per_write_integer16(s, 0x79F3, 1001))
return FALSE;
/* ConferenceCreateResponse::tag (INTEGER) */
per_write_integer(s, 1);
if (!per_write_integer(s, 1))
return FALSE;
/* ConferenceCreateResponse::result (ENUMERATED) */
per_write_enumerated(s, 0, MCS_Result_enum_length);
if (!per_write_enumerated(s, 0, MCS_Result_enum_length))
return FALSE;
/* number of UserData sets */
per_write_number_of_sets(s, 1);
if (!per_write_number_of_sets(s, 1))
return FALSE;
/* UserData::value present + select h221NonStandard (1) */
per_write_choice(s, 0xC0);
if (!per_write_choice(s, 0xC0))
return FALSE;
/* h221NonStandard */
per_write_octet_string(s, h221_sc_key, 4,
4); /* h221NonStandard, server-to-client H.221 key, "McDn" */
if (!per_write_octet_string(s, h221_sc_key, 4,
4)) /* h221NonStandard, server-to-client H.221 key, "McDn" */
return FALSE;
/* userData (OCTET_STRING) */
per_write_octet_string(s, Stream_Buffer(userData), Stream_GetPosition(userData),
0); /* array of server data blocks */
return per_write_octet_string(s, Stream_Buffer(userData), Stream_GetPosition(userData),
0); /* array of server data blocks */
}
BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, int length)
@ -472,10 +492,9 @@ BOOL gcc_read_client_data_blocks(wStream* s, rdpMcs* mcs, int length)
BOOL gcc_write_client_data_blocks(wStream* s, rdpMcs* mcs)
{
rdpSettings* settings = mcs->settings;
gcc_write_client_core_data(s, mcs);
gcc_write_client_cluster_data(s, mcs);
gcc_write_client_security_data(s, mcs);
gcc_write_client_network_data(s, mcs);
if (!gcc_write_client_core_data(s, mcs) || !gcc_write_client_cluster_data(s, mcs) ||
!gcc_write_client_security_data(s, mcs) || !gcc_write_client_network_data(s, mcs))
return FALSE;
/* extended client data supported */
@ -483,15 +502,14 @@ BOOL gcc_write_client_data_blocks(wStream* s, rdpMcs* mcs)
{
if (settings->UseMultimon && !settings->SpanMonitors)
{
if (!gcc_write_client_monitor_data(s, mcs))
return FALSE;
if (!gcc_write_client_monitor_extended_data(s, mcs))
if (!gcc_write_client_monitor_data(s, mcs) ||
!gcc_write_client_monitor_extended_data(s, mcs))
return FALSE;
}
gcc_write_client_message_channel_data(s, mcs);
gcc_write_client_multitransport_channel_data(s, mcs);
if (!gcc_write_client_message_channel_data(s, mcs) ||
!gcc_write_client_multitransport_channel_data(s, mcs))
return FALSE;
}
else
{
@ -502,10 +520,8 @@ BOOL gcc_write_client_data_blocks(wStream* s, rdpMcs* mcs)
if (settings->ForceMultimon)
{
WLog_ERR(TAG, "Sending multi monitor information anyway (may break connectivity!)");
if (!gcc_write_client_monitor_data(s, mcs))
return FALSE;
if (!gcc_write_client_monitor_extended_data(s, mcs))
if (!gcc_write_client_monitor_data(s, mcs) ||
!gcc_write_client_monitor_extended_data(s, mcs))
return FALSE;
}
else
@ -514,7 +530,6 @@ BOOL gcc_write_client_data_blocks(wStream* s, rdpMcs* mcs)
}
}
}
return TRUE;
}
@ -646,10 +661,13 @@ BOOL gcc_read_user_data_header(wStream* s, UINT16* type, UINT16* length)
* @param length data block length
*/
void gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length)
BOOL gcc_write_user_data_header(wStream* s, UINT16 type, UINT16 length)
{
if (!Stream_EnsureRemainingCapacity(s, 4 + length))
return FALSE;
Stream_Write_UINT16(s, type); /* type */
Stream_Write_UINT16(s, length); /* length */
return TRUE;
}
/**
@ -916,7 +934,7 @@ BOOL gcc_read_client_core_data(wStream* s, rdpMcs* mcs, UINT16 blockLength)
* @param settings rdp settings
*/
void gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
{
WCHAR* clientName = NULL;
int clientNameLength;
@ -927,7 +945,8 @@ void gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
WCHAR* clientDigProductId = NULL;
int clientDigProductIdLength;
rdpSettings* settings = mcs->settings;
gcc_write_user_data_header(s, CS_CORE, 234);
if (!gcc_write_user_data_header(s, CS_CORE, 234))
return FALSE;
clientNameLength = ConvertToUnicode(CP_UTF8, 0, settings->ClientHostname, -1, &clientName, 0);
clientDigProductIdLength =
ConvertToUnicode(CP_UTF8, 0, settings->ClientProductId, -1, &clientDigProductId, 0);
@ -947,6 +966,8 @@ void gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
clientNameLength = 16;
clientName[clientNameLength - 1] = 0;
}
if (!Stream_EnsureRemainingCapacity(s, 32 + 12 + 64 + 8))
return FALSE;
Stream_Write(s, clientName, (clientNameLength * 2));
Stream_Zero(s, 32 - (clientNameLength * 2));
@ -990,6 +1011,8 @@ void gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
if (settings->SupportStatusInfoPdu)
earlyCapabilityFlags |= RNS_UD_CS_SUPPORT_STATUSINFO_PDU;
if (!Stream_EnsureRemainingCapacity(s, 6))
return FALSE;
Stream_Write_UINT16(s, highColorDepth); /* highColorDepth */
Stream_Write_UINT16(s, supportedColorDepths); /* supportedColorDepths */
@ -1002,6 +1025,8 @@ void gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
clientDigProductId[clientDigProductIdLength - 1] = 0;
}
if (!Stream_EnsureRemainingCapacity(s, 64 + 24))
return FALSE;
Stream_Write(s, clientDigProductId, (clientDigProductIdLength * 2));
Stream_Zero(s, 64 - (clientDigProductIdLength * 2));
free(clientDigProductId);
@ -1013,6 +1038,7 @@ void gcc_write_client_core_data(wStream* s, rdpMcs* mcs)
Stream_Write_UINT16(s, settings->DesktopOrientation); /* desktopOrientation */
Stream_Write_UINT32(s, settings->DesktopScaleFactor); /* desktopScaleFactor */
Stream_Write_UINT32(s, settings->DeviceScaleFactor); /* deviceScaleFactor */
return TRUE;
}
BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs)
@ -1041,16 +1067,14 @@ BOOL gcc_read_server_core_data(wStream* s, rdpMcs* mcs)
return TRUE;
}
BOOL gcc_write_server_core_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_server_core_data(wStream* s, const rdpMcs* mcs)
{
UINT32 earlyCapabilityFlags = 0;
rdpSettings* settings = mcs->settings;
const rdpSettings* settings = mcs->settings;
if (!Stream_EnsureRemainingCapacity(s, 20))
if (!gcc_write_user_data_header(s, SC_CORE, 16))
return FALSE;
gcc_write_user_data_header(s, SC_CORE, 16);
if (settings->SupportDynamicTimeZone)
earlyCapabilityFlags |= RNS_UD_SC_DYNAMIC_DST_SUPPORTED;
@ -1098,10 +1122,11 @@ BOOL gcc_read_client_security_data(wStream* s, rdpMcs* mcs, UINT16 blockLength)
* @param settings rdp settings
*/
void gcc_write_client_security_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_security_data(wStream* s, const rdpMcs* mcs)
{
rdpSettings* settings = mcs->settings;
gcc_write_user_data_header(s, CS_SECURITY, 12);
const rdpSettings* settings = mcs->settings;
if (!gcc_write_user_data_header(s, CS_SECURITY, 12))
return FALSE;
if (settings->UseRdpSecurityLayer)
{
@ -1114,11 +1139,12 @@ void gcc_write_client_security_data(wStream* s, rdpMcs* mcs)
Stream_Write_UINT32(s, 0); /* encryptionMethods */
Stream_Write_UINT32(s, settings->EncryptionMethods); /* extEncryptionMethods */
}
return TRUE;
}
BOOL gcc_read_server_security_data(wStream* s, rdpMcs* mcs)
{
BYTE* data;
const BYTE* data;
UINT32 length;
rdpSettings* settings = mcs->settings;
BOOL validCryptoConfig = FALSE;
@ -1473,10 +1499,9 @@ BOOL gcc_write_server_security_data(wStream* s, rdpMcs* mcs)
headerLen += serverCertLen;
}
if (!Stream_EnsureRemainingCapacity(s, headerLen + 4))
if (!gcc_write_user_data_header(s, SC_SECURITY, headerLen))
return FALSE;
gcc_write_user_data_header(s, SC_SECURITY, headerLen);
Stream_Write_UINT32(s, settings->EncryptionMethods); /* encryptionMethod */
Stream_Write_UINT32(s, settings->EncryptionLevel); /* encryptionLevel */
@ -1580,7 +1605,7 @@ BOOL gcc_read_client_network_data(wStream* s, rdpMcs* mcs, UINT16 blockLength)
* @param settings rdp settings
*/
void gcc_write_client_network_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_network_data(wStream* s, const rdpMcs* mcs)
{
UINT32 i;
UINT16 length;
@ -1588,7 +1613,8 @@ void gcc_write_client_network_data(wStream* s, rdpMcs* mcs)
if (mcs->channelCount > 0)
{
length = mcs->channelCount * 12 + 8;
gcc_write_user_data_header(s, CS_NET, length);
if (!gcc_write_user_data_header(s, CS_NET, length))
return FALSE;
Stream_Write_UINT32(s, mcs->channelCount); /* channelCount */
/* channelDefArray */
@ -1599,6 +1625,7 @@ void gcc_write_client_network_data(wStream* s, rdpMcs* mcs)
Stream_Write_UINT32(s, mcs->channels[i].options); /* options (4 bytes) */
}
}
return TRUE;
}
BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs)
@ -1642,15 +1669,14 @@ BOOL gcc_read_server_network_data(wStream* s, rdpMcs* mcs)
return TRUE;
}
BOOL gcc_write_server_network_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_server_network_data(wStream* s, const rdpMcs* mcs)
{
UINT32 i;
int payloadLen = 8 + mcs->channelCount * 2 + (mcs->channelCount % 2 == 1 ? 2 : 0);
const size_t payloadLen = 8 + mcs->channelCount * 2 + (mcs->channelCount % 2 == 1 ? 2 : 0);
if (!Stream_EnsureRemainingCapacity(s, payloadLen + 4))
if (!gcc_write_user_data_header(s, SC_NET, payloadLen))
return FALSE;
gcc_write_user_data_header(s, SC_NET, payloadLen);
Stream_Write_UINT16(s, MCS_GLOBAL_CHANNEL_ID); /* MCSChannelId */
Stream_Write_UINT16(s, mcs->channelCount); /* channelCount */
@ -1706,11 +1732,12 @@ BOOL gcc_read_client_cluster_data(wStream* s, rdpMcs* mcs, UINT16 blockLength)
* @param settings rdp settings
*/
void gcc_write_client_cluster_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_cluster_data(wStream* s, const rdpMcs* mcs)
{
UINT32 flags;
rdpSettings* settings = mcs->settings;
gcc_write_user_data_header(s, CS_CLUSTER, 12);
const rdpSettings* settings = mcs->settings;
if (!gcc_write_user_data_header(s, CS_CLUSTER, 12))
return FALSE;
flags = REDIRECTION_SUPPORTED | (REDIRECTION_VERSION4 << 2);
if (settings->ConsoleSession || settings->RedirectedSessionId)
@ -1721,6 +1748,7 @@ void gcc_write_client_cluster_data(wStream* s, rdpMcs* mcs)
Stream_Write_UINT32(s, flags); /* flags */
Stream_Write_UINT32(s, settings->RedirectedSessionId); /* redirectedSessionID */
return TRUE;
}
/**
@ -1790,21 +1818,19 @@ BOOL gcc_read_client_monitor_data(wStream* s, rdpMcs* mcs, UINT16 blockLength)
* @param settings rdp settings
*/
BOOL gcc_write_client_monitor_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_monitor_data(wStream* s, const rdpMcs* mcs)
{
UINT32 i;
UINT16 length;
UINT32 left, top, right, bottom, flags;
INT32 baseX = 0, baseY = 0;
rdpSettings* settings = mcs->settings;
const rdpSettings* settings = mcs->settings;
if (settings->MonitorCount > 1)
{
length = (20 * settings->MonitorCount) + 12;
if (!Stream_EnsureRemainingCapacity(s, length))
if (!gcc_write_user_data_header(s, CS_MONITOR, length))
return FALSE;
gcc_write_user_data_header(s, CS_MONITOR, length);
Stream_Write_UINT32(s, 0); /* flags */
Stream_Write_UINT32(s, settings->MonitorCount); /* monitorCount */
@ -1834,7 +1860,6 @@ BOOL gcc_write_client_monitor_data(wStream* s, rdpMcs* mcs)
Stream_Write_UINT32(s, flags); /* flags */
}
}
return TRUE;
}
@ -1882,19 +1907,17 @@ BOOL gcc_read_client_monitor_extended_data(wStream* s, rdpMcs* mcs, UINT16 block
return TRUE;
}
BOOL gcc_write_client_monitor_extended_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_monitor_extended_data(wStream* s, const rdpMcs* mcs)
{
UINT32 i;
UINT16 length;
rdpSettings* settings = mcs->settings;
const rdpSettings* settings = mcs->settings;
if (settings->HasMonitorAttributes)
{
length = (20 * settings->MonitorCount) + 16;
if (!Stream_EnsureRemainingCapacity(s, length))
if (!gcc_write_user_data_header(s, CS_MONITOR_EX, length))
return FALSE;
gcc_write_user_data_header(s, CS_MONITOR_EX, length);
Stream_Write_UINT32(s, 0); /* flags */
Stream_Write_UINT32(s, 20); /* monitorAttributeSize */
Stream_Write_UINT32(s, settings->MonitorCount); /* monitorCount */
@ -1914,7 +1937,6 @@ BOOL gcc_write_client_monitor_extended_data(wStream* s, rdpMcs* mcs)
settings->MonitorDefArray[i].attributes.deviceScaleFactor); /* deviceScaleFactor */
}
}
return TRUE;
}
@ -1944,16 +1966,18 @@ BOOL gcc_read_client_message_channel_data(wStream* s, rdpMcs* mcs, UINT16 blockL
* @param settings rdp settings
*/
void gcc_write_client_message_channel_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_message_channel_data(wStream* s, const rdpMcs* mcs)
{
rdpSettings* settings = mcs->settings;
const rdpSettings* settings = mcs->settings;
if (settings->NetworkAutoDetect || settings->SupportHeartbeatPdu ||
settings->SupportMultitransport)
{
gcc_write_user_data_header(s, CS_MCS_MSGCHANNEL, 8);
if (!gcc_write_user_data_header(s, CS_MCS_MSGCHANNEL, 8))
return FALSE;
Stream_Write_UINT32(s, 0); /* flags */
}
return TRUE;
}
BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs)
@ -1969,15 +1993,14 @@ BOOL gcc_read_server_message_channel_data(wStream* s, rdpMcs* mcs)
return TRUE;
}
BOOL gcc_write_server_message_channel_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_server_message_channel_data(wStream* s, const rdpMcs* mcs)
{
if (mcs->messageChannelId == 0)
return TRUE;
if (!Stream_EnsureRemainingCapacity(s, 2 + 4))
if (!gcc_write_user_data_header(s, SC_MCS_MSGCHANNEL, 6))
return FALSE;
gcc_write_user_data_header(s, SC_MCS_MSGCHANNEL, 6);
Stream_Write_UINT16(s, mcs->messageChannelId); /* mcsChannelId (2 bytes) */
return TRUE;
}
@ -2007,12 +2030,14 @@ BOOL gcc_read_client_multitransport_channel_data(wStream* s, rdpMcs* mcs, UINT16
* @param settings rdp settings
*/
void gcc_write_client_multitransport_channel_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_client_multitransport_channel_data(wStream* s, const rdpMcs* mcs)
{
rdpSettings* settings = mcs->settings;
const rdpSettings* settings = mcs->settings;
gcc_write_user_data_header(s, CS_MULTITRANSPORT, 8);
if (!gcc_write_user_data_header(s, CS_MULTITRANSPORT, 8))
return FALSE;
Stream_Write_UINT32(s, settings->MultitransportFlags); /* flags */
return TRUE;
}
BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs)
@ -2026,9 +2051,11 @@ BOOL gcc_read_server_multitransport_channel_data(wStream* s, rdpMcs* mcs)
return TRUE;
}
void gcc_write_server_multitransport_channel_data(wStream* s, rdpMcs* mcs)
BOOL gcc_write_server_multitransport_channel_data(wStream* s, const rdpMcs* mcs)
{
UINT32 flags = 0;
gcc_write_user_data_header(s, SC_MULTITRANSPORT, 8);
if (!gcc_write_user_data_header(s, SC_MULTITRANSPORT, 8))
return FALSE;
Stream_Write_UINT32(s, flags); /* flags (4 bytes) */
return TRUE;
}

4
libfreerdp/core/gcc.h
View File

@ -31,9 +31,9 @@
#include <winpr/stream.h>
FREERDP_LOCAL BOOL gcc_read_conference_create_request(wStream* s, rdpMcs* mcs);
FREERDP_LOCAL void gcc_write_conference_create_request(wStream* s, wStream* userData);
FREERDP_LOCAL BOOL gcc_write_conference_create_request(wStream* s, wStream* userData);
FREERDP_LOCAL BOOL gcc_read_conference_create_response(wStream* s, rdpMcs* mcs);
FREERDP_LOCAL void gcc_write_conference_create_response(wStream* s, wStream* userData);
FREERDP_LOCAL BOOL gcc_write_conference_create_response(wStream* s, wStream* userData);
FREERDP_LOCAL BOOL gcc_write_client_data_blocks(wStream* s, rdpMcs* mcs);
FREERDP_LOCAL BOOL gcc_write_server_data_blocks(wStream* s, rdpMcs* mcs);

2
libfreerdp/core/license.c
View File

@ -243,7 +243,7 @@ static BOOL path_make(const char* path, LPSECURITY_ATTRIBUTES lpAttributes)
return rc;
}
static BOOL saveCal(rdpSettings* settings, const BYTE* data, size_t length, char* hostname)
static BOOL saveCal(rdpSettings* settings, const BYTE* data, size_t length, const char* hostname)
{
char hash[41];
FILE* fp;

7
libfreerdp/core/mcs.c
View File

@ -703,7 +703,6 @@ BOOL mcs_send_connect_initial(rdpMcs* mcs)
if (!gcc_write_client_data_blocks(client_data, mcs))
goto out;
gcc_CCrq = Stream_New(NULL, 1024);
if (!gcc_CCrq)
@ -712,7 +711,8 @@ BOOL mcs_send_connect_initial(rdpMcs* mcs)
goto out;
}
gcc_write_conference_create_request(gcc_CCrq, client_data);
if (!gcc_write_conference_create_request(gcc_CCrq, client_data))
goto out;
length = Stream_GetPosition(gcc_CCrq) + 7;
s = Stream_New(NULL, 1024 + length);
@ -827,7 +827,8 @@ BOOL mcs_send_connect_response(rdpMcs* mcs)
goto out;
}
gcc_write_conference_create_response(gcc_CCrsp, server_data);
if (!gcc_write_conference_create_response(gcc_CCrsp, server_data))
goto out;
length = Stream_GetPosition(gcc_CCrsp) + 7;
s = Stream_New(NULL, length + 1024);

8
libfreerdp/core/nego.c
View File

@ -46,7 +46,7 @@ struct rdp_nego
DWORD RoutingTokenLength;
BOOL SendPreconnectionPdu;
UINT32 PreconnectionId;
char* PreconnectionBlob;
const char* PreconnectionBlob;
NEGO_STATE state;
BOOL TcpConnected;
@ -1299,7 +1299,7 @@ void nego_enable_ext(rdpNego* nego, BOOL enable_ext)
* @param RoutingTokenLength
*/
BOOL nego_set_routing_token(rdpNego* nego, BYTE* RoutingToken, DWORD RoutingTokenLength)
BOOL nego_set_routing_token(rdpNego* nego, const BYTE* RoutingToken, DWORD RoutingTokenLength)
{
if (RoutingTokenLength == 0)
return FALSE;
@ -1321,7 +1321,7 @@ BOOL nego_set_routing_token(rdpNego* nego, BYTE* RoutingToken, DWORD RoutingToke
* @param cookie
*/
BOOL nego_set_cookie(rdpNego* nego, char* cookie)
BOOL nego_set_cookie(rdpNego* nego, const char* cookie)
{
if (nego->cookie)
{
@ -1379,7 +1379,7 @@ void nego_set_preconnection_id(rdpNego* nego, UINT32 PreconnectionId)
* @param blob
*/
void nego_set_preconnection_blob(rdpNego* nego, char* PreconnectionBlob)
void nego_set_preconnection_blob(rdpNego* nego, const char* PreconnectionBlob)
{
nego->PreconnectionBlob = PreconnectionBlob;
}

6
libfreerdp/core/nego.h
View File

@ -118,13 +118,13 @@ FREERDP_LOCAL void nego_enable_tls(rdpNego* nego, BOOL enable_tls);
FREERDP_LOCAL void nego_enable_nla(rdpNego* nego, BOOL enable_nla);
FREERDP_LOCAL void nego_enable_ext(rdpNego* nego, BOOL enable_ext);
FREERDP_LOCAL const BYTE* nego_get_routing_token(rdpNego* nego, DWORD* RoutingTokenLength);
FREERDP_LOCAL BOOL nego_set_routing_token(rdpNego* nego, BYTE* RoutingToken,
FREERDP_LOCAL BOOL nego_set_routing_token(rdpNego* nego, const BYTE* RoutingToken,
DWORD RoutingTokenLength);
FREERDP_LOCAL BOOL nego_set_cookie(rdpNego* nego, char* cookie);
FREERDP_LOCAL BOOL nego_set_cookie(rdpNego* nego, const char* cookie);
FREERDP_LOCAL void nego_set_cookie_max_length(rdpNego* nego, UINT32 CookieMaxLength);
FREERDP_LOCAL void nego_set_send_preconnection_pdu(rdpNego* nego, BOOL SendPreconnectionPdu);
FREERDP_LOCAL void nego_set_preconnection_id(rdpNego* nego, UINT32 PreconnectionId);
FREERDP_LOCAL void nego_set_preconnection_blob(rdpNego* nego, char* PreconnectionBlob);
FREERDP_LOCAL void nego_set_preconnection_blob(rdpNego* nego, const char* PreconnectionBlob);
FREERDP_LOCAL UINT32 nego_get_selected_protocol(rdpNego* nego);
FREERDP_LOCAL BOOL nego_set_selected_protocol(rdpNego* nego, UINT32 SelectedProtocol);

46
libfreerdp/crypto/certificate.c
View File

@ -70,25 +70,44 @@ static BOOL certificate_line_is_comment(const char* line, size_t length)
return TRUE;
}
static void certificate_store_uninit(rdpCertificateStore* certificate_store)
{
if (certificate_store)
{
free(certificate_store->path);
free(certificate_store->file);
free(certificate_store->legacy_file);
certificate_store->path = NULL;
certificate_store->file = NULL;
certificate_store->legacy_file = NULL;
}
}
static BOOL certificate_store_init(rdpCertificateStore* certificate_store)
{
char* server_path = NULL;
rdpSettings* settings;
const char* ConfigPath;
if (!certificate_store)
return FALSE;
settings = certificate_store->settings;
if (!PathFileExistsA(settings->ConfigPath))
if (!settings)
return FALSE;
ConfigPath = settings->ConfigPath;
if (!ConfigPath)
return FALSE;
if (!PathFileExistsA(ConfigPath))
{
if (!PathMakePathA(settings->ConfigPath, 0))
if (!PathMakePathA(ConfigPath, 0))
{
WLog_ERR(TAG, "error creating directory '%s'", settings->ConfigPath);
WLog_ERR(TAG, "error creating directory '%s'", ConfigPath);
goto fail;
}
WLog_INFO(TAG, "creating directory %s", settings->ConfigPath);
WLog_INFO(TAG, "creating directory %s", ConfigPath);
}
if (!(certificate_store->path =
GetCombinedPath(settings->ConfigPath, (char*)certificate_store_dir)))
if (!(certificate_store->path = GetCombinedPath(ConfigPath, (char*)certificate_store_dir)))
goto fail;
if (!PathFileExistsA(certificate_store->path))
@ -102,7 +121,7 @@ static BOOL certificate_store_init(rdpCertificateStore* certificate_store)
WLog_INFO(TAG, "creating directory [%s]", certificate_store->path);
}
if (!(server_path = GetCombinedPath(settings->ConfigPath, (char*)certificate_server_dir)))
if (!(server_path = GetCombinedPath(ConfigPath, (char*)certificate_server_dir)))
goto fail;
if (!PathFileExistsA(server_path))
@ -117,11 +136,11 @@ static BOOL certificate_store_init(rdpCertificateStore* certificate_store)
}
if (!(certificate_store->file =
GetCombinedPath(settings->ConfigPath, (char*)certificate_known_hosts_file)))
GetCombinedPath(ConfigPath, (char*)certificate_known_hosts_file)))
goto fail;
if (!(certificate_store->legacy_file =
GetCombinedPath(settings->ConfigPath, (char*)certificate_legacy_hosts_file)))
GetCombinedPath(ConfigPath, (char*)certificate_legacy_hosts_file)))
goto fail;
free(server_path);
@ -129,10 +148,7 @@ static BOOL certificate_store_init(rdpCertificateStore* certificate_store)
fail:
WLog_ERR(TAG, "certificate store initialization failed");
free(server_path);
free(certificate_store->path);
free(certificate_store->file);
certificate_store->path = NULL;
certificate_store->file = NULL;
certificate_store_uninit(certificate_store);
return FALSE;
}
@ -757,11 +773,9 @@ rdpCertificateStore* certificate_store_new(rdpSettings* settings)
void certificate_store_free(rdpCertificateStore* certstore)
{
certificate_store_uninit(certstore);
if (certstore != NULL)
{
free(certstore->path);
free(certstore->file);
free(certstore->legacy_file);
free(certstore);
}
}

107
libfreerdp/crypto/per.c
View File

@ -63,12 +63,21 @@ BOOL per_read_length(wStream* s, UINT16* length)
* @param length length
*/
void per_write_length(wStream* s, int length)
BOOL per_write_length(wStream* s, UINT16 length)
{
if (length > 0x7F)
{
if (!Stream_EnsureRemainingCapacity(s, 2))
return FALSE;
Stream_Write_UINT16_BE(s, (length | 0x8000));
}
else
{
if (!Stream_EnsureRemainingCapacity(s, 1))
return FALSE;
Stream_Write_UINT8(s, length);
}
return TRUE;
}
/**
@ -93,9 +102,12 @@ BOOL per_read_choice(wStream* s, BYTE* choice)
* @param choice index of chosen field
*/
void per_write_choice(wStream* s, BYTE choice)
BOOL per_write_choice(wStream* s, BYTE choice)
{
if (!Stream_EnsureRemainingCapacity(s, 1))
return FALSE;
Stream_Write_UINT8(s, choice);
return TRUE;
}
/**
@ -120,9 +132,12 @@ BOOL per_read_selection(wStream* s, BYTE* selection)
* @param selection bit map of selected fields
*/
void per_write_selection(wStream* s, BYTE selection)
BOOL per_write_selection(wStream* s, BYTE selection)
{
if (!Stream_EnsureRemainingCapacity(s, 1))
return FALSE;
Stream_Write_UINT8(s, selection);
return TRUE;
}
/**
@ -147,9 +162,12 @@ BOOL per_read_number_of_sets(wStream* s, BYTE* number)
* @param number number of sets
*/
void per_write_number_of_sets(wStream* s, BYTE number)
BOOL per_write_number_of_sets(wStream* s, BYTE number)
{
if (!Stream_EnsureRemainingCapacity(s, 1))
return FALSE;
Stream_Write_UINT8(s, number);
return TRUE;
}
/**
@ -158,9 +176,9 @@ void per_write_number_of_sets(wStream* s, BYTE number)
* @param length
*/
BOOL per_read_padding(wStream* s, int length)
BOOL per_read_padding(wStream* s, UINT16 length)
{
if (((int)Stream_GetRemainingLength(s)) < length)
if ((Stream_GetRemainingLength(s)) < length)
return FALSE;
Stream_Seek(s, length);
@ -173,12 +191,12 @@ BOOL per_read_padding(wStream* s, int length)
* @param length
*/
void per_write_padding(wStream* s, int length)
BOOL per_write_padding(wStream* s, UINT16 length)
{
int i;
for (i = 0; i < length; i++)
Stream_Write_UINT8(s, 0);
if (!Stream_EnsureRemainingCapacity(s, length))
return FALSE;
Stream_Zero(s, length);
return TRUE;
}
/**
@ -216,23 +234,33 @@ BOOL per_read_integer(wStream* s, UINT32* integer)
* @param integer integer
*/
void per_write_integer(wStream* s, UINT32 integer)
BOOL per_write_integer(wStream* s, UINT32 integer)
{
if (integer <= 0xFF)
{
per_write_length(s, 1);
if (!per_write_length(s, 1))
return FALSE;
if (!Stream_EnsureRemainingCapacity(s, 1))
return FALSE;
Stream_Write_UINT8(s, integer);
}
else if (integer <= 0xFFFF)
{
per_write_length(s, 2);
if (!per_write_length(s, 2))
return FALSE;
if (!Stream_EnsureRemainingCapacity(s, 2))
return FALSE;
Stream_Write_UINT16_BE(s, integer);
}
else if (integer <= 0xFFFFFFFF)
{
per_write_length(s, 4);
if (!per_write_length(s, 4))
return FALSE;
if (!Stream_EnsureRemainingCapacity(s, 4))
return FALSE;
Stream_Write_UINT32_BE(s, integer);
}
return TRUE;
}
/**
@ -265,9 +293,12 @@ BOOL per_read_integer16(wStream* s, UINT16* integer, UINT16 min)
* @param min minimum value
*/
void per_write_integer16(wStream* s, UINT16 integer, UINT16 min)
BOOL per_write_integer16(wStream* s, UINT16 integer, UINT16 min)
{
if (!Stream_EnsureRemainingCapacity(s, 2))
return FALSE;
Stream_Write_UINT16_BE(s, integer - min);
return TRUE;
}
/**
@ -300,9 +331,12 @@ BOOL per_read_enumerated(wStream* s, BYTE* enumerated, BYTE count)
* @return
*/
void per_write_enumerated(wStream* s, BYTE enumerated, BYTE count)
BOOL per_write_enumerated(wStream* s, BYTE enumerated, BYTE count)
{
if (!Stream_EnsureRemainingCapacity(s, 1))
return FALSE;
Stream_Write_UINT8(s, enumerated);
return TRUE;
}
/**
@ -355,15 +389,18 @@ BOOL per_read_object_identifier(wStream* s, BYTE oid[6])
* @warning It works correctly only for limited set of OIDs.
*/
void per_write_object_identifier(wStream* s, BYTE oid[6])
BOOL per_write_object_identifier(wStream* s, const BYTE oid[6])
{
BYTE t12 = oid[0] * 40 + oid[1];
if (!Stream_EnsureRemainingCapacity(s, 6))
return FALSE;
Stream_Write_UINT8(s, 5); /* length */
Stream_Write_UINT8(s, t12); /* first two tuples */
Stream_Write_UINT8(s, oid[2]); /* tuple 3 */
Stream_Write_UINT8(s, oid[3]); /* tuple 4 */
Stream_Write_UINT8(s, oid[4]); /* tuple 5 */
Stream_Write_UINT8(s, oid[5]); /* tuple 6 */
return TRUE;
}
/**
@ -390,9 +427,9 @@ static void per_write_string(wStream* s, BYTE* str, int length)
* @return
*/
BOOL per_read_octet_string(wStream* s, BYTE* oct_str, int length, int min)
BOOL per_read_octet_string(wStream* s, BYTE* oct_str, UINT16 length, UINT16 min)
{
int i;
UINT16 i;
UINT16 mlength;
BYTE* a_oct_str;
@ -402,7 +439,7 @@ BOOL per_read_octet_string(wStream* s, BYTE* oct_str, int length, int min)
if (mlength + min != length)
return FALSE;
if (((int)Stream_GetRemainingLength(s)) < length)
if ((Stream_GetRemainingLength(s)) < length)
return FALSE;
a_oct_str = Stream_Pointer(s);
@ -425,17 +462,21 @@ BOOL per_read_octet_string(wStream* s, BYTE* oct_str, int length, int min)
* @param min minimum string length
*/
void per_write_octet_string(wStream* s, BYTE* oct_str, int length, int min)
BOOL per_write_octet_string(wStream* s, const BYTE* oct_str, UINT16 length, UINT16 min)
{
int i;
int mlength;
UINT16 i;
UINT16 mlength;
mlength = (length - min >= 0) ? length - min : min;
mlength = (length >= min) ? length - min : min;
per_write_length(s, mlength);
if (!per_write_length(s, mlength))
return FALSE;
if (!Stream_EnsureRemainingCapacity(s, length))
return FALSE;
for (i = 0; i < length; i++)
Stream_Write_UINT8(s, oct_str[i]);
return TRUE;
}
/**
@ -471,16 +512,19 @@ BOOL per_read_numeric_string(wStream* s, int min)
* @param min minimum string length
*/
void per_write_numeric_string(wStream* s, BYTE* num_str, int length, int min)
BOOL per_write_numeric_string(wStream* s, const BYTE* num_str, UINT16 length, UINT16 min)
{
int i;
int mlength;
UINT16 i;
UINT16 mlength;
BYTE num, c1, c2;
mlength = (length - min >= 0) ? length - min : min;
mlength = (length >= min) ? length - min : min;
per_write_length(s, mlength);
if (!per_write_length(s, mlength))
return FALSE;
if (!Stream_EnsureRemainingCapacity(s, length))
return FALSE;
for (i = 0; i < length; i += 2)
{
c1 = num_str[i];
@ -492,4 +536,5 @@ void per_write_numeric_string(wStream* s, BYTE* num_str, int length, int min)
Stream_Write_UINT8(s, num); /* string */
}
return TRUE;
}

5
libfreerdp/utils/pcap.c
View File

@ -166,7 +166,7 @@ BOOL pcap_get_next_record(rdpPcap* pcap, pcap_record* record)
return pcap_has_next_record(pcap) && pcap_read_record(pcap, record);
}
rdpPcap* pcap_open(char* name, BOOL write)
rdpPcap* pcap_open(const char* name, BOOL write)
{
rdpPcap* pcap;
@ -174,7 +174,7 @@ rdpPcap* pcap_open(char* name, BOOL write)
if (!pcap)
goto fail;
pcap->name = name;
pcap->name = _strdup(name);
pcap->write = write;
pcap->record_count = 0;
pcap->fp = fopen(name, write ? "w+b" : "rb");
@ -232,5 +232,6 @@ void pcap_close(rdpPcap* pcap)
if (pcap->fp != NULL)
fclose(pcap->fp);
free(pcap->name);
free(pcap);
}

1
server/proxy/modules/capture/cap_main.c
View File

@ -270,6 +270,7 @@ static proxyPlugin demo_plugin = {
NULL, /* MouseEvent */
NULL, /* ClientChannelData */
NULL, /* ServerChannelData */
NULL /* ServerFetchTargetAddr */
};
BOOL proxy_module_entry_point(proxyPluginsManager* plugins_manager)

8
winpr/include/winpr/sam.h
View File

@ -41,10 +41,10 @@ extern "C"
{
#endif
WINPR_API WINPR_SAM_ENTRY* SamLookupUserA(WINPR_SAM* sam, LPSTR User, UINT32 UserLength,
LPSTR Domain, UINT32 DomainLength);
WINPR_API WINPR_SAM_ENTRY* SamLookupUserW(WINPR_SAM* sam, LPWSTR User, UINT32 UserLength,
LPWSTR Domain, UINT32 DomainLength);
WINPR_API WINPR_SAM_ENTRY* SamLookupUserA(WINPR_SAM* sam, LPCSTR User, UINT32 UserLength,
LPCSTR Domain, UINT32 DomainLength);
WINPR_API WINPR_SAM_ENTRY* SamLookupUserW(WINPR_SAM* sam, LPCWSTR User, UINT32 UserLength,
LPCWSTR Domain, UINT32 DomainLength);
WINPR_API void SamResetEntry(WINPR_SAM_ENTRY* entry);
WINPR_API void SamFreeEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry);

1
winpr/libwinpr/sysinfo/cpufeatures/cpu-features.c
View File

@ -69,6 +69,7 @@
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/system_properties.h>
#include <unistd.h>
#include <winpr/wtypes.h>

7
winpr/libwinpr/thread/process.c
View File

@ -165,7 +165,12 @@ static BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags, LPCSTR lpApplic
BOOL restoreSigMask = FALSE;
numArgs = 0;
lpszEnvironmentBlock = NULL;
pArgs = CommandLineToArgvA(lpCommandLine, &numArgs);
/* https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessa
*/
if (lpCommandLine)
pArgs = CommandLineToArgvA(lpCommandLine, &numArgs);
else
pArgs = CommandLineToArgvA(lpApplicationName, &numArgs);
if (!pArgs)
return FALSE;

4
winpr/libwinpr/utils/sam.c
View File

@ -271,7 +271,7 @@ void SamResetEntry(WINPR_SAM_ENTRY* entry)
ZeroMemory(entry->NtHash, sizeof(entry->NtHash));
}
WINPR_SAM_ENTRY* SamLookupUserA(WINPR_SAM* sam, LPSTR User, UINT32 UserLength, LPSTR Domain,
WINPR_SAM_ENTRY* SamLookupUserA(WINPR_SAM* sam, LPCSTR User, UINT32 UserLength, LPCSTR Domain,
UINT32 DomainLength)
{
size_t length;
@ -325,7 +325,7 @@ out_fail:
return entry;
}
WINPR_SAM_ENTRY* SamLookupUserW(WINPR_SAM* sam, LPWSTR User, UINT32 UserLength, LPWSTR Domain,
WINPR_SAM_ENTRY* SamLookupUserW(WINPR_SAM* sam, LPCWSTR User, UINT32 UserLength, LPCWSTR Domain,
UINT32 DomainLength)
{
size_t length;