void xf_toggle_fullscreen(xfContext* xfc)
{
WindowStateChangeEventArgs e;
rdpContext* context = (rdpContext*) xfc;
rdpSettings* settings = context->settings;
xfc->fullscreen = (xfc->fullscreen) ? FALSE : TRUE;
xfc->decorations = (xfc->fullscreen) ? FALSE : settings->Decorations;
xf_SetWindowFullscreen(xfc, xfc->window, xfc->fullscreen);
EventArgsInit(&e, "xfreerdp");
e.state = xfc->fullscreen ? FREERDP_WINDOW_STATE_FULLSCREEN : 0;
PubSub_OnWindowStateChange(context->pubSub, context, &e);
}
UINT freerdp_channels_disconnect(rdpChannels* channels, freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
char* name;
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_CLIENT_DATA* pChannelClientData;
if (!channels->connected)
return 0;
channels->connected = 0;
freerdp_channels_check_fds(channels, instance);
/* tell all libraries we are shutting down */
for (index = 0; index < channels->clientDataCount; index++)
{
ChannelDisconnectedEventArgs e;
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
pChannelClientData->pChannelInitEventProc(
pChannelClientData->pInitHandle,
CHANNEL_EVENT_DISCONNECTED, 0, 0);
if (getChannelError(instance->context) != CHANNEL_RC_OK)
goto fail;
pChannelOpenData = &channels->openDataList[index];
name = (char*) malloc(9);
if (!name)
return -1;
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
free(name);
}
fail:
return error;
}
void xf_toggle_fullscreen(xfContext* xfc)
{
Pixmap contents = 0;
WindowStateChangeEventArgs e;
xf_lock_x11(xfc, TRUE);
contents = XCreatePixmap(xfc->display, xfc->window->handle, xfc->width, xfc->height, xfc->depth);
XCopyArea(xfc->display, xfc->primary, contents, xfc->gc, 0, 0, xfc->width, xfc->height, 0, 0);
XDestroyWindow(xfc->display, xfc->window->handle);
xfc->fullscreen = (xfc->fullscreen) ? FALSE : TRUE;
xf_create_window(xfc);
XCopyArea(xfc->display, contents, xfc->primary, xfc->gc, 0, 0, xfc->width, xfc->height, 0, 0);
XFreePixmap(xfc->display, contents);
xf_unlock_x11(xfc, TRUE);
EventArgsInit(&e, "xfreerdp");
e.state = xfc->fullscreen ? FREERDP_WINDOW_STATE_FULLSCREEN : 0;
PubSub_OnWindowStateChange(((rdpContext *) xfc)->pubSub, xfc, &e);
}
UINT freerdp_channels_disconnect(rdpChannels* channels, freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_CLIENT_DATA* pChannelClientData;
if (!channels->connected)
return 0;
freerdp_channels_check_fds(channels, instance);
/* tell all libraries we are shutting down */
for (index = 0; index < channels->clientDataCount; index++)
{
ChannelDisconnectedEventArgs e;
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
{
pChannelClientData->pChannelInitEventProc(
pChannelClientData->pInitHandle, CHANNEL_EVENT_DISCONNECTED, 0, 0);
}
else if (pChannelClientData->pChannelInitEventProcEx)
{
pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
pChannelClientData->pInitHandle, CHANNEL_EVENT_DISCONNECTED, 0, 0);
}
if (getChannelError(instance->context) != CHANNEL_RC_OK)
continue;
pChannelOpenData = &channels->openDataList[index];
EventArgsInit(&e, "freerdp");
e.name = pChannelOpenData->name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
}
channels->connected = FALSE;
return error;
}
UINT freerdp_channels_detach(freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
char* hostname;
int hostnameLength;
rdpChannels* channels;
CHANNEL_CLIENT_DATA* pChannelClientData;
channels = instance->context->channels;
hostname = instance->settings->ServerHostname;
hostnameLength = (int) strlen(hostname);
for (index = 0; index < channels->clientDataCount; index++)
{
ChannelDetachedEventArgs e;
CHANNEL_OPEN_DATA* pChannelOpenData;
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
{
pChannelClientData->pChannelInitEventProc(
pChannelClientData->pInitHandle, CHANNEL_EVENT_DETACHED, hostname, hostnameLength);
}
else if (pChannelClientData->pChannelInitEventProcEx)
{
pChannelClientData->pChannelInitEventProcEx(pChannelClientData->lpUserParam,
pChannelClientData->pInitHandle, CHANNEL_EVENT_DETACHED, hostname, hostnameLength);
}
if (getChannelError(instance->context) != CHANNEL_RC_OK)
goto fail;
pChannelOpenData = &channels->openDataList[index];
EventArgsInit(&e, "freerdp");
e.name = pChannelOpenData->name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelDetached(instance->context->pubSub, instance->context, &e);
}
fail:
return error;
}
void freerdp_channels_close(rdpChannels* channels, freerdp* instance)
{
int index;
char* name;
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_CLIENT_DATA* pChannelClientData;
DEBUG_CHANNELS("closing");
channels->is_connected = 0;
freerdp_channels_check_fds(channels, instance);
/* tell all libraries we are shutting down */
for (index = 0; index < channels->clientDataCount; index++)
{
ChannelDisconnectedEventArgs e;
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle, CHANNEL_EVENT_TERMINATED, 0, 0);
pChannelOpenData = &channels->openDataList[index];
name = (char*) malloc(9);
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
free(name);
}
/* Emit a quit signal to the internal message pipe. */
MessagePipe_PostQuit(channels->MsgPipe, 0);
}
BOOL rdp_set_error_info(rdpRdp* rdp, UINT32 errorInfo)
{
rdp->errorInfo = errorInfo;
if (rdp->errorInfo != ERRINFO_SUCCESS)
{
ErrorInfoEventArgs e;
rdpContext* context = rdp->instance->context;
rdp->context->LastError = MAKE_FREERDP_ERROR(ERRINFO, errorInfo);
rdp_print_errinfo(rdp->errorInfo);
EventArgsInit(&e, "freerdp");
e.code = rdp->errorInfo;
PubSub_OnErrorInfo(context->pubSub, context, &e);
}
else
{
rdp->context->LastError = FREERDP_ERROR_SUCCESS;
}
return TRUE;
}
BOOL freerdp_check_fds(freerdp* instance)
{
int status;
rdpRdp* rdp;
rdp = instance->context->rdp;
status = rdp_check_fds(rdp);
if (status < 0)
{
TerminateEventArgs e;
rdpContext* context = instance->context;
EventArgsInit(&e, "freerdp");
e.code = 0;
PubSub_OnTerminate(context->pubSub, context, &e);
return FALSE;
}
return TRUE;
}
int freerdp_set_param_double(rdpSettings* settings, int id, double param)
{
ParamChangeEventArgs e;
rdpContext* context = ((freerdp*) settings->instance)->context;
switch (id)
{
case FreeRDP_ScalingFactor:
settings->ScalingFactor = param;
break;
default:
return -1;
break;
}
settings->settings_modified[id] = 1;
EventArgsInit(&e, "freerdp");
e.id = id;
PubSub_OnParamChange(context->pubSub, context, &e);
return 0;
}
BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym)
{
XF_MODIFIER_KEYS mod = { 0 };
xk_keyboard_get_modifier_keys(xfc, &mod);
if (!xf_keyboard_execute_action_script(xfc, &mod, keysym))
{
return TRUE;
}
if(xfc->fullscreen_toggle)
{
if (keysym == XK_Return)
{
if (mod.Ctrl && mod.Alt)
{
/* Ctrl-Alt-Enter: toggle full screen */
xf_toggle_fullscreen(xfc);
return TRUE;
}
}
}
if ((keysym == XK_c) || (keysym == XK_C))
{
if (mod.Ctrl && mod.Alt)
{
/* Ctrl-Alt-C: toggle control */
xf_toggle_control(xfc);
return TRUE;
}
}
if (keysym == XK_period)
{
if (mod.Ctrl && mod.Alt)
{
/* Zoom In (scale larger) */
double s = xfc->settings->ScalingFactor;
s += 0.1;
if (s > 2.0)
s = 2.0;
xfc->settings->ScalingFactor = s;
xfc->currentWidth = xfc->originalWidth * s;
xfc->currentHeight = xfc->originalHeight * s;
xf_transform_window(xfc);
{
ResizeWindowEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.width = (int) xfc->originalWidth * xfc->settings->ScalingFactor;
e.height = (int) xfc->originalHeight * xfc->settings->ScalingFactor;
PubSub_OnResizeWindow(((rdpContext*) xfc)->pubSub, xfc, &e);
}
xf_draw_screen_scaled(xfc, 0, 0, 0, 0, FALSE);
return TRUE;
}
}
if (keysym == XK_comma)
{
if (mod.Ctrl && mod.Alt)
{
/* Zoom Out (scale smaller) */
double s = xfc->settings->ScalingFactor;
s -= 0.1;
if (s < 0.5)
s = 0.5;
xfc->settings->ScalingFactor = s;
xfc->currentWidth = xfc->originalWidth * s;
xfc->currentHeight = xfc->originalHeight * s;
xf_transform_window(xfc);
{
ResizeWindowEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.width = (int) xfc->originalWidth * xfc->settings->ScalingFactor;
e.height = (int) xfc->originalHeight * xfc->settings->ScalingFactor;
PubSub_OnResizeWindow(((rdpContext*) xfc)->pubSub, xfc, &e);
}
xf_draw_screen_scaled(xfc, 0, 0, 0, 0, FALSE);
return TRUE;
}
}
if (keysym == XK_KP_4)
{
if (mod.Ctrl && mod.Alt)
{
{
PanningChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.XPan = -5;
e.YPan = 0;
PubSub_OnPanningChange(((rdpContext*) xfc)->pubSub, xfc, &e);
}
return TRUE;
}
}
if (keysym == XK_KP_6)
{
if (mod.Ctrl && mod.Alt)
{
{
PanningChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.XPan = 5;
e.YPan = 0;
PubSub_OnPanningChange(((rdpContext*) xfc)->pubSub, xfc, &e);
}
return TRUE;
}
}
if (keysym == XK_KP_8)
{
if (mod.Ctrl && mod.Alt)
{
{
PanningChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.XPan = 0;
e.YPan = -5;
PubSub_OnPanningChange(((rdpContext*) xfc)->pubSub, xfc, &e);
}
return TRUE;
}
}
if (keysym == XK_KP_2)
{
if (mod.Ctrl && mod.Alt)
{
{
PanningChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.XPan = 0;
e.YPan = 5;
PubSub_OnPanningChange(((rdpContext*) xfc)->pubSub, xfc, &e);
}
return TRUE;
}
}
return FALSE;
}
/**
* Function description
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT rdpgfx_recv_reset_graphics_pdu(RDPGFX_CHANNEL_CALLBACK* callback,
wStream* s)
{
int pad;
UINT32 index;
MONITOR_DEF* monitor;
RDPGFX_RESET_GRAPHICS_PDU pdu;
RDPGFX_PLUGIN* gfx = (RDPGFX_PLUGIN*) callback->plugin;
RdpgfxClientContext* context = (RdpgfxClientContext*) gfx->iface.pInterface;
UINT error = CHANNEL_RC_OK;
GraphicsResetEventArgs graphicsReset;
if (Stream_GetRemainingLength(s) < 12)
{
WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");
return ERROR_INVALID_DATA;
}
Stream_Read_UINT32(s, pdu.width); /* width (4 bytes) */
Stream_Read_UINT32(s, pdu.height); /* height (4 bytes) */
Stream_Read_UINT32(s, pdu.monitorCount); /* monitorCount (4 bytes) */
if (Stream_GetRemainingLength(s) < (pdu.monitorCount * 20))
{
WLog_Print(gfx->log, WLOG_ERROR, "not enough data!");
return ERROR_INVALID_DATA;
}
pdu.monitorDefArray = (MONITOR_DEF*) calloc(pdu.monitorCount, sizeof(MONITOR_DEF));
if (!pdu.monitorDefArray)
{
WLog_Print(gfx->log, WLOG_ERROR, "calloc failed!");
return CHANNEL_RC_NO_MEMORY;
}
for (index = 0; index < pdu.monitorCount; index++)
{
monitor = &(pdu.monitorDefArray[index]);
Stream_Read_UINT32(s, monitor->left); /* left (4 bytes) */
Stream_Read_UINT32(s, monitor->top); /* top (4 bytes) */
Stream_Read_UINT32(s, monitor->right); /* right (4 bytes) */
Stream_Read_UINT32(s, monitor->bottom); /* bottom (4 bytes) */
Stream_Read_UINT32(s, monitor->flags); /* flags (4 bytes) */
}
pad = 340 - (RDPGFX_HEADER_SIZE + 12 + (pdu.monitorCount * 20));
if (Stream_GetRemainingLength(s) < (size_t) pad)
{
WLog_Print(gfx->log, WLOG_ERROR, "Stream_GetRemainingLength failed!");
free(pdu.monitorDefArray);
return CHANNEL_RC_NO_MEMORY;
}
Stream_Seek(s, pad); /* pad (total size is 340 bytes) */
WLog_Print(gfx->log, WLOG_DEBUG, "RecvResetGraphicsPdu: width: %"PRIu32" height: %"PRIu32" count: %"PRIu32"",
pdu.width, pdu.height, pdu.monitorCount);
for (index = 0; index < pdu.monitorCount; index++)
{
monitor = &(pdu.monitorDefArray[index]);
WLog_Print(gfx->log, WLOG_DEBUG,
"RecvResetGraphicsPdu: monitor left:%"PRIi32" top:%"PRIi32" right:%"PRIi32" left:%"PRIi32" flags:0x%"PRIx32"",
monitor->left, monitor->top, monitor->right, monitor->bottom, monitor->flags);
}
if (context)
{
IFCALLRET(context->ResetGraphics, error, context, &pdu);
if (error)
WLog_Print(gfx->log, WLOG_ERROR, "context->ResetGraphics failed with error %"PRIu32"", error);
}
/* some listeners may be interested (namely the display channel) */
EventArgsInit(&graphicsReset, "xfreerdp");
graphicsReset.width = pdu.width;
graphicsReset.height = pdu.height;
PubSub_OnGraphicsReset(gfx->rdpcontext->pubSub, gfx->rdpcontext, &graphicsReset);
free(pdu.monitorDefArray);
return error;
}
int freerdp_set_param_uint32(rdpSettings* settings, int id, UINT32 param)
{
ParamChangeEventArgs e;
rdpContext* context = ((freerdp*) settings->instance)->context;
switch (id)
{
case FreeRDP_ShareId:
settings->ShareId = param;
break;
case FreeRDP_PduSource:
settings->PduSource = param;
break;
case FreeRDP_ServerPort:
settings->ServerPort = param;
break;
case FreeRDP_RdpVersion:
settings->RdpVersion = param;
break;
case FreeRDP_DesktopWidth:
settings->DesktopWidth = param;
break;
case FreeRDP_DesktopHeight:
settings->DesktopHeight = param;
break;
case FreeRDP_ColorDepth:
settings->ColorDepth = param;
break;
case FreeRDP_ConnectionType:
settings->ConnectionType = param;
break;
case FreeRDP_ClientBuild:
settings->ClientBuild = param;
break;
case FreeRDP_EarlyCapabilityFlags:
settings->EarlyCapabilityFlags = param;
break;
case FreeRDP_EncryptionMethods:
settings->EncryptionMethods = param;
break;
case FreeRDP_ExtEncryptionMethods:
settings->ExtEncryptionMethods = param;
break;
case FreeRDP_EncryptionLevel:
settings->EncryptionLevel = param;
break;
case FreeRDP_ChannelCount:
settings->ChannelCount = param;
break;
case FreeRDP_ChannelDefArraySize:
settings->ChannelDefArraySize = param;
break;
case FreeRDP_ClusterInfoFlags:
settings->ClusterInfoFlags = param;
break;
case FreeRDP_RedirectedSessionId:
settings->RedirectedSessionId = param;
break;
case FreeRDP_MonitorDefArraySize:
settings->MonitorDefArraySize = param;
break;
case FreeRDP_DesktopPosX:
settings->DesktopPosX = param;
break;
case FreeRDP_DesktopPosY:
settings->DesktopPosY = param;
break;
case FreeRDP_MultitransportFlags:
settings->MultitransportFlags = param;
break;
case FreeRDP_AutoReconnectMaxRetries:
settings->AutoReconnectMaxRetries = param;
break;
case FreeRDP_PerformanceFlags:
settings->PerformanceFlags = param;
break;
case FreeRDP_RequestedProtocols:
settings->RequestedProtocols = param;
break;
case FreeRDP_SelectedProtocol:
settings->SelectedProtocol = param;
break;
case FreeRDP_NegotiationFlags:
settings->NegotiationFlags = param;
break;
case FreeRDP_CookieMaxLength:
settings->CookieMaxLength = param;
break;
case FreeRDP_PreconnectionId:
settings->PreconnectionId = param;
break;
case FreeRDP_RedirectionFlags:
settings->RedirectionFlags = param;
break;
case FreeRDP_LoadBalanceInfoLength:
settings->LoadBalanceInfoLength = param;
break;
case FreeRDP_RedirectionUsernameLength:
settings->RedirectionUsernameLength = param;
break;
case FreeRDP_RedirectionDomainLength:
settings->RedirectionDomainLength = param;
break;
case FreeRDP_RedirectionPasswordLength:
settings->RedirectionPasswordLength = param;
break;
case FreeRDP_RedirectionTargetFQDNLength:
settings->RedirectionTargetFQDNLength = param;
break;
case FreeRDP_RedirectionTargetNetBiosNameLength:
settings->RedirectionTargetNetBiosNameLength = param;
break;
case FreeRDP_RedirectionTsvUrlLength:
settings->RedirectionTsvUrlLength = param;
break;
case FreeRDP_TargetNetAddressCount:
settings->TargetNetAddressCount = param;
break;
case FreeRDP_PercentScreen:
settings->PercentScreen = param;
break;
case FreeRDP_GatewayUsageMethod:
settings->GatewayUsageMethod = param;
break;
case FreeRDP_GatewayPort:
settings->GatewayPort = param;
break;
case FreeRDP_GatewayCredentialsSource:
settings->GatewayCredentialsSource = param;
break;
case FreeRDP_RemoteAppNumIconCaches:
settings->RemoteAppNumIconCaches = param;
break;
case FreeRDP_RemoteAppNumIconCacheEntries:
settings->RemoteAppNumIconCacheEntries = param;
break;
case FreeRDP_ReceivedCapabilitiesSize:
settings->ReceivedCapabilitiesSize = param;
break;
case FreeRDP_OsMajorType:
settings->OsMajorType = param;
break;
case FreeRDP_OsMinorType:
settings->OsMinorType = param;
break;
case FreeRDP_BitmapCacheVersion:
settings->BitmapCacheVersion = param;
break;
case FreeRDP_BitmapCacheV2NumCells:
settings->BitmapCacheV2NumCells = param;
break;
case FreeRDP_PointerCacheSize:
settings->PointerCacheSize = param;
break;
case FreeRDP_KeyboardLayout:
settings->KeyboardLayout = param;
break;
case FreeRDP_KeyboardType:
settings->KeyboardType = param;
break;
case FreeRDP_KeyboardSubType:
settings->KeyboardSubType = param;
break;
case FreeRDP_KeyboardFunctionKey:
settings->KeyboardFunctionKey = param;
break;
case FreeRDP_BrushSupportLevel:
settings->BrushSupportLevel = param;
break;
case FreeRDP_GlyphSupportLevel:
settings->GlyphSupportLevel = param;
break;
case FreeRDP_OffscreenSupportLevel:
settings->OffscreenSupportLevel = param;
break;
case FreeRDP_OffscreenCacheSize:
settings->OffscreenCacheSize = param;
break;
case FreeRDP_OffscreenCacheEntries:
settings->OffscreenCacheEntries = param;
break;
case FreeRDP_VirtualChannelCompressionFlags:
settings->VirtualChannelCompressionFlags = param;
break;
case FreeRDP_VirtualChannelChunkSize:
settings->VirtualChannelChunkSize = param;
break;
case FreeRDP_MultifragMaxRequestSize:
settings->MultifragMaxRequestSize = param;
break;
case FreeRDP_LargePointerFlag:
settings->LargePointerFlag = param;
break;
case FreeRDP_CompDeskSupportLevel:
settings->CompDeskSupportLevel = param;
break;
case FreeRDP_RemoteFxCodecId:
settings->RemoteFxCodecId = param;
break;
case FreeRDP_RemoteFxCodecMode:
settings->RemoteFxCodecMode = param;
break;
case FreeRDP_NSCodecId:
settings->NSCodecId = param;
break;
case FreeRDP_JpegCodecId:
settings->JpegCodecId = param;
break;
case FreeRDP_JpegQuality:
settings->JpegQuality = param;
break;
case FreeRDP_BitmapCacheV3CodecId:
settings->BitmapCacheV3CodecId = param;
break;
case FreeRDP_DrawNineGridCacheSize:
settings->DrawNineGridCacheSize = param;
break;
case FreeRDP_DrawNineGridCacheEntries:
settings->DrawNineGridCacheEntries = param;
break;
case FreeRDP_DeviceCount:
settings->DeviceCount = param;
break;
case FreeRDP_DeviceArraySize:
settings->DeviceArraySize = param;
break;
case FreeRDP_StaticChannelCount:
settings->StaticChannelCount = param;
break;
case FreeRDP_StaticChannelArraySize:
settings->StaticChannelArraySize = param;
break;
case FreeRDP_DynamicChannelCount:
settings->DynamicChannelCount = param;
break;
case FreeRDP_DynamicChannelArraySize:
settings->DynamicChannelArraySize = param;
break;
default:
return -1;
break;
}
// Mark field as modified
settings->settings_modified[id] = 1;
EventArgsInit(&e, "freerdp");
e.id = id;
PubSub_OnParamChange(context->pubSub, context, &e);
return 0;
}
/**
* go through and inform all the libraries that we are connected
* this will tell the libraries that its ok to call MyVirtualChannelOpen
* called only from main thread
*/
UINT freerdp_channels_post_connect(rdpChannels* channels, freerdp* instance)
{
UINT error = CHANNEL_RC_OK;
int index;
char* name = NULL;
char* hostname;
int hostnameLength;
CHANNEL_CLIENT_DATA* pChannelClientData;
channels->connected = 1;
hostname = instance->settings->ServerHostname;
hostnameLength = (int) strlen(hostname);
for (index = 0; index < channels->clientDataCount; index++)
{
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
{
ChannelConnectedEventArgs e;
CHANNEL_OPEN_DATA* pChannelOpenData;
pChannelOpenData = &channels->openDataList[index];
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
CHANNEL_EVENT_CONNECTED, hostname, hostnameLength);
if (getChannelError(instance->context) != CHANNEL_RC_OK)
goto fail;
name = (char*) malloc(9);
if (!name)
{
error = CHANNEL_RC_NO_MEMORY;
goto fail;
}
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e);
free(name);
name = NULL;
}
}
channels->drdynvc = (DrdynvcClientContext*) freerdp_channels_get_static_channel_interface(channels, "drdynvc");
if (channels->drdynvc)
{
channels->drdynvc->custom = (void*) channels;
channels->drdynvc->OnChannelConnected = freerdp_drdynvc_on_channel_connected;
channels->drdynvc->OnChannelDisconnected = freerdp_drdynvc_on_channel_disconnected;
}
fail:
free (name);
return error;
}
BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym)
{
XF_MODIFIER_KEYS mod = { 0 };
xk_keyboard_get_modifier_keys(xfc, &mod);
if (!xf_keyboard_execute_action_script(xfc, &mod, keysym))
{
return TRUE;
}
if(!xfc->remote_app && xfc->fullscreen_toggle)
{
if (keysym == XK_Return)
{
WLog_DBG(TAG, "X keycode 0x%x, Ctrl: %d, Alt: %d", keysym, mod.Ctrl, mod.Alt);
if (mod.Ctrl && mod.Alt)
{
/* Ctrl-Alt-Enter: toggle full screen */
xf_toggle_fullscreen(xfc);
return TRUE;
}
}
}
if (!xfc->remote_app)
{
if ((keysym == XK_Tab) || (keysym == XK_Left) || (keysym == XK_Right))
{
WLog_DBG(TAG, "X keycode 0x%x, Ctrl: %d, Alt: %d", keysym, mod.Ctrl, mod.Alt);
if (mod.Ctrl && mod.Alt)
{
/* Works in either full screen or windowed.
* If in fullscreen or cursor inside window - need to do
* "double" ctrl-alt-* key press and release...
* 1st ctrl-alt-[tab-left-right] releases from x11 key binding
* 2nd ctrl-alt-[tab-left-right] executes OS system key binding
* Note: If windowed and cursor is not in freerdp window, ie.,
* on tile bar, this doesnt apply and ctrl-alt-[tab-left-right]
* key press will work as OS system key binding.
*/
XUngrabKeyboard(xfc->display, CurrentTime);
return TRUE;
}
}
}
if ((keysym == XK_c) || (keysym == XK_C))
{
if (mod.Ctrl && mod.Alt)
{
/* Ctrl-Alt-C: toggle control */
xf_toggle_control(xfc);
return TRUE;
}
}
#if 0 /* set to 1 to enable multi touch gesture simulation via keyboard */
#ifdef WITH_XRENDER
if (!xfc->remote_app && xfc->settings->MultiTouchGestures)
{
if (mod.Ctrl && mod.Alt)
{
int pdx = 0;
int pdy = 0;
int zdx = 0;
int zdy = 0;
switch(keysym)
{
case XK_0: /* Ctrl-Alt-0: Reset scaling and panning */
xfc->scaledWidth = xfc->sessionWidth;
xfc->scaledHeight = xfc->sessionHeight;
xfc->offset_x = 0;
xfc->offset_y = 0;
if (!xfc->fullscreen && (xfc->sessionWidth != xfc->window->width ||
xfc->sessionHeight != xfc->window->height))
{
xf_ResizeDesktopWindow(xfc, xfc->window, xfc->sessionWidth, xfc->sessionHeight);
}
xf_draw_screen(xfc, 0, 0, xfc->sessionWidth, xfc->sessionHeight);
return TRUE;
case XK_1: /* Ctrl-Alt-1: Zoom in */
zdx = zdy = 10;
break;
case XK_2: /* Ctrl-Alt-2: Zoom out */
zdx = zdy = -10;
break;
case XK_3: /* Ctrl-Alt-3: Pan left */
pdx = -10;
break;
case XK_4: /* Ctrl-Alt-4: Pan right */
pdx = 10;
break;
case XK_5: /* Ctrl-Alt-5: Pan up */
pdy = -10;
break;
case XK_6: /* Ctrl-Alt-6: Pan up */
pdy = 10;
break;
}
if (pdx != 0 || pdy != 0)
{
PanningChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.dx = pdx;
e.dy = pdy;
PubSub_OnPanningChange(((rdpContext*) xfc)->pubSub, xfc, &e);
return TRUE;
}
if (zdx != 0 || zdy != 0)
{
ZoomingChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.dx = zdx;
e.dy = zdy;
PubSub_OnZoomingChange(((rdpContext*) xfc)->pubSub, xfc, &e);
return TRUE;
}
}
}
#endif /* WITH_XRENDER defined */
#endif /* pinch/zoom/pan simulation */
return FALSE;
}
int freerdp_set_param_string(rdpSettings* settings, int id, char* param)
{
ParamChangeEventArgs e;
rdpContext* context = ((freerdp*) settings->instance)->context;
switch (id)
{
case FreeRDP_ServerHostname:
settings->ServerHostname = _strdup(param);
break;
case FreeRDP_Username:
settings->Username = _strdup(param);
break;
case FreeRDP_Password:
settings->Password = _strdup(param);
break;
case FreeRDP_Domain:
settings->Domain = _strdup(param);
break;
case FreeRDP_ClientHostname:
settings->ClientHostname = _strdup(param);
break;
case FreeRDP_ClientProductId:
settings->ClientProductId = _strdup(param);
break;
case FreeRDP_AlternateShell:
settings->AlternateShell = _strdup(param);
break;
case FreeRDP_ShellWorkingDirectory:
settings->ShellWorkingDirectory = _strdup(param);
break;
case FreeRDP_ClientAddress:
settings->ClientAddress = _strdup(param);
break;
case FreeRDP_ClientDir:
settings->ClientDir = _strdup(param);
break;
case FreeRDP_DynamicDSTTimeZoneKeyName:
settings->DynamicDSTTimeZoneKeyName = _strdup(param);
break;
case FreeRDP_PreconnectionBlob:
settings->PreconnectionBlob = _strdup(param);
break;
case FreeRDP_KerberosKdc:
settings->KerberosKdc = _strdup(param);
break;
case FreeRDP_KerberosRealm:
settings->KerberosRealm = _strdup(param);
break;
case FreeRDP_CertificateName:
settings->CertificateName = _strdup(param);
break;
case FreeRDP_CertificateFile:
settings->CertificateFile = _strdup(param);
break;
case FreeRDP_PrivateKeyFile:
settings->PrivateKeyFile = _strdup(param);
break;
case FreeRDP_RdpKeyFile:
settings->RdpKeyFile = _strdup(param);
break;
case FreeRDP_WindowTitle:
settings->WindowTitle = _strdup(param);
break;
case FreeRDP_ComputerName:
settings->ComputerName = _strdup(param);
break;
case FreeRDP_ConnectionFile:
settings->ConnectionFile = _strdup(param);
break;
case FreeRDP_HomePath:
settings->HomePath = _strdup(param);
break;
case FreeRDP_ConfigPath:
settings->ConfigPath = _strdup(param);
break;
case FreeRDP_CurrentPath:
settings->CurrentPath = _strdup(param);
break;
case FreeRDP_DumpRemoteFxFile:
settings->DumpRemoteFxFile = _strdup(param);
break;
case FreeRDP_PlayRemoteFxFile:
settings->PlayRemoteFxFile = _strdup(param);
break;
case FreeRDP_GatewayHostname:
settings->GatewayHostname = _strdup(param);
break;
case FreeRDP_GatewayUsername:
settings->GatewayUsername = _strdup(param);
break;
case FreeRDP_GatewayPassword:
settings->GatewayPassword = _strdup(param);
break;
case FreeRDP_GatewayDomain:
settings->GatewayDomain = _strdup(param);
break;
case FreeRDP_RemoteApplicationName:
settings->RemoteApplicationName = _strdup(param);
break;
case FreeRDP_RemoteApplicationIcon:
settings->RemoteApplicationIcon = _strdup(param);
break;
case FreeRDP_RemoteApplicationProgram:
settings->RemoteApplicationProgram = _strdup(param);
break;
case FreeRDP_RemoteApplicationFile:
settings->RemoteApplicationFile = _strdup(param);
break;
case FreeRDP_RemoteApplicationGuid:
settings->RemoteApplicationGuid = _strdup(param);
break;
case FreeRDP_RemoteApplicationCmdLine:
settings->RemoteApplicationCmdLine = _strdup(param);
break;
case FreeRDP_ImeFileName:
settings->ImeFileName = _strdup(param);
break;
case FreeRDP_DrivesToRedirect:
settings->DrivesToRedirect = _strdup(param);
break;
default:
return -1;
break;
}
// Mark field as modified
settings->settings_modified[id] = 1;
EventArgsInit(&e, "freerdp");
e.id = id;
PubSub_OnParamChange(context->pubSub, context, &e);
return 0;
}
int rpc_client_on_fragment_received_event(rdpRpc* rpc)
{
BYTE* buffer;
UINT32 StubOffset;
UINT32 StubLength;
wStream* fragment;
rpcconn_hdr_t* header;
freerdp* instance;
instance = (freerdp*) rpc->transport->settings->instance;
if (!rpc->client->pdu)
rpc->client->pdu = rpc_client_receive_pool_take(rpc);
fragment = Queue_Dequeue(rpc->client->FragmentQueue);
buffer = (BYTE*) Stream_Buffer(fragment);
header = (rpcconn_hdr_t*) Stream_Buffer(fragment);
if (rpc->State < RPC_CLIENT_STATE_CONTEXT_NEGOTIATED)
{
rpc->client->pdu->Flags = 0;
rpc->client->pdu->CallId = header->common.call_id;
Stream_EnsureCapacity(rpc->client->pdu->s, Stream_Length(fragment));
Stream_Write(rpc->client->pdu->s, buffer, Stream_Length(fragment));
Stream_Length(rpc->client->pdu->s) = Stream_GetPosition(rpc->client->pdu->s);
rpc_client_fragment_pool_return(rpc, fragment);
Queue_Enqueue(rpc->client->ReceiveQueue, rpc->client->pdu);
SetEvent(rpc->transport->ReceiveEvent);
rpc->client->pdu = NULL;
return 0;
}
if (header->common.ptype == PTYPE_RTS)
{
if (rpc->VirtualConnection->State >= VIRTUAL_CONNECTION_STATE_OPENED)
{
//fprintf(stderr, "Receiving Out-of-Sequence RTS PDU\n");
rts_recv_out_of_sequence_pdu(rpc, buffer, header->common.frag_length);
rpc_client_fragment_pool_return(rpc, fragment);
}
else
{
fprintf(stderr, "warning: unhandled RTS PDU\n");
}
return 0;
}
else if (header->common.ptype == PTYPE_FAULT)
{
rpc_recv_fault_pdu(header);
return -1;
}
if (header->common.ptype != PTYPE_RESPONSE)
{
fprintf(stderr, "Unexpected RPC PDU type: %d\n", header->common.ptype);
return -1;
}
rpc->VirtualConnection->DefaultOutChannel->BytesReceived += header->common.frag_length;
rpc->VirtualConnection->DefaultOutChannel->ReceiverAvailableWindow -= header->common.frag_length;
if (!rpc_get_stub_data_info(rpc, buffer, &StubOffset, &StubLength))
{
fprintf(stderr, "rpc_recv_pdu_fragment: expected stub\n");
return -1;
}
if (StubLength == 4)
{
//fprintf(stderr, "Ignoring TsProxySendToServer Response\n");
printf("Got stub length 4 with flags %d and callid %d\n", header->common.pfc_flags, header->common.call_id);
/* received a disconnect request from the server? */
if ((header->common.call_id == rpc->PipeCallId) && (header->common.pfc_flags & PFC_LAST_FRAG))
{
TerminateEventArgs e;
instance->context->rdp->disconnect = TRUE;
rpc->transport->tsg->state = TSG_STATE_TUNNEL_CLOSE_PENDING;
EventArgsInit(&e, "freerdp");
e.code = 0;
PubSub_OnTerminate(instance->context->pubSub, instance->context, &e);
}
rpc_client_fragment_pool_return(rpc, fragment);
return 0;
}
Stream_EnsureCapacity(rpc->client->pdu->s, header->response.alloc_hint);
buffer = (BYTE*) Stream_Buffer(fragment);
header = (rpcconn_hdr_t*) Stream_Buffer(fragment);
if (rpc->StubFragCount == 0)
rpc->StubCallId = header->common.call_id;
if (rpc->StubCallId != header->common.call_id)
{
fprintf(stderr, "invalid call_id: actual: %d, expected: %d, frag_count: %d\n",
rpc->StubCallId, header->common.call_id, rpc->StubFragCount);
}
Stream_Write(rpc->client->pdu->s, &buffer[StubOffset], StubLength);
rpc->StubFragCount++;
rpc_client_fragment_pool_return(rpc, fragment);
if (rpc->VirtualConnection->DefaultOutChannel->ReceiverAvailableWindow < (rpc->ReceiveWindow / 2))
{
//fprintf(stderr, "Sending Flow Control Ack PDU\n");
rts_send_flow_control_ack_pdu(rpc);
}
/**
* If alloc_hint is set to a nonzero value and a request or a response is fragmented into multiple
* PDUs, implementations of these extensions SHOULD set the alloc_hint field in every PDU to be the
* combined stub data length of all remaining fragment PDUs.
*/
if (header->response.alloc_hint == StubLength)
{
rpc->client->pdu->Flags = RPC_PDU_FLAG_STUB;
rpc->client->pdu->CallId = rpc->StubCallId;
Stream_Length(rpc->client->pdu->s) = Stream_GetPosition(rpc->client->pdu->s);
rpc->StubFragCount = 0;
rpc->StubCallId = 0;
Queue_Enqueue(rpc->client->ReceiveQueue, rpc->client->pdu);
rpc->client->pdu = NULL;
return 0;
}
return 0;
}
BOOL rdp_read_header(rdpRdp* rdp, wStream* s, UINT16* length, UINT16* channelId)
{
BYTE byte;
UINT16 initiator;
enum DomainMCSPDU MCSPDU;
MCSPDU = (rdp->settings->ServerMode) ? DomainMCSPDU_SendDataRequest : DomainMCSPDU_SendDataIndication;
if (!mcs_read_domain_mcspdu_header(s, &MCSPDU, length))
{
if (MCSPDU != DomainMCSPDU_DisconnectProviderUltimatum)
return FALSE;
}
if ((size_t) (*length - 8) > Stream_GetRemainingLength(s))
return FALSE;
if (MCSPDU == DomainMCSPDU_DisconnectProviderUltimatum)
{
int reason = 0;
TerminateEventArgs e;
rdpContext* context;
if (!mcs_recv_disconnect_provider_ultimatum(rdp->mcs, s, &reason))
return FALSE;
if (rdp->instance == NULL)
{
rdp->disconnect = TRUE;
return FALSE;
}
context = rdp->instance->context;
if (rdp->errorInfo == ERRINFO_SUCCESS)
{
/**
* Some servers like Windows Server 2008 R2 do not send the error info pdu
* when the user logs off like they should. Map DisconnectProviderUltimatum
* to a ERRINFO_LOGOFF_BY_USER when the errinfo code is ERRINFO_SUCCESS.
*/
if (reason == MCS_Reason_provider_initiated)
rdp_set_error_info(rdp, ERRINFO_RPC_INITIATED_DISCONNECT);
else if (reason == MCS_Reason_user_requested)
rdp_set_error_info(rdp, ERRINFO_LOGOFF_BY_USER);
else
rdp_set_error_info(rdp, ERRINFO_RPC_INITIATED_DISCONNECT);
}
DEBUG_WARN( "DisconnectProviderUltimatum: reason: %d\n", reason);
rdp->disconnect = TRUE;
EventArgsInit(&e, "freerdp");
e.code = 0;
PubSub_OnTerminate(context->pubSub, context, &e);
return TRUE;
}
if (Stream_GetRemainingLength(s) < 5)
return FALSE;
per_read_integer16(s, &initiator, MCS_BASE_CHANNEL_ID); /* initiator (UserId) */
per_read_integer16(s, channelId, 0); /* channelId */
Stream_Read_UINT8(s, byte); /* dataPriority + Segmentation (0x70) */
if (!per_read_length(s, length)) /* userData (OCTET_STRING) */
return FALSE;
if (*length > Stream_GetRemainingLength(s))
return FALSE;
return TRUE;
}
int freerdp_set_param_bool(rdpSettings* settings, int id, BOOL param)
{
ParamChangeEventArgs e;
rdpContext* context = ((freerdp*) settings->instance)->context;
switch (id)
{
case FreeRDP_ServerMode:
settings->ServerMode = param;
break;
case FreeRDP_NetworkAutoDetect:
settings->NetworkAutoDetect = param;
break;
case FreeRDP_SupportAsymetricKeys:
settings->SupportAsymetricKeys = param;
break;
case FreeRDP_SupportErrorInfoPdu:
settings->SupportErrorInfoPdu = param;
break;
case FreeRDP_SupportStatusInfoPdu:
settings->SupportStatusInfoPdu = param;
break;
case FreeRDP_SupportMonitorLayoutPdu:
settings->SupportMonitorLayoutPdu = param;
break;
case FreeRDP_SupportGraphicsPipeline:
settings->SupportGraphicsPipeline = param;
break;
case FreeRDP_SupportDynamicTimeZone:
settings->SupportDynamicTimeZone = param;
break;
case FreeRDP_DisableEncryption:
settings->DisableEncryption = param;
break;
case FreeRDP_ConsoleSession:
settings->ConsoleSession = param;
break;
case FreeRDP_SpanMonitors:
settings->SpanMonitors = param;
break;
case FreeRDP_UseMultimon:
settings->UseMultimon = param;
break;
case FreeRDP_ForceMultimon:
settings->ForceMultimon = param;
break;
case FreeRDP_AutoLogonEnabled:
settings->AutoLogonEnabled = param;
break;
case FreeRDP_CompressionEnabled:
settings->CompressionEnabled = param;
break;
case FreeRDP_DisableCtrlAltDel:
settings->DisableCtrlAltDel = param;
break;
case FreeRDP_EnableWindowsKey:
settings->EnableWindowsKey = param;
break;
case FreeRDP_MaximizeShell:
settings->MaximizeShell = param;
break;
case FreeRDP_LogonNotify:
settings->LogonNotify = param;
break;
case FreeRDP_LogonErrors:
settings->LogonErrors = param;
break;
case FreeRDP_MouseAttached:
settings->MouseAttached = param;
break;
case FreeRDP_MouseHasWheel:
settings->MouseHasWheel = param;
break;
case FreeRDP_RemoteConsoleAudio:
settings->RemoteConsoleAudio = param;
break;
case FreeRDP_AudioPlayback:
settings->AudioPlayback = param;
break;
case FreeRDP_AudioCapture:
settings->AudioCapture = param;
break;
case FreeRDP_VideoDisable:
settings->VideoDisable = param;
break;
case FreeRDP_PasswordIsSmartcardPin:
settings->PasswordIsSmartcardPin = param;
break;
case FreeRDP_UsingSavedCredentials:
settings->UsingSavedCredentials = param;
break;
case FreeRDP_ForceEncryptedCsPdu:
settings->ForceEncryptedCsPdu = param;
break;
case FreeRDP_IPv6Enabled:
settings->IPv6Enabled = param;
break;
case FreeRDP_AutoReconnectionEnabled:
settings->AutoReconnectionEnabled = param;
break;
case FreeRDP_DynamicDaylightTimeDisabled:
settings->DynamicDaylightTimeDisabled = param;
break;
case FreeRDP_AllowFontSmoothing:
settings->AllowFontSmoothing = param;
break;
case FreeRDP_DisableWallpaper:
settings->DisableWallpaper = param;
break;
case FreeRDP_DisableFullWindowDrag:
settings->DisableFullWindowDrag = param;
break;
case FreeRDP_DisableMenuAnims:
settings->DisableMenuAnims = param;
break;
case FreeRDP_DisableThemes:
settings->DisableThemes = param;
break;
case FreeRDP_DisableCursorShadow:
settings->DisableCursorShadow = param;
break;
case FreeRDP_DisableCursorBlinking:
settings->DisableCursorBlinking = param;
break;
case FreeRDP_AllowDesktopComposition:
settings->AllowDesktopComposition = param;
break;
case FreeRDP_TlsSecurity:
settings->TlsSecurity = param;
break;
case FreeRDP_NlaSecurity:
settings->NlaSecurity = param;
break;
case FreeRDP_RdpSecurity:
settings->RdpSecurity = param;
break;
case FreeRDP_ExtSecurity:
settings->ExtSecurity = param;
break;
case FreeRDP_Authentication:
settings->Authentication = param;
break;
case FreeRDP_NegotiateSecurityLayer:
settings->NegotiateSecurityLayer = param;
break;
case FreeRDP_MstscCookieMode:
settings->MstscCookieMode = param;
break;
case FreeRDP_SendPreconnectionPdu:
settings->SendPreconnectionPdu = param;
break;
case FreeRDP_IgnoreCertificate:
settings->IgnoreCertificate = param;
break;
case FreeRDP_Workarea:
settings->Workarea = param;
break;
case FreeRDP_Fullscreen:
settings->Fullscreen = param;
break;
case FreeRDP_GrabKeyboard:
settings->GrabKeyboard = param;
break;
case FreeRDP_Decorations:
settings->Decorations = param;
break;
case FreeRDP_SmartSizing:
settings->SmartSizing = param;
break;
case FreeRDP_MouseMotion:
settings->MouseMotion = param;
break;
case FreeRDP_AsyncInput:
settings->AsyncInput = param;
break;
case FreeRDP_AsyncUpdate:
settings->AsyncUpdate = param;
break;
case FreeRDP_AsyncChannels:
settings->AsyncChannels = param;
break;
case FreeRDP_ToggleFullscreen:
settings->ToggleFullscreen = param;
break;
case FreeRDP_SoftwareGdi:
settings->SoftwareGdi = param;
break;
case FreeRDP_LocalConnection:
settings->LocalConnection = param;
break;
case FreeRDP_AuthenticationOnly:
settings->AuthenticationOnly = param;
break;
case FreeRDP_CredentialsFromStdin:
settings->CredentialsFromStdin = param;
break;
case FreeRDP_DumpRemoteFx:
settings->DumpRemoteFx = param;
break;
case FreeRDP_PlayRemoteFx:
settings->PlayRemoteFx = param;
break;
case FreeRDP_GatewayUseSameCredentials:
settings->GatewayUseSameCredentials = param;
break;
case FreeRDP_GatewayEnabled:
settings->GatewayEnabled = param;
break;
case FreeRDP_RemoteApplicationMode:
settings->RemoteApplicationMode = param;
break;
case FreeRDP_RemoteAppLanguageBarSupported:
settings->RemoteAppLanguageBarSupported = param;
break;
case FreeRDP_RefreshRect:
settings->RefreshRect = param;
break;
case FreeRDP_SuppressOutput:
settings->SuppressOutput = param;
break;
case FreeRDP_FastPathOutput:
settings->FastPathOutput = param;
break;
case FreeRDP_SaltedChecksum:
settings->SaltedChecksum = param;
break;
case FreeRDP_LongCredentialsSupported:
settings->LongCredentialsSupported = param;
break;
case FreeRDP_NoBitmapCompressionHeader:
settings->NoBitmapCompressionHeader = param;
break;
case FreeRDP_BitmapCompressionDisabled:
settings->BitmapCompressionDisabled = param;
break;
case FreeRDP_DesktopResize:
settings->DesktopResize = param;
break;
case FreeRDP_DrawAllowDynamicColorFidelity:
settings->DrawAllowDynamicColorFidelity = param;
break;
case FreeRDP_DrawAllowColorSubsampling:
settings->DrawAllowColorSubsampling = param;
break;
case FreeRDP_DrawAllowSkipAlpha:
settings->DrawAllowSkipAlpha = param;
break;
case FreeRDP_BitmapCacheV3Enabled:
settings->BitmapCacheV3Enabled = param;
break;
case FreeRDP_AltSecFrameMarkerSupport:
settings->AltSecFrameMarkerSupport = param;
break;
case FreeRDP_BitmapCacheEnabled:
settings->BitmapCacheEnabled = param;
break;
case FreeRDP_AllowCacheWaitingList:
settings->AllowCacheWaitingList = param;
break;
case FreeRDP_BitmapCachePersistEnabled:
settings->BitmapCachePersistEnabled = param;
break;
case FreeRDP_ColorPointerFlag:
settings->ColorPointerFlag = param;
break;
case FreeRDP_UnicodeInput:
settings->UnicodeInput = param;
break;
case FreeRDP_FastPathInput:
settings->FastPathInput = param;
break;
case FreeRDP_MultiTouchInput:
settings->MultiTouchInput = param;
break;
case FreeRDP_MultiTouchGestures:
settings->MultiTouchGestures = param;
break;
case FreeRDP_SoundBeepsEnabled:
settings->SoundBeepsEnabled = param;
break;
case FreeRDP_SurfaceCommandsEnabled:
settings->SurfaceCommandsEnabled = param;
break;
case FreeRDP_FrameMarkerCommandEnabled:
settings->FrameMarkerCommandEnabled = param;
break;
case FreeRDP_RemoteFxOnly:
settings->RemoteFxOnly = param;
break;
case FreeRDP_RemoteFxCodec:
settings->RemoteFxCodec = param;
break;
case FreeRDP_RemoteFxImageCodec:
settings->RemoteFxImageCodec = param;
break;
case FreeRDP_NSCodec:
settings->NSCodec = param;
break;
case FreeRDP_FrameAcknowledge:
settings->FrameAcknowledge = param;
break;
case FreeRDP_JpegCodec:
settings->JpegCodec = param;
break;
case FreeRDP_DrawNineGridEnabled:
settings->DrawNineGridEnabled = param;
break;
case FreeRDP_DrawGdiPlusEnabled:
settings->DrawGdiPlusEnabled = param;
break;
case FreeRDP_DrawGdiPlusCacheEnabled:
settings->DrawGdiPlusCacheEnabled = param;
break;
case FreeRDP_DeviceRedirection:
settings->DeviceRedirection = param;
break;
case FreeRDP_RedirectDrives:
settings->RedirectDrives = param;
break;
case FreeRDP_RedirectHomeDrive:
settings->RedirectHomeDrive = param;
break;
case FreeRDP_RedirectSmartCards:
settings->RedirectSmartCards = param;
break;
case FreeRDP_RedirectPrinters:
settings->RedirectPrinters = param;
break;
case FreeRDP_RedirectSerialPorts:
settings->RedirectSerialPorts = param;
break;
case FreeRDP_RedirectParallelPorts:
settings->RedirectParallelPorts = param;
break;
case FreeRDP_RedirectClipboard:
settings->RedirectClipboard = param;
break;
default:
return -1;
break;
}
// Mark field as modified
settings->settings_modified[id] = 1;
EventArgsInit(&e, "freerdp");
e.id = id;
PubSub_OnParamChange(context->pubSub, context, &e);
return -1;
}
BOOL wf_post_connect(freerdp* instance)
{
rdpGdi* gdi;
DWORD dwStyle;
rdpCache* cache;
wfContext* wfc;
rdpContext* context;
WCHAR lpWindowName[64];
rdpSettings* settings;
EmbedWindowEventArgs e;
settings = instance->settings;
context = instance->context;
wfc = (wfContext*) instance->context;
cache = instance->context->cache;
wfc->dstBpp = 32;
wfc->width = settings->DesktopWidth;
wfc->height = settings->DesktopHeight;
if (settings->SoftwareGdi)
{
wfc->primary = wf_image_new(wfc, wfc->width, wfc->height, wfc->dstBpp, NULL);
if (!gdi_init(instance, CLRCONV_ALPHA | CLRBUF_32BPP, wfc->primary->pdata))
return FALSE;
gdi = instance->context->gdi;
wfc->hdc = gdi->primary->hdc;
}
else
{
wf_gdi_register_update_callbacks(instance->update);
wfc->srcBpp = instance->settings->ColorDepth;
wfc->primary = wf_image_new(wfc, wfc->width, wfc->height, wfc->dstBpp, NULL);
if (!(wfc->hdc = gdi_GetDC()))
return FALSE;
wfc->hdc->bitsPerPixel = wfc->dstBpp;
wfc->hdc->bytesPerPixel = wfc->dstBpp / 8;
wfc->hdc->alpha = wfc->clrconv->alpha;
wfc->hdc->invert = wfc->clrconv->invert;
wfc->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND));
wfc->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
wfc->hdc->hwnd->invalid->null = 1;
wfc->hdc->hwnd->count = 32;
wfc->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * wfc->hdc->hwnd->count);
wfc->hdc->hwnd->ninvalid = 0;
if (settings->RemoteFxCodec)
{
wfc->tile = wf_image_new(wfc, 64, 64, 32, NULL);
}
}
if (settings->WindowTitle != NULL)
_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"%S", settings->WindowTitle);
else if (settings->ServerPort == 3389)
_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S", settings->ServerHostname);
else
_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S:%d", settings->ServerHostname, settings->ServerPort);
if (settings->EmbeddedWindow)
settings->Decorations = FALSE;
if (wfc->fullscreen)
dwStyle = WS_POPUP;
else if (!settings->Decorations)
dwStyle = WS_CHILD | WS_BORDER;
else
dwStyle = WS_CAPTION | WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX | WS_SIZEBOX | WS_MAXIMIZEBOX;
if (!wfc->hwnd)
{
wfc->hwnd = CreateWindowEx((DWORD) NULL, wfc->wndClassName, lpWindowName, dwStyle,
0, 0, 0, 0, wfc->hWndParent, NULL, wfc->hInstance, NULL);
SetWindowLongPtr(wfc->hwnd, GWLP_USERDATA, (LONG_PTR) wfc);
}
wf_resize_window(wfc);
wf_add_system_menu(wfc);
BitBlt(wfc->primary->hdc, 0, 0, wfc->width, wfc->height, NULL, 0, 0, BLACKNESS);
wfc->drawing = wfc->primary;
EventArgsInit(&e, "wfreerdp");
e.embed = FALSE;
e.handle = (void*) wfc->hwnd;
PubSub_OnEmbedWindow(context->pubSub, context, &e);
ShowWindow(wfc->hwnd, SW_SHOWNORMAL);
UpdateWindow(wfc->hwnd);
if (settings->SoftwareGdi)
{
instance->update->BeginPaint = (pBeginPaint) wf_sw_begin_paint;
instance->update->EndPaint = (pEndPaint) wf_sw_end_paint;
instance->update->DesktopResize = (pDesktopResize) wf_sw_desktop_resize;
}
else
{
instance->update->BeginPaint = (pBeginPaint) wf_hw_begin_paint;
instance->update->EndPaint = (pEndPaint) wf_hw_end_paint;
instance->update->DesktopResize = (pDesktopResize) wf_hw_desktop_resize;
}
pointer_cache_register_callbacks(instance->update);
wf_register_pointer(context->graphics);
if (!settings->SoftwareGdi)
{
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
wf_register_graphics(context->graphics);
instance->update->BitmapUpdate = wf_gdi_bitmap_update;
}
freerdp_channels_post_connect(context->channels, instance);
if (wfc->fullscreen)
floatbar_window_create(wfc);
return TRUE;
}
/** Creates a new connection based on the settings found in the "instance" parameter
* It will use the callbacks registered on the structure to process the pre/post connect operations
* that the caller requires.
* @see struct rdp_freerdp in freerdp.h
*
* @param instance - pointer to a rdp_freerdp structure that contains base information to establish the connection.
* On return, this function will be initialized with the new connection's settings.
*
* @return TRUE if successful. FALSE otherwise.
*
*/
BOOL freerdp_connect(freerdp* instance)
{
rdpRdp* rdp;
BOOL status = TRUE;
rdpSettings* settings;
ConnectionResultEventArgs e;
/* We always set the return code to 0 before we start the connect sequence*/
connectErrorCode = 0;
freerdp_set_last_error(instance->context, FREERDP_ERROR_SUCCESS);
rdp = instance->context->rdp;
settings = instance->settings;
instance->context->codecs = codecs_new(instance->context);
IFCALLRET(instance->PreConnect, status, instance);
if (settings->KeyboardLayout == KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002)
{
settings->KeyboardType = 7;
settings->KeyboardSubType = 2;
settings->KeyboardFunctionKey = 12;
}
if (!status)
{
if (!freerdp_get_last_error(rdp->context))
freerdp_set_last_error(instance->context, FREERDP_ERROR_PRE_CONNECT_FAILED);
WLog_ERR(TAG, "freerdp_pre_connect failed");
goto freerdp_connect_finally;
}
status = rdp_client_connect(rdp);
/* --authonly tests the connection without a UI */
if (instance->settings->AuthenticationOnly)
{
WLog_ERR(TAG, "Authentication only, exit status %d", !status);
goto freerdp_connect_finally;
}
if (status)
{
if (instance->settings->DumpRemoteFx)
{
instance->update->pcap_rfx = pcap_open(instance->settings->DumpRemoteFxFile, TRUE);
if (instance->update->pcap_rfx)
instance->update->dump_rfx = TRUE;
}
IFCALLRET(instance->PostConnect, status, instance);
if (!status || !update_post_connect(instance->update))
{
WLog_ERR(TAG, "freerdp_post_connect failed");
if (!freerdp_get_last_error(rdp->context))
freerdp_set_last_error(instance->context, FREERDP_ERROR_POST_CONNECT_FAILED);
goto freerdp_connect_finally;
}
if (instance->settings->PlayRemoteFx)
{
wStream* s;
rdpUpdate* update;
pcap_record record;
update = instance->update;
update->pcap_rfx = pcap_open(settings->PlayRemoteFxFile, FALSE);
if (!update->pcap_rfx)
{
status = FALSE;
goto freerdp_connect_finally;
}
else
{
update->play_rfx = TRUE;
}
while (pcap_has_next_record(update->pcap_rfx))
{
pcap_get_next_record_header(update->pcap_rfx, &record);
if (!(s = StreamPool_Take(rdp->transport->ReceivePool, record.length)))
break;
record.data = Stream_Buffer(s);
pcap_get_next_record_content(update->pcap_rfx, &record);
Stream_SetLength(s,record.length);
Stream_SetPosition(s, 0);
update->BeginPaint(update->context);
update_recv_surfcmds(update, Stream_Length(s) , s);
update->EndPaint(update->context);
Stream_Release(s);
}
pcap_close(update->pcap_rfx);
update->pcap_rfx = NULL;
status = TRUE;
goto freerdp_connect_finally;
}
}
if (rdp->errorInfo == ERRINFO_SERVER_INSUFFICIENT_PRIVILEGES)
freerdp_set_last_error(instance->context, FREERDP_ERROR_INSUFFICIENT_PRIVILEGES);
SetEvent(rdp->transport->connectedEvent);
freerdp_connect_finally:
EventArgsInit(&e, "freerdp");
e.result = status ? 0 : -1;
PubSub_OnConnectionResult(instance->context->pubSub, instance->context, &e);
return status;
}
/** Creates a new connection based on the settings found in the "instance" parameter
* It will use the callbacks registered on the structure to process the pre/post connect operations
* that the caller requires.
* @see struct rdp_freerdp in freerdp.h
*
* @param instance - pointer to a rdp_freerdp structure that contains base information to establish the connection.
* On return, this function will be initialized with the new connection's settings.
*
* @return TRUE if successful. FALSE otherwise.
*
*/
BOOL freerdp_connect(freerdp* instance)
{
rdpRdp* rdp;
rdpSettings* settings;
BOOL status = FALSE;
ConnectionResultEventArgs e;
/* We always set the return code to 0 before we start the connect sequence*/
connectErrorCode = 0;
rdp = instance->context->rdp;
settings = instance->settings;
IFCALLRET(instance->PreConnect, status, instance);
if (settings->KeyboardLayout == KBD_JAPANESE_INPUT_SYSTEM_MS_IME2002)
{
settings->KeyboardType = 7;
settings->KeyboardSubType = 2;
settings->KeyboardFunctionKey = 12;
}
extension_load_and_init_plugins(rdp->extension);
extension_pre_connect(rdp->extension);
if (!status)
{
if (!connectErrorCode)
{
connectErrorCode = PREECONNECTERROR;
}
fprintf(stderr, "%s:%d: freerdp_pre_connect failed\n", __FILE__, __LINE__);
goto freerdp_connect_finally;
}
status = rdp_client_connect(rdp);
/* --authonly tests the connection without a UI */
if (instance->settings->AuthenticationOnly)
{
fprintf(stderr, "%s:%d: Authentication only, exit status %d\n", __FILE__, __LINE__, !status);
goto freerdp_connect_finally;
}
if (status)
{
if (instance->settings->DumpRemoteFx)
{
instance->update->pcap_rfx = pcap_open(instance->settings->DumpRemoteFxFile, TRUE);
if (instance->update->pcap_rfx)
instance->update->dump_rfx = TRUE;
}
extension_post_connect(rdp->extension);
IFCALLRET(instance->PostConnect, status, instance);
update_post_connect(instance->update);
if (!status)
{
fprintf(stderr, "freerdp_post_connect failed\n");
if (!connectErrorCode)
{
connectErrorCode = POSTCONNECTERROR;
}
goto freerdp_connect_finally;
}
if (instance->settings->PlayRemoteFx)
{
wStream* s;
rdpUpdate* update;
pcap_record record;
update = instance->update;
update->pcap_rfx = pcap_open(settings->PlayRemoteFxFile, FALSE);
if (!update->pcap_rfx)
{
status = FALSE;
goto freerdp_connect_finally;
}
else
{
update->play_rfx = TRUE;
}
while (pcap_has_next_record(update->pcap_rfx))
{
pcap_get_next_record_header(update->pcap_rfx, &record);
s = StreamPool_Take(rdp->transport->ReceivePool, record.length);
record.data = Stream_Buffer(s);
pcap_get_next_record_content(update->pcap_rfx, &record);
Stream_SetLength(s,record.length);
Stream_SetPosition(s, 0);
update->BeginPaint(update->context);
update_recv_surfcmds(update, Stream_Length(s) , s);
update->EndPaint(update->context);
Stream_Release(s);
StreamPool_Return(rdp->transport->ReceivePool, s);
}
pcap_close(update->pcap_rfx);
update->pcap_rfx = NULL;
status = TRUE;
goto freerdp_connect_finally;
}
}
if (rdp->errorInfo == ERRINFO_SERVER_INSUFFICIENT_PRIVILEGES)
{
connectErrorCode = INSUFFICIENTPRIVILEGESERROR;
}
if (!connectErrorCode)
{
connectErrorCode = UNDEFINEDCONNECTERROR;
}
SetEvent(rdp->transport->connectedEvent);
freerdp_connect_finally:
EventArgsInit(&e, "freerdp");
e.result = status ? 0 : -1;
PubSub_OnConnectionResult(instance->context->pubSub, instance->context, &e);
return status;
}
BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym)
{
XF_MODIFIER_KEYS mod = { 0 };
xk_keyboard_get_modifier_keys(xfc, &mod);
if (!xf_keyboard_execute_action_script(xfc, &mod, keysym))
{
return TRUE;
}
if(xfc->fullscreen_toggle)
{
if (keysym == XK_Return)
{
if (mod.Ctrl && mod.Alt)
{
/* Ctrl-Alt-Enter: toggle full screen */
xf_toggle_fullscreen(xfc);
return TRUE;
}
}
}
if ((keysym == XK_c) || (keysym == XK_C))
{
if (mod.Ctrl && mod.Alt)
{
/* Ctrl-Alt-C: toggle control */
xf_toggle_control(xfc);
return TRUE;
}
}
#if 0 /* set to 1 to enable multi touch gesture simulation via keyboard */
#ifdef WITH_XRENDER
if (!xfc->remote_app && xfc->settings->MultiTouchGestures)
{
if (mod.Ctrl && mod.Alt)
{
int pdx = 0;
int pdy = 0;
int zdx = 0;
int zdy = 0;
switch(keysym)
{
case XK_0: /* Ctrl-Alt-0: Reset scaling and panning */
xfc->scaledWidth = xfc->sessionWidth;
xfc->scaledHeight = xfc->sessionHeight;
xfc->offset_x = 0;
xfc->offset_y = 0;
if (!xfc->fullscreen && (xfc->sessionWidth != xfc->window->width ||
xfc->sessionHeight != xfc->window->height))
{
xf_ResizeDesktopWindow(xfc, xfc->window, xfc->sessionWidth, xfc->sessionHeight);
}
xf_draw_screen(xfc, 0, 0, xfc->sessionWidth, xfc->sessionHeight);
return TRUE;
case XK_1: /* Ctrl-Alt-1: Zoom in */
zdx = zdy = 10;
break;
case XK_2: /* Ctrl-Alt-2: Zoom out */
zdx = zdy = -10;
break;
case XK_3: /* Ctrl-Alt-3: Pan left */
pdx = -10;
break;
case XK_4: /* Ctrl-Alt-4: Pan right */
pdx = 10;
break;
case XK_5: /* Ctrl-Alt-5: Pan up */
pdy = -10;
break;
case XK_6: /* Ctrl-Alt-6: Pan up */
pdy = 10;
break;
}
if (pdx != 0 || pdy != 0)
{
PanningChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.dx = pdx;
e.dy = pdy;
PubSub_OnPanningChange(((rdpContext*) xfc)->pubSub, xfc, &e);
return TRUE;
}
if (zdx != 0 || zdy != 0)
{
ZoomingChangeEventArgs e;
EventArgsInit(&e, "xfreerdp");
e.dx = zdx;
e.dy = zdy;
PubSub_OnZoomingChange(((rdpContext*) xfc)->pubSub, xfc, &e);
return TRUE;
}
}
}
#endif /* WITH_XRENDER defined */
#endif /* pinch/zoom/pan simulation */
return FALSE;
}
