Wire up process launch error codes.

sandbox/win/src/target_process.cc

 // Copyright (c) 2012 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.
 
 #include "sandbox/win/src/target_process.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 101 matching lines @@
     }
   }
 
   // ipc_server_ references our process handle, so make sure the former is shut
   // down before the latter is closed (by ScopedProcessInformation).
   ipc_server_.reset();
 }
 
 // Creates the target (child) process suspended and assigns it to the job
 // object.
-DWORD TargetProcess::Create(const wchar_t* exe_path,
-                            const wchar_t* command_line,
-                            bool inherit_handles,
-                            const base::win::StartupInformation& startup_info,
-                            base::win::ScopedProcessInformation* target_info) {
+ResultCode TargetProcess::Create(
+    const wchar_t* exe_path,
+    const wchar_t* command_line,
+    bool inherit_handles,
+    const base::win::StartupInformation& startup_info,
+    base::win::ScopedProcessInformation* target_info,
+    DWORD* win_error) {
   if (lowbox_token_.IsValid() &&
       base::win::GetVersion() < base::win::VERSION_WIN8) {
     // We don't allow lowbox_token below Windows 8.
-    return ERROR_INVALID_PARAMETER;
+    return SBOX_ERROR_BAD_PARAMS;
   }
 
   exe_name_.reset(_wcsdup(exe_path));
 
   // the command line needs to be writable by CreateProcess().
   std::unique_ptr<wchar_t, base::FreeDeleter> cmd_line(_wcsdup(command_line));
 
   // Start the target process suspended.
   DWORD flags =
       CREATE_SUSPENDED | CREATE_UNICODE_ENVIRONMENT | DETACHED_PROCESS;
 
   if (startup_info.has_extended_startup_info())
     flags |= EXTENDED_STARTUPINFO_PRESENT;
 
   if (job_ && base::win::GetVersion() < base::win::VERSION_WIN8) {
     // Windows 8 implements nested jobs, but for older systems we need to
     // break out of any job we're in to enforce our restrictions.
     flags |= CREATE_BREAKAWAY_FROM_JOB;
   }
 
   PROCESS_INFORMATION temp_process_info = {};
   if (!::CreateProcessAsUserW(lockdown_token_.Get(), exe_path, cmd_line.get(),
                               NULL,  // No security attribute.
                               NULL,  // No thread attribute.
                               inherit_handles, flags,
                               NULL,  // Use the environment of the caller.
                               NULL,  // Use current directory of the caller.
                               startup_info.startup_info(),
                               &temp_process_info)) {
-    return ::GetLastError();
+    *win_error = ::GetLastError();
+    return SBOX_ERROR_CREATE_PROCESS;
   }
   base::win::ScopedProcessInformation process_info(temp_process_info);
 
-  DWORD win_result = ERROR_SUCCESS;
-
   if (job_) {
     // Assign the suspended target to the windows job object.
     if (!::AssignProcessToJobObject(job_, process_info.process_handle())) {
-      win_result = ::GetLastError();
+      *win_error = ::GetLastError();
       ::TerminateProcess(process_info.process_handle(), 0);
-      return win_result;
+      return SBOX_ERROR_ASSIGN_PROCESS_TO_JOB_OBJECT;
     }
   }
 
   if (initial_token_.IsValid()) {
     // Change the token of the main thread of the new process for the
     // impersonation token with more rights. This allows the target to start;
     // otherwise it will crash too early for us to help.
     HANDLE temp_thread = process_info.thread_handle();
     if (!::SetThreadToken(&temp_thread, initial_token_.Get())) {
-      win_result = ::GetLastError();
+      *win_error = ::GetLastError();
       // It might be a security breach if we let the target run outside the job
       // so kill it before it causes damage.
       ::TerminateProcess(process_info.process_handle(), 0);
-      return win_result;
+      return SBOX_ERROR_SET_THREAD_TOKEN;
     }
     initial_token_.Close();
   }
 
   CONTEXT context;
   context.ContextFlags = CONTEXT_ALL;
   if (!::GetThreadContext(process_info.thread_handle(), &context)) {
-    win_result = ::GetLastError();
+    *win_error = ::GetLastError();
     ::TerminateProcess(process_info.process_handle(), 0);
-    return win_result;
+    return SBOX_ERROR_GET_THREAD_CONTEXT;
   }
 
 #if defined(_WIN64)
   void* entry_point = reinterpret_cast<void*>(context.Rcx);
 #else
 #pragma warning(push)
 #pragma warning(disable: 4312)
   // This cast generates a warning because it is 32 bit specific.
   void* entry_point = reinterpret_cast<void*>(context.Eax);
 #pragma warning(pop)
 #endif  // _WIN64
 
   if (!target_info->DuplicateFrom(process_info)) {
-    win_result = ::GetLastError();  // This may or may not be correct.
+    *win_error = ::GetLastError();  // This may or may not be correct.
     ::TerminateProcess(process_info.process_handle(), 0);
-    return win_result;
+    return SBOX_ERROR_DUPLICATE_TARGET_INFO;
   }
 
   if (lowbox_token_.IsValid()) {
     PROCESS_ACCESS_TOKEN process_access_token;
     process_access_token.thread = process_info.thread_handle();
     process_access_token.token = lowbox_token_.Get();
 
     NtSetInformationProcess SetInformationProcess = NULL;
     ResolveNTFunctionPtr("NtSetInformationProcess", &SetInformationProcess);
 
     NTSTATUS status = SetInformationProcess(
         process_info.process_handle(),
         static_cast<PROCESS_INFORMATION_CLASS>(NtProcessInformationAccessToken),
         &process_access_token, sizeof(process_access_token));
     if (!NT_SUCCESS(status)) {
-      win_result = ERROR_INVALID_TOKEN;
+      *win_error = ERROR_INVALID_TOKEN;
       ::TerminateProcess(process_info.process_handle(), 0);  // exit code
-      return win_result;
+      return SBOX_ERROR_SET_LOW_BOX_TOKEN;
     }
   }
 
   base_address_ = GetBaseAddress(exe_path, entry_point);
   sandbox_process_info_.Set(process_info.Take());
-  return win_result;
+  return SBOX_ALL_OK;
 }
 
 ResultCode TargetProcess::TransferVariable(const char* name, void* address,
                                            size_t size) {
   if (!sandbox_process_info_.IsValid())
     return SBOX_ERROR_UNEXPECTED_CALL;
 
   void* child_var = address;
 
 #if SANDBOX_EXPORTS
@@ skipping 18 matching lines @@
     return SBOX_ERROR_GENERIC;
 
   if (written != size)
     return SBOX_ERROR_GENERIC;
 
   return SBOX_ALL_OK;
 }
 
 // Construct the IPC server and the IPC dispatcher. When the target does
 // an IPC it will eventually call the dispatcher.
-DWORD TargetProcess::Init(Dispatcher* ipc_dispatcher,
-                          void* policy,
-                          uint32_t shared_IPC_size,
-                          uint32_t shared_policy_size) {
+ResultCode TargetProcess::Init(Dispatcher* ipc_dispatcher,
+                               void* policy,
+                               uint32_t shared_IPC_size,
+                               uint32_t shared_policy_size,
+                               DWORD* win_error) {
   // We need to map the shared memory on the target. This is necessary for
   // any IPC that needs to take place, even if the target has not yet hit
   // the main( ) function or even has initialized the CRT. So here we set
   // the handle to the shared section. The target on the first IPC must do
   // the rest, which boils down to calling MapViewofFile()
 
   // We use this single memory pool for IPC and for policy.
   DWORD shared_mem_size = static_cast<DWORD>(shared_IPC_size +
                                              shared_policy_size);
   shared_section_.Set(::CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
                                            PAGE_READWRITE | SEC_COMMIT,
                                            0, shared_mem_size, NULL));
   if (!shared_section_.IsValid()) {
-    return ::GetLastError();
+    *win_error = ::GetLastError();
+    return SBOX_ERROR_CREATE_FILE_MAPPING;
   }
 
   DWORD access = FILE_MAP_READ | FILE_MAP_WRITE | SECTION_QUERY;
   HANDLE target_shared_section;
   if (!::DuplicateHandle(::GetCurrentProcess(), shared_section_.Get(),
                          sandbox_process_info_.process_handle(),
                          &target_shared_section, access, FALSE, 0)) {
-    return ::GetLastError();
+    *win_error = ::GetLastError();
+    return SBOX_ERROR_DUPLICATE_SHARED_SECTION;
   }
 
   void* shared_memory = ::MapViewOfFile(shared_section_.Get(),
                                         FILE_MAP_WRITE|FILE_MAP_READ,
                                         0, 0, 0);
   if (NULL == shared_memory) {
-    return ::GetLastError();
+    *win_error = ::GetLastError();
+    return SBOX_ERROR_MAP_VIEW_OF_SHARED_SECTION;
   }
 
   CopyPolicyToTarget(policy, shared_policy_size,
                      reinterpret_cast<char*>(shared_memory) + shared_IPC_size);
 
   ResultCode ret;
   // Set the global variables in the target. These are not used on the broker.
   g_shared_section = target_shared_section;
   ret = TransferVariable("g_shared_section", &g_shared_section,
                          sizeof(g_shared_section));
   g_shared_section = NULL;
   if (SBOX_ALL_OK != ret) {
-    return (SBOX_ERROR_GENERIC == ret)?
-           ::GetLastError() : ERROR_INVALID_FUNCTION;
+    *win_error = ::GetLastError();
+    return ret;
   }
   g_shared_IPC_size = shared_IPC_size;
   ret = TransferVariable("g_shared_IPC_size", &g_shared_IPC_size,
                          sizeof(g_shared_IPC_size));
   g_shared_IPC_size = 0;
   if (SBOX_ALL_OK != ret) {
-    return (SBOX_ERROR_GENERIC == ret) ?
-           ::GetLastError() : ERROR_INVALID_FUNCTION;
+    *win_error = ::GetLastError();
+    return ret;
   }
   g_shared_policy_size = shared_policy_size;
   ret = TransferVariable("g_shared_policy_size", &g_shared_policy_size,
                          sizeof(g_shared_policy_size));
   g_shared_policy_size = 0;
   if (SBOX_ALL_OK != ret) {
-    return (SBOX_ERROR_GENERIC == ret) ?
-           ::GetLastError() : ERROR_INVALID_FUNCTION;
+    *win_error = ::GetLastError();
+    return ret;
   }
 
   ipc_server_.reset(
       new SharedMemIPCServer(sandbox_process_info_.process_handle(),
                              sandbox_process_info_.process_id(),
                              thread_pool_, ipc_dispatcher));
 
   if (!ipc_server_->Init(shared_memory, shared_IPC_size, kIPCChannelSize))
-    return ERROR_NOT_ENOUGH_MEMORY;
+    return SBOX_ERROR_NO_SPACE;
 
   // After this point we cannot use this handle anymore.
   ::CloseHandle(sandbox_process_info_.TakeThreadHandle());
 
-  return ERROR_SUCCESS;
+  return SBOX_ALL_OK;
 }
 
 void TargetProcess::Terminate() {
   if (!sandbox_process_info_.IsValid())
     return;
 
   ::TerminateProcess(sandbox_process_info_.process_handle(), 0);
 }
 
 TargetProcess* MakeTestTargetProcess(HANDLE process, HMODULE base_address) {
   TargetProcess* target =
       new TargetProcess(base::win::ScopedHandle(), base::win::ScopedHandle(),
                         base::win::ScopedHandle(), NULL, NULL);
   PROCESS_INFORMATION process_info = {};
   process_info.hProcess = process;
   target->sandbox_process_info_.Set(process_info);
   target->base_address_ = base_address;
   return target;
 }
 
 }  // namespace sandbox