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#ifndef IPC_IPC_CHANNEL_NACL_H_ 6#define IPC_IPC_CHANNEL_NACL_H_ 7 8#include <deque> 9#include <string> 10 11#include "base/memory/linked_ptr.h" 12#include "base/memory/scoped_ptr.h" 13#include "base/memory/weak_ptr.h" 14#include "base/process/process.h" 15#include "base/threading/simple_thread.h" 16#include "ipc/ipc_channel.h" 17#include "ipc/ipc_channel_reader.h" 18 19namespace IPC { 20 21// Contains the results from one call to imc_recvmsg (data and file 22// descriptors). 23struct MessageContents; 24 25// Similar to the Posix version of ChannelImpl but for Native Client code. 26// This is somewhat different because sendmsg/recvmsg here do not follow POSIX 27// semantics. Instead, they are implemented by a custom embedding of 28// NaClDescCustom. See NaClIPCAdapter for the trusted-side implementation. 29// 30// We don't need to worry about complicated set up and READWRITE mode for 31// sharing handles. We also currently do not support passing file descriptors or 32// named pipes, and we use background threads to emulate signaling when we can 33// read or write without blocking. 34class Channel::ChannelImpl : public internal::ChannelReader { 35 public: 36 // Mirror methods of Channel, see ipc_channel.h for description. 37 ChannelImpl(const IPC::ChannelHandle& channel_handle, 38 Mode mode, 39 Listener* listener); 40 virtual ~ChannelImpl(); 41 42 // Channel implementation. 43 bool Connect(); 44 void Close(); 45 bool Send(Message* message); 46 47 // Posted to the main thread by ReaderThreadRunner. 48 void DidRecvMsg(scoped_ptr<MessageContents> contents); 49 void ReadDidFail(); 50 51 private: 52 class ReaderThreadRunner; 53 54 bool CreatePipe(const IPC::ChannelHandle& channel_handle); 55 bool ProcessOutgoingMessages(); 56 57 // ChannelReader implementation. 58 virtual ReadState ReadData(char* buffer, 59 int buffer_len, 60 int* bytes_read) OVERRIDE; 61 virtual bool WillDispatchInputMessage(Message* msg) OVERRIDE; 62 virtual bool DidEmptyInputBuffers() OVERRIDE; 63 virtual void HandleInternalMessage(const Message& msg) OVERRIDE; 64 65 Mode mode_; 66 bool waiting_connect_; 67 68 // The pipe used for communication. 69 int pipe_; 70 71 // The "name" of our pipe. On Windows this is the global identifier for 72 // the pipe. On POSIX it's used as a key in a local map of file descriptors. 73 // For NaCl, we don't actually support looking up file descriptors by name, 74 // and it's only used for debug information. 75 std::string pipe_name_; 76 77 // We use a thread for reading, so that we can simply block on reading and 78 // post the received data back to the main thread to be properly interleaved 79 // with other tasks in the MessagePump. 80 // 81 // imc_recvmsg supports non-blocking reads, but there's no easy way to be 82 // informed when a write or read can be done without blocking (this is handled 83 // by libevent in Posix). 84 scoped_ptr<ReaderThreadRunner> reader_thread_runner_; 85 scoped_ptr<base::DelegateSimpleThread> reader_thread_; 86 87 // IPC::ChannelReader expects to be able to call ReadData on us to 88 // synchronously read data waiting in the pipe's buffer without blocking. 89 // Since we can't do that (see 1 and 2 above), the reader thread does blocking 90 // reads and posts the data over to the main thread in MessageContents. Each 91 // MessageContents object is the result of one call to "imc_recvmsg". 92 // DidRecvMsg breaks the MessageContents out in to the data and the file 93 // descriptors, and puts them on these two queues. 94 // TODO(dmichael): There's probably a more efficient way to emulate this with 95 // a circular buffer or something, so we don't have to do so 96 // many heap allocations. But it maybe isn't worth 97 // the trouble given that we probably want to implement 1 and 98 // 2 above in NaCl eventually. 99 // When ReadData is called, it pulls the bytes out of this queue in order. 100 std::deque<linked_ptr<std::vector<char> > > read_queue_; 101 // Queue of file descriptors extracted from imc_recvmsg messages. 102 // NOTE: The implementation assumes underlying storage here is contiguous, so 103 // don't change to something like std::deque<> without changing the 104 // implementation! 105 std::vector<int> input_fds_; 106 107 // This queue is used when a message is sent prior to Connect having been 108 // called. Normally after we're connected, the queue is empty. 109 std::deque<linked_ptr<Message> > output_queue_; 110 111 base::WeakPtrFactory<ChannelImpl> weak_ptr_factory_; 112 113 DISALLOW_IMPLICIT_CONSTRUCTORS(ChannelImpl); 114}; 115 116} // namespace IPC 117 118#endif // IPC_IPC_CHANNEL_NACL_H_ 119