pickle.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019
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 "base/pickle.h" 6 7#include <stdlib.h> 8 9#include <algorithm> // for max() 10 11//------------------------------------------------------------------------------ 12 13// static 14const int Pickle::kPayloadUnit = 64; 15 16static const size_t kCapacityReadOnly = static_cast<size_t>(-1); 17 18PickleIterator::PickleIterator(const Pickle& pickle) 19 : read_ptr_(pickle.payload()), 20 read_end_ptr_(pickle.end_of_payload()) { 21} 22 23template <typename Type> 24inline bool PickleIterator::ReadBuiltinType(Type* result) { 25 const char* read_from = GetReadPointerAndAdvance<Type>(); 26 if (!read_from) 27 return false; 28 if (sizeof(Type) > sizeof(uint32)) 29 memcpy(result, read_from, sizeof(*result)); 30 else 31 *result = *reinterpret_cast<const Type*>(read_from); 32 return true; 33} 34 35template<typename Type> 36inline const char* PickleIterator::GetReadPointerAndAdvance() { 37 const char* current_read_ptr = read_ptr_; 38 if (read_ptr_ + sizeof(Type) > read_end_ptr_) 39 return NULL; 40 if (sizeof(Type) < sizeof(uint32)) 41 read_ptr_ += AlignInt(sizeof(Type), sizeof(uint32)); 42 else 43 read_ptr_ += sizeof(Type); 44 return current_read_ptr; 45} 46 47const char* PickleIterator::GetReadPointerAndAdvance(int num_bytes) { 48 if (num_bytes < 0 || read_end_ptr_ - read_ptr_ < num_bytes) 49 return NULL; 50 const char* current_read_ptr = read_ptr_; 51 read_ptr_ += AlignInt(num_bytes, sizeof(uint32)); 52 return current_read_ptr; 53} 54 55inline const char* PickleIterator::GetReadPointerAndAdvance(int num_elements, 56 size_t size_element) { 57 // Check for int32 overflow. 58 int64 num_bytes = static_cast<int64>(num_elements) * size_element; 59 int num_bytes32 = static_cast<int>(num_bytes); 60 if (num_bytes != static_cast<int64>(num_bytes32)) 61 return NULL; 62 return GetReadPointerAndAdvance(num_bytes32); 63} 64 65bool PickleIterator::ReadBool(bool* result) { 66 return ReadBuiltinType(result); 67} 68 69bool PickleIterator::ReadInt(int* result) { 70 return ReadBuiltinType(result); 71} 72 73bool PickleIterator::ReadLong(long* result) { 74 return ReadBuiltinType(result); 75} 76 77bool PickleIterator::ReadUInt16(uint16* result) { 78 return ReadBuiltinType(result); 79} 80 81bool PickleIterator::ReadUInt32(uint32* result) { 82 return ReadBuiltinType(result); 83} 84 85bool PickleIterator::ReadInt64(int64* result) { 86 return ReadBuiltinType(result); 87} 88 89bool PickleIterator::ReadUInt64(uint64* result) { 90 return ReadBuiltinType(result); 91} 92 93bool PickleIterator::ReadString(std::string* result) { 94 int len; 95 if (!ReadInt(&len)) 96 return false; 97 const char* read_from = GetReadPointerAndAdvance(len); 98 if (!read_from) 99 return false; 100 101 result->assign(read_from, len); 102 return true; 103} 104 105bool PickleIterator::ReadWString(std::wstring* result) { 106 int len; 107 if (!ReadInt(&len)) 108 return false; 109 const char* read_from = GetReadPointerAndAdvance(len, sizeof(wchar_t)); 110 if (!read_from) 111 return false; 112 113 result->assign(reinterpret_cast<const wchar_t*>(read_from), len); 114 return true; 115} 116 117bool PickleIterator::ReadString16(string16* result) { 118 int len; 119 if (!ReadInt(&len)) 120 return false; 121 const char* read_from = GetReadPointerAndAdvance(len, sizeof(char16)); 122 if (!read_from) 123 return false; 124 125 result->assign(reinterpret_cast<const char16*>(read_from), len); 126 return true; 127} 128 129bool PickleIterator::ReadData(const char** data, int* length) { 130 *length = 0; 131 *data = 0; 132 133 if (!ReadInt(length)) 134 return false; 135 136 return ReadBytes(data, *length); 137} 138 139bool PickleIterator::ReadBytes(const char** data, int length) { 140 const char* read_from = GetReadPointerAndAdvance(length); 141 if (!read_from) 142 return false; 143 *data = read_from; 144 return true; 145} 146 147// Payload is uint32 aligned. 148 149Pickle::Pickle() 150 : header_(NULL), 151 header_size_(sizeof(Header)), 152 capacity_(0), 153 variable_buffer_offset_(0) { 154 Resize(kPayloadUnit); 155 header_->payload_size = 0; 156} 157 158Pickle::Pickle(int header_size) 159 : header_(NULL), 160 header_size_(AlignInt(header_size, sizeof(uint32))), 161 capacity_(0), 162 variable_buffer_offset_(0) { 163 DCHECK_GE(static_cast<size_t>(header_size), sizeof(Header)); 164 DCHECK_LE(header_size, kPayloadUnit); 165 Resize(kPayloadUnit); 166 header_->payload_size = 0; 167} 168 169Pickle::Pickle(const char* data, int data_len) 170 : header_(reinterpret_cast<Header*>(const_cast<char*>(data))), 171 header_size_(0), 172 capacity_(kCapacityReadOnly), 173 variable_buffer_offset_(0) { 174 if (data_len >= static_cast<int>(sizeof(Header))) 175 header_size_ = data_len - header_->payload_size; 176 177 if (header_size_ > static_cast<unsigned int>(data_len)) 178 header_size_ = 0; 179 180 if (header_size_ != AlignInt(header_size_, sizeof(uint32))) 181 header_size_ = 0; 182 183 // If there is anything wrong with the data, we're not going to use it. 184 if (!header_size_) 185 header_ = NULL; 186} 187 188Pickle::Pickle(const Pickle& other) 189 : header_(NULL), 190 header_size_(other.header_size_), 191 capacity_(0), 192 variable_buffer_offset_(other.variable_buffer_offset_) { 193 size_t payload_size = header_size_ + other.header_->payload_size; 194 bool resized = Resize(payload_size); 195 CHECK(resized); // Realloc failed. 196 memcpy(header_, other.header_, payload_size); 197} 198 199Pickle::~Pickle() { 200 if (capacity_ != kCapacityReadOnly) 201 free(header_); 202} 203 204Pickle& Pickle::operator=(const Pickle& other) { 205 if (this == &other) { 206 NOTREACHED(); 207 return *this; 208 } 209 if (capacity_ == kCapacityReadOnly) { 210 header_ = NULL; 211 capacity_ = 0; 212 } 213 if (header_size_ != other.header_size_) { 214 free(header_); 215 header_ = NULL; 216 header_size_ = other.header_size_; 217 } 218 bool resized = Resize(other.header_size_ + other.header_->payload_size); 219 CHECK(resized); // Realloc failed. 220 memcpy(header_, other.header_, 221 other.header_size_ + other.header_->payload_size); 222 variable_buffer_offset_ = other.variable_buffer_offset_; 223 return *this; 224} 225 226bool Pickle::WriteString(const std::string& value) { 227 if (!WriteInt(static_cast<int>(value.size()))) 228 return false; 229 230 return WriteBytes(value.data(), static_cast<int>(value.size())); 231} 232 233bool Pickle::WriteWString(const std::wstring& value) { 234 if (!WriteInt(static_cast<int>(value.size()))) 235 return false; 236 237 return WriteBytes(value.data(), 238 static_cast<int>(value.size() * sizeof(wchar_t))); 239} 240 241bool Pickle::WriteString16(const string16& value) { 242 if (!WriteInt(static_cast<int>(value.size()))) 243 return false; 244 245 return WriteBytes(value.data(), 246 static_cast<int>(value.size()) * sizeof(char16)); 247} 248 249bool Pickle::WriteData(const char* data, int length) { 250 return length >= 0 && WriteInt(length) && WriteBytes(data, length); 251} 252 253bool Pickle::WriteBytes(const void* data, int data_len) { 254 DCHECK_NE(kCapacityReadOnly, capacity_) << "oops: pickle is readonly"; 255 256 char* dest = BeginWrite(data_len); 257 if (!dest) 258 return false; 259 260 memcpy(dest, data, data_len); 261 262 EndWrite(dest, data_len); 263 return true; 264} 265 266char* Pickle::BeginWriteData(int length) { 267 DCHECK_EQ(variable_buffer_offset_, 0U) << 268 "There can only be one variable buffer in a Pickle"; 269 270 if (length < 0 || !WriteInt(length)) 271 return NULL; 272 273 char *data_ptr = BeginWrite(length); 274 if (!data_ptr) 275 return NULL; 276 277 variable_buffer_offset_ = 278 data_ptr - reinterpret_cast<char*>(header_) - sizeof(int); 279 280 // EndWrite doesn't necessarily have to be called after the write operation, 281 // so we call it here to pad out what the caller will eventually write. 282 EndWrite(data_ptr, length); 283 return data_ptr; 284} 285 286void Pickle::TrimWriteData(int new_length) { 287 DCHECK_NE(variable_buffer_offset_, 0U); 288 289 // Fetch the the variable buffer size 290 int* cur_length = reinterpret_cast<int*>( 291 reinterpret_cast<char*>(header_) + variable_buffer_offset_); 292 293 if (new_length < 0 || new_length > *cur_length) { 294 NOTREACHED() << "Invalid length in TrimWriteData."; 295 return; 296 } 297 298 // Update the payload size and variable buffer size 299 header_->payload_size -= (*cur_length - new_length); 300 *cur_length = new_length; 301} 302 303char* Pickle::BeginWrite(size_t length) { 304 // write at a uint32-aligned offset from the beginning of the header 305 size_t offset = AlignInt(header_->payload_size, sizeof(uint32)); 306 307 size_t new_size = offset + length; 308 size_t needed_size = header_size_ + new_size; 309 if (needed_size > capacity_ && !Resize(std::max(capacity_ * 2, needed_size))) 310 return NULL; 311 312#ifdef ARCH_CPU_64_BITS 313 DCHECK_LE(length, kuint32max); 314#endif 315 316 header_->payload_size = static_cast<uint32>(new_size); 317 return payload() + offset; 318} 319 320void Pickle::EndWrite(char* dest, int length) { 321 // Zero-pad to keep tools like valgrind from complaining about uninitialized 322 // memory. 323 if (length % sizeof(uint32)) 324 memset(dest + length, 0, sizeof(uint32) - (length % sizeof(uint32))); 325} 326 327bool Pickle::Resize(size_t new_capacity) { 328 new_capacity = AlignInt(new_capacity, kPayloadUnit); 329 330 CHECK_NE(capacity_, kCapacityReadOnly); 331 void* p = realloc(header_, new_capacity); 332 if (!p) 333 return false; 334 335 header_ = reinterpret_cast<Header*>(p); 336 capacity_ = new_capacity; 337 return true; 338} 339 340// static 341const char* Pickle::FindNext(size_t header_size, 342 const char* start, 343 const char* end) { 344 DCHECK_EQ(header_size, AlignInt(header_size, sizeof(uint32))); 345 DCHECK_LE(header_size, static_cast<size_t>(kPayloadUnit)); 346 347 if (static_cast<size_t>(end - start) < sizeof(Header)) 348 return NULL; 349 350 const Header* hdr = reinterpret_cast<const Header*>(start); 351 const char* payload_base = start + header_size; 352 const char* payload_end = payload_base + hdr->payload_size; 353 if (payload_end < payload_base) 354 return NULL; 355 356 return (payload_end > end) ? NULL : payload_end; 357} 358