ipc/ipc_message_utils_unittest.cc

   1 // Copyright 2012 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ipc/ipc_message_utils.h"
   6
   7 #include <stddef.h>
   8 #include <stdint.h>
   9 #include <memory>
  10
  11 #include "base/files/file_path.h"
  12 #include "base/json/json_reader.h"
  13 #include "base/memory/ptr_util.h"
  14 #include "base/test/test_shared_memory_util.h"
  15 #include "base/unguessable_token.h"
  16 #include "build/build_config.h"
  17 #include "ipc/ipc_channel_handle.h"
  18 #include "ipc/ipc_message.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 #if BUILDFLAG(IS_WIN)
  22 #include <windows.h>
  23 #endif
  24
  25 namespace IPC {
  26 namespace {
  27
  28 // Tests nesting of messages as parameters to other messages.
  29 TEST(IPCMessageUtilsTest, NestedMessages) {
  30   int32_t nested_routing = 12;
  31   uint32_t nested_type = 78;
  32   int nested_content = 456789;
  33   Message::PriorityValue nested_priority = Message::PRIORITY_HIGH;
  34   Message nested_msg(nested_routing, nested_type, nested_priority);
  35   nested_msg.set_sync();
  36   ParamTraits<int>::Write(&nested_msg, nested_content);
  37
  38   // Outer message contains the nested one as its parameter.
  39   int32_t outer_routing = 91;
  40   uint32_t outer_type = 88;
  41   Message::PriorityValue outer_priority = Message::PRIORITY_NORMAL;
  42   Message outer_msg(outer_routing, outer_type, outer_priority);
  43   ParamTraits<Message>::Write(&outer_msg, nested_msg);
  44
  45   // Read back the nested message.
  46   base::PickleIterator iter(outer_msg);
  47   IPC::Message result_msg;
  48   ASSERT_TRUE(ParamTraits<Message>::Read(&outer_msg, &iter, &result_msg));
  49
  50   // Verify nested message headers.
  51   EXPECT_EQ(nested_msg.routing_id(), result_msg.routing_id());
  52   EXPECT_EQ(nested_msg.type(), result_msg.type());
  53   EXPECT_EQ(nested_msg.priority(), result_msg.priority());
  54   EXPECT_EQ(nested_msg.flags(), result_msg.flags());
  55
  56   // Verify nested message content
  57   base::PickleIterator nested_iter(nested_msg);
  58   int result_content = 0;
  59   ASSERT_TRUE(ParamTraits<int>::Read(&nested_msg, &nested_iter,
  60                                      &result_content));
  61   EXPECT_EQ(nested_content, result_content);
  62
  63   // Try reading past the ends for both messages and make sure it fails.
  64   IPC::Message dummy;
  65   ASSERT_FALSE(ParamTraits<Message>::Read(&outer_msg, &iter, &dummy));
  66   ASSERT_FALSE(ParamTraits<int>::Read(&nested_msg, &nested_iter,
  67                                       &result_content));
  68 }
  69
  70 // Tests that detection of various bad parameters is working correctly.
  71 TEST(IPCMessageUtilsTest, ParameterValidation) {
  72   base::FilePath::StringType ok_string(FILE_PATH_LITERAL("hello"), 5);
  73   base::FilePath::StringType bad_string(FILE_PATH_LITERAL("hel\0o"), 5);
  74
  75   // Change this if ParamTraits<FilePath>::Write() changes.
  76   IPC::Message message;
  77   ParamTraits<base::FilePath::StringType>::Write(&message, ok_string);
  78   ParamTraits<base::FilePath::StringType>::Write(&message, bad_string);
  79
  80   base::PickleIterator iter(message);
  81   base::FilePath ok_path;
  82   base::FilePath bad_path;
  83   ASSERT_TRUE(ParamTraits<base::FilePath>::Read(&message, &iter, &ok_path));
  84   ASSERT_FALSE(ParamTraits<base::FilePath>::Read(&message, &iter, &bad_path));
  85 }
  86
  87 TEST(IPCMessageUtilsTest, InlinedVector) {
  88   static constexpr size_t stack_capacity = 5;
  89   absl::InlinedVector<double, stack_capacity> inlined_vector;
  90   for (size_t i = 0; i < 2 * stack_capacity; i++) {
  91     inlined_vector.push_back(i * 2.0);
  92   }
  93
  94   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
  95   IPC::WriteParam(&msg, inlined_vector);
  96
  97   absl::InlinedVector<double, stack_capacity> output;
  98   base::PickleIterator iter(msg);
  99   EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
 100   ASSERT_EQ(inlined_vector.size(), output.size());
 101   for (size_t i = 0; i < 2 * stack_capacity; i++) {
 102     EXPECT_EQ(inlined_vector[i], output[i]);
 103   }
 104 }
 105
 106 TEST(IPCMessageUtilsTest, MojoChannelHandle) {
 107   mojo::MessagePipe message_pipe;
 108   IPC::ChannelHandle channel_handle(message_pipe.handle0.release());
 109
 110   IPC::Message message;
 111   IPC::WriteParam(&message, channel_handle);
 112
 113   base::PickleIterator iter(message);
 114   IPC::ChannelHandle result_handle;
 115   EXPECT_TRUE(IPC::ReadParam(&message, &iter, &result_handle));
 116   EXPECT_EQ(channel_handle.mojo_handle, result_handle.mojo_handle);
 117 }
 118
 119 TEST(IPCMessageUtilsTest, OptionalUnset) {
 120   absl::optional<int> opt;
 121   base::Pickle pickle;
 122   IPC::WriteParam(&pickle, opt);
 123
 124   std::string log;
 125   IPC::LogParam(opt, &log);
 126   EXPECT_EQ("(unset)", log);
 127
 128   absl::optional<int> unserialized_opt;
 129   base::PickleIterator iter(pickle);
 130   EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &unserialized_opt));
 131   EXPECT_FALSE(unserialized_opt);
 132 }
 133
 134 TEST(IPCMessageUtilsTest, OptionalSet) {
 135   absl::optional<int> opt(10);
 136   base::Pickle pickle;
 137   IPC::WriteParam(&pickle, opt);
 138
 139   std::string log;
 140   IPC::LogParam(opt, &log);
 141   EXPECT_EQ("10", log);
 142
 143   absl::optional<int> unserialized_opt;
 144   base::PickleIterator iter(pickle);
 145   EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &unserialized_opt));
 146   EXPECT_TRUE(unserialized_opt);
 147   EXPECT_EQ(opt.value(), unserialized_opt.value());
 148 }
 149
 150 template <typename SharedMemoryRegionType>
 151 class SharedMemoryRegionTypedTest : public ::testing::Test {};
 152
 153 typedef ::testing::Types<base::WritableSharedMemoryRegion,
 154                          base::UnsafeSharedMemoryRegion,
 155                          base::ReadOnlySharedMemoryRegion>
 156     AllSharedMemoryRegionTypes;
 157 TYPED_TEST_SUITE(SharedMemoryRegionTypedTest, AllSharedMemoryRegionTypes);
 158
 159 TYPED_TEST(SharedMemoryRegionTypedTest, WriteAndRead) {
 160   const size_t size = 2314;
 161   auto [pre_pickle, pre_mapping] = base::CreateMappedRegion<TypeParam>(size);
 162   const size_t pre_size = pre_pickle.GetSize();
 163
 164   const std::string content = "Hello, world!";
 165   memcpy(pre_mapping.memory(), content.data(), content.size());
 166
 167   IPC::Message message;
 168   IPC::WriteParam(&message, pre_pickle);
 169   EXPECT_FALSE(pre_pickle.IsValid());
 170
 171   TypeParam post_pickle;
 172   base::PickleIterator iter(message);
 173   EXPECT_TRUE(IPC::ReadParam(&message, &iter, &post_pickle));
 174   EXPECT_EQ(pre_size, post_pickle.GetSize());
 175   typename TypeParam::MappingType post_mapping = post_pickle.Map();
 176   EXPECT_EQ(pre_mapping.guid(), post_mapping.guid());
 177   EXPECT_EQ(0, memcmp(pre_mapping.memory(), post_mapping.memory(),
 178                       post_pickle.GetSize()));
 179 }
 180
 181 TYPED_TEST(SharedMemoryRegionTypedTest, InvalidRegion) {
 182   TypeParam pre_pickle;
 183   EXPECT_FALSE(pre_pickle.IsValid());
 184
 185   IPC::Message message;
 186   IPC::WriteParam(&message, pre_pickle);
 187
 188   TypeParam post_pickle;
 189   base::PickleIterator iter(message);
 190   EXPECT_TRUE(IPC::ReadParam(&message, &iter, &post_pickle));
 191   EXPECT_FALSE(post_pickle.IsValid());
 192 }
 193
 194 TEST(IPCMessageUtilsTest, UnguessableTokenTest) {
 195   base::UnguessableToken token = base::UnguessableToken::Create();
 196   base::Pickle pickle;
 197   IPC::WriteParam(&pickle, token);
 198
 199   std::string log;
 200   IPC::LogParam(token, &log);
 201   EXPECT_EQ(token.ToString(), log);
 202
 203   base::UnguessableToken deserialized_token;
 204   base::PickleIterator iter(pickle);
 205   EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &deserialized_token));
 206   EXPECT_EQ(token, deserialized_token);
 207 }
 208
 209 TEST(IPCMessageUtilsTest, FlatMap) {
 210   base::flat_map<std::string, int> input;
 211   input["foo"] = 42;
 212   input["bar"] = 96;
 213
 214   base::Pickle pickle;
 215   IPC::WriteParam(&pickle, input);
 216
 217   base::PickleIterator iter(pickle);
 218   base::flat_map<std::string, int> output;
 219   EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &output));
 220
 221   EXPECT_EQ(input, output);
 222 }
 223
 224 TEST(IPCMessageUtilsTest, StrongAlias) {
 225   using TestType = base::StrongAlias<class Tag, int>;
 226   TestType input(42);
 227
 228   base::Pickle pickle;
 229   IPC::WriteParam(&pickle, input);
 230
 231   base::PickleIterator iter(pickle);
 232   TestType output;
 233   EXPECT_TRUE(IPC::ReadParam(&pickle, &iter, &output));
 234
 235   EXPECT_EQ(input, output);
 236 }
 237
 238 TEST(IPCMessageUtilsTest, DictValueConversion) {
 239   base::Value::Dict dict_value;
 240   dict_value.Set("path1", 42);
 241   dict_value.Set("path2", 84);
 242   base::Value::List subvalue;
 243   subvalue.Append(1234);
 244   subvalue.Append(5678);
 245   dict_value.Set("path3", std::move(subvalue));
 246
 247   IPC::Message message;
 248   ParamTraits<base::Value::Dict>::Write(&message, dict_value);
 249
 250   base::PickleIterator iter(message);
 251   base::Value::Dict read_value;
 252   ASSERT_TRUE(
 253       ParamTraits<base::Value::Dict>::Read(&message, &iter, &read_value));
 254   EXPECT_EQ(dict_value, read_value);
 255 }
 256
 257 TEST(IPCMessageUtilsTest, ListValueConversion) {
 258   base::Value::List list_value;
 259   list_value.Append(42);
 260   list_value.Append(84);
 261
 262   IPC::Message message;
 263   ParamTraits<base::Value::List>::Write(&message, list_value);
 264
 265   base::PickleIterator iter(message);
 266   base::Value::List read_value;
 267   ASSERT_TRUE(
 268       ParamTraits<base::Value::List>::Read(&message, &iter, &read_value));
 269   EXPECT_EQ(list_value, read_value);
 270 }
 271
 272 #if BUILDFLAG(IS_WIN)
 273 TEST(IPCMessageUtilsTest, ScopedHandle) {
 274   HANDLE raw_dupe_handle;
 275   ASSERT_TRUE(::DuplicateHandle(::GetCurrentProcess(), ::GetCurrentProcess(),
 276                                 ::GetCurrentProcess(), &raw_dupe_handle, 0,
 277                                 FALSE, DUPLICATE_SAME_ACCESS));
 278   base::win::ScopedHandle dupe_handle(raw_dupe_handle);
 279
 280   Message message(0, 0, Message::PRIORITY_LOW);
 281   WriteParam(&message, dupe_handle);
 282
 283   base::PickleIterator iter(message);
 284   base::win::ScopedHandle read_handle;
 285   EXPECT_TRUE(ReadParam(&message, &iter, &read_handle));
 286   EXPECT_TRUE(read_handle.IsValid());
 287 }
 288 #endif  // BUILDFLAG(IS_WIN)
 289
 290 }  // namespace
 291 }  // namespace IPC