chrome/nacl/nacl_ipc_adapter.cc

   1 // Copyright (c) 2012 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
   5 #include "chrome/nacl/nacl_ipc_adapter.h"
   6
   7 #include <limits.h>
   8 #include <string.h>
   9
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/location.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/shared_memory.h"
  15 #include "build/build_config.h"
  16 #include "ipc/ipc_channel.h"
  17 #include "ipc/ipc_platform_file.h"
  18 #include "native_client/src/trusted/desc/nacl_desc_base.h"
  19 #include "native_client/src/trusted/desc/nacl_desc_custom.h"
  20 #include "native_client/src/trusted/desc/nacl_desc_imc_shm.h"
  21 #include "native_client/src/trusted/desc/nacl_desc_io.h"
  22 #include "native_client/src/trusted/desc/nacl_desc_sync_socket.h"
  23 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
  24 #include "native_client/src/trusted/service_runtime/include/sys/fcntl.h"
  25 #include "ppapi/c/ppb_file_io.h"
  26 #include "ppapi/proxy/ppapi_messages.h"
  27 #include "ppapi/proxy/serialized_handle.h"
  28
  29 namespace {
  30
  31 enum BufferSizeStatus {
  32   // The buffer contains a full message with no extra bytes.
  33   MESSAGE_IS_COMPLETE,
  34
  35   // The message doesn't fit and the buffer contains only some of it.
  36   MESSAGE_IS_TRUNCATED,
  37
  38   // The buffer contains a full message + extra data.
  39   MESSAGE_HAS_EXTRA_DATA
  40 };
  41
  42 BufferSizeStatus GetBufferStatus(const char* data, size_t len) {
  43   if (len < sizeof(NaClIPCAdapter::NaClMessageHeader))
  44     return MESSAGE_IS_TRUNCATED;
  45
  46   const NaClIPCAdapter::NaClMessageHeader* header =
  47       reinterpret_cast<const NaClIPCAdapter::NaClMessageHeader*>(data);
  48   uint32 message_size =
  49       sizeof(NaClIPCAdapter::NaClMessageHeader) + header->payload_size;
  50
  51   if (len == message_size)
  52     return MESSAGE_IS_COMPLETE;
  53   if (len > message_size)
  54     return MESSAGE_HAS_EXTRA_DATA;
  55   return MESSAGE_IS_TRUNCATED;
  56 }
  57
  58 // This object allows the NaClDesc to hold a reference to a NaClIPCAdapter and
  59 // forward calls to it.
  60 struct DescThunker {
  61   explicit DescThunker(NaClIPCAdapter* adapter_param)
  62       : adapter(adapter_param) {
  63   }
  64   scoped_refptr<NaClIPCAdapter> adapter;
  65 };
  66
  67 NaClIPCAdapter* ToAdapter(void* handle) {
  68   return static_cast<DescThunker*>(handle)->adapter.get();
  69 }
  70
  71 // NaClDescCustom implementation.
  72 void NaClDescCustomDestroy(void* handle) {
  73   delete static_cast<DescThunker*>(handle);
  74 }
  75
  76 ssize_t NaClDescCustomSendMsg(void* handle, const NaClImcTypedMsgHdr* msg,
  77                               int /* flags */) {
  78   return static_cast<ssize_t>(ToAdapter(handle)->Send(msg));
  79 }
  80
  81 ssize_t NaClDescCustomRecvMsg(void* handle, NaClImcTypedMsgHdr* msg,
  82                               int /* flags */) {
  83   return static_cast<ssize_t>(ToAdapter(handle)->BlockingReceive(msg));
  84 }
  85
  86 NaClDesc* MakeNaClDescCustom(NaClIPCAdapter* adapter) {
  87   NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER;
  88   funcs.Destroy = NaClDescCustomDestroy;
  89   funcs.SendMsg = NaClDescCustomSendMsg;
  90   funcs.RecvMsg = NaClDescCustomRecvMsg;
  91   // NaClDescMakeCustomDesc gives us a reference on the returned NaClDesc.
  92   return NaClDescMakeCustomDesc(new DescThunker(adapter), &funcs);
  93 }
  94
  95 void DeleteChannel(IPC::Channel* channel) {
  96   delete channel;
  97 }
  98
  99 // Translates Pepper's read/write open flags into NaCl's ones. The other open
 100 // flags are discarded. If neither of the read/write flags is specified, just
 101 // returns NACL_ABI_O_RDONLY as a safe fallback.
 102 int TranslatePepperFileReadWriteOpenFlags(int32_t pp_open_flags) {
 103   int nacl_open_flag;
 104   if ((pp_open_flags & (PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_WRITE)) ==
 105       (PP_FILEOPENFLAG_READ | PP_FILEOPENFLAG_WRITE)) {
 106     nacl_open_flag = NACL_ABI_O_RDWR;
 107   } else if (pp_open_flags & PP_FILEOPENFLAG_READ) {
 108     nacl_open_flag = NACL_ABI_O_RDONLY;
 109   } else if (pp_open_flags & PP_FILEOPENFLAG_WRITE) {
 110     nacl_open_flag = NACL_ABI_O_WRONLY;
 111   } else {
 112     DLOG(WARNING) << "PP_FILEOPENFLAG_READ and/or PP_FILEOPENFLAG_WRITE "
 113                   << "should be specified.";
 114     // NACL_ABI_O_RDONLY == 0, so make this ambiguous case readonly as a safe
 115     // fallback.
 116     nacl_open_flag = NACL_ABI_O_RDONLY;
 117   }
 118   return nacl_open_flag;
 119 }
 120
 121 class NaClDescWrapper {
 122  public:
 123   explicit NaClDescWrapper(NaClDesc* desc): desc_(desc) {}
 124   ~NaClDescWrapper() {
 125     NaClDescUnref(desc_);
 126   }
 127
 128   NaClDesc* desc() { return desc_; }
 129
 130  private:
 131   NaClDesc* desc_;
 132   DISALLOW_COPY_AND_ASSIGN(NaClDescWrapper);
 133 };
 134
 135 }  // namespace
 136
 137 class NaClIPCAdapter::RewrittenMessage
 138     : public base::RefCounted<RewrittenMessage> {
 139  public:
 140   RewrittenMessage();
 141
 142   bool is_consumed() const { return data_read_cursor_ == data_len_; }
 143
 144   void SetData(const NaClIPCAdapter::NaClMessageHeader& header,
 145                const void* payload, size_t payload_length);
 146
 147   int Read(NaClImcTypedMsgHdr* msg);
 148
 149   void AddDescriptor(NaClDescWrapper* desc) { descs_.push_back(desc); }
 150
 151   size_t desc_count() const { return descs_.size(); }
 152
 153  private:
 154   friend class base::RefCounted<RewrittenMessage>;
 155   ~RewrittenMessage() {}
 156
 157   scoped_ptr<char[]> data_;
 158   size_t data_len_;
 159
 160   // Offset into data where the next read will happen. This will be equal to
 161   // data_len_ when all data has been consumed.
 162   size_t data_read_cursor_;
 163
 164   // Wrapped descriptors for transfer to untrusted code.
 165   ScopedVector<NaClDescWrapper> descs_;
 166 };
 167
 168 NaClIPCAdapter::RewrittenMessage::RewrittenMessage()
 169     : data_len_(0),
 170       data_read_cursor_(0) {
 171 }
 172
 173 void NaClIPCAdapter::RewrittenMessage::SetData(
 174     const NaClIPCAdapter::NaClMessageHeader& header,
 175     const void* payload,
 176     size_t payload_length) {
 177   DCHECK(!data_.get() && data_len_ == 0);
 178   size_t header_len = sizeof(NaClIPCAdapter::NaClMessageHeader);
 179   data_len_ = header_len + payload_length;
 180   data_.reset(new char[data_len_]);
 181
 182   memcpy(data_.get(), &header, sizeof(NaClIPCAdapter::NaClMessageHeader));
 183   memcpy(&data_[header_len], payload, payload_length);
 184 }
 185
 186 int NaClIPCAdapter::RewrittenMessage::Read(NaClImcTypedMsgHdr* msg) {
 187   CHECK(data_len_ >= data_read_cursor_);
 188   char* dest_buffer = static_cast<char*>(msg->iov[0].base);
 189   size_t dest_buffer_size = msg->iov[0].length;
 190   size_t bytes_to_write = std::min(dest_buffer_size,
 191                                    data_len_ - data_read_cursor_);
 192   if (bytes_to_write == 0)
 193     return 0;
 194
 195   memcpy(dest_buffer, &data_[data_read_cursor_], bytes_to_write);
 196   data_read_cursor_ += bytes_to_write;
 197
 198   // Once all data has been consumed, transfer any file descriptors.
 199   if (is_consumed()) {
 200     nacl_abi_size_t desc_count = static_cast<nacl_abi_size_t>(descs_.size());
 201     CHECK(desc_count <= msg->ndesc_length);
 202     msg->ndesc_length = desc_count;
 203     for (nacl_abi_size_t i = 0; i < desc_count; i++) {
 204       // Copy the NaClDesc to the buffer and add a ref so it won't be freed
 205       // when we clear our ScopedVector.
 206       msg->ndescv[i] = descs_[i]->desc();
 207       NaClDescRef(descs_[i]->desc());
 208     }
 209     descs_.clear();
 210   } else {
 211     msg->ndesc_length = 0;
 212   }
 213   return static_cast<int>(bytes_to_write);
 214 }
 215
 216 NaClIPCAdapter::LockedData::LockedData()
 217     : channel_closed_(false) {
 218 }
 219
 220 NaClIPCAdapter::LockedData::~LockedData() {
 221 }
 222
 223 NaClIPCAdapter::IOThreadData::IOThreadData() {
 224 }
 225
 226 NaClIPCAdapter::IOThreadData::~IOThreadData() {
 227 }
 228
 229 NaClIPCAdapter::NaClIPCAdapter(const IPC::ChannelHandle& handle,
 230                                base::TaskRunner* runner)
 231     : lock_(),
 232       cond_var_(&lock_),
 233       task_runner_(runner),
 234       locked_data_() {
 235   io_thread_data_.channel_.reset(
 236       new IPC::Channel(handle, IPC::Channel::MODE_SERVER, this));
 237   // Note, we can not PostTask for ConnectChannelOnIOThread here. If we did,
 238   // and that task ran before this constructor completes, the reference count
 239   // would go to 1 and then to 0 because of the Task, before we've been returned
 240   // to the owning scoped_refptr, which is supposed to give us our first
 241   // ref-count.
 242 }
 243
 244 NaClIPCAdapter::NaClIPCAdapter(scoped_ptr<IPC::Channel> channel,
 245                                base::TaskRunner* runner)
 246     : lock_(),
 247       cond_var_(&lock_),
 248       task_runner_(runner),
 249       locked_data_() {
 250   io_thread_data_.channel_ = channel.Pass();
 251 }
 252
 253 void NaClIPCAdapter::ConnectChannel() {
 254   task_runner_->PostTask(FROM_HERE,
 255       base::Bind(&NaClIPCAdapter::ConnectChannelOnIOThread, this));
 256 }
 257
 258 // Note that this message is controlled by the untrusted code. So we should be
 259 // skeptical of anything it contains and quick to give up if anything is fishy.
 260 int NaClIPCAdapter::Send(const NaClImcTypedMsgHdr* msg) {
 261   if (msg->iov_length != 1)
 262     return -1;
 263
 264   base::AutoLock lock(lock_);
 265
 266   const char* input_data = static_cast<char*>(msg->iov[0].base);
 267   size_t input_data_len = msg->iov[0].length;
 268   if (input_data_len > IPC::Channel::kMaximumMessageSize) {
 269     ClearToBeSent();
 270     return -1;
 271   }
 272
 273   // current_message[_len] refers to the total input data received so far.
 274   const char* current_message;
 275   size_t current_message_len;
 276   bool did_append_input_data;
 277   if (locked_data_.to_be_sent_.empty()) {
 278     // No accumulated data, we can avoid a copy by referring to the input
 279     // buffer (the entire message fitting in one call is the common case).
 280     current_message = input_data;
 281     current_message_len = input_data_len;
 282     did_append_input_data = false;
 283   } else {
 284     // We've already accumulated some data, accumulate this new data and
 285     // point to the beginning of the buffer.
 286
 287     // Make sure our accumulated message size doesn't overflow our max. Since
 288     // we know that data_len < max size (checked above) and our current
 289     // accumulated value is also < max size, we just need to make sure that
 290     // 2x max size can never overflow.
 291     COMPILE_ASSERT(IPC::Channel::kMaximumMessageSize < (UINT_MAX / 2),
 292                    MaximumMessageSizeWillOverflow);
 293     size_t new_size = locked_data_.to_be_sent_.size() + input_data_len;
 294     if (new_size > IPC::Channel::kMaximumMessageSize) {
 295       ClearToBeSent();
 296       return -1;
 297     }
 298
 299     locked_data_.to_be_sent_.append(input_data, input_data_len);
 300     current_message = &locked_data_.to_be_sent_[0];
 301     current_message_len = locked_data_.to_be_sent_.size();
 302     did_append_input_data = true;
 303   }
 304
 305   // Check the total data we've accumulated so far to see if it contains a full
 306   // message.
 307   switch (GetBufferStatus(current_message, current_message_len)) {
 308     case MESSAGE_IS_COMPLETE: {
 309       // Got a complete message, can send it out. This will be the common case.
 310       bool success = SendCompleteMessage(current_message, current_message_len);
 311       ClearToBeSent();
 312       return success ? static_cast<int>(input_data_len) : -1;
 313     }
 314     case MESSAGE_IS_TRUNCATED:
 315       // For truncated messages, just accumulate the new data (if we didn't
 316       // already do so above) and go back to waiting for more.
 317       if (!did_append_input_data)
 318         locked_data_.to_be_sent_.append(input_data, input_data_len);
 319       return static_cast<int>(input_data_len);
 320     case MESSAGE_HAS_EXTRA_DATA:
 321     default:
 322       // When the plugin gives us too much data, it's an error.
 323       ClearToBeSent();
 324       return -1;
 325   }
 326 }
 327
 328 int NaClIPCAdapter::BlockingReceive(NaClImcTypedMsgHdr* msg) {
 329   if (msg->iov_length != 1)
 330     return -1;
 331
 332   int retval = 0;
 333   {
 334     base::AutoLock lock(lock_);
 335     while (locked_data_.to_be_received_.empty() &&
 336            !locked_data_.channel_closed_)
 337       cond_var_.Wait();
 338     if (locked_data_.channel_closed_) {
 339       retval = -1;
 340     } else {
 341       retval = LockedReceive(msg);
 342       DCHECK(retval > 0);
 343     }
 344   }
 345   cond_var_.Signal();
 346   return retval;
 347 }
 348
 349 void NaClIPCAdapter::CloseChannel() {
 350   {
 351     base::AutoLock lock(lock_);
 352     locked_data_.channel_closed_ = true;
 353   }
 354   cond_var_.Signal();
 355
 356   task_runner_->PostTask(FROM_HERE,
 357       base::Bind(&NaClIPCAdapter::CloseChannelOnIOThread, this));
 358 }
 359
 360 NaClDesc* NaClIPCAdapter::MakeNaClDesc() {
 361   return MakeNaClDescCustom(this);
 362 }
 363
 364 #if defined(OS_POSIX)
 365 int NaClIPCAdapter::TakeClientFileDescriptor() {
 366   return io_thread_data_.channel_->TakeClientFileDescriptor();
 367 }
 368 #endif
 369
 370 bool NaClIPCAdapter::OnMessageReceived(const IPC::Message& msg) {
 371   {
 372     base::AutoLock lock(lock_);
 373
 374     scoped_refptr<RewrittenMessage> rewritten_msg(new RewrittenMessage);
 375
 376     typedef std::vector<ppapi::proxy::SerializedHandle> Handles;
 377     Handles handles;
 378     scoped_ptr<IPC::Message> new_msg_ptr;
 379     bool success = locked_data_.handle_converter_.ConvertNativeHandlesToPosix(
 380         msg, &handles, &new_msg_ptr);
 381     if (!success)
 382       return false;
 383
 384     // Now add any descriptors we found to rewritten_msg. |handles| is usually
 385     // empty, unless we read a message containing a FD or handle.
 386     for (Handles::const_iterator iter = handles.begin();
 387          iter != handles.end();
 388          ++iter) {
 389       scoped_ptr<NaClDescWrapper> nacl_desc;
 390       switch (iter->type()) {
 391         case ppapi::proxy::SerializedHandle::SHARED_MEMORY: {
 392           const base::SharedMemoryHandle& shm_handle = iter->shmem();
 393           uint32_t size = iter->size();
 394           nacl_desc.reset(new NaClDescWrapper(NaClDescImcShmMake(
 395 #if defined(OS_WIN)
 396               shm_handle,
 397 #else
 398               shm_handle.fd,
 399 #endif
 400               static_cast<size_t>(size))));
 401           break;
 402         }
 403         case ppapi::proxy::SerializedHandle::SOCKET: {
 404           nacl_desc.reset(new NaClDescWrapper(NaClDescSyncSocketMake(
 405 #if defined(OS_WIN)
 406               iter->descriptor()
 407 #else
 408               iter->descriptor().fd
 409 #endif
 410           )));
 411           break;
 412         }
 413         case ppapi::proxy::SerializedHandle::CHANNEL_HANDLE: {
 414           // Check that this came from a PpapiMsg_CreateNaClChannel message.
 415           // This code here is only appropriate for that message.
 416           DCHECK(msg.type() == PpapiMsg_CreateNaClChannel::ID);
 417           IPC::ChannelHandle channel_handle =
 418               IPC::Channel::GenerateVerifiedChannelID("nacl");
 419           scoped_refptr<NaClIPCAdapter> ipc_adapter(
 420               new NaClIPCAdapter(channel_handle, task_runner_.get()));
 421           ipc_adapter->ConnectChannel();
 422 #if defined(OS_POSIX)
 423           channel_handle.socket = base::FileDescriptor(
 424               ipc_adapter->TakeClientFileDescriptor(), true);
 425 #endif
 426           nacl_desc.reset(new NaClDescWrapper(ipc_adapter->MakeNaClDesc()));
 427           // Send back a message that the channel was created.
 428           scoped_ptr<IPC::Message> response(
 429               new PpapiHostMsg_ChannelCreated(channel_handle));
 430           task_runner_->PostTask(FROM_HERE,
 431               base::Bind(&NaClIPCAdapter::SendMessageOnIOThread, this,
 432                          base::Passed(&response)));
 433           break;
 434         }
 435         case ppapi::proxy::SerializedHandle::FILE:
 436           nacl_desc.reset(new NaClDescWrapper(NaClDescIoDescFromHandleAllocCtor(
 437 #if defined(OS_WIN)
 438               iter->descriptor(),
 439 #else
 440               iter->descriptor().fd,
 441 #endif
 442               TranslatePepperFileReadWriteOpenFlags(iter->open_flag()))));
 443           break;
 444         case ppapi::proxy::SerializedHandle::INVALID: {
 445           // Nothing to do. TODO(dmichael): Should we log this? Or is it
 446           // sometimes okay to pass an INVALID handle?
 447           break;
 448         }
 449         // No default, so the compiler will warn us if new types get added.
 450       }
 451       if (nacl_desc.get())
 452         rewritten_msg->AddDescriptor(nacl_desc.release());
 453     }
 454     if (new_msg_ptr && !handles.empty())
 455       SaveMessage(*new_msg_ptr, rewritten_msg.get());
 456     else
 457       SaveMessage(msg, rewritten_msg.get());
 458   }
 459   cond_var_.Signal();
 460   return true;
 461 }
 462
 463 void NaClIPCAdapter::OnChannelConnected(int32 peer_pid) {
 464 }
 465
 466 void NaClIPCAdapter::OnChannelError() {
 467   CloseChannel();
 468 }
 469
 470 NaClIPCAdapter::~NaClIPCAdapter() {
 471   // Make sure the channel is deleted on the IO thread.
 472   task_runner_->PostTask(FROM_HERE,
 473       base::Bind(&DeleteChannel, io_thread_data_.channel_.release()));
 474 }
 475
 476 int NaClIPCAdapter::LockedReceive(NaClImcTypedMsgHdr* msg) {
 477   lock_.AssertAcquired();
 478
 479   if (locked_data_.to_be_received_.empty())
 480     return 0;
 481   scoped_refptr<RewrittenMessage> current =
 482       locked_data_.to_be_received_.front();
 483
 484   int retval = current->Read(msg);
 485
 486   // When a message is entirely consumed, remove if from the waiting queue.
 487   if (current->is_consumed())
 488     locked_data_.to_be_received_.pop();
 489
 490   return retval;
 491 }
 492
 493 bool NaClIPCAdapter::SendCompleteMessage(const char* buffer,
 494                                          size_t buffer_len) {
 495   lock_.AssertAcquired();
 496   // The message will have already been validated, so we know it's large enough
 497   // for our header.
 498   const NaClMessageHeader* header =
 499       reinterpret_cast<const NaClMessageHeader*>(buffer);
 500
 501   // Length of the message not including the body. The data passed to us by the
 502   // plugin should match that in the message header. This should have already
 503   // been validated by GetBufferStatus.
 504   int body_len = static_cast<int>(buffer_len - sizeof(NaClMessageHeader));
 505   DCHECK(body_len == static_cast<int>(header->payload_size));
 506
 507   // We actually discard the flags and only copy the ones we care about. This
 508   // is just because message doesn't have a constructor that takes raw flags.
 509   scoped_ptr<IPC::Message> msg(
 510       new IPC::Message(header->routing, header->type,
 511                        IPC::Message::PRIORITY_NORMAL));
 512   if (header->flags & IPC::Message::SYNC_BIT)
 513     msg->set_sync();
 514   if (header->flags & IPC::Message::REPLY_BIT)
 515     msg->set_reply();
 516   if (header->flags & IPC::Message::REPLY_ERROR_BIT)
 517     msg->set_reply_error();
 518   if (header->flags & IPC::Message::UNBLOCK_BIT)
 519     msg->set_unblock(true);
 520
 521   msg->WriteBytes(&buffer[sizeof(NaClMessageHeader)], body_len);
 522
 523   // Technically we didn't have to do any of the previous work in the lock. But
 524   // sometimes our buffer will point to the to_be_sent_ string which is
 525   // protected by the lock, and it's messier to factor Send() such that it can
 526   // unlock for us. Holding the lock for the message construction, which is
 527   // just some memcpys, shouldn't be a big deal.
 528   lock_.AssertAcquired();
 529   if (locked_data_.channel_closed_)
 530     return false;  // TODO(brettw) clean up handles here when we add support!
 531
 532   if (msg->is_sync()) {
 533     locked_data_.handle_converter_.RegisterSyncMessageForReply(*msg);
 534   }
 535   // Actual send must be done on the I/O thread.
 536   task_runner_->PostTask(FROM_HERE,
 537       base::Bind(&NaClIPCAdapter::SendMessageOnIOThread, this,
 538                  base::Passed(&msg)));
 539   return true;
 540 }
 541
 542 void NaClIPCAdapter::ClearToBeSent() {
 543   lock_.AssertAcquired();
 544
 545   // Don't let the string keep its buffer behind our back.
 546   std::string empty;
 547   locked_data_.to_be_sent_.swap(empty);
 548 }
 549
 550 void NaClIPCAdapter::ConnectChannelOnIOThread() {
 551   if (!io_thread_data_.channel_->Connect())
 552     NOTREACHED();
 553 }
 554
 555 void NaClIPCAdapter::CloseChannelOnIOThread() {
 556   io_thread_data_.channel_->Close();
 557 }
 558
 559 void NaClIPCAdapter::SendMessageOnIOThread(scoped_ptr<IPC::Message> message) {
 560   io_thread_data_.channel_->Send(message.release());
 561 }
 562
 563 void NaClIPCAdapter::SaveMessage(const IPC::Message& msg,
 564                                  RewrittenMessage* rewritten_msg) {
 565   lock_.AssertAcquired();
 566   // There is some padding in this structure (the "padding" member is 16
 567   // bits but this then gets padded to 32 bits). We want to be sure not to
 568   // leak data to the untrusted plugin, so zero everything out first.
 569   NaClMessageHeader header;
 570   memset(&header, 0, sizeof(NaClMessageHeader));
 571
 572   header.payload_size = static_cast<uint32>(msg.payload_size());
 573   header.routing = msg.routing_id();
 574   header.type = msg.type();
 575   header.flags = msg.flags();
 576   header.num_fds = static_cast<int>(rewritten_msg->desc_count());
 577
 578   rewritten_msg->SetData(header, msg.payload(), msg.payload_size());
 579   locked_data_.to_be_received_.push(rewritten_msg);
 580 }
 581
 582 int TranslatePepperFileReadWriteOpenFlagsForTesting(int32_t pp_open_flags) {
 583   return TranslatePepperFileReadWriteOpenFlags(pp_open_flags);
 584 }