util/ios/ios_intermediate_dump_writer.cc - crashpad/crashpad - Git at Google

 // Copyright 2021 The Crashpad Authors
 //
 // 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 "util/ios/ios_intermediate_dump_writer.h"

 #include <fcntl.h>
 #include <mach/mach.h>
 #include <string.h>
 #include <unistd.h>

 #include <algorithm>
 #include <ostream>

 #include "base/check.h"
 #include "base/check_op.h"
 #include "base/posix/eintr_wrapper.h"
 #include "build/build_config.h"
 #include "util/ios/raw_logging.h"
 #include "util/ios/scoped_vm_read.h"

 namespace crashpad {
 namespace internal {

 // Similar to LoggingWriteFile but with CRASHPAD_RAW_LOG.
 bool RawLoggingWriteFile(int fd, const void* data, size_t size) {
   const char* data_char = static_cast<const char*>(data);
   while (size > 0) {
     ssize_t bytes_written = HANDLE_EINTR(write(fd, data_char, size));
     if (bytes_written < 0 || bytes_written == 0) {
       CRASHPAD_RAW_LOG_ERROR(bytes_written, "RawLoggingWriteFile");
       return false;
     }
     data_char += bytes_written;
     size -= bytes_written;
   }
   return true;
 }

 // Similar to LoggingCloseFile but with CRASHPAD_RAW_LOG.
 bool RawLoggingCloseFile(int fd) {
   int rv = IGNORE_EINTR(close(fd));
   if (rv != 0) {
     CRASHPAD_RAW_LOG_ERROR(rv, "RawLoggingCloseFile");
   }
   return rv == 0;
 }

 IOSIntermediateDumpWriter::~IOSIntermediateDumpWriter() {
   CHECK_EQ(fd_, -1) << "Call Close() before this object is destroyed.";
 }

 bool IOSIntermediateDumpWriter::Open(const base::FilePath& path) {
   // Set data protection class D (No protection). A file with this type of
   // protection can be read from or written to at any time.
   // See:
   // https://support.apple.com/guide/security/data-protection-classes-secb010e978a/web
   constexpr int PROTECTION_CLASS_D = 4;
   fd_ = HANDLE_EINTR(open_dprotected_np(path.value().c_str(),
                                         O_WRONLY | O_CREAT | O_TRUNC,
                                         PROTECTION_CLASS_D,
                                         0 /* dpflags */,
                                         0644 /* mode */));
   if (fd_ < 0) {
     CRASHPAD_RAW_LOG_ERROR(fd_, "open intermediate dump");
     CRASHPAD_RAW_LOG(path.value().c_str());
     return false;
   }

   return true;
 }

 bool IOSIntermediateDumpWriter::Close() {
   if (fd_ < 0) {
     return true;
   }
   const bool flushed = FlushWriteBuffer();
   const bool closed = RawLoggingCloseFile(fd_);
   fd_ = -1;
   return flushed && closed;
 }

 bool IOSIntermediateDumpWriter::AddPropertyCString(IntermediateDumpKey key,
                                                    size_t max_length,
                                                    const char* value) {
   constexpr size_t kMaxStringBytes = 1024;
   if (max_length > kMaxStringBytes) {
     CRASHPAD_RAW_LOG("AddPropertyCString max_length too large");
     return false;
   }

   char buffer[kMaxStringBytes];
   size_t string_length;
   if (ReadCStringInternal(value, buffer, max_length, &string_length)) {
     return Property(key, buffer, string_length);
   }
   return false;
 }

 bool IOSIntermediateDumpWriter::ReadCStringInternal(const char* value,
                                                     char* buffer,
                                                     size_t max_length,
                                                     size_t* string_length) {
   size_t length = 0;
   while (length < max_length) {
     vm_address_t data_address = reinterpret_cast<vm_address_t>(value + length);
     // Calculate bytes to read past `data_address`, either the number of bytes
     // to the end of the page, or the remaining bytes in `buffer`, whichever is
     // smaller.
     size_t data_to_end_of_page =
         getpagesize() - (data_address - trunc_page(data_address));
     size_t remaining_bytes_in_buffer = max_length - length;
     size_t bytes_to_read =
         std::min(data_to_end_of_page, remaining_bytes_in_buffer);

     char* buffer_start = buffer + length;
     size_t bytes_read = 0;
     kern_return_t kr =
         vm_read_overwrite(mach_task_self(),
                           data_address,
                           bytes_to_read,
                           reinterpret_cast<vm_address_t>(buffer_start),
                           &bytes_read);
     if (kr != KERN_SUCCESS || bytes_read <= 0) {
       CRASHPAD_RAW_LOG("ReadCStringInternal vm_read_overwrite failed");
       return false;
     }

     char* nul = static_cast<char*>(memchr(buffer_start, '\0', bytes_read));
     if (nul != nullptr) {
       length += nul - buffer_start;
       *string_length = length;
       return true;
     }
     length += bytes_read;
   }
   CRASHPAD_RAW_LOG("unterminated string");
   return false;
 }

 bool IOSIntermediateDumpWriter::AddPropertyInternal(IntermediateDumpKey key,
                                                     const char* value,
                                                     size_t value_length) {
   ScopedVMRead<char> vmread;
   if (!vmread.Read(value, value_length))
     return false;
   return Property(key, vmread.get(), value_length);
 }

 bool IOSIntermediateDumpWriter::ArrayMapStart() {
   const CommandType command_type = CommandType::kMapStart;
   return BufferedWrite(&command_type, sizeof(command_type));
 }

 bool IOSIntermediateDumpWriter::MapStart(IntermediateDumpKey key) {
   const CommandType command_type = CommandType::kMapStart;
   return BufferedWrite(&command_type, sizeof(command_type)) &&
          BufferedWrite(&key, sizeof(key));
 }

 bool IOSIntermediateDumpWriter::ArrayStart(IntermediateDumpKey key) {
   const CommandType command_type = CommandType::kArrayStart;
   return BufferedWrite(&command_type, sizeof(command_type)) &&
          BufferedWrite(&key, sizeof(key));
 }

 bool IOSIntermediateDumpWriter::MapEnd() {
   const CommandType command_type = CommandType::kMapEnd;
   return BufferedWrite(&command_type, sizeof(command_type));
 }

 bool IOSIntermediateDumpWriter::ArrayEnd() {
   const CommandType command_type = CommandType::kArrayEnd;
   return BufferedWrite(&command_type, sizeof(command_type));
 }

 bool IOSIntermediateDumpWriter::RootMapStart() {
   const CommandType command_type = CommandType::kRootMapStart;
   return BufferedWrite(&command_type, sizeof(command_type));
 }

 bool IOSIntermediateDumpWriter::RootMapEnd() {
   const CommandType command_type = CommandType::kRootMapEnd;
   return BufferedWrite(&command_type, sizeof(command_type));
 }

 bool IOSIntermediateDumpWriter::Property(IntermediateDumpKey key,
                                          const void* value,
                                          size_t value_length) {
   const CommandType command_type = CommandType::kProperty;
   return BufferedWrite(&command_type, sizeof(command_type)) &&
          BufferedWrite(&key, sizeof(key)) &&
          BufferedWrite(&value_length, sizeof(size_t)) &&
          BufferedWrite(value, value_length);
 }

 bool IOSIntermediateDumpWriter::FlushWriteBuffer() {
   size_t size = buffer_occupied_;
   buffer_occupied_ = 0;
   return RawLoggingWriteFile(fd_, buffer_, size);
 }

 bool IOSIntermediateDumpWriter::BufferedWrite(const void* data,
                                               size_t data_size) {
   const char* data_char = static_cast<const char*>(data);
   // If `buffer_` is occupied, fill it up first, and flush if full.
   if (buffer_occupied_ > 0) {
     size_t data_size_to_copy =
         std::min(kBufferSize - buffer_occupied_, data_size);
     memcpy(buffer_ + buffer_occupied_, data_char, data_size_to_copy);
     buffer_occupied_ += data_size_to_copy;
     data_char += data_size_to_copy;
     data_size -= data_size_to_copy;

     if (buffer_occupied_ == kBufferSize) {
       if (!FlushWriteBuffer()) {
         return false;
       }
     }
   }

   // Either `data_size` is big enough that it could fill `buffer_`, trigger
   // a FlushWriteBuffer, and reset `buffer_occuppied_` to zero, or there is no
   // data left to process.
   DCHECK(buffer_occupied_ == 0 || data_size == 0);

   // Write the rest of the `data` in an increment of kBufferSize.
   if (data_size >= kBufferSize) {
     DCHECK_EQ(buffer_occupied_, 0u);
     size_t data_size_to_write = data_size - (data_size % kBufferSize);
     if (!RawLoggingWriteFile(fd_, data_char, data_size_to_write)) {
       return false;
     }
     data_char += data_size_to_write;
     data_size -= data_size_to_write;
   }

   // If there's any `data` left, put it in `buffer_`.
   if (data_size > 0) {
     DCHECK_EQ(buffer_occupied_, 0u);
     memcpy(buffer_, data_char, data_size);
     buffer_occupied_ = data_size;
   }

   return true;
 }

 }  // namespace internal
 }  // namespace crashpad
	// Copyright 2021 The Crashpad Authors
	//
	// 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 "util/ios/ios_intermediate_dump_writer.h"

	#include <fcntl.h>
	#include <mach/mach.h>
	#include <string.h>
	#include <unistd.h>

	#include <algorithm>
	#include <ostream>

	#include "base/check.h"
	#include "base/check_op.h"
	#include "base/posix/eintr_wrapper.h"
	#include "build/build_config.h"
	#include "util/ios/raw_logging.h"
	#include "util/ios/scoped_vm_read.h"

	namespace crashpad {
	namespace internal {

	// Similar to LoggingWriteFile but with CRASHPAD_RAW_LOG.
	bool RawLoggingWriteFile(int fd, const void* data, size_t size) {
	const char* data_char = static_cast<const char*>(data);
	while (size > 0) {
	ssize_t bytes_written = HANDLE_EINTR(write(fd, data_char, size));
	if (bytes_written < 0 \|\| bytes_written == 0) {
	CRASHPAD_RAW_LOG_ERROR(bytes_written, "RawLoggingWriteFile");
	return false;
	}
	data_char += bytes_written;
	size -= bytes_written;
	}
	return true;
	}

	// Similar to LoggingCloseFile but with CRASHPAD_RAW_LOG.
	bool RawLoggingCloseFile(int fd) {
	int rv = IGNORE_EINTR(close(fd));
	if (rv != 0) {
	CRASHPAD_RAW_LOG_ERROR(rv, "RawLoggingCloseFile");
	}
	return rv == 0;
	}

	IOSIntermediateDumpWriter::~IOSIntermediateDumpWriter() {
	CHECK_EQ(fd_, -1) << "Call Close() before this object is destroyed.";
	}

	bool IOSIntermediateDumpWriter::Open(const base::FilePath& path) {
	// Set data protection class D (No protection). A file with this type of
	// protection can be read from or written to at any time.
	// See:
	// https://support.apple.com/guide/security/data-protection-classes-secb010e978a/web
	constexpr int PROTECTION_CLASS_D = 4;
	fd_ = HANDLE_EINTR(open_dprotected_np(path.value().c_str(),
	O_WRONLY \| O_CREAT \| O_TRUNC,
	PROTECTION_CLASS_D,
	0 /* dpflags */,
	0644 /* mode */));
	if (fd_ < 0) {
	CRASHPAD_RAW_LOG_ERROR(fd_, "open intermediate dump");
	CRASHPAD_RAW_LOG(path.value().c_str());
	return false;
	}

	return true;
	}

	bool IOSIntermediateDumpWriter::Close() {
	if (fd_ < 0) {
	return true;
	}
	const bool flushed = FlushWriteBuffer();
	const bool closed = RawLoggingCloseFile(fd_);
	fd_ = -1;
	return flushed && closed;
	}

	bool IOSIntermediateDumpWriter::AddPropertyCString(IntermediateDumpKey key,
	size_t max_length,
	const char* value) {
	constexpr size_t kMaxStringBytes = 1024;
	if (max_length > kMaxStringBytes) {
	CRASHPAD_RAW_LOG("AddPropertyCString max_length too large");
	return false;
	}

	char buffer[kMaxStringBytes];
	size_t string_length;
	if (ReadCStringInternal(value, buffer, max_length, &string_length)) {
	return Property(key, buffer, string_length);
	}
	return false;
	}

	bool IOSIntermediateDumpWriter::ReadCStringInternal(const char* value,
	char* buffer,
	size_t max_length,
	size_t* string_length) {
	size_t length = 0;
	while (length < max_length) {
	vm_address_t data_address = reinterpret_cast<vm_address_t>(value + length);
	// Calculate bytes to read past `data_address`, either the number of bytes
	// to the end of the page, or the remaining bytes in `buffer`, whichever is
	// smaller.
	size_t data_to_end_of_page =
	getpagesize() - (data_address - trunc_page(data_address));
	size_t remaining_bytes_in_buffer = max_length - length;
	size_t bytes_to_read =
	std::min(data_to_end_of_page, remaining_bytes_in_buffer);

	char* buffer_start = buffer + length;
	size_t bytes_read = 0;
	kern_return_t kr =
	vm_read_overwrite(mach_task_self(),
	data_address,
	bytes_to_read,
	reinterpret_cast<vm_address_t>(buffer_start),
	&bytes_read);
	if (kr != KERN_SUCCESS \|\| bytes_read <= 0) {
	CRASHPAD_RAW_LOG("ReadCStringInternal vm_read_overwrite failed");
	return false;
	}

	char* nul = static_cast<char*>(memchr(buffer_start, '\0', bytes_read));
	if (nul != nullptr) {
	length += nul - buffer_start;
	*string_length = length;
	return true;
	}
	length += bytes_read;
	}
	CRASHPAD_RAW_LOG("unterminated string");
	return false;
	}

	bool IOSIntermediateDumpWriter::AddPropertyInternal(IntermediateDumpKey key,
	const char* value,
	size_t value_length) {
	ScopedVMRead<char> vmread;
	if (!vmread.Read(value, value_length))
	return false;
	return Property(key, vmread.get(), value_length);
	}

	bool IOSIntermediateDumpWriter::ArrayMapStart() {
	const CommandType command_type = CommandType::kMapStart;
	return BufferedWrite(&command_type, sizeof(command_type));
	}

	bool IOSIntermediateDumpWriter::MapStart(IntermediateDumpKey key) {
	const CommandType command_type = CommandType::kMapStart;
	return BufferedWrite(&command_type, sizeof(command_type)) &&
	BufferedWrite(&key, sizeof(key));
	}

	bool IOSIntermediateDumpWriter::ArrayStart(IntermediateDumpKey key) {
	const CommandType command_type = CommandType::kArrayStart;
	return BufferedWrite(&command_type, sizeof(command_type)) &&
	BufferedWrite(&key, sizeof(key));
	}

	bool IOSIntermediateDumpWriter::MapEnd() {
	const CommandType command_type = CommandType::kMapEnd;
	return BufferedWrite(&command_type, sizeof(command_type));
	}

	bool IOSIntermediateDumpWriter::ArrayEnd() {
	const CommandType command_type = CommandType::kArrayEnd;
	return BufferedWrite(&command_type, sizeof(command_type));
	}

	bool IOSIntermediateDumpWriter::RootMapStart() {
	const CommandType command_type = CommandType::kRootMapStart;
	return BufferedWrite(&command_type, sizeof(command_type));
	}

	bool IOSIntermediateDumpWriter::RootMapEnd() {
	const CommandType command_type = CommandType::kRootMapEnd;
	return BufferedWrite(&command_type, sizeof(command_type));
	}

	bool IOSIntermediateDumpWriter::Property(IntermediateDumpKey key,
	const void* value,
	size_t value_length) {
	const CommandType command_type = CommandType::kProperty;
	return BufferedWrite(&command_type, sizeof(command_type)) &&
	BufferedWrite(&key, sizeof(key)) &&
	BufferedWrite(&value_length, sizeof(size_t)) &&
	BufferedWrite(value, value_length);
	}

	bool IOSIntermediateDumpWriter::FlushWriteBuffer() {
	size_t size = buffer_occupied_;
	buffer_occupied_ = 0;
	return RawLoggingWriteFile(fd_, buffer_, size);
	}

	bool IOSIntermediateDumpWriter::BufferedWrite(const void* data,
	size_t data_size) {
	const char* data_char = static_cast<const char*>(data);
	// If `buffer_` is occupied, fill it up first, and flush if full.
	if (buffer_occupied_ > 0) {
	size_t data_size_to_copy =
	std::min(kBufferSize - buffer_occupied_, data_size);
	memcpy(buffer_ + buffer_occupied_, data_char, data_size_to_copy);
	buffer_occupied_ += data_size_to_copy;
	data_char += data_size_to_copy;
	data_size -= data_size_to_copy;

	if (buffer_occupied_ == kBufferSize) {
	if (!FlushWriteBuffer()) {
	return false;
	}
	}
	}

	// Either `data_size` is big enough that it could fill `buffer_`, trigger
	// a FlushWriteBuffer, and reset `buffer_occuppied_` to zero, or there is no
	// data left to process.
	DCHECK(buffer_occupied_ == 0 \|\| data_size == 0);

	// Write the rest of the `data` in an increment of kBufferSize.
	if (data_size >= kBufferSize) {
	DCHECK_EQ(buffer_occupied_, 0u);
	size_t data_size_to_write = data_size - (data_size % kBufferSize);
	if (!RawLoggingWriteFile(fd_, data_char, data_size_to_write)) {
	return false;
	}
	data_char += data_size_to_write;
	data_size -= data_size_to_write;
	}

	// If there's any `data` left, put it in `buffer_`.
	if (data_size > 0) {
	DCHECK_EQ(buffer_occupied_, 0u);
	memcpy(buffer_, data_char, data_size);
	buffer_occupied_ = data_size;
	}

	return true;
	}

	} // namespace internal
	} // namespace crashpad