namespace {
/**
- * Invoke specific function on ScClient
+ * Invoke specific function on VsmClient
*
* @param fun Function to be called. It must not throw any exception.
*/
-void one_shot(const function<ScStatus(ScClient)>& fun)
+void one_shot(const function<VsmStatus(VsmClient)>& fun)
{
string msg;
- ScStatus status;
- ScClient client;
+ VsmStatus status;
+ VsmClient client;
- status = sc_start_glib_loop();
- if (SCCLIENT_SUCCESS != status) {
+ status = vsm_start_glib_loop();
+ if (VSMCLIENT_SUCCESS != status) {
throw runtime_error("Can't start glib loop");
}
- client = sc_client_create();
+ client = vsm_client_create();
if (NULL == client) {
msg = "Can't create client";
goto finish;
}
- status = sc_connect(client);
- if (SCCLIENT_SUCCESS != status) {
- msg = sc_get_status_message(client);
+ status = vsm_connect(client);
+ if (VSMCLIENT_SUCCESS != status) {
+ msg = vsm_get_status_message(client);
goto finish;
}
status = fun(client);
- if (SCCLIENT_SUCCESS != status) {
- msg = sc_get_status_message(client);
+ if (VSMCLIENT_SUCCESS != status) {
+ msg = vsm_get_status_message(client);
goto finish;
}
finish:
- sc_client_free(client);
- sc_stop_glib_loop();
+ vsm_client_free(client);
+ vsm_stop_glib_loop();
if (! msg.empty()) {
throw runtime_error(msg);
}
throw runtime_error("Not enough parameters");
}
- one_shot(bind(sc_set_active_container, _1, argv[pos + 1]));
+ one_shot(bind(vsm_set_active_container, _1, argv[pos + 1]));
}
-void add_container(int pos, int argc, const char** argv)
+void create_domain(int pos, int argc, const char** argv)
{
using namespace std::placeholders;
throw runtime_error("Not enough parameters");
}
- one_shot(bind(sc_add_container, _1, argv[pos + 1]));
+ one_shot(bind(vsm_create_domain, _1, argv[pos + 1]));
}
} // namespace cli
* @param argsSpec Description of arguments
*/
CommandLineInterface(const ExecutorCallback& executorCallback,
- const std::string& usage,
- const std::string& usageInfo,
- const ArgsSpec& argsSpec)
+ const std::string& usage,
+ const std::string& usageInfo,
+ const ArgsSpec& argsSpec)
: mExecutorCallback(executorCallback),
mUsage(usage),
mUsageInfo(usageInfo),
};
/**
- * Parses command line arguments and call sc_set_active_container
+ * Parses command line arguments and call vsm_set_active_container
*
- * @see sc_set_active_container
+ * @see vsm_set_active_container
*/
void set_active_container(int pos, int argc, const char** argv);
/**
- * Parses command line arguments and call sc_add_container
+ * Parses command line arguments and call vsm_create_domain
*
- * @see sc_add_container
+ * @see vsm_create_domain
*/
-void add_container(int pos, int argc, const char** argv);
+void create_domain(int pos, int argc, const char** argv);
} // namespace cli
} // namespace security_containers
using namespace security_containers::cli;
std::map<std::string, CommandLineInterface> commands = {
- {"set_active_container", {
- set_active_container,
- "set_active_container container_id",
- "Set active (foreground) container",
- {{"container_id", "id container name"}}}
+ {
+ "set_active_container", {
+ set_active_container,
+ "set_active_container container_id",
+ "Set active (foreground) container",
+ {{"container_id", "id container name"}}
+ }
},
- {"add_container", {
- add_container,
- "add_container container_id",
- "Create and add container",
- {{"container_id", "id container name"}}}
+ {
+ "create_domain", {
+ create_domain,
+ "create_domain container_id",
+ "Create and add container",
+ {{"container_id", "id container name"}}
+ }
}
};
CommandLineInterface& command = commands[argv[1]];
try {
- command.execute(1, argc, argv);
+ command.execute(1, argc, argv);
} catch (const std::runtime_error& ex) {
std::cerr << ex.what() << std::endl;
return EXIT_FAILURE;
unique_ptr<ScopedGlibLoop> gGlibLoop;
-void toDict(GVariant* in, ScArrayString* keys, ScArrayString* values)
+void toDict(GVariant* in, VsmArrayString* keys, VsmArrayString* values)
{
assert(in);
assert(keys);
*scArray = ids;
}
-ScStatus toStatus(const std::exception& ex)
+VsmStatus toStatus(const std::exception& ex)
{
if (typeid(DbusCustomException) == typeid(ex)) {
- return SCCLIENT_CUSTOM_ERROR;
+ return VSMCLIENT_CUSTOM_ERROR;
} else if (typeid(DbusIOException) == typeid(ex)) {
- return SCCLIENT_IO_ERROR;
+ return VSMCLIENT_IO_ERROR;
} else if (typeid(DbusOperationException) == typeid(ex)) {
- return SCCLIENT_OPERATION_FAILED;
+ return VSMCLIENT_OPERATION_FAILED;
} else if (typeid(DbusInvalidArgumentException) == typeid(ex)) {
- return SCCLIENT_INVALID_ARGUMENT;
+ return VSMCLIENT_INVALID_ARGUMENT;
} else if (typeid(DbusException) == typeid(ex)) {
- return SCCLIENT_OTHER_ERROR;
+ return VSMCLIENT_OTHER_ERROR;
}
- return SCCLIENT_OTHER_ERROR;
+ return VSMCLIENT_OTHER_ERROR;
}
bool readFirstLineOfFile(const std::string& path, std::string& ret)
} //namespace
-ScStatus Client::sc_start_glib_loop() noexcept
+VsmStatus Client::vsm_start_glib_loop() noexcept
{
try {
if (!gGlibLoop) {
gGlibLoop.reset(new ScopedGlibLoop());
}
} catch (const exception&) {
- return SCCLIENT_OTHER_ERROR;
+ return VSMCLIENT_OTHER_ERROR;
}
- return SCCLIENT_SUCCESS;
+ return VSMCLIENT_SUCCESS;
}
-ScStatus Client::sc_stop_glib_loop() noexcept
+VsmStatus Client::vsm_stop_glib_loop() noexcept
{
try {
gGlibLoop.reset();
} catch (const exception&) {
- return SCCLIENT_OTHER_ERROR;
+ return VSMCLIENT_OTHER_ERROR;
}
- return SCCLIENT_SUCCESS;
+ return VSMCLIENT_SUCCESS;
}
Client::Status::Status()
- : mScStatus(SCCLIENT_SUCCESS), mMsg()
+ : mVsmStatus(VSMCLIENT_SUCCESS), mMsg()
{
}
-Client::Status::Status(ScStatus status, const std::string& msg)
- : mScStatus(status), mMsg(msg)
+Client::Status::Status(VsmStatus status, const std::string& msg)
+ : mVsmStatus(status), mMsg(msg)
{
}
{
}
-ScStatus Client::createSystem() noexcept
+VsmStatus Client::createSystem() noexcept
{
try {
mConnection = DbusConnection::createSystem();
mStatus = Status();
- } catch (const exception& ex) {
+ } catch (const exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
}
- return sc_get_status();
+ return vsm_get_status();
}
-ScStatus Client::create(const string& address) noexcept
+VsmStatus Client::create(const string& address) noexcept
{
try {
mConnection = DbusConnection::create(address);
mStatus = Status();
- } catch (const exception& ex) {
+ } catch (const exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
}
- return sc_get_status();
+ return vsm_get_status();
}
-ScStatus Client::callMethod(const DbusInterfaceInfo& info,
- const string& method,
- GVariant* args_in,
- const string& args_spec_out,
- GVariant** args_out)
+VsmStatus Client::callMethod(const DbusInterfaceInfo& info,
+ const string& method,
+ GVariant* args_in,
+ const string& args_spec_out,
+ GVariant** args_out)
{
try {
GVariantPtr ret = mConnection->callMethod(info.busName,
} catch (const exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
}
- return sc_get_status();
+ return vsm_get_status();
}
-ScStatus Client::signalSubscribe(const DbusInterfaceInfo& info,
- const string& name,
- SignalCallback signalCallback)
+VsmStatus Client::signalSubscribe(const DbusInterfaceInfo& info,
+ const string& name,
+ SignalCallback signalCallback)
{
auto onSignal = [=](const std::string& /*senderBusName*/,
const std::string & objectPath,
const std::string & signalName,
GVariant * parameters) {
if (objectPath == info.objectPath &&
- interface == info.interface &&
- signalName == name) {
+ interface == info.interface &&
+ signalName == name) {
signalCallback(parameters);
}
} catch (const std::exception& ex) {
mStatus = Status(toStatus(ex), ex.what());
}
- return sc_get_status();
+ return vsm_get_status();
}
-const char* Client::sc_get_status_message() noexcept
+const char* Client::vsm_get_status_message() noexcept
{
return mStatus.mMsg.c_str();
}
-ScStatus Client::sc_get_status() noexcept
+VsmStatus Client::vsm_get_status() noexcept
{
- return mStatus.mScStatus;
+ return mStatus.mVsmStatus;
}
-ScStatus Client::sc_get_container_dbuses(ScArrayString* keys, ScArrayString* values) noexcept
+VsmStatus Client::vsm_get_container_dbuses(VsmArrayString* keys, VsmArrayString* values) noexcept
{
assert(keys);
assert(values);
GVariant* out;
- ScStatus ret = callMethod(HOST_INTERFACE,
- api::host::METHOD_GET_CONTAINER_DBUSES,
- NULL,
- "(a{ss})",
- &out);
- if (ret != SCCLIENT_SUCCESS) {
+ VsmStatus ret = callMethod(HOST_INTERFACE,
+ api::host::METHOD_GET_CONTAINER_DBUSES,
+ NULL,
+ "(a{ss})",
+ &out);
+ if (ret != VSMCLIENT_SUCCESS) {
return ret;
}
GVariant* unpacked;
return ret;
}
-ScStatus Client::sc_get_container_ids(ScArrayString* array) noexcept
+VsmStatus Client::vsm_get_domain_ids(VsmArrayString* array) noexcept
{
assert(array);
GVariant* out;
- ScStatus ret = callMethod(HOST_INTERFACE,
- api::host::METHOD_GET_CONTAINER_ID_LIST,
- NULL,
- "(as)",
- &out);
- if (ret != SCCLIENT_SUCCESS) {
+ VsmStatus ret = callMethod(HOST_INTERFACE,
+ api::host::METHOD_GET_CONTAINER_ID_LIST,
+ NULL,
+ "(as)",
+ &out);
+ if (ret != VSMCLIENT_SUCCESS) {
return ret;
}
GVariant* unpacked;
return ret;
}
-ScStatus Client::sc_get_active_container_id(ScString* id) noexcept
+VsmStatus Client::vsm_get_active_container_id(VsmString* id) noexcept
{
assert(id);
GVariant* out;
- ScStatus ret = callMethod(HOST_INTERFACE,
- api::host::METHOD_GET_ACTIVE_CONTAINER_ID,
- NULL,
- "(s)",
- &out);
- if (ret != SCCLIENT_SUCCESS) {
+ VsmStatus ret = callMethod(HOST_INTERFACE,
+ api::host::METHOD_GET_ACTIVE_CONTAINER_ID,
+ NULL,
+ "(s)",
+ &out);
+ if (ret != VSMCLIENT_SUCCESS) {
return ret;
}
GVariant* unpacked;
return ret;
}
-ScStatus Client::sc_get_container_id_by_pid(int pid, ScString* id) noexcept
+VsmStatus Client::vsm_lookup_domain_by_pid(int pid, VsmString* id) noexcept
{
assert(id);
std::string cpuset;
if (!readFirstLineOfFile(path, cpuset)) {
- mStatus = Status(SCCLIENT_INVALID_ARGUMENT, "Process not found");
- return sc_get_status();
+ mStatus = Status(VSMCLIENT_INVALID_ARGUMENT, "Process not found");
+ return vsm_get_status();
}
std::string containerId;
if (!parseContainerIdFromCpuSet(cpuset, containerId)) {
- mStatus = Status(SCCLIENT_OTHER_ERROR, "unknown format of cpuset");
- return sc_get_status();
+ mStatus = Status(VSMCLIENT_OTHER_ERROR, "unknown format of cpuset");
+ return vsm_get_status();
}
*id = strdup(containerId.c_str());
mStatus = Status();
- return sc_get_status();;
+ return vsm_get_status();;
}
-ScStatus Client::sc_set_active_container(const char* id) noexcept
+VsmStatus Client::vsm_set_active_container(const char* id) noexcept
{
assert(id);
return callMethod(HOST_INTERFACE, api::host::METHOD_SET_ACTIVE_CONTAINER, args_in);
}
-ScStatus Client::sc_add_container(const char* id) noexcept
+VsmStatus Client::vsm_create_domain(const char* id) noexcept
{
assert(id);
return callMethod(HOST_INTERFACE, api::host::METHOD_ADD_CONTAINER, args_in);
}
-ScStatus Client::sc_container_dbus_state(ScContainerDbusStateCallback containerDbusStateCallback,
+VsmStatus Client::vsm_add_state_callback(VsmContainerDbusStateCallback containerDbusStateCallback,
void* data) noexcept
{
assert(containerDbusStateCallback);
- auto onSigal = [=](GVariant * parameters) {
+ auto onSigal = [=](GVariant * parameters)
+ {
const char* container;
const char* dbusAddress;
g_variant_get(parameters, "(&s&s)", &container, &dbusAddress);
onSigal);
}
-ScStatus Client::sc_notify_active_container(const char* application, const char* message) noexcept
+VsmStatus Client::vsm_notify_active_container(const char* application, const char* message) noexcept
{
assert(application);
assert(message);
args_in);
}
-ScStatus Client::sc_file_move_request(const char* destContainer, const char* path) noexcept
+VsmStatus Client::vsm_file_move_request(const char* destContainer, const char* path) noexcept
{
assert(destContainer);
assert(path);
GVariant* out;
GVariant* args_in = g_variant_new("(ss)", destContainer, path);
- ScStatus ret = callMethod(CONTAINER_INTERFACE,
- api::container::METHOD_FILE_MOVE_REQUEST,
- args_in,
- "(s)",
- &out);
+ VsmStatus ret = callMethod(CONTAINER_INTERFACE,
+ api::container::METHOD_FILE_MOVE_REQUEST,
+ args_in,
+ "(s)",
+ &out);
- if (ret != SCCLIENT_SUCCESS) {
+ if (ret != VSMCLIENT_SUCCESS) {
return ret;
}
const gchar* retcode = NULL;;
g_variant_get(out, "(&s)", &retcode);
if (strcmp(retcode, api::container::FILE_MOVE_SUCCEEDED.c_str()) != 0) {
- mStatus = Status(SCCLIENT_CUSTOM_ERROR, retcode);
+ mStatus = Status(VSMCLIENT_CUSTOM_ERROR, retcode);
g_variant_unref(out);
- return sc_get_status();
+ return vsm_get_status();
}
g_variant_unref(out);
return ret;
}
-ScStatus Client::sc_notification(ScNotificationCallback notificationCallback, void* data) noexcept
+VsmStatus Client::vsm_notification(VsmNotificationCallback notificationCallback, void* data) noexcept
{
assert(notificationCallback);
typedef std::function<void(GVariant* parameters)> SignalCallback;
struct Status {
Status();
- Status(ScStatus status, const std::string& msg);
- ScStatus mScStatus;
+ Status(VsmStatus status, const std::string& msg);
+ VsmStatus mVsmStatus;
std::string mMsg;
};
dbus::DbusConnection::Pointer mConnection;
Status mStatus;
- ScStatus callMethod(const DbusInterfaceInfo& info,
- const std::string& method,
- GVariant* args_in,
- const std::string& args_spec_out = std::string(),
- GVariant** args_out = NULL);
- ScStatus signalSubscribe(const DbusInterfaceInfo& info,
- const std::string& name,
- SignalCallback signalCallback);
+ VsmStatus callMethod(const DbusInterfaceInfo& info,
+ const std::string& method,
+ GVariant* args_in,
+ const std::string& args_spec_out = std::string(),
+ GVariant** args_out = NULL);
+ VsmStatus signalSubscribe(const DbusInterfaceInfo& info,
+ const std::string& name,
+ SignalCallback signalCallback);
public:
Client() noexcept;
*
* @return status of this function call
*/
- ScStatus createSystem() noexcept;
+ VsmStatus createSystem() noexcept;
/**
* Create client.
* @param address Dbus socket address
* @return status of this function call
*/
- ScStatus create(const std::string& address) noexcept;
+ VsmStatus create(const std::string& address) noexcept;
/**
- * @see ::sc_get_status_message
+ * @see ::vsm_get_status_message
*/
- const char* sc_get_status_message() noexcept;
+ const char* vsm_get_status_message() noexcept;
/**
- * @see ::sc_get_status
+ * @see ::vsm_get_status
*/
- ScStatus sc_get_status() noexcept;
+ VsmStatus vsm_get_status() noexcept;
/**
- * @see ::sc_get_container_dbuses
+ * @see ::vsm_get_container_dbuses
*/
- ScStatus sc_get_container_dbuses(ScArrayString* keys, ScArrayString* values) noexcept;
+ VsmStatus vsm_get_container_dbuses(VsmArrayString* keys, VsmArrayString* values) noexcept;
/**
- * @see ::sc_get_container_ids
+ * @see ::vsm_get_domain_ids
*/
- ScStatus sc_get_container_ids(ScArrayString* array) noexcept;
+ VsmStatus vsm_get_domain_ids(VsmArrayString* array) noexcept;
/**
- * @see ::sc_get_active_container_id
+ * @see ::vsm_get_active_container_id
*/
- ScStatus sc_get_active_container_id(ScString* id) noexcept;
+ VsmStatus vsm_get_active_container_id(VsmString* id) noexcept;
/**
- * @see ::sc_get_container_id_by_pid
+ * @see ::vsm_lookup_domain_by_pid
*/
- ScStatus sc_get_container_id_by_pid(int pid, ScString* id) noexcept;
+ VsmStatus vsm_lookup_domain_by_pid(int pid, VsmString* id) noexcept;
/**
- * @see ::sc_set_active_container
+ * @see ::vsm_set_active_container
*/
- ScStatus sc_set_active_container(const char* id) noexcept;
+ VsmStatus vsm_set_active_container(const char* id) noexcept;
/**
- * @see ::sc_add_container
+ * @see ::vsm_create_domain
*/
- ScStatus sc_add_container(const char* id) noexcept;
+ VsmStatus vsm_create_domain(const char* id) noexcept;
/**
- * @see ::sc_container_dbus_state
+ * @see ::vsm_add_state_callback
*/
- ScStatus sc_container_dbus_state(ScContainerDbusStateCallback containerDbusStateCallback,
+ VsmStatus vsm_add_state_callback(VsmContainerDbusStateCallback containerDbusStateCallback,
void* data) noexcept;
/**
- * @see ::sc_notify_active_container
+ * @see ::vsm_notify_active_container
*/
- ScStatus sc_notify_active_container(const char* application, const char* message) noexcept;
+ VsmStatus vsm_notify_active_container(const char* application, const char* message) noexcept;
/**
- * @see ::sc_file_move_request
+ * @see ::vsm_file_move_request
*/
- ScStatus sc_file_move_request(const char* destContainer, const char* path) noexcept;
+ VsmStatus vsm_file_move_request(const char* destContainer, const char* path) noexcept;
/**
- * @see ::sc_notification
+ * @see ::vsm_notification
*/
- ScStatus sc_notification(ScNotificationCallback notificationCallback, void* data) noexcept;
+ VsmStatus vsm_notification(VsmNotificationCallback notificationCallback, void* data) noexcept;
/**
- * @see ::sc_start_glib_loop
+ * @see ::vsm_start_glib_loop
*/
- static ScStatus sc_start_glib_loop() noexcept;
+ static VsmStatus vsm_start_glib_loop() noexcept;
/**
- * @see ::sc_stop_glib_loop
+ * @see ::vsm_stop_glib_loop
*/
- static ScStatus sc_stop_glib_loop() noexcept;
+ static VsmStatus vsm_stop_glib_loop() noexcept;
};
#endif /* SECURITY_CONTAINERS_CLIENT_IMPL_HPP */
namespace {
-Client& getClient(ScClient client)
+Client& getClient(VsmClient client)
{
assert(client);
return *reinterpret_cast<Client*>(client);
} // namespace
/* external */
-API ScStatus sc_start_glib_loop()
+API VsmStatus vsm_start_glib_loop()
{
- return Client::sc_start_glib_loop();
+ return Client::vsm_start_glib_loop();
}
-API ScStatus sc_stop_glib_loop()
+API VsmStatus vsm_stop_glib_loop()
{
- return Client::sc_stop_glib_loop();
+ return Client::vsm_stop_glib_loop();
}
-API ScClient sc_client_create()
+API VsmClient vsm_client_create()
{
Client* clientPtr = new(nothrow) Client();
- return reinterpret_cast<ScClient>(clientPtr);
+ return reinterpret_cast<VsmClient>(clientPtr);
}
-API ScStatus sc_connect(ScClient client)
+API VsmStatus vsm_connect(VsmClient client)
{
return getClient(client).createSystem();
}
-API ScStatus sc_connect_custom(ScClient client, const char* address)
+API VsmStatus vsm_connect_custom(VsmClient client, const char* address)
{
return getClient(client).create(address);
}
-API void sc_array_string_free(ScArrayString astring)
+API void vsm_array_string_free(VsmArrayString astring)
{
if (!astring) {
return;
}
for (char** ptr = astring; *ptr; ++ptr) {
- sc_string_free(*ptr);
+ vsm_string_free(*ptr);
}
free(astring);
}
-API void sc_string_free(ScString string)
+API void vsm_string_free(VsmString string)
{
free(string);
}
-API void sc_client_free(ScClient client)
+API void vsm_client_free(VsmClient client)
{
if (client != NULL) {
delete &getClient(client);
}
}
-API const char* sc_get_status_message(ScClient client)
+API const char* vsm_get_status_message(VsmClient client)
{
- return getClient(client).sc_get_status_message();
+ return getClient(client).vsm_get_status_message();
}
-API ScStatus sc_get_status(ScClient client)
+API VsmStatus vsm_get_status(VsmClient client)
{
- return getClient(client).sc_get_status();
+ return getClient(client).vsm_get_status();
}
-API ScStatus sc_get_container_dbuses(ScClient client, ScArrayString* keys, ScArrayString* values)
+API VsmStatus vsm_get_container_dbuses(VsmClient client, VsmArrayString* keys, VsmArrayString* values)
{
- return getClient(client).sc_get_container_dbuses(keys, values);
+ return getClient(client).vsm_get_container_dbuses(keys, values);
}
-API ScStatus sc_get_container_ids(ScClient client, ScArrayString* array)
+API VsmStatus vsm_get_domain_ids(VsmClient client, VsmArrayString* array)
{
- return getClient(client).sc_get_container_ids(array);
+ return getClient(client).vsm_get_domain_ids(array);
}
-API ScStatus sc_get_active_container_id(ScClient client, ScString* id)
+API VsmStatus vsm_get_active_container_id(VsmClient client, VsmString* id)
{
- return getClient(client).sc_get_active_container_id(id);
+ return getClient(client).vsm_get_active_container_id(id);
}
-API ScStatus sc_get_container_id_by_pid(ScClient client, int pid, ScString* id)
+API VsmStatus vsm_lookup_domain_by_pid(VsmClient client, int pid, VsmString* id)
{
- return getClient(client).sc_get_container_id_by_pid(pid, id);
+ return getClient(client).vsm_lookup_domain_by_pid(pid, id);
}
-API ScStatus sc_set_active_container(ScClient client, const char* id)
+API VsmStatus vsm_set_active_container(VsmClient client, const char* id)
{
- return getClient(client).sc_set_active_container(id);
+ return getClient(client).vsm_set_active_container(id);
}
-API ScStatus sc_add_container(ScClient client, const char* id)
+API VsmStatus vsm_create_domain(VsmClient client, const char* id)
{
- return getClient(client).sc_add_container(id);
+ return getClient(client).vsm_create_domain(id);
}
-API ScStatus sc_container_dbus_state(ScClient client,
- ScContainerDbusStateCallback containerDbusStateCallback,
+API VsmStatus vsm_add_state_callback(VsmClient client,
+ VsmContainerDbusStateCallback containerDbusStateCallback,
void* data)
{
- return getClient(client).sc_container_dbus_state(containerDbusStateCallback, data);
+ return getClient(client).vsm_add_state_callback(containerDbusStateCallback, data);
}
-API ScStatus sc_notify_active_container(ScClient client,
- const char* application,
- const char* message)
+API VsmStatus vsm_notify_active_container(VsmClient client,
+ const char* application,
+ const char* message)
{
- return getClient(client).sc_notify_active_container(application, message);
+ return getClient(client).vsm_notify_active_container(application, message);
}
-API ScStatus sc_file_move_request(ScClient client, const char* destContainer, const char* path)
+API VsmStatus vsm_file_move_request(VsmClient client, const char* destContainer, const char* path)
{
- return getClient(client).sc_file_move_request(destContainer, path);
+ return getClient(client).vsm_file_move_request(destContainer, path);
}
-API ScStatus sc_notification(ScClient client,
- ScNotificationCallback notificationCallback,
- void* data)
+API VsmStatus vsm_notification(VsmClient client,
+ VsmNotificationCallback notificationCallback,
+ void* data)
{
- return getClient(client).sc_notification(notificationCallback, data);
+ return getClient(client).vsm_notification(notificationCallback, data);
}
int main(int argc, char** argv)
{
- ScStatus status;
- ScClient client;
- ScArrayString values = NULL;
+ VsmStatus status;
+ VsmClient client;
+ VsmArrayString values = NULL;
int ret = 0;
- status = sc_start_glib_loop(); // start glib loop (if not started any yet)
- if (SCCLIENT_SUCCESS != status) {
+ status = vsm_start_glib_loop(); // start glib loop (if not started any yet)
+ if (VSMCLIENT_SUCCESS != status) {
// error!
return 1;
}
- client = sc_client_create(); // create client handle
+ client = vsm_client_create(); // create client handle
if (NULL == client) {
// error!
ret = 1;
goto finish;
}
- status = sc_connect(client); // connect to dbus
- if (SCCLIENT_SUCCESS != status) {
+ status = vsm_connect(client); // connect to dbus
+ if (VSMCLIENT_SUCCESS != status) {
// error!
ret = 1;
goto finish;
}
- status = sc_get_container_ids(client, &values);
- if (SCCLIENT_SUCCESS != status) {
+ status = vsm_get_domain_ids(client, &values);
+ if (VSMCLIENT_SUCCESS != status) {
// error!
ret = 1;
goto finish;
}
// print array
- for (ScArrayString iValues = values; *iValues; iValues++) {
+ for (VsmArrayString iValues = values; *iValues; iValues++) {
printf("%s\n", *iValues);
}
finish:
- sc_array_string_free(values); // free memory
- sc_client_free(client); // destroy client handle
- sc_stop_glib_loop(); // stop the glib loop (use only with sc_start_glib_loop)
+ vsm_array_string_free(values); // free memory
+ vsm_client_free(client); // destroy client handle
+ vsm_stop_glib_loop(); // stop the glib loop (use only with vsm_start_glib_loop)
return ret;
}
@endcode
/**
* security-containers-server's client pointer.
*/
-typedef void* ScClient;
+typedef void* VsmClient;
/**
* NULL-terminated string type.
*
- * @sa sc_array_string_free
+ * @sa vsm_array_string_free
*/
-typedef char* ScString;
+typedef char* VsmString;
/**
* NULL-terminated array of strings type.
*
- * @sa sc_string_free
+ * @sa vsm_string_free
*/
-typedef ScString* ScArrayString;
+typedef VsmString* VsmArrayString;
/**
* Completion status of communication function.
*/
typedef enum {
- SCCLIENT_CUSTOM_ERROR, ///< User specified error
- SCCLIENT_IO_ERROR, ///< Input/Output error
- SCCLIENT_OPERATION_FAILED, ///< Operation failed
- SCCLIENT_INVALID_ARGUMENT, ///< Invalid argument
- SCCLIENT_OTHER_ERROR, ///< Other error
- SCCLIENT_SUCCESS ///< Success
-} ScStatus;
+ VSMCLIENT_CUSTOM_ERROR, ///< User specified error
+ VSMCLIENT_IO_ERROR, ///< Input/Output error
+ VSMCLIENT_OPERATION_FAILED, ///< Operation failed
+ VSMCLIENT_INVALID_ARGUMENT, ///< Invalid argument
+ VSMCLIENT_OTHER_ERROR, ///< Other error
+ VSMCLIENT_SUCCESS ///< Success
+} VsmStatus;
/**
* Start glib loop.
*
* @return status of this function call
*/
-ScStatus sc_start_glib_loop();
+VsmStatus vsm_start_glib_loop();
/**
* Stop glib loop.
*
- * Call only if sc_start_glib_loop() was called.
+ * Call only if vsm_start_glib_loop() was called.
*
* @return status of this function call
*/
-ScStatus sc_stop_glib_loop();
+VsmStatus vsm_stop_glib_loop();
/**
* Create a new security-containers-server's client.
*
* @return Created client pointer or NULL on failure.
*/
-ScClient sc_client_create();
+VsmClient vsm_client_create();
/**
* Release client resources.
*
* @param[in] client security-containers-server's client
*/
-void sc_client_free(ScClient client);
+void vsm_client_free(VsmClient client);
/**
* Get status code of last security-containers-server communication.
* @param[in] client security-containers-server's client
* @return status of this function call
*/
-ScStatus sc_get_status(ScClient client);
+VsmStatus vsm_get_status(VsmClient client);
/**
* Get status message of the last security-containers-server communication.
* @param[in] client security-containers-server's client
* @return last status message from security-containers-server communication
*/
-const char* sc_get_status_message(ScClient client);
+const char* vsm_get_status_message(VsmClient client);
/**
* Connect client to the security-containers-server.
* @param[in] client security-containers-server's client
* @return status of this function call
*/
-ScStatus sc_connect(ScClient client);
+VsmStatus vsm_connect(VsmClient client);
/**
* Connect client to the security-containers-server via custom address.
* @param[in] address dbus address
* @return status of this function call
*/
-ScStatus sc_connect_custom(ScClient client, const char* address);
+VsmStatus vsm_connect_custom(VsmClient client, const char* address);
/**
- * Release ScArrayString.
+ * Release VsmArrayString.
*
- * @param[in] astring ScArrayString
+ * @param[in] astring VsmArrayString
*/
-void sc_array_string_free(ScArrayString astring);
+void vsm_array_string_free(VsmArrayString astring);
/**
- * Release ScString.
+ * Release VsmString.
*
- * @param string ScString
+ * @param string VsmString
*/
-void sc_string_free(ScString string);
+void vsm_string_free(VsmString string);
/**
*
* @param[in] containerId affected container id
* @param[in] dbusAddress new D-Bus address
- * @param data custom user's data pointer passed to sc_container_dbus_state() function
+ * @param data custom user's data pointer passed to vsm_add_state_callback() function
*/
-typedef void (*ScContainerDbusStateCallback)(const char* containerId,
+typedef void (*VsmContainerDbusStateCallback)(const char* containerId,
const char* dbusAddress,
void* data);
* @param[out] values array of containers dbus address
* @return status of this function call
* @post keys[i] corresponds to values[i]
- * @remark Use sc_array_string_free() to free memory occupied by @p keys and @p values.
+ * @remark Use vsm_array_string_free() to free memory occupied by @p keys and @p values.
*/
-ScStatus sc_get_container_dbuses(ScClient client, ScArrayString* keys, ScArrayString* values);
+VsmStatus vsm_get_container_dbuses(VsmClient client, VsmArrayString* keys, VsmArrayString* values);
/**
* Get containers name.
* @param[in] client security-containers-server's client
* @param[out] array array of containers name
* @return status of this function call
- * @remark Use sc_array_string_free() to free memory occupied by @p array.
+ * @remark Use vsm_array_string_free() to free memory occupied by @p array.
*/
-ScStatus sc_get_container_ids(ScClient client, ScArrayString* array);
+VsmStatus vsm_get_domain_ids(VsmClient client, VsmArrayString* array);
/**
* Get active (foreground) container name.
* @param[in] client security-containers-server's client
* @param[out] id active container name
* @return status of this function call
- * @remark Use @p sc_string_free() to free memory occupied by @p id.
+ * @remark Use @p vsm_string_free() to free memory occupied by @p id.
*/
-ScStatus sc_get_active_container_id(ScClient client, ScString* id);
+VsmStatus vsm_get_active_container_id(VsmClient client, VsmString* id);
/**
* Get container name of process with given pid.
* @param[in] pid process id
* @param[out] id active container name
* @return status of this function call
- * @remark Use @p sc_string_free() to free memory occupied by @p id.
+ * @remark Use @p vsm_string_free() to free memory occupied by @p id.
*/
-ScStatus sc_get_container_id_by_pid(ScClient client, int pid, ScString* id);
+VsmStatus vsm_lookup_domain_by_pid(VsmClient client, int pid, VsmString* id);
/**
* Set active (foreground) container.
* @param[in] id container name
* @return status of this function call
*/
-ScStatus sc_set_active_container(ScClient client, const char* id);
+VsmStatus vsm_set_active_container(VsmClient client, const char* id);
/**
* Create and add container
* @param[in] id container id
* @return status of this function call
*/
-ScStatus sc_add_container(ScClient client, const char* id);
+VsmStatus vsm_create_domain(VsmClient client, const char* id);
/**
* Register dbus state change callback function.
* @param[in] data some extra data that will be passed to callback function
* @return status of this function call
*/
-ScStatus sc_container_dbus_state(ScClient client,
- ScContainerDbusStateCallback containerDbusStateCallback,
+VsmStatus vsm_add_state_callback(VsmClient client,
+ VsmContainerDbusStateCallback containerDbusStateCallback,
void* data);
/** @} */ // Host API
* @param[in] container source container
* @param[in] application sending application name
* @param[in] message notification message
- * @param data custom user's data pointer passed to sc_notification()
+ * @param data custom user's data pointer passed to vsm_notification()
*/
-typedef void (*ScNotificationCallback)(const char* container,
+typedef void (*VsmNotificationCallback)(const char* container,
const char* application,
const char* message,
void* data);
* @param[in] message message
* @return status of this function call
*/
-ScStatus sc_notify_active_container(ScClient client, const char* application, const char* message);
+VsmStatus vsm_notify_active_container(VsmClient client, const char* application, const char* message);
/**
* Move file between containers.
* @param[in] path path to moved file
* @return status of this function call
*/
-ScStatus sc_file_move_request(ScClient client, const char* destContainer, const char* path);
+VsmStatus vsm_file_move_request(VsmClient client, const char* destContainer, const char* path);
/**
* Register notification callback function.
* @param[in] data some extra data that will be passed to callback function
* @return status of this function call
*/
-ScStatus sc_notification(ScClient client, ScNotificationCallback notificationCallback, void* data);
+VsmStatus vsm_notification(VsmClient client, VsmNotificationCallback notificationCallback, void* data);
/** @} */ // Domain API
SC_TEST_CONFIG_INSTALL_DIR "/client/ut-client/test-dbus-daemon.conf";
struct Loop {
- Loop() { sc_start_glib_loop(); }
- ~Loop() { sc_stop_glib_loop(); }
+ Loop()
+ {
+ vsm_start_glib_loop();
+ }
+ ~Loop()
+ {
+ vsm_stop_glib_loop();
+ }
};
struct Fixture {
const int EVENT_TIMEOUT = 5000; ///< ms
const std::map<std::string, std::string> EXPECTED_DBUSES_STARTED = {
- {"ut-containers-manager-console1-dbus",
- "unix:path=/tmp/ut-containers-manager/console1-dbus/dbus/system_bus_socket"},
- {"ut-containers-manager-console2-dbus",
- "unix:path=/tmp/ut-containers-manager/console2-dbus/dbus/system_bus_socket"},
- {"ut-containers-manager-console3-dbus",
- "unix:path=/tmp/ut-containers-manager/console3-dbus/dbus/system_bus_socket"}};
-
-void convertDictToMap(ScArrayString keys,
- ScArrayString values,
+ {
+ "ut-containers-manager-console1-dbus",
+ "unix:path=/tmp/ut-containers-manager/console1-dbus/dbus/system_bus_socket"
+ },
+ {
+ "ut-containers-manager-console2-dbus",
+ "unix:path=/tmp/ut-containers-manager/console2-dbus/dbus/system_bus_socket"
+ },
+ {
+ "ut-containers-manager-console3-dbus",
+ "unix:path=/tmp/ut-containers-manager/console3-dbus/dbus/system_bus_socket"
+ }
+};
+
+void convertDictToMap(VsmArrayString keys,
+ VsmArrayString values,
std::map<std::string, std::string>& ret)
{
- ScArrayString iKeys;
- ScArrayString iValues;
+ VsmArrayString iKeys;
+ VsmArrayString iValues;
for (iKeys = keys, iValues = values; *iKeys && *iValues; iKeys++, iValues++) {
ret.insert(std::make_pair(*iKeys, *iValues));
}
}
-void convertArrayToSet(ScArrayString values, std::set<std::string>& ret)
+void convertArrayToSet(VsmArrayString values, std::set<std::string>& ret)
{
- for (ScArrayString iValues = values; *iValues; iValues++) {
+ for (VsmArrayString iValues = values; *iValues; iValues++) {
ret.insert(*iValues);
}
}
-int getArrayStringLength(ScArrayString astring, int max_len = -1)
+int getArrayStringLength(VsmArrayString astring, int max_len = -1)
{
int i = 0;
for (i = 0; astring[i]; i++) {
{
cm.stopAll();
- ScClient client = sc_client_create();
- ScStatus status = sc_connect_custom(client,
- EXPECTED_DBUSES_STARTED.begin()->second.c_str());
- BOOST_CHECK_EQUAL(SCCLIENT_IO_ERROR, status);
- sc_client_free(client);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect_custom(client,
+ EXPECTED_DBUSES_STARTED.begin()->second.c_str());
+ BOOST_CHECK_EQUAL(VSMCLIENT_IO_ERROR, status);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(GetContainerDbusesTest)
{
- ScClient client = sc_client_create();
- ScStatus status = sc_connect(client);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- ScArrayString keys, values;
- status = sc_get_container_dbuses(client, &keys, &values);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect(client);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
+ VsmArrayString keys, values;
+ status = vsm_get_container_dbuses(client, &keys, &values);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(getArrayStringLength(keys, EXPECTED_DBUSES_STARTED.size() + 1),
EXPECTED_DBUSES_STARTED.size());
std::map<std::string, std::string> containers;
convertDictToMap(keys, values, containers);
BOOST_CHECK(containers == EXPECTED_DBUSES_STARTED);
- sc_array_string_free(keys);
- sc_array_string_free(values);
- sc_client_free(client);
+ vsm_array_string_free(keys);
+ vsm_array_string_free(values);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(GetContainerIdsTest)
{
- ScClient client = sc_client_create();
- ScStatus status = sc_connect(client);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- ScArrayString values;
- status = sc_get_container_ids(client, &values);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect(client);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
+ VsmArrayString values;
+ status = vsm_get_domain_ids(client, &values);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(getArrayStringLength(values, EXPECTED_DBUSES_STARTED.size() + 1),
EXPECTED_DBUSES_STARTED.size());
for (const auto& container : containers) {
BOOST_CHECK(EXPECTED_DBUSES_STARTED.find(container) != EXPECTED_DBUSES_STARTED.cend());
}
- sc_array_string_free(values);
- sc_client_free(client);
+ vsm_array_string_free(values);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(GetActiveContainerIdTest)
{
- ScClient client = sc_client_create();
- ScStatus status = sc_connect(client);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- ScString container;
- status = sc_get_active_container_id(client, &container);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect(client);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
+ VsmString container;
+ status = vsm_get_active_container_id(client, &container);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(container, cm.getRunningForegroundContainerId());
- sc_string_free(container);
- sc_client_free(client);
+ vsm_string_free(container);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(SetActiveContainerTest)
BOOST_REQUIRE_NE(newActiveContainerId, cm.getRunningForegroundContainerId());
- ScClient client = sc_client_create();
- ScStatus status = sc_connect(client);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- status = sc_set_active_container(client, newActiveContainerId.c_str());
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect(client);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
+ status = vsm_set_active_container(client, newActiveContainerId.c_str());
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(newActiveContainerId, cm.getRunningForegroundContainerId());
- sc_client_free(client);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(AddContainerTest)
{
const std::string newActiveContainerId = "";
- ScClient client = sc_client_create();
- ScStatus status = sc_connect(client);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- status = sc_add_container(client, newActiveContainerId.c_str());
- BOOST_REQUIRE_EQUAL(SCCLIENT_CUSTOM_ERROR, status);
- sc_client_free(client);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect(client);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
+ status = vsm_create_domain(client, newActiveContainerId.c_str());
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_CUSTOM_ERROR, status);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(FileMoveRequestTest)
const std::string path = "/tmp/fake_path";
const std::string secondContainer = "fake_container";
- ScClient client = sc_client_create();
- ScStatus status = sc_connect_custom(client, EXPECTED_DBUSES_STARTED.begin()->second.c_str());
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
- status = sc_file_move_request(client, secondContainer.c_str(), path.c_str());
- BOOST_REQUIRE_EQUAL(SCCLIENT_CUSTOM_ERROR, status);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect_custom(client, EXPECTED_DBUSES_STARTED.begin()->second.c_str());
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
+ status = vsm_file_move_request(client, secondContainer.c_str(), path.c_str());
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_CUSTOM_ERROR, status);
BOOST_REQUIRE_EQUAL(api::container::FILE_MOVE_DESTINATION_NOT_FOUND,
- sc_get_status_message(client));
- sc_client_free(client);
+ vsm_get_status_message(client));
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(NotificationTest)
auto callback = [](const char* container,
const char* application,
const char* message,
- void* data)
- {
+ void* data) {
CallbackData& callbackData = *reinterpret_cast<CallbackData*>(data);
callbackData.receivedSignalMsg.push_back(std::make_tuple(container, application, message));
callbackData.signalReceivedLatch.set();
};
CallbackData callbackData;
- std::map<std::string, ScClient> clients;
+ std::map<std::string, VsmClient> clients;
for (const auto& it : EXPECTED_DBUSES_STARTED) {
- ScClient client = sc_client_create();
- ScStatus status = sc_connect_custom(client, it.second.c_str());
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmClient client = vsm_client_create();
+ VsmStatus status = vsm_connect_custom(client, it.second.c_str());
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
clients[it.first] = client;
}
for (auto& client : clients) {
- ScStatus status = sc_notification(client.second, callback, &callbackData);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmStatus status = vsm_notification(client.second, callback, &callbackData);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
}
for (auto& client : clients) {
- ScStatus status = sc_notify_active_container(client.second,
- MSG_APP.c_str(),
- MSG_CONTENT.c_str());
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmStatus status = vsm_notify_active_container(client.second,
+ MSG_APP.c_str(),
+ MSG_CONTENT.c_str());
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
}
BOOST_CHECK(callbackData.signalReceivedLatch.waitForN(clients.size() - 1, EVENT_TIMEOUT));
}
for (auto& client : clients) {
- sc_client_free(client.second);
+ vsm_client_free(client.second);
}
}
BOOST_AUTO_TEST_CASE(GetContainerIdByPidTest1)
{
- ScClient client = sc_client_create();
- ScString container;
- ScStatus status = sc_get_container_id_by_pid(client, 1, &container);
- BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
+ VsmClient client = vsm_client_create();
+ VsmString container;
+ VsmStatus status = vsm_lookup_domain_by_pid(client, 1, &container);
+ BOOST_REQUIRE_EQUAL(VSMCLIENT_SUCCESS, status);
BOOST_CHECK_EQUAL(container, std::string("host"));
- sc_string_free(container);
- sc_client_free(client);
+ vsm_string_free(container);
+ vsm_client_free(client);
}
BOOST_AUTO_TEST_CASE(GetContainerIdByPidTest2)
{
std::set<std::string> ids;
- ScClient client = sc_client_create();
+ VsmClient client = vsm_client_create();
for (int n = 0; n < 100000; ++n) {
- ScString container;
- ScStatus status = sc_get_container_id_by_pid(client, n, &container);
- if (status == SCCLIENT_SUCCESS) {
+ VsmString container;
+ VsmStatus status = vsm_lookup_domain_by_pid(client, n, &container);
+ if (status == VSMCLIENT_SUCCESS) {
ids.insert(container);
- sc_string_free(container);
+ vsm_string_free(container);
} else {
- BOOST_WARN_MESSAGE(status == SCCLIENT_INVALID_ARGUMENT, sc_get_status_message(client));
+ BOOST_WARN_MESSAGE(status == VSMCLIENT_INVALID_ARGUMENT, vsm_get_status_message(client));
}
}
- sc_client_free(client);
+ vsm_client_free(client);
BOOST_CHECK(ids.count("host") == 1);
projects / platform / core / security / vasum.git / commitdiff