569 lines
15 KiB
C++
569 lines
15 KiB
C++
/*
|
|
* \brief Port of VirtualBox to Genode
|
|
* \author Norman Feske
|
|
* \author Alexander Boettcher
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2013-2017 Genode Labs GmbH
|
|
*
|
|
* This file is distributed under the terms of the GNU General Public License
|
|
* version 2.
|
|
*/
|
|
|
|
#include <base/log.h>
|
|
#include <libc/component.h>
|
|
#include <util/xml_node.h>
|
|
|
|
#include <VBox/settings.h>
|
|
#include <SharedClipboard/VBoxClipboard.h>
|
|
#include <VBox/HostServices/VBoxClipboardSvc.h>
|
|
|
|
#include "ConsoleImpl.h"
|
|
#include "MouseImpl.h"
|
|
#include "DisplayImpl.h"
|
|
#include "GuestImpl.h"
|
|
|
|
#include "dummy/macros.h"
|
|
|
|
#include "console.h"
|
|
#include "fb.h"
|
|
#include "vmm.h"
|
|
|
|
static const bool debug = false;
|
|
static bool vm_down = false;
|
|
|
|
static Genode::Attached_rom_dataspace *clipboard_rom = nullptr;
|
|
static Genode::Reporter *clipboard_reporter = nullptr;
|
|
static char *decoded_clipboard_content = nullptr;
|
|
|
|
|
|
void Console::uninit()
|
|
DUMMY()
|
|
HRESULT Console::teleport(const com::Utf8Str &, ULONG, const com::Utf8Str &,
|
|
ULONG, ComPtr<IProgress> &aProgress)
|
|
DUMMY(E_FAIL)
|
|
HRESULT Console::i_teleporterTrg(PUVM, IMachine *, Utf8Str *, bool, Progress *,
|
|
bool *)
|
|
DUMMY(E_FAIL)
|
|
|
|
HRESULT Console::i_attachToTapInterface(INetworkAdapter *networkAdapter)
|
|
{
|
|
ULONG slot = 0;
|
|
HRESULT rc = networkAdapter->COMGETTER(Slot)(&slot);
|
|
AssertComRC(rc);
|
|
|
|
maTapFD[slot] = (RTFILE)1;
|
|
|
|
TRACE(rc)
|
|
}
|
|
|
|
HRESULT Console::i_detachFromTapInterface(INetworkAdapter *networkAdapter)
|
|
{
|
|
ULONG slot = 0;
|
|
HRESULT rc = networkAdapter->COMGETTER(Slot)(&slot);
|
|
AssertComRC(rc);
|
|
|
|
if (maTapFD[slot] != NIL_RTFILE)
|
|
maTapFD[slot] = NIL_RTFILE;
|
|
|
|
TRACE(rc)
|
|
}
|
|
|
|
void fireStateChangedEvent(IEventSource* aSource,
|
|
MachineState_T a_state)
|
|
{
|
|
if (a_state != MachineState_PoweredOff)
|
|
return;
|
|
|
|
vm_down = true;
|
|
|
|
genode_env().parent().exit(0);
|
|
}
|
|
|
|
void fireRuntimeErrorEvent(IEventSource* aSource, BOOL a_fatal,
|
|
CBSTR a_id, CBSTR a_message)
|
|
{
|
|
Genode::error(__func__, " : ", a_fatal, " ",
|
|
Utf8Str(a_id).c_str(), " ",
|
|
Utf8Str(a_message).c_str());
|
|
|
|
TRACE();
|
|
}
|
|
|
|
void Console::i_onAdditionsStateChange()
|
|
{
|
|
dynamic_cast<GenodeConsole *>(this)->update_video_mode();
|
|
}
|
|
|
|
void GenodeConsole::update_video_mode()
|
|
{
|
|
Display *d = i_getDisplay();
|
|
|
|
IFramebuffer *pFramebuffer = NULL;
|
|
HRESULT rc = d->QueryFramebuffer(0, &pFramebuffer);
|
|
Assert(SUCCEEDED(rc) && pFramebuffer);
|
|
|
|
Genodefb *fb = dynamic_cast<Genodefb *>(pFramebuffer);
|
|
|
|
if (!fb)
|
|
return;
|
|
|
|
if ((fb->w() <= 1) && (fb->h() <= 1)) {
|
|
/* interpret a size of 0x0 as indication to quit VirtualBox */
|
|
if (PowerButton() != S_OK)
|
|
Genode::error("ACPI shutdown failed");
|
|
return;
|
|
}
|
|
|
|
d->SetVideoModeHint(0 /*=display*/,
|
|
true /*=enabled*/, false /*=changeOrigin*/,
|
|
0 /*=originX*/, 0 /*=originY*/,
|
|
fb->w(), fb->h(),
|
|
/* Windows 8 only accepts 32-bpp modes */
|
|
32);
|
|
}
|
|
|
|
void GenodeConsole::_handle_input()
|
|
{
|
|
/* disable input processing if vm is powered down */
|
|
if (vm_down && (_vbox_mouse || _vbox_keyboard)) {
|
|
_vbox_mouse = nullptr;
|
|
_vbox_keyboard = nullptr;
|
|
_input.sigh(Genode::Signal_context_capability());
|
|
}
|
|
|
|
static LONG64 mt_events [64];
|
|
unsigned mt_number = 0;
|
|
|
|
/* read out input capabilities of guest */
|
|
bool guest_abs = false, guest_rel = false, guest_multi = false;
|
|
if (_vbox_mouse) {
|
|
_vbox_mouse->COMGETTER(AbsoluteSupported)(&guest_abs);
|
|
_vbox_mouse->COMGETTER(RelativeSupported)(&guest_rel);
|
|
_vbox_mouse->COMGETTER(MultiTouchSupported)(&guest_multi);
|
|
}
|
|
|
|
_input.for_each_event([&] (Input::Event const &ev) {
|
|
/* if keyboard/mouse not available, consume input events and drop it */
|
|
if (!_vbox_keyboard || !_vbox_mouse)
|
|
return;
|
|
|
|
auto keyboard_submit = [&] (Input::Keycode key, bool release) {
|
|
|
|
Scan_code scan_code(key);
|
|
|
|
unsigned char const release_bit = release ? 0x80 : 0;
|
|
|
|
if (scan_code.normal())
|
|
_vbox_keyboard->PutScancode(scan_code.code() | release_bit);
|
|
|
|
if (scan_code.ext()) {
|
|
_vbox_keyboard->PutScancode(0xe0);
|
|
_vbox_keyboard->PutScancode(scan_code.ext() | release_bit);
|
|
}
|
|
};
|
|
|
|
/* obtain bit mask of currently pressed mouse buttons */
|
|
auto curr_mouse_button_bits = [&] () {
|
|
return (_key_status[Input::BTN_LEFT] ? MouseButtonState_LeftButton : 0)
|
|
| (_key_status[Input::BTN_RIGHT] ? MouseButtonState_RightButton : 0)
|
|
| (_key_status[Input::BTN_MIDDLE] ? MouseButtonState_MiddleButton : 0);
|
|
};
|
|
|
|
unsigned const old_mouse_button_bits = curr_mouse_button_bits();
|
|
|
|
ev.handle_press([&] (Input::Keycode key, Genode::Codepoint) {
|
|
keyboard_submit(key, false);
|
|
_key_status[key] = true;
|
|
});
|
|
|
|
ev.handle_release([&] (Input::Keycode key) {
|
|
keyboard_submit(key, true);
|
|
_key_status[key] = false;
|
|
});
|
|
|
|
unsigned const mouse_button_bits = curr_mouse_button_bits();
|
|
|
|
if (mouse_button_bits != old_mouse_button_bits) {
|
|
|
|
if (_last_received_motion_event_was_absolute) {
|
|
/* prefer absolute button event */
|
|
if (guest_abs)
|
|
_vbox_mouse->PutMouseEventAbsolute(_ax, _ay, 0, 0, mouse_button_bits);
|
|
else if (guest_rel)
|
|
_vbox_mouse->PutMouseEvent(0, 0, 0, 0, mouse_button_bits);
|
|
} else {
|
|
/* prefer relative button event */
|
|
if (guest_rel)
|
|
_vbox_mouse->PutMouseEvent(0, 0, 0, 0, mouse_button_bits);
|
|
else if (guest_abs)
|
|
_vbox_mouse->PutMouseEventAbsolute(_ax, _ay, 0, 0, mouse_button_bits);
|
|
}
|
|
}
|
|
|
|
ev.handle_absolute_motion([&] (int x, int y) {
|
|
|
|
_last_received_motion_event_was_absolute = true;
|
|
|
|
/* transform absolute to relative if guest is so odd */
|
|
if (!guest_abs && guest_rel) {
|
|
int const boundary = 20;
|
|
int rx = x - _ax;
|
|
int ry = y - _ay;
|
|
rx = Genode::min(boundary, Genode::max(-boundary, rx));
|
|
ry = Genode::min(boundary, Genode::max(-boundary, ry));
|
|
_vbox_mouse->PutMouseEvent(rx, ry, 0, 0, mouse_button_bits);
|
|
} else
|
|
_vbox_mouse->PutMouseEventAbsolute(x, y, 0, 0, mouse_button_bits);
|
|
|
|
_ax = x;
|
|
_ay = y;
|
|
});
|
|
|
|
ev.handle_relative_motion([&] (int x, int y) {
|
|
|
|
_last_received_motion_event_was_absolute = false;
|
|
|
|
/* prefer relative motion event */
|
|
if (guest_rel)
|
|
_vbox_mouse->PutMouseEvent(x, y, 0, 0, mouse_button_bits);
|
|
else if (guest_abs) {
|
|
_ax += x;
|
|
_ay += y;
|
|
_vbox_mouse->PutMouseEventAbsolute(_ax, _ay, 0, 0, mouse_button_bits);
|
|
}
|
|
});
|
|
|
|
ev.handle_wheel([&] (int x, int y) {
|
|
|
|
if (_last_received_motion_event_was_absolute)
|
|
_vbox_mouse->PutMouseEventAbsolute(_ax, _ay, -y, -x, 0);
|
|
else
|
|
_vbox_mouse->PutMouseEvent(0, 0, -y, -x, 0);
|
|
});
|
|
|
|
ev.handle_touch([&] (Input::Touch_id id, int x, int y) {
|
|
|
|
/* if multitouch queue is full - send it */
|
|
if (mt_number >= sizeof(mt_events) / sizeof(mt_events[0])) {
|
|
_vbox_mouse->PutEventMultiTouch(mt_number, mt_number,
|
|
mt_events, RTTimeMilliTS());
|
|
mt_number = 0;
|
|
}
|
|
|
|
/* Mouse::putEventMultiTouch drops values of 0 */
|
|
if (x <= 0) x = 1;
|
|
if (y <= 0) y = 1;
|
|
|
|
enum { IN_CONTACT = 0x01, IN_RANGE = 0x02 };
|
|
|
|
uint16_t const s = RT_MAKE_U16(id.value, IN_CONTACT | IN_RANGE);
|
|
mt_events[mt_number++] = RT_MAKE_U64_FROM_U16(x, y, s, 0);
|
|
});
|
|
|
|
ev.handle_touch_release([&] (Input::Touch_id id) {
|
|
uint16_t const s = RT_MAKE_U16(id.value, 0);
|
|
mt_events[mt_number++] = RT_MAKE_U64_FROM_U16(0, 0, s, 0);
|
|
});
|
|
});
|
|
|
|
/* if there are elements in multi-touch queue - send it */
|
|
if (mt_number)
|
|
_vbox_mouse->PutEventMultiTouch(mt_number, mt_number, mt_events,
|
|
RTTimeMilliTS());
|
|
}
|
|
|
|
void GenodeConsole::_handle_mode_change()
|
|
{
|
|
IFramebuffer *pFramebuffer = NULL;
|
|
HRESULT rc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
|
|
Assert(SUCCEEDED(rc) && pFramebuffer);
|
|
|
|
Genodefb *fb = dynamic_cast<Genodefb *>(pFramebuffer);
|
|
|
|
fb->update_mode(_nitpicker.mode());
|
|
update_video_mode();
|
|
}
|
|
|
|
void GenodeConsole::init_clipboard()
|
|
{
|
|
if (!&*i_machine())
|
|
return;
|
|
|
|
ClipboardMode_T mode;
|
|
i_machine()->COMGETTER(ClipboardMode)(&mode);
|
|
|
|
if (mode == ClipboardMode_Bidirectional ||
|
|
mode == ClipboardMode_HostToGuest) {
|
|
|
|
_clipboard_rom = new Genode::Attached_rom_dataspace(genode_env(), "clipboard");
|
|
_clipboard_rom->sigh(_clipboard_signal_dispatcher);
|
|
|
|
clipboard_rom = _clipboard_rom;
|
|
}
|
|
|
|
if (mode == ClipboardMode_Bidirectional ||
|
|
mode == ClipboardMode_GuestToHost) {
|
|
|
|
_clipboard_reporter = new Genode::Reporter(genode_env(), "clipboard");
|
|
_clipboard_reporter->enabled(true);
|
|
|
|
clipboard_reporter = _clipboard_reporter;
|
|
}
|
|
}
|
|
|
|
void GenodeConsole::_handle_cb_rom_change()
|
|
{
|
|
if (!_clipboard_rom)
|
|
return;
|
|
|
|
vboxClipboardSync(nullptr);
|
|
}
|
|
|
|
void GenodeConsole::init_backends(IKeyboard * gKeyboard, IMouse * gMouse)
|
|
{
|
|
_vbox_keyboard = gKeyboard;
|
|
_vbox_mouse = gMouse;
|
|
|
|
/* register the mode change signal dispatcher at the framebuffer */
|
|
IFramebuffer *pFramebuffer = NULL;
|
|
HRESULT rc = i_getDisplay()->QueryFramebuffer(0, &pFramebuffer);
|
|
Assert(SUCCEEDED(rc) && pFramebuffer);
|
|
|
|
_nitpicker.mode_sigh(_mode_change_signal_dispatcher);
|
|
|
|
_handle_mode_change();
|
|
}
|
|
|
|
void GenodeConsole::i_onMouseCapabilityChange(BOOL supportsAbsolute,
|
|
BOOL supportsRelative,
|
|
BOOL supportsMT,
|
|
BOOL needsHostCursor)
|
|
{
|
|
if (supportsAbsolute) {
|
|
/* let the guest hide the software cursor */
|
|
Mouse *gMouse = i_getMouse();
|
|
gMouse->PutMouseEventAbsolute(-1, -1, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/**********************
|
|
* Clipboard handling *
|
|
**********************/
|
|
|
|
struct _VBOXCLIPBOARDCONTEXT
|
|
{
|
|
VBOXCLIPBOARDCLIENTDATA *pClient;
|
|
};
|
|
|
|
static VBOXCLIPBOARDCONTEXT context;
|
|
|
|
int vboxClipboardInit (void) { return VINF_SUCCESS; }
|
|
|
|
void vboxClipboardDestroy (void)
|
|
{
|
|
free(decoded_clipboard_content);
|
|
clipboard_rom = nullptr;
|
|
}
|
|
|
|
int vboxClipboardConnect (VBOXCLIPBOARDCLIENTDATA *pClient, bool fHeadless)
|
|
{
|
|
if (!pClient || context.pClient != NULL)
|
|
return VERR_NOT_SUPPORTED;
|
|
|
|
vboxSvcClipboardLock();
|
|
|
|
pClient->pCtx = &context;
|
|
pClient->pCtx->pClient = pClient;
|
|
|
|
vboxSvcClipboardUnlock();
|
|
|
|
int rc = vboxClipboardSync (pClient);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void vboxClipboardDisconnect (VBOXCLIPBOARDCLIENTDATA *pClient)
|
|
{
|
|
if (!pClient || !pClient->pCtx)
|
|
return;
|
|
|
|
vboxSvcClipboardLock();
|
|
pClient->pCtx->pClient = NULL;
|
|
vboxSvcClipboardUnlock();
|
|
}
|
|
|
|
void vboxClipboardFormatAnnounce (VBOXCLIPBOARDCLIENTDATA *pClient,
|
|
uint32_t formats)
|
|
{
|
|
if (!pClient)
|
|
return;
|
|
|
|
vboxSvcClipboardReportMsg (pClient,
|
|
VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
|
|
formats);
|
|
}
|
|
|
|
int vboxClipboardReadData (VBOXCLIPBOARDCLIENTDATA *pClient, uint32_t format,
|
|
void *pv, uint32_t const cb, uint32_t *pcbActual)
|
|
{
|
|
if (!clipboard_rom || format != VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
|
|
return VERR_NOT_SUPPORTED;
|
|
|
|
if (!pv || !pcbActual || cb == 0)
|
|
return VERR_INVALID_PARAMETER;
|
|
|
|
clipboard_rom->update();
|
|
|
|
if (!clipboard_rom->valid()) {
|
|
Genode::error("invalid clipboard dataspace");
|
|
return VERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
char * data = clipboard_rom->local_addr<char>();
|
|
|
|
try {
|
|
|
|
Genode::Xml_node node(data);
|
|
if (!node.has_type("clipboard")) {
|
|
Genode::error("invalid clipboard xml syntax");
|
|
return VERR_INVALID_PARAMETER;
|
|
}
|
|
|
|
free(decoded_clipboard_content);
|
|
|
|
decoded_clipboard_content = (char*)malloc(node.content_size());
|
|
|
|
if (!decoded_clipboard_content) {
|
|
Genode::error("could not allocate buffer for decoded clipboard content");
|
|
return 0;
|
|
}
|
|
|
|
size_t const len = node.decoded_content(decoded_clipboard_content,
|
|
node.content_size());
|
|
size_t written = 0;
|
|
|
|
PRTUTF16 utf16_string = reinterpret_cast<PRTUTF16>(pv);
|
|
int rc = RTStrToUtf16Ex(decoded_clipboard_content, len, &utf16_string, cb, &written);
|
|
|
|
if (RT_SUCCESS(rc)) {
|
|
if ((written * 2) + 2 > cb)
|
|
written = (cb - 2) / 2;
|
|
|
|
/* +1 stuff required for Windows guests ... linux guest doesn't care */
|
|
*pcbActual = (written + 1) * 2;
|
|
utf16_string[written] = 0;
|
|
} else
|
|
*pcbActual = 0;
|
|
|
|
} catch (Genode::Xml_node::Invalid_syntax) {
|
|
Genode::error("invalid clipboard xml syntax");
|
|
return VERR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return VINF_SUCCESS;
|
|
}
|
|
|
|
void vboxClipboardWriteData (VBOXCLIPBOARDCLIENTDATA *pClient, void *pv,
|
|
uint32_t cb, uint32_t format)
|
|
{
|
|
if (format != VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT || !pv || !pClient ||
|
|
!clipboard_reporter)
|
|
return;
|
|
|
|
PCRTUTF16 utf16str = reinterpret_cast<PCRTUTF16>(pv);
|
|
char * message = 0;
|
|
|
|
int rc = RTUtf16ToUtf8(utf16str, &message);
|
|
|
|
if (!RT_SUCCESS(rc) || !message)
|
|
return;
|
|
|
|
try {
|
|
Genode::Reporter::Xml_generator xml(*clipboard_reporter, [&] () {
|
|
xml.append_sanitized(message, strlen(message)); });
|
|
} catch (...) {
|
|
Genode::error("could not write clipboard data");
|
|
}
|
|
|
|
RTStrFree(message);
|
|
}
|
|
|
|
int vboxClipboardSync (VBOXCLIPBOARDCLIENTDATA *pClient)
|
|
{
|
|
if (!pClient)
|
|
pClient = context.pClient;
|
|
|
|
if (!pClient)
|
|
return VERR_NOT_SUPPORTED;
|
|
|
|
vboxSvcClipboardReportMsg (pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS,
|
|
VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
|
|
|
|
return VINF_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Sticky key handling
|
|
*/
|
|
static bool host_caps_lock = false;
|
|
static bool guest_caps_lock = false;
|
|
|
|
void fireKeyboardLedsChangedEvent(IEventSource *, bool num_lock,
|
|
bool caps_lock, bool scroll_lock)
|
|
{
|
|
guest_caps_lock = caps_lock;
|
|
}
|
|
|
|
void GenodeConsole::_handle_sticky_keys()
|
|
{
|
|
/* no keyboard - no sticky key handling */
|
|
if (!_vbox_keyboard || !_caps_lock.constructed())
|
|
return;
|
|
|
|
_caps_lock->update();
|
|
|
|
if (!_caps_lock->valid())
|
|
return;
|
|
|
|
bool const caps_lock = _caps_lock->xml().attribute_value("enabled",
|
|
guest_caps_lock);
|
|
|
|
bool trigger_caps_lock = false;
|
|
|
|
/*
|
|
* If guest didn't respond with led change last time, we have to
|
|
* trigger caps_lock change - mainly assuming that guest don't use the
|
|
* led to externalize its internal caps_lock state.
|
|
*/
|
|
if (caps_lock != host_caps_lock && host_caps_lock != guest_caps_lock)
|
|
trigger_caps_lock = true;
|
|
|
|
if (caps_lock != guest_caps_lock)
|
|
trigger_caps_lock = true;
|
|
|
|
/* remember last seen host caps lock state */
|
|
host_caps_lock = caps_lock;
|
|
|
|
if (trigger_caps_lock) {
|
|
_vbox_keyboard->PutScancode(Input::KEY_CAPSLOCK);
|
|
_vbox_keyboard->PutScancode(Input::KEY_CAPSLOCK | 0x80);
|
|
}
|
|
}
|
|
|
|
void GenodeConsole::handle_input() {
|
|
Libc::with_libc([&] () { _handle_input(); }); }
|
|
|
|
void GenodeConsole::handle_sticky_keys() {
|
|
Libc::with_libc([&] () { _handle_sticky_keys(); }); }
|
|
|
|
void GenodeConsole::handle_mode_change() {
|
|
Libc::with_libc([&] () { _handle_mode_change(); }); }
|
|
|
|
void GenodeConsole::handle_cb_rom_change() {
|
|
Libc::with_libc([&] () { _handle_cb_rom_change(); }); }
|