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_MESSAGE_H_
6#define IPC_IPC_MESSAGE_H_
7
8#include <string>
9
10#include "base/basictypes.h"
11#include "base/debug/trace_event.h"
12#include "base/files/file.h"
13#include "base/pickle.h"
14#include "ipc/ipc_export.h"
15
16#if !defined(NDEBUG)
17#define IPC_MESSAGE_LOG_ENABLED
18#endif
19
20#if defined(OS_POSIX)
21#include "base/memory/ref_counted.h"
22#endif
23
24class FileDescriptorSet;
25
26namespace IPC {
27
28//------------------------------------------------------------------------------
29
30struct LogData;
31
32class IPC_EXPORT Message : public Pickle {
33 public:
34  enum PriorityValue {
35    PRIORITY_LOW = 1,
36    PRIORITY_NORMAL,
37    PRIORITY_HIGH
38  };
39
40  // Bit values used in the flags field.
41  // Upper 24 bits of flags store a reference number, so this enum is limited to
42  // 8 bits.
43  enum {
44    PRIORITY_MASK     = 0x03,  // Low 2 bits of store the priority value.
45    SYNC_BIT          = 0x04,
46    REPLY_BIT         = 0x08,
47    REPLY_ERROR_BIT   = 0x10,
48    UNBLOCK_BIT       = 0x20,
49    PUMPING_MSGS_BIT  = 0x40,
50    HAS_SENT_TIME_BIT = 0x80,
51  };
52
53  virtual ~Message();
54
55  Message();
56
57  // Initialize a message with a user-defined type, priority value, and
58  // destination WebView ID.
59  Message(int32 routing_id, uint32 type, PriorityValue priority);
60
61  // Initializes a message from a const block of data.  The data is not copied;
62  // instead the data is merely referenced by this message.  Only const methods
63  // should be used on the message when initialized this way.
64  Message(const char* data, int data_len);
65
66  Message(const Message& other);
67  Message& operator=(const Message& other);
68
69  PriorityValue priority() const {
70    return static_cast<PriorityValue>(header()->flags & PRIORITY_MASK);
71  }
72
73  // True if this is a synchronous message.
74  void set_sync() {
75    header()->flags |= SYNC_BIT;
76  }
77  bool is_sync() const {
78    return (header()->flags & SYNC_BIT) != 0;
79  }
80
81  // Set this on a reply to a synchronous message.
82  void set_reply() {
83    header()->flags |= REPLY_BIT;
84  }
85
86  bool is_reply() const {
87    return (header()->flags & REPLY_BIT) != 0;
88  }
89
90  // Set this on a reply to a synchronous message to indicate that no receiver
91  // was found.
92  void set_reply_error() {
93    header()->flags |= REPLY_ERROR_BIT;
94  }
95
96  bool is_reply_error() const {
97    return (header()->flags & REPLY_ERROR_BIT) != 0;
98  }
99
100  // Normally when a receiver gets a message and they're blocked on a
101  // synchronous message Send, they buffer a message.  Setting this flag causes
102  // the receiver to be unblocked and the message to be dispatched immediately.
103  void set_unblock(bool unblock) {
104    if (unblock) {
105      header()->flags |= UNBLOCK_BIT;
106    } else {
107      header()->flags &= ~UNBLOCK_BIT;
108    }
109  }
110
111  bool should_unblock() const {
112    return (header()->flags & UNBLOCK_BIT) != 0;
113  }
114
115  // Tells the receiver that the caller is pumping messages while waiting
116  // for the result.
117  bool is_caller_pumping_messages() const {
118    return (header()->flags & PUMPING_MSGS_BIT) != 0;
119  }
120
121  void set_dispatch_error() const {
122    dispatch_error_ = true;
123  }
124
125  bool dispatch_error() const {
126    return dispatch_error_;
127  }
128
129  uint32 type() const {
130    return header()->type;
131  }
132
133  int32 routing_id() const {
134    return header()->routing;
135  }
136
137  void set_routing_id(int32 new_id) {
138    header()->routing = new_id;
139  }
140
141  uint32 flags() const {
142    return header()->flags;
143  }
144
145  // Sets all the given header values. The message should be empty at this
146  // call.
147  void SetHeaderValues(int32 routing, uint32 type, uint32 flags);
148
149  template<class T, class S, class P>
150  static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
151                       void (T::*func)()) {
152    (obj->*func)();
153    return true;
154  }
155
156  template<class T, class S, class P>
157  static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter,
158                       void (T::*func)(P*)) {
159    (obj->*func)(parameter);
160    return true;
161  }
162
163  // Used for async messages with no parameters.
164  static void Log(std::string* name, const Message* msg, std::string* l) {
165  }
166
167  // Find the end of the message data that starts at range_start.  Returns NULL
168  // if the entire message is not found in the given data range.
169  static const char* FindNext(const char* range_start, const char* range_end) {
170    return Pickle::FindNext(sizeof(Header), range_start, range_end);
171  }
172
173#if defined(OS_POSIX)
174  // On POSIX, a message supports reading / writing FileDescriptor objects.
175  // This is used to pass a file descriptor to the peer of an IPC channel.
176
177  // Add a descriptor to the end of the set. Returns false if the set is full.
178  bool WriteFile(base::ScopedFD descriptor);
179  bool WriteBorrowingFile(const base::PlatformFile& descriptor);
180
181  // Get a file descriptor from the message. Returns false on error.
182  //   iter: a Pickle iterator to the current location in the message.
183  bool ReadFile(PickleIterator* iter, base::ScopedFD* file) const;
184
185  // Returns true if there are any file descriptors in this message.
186  bool HasFileDescriptors() const;
187#endif
188
189#ifdef IPC_MESSAGE_LOG_ENABLED
190  // Adds the outgoing time from Time::Now() at the end of the message and sets
191  // a bit to indicate that it's been added.
192  void set_sent_time(int64 time);
193  int64 sent_time() const;
194
195  void set_received_time(int64 time) const;
196  int64 received_time() const { return received_time_; }
197  void set_output_params(const std::string& op) const { output_params_ = op; }
198  const std::string& output_params() const { return output_params_; }
199  // The following four functions are needed so we can log sync messages with
200  // delayed replies.  We stick the log data from the sent message into the
201  // reply message, so that when it's sent and we have the output parameters
202  // we can log it.  As such, we set a flag on the sent message to not log it.
203  void set_sync_log_data(LogData* data) const { log_data_ = data; }
204  LogData* sync_log_data() const { return log_data_; }
205  void set_dont_log() const { dont_log_ = true; }
206  bool dont_log() const { return dont_log_; }
207#endif
208
209  // Called to trace when message is sent.
210  void TraceMessageBegin() {
211    TRACE_EVENT_FLOW_BEGIN0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"), "IPC",
212        header()->flags);
213  }
214  // Called to trace when message is received.
215  void TraceMessageEnd() {
216    TRACE_EVENT_FLOW_END0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"), "IPC",
217        header()->flags);
218  }
219
220 protected:
221  friend class Channel;
222  friend class ChannelMojo;
223  friend class ChannelNacl;
224  friend class ChannelPosix;
225  friend class ChannelWin;
226  friend class MessageReplyDeserializer;
227  friend class SyncMessage;
228
229#pragma pack(push, 4)
230  struct Header : Pickle::Header {
231    int32 routing;  // ID of the view that this message is destined for
232    uint32 type;    // specifies the user-defined message type
233    uint32 flags;   // specifies control flags for the message
234#if defined(OS_POSIX)
235    uint16 num_fds; // the number of descriptors included with this message
236    uint16 pad;     // explicitly initialize this to appease valgrind
237#endif
238  };
239#pragma pack(pop)
240
241  Header* header() {
242    return headerT<Header>();
243  }
244  const Header* header() const {
245    return headerT<Header>();
246  }
247
248  void Init();
249
250  // Used internally to support IPC::Listener::OnBadMessageReceived.
251  mutable bool dispatch_error_;
252
253#if defined(OS_POSIX)
254  // The set of file descriptors associated with this message.
255  scoped_refptr<FileDescriptorSet> file_descriptor_set_;
256
257  // Ensure that a FileDescriptorSet is allocated
258  void EnsureFileDescriptorSet();
259
260  FileDescriptorSet* file_descriptor_set() {
261    EnsureFileDescriptorSet();
262    return file_descriptor_set_.get();
263  }
264  const FileDescriptorSet* file_descriptor_set() const {
265    return file_descriptor_set_.get();
266  }
267#endif
268
269#ifdef IPC_MESSAGE_LOG_ENABLED
270  // Used for logging.
271  mutable int64 received_time_;
272  mutable std::string output_params_;
273  mutable LogData* log_data_;
274  mutable bool dont_log_;
275#endif
276};
277
278//------------------------------------------------------------------------------
279
280}  // namespace IPC
281
282enum SpecialRoutingIDs {
283  // indicates that we don't have a routing ID yet.
284  MSG_ROUTING_NONE = -2,
285
286  // indicates a general message not sent to a particular tab.
287  MSG_ROUTING_CONTROL = kint32max,
288};
289
290#define IPC_REPLY_ID 0xFFFFFFF0  // Special message id for replies
291#define IPC_LOGGING_ID 0xFFFFFFF1  // Special message id for logging
292
293#endif  // IPC_IPC_MESSAGE_H_
294