return callMethod(HOST_INTERFACE, api::host::METHOD_SET_ACTIVE_CONTAINER, args_in);
}
-ScStatus Client::sc_container_dbus_state(ScContainerDbusStateCallback containerDbusStateCallback)
- noexcept
+ScStatus Client::sc_container_dbus_state(ScContainerDbusStateCallback 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);
- containerDbusStateCallback(container, dbusAddress);
+ containerDbusStateCallback(container, dbusAddress, data);
};
return signalSubscribe(HOST_INTERFACE,
args_in);
}
-ScStatus Client::sc_notification(ScNotificationCallback notificationCallback) noexcept
+ScStatus Client::sc_notification(ScNotificationCallback notificationCallback, void* data) noexcept
{
assert(notificationCallback);
- auto onSigal = [ = ](GVariant * parameters) {
+ auto onSigal = [=](GVariant * parameters) {
const char* container;
const char* application;
const char* message;
g_variant_get(parameters, "(&s&s&s)", &container, &application, &message);
- notificationCallback(container, application, message);
+ notificationCallback(container, application, message, data);
};
return signalSubscribe(CONTAINER_INTERFACE, api::container::SIGNAL_NOTIFICATION, onSigal);
/**
* @see ::sc_container_dbus_state
*/
- ScStatus sc_container_dbus_state(ScContainerDbusStateCallback containerDbusStateCallback) noexcept;
+ ScStatus sc_container_dbus_state(ScContainerDbusStateCallback containerDbusStateCallback,
+ void* data) noexcept;
/**
* @see ::sc_notify_active_container
/**
* @see ::sc_notification
*/
- ScStatus sc_notification(ScNotificationCallback notificationCallback) noexcept;
+ ScStatus sc_notification(ScNotificationCallback notificationCallback, void* data) noexcept;
/**
* @see ::sc_start_glib_loop
*/
}
API ScStatus sc_container_dbus_state(ScClient client,
- ScContainerDbusStateCallback containerDbusStateCallback)
+ ScContainerDbusStateCallback containerDbusStateCallback,
+ void* data)
{
- return getClient(client).sc_container_dbus_state(containerDbusStateCallback);
+ return getClient(client).sc_container_dbus_state(containerDbusStateCallback, data);
}
API ScStatus sc_notify_active_container(ScClient client,
return getClient(client).sc_notify_active_container(application, message);
}
-API ScStatus sc_notification(ScClient client, ScNotificationCallback notificationCallback)
+API ScStatus sc_notification(ScClient client,
+ ScNotificationCallback notificationCallback,
+ void* data)
{
- return getClient(client).sc_notification(notificationCallback);
+ return getClient(client).sc_notification(notificationCallback, data);
}
/**
* Dbus state change callback function signature.
*/
-typedef void (*ScContainerDbusStateCallback)(const char* containerId, const char* dbusAddress);
+typedef void (*ScContainerDbusStateCallback)(const char* containerId,
+ const char* dbusAddress,
+ void* data);
/**
* Get dbus address of each container.
*
* @param client security-containers-server's client
* @param containerDbusStateCallback callback function
+ * @param 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);
+ ScContainerDbusStateCallback containerDbusStateCallback,
+ void* data);
/*************************************************************************************************
*/
typedef void (*ScNotificationCallback)(const char* container,
const char* application,
- const char* message);
+ const char* message,
+ void* data);
/**
* Send message to active container.
*
*
* @param client security-containers-server's client
* @param notificationCallback callback function
+ * @param data some extra data that will be passed to callback function
* @return status of this function call
*/
-ScStatus sc_notification(ScClient client, ScNotificationCallback notificationCallback);
+ScStatus sc_notification(ScClient client, ScNotificationCallback notificationCallback, void* data);
#ifdef __cplusplus
}
#endif
BOOST_AUTO_TEST_CASE(NotificationTest)
{
- // TODO add a void* to callback parameter and pass this two variables
- // so that they no longer need to be global
- static Latch signalReceivedLatch;
- static std::vector< std::tuple<std::string, std::string, std::string> > receivedSignalMsg;
-
- auto callback = [](const char* container, const char* application, const char* message) {
- receivedSignalMsg.push_back(std::make_tuple(container, application, message));
- signalReceivedLatch.set();
+ const std::string MSG_CONTENT = "msg";
+ const std::string MSG_APP = "app";
+
+ struct CallbackData {
+ Latch signalReceivedLatch;
+ std::vector< std::tuple<std::string, std::string, std::string> > receivedSignalMsg;
+ };
+
+ auto callback = [](const char* container,
+ const char* application,
+ const char* message,
+ 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;
for (const auto& it : EXPECTED_DBUSES_STARTED) {
ScClient client = sc_client_create();
clients[it.first] = client;
}
for (auto& client : clients) {
- ScStatus status = sc_notification(client.second, callback);
+ ScStatus status = sc_notification(client.second, callback, &callbackData);
BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
}
for (auto& client : clients) {
- ScStatus status = sc_notify_active_container(client.second, "app", "msg");
+ ScStatus status = sc_notify_active_container(client.second,
+ MSG_APP.c_str(),
+ MSG_CONTENT.c_str());
BOOST_REQUIRE_EQUAL(SCCLIENT_SUCCESS, status);
}
- BOOST_CHECK(signalReceivedLatch.waitForN(clients.size() - 1, EVENT_TIMEOUT));
- BOOST_CHECK(signalReceivedLatch.empty());
+ BOOST_CHECK(callbackData.signalReceivedLatch.waitForN(clients.size() - 1, EVENT_TIMEOUT));
+ BOOST_CHECK(callbackData.signalReceivedLatch.empty());
+
+ for (const auto& msg : callbackData.receivedSignalMsg) {
+ BOOST_CHECK(clients.count(std::get<0>(msg)) > 0);
+ BOOST_CHECK_EQUAL(std::get<1>(msg), MSG_APP);
+ BOOST_CHECK_EQUAL(std::get<2>(msg), MSG_CONTENT);
+ }
for (auto& client : clients) {
sc_client_free(client.second);