434 lines
9.8 KiB
C++
434 lines
9.8 KiB
C++
/*
|
|
* \brief Clipboard test
|
|
* \author Norman Feske
|
|
* \date 2015-09-23
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2015 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
/* Genode includes */
|
|
#include <os/server.h>
|
|
#include <report_session/connection.h>
|
|
#include <os/attached_rom_dataspace.h>
|
|
#include <os/reporter.h>
|
|
#include <util/xml_generator.h>
|
|
#include <util/xml_node.h>
|
|
#include <timer_session/connection.h>
|
|
|
|
|
|
class Nitpicker
|
|
{
|
|
private:
|
|
|
|
Timer::Session &_timer;
|
|
|
|
Genode::Reporter _focus_reporter { "focus" };
|
|
|
|
void _focus(char const *domain, bool active)
|
|
{
|
|
Genode::Reporter::Xml_generator xml(_focus_reporter, [&] () {
|
|
xml.attribute("domain", domain);
|
|
xml.attribute("active", active ? "yes" : "no");
|
|
});
|
|
|
|
/*
|
|
* Trigger a state change after a while. We wait a bit after
|
|
* reporting a new focus to give the new state some time to
|
|
* propagate through the report-rom server to the clipboard.
|
|
*/
|
|
_timer.trigger_once(250*1000);
|
|
}
|
|
|
|
public:
|
|
|
|
Nitpicker(Timer::Session &timer)
|
|
:
|
|
_timer(timer)
|
|
{
|
|
_focus_reporter.enabled(true);
|
|
}
|
|
|
|
void focus_active (char const *domain) { _focus(domain, true); }
|
|
void focus_inactive(char const *domain) { _focus(domain, false); }
|
|
};
|
|
|
|
|
|
/**
|
|
* Callback called each time when a subsystem makes progress
|
|
*
|
|
* This function drives the state machine of the test program.
|
|
*/
|
|
struct Handle_step_fn
|
|
{
|
|
virtual void handle_step(unsigned) = 0;
|
|
};
|
|
|
|
|
|
class Subsystem
|
|
{
|
|
private:
|
|
|
|
Server::Entrypoint &_ep;
|
|
|
|
typedef Genode::String<100> Label;
|
|
|
|
Label _name;
|
|
|
|
Handle_step_fn &_handle_step_fn;
|
|
|
|
bool _expect_import = true;
|
|
|
|
Label _session_label()
|
|
{
|
|
char buf[Label::capacity()];
|
|
Genode::snprintf(buf, sizeof(buf), "%s -> clipboard", _name.string());
|
|
return Label(buf);
|
|
}
|
|
|
|
Genode::Attached_rom_dataspace _import_rom;
|
|
|
|
char const *_import_content = nullptr;
|
|
|
|
Report::Connection _export_report { _session_label().string() };
|
|
|
|
Genode::Attached_dataspace _export_report_ds { _export_report.dataspace() };
|
|
|
|
static void _log_lines(char const *string, Genode::size_t len)
|
|
{
|
|
Genode::print_lines<200>(string, len,
|
|
[&] (char const *line) { PLOG(" %s", line); });
|
|
}
|
|
|
|
void _handle_import(unsigned)
|
|
{
|
|
if (!_expect_import) {
|
|
class Unexpected_clipboard_import { };
|
|
throw Unexpected_clipboard_import();
|
|
}
|
|
|
|
PLOG("\n%s: import new content:", _name.string());
|
|
|
|
_import_rom.update();
|
|
|
|
if (!_import_rom.is_valid())
|
|
return;
|
|
|
|
_import_content = _import_rom.local_addr<char>();
|
|
_log_lines(_import_content, _import_rom.size());
|
|
|
|
/* trigger next step */
|
|
_handle_step_fn.handle_step(0);
|
|
}
|
|
|
|
Genode::Signal_rpc_member<Subsystem> _import_dispatcher =
|
|
{ _ep, *this, &Subsystem::_handle_import };
|
|
|
|
static void _strip_outer_whitespace(char const **str_ptr, Genode::size_t &len)
|
|
{
|
|
char const *str = *str_ptr;
|
|
|
|
/* strip leading whitespace */
|
|
for (; Genode::is_whitespace(*str); str++, len--);
|
|
|
|
/* strip trailing whitespace */
|
|
for (; len > 1 && Genode::is_whitespace(str[len - 1]); len--);
|
|
|
|
*str_ptr = str;
|
|
}
|
|
|
|
/**
|
|
* Return currently present imported text
|
|
*
|
|
* \throw Xml_node::Nonexistent_sub_node
|
|
*/
|
|
Genode::Xml_node _imported_text() const
|
|
{
|
|
if (!_import_content)
|
|
throw Genode::Xml_node::Nonexistent_sub_node();
|
|
|
|
Genode::Xml_node clipboard(_import_content,
|
|
_import_rom.size());
|
|
|
|
return clipboard.sub_node("text");
|
|
}
|
|
|
|
public:
|
|
|
|
Subsystem(Server::Entrypoint &ep, char const *name,
|
|
Handle_step_fn &handle_step_fn)
|
|
:
|
|
_ep(ep),
|
|
_name(name),
|
|
_handle_step_fn(handle_step_fn),
|
|
_import_rom(_session_label().string())
|
|
{
|
|
_import_rom.sigh(_import_dispatcher);
|
|
}
|
|
|
|
void copy(char const *str)
|
|
{
|
|
Genode::Xml_generator xml(_export_report_ds.local_addr<char>(),
|
|
_export_report_ds.size(),
|
|
"clipboard", [&] ()
|
|
{
|
|
xml.attribute("origin", _name.string());
|
|
xml.node("text", [&] () {
|
|
xml.append(str, Genode::strlen(str));
|
|
});
|
|
});
|
|
|
|
PLOG("\n%s: export content:", _name.string());
|
|
_log_lines(_export_report_ds.local_addr<char>(), xml.used());
|
|
|
|
_export_report.submit(xml.used());
|
|
}
|
|
|
|
bool has_content(char const *str) const
|
|
{
|
|
using namespace Genode;
|
|
try {
|
|
typedef Genode::String<100> String;
|
|
|
|
String const expected(str);
|
|
String const imported = _imported_text().decoded_content<String>();
|
|
|
|
return expected == imported;
|
|
}
|
|
catch (...) { }
|
|
return false;
|
|
}
|
|
|
|
bool is_cleared() const
|
|
{
|
|
try {
|
|
_imported_text();
|
|
return false;
|
|
} catch (...) { }
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Configure assertion for situation where no imports are expected
|
|
*/
|
|
void expect_import(bool expect) { _expect_import = expect; }
|
|
};
|
|
|
|
|
|
namespace Server { struct Main; }
|
|
|
|
|
|
struct Server::Main : Handle_step_fn
|
|
{
|
|
Entrypoint &_ep;
|
|
|
|
enum State {
|
|
INIT,
|
|
FOCUSED_HOBBY_DOMAIN,
|
|
EXPECT_CAT_PICTURE,
|
|
FOCUSED_ADMIN_DOMAIN,
|
|
EXPECT_PRIVATE_KEY,
|
|
BLOCKED_REPETITION,
|
|
FOCUSED_WORK_DOMAIN,
|
|
EXPECT_CONTRACT,
|
|
FOCUS_BECOMES_INACTIVE,
|
|
BLOCKED_WHEN_INACTIVE,
|
|
FOCUSED_HOBBY_DOMAIN_AGAIN,
|
|
WAIT_FOR_SUCCESS
|
|
};
|
|
|
|
State _state = INIT;
|
|
|
|
static char const *_state_name(State state)
|
|
{
|
|
switch (state) {
|
|
case INIT: return "INIT";
|
|
case FOCUSED_HOBBY_DOMAIN: return "FOCUSED_HOBBY_DOMAIN";
|
|
case EXPECT_CAT_PICTURE: return "EXPECT_CAT_PICTURE";
|
|
case FOCUSED_ADMIN_DOMAIN: return "FOCUSED_ADMIN_DOMAIN";
|
|
case EXPECT_PRIVATE_KEY: return "EXPECT_PRIVATE_KEY";
|
|
case BLOCKED_REPETITION: return "BLOCKED_REPETITION";
|
|
case FOCUSED_WORK_DOMAIN: return "FOCUSED_WORK_DOMAIN";
|
|
case EXPECT_CONTRACT: return "EXPECT_CONTRACT";
|
|
case FOCUS_BECOMES_INACTIVE: return "FOCUS_BECOMES_INACTIVE";
|
|
case BLOCKED_WHEN_INACTIVE: return "BLOCKED_WHEN_INACTIVE";
|
|
case FOCUSED_HOBBY_DOMAIN_AGAIN: return "FOCUSED_HOBBY_DOMAIN_AGAIN";
|
|
case WAIT_FOR_SUCCESS: return "WAIT_FOR_SUCCESS";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void _enter_state(State state)
|
|
{
|
|
PINF("\n-> entering state %s", _state_name(state));
|
|
_state = state;
|
|
}
|
|
|
|
void handle_step(unsigned cnt) override
|
|
{
|
|
PLOG("\n -- state %s --", _state_name(_state));
|
|
|
|
char const * const cat_picture = "cat picture";
|
|
char const * const private_key = "private key";
|
|
char const * const another_private_key = "another private key";
|
|
char const * const contract = "contract";
|
|
char const * const garbage = "garbage";
|
|
|
|
char const * const hobby_domain = "hobby";
|
|
char const * const work_domain = "work";
|
|
char const * const admin_domain = "admin";
|
|
|
|
switch (_state) {
|
|
|
|
case INIT:
|
|
_nitpicker.focus_active(hobby_domain);
|
|
_enter_state(FOCUSED_HOBBY_DOMAIN);
|
|
return;
|
|
|
|
case FOCUSED_HOBBY_DOMAIN:
|
|
_hobby.copy(cat_picture);
|
|
_enter_state(EXPECT_CAT_PICTURE);
|
|
return;
|
|
|
|
case EXPECT_CAT_PICTURE:
|
|
|
|
if (!_hobby.has_content(cat_picture)
|
|
|| !_work .has_content(cat_picture)
|
|
|| !_admin.has_content(cat_picture))
|
|
return;
|
|
|
|
_nitpicker.focus_active(admin_domain);
|
|
_enter_state(FOCUSED_ADMIN_DOMAIN);
|
|
return;
|
|
|
|
case FOCUSED_ADMIN_DOMAIN:
|
|
_admin.copy(private_key);
|
|
_enter_state(EXPECT_PRIVATE_KEY);
|
|
return;
|
|
|
|
case EXPECT_PRIVATE_KEY:
|
|
|
|
if (!_hobby.is_cleared()
|
|
|| !_work .is_cleared()
|
|
|| !_admin.has_content(private_key))
|
|
return;
|
|
|
|
/*
|
|
* Issue a copy operation that leaves the hobby and work
|
|
* domains unchanged. The unchanged domains are not expected
|
|
* to receive any notification. Otherwise, such notifications
|
|
* could be misused as a covert channel.
|
|
*/
|
|
_work .expect_import(false);
|
|
_hobby.expect_import(false);
|
|
_admin.copy(another_private_key);
|
|
|
|
_timer.trigger_once(500*1000);
|
|
_enter_state(BLOCKED_REPETITION);
|
|
return;
|
|
|
|
case BLOCKED_REPETITION:
|
|
|
|
/*
|
|
* Let the work and hobby domains accept new imports.
|
|
*/
|
|
_work .expect_import(true);
|
|
_hobby.expect_import(true);
|
|
|
|
_nitpicker.focus_active(work_domain);
|
|
_enter_state(FOCUSED_WORK_DOMAIN);
|
|
return;
|
|
|
|
case FOCUSED_WORK_DOMAIN:
|
|
_work.copy(contract);
|
|
_enter_state(EXPECT_CONTRACT);
|
|
return;
|
|
|
|
case EXPECT_CONTRACT:
|
|
|
|
if (!_hobby.is_cleared()
|
|
|| !_work .has_content(contract)
|
|
|| !_admin.has_content(contract))
|
|
return;
|
|
|
|
_nitpicker.focus_inactive(work_domain);
|
|
_enter_state(FOCUS_BECOMES_INACTIVE);
|
|
return;
|
|
|
|
case FOCUS_BECOMES_INACTIVE:
|
|
|
|
/*
|
|
* With the focus becoming inactive, we do not expect the
|
|
* delivery of any new clipboard content.
|
|
*/
|
|
_work .expect_import(false);
|
|
_admin.expect_import(false);
|
|
_hobby.expect_import(false);
|
|
_work.copy(garbage);
|
|
|
|
/*
|
|
* Since no state changes are triggered from the outside,
|
|
* we schedule a timeout to proceed.
|
|
*/
|
|
_timer.trigger_once(500*1000);
|
|
_enter_state(BLOCKED_WHEN_INACTIVE);
|
|
return;
|
|
|
|
case BLOCKED_WHEN_INACTIVE:
|
|
_nitpicker.focus_active(hobby_domain);
|
|
_enter_state(FOCUSED_HOBBY_DOMAIN_AGAIN);
|
|
return;
|
|
|
|
case FOCUSED_HOBBY_DOMAIN_AGAIN:
|
|
/*
|
|
* Let the work domain try to issue a copy operation while the
|
|
* hobby domain is focused. The clipboard is expected to block
|
|
* this report.
|
|
*/
|
|
_work.copy(garbage);
|
|
_timer.trigger_once(500*1000);
|
|
_enter_state(WAIT_FOR_SUCCESS);
|
|
return;
|
|
|
|
case WAIT_FOR_SUCCESS:
|
|
break;
|
|
}
|
|
}
|
|
|
|
Genode::Signal_rpc_member<Main> _step_dispatcher =
|
|
{ _ep, *this, &Main::handle_step };
|
|
|
|
Subsystem _admin { _ep, "noux", *this };
|
|
Subsystem _hobby { _ep, "linux", *this };
|
|
Subsystem _work { _ep, "win7", *this };
|
|
|
|
Timer::Connection _timer;
|
|
|
|
Nitpicker _nitpicker { _timer };
|
|
|
|
Main(Entrypoint &ep) : _ep(ep)
|
|
{
|
|
_timer.sigh(_step_dispatcher);
|
|
|
|
/* trigger first step */
|
|
handle_step(0);
|
|
}
|
|
};
|
|
|
|
|
|
namespace Server {
|
|
|
|
char const *name() { return "ep"; }
|
|
|
|
size_t stack_size() { return 4*1024*sizeof(long); }
|
|
|
|
void construct(Entrypoint &ep)
|
|
{
|
|
static Main main(ep);
|
|
}
|
|
}
|