add more ownership API methods to libcros

chromeos_login.cc

 // Copyright (c) 2010 The Chromium OS 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 "chromeos_login.h"  // NOLINT
 
 #include <vector>
 
 #include <base/basictypes.h>
 #include <base/string_util.h>
 #include <dbus/dbus-glib-lowlevel.h>
 #include <chromeos/dbus/dbus.h>
 #include <chromeos/dbus/service_constants.h>
 #include <chromeos/glib/object.h>
 
 #include "marshal.glibmarshal.h"  // NOLINT
 
 namespace chromeos {  // NOLINT
 
+
+#define SCOPED_SAFE_MESSAGE(e) (e->message ? e->message : "unknown error")
+
 namespace {
 chromeos::dbus::Proxy CreateProxy() {
   dbus::BusConnection bus = dbus::GetSystemBusConnection();
   return chromeos::dbus::Proxy(bus,
                                login_manager::kSessionManagerServiceName,
                                login_manager::kSessionManagerServicePath,
                                login_manager::kSessionManagerInterface);
 }
 }  // Anonymous namespace.
 
@@ skipping 11 matching lines @@
   }
 
  private:
   SessionMonitor monitor_;
   void* object_;
 
   DISALLOW_COPY_AND_ASSIGN(OpaqueSessionConnection);
 };
 
 extern "C"
+bool ChromeOSCheckWhitelist(const char* email,
+                            std::vector<uint8>* signature) {
+  DCHECK(signature);
+  chromeos::dbus::Proxy proxy = CreateProxy();
+  chromeos::glib::ScopedError error;
+
+  GArray* sig;
+
+  if (!::dbus_g_proxy_call(proxy.gproxy(),
+                           login_manager::kSessionManagerCheckWhitelist,
+                           &Resetter(&error).lvalue(),
+                           G_TYPE_STRING, email,
+                           G_TYPE_INVALID,
+                           DBUS_TYPE_G_UCHAR_ARRAY, &sig,
+                           G_TYPE_INVALID)) {
+    LOG(WARNING) << login_manager::kSessionManagerCheckWhitelist << " failed: "
+                 << SCOPED_SAFE_MESSAGE(error);
+    return false;
+  }
+  bool rv = false;
+  signature->resize(sig->len);
+  if (signature->size() == sig->len) {
+    memcpy(&(signature->at(0)), static_cast<const void*>(sig->data), sig->len);
+    rv = true;
+  }
+  g_array_free(sig, false);
+  return rv;
+}
+
+extern "C"
 bool ChromeOSEmitLoginPromptReady() {
   chromeos::dbus::Proxy proxy = CreateProxy();
   gboolean done = false;
   chromeos::glib::ScopedError error;
 
   if (!::dbus_g_proxy_call(proxy.gproxy(),
                            login_manager::kSessionManagerEmitLoginPromptReady,
                            &Resetter(&error).lvalue(),
                            G_TYPE_INVALID,
-                           G_TYPE_BOOLEAN,
-                           &done,
+                           G_TYPE_BOOLEAN, &done,
                            G_TYPE_INVALID)) {
 
     LOG(WARNING) << login_manager::kSessionManagerEmitLoginPromptReady
-                 << " failed: "
-                 << (error->message ? error->message : "Unknown Error.");
+                 << " failed: " << SCOPED_SAFE_MESSAGE(error);
 
   }
   return done;
 }
 
 extern "C"
