// Copyright (c) 2012 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. #ifndef IPC_IPC_MESSAGE_H_ #define IPC_IPC_MESSAGE_H_ #include #include #include #include "base/gtest_prod_util.h" #include "base/memory/ref_counted.h" #include "base/pickle.h" #include "build/build_config.h" #include "ipc/ipc_buildflags.h" #include "ipc/ipc_message_support_export.h" namespace mojo { namespace internal { struct UnmappedNativeStructSerializerImpl; } } // namespace mojo namespace IPC { namespace internal { class ChannelReader; } // namespace internal //------------------------------------------------------------------------------ struct LogData; class MessageAttachmentSet; class IPC_MESSAGE_SUPPORT_EXPORT Message : public base::Pickle { public: enum PriorityValue { PRIORITY_LOW = 1, PRIORITY_NORMAL, PRIORITY_HIGH }; // Bit values used in the flags field. // Upper 24 bits of flags store a reference number, so this enum is limited to // 8 bits. enum { PRIORITY_MASK = 0x03, // Low 2 bits of store the priority value. SYNC_BIT = 0x04, REPLY_BIT = 0x08, REPLY_ERROR_BIT = 0x10, UNBLOCK_BIT = 0x20, PUMPING_MSGS_BIT = 0x40, // Deprecated. HAS_SENT_TIME_BIT = 0x80, }; ~Message() override; Message(); // Initialize a message with a user-defined type, priority value, and // destination WebView ID. Message(int32_t routing_id, uint32_t type, PriorityValue priority); // Initializes a message from a const block of data. The data is not copied; // instead the data is merely referenced by this message. Only const methods // should be used on the message when initialized this way. Message(const char* data, size_t data_len); Message(const Message& other); Message& operator=(const Message& other); bool IsValid() const { return header_size() == sizeof(Header) && header(); } PriorityValue priority() const { return static_cast(header()->flags & PRIORITY_MASK); } // True if this is a synchronous message. void set_sync() { header()->flags |= SYNC_BIT; } bool is_sync() const { return (header()->flags & SYNC_BIT) != 0; } // Set this on a reply to a synchronous message. void set_reply() { header()->flags |= REPLY_BIT; } bool is_reply() const { return (header()->flags & REPLY_BIT) != 0; } // Set this on a reply to a synchronous message to indicate that no receiver // was found. void set_reply_error() { header()->flags |= REPLY_ERROR_BIT; } bool is_reply_error() const { return (header()->flags & REPLY_ERROR_BIT) != 0; } // Normally when a receiver gets a message and they're blocked on a // synchronous message Send, they buffer a message. Setting this flag causes // the receiver to be unblocked and the message to be dispatched immediately. void set_unblock(bool unblock) { if (unblock) { header()->flags |= UNBLOCK_BIT; } else { header()->flags &= static_cast(~UNBLOCK_BIT); } } bool should_unblock() const { return (header()->flags & UNBLOCK_BIT) != 0; } void set_dispatch_error() const { dispatch_error_ = true; } bool dispatch_error() const { return dispatch_error_; } uint32_t type() const { return header()->type; } int32_t routing_id() const { return header()->routing; } void set_routing_id(int32_t new_id) { header()->routing = new_id; } uint32_t flags() const { return header()->flags; } // Sets all the given header values. The message should be empty at this // call. void SetHeaderValues(int32_t routing, uint32_t type, uint32_t flags); template static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter, void (T::*func)()) { (obj->*func)(); return true; } template static bool Dispatch(const Message* msg, T* obj, S* sender, P* parameter, void (T::*func)(P*)) { (obj->*func)(parameter); return true; } // Used for async messages with no parameters. static void Log(std::string* name, const Message* msg, std::string* l) { } // The static method FindNext() returns several pieces of information, which // are aggregated into an instance of this struct. struct IPC_MESSAGE_SUPPORT_EXPORT NextMessageInfo { NextMessageInfo(); ~NextMessageInfo(); // Total message size. Always valid if |message_found| is true. // If |message_found| is false but we could determine message size // from the header, this field is non-zero. Otherwise it's zero. size_t message_size; // Whether an entire message was found in the given memory range. bool message_found; // Only filled in if |message_found| is true. // The start address is passed into FindNext() by the caller, so isn't // repeated in this struct. The end address of the pickle should be used to // construct a base::Pickle. const char* pickle_end; // Only filled in if |message_found| is true. // The end address of the message should be used to determine the start // address of the next message. const char* message_end; }; // |info| is an output parameter and must not be nullptr. static void FindNext(const char* range_start, const char* range_end, NextMessageInfo* info); // WriteAttachment appends |attachment| to the end of the set. It returns // false iff the set is full. bool WriteAttachment( scoped_refptr attachment) override; // ReadAttachment parses an attachment given the parsing state |iter| and // writes it to |*attachment|. It returns true on success. bool ReadAttachment( base::PickleIterator* iter, scoped_refptr* attachment) const override; // Returns true if there are any attachment in this message. bool HasAttachments() const override; #if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED) // Adds the outgoing time from Time::Now() at the end of the message and sets // a bit to indicate that it's been added. void set_sent_time(int64_t time); int64_t sent_time() const; void set_received_time(int64_t time) const; int64_t received_time() const { return received_time_; } void set_output_params(const std::string& op) const { output_params_ = op; } const std::string& output_params() const { return output_params_; } // The following four functions are needed so we can log sync messages with // delayed replies. We stick the log data from the sent message into the // reply message, so that when it's sent and we have the output parameters // we can log it. As such, we set a flag on the sent message to not log it. void set_sync_log_data(LogData* data) const { log_data_ = data; } LogData* sync_log_data() const { return log_data_; } void set_dont_log() const { dont_log_ = true; } bool dont_log() const { return dont_log_; } #endif protected: friend class Channel; friend class ChannelMojo; friend class ChannelNacl; friend class ChannelPosix; friend class ChannelWin; friend class internal::ChannelReader; friend class MessageReplyDeserializer; friend class SyncMessage; friend struct mojo::internal::UnmappedNativeStructSerializerImpl; #pragma pack(push, 4) struct Header : base::Pickle::Header { int32_t routing; // ID of the view that this message is destined for uint32_t type; // specifies the user-defined message type uint32_t flags; // specifies control flags for the message #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA) uint16_t num_fds; // the number of descriptors included with this message uint16_t pad; // explicitly initialize this to appease valgrind #endif }; #pragma pack(pop) Header* header() { return headerT
(); } const Header* header() const { return headerT
(); } void Init(); // Used internally to support IPC::Listener::OnBadMessageReceived. mutable bool dispatch_error_; // The set of file descriptors associated with this message. scoped_refptr attachment_set_; // Ensure that a MessageAttachmentSet is allocated void EnsureMessageAttachmentSet(); MessageAttachmentSet* attachment_set() { EnsureMessageAttachmentSet(); return attachment_set_.get(); } const MessageAttachmentSet* attachment_set() const { return attachment_set_.get(); } #if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED) // Used for logging. mutable int64_t received_time_; mutable std::string output_params_; mutable LogData* log_data_; mutable bool dont_log_; #endif FRIEND_TEST_ALL_PREFIXES(IPCMessageTest, FindNext); FRIEND_TEST_ALL_PREFIXES(IPCMessageTest, FindNextOverflow); }; //------------------------------------------------------------------------------ } // namespace IPC enum SpecialRoutingIDs { // indicates that we don't have a routing ID yet. MSG_ROUTING_NONE = -2, // indicates a general message not sent to a particular tab. MSG_ROUTING_CONTROL = INT32_MAX, }; #define IPC_REPLY_ID 0xFFFFFFF0 // Special message id for replies #define IPC_LOGGING_ID 0xFFFFFFF1 // Special message id for logging #endif // IPC_IPC_MESSAGE_H_