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/files/file.h" 8#include "base/memory/shared_memory.h" 9#include "base/pickle.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 17namespace ppapi { 18namespace proxy { 19 20SerializedHandle::SerializedHandle() 21 : type_(INVALID), 22 shm_handle_(base::SharedMemory::NULLHandle()), 23 size_(0), 24 descriptor_(IPC::InvalidPlatformFileForTransit()), 25 open_flags_(0), 26 file_io_(0) { 27} 28 29SerializedHandle::SerializedHandle(Type type_param) 30 : type_(type_param), 31 shm_handle_(base::SharedMemory::NULLHandle()), 32 size_(0), 33 descriptor_(IPC::InvalidPlatformFileForTransit()), 34 open_flags_(0), 35 file_io_(0) { 36} 37 38SerializedHandle::SerializedHandle(const base::SharedMemoryHandle& handle, 39 uint32 size) 40 : type_(SHARED_MEMORY), 41 shm_handle_(handle), 42 size_(size), 43 descriptor_(IPC::InvalidPlatformFileForTransit()), 44 open_flags_(0), 45 file_io_(0) { 46} 47 48SerializedHandle::SerializedHandle( 49 Type type, 50 const IPC::PlatformFileForTransit& socket_descriptor) 51 : type_(type), 52 shm_handle_(base::SharedMemory::NULLHandle()), 53 size_(0), 54 descriptor_(socket_descriptor), 55 open_flags_(0), 56 file_io_(0) { 57} 58 59bool SerializedHandle::IsHandleValid() const { 60 switch (type_) { 61 case SHARED_MEMORY: 62 return base::SharedMemory::IsHandleValid(shm_handle_); 63 case SOCKET: 64 case FILE: 65 return !(IPC::InvalidPlatformFileForTransit() == descriptor_); 66 case INVALID: 67 return false; 68 // No default so the compiler will warn us if a new type is added. 69 } 70 return false; 71} 72 73void SerializedHandle::Close() { 74 if (IsHandleValid()) { 75 switch (type_) { 76 case INVALID: 77 NOTREACHED(); 78 break; 79 case SHARED_MEMORY: 80 base::SharedMemory::CloseHandle(shm_handle_); 81 break; 82 case SOCKET: 83 case FILE: 84 base::File file_closer = IPC::PlatformFileForTransitToFile(descriptor_); 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 93bool 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_flags) || !pickle->WriteInt(hdr.file_io)) 102 return false; 103 } 104 return true; 105} 106 107// static 108bool SerializedHandle::ReadHeader(PickleIterator* iter, Header* hdr) { 109 *hdr = Header(INVALID, 0, 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_flags = 0; 125 PP_Resource file_io = 0; 126 if (!iter->ReadInt(&open_flags) || !iter->ReadInt(&file_io)) 127 return false; 128 hdr->open_flags = open_flags; 129 hdr->file_io = file_io; 130 valid_type = true; 131 } 132 case SOCKET: 133 case INVALID: 134 valid_type = true; 135 break; 136 // No default so the compiler will warn us if a new type is added. 137 } 138 if (valid_type) 139 hdr->type = Type(type); 140 return valid_type; 141} 142 143} // namespace proxy 144} // namespace ppapi 145