core_ipcz.cc 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656
  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/core_ipcz.h"
  5. #include <cstddef>
  6. #include <cstdint>
  7. #include <utility>
  8. #include <vector>
  9. #include "base/containers/span.h"
  10. #include "base/memory/ptr_util.h"
  11. #include "base/notreached.h"
  12. #include "base/numerics/safe_conversions.h"
  13. #include "base/time/time.h"
  14. #include "mojo/core/ipcz_api.h"
  15. #include "mojo/core/ipcz_driver/mojo_trap.h"
  16. #include "mojo/core/ipcz_driver/wrapped_platform_handle.h"
  17. #include "mojo/public/cpp/platform/platform_handle.h"
  18. #include "third_party/ipcz/include/ipcz/ipcz.h"
  19. namespace mojo::core {
  20. namespace {
  21. // The ipcz-based implementation of Mojo message objects. ipcz API exposes no
  22. // notion of message objects, so this is merely heap storage for data and ipcz
  23. // handles.
  24. class MojoMessage {
  25. public:
  26. // Even with an input size of 0, MojoAppendMessageData is expected to allocate
  27. // *some* storage for message data. This constant therefore sets a lower bound
  28. // on payload allocation size. 32 bytes is chosen since it's the smallest
  29. // possible Mojo bindings message size (v0 header + 8 byte payload)
  30. static constexpr size_t kMinBufferSize = 32;
  31. MojoMessage() = default;
  32. MojoMessage(std::vector<uint8_t> data, std::vector<IpczHandle> handles) {
  33. SetContents(std::move(data), std::move(handles));
  34. }
  35. ~MojoMessage() {
  36. for (IpczHandle handle : handles_) {
  37. if (handle != IPCZ_INVALID_HANDLE) {
  38. GetIpczAPI().Close(handle, IPCZ_NO_FLAGS, nullptr);
  39. }
  40. }
  41. }
  42. static MojoMessage* FromHandle(MojoMessageHandle handle) {
  43. return reinterpret_cast<MojoMessage*>(handle);
  44. }
  45. static std::unique_ptr<MojoMessage> TakeFromHandle(MojoMessageHandle handle) {
  46. return base::WrapUnique(FromHandle(handle));
  47. }
  48. MojoMessageHandle handle() const {
  49. return reinterpret_cast<MojoMessageHandle>(this);
  50. }
  51. base::span<uint8_t> data() { return data_; }
  52. std::vector<IpczHandle>& handles() { return handles_; }
  53. void SetContents(std::vector<uint8_t> data, std::vector<IpczHandle> handles) {
  54. const size_t size = data.size();
  55. if (size >= kMinBufferSize) {
  56. data_storage_ = std::move(data);
  57. } else {
  58. data_storage_.resize(kMinBufferSize);
  59. std::copy(data.begin(), data.end(), data_storage_.begin());
  60. }
  61. data_ = base::make_span(data_storage_).first(size);
  62. handles_ = std::move(handles);
  63. }
  64. MojoResult AppendData(uint32_t additional_num_bytes,
  65. const MojoHandle* handles,
  66. uint32_t num_handles,
  67. void** buffer,
  68. uint32_t* buffer_size) {
  69. const size_t new_data_size = data_.size() + additional_num_bytes;
  70. const size_t required_storage_size =
  71. std::max(new_data_size, kMinBufferSize);
  72. if (required_storage_size > data_storage_.size()) {
  73. data_storage_.resize(std::max(data_.size() * 2, required_storage_size));
  74. }
  75. data_ = base::make_span(data_storage_).first(new_data_size);
  76. handles_.reserve(handles_.size() + num_handles);
  77. for (MojoHandle handle : base::make_span(handles, num_handles)) {
  78. handles_.push_back(handle);
  79. }
  80. if (buffer) {
  81. *buffer = data_storage_.data();
  82. }
  83. if (buffer_size) {
  84. *buffer_size = base::checked_cast<uint32_t>(data_storage_.size());
  85. }
  86. return MOJO_RESULT_OK;
  87. }
  88. IpczResult GetData(void** buffer,
  89. uint32_t* num_bytes,
  90. MojoHandle* handles,
  91. uint32_t* num_handles,
  92. bool consume_handles) {
  93. if (buffer) {
  94. *buffer = data_storage_.data();
  95. }
  96. if (num_bytes) {
  97. *num_bytes = base::checked_cast<uint32_t>(data_.size());
  98. }
  99. if (!consume_handles || handles_.empty()) {
  100. return MOJO_RESULT_OK;
  101. }
  102. uint32_t capacity = num_handles ? *num_handles : 0;
  103. uint32_t required_capacity = base::checked_cast<uint32_t>(handles_.size());
  104. if (num_handles) {
  105. *num_handles = required_capacity;
  106. }
  107. if (!handles || capacity < required_capacity) {
  108. return MOJO_RESULT_RESOURCE_EXHAUSTED;
  109. }
  110. std::copy(handles_.begin(), handles_.end(), handles);
  111. handles_.clear();
  112. return MOJO_RESULT_OK;
  113. }
  114. private:
  115. std::vector<uint8_t> data_storage_;
  116. base::span<uint8_t> data_;
  117. std::vector<IpczHandle> handles_;
  118. };
  119. // ipcz get and put operations differ slightly in their return code semantics as
  120. // compared to Mojo read and write operations. These helpers perform the
  121. // translation.
  122. MojoResult GetMojoReadResultForIpczGet(IpczResult result) {
  123. if (result == IPCZ_RESULT_UNAVAILABLE) {
  124. // The peer is still open but there are not currently any parcels to read.
  125. return MOJO_RESULT_SHOULD_WAIT;
  126. }
  127. if (result == IPCZ_RESULT_NOT_FOUND) {
  128. // There are no more parcels to read and the peer is closed.
  129. return MOJO_RESULT_FAILED_PRECONDITION;
  130. }
  131. return result;
  132. }
  133. MojoResult GetMojoWriteResultForIpczPut(IpczResult result) {
  134. if (result == IPCZ_RESULT_RESOURCE_EXHAUSTED) {
  135. // For put operations with limits, which are used to emulate data pipe
  136. // producer writes, this indicates that the caller needs to try again later
  137. // due to the pipe being at capacity.
  138. return MOJO_RESULT_SHOULD_WAIT;
  139. }
  140. if (result == IPCZ_RESULT_NOT_FOUND) {
  141. // The peer is closed.
  142. return MOJO_RESULT_FAILED_PRECONDITION;
  143. }
  144. return result;
  145. }
  146. extern "C" {
  147. MojoResult MojoInitializeIpcz(const struct MojoInitializeOptions* options) {
  148. NOTREACHED();
  149. return MOJO_RESULT_OK;
  150. }
  151. MojoTimeTicks MojoGetTimeTicksNowIpcz() {
  152. return base::Time::Now().ToDeltaSinceWindowsEpoch().InMicroseconds();
  153. }
  154. MojoResult MojoCloseIpcz(MojoHandle handle) {
  155. return GetIpczAPI().Close(handle, IPCZ_NO_FLAGS, nullptr);
  156. }
  157. MojoResult MojoQueryHandleSignalsStateIpcz(
  158. MojoHandle handle,
  159. MojoHandleSignalsState* signals_state) {
  160. IpczPortalStatus status = {sizeof(status)};
  161. IpczResult result =
  162. GetIpczAPI().QueryPortalStatus(handle, IPCZ_NO_FLAGS, nullptr, &status);
  163. if (result != IPCZ_RESULT_OK) {
  164. return result;
  165. }
  166. // TODO: These signals aren't quite accurate for data pipe handles.
  167. signals_state->satisfiable_signals = MOJO_HANDLE_SIGNAL_PEER_CLOSED;
  168. signals_state->satisfied_signals = 0;
  169. if (status.flags & IPCZ_PORTAL_STATUS_PEER_CLOSED) {
  170. signals_state->satisfied_signals |= MOJO_HANDLE_SIGNAL_PEER_CLOSED;
  171. } else {
  172. signals_state->satisfiable_signals |= MOJO_HANDLE_SIGNAL_WRITABLE |
  173. MOJO_HANDLE_SIGNAL_QUOTA_EXCEEDED |
  174. MOJO_HANDLE_SIGNAL_PEER_REMOTE;
  175. signals_state->satisfied_signals |= MOJO_HANDLE_SIGNAL_WRITABLE;
  176. }
  177. if ((status.flags & IPCZ_PORTAL_STATUS_DEAD) == 0) {
  178. signals_state->satisfiable_signals |= MOJO_HANDLE_SIGNAL_READABLE;
  179. }
  180. if (status.num_local_parcels > 0) {
  181. signals_state->satisfied_signals |= MOJO_HANDLE_SIGNAL_READABLE;
  182. }
  183. return MOJO_RESULT_OK;
  184. }
  185. MojoResult MojoCreateMessagePipeIpcz(
  186. const MojoCreateMessagePipeOptions* options,
  187. MojoHandle* message_pipe_handle0,
  188. MojoHandle* message_pipe_handle1) {
  189. return GetIpczAPI().OpenPortals(GetIpczNode(), IPCZ_NO_FLAGS, nullptr,
  190. message_pipe_handle0, message_pipe_handle1);
  191. }
  192. MojoResult MojoWriteMessageIpcz(MojoHandle message_pipe_handle,
  193. MojoMessageHandle message,
  194. const MojoWriteMessageOptions* options) {
  195. auto m = MojoMessage::TakeFromHandle(message);
  196. if (!m || !message_pipe_handle) {
  197. return MOJO_RESULT_INVALID_ARGUMENT;
  198. }
  199. IpczResult result = GetIpczAPI().Put(
  200. message_pipe_handle, m->data().data(), m->data().size(),
  201. m->handles().data(), m->handles().size(), IPCZ_NO_FLAGS, nullptr);
  202. if (result == IPCZ_RESULT_NOT_FOUND) {
  203. return MOJO_RESULT_FAILED_PRECONDITION;
  204. }
  205. if (result == IPCZ_RESULT_OK) {
  206. // Ensure the hadles don't get freed on MojoMessage destruction, as their
  207. // ownership was relinquished in Put() above.
  208. m->handles().clear();
  209. }
  210. return GetMojoWriteResultForIpczPut(result);
  211. }
  212. MojoResult MojoReadMessageIpcz(MojoHandle message_pipe_handle,
  213. const MojoReadMessageOptions* options,
  214. MojoMessageHandle* message) {
  215. std::vector<uint8_t> data;
  216. std::vector<MojoHandle> handles;
  217. size_t num_bytes = 0;
  218. size_t num_handles = 0;
  219. IpczResult result =
  220. GetIpczAPI().Get(message_pipe_handle, IPCZ_NO_FLAGS, nullptr, nullptr,
  221. &num_bytes, nullptr, &num_handles);
  222. if (result == IPCZ_RESULT_OK) {
  223. *message = std::make_unique<MojoMessage>().release()->handle();
  224. return MOJO_RESULT_OK;
  225. }
  226. if (result != IPCZ_RESULT_RESOURCE_EXHAUSTED) {
  227. return GetMojoReadResultForIpczGet(result);
  228. }
  229. data.resize(num_bytes);
  230. handles.resize(num_handles);
  231. result =
  232. GetIpczAPI().Get(message_pipe_handle, IPCZ_NO_FLAGS, nullptr, data.data(),
  233. &num_bytes, handles.data(), &num_handles);
  234. if (result != IPCZ_RESULT_OK) {
  235. return GetMojoReadResultForIpczGet(result);
  236. }
  237. auto m = std::make_unique<MojoMessage>();
  238. m->SetContents(std::move(data), std::move(handles));
  239. *message = m.release()->handle();
  240. return MOJO_RESULT_OK;
  241. }
  242. MojoResult MojoFuseMessagePipesIpcz(
  243. MojoHandle handle0,
  244. MojoHandle handle1,
  245. const MojoFuseMessagePipesOptions* options) {
  246. return GetIpczAPI().MergePortals(handle0, handle1, IPCZ_NO_FLAGS, nullptr);
  247. }
  248. MojoResult MojoCreateMessageIpcz(const MojoCreateMessageOptions* options,
  249. MojoMessageHandle* message) {
  250. auto new_message = std::make_unique<MojoMessage>();
  251. *message = new_message.release()->handle();
  252. return MOJO_RESULT_OK;
  253. }
  254. MojoResult MojoDestroyMessageIpcz(MojoMessageHandle message) {
  255. std::unique_ptr<MojoMessage> scoped_message(MojoMessage::FromHandle(message));
  256. return scoped_message ? MOJO_RESULT_OK : MOJO_RESULT_INVALID_ARGUMENT;
  257. }
  258. MojoResult MojoSerializeMessageIpcz(
  259. MojoMessageHandle message,
  260. const MojoSerializeMessageOptions* options) {
  261. return MOJO_RESULT_UNIMPLEMENTED;
  262. }
  263. MojoResult MojoAppendMessageDataIpcz(
  264. MojoMessageHandle message,
  265. uint32_t additional_payload_size,
  266. const MojoHandle* handles,
  267. uint32_t num_handles,
  268. const MojoAppendMessageDataOptions* options,
  269. void** buffer,
  270. uint32_t* buffer_size) {
  271. if (auto* m = MojoMessage::FromHandle(message)) {
  272. return m->AppendData(additional_payload_size, handles, num_handles, buffer,
  273. buffer_size);
  274. }
  275. return MOJO_RESULT_INVALID_ARGUMENT;
  276. }
  277. MojoResult MojoGetMessageDataIpcz(MojoMessageHandle message,
  278. const MojoGetMessageDataOptions* options,
  279. void** buffer,
  280. uint32_t* num_bytes,
  281. MojoHandle* handles,
  282. uint32_t* num_handles) {
  283. if (auto* m = MojoMessage::FromHandle(message)) {
  284. const bool consume_handles =
  285. !options ||
  286. ((options->flags & MOJO_GET_MESSAGE_DATA_FLAG_IGNORE_HANDLES) == 0);
  287. return m->GetData(buffer, num_bytes, handles, num_handles, consume_handles);
  288. }
  289. return MOJO_RESULT_INVALID_ARGUMENT;
  290. }
  291. MojoResult MojoSetMessageContextIpcz(
  292. MojoMessageHandle message,
  293. uintptr_t context,
  294. MojoMessageContextSerializer serializer,
  295. MojoMessageContextDestructor destructor,
  296. const MojoSetMessageContextOptions* options) {
  297. return MOJO_RESULT_UNIMPLEMENTED;
  298. }
  299. MojoResult MojoGetMessageContextIpcz(
  300. MojoMessageHandle message,
  301. const MojoGetMessageContextOptions* options,
  302. uintptr_t* context) {
  303. return MOJO_RESULT_UNIMPLEMENTED;
  304. }
  305. MojoResult MojoNotifyBadMessageIpcz(
  306. MojoMessageHandle message,
  307. const char* error,
  308. uint32_t error_num_bytes,
  309. const MojoNotifyBadMessageOptions* options) {
  310. return MOJO_RESULT_UNIMPLEMENTED;
  311. }
  312. MojoResult MojoCreateDataPipeIpcz(const MojoCreateDataPipeOptions* options,
  313. MojoHandle* data_pipe_producer_handle,
  314. MojoHandle* data_pipe_consumer_handle) {
  315. return MOJO_RESULT_UNIMPLEMENTED;
  316. }
  317. MojoResult MojoWriteDataIpcz(MojoHandle data_pipe_producer_handle,
  318. const void* elements,
  319. uint32_t* num_elements,
  320. const MojoWriteDataOptions* options) {
  321. return MOJO_RESULT_UNIMPLEMENTED;
  322. }
  323. MojoResult MojoBeginWriteDataIpcz(MojoHandle data_pipe_producer_handle,
  324. const MojoBeginWriteDataOptions* options,
  325. void** buffer,
  326. uint32_t* buffer_num_elements) {
  327. return MOJO_RESULT_UNIMPLEMENTED;
  328. }
  329. MojoResult MojoEndWriteDataIpcz(MojoHandle data_pipe_producer_handle,
  330. uint32_t num_elements_written,
  331. const MojoEndWriteDataOptions* options) {
  332. return MOJO_RESULT_UNIMPLEMENTED;
  333. }
  334. MojoResult MojoReadDataIpcz(MojoHandle data_pipe_consumer_handle,
  335. const MojoReadDataOptions* options,
  336. void* elements,
  337. uint32_t* num_elements) {
  338. return MOJO_RESULT_UNIMPLEMENTED;
  339. }
  340. MojoResult MojoBeginReadDataIpcz(MojoHandle data_pipe_consumer_handle,
  341. const MojoBeginReadDataOptions* options,
  342. const void** buffer,
  343. uint32_t* buffer_num_elements) {
  344. return MOJO_RESULT_UNIMPLEMENTED;
  345. }
  346. MojoResult MojoEndReadDataIpcz(MojoHandle data_pipe_consumer_handle,
  347. uint32_t num_elements_read,
  348. const MojoEndReadDataOptions* options) {
  349. return MOJO_RESULT_UNIMPLEMENTED;
  350. }
  351. MojoResult MojoCreateSharedBufferIpcz(
  352. uint64_t num_bytes,
  353. const MojoCreateSharedBufferOptions* options,
  354. MojoHandle* shared_buffer_handle) {
  355. return MOJO_RESULT_UNIMPLEMENTED;
  356. }
  357. MojoResult MojoDuplicateBufferHandleIpcz(
  358. MojoHandle buffer_handle,
  359. const MojoDuplicateBufferHandleOptions* options,
  360. MojoHandle* new_buffer_handle) {
  361. return MOJO_RESULT_UNIMPLEMENTED;
  362. }
  363. MojoResult MojoMapBufferIpcz(MojoHandle buffer_handle,
  364. uint64_t offset,
  365. uint64_t num_bytes,
  366. const MojoMapBufferOptions* options,
  367. void** address) {
  368. return MOJO_RESULT_UNIMPLEMENTED;
  369. }
  370. MojoResult MojoUnmapBufferIpcz(void* address) {
  371. return MOJO_RESULT_UNIMPLEMENTED;
  372. }
  373. MojoResult MojoGetBufferInfoIpcz(MojoHandle buffer_handle,
  374. const MojoGetBufferInfoOptions* options,
  375. MojoSharedBufferInfo* info) {
  376. return MOJO_RESULT_UNIMPLEMENTED;
  377. }
  378. MojoResult MojoCreateTrapIpcz(MojoTrapEventHandler handler,
  379. const MojoCreateTrapOptions* options,
  380. MojoHandle* trap_handle) {
  381. if (!handler || !trap_handle) {
  382. return MOJO_RESULT_INVALID_ARGUMENT;
  383. }
  384. *trap_handle = ipcz_driver::MojoTrap::MakeBoxed(handler);
  385. return MOJO_RESULT_OK;
  386. }
  387. MojoResult MojoAddTriggerIpcz(MojoHandle trap_handle,
  388. MojoHandle handle,
  389. MojoHandleSignals signals,
  390. MojoTriggerCondition condition,
  391. uintptr_t context,
  392. const MojoAddTriggerOptions* options) {
  393. auto* trap = ipcz_driver::MojoTrap::FromBox(trap_handle);
  394. if (!trap) {
  395. return MOJO_RESULT_INVALID_ARGUMENT;
  396. }
  397. return trap->AddTrigger(handle, signals, condition, context);
  398. }
  399. MojoResult MojoRemoveTriggerIpcz(MojoHandle trap_handle,
  400. uintptr_t context,
  401. const MojoRemoveTriggerOptions* options) {
  402. auto* trap = ipcz_driver::MojoTrap::FromBox(trap_handle);
  403. if (!trap) {
  404. return MOJO_RESULT_INVALID_ARGUMENT;
  405. }
  406. return trap->RemoveTrigger(context);
  407. }
  408. MojoResult MojoArmTrapIpcz(MojoHandle trap_handle,
  409. const MojoArmTrapOptions* options,
  410. uint32_t* num_blocking_events,
  411. MojoTrapEvent* blocking_events) {
  412. auto* trap = ipcz_driver::MojoTrap::FromBox(trap_handle);
  413. if (!trap) {
  414. return MOJO_RESULT_INVALID_ARGUMENT;
  415. }
  416. return trap->Arm(blocking_events, num_blocking_events);
  417. }
  418. MojoResult MojoWrapPlatformHandleIpcz(
  419. const MojoPlatformHandle* platform_handle,
  420. const MojoWrapPlatformHandleOptions* options,
  421. MojoHandle* mojo_handle) {
  422. if (!platform_handle || !mojo_handle) {
  423. return MOJO_RESULT_INVALID_ARGUMENT;
  424. }
  425. auto handle = PlatformHandle::FromMojoPlatformHandle(platform_handle);
  426. *mojo_handle =
  427. ipcz_driver::WrappedPlatformHandle::MakeBoxed(std::move(handle));
  428. return MOJO_RESULT_OK;
  429. }
  430. MojoResult MojoUnwrapPlatformHandleIpcz(
  431. MojoHandle mojo_handle,
  432. const MojoUnwrapPlatformHandleOptions* options,
  433. MojoPlatformHandle* platform_handle) {
  434. if (!mojo_handle || !platform_handle ||
  435. platform_handle->struct_size < sizeof(*platform_handle)) {
  436. return MOJO_RESULT_INVALID_ARGUMENT;
  437. }
  438. auto wrapper = ipcz_driver::WrappedPlatformHandle::Unbox(mojo_handle);
  439. if (!wrapper) {
  440. return MOJO_RESULT_INVALID_ARGUMENT;
  441. }
  442. PlatformHandle::ToMojoPlatformHandle(std::move(wrapper->handle()),
  443. platform_handle);
  444. return MOJO_RESULT_OK;
  445. }
  446. MojoResult MojoWrapPlatformSharedMemoryRegionIpcz(
  447. const MojoPlatformHandle* platform_handles,
  448. uint32_t num_platform_handles,
  449. uint64_t num_bytes,
  450. const MojoSharedBufferGuid* guid,
  451. MojoPlatformSharedMemoryRegionAccessMode access_mode,
  452. const MojoWrapPlatformSharedMemoryRegionOptions* options,
  453. MojoHandle* mojo_handle) {
  454. return MOJO_RESULT_UNIMPLEMENTED;
  455. }
  456. MojoResult MojoUnwrapPlatformSharedMemoryRegionIpcz(
  457. MojoHandle mojo_handle,
  458. const MojoUnwrapPlatformSharedMemoryRegionOptions* options,
  459. MojoPlatformHandle* platform_handles,
  460. uint32_t* num_platform_handles,
  461. uint64_t* num_bytes,
  462. MojoSharedBufferGuid* mojo_guid,
  463. MojoPlatformSharedMemoryRegionAccessMode* access_mode) {
  464. return MOJO_RESULT_UNIMPLEMENTED;
  465. }
  466. MojoResult MojoCreateInvitationIpcz(const MojoCreateInvitationOptions* options,
  467. MojoHandle* invitation_handle) {
  468. return MOJO_RESULT_UNIMPLEMENTED;
  469. }
  470. MojoResult MojoAttachMessagePipeToInvitationIpcz(
  471. MojoHandle invitation_handle,
  472. const void* name,
  473. uint32_t name_num_bytes,
  474. const MojoAttachMessagePipeToInvitationOptions* options,
  475. MojoHandle* message_pipe_handle) {
  476. return MOJO_RESULT_UNIMPLEMENTED;
  477. }
  478. MojoResult MojoExtractMessagePipeFromInvitationIpcz(
  479. MojoHandle invitation_handle,
  480. const void* name,
  481. uint32_t name_num_bytes,
  482. const MojoExtractMessagePipeFromInvitationOptions* options,
  483. MojoHandle* message_pipe_handle) {
  484. return MOJO_RESULT_UNIMPLEMENTED;
  485. }
  486. MojoResult MojoSendInvitationIpcz(
  487. MojoHandle invitation_handle,
  488. const MojoPlatformProcessHandle* process_handle,
  489. const MojoInvitationTransportEndpoint* transport_endpoint,
  490. MojoProcessErrorHandler error_handler,
  491. uintptr_t error_handler_context,
  492. const MojoSendInvitationOptions* options) {
  493. return MOJO_RESULT_UNIMPLEMENTED;
  494. }
  495. MojoResult MojoAcceptInvitationIpcz(
  496. const MojoInvitationTransportEndpoint* transport_endpoint,
  497. const MojoAcceptInvitationOptions* options,
  498. MojoHandle* invitation_handle) {
  499. return MOJO_RESULT_UNIMPLEMENTED;
  500. }
  501. MojoResult MojoSetQuotaIpcz(MojoHandle handle,
  502. MojoQuotaType type,
  503. uint64_t limit,
  504. const MojoSetQuotaOptions* options) {
  505. return MOJO_RESULT_UNIMPLEMENTED;
  506. }
  507. MojoResult MojoQueryQuotaIpcz(MojoHandle handle,
  508. MojoQuotaType type,
  509. const MojoQueryQuotaOptions* options,
  510. uint64_t* current_limit,
  511. uint64_t* current_usage) {
  512. return MOJO_RESULT_UNIMPLEMENTED;
  513. }
  514. MojoResult MojoShutdownIpcz(const MojoShutdownOptions* options) {
  515. NOTREACHED();
  516. return MOJO_RESULT_OK;
  517. }
  518. MojoResult MojoSetDefaultProcessErrorHandlerIpcz(
  519. MojoDefaultProcessErrorHandler handler,
  520. const MojoSetDefaultProcessErrorHandlerOptions* options) {
  521. return MOJO_RESULT_UNIMPLEMENTED;
  522. }
  523. } // extern "C"
  524. MojoSystemThunks2 g_mojo_ipcz_thunks = {
  525. sizeof(MojoSystemThunks2),
  526. MojoInitializeIpcz,
  527. MojoGetTimeTicksNowIpcz,
  528. MojoCloseIpcz,
  529. MojoQueryHandleSignalsStateIpcz,
  530. MojoCreateMessagePipeIpcz,
  531. MojoWriteMessageIpcz,
  532. MojoReadMessageIpcz,
  533. MojoFuseMessagePipesIpcz,
  534. MojoCreateMessageIpcz,
  535. MojoDestroyMessageIpcz,
  536. MojoSerializeMessageIpcz,
  537. MojoAppendMessageDataIpcz,
  538. MojoGetMessageDataIpcz,
  539. MojoSetMessageContextIpcz,
  540. MojoGetMessageContextIpcz,
  541. MojoNotifyBadMessageIpcz,
  542. MojoCreateDataPipeIpcz,
  543. MojoWriteDataIpcz,
  544. MojoBeginWriteDataIpcz,
  545. MojoEndWriteDataIpcz,
  546. MojoReadDataIpcz,
  547. MojoBeginReadDataIpcz,
  548. MojoEndReadDataIpcz,
  549. MojoCreateSharedBufferIpcz,
  550. MojoDuplicateBufferHandleIpcz,
  551. MojoMapBufferIpcz,
  552. MojoUnmapBufferIpcz,
  553. MojoGetBufferInfoIpcz,
  554. MojoCreateTrapIpcz,
  555. MojoAddTriggerIpcz,
  556. MojoRemoveTriggerIpcz,
  557. MojoArmTrapIpcz,
  558. MojoWrapPlatformHandleIpcz,
  559. MojoUnwrapPlatformHandleIpcz,
  560. MojoWrapPlatformSharedMemoryRegionIpcz,
  561. MojoUnwrapPlatformSharedMemoryRegionIpcz,
  562. MojoCreateInvitationIpcz,
  563. MojoAttachMessagePipeToInvitationIpcz,
  564. MojoExtractMessagePipeFromInvitationIpcz,
  565. MojoSendInvitationIpcz,
  566. MojoAcceptInvitationIpcz,
  567. MojoSetQuotaIpcz,
  568. MojoQueryQuotaIpcz,
  569. MojoShutdownIpcz,
  570. MojoSetDefaultProcessErrorHandlerIpcz};
  571. } // namespace
  572. const MojoSystemThunks2* GetMojoIpczImpl() {
  573. return &g_mojo_ipcz_thunks;
  574. }
  575. } // namespace mojo::core