The Tor Browser / file revision

 // Copyright (c) 2006, 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.

 #include <ObjBase.h>

 #include <algorithm>

 #include <cassert>

 #include <cstdio>

 #include "common/windows/string_utils-inl.h"

 #include "client/windows/common/ipc_protocol.h"

 #include "client/windows/handler/exception_handler.h"

 #include "common/windows/guid_string.h"

 namespace google_breakpad {

 static const int kWaitForHandlerThreadMs = 60000;

 static const int kExceptionHandlerThreadInitialStackSize = 64 * 1024;

 // As documented on MSDN, on failure SuspendThread returns (DWORD) -1

 static const DWORD kFailedToSuspendThread = static_cast<DWORD>(-1);

 // This is passed as the context to the MinidumpWriteDump callback.

 typedef struct {

   AppMemoryList::const_iterator iter;

   AppMemoryList::const_iterator end;

 } MinidumpCallbackContext;

 vector<ExceptionHandler*>* ExceptionHandler::handler_stack_ = NULL;

 LONG ExceptionHandler::handler_stack_index_ = 0;

 CRITICAL_SECTION ExceptionHandler::handler_stack_critical_section_;

 volatile LONG ExceptionHandler::instance_count_ = 0;

 ExceptionHandler::ExceptionHandler(const wstring& dump_path,

                                    FilterCallback filter,

                                    MinidumpCallback callback,

                                    void* callback_context,

                                    int handler_types,

                                    MINIDUMP_TYPE dump_type,

                                    const wchar_t* pipe_name,

                                    const CustomClientInfo* custom_info) {

   Initialize(dump_path,

              filter,

              callback,

              callback_context,

              handler_types,

              dump_type,

              pipe_name,

              NULL,

              custom_info);

 }

 ExceptionHandler::ExceptionHandler(const wstring& dump_path,

                                    FilterCallback filter,

                                    MinidumpCallback callback,

                                    void* callback_context,

                                    int handler_types,

                                    MINIDUMP_TYPE dump_type,

                                    HANDLE pipe_handle,

                                    const CustomClientInfo* custom_info) {

   Initialize(dump_path,

              filter,

              callback,

              callback_context,

              handler_types,

              dump_type,

              NULL,

              pipe_handle,

              custom_info);

 }  

 ExceptionHandler::ExceptionHandler(const wstring &dump_path,

                                    FilterCallback filter,

                                    MinidumpCallback callback,

                                    void* callback_context,

                                    int handler_types) {

   Initialize(dump_path,

              filter,

              callback,

              callback_context,

              handler_types,

              MiniDumpNormal,

              NULL,

              NULL,

              NULL);

 }

 void ExceptionHandler::Initialize(const wstring& dump_path,

                                   FilterCallback filter,

                                   MinidumpCallback callback,

                                   void* callback_context,

                                   int handler_types,

                                   MINIDUMP_TYPE dump_type,

                                   const wchar_t* pipe_name,

                                   HANDLE pipe_handle,

                                   const CustomClientInfo* custom_info) {

   LONG instance_count = InterlockedIncrement(&instance_count_);

   filter_ = filter;

   callback_ = callback;

   callback_context_ = callback_context;

   dump_path_c_ = NULL;

   next_minidump_id_c_ = NULL;

   next_minidump_path_c_ = NULL;

   dbghelp_module_ = NULL;

   minidump_write_dump_ = NULL;

   dump_type_ = dump_type;

   rpcrt4_module_ = NULL;

   uuid_create_ = NULL;

   handler_types_ = handler_types;

   previous_filter_ = NULL;

 #if _MSC_VER >= 1400  // MSVC 2005/8

   previous_iph_ = NULL;

 #endif  // _MSC_VER >= 1400

   previous_pch_ = NULL;

   handler_thread_ = NULL;

   is_shutdown_ = false;

   handler_start_semaphore_ = NULL;

   handler_finish_semaphore_ = NULL;

   requesting_thread_id_ = 0;

   exception_info_ = NULL;

   assertion_ = NULL;

   handler_return_value_ = false;

   handle_debug_exceptions_ = false;

   // Attempt to use out-of-process if user has specified a pipe.

   if (pipe_name != NULL || pipe_handle != NULL) {

     assert(!(pipe_name && pipe_handle));

     scoped_ptr<CrashGenerationClient> client;

     if (pipe_name) {

       client.reset(

         new CrashGenerationClient(pipe_name,

                                   dump_type_,

                                   custom_info));

     } else {

       client.reset(

         new CrashGenerationClient(pipe_handle,

                                   dump_type_,

                                   custom_info));

     }

     // If successful in registering with the monitoring process,

     // there is no need to setup in-process crash generation.

     if (client->Register()) {

       crash_generation_client_.reset(client.release());

     }

   }

   if (!IsOutOfProcess()) {

     // Either client did not ask for out-of-process crash generation

     // or registration with the server process failed. In either case,

     // setup to do in-process crash generation.

     // Set synchronization primitives and the handler thread.  Each

     // ExceptionHandler object gets its own handler thread because that's the

     // only way to reliably guarantee sufficient stack space in an exception,

     // and it allows an easy way to get a snapshot of the requesting thread's

     // context outside of an exception.

     InitializeCriticalSection(&handler_critical_section_);

     handler_start_semaphore_ = CreateSemaphore(NULL, 0, 1, NULL);

     assert(handler_start_semaphore_ != NULL);

     handler_finish_semaphore_ = CreateSemaphore(NULL, 0, 1, NULL);

     assert(handler_finish_semaphore_ != NULL);

     // Don't attempt to create the thread if we could not create the semaphores.

     if (handler_finish_semaphore_ != NULL && handler_start_semaphore_ != NULL) {

       DWORD thread_id;

       handler_thread_ = CreateThread(NULL,         // lpThreadAttributes

                                      kExceptionHandlerThreadInitialStackSize,

                                      ExceptionHandlerThreadMain,

                                      this,         // lpParameter

                                      0,            // dwCreationFlags

                                      &thread_id);

       assert(handler_thread_ != NULL);

     }

     dbghelp_module_ = LoadLibrary(L"dbghelp.dll");

     if (dbghelp_module_) {

       minidump_write_dump_ = reinterpret_cast<MiniDumpWriteDump_type>(

           GetProcAddress(dbghelp_module_, "MiniDumpWriteDump"));

     }

     // Load this library dynamically to not affect existing projects.  Most

     // projects don't link against this directly, it's usually dynamically

     // loaded by dependent code.

     rpcrt4_module_ = LoadLibrary(L"rpcrt4.dll");

     if (rpcrt4_module_) {

       uuid_create_ = reinterpret_cast<UuidCreate_type>(

           GetProcAddress(rpcrt4_module_, "UuidCreate"));

     }

     // set_dump_path calls UpdateNextID.  This sets up all of the path and id

     // strings, and their equivalent c_str pointers.

     set_dump_path(dump_path);

   }

   // Reserve one element for the instruction memory

   AppMemory instruction_memory;

   instruction_memory.ptr = NULL;

   instruction_memory.length = 0;

   app_memory_info_.push_back(instruction_memory);

   // There is a race condition here. If the first instance has not yet

   // initialized the critical section, the second (and later) instances may

   // try to use uninitialized critical section object. The feature of multiple

   // instances in one module is not used much, so leave it as is for now.

   // One way to solve this in the current design (that is, keeping the static

   // handler stack) is to use spin locks with volatile bools to synchronize

   // the handler stack. This works only if the compiler guarantees to generate

   // cache coherent code for volatile.

   // TODO(munjal): Fix this in a better way by changing the design if possible.

   // Lazy initialization of the handler_stack_critical_section_

   if (instance_count == 1) {

     InitializeCriticalSection(&handler_stack_critical_section_);

   }

   if (handler_types != HANDLER_NONE) {

     EnterCriticalSection(&handler_stack_critical_section_);

     // The first time an ExceptionHandler that installs a handler is

     // created, set up the handler stack.

     if (!handler_stack_) {

       handler_stack_ = new vector<ExceptionHandler*>();

     }

     handler_stack_->push_back(this);

     if (handler_types & HANDLER_EXCEPTION)

       previous_filter_ = SetUnhandledExceptionFilter(HandleException);

 #if _MSC_VER >= 1400  // MSVC 2005/8

     if (handler_types & HANDLER_INVALID_PARAMETER)

       previous_iph_ = _set_invalid_parameter_handler(HandleInvalidParameter);

 #endif  // _MSC_VER >= 1400

     if (handler_types & HANDLER_PURECALL)

       previous_pch_ = _set_purecall_handler(HandlePureVirtualCall);

     LeaveCriticalSection(&handler_stack_critical_section_);

   }

 }

 ExceptionHandler::~ExceptionHandler() {

   if (dbghelp_module_) {

     FreeLibrary(dbghelp_module_);

   }

   if (rpcrt4_module_) {

     FreeLibrary(rpcrt4_module_);

   }

   if (handler_types_ != HANDLER_NONE) {

     EnterCriticalSection(&handler_stack_critical_section_);

     if (handler_types_ & HANDLER_EXCEPTION)

       SetUnhandledExceptionFilter(previous_filter_);

 #if _MSC_VER >= 1400  // MSVC 2005/8

     if (handler_types_ & HANDLER_INVALID_PARAMETER)

       _set_invalid_parameter_handler(previous_iph_);

 #endif  // _MSC_VER >= 1400

     if (handler_types_ & HANDLER_PURECALL)

       _set_purecall_handler(previous_pch_);

     if (handler_stack_->back() == this) {

       handler_stack_->pop_back();

     } else {

       // TODO(mmentovai): use advapi32!ReportEvent to log the warning to the

       // system's application event log.

       fprintf(stderr, "warning: removing Breakpad handler out of order\n");

       vector<ExceptionHandler*>::iterator iterator = handler_stack_->begin();

       while (iterator != handler_stack_->end()) {

         if (*iterator == this) {

           iterator = handler_stack_->erase(iterator);

         } else {

           ++iterator;

         }

       }

     }

     if (handler_stack_->empty()) {

       // When destroying the last ExceptionHandler that installed a handler,

       // clean up the handler stack.

       delete handler_stack_;

       handler_stack_ = NULL;

     }

     LeaveCriticalSection(&handler_stack_critical_section_);

   }

   // Some of the objects were only initialized if out of process

   // registration was not done.

   if (!IsOutOfProcess()) {

 #ifdef BREAKPAD_NO_TERMINATE_THREAD

     // Clean up the handler thread and synchronization primitives. The handler

     // thread is either waiting on the semaphore to handle a crash or it is

     // handling a crash. Coming out of the wait is fast but wait more in the

     // eventuality a crash is handled.  This compilation option results in a

     // deadlock if the exception handler is destroyed while executing code

     // inside DllMain.

     is_shutdown_ = true;

     ReleaseSemaphore(handler_start_semaphore_, 1, NULL);

     WaitForSingleObject(handler_thread_, kWaitForHandlerThreadMs);

 #else

     TerminateThread(handler_thread_, 1);

 #endif  // BREAKPAD_NO_TERMINATE_THREAD

     CloseHandle(handler_thread_);

     handler_thread_ = NULL;

     DeleteCriticalSection(&handler_critical_section_);

     CloseHandle(handler_start_semaphore_);

     CloseHandle(handler_finish_semaphore_);

   }

   // There is a race condition in the code below: if this instance is

   // deleting the static critical section and a new instance of the class

   // is created, then there is a possibility that the critical section be

   // initialized while the same critical section is being deleted. Given the

   // usage pattern for the code, this race condition is unlikely to hit, but it

   // is a race condition nonetheless.

   if (InterlockedDecrement(&instance_count_) == 0) {

     DeleteCriticalSection(&handler_stack_critical_section_);

   }

 }

 bool ExceptionHandler::RequestUpload(DWORD crash_id) {

   return crash_generation_client_->RequestUpload(crash_id);

 }

 // static

 DWORD ExceptionHandler::ExceptionHandlerThreadMain(void* lpParameter) {

   ExceptionHandler* self = reinterpret_cast<ExceptionHandler *>(lpParameter);

   assert(self);

   assert(self->handler_start_semaphore_ != NULL);

   assert(self->handler_finish_semaphore_ != NULL);

   while (true) {

     if (WaitForSingleObject(self->handler_start_semaphore_, INFINITE) ==

         WAIT_OBJECT_0) {

       // Perform the requested action.

       if (self->is_shutdown_) {

         // The instance of the exception handler is being destroyed.

         break;

       } else {

         self->handler_return_value_ =

             self->WriteMinidumpWithException(self->requesting_thread_id_,

                                              self->exception_info_,

                                              self->assertion_);

       }

       // Allow the requesting thread to proceed.

       ReleaseSemaphore(self->handler_finish_semaphore_, 1, NULL);

     }

   }

   // This statement is not reached when the thread is unconditionally

   // terminated by the ExceptionHandler destructor.

   return 0;

 }

 // HandleException and HandleInvalidParameter must create an

 // AutoExceptionHandler object to maintain static state and to determine which

 // ExceptionHandler instance to use.  The constructor locates the correct

 // instance, and makes it available through get_handler().  The destructor

 // restores the state in effect prior to allocating the AutoExceptionHandler.

 class AutoExceptionHandler {

  public:

   AutoExceptionHandler() {

     // Increment handler_stack_index_ so that if another Breakpad handler is

     // registered using this same HandleException function, and it needs to be

     // called while this handler is running (either because this handler

     // declines to handle the exception, or an exception occurs during

     // handling), HandleException will find the appropriate ExceptionHandler

     // object in handler_stack_ to deliver the exception to.

     //

     // Because handler_stack_ is addressed in reverse (as |size - index|),

     // preincrementing handler_stack_index_ avoids needing to subtract 1 from

     // the argument to |at|.

     //

     // The index is maintained instead of popping elements off of the handler

     // stack and pushing them at the end of this method.  This avoids ruining

     // the order of elements in the stack in the event that some other thread

     // decides to manipulate the handler stack (such as creating a new

     // ExceptionHandler object) while an exception is being handled.

     EnterCriticalSection(&ExceptionHandler::handler_stack_critical_section_);

     handler_ = ExceptionHandler::handler_stack_->at(

         ExceptionHandler::handler_stack_->size() -

         ++ExceptionHandler::handler_stack_index_);

     // In case another exception occurs while this handler is doing its thing,

     // it should be delivered to the previous filter.

     SetUnhandledExceptionFilter(handler_->previous_filter_);

 #if _MSC_VER >= 1400  // MSVC 2005/8

     _set_invalid_parameter_handler(handler_->previous_iph_);

 #endif  // _MSC_VER >= 1400

     _set_purecall_handler(handler_->previous_pch_);

   }

   ~AutoExceptionHandler() {

     // Put things back the way they were before entering this handler.

     SetUnhandledExceptionFilter(ExceptionHandler::HandleException);

 #if _MSC_VER >= 1400  // MSVC 2005/8

     _set_invalid_parameter_handler(ExceptionHandler::HandleInvalidParameter);

 #endif  // _MSC_VER >= 1400

     _set_purecall_handler(ExceptionHandler::HandlePureVirtualCall);

     --ExceptionHandler::handler_stack_index_;

     LeaveCriticalSection(&ExceptionHandler::handler_stack_critical_section_);

   }

   ExceptionHandler* get_handler() const { return handler_; }

  private:

   ExceptionHandler* handler_;

 };

 // static

 LONG ExceptionHandler::HandleException(EXCEPTION_POINTERS* exinfo) {

   AutoExceptionHandler auto_exception_handler;

   ExceptionHandler* current_handler = auto_exception_handler.get_handler();

   // Ignore EXCEPTION_BREAKPOINT and EXCEPTION_SINGLE_STEP exceptions.  This

   // logic will short-circuit before calling WriteMinidumpOnHandlerThread,

   // allowing something else to handle the breakpoint without incurring the

   // overhead transitioning to and from the handler thread.  This behavior

   // can be overridden by calling ExceptionHandler::set_handle_debug_exceptions.

   DWORD code = exinfo->ExceptionRecord->ExceptionCode;

   LONG action;

   bool is_debug_exception = (code == EXCEPTION_BREAKPOINT) ||

                             (code == EXCEPTION_SINGLE_STEP);

   bool success = false;

   if (!is_debug_exception ||

       current_handler->get_handle_debug_exceptions()) {

     // If out-of-proc crash handler client is available, we have to use that

     // to generate dump and we cannot fall back on in-proc dump generation

     // because we never prepared for an in-proc dump generation

     // In case of out-of-process dump generation, directly call

     // WriteMinidumpWithException since there is no separate thread running.

     if (current_handler->IsOutOfProcess()) {

       success = current_handler->WriteMinidumpWithException(

           GetCurrentThreadId(),

           exinfo,

           NULL);

     } else {

       success = current_handler->WriteMinidumpOnHandlerThread(exinfo, NULL);

     }

   }

   // The handler fully handled the exception.  Returning

   // EXCEPTION_EXECUTE_HANDLER indicates this to the system, and usually

   // results in the application being terminated.

   //

   // Note: If the application was launched from within the Cygwin

   // environment, returning EXCEPTION_EXECUTE_HANDLER seems to cause the

   // application to be restarted.

   if (success) {

     action = EXCEPTION_EXECUTE_HANDLER;

   } else {

     // There was an exception, it was a breakpoint or something else ignored

     // above, or it was passed to the handler, which decided not to handle it.

     // This could be because the filter callback didn't want it, because

     // minidump writing failed for some reason, or because the post-minidump

     // callback function indicated failure.  Give the previous handler a

     // chance to do something with the exception.  If there is no previous

     // handler, return EXCEPTION_CONTINUE_SEARCH, which will allow a debugger

     // or native "crashed" dialog to handle the exception.

     if (current_handler->previous_filter_) {

       action = current_handler->previous_filter_(exinfo);

     } else {

       action = EXCEPTION_CONTINUE_SEARCH;

     }

   }

   return action;

 }

 #if _MSC_VER >= 1400  // MSVC 2005/8

 // static

 void ExceptionHandler::HandleInvalidParameter(const wchar_t* expression,

                                               const wchar_t* function,

                                               const wchar_t* file,

                                               unsigned int line,

                                               uintptr_t reserved) {

   // This is an invalid parameter, not an exception.  It's safe to play with

   // sprintf here.

   AutoExceptionHandler auto_exception_handler;

   ExceptionHandler* current_handler = auto_exception_handler.get_handler();

   MDRawAssertionInfo assertion;

   memset(&assertion, 0, sizeof(assertion));

   _snwprintf_s(reinterpret_cast<wchar_t*>(assertion.expression),

                sizeof(assertion.expression) / sizeof(assertion.expression[0]),

                _TRUNCATE, L"%s", expression);

   _snwprintf_s(reinterpret_cast<wchar_t*>(assertion.function),

                sizeof(assertion.function) / sizeof(assertion.function[0]),

                _TRUNCATE, L"%s", function);

   _snwprintf_s(reinterpret_cast<wchar_t*>(assertion.file),

                sizeof(assertion.file) / sizeof(assertion.file[0]),

                _TRUNCATE, L"%s", file);

   assertion.line = line;

   assertion.type = MD_ASSERTION_INFO_TYPE_INVALID_PARAMETER;

   // Make up an exception record for the current thread and CPU context

   // to make it possible for the crash processor to classify these

   // as do regular crashes, and to make it humane for developers to

   // analyze them.

   EXCEPTION_RECORD exception_record = {};

   CONTEXT exception_context = {};

   EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context };

   ::RtlCaptureContext(&exception_context);

   exception_record.ExceptionCode = STATUS_INVALID_PARAMETER;

   // We store pointers to the the expression and function strings,

   // and the line as exception parameters to make them easy to

   // access by the developer on the far side.

   exception_record.NumberParameters = 3;

   exception_record.ExceptionInformation[0] =

       reinterpret_cast<ULONG_PTR>(&assertion.expression);

   exception_record.ExceptionInformation[1] =

       reinterpret_cast<ULONG_PTR>(&assertion.file);

   exception_record.ExceptionInformation[2] = assertion.line;

   bool success = false;

   // In case of out-of-process dump generation, directly call

   // WriteMinidumpWithException since there is no separate thread running.

   if (current_handler->IsOutOfProcess()) {

     success = current_handler->WriteMinidumpWithException(

         GetCurrentThreadId(),

         &exception_ptrs,

         &assertion);

   } else {

     success = current_handler->WriteMinidumpOnHandlerThread(&exception_ptrs,

                                                             &assertion);

   }

   if (!success) {

     if (current_handler->previous_iph_) {

       // The handler didn't fully handle the exception.  Give it to the

       // previous invalid parameter handler.

       current_handler->previous_iph_(expression,

                                      function,

                                      file,

                                      line,

                                      reserved);

     } else {

       // If there's no previous handler, pass the exception back in to the

       // invalid parameter handler's core.  That's the routine that called this

       // function, but now, since this function is no longer registered (and in

       // fact, no function at all is registered), this will result in the

       // default code path being taken: _CRT_DEBUGGER_HOOK and _invoke_watson.

       // Use _invalid_parameter where it exists (in _DEBUG builds) as it passes

       // more information through.  In non-debug builds, it is not available,

       // so fall back to using _invalid_parameter_noinfo.  See invarg.c in the

       // CRT source.

 #ifdef _DEBUG

       _invalid_parameter(expression, function, file, line, reserved);

 #else  // _DEBUG

       _invalid_parameter_noinfo();

 #endif  // _DEBUG

     }

   }

   // The handler either took care of the invalid parameter problem itself,

   // or passed it on to another handler.  "Swallow" it by exiting, paralleling

   // the behavior of "swallowing" exceptions.

   exit(0);

 }

 #endif  // _MSC_VER >= 1400

 // static

 void ExceptionHandler::HandlePureVirtualCall() {

   // This is an pure virtual function call, not an exception.  It's safe to

   // play with sprintf here.

   AutoExceptionHandler auto_exception_handler;

   ExceptionHandler* current_handler = auto_exception_handler.get_handler();

   MDRawAssertionInfo assertion;

   memset(&assertion, 0, sizeof(assertion));

   assertion.type = MD_ASSERTION_INFO_TYPE_PURE_VIRTUAL_CALL;

   // Make up an exception record for the current thread and CPU context

   // to make it possible for the crash processor to classify these

   // as do regular crashes, and to make it humane for developers to

   // analyze them.

   EXCEPTION_RECORD exception_record = {};

   CONTEXT exception_context = {};

   EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context };

   ::RtlCaptureContext(&exception_context);

   exception_record.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION;

   // We store pointers to the the expression and function strings,

   // and the line as exception parameters to make them easy to

   // access by the developer on the far side.

   exception_record.NumberParameters = 3;

   exception_record.ExceptionInformation[0] =

       reinterpret_cast<ULONG_PTR>(&assertion.expression);

   exception_record.ExceptionInformation[1] =

       reinterpret_cast<ULONG_PTR>(&assertion.file);

   exception_record.ExceptionInformation[2] = assertion.line;

   bool success = false;

   // In case of out-of-process dump generation, directly call

   // WriteMinidumpWithException since there is no separate thread running.

   if (current_handler->IsOutOfProcess()) {

     success = current_handler->WriteMinidumpWithException(

         GetCurrentThreadId(),

         &exception_ptrs,

         &assertion);

   } else {

     success = current_handler->WriteMinidumpOnHandlerThread(&exception_ptrs,

                                                             &assertion);

   }

   if (!success) {

     if (current_handler->previous_pch_) {

       // The handler didn't fully handle the exception.  Give it to the

       // previous purecall handler.

       current_handler->previous_pch_();

     } else {

       // If there's no previous handler, return and let _purecall handle it.

       // This will just put up an assertion dialog.

       return;

     }

   }

   // The handler either took care of the invalid parameter problem itself,

   // or passed it on to another handler.  "Swallow" it by exiting, paralleling

   // the behavior of "swallowing" exceptions.

   exit(0);

 }

 bool ExceptionHandler::WriteMinidumpOnHandlerThread(

     EXCEPTION_POINTERS* exinfo, MDRawAssertionInfo* assertion) {

   EnterCriticalSection(&handler_critical_section_);

   // There isn't much we can do if the handler thread

   // was not successfully created.

   if (handler_thread_ == NULL) {

     LeaveCriticalSection(&handler_critical_section_);

     return false;

   }

   // The handler thread should only be created when the semaphores are valid.

   assert(handler_start_semaphore_ != NULL);

   assert(handler_finish_semaphore_ != NULL);

   // Set up data to be passed in to the handler thread.

   requesting_thread_id_ = GetCurrentThreadId();

   exception_info_ = exinfo;

   assertion_ = assertion;

   // This causes the handler thread to call WriteMinidumpWithException.

   ReleaseSemaphore(handler_start_semaphore_, 1, NULL);

   // Wait until WriteMinidumpWithException is done and collect its return value.

   WaitForSingleObject(handler_finish_semaphore_, INFINITE);

   bool status = handler_return_value_;

   // Clean up.

   requesting_thread_id_ = 0;

   exception_info_ = NULL;

   assertion_ = NULL;

   LeaveCriticalSection(&handler_critical_section_);

   return status;

 }

 bool ExceptionHandler::WriteMinidump() {

   // Make up an exception record for the current thread and CPU context

   // to make it possible for the crash processor to classify these

   // as do regular crashes, and to make it humane for developers to

   // analyze them.

   EXCEPTION_RECORD exception_record = {};

   CONTEXT exception_context = {};

   EXCEPTION_POINTERS exception_ptrs = { &exception_record, &exception_context };

   ::RtlCaptureContext(&exception_context);

   exception_record.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION;

   return WriteMinidumpForException(&exception_ptrs);

 }

 bool ExceptionHandler::WriteMinidumpForException(EXCEPTION_POINTERS* exinfo) {

   // In case of out-of-process dump generation, directly call

   // WriteMinidumpWithException since there is no separate thread running.

   if (IsOutOfProcess()) {

     return WriteMinidumpWithException(GetCurrentThreadId(),

                                       exinfo,

                                       NULL);

   }

   bool success = WriteMinidumpOnHandlerThread(exinfo, NULL);

   UpdateNextID();

   return success;

 }

 // static

 bool ExceptionHandler::WriteMinidump(const wstring &dump_path,

                                      MinidumpCallback callback,

                                      void* callback_context) {

   ExceptionHandler handler(dump_path, NULL, callback, callback_context,

                            HANDLER_NONE);

   return handler.WriteMinidump();

 }

 // static

 bool ExceptionHandler::WriteMinidumpForChild(HANDLE child,

                                              DWORD child_blamed_thread,

                                              const wstring& dump_path,

                                              MinidumpCallback callback,

                                              void* callback_context) {

   EXCEPTION_RECORD ex;

   CONTEXT ctx;

   EXCEPTION_POINTERS exinfo = { NULL, NULL };

   DWORD last_suspend_count = kFailedToSuspendThread;

   HANDLE child_thread_handle = OpenThread(THREAD_GET_CONTEXT |

                                           THREAD_QUERY_INFORMATION |

                                           THREAD_SUSPEND_RESUME,

                                           FALSE,

                                           child_blamed_thread);

   // This thread may have died already, so not opening the handle is a

   // non-fatal error.

   if (child_thread_handle != NULL) {

     last_suspend_count = SuspendThread(child_thread_handle);

     if (last_suspend_count != kFailedToSuspendThread) {

       ctx.ContextFlags = CONTEXT_ALL;

       if (GetThreadContext(child_thread_handle, &ctx)) {

         memset(&ex, 0, sizeof(ex));

         ex.ExceptionCode = EXCEPTION_BREAKPOINT;

 #if defined(_M_IX86)

         ex.ExceptionAddress = reinterpret_cast<PVOID>(ctx.Eip);

 #elif defined(_M_X64)

         ex.ExceptionAddress = reinterpret_cast<PVOID>(ctx.Rip);

 #endif

         exinfo.ExceptionRecord = &ex;

         exinfo.ContextRecord = &ctx;

       }

     }

   }

   ExceptionHandler handler(dump_path, NULL, callback, callback_context,

                            HANDLER_NONE);

   bool success = handler.WriteMinidumpWithExceptionForProcess(

       child_blamed_thread,

       exinfo.ExceptionRecord ? &exinfo : NULL,

       NULL, child, false);

   if (last_suspend_count != kFailedToSuspendThread) {

     ResumeThread(child_thread_handle);

   }

   CloseHandle(child_thread_handle);

   if (callback) {

     success = callback(handler.dump_path_c_, handler.next_minidump_id_c_,

                        callback_context, NULL, NULL, success);

   }

   return success;

 }

 bool ExceptionHandler::WriteMinidumpWithException(

     DWORD requesting_thread_id,

     EXCEPTION_POINTERS* exinfo,

     MDRawAssertionInfo* assertion) {

   // Give user code a chance to approve or prevent writing a minidump.  If the

   // filter returns false, don't handle the exception at all.  If this method

   // was called as a result of an exception, returning false will cause

   // HandleException to call any previous handler or return

   // EXCEPTION_CONTINUE_SEARCH on the exception thread, allowing it to appear

   // as though this handler were not present at all.

   if (filter_ && !filter_(callback_context_, exinfo, assertion)) {

     return false;

   }

   bool success = false;

   if (IsOutOfProcess()) {

     success = crash_generation_client_->RequestDump(exinfo, assertion);

   } else {

     success = WriteMinidumpWithExceptionForProcess(requesting_thread_id,

                                                    exinfo,

                                                    assertion,

                                                    GetCurrentProcess(),

                                                    true);

   }

   if (callback_) {

     // TODO(munjal): In case of out-of-process dump generation, both

     // dump_path_c_ and next_minidump_id_ will be NULL. For out-of-process

     // scenario, the server process ends up creating the dump path and dump

     // id so they are not known to the client.

     success = callback_(dump_path_c_, next_minidump_id_c_, callback_context_,

                         exinfo, assertion, success);

   }

   return success;

 }

 // static

 BOOL CALLBACK ExceptionHandler::MinidumpWriteDumpCallback(

     PVOID context,

     const PMINIDUMP_CALLBACK_INPUT callback_input,

     PMINIDUMP_CALLBACK_OUTPUT callback_output) {

   switch (callback_input->CallbackType) {

   case MemoryCallback: {

     MinidumpCallbackContext* callback_context =

         reinterpret_cast<MinidumpCallbackContext*>(context);

     if (callback_context->iter == callback_context->end)

       return FALSE;

     // Include the specified memory region.

     callback_output->MemoryBase = callback_context->iter->ptr;

     callback_output->MemorySize = callback_context->iter->length;

     callback_context->iter++;

     return TRUE;

   }

     // Include all modules.

   case IncludeModuleCallback:

   case ModuleCallback:

     return TRUE;

     // Include all threads.

   case IncludeThreadCallback:

   case ThreadCallback:

     return TRUE;

     // Stop receiving cancel callbacks.

   case CancelCallback:

     callback_output->CheckCancel = FALSE;

     callback_output->Cancel = FALSE;

     return TRUE;

   }

   // Ignore other callback types.

   return FALSE;

 }

 bool ExceptionHandler::WriteMinidumpWithExceptionForProcess(

     DWORD requesting_thread_id,

     EXCEPTION_POINTERS* exinfo,

     MDRawAssertionInfo* assertion,

     HANDLE process,

     bool write_requester_stream) {

   bool success = false;

   if (minidump_write_dump_) {

     HANDLE dump_file = CreateFile(next_minidump_path_c_,

                                   GENERIC_WRITE,

                                   0,  // no sharing

                                   NULL,

                                   CREATE_NEW,  // fail if exists

                                   FILE_ATTRIBUTE_NORMAL,

                                   NULL);

     if (dump_file != INVALID_HANDLE_VALUE) {

       MINIDUMP_EXCEPTION_INFORMATION except_info;

       except_info.ThreadId = requesting_thread_id;

       except_info.ExceptionPointers = exinfo;

       except_info.ClientPointers = FALSE;

       // Leave room in user_stream_array for possible breakpad and

       // assertion info streams.

       MINIDUMP_USER_STREAM user_stream_array[2];

       MINIDUMP_USER_STREAM_INFORMATION user_streams;

       user_streams.UserStreamCount = 0;

       user_streams.UserStreamArray = user_stream_array;

       if (write_requester_stream) {

         // Add an MDRawBreakpadInfo stream to the minidump, to provide

         // additional information about the exception handler to the Breakpad

         // processor. The information will help the processor determine which

         // threads are relevant.  The Breakpad processor does not require this

         // information but can function better with Breakpad-generated dumps

         // when it is present. The native debugger is not harmed by the

         // presence of this information.

         MDRawBreakpadInfo breakpad_info;

         breakpad_info.validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID |

                                  MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID;

         breakpad_info.dump_thread_id = GetCurrentThreadId();

         breakpad_info.requesting_thread_id = requesting_thread_id;

         int index = user_streams.UserStreamCount;

         user_stream_array[index].Type = MD_BREAKPAD_INFO_STREAM;

         user_stream_array[index].BufferSize = sizeof(breakpad_info);

         user_stream_array[index].Buffer = &breakpad_info;

         ++user_streams.UserStreamCount;

       }

       if (assertion) {

         int index = user_streams.UserStreamCount;

         user_stream_array[index].Type = MD_ASSERTION_INFO_STREAM;

         user_stream_array[index].BufferSize = sizeof(MDRawAssertionInfo);

         user_stream_array[index].Buffer = assertion;

         ++user_streams.UserStreamCount;

       }

       // Older versions of DbgHelp.dll don't correctly put the memory around

       // the faulting instruction pointer into the minidump. This

       // callback will ensure that it gets included.

       if (exinfo) {

         // Find a memory region of 256 bytes centered on the

         // faulting instruction pointer.

         const ULONG64 instruction_pointer =

 #if defined(_M_IX86)

           exinfo->ContextRecord->Eip;

 #elif defined(_M_AMD64)

         exinfo->ContextRecord->Rip;

 #else

 #error Unsupported platform

 #endif

         MEMORY_BASIC_INFORMATION info;

         if (VirtualQueryEx(process,

                            reinterpret_cast<LPCVOID>(instruction_pointer),

                            &info,

                            sizeof(MEMORY_BASIC_INFORMATION)) != 0 &&

             info.State == MEM_COMMIT) {

           // Attempt to get 128 bytes before and after the instruction

           // pointer, but settle for whatever's available up to the

           // boundaries of the memory region.

           const ULONG64 kIPMemorySize = 256;

           ULONG64 base =

             (std::max)(reinterpret_cast<ULONG64>(info.BaseAddress),

                        instruction_pointer - (kIPMemorySize / 2));

           ULONG64 end_of_range =

             (std::min)(instruction_pointer + (kIPMemorySize / 2),

                        reinterpret_cast<ULONG64>(info.BaseAddress)

                        + info.RegionSize);

           ULONG size = static_cast<ULONG>(end_of_range - base);

           AppMemory& elt = app_memory_info_.front();

           elt.ptr = base;

           elt.length = size;

         }

       }

       MinidumpCallbackContext context;

       context.iter = app_memory_info_.begin();

       context.end = app_memory_info_.end();

       // Skip the reserved element if there was no instruction memory

       if (context.iter->ptr == 0) {

         context.iter++;

       }

       MINIDUMP_CALLBACK_INFORMATION callback;

       callback.CallbackRoutine = MinidumpWriteDumpCallback;

       callback.CallbackParam = reinterpret_cast<void*>(&context);

       // The explicit comparison to TRUE avoids a warning (C4800).

       success = (minidump_write_dump_(process,

                                       GetProcessId(process),

                                       dump_file,

                                       dump_type_,

                                       exinfo ? &except_info : NULL,

                                       &user_streams,

                                       &callback) == TRUE);

       CloseHandle(dump_file);

     }

   }

   return success;

 }

 void ExceptionHandler::UpdateNextID() {

   assert(uuid_create_);

   UUID id = {0};

   if (uuid_create_) {

     uuid_create_(&id);

   }

   next_minidump_id_ = GUIDString::GUIDToWString(&id);

   next_minidump_id_c_ = next_minidump_id_.c_str();

   wchar_t minidump_path[MAX_PATH];

   swprintf(minidump_path, MAX_PATH, L"%s\\%s.dmp",

            dump_path_c_, next_minidump_id_c_);

   // remove when VC++7.1 is no longer supported

   minidump_path[MAX_PATH - 1] = L'\0';

   next_minidump_path_ = minidump_path;

   next_minidump_path_c_ = next_minidump_path_.c_str();

 }

 void ExceptionHandler::RegisterAppMemory(void* ptr, size_t length) {

   AppMemoryList::iterator iter =

     std::find(app_memory_info_.begin(), app_memory_info_.end(), ptr);

   if (iter != app_memory_info_.end()) {

     // Don't allow registering the same pointer twice.

     return;

   }

   AppMemory app_memory;

   app_memory.ptr = reinterpret_cast<ULONG64>(ptr);

   app_memory.length = static_cast<ULONG>(length);

   app_memory_info_.push_back(app_memory);

 }

 void ExceptionHandler::UnregisterAppMemory(void* ptr) {

   AppMemoryList::iterator iter =

     std::find(app_memory_info_.begin(), app_memory_info_.end(), ptr);

   if (iter != app_memory_info_.end()) {

     app_memory_info_.erase(iter);

   }

 }

 }  // namespace google_breakpad