tor-browser

Utils.h (12543B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef Utils_h
#define Utils_h

#include <pthread.h>
#include <stdint.h>
#include <stddef.h>
#include <sys/mman.h>
#include <unistd.h>
#include "mozilla/Assertions.h"
#include "mozilla/Atomics.h"

/**
* On architectures that are little endian and that support unaligned reads,
* we can use direct type, but on others, we want to have a special class
* to handle conversion and alignment issues.
*/
#if !defined(DEBUG) && (defined(__i386__) || defined(__x86_64__))
typedef uint16_t le_uint16;
typedef uint32_t le_uint32;
#else

/**
* Template that allows to find an unsigned int type from a (computed) bit size
*/
template <int s>
struct UInt {};
template <>
struct UInt<16> {
 typedef uint16_t Type;
};
template <>
struct UInt<32> {
 typedef uint32_t Type;
};

/**
* Template to access 2 n-bit sized words as a 2*n-bit sized word, doing
* conversion from little endian and avoiding alignment issues.
*/
template <typename T>
class le_to_cpu {
public:
 typedef typename UInt<16 * sizeof(T)>::Type Type;

 operator Type() const { return (b << (sizeof(T) * 8)) | a; }

 const le_to_cpu& operator=(const Type& v) {
   a = v & ((1 << (sizeof(T) * 8)) - 1);
   b = v >> (sizeof(T) * 8);
   return *this;
 }

 le_to_cpu() {}
 explicit le_to_cpu(const Type& v) { operator=(v); }

 const le_to_cpu& operator+=(const Type& v) {
   return operator=(operator Type() + v);
 }

 const le_to_cpu& operator++(int) { return operator=(operator Type() + 1); }

private:
 T a, b;
};

/**
* Type definitions
*/
typedef le_to_cpu<unsigned char> le_uint16;
typedef le_to_cpu<le_uint16> le_uint32;
#endif

struct AutoCloseFD {
 const int fd;

 MOZ_IMPLICIT AutoCloseFD(int fd) : fd(fd) {}
 ~AutoCloseFD() {
   if (fd != -1) close(fd);
 }
 operator int() const { return fd; }
};

extern mozilla::Atomic<size_t, mozilla::ReleaseAcquire> gPageSize;

/**
* Page alignment helpers
*/
static size_t PageSize() {
 if (!gPageSize) {
   gPageSize = sysconf(_SC_PAGESIZE);
 }

 return gPageSize;
}

static inline uintptr_t AlignedPtr(uintptr_t ptr, size_t alignment) {
 return ptr & ~(alignment - 1);
}

template <typename T>
static inline T* AlignedPtr(T* ptr, size_t alignment) {
 return reinterpret_cast<T*>(
     AlignedPtr(reinterpret_cast<uintptr_t>(ptr), alignment));
}

template <typename T>
static inline T PageAlignedPtr(T ptr) {
 return AlignedPtr(ptr, PageSize());
}

static inline uintptr_t AlignedEndPtr(uintptr_t ptr, size_t alignment) {
 return AlignedPtr(ptr + alignment - 1, alignment);
}

template <typename T>
static inline T* AlignedEndPtr(T* ptr, size_t alignment) {
 return reinterpret_cast<T*>(
     AlignedEndPtr(reinterpret_cast<uintptr_t>(ptr), alignment));
}

template <typename T>
static inline T PageAlignedEndPtr(T ptr) {
 return AlignedEndPtr(ptr, PageSize());
}

static inline size_t AlignedSize(size_t size, size_t alignment) {
 return (size + alignment - 1) & ~(alignment - 1);
}

static inline size_t PageAlignedSize(size_t size) {
 return AlignedSize(size, PageSize());
}

static inline bool IsAlignedPtr(uintptr_t ptr, size_t alignment) {
 return ptr % alignment == 0;
}

template <typename T>
static inline bool IsAlignedPtr(T* ptr, size_t alignment) {
 return IsAlignedPtr(reinterpret_cast<uintptr_t>(ptr), alignment);
}

template <typename T>
static inline bool IsPageAlignedPtr(T ptr) {
 return IsAlignedPtr(ptr, PageSize());
}

static inline bool IsAlignedSize(size_t size, size_t alignment) {
 return size % alignment == 0;
}

static inline bool IsPageAlignedSize(size_t size) {
 return IsAlignedSize(size, PageSize());
}

static inline size_t PageNumber(size_t size) {
 return (size + PageSize() - 1) / PageSize();
}

/**
* MemoryRange stores a pointer, size pair.
*/
class MemoryRange {
public:
 MemoryRange(void* buf, size_t length) : buf(buf), length(length) {}

 void Assign(void* b, size_t len) {
   buf = b;
   length = len;
 }

 void Assign(const MemoryRange& other) {
   buf = other.buf;
   length = other.length;
 }

 void* get() const { return buf; }

 operator void*() const { return buf; }

 operator unsigned char*() const {
   return reinterpret_cast<unsigned char*>(buf);
 }

 bool operator==(void* ptr) const { return buf == ptr; }

 bool operator==(unsigned char* ptr) const { return buf == ptr; }

 void* operator+(off_t offset) const {
   return reinterpret_cast<char*>(buf) + offset;
 }

 /**
  * Returns whether the given address is within the mapped range
  */
 bool Contains(void* ptr) const {
   return (ptr >= buf) && (ptr < reinterpret_cast<char*>(buf) + length);
 }

 /**
  * Returns the length of the mapped range
  */
 size_t GetLength() const { return length; }

 static MemoryRange mmap(void* addr, size_t length, int prot, int flags,
                         int fd, off_t offset) {
   return MemoryRange(::mmap(addr, length, prot, flags, fd, offset), length);
 }

private:
 void* buf;
 size_t length;
};

/**
* MappedPtr is a RAII wrapper for mmap()ed memory. It can be used as
* a simple void * or unsigned char *.
*
* It is defined as a derivative of a template that allows to use a
* different unmapping strategy.
*/
template <typename T>
class GenericMappedPtr : public MemoryRange {
public:
 GenericMappedPtr(void* buf, size_t length) : MemoryRange(buf, length) {}
 explicit GenericMappedPtr(const MemoryRange& other) : MemoryRange(other) {}
 GenericMappedPtr() : MemoryRange(MAP_FAILED, 0) {}

 void Assign(void* b, size_t len) {
   if (get() != MAP_FAILED) static_cast<T*>(this)->munmap(get(), GetLength());
   MemoryRange::Assign(b, len);
 }

 void Assign(const MemoryRange& other) {
   Assign(other.get(), other.GetLength());
 }

 ~GenericMappedPtr() {
   if (get() != MAP_FAILED) static_cast<T*>(this)->munmap(get(), GetLength());
 }

 void release() { MemoryRange::Assign(MAP_FAILED, 0); }
};

struct MappedPtr : public GenericMappedPtr<MappedPtr> {
 MappedPtr(void* buf, size_t length)
     : GenericMappedPtr<MappedPtr>(buf, length) {}
 MOZ_IMPLICIT MappedPtr(const MemoryRange& other)
     : GenericMappedPtr<MappedPtr>(other) {}
 MappedPtr() : GenericMappedPtr<MappedPtr>() {}

private:
 friend class GenericMappedPtr<MappedPtr>;
 void munmap(void* buf, size_t length) { ::munmap(buf, length); }
};

/**
* UnsizedArray is a way to access raw arrays of data in memory.
*
*   struct S { ... };
*   UnsizedArray<S> a(buf);
*   UnsizedArray<S> b; b.Init(buf);
*
* This is roughly equivalent to
*   const S *a = reinterpret_cast<const S *>(buf);
*   const S *b = nullptr; b = reinterpret_cast<const S *>(buf);
*
* An UnsizedArray has no known length, and it's up to the caller to make
* sure the accessed memory is mapped and makes sense.
*/
template <typename T>
class UnsizedArray {
public:
 typedef size_t idx_t;

 /**
  * Constructors and Initializers
  */
 UnsizedArray() : contents(nullptr) {}
 explicit UnsizedArray(const void* buf)
     : contents(reinterpret_cast<const T*>(buf)) {}

 void Init(const void* buf) {
   MOZ_ASSERT(contents == nullptr);
   contents = reinterpret_cast<const T*>(buf);
 }

 /**
  * Returns the nth element of the array
  */
 const T& operator[](const idx_t index) const {
   MOZ_ASSERT(contents);
   return contents[index];
 }

 operator const T*() const { return contents; }
 /**
  * Returns whether the array points somewhere
  */
 explicit operator bool() const { return contents != nullptr; }

private:
 const T* contents;
};

/**
* Array, like UnsizedArray, is a way to access raw arrays of data in memory.
* Unlike UnsizedArray, it has a known length, and is enumerable with an
* iterator.
*
*   struct S { ... };
*   Array<S> a(buf, len);
*   UnsizedArray<S> b; b.Init(buf, len);
*
* In the above examples, len is the number of elements in the array. It is
* also possible to initialize an Array with the buffer size:
*
*   Array<S> c; c.InitSize(buf, size);
*
* It is also possible to initialize an Array in two steps, only providing
* one data at a time:
*
*   Array<S> d;
*   d.Init(buf);
*   d.Init(len); // or d.InitSize(size);
*
*/
template <typename T>
class Array : public UnsizedArray<T> {
public:
 typedef typename UnsizedArray<T>::idx_t idx_t;

 /**
  * Constructors and Initializers
  */
 Array() : UnsizedArray<T>(), length(0) {}
 Array(const void* buf, const idx_t length)
     : UnsizedArray<T>(buf), length(length) {}

 void Init(const void* buf) { UnsizedArray<T>::Init(buf); }

 void Init(const idx_t len) {
   MOZ_ASSERT(length == 0);
   length = len;
 }

 void InitSize(const idx_t size) { Init(size / sizeof(T)); }

 void Init(const void* buf, const idx_t len) {
   UnsizedArray<T>::Init(buf);
   Init(len);
 }

 void InitSize(const void* buf, const idx_t size) {
   UnsizedArray<T>::Init(buf);
   InitSize(size);
 }

 /**
  * Returns the nth element of the array
  */
 const T& operator[](const idx_t index) const {
   MOZ_ASSERT(index < length);
   MOZ_ASSERT(operator bool());
   return UnsizedArray<T>::operator[](index);
 }

 /**
  * Returns the number of elements in the array
  */
 idx_t numElements() const { return length; }

 /**
  * Returns whether the array points somewhere and has at least one element.
  */
 explicit operator bool() const {
   return (length > 0) && UnsizedArray<T>::operator bool();
 }

 /**
  * Iterator for an Array. Use is similar to that of STL const_iterators:
  *
  *   struct S { ... };
  *   Array<S> a(buf, len);
  *   for (Array<S>::iterator it = a.begin(); it < a.end(); ++it) {
  *     // Do something with *it.
  *   }
  */
 class iterator {
  public:
   iterator() : item(nullptr) {}

   const T& operator*() const { return *item; }

   const T* operator->() const { return item; }

   iterator& operator++() {
     ++item;
     return *this;
   }

   bool operator<(const iterator& other) const { return item < other.item; }

  protected:
   friend class Array<T>;
   explicit iterator(const T& item) : item(&item) {}

  private:
   const T* item;
 };

 /**
  * Returns an iterator pointing at the beginning of the Array
  */
 iterator begin() const {
   if (length) return iterator(UnsizedArray<T>::operator[](0));
   return iterator();
 }

 /**
  * Returns an iterator pointing past the end of the Array
  */
 iterator end() const {
   if (length) return iterator(UnsizedArray<T>::operator[](length));
   return iterator();
 }

 /**
  * Reverse iterator for an Array. Use is similar to that of STL
  * const_reverse_iterators:
  *
  *   struct S { ... };
  *   Array<S> a(buf, len);
  *   for (Array<S>::reverse_iterator it = a.rbegin(); it < a.rend(); ++it) {
  *     // Do something with *it.
  *   }
  */
 class reverse_iterator {
  public:
   reverse_iterator() : item(nullptr) {}

   const T& operator*() const {
     const T* tmp = item;
     return *--tmp;
   }

   const T* operator->() const { return &operator*(); }

   reverse_iterator& operator++() {
     --item;
     return *this;
   }

   bool operator<(const reverse_iterator& other) const {
     return item > other.item;
   }

  protected:
   friend class Array<T>;
   explicit reverse_iterator(const T& item) : item(&item) {}

  private:
   const T* item;
 };

 /**
  * Returns a reverse iterator pointing at the end of the Array
  */
 reverse_iterator rbegin() const {
   if (length) return reverse_iterator(UnsizedArray<T>::operator[](length));
   return reverse_iterator();
 }

 /**
  * Returns a reverse iterator pointing past the beginning of the Array
  */
 reverse_iterator rend() const {
   if (length) return reverse_iterator(UnsizedArray<T>::operator[](0));
   return reverse_iterator();
 }

private:
 idx_t length;
};

/**
* Transforms a pointer-to-function to a pointer-to-object pointing at the
* same address.
*/
template <typename T>
void* FunctionPtr(T func) {
 union {
   void* ptr;
   T func;
 } f;
 f.func = func;
 return f.ptr;
}

class AutoLock {
public:
 explicit AutoLock(pthread_mutex_t* mutex) : mutex(mutex) {
   if (pthread_mutex_lock(mutex)) MOZ_CRASH("pthread_mutex_lock failed");
 }
 ~AutoLock() {
   if (pthread_mutex_unlock(mutex)) MOZ_CRASH("pthread_mutex_unlock failed");
 }

private:
 pthread_mutex_t* mutex;
};

#endif /* Utils_h */