ipc/ipc_message.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 "ipc/ipc_message.h"
   6
   7 #include "base/atomic_sequence_num.h"
   8 #include "base/logging.h"
   9 #include "build/build_config.h"
  10
  11 #if defined(OS_POSIX)
  12 #include "ipc/file_descriptor_set_posix.h"
  13 #endif
  14
  15 namespace {
  16
  17 base::StaticAtomicSequenceNumber g_ref_num;
  18
  19 // Create a reference number for identifying IPC messages in traces. The return
  20 // values has the reference number stored in the upper 24 bits, leaving the low
  21 // 8 bits set to 0 for use as flags.
  22 inline uint32 GetRefNumUpper24() {
  23   base::debug::TraceLog* trace_log = base::debug::TraceLog::GetInstance();
  24   int32 pid = trace_log ? trace_log->process_id() : 0;
  25   int32 count = g_ref_num.GetNext();
  26   // The 24 bit hash is composed of 14 bits of the count and 10 bits of the
  27   // Process ID. With the current trace event buffer cap, the 14-bit count did
  28   // not appear to wrap during a trace. Note that it is not a big deal if
  29   // collisions occur, as this is only used for debugging and trace analysis.
  30   return ((pid << 14) | (count & 0x3fff)) << 8;
  31 }
  32
  33 }  // namespace
  34
  35 namespace IPC {
  36
  37 //------------------------------------------------------------------------------
  38
  39 Message::~Message() {
  40 }
  41
  42 Message::Message()
  43     : Pickle(sizeof(Header)) {
  44   header()->routing = header()->type = 0;
  45   header()->flags = GetRefNumUpper24();
  46 #if defined(OS_POSIX)
  47   header()->num_fds = 0;
  48   header()->pad = 0;
  49 #endif
  50   Init();
  51 }
  52
  53 Message::Message(int32 routing_id, uint32 type, PriorityValue priority)
  54     : Pickle(sizeof(Header)) {
  55   header()->routing = routing_id;
  56   header()->type = type;
  57   DCHECK((priority & 0xffffff00) == 0);
  58   header()->flags = priority | GetRefNumUpper24();
  59 #if defined(OS_POSIX)
  60   header()->num_fds = 0;
  61   header()->pad = 0;
  62 #endif
  63   Init();
  64 }
  65
  66 Message::Message(const char* data, int data_len) : Pickle(data, data_len) {
  67   Init();
  68 }
  69
  70 Message::Message(const Message& other) : Pickle(other) {
  71   Init();
  72 #if defined(OS_POSIX)
  73   file_descriptor_set_ = other.file_descriptor_set_;
  74 #endif
  75 }
  76
  77 void Message::Init() {
  78   dispatch_error_ = false;
  79 #ifdef IPC_MESSAGE_LOG_ENABLED
  80   received_time_ = 0;
  81   dont_log_ = false;
  82   log_data_ = NULL;
  83 #endif
  84 }
  85
  86 Message& Message::operator=(const Message& other) {
  87   *static_cast<Pickle*>(this) = other;
  88 #if defined(OS_POSIX)
  89   file_descriptor_set_ = other.file_descriptor_set_;
  90 #endif
  91   return *this;
  92 }
  93
  94 void Message::SetHeaderValues(int32 routing, uint32 type, uint32 flags) {
  95   // This should only be called when the message is already empty.
  96   DCHECK(payload_size() == 0);
  97
  98   header()->routing = routing;
  99   header()->type = type;
 100   header()->flags = flags;
 101 }
 102
 103 #ifdef IPC_MESSAGE_LOG_ENABLED
 104 void Message::set_sent_time(int64 time) {
 105   DCHECK((header()->flags & HAS_SENT_TIME_BIT) == 0);
 106   header()->flags |= HAS_SENT_TIME_BIT;
 107   WriteInt64(time);
 108 }
 109
 110 int64 Message::sent_time() const {
 111   if ((header()->flags & HAS_SENT_TIME_BIT) == 0)
 112     return 0;
 113
 114   const char* data = end_of_payload();
 115   data -= sizeof(int64);
 116   return *(reinterpret_cast<const int64*>(data));
 117 }
 118
 119 void Message::set_received_time(int64 time) const {
 120   received_time_ = time;
 121 }
 122 #endif
 123
 124 #if defined(OS_POSIX)
 125 bool Message::WriteFileDescriptor(const base::FileDescriptor& descriptor) {
 126   // We write the index of the descriptor so that we don't have to
 127   // keep the current descriptor as extra decoding state when deserialising.
 128   WriteInt(file_descriptor_set()->size());
 129   if (descriptor.auto_close) {
 130     return file_descriptor_set()->AddAndAutoClose(descriptor.fd);
 131   } else {
 132     return file_descriptor_set()->Add(descriptor.fd);
 133   }
 134 }
 135
 136 bool Message::ReadFileDescriptor(PickleIterator* iter,
 137                                  base::FileDescriptor* descriptor) const {
 138   int descriptor_index;
 139   if (!ReadInt(iter, &descriptor_index))
 140     return false;
 141
 142   FileDescriptorSet* file_descriptor_set = file_descriptor_set_.get();
 143   if (!file_descriptor_set)
 144     return false;
 145
 146   descriptor->fd = file_descriptor_set->GetDescriptorAt(descriptor_index);
 147   descriptor->auto_close = true;
 148
 149   return descriptor->fd >= 0;
 150 }
 151
 152 bool Message::HasFileDescriptors() const {
 153   return file_descriptor_set_.get() && !file_descriptor_set_->empty();
 154 }
 155
 156 void Message::EnsureFileDescriptorSet() {
 157   if (file_descriptor_set_.get() == NULL)
 158     file_descriptor_set_ = new FileDescriptorSet;
 159 }
 160
 161 #endif
 162
 163 }  // namespace IPC