ipc/mojo/ipc_channel_mojo.cc

// 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_channel_mojo.h"

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/lazy_instance.h"
#include "ipc/ipc_listener.h"
#include "mojo/embedder/embedder.h"

#if defined(OS_POSIX) && !defined(OS_NACL)
#include "ipc/file_descriptor_set_posix.h"
#endif

namespace IPC {

namespace {

// IPC::Listener for bootstrap channels.
// It should never receive any message.
class NullListener : public Listener {
 public:
  virtual bool OnMessageReceived(const Message&) OVERRIDE {
    NOTREACHED();
    return false;
  }

  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
    NOTREACHED();
  }

  virtual void OnChannelError() OVERRIDE {
    NOTREACHED();
  }

  virtual void OnBadMessageReceived(const Message& message) OVERRIDE {
    NOTREACHED();
  }
};

base::LazyInstance<NullListener> g_null_listener = LAZY_INSTANCE_INITIALIZER;

class MojoChannelFactory : public ChannelFactory {
 public:
  MojoChannelFactory(
      ChannelHandle channel_handle,
      Channel::Mode mode,
      scoped_refptr<base::TaskRunner> io_thread_task_runner)
      : channel_handle_(channel_handle),
        mode_(mode),
        io_thread_task_runner_(io_thread_task_runner) {
  }

  virtual std::string GetName() const OVERRIDE {
    return channel_handle_.name;
  }

  virtual scoped_ptr<Channel> BuildChannel(Listener* listener) OVERRIDE {
    return ChannelMojo::Create(
        channel_handle_,
        mode_,
        listener,
        io_thread_task_runner_).PassAs<Channel>();
  }

 private:
  ChannelHandle channel_handle_;
  Channel::Mode mode_;
  scoped_refptr<base::TaskRunner> io_thread_task_runner_;
};

mojo::embedder::PlatformHandle ToPlatformHandle(
    const ChannelHandle& handle) {
#if defined(OS_POSIX) && !defined(OS_NACL)
  return mojo::embedder::PlatformHandle(handle.socket.fd);
#elif defined(OS_WIN)
  return mojo::embedder::PlatformHandle(handle.pipe.handle);
#else
#error "Unsupported Platform!"
#endif
}

//------------------------------------------------------------------------------

// TODO(morrita): This should be built using higher-level Mojo construct
// for clarity and extensibility.
class HelloMessage {
 public:
  static Pickle CreateRequest(int32 pid) {
    Pickle request;
    request.WriteString(kHelloRequestMagic);
    request.WriteInt(pid);
    return request;
  }

  static bool ReadRequest(Pickle& pickle, int32* pid) {
    PickleIterator iter(pickle);
    std::string hello;
    if (!iter.ReadString(&hello)) {
      DLOG(WARNING) << "Failed to Read magic string.";
      return false;
    }

    if (hello != kHelloRequestMagic) {
      DLOG(WARNING) << "Magic mismatch:" << hello;
      return false;
    }

    int read_pid;
    if (!iter.ReadInt(&read_pid)) {
      DLOG(WARNING) << "Failed to Read PID.";
      return false;
    }

    *pid = read_pid;
    return true;
  }

  static Pickle CreateResponse(int32 pid) {
    Pickle request;
    request.WriteString(kHelloResponseMagic);
    request.WriteInt(pid);
    return request;
  }

  static bool ReadResponse(Pickle& pickle, int32* pid) {
    PickleIterator iter(pickle);
    std::string hello;
    if (!iter.ReadString(&hello)) {
      DLOG(WARNING) << "Failed to read magic string.";
      return false;
    }

    if (hello != kHelloResponseMagic) {
      DLOG(WARNING) << "Magic mismatch:" << hello;
      return false;
    }

    int read_pid;
    if (!iter.ReadInt(&read_pid)) {
      DLOG(WARNING) << "Failed to read PID.";
      return false;
    }

    *pid = read_pid;
    return true;
  }

