transport_test.cc 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. // Copyright 2022 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "mojo/core/ipcz_driver/transport.h"
  5. #include <algorithm>
  6. #include <cstring>
  7. #include <queue>
  8. #include <string>
  9. #include <string_view>
  10. #include <utility>
  11. #include <vector>
  12. #include "base/containers/span.h"
  13. #include "base/files/file.h"
  14. #include "base/files/scoped_temp_dir.h"
  15. #include "base/memory/scoped_refptr.h"
  16. #include "base/synchronization/condition_variable.h"
  17. #include "base/synchronization/lock.h"
  18. #include "base/synchronization/waitable_event.h"
  19. #include "build/build_config.h"
  20. #include "mojo/core/ipcz_driver/driver.h"
  21. #include "mojo/core/ipcz_driver/transmissible_platform_handle.h"
  22. #include "mojo/core/ipcz_driver/wrapped_platform_handle.h"
  23. #include "mojo/core/test/mojo_test_base.h"
  24. #include "mojo/public/c/system/platform_handle.h"
  25. #include "mojo/public/cpp/platform/platform_channel.h"
  26. #include "mojo/public/cpp/platform/platform_handle.h"
  27. #include "mojo/public/cpp/system/platform_handle.h"
  28. namespace mojo::core::ipcz_driver {
  29. namespace {
  30. struct TestMessage {
  31. TestMessage() = default;
  32. explicit TestMessage(std::string_view str,
  33. base::span<IpczDriverHandle> handles = {})
  34. : bytes(str.begin(), str.end()),
  35. handles(handles.begin(), handles.end()) {}
  36. std::string as_string() const {
  37. return {reinterpret_cast<const char*>(bytes.data()), bytes.size()};
  38. }
  39. void Transmit(Transport& transmitter) {
  40. transmitter.Transmit(base::make_span(bytes), base::make_span(handles));
  41. }
  42. std::vector<uint8_t> bytes;
  43. std::vector<IpczDriverHandle> handles;
  44. };
  45. // These tests use Mojo and Mojo's existing multiprocess test facilities to set
  46. // up a multiprocess environment and send an initial transport handle to the
  47. // child process.
  48. class MojoIpczTransportTest : public test::MojoTestBase {
  49. protected:
  50. // Creates a new ad hoc ipcz Transport object from a new PlatformChannel. One
  51. // end of the channel is returned as a Transport while the other is sent over
  52. // `pipe` to `process`.
  53. static scoped_refptr<Transport> CreateAndSendTransport(
  54. MojoHandle pipe,
  55. const base::Process& process) {
  56. PlatformChannel channel;
  57. MojoHandle transport_for_client =
  58. WrapPlatformHandle(channel.TakeRemoteEndpoint().TakePlatformHandle())
  59. .release()
  60. .value();
  61. WriteMessageWithHandles(pipe, "", &transport_for_client, 1);
  62. return base::MakeRefCounted<Transport>(Transport::kToNonBroker,
  63. channel.TakeLocalEndpoint(),
  64. process.Duplicate());
  65. }
  66. // Retrieves a PlatformChannel endpoint from `pipe` and returns a newly
  67. // constructed Transport over it.
  68. static scoped_refptr<Transport> ReceiveTransport(MojoHandle pipe) {
  69. MojoHandle transport_for_client;
  70. ReadMessageWithHandles(pipe, &transport_for_client, 1);
  71. PlatformHandle handle =
  72. UnwrapPlatformHandle(ScopedHandle(Handle(transport_for_client)));
  73. return base::MakeRefCounted<Transport>(
  74. Transport::kToBroker, PlatformChannelEndpoint(std::move(handle)));
  75. }
  76. static TestMessage SerializeObjectFor(Transport& transmitter,
  77. scoped_refptr<ObjectBase> object) {
  78. size_t num_bytes = 0;
  79. size_t num_handles = 0;
  80. EXPECT_EQ(IPCZ_RESULT_RESOURCE_EXHAUSTED,
  81. transmitter.SerializeObject(*object, nullptr, &num_bytes, nullptr,
  82. &num_handles));
  83. TestMessage message;
  84. message.bytes.resize(num_bytes);
  85. message.handles.resize(num_handles);
  86. EXPECT_EQ(IPCZ_RESULT_OK, transmitter.SerializeObject(
  87. *object, message.bytes.data(), &num_bytes,
  88. message.handles.data(), &num_handles));
  89. return message;
  90. }
  91. template <typename T>
  92. static scoped_refptr<T> DeserializeObjectFrom(Transport& receiver,
  93. const TestMessage& message) {
  94. scoped_refptr<ObjectBase> object;
  95. const IpczResult result =
  96. receiver.DeserializeObject(base::make_span(message.bytes),
  97. base::make_span(message.handles), object);
  98. CHECK_EQ(result, IPCZ_RESULT_OK);
  99. CHECK_EQ(object->type(), T::object_type());
  100. return base::WrapRefCounted(static_cast<T*>(object.get()));
  101. }
  102. static TestMessage SerializeFileFor(Transport& transmitter, base::File file) {
  103. auto wrapper = base::MakeRefCounted<WrappedPlatformHandle>(
  104. PlatformHandle(base::ScopedPlatformFile(file.TakePlatformFile())));
  105. return SerializeObjectFor(transmitter, std::move(wrapper));
  106. }
  107. static base::File DeserializeFileFrom(Transport& receiver,
  108. const TestMessage& message) {
  109. scoped_refptr<WrappedPlatformHandle> wrapper =
  110. DeserializeObjectFrom<WrappedPlatformHandle>(receiver, message);
  111. CHECK(wrapper);
  112. #if BUILDFLAG(IS_WIN)
  113. return base::File(wrapper->TakeHandle().TakeHandle());
  114. #elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  115. return base::File(wrapper->TakeHandle().TakeFD());
  116. #endif
  117. }
  118. };
  119. // TransportListener provides a convenient way for tests to listen to incoming
  120. // events on a Transport.
  121. class TransportListener {
  122. public:
  123. explicit TransportListener(Transport& transport) : transport_(transport) {
  124. transport_.Activate(reinterpret_cast<IpczHandle>(this),
  125. &TransportListener::OnActivity);
  126. }
  127. ~TransportListener() {
  128. transport_.Deactivate();
  129. deactivation_event_.Wait();
  130. }
  131. TestMessage WaitForNextMessage() {
  132. base::AutoLock lock(lock_);
  133. while (messages_.empty()) {
  134. have_messages_.Wait();
  135. }
  136. TestMessage message = std::move(messages_.front());
  137. messages_.pop();
  138. return message;
  139. }
  140. void WaitForDisconnect() { disconnect_event_.Wait(); }
  141. private:
  142. static IpczResult OnActivity(IpczHandle transport,
  143. const void* data,
  144. size_t num_bytes,
  145. const IpczDriverHandle* handles,
  146. size_t num_handles,
  147. IpczTransportActivityFlags flags,
  148. const void*) {
  149. auto* listener = reinterpret_cast<TransportListener*>(transport);
  150. auto bytes = base::make_span(static_cast<const uint8_t*>(data), num_bytes);
  151. listener->HandleActivity(bytes, base::make_span(handles, num_handles),
  152. flags);
  153. return IPCZ_RESULT_OK;
  154. }
  155. void HandleActivity(base::span<const uint8_t> bytes,
  156. base::span<const IpczDriverHandle> handles,
  157. IpczTransportActivityFlags flags) {
  158. if (flags & IPCZ_TRANSPORT_ACTIVITY_ERROR) {
  159. disconnect_event_.Signal();
  160. return;
  161. }
  162. if (flags & IPCZ_TRANSPORT_ACTIVITY_DEACTIVATED) {
  163. deactivation_event_.Signal();
  164. return;
  165. }
  166. TestMessage message;
  167. message.bytes.resize(bytes.size());
  168. message.handles.resize(handles.size());
  169. std::copy(bytes.begin(), bytes.end(), message.bytes.begin());
  170. std::copy(handles.begin(), handles.end(), message.handles.begin());
  171. base::AutoLock lock(lock_);
  172. messages_.push(std::move(message));
  173. have_messages_.Signal();
  174. }
  175. Transport& transport_;
  176. base::Lock lock_;
  177. base::ConditionVariable have_messages_{&lock_};
  178. std::queue<TestMessage> messages_ GUARDED_BY(lock_);
  179. base::WaitableEvent disconnect_event_;
  180. base::WaitableEvent deactivation_event_;
  181. };
  182. constexpr std::string_view kMessage1 = "we are messages";
  183. constexpr std::string_view kMessage2 = "tremendous messages";
  184. constexpr std::string_view kMessage3 = "the very best messages";
  185. constexpr std::string_view kMessage4 = "everyone says so";
  186. DEFINE_TEST_CLIENT_TEST_WITH_PIPE(BasicTransmitClient,
  187. MojoIpczTransportTest,
  188. h) {
  189. scoped_refptr<Transport> transport = ReceiveTransport(h);
  190. TransportListener listener(*transport);
  191. TestMessage(kMessage3).Transmit(*transport);
  192. TestMessage(kMessage4).Transmit(*transport);
  193. EXPECT_EQ(kMessage1, listener.WaitForNextMessage().as_string());
  194. EXPECT_EQ(kMessage2, listener.WaitForNextMessage().as_string());
  195. }
  196. TEST_F(MojoIpczTransportTest, BasicTransmit) {
  197. RunTestClientWithController("BasicTransmitClient", [&](ClientController& c) {
  198. scoped_refptr<Transport> transport =
  199. CreateAndSendTransport(c.pipe(), c.process());
  200. TransportListener listener(*transport);
  201. TestMessage(kMessage1).Transmit(*transport);
  202. TestMessage(kMessage2).Transmit(*transport);
  203. EXPECT_EQ(kMessage3, listener.WaitForNextMessage().as_string());
  204. EXPECT_EQ(kMessage4, listener.WaitForNextMessage().as_string());
  205. listener.WaitForDisconnect();
  206. });
  207. }
  208. // Transport on Windows does not support out-of-band handle transfer, so this
  209. // test is impossible there. Windows handle transmission is instead covered by
  210. // tests which more broadly cover driver object serialization.
  211. #if !BUILDFLAG(IS_WIN)
  212. IpczDriverHandle MakeHandleFromEndpoint(PlatformChannelEndpoint endpoint) {
  213. return TransmissiblePlatformHandle::ReleaseAsHandle(
  214. base::MakeRefCounted<TransmissiblePlatformHandle>(
  215. endpoint.TakePlatformHandle()));
  216. }
  217. scoped_refptr<Transport> MakeTransportFromMessage(const TestMessage& message) {
  218. CHECK_EQ(message.handles.size(), 1u);
  219. auto handle = TransmissiblePlatformHandle::TakeFromHandle(message.handles[0]);
  220. CHECK(handle);
  221. return base::MakeRefCounted<Transport>(
  222. Transport::kToBroker, PlatformChannelEndpoint(handle->TakeHandle()));
  223. }
  224. DEFINE_TEST_CLIENT_TEST_WITH_PIPE(TransmitHandleClient,
  225. MojoIpczTransportTest,
  226. h) {
  227. scoped_refptr<Transport> transport = ReceiveTransport(h);
  228. scoped_refptr<Transport> new_transport1;
  229. scoped_refptr<Transport> new_transport2;
  230. {
  231. TransportListener listener(*transport);
  232. new_transport1 = MakeTransportFromMessage(listener.WaitForNextMessage());
  233. new_transport2 = MakeTransportFromMessage(listener.WaitForNextMessage());
  234. }
  235. TransportListener listener1(*new_transport1);
  236. TransportListener listener2(*new_transport2);
  237. TestMessage(kMessage3).Transmit(*new_transport1);
  238. TestMessage(kMessage4).Transmit(*new_transport2);
  239. EXPECT_EQ(kMessage1, listener1.WaitForNextMessage().as_string());
  240. EXPECT_EQ(kMessage2, listener2.WaitForNextMessage().as_string());
  241. }
  242. TEST_F(MojoIpczTransportTest, TransmitHandle) {
  243. RunTestClientWithController("TransmitHandleClient", [&](ClientController& c) {
  244. scoped_refptr<Transport> transport =
  245. CreateAndSendTransport(c.pipe(), c.process());
  246. // The PlatformHandle backing a PlatformChannelEndpoint is already
  247. // transmissible on all applicable platforms, so we can conveniently test
  248. // handle transmission without depending on driver object serialization.
  249. PlatformChannel channel1;
  250. auto new_transport1 = base::MakeRefCounted<Transport>(
  251. Transport::kToNonBroker, channel1.TakeLocalEndpoint(),
  252. c.process().Duplicate());
  253. PlatformChannel channel2;
  254. auto new_transport2 = base::MakeRefCounted<Transport>(
  255. Transport::kToNonBroker, channel2.TakeLocalEndpoint(),
  256. c.process().Duplicate());
  257. IpczDriverHandle handle1 =
  258. MakeHandleFromEndpoint(channel1.TakeRemoteEndpoint());
  259. IpczDriverHandle handle2 =
  260. MakeHandleFromEndpoint(channel2.TakeRemoteEndpoint());
  261. {
  262. TransportListener listener(*transport);
  263. TestMessage("!", {&handle1, 1}).Transmit(*transport);
  264. TestMessage("!", {&handle2, 1}).Transmit(*transport);
  265. listener.WaitForDisconnect();
  266. }
  267. TransportListener listener1(*new_transport1);
  268. TransportListener listener2(*new_transport2);
  269. TestMessage(kMessage1).Transmit(*new_transport1);
  270. TestMessage(kMessage2).Transmit(*new_transport2);
  271. EXPECT_EQ(kMessage3, listener1.WaitForNextMessage().as_string());
  272. EXPECT_EQ(kMessage4, listener2.WaitForNextMessage().as_string());
  273. listener1.WaitForDisconnect();
  274. listener2.WaitForDisconnect();
  275. });
  276. }
  277. #endif // !BUILDFLAG(IS_WIN)
  278. DEFINE_TEST_CLIENT_TEST_WITH_PIPE(TransmitSerializedTransportClient,
  279. MojoIpczTransportTest,
  280. h) {
  281. scoped_refptr<Transport> transport = ReceiveTransport(h);
  282. scoped_refptr<Transport> new_transport;
  283. {
  284. TransportListener listener(*transport);
  285. new_transport = DeserializeObjectFrom<Transport>(
  286. *transport, listener.WaitForNextMessage());
  287. }
  288. TransportListener listener(*new_transport);
  289. TestMessage(kMessage3).Transmit(*new_transport);
  290. TestMessage(kMessage4).Transmit(*new_transport);
  291. EXPECT_EQ(kMessage1, listener.WaitForNextMessage().as_string());
  292. EXPECT_EQ(kMessage2, listener.WaitForNextMessage().as_string());
  293. }
  294. TEST_F(MojoIpczTransportTest, TransmitSerializedTransport) {
  295. RunTestClientWithController(
  296. "TransmitSerializedTransportClient", [&](ClientController& c) {
  297. scoped_refptr<Transport> transport =
  298. CreateAndSendTransport(c.pipe(), c.process());
  299. auto [our_new_transport, their_new_transport] = Transport::CreatePair(
  300. Transport::kToNonBroker, Transport::kToBroker);
  301. {
  302. TransportListener listener(*transport);
  303. SerializeObjectFor(*transport, std::move(their_new_transport))
  304. .Transmit(*transport);
  305. listener.WaitForDisconnect();
  306. }
  307. TransportListener listener(*our_new_transport);
  308. TestMessage(kMessage1).Transmit(*our_new_transport);
  309. TestMessage(kMessage2).Transmit(*our_new_transport);
  310. EXPECT_EQ(kMessage3, listener.WaitForNextMessage().as_string());
  311. EXPECT_EQ(kMessage4, listener.WaitForNextMessage().as_string());
  312. listener.WaitForDisconnect();
  313. });
  314. }
  315. DEFINE_TEST_CLIENT_TEST_WITH_PIPE(TransmitFileClient,
  316. MojoIpczTransportTest,
  317. h) {
  318. scoped_refptr<Transport> transport = ReceiveTransport(h);
  319. TransportListener listener(*transport);
  320. base::File file =
  321. DeserializeFileFrom(*transport, listener.WaitForNextMessage());
  322. std::vector<char> data(file.GetLength());
  323. file.Read(0, data.data(), data.size());
  324. EXPECT_EQ(kMessage1, std::string(data.begin(), data.end()));
  325. }
  326. TEST_F(MojoIpczTransportTest, TransmitFile) {
  327. RunTestClientWithController("TransmitFileClient", [&](ClientController& c) {
  328. scoped_refptr<Transport> transport =
  329. CreateAndSendTransport(c.pipe(), c.process());
  330. base::ScopedTempDir temp_dir;
  331. CHECK(temp_dir.CreateUniqueTempDir());
  332. base::File new_file(temp_dir.GetPath().AppendASCII("testfile"),
  333. base::File::FLAG_CREATE | base::File::FLAG_READ |
  334. base::File::FLAG_WRITE);
  335. new_file.Write(0, kMessage1.data(), kMessage1.size());
  336. TransportListener listener(*transport);
  337. SerializeFileFor(*transport, std::move(new_file)).Transmit(*transport);
  338. listener.WaitForDisconnect();
  339. });
  340. }
  341. } // namespace
  342. } // namespace mojo::core::ipcz_driver