#include "rpc-port/aul-internal.hh"
#include "rpc-port/cynara_thread.hh"
-#include "rpc-port/log-private.hh"
#include "rpc-port/glib-internal.hh"
+#include "rpc-port/log-private.hh"
namespace rpc_port {
namespace internal {
int ret = cynara_creds_socket_get_user(fd, USER_METHOD_DEFAULT, &user);
if (ret != CYNARA_API_SUCCESS) {
// LCOV_EXCL_START
- char buf[128] = { 0, };
+ char buf[128] = {
+ 0,
+ };
cynara_strerror(ret, buf, sizeof(buf));
- _E("cynara_creds_socket_get_user() is failed. fd(%d), error(%d:%s)",
- fd, ret, buf);
+ _E("cynara_creds_socket_get_user() is failed. fd(%d), error(%d:%s)", fd,
+ ret, buf);
return nullptr;
// LCOV_EXCL_STOP
}
ret = cynara_creds_socket_get_client(fd, CLIENT_METHOD_DEFAULT, &client);
if (ret != CYNARA_API_SUCCESS) {
// LCOV_EXCL_START
- char buf[128] = { 0, };
+ char buf[128] = {
+ 0,
+ };
cynara_strerror(ret, buf, sizeof(buf));
- _E("cynara_creds_socket_get_client() is failed. fd(%d), error(%d:%s)",
- fd, ret, buf);
+ _E("cynara_creds_socket_get_client() is failed. fd(%d), error(%d:%s)", fd,
+ ret, buf);
return nullptr;
// LCOV_EXCL_STOP
}
int Check(const std::shared_ptr<Creds>& creds,
const std::string& privilege) const {
std::lock_guard<std::recursive_mutex> lock(mutex_);
- _W("cynara_check() ++ privilege(%s), user(%s)",
- privilege.c_str(), creds->GetUser().c_str());
+ _W("cynara_check() ++ privilege(%s), user(%s)", privilege.c_str(),
+ creds->GetUser().c_str());
int ret = cynara_check(handle_.get(), creds->GetClient().c_str(), "",
creds->GetUser().c_str(), privilege.c_str());
- _W("cynara_check() -- privilege(%s), user(%s)",
- privilege.c_str(), creds->GetUser().c_str());
+ _W("cynara_check() -- privilege(%s), user(%s)", privilege.c_str(),
+ creds->GetUser().c_str());
if (ret != CYNARA_API_ACCESS_ALLOWED) {
_E("cynara_check() is not allowed. privilege(%s), error(%d)",
privilege.c_str(), ret);
privileges_.push_back(std::move(privilege));
}
-void AccessController::SetTrusted(const bool trusted) {
- trusted_ = trusted;
-}
+void AccessController::SetTrusted(const bool trusted) { trusted_ = trusted; }
int AccessController::CheckPrivilege(int fd) {
auto creds = cynara_inst.FetchCredsFromSocket(fd);
if (creds == nullptr) return -1;
for (const auto& privilege : privileges_) {
- if (cynara_inst.Check(creds, privilege) != 0)
- return -1;
+ if (cynara_inst.Check(creds, privilege) != 0) return -1;
}
return 0;
// LCOV_EXCL_START
int AccessController::CheckTrusted(const std::string& sender_appid) {
- if (getuid() < kRegularUidMin)
- return 0;
+ if (getuid() < kRegularUidMin) return 0;
- if (appid_.empty())
- appid_ = Aul::GetAppId(getpid());
+ if (appid_.empty()) appid_ = Aul::GetAppId(getpid());
_D("CheckCertificate : %s :: %s", appid_.c_str(), sender_appid.c_str());
pkgmgrinfo_cert_compare_result_type_e res;
- int ret = pkgmgrinfo_pkginfo_compare_usr_app_cert_info(appid_.c_str(),
- sender_appid.c_str(), getuid(), &res);
+ int ret = pkgmgrinfo_pkginfo_compare_usr_app_cert_info(
+ appid_.c_str(), sender_appid.c_str(), getuid(), &res);
if (ret < 0) {
_E("CheckCertificate() Failed");
return -1;
int ret = 0;
if (!privileges_.empty()) {
ret = CheckPrivilege(fd);
- if (ret != 0)
- return ret;
+ if (ret != 0) return ret;
}
- if (trusted_)
- ret = CheckTrusted(sender_appid);
+ if (trusted_) ret = CheckTrusted(sender_appid);
return ret;
}
CompleteCallback callback) {
auto* tmp_handle = new std::shared_ptr<AccessController>(shared_from_this());
GMainContext* context = g_main_context_ref_thread_default();
- auto job = std::make_shared<Job>([=] {
+ auto job = std::make_shared<Job>([fd, appid = std::move(sender_appid),
+ cb = std::move(callback), tmp_handle,
+ context, this] {
std::lock_guard<std::recursive_mutex> job_lock(GetMutex());
if ((*tmp_handle).use_count() == 1) {
delete tmp_handle; // LCOV_EXCL_LINE
return Job::Type::Continue; // LCOV_EXCL_LINE
}
- int res = Check(fd, sender_appid);
+ int res = Check(fd, appid);
auto* cbdata = new std::tuple<CompleteCallback, int,
std::shared_ptr<AccessController>*>(
- std::move(callback), res, tmp_handle);
+ std::move(cb), res, tmp_handle);
auto* source = GLib::IdleAddFull(
context, G_PRIORITY_DEFAULT,
return G_SOURCE_REMOVE;
},
cbdata);
- if (source == nullptr)
- _E("Failed to add idle source");
+ if (source == nullptr) _E("Failed to add idle source");
g_main_context_unref(context);
return Job::Type::Continue;
*/
#include <errno.h>
+#include <fcntl.h>
#include <glib.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <unistd.h>
#include <iostream>
-#include <stdexcept>
#include <memory>
+#include <stdexcept>
#include <thread>
#include "include/rpc-port-internal.h"
+#include "include/rpc-port-parcel-internal.h"
+#include "include/rpc-port-parcel.h"
#include "unit_tests/mock/aul_mock.hh"
#include "unit_tests/mock/inotify_mock.hh"
#include "unit_tests/mock/test_fixture.hh"
using ::testing::_;
using ::testing::DoAll;
+using ::testing::Invoke;
using ::testing::Return;
using ::testing::SetArgPointee;
-using ::testing::Invoke;
namespace {
public:
WatchInfo() {}
WatchInfo(std::string app_id, std::string port_name,
- aul_rpc_port_appeared_cb appeared_cb,
- aul_rpc_port_vanished_cb vanished_cb,
- void* user_data)
+ aul_rpc_port_appeared_cb appeared_cb,
+ aul_rpc_port_vanished_cb vanished_cb, void* user_data)
: app_id_(std::move(app_id)),
port_name_(std::move(port_name)),
appeared_cb_(appeared_cb),
vanished_cb_(vanished_cb),
- user_data_(user_data) {
- }
+ user_data_(user_data) {}
~WatchInfo() {}
int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (fd < 0) {
fd = -errno;
- fprintf(stderr, "socket() is failed. path(%s), errno(%d)\n",
- path.c_str(), errno);
+ fprintf(stderr, "socket() is failed. path(%s), errno(%d)\n", path.c_str(),
+ errno);
return fd;
}
- struct sockaddr_un addr = { 0, };
+ struct sockaddr_un addr = {
+ 0,
+ };
addr.sun_family = AF_UNIX;
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", path.c_str());
unlink(path.c_str());
int ret = bind(fd, addr_ptr, sizeof(addr));
if (ret != 0) {
ret = -errno;
- fprintf(stderr, "bind() is failed. path(%s), errno(%d)\n",
- path.c_str(), errno);
+ fprintf(stderr, "bind() is failed. path(%s), errno(%d)\n", path.c_str(),
+ errno);
close(fd);
return ret;
}
ret = listen(fd, 128);
if (ret != 0) {
ret = -errno;
- fprintf(stderr, "listen() is failed. path(%s), errno(%d)\n",
- path.c_str(), errno);
+ fprintf(stderr, "listen() is failed. path(%s), errno(%d)\n", path.c_str(),
+ errno);
close(fd);
return ret;
}
mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP |
- S_IROTH | S_IWOTH | S_IXOTH;
+ S_IROTH | S_IWOTH | S_IXOTH;
ret = chmod(path.c_str(), mode);
if (ret != 0)
- fprintf(stderr, "chmod(%s, %d) is failed. errno(%d)\n",
- path.c_str(), mode, errno);
+ fprintf(stderr, "chmod(%s, %d) is failed. errno(%d)\n", path.c_str(), mode,
+ errno);
return fd;
}
}
int FakeAulRpcPortUsrGetPath(const char* app_id, const char* port_name,
- uid_t uid, char** port_path) {
- std::string path = "/tmp/." + std::string(app_id) + "_" +
- std::string(port_name);
+ uid_t uid, char** port_path) {
+ std::string path =
+ "/tmp/." + std::string(app_id) + "_" + std::string(port_name);
*port_path = strdup(path.c_str());
return 0;
}
int FakeAulRpcPortUsrPrepareStub(const char* app_id, const char* port_name,
- uid_t uid) {
+ uid_t uid) {
return 0;
}
int FakeAulRpcPortUsrExist(const char* app_id, const char* port_name, uid_t uid,
- bool* exist) {
+ bool* exist) {
if (!strcmp(port_name, "test_port")) {
*exist = true;
- if (test_port_handle.get() != nullptr)
- test_port_handle->Appear();
+ if (test_port_handle.get() != nullptr) test_port_handle->Appear();
} else {
*exist = false;
- if (test_port_handle.get() != nullptr)
- test_port_handle->Vanish();
+ if (test_port_handle.get() != nullptr) test_port_handle->Vanish();
}
return 0;
}
-int FakeAulRpcPortNotifyRpcFinished() {
- return 0;
-}
+int FakeAulRpcPortNotifyRpcFinished() { return 0; }
int FakeAulRpcPortUsrAddWatch(const char* app_id, const char* port_name,
- aul_rpc_port_appeared_cb appeared_cb, aul_rpc_port_vanished_cb vanished_cb,
- void* user_data, uid_t uid, aul_rpc_port_watch_h* handle) {
+ aul_rpc_port_appeared_cb appeared_cb,
+ aul_rpc_port_vanished_cb vanished_cb,
+ void* user_data, uid_t uid,
+ aul_rpc_port_watch_h* handle) {
if (!strcmp(port_name, "test_port")) {
test_port_handle.reset(
new WatchInfo(app_id, port_name, appeared_cb, vanished_cb, user_data));
int FakeAulRpcPortUsrCreate(const char* port_name, uid_t uid, int* fd) {
char* port_path = nullptr;
FakeAulRpcPortUsrGetPath("TestApp", port_name, uid, &port_path);
- if (port_path == nullptr)
- return -1;
+ if (port_path == nullptr) return -1;
- std::unique_ptr<char, decltype(std::free)*> port_path_auto(
- port_path, std::free);
+ std::unique_ptr<char, decltype(std::free)*> port_path_auto(port_path,
+ std::free);
int socket_fd = CreateSocket(port_path);
- if (socket_fd < 0)
- return -1;
+ if (socket_fd < 0) return -1;
*fd = socket_fd;
return 0;
int FakeAulRpcPortUsrDestroy(const char* port_name, uid_t uid) {
char* port_path = nullptr;
FakeAulRpcPortUsrGetPath("TestApp", port_name, uid, &port_path);
- if (port_path == nullptr)
- return -1;
+ if (port_path == nullptr) return -1;
- std::unique_ptr<char, decltype(std::free)*> port_path_auto(
- port_path, std::free);
+ std::unique_ptr<char, decltype(std::free)*> port_path_auto(port_path,
+ std::free);
unlink(port_path);
return 0;
}
int FakeAulProcRegister(const char* proc_name, bundle* extra) {
- if (proc_name == nullptr)
- return -1;
+ if (proc_name == nullptr) return -1;
return 0;
}
-int FakeAulProcDeregister() {
- return 0;
-}
+int FakeAulProcDeregister() { return 0; }
} // namespace
}
void SetFakeFuncs() {
+ EXPECT_CALL(GetMock<AulMock>(), aul_app_get_appid_bypid(_, _, _))
+ .WillRepeatedly(Invoke(FakeAulAppGetAppIdByPid));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_usr_get_path(_, _, _, _))
+ .WillRepeatedly(Invoke(FakeAulRpcPortUsrGetPath));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_usr_prepare_stub(_, _, _))
+ .WillRepeatedly(Invoke(FakeAulRpcPortUsrPrepareStub));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_usr_exist(_, _, _, _))
+ .WillRepeatedly(Invoke(FakeAulRpcPortUsrExist));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_notify_rpc_finished())
+ .WillRepeatedly(Invoke(FakeAulRpcPortNotifyRpcFinished));
EXPECT_CALL(GetMock<AulMock>(),
- aul_app_get_appid_bypid(_, _, _))
- .WillRepeatedly(Invoke(FakeAulAppGetAppIdByPid));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_usr_get_path(_, _, _, _))
- .WillRepeatedly(Invoke(FakeAulRpcPortUsrGetPath));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_usr_prepare_stub(_, _, _))
- .WillRepeatedly(Invoke(FakeAulRpcPortUsrPrepareStub));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_usr_exist(_, _, _, _))
- .WillRepeatedly(Invoke(FakeAulRpcPortUsrExist));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_notify_rpc_finished())
- .WillRepeatedly(Invoke(FakeAulRpcPortNotifyRpcFinished));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_usr_add_watch(_, _, _, _, _, _, _))
- .WillRepeatedly(Invoke(FakeAulRpcPortUsrAddWatch));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_remove_watch(_))
- .WillRepeatedly(Invoke(FakeAulRpcPortRemoveWatch));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_svc_get_appid_by_alias_appid(_, _))
- .WillRepeatedly(Invoke(FakeAulSvcGetAppIdByAliasAppId));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_usr_create(_, _, _))
- .WillRepeatedly(Invoke(FakeAulRpcPortUsrCreate));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_rpc_port_usr_destroy(_, _))
- .WillRepeatedly(Invoke(FakeAulRpcPortUsrDestroy));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_proc_register(_, _))
- .WillRepeatedly(Invoke(FakeAulProcRegister));
- EXPECT_CALL(GetMock<AulMock>(),
- aul_proc_deregister())
- .WillRepeatedly(Invoke(FakeAulProcDeregister));
+ aul_rpc_port_usr_add_watch(_, _, _, _, _, _, _))
+ .WillRepeatedly(Invoke(FakeAulRpcPortUsrAddWatch));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_remove_watch(_))
+ .WillRepeatedly(Invoke(FakeAulRpcPortRemoveWatch));
+ EXPECT_CALL(GetMock<AulMock>(), aul_svc_get_appid_by_alias_appid(_, _))
+ .WillRepeatedly(Invoke(FakeAulSvcGetAppIdByAliasAppId));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_usr_create(_, _, _))
+ .WillRepeatedly(Invoke(FakeAulRpcPortUsrCreate));
+ EXPECT_CALL(GetMock<AulMock>(), aul_rpc_port_usr_destroy(_, _))
+ .WillRepeatedly(Invoke(FakeAulRpcPortUsrDestroy));
+ EXPECT_CALL(GetMock<AulMock>(), aul_proc_register(_, _))
+ .WillRepeatedly(Invoke(FakeAulProcRegister));
+ EXPECT_CALL(GetMock<AulMock>(), aul_proc_deregister())
+ .WillRepeatedly(Invoke(FakeAulProcDeregister));
}
- void RunMainLoop() {
- g_main_loop_run(mainloop_);
- }
+ void RunMainLoop() { g_main_loop_run(mainloop_); }
- void Finish() {
- g_main_loop_quit(mainloop_);
- }
+ void Finish() { g_main_loop_quit(mainloop_); }
void KillStub() {
int ret = rpc_port_stub_destroy(stub_handle_);
}
void StubSetup() {
- int ret = rpc_port_stub_add_received_event_cb(stub_handle_,
- [](const char* sender, const char* instance,
- rpc_port_h port, void *data) -> int {
+ int ret = rpc_port_stub_add_received_event_cb(
+ stub_handle_,
+ [](const char* sender, const char* instance, rpc_port_h port,
+ void* data) -> int {
RpcPortConnection* p = static_cast<RpcPortConnection*>(data);
p->stub_port_ = port;
pid_t pid = -1;
rpc_port_h main_port = nullptr;
ret = rpc_port_stub_get_port(p->stub_handle_, RPC_PORT_PORT_MAIN,
- instance, &main_port);
+ instance, &main_port);
if (ret != RPC_PORT_ERROR_NONE)
std::cerr << "Failed to get main port" << std::endl;
- ret = rpc_port_stub_get_port(p->stub_handle_,
- RPC_PORT_PORT_CALLBACK, instance, &p->stub_callback_port_);
+ ret = rpc_port_stub_get_port(p->stub_handle_, RPC_PORT_PORT_CALLBACK,
+ instance, &p->stub_callback_port_);
p->Finish();
- if (ret != RPC_PORT_ERROR_NONE)
- return -1;
+ if (ret != RPC_PORT_ERROR_NONE) return -1;
return RPC_PORT_ERROR_NONE;
- }, this);
+ },
+ this);
ASSERT_EQ(ret, RPC_PORT_ERROR_NONE);
- ret = rpc_port_stub_add_disconnected_event_cb(stub_handle_,
- [](const char* sender, const char* instance, void *data) {
+ ret = rpc_port_stub_add_disconnected_event_cb(
+ stub_handle_,
+ [](const char* sender, const char* instance, void* data) {
auto* p = static_cast<RpcPortConnection*>(data);
p->touch_stub_disconnected_event_cb_ = true;
- g_timeout_add(1, [](void* data) -> gboolean {
- auto* p = static_cast<RpcPortConnection*>(data);
- p->Finish();
- return G_SOURCE_REMOVE;
- }, p);
+ g_timeout_add(
+ 1,
+ [](void* data) -> gboolean {
+ auto* p = static_cast<RpcPortConnection*>(data);
+ p->Finish();
+ return G_SOURCE_REMOVE;
+ },
+ p);
},
this);
ASSERT_EQ(ret, RPC_PORT_ERROR_NONE);
- ret = rpc_port_stub_add_privilege(stub_handle_,
- "http://tizen.org/privilege/appmanager.launch");
+ ret = rpc_port_stub_add_privilege(
+ stub_handle_, "http://tizen.org/privilege/appmanager.launch");
ASSERT_EQ(ret, RPC_PORT_ERROR_NONE);
ret = rpc_port_stub_set_trusted(stub_handle_, true);
}
void ProxySetup() {
- int ret = rpc_port_proxy_add_connected_event_cb(proxy_handle_,
+ int ret = rpc_port_proxy_add_connected_event_cb(
+ proxy_handle_,
[](const char* ep, const char* port_name, rpc_port_h port, void* data) {
RpcPortConnection* p = static_cast<RpcPortConnection*>(data);
p->proxy_port_ = port;
rpc_port_proxy_get_port(p->proxy_handle_, RPC_PORT_PORT_CALLBACK,
- &p->proxy_callback_port_);
+ &p->proxy_callback_port_);
p->Finish();
- }, this);
+ },
+ this);
ASSERT_EQ(ret, 0);
- ret = rpc_port_proxy_add_disconnected_event_cb(proxy_handle_,
+ ret = rpc_port_proxy_add_disconnected_event_cb(
+ proxy_handle_,
[](const char* ep, const char* port_name, void* data) {
auto* p = static_cast<RpcPortConnection*>(data);
p->touch_proxy_disconnected_event_cb_ = true;
- g_timeout_add(1, [](void* data) -> gboolean {
- auto* p = static_cast<RpcPortConnection*>(data);
- p->Finish();
- return G_SOURCE_REMOVE;
- }, p);
+ g_timeout_add(
+ 1,
+ [](void* data) -> gboolean {
+ auto* p = static_cast<RpcPortConnection*>(data);
+ p->Finish();
+ return G_SOURCE_REMOVE;
+ },
+ p);
},
this);
ASSERT_EQ(ret, 0);
- ret = rpc_port_proxy_add_received_event_cb(proxy_handle_,
- [](const char *ep, const char *port_name, void *data) {
+ ret = rpc_port_proxy_add_received_event_cb(
+ proxy_handle_,
+ [](const char* ep, const char* port_name, void* data) {
RpcPortConnection* p = static_cast<RpcPortConnection*>(data);
p->touch_proxy_received_event_cb_ = true;
p->Finish();
- }, this);
+ },
+ this);
ASSERT_EQ(ret, 0);
ret = rpc_port_proxy_connect(proxy_handle_, "TestApp", "test_port");
};
TEST_F(RpcPortBase, rpc_port_event_connect) {
- int ret = rpc_port_stub_add_connected_event_cb(stub_handle_,
- [](const char *sender, const char* instance, void *data) {
+ int ret = rpc_port_stub_add_connected_event_cb(
+ stub_handle_,
+ [](const char* sender, const char* instance, void* data) {
RpcPortBase* p = static_cast<RpcPortBase*>(data);
p->touch_stub_connected_event_cb_ = true;
- }, this);
+ },
+ this);
ASSERT_EQ(ret, 0);
ret = rpc_port_stub_listen(stub_handle_);
ASSERT_EQ(ret, 0);
- ret = rpc_port_proxy_add_connected_event_cb(proxy_handle_,
- [](const char *ep, const char *port_name, rpc_port_h port, void *data) {
- RpcPortBase* p = static_cast<RpcPortBase*>(data);
- p->touch_proxy_connected_event_cb_ = true;
- p->Finish();
- }, this);
+ ret = rpc_port_proxy_add_connected_event_cb(
+ proxy_handle_,
+ [](const char* ep, const char* port_name, rpc_port_h port, void* data) {
+ RpcPortBase* p = static_cast<RpcPortBase*>(data);
+ p->touch_proxy_connected_event_cb_ = true;
+ p->Finish();
+ },
+ this);
ASSERT_EQ(ret, 0);
ret = rpc_port_proxy_connect(proxy_handle_, "TestApp", "test_port");
}
TEST_F(RpcPortBase, rpc_port_event_connect_sync) {
- int ret = rpc_port_stub_add_connected_event_cb(stub_handle_,
- [](const char *sender, const char* instance, void *data) {
+ int ret = rpc_port_stub_add_connected_event_cb(
+ stub_handle_,
+ [](const char* sender, const char* instance, void* data) {
RpcPortBase* p = static_cast<RpcPortBase*>(data);
p->touch_stub_connected_event_cb_ = true;
- }, this);
+ },
+ this);
ASSERT_EQ(ret, 0);
ret = rpc_port_stub_listen(stub_handle_);
ASSERT_EQ(ret, 0);
- ret = rpc_port_proxy_add_connected_event_cb(proxy_handle_,
- [](const char *ep, const char *port_name, rpc_port_h port, void *data) {
- RpcPortBase* p = static_cast<RpcPortBase*>(data);
- p->touch_proxy_connected_event_cb_ = true;
- p->Finish();
- }, this);
+ ret = rpc_port_proxy_add_connected_event_cb(
+ proxy_handle_,
+ [](const char* ep, const char* port_name, rpc_port_h port, void* data) {
+ RpcPortBase* p = static_cast<RpcPortBase*>(data);
+ p->touch_proxy_connected_event_cb_ = true;
+ p->Finish();
+ },
+ this);
ASSERT_EQ(ret, 0);
- std::thread t([](RpcPortBase* p) {
- int ret = rpc_port_proxy_connect_sync(p->proxy_handle_, "TestApp",
- "test_port");
- ASSERT_EQ(ret, 0);
- }, this);
+ std::thread t(
+ [](RpcPortBase* p) {
+ int ret = rpc_port_proxy_connect_sync(p->proxy_handle_, "TestApp",
+ "test_port");
+ ASSERT_EQ(ret, 0);
+ },
+ this);
RunMainLoop();
t.join();
}
TEST_F(RpcPortBase, rpc_port_proxy_event_reject_N) {
- int ret = rpc_port_proxy_add_rejected_event_cb(proxy_handle_,
- [](const char *ep, const char *port_name, void *data) {
- RpcPortBase* p = static_cast<RpcPortBase*>(data);
- p->touch_proxy_rejected_event_cb_ = true;
- p->Finish();
- }, this);
+ int ret = rpc_port_proxy_add_rejected_event_cb(
+ proxy_handle_,
+ [](const char* ep, const char* port_name, void* data) {
+ RpcPortBase* p = static_cast<RpcPortBase*>(data);
+ p->touch_proxy_rejected_event_cb_ = true;
+ p->Finish();
+ },
+ this);
ASSERT_EQ(ret, 0);
rpc_port_set_timeout(5000);
ret = rpc_port_proxy_connect(proxy_handle_, "TestApp", "wrong_port");
ASSERT_EQ(ret, 0);
- guint tag = g_timeout_add_seconds(10,
+ guint tag = g_timeout_add_seconds(
+ 10,
[](gpointer data) -> gboolean {
auto* p = static_cast<RpcPortBase*>(data);
p->Finish();
return G_SOURCE_REMOVE;
- }, this);
+ },
+ this);
RunMainLoop();
ASSERT_TRUE(touch_proxy_rejected_event_cb_);
char res[] = "OK";
char r_buf[256];
- if (proxy_port_ == nullptr)
- RunMainLoop();
+ if (proxy_port_ == nullptr) RunMainLoop();
ASSERT_NE(proxy_port_, nullptr);
int ret = rpc_port_write(proxy_port_, res, sizeof(res));
ASSERT_EQ(ret, 0);
- if (stub_port_ == nullptr)
- RunMainLoop();
+ if (stub_port_ == nullptr) RunMainLoop();
ASSERT_NE(stub_port_, nullptr);
ASSERT_NE(stub_callback_port_, nullptr);
char res[] = "OK";
char r_buf[256];
- if (proxy_port_ == nullptr)
- RunMainLoop();
+ if (proxy_port_ == nullptr) RunMainLoop();
ASSERT_NE(proxy_port_, nullptr);
int ret = rpc_port_write(proxy_port_, buf, sizeof(buf));
ASSERT_EQ(ret, 0);
- if (stub_port_ == nullptr)
- RunMainLoop();
+ if (stub_port_ == nullptr) RunMainLoop();
ASSERT_NE(stub_port_, nullptr);
ASSERT_STREQ("OK", r_buf);
}
+TEST_F(RpcPortConnection, rpc_port_read_write_parcel) {
+ if (proxy_port_ == nullptr) RunMainLoop();
+
+ ASSERT_NE(proxy_port_, nullptr);
+
+ rpc_port_parcel_h parcel;
+ int ret = rpc_port_parcel_create(&parcel);
+ ASSERT_EQ(ret, 0);
+ ret = rpc_port_parcel_write_string(parcel, "test");
+ ASSERT_EQ(ret, 0);
+ ret = rpc_port_parcel_send(parcel, proxy_port_);
+ ASSERT_EQ(ret, 0);
+
+ if (stub_port_ == nullptr) RunMainLoop();
+
+ ASSERT_NE(stub_port_, nullptr);
+
+ rpc_port_parcel_h recv_parcel;
+ ret = rpc_port_parcel_create_from_port(&recv_parcel, stub_port_);
+ ASSERT_EQ(ret, 0);
+
+ char* str = nullptr;
+ ret = rpc_port_parcel_read_string(recv_parcel, &str);
+ ASSERT_EQ(ret, 0);
+
+ ASSERT_STREQ(str, "test");
+ free(str);
+
+ rpc_port_parcel_destroy(parcel);
+ rpc_port_parcel_destroy(recv_parcel);
+}
+
+TEST_F(RpcPortConnection, rpc_port_read_write_parcel_fd_one) {
+ int fd;
+ int ret;
+
+ fd = open("./test.txt", O_CREAT | O_RDWR | O_TRUNC, 0666);
+ ret = write(fd, "test", 5);
+ ASSERT_EQ(ret, 5);
+
+ if (proxy_port_ == nullptr) RunMainLoop();
+
+ ASSERT_NE(proxy_port_, nullptr);
+
+ rpc_port_parcel_h parcel;
+ ret = rpc_port_parcel_create(&parcel);
+ ASSERT_EQ(ret, 0);
+ ret = rpc_port_parcel_write_fd(parcel, fd);
+ ASSERT_EQ(ret, 0);
+ ret = rpc_port_parcel_send(parcel, proxy_port_);
+ ASSERT_EQ(ret, 0);
+
+ if (stub_port_ == nullptr) RunMainLoop();
+
+ ASSERT_NE(stub_port_, nullptr);
+
+ rpc_port_parcel_h recv_parcel;
+ ret = rpc_port_parcel_create_from_port(&recv_parcel, stub_port_);
+ ASSERT_EQ(ret, 0);
+
+ int recv_fd = -1;
+ ret = rpc_port_parcel_read_fd(recv_parcel, &recv_fd);
+ ASSERT_EQ(ret, 0);
+
+ ASSERT_NE(recv_fd, -1);
+
+ rpc_port_parcel_destroy(parcel);
+ rpc_port_parcel_destroy(recv_parcel);
+
+ char text_buf[10] = {
+ 0,
+ };
+ lseek(recv_fd, SEEK_SET, 0);
+ ret = read(recv_fd, text_buf, 5);
+ ASSERT_EQ(ret, 5);
+ ASSERT_STREQ(text_buf, "test");
+
+ close(fd);
+ close(recv_fd);
+}
+
+TEST_F(RpcPortConnection, rpc_port_read_write_parcel_fd_multi) {
+ constexpr const int MAX_TEST_FD = 120;
+
+ int fd[MAX_TEST_FD] = {
+ 0,
+ };
+ int ret;
+
+ for (int i = 0; i < MAX_TEST_FD; i++) {
+ fd[i] = open(std::format("./test{}.txt", i).data(),
+ O_CREAT | O_RDWR | O_TRUNC, 0666);
+ }
+
+ if (proxy_port_ == nullptr) RunMainLoop();
+
+ ASSERT_NE(proxy_port_, nullptr);
+
+ rpc_port_parcel_h parcel;
+ ret = rpc_port_parcel_create(&parcel);
+ ASSERT_EQ(ret, 0);
+
+ for (int i = 0; i < MAX_TEST_FD; i++) {
+ ret = rpc_port_parcel_write_fd(parcel, fd[i]);
+ ASSERT_EQ(ret, 0);
+ }
+ ret = rpc_port_parcel_send(parcel, proxy_port_);
+ ASSERT_EQ(ret, 0);
+
+ if (stub_port_ == nullptr) RunMainLoop();
+ ASSERT_NE(stub_port_, nullptr);
+
+ rpc_port_parcel_h recv_parcel;
+ ret = rpc_port_parcel_create_from_port(&recv_parcel, stub_port_);
+ ASSERT_EQ(ret, 0);
+
+ int recv_fd[MAX_TEST_FD] = {
+ 0,
+ };
+
+ for (int i = 0; i < MAX_TEST_FD; i++) {
+ ret = rpc_port_parcel_read_fd(recv_parcel, &recv_fd[i]);
+ ASSERT_EQ(ret, 0);
+ EXPECT_TRUE(recv_fd[i] > 0);
+ }
+
+ rpc_port_parcel_destroy(parcel);
+ rpc_port_parcel_destroy(recv_parcel);
+
+ for (int i = 0; i < MAX_TEST_FD; i++) {
+ close(fd[i]);
+ close(recv_fd[i]);
+ }
+}
+
TEST_F(RpcPortConnection, rpc_port_proxy_disconnected_N) {
KillStub();
RunMainLoop();
TEST_F(RpcPortConnection, rpc_port_disconnect_P) {
char res[] = "test";
- if (proxy_port_ == nullptr)
- RunMainLoop();
+ if (proxy_port_ == nullptr) RunMainLoop();
ASSERT_NE(proxy_port_, nullptr);
int ret = rpc_port_write(proxy_port_, res, sizeof(res));
ASSERT_EQ(ret, 0);
- if (stub_port_ == nullptr)
- RunMainLoop();
+ if (stub_port_ == nullptr) RunMainLoop();
ret = rpc_port_disconnect(stub_port_);
EXPECT_EQ(ret, 0);
projects / platform / core / appfw / rpc-port.git / commitdiff