 private:
  static const char* kHelloRequestMagic;
  static const char* kHelloResponseMagic;
};

const char* HelloMessage::kHelloRequestMagic = "MREQ";
const char* HelloMessage::kHelloResponseMagic = "MRES";

} // namespace

//------------------------------------------------------------------------------

// A MessagePipeReader implemenation for IPC::Message communication.
class ChannelMojo::MessageReader : public internal::MessagePipeReader {
 public:
  MessageReader(mojo::ScopedMessagePipeHandle pipe, ChannelMojo* owner)
      : internal::MessagePipeReader(pipe.Pass()),
        owner_(owner) {}

  bool Send(scoped_ptr<Message> message);
  virtual void OnMessageReceived() OVERRIDE;
  virtual void OnPipeClosed() OVERRIDE;
  virtual void OnPipeError(MojoResult error) OVERRIDE;

 private:
  ChannelMojo* owner_;
};

void ChannelMojo::MessageReader::OnMessageReceived() {
  Message message(data_buffer().empty() ? "" : &data_buffer()[0],
                  static_cast<uint32>(data_buffer().size()));

  std::vector<MojoHandle> handle_buffer;
  TakeHandleBuffer(&handle_buffer);
#if defined(OS_POSIX) && !defined(OS_NACL)
  for (size_t i = 0; i < handle_buffer.size(); ++i) {
    mojo::embedder::ScopedPlatformHandle platform_handle;
    MojoResult unwrap_result = mojo::embedder::PassWrappedPlatformHandle(
        handle_buffer[i], &platform_handle);
    if (unwrap_result != MOJO_RESULT_OK) {
      DLOG(WARNING) << "Pipe failed to covert handles. Closing: "
                    << unwrap_result;
      CloseWithError(unwrap_result);
      return;
    }

    bool ok = message.file_descriptor_set()->Add(platform_handle.release().fd);
    DCHECK(ok);
  }
#else
  DCHECK(handle_buffer.empty());
#endif

  message.TraceMessageEnd();
  owner_->OnMessageReceived(message);
}

void ChannelMojo::MessageReader::OnPipeClosed() {
  if (!owner_)
    return;
  owner_->OnPipeClosed(this);
  owner_ = NULL;
}

void ChannelMojo::MessageReader::OnPipeError(MojoResult error) {
  if (!owner_)
    return;
  owner_->OnPipeError(this);
}

bool ChannelMojo::MessageReader::Send(scoped_ptr<Message> message) {
  DCHECK(IsValid());

  message->TraceMessageBegin();
  std::vector<MojoHandle> handles;
#if defined(OS_POSIX) && !defined(OS_NACL)
  if (message->HasFileDescriptors()) {
    FileDescriptorSet* fdset = message->file_descriptor_set();
    for (size_t i = 0; i < fdset->size(); ++i) {
      MojoHandle wrapped_handle;
      MojoResult wrap_result = CreatePlatformHandleWrapper(
          mojo::embedder::ScopedPlatformHandle(
              mojo::embedder::PlatformHandle(
                  fdset->GetDescriptorAt(i))),
          &wrapped_handle);
      if (MOJO_RESULT_OK != wrap_result) {
        DLOG(WARNING) << "Pipe failed to wrap handles. Closing: "
                      << wrap_result;
        CloseWithError(wrap_result);
        return false;
      }

      handles.push_back(wrapped_handle);
    }
  }
#endif
  MojoResult write_result = MojoWriteMessage(
      handle(),
      message->data(), static_cast<uint32>(message->size()),
      handles.empty() ? NULL : &handles[0],
      static_cast<uint32>(handles.size()),
      MOJO_WRITE_MESSAGE_FLAG_NONE);
  if (MOJO_RESULT_OK != write_result) {
    CloseWithError(write_result);
    return false;
  }

  return true;
}

//------------------------------------------------------------------------------

