| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fuchsia/ldsvc/c/fidl.h> |
| #include <string.h> |
| #include <threads.h> |
| #include <zircon/fidl.h> |
| #include <zircon/syscalls.h> |
| |
| #include <unittest/unittest.h> |
| |
| static bool g_server_done = false; |
| |
| static zx_status_t ldsvc_Done(void* ctx) { |
| g_server_done = true; |
| return ZX_OK; |
| } |
| |
| static zx_status_t ldsvc_LoadObject(void* ctx, const char* object_name_data, size_t object_name_size, fidl_txn_t* txn) { |
| size_t len = strlen("object name"); |
| ASSERT_EQ(len, object_name_size, ""); |
| EXPECT_EQ(0, memcmp(object_name_data, "object name", len), ""); |
| zx_handle_t event = ZX_HANDLE_INVALID; |
| EXPECT_EQ(ZX_OK, zx_event_create(0, &event), ""); |
| return fuchsia_ldsvc_LoaderLoadObject_reply(txn, 42, event); |
| } |
| |
| static zx_status_t ldsvc_LoadScriptInterpreter(void* ctx, const char* interpreter_name_data, size_t interpreter_name_size, fidl_txn_t* txn) { |
| size_t len = strlen("script interpreter"); |
| ASSERT_EQ(len, interpreter_name_size, ""); |
| EXPECT_EQ(0, memcmp(interpreter_name_data, "script interpreter", len), ""); |
| zx_handle_t event = ZX_HANDLE_INVALID; |
| EXPECT_EQ(ZX_OK, zx_event_create(0, &event), ""); |
| return fuchsia_ldsvc_LoaderLoadScriptInterpreter_reply(txn, 43, event); |
| } |
| |
| static zx_status_t ldsvc_Config(void* ctx, const char* config_data, size_t config_size, fidl_txn_t* txn) { |
| size_t len = strlen("my config"); |
| ASSERT_EQ(len, config_size, ""); |
| EXPECT_EQ(0, memcmp(config_data, "my config", len), ""); |
| return fuchsia_ldsvc_LoaderConfig_reply(txn, 44); |
| } |
| |
| static zx_status_t ldsvc_Clone(void* ctx, zx_handle_t loader, fidl_txn_t* txn) { |
| EXPECT_EQ(ZX_OK, zx_handle_close(loader), ""); |
| return fuchsia_ldsvc_LoaderClone_reply(txn, 45); |
| } |
| |
| static zx_status_t ldsvc_DebugPublishDataSink(void* ctx, const char* data_sink_data, size_t data_sink_size, zx_handle_t data, fidl_txn_t* txn) { |
| size_t len = strlen("my data sink"); |
| ASSERT_EQ(len, data_sink_size, ""); |
| EXPECT_EQ(0, memcmp(data_sink_data, "my data sink", len), ""); |
| EXPECT_EQ(ZX_OK, zx_handle_close(data), ""); |
| return fuchsia_ldsvc_LoaderDebugPublishDataSink_reply(txn, 46); |
| } |
| |
| static zx_status_t ldsvc_DebugLoadConfig(void* ctx, const char* config_name_data, size_t config_name_size, fidl_txn_t* txn) { |
| size_t len = strlen("my debug config"); |
| ASSERT_EQ(len, config_name_size, ""); |
| EXPECT_EQ(0, memcmp(config_name_data, "my debug config", len), ""); |
| zx_handle_t event = ZX_HANDLE_INVALID; |
| EXPECT_EQ(ZX_OK, zx_event_create(0, &event), ""); |
| return fuchsia_ldsvc_LoaderDebugLoadConfig_reply(txn, 47, event); |
| } |
| |
| static const fuchsia_ldsvc_Loader_ops_t kOps = { |
| .Done = ldsvc_Done, |
| .LoadObject = ldsvc_LoadObject, |
| .LoadScriptInterpreter = ldsvc_LoadScriptInterpreter, |
| .Config = ldsvc_Config, |
| .Clone = ldsvc_Clone, |
| .DebugPublishDataSink = ldsvc_DebugPublishDataSink, |
| .DebugLoadConfig = ldsvc_DebugLoadConfig, |
| }; |
| |
| typedef struct ldsvc_connection { |
| fidl_txn_t txn; |
| zx_handle_t channel; |
| zx_txid_t txid; |
| uint32_t reply_count; |
| } ldsvc_connection_t; |
| |
| static zx_status_t ldsvc_server_reply(fidl_txn_t* txn, const fidl_msg_t* msg) { |
| ldsvc_connection_t* conn = (ldsvc_connection_t*)txn; |
| if (msg->num_bytes < sizeof(fidl_message_header_t)) |
| return ZX_ERR_INVALID_ARGS; |
| fidl_message_header_t* hdr = (fidl_message_header_t*)msg->bytes; |
| hdr->txid = conn->txid; |
| conn->txid = 0; |
| ++conn->reply_count; |
| return zx_channel_write(conn->channel, 0, msg->bytes, msg->num_bytes, |
| msg->handles, msg->num_handles); |
| } |
| |
| static int ldsvc_server(void* ctx) { |
| ldsvc_connection_t conn = { |
| .txn.reply = ldsvc_server_reply, |
| .channel = *(zx_handle_t*)ctx, |
| .reply_count = 0u, |
| }; |
| zx_status_t status = ZX_OK; |
| g_server_done = false; |
| |
| while (status == ZX_OK && !g_server_done) { |
| zx_signals_t observed; |
| status = zx_object_wait_one( |
| conn.channel, ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, |
| ZX_TIME_INFINITE, &observed); |
| if ((observed & ZX_CHANNEL_READABLE) != 0) { |
| ASSERT_EQ(ZX_OK, status, ""); |
| char bytes[ZX_CHANNEL_MAX_MSG_BYTES]; |
| zx_handle_t handles[ZX_CHANNEL_MAX_MSG_HANDLES]; |
| fidl_msg_t msg = { |
| .bytes = bytes, |
| .handles = handles, |
| .num_bytes = 0u, |
| .num_handles = 0u, |
| }; |
| status = zx_channel_read(conn.channel, 0, bytes, handles, |
| ZX_CHANNEL_MAX_MSG_BYTES, |
| ZX_CHANNEL_MAX_MSG_HANDLES, |
| &msg.num_bytes, &msg.num_handles); |
| ASSERT_EQ(ZX_OK, status, ""); |
| ASSERT_GE(msg.num_bytes, sizeof(fidl_message_header_t), ""); |
| fidl_message_header_t* hdr = (fidl_message_header_t*)msg.bytes; |
| conn.txid = hdr->txid; |
| conn.reply_count = 0u; |
| status = fuchsia_ldsvc_Loader_dispatch(NULL, &conn.txn, &msg, &kOps); |
| ASSERT_EQ(ZX_OK, status, ""); |
| if (!g_server_done) |
| ASSERT_EQ(1u, conn.reply_count, ""); |
| } else { |
| break; |
| } |
| } |
| |
| zx_handle_close(conn.channel); |
| return 0; |
| } |
| |
| static bool loader_test(void) { |
| BEGIN_TEST; |
| |
| zx_handle_t client, server; |
| zx_status_t status = zx_channel_create(0, &client, &server); |
| ASSERT_EQ(ZX_OK, status, ""); |
| |
| thrd_t thread; |
| int rv = thrd_create(&thread, ldsvc_server, &server); |
| ASSERT_EQ(thrd_success, rv, ""); |
| |
| { |
| const char* object_name = "object name"; |
| zx_status_t rv = ZX_OK; |
| zx_handle_t object = ZX_HANDLE_INVALID; |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderLoadObject(client, object_name, strlen(object_name), &rv, &object), ""); |
| ASSERT_EQ(42, rv, ""); |
| ASSERT_EQ(ZX_OK, zx_handle_close(object), ""); |
| } |
| |
| { |
| const char* interpreter_name = "script interpreter"; |
| zx_status_t rv = ZX_OK; |
| zx_handle_t object = ZX_HANDLE_INVALID; |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderLoadScriptInterpreter(client, interpreter_name, strlen(interpreter_name), &rv, &object), ""); |
| ASSERT_EQ(43, rv, ""); |
| ASSERT_EQ(ZX_OK, zx_handle_close(object), ""); |
| } |
| |
| { |
| const char* config = "my config"; |
| zx_status_t rv = ZX_OK; |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderConfig(client, config, strlen(config), &rv), ""); |
| ASSERT_EQ(44, rv, ""); |
| } |
| |
| { |
| zx_status_t rv = ZX_OK; |
| zx_handle_t h1, h2; |
| ASSERT_EQ(ZX_OK, zx_eventpair_create(0, &h1, &h2), ""); |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderClone(client, h1, &rv), ""); |
| ASSERT_EQ(45, rv, ""); |
| ASSERT_EQ(ZX_ERR_PEER_CLOSED, zx_object_signal_peer(h2, 0, 0), ""); |
| ASSERT_EQ(ZX_OK, zx_handle_close(h2), ""); |
| } |
| |
| { |
| const char* sink = "my data sink"; |
| zx_status_t rv = ZX_OK; |
| zx_handle_t h1, h2; |
| ASSERT_EQ(ZX_OK, zx_eventpair_create(0, &h1, &h2), ""); |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderDebugPublishDataSink(client, sink, strlen(sink), h1, &rv), ""); |
| ASSERT_EQ(46, rv, ""); |
| ASSERT_EQ(ZX_ERR_PEER_CLOSED, zx_object_signal_peer(h2, 0, 0), ""); |
| ASSERT_EQ(ZX_OK, zx_handle_close(h2), ""); |
| } |
| |
| { |
| const char* config_name = "my debug config"; |
| zx_status_t rv = ZX_OK; |
| zx_handle_t object = ZX_HANDLE_INVALID; |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderDebugLoadConfig(client, config_name, strlen(config_name), &rv, &object), ""); |
| ASSERT_EQ(47, rv, ""); |
| ASSERT_EQ(ZX_OK, zx_handle_close(object), ""); |
| } |
| |
| ASSERT_EQ(ZX_OK, fuchsia_ldsvc_LoaderDone(client), ""); |
| ASSERT_EQ(ZX_OK, zx_handle_close(client), ""); |
| |
| int result = 0; |
| rv = thrd_join(thread, &result); |
| ASSERT_EQ(thrd_success, rv, ""); |
| |
| END_TEST; |
| } |
| |
| BEGIN_TEST_CASE(ldsvc_tests) |
| RUN_NAMED_TEST("fuchsia.ldsvc.Loader test", loader_test) |
| END_TEST_CASE(ldsvc_tests); |