+bool ChromeOSCheckRetrieveProperty(const char* name,
+                                   std::string* out_value,
+                                   std::vector<uint8>* signature) {
+  DCHECK(signature);
+  chromeos::dbus::Proxy proxy = CreateProxy();
+  chromeos::glib::ScopedError error;
+
+  GArray* sig;
+  gchar* value;
+
+  if (!::dbus_g_proxy_call(proxy.gproxy(),
+                           login_manager::kSessionManagerCheckWhitelist,
+                           &Resetter(&error).lvalue(),
+                           G_TYPE_STRING, name,
+                           G_TYPE_INVALID,
+                           G_TYPE_STRING, value,
+                           DBUS_TYPE_G_UCHAR_ARRAY, &sig,
+                           G_TYPE_INVALID)) {
+    LOG(WARNING) << login_manager::kSessionManagerCheckWhitelist << " failed: "
+                 << SCOPED_SAFE_MESSAGE(error);
+    return false;
+  }
+  bool rv = false;
+  signature->resize(sig->len);
+  if (signature->size() == sig->len) {
+    memcpy(&(signature->at(0)), static_cast<const void*>(sig->data), sig->len);
+    rv = true;
+  }
+  g_array_free(sig, false);
+  out_value->assign(value);
+  return rv;
+}
+
+extern "C"
 bool ChromeOSSetOwnerKey(const std::vector<uint8>& public_key_der) {
   chromeos::dbus::Proxy proxy = CreateProxy();
   chromeos::glib::ScopedError error;
 
   GArray* key_der = g_array_sized_new(FALSE, FALSE, 1, public_key_der.size());
   g_array_append_vals(key_der, &public_key_der[0], public_key_der.size());
 
   bool rv = true;
   if (!::dbus_g_proxy_call(proxy.gproxy(),
                            login_manager::kSessionManagerSetOwnerKey,
                            &Resetter(&error).lvalue(),
-                           DBUS_TYPE_G_UCHAR_ARRAY,
-                           key_der,
+                           DBUS_TYPE_G_UCHAR_ARRAY, key_der,
                            G_TYPE_INVALID,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << login_manager::kSessionManagerSetOwnerKey << " failed: "
-                 << (error->message ? error->message : "Unknown Error.");
+                 << SCOPED_SAFE_MESSAGE(error);
     rv = false;
   }
   g_array_free(key_der, TRUE);
   return rv;
 }
 
 extern "C"
 bool ChromeOSStartSession(const char* user_email,
                           const char* unique_id /* unused */) {
   chromeos::dbus::Proxy proxy = CreateProxy();
   gboolean done = false;
   chromeos::glib::ScopedError error;
 
   if (!::dbus_g_proxy_call(proxy.gproxy(),
                            login_manager::kSessionManagerStartSession,
                            &Resetter(&error).lvalue(),
-                           G_TYPE_STRING,
-                           user_email,
-                           G_TYPE_STRING,
-                           unique_id,
+                           G_TYPE_STRING, user_email,
+                           G_TYPE_STRING, unique_id,
                            G_TYPE_INVALID,
-                           G_TYPE_BOOLEAN,
-                           &done,
+                           G_TYPE_BOOLEAN, &done,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << login_manager::kSessionManagerStartSession << " failed: "
-                 << (error->message ? error->message : "Unknown Error.");
+                 << SCOPED_SAFE_MESSAGE(error);
   }
   return done;
 }
 
 extern "C"
 bool ChromeOSStopSession(const char* unique_id /* unused */) {
   chromeos::dbus::Proxy proxy = CreateProxy();
   gboolean done = false;
   chromeos::glib::ScopedError error;
 
   if (!::dbus_g_proxy_call(proxy.gproxy(),
                            login_manager::kSessionManagerStopSession,
                            &Resetter(&error).lvalue(),
-                           G_TYPE_STRING,
-                           unique_id,
+                           G_TYPE_STRING, unique_id,
                            G_TYPE_INVALID,
-                           G_TYPE_BOOLEAN,
-                           &done,
+                           G_TYPE_BOOLEAN, &done,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << login_manager::kSessionManagerStopSession << " failed: "
-                 << (error->message ? error->message : "Unknown Error.");
+                 << SCOPED_SAFE_MESSAGE(error);
   }
   return done;
 }
 
 extern "C"
 bool ChromeOSRestartJob(int pid, const char* command_line) {
   chromeos::dbus::Proxy proxy = CreateProxy();
   gboolean done = false;
   chromeos::glib::ScopedError error;
 
   if (!::dbus_g_proxy_call(proxy.gproxy(),
                            login_manager::kSessionManagerRestartJob,
                            &Resetter(&error).lvalue(),
-                           G_TYPE_INT,
-                           pid,
-                           G_TYPE_STRING,
-                           command_line,
+                           G_TYPE_INT, pid,
+                           G_TYPE_STRING, command_line,
                            G_TYPE_INVALID,
-                           G_TYPE_BOOLEAN,
-                           &done,
+                           G_TYPE_BOOLEAN, &done,
                            G_TYPE_INVALID)) {
     LOG(WARNING) << login_manager::kSessionManagerRestartJob << " failed: "
-                 << (error->message ? error->message : "Unknown Error.");
+                 << SCOPED_SAFE_MESSAGE(error);
   }
   return done;
 }
 
+extern "C"
+bool ChromeOSStoreProperty(const char* name,
+                           const char* value,
+                           const std::vector<uint8>& signature) {
+  chromeos::dbus::Proxy proxy = CreateProxy();
+  chromeos::glib::ScopedError error;
 
+  GArray* sig = g_array_sized_new(FALSE, FALSE, 1, signature.size());
+  g_array_append_vals(sig, &signature[0], signature.size());
 
+  bool rv = true;
+  if (!::dbus_g_proxy_call(proxy.gproxy(),
+                           login_manager::kSessionManagerStoreProperty,
+                           &Resetter(&error).lvalue(),
+                           G_TYPE_STRING, name,
+                           G_TYPE_STRING, value,
+                           DBUS_TYPE_G_UCHAR_ARRAY, sig,
+                           G_TYPE_INVALID,
+                           G_TYPE_INVALID)) {
+    LOG(WARNING) << login_manager::kSessionManagerStoreProperty << " failed: "
+                 << SCOPED_SAFE_MESSAGE(error);
+    rv = false;
+  }
+  g_array_free(sig, TRUE);
+  return rv;
+}
+
+namespace {
+bool WhitelistOpHelper(const char* op,
+                       const char* email,
+                       const std::vector<uint8>& signature) {
+  chromeos::dbus::Proxy proxy = CreateProxy();
+  chromeos::glib::ScopedError error;
+
+  GArray* sig = g_array_sized_new(FALSE, FALSE, 1, signature.size());
+  g_array_append_vals(sig, &signature[0], signature.size());
+
+  bool rv = true;
+  if (!::dbus_g_proxy_call(proxy.gproxy(),
+                           op,
+                           &Resetter(&error).lvalue(),
+                           G_TYPE_STRING, email,
+                           DBUS_TYPE_G_UCHAR_ARRAY, sig,
+                           G_TYPE_INVALID,
+                           G_TYPE_INVALID)) {
+    LOG(WARNING) << op << " failed: " << SCOPED_SAFE_MESSAGE(error);
+    rv = false;
+  }
+  g_array_free(sig, TRUE);
+  return rv;
+}
+}  // anonymous namespace
+
+extern "C"
+bool ChromeOSUnwhitelist(const char* email,
+                         const std::vector<uint8>& signature) {
+  return WhitelistOpHelper(login_manager::kSessionManagerUnwhitelist,
+                           email,
+                           signature);
+}
+
+extern "C"
+bool ChromeOSWhitelist(const char* email,
+                       const std::vector<uint8>& signature) {
+  return WhitelistOpHelper(login_manager::kSessionManagerWhitelist,
+                           email,
+                           signature);
+}
+
+namespace {
 #define SAFE_MESSAGE(e) (e.message ? e.message : "unknown error")
 
-namespace {
 bool IsSuccess(DBusMessage* message) {
   char* out_string = NULL;
   DBusError error;
   dbus_error_init (&error);
   bool unpack = dbus_message_get_args(message,
                                       &error,
                                       DBUS_TYPE_STRING,
                                       &out_string,
                                       DBUS_TYPE_INVALID);
   if (!unpack) {
@@ skipping 59 matching lines @@
 extern "C"
 void ChromeOSDisconnectSession(SessionConnection connection) {
   DBusConnection *bus = ::dbus_g_connection_get_connection(
       dbus::GetSystemBusConnection().g_connection());
   ::dbus_connection_remove_filter(bus, &Filter, connection);
   delete connection;
   LOG(INFO) << "Disconnected from session manager";
 }
 
 }  // namespace chromeos