mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:FreeRDP/FreeRDP

This commit is contained in:
Marc-André Moreau 2015-06-26 14:00:03 -04:00
parent 24ed6b06cc 20878e50fe
commit 5ec19d2045
230 changed files with 6279 additions and 2726 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -94,6 +94,7 @@ client/X11/xfreerdp
client/Mac/xcode
client/Sample/sfreerdp
client/DirectFB/dfreerdp
client/Wayland/wlfreerdp
server/Sample/sfreerdp-server
server/X11/xfreerdp-server
xcode
@ -132,6 +133,9 @@ TAGS
# packaging related files
!packaging/scripts/prepare_deb_freerdp-nightly.sh
packaging/deb/freerdp-nightly/freerdp-nightly
packaging/deb/freerdp-nightly/freerdp-nightly-dev
packaging/deb/freerdp-nightly/freerdp-nightly-dbg
#
.idea

32
CMakeLists.txt
View File

@ -651,17 +651,6 @@ set(FREERDP_EXTENSION_PATH "${CMAKE_INSTALL_FULL_LIBDIR}/freerdp/extensions")
include_directories(${CMAKE_CURRENT_BINARY_DIR})
include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
if(BSD)
if(IS_DIRECTORY /usr/local/include)
include_directories(/usr/local/include)
link_directories(/usr/local/lib)
endif()
if(OPENBSD)
if(IS_DIRECTORY /usr/X11R6/include)
include_directories(/usr/X11R6/include)
endif()
endif()
endif()
# Configure files
add_definitions("-DHAVE_CONFIG_H")
@ -722,10 +711,6 @@ add_subdirectory(include)
add_subdirectory(libfreerdp)
if(WITH_CHANNELS)
add_subdirectory(channels)
endif()
if (IOS)
set(CMAKE_OSX_DEPLOYMENT_TARGET "")
if (IOS_PLATFORM MATCHES "SIMULATOR")
@ -741,6 +726,22 @@ include_directories("${CMAKE_BINARY_DIR}/rdtk/include")
add_subdirectory(rdtk)
if(BSD)
if(IS_DIRECTORY /usr/local/include)
include_directories(/usr/local/include)
link_directories(/usr/local/lib)
endif()
if(OPENBSD)
if(IS_DIRECTORY /usr/X11R6/include)
include_directories(/usr/X11R6/include)
endif()
endif()
endif()
if(WITH_CHANNELS)
add_subdirectory(channels)
endif()
if(WITH_CLIENT)
add_subdirectory(client)
endif()
@ -749,6 +750,7 @@ if(WITH_SERVER)
add_subdirectory(server)
endif()
# Exporting
if(${CMAKE_VERSION} VERSION_GREATER "2.8.10")

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

@ -97,7 +97,7 @@ static int audin_process_version(IWTSVirtualChannelCallback* pChannelCallback, w
Stream_Read_UINT32(s, Version);
DEBUG_DVC("process_version: Version=%d", Version);
DEBUG_DVC("Version=%d", Version);
out = Stream_New(NULL, 5);
Stream_Write_UINT8(out, MSG_SNDIN_VERSION);
@ -130,7 +130,7 @@ static int audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback, w
UINT32 cbSizeFormatsPacket;
Stream_Read_UINT32(s, NumFormats);
DEBUG_DVC("process_formats: NumFormats %d", NumFormats);
DEBUG_DVC("NumFormats %d", NumFormats);
if ((NumFormats < 1) || (NumFormats > 1000))
{
WLog_ERR(TAG, "bad NumFormats %d", NumFormats);
@ -158,7 +158,7 @@ static int audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback, w
format.data = Stream_Pointer(s);
Stream_Seek(s, format.cbSize);
DEBUG_DVC("process_formats: wFormatTag=%d nChannels=%d nSamplesPerSec=%d "
DEBUG_DVC("wFormatTag=%d nChannels=%d nSamplesPerSec=%d "
"nBlockAlign=%d wBitsPerSample=%d cbSize=%d",
format.wFormatTag, format.nChannels, format.nSamplesPerSec,
format.nBlockAlign, format.wBitsPerSample, format.cbSize);
@ -171,7 +171,7 @@ static int audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback, w
continue;
if (audin->device && audin->device->FormatSupported(audin->device, &format))
{
DEBUG_DVC("process_formats: format ok");
DEBUG_DVC("format ok");
/* Store the agreed format in the corresponding index */
callback->formats[callback->formats_count++] = format;
@ -264,7 +264,7 @@ static int audin_process_open(IWTSVirtualChannelCallback* pChannelCallback, wStr
Stream_Read_UINT32(s, FramesPerPacket);
Stream_Read_UINT32(s, initialFormat);
DEBUG_DVC("process_open: FramesPerPacket=%d initialFormat=%d",
DEBUG_DVC("FramesPerPacket=%d initialFormat=%d",
FramesPerPacket, initialFormat);
if (initialFormat >= (UINT32) callback->formats_count)
@ -296,7 +296,7 @@ static int audin_process_format_change(IWTSVirtualChannelCallback* pChannelCallb
Stream_Read_UINT32(s, NewFormat);
DEBUG_DVC("process_format_change: NewFormat=%d", NewFormat);
DEBUG_DVC("NewFormat=%d", NewFormat);
if (NewFormat >= (UINT32) callback->formats_count)
{
@ -326,7 +326,7 @@ static int audin_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
Stream_Read_UINT8(data, MessageId);
DEBUG_DVC("on_data_received: MessageId=0x%x", MessageId);
DEBUG_DVC("MessageId=0x%x", MessageId);
switch (MessageId)
{
@ -360,7 +360,7 @@ static int audin_on_close(IWTSVirtualChannelCallback* pChannelCallback)
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) callback->plugin;
DEBUG_DVC("on_close");
DEBUG_DVC("...");
if (audin->device)
IFCALL(audin->device->Close, audin->device);
@ -378,7 +378,7 @@ static int audin_on_new_channel_connection(IWTSListenerCallback* pListenerCallba
AUDIN_CHANNEL_CALLBACK* callback;
AUDIN_LISTENER_CALLBACK* listener_callback = (AUDIN_LISTENER_CALLBACK*) pListenerCallback;
DEBUG_DVC("on_new_channel_connection");
DEBUG_DVC("...");
callback = (AUDIN_CHANNEL_CALLBACK*) malloc(sizeof(AUDIN_CHANNEL_CALLBACK));
ZeroMemory(callback, sizeof(AUDIN_CHANNEL_CALLBACK));
@ -398,7 +398,7 @@ static int audin_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManage
{
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) pPlugin;
DEBUG_DVC("plugin_initialize");
DEBUG_DVC("...");
audin->listener_callback = (AUDIN_LISTENER_CALLBACK*) malloc(sizeof(AUDIN_LISTENER_CALLBACK));
ZeroMemory(audin->listener_callback, sizeof(AUDIN_LISTENER_CALLBACK));
@ -415,7 +415,7 @@ static int audin_plugin_terminated(IWTSPlugin* pPlugin)
{
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) pPlugin;
DEBUG_DVC("plugin_terminated");
DEBUG_DVC("...");
if (audin->device)
{
@ -445,7 +445,7 @@ static void audin_register_device_plugin(IWTSPlugin* pPlugin, IAudinDevice* devi
return;
}
DEBUG_DVC("register_device_plugin: device registered.");
DEBUG_DVC("device registered.");
audin->device = device;
}

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

@ -161,7 +161,9 @@ static void audin_opensles_free(IAudinDevice* device)
static BOOL audin_opensles_format_supported(IAudinDevice* device, audinFormat* format)
{
#ifdef WITH_DEBUG_DVC
AudinOpenSLESDevice* opensles = (AudinOpenSLESDevice*) device;
#endif
DEBUG_DVC("device=%p, format=%p", opensles, format);

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

@ -37,9 +37,9 @@
#include <limits.h>
#include <unistd.h>
#if defined(__OpenBSD__)
#include <soundcard.h>
#include <soundcard.h>
#else
#include <sys/soundcard.h>
#include <sys/soundcard.h>
#endif
#include <sys/ioctl.h>
@ -49,14 +49,15 @@
#include "audin_main.h"
typedef struct _AudinOSSDevice {
typedef struct _AudinOSSDevice
{
IAudinDevice iface;
FREERDP_DSP_CONTEXT* dsp_context;
HANDLE thread;
HANDLE stopEvent;
audinFormat format;
UINT32 FramesPerPacket;
int dev_unit;
@ -70,193 +71,259 @@ typedef struct _AudinOSSDevice {
WLog_ERR(TAG, "%s: %i - %s\n", _text, _error, strerror(_error));
static int audin_oss_get_format(audinFormat *format) {
static int audin_oss_get_format(audinFormat* format)
{
switch (format->wFormatTag)
{
case WAVE_FORMAT_PCM:
switch (format->wFormatTag) {
case WAVE_FORMAT_PCM:
switch (format->wBitsPerSample) {
case 8:
return AFMT_S8;
case 16:
return AFMT_S16_LE;
}
break;
case WAVE_FORMAT_ALAW:
return AFMT_A_LAW;
switch (format->wBitsPerSample)
{
case 8:
return AFMT_S8;
case 16:
return AFMT_S16_LE;
}
break;
case WAVE_FORMAT_ALAW:
return AFMT_A_LAW;
#if 0 /* This does not work on my desktop. */
case WAVE_FORMAT_MULAW:
return AFMT_MU_LAW;
case WAVE_FORMAT_MULAW:
return AFMT_MU_LAW;
#endif
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
return AFMT_S16_LE;
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
return AFMT_S16_LE;
}
return 0;
}
static BOOL audin_oss_format_supported(IAudinDevice *device, audinFormat *format) {
static BOOL audin_oss_format_supported(IAudinDevice* device, audinFormat* format)
{
int req_fmt = 0;
if (device == NULL || format == NULL)
return FALSE;
switch (format->wFormatTag) {
case WAVE_FORMAT_PCM:
if (format->cbSize != 0 ||
format->nSamplesPerSec > 48000 ||
(format->wBitsPerSample != 8 && format->wBitsPerSample != 16) ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
if (format->nSamplesPerSec > 48000 ||
format->wBitsPerSample != 4 ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
switch (format->wFormatTag)
{
case WAVE_FORMAT_PCM:
if (format->cbSize != 0 ||
format->nSamplesPerSec > 48000 ||
(format->wBitsPerSample != 8 && format->wBitsPerSample != 16) ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
if (format->nSamplesPerSec > 48000 ||
format->wBitsPerSample != 4 ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
}
req_fmt = audin_oss_get_format(format);
if (req_fmt == 0)
return FALSE;
return TRUE;
}
static void audin_oss_set_format(IAudinDevice *device, audinFormat *format, UINT32 FramesPerPacket) {
AudinOSSDevice *oss = (AudinOSSDevice*)device;
static void audin_oss_set_format(IAudinDevice* device, audinFormat* format, UINT32 FramesPerPacket)
{
AudinOSSDevice* oss = (AudinOSSDevice*)device;
if (device == NULL || format == NULL)
return;
oss->FramesPerPacket = FramesPerPacket;
CopyMemory(&(oss->format), format, sizeof(audinFormat));
switch (format->wFormatTag) {
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
oss->FramesPerPacket *= 4; /* Compression ratio. */
oss->format.wBitsPerSample *= 4;
break;
switch (format->wFormatTag)
{
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
oss->FramesPerPacket *= 4; /* Compression ratio. */
oss->format.wBitsPerSample *= 4;
break;
}
}
static void *audin_oss_thread_func(void *arg)
static void* audin_oss_thread_func(void* arg)
{
char dev_name[PATH_MAX] = "/dev/dsp";
int pcm_handle = -1;
BYTE *buffer = NULL, *encoded_data;
char mixer_name[PATH_MAX] = "/dev/mixer";
int pcm_handle = -1, mixer_handle;
BYTE* buffer = NULL, *encoded_data;
int tmp, buffer_size, encoded_size;
AudinOSSDevice *oss = (AudinOSSDevice*)arg;
AudinOSSDevice* oss = (AudinOSSDevice*)arg;
if (arg == NULL)
goto err_out;
if (oss->dev_unit != -1)
{
snprintf(dev_name, (PATH_MAX - 1), "/dev/dsp%i", oss->dev_unit);
snprintf(mixer_name, PATH_MAX - 1, "/dev/mixer%i", oss->dev_unit);
}
WLog_INFO(TAG, "open: %s", dev_name);
if ((pcm_handle = open(dev_name, O_RDONLY)) < 0) {
if ((pcm_handle = open(dev_name, O_RDONLY)) < 0)
{
OSS_LOG_ERR("sound dev open failed", errno);
goto err_out;
}
/* Set rec volume to 100%. */
if ((mixer_handle = open(mixer_name, O_RDWR)) < 0)
{
OSS_LOG_ERR("mixer open failed, not critical", errno);
}
else
{
tmp = (100 | (100 << 8));
if (ioctl(mixer_handle, MIXER_WRITE(SOUND_MIXER_MIC), &tmp) == -1)
OSS_LOG_ERR("WRITE_MIXER - SOUND_MIXER_MIC, not critical", errno);
tmp = (100 | (100 << 8));
if (ioctl(mixer_handle, MIXER_WRITE(SOUND_MIXER_RECLEV), &tmp) == -1)
OSS_LOG_ERR("WRITE_MIXER - SOUND_MIXER_RECLEV, not critical", errno);
close(mixer_handle);
}
#if 0 /* FreeBSD OSS implementation at this moment (2015.03) does not set PCM_CAP_INPUT flag. */
tmp = 0;
if (ioctl(pcm_handle, SNDCTL_DSP_GETCAPS, &tmp) == -1) {
if (ioctl(pcm_handle, SNDCTL_DSP_GETCAPS, &tmp) == -1)
{
OSS_LOG_ERR("SNDCTL_DSP_GETCAPS failed, try ignory", errno);
} else if ((tmp & PCM_CAP_INPUT) == 0) {
}
else if ((tmp & PCM_CAP_INPUT) == 0)
{
OSS_LOG_ERR("Device does not supports playback", EOPNOTSUPP);
goto err_out;
}
#endif
/* Set format. */
tmp = audin_oss_get_format(&oss->format);
if (ioctl(pcm_handle, SNDCTL_DSP_SETFMT, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SETFMT failed", errno);
tmp = oss->format.nChannels;
if (ioctl(pcm_handle, SNDCTL_DSP_CHANNELS, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_CHANNELS failed", errno);
tmp = oss->format.nSamplesPerSec;
if (ioctl(pcm_handle, SNDCTL_DSP_SPEED, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SPEED failed", errno);
tmp = oss->format.nBlockAlign;
if (ioctl(pcm_handle, SNDCTL_DSP_SETFRAGMENT, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SETFRAGMENT failed", errno);
buffer_size = (oss->FramesPerPacket * oss->format.nChannels * (oss->format.wBitsPerSample / 8));
buffer_size = (oss->FramesPerPacket * oss->format.nChannels * (oss->format.wBitsPerSample / 8));
buffer = (BYTE*)malloc((buffer_size + sizeof(void*)));
if (NULL == buffer) {
if (NULL == buffer)
{
OSS_LOG_ERR("malloc() fail", errno);
goto err_out;
}
ZeroMemory(buffer, buffer_size);
ZeroMemory(buffer, buffer_size);
freerdp_dsp_context_reset_adpcm(oss->dsp_context);
while (WaitForSingleObject(oss->stopEvent, 0) != WAIT_OBJECT_0) {
while (WaitForSingleObject(oss->stopEvent, 0) != WAIT_OBJECT_0)
{
tmp = read(pcm_handle, buffer, buffer_size);
if (tmp < 0) { /* Error happen. */
/* Error happen. */
if (tmp < 0)
{
OSS_LOG_ERR("read() error", errno);
continue;
}
if (tmp < buffer_size) /* Not enouth data. */
continue;
/* Process. */
switch (oss->format.wFormatTag) {
case WAVE_FORMAT_ADPCM:
oss->dsp_context->encode_ms_adpcm(oss->dsp_context,
buffer, buffer_size, oss->format.nChannels, oss->format.nBlockAlign);
encoded_data = oss->dsp_context->adpcm_buffer;
encoded_size = oss->dsp_context->adpcm_size;
break;
case WAVE_FORMAT_DVI_ADPCM:
oss->dsp_context->encode_ima_adpcm(oss->dsp_context,
buffer, buffer_size, oss->format.nChannels, oss->format.nBlockAlign);
encoded_data = oss->dsp_context->adpcm_buffer;
encoded_size = oss->dsp_context->adpcm_size;
break;
default:
encoded_data = buffer;
encoded_size = buffer_size;
break;
switch (oss->format.wFormatTag)
{
case WAVE_FORMAT_ADPCM:
oss->dsp_context->encode_ms_adpcm(oss->dsp_context,
buffer, buffer_size, oss->format.nChannels, oss->format.nBlockAlign);
encoded_data = oss->dsp_context->adpcm_buffer;
encoded_size = oss->dsp_context->adpcm_size;
break;
case WAVE_FORMAT_DVI_ADPCM:
oss->dsp_context->encode_ima_adpcm(oss->dsp_context,
buffer, buffer_size, oss->format.nChannels, oss->format.nBlockAlign);
encoded_data = oss->dsp_context->adpcm_buffer;
encoded_size = oss->dsp_context->adpcm_size;
break;
default:
encoded_data = buffer;
encoded_size = buffer_size;
break;
}
if (0 != oss->receive(encoded_data, encoded_size, oss->user_data))
if (0 == oss->receive(encoded_data, encoded_size, oss->user_data))
break;
}
err_out:
if (pcm_handle != -1)
{
WLog_INFO(TAG, "close: %s", dev_name);
close(pcm_handle);
}
free(buffer);
ExitThread(0);
return NULL;
}
static void audin_oss_open(IAudinDevice *device, AudinReceive receive, void *user_data) {
AudinOSSDevice *oss = (AudinOSSDevice*)device;
static void audin_oss_open(IAudinDevice* device, AudinReceive receive, void* user_data)
{
AudinOSSDevice* oss = (AudinOSSDevice*)device;
oss->receive = receive;
oss->user_data = user_data;
oss->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
oss->thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)audin_oss_thread_func, oss, 0, NULL);
}
static void audin_oss_close(IAudinDevice *device) {
AudinOSSDevice *oss = (AudinOSSDevice*)device;
static void audin_oss_close(IAudinDevice* device)
{
AudinOSSDevice* oss = (AudinOSSDevice*)device;
if (device == NULL)
return;
if (oss->stopEvent != NULL) {
if (oss->stopEvent != NULL)
{
SetEvent(oss->stopEvent);
WaitForSingleObject(oss->thread, INFINITE);
CloseHandle(oss->stopEvent);
oss->stopEvent = NULL;
CloseHandle(oss->thread);
oss->thread = NULL;
}
@ -265,81 +332,79 @@ static void audin_oss_close(IAudinDevice *device) {
oss->user_data = NULL;
}
static void audin_oss_free(IAudinDevice *device) {
AudinOSSDevice *oss = (AudinOSSDevice*)device;
static void audin_oss_free(IAudinDevice* device)
{
AudinOSSDevice* oss = (AudinOSSDevice*)device;
if (device == NULL)
return;
audin_oss_close(device);
freerdp_dsp_context_free(oss->dsp_context);
free(oss);
}
COMMAND_LINE_ARGUMENT_A audin_oss_args[] = {
COMMAND_LINE_ARGUMENT_A audin_oss_args[] =
{
{ "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", NULL, NULL, -1, NULL, "audio device name" },
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
};
static void audin_oss_parse_addin_args(AudinOSSDevice *device, ADDIN_ARGV *args) {
static void audin_oss_parse_addin_args(AudinOSSDevice* device, ADDIN_ARGV* args)
{
int status;
char *str_num, *eptr;
char* str_num, *eptr;
DWORD flags;
COMMAND_LINE_ARGUMENT_A *arg;
AudinOSSDevice *oss = (AudinOSSDevice*)device;
COMMAND_LINE_ARGUMENT_A* arg;
AudinOSSDevice* oss = (AudinOSSDevice*)device;
flags = COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON | COMMAND_LINE_IGN_UNKNOWN_KEYWORD;
status = CommandLineParseArgumentsA(args->argc, (const char**)args->argv, audin_oss_args, flags, oss, NULL, NULL);
if (status < 0)
return;
arg = audin_oss_args;
do {
do
{
if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
continue;
CommandLineSwitchStart(arg)
CommandLineSwitchCase(arg, "dev") {
CommandLineSwitchCase(arg, "dev")
{
str_num = _strdup(arg->Value);
oss->dev_unit = strtol(str_num, &eptr, 10);
if (oss->dev_unit < 0 || *eptr != '\0')
oss->dev_unit = -1;
free(str_num);
}
CommandLineSwitchEnd(arg)
} while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
}
while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
}
#ifdef STATIC_CHANNELS
#define freerdp_audin_client_subsystem_entry oss_freerdp_audin_client_subsystem_entry
#endif
int freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints) {
ADDIN_ARGV *args;
AudinOSSDevice *oss;
int freerdp_audin_client_subsystem_entry(PFREERDP_AUDIN_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
AudinOSSDevice* oss;
oss = (AudinOSSDevice*)malloc(sizeof(AudinOSSDevice));
ZeroMemory(oss, sizeof(AudinOSSDevice));
oss->iface.Open = audin_oss_open;
oss->iface.FormatSupported = audin_oss_format_supported;
oss->iface.SetFormat = audin_oss_set_format;
oss->iface.Close = audin_oss_close;
oss->iface.Free = audin_oss_free;
oss->dev_unit = -1;
args = pEntryPoints->args;
audin_oss_parse_addin_args(oss, args);
oss->dsp_context = freerdp_dsp_context_new();
pEntryPoints->pRegisterAudinDevice(pEntryPoints->plugin, (IAudinDevice*)oss);
return 0;
}

2
channels/cliprdr/client/cliprdr_main.c
View File

@ -458,7 +458,7 @@ int cliprdr_temp_directory(CliprdrClientContext* context, CLIPRDR_TEMP_DIRECTORY
if (length > 520)
length = 520;
Stream_Write(s, tempDirectory->szTempDir, length * 2);
Stream_Write(s, wszTempDir, length * 2);
Stream_Zero(s, (520 - length) * 2);
free(wszTempDir);

5
channels/rail/client/rail_main.c
View File

@ -575,6 +575,8 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
CHANNEL_ENTRY_POINTS_FREERDP* pEntryPointsEx;
rail = (railPlugin*) calloc(1, sizeof(railPlugin));
if (!rail)
return FALSE;
rail->channelDef.options =
CHANNEL_OPTION_INITIALIZED |
@ -591,7 +593,10 @@ BOOL VCAPITYPE VirtualChannelEntry(PCHANNEL_ENTRY_POINTS pEntryPoints)
{
context = (RailClientContext*) calloc(1, sizeof(RailClientContext));
if (!context)
{
free(rail);
return FALSE;
}
context->handle = (void*) rail;
context->custom = NULL;

2
channels/rdpgfx/client/rdpgfx_main.c
View File

@ -854,6 +854,8 @@ static int rdpgfx_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
}
s = Stream_New(pDstData, DstSize);
if (!s)
return 0;
while (((size_t) Stream_GetPosition(s)) < Stream_Length(s))
{

2
channels/rdpsnd/client/opensles/opensl_io.h
View File

@ -77,7 +77,7 @@ typedef struct opensl_stream {
/*
* Set the volume input level.
*/
void android_SetOutputVolume(OPENSL_STREAM *p, int level);
void android_SetInputVolume(OPENSL_STREAM *p, int level);
/*
* Get the current output mute setting.
*/

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

@ -37,9 +37,9 @@
#include <limits.h>
#include <unistd.h>
#if defined(__OpenBSD__)
#include <soundcard.h>
#include <soundcard.h>
#else
#include <sys/soundcard.h>
#include <sys/soundcard.h>
#endif
#include <sys/ioctl.h>
@ -51,7 +51,8 @@
typedef struct rdpsnd_oss_plugin rdpsndOssPlugin;
struct rdpsnd_oss_plugin {
struct rdpsnd_oss_plugin
{
rdpsndDevicePlugin device;
int pcm_handle;
@ -63,68 +64,85 @@ struct rdpsnd_oss_plugin {
int latency;
AUDIO_FORMAT format;
FREERDP_DSP_CONTEXT *dsp_context;
FREERDP_DSP_CONTEXT* dsp_context;
};
#define OSS_LOG_ERR(_text, _error) \
if (_error != 0) \
WLog_ERR(TAG, "%s: %i - %s", _text, _error, strerror(_error));
{ \
if (_error != 0) \
WLog_ERR(TAG, "%s: %i - %s", _text, _error, strerror(_error)); \
}
static int rdpsnd_oss_get_format(AUDIO_FORMAT *format) {
static int rdpsnd_oss_get_format(AUDIO_FORMAT* format)
{
switch (format->wFormatTag)
{
case WAVE_FORMAT_PCM:
switch (format->wFormatTag) {
case WAVE_FORMAT_PCM:
switch (format->wBitsPerSample) {
case 8:
return AFMT_S8;
case 16:
return AFMT_S16_LE;
}
break;
case WAVE_FORMAT_ALAW:
return AFMT_A_LAW;
switch (format->wBitsPerSample)
{
case 8:
return AFMT_S8;
case 16:
return AFMT_S16_LE;
}
break;
case WAVE_FORMAT_ALAW:
return AFMT_A_LAW;
#if 0 /* This does not work on my desktop. */
case WAVE_FORMAT_MULAW:
return AFMT_MU_LAW;
case WAVE_FORMAT_MULAW:
return AFMT_MU_LAW;
#endif
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
return AFMT_S16_LE;
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
return AFMT_S16_LE;
}
return 0;
}
static BOOL rdpsnd_oss_format_supported(rdpsndDevicePlugin *device, AUDIO_FORMAT *format) {
static BOOL rdpsnd_oss_format_supported(rdpsndDevicePlugin* device, AUDIO_FORMAT* format)
{
int req_fmt = 0;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL || format == NULL)
return FALSE;
switch (format->wFormatTag) {
case WAVE_FORMAT_PCM:
if (format->cbSize != 0 ||
format->nSamplesPerSec > 48000 ||
(format->wBitsPerSample != 8 && format->wBitsPerSample != 16) ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
if (format->nSamplesPerSec > 48000 ||
format->wBitsPerSample != 4 ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
switch (format->wFormatTag)
{
case WAVE_FORMAT_PCM:
if (format->cbSize != 0 ||
format->nSamplesPerSec > 48000 ||
(format->wBitsPerSample != 8 && format->wBitsPerSample != 16) ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
case WAVE_FORMAT_ADPCM:
case WAVE_FORMAT_DVI_ADPCM:
if (format->nSamplesPerSec > 48000 ||
format->wBitsPerSample != 4 ||
(format->nChannels != 1 && format->nChannels != 2))
return FALSE;
break;
}
req_fmt = rdpsnd_oss_get_format(format);
if (oss->pcm_handle != -1) { /* Check really supported formats by dev. */
/* Check really supported formats by dev. */
if (oss->pcm_handle != -1)
{
if ((req_fmt & oss->supported_formats) == 0)
return FALSE;
} else {
}
else
{
if (req_fmt == 0)
return FALSE;
}
@ -132,45 +150,57 @@ static BOOL rdpsnd_oss_format_supported(rdpsndDevicePlugin *device, AUDIO_FORMAT
return TRUE;
}
static void rdpsnd_oss_set_format(rdpsndDevicePlugin *device, AUDIO_FORMAT *format, int latency) {
static void rdpsnd_oss_set_format(rdpsndDevicePlugin* device, AUDIO_FORMAT* format, int latency)
{
int tmp;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL || oss->pcm_handle == -1 || format == NULL)
return;
oss->latency = latency;
CopyMemory(&(oss->format), format, sizeof(AUDIO_FORMAT));
tmp = rdpsnd_oss_get_format(format);
if (ioctl(oss->pcm_handle, SNDCTL_DSP_SETFMT, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SETFMT failed", errno);
tmp = format->nChannels;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_CHANNELS, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_CHANNELS failed", errno);
tmp = format->nSamplesPerSec;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_SPEED, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SPEED failed", errno);
tmp = format->nBlockAlign;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_SETFRAGMENT, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SETFRAGMENT failed", errno);
}
static void rdpsnd_oss_open_mixer(rdpsndOssPlugin *oss) {
static void rdpsnd_oss_open_mixer(rdpsndOssPlugin* oss)
{
int devmask = 0;
char mixer[PATH_MAX] = "/dev/mixer";
char mixer_name[PATH_MAX] = "/dev/mixer";
if (oss->mixer_handle != -1)
return;
if (oss->dev_unit != -1)
snprintf(mixer, PATH_MAX - 1, "/dev/mixer%i", oss->dev_unit);
if ((oss->mixer_handle = open(mixer, O_RDWR)) < 0) {
snprintf(mixer_name, PATH_MAX - 1, "/dev/mixer%i", oss->dev_unit);
if ((oss->mixer_handle = open(mixer_name, O_RDWR)) < 0)
{
OSS_LOG_ERR("mixer open failed", errno);
oss->mixer_handle = -1;
return;
}
if (ioctl(oss->mixer_handle, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
if (ioctl(oss->mixer_handle, SOUND_MIXER_READ_DEVMASK, &devmask) == -1)
{
OSS_LOG_ERR("SOUND_MIXER_READ_DEVMASK failed", errno);
close(oss->mixer_handle);
oss->mixer_handle = -1;
@ -178,158 +208,172 @@ static void rdpsnd_oss_open_mixer(rdpsndOssPlugin *oss) {
}
}
static void rdpsnd_oss_open(rdpsndDevicePlugin *device, AUDIO_FORMAT *format, int latency) {
static void rdpsnd_oss_open(rdpsndDevicePlugin* device, AUDIO_FORMAT* format, int latency)
{
char dev_name[PATH_MAX] = "/dev/dsp";
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL || oss->pcm_handle != -1)
return;
if (oss->dev_unit != -1)
snprintf(dev_name, PATH_MAX - 1, "/dev/dsp%i", oss->dev_unit);
WLog_INFO(TAG, "open: %s", dev_name);
if ((oss->pcm_handle = open(dev_name, O_WRONLY)) < 0) {
if ((oss->pcm_handle = open(dev_name, O_WRONLY)) < 0)
{
OSS_LOG_ERR("sound dev open failed", errno);
oss->pcm_handle = -1;
return;
}
#if 0 /* FreeBSD OSS implementation at this moment (2015.03) does not set PCM_CAP_OUTPUT flag. */
int mask = 0;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_GETCAPS, &mask) == -1) {
if (ioctl(oss->pcm_handle, SNDCTL_DSP_GETCAPS, &mask) == -1)
{
OSS_LOG_ERR("SNDCTL_DSP_GETCAPS failed, try ignory", errno);
} else if ((mask & PCM_CAP_OUTPUT) == 0) {
}
else if ((mask & PCM_CAP_OUTPUT) == 0)
{
OSS_LOG_ERR("Device does not supports playback", EOPNOTSUPP);
close(oss->pcm_handle);
oss->pcm_handle = -1;
return;
}
#endif
if (ioctl(oss->pcm_handle, SNDCTL_DSP_GETFMTS, &oss->supported_formats) == -1) {
if (ioctl(oss->pcm_handle, SNDCTL_DSP_GETFMTS, &oss->supported_formats) == -1)
{
OSS_LOG_ERR("SNDCTL_DSP_GETFMTS failed", errno);
close(oss->pcm_handle);
oss->pcm_handle = -1;
return;
}
freerdp_dsp_context_reset_adpcm(oss->dsp_context);
rdpsnd_oss_set_format(device, format, latency);
rdpsnd_oss_open_mixer(oss);
}
static void rdpsnd_oss_close(rdpsndDevicePlugin *device) {
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
static void rdpsnd_oss_close(rdpsndDevicePlugin* device)
{
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL)
return;
if (oss->pcm_handle != -1) {
if (oss->pcm_handle != -1)
{
WLog_INFO(TAG, "close: dsp");
close(oss->pcm_handle);
oss->pcm_handle = -1;
}
if (oss->mixer_handle != -1) {
if (oss->mixer_handle != -1)
{
WLog_INFO(TAG, "close: mixer");
close(oss->mixer_handle);
oss->mixer_handle = -1;
}
}
static void rdpsnd_oss_free(rdpsndDevicePlugin *device) {
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
static void rdpsnd_oss_free(rdpsndDevicePlugin* device)
{
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL)
return;
rdpsnd_oss_close(device);
freerdp_dsp_context_free(oss->dsp_context);
free(oss);
}
static UINT32 rdpsnd_oss_get_volume(rdpsndDevicePlugin *device) {
static UINT32 rdpsnd_oss_get_volume(rdpsndDevicePlugin* device)
{
int vol;
UINT32 dwVolume;
UINT16 dwVolumeLeft, dwVolumeRight;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
/* On error return 50% volume. */
dwVolumeLeft = ((50 * 0xFFFF) / 100); /* 50% */
dwVolumeRight = ((50 * 0xFFFF) / 100); /* 50% */
dwVolume = ((dwVolumeLeft << 16) | dwVolumeRight);
if (device == NULL || oss->mixer_handle == -1)
return dwVolume;
if (ioctl(oss->mixer_handle, MIXER_READ(SOUND_MIXER_VOLUME), &vol) == -1) {
if (ioctl(oss->mixer_handle, MIXER_READ(SOUND_MIXER_VOLUME), &vol) == -1)
{
OSS_LOG_ERR("MIXER_READ", errno);
return dwVolume;
}
dwVolumeLeft = (((vol & 0x7f) * 0xFFFF) / 100);
dwVolumeRight = ((((vol >> 8) & 0x7f) * 0xFFFF) / 100);
dwVolume = ((dwVolumeLeft << 16) | dwVolumeRight);
return dwVolume;
}
static void rdpsnd_oss_set_volume(rdpsndDevicePlugin *device, UINT32 value) {
static void rdpsnd_oss_set_volume(rdpsndDevicePlugin* device, UINT32 value)
{
int left, right;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL || oss->mixer_handle == -1)
return;
left = (value & 0xFFFF);
right = ((value >> 16) & 0xFFFF);
left = (((value & 0xFFFF) * 100) / 0xFFFF);
right = ((((value >> 16) & 0xFFFF) * 100) / 0xFFFF);
if (left < 0)
left = 0;
else if (left > 100)
left = 100;
if (right < 0)
right = 0;
else if (right > 100)
right = 100;
left |= (right << 8);
if (ioctl(oss->mixer_handle, MIXER_WRITE(SOUND_MIXER_VOLUME), &left) == -1)
OSS_LOG_ERR("WRITE_MIXER", errno);
}
static void rdpsnd_oss_wave_decode(rdpsndDevicePlugin *device, RDPSND_WAVE *wave) {
int size;
BYTE *data;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
static void rdpsnd_oss_wave_decode(rdpsndDevicePlugin* device, RDPSND_WAVE* wave)
{
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL || wave == NULL)
return;
switch (oss->format.wFormatTag) {
case WAVE_FORMAT_ADPCM:
oss->dsp_context->decode_ms_adpcm(oss->dsp_context,
wave->data, wave->length, oss->format.nChannels, oss->format.nBlockAlign);
size = oss->dsp_context->adpcm_size;
data = oss->dsp_context->adpcm_buffer;
break;
case WAVE_FORMAT_DVI_ADPCM:
oss->dsp_context->decode_ima_adpcm(oss->dsp_context,
wave->data, wave->length, oss->format.nChannels, oss->format.nBlockAlign);
size = oss->dsp_context->adpcm_size;
data = oss->dsp_context->adpcm_buffer;
break;
default:
size = wave->length;
data = wave->data;
switch (oss->format.wFormatTag)
{
case WAVE_FORMAT_ADPCM:
oss->dsp_context->decode_ms_adpcm(oss->dsp_context,
wave->data, wave->length, oss->format.nChannels, oss->format.nBlockAlign);
wave->length = oss->dsp_context->adpcm_size;
wave->data = oss->dsp_context->adpcm_buffer;
break;
case WAVE_FORMAT_DVI_ADPCM:
oss->dsp_context->decode_ima_adpcm(oss->dsp_context,
wave->data, wave->length, oss->format.nChannels, oss->format.nBlockAlign);
wave->length = oss->dsp_context->adpcm_size;
wave->data = oss->dsp_context->adpcm_buffer;
break;
}
wave->data = (BYTE*)malloc(size);
CopyMemory(wave->data, data, size);
wave->length = size;
}
static void rdpsnd_oss_wave_play(rdpsndDevicePlugin *device, RDPSND_WAVE *wave) {
BYTE *data;
int offset, size, status;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
static void rdpsnd_oss_wave_play(rdpsndDevicePlugin* device, RDPSND_WAVE* wave)
{
BYTE* data;
int offset, size, status, latency;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
if (device == NULL || wave == NULL)
return;
@ -337,61 +381,69 @@ static void rdpsnd_oss_wave_play(rdpsndDevicePlugin *device, RDPSND_WAVE *wave)
offset = 0;
data = wave->data;
size = wave->length;
latency = oss->latency;
while (offset < size) {
while (offset < size)
{
status = write(oss->pcm_handle, &data[offset], (size - offset));
if (status < 0) {
if (status < 0)
{
OSS_LOG_ERR("write fail", errno);
rdpsnd_oss_close(device);
rdpsnd_oss_open(device, NULL, 0);
rdpsnd_oss_open(device, NULL, latency);
break;
}
offset += status;
}
/* From rdpsnd_main.c */
wave->wTimeStampB = wave->wTimeStampA + wave->wAudioLength + 65;
wave->wLocalTimeB = wave->wLocalTimeA + wave->wAudioLength + 65;
free(data);
/* From rdpsnd_main.c */
wave->wTimeStampB = wave->wTimeStampA + wave->wAudioLength + 65 + latency;
wave->wLocalTimeB = wave->wLocalTimeA + wave->wAudioLength + 65 + latency;
}
static COMMAND_LINE_ARGUMENT_A rdpsnd_oss_args[] = {
static COMMAND_LINE_ARGUMENT_A rdpsnd_oss_args[] =
{
{ "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", NULL, NULL, -1, NULL, "device" },
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
};
static int rdpsnd_oss_parse_addin_args(rdpsndDevicePlugin *device, ADDIN_ARGV *args) {
static int rdpsnd_oss_parse_addin_args(rdpsndDevicePlugin* device, ADDIN_ARGV* args)
{
int status;
char *str_num, *eptr;
char* str_num, *eptr;
DWORD flags;
COMMAND_LINE_ARGUMENT_A *arg;
rdpsndOssPlugin *oss = (rdpsndOssPlugin*)device;
COMMAND_LINE_ARGUMENT_A* arg;
rdpsndOssPlugin* oss = (rdpsndOssPlugin*)device;
flags = COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON | COMMAND_LINE_IGN_UNKNOWN_KEYWORD;
status = CommandLineParseArgumentsA(args->argc, (const char**)args->argv, rdpsnd_oss_args, flags, oss, NULL, NULL);
if (status < 0)
return status;
arg = rdpsnd_oss_args;
do {
do
{
if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
continue;
CommandLineSwitchStart(arg)
CommandLineSwitchCase(arg, "dev") {
CommandLineSwitchCase(arg, "dev")
{
str_num = _strdup(arg->Value);
oss->dev_unit = strtol(str_num, &eptr, 10);
if (oss->dev_unit < 0 || *eptr != '\0')
oss->dev_unit = -1;
free(str_num);
}
CommandLineSwitchEnd(arg)
} while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
}
while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
return status;
}
@ -400,13 +452,12 @@ static int rdpsnd_oss_parse_addin_args(rdpsndDevicePlugin *device, ADDIN_ARGV *a
#define freerdp_rdpsnd_client_subsystem_entry oss_freerdp_rdpsnd_client_subsystem_entry
#endif
int freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints) {
ADDIN_ARGV *args;
rdpsndOssPlugin *oss;
int freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
ADDIN_ARGV* args;
rdpsndOssPlugin* oss;
oss = (rdpsndOssPlugin*)malloc(sizeof(rdpsndOssPlugin));
ZeroMemory(oss, sizeof(rdpsndOssPlugin));
oss->device.Open = rdpsnd_oss_open;
oss->device.FormatSupported = rdpsnd_oss_format_supported;
oss->device.SetFormat = rdpsnd_oss_set_format;
@ -416,17 +467,12 @@ int freerdp_rdpsnd_client_subsystem_entry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pE
oss->device.WavePlay = rdpsnd_oss_wave_play;
oss->device.Close = rdpsnd_oss_close;
oss->device.Free = rdpsnd_oss_free;
oss->pcm_handle = -1;
oss->mixer_handle = -1;
oss->dev_unit = -1;
args = pEntryPoints->args;
rdpsnd_oss_parse_addin_args((rdpsndDevicePlugin*)oss, args);
oss->dsp_context = freerdp_dsp_context_new();
pEntryPoints->pRegisterRdpsndDevice(pEntryPoints->rdpsnd, (rdpsndDevicePlugin*)oss);
return 0;
}

4
channels/tsmf/client/CMakeLists.txt
View File

@ -62,6 +62,10 @@ if(WITH_GSTREAMER_0_10 OR WITH_GSTREAMER_1_0)
endif()
endif()
if(WITH_OSS)
add_channel_client_subsystem(${MODULE_PREFIX} ${CHANNEL_NAME} "oss" "audio")
endif()
if(WITH_ALSA)
add_channel_client_subsystem(${MODULE_PREFIX} ${CHANNEL_NAME} "alsa" "audio")
endif()

3
channels/tsmf/client/alsa/tsmf_alsa.c
View File

@ -68,8 +68,7 @@ static BOOL tsmf_alsa_open(ITSMFAudioDevice *audio, const char *device)
TSMFAlsaAudioDevice *alsa = (TSMFAlsaAudioDevice *) audio;
if(!device)
{
if(!alsa->device[0])
strncpy(alsa->device, "default", sizeof(alsa->device));
strncpy(alsa->device, "default", sizeof(alsa->device));
}
else
{

23
channels/tsmf/client/gstreamer/tsmf_X11.c
View File

@ -25,6 +25,9 @@
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <err.h>
#include <errno.h>
#include <winpr/thread.h>
#include <gst/gst.h>
@ -61,8 +64,8 @@ struct X11Handle
static const char* get_shm_id()
{
static char shm_id[64];
snprintf(shm_id, sizeof(shm_id), "com.freerdp.xfreerdp.tsmf_%016X", GetCurrentProcessId());
static char shm_id[128];
snprintf(shm_id, sizeof(shm_id), "/com.freerdp.xfreerdp.tsmf_%016X", GetCurrentProcessId());
return shm_id;
}
@ -87,7 +90,6 @@ int tsmf_platform_create(TSMFGstreamerDecoder* decoder)
return -1;
hdl = calloc(1, sizeof(struct X11Handle));
if (!hdl)
{
WLog_ERR(TAG, "Could not allocate handle.");
@ -95,26 +97,21 @@ int tsmf_platform_create(TSMFGstreamerDecoder* decoder)
}
decoder->platform = hdl;
hdl->shmid = shm_open(get_shm_id(), O_RDWR, PROT_READ | PROT_WRITE);;
if (hdl->shmid < 0)
hdl->shmid = shm_open(get_shm_id(), (O_RDWR | O_CREAT), (PROT_READ | PROT_WRITE));
if (hdl->shmid == -1)
{
WLog_ERR(TAG, "failed to get access to shared memory - shmget()");
WLog_ERR(TAG, "failed to get access to shared memory - shmget(%s): %i - %s", get_shm_id(), errno, strerror(errno));
return -2;
}
else
{
hdl->xfwin = mmap(0, sizeof(void *), PROT_READ | PROT_WRITE, MAP_SHARED, hdl->shmid, 0);
}
if (hdl->xfwin == (int*)-1)
hdl->xfwin = mmap(0, sizeof(void *), PROT_READ | PROT_WRITE, MAP_SHARED, hdl->shmid, 0);
if (hdl->xfwin == MAP_FAILED)
{
WLog_ERR(TAG, "shmat failed!");
return -3;
}
hdl->disp = XOpenDisplay(NULL);
if (!hdl->disp)
{
WLog_ERR(TAG, "Failed to open display");

32
channels/tsmf/client/oss/CMakeLists.txt Normal file
View File

@ -0,0 +1,32 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright (c) 2015 Rozhuk Ivan <rozhuk.im@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.
define_channel_client_subsystem("tsmf" "oss" "audio")
set(${MODULE_PREFIX}_SRCS
tsmf_oss.c)
include_directories(..)
include_directories(${OSS_INCLUDE_DIRS})
add_channel_client_subsystem_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} "" TRUE "")
target_link_libraries(${MODULE_NAME} freerdp ${OSS_LIBRARIES})
install(TARGETS ${MODULE_NAME} DESTINATION ${FREERDP_ADDIN_PATH} EXPORT FreeRDPTargets)

251
channels/tsmf/client/oss/tsmf_oss.c Normal file
View File

@ -0,0 +1,251 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Video Redirection Virtual Channel - OSS Audio Device
*
* Copyright (c) 2015 Rozhuk Ivan <rozhuk.im@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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <winpr/crt.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <limits.h>
#include <unistd.h>
#include <sys/soundcard.h>
#include <sys/ioctl.h>
#include <freerdp/types.h>
#include <freerdp/codec/dsp.h>
#include "tsmf_audio.h"
typedef struct _TSMFOSSAudioDevice
{
ITSMFAudioDevice iface;
char dev_name[PATH_MAX];
int pcm_handle;
UINT32 sample_rate;
UINT32 channels;
UINT32 bits_per_sample;
UINT32 data_size_last;
} TSMFOssAudioDevice;
#define OSS_LOG_ERR(_text, _error) \
if (_error != 0) \
WLog_ERR(TAG, "%s: %i - %s", _text, _error, strerror(_error));
static BOOL tsmf_oss_open(ITSMFAudioDevice* audio, const char* device)
{
int tmp;
TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio;
if (oss == NULL || oss->pcm_handle != -1)
return FALSE;
if (device == NULL) /* Default device. */
{
strncpy(oss->dev_name, "/dev/dsp", sizeof(oss->dev_name));
}
else
{
strncpy(oss->dev_name, device, sizeof(oss->dev_name));
}
if ((oss->pcm_handle = open(oss->dev_name, O_WRONLY)) < 0)
{
OSS_LOG_ERR("sound dev open failed", errno);
oss->pcm_handle = -1;
return FALSE;
}
#if 0 /* FreeBSD OSS implementation at this moment (2015.03) does not set PCM_CAP_OUTPUT flag. */
tmp = 0;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_GETCAPS, &mask) == -1)
{
OSS_LOG_ERR("SNDCTL_DSP_GETCAPS failed, try ignory", errno);
}
else if ((mask & PCM_CAP_OUTPUT) == 0)
{
OSS_LOG_ERR("Device does not supports playback", EOPNOTSUPP);
close(oss->pcm_handle);
oss->pcm_handle = -1;
return FALSE;
}
#endif
tmp = 0;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_GETFMTS, &tmp) == -1)
{
OSS_LOG_ERR("SNDCTL_DSP_GETFMTS failed", errno);
close(oss->pcm_handle);
oss->pcm_handle = -1;
return FALSE;
}
if ((AFMT_S16_LE & tmp) == 0)
{
OSS_LOG_ERR("SNDCTL_DSP_GETFMTS - AFMT_S16_LE", EOPNOTSUPP);
close(oss->pcm_handle);
oss->pcm_handle = -1;
return FALSE;
}
WLog_INFO(TAG, "open: %s", oss->dev_name);
return TRUE;
}
static BOOL tsmf_oss_set_format(ITSMFAudioDevice* audio, UINT32 sample_rate, UINT32 channels, UINT32 bits_per_sample)
{
int tmp;
TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio;
if (oss == NULL || oss->pcm_handle == -1)
return FALSE;
oss->sample_rate = sample_rate;
oss->channels = channels;
oss->bits_per_sample = bits_per_sample;
tmp = AFMT_S16_LE;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_SETFMT, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SETFMT failed", errno);
tmp = channels;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_CHANNELS, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_CHANNELS failed", errno);
tmp = sample_rate;
if (ioctl(oss->pcm_handle, SNDCTL_DSP_SPEED, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SPEED failed", errno);
tmp = ((bits_per_sample / 8) * channels * sample_rate);
if (ioctl(oss->pcm_handle, SNDCTL_DSP_SETFRAGMENT, &tmp) == -1)
OSS_LOG_ERR("SNDCTL_DSP_SETFRAGMENT failed", errno);
DEBUG_TSMF("sample_rate %d channels %d bits_per_sample %d",
sample_rate, channels, bits_per_sample);
return TRUE;
}
static BOOL tsmf_oss_play(ITSMFAudioDevice* audio, BYTE* data, UINT32 data_size)
{
int status;
UINT32 offset;
TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio;
DEBUG_TSMF("tsmf_oss_play: data_size %d", data_size);
if (oss == NULL || oss->pcm_handle == -1)
return FALSE;
if (data == NULL || data_size == 0)
{
free(data);
return TRUE;
}
offset = 0;
oss->data_size_last = data_size;
while (offset < data_size)
{
status = write(oss->pcm_handle, &data[offset], (data_size - offset));
if (status < 0)
{
OSS_LOG_ERR("write fail", errno);
free(data);
return FALSE;
}
offset += status;
}
free(data);
return TRUE;
}
static UINT64 tsmf_oss_get_latency(ITSMFAudioDevice* audio)
{
UINT64 latency = 0;
TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio;
if (oss == NULL)
return 0;
//latency = ((oss->data_size_last / (oss->bits_per_sample / 8)) * oss->sample_rate);
//WLog_INFO(TAG, "latency: %zu", latency);
return latency;
}
static void tsmf_oss_flush(ITSMFAudioDevice* audio)
{
}
static void tsmf_oss_free(ITSMFAudioDevice* audio)
{
TSMFOssAudioDevice* oss = (TSMFOssAudioDevice*)audio;
if (oss == NULL)
return;
if (oss->pcm_handle != -1)
{
WLog_INFO(TAG, "close: %s", oss->dev_name);
close(oss->pcm_handle);
}
free(oss);
}
#ifdef STATIC_CHANNELS
#define freerdp_tsmf_client_audio_subsystem_entry oss_freerdp_tsmf_client_audio_subsystem_entry
#endif
ITSMFAudioDevice* freerdp_tsmf_client_audio_subsystem_entry(void)
{
TSMFOssAudioDevice* oss;
oss = (TSMFOssAudioDevice*)malloc(sizeof(TSMFOssAudioDevice));
ZeroMemory(oss, sizeof(TSMFOssAudioDevice));
oss->iface.Open = tsmf_oss_open;
oss->iface.SetFormat = tsmf_oss_set_format;
oss->iface.Play = tsmf_oss_play;
oss->iface.GetLatency = tsmf_oss_get_latency;
oss->iface.Flush = tsmf_oss_flush;
oss->iface.Free = tsmf_oss_free;
oss->pcm_handle = -1;
return (ITSMFAudioDevice*)oss;
}

28
channels/tsmf/client/tsmf_audio.c
View File

@ -49,6 +49,11 @@ static ITSMFAudioDevice* tsmf_load_audio_device_by_name(const char* name, const
{
audio->Free(audio);
audio = NULL;
WLog_ERR(TAG, "failed to open, name: %s, device: %s", name, device);
}
else
{
WLog_DBG(TAG, "name: %s, device: %s", name, device);
}
return audio;
@ -56,7 +61,7 @@ static ITSMFAudioDevice* tsmf_load_audio_device_by_name(const char* name, const
ITSMFAudioDevice* tsmf_load_audio_device(const char* name, const char* device)
{
ITSMFAudioDevice* audio;
ITSMFAudioDevice* audio = NULL;
if (name)
{
@ -64,10 +69,29 @@ ITSMFAudioDevice* tsmf_load_audio_device(const char* name, const char* device)
}
else
{
audio = tsmf_load_audio_device_by_name("pulse", device);
#if defined(WITH_PULSE)
if (!audio)
audio = tsmf_load_audio_device_by_name("pulse", device);
#endif
#if defined(WITH_OSS)
if (!audio)
audio = tsmf_load_audio_device_by_name("oss", device);
#endif
#if defined(WITH_ALSA)
if (!audio)
audio = tsmf_load_audio_device_by_name("alsa", device);
#endif
}
if (audio == NULL)
{
WLog_ERR(TAG, "no sound device.");
}
else
{
WLog_DBG(TAG, "name: %s, device: %s", name, device);
}
return audio;

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

@ -362,8 +362,8 @@ static int tsmf_plugin_terminated(IWTSPlugin* pPlugin)
COMMAND_LINE_ARGUMENT_A tsmf_args[] =
{
{ "audio", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>", NULL, NULL, -1, NULL, "audio subsystem" },
{ "audio-dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", NULL, NULL, -1, NULL, "audio device name" },
{ "sys", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>", NULL, NULL, -1, NULL, "audio subsystem" },
{ "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", NULL, NULL, -1, NULL, "audio device name" },
{ "decoder", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>", NULL, NULL, -1, NULL, "decoder subsystem" },
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
};
@ -386,11 +386,11 @@ static void tsmf_process_addin_args(IWTSPlugin *pPlugin, ADDIN_ARGV *args)
if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
continue;
CommandLineSwitchStart(arg)
CommandLineSwitchCase(arg, "audio")
CommandLineSwitchCase(arg, "sys")
{
tsmf->audio_name = _strdup(arg->Value);
}
CommandLineSwitchCase(arg, "audio-dev")
CommandLineSwitchCase(arg, "dev")
{
tsmf->audio_device = _strdup(arg->Value);
}

6
channels/tsmf/client/tsmf_media.c
View File

@ -424,13 +424,13 @@ static void tsmf_sample_playback_audio(TSMF_SAMPLE* sample)
DEBUG_TSMF("MessageId %d EndTime %d consumed.",
sample->sample_id, (int)sample->end_time);
if (sample->stream->audio && sample->data)
if (stream->audio && sample->data)
{
sample->stream->audio->Play(sample->stream->audio, sample->data, sample->decoded_size);
stream->audio->Play(stream->audio, sample->data, sample->decoded_size);
sample->data = NULL;
sample->decoded_size = 0;
if (stream->audio && stream->audio->GetLatency)
if (stream->audio->GetLatency)
latency = stream->audio->GetLatency(stream->audio);
}
else

19
channels/urbdrc/CMakeLists.txt
View File

@ -18,15 +18,28 @@
define_channel("urbdrc")
if(NOT WIN32)
find_package(DevD)
find_package(UDev)
find_package(UUID)
find_package(DbusGlib)
find_package(libusb-1.0)
endif()
if(UDEV_FOUND AND UUID_FOUND AND DBUS_GLIB_FOUND AND LIBUSB_1_FOUND)
set(URBDRC_DEPENDENCIES_FOUND TRUE)
message(STATUS "Found all URBDRC dependencies")
if(DEVD_FOUND OR UDEV_FOUND)
if(UUID_FOUND AND DBUS_GLIB_FOUND AND LIBUSB_1_FOUND)
set(URBDRC_DEPENDENCIES_FOUND TRUE)
message(STATUS "Found all URBDRC dependencies")
else()
if(NOT UUID_FOUND)
message(STATUS "URBDRC dependencie not found: UUID")
endif()
if(NOT DBUS_GLIB_FOUND)
message(STATUS "URBDRC dependencie not found: DBUS_GLIB")
endif()
if(NOT LIBUSB_1_FOUND)
message(STATUS "URBDRC dependencie not found: LIBUSB_1")
endif()
endif()
endif()
if(WITH_CLIENT_CHANNELS)

4
channels/urbdrc/client/CMakeLists.txt
View File

@ -39,8 +39,10 @@ add_channel_client_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} TRUE
set(${MODULE_PREFIX}_LIBS
${DBUS_GLIB_LIBRARIES}
${UDEV_LIBRARIES}
${UUID_LIBRARIES})
if (UDEV_FOUND AND UDEV_LIBRARIES)
set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} ${UDEV_LIBRARIES})
endif()
set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} winpr freerdp)

2
channels/urbdrc/client/data_transfer.c
View File

@ -1281,7 +1281,7 @@ static int urb_os_feature_descriptor_request(URBDRC_CHANNEL_CALLBACK * callback,
data_read_UINT32(data + 0, RequestId);
data_read_BYTE(data + 4, Recipient); /** Recipient */
Recipient = Recipient && 0x1f;
Recipient = (Recipient & 0x1f); /* XXX: origin: Recipient && 0x1f !? */
data_read_BYTE(data + 5, InterfaceNumber); /** InterfaceNumber */
data_read_BYTE(data + 6, Ms_PageIndex); /** Ms_PageIndex */
data_read_UINT16(data + 7, Ms_featureDescIndex); /** Ms_featureDescIndex */

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

@ -22,7 +22,9 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if defined(__linux__)
#include <libudev.h>
#endif
#include "libusb_udevice.h"
@ -455,8 +457,7 @@ static void print_status(enum libusb_transfer_status status)
static LIBUSB_DEVICE* udev_get_libusb_dev(int bus_number, int dev_number)
{
int i;
ssize_t total_device;
ssize_t i, total_device;
LIBUSB_DEVICE** libusb_list;
total_device = libusb_get_device_list(NULL, &libusb_list);
@ -492,7 +493,69 @@ static LIBUSB_DEVICE_DESCRIPTOR* udev_new_descript(LIBUSB_DEVICE* libusb_dev)
return descriptor;
}
/* Get HUB handle */
/* Get HUB handle */
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
static int udev_get_hub_handle(UDEVICE* pdev, UINT16 bus_number, UINT16 dev_number) {
int error;
ssize_t i, total_device, ports_cnt;
uint8_t port_numbers[16];
LIBUSB_DEVICE **libusb_list;
total_device = libusb_get_device_list(NULL, &libusb_list);
/* Look for device. */
error = -1;
for (i = 0; i < total_device; i ++)
{
if ((bus_number != libusb_get_bus_number(libusb_list[i])) ||
(dev_number != libusb_get_device_address(libusb_list[i])))
continue;
error = libusb_open(libusb_list[i], &pdev->hub_handle);
if (error < 0)
{
WLog_ERR(TAG,"libusb_open error: %i - %s", error, libusb_strerror(error));
break;
}
/* get port number */
error = libusb_get_port_numbers(libusb_list[i], port_numbers, sizeof(port_numbers));
libusb_close(pdev->hub_handle);
if (error < 1)
{ /* Prevent open hub, treat as error. */
WLog_ERR(TAG,"libusb_get_port_numbers error: %i - %s", error, libusb_strerror(error));
break;
}
pdev->port_number = port_numbers[(error - 1)];
error = 0;
WLog_DBG(TAG, " Port: %d", pdev->port_number);
/* gen device path */
sprintf(pdev->path, "ugen%d.%d", bus_number, dev_number);
WLog_DBG(TAG, " DevPath: %s", pdev->path);
break;
}
/* Look for device hub. */
if (error == 0)
{
error = -1;
for (i = 0; i < total_device; i ++)
{
if ((bus_number != libusb_get_bus_number(libusb_list[i])) ||
(1 != libusb_get_device_address(libusb_list[i]))) /* Root hub allways first on bus. */
continue;
WLog_DBG(TAG, " Open hub: %d", bus_number);
error = libusb_open(libusb_list[i], &pdev->hub_handle);
if (error < 0)
WLog_ERR(TAG,"libusb_open error: %i - %s", error, libusb_strerror(error));
break;
}
}
libusb_free_device_list(libusb_list, 1);
if (error < 0)
return -1;
WLog_DBG(TAG, "libusb_open success!");
return 0;
}
#endif
#if defined(__linux__)
static int udev_get_hub_handle(UDEVICE* pdev, UINT16 bus_number, UINT16 dev_number)
{
struct udev* udev;
@ -627,6 +690,7 @@ static int udev_get_hub_handle(UDEVICE* pdev, UINT16 bus_number, UINT16 dev_numb
/* Success! */
return 0;
}
#endif
static int libusb_udev_select_interface(IUDEVICE* idev, BYTE InterfaceNumber, BYTE AlternateSetting)
{
@ -1211,6 +1275,7 @@ static int libusb_udev_query_device_port_status(IUDEVICE* idev, UINT32* UsbdStat
UDEVICE* pdev = (UDEVICE*) idev;
int success = 0, ret;
WLog_DBG(TAG,"...");
if (pdev->hub_handle != NULL)
{
ret = idev->control_transfer(idev, 0xffff, 0, 0,
@ -1815,10 +1880,10 @@ int udev_new_by_id(UINT16 idVendor, UINT16 idProduct, IUDEVICE*** devArray)
UDEVICE** array;
UINT16 bus_number;
UINT16 dev_number;
ssize_t total_device;
int i, status, num = 0;
ssize_t i, total_device;
int status, num = 0;
WLog_ERR(TAG, "VID: 0x%04X PID: 0x%04X", idVendor, idProduct);
WLog_INFO(TAG, "VID: 0x%04X, PID: 0x%04X", idVendor, idProduct);
array = (UDEVICE**) malloc(16 * sizeof(UDEVICE*));
@ -1839,7 +1904,7 @@ int udev_new_by_id(UINT16 idVendor, UINT16 idProduct, IUDEVICE*** devArray)
if (status < 0)
{
WLog_ERR(TAG, "libusb_open: (by id) error: 0x%08X (%d)", status, status);
WLog_ERR(TAG, "libusb_open: (by id) error: 0x%08X (%d)", status, status);
zfree(descriptor);
zfree(array[num]);
continue;

4
channels/urbdrc/client/libusb/libusb_udevice.h
View File

@ -23,7 +23,11 @@
#ifndef __LIBUSB_UDEVICE_H
#define __LIBUSB_UDEVICE_H
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
#include <libusb.h>
#else
#include <libusb-1.0/libusb.h>
#endif
#include "urbdrc_types.h"
#include "request_queue.h"

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

@ -610,5 +610,7 @@ int freerdp_urbdrc_client_subsystem_entry(PFREERDP_URBDRC_SERVICE_ENTRY_POINTS p
pEntryPoints->pRegisterUDEVMAN(pEntryPoints->plugin, (IUDEVMAN*) udevman);
WLog_DBG(TAG, "UDEVMAN device registered.");
return 0;
}

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

@ -24,7 +24,16 @@
#include <string.h>
#include <unistd.h>
#include <time.h>
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <err.h>
#endif
#if defined(__linux__)
#include <libudev.h>
#endif
#include <winpr/crt.h>
#include <winpr/synch.h>
@ -435,6 +444,266 @@ static int urbdrc_exchange_capabilities(URBDRC_CHANNEL_CALLBACK* callback, char*
return error;
}
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
static char *devd_get_val(char *buf, size_t buf_size, const char *val_name, size_t val_name_size, size_t *val_size) {
char *ret, *buf_end, *ptr;
buf_end = (buf + buf_size);
for (ret = buf; ret != NULL && ret < buf_end;)
{
ret = memmem(ret, (buf_end - ret), val_name, val_name_size);
if (ret == NULL)
return NULL;
/* Found. */
/* Check: space before or buf+1. */
if ((buf + 1) < ret && ret[-1] != ' ')
{
ret += val_name_size;
continue;
}
/* Check: = after name and size for value. */
ret += val_name_size;
if ((ret + 1) >= buf_end)
return NULL;
if (ret[0] != '=')
continue;
ret ++;
break;
}
if (ret == NULL || val_size == NULL)
return ret;
/* Calc value data size. */
ptr = memchr(ret, ' ', (buf_end - ret));
if (ptr == NULL) /* End of string/last value. */
ptr = buf_end;
(*val_size) = (ptr - ret);
return ret;
}
static void *urbdrc_search_usb_device(void *arg) {
USB_SEARCHMAN *searchman = (USB_SEARCHMAN*)arg;
URBDRC_PLUGIN *urbdrc = (URBDRC_PLUGIN*)searchman->urbdrc;
IUDEVMAN *udevman = urbdrc->udevman;
IWTSVirtualChannelManager *channel_mgr = urbdrc->listener_callback->channel_mgr;
IWTSVirtualChannel *dvc_channel;
USB_SEARCHDEV *sdev;
IUDEVICE *pdev;
HANDLE listobj[2];
HANDLE mon_fd;
int devd_skt;
char buf[4096], *val, *ptr, *end_val;
ssize_t data_size;
size_t val_size, tm;
int idVendor, idProduct;
int busnum, devnum;
int action, success, error, found, on_close;
struct sockaddr_un sun;
WLog_DBG(TAG, "urbdrc_search_usb_device - devd: start");
devd_skt = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
if (devd_skt == -1)
{
WLog_ERR(TAG, "Can't create devd socket: error = %i", errno);
goto err_out;
}
memset(&sun, 0, sizeof(sun));
sun.sun_family = PF_LOCAL;
sun.sun_len = sizeof(sun);
strlcpy(sun.sun_path, "/var/run/devd.seqpacket.pipe", sizeof(sun.sun_path));
if (-1 == connect(devd_skt, (struct sockaddr*)&sun, sizeof(sun)))
{
WLog_ERR(TAG, "Can't connect devd socket: error = %i - %s", errno, strerror(errno));
goto err_out;
}
/* Get the file descriptor (fd) for the monitor.
This fd will get passed to select() */
mon_fd = CreateFileDescriptorEvent(NULL, TRUE, FALSE, devd_skt);
listobj[0] = searchman->term_event;
listobj[1] = mon_fd;
while (WaitForMultipleObjects(2, listobj, FALSE, INFINITE) != WAIT_OBJECT_0)
{
WLog_DBG(TAG, "======= SEARCH ======= ");
/* !system=USB subsystem=DEVICE type=ATTACH ugen=ugen3.3 cdev=ugen3.3 vendor=0x046d product=0x082d devclass=0xef devsubclass=0x02 sernum="6E7D726F" release=0x0011 mode=host port=4 parent=ugen3.1 */
/* !system=USB subsystem=DEVICE type=DETACH ugen=ugen3.3 cdev=ugen3.3 vendor=0x046d product=0x082d devclass=0xef devsubclass=0x02 sernum="6E7D726F" release=0x0011 mode=host port=4 parent=ugen3.1 */
data_size = read(devd_skt, buf, (sizeof(buf) - 1));
if (data_size == -1)
{
WLog_ERR(TAG, "devd socket read: error = %i", errno);
break;
}
buf[data_size] = 0;
WLog_DBG(TAG, "devd event: %s", buf);
if (buf[0] != '!') /* Skeep non notify events. */
continue;
/* Check: system=USB */
val = devd_get_val(buf, data_size, "system", 6, &val_size);
if (val == NULL || val_size != 3 || memcmp(val, "USB", 3) != 0)
continue;
/* Check: subsystem=DEVICE */
val = devd_get_val(buf, data_size, "subsystem", 9, &val_size);
if (val == NULL || val_size != 6 || memcmp(val, "DEVICE", 6) != 0)
continue;
/* Get event type. */
val = devd_get_val(buf, data_size, "type", 4, &val_size);
if (val == NULL || val_size != 6)
continue;
action = -1;
if (memcmp(val, "ATTACH", 6) == 0)
action = 0;
if (memcmp(val, "DETACH", 6) == 0)
action = 1;
if (action == -1)
continue; /* Skeep other actions. */
/* Get bus and dev num. */
/* ugen=ugen3.3 */
val = devd_get_val(buf, data_size, "ugen", 4, &val_size);
if (val == NULL || val_size < 7 || memcmp(val, "ugen", 4) != 0)
continue;
val += 4;
val_size -= 4;
ptr = memchr(val, '.', val_size);
if (ptr == NULL)
continue;
/* Prepare strings. */
ptr[0] = 0;
ptr ++;
val[val_size] = 0;
/* Extract numbers. */
busnum = atoi(val);
devnum = atoi(ptr);
/* Restore spaces. */
ptr[-1] = ' ';
val[val_size] = ' ';
/* Handle event. */
dvc_channel = NULL;
switch (action)
{
case 0: /* ATTACH */
sdev = NULL;
success = 0;
found = 0;
/* vendor=0x046d */
val = devd_get_val(buf, data_size, "vendor", 6, &val_size);
if (val == NULL || val_size < 1)
continue;
val[val_size] = 0;
idVendor = strtol(val, NULL, 16);
val[val_size] = ' ';
/* product=0x082d */
val = devd_get_val(buf, data_size, "product", 7, &val_size);
if (val == NULL || val_size < 1)
continue;
val[val_size] = 0;
idProduct = strtol(val, NULL, 16);
val[val_size] = ' ';
WLog_DBG(TAG, "ATTACH: bus: %i, dev: %i, ven: %i, prod: %i", busnum, devnum, idVendor, idProduct);
dvc_channel = channel_mgr->FindChannelById(channel_mgr, urbdrc->first_channel_id);
searchman->rewind(searchman);
while (dvc_channel && searchman->has_next(searchman))
{
sdev = searchman->get_next(searchman);
if (sdev->idVendor == idVendor &&
sdev->idProduct == idProduct)
{
WLog_VRB(TAG, "Searchman Found Device: %04x:%04x",
sdev->idVendor, sdev->idProduct);
found = 1;
break;
}
}
if (!found && udevman->isAutoAdd(udevman))
{
WLog_VRB(TAG, "Auto Find Device: %04x:%04x ",
idVendor, idProduct);
found = 2;
}
if (found)
{
success = udevman->register_udevice(udevman, busnum, devnum,
searchman->UsbDevice, 0, 0, UDEVMAN_FLAG_ADD_BY_ADDR);
}
if (success)
{
searchman->UsbDevice ++;
usleep(400000);
error = urdbrc_send_virtual_channel_add(dvc_channel, 0);
if (found == 1)
searchman->remove(searchman, sdev->idVendor, sdev->idProduct);
}
break;
case 1: /* DETACH */
pdev = NULL;
on_close = 0;
WLog_DBG(TAG, "DETACH: bus: %i, dev: %i", busnum, devnum);
usleep(500000);
udevman->loading_lock(udevman);
udevman->rewind(udevman);
while (udevman->has_next(udevman))
{
pdev = udevman->get_next(udevman);
if (pdev->get_bus_number(pdev) == busnum &&
pdev->get_dev_number(pdev) == devnum)
{
dvc_channel = channel_mgr->FindChannelById(channel_mgr, pdev->get_channel_id(pdev));
if (dvc_channel == NULL)
{
WLog_ERR(TAG, "SEARCH: dvc_channel %d is NULL!!", pdev->get_channel_id(pdev));
func_close_udevice(searchman, pdev);
break;
}
if (!pdev->isSigToEnd(pdev))
{
dvc_channel->Write(dvc_channel, 0, NULL, NULL);
pdev->SigToEnd(pdev);
}
on_close = 1;
break;
}
}
udevman->loading_unlock(udevman);
usleep(300000);
if (pdev && on_close && dvc_channel &&
pdev->isSigToEnd(pdev) &&
!(pdev->isChannelClosed(pdev)))
{
dvc_channel->Close(dvc_channel);
}
break;
}
}
CloseHandle(mon_fd);
err_out:
close(devd_skt);
sem_post(&searchman->sem_term);
WLog_DBG(TAG, "urbdrc_search_usb_device - devd: end");
return 0;
}
#endif
#if defined (__linux__)
static void* urbdrc_search_usb_device(void* arg)
{
USB_SEARCHMAN* searchman = (USB_SEARCHMAN*) arg;
@ -658,6 +927,7 @@ fail_create_monfd_event:
return 0;
}
#endif
void* urbdrc_new_device_create(void* arg)
{
@ -674,8 +944,10 @@ void* urbdrc_new_device_create(void* arg)
UINT32 FunctionId;
int i = 0, found = 0;
WLog_DBG(TAG, "...");
channel_mgr = urbdrc->listener_callback->channel_mgr;
ChannelId = channel_mgr->GetChannelId(callback->channel);
ChannelId = channel_mgr->GetChannelId(callback->channel);
data_read_UINT32(pBuffer + 0, MessageId);
data_read_UINT32(pBuffer + 4, FunctionId);
@ -743,6 +1015,8 @@ static int urbdrc_process_channel_notification(URBDRC_CHANNEL_CALLBACK* callback
UINT32 FunctionId;
URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) callback->plugin;
WLog_DBG(TAG, "...");
data_read_UINT32(pBuffer + 0, MessageId);
data_read_UINT32(pBuffer + 4, FunctionId);
@ -793,7 +1067,7 @@ static int urbdrc_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
UINT32 Mask;
int error = 0;
char* pBuffer = (char*)Stream_Pointer(data);
UINT32 cbSize = Stream_GetRemainingLength(data);
UINT32 cbSize = Stream_GetRemainingLength(data);
if (callback == NULL)
return 0;

4
channels/urbdrc/client/urbdrc_types.h
View File

@ -30,7 +30,11 @@
#include <freerdp/channels/log.h>
#include <freerdp/utils/msusb.h>
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
#include <uuid.h>
#else
#include <uuid/uuid.h>
#endif
#include <pthread.h>
#include <semaphore.h>

1
client/.gitignore vendored
View File

@ -7,4 +7,5 @@
!/Sample
!/Windows
!/X11
!/Wayland
!/CMakeLists.txt

61
client/Android/FreeRDPCore/jni/android_event.c
View File

@ -69,20 +69,20 @@ void android_clear_event(ANDROID_EVENT_QUEUE * queue)
}
}
void android_push_event(freerdp * inst, ANDROID_EVENT* event)
BOOL android_push_event(freerdp * inst, ANDROID_EVENT* event)
{
androidContext* aCtx = (androidContext*)inst->context;
if (aCtx->event_queue->count >= aCtx->event_queue->size)
{
int new_size;
int new_events;
void* new_events;
new_size = aCtx->event_queue->size * 2;
new_events = realloc((void*) aCtx->event_queue->events,
sizeof(ANDROID_EVENT*) * new_size);
if (!new_events)
return;
return FALSE;
aCtx->event_queue->events = new_events;
aCtx->event_queue->size = new_size;
}
@ -90,6 +90,7 @@ void android_push_event(freerdp * inst, ANDROID_EVENT* event)
aCtx->event_queue->events[(aCtx->event_queue->count)++] = event;
android_set_event(aCtx->event_queue);
return TRUE;
}
ANDROID_EVENT* android_peek_event(ANDROID_EVENT_QUEUE * queue)
@ -226,8 +227,9 @@ ANDROID_EVENT_KEY* android_event_key_new(int flags, UINT16 scancode)
{
ANDROID_EVENT_KEY* event;
event = (ANDROID_EVENT_KEY*) malloc(sizeof(ANDROID_EVENT_KEY));
memset(event, 0, sizeof(ANDROID_EVENT_KEY));
event = (ANDROID_EVENT_KEY*) calloc(1, sizeof(ANDROID_EVENT_KEY));
if (!event)
return NULL;
event->type = EVENT_TYPE_KEY;
event->flags = flags;
@ -245,8 +247,9 @@ ANDROID_EVENT_KEY* android_event_unicodekey_new(UINT16 key)
{
ANDROID_EVENT_KEY* event;
event = (ANDROID_EVENT_KEY*) malloc(sizeof(ANDROID_EVENT_KEY));
memset(event, 0, sizeof(ANDROID_EVENT_KEY));
event = (ANDROID_EVENT_KEY*) calloc(1, sizeof(ANDROID_EVENT_KEY));
if (!event)
return NULL;
event->type = EVENT_TYPE_KEY_UNICODE;
event->scancode = key;
@ -263,8 +266,9 @@ ANDROID_EVENT_CURSOR* android_event_cursor_new(UINT16 flags, UINT16 x, UINT16 y)
{
ANDROID_EVENT_CURSOR* event;
event = (ANDROID_EVENT_CURSOR*) malloc(sizeof(ANDROID_EVENT_CURSOR));
memset(event, 0, sizeof(ANDROID_EVENT_CURSOR));
event = (ANDROID_EVENT_CURSOR*) calloc(1, sizeof(ANDROID_EVENT_CURSOR));
if (!event)
return NULL;
event->type = EVENT_TYPE_CURSOR;
event->x = x;
@ -283,8 +287,9 @@ ANDROID_EVENT* android_event_disconnect_new()
{
ANDROID_EVENT* event;
event = (ANDROID_EVENT*) malloc(sizeof(ANDROID_EVENT));
memset(event, 0, sizeof(ANDROID_EVENT));
event = (ANDROID_EVENT*) calloc(1, sizeof(ANDROID_EVENT));
if (!event)
return NULL;
event->type = EVENT_TYPE_DISCONNECT;
return event;
@ -299,13 +304,19 @@ ANDROID_EVENT_CLIPBOARD* android_event_clipboard_new(void* data, int data_length
{
ANDROID_EVENT_CLIPBOARD* event;
event = (ANDROID_EVENT_CLIPBOARD*) malloc(sizeof(ANDROID_EVENT_CLIPBOARD));
memset(event, 0, sizeof(ANDROID_EVENT_CLIPBOARD));
event = (ANDROID_EVENT_CLIPBOARD*) calloc(1, sizeof(ANDROID_EVENT_CLIPBOARD));
if (!event)
return NULL;
event->type = EVENT_TYPE_CLIPBOARD;
if (data)
{
event->data = malloc(data_length);
if (!event->data)
{
free(event);
return NULL;
}
memcpy(event->data, data, data_length);
event->data_length = data_length;
}
@ -322,12 +333,16 @@ void android_event_clipboard_free(ANDROID_EVENT_CLIPBOARD* event)
}
}
void android_event_queue_init(freerdp * inst)
BOOL android_event_queue_init(freerdp * inst)
{
androidContext* aCtx = (androidContext*)inst->context;
aCtx->event_queue = (ANDROID_EVENT_QUEUE*) malloc(sizeof(ANDROID_EVENT_QUEUE));
memset(aCtx->event_queue, 0, sizeof(ANDROID_EVENT_QUEUE));
aCtx->event_queue = (ANDROID_EVENT_QUEUE*) calloc(1, sizeof(ANDROID_EVENT_QUEUE));
if (!aCtx->event_queue)
{
WLog_ERR(TAG, "android_event_queue_init: memory allocation failed");
return FALSE;
}
aCtx->event_queue->pipe_fd[0] = -1;
aCtx->event_queue->pipe_fd[1] = -1;
@ -335,9 +350,21 @@ void android_event_queue_init(freerdp * inst)
aCtx->event_queue->size = 16;
aCtx->event_queue->count = 0;
aCtx->event_queue->events = (ANDROID_EVENT**) malloc(sizeof(ANDROID_EVENT*) * aCtx->event_queue->size);
if (!aCtx->event_queue->events)
{
WLog_ERR(TAG, "android_event_queue_init: memory allocation failed");
free(aCtx->event_queue);
return FALSE;
}
if (pipe(aCtx->event_queue->pipe_fd) < 0)
WLog_ERR(TAG, "android_pre_connect: pipe failed");
{
WLog_ERR(TAG, "android_event_queue_init: pipe creation failed");
free(aCtx->event_queue->events);
free(aCtx->event_queue);
return FALSE;
}
return TRUE;
}
void android_event_queue_uninit(freerdp * inst)

4
client/Android/FreeRDPCore/jni/android_event.h
View File

@ -62,7 +62,7 @@ typedef struct _ANDROID_EVENT_QUEUE ANDROID_EVENT_QUEUE;
int android_is_event_set(ANDROID_EVENT_QUEUE * queue);
void android_set_event(ANDROID_EVENT_QUEUE * queue);
void android_clear_event(ANDROID_EVENT_QUEUE * queue);
void android_push_event(freerdp * inst, ANDROID_EVENT* event);
BOOL android_push_event(freerdp * inst, ANDROID_EVENT* event);
ANDROID_EVENT* android_peek_event(ANDROID_EVENT_QUEUE * queue);
ANDROID_EVENT* android_pop_event(ANDROID_EVENT_QUEUE * queue);
int android_process_event(ANDROID_EVENT_QUEUE * queue, freerdp * inst);
@ -79,7 +79,7 @@ void android_event_unicodekey_free(ANDROID_EVENT_KEY* event);
void android_event_cursor_free(ANDROID_EVENT_CURSOR* event);
void android_event_disconnect_free(ANDROID_EVENT* event);
void android_event_clipboard_free(ANDROID_EVENT_CLIPBOARD* event);
void android_event_queue_init(freerdp * inst);
BOOL android_event_queue_init(freerdp * inst);
void android_event_queue_uninit(freerdp * inst);
#endif /* FREERDP_ANDROID_EVENT_H */

329
client/Android/FreeRDPCore/jni/android_freerdp.c
View File

@ -4,6 +4,7 @@
Copyright 2010-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz
Copyright 2013 Thincast Technologies GmbH, Author: Armin Novak
Copyright 2015 Bernhard Miklautz <bernhard.miklautz@thincast.com>
This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
@ -35,6 +36,7 @@
#include <freerdp/locale/keyboard.h>
#include <freerdp/primitives.h>
#include <freerdp/version.h>
#include <freerdp/settings.h>
#include <android/bitmap.h>
@ -48,15 +50,21 @@
#include "jni/prof.h"
#endif
BOOL android_context_new(freerdp* instance, rdpContext* context)
static BOOL android_context_new(freerdp* instance, rdpContext* context)
{
if (!(context->channels = freerdp_channels_new()))
return FALSE;
android_event_queue_init(instance);
if (!android_event_queue_init(instance))
{
freerdp_channels_free(context->channels);
return FALSE;
}
return TRUE;
}
void android_context_free(freerdp* instance, rdpContext* context)
static void android_context_free(freerdp* instance, rdpContext* context)
{
if (context && context->channels)
{
@ -67,14 +75,14 @@ void android_context_free(freerdp* instance, rdpContext* context)
android_event_queue_uninit(instance);
}
void android_OnChannelConnectedEventHandler(rdpContext* context, ChannelConnectedEventArgs* e)
static void android_OnChannelConnectedEventHandler(rdpContext* context, ChannelConnectedEventArgs* e)
{
rdpSettings* settings = context->settings;
androidContext* afc = (androidContext*) context;
if (strcmp(e->name, RDPEI_DVC_CHANNEL_NAME) == 0)
{
DEBUG_ANDROID("Unhandled case.. RDPEI_DVC_CHANNEL_NAME");
}
else if (strcmp(e->name, RDPGFX_DVC_CHANNEL_NAME) == 0)
{
@ -87,14 +95,14 @@ void android_OnChannelConnectedEventHandler(rdpContext* context, ChannelConnecte
}
}
void android_OnChannelDisconnectedEventHandler(rdpContext* context, ChannelDisconnectedEventArgs* e)
static void android_OnChannelDisconnectedEventHandler(rdpContext* context, ChannelDisconnectedEventArgs* e)
{
rdpSettings* settings = context->settings;
androidContext* afc = (androidContext*) context;
if (strcmp(e->name, RDPEI_DVC_CHANNEL_NAME) == 0)
{
DEBUG_ANDROID("Unhandled case.. RDPEI_DVC_CHANNEL_NAME");
}
else if (strcmp(e->name, RDPGFX_DVC_CHANNEL_NAME) == 0)
{
@ -107,7 +115,7 @@ void android_OnChannelDisconnectedEventHandler(rdpContext* context, ChannelDisco
}
}
BOOL android_begin_paint(rdpContext* context)
static BOOL android_begin_paint(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
@ -115,7 +123,7 @@ BOOL android_begin_paint(rdpContext* context)
return TRUE;
}
BOOL android_end_paint(rdpContext* context)
static BOOL android_end_paint(rdpContext* context)
{
int i;
int ninvalid;
@ -158,7 +166,7 @@ BOOL android_end_paint(rdpContext* context)
return TRUE;
}
BOOL android_desktop_resize(rdpContext* context)
static BOOL android_desktop_resize(rdpContext* context)
{
DEBUG_ANDROID("ui_desktop_resize");
@ -172,7 +180,7 @@ BOOL android_desktop_resize(rdpContext* context)
return TRUE;
}
BOOL android_pre_connect(freerdp* instance)
static BOOL android_pre_connect(freerdp* instance)
{
DEBUG_ANDROID("android_pre_connect");
@ -233,7 +241,8 @@ static BOOL android_post_connect(freerdp* instance)
settings->DesktopWidth, settings->DesktopHeight,
settings->ColorDepth);
instance->context->cache = cache_new(settings);
if (!(instance->context->cache = cache_new(settings)))
return FALSE;
if (instance->settings->ColorDepth > 16)
gdi_flags = CLRBUF_32BPP | CLRCONV_ALPHA | CLRCONV_INVERT;
@ -247,7 +256,8 @@ static BOOL android_post_connect(freerdp* instance)
instance->update->EndPaint = android_end_paint;
instance->update->DesktopResize = android_desktop_resize;
freerdp_channels_post_connect(instance->context->channels, instance);
if (freerdp_channels_post_connect(instance->context->channels, instance) < 0)
return FALSE;
freerdp_callback("OnConnectionSuccess", "(I)V", instance);
@ -256,11 +266,12 @@ static BOOL android_post_connect(freerdp* instance)
static void android_post_disconnect(freerdp* instance)
{
DEBUG_ANDROID("android_post_disconnect");
gdi_free(instance);
cache_free(instance->context->cache);
}
BOOL android_authenticate(freerdp* instance, char** username, char** password, char** domain)
static BOOL android_authenticate(freerdp* instance, char** username, char** password, char** domain)
{
DEBUG_ANDROID("Authenticate user:");
DEBUG_ANDROID(" Username: %s", *username);
@ -293,7 +304,7 @@ BOOL android_authenticate(freerdp* instance, char** username, char** password, c
return ((res == JNI_TRUE) ? TRUE : FALSE);
}
BOOL android_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
static BOOL android_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)
{
DEBUG_ANDROID("Certificate details:");
DEBUG_ANDROID("\tSubject: %s", subject);
@ -317,7 +328,7 @@ BOOL android_verify_certificate(freerdp* instance, char* subject, char* issuer,
return ((res == JNI_TRUE) ? TRUE : FALSE);
}
BOOL android_verify_changed_certificate(freerdp* instance, char* subject, char* issuer, char* new_fingerprint, char* old_fingerprint)
static BOOL android_verify_changed_certificate(freerdp* instance, char* subject, char* issuer, char* new_fingerprint, char* old_fingerprint)
{
return android_verify_certificate(instance, subject, issuer, new_fingerprint);
}
@ -332,7 +343,7 @@ static void* jni_input_thread(void* arg)
assert(NULL != instance);
assert(NULL != aCtx);
DEBUG_ANDROID("Start.");
DEBUG_ANDROID("input_thread Start.");
if (!(queue = freerdp_get_message_queue(instance, FREERDP_INPUT_MESSAGE_QUEUE)))
goto fail_get_message_queue;
@ -365,7 +376,7 @@ static void* jni_input_thread(void* arg)
}
while(1);
DEBUG_ANDROID("Quit.");
DEBUG_ANDROID("input_thread Quit.");
fail_get_message_queue_event:
CloseHandle(event[1]);
@ -388,7 +399,7 @@ static void* jni_channels_thread(void* arg)
assert(NULL != instance);
DEBUG_ANDROID("Start.");
DEBUG_ANDROID("Channels_thread Start.");
channels = instance->context->channels;
event = freerdp_channels_get_event_handle(instance);
@ -401,7 +412,7 @@ static void* jni_channels_thread(void* arg)
break;
}
DEBUG_ANDROID("Quit.");
DEBUG_ANDROID("channels_thread Quit.");
ExitThread(0);
return NULL;
@ -613,11 +624,11 @@ disconnect:
CloseHandle(input_thread);
}
DEBUG_ANDROID("Disconnecting...");
DEBUG_ANDROID("run Disconnecting...");
freerdp_disconnect(instance);
freerdp_callback("OnDisconnected", "(I)V", instance);
DEBUG_ANDROID("Quit.");
DEBUG_ANDROID("run Quit.");
return 0;
}
@ -626,13 +637,13 @@ static void* android_thread_func(void* param)
{
freerdp* instance = param;
DEBUG_ANDROID("Start.");
DEBUG_ANDROID("android_thread_func Start.");
assert(instance);
android_freerdp_run(instance);
DEBUG_ANDROID("Quit.");
DEBUG_ANDROID("android_thread_func Quit.");
ExitThread(0);
return NULL;
@ -649,7 +660,7 @@ JNIEXPORT jint JNICALL jni_freerdp_new(JNIEnv *env, jclass cls)
// create instance
if (!(instance = freerdp_new()))
return NULL;
return (jint)NULL;
instance->PreConnect = android_pre_connect;
instance->PostConnect = android_post_connect;
instance->PostDisconnect = android_post_disconnect;
@ -705,12 +716,20 @@ JNIEXPORT jboolean JNICALL jni_freerdp_disconnect(JNIEnv *env, jclass cls, jint
freerdp* inst = (freerdp*)instance;
androidContext* ctx = (androidContext*)inst->context;
ANDROID_EVENT* event = (ANDROID_EVENT*)android_event_disconnect_new();
if (!event)
return JNI_FALSE;
DEBUG_ANDROID("DISCONNECT!");
assert(inst);
assert(ctx);
assert(event);
android_push_event(inst, event);
if (!android_push_event(inst, event))
{
android_event_disconnect_free(event);
return JNI_FALSE;
}
WaitForSingleObject(ctx->thread, INFINITE);
CloseHandle(ctx->thread);
@ -721,43 +740,71 @@ JNIEXPORT jboolean JNICALL jni_freerdp_disconnect(JNIEnv *env, jclass cls, jint
return (jboolean) JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_cancel_connection(JNIEnv *env, jclass cls, jint instance)
JNIEXPORT jboolean JNICALL jni_freerdp_cancel_connection(JNIEnv *env, jclass cls, jint instance)
{
jni_freerdp_disconnect(env, cls, instance);
return jni_freerdp_disconnect(env, cls, instance);
}
JNIEXPORT void JNICALL jni_freerdp_set_data_directory(JNIEnv *env, jclass cls, jint instance, jstring jdirectory)
JNIEXPORT jboolean JNICALL jni_freerdp_set_data_directory(JNIEnv *env, jclass cls, jint instance, jstring jdirectory)
{
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
const jbyte *directory = (*env)->GetStringUTFChars(env, jdirectory, NULL);
const jbyte* directory = (*env)->GetStringUTFChars(env, jdirectory, NULL);
if (!directory)
return JNI_FALSE;
free(settings->HomePath);
free(settings->ConfigPath);
settings->HomePath = settings->ConfigPath = NULL;
int config_dir_len = strlen(directory) + 10; /* +9 chars for /.freerdp and +1 for \0 */
char* config_dir_buf = (char*)malloc(config_dir_len);
if (!config_dir_buf)
goto out_malloc_fail;
strcpy(config_dir_buf, directory);
strcat(config_dir_buf, "/.freerdp");
settings->HomePath = strdup(directory);
if (!settings->HomePath)
goto out_strdup_fail;
settings->ConfigPath = config_dir_buf; /* will be freed by freerdp library */
(*env)->ReleaseStringUTFChars(env, jdirectory, directory);
return JNI_TRUE;
out_strdup_fail:
free(config_dir_buf);
out_malloc_fail:
(*env)->ReleaseStringUTFChars(env, jdirectory, directory);
return JNI_FALSE;
}
JNIEXPORT void JNICALL jni_freerdp_set_connection_info(JNIEnv *env, jclass cls, jint instance,
JNIEXPORT jboolean JNICALL jni_freerdp_set_connection_info(JNIEnv *env, jclass cls, jint instance,
jstring jhostname, jstring jusername, jstring jpassword, jstring jdomain, jint width, jint height,
jint color_depth, jint port, jboolean console, jint security, jstring jcertname)
{
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
const jbyte *hostname = (*env)->GetStringUTFChars(env, jhostname, NULL);
const jbyte *username = (*env)->GetStringUTFChars(env, jusername, NULL);
const jbyte *password = (*env)->GetStringUTFChars(env, jpassword, NULL);
const jbyte *domain = (*env)->GetStringUTFChars(env, jdomain, NULL);
const jbyte *certname = (*env)->GetStringUTFChars(env, jcertname, NULL);
const jbyte *hostname;
const jbyte *username;
const jbyte *password;
const jbyte *domain;
const jbyte *certname;
if(!(hostname = (*env)->GetStringUTFChars(env, jhostname, NULL)))
return JNI_FALSE;
if (!(username = (*env)->GetStringUTFChars(env, jusername, NULL)))
goto out_fail_username;
if (!(password = (*env)->GetStringUTFChars(env, jpassword, NULL)))
goto out_fail_password;
if (!(domain = (*env)->GetStringUTFChars(env, jdomain, NULL)))
goto out_fail_domain;
if (!(certname = (*env)->GetStringUTFChars(env, jcertname, NULL)))
goto out_fail_certname;
DEBUG_ANDROID("hostname: %s", (char*) hostname);
DEBUG_ANDROID("username: %s", (char*) username);
@ -779,21 +826,30 @@ JNIEXPORT void JNICALL jni_freerdp_set_connection_info(JNIEnv *env, jclass cls,
if (color_depth <= 16)
settings->DesktopWidth &= (~1);
settings->ServerHostname = strdup(hostname);
if (!(settings->ServerHostname = strdup(hostname)))
goto out_fail_strdup;
if (username && strlen(username) > 0)
settings->Username = strdup(username);
{
if (!(settings->Username = strdup(username)))
goto out_fail_strdup;
}
if (password && strlen(password) > 0)
{
settings->Password = strdup(password);
if (!(settings->Password = strdup(password)))
goto out_fail_strdup;
settings->AutoLogonEnabled = TRUE;
}
settings->Domain = strdup(domain);
if (!(settings->Domain = strdup(domain)))
goto out_fail_strdup;
if (certname && strlen(certname) > 0)
settings->CertificateName = strdup(certname);
{
if (!(settings->CertificateName = strdup(certname)))
goto out_fail_strdup;
}
settings->ConsoleSession = (console == JNI_TRUE) ? TRUE : FALSE;
@ -840,7 +896,20 @@ JNIEXPORT void JNICALL jni_freerdp_set_connection_info(JNIEnv *env, jclass cls,
(*env)->ReleaseStringUTFChars(env, jdomain, domain);
(*env)->ReleaseStringUTFChars(env, jcertname, certname);
return;
return JNI_TRUE;
out_fail_strdup:
(*env)->ReleaseStringUTFChars(env, jcertname, certname);
out_fail_certname:
(*env)->ReleaseStringUTFChars(env, jdomain, domain);
out_fail_domain:
(*env)->ReleaseStringUTFChars(env, jpassword, password);
out_fail_password:
(*env)->ReleaseStringUTFChars(env, jusername, username);
out_fail_username:
(*env)->ReleaseStringUTFChars(env, jhostname, hostname);
return JNI_FALSE;
}
JNIEXPORT void JNICALL jni_freerdp_set_performance_flags(
@ -881,16 +950,23 @@ JNIEXPORT void JNICALL jni_freerdp_set_performance_flags(
DEBUG_ANDROID("performance_flags: %04X", settings->PerformanceFlags);
}
JNIEXPORT void JNICALL jni_freerdp_set_advanced_settings(JNIEnv *env, jclass cls,
JNIEXPORT jboolean JNICALL jni_freerdp_set_advanced_settings(JNIEnv *env, jclass cls,
jint instance, jstring jRemoteProgram, jstring jWorkDir,
jboolean async_channel, jboolean async_transport, jboolean async_input,
jboolean async_update)
{
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
jboolean ret = JNI_FALSE;
const jbyte *remote_program = (*env)->GetStringUTFChars(env, jRemoteProgram, NULL);
const jbyte *work_dir = (*env)->GetStringUTFChars(env, jWorkDir, NULL);
const jbyte *remote_program;
const jbyte *work_dir;
if (!(remote_program = (*env)->GetStringUTFChars(env, jRemoteProgram, NULL)))
return JNI_FALSE;
if (!(work_dir = (*env)->GetStringUTFChars(env, jWorkDir, NULL)))
goto out_fail_work_dir;
DEBUG_ANDROID("Remote Program: %s", (char*) remote_program);
DEBUG_ANDROID("Work Dir: %s", (char*) work_dir);
@ -902,36 +978,56 @@ JNIEXPORT void JNICALL jni_freerdp_set_advanced_settings(JNIEnv *env, jclass cls
settings->AsyncInput = async_input;
if (remote_program && strlen(remote_program) > 0)
settings->AlternateShell = strdup(remote_program);
{
if (!(settings->AlternateShell = strdup(remote_program)))
goto out_fail_strdup;
}
if (work_dir && strlen(work_dir) > 0)
settings->ShellWorkingDirectory = strdup(work_dir);
{
if (!(settings->ShellWorkingDirectory = strdup(work_dir)))
goto out_fail_strdup;
}
(*env)->ReleaseStringUTFChars(env, jRemoteProgram, remote_program);
ret = JNI_TRUE;
out_fail_strdup:
(*env)->ReleaseStringUTFChars(env, jWorkDir, work_dir);
out_fail_work_dir:
(*env)->ReleaseStringUTFChars(env, jRemoteProgram, remote_program);
return ret;
}
JNIEXPORT void JNICALL jni_freerdp_set_drive_redirection(JNIEnv *env, jclass cls, jint instance, jstring jpath)
JNIEXPORT jboolean JNICALL jni_freerdp_set_drive_redirection(JNIEnv *env, jclass cls, jint instance, jstring jpath)
{
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
char* args[] = {"drive", "Android", ""};
jboolean ret = JNI_FALSE;
const jbyte *path = (*env)->GetStringUTFChars(env, jpath, NULL);
if (!path)
return JNI_FALSE;
DEBUG_ANDROID("drive redirect: %s", (char*)path);
args[2] = (char*)path;
freerdp_client_add_device_channel(settings, 3, args);
if (freerdp_client_add_device_channel(settings, 3, args) == -1)
{
settings->DeviceRedirection = FALSE;
goto out_fail;
}
settings->DeviceRedirection = TRUE;
ret = JNI_TRUE;
out_fail:
(*env)->ReleaseStringUTFChars(env, jpath, path);
return ret;
}
JNIEXPORT void JNICALL jni_freerdp_set_sound_redirection(JNIEnv *env,
JNIEXPORT jboolean JNICALL jni_freerdp_set_sound_redirection(JNIEnv *env,
jclass cls, jint instance, jint redirect)
{
char** p;
int count = 1;
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
@ -939,23 +1035,24 @@ JNIEXPORT void JNICALL jni_freerdp_set_sound_redirection(JNIEnv *env,
redirect ? ((redirect == 1) ? "Server" : "Redirect") : "None");
settings->AudioPlayback = (redirect == 2) ? TRUE : FALSE;
settings->RemoteConsoleAudio = (redirect == 1) ? TRUE : FALSE;
if (settings->AudioPlayback)
{
p = malloc(sizeof(char*));
p[0] = "rdpsnd";
int ret;
char* p[1] = {"rdpsnd"};
int count = 1;
freerdp_client_add_static_channel(settings, count, p);
ret = freerdp_client_add_static_channel(settings, count, p);
free(p);
if(ret == -1)
return JNI_FALSE;
}
settings->RemoteConsoleAudio = (redirect == 1) ? TRUE : FALSE;
return JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_set_microphone_redirection(JNIEnv *env,
JNIEXPORT jboolean JNICALL jni_freerdp_set_microphone_redirection(JNIEnv *env,
jclass cls, jint instance, jboolean enable)
{
char** p;
int count = 1;
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
@ -964,13 +1061,17 @@ JNIEXPORT void JNICALL jni_freerdp_set_microphone_redirection(JNIEnv *env,
settings->AudioCapture = enable;
if (enable)
{
p = malloc(sizeof(char*));
p[0] = "audin";
int ret;
char* p[1] = {"audin"};
int count = 1;
freerdp_client_add_dynamic_channel(settings, count, p);
ret = freerdp_client_add_dynamic_channel(settings, count, p);
if (ret == -1)
return JNI_FALSE;
free(p);
}
return JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_set_clipboard_redirection(JNIEnv *env, jclass cls, jint instance, jboolean enable)
@ -983,16 +1084,26 @@ JNIEXPORT void JNICALL jni_freerdp_set_clipboard_redirection(JNIEnv *env, jclass
settings->RedirectClipboard = enable ? TRUE : FALSE;
}
JNIEXPORT void JNICALL jni_freerdp_set_gateway_info(JNIEnv *env, jclass cls, jint instance, jstring jgatewayhostname, jint port,
JNIEXPORT jboolean JNICALL jni_freerdp_set_gateway_info(JNIEnv *env, jclass cls, jint instance, jstring jgatewayhostname, jint port,
jstring jgatewayusername, jstring jgatewaypassword, jstring jgatewaydomain)
{
freerdp* inst = (freerdp*)instance;
rdpSettings * settings = inst->settings;
jboolean ret = JNI_FALSE;
const jbyte *gatewayhostname = (*env)->GetStringUTFChars(env, jgatewayhostname, NULL);
const jbyte *gatewayusername = (*env)->GetStringUTFChars(env, jgatewayusername, NULL);
const jbyte *gatewaypassword = (*env)->GetStringUTFChars(env, jgatewaypassword, NULL);
const jbyte *gatewaydomain = (*env)->GetStringUTFChars(env, jgatewaydomain, NULL);
const jbyte *gatewayhostname;
const jbyte *gatewayusername;
const jbyte *gatewaypassword;
const jbyte *gatewaydomain;
if (!(gatewayhostname = (*env)->GetStringUTFChars(env, jgatewayhostname, NULL)))
return JNI_FALSE;
if (!(gatewayusername = (*env)->GetStringUTFChars(env, jgatewayusername, NULL)))
goto out_fail_username;
if (!(gatewaypassword = (*env)->GetStringUTFChars(env, jgatewaypassword, NULL)))
goto out_fail_password;
if (!(gatewaydomain = (*env)->GetStringUTFChars(env, jgatewaydomain, NULL)))
goto out_fail_domain;
DEBUG_ANDROID("gatewayhostname: %s", (char*) gatewayhostname);
DEBUG_ANDROID("gatewayport: %d", port);
@ -1000,19 +1111,33 @@ JNIEXPORT void JNICALL jni_freerdp_set_gateway_info(JNIEnv *env, jclass cls, jin
DEBUG_ANDROID("gatewaypassword: %s", (char*) gatewaypassword);
DEBUG_ANDROID("gatewaydomain: %s", (char*) gatewaydomain);
settings->GatewayHostname = strdup(gatewayhostname);
settings->GatewayPort = port;
settings->GatewayUsername = strdup(gatewayusername);
settings->GatewayPassword = strdup(gatewaypassword);
settings->GatewayDomain = strdup(gatewaydomain);
settings->GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
settings->GatewayEnabled = TRUE;
settings->GatewayUseSameCredentials = FALSE;
settings->GatewayHostname = strdup(gatewayhostname);
settings->GatewayUsername = strdup(gatewayusername);
settings->GatewayPassword = strdup(gatewaypassword);
settings->GatewayDomain = strdup(gatewaydomain);
if (!settings->GatewayHostname || !settings->GatewayUsername ||
!settings->GatewayPassword || !settings->GatewayDomain)
{
goto out_fail_strdup;
}
(*env)->ReleaseStringUTFChars(env, jgatewayhostname, gatewayhostname);
(*env)->ReleaseStringUTFChars(env, jgatewayusername, gatewayusername);
(*env)->ReleaseStringUTFChars(env, jgatewaypassword, gatewaypassword);
ret = JNI_TRUE;
out_fail_strdup:
(*env)->ReleaseStringUTFChars(env, jgatewaydomain, gatewaydomain);
out_fail_domain:
(*env)->ReleaseStringUTFChars(env, jgatewaypassword, gatewaypassword);
out_fail_password:
(*env)->ReleaseStringUTFChars(env, jgatewayusername, gatewayusername);
out_fail_username:
(*env)->ReleaseStringUTFChars(env, jgatewayhostname, gatewayhostname);
return ret;
}
static void copy_pixel_buffer(UINT8* dstBuf, UINT8* srcBuf, int x, int y, int width, int height, int wBuf, int hBuf, int bpp)
@ -1065,7 +1190,7 @@ JNIEXPORT jboolean JNICALL jni_freerdp_update_graphics(
return JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_send_key_event(
JNIEXPORT jboolean JNICALL jni_freerdp_send_key_event(
JNIEnv *env, jclass cls, jint instance, jint keycode, jboolean down)
{
DWORD scancode;
@ -1077,54 +1202,86 @@ JNIEXPORT void JNICALL jni_freerdp_send_key_event(
int flags = (down == JNI_TRUE) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE;
flags |= (scancode & KBDEXT) ? KBD_FLAGS_EXTENDED : 0;
event = (ANDROID_EVENT*) android_event_key_new(flags, scancode & 0xFF);
if (!event)
return JNI_FALSE;
android_push_event(inst, event);
if (!android_push_event(inst, event))
{
android_event_key_free((ANDROID_EVENT_KEY *)event);
return JNI_FALSE;
}
DEBUG_ANDROID("send_key_event: %d, %d", (int)scancode, flags);
return JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_send_unicodekey_event(
JNIEXPORT jboolean JNICALL jni_freerdp_send_unicodekey_event(
JNIEnv *env, jclass cls, jint instance, jint keycode)
{
ANDROID_EVENT* event;
freerdp* inst = (freerdp*)instance;
event = (ANDROID_EVENT*) android_event_unicodekey_new(keycode);
android_push_event(inst, event);
if (!event)
return JNI_FALSE;
if (!android_push_event(inst, event))
{
android_event_unicodekey_free((ANDROID_EVENT_KEY *)event);
return JNI_FALSE;
}
DEBUG_ANDROID("send_unicodekey_event: %d", keycode);
return JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_send_cursor_event(
JNIEXPORT jboolean JNICALL jni_freerdp_send_cursor_event(
JNIEnv *env, jclass cls, jint instance, jint x, jint y, jint flags)
{
ANDROID_EVENT* event;
freerdp* inst = (freerdp*)instance;
event = (ANDROID_EVENT*) android_event_cursor_new(flags, x, y);
android_push_event(inst, event);
if (!event)
return JNI_FALSE;
if (!android_push_event(inst, event))
{
android_event_cursor_free((ANDROID_EVENT_CURSOR *)event);
return JNI_FALSE;
}
DEBUG_ANDROID("send_cursor_event: (%d, %d), %d", x, y, flags);
return JNI_TRUE;
}
JNIEXPORT void JNICALL jni_freerdp_send_clipboard_data(JNIEnv *env, jclass cls, jint instance, jstring jdata)
JNIEXPORT jboolean JNICALL jni_freerdp_send_clipboard_data(JNIEnv *env, jclass cls, jint instance, jstring jdata)
{
ANDROID_EVENT* event;
freerdp* inst = (freerdp*)instance;
const jbyte *data = jdata != NULL ? (*env)->GetStringUTFChars(env, jdata, NULL) : NULL;
int data_length = data ? strlen(data) : 0;
jboolean ret = JNI_FALSE;;
event = (ANDROID_EVENT*) android_event_clipboard_new((void*)data, data_length);
android_push_event(inst, event);
if (!event)
goto out_fail;
if (!android_push_event(inst, event))
{
android_event_clipboard_free((ANDROID_EVENT_CLIPBOARD *)event);
goto out_fail;
}
DEBUG_ANDROID("send_clipboard_data: (%s)", data);
ret = JNI_TRUE;
out_fail:
if (data)
(*env)->ReleaseStringUTFChars(env, jdata, data);
return ret;
}
JNIEXPORT jstring JNICALL jni_freerdp_get_version(JNIEnv *env, jclass cls)
{
return (*env)->NewStringUTF(env, GIT_REVISION);
}

24
client/Android/FreeRDPCore/jni/android_freerdp.h
View File

@ -44,27 +44,27 @@ JNIEXPORT jint JNICALL jni_freerdp_new(JNIEnv *env, jclass cls);
JNIEXPORT void JNICALL jni_freerdp_free(JNIEnv *env, jclass cls, jint instance);
JNIEXPORT jboolean JNICALL jni_freerdp_connect(JNIEnv *env, jclass cls, jint instance);
JNIEXPORT jboolean JNICALL jni_freerdp_disconnect(JNIEnv *env, jclass cls, jint instance);
JNIEXPORT void JNICALL jni_freerdp_cancel_connection(JNIEnv *env, jclass cls, jint instance);
JNIEXPORT void JNICALL jni_freerdp_set_connection_info(JNIEnv *env, jclass cls, jint instance,
JNIEXPORT jboolean JNICALL jni_freerdp_cancel_connection(JNIEnv *env, jclass cls, jint instance);
JNIEXPORT jboolean JNICALL jni_freerdp_set_connection_info(JNIEnv *env, jclass cls, jint instance,
jstring jhostname, jstring jusername, jstring jpassword, jstring jdomain, jint width,
jint height, jint color_depth, jint port, jboolean console, jint security, jstring jcertname);
JNIEXPORT void JNICALL jni_freerdp_set_performance_flags(JNIEnv *env, jclass cls, jint instance, jboolean remotefx, jboolean disableWallpaper, jboolean disableFullWindowDrag,
jboolean disableMenuAnimations, jboolean disableTheming, jboolean enableFontSmoothing, jboolean enableDesktopComposition);
JNIEXPORT void JNICALL jni_freerdp_set_advanced_settings(JNIEnv *env, jclass cls,
JNIEXPORT jboolean JNICALL jni_freerdp_set_advanced_settings(JNIEnv *env, jclass cls,
jint instance, jstring jRemoteProgram, jstring jWorkDir,
jboolean async_channel, jboolean async_transport, jboolean async_input,
jboolean async_update);
JNIEXPORT void JNICALL jni_freerdp_set_drive_redirection(JNIEnv *env, jclass cls, jint instance, jstring jpath);
JNIEXPORT void JNICALL jni_freerdp_set_sound_redirection(JNIEnv *env, jclass cls, jint instance, jint redirect);
JNIEXPORT void JNICALL jni_freerdp_set_microphone_redirection(JNIEnv *env, jclass cls, jint instance, jboolean enable);
JNIEXPORT jboolean JNICALL jni_freerdp_set_drive_redirection(JNIEnv *env, jclass cls, jint instance, jstring jpath);
JNIEXPORT jboolean JNICALL jni_freerdp_set_sound_redirection(JNIEnv *env, jclass cls, jint instance, jint redirect);
JNIEXPORT jboolean JNICALL jni_freerdp_set_microphone_redirection(JNIEnv *env, jclass cls, jint instance, jboolean enable);
JNIEXPORT void JNICALL jni_freerdp_set_clipboard_redirection(JNIEnv *env, jclass cls, jint instance, jboolean enable);
JNIEXPORT void JNICALL jni_freerdp_set_gateway_info(JNIEnv *env, jclass cls, jint instance, jstring jgatewayhostname, jint port, jstring jgatewayusername, jstring jgatewaypassword, jstring jgatewaydomain);
JNIEXPORT void JNICALL jni_freerdp_set_data_directory(JNIEnv *env, jclass cls, jint instance, jstring jdirectory);
JNIEXPORT jboolean JNICALL jni_freerdp_set_gateway_info(JNIEnv *env, jclass cls, jint instance, jstring jgatewayhostname, jint port, jstring jgatewayusername, jstring jgatewaypassword, jstring jgatewaydomain);
JNIEXPORT jboolean JNICALL jni_freerdp_set_data_directory(JNIEnv *env, jclass cls, jint instance, jstring jdirectory);
JNIEXPORT jboolean JNICALL jni_freerdp_update_graphics(JNIEnv *env, jclass cls, jint instance, jobject bitmap, jint x, jint y, jint width, jint height);
JNIEXPORT void JNICALL jni_freerdp_send_cursor_event(JNIEnv *env, jclass cls, jint instance, jint x, jint y, jint flags);
JNIEXPORT void JNICALL jni_freerdp_send_key_event(JNIEnv *env, jclass cls, jint instance, jint keycode, jboolean down);
JNIEXPORT void JNICALL jni_freerdp_send_unicodekey_event(JNIEnv *env, jclass cls, jint instance, jint keycode);
JNIEXPORT void JNICALL jni_freerdp_send_clipboard_data(JNIEnv *env, jclass cls, jint instance, jstring jdata);
JNIEXPORT jboolean JNICALL jni_freerdp_send_cursor_event(JNIEnv *env, jclass cls, jint instance, jint x, jint y, jint flags);
JNIEXPORT jboolean JNICALL jni_freerdp_send_key_event(JNIEnv *env, jclass cls, jint instance, jint keycode, jboolean down);
JNIEXPORT jboolean JNICALL jni_freerdp_send_unicodekey_event(JNIEnv *env, jclass cls, jint instance, jint keycode);
JNIEXPORT jboolean JNICALL jni_freerdp_send_clipboard_data(JNIEnv *env, jclass cls, jint instance, jstring jdata);
JNIEXPORT jstring JNICALL jni_freerdp_get_version(JNIEnv *env, jclass cls);
#endif /* __ANDROID_FREERDP_H */

2
client/Android/FreeRDPCore/jni/android_jni_utils.c
View File

@ -99,6 +99,8 @@ char* get_string_from_string_builder(JNIEnv* env, jobject strBuilder)
// read string
native_str = (*env)->GetStringUTFChars(env, strObj, NULL);
if (!native_str)
return NULL;
result = strdup(native_str);
(*env)->ReleaseStringUTFChars(env, strObj, native_str);

48
client/Android/FreeRDPCore/jni/generated/android_freerdp_jni.c
View File

@ -40,32 +40,32 @@ JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_free
return jni_freerdp_disconnect(env, cls, instance);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1cancel_1connection(JNIEnv *env, jclass cls, jint instance)
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1cancel_1connection(JNIEnv *env, jclass cls, jint instance)
{
jni_freerdp_cancel_connection(env, cls, instance);
return jni_freerdp_cancel_connection(env, cls, instance);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1connection_1info(JNIEnv *env, jclass cls, jint instance,
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1connection_1info(JNIEnv *env, jclass cls, jint instance,
jstring jhostname, jstring jusername, jstring jpassword, jstring jdomain, jint width, jint height, jint color_depth, jint port,
jboolean console, jint security, jstring certname)
{
jni_freerdp_set_connection_info(env, cls, instance, jhostname, jusername, jpassword, jdomain,
return jni_freerdp_set_connection_info(env, cls, instance, jhostname, jusername, jpassword, jdomain,
width, height, color_depth, port, console, security, certname);
}
JNIEXPORT void JNICALL
JNIEXPORT jboolean JNICALL
Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1advanced_1settings(
JNIEnv *env, jclass cls, jint instance, jstring remote_program, jstring work_dir,
jboolean async_channel, jboolean async_transport, jboolean async_input,
jboolean async_update)
{
jni_freerdp_set_advanced_settings(env, cls, instance, remote_program, work_dir,
return jni_freerdp_set_advanced_settings(env, cls, instance, remote_program, work_dir,
async_channel, async_transport, async_input, async_update);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1data_1directory(JNIEnv *env, jclass cls, jint instance, jstring directory)
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1data_1directory(JNIEnv *env, jclass cls, jint instance, jstring directory)
{
jni_freerdp_set_data_directory(env, cls, instance, directory);
return jni_freerdp_set_data_directory(env, cls, instance, directory);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1performance_1flags(
@ -81,28 +81,28 @@ JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_
jni_freerdp_set_clipboard_redirection(env, cls, inst, enable);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1sound_1redirection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1sound_1redirection
(JNIEnv *env, jclass cls, jint inst, jint redirect)
{
jni_freerdp_set_sound_redirection(env, cls, inst, redirect);
return jni_freerdp_set_sound_redirection(env, cls, inst, redirect);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1microphone_1redirection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1microphone_1redirection
(JNIEnv *env, jclass cls, jint inst, jboolean redirect)
{
jni_freerdp_set_microphone_redirection(env, cls, inst, redirect);
return jni_freerdp_set_microphone_redirection(env, cls, inst, redirect);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1drive_1redirection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1drive_1redirection
(JNIEnv *env, jclass cls, jint inst, jstring path)
{
jni_freerdp_set_drive_redirection(env, cls, inst, path);
return jni_freerdp_set_drive_redirection(env, cls, inst, path);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1gateway_1info
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1gateway_1info
(JNIEnv *env, jclass cls, jint inst, jstring hostname, jint port, jstring username, jstring password, jstring domain)
{
jni_freerdp_set_gateway_info(env, cls, inst, hostname, port, username, password, domain);
return jni_freerdp_set_gateway_info(env, cls, inst, hostname, port, username, password, domain);
}
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1update_1graphics(
@ -111,28 +111,28 @@ JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_free
return jni_freerdp_update_graphics(env, cls, instance, bitmap, x, y, width, height);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event(
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event(
JNIEnv *env, jclass cls, jint instance, jint x, jint y, jint flags)
{
jni_freerdp_send_cursor_event(env, cls, instance, x, y, flags);
return jni_freerdp_send_cursor_event(env, cls, instance, x, y, flags);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event(
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event(
JNIEnv *env, jclass cls, jint instance, jint keycode, jboolean down)
{
jni_freerdp_send_key_event(env, cls, instance, keycode, down);
return jni_freerdp_send_key_event(env, cls, instance, keycode, down);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event
(JNIEnv *env, jclass cls, jint instance, jint keycode)
{
jni_freerdp_send_unicodekey_event(env, cls, instance, keycode);
return jni_freerdp_send_unicodekey_event(env, cls, instance, keycode);
}
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data
(JNIEnv *env, jclass cls, jint instance, jstring data)
{
jni_freerdp_send_clipboard_data(env, cls, instance, data);
return jni_freerdp_send_clipboard_data(env, cls, instance, data);
}
JNIEXPORT jstring JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1get_1version(JNIEnv *env, jclass cls)

48
client/Android/FreeRDPCore/jni/generated/com_freerdp_freerdpcore_services_LibFreeRDP.h
View File

@ -42,17 +42,17 @@ JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_free
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_cancel_connection
* Signature: (I)V
* Signature: (I)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1cancel_1connection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1cancel_1connection
(JNIEnv *, jclass, jint);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_connection_info
* Signature: (ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIIIZILjava/lang/String;)V
* Signature: (ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIIIZILjava/lang/String;)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1connection_1info
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1connection_1info
(JNIEnv *, jclass, jint, jstring, jstring, jstring, jstring, jint, jint, jint, jint, jboolean, jint, jstring);
/*
@ -66,17 +66,17 @@ JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_advanced_settings
* Signature: (ILjava/lang/String;Ljava/lang/String;ZZZZ)V
* Signature: (ILjava/lang/String;Ljava/lang/String;ZZZZ)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1advanced_1settings
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1advanced_1settings
(JNIEnv *, jclass, jint, jstring, jstring, jboolean, jboolean, jboolean, jboolean);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_data_directory
* Signature: (ILjava/lang/String;)V
* Signature: (ILjava/lang/String;)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1data_1directory
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1data_1directory
(JNIEnv *, jclass, jint, jstring);
/*
@ -90,33 +90,33 @@ JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_sound_redirection
* Signature: (IZ)V
* Signature: (II)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1sound_1redirection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1sound_1redirection
(JNIEnv *, jclass, jint, jint);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_microphone_redirection
* Signature: (IZ)V
* Signature: (IZ)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1microphone_1redirection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1microphone_1redirection
(JNIEnv *, jclass, jint, jboolean);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_drive_redirection
* Signature: (ILjava/lang/String;)V
* Signature: (ILjava/lang/String;)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1drive_1redirection
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1drive_1redirection
(JNIEnv *, jclass, jint, jstring);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_set_gateway_info
* Signature: (ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
* Signature: (ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1gateway_1info
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1set_1gateway_1info
(JNIEnv *, jclass, jint, jstring, jint, jstring, jstring, jstring);
/*
@ -130,33 +130,33 @@ JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_free
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_send_cursor_event
* Signature: (IIII)V
* Signature: (IIII)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1cursor_1event
(JNIEnv *, jclass, jint, jint, jint, jint);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_send_key_event
* Signature: (IIZ)V
* Signature: (IIZ)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1key_1event
(JNIEnv *, jclass, jint, jint, jboolean);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_send_unicodekey_event
* Signature: (II)V
* Signature: (II)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1unicodekey_1event
(JNIEnv *, jclass, jint, jint);
/*
* Class: com_freerdp_freerdpcore_services_LibFreeRDP
* Method: freerdp_send_clipboard_data
* Signature: (ILjava/lang/String;)V
* Signature: (ILjava/lang/String;)Z
*/
JNIEXPORT void JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data
JNIEXPORT jboolean JNICALL Java_com_freerdp_freerdpcore_services_LibFreeRDP_freerdp_1send_1clipboard_1data
(JNIEnv *, jclass, jint, jstring);
/*

48
client/Android/FreeRDPCore/src/com/freerdp/freerdpcore/services/LibFreeRDP.java
View File

@ -23,9 +23,9 @@ public class LibFreeRDP
private static native void freerdp_free(int inst);
private static native boolean freerdp_connect(int inst);
private static native boolean freerdp_disconnect(int inst);
private static native void freerdp_cancel_connection(int inst);
private static native boolean freerdp_cancel_connection(int inst);
private static native void freerdp_set_connection_info(int inst,
private static native boolean freerdp_set_connection_info(int inst,
String hostname, String username, String password, String domain,
int width, int height, int color_depth, int port, boolean console,
int security, String certname);
@ -35,27 +35,27 @@ public class LibFreeRDP
boolean disableMenuAnimations, boolean disableTheming,
boolean enableFontSmoothing, boolean enableDesktopComposition);
private static native void freerdp_set_advanced_settings(int inst,
private static native boolean freerdp_set_advanced_settings(int inst,
String remoteProgram, String workDir, boolean async_channel,
boolean async_transport, boolean async_input, boolean async_update);
private static native void freerdp_set_data_directory(int inst, String directory);
private static native boolean freerdp_set_data_directory(int inst, String directory);
private static native void freerdp_set_clipboard_redirection(int inst, boolean enable);
private static native void freerdp_set_sound_redirection(int inst, int redirect);
private static native void freerdp_set_microphone_redirection(int inst, boolean enable);
private static native void freerdp_set_drive_redirection(int inst, String path);
private static native boolean freerdp_set_sound_redirection(int inst, int redirect);
private static native boolean freerdp_set_microphone_redirection(int inst, boolean enable);
private static native boolean freerdp_set_drive_redirection(int inst, String path);
private static native void freerdp_set_gateway_info(int inst, String gatewayhostname, int port,
private static native boolean freerdp_set_gateway_info(int inst, String gatewayhostname, int port,
String gatewayusername, String gatewaypassword, String gatewaydomain);
private static native boolean freerdp_update_graphics(int inst,
Bitmap bitmap, int x, int y, int width, int height);
private static native void freerdp_send_cursor_event(int inst, int x, int y, int flags);
private static native void freerdp_send_key_event(int inst, int keycode, boolean down);
private static native void freerdp_send_unicodekey_event(int inst, int keycode);
private static native void freerdp_send_clipboard_data(int inst, String data);
private static native boolean freerdp_send_cursor_event(int inst, int x, int y, int flags);
private static native boolean freerdp_send_key_event(int inst, int keycode, boolean down);
private static native boolean freerdp_send_unicodekey_event(int inst, int keycode);
private static native boolean freerdp_send_clipboard_data(int inst, String data);
private static native String freerdp_get_version();
@ -106,9 +106,9 @@ public class LibFreeRDP
return freerdp_disconnect(inst);
}
public static void cancelConnection(int inst)
public static boolean cancelConnection(int inst)
{
freerdp_cancel_connection(inst);
return freerdp_cancel_connection(inst);
}
public static boolean setConnectionInfo(int inst, BookmarkBase bookmark)
@ -185,9 +185,9 @@ public class LibFreeRDP
return true;
}
public static void setDataDirectory(int inst, String directory)
public static boolean setDataDirectory(int inst, String directory)
{
freerdp_set_data_directory(inst, directory);
return freerdp_set_data_directory(inst, directory);
}
public static boolean updateGraphics(int inst, Bitmap bitmap, int x, int y, int width, int height)
@ -195,24 +195,24 @@ public class LibFreeRDP
return freerdp_update_graphics(inst, bitmap, x, y, width, height);
}
public static void sendCursorEvent(int inst, int x, int y, int flags)
public static boolean sendCursorEvent(int inst, int x, int y, int flags)
{
freerdp_send_cursor_event(inst, x, y, flags);
return freerdp_send_cursor_event(inst, x, y, flags);
}
public static void sendKeyEvent(int inst, int keycode, boolean down)
public static boolean sendKeyEvent(int inst, int keycode, boolean down)
{
freerdp_send_key_event(inst, keycode, down);
return freerdp_send_key_event(inst, keycode, down);
}
public static void sendUnicodeKeyEvent(int inst, int keycode)
public static boolean sendUnicodeKeyEvent(int inst, int keycode)
{
freerdp_send_unicodekey_event(inst, keycode);
return freerdp_send_unicodekey_event(inst, keycode);
}
public static void sendClipboardData(int inst, String data)
public static boolean sendClipboardData(int inst, String data)
{
freerdp_send_clipboard_data(inst, data);
return freerdp_send_clipboard_data(inst, data);
}
private static void OnConnectionSuccess(int inst)

8
client/DirectFB/dfreerdp.c
View File

@ -179,9 +179,7 @@ BOOL df_pre_connect(freerdp* instance)
freerdp_channels_pre_connect(instance->context->channels, instance);
instance->context->cache = cache_new(instance->settings);
return TRUE;
return (instance->context->cache = cache_new(instance->settings)) != NULL;
}
BOOL df_post_connect(freerdp* instance)
@ -237,9 +235,7 @@ BOOL df_post_connect(freerdp* instance)
pointer_cache_register_callbacks(instance->update);
df_register_graphics(instance->context->graphics);
freerdp_channels_post_connect(instance->context->channels, instance);
return TRUE;
return freerdp_channels_post_connect(instance->context->channels, instance) >= 0;
}
BOOL df_verify_certificate(freerdp* instance, char* subject, char* issuer, char* fingerprint)

4
client/Sample/freerdp.c
View File

@ -122,9 +122,7 @@ static BOOL tf_post_connect(freerdp* instance)
instance->update->BeginPaint = tf_begin_paint;
instance->update->EndPaint = tf_end_paint;
freerdp_channels_post_connect(instance->context->channels, instance);
return TRUE;
return (freerdp_channels_post_connect(instance->context->channels, instance) >= 0);
}
static void* tf_client_thread_proc(freerdp* instance)

4
client/Wayland/wlf_window.c
View File

@ -149,9 +149,9 @@ wlfWindow* wlf_CreateDesktopWindow(wlfContext* wlfc, char* name, int width, int
wlf_ResizeDesktopWindow(wlfc, window, width, height);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
}
wlf_SetWindowText(wlfc, window, name);
wlf_SetWindowText(wlfc, window, name);
}
return window;
}

2
client/Wayland/wlfreerdp.c
View File

@ -142,7 +142,7 @@ static BOOL wl_post_connect(freerdp* instance)
/* put Wayland data in the context here */
context->window = window;
if (freerdp_channels_post_connect(instance->context->channels, instance))
if (freerdp_channels_post_connect(instance->context->channels, instance) < 0)
return FALSE;
wlf_UpdateWindowArea(context, window, 0, 0, gdi->width, gdi->height);

22
client/Windows/cli/wfreerdp.c
View File

@ -50,6 +50,7 @@ INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
rdpContext* context;
rdpSettings* settings;
RDP_CLIENT_ENTRY_POINTS clientEntryPoints;
int ret = 0;
ZeroMemory(&clientEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
clientEntryPoints.Size = sizeof(RDP_CLIENT_ENTRY_POINTS);
@ -66,9 +67,26 @@ INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
context->argc = __argc;
context->argv = (char**) malloc(sizeof(char*) * __argc);
if (!context->argv)
{
ret = 1;
goto out;
}
for (index = 0; index < context->argc; index++)
{
context->argv[index] = _strdup(__argv[index]);
if (!context->argv[index])
{
ret = 1;
for (--index; index >= 0; --index)
free(context->argv[index]);
free(context->argv);
context->argv = NULL;
goto out;
}
}
status = freerdp_client_settings_parse_command_line(settings, context->argc, context->argv, FALSE);
@ -89,8 +107,8 @@ INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
GetExitCodeThread(thread, &dwExitCode);
freerdp_client_stop(context);
out:
freerdp_client_context_free(context);
return 0;
return ret;
}

30
client/Windows/wf_client.c
View File

@ -275,7 +275,8 @@ BOOL wf_pre_connect(freerdp* instance)
wfc->clrconv->palette = NULL;
wfc->clrconv->alpha = FALSE;
instance->context->cache = cache_new(settings);
if (!(instance->context->cache = cache_new(settings)))
return FALSE;
desktopWidth = settings->DesktopWidth;
desktopHeight = settings->DesktopHeight;
@ -321,7 +322,7 @@ BOOL wf_pre_connect(freerdp* instance)
(settings->DesktopWidth > 4096) || (settings->DesktopHeight > 4096))
{
WLog_ERR(TAG, "invalid dimensions %d %d", settings->DesktopWidth, settings->DesktopHeight);
return 1;
return FALSE;
}
freerdp_set_param_uint32(settings, FreeRDP_KeyboardLayout, (int) GetKeyboardLayout(0) & 0x0000FFFF);
@ -484,7 +485,8 @@ BOOL wf_post_connect(freerdp* instance)
instance->update->BitmapUpdate = wf_gdi_bitmap_update;
}
freerdp_channels_post_connect(context->channels, instance);
if (freerdp_channels_post_connect(context->channels, instance) < 0)
return FALSE;
if (wfc->fullscreen)
floatbar_window_create(wfc);
@ -534,13 +536,31 @@ BOOL wf_authenticate(freerdp* instance, char** username, char** password, char**
status = CredUIParseUserNameA(UserName, User, sizeof(User), Domain, sizeof(Domain));
//WLog_ERR(TAG, "User: %s Domain: %s Password: %s", User, Domain, Password);
*username = _strdup(User);
if (!(*username))
{
WLog_ERR(TAG, "strdup failed", status);
return FALSE;
}
if (strlen(Domain) > 0)
*domain = _strdup(Domain);
else
*domain = _strdup("\0");
if (!(*domain))
{
free(*username);
WLog_ERR(TAG, "strdup failed", status);
return FALSE;
}
*password = _strdup(Password);
if (!(*password))
{
free(*username);
free(*domain);
return FALSE;
}
return TRUE;
}
@ -873,6 +893,10 @@ int freerdp_client_load_settings_from_rdp_file(wfContext* wfc, char* filename)
if (filename)
{
settings->ConnectionFile = _strdup(filename);
if (!settings->ConnectionFile)
{
return 3;
}
// free old settings file
freerdp_client_rdp_file_free(wfc->connectionRdpFile);

19
client/X11/xf_client.c
View File

@ -552,6 +552,8 @@ BOOL xf_create_window(xfContext* xfc)
if (settings->WindowTitle)
{
windowTitle = _strdup(settings->WindowTitle);
if (!windowTitle)
return FALSE;
}
else if (settings->ServerPort == 3389)
{
@ -999,6 +1001,8 @@ BOOL xf_pre_connect(freerdp* instance)
if (login_name)
{
settings->Username = _strdup(login_name);
if (!settings->Username)
return FALSE;
WLog_INFO(TAG, "No user name set. - Using login name: %s", settings->Username);
}
}
@ -1016,9 +1020,13 @@ BOOL xf_pre_connect(freerdp* instance)
}
if (!context->cache)
context->cache = cache_new(settings);
{
if (!(context->cache = cache_new(settings)))
return FALSE;
}
xf_keyboard_init(xfc);
if (!xf_keyboard_init(xfc))
return FALSE;
xf_detect_monitors(xfc, &maxWidth, &maxHeight);
@ -1165,7 +1173,8 @@ BOOL xf_post_connect(freerdp* instance)
update->SetKeyboardIndicators = xf_keyboard_set_indicators;
xfc->clipboard = xf_clipboard_new(xfc);
freerdp_channels_post_connect(channels, instance);
if (freerdp_channels_post_connect(channels, instance) < 0)
return FALSE;
EventArgsInit(&e, "xfreerdp");
e.width = settings->DesktopWidth;
@ -1422,8 +1431,8 @@ void* xf_client_thread(void* param)
xfContext* xfc;
freerdp* instance;
rdpContext* context;
HANDLE inputEvent;
HANDLE inputThread;
HANDLE inputEvent = NULL;
HANDLE inputThread = NULL;
rdpChannels* channels;
rdpSettings* settings;

16
client/X11/xf_cliprdr.c
View File

@ -836,6 +836,16 @@ static int xf_cliprdr_server_format_list(CliprdrClientContext* context, CLIPRDR_
format = &formatList->formats[i];
clipboard->serverFormats[i].formatId = format->formatId;
clipboard->serverFormats[i].formatName = _strdup(format->formatName);
if (!clipboard->serverFormats[i].formatName)
{
for (--i; i >= 0; --i)
free(clipboard->serverFormats[i].formatName);
clipboard->numServerFormats = 0;
free(clipboard->serverFormats);
clipboard->serverFormats = NULL;
return -1;
}
}
clipboard->numTargets = 2;
@ -1103,6 +1113,12 @@ xfClipboard* xf_clipboard_new(xfContext* xfc)
clipboard->clientFormats[n].atom = XInternAtom(xfc->display, "text/html", False);
clipboard->clientFormats[n].formatId = CB_FORMAT_HTML;
clipboard->clientFormats[n].formatName = _strdup("HTML Format");
if (!clipboard->clientFormats[n].formatName)
{
ClipboardDestroy(clipboard->system);
free(clipboard);
return NULL;
}
n++;
clipboard->numClientFormats = n;

30
client/X11/xf_event.c
View File

@ -87,7 +87,6 @@ const char* const X11_EVENT_STRINGS[] =
BOOL xf_event_action_script_init(xfContext* xfc)
{
int exitCode;
char* xevent;
FILE* actionScript;
char buffer[1024] = { 0 };
@ -102,18 +101,22 @@ BOOL xf_event_action_script_init(xfContext* xfc)
actionScript = popen(command, "r");
if (actionScript < 0)
if (!actionScript)
return FALSE;
while (fgets(buffer, sizeof(buffer), actionScript))
{
strtok(buffer, "\n");
xevent = _strdup(buffer);
if (ArrayList_Add(xfc->xevents, xevent) < 0)
if (!xevent || ArrayList_Add(xfc->xevents, xevent) < 0)
{
ArrayList_Free(xfc->xevents);
xfc->xevents = NULL;
return FALSE;
}
}
exitCode = pclose(actionScript);
pclose(actionScript);
return TRUE;
}
@ -127,23 +130,22 @@ void xf_event_action_script_free(xfContext* xfc)
}
}
int xf_event_execute_action_script(xfContext* xfc, XEvent* event)
static BOOL xf_event_execute_action_script(xfContext* xfc, XEvent* event)
{
int index;
int count;
char* name;
int exitCode;
FILE* actionScript;
BOOL match = FALSE;
const char* xeventName;
char buffer[1024] = { 0 };
char command[1024] = { 0 };
if (!xfc->actionScript)
return 1;
if (!xfc->actionScript || !xfc->xevents)
return FALSE;
if (event->type > (sizeof(X11_EVENT_STRINGS) / sizeof(const char*)))
return 1;
return FALSE;
xeventName = X11_EVENT_STRINGS[event->type];
@ -161,24 +163,24 @@ int xf_event_execute_action_script(xfContext* xfc, XEvent* event)
}
if (!match)
return 1;
return FALSE;
sprintf_s(command, sizeof(command), "%s xevent %s %d",
xfc->actionScript, xeventName, (int) xfc->window->handle);
actionScript = popen(command, "r");
if (actionScript < 0)
return -1;
if (!actionScript)
return FALSE;
while (fgets(buffer, sizeof(buffer), actionScript))
{
strtok(buffer, "\n");
}
exitCode = pclose(actionScript);
pclose(actionScript);
return 1;
return TRUE;
}
void xf_event_adjust_coordinates(xfContext* xfc, int* x, int *y)

2
client/X11/xf_gdi.c
View File

@ -221,7 +221,7 @@ BOOL xf_set_rop3(xfContext* xfc, int rop3)
UINT32 xf_convert_rdp_order_color(xfContext* xfc, UINT32 color)
{
UINT32 r, g, b;
UINT32 r = 0, g = 0, b = 0;
switch (xfc->srcBpp)
{

31
client/X11/xf_keyboard.c
View File

@ -45,7 +45,6 @@
BOOL xf_keyboard_action_script_init(xfContext* xfc)
{
int exitCode;
FILE* keyScript;
char* keyCombination;
char buffer[1024] = { 0 };
@ -61,11 +60,11 @@ BOOL xf_keyboard_action_script_init(xfContext* xfc)
xfc->actionScript = _strdup("/usr/share/freerdp/action.sh");
if (!xfc->actionScript)
return 0;
return FALSE;
xfc->keyCombinations = ArrayList_New(TRUE);
if (!xfc->keyCombinations)
return 0;
return FALSE;
ArrayList_Object(xfc->keyCombinations)->fnObjectFree = free;
@ -73,24 +72,30 @@ BOOL xf_keyboard_action_script_init(xfContext* xfc)
keyScript = popen(command, "r");
if (keyScript < 0)
if (!keyScript)
{
free(xfc->actionScript);
xfc->actionScript = NULL;
return 0;
return FALSE;
}
while (fgets(buffer, sizeof(buffer), keyScript) != NULL)
{
strtok(buffer, "\n");
keyCombination = _strdup(buffer);
if (ArrayList_Add(xfc->keyCombinations, keyCombination) < 0)
return 0;
if (!keyCombination || ArrayList_Add(xfc->keyCombinations, keyCombination) < 0)
{
ArrayList_Free(xfc->keyCombinations);
free(xfc->actionScript);
xfc->actionScript = NULL;
pclose(keyScript);
return FALSE;
}
}
exitCode = pclose(keyScript);
pclose(keyScript);
return xf_event_action_script_init(xfc);
}
void xf_keyboard_action_script_free(xfContext* xfc)
@ -110,7 +115,7 @@ void xf_keyboard_action_script_free(xfContext* xfc)
}
}
void xf_keyboard_init(xfContext* xfc)
BOOL xf_keyboard_init(xfContext* xfc)
{
xf_keyboard_clear(xfc);
@ -121,9 +126,11 @@ void xf_keyboard_init(xfContext* xfc)
if (xfc->modifierMap)
XFreeModifiermap(xfc->modifierMap);
xfc->modifierMap = XGetModifierMapping(xfc->display);
if (!(xfc->modifierMap = XGetModifierMapping(xfc->display)))
return FALSE;
xf_keyboard_action_script_init(xfc);
return TRUE;
}
void xf_keyboard_free(xfContext* xfc)
@ -407,7 +414,7 @@ int xf_keyboard_execute_action_script(xfContext* xfc, XF_MODIFIER_KEYS* mod, Key
keyScript = popen(command, "r");
if (keyScript < 0)
if (!keyScript)
return -1;
while (fgets(buffer, sizeof(buffer), keyScript) != NULL)

2
client/X11/xf_keyboard.h
View File

@ -44,7 +44,7 @@ struct _XF_MODIFIER_KEYS
};
typedef struct _XF_MODIFIER_KEYS XF_MODIFIER_KEYS;
void xf_keyboard_init(xfContext* xfc);
BOOL xf_keyboard_init(xfContext* xfc);
void xf_keyboard_free(xfContext* xfc);
void xf_keyboard_clear(xfContext* xfc);
void xf_keyboard_key_press(xfContext* xfc, BYTE keycode, KeySym keysym);

5
client/X11/xf_rail.c
View File

@ -312,6 +312,11 @@ static BOOL xf_rail_window_common(rdpContext* context, WINDOW_ORDER_INFO* orderI
{
appWindow->title = _strdup("RdpRailWindow");
}
if (!appWindow->title)
{
free(appWindow);
return FALSE;
}
HashTable_Add(xfc->railWindows, (void*) (UINT_PTR) orderInfo->windowId, (void*) appWindow);

2
client/X11/xf_tsmf.c
View File

@ -187,6 +187,7 @@ int xf_tsmf_xv_video_frame_event(TsmfClientContext* tsmf, TSMF_VIDEO_FRAME_EVENT
else
{
WLog_DBG(TAG, "pixel format 0x%X not supported by hardware.", pixfmt);
free(xrects);
return -1003;
}
@ -213,6 +214,7 @@ int xf_tsmf_xv_video_frame_event(TsmfClientContext* tsmf, TSMF_VIDEO_FRAME_EVENT
if (!XShmAttach(xfc->display, &shminfo))
{
XFree(image);
free(xrects);
WLog_DBG(TAG, "XShmAttach failed.");
return -1004;
}

6
client/X11/xf_window.c
View File

@ -335,7 +335,7 @@ static void xf_SetWindowPID(xfContext* xfc, Window window, pid_t pid)
static const char* get_shm_id()
{
static char shm_id[64];
snprintf(shm_id, sizeof(shm_id), "com.freerdp.xfreerdp.tsmf_%016X", GetCurrentProcessId());
snprintf(shm_id, sizeof(shm_id), "/com.freerdp.xfreerdp.tsmf_%016X", GetCurrentProcessId());
return shm_id;
}
@ -368,7 +368,7 @@ xfWindow* xf_CreateDesktopWindow(xfContext* xfc, char* name, int width, int heig
CWBackPixel | CWBackingStore | CWOverrideRedirect | CWColormap |
CWBorderPixel | CWWinGravity | CWBitGravity, &xfc->attribs);
window->shmid = shm_open(get_shm_id(), O_CREAT | O_EXCL | O_RDWR, S_IREAD | S_IWRITE);
window->shmid = shm_open(get_shm_id(), (O_CREAT | O_RDWR), (S_IREAD | S_IWRITE));
if (window->shmid < 0)
{
@ -382,7 +382,7 @@ xfWindow* xf_CreateDesktopWindow(xfContext* xfc, char* name, int width, int heig
mem = mmap(0, sizeof(window->handle), PROT_READ | PROT_WRITE, MAP_SHARED, window->shmid, 0);
if (mem == ((int*) -1))
if (mem == MAP_FAILED)
{
DEBUG_X11("xf_CreateDesktopWindow: failed to assign pointer to the memory address - shmat()\n");
}

28
client/common/client.c
View File

@ -213,13 +213,20 @@ int freerdp_client_settings_parse_command_line(rdpSettings* settings, int argc,
int freerdp_client_settings_parse_connection_file(rdpSettings* settings, const char* filename)
{
rdpFile* file;
int ret = -1;
file = freerdp_client_rdp_file_new();
freerdp_client_parse_rdp_file(file, filename);
freerdp_client_populate_settings_from_rdp_file(file, settings);
freerdp_client_rdp_file_free(file);
if (!file)
return -1;
if (!freerdp_client_parse_rdp_file(file, filename))
goto out;
if (!freerdp_client_populate_settings_from_rdp_file(file, settings))
goto out;
return 0;
ret = 0;
out:
freerdp_client_rdp_file_free(file);
return ret;
}
int freerdp_client_settings_parse_connection_file_buffer(rdpSettings* settings, const BYTE* buffer, size_t size)
@ -228,6 +235,8 @@ int freerdp_client_settings_parse_connection_file_buffer(rdpSettings* settings,
int status = -1;
file = freerdp_client_rdp_file_new();
if (!file)
return -1;
if (freerdp_client_parse_rdp_file_buffer(file, buffer, size)
&& freerdp_client_populate_settings_from_rdp_file(file, settings))
@ -243,18 +252,23 @@ int freerdp_client_settings_parse_connection_file_buffer(rdpSettings* settings,
int freerdp_client_settings_write_connection_file(const rdpSettings* settings, const char* filename, BOOL unicode)
{
rdpFile* file;
int ret = -1;
file = freerdp_client_rdp_file_new();
if (!file)
return -1;
if (!freerdp_client_populate_rdp_file_from_settings(file, settings))
return -1;
goto out;
if (!freerdp_client_write_rdp_file(file, filename, unicode))
return -1;
goto out;
ret = 0;
out:
freerdp_client_rdp_file_free(file);
return 0;
return ret;
}
int freerdp_client_settings_parse_assistance_file(rdpSettings* settings, const char* filename)

379
client/common/cmdline.c
View File

@ -91,10 +91,10 @@ COMMAND_LINE_ARGUMENT_A args[] =
{ "compression-level", COMMAND_LINE_VALUE_REQUIRED, "<level>", NULL, NULL, -1, NULL, "Compression level (0,1,2)" },
{ "shell", COMMAND_LINE_VALUE_REQUIRED, NULL, NULL, NULL, -1, NULL, "Alternate shell" },
{ "shell-dir", COMMAND_LINE_VALUE_REQUIRED, NULL, NULL, NULL, -1, NULL, "Shell working directory" },
{ "sound", COMMAND_LINE_VALUE_OPTIONAL, NULL, NULL, NULL, -1, "audio", "Audio output (sound)" },
{ "microphone", COMMAND_LINE_VALUE_OPTIONAL, NULL, NULL, NULL, -1, "mic", "Audio input (microphone)" },
{ "sound", COMMAND_LINE_VALUE_OPTIONAL, "[sys][dev][format][rate][channel][latency][quality]", NULL, NULL, -1, "audio", "Audio output (sound)" },
{ "microphone", COMMAND_LINE_VALUE_OPTIONAL, "[sys][dev][format][rate][channel]", NULL, NULL, -1, "mic", "Audio input (microphone)" },
{ "audio-mode", COMMAND_LINE_VALUE_REQUIRED, NULL, NULL, NULL, -1, NULL, "Audio output mode" },
{ "multimedia", COMMAND_LINE_VALUE_OPTIONAL, NULL, NULL, NULL, -1, "mmr", "Redirect multimedia (video)" },
{ "multimedia", COMMAND_LINE_VALUE_OPTIONAL, "[sys][dev][decoder]", NULL, NULL, -1, "mmr", "Redirect multimedia (video)" },
{ "network", COMMAND_LINE_VALUE_REQUIRED, NULL, NULL, NULL, -1, NULL, "Network connection type" },
{ "drive", COMMAND_LINE_VALUE_REQUIRED, NULL, NULL, NULL, -1, NULL, "Redirect drive" },
{ "drives", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueFalse, NULL, -1, NULL, "Redirect all drives" },
@ -104,7 +104,7 @@ COMMAND_LINE_ARGUMENT_A args[] =
{ "parallel", COMMAND_LINE_VALUE_OPTIONAL, NULL, NULL, NULL, -1, NULL, "Redirect parallel device" },
{ "smartcard", COMMAND_LINE_VALUE_OPTIONAL, NULL, NULL, NULL, -1, NULL, "Redirect smartcard device" },
{ "printer", COMMAND_LINE_VALUE_OPTIONAL, NULL, NULL, NULL, -1, NULL, "Redirect printer device" },
{ "usb", COMMAND_LINE_VALUE_REQUIRED, NULL, NULL, NULL, -1, NULL, "Redirect USB device" },
{ "usb", COMMAND_LINE_VALUE_REQUIRED, "[dbg][dev][id|addr][auto]", NULL, NULL, -1, NULL, "Redirect USB device" },
{ "multitouch", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueFalse, NULL, -1, NULL, "Redirect multitouch input" },
{ "gestures", COMMAND_LINE_VALUE_BOOL, NULL, BoolValueFalse, NULL, -1, NULL, "Consume multitouch input locally" },
{ "echo", COMMAND_LINE_VALUE_FLAG, NULL, NULL, NULL, -1, "echo", "Echo channel" },
@ -216,6 +216,8 @@ int freerdp_client_print_command_line_help(int argc, char** argv)
{
length = (int)(strlen(arg->Name) + strlen(arg->Format) + 2);
str = (char*) calloc(length + 1UL, sizeof(char));
if (!str)
return -1;
sprintf_s(str, length + 1, "%s:%s", arg->Name, arg->Format);
printf("%-20s", str);
free(str);
@ -231,6 +233,8 @@ int freerdp_client_print_command_line_help(int argc, char** argv)
{
length = (int) strlen(arg->Name) + 32;
str = (char*) calloc(length + 1UL, sizeof(char));
if (!str)
return -1;
sprintf_s(str, length + 1, "%s (default:%s)", arg->Name,
arg->Default ? "on" : "off");
@ -264,10 +268,13 @@ int freerdp_client_print_command_line_help(int argc, char** argv)
printf("Printer Redirection: /printer:<device>,<driver>\n");
printf("\n");
printf("Audio Output Redirection: /sound:sys:oss,dev:1,format:1\n");
printf("Audio Output Redirection: /sound:sys:alsa\n");
printf("Audio Input Redirection: /microphone:sys:oss,dev:1,format:1\n");
printf("Audio Input Redirection: /microphone:sys:alsa\n");
printf("\n");
printf("Multimedia Redirection: /multimedia:sys:oss,dev:/dev/dsp1,decoder:ffmpeg\n");
printf("Multimedia Redirection: /multimedia:sys:alsa\n");
printf("USB Device Redirection: /usb:id,dev:054c:0268\n");
printf("\n");
@ -292,7 +299,8 @@ int freerdp_client_command_line_pre_filter(void* context, int index, int argc, L
if (_stricmp(&(argv[index])[length - 4], ".rdp") == 0)
{
settings = (rdpSettings*) context;
settings->ConnectionFile = _strdup(argv[index]);
if (!(settings->ConnectionFile = _strdup(argv[index])))
return COMMAND_LINE_ERROR_MEMORY;
return 1;
}
@ -303,7 +311,8 @@ int freerdp_client_command_line_pre_filter(void* context, int index, int argc, L
if (_stricmp(&(argv[index])[length - 13], ".msrcIncident") == 0)
{
settings = (rdpSettings*) context;
settings->AssistanceFile = _strdup(argv[index]);
if (!(settings->AssistanceFile = _strdup(argv[index])))
return COMMAND_LINE_ERROR_MEMORY;
return 1;
}
@ -332,12 +341,31 @@ int freerdp_client_add_device_channel(rdpSettings* settings, int count, char** p
drive->Type = RDPDR_DTYP_FILESYSTEM;
if (count > 1)
drive->Name = _strdup(params[1]);
{
if (!(drive->Name = _strdup(params[1])))
{
free(drive);
return -1;
}
}
if (count > 2)
drive->Path = _strdup(params[2]);
{
if (!(drive->Path = _strdup(params[2])))
{
free(drive->Name);
free(drive);
return -1;
}
}
freerdp_device_collection_add(settings, (RDPDR_DEVICE*) drive);
if (!freerdp_device_collection_add(settings, (RDPDR_DEVICE*) drive))
{
free(drive->Path);
free(drive->Name);
free(drive);
return -1;
}
return 1;
}
@ -361,12 +389,33 @@ int freerdp_client_add_device_channel(rdpSettings* settings, int count, char** p
printer->Type = RDPDR_DTYP_PRINT;
if (count > 1)
printer->Name = _strdup(params[1]);
{
if (!(printer->Name = _strdup(params[1])))
{
free(printer);
return -1;
}
}
if (count > 2)
printer->DriverName = _strdup(params[2]);
{
if (!(printer->DriverName = _strdup(params[2])))
{
free(printer->Name);
free(printer);
return -1;
}
}
if (!freerdp_device_collection_add(settings, (RDPDR_DEVICE*) printer))
{
free(printer->DriverName);
free(printer->Name);
free(printer);
return -1;
}
freerdp_device_collection_add(settings, (RDPDR_DEVICE*) printer);
}
return 1;
@ -391,12 +440,30 @@ int freerdp_client_add_device_channel(rdpSettings* settings, int count, char** p
smartcard->Type = RDPDR_DTYP_SMARTCARD;
if (count > 1)
smartcard->Name = _strdup(params[1]);
{
if (!(smartcard->Name = _strdup(params[1])))
{
free(smartcard);
return -1;
}
}
if (count > 2)
smartcard->Path = _strdup(params[2]);
freerdp_device_collection_add(settings, (RDPDR_DEVICE*) smartcard);
{
if (!(smartcard->Path = _strdup(params[2])))
{
free(smartcard->Name);
free(smartcard);
return -1;
}
}
if (!freerdp_device_collection_add(settings, (RDPDR_DEVICE*) smartcard))
{
free(smartcard->Path);
free(smartcard->Name);
free(smartcard);
return -1;
}
}
return 1;
@ -419,18 +486,56 @@ int freerdp_client_add_device_channel(rdpSettings* settings, int count, char** p
serial->Type = RDPDR_DTYP_SERIAL;
if (count > 1)
serial->Name = _strdup(params[1]);
{
if (!(serial->Name = _strdup(params[1])))
{
free(serial);
return -1;
}
}
if (count > 2)
serial->Path = _strdup(params[2]);
{
if (!(serial->Path = _strdup(params[2])))
{
free(serial->Name);
free(serial);
return -1;
}
}
if (count > 3)
serial->Driver = _strdup(params[3]);
{
if (!(serial->Driver = _strdup(params[3])))
{
free(serial->Path);
free(serial->Name);
free(serial);
return -1;
}
}
if (count > 4)
serial->Permissive = _strdup(params[4]);
{
if (!(serial->Permissive = _strdup(params[4])))
{
free(serial->Driver);
free(serial->Path);
free(serial->Name);
free(serial);
return -1;
}
}
freerdp_device_collection_add(settings, (RDPDR_DEVICE*) serial);
if (!freerdp_device_collection_add(settings, (RDPDR_DEVICE*) serial))
{
free(serial->Permissive);
free(serial->Driver);
free(serial->Path);
free(serial->Name);
free(serial);
return -1;
}
return 1;
}
@ -452,12 +557,31 @@ int freerdp_client_add_device_channel(rdpSettings* settings, int count, char** p
parallel->Type = RDPDR_DTYP_PARALLEL;
if (count > 1)
parallel->Name = _strdup(params[1]);
{
if (!(parallel->Name = _strdup(params[1])))
{
free(parallel);
return -1;
}
}
if (count > 2)
parallel->Path = _strdup(params[2]);
{
if (!(parallel->Path = _strdup(params[2])))
{
free(parallel->Name);
free(parallel);
return -1;
}
}
freerdp_device_collection_add(settings, (RDPDR_DEVICE*) parallel);
if (!freerdp_device_collection_add(settings, (RDPDR_DEVICE*) parallel))
{
free(parallel->Path);
free(parallel->Name);
free(parallel);
return -1;
}
return 1;
}
@ -470,17 +594,40 @@ int freerdp_client_add_static_channel(rdpSettings* settings, int count, char** p
int index;
ADDIN_ARGV* args;
args = (ADDIN_ARGV*) malloc(sizeof(ADDIN_ARGV));
args = (ADDIN_ARGV*) calloc(1, sizeof(ADDIN_ARGV));
if (!args)
return -1;
args->argc = count;
args->argv = (char**) calloc(args->argc, sizeof(char*));
if (!args->argv)
goto error_argv;
for (index = 0; index < args->argc; index++)
{
args->argv[index] = _strdup(params[index]);
if (!args->argv[index])
{
for (--index; index >= 0; --index)
free(args->argv[index]);
freerdp_static_channel_collection_add(settings, args);
goto error_argv_strdup;
}
}
if (!freerdp_static_channel_collection_add(settings, args))
goto error_argv_index;
return 0;
error_argv_index:
for (index = 0; index < args->argc; index++)
free(args->argv[index]);
error_argv_strdup:
free(args->argv);
error_argv:
free(args);
return -1;
}
int freerdp_client_add_dynamic_channel(rdpSettings* settings, int count, char** params)
@ -489,16 +636,39 @@ int freerdp_client_add_dynamic_channel(rdpSettings* settings, int count, char**
ADDIN_ARGV* args;
args = (ADDIN_ARGV*) malloc(sizeof(ADDIN_ARGV));
if (!args)
return -1;
args->argc = count;
args->argv = (char**) calloc(args->argc, sizeof(char*));
if (!args->argv)
goto error_argv;
for (index = 0; index < args->argc; index++)
{
args->argv[index] = _strdup(params[index]);
if (!args->argv[index])
{
for (--index; index >= 0; --index)
free(args->argv[index]);
freerdp_dynamic_channel_collection_add(settings, args);
goto error_argv_strdup;
}
}
if (!freerdp_dynamic_channel_collection_add(settings, args))
goto error_argv_index;
return 0;
error_argv_index:
for (index = 0; index < args->argc; index++)
free(args->argv[index]);
error_argv_strdup:
free(args->argv);
error_argv:
free(args);
return -1;
}
static char** freerdp_command_line_parse_comma_separated_values(char* list, int* count)
@ -522,6 +692,8 @@ static char** freerdp_command_line_parse_comma_separated_values(char* list, int*
nArgs = nCommas + 1;
p = (char**) calloc((nArgs + 1UL), sizeof(char*));
if (!p)
return NULL;
str = (char*) list;
@ -562,6 +734,7 @@ static char** freerdp_command_line_parse_comma_separated_values_offset(char* lis
int freerdp_client_command_line_post_filter(void* context, COMMAND_LINE_ARGUMENT_A* arg)
{
rdpSettings* settings = (rdpSettings*) context;
int status = 0;
CommandLineSwitchStart(arg)
@ -586,7 +759,7 @@ int freerdp_client_command_line_post_filter(void* context, COMMAND_LINE_ARGUMENT
p = freerdp_command_line_parse_comma_separated_values(arg->Value, &count);
freerdp_client_add_static_channel(settings, count, p);
status = freerdp_client_add_static_channel(settings, count, p);
free(p);
}
@ -712,7 +885,7 @@ int freerdp_client_command_line_post_filter(void* context, COMMAND_LINE_ARGUMENT
p = freerdp_command_line_parse_comma_separated_values_offset(arg->Value, &count);
p[0] = "rdpsnd";
freerdp_client_add_static_channel(settings, count, p);
status = freerdp_client_add_static_channel(settings, count, p);
free(p);
}
@ -724,7 +897,7 @@ int freerdp_client_command_line_post_filter(void* context, COMMAND_LINE_ARGUMENT
count = 1;
p[0] = "rdpsnd";
freerdp_client_add_static_channel(settings, count, p);
status = freerdp_client_add_static_channel(settings, count, p);
}
}
CommandLineSwitchCase(arg, "microphone")
@ -789,17 +962,15 @@ int freerdp_client_command_line_post_filter(void* context, COMMAND_LINE_ARGUMENT
CommandLineSwitchEnd(arg)
return 0;
return status;
}
int freerdp_parse_username(char* username, char** user, char** domain)
{
char* p;
char* u;
int length = 0;
p = strchr(username, '\\');
u = strrchr(username, '@');
*user = NULL;
*domain = NULL;
@ -832,10 +1003,6 @@ int freerdp_parse_username(char* username, char** user, char** domain)
if (!*user)
return -1;
/* If only username is given, prefix that with 'TARGET'
* otherwise set the domain to an empty string.
* NOTE: Domain NULL will result in undefined behavior.
*/
*domain = _strdup("\0");
if (!*domain)
@ -963,6 +1130,8 @@ int freerdp_map_keyboard_layout_name_to_id(char* name)
RDP_KEYBOARD_LAYOUT* layouts;
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_STANDARD);
if (!layouts)
return -1;
for (i = 0; layouts[i].code; i++)
{
@ -976,6 +1145,8 @@ int freerdp_map_keyboard_layout_name_to_id(char* name)
return id;
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_VARIANT);
if (!layouts)
return -1;
for (i = 0; layouts[i].code; i++)
{
@ -989,6 +1160,8 @@ int freerdp_map_keyboard_layout_name_to_id(char* name)
return id;
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_IME);
if (!layouts)
return -1;
for (i = 0; layouts[i].code; i++)
{
@ -1187,18 +1360,21 @@ int freerdp_client_settings_command_line_status_print(rdpSettings* settings, int
RDP_KEYBOARD_LAYOUT* layouts;
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_STANDARD);
//if (!layouts) /* FIXME*/
printf("\nKeyboard Layouts\n");
for (i = 0; layouts[i].code; i++)
printf("0x%08X\t%s\n", (int) layouts[i].code, layouts[i].name);
free(layouts);
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_VARIANT);
//if (!layouts) /* FIXME*/
printf("\nKeyboard Layout Variants\n");
for (i = 0; layouts[i].code; i++)
printf("0x%08X\t%s\n", (int) layouts[i].code, layouts[i].name);
free(layouts);
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_IME);
//if (!layouts) /* FIXME*/
printf("\nKeyboard Input Method Editors (IMEs)\n");
for (i = 0; layouts[i].code; i++)
printf("0x%08X\t%s\n", (int) layouts[i].code, layouts[i].name);
@ -1282,13 +1458,16 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
{
length = (int) (p - arg->Value);
settings->ServerPort = atoi(&p[1]);
settings->ServerHostname = (char*) calloc(length + 1UL, sizeof(char));
if (!(settings->ServerHostname = (char*) calloc(length + 1UL, sizeof(char))))
return COMMAND_LINE_ERROR_MEMORY;
strncpy(settings->ServerHostname, arg->Value, length);
settings->ServerHostname[length] = '\0';
}
else
{
settings->ServerHostname = _strdup(arg->Value);
if (!(settings->ServerHostname = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
}
else /* ipv6 */
@ -1299,7 +1478,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
continue;
length = p2 - p;
settings->ServerHostname = (char*) calloc(length, sizeof(char));
if (!(settings->ServerHostname = (char*) calloc(length, sizeof(char))))
return COMMAND_LINE_ERROR;
strncpy(settings->ServerHostname, p+1, length-1);
if (*(p2 + 1) == ':')
{
@ -1310,7 +1490,9 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "spn-class")
{
settings->AuthenticationServiceClass = _strdup(arg->Value);
if (!(settings->AuthenticationServiceClass = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "credentials-delegation")
{
@ -1324,7 +1506,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
if (arg->Flags & COMMAND_LINE_VALUE_PRESENT)
{
settings->SendPreconnectionPdu = TRUE;
settings->PreconnectionBlob = _strdup(arg->Value);
if (!(settings->PreconnectionBlob = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
}
CommandLineSwitchCase(arg, "w")
@ -1337,7 +1520,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "size")
{
str = _strdup(arg->Value);
if (!(str = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
p = strchr(str, 'x');
@ -1391,6 +1575,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
int count = 0;
p = freerdp_command_line_parse_comma_separated_values(arg->Value, &count);
if (!p)
return COMMAND_LINE_ERROR_MEMORY;
if (count > 16)
count = 16;
@ -1411,7 +1597,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "t")
{
settings->WindowTitle = _strdup(arg->Value);
if (!(settings->WindowTitle = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "decorations")
{
@ -1423,7 +1610,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
if (arg->Value)
{
str = _strdup(arg->Value);
if (!(str = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
if ((p = strchr(str, 'x')))
{
*p = '\0';
@ -1450,11 +1638,13 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
{
settings->ConsoleSession = TRUE;
settings->RestrictedAdminModeRequired = TRUE;
settings->PasswordHash = _strdup(arg->Value);
if (!(settings->PasswordHash = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "client-hostname")
{
settings->ClientHostname = _strdup(arg->Value);
if (!(settings->ClientHostname = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "kbd")
{
@ -1469,11 +1659,15 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
if (id == 0)
{
id = (unsigned long int) freerdp_map_keyboard_layout_name_to_id(arg->Value);
if (!id)
if (id == -1)
WLog_ERR(TAG, "A problem occured while mapping the layout name to id");
else if (id == 0)
{
WLog_ERR(TAG, "Could not identify keyboard layout: %s", arg->Value);
WLog_ERR(TAG, "Use /kbd-list to list available layouts");
}
if (id <= 0)
return COMMAND_LINE_STATUS_PRINT;
}
settings->KeyboardLayout = (UINT32) id;
@ -1496,11 +1690,13 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "d")
{
settings->Domain = _strdup(arg->Value);
if (!(settings->Domain = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "p")
{
settings->Password = _strdup(arg->Value);
if (!(settings->Password = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "g")
{
@ -1512,18 +1708,21 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
{
length = (int) (p - arg->Value);
settings->GatewayPort = atoi(&p[1]);
settings->GatewayHostname = (char*) calloc(length + 1UL, sizeof(char));
if (!(settings->GatewayHostname = (char*) calloc(length + 1UL, sizeof(char))))
return COMMAND_LINE_ERROR_MEMORY;
strncpy(settings->GatewayHostname, arg->Value, length);
settings->GatewayHostname[length] = '\0';
}
else
{
settings->GatewayHostname = _strdup(arg->Value);
if (!(settings->GatewayHostname = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
}
else
{
settings->GatewayHostname = _strdup(settings->ServerHostname);
if (!(settings->GatewayHostname = _strdup(settings->ServerHostname)))
return COMMAND_LINE_ERROR_MEMORY;
}
settings->GatewayEnabled = TRUE;
@ -1533,17 +1732,21 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "gu")
{
gwUser = _strdup(arg->Value);
if (!(gwUser = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
settings->GatewayUseSameCredentials = FALSE;
}
CommandLineSwitchCase(arg, "gd")
{
settings->GatewayDomain = _strdup(arg->Value);
if (!(settings->GatewayDomain = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
settings->GatewayUseSameCredentials = FALSE;
}
CommandLineSwitchCase(arg, "gp")
{
settings->GatewayPassword = _strdup(arg->Value);
if (!(settings->GatewayPassword = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
settings->GatewayUseSameCredentials = FALSE;
}
CommandLineSwitchCase(arg, "gt")
@ -1587,7 +1790,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "app")
{
settings->RemoteApplicationProgram = _strdup(arg->Value);
if (!(settings->RemoteApplicationProgram = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
settings->RemoteApplicationMode = TRUE;
settings->RemoteAppLanguageBarSupported = TRUE;
@ -1597,28 +1801,35 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "load-balance-info")
{
settings->LoadBalanceInfo = (BYTE*) _strdup(arg->Value);
if (!(settings->LoadBalanceInfo = (BYTE*) _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
settings->LoadBalanceInfoLength = (UINT32) strlen((char*) settings->LoadBalanceInfo);
}
CommandLineSwitchCase(arg, "app-name")
{
settings->RemoteApplicationName = _strdup(arg->Value);
if (!(settings->RemoteApplicationName = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "app-icon")
{
settings->RemoteApplicationIcon = _strdup(arg->Value);
if (!(settings->RemoteApplicationIcon = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "app-cmd")
{
settings->RemoteApplicationCmdLine = _strdup(arg->Value);
if (!(settings->RemoteApplicationCmdLine = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "app-file")
{
settings->RemoteApplicationFile = _strdup(arg->Value);
if (!(settings->RemoteApplicationFile = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "app-guid")
{
settings->RemoteApplicationGuid = _strdup(arg->Value);
if (!(settings->RemoteApplicationGuid = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "compression")
{
@ -1642,11 +1853,13 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "shell")
{
settings->AlternateShell = _strdup(arg->Value);
if (!(settings->AlternateShell = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "shell-dir")
{
settings->ShellWorkingDirectory = _strdup(arg->Value);
if (!(settings->ShellWorkingDirectory = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "audio-mode")
{
@ -1798,7 +2011,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
CommandLineSwitchCase(arg, "pcb")
{
settings->SendPreconnectionPdu = TRUE;
settings->PreconnectionBlob = _strdup(arg->Value);
if (!(settings->PreconnectionBlob = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "pcid")
{
@ -1888,20 +2102,24 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
{
if (strcmp(arg->Value, "netmon") == 0)
{
settings->AllowedTlsCiphers = _strdup("ALL:!ECDH");
if (!(settings->AllowedTlsCiphers = _strdup("ALL:!ECDH")))
return COMMAND_LINE_ERROR_MEMORY;
}
else if (strcmp(arg->Value, "ma") == 0)
{
settings->AllowedTlsCiphers = _strdup("AES128-SHA");
if (!(settings->AllowedTlsCiphers = _strdup("AES128-SHA")))
return COMMAND_LINE_ERROR_MEMORY;
}
else
{
settings->AllowedTlsCiphers = _strdup(arg->Value);
if (!(settings->AllowedTlsCiphers = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
}
CommandLineSwitchCase(arg, "cert-name")
{
settings->CertificateName = _strdup(arg->Value);
if (!(settings->CertificateName = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "cert-ignore")
{
@ -1990,11 +2208,13 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
}
CommandLineSwitchCase(arg, "wm-class")
{
settings->WmClass = _strdup(arg->Value);
if (!(settings->WmClass = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "play-rfx")
{
settings->PlayRemoteFxFile = _strdup(arg->Value);
if (!(settings->PlayRemoteFxFile = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
settings->PlayRemoteFx = TRUE;
}
CommandLineSwitchCase(arg, "auth-only")
@ -2028,7 +2248,8 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
CommandLineSwitchCase(arg, "assistance")
{
settings->RemoteAssistanceMode = TRUE;
settings->RemoteAssistancePassword = _strdup(arg->Value);
if (!(settings->RemoteAssistancePassword = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchDefault(arg)
{
@ -2040,17 +2261,23 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
if (!settings->Domain && user)
{
freerdp_parse_username(user, &settings->Username, &settings->Domain);
int ret;
ret = freerdp_parse_username(user, &settings->Username, &settings->Domain);
free(user);
if (ret != 0 )
return COMMAND_LINE_ERROR;
}
else
settings->Username = user;
if (!settings->GatewayDomain && gwUser)
{
freerdp_parse_username(gwUser, &settings->GatewayUsername,
int ret;
ret = freerdp_parse_username(gwUser, &settings->GatewayUsername,
&settings->GatewayDomain);
free(gwUser);
if (ret != 0)
return COMMAND_LINE_ERROR;
}
else
settings->GatewayUsername = gwUser;

85
client/common/compatibility.c
View File

@ -89,7 +89,7 @@ COMMAND_LINE_ARGUMENT_A old_args[] =
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL }
};
void freerdp_client_old_parse_hostname(char* str, char** ServerHostname, UINT32* ServerPort)
BOOL freerdp_client_old_parse_hostname(char* str, char** ServerHostname, UINT32* ServerPort)
{
char* p;
@ -97,7 +97,8 @@ void freerdp_client_old_parse_hostname(char* str, char** ServerHostname, UINT32*
&& (p[1] == 0 || (p[1] == ':' && !strchr(p + 2, ':'))))
{
/* Either "[...]" or "[...]:..." with at most one : after the brackets */
*ServerHostname = _strdup(str + 1);
if (!(*ServerHostname = _strdup(str + 1)))
return FALSE;
if ((p = strchr((char*) *ServerHostname, ']')))
{
@ -110,7 +111,8 @@ void freerdp_client_old_parse_hostname(char* str, char** ServerHostname, UINT32*
else
{
/* Port number is cut off and used if exactly one : in the string */
*ServerHostname = _strdup(str);
if (!(*ServerHostname = _strdup(str)))
return FALSE;
if ((p = strchr((char*) *ServerHostname, ':')) && !strchr(p + 1, ':'))
{
@ -118,6 +120,7 @@ void freerdp_client_old_parse_hostname(char* str, char** ServerHostname, UINT32*
*ServerPort = atoi(p + 1);
}
}
return TRUE;
}
int freerdp_client_old_process_plugin(rdpSettings* settings, ADDIN_ARGV* args)
@ -183,7 +186,8 @@ int freerdp_client_old_process_plugin(rdpSettings* settings, ADDIN_ARGV* args)
return 1;
args_handled++;
settings->RemoteApplicationProgram = _strdup(args->argv[1]);
if (!(settings->RemoteApplicationProgram = _strdup(args->argv[1])))
return -1;
}
else
{
@ -211,8 +215,9 @@ int freerdp_client_old_command_line_pre_filter(void* context, int index, int arg
return -1;
}
freerdp_client_old_parse_hostname((char*) argv[index],
&settings->ServerHostname, &settings->ServerPort);
if (!freerdp_client_old_parse_hostname((char*) argv[index],
&settings->ServerHostname, &settings->ServerPort))
return -1;
return 2;
}
@ -240,7 +245,14 @@ int freerdp_client_old_command_line_pre_filter(void* context, int index, int arg
return -1;
args = (ADDIN_ARGV*) malloc(sizeof(ADDIN_ARGV));
if (!args)
return -1;
args->argv = (char**) calloc(argc, sizeof(char*));
if (!args->argv)
{
free(args);
return -1;
}
args->argc = 1;
if ((index < argc - 1) && strcmp("--data", argv[index + 1]) == 0)
@ -250,9 +262,14 @@ int freerdp_client_old_command_line_pre_filter(void* context, int index, int arg
while ((index < argc) && (strcmp("--", argv[index]) != 0))
{
args_handled ++;
args_handled++;
args->argc = 1;
args->argv[0] = _strdup(argv[t]);
if (!(args->argv[0] = _strdup(argv[t])))
{
free(args->argv);
free(args);
return -1;
}
for (j = 0, p = (char*) argv[index]; (j < 4) && (p != NULL); j++)
{
@ -277,14 +294,31 @@ int freerdp_client_old_command_line_pre_filter(void* context, int index, int arg
if (p != NULL)
{
length = (int) (p - a);
args->argv[j + 1] = (char*) malloc(length + 1);
if (!(args->argv[j + 1] = (char*) malloc(length + 1)))
{
for (; j >= 0; --j)
free(args->argv[j]);
free(args->argv);
free(args);
return -1;
}
CopyMemory(args->argv[j + 1], a, length);
args->argv[j + 1][length] = '\0';
p++;
}
else
{
args->argv[j + 1] = _strdup(a);
if (!(args->argv[j + 1] = _strdup(a)))
{
for (; j >= 0; --j)
free(args->argv[j]);
free(args->argv);
free(args);
return -1;
}
}
args->argc++;
@ -306,7 +340,12 @@ int freerdp_client_old_command_line_pre_filter(void* context, int index, int arg
{
if (settings)
{
args->argv[0] = _strdup(argv[t]);
if (!(args->argv[0] = _strdup(argv[t])))
{
free(args->argv);
free(args);
return -1;
}
args_handled = freerdp_client_old_process_plugin(settings, args);
free (args->argv[0]);
}
@ -459,8 +498,9 @@ int freerdp_client_parse_old_command_line_arguments(int argc, char** argv, rdpSe
}
CommandLineSwitchCase(arg, "c")
{
settings->ShellWorkingDirectory = _strdup(arg->Value);
WLog_WARN(TAG, "-c %s -> /shell-dir:%s", arg->Value, arg->Value);
if (!(settings->ShellWorkingDirectory = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
}
CommandLineSwitchCase(arg, "D")
{
@ -469,12 +509,14 @@ int freerdp_client_parse_old_command_line_arguments(int argc, char** argv, rdpSe
}
CommandLineSwitchCase(arg, "T")
{
settings->WindowTitle = _strdup(arg->Value);
if (!(settings->WindowTitle = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
WLog_WARN(TAG, "-T %s -> /title:%s", arg->Value, arg->Value);
}
CommandLineSwitchCase(arg, "d")
{
settings->Domain = _strdup(arg->Value);
if (!(settings->Domain = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
WLog_WARN(TAG, "-d %s -> /d:%s", arg->Value, arg->Value);
}
CommandLineSwitchCase(arg, "f")
@ -484,7 +526,8 @@ int freerdp_client_parse_old_command_line_arguments(int argc, char** argv, rdpSe
}
CommandLineSwitchCase(arg, "g")
{
str = _strdup(arg->Value);
if (!(str = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
p = strchr(str, 'x');
@ -511,7 +554,8 @@ int freerdp_client_parse_old_command_line_arguments(int argc, char** argv, rdpSe
}
CommandLineSwitchCase(arg, "n")
{
settings->ClientHostname = _strdup(arg->Value);
if (!(settings->ClientHostname = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
WLog_WARN(TAG, "-n -> /client-hostname:%s", arg->Value);
}
CommandLineSwitchCase(arg, "o")
@ -521,14 +565,16 @@ int freerdp_client_parse_old_command_line_arguments(int argc, char** argv, rdpSe
}
CommandLineSwitchCase(arg, "p")
{
settings->Password = _strdup(arg->Value);
if (!(settings->Password = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
WLog_WARN(TAG, "-p ****** -> /p:******");
/* Hide the value from 'ps'. */
FillMemory(arg->Value, strlen(arg->Value), '*');
}
CommandLineSwitchCase(arg, "s")
{
settings->AlternateShell = _strdup(arg->Value);
if (!(settings->AlternateShell = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
WLog_WARN(TAG, "-s %s -> /shell:%s", arg->Value, arg->Value);
}
CommandLineSwitchCase(arg, "t")
@ -538,7 +584,8 @@ int freerdp_client_parse_old_command_line_arguments(int argc, char** argv, rdpSe
}
CommandLineSwitchCase(arg, "u")
{
settings->Username = _strdup(arg->Value);
if (!(settings->Username = _strdup(arg->Value)))
return COMMAND_LINE_ERROR_MEMORY;
WLog_WARN(TAG, "-u %s -> /u:%s", arg->Value, arg->Value);
}
CommandLineSwitchCase(arg, "x")

348
client/common/file.c
View File

@ -52,9 +52,16 @@ static WCHAR CR_LF_STR_W[] = { '\r', '\n', '\0' };
#define INVALID_INTEGER_VALUE 0xFFFFFFFF
BOOL freerdp_client_rdp_file_set_integer(rdpFile* file, const char* name, int value, int index)
/*
* Set an integer in a rdpFile
*
* @return 0 if a standard name was set, 1 for a non-standard name, -1 on error
*
*/
static int freerdp_client_rdp_file_set_integer(rdpFile* file, const char* name, int value, int index)
{
BOOL bStandard = TRUE;
int standard = 1;
#ifdef DEBUG_CLIENT_FILE
WLog_DBG(TAG, "%s:i:%d", name, value);
@ -189,122 +196,161 @@ BOOL freerdp_client_rdp_file_set_integer(rdpFile* file, const char* name, int va
else if (_stricmp(name, "rdgiskdcproxy") == 0)
file->RdgIsKdcProxy = value;
else
bStandard = FALSE;
standard = 1;
if (index >= 0)
{
file->lines[index].name = _strdup(name);
if (!file->lines[index].name)
return -1;
file->lines[index].iValue = (DWORD) value;
file->lines[index].flags = RDP_FILE_LINE_FLAG_FORMATTED;
file->lines[index].flags |= RDP_FILE_LINE_FLAG_TYPE_INTEGER;
if (bStandard)
if (standard)
file->lines[index].flags |= RDP_FILE_LINE_FLAG_STANDARD;
file->lines[index].valueLength = 0;
}
return bStandard;
return standard;
}
void freerdp_client_parse_rdp_file_integer_unicode(rdpFile* file, WCHAR* name, WCHAR* value, int index)
static BOOL freerdp_client_parse_rdp_file_integer_unicode(rdpFile* file, WCHAR* name, WCHAR* value, int index)
{
int length;
int ivalue;
char* nameA;
char* valueA;
BOOL ret = TRUE;
length = (int) _wcslen(name);
nameA = (char*) malloc(length + 1);
if (!nameA)
return FALSE;
WideCharToMultiByte(CP_UTF8, 0, name, length, nameA, length, NULL, NULL);
nameA[length] = '\0';
length = (int) _wcslen(value);
valueA = (char*) malloc(length + 1);
if (!valueA)
{
free(nameA);
return FALSE;
}
WideCharToMultiByte(CP_UTF8, 0, value, length, valueA, length, NULL, NULL);
valueA[length] = '\0';
ivalue = atoi(valueA);
freerdp_client_rdp_file_set_integer(file, nameA, ivalue, index);
if (freerdp_client_rdp_file_set_integer(file, nameA, ivalue, index) < 0)
ret = FALSE;
free(nameA);
free(valueA);
return ret;
}
void freerdp_client_parse_rdp_file_integer_ascii(rdpFile* file, const char* name, const char* value, int index)
static BOOL freerdp_client_parse_rdp_file_integer_ascii(rdpFile* file, const char* name, const char* value, int index)
{
int ivalue = atoi(value);
freerdp_client_rdp_file_set_integer(file, name, ivalue, index);
if (freerdp_client_rdp_file_set_integer(file, name, ivalue, index) < 0)
return FALSE;
return TRUE;
}
BOOL freerdp_client_rdp_file_set_string(rdpFile* file, const char* name, const char* value, int index)
/**
*
* @param file rdpFile
* @param name name of the string
* @param value value of the string to set
* @param index line index of the rdpFile
* @return 0 on success, 1 if the key wasn't found (not a standard key), -1 on error
*/
static int freerdp_client_rdp_file_set_string(rdpFile* file, const char* name, const char* value, int index)
{
BOOL bStandard = TRUE;
int standard = 0;
LPSTR *tmp = NULL;
#ifdef DEBUG_CLIENT_FILE
WLog_DBG(TAG, "%s:s:%s", name, value);
#endif
if (!file)
return -1;
if (_stricmp(name, "username") == 0)
file->Username = _strdup(value);
tmp = &file->Username;
else if (_stricmp(name, "domain") == 0)
file->Domain = _strdup(value);
tmp = &file->Domain;
else if (_stricmp(name, "full address") == 0)
file->FullAddress = _strdup(value);
tmp = &file->FullAddress;
else if (_stricmp(name, "alternate full address") == 0)
file->AlternateFullAddress = _strdup(value);
tmp = &file->AlternateFullAddress;
else if (_stricmp(name, "usbdevicestoredirect") == 0)
file->UsbDevicesToRedirect = _strdup(value);
tmp = &file->UsbDevicesToRedirect;
else if (_stricmp(name, "loadbalanceinfo") == 0)
file->LoadBalanceInfo = _strdup(value);
tmp = &file->LoadBalanceInfo;
else if (_stricmp(name, "remoteapplicationname") == 0)
file->RemoteApplicationName = _strdup(value);
tmp = &file->RemoteApplicationName;
else if (_stricmp(name, "remoteapplicationicon") == 0)
file->RemoteApplicationIcon = _strdup(value);
tmp = &file->RemoteApplicationIcon;
else if (_stricmp(name, "remoteapplicationprogram") == 0)
file->RemoteApplicationProgram = _strdup(value);
tmp = &file->RemoteApplicationProgram;
else if (_stricmp(name, "remoteapplicationfile") == 0)
file->RemoteApplicationFile = _strdup(value);
tmp = &file->RemoteApplicationFile;
else if (_stricmp(name, "remoteapplicationguid") == 0)
file->RemoteApplicationGuid = _strdup(value);
tmp = &file->RemoteApplicationGuid;
else if (_stricmp(name, "remoteapplicationcmdline") == 0)
file->RemoteApplicationCmdLine = _strdup(value);
tmp = &file->RemoteApplicationCmdLine;
else if (_stricmp(name, "alternate shell") == 0)
file->AlternateShell = _strdup(value);
tmp = &file->AlternateShell;
else if (_stricmp(name, "shell working directory") == 0)
file->ShellWorkingDirectory = _strdup(value);
tmp = &file->ShellWorkingDirectory;
else if (_stricmp(name, "gatewayhostname") == 0)
file->GatewayHostname = _strdup(value);
tmp = &file->GatewayHostname;
else if (_stricmp(name, "kdcproxyname") == 0)
file->KdcProxyName = _strdup(value);
tmp = &file->KdcProxyName;
else if (_stricmp(name, "drivestoredirect") == 0)
file->DrivesToRedirect = _strdup(value);
tmp = &file->DrivesToRedirect;
else if (_stricmp(name, "devicestoredirect") == 0)
file->DevicesToRedirect = _strdup(value);
tmp = &file->DevicesToRedirect;
else if (_stricmp(name, "winposstr") == 0)
file->WinPosStr = _strdup(value);
tmp = &file->WinPosStr;
else
bStandard = FALSE;
standard = 1;
if (tmp && !(*tmp = _strdup(value)))
return -1;
if (index >= 0)
{
if (!file->lines)
return -1;
file->lines[index].name = _strdup(name);
file->lines[index].sValue = _strdup(value);
if (!file->lines[index].name || !file->lines[index].sValue)
{
free(file->lines[index].name);
free(file->lines[index].sValue);
return -1;
}
file->lines[index].flags = RDP_FILE_LINE_FLAG_FORMATTED;
file->lines[index].flags |= RDP_FILE_LINE_FLAG_TYPE_STRING;
if (bStandard)
if (standard == 0)
file->lines[index].flags |= RDP_FILE_LINE_FLAG_STANDARD;
file->lines[index].valueLength = 0;
}
return bStandard;
return standard;
}
void freerdp_client_add_option(rdpFile* file, char* option)
static BOOL freerdp_client_add_option(rdpFile* file, char* option)
{
while ((file->argc + 1) > file->argSize)
{
@ -314,16 +360,19 @@ void freerdp_client_add_option(rdpFile* file, char* option)
new_size = file->argSize * 2;
new_argv = (char**) realloc(file->argv, new_size * sizeof(char*));
if (!new_argv)
return;
return FALSE;
file->argv = new_argv;
file->argSize = new_size;
}
file->argv[file->argc] = _strdup(option);
if (!file->argv[file->argc])
return FALSE;
(file->argc)++;
return TRUE;
}
int freerdp_client_parse_rdp_file_add_line(rdpFile* file, char* line, int index)
static int freerdp_client_parse_rdp_file_add_line(rdpFile* file, char* line, int index)
{
if (index < 0)
index = file->lineCount;
@ -343,72 +392,105 @@ int freerdp_client_parse_rdp_file_add_line(rdpFile* file, char* line, int index)
ZeroMemory(&(file->lines[file->lineCount]), sizeof(rdpFileLine));
file->lines[file->lineCount].text = _strdup(line);
if (!file->lines[file->lineCount].text)
return -1;
file->lines[file->lineCount].index = index;
(file->lineCount)++;
return index;
}
void freerdp_client_parse_rdp_file_add_line_unicode(rdpFile* file, WCHAR* line, int index)
static BOOL freerdp_client_parse_rdp_file_add_line_unicode(rdpFile* file, WCHAR* line, int index)
{
char* lineA = NULL;
BOOL ret = TRUE;
ConvertFromUnicode(CP_UTF8, 0, line, -1, &lineA, 0, NULL, NULL);
freerdp_client_parse_rdp_file_add_line(file, lineA, index);
if (!lineA)
return FALSE;
if (freerdp_client_parse_rdp_file_add_line(file, lineA, index) == -1)
ret = FALSE;
free(lineA);
return ret;
}
void freerdp_client_parse_rdp_file_add_line_ascii(rdpFile* file, char* line, int index)
static BOOL freerdp_client_parse_rdp_file_add_line_ascii(rdpFile* file, char* line, int index)
{
freerdp_client_parse_rdp_file_add_line(file, line, index);
if (freerdp_client_parse_rdp_file_add_line(file, line, index) == -1)
return FALSE;
return TRUE;
}
void freerdp_client_parse_rdp_file_string_unicode(rdpFile* file, WCHAR* name, WCHAR* value, int index)
static BOOL freerdp_client_parse_rdp_file_string_unicode(rdpFile* file, WCHAR* name, WCHAR* value, int index)
{
int length;
char* nameA;
char* valueA;
BOOL ret = TRUE;
length = (int) _wcslen(name);
nameA = (char*) malloc(length + 1);
if (!nameA)
return FALSE;
WideCharToMultiByte(CP_UTF8, 0, name, length, nameA, length, NULL, NULL);
nameA[length] = '\0';
length = (int) _wcslen(value);
valueA = (char*) malloc(length + 1);
if (!valueA)
{
free(nameA);
return FALSE;
}
WideCharToMultiByte(CP_UTF8, 0, value, length, valueA, length, NULL, NULL);
valueA[length] = '\0';
freerdp_client_rdp_file_set_string(file, nameA, valueA, index);
if (freerdp_client_rdp_file_set_string(file, nameA, valueA, index) == -1)
ret = FALSE;
free(nameA);
free(valueA);
return ret;
}
void freerdp_client_parse_rdp_file_string_ascii(rdpFile* file, char* name, char* value, int index)
static BOOL freerdp_client_parse_rdp_file_string_ascii(rdpFile* file, char* name, char* value, int index)
{
BOOL ret = TRUE;
char* valueA = _strdup(value);
freerdp_client_rdp_file_set_string(file, name, valueA, index);
if (!valueA)
return FALSE;
if (freerdp_client_rdp_file_set_string(file, name, valueA, index) == -1)
ret = FALSE;
free(valueA);
return ret;
}
void freerdp_client_parse_rdp_file_option_unicode(rdpFile* file, WCHAR* option, int index)
static BOOL freerdp_client_parse_rdp_file_option_unicode(rdpFile* file, WCHAR* option, int index)
{
char* optionA = NULL;
BOOL ret;
ConvertFromUnicode(CP_UTF8, 0, option, -1, &optionA, 0, NULL, NULL);
freerdp_client_add_option(file, optionA);
if (!optionA)
return FALSE;
ret = freerdp_client_add_option(file, optionA);
free(optionA);
return ret;
}
void freerdp_client_parse_rdp_file_option_ascii(rdpFile* file, char* option, int index)
static BOOL freerdp_client_parse_rdp_file_option_ascii(rdpFile* file, char* option, int index)
{
freerdp_client_add_option(file, option);
return freerdp_client_add_option(file, option);
}
BOOL freerdp_client_parse_rdp_file_buffer_ascii(rdpFile* file, const BYTE* buffer, size_t size)
static BOOL freerdp_client_parse_rdp_file_buffer_ascii(rdpFile* file, const BYTE* buffer, size_t size)
{
int index;
int length;
@ -431,11 +513,14 @@ BOOL freerdp_client_parse_rdp_file_buffer_ascii(rdpFile* file, const BYTE* buffe
beg = line;
end = &line[length - 1];
freerdp_client_parse_rdp_file_add_line_ascii(file, line, index);
if (!freerdp_client_parse_rdp_file_add_line_ascii(file, line, index))
return FALSE;
if (beg[0] == '/')
{
freerdp_client_parse_rdp_file_option_ascii(file, line, index);
if (!freerdp_client_parse_rdp_file_option_ascii(file, line, index))
return FALSE;
goto next_line; /* FreeRDP option */
}
@ -462,12 +547,14 @@ BOOL freerdp_client_parse_rdp_file_buffer_ascii(rdpFile* file, const BYTE* buffe
if (*type == 'i')
{
/* integer type */
freerdp_client_parse_rdp_file_integer_ascii(file, name, value, index);
if (!freerdp_client_parse_rdp_file_integer_ascii(file, name, value, index))
return FALSE;
}
else if (*type == 's')
{
/* string type */
freerdp_client_parse_rdp_file_string_ascii(file, name, value, index);
if (!freerdp_client_parse_rdp_file_string_ascii(file, name, value, index))
return FALSE;
}
else if (*type == 'b')
{
@ -483,7 +570,7 @@ next_line:
return TRUE;
}
BOOL freerdp_client_parse_rdp_file_buffer_unicode(rdpFile* file, const BYTE* buffer, size_t size)
static BOOL freerdp_client_parse_rdp_file_buffer_unicode(rdpFile* file, const BYTE* buffer, size_t size)
{
int index;
int length;
@ -506,7 +593,8 @@ BOOL freerdp_client_parse_rdp_file_buffer_unicode(rdpFile* file, const BYTE* buf
beg = line;
end = &line[length - 1];
freerdp_client_parse_rdp_file_add_line_unicode(file, line, index);
if (!freerdp_client_parse_rdp_file_add_line_unicode(file, line, index))
return FALSE;
if (beg[0] == '/')
{
@ -538,12 +626,14 @@ BOOL freerdp_client_parse_rdp_file_buffer_unicode(rdpFile* file, const BYTE* buf
if (*type == 'i')
{
/* integer type */
freerdp_client_parse_rdp_file_integer_unicode(file, name, value, index);
if (!freerdp_client_parse_rdp_file_integer_unicode(file, name, value, index))
return FALSE;
}
else if (*type == 's')
{
/* string type */
freerdp_client_parse_rdp_file_string_unicode(file, name, value, index);
if (!freerdp_client_parse_rdp_file_string_unicode(file, name, value, index))
return FALSE;
}
else if (*type == 'b')
{
@ -594,6 +684,11 @@ BOOL freerdp_client_parse_rdp_file(rdpFile* file, const char* name)
}
buffer = (BYTE*) malloc(file_size + 2);
if (!buffer)
{
fclose(fp);
return FALSE;
}
read_size = fread(buffer, file_size, 1, fp);
if (!read_size)
@ -606,7 +701,6 @@ BOOL freerdp_client_parse_rdp_file(rdpFile* file, const char* name)
if (read_size < 1)
{
free(buffer);
buffer = NULL;
return FALSE;
}
@ -623,7 +717,9 @@ BOOL freerdp_client_parse_rdp_file(rdpFile* file, const char* name)
#define WRITE_ALL_SETTINGS TRUE
#define SETTING_MODIFIED(_settings, _field) (WRITE_ALL_SETTINGS || _settings->SettingsModified[FreeRDP_##_field])
#define SETTING_MODIFIED_SET(_target, _settings, _field) if SETTING_MODIFIED(_settings, _field) _target = _settings->_field
#define SETTING_MODIFIED_SET_STRING(_target, _settings, _field) if SETTING_MODIFIED(_settings, _field) _target = _strdup(_settings->_field)
#define SETTING_MODIFIED_SET_STRING(_target, _settings, _field) do { if SETTING_MODIFIED(_settings, _field) _target = _strdup(_settings->_field); \
if (!_target) return FALSE; \
} while (0)
BOOL freerdp_client_populate_rdp_file_from_settings(rdpFile* file, const rdpSettings* settings)
{
@ -763,18 +859,26 @@ size_t freerdp_client_write_rdp_file_buffer(const rdpFile* file, char* buffer, s
BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings* settings)
{
if (~((size_t) file->Domain))
freerdp_set_param_string(settings, FreeRDP_Domain, file->Domain);
{
if (freerdp_set_param_string(settings, FreeRDP_Domain, file->Domain) != 0)
return FALSE;
}
if (~((size_t) file->Username))
{
char* user = NULL;
char* domain = NULL;
freerdp_parse_username(file->Username, &user, &domain);
freerdp_set_param_string(settings, FreeRDP_Username, user);
if (freerdp_parse_username(file->Username, &user, &domain) != 0)
return FALSE;
if (freerdp_set_param_string(settings, FreeRDP_Username, user) != 0)
return FALSE;
if (domain)
freerdp_set_param_string(settings, FreeRDP_Domain, domain);
{
if (freerdp_set_param_string(settings, FreeRDP_Domain, domain) != 0)
return FALSE;
}
free(user);
free(domain);
@ -785,9 +889,11 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
int port = -1;
char* host = NULL;
freerdp_parse_hostname(file->FullAddress, &host, &port);
if (freerdp_parse_hostname(file->FullAddress, &host, &port) != 0)
return FALSE;
freerdp_set_param_string(settings, FreeRDP_ServerHostname, host);
if (freerdp_set_param_string(settings, FreeRDP_ServerHostname, host) != 0)
return FALSE;
if (port > 0)
freerdp_set_param_uint32(settings, FreeRDP_ServerPort, (UINT32) port);
@ -813,9 +919,15 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
if (~file->EnableCredSSPSupport)
freerdp_set_param_bool(settings, FreeRDP_NlaSecurity, file->EnableCredSSPSupport);
if (~((size_t) file->AlternateShell))
freerdp_set_param_string(settings, FreeRDP_AlternateShell, file->AlternateShell);
{
if(freerdp_set_param_string(settings, FreeRDP_AlternateShell, file->AlternateShell) != 0)
return FALSE;
}
if (~((size_t) file->ShellWorkingDirectory))
freerdp_set_param_string(settings, FreeRDP_ShellWorkingDirectory, file->ShellWorkingDirectory);
{
if (freerdp_set_param_string(settings, FreeRDP_ShellWorkingDirectory, file->ShellWorkingDirectory) != 0)
return FALSE;
}
if (~file->ScreenModeId)
{
@ -845,6 +957,8 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
if (~((size_t) file->LoadBalanceInfo))
{
settings->LoadBalanceInfo = (BYTE*) _strdup(file->LoadBalanceInfo);
if (!settings->LoadBalanceInfo)
return FALSE;
settings->LoadBalanceInfoLength = (int) strlen((char*) settings->LoadBalanceInfo);
}
@ -897,9 +1011,11 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
int port = -1;
char* host = NULL;
freerdp_parse_hostname(file->GatewayHostname, &host, &port);
if (freerdp_parse_hostname(file->GatewayHostname, &host, &port) != 0)
return FALSE;
freerdp_set_param_string(settings, FreeRDP_GatewayHostname, host);
if (freerdp_set_param_string(settings, FreeRDP_GatewayHostname, host) != 0)
return FALSE;
if (port > 0)
freerdp_set_param_uint32(settings, FreeRDP_GatewayPort, (UINT32) port);
@ -916,15 +1032,30 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
if (~file->RemoteApplicationMode)
freerdp_set_param_bool(settings, FreeRDP_RemoteApplicationMode, file->RemoteApplicationMode);
if (~((size_t) file->RemoteApplicationProgram))
freerdp_set_param_string(settings, FreeRDP_RemoteApplicationProgram, file->RemoteApplicationProgram);
{
if (freerdp_set_param_string(settings, FreeRDP_RemoteApplicationProgram, file->RemoteApplicationProgram) != 0)
return FALSE;
}
if (~((size_t) file->RemoteApplicationName))
freerdp_set_param_string(settings, FreeRDP_RemoteApplicationName, file->RemoteApplicationName);
{
if (freerdp_set_param_string(settings, FreeRDP_RemoteApplicationName, file->RemoteApplicationName) != 0)
return FALSE;
}
if (~((size_t) file->RemoteApplicationIcon))
freerdp_set_param_string(settings, FreeRDP_RemoteApplicationIcon, file->RemoteApplicationIcon);
{
if (freerdp_set_param_string(settings, FreeRDP_RemoteApplicationIcon, file->RemoteApplicationIcon) != 0)
return FALSE;
}
if (~((size_t) file->RemoteApplicationFile))
freerdp_set_param_string(settings, FreeRDP_RemoteApplicationGuid, file->RemoteApplicationGuid);
{
if (freerdp_set_param_string(settings, FreeRDP_RemoteApplicationGuid, file->RemoteApplicationGuid) != 0)
return FALSE;
}
if (~((size_t) file->RemoteApplicationCmdLine))
freerdp_set_param_string(settings, FreeRDP_RemoteApplicationCmdLine, file->RemoteApplicationCmdLine);
{
if (freerdp_set_param_string(settings, FreeRDP_RemoteApplicationCmdLine, file->RemoteApplicationCmdLine) != 0)
return FALSE;
}
if (~file->SpanMonitors)
freerdp_set_param_bool(settings, FreeRDP_SpanMonitors, file->SpanMonitors);
@ -1036,14 +1167,15 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
char* ConnectionFile = settings->ConnectionFile;
settings->ConnectionFile = NULL;
freerdp_client_settings_parse_command_line(settings, file->argc, file->argv, FALSE);
if (freerdp_client_settings_parse_command_line(settings, file->argc, file->argv, FALSE) < 0)
return FALSE;
settings->ConnectionFile = ConnectionFile;
}
return TRUE;
}
rdpFileLine* freerdp_client_rdp_file_find_line_index(rdpFile* file, int index)
static rdpFileLine* freerdp_client_rdp_file_find_line_index(rdpFile* file, int index)
{
rdpFileLine* line;
@ -1052,7 +1184,7 @@ rdpFileLine* freerdp_client_rdp_file_find_line_index(rdpFile* file, int index)
return line;
}
rdpFileLine* freerdp_client_rdp_file_find_line_by_name(rdpFile* file, const char* name)
static rdpFileLine* freerdp_client_rdp_file_find_line_by_name(rdpFile* file, const char* name)
{
int index;
BOOL bFound = FALSE;
@ -1075,6 +1207,14 @@ rdpFileLine* freerdp_client_rdp_file_find_line_by_name(rdpFile* file, const char
return (bFound) ? line : NULL;
}
/**
* Set a string option to a rdpFile
* @param file rdpFile
* @param name name of the option
* @param value value of the option
* @return 0 on success
*/
int freerdp_client_rdp_file_set_string_option(rdpFile* file, const char* name, const char* value)
{
int index;
@ -1082,17 +1222,20 @@ int freerdp_client_rdp_file_set_string_option(rdpFile* file, const char* name, c
char* text;
rdpFileLine* line;
line = freerdp_client_rdp_file_find_line_by_name(file, name);
length = _scprintf("%s:s:%s", name, value);
text = (char*) malloc(length + 1);
if (!text)
return -1;
sprintf_s(text, length + 1, "%s:s:%s", name, value ? value : "");
text[length] = '\0';
line = freerdp_client_rdp_file_find_line_by_name(file, name);
if (line)
{
free(line->sValue);
line->sValue = _strdup(value);
if (!line->sValue)
goto out_fail;
free(line->text);
line->text = text;
@ -1100,14 +1243,24 @@ int freerdp_client_rdp_file_set_string_option(rdpFile* file, const char* name, c
else
{
index = freerdp_client_parse_rdp_file_add_line(file, text, -1);
line = freerdp_client_rdp_file_find_line_index(file, index);
if (index == -1)
goto out_fail;
freerdp_client_rdp_file_set_string(file, name, value, index);
if (!(line = freerdp_client_rdp_file_find_line_index(file, index)))
goto out_fail;
if (freerdp_client_rdp_file_set_string(file, name, value, index) == -1)
goto out_fail;
free(text);
}
return 0;
out_fail:
free(text);
return -1;
}
const char* freerdp_client_rdp_file_get_string_option(rdpFile* file, const char* name)
@ -1149,9 +1302,18 @@ int freerdp_client_rdp_file_set_integer_option(rdpFile* file, const char* name,
else
{
index = freerdp_client_parse_rdp_file_add_line(file, text, -1);
if (index < 0)
{
free(text);
return -1;
}
line = freerdp_client_rdp_file_find_line_index(file, index);
freerdp_client_rdp_file_set_integer(file, (char*) name, value, index);
if (freerdp_client_rdp_file_set_integer(file, (char*) name, value, index) < 0)
{
free(text);
return -1;
}
free(text);
}
@ -1174,7 +1336,7 @@ int freerdp_client_rdp_file_get_integer_option(rdpFile* file, const char* name)
return line->iValue;
}
void freerdp_client_file_string_check_free(LPSTR str)
static void freerdp_client_file_string_check_free(LPSTR str)
{
if (~((size_t) str))
free(str);
@ -1193,12 +1355,30 @@ rdpFile* freerdp_client_rdp_file_new()
file->lineCount = 0;
file->lineSize = 32;
file->lines = (rdpFileLine*) malloc(file->lineSize * sizeof(rdpFileLine));
if (!file->lines)
{
free(file);
return NULL;
}
file->argc = 0;
file->argSize = 32;
file->argv = (char**) malloc(file->argSize * sizeof(char*));
if (!file->argv)
{
free(file->lines);
free(file);
return NULL;
}
freerdp_client_add_option(file, "freerdp");
if (!freerdp_client_add_option(file, "freerdp"))
{
free(file->argv);
free(file->lines);
free(file);
return NULL;
}
}
return file;

18
client/common/test/TestClientRdpFile.c
View File

@ -271,6 +271,11 @@ int TestClientRdpFile(int argc, char* argv[])
/* Unicode */
file = freerdp_client_rdp_file_new();
if (!file)
{
printf("rdp_file_new failed\n");
return -1;
}
freerdp_client_parse_rdp_file_buffer(file, testRdpFileUTF16, sizeof(testRdpFileUTF16));
if (file->UseMultiMon != 0)
@ -331,7 +336,12 @@ int TestClientRdpFile(int argc, char* argv[])
}
iValue = freerdp_client_rdp_file_get_integer_option(file, "vendor integer");
freerdp_client_rdp_file_set_integer_option(file, "vendor integer", 456);
if (freerdp_client_rdp_file_set_integer_option(file, "vendor integer", 456) == -1)
{
printf("failed to set integer: vendor integer");
return -1;
}
iValue = freerdp_client_rdp_file_get_integer_option(file, "vendor integer");
sValue = (char*) freerdp_client_rdp_file_get_string_option(file, "vendor string");
@ -339,7 +349,11 @@ int TestClientRdpFile(int argc, char* argv[])
sValue = (char*) freerdp_client_rdp_file_get_string_option(file, "vendor string");
freerdp_client_rdp_file_set_string_option(file, "fruits", "banana,oranges");
freerdp_client_rdp_file_set_integer_option(file, "numbers", 123456789);
if (freerdp_client_rdp_file_set_integer_option(file, "numbers", 123456789) == -1)
{
printf("failed to set integer: numbers");
return -1;
}
for (index = 0; index < file->lineCount; index++)
{

12
client/iOS/FreeRDP/ios_freerdp.m
View File

@ -11,6 +11,7 @@
#import <freerdp/channels/channels.h>
#import <freerdp/client/channels.h>
#import <freerdp/client/cmdline.h>
#import <freerdp/freerdp.h>
#import "ios_freerdp.h"
#import "ios_freerdp_ui.h"
@ -19,7 +20,6 @@
#import "RDPSession.h"
#import "Utils.h"
#pragma mark Connection helpers
static BOOL ios_pre_connect(freerdp* instance)
@ -279,6 +279,8 @@ void ios_context_free(freerdp* instance, rdpContext* context)
freerdp* ios_freerdp_new()
{
freerdp* inst = freerdp_new();
if (!inst)
return NULL;
inst->PreConnect = ios_pre_connect;
inst->PostConnect = ios_post_connect;
@ -297,6 +299,14 @@ freerdp* ios_freerdp_new()
free(inst->settings->ConfigPath);
inst->settings->HomePath = strdup([home_path UTF8String]);
inst->settings->ConfigPath = strdup([[home_path stringByAppendingPathComponent:@".freerdp"] UTF8String]);
if (!inst->settings->HomePath || !inst->settings->ConfigPath)
{
free(inst->settings->HomePath);
free(inst->settings->ConfigPath);
freerdp_context_free(inst);
freerdp_free(inst);
return NULL;
}
return inst;
}

8
client/iOS/FreeRDP/ios_freerdp_ui.m
View File

@ -51,6 +51,14 @@ BOOL ios_ui_authenticate(freerdp * instance, char** username, char** password, c
*username = strdup([[params objectForKey:@"username"] UTF8String]);
*password = strdup([[params objectForKey:@"password"] UTF8String]);
*domain = strdup([[params objectForKey:@"domain"] UTF8String]);
if (!(*username) || !(*password) || !(*domain))
{
free(*username);
free(*password);
free(*domain);
return FALSE;
}
return TRUE;
}

41
client/iOS/Models/RDPSession.m
View File

@ -75,31 +75,46 @@ NSString* TSXSessionDidFailToConnectNotification = @"TSXSessionDidFailToConnect"
settings->ConsoleSession = 1;
// connection info
settings->ServerHostname = strdup([_params UTF8StringForKey:@"hostname"]);
if (!(settings->ServerHostname = strdup([_params UTF8StringForKey:@"hostname"])))
goto out_free;
// String settings
if ([[_params StringForKey:@"username"] length])
{
settings->Username = strdup([_params UTF8StringForKey:@"username"]);
if (!settings->Username)
goto out_free;
}
if ([[_params StringForKey:@"password"] length])
{
settings->Password = strdup([_params UTF8StringForKey:@"password"]);
if (!settings->Password)
goto out_free;
}
if ([[_params StringForKey:@"domain"] length])
{
settings->Domain = strdup([_params UTF8StringForKey:@"domain"]);
if (!settings->Domain)
goto out_free;
}
settings->ShellWorkingDirectory = strdup([_params UTF8StringForKey:@"working_directory"]);
settings->AlternateShell = strdup([_params UTF8StringForKey:@"remote_program"]);
// RemoteFX
if (!settings->ShellWorkingDirectory || !settings->AlternateShell)
goto out_free;
// RemoteFX
if ([_params boolForKey:@"perf_remotefx" with3GEnabled:connected_via_3g])
{
settings->RemoteFxCodec = TRUE;
settings->FastPathOutput = TRUE;
settings->ColorDepth = 32;
settings->LargePointerFlag = TRUE;
settings->FrameMarkerCommandEnabled = TRUE;
settings->FrameAcknowledge = 10;
settings->FrameMarkerCommandEnabled = TRUE;
settings->FrameAcknowledge = 10;
}
else
{
@ -176,6 +191,12 @@ NSString* TSXSessionDidFailToConnectNotification = @"TSXSessionDidFailToConnect"
settings->GatewayUsageMethod = TSC_PROXY_MODE_DIRECT;
settings->GatewayEnabled = TRUE;
settings->GatewayUseSameCredentials = FALSE;
if (!settings->GatewayHostname || !settings->GatewayUsername || !settings->GatewayPassword
|| !settings->GatewayDomain)
{
goto out_free;
}
}
// Remote keyboard layout
@ -187,6 +208,10 @@ NSString* TSXSessionDidFailToConnectNotification = @"TSXSessionDidFailToConnect"
[self mfi]->session = self;
return self;
out_free:
[self release];
return nil;
}
- (void)dealloc

2
cmake/ConfigOptionsAndroid.cmake
View File

@ -28,6 +28,6 @@ option(ANDROID_BUILD_JAVA_DEBUG "Create a android debug package" ${JAVA_DEBUG_DE
set(ANDROID_APP_VERSION 3 CACHE STRING "Application version")
set(ANDROID_APP_TARGET_SDK 21 CACHE STRING "Application target android SDK")
set(ANDROID_APP_MIN_SDK 9 CACHE STRING "Application minimum android SDK requirement")
set(ANDROID_APP_MIN_SDK 14 CACHE STRING "Application minimum android SDK requirement")
set(ANDROID_APP_GOOGLE_TARGET_SDK "16" CACHE STRING "Application target google SDK")

31
cmake/FindDevD.cmake Normal file
View File

@ -0,0 +1,31 @@
# Configure devd environment
#
# DEVD_FOUND - system has a devd
# DEVD_BIN_DIR - devd bin dir
# DEVD_SKT_DIR - devd socket dir
#
# Copyright (c) 2015 Rozhuk Ivan <rozhuk.im@gmail.com>
# Redistribution and use is allowed according to the terms of the BSD license.
#
FIND_PATH(
DEVD_BIN_DIR
NAMES devd
PATHS /sbin /usr/sbin /usr/local/sbin
)
FIND_PATH(
DEVD_SKT_DIR
NAMES devd.seqpacket.pipe devd.pipe
PATHS /var/run/
)
if (DEVD_BIN_DIR)
set(DEVD_FOUND "YES")
message(STATUS "devd found")
if (NOT DEVD_SKT_DIR)
message(STATUS "devd not running!")
endif (NOT DEVD_SKT_DIR)
endif (DEVD_BIN_DIR)

32
cmake/FindUUID.cmake
View File

@ -20,6 +20,7 @@ set(UUID_FOUND TRUE)
else (UUID_LIBRARIES AND UUID_INCLUDE_DIRS)
find_path(UUID_INCLUDE_DIR
NAMES
uuid.h
uuid/uuid.h
PATHS
${UUID_DIR}/include
@ -85,26 +86,27 @@ $ENV{OSG_ROOT}/lib
/opt/lib
/usr/freeware/lib64
)
if (NOT UUID_LIBRARY AND BSD)
set(UUID_LIBRARY "")
endif(NOT UUID_LIBRARY AND BSD)
set(UUID_INCLUDE_DIRS
${UUID_INCLUDE_DIR}
)
set(UUID_LIBRARIES
${UUID_LIBRARY}
)
set(UUID_INCLUDE_DIRS ${UUID_INCLUDE_DIR})
set(UUID_LIBRARIES ${UUID_LIBRARY})
if (UUID_INCLUDE_DIRS AND UUID_LIBRARIES)
set(UUID_FOUND TRUE)
endif (UUID_INCLUDE_DIRS AND UUID_LIBRARIES)
if (UUID_INCLUDE_DIRS)
if (BSD OR UUID_LIBRARIES)
set(UUID_FOUND TRUE)
endif (BSD OR UUID_LIBRARIES)
endif (UUID_INCLUDE_DIRS)
if (UUID_FOUND)
if (NOT UUID_FIND_QUIETLY)
message(STATUS "Found UUID: ${UUID_LIBRARIES}")
endif (NOT UUID_FIND_QUIETLY)
if (NOT UUID_FIND_QUIETLY)
message(STATUS "Found UUID: ${UUID_LIBRARIES}")
endif (NOT UUID_FIND_QUIETLY)
else (UUID_FOUND)
if (UUID_FIND_REQUIRED)
message(FATAL_ERROR "Could not find UUID")
endif (UUID_FIND_REQUIRED)
if (UUID_FIND_REQUIRED)
message(FATAL_ERROR "Could not find UUID")
endif (UUID_FIND_REQUIRED)
endif (UUID_FOUND)
# show the UUID_INCLUDE_DIRS and UUID_LIBRARIES variables only in the advanced view

4
docs/README.android
View File

@ -209,6 +209,6 @@ After that FreeRDP and the Android package need to be rebuilt to include the lat
Android CMake related Variables
-------------------------------
ANDROID_APP_TARGET_SDK ... specifies the desired android target SDK, currently 11
ANDROID_APP_MIN_SDK ... specifies the minimum android SDK version supported, currently 8
ANDROID_APP_TARGET_SDK ... specifies the desired android target SDK, currently 21
ANDROID_APP_MIN_SDK ... specifies the minimum android SDK version supported, currently 14
ANDROID_APP_GOOGLE_TARGET_SDK ... specifies the minimum google SDK requirement, currently 16

2
include/freerdp/codec/planar.h
View File

@ -104,7 +104,7 @@ struct _BITMAP_PLANAR_CONTEXT
FREERDP_API int freerdp_split_color_planes(BYTE* data, UINT32 format, int width, int height, int scanline, BYTE* planes[4]);
FREERDP_API BYTE* freerdp_bitmap_planar_compress_plane_rle(BYTE* plane, int width, int height, BYTE* outPlane, int* dstSize);
FREERDP_API BYTE* freerdp_bitmap_planar_delta_encode_plane(BYTE* inPlane, int width, int height, BYTE* outPlane);
FREERDP_API int freerdp_bitmap_planar_delta_encode_planes(BYTE* inPlanes[4], int width, int height, BYTE* outPlanes[4]);
FREERDP_API BOOL freerdp_bitmap_planar_delta_encode_planes(BYTE* inPlanes[4], int width, int height, BYTE* outPlanes[4]);
FREERDP_API BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context, BYTE* data, UINT32 format,
int width, int height, int scanline, BYTE* dstData, int* pDstSize);

4
include/freerdp/crypto/certificate.h
View File

@ -55,8 +55,8 @@ struct rdp_certificate_store
#endif
FREERDP_API rdpCertificateData* certificate_data_new(
char* hostname, UINT16 port, char*subject,
char*issuer, char* fingerprint);
char* hostname, UINT16 port, char* subject,
char* issuer, char* fingerprint);
FREERDP_API void certificate_data_free(
rdpCertificateData* certificate_data);
FREERDP_API rdpCertificateStore* certificate_store_new(

10
include/freerdp/gdi/16bpp.h
View File

@ -24,7 +24,7 @@
#include <freerdp/freerdp.h>
#include <freerdp/gdi/gdi.h>
typedef int (*pLineTo_16bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
typedef BOOL (*pLineTo_16bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
#ifdef __cplusplus
extern "C" {
@ -32,10 +32,10 @@ typedef int (*pLineTo_16bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API UINT16 gdi_get_color_16bpp(HGDI_DC hdc, GDI_COLOR color);
FREERDP_API int FillRect_16bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API int BitBlt_16bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
FREERDP_API int PatBlt_16bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
FREERDP_API int LineTo_16bpp(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API BOOL FillRect_16bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API BOOL BitBlt_16bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, DWORD rop);
FREERDP_API BOOL PatBlt_16bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, DWORD rop);
FREERDP_API BOOL LineTo_16bpp(HGDI_DC hdc, int nXEnd, int nYEnd);
#ifdef __cplusplus
}

10
include/freerdp/gdi/32bpp.h
View File

@ -24,7 +24,7 @@
#include <freerdp/freerdp.h>
#include <freerdp/gdi/gdi.h>
typedef int (*pLineTo_32bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
typedef BOOL (*pLineTo_32bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
#ifdef __cplusplus
extern "C" {
@ -32,10 +32,10 @@ typedef int (*pLineTo_32bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API UINT32 gdi_get_color_32bpp(HGDI_DC hdc, GDI_COLOR color);
FREERDP_API int FillRect_32bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API int BitBlt_32bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
FREERDP_API int PatBlt_32bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
FREERDP_API int LineTo_32bpp(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API BOOL FillRect_32bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API BOOL BitBlt_32bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, DWORD rop);
FREERDP_API BOOL PatBlt_32bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, DWORD rop);
FREERDP_API BOOL LineTo_32bpp(HGDI_DC hdc, int nXEnd, int nYEnd);
#ifdef __cplusplus
}

10
include/freerdp/gdi/8bpp.h
View File

@ -24,7 +24,7 @@
#include <freerdp/freerdp.h>
#include <freerdp/gdi/gdi.h>
typedef int (*pLineTo_8bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
typedef BOOL (*pLineTo_8bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
#ifdef __cplusplus
extern "C" {
@ -32,10 +32,10 @@ typedef int (*pLineTo_8bpp)(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API BYTE gdi_get_color_8bpp(HGDI_DC hdc, GDI_COLOR color);
FREERDP_API int FillRect_8bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API int BitBlt_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
FREERDP_API int PatBlt_8bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
FREERDP_API int LineTo_8bpp(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API BOOL FillRect_8bpp(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API BOOL BitBlt_8bpp(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, DWORD rop);
FREERDP_API BOOL PatBlt_8bpp(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, DWORD rop);
FREERDP_API BOOL LineTo_8bpp(HGDI_DC hdc, int nXEnd, int nYEnd);
#ifdef __cplusplus
}

4
include/freerdp/gdi/bitmap.h
View File

@ -40,9 +40,9 @@ FREERDP_API void gdi_SetPixel_16bpp(HGDI_BITMAP hBmp, int X, int Y, UINT16 pixel
FREERDP_API void gdi_SetPixel_32bpp(HGDI_BITMAP hBmp, int X, int Y, UINT32 pixel);
FREERDP_API HGDI_BITMAP gdi_CreateBitmap(int nWidth, int nHeight, int cBitsPerPixel, BYTE* data);
FREERDP_API HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, int nWidth, int nHeight);
FREERDP_API int gdi_BitBlt(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
FREERDP_API BOOL gdi_BitBlt(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, DWORD rop);
typedef int (*p_BitBlt)(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, int rop);
typedef BOOL (*p_BitBlt)(HGDI_DC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HGDI_DC hdcSrc, int nXSrc, int nYSrc, DWORD rop);
#ifdef __cplusplus
}

4
include/freerdp/gdi/brush.h
View File

@ -30,12 +30,12 @@
FREERDP_API HGDI_BRUSH gdi_CreateSolidBrush(GDI_COLOR crColor);
FREERDP_API HGDI_BRUSH gdi_CreatePatternBrush(HGDI_BITMAP hbmp);
FREERDP_API HGDI_BRUSH gdi_CreateHatchBrush(HGDI_BITMAP hbmp);
FREERDP_API int gdi_PatBlt(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
FREERDP_API BOOL gdi_PatBlt(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, DWORD rop);
#ifdef __cplusplus
}
#endif
typedef int (*p_PatBlt)(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, int rop);
typedef BOOL (*p_PatBlt)(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, DWORD rop);
#endif /* FREERDP_GDI_BRUSH_H */

6
include/freerdp/gdi/clipping.h
View File

@ -27,10 +27,10 @@
extern "C" {
#endif
FREERDP_API int gdi_SetClipRgn(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight);
FREERDP_API BOOL gdi_SetClipRgn(HGDI_DC hdc, int nXLeft, int nYLeft, int nWidth, int nHeight);
FREERDP_API HGDI_RGN gdi_GetClipRgn(HGDI_DC hdc);
FREERDP_API int gdi_SetNullClipRgn(HGDI_DC hdc);
FREERDP_API int gdi_ClipCoords(HGDI_DC hdc, int *x, int *y, int *w, int *h, int *srcx, int *srcy);
FREERDP_API BOOL gdi_SetNullClipRgn(HGDI_DC hdc);
FREERDP_API BOOL gdi_ClipCoords(HGDI_DC hdc, int *x, int *y, int *w, int *h, int *srcx, int *srcy);
#ifdef __cplusplus
}

4
include/freerdp/gdi/dc.h
View File

@ -31,8 +31,8 @@ FREERDP_API HGDI_DC gdi_GetDC(void);
FREERDP_API HGDI_DC gdi_CreateDC(UINT32 flags, int bpp);
FREERDP_API HGDI_DC gdi_CreateCompatibleDC(HGDI_DC hdc);
FREERDP_API HGDIOBJECT gdi_SelectObject(HGDI_DC hdc, HGDIOBJECT hgdiobject);
FREERDP_API int gdi_DeleteObject(HGDIOBJECT hgdiobject);
FREERDP_API int gdi_DeleteDC(HGDI_DC hdc);
FREERDP_API BOOL gdi_DeleteObject(HGDIOBJECT hgdiobject);
FREERDP_API BOOL gdi_DeleteDC(HGDI_DC hdc);
#ifdef __cplusplus
}

2
include/freerdp/gdi/gdi.h
View File

@ -315,7 +315,7 @@ struct rdp_gdi
extern "C" {
#endif
FREERDP_API UINT32 gdi_rop3_code(BYTE code);
FREERDP_API DWORD gdi_rop3_code(BYTE code);
FREERDP_API UINT32 gdi_get_pixel_format(UINT32 bitsPerPixel, BOOL vFlip);
FREERDP_API BYTE* gdi_get_bitmap_pointer(HGDI_DC hdcBmp, int x, int y);
FREERDP_API BYTE* gdi_get_brush_pointer(HGDI_DC hdcBrush, int x, int y);

12
include/freerdp/gdi/line.h
View File

@ -27,16 +27,16 @@
extern "C" {
#endif
FREERDP_API int gdi_LineTo(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API int gdi_PolylineTo(HGDI_DC hdc, GDI_POINT *lppt, int cCount);
FREERDP_API int gdi_Polyline(HGDI_DC hdc, GDI_POINT *lppt, int cPoints);
FREERDP_API int gdi_PolyPolyline(HGDI_DC hdc, GDI_POINT *lppt, int *lpdwPolyPoints, int cCount);
FREERDP_API int gdi_MoveToEx(HGDI_DC hdc, int X, int Y, HGDI_POINT lpPoint);
FREERDP_API BOOL gdi_LineTo(HGDI_DC hdc, int nXEnd, int nYEnd);
FREERDP_API BOOL gdi_PolylineTo(HGDI_DC hdc, GDI_POINT *lppt, DWORD cCount);
FREERDP_API BOOL gdi_Polyline(HGDI_DC hdc, GDI_POINT *lppt, int cPoints);
FREERDP_API BOOL gdi_PolyPolyline(HGDI_DC hdc, GDI_POINT *lppt, int *lpdwPolyPoints, DWORD cCount);
FREERDP_API BOOL gdi_MoveToEx(HGDI_DC hdc, int X, int Y, HGDI_POINT lpPoint);
#ifdef __cplusplus
}
#endif
typedef int (*p_LineTo)(HGDI_DC hdc, int nXEnd, int nYEnd);
typedef BOOL (*p_LineTo)(HGDI_DC hdc, int nXEnd, int nYEnd);
#endif /* FREERDP_GDI_LINE_H */

14
include/freerdp/gdi/region.h
View File

@ -37,13 +37,13 @@ FREERDP_API void gdi_RgnToRect(HGDI_RGN rgn, HGDI_RECT rect);
FREERDP_API void gdi_CRgnToRect(int x, int y, int w, int h, HGDI_RECT rect);
FREERDP_API void gdi_RgnToCRect(HGDI_RGN rgn, int *left, int *top, int *right, int *bottom);
FREERDP_API void gdi_CRgnToCRect(int x, int y, int w, int h, int *left, int *top, int *right, int *bottom);
FREERDP_API int gdi_CopyOverlap(int x, int y, int width, int height, int srcx, int srcy);
FREERDP_API int gdi_SetRect(HGDI_RECT rc, int xLeft, int yTop, int xRight, int yBottom);
FREERDP_API int gdi_SetRgn(HGDI_RGN hRgn, int nXLeft, int nYLeft, int nWidth, int nHeight);
FREERDP_API int gdi_SetRectRgn(HGDI_RGN hRgn, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
FREERDP_API int gdi_EqualRgn(HGDI_RGN hSrcRgn1, HGDI_RGN hSrcRgn2);
FREERDP_API int gdi_CopyRect(HGDI_RECT dst, HGDI_RECT src);
FREERDP_API int gdi_PtInRect(HGDI_RECT rc, int x, int y);
FREERDP_API BOOL gdi_CopyOverlap(int x, int y, int width, int height, int srcx, int srcy);
FREERDP_API BOOL gdi_SetRect(HGDI_RECT rc, int xLeft, int yTop, int xRight, int yBottom);
FREERDP_API BOOL gdi_SetRgn(HGDI_RGN hRgn, int nXLeft, int nYLeft, int nWidth, int nHeight);
FREERDP_API BOOL gdi_SetRectRgn(HGDI_RGN hRgn, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
FREERDP_API BOOL gdi_EqualRgn(HGDI_RGN hSrcRgn1, HGDI_RGN hSrcRgn2);
FREERDP_API BOOL gdi_CopyRect(HGDI_RECT dst, HGDI_RECT src);
FREERDP_API BOOL gdi_PtInRect(HGDI_RECT rc, int x, int y);
FREERDP_API BOOL gdi_InvalidateRegion(HGDI_DC hdc, int x, int y, int w, int h);
#ifdef __cplusplus

12
include/freerdp/gdi/shape.h
View File

@ -27,13 +27,13 @@
extern "C" {
#endif
FREERDP_API int gdi_Ellipse(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
FREERDP_API int gdi_FillRect(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API int gdi_Polygon(HGDI_DC hdc, GDI_POINT *lpPoints, int nCount);
FREERDP_API int gdi_PolyPolygon(HGDI_DC hdc, GDI_POINT *lpPoints, int *lpPolyCounts, int nCount);
FREERDP_API int gdi_Rectangle(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
FREERDP_API BOOL gdi_Ellipse(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
FREERDP_API BOOL gdi_FillRect(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
FREERDP_API BOOL gdi_Polygon(HGDI_DC hdc, GDI_POINT *lpPoints, int nCount);
FREERDP_API BOOL gdi_PolyPolygon(HGDI_DC hdc, GDI_POINT *lpPoints, int *lpPolyCounts, int nCount);
FREERDP_API BOOL gdi_Rectangle(HGDI_DC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
typedef int (*p_FillRect)(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
typedef BOOL (*p_FillRect)(HGDI_DC hdc, HGDI_RECT rect, HGDI_BRUSH hbr);
#ifdef __cplusplus
}

3
include/freerdp/server/shadow.h
View File

@ -279,6 +279,9 @@ FREERDP_API BOOL shadow_client_post_msg(rdpShadowClient* client, void* context,
FREERDP_API int shadow_client_boardcast_msg(rdpShadowServer* server, void* context, UINT32 type, SHADOW_MSG_OUT* msg, void* lParam);
FREERDP_API int shadow_client_boardcast_quit(rdpShadowServer* server, int nExitCode);
FREERDP_API int shadow_encoder_preferred_fps(rdpShadowEncoder* encoder);
FREERDP_API UINT32 shadow_encoder_inflight_frames(rdpShadowEncoder* encoder);
#ifdef __cplusplus
}
#endif

6
include/freerdp/settings.h
View File

@ -1435,17 +1435,17 @@ FREERDP_API int freerdp_addin_replace_argument(ADDIN_ARGV* args, char* previous,
FREERDP_API int freerdp_addin_set_argument_value(ADDIN_ARGV* args, char* option, char* value);
FREERDP_API int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, char* previous, char* option, char* value);
FREERDP_API void freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device);
FREERDP_API BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device);
FREERDP_API RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings, const char* name);
FREERDP_API RDPDR_DEVICE* freerdp_device_clone(RDPDR_DEVICE* device);
FREERDP_API void freerdp_device_collection_free(rdpSettings* settings);
FREERDP_API void freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel);
FREERDP_API BOOL freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel);
FREERDP_API ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings, const char* name);
FREERDP_API ADDIN_ARGV* freerdp_static_channel_clone(ADDIN_ARGV* channel);
FREERDP_API void freerdp_static_channel_collection_free(rdpSettings* settings);
FREERDP_API void freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel);
FREERDP_API BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel);
FREERDP_API ADDIN_ARGV* freerdp_dynamic_channel_collection_find(rdpSettings* settings, const char* name);
FREERDP_API ADDIN_ARGV* freerdp_dynamic_channel_clone(ADDIN_ARGV* channel);
FREERDP_API void freerdp_dynamic_channel_collection_free(rdpSettings* settings);

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

@ -75,7 +75,7 @@ extern "C" {
FREERDP_API rdpPcap* pcap_open(char* name, BOOL write);
FREERDP_API void pcap_close(rdpPcap* pcap);
FREERDP_API void pcap_add_record(rdpPcap* pcap, void* data, UINT32 length);
FREERDP_API BOOL pcap_add_record(rdpPcap* pcap, void* data, UINT32 length);
FREERDP_API BOOL pcap_has_next_record(rdpPcap* pcap);
FREERDP_API BOOL pcap_get_next_record(rdpPcap* pcap, pcap_record* record);
FREERDP_API BOOL pcap_get_next_record_header(rdpPcap* pcap, pcap_record* record);

30
libfreerdp/cache/brush.c vendored
View File

@ -189,25 +189,31 @@ rdpBrushCache* brush_cache_new(rdpSettings* settings)
{
rdpBrushCache* brushCache;
brushCache = (rdpBrushCache*) malloc(sizeof(rdpBrushCache));
brushCache = (rdpBrushCache*) calloc(1, sizeof(rdpBrushCache));
if (brushCache)
{
ZeroMemory(brushCache, sizeof(rdpBrushCache));
if (!brushCache)
return NULL;
brushCache->settings = settings;
brushCache->settings = settings;
brushCache->maxEntries = 64;
brushCache->maxMonoEntries = 64;
brushCache->maxEntries = 64;
brushCache->maxMonoEntries = 64;
brushCache->entries = (BRUSH_ENTRY*) malloc(sizeof(BRUSH_ENTRY) * brushCache->maxEntries);
ZeroMemory(brushCache->entries, sizeof(BRUSH_ENTRY) * brushCache->maxEntries);
brushCache->entries = (BRUSH_ENTRY*)calloc(brushCache->maxEntries, sizeof(BRUSH_ENTRY));
if (!brushCache->entries)
goto error_entries;
brushCache->monoEntries = (BRUSH_ENTRY*) malloc(sizeof(BRUSH_ENTRY) * brushCache->maxMonoEntries);
ZeroMemory(brushCache->monoEntries, sizeof(BRUSH_ENTRY) * brushCache->maxMonoEntries);
}
brushCache->monoEntries = (BRUSH_ENTRY*) calloc(brushCache->maxMonoEntries, sizeof(BRUSH_ENTRY));
if (!brushCache->monoEntries)
goto error_mono;
return brushCache;
error_mono:
free(brushCache->entries);
error_entries:
free(brushCache);
return NULL;
}
void brush_cache_free(rdpBrushCache* brushCache)

54
libfreerdp/cache/cache.c vendored
View File

@ -31,22 +31,50 @@ rdpCache* cache_new(rdpSettings* settings)
{
rdpCache* cache;
cache = (rdpCache*) malloc(sizeof(rdpCache));
ZeroMemory(cache, sizeof(rdpCache));
cache = (rdpCache*) calloc(1, sizeof(rdpCache));
if (!cache)
return NULL;
if (cache != NULL)
{
cache->settings = settings;
cache->glyph = glyph_cache_new(settings);
cache->brush = brush_cache_new(settings);
cache->pointer = pointer_cache_new(settings);
cache->bitmap = bitmap_cache_new(settings);
cache->offscreen = offscreen_cache_new(settings);
cache->palette = palette_cache_new(settings);
cache->nine_grid = nine_grid_cache_new(settings);
}
cache->settings = settings;
cache->glyph = glyph_cache_new(settings);
if (!cache->glyph)
goto error_glyph;
cache->brush = brush_cache_new(settings);
if (!cache->brush)
goto error_brush;
cache->pointer = pointer_cache_new(settings);
if (!cache->pointer)
goto error_pointer;
cache->bitmap = bitmap_cache_new(settings);
if (!cache->bitmap)
goto error_bitmap;
cache->offscreen = offscreen_cache_new(settings);
if (!cache->offscreen)
goto error_offscreen;
cache->palette = palette_cache_new(settings);
if (!cache->palette)
goto error_palette;
cache->nine_grid = nine_grid_cache_new(settings);
if (!cache->nine_grid)
goto error_ninegrid;
return cache;
error_ninegrid:
palette_cache_free(cache->palette);
error_palette:
offscreen_cache_free(cache->offscreen);
error_offscreen:
bitmap_cache_free(cache->bitmap);
error_bitmap:
pointer_cache_free(cache->pointer);
error_pointer:
brush_cache_free(cache->brush);
error_brush:
glyph_cache_free(cache->glyph);
error_glyph:
free(cache);
return NULL;
}
void cache_free(rdpCache* cache)

55
libfreerdp/cache/glyph.c vendored
View File

@ -57,7 +57,7 @@ void update_process_glyph(rdpContext* context, BYTE* data, int* index,
if (offset & 0x80)
{
offset = data[*index + 1] | (data[*index + 2] << 8);
offset = data[*index + 1] | ((int)((char)data[*index + 2]) << 8);
(*index)++;
(*index)++;
}
@ -77,7 +77,7 @@ void update_process_glyph(rdpContext* context, BYTE* data, int* index,
}
}
void update_process_glyph_fragments(rdpContext* context, BYTE* data, UINT32 length,
BOOL update_process_glyph_fragments(rdpContext* context, BYTE* data, UINT32 length,
UINT32 cacheId, UINT32 ulCharInc, UINT32 flAccel, UINT32 bgcolor, UINT32 fgcolor, int x, int y,
int bkX, int bkY, int bkWidth, int bkHeight, int opX, int opY, int opWidth, int opHeight, BOOL fOpRedundant)
{
@ -108,17 +108,20 @@ void update_process_glyph_fragments(rdpContext* context, BYTE* data, UINT32 leng
if (opWidth > 0 && opHeight > 0)
{
Glyph_BeginDraw(context, opX, opY, opWidth, opHeight, bgcolor, fgcolor, fOpRedundant);
if (!Glyph_BeginDraw(context, opX, opY, opWidth, opHeight, bgcolor, fgcolor, fOpRedundant))
return FALSE;
}
else
{
if (fOpRedundant)
{
Glyph_BeginDraw(context, bkX, bkY, bkWidth, bkHeight, bgcolor, fgcolor, fOpRedundant);
if (!Glyph_BeginDraw(context, bkX, bkY, bkWidth, bkHeight, bgcolor, fgcolor, fOpRedundant))
return FALSE;
}
else
{
Glyph_BeginDraw(context, 0, 0, 0, 0, bgcolor, fgcolor, fOpRedundant);
if (!Glyph_BeginDraw(context, 0, 0, 0, 0, bgcolor, fgcolor, fOpRedundant))
return FALSE;
}
}
@ -175,6 +178,8 @@ void update_process_glyph_fragments(rdpContext* context, BYTE* data, UINT32 leng
size = data[index + 2];
fragments = (BYTE*) malloc(size);
if (!fragments)
return FALSE;
CopyMemory(fragments, data, size);
glyph_cache_fragment_put(glyph_cache, id, size, fragments);
@ -194,9 +199,9 @@ void update_process_glyph_fragments(rdpContext* context, BYTE* data, UINT32 leng
}
if (opWidth > 0 && opHeight > 0)
Glyph_EndDraw(context, opX, opY, opWidth, opHeight, bgcolor, fgcolor);
else
Glyph_EndDraw(context, bkX, bkY, bkWidth, bkHeight, bgcolor, fgcolor);
return Glyph_EndDraw(context, opX, opY, opWidth, opHeight, bgcolor, fgcolor);
return Glyph_EndDraw(context, bkX, bkY, bkWidth, bkHeight, bgcolor, fgcolor);
}
BOOL update_gdi_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
@ -211,14 +216,12 @@ BOOL update_gdi_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
bkHeight = glyphIndex->bkBottom - glyphIndex->bkTop;
opHeight = glyphIndex->opBottom - glyphIndex->opTop;
update_process_glyph_fragments(context, glyphIndex->data, glyphIndex->cbData,
return update_process_glyph_fragments(context, glyphIndex->data, glyphIndex->cbData,
glyphIndex->cacheId, glyphIndex->ulCharInc, glyphIndex->flAccel,
glyphIndex->backColor, glyphIndex->foreColor, glyphIndex->x, glyphIndex->y,
glyphIndex->bkLeft, glyphIndex->bkTop, bkWidth, bkHeight,
glyphIndex->opLeft, glyphIndex->opTop, opWidth, opHeight,
glyphIndex->fOpRedundant);
return TRUE;
}
BOOL update_gdi_fast_index(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
@ -263,7 +266,7 @@ BOOL update_gdi_fast_index(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
if (y == -32768)
y = fastIndex->bkTop;
update_process_glyph_fragments(context, fastIndex->data, fastIndex->cbData,
return update_process_glyph_fragments(context, fastIndex->data, fastIndex->cbData,
fastIndex->cacheId, fastIndex->ulCharInc, fastIndex->flAccel,
fastIndex->backColor, fastIndex->foreColor, x, y,
fastIndex->bkLeft, fastIndex->bkTop,
@ -271,7 +274,6 @@ BOOL update_gdi_fast_index(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
opLeft, opTop,
opRight - opLeft, opBottom - opTop,
FALSE);
return TRUE;
}
BOOL update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
@ -323,14 +325,20 @@ BOOL update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
glyphData = &fastGlyph->glyphData;
glyph = Glyph_Alloc(context);
if (!glyph)
return FALSE;
glyph->x = glyphData->x;
glyph->y = glyphData->y;
glyph->cx = glyphData->cx;
glyph->cy = glyphData->cy;
glyph->cb = glyphData->cb;
glyph->aj = malloc(glyphData->cb);
if (!glyph->aj)
goto error_aj;
CopyMemory(glyph->aj, glyphData->aj, glyph->cb);
Glyph_New(context, glyph);
if (!Glyph_New(context, glyph))
goto error_glyph_new;
glyph_cache_put(cache->glyph, fastGlyph->cacheId, fastGlyph->data[0], glyph);
}
@ -338,7 +346,7 @@ BOOL update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
text_data[0] = fastGlyph->data[0];
text_data[1] = 0;
update_process_glyph_fragments(context, text_data, 1,
return update_process_glyph_fragments(context, text_data, 1,
fastGlyph->cacheId, fastGlyph->ulCharInc, fastGlyph->flAccel,
fastGlyph->backColor, fastGlyph->foreColor, x, y,
fastGlyph->bkLeft, fastGlyph->bkTop,
@ -346,7 +354,13 @@ BOOL update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
opLeft, opTop,
opRight - opLeft, opBottom - opTop,
FALSE);
return TRUE;
error_glyph_new:
free(glyph->aj);
glyph->aj = NULL;
error_aj:
Glyph_Free(context, glyph);
return FALSE;
}
BOOL update_gdi_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyph)
@ -362,10 +376,7 @@ BOOL update_gdi_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyph)
glyph = Glyph_Alloc(context);
if (!glyph)
{
/* TODO: cleanup previously allocated memory */
return FALSE;
}
glyph->x = glyph_data->x;
glyph->y = glyph_data->y;
@ -373,7 +384,11 @@ BOOL update_gdi_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyph)
glyph->cy = glyph_data->cy;
glyph->cb = glyph_data->cb;
glyph->aj = glyph_data->aj;
Glyph_New(context, glyph);
if (!Glyph_New(context, glyph))
{
Glyph_Free(context, glyph);
return FALSE;
}
glyph_cache_put(cache->glyph, cacheGlyph->cacheId, glyph_data->cacheIndex, glyph);
}

28
libfreerdp/cache/nine_grid.c vendored
View File

@ -95,21 +95,23 @@ rdpNineGridCache* nine_grid_cache_new(rdpSettings* settings)
{
rdpNineGridCache* nine_grid;
nine_grid = (rdpNineGridCache*) malloc(sizeof(rdpNineGridCache));
ZeroMemory(nine_grid, sizeof(rdpNineGridCache));
nine_grid = (rdpNineGridCache*) calloc(1, sizeof(rdpNineGridCache));
if (!nine_grid)
return NULL;
if (nine_grid != NULL)
nine_grid->settings = settings;
nine_grid->maxSize = 2560;
nine_grid->maxEntries = 256;
nine_grid->settings->DrawNineGridCacheSize = nine_grid->maxSize;
nine_grid->settings->DrawNineGridCacheEntries = nine_grid->maxEntries;
nine_grid->entries = (NINE_GRID_ENTRY*) calloc(nine_grid->maxEntries, sizeof(NINE_GRID_ENTRY));
if (!nine_grid->entries)
{
nine_grid->settings = settings;
nine_grid->maxSize = 2560;
nine_grid->maxEntries = 256;
nine_grid->settings->DrawNineGridCacheSize = nine_grid->maxSize;
nine_grid->settings->DrawNineGridCacheEntries = nine_grid->maxEntries;
nine_grid->entries = (NINE_GRID_ENTRY*) malloc(sizeof(NINE_GRID_ENTRY) * nine_grid->maxEntries);
ZeroMemory(nine_grid->entries, sizeof(NINE_GRID_ENTRY) * nine_grid->maxEntries);
free(nine_grid);
return NULL;
}
return nine_grid;

35
libfreerdp/cache/offscreen.c vendored
View File

@ -146,26 +146,27 @@ rdpOffscreenCache* offscreen_cache_new(rdpSettings* settings)
{
rdpOffscreenCache* offscreenCache;
offscreenCache = (rdpOffscreenCache*) malloc(sizeof(rdpOffscreenCache));
offscreenCache = (rdpOffscreenCache*) calloc(1, sizeof(rdpOffscreenCache));
if (offscreenCache)
if (!offscreenCache)
return NULL;
offscreenCache->settings = settings;
offscreenCache->update = ((freerdp*) settings->instance)->update;
offscreenCache->currentSurface = SCREEN_BITMAP_SURFACE;
offscreenCache->maxSize = 7680;
offscreenCache->maxEntries = 2000;
settings->OffscreenCacheSize = offscreenCache->maxSize;
settings->OffscreenCacheEntries = offscreenCache->maxEntries;
offscreenCache->entries = (rdpBitmap**) calloc(offscreenCache->maxEntries, sizeof(rdpBitmap*));
if (!offscreenCache->entries)
{
ZeroMemory(offscreenCache, sizeof(rdpOffscreenCache));
offscreenCache->settings = settings;
offscreenCache->update = ((freerdp*) settings->instance)->update;
offscreenCache->currentSurface = SCREEN_BITMAP_SURFACE;
offscreenCache->maxSize = 7680;
offscreenCache->maxEntries = 2000;
settings->OffscreenCacheSize = offscreenCache->maxSize;
settings->OffscreenCacheEntries = offscreenCache->maxEntries;
offscreenCache->entries = (rdpBitmap**) malloc(sizeof(rdpBitmap*) * offscreenCache->maxEntries);
ZeroMemory(offscreenCache->entries, sizeof(rdpBitmap*) * offscreenCache->maxEntries);
free(offscreenCache);
return NULL;
}
return offscreenCache;
}

79
libfreerdp/cache/pointer.c vendored
View File

@ -109,39 +109,37 @@ BOOL update_pointer_new(rdpContext* context, POINTER_NEW_UPDATE* pointer_new)
rdpCache* cache = context->cache;
pointer = Pointer_Alloc(context);
if (!pointer)
return FALSE;
if (pointer != NULL)
pointer->xorBpp = pointer_new->xorBpp;
pointer->xPos = pointer_new->colorPtrAttr.xPos;
pointer->yPos = pointer_new->colorPtrAttr.yPos;
pointer->width = pointer_new->colorPtrAttr.width;
pointer->height = pointer_new->colorPtrAttr.height;
pointer->lengthAndMask = pointer_new->colorPtrAttr.lengthAndMask;
pointer->lengthXorMask = pointer_new->colorPtrAttr.lengthXorMask;
if (pointer->lengthAndMask)
{
pointer->xorBpp = pointer_new->xorBpp;
pointer->xPos = pointer_new->colorPtrAttr.xPos;
pointer->yPos = pointer_new->colorPtrAttr.yPos;
pointer->width = pointer_new->colorPtrAttr.width;
pointer->height = pointer_new->colorPtrAttr.height;
pointer->lengthAndMask = pointer_new->colorPtrAttr.lengthAndMask;
pointer->lengthXorMask = pointer_new->colorPtrAttr.lengthXorMask;
pointer->andMaskData = pointer->xorMaskData = NULL;
if (pointer->lengthAndMask)
{
pointer->andMaskData = (BYTE*) malloc(pointer->lengthAndMask);
if (!pointer->andMaskData)
goto out_fail;
CopyMemory(pointer->andMaskData, pointer_new->colorPtrAttr.andMaskData, pointer->lengthAndMask);
}
if (pointer->lengthXorMask)
{
pointer->xorMaskData = (BYTE*) malloc(pointer->lengthXorMask);
CopyMemory(pointer->xorMaskData, pointer_new->colorPtrAttr.xorMaskData, pointer->lengthXorMask);
}
pointer->New(context, pointer);
pointer_cache_put(cache->pointer, pointer_new->colorPtrAttr.cacheIndex, pointer);
Pointer_Set(context, pointer);
return TRUE;
pointer->andMaskData = (BYTE*) malloc(pointer->lengthAndMask);
if (!pointer->andMaskData)
goto out_fail;
CopyMemory(pointer->andMaskData, pointer_new->colorPtrAttr.andMaskData, pointer->lengthAndMask);
}
return FALSE;
if (pointer->lengthXorMask)
{
pointer->xorMaskData = (BYTE*) malloc(pointer->lengthXorMask);
if (!pointer->xorMaskData)
goto out_fail;
CopyMemory(pointer->xorMaskData, pointer_new->colorPtrAttr.xorMaskData, pointer->lengthXorMask);
}
if (!pointer->New(context, pointer))
goto out_fail;
pointer_cache_put(cache->pointer, pointer_new->colorPtrAttr.cacheIndex, pointer);
return Pointer_Set(context, pointer);
out_fail:
free(pointer->andMaskData);
@ -213,18 +211,19 @@ rdpPointerCache* pointer_cache_new(rdpSettings* settings)
{
rdpPointerCache* pointer_cache;
pointer_cache = (rdpPointerCache*) malloc(sizeof(rdpPointerCache));
pointer_cache = (rdpPointerCache*) calloc(1, sizeof(rdpPointerCache));
if (!pointer_cache)
return NULL;
if (pointer_cache != NULL)
pointer_cache->settings = settings;
pointer_cache->cacheSize = settings->PointerCacheSize;
pointer_cache->update = ((freerdp*) settings->instance)->update;
pointer_cache->entries = (rdpPointer**) calloc(pointer_cache->cacheSize, sizeof(rdpPointer*));
if (!pointer_cache->entries)
{
ZeroMemory(pointer_cache, sizeof(rdpPointerCache));
pointer_cache->settings = settings;
pointer_cache->cacheSize = settings->PointerCacheSize;
pointer_cache->update = ((freerdp*) settings->instance)->update;
pointer_cache->entries = (rdpPointer**) malloc(sizeof(rdpPointer*) * pointer_cache->cacheSize);
ZeroMemory(pointer_cache->entries, sizeof(rdpPointer*) * pointer_cache->cacheSize);
free(pointer_cache);
return NULL;
}
return pointer_cache;

59
libfreerdp/codec/clear.c
View File

@ -377,12 +377,13 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
if (vBarShortEntry->count > vBarShortEntry->size)
{
UINT32 *tmp;
vBarShortEntry->size = vBarShortEntry->count;
if (!vBarShortEntry->pixels)
vBarShortEntry->pixels = (UINT32*) malloc(vBarShortEntry->count * 4);
else
vBarShortEntry->pixels = (UINT32*) realloc(vBarShortEntry->pixels, vBarShortEntry->count * 4);
tmp = (UINT32*) realloc(vBarShortEntry->pixels, vBarShortEntry->count * 4);
if (!tmp)
return -1;
vBarShortEntry->pixels = tmp;
}
if (!vBarShortEntry->pixels && vBarShortEntry->size)
@ -442,12 +443,13 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
if (vBarEntry->count > vBarEntry->size)
{
UINT32 *tmp;
vBarEntry->size = vBarEntry->count;
if (!vBarEntry->pixels)
vBarEntry->pixels = (UINT32*) malloc(vBarEntry->count * 4);
else
vBarEntry->pixels = (UINT32*) realloc(vBarEntry->pixels, vBarEntry->count * 4);
tmp = (UINT32*) realloc(vBarEntry->pixels, vBarEntry->count * 4);
if (!tmp)
return -1;
vBarEntry->pixels = tmp;
}
if (!vBarEntry->pixels && vBarEntry->size)
@ -791,12 +793,13 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
if (glyphEntry->count > glyphEntry->size)
{
UINT32 *tmp;
glyphEntry->size = glyphEntry->count;
if (!glyphEntry->pixels)
glyphEntry->pixels = (UINT32*) malloc(glyphEntry->size * 4);
else
glyphEntry->pixels = (UINT32*) realloc(glyphEntry->pixels, glyphEntry->size * 4);
tmp = (UINT32*) realloc(glyphEntry->pixels, glyphEntry->size * 4);
if (!tmp)
return -1;
glyphEntry->pixels = tmp;
}
if (!glyphEntry->pixels)
@ -841,27 +844,31 @@ CLEAR_CONTEXT* clear_context_new(BOOL Compressor)
clear = (CLEAR_CONTEXT*) calloc(1, sizeof(CLEAR_CONTEXT));
if (clear)
{
clear->Compressor = Compressor;
if (!clear)
return NULL;
clear->nsc = nsc_context_new();
clear->Compressor = Compressor;
if (!clear->nsc)
{
free (clear);
return NULL;
}
clear->nsc = nsc_context_new();
if (!clear->nsc)
goto error_nsc;
nsc_context_set_pixel_format(clear->nsc, RDP_PIXEL_FORMAT_R8G8B8);
nsc_context_set_pixel_format(clear->nsc, RDP_PIXEL_FORMAT_R8G8B8);
clear->TempSize = 512 * 512 * 4;
clear->TempBuffer = (BYTE*) malloc(clear->TempSize);
clear->TempSize = 512 * 512 * 4;
clear->TempBuffer = (BYTE*) malloc(clear->TempSize);
if (!clear->TempBuffer)
goto error_temp_buffer;
clear_context_reset(clear);
}
clear_context_reset(clear);
return clear;
error_temp_buffer:
nsc_context_free(clear->nsc);
error_nsc:
free(clear);
return NULL;
}
void clear_context_free(CLEAR_CONTEXT* clear)

25
libfreerdp/codec/h264.c
View File

@ -679,7 +679,7 @@ int h264_decompress(H264_CONTEXT* h264, BYTE* pSrcData, UINT32 SrcSize,
int h264_compress(H264_CONTEXT* h264, BYTE* pSrcData, DWORD SrcFormat,
int nSrcStep, int nSrcWidth, int nSrcHeight, BYTE** ppDstData, UINT32* pDstSize)
{
int status;
int status = -1;
prim_size_t roi;
int nWidth, nHeight;
primitives_t *prims = primitives_get();
@ -691,12 +691,19 @@ int h264_compress(H264_CONTEXT* h264, BYTE* pSrcData, DWORD SrcFormat,
nWidth = (nSrcWidth + 1) & ~1;
nHeight = (nSrcHeight + 1) & ~1;
h264->pYUVData[0] = (BYTE*) malloc(nWidth * nHeight);
if (!(h264->pYUVData[0] = (BYTE*) malloc(nWidth * nHeight)))
return -1;
h264->iStride[0] = nWidth;
h264->pYUVData[1] = (BYTE*) malloc(nWidth * nHeight / 4);
if (!(h264->pYUVData[1] = (BYTE*) malloc(nWidth * nHeight / 4)))
goto error_1;
h264->iStride[1] = nWidth / 2;
h264->pYUVData[2] = (BYTE*) malloc(nWidth * nHeight / 4);
if (!(h264->pYUVData[2] = (BYTE*) malloc(nWidth * nHeight / 4)))
goto error_2;
h264->iStride[2] = nWidth / 2;
h264->width = nWidth;
h264->height = nHeight;
roi.width = nSrcWidth;
@ -706,12 +713,14 @@ int h264_compress(H264_CONTEXT* h264, BYTE* pSrcData, DWORD SrcFormat,
status = h264->subsystem->Compress(h264, ppDstData, pDstSize);
free(h264->pYUVData[0]);
free(h264->pYUVData[1]);
free(h264->pYUVData[2]);
h264->pYUVData[0] = NULL;
h264->pYUVData[1] = NULL;
h264->pYUVData[2] = NULL;
error_2:
free(h264->pYUVData[1]);
h264->pYUVData[1] = NULL;
error_1:
free(h264->pYUVData[0]);
h264->pYUVData[0] = NULL;
return status;
}

47
libfreerdp/codec/planar.c
View File

@ -873,6 +873,8 @@ BYTE* freerdp_bitmap_planar_compress_plane_rle(BYTE* inPlane, int width, int hei
{
outBufferSize = width * height;
outPlane = malloc(outBufferSize);
if (!outPlane)
return NULL;
}
else
{
@ -968,7 +970,10 @@ BYTE* freerdp_bitmap_planar_delta_encode_plane(BYTE* inPlane, int width, int hei
BYTE *outPtr, *srcPtr, *prevLinePtr;
if (!outPlane)
outPlane = (BYTE*) malloc(width * height);
{
if (!(outPlane = (BYTE*) malloc(width * height)))
return NULL;
}
// first line is copied as is
CopyMemory(outPlane, inPlane, width);
@ -994,14 +999,18 @@ BYTE* freerdp_bitmap_planar_delta_encode_plane(BYTE* inPlane, int width, int hei
return outPlane;
}
int freerdp_bitmap_planar_delta_encode_planes(BYTE* inPlanes[4], int width, int height, BYTE* outPlanes[4])
BOOL freerdp_bitmap_planar_delta_encode_planes(BYTE* inPlanes[4], int width, int height, BYTE* outPlanes[4])
{
outPlanes[0] = freerdp_bitmap_planar_delta_encode_plane(inPlanes[0], width, height, outPlanes[0]);
outPlanes[1] = freerdp_bitmap_planar_delta_encode_plane(inPlanes[1], width, height, outPlanes[1]);
outPlanes[2] = freerdp_bitmap_planar_delta_encode_plane(inPlanes[2], width, height, outPlanes[2]);
outPlanes[3] = freerdp_bitmap_planar_delta_encode_plane(inPlanes[3], width, height, outPlanes[3]);
int i;
return 0;
for (i = 0; i < 4; i++)
{
outPlanes[i] = freerdp_bitmap_planar_delta_encode_plane(inPlanes[i], width, height, outPlanes[i]);
if (!outPlanes[i])
return FALSE;
}
return TRUE;
}
BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context, BYTE* data, UINT32 format,
@ -1025,7 +1034,8 @@ BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context, BYTE* data,
if (context->AllowRunLengthEncoding)
{
freerdp_bitmap_planar_delta_encode_planes(context->planes, width, height, context->deltaPlanes);
if (!freerdp_bitmap_planar_delta_encode_planes(context->planes, width, height, context->deltaPlanes))
return NULL;;
if (freerdp_bitmap_planar_compress_planes_rle(context->deltaPlanes, width, height,
context->rlePlanesBuffer, (int*) &dstSizes, context->AllowSkipAlpha) > 0)
@ -1071,6 +1081,8 @@ BYTE* freerdp_bitmap_compress_planar(BITMAP_PLANAR_CONTEXT* context, BYTE* data,
size++;
dstData = malloc(size);
if (!dstData)
return NULL;
*pDstSize = size;
}
@ -1157,13 +1169,10 @@ BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(DWORD flags, int maxWid
{
BITMAP_PLANAR_CONTEXT* context;
context = (BITMAP_PLANAR_CONTEXT*) malloc(sizeof(BITMAP_PLANAR_CONTEXT));
context = (BITMAP_PLANAR_CONTEXT*) calloc(1, sizeof(BITMAP_PLANAR_CONTEXT));
if (!context)
return NULL;
ZeroMemory(context, sizeof(BITMAP_PLANAR_CONTEXT));
if (flags & PLANAR_FORMAT_HEADER_NA)
context->AllowSkipAlpha = TRUE;
@ -1183,20 +1192,34 @@ BITMAP_PLANAR_CONTEXT* freerdp_bitmap_planar_context_new(DWORD flags, int maxWid
context->maxPlaneSize = context->maxWidth * context->maxHeight;
context->planesBuffer = malloc(context->maxPlaneSize * 4);
if (!context->planesBuffer)
goto error_planesBuffer;
context->planes[0] = &context->planesBuffer[context->maxPlaneSize * 0];
context->planes[1] = &context->planesBuffer[context->maxPlaneSize * 1];
context->planes[2] = &context->planesBuffer[context->maxPlaneSize * 2];
context->planes[3] = &context->planesBuffer[context->maxPlaneSize * 3];
context->deltaPlanesBuffer = malloc(context->maxPlaneSize * 4);
if (!context->deltaPlanesBuffer)
goto error_deltaPlanesBuffer;
context->deltaPlanes[0] = &context->deltaPlanesBuffer[context->maxPlaneSize * 0];
context->deltaPlanes[1] = &context->deltaPlanesBuffer[context->maxPlaneSize * 1];
context->deltaPlanes[2] = &context->deltaPlanesBuffer[context->maxPlaneSize * 2];
context->deltaPlanes[3] = &context->deltaPlanesBuffer[context->maxPlaneSize * 3];
context->rlePlanesBuffer = malloc(context->maxPlaneSize * 4);
if (!context->rlePlanesBuffer)
goto error_rlePlanesBuffer;
return context;
error_rlePlanesBuffer:
free(context->deltaPlanesBuffer);
error_deltaPlanesBuffer:
free(context->planesBuffer);
error_planesBuffer:
free(context);
return NULL;
}
void freerdp_bitmap_planar_context_free(BITMAP_PLANAR_CONTEXT* context)

22
libfreerdp/codec/rfx.c
View File

@ -61,6 +61,9 @@
#define RFX_INIT_SIMD(_rfx_context) do { } while (0)
#endif
#define RFX_KEY "Software\\"FREERDP_VENDOR_STRING"\\" \
FREERDP_PRODUCT_STRING"\\RemoteFX"
/**
* The quantization values control the compression rate and quality. The value
* range is between 6 and 15. The higher value, the higher compression rate
@ -251,7 +254,7 @@ RFX_CONTEXT* rfx_context_new(BOOL encoder)
* dwt_buffer: 32 * 32 * 2 * 2 * sizeof(INT16) = 8192, maximum sub-band width is 32
*
* Additionally we add 32 bytes (16 in front and 16 at the back of the buffer)
* in order to allow optimized functions (SEE, NEON) to read from positions
* in order to allow optimized functions (SEE, NEON) to read from positions
* that are actually in front/beyond the buffer. Offset calculations are
* performed at the BufferPool_Take function calls in rfx_encode/decode.c.
*
@ -284,7 +287,7 @@ RFX_CONTEXT* rfx_context_new(BOOL encoder)
priv->MinThreadCount = sysinfo.dwNumberOfProcessors;
priv->MaxThreadCount = 0;
status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\FreeRDP\\RemoteFX"), 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, RFX_KEY, 0, KEY_READ | KEY_WOW64_64KEY, &hKey);
if (status == ERROR_SUCCESS)
{
@ -328,15 +331,15 @@ RFX_CONTEXT* rfx_context_new(BOOL encoder)
/* create profilers for default decoding routines */
rfx_profiler_create(context);
/* set up default routines */
context->quantization_decode = rfx_quantization_decode;
context->quantization_encode = rfx_quantization_encode;
context->quantization_decode = rfx_quantization_decode;
context->quantization_encode = rfx_quantization_encode;
context->dwt_2d_decode = rfx_dwt_2d_decode;
context->dwt_2d_encode = rfx_dwt_2d_encode;
RFX_INIT_SIMD(context);
context->state = RFX_STATE_SEND_HEADERS;
return context;
@ -514,7 +517,7 @@ static BOOL rfx_process_message_channels(RFX_CONTEXT* context, wStream* s)
Stream_Read_UINT8(s, numChannels); /* numChannels (1 byte), must bet set to 0x01 */
/* In RDVH sessions, numChannels will represent the number of virtual monitors
/* In RDVH sessions, numChannels will represent the number of virtual monitors
* configured and does not always be set to 0x01 as [MS-RDPRFX] said.
*/
if (numChannels < 1)
@ -966,10 +969,9 @@ static BOOL rfx_process_message_tileset(RFX_CONTEXT* context, RFX_MESSAGE* messa
WaitForThreadpoolWorkCallbacks(work_objects[i], FALSE);
CloseThreadpoolWork(work_objects[i]);
}
free(work_objects);
free(params);
}
free(work_objects);
free(params);
for (i = 0; i < message->numTiles; i++)
{

44
libfreerdp/codec/test/TestFreeRDPCodecPlanar.c
View File

@ -2960,9 +2960,14 @@ int test_individual_planes_encoding_rle()
CopyMemory(planar->planes[1], (BYTE*) TEST_64X64_RED_PLANE, planeSize); /* Red */
CopyMemory(planar->planes[2], (BYTE*) TEST_64X64_GREEN_PLANE, planeSize); /* Green */
CopyMemory(planar->planes[3], (BYTE*) TEST_64X64_BLUE_PLANE, planeSize); /* Blue */
freerdp_bitmap_planar_delta_encode_plane(planar->planes[1], width, height, planar->deltaPlanes[1]); /* Red */
freerdp_bitmap_planar_delta_encode_plane(planar->planes[2], width, height, planar->deltaPlanes[2]); /* Green */
freerdp_bitmap_planar_delta_encode_plane(planar->planes[3], width, height, planar->deltaPlanes[3]); /* Blue */
if (!freerdp_bitmap_planar_delta_encode_plane(planar->planes[1], width, height, planar->deltaPlanes[1]) || /* Red */
!freerdp_bitmap_planar_delta_encode_plane(planar->planes[2], width, height, planar->deltaPlanes[2]) || /* Green */
!freerdp_bitmap_planar_delta_encode_plane(planar->planes[3], width, height, planar->deltaPlanes[3])) /* Blue */
{
return -1;
}
pOutput = planar->rlePlanesBuffer;
availableSize = planeSize * 3;
/* Red */
@ -3101,11 +3106,15 @@ int TestFreeRDPCodecPlanar(int argc, char* argv[])
width = i;
height = i;
whiteBitmap = (BYTE*) malloc(width * height * 4);
if (!whiteBitmap)
return -1;
FillMemory(whiteBitmap, width * height * 4, 0xFF);
fill_bitmap_alpha_channel(whiteBitmap, width, height, 0x00);
compressedBitmap = freerdp_bitmap_compress_planar(planar, whiteBitmap, format, width, height, width * 4, NULL, &dstSize);
decompressedBitmap = (BYTE*) malloc(width * height * 4);
ZeroMemory(decompressedBitmap, width * height * 4);
decompressedBitmap = (BYTE*) calloc(width * height, 4);
if (!decompressedBitmap)
return -1;
pDstData = decompressedBitmap;
@ -3138,12 +3147,14 @@ int TestFreeRDPCodecPlanar(int argc, char* argv[])
{
width = i;
height = i;
blackBitmap = (BYTE*) malloc(width * height * 4);
ZeroMemory(blackBitmap, width * height * 4);
blackBitmap = (BYTE*) calloc(width * height, 4);
if (!blackBitmap)
return -1;
fill_bitmap_alpha_channel(blackBitmap, width, height, 0x00);
compressedBitmap = freerdp_bitmap_compress_planar(planar, blackBitmap, format, width, height, width * 4, NULL, &dstSize);
decompressedBitmap = (BYTE*) malloc(width * height * 4);
ZeroMemory(decompressedBitmap, width * height * 4);
decompressedBitmap = (BYTE*) calloc(width * height, 4);
if (!decompressedBitmap)
return -1;
pDstData = decompressedBitmap;
@ -3179,8 +3190,9 @@ int TestFreeRDPCodecPlanar(int argc, char* argv[])
height = 64;
compressedBitmap = freerdp_bitmap_compress_planar(planar, (BYTE*) TEST_RLE_BITMAP_EXPERIMENTAL_01,
format, width, height, width * 4, NULL, &dstSize);
decompressedBitmap = (BYTE*) malloc(width * height * 4);
ZeroMemory(decompressedBitmap, width * height * 4);
decompressedBitmap = (BYTE*) calloc(width * height, 4);
if (!decompressedBitmap)
return -1;
pDstData = decompressedBitmap;
@ -3217,8 +3229,9 @@ int TestFreeRDPCodecPlanar(int argc, char* argv[])
height = 64;
compressedBitmap = freerdp_bitmap_compress_planar(planar, (BYTE*) TEST_RLE_BITMAP_EXPERIMENTAL_02,
format, width, height, width * 4, NULL, &dstSize);
decompressedBitmap = (BYTE*) malloc(width * height * 4);
ZeroMemory(decompressedBitmap, width * height * 4);
decompressedBitmap = (BYTE*) calloc(width * height, 4);
if (!decompressedBitmap)
return -1;
pDstData = decompressedBitmap;
@ -3262,8 +3275,9 @@ int TestFreeRDPCodecPlanar(int argc, char* argv[])
height = 64;
compressedBitmap = freerdp_bitmap_compress_planar(planar, (BYTE*) TEST_RLE_BITMAP_EXPERIMENTAL_03,
format, width, height, width * 4, NULL, &dstSize);
decompressedBitmap = (BYTE*) malloc(width * height * 4);
ZeroMemory(decompressedBitmap, width * height * 4);
decompressedBitmap = (BYTE*) calloc(width * height, 4);
if (!decompressedBitmap)
return -1;
pDstData = decompressedBitmap;

63
libfreerdp/codec/test/TestFreeRDPCodecProgressive.c
View File

@ -134,6 +134,16 @@ static int g_Height = 0;
static int g_DstStep = 0;
static BYTE* g_DstData = NULL;
static void sample_file_free(EGFX_SAMPLE_FILE* file)
{
if (!file)
return;
free(file->buffer);
file->buffer = NULL;
file->size = 0;
}
static void test_fill_image_alpha_channel(BYTE* data, int width, int height, BYTE value)
{
int i, j;
@ -258,8 +268,11 @@ BYTE* test_progressive_load_file(char* path, char* file, UINT32* size)
char* filename;
filename = GetCombinedPath(path, file);
if (!filename)
return NULL;
fp = fopen(filename, "r");
free(filename);
if (!fp)
return NULL;
@ -271,12 +284,18 @@ BYTE* test_progressive_load_file(char* path, char* file, UINT32* size)
buffer = (BYTE*) malloc(*size);
if (!buffer)
{
fclose(fp);
return NULL;
}
if (fread(buffer, *size, 1, fp) != 1)
{
free(buffer);
fclose(fp);
return NULL;
}
free(filename);
fclose(fp);
return buffer;
@ -931,6 +950,7 @@ int test_progressive_decode(PROGRESSIVE_CONTEXT* progressive, EGFX_SAMPLE_FILE f
int test_progressive_ms_sample(char* ms_sample_path)
{
int i, j, k;
int count;
int status;
EGFX_SAMPLE_FILE files[3][4][4];
@ -947,12 +967,34 @@ int test_progressive_ms_sample(char* ms_sample_path)
status = test_progressive_load_files(ms_sample_path, files);
if (status < 0)
{
for(i=0; i<3; i++)
{
for (j=0; j<4; j++)
{
for (k=0; k<4; k++)
sample_file_free(&files[i][j][k]);
}
}
return -1;
}
status = test_progressive_load_bitmaps(ms_sample_path, bitmaps);
if (status < 0)
{
for(i=0; i<3; i++)
{
for (j=0; j<4; j++)
{
for (k=0; k<4; k++)
sample_file_free(&files[i][j][k]);
}
}
return -1;
}
count = 4;
@ -1000,6 +1042,18 @@ int test_progressive_ms_sample(char* ms_sample_path)
progressive_context_free(progressive);
for(i=0; i<3; i++)
{
for (j=0; j<4; j++)
{
for (k=0; k<4; k++)
{
sample_file_free(&bitmaps[i][j][k]);
sample_file_free(&files[i][j][k]);
}
}
}
_aligned_free(g_DstData);
return 0;
@ -1009,7 +1063,12 @@ int TestFreeRDPCodecProgressive(int argc, char* argv[])
{
char* ms_sample_path;
ms_sample_path = _strdup("/tmp/EGFX_PROGRESSIVE_MS_SAMPLE");
ms_sample_path = GetKnownSubPath(KNOWN_PATH_TEMP, "EGFX_PROGRESSIVE_MS_SAMPLE");
if (!ms_sample_path)
{
printf("Memory allocation failed\n");
return -1;
}
if (PathFileExistsA(ms_sample_path))
return test_progressive_ms_sample(ms_sample_path);

4
libfreerdp/codec/zgfx.c
View File

@ -337,6 +337,8 @@ int zgfx_decompress(ZGFX_CONTEXT* zgfx, BYTE* pSrcData, UINT32 SrcSize, BYTE** p
status = zgfx_decompress_segment(zgfx, &pSrcData[1], SrcSize - 1);
*ppDstData = (BYTE*) malloc(zgfx->OutputCount);
if (!*ppDstData)
return -1;
*pDstSize = zgfx->OutputCount;
CopyMemory(*ppDstData, zgfx->OutputBuffer, zgfx->OutputCount);
@ -355,6 +357,8 @@ int zgfx_decompress(ZGFX_CONTEXT* zgfx, BYTE* pSrcData, UINT32 SrcSize, BYTE** p
uncompressedSize = *((UINT32*) &pSrcData[3]); /* uncompressedSize (4 bytes) */
pConcatenated = (BYTE*) malloc(uncompressedSize);
if (!pConcatenated)
return -1;
*ppDstData = pConcatenated;
*pDstSize = uncompressedSize;

83
libfreerdp/common/addin.c
View File

@ -46,11 +46,17 @@ LPSTR freerdp_get_library_install_path()
cchPath = cchInstallPrefix + cchLibraryPath + 2;
pszPath = (LPSTR) malloc(cchPath + 1);
if (!pszPath)
return NULL;
CopyMemory(pszPath, pszInstallPrefix, cchInstallPrefix);
pszPath[cchInstallPrefix] = '\0';
NativePathCchAppendA(pszPath, cchPath + 1, pszLibraryPath);
if (FAILED(NativePathCchAppendA(pszPath, cchPath + 1, pszLibraryPath)))
{
free(pszPath);
return NULL;
}
return pszPath;
}
@ -69,11 +75,17 @@ LPSTR freerdp_get_dynamic_addin_install_path()
cchPath = cchInstallPrefix + cchAddinPath + 2;
pszPath = (LPSTR) malloc(cchPath + 1);
if (!pszPath)
return NULL;
CopyMemory(pszPath, pszInstallPrefix, cchInstallPrefix);
pszPath[cchInstallPrefix] = '\0';
NativePathCchAppendA(pszPath, cchPath + 1, pszAddinPath);
if (FAILED(NativePathCchAppendA(pszPath, cchPath + 1, pszAddinPath)))
{
free(pszPath);
return NULL;
}
return pszPath;
}
@ -98,7 +110,7 @@ void* freerdp_load_dynamic_addin(LPCSTR pszFileName, LPCSTR pszPath, LPCSTR pszE
bHasExt = TRUE;
cchFileName = strlen(pszFileName);
if (PathCchFindExtensionA(pszFileName, cchFileName + 1, &pszExt) != S_OK)
if (FAILED(PathCchFindExtensionA(pszFileName, cchFileName + 1, &pszExt)))
{
pszExt = PathGetSharedLibraryExtensionA(PATH_SHARED_LIB_EXT_WITH_DOT);
cchExt = strlen(pszExt);
@ -106,20 +118,39 @@ void* freerdp_load_dynamic_addin(LPCSTR pszFileName, LPCSTR pszPath, LPCSTR pszE
}
pszAddinInstallPath = freerdp_get_dynamic_addin_install_path();
if (!pszAddinInstallPath)
return NULL;
cchAddinInstallPath = strlen(pszAddinInstallPath);
cchFilePath = cchAddinInstallPath + cchFileName + 32;
pszFilePath = (LPSTR) malloc(cchFilePath + 1);
if (!pszFilePath)
{
free(pszAddinInstallPath);
return NULL;
}
if (bHasExt)
{
pszAddinFile = _strdup(pszFileName);
if (!pszAddinFile)
{
free(pszAddinInstallPath);
free(pszFilePath);
return NULL;
}
cchAddinFile = strlen(pszAddinFile);
}
else
{
cchAddinFile = cchFileName + cchExt + 2 + sizeof(CMAKE_SHARED_LIBRARY_PREFIX);
pszAddinFile = (LPSTR) malloc(cchAddinFile + 1);
if (!pszAddinFile)
{
free(pszAddinInstallPath);
free(pszFilePath);
return NULL;
}
sprintf_s(pszAddinFile, cchAddinFile, CMAKE_SHARED_LIBRARY_PREFIX"%s%s", pszFileName, pszExt);
cchAddinFile = strlen(pszAddinFile);
}
@ -161,6 +192,8 @@ void* freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPSTR pszSubsyste
{
cchFileName += strlen(pszName) + strlen(pszSubsystem) + strlen(pszType) + strlen(pszExtension);
pszFileName = (LPSTR) malloc(cchFileName);
if (!pszFileName)
return NULL;
sprintf_s(pszFileName, cchFileName, "%s%s-client-%s-%s.%s", pszPrefix, pszName, pszSubsystem, pszType, pszExtension);
cchFileName = strlen(pszFileName);
}
@ -168,6 +201,9 @@ void* freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPSTR pszSubsyste
{
cchFileName += strlen(pszName) + strlen(pszSubsystem) + strlen(pszExtension);
pszFileName = (LPSTR) malloc(cchFileName);
if (!pszFileName)
return NULL;
sprintf_s(pszFileName, cchFileName, "%s%s-client-%s.%s", pszPrefix, pszName, pszSubsystem, pszExtension);
cchFileName = strlen(pszFileName);
}
@ -175,6 +211,9 @@ void* freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPSTR pszSubsyste
{
cchFileName += strlen(pszName) + strlen(pszExtension);
pszFileName = (LPSTR) malloc(cchFileName);
if (!pszFileName)
return NULL;
sprintf_s(pszFileName, cchFileName, "%s%s-client.%s", pszPrefix, pszName, pszExtension);
cchFileName = strlen(pszFileName);
}
@ -192,6 +231,11 @@ void* freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPSTR pszSubsyste
cchEntryName = 64 + strlen(pszName);
pszEntryName = (LPSTR) malloc(cchEntryName + 1);
if (!pszEntryName)
{
free(pszFileName);
return NULL;
}
sprintf_s(pszEntryName, cchEntryName + 1, "freerdp_%s_client_subsystem_entry", pszName);
entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszEntryName);
@ -199,29 +243,22 @@ void* freerdp_load_dynamic_channel_addin_entry(LPCSTR pszName, LPSTR pszSubsyste
free(pszEntryName);
free(pszFileName);
if (entry)
return entry;
return entry;
}
/* channel add-in */
if (dwFlags & FREERDP_ADDIN_CHANNEL_STATIC)
entry = freerdp_load_dynamic_addin(pszFileName, NULL, "VirtualChannelEntry");
else if (dwFlags & FREERDP_ADDIN_CHANNEL_DYNAMIC)
entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DVCPluginEntry");
else if (dwFlags & FREERDP_ADDIN_CHANNEL_DEVICE)
entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DeviceServiceEntry");
else
{
/* channel add-in */
entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszType);
if (dwFlags & FREERDP_ADDIN_CHANNEL_STATIC)
entry = freerdp_load_dynamic_addin(pszFileName, NULL, "VirtualChannelEntry");
else if (dwFlags & FREERDP_ADDIN_CHANNEL_DYNAMIC)
entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DVCPluginEntry");
else if (dwFlags & FREERDP_ADDIN_CHANNEL_DEVICE)
entry = freerdp_load_dynamic_addin(pszFileName, NULL, "DeviceServiceEntry");
else
entry = freerdp_load_dynamic_addin(pszFileName, NULL, pszType);
free(pszFileName);
if (entry)
return entry;
}
return NULL;
free(pszFileName);
return entry;
}
static FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN freerdp_load_static_channel_addin_entry = NULL;

180
libfreerdp/common/assistance.c
View File

@ -140,9 +140,11 @@ int freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
}
tokens = (char**) malloc(sizeof(char*) * count);
if (!tokens)
{
free(str);
return -1;
}
count = 0;
tokens[count++] = str;
@ -161,12 +163,7 @@ int freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
file->MachinePorts = (UINT32*) calloc(count, sizeof(UINT32));
if (!file->MachineAddresses || !file->MachinePorts)
{
free(file->MachineAddresses);
free(file->MachinePorts);
free(tokens);
return -1;
}
goto out;
for (i = 0; i < count; i++)
{
@ -177,10 +174,7 @@ int freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
q = strchr(p, ':');
if (!q)
{
free(tokens);
return -1;
}
goto out;
q[0] = '\0';
q++;
@ -189,7 +183,7 @@ int freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
file->MachinePorts[i] = (UINT32) atoi(q);
if (!file->MachineAddresses[i])
return -1;
goto out;
q[-1] = ':';
}
@ -209,26 +203,43 @@ int freerdp_assistance_parse_address_list(rdpAssistanceFile* file, char* list)
q = strchr(p, ':');
if (!q)
{
free(tokens);
return -1;
}
goto out;
q[0] = '\0';
q++;
if (file->MachineAddress)
free(file->MachineAddress);
file->MachineAddress = _strdup(p);
if (!file->MachineAddress)
goto out;
file->MachinePort = (UINT32) atoi(q);
if (!file->MachineAddress)
return -1;
goto out;
break;
}
free(tokens);
free(str);
return 1;
out:
if (file->MachineAddresses)
{
for (i=0; i<count; i++)
free (file->MachineAddresses[i]);
}
free (file->MachineAddresses);
free (file->MachinePorts);
file->MachineCount = 0;
file->MachinePorts = NULL;
file->MachineAddresses = NULL;
free(tokens);
free(str);
return -1;
}
int freerdp_assistance_parse_connection_string1(rdpAssistanceFile* file)
@ -238,6 +249,7 @@ int freerdp_assistance_parse_connection_string1(rdpAssistanceFile* file)
int count;
int length;
char* tokens[8];
int ret;
/**
* <ProtocolVersion>,<protocolType>,<machineAddressList>,<assistantAccountPwd>,
@ -298,10 +310,13 @@ int freerdp_assistance_parse_connection_string1(rdpAssistanceFile* file)
if (!file->RASpecificParams)
return -1;
freerdp_assistance_parse_address_list(file, tokens[2]);
ret = freerdp_assistance_parse_address_list(file, tokens[2]);
free(str);
if (ret != 1)
return -1;
return 1;
}
@ -323,96 +338,92 @@ int freerdp_assistance_parse_connection_string1(rdpAssistanceFile* file)
int freerdp_assistance_parse_connection_string2(rdpAssistanceFile* file)
{
char* p;
char* q;
int port;
char* str;
size_t length;
char* tag;
char* end;
char* p;
int ret = -1;
str = file->ConnectionString2;
if (!strstr(str, "<E>"))
return -1;
if (!strstr(str, "<C>"))
return -1;
str = _strdup(file->ConnectionString2);
if (!str)
return -1;
p = strstr(str, "<E>");
if (!(tag = strstr(str, "<A")))
goto out_fail;
if (!p)
return -1;
/* Parse Auth String Node (<A>) */
end = strstr(tag, "/>");
if (!end)
goto out_fail;
p = strstr(str, "<C>");
if (!p)
return -1;
/* Auth String Node (<A>) */
p = strstr(str, "<A");
if (!p)
return -1;
p = strstr(p, "KH=\"");
*end = '\0';
p = strstr(tag, "KH=\"");
if (p)
{
char *q;
size_t length;
p += sizeof("KH=\"") - 1;
q = strchr(p, '"');
if (!q)
return -1;
goto out_fail;
length = q - p;
free(file->RASpecificParams);
file->RASpecificParams = (char*) malloc(length + 1);
if (!file->RASpecificParams)
return -1;
goto out_fail;
CopyMemory(file->RASpecificParams, p, length);
file->RASpecificParams[length] = '\0';
p += length;
}
if (p)
p = strstr(p, "ID=\"");
else
p = _strdup("ID=\"");
p = strstr(tag, "ID=\"");
if (p)
{
char *q;
size_t length;
p += sizeof("ID=\"") - 1;
q = strchr(p, '"');
if (!q)
return -1;
goto out_fail;
length = q - p;
free(file->RASessionId);
file->RASessionId = (char*) malloc(length + 1);
if (!file->RASessionId)
return -1;
goto out_fail;
CopyMemory(file->RASessionId, p, length);
file->RASessionId[length] = '\0';
p += length;
}
*end = '/';
if (p)
p = strstr(p, "<L P=\"");
else
p = _strdup("<L P=\"");
/* Parse <L last address is used */
p = strstr(str, "<L P=\"");
while (p)
{
char *q;
int port;
size_t length;
p += sizeof("<L P=\"") - 1;
q = strchr(p, '"');
if (!q)
return -1;
goto out_fail;
q[0] = '\0';
q++;
@ -422,14 +433,14 @@ int freerdp_assistance_parse_connection_string2(rdpAssistanceFile* file)
p = strstr(q, " N=\"");
if (!p)
return -1;
goto out_fail;
p += sizeof(" N=\"") - 1;
q = strchr(p, '"');
if (!q)
return -1;
goto out_fail;
q[0] = '\0';
q++;
@ -440,7 +451,11 @@ int freerdp_assistance_parse_connection_string2(rdpAssistanceFile* file)
{
if (strncmp(p, "169.254.", 8) != 0)
{
if (file->MachineAddress)
free(file->MachineAddress);
file->MachineAddress = _strdup(p);
if (!file->MachineAddress)
goto out_fail;
file->MachinePort = (UINT32) port;
break;
}
@ -449,9 +464,11 @@ int freerdp_assistance_parse_connection_string2(rdpAssistanceFile* file)
p = strstr(q, "<L P=\"");
}
ret = 1;
out_fail:
free(str);
return ret;
return 1;
}
char* freerdp_assistance_construct_expert_blob(const char* name, const char* pass)
@ -748,7 +765,7 @@ int freerdp_assistance_decrypt2(rdpAssistanceFile* file, const char* password)
status = freerdp_assistance_parse_connection_string2(file);
WLog_DBG(TAG, "freerdp_assistance_parse_connection_string2: %d", status);
return 1;
return status;
}
int freerdp_assistance_decrypt(rdpAssistanceFile* file, const char* password)
@ -825,6 +842,8 @@ char* freerdp_assistance_bin_to_hex_string(const BYTE* data, int size)
char bin2hex[] = "0123456789ABCDEF";
p = (char*) malloc((size + 1) * 2);
if (!p)
return NULL;
for (i = 0; i < size; i++)
{
@ -1129,21 +1148,21 @@ int freerdp_client_populate_settings_from_assistance_file(rdpAssistanceFile* fil
freerdp_set_param_bool(settings, FreeRDP_RemoteAssistanceMode, TRUE);
if (!file->RASessionId)
if (!file->RASessionId || !file->MachineAddress)
return -1;
freerdp_set_param_string(settings, FreeRDP_RemoteAssistanceSessionId, file->RASessionId);
if (file->RCTicket)
freerdp_set_param_string(settings, FreeRDP_RemoteAssistanceRCTicket, file->RCTicket);
if (file->PassStub)
freerdp_set_param_string(settings, FreeRDP_RemoteAssistancePassStub, file->PassStub);
if (!file->MachineAddress)
if (freerdp_set_param_string(settings, FreeRDP_RemoteAssistanceSessionId, file->RASessionId) != 0)
return -1;
if (file->RCTicket && (freerdp_set_param_string(settings, FreeRDP_RemoteAssistanceRCTicket, file->RCTicket) != 0))
return -1;
if (file->PassStub && (freerdp_set_param_string(settings, FreeRDP_RemoteAssistancePassStub, file->PassStub) != 0))
return -1;
if (freerdp_set_param_string(settings, FreeRDP_ServerHostname, file->MachineAddress) != 0)
return -1;
freerdp_set_param_string(settings, FreeRDP_ServerHostname, file->MachineAddress);
freerdp_set_param_uint32(settings, FreeRDP_ServerPort, file->MachinePort);
freerdp_target_net_addresses_free(settings);
@ -1173,16 +1192,7 @@ int freerdp_client_populate_settings_from_assistance_file(rdpAssistanceFile* fil
rdpAssistanceFile* freerdp_assistance_file_new()
{
rdpAssistanceFile* file;
file = (rdpAssistanceFile*) calloc(1, sizeof(rdpAssistanceFile));
if (file)
{
}
return file;
return (rdpAssistanceFile*) calloc(1, sizeof(rdpAssistanceFile));
}
void freerdp_assistance_file_free(rdpAssistanceFile* file)

206
libfreerdp/common/settings.c
View File

@ -51,7 +51,8 @@ int freerdp_addin_set_argument(ADDIN_ARGV* args, char* argument)
return -1;
args->argv = new_argv;
args->argc++;
args->argv[args->argc - 1] = _strdup(argument);
if (!(args->argv[args->argc - 1] = _strdup(argument)))
return -1;
return 0;
}
@ -66,7 +67,8 @@ int freerdp_addin_replace_argument(ADDIN_ARGV* args, char* previous, char* argum
if (strcmp(args->argv[i], previous) == 0)
{
free(args->argv[i]);
args->argv[i] = _strdup(argument);
if (!(args->argv[i] = _strdup(argument)))
return -1;
return 1;
}
@ -77,7 +79,8 @@ int freerdp_addin_replace_argument(ADDIN_ARGV* args, char* previous, char* argum
return -1;
args->argv = new_argv;
args->argc++;
args->argv[args->argc - 1] = _strdup(argument);
if (!(args->argv[args->argc - 1] = _strdup(argument)))
return -1;
return 0;
}
@ -92,6 +95,8 @@ int freerdp_addin_set_argument_value(ADDIN_ARGV* args, char* option, char* value
length = strlen(option) + strlen(value) + 1;
str = (char*) malloc(length + 1);
if (!str)
return -1;
sprintf_s(str, length + 1, "%s:%s", option, value);
for (i = 0; i < args->argc; i++)
@ -112,7 +117,11 @@ int freerdp_addin_set_argument_value(ADDIN_ARGV* args, char* option, char* value
new_argv = (char**) realloc(args->argv, sizeof(char*) * (args->argc + 1));
if (!new_argv)
{
free(str);
return -1;
}
args->argv = new_argv;
args->argc++;
args->argv[args->argc - 1] = str;
@ -129,6 +138,8 @@ int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, char* previous, char*
length = strlen(option) + strlen(value) + 1;
str = (char*) malloc(length + 1);
if (!str)
return -1;
sprintf_s(str, length + 1, "%s:%s", option, value);
for (i = 0; i < args->argc; i++)
@ -144,7 +155,10 @@ int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, char* previous, char*
new_argv = (char**) realloc(args->argv, sizeof(char*) * (args->argc + 1));
if (!new_argv)
{
free(str);
return -1;
}
args->argv = new_argv;
args->argc++;
args->argv[args->argc - 1] = str;
@ -152,10 +166,10 @@ int freerdp_addin_replace_argument_value(ADDIN_ARGV* args, char* previous, char*
return 0;
}
void freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device)
BOOL freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device)
{
if (!settings->DeviceArray)
return;
return FALSE;
if (settings->DeviceArraySize < (settings->DeviceCount + 1))
{
@ -166,12 +180,13 @@ void freerdp_device_collection_add(rdpSettings* settings, RDPDR_DEVICE* device)
new_array = (RDPDR_DEVICE**)
realloc(settings->DeviceArray, new_size * sizeof(RDPDR_DEVICE*));
if (!new_array)
return;
return FALSE;
settings->DeviceArray = new_array;
settings->DeviceArraySize = new_size;
}
settings->DeviceArray[settings->DeviceCount++] = device;
return TRUE;
}
RDPDR_DEVICE* freerdp_device_collection_find(rdpSettings* settings, const char* name)
@ -381,6 +396,9 @@ void freerdp_device_collection_free(rdpSettings* settings)
{
device = (RDPDR_DEVICE*) settings->DeviceArray[index];
if (!device)
continue;
free(device->Name);
if (settings->DeviceArray[index]->Type == RDPDR_DTYP_FILESYSTEM)
@ -415,10 +433,10 @@ void freerdp_device_collection_free(rdpSettings* settings)
settings->DeviceCount = 0;
}
void freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
BOOL freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
{
if (!settings->StaticChannelArray)
return;
return FALSE;
if (settings->StaticChannelArraySize < (settings->StaticChannelCount + 1))
{
@ -429,12 +447,13 @@ void freerdp_static_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* ch
new_array = (ADDIN_ARGV**)
realloc(settings->StaticChannelArray, new_size * sizeof(ADDIN_ARGV*));
if (!new_array)
return;
return FALSE;
settings->StaticChannelArray = new_array;
settings->StaticChannelArraySize = new_size;
}
settings->StaticChannelArray[settings->StaticChannelCount++] = channel;
return TRUE;
}
ADDIN_ARGV* freerdp_static_channel_collection_find(rdpSettings* settings, const char* name)
@ -491,6 +510,9 @@ void freerdp_static_channel_collection_free(rdpSettings* settings)
for (i = 0; i < settings->StaticChannelCount; i++)
{
if (!settings->StaticChannelArray[i])
continue;
for (j = 0; j < settings->StaticChannelArray[i]->argc; j++)
free(settings->StaticChannelArray[i]->argv[j]);
@ -505,30 +527,25 @@ void freerdp_static_channel_collection_free(rdpSettings* settings)
settings->StaticChannelCount = 0;
}
void freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
BOOL freerdp_dynamic_channel_collection_add(rdpSettings* settings, ADDIN_ARGV* channel)
{
if (!settings->DynamicChannelArray)
return;
return FALSE;
if (settings->DynamicChannelArraySize < (settings->DynamicChannelCount + 1))
{
UINT32 new_size;
ADDIN_ARGV **new_array;
settings->DynamicChannelArraySize *= 2;
settings->DynamicChannelArray = (ADDIN_ARGV**)
realloc(settings->DynamicChannelArray, settings->DynamicChannelArraySize * sizeof(ADDIN_ARGV*));
new_size = settings->DynamicChannelArraySize * 2;
new_array = (ADDIN_ARGV**)
realloc(settings->DynamicChannelArray, new_size * sizeof(ADDIN_ARGV*));
new_array = realloc(settings->DynamicChannelArray, settings->DynamicChannelArraySize * sizeof(ADDIN_ARGV*) * 2);
if (!new_array)
return;
return FALSE;
settings->DynamicChannelArraySize *= 2;
settings->DynamicChannelArray = new_array;
settings->DynamicChannelArraySize = new_size;
}
settings->DynamicChannelArray[settings->DynamicChannelCount++] = channel;
return TRUE;
}
ADDIN_ARGV* freerdp_dynamic_channel_collection_find(rdpSettings* settings, const char* name)
@ -588,6 +605,9 @@ void freerdp_dynamic_channel_collection_free(rdpSettings* settings)
for (i = 0; i < settings->DynamicChannelCount; i++)
{
if (!settings->DynamicChannelArray[i])
continue;
for (j = 0; j < settings->DynamicChannelArray[i]->argc; j++)
free(settings->DynamicChannelArray[i]->argv[j]);
@ -2432,231 +2452,191 @@ char* freerdp_get_param_string(rdpSettings* settings, int id)
int freerdp_set_param_string(rdpSettings* settings, int id, const char* param)
{
char **tmp = NULL;
if (!param)
return -1;
switch (id)
{
case FreeRDP_ServerHostname:
free(settings->ServerHostname);
settings->ServerHostname = _strdup(param);
tmp = &settings->ServerHostname;
break;
case FreeRDP_Username:
free(settings->Username);
settings->Username = _strdup(param);
tmp = &settings->Username;
break;
case FreeRDP_Password:
free(settings->Password);
settings->Password = _strdup(param);
tmp = &settings->Password;
break;
case FreeRDP_Domain:
free(settings->Domain);
settings->Domain = _strdup(param);
tmp = &settings->Domain;
break;
case FreeRDP_PasswordHash:
free(settings->PasswordHash);
settings->PasswordHash = _strdup(param);
tmp = &settings->PasswordHash;
break;
case FreeRDP_ClientHostname:
free(settings->ClientHostname);
settings->ClientHostname = _strdup(param);
tmp = &settings->ClientHostname;
break;
case FreeRDP_ClientProductId:
free(settings->ClientProductId);
settings->ClientProductId = _strdup(param);
tmp = &settings->ClientProductId;
break;
case FreeRDP_AlternateShell:
free(settings->AlternateShell);
settings->AlternateShell = _strdup(param);
tmp = &settings->AlternateShell;
break;
case FreeRDP_ShellWorkingDirectory:
free(settings->ShellWorkingDirectory);
settings->ShellWorkingDirectory = _strdup(param);
tmp = &settings->ShellWorkingDirectory;
break;
case FreeRDP_ClientAddress:
free(settings->ClientAddress);
settings->ClientAddress = _strdup(param);
tmp = &settings->ClientAddress;
break;
case FreeRDP_ClientDir:
free(settings->ClientDir);
settings->ClientDir = _strdup(param);
tmp = &settings->ClientDir;
break;
case FreeRDP_DynamicDSTTimeZoneKeyName:
free(settings->DynamicDSTTimeZoneKeyName);
settings->DynamicDSTTimeZoneKeyName = _strdup(param);
tmp = &settings->DynamicDSTTimeZoneKeyName;
break;
case FreeRDP_RemoteAssistanceSessionId:
free(settings->RemoteAssistanceSessionId);
settings->RemoteAssistanceSessionId = _strdup(param);
tmp = &settings->RemoteAssistanceSessionId;
break;
case FreeRDP_RemoteAssistancePassStub:
free(settings->RemoteAssistancePassStub);
settings->RemoteAssistancePassStub = _strdup(param);
tmp = &settings->RemoteAssistancePassStub;
break;
case FreeRDP_RemoteAssistancePassword:
free(settings->RemoteAssistancePassword);
settings->RemoteAssistancePassword = _strdup(param);
tmp = &settings->RemoteAssistancePassword;
break;
case FreeRDP_RemoteAssistanceRCTicket:
free(settings->RemoteAssistanceRCTicket);
settings->RemoteAssistanceRCTicket = _strdup(param);
tmp = &settings->RemoteAssistanceRCTicket;
break;
case FreeRDP_AuthenticationServiceClass:
free(settings->AuthenticationServiceClass);
settings->AuthenticationServiceClass = _strdup(param);
tmp = &settings->AuthenticationServiceClass;
break;
case FreeRDP_PreconnectionBlob:
free(settings->PreconnectionBlob);
settings->PreconnectionBlob = _strdup(param);
tmp = &settings->PreconnectionBlob;
break;
case FreeRDP_KerberosKdc:
free(settings->KerberosKdc);
settings->KerberosKdc = _strdup(param);
tmp = &settings->KerberosKdc;
break;
case FreeRDP_KerberosRealm:
free(settings->KerberosRealm);
settings->KerberosRealm = _strdup(param);
tmp = &settings->KerberosRealm;
break;
case FreeRDP_CertificateName:
free(settings->CertificateName);
settings->CertificateName = _strdup(param);
tmp = &settings->CertificateName;
break;
case FreeRDP_CertificateFile:
free(settings->CertificateFile);
settings->CertificateFile = _strdup(param);
tmp = &settings->CertificateFile;
break;
case FreeRDP_PrivateKeyFile:
free(settings->PrivateKeyFile);
settings->PrivateKeyFile = _strdup(param);
tmp = &settings->PrivateKeyFile;
break;
case FreeRDP_RdpKeyFile:
free(settings->RdpKeyFile);
settings->RdpKeyFile = _strdup(param);
tmp = &settings->RdpKeyFile;
break;
case FreeRDP_WindowTitle:
free(settings->WindowTitle);
settings->WindowTitle = _strdup(param);
tmp = &settings->WindowTitle;
break;
case FreeRDP_ComputerName:
free(settings->ComputerName);
settings->ComputerName = _strdup(param);
tmp = &settings->ComputerName;
break;
case FreeRDP_ConnectionFile:
free(settings->ConnectionFile);
settings->ConnectionFile = _strdup(param);
tmp = &settings->ConnectionFile;
break;
case FreeRDP_AssistanceFile:
free(settings->AssistanceFile);
settings->AssistanceFile = _strdup(param);
tmp = &settings->AssistanceFile;
break;
case FreeRDP_HomePath:
free(settings->HomePath);
settings->HomePath = _strdup(param);
tmp = &settings->HomePath;
break;
case FreeRDP_ConfigPath:
free(settings->ConfigPath);
settings->ConfigPath = _strdup(param);
tmp = &settings->ConfigPath;
break;
case FreeRDP_CurrentPath:
free(settings->CurrentPath);
settings->CurrentPath = _strdup(param);
tmp = &settings->CurrentPath;
break;
case FreeRDP_DumpRemoteFxFile:
free(settings->DumpRemoteFxFile);
settings->DumpRemoteFxFile = _strdup(param);
tmp = &settings->DumpRemoteFxFile;
break;
case FreeRDP_PlayRemoteFxFile:
free(settings->PlayRemoteFxFile);
settings->PlayRemoteFxFile = _strdup(param);
tmp = &settings->PlayRemoteFxFile;
break;
case FreeRDP_GatewayHostname:
free(settings->GatewayHostname);
settings->GatewayHostname = _strdup(param);
tmp = &settings->GatewayHostname;
break;
case FreeRDP_GatewayUsername:
free(settings->GatewayUsername);
settings->GatewayUsername = _strdup(param);
tmp = &settings->GatewayUsername;
break;
case FreeRDP_GatewayPassword:
free(settings->GatewayPassword);
settings->GatewayPassword = _strdup(param);
tmp = &settings->GatewayPassword;
break;
case FreeRDP_GatewayDomain:
free(settings->GatewayDomain);
settings->GatewayDomain = _strdup(param);
tmp = &settings->GatewayDomain;
break;
case FreeRDP_RemoteApplicationName:
free(settings->RemoteApplicationName);
settings->RemoteApplicationName = _strdup(param);
tmp = &settings->RemoteApplicationName;
break;
case FreeRDP_RemoteApplicationIcon:
free(settings->RemoteApplicationIcon);
settings->RemoteApplicationIcon = _strdup(param);
tmp = &settings->RemoteApplicationIcon;
break;
case FreeRDP_RemoteApplicationProgram:
free(settings->RemoteApplicationProgram);
settings->RemoteApplicationProgram = _strdup(param);
tmp = &settings->RemoteApplicationProgram;
break;
case FreeRDP_RemoteApplicationFile:
free(settings->RemoteApplicationFile);
settings->RemoteApplicationFile = _strdup(param);
tmp = &settings->RemoteApplicationFile;
break;
case FreeRDP_RemoteApplicationGuid:
free(settings->RemoteApplicationGuid);
settings->RemoteApplicationGuid = _strdup(param);
tmp = &settings->RemoteApplicationGuid;
break;
case FreeRDP_RemoteApplicationCmdLine:
free(settings->RemoteApplicationCmdLine);
settings->RemoteApplicationCmdLine = _strdup(param);
tmp = &settings->RemoteApplicationCmdLine;
break;
case FreeRDP_ImeFileName:
free(settings->ImeFileName);
settings->ImeFileName = _strdup(param);
tmp = &settings->ImeFileName;
break;
case FreeRDP_DrivesToRedirect:
free(settings->DrivesToRedirect);
settings->DrivesToRedirect = _strdup(param);
tmp = &settings->DrivesToRedirect;
break;
default:
@ -2664,6 +2644,10 @@ int freerdp_set_param_string(rdpSettings* settings, int id, const char* param)
return -1;
}
free(*tmp);
if (!(*tmp = _strdup(param)))
return -1;
/* Mark field as modified */
settings->SettingsModified[id] = 1;

26
libfreerdp/common/test/TestCommonAssistance.c
View File

@ -4,9 +4,9 @@
#include <freerdp/assistance.h>
const char* TEST_MSRC_INCIDENT_PASSWORD_TYPE1 = "Password1";
const char TEST_MSRC_INCIDENT_PASSWORD_TYPE1[] = "Password1";
static const char* TEST_MSRC_INCIDENT_FILE_TYPE1 =
static const char TEST_MSRC_INCIDENT_FILE_TYPE1[] =
"<?xml version=\"1.0\" encoding=\"Unicode\" ?>"
"<UPLOADINFO TYPE=\"Escalated\">"
"<UPLOADDATA "
@ -24,9 +24,9 @@ const BYTE TEST_MSRC_INCIDENT_EXPERT_BLOB_TYPE1[32] =
"\x3C\x9C\xAE\x0B\xCE\x7A\xB1\x5C\x8A\xAC\x01\xD6\x76\x04\x5E\xDF"
"\x3F\xFA\xF0\x92\xE2\xDE\x36\x8A\x20\x17\xE6\x8A\x0D\xED\x7C\x90";
const char* TEST_MSRC_INCIDENT_PASSWORD_TYPE2 = "48BJQ853X3B4";
const char TEST_MSRC_INCIDENT_PASSWORD_TYPE2[] = "48BJQ853X3B4";
static const char* TEST_MSRC_INCIDENT_FILE_TYPE2 =
static const char TEST_MSRC_INCIDENT_FILE_TYPE2[] =
"<?xml version=\"1.0\"?>"
"<UPLOADINFO TYPE=\"Escalated\">"
"<UPLOADDATA USERNAME=\"awake\" "
@ -85,6 +85,9 @@ int test_msrsc_incident_file_type1()
file = freerdp_assistance_file_new();
if (!file)
return -1;
status = freerdp_assistance_parse_file_buffer(file,
TEST_MSRC_INCIDENT_FILE_TYPE1, sizeof(TEST_MSRC_INCIDENT_FILE_TYPE1));
@ -136,6 +139,9 @@ int test_msrsc_incident_file_type2()
file = freerdp_assistance_file_new();
if (!file)
return -1;
status = freerdp_assistance_parse_file_buffer(file,
TEST_MSRC_INCIDENT_FILE_TYPE2, sizeof(TEST_MSRC_INCIDENT_FILE_TYPE2));
@ -174,9 +180,17 @@ int test_msrsc_incident_file_type2()
int TestCommonAssistance(int argc, char* argv[])
{
test_msrsc_incident_file_type1();
if (test_msrsc_incident_file_type1() != 0)
{
printf("test_msrsc_incident_file_type1 failed\n");
return -1;
}
test_msrsc_incident_file_type2();
if (test_msrsc_incident_file_type2() != 0)
{
printf("test_msrsc_incident_file_type1 failed\n");
return -1;
}
return 0;
}

25
libfreerdp/core/certificate.c
View File

@ -791,6 +791,8 @@ rdpCertificate* certificate_clone(rdpCertificate* certificate)
if (certificate->cert_info.ModulusLength)
{
_certificate->cert_info.Modulus = (BYTE*) malloc(certificate->cert_info.ModulusLength);
if (!_certificate->cert_info.Modulus)
goto out_fail;
CopyMemory(_certificate->cert_info.Modulus, certificate->cert_info.Modulus, certificate->cert_info.ModulusLength);
_certificate->cert_info.ModulusLength = certificate->cert_info.ModulusLength;
}
@ -798,11 +800,15 @@ rdpCertificate* certificate_clone(rdpCertificate* certificate)
if (certificate->x509_cert_chain)
{
_certificate->x509_cert_chain = (rdpX509CertChain*) malloc(sizeof(rdpX509CertChain));
if (!_certificate->x509_cert_chain)
goto out_fail;
CopyMemory(_certificate->x509_cert_chain, certificate->x509_cert_chain, sizeof(rdpX509CertChain));
if (certificate->x509_cert_chain->count)
{
_certificate->x509_cert_chain->array = (rdpCertBlob*) calloc(certificate->x509_cert_chain->count, sizeof(rdpCertBlob));
if (!_certificate->x509_cert_chain->array)
goto out_fail;
for (index = 0; index < certificate->x509_cert_chain->count; index++)
{
@ -811,6 +817,15 @@ rdpCertificate* certificate_clone(rdpCertificate* certificate)
if (certificate->x509_cert_chain->array[index].length)
{
_certificate->x509_cert_chain->array[index].data = (BYTE*) malloc(certificate->x509_cert_chain->array[index].length);
if (!_certificate->x509_cert_chain->array[index].data)
{
for (--index; index >= 0; --index)
{
if (certificate->x509_cert_chain->array[index].length)
free(_certificate->x509_cert_chain->array[index].data);
}
goto out_fail;
}
CopyMemory(_certificate->x509_cert_chain->array[index].data, certificate->x509_cert_chain->array[index].data,
_certificate->x509_cert_chain->array[index].length);
}
@ -819,6 +834,16 @@ 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);
return NULL;
}
/**

4
libfreerdp/core/client.c
View File

@ -237,6 +237,8 @@ int freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle, CHANNEL_EVENT_CONNECTED, hostname, hostnameLength);
name = (char*) malloc(9);
if (!name)
return -1;
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';
@ -449,6 +451,8 @@ int freerdp_channels_disconnect(rdpChannels* channels, freerdp* instance)
pChannelOpenData = &channels->openDataList[index];
name = (char*) malloc(9);
if (!name)
return -1;
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';

24
libfreerdp/core/connection.c
View File

@ -334,11 +334,13 @@ BOOL rdp_client_redirect(rdpRdp* rdp)
rdpSettings* settings = rdp->settings;
rdp_client_disconnect(rdp);
rdp_redirection_apply_settings(rdp);
if (rdp_redirection_apply_settings(rdp) != 0)
return FALSE;
if (settings->RedirectionFlags & LB_LOAD_BALANCE_INFO)
{
nego_set_routing_token(rdp->nego, settings->LoadBalanceInfo, settings->LoadBalanceInfoLength);
if (!nego_set_routing_token(rdp->nego, settings->LoadBalanceInfo, settings->LoadBalanceInfoLength))
return FALSE;
}
else
{
@ -346,16 +348,22 @@ BOOL rdp_client_redirect(rdpRdp* rdp)
{
free(settings->ServerHostname);
settings->ServerHostname = _strdup(settings->RedirectionTargetFQDN);
if (!settings->ServerHostname)
return FALSE;
}
else if (settings->RedirectionFlags & LB_TARGET_NET_ADDRESS)
{
free(settings->ServerHostname);
settings->ServerHostname = _strdup(settings->TargetNetAddress);
if (!settings->ServerHostname)
return FALSE;
}
else if (settings->RedirectionFlags & LB_TARGET_NETBIOS_NAME)
{
free(settings->ServerHostname);
settings->ServerHostname = _strdup(settings->RedirectionTargetNetBiosName);
if (!settings->ServerHostname)
return FALSE;
}
}
@ -363,12 +371,16 @@ BOOL rdp_client_redirect(rdpRdp* rdp)
{
free(settings->Username);
settings->Username = _strdup(settings->RedirectionUsername);
if (!settings->Username)
return FALSE;
}
if (settings->RedirectionFlags & LB_DOMAIN)
{
free(settings->Domain);
settings->Domain = _strdup(settings->RedirectionDomain);
if (!settings->Domain)
return FALSE;
}
status = rdp_client_connect(rdp);
@ -388,7 +400,7 @@ BOOL rdp_client_reconnect(rdpRdp* rdp)
status = rdp_client_connect(rdp);
if (status)
freerdp_channels_post_connect(channels, context->instance);
status = (freerdp_channels_post_connect(channels, context->instance) >= 0);
return status;
}
@ -826,7 +838,11 @@ int rdp_client_connect_demand_active(rdpRdp* rdp, wStream* s)
if (!rdp_send_confirm_active(rdp))
return -1;
input_register_client_callbacks(rdp->input);
if (!input_register_client_callbacks(rdp->input))
{
WLog_ERR(TAG, "error registering client callbacks");
return -1;
}
/**
* The server may request a different desktop size during Deactivation-Reactivation sequence.

56
libfreerdp/core/fastpath.c
View File

@ -263,13 +263,19 @@ static int fastpath_recv_update(rdpFastPath* fastpath, BYTE updateCode, UINT32 s
{
case FASTPATH_UPDATETYPE_ORDERS:
if (!fastpath_recv_orders(fastpath, s))
{
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_ORDERS - fastpath_recv_orders()");
return -1;
}
break;
case FASTPATH_UPDATETYPE_BITMAP:
case FASTPATH_UPDATETYPE_PALETTE:
if (!fastpath_recv_update_common(fastpath, s))
{
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_ORDERS - fastpath_recv_orders()");
return -1;
}
break;
case FASTPATH_UPDATETYPE_SYNCHRONIZE:
@ -281,6 +287,8 @@ static int fastpath_recv_update(rdpFastPath* fastpath, BYTE updateCode, UINT32 s
case FASTPATH_UPDATETYPE_SURFCMDS:
status = update_recv_surfcmds(update, size, s);
if (status < 0)
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_SURFCMDS - update_recv_surfcmds() - %i", status);
break;
case FASTPATH_UPDATETYPE_PTR_NULL:
@ -291,30 +299,41 @@ static int fastpath_recv_update(rdpFastPath* fastpath, BYTE updateCode, UINT32 s
case FASTPATH_UPDATETYPE_PTR_DEFAULT:
update->pointer->pointer_system.type = SYSPTR_DEFAULT;
IFCALL(pointer->PointerSystem, context, &pointer->pointer_system);
break;
case FASTPATH_UPDATETYPE_PTR_POSITION:
if (!update_read_pointer_position(s, &pointer->pointer_position))
{
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_PTR_POSITION - update_read_pointer_position()");
return -1;
}
IFCALL(pointer->PointerPosition, context, &pointer->pointer_position);
break;
case FASTPATH_UPDATETYPE_COLOR:
if (!update_read_pointer_color(s, &pointer->pointer_color, 24))
{
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_COLOR - update_read_pointer_color()");
return -1;
}
IFCALL(pointer->PointerColor, context, &pointer->pointer_color);
break;
case FASTPATH_UPDATETYPE_CACHED:
if (!update_read_pointer_cached(s, &pointer->pointer_cached))
{
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_CACHED - update_read_pointer_cached()");
return -1;
}
IFCALL(pointer->PointerCached, context, &pointer->pointer_cached);
break;
case FASTPATH_UPDATETYPE_POINTER:
if (!update_read_pointer_new(s, &pointer->pointer_new))
{
WLog_ERR(TAG, "FASTPATH_UPDATETYPE_POINTER - update_read_pointer_new()");
return -1;
}
IFCALL(pointer->PointerNew, context, &pointer->pointer_new);
break;
@ -371,7 +390,10 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
Stream_Read_UINT16(s, size);
if (Stream_GetRemainingLength(s) < size)
{
WLog_ERR(TAG, "Stream_GetRemainingLength() < size");
return -1;
}
cs = s;
next_pos = Stream_GetPosition(s) + size;
@ -380,7 +402,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
if (bulkStatus < 0)
{
WLog_ERR(TAG, "bulk_decompress() failed");
WLog_ERR(TAG, "bulk_decompress() failed");
return -1;
}
@ -402,7 +424,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
{
if (fastpath->fragmentation != -1)
{
WLog_ERR(TAG, "Unexpected FASTPATH_FRAGMENT_SINGLE");
WLog_ERR(TAG, "Unexpected FASTPATH_FRAGMENT_SINGLE");
goto out_fail;
}
@ -410,7 +432,10 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
status = fastpath_recv_update(fastpath, updateCode, totalSize, cs);
if (status < 0)
{
WLog_ERR(TAG, "fastpath_recv_update() - %i", status);
goto out_fail;
}
}
else
{
@ -418,7 +443,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
{
if (fastpath->fragmentation != -1)
{
WLog_ERR(TAG, "Unexpected FASTPATH_FRAGMENT_FIRST");
WLog_ERR(TAG, "fastpath_recv_update_data: Unexpected FASTPATH_FRAGMENT_FIRST");
goto out_fail;
}
@ -428,7 +453,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
if (totalSize > transport->settings->MultifragMaxRequestSize)
{
WLog_ERR(TAG, "Total size (%d) exceeds MultifragMaxRequestSize (%d)",
WLog_ERR(TAG, "Total size (%d) exceeds MultifragMaxRequestSize (%d)",
totalSize, transport->settings->MultifragMaxRequestSize);
goto out_fail;
}
@ -445,7 +470,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
if ((fastpath->fragmentation != FASTPATH_FRAGMENT_FIRST) &&
(fastpath->fragmentation != FASTPATH_FRAGMENT_NEXT))
{
WLog_ERR(TAG, "Unexpected FASTPATH_FRAGMENT_NEXT");
WLog_ERR(TAG, "fastpath_recv_update_data: Unexpected FASTPATH_FRAGMENT_NEXT");
goto out_fail;
}
@ -455,7 +480,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
if (totalSize > transport->settings->MultifragMaxRequestSize)
{
WLog_ERR(TAG, "Total size (%d) exceeds MultifragMaxRequestSize (%d)",
WLog_ERR(TAG, "Total size (%d) exceeds MultifragMaxRequestSize (%d)",
totalSize, transport->settings->MultifragMaxRequestSize);
goto out_fail;
}
@ -473,7 +498,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
if ((fastpath->fragmentation != FASTPATH_FRAGMENT_FIRST) &&
(fastpath->fragmentation != FASTPATH_FRAGMENT_NEXT))
{
WLog_ERR(TAG, "Unexpected FASTPATH_FRAGMENT_LAST");
WLog_ERR(TAG, "fastpath_recv_update_data: Unexpected FASTPATH_FRAGMENT_LAST");
goto out_fail;
}
@ -483,7 +508,7 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
if (totalSize > transport->settings->MultifragMaxRequestSize)
{
WLog_ERR(TAG, "Total size (%d) exceeds MultifragMaxRequestSize (%d)",
WLog_ERR(TAG, "Total size (%d) exceeds MultifragMaxRequestSize (%d)",
totalSize, transport->settings->MultifragMaxRequestSize);
goto out_fail;
}
@ -504,7 +529,10 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
Stream_Release(fastpath->updateData);
if (status < 0)
{
WLog_ERR(TAG, "fastpath_recv_update_data: fastpath_recv_update() - %i", status);
goto out_fail;
}
}
}
@ -526,7 +554,6 @@ out_fail:
int fastpath_recv_updates(rdpFastPath* fastpath, wStream* s)
{
int status = 0;
rdpUpdate* update = fastpath->rdp->update;
IFCALL(update->BeginPaint, update->context);
@ -534,12 +561,15 @@ int fastpath_recv_updates(rdpFastPath* fastpath, wStream* s)
while (Stream_GetRemainingLength(s) >= 3)
{
if (fastpath_recv_update_data(fastpath, s) < 0)
{
WLog_ERR(TAG, "fastpath_recv_update_data() fail");
return -1;
}
}
IFCALL(update->EndPaint, update->context);
return status;
return 0;
}
static BOOL fastpath_read_input_event_header(wStream* s, BYTE* eventFlags, BYTE* eventCode)
@ -683,7 +713,7 @@ static BOOL fastpath_recv_input_event(rdpFastPath* fastpath, wStream* s)
break;
default:
WLog_ERR(TAG, "Unknown eventCode %d", eventCode);
WLog_ERR(TAG, "Unknown eventCode %d", eventCode);
break;
}
@ -794,7 +824,7 @@ BOOL fastpath_send_multiple_input_pdu(rdpFastPath* fastpath, wStream* s, int iNu
if (length >= (2 << 14))
{
WLog_ERR(TAG, "Maximum FastPath PDU length is 32767");
WLog_ERR(TAG, "Maximum FastPath PDU length is 32767");
return FALSE;
}

9
libfreerdp/core/freerdp.c
View File

@ -210,6 +210,7 @@ BOOL freerdp_check_fds(freerdp* instance)
TerminateEventArgs e;
rdpContext* context = instance->context;
WLog_DBG(TAG, "rdp_check_fds() - %i", status);
EventArgsInit(&e, "freerdp");
e.code = 0;
PubSub_OnTerminate(context->pubSub, context, &e);
@ -244,9 +245,17 @@ BOOL freerdp_check_event_handles(rdpContext* context)
status = freerdp_check_fds(context->instance);
if (!status)
{
WLog_ERR(TAG, "freerdp_check_fds() failed - %i", status);
return FALSE;
}
status = freerdp_channels_check_fds(context->channels, context->instance);
if (!status)
{
WLog_ERR(TAG, "freerdp_channels_check_fds() failed - %i", status);
return FALSE;
}
return status;
}

Some files were not shown because too many files have changed in this diff Show More