Google Git
Sign in
chromium / chromium / src / lkgr / . / mojo / core / ports / event.cc
blob: c1b16ca3b5b3cca034f96ab918199609b9174e6a [file] [log] [blame]
Avi Drissmand387f0922022-09-14 20:51:31[diff] [blame]1// Copyright 2016 The Chromium Authors
rockot26ffc142016-02-10 05:53:07[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Arthur Sonzognid4ee5452024-07-18 21:51:54[diff] [blame]5#ifdef UNSAFE_BUFFERS_BUILD
6// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
7#pragma allow_unsafe_buffers
8#endif
9
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]10#include "mojo/core/ports/event.h"
rockot26ffc142016-02-10 05:53:07[diff] [blame]11
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]12#include <stdint.h>
rockot26ffc142016-02-10 05:53:07[diff] [blame]13#include <string.h>
14
Peter Kasting8832e5642022-10-28 06:23:12[diff] [blame]15#include <algorithm>
16
Hans Wennborg7c2ea37d2020-04-21 20:22:33[diff] [blame]17#include "base/logging.h"
David Sanders27d32052022-04-04 18:08:19[diff] [blame]18#include "base/memory/ptr_util.h"
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]19#include "base/numerics/safe_math.h"
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]20#include "mojo/core/ports/user_message.h"
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]21
rockot26ffc142016-02-10 05:53:07[diff] [blame]22namespace mojo {
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]23namespace core {
rockot26ffc142016-02-10 05:53:07[diff] [blame]24namespace ports {
25
26namespace {
27
28const size_t kPortsMessageAlignment = 8;
29
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]30#pragma pack(push, 1)
31
32struct SerializedHeader {
33 Event::Type type;
34 uint32_t padding;
35 PortName port_name;
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]36#ifndef MOJO_BACKWARDS_COMPAT
37 PortName from_port;
38 uint64_t control_sequence_num;
39#endif
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]40};
41
42struct UserMessageEventData {
43 uint64_t sequence_num;
44 uint32_t num_ports;
Ken Rockot3e0b3d022019-04-17 17:51:03[diff] [blame]45 uint32_t padding;
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]46};
47
48struct ObserveProxyEventData {
49 NodeName proxy_node_name;
50 PortName proxy_port_name;
51 NodeName proxy_target_node_name;
52 PortName proxy_target_port_name;
53};
54
55struct ObserveProxyAckEventData {
56 uint64_t last_sequence_num;
57};
58
59struct ObserveClosureEventData {
60 uint64_t last_sequence_num;
61};
62
63struct MergePortEventData {
64 PortName new_port_name;
65 Event::PortDescriptor new_port_descriptor;
66};
67
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]68struct UserMessageReadAckRequestEventData {
69 uint64_t sequence_num_to_acknowledge;
70};
71
72struct UserMessageReadAckEventData {
73 uint64_t sequence_num_acknowledged;
74};
75
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]76struct UpdatePreviousPeerEventData {
77 NodeName new_node_name;
78 PortName new_port_name;
79};
80
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]81#pragma pack(pop)
82
83static_assert(sizeof(Event::PortDescriptor) % kPortsMessageAlignment == 0,
rockot26ffc142016-02-10 05:53:07[diff] [blame]84 "Invalid PortDescriptor size.");
85
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]86static_assert(sizeof(SerializedHeader) % kPortsMessageAlignment == 0,
87 "Invalid SerializedHeader size.");
rockot26ffc142016-02-10 05:53:07[diff] [blame]88
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]89static_assert(sizeof(UserMessageEventData) % kPortsMessageAlignment == 0,
rockot26ffc142016-02-10 05:53:07[diff] [blame]90 "Invalid UserEventData size.");
91
92static_assert(sizeof(ObserveProxyEventData) % kPortsMessageAlignment == 0,
93 "Invalid ObserveProxyEventData size.");
94
95static_assert(sizeof(ObserveProxyAckEventData) % kPortsMessageAlignment == 0,
96 "Invalid ObserveProxyAckEventData size.");
97
98static_assert(sizeof(ObserveClosureEventData) % kPortsMessageAlignment == 0,
99 "Invalid ObserveClosureEventData size.");
100
101static_assert(sizeof(MergePortEventData) % kPortsMessageAlignment == 0,
102 "Invalid MergePortEventData size.");
103
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]104static_assert(sizeof(UserMessageReadAckRequestEventData) %
105 kPortsMessageAlignment ==
106 0,
107 "Invalid UserMessageReadAckRequestEventData size.");
108
109static_assert(sizeof(UserMessageReadAckEventData) % kPortsMessageAlignment == 0,
110 "Invalid UserMessageReadAckEventData size.");
111
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]112static_assert(sizeof(UpdatePreviousPeerEventData) % kPortsMessageAlignment == 0,
113 "Invalid UpdatePreviousPeerEventData size.");
114
rockot26ffc142016-02-10 05:53:07[diff] [blame]115} // namespace
116
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]117Event::PortDescriptor::PortDescriptor() {
rockot26ffc142016-02-10 05:53:07[diff] [blame]118 memset(padding, 0, sizeof(padding));
119}
120
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]121Event::~Event() = default;
122
123// static
124ScopedEvent Event::Deserialize(const void* buffer, size_t num_bytes) {
125 if (num_bytes < sizeof(SerializedHeader))
126 return nullptr;
127
128 const auto* header = static_cast<const SerializedHeader*>(buffer);
129 const PortName& port_name = header->port_name;
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]130#ifndef MOJO_BACKWARDS_COMPAT
131 const PortName& from_port = header->from_port;
132 const uint64_t control_sequence_num = header->control_sequence_num;
133#else
134 const PortName& from_port = kInvalidPortName;
135 const uint64_t control_sequence_num = std::numeric_limits<uint64_t>::max();
136#endif
Ken Rockot5f3e8cf2017-12-18 21:08:02[diff] [blame]137 const size_t data_size = num_bytes - sizeof(*header);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]138 switch (header->type) {
139 case Type::kUserMessage:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]140 return UserMessageEvent::Deserialize(
141 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]142 case Type::kPortAccepted:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]143 return PortAcceptedEvent::Deserialize(
144 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]145 case Type::kObserveProxy:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]146 return ObserveProxyEvent::Deserialize(
147 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]148 case Type::kObserveProxyAck:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]149 return ObserveProxyAckEvent::Deserialize(
150 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]151 case Type::kObserveClosure:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]152 return ObserveClosureEvent::Deserialize(
153 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]154 case Type::kMergePort:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]155 return MergePortEvent::Deserialize(
156 port_name, from_port, control_sequence_num, header + 1, data_size);
Sigurdur Asgeirsson86c1eb32020-01-28 22:51:56[diff] [blame]157 case Type::kUserMessageReadAckRequest:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]158 return UserMessageReadAckRequestEvent::Deserialize(
159 port_name, from_port, control_sequence_num, header + 1, data_size);
Sigurdur Asgeirsson86c1eb32020-01-28 22:51:56[diff] [blame]160 case Type::kUserMessageReadAck:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]161 return UserMessageReadAckEvent::Deserialize(
162 port_name, from_port, control_sequence_num, header + 1, data_size);
163 case Type::kUpdatePreviousPeer:
164 return UpdatePreviousPeerEvent::Deserialize(
165 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]166 default:
167 DVLOG(2) << "Ingoring unknown port event type: "
168 << static_cast<uint32_t>(header->type);
169 return nullptr;
170 }
171}
172
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]173Event::Event(Type type,
174 const PortName& port_name,
175 const PortName& from_port,
176 uint64_t control_sequence_num)
177 : type_(type),
178 port_name_(port_name),
179 from_port_(from_port),
180 control_sequence_num_(control_sequence_num) {}
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]181
182size_t Event::GetSerializedSize() const {
183 return sizeof(SerializedHeader) + GetSerializedDataSize();
184}
185
186void Event::Serialize(void* buffer) const {
187 auto* header = static_cast<SerializedHeader*>(buffer);
188 header->type = type_;
189 header->padding = 0;
190 header->port_name = port_name_;
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]191#ifndef MOJO_BACKWARDS_COMPAT
192 header->from_port = from_port_;
193 header->control_sequence_num = control_sequence_num_;
194#endif
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]195 SerializeData(header + 1);
196}
197
Stephen Roettger4b6f8c5c2021-12-20 18:46:48[diff] [blame]198ScopedEvent Event::CloneForBroadcast() const {
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]199 return nullptr;
200}
201
202UserMessageEvent::~UserMessageEvent() = default;
203
204UserMessageEvent::UserMessageEvent(size_t num_ports)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]205 : Event(Type::kUserMessage, kInvalidPortName, kInvalidPortName, -1) {
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]206 ReservePorts(num_ports);
207}
208
209void UserMessageEvent::AttachMessage(std::unique_ptr<UserMessage> message) {
210 DCHECK(!message_);
211 message_ = std::move(message);
212}
213
214void UserMessageEvent::ReservePorts(size_t num_ports) {
215 port_descriptors_.resize(num_ports);
216 ports_.resize(num_ports);
217}
218
Ken Rockot15b2b0b2017-06-12 20:36:05[diff] [blame]219bool UserMessageEvent::NotifyWillBeRoutedExternally() {
220 DCHECK(message_);
Ken Rockotfdf158da2017-06-12 20:45:29[diff] [blame]221 return message_->WillBeRoutedExternally();
Ken Rockot15b2b0b2017-06-12 20:36:05[diff] [blame]222}
223
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]224// static
225ScopedEvent UserMessageEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]226 const PortName& from_port,
227 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]228 const void* buffer,
229 size_t num_bytes) {
230 if (num_bytes < sizeof(UserMessageEventData))
231 return nullptr;
232
233 const auto* data = static_cast<const UserMessageEventData*>(buffer);
234 base::CheckedNumeric<size_t> port_data_size = data->num_ports;
235 port_data_size *= sizeof(PortDescriptor) + sizeof(PortName);
236 if (!port_data_size.IsValid())
237 return nullptr;
238
239 base::CheckedNumeric<size_t> total_size = port_data_size.ValueOrDie();
240 total_size += sizeof(UserMessageEventData);
241 if (!total_size.IsValid() || num_bytes < total_size.ValueOrDie())
242 return nullptr;
243
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]244 auto event = base::WrapUnique(new UserMessageEvent(
245 port_name, from_port, control_sequence_num, data->sequence_num));
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]246 event->ReservePorts(data->num_ports);
247 const auto* in_descriptors =
248 reinterpret_cast<const PortDescriptor*>(data + 1);
249 std::copy(in_descriptors, in_descriptors + data->num_ports,
250 event->port_descriptors());
251
252 const auto* in_names =
253 reinterpret_cast<const PortName*>(in_descriptors + data->num_ports);
Ken Rockot863f3482019-04-17 17:47:50[diff] [blame]254 std::copy(in_names, in_names + data->num_ports, event->ports());
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]255 return std::move(event);
256}
257
258UserMessageEvent::UserMessageEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]259 const PortName& from_port,
260 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]261 uint64_t sequence_num)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]262 : Event(Type::kUserMessage, port_name, from_port, control_sequence_num),
263 sequence_num_(sequence_num) {}
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]264
Ken Rockot0db0bcf2018-07-12 22:01:12[diff] [blame]265size_t UserMessageEvent::GetSizeIfSerialized() const {
266 if (!message_)
267 return 0;
268 return message_->GetSizeIfSerialized();
269}
270
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]271size_t UserMessageEvent::GetSerializedDataSize() const {
272 DCHECK_EQ(ports_.size(), port_descriptors_.size());
273 base::CheckedNumeric<size_t> size = sizeof(UserMessageEventData);
274 base::CheckedNumeric<size_t> ports_size =
275 sizeof(PortDescriptor) + sizeof(PortName);
276 ports_size *= ports_.size();
277 return (size + ports_size.ValueOrDie()).ValueOrDie();
278}
279
280void UserMessageEvent::SerializeData(void* buffer) const {
281 DCHECK_EQ(ports_.size(), port_descriptors_.size());
282 auto* data = static_cast<UserMessageEventData*>(buffer);
283 data->sequence_num = sequence_num_;
284 DCHECK(base::IsValueInRangeForNumericType<uint32_t>(ports_.size()));
285 data->num_ports = static_cast<uint32_t>(ports_.size());
Ken Rockot3e0b3d022019-04-17 17:51:03[diff] [blame]286 data->padding = 0;
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]287
288 auto* ports_data = reinterpret_cast<PortDescriptor*>(data + 1);
Peter Kasting1ed31f52025-01-27 22:15:35[diff] [blame]289 std::ranges::copy(port_descriptors_, ports_data);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]290
291 auto* port_names_data =
292 reinterpret_cast<PortName*>(ports_data + ports_.size());
Peter Kasting1ed31f52025-01-27 22:15:35[diff] [blame]293 std::ranges::copy(ports_, port_names_data);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]294}
295
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]296PortAcceptedEvent::PortAcceptedEvent(const PortName& port_name,
297 const PortName& from_port,
298 uint64_t control_sequence_num)
299 : Event(Type::kPortAccepted, port_name, from_port, control_sequence_num) {}
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]300
301PortAcceptedEvent::~PortAcceptedEvent() = default;
302
303// static
304ScopedEvent PortAcceptedEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]305 const PortName& from_port,
306 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]307 const void* buffer,
308 size_t num_bytes) {
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]309 return std::make_unique<PortAcceptedEvent>(port_name, from_port,
310 control_sequence_num);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]311}
312
313size_t PortAcceptedEvent::GetSerializedDataSize() const {
314 return 0;
315}
316
317void PortAcceptedEvent::SerializeData(void* buffer) const {}
318
319ObserveProxyEvent::ObserveProxyEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]320 const PortName& from_port,
321 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]322 const NodeName& proxy_node_name,
323 const PortName& proxy_port_name,
324 const NodeName& proxy_target_node_name,
325 const PortName& proxy_target_port_name)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]326 : Event(Type::kObserveProxy, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]327 proxy_node_name_(proxy_node_name),
328 proxy_port_name_(proxy_port_name),
329 proxy_target_node_name_(proxy_target_node_name),
330 proxy_target_port_name_(proxy_target_port_name) {}
331
332ObserveProxyEvent::~ObserveProxyEvent() = default;
333
334// static
335ScopedEvent ObserveProxyEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]336 const PortName& from_port,
337 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]338 const void* buffer,
339 size_t num_bytes) {
340 if (num_bytes < sizeof(ObserveProxyEventData))
341 return nullptr;
342
343 const auto* data = static_cast<const ObserveProxyEventData*>(buffer);
Jeremy Romancf9ae2f2017-08-24 17:06:37[diff] [blame]344 return std::make_unique<ObserveProxyEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]345 port_name, from_port, control_sequence_num, data->proxy_node_name,
346 data->proxy_port_name, data->proxy_target_node_name,
347 data->proxy_target_port_name);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]348}
349
350size_t ObserveProxyEvent::GetSerializedDataSize() const {
351 return sizeof(ObserveProxyEventData);
352}
353
354void ObserveProxyEvent::SerializeData(void* buffer) const {
355 auto* data = static_cast<ObserveProxyEventData*>(buffer);
356 data->proxy_node_name = proxy_node_name_;
357 data->proxy_port_name = proxy_port_name_;
358 data->proxy_target_node_name = proxy_target_node_name_;
359 data->proxy_target_port_name = proxy_target_port_name_;
360}
361
Stephen Roettger4b6f8c5c2021-12-20 18:46:48[diff] [blame]362ScopedEvent ObserveProxyEvent::CloneForBroadcast() const {
363 // Don't broadcast events targeted at specific ports. Otherwise a malicioius
364 // node can use this to bypass sender verification.
365 if (port_name() != kInvalidPortName) {
366 return nullptr;
367 }
Jeremy Romancf9ae2f2017-08-24 17:06:37[diff] [blame]368 return std::make_unique<ObserveProxyEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]369 port_name(), from_port(), control_sequence_num(), proxy_node_name_,
370 proxy_port_name_, proxy_target_node_name_, proxy_target_port_name_);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]371}
372
373ObserveProxyAckEvent::ObserveProxyAckEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]374 const PortName& from_port,
375 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]376 uint64_t last_sequence_num)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]377 : Event(Type::kObserveProxyAck, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]378 last_sequence_num_(last_sequence_num) {}
379
380ObserveProxyAckEvent::~ObserveProxyAckEvent() = default;
381
382// static
383ScopedEvent ObserveProxyAckEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]384 const PortName& from_port,
385 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]386 const void* buffer,
387 size_t num_bytes) {
388 if (num_bytes < sizeof(ObserveProxyAckEventData))
389 return nullptr;
390
391 const auto* data = static_cast<const ObserveProxyAckEventData*>(buffer);
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]392 return std::make_unique<ObserveProxyAckEvent>(
393 port_name, from_port, control_sequence_num, data->last_sequence_num);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]394}
395
396size_t ObserveProxyAckEvent::GetSerializedDataSize() const {
397 return sizeof(ObserveProxyAckEventData);
398}
399
400void ObserveProxyAckEvent::SerializeData(void* buffer) const {
401 auto* data = static_cast<ObserveProxyAckEventData*>(buffer);
402 data->last_sequence_num = last_sequence_num_;
403}
404
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]405ObserveClosureEvent::ObserveClosureEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]406 const PortName& from_port,
407 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]408 uint64_t last_sequence_num)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]409 : Event(Type::kObserveClosure, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]410 last_sequence_num_(last_sequence_num) {}
411
412ObserveClosureEvent::~ObserveClosureEvent() = default;
413
414// static
415ScopedEvent ObserveClosureEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]416 const PortName& from_port,
417 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]418 const void* buffer,
419 size_t num_bytes) {
420 if (num_bytes < sizeof(ObserveClosureEventData))
421 return nullptr;
422
423 const auto* data = static_cast<const ObserveClosureEventData*>(buffer);
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]424 return std::make_unique<ObserveClosureEvent>(
425 port_name, from_port, control_sequence_num, data->last_sequence_num);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]426}
427
428size_t ObserveClosureEvent::GetSerializedDataSize() const {
429 return sizeof(ObserveClosureEventData);
430}
431
432void ObserveClosureEvent::SerializeData(void* buffer) const {
433 auto* data = static_cast<ObserveClosureEventData*>(buffer);
434 data->last_sequence_num = last_sequence_num_;
435}
436
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]437MergePortEvent::MergePortEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]438 const PortName& from_port,
439 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]440 const PortName& new_port_name,
441 const PortDescriptor& new_port_descriptor)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]442 : Event(Type::kMergePort, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]443 new_port_name_(new_port_name),
444 new_port_descriptor_(new_port_descriptor) {}
445
446MergePortEvent::~MergePortEvent() = default;
447
448// static
449ScopedEvent MergePortEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]450 const PortName& from_port,
451 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]452 const void* buffer,
453 size_t num_bytes) {
454 if (num_bytes < sizeof(MergePortEventData))
455 return nullptr;
456
457 const auto* data = static_cast<const MergePortEventData*>(buffer);
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]458 return std::make_unique<MergePortEvent>(
459 port_name, from_port, control_sequence_num, data->new_port_name,
460 data->new_port_descriptor);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]461}
462
463size_t MergePortEvent::GetSerializedDataSize() const {
464 return sizeof(MergePortEventData);
465}
466
467void MergePortEvent::SerializeData(void* buffer) const {
468 auto* data = static_cast<MergePortEventData*>(buffer);
469 data->new_port_name = new_port_name_;
470 data->new_port_descriptor = new_port_descriptor_;
471}
472
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]473UserMessageReadAckRequestEvent::UserMessageReadAckRequestEvent(
474 const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]475 const PortName& from_port,
476 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]477 uint64_t sequence_num_to_acknowledge)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]478 : Event(Type::kUserMessageReadAckRequest,
479 port_name,
480 from_port,
481 control_sequence_num),
482 sequence_num_to_acknowledge_(sequence_num_to_acknowledge) {}
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]483
484UserMessageReadAckRequestEvent::~UserMessageReadAckRequestEvent() = default;
485
486// static
487ScopedEvent UserMessageReadAckRequestEvent::Deserialize(
488 const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]489 const PortName& from_port,
490 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]491 const void* buffer,
492 size_t num_bytes) {
493 if (num_bytes < sizeof(UserMessageReadAckRequestEventData))
494 return nullptr;
495
496 const auto* data =
497 static_cast<const UserMessageReadAckRequestEventData*>(buffer);
498 return std::make_unique<UserMessageReadAckRequestEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]499 port_name, from_port, control_sequence_num,
500 data->sequence_num_to_acknowledge);
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]501}
502
503size_t UserMessageReadAckRequestEvent::GetSerializedDataSize() const {
504 return sizeof(UserMessageReadAckRequestEventData);
505}
506
507void UserMessageReadAckRequestEvent::SerializeData(void* buffer) const {
508 auto* data = static_cast<UserMessageReadAckRequestEventData*>(buffer);
509 data->sequence_num_to_acknowledge = sequence_num_to_acknowledge_;
510}
511
512UserMessageReadAckEvent::UserMessageReadAckEvent(
513 const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]514 const PortName& from_port,
515 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]516 uint64_t sequence_num_acknowledged)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]517 : Event(Type::kUserMessageReadAck,
518 port_name,
519 from_port,
520 control_sequence_num),
521 sequence_num_acknowledged_(sequence_num_acknowledged) {}
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]522
523UserMessageReadAckEvent::~UserMessageReadAckEvent() = default;
524
525// static
526ScopedEvent UserMessageReadAckEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]527 const PortName& from_port,
528 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]529 const void* buffer,
530 size_t num_bytes) {
531 if (num_bytes < sizeof(UserMessageReadAckEventData))
532 return nullptr;
533
534 const auto* data = static_cast<const UserMessageReadAckEventData*>(buffer);
535 return std::make_unique<UserMessageReadAckEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]536 port_name, from_port, control_sequence_num,
537 data->sequence_num_acknowledged);
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]538}
539
540size_t UserMessageReadAckEvent::GetSerializedDataSize() const {
541 return sizeof(UserMessageReadAckEventData);
542}
543
544void UserMessageReadAckEvent::SerializeData(void* buffer) const {
545 auto* data = static_cast<UserMessageReadAckEventData*>(buffer);
546 data->sequence_num_acknowledged = sequence_num_acknowledged_;
547}
548
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]549UpdatePreviousPeerEvent::UpdatePreviousPeerEvent(const PortName& port_name,
550 const PortName& from_port,
551 uint64_t control_sequence_num,
552 const NodeName& new_node_name,
553 const PortName& new_port_name)
554 : Event(Type::kUpdatePreviousPeer,
555 port_name,
556 from_port,
557 control_sequence_num),
558 new_node_name_(new_node_name),
559 new_port_name_(new_port_name) {}
560
561UpdatePreviousPeerEvent::~UpdatePreviousPeerEvent() = default;
562
563// static
564ScopedEvent UpdatePreviousPeerEvent::Deserialize(const PortName& port_name,
565 const PortName& from_port,
566 uint64_t control_sequence_num,
567 const void* buffer,
568 size_t num_bytes) {
569 if (num_bytes < sizeof(UpdatePreviousPeerEventData))
570 return nullptr;
571
572 const auto* data = static_cast<const UpdatePreviousPeerEventData*>(buffer);
573 return std::make_unique<UpdatePreviousPeerEvent>(
574 port_name, from_port, control_sequence_num, data->new_node_name,
575 data->new_port_name);
576}
577
578size_t UpdatePreviousPeerEvent::GetSerializedDataSize() const {
579 return sizeof(UpdatePreviousPeerEventData);
580}
581
582void UpdatePreviousPeerEvent::SerializeData(void* buffer) const {
583 auto* data = static_cast<UpdatePreviousPeerEventData*>(buffer);
584 data->new_node_name = new_node_name_;
585 data->new_port_name = new_port_name_;
586}
587
rockot26ffc142016-02-10 05:53:07[diff] [blame]588} // namespace ports
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]589} // namespace core
rockot26ffc142016-02-10 05:53:07[diff] [blame]590} // namespace mojo