Refactor native_backend_kwallet_x

chrome/browser/password_manager/kwallet_dbus.cc

+// Copyright 2016 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 <chrome/browser/password_manager/kwallet_dbus.h>
+
+#include <memory>
+
+#include "base/logging.h"
+#include "dbus/message.h"
+#include "dbus/object_proxy.h"
+
+namespace {
+
+// DBus service, path, and interface names for klauncher and kwalletd.
+const char kKWalletDName[] = "kwalletd";
+const char kKWalletD5Name[] = "kwalletd5";
+const char kKWalletServiceName[] = "org.kde.kwalletd";
+const char kKWallet5ServiceName[] = "org.kde.kwalletd5";
+const char kKWalletPath[] = "/modules/kwalletd";
+const char kKWallet5Path[] = "/modules/kwalletd5";
+const char kKWalletInterface[] = "org.kde.KWallet";
+const char kKLauncherServiceName[] = "org.kde.klauncher";
+const char kKLauncherPath[] = "/KLauncher";
+const char kKLauncherInterface[] = "org.kde.KLauncher";
+
+}  // namespace
+
+KWalletDBus::KWalletDBus(base::nix::DesktopEnvironment desktop_env)
+    : session_bus_(nullptr), kwallet_proxy_(nullptr) {
+  if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
+    dbus_service_name_ = kKWallet5ServiceName;
+    dbus_path_ = kKWallet5Path;
+    kwalletd_name_ = kKWalletD5Name;
+  } else {
+    dbus_service_name_ = kKWalletServiceName;
+    dbus_path_ = kKWalletPath;
+    kwalletd_name_ = kKWalletDName;
+  }
+}
+
+KWalletDBus::~KWalletDBus() {
+  session_bus_->ShutdownAndBlock();

[vasilii, 2016/06/10 16:58:09]

Why do you kill it here and in NativeBackendKWallet::~NativeBackendKWallet()?
Also threading isn't clear.

[cfroussios, 2016/06/16 12:29:08]

Done. The responsibility of destroying the bus was moved to the owner of
KWalletDBus, but this was left behind.

+}
+
+dbus::Bus* KWalletDBus::GetBus() {
+  return session_bus_.get();
+}
+
+void KWalletDBus::SetSessionBus(scoped_refptr<dbus::Bus> session_bus) {
+  session_bus_ = session_bus;
+  kwallet_proxy_ = session_bus_->GetObjectProxy(dbus_service_name_,
+                                                dbus::ObjectPath(dbus_path_));
+}
+
+bool KWalletDBus::StartKWalletd() {
+  dbus::ObjectProxy* klauncher = session_bus_->GetObjectProxy(
+      kKLauncherServiceName, dbus::ObjectPath(kKLauncherPath));
+
+  dbus::MethodCall method_call(kKLauncherInterface,
+                               "start_service_by_desktop_name");
+  dbus::MessageWriter builder(&method_call);
+  std::vector<std::string> empty;
+  builder.AppendString(kwalletd_name_);  // serviceName
+  builder.AppendArrayOfStrings(empty);   // urls
+  builder.AppendArrayOfStrings(empty);   // envs
+  builder.AppendString(std::string());   // startup_id
+  builder.AppendBool(false);             // blind
+  std::unique_ptr<dbus::Response> response(klauncher->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting klauncher to start " << kwalletd_name_;
+    return false;
+  }
+  dbus::MessageReader reader(response.get());
+  int32_t ret = -1;
+  std::string dbus_name;
+  std::string error;
+  int32_t pid = -1;
+  if (!reader.PopInt32(&ret) || !reader.PopString(&dbus_name) ||
+      !reader.PopString(&error) || !reader.PopInt32(&pid)) {
+    LOG(ERROR) << "Error reading response from klauncher to start "
+               << kwalletd_name_ << ": " << response->ToString();
+    return false;
+  }
+  if (!error.empty() || ret) {
+    LOG(ERROR) << "Error launching " << kwalletd_name_ << ": error '" << error
+               << "' (code " << ret << ")";
+    return false;
+  }
+
+  return true;
+}
+
+KWalletDBus::Error KWalletDBus::IsEnabled(bool* enabled) {
+  dbus::MethodCall method_call(kKWalletInterface, "isEnabled");
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (isEnabled)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopBool(enabled)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (isEnabled): " << response->ToString();
+    return CANNOT_READ;
+  }
+  // Not enabled? Don't use KWallet. But also don't warn here.
+  if (!enabled) {
+    VLOG(1) << kwalletd_name_ << " reports that KWallet is not enabled.";
+  }
+
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::NetworkWallet(std::string* wallet_name) {
+  // Get the wallet name.
+  dbus::MethodCall method_call(kKWalletInterface, "networkWallet");
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (networkWallet)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopString(wallet_name)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (networkWallet): " << response->ToString();
+    return CANNOT_READ;
+  }
+
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::HasEntry(bool* has_entry,
+                                         const int wallet_handle,
+                                         const std::string& folder_name,
+                                         const std::string& signon_realm,
+                                         const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "hasEntry");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(wallet_handle);  // handle
+  builder.AppendString(folder_name);   // folder
+  builder.AppendString(signon_realm);  // key
+  builder.AppendString(app_name);      // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (hasEntry)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopBool(has_entry)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (hasEntry): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::ReadEntry(const uint8_t** bytes,
+                                          size_t* length,
+                                          const int wallet_handle,
+                                          const std::string& folder_name,
+                                          const std::string& signon_realm,
+                                          const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "readEntry");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(wallet_handle);  // handle
+  builder.AppendString(folder_name);   // folder
+  builder.AppendString(signon_realm);  // key
+  builder.AppendString(app_name);      // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (readEntry)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());

