The Tor Browser: uriloader/exthandler/win/nsMIMEInfoWin.cpp@6474c204b198 (annotated)

uriloader/exthandler/win/nsMIMEInfoWin.cpp@6474c204b198 (annotated)

uriloader/exthandler/win/nsMIMEInfoWin.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsArrayEnumerator.h"
 #include "nsCOMArray.h"
 #include "nsIFile.h"
 #include "nsIVariant.h"
 #include "nsMIMEInfoWin.h"
 #include "nsNetUtil.h"
 #include <windows.h>
 #include <shellapi.h>
 #include "nsAutoPtr.h"
 #include "nsIMutableArray.h"
 #include "nsTArray.h"
 #include "shlobj.h"
 #include "windows.h"
 #include "nsIWindowsRegKey.h"
 #include "nsIProcess.h"
 #include "nsOSHelperAppService.h"
 #include "nsUnicharUtils.h"
 #include "nsITextToSubURI.h"
 #define RUNDLL32_EXE L"\\rundll32.exe"
 NS_IMPL_ISUPPORTS_INHERITED(nsMIMEInfoWin, nsMIMEInfoBase, nsIPropertyBag)
 nsMIMEInfoWin::~nsMIMEInfoWin()
 {
 }
 nsresult
 nsMIMEInfoWin::LaunchDefaultWithFile(nsIFile* aFile)
 {
   // Launch the file, unless it is an executable.
   bool executable = true;
   aFile->IsExecutable(&executable);
   if (executable)
     return NS_ERROR_FAILURE;
   return aFile->Launch();
 }
 NS_IMETHODIMP
 nsMIMEInfoWin::LaunchWithFile(nsIFile* aFile)
 {
   nsresult rv;
   // it doesn't make any sense to call this on protocol handlers
   NS_ASSERTION(mClass == eMIMEInfo,
                "nsMIMEInfoBase should have mClass == eMIMEInfo");
   if (mPreferredAction == useSystemDefault) {
     return LaunchDefaultWithFile(aFile);
   }
   if (mPreferredAction == useHelperApp) {
     if (!mPreferredApplication)
       return NS_ERROR_FILE_NOT_FOUND;
     // at the moment, we only know how to hand files off to local handlers
     nsCOMPtr<nsILocalHandlerApp> localHandler =
       do_QueryInterface(mPreferredApplication, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> executable;
     rv = localHandler->GetExecutable(getter_AddRefs(executable));
     NS_ENSURE_SUCCESS(rv, rv);
     nsAutoString path;
     aFile->GetPath(path);
     // Deal with local dll based handlers
     nsCString filename;
     executable->GetNativeLeafName(filename);
     if (filename.Length() > 4) {
       nsCString extension(Substring(filename, filename.Length() - 4, 4));
       if (extension.LowerCaseEqualsLiteral(".dll")) {
         nsAutoString args;
         // executable is rundll32, everything else is a list of parameters,
         // including the dll handler.
         if (!GetDllLaunchInfo(executable, aFile, args, false))
           return NS_ERROR_INVALID_ARG;
         WCHAR rundll32Path[MAX_PATH + sizeof(RUNDLL32_EXE) / sizeof(WCHAR) + 1] = {L'\0'};
         if (!GetSystemDirectoryW(rundll32Path, MAX_PATH)) {
           return NS_ERROR_FILE_NOT_FOUND;
         }
         lstrcatW(rundll32Path, RUNDLL32_EXE);
         SHELLEXECUTEINFOW seinfo;
         memset(&seinfo, 0, sizeof(seinfo));
         seinfo.cbSize = sizeof(SHELLEXECUTEINFOW);
         seinfo.fMask  = 0;
         seinfo.hwnd   = nullptr;
         seinfo.lpVerb = nullptr;
         seinfo.lpFile = rundll32Path;
         seinfo.lpParameters =  args.get();
         seinfo.lpDirectory  = nullptr;
         seinfo.nShow  = SW_SHOWNORMAL;
         if (ShellExecuteExW(&seinfo))
           return NS_OK;
         switch ((LONG_PTR)seinfo.hInstApp) {
           case 0:
           case SE_ERR_OOM:
             return NS_ERROR_OUT_OF_MEMORY;
           case SE_ERR_ACCESSDENIED:
             return NS_ERROR_FILE_ACCESS_DENIED;
           case SE_ERR_ASSOCINCOMPLETE:
           case SE_ERR_NOASSOC:
             return NS_ERROR_UNEXPECTED;
           case SE_ERR_DDEBUSY:
           case SE_ERR_DDEFAIL:
           case SE_ERR_DDETIMEOUT:
             return NS_ERROR_NOT_AVAILABLE;
           case SE_ERR_DLLNOTFOUND:
             return NS_ERROR_FAILURE;
           case SE_ERR_SHARE:
             return NS_ERROR_FILE_IS_LOCKED;
           default:
             switch(GetLastError()) {
               case ERROR_FILE_NOT_FOUND:
                 return NS_ERROR_FILE_NOT_FOUND;
               case ERROR_PATH_NOT_FOUND:
                 return NS_ERROR_FILE_UNRECOGNIZED_PATH;
               case ERROR_BAD_FORMAT:
                 return NS_ERROR_FILE_CORRUPTED;
             }
         }
         return NS_ERROR_FILE_EXECUTION_FAILED;
       }
     }
     return LaunchWithIProcess(executable, path);
   }
   return NS_ERROR_INVALID_ARG;
 }
 NS_IMETHODIMP
 nsMIMEInfoWin::GetHasDefaultHandler(bool * _retval)
 {
   // We have a default application if we have a description
   // We can ShellExecute anything; however, callers are probably interested if
   // there is really an application associated with this type of file
   *_retval = !mDefaultAppDescription.IsEmpty();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsMIMEInfoWin::GetEnumerator(nsISimpleEnumerator* *_retval)
 {
   nsCOMArray<nsIVariant> properties;
   nsCOMPtr<nsIVariant> variant;
   GetProperty(NS_LITERAL_STRING("defaultApplicationIconURL"), getter_AddRefs(variant));
   if (variant)
     properties.AppendObject(variant);
   GetProperty(NS_LITERAL_STRING("customApplicationIconURL"), getter_AddRefs(variant));
   if (variant)
     properties.AppendObject(variant);
   return NS_NewArrayEnumerator(_retval, properties);
 }
 static nsresult GetIconURLVariant(nsIFile* aApplication, nsIVariant* *_retval)
 {
   nsresult rv = CallCreateInstance("@mozilla.org/variant;1", _retval);
   if (NS_FAILED(rv))
     return rv;
   nsAutoCString fileURLSpec;
   NS_GetURLSpecFromFile(aApplication, fileURLSpec);
   nsAutoCString iconURLSpec; iconURLSpec.AssignLiteral("moz-icon://");
   iconURLSpec += fileURLSpec;
   nsCOMPtr<nsIWritableVariant> writable(do_QueryInterface(*_retval));
   writable->SetAsAUTF8String(iconURLSpec);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsMIMEInfoWin::GetProperty(const nsAString& aName, nsIVariant* *_retval)
 {
   nsresult rv;
   if (mDefaultApplication && aName.EqualsLiteral(PROPERTY_DEFAULT_APP_ICON_URL)) {
     rv = GetIconURLVariant(mDefaultApplication, _retval);
     NS_ENSURE_SUCCESS(rv, rv);
   } else if (mPreferredApplication &&
              aName.EqualsLiteral(PROPERTY_CUSTOM_APP_ICON_URL)) {
     nsCOMPtr<nsILocalHandlerApp> localHandler =
       do_QueryInterface(mPreferredApplication, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> executable;
     rv = localHandler->GetExecutable(getter_AddRefs(executable));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = GetIconURLVariant(executable, _retval);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }
 // this implementation was pretty much copied verbatime from
 // Tony Robinson's code in nsExternalProtocolWin.cpp
 nsresult
 nsMIMEInfoWin::LoadUriInternal(nsIURI * aURL)
 {
   nsresult rv = NS_OK;
   // 1. Find the default app for this protocol
   // 2. Set up the command line
   // 3. Launch the app.
   // For now, we'll just cheat essentially, check for the command line
   // then just call ShellExecute()!
   if (aURL)
   {
     // extract the url spec from the url
     nsAutoCString urlSpec;
     aURL->GetAsciiSpec(urlSpec);
     // Unescape non-ASCII characters in the URL
     nsAutoCString urlCharset;
     nsAutoString utf16Spec;
     rv = aURL->GetOriginCharset(urlCharset);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsITextToSubURI> textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = textToSubURI->UnEscapeNonAsciiURI(urlCharset, urlSpec, utf16Spec);
     NS_ENSURE_SUCCESS(rv, rv);
     static const wchar_t cmdVerb[] = L"open";
     SHELLEXECUTEINFOW sinfo;
     memset(&sinfo, 0, sizeof(sinfo));
     sinfo.cbSize   = sizeof(sinfo);
     sinfo.fMask    = SEE_MASK_FLAG_DDEWAIT |
       SEE_MASK_FLAG_NO_UI;
     sinfo.hwnd     = nullptr;
     sinfo.lpVerb   = (LPWSTR)&cmdVerb;
     sinfo.nShow    = SW_SHOWNORMAL;
     LPITEMIDLIST pidl = nullptr;
     SFGAOF sfgao;
     // Bug 394974
     if (SUCCEEDED(SHParseDisplayName(utf16Spec.get(), nullptr,
                                      &pidl, 0, &sfgao))) {
       sinfo.lpIDList = pidl;
       sinfo.fMask |= SEE_MASK_INVOKEIDLIST;
     } else {
       // SHParseDisplayName failed. Bailing out as work around for
       // Microsoft Security Bulletin MS07-061
       rv = NS_ERROR_FAILURE;
     }
     if (NS_SUCCEEDED(rv)) {
       BOOL result = ShellExecuteExW(&sinfo);
       if (!result || ((LONG_PTR)sinfo.hInstApp) < 32)
         rv = NS_ERROR_FAILURE;
     }
     if (pidl)
       CoTaskMemFree(pidl);
   }
   return rv;
 }
 // Given a path to a local file, return its nsILocalHandlerApp instance.
 bool nsMIMEInfoWin::GetLocalHandlerApp(const nsAString& aCommandHandler,
                                          nsCOMPtr<nsILocalHandlerApp>& aApp)
 {
   nsCOMPtr<nsIFile> locfile;
   nsresult rv =
     NS_NewLocalFile(aCommandHandler, true, getter_AddRefs(locfile));
   if (NS_FAILED(rv))
     return false;
   aApp = do_CreateInstance("@mozilla.org/uriloader/local-handler-app;1");
   if (!aApp)
     return false;
   aApp->SetExecutable(locfile);
   return true;
 }
 // Return the cleaned up file path associated with a command verb
 // located in root/Applications.
 bool nsMIMEInfoWin::GetAppsVerbCommandHandler(const nsAString& appExeName,
                                                 nsAString& applicationPath,
                                                 bool edit)
 {
   nsCOMPtr<nsIWindowsRegKey> appKey =
     do_CreateInstance("@mozilla.org/windows-registry-key;1");
   if (!appKey)
     return false;
   // HKEY_CLASSES_ROOT\Applications\iexplore.exe
   nsAutoString applicationsPath;
   applicationsPath.AppendLiteral("Applications\\");
   applicationsPath.Append(appExeName);
   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                              applicationsPath,
                              nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_FAILED(rv))
     return false;
   // Check for the NoOpenWith flag, if it exists
   uint32_t value;
   if (NS_SUCCEEDED(appKey->ReadIntValue(
       NS_LITERAL_STRING("NoOpenWith"), &value)) &&
       value == 1)
     return false;
   nsAutoString dummy;
   if (NS_SUCCEEDED(appKey->ReadStringValue(
         NS_LITERAL_STRING("NoOpenWith"), dummy)))
     return false;
   appKey->Close();
   // HKEY_CLASSES_ROOT\Applications\iexplore.exe\shell\open\command
   applicationsPath.AssignLiteral("Applications\\");
   applicationsPath.Append(appExeName);
   if (!edit)
     applicationsPath.AppendLiteral("\\shell\\open\\command");
   else
     applicationsPath.AppendLiteral("\\shell\\edit\\command");
   rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                     applicationsPath,
                     nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_FAILED(rv))
     return false;
   nsAutoString appFilesystemCommand;
   if (NS_SUCCEEDED(appKey->ReadStringValue(EmptyString(),
                                            appFilesystemCommand))) {
     // Expand environment vars, clean up any misc.
     if (!nsOSHelperAppService::CleanupCmdHandlerPath(appFilesystemCommand))
       return false;
     applicationPath = appFilesystemCommand;
     return true;
   }
   return false;
 }
 // Return a fully populated command string based on
 // passing information. Used in launchWithFile to trace
 // back to the full handler path based on the dll.
 // (dll, targetfile, return args, open/edit)
 bool nsMIMEInfoWin::GetDllLaunchInfo(nsIFile * aDll,
                                        nsIFile * aFile,
                                        nsAString& args,
                                        bool edit)
 {
   if (!aDll || !aFile)
     return false;
   nsString appExeName;
   aDll->GetLeafName(appExeName);
   nsCOMPtr<nsIWindowsRegKey> appKey =
     do_CreateInstance("@mozilla.org/windows-registry-key;1");
   if (!appKey)
     return false;
   // HKEY_CLASSES_ROOT\Applications\iexplore.exe
   nsAutoString applicationsPath;
   applicationsPath.AppendLiteral("Applications\\");
   applicationsPath.Append(appExeName);
   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                              applicationsPath,
                              nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_FAILED(rv))
     return false;
   // Check for the NoOpenWith flag, if it exists
   uint32_t value;
   rv = appKey->ReadIntValue(NS_LITERAL_STRING("NoOpenWith"), &value);
   if (NS_SUCCEEDED(rv) && value == 1)
     return false;
   nsAutoString dummy;
   if (NS_SUCCEEDED(appKey->ReadStringValue(NS_LITERAL_STRING("NoOpenWith"),
                                            dummy)))
     return false;
   appKey->Close();
   // HKEY_CLASSES_ROOT\Applications\iexplore.exe\shell\open\command
   applicationsPath.AssignLiteral("Applications\\");
   applicationsPath.Append(appExeName);
   if (!edit)
     applicationsPath.AppendLiteral("\\shell\\open\\command");
   else
     applicationsPath.AppendLiteral("\\shell\\edit\\command");
   rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                     applicationsPath,
                     nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_FAILED(rv))
     return false;
   nsAutoString appFilesystemCommand;
   if (NS_SUCCEEDED(appKey->ReadStringValue(EmptyString(),
                                            appFilesystemCommand))) {
     // Replace embedded environment variables.
     uint32_t bufLength =
       ::ExpandEnvironmentStringsW(appFilesystemCommand.get(),
                                   L"", 0);
     if (bufLength == 0) // Error
       return false;
     nsAutoArrayPtr<wchar_t> destination(new wchar_t[bufLength]);
     if (!destination)
       return false;
     if (!::ExpandEnvironmentStringsW(appFilesystemCommand.get(),
                                      destination,
                                      bufLength))
       return false;
     appFilesystemCommand = static_cast<const wchar_t*>(destination);
     // C:\Windows\System32\rundll32.exe "C:\Program Files\Windows
     // Photo Gallery\PhotoViewer.dll", ImageView_Fullscreen %1
     nsAutoString params;
     NS_NAMED_LITERAL_STRING(rundllSegment, "rundll32.exe ");
     int32_t index = appFilesystemCommand.Find(rundllSegment);
     if (index > kNotFound) {
       params.Append(Substring(appFilesystemCommand,
                     index + rundllSegment.Length()));
     } else {
       params.Append(appFilesystemCommand);
     }
     // check to make sure we have a %1 and fill it
     NS_NAMED_LITERAL_STRING(percentOneParam, "%1");
     index = params.Find(percentOneParam);
     if (index == kNotFound) // no parameter
       return false;
     nsString target;
     aFile->GetTarget(target);
     params.Replace(index, 2, target);
     args = params;
     return true;
   }
   return false;
 }
 // Return the cleaned up file path associated with a progid command
 // verb located in root.
 bool nsMIMEInfoWin::GetProgIDVerbCommandHandler(const nsAString& appProgIDName,
                                                   nsAString& applicationPath,
                                                   bool edit)
 {
   nsCOMPtr<nsIWindowsRegKey> appKey =
     do_CreateInstance("@mozilla.org/windows-registry-key;1");
   if (!appKey)
     return false;
   nsAutoString appProgId(appProgIDName);
   // HKEY_CLASSES_ROOT\Windows.XPSReachViewer\shell\open\command
   if (!edit)
     appProgId.AppendLiteral("\\shell\\open\\command");
   else
     appProgId.AppendLiteral("\\shell\\edit\\command");
   nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                              appProgId,
                              nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_FAILED(rv))
     return false;
   nsAutoString appFilesystemCommand;
   if (NS_SUCCEEDED(appKey->ReadStringValue(EmptyString(), appFilesystemCommand))) {
     // Expand environment vars, clean up any misc.
     if (!nsOSHelperAppService::CleanupCmdHandlerPath(appFilesystemCommand))
       return false;
     applicationPath = appFilesystemCommand;
     return true;
   }
   return false;
 }
 // Helper routine used in tracking app lists. Converts path
 // entries to lower case and stores them in the trackList array.
 void nsMIMEInfoWin::ProcessPath(nsCOMPtr<nsIMutableArray>& appList,
                                 nsTArray<nsString>& trackList,
                                 const nsAString& appFilesystemCommand)
 {
   nsAutoString lower(appFilesystemCommand);
   ToLowerCase(lower);
   // Don't include firefox.exe in the list
   WCHAR exe[MAX_PATH+1];
   uint32_t len = GetModuleFileNameW(nullptr, exe, MAX_PATH);
   if (len < MAX_PATH && len != 0) {
     uint32_t index = lower.Find(exe);
     if (index != -1)
       return;
   }
   nsCOMPtr<nsILocalHandlerApp> aApp;
   if (!GetLocalHandlerApp(appFilesystemCommand, aApp))
     return;
   // Save in our main tracking arrays
   appList->AppendElement(aApp, false);
   trackList.AppendElement(lower);
 }
 // Helper routine that handles a compare between a path
 // and an array of paths.
 static bool IsPathInList(nsAString& appPath,
                            nsTArray<nsString>& trackList)
 {
   // trackList data is always lowercase, see ProcessPath
   // above.
   nsAutoString tmp(appPath);
   ToLowerCase(tmp);
   for (uint32_t i = 0; i < trackList.Length(); i++) {
     if (tmp.Equals(trackList[i]))
       return true;
   }
   return false;
 }
 /**
  * Returns a list of nsILocalHandlerApp objects containing local
  * handlers associated with this mimeinfo. Implemented per
  * platform using information in this object to generate the
  * best list. Typically used for an "open with" style user
  * option.
  *
  * @return nsIArray of nsILocalHandlerApp
  */
 NS_IMETHODIMP
 nsMIMEInfoWin::GetPossibleLocalHandlers(nsIArray **_retval)
 {
   nsresult rv;
   *_retval = nullptr;
   nsCOMPtr<nsIMutableArray> appList =
     do_CreateInstance("@mozilla.org/array;1");
   if (!appList)
     return NS_ERROR_FAILURE;
   nsTArray<nsString> trackList;
   nsAutoCString fileExt;
   GetPrimaryExtension(fileExt);
   nsCOMPtr<nsIWindowsRegKey> regKey =
     do_CreateInstance("@mozilla.org/windows-registry-key;1");
   if (!regKey)
     return NS_ERROR_FAILURE;
   nsCOMPtr<nsIWindowsRegKey> appKey =
     do_CreateInstance("@mozilla.org/windows-registry-key;1");
   if (!appKey)
     return NS_ERROR_FAILURE;
   nsAutoString workingRegistryPath;
   bool extKnown = false;
   if (fileExt.IsEmpty()) {
     extKnown = true;
     // Mime type discovery is possible in some cases, through
     // HKEY_CLASSES_ROOT\MIME\Database\Content Type, however, a number
     // of file extensions related to mime type are simply not defined,
     // (application/rss+xml & application/atom+xml are good examples)
     // in which case we can only provide a generic list.
     nsAutoCString mimeType;
     GetMIMEType(mimeType);
     if (!mimeType.IsEmpty()) {
       workingRegistryPath.AppendLiteral("MIME\\Database\\Content Type\\");
       workingRegistryPath.Append(NS_ConvertASCIItoUTF16(mimeType));
       rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                         workingRegistryPath,
                         nsIWindowsRegKey::ACCESS_QUERY_VALUE);
       if(NS_SUCCEEDED(rv)) {
         nsAutoString mimeFileExt;
         if (NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), mimeFileExt))) {
           CopyUTF16toUTF8(mimeFileExt, fileExt);
           extKnown = false;
         }
       }
     }
   }
   nsAutoString fileExtToUse;
   if (fileExt.First() != '.')
     fileExtToUse = char16_t('.');
   fileExtToUse.Append(NS_ConvertUTF8toUTF16(fileExt));
   // Note, the order in which these occur has an effect on the
   // validity of the resulting display list.
   if (!extKnown) {
     // 1) Get the default handler if it exists
     workingRegistryPath = fileExtToUse;
     rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                       workingRegistryPath,
                       nsIWindowsRegKey::ACCESS_QUERY_VALUE);
     if (NS_SUCCEEDED(rv)) {
       nsAutoString appProgId;
       if (NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), appProgId))) {
         // Bug 358297 - ignore the embedded internet explorer handler
         if (appProgId != NS_LITERAL_STRING("XPSViewer.Document")) {
           nsAutoString appFilesystemCommand;
           if (GetProgIDVerbCommandHandler(appProgId,
                                           appFilesystemCommand,
                                           false) &&
               !IsPathInList(appFilesystemCommand, trackList)) {
             ProcessPath(appList, trackList, appFilesystemCommand);
           }
         }
       }
       regKey->Close();
     }
     // 2) list HKEY_CLASSES_ROOT\.ext\OpenWithList
     workingRegistryPath = fileExtToUse;
     workingRegistryPath.AppendLiteral("\\OpenWithList");
     rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                       workingRegistryPath,
                       nsIWindowsRegKey::ACCESS_QUERY_VALUE);
     if (NS_SUCCEEDED(rv)) {
       uint32_t count = 0;
       if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
         for (uint32_t index = 0; index < count; index++) {
           nsAutoString appName;
           if (NS_FAILED(regKey->GetValueName(index, appName)))
             continue;
           // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
           nsAutoString appFilesystemCommand;
           if (!GetAppsVerbCommandHandler(appName,
                                          appFilesystemCommand,
                                          false) ||
               IsPathInList(appFilesystemCommand, trackList))
             continue;
           ProcessPath(appList, trackList, appFilesystemCommand);
         }
       }
       regKey->Close();
     }
     // 3) List HKEY_CLASSES_ROOT\.ext\OpenWithProgids, with the
     // different step of resolving the progids for the command handler.
     workingRegistryPath = fileExtToUse;
     workingRegistryPath.AppendLiteral("\\OpenWithProgids");
     rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                       workingRegistryPath,
                       nsIWindowsRegKey::ACCESS_QUERY_VALUE);
     if (NS_SUCCEEDED(rv)) {
       uint32_t count = 0;
       if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
         for (uint32_t index = 0; index < count; index++) {
           // HKEY_CLASSES_ROOT\.ext\OpenWithProgids\Windows.XPSReachViewer
           nsAutoString appProgId;
           if (NS_FAILED(regKey->GetValueName(index, appProgId)))
             continue;
           nsAutoString appFilesystemCommand;
           if (!GetProgIDVerbCommandHandler(appProgId,
                                            appFilesystemCommand,
                                            false) ||
               IsPathInList(appFilesystemCommand, trackList))
             continue;
           ProcessPath(appList, trackList, appFilesystemCommand);
         }
       }
       regKey->Close();
     }
     // 4) Add any non configured applications located in the MRU list
     // HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion
     // \Explorer\FileExts\.ext\OpenWithList
     workingRegistryPath =
       NS_LITERAL_STRING("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\");
     workingRegistryPath += fileExtToUse;
     workingRegistryPath.AppendLiteral("\\OpenWithList");
     rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
                       workingRegistryPath,
                       nsIWindowsRegKey::ACCESS_QUERY_VALUE);
     if (NS_SUCCEEDED(rv)) {
       uint32_t count = 0;
       if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
         for (uint32_t index = 0; index < count; index++) {
           nsAutoString appName, appValue;
           if (NS_FAILED(regKey->GetValueName(index, appName)))
             continue;
           if (appName.EqualsLiteral("MRUList"))
             continue;
           if (NS_FAILED(regKey->ReadStringValue(appName, appValue)))
             continue;
           // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
           nsAutoString appFilesystemCommand;
           if (!GetAppsVerbCommandHandler(appValue,
                                          appFilesystemCommand,
                                          false) ||
               IsPathInList(appFilesystemCommand, trackList))
             continue;
           ProcessPath(appList, trackList, appFilesystemCommand);
         }
       }
     }
     // 5) Add any non configured progids in the MRU list, with the
     // different step of resolving the progids for the command handler.
     // HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion
     // \Explorer\FileExts\.ext\OpenWithProgids
     workingRegistryPath =
       NS_LITERAL_STRING("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\");
     workingRegistryPath += fileExtToUse;
     workingRegistryPath.AppendLiteral("\\OpenWithProgids");
     regKey->Open(nsIWindowsRegKey::ROOT_KEY_CURRENT_USER,
                  workingRegistryPath,
                  nsIWindowsRegKey::ACCESS_QUERY_VALUE);
     if (NS_SUCCEEDED(rv)) {
       uint32_t count = 0;
       if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
         for (uint32_t index = 0; index < count; index++) {
           nsAutoString appIndex, appProgId;
           if (NS_FAILED(regKey->GetValueName(index, appProgId)))
             continue;
           nsAutoString appFilesystemCommand;
           if (!GetProgIDVerbCommandHandler(appProgId,
                                            appFilesystemCommand,
                                            false) ||
               IsPathInList(appFilesystemCommand, trackList))
             continue;
           ProcessPath(appList, trackList, appFilesystemCommand);
         }
       }
       regKey->Close();
     }
     // 6) Check the perceived type value, and use this to lookup the perceivedtype
     // open with list.
     // http://msdn2.microsoft.com/en-us/library/aa969373.aspx
     workingRegistryPath = fileExtToUse;
     regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                  workingRegistryPath,
                  nsIWindowsRegKey::ACCESS_QUERY_VALUE);
     if (NS_SUCCEEDED(rv)) {
       nsAutoString perceivedType;
       rv = regKey->ReadStringValue(NS_LITERAL_STRING("PerceivedType"),
                                    perceivedType);
       if (NS_SUCCEEDED(rv)) {
         nsAutoString openWithListPath(NS_LITERAL_STRING("SystemFileAssociations\\"));
         openWithListPath.Append(perceivedType); // no period
         openWithListPath.Append(NS_LITERAL_STRING("\\OpenWithList"));
         nsresult rv = appKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                                    openWithListPath,
                                    nsIWindowsRegKey::ACCESS_QUERY_VALUE);
         if (NS_SUCCEEDED(rv)) {
           uint32_t count = 0;
           if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
             for (uint32_t index = 0; index < count; index++) {
               nsAutoString appName;
               if (NS_FAILED(regKey->GetValueName(index, appName)))
                 continue;
               // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
               nsAutoString appFilesystemCommand;
               if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand,
                                              false) ||
                   IsPathInList(appFilesystemCommand, trackList))
                 continue;
               ProcessPath(appList, trackList, appFilesystemCommand);
             }
           }
         }
       }
     }
   } // extKnown == false
   // 7) list global HKEY_CLASSES_ROOT\*\OpenWithList
   // Listing general purpose handlers, not specific to a mime type or file extension
   workingRegistryPath = NS_LITERAL_STRING("*\\OpenWithList");
   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                     workingRegistryPath,
                     nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_SUCCEEDED(rv)) {
     uint32_t count = 0;
     if (NS_SUCCEEDED(regKey->GetValueCount(&count)) && count > 0) {
       for (uint32_t index = 0; index < count; index++) {
         nsAutoString appName;
         if (NS_FAILED(regKey->GetValueName(index, appName)))
           continue;
         // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
         nsAutoString appFilesystemCommand;
         if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand,
                                        false) ||
             IsPathInList(appFilesystemCommand, trackList))
           continue;
         ProcessPath(appList, trackList, appFilesystemCommand);
       }
     }
     regKey->Close();
   }
   // 8) General application's list - not file extension specific on windows
   workingRegistryPath = NS_LITERAL_STRING("Applications");
   rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT,
                     workingRegistryPath,
                     nsIWindowsRegKey::ACCESS_ENUMERATE_SUB_KEYS|
                     nsIWindowsRegKey::ACCESS_QUERY_VALUE);
   if (NS_SUCCEEDED(rv)) {
     uint32_t count = 0;
     if (NS_SUCCEEDED(regKey->GetChildCount(&count)) && count > 0) {
       for (uint32_t index = 0; index < count; index++) {
         nsAutoString appName;
         if (NS_FAILED(regKey->GetChildName(index, appName)))
           continue;
         // HKEY_CLASSES_ROOT\Applications\firefox.exe = "path params"
         nsAutoString appFilesystemCommand;
         if (!GetAppsVerbCommandHandler(appName, appFilesystemCommand,
                                        false) ||
             IsPathInList(appFilesystemCommand, trackList))
           continue;
         ProcessPath(appList, trackList, appFilesystemCommand);
       }
     }
   }
   // Return to the caller
   *_retval = appList;
   NS_ADDREF(*_retval);
   return NS_OK;
 }

The Tor Browser / annotate

uriloader/exthandler/win/nsMIMEInfoWin.cpp@6474c204b198 (annotated)

uriloader/exthandler/win/nsMIMEInfoWin.cpp