// MessagePipeReader implemenation for control messages.
// Actual message handling is implemented by sublcasses.
class ChannelMojo::ControlReader : public internal::MessagePipeReader {
 public:
  ControlReader(mojo::ScopedMessagePipeHandle pipe, ChannelMojo* owner)
      : internal::MessagePipeReader(pipe.Pass()),
        owner_(owner) {}

  virtual bool Connect() { return true; }
  virtual void OnPipeClosed() OVERRIDE;
  virtual void OnPipeError(MojoResult error) OVERRIDE;

 protected:
  ChannelMojo* owner_;
};

void ChannelMojo::ControlReader::OnPipeClosed() {
  if (!owner_)
    return;
  owner_->OnPipeClosed(this);
  owner_ = NULL;
}

void ChannelMojo::ControlReader::OnPipeError(MojoResult error) {
  if (!owner_)
    return;
  owner_->OnPipeError(this);
}

//------------------------------------------------------------------------------

// ControlReader for server-side ChannelMojo.
class ChannelMojo::ServerControlReader : public ChannelMojo::ControlReader {
 public:
  ServerControlReader(mojo::ScopedMessagePipeHandle pipe, ChannelMojo* owner)
      : ControlReader(pipe.Pass(), owner) { }

  virtual bool Connect() OVERRIDE;
  virtual void OnMessageReceived() OVERRIDE;

 private:
  MojoResult SendHelloRequest();
  MojoResult RespondHelloResponse();

  mojo::ScopedMessagePipeHandle message_pipe_;
};

bool ChannelMojo::ServerControlReader::Connect() {
  MojoResult result = SendHelloRequest();
  if (result != MOJO_RESULT_OK) {
    CloseWithError(result);
    return false;
  }

  return true;
}

MojoResult ChannelMojo::ServerControlReader::SendHelloRequest() {
  DCHECK(IsValid());
  DCHECK(!message_pipe_.is_valid());

  mojo::ScopedMessagePipeHandle self;
  mojo::ScopedMessagePipeHandle peer;
  MojoResult create_result = mojo::CreateMessagePipe(
      NULL, &message_pipe_, &peer);
  if (MOJO_RESULT_OK != create_result) {
    DLOG(WARNING) << "mojo::CreateMessagePipe failed: " << create_result;
    return create_result;
  }

  MojoHandle peer_to_send = peer.get().value();
  Pickle request = HelloMessage::CreateRequest(owner_->GetSelfPID());
  MojoResult write_result = MojoWriteMessage(
      handle(),
      request.data(), static_cast<uint32>(request.size()),
      &peer_to_send, 1,
      MOJO_WRITE_MESSAGE_FLAG_NONE);
  if (MOJO_RESULT_OK != write_result) {
    DLOG(WARNING) << "Writing Hello request failed: " << create_result;
    return write_result;
  }

  // |peer| is sent and no longer owned by |this|.
  (void)peer.release();
  return MOJO_RESULT_OK;
}

MojoResult ChannelMojo::ServerControlReader::RespondHelloResponse() {
  Pickle request(data_buffer().empty() ? "" : &data_buffer()[0],
                 static_cast<uint32>(data_buffer().size()));

  int32 read_pid = 0;
  if (!HelloMessage::ReadResponse(request, &read_pid)) {
    DLOG(ERROR) << "Failed to parse Hello response.";
    return MOJO_RESULT_UNKNOWN;
  }

  base::ProcessId pid = static_cast<base::ProcessId>(read_pid);
  owner_->set_peer_pid(pid);
  owner_->OnConnected(message_pipe_.Pass());
  return MOJO_RESULT_OK;
}

void ChannelMojo::ServerControlReader::OnMessageReceived() {
  MojoResult result = RespondHelloResponse();
  if (result != MOJO_RESULT_OK)
    CloseWithError(result);
}

//------------------------------------------------------------------------------

// ControlReader for client-side ChannelMojo.
class ChannelMojo::ClientControlReader : public ChannelMojo::ControlReader {
 public:
  ClientControlReader(mojo::ScopedMessagePipeHandle pipe, ChannelMojo* owner)
      : ControlReader(pipe.Pass(), owner) {}

