Home | History | Annotate | Download | only in ipc 
      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/atomicops.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::subtle::Atomic32 g_ref_num = 0;
     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 = base::subtle::NoBarrier_AtomicIncrement(&g_ref_num, 1);
     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 << 22) | (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   InitLoggingVariables();
     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   InitLoggingVariables();
     64 }
     65 
     66 Message::Message(const char* data, int data_len) : Pickle(data, data_len) {
     67   InitLoggingVariables();
     68 }
     69 
     70 Message::Message(const Message& other) : Pickle(other) {
     71   InitLoggingVariables();
     72 #if defined(OS_POSIX)
     73   file_descriptor_set_ = other.file_descriptor_set_;
     74 #endif
     75 }
     76 
     77 void Message::InitLoggingVariables() {
     78 #ifdef IPC_MESSAGE_LOG_ENABLED
     79   received_time_ = 0;
     80   dont_log_ = false;
     81   log_data_ = NULL;
     82 #endif
     83 }
     84 
     85 Message& Message::operator=(const Message& other) {
     86   *static_cast<Pickle*>(this) = other;
     87 #if defined(OS_POSIX)
     88   file_descriptor_set_ = other.file_descriptor_set_;
     89 #endif
     90   return *this;
     91 }
     92 
     93 void Message::SetHeaderValues(int32 routing, uint32 type, uint32 flags) {
     94   // This should only be called when the message is already empty.
     95   DCHECK(payload_size() == 0);
     96 
     97   header()->routing = routing;
     98   header()->type = type;
     99   header()->flags = flags;
    100 }
    101 
    102 #ifdef IPC_MESSAGE_LOG_ENABLED
    103 void Message::set_sent_time(int64 time) {
    104   DCHECK((header()->flags & HAS_SENT_TIME_BIT) == 0);
    105   header()->flags |= HAS_SENT_TIME_BIT;
    106   WriteInt64(time);
    107 }
    108 
    109 int64 Message::sent_time() const {
    110   if ((header()->flags & HAS_SENT_TIME_BIT) == 0)
    111     return 0;
    112 
    113   const char* data = end_of_payload();
    114   data -= sizeof(int64);
    115   return *(reinterpret_cast<const int64*>(data));
    116 }
    117 
    118 void Message::set_received_time(int64 time) const {
    119   received_time_ = time;
    120 }
    121 #endif
    122 
    123 #if defined(OS_POSIX)
    124 bool Message::WriteFileDescriptor(const base::FileDescriptor& descriptor) {
    125   // We write the index of the descriptor so that we don't have to
    126   // keep the current descriptor as extra decoding state when deserialising.
    127   WriteInt(file_descriptor_set()->size());
    128   if (descriptor.auto_close) {
    129     return file_descriptor_set()->AddAndAutoClose(descriptor.fd);
    130   } else {
    131     return file_descriptor_set()->Add(descriptor.fd);
    132   }
    133 }
    134 
    135 bool Message::ReadFileDescriptor(PickleIterator* iter,
    136                                  base::FileDescriptor* descriptor) const {
    137   int descriptor_index;
    138   if (!ReadInt(iter, &descriptor_index))
    139     return false;
    140 
    141   FileDescriptorSet* file_descriptor_set = file_descriptor_set_.get();
    142   if (!file_descriptor_set)
    143     return false;
    144 
    145   descriptor->fd = file_descriptor_set->GetDescriptorAt(descriptor_index);
    146   descriptor->auto_close = true;
    147 
    148   return descriptor->fd >= 0;
    149 }
    150 
    151 bool Message::HasFileDescriptors() const {
    152   return file_descriptor_set_.get() && !file_descriptor_set_->empty();
    153 }
    154 
    155 void Message::EnsureFileDescriptorSet() {
    156   if (file_descriptor_set_.get() == NULL)
    157     file_descriptor_set_ = new FileDescriptorSet;
    158 }
    159 
    160 #endif
    161 
    162 }  // namespace IPC
    163