// Copyright 2016 The Chromium 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 <stdint.h>
|
#include <string.h>
|
|
#include <algorithm>
|
#include <string>
|
#include <vector>
|
|
#include "base/files/file.h"
|
#include "base/files/file_util.h"
|
#include "base/memory/shared_memory.h"
|
#include "base/process/process_handle.h"
|
#include "build/build_config.h"
|
#include "mojo/core/test/mojo_test_base.h"
|
#include "mojo/public/c/system/platform_handle.h"
|
#include "mojo/public/cpp/system/message_pipe.h"
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#if defined(OS_WIN)
|
#include <windows.h>
|
#endif
|
|
#if defined(OS_WIN)
|
#define SIMPLE_PLATFORM_HANDLE_TYPE MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE
|
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
|
#define SIMPLE_PLATFORM_HANDLE_TYPE MOJO_PLATFORM_HANDLE_TYPE_FILE_DESCRIPTOR
|
#endif
|
|
#if defined(OS_FUCHSIA)
|
#define SHARED_BUFFER_PLATFORM_HANDLE_TYPE \
|
MOJO_PLATFORM_HANDLE_TYPE_FUCHSIA_HANDLE
|
#elif defined(OS_MACOSX) && !defined(OS_IOS)
|
#define SHARED_BUFFER_PLATFORM_HANDLE_TYPE MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT
|
#elif defined(OS_WIN) || defined(OS_POSIX)
|
#define SHARED_BUFFER_PLATFORM_HANDLE_TYPE SIMPLE_PLATFORM_HANDLE_TYPE
|
#endif
|
|
uint64_t PlatformHandleValueFromPlatformFile(base::PlatformFile file) {
|
#if defined(OS_WIN)
|
return reinterpret_cast<uint64_t>(file);
|
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
|
return static_cast<uint64_t>(file);
|
#endif
|
}
|
|
base::PlatformFile PlatformFileFromPlatformHandleValue(uint64_t value) {
|
#if defined(OS_WIN)
|
return reinterpret_cast<base::PlatformFile>(value);
|
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
|
return static_cast<base::PlatformFile>(value);
|
#endif
|
}
|
|
namespace mojo {
|
namespace core {
|
namespace {
|
|
using PlatformWrapperTest = test::MojoTestBase;
|
|
TEST_F(PlatformWrapperTest, WrapPlatformHandle) {
|
// Create a temporary file and write a message to it.
|
base::FilePath temp_file_path;
|
ASSERT_TRUE(base::CreateTemporaryFile(&temp_file_path));
|
const std::string kMessage = "Hello, world!";
|
EXPECT_EQ(base::WriteFile(temp_file_path, kMessage.data(),
|
static_cast<int>(kMessage.size())),
|
static_cast<int>(kMessage.size()));
|
|
RunTestClient("ReadPlatformFile", [&](MojoHandle h) {
|
// Open the temporary file for reading, wrap its handle, and send it to
|
// the child along with the expected message to be read.
|
base::File file(temp_file_path,
|
base::File::FLAG_OPEN | base::File::FLAG_READ);
|
EXPECT_TRUE(file.IsValid());
|
|
MojoHandle wrapped_handle;
|
MojoPlatformHandle os_file;
|
os_file.struct_size = sizeof(MojoPlatformHandle);
|
os_file.type = SIMPLE_PLATFORM_HANDLE_TYPE;
|
os_file.value =
|
PlatformHandleValueFromPlatformFile(file.TakePlatformFile());
|
EXPECT_EQ(MOJO_RESULT_OK,
|
MojoWrapPlatformHandle(&os_file, nullptr, &wrapped_handle));
|
|
WriteMessageWithHandles(h, kMessage, &wrapped_handle, 1);
|
});
|
|
base::DeleteFile(temp_file_path, false);
|
}
|
|
DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadPlatformFile, PlatformWrapperTest, h) {
|
// Read a message and a wrapped file handle; unwrap the handle.
|
MojoHandle wrapped_handle;
|
std::string message = ReadMessageWithHandles(h, &wrapped_handle, 1);
|
|
MojoPlatformHandle platform_handle;
|
platform_handle.struct_size = sizeof(MojoPlatformHandle);
|
ASSERT_EQ(MOJO_RESULT_OK, MojoUnwrapPlatformHandle(wrapped_handle, nullptr,
|
&platform_handle));
|
EXPECT_EQ(SIMPLE_PLATFORM_HANDLE_TYPE, platform_handle.type);
|
base::File file(PlatformFileFromPlatformHandleValue(platform_handle.value));
|
|
// Expect to read the same message from the file.
|
std::vector<char> data(message.size());
|
EXPECT_EQ(file.ReadAtCurrentPos(data.data(), static_cast<int>(data.size())),
|
static_cast<int>(data.size()));
|
EXPECT_TRUE(std::equal(message.begin(), message.end(), data.begin()));
|
}
|
|
TEST_F(PlatformWrapperTest, WrapPlatformSharedMemoryRegion) {
|
// Allocate a new platform shared buffer and write a message into it.
|
const std::string kMessage = "Hello, world!";
|
base::SharedMemory buffer;
|
buffer.CreateAndMapAnonymous(kMessage.size());
|
CHECK(buffer.memory());
|
memcpy(buffer.memory(), kMessage.data(), kMessage.size());
|
|
RunTestClient("ReadPlatformSharedBuffer", [&](MojoHandle h) {
|
// Wrap the shared memory handle and send it to the child along with the
|
// expected message.
|
base::SharedMemoryHandle memory_handle =
|
base::SharedMemory::DuplicateHandle(buffer.handle());
|
MojoPlatformHandle os_buffer;
|
os_buffer.struct_size = sizeof(MojoPlatformHandle);
|
os_buffer.type = SHARED_BUFFER_PLATFORM_HANDLE_TYPE;
|
#if defined(OS_WIN)
|
os_buffer.value = reinterpret_cast<uint64_t>(memory_handle.GetHandle());
|
#elif defined(OS_MACOSX) && !defined(OS_IOS)
|
os_buffer.value = static_cast<uint64_t>(memory_handle.GetMemoryObject());
|
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
|
os_buffer.value = static_cast<uint64_t>(memory_handle.GetHandle());
|
#else
|
#error Unsupported platform
|
#endif
|
|
MojoSharedBufferGuid mojo_guid;
|
base::UnguessableToken guid = memory_handle.GetGUID();
|
mojo_guid.high = guid.GetHighForSerialization();
|
mojo_guid.low = guid.GetLowForSerialization();
|
|
MojoHandle wrapped_handle;
|
ASSERT_EQ(MOJO_RESULT_OK,
|
MojoWrapPlatformSharedMemoryRegion(
|
&os_buffer, 1, kMessage.size(), &mojo_guid,
|
MOJO_PLATFORM_SHARED_MEMORY_REGION_ACCESS_MODE_UNSAFE,
|
nullptr, &wrapped_handle));
|
WriteMessageWithHandles(h, kMessage, &wrapped_handle, 1);
|
|
// As a sanity check, send the GUID explicitly in a second message. We'll
|
// verify that the deserialized buffer handle holds the same GUID on the
|
// receiving end.
|
WriteMessageRaw(MessagePipeHandle(h), &mojo_guid, sizeof(mojo_guid),
|
nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
|
});
|
}
|
|
DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadPlatformSharedBuffer,
|
PlatformWrapperTest,
|
h) {
|
// Read a message and a wrapped shared buffer handle.
|
MojoHandle wrapped_handle;
|
std::string message = ReadMessageWithHandles(h, &wrapped_handle, 1);
|
|
// Check the message in the buffer
|
ExpectBufferContents(wrapped_handle, 0, message);
|
|
// Now unwrap the buffer and verify that the base::SharedMemoryHandle also
|
// works as expected.
|
MojoPlatformHandle os_buffer;
|
os_buffer.struct_size = sizeof(MojoPlatformHandle);
|
uint32_t num_handles = 1;
|
uint64_t size;
|
MojoSharedBufferGuid mojo_guid;
|
MojoPlatformSharedMemoryRegionAccessMode access_mode;
|
ASSERT_EQ(MOJO_RESULT_OK, MojoUnwrapPlatformSharedMemoryRegion(
|
wrapped_handle, nullptr, &os_buffer,
|
&num_handles, &size, &mojo_guid, &access_mode));
|
EXPECT_EQ(MOJO_PLATFORM_SHARED_MEMORY_REGION_ACCESS_MODE_UNSAFE, access_mode);
|
|
base::UnguessableToken guid =
|
base::UnguessableToken::Deserialize(mojo_guid.high, mojo_guid.low);
|
#if defined(OS_WIN)
|
ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE, os_buffer.type);
|
base::SharedMemoryHandle memory_handle(
|
reinterpret_cast<HANDLE>(os_buffer.value), size, guid);
|
#elif defined(OS_FUCHSIA)
|
ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_FUCHSIA_HANDLE, os_buffer.type);
|
base::SharedMemoryHandle memory_handle(
|
static_cast<zx_handle_t>(os_buffer.value), size, guid);
|
#elif defined(OS_MACOSX) && !defined(OS_IOS)
|
ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT, os_buffer.type);
|
base::SharedMemoryHandle memory_handle(
|
static_cast<mach_port_t>(os_buffer.value), size, guid);
|
#elif defined(OS_POSIX)
|
ASSERT_EQ(MOJO_PLATFORM_HANDLE_TYPE_FILE_DESCRIPTOR, os_buffer.type);
|
base::SharedMemoryHandle memory_handle(
|
base::FileDescriptor(static_cast<int>(os_buffer.value), false), size,
|
guid);
|
#endif
|
|
base::SharedMemory memory(memory_handle, false);
|
memory.Map(message.size());
|
ASSERT_TRUE(memory.memory());
|
|
EXPECT_TRUE(std::equal(message.begin(), message.end(),
|
static_cast<const char*>(memory.memory())));
|
|
// Verify that the received buffer's internal GUID was preserved in transit.
|
EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE));
|
std::vector<uint8_t> guid_bytes;
|
EXPECT_EQ(MOJO_RESULT_OK,
|
ReadMessageRaw(MessagePipeHandle(h), &guid_bytes, nullptr,
|
MOJO_READ_MESSAGE_FLAG_NONE));
|
EXPECT_EQ(sizeof(MojoSharedBufferGuid), guid_bytes.size());
|
auto* expected_guid =
|
reinterpret_cast<MojoSharedBufferGuid*>(guid_bytes.data());
|
EXPECT_EQ(expected_guid->high, mojo_guid.high);
|
EXPECT_EQ(expected_guid->low, mojo_guid.low);
|
}
|
|
TEST_F(PlatformWrapperTest, InvalidHandle) {
|
// Wrap an invalid platform handle and expect to unwrap the same.
|
|
MojoHandle wrapped_handle;
|
MojoPlatformHandle invalid_handle;
|
invalid_handle.struct_size = sizeof(MojoPlatformHandle);
|
invalid_handle.type = MOJO_PLATFORM_HANDLE_TYPE_INVALID;
|
EXPECT_EQ(MOJO_RESULT_OK,
|
MojoWrapPlatformHandle(&invalid_handle, nullptr, &wrapped_handle));
|
EXPECT_EQ(MOJO_RESULT_OK,
|
MojoUnwrapPlatformHandle(wrapped_handle, nullptr, &invalid_handle));
|
EXPECT_EQ(MOJO_PLATFORM_HANDLE_TYPE_INVALID, invalid_handle.type);
|
}
|
|
TEST_F(PlatformWrapperTest, InvalidArgument) {
|
// Try to wrap an invalid MojoPlatformHandle struct and expect an error.
|
MojoHandle wrapped_handle;
|
MojoPlatformHandle platform_handle;
|
platform_handle.struct_size = 0;
|
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
|
MojoWrapPlatformHandle(&platform_handle, nullptr, &wrapped_handle));
|
}
|
|
} // namespace
|
} // namespace core
|
} // namespace mojo
|