[vasilii, 2016/06/10 16:58:09]

It's destroyed here and |bytes| becomes invalid. 

[cfroussios, 2016/06/16 12:29:08]

Done.

+  if (!reader.PopArrayOfBytes(bytes, length)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (readEntry): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::EntryList(
+    std::vector<std::string>* entry_list_ptr,
+    const int wallet_handle,
+    const std::string& folder_name,
+    const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "entryList");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(wallet_handle);  // handle
+  builder.AppendString(folder_name);   // folder
+  builder.AppendString(app_name);      // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (entryList)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopArrayOfStrings(entry_list_ptr)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << "(entryList): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::RemoveEntry(int* rv_ptr,
+                                            const int wallet_handle,
+                                            const std::string& folder_name,
+                                            const std::string& signon_realm,
+                                            const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "removeEntry");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(wallet_handle);  // handle
+  builder.AppendString(folder_name);   // folder
+  builder.AppendString(signon_realm);  // key
+  builder.AppendString(app_name);      // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (removeEntry)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopInt32(rv_ptr)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (removeEntry): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::WriteEntry(int* rv_ptr,
+                                           const int wallet_handle,
+                                           const std::string& folder_name,
+                                           const std::string& signon_realm,
+                                           const uint8_t* data,
+                                           const size_t length,
+                                           const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "writeEntry");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(wallet_handle);        // handle
+  builder.AppendString(folder_name);         // folder
+  builder.AppendString(signon_realm);        // key
+  builder.AppendArrayOfBytes(data, length);  // value
+  builder.AppendString(app_name);            // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (writeEntry)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopInt32(rv_ptr)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (writeEntry): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::Open(int* handle_ptr,
+                                     const std::string& wallet_name,
+                                     const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "open");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendString(wallet_name);  // wallet
+  builder.AppendInt64(0);             // wid
+  builder.AppendString(app_name);     // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (open)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopInt32(handle_ptr)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (open): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::HasFolder(bool* has_folder_ptr,
+                                          const int handle,
+                                          const std::string& folder_name,
+                                          const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "hasFolder");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(handle);        // handle
+  builder.AppendString(folder_name);  // folder
+  builder.AppendString(app_name);     // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (hasFolder)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopBool(has_folder_ptr)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (hasFolder): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}
+
+KWalletDBus::Error KWalletDBus::CreateFolder(bool* success_ptr,
+                                             const int handle,
+                                             const std::string& folder_name,
+                                             const std::string& app_name) {
+  dbus::MethodCall method_call(kKWalletInterface, "createFolder");
+  dbus::MessageWriter builder(&method_call);
+  builder.AppendInt32(handle);        // handle
+  builder.AppendString(folder_name);  // folder
+  builder.AppendString(app_name);     // appid
+  std::unique_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  if (!response.get()) {
+    LOG(ERROR) << "Error contacting << " << kwalletd_name_ << " (createFolder)";
+    return CANNOT_CONTACT;
+  }
+  dbus::MessageReader reader(response.get());
+  if (!reader.PopBool(success_ptr)) {
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (createFolder): " << response->ToString();
+    return CANNOT_READ;
+  }
+  return SUCCESS;
+}