Linux: make GNOME keyring password store able to use libgnome-keyring via dlopen.

chrome/browser/password_manager/password_store_gnome.cc

 // Copyright (c) 2010 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/password_store_gnome.h"
 
+#if defined(DLOPEN_GNOME_KEYRING)
+#include <dlfcn.h>
+#endif
+
+#include <map>
 #include <string>
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 
 using std::map;
 using std::string;
 using std::vector;
 using webkit_glue::PasswordForm;
 
+/* Many of the gnome_keyring_* functions use variable arguments, which makes
+ * them difficult if not impossible to wrap in C. Therefore, we want the
+ * actual uses below to either call the functions directly (if we are linking
+ * against libgnome-keyring), or call them via appropriately-typed function
+ * pointers (if we are dynamically loading libgnome-keyring).
+ *
+ * Thus, instead of making a wrapper class with two implementations, we use
+ * the preprocessor to rename the calls below in the dynamic load case, and
+ * provide a function to initialize a set of function pointers that have the
+ * alternate names. We also make sure the types are correct, since otherwise
+ * dynamic loading like this would leave us vulnerable to signature changes. */
+
+#if defined(DLOPEN_GNOME_KEYRING)
+
+namespace {
+
+gboolean (*wrap_gnome_keyring_is_available)();
+GnomeKeyringResult (*wrap_gnome_keyring_store_password_sync)(  // NOLINT
+    const GnomeKeyringPasswordSchema* schema, const gchar* keyring,
+    const gchar* display_name, const gchar* password, ...);
+GnomeKeyringResult (*wrap_gnome_keyring_delete_password_sync)(  // NOLINT
+    const GnomeKeyringPasswordSchema* schema, ...);
+GnomeKeyringResult (*wrap_gnome_keyring_find_itemsv_sync)(  // NOLINT
+    GnomeKeyringItemType type, GList** found, ...);
+const gchar* (*wrap_gnome_keyring_result_to_message)(GnomeKeyringResult res);
+void (*wrap_gnome_keyring_found_list_free)(GList* found_list);
+
+/* Cause the compiler to complain if the types of the above function pointers
+ * do not correspond to the types of the actual gnome_keyring_* functions. */
+#define GNOME_KEYRING_VERIFY_TYPE(name) \
+    typeof(&gnome_keyring_##name) name = wrap_gnome_keyring_##name; name = name
+
+inline void VerifyGnomeKeyringTypes() {
+  GNOME_KEYRING_VERIFY_TYPE(is_available);
+  GNOME_KEYRING_VERIFY_TYPE(store_password_sync);
+  GNOME_KEYRING_VERIFY_TYPE(delete_password_sync);
+  GNOME_KEYRING_VERIFY_TYPE(find_itemsv_sync);
+  GNOME_KEYRING_VERIFY_TYPE(result_to_message);
+  GNOME_KEYRING_VERIFY_TYPE(found_list_free);
+}
+#undef GNOME_KEYRING_VERIFY_TYPE
+
+/* Make it easy to initialize the function pointers above with a loop below. */
+#define GNOME_KEYRING_FUNCTION(name) \
+    {#name, reinterpret_cast<void**>(&wrap_##name)}
+const struct {
+  const char* name;
+  void** pointer;
+} gnome_keyring_functions[] = {
+    GNOME_KEYRING_FUNCTION(gnome_keyring_is_available),
+    GNOME_KEYRING_FUNCTION(gnome_keyring_store_password_sync),
+    GNOME_KEYRING_FUNCTION(gnome_keyring_delete_password_sync),
+    GNOME_KEYRING_FUNCTION(gnome_keyring_find_itemsv_sync),
+    GNOME_KEYRING_FUNCTION(gnome_keyring_result_to_message),
+    GNOME_KEYRING_FUNCTION(gnome_keyring_found_list_free),
+    {NULL, NULL}
+};
+#undef GNOME_KEYRING_FUNCTION
+
+/* Allow application code below to use the normal function names, but actually
+ * end up using the function pointers above instead. */
+#define gnome_keyring_is_available \
+    wrap_gnome_keyring_is_available
+#define gnome_keyring_store_password_sync \
+    wrap_gnome_keyring_store_password_sync
+#define gnome_keyring_delete_password_sync \
+    wrap_gnome_keyring_delete_password_sync
+#define gnome_keyring_find_itemsv_sync \
+    wrap_gnome_keyring_find_itemsv_sync
+#define gnome_keyring_result_to_message \
+    wrap_gnome_keyring_result_to_message
+#define gnome_keyring_found_list_free \
+    wrap_gnome_keyring_found_list_free
+
+/* Load the library and initialize the function pointers. */
+bool LoadGnomeKeyring() {
+  void* handle = dlopen("libgnome-keyring.so.0", RTLD_NOW | RTLD_GLOBAL);
+  if (!handle) {
+    LOG(INFO) << "Could not find libgnome-keyring.so.0";
+    return false;
+  }
+  for (size_t i = 0; gnome_keyring_functions[i].name; ++i) {
+    dlerror();
+    *gnome_keyring_functions[i].pointer =
+        dlsym(handle, gnome_keyring_functions[i].name);
+    const char* error = dlerror();
+    if (error) {
+      LOG(ERROR) << "Unable to load symbol " <<
+          gnome_keyring_functions[i].name << ": " << error;
+      dlclose(handle);
+      return false;
+    }
+  }
+  // We leak the library handle. That's OK: this function is called only once.
+  return true;
+}
+
+}  // namespace
+
+#else  // DLOPEN_GNOME_KEYRING
+
+namespace {
+
+bool LoadGnomeKeyring() {
+  return true;
+}
+
+}  // namespace
+
+#endif  // DLOPEN_GNOME_KEYRING
+
 #define GNOME_KEYRING_APPLICATION_CHROME "chrome"
 
 // Schema is analagous to the fields in PasswordForm.
 const GnomeKeyringPasswordSchema PasswordStoreGnome::kGnomeSchema = {
   GNOME_KEYRING_ITEM_GENERIC_SECRET, {
     { "origin_url", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "action_url", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "username_element", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "username_value", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "password_element", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
@@ skipping 12 matching lines @@
 
 PasswordStoreGnome::PasswordStoreGnome(LoginDatabase* login_db,
                                        Profile* profile,
                                        WebDataService* web_data_service) {
 }
 
 PasswordStoreGnome::~PasswordStoreGnome() {
 }
 
 bool PasswordStoreGnome::Init() {
-  return PasswordStore::Init() && gnome_keyring_is_available();
+  return PasswordStore::Init() &&
+         LoadGnomeKeyring() &&
+         gnome_keyring_is_available();
 }
 
 void PasswordStoreGnome::AddLoginImpl(const PasswordForm& form) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   AddLoginHelper(form, base::Time::Now());
 }
 
 void PasswordStoreGnome::UpdateLoginImpl(const PasswordForm& form) {
   // Based on LoginDatabase::UpdateLogin(), we search for forms to update by
   // origin_url, username_element, username_value, password_element, and
@@ skipping 231 matching lines @@
     form->password_value = UTF8ToUTF16(string(password));
     form->submit_element =
         UTF8ToUTF16(string(string_attribute_map["submit_element"]));
     form->signon_realm = string_attribute_map["signon_realm"];
     form->ssl_valid = uint_attribute_map["ssl_valid"];
     form->preferred = uint_attribute_map["preferred"];
     string date = string_attribute_map["date_created"];
     int64 date_created = 0;
     bool date_ok = StringToInt64(date, &date_created);
     DCHECK(date_ok);
-    DCHECK(date_created != 0);
+    DCHECK_NE(date_created, 0);
     form->date_created = base::Time::FromTimeT(date_created);
     form->blacklisted_by_user = uint_attribute_map["blacklisted_by_user"];
     form->scheme = static_cast<PasswordForm::Scheme>(
         uint_attribute_map["scheme"]);
 
     forms->push_back(form);
 
     element = g_list_next(element);
   }
   gnome_keyring_found_list_free(found);
 }