The Tor Browser: toolkit/crashreporter/google-breakpad/src/common/memory.h@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/memory.h@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/memory.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 // Copyright (c) 2009, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef GOOGLE_BREAKPAD_COMMON_MEMORY_H_
 #define GOOGLE_BREAKPAD_COMMON_MEMORY_H_
 #include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #ifdef __APPLE__
 #define sys_mmap mmap
 #define sys_mmap2 mmap
 #define sys_munmap munmap
 #define MAP_ANONYMOUS MAP_ANON
 #else
 #include "third_party/lss/linux_syscall_support.h"
 #endif
 namespace google_breakpad {
 // This is very simple allocator which fetches pages from the kernel directly.
 // Thus, it can be used even when the heap may be corrupted.
 //
 // There is no free operation. The pages are only freed when the object is
 // destroyed.
 class PageAllocator {
  public:
   PageAllocator()
       : page_size_(getpagesize()),
         last_(NULL),
         current_page_(NULL),
         page_offset_(0) {
   }
   ~PageAllocator() {
     FreeAll();
   }
   void *Alloc(unsigned bytes) {
     if (!bytes)
       return NULL;
     if (current_page_ && page_size_ - page_offset_ >= bytes) {
       uint8_t *const ret = current_page_ + page_offset_;
       page_offset_ += bytes;
       if (page_offset_ == page_size_) {
         page_offset_ = 0;
         current_page_ = NULL;
       }
       return ret;
     }
     const unsigned pages =
         (bytes + sizeof(PageHeader) + page_size_ - 1) / page_size_;
     uint8_t *const ret = GetNPages(pages);
     if (!ret)
       return NULL;
     page_offset_ = (page_size_ - (page_size_ * pages - (bytes + sizeof(PageHeader)))) % page_size_;
     current_page_ = page_offset_ ? ret + page_size_ * (pages - 1) : NULL;
     return ret + sizeof(PageHeader);
   }
  private:
   uint8_t *GetNPages(unsigned num_pages) {
 #ifdef __x86_64
     void *a = sys_mmap(NULL, page_size_ * num_pages, PROT_READ | PROT_WRITE,
                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 #else
     void *a = sys_mmap2(NULL, page_size_ * num_pages, PROT_READ | PROT_WRITE,
                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 #endif
     if (a == MAP_FAILED)
       return NULL;
     struct PageHeader *header = reinterpret_cast<PageHeader*>(a);
     header->next = last_;
     header->num_pages = num_pages;
     last_ = header;
     return reinterpret_cast<uint8_t*>(a);
   }
   void FreeAll() {
     PageHeader *next;
     for (PageHeader *cur = last_; cur; cur = next) {
       next = cur->next;
       sys_munmap(cur, cur->num_pages * page_size_);
     }
   }
   struct PageHeader {
     PageHeader *next;  // pointer to the start of the next set of pages.
     unsigned num_pages;  // the number of pages in this set.
   };
   const unsigned page_size_;
   PageHeader *last_;
   uint8_t *current_page_;
   unsigned page_offset_;
 };
 // A wasteful vector is like a normal std::vector, except that it's very much
 // simplier and it allocates memory from a PageAllocator. It's wasteful
 // because, when resizing, it always allocates a whole new array since the
 // PageAllocator doesn't support realloc.
 template<class T>
 class wasteful_vector {
  public:
   wasteful_vector(PageAllocator *allocator, unsigned size_hint = 16)
       : allocator_(allocator),
         a_((T*) allocator->Alloc(sizeof(T) * size_hint)),
         allocated_(size_hint),
         used_(0) {
   }
   T& back() {
     return a_[used_ - 1];
   }
   const T& back() const {
     return a_[used_ - 1];
   }
   bool empty() const {
     return used_ == 0;
   }
   void push_back(const T& new_element) {
     if (used_ == allocated_)
       Realloc(allocated_ * 2);
     a_[used_++] = new_element;
   }
   size_t size() const {
     return used_;
   }
   void resize(unsigned sz, T c = T()) {
     // No need to test "sz >= 0", as "sz" is unsigned.
     if (sz <= used_) {
       used_ = sz;
     } else {
       unsigned a = allocated_;
       if (sz > a) {
         while (sz > a) {
           a *= 2;
         }
         Realloc(a);
       }
       while (sz > used_) {
         a_[used_++] = c;
       }
     }
   }
   T& operator[](size_t index) {
     return a_[index];
   }
   const T& operator[](size_t index) const {
     return a_[index];
   }
  private:
   void Realloc(unsigned new_size) {
     T *new_array =
         reinterpret_cast<T*>(allocator_->Alloc(sizeof(T) * new_size));
     memcpy(new_array, a_, used_ * sizeof(T));
     a_ = new_array;
     allocated_ = new_size;
   }
   PageAllocator *const allocator_;
   T *a_;  // pointer to an array of |allocated_| elements.
   unsigned allocated_;  // size of |a_|, in elements.
   unsigned used_;  // number of used slots in |a_|.
 };
 }  // namespace google_breakpad
 inline void* operator new(size_t nbytes,
                           google_breakpad::PageAllocator& allocator) {
    return allocator.Alloc(nbytes);
 }
 #endif  // GOOGLE_BREAKPAD_COMMON_MEMORY_H_

The Tor Browser / annotate

toolkit/crashreporter/google-breakpad/src/common/memory.h@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/memory.h