1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// 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 "mojo/edk/system/broker.h"
#include <fcntl.h>
#include <unistd.h>
#include <utility>
#include "base/logging.h"
#include "mojo/edk/embedder/embedder_internal.h"
#include "mojo/edk/embedder/platform_channel_utils_posix.h"
#include "mojo/edk/embedder/platform_handle_utils.h"
#include "mojo/edk/embedder/platform_handle_vector.h"
#include "mojo/edk/embedder/platform_shared_buffer.h"
#include "mojo/edk/system/broker_messages.h"
#include "mojo/edk/system/channel.h"
namespace mojo {
namespace edk {
namespace {
bool WaitForBrokerMessage(PlatformHandle platform_handle,
BrokerMessageType expected_type,
size_t expected_num_handles,
std::deque<PlatformHandle>* incoming_handles) {
Channel::MessagePtr message(
new Channel::Message(sizeof(BrokerMessageHeader), expected_num_handles));
std::deque<PlatformHandle> incoming_platform_handles;
ssize_t read_result = PlatformChannelRecvmsg(
platform_handle, const_cast<void*>(message->data()),
message->data_num_bytes(), &incoming_platform_handles, true /* block */);
bool error = false;
if (read_result < 0) {
PLOG(ERROR) << "Recvmsg error";
error = true;
} else if (static_cast<size_t>(read_result) != message->data_num_bytes()) {
LOG(ERROR) << "Invalid node channel message";
error = true;
} else if (incoming_platform_handles.size() != expected_num_handles) {
LOG(ERROR) << "Received unexpected number of handles";
error = true;
}
if (!error) {
const BrokerMessageHeader* header =
reinterpret_cast<const BrokerMessageHeader*>(message->payload());
if (header->type != expected_type) {
LOG(ERROR) << "Unexpected message";
error = true;
}
}
if (error) {
CloseAllPlatformHandles(&incoming_platform_handles);
} else {
if (incoming_handles)
incoming_handles->swap(incoming_platform_handles);
}
return !error;
}
} // namespace
Broker::Broker(ScopedPlatformHandle platform_handle)
: sync_channel_(std::move(platform_handle)) {
CHECK(sync_channel_.is_valid());
// Mark the channel as blocking.
int flags = fcntl(sync_channel_.get().handle, F_GETFL);
PCHECK(flags != -1);
flags = fcntl(sync_channel_.get().handle, F_SETFL, flags & ~O_NONBLOCK);
PCHECK(flags != -1);
// Wait for the first message, which should contain a handle.
std::deque<PlatformHandle> incoming_platform_handles;
if (WaitForBrokerMessage(sync_channel_.get(), BrokerMessageType::INIT, 1,
&incoming_platform_handles)) {
parent_channel_ = ScopedPlatformHandle(incoming_platform_handles.front());
}
}
Broker::~Broker() = default;
ScopedPlatformHandle Broker::GetParentPlatformHandle() {
return std::move(parent_channel_);
}
scoped_refptr<PlatformSharedBuffer> Broker::GetSharedBuffer(size_t num_bytes) {
base::AutoLock lock(lock_);
BufferRequestData* buffer_request;
Channel::MessagePtr out_message = CreateBrokerMessage(
BrokerMessageType::BUFFER_REQUEST, 0, 0, &buffer_request);
buffer_request->size = num_bytes;
ssize_t write_result = PlatformChannelWrite(
sync_channel_.get(), out_message->data(), out_message->data_num_bytes());
if (write_result < 0) {
PLOG(ERROR) << "Error sending sync broker message";
return nullptr;
} else if (static_cast<size_t>(write_result) !=
out_message->data_num_bytes()) {
LOG(ERROR) << "Error sending complete broker message";
return nullptr;
}
std::deque<PlatformHandle> incoming_platform_handles;
if (WaitForBrokerMessage(sync_channel_.get(),
BrokerMessageType::BUFFER_RESPONSE, 2,
&incoming_platform_handles)) {
ScopedPlatformHandle rw_handle(incoming_platform_handles.front());
incoming_platform_handles.pop_front();
ScopedPlatformHandle ro_handle(incoming_platform_handles.front());
return PlatformSharedBuffer::CreateFromPlatformHandlePair(
num_bytes, std::move(rw_handle), std::move(ro_handle));
}
return nullptr;
}
} // namespace edk
} // namespace mojo
|
