Protect the exception handler against failure to create semaphores & a thread...

client/windows/handler/exception_handler.cc

 // 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
@@ skipping 122 matching lines @@
     // 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);
 
-    DWORD thread_id;
-    handler_thread_ = CreateThread(NULL,         // lpThreadAttributes
-                                   kExceptionHandlerThreadInitialStackSize,
-                                   ExceptionHandlerThreadMain,
-                                   this,         // lpParameter
-                                   0,            // dwCreationFlags
-                                   &thread_id);
+    // 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.
@@ skipping 95 matching lines @@
     DeleteCriticalSection(&handler_critical_section_);
     CloseHandle(handler_start_semaphore_);
     CloseHandle(handler_finish_semaphore_);
   }
 }
 
 // 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.
       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);
@@ skipping 235 matching lines @@
   // 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);
@@ skipping 143 matching lines @@
            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();
 }
 
 }  // namespace google_breakpad