  virtual void OnMessageReceived() OVERRIDE;

 private:
  MojoResult RespondHelloRequest(MojoHandle message_channel);
};

MojoResult ChannelMojo::ClientControlReader::RespondHelloRequest(
    MojoHandle message_channel) {
  DCHECK(IsValid());

  mojo::ScopedMessagePipeHandle received_pipe(
      (mojo::MessagePipeHandle(message_channel)));

  int32 read_request = 0;
  Pickle request(data_buffer().empty() ? "" : &data_buffer()[0],
                 static_cast<uint32>(data_buffer().size()));
  if (!HelloMessage::ReadRequest(request, &read_request)) {
    DLOG(ERROR) << "Hello request has wrong magic.";
    return MOJO_RESULT_UNKNOWN;
  }

  base::ProcessId pid = read_request;
  Pickle response = HelloMessage::CreateResponse(owner_->GetSelfPID());
  MojoResult write_result = MojoWriteMessage(
      handle(),
      response.data(), static_cast<uint32>(response.size()),
      NULL, 0,
      MOJO_WRITE_MESSAGE_FLAG_NONE);
  if (MOJO_RESULT_OK != write_result) {
    DLOG(ERROR) << "Writing Hello response failed: " << write_result;
    return write_result;
  }

  owner_->set_peer_pid(pid);
  owner_->OnConnected(received_pipe.Pass());
  return MOJO_RESULT_OK;
}

void ChannelMojo::ClientControlReader::OnMessageReceived() {
  std::vector<MojoHandle> handle_buffer;
  TakeHandleBuffer(&handle_buffer);
  if (handle_buffer.size() != 1) {
    DLOG(ERROR) << "Hello request doesn't contains required handle: "
                << handle_buffer.size();
    CloseWithError(MOJO_RESULT_UNKNOWN);
    return;
  }

  MojoResult result = RespondHelloRequest(handle_buffer[0]);
  if (result != MOJO_RESULT_OK) {
    DLOG(ERROR) << "Failed to respond Hello request. Closing: "
                << result;
    CloseWithError(result);
  }
}

//------------------------------------------------------------------------------

void ChannelMojo::ChannelInfoDeleter::operator()(
    mojo::embedder::ChannelInfo* ptr) const {
  mojo::embedder::DestroyChannelOnIOThread(ptr);
}

//------------------------------------------------------------------------------

// static
scoped_ptr<ChannelMojo> ChannelMojo::Create(
    scoped_ptr<Channel> bootstrap, Mode mode, Listener* listener,
    scoped_refptr<base::TaskRunner> io_thread_task_runner) {
  return make_scoped_ptr(new ChannelMojo(
      bootstrap.Pass(), mode, listener, io_thread_task_runner));
}

// static
scoped_ptr<ChannelMojo> ChannelMojo::Create(
    const ChannelHandle &channel_handle, Mode mode, Listener* listener,
    scoped_refptr<base::TaskRunner> io_thread_task_runner) {
  return Create(
      Channel::Create(channel_handle, mode, g_null_listener.Pointer()),
      mode, listener, io_thread_task_runner);
}

// static
scoped_ptr<ChannelFactory> ChannelMojo::CreateFactory(
    const ChannelHandle &channel_handle, Mode mode,
    scoped_refptr<base::TaskRunner> io_thread_task_runner) {
  return make_scoped_ptr(
      new MojoChannelFactory(
          channel_handle, mode,
          io_thread_task_runner)).PassAs<ChannelFactory>();
}

ChannelMojo::ChannelMojo(
    scoped_ptr<Channel> bootstrap, Mode mode, Listener* listener,
    scoped_refptr<base::TaskRunner> io_thread_task_runner)
    : weak_factory_(this),
      bootstrap_(bootstrap.Pass()),
      mode_(mode), listener_(listener),
      peer_pid_(base::kNullProcessId) {
  DCHECK(mode_ == MODE_SERVER || mode_ == MODE_CLIENT);
  mojo::ScopedMessagePipeHandle control_pipe
      = mojo::embedder::CreateChannel(
          mojo::embedder::ScopedPlatformHandle(
              ToPlatformHandle(bootstrap_->TakePipeHandle())),
          io_thread_task_runner,
          base::Bind(&ChannelMojo::DidCreateChannel, base::Unretained(this)),
          io_thread_task_runner);

  // MessagePipeReader, that is crated in InitOnIOThread(), should live only in
  // IO thread, but IPC::Channel can be instantiated outside of it.
  // So we move the creation to the appropriate thread.
  if (base::MessageLoopProxy::current() == io_thread_task_runner) {
    InitOnIOThread(control_pipe.Pass());
  } else {
    io_thread_task_runner->PostTask(
        FROM_HERE,
        base::Bind(&ChannelMojo::InitOnIOThread,
                   weak_factory_.GetWeakPtr(),
                   base::Passed(control_pipe.Pass())));
  }
}

ChannelMojo::~ChannelMojo() {
  Close();
}

void ChannelMojo::InitOnIOThread(mojo::ScopedMessagePipeHandle control_pipe) {
  control_reader_ = CreateControlReader(control_pipe.Pass());
}

scoped_ptr<ChannelMojo::ControlReader> ChannelMojo::CreateControlReader(
    mojo::ScopedMessagePipeHandle pipe) {
  if (MODE_SERVER == mode_) {
    return make_scoped_ptr(
        new ServerControlReader(pipe.Pass(), this)).PassAs<ControlReader>();
  }

  DCHECK(mode_ == MODE_CLIENT);
  return make_scoped_ptr(
      new ClientControlReader(pipe.Pass(), this)).PassAs<ControlReader>();
}

bool ChannelMojo::Connect() {
  DCHECK(!message_reader_);
  return control_reader_->Connect();
}

void ChannelMojo::Close() {
  control_reader_.reset();
  message_reader_.reset();
  channel_info_.reset();
}

void ChannelMojo::OnConnected(mojo::ScopedMessagePipeHandle pipe) {
  message_reader_ = make_scoped_ptr(new MessageReader(pipe.Pass(), this));

  for (size_t i = 0; i < pending_messages_.size(); ++i) {
    message_reader_->Send(make_scoped_ptr(pending_messages_[i]));
    pending_messages_[i] = NULL;
  }

  pending_messages_.clear();

  listener_->OnChannelConnected(GetPeerPID());
}

void ChannelMojo::OnPipeClosed(internal::MessagePipeReader* reader) {
  Close();
}

void ChannelMojo::OnPipeError(internal::MessagePipeReader* reader) {
  listener_->OnChannelError();
}


bool ChannelMojo::Send(Message* message) {
  if (!message_reader_) {
    pending_messages_.push_back(message);
    return true;
  }

  return message_reader_->Send(make_scoped_ptr(message));
}

base::ProcessId ChannelMojo::GetPeerPID() const {
  return peer_pid_;
}

base::ProcessId ChannelMojo::GetSelfPID() const {
  return bootstrap_->GetSelfPID();
}

ChannelHandle ChannelMojo::TakePipeHandle() {
  return bootstrap_->TakePipeHandle();
}

void ChannelMojo::DidCreateChannel(mojo::embedder::ChannelInfo* info) {
  channel_info_.reset(info);
}

void ChannelMojo::OnMessageReceived(Message& message) {
  listener_->OnMessageReceived(message);
  if (message.dispatch_error())
    listener_->OnBadMessageReceived(message);
}

#if defined(OS_POSIX) && !defined(OS_NACL)
int ChannelMojo::GetClientFileDescriptor() const {
  return bootstrap_->GetClientFileDescriptor();
}

int ChannelMojo::TakeClientFileDescriptor() {
  return bootstrap_->TakeClientFileDescriptor();
}
#endif  // defined(OS_POSIX) && !defined(OS_NACL)

}  // namespace IPC