summaryrefslogtreecommitdiffstats
path: root/ipc/chromium/src/base/pickle.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /ipc/chromium/src/base/pickle.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'ipc/chromium/src/base/pickle.h')
-rw-r--r--ipc/chromium/src/base/pickle.h326
1 files changed, 326 insertions, 0 deletions
diff --git a/ipc/chromium/src/base/pickle.h b/ipc/chromium/src/base/pickle.h
new file mode 100644
index 000000000..d031f6124
--- /dev/null
+++ b/ipc/chromium/src/base/pickle.h
@@ -0,0 +1,326 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PICKLE_H__
+#define BASE_PICKLE_H__
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/string16.h"
+
+#include "mozilla/Attributes.h"
+#include "mozilla/BufferList.h"
+#include "mozilla/mozalloc.h"
+
+#ifdef MOZ_FAULTY
+#include "base/singleton.h"
+#include "mozilla/ipc/Faulty.h"
+#endif
+
+#if !defined(RELEASE_OR_BETA) || defined(DEBUG)
+#define MOZ_PICKLE_SENTINEL_CHECKING
+#endif
+
+class Pickle;
+
+class PickleIterator {
+public:
+ explicit PickleIterator(const Pickle& pickle);
+
+private:
+ friend class Pickle;
+
+ mozilla::BufferList<InfallibleAllocPolicy>::IterImpl iter_;
+
+ template<typename T>
+ void CopyInto(T* dest);
+};
+
+// This class provides facilities for basic binary value packing and unpacking.
+//
+// The Pickle class supports appending primitive values (ints, strings, etc.)
+// to a pickle instance. The Pickle instance grows its internal memory buffer
+// dynamically to hold the sequence of primitive values. The internal memory
+// buffer is exposed as the "data" of the Pickle. This "data" can be passed
+// to a Pickle object to initialize it for reading.
+//
+// When reading from a Pickle object, it is important for the consumer to know
+// what value types to read and in what order to read them as the Pickle does
+// not keep track of the type of data written to it.
+//
+// The Pickle's data has a header which contains the size of the Pickle's
+// payload. It can optionally support additional space in the header. That
+// space is controlled by the header_size parameter passed to the Pickle
+// constructor.
+//
+class Pickle {
+ public:
+ ~Pickle();
+
+ Pickle() = delete;
+
+ // Initialize a Pickle object with the specified header size in bytes, which
+ // must be greater-than-or-equal-to sizeof(Pickle::Header). The header size
+ // will be rounded up to ensure that the header size is 32bit-aligned.
+ explicit Pickle(uint32_t header_size);
+
+ Pickle(uint32_t header_size, const char* data, uint32_t length);
+
+ Pickle(const Pickle& other) = delete;
+
+ Pickle(Pickle&& other);
+
+ // Performs a deep copy.
+ Pickle& operator=(const Pickle& other) = delete;
+
+ Pickle& operator=(Pickle&& other);
+
+ // Returns the size of the Pickle's data.
+ uint32_t size() const { return header_size_ + header_->payload_size; }
+
+ typedef mozilla::BufferList<InfallibleAllocPolicy> BufferList;
+
+ const BufferList& Buffers() const { return buffers_; }
+
+ uint32_t CurrentSize() const { return buffers_.Size(); }
+
+ // Methods for reading the payload of the Pickle. To read from the start of
+ // the Pickle, initialize *iter to NULL. If successful, these methods return
+ // true. Otherwise, false is returned to indicate that the result could not
+ // be extracted.
+ MOZ_MUST_USE bool ReadBool(PickleIterator* iter, bool* result) const;
+ MOZ_MUST_USE bool ReadInt16(PickleIterator* iter, int16_t* result) const;
+ MOZ_MUST_USE bool ReadUInt16(PickleIterator* iter, uint16_t* result) const;
+ MOZ_MUST_USE bool ReadShort(PickleIterator* iter, short* result) const;
+ MOZ_MUST_USE bool ReadInt(PickleIterator* iter, int* result) const;
+ MOZ_MUST_USE bool ReadLong(PickleIterator* iter, long* result) const;
+ MOZ_MUST_USE bool ReadULong(PickleIterator* iter, unsigned long* result) const;
+ MOZ_MUST_USE bool ReadSize(PickleIterator* iter, size_t* result) const;
+ MOZ_MUST_USE bool ReadInt32(PickleIterator* iter, int32_t* result) const;
+ MOZ_MUST_USE bool ReadUInt32(PickleIterator* iter, uint32_t* result) const;
+ MOZ_MUST_USE bool ReadInt64(PickleIterator* iter, int64_t* result) const;
+ MOZ_MUST_USE bool ReadUInt64(PickleIterator* iter, uint64_t* result) const;
+ MOZ_MUST_USE bool ReadDouble(PickleIterator* iter, double* result) const;
+ MOZ_MUST_USE bool ReadIntPtr(PickleIterator* iter, intptr_t* result) const;
+ MOZ_MUST_USE bool ReadUnsignedChar(PickleIterator* iter, unsigned char* result) const;
+ MOZ_MUST_USE bool ReadString(PickleIterator* iter, std::string* result) const;
+ MOZ_MUST_USE bool ReadWString(PickleIterator* iter, std::wstring* result) const;
+ MOZ_MUST_USE bool ReadBytesInto(PickleIterator* iter, void* data, uint32_t length) const;
+ MOZ_MUST_USE bool ExtractBuffers(PickleIterator* iter, size_t length, BufferList* buffers,
+ uint32_t alignment = sizeof(memberAlignmentType)) const;
+
+ // Safer version of ReadInt() checks for the result not being negative.
+ // Use it for reading the object sizes.
+ MOZ_MUST_USE bool ReadLength(PickleIterator* iter, int* result) const;
+
+ MOZ_MUST_USE bool ReadSentinel(PickleIterator* iter, uint32_t sentinel) const
+#ifdef MOZ_PICKLE_SENTINEL_CHECKING
+ ;
+#else
+ {
+ return true;
+ }
+#endif
+
+ void EndRead(PickleIterator& iter) const;
+
+ // Methods for adding to the payload of the Pickle. These values are
+ // appended to the end of the Pickle's payload. When reading values from a
+ // Pickle, it is important to read them in the order in which they were added
+ // to the Pickle.
+ bool WriteBool(bool value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzBool(&value);
+#endif
+ return WriteInt(value ? 1 : 0);
+ }
+ bool WriteInt16(int16_t value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzInt16(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteUInt16(uint16_t value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt16(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteInt(int value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzInt(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteLong(long value) {
+ // Always written as a 64-bit value since the size for this type can
+ // differ between architectures.
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzLong(&value);
+#endif
+ return WriteInt64(int64_t(value));
+ }
+ bool WriteULong(unsigned long value) {
+ // Always written as a 64-bit value since the size for this type can
+ // differ between architectures.
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzULong(&value);
+#endif
+ return WriteUInt64(uint64_t(value));
+ }
+ bool WriteSize(size_t value) {
+ // Always written as a 64-bit value since the size for this type can
+ // differ between architectures.
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzSize(&value);
+#endif
+ return WriteUInt64(uint64_t(value));
+ }
+ bool WriteInt32(int32_t value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzInt(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteUInt32(uint32_t value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt32(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteInt64(int64_t value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzInt64(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteUInt64(uint64_t value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzUInt64(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteDouble(double value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzDouble(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteIntPtr(intptr_t value) {
+ // Always written as a 64-bit value since the size for this type can
+ // differ between architectures.
+ return WriteInt64(int64_t(value));
+ }
+ bool WriteUnsignedChar(unsigned char value) {
+#ifdef MOZ_FAULTY
+ Singleton<mozilla::ipc::Faulty>::get()->FuzzUChar(&value);
+#endif
+ return WriteBytes(&value, sizeof(value));
+ }
+ bool WriteString(const std::string& value);
+ bool WriteWString(const std::wstring& value);
+ bool WriteData(const char* data, uint32_t length);
+ bool WriteBytes(const void* data, uint32_t data_len,
+ uint32_t alignment = sizeof(memberAlignmentType));
+
+ bool WriteSentinel(uint32_t sentinel)
+#ifdef MOZ_PICKLE_SENTINEL_CHECKING
+ ;
+#else
+ {
+ return true;
+ }
+#endif
+
+ int32_t* GetInt32PtrForTest(uint32_t offset);
+
+ void InputBytes(const char* data, uint32_t length);
+
+ // Payload follows after allocation of Header (header size is customizable).
+ struct Header {
+ uint32_t payload_size; // Specifies the size of the payload.
+ };
+
+ // Returns the header, cast to a user-specified type T. The type T must be a
+ // subclass of Header and its size must correspond to the header_size passed
+ // to the Pickle constructor.
+ template <class T>
+ T* headerT() {
+ DCHECK(sizeof(T) == header_size_);
+ return static_cast<T*>(header_);
+ }
+ template <class T>
+ const T* headerT() const {
+ DCHECK(sizeof(T) == header_size_);
+ return static_cast<const T*>(header_);
+ }
+
+ typedef uint32_t memberAlignmentType;
+
+ protected:
+ uint32_t payload_size() const { return header_->payload_size; }
+
+ // Resizes the buffer for use when writing the specified amount of data. The
+ // location that the data should be written at is returned, or NULL if there
+ // was an error. Call EndWrite with the returned offset and the given length
+ // to pad out for the next write.
+ void BeginWrite(uint32_t length, uint32_t alignment);
+
+ // Completes the write operation by padding the data with NULL bytes until it
+ // is padded. Should be paired with BeginWrite, but it does not necessarily
+ // have to be called after the data is written.
+ void EndWrite(uint32_t length);
+
+ // Round 'bytes' up to the next multiple of 'alignment'. 'alignment' must be
+ // a power of 2.
+ template<uint32_t alignment> struct ConstantAligner {
+ static uint32_t align(int bytes) {
+ static_assert((alignment & (alignment - 1)) == 0,
+ "alignment must be a power of two");
+ return (bytes + (alignment - 1)) & ~static_cast<uint32_t>(alignment - 1);
+ }
+ };
+
+ static uint32_t AlignInt(int bytes) {
+ return ConstantAligner<sizeof(memberAlignmentType)>::align(bytes);
+ }
+
+ static uint32_t AlignCapacity(int bytes) {
+ return ConstantAligner<kSegmentAlignment>::align(bytes);
+ }
+
+ // Returns true if the given iterator could point to data with the given
+ // length. If there is no room for the given data before the end of the
+ // payload, returns false.
+ bool IteratorHasRoomFor(const PickleIterator& iter, uint32_t len) const;
+
+ // Moves the iterator by the given number of bytes, making sure it is aligned.
+ // Pointer (iterator) is NOT aligned, but the change in the pointer
+ // is guaranteed to be a multiple of sizeof(memberAlignmentType).
+ void UpdateIter(PickleIterator* iter, uint32_t bytes) const;
+
+ // Figure out how big the message starting at range_start is. Returns 0 if
+ // there's no enough data to determine (i.e., if [range_start, range_end) does
+ // not contain enough of the message header to know the size).
+ static uint32_t MessageSize(uint32_t header_size,
+ const char* range_start,
+ const char* range_end);
+
+ // Segments capacities are aligned to 8 bytes to ensure that all reads/writes
+ // at 8-byte aligned offsets will be on 8-byte aligned pointers.
+ static const uint32_t kSegmentAlignment = 8;
+
+ private:
+ friend class PickleIterator;
+
+ BufferList buffers_;
+ Header* header_;
+ uint32_t header_size_;
+};
+
+#endif // BASE_PICKLE_H__