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_H_ 6 #define IPC_IPC_CHANNEL_H_ 7 8 #include <string> 9 10 #if defined(OS_POSIX) 11 #include <sys/types.h> 12 #endif 13 14 #include "base/compiler_specific.h" 15 #include "base/process/process.h" 16 #include "ipc/ipc_channel_handle.h" 17 #include "ipc/ipc_message.h" 18 #include "ipc/ipc_sender.h" 19 20 namespace IPC { 21 22 class Listener; 23 24 //------------------------------------------------------------------------------ 25 // See 26 // http://www.chromium.org/developers/design-documents/inter-process-communication 27 // for overview of IPC in Chromium. 28 29 // Channels are implemented using named pipes on Windows, and 30 // socket pairs (or in some special cases unix domain sockets) on POSIX. 31 // On Windows we access pipes in various processes by name. 32 // On POSIX we pass file descriptors to child processes and assign names to them 33 // in a lookup table. 34 // In general on POSIX we do not use unix domain sockets due to security 35 // concerns and the fact that they can leave garbage around the file system 36 // (MacOS does not support abstract named unix domain sockets). 37 // You can use unix domain sockets if you like on POSIX by constructing the 38 // the channel with the mode set to one of the NAMED modes. NAMED modes are 39 // currently used by automation and service processes. 40 41 class IPC_EXPORT Channel : public Sender { 42 // Security tests need access to the pipe handle. 43 friend class ChannelTest; 44 45 public: 46 // Flags to test modes 47 enum ModeFlags { 48 MODE_NO_FLAG = 0x0, 49 MODE_SERVER_FLAG = 0x1, 50 MODE_CLIENT_FLAG = 0x2, 51 MODE_NAMED_FLAG = 0x4, 52 #if defined(OS_POSIX) 53 MODE_OPEN_ACCESS_FLAG = 0x8, // Don't restrict access based on client UID. 54 #endif 55 }; 56 57 // Some Standard Modes 58 enum Mode { 59 MODE_NONE = MODE_NO_FLAG, 60 MODE_SERVER = MODE_SERVER_FLAG, 61 MODE_CLIENT = MODE_CLIENT_FLAG, 62 // Channels on Windows are named by default and accessible from other 63 // processes. On POSIX channels are anonymous by default and not accessible 64 // from other processes. Named channels work via named unix domain sockets. 65 // On Windows MODE_NAMED_SERVER is equivalent to MODE_SERVER and 66 // MODE_NAMED_CLIENT is equivalent to MODE_CLIENT. 67 MODE_NAMED_SERVER = MODE_SERVER_FLAG | MODE_NAMED_FLAG, 68 MODE_NAMED_CLIENT = MODE_CLIENT_FLAG | MODE_NAMED_FLAG, 69 #if defined(OS_POSIX) 70 // An "open" named server accepts connections from ANY client. 71 // The caller must then implement their own access-control based on the 72 // client process' user Id. 73 MODE_OPEN_NAMED_SERVER = MODE_OPEN_ACCESS_FLAG | MODE_SERVER_FLAG | 74 MODE_NAMED_FLAG 75 #endif 76 }; 77 78 // The Hello message is internal to the Channel class. It is sent 79 // by the peer when the channel is connected. The message contains 80 // just the process id (pid). The message has a special routing_id 81 // (MSG_ROUTING_NONE) and type (HELLO_MESSAGE_TYPE). 82 enum { 83 HELLO_MESSAGE_TYPE = kuint16max // Maximum value of message type (uint16), 84 // to avoid conflicting with normal 85 // message types, which are enumeration 86 // constants starting from 0. 87 }; 88 89 // The maximum message size in bytes. Attempting to receive a message of this 90 // size or bigger results in a channel error. 91 static const size_t kMaximumMessageSize = 128 * 1024 * 1024; 92 93 // Amount of data to read at once from the pipe. 94 static const size_t kReadBufferSize = 4 * 1024; 95 96 // Initialize a Channel. 97 // 98 // |channel_handle| identifies the communication Channel. For POSIX, if 99 // the file descriptor in the channel handle is != -1, the channel takes 100 // ownership of the file descriptor and will close it appropriately, otherwise 101 // it will create a new descriptor internally. 102 // |mode| specifies whether this Channel is to operate in server mode or 103 // client mode. In server mode, the Channel is responsible for setting up the 104 // IPC object, whereas in client mode, the Channel merely connects to the 105 // already established IPC object. 106 // |listener| receives a callback on the current thread for each newly 107 // received message. 108 // 109 Channel(const IPC::ChannelHandle &channel_handle, Mode mode, 110 Listener* listener); 111 112 virtual ~Channel(); 113 114 // Connect the pipe. On the server side, this will initiate 115 // waiting for connections. On the client, it attempts to 116 // connect to a pre-existing pipe. Note, calling Connect() 117 // will not block the calling thread and may complete 118 // asynchronously. 119 bool Connect() WARN_UNUSED_RESULT; 120 121 // Close this Channel explicitly. May be called multiple times. 122 // On POSIX calling close on an IPC channel that listens for connections will 123 // cause it to close any accepted connections, and it will stop listening for 124 // new connections. If you just want to close the currently accepted 125 // connection and listen for new ones, use ResetToAcceptingConnectionState. 126 void Close(); 127 128 // Get the process ID for the connected peer. 129 // 130 // Returns base::kNullProcessId if the peer is not connected yet. Watch out 131 // for race conditions. You can easily get a channel to another process, but 132 // if your process has not yet processed the "hello" message from the remote 133 // side, this will fail. You should either make sure calling this is either 134 // in response to a message from the remote side (which guarantees that it's 135 // been connected), or you wait for the "connected" notification on the 136 // listener. 137 base::ProcessId peer_pid() const; 138 139 // Send a message over the Channel to the listener on the other end. 140 // 141 // |message| must be allocated using operator new. This object will be 142 // deleted once the contents of the Message have been sent. 143 virtual bool Send(Message* message) OVERRIDE; 144 145 #if defined(OS_POSIX) 146 // On POSIX an IPC::Channel wraps a socketpair(), this method returns the 147 // FD # for the client end of the socket. 148 // This method may only be called on the server side of a channel. 149 // This method can be called on any thread. 150 int GetClientFileDescriptor() const; 151 152 // Same as GetClientFileDescriptor, but transfers the ownership of the 153 // file descriptor to the caller. 154 // This method can be called on any thread. 155 int TakeClientFileDescriptor(); 156 157 // On POSIX an IPC::Channel can either wrap an established socket, or it 158 // can wrap a socket that is listening for connections. Currently an 159 // IPC::Channel that listens for connections can only accept one connection 160 // at a time. 161 162 // Returns true if the channel supports listening for connections. 163 bool AcceptsConnections() const; 164 165 // Returns true if the channel supports listening for connections and is 166 // currently connected. 167 bool HasAcceptedConnection() const; 168 169 // Returns true if the peer process' effective user id can be determined, in 170 // which case the supplied peer_euid is updated with it. 171 bool GetPeerEuid(uid_t* peer_euid) const; 172 173 // Closes any currently connected socket, and returns to a listening state 174 // for more connections. 175 void ResetToAcceptingConnectionState(); 176 #endif // defined(OS_POSIX) && !defined(OS_NACL) 177 178 // Returns true if a named server channel is initialized on the given channel 179 // ID. Even if true, the server may have already accepted a connection. 180 static bool IsNamedServerInitialized(const std::string& channel_id); 181 182 #if !defined(OS_NACL) 183 // Generates a channel ID that's non-predictable and unique. 184 static std::string GenerateUniqueRandomChannelID(); 185 186 // Generates a channel ID that, if passed to the client as a shared secret, 187 // will validate that the client's authenticity. On platforms that do not 188 // require additional this is simply calls GenerateUniqueRandomChannelID(). 189 // For portability the prefix should not include the \ character. 190 static std::string GenerateVerifiedChannelID(const std::string& prefix); 191 #endif 192 193 #if defined(OS_LINUX) 194 // Sandboxed processes live in a PID namespace, so when sending the IPC hello 195 // message from client to server we need to send the PID from the global 196 // PID namespace. 197 static void SetGlobalPid(int pid); 198 #endif 199 200 protected: 201 // Used in Chrome by the TestSink to provide a dummy channel implementation 202 // for testing. TestSink overrides the "interesting" functions in Channel so 203 // no actual implementation is needed. This will cause un-overridden calls to 204 // segfault. Do not use outside of test code! 205 Channel() : channel_impl_(0) { } 206 207 private: 208 // PIMPL to which all channel calls are delegated. 209 class ChannelImpl; 210 ChannelImpl *channel_impl_; 211 }; 212 213 } // namespace IPC 214 215 #endif // IPC_IPC_CHANNEL_H_ 216
