Cross platform low level file IO wrappers

util/file/file_io_win.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "minidump/minidump_writer_util.h"
+#include "util/file/file_io.h"
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "util/stdlib/strlcpy.h"
+
+namespace {
+
+bool IsSocketHandle(HANDLE file) {
+  if (GetFileType(file) == FILE_TYPE_PIPE) {
+    // FILE_TYPE_PIPE means that it's a socket, a named pipe, or an anonymous
+    // pipe. If we are unable to retrieve the pipe information, we know it's a
+    // socket.
+    return !GetNamedPipeInfo(file, NULL, NULL, NULL, NULL);
+  }
+  return false;
+}
+
+}  // namespace
 
 namespace crashpad {
-namespace internal {
 
-// static
-void MinidumpWriterUtil::AssignTimeT(uint32_t* destination, time_t source) {
-  if (!base::IsValueInRangeForNumericType<uint32_t>(source)) {
-    LOG(WARNING) << "timestamp " << source << " out of range";
+// TODO(scottmg): Handle > DWORD sized writes if necessary.
+
+ssize_t ReadFile(FileHandle file, void* buffer, size_t size) {
+  DCHECK(!IsSocketHandle(file));
+  DWORD size_dword = base::checked_cast<DWORD>(size);
+  DWORD total_read = 0;
+  char* buffer_c = reinterpret_cast<char*>(buffer);
+  while (size_dword > 0) {
+    DWORD bytes_read;
+    BOOL success = ::ReadFile(file, buffer_c, size_dword, &bytes_read, nullptr);
+    if (!success && GetLastError() != ERROR_MORE_DATA) {
+      return -1;
+    } else if (success && bytes_read == 0 &&
+               GetFileType(file) != FILE_TYPE_PIPE) {
+      // Zero bytes read for a file indicates reaching EOF. Zero bytes read from
+      // a pipe indicates only that there was a zero byte WriteFile issued on
+      // the other end, so continue reading.
+      break;
+    }
+
+    buffer_c += bytes_read;
+    size_dword -= bytes_read;
+    total_read += bytes_read;
   }
-
-  *destination = source;
+  return total_read;
 }
 
-// static
-base::string16 MinidumpWriterUtil::ConvertUTF8ToUTF16(const std::string& utf8) {
-  base::string16 utf16;
-  if (!base::UTF8ToUTF16(utf8.data(), utf8.length(), &utf16)) {
-    LOG(WARNING) << "string " << utf8
-                 << " cannot be converted to UTF-16 losslessly";
-  }
-  return utf16;
+ssize_t WriteFile(FileHandle file, const void* buffer, size_t size) {
+  // TODO(scottmg): This might need to handle the limit for pipes across a
+  // network in the future.
+  DWORD size_dword = base::checked_cast<DWORD>(size);
+  DWORD bytes_written;
+  BOOL rv = ::WriteFile(file, buffer, size_dword, &bytes_written, nullptr);
+  if (!rv)
+    return -1;
+  CHECK_EQ(bytes_written, size_dword);
+  return bytes_written;
 }
 
-// static
-void MinidumpWriterUtil::AssignUTF8ToUTF16(base::char16* destination,
-                                           size_t destination_size,
-                                           const std::string& source) {
-  base::string16 source_utf16 = ConvertUTF8ToUTF16(source);
-  if (source_utf16.size() > destination_size - 1) {
-    LOG(WARNING) << "string " << source << " UTF-16 length "
-                 << source_utf16.size()
-                 << " will be truncated to UTF-16 length "
-                 << destination_size - 1;
-  }
-
-  source_utf16.resize(destination_size - 1);
-  c16lcpy(destination, source_utf16.c_str(), destination_size);
+bool LoggingCloseFile(FileHandle file) {
+  BOOL rv = CloseHandle(file);
+  PLOG_IF(ERROR, !rv) << "CloseHandle";
+  return rv;
 }
 
-}  // namespace internal
 }  // namespace crashpad