ppapi/proxy/serialized_handle.cc

   1 // Copyright (c) 2013 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 "ppapi/proxy/serialized_handle.h"
   6
   7 #include "base/memory/shared_memory.h"
   8 #include "base/pickle.h"
   9 #include "base/platform_file.h"
  10 #include "build/build_config.h"
  11 #include "ipc/ipc_platform_file.h"
  12
  13 #if defined(OS_NACL)
  14 #include <unistd.h>
  15 #endif
  16
  17 namespace ppapi {
  18 namespace proxy {
  19
  20 SerializedHandle::SerializedHandle()
  21     : type_(INVALID),
  22       shm_handle_(base::SharedMemory::NULLHandle()),
  23       size_(0),
  24       descriptor_(IPC::InvalidPlatformFileForTransit()) {
  25 }
  26
  27 SerializedHandle::SerializedHandle(Type type_param)
  28     : type_(type_param),
  29       shm_handle_(base::SharedMemory::NULLHandle()),
  30       size_(0),
  31       descriptor_(IPC::InvalidPlatformFileForTransit()) {
  32 }
  33
  34 SerializedHandle::SerializedHandle(const base::SharedMemoryHandle& handle,
  35                                    uint32 size)
  36     : type_(SHARED_MEMORY),
  37       shm_handle_(handle),
  38       size_(size),
  39       descriptor_(IPC::InvalidPlatformFileForTransit()) {
  40 }
  41
  42 SerializedHandle::SerializedHandle(
  43     Type type,
  44     const IPC::PlatformFileForTransit& socket_descriptor)
  45     : type_(type),
  46       shm_handle_(base::SharedMemory::NULLHandle()),
  47       size_(0),
  48       descriptor_(socket_descriptor) {
  49 }
  50
  51 bool SerializedHandle::IsHandleValid() const {
  52   switch (type_) {
  53     case SHARED_MEMORY:
  54       return base::SharedMemory::IsHandleValid(shm_handle_);
  55     case SOCKET:
  56     case CHANNEL_HANDLE:
  57     case FILE:
  58       return !(IPC::InvalidPlatformFileForTransit() == descriptor_);
  59     case INVALID:
  60       return false;
  61     // No default so the compiler will warn us if a new type is added.
  62   }
  63   return false;
  64 }
  65
  66 void SerializedHandle::Close() {
  67   if (IsHandleValid()) {
  68     switch (type_) {
  69       case INVALID:
  70         NOTREACHED();
  71         break;
  72       case SHARED_MEMORY:
  73         base::SharedMemory::CloseHandle(shm_handle_);
  74         break;
  75       case SOCKET:
  76       case CHANNEL_HANDLE:
  77       case FILE:
  78         base::PlatformFile file =
  79             IPC::PlatformFileForTransitToPlatformFile(descriptor_);
  80 #if !defined(OS_NACL)
  81         base::ClosePlatformFile(file);
  82 #else
  83         close(file);
  84 #endif
  85         break;
  86       // No default so the compiler will warn us if a new type is added.
  87     }
  88   }
  89   *this = SerializedHandle();
  90 }
  91
  92 // static
  93 bool SerializedHandle::WriteHeader(const Header& hdr, Pickle* pickle) {
  94   if (!pickle->WriteInt(hdr.type))
  95     return false;
  96   if (hdr.type == SHARED_MEMORY) {
  97     if (!pickle->WriteUInt32(hdr.size))
  98       return false;
  99   }
 100   if (hdr.type == FILE) {
 101     if (!pickle->WriteInt(hdr.open_flag))
 102       return false;
 103   }
 104   return true;
 105 }
 106
 107 // static
 108 bool SerializedHandle::ReadHeader(PickleIterator* iter, Header* hdr) {
 109   *hdr = Header(INVALID, 0, 0);
 110   int type = 0;
 111   if (!iter->ReadInt(&type))
 112     return false;
 113   bool valid_type = false;
 114   switch (type) {
 115     case SHARED_MEMORY: {
 116       uint32 size = 0;
 117       if (!iter->ReadUInt32(&size))
 118         return false;
 119       hdr->size = size;
 120       valid_type = true;
 121       break;
 122     }
 123     case FILE: {
 124       int open_flag = 0;
 125       if (!iter->ReadInt(&open_flag))
 126         return false;
 127       hdr->open_flag = open_flag;
 128       valid_type = true;
 129     }
 130     case SOCKET:
 131     case CHANNEL_HANDLE:
 132     case INVALID:
 133       valid_type = true;
 134       break;
 135     // No default so the compiler will warn us if a new type is added.
 136   }
 137   if (valid_type)
 138     hdr->type = Type(type);
 139   return valid_type;
 140 }
 141
 142 }  // namespace proxy
 143 }  // namespace ppapi