blob: d296675660577fe54e5e0156ee00338eea0bb79e [file] [log] [blame]
// Copyright 2014 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 "ipc/mojo/ipc_mojo_bootstrap.h"
#include <stdint.h>
#include <utility>
#include "base/logging.h"
#include "base/macros.h"
#include "base/process/process_handle.h"
#include "build/build_config.h"
#include "ipc/ipc_message_utils.h"
#include "ipc/ipc_platform_file.h"
#include "third_party/mojo/src/mojo/edk/embedder/platform_channel_pair.h"
namespace IPC {
namespace {
// MojoBootstrap for the server process. You should create the instance
// using MojoBootstrap::Create().
class MojoServerBootstrap : public MojoBootstrap {
public:
MojoServerBootstrap();
private:
void SendClientPipe(int32_t peer_pid);
// Listener implementations
bool OnMessageReceived(const Message& message) override;
void OnChannelConnected(int32_t peer_pid) override;
mojo::embedder::ScopedPlatformHandle server_pipe_;
bool connected_;
int32_t peer_pid_;
DISALLOW_COPY_AND_ASSIGN(MojoServerBootstrap);
};
MojoServerBootstrap::MojoServerBootstrap() : connected_(false), peer_pid_(0) {
}
void MojoServerBootstrap::SendClientPipe(int32_t peer_pid) {
DCHECK_EQ(state(), STATE_INITIALIZED);
DCHECK(connected_);
mojo::embedder::PlatformChannelPair channel_pair;
server_pipe_ = channel_pair.PassServerHandle();
base::Process peer_process =
#if defined(OS_WIN)
base::Process::OpenWithAccess(peer_pid, PROCESS_DUP_HANDLE);
#else
base::Process::Open(peer_pid);
#endif
PlatformFileForTransit client_pipe = GetFileHandleForProcess(
#if defined(OS_POSIX)
channel_pair.PassClientHandle().release().fd,
#else
channel_pair.PassClientHandle().release().handle,
#endif
peer_process.Handle(), true);
if (client_pipe == IPC::InvalidPlatformFileForTransit()) {
#if !defined(OS_WIN)
// GetFileHandleForProcess() only fails on Windows.
NOTREACHED();
#endif
LOG(WARNING) << "Failed to translate file handle for client process.";
Fail();
return;
}
scoped_ptr<Message> message(new Message());
ParamTraits<PlatformFileForTransit>::Write(message.get(), client_pipe);
Send(message.release());
set_state(STATE_WAITING_ACK);
}
void MojoServerBootstrap::OnChannelConnected(int32_t peer_pid) {
DCHECK_EQ(state(), STATE_INITIALIZED);
connected_ = true;
peer_pid_ = peer_pid;
SendClientPipe(peer_pid);
}
bool MojoServerBootstrap::OnMessageReceived(const Message&) {
if (state() != STATE_WAITING_ACK) {
set_state(STATE_ERROR);
LOG(ERROR) << "Got inconsistent message from client.";
return false;
}
set_state(STATE_READY);
CHECK(server_pipe_.is_valid());
delegate()->OnPipeAvailable(
mojo::embedder::ScopedPlatformHandle(server_pipe_.release()), peer_pid_);
return true;
}
// MojoBootstrap for client processes. You should create the instance
// using MojoBootstrap::Create().
class MojoClientBootstrap : public MojoBootstrap {
public:
MojoClientBootstrap();
private:
// Listener implementations
bool OnMessageReceived(const Message& message) override;
void OnChannelConnected(int32_t peer_pid) override;
int32_t peer_pid_;
DISALLOW_COPY_AND_ASSIGN(MojoClientBootstrap);
};
MojoClientBootstrap::MojoClientBootstrap() : peer_pid_(0) {
}
bool MojoClientBootstrap::OnMessageReceived(const Message& message) {
if (state() != STATE_INITIALIZED) {
set_state(STATE_ERROR);
LOG(ERROR) << "Got inconsistent message from server.";
return false;
}
PlatformFileForTransit pipe;
base::PickleIterator iter(message);
if (!ParamTraits<PlatformFileForTransit>::Read(&message, &iter, &pipe)) {
LOG(WARNING) << "Failed to read a file handle from bootstrap channel.";
message.set_dispatch_error();
return false;
}
// Sends ACK back.
Send(new Message());
set_state(STATE_READY);
delegate()->OnPipeAvailable(
mojo::embedder::ScopedPlatformHandle(mojo::embedder::PlatformHandle(
PlatformFileForTransitToPlatformFile(pipe))), peer_pid_);
return true;
}
void MojoClientBootstrap::OnChannelConnected(int32_t peer_pid) {
peer_pid_ = peer_pid;
}
} // namespace
// MojoBootstrap
// static
scoped_ptr<MojoBootstrap> MojoBootstrap::Create(ChannelHandle handle,
Channel::Mode mode,
Delegate* delegate) {
CHECK(mode == Channel::MODE_CLIENT || mode == Channel::MODE_SERVER);
scoped_ptr<MojoBootstrap> self =
mode == Channel::MODE_CLIENT
? scoped_ptr<MojoBootstrap>(new MojoClientBootstrap())
: scoped_ptr<MojoBootstrap>(new MojoServerBootstrap());
scoped_ptr<Channel> bootstrap_channel =
Channel::Create(handle, mode, self.get());
self->Init(std::move(bootstrap_channel), delegate);
return self;
}
MojoBootstrap::MojoBootstrap() : delegate_(NULL), state_(STATE_INITIALIZED) {
}
MojoBootstrap::~MojoBootstrap() {
}
void MojoBootstrap::Init(scoped_ptr<Channel> channel, Delegate* delegate) {
channel_ = std::move(channel);
delegate_ = delegate;
}
bool MojoBootstrap::Connect() {
return channel_->Connect();
}
base::ProcessId MojoBootstrap::GetSelfPID() const {
return channel_->GetSelfPID();
}
void MojoBootstrap::OnBadMessageReceived(const Message& message) {
Fail();
}
void MojoBootstrap::OnChannelError() {
if (state_ == STATE_READY || state_ == STATE_ERROR)
return;
DLOG(WARNING) << "Detected error on Mojo bootstrap channel.";
Fail();
}
void MojoBootstrap::Fail() {
set_state(STATE_ERROR);
delegate()->OnBootstrapError();
}
bool MojoBootstrap::HasFailed() const {
return state() == STATE_ERROR;
}
bool MojoBootstrap::Send(Message* message) {
return channel_->Send(message);
}
#if defined(OS_POSIX) && !defined(OS_NACL)
int MojoBootstrap::GetClientFileDescriptor() const {
return channel_->GetClientFileDescriptor();
}
base::ScopedFD MojoBootstrap::TakeClientFileDescriptor() {
return channel_->TakeClientFileDescriptor();
}
#endif // defined(OS_POSIX) && !defined(OS_NACL)
} // namespace IPC