/* Respond to a demand active PDU */
static void process_demand_active(STREAM s) {
uint8 type;
uint16 len_src_descriptor, len_combined_caps;
in_uint32_le(s, g_rdp_shareid);
in_uint16_le(s, len_src_descriptor);
in_uint16_le(s, len_combined_caps);
in_uint8s(s, len_src_descriptor);
DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
rdp_process_server_caps(s, len_combined_caps);
rdp_send_confirm_active();
rdp_send_synchronise();
rdp_send_control(RDP_CTL_COOPERATE);
rdp_send_control(RDP_CTL_REQUEST_CONTROL);
rdp_recv(&type); /* RDP_PDU_SYNCHRONIZE */
rdp_recv(&type); /* RDP_CTL_COOPERATE */
rdp_recv(&type); /* RDP_CTL_GRANT_CONTROL */
rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0,
g_numlock_sync ? ui_get_numlock_state(read_keyboard_state()) : 0,
0);
if (g_use_rdp5) {
rdp_enum_bmpcache2();
rdp_send_fonts(3);
} else {
rdp_send_fonts(1);
rdp_send_fonts(2);
}
rdp_recv(&type); /* RDP_PDU_UNKNOWN 0x28 (Fonts?) */
reset_order_state();
}
void
reset_modifier_keys()
{
unsigned int state = read_keyboard_state();
/* reset keys */
uint32 ev_time;
ev_time = time(NULL);
printf("remote_modifier_state: %.8X\n", remote_modifier_state);
if (MASK_HAS_BITS(remote_modifier_state, MapLeftShiftMask)
&& !get_key_state(state, XK_Shift_L))
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
if (MASK_HAS_BITS(remote_modifier_state, MapRightShiftMask)
&& !get_key_state(state, XK_Shift_R))
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
if (MASK_HAS_BITS(remote_modifier_state, MapLeftCtrlMask)
&& !get_key_state(state, XK_Control_L))
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
if (MASK_HAS_BITS(remote_modifier_state, MapRightCtrlMask)
&& !get_key_state(state, XK_Control_R))
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);
if (MASK_HAS_BITS(remote_modifier_state, MapLeftAltMask) && !get_key_state(state, XK_Alt_L))
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);
if (MASK_HAS_BITS(remote_modifier_state, MapRightAltMask) &&
!get_key_state(state, XK_Alt_R) && !get_key_state(state, XK_Mode_switch)
&& !get_key_state(state, XK_ISO_Level3_Shift))
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
reset_winkey(ev_time);
if (g_numlock_sync)
rdp_send_input(ev_time, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(state), 0);
}
void
clear_modifier_keys()
{
unsigned int state = read_keyboard_state();
/* reset keys */
uint32 ev_time;
ev_time = time(NULL);
printf("remote_modifier_state: %.8X\n", remote_modifier_state);
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LSHIFT);
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RSHIFT);
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LCTRL);
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RCTRL);
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_LALT);
rdp_send_scancode(ev_time, RDP_KEYRELEASE, SCANCODE_CHAR_RALT);
remote_modifier_state=0;
reset_winkey(ev_time);
rdp_send_input(ev_time, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(state), 0);
}
/* Respond to a demand active PDU */
static void
process_demand_active(STREAM s)
{
uint8 type;
in_uint32_le(s, g_rdp_shareid);
DEBUG(("DEMAND_ACTIVE(id=0x%x)\n", g_rdp_shareid));
rdp_send_confirm_active();
rdp_send_synchronise();
rdp_send_control(RDP_CTL_COOPERATE);
rdp_send_control(RDP_CTL_REQUEST_CONTROL);
rdp_recv(&type); /* RDP_PDU_SYNCHRONIZE */
rdp_recv(&type); /* RDP_CTL_COOPERATE */
rdp_recv(&type); /* RDP_CTL_GRANT_CONTROL */
rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0, ui_get_numlock_state(read_keyboard_state()), 0);
rdp_send_fonts(1);
rdp_send_fonts(2);
rdp_recv(&type); /* RDP_PDU_UNKNOWN 0x28 */
reset_order_state();
}
/* Handle special key combinations */
RD_BOOL
handle_special_keys(uint32 keysym, unsigned int state, uint32 ev_time, RD_BOOL pressed)
{
switch (keysym)
{
case XK_Return:
if ((get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R))
&& (get_key_state(state, XK_Control_L)
|| get_key_state(state, XK_Control_R)))
{
/* Ctrl-Alt-Enter: toggle full screen */
if (pressed)
xwin_toggle_fullscreen();
return True;
}
break;
case XK_Break:
/* Send Break sequence E0 46 E0 C6 */
if (pressed)
{
rdp_send_scancode(ev_time, RDP_KEYPRESS,
(SCANCODE_EXTENDED | 0x46));
rdp_send_scancode(ev_time, RDP_KEYPRESS,
(SCANCODE_EXTENDED | 0xc6));
}
/* No release sequence */
return True;
break;
case XK_Pause:
/* According to MS Keyboard Scan Code
Specification, pressing Pause should result
in E1 1D 45 E1 9D C5. I'm not exactly sure
of how this is supposed to be sent via
RDP. The code below seems to work, but with
the side effect that Left Ctrl stays
down. Therefore, we release it when Pause
is released. */
if (pressed)
{
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x1d, 0);
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x45, 0);
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xe1, 0);
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0x9d, 0);
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYPRESS, 0xc5, 0);
}
else
{
/* Release Left Ctrl */
rdp_send_input(ev_time, RDP_INPUT_SCANCODE, RDP_KEYRELEASE,
0x1d, 0);
}
return True;
break;
case XK_Meta_L: /* Windows keys */
case XK_Super_L:
case XK_Hyper_L:
send_winkey(ev_time, pressed, True);
return True;
break;
case XK_Meta_R:
case XK_Super_R:
case XK_Hyper_R:
send_winkey(ev_time, pressed, False);
return True;
break;
case XK_space:
/* Prevent access to the Windows system menu in single app mode */
if (g_win_button_size
&& (get_key_state(state, XK_Alt_L) || get_key_state(state, XK_Alt_R)))
return True;
break;
case XK_Num_Lock:
/* Synchronize on key release */
if (g_numlock_sync && !pressed)
rdp_send_input(0, RDP_INPUT_SYNCHRONIZE, 0,
ui_get_numlock_state(read_keyboard_state()), 0);
/* Inhibit */
return True;
break;
case XK_Overlay1_Enable:
/* Toggle SeamlessRDP */
if (pressed)
ui_seamless_toggle();
break;
}
return False;
}