64-bit compatibility changes for the sandbox code

sandbox/src/service_resolver.cc

 // Copyright (c) 2006-2008 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/src/service_resolver.h"
 
 #include "base/logging.h"
 #include "base/pe_image.h"
 #include "base/scoped_ptr.h"
 #include "sandbox/src/sandbox_types.h"
@@ skipping 98 matching lines @@
 bool WriteProtectedChildMemory(HANDLE child_process,
                                void* address,
                                const void* buffer,
                                size_t length) {
   // first, remove the protections
   DWORD old_protection;
   if (!::VirtualProtectEx(child_process, address, length,
                           PAGE_WRITECOPY, &old_protection))
     return false;
 
-  DWORD written;
+  SIZE_T written;
   bool ok = ::WriteProcessMemory(child_process, address, buffer, length,
                                  &written) && (length == written);
 
   // always attempt to restore the original protection
   if (!::VirtualProtectEx(child_process, address, length,
                           old_protection, &old_protection))
     return false;
 
   return ok;
 }
@@ skipping 60 matching lines @@
 
   return STATUS_SUCCESS;
 }
 
 size_t ServiceResolverThunk::GetThunkSize() const {
   return offsetof(ServiceFullThunk, internal_thunk) + GetInternalThunkSize();
 }
 
 bool ServiceResolverThunk::IsFunctionAService(void* local_thunk) const {
   ServiceEntry function_code;
-  DWORD read;
+  SIZE_T read;
   if (!::ReadProcessMemory(process_, target_, &function_code,
                            sizeof(function_code), &read))
     return false;
 
   if (sizeof(function_code) != read)
     return false;
 
   if (kMovEax != function_code.mov_eax ||
       kMovEdx != function_code.mov_edx ||
       (kCallPtrEdx != function_code.call_ptr_edx &&
@@ skipping 75 matching lines @@
     bytes_to_write = offsetof(ServiceEntry, mov_edx);
   }
 
   // setup the thunk
   SetInternalThunk(&full_local_thunk->internal_thunk, GetInternalThunkSize(),
                    remote_thunk, interceptor_);
 
   size_t thunk_size = GetThunkSize();
 
   // copy the local thunk buffer to the child
-  DWORD written;
+  SIZE_T written;
   if (!::WriteProcessMemory(process_, remote_thunk, local_thunk,
                             thunk_size, &written))
     return STATUS_UNSUCCESSFUL;
 
   if (thunk_size != written)
     return STATUS_UNSUCCESSFUL;
 
   // and now change the function to intercept, on the child
   if (NULL != ntdll_base_) {
     // running a unit test
     if (!::WriteProcessMemory(process_, target_, &intercepted_code,
                               bytes_to_write, &written))
       return STATUS_UNSUCCESSFUL;
   } else {
     if (!::WriteProtectedChildMemory(process_, target_, &intercepted_code,
                                      bytes_to_write))
       return STATUS_UNSUCCESSFUL;
   }
 
   return STATUS_SUCCESS;
 }
 
 bool ServiceResolverThunk::SaveOriginalFunction(void* local_thunk,
                                                 void* remote_thunk) {
   ServiceEntry function_code;
-  DWORD read;
+  SIZE_T read;
   if (!::ReadProcessMemory(process_, target_, &function_code,
                            sizeof(function_code), &read))
     return false;
 
   if (sizeof(function_code) != read)
     return false;
 
   if (kJmp32 == function_code.mov_eax) {
     // Plain old entry point patch. The relative jump address follows it.
     ULONG relative = function_code.service_id;
@@ skipping 14 matching lines @@
   }
 
   // Save the verified code
   memcpy(local_thunk, &function_code, sizeof(function_code));
 
   return true;
 }
 
 bool Wow64ResolverThunk::IsFunctionAService(void* local_thunk) const {
   Wow64Entry function_code;
-  DWORD read;
+  SIZE_T read;
   if (!::ReadProcessMemory(process_, target_, &function_code,
                            sizeof(function_code), &read))
     return false;
 
   if (sizeof(function_code) != read)
     return false;
 
   if (kMovEax != function_code.mov_eax || kXorEcx != function_code.xor_ecx ||
       kLeaEdx != function_code.lea_edx || kCallFs1 != function_code.call_fs1 ||
       kCallFs2 != function_code.call_fs2 || kCallFs3 != function_code.call_fs3)
     return false;
 
   if ((kAddEsp1 == function_code.add_esp1 &&
        kAddEsp2 == function_code.add_esp2 &&
        kRet == function_code.ret) || kRet == function_code.add_esp1) {
     // Save the verified code
     memcpy(local_thunk, &function_code, sizeof(function_code));
     return true;
   }
 
   return false;
 }
 
 bool Win2kResolverThunk::IsFunctionAService(void* local_thunk) const {
   ServiceEntry function_code;
-  DWORD read;
+  SIZE_T read;
   if (!::ReadProcessMemory(process_, target_, &function_code,
                            sizeof(function_code), &read))
     return false;
 
   if (sizeof(function_code) != read)
     return false;
 
   if (kMovEax != function_code.mov_eax ||
       function_code.service_id > kMaxService)
     return false;
 
   // Save the verified code
   memcpy(local_thunk, &function_code, sizeof(function_code));
 
   return true;
 }
 
 }  // namespace sandbox