Add two new entry points to the Chrome Frame DLL to allow for non-admin regis...

chrome_frame/chrome_tab.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.
 
 // chrome_tab.cc : Implementation of DLL Exports.
 
 // Include without path to make GYP build see it.
 #include "chrome_tab.h"  // NOLINT
 
 #include <atlsecurity.h>
@@ skipping 25 matching lines @@
 #include "chrome_frame/chrome_launcher_utils.h"
 #include "chrome_frame/chrome_protocol.h"
 #include "chrome_frame/module_utils.h"
 #include "chrome_frame/resource.h"
 #include "chrome_frame/utils.h"
 #include "googleurl/src/url_util.h"
 
 namespace {
 // This function has the side effect of initializing an unprotected
 // vector pointer inside GoogleUrl. If this is called during DLL loading,
-// it has the effect of avoiding an initializiation race on that pointer.
+// it has the effect of avoiding an initialization race on that pointer.
 // TODO(siggi): fix GoogleUrl.
 void InitGoogleUrl() {
   static const char kDummyUrl[] = "http://www.google.com";
 
   url_util::IsStandard(kDummyUrl,
                        url_parse::MakeRange(0, arraysize(kDummyUrl)));
 }
 }
 
 static const wchar_t kBhoRegistryPath[] =
@@ skipping 24 matching lines @@
 OBJECT_ENTRY_AUTO(__uuidof(ChromeProtocol), ChromeProtocol)
 
 
 // See comments in DllGetClassObject.
 LPFNGETCLASSOBJECT g_dll_get_class_object_redir_ptr = NULL;
 
 class ChromeTabModule : public CAtlDllModuleT<ChromeTabModule> {
  public:
   typedef CAtlDllModuleT<ChromeTabModule> ParentClass;
 
+  ChromeTabModule() : do_system_registration_(true) {}
+
   DECLARE_LIBID(LIBID_ChromeTabLib)
   DECLARE_REGISTRY_APPID_RESOURCEID(IDR_CHROMETAB,
                                     "{FD9B1B31-F4D8-436A-8F4F-D3C2E36733D3}")
 
   // Override to add our SYSTIME binary value to registry scripts.
   // See chrome_frame_activex.rgs for usage.
   virtual HRESULT AddCommonRGSReplacements(IRegistrarBase* registrar) throw() {
     HRESULT hr = ParentClass::AddCommonRGSReplacements(registrar);
 
     if (SUCCEEDED(hr)) {
@@ skipping 43 matching lines @@
       DCHECK(SUCCEEDED(hr));
     }
 
     if (SUCCEEDED(hr)) {
       // Add the filename of chrome_launcher.exe
       hr = registrar->AddReplacement(L"CHROME_LAUNCHER_APPNAME",
                                      chrome_launcher::kLauncherExeBaseName);
       DCHECK(SUCCEEDED(hr));
     }
 
+    if (SUCCEEDED(hr)) {
+      // Add the registry hive to use.
+      // Note: This is ugly as hell. I'd rather use the pMapEntries parameter
+      // to CAtlModule::UpdateRegistryFromResource, unfortunately we have a
+      // few components that are registered by calling their
+      // static T::UpdateRegistry() methods directly, which doesn't allow
+      // pMapEntries to be passed through :-(
+      if (do_system_registration_) {
+        hr = registrar->AddReplacement(L"HIVE", L"HKLM");
+      } else {
+        hr = registrar->AddReplacement(L"HIVE", L"HKCU");
+      }
+      DCHECK(SUCCEEDED(hr));
+    }
+
     return hr;
   }
+
+  // See comments in AddCommonRGSReplacements
+  bool do_system_registration_;
 };
 
 ChromeTabModule _AtlModule;
 
 base::AtExitManager* g_exit_manager = NULL;
-bool RegisterSecuredMimeHandler(bool enable);  // forward
+bool RegisterSecuredMimeHandler(bool enable, bool is_system);  // forward
 
 // DLL Entry Point
 extern "C" BOOL WINAPI DllMain(HINSTANCE instance,
                                DWORD reason,
                                LPVOID reserved) {
   UNREFERENCED_PARAMETER(instance);
   if (reason == DLL_PROCESS_ATTACH) {
 #ifndef NDEBUG
     // Silence traces from the ATL registrar to reduce the log noise.
     ATL::CTrace::s_trace.ChangeCategory(atlTraceRegistrar, 0,
@@ skipping 146 matching lines @@
   GCF_PROTOCOL        = 0x0004,
   BHO_CLSID           = 0x0008,
   BHO_REGISTRATION    = 0x0010,
   TYPELIB             = 0x0020,
 
   NPAPI_PLUGIN        = 0x1000,
 
   ALL                 = 0xFFFF
 };
 
-STDAPI CustomRegistration(UINT reg_flags, BOOL reg) {
+STDAPI CustomRegistration(UINT reg_flags, BOOL reg, bool is_system) {
   UINT flags = reg_flags;
 
   if (reg && (flags & (ACTIVEDOC | ACTIVEX)))
     flags |= (TYPELIB |GCF_PROTOCOL);
 
   HRESULT hr = S_OK;
 
+  // Set the flag that gets checked in AddCommonRGSReplacements before doing
+  // registration work.
+  _AtlModule.do_system_registration_ = is_system;
+
   if ((hr == S_OK) && (flags & ACTIVEDOC)) {
-    if (!RegisterSecuredMimeHandler(reg? true : false))
+    // Don't fail to unregister if we can't undo the secure mime
+    // handler registration. This was observed getting hit during
+    // uninstallation.
+    if (!RegisterSecuredMimeHandler(reg ? true : false, is_system) && reg)
       return E_FAIL;
     hr = ChromeActiveDocument::UpdateRegistry(reg);
   }
 
   if ((hr == S_OK) && (flags & ACTIVEX)) {
     // We have to call the static T::UpdateRegistry function instead of
     // _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_ACTIVEX, reg)
     // because there is specific OLEMISC replacement.
     hr = ChromeFrameActivex::UpdateRegistry(reg);
     // TODO(amit): Move elevation policy registration from ActiveX rgs
     // into a separate rgs.
     RefreshElevationPolicy();
   }
 
   if ((hr == S_OK) && (flags & GCF_PROTOCOL)) {
     hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEPROTOCOL, reg);
   }
 
   if ((hr == S_OK) && (flags & BHO_CLSID)) {
     hr = Bho::UpdateRegistry(reg);
   }
 
-  if ((hr == S_OK) && (flags & BHO_REGISTRATION)) {
+  if ((hr == S_OK) && (flags & BHO_REGISTRATION) && !is_system) {
     _AtlModule.UpdateRegistryFromResourceS(IDR_REGISTER_BHO, reg);
   }
 
   if ((hr == S_OK) && (flags & TYPELIB)) {
-    hr = (reg)? _AtlComModule.RegisterTypeLib():
-                _AtlComModule.UnRegisterTypeLib();
+    hr = (reg)?
+        UtilRegisterTypeLib(_AtlComModule.m_hInstTypeLib, NULL, !is_system) :
+        UtilUnRegisterTypeLib(_AtlComModule.m_hInstTypeLib, NULL, !is_system);
   }
 
   if ((hr == S_OK) && (flags & NPAPI_PLUGIN)) {
     hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_NPAPI, reg);
   }
 
   if (hr == S_OK) {
     hr = _AtlModule.UpdateRegistryAppId(reg);
   }
 
   return hr;
 }
 
 
 
 // DllRegisterServer - Adds entries to the system registry
 STDAPI DllRegisterServer() {
   UINT flags =  ACTIVEX | ACTIVEDOC | TYPELIB | GCF_PROTOCOL |
                 BHO_CLSID | BHO_REGISTRATION;
 
   if (UtilIsPersistentNPAPIMarkerSet()) {
     flags |= IDR_CHROMEFRAME_NPAPI;
   }
 
-  HRESULT hr = CustomRegistration(flags, TRUE);
+  HRESULT hr = CustomRegistration(flags, TRUE, true);
   if (SUCCEEDED(hr)) {
     SetupRunOnce();
   }
 
   return hr;
 }
 
 // DllUnregisterServer - Removes entries from the system registry
 STDAPI DllUnregisterServer() {
-  HRESULT hr = CustomRegistration(ALL, FALSE);
+  HRESULT hr = CustomRegistration(ALL, FALSE, true);
+  return hr;
+}
+
+// DllRegisterServer - Adds entries to the HKCU hive in the registry
+STDAPI DllRegisterUserServer() {
+  UINT flags =  ACTIVEX | ACTIVEDOC | TYPELIB | GCF_PROTOCOL | BHO_CLSID;
+
+  if (UtilIsPersistentNPAPIMarkerSet()) {
+    flags |= IDR_CHROMEFRAME_NPAPI;
+  }
+
+  HRESULT hr = CustomRegistration(flags, TRUE, false);
+  if (SUCCEEDED(hr)) {
+    SetupRunOnce();
+  }
+
+  return hr;
+}
+
+// DllRegisterServer - Removes entries from the HKCU hive in the registry.
+STDAPI DllUnregisterUserServer() {
+  HRESULT hr = CustomRegistration(ALL, FALSE, false);
   return hr;
 }
 
 // Registers the NPAPI plugin and sets the persistent marker that tells us
 // to re-register it through updates.
 STDAPI RegisterNPAPIPlugin() {
   HRESULT hr = _AtlModule.UpdateRegistryFromResourceS(IDR_CHROMEFRAME_NPAPI,
                                                       TRUE);
   if (SUCCEEDED(hr)) {
     if (!UtilChangePersistentNPAPIMarker(true)) {
@@ skipping 123 matching lines @@
     return user_;
   }
 
  private:
   CAccessToken token_;
   CTokenPrivileges take_ownership_;
   CTokenPrivileges restore_;
   CSid user_;
 };
 
-static bool SetOrDeleteMimeHandlerKey(bool set) {
+static bool SetOrDeleteMimeHandlerKey(bool set, HKEY root_key) {
   std::wstring key_name = kInternetSettings;
   key_name.append(L"\\Secure Mime Handlers");
-  RegKey key(HKEY_LOCAL_MACHINE, key_name.c_str(), KEY_READ | KEY_WRITE);
+  RegKey key(root_key, key_name.c_str(), KEY_READ | KEY_WRITE);
   if (!key.Valid())
     return false;
 
   bool result;
   if (set) {
     result = key.WriteValue(L"ChromeTab.ChromeActiveDocument", 1);
     result = key.WriteValue(L"ChromeTab.ChromeActiveDocument.1", 1) && result;
   } else {
     result = key.DeleteValue(L"ChromeTab.ChromeActiveDocument");
     result = key.DeleteValue(L"ChromeTab.ChromeActiveDocument.1") && result;
   }
 
   return result;
 }
 
-bool RegisterSecuredMimeHandler(bool enable) {
-  if (win_util::GetWinVersion() < win_util::WINVERSION_VISTA) {
-    return SetOrDeleteMimeHandlerKey(enable);
+bool RegisterSecuredMimeHandler(bool enable, bool is_system) {
+  if (!is_system) {
+    return SetOrDeleteMimeHandlerKey(enable, HKEY_CURRENT_USER);
+  } else if (win_util::GetWinVersion() < win_util::WINVERSION_VISTA) {
+    return SetOrDeleteMimeHandlerKey(enable, HKEY_LOCAL_MACHINE);
   }
 
   std::wstring mime_key = kInternetSettings;
   mime_key.append(L"\\Secure Mime Handlers");
   std::wstring backup_key = kInternetSettings;
   backup_key.append(L"\\__backup_SMH__");
   std::wstring object_name = L"MACHINE\\";
   object_name.append(mime_key);
 
   TokenWithPrivileges token_;
@@ skipping 13 matching lines @@
 
   backup.SaveSecurity(sd);
   bool result = false;
   // set new owner
   if (AtlSetOwnerSid(object_name.c_str(), SE_REGISTRY_KEY, token_.GetUser())) {
     // set new dacl
     CDacl new_dacl;
     sd.GetDacl(&new_dacl);
     new_dacl.AddAllowedAce(token_.GetUser(), GENERIC_WRITE | GENERIC_READ);
     if (AtlSetDacl(object_name.c_str(), SE_REGISTRY_KEY, new_dacl)) {
-      result = SetOrDeleteMimeHandlerKey(enable);
+      result = SetOrDeleteMimeHandlerKey(enable, HKEY_LOCAL_MACHINE);
     }
   }
 
   backup.RestoreSecurity(object_name.c_str());
   return result;
 }