Define the Settings interface for a CrashReportDatabase and provide a Mac implementation.

client/settings.cc

+// Copyright 2015 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 "client/settings.h"
+
+#include <limits>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <uuid/uuid.h>
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "util/numeric/in_range_cast.h"
+
+namespace crashpad {
+
+struct ALIGNAS(4) Settings::Data {
+  static const uint16_t kSettingsVersion = 1;
+
+  Data() : version(kSettingsVersion),
+           options(0),
+           last_upload_attempt_time(0),
+           client_id() {}
+
+  enum Options : uint32_t {
+    kUploadsEnabled = 1 << 0,
+  };
+
+  uint32_t version;
+  uint32_t options;
+  uint64_t last_upload_attempt_time;  // time_t
+  UUID client_id;
+};
+
+Settings::Settings(const base::FilePath& file_path)
+    : file_path_(file_path) {

[Mark Mentovai, 2015/03/09 22:41:34]

, initialized_()

[Robert Sesek, 2015/03/09 22:44:39]

Done.

+}
+
+Settings::~Settings() {
+}
+
+bool Settings::Initialize() {
+  INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
+
+  ScopedFileHandle handle(HANDLE_EINTR(
+      open(file_path(),
+           O_CREAT | O_EXCL | O_WRONLY | O_EXLOCK,
+           0644)));
+
+  // The file was created, so this is a new database that needs to be
+  // initialized with a client ID.
+  if (handle.is_valid()) {
+    bool initialized = InitializeSettings(handle.get());
+    if (initialized)
+      INITIALIZATION_STATE_SET_VALID(initialized_);
+    return initialized;
+  }
+
+  // The file wasn't created, try opening it for a write operation. If the file
+  // needs to be recovered, writing is necessary. This also ensures that the
+  // process has permission to write the file.
+  Data settings;
+  if (!OpenForWritingAndReadSettings(&settings).is_valid())
+    return false;
+
+  INITIALIZATION_STATE_SET_VALID(initialized_);
+  return true;
+}
+
+bool Settings::GetClientID(UUID* client_id) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  Data settings;
+  if (!OpenAndReadSettings(&settings))
+    return false;
+
+  *client_id = settings.client_id;
+  return true;
+}
+
+bool Settings::GetUploadsEnabled(bool* enabled) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  Data settings;
+  if (!OpenAndReadSettings(&settings))
+    return false;
+
+  *enabled = (settings.options & Data::Options::kUploadsEnabled) != 0;
+  return true;
+}
+
+bool Settings::SetUploadsEnabled(bool enabled) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  Data settings;
+  ScopedFileHandle handle = OpenForWritingAndReadSettings(&settings);
+  if (!handle.is_valid())
+    return false;
+
+  if (enabled)
+    settings.options |= Data::Options::kUploadsEnabled;
+  else
+    settings.options &= ~Data::Options::kUploadsEnabled;
+
+  return WriteSettings(handle.get(), settings);
+}
+
+bool Settings::GetLastUploadAttemptTime(time_t* time) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  Data settings;
+  if (!OpenAndReadSettings(&settings))
+    return false;
+
+  *time = InRangeCast<time_t>(settings.last_upload_attempt_time,
+                              std::numeric_limits<time_t>::max());
+  return true;
+}
+
+bool Settings::SetLastUploadAttemptTime(time_t time) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  Data settings;
+  ScopedFileHandle handle = OpenForWritingAndReadSettings(&settings);
+  if (!handle.is_valid())
+    return false;
+
+  settings.last_upload_attempt_time = InRangeCast<uint64_t>(time, 0);
+
+  return WriteSettings(handle.get(), settings);
+}
+
+ScopedFileHandle Settings::OpenForReading() {
+  ScopedFileHandle handle(HANDLE_EINTR(open(file_path(), O_RDONLY | O_SHLOCK)));
+  PLOG_IF(ERROR, !handle.is_valid()) << "open for reading";
+  return handle.Pass();
+}
+
+ScopedFileHandle Settings::OpenForReadingAndWriting() {
+  ScopedFileHandle handle(HANDLE_EINTR(
+      open(file_path(), O_RDWR | O_EXLOCK | O_CREAT)));
+  PLOG_IF(ERROR, !handle.is_valid()) << "open for writing";
+  return handle.Pass();
+}
+
+bool Settings::OpenAndReadSettings(Data* out_data) {
+  ScopedFileHandle handle = OpenForReading();
+  if (!handle.is_valid())
+    return false;
+
+  if (ReadSettings(handle.get(), out_data))
+    return true;
+
+  // The settings file is corrupt, so reinitialize it.
+  handle.reset();
+
+  // The settings failed to be read, so re-initialize them.
+  return RecoverSettings(kInvalidFileHandle, out_data);
+}
+
+ScopedFileHandle Settings::OpenForWritingAndReadSettings(Data* out_data) {
+  ScopedFileHandle handle = OpenForReadingAndWriting();
+  if (!handle.is_valid())
+    return ScopedFileHandle();
+
+  if (!ReadSettings(handle.get(), out_data)) {
+    if (!RecoverSettings(handle.get(), out_data))
+      return ScopedFileHandle();
+  }
+
+  return handle.Pass();
+}
+
+bool Settings::ReadSettings(FileHandle handle, Data* out_data) {
+  if (LoggingSeekFile(handle, 0, SEEK_SET) != 0)
+    return false;
+
+  if (!LoggingReadFile(handle, out_data, sizeof(*out_data)))
+    return false;
+
+  if (out_data->version != Data::kSettingsVersion) {
+    LOG(ERROR) << "Settings version is not " << Data::kSettingsVersion;
+    return false;
+  }
+
+  return true;
+}
+
+bool Settings::WriteSettings(FileHandle handle, const Data& data) {
+  if (LoggingSeekFile(handle, 0, SEEK_SET) != 0)
+    return false;
+
+  if (HANDLE_EINTR(ftruncate(handle, 0)) != 0) {
+    PLOG(ERROR) << "ftruncate settings file";
+    return false;
+  }
+
+  return LoggingWriteFile(handle, &data, sizeof(Data));
+}
+
+bool Settings::RecoverSettings(FileHandle handle, Data* out_data) {
+  ScopedFileHandle scoped_handle;
+  if (handle == kInvalidFileHandle) {
+    scoped_handle.reset(OpenForReadingAndWriting().release());
+    handle = scoped_handle.get();
+
+    // Test if the file has already been recovered now that the exclusive lock
+    // is held.
+    if (ReadSettings(handle, out_data))
+      return true;
+  }
+
+  LOG(INFO) << "Recovering settings file " << file_path();
+
+  if (handle == kInvalidFileHandle) {
+    LOG(ERROR) << "Invalid file handle";
+    return false;
+  }
+
+  if (!InitializeSettings(handle))
+    return false;
+
+  return ReadSettings(handle, out_data);
+}
+
+bool Settings::InitializeSettings(FileHandle handle) {
+  uuid_t uuid;
+  uuid_generate(uuid);
+
+  Data settings;
+  settings.client_id.InitializeFromBytes(uuid);
+
+  return WriteSettings(handle, settings);
+}
+
+}  // namespace